前言

在开发flutter或android项目，选择用Android stuido是比较方便的，在git的可视化使用上，Android studio已经非常方便了，但是还是有很多的小伙伴，依旧用其他工具来管理git。那么今天我就来详细的介绍一下 Android stuido的git使用与操作。

一、基本认知

git是采用分布式版本库机制。

工作区

项目目录下的文件可以称之为工作区

暂存区

增加文件，执行add操作则是把文件添加到暂存区

基本操作

git add 是将文件放到暂缓区
git commit 则是把文件添加到本地仓库
git push 则是提交到远程仓库
git status 是查看现有版本库中的文件状态

head指针

head表示的是当前版本，并不是任何分支的最新版本

二、Android studio中的git

文件样式与对应关系

文件1是git忽略文件
文件2是与本地分支版本一致
文件3是咱为提交到本地分支，并做了修改

假如文件是红色的样子，表示并没提交到暂存区

界面与操作

1. commit 提交到本地分支 （基本操作，不做说明）


2. add 添加到暂存区 （基本操作，不做说明）


3. .git/info/exclude (添加到 忽略文件，是为了让文件脱离git管理，不会上传到git仓库)


4. Annotate with Git Blame (显示每行代码的作者，如下图)

5. show diff （故名思义differences 差别）
6. compare with reversion（与某个版本比较）
7. compare with branch（与某个分支比较）
8. show history （查看历史）
9. show current revision （显示当前行最新修订历史版本、提示）
10. Rollback.. 在没有提交到本地库之前，丢弃工作区内容。
11. push.. 推到线上分支
12. pull.. 线上拉到本地并合并
13. fetch 线上拉到本地
14. merge.. 选择分支进行合并
15. rebase.. 选择分支进行合并，如有有合并冲突，会提示整理为一条commit直线
16. branches.. 创建分支与查看分支（这块下面快捷操作具体介绍）
17. new branch 会按照当前本地提交版本，来创建新的分支
18. new tag 给某一次提交增加个可识别的名字
19. reset HEAD
注意：Git中，用HEAD表示当前版本

有三个选项
Mixed：参数为默认值，暂存区的内容和工作区的内容都在工作区，提交上的都会还原到工作区
Soft：工作区的内容依旧在工作区，暂存区的内容还在暂存区（不被git管理的文件会变为新增文件）
Hard：工作区和暂存区的内容全部丢失（需要谨慎操作，一步就啥也木有了）

to commit 选择你要还原的commit号
20. stash changes..
git中如果本地有文件改动未提交、且该文件和服务器最新版本有冲突，pull更新会提示错误，无法更新：要么先commit自己的改动然后再通过pull拉取代码，stash的好处是可以先将你的改动暂存到本地仓库中，随时可以取出来再用，但是不用担心下次push到服务器时，把不想提交的改动也push到服务器上，因为Stash Changes的内容不参与commit和push。
21. unstash changes

View：查看
Drop：删除
Clear：清理
pop stash：移除stash
reinstate index
22. manager remote
查看git remote内容

右下角快捷操作

merge into current 合并到当前分支
rebase current onto selected 合并到当前rebase模式
chechout and rebase onto current 切换分支，并将分支合并到当前切换的分支

git面板快捷操作

compact references view 简洁引用视图
简洁引用：

align references to left 将引用向左对齐
引用左右对齐配置：

Show tag names 显示标签名称
设置是否显示标签：

Show long Edges 显示长线

Turn Intellisort On 打开intelli 排序
incase of merge show incoming commits first (directly below merge commit)
在合并的情况下，首先显示传入的提交 直接合并在下边

关键词含义

n：数据规模

时间复杂度

算法运行过程中所耗费的时间。

空间复杂度

算法运行过程中临时占用存储空间的大小。例如：O(1)表示所需空间大小为常量，与数据量n无关。

稳定性含义

• 稳定：在排序之前，如果两个数相等，那么排序之后，这两个数的先后顺序不变。如排序前，a=b，a在b的前面；那么排序后，a依旧在b的前面。


• 不稳定：在排序之前，如果两个数相等，那么排序之后，这两个数的先后顺序改变。如排序前，a=b，a在b的前面；那么排序后，a在b的后面。

冒泡排序

原理步骤

1. 比较相邻的两个数，如果前面的数大于后面的数，就交换这两个数。


2. 相邻的最前一对数和最后一对数都要进行比较，这样最后一个数就是最大的数。


3. 每个元素重复以上步骤，除了最后一个数。


4. 重复1-3的步骤。

代码实现

private static int[] bubbleSort(int array[]) {

    if (array.length == 0) {      

       return array;    

    }

    // 第1个for循环相当于步骤4    

    for (int i = 0; i < array.length; i++) {

        // 第2个for循环相当于步骤3        

        // array.length -1 是因为后面有j+1，先-1是为了避免数组越界        

        // array.length -1 - i，之所以减i（已经排过1遍，就减1；如果已经排过i遍，就减i），是为了不比较排在最后且已经排好序的数，相当于步骤3的最后一句话        

        for (int j = 0; j < array.length - 1 - i; j++) {

            int temp;            

            // if判断语句相当于步骤1和步骤2            

            if (array[j] > array[j + 1]) {                

                temp = array[j];                

                array[j] = array[j + 1];                

                array[j + 1] = temp;            

            }        

        }    

     }

     return array;

    }

快速排序

原理步骤

1. 取数组中的一个数作为key。


2. 从后往前获取数组的数，并将其与key进行对比。


3. 如果其中一个数小于key，那么就将这个数和key交换位置。


4. 交换位置之后，从前往后获取数组的数，并将其与key对比。


5. 如果其中一个数大于key，那么就将这个数和key交换位置。


6. 重复2-5的过程，直到key前面的数都比key小，key后面的数都比key大，这样就完成一次排序。


7. 以key为中心，对key前面的数组和后面的数组执行1-6的过程，直到数组完全有序。

代码实现

private static void quickSort(int[] array, int left, int right) {

    if (left >= right) {      

        return;    

    }

    int i, j, x;    

    i = left;    

    j = right;    

    x = array[i];

    while (i < j) {        

        while (i < j && array[j] > x) {            

            j--;        

        }        

        if (i < j) {            

            array[i] = array[j];            

            i++;        

        }        

        while (i < j && array[i] < x) {            

            i++;        

        }        

        if (i < j) {            

            array[j] = array[i];            

            j--;        

        }    

    }    

    // j=i    

    array[j] = x;    

    quickSort(array, j + 1, right);    

    quickSort(array, left, j - 1);

    }

插入排序

原理

• 每一步将一个待排序的数插入到已经排好序的序列中，直到插完所有数据。

代码实现

private static int[] insertSort(int array[]) {          

        if (array.length == 0) {                

            return array;          

        }                

        int i, j, temp;          

        // 注释①          

        for (i = 1; i < array.length; i++) {              

            // 注释②                  

            temp = array[i];                  

            // 注释③                  

            for (j = i - 1; j >= 0 && array[j] > temp; j--) {                    

                // 注释④                        

                array[j+1] = array[j];                  

            }                  

            // 注释⑤                  

            array[j+1] = temp;           

        }                  

        return array;

}

注释①

• 默认数组第一个数（i=0的数）是有序的。

注释②

• array[i]为待排序的数据。

注释③

• array[i]前面的数与array[i]进行排序。

注释④

• arr[j]相当于前数，arr[j+1]相当于后数。


• 如果前数比后数大，交换位置，前数放到后数的位置。

注释⑤

• 如果for循环内前数和后数交换了位置（即前数挪到了后数的位置），那么注释⑤处的代码，就是将后数挪到前数的位置，实现交换。


• 如果缺少注释⑤处的代码，那么前数的位置就会“空缺”，或者说依旧是原来的数，并没有实现交换。


• 如果for循环内两数并没有交换（即跳出了for循环），此时j=i-1,j+1=i,与tmp=a[i]效果是一样的。

选择排序

原理步骤：

1. 从未排序的序列中取出最小（最大）的数，放入已排序序列的初始位置；


2. 继续从未排序序列剩余的数中取最小（最大）的数，放在已排序序列的末尾。


3. 持续执行②的步骤，直到整个序列有序。

代码实现

private static int[] selectionSort(int[] array) {    

    if (array.length == 0) {        

        return array;    

    }    

    for (int i = 0; i < array.length; i++) {        

        int min = i;        

        for (int j = i; j < array.length; j++) {            

            // 从未排序序列中获取最小值            

            if (array[j] < array[min]) {                

                min = j;            

            }        

        }        

        // 把获取的最小值放入已排序序列的末尾（此时i代表末尾的索引）        

        int temp = array[i];        

        array[i] = array[min];        

        array[min] = temp;    

    }    

    return array;

}

总结1：

• 插入排序和选择排序可以划为一类排序算法来理解和掌握。


• 它们都具有相同点——将数组划分为已排序、未排序两个部分，然后将未排序的部分逐个迁移到已排序的部分，最终使整个数组实现完全有序。


• 而不同点在于从未排序合入到已排序的方式。插入排序会将未排序的数据在已排序的数组中执行直接插入排序；而选择排序会先在未排序的数组中选出最小值，当这个值合入到已排序的数组中时，不需要再进行比较，直接放到已排序数组的末尾就可以了。

希尔排序

原理步骤

• 把一个数组按增量进行分组。（增量指分组数量）


• 每个分组采用直接插入排序进行排序。


• 然后减小增量，每个分组的元素数目增加，直到增量为1，整个文件变为一组，算法结束。

代码实现

private static int[] shellSort(int[] array) {    

    if (array.length == 0) {        

        return array;    

    }

    // gap为分组数目    

    for (int gap = array.length / 2; gap > 0; gap = gap / 2) {    

        // i为索引,对每组进行排序        

        for (int i = gap; i < array.length; i++) {        

        // j为临时变量            

        int j = i;            

        // 分组内元素的个数可能大于2个，因此使用while循环            

        while (j - gap >= 0 && array[j] < array[j - gap]) {            

            // 在同一个分组中，如果后面的数（j）比前面的（j-gap）大，就交换它们的位置                

            int temp = array[j];                

            array[j] = array[j - gap];                

            array[j - gap] = temp;

            j = j - gap;            

        }        

        }    

     }    

     return array;

}

归并排序

原理步骤

• 将一个数组分为左子数组和右子数组，两个子数组的长度为n/2（n为数组的总长度）。


• 在两个子数组间进行归并排序（即每个子数组划分为更小的左子数组和右子数组，直到无法再分时，对两个数组进行排序，详情见代码）。


• 将两个有序的子数组合并为一个最终的有序数组。

代码实现

private static int[] mergeSort(int[] array) {    

    // 数组只有一个元素或没有元素，直接返回。    

    // 脱离递归的条件    

    if (array.length < 2) {        

        return array;    

    }    

    // 将数组分为两半，分别进行排序    

    int[] left = Arrays.copyOfRange(array, 0, array.length / 2);    

    int[] right = Arrays.copyOfRange(array, array.length / 2, array.length);    

    return merge(mergeSort(left),mergeSort(right));

}



    /** 

      * 将左数组与右数组合并为一个有序数组 

      * 注意：此时左数组、右数组已经有序 

      * @param left 

      * @param right 

      * @return 

      */

    private static int[] merge(int[] left, int[] right) {    

        // 合并后的有序数组    

        int[] result = new int[left.length + right.length];    

        for (int index = 0, i = 0, j = 0; index < result.length; index++) {        

        if (i >= left.length) {            

            // 如果左数组已经遍历结束，就插入右数组的值            

            result[index] = right[j];            

            j++;        

        } else if (j >= right.length) {            

            // 如果右数组已经遍历结束，就插入左数组的值            

            result[index] = left[i];            

            i++;        

        } else if (left[i] > right[j]) {            

            // 左数组与右数组的值同时存在时，就对两数进行比较            

            // 如果右数组的值比较小，就插入右数组的值。            

            result[index] = right[j];            

            j++;        

        } else {            

            // 左数组与右数组的值同时存在时，就对两数进行比较            

            // 如果左数组的值比较小，就插入左数组的值。            

            result[index] = left[i];            

            i++;        

        }    

    }    

    return result;

}

总结2：

• 希尔排序和归并排序可以划为一类排序算法来理解和掌握。


• 它们都具有相同点——先将整个大的数组分为不同的小组，然后对小组的数据进行排序，最终将所有小组合并为一个有序数组。


• 而不同点在于分组后的排序方式不同。希尔排序会针对一个小组内的数据执行直接插入排序，而归并排序会直接将两个小组合并为一个有序数组。

排序算法进阶

• 以上冒泡、快排、插入、选择、希尔、归并这六种排序算法都是基础的排序算法，很多中等、困难难度的算法题一般都是基于上述算法进行解决。（比如《合并两个有序数组》其实就是归并算法的某一部分）


• 推荐《最小K个数》、《数组中的第K个最大元素》作为进阶学习。（它们都是基于快排实现，类似的变形有最大K个数等）

Android小萌新今天在做项目的时候遇到一个小问题，来记录一下~

在做一个登录界面的时候，想使用DataBinding+ViewModel+LiveData

但是怎样让ViewModel拿到EditText控件的实例呢？一开始想到把DataBinding对象从Activity传入ViewModel，后来发现不可行，因为DataBinding在初始化的时候需要传入owner参数，而这个owner参数传的是Activity本身，也就是说DataBinding持有了Activity的引用，这时候如果把DataBinding传给ViewModel不就成了ViewModel持有Activity的引用了吗？内存泄漏！不行！

解决办法是通过DataBinding双向绑定（View可以操作数据，数据变化时通知View），让EditText的内容直接对应到ViewModel中的LiveData上，这样的话在输入框输入的同时LiveData也在随时变化。

一些收获的经验：

1. @={}和@{}

我发现EditText的text属性要使用@={...}而不是像TextView直接使用@{...}来和Livedata绑定，多出来的这个"="我个人认为是TextView和LiveData绑定仅仅只是get数据，而EditText和数据绑定需要get和实时set数据，所以"="可以理解为赋值

<EditText

        ...

        android:text="@={viewModel.inputAccount}"

        ... />

        

<EditText

        ...

        android:text="@={viewModel.inputVerify}"

        ... />



<Button

        ...

        android:onClick="@{(v)->viewModel.onLogin()}"

        ... />

2. 为什么在账号EditText输入一个数，getInputAccount()会被调用两次呢？

public class TemporaryLoginViewModel extends ViewModel {



    private static final String TAG = "TemporaryLoginViewModel";

    MutableLiveData<String> mInputAccount;

    MutableLiveData<String> mInputVerify;



    public MutableLiveData<String> getInputAccount() {

        // TODO:为什么EditText输入一个数，getInputAccount()会调用两次？

        Log.d(TAG, "getInputAccount: Entrance");

        //双检锁

        if (mInputAccount == null)

            synchronized (TemporaryLoginViewModel.class) {

                if (mInputAccount == null)

                    mInputAccount = new MutableLiveData<>();

            }

        //只是TextView展示的话可以返回不可变的LiveData，这里因为是EditText所以只能返回可变的MutableLivedata

        return mInputAccount;

    }



    public MutableLiveData<String> getInputVerify() {

        ...

    }



    public void onLogin() {

        Log.d(TAG, "onLogin: 账号：" + mInputAccount.getValue() + "  验证码：" + mInputVerify.getValue());

    }

}

这就要进入源码去看一眼了，在getInputAccount()上选择findUsages
发现有两处地方调用了它

第一处在一个回调方法的onChange()中，我们打个断点查看虚拟机栈的栈帧，在第一次执行到断点的时候，虚拟机栈是这样的：

onChange()内部是这样的：

也就是说你在输入框里打字使得EditText数据改变的时候，首先回调到onChange()中，在这个onChange()中通过getInputAccount()得到LiveData再给它set一个字符串值

第二处是在executeBindings()中，这个方法是什么时候执行呢？我们让程序继续执行，在下一次执行到断点的时候，虚拟机栈是这样的：

可以看到在第二次执行到断点的时候，程序从executeBindings()方法中企图调用getInputAccount()

继续向下追踪，就可以看到这样的一个描述

意思是当View所绑定的数据发生变更的时候，执行此方法

总结

走到这里就很清晰了，整个流程是首先在输入框中输入，当监听到输入后先回调onChange()，在onChange()中通过getInputAccount()得到LiveData，然后修改了LiveData的值；LiveData一但修改，就会重新执行executeBindings()，所以又会调用一次getInputAccount()

到现在就明白了为什么ViewModel中的getInputAccount()会被执行两次啦~

3. getInputAccount()只能返回MutableLiveData

第三个问题也很好理解，为了安全嘛，我一开始试图让getInputAccount()返回一个不可修改的LiveData，然后报错了！

从第二个问题的分析不难看出，人家内部还要给get到的LiveData执行setValue()呢，所以返回的LiveData一定是可变的MutableLiveData啦~

4. 程序启动时会额外执行一次getInputAccount()

当我查看Activity中的setLifecycleOwner(this)方法时发现它设置了一个LifecycleObserver

进入这个Observer

它观察到Activity处于onStart状态的时候会调用executePendingBindings()

进入executePendingBindings()瞅瞅

又要去调用executeBindingsInternal()，这不就是我们上面在虚拟机栈中看到的调用步骤吗？也就是说在Activity在onStart状态时会执行一次getInputAccount()

卡顿优化思路

• 卡顿原理分析


• 卡顿流程flow


• 卡顿概貌分析


• 卡顿实际数据收集


• 卡顿优化细节

卡顿原因

屏幕刷新频率高于帧率,帧率低于30

每帧执行流程

Choreographer中维护着四个队列callbacks

• 输入事件队列


• 动画队列


• 绘制队列


• app添加的frameCallback队列

vysnc信号由SurfaceFlinger中创建HWC触发，通过bitTube技术发送到目标进程，目标进程vsync信号到来时，执行Choreographer中的onVsync回调，最终触发doFrame顺序执行这四条队列中的消息。

bitTube

在linux/unix中，bitTube技术成为socketPair，它通过dup技术复制socket的句柄，传递到目标进程，开启socket的全双工通信。

句柄

在内核中，每一个进程都有一个私有的“打开文件表”，这个表是一个指针数组，每一个元素都指向一个内核的打开文件对象。而fd，就是这个表的下标。当用户打开一个文件时，内核会在内部生成一个打开文件对象，并在这个表里找到一个空项，让这一项指向生成的打开文件对象，并返回这一项的下标作为fd.

ui优化

• 多余Bg移除


• ui重叠区域优化 cancas.clipRect


• 减少ui层级


• 耗时方法分析与优化


• 多样式布局采用单一rv处理

webview优化

webview的加载流程

webiew初始化

• 目的是初始化并启动浏览器内核。


• 提前初始化webview并隐藏 优化126ms

webview 单独进程

• 单独进程 activity配置


• 单独进程的交互 webview.addJavascriptInterface(),webview.evalute()

安全性

• addJavaScriptInterface添加的java对象的方法，需要添加@addJavascriptInterface注解，避免xss攻击

卡顿收集策略

开发卡顿检测StrictMode

private void initStrictMode() {

    if (isDebug()) {

        StrictMode.setThreadPolicy(new StrictMode.ThreadPolicy.Builder()

                .detectCustomSlowCalls() //API等级11，使用StrictMode.noteSlowCode

                .detectDiskReads()

                .detectDiskWrites()

                .detectNetwork() // or .detectAll() for all detectable problems

                .penaltyDialog() //弹出违规提示对话框

                .penaltyLog() //在Logcat 中打印违规异常信息

                .penaltyFlashScreen() //API等级11

                .build());

        StrictMode.setVmPolicy(new StrictMode.VmPolicy.Builder()

                .detectLeakedSqlLiteObjects()

                .detectLeakedClosableObjects() //API等级11

                .penaltyLog()

                .penaltyDeath()

                .build());

    }

}

线下卡顿检测

• adb shell dumpsys gfxinfo [packagename]

Applications Graphics Acceleration Info:

Uptime: 205237819 Realtime: 436545102



** Graphics info for pid 5842 [xxxx] **



Stats since: 198741999784549ns

Total frames rendered: 653

Janky frames: 157 (24.04%)

50th percentile: 9ms

90th percentile: 34ms

95th percentile: 53ms

99th percentile: 200ms

Number Missed Vsync: 46

Number High input latency: 268

Number Slow UI thread: 76

Number Slow bitmap uploads: 3

Number Slow issue draw commands: 8

Number Frame deadline missed: 92

• 通过gpu绘制条形柱分析

条形柱共分为8种颜色，绿色和蓝色部分是异步应用能够优化的部分。包括其他处理 - 输入 - 动画 - travel

BlockCanary检测卡顿

在ActivityThread.main中的Looper大循环中，Looper.looponce会不断从消息队列中取出消息派发出去,并在前后通过logging打印了两个日志，我们通过设置自定义的logger，在两部分日志的时间差与30ms做对比，如果超过30ms，认为是卡顿。

logging.println(">>>>> Dispatching to " + msg.target + " "

                    + msg.callback + ": " + msg.what);

msg.target.dispatchMessage(msg);

logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);

卡顿分析信息收集

• Debug.startMethodTracing 收集具体的卡顿方法


• 查看trace文件 根据bottomup分析具体的耗时方法


• 火焰图，横轴是调用方法耗时，纵轴是调用深度


• 调用图，调用链以及方法耗时

线上卡顿分析与收集

在ActivityThread.main中的Looper大循环中，Looper.looponce会不断从消息队列中取出消息派发出去,并在前后通过logging打印了两个日志，我们通过设置自定义的logger，在两部分日志的时间差与30ms做对比，如果超过30ms，认为是卡顿。将主线程堆栈信息写入到缓存文件并异步发送到日志后台。

常见的卡顿问题

sharepreference

• 首次读取写入会loadxml到内存


• sp文件修改是全量读写的


• commit异步写入，通过CountdownLatch阻塞等待结果


• apply延迟100ms写入，无返回结果


• 主线程ANR，sp的修改会先体现在内存中，然后往QueueWorker中加入磁盘异步写数据的任务，但是会在Activity.onResume以及Service.onstartCommand等方法中增加waitToFinish等待磁盘写入完成的代码。


• 解决方案使用MMKV


• 尽量拆分小的xml

主线程操作文件

主线程网络操作

写在前面

首先祝大家新年快乐，开工大吉。

最新刚换了工作，大部分精力还是放到新工作上面，所以这次还是先给大家带来一个小而实用的库：Silhouette。另外，考虑到Kotlin越来越普及，作者在开发过程中也切实感受到Kotlin相较于Java带来的便利，后续的IM系列文章及项目考虑用Kotlin重写，而且考虑到由于工作业务需求过多可能出现断更的情况，所以打算一次性写完再放出来，避免大家学习不方便。

废话不多说，直接开始吧。

Silhouette是什么？

Silhouette意为“剪影”，取名并没有特别的含义，只是单纯地觉得意境较美。例如上一篇文章Shine——更简单的Android网络请求库封装的网络请求库：Shine即意为“闪耀”，也没有特别的含义，只是作者认为开源库起名较难，特意找一些比较优美的单词。

Silhouette是一系列基于GradientDrawable及StateListDrawable封装的组件集合，主要用于实现在Android Layout XML中直接支持Shape/Selector等功能。

我们都知道在Android开发中，不同的TextView及Button各种样式（形状、背景色、描边、圆角、渐变等）的传统实现方式是在drawable文件夹中编写各种shape/selector等文件，这种方式至少会存在以下几种弊端：

1. shape/selector文件过多，项目体积增大；


2. shape/selector文件命名困难，命名规范时往往会存在功能重复的文件；


3. 功能存在局限性：例如gradient渐变色。传统shape方式只支持三种颜色过渡(startColor/centerColor/endColor)，如果设计稿存在四种以上颜色渐变，shape gradient无能为力。再比如TextView在常态和按下态需要同时改变背景色及文字颜色时，传统方式只能在代码中动态设置等。


4. 开发效率低；


5. 难以维护等；

综上所述，我们迫切需要一个库来解决以上问题，Silhouette正具备这些能力。接下来，我们来具体看看Silhouette能做什么吧。

Silhouette能做什么？

上面说到Silhouette是一系列组件集合，具体包含以下组件：

• 
  

  SleTextButton
  
  基于AppCompatTextView封装；
  
  具备定义各种样式（形状、背景色、描边、圆角、渐变等）的能力 ；
  
  具备不同状态（常态、按下态、不可点击态）下文字颜色指定等。

  
  


• 
  

  SleImageButton
  
  基于ShapeableImageView封装；
  
  通过指定sle_ib_type属性使ImageView支持按下态遮罩层、透明度改变、自定义图片，同时支持CheckBox功能；
  
  通过指定sle_ib_style属性使ImageView支持Normal、圆角、圆形等形状。

  
  


• 
  

  SleConstraintLayout
  
  基于ConstraintLayout封装；
  
  具备定义各种样式（形状、背景色、描边、圆角、渐变等）的功能。

  
  


• 
  

  SleRelativeLayout
  
  基于RelativeLayout封装；
  
  具备定义各种样式（形状、背景色、描边、圆角、渐变等）的功能。

  
  


• 
  

  SleLinearLayout
  
  基于LinearLayout封装；
  
  具备定义各种样式（形状、背景色、描边、圆角、渐变等）的功能。

  
  


• 
  

  SleFrameLayout
  
  基于FrameLayout封装；
  
  具备定义各种样式（形状、背景色、描边、圆角、渐变等）的功能。

  
  

设计、封装思路及原理

• 
  

  项目结构
  
  com.freddy.silhouette

  
  
  
  
  • config（配置相关，存放全局注解及公共常量、默认值等）
  
  
  • ext（kotlin扩展相关，可选择用或不用）
  
  
  • utils（工具类相关，可选择用或不用）
  
  
  • widget（控件相关）
    
    
    
    • button
    
    
    • layout
    
    
    
    
  
  
  
  

  由此可见，项目结构非常简单，所以Silhouette也是一个比较轻量级的库。

  
  


• 
  

  封装思路及原理
  
  由于该库非常简单，实际上就是根据Shape/Selector进行自定义属性，从而利用GradientDrawable及StateListDrawable提供的API进行封装，不存在什么难度，在此就不展开讲了。

  
  

  下面贴一下代码片段，基本上几个组件的实现原理都大同小异，都是利用GradientDrawable及StateListDrawable实现组件的Shape及Selector功能：

  
  

private fun init() {

    val normalDrawable =

        getDrawable(normalBackgroundColor, normalStrokeColor, normalGradientColors)

    var pressedDrawable: GradientDrawable? = null

    var disabledDrawable: GradientDrawable? = null

    var selectedDrawable: GradientDrawable? = null

    when (type) {

        TYPE_MASK -> {

            pressedDrawable = getDrawable(

                normalBackgroundColor,

                normalStrokeColor,

                normalGradientColors

            ).apply {

                colorFilter =

                    PorterDuffColorFilter(maskBackgroundColor, PorterDuff.Mode.SRC_ATOP)

            }

            disabledDrawable =

                getDrawable(disabledBackgroundColor, disabledBackgroundColor)

        }

        TYPE_SELECTOR -> {

            pressedDrawable =

                getDrawable(pressedBackgroundColor, pressedStrokeColor, pressedGradientColors)

            disabledDrawable = getDrawable(

                disabledBackgroundColor,

                disabledStrokeColor,

                disabledGradientColors

            )

        }

    }

    selectedDrawable = getDrawable(

        selectedBackgroundColor,

        selectedStrokeColor,

        selectedGradientColors

    )

    setTextColor(normalTextColor)

    background = StateListDrawable().apply {

        if (type != TYPE_NONE) {

            addState(intArrayOf(android.R.attr.state_pressed), pressedDrawable)

        }

        addState(intArrayOf(-android.R.attr.state_enabled), disabledDrawable)

        addState(intArrayOf(android.R.attr.state_selected), selectedDrawable)

        addState(intArrayOf(), normalDrawable)

    }

  

    setOnTouchListener(this)

}

  

private fun getDrawable(

    backgroundColor: Int,

    strokeColor: Int,

    gradientColors: IntArray? = null

): GradientDrawable {

    // 背景色相关

    val drawable = GradientDrawable()

    setupColor(drawable, backgroundColor)

  

    // 形状相关

    (drawable.mutate() as GradientDrawable).shape = shape

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {

        drawable.innerRadius = innerRadius

        if (innerRadiusRatio > 0f) {

            drawable.innerRadiusRatio = innerRadiusRatio

        }

        drawable.thickness = thickness

        if (thicknessRatio > 0f) {

            drawable.thicknessRatio = thicknessRatio

        }

    }

  

    // 描边相关

    if (strokeColor != 0) {

        (drawable.mutate() as GradientDrawable).setStroke(

            strokeWidth,

            strokeColor,

            dashWidth,

            dashGap

        )

    }

  

    // 圆角相关

    setupCornersRadius(

        drawable,

        cornersRadius,

        cornersTopLeftRadius,

        cornersTopRightRadius,

        cornersBottomRightRadius,

        cornersBottomLeftRadius

    )

  

    // 渐变相关

    (drawable.mutate() as GradientDrawable).gradientType = gradientType

    if (gradientCenterX != 0.0f || gradientCenterY != 0.0f) {

        (drawable.mutate() as GradientDrawable).setGradientCenter(

            gradientCenterX,

            gradientCenterY

        )

    }

    gradientColors?.let { colors ->

        (drawable.mutate() as GradientDrawable).colors = colors

    }

    var orientation: GradientDrawable.Orientation? = null

    when (gradientOrientation) {

        GRADIENT_ORIENTATION_TOP_BOTTOM -> {

            orientation = GradientDrawable.Orientation.TOP_BOTTOM

        }

        GRADIENT_ORIENTATION_TR_BL -> {

            orientation = GradientDrawable.Orientation.TR_BL

        }

        GRADIENT_ORIENTATION_RIGHT_LEFT -> {

            orientation = GradientDrawable.Orientation.RIGHT_LEFT

        }

        GRADIENT_ORIENTATION_BR_TL -> {

            orientation = GradientDrawable.Orientation.BR_TL

        }

        GRADIENT_ORIENTATION_BOTTOM_TOP -> {

            orientation = GradientDrawable.Orientation.BOTTOM_TOP

        }

        GRADIENT_ORIENTATION_BL_TR -> {

            orientation = GradientDrawable.Orientation.BL_TR

        }

        GRADIENT_ORIENTATION_LEFT_RIGHT -> {

            orientation = GradientDrawable.Orientation.LEFT_RIGHT

        }

        GRADIENT_ORIENTATION_TL_BR -> {

            drawable.orientation = GradientDrawable.Orientation.TL_BR

        }

    }

    orientation?.apply {

        (drawable.mutate() as GradientDrawable).orientation = this

    }

    return drawable

}

感兴趣的同学可以到官方文档了解GradientDrawable及StateListDrawable的原理。

自定义属性列表

自定义属性分为通用属性和特有属性。

• 
  

  通用属性

  
  
  
  
  • 类型
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  

  属性名称	类型	说明	备注
  sle_type	enum	类型 mask：遮罩 selector：自定义样式 none：无	默认值：mask 默认的mask为90%透明度黑色，可通过sle_maskBackgroundColors属性设置 若不指定为selector，则自定义样式无效

  
  
  
  
  • 形状相关
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  

  属性名称	类型	说明	备注
  sle_shape	enum	形状 rectangle：矩形 oval：椭圆形 line：线性形状 ring：环形	默认值：rectangle
  sle_innerRadius	dimension|reference	尺寸，内环的半径	shape="ring"可用
  sle_innerRadiusRatio	float	以环的宽度比率来表示内环的半径	shape="ring"可用
  sle_thickness	dimension|reference	尺寸，环的厚度	shape="ring"可用
  sle_thicknessRatio	float	以环的宽度比率来表示环的厚度	shape="ring"可用

  
  
  
  
  • 背景色相关
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  

  属性名称	类型	说明	备注
  sle_normalBackgroundColor	color|reference	常态背景颜色	/
  sle_pressedBackgroundColor	color|reference	按下态背景颜色	/
  sle_disabledBackgroundColor	color|reference	不可点击态背景颜色	默认值：#CCCCCC
  sle_selectedBackgroundColor	color|reference	选中态背景颜色	/

  
  
  
  
  • 描边相关
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  

  属性名称	类型	说明	备注
  sle_normalStrokeColor	color|reference	常态描边颜色	/
  sle_pressedStrokeColor	color|reference	按下态描边颜色	/
  sle_disabledStrokeColor	color|reference	不可点击态描边颜色	/
  sle_selectedStrokeColor	color|reference	选中态描边颜色	/
  sle_strokeWidth	dimension|reference	描边宽度	/
  sle_dashWidth	dimension|reference	虚线宽度	/
  sle_dashGap	dimension|reference	虚线间隔	/

  
  
  
  
  • 圆角相关
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  

  属性名称	类型	说明	备注
  sle_cornersRadius	dimension|reference	总圆角半径	/
  sle_cornersTopLeftRadius	dimension|reference	左上角圆角半径	/
  sle_cornersTopRightRadius	dimension|reference	右上角圆角半径	/
  sle_cornersBottomLeftRadius	dimension|reference	左下角圆角半径	/
  sle_cornersBottomRightRadius	dimension|reference	右下角圆角半径	/

  
  
  
  
  • 渐变相关
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  

  属性名称	类型	说明	备注
  sle_normalGradientColors	reference	常态渐变背景色	支持在res/array下定义数组实现多个颜色渐变
  sle_pressedGradientColors	reference	按下态渐变背景色	支持在res/array下定义数组实现多个颜色渐变
  sle_disabledGradientColors	reference	不可点击态渐变背景色	支持在res/array下定义数组实现多个颜色渐变
  sle_selectedGradientColors	reference	选中态渐变背景色	支持在res/array下定义数组实现多个颜色渐变
  sle_gradientOrientation	enum	渐变方向 TOP_BOTTOM：从上到下 TR_BL：从右上到左下 RIGHT_LEFT：从右到左 BR_TL：从右下到左上 BOTTOM_TOP：从下到上 BL_TR：从左下到右上 LEFT_RIGHT：从左到右 TL_BR：从左上到右下	/
  sle_gradientType	enum	渐变类型 linear：线性渐变 radial：圆形渐变，起始颜色从gradientCenterX、gradientCenterY点开始 sweep：A sweeping line gradient	/
  sle_gradientCenterX	float	渐变中心放射点x坐标	注意，这里的坐标是整个背景的百分比的点，并不是确切点，0.2就是20%的点
  sle_gradientCenterY	float	渐变中心放射点y坐标	注意，这里的坐标是整个背景的百分比的点，并不是确切点，0.2就是20%的点
  sle_gradientRadius	dimension|reference	渐变半径	需要配合gradientType=radial使用，如果设置gradientType=radial而没有设置gradientRadius，将会报错

  
  
  
  
  • 其它
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  

  属性名称	类型	说明	备注
  sle_maskBackgroundColor	color|reference	当sle_type=mask时，按钮按下状态的遮罩颜色	默认值：90%透明度黑色(#1A000000)
  sle_cancelOffset	dimension|reference	用于解决手指移出控件区域判断为cancel的偏移量	默认值：8dp

  
  


• 
  

  特有属性

  
  
  
  
  • SleConstraintLayout/SleRelativeLayout/SleFrameLayout/SleLinearLayout
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  

  属性名称	类型	说明	备注
  sle_interceptType	enum	事件拦截类型 intercept_super：return super intercept_true：return true intercept_false：return false	Layout组件设置此值，可实现是否拦截事件，如果设置为intercept_true，事件将不传递到子控件，在某些场景比较实用

  
  
  
  
  • SleTextButton
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  

  属性名称	类型	说明	备注
  sle_normalTextColor	color|reference	常态文字颜色	/
  sle_pressedTextColor	color|reference	按下态文字颜色	/
  sle_disabledTextColor	color|reference	不可点击态文字颜色	/
  sle_selectedTextColor	color|reference	选中态文字颜色	/

  
  
  
  
  • SleImageButton
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  

  属性名称	类型	说明	备注
  sle_ib_type	enum	类型 mask：图片遮罩 alpha：图片透明度改变 selector：自定义图片 checkBox：CheckBox场景 none：无	1.指定为mask时，自定义图片资源无效； 2.指定为alpha时，sle_pressedAlpha/sle_disabledAlpha生效； 3.指定为selector时，sle_normalResId/sle_pressedResId/sle_disabledResId生效； 4.指定为checkBox时，sle_checkedResId/sle_uncheckedResId/sle_isChecked生效； 5.指定为none时，图片资源均不生效，圆角相关配置有效
  sle_ib_style	enum	ImageView形状 normal：普通形状 rounded：圆角 oval：圆形	默认值：normal
  sle_normalResId	color|reference	常态图片资源	/
  sle_pressedResId	color|reference	按下态图片资源	/
  sle_disabledResId	color|reference	不可点击态图片资源	/
  sle_checkedResId	color|reference	选中态checkBox图片资源	/
  sle_uncheckedResId	color|reference	非选中态checkBox图片资源	/
  sle_isChecked	boolean	CheckBox是否选中	默认值：false
  sle_pressedAlpha	float	按下态图片透明度	默认值：70%
  sle_disabledAlpha	float	不可点击态图片透明度	默认值：30%

  
  

使用方式

1. 添加依赖

implementation "io.github.freddychen:silhouette:$lastest_version"

Note：最新版本可在maven central silhouette中找到。

2. 使用

由于自定义属性太多，在此就不一一列举了。下面给出几种常见的场景示例，大家可以根据自定义属性表自行编写：

• 常态

• 按下态

以上布局代码为：

<?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"

    android:layout_width="match_parent"

    android:layout_height="match_parent"

    android:background="@color/black"

    android:gravity="center_horizontal"

    android:orientation="vertical">



    <com.freddy.silhouette.widget.button.SleTextButton

        android:id="@+id/stb_1"

        android:layout_width="match_parent"

        android:layout_height="54dp"

        android:layout_marginHorizontal="48dp"

        android:layout_marginTop="14dp"

        android:gravity="center"

        android:text="SleTextButton1"

        android:textSize="20sp"

        app:sle_cornersRadius="28dp"

        app:sle_normalBackgroundColor="#f88789"

        app:sle_normalTextColor="@color/white"

        app:sle_type="mask" />



    <com.freddy.silhouette.widget.button.SleTextButton

        android:id="@+id/stb_2"

        android:layout_width="match_parent"

        android:layout_height="54dp"

        android:layout_marginHorizontal="48dp"

        android:layout_marginTop="14dp"

        android:gravity="center"

        android:text="SleTextButton2"

        android:textSize="20sp"

        app:sle_cornersBottomRightRadius="24dp"

        app:sle_cornersTopLeftRadius="14dp"

        app:sle_normalBackgroundColor="#338899"

        app:sle_normalTextColor="@color/white"

        app:sle_pressedBackgroundColor="#aeeacd"

        app:sle_type="selector" />



    <com.freddy.silhouette.widget.button.SleTextButton

        android:id="@+id/stb_3"

        android:layout_width="120dp"

        android:layout_height="120dp"

        android:layout_marginHorizontal="48dp"

        android:layout_marginTop="14dp"

        android:enabled="false"

        android:gravity="center"

        android:text="SleTextButton2"

        android:textSize="14sp"

        app:sle_cornersBottomRightRadius="24dp"

        app:sle_cornersTopLeftRadius="14dp"

        app:sle_normalBackgroundColor="#cc688e"

        app:sle_normalTextColor="@color/white"

        app:sle_pressedBackgroundColor="#34eeac"

        app:sle_shape="oval"

        app:sle_type="selector" />



    <com.freddy.silhouette.widget.button.SleImageButton

        android:id="@+id/sib_1"

        android:layout_width="84dp"

        android:layout_height="84dp"

        android:layout_marginTop="14dp"

        app:sle_ib_type="mask"

        app:sle_normalResId="@drawable/ic_launcher_background" />



    <com.freddy.silhouette.widget.button.SleImageButton

        android:id="@+id/sib_2"

        android:layout_width="128dp"

        android:layout_height="128dp"

        android:layout_marginTop="14dp"

        app:sle_ib_type="alpha"

        app:sle_normalResId="@drawable/ic_launcher_background" />



    <com.freddy.silhouette.widget.button.SleImageButton

        android:id="@+id/sib_3"

        android:layout_width="72dp"

        android:layout_height="72dp"

        android:layout_marginTop="14dp"

        app:sle_ib_type="selector"

        app:sle_normalResId="@mipmap/ic_launcher"

        app:sle_pressedResId="@drawable/ic_launcher_foreground" />



    <com.freddy.silhouette.widget.layout.SleConstraintLayout

        android:id="@+id/scl_1"

        android:layout_width="match_parent"

        android:layout_height="wrap_content"

        android:layout_marginHorizontal="48dp"

        android:layout_marginTop="14dp"

        android:paddingHorizontal="14dp"

        android:paddingVertical="8dp"

        app:sle_cornersRadius="10dp"

        app:sle_interceptType="intercept_super"

        app:sle_normalBackgroundColor="@color/white">



        <ImageView

            android:layout_width="72dp"

            android:layout_height="48dp"

            android:scaleType="centerCrop"

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



        <TextView

            android:layout_width="wrap_content"

            android:layout_height="wrap_content"

            android:text="UserName"

            android:textColor="@color/black"

            android:textSize="18sp"

            app:layout_constraintBottom_toBottomOf="parent"

            app:layout_constraintEnd_toEndOf="parent"

            app:layout_constraintStart_toStartOf="parent"

            app:layout_constraintTop_toTopOf="parent" />

    </com.freddy.silhouette.widget.layout.SleConstraintLayout>



    <com.freddy.silhouette.widget.layout.SleLinearLayout

        android:id="@+id/sll_1"

        android:layout_width="match_parent"

        android:layout_height="wrap_content"

        android:layout_marginHorizontal="48dp"

        android:layout_marginTop="14dp"

        android:gravity="center_vertical"

        android:paddingHorizontal="14dp"

        app:sle_type="selector"

        android:paddingVertical="8dp"

        app:sle_cornersTopRightRadius="24dp"

        app:sle_cornersBottomRightRadius="18dp"

        app:sle_interceptType="intercept_true"

        app:sle_pressedBackgroundColor="#fe9e87"

        app:sle_normalBackgroundColor="#aee949">



        <ImageView

            android:layout_width="72dp"

            android:layout_height="48dp"

            android:scaleType="centerCrop"

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



        <TextView

            android:layout_width="wrap_content"

            android:layout_height="wrap_content"

            android:layout_marginStart="14dp"

            android:text="UserName"

            android:textColor="@color/black"

            android:textSize="18sp"

            app:layout_constraintBottom_toBottomOf="parent"

            app:layout_constraintEnd_toEndOf="parent"

            app:layout_constraintStart_toStartOf="parent"

            app:layout_constraintTop_toTopOf="parent" />

    </com.freddy.silhouette.widget.layout.SleLinearLayout>

</LinearLayout>

Note：需要给组件设置setOnClickListener才能看到效果。

至于更多的功能，就让大家去试试吧，篇幅有限，就不一一列举了。有任何疑问，欢迎通过QQ群或微信公众号联系我。

版本记录

写在最后

终于写完了，Shape/Selector在每个项目中基本都会用到，而且频率还不算低。Silhouette原理虽然简单，但确实能解决很多问题，这些都是平时开发中的积累，希望对大家能有所帮助。欢迎大家star和fork，让我们为Android开发共同贡献一份力量。另外如果有疑问欢迎加入我的QQ群：1015178804，同时也欢迎大家关注我的公众号：FreddyChen，让我们共同进步和成长。

大纲

1. 使用dp而不是px


2. 尽量使用自动适配布局，而不要指定分辨率


3. 使用宽高限定符
   
   
   
   1. values-1080x1920，以1080P为基准计算每种常见分辨率对应的尺寸。
   
   
   2. 需要尽可能全的添加各种设备的分辨率（有工具）
   
   
   3. 容错性不足，如果设备分辨率不能精确匹配对应限定符，会默认使用统一默认的dimens
   
   
   
   


4. 第三方自动适配UI框架
   
   
   
   1. 原理：自定义RelativeLayout，在onMeasure中对控件分辨率做变换
   
   
   2. 第三方框架，维护性很成问题
   
   
   3. 一些自定义View，处理比较麻烦
   
   
   
   


5. 最小宽度限定符，类似宽高限定符
   
   
   
   1. values-sw240dp，同样以某一dp宽度为基准计算其他宽度dp的值
   
   
   2. values-sw360dp、values-sw480dp
   
   
   3. 相比宽高限定符，最小宽度限定符不进行精确匹配，会遵循就近原则，可以较好的解决容错问题。
   
   
   4. 如：设备宽364dp，系统会自动就近配置values-sw360dp下的dimens，显示效果相差不会很大
   
   
   
   


6. 今日头条——修改density值
   
   
   
   1. 原理：px = dp x (dpi/160) = dp x density
   
   
   2. 既然如此，将density
   
   
   3. 需要UI出设计图时以统一的dp为基准
   
   
   4. mp.weixin.qq.com/s/d9QCoBP6k…
   
   
   
   

基本概念

• 像素——px


• 密度独立像素——dp或dip


• 像素密度——dpi，单位面积内的像素数。
  
  
  
  • 软件系统的概念。
  
  
  • 在系统出厂时，配置文件中的固定值。
  
  
  • 通常的取值有：160、240、360、480等。
  
  
  • 不同于物理概念上的屏幕密度ppi，如ppi为415、430和470时，dpi可能会统一设置为480。
  
  
  
  


• density——当dpi=160时，1px = 1pd,此时denstiy的值为1，dpi=240时，1.5px = 1dp,density的值为1.5。


• 上述值的关系：
  
  
  
  • denstiy = dpi / 160;
  
  
  • px = dp x density = dp x （dpi / 160）
  
  
  
  

Android设备的碎片化极为严重，各种尺寸和分辨率的设备无比繁多。使得在Android开发中，UI适配变成了开发过程中极为重要的一步。为此Google提出了密度独立像素dip或dp的概率，旨在更友好的处理Android UI适配问题。

但是效果嘛，只能说差强人意，可以解决大部分的业务场景，但是剩下的个别情况就搞死人了，原因在于Android设备碎片化实在太严重了，存在各种分辨率和dpi的设备。

比如两台设备A和B，分辨率是1920x1080，dpi分别为420和480，在布局中编写一个100dp宽的ImageView，按照上面的公式ImageView的显示宽度分别为：100dp x 420 / 160 = 262.5和100dp x 480 / 160 = 300，ImageView在B设备上明显显示要大一些。差异可能还不明显，我们把宽度改为360dp呢，A设备显示宽度为：948px，B设备显示宽度为：1080px。这就扯淡了，一个宽度填充满屏幕，一个不满。这种情况肯定是需要开发来背锅解决的。

适配方案

虽然上面提到了使用dp无法解决全部业务场景，但是相对于直接使用px已经可以解决大部分场景下的适配问题了。

所以UI适配的第一条就是：

1. 使用dp代替px来编写布局。

又因为上面无法适配的个别场景，所以UI适配的第二条是：

2.尽量使用自动适配布局，而不要指定分辨率

这一条也很好理解，尽量使用ConstraintLayout 约束布局和LinearLayout等父布局，不要写死分辨率，比如上面的例子如果使用match_parent而不是360dp，也可以避免出现显示不一致问题（但是仅限于上列）。

限定符

Google同样意识到dp满足所以业务场景的需要，所以提供了宽度限定符的概念。

虽然您的布局应始终通过拉伸其视图内部和周围的空间来应对不同的屏幕尺寸，但这可能无法针对每种屏幕尺寸提供最佳用户体验。例如，您为手机设计的界面或许无法在平板电脑上提供良好的体验。因此，您的应用还应提供备用布局资源，以针对特定屏幕尺寸优化界面设计。

最小宽度限定符

使用“最小宽度”屏幕尺寸限定符，您可以为具有最小宽度（以密度无关像素 dp 或 dip 为度量单位）的屏幕提供备用布局。

通过将屏幕尺寸描述为密度无关像素的度量值，Android 允许您创建专为非常具体的屏幕尺寸而设计的布局，同时让您不必对不同的像素密度有任何担心。

通俗一点翻译就是：可用通过xxxx-swXXXdp的方式定义一些最小限定符的资源文件，比如：values-sw400dp、values-sw600dp，系统会自动匹配如屏幕宽度相近资源文件夹。

我们再来看上面的例子两台设备A和B，分辨率是1920x1080，dpi分别为360和400。我们简化下问题比如设计图给的是1920x1080 360dpi，包含一个22.5px * 22.5px = 10dp * 10dp的图片。按经验布局应该如下编写：

<ImageView

    android:id="@+id/img_iv"

    android:layout_width="10dp"

    android:layout_height="10dp"

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

在不同设备上运行的结果：

• 1280 x 720 240dpi的设备，图片显示为15px * 15px；


• 1920 x1080 360dpi的A设备，图片显示为22.5px * 22.5px;


• 1920 x1080 400dpi的B设备，图片显示为25px * 25px;

可以看到B设备图片显示是有问题的，为了解决这个问题，我们使用最小宽度限定符定义两个资源文件夹：values-sw360dp和values-sw400dp。

在values-sw360dp中添加dimen.xml内容如下：

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

<resources>

    <dimen name="dp_1">1dp</dimen>

    <dimen name="dp_2">2dp</dimen>

    <dimen name="dp_3">3dp</dimen>

    <dimen name="dp_4">4dp</dimen>

    <dimen name="dp_5">5dp</dimen>

    <dimen name="dp_6">6dp</dimen>

    <dimen name="dp_7">7dp</dimen>

  <!-- 省略其他值 -->

  	<dimen name="dp_360">360dp</dimen>

    <!-- 因为设计图是360dpi，所以控件尺寸通常不会超过360dp，定义最大360dp的值足够使用 -->

</resources>

在values-sw420dp中添加dimen.xml，文件中的dimen值很容易换算出来：在360dpi中dp_1 = 1dp，那么在400dpi中dp_1 = 360 / 400 = 0.9dp，文件内容如下：

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

<resources>

    <dimen name="dp_1">0.9dp</dimen>

    <dimen name="dp_2">1.8dp</dimen>

    <dimen name="dp_3">2.7dp</dimen>

    <dimen name="dp_4">3.6dp</dimen>

    <dimen name="dp_5">4.5dp</dimen>

    <dimen name="dp_6">5.4dp</dimen>

    <dimen name="dp_7">6.3dp</dimen>

  	<!-- 省略其他值 -->

</resources>

注意要在values文件夹下添加默认dimen.xml，文件内容与values-sw360dp中添加dimen.xml一致（因为设计图恰好是360dpi的）。

布局中的ImageView自然要改写为：

<ImageView

    android:id="@+id/img_iv"

    android:layout_width="@dimen/dp_10"

    android:layout_height="@dimen/dp_10"

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

我们再来看一下不同设备运行结果：

• 1280 x 720 240dpi的设备，未匹配到限定符使用values中的dimen，dp_10 = 10dp, px = 10 * 240 / 160 = 15px，图片显示尺寸为15px * 15px。


• 1920 x1080 360dpi的A设备，匹配到sw360dp限定符，dp_10 = 10dp, px = 10 * 360 / 160 = 20px，图片显示尺寸为22.5px * 22.5px。


• 1920 x1080 400dpi的B设备，匹配到sw420dp限定符，dp_10 = 9dp, px = 9 * 400 / 160 = 20px，图片显示尺寸为22.5px * 22.5px。

完美的解决了设备A和B的显示问题，所以UI适配的第三条是：

3. 使用最小（可用）宽度限定符，解决同样分辨率不同dpi的设备适配问题。

这种方案看似完美，但是也有一些隐含的问题：此方案只能解决同样分辨率不同dpi设备的适配问题：

• 一旦出现不同分辨率相同dpi的情况就无效了（当然这种情况的可能性不高）。


• 以上举例只是基于1920x1080这一种分辨率为例说明，试想一下如果1280x720的设备存在240dpi和280dpi的情况呢？我们只能针对特殊情况适配处理，无法解决全部场景适配问题。

宽高限定符

类似于上面说的最小宽度限定符，但是需要精确指定要匹配的设备宽高，values-1920x1080、values-1280x720等。配置与使用方式也与上面类似，如设计图尺寸为1920x1080 360dpi，那么只需要以1920x1080为基准计算所有分辨率对应的尺寸就可以了，布局编写时按照给的尺寸一一对应就可以，比如：给出的ImageView是20px*20px的，那在布局中同样指定width和height为@dimen/dp_20就可以了。

values-1920x1080中dimens.xml如下：

<resources>

    <dimen name="dp_1">1px</dimen>

    <dimen name="dp_2">2px</dimen>

    <dimen name="dp_3">3px</dimen>

    <dimen name="dp_4">4px</dimen>

    <dimen name="dp_5">5px</dimen>

    <dimen name="dp_6">6px</dimen>

    <dimen name="dp_7">7px</dimen>

    <dimen name="dp_8">8px</dimen>

    <dimen name="dp_9">9px</dimen>

  	<!-- 省略其他 -->

  	<dimen name="dp_1920">1920px</dimen>

</resources>

values-1280x720中dimens.xml换算为：

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

<resources>

    <dimen name="dp_1">0.66px</dimen>

    <dimen name="dp_2">1.33px</dimen>

    <dimen name="dp_3">2.0px</dimen>

    <dimen name="dp_4">2.66px</dimen>

    <dimen name="dp_5">3.33px</dimen>

    <dimen name="dp_6">4.0px</dimen>

    <dimen name="dp_7">4.66px</dimen>

  	<!-- 省略其他 -->

</resources>

同样需要在values添加默认尺寸dimen.xml，内容同基准分辨率文件。

因为不是所有设备屏幕都是16:9的，也可以按照宽高拆分成两个dimens.xml文件dimen_x.xml和dimen_y.xml，按照宽高：1920x1080分别换算得到x和y的值，但是页面设计通常是竖屏可滑动的，所以对高度不敏感，只需要根据一个维度计算统一值就可以了。

以上计算方式比较简单了，不需要自己编写换算可以通过代码工具或者自己写个类实现。（网上有好多，找一下应该可以找到）。

理论上只要尽可能多的枚举所有设备分辨率，就可以完美的解决屏幕适配问题，所以UI适配的第四条是：

4.使用宽高限定符，精确匹配屏幕分辨率。

这种方案已经近乎完美了，一度成为比较热门的解决方案，也有很多团队使用过此方案。但是之前也说过Android设备的碎片化太严重了，综合考虑基本不可能在项目中枚举所有的屏幕尺寸进行适配，如果设备没有匹配到对应尺寸会使用values下的默认尺寸文件，可能会出现严重的UI适配问题。

但是不可否认此种方案实现简单，对于编写布局也很友好（直接填入设计图的尺寸值就行，不需要换算），可以解决绝大多数的设备适配问题，是一种很友好的解决方案。

第三方UI适配框架

有很多第三方库的解决方案，是从ViewGroup入手的，要么重写常用的如：RelativeLayout、LinearLayout和FrameLayout等在控件内部做转换来适配不同尺寸的设备，要么提供新的Layout如：Google的PercentLayout布局。但是这些方案基本都不在维护了，这里就不详细展开了，感兴趣的可以自行搜索了解。

UI适配的第五条是：

5. 使用第三方自适配框架，解决UI适配问题。

感兴趣的可以参考以下文档：

• 鸿洋大佬的AndroidAutoLayout


• Percentlayout介绍


• Percentlayout官方文档

其他适配方案

参考字节的实现方案：

一种极低成本的Android屏幕适配方式

这篇文章着实属于拾人牙慧了，起因是因为看到了这篇博客Android 目前最稳定和高效的UI适配方案。所以想着确实应该把这部分知识梳理一下，所以写了这篇文档加了一些自己的里面，主要也是为了梳理知识点加深理解。

文中列举的几种UI适配方案，没有严格的优劣之分，可以根据自己的业务需求选择，也可以选择几种搭配使用，比如笔者目前主要做智能电视（盒子）的应用开发，Android电视不同于手机，碎片化没有那么严重，电视分辨率种类屈指可数，所以在日常项目中基本选择使用宽高限定符的方案进行适配，效果也是极好的。

前言

当我们在 Java 中使用 sleep() 让线程休眠的时候，总是需要使用 try catch 去包含它：

        try {

            sleep(1000);

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

但是，我们却很少在 catch 中执行其它代码，仿佛这个 try catch 是理所当然一样，但其实，存在即合理，不可能无缘无故地多出一个 try catch。

在给出原因之前，我先要讲讲另外一个知识点，那就是如何去停止线程。

如何停止线程

stop()

最直接了断的方法就是调用 stop()，它能直接结束线程的执行，就如：

        // 开启线程循环输出当前的时间

        Thread thread = new Thread(){

            @Override

            public void run() {

                while (true){

                    System.out.println(System.currentTimeMillis());

                }

            }

        };

        thread.start();

        // 睡眠两秒后停止线程

        try {

            sleep(2000);

            thread.stop();

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

输出结果：

···

1643730391073

1643730391073

1643730391073

1643730391073

1643730391073



Process finished with exit code 0

很明显是能够把线程暂停掉的。但是，该方法现在被标记遗弃状态。

大概意思就是：

这个方法原本是设计用来停止线程并抛出线程死亡的异常，但是实际上它是不安全的，因为它是直接终止线程解放锁，这很难正确地抛出线程死亡的异常进行处理，所以，更好的方式是设置一个判断条件，然后在线程执行的过程中去判断该条件以去决定是否要进行停止线程，这样就能进行处理并有序地退出这个线程。假如一个线程等待很久的话，那才会直接中断线程并抛出异常。

按照上面所说，我们可以设置一个变量来进行控制，当然，我们可以声明一个 bool 类型进行判断，但是更好的方式是使用 interrupt()。

interrupt()

源码：

    public void interrupt() {

        if (this != Thread.currentThread())

            checkAccess();



        synchronized (blockerLock) {

            Interruptible b = blocker;

            if (b != null) {

                interrupt0();           // Just to set the interrupt flag

                b.interrupt(this);

                return;

            }

        }

        interrupt0();

    }

Just to set the interrupt flag 这里很明显就是说明只是进行了一个中断标记而已，并不会直接中断线程，所以，需要使用 interrupt() 的时候，我们还要在线程中进行 interrupt 的状态判断：

        // 开启线程循环输出当前的时间

        // 每次循环前都去判断该线程是否被中断了

        Thread thread = new Thread(){

            @Override

            public void run() {

                while (true){

                    if(isInterrupted()){

                        return;

                    }

                    System.out.println(System.currentTimeMillis());

                }

            }

        };

        thread.start();

        // 睡眠两秒后标记中断线程

        try {

            sleep(2000);

            thread.interrupt();

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

输出结果：

···

1643731839919

1643731839919

1643731839919



Process finished with exit code 0

这样也能正常的中断线程。

好了，如何中断线程到这里讲完了，大家拜拜~~

喂！等下，这文章是不是还有东西没讲 (#`O′)，sleep()为什么要 try catch 还没说。

好像是这样。

中断等待

我们再看看 stop() 被标记为遗弃的说明：

 If the target thread waits for long periods (on a condition variable, for example),

 the interrupt method should be used to interrupt the wait.

也就是说，当线程在等待过久的时候，interrupt() 应该去中断这个等待。

所以，原因就找到了，要加 try catch，是因为当线程在 sleep() 的时候，调用线程的 interrupt() 方法，就会直接中断线程的 sleep 状态，抛出 InterruptedException。

因为调用 interrupt() 的时候，其实就是想尽快地结束线程，所以，继续的 sleep 是没有意义的，应该尽快结束。

        // 开启线程

        // 线程睡眠 10 秒

        Thread thread = new Thread(){

            @Override

            public void run() {

                try {

                    sleep(10000);

                } catch (InterruptedException e) {

                    System.out.println("sleep 状态被中断了！");

                    e.printStackTrace();

                }

            }

        };

        thread.start();

        // 睡眠两秒后标记中断线程

        try {

            sleep(2000);

            thread.interrupt();

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

输出结果：

sleep 状态被中断了！

java.lang.InterruptedException: sleep interrupted

	at java.base/java.lang.Thread.sleep(Native Method)

	at com.magic.vstyle.TestMain$1.run(TestMain.java:16)



Process finished with exit code 0

这时，我们就可以 catch 到这个异常后进行额外操作，例如回收资源等。这时，停止线程就是一种可控的行为了。

昨天在康 KunMinX 大佬的：《重学安卓：Activity 生命周期的 3 个辟谣》，在加餐处看到这段：

转换后的理解：单进程场景，Activity被回收只可能是因为进程被系统回收了。

感觉不太对？因为在很久以前，遇到过这样一个场景：

App打开多个Activity，然后手机晾一边，过一段时间后(屏幕常亮)，点击回退，之前的Activity空白，然后重新加载了。

App在前台，不在栈顶的Activity却被干掉，但进程还健在，如果真是这样，就和上面的理解有些出入了。

立马写个代码验证下，大概流程如下：

写个父类Activity，生命周期回调加日志打印，接着打开一个Activity，包含一个按钮，点击后依次打开多个Activity，最后一个加个按钮，点一下就申请一个大一点的ByteArray来模拟内存分配，看内存不足时是否会回收Activity。

测试结果如下：

App宁愿OOM，也不愿意回收Activity，鬼使神差地加上 android:largeHeap="true" ，结果一样。

em...难道是我记错了？？？

等等！！！我好像混淆了两个东西：系统可用内存不足 和 应用可用内存不足。

0x1、系统可用内存不足

LMK机制

Android系统中，进程的生命周期由系统控制，处于体验和性能考虑，在APP中点击Home键或Back回退操作，并不会真的杀掉APP，进程依旧存在于内存中，这样下次启动此APP时就能更加快速。随着系统运行时间增长，打开APP越来越多，内存中的进程随着增多，系统的可用内存会越来越少。咋办，总不能让用户自己去杀进程吧，所以系统内置一套 回收机制，当系统可用内存达到一个 阈值，系统会根据 进程优先级 来杀掉一部分进程，释放内存供后续启动APP使用。

Android的这套回收机制，是基于Linux内核的OOM规则改进而来的，叫 Low Memory Killer，简称 LMK。

阈值 & 杀谁

通过下述两个文件配合完成，不同手机数值可能不同，以我的老爷机 魅蓝E2 为例 (Android 11的Mix2S一直说没权限打开此文件)：

# /sys/module/lowmemorykiller/parameters/minfree

# 单位：Page页，1Page = 4KB

18432,23040,27648,46080,66560,97280



# /sys/module/lowmemorykiller/parameters/adj

0,58,117,176,529,1000

Android系统会为每个进程维护一个 adj(优先级)：

• Android 6及以前称为：oom_adj，值范围：[-17,16]，LMK要换算*1000/17
• Android 7后称为：oom_score_adj，值范围：[-1000,1000]

然后，上面两个文件的值，其实是以一一对应的，比如：

66560  * 4 / 1024 = 260MB → 当系统可用内存减少到260MB时，会杀掉adj值大于529的进程；

18432 * 4 / 1024 = 72MB → 当系统可用内存减少到72MB，杀掉ajd值大于0的进程；

adj怎么看

直接通过命令行查看：

可以看到，adj是动态变化的，当App状态及四大组件生命周期发生改变时，都会改变它的值。常见ADJ级别如下：

• NATIVE_ADJ → -1000，init进程fork出来的native进程，不受system管控；
• SYSTEM_ADJ → -900，system_server进程；
• PERSISTENT_PROC_ADJ → -800，系统persistent进程，一般不会被杀，杀了或者Carsh系统也会重新拉起；
• PERSISTENT_SERVICE_ADJ → -700，关联着系统或persistent进程；
• FOREGROUND_APP_ADJ → 0，前台进程；
• VISIBLE_APP_ADJ → 100，可见进程；
• PERCEPTIBLE_APP_ADJ → 200，可感知进程，比如后台音乐播放；
• BACKUP_APP_ADJ → 300，执行bindBackupAgent()过程的备份进程；
• HEAVY_WEIGHT_APP_ADJ → 400，重量级进程，system/rootdir/init.rc文件中设置；
• SERVICE_ADJ → 500，服务进程；
• HOME_APP_ADJ → 600，Home进程，类型为ACTIVITY_TYPE_HOME的应用，如Launcher；
• PREVIOUS_APP_ADJ → 700，用户上一个使用的App进程；
• SERVICE_B_ADJ → 800，B List中的Service；
• CACHED_APP_MIN_ADJ → 900，不可见进程 的adj最小值；
• CACHED_APP_MAX_ADJ → 906，不可见进程的adj最大值；
• UNKNOWN_ADJ → 1001，一般指将要会缓存进程，无法获取确定值；

关于ADJ计算的详细算法分析可见Gityuan大佬的：《解读Android进程优先级ADJ算法》，干货多多，顺带从总结处捞一波进程保活伎俩：

• UI进程与Service进程分离，包含Activity的Service进程，一进后台ADJ>=900，随时可能被系统回收，分离的话ADJ=500，被杀的可能性降低，尤其是系统允许自启动的服务进程，必须做UI分离，避免消耗较大内存；
• 真正需要用户可感知的应用，调用startForegroundService()启用前台服务，ADJ=200;
• 进程中的Service工作完，务必主动调用stopService或stopSelf来停止服务，避免占用内存，浪费系统资源；
• 不要长时间绑定其他进程的service或者provider，每次使用完成后应立刻释放，避免其他进程常驻于内存；
• APP应该实现接口onTrimMemory()和onLowMemory()，根据TrimLevel适当地将非必须内存在回调方法中加以释放，当系统内存紧张时会回调该接口，减少系统卡顿与杀进程频次；
• 更应在优化内存上下功夫，相同ADJ级别，系统会优先杀内存占用的进程；

问：能否把自己的App的ADJ值设置为-1000，让其杀不死？ 答：不可以，要有root权限才能修改adj，而且改了重启手机还是恢复的。

扯得有点远了，回到问题上：

系统内存不足时，会在内核层直接查杀进程，不会在Framework层还跟你叨逼叨看回收哪个Activity。

所以在系统这个层面，单进程场景，Activity被回收只可能是因为进程被系统回收了，这句话是没毛病的，但在应用层面就不一定了。

0x2、应用可用内存不足

APP进程(虚拟机)的内存分配实际上是对 堆的分配和释放，为了整个系统的内存控制需要，会为每个应用程序设置一个 堆的限制阈值，如果应用使用内存接近阈值还尝试分配内存，就很容易引起OOM。

当然，不会那么蠢，还要开发仔自己在APP里回收内存，虚拟机自带 GC，这里就不向去卷具体的回收算法了

假设应用内存不足真的会回收Activity，那该怎么设计？一种解法如下：

应用启动时，开一个子线程，定时轮询当前可用内存是否超过阈值，超过的话干掉Activity

那就来跟下Android是不是也是这样设计的？

Activity回收机制

跟下应用启动入口：ActivityThread → main()

跟下 attach()：

这里就非常像，run()中计算：已用内存 > 3/4最大内存，就执行 releaseSomeActivities()，跟下：

所以 getService() 是获取了 IActivityTaskManager.aidl接口，具体的实现类是 ActivityTaskManangerService：

继续往下跟： RootActivityContainer → releaseSomeActivitiesLocked()：

跟下：WindowProcessController → getReleaseSomeActivitiesTasks()

然后再往下走就是释放Activity的代码了：ActivityStack → releaseSomeActivitiesLocked()

具体咋释放，就不往下跟了哈，接着跟下是怎么监控的~

内存监控机制

跟回：BinderInternal.addGcWatcher()

这里可能看得你有点迷，但是当你理解了就会觉得很妙了：

虚拟机GC会干掉 WeakReference 的对象，在释放内存前，会调用对象的 finalize()，而这里有创建了一个新的 WeakReference 实例。下次GC，又会走一遍这里的代码，啧啧啧，相比起轮询高效多了

到此，应用内存不足回收Activity的流程就大概缕清了，接着可以写个代码验证下是否真的这样。

Demo验证

先试下两个Task的：

模拟内存分配的页面，然后一直点~

宁愿OOM，也不回收，试试三个~

好家伙，onDestory()了，此时按Back回退这些页面，发现走了onCreate()，即回收了，接着试试四个的情况：

可以，每次只回收一个Task，到此验证完毕了~

0x3、结论

• 系统内存不足时，直接在内核层查杀(回收)进程，并不会考虑回收哪个Activity；
• 进程内存不足时，如果此进程 Activity Task数 >= 3 且 使用内存超过3/4，会对 不可见 Task进行回收，每次回收 1个 Task，回收时机为每次gc；

参考文献：

• 解读Android进程优先级ADJ算法

• Android中的LowMemoryKiller机制

• Android 进程回收之LowMemoryKiller原理篇

• Android可见APP的不可见任务栈（TaskRecord）销毁分析

背景

我们在多模块项目开发过程中，会遇到这样的场景，工程里依赖了一个自己的或者其他同事的 aar 模块，有时候为了开发调试方便，经常会把 aar 改为本地源码依赖，开发完毕并提交的时候，会再修改回 aar 依赖，这样就会很不方便，开发流程图示如下：

解决

一开始我们通过在 app 的 build.gradle 里的 dependency 判断如果是需要本地依赖的 aar，就替换为 implementation project 依赖，伪代码如下：

dependencies {

    if(enableLocalModule) {

        implementation 'custom:test:0.0.1'

    } else {

        implementation project(path: ':test')

    }

}

这样就可以不用每次提交代码还要修改回 aar 依赖，但是如果其他模块如果也依赖了该 aar 模块，就会出现问题，虽然可以继续修改其他模块里的依赖方式，但是这样就会有侵入性，而且不能彻底解决问题，仍然有可能出现本地依赖和 aar 依赖的代码不一致问题。

Gradle 官方针对这种场景提供了更好的解决方式 DependencySubstitution，使用方式如下：

步骤1：在 settting.gradle，添加如下代码：

// 加载本地 module

if (file("local.properties").exists()) {

    def properties = new Properties()

    def inputStream = file("local.properties").newDataInputStream()

    properties.load( inputStream )

    def moduleName = properties.getProperty("moduleName")

    def modulePath = properties.getProperty("modulePath")

    if (moduleName != null && modulePath != null) {

        include moduleName

        project(moduleName).projectDir = file(modulePath)

    }

}

步骤2：在 app 的 build.gradle 添加以下代码

configurations.all {

    resolutionStrategy.dependencySubstitution.all { DependencySubstitution dependency ->

        // use local module

        if (dependency.requested instanceof ModuleComponentSelector && dependency.requested.group == "custom") {

            def targetProject = findProject(":test")

            if (targetProject != null) {

                dependency.useTarget targetProject

            }

        }

    }

}

步骤3：：在 local.properties 里

moduleName=:test

modulePath=../AndroidStudioProjects/TestProject/testModule

到这里就大功告成了，后续只需要在 local.properties 里开启和关闭，即可实现 aar 模块本地依赖调试，提交代码也不用去手动修改回 aar 依赖。

参考

• Customizing resolution of a dependency directly

简介

在Android应用中，如果不是单机的话，应该都有请求后端接口API的情况，本篇文章就介绍下Retrofit在Android中如何进行使用的

相关代码

我们以一个简单的登录接口为例

完整代码GitHub上有：github.com/lw124392545…

仅做代码参考，目前数据监控上传是有了，但界面这些还很粗糙，没有完善

相关的依赖引入

首先我们在工程中引入相关的依赖：

    implementation 'com.squareup.okhttp3:okhttp:4.5.0'

    implementation 'com.squareup.retrofit2:retrofit:2.9.0'

    implementation 'com.squareup.retrofit2:converter-gson:2.9.0'

相关的手机权限开启

需要在文件中开启网络权限：

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

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

    package="com.example.selfgrowth">



    <uses-permission android:name="android.permission.INTERNET"/>



    <application

    ......

    </application>



</manifest>

配置Retrofit Client

Client的相关配置：单例，配置基于OKHTTP，Gson序列化;OKHTTP中添加了请求拦截器

@Data

public class RetrofitClient {



    private static final RetrofitClient instance = new RetrofitClient();



    private final Retrofit retrofit = new Retrofit.Builder()

            .baseUrl(HttpConfig.ADDRESS) //基础url,其他部分在GetRequestInterface里

            .client(httpClient())

            .addConverterFactory(GsonConverterFactory.create()) //Gson数据转换器

            .build();



    public static RetrofitClient getInstance() {

        return instance;

    }



    private OkHttpClient httpClient() {

        return new OkHttpClient.Builder()

                .addInterceptor(new AccessTokenInterceptor())

                .connectTimeout(20, TimeUnit.SECONDS)

                .build();

    }

}

配置通用的请求拦截器

比如在请求中，带上Authorization等

public class AccessTokenInterceptor implements Interceptor {



    @NonNull

    @Override

    public Response intercept(@NonNull Chain chain) throws IOException {

        if (UserCache.getInstance().getToken() == null) {

            return chain.proceed(chain.request());

        }



        Request original = chain.request();

        Request.Builder requestBuilder = original.newBuilder()

                .addHeader("Authorization", UserCache.getInstance().getToken());

        Request request = requestBuilder.build();

        return chain.proceed(request);

    }

}

Retrofit接口定义

登录请求的接口定义：

public interface UserApi {



    /**

     * 用户登录

     **/

    @POST("auth/user/login")

    Call<ApiResponse> login(@Body LoginUser user);

}

Retrofit Request具体请求编写

我们首先定义一个抽象类，在其中持有我们的RetrofitClient全局类，在其中发起请求，由于Android UI的形式，请求是异步的

public abstract class Request {



    final Retrofit retrofit;



    public Request() {

        this.retrofit = RetrofitClient.getInstance().getRetrofit();

    }



    /**

     * 发送网络请求(异步)

     * @param call call

     */

    void sendRequest(Call<ApiResponse> call, Consumer<? super Object> success, Consumer<? super Object> failed) {

        call.enqueue(new Callback<ApiResponse>() {

            @Override

            public void onResponse(Call<ApiResponse> call, Response<ApiResponse> response) {

                if (response.code() != 200) {

                    Log.w("Http Response", "请求响应错误");

                    failed.accept(response.raw().message());

                    return;

                }

                if (response.body() == null || response.body().getData() == null) {

                    success.accept(null);

                    return;

                }

                Object res = response.body().getData();

                if (String.valueOf(res).isEmpty()) {

                    success.accept(null);

                    return;

                }

                success.accept(res);

            }



            @Override

            public void onFailure(Call<ApiResponse> call, Throwable t) {

                System.out.println("GetOutWarehouseList->onFailure(MainActivity.java): "+t.toString() );

            }

        });

    }

}

如上所示，请求成功就执行success相关的逻辑，失败则执行failed相关的逻辑

登录请求的具体逻辑如下：构造Retrofit Interface，发起请求

public class UserRequest extends Request {



    public void login(LoginUser user, Consumer<? super Object> success, Consumer<? super Object> failed) {

        UserApi request = retrofit.create(UserApi.class);

        Call<ApiResponse> call = request.login(user);

        sendRequest(call, success, failed);

    }

}

Android UI中进行调动

使用示例如下，点击一个登录按钮后触发

public class LoginFragment extends Fragment {



    private final UserRequest userRequest = new UserRequest();



    @Nullable

    @Override

    public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {

        View rootView = inflater.inflate(R.layout.fragment_login, container, false);

        Button loginButton = rootView.findViewById(R.id.login_button);

        loginButton.setOnClickListener(view -> {

            EditText email = rootView.findViewById(R.id.login_email_edit);

            EditText password = rootView.findViewById(R.id.login_password_edit);



            final LoginUser user = LoginUser.builder()

                    .email(email.getText().toString())

                    .password(password.getText().toString())

                    .build();



            // 获取相关的用户名和密码后，调用登录接口

            userRequest.login(user, (token) -> {

                UserCache.getInstance().initUser(email.getText().toString(), token.toString());

                final SharedPreferences preferences = requireContext().getSharedPreferences("userInfo", Context.MODE_PRIVATE);

                final SharedPreferences.Editor edit = preferences.edit();

                edit.putString("username", email.getText().toString());

                edit.putString("password", password.getText().toString());

                edit.apply();

                Snackbar.make(view, "登录成功:" + token.toString(), Snackbar.LENGTH_LONG)

                        .setAction("Action", null).show();

            }, failedMessage -> {

                Snackbar.make(view, "登录失败:" + failedMessage, Snackbar.LENGTH_LONG)

                        .setAction("Action", null).show();

            });

        });

        return rootView;

    }



    @Override

    public void onActivityCreated(@Nullable Bundle savedInstanceState) {

        super.onActivityCreated(savedInstanceState);

        final SharedPreferences preferences = getActivity().getSharedPreferences("userInfo", Activity.MODE_PRIVATE);

        final String userName = preferences.getString("username", "");

        final String password = preferences.getString("password", "");

        final EditText emailEdit = getView().findViewById(R.id.login_email_edit);

        final EditText passwordEdit = getView().findViewById(R.id.login_password_edit);

        emailEdit.setText(userName);

        passwordEdit.setText(password);

    }

}

总结

本篇文章中介绍了如Android学习中如何使用Retrofit发起网络请求

但由于吃初学，虽然感觉能用，但有点繁琐，不知道在实际的Android开发中，网络请求的最近实践是怎么样的，如果有的话，大佬可以在评论区告知下，感谢

put

为了验证依赖注入的功能，首先创建两个测试页面：PageA 和 PageB ，PageA 添加两个按钮 toB 和 find ，分别为跳转 PageB 和获取依赖；在 PageB 中通过 put 方法注入依赖对象，然后调用按钮触发 find 获取依赖。关键源码如下：

PageA：

TextButton(

  child: const Text("toB"),

  onPressed: (){

      /// Navigator.push(context, MaterialPageRoute(builder: (context) => const PageB()));

      /// Get.to(const PageB());

  },

),



TextButton(

  child: const Text("find"),

  onPressed: () async {

    User user = Get.find();

    print("page a username : ${user.name}  id: ${user.id}");

  })

PageB:

Get.put(User.create("张三", DateTime.now().millisecondsSinceEpoch)));



User user = Get.find();



TextButton(

  child: const Text("find"),

  onPressed: (){

    User user = Get.find();

    print("${DateTime.now()} page b username : ${user.name}  id: ${user.id}");

  })

其中 User 为自定义对象，用于测试注入，源码如下：

User:

class User{

  final String? name;

  final int? id;

  

  factory User.create(String name, int id){

    print("${DateTime.now()} create User");

    return User(name, id);

  }

}

Navigator 路由跳转

首先使用 Flutter 自带的路由管理从 PageA 跳转 PageB， 然后返回 PageA 再点击 find 按钮获取 User 依赖：

Navigator.push(context, MaterialPageRoute(builder: (context) => const PageB()));

流程：PageA -> PageB -> put -> find -> PageA -> find

输出结果：

/// put

I/flutter (31878): 2022-01-27 19:18:20.851800 create User

[GETX] Instance "User" has been created



/// page b find  

I/flutter (31878): 2022-01-27 19:18:22.170133 page b username : 张三  id: 1643282300139

 

/// page a find 

I/flutter (31878): 2022-01-27 19:18:25.554667 page a username : 张三  id: 1643282300139

通过输出结果发现，在 PageB 注入的依赖 User，在返回 PageA 后通过 find 依然能获取，并且是同一个对象。通过 Flutter 通过源码一步一步剖析 Getx 依赖管理的实现 这篇文章知道，在页面销毁的时候会回收依赖，但是这里为什么返回 PageA 后还能获取到依赖对象呢？是因为在页面销毁时回收有个前提是使用 GetX 的路由管理页面，使用官方的 Navigator 进行路由跳转时页面销毁不会触发回收依赖。

GetX 路由跳转

接下来换成使用 GetX 进行路由跳转进行同样的操作，再看看输出结果：

Get.to(const PageB());

流程：PageA -> PageB -> put -> find -> PageA -> find

输出结果：

[GETX] GOING TO ROUTE /PageB



/// put

I/flutter (31878): 2022-01-27 19:16:32.014530 create User

[GETX] Instance "User" has been created



/// page b find

I/flutter (31878): 2022-01-27 19:16:34.043144 page b username : 张三  id: 1643282192014

[GETX] CLOSE TO ROUTE /PageB

[GETX] "User" deleted from memory



/// page a find error

E/flutter (31878): [ERROR:flutter/lib/ui/ui_dart_state.cc(209)] Unhandled Exception: "User" not found. You need to call "Get.put(User())" or "Get.lazyPut(()=>User())"

发现在 PageB 中获取是正常，关闭 PageB 时输出了一句 "User" deleted from memory 即在 PageB 注入的 User 被删除了，此时在 PageA 再通过 find 获取 User 就报错了，提示需要先调用 put 或者 lazyPut 先注入依赖对象。这就验证了使用 GetX 路由跳转时，使用 put 默认注入依赖时，当页面销毁依赖也会被回收。

permanent

put 还有一个 permanent 参数，在 Flutter应用框架搭建(一)GetX集成及使用详解 这篇文章里介绍过，permanent 的作用是永久保留，默认为 false，接下来在 put 时设置 permanent 为 true，并同样使用 GetX 的路由跳转重复上面的流程。

关键代码：

Get.put(User.create("张三", DateTime.now().millisecondsSinceEpoch), permanent: true);

流程：PageA -> PageB -> put -> find -> PageA -> find

输出结果：

[GETX] GOING TO ROUTE /PageB

/// put

I/flutter (31878): 2022-01-27 19:15:16.110403 create User

[GETX] Instance "User" has been created



/// page b find  

I/flutter (31878): 2022-01-27 19:15:18.667360 page b username : 张三  id: 1643282116109

[GETX] CLOSE TO ROUTE /PageB

[GETX] "User" has been marked as permanent, SmartManagement is not authorized to delete it.



/// page a find success

I/flutter (31878): page a username : 张三  id: 1643282116109

设置 permanent 为 true 后，返回 PageA 同样能获取到依赖对象，说明依赖并没有因为页面销毁而回收，GetX 的日志输出也说明了 User 被标记为 permanent 而不会被删除："User" has been marked as permanent, SmartManagement is not authorized to delete it.

lazyPut

lazyPut 为延迟初始化依赖对象 ：

Get.lazyPut(() => User.create("张三", DateTime.now().millisecondsSinceEpoch));



TextButton(  

    child: const Text("find"),  

    onPressed: () async {    

        User user = Get.find();    

        print("${DateTime.now()} page b username : ${user.name}  id: ${user.id}"); 

      })

流程：PageA -> PageB -> put -> find -> find -> PageA -> find， 从 PageA 跳转 PageB，先通过 lazyPut 注入依赖，然后点击 find 获取依赖，过 3 秒再点击一次，然后返回 PageA 点击 find 获取一次。

输出结果：

[GETX] GOING TO ROUTE /PageB

/// lazyPut  



/// page b find 1

I/flutter (31878): 2022-01-27 17:38:49.590295 create User

[GETX] Instance "User" has been created

I/flutter (31878): 2022-01-27 17:38:49.603063 page b username : 张三  id: 1643276329589



/// page b find 2  

I/flutter (31878): 2022-01-27 17:38:52.297049 page b username : 张三  id: 1643276329589

[GETX] CLOSE TO ROUTE /PageB

[GETX] "User" deleted from memory



/// page a find error

E/flutter (31878): [ERROR:flutter/lib/ui/ui_dart_state.cc(209)] Unhandled Exception: "User" not found. You need to call "Get.put(User())" or "Get.lazyPut(()=>User())"

通过日志发现 User 对象是在第一次调用 find 时进行初始化话的，第二次 find 时不会再次初始化 User；同样的 PageB 销毁时依赖也会被回收，导致在 PageA 中获取会报错。

fenix

lazyPut 还有一个 fenix 参数默认为 false，作用是当销毁时，会将依赖移除，但是下次 find 时又会重新创建依赖对象。

lazyPut 添加 fenix 参数 ：

 Get.lazyPut(() => User.create("张三", DateTime.now().millisecondsSinceEpoch), fenix: true);

流程：PageA -> PageB -> put -> find -> find -> PageA -> find，与上面流程一致。

输出结果：

[GETX] GOING TO ROUTE /PageB

/// lazyPut

  

/// page b find 1

[GETX] Instance "User" has been created

I/flutter (31878): 2022-01-27 17:58:58.321564 create User

I/flutter (31878): 2022-01-27 17:58:58.333369 page b username : 张三  id: 1643277538321



/// page b find 2 

I/flutter (31878): 2022-01-27 17:59:01.647629 page b username : 张三  id: 1643277538321

[GETX] CLOSE TO ROUTE /PageB



/// page a find success

I/flutter (31878): 2022-01-27 17:59:07.666929 create User

[GETX] Instance "User" has been created

I/flutter (31878): page a username : 张三  id: 1643277547666

通过输出日志分析，在 PageB 中的表现与不加 fenix 表现一致，但是返回 PageA 后获取依赖并没有报错，而是重新创建了依赖对象。这就是 fenix 的作用。

putAsync

putAsync 与 put 基本一致，不同的是传入依赖可以异步初始化。测试代码修改如下：

print("${DateTime.now()} : page b putAsync User");

Get.putAsync(() async {

  await Future.delayed(const Duration(seconds: 3));

  return User.create("张三", DateTime.now().millisecondsSinceEpoch);

});

使用 Future.delayed 模拟耗时操作。

流程：PageA -> PageB -> put -> find -> PageA -> find

输出结果：

[GETX] GOING TO ROUTE /PageB



/// putAsync 

I/flutter (31878): 2022-01-27 18:48:34.280337 : page b putAsync User

 

/// create user

I/flutter (31878): 2022-01-27 18:48:37.306073 create User

[GETX] Instance "User" has been created

 

/// page b find

I/flutter (31878): 2022-01-27 18:48:40.264854 page b username : 张三  id: 1643280517305

[GETX] CLOSE TO ROUTE /PageB

[GETX] "User" deleted from memory



/// page a find error

E/flutter (31878): [ERROR:flutter/lib/ui/ui_dart_state.cc(209)] Unhandled Exception: "User" not found. You need to call "Get.put(User())" or "Get.lazyPut(()=>User())"

通过日志发现，put 后确实是过了 3s 才创建 User。

create

create 的 permanent 参数默认为 true，即永久保留，但是通过 Flutter应用框架搭建(一)GetX集成及使用详解 这篇源码分析知道，create 内部调用时 isSingleton 设置为 false，即每次 find 时都会重新创建依赖对象。

Get.create(() => User.create("张三", DateTime.now().millisecondsSinceEpoch));

流程：PageA -> PageB -> put -> find -> find -> PageA -> find

输出结果：

[GETX] GOING TO ROUTE /PageB

/// create 

  

/// page b find 1

I/flutter (31878): 2022-01-27 18:56:10.520961 create User

I/flutter (31878): 2022-01-27 18:56:10.532465 page b username : 张三  id: 1643280970520



/// page b find 2

I/flutter (31878): 2022-01-27 18:56:18.933750 create User

I/flutter (31878): 2022-01-27 18:56:18.934188 page b username : 张三  id: 1643280978933

  

[GETX] CLOSE TO ROUTE /PageB



/// page a find success

I/flutter (31878): 2022-01-27 18:56:25.319224 create User

I/flutter (31878): page a username : 张三  id: 1643280985319

通过日志发现，确实是每次 find 时都会重新创建 User 对象，并且退出 PageB 后还能通过 find 获取依赖对象。

总结

通过代码调用不同的注入方法，设置不同的参数，分析输出日志，详细的介绍了 put、 lazyPut、 putAsync、 create 以及 permanent、 fenix 参数的具体作用，开发中可根据实际业务场景灵活使用不同注入方式。关于注入的 tag 参数将在后续文章中详细介绍。

整理 | 于轩
出品 | 程序人生（ID：coder _life）

在之前的两篇文章中主要分析了 Java 栈的缺点 ，为什么不推荐使用 Java 栈 ，以及 为什么不推荐直接使用 ArrayDeque 代替 Java Stack 。更多内容点击下方链接前去查看。

• 算法动画图解 | 被 "废弃" 的 Java 栈，为什么还在用


• 为什么不推荐 ArrayDeque 代替 Stack

接口 Deque 的子类 ArrayDeque ，作为栈使用时比 Stack 快，因为原来的 Java 的 Stack 继承自 Vector，而 Vector 在每个方法中都加了锁，而 Deque 的子类 ArrayDeque 并没有锁的开销。

接口 Deque 还有另外一个子类 LinkedList。LinkedList 基于双向链表实现的双端队列，ArrayDeque 作为队列使用时可能比 LinkedList 快。

而这篇文章主要来分析，为什么 ArrayDeque 比 LinkedList 快。在开始分析之前，我们需要简单的了解一下它们的数据结构的特点。

接口 Deque

接口 Deque 继承自 Queue 即队列, 在 Java 中队列有两种形式，单向队列（ AbstractQueue ） 和 双端队列（ Deque ），单向队列效果如下所示，只能从一端进入，另外一端出去。

而今天主要介绍双端队列（ Deque ）, Deque 是双端队列的线性数据结构, 可以在两端进行插入和删除操作，效果如下所示。

双端队列（ Deque ）的子类分别是 ArrayDeque 和 LinkedList，ArrayDeque 基于数组实现的双端队列，而 LinkedList 基于双向链表实现的双端队列，它们的继承关系如下图所示。

接口 Deque 和 Queue 提供了两套 API ，存在两种形式，分别为抛出异常，和不抛出异常，返回一个特殊值 null 或者布尔值 ( true | false )。

ArrayDeque

ArrayDeque 是基于（循环）数组的方式实现双端队列，数组初始化容量为 16（JDK 8），结构图如下所示。

ArrayDeque 具有以下特点：

• 因为双端队列只能在头部和尾部插入或者删除元素，所以时间复杂度为 O(1)，但是在扩容的时候需要批量移动元素，其时间复杂度为 O(n)


• 扩容的时候，将数组长度扩容为原来的 2 倍，即 n << 1


• 数组采用连续的内存地址空间，所以查询的时候，时间复杂度为 O(1)


• 它是非线程安全的集合

LinkedList

LinkedList 基于双向链表实现的双端队列，它的结构图如下所示。

LinkedList 具有以下特点：

• LinkedList 是基于双向链表的结构来存储元素，所以长度没有限制，因此不存在扩容机制


• 由于链表的内存地址是非连续的，所以只能从头部或者尾部查找元素，查询的时间复杂为 O(n)，但是 JDK 对 LinkedList 做了查找优化，当我们查找某个元素时，若 index < (size / 2)，则从 head 往后查找，否则从 tail 开始往前查找 , 但是我们在计算时间复杂度的时候，常数项可以省略，故时间复杂度 O(n)

Node<E> node(int index) {

    // size >> 1 等价于 size / 2

    if (index < (size >> 1)) {

        // form head to tail

    } else {

        // form tail to head

    }

}

• 链表通过指针去访问各个元素，所以插入、删除元素只需要更改指针指向即可，因此插入、删除的时间复杂度 O(1)


• 它是非线程安全的集合

最后汇总一下 ArrayDeque 和 LinkedList 的特点如下所示：

为什么 ArrayDeque 比 LinkedList 快

了解完数据结构特点之后，接下来我们从两个方面分析为什么 ArrayDeque 作为队列使用时可能比 LinkedList 快。

• 
  

  从速度的角度：ArrayDeque 基于数组实现双端队列，而 LinkedList 基于双向链表实现双端队列，数组采用连续的内存地址空间，通过下标索引访问，链表是非连续的内存地址空间，通过指针访问，所以在寻址方面数组的效率高于链表。

  
  


• 
  

  从内存的角度：虽然 LinkedList 没有扩容的问题，但是插入元素的时候，需要创建一个 Node 对象, 换句话说每次都要执行 new 操作，当执行 new 操作的时候，其过程是非常慢的，会经历两个过程：类加载过程 、对象创建过程。

  
  
  
  
  • 
    

    类加载过程

    
    
    
    
    • 会先判断这个类是否已经初始化，如果没有初始化，会执行类的加载过程
    
    
    • 类的加载过程：加载、验证、准备、解析、初始化等等阶段，之后会执行 <clinit>() 方法，初始化静态变量，执行静态代码块等等
    
    
    
    
  
  
  • 
    

    对象创建过程

    
    
    
    
    • 如果类已经初始化了，直接执行对象的创建过程
    
    
    • 对象的创建过程：在堆内存中开辟一块空间，给开辟空间分配一个地址，之后执行初始化，会执行 <init>() 方法，初始化普通变量，调用普通代码块
    
    
    
    
  
  
  
  

接下来我们通过 算法动画图解 | 被 "废弃" 的 Java 栈，为什么还在用 文章中 LeetCode 算法题：有效的括号，来验证它们的执行速度，以及在内存方面的开销，代码如下所示：

class Solution {

    public boolean isValid(String s) {

    

        // LinkedList VS ArrayDeque

        

        // Deque<Character> stack = new LinkedList<Character>();

        Deque<Character> stack = new ArrayDeque<Character>();

        

        // 开始遍历字符串

        for (int i = 0; i < s.length(); i++) {

            char c = s.charAt(i);

            // 遇到左括号，则将其对应的右括号压入栈中

            if (c == '(') {

                stack.push(')');

            } else if (c == '[') {

                stack.push(']');

            } else if (c == '{') {

                stack.push('}');

            } else {

                // 遇到右括号，判断当前元素是否和栈顶元素相等，不相等提前返回，结束循环

                if (stack.isEmpty() || stack.poll() != c) {

                    return false;

                }

            }

        }

        // 通过判断栈是否为空，来检查是否是有效的括号

        return stack.isEmpty();

    }

}

正如你所看到的，核心算法都是一样的，通过接口 Deque 来访问，只是初始化接口 Deque 代码不一样。

// 通过 LinkedList 初始化     

Deque<Character> stack = new LinkedList<Character>();



// 通过 ArrayDeque 初始化

Deque<Character> stack = new ArrayDeque<Character>();

结果如上所示，无论是在执行速度、还是在内存开销上 ArrayDeque 的性能都比 LinkedList 要好。

如果有帮助 点个赞 就是对我最大的鼓励

代码不止，文章不停

欢迎关注公众号：ByteCode，持续分享最新的技术

最后推荐长期更新和维护的项目：

• 
  

  个人博客，将所有文章进行分类，欢迎前去查看 hi-dhl.com

  
  


• 
  

  KtKit 小巧而实用，用 Kotlin 语言编写的工具库，欢迎前去查看 KtKit

  
  


• 
  

  计划建立一个最全、最新的 AndroidX Jetpack 相关组件的实战项目 以及 相关组件原理分析文章，正在逐渐增加 Jetpack 新成员，仓库持续更新，欢迎前去查看 AndroidX-Jetpack-Practice

  
  


• 
  

  LeetCode / 剑指 offer / 国内外大厂面试题 / 多线程 题解，语言 Java 和 kotlin，包含多种解法、解题思路、时间复杂度、空间复杂度分析
  

  
  
  
  
  
  • 剑指 offer 及国内外大厂面试题解：在线阅读
  
  
  • LeetCode 系列题解：在线阅读
  
  
  
  

近期必读热门文章

• 为什么不推荐 ArrayDeque 代替 Stack


• 算法动画图解 | 被 "废弃" 的 Java 栈，为什么还在用


• 影响性能的 Kotlin 代码（一）


• Jetpack Splashscreen 解析 | 助力新生代 IT 农民工 事半功倍


• 为数不多的人知道的 Kotlin 技巧及解析(三)


• 为数不多的人知道的 Kotlin 技巧以及 原理解析（二）


• 为数不多的人知道的 Kotlin 技巧以及 原理解析（一）


• 揭秘 Kotlin 中的 == 和 ===


• Kotlin 密封类进化了


• Kotlin 中的密封类 优于 带标签的类


• Kotlin Sealed 是什么？为什么 Google 都在用


• Android 12 行为变更，对应用产生的影响


• 图解多平台 AndroidStudio 技巧(三)


• Kotlin StateFlow 搜索功能的实践 DB + NetWork


• Kotlin 插件的落幕，ViewBinding 的崛起

前言

在使用Kotlin语言进行开发时，我相信很多开发者都信手拈来地使用by或者by lazy来简化你的属性初始化，但是by lazy涉及的知识点真的了解吗 假如让你实现这个功能，你会如何设计。

正文

话不多说，我们从简单的属性委托by来说起。

委托属性

什么是委托属性呢，比较官方的说法就是假如你想实现一个比较复杂的属性，它们处理起来比把值保存在支持字段中更复杂，但是却不想在每个访问器都重复这样的逻辑，于是把获取这个属性实例的工作交给了一个辅助对象，这个辅助对象就是委托。

比如可以把这个属性的值保存在数据库中，一个Map中等，而不是直接调用其访问器。

看完这个委托属性的定义，假如你不熟悉Kotlin也可以理解，就是我这个类的实例由另一个辅助类对象来提供，但是这时你可能会疑惑，上面定义中说的支持字段和访问器是什么呢，这里顺便给不熟悉Kotlin的同学普及一波。

Java的属性

当你定义一个Java类时，在定义字段时并不是所有字段都是属性，比如下面代码：

//Java类

public class Phone {

    

    //3个字段

    private String name;

    private int price;

    private int color;



    //name字段访问器

    private String getName() {

        return name;

    }



    private void setName(String name){

        this.name = name;

    }



    //price字段访问器

    private int getPrice() {

        return price;

    }



    private void setPrice(int price){

        this.price = price;

    }

}

上面我在Phone类中定义了3个字段，但是只有name和price是Phone的属性，因为这2个字段有对应的get和set，也只有符合有getter和setter的字段才叫做属性。

这也能看出Java类的属性值是保存在字段中的，当然你也可以定义setXX函数和getXX函数，既然XX属性没有地方保存，XX也是类的属性。

Kotlin的属性

而对于Kotlin的类来说，属性定义就非常简单了，比如下面类：

class People(){

    val name: String? = null

    var age: Int? = null

}

在Kotlin的类中只要使用val/var定义的字段，它就是类的属性，然后会自带getter和setter方法(val属性相当于Java的final变量，是没有set方法的)，比如下面：

val people = People()

//调用name属性的getter方法

people.name

//调用age属性的setter方法

people.age = 12

这时就有了疑问，为什么上面代码定义name时我在后面给他赋值了即null值，和Java一样不赋值可以吗 还有个疑问就是在Java中是把属性的值保存在字段中，那Kotlin呢，比如name这个属性的值就保存给它自己吗

带着问题，我们继续分析。

Kotlin属性访问器

前面我们可知Java中的属性是保存在字段中，或者不要字段，其实Kotlin也可以，这个就是给属性定义自定义setter方法和getter方法，如下代码：

class People(){

    val name: String? = null

    var age: Int = 0

    //定义了isAbove18这个属性

    var isAbove18: Boolean = false

        get() = age > 18

}

比如这里自定义了get访问器，当再访问这个属性时，便会调用其get方法，然后进行返回值。

Kotlin属性支持字段field

这时一想那Kotlin的属性值保存在哪里呢，Kotlin会使用一个field的支持字段来保存属性。如下代码：

class People{

    val name: String? = null

    var age: Int = 0

        //返回field的值

        get() = field

        //设置field的值

        set(value){

            Log.i("People", "旧值是$field 新值是$value ")

            field = value

        }



    var isAbove18: Boolean = false

        get() = age > 18

}

可以发现每个属性都会有个支持字段field来保存属性的值。

好了，为了介绍为什么Kotlin要有委托属性这个机制，假如我在一个类中，需要定义一个属性，这时获取属性的值如果使用get方法来获取，会在多个类都要写一遍，十分不符合代码设计，所以委托属性至关重要。

委托属性的实现

在前面说委托属性的概念时就说了，这个属性的值需要由一个新类来代理处理，这就是委托属性，那我们也可以大概猜出委托属性的底层逻辑，大致如下面代码：

class People{

    val name: String? = null

    var age: Int = 0

    val isAbove18: Boolean = false

    //email属性进行委托，把它委托给ProduceEmail类

    var email: String by ProduceEmail()

}

假如People的email属性需要委托，上面代码编译器会编译成如下：

class People{

    val name: String? = null

    var age: Int = 0

    val isAbove18: Boolean = false

    //委托类的实例

    private val productEmail = ProduceEmail()

    //委托属性

    var email: String

        //访问器从委托类实例获取值

        get() = productEmail.getValue()

        //设置值把值设置进委托类实例

        set(value) = productEmail.setValue(value)

}

当然上面代码是编译不过的，只是说一下委托的实现大致原理。那假如想使ProduceEmail类真的具有这个功能，需要如何实现呢。

by约定

其实我们经常使用 by 关键字它是一种约定，是对啥的约定呢 是对委托类的方法的约定，关于啥是约定，一句话说明白就是简化函数调用，具体可以查看我之前的文章：

# Kotlin invoke约定，让Kotlin代码更简洁

那这里的by约定简化了啥函数调用呢 其实也就是属性的get方法和set方法，当然委托类需要定义相应的函数，也就是下面这2个函数：

//by约定能正常使用的方法

class ProduceEmail(){

    

    private val emails = arrayListOf("111@qq.com")

    

    //对应于被委托属性的get函数

    operator fun getValue(people: People, property: KProperty<*>): String {

        Log.i("zyh", "getValue: 操作的属性名是 ${property.name}")

        return emails.last()

    }



    //对于被委托属性的get函数

    operator fun setValue(people: People, property: KProperty<*>, s: String) {

        emails.add(s)

    }



}

定义完上面委托类，便可以进行委托属性了：

class People{

    val name: String? = null

    var age: Int = 0

    val isAbove18: Boolean = false

    //委托属性

    var email: String by ProduceEmail()

}

然后看一下调用地方：

val people = People()

Log.i("zyh", "onCreate: ${people.email}")

people.email = "222@qq.com"

Log.i("zyh", "onCreate: ${people.email}")

打印如下：

会发现每次调用email属性的访问器方法时，都会调用委托类的方法。

关于委托类中的方法，当你使用by关键字时，IDE会自动提醒，提醒如下：

比如getValue方法中的参数，第一个就是接收者了，你这个要委托的属性是哪个类的，第二个就是属性了，关于KProperty不熟悉的同学可以查看文章：

# Kotlin反射全解析3 -- 大展身手的KProperty

它就代表这属性，可以调用其中的一些方法来获取属性的信息。

而且方法必须使用operator关键字修饰，这是重载操作符的必须步骤，想使用约定，就必须这样干。

by lazy的实现

由前面明白了by的原理，我们接着来看一下我们经常使用的by lazy是个啥，直接看代码：

//这里使用by lazy惰性初始化一个实例

val instance: DataStoreManager by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED) {

    DataStoreManager(store) }

比如上面代码，使用惰性初始化初始了一个实例，我们来看一下这个by的实现：

//by代码

@kotlin.internal.InlineOnly

public inline operator fun <T> Lazy<T>.getValue(thisRef: Any?, property: KProperty<*>): T = value

哦，会发现它是Lazy类的一个扩展函数，按照前面我们对by的理解，它就是把被委托的属性的get函数和getValue进行配对，所以可以想象在Lazy< T >类中，这个value便是返回的值，我们来看一下：

//惰性初始化类

public interface Lazy<out T> {

    

    //懒加载的值，一旦被赋值，将不会被改变

    public val value: T



    //表示是否已经初始化

    public fun isInitialized(): Boolean

}

到这里我们注意一下 by lazy的lazy，这个就是一个高阶函数，来创建Lazy实例的，lazy源码：

//lazy源码

public actual fun <T> lazy(mode: LazyThreadSafetyMode, initializer: () -> T): Lazy<T> =

    when (mode) {

        LazyThreadSafetyMode.SYNCHRONIZED -> SynchronizedLazyImpl(initializer)

        LazyThreadSafetyMode.PUBLICATION -> SafePublicationLazyImpl(initializer)

        LazyThreadSafetyMode.NONE -> UnsafeLazyImpl(initializer)

    }

这里会发现第一个参数便是线程同步的模式，第二个参数是初始化器，我们就直接看一下最常见的SYNCHRONIZED的模式代码：

//线程安全模式下的单例

private class SynchronizedLazyImpl<out T>(initializer: () -> T, lock: Any? = null) : Lazy<T>, Serializable {

    private var initializer: (() -> T)? = initializer

    //用来保存值，当已经被初始化时则不是默认值

    @Volatile private var _value: Any? = UNINITIALIZED_VALUE

    //锁

    private val lock = lock ?: this



    override val value: T

        //见分析1

        get() {

            //第一次判空，当实例存在则直接返回

            val _v1 = _value

            if (_v1 !== UNINITIALIZED_VALUE) {

                @Suppress("UNCHECKED_CAST")

                return _v1 as T

            }

            //使用锁进行同步

            return synchronized(lock) {

                //第二次判空

                val _v2 = _value

                if (_v2 !== UNINITIALIZED_VALUE) {

                    @Suppress("UNCHECKED_CAST") (_v2 as T)

                } else {

                    //真正初始化

                    val typedValue = initializer!!()

                    _value = typedValue

                    initializer = null

                    typedValue

                }

            }

        }



    //是否已经完成

    override fun isInitialized(): Boolean = _value !== UNINITIALIZED_VALUE



    override fun toString(): String = if (isInitialized()) value.toString() else "Lazy value not initialized yet."



    private fun writeReplace(): Any = InitializedLazyImpl(value)

}

分析1：这个单例实现是不是有点眼熟，没错它就是双重校验锁实现的单例，假如你对双重校验锁的实现单例方式还不是很明白可以查看文章：

# Java双重校验锁单例原理 赶快看进来

这里实现懒加载单例的模式就是双重校验锁，2次判空以及volatile关键字都是有作用的，这里不再赘述。

总结

先搞明白by的原理，再理解by lazy就非常好理解了，虽然这些关键字我们经常使用，不过看一下其源码实现还是很舒爽的，尤其是Kotlin的高阶函数的一些SDK写法还是很值的学习。

前沿

页面通用Loading组件是一个App必不可少的基础功能，之前只开发过Android原生的页面Loading，这次就按原生的逻辑再开发一个Flutter的Widget，对其进行封装复用

我们先看下效果：

原理

状态

一个通用的页面加载Loading组件应该具备以下几种状态：

IDLE 初始化

Idle状态，此时的组件还只是初始化

LOADING 加载中

Loading状态，一般在网络请求或者耗时加载数据时调用，通用显示的是一个progress或者自定义的帧动画

LOADING_SUCCESS

LoadingSuccess加载成功，一般在网络请求成功后调用，并将需要展示的页面展示出来

LOADING_SUCCESS_BUT_EMPTY

页面加载成功但是没有数据，这种情况一般是发起列表数据请求但是没有数据，通常我们会展示一个空数据的页面来提醒用户

NETWORK_BLOCKED

网络错误，一般是由于网络异常、网络请求连接超时导致。此时我们需要展示一个网络错误的页面，并且带有重试按钮，让用户重新发起请求

ERROR

通常是接口错误，这种情况下我们会根据接口返回的错误码或者错误文本提示用户，并且也有重试按钮

/// 状态枚举

enum LoadingStatus {

  idle, // 初始化

  loading, // 加载中

  loading_suc, // 加载成功

  loading_suc_but_empty, // 加载成功但是数据为空

  network_blocked, // 网络加载错误

  error, // 加载错误

}

点击事件回调

当网络异常或者接口报错时，会显示错误页面，并且提供重试按钮，让用户点击重新请求。基于这个需求，我们还需要提供点击重试后的事件回调让业务可以处理重新请求。

 /// 定义点击事件

 typedef OnTapCallback = Function(LoadingView widget);

提示文案

提供提示文案的自定义，方便业务根据自己的需求展示特定的提示文案

代码实现

根据上面的原理来实现对应的代码

1. 构造方法

 /// 构造方法

 LoadingView({

    Key key,

    @required this.child, // 需要加载的Widget

    @required this.todoAfterError, // 错误点击重试

    @required this.todoAfterNetworkBlocked, // 网络错误点击重试

    this.networkBlockedDesc = "网络连接超时，请检查你的网络环境",

    this.errorDesc = "加载失败",

    this.loadingStatus = LoadingStatus.idle,

 }) : super(key: key);

2. 根据不同的Loading状态展示对应的Widget

• 其中idle、success状态直接展示需要加载的Widget（这里也可以使用渐变动画进行切换过度）

 ///根据不同状态展示不同Widget

  Widget _buildBody() {

    switch (widget.loadingStatus) {

      case LoadingStatus.idle:

        return widget.child;

      case LoadingStatus.loading:

        return _buildLoadingView();

      case LoadingStatus.loading_suc:

        return widget.child;

      case LoadingStatus.loading_suc_but_empty:

        return _buildLoadingSucButEmptyView();

      case LoadingStatus.error:

        return _buildErrorView();

      case LoadingStatus.network_blocked:

        return _buildNetworkBlockedView();

    }

    return widget.child;

  }

3. buildLoadingView，这里简单用了系统的CircularProgressIndicator，也可以自己显示帧动画

  /// 加载中 View

  Widget _buildLoadingView() {

    return Container(

      width: double.maxFinite,

      height: double.maxFinite,

      child: Center(

        child: SizedBox(

          height: 22.w,

          width: 22.w,

          child: CircularProgressIndicator(

            strokeWidth: 2,

            valueColor: AlwaysStoppedAnimation<Color>(AppColors.primaryBgBlue),

          ),

        ),

      ),

    );

  }

4. 其他提示页面，这里做了一个统一的封装

 /// 编译通用页面

  Container _buildGeneralTapView({

    String url = "images/icon_network_blocked.png",

    String desc,

    @required Function onTap,

  }) {

    return Container(

      color: AppColors.primaryBgWhite,

      width: double.maxFinite,

      height: double.maxFinite,

      child: Center(

        child: SizedBox(

          height: 250.h,

          child: Column(

            children: [

              Image.asset(url,

                  width: 140.w, height: 99.h),

              SizedBox(

                height: 40.h,

              ),

              Text(

                desc,

                style: AppText.gray50Text12,

                maxLines: 2,

                overflow: TextOverflow.ellipsis,

              ),

              SizedBox(

                height: 30.h,

              ),

              if (onTap != null)

                BorderRedBtnWidget(

                  content: "重新加载",

                  onClick: onTap,

                  padding: 40.w,

                ),

            ],

          ),

        ),

      ),

    );

  }

  

    /// 加载成功但数据为空 View

  Widget _buildLoadingSucButEmptyView() {

    return _buildGeneralTapView(

      url: "images/icon_empty.png",

      desc: "暂无数据",

      onTap: null,

    );

  }



  /// 网络加载错误页面

  Widget _buildNetworkBlockedView() {

    return _buildGeneralTapView(

        url: "images/icon_network_blocked.png",

        desc: widget.networkBlockedDesc,

        onTap: () {

          widget.todoAfterNetworkBlocked(widget);

        });

  }



  /// 加载错误页面

  Widget _buildErrorView() {

    return _buildGeneralTapView(

        url: "images/icon_error.png",

        desc: widget.errorDesc,

        onTap: () {

          widget.todoAfterError(widget);

        });

  }

使用

  Widget _buildBody() {

     var loadingView = LoadingView(

      loadingStatus: LoadingStatus.loading,

      child: _buildContent(),

      todoAfterNetworkBlocked: (LoadingView widget) {

        // 网络错误，点击重试

        widget.updateStatus(LoadingStatus.loading);

        Future.delayed(Duration(milliseconds: 1000), () {

          widget.updateStatus(LoadingStatus.error);

        });

      },

      todoAfterError: (LoadingView widget) {

        // 接口错误，点击重试

        widget.updateStatus(LoadingStatus.loading);

        Future.delayed(Duration(milliseconds: 1000), () {

          // widget.updateStatus(LoadingStatus.loading_suc);

          widget.updateStatus(LoadingStatus.loading_suc_but_empty);

        });

      },

    );

     Future.delayed(Duration(milliseconds: 1000), (){

       loadingView.updateStatus(LoadingStatus.network_blocked);

     });

     return loadingView;

  }

总结

至此已经完成了对整个Loading组件的封装，代码已上传Github

背景

在Flutter开发中需要用到视频播放的功能,Flutter对视频播放的支持并不是很友好所以Google提供了TextureLayer让Flutter端能够使用原生端的渲染,这样我们原生端很多优秀的视频播放组件能够在Flutter程序上使用了

Texture的创建

Texture是Platform端创建的,创建是会生成一个textureId,textureId可以映射获取到Texture

• Androaid端FlutterRenderer创建SurfaceTexture

  @Override

  public SurfaceTextureEntry createSurfaceTexture() {

    Log.v(TAG, "Creating a SurfaceTexture.");

    //创建SurfaceTexture

    final SurfaceTexture surfaceTexture = new SurfaceTexture(0);

    surfaceTexture.detachFromGLContext();

    final SurfaceTextureRegistryEntry entry =

        new SurfaceTextureRegistryEntry(nextTextureId.getAndIncrement(), surfaceTexture);

    Log.v(TAG, "New SurfaceTexture ID: " + entry.id());

    // 映射 textureId/entry.id() 和 SurfaceTexture的关系

    registerTexture(entry.id(), entry.textureWrapper());

    return entry;

  }

• Flutter Engine中 platform_view_android_jni_impl.cc

static void RegisterTexture(JNIEnv* env,

                            jobject jcaller,

                            jlong shell_holder,

                            jlong texture_id,

                            jobject surface_texture) {

  ANDROID_SHELL_HOLDER->GetPlatformView()->RegisterExternalTexture(

      static_cast<int64_t>(texture_id),                        //

      fml::jni::JavaObjectWeakGlobalRef(env, surface_texture)  //

  );

}

• android_shell_holder.cc

fml::WeakPtr<PlatformViewAndroid> AndroidShellHolder::GetPlatformView() {

  FML_DCHECK(platform_view_);

  return platform_view_;

}

• platform_view_android.cc

void PlatformViewAndroid::RegisterExternalTexture(

    int64_t texture_id,

    const fml::jni::JavaObjectWeakGlobalRef& surface_texture) {

    //AndroidExternalTextureGL 即 Texture

  RegisterTexture(std::make_shared<AndroidExternalTextureGL>(

      texture_id, surface_texture, std::move(jni_facade_)));

}

• platform_view.cc

void PlatformView::RegisterTexture(std::shared_ptr<flutter::Texture> texture) {

  delegate_.OnPlatformViewRegisterTexture(std::move(texture));

}

• shell.cc

// |PlatformView::Delegate|

void Shell::OnPlatformViewRegisterTexture(

    std::shared_ptr<flutter::Texture> texture) {

  FML_DCHECK(is_setup_);

  FML_DCHECK(task_runners_.GetPlatformTaskRunner()->RunsTasksOnCurrentThread());



  task_runners_.GetRasterTaskRunner()->PostTask(

      [rasterizer = rasterizer_->GetWeakPtr(), texture] {

        if (rasterizer) {

          if (auto* registry = rasterizer->GetTextureRegistry()) {

            registry->RegisterTexture(texture);

          }

        }

      });

}

• texture.cc

void TextureRegistry::RegisterTexture(std::shared_ptr<Texture> texture) {

  if (!texture) {

    return;

  }

  mapping_[texture->Id()] = texture;

}

通过上述流程Flutter Engine层最终会把SurfaceTexture存到mapping_中

Texture的获取

Texture的获取是在Flutter端，通过textureId获取到mapping_中保存的Texture并且创建出一个TextureLayer映射到Flutter framework层

• Flutter端TextureLayer

  @override

  void addToScene(ui.SceneBuilder builder, [ Offset layerOffset = Offset.zero ]) {

    final Rect shiftedRect = layerOffset == Offset.zero ? rect : rect.shift(layerOffset);

    builder.addTexture(

      textureId,

      offset: shiftedRect.topLeft,

      width: shiftedRect.width,

      height: shiftedRect.height,

      freeze: freeze,

      filterQuality: filterQuality,

    );

  }

• SceneBuilder

  void _addTexture(double dx, double dy, double width, double height, int textureId, bool freeze,

      int filterQuality) native 'SceneBuilder_addTexture'; // 调用Engine中的方法

• scene_builder.cc

void SceneBuilder::addTexture(double dx,

                              double dy,

                              double width,

                              double height,

                              int64_t textureId,

                              bool freeze,

                              int filterQualityIndex) {

  auto sampling = ImageFilter::SamplingFromIndex(filterQualityIndex);

  auto layer = std::make_unique<flutter::TextureLayer>(

      SkPoint::Make(dx, dy), SkSize::Make(width, height), textureId, freeze,

      sampling);

  AddLayer(std::move(layer));

}

• texture_layer.cc

//GPU线程绘制时会调用该方法

void TextureLayer::Paint(PaintContext& context) const {

  TRACE_EVENT0("flutter", "TextureLayer::Paint");

  FML_DCHECK(needs_painting(context));



//获取texture_registry中注册好的texture

  std::shared_ptr<Texture> texture =

      context.texture_registry.GetTexture(texture_id_);

  if (!texture) {

    TRACE_EVENT_INSTANT0("flutter", "null texture");

    return;

  }

  texture->Paint(*context.leaf_nodes_canvas, paint_bounds(), freeze_,

                 context.gr_context, sampling_);

}

Texture的使用

Texture是封装的TextureLayer,通过上述流程分析后再来使用TextureLayer就比较简单了,可以通过MethodChannel的方式让Platform端创建一个Texture,最终返回一个textureId到Flutter端，Flutter端通过textureId的映射获取到Flutter Engine层创建好的Texture并包装成一个TextureLayer返回到Flutter framework层。

1. 创建MethodChannel


2. 创建SurfaceTexture


3. 获取textureId创建Texture

以下是以获取摄像头预览为例:

• Android 端示例代码

import android.Manifest;

import android.content.Context;

import android.content.pm.PackageManager;

import android.graphics.SurfaceTexture;

import android.hardware.camera2.CameraAccessException;

import android.hardware.camera2.CameraCaptureSession;

import android.hardware.camera2.CameraDevice;

import android.hardware.camera2.CameraManager;

import android.hardware.camera2.CaptureRequest;

import android.os.Handler;

import android.util.Log;

import android.view.Surface;





import androidx.annotation.NonNull;

import androidx.core.app.ActivityCompat;



import java.util.Arrays;



import io.flutter.embedding.android.FlutterActivity;

import io.flutter.embedding.engine.FlutterEngine;

import io.flutter.plugin.common.MethodChannel;

import io.flutter.view.TextureRegistry;



public class MainActivity extends FlutterActivity {

    public static final String TAG = "MainActivity";

    MethodChannel channel;

    private Handler backgroundHandler;



    @Override

    public void configureFlutterEngine(@NonNull FlutterEngine flutterEngine) {

        super.configureFlutterEngine(flutterEngine);

        backgroundHandler = new Handler();

        channel = new MethodChannel(flutterEngine.getDartExecutor()

                .getBinaryMessenger(), "flutter/texture/channel");



        channel.setMethodCallHandler((call, result) -> {

            switch (call.method) {

                case "createTexture":

                    createTexture(flutterEngine,result);

                    break;

            }

        });

    }



    private void createTexture(FlutterEngine flutterEngine,MethodChannel.Result result) {

        CameraManager cameraManager = (CameraManager) getSystemService(Context.CAMERA_SERVICE);

        if (ActivityCompat.checkSelfPermission(this, Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {

            result.success(-1);

            ActivityCompat.requestPermissions(this,new String[]{Manifest.permission.CAMERA},1);

            return;

        }

        TextureRegistry.SurfaceTextureEntry entry =

                flutterEngine.getRenderer().createSurfaceTexture();

        SurfaceTexture surfaceTexture = entry.surfaceTexture();

        Surface surface = new Surface(surfaceTexture);

        try {

            cameraManager.openCamera(

                    "0",

                    new CameraDevice.StateCallback() {

                        @Override

                        public void onOpened(@NonNull CameraDevice device) {

                            result.success(entry.id());

                            CaptureRequest.Builder previewRequestBuilder = null;

                            try {

                                previewRequestBuilder = device.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);

                                previewRequestBuilder.addTarget(surface);

                                startPreview(result,device,surface,previewRequestBuilder,backgroundHandler);

                            } catch (CameraAccessException e) {

                                e.printStackTrace();

                            }



                        }



                        @Override

                        public void onDisconnected(@NonNull CameraDevice camera) {

                            

                        }



                        @Override

                        public void onError(@NonNull CameraDevice cameraDevice, int errorCode) {

                            Log.i(TAG, "open | onError");

                            result.success(-1);

                        }

                    },

                    backgroundHandler);

        } catch (CameraAccessException e) {

            e.printStackTrace();

        }





    }



    private void startPreview(MethodChannel.Result result,CameraDevice device, Surface surface, CaptureRequest.Builder previewRequestBuilder, Handler backgroundHandler) {

        try {

            device.createCaptureSession(Arrays.asList(surface), new CameraCaptureSession.StateCallback() {

                @Override

                public void onConfigured(@NonNull CameraCaptureSession session) {

                    Log.i(TAG, "startPreview");

                    try {

                        session.setRepeatingRequest(previewRequestBuilder.build(),null,backgroundHandler );

                    } catch (CameraAccessException e) {

                        e.printStackTrace();

                    }

                }



                @Override

                public void onConfigureFailed(@NonNull CameraCaptureSession session) {

                    Log.i(TAG, "startPreview Failed");

                }

            },backgroundHandler);

        } catch (CameraAccessException e) {

            e.printStackTrace();

        }

    }

}

• Flutter端示例代码

import 'package:flutter/material.dart';

import 'package:flutter/services.dart';



MethodChannel methodChannel = MethodChannel('flutter/texture/channel');



void main() {

  runApp(MyApp());

}



class MyApp extends StatelessWidget {

  // This widget is the root of your application.

  @override

  Widget build(BuildContext context) {

    return MaterialApp(

      title: 'Flutter Demo',

      theme: ThemeData(

        primarySwatch: Colors.blue,

      ),

      home: MyHomePage(title: 'Flutter Demo Home Page'),

    );

  }

}



class MyHomePage extends StatefulWidget {

  MyHomePage({Key? key, required this.title}) : super(key: key);

  

  final String title;

  @override

  _MyHomePageState createState() => _MyHomePageState();

}



class _MyHomePageState extends State<MyHomePage> {

  int _counter = 0;

  int textureId = -1;



  Future<void> _createTexture() async {

    print('textureId = $textureId');

    if (textureId < 0) {

      methodChannel.invokeMethod('createTexture').then((value) {

        textureId = value;

        setState(() {

          print('textureId ==== $textureId');

        });

      });

    }



  }



  @override

  Widget build(BuildContext context) {



    return Scaffold(

      appBar: AppBar(

        title: Text(widget.title),

      ),

      body: Center(

        child: Column(

          mainAxisAlignment: MainAxisAlignment.center,

          children: <Widget>[

            if (textureId > -1)

              Container(

                width: 300,

                height: 400,

                child: Texture(

                  textureId: textureId,

                ),

              )

          ],

        ),

      ),

      floatingActionButton: FloatingActionButton(

        onPressed: _createTexture,

        tooltip: 'createTexture',

        child: Icon(Icons.add),

      ), 

    );

  }

}

上述代码在Android并未创建View，而是创建了SurfaceTexture与camera绑定后通过Texture的形式在Flutter端显示

Texture和PlatformView的区别

PlatformView是Flutter中嵌套Platform中的View,如:TextView。它们的区别在Texture是渲染层的东西，而PlatformView本质是一个View它拥有View所有的属性。

总结

本文通过源码分析以及简单的摄像头预览示例讲解了Flutter外接纹理的原理和使用方式，希望能够帮助部分刚接触Flutter开发的同学加深对Flutter外接纹理的认识。