Android 12以上加入了SplashScreen，并且支持开屏动画了！因此我在【小鹅事务所】项目中加入了一个开屏动画，如下（为方便动图展示，我故意延长了几秒钟）：

SplashScreen

简单介绍一下SplashScreen，仅在冷启动或者温启动的时候会展示SplashScreen，支持VAD动画、帧动画。我就先使用帧动画实现这个开屏动画，后面会考虑换成VAD动画。关于SplashScreen具体就不细讲啦，我讲这些讲不明白，没有官方文档讲得好，直接进入实战！！

注意裁切

ICON在设计的时候只能够占用三分之二大小的圆，超出这部分的会被裁切掉，所以这点需要注意！

设计

首先打开UI设计软件，我此处用Figma，新建一个方形的框框，方形的框框里面整一个三分二大小的圆圈，像这样。

然后呢，就把设计好的Icon放进去

这个时候一张静态图就做好啦，但是帧动画需要让图片动起来的话，就需要多张静态图。怎么设计它动起来呢？我的思路是让它扭头！像这样。

然后再把框框的颜色隐藏掉，我们只需要透明背景的Icon

注意，为了展示外边需要留空间，我给它们的框框加上描边，实际不需要！这个时候就可以导出图片啦，我这边选择导出矢量图，也就是SVG格式。

导入动画

打开Android Studio，右键点击res → new → Vector Asset，再导入图片，将静态图都导进去就可以做动画啦。

新建anim_little_goose.xml，根标签是animation-list，并在里面放4个item。

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

<animation-list xmlns:android="http://schemas.android.com/apk/res/android"

    android:oneshot="false">

    <item

        android:drawable="@drawable/ic_little_goose"

        android:duration="50" />

    <item

        android:drawable="@drawable/ic_little_goose_back"

        android:duration="150" />

    <item

        android:drawable="@drawable/ic_little_goose"

        android:duration="50" />

    <item

        android:drawable="@drawable/ic_little_goose_fore"

        android:duration="150" />

</animation-list>

根据命名可以看出

• 
  

  第一帧为正常的小鹅，展示50毫秒

  
  


• 
  

  第二帧为向后扭头的小鹅，展示150毫秒

  
  


• 
  

  第三帧为正常的小鹅，展示50毫秒

  
  


• 
  

  第四帧为向前扭头的小鹅，展示150毫秒

  
  

一次循环就是400毫秒，点开Split界面，就能在右边预览动画了，这个时候，动画就简简单单做好了。

SplashScreen

引入依赖

由于SplashScreen是Android12以上才有的，而Android12以下需要适配，但是！Jetpack提供了同名适配库，去gradle引用就好了。

//SplashScreen

implementation 'androidx.core:core-splashscreen:1.0.0'

设置开屏主题

然后在res/values/themes中新建一个style标签，并将其父标签设为Theme.SplashScreen，需要注意的是，如果适配了黑夜模式的话，也可以在values-night/themes文件下单独配置。

<style name="Theme.AppSplashScreen" parent="Theme.SplashScreen">

    <item name="windowSplashScreenBackground">@color/primary_color</item>

    <item name="windowSplashScreenAnimatedIcon">@drawable/anim_little_goose</item>

    <item name="windowSplashScreenAnimationDuration">3000</item>

    <item name="postSplashScreenTheme">@style/Theme.Account</item>

</style>

我这边配置一个无ICON背景的动画，因此不用windowSplashScreenIconBackgroundColor标签设置ICON背景。

简单介绍一下我设置的4个标签

• 
  

  windowSplashScreenBackground设置整个开屏动画的背景颜色。

  
  


• 
  

  windowSplashScreenAnimatedIcon设置的是开屏动画播放的动画文件，也就是上面写的动画文件。

  
  


• 
  

  windowSplashScreenAnimationDuration设置的是动画的播放时长，也就是说小鹅抖三秒钟头就会停止播放。

  
  


• 
  

  postSplashScreenTheme这个设置的是开屏动画播放完需要回到的主题，此处设置了我的主题。

  
  

  <style name="Theme.Account" parent="Theme.MaterialComponents.DayNight.NoActionBar">
  
  ...
  
  </style>
  

  
  

在Manifest注册

    <application

        android:label="@string/app_name"

        ...

        android:theme="@style/Theme.Account">

        

        ...

        <activity

            android:name=".ui.MainActivity"

            android:theme="@style/Theme.AppSplashScreen"

            android:exported="true">

            <intent-filter>

                <action android:name="android.intent.action.MAIN" />

                

                <category android:name="android.intent.category.LAUNCHER" />

            </intent-filter>

        </activity>

        

    </application>

可以看到在打开应用打开的第一个Activity，即MainActivity中设置了开屏主题，而在Application中设置了自己的主题。在Application设置主题的话，这个Application中的除了特殊设置Theme的Activity，其它都默认使用Application主题。

去MainActivity吧！

class MainActivity : BaseActivity() {



    private val binding by viewBinding(ActivityMainBinding::inflate)



    override fun onCreate(savedInstanceState: Bundle?) {

        val splashScreen = installSplashScreen()

        splashScreen.setKeepOnScreenCondition { !isAppInit }

        super.onCreate(savedInstanceState)

        initView()

    }   

    ...



}

重写onCreate函数，并在调用super.onCreate之前加载SplashScreen，即调用installSplashScreen，获得一个splashScreen实例，理论上来说调用installSplashScreen函数已经可以实现开屏动画了，可是我想等到一部分数据加载完再进入APP怎么办？

可以看到我调用了setKeepOnScreenCondition 函数，传入一个接口，这个接口返回一个Boolean值，如果返回true则继续展示开屏，如果返回false则进入APP。而此函数在每次绘制之前都会调用，是主线程调用的，因此不能在这里处理太多东西阻塞主线程！

我这边就设置了一个顶层变量，每次都去看看这个顶层变量的值，不会阻塞主线程。

class AccountApplication : Application() {



    val supervisorScope = CoroutineScope(SupervisorJob() + Dispatchers.IO)

    

    //初始化数据 防止第一次打开还要加载

    private fun initData() {

        supervisorScope.launch {

            val initIconDataDeferred = async { TransactionIconHelper.initIconData() }

            val initTransactionDeferred = async { TransactionHelper.initTransaction() }

            val initScheduleDeferred = async { ScheduleHelper.initSchedule() }

            val initNoteDeferred = async { NoteHelper.initNote() }

            val initMemorialsDeferred = async { MemorialHelper.initMemorials() }

            val initTopMemorialDeferred = async { MemorialHelper.initTopMemorial() }

            val initDataStoreDeferred = async { DataStoreHelper.INSTANCE.initDataStore() }

            initIconDataDeferred.await()

            initTransactionDeferred.await()

            initScheduleDeferred.await()

            initNoteDeferred.await()

            initMemorialsDeferred.await()

            initTopMemorialDeferred.await()

            initDataStoreDeferred.await()

            isAppInit = true

        }

    }

}



var isAppInit = false

我在Application中对所有需要初始化的东西先初始化一遍，初始化完之后再将isAppInit设置为true，此时在闪屏那边获取的为false，也就是说就会进入APP了。

到这里就结束了，去运行一下吧！

总结

说实话，在我看来，SplashScreen其实用处不大，因为我们的闪屏一般是用来放advertisement的，而不是放有趣的动画的！

参考

SplashScreen: developer.android.google.cn/develop/ui/…

简介

APT(Annotation Processing Tool)即注解处理器，在编译的时候可以处理注解然后搞一些事情，也可以在编译时生成一些文件之类的。ButterKnife和EventBus都使用了APT技术，如果不会APT技术就很难看懂这两个框架的源码。

作用

使用APT可以在编译时来处理编译时注解，生成额外的Java文件，有如下效果：

• 可以达到减少重复代码手工编写的效果。

如ButterKnife，我们可以直接使用注解来减少findviewbyid这些代码，只需要通过注解表示是哪个id就够了。

• 功能封装。将主要的功能逻辑封装起来，只保留注解调用。


• 相对于使用Java反射来处理运行时注解，使用APT有着更加良好的性能。

Android基本编译流程

Android中的代码编译时需要经过：Java——>class ——> dex 流程，代码最终生成dex文件打入到APK包里面。

编译流程如图所示：

• APT是在编译开始时就介入的，用来处理编译时注解。


• AOP（Aspect Oridnted Programming）是在编译完成后生成dex文件之前，通过直接修改.class文件的方式，来对代码进行修改或添加逻辑。常用在在代码监控，代码修改，代码分析这些场景。

基本使用

基本使用流程主要包括如下几个步骤：

1. 创建自定义注解


2. 创建注解处理器，处理Java文件生成逻辑


3. 封装一个供外部调用的API


4. 项目中调用

整理思路

1. 首先我们需要创建两个JavaLibrary


2. 一个用来定义注解，一个用来扫描注解


3. 获取到添加注解的成员变量名


4. 动态生成类和方法用IO生成文件

实战

创建一个空项目

创建两个JavaLibrary

• 注解的Lib: apt-annotation


• 扫描注解的Lib: apt-processor

创建完之后

app模块依赖两个Library

implementation project(path: ':apt-annotation')

annotationProcessor project(path: ':apt-processor')

注解Lib中创建一个注解类

如果还不会自定义注解的同学，可以先去看我之前写的一篇Java自定义注解入门到实战

@Retention(RetentionPolicy.CLASS)

@Target(ElementType.FIELD)

public @interface Print {



}

扫描注解的Lib添加依赖

dependencies {

    //自动注册，动态生成 META-INF/...文件

    implementation 'com.google.auto.service:auto-service:1.0-rc6'

    annotationProcessor 'com.google.auto.service:auto-service:1.0-rc6'

    //依赖apt-annotation

    implementation project(path: ':apt-annotation')

}

创建扫描注解的类

重写init方法，输出Hello,APT

注意: 这里是JavaLib，所以不能使用Log打印，这里可以使用Java的println()或注解处理器给我们提供的方法，建议使用注解处理器给我们提供的

现在我们已经完成了APT的基本配置，现在我们可以build一下项目了，成败在此一举

如果你已经成功输出了文本，说明APT已经配置好，可以继续下一步了

继续完成功能

现在我们可以继续完成上面要实现的功能了，我们需要先来实现几个方法

/**

 * 要扫描扫描的注解，可以添加多个

 */

@Override

public Set<String> getSupportedAnnotationTypes() {

    HashSet<String> hashSet = new HashSet<>();

    hashSet.add(Print.class.getCanonicalName());

    return hashSet;

}



/**

 * 编译版本，固定写法就可以

 */

@Override

public SourceVersion getSupportedSourceVersion() {

    return processingEnv.getSourceVersion();

}

定义注解

我们先在MianActivity中添加两个成员变量并使用我们定义的注解

定义注解

真正解析注解的地方是在process方法，我们先试试能不能拿到被注解的变量名

/**

 * 扫描注解回调

 */

@Override

public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {

    //拿到所有添加Print注解的成员变量

    Set<? extends Element> elements = roundEnv.getElementsAnnotatedWith(Print.class);

    for (Element element : elements) {

        //拿到成员变量名

        Name simpleName = element.getSimpleName();

        //输出成员变量名

        processingEnv.getMessager().printMessage(Diagnostic.Kind.NOTE,simpleName);

    }

    return false;

}

编译试一下

生成类

既然能拿到被注解的变量名，后面就简单了，我们只需要用字符串拼出来一个工具类，然后用IO流写到本地就ok了

查看效果

现在点击一下编译，然后我们可以看到app模块下的build文件已经有我们生成的类了

调用方法

现在我们回到MainActivity，就可以直接调用这个动态生成的类了

总结

优点：

它可以做任何你不想做的繁杂的工作，它可以帮你写任何你不想重复代码，将重复代码抽取出来，用AOP思想去编写。 它可以生成任何java代码供你在任何地方使用。

难点：

在于设计模式和解耦思想的灵活应用。在于代理类代码生成的繁琐：你可以手动进行字符串拼接，也可以用squareup公司的javapoet库来构建出任何你想要的java代码。

一位组员遇到一个问题，几个同事都没能帮忙解决，我在这边就开门见山直接描述当时他遇到的问题。他在 forEach 处理了异步，但是始终不能顺序执行，至此想要的数据怎么都拿不到，组员绞尽脑汁，不知道问题发生在哪里。此篇文章我们就来探究下 forEach 循环下处理异步会发生什么样的情况。

探索

我们先看一段简单的 forEach 处理异步的代码

//forEach 处理
let promiseTasek = (num) => {
	return new Promise((resolve, rejece) => {
		setTimeout(() => {
			console.log(num)
			resolve(true)
                }, 4000)
	})
}
function toTaskByForEach() {
	const arr = [1, 2, 3, 4, 5, 6]
	arr.forEach(async (item) => {
		await promiseTasek(item)
	})
}
		
toTaskByForEach()

执行结果 注意执行输出的变化，他会直接打印出 1,2,3,4,5,6 本来想录制一个 gif 的，确实没找到一个好的工具录制浏览器的控制台

我们尝试换一种循环 for of 看一下效果对比一下

let promiseTasek = (num) => {
	return new Promise((resolve, rejece) => {
		setTimeout(() => {
			console.log(num)
			resolve(true)
                }, 4000)
	})
}

async function toTaskByForOf(){
    const arr = [1,2,3,4,5,6]
    for (let i of arr) {
	await promiseTasek(i)			
    }
}
toTaskByForOf()

来看下执行结果 他会按顺序执行依次打印出 1,2,3,4,5,6

所以这是为啥呢

后来我们研究了一下 map

//forEach 处理
let promiseTasek = (num) => {
	return new Promise((resolve, rejece) => {
		setTimeout(() => {
			console.log(num)
			resolve(true)
                }, 4000)
	})
}
function toTaskByMap() {
	const arr = [1, 2, 3, 4, 5, 6]
	arr.map(async (item) => {
		await promiseTasek(item)
	})
}
		
toTaskByMap()

前言

起因是我在开发功能需要使用Bitmap的方法：

BitmapFactory.decodeResource(my.main.getResources(),R.drawable.vector_my_need);

结果就倒大霉，运行时直接报错：

java.lang.NullPointerException: Attempt to invoke virtual method 'boolean android.graphics.Bitmap.isRecycled()' on a null object reference

从日志分析，我们知道是出现了空指针，当时我先是想自己找原因，结果定位到view的源代码里，是在draw方法中，但没找到，我还没放弃，于是又定位了updateDisplayListIfDirty（） 方法以及其他报错对应点，于是终于发现了是我bitmap的使用出了问题：

找到问题固然是好事，可是如何解决呢？这就要靠搜索了，接下来让我们看看解决方法。

正篇

正确的搜索方法

其实我在搜索上吃了许多亏，一开始在国内搜索上一直给我推C站的结果虽然有点相似但其实都相差甚远，最后我在StackOverflow上找到了答案，这也是曾经让别人困惑的一个问题：

可以看到有31K人浏览过此问题，所以该问题早有认可的答案：

意思说，我们用的vector矢量可绘制对象需要创建位图，而不是对其进行解码，且方法在下一个帖子中。

完美的解决方案

其实说到这，我已经明白，是我用SVG图资源放到安卓项目中转成Vector的xml文件，这种文件解码无法获得正确的bitmap,于是我恍然大悟的点开了下个帖子：

我为这个标准答案标记了中文解释，给出的是将我们的vector资源实例成Drawable对象，然后通过Bitmap的创建方法去创建成一个新的bitmap,代码如下：

Drawable d = getResources().getDrawable(R.drawable.your_drawable, your_app_theme);

这一步就是变成Drawable对象，接下来：

public static Bitmap drawableToBitmap (Drawable drawable) {



    if (drawable instanceof BitmapDrawable) {

        return ((BitmapDrawable)drawable).getBitmap();

    }



    Bitmap bitmap = Bitmap.createBitmap(drawable.getIntrinsicWidth(), drawable.getIntrinsicHeight(), Config.ARGB_8888);

    Canvas canvas = new Canvas(bitmap); 

    drawable.setBounds(0, 0, canvas.getWidth(), canvas.getHeight());

    drawable.draw(canvas);



    return bitmap;

}

这段代码是将Drawable对象转换成Bitmap封装成了工具方法，便于直接应用于主代码。

而方法内部，也分成两层：

首先第一层，我们用instanceof测试它左边的对象是否是它右边的类的实例，如果是真命题则直接返回强制转成BitmapDrawable，并直接调用它的getBitmap()方法即可。

而如果第一层没有成功，则由第二层处理，我们先实例化Bitmap对象，利用Bitmap的createBitmap()方法输入drawable对象的固有宽高和BItmap通道配置获取bitmap

然后调用canvas绘制bitmap,最后先用drawable的setBounds()方法为Drawable对象指定一个边界矩形，这是为了调用 draw() 方法前可以确定绘制对象将绘制的位置，接着用draw()方法完成绘制，返回最终的bitmap即完成。

结语

这还是我第一次这么容易就获取到了明确的正确解决方案，所以特地记录下来，当然，如果你出现了这个空指针就不需要去看英文结果了，让我们更方便的解决这个问题吧。

背景

在kotlin语言已经渗透至各领域的环境下，比如服务端，android，跨平台Kmm，native for kotlin，几乎所有的领域都可以用kotlin去编写了，当然还有不成熟的地方，但是JB的目标是很一致的！我们最常用的gradle构建工具，也支持kotlin好久了，但是由于编译速度或者转换成本的原因，真正实现kts转换的项目很少。在笔者的mac m1 中使用最新版的AS去编译build.gradle.kts，速度已经是和用groovy写的gradle脚本不相上下了，所以就准备写了这篇文章，希望做一个记录与分享。

虽然主流的gradle脚本编写依旧是groovy，但是android开发者官网也在推荐迁移到kotlin

编译前准备

这里推荐看看这篇文章，里面也涵盖了很多干货，

全局替换‘’为“”

在kotlin中，表示一个字符串用“”，不同于groovy的‘ ’，所以我们需要全局替换。可以通过快捷方式command/control+shift+R 全局替换，选中匹配正则表达式并设定file mask 为 *.gradle：

正则表达式

'(.*?[^\\])'

作用范围为

"$1"

全局替换方法调用

在groovy中，方法是可以隐藏（），举个例子

apply plugin: "com.android.application"

这里实际上是调用apply方法，然后命名参数是plugin，内容围为"com.android.application",然而在kotlin语法中，我们需要以（）或者invoke的方式才能调用一个方法，所以我们要给所有的groovy函数调用添加（）

正则表达式

(\w+) (([^=\{\s]+)(.*))

作用范围为

$1($2)

很遗憾的是，这个对于多行来说还是存在不足的，所以我们全局替换后还需要手动去修正部分内容即可，这里我们只要记得一个原则即可，想要调用一个kotlin函数，把参数包裹在（）内即可,比如调用一个task函数，那么参数即为

task(sourcesJar(type: Jar) {

    from(android.sourceSets.main.java.srcDirs)

    classifier = "sources"

})

gradle kt化

接下来我们只需要把build.gradle 更改为文件名称为build.gradle.kts 即可,由于我们修改文件为了build.gradle.kts,所以当前就以kts脚本进行编译，所以很多的参数都是处于找不到状态的，即使sync也会报错，所以我们需要把报错的地方先注释掉，然后再进行sync操作，如果成功的话，AS就会帮我们进行一次编译，此时就可以有代码提示了。

开始前准备

以kotlin的方式编译，此时函数就处于可点击查看状态，区别于groovy，因为groovy是动态类型语言，所以很多做了很多语法糖，但是也给我们在debug阶段带来了很多困难，比如没有提示等等，因为groovy只需要保证在运行时找到函数即可，而kotlin却不一样，所以很多动态生成的函数就无法在编译时直接使用了，比如

对于这种动态函数，kotlin for gradle 其实也给我们内置了很多参数来对应着groovy的动态函数，下面我们来从以下方面去实践吧，tip：以下是gradle脚本编写常用

ext

我们在groovy脚本中，可以定义额外的变量在ext{}中，那么这个在kotlin中可以使用吗？嘿嘿，能用我就不会提到对吧！对的，不可以，因为ext也是一个动态函数，我们kotlin可没法用呀！那怎么办！别怕，kts中给我们定义了一个类似的变量，即extra，我们可以通过by extra去定义，然后就可以自由用我们的myNewProperty变量啦！

val myNewProperty by extra("initial value")

但是，如果我们在其他的gradle.kts脚本中用myNewProperty这个变量，那么也会找不到，因为myNewProperty这个的作用域其实只在当前文件中，确切来说是我们的build.gradle 最后会被编译生成一个Build_Init的类，这个类里面的东西能用的前提是，被先编译过！如果当前编译中的module引用了未被编译的module的变量，这当然不可行啦！当然，还是有对策的，我们可以在BuildScr这个module中定义自定义的函数，因为BuildScr这个module被定义在第一个先执行的module，所以我们后面的module就可以引用到这个“第一个module”的变量的方式去引用自定义的变量！

task

• 新建task

groovy版本



task clean(type: Delete) {

    delete rootProject.buildDir

}

比如clean就是一个我们自定义的task，转换为kotlin后其实也很简单，task是一个函数名，Delete是task的类型，clean是自定义名称

task("clean",{

    delete(rootProject.buildDir)

})

当然，我们的task类型可能在编写的由于泛型推断，隐藏了具体的类型，这个时候我们可以通过

 ./gradlew help --task task名

去查看相应的类型

• 已有task修改
  对于有些是已经在gradle编译时存在的函数任务，比如

groovy版本



wrapper{

       gradleVersion = "7.1.1"

       distributionType = Wrapper.DistributionType.BIN

   }

这个我们kotlin版本的build.gradle能不能识别呢？其实是不可以的，因为编译器也不知道从哪里去找wrapper的定义，因为这个函数在groovy中隐藏了作用域，其实它存在于TaskContainerScope这个作用域中，所以对于所有的的task，其实都是执行在这里面的，我们可以通过tasks去找到

tasks {

    named("wrapper") {

            gradleVersion = "7.1.1"

            distributionType = Wrapper.DistributionType.BIN



    }

}

这种方式，去找到一个我们想要的task，并配置其内容

• 生命周期函数
  我们可以通过函数调用的方式去配置相应的生命周期函数，比如doLast

tasks.create("greeting") {

    doLast { println("Hello, World!") }

}

再比如dependOn

task("javadocJar", {

    dependsOn(tasks.findByName("javadoc"))

})

动态函数

sourceSets就是一个典型的动态函数，为什么这么说，因为很多plugin都有自己的设置，比如Groovy的sourceSets，再比如Android的SourceSets，它其实是一个接口，正在实现其实是在plugin中。如果我们需要自定义配置一些东西，比如配置jniLibs的libs目录，直接迁移到kts就会出现main找不到的情况，这里是因为main不是一个内置的函数，但是存在相应的成员，这个时候我们可以通过by getting方式去获取，只要我们的变量在作用域内是存在的（编译阶段会添加），就可以获取到。如果我们想要生成其他成员，也可以通过by creating{}方式去生成一个没有的成员

sourceSets{

    val main by getting{

        jniLibs.srcDirs("src/main/libs")

        jni.srcDirs()

    }



}

也可以通过getByName方式去获取

sourceSets.getByName("main")

plugins

在比较旧的版本中，我们AS默认创建引入一个plugin的方式是

apply plugin: 'com.android.application'

其实这也是依赖了groovy的动态编译机制，这里针对的是，比如android{}作用域，如果我们转换成了build.gradle.kts，我们会惊讶的发现，android{}这个作用域居然爆红找不到了！这个时候我们需要改写成

plugins {

    id("com.android.application")

}

就能够找到了，那么这背后的原理是什么呢？我们有必要去探究一下gradle的内部实现。

说了这么多的应用层写法，了解我的小伙伴肯定知道，原理解析肯定是放在最后啦！但是gradle是一个庞大的工程，单单靠着干唠是写不完的，所以我选出了最重要的一个例子，即plugins的解析，希望能够抛砖引玉，一起学习下去吧！

Plugins解析

我们可以通过在gradle文件中设置断点，然后debug运行gradle调试来学习gradle，最终在编译时，我们会走到DefaultScriptPluginFactory中进行相应的任务生成，我们来看看

DefaultScriptPluginFactory

            final ScriptTarget initialPassScriptTarget = initialPassTarget(target);



            ScriptCompiler compiler = scriptCompilerFactory.createCompiler(scriptSource);



            // 第一个阶段Pass 1, extract plugin requests and plugin repositories and execute buildscript {}, ignoring (i.e. not even compiling) anything else

            CompileOperation initialOperation = compileOperationFactory.getPluginsBlockCompileOperation(initialPassScriptTarget);

            Class scriptType = initialPassScriptTarget.getScriptClass();

            ScriptRunner initialRunner = compiler.compile(scriptType, initialOperation, baseScope, Actions.doNothing());

            initialRunner.run(target, services);



            PluginRequests initialPluginRequests = getInitialPluginRequests(initialRunner);

            PluginRequests mergedPluginRequests = autoAppliedPluginHandler.mergeWithAutoAppliedPlugins(initialPluginRequests, target);



            PluginManagerInternal pluginManager = topLevelScript ? initialPassScriptTarget.getPluginManager() : null;

            pluginRequestApplicator.applyPlugins(mergedPluginRequests, scriptHandler, pluginManager, targetScope);



            // 第二个阶段Pass 2, compile everything except buildscript {}, pluginManagement{}, and plugin requests, then run

            final ScriptTarget scriptTarget = secondPassTarget(target);

            scriptType = scriptTarget.getScriptClass();



            CompileOperation operation = compileOperationFactory.getScriptCompileOperation(scriptSource, scriptTarget);



            final ScriptRunner runner = compiler.compile(scriptType, operation, targetScope, ClosureCreationInterceptingVerifier.INSTANCE);

            if (scriptTarget.getSupportsMethodInheritance() && runner.getHasMethods()) {

                scriptTarget.attachScript(runner.getScript());

            }

            if (!runner.getRunDoesSomething()) {

                return;

            }



            Runnable buildScriptRunner = () -> runner.run(target, services);



            boolean hasImperativeStatements = runner.getData().getHasImperativeStatements();

            scriptTarget.addConfiguration(buildScriptRunner, !hasImperativeStatements);

        }



       

可以看到，源码中特别注释了，编译时的两个阶段，我们可以看到，所有的script（指函数调用），都是分别经过了阶段1和阶段2之后才真正生效的。

那么为什么android作用域在apply plugin的方式不行，plugins方式却可以呢？其实就是两个运行阶段不一致的问题。groovy可以在运行时动态找到android 这个函数，即使两者都在阶段2运行，因为groovy语法本身的特性，即使android这个函数没有定义我们也可以引用，也是在运行时阶段报错。而kotlin不一样，kotlin需要在编译的时候需要找到我们要引用的函数，即android，所以同一个阶段即plugin都没有生效（需要执行完阶段才生效），我们当然也找不到android函数，那为什么plugins又可以呢？其实很容易想到，因为plugins是在第一阶段中执行并生效的，而android引用在第二个阶段，我们接着看源码

重点关注一下compileOperationFactory.getPluginsBlockCompileOperation方法，这个方法的实现类是DefaultCompileOperationFactory，在这里我们可以看到里面定义了两个阶段

public class DefaultCompileOperationFactory implements CompileOperationFactory {

    private static final StringInterner INTERNER = new StringInterner();

    private static final String CLASSPATH_COMPILE_STAGE = "CLASSPATH";

    private static final String BODY_COMPILE_STAGE = "BODY";



    private final BuildScriptDataSerializer buildScriptDataSerializer = new BuildScriptDataSerializer();

    private final DocumentationRegistry documentationRegistry;



    public DefaultCompileOperationFactory(DocumentationRegistry documentationRegistry) {

        this.documentationRegistry = documentationRegistry;

    }



    public CompileOperation getPluginsBlockCompileOperation(ScriptTarget initialPassScriptTarget) {

        InitialPassStatementTransformer initialPassStatementTransformer = new InitialPassStatementTransformer(initialPassScriptTarget, documentationRegistry);

        SubsetScriptTransformer initialTransformer = new SubsetScriptTransformer(initialPassStatementTransformer);

        String id = INTERNER.intern("cp_" + initialPassScriptTarget.getId());

        return new NoDataCompileOperation(id, CLASSPATH_COMPILE_STAGE, initialTransformer);

    }



    public CompileOperation getScriptCompileOperation(ScriptSource scriptSource, ScriptTarget scriptTarget) {

        BuildScriptTransformer buildScriptTransformer = new BuildScriptTransformer(scriptSource, scriptTarget);

        String operationId = scriptTarget.getId();

        return new FactoryBackedCompileOperation<>(operationId, BODY_COMPILE_STAGE, buildScriptTransformer, buildScriptTransformer, buildScriptDataSerializer);

    }

}

getPluginsBlockCompileOperation中创建了一个InitialPassStatementTransformer类对象,我们关注transform方法的内容，即如果找到了plugins，我们就进行接下来的transform操作transformPluginsBlock，这就验证了，plugins的确在第一个阶段即classpath阶段运行

    @Override

    public Statement transform(SourceUnit sourceUnit, Statement statement) {

        ...



        if (scriptBlock.getName().equals(PLUGINS)) {

            return transformPluginsBlock(scriptBlock, sourceUnit, statement);

        }

        ...

        

总结

文章列出来了几个关键的迁移了，相信大部分的问题都可以解决了，的确在迁移到kotlin之后，还是存在一定的迁移成本的，大部分就只能生啃官网介绍，希望看完都有收获吧！

🔥 应用场景

Toast提示默认显示在界面底部，使用Toast.setGravity()将提示显示在中间，如下：

        Toast toast = Toast.makeText(this, str, Toast.LENGTH_SHORT);

        toast.setGravity(Gravity.CENTER, 0, 0);

        toast.show();

运行在在Android 12上无法显示，查看Logcat提示如下：

Toast: setGravity() shouldn't be called on text toasts, the values won't be used

意思就是：你不能使用toast调用setGravity，调用无效。哎呀，看给牛气的，咱看看源码找找原因

🔥 源码

💥 Toast.setGravity()

    /**

     * 设置Toast出现在屏幕上的位置。

     *

     * 警告：从 Android R 开始，对于面向 API 级别 R 或更高级别的应用程序，此方法在文本 toast 上调用时无效。

     */

    public void setGravity(int gravity, int xOffset, int yOffset) {

        if (isSystemRenderedTextToast()) {

            Log.e(TAG, "setGravity() shouldn't be called on text toasts, the values won't be used");

        }

        mTN.mGravity = gravity;

        mTN.mX = xOffset;

        mTN.mY = yOffset;

    }

妥了，人家就告诉你了 版本>=Android R(30),调用该方法无效。无效就无效呗，还不给显示了，过分。

Logcat的提示居然是在这里提示的，来都来了，咱们看看isSystemRenderedTextToast()方法。

💥 Toast.isSystemRenderedTextToast()

    /**

     *Text Toast 将由 SystemUI 呈现，而不是在应用程序内呈现，因此应用程序无法绕过后台自定义 Toast 限制。

     */

    @ChangeId

    @EnabledAfter(targetSdkVersion = Build.VERSION_CODES.Q)

    private static final long CHANGE_TEXT_TOASTS_IN_THE_SYSTEM = 147798919L;

    

    private boolean isSystemRenderedTextToast() {

        return Compatibility.isChangeEnabled(CHANGE_TEXT_TOASTS_IN_THE_SYSTEM) && mNextView == null;

    }

重点了。Text Toast 将由 SystemUI 呈现，而不是在应用程序内呈现。

清晰明了，可以这样玩，但是你级别不够，不给你玩。

事情整明白了，再想想解决解决方案。他说了Text Toast 将由 SystemUI 呈现，那我不用 Text 不就行了。

🔥 Toast 提供的方法

先看看Tast提供的方法：

有这几个方法。咱们实践一下。保险起见看看源码

💥 Toast.setView() 源码

    /**

     * 设置显示的View

     * @deprecated 自定义 Toast 视图已弃用。 应用程序可以使用 makeText 方法创建标准文本 toast，

     * 或使用 Snackbar

     */

    @Deprecated

    public void setView(View view) {

        mNextView = view;

    }

这个更狠，直接弃用。

• 
  

  要么老老实实的用默认的Toast。

  
  


• 
  

  要么使用 Snackbar。

  
  

🔥 Snackbar

Snackbar 就是一个类似Toast的快速弹出消息提示的控件(我是刚知道，哈哈)。

与Toast相比：

• 
  

  一次只能显示一个

  
  


• 
  

  与用户交互

  
  
  
  
  • 在右侧设置按钮来添加事件，根据 Material Design 的设计原则，只显示 1 个按钮 (添加多个,以最后的为准)
  
  
  
  


• 
  

  提供Snackbar显示和关闭的监听事件

  
  
  
  
  • BaseTransientBottomBar.addCallback(BaseCallback)
  
  
  
  

💥 代码实现

    showMessage(findViewById(android.R.id.content), str, Snackbar.LENGTH_INDEFINITE);

  

    public static void showMessage(View view, String str, int length) {

        Snackbar snackbar = Snackbar.make(view, str, length);



        View snackbarView = snackbar.getView();

        //设置布局居中

        FrameLayout.LayoutParams params = new FrameLayout.LayoutParams(snackbarView.getLayoutParams().width, snackbarView.getLayoutParams().height);

        params.gravity = Gravity.CENTER;

        snackbarView.setLayoutParams(params);

        //文字居中

        TextView message = (TextView) snackbarView.findViewById(R.id.snackbar_text);

        //View.setTextAlignment需要SDK>=17

        message.setTextAlignment(View.TEXT_ALIGNMENT_GRAVITY);

        message.setGravity(Gravity.CENTER);

        message.setMaxLines(1);

        snackbar.addCallback(new BaseTransientBottomBar.BaseCallback<Snackbar>() {

            @Override

            public void onDismissed(Snackbar transientBottomBar, int event) {

                super.onDismissed(transientBottomBar, event);

                //Snackbar关闭

            }



            @Override

            public void onShown(Snackbar transientBottomBar) {

                super.onShown(transientBottomBar);

                //Snackbar显示

            }

        });

        snackbar.setAction("取消", new View.OnClickListener() {

            @Override

            public void onClick(View v) {

                //显示一个默认的Snackbar。

                Snackbar.make(view, "我先走", BaseTransientBottomBar.LENGTH_LONG).show();

            }

        });

        snackbar.show();

    }

Snackbar.make的三个参数：

• View：从View中找出当前窗口最外层视图，然后在其底部显示。


• 第二个参数(text)：
  
  
  
  • CharSequence
  
  
  • StringRes
  
  
  
  


• duration(显示时长)
  
  
  
  • Snackbar.LENGTH_INDEFINITE 从 show()开始显示,直到它被关闭或显示另一个 Snackbar。
  
  
  • Snackbar.LENGTH_SHORT 短时间
  
  
  • Snackbar.LENGTH_LONG 长时间
  
  
  • 自定义持续时间 以毫秒为单位
  
  
  
  

💥 效果

Android 12

Android 5.1

💥 工具类

如果觉得设置麻烦可以看看下面这边文章，然后整合一套适合自己的。

一行代码搞定Snackbar

又到了小技巧系列更新时间，今天我们分享一个比较轻松的内容：Flutter 里的代码优化，优化的目的主要是为了提高性能和可维护性，放心，本篇我们不讲深入的源码分析，就是分享最最最基础的布局代码优化。

我们先从一个简单的例子开始，相信大家对于 Flutter 的 UI 构建不会陌生，那么如下代码所示，日常开发过程中 A 和 B 这两种代码组织方式，你更常用的是哪一种？

A （函数方式）	B （Component Class 方式）

如果是从代码运行之后的 UI 效果来看，这两个方式运行之后的布局效果并不会有什么差异，而通常因为可以写更少代码和参数调用更方便等原因，我们可能在编写页面的内部控件时，会更经常使用 A （函数方式） 这种写法，也有称之为 Helper Method 的叫法。

那使用函数方式构建 UI 有没有问题？答案肯定是没问题，但是某些场景下，对比使用 B （Component Class 方式） ，可能性能表现上相对没那么优秀。

举个例子，如下代码所示，在 renderA 函数里我们通过点击按键修改 count，在修改之后触发 UI 渲染时就需要用到 setState ，也就是我们每点一下，当前整个页面就是触发一次 rebuild ，但是我们只是想要改变当前 renderA 里的 count 文本而已。

这就是使用函数构建内部控件最常见的问题之一，因为子控件更新时是通过父容器的 setState ，所以每次子控件比如 renderA 发生变化时，就会触发整个 Widget 都出现 rebuild ，这其实并不是特别符合我们的预期。

科普一个众所周知的知识点， setState 其实就是调用 StatefulWidget 对应的 StatefulElement 里的 markNeedsBuild 方法，也就是对 Element (BuildContext) 里的 _dirty 标识为设置为 true ，仅此而已， 然后等待下次渲染更新。

当然，你说像 renderA 这种写法会引起很严重的性能问题吗？事实上并不会，因为众所周知 Flutter 里的 UI 构建是通过多个不同的树来完成的，而 Widget 并不是真实的控件，所以一般情况下 renderA 这种写法导致的 rebuild 是不会产生严重的性能缺陷。

但是，如果同级下你的 renderB 是如下所示这样的情况呢？虽然这段代码毫无意义，但是我们在 renderA 点击改变 count 的时候，其实并没有改变 renderB 的用到的 status 参数，但是因为 renderA 里调用了 setState ，导致 renderB 每次都会进行重复进行浮点计算。

当然你可以说我写个变量进行缓存提前判断也可以解决，但这并不是这个例子的关键，那如果把上面这个例子变成 Component Class 的方式会有什么好处：

• A 在点击更新 count 时不会影响其他控件
• B 控件通过 didUpdateWidget 可以用更优雅的方式决定更新条件

这样看起来是不是更合理一些？另外 Component Class 的实现方式，也能在一定层度解决代码层级嵌套的问题，有时候实现一些 Component Class 的模版也可以成为 Flutter 里提高效率的工具，这个后面我们会聊到。

当然使用 Component Class 在无形之中会需要你写更多的代码，同时控件之间的状态联动成本也会有所提高，例如你需要在 B 控件关联 A 的 count 变化去改变高度，这时候可能就需要加入 InheritedWidget 或者 ValueNotifier 等方式来实现。

例如 Flutter 里 DefaultTabController 配合 TabBar 和 TabBarView 的实现就是一个很好的参考。

 Widget build(BuildContext context) {

     return DefaultTabController(

       length: myTabs.length,

       child: Scaffold(

         appBar: AppBar(

           bottom: TabBar(

             tabs: myTabs,

           ),

         ),

         body: TabBarView(

           children: myTabs.map((Tab tab) {

             final String label = tab.text.toLowerCase();

             return Center(

               child: Text(

                 'This is the $label tab',

                 style: const TextStyle(fontSize: 36),

               ),

             );

           }).toList(),

         ),

       ),

     );

  }

所以到这里我们理解一个小技巧：在不偷懒的情况下，使用 Component Class 的方式实现子控件会比使用函数方式可能得到更好的性能和代码结构。

当然，使用 Component Class 实现的方式，在调试时也会比函数方式更方便，如下图所示，当使用函数方式布局时，你在 Flutter Inspector 里看到的 Widget Tree 和 Details Tree 是完全铺平的情况，也没办法定制调试参数。

但是当你 Component Class 组织布局的时候，你就可以通过 override debugFillProperties 方法来可视化一些参数状态，例如 ItemA 里可以把 count 添加到 debugFillProperties 里，这样在 Details Tree 里也可以直观看到目前的 count 状态信息。

所以这里又有一个小技巧：通过 override debugFillProperties ，可以定制一些 Debug 时的可视化参数来帮助我们更好调试布局。

既然讲到利用 Component Class 组织布局，那就不得不聊一个典型的控件：AnimatedBuilder 。

AnimatedBuilder 可以是最常说到的一个性能优化的例子， 一般情况下在页面的子控件里使用动画，特别是循环动画的话，我们都会建议使用前面介绍的 Component Class 方式，不然动画导致当前页面不停 rebuild 肯定会导致性能影响。

但是有时候我就不想用 Component Class 该怎么办？我就是想写在当前 Page 里，那就可以使用 AnimatedBuilder ，你只要把需要执行动画的部分放到 builder 方法里就好了。

因为 AnimatedBuilder 的内部会有一个 _AnimatedState 用于独立触发 setState，从而执行外部 builder 方法执行动画效果。

类似 AnimatedBuilder 的模版实现，可以在一定程度上解决使用 Component Class 的痛点，当然，在使用 AnimatedBuilder 还是有一些需要注意， 比如 child 如果不需要跟随动画进行其他变化，一般是要放到 AnimatedBuilder 的 child 配置里，因为如果直接放在 builder 方法里，那就会出现 child 也跟随动画重新 rebuild 的情况，但是如果是放到 child 配置项里，那就是调用了 child 的对象缓存。

不正确使用	正确使用

如果对于这个缓存概念不理解，可以参考 《MediaQuery 和 build 优化你不知道的秘密》 里的“缓存区域不随帧变化，以便得到最小化的构建”。

当然类似 AnimatedBuilder 的构建方式还要注意 context 问题，不要拿错 context ，这也是很多时候会犯的潜在错误，特别是在调用 of(context) 的时候。

那有的人可能到这里会觉得，那你之前一直说 Widget 很轻，Widget 不是真正的控件，那 rebuild 多几次有什么问题？

一般情况下确实不会有太大问题，但是当你的控件有 Opacity 、ColorFilter 、 ShaderMash 或者 ClipRect（Clip.antiAliasWithSaveLayer）时，就可能会有较大的性能影响，因为他们都是可能会触发 saveLayer 的操作。

为什么 saveLayer 对性能影响很大？因为需要在 GPU 绘制是需要增加额外的缓冲区域，粗俗点说就是需要做图层的保存和合成，这就会对 GPU 渲染时产生较大影响的耗时。

而这里面最常遇到的应该就是 Opacity 带来的性能问题，因为它看起来是那么的轻便，但是从官方的介绍里，除非真的有必要，不然可以使用效果类似的实现去做场景替代，例如：

你需要对图片做透明度相关的动画是，那么使用 AnimatedOpacity 或 FadeInImage 代替 Opacity 会对性能更有帮助。

AnimatedOpacity 和 Opacity 不一样吗？某种程度上还真不大一样， Opacity 的内部是 pushOpacity 的操作，而 AnimatedOpacity 里虽然有 OpacityLayer ，但是变动时是 updateCompositedLayer ；而 FadeInImage 会使用 GPU 的 fragment shader 去处理透明度的问题，所以性能也会更好一些。

或者在类似有颜色透明度的场景时，可以通过 Color.fromRGBO 来替代 Opacity ，除非你需要将不透明度应用到一大组较为复杂的 child 里，你才会需要使用 Opacity 。

/// no

Opacity(opacity: 0.5, child: Container(color: Colors.red))

  

/// yes  

Container(color: Color.fromRGBO(255, 0, 0, 0.5))

另外还有 IntrinsicHeight / IntrinsicWidth 的场景，因为它们是可以通过 child 的内部宽高来调整 child 的大小，但是这个推算布局的过程会比较费时，可能会到 O（N²），虽然 Flutter 里针对这部分计算结果做了缓存，但是不妨碍它的耗时。

这么说可能有点抽象，举一个官方介绍过的例子，如下代码所示，当你在 ListView 里对 Row 的 children 进行 Align 排列时，你可能会发现它没有效果，因为此时通过 Border 可以看到，绿色和蓝色方框的父容器大小一致。

但是在加上 IntrinsicHeight 之后， 因为通过 IntrinsicHeight 的测算之后再返回 size，Row 里的三个 Item 现在高度一致，，这时候 Align 就可以生效了，但是正如前面所说，这个操作性对性能来说相对昂贵，虽然系统有缓存参数，但是如果出现动画 rebuild ，也会对性能造成影响。

对这部分感兴趣的可以看 ： 《带你了解不一样的 Flutter》

到这里我们就理解了 （函数方式） 和 （Component Class 方式）组织布局的不同之处，同时也知道了 Component Class 方式可以帮助我们更好地调试布局代码，也举例了一些 UI 布局里常见的耗时场景。

那本篇的小技巧到这里就结束了，如果你还有什么感兴趣或者有疑惑的，欢迎留言评论～

Kotlin是由JetBrains开发的针对JVM、Android和浏览器的静态编程语言,是Android的官方语言。Kotlin拥有较多高级而又简洁的语法特性，提升了我们的开发效率，减少了代码量。

在使用 java 的时候，我们在用class定义一个entity时除了写get、set方法(使用Kotlin后省了这部分工作)，经常还会重写类的 equals、hashCode和toString方法，这些方法往往都是模板化的。在 kotlin 中提供了data class搞定这些模版化代码。

data class与class的区别:

实现方式

• class类

  class ClassUser(val name: String, var age: Int)
  

• data class类

  data class DataClassUser(val name: String, var age: Int)
  

自动重写toString方法

• data类的toString方法会打印出属性的值
• 非data类的toString方法则打印出内存地址

  val classUser = ClassUser("classuser", 18)
  
  val dataClassUser = DataClassUser("dataclassuser", 20)
  
  println("ClassUser -> ${classUser.toString()}")
  
  // ClassUser -> com.imock.vicjava.keyuse.ClassUser@11026067
  
  
  
  println("DataClassUser -> ${dataClassUser.toString()}")
  
  // DataClassUser -> DataClassUser(name=dataclassuser, age=20)
  

新增componentN方法

• data类新增属性的componentN方法，component1代表第一个属性，component2代表第二个属性。（常用于解构声明）

  val dataClassUser = DataClassUser("dataclassuser", 20)
  
  println("DataClassUser component1() -> ${dataClassUser.component1()}")
  
  // DataClassUser component1() -> dataclassuser
  
  
  
  println("DataClassUser component2() -> ${dataClassUser.component2()}")
  
  // DataClassUser component2() -> 20
  

新增copy方法

• data类新增copy方法，可以用来修改部分属性，但是保持其他不变。

  val dataClassUser = DataClassUser("dataclassuser", 20)
  
  println("ClassUser toString() -> ${classUser.toString()}")
  
  // DataClassUser -> DataClassUser(name=dataclassuser, age=20)
  
  
  
  val newDataClassUser = dataClassUser.copy(age = 22)
  
  println("DataClassUser copy -> ${newDataClassUser.toString()}")
  
  // DataClassUser copy -> DataClassUser(name=dataclassuser, age=22)
  

重写hashCode和 equals方法

• data类重写hashCode方法，equals方法可以稍后看下源码，先判断两个是否是同一个对象，如果不是则进行类型判断，是相同类型则逐个比较属性的值。 

  val classUserLisa1 = ClassUser("lisa", 20)
  
  val classUserLisa2 = ClassUser("lisa", 20)
  
  println("ClassUser equals -> ${classUserLisa1.equals(classUserLisa2)}")
  
  // ClassUser equals -> false
  
  println("classUserLisa1 hashCode -> ${classUserLisa1.hashCode()}")
  
  // classUserLisa1 hashCode -> 2081652693
  
  println("classUserLisa2 hashCode -> ${classUserLisa2.hashCode()}")
  
  // classUserLisa2 hashCode -> 406765571
  
  
  
  val dataClassUserLisa1 = DataClassUser("lisa", 20)
  
  val dataClassUserLisa2 = DataClassUser("lisa", 20)
  
  println("DataClassUser equals -> ${dataClassUserLisa1.equals(dataClassUserLisa2)}")
  
  // DataClassUser equals -> true
  
  println("dataClassUserLisa1 hashCode -> ${dataClassUserLisa1.hashCode()}")
  
  // dataClassUserLisa1 hashCode -> 102981865
  
  println("dataClassUserLisa2 hashCode -> ${dataClassUserLisa2.hashCode()}")
  
  // dataClassUserLisa2 hashCode -> 102981865
  

data class为何如此神奇

data class DataClassUser(val name: String, var age: Int)



class ClassUser(var name: String, var age: Int)

单独看实现上两者没有太大的区别，一个使用data class，一个使用class，为何data class却多出那么多能力？得益于Kotlin高级的语法特性。我们都知道kotlin最终还是要编译成 java class 在 JVM 上运行的，为了更好的理解Kotlin高级而又简洁的语法特性，有时我们需要看看用kotlin写完的代码编译后是什么样子。Talk is cheap, show me the code.

class类编译后的java代码

Kotlin写法如下：

class ClassUser(var name: String, var age: Int)

查看编译后的java代码如下，可以看到帮我们自动生成了get、set和构造方法：

public final class ClassUser {

   @NotNull

   private final String name;

   private int age;

   @NotNull

   public final String getName() {

      return this.name;

   }

   public final int getAge() {

      return this.age;

   }

   public final void setAge(int var1) {

      this.age = var1;

   }

   public ClassUser(@NotNull String name, int age) {

      Intrinsics.checkNotNullParameter(name, "name");

      super();

      this.name = name;

      this.age = age;

   }

}

data class类编译后的java代码

Kotlin写法如下：

data class DataClassUser(val name: String, var age: Int)

查看其编译后的java代码如下，会发现比class类编译后的代码多了部分方法，新增了components和copy方法，重写了equals、hashCode和toString方法。

public final class DataClassUser {

   @NotNull

   private final String name;

   private int age;

   @NotNull

   public final String getName() {

      return this.name;

   }

   public final int getAge() {

      return this.age;

   }

   public final void setAge(int var1) {

      this.age = var1;

   }

   public DataClassUser(@NotNull String name, int age) {

      Intrinsics.checkNotNullParameter(name, "name");

      super();

      this.name = name;

      this.age = age;

   }

   // 新增方法

   @NotNull

   public final String component1() {

      return this.name;

   }

   // 新增方法

   public final int component2() {

      return this.age;

   }

   // 新增方法

   @NotNull

   public final DataClassUser copy(@NotNull String name, int age) {

      Intrinsics.checkNotNullParameter(name, "name");

      return new DataClassUser(name, age);

   }

   // 新增方法

   // $FF: synthetic method

   public static DataClassUser copy$default(DataClassUser var0, String var1, int var2, int var3, Object var4) {

      if ((var3 & 1) != 0) {

         var1 = var0.name;

      }

      if ((var3 & 2) != 0) {

         var2 = var0.age;

      }

      return var0.copy(var1, var2);

   }

   // 重写该方法

   @NotNull

   public String toString() {

      return "DataClassUser(name=" + this.name + ", age=" + this.age + ")";

   }

   // 重写该方法

   public int hashCode() {

      String var10000 = this.name;

      return (var10000 != null ? var10000.hashCode() : 0) * 31 + Integer.hashCode(this.age);

   }

   // 重写该方法

   public boolean equals(@Nullable Object var1) {

      if (this != var1) {

         if (var1 instanceof DataClassUser) {

            DataClassUser var2 = (DataClassUser)var1;

            if (Intrinsics.areEqual(this.name, var2.name) && this.age == var2.age) {

               return true;

            }

         }

         return false;

      } else {

         return true;

      }

   }

}

总结

知道data class干了啥

• 重写toString方法。
• 新增componentN方法(component1()、component2()、...、componentN())，其对应属性的声明顺序（常用于解构声明）。
• 新增copy方法，可以用来修改部分属性，但是保持其他不变。
  特别提下copy方法，可能有些同学疑问很少见到这个方法使用场景，慢慢地等你用上了MVI框架就知道State必须使用 Kotlin data class，copy方法的应用自然少不了。
• 重写equals和hasCode方法，equals()方法不再单一比较对象引用，而是先判断两个是否是同一个对象，如果不是则进行类型判断，是相同类型则逐个比较属性的值。  

使用data class需要注意啥

• 主构造函数必须要至少有一个参数。
• 主构造函数中的所有参数必须被标记为val或者var。
• 数据类不能有以下修饰符：abstract、inner、open、sealed。  

前言

Kotlin 为我们提供了两种创建“热流”的工具：StateFlow 和 SharedFlow。StateFlow 经常被用来替代 LiveData 充当架构组件使用，所以大家相对熟悉。其实 StateFlow 只是 SharedFlow 的一种特化形式，SharedFlow 的功能更强大、使用场景更多，这得益于其自带的缓存系统，本文用图解的方式，带大家更形象地理解 SharedFlow 的缓存系统。

创建 SharedFlow 需要使用到 MutableSharedFlow() 方法，我们通过方法的三个参数配置缓存：

fun <T> MutableSharedFlow(

    replay: Int = 0, 

    extraBufferCapacity: Int = 0, 

    onBufferOverflow: BufferOverflow = BufferOverflow.SUSPEND

): MutableSharedFlow<T>

接下来，我们通过时序图的形式介绍这三个关键参数对缓存的影响。正文之前让我们先统一一下用语：

• Emitter：Flow 数据的生产者，从上游发射数据
• Subcriber：Flow 数据的消费者，在下游接收数据

replay

当 Subscriber 订阅 SharedFlow 时，有机会接收到之前已发送过的数据，replay 指定了可以收到 subscribe 之前数据的数量。replay 不能为负数，默认值为 0 表示 Subscriber 只能接收到 subscribe 之后 emit 的数据：

上图展示的是 replay = 0 的情况，Subscriber 无法收到 subscribe 之前 emit 的 ❶，只能接收到 ❷ 和 ❸。

当 replay = n （ n > 0）时，SharedFlow 会启用缓存，此时 BufferSize 为 n，意味着可以缓存发射过的最近 n 个数据，并发送给新增的 Subscriber。

上图以 n = 1 为例 ：

1. Emitter 发送 ❶ ，并被 Buffer 缓存
2. Subscriber 订阅 SharedFlow 后，接收到缓存的 ❶
3. Emitter 相继发送 ❷ ❸ ，Buffer 缓存的数据相继依次被更新

在生产者消费者模型中，有时消费的速度赶不及生产，此时要加以控制，要么停止生产，要么丢弃数据。SharedFlow 也同样如此。有时 Subscriber 的处理速度较慢，Buffer 缓存的数据得不到及时处理，当 Buffer 为空时，emit 默认将会被挂起 （ onBufferOverflow = SUSPEND）

上面的图展示了 replay = 1 时 emit 发生 suspend 场景：

1. Emitter 发送 ❶ 并被缓存
2. Subscriber 订阅 SharedFlow ，接收 replay 的 ❶ 开始处理
3. Emitter 发送 ❷ ，缓存数据更新为 ❷ ，由于 Subscriber 对 ❶ 的处理尚未结束，❷ 在缓存中没有及时被消费
4. Emitter 发送 ❸，由于缓存的 ❷ 尚未被 Subscriber 消费，emit 发生挂起
5. Subscriber 开始消费 ❷ ，Buffer 缓存 ❸ ， Emitter 可以继续 emit 新数据

注意 SharedFlow 作为一个多播可以有多个 Subscriber，所以上面例子中，❷ 被消费的时间点，取决于最后一个开始处理的 Subscriber。

extraBufferCapacity

extraBufferCapacity 中的 extra 表示 replay-cache 之外为 Buffer 还可以额外追加的缓存。

若 replay = n， extraBufferCapacity = m，则 BufferSize = m + n。

extraBufferCapacity 默认为 0，设置 extraBufferCapacity 有助于提升 Emitter 的吞吐量

在上图的基础之上，我们再设置 extraBufferCapacity = 1，效果如下图：

上图中 BufferSize = 1 + 1 = 2 ：

1. Emitter 发送 ❶ 并得到 Subscriber1 的处理 ，❶ 作为 replay 的一个数据被缓存，
2. Emitter 发送 ❷，Buffer 中 replay-cache 的数据更新为 ❷
3. Emitter 发送 ❸，Buffer 在存储了 replay 数据 ❷ 之上，作为 extra 又存储了 ❸
4. Emitter 发送 ❹，此时 Buffer 已没有空余位置，emit 挂起
5. Subscriber2 订阅 SharedFlow。虽然此时 Buffer 中存有 ❷ ❸ 两个数据，但是由于 replay = 1，所以 Subscriber2 只能收到最近的一个数据 ❸
6. Subscriber1 处理完 ❶ 后，依次处理 Buffer 中的下一个数据，开始消费 ❷
7. 对于 SharedFlow 来说，已经不存在没有消费 ❷ 的 Subscriber，❷ 移除缓存，❹ 的 emit 继续，并进入缓存，此时 Buffer 又有两个数据 ❸ ❹ ，
8. Subscriber1 处理完 ❷ ，开始消费 ❸
9. 不存在没有消费 ❸ 的 Subscriber， ❸ 移除缓存。

onBufferOverflow

前面的例子中，当 Buffer 被填满时，emit 会被挂起，这都是建立在 onBufferOverflow 为 SUSPEND 的前提下的。onBufferOverflow 用来指定缓存移除时的策略，除了默认的 SUSPEND，还有两个数据丢弃策略：

• DROP_LATEST：丢弃最新的数据
• DROP_OLDEST：丢弃最老的数据

需要特别注意的是，当 BufferSize = 0 时，extraBufferCapacity 只支持 SUSPEND，其他丢弃策略是无效的。这很好理解，因为 Buffer 中没有数据，所以丢弃无从下手，所以启动丢弃策略的前提是 Buffer 至少有一个缓冲区，且数据被填满

上图展示 DROP_LATEST 的效果。假设 replay = 2，extra = 0

1. Emitter 发送 ❸ 时，由于 ❶ 已经被消费，所以 Buffer 数据从 ❶❷ 变为 ❷❸
2. Emitter 发送 ❹ 时，由于 ❷ 还未被消费，Buffer 处于填满状态， ❹ 直接被丢弃
3. Emitter 发送 ❺ 时，由于 ❷ 已经被费，可以移除缓存，Buffer 数据变为 ❸❺

上图展示了 DROP_OLDEST 的效果，与 DROP_LATEST 比较后非常明显，缓存中永远会储存最新的两个数据，但是较老的数据不管有没有被消费，都可能会从 Buffer 移除，所以 Subscriber 可以消费当前最新的数据，但是有可能漏掉中间的数据，比如图中漏掉了 ❷

注意：当 extraBufferCapacity 设为 SUSPEND 可以保证 Subscriber 一个不漏的消费掉所有数据，但是会影响 Emitter 的速度；当设置为 DROP_XXX 时，可以保证 emit 调用后立即返回，但是 Subscriber 可能会漏掉部分数据。

如果我们不想让 emit 发生挂起，除了设置 DROP_XXX 之外，还有一个方法就是调用 tryEmit，这是一个非 suspend 版本的 emit

abstract suspend override fun emit(value: T)



abstract fun tryEmit(value: T): Boolean

tryEmit 返回一个 boolean 值，你可以这样判断返回值，当使用 emit 会挂起时，使用 tryEmit 会返回 false，其余情况都是 true。这意味着 tryEmit 返回 false 的前提是 extraBufferCapacity 必须设为 SUSPEND，且 Buffer 中空余位置为 0 。此时使用 tryEmit 的效果等同于 DROP_LATEST。

SharedFlow Buffer

前面介绍的 MutableSharedFlow 的三个参数，其本质都是围绕 SharedFlow 的 Buffer 进行工作的。那么这个 Buffer 具体结构是怎样的呢？

上面这个图是 SharedFlow 源码中关于 Buffer 的注释，这个图形象地告诉了我们 Buffer 是一个线性数据结构（就是一个普通的数组 Array<Any?>），但是这个图不能直观反应 Buffer 运行机制。下面通过一个例子，看一下 Buffer 在运行时的具体更新过程：

val sharedFlow = MutableSharedFlow<Int>(

    replay = 2, 

    extraBufferCapacity = 2,

    onBufferOverflow = BufferOverflow.SUSPEND

)

var emitValue = 1



fun main() {

    runBlocking {

        launch {

            sharedFlow.onEach {

                delay(200) // simulate the consume of data

            }.collect()

        }



        repeat(12) {

            sharedFlow.emit(emitValue)

            emitValue++

            delay(50)

        }

    }

}

上面的代码很简单，SharedFlow 的 BufferSize = 2+2 = 4，Emitter 生产的速度大于 Subscriber 消费的速度，所以过程中会出现 Buffer 的填充和更新，下面依旧用图的方式展示 Buffer 的变化

先看一下代码对应的时序图:

有前面的介绍，相信这个时序图很容易理解，这里就不再赘述了，下面重点图解一下 Buffer 的内存变化。SharedFlow 的 Buffer 本质上是一个基于 Array 实现的 queue，通过指针移动从往队列增删元素，避免了元素在实际数组中的移动。这里关键的指针有三个：

• head：队列的 head 指向 Buffer 的第一个有效数据，这是时间上最早进入缓存的数据，在数据被所有的 Subscriber 消费之前不会移除缓存。因此 head 也代表了最慢的 Subscriber 的处理进度
• replay：Buffer 为 replay-cache 预留空间的其实位置，当有新的 Subscriber 订阅发生时，从此位置开始处理数据。
• end：新数据进入缓存时的位置，end 这也代表了最快的 Subscriber 的处理进度。

如果 bufferSize 表示当前 Buffer 中存储数据的个数，则我们可知三指针 index 符合如下关系：

• replay <= head + bufferSize
• end = head + bufferSize

了解了三指针的含义后，我们再来看上图中的 Buffer 是如何工作的：

最后，总结一下 Buffer 的特点：

• 基于数组实现，当数组空间不够时进行 2n 的扩容
• 元素进入数组后的位置保持不变，通过移动指针，决定数据的消费起点
• 指针移动到数组尾部后，会重新指向头部，数组空间可循环使用

前言

前段时间出现了webview的输入框被软键盘挡住的问题，处理之后顺便对一些列的输入框被挡住的情况进行一个总结。

正常情况下的输入框被挡

正常情况下，输入框被输入法挡住，一般给window设softInputMode就能解决。

window.getAttributes().softInputMode = WindowManager.LayoutParams.XXX

有3种情况:

(1)SOFT_INPUT_ADJUST_RESIZE： 布局会被软键盘顶上去
(2)SOFT_INPUT_ADJUST_PAN：只会把输入框给顶上去（就是只顶一部分距离）
(3)SOFT_INPUT_ADJUST_NOTHING：不做任何操作（就是不顶）

SOFT_INPUT_ADJUST_PAN和SOFT_INPUT_ADJUST_RESIZE的不同在于SOFT_INPUT_ADJUST_PAN只是把输入框，而SOFT_INPUT_ADJUST_RESIZE会把整个布局顶上去，这就会有种布局高度在输入框展示和隐藏时高度动态变化的视觉效果。

如果你是出现了输入框被挡的情况，一般设置SOFT_INPUT_ADJUST_PAN就能解决。如果你是输入框没被挡，但是软键盘弹出的时候会把布局往上顶，如果你不希望往上顶，可以设置SOFT_INPUT_ADJUST_NOTHING。

softInputMode是window的属性，你给在Mainifest给Activity设置，也是设给window，你如果是Dialog或者popupwindow这种，就直接getWindow()来设置就行。正常情况下设置这个属性就能解决问题。

Webview的输入框被挡

但是Webview的输入框被挡的情况下，设这个属性有可能会失效。

Webview的情况下，SOFT_INPUT_ADJUST_PAN会没效果，然后，如果是Webview并且你还开沉浸模式的情况的话，SOFT_INPUT_ADJUST_RESIZE和SOFT_INPUT_ADJUST_PAN都会不起作用。

我去查看资料，发现这就是经典的issue 5497， 网上很多的解决方案就是通过AndroidBug5497Workaround，这个方案很容易能查到，我就不贴出来了，原理就是监听View树的变化，然后再计算高度，再去动态设置。这个方案的确能解决问题，但是我觉得这个操作不可控的因素比较多，说白了就是会不会某种机型或者情况下使用会出现其它的BUG，导致你需要写一些判断逻辑来处理特殊的情况。

解法就是不用沉浸模式然后使用SOFT_INPUT_ADJUST_RESIZE就能解决。但是有时候这个window显示的时候就需要沉浸模式，特别是一些适配刘海屏、水滴屏这些场景。

setSystemUiVisibility(View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN)

那我的第一反应就是改变布局

window. setLayout(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT);

这样是能正常把弹框顶上去，但是控件内部用的也是WRAP_CONTENT导致SOFT_INPUT_ADJUST_RESIZE改变布局之后就恢复不了原样，也就是会变形。而不用WRAP_CONTENT用固定高度的话，SOFT_INPUT_ADJUST_RESIZE也是失效的。

没事，还要办法，在MATCH_PARENT的情况下我们去设置fitSystemWindows为true，但是这个属性会让出一个顶部的安全距离，效果就是向下偏移了一个状态栏的高度。

这种情况下你可以去设置margin来解决这个顶部偏移的问题。

params.topMargin = statusHeight == 0 ? -120 : -statusHeight;

view.setLayoutParams(params);

这样的操作是能解除顶部偏移的问题，但是布局有可能被纵向压缩，这个我没完全测试过，我觉得如果你布局高度是固定的，可能不会受到影响，但我的webview是自适应的，webview里面的内容也是自适应的，所以我这出现了布局纵向压缩的情况。举个例子，你的view的高度是800，状态栏高度是100，那设fitSystemWindows之后的效果就是view显示700，paddingTop 100，这样的效果，设置params.topMargin =-100，之后，view显示700，paddingTop 100。大概是这个意思：能从视觉上消除顶部偏移，但是布局纵向被压缩的问题没得到处理

所以最终的解决方法是改WindowInsets的Rect (这个我等下会再解释是什么意思)

具体的操作就是在你的自定义view中加入下面两个方法

@Override

public void setFitsSystemWindows(boolean fitSystemWindows) {

    fitSystemWindows = true;

    super.setFitsSystemWindows(fitSystemWindows);

}





@Override

protected boolean fitSystemWindows(Rect insets) {

    Log.v("mmp", "测试顶部偏移量:  "+insets.top);

    insets.top = 0;

    return super.fitSystemWindows(insets);

}

小结

解决WebView+沉浸模式下输入框被软键盘挡住的步骤：

1. window.getAttributes().softInputMode设置成SOFT_INPUT_ADJUST_RESIZE


2. 设置view的fitSystemWindows为true，我这里是webview里面的输入框被挡住，设的就是webview而不是父View


3. 重写fitSystemWindows方法，把insets的top设为0

WindowInsets

根据上面的3步操作，你就能处理webview输入框被挡的问题，但是如果你想知道为什么，这是什么原理。你就需要去了解WindowInsets。我们的沉浸模式的操作setSystemUiVisibility和设置fitSystemWindows属性，还有重写fitSystemWindows方法，都和WindowInsets有关。

WindowInsets是应用于窗口的系统视图的插入。例如状态栏STATUS_BAR和导航栏NAVIGATION_BAR。它会被view引用，所以我们要做具体的操作，是对view进行操作。

还有一个比较重要的问题，WindowInsets的不同版本都是有一定的差别，Android28、Android29、Android30都有一定的差别，例如29中有个android.graphics.Insets类，这是28里面没有的，我们可以在29中拿到它然后查看top、left等4个属性，但是只能查看，它是final的，不能直接拿出来修改。

但是WindowInsets这块其实能讲的内容比较多，以后可以拿出来单独做一篇文章，这里就简单介绍下，你只需要指定我们解决上面那些问题的原理，就是这个东西。

源码解析

大概对WindowInsets有个了解之后，我再带大家简单过一遍setFitsSystemWindows的源码，相信大家会印象更深。

public void setFitsSystemWindows(boolean fitSystemWindows) {

    setFlags(fitSystemWindows ? FITS_SYSTEM_WINDOWS : 0, FITS_SYSTEM_WINDOWS);

}

它这里只是设置一个flag而已，如果你看它的注释（我这里就不帖出来了），他会把你引导到protected boolean fitSystemWindows(Rect insets)这个方法（我之后会说为什么会到这个方法）

@Deprecated

protected boolean fitSystemWindows(Rect insets) {

    if ((mPrivateFlags3 & PFLAG3_APPLYING_INSETS) == 0) {

        if (insets == null) {

            // Null insets by definition have already been consumed.

            // This call cannot apply insets since there are none to apply,

            // so return false.

            return false;

        }

        // If we're not in the process of dispatching the newer apply insets call,

        // that means we're not in the compatibility path. Dispatch into the newer

        // apply insets path and take things from there.

        try {

            mPrivateFlags3 |= PFLAG3_FITTING_SYSTEM_WINDOWS;

            return dispatchApplyWindowInsets(new WindowInsets(insets)).isConsumed();

        } finally {

            mPrivateFlags3 &= ~PFLAG3_FITTING_SYSTEM_WINDOWS;

        }

    } else {

        // We're being called from the newer apply insets path.

        // Perform the standard fallback behavior.

        return fitSystemWindowsInt(insets);

    }

}

(mPrivateFlags3 & PFLAG3_APPLYING_INSETS) == 0 这个判断后面会简单讲，你只需要知道正常情况是执行fitSystemWindowsInt(insets)

而fitSystemWindows又是哪里调用的？往前跳，能看到是onApplyWindowInsets调用的，而onApplyWindowInsets又是由dispatchApplyWindowInsets调用的。其实到这里已经没必要往前找了，能看出这个就是个分发机制，没错，这里就是WindowInsets的分发机制，和View的事件分发机制类似，再往前找就是viewgroup调用的。前面说了WindowInsets在这里不会详细说，所以WindowInsets分发机制这里也不会去展开，你只需要先知道有那么一回事就行。

public WindowInsets dispatchApplyWindowInsets(WindowInsets insets) {

    try {

        mPrivateFlags3 |= PFLAG3_APPLYING_INSETS;

        if (mListenerInfo != null && mListenerInfo.mOnApplyWindowInsetsListener != null) {

            return mListenerInfo.mOnApplyWindowInsetsListener.onApplyWindowInsets(this, insets);

        } else {

            return onApplyWindowInsets(insets);

        }

    } finally {

        mPrivateFlags3 &= ~PFLAG3_APPLYING_INSETS;

    }

}

假设mPrivateFlags3是0，PFLAG3_APPLYING_INSETS是20，0和20做或运算，就是20。然后判断是否有mOnApplyWindowInsetsListener，这个Listener就是我们有没有在外面做

setOnApplyWindowInsetsListener(new OnApplyWindowInsetsListener() {

    @Override

    public WindowInsets onApplyWindowInsets(View v, WindowInsets insets) {

        ......

        return insets;

    }

});

假设没有，调用onApplyWindowInsets

public WindowInsets onApplyWindowInsets(WindowInsets insets) {

    if ((mPrivateFlags3 & PFLAG3_FITTING_SYSTEM_WINDOWS) == 0) {

        // We weren't called from within a direct call to fitSystemWindows,

        // call into it as a fallback in case we're in a class that overrides it

        // and has logic to perform.

        if (fitSystemWindows(insets.getSystemWindowInsetsAsRect())) {

            return insets.consumeSystemWindowInsets();

        }

    } else {

        // We were called from within a direct call to fitSystemWindows.

        if (fitSystemWindowsInt(insets.getSystemWindowInsetsAsRect())) {

            return insets.consumeSystemWindowInsets();

        }

    }

    return insets;

}

mPrivateFlags3 & PFLAG3_FITTING_SYSTEM_WINDOWS就是20和40做与运算，那就是0，所以调用fitSystemWindows。

而fitSystemWindows的(mPrivateFlags3 & PFLAG3_APPLYING_INSETS) == 0)就是20和20做与运算，不为0，所以调用fitSystemWindowsInt。

分析到这里，就需要结合我们上面解决BUG的思路了，我们其实是要拿到Rect insets这个参数，并且修改它的top。

setOnApplyWindowInsetsListener(new OnApplyWindowInsetsListener() {

    @Override

    public WindowInsets onApplyWindowInsets(View v, WindowInsets insets) {

        ......

        return insets;

    }

});

setOnApplyWindowInsetsListener回调中的insets可以拿到android.graphics.Insets这个类，但是你只能看到top是多少，没办法修改。当然你可以看到top是多少，然后按我上面的做法Margin设置一下

params.topMargin = -top;

如果你的布局不发生纵向变形，那倒没有多大关系，如果有变形，那就不能用这个做法。从源码看，这个过程主要涉及3个方法。我们能看出最好下手的地方就是fitSystemWindows。因为onApplyWindowInsets和dispatchApplyWindowInsets是分发机制的方法，你要在这里下手的话可能会出现流程混乱等问题。

所以我们这样做来解决fitSystemWindows = true出现的顶部偏移。

@Override

public void setFitsSystemWindows(boolean fitSystemWindows) {

    fitSystemWindows = true;

    super.setFitsSystemWindows(fitSystemWindows);

}





@Override

protected boolean fitSystemWindows(Rect insets) {

    Log.v("mmp", "测试顶部偏移量:  "+insets.top);

    insets.top = 0;

    return super.fitSystemWindows(insets);

}

扩展

上面已经解决问题了，这里是为了扩展一下思路。

fitSystemWindows方法是protected，导致你能重写它，但是如果这个过程我们没办法用继承来实现呢？

其实这就是一个解决问题的思路，我们要知道为什么会出现这种情况，原理是什么，比如这里我们知道这个fitSystemWindows导致的顶部偏移是insets的top导致的。你得先知道这一点，不然你不知道怎么去解决这个问题，你只能去网上找别人的方法一个一个试。那我怎么知道是insets的top导致的呢？这就需要有一定的源码阅读能力，还要知道这个东西设计的思想是怎样的。当你知道有这么一个东西之后，再想办法去拿到它然后改变数据。

这里我我们是利用继承protected方法这个特性去获取到insets，那如果这个过程没办法通过继承实现怎么办？比如这里是因为fitSystemWindows是view的方法，而我们自定义view正好继承view。如果它是内部自己写的一个类去实现这个操作呢？

这种情况下一般两种操作比较万金油：

1. 你写一个类去继承它那个类，然后在你写的类里面去改insets，然后通过反射的方式把它注入给View


2. 动态代理

我其实一开始改这个的想法就是用动态代理，所以马上把代码撸出来。

public class WebViewProxy implements InvocationHandler {



    private Object relObj;



    public Object newProxyInstance(Object object){

        this.relObj = object;

        return Proxy.newProxyInstance(relObj.getClass().getClassLoader(), relObj.getClass().getInterfaces(), this);

    }



    @Override

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        try {

            if ("fitSystemWindows".equals(method.getName()) && args != null && args.length == 1){

                Log.v("mmp", "测试代理效果 "+args);

            }

        }catch (Exception e){

            e.printStackTrace();

        }

        return proxy;

    }



}

WebViewProxy proxy = new WebViewProxy();

View viewproxy = (View) proxy.newProxyInstance(mWebView);

然后才发现fitSystemWindows不是接口方法，白忙活一场，但是如果fitSystemWindows是接口方法的话，我这里就可以用通过动态代理加反射的操作去修改这个insets，虽然用不上，但也是个思路。最后发现可以直接重写这个方法就行，我反倒还把问题想复杂了。

App中搜索功能是必不可少的，搜索功能可以帮助用户快速获取想要的信息。对此，Android提供了一个搜索框架，本文介绍如何通过搜索框架实现搜索功能。

搜索框架简介

Android 搜索框架提供了搜索弹窗和搜索控件两种使用方式。

• 
  

  搜索弹窗：系统控制的弹窗，激活后显示在页面顶部，输入的内容提交后会通过Intent传递到指定的搜索Activity中处理，可以添加搜索建议。

  
  


• 
  

  搜索控件（SearchView）：系统实现的搜索控件，可以放在任意位置（可以与Toolbar结合使用），默认情况下与EditText类似，需要自己添加监听处理用户输入的数据，通过配置可以达到与搜索弹窗一致的行为。

  
  

使用搜索框架实现搜索功能

可搜索配置

在res/xml目录下创建searchable.xml（必须用此命名），如下：

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

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

    android:hint="@string/search_hint"

    android:label="@string/app_name" />

android:label是此配置文件必须配置的属性，通常配置为App的名字，android:hint配置用户未输入内容时的提示文案，官方建议格式为“搜索${content or product}”。

更多可搜索配置包含的语法和用法可以看官方文档。

搜索页面

配置一个单独的Activity用于显示搜索内容，用户可能会在搜索完一个内容后立刻搜索下一个内容，所以建议把搜索页面设置为SingleTop，避免重复创建搜索页面。

在AndroidManifest中配置搜索页面，如下：

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

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



    <application

        ... 

        >



        <activity

            android:name=".search.SearchActivity"

            android:exported="false"

            android:launchMode="singleTop">



            <meta-data

                android:name="android.app.searchable"

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



            <intent-filter>

                <action android:name="android.intent.action.SEARCH" />

            </intent-filter>

        </activity>

    </application>

</manifest>

在Activity中处理搜索数据，代码如下：

class SearchActivity : AppCompatActivity() {



    private lateinit var binding: LayoutSearchActivityBinding



    override fun onCreate(savedInstanceState: Bundle?) {

        super.onCreate(savedInstanceState)

        binding = DataBindingUtil.setContentView(this, R.layout.layout_search_activity)

        // 当搜索页面第一次打开时，获取搜索内容

        getQueryKey(intent)

    }



    override fun onNewIntent(intent: Intent?) {

        super.onNewIntent(intent)

        // 更新Intent数据

        setIntent(intent)

        // 当搜索页面多次打开，并仍在栈顶时，获取搜索内容

        getQueryKey(intent)

    }



    private fun getQueryKey(intent: Intent?) {

        intent?.run {

            if (Intent.ACTION_SEARCH == action) {

                // 用户输入的内容

                val queryKey = getStringExtra(SearchManager.QUERY) ?: ""

                if (queryKey.isNotEmpty()) {

                    doSearch(queryKey)

                }

            }

        }

    }



    private fun doSearch(queryKey: String) {

        // 根据用户输入内容执行搜索操作

    }

}

使用SearchView

SearchView可以放在页面的任意位置，本文与Toolbar结合使用，如何在Toolbar中创建菜单项在上一篇文章中介绍过，此处省略。要使SearchView与搜索弹窗保持一致的行为需要在代码中进行配置，如下：

class SearchActivity : AppCompatActivity() {



    private lateinit var binding: LayoutSearchActivityBinding



    override fun onCreateOptionsMenu(menu: Menu?): Boolean {

        menuInflater.inflate(R.menu.example_seach_menu, menu)

        menu?.run {

            val searchManager = getSystemService(Context.SEARCH_SERVICE) as SearchManager

            val searchView = findItem(R.id.action_search).actionView as SearchView

            //设置搜索配置  

            searchView.setSearchableInfo(searchManager.getSearchableInfo(componentName))

        }

        return true

    }

    

    ...

}

使用搜索弹窗

在Activity中使用搜索弹窗，如果Activity已经配置为搜索页面则无需额外配置，否则需要在AndroidManifest中添加配置，如下：

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

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



    <application

        ... 

        >



        <activity

            android:name=".search.SearchExampleActivity">



            <!--为当前页面指定搜索页面-->

            <!--如果所有页面都使用搜索弹窗，则将此meta-data移到applicaion标签下-->

            <meta-data

                android:name="android.app.default_searchable"

                android:value=".search.SearchActivity" />

        </activity>

    </application>

</manifest>

在Activity中通过onSearchRequested方法来调用搜索弹窗，如下：

class SearchExampleActivity : AppCompatActivity() {



    override fun onCreate(savedInstanceState: Bundle?) {

        super.onCreate(savedInstanceState)

        val binding: LayoutSearchExampleActivityBinding = DataBindingUtil.setContentView(this, R.layout.layout_search_example_activity)

        binding.btnSearchDialog.setOnClickListener { onSearchRequested() }

    }

}

搜索弹窗对Activity生命周期的影响

搜索弹窗的显示隐藏，不会像其他弹窗一样触发Activity的onPause、onResume方法。如果在搜索弹窗显示隐藏的同时需要对其他功能进行处理，可以通过onSearchRequested和OnDismissListener来实现，代码如下：

class SearchExampleActivity : AppCompatActivity() {



    override fun onSearchRequested(): Boolean {

        // 搜索弹窗显示，可以在此处理其他功能

        return super.onSearchRequested()

    }



    override fun onCreate(savedInstanceState: Bundle?) {

        super.onCreate(savedInstanceState)

        val binding: LayoutSearchExampleActivityBinding = DataBindingUtil.setContentView(this, R.layout.layout_search_example_activity)

        binding.btnSearchDialog.setOnClickListener { onSearchRequested() }

        val searchManager = getSystemService(Context.SEARCH_SERVICE) as SearchManager

        searchManager.setOnDismissListener {

            // 搜索弹窗隐藏，可以在此处理其他功能

        }

    }

}

附加额外的参数

使用搜索弹窗时，如果需要附加额外的参数用于优化搜索查询的过程，例如用户的性别、年龄等，可以通过如下代码实现：

// 配置额外参数

class SearchExampleActivity : AppCompatActivity() {



    override fun onSearchRequested(): Boolean {

        val appData = Bundle()

        appData.putString("gender", "male")

        appData.putInt("age", 24)

        startSearch(null, false, appData, false)

        // 返回true表示已经发起了查询

        return true

    }



    ...

}



// 在搜素页面中获取额外参数

class SearchActivity : AppCompatActivity() {



    override fun onCreate(savedInstanceState: Bundle?) {

        super.onCreate(savedInstanceState)  

        intent?.run {

            if (Intent.ACTION_SEARCH == action) {

                // 用户输入的内容

                val queryKey = getStringExtra(SearchManager.QUERY) ?: ""

                // 额外参数

                val appData = getBundleExtra(SearchManager.APP_DATA)

                appData?.run {

                    val gender = getString("gender") ?: ""

                    val age = getInt("age")

                }

            }

        }

    }

}

语音搜索

语音搜索让用户无需输入内容就可进行搜索，要开启语音搜索，需要在searchable.xml增加配置，如下：

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

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

    android:hint="@string/search_hint"

    android:label="@string/app_name"

    android:voiceSearchMode="showVoiceSearchButton|launchRecognizer" />

语音搜索必须配置showVoiceSearchButton用于显示语音搜索按钮，配置launchRecognizer指定语音搜索按钮启动一个语音识别程序用于识别语音转录为文本并发送至搜索页面。

更多语音搜索配置包含的语法和用法可以看官方文档。

注意，语音识别后的文本会直接发送至搜索页面，无法更改，需要进行完备的测试确保语音搜索功能适合你的App。

搜索记录

用户执行过搜索后，可以将搜索的内容保存下来，下次要搜索相同的内容时，输入部分文字后就会显示匹配的搜索记录。

要实现此功能，需要完成下列步骤：

创建SearchRecentSuggestionsProvider

自定义RecentSearchProvider继承SearchRecentSuggestionsProvider，代码如下：

class RecentSearchProvider : SearchRecentSuggestionsProvider() {



    companion object {

        // 授权方的名称（建议设置为文件提供者的完整名称）

        const val AUTHORITY = "com.chenyihong.exampledemo.search.RecentSearchProvider"

        // 数据库模式 

        // 必须配置 DATABASE_MODE_QUERIES 

        // 可选配置 DATABASE_MODE_2LINES，为搜索记录提供第二行文本，可用于作为详情补充

        const val MODE: Int = DATABASE_MODE_QUERIES or DATABASE_MODE_2LINES

    }



    init {

        // 设置搜索授权方的名称与数据库模式

        setupSuggestions(AUTHORITY, MODE)

    }

}

在AndroidManifest中配置Provider，如下：

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

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



    <application

        ... 

        >

        

        <!--android:authorities的值与RecentSearchProvider中的AUTHORITY一致-->

        <provider

            android:name=".search.RecentSearchProvider"

            android:authorities="com.chenyihong.exampledemo.search.RecentSearchProvider"

            android:exported="false" />

    </application>

</manifest>

修改可搜索配置

在searchable.xml增加配置，如下：

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

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

    android:hint="@string/search_hint"

    android:label="@string/app_name"

    android:voiceSearchMode="showVoiceSearchButton|launchRecognizer"

    android:searchSuggestAuthority="com.chenyihong.exampledemo.search.RecentSearchProvider"

    android:searchSuggestSelection=" ?"/>

android:searchSuggestAuthority 的值与RecentSearchProvider中的AUTHORITY保持一致。android:searchSuggestSelection的值必须为" ?"，该值为数据库选择参数的占位符，自动由用户输入的内容替换。

在搜索页面中保存查询

获取到用户输入的数据时保存，代码如下：

class SearchActivity : BaseGestureDetectorActivity() {



    override fun onCreate(savedInstanceState: Bundle?) {

        super.onCreate(savedInstanceState)

        intent?.run {

            if (Intent.ACTION_SEARCH == action) {

                val queryKey = getStringExtra(SearchManager.QUERY) ?: ""

                if (queryKey.isNotEmpty()) {

                    // 第一个参数为用户输入的内容

                    // 第二个参数为第二行文本，可为null，仅当RecentSearchProvider.MODE为DATABASE_MODE_QUERIES or DATABASE_MODE_2LINES时有效。

                    SearchRecentSuggestions(this@SearchActivity, RecentSearchProvider.AUTHORITY, RecentSearchProvider.MODE)

                        .saveRecentQuery(queryKey, "history $queryKey")

                }

            }

        }

    }

}

清除搜索历史

为了保护用户的隐私，官方的建议是App必须提供清除搜索记录的功能。请求搜索记录可以通过如下代码实现：

class SearchActivity : BaseGestureDetectorActivity() {



    override fun onCreate(savedInstanceState: Bundle?) {

        super.onCreate(savedInstanceState)

        SearchRecentSuggestions(this, RecentSearchProvider.AUTHORITY, RecentSearchProvider.MODE)

            .clearHistory()

    }

}

示例

整合之后做了个示例Demo，代码如下：

// 可搜索配置

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

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

    android:hint="@string/search_hint"

    android:label="@string/app_name"

    android:searchSuggestAuthority="com.chenyihong.exampledemo.search.RecentSearchProvider"

    android:searchSuggestSelection=" ?"

    android:voiceSearchMode="showVoiceSearchButton|launchRecognizer" />



// 清单文件

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

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



    <application

        ...

        >

        

        <activity

            android:name=".search.SearchExampleActivity"

            android:screenOrientation="portrait">



            <!--为当前页面指定搜索页面-->

            <meta-data

                android:name="android.app.default_searchable"

                android:value=".search.SearchActivity" />

        </activity>



        <activity

            android:name=".search.SearchActivity"

            android:exported="false"

            android:launchMode="singleTop"

            android:parentActivityName="com.chenyihong.exampledemo.search.SearchExampleActivity"

            android:screenOrientation="portrait">



            <meta-data

                android:name="android.support.PARENT_ACTIVITY"

                android:value="com.chenyihong.exampledemo.search.SearchExampleActivity" />



            <meta-data

                android:name="android.app.searchable"

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



            <intent-filter>

                <action android:name="android.intent.action.SEARCH" />

            </intent-filter>

        </activity>



        <provider

            android:name=".search.RecentSearchProvider"

            android:authorities="com.chenyihong.exampledemo.search.RecentSearchProvider"

            android:exported="false" />

    </application>

</manifest>



// 示例Activity

class SearchExampleActivity : BaseGestureDetectorActivity() {



    override fun onSearchRequested(): Boolean {

        val appData = Bundle()

        appData.putString("gender", "male")

        appData.putInt("age", 24)

        startSearch(null, false, appData, false)

        return true

    }



    override fun onCreate(savedInstanceState: Bundle?) {

        super.onCreate(savedInstanceState)

        val binding: LayoutSearchExampleActivityBinding = DataBindingUtil.setContentView(this, R.layout.layout_search_example_activity)

        binding.btnSearchView.setOnClickListener { startActivity(Intent(this, SearchActivity::class.java)) }

        binding.btnSearchDialog.setOnClickListener { onSearchRequested() }

        val searchManager = getSystemService(Context.SEARCH_SERVICE) as SearchManager

        searchManager.setOnDismissListener {

            runOnUiThread { Toast.makeText(this, "Search Dialog dismiss", Toast.LENGTH_SHORT).show() }

        }

    }

}



class SearchActivity : BaseGestureDetectorActivity() {



    private lateinit var binding: LayoutSearchActivityBinding



    private val textDataAdapter = TextDataAdapter()



    private val originData = ArrayList<String>()



    private var lastQueryValue = ""



    override fun onCreateOptionsMenu(menu: Menu?): Boolean {

        menuInflater.inflate(R.menu.example_seach_menu, menu)

        menu?.run {

            val searchManager = getSystemService(Context.SEARCH_SERVICE) as SearchManager

            val searchView = findItem(R.id.action_search).actionView as SearchView

            searchView.setOnCloseListener {

                textDataAdapter.setNewData(originData)

                false

            }

            searchView.setSearchableInfo(searchManager.getSearchableInfo(componentName))

            if (lastQueryValue.isNotEmpty()) {

                searchView.setQuery(lastQueryValue, false)

            }

        }

        return true

    }



    override fun onOptionsItemSelected(item: MenuItem): Boolean {

        if (item.itemId == R.id.action_clear_search_histor) {

            SearchRecentSuggestions(this, RecentSearchProvider.AUTHORITY, RecentSearchProvider.MODE)

                .clearHistory()

        }

        return super.onOptionsItemSelected(item)

    }



    override fun onCreate(savedInstanceState: Bundle?) {

        super.onCreate(savedInstanceState)

        binding = DataBindingUtil.setContentView(this, R.layout.layout_search_activity)

        setSupportActionBar(binding.toolbar)

        supportActionBar?.run {

            title = "SearchExample"

            setHomeAsUpIndicator(R.drawable.icon_back)

            setDisplayHomeAsUpEnabled(true)

        }

        binding.rvContent.adapter = textDataAdapter

        originData.add("test data qwertyuiop")

        originData.add("test data asdfghjkl")

        originData.add("test data zxcvbnm")

        originData.add("test data 123456789")

        originData.add("test data /.,?-+")

        textDataAdapter.setNewData(originData)

        // 获取搜索内容

        getQueryKey(intent, false)

    }



    override fun onNewIntent(intent: Intent?) {

        super.onNewIntent(intent)

        // 更新Intent数据

        setIntent(intent)

        // 获取搜索内容

        getQueryKey(intent, true)

    }



    private fun getQueryKey(intent: Intent?, newIntent: Boolean) {

        intent?.run {

            if (Intent.ACTION_SEARCH == action) {

                val queryKey = getStringExtra(SearchManager.QUERY) ?: ""

                if (queryKey.isNotEmpty()) {

                    SearchRecentSuggestions(this@SearchActivity, RecentSearchProvider.AUTHORITY, RecentSearchProvider.MODE)

                        .saveRecentQuery(queryKey, "history $queryKey")

                    if (!newIntent) {

                        lastQueryValue = queryKey

                    }

                    val appData = getBundleExtra(SearchManager.APP_DATA)

                    doSearch(queryKey, appData)

                }

            }

        }

    }



    private fun doSearch(queryKey: String, appData: Bundle?) {

        appData?.run {

            val gender = getString("gender") ?: ""

            val age = getInt("age")

        }

        val filterData = originData.filter { it.contains(queryKey) } as ArrayList<String>

        textDataAdapter.setNewData(filterData)

    }

}

ExampleDemo github

ExampleDemo gitee

效果如图：

隐式一致性消除了很多我们需要自己为Sendable协议添加一致性的情况。然而，在有些情况下，我们知道我们的类型是线程安全的，但是编译器并没有为我们添加隐式一致性。
常见的例子是被标记为不可变和内部具有锁定机制的类：

/// User 是不可改变的，因此是线程安全的，所以可以遵守 Sendable 协议
final class User: Sendable {
let name: String

init(name: String) { self.name = name }
}

你需要用@unchecked属性来标记可变类，以表明我们的类由于内部锁定机制所以是线程安全的：

extension DispatchQueue {
static let userMutatingLock = DispatchQueue(label: "person.lock.queue")
}

final class MutableUser: @unchecked Sendable {
private var name: String = ""

func updateName(_ name: String) {
DispatchQueue.userMutatingLock.sync {
self.name = name
}
}
}

遵守 Sendable的限制

Sendable协议的一致性必须发生在同一个源文件中，以确保编译器检查所有可见成员的线程安全。
例如，你可以在例如 Swift package这样的模块中定义以下类型：

public struct Article {
internal var title: String
}

Article 是公开的，而标题title是内部的，在模块外不可见。因此，编译器不能在源文件之外应用Sendable一致性，因为它对标题属性不可见，即使标题使用的是遵守Sendable协议的String类型。
同样的问题发生在我们想要使一个可变的非最终类遵守Sendable协议时：

函数可以跨并发域传递，因此也需要可发送的一致性。然而，函数不能符合协议，所以Swift引入了@Sendable属性。你可以传递的函数的例子是全局函数声明、闭包和访问器，如getters和setters。
SE-302的部分动机是执行尽可能少的同步

我们希望这样一个系统中的绝大多数代码都是无同步的。

使用@Sendable属性，我们将告诉编译器，他不需要额外的同步，因为闭包中所有捕获的值都是线程安全的。一个典型的例子是在Actor isolation中使用闭包。

actor ArticlesList {
func filteredArticles(_ isIncluded: @Sendable (Article) -> Bool) async -> [Article] {
// ...
}
}

如果你用非 Sendabel 类型的闭包，我们会遇到一个错误:

let listOfArticles = ArticlesList()
var searchKeyword: NSAttributedString? = NSAttributedString(string: "keyword")
let filteredArticles = await listOfArticles.filteredArticles { article in

// Error: Reference to captured var 'searchKeyword' in concurrently-executing code
guard let searchKeyword = searchKeyword else { return false }
return article.title == searchKeyword.string
}

当然，我们可以通过使用一个普通的String来快速解决这种情况，但它展示了编译器如何帮助我们执行线程安全。

Swift 6: 代码启用并发性检查

Xcode 14 允许您通过 SWIFT_STRICT_CONCURRENCY 构建设置启用严格的并发性检查。

启用严格的并发性检查，以修复 Sendable 的符合性

这个构建设置控制编译器对Sendable和actor-isolation检查的执行水平:
Minimal : 编译器将只诊断明确标有Sendable一致性的实例，并等同于Swift 5.5和5.6的行为。不会有任何警告或错误。
Targeted: 强制执行Sendable约束，并对你所有采用async/await等并发的代码进行actor-isolation检查。编译器还将检查明确采用Sendable的实例。这种模式试图在与现有代码的兼容性和捕捉潜在的数据竞赛之间取得平衡。
Complete: 匹配预期的 Swift 6语义，以检查和消除数据竞赛。这种模式检查其他两种模式所做的一切，并对你项目中的所有代码进行这些检查。
严格的并发检查构建设置有助于 Swift 向数据竞赛安全迈进。与此构建设置相关的每一个触发的警告都可能表明你的代码中存在潜在的数据竞赛。因此，必须考虑启用严格并发检查来验证你的代码。

Enabling strict concurrency in Xcode 14

你会得到的警告数量取决于你在项目中使用并发的频率。对于Stock Analyzer，我有大约17个警告需要解决：

并发相关的警告，表明潜在的数据竞赛.

这些警告可能让人望而生畏，但利用本文的知识，你应该能够摆脱大部分警告，防止数据竞赛的发生。然而，有些警告是你无法控制的，因为是外部模块触发了它们。在我的例子中，我有一个与SWHighlight有关的警告，它不符合Sendable，而苹果在他们的SharedWithYou框架中定义了它。
在上述SharedWithYou框架的例子中，最好是等待库的所有者添加Sendable支持。在这种情况下，这就意味着要等待苹果公司为SWHighlight实例指明Sendable的一致性。对于这些库，你可以通过使用@preconcurrency属性来暂时禁用Sendable警告:

@preconcurrency import SharedWithYou

重要的是要明白，我们并没有解决这些警告，而只是禁用了它们。来自这些库的代码仍然有可能发生数据竞赛。如果你正在使用这些框架的实例，你需要考虑实例是否真的是线程安全的。一旦你使用的框架被更新为Sendable的一致性，你可以删除@preconcurrency属性，并修复可能触发的警告。

背景

flutter版本要实现一个渐变的圆弧指示器,如图



颜色需要有个渐变,而且根据百分比的不同,中间的菱形指向还不一样

1.自定义CustomPainter

class PlatePainter extends CustomPainter {

  @override

  void paint(Canvas canvas, Size size) {

    // 画图逻辑

  }



  @override

  bool shouldRepaint(covariant CustomPainter oldDelegate) {

    // 是否需要重绘的判断 ,可以先返回false

    return false;

  }

}

然后加入一点点画图的细节:

import 'dart:math';

import 'dart:ui' as ui;

import 'package:flutter/material.dart';



class PlatePainter3 extends CustomPainter {

  final Paint _paintProgress = Paint()

    ..strokeWidth = 15

    ..style = PaintingStyle.stroke;

  final Paint _paintBg = Paint()

    ..strokeWidth = 15

    ..color = const Color(0xFFC8CAFF).withAlpha(22)

    ..style = PaintingStyle.stroke;

  final Paint _paintLine = Paint()

    ..strokeWidth = 2

    ..color = const Color(0Xff7A80FF)

    ..style = PaintingStyle.fill;

  final Path _path = Path();

  final Paint _paintCenter = Paint()

    ..strokeWidth = 2

    ..color = const Color(0xFF767DFF).withAlpha(14)

    ..style = PaintingStyle.fill;



  @override

  void paint(Canvas canvas, Size size) {

    final width = size.width;

    final height = size.height;

    final center = Offset(width / 2, height * 3 / 4);

    final rect = Rect.fromCircle(

      center: center,

      radius: 60,

    );

    canvas.drawArc(rect, pi * 0.8, pi * 2 * (0.1 + 0.1 + 0.5), false, _paintBg);

    _paintProgress.shader = ui.Gradient.sweep(

      center,

      [

        const Color(0XffCACCFF),

        const Color(0Xff7A80FF),

      ],

    );

    canvas.drawArc(rect, pi * 0.8, (pi * 2 * 0.7) , false, _paintProgress);



    TextPainter textPainter = TextPainter(

      text: const TextSpan(text: '0', style: TextStyle(color: Colors.black, fontSize: 10)),

      textDirection: TextDirection.ltr,

    );

    textPainter.layout(maxWidth: width);

    textPainter.paint(canvas, Offset(width / 2 - 60 + 15, height - 5));

    textPainter.text = const TextSpan(text: '100', style: TextStyle(color: Colors.black, fontSize: 10));

    textPainter.layout(maxWidth: width);

    textPainter.paint(canvas, Offset(width / 2 + 60 - 15 - 20, height - 5));

    Offset c = Offset(width / 2, height * 3 / 4);

    var angle = pi * 0.8 + pi * 2 * (0.1 + 0.1 + 0.5) ;

    canvas.drawLine(c + _calXYByRadius(angle, 50), c + _calXYByRadius(angle, 70), _paintLine);



    final o1 = c+_calXYByRadius(angle, 15);

    final o2 = c+_calXYByRadius(angle + pi, 15);

    final o3 = c+_calXYByRadius(angle + 0.5 * pi, 5);

    final o4 = c+_calXYByRadius(angle + pi + 0.5 * pi, 5);

    _path.reset();

    _path.moveTo(o1.dx, o1.dy);

    _path.lineTo(o3.dx, o3.dy);

    _path.lineTo(o2.dx, o2.dy);

    _path.lineTo(o4.dx, o4.dy);

    _path.close();

    _paintCenter.color = const Color(0xFF767DFF);

    canvas.drawPath(_path, _paintCenter);



    _paintCenter.color = const Color(0xFF767DFF).withAlpha(14);

    canvas.drawCircle(c, 20, _paintCenter);

    _paintCenter.color =  Colors.white;

    canvas.drawCircle(c, 2, _paintCenter);

  }



  @override

  bool shouldRepaint(covariant CustomPainter oldDelegate) {

    return false;

  }



  Offset _calXYByRadius(double angle, double radius) {

    final y = sin(angle) * radius;

    final x = cos(angle) * radius;

    return Offset(x, y);

  }

}

中间颜色的渐变用到了Paint的方法shader,设置的属性为 dart:ui包下的Gradient,不要导错包了,应该import的时候加入 as ui,才可以如代码中设置的样式.

import 'dart:ui' as ui;

满心欢喜的运行一下,Duang

渐变颜色没有按照想象中的开始和结束.

2.关于 paint的shader属性

/// The shader to use when stroking or filling a shape.

///

/// When this is null, the [color] is used instead.

///

/// See also:

///

///  * [Gradient], a shader that paints a color gradient.

///  * [ImageShader], a shader that tiles an [Image].

///  * [colorFilter], which overrides [shader].

///  * [color], which is used if [shader] and [colorFilter] are null.

Shader? get shader {

  return _objects?[_kShaderIndex] as Shader?;

}

set shader(Shader? value) {

  _ensureObjectsInitialized()[_kShaderIndex] = value;

}

直接查看Gradient类的sweep方法,参数如下

Gradient.sweep(

  Offset center,

  List<Color> colors, [

  List<double>? colorStops,

  TileMode tileMode = TileMode.clamp,

  double startAngle = 0.0,

  double endAngle = math.pi * 2,

  Float64List? matrix4,

])

翻译如下

创建一个以 center 为中心、从 startAngle 开始到 endAngle 结束的扫描渐变。 startAngle 和 endAngle 应该以弧度提供，零弧度是 center 右侧的水平线，正角度围绕 center 顺时针方向。如果提供了 colorStops，colorStops[i] 是一个从 0.0 到 1.0 的数字，它指定了 color[i] 在渐变中的开始位置。如果 colorStops 没有提供，那么只有两个停止点，在 0.0 和 1.0，是隐含的（因此 color 必须只有两个条目）。 startAngle 之前和 endAngle 之后的行为由 tileMode 参数描述。有关详细信息，请参阅 [TileMode] 枚举。

哦哦,应该修改startAngle和endAngle方法,然后按照开始和结束的颜色结束.修改

_paintProgress.shader = ui.Gradient.sweep(

  center,

  [

    const Color(0XffCACCFF),

    const Color(0Xff7A80FF),

  ],

  [0, 1],

  TileMode.clamp,

  0.8 * pi,

  2.2 * pi,

);

然后运行

好像开始的颜色正常了,但是结束颜色还是一样的问题.

3.两种解决方法

3.1 设置shader属性(推荐)

_paintProgress.shader = ui.Gradient.sweep(

  center,

  [

    const Color(0Xff7A80FF),

    const Color(0XffCACCFF),

    const Color(0Xff7A80FF),

  ],

  [0.0, 0.5, 0.9],

  TileMode.clamp,

);

运行如图:

3.2 旋转控件,开始绘制从0开始

painter修改代码

import 'dart:math';

import 'dart:ui' as ui;



import 'package:flutter/material.dart';



class PlatePainter4 extends CustomPainter {



  final Paint _paintProgress = Paint()

    ..strokeWidth = 15

    ..style = PaintingStyle.stroke;

  final Paint _paintBg = Paint()

    ..strokeWidth = 15

    ..color = const Color(0xFFC8CAFF).withAlpha(22)

    ..style = PaintingStyle.stroke;

  final Paint _paintLine = Paint()

    ..strokeWidth = 2

    ..color = const Color(0Xff7A80FF)

    ..style = PaintingStyle.fill;

  final Path _path = Path();

  final Paint _paintCenter = Paint()

    ..strokeWidth = 2

    ..color = const Color(0xFF767DFF).withAlpha(14)

    ..style = PaintingStyle.fill;



  @override

  void paint(Canvas canvas, Size size) {

    final width = size.width;

    final height = size.height;

    final center = Offset(width / 2, height  /2);

    final rect = Rect.fromCircle(

      center: center,

      radius: 60,

    );

    canvas.drawArc(rect, 0, (pi * 1.4), false, _paintBg);

    _paintProgress.shader = ui.Gradient.sweep(

      center,

      [

        const Color(0XffCACCFF),

        const Color(0Xff7A80FF),

        // const Color(0Xff7A80FF),

        // Colors.white,

        // Colors.black,

      ],

    );

    canvas.drawArc(rect, 0, (pi * 1.4) , false, _paintProgress);



    // TextPainter textPainter = TextPainter(

    //   text: const TextSpan(text: '0', style: TextStyle(color: Colors.black, fontSize: 10)),

    //   textDirection: TextDirection.ltr,

    // );

    // textPainter.layout(maxWidth: width);

    // textPainter.paint(canvas, Offset(width / 2 - 60 + 15, height - 5));

    // textPainter.text = const TextSpan(text: '100', style: TextStyle(color: Colors.black, fontSize: 10));

    // textPainter.layout(maxWidth: width);

    // textPainter.paint(canvas, Offset(width / 2 + 60 - 15 - 20, height - 5));

    Offset c = Offset(width / 2, height  / 2);

    var angle =  pi *  1.4 ;

    canvas.drawLine(c + _calXYByRadius(angle, 50), c + _calXYByRadius(angle, 70), _paintLine);



    final o1 = c+_calXYByRadius(angle, 15);

    final o2 = c+_calXYByRadius(angle + pi, 15);

    final o3 = c+_calXYByRadius(angle + 0.5 * pi, 5);

    final o4 = c+_calXYByRadius(angle + pi + 0.5 * pi, 5);

    _path.reset();

    _path.moveTo(o1.dx, o1.dy);

    _path.lineTo(o3.dx, o3.dy);

    _path.lineTo(o2.dx, o2.dy);

    _path.lineTo(o4.dx, o4.dy);

    _path.close();

    _paintCenter.color = const Color(0xFF767DFF);

    canvas.drawPath(_path, _paintCenter);



    _paintCenter.color = const Color(0xFF767DFF).withAlpha(14);

    canvas.drawCircle(c, 20, _paintCenter);

    _paintCenter.color =  Colors.white;

    canvas.drawCircle(c, 2, _paintCenter);

  }



  @override

  bool shouldRepaint(covariant CustomPainter oldDelegate) {

    return false;

  }



  Offset _calXYByRadius(double angle, double radius) {

    final y = sin(angle) * radius;

    final x = cos(angle) * radius;

    return Offset(x, y);

  }

}

页面代码加入旋转代码:

Transform.rotate(

  angle: 0.8 * pi,

  child: CustomPaint(

    painter: PlatePainter4(),

    size: const Size(180, 180),

  ),

),

运行如下图第二个:



缺点:画文字的坐标还需要重新计算和旋转

4.加上动画,动起来

效果图:

最终代码:
Page:

import 'dart:math';



import 'package:demo4/widgets/plate_painter.dart';

import 'package:demo4/widgets/plate_painter3.dart';

import 'package:flutter/material.dart';



import '../widgets/plate_painter2.dart';

import '../widgets/plate_painter4.dart';



class Page6 extends StatefulWidget {

  const Page6({Key? key}) : super(key: key);



  @override

  State<Page6> createState() => _Page6State();

}



class _Page6State extends State<Page6> with TickerProviderStateMixin{

  late AnimationController _animationController;

  static final Animatable<double> _iconTurnTween =

      Tween<double>(begin: 0.0, end: 1.0).chain(CurveTween(curve: Curves.fastOutSlowIn));



  @override

  void initState() {

    _animationController = AnimationController(vsync: this, duration: const Duration(seconds: 6));

    _animationController.drive(_iconTurnTween);

    _animationController.forward();

    super.initState();

  }



  @override

  void dispose() {

    _animationController.dispose();

    super.dispose();

  }



  @override

  Widget build(BuildContext context) {

    return Scaffold(

      appBar: AppBar(

        title: const Text('自定义圆盘'),

      ),

      body: Column(

        children: [

          AnimatedBuilder(

            animation: _animationController.view,

            builder: (_, __) {

              final progress = _animationController.value;

              return CustomPaint(

                painter: PlatePainter(progress),

                size: const Size(180, 180),

              );

            },

          ),

          AnimatedBuilder(

            animation: _animationController.view,

            builder: (_, __) {

              final progress = _animationController.value;

              return Transform.rotate(

                angle: 0.8 * pi,

                child: CustomPaint(

                  painter: PlatePainter2(progress),

                  size: const Size(180, 180),

                ),

              );

            },

          ),



        ],

      ),

    );

  }

}

方法一:

import 'dart:math';

import 'dart:ui' as ui;



import 'package:flutter/material.dart';



class PlatePainter extends CustomPainter {

  PlatePainter(

    this.progress,

  );



  final num progress;

  final Paint _paintProgress = Paint()

    ..strokeWidth = 15

    ..style = PaintingStyle.stroke;

  final Paint _paintBg = Paint()

    ..strokeWidth = 15

    ..color = const Color(0xFFC8CAFF).withAlpha(22)

    ..style = PaintingStyle.stroke;

  final Paint _paintLine = Paint()

    ..strokeWidth = 2

    ..color = const Color(0Xff7A80FF)

    ..style = PaintingStyle.fill;

  final Path _path = Path();

  final Paint _paintCenter = Paint()

    ..strokeWidth = 2

    ..color = const Color(0xFF767DFF).withAlpha(14)

    ..style = PaintingStyle.fill;



  @override

  void paint(Canvas canvas, Size size) {

    final width = size.width;

    final height = size.height;

    final center = Offset(width / 2, height * 3 / 4);

    final rect = Rect.fromCircle(

      center: center,

      radius: 60,

    );

    canvas.drawArc(rect, pi * 0.8, pi * 2 * (0.1 + 0.1 + 0.5), false, _paintBg);

    _paintProgress.shader = ui.Gradient.sweep(

      center,

      [

        const Color(0Xff7A80FF),

        const Color(0XffCACCFF),

        const Color(0Xff7A80FF),

      ],

      [0.0, 0.5, 0.9],

      TileMode.clamp,

    );

    canvas.drawArc(rect, pi * 0.8, (pi * 2 * 0.7) * progress, false, _paintProgress);



    TextPainter textPainter = TextPainter(

      text: const TextSpan(text: '0', style: TextStyle(color: Colors.black, fontSize: 10)),

      textDirection: TextDirection.ltr,

    );

    textPainter.layout(maxWidth: width);

    textPainter.paint(canvas, Offset(width / 2 - 60 + 15, height - 5));

    textPainter.text = const TextSpan(text: '100', style: TextStyle(color: Colors.black, fontSize: 10));

    textPainter.layout(maxWidth: width);

    textPainter.paint(canvas, Offset(width / 2 + 60 - 15 - 20, height - 5));

    Offset c = Offset(width / 2, height * 3 / 4);

    var angle = pi * 0.8 + pi * 2 * (0.1 + 0.1 + 0.5) * progress;

    canvas.drawLine(c + _calXYByRadius(angle, 50), c + _calXYByRadius(angle, 70), _paintLine);



    final o1 = c+_calXYByRadius(angle, 15);

    final o2 = c+_calXYByRadius(angle + pi, 15);

    final o3 = c+_calXYByRadius(angle + 0.5 * pi, 5);

    final o4 = c+_calXYByRadius(angle + pi + 0.5 * pi, 5);

    _path.reset();

    _path.moveTo(o1.dx, o1.dy);

    _path.lineTo(o3.dx, o3.dy);

    _path.lineTo(o2.dx, o2.dy);

    _path.lineTo(o4.dx, o4.dy);

    _path.close();

    _paintCenter.color = const Color(0xFF767DFF);

    canvas.drawPath(_path, _paintCenter);



    _paintCenter.color = const Color(0xFF767DFF).withAlpha(14);

    canvas.drawCircle(c, 20, _paintCenter);

    _paintCenter.color =  Colors.white;

    canvas.drawCircle(c, 2, _paintCenter);

  }



  @override

  bool shouldRepaint(covariant CustomPainter oldDelegate) {

    return (oldDelegate as PlatePainter).progress != progress;

  }



  Offset _calXYByRadius(double angle, double radius) {

    final y = sin(angle) * radius;

    final x = cos(angle) * radius;

    return Offset(x, y);

  }

}

方法二:

import 'dart:math';

import 'dart:ui' as ui;



import 'package:flutter/material.dart';



class PlatePainter2 extends CustomPainter {

  PlatePainter2(

    this.progress,

  );



  final num progress;

  final Paint _paintProgress = Paint()

    ..strokeWidth = 15

    ..style = PaintingStyle.stroke;

  final Paint _paintBg = Paint()

    ..strokeWidth = 15

    ..color = const Color(0xFFC8CAFF).withAlpha(22)

    ..style = PaintingStyle.stroke;

  final Paint _paintLine = Paint()

    ..strokeWidth = 2

    ..color = const Color(0Xff7A80FF)

    ..style = PaintingStyle.fill;

  final Path _path = Path();

  final Paint _paintCenter = Paint()

    ..strokeWidth = 2

    ..color = const Color(0xFF767DFF).withAlpha(14)

    ..style = PaintingStyle.fill;



  @override

  void paint(Canvas canvas, Size size) {

    final width = size.width;

    final height = size.height;

    final center = Offset(width / 2, height /2);

    final rect = Rect.fromCircle(

      center: center,

      radius: 60,

    );

    canvas.drawArc(rect, 0, (pi * 1.4), false, _paintBg);

    _paintProgress.shader = ui.Gradient.sweep(

      center,

      [

        const Color(0XffCACCFF),

        const Color(0Xff7A80FF),

        // const Color(0Xff7A80FF),

        // Colors.white,

        // Colors.black,

      ],

    );

    canvas.drawArc(rect, 0, (pi * 1.4) * progress, false, _paintProgress);



    // TextPainter textPainter = TextPainter(

    //   text: const TextSpan(text: '0', style: TextStyle(color: Colors.black, fontSize: 10)),

    //   textDirection: TextDirection.ltr,

    // );

    // textPainter.layout(maxWidth: width);

    // textPainter.paint(canvas, Offset(width / 2 - 60 + 15, height - 5));

    // textPainter.text = const TextSpan(text: '100', style: TextStyle(color: Colors.black, fontSize: 10));

    // textPainter.layout(maxWidth: width);

    // textPainter.paint(canvas, Offset(width / 2 + 60 - 15 - 20, height - 5));

    Offset c = Offset(width / 2, height /2);

    var angle =  pi *  1.4 * progress;

    canvas.drawLine(c + _calXYByRadius(angle, 50), c + _calXYByRadius(angle, 70), _paintLine);



    final o1 = c+_calXYByRadius(angle, 15);

    final o2 = c+_calXYByRadius(angle + pi, 15);

    final o3 = c+_calXYByRadius(angle + 0.5 * pi, 5);

    final o4 = c+_calXYByRadius(angle + pi + 0.5 * pi, 5);

    _path.reset();

    _path.moveTo(o1.dx, o1.dy);

    _path.lineTo(o3.dx, o3.dy);

    _path.lineTo(o2.dx, o2.dy);

    _path.lineTo(o4.dx, o4.dy);

    _path.close();

    _paintCenter.color = const Color(0xFF767DFF);

    canvas.drawPath(_path, _paintCenter);



    _paintCenter.color = const Color(0xFF767DFF).withAlpha(14);

    canvas.drawCircle(c, 20, _paintCenter);

    _paintCenter.color =  Colors.white;

    canvas.drawCircle(c, 2, _paintCenter);

  }



  @override

  bool shouldRepaint(covariant CustomPainter oldDelegate) {

    return (oldDelegate as PlatePainter2).progress != progress;

  }



  Offset _calXYByRadius(double angle, double radius) {

    final y = sin(angle) * radius;

    final x = cos(angle) * radius;

    return Offset(x, y);

  }

}