模版方法模式

前言

模版方法模式，是行为型设计模式的一种。这个模式的使用频率没有那么高，以至于之前从来没有了解过该模式。不过兄弟们也不用怕，这个模式其实还是比较简单的。等会咱们举个例子，来理解一下这个模式。

介绍

概念理解

模版方法模式，个人理解是，将类中的一些方法执行顺序进行排序。其中的部分方法可以被重写。排序后的方法就是模版方法。排序后的类就是模版类。这种代码设计思路就是模版方法模式。

菜谱：猪脚面

上面的描述可能有点抽象。那么咱就换一个讲法来说一下这个模式。

从前呢，在京海市有一条街叫旧厂街，那里呢有一个菜市场，菜市场里有一个卖鱼的小老板他叫高启强。他呢有一个弟弟妹妹。兄妹三人啊从小就喜欢吃猪脚面。但是由于家里穷，所以三人只够吃一碗面。妹妹高启兰吃猪脚，弟弟高启盛吃面，而高启强就只能喝面汤。

由于的确穷，他就去找饭店老板要了一份菜谱。饭店老板看他可怜就给了他一份猪脚面的菜谱，具体如下：

1. 把水烧开


2. 放面条


3. 放猪脚


4. 放佐料


5. 把面煮熟

他兴高采烈的按照菜谱做了一份猪脚面，给弟弟妹妹吃。可是结果却让他失望了。因为猪脚面的味道出了问题。

他去找了老板，老板对他说，阿强啊，我给你的菜谱肯定没问题，味道不对一定是哪个环节出错了。

于是他又给老板做了一遍。当他放完佐料的时候。老板立刻叫住了他，对他说。阿强，你其他的步骤都没有错，但是放佐料这一步和我有些不一样。

这一步这里你应该要放的是酱油和老抽，再用盐和鸡精调味。可这里你只用了醋来调味，所以味道不对。高启强满脸通红的对老板说，对不起啊老板，我家太穷类没有那些调理所以只能用醋代替了。

在上面这个例子中，这里面的菜谱就是模板也可以说是框架。
菜谱的执行顺序可以被看作是模板方法。而且这里的执行顺序是固定无法被改变的。
执行顺序无法改变，但是具体的做菜步骤却是可以被重写的。比如说放佐料。

例子中的高启强正是由于这一步的不同，导致他做出的猪脚面和老板的口味不一致。

2023春晚

上面这个可以看作是模版方法模式的一个简单举例。接下来咱们再举个有代码的例子加深下对模版方法模式的印象。

春晚模版类

SpringFestivalGala规定了春晚必须遵循的节目流程。这个代码中的start方法，可以看作是模版方法模式中最重要的一环，因为他就是规定了其他方法调用顺序的模版方法。

1. 开场白


2. 唱歌


3. 跳舞


4. 小品


5. 难忘今宵

由于不同卫视的节目顺序都遵循这套模版。而且最后的节目难忘今宵是春晚保留节目，所以该节目必须所有春晚保持一致，具体代码如下所示：

/**

 * Author（作者）：jtl

 * Date（日期）：2023/2/10 20:05

 * Detail（详情）：春晚流程（春晚模版 ）

 */

public abstract class SpringFestivalGala {

    public void start(){

        prologue();

        song();

        dance();

        comedySketch();

        unforgettableTonight();

    }

    //开场白

    public abstract void prologue();

    

    //歌曲节目

    public abstract void song();



    //小品节目

    public abstract void comedySketch();

    

    //舞蹈节目

    public abstract void dance();

    

    //难忘今宵

    private void unforgettableTonight(){

        System.out.println("结尾：难忘今宵");

    }

}

复制代码

上面的代码中，不同的春晚，有着不同的小品舞蹈等节目，所以需要SpringFestivalGala的子类需要重写这几个方法。但是难忘今宵是所有春晚共同的节目。因此可以复用。
而start方法就可以看作是模版方法。它里面的节目执行顺序是固定的无法被改变。

辽视春晚

辽宁春晚继承了春晚的固定模版。具体代码如下：

/**

 * Author（作者）：jtl

 * Date（日期）：2023/2/10 20:42

 * Detail（详情）：辽宁春晚

 */

public class SpringFestivalGalaOfLiaoning extends SpringFestivalGala{

    @Override

    public void prologue() {

        System.out.println("开场白：欢迎来到，2023年，辽宁卫视春晚现场");

    }



    @Override

    public void song() {

        System.out.println("歌曲：孙楠，谭维维-追光");

    }



    @Override

    public void comedySketch() {

        System.out.println("小品：宋小宝-杨树林：非常营销");

    }



    @Override

    public void dance() {

        System.out.println("舞蹈：舞蹈-欢庆中国年");

    }

}

复制代码

央视春晚

央视春晚同样遵循春晚的传统模版。有着开场白，歌曲等精彩的演出。尤其是小品初见照相馆一经播出，一己之力推动年轻人的离婚率，简直是今年节目之最！
央视春晚的具体代码如下：

/**

 * Author（作者）：jtl

 * Date（日期）：2023/2/10 20:53

 * Detail（详情）：CCTV 央视春晚

 */

public class CCTVSpringFestivalGala extends SpringFestivalGala{

    @Override

    public void prologue() {

        System.out.println("开场白：欢迎来到，2023年，央视春晚的现场");

    }



    @Override

    public void song() {

        System.out.println("歌曲：邓超-好运全都来");

    }



    @Override

    public void comedySketch() {

        System.out.println("小品：于震-初见照相馆");

    }



    @Override

    public void dance() {

        System.out.println("舞蹈：辽宁芭蕾舞团：我们的田野上");

    }

}



复制代码

客户端代码

调用这两个类的客户端代码

/**

 * Author（作者）：jtl

 * Date（日期）：2023/2/10 20:04

 * Detail（详情）：模版方法模式客户端

 */

public class Client {

    public static void main(String[] args) {

        CCTVSpringFestivalGala cctv = new CCTVSpringFestivalGala();

        cctv.start();



        System.out.println("----------------分割线----------------");



        SpringFestivalGalaOfLiaoning liaoning = new SpringFestivalGalaOfLiaoning();

        liaoning.start();

    }

}

复制代码

运行结果

结果如图所示

模版方法模式的模版

1. 有一个固定的模版类A，它是一个抽象类


2. 模版类A里有一些方法，这些方法里有需要子类重写的抽象方法


3. 有一个模版方法，它里面有着这些方法的调用顺序。这个顺序是不能被改变的，也是模版方法模式的核心


4. 子类继承模版类A，重写它的抽象方法

后记总结

至此，模版方法模式就算是介绍完毕了。细心的小伙伴可能发现了，模版方法模式的模版如果要扩展的话，就必须改了啊，他这违反了开闭原则啊。

没错，这是这个模式的一个缺陷。从模版方法模式的定义来看，它的概念就是给其他类提供一套固定的执行流程，这个执行流程就是模版方法。其他类只能修改其中的方法，不能修改执行流程,即不能修改模版方法。所以它从定义上就不存在修改执行流程这一可能。可能有点强行洗白，但是这也是一种解释方式。

还是那句话，对于设计模式来说，没有固定的套路。毕竟它只是人们经过长时间总结出来的代码经验。所以千万别被所谓的设计模式框架所拘束，只要符合要求，有利阅读和扩展就是好的代码。

如果喜欢请点个赞，支持一下。有错误或不同想法请及时指正哈。辛苦您看到这里，下篇文章再见哈，👋👋👋

前些天项目经理找到我说,阿杰,你过来一下,我这有个小方法,你帮我写一下

• 需求: 提供一个文本文件,按行读取,然后给出一个回调函数,可以由调用者去实现对每行的处理.

我就想,你这不是瞧不起我吗.5分钟搞定!!嘴里却说,你这个有点难,我需要研究下大概今天下班前能完成.

5分钟过去了----> 代码完成

摸鱼3小时 ----> ok 代码一发,收工准备下班

public void clean2(String path, Consumer<String> consumer){

    FileReader fileReader = null;

    BufferedReader br = null;

    try{

        fileReader = new FileReader(path);

        br = new BufferedReader(fileReader);

        String line;

        while((line = br.readLine()) != null ){

            consumer.accept(line);

        }

    }catch (IOException e){

        // do

    }finally {

        try {

            if (br != null){

                br.close();

            }

            if (fileReader != null){

                fileReader.close();

            }

        } catch (IOException e) {

            // do

        }

    }

}

项目经理 😶😶😶😶: 你tm明天别来了,自己去财务把这个月的结了,3行代码就写完的功能写成这个鬼样子.

那我就想啊,我写的这么完美,那凭什么开除我,经过我九九八十一天的苦思冥想,终于找到了问题的原因!!

try-cache-finally

try-finally 是java SE7之前我们处理一些需要关闭的资源的做法，无论是否出现异常都要对资源进行关闭。*

如果try块和finally块中的方法都抛出异常那么try块中的异常会被抑制（suppress），只会抛出finally中的异常，而把try块的异常完全忽略。

这里如果我们用catch语句去获得try块的异常，也没有什么影响，catch块虽然能获取到try块的异常但是对函数运行结束抛出的异常并没有什么影响。

try-with-resources

try-with-resources语句能够帮你自动调用资源的close()函数关闭资源不用到finally块。

前提是只有实现了Closeable接口的才能自动关闭

public void clean(String path, Consumer<String> consumer) throws IOException {

    try (BufferedReader br = new BufferedReader(new FileReader(path))) {

        String line;

        while((line = br.readLine()) != null ){

            consumer.accept(line);

        }

    }

}

这是try-with-resources语句的结构，在try关键字后面的( )里new一些需要自动关闭的资源。

这个时候如果方法 readLine 和自动关闭资源的过程都抛出异常，那么：

1. 
   

   函数执行结束之后抛出的是try块的异常，而try-with-resources语句关闭过程中的异常会被抑制，放在try块抛出的异常的一个数组里。（上面的非try-with-resources例子抛出的是finally的异常，而且try块的异常也不会放在fianlly抛出的异常的抑制数组里）

   
   


2. 
   

   可以通过异常的public final synchronized Throwable[] getSuppressed() 方法获得一个被抑制异常的数组。

   
   


3. 
   

   try块抛出的异常调用getSuppressed()方法获得一个被它抑制的异常的数组，其中就有关闭资源的过程产生的异常。

   
   

try-with-resources 语句能放多个资源,使用 ; 分割

try (

        BufferedReader br = new BufferedReader(new FileReader(path));

        ZipFile zipFile = new ZipFile("");

        FileReader fileReader = new FileReader("");

) {



}

最后任务执行完毕或者出现异常中断之后是根据new的反向顺序调用各资源的close()的。后new的先关。

try-with-resources 语句也可以有 catch 和 finally 块

public void clean3(String path, Consumer<String> consumer){

    try (BufferedReader br = new BufferedReader(new FileReader(path))) {

        System.out.println("RuntimeException 前");

        int a = 1/0;

        System.out.println("RuntimeException 后");

    }catch (RuntimeException e){

        System.out.println("抛出 RuntimeException");

    }catch (IOException e){

        System.out.println("抛出 RuntimeException");

    }finally {

        System.out.println("finally");

    }

}

RuntimeException 前

抛出 RuntimeException

finally

本章节是Compose自定义绘制的第二章，画的是一个之前设计给的一个比较复杂的，设计所谓的会呼吸的动画，那时候实现花了蛮长的时间，搬着电脑跟设计一帧一帧地对，没多久后来需求就被拿掉了，至于文章的标题哈哈随意起了一个，长得有点像而已。

Compose的实现，图形本身跟上一章节的LocationMarker其实差不太多，倒过来了而已，调整了P1跟P3, 基本图形的Path，这里不再做介绍，读者也可以去看代码实现。主要介绍一下动画吧。

首先看一下gif动图：

整个图形分三层，最底层是灰色的背景，没有动画实现。

第二层是一个层变的动画，每层有个delay的不同延迟，对alpha最一个ObjectAnimator.ofFloat(water1, "alpha", 0f, 0.5f, 0.2f, 1f)渐变的动画，0.5f 到0.2f, 再到1f这个地方展现出所谓的呼吸的感觉。Compose目前写的不多，有些冗余代码没有抽象，先实现了功能效果。

@Composable

fun drawWaterDrop(){

  val waterDropModel by remember {

  mutableStateOf(WaterDropModel.waterDropM)

  }

  val color1 = colorResource(id = waterDropModel.water1.colorResource)

  val color2 = colorResource(id = waterDropModel.water2.colorResource)

  val color3 = colorResource(id = waterDropModel.water3.colorResource)

  val color4 = colorResource(id = waterDropModel.water4.colorResource)

  val color5 = colorResource(id = waterDropModel.water5.colorResource)

  val color6 = colorResource(id = waterDropModel.water6.colorResource)

  val color7 = colorResource(id = waterDropModel.water7.colorResource)

  val color8 = colorResource(id = waterDropModel.water8.colorResource)



  val animAlpha1 = remember { Animatable(0f, Float.VectorConverter) }

  val animAlpha2 = remember { Animatable(0f, Float.VectorConverter) }

  val animAlpha3 = remember { Animatable(0f, Float.VectorConverter) }

  val animAlpha4 = remember { Animatable(0f, Float.VectorConverter) }

  val animAlpha5 = remember { Animatable(0f, Float.VectorConverter) }

  val animAlpha6 = remember { Animatable(0f, Float.VectorConverter) }

  val animAlpha7 = remember { Animatable(0f, Float.VectorConverter) }

  val animAlpha8 = remember { Animatable(0f, Float.VectorConverter) }



 

    LaunchedEffect(Unit){

        animAlpha1.animateTo(1f, animationSpec = myKeyframs(0))

    }

    LaunchedEffect(Unit){

        animAlpha2.animateTo(1f, animationSpec = myKeyframs(1))

    }

    LaunchedEffect(Unit){

        animAlpha3.animateTo(1f, animationSpec = myKeyframs(2))

    }

    LaunchedEffect(Unit){

        animAlpha4.animateTo(1f, animationSpec = myKeyframs(3))

    }

    LaunchedEffect(Unit){

        animAlpha5.animateTo(1f, animationSpec = myKeyframs(4))

    }

    LaunchedEffect(Unit){

        animAlpha6.animateTo(1f, animationSpec = myKeyframs(5))

    }

    LaunchedEffect(Unit){

        animAlpha7.animateTo(1f, animationSpec = myKeyframs(6))

    }

    LaunchedEffect(Unit){

        animAlpha8.animateTo(1f, animationSpec = myKeyframs(7))

    }



  Canvas(modifier = Modifier.fillMaxSize()){

  val contentWidth = size.width

  val contentHeight = size.height

  withTransform({

  translate(left = contentWidth / 2, top = contentHeight / 2)}) {

  drawPath(AndroidPath(waterDropModel.water8Path), color = color8, alpha = animAlpha8.value)

  drawPath(AndroidPath(waterDropModel.water7Path), color = color7, alpha = animAlpha7.value)

  drawPath(AndroidPath(waterDropModel.water6Path), color = color6, alpha = animAlpha6.value)

  drawPath(AndroidPath(waterDropModel.water5Path), color = color5, alpha = animAlpha5.value)

  drawPath(AndroidPath(waterDropModel.water4Path), color = color4, alpha = animAlpha4.value)

  drawPath(AndroidPath(waterDropModel.water3Path), color = color3, alpha = animAlpha3.value)

  drawPath(AndroidPath(waterDropModel.water2Path), color = color2, alpha = animAlpha2.value)

  drawPath(AndroidPath(waterDropModel.water1Path), color = color1, alpha = animAlpha1.value)

  }

  }

}



private fun myKeyframs(num:Int):KeyframesSpec<Float>{

    return keyframes{

        durationMillis = 3000

        delayMillis = num * 2000

        0.5f at 1000 with LinearEasing

        0.2f at 2000 with LinearEasing

    }

}

然后就是外层扫光的动画，像探照灯一样一圈圈的扫，一共扫7遍，代码跟层变动画差不多，也是对alpha值做渐变，目前代码是调用扫光动画7次，后续看看如何优化性能。每次调用传入不同的delay值即可。

@Composable

fun drawWaterDropScan(delayTime:Long){

    val waterDropModel by remember {

        mutableStateOf(WaterDropModel.waterDropMScan)

    }

    val color1 = colorResource(id = waterDropModel.water1.colorResource)

    val color2 = colorResource(id = waterDropModel.water2.colorResource)

    val color3 = colorResource(id = waterDropModel.water3.colorResource)

    val color4 = colorResource(id = waterDropModel.water4.colorResource)

    val color5 = colorResource(id = waterDropModel.water5.colorResource)

    val color6 = colorResource(id = waterDropModel.water6.colorResource)

    val color7 = colorResource(id = waterDropModel.water7.colorResource)

    val color8 = colorResource(id = waterDropModel.water8.colorResource)

    val animAlpha2 = remember { Animatable(0f, Float.VectorConverter) }

    val animAlpha3 = remember { Animatable(0f, Float.VectorConverter) }

    val animAlpha4 = remember { Animatable(0f, Float.VectorConverter) }

    val animAlpha5 = remember { Animatable(0f, Float.VectorConverter) }

    val animAlpha6 = remember { Animatable(0f, Float.VectorConverter) }

    val animAlpha7 = remember { Animatable(0f, Float.VectorConverter) }

    val animAlpha8 = remember { Animatable(0f, Float.VectorConverter) }



    LaunchedEffect(Unit){

        delay(delayTime)

        val map = mutableMapOf<Float, Int>().apply { put(1f, 350) }

        animAlpha2.animateTo(0f, animationSpec = myKeyframs2(700, 0, map))

    }



    LaunchedEffect(Unit){

        delay(delayTime)

        val map = mutableMapOf<Float, Int>().apply { put(0.8f, 315) }

        animAlpha3.animateTo(0f, animationSpec = myKeyframs2(630, 233, map))

    }



    LaunchedEffect(Unit){

        delay(delayTime)

        val map = mutableMapOf<Float, Int>().apply { put(0.55f, 315) }

        animAlpha4.animateTo(0f, animationSpec = myKeyframs2(630, 383, map))

    }



    LaunchedEffect(Unit){

        delay(delayTime)

        val map = mutableMapOf<Float, Int>().apply { put(0.5f, 325) }

        animAlpha5.animateTo(0f, animationSpec = myKeyframs2(650, 533, map))

    }



    LaunchedEffect(Unit){

        delay(delayTime)

        val map = mutableMapOf<Float, Int>().apply { put(0.45f, 325) }

        animAlpha6.animateTo(0f, animationSpec = myKeyframs2(650, 667, map))

    }



    LaunchedEffect(Unit){

        delay(delayTime)

        val map = mutableMapOf<Float, Int>().apply { put(0.35f, 283) }

        animAlpha7.animateTo(0f, animationSpec = myKeyframs2(567, 816, map))

    }



    LaunchedEffect(Unit){

        delay(delayTime)

        val map = mutableMapOf<Float, Int>().apply { put(0.3f, 216) }

        animAlpha8.animateTo(0f, animationSpec = myKeyframs2(433, 983, map))

    }



  Canvas(modifier = Modifier.fillMaxSize()){

  val contentWidth = size.width

  val contentHeight = size.height



  withTransform({

  translate(left = contentWidth / 2, top = contentHeight / 2)

  }) {

  drawPath(AndroidPath(waterDropModel.water8Path), color = color8, alpha = animAlpha8.value)

  drawPath(AndroidPath(waterDropModel.water7Path), color = color7, alpha = animAlpha7.value)

  drawPath(AndroidPath(waterDropModel.water6Path), color = color6, alpha = animAlpha6.value)

  drawPath(AndroidPath(waterDropModel.water5Path), color = color5, alpha = animAlpha5.value)

  drawPath(AndroidPath(waterDropModel.water4Path), color = color4, alpha = animAlpha4.value)

  drawPath(AndroidPath(waterDropModel.water3Path), color = color3, alpha = animAlpha3.value)

  drawPath(AndroidPath(waterDropModel.water2Path), color = color2, alpha = animAlpha2.value)

  drawPath(AndroidPath(waterDropModel.water1Path), color = color1)

  }

  }

}



private fun myKeyframs2(durationMillisParams:Int, delayMillisParams:Int, frames:Map<Float, Int>):KeyframesSpec<Float>{

    return keyframes{

        durationMillis = durationMillisParams

        delayMillis = delayMillisParams

        for ((valueF, timestamp) in frames){

           valueF at timestamp

        }

    }

}





@Preview

@Composable

fun WaterDrop(){

    Box(modifier = Modifier.fillMaxSize()){

        drawWaterDropBg()

        drawWaterDrop()

        for (num in 1 .. 7){

            drawWaterDropScan(delayTime = num * 2000L)

        }

    }

}

代码跟LocationMarker在一个Project里面，暂时没有添加导航。github.com/yinxiucheng… 下的CustomerComposeView.

Android引入约束布局的目的是为了减少布局层级的嵌套，从而提升渲染性能。约束布局综合线性布局、相对布局、帧布局的部分功能，缺点也很明显，就是可能要多写几行代码。所以约束布局使用时，还得综合考虑代码量。提升性能也并不一定非得使用约束布局，也可以在ViewGroup上dispatchDraw。你需要根据业务的具体情况选择最合适的实现方式。我知道很多人一开始很不习惯使用约束布局，但既然你诚心诚意问我怎么使用了？于是我就大发慈悲告诉你怎么使用呗。

链式约束

用得最多的非链式约束莫属了。这看起来是不是类似于相对布局？那么有人问了，既然相对布局写法这么简洁，都不用强制你写另一个方向的占满屏幕的约束，为什么还要使用约束布局呢？约束布局它还是有它过布局之处的，比如以下一些功能，相对布局是做不到的。

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

<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"

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

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

    android:layout_width="match_parent"

    android:layout_height="match_parent">

    <ImageView

        android:id="@+id/iv1"

        android:layout_width="100dp"

        android:layout_height="100dp"

        android:background="#F0F"

        app:layout_constraintVertical_chainStyle="spread"

        app:layout_constraintTop_toTopOf="parent"

        app:layout_constraintEnd_toEndOf="parent"

        app:layout_constraintStart_toStartOf="parent"

        app:layout_constraintBottom_toTopOf="@+id/iv2"/>



    <ImageView

        android:id="@+id/iv2"

        android:layout_width="100dp"

        android:layout_height="100dp"

        android:background="#FF0"

        app:layout_constraintBottom_toTopOf="@id/iv3"

        app:layout_constraintEnd_toEndOf="parent"

        app:layout_constraintStart_toStartOf="parent"

        app:layout_constraintTop_toBottomOf="@+id/iv1"/>

    <ImageView

        android:id="@+id/iv3"

        android:layout_width="100dp"

        android:layout_height="100dp"

        android:background="#0FF"

        app:layout_constraintBottom_toTopOf="@id/iv4"

        app:layout_constraintEnd_toEndOf="parent"

        app:layout_constraintStart_toStartOf="parent"

        app:layout_constraintTop_toBottomOf="@+id/iv2"/>

    <ImageView

        android:id="@+id/iv4"

        android:layout_width="100dp"

        android:layout_height="100dp"

        android:background="#0F0"

        app:layout_constraintBottom_toBottomOf="parent"

        app:layout_constraintEnd_toEndOf="parent"

        app:layout_constraintStart_toStartOf="parent"

        app:layout_constraintTop_toBottomOf="@+id/iv3"/>

</androidx.constraintlayout.widget.ConstraintLayout>

我们可以在链首的控件添加一个layout_constraintVertical_chainStyle属性为spread，翻译成展开，在我看来就是排队，要保持间距一样，而且边缘不能站，默认不写也是指定的spread。

如果你改成spread_inside，就会变成可以靠墙的情况。

那如果你改成packed，就会贴在一起了。

使用Group分组进行显示和隐藏

而如果你添加以下代码在布局中，就会将id为iv1和iv3点色块去掉，这样iv2和iv4就贴在一起了。

<androidx.constraintlayout.widget.Group

    android:id="@+id/group"

    android:layout_width="wrap_content"

    android:layout_height="wrap_content"

    android:visibility="gone"

    app:constraint_referenced_ids="iv1,iv3" />

Guideline引导线

<androidx.constraintlayout.widget.Guideline

    android:layout_width="wrap_content"

    android:layout_height="wrap_content"

    android:orientation="vertical"

    app:layout_constraintGuide_percent="0.5"/>

使用引导线，可以在预览布局的时候看到，在运行时是看不到的，可以作为布局的参考线。

切换到Design的选项卡你就能看到了。
引导线的另外两个属性是layout_constraintGuide_begin和layout_constraintGuide_end，一看就知道这个是使用边距定位的。

角度约束

角度约束的以下三个属性是一起使用的。

layout_constraintCircle  

layout_constraintCircleAngle

layout_constraintCircleRadius  

<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"

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

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

    android:layout_width="match_parent"

    android:layout_height="match_parent">



    <ImageView

        android:id="@+id/iv1"

        android:layout_width="100dp"

        android:layout_height="100dp"

        android:background="#FFC0C0"

        app:layout_constraintTop_toTopOf="parent"

        app:layout_constraintEnd_toEndOf="parent"

        app:layout_constraintStart_toStartOf="parent"

        app:layout_constraintBottom_toBottomOf="parent"/>



    <ImageView

        android:id="@+id/iv2"

        android:layout_width="100dp"

        android:layout_height="100dp"

        android:background="#FF0"

        app:layout_constraintCircle="@id/iv1" 

        app:layout_constraintCircleAngle="30"

        app:layout_constraintCircleRadius="150dp"/>

    <androidx.constraintlayout.widget.Guideline

        android:layout_width="wrap_content"

        android:layout_height="wrap_content"

        android:orientation="horizontal"

        app:layout_constraintGuide_percent="0.5"/>

    <androidx.constraintlayout.widget.Guideline

        android:layout_width="wrap_content"

        android:layout_height="wrap_content"

        android:orientation="vertical"

        app:layout_constraintGuide_percent="0.5"/>



</androidx.constraintlayout.widget.ConstraintLayout>

知道你们喜欢粉嫩的，所以特地把色块的颜色换了一下。旋转角是以垂直向上为0度角，顺时针旋转30度。距离则是计算两控件重心的连线。在矩形区域中，重心就在对角线的交叉点。

位置百分比偏移

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

<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"

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

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

    android:layout_width="match_parent"

    android:layout_height="match_parent">



    <ImageView

        android:id="@+id/iv1"

        android:layout_width="100dp"

        android:layout_height="100dp"

        android:background="#FFC0C0"

        app:layout_constraintStart_toStartOf="parent"

        app:layout_constraintEnd_toEndOf="parent"

        app:layout_constraintHorizontal_bias="0.5"

        app:layout_constraintTop_toTopOf="parent"

        app:layout_constraintBottom_toTopOf="@+id/iv2"/>



    <ImageView

        android:id="@+id/iv2"

        android:layout_width="100dp"

        android:layout_height="100dp"

        android:background="#FF0"

        app:layout_constraintStart_toStartOf="parent"

        app:layout_constraintEnd_toEndOf="parent"

        app:layout_constraintHorizontal_bias="0.4"

        app:layout_constraintBottom_toBottomOf="parent"

        app:layout_constraintTop_toBottomOf="@+id/iv1"/>

    <androidx.constraintlayout.widget.Guideline

        android:layout_width="wrap_content"

        android:layout_height="wrap_content"

        android:orientation="vertical"

        app:layout_constraintGuide_percent="0.5"/>

</androidx.constraintlayout.widget.ConstraintLayout>

这里需要注意，不是只使用layout_constraintHorizontal_bias就可以了，原有该方向的约束也不能少。

使用goneMargin设置被依赖的控件gone时，依赖控件的边距

goneMargin有以下属性：

layout_goneMarginStart  

layout_goneMarginEnd  

layout_goneMarginTop  

layout_goneMarginBottom  

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

<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"

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

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

    android:layout_width="match_parent"

    android:layout_height="match_parent"

    tools:context=".MainActivity">



    <ImageView

        android:id="@+id/iv1"

        android:layout_width="100dp"

        android:layout_height="100dp"

        android:background="#FFC0C0"

        android:visibility="gone"

        app:layout_constraintTop_toTopOf="parent"

        app:layout_constraintEnd_toEndOf="parent"

        app:layout_constraintStart_toStartOf="parent"

        app:layout_constraintBottom_toTopOf="@+id/iv2"/>



    <ImageView

        android:id="@+id/iv2"

        android:layout_width="100dp"

        android:layout_height="100dp"

        android:background="#FF0"

        app:layout_goneMarginTop="10dp"

        app:layout_constraintTop_toBottomOf="@+id/iv1"

        app:layout_constraintEnd_toEndOf="parent"

        app:layout_constraintStart_toStartOf="parent"/>



    <androidx.constraintlayout.widget.Guideline

        android:layout_width="wrap_content"

        android:layout_height="wrap_content"

        android:orientation="horizontal"

        app:layout_constraintGuide_begin="10dp"/>

</androidx.constraintlayout.widget.ConstraintLayout>

约束宽高比

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

<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"

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

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

    android:layout_width="match_parent"

    android:layout_height="match_parent">



    <ImageView

        android:id="@+id/iv1"

        android:layout_width="0dp"

        android:layout_height="100dp"

        app:layout_constraintDimensionRatio="1:1"

        android:background="#FFC0C0"

        app:layout_constraintStart_toStartOf="parent"

        app:layout_constraintEnd_toEndOf="parent"

        app:layout_constraintTop_toTopOf="parent"

        app:layout_constraintBottom_toTopOf="@id/iv2"/>



    <ImageView

        android:id="@+id/iv2"

        android:layout_width="100dp"

        android:layout_height="0dp"

        android:background="#FF0"

        app:layout_constraintDimensionRatio="H,3:2"

        app:layout_constraintStart_toStartOf="parent"

        app:layout_constraintEnd_toEndOf="parent"

        app:layout_constraintTop_toBottomOf="@id/iv1"

        app:layout_constraintBottom_toBottomOf="parent"/>

</androidx.constraintlayout.widget.ConstraintLayout>

我们可以将宽高的其中一个设置为0dp，然后这个宽或高根据相对于另一个的比例来。如果高度为0dp，需要根据宽度来确认高度，你可以直接赋值为3:2，也可以赋值为H,3:2，这也是推荐的写法，我一般省略W和H。如果高度为0dp，你本应该写H，而你写成了W，那就要把比例反过来看宽高比。

权重约束

这个类似于线性布局的权重功能。

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

<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"

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

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

    android:layout_width="match_parent"

    android:layout_height="match_parent">



    <ImageView

        android:id="@+id/iv1"

        android:layout_width="100dp"

        android:layout_height="0dp"

        app:layout_constraintVertical_weight="1"

        android:background="#FFC0C0"

        app:layout_constraintStart_toStartOf="parent"

        app:layout_constraintEnd_toEndOf="parent"

        app:layout_constraintTop_toTopOf="parent"

        app:layout_constraintBottom_toTopOf="@id/iv2"/>



    <ImageView

        android:id="@+id/iv2"

        android:layout_width="100dp"

        android:layout_height="0dp"

        app:layout_constraintVertical_weight="2"

        android:background="#FF0"

        app:layout_constraintStart_toStartOf="parent"

        app:layout_constraintEnd_toEndOf="parent"

        app:layout_constraintTop_toBottomOf="@id/iv1"

        app:layout_constraintBottom_toBottomOf="parent"/>

</androidx.constraintlayout.widget.ConstraintLayout>

前言

本来准备过年时候慢慢写，但过完年才发现一篇都没写，真是难为情，今天我们就看看RabbitAPP中进入webview中使用的兔兔进度条，参考了51博客网的自定义progress的方法（自定义view之自定义电池效果_xiyangyang8110的技术博客_51CTO博客），其实还是挺简陋的，本来想画一个兔子跑的指示器的progress的，但是想了半天没动手，还是采用这种最简单的方法。

正篇

最终效果

首先我们来看看效果：

实现方法

实现方法其实很简单，先给一张图片，然后调用ProgressBar控件覆盖它，并且重新写ProgressBar的样式：

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

<resources>

    <style name="StyleRabbitProgressBar" parent="Widget.AppCompat.ProgressBar.Horizontal">

        <item name="android:progressDrawable">@drawable/shape_progressbar</item>

    </style>

</resources>

我们这里使用了ProgressBar的水平进度条样式，然后对其sprogressDrawable重新添加shape:

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

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

    <!--progressbar的背景颜色-->

    <!--    <item android:id="@android:id/background">-->

    <!--        <shape>-->

    <!--            <corners android:radius="5dip" />-->

    <!--            <gradient-->

    <!--                android:startColor="@color/black"-->

    <!--                android:centerColor="@color/blue"-->

    <!--                android:endColor="@color/black"-->

    <!--                android:angle="270"-->

    <!--                />-->

    <!--        </shape>-->

    <!--    </item>-->

    <!--progressBar的缓冲进度颜色-->

    <!--    <item android:id="@android:id/secondaryProgress">-->

    <!--        <clip>-->

    <!--            <shape>-->

    <!--                <corners android:radius="5dip" />-->

    <!--                <gradient-->

    <!--                    android:startColor="@color/white"-->

    <!--                    android:centerColor="@color/white"-->

    <!--                    android:endColor="@color/white"-->

    <!--                    android:angle="270"-->

    <!--                    />-->

    <!--            </shape>-->

    <!--        </clip>-->

    <!--    </item>-->

    <!--progressBar的最终进度颜色-->

    <item android:id="@android:id/progress">

        <clip>

            <shape>

                <corners android:radius="5dip" />

                <gradient

                    android:startColor="#33E91E63"

                    android:centerColor="#33E91E63"

                    android:endColor="#33E91E63"

                    android:angle="270"

                    />

            </shape>

        </clip>

    </item>

</layer-list>

根据需要对进度颜色进行控制，我们最终采用棕红色，对进度条颜色变更，最后我们加入到webview页面的布局中：

<RelativeLayout

    android:layout_width="wrap_content"

    android:layout_height="wrap_content"

    android:layout_gravity="center">



    <ImageView

        android:layout_width="wrap_content"

        android:layout_height="wrap_content"

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

    <ProgressBar

        android:id="@+id/progressRabbit"

        android:layout_marginTop="5dp"

        android:layout_marginStart="4dp"

        style="@style/StyleRabbitProgressBar"

        android:layout_width="130dp"

        android:layout_height="120dp"

        android:max="100" />

</RelativeLayout>

最后，再到webview页面的Activity代码中控制显示：

 binding.vWebView.webChromeClient = object : WebChromeClient() {

            override fun onProgressChanged(view: WebView?, newProgress: Int) {

                Log.i("onPageStarted", "页面加载")



                binding.progressRabbit.progress = newProgress

            }

我们通过WebView的webChromeClient方法对onProgressChanged复写，对其中的newProgress参数赋值给我们进度条控件的progress参数，这样就起到了对网页加载的可视化。

于是我们就可以在web加载的时候看到上面有个兔子，兔子的背景全红后就加载好网页了。

总结

这个进度条现在越看越难受，下一次会把进度条重新制作一遍，还是把它作为指示器去绘制一个进度条比较好，不过之前我写自定义view都是用Java，Kotlin中还是不会写，希望能尽快学会用Kotlin自定义view，感谢您的观看。

春节长假的尾巴怕是抓不住了，那就安心等五一吧。

可一回到岗位上，熟悉的办公室味道，熟悉的同事，月薪8000，互相笑嘻嘻。

突然迎来老板的动员大会，今年蒸蒸日上，大家共创辉煌，抿一口蛋糕，大家都是一家人。

但仔细想了想，你还欠我年终奖呢。

回到几平米的屋子，用身子量了量床，打开某脉，某乎，果然大家都一样，年终奖没发；简历石沉大海；发消息只读不回。

顺手打开某招聘，看了看岗位，这个厂还不错，可是要求好高，我啥都不会。

“哎，算了，我简历还没更新呢，我躺到6月份拿到年终奖再跑路。”

“Timi~”

这是不是你的状态呢？我们习惯被一些悲观的环境因素所影响，以至于在网络上寻求共鸣，麻痹自己停滞不前，甚至看到别人比自己惨内心略显喜悦。

最终一年一年下来，玩没玩到，钱没赚到，反倒把自己给内耗住了。

故此，写一篇求职经验相关的文章，此文不对职业规划做文章，也不是鼓励跳槽，更不是和任何人作对。

而是，刚毕业求职，打算跳槽，已经离职进行求职的一个经验分享。

也是以我经验以及身边大佬的一些经验进行分享。这里包含面试前的心态调整、简历制作、面试沟通指导等内容。

文末更有简历模板，全面的面试资料，以及面试经验指导。

心态篇

第一个需要转变的就是心态问题。在这里我其实主张“平等相待，泰然处之”。

很多伙伴对于求职的心态总是低于其一端，但是其本质是你提供劳动力，对方提供相应的报酬，一拍即合的事，没有因为对方提供报酬你就对他畏首畏尾。

从我毕业到现在，没有任何一场因为自己菜，对面试官的提问答不出来，题目做不出来，但是对面试官毕恭毕敬，甚至低头哈腰而促成一个岗位。

很简单，面试官也是一个员工，负责技术把关。当你实力不行但是态度很OK的时候，面试官点头同意，进入岗位后所造成的一切损失，面试官也会面临连带作用，被质疑技术行不行，看人准不准。他们也渴望一场势均力敌的较量呢。

所以，我们尽可能的对阵面试官，都能把心态置于同一水平上，不卑不亢，切磋技术，聊经验，聊项目，全当朋友一样聊天。

技术栈势均力敌就多沟通探讨一点，他强就虚心请教并告知某某知识点还没过多接触，你强就大致内容讲述出来，点到为止不要秀技即可。

我相信面试官基本在公司具备一定权重的，或许有可能就是入职引导你的人。也是很讲礼貌的，基础的问候相信大家都明白，也不讲述，讲多了画风就变了。

摆平心态不是几句劝诫的话就能做到的。

我以前比较弱势，对人心态总是低于一端，语气小，讲的内容不够自信甚至紧张，一紧张很多马脚露出来了，一些知识点的也连不上，支支吾吾作答。

所以我在2022年就专门花了心思去解决这一问题，具体行动往期文章也有透露，但帮助最大的还是反复阅读 《庄子.内篇》 以及B站的视频注解，让我的内心平淡了很多，也看开了很多，内篇中比较出名的在我们高中课本《逍遥游》也有学到。

“至人无己，神人无功，圣人无名。”

所有的一切，领导也好，老板也好，大佬也好。都是自己的意识有意给人贴上的标签，本质都是人，都是生物，多细胞生物。

或许吃穿奢靡，身居庙堂，那又如何呢？不都是碳基生物吗？

描述有些不当，本意是让大家心态放开点，没有什么大不了的。

依我个人经验，在自己的心结开放了之后，在面试求职时，基本对等谈话，会的知识点就多说一点，对知识点不那么熟就借助经验和案例来分析，不会就讲明没有过多了解，不丢人。

在平等状态下聊天，很多知识点能够由点连成片，顺势探讨下去，不仅你的感觉良好，面试官体验也很棒。

我在2022年国庆结束后，裸辞后选择继续求职，深圳和杭州都有offer，更有甚者免试用期，14薪，增加薪资邀请加入他们。

在那一刻明白，企业在面对一个真正人才时不会吝啬待遇，关键你是不是他要找的人。

简历篇

简历，或许是每一位求职者的第一道门槛，一个简历能够看出你对这份职业的用心程度，和你的细心严谨程度。

为什么这么说呢？

前阵子也帮一些伙伴检查过和更改过简历，一路下来更新简历版本中，出现过错别字，排版不雅观，描述有误，甚至有时候邮箱，电话号码都写错过。

纠结简历石沉大海，只读不回的原因，往往是一些细节导致。有些 HR 对于文字是很严苛的，一见到细微地方不对，就会联想到候选人不够严谨。毕竟作为一名程序员，对数据严谨和信息敏感难道不是应该的吗？

基础信息，岗位经历描述切勿忽视，文字表达也是需要斟酌，完事后多审查几遍，这个只有靠自己的习惯和用心程度。

连自己的简历都看不到 5 遍，这是对自己的自信还是对自己经历不忍直视，何况给人改简历挑毛病都要阅读几遍呢。

那我们回归到简历排版上，选择排版上也推崇精简排版，把一些基础信息，工作经历，技术栈描述清楚就OK，并不需要多花里胡哨。

在描述专业技能时，根据自身情况描述清楚，注意一些技术名词的写法，有些技术严谨的人对于写法还是尤其在意的。

曾有一次自己写的一篇文章对一个技术英文写法不正确，一部分的人对我进行批评和纠正。所以有一些细微的细节在自己看来微乎其微甚至无所谓，但总是有人会持有不同看法。

▲图/ 简历基础信息示例一

又如下图，精简模板即可，把自己的基本信息描述清楚即可，谨慎出现错别字和联系方式信息错误等。

▲图/ 简历基础信息示例二

有伙伴咨询过我，如果自己是专升本的情况该怎么填写简历。

如果是以上情况，可以准备多份简历，一份简历头部的基础，学历为本科，院校为本科院校，在后面的教育背景一栏，则一行为本科院校，第二行为专科院校。

另一份，则简历头部基础信息填写本科的学校信息，教育背景这一栏清除不填写或者只写本科一栏。

▲图/ 简历教育信息示例一

如果是你心仪的岗位，根据岗位要求，发送相应要求的简历，先获取展示自己的机会再说。

至于项目经历，这可能是第二重点，一些岗位会根据你的经历来招聘，上手会快一些，比如一家企业的岗位物联网方向较多，那他更加倾向于熟悉在物联网设备上有相关经历的伙伴。

同时在面试时，面试官更多可能通过你的项目经历以及用到的技术栈来考察你。

这里有个小技巧就是，你的技术栈和项目经历可以按实际需求写，当你发现有一些岗位是你心仪但是你又没有相关经验之后，你的技术栈和项目经历里可以稍微加上匹配岗位的技术栈和技术使用经历，这里虽然给自己留了坑，但是在获取面试机会之后需要自己补充相关的知识点。

▲图/ 简历项目经历示例一

▲图/ 简历项目经历示例二

以上两个案例，描述一个项目经历的基本信息，包含项目是什么，怎么做，做了什么，你负责并担任了什么，你的收获又是什么。

通俗一点，就是不要以自己的角度去写，要给到面试官角度去写，让面试官通过你的项目经历了解你的能力和经历，知道这个项目的权重比重是否大，你又负责了多少职责以及使用了什么手段去完成这个项目。

自我介绍一栏，阐明自己的一些辅助优点，例如你的自我评价是怎样的一个人，对于团队、岗位你能够具备什么样的素质，以及业余会干嘛，是否有更迭技术等等。

▲图/ 简历自我评价示例一

▲图/ 简历自我评价示例二

另外，简历文件的格式一定要规范化，文件命名名为：姓名+岗位+学历+联系方式。 例如：桑小榆-开发岗-本科-1517258505。

这里有伙伴不规范原因就是以自身角度想法，打开一看就知道是你，但是没经历过永远不知道一个 HR 面对一群人挑选简历时的心酸，命名的规范化突出略显重要。

面试篇

前期的准备，都是在做铺垫，为的就是和面试官阵面对决，这绝对是一个综合素质的体现，展示技术情况，沟通实力以及心理素质情况。

对于前期心态的准备以及简历的准备，很幸运的被邀请到了面试，这时候你需要准备的就是对被邀请的企业背景了解和岗位的大致了解。

以至于不那么被动的和面试官尬聊：你有什么想要问的吗？

这里面试的环境，基本包含了笔试，机试，面聊等等。

对于笔试和机试，那一定是对于自身知识储备的考验了，这里需要我们自身去积累和回顾了。

面试造飞机，工作拧螺丝或许是很常见的行为，这也不得不让我们需要对笔试题和机试题的一些提前准备了。

找工作不容易，大家何尝不想当一名八股文选手，怕就怕有人连八股文的苦都不想吃。

这里我也准备了 Web 岗位，.NET 岗位，和 JAVA 岗位的面试资料，更有简历模板奉上，大家也可在文末查看。

对于面试时自我介绍，如果你能够很好的讲诉自己那不用说，如果不是很清晰，可以自己写好一段自我介绍，记熟悉就好，面试的时候围绕着写的内容可以很好的完成自我介绍。

对于技术面试，大多会围绕你简历所写的知识进行提问，尽可能的熟悉你的简历和所写到的技术栈，在回答问题时尽量引导你熟悉的技术范围内，不要炫技或者提到你听过但是不熟悉的知识点，这样引导下去将会很糟糕。

我曾经有一次就是回答 AOP 编程思想时，讲完一些大概内容之后还提到了框架的使用，结果对面直接提问如果不用框架，自己手动代码实现会怎么做，这就往困难的方向了，好在心态比较稳加上有过经验一点一点回答上了。

结束篇

如果，老东家不是那么抠门，我找啥自行车啊。

如果，老东家体恤员工的不易，我也不用每天花力气惦记上个月的工资还没发，年终奖还欠我呢。

如果，老东家足够爽快，我也不用每天猜测啥时候涨薪，也不用每天刷刷岗位，偷偷打电话。

哎呀，人与人之间咋就这么复杂呢~

如果，你的老东家亏待了你，或者你看不到未来了，你可以试试以下步骤：

金三银四路线

1.着手准备自己技术栈的复盘和技术栈更迭；

2.打开LeetCode，每日练习算法题，开拓思路；

3.查看相关岗位并更新自己的简历；

4.提前准备好自我介绍，几个提问的问题；

5.交接好手头工作，善待和你一样的打工人并告辞后赴任。

对于三高系统，Redis是必须/必需的，当并发高到一定的程度就可能会出现HotKey的问题，今天我们来看下Redis中的HotKey如何解决。

什么是HotKey

在较短的时间内，海量请求访问一个Key，这样的Key就被称为HotKey。

HotKey的危害

• 海量请求在较短的时间内，访问一个Key，势必会导致被访问的Redis服务器压力剧增，可能会将Redis服务器击垮，从而影响线上业务；


• HotKey过期的一瞬间，海量请求在较短的时间内，访问这个Key，因为Key过期了，这些请求会走到数据库，可能会将数据库击垮，从而影响线上业务。（这是缓存击穿问题）

HotKey如何解决

HotKey如何解决是一个比较宽泛的问题，涉及到多个方面，我们一个个来看。

Redis部署

通常来说，Redis有两种集群形式：数据分片集群、主从+哨兵集群，其实这两种集群形式或多或少的都一定程度上缓解了HotKey的问题。

主从+哨兵集群

如果我们采用单主：

• 所有的读请求都会打在仅有的一个Redis服务器，都不用管Key是什么，只要并发一高，就会导致Redis服务器压力剧增；


• 一旦仅有的一个Redis服务器挂了，就没有第二个Redis服务器顶上去了，无法继续提供服务。

如果我们采用主从+哨兵集群：

• 读请求会被分散到Master节点或者多台Slave节点，将请求进行了初步的分散；


• Master节点挂了，Slave节点会升级为新的Master节点，继续提供服务。

数据分片集群

Key被分散在了不同的Redis节点，将请求进行了进一步的分散。

如果采用数据分片集群，同时也会部署主从+哨兵，这样又有了主从+哨兵集群的特性：

• 读请求会被分散到Master节点或者多台Slave节点，将请求进行了初步的分散；


• Master节点挂了，Slave节点会升级为新的Master节点，继续提供服务。

画外音：我以前一直以为大部分公司都已经采用了数据分片集群，其实不然，某个我认为不差钱的公司，在2021年采用的还是主从+哨兵集群，出了问题，才转变成数据分片集群，我到我们公司一瞧，才发现我们公司也是主从+哨兵集群。

隔离

不同的业务分配不同的Redis集群，不要将所有的业务都“混杂”在一个Redis集群。

只要可以做到集群+隔离，在一定程度上就已经避免了HotKey，但是对于超高并发的系统来说，可能还有点不够，所以才会有下面的更进一步的措施。

如何应对HotKey

这个问题，可以拆分成三个子问题：如何发现HotKey、如何通知HotKey的产生、如何对HotKey进行处理。

如何发现HotKey

如何发现HotKey的前提是知道每个Key的使用情况，并进行统计，所以这又拆成了两个更小的子问题：如何知道每个Key的使用情况，如何进行统计。

如何知道每个Key的使用情况

谁最清楚知道每个Key的使用情况，当然是客户端、代理层，所以我们可以在客户端或者代理层进行埋点。

客户端埋点

在客户端请求Redis的代码中进行埋点。

优点：

• 实现较为简单


• 轻量级


• 几乎没有性能损耗

缺点：

• 进行统一管理较为麻烦：如果想开启或者关闭埋点、上报，会比较麻烦


• 升级、迭代较为麻烦：如果埋点、上报方式需要优化，就需要升级Jar包，再找一个黄道吉日进行发布


• 客户端会有一定的压力：不管是实时上报使用情况，还是准实时上报使用情况，都会对客户端造成一定的压力

代理层埋点

客户端不直接连接Redis集群，而是连接Redis代理，在代理层进行埋点。

优点：

• 客户端没有压力


• 对客户端完全透明


• 升级、迭代比较简单


• 进行统一管理比较简单

缺点：

• 实现复杂


• 会有一定的性能损耗：代理层需要转发请求到真正的Redis集群


• 单点故障问题：需要做到高可用，更复杂


• 单点热点问题：代理层本身就是一个热点，需要分散热点，更复杂

如何上报每个Key的使用情况

我们在客户端或者代理层进行了埋点，自然是由它们上报每个Key的使用情况，如何上报又是一个小话题。

实时/准实时

• 实时上报：每次请求，都进行上报


• 准实时上报：积累一定量或者一定时间的请求，再进行上报

是否预统计

如果采用准实时上报，在客户端或者代理层是否对使用情况进行预统计：

• 进行预统计：减少上报的数据量，减轻统计的压力，自身会有压力


• 不进行预统计：上报的数据量比较多，自身几乎没有压力

如何统计

不管如何进行上报，使用情况最终都会通过Kafka，发送到统计端，这个时候统计端就来活了。
一般来说，这个时候会借助于大数据，较为简单的方式：Flink开一个时间窗口，消费Kafka的数据，对时间窗口内的数据进行统计，如果在一个时间窗口内，某个Key的使用达了一定的阈值，就代表这是一个HotKey。

如何通知HotKey的产生

经过上面的步骤，我们已经知道了某个HotKey产生了，这个时候就需要通知到客户端或者代理层，那如何通知HotKey的产生呢？

• MQ：用MQ通知客户端或者代理层HotKey是什么


• RPC/Http：通过RPC/Http通知客户端或者代理层HotKey是什么


• 配置中心/注册中心指令：既然遇到了HotKey的问题，并且想解决，那基本上是技术实力非常强大的公司，应该有非常完善的服务治理体系，此时，可以通过配置中心/注册中心下发指令到客户端或者代理层，告知HotKey是什么

如何处理HotKey

客户端或者代理层已经知晓了HotKey产生了，就自动开启一定的策略，来避免HotKey带来的热点问题：

• 使用本地缓存，不至于让所有请求都打到Redis集群


• 将HotKey的数据复制多份，分散到不同的Redis节点上

在实际开发中，可能在很大程度上，都不会有埋点、上报、统计，通知、策略自动开启，这一套比较完善的Redis HotKey解决方案，我们能做到的就是预估某个Key可能会成为热点，就采用本地缓存+复制多份HotKey数据的方式来避免HotKey带来的热点问题。我们还经常会因为偷懒，所以设计了一个大而全的Key，所有的业务都从这个Key中读取数据，但是有些业务只需要其中的一小部分数据，有些业务只需要另外一小部分数据，如果不同的业务读取不同的Key，又可以将请求进行分散，这是非常简单，而且有效的方式。

End

LocationMarker是运动轨迹上Start、End, 以及整公里点上笔者自定义绘制的一个MarkerView, 当时之所以没有用设计给的icon是这个MarkerView里需要填充动态的数字，自定义的话自主性比较大些也方面做动画，之前的Android 传统自定义View的实现可以看这篇文章介绍 运动App自定义LocationMarker。

这里先看下gif动图：

LocationMarkerView图的绘制

绘制方面基本没有太多的逻辑，通过Compose的自定义绘制Canvas() 绘制 一个构建的Path，生成View的Path其实是主要的实现过程。

Canvas(modifier = Modifier.size(0.dp)){

  drawPath(AndroidPath(markerViewPath), color = color)

  drawPath(AndroidPath(bottomOval), color = colorOval)

}

这里Compose的path，还有好些接口对不上以及缺少API，所以通过AndroidPath(nativepath)接口进行转化进行绘制，bottomOval是 Start、End点底部阴影的Path。生成markerViewPath以及bottomOval的逻辑都在LocationMarker类中，LocationMarker主要包含了上下两套点 p1、p3(HPoint), 左右两套点p2、p4(VPoint), 以及绘制View的参数属性集合类MarkerParams.

获取markerViewPath, 首先给p1、p3(HPoint)，p2、p4(VPoint)中8个点设置Value值，circleModel(radius)，然后从底部p1底部点逆时针转圈依次调用三阶贝塞尔函数接口，最后close实现水滴倒置状态的Path，见实现：

fun getPath(radius: Float): Path{

  circleModel(radius)

  val path = Path()

  p1.setYValue(p1.y + radius * 0.2f * 1.05f) //设置 p1 底部左右两个点的y值

  p1.y += radius * 0.2f * 1.05f //设置 p1 自己的y值

  path.moveTo(p1.x, p1.y)

  path.cubicTo(p1.right.x, p1.right.y, p2.bottom.x, p2.bottom.y, p2.x, p2.y)

  path.cubicTo(p2.top.x, p2.top.y, p3.right.x, p3.right.y, p3.x, p3.y)

  path.cubicTo(p3.left.x, p3.left.y, p4.top.x, p4.top.y, p4.x, p4.y)

  path.cubicTo(p4.bottom.x, p4.bottom.y, p1.left.x, p1.left.y, p1.x, p1.y)

  path.close()

  val circle = Path()

  circle.addCircle(p3.x, p3.y + radius, markerParams.circleRadius.value, Path.Direction.CCW)

  path.op(circle, Path.Op.DIFFERENCE)

  return path

}

拿到相应的Path后，在Composeable函数里进行如上所述的绘制Path即可：

val locationMarker = LocationMarker(markerParams)

val markerViewPath = locationMarker.getPath(markerParams.radius.value)

val bottomOval = locationMarker.getBottomOval()

val color = colorResource(id = markerParams.wrapperColor)

val colorOval = colorResource(R.color.location_bottom_shader)



Canvas(modifier = Modifier.size(0.dp)){

  drawPath(AndroidPath(markerViewPath), color = color)

  drawPath(AndroidPath(bottomOval), color = colorOval)

}

绘制整公里的文字

Compose的Canvas 里目前的Version并不支持drawText的绘制，不过开放了一个调用原始drawText的转换API, 原始的drawText 是需要Paint参数的， 同时依赖Paint来计算Text 对应RectF的Height值，这里Paint()是Compose的一个Paint，需要调用asFrameworkPaint() 进行转化

val paint = Paint().asFrameworkPaint().apply {

  setColor(-0x1)

  style = android.graphics.Paint.Style.FILL

  strokeWidth = 1f

  isAntiAlias = true

  typeface = Typeface.DEFAULT_BOLD

  textSize = markerParams.txtSize.toFloat()

}

计算Text 绘制依赖的RectF，并将rectF.left作为drawText的X值，同时计算drawText的基线 baseLineY，最后传入nativeCanvas.drawText() 接口进行绘制。

val rectF = createTextRectF(locationMarker, paint, markerParams)

val baseLineY = getTextBaseY(rectF, paint)

Canvas(modifier = Modifier.size(0.dp)){

  drawIntoCanvas {

    it.nativeCanvas.drawText(markerParams.markerStr,  rectF.left, baseLineY, paint)

  }

}

drawText获取绘制基线 baseLineY的工具类方法：

fun getTextBaseY(rectF: RectF, paint: Paint): Float {

    val fontMetrics = paint.fontMetrics

    return rectF.centerY() - fontMetrics.top / 2 - fontMetrics.bottom / 2

}

添加动画

这里简单的用一个放大的动画实现，跟原始的高德地图、Mapbox地图的一个growth过程的一个动画有些差距的，暂且先这样实现吧。首先是定义两个radius相关的State对象，具体来说是Proxy, 以及一个动画生长的大小控制的Float的变量Fraction，再通过自定义animateDpAsState作为 animation值的对象，最终给到MarkParams作为参数，animation值的变化，会导致MarkParams的变化，最后导致Recompose，形成动画。

  val circleRadius by rememberSaveable{ mutableStateOf(25) }

  val radius by rememberSaveable{ mutableStateOf(60) }

  var animatedFloatFraction by remember { mutableStateOf(0f) }

  val radiusDp by animateDpAsState(

    targetValue = (radius * animatedFloatFraction).dp,

    animationSpec = tween(

      durationMillis = 1000,

      delayMillis = 500,

      easing = LinearOutSlowInEasing

    )

  )



  val circleRadiusDp by animateDpAsState(

    targetValue = (circleRadius * animatedFloatFraction).dp,

    animationSpec = tween(

      durationMillis = 1000,

      delayMillis = 500,

      easing = LinearOutSlowInEasing

    )

  )



  val markerParams by remember {

    derivedStateOf { MarkerParams(radiusDp, circleRadiusDp, wrapperColor = wrapperColor) }

  }

   

Compose 自定义View LocationMarkerView 主要通过drawPath,以及调用原生的drawText, 最后添加了一个scale类似的动画实现，最终实现运动轨迹里的一个小小的View的实现。

代码见：github.com/yinxiucheng… 下的CustomerComposeView

前言

本篇是通过图片的点击事件去切换图片，实现图片点击轮播，而新年兔了个兔专题，当然是使用了一系列兔子的图片作为轮播图展示的，下面我们来看看怎么实现点兔换图的。

正篇

实现方法

其实安卓中实现方法很简单，我们可以轻松办到,就是ImageView中增加点击事件

class RabbitFirst : AppCompatActivity() {



    private lateinit var binding: ActivityRabbitFirstBinding

    private var id by Delegates.notNull<Int>()



    override fun onCreate(savedInstanceState: Bundle?) {

        super.onCreate(savedInstanceState)



        binding = ActivityRabbitFirstBinding.inflate(layoutInflater)



        setContentView(binding.root)





        id = 0



        binding.img1.setOnClickListener {

            if (id == 0) {

                binding.img1.setImageBitmap(BitmapFactory.decodeResource(resources, R.drawable.rabit_c) )

                id++

                return@setOnClickListener

            }

            if (id == 1) {

                binding.img1.setImageResource(R.drawable.rabit_b)

                id++

                return@setOnClickListener

            }

            if (id == 2) {

                binding.img1.setImageResource(R.drawable.rabit_a)

                id++

                return@setOnClickListener

            }

            if (id == 3) {

                binding.img1.setImageResource(R.drawable.rabit_d)

                id = 0

                return@setOnClickListener

            }



            Log.i("id ===$id", "is id")

        }

    }

}

如果图片多了可以使用数组去存，然后单独写方法去处理，这里只有四张图，所以我这里使用if判断，主要还是没找到有关setImageResource的对应方法，网上似乎说没有对应的get方法，可以使用加setTag和getTag方法去实现，和我的判断方法也类似，我的判断方法就是如果有四张图，我们就给它显示顺序，从0-3，开始，id为0-2时点击图片切换下一张，到id=3时再清空id值，置为0，这样又能回到第一张兔子图。

展示效果

最终效果如下，我们点击图片就可以进行图片轮换：

ps:实现的时候出现了不能点击的问题，然后发现原来是在点击事件使用id全局变量增加时正好依次增加最后还是回到原图了，所以需要if里加上返回return，不经过下个if检查

总结

虽然形式很简单，但也是安卓的实现方法去做的，其实很多五花八门的效果都是从最简单的开始，然后添加各种新的技术最终才变得更加有趣好看。

前言

虽然缓存被认为是软件系统的性能助推器，但如果处理不当，它也容易出现错误。

在本文中，我将介绍 3 个有时可能会造成灾难性后果的常见缓存问题，希望大家在架构上引入缓存时，需要考虑到。

缓存击穿

缓存故障

当缓存键过期时会发生缓存故障，并且多个请求同时访问数据库以查找相同的键。

让我们来看看它是如何工作的:

• 热缓存键过期。


• 多个并发请求进来搜索同一个键。


• 服务器向数据库发起多个并发请求以查找相同的键。

缓存击穿会显著增加数据库的负载，尤其是当许多热键同时过期时。

下面是解决这个问题的2种解决方案：

• 获取搜索到的key的分布式锁，当一个线程试图更新缓存时，其他线程需要等待。


• 利用Refresh-ahead 策略异步刷新热数据，使热键永不过期。

缓存穿透

缓存穿透

当搜索到的key既不在缓存中, 也不在数据库中时，就会发生缓存穿透， 连数据库都穿透过去了。

让我们来看看它是如何工作的，当key既不在缓存中也不在数据库中时，就会发生这种情况。

• 当用户查询key时，应用程序由于缓存未命中而去查询数据库数据库。


• 由于数据库不包含该key并返回空结果，因此该key也不会被缓存。


• 因此，每个查询最终都会导致缓存未命中，而命中数据库，直接进行查库。

虽然乍一看这似乎微不足道，但攻击者可以通过使用此类密钥启动大量搜索来尝试破坏你的数据库。

为了解决这个问题，我们可以：

• 缓存过期时间较短的空结果。


• 使用布隆过滤器。在查询数据库之前，应用程序在布隆过滤器中查找key，如果key不存在则立即返回。

缓存雪崩

当对数据库的请求突然激增时，就会发生缓存雪崩。

这发生在：

• 许多缓存数据同时过期。


• 缓存服务宕机，所有请求都直接访问数据库。

数据库流量的突然激增可能会导致级联效应，并可能最终导致您的服务崩溃。

下面是一些常见的解决方案：

• 调整缓存键的过期时间，使它们不会同时过期。


• 使用Refresh-ahead 策略异步刷新热数据，使其永不过期。


• 使用缓存集群来避免单点故障。当主节点崩溃时，其中一个副本被提升为新的主节点。

总结

虽然这些缓存问题起初看起来微不足道，但有时可能会对我们的下游客户端和依赖项产生级联效应。事先了解它们可以让我们设计一个更强大的系统，也可以简化我们的故障排除过程。

1、目标

使用AccessibilityService的方式，实现微信自动抢红包（吐槽一下，网上找了许多文档，由于各种原因，无法实现对应效果，所以先给自己整理下），关于AccessibilityService的文章，网上有很多（没错，多的都懒得贴链接那种多），可自行查找。

2、实现流程

1、流程分析（这里只分析在桌面的情况）

我们把一个抢红包发的过程拆分来看，可以分为几个步骤：

收到通知 -> 点击通知栏 -> 点击红包 -> 点击开红包 -> 退出红包详情页

以上是一个抢红包的基本流程。

2、实现步骤

1、收到通知 以及 点击通知栏

接收通知栏的消息，介绍两种方式

Ⅰ、AccessibilityService

即通过AccessibilityService的AccessibilityEvent.TYPE_NOTIFICATION_STATE_CHANGED事件来获取到Notification

private fun handleNotification(event: AccessibilityEvent) {

    val texts = event.text

    if (!texts.isEmpty()) {

            for (text in texts) {

                val content = text.toString()

                //如果微信红包的提示信息,则模拟点击进入相应的聊天窗口

                if (content.contains("[微信红包]")) {

                    if (event.parcelableData != null && event.parcelableData is Notification) {

                        val notification: Notification? = event.parcelableData as Notification?

                        val pendingIntent: PendingIntent = notification!!.contentIntent

                        try {

                            pendingIntent.send()

                        } catch (e: CanceledException) {

                            e.printStackTrace()

                        }

                    }

                }

            }

        }



}

Ⅱ、NotificationListenerService

这是监听通知栏的另一种方式，记得要获取权限哦

class MyNotificationListenerService : NotificationListenerService() {



    override fun onNotificationPosted(sbn: StatusBarNotification?) {

        super.onNotificationPosted(sbn)



        val extras = sbn?.notification?.extras

        // 获取接收消息APP的包名

        val notificationPkg = sbn?.packageName

        // 获取接收消息的抬头

        val notificationTitle = extras?.getString(Notification.EXTRA_TITLE)

        // 获取接收消息的内容

        val notificationText = extras?.getString(Notification.EXTRA_TEXT)

        if (notificationPkg != null) {

            Log.d("收到的消息内容包名：", notificationPkg)

            if (notificationPkg == "com.tencent.mm"){

                if (notificationText?.contains("[微信红包]") == true){

                    //收到微信红包了

                    val intent = sbn.notification.contentIntent

                    intent.send()

                }

            }

        }

        Log.d("收到的消息内容", "Notification posted $notificationTitle & $notificationText")

    }



    override fun onNotificationRemoved(sbn: StatusBarNotification?) {

        super.onNotificationRemoved(sbn)

    }

}

2、点击红包

通过上述的跳转，可以进入聊天详情页面，到达详情页之后，接下来就是点击对应的红包卡片，那么问题来了，怎么点？肯定不是手动点。。。

我们来分析一下，一个聊天列表中，我们怎样才能识别到红包卡片，我看网上有通过findAccessibilityNodeInfosByViewId来获取对应的View，这个也可以，只是我们获取id的方式需要借助工具，可以用Android Device Monitor,但是这玩意早就废废弃了，虽然在sdk的目录下存在monitor，奈何本人太菜，点击就是打不开

我本地的jdk是11，我怀疑是不兼容，毕竟Android Device Monitor太老了。换新的layout Inspector，也就看看本地的debug应用，无法查看微信的呀。要么就反编译，这个就先不考虑了，换findAccessibilityNodeInfosByText这个方法试试。

这个方法从字面意思能看出来，是通过text来匹配的，我们可以知道红包卡片上面是有“微信红包”的固定字样的，是不是可以通股票这个来匹配呢，这还有个其他问题，并不是所有的红包都需要点，比如已过期，已领取的是不是要过滤下，咋一看挺好过滤的，一个循环就好，仔细想，这是棵树，不太好剔除，所以换了个思路。

最终方案就是递归一棵树，往一个列表里面塞值，“已过期”和“已领取”的塞一个字符串“#”，匹配到“微信红包”的塞一个AccessibilityNodeInfo，这样如果这个红包不能抢，那肯定一前一后分别是一个字符串和一个AccessibilityNodeInfo，因此，我们读到一个AccessibilityNodeInfo，并且前一个值不是字符串，就可以执行点击事件，代码如下

private fun getPacket() {

    val rootNode = rootInActiveWindow

    val caches:ArrayList<Any> = ArrayList()

    recycle(rootNode,caches)

    if(caches.isNotEmpty()){

        for(index in 0 until caches.size){

            if(caches[index] is AccessibilityNodeInfo && (index == 0 || caches[index-1] !is String )){

                val node = caches[index] as AccessibilityNodeInfo

                var parent = node.parent

                while (parent != null) {

                    if (parent.isClickable) {

                        parent.performAction(AccessibilityNodeInfo.ACTION_CLICK)

                        break

                    }

                    parent = parent.parent

                }

                break

            }

        }

    }



}



private fun recycle(node: AccessibilityNodeInfo,caches:ArrayList<Any>) {

        if (node.childCount == 0) {

            if (node.text != null) {

                if ("已过期" == node.text.toString() || "已被领完" == node.text.toString() || "已领取" == node.text.toString()) {

                    caches.add("#")

                }



                if ("微信红包" == node.text.toString()) {

                    caches.add(node)

                }

            }

        } else {

            for (i in 0 until node.childCount) {

                if (node.getChild(i) != null) {

                    recycle(node.getChild(i),caches)

                }

            }

        }

    }

以上只点击了第一个能点击的红包卡片，想点击所有的可另行处理。

3、点击开红包

这里思路跟上面类似，开红包页面比较简单，但是奈何开红包是个按钮，在不知道id的前提下，我们也不知道则呢么获取它，所以采用迂回套路，找固定的东西，我这里发现每个开红包的页面都有个“xxx的红包”文案，然后这个页面比较简单，只有个关闭，和开红包，我们通过获取“xxx的红包”对应的View来获取父View,然后递归子View，判断可点击的，执行点击事件不就可以了吗

private fun openPacket() {

    val nodeInfo = rootInActiveWindow

    if (nodeInfo != null) {

        val list = nodeInfo.findAccessibilityNodeInfosByText ("的红包")

        for ( i in 0 until list.size) {

            val parent = list[i].parent

            if (parent != null) {

                for ( j in 0 until  parent.childCount) {

                    val child = parent.getChild (j)

                    if (child != null && child.isClickable) {

                        child.performAction(AccessibilityNodeInfo.ACTION_CLICK)

                    }

                }



            }



        }

    }



}

4、退出红包详情页

这里回退也是个按钮，我们也不知道id，所以可以跟点开红包一样，迂回套路，获取其他的View，来获取父布局，然后递归子布局，依次执行点击事件，当然关闭事件是在前面的，也就是说关闭会优先执行到

private fun close() {

    val nodeInfo = rootInActiveWindow

    if (nodeInfo != null) {

        val list = nodeInfo.findAccessibilityNodeInfosByText ("的红包")

        if (list.isNotEmpty()) {

            val parent = list[0].parent.parent.parent

            if (parent != null) {

                for ( j in 0 until  parent.childCount) {

                    val child = parent.getChild (j)

                    if (child != null && child.isClickable) {

                        child.performAction(AccessibilityNodeInfo.ACTION_CLICK)

                    }

                }



            }



        }

    }

}

3、遇到问题

1、AccessibilityService收不到AccessibilityEvent.TYPE_NOTIFICATION_STATE_CHANGED事件

android碎片问题很正常，我这边是使用NotificationListenerService来替代的。

2、需要点击View的定位

简单是就是到页面应该点哪个View，找到相应的规则，来过滤出对应的View，这个规则是随着微信的改变而变化的，findAccessibilityNodeInfosByViewId最直接，但是奈何工具问题，有点麻烦，于是采用取巧的办法，通过找到其他View来定位自身

4、完整代码

MyNotificationListenerService

class MyNotificationListenerService : NotificationListenerService() {



    override fun onNotificationPosted(sbn: StatusBarNotification?) {

        super.onNotificationPosted(sbn)



        val extras = sbn?.notification?.extras

        // 获取接收消息APP的包名

        val notificationPkg = sbn?.packageName

        // 获取接收消息的抬头

        val notificationTitle = extras?.getString(Notification.EXTRA_TITLE)

        // 获取接收消息的内容

        val notificationText = extras?.getString(Notification.EXTRA_TEXT)

        if (notificationPkg != null) {

            Log.d("收到的消息内容包名：", notificationPkg)

            if (notificationPkg == "com.tencent.mm"){

                if (notificationText?.contains("[微信红包]") == true){

                    //收到微信红包了

                    val intent = sbn.notification.contentIntent

                    intent.send()

                }

            }

        } Log.d("收到的消息内容", "Notification posted $notificationTitle & $notificationText")

    }



    override fun onNotificationRemoved(sbn: StatusBarNotification?) {

        super.onNotificationRemoved(sbn)

    }

}

MyAccessibilityService

class RobService : AccessibilityService() {



    override fun onAccessibilityEvent(event: AccessibilityEvent) {

        val eventType = event.eventType

        when (eventType) {

            AccessibilityEvent.TYPE_NOTIFICATION_STATE_CHANGED -> handleNotification(event)

            AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED, AccessibilityEvent.TYPE_WINDOW_CONTENT_CHANGED -> {

                val className = event.className.toString()

                Log.e("测试无障碍",className)

                if (className == "com.tencent.mm.ui.LauncherUI") {

                    getPacket()

                } else if (className == "com.tencent.mm.plugin.luckymoney.ui.LuckyMoneyReceiveUI") {

                    openPacket()

                } else if (className == "com.tencent.mm.plugin.luckymoney.ui.LuckyMoneyNotHookReceiveUI") {

                    openPacket()

                }  else if (className == "com.tencent.mm.plugin.luckymoney.ui.LuckyMoneyDetailUI") {

                    close()

                }



            }

        }

    }



    /**

     * 处理通知栏信息

     *

     * 如果是微信红包的提示信息,则模拟点击

     *

     * @param event

     */

    private fun handleNotification(event: AccessibilityEvent) {

        val texts = event.text

        if (!texts.isEmpty()) {

            for (text in texts) {

                val content = text.toString()

                //如果微信红包的提示信息,则模拟点击进入相应的聊天窗口

                if (content.contains("[微信红包]")) {

                    if (event.parcelableData != null && event.parcelableData is Notification) {

                        val notification: Notification? = event.parcelableData as Notification?

                        val pendingIntent: PendingIntent = notification!!.contentIntent

                        try {

                            pendingIntent.send()

                        } catch (e: CanceledException) {

                            e.printStackTrace()

                        }

                    }

                }

            }

        }



    }



    /**

     * 关闭红包详情界面,实现自动返回聊天窗口

     */

    @TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR2)

    private fun close() {

        val nodeInfo = rootInActiveWindow

        if (nodeInfo != null) {

            val list = nodeInfo.findAccessibilityNodeInfosByText ("的红包")

            if (list.isNotEmpty()) {

                val parent = list[0].parent.parent.parent

                if (parent != null) {

                    for ( j in 0 until  parent.childCount) {

                        val child = parent.getChild (j)

                        if (child != null && child.isClickable) {

                            child.performAction(AccessibilityNodeInfo.ACTION_CLICK)

                        }

                    }



                }



            }

        }

    }



    /**

     * 模拟点击,拆开红包

     */

    @TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR2)

    private fun openPacket() {

        Log.e("测试无障碍","点击红包")

        Thread.sleep(100)

        val nodeInfo = rootInActiveWindow

        if (nodeInfo != null) {

            val list = nodeInfo.findAccessibilityNodeInfosByText ("的红包")

            for ( i in 0 until list.size) {

                val parent = list[i].parent

                if (parent != null) {

                    for ( j in 0 until  parent.childCount) {

                        val child = parent.getChild (j)

                        if (child != null && child.isClickable) {

                            Log.e("测试无障碍","点击红包成功")

                            child.performAction(AccessibilityNodeInfo.ACTION_CLICK)

                        }

                }



            }



            }

        }



    }



    /**

     * 模拟点击,打开抢红包界面

     */

    @TargetApi(Build.VERSION_CODES.JELLY_BEAN)

    private fun getPacket() {

        Log.e("测试无障碍","获取红包")

        val rootNode = rootInActiveWindow

        val caches:ArrayList<Any> = ArrayList()

        recycle(rootNode,caches)

        if(caches.isNotEmpty()){

            for(index in 0 until caches.size){

                if(caches[index] is AccessibilityNodeInfo && (index == 0 || caches[index-1] !is String )){

                    val node = caches[index] as AccessibilityNodeInfo

//                    node.performAction(AccessibilityNodeInfo.ACTION_CLICK)

                    var parent = node.parent

                    while (parent != null) {

                        if (parent.isClickable) {

                            parent.performAction(AccessibilityNodeInfo.ACTION_CLICK)

                            Log.e("测试无障碍","获取红包成功")

                            break

                        }

                        parent = parent.parent

                    }

                    break

                }

            }

        }



    }



    /**

     * 递归查找当前聊天窗口中的红包信息

     *

     * 聊天窗口中的红包都存在"微信红包"一词,因此可根据该词查找红包

     *

     * @param node

     */

    private fun recycle(node: AccessibilityNodeInfo,caches:ArrayList<Any>) {

        if (node.childCount == 0) {

            if (node.text != null) {

                if ("已过期" == node.text.toString() || "已被领完" == node.text.toString() || "已领取" == node.text.toString()) {

                    caches.add("#")

                }



                if ("微信红包" == node.text.toString()) {

                    caches.add(node)

                }

            }

        } else {

            for (i in 0 until node.childCount) {

                if (node.getChild(i) != null) {

                    recycle(node.getChild(i),caches)

                }

            }

        }

    }



    override fun onInterrupt() {}

    override fun onServiceConnected() {

        super.onServiceConnected()

        Log.e("测试无障碍id","启动")

        val info: AccessibilityServiceInfo = serviceInfo

        info.packageNames = arrayOf("com.tencent.mm")

        serviceInfo = info

    }

}

5、总结

此文是对AccessibilityService的使用的一个梳理，这个功能其实不麻烦，主要是一些细节问题，像自动领取支付宝红包，自动领取QQ红包或者其他功能等也都可以用类似方法实现。

前言

在各类软件应用中，会经常遇到空页面的情况，比如列表无数据、搜不到相应结果、用户数据没有添加等等。这种空页面看似很少出现，但是如果不注意体验的话，会让用户不快甚至是困惑。今天我们就来讲讲针对各类空页面，如何改善用户体验。

列表无数据

页面无数据通常会在列表类页面中出现，最为简单的方式就是用一个空图标+文字说明的方式告诉用户查询的结果为空，比如下面这样。

这是中规中矩的无数据空页面，遇到过奇葩的情况是直接给一个白屏 —— 你这是告诉用户是数据加载不出来呢还是没数据呢？
相比这种静态的空页面，我们可以使用 Lottie 加载一些带动效的无数据指示，会让用户体验好很多。而需要写的代码其实并没有几行。

Widget build(BuildContext context) {

  return Scaffold(

    backgroundColor: Colors.white,

    appBar: AppBar(

      title: const Text('抱歉'),

    ),

    body: Center(

      child: Column(

        mainAxisAlignment: MainAxisAlignment.center,

        children: [

          Lottie.asset(

            'assets/empty.json',

            repeat: true,

            width: 200.0,

          ),

          Text(

            '暂无数据',

            style: TextStyle(

              color: Colors.grey[400],

              fontSize: 14.0,

            ),

          ),

        ],

      ),

    ),

  );

}

找不到搜索结果

对于搜索，在没有搜到对应的数内容时，相比给一个空页面，给一些用户感兴趣的相似内容可能会更好，一方面可以让用户浏览替代的内容，另一方面可以在一定程度上提高转化率。典型的例子就是在商品搜索的时候，如果没有找到对应的商品，会推荐系统里相关的商品，比如下面是京东的例子。

用户数据没有添加

这是需要用户主动提交才会有数据的情况。糟糕的体验是只告诉用户没有数据，而没有引导用户去添加数据。比如我们的地址管理，我们来看到下面两种体验，一对比高下立现。

第一种一个是添加地址的按钮不够显眼，另外就是在需要用户操作的时候，缺乏引导。这会导致首次使用该功能的用户很迷茫，一时不知道从哪里添加收货地址。相比之下，下面的实现方式按钮位置更明显，而且通过动画能够让用户清楚地知道可以通过点击下面的按钮添加收货地址。

第二种方式实现的代码如下所示，这里的引导动画效果使用了 AnimatedPositioned 组件实现（相关文章可以参考：🚀🚀🚀庆祝神舟十三号发射成功，来一个火箭发射动画）。

Widget build(BuildContext context) {

  return Scaffold(

    appBar: AppBar(

      title: const Text('收货地址'),

    ),

    body: Stack(

      children: [

        Center(

          child: Column(

            mainAxisAlignment: MainAxisAlignment.center,

            children: [

              Image.asset('assets/common-empty.png', width: 100.0),

              Text(

                '暂无收货地址',

                style: TextStyle(

                  color: Colors.grey[400],

                  fontSize: 16.0,

                  height: 2,

                ),

              ),

            ],

          ),

        ),

        AnimatedPositioned(

          duration: const Duration(milliseconds: 500),

          bottom: _bottom,

          height: guideIconSize,

          left: MediaQuery.of(context).size.width / 2 - guideIconSize / 2,

          onEnd: () {

            setState(() {

              if (_bottom == minBottom) {

                _bottom = maxBottom;

              } else {

                _bottom = minBottom;

              }

            });

          },

          child: Icon(Icons.arrow_downward,

              color: Theme.of(context).primaryColor, size: guideIconSize),

        )

      ],

    ),

    bottomSheet: Container(

      height: 50.0,

      width: MediaQuery.of(context).size.width,

      color: Theme.of(context).primaryColor,

      margin: const EdgeInsets.all(0.0),

      child: TextButton(

        onPressed: () {

          if (kDebugMode) {

            print('跳到添加地址！');

          }

        },

        child: const Text('添加收货地址', style: TextStyle(color: Colors.white)),

      ),

    ),

  );

}

网络连接问题

网络连接偶尔会出现短时间连接断开导致无法加载后端数据的问题，这个时候可不能直接放个网络错误的指示页面就完了，比如下面这样。

动画确实改善了用户体验，但没有解决根本问题。我们来看一下我们自己网络连接有问题的时候的处理步骤：

1. 如果手机的网络连接没问题，我们会希望当前页面能够重新加载；


2. 如果手机网络有问题，我们可能会切换网络（比如切换到4G 网络），然后还是希望能够重新加载。

这个空页面没有提供重新加载的功能，这意味着用户需要返回到上一个页面，找到之前点击的内容，然后再进入这个页面来达到再次刷新的目的。这额外多了两个步骤，而且还需要用户记住之前点击的内容，体验就不怎么好了。这种情况只需要提供一个重新加载的按钮，体验就会好很多了。

总结

总结一下，如何提高空页面的用户体验，针对我们提到的4种情况有对应的4个原则：

1. 对于确实无数据的情况，给出有好的提示，比如实用动画+文字的形式。千万不要认为反正后台有数据，不会出现空页面而什么都不做——结果就是让用户看着白屏一脸懵逼！


2. 用户输入的搜索词可能会非常长（比如复制京东的商品名称去淘宝搜），很可能搜不到结果。如果可能，建议对于搜索词长的情况能够匹配一些标签，通过标签搜相关的内容推荐给用户，这比搜不到给一个空白页面的体验会好很多，而且海还会促进应用的内容或商品消费。


3. 对于需要用户执行添加动作才会有的数据（比如收货地址、收藏夹、好友等），要给出合理的引导，让用户能够顺利地完成相应的动作，而不是让用户自己摸索。


4. 对于因为网络、本机授权等导致出现错误无法加载数据的情况，除了给出友好的提示之外，要同时能够提供类似重新加载的功能，便于用户解决本机问题后，能够回来直接重新加载页面内容。

从心理上来说，人对于空白状态都是有点畏惧的。因此，开发出好的体验的空页面就是需要给用户合理的解释和必要的引导，让空页面不那么空！

在之前的文章Android 一种点赞动画的实现中，通过Animation和Animator实现了一种点赞动画效果，有知友评论用MotionLayout是否会比较简单。我之前还没有使用过MotionLayout，刚好通过实现这个点赞动画来学习一下MotionLayout的使用。

MotionLayout

MotionLayout是ConstraintLayout的子类，包含在ConstraintLayout库中，在ConstraintLayout的基础上，增加了管理控件动画的功能。

官方文档

添加库

如果之前没有使用ConstraintLayout，那么需要在app module下的build.gradle中添加代码，如下:

dependencies {

    // 项目中使用AndroidX

    implementation 'androidx.constraintlayout:constraintlayout:2.0.0-beta1'

    

    // 项目中未使用AndroidX

    implementation 'com.android.support.constraint:constraint-layout:2.0.0-beta1'

}

点赞效果的实现

尝试使用MotionLayout来实现之前的点赞动画，最终实现了缩放以及发散效果。

布局中添加MotionLayout

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

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

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

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



    <!--根节点改为使用MotionLayout-->

    <!--layoutDescription 配置MotionScene配置文件-->

    <!--showPaths设置是否显示动画的轨迹-->

    <androidx.constraintlayout.motion.widget.MotionLayout

        android:id="@+id/motion_layout"

        android:layout_width="match_parent"

        android:layout_height="match_parent"

        motion:layoutDescription="@xml/example_motion_scene"

        tools:showPaths="true">



        <include

            android:id="@+id/include_title"

            layout="@layout/layout_title" />



        <androidx.appcompat.widget.AppCompatImageView

            android:id="@+id/iv_thumb_up"

            android:layout_width="25dp"

            android:layout_height="25dp"

            android:layout_marginTop="2dp"

            android:src="@drawable/icon_thumb_up"

            motion:layout_constraintBottom_toBottomOf="parent"

            motion:layout_constraintEnd_toEndOf="parent"

            motion:layout_constraintStart_toStartOf="parent"

            motion:layout_constraintTop_toTopOf="parent" />



        <androidx.appcompat.widget.AppCompatImageView

            android:id="@+id/iv_thumb_up1"

            android:layout_width="25dp"

            android:layout_height="25dp"

            android:layout_marginTop="2dp"

            android:src="@drawable/icon_thumb_up"

            android:visibility="gone"

            motion:layout_constraintBottom_toBottomOf="parent"

            motion:layout_constraintEnd_toEndOf="parent"

            motion:layout_constraintStart_toStartOf="parent"

            motion:layout_constraintTop_toTopOf="parent" />



        <androidx.appcompat.widget.AppCompatImageView

            android:id="@+id/iv_thumb_up2"

            android:layout_width="25dp"

            android:layout_height="25dp"

            android:layout_marginTop="2dp"

            android:src="@drawable/icon_thumb_up"

            android:visibility="gone"

            motion:layout_constraintBottom_toBottomOf="parent"

            motion:layout_constraintEnd_toEndOf="parent"

            motion:layout_constraintStart_toStartOf="parent"

            motion:layout_constraintTop_toTopOf="parent" />



        <androidx.appcompat.widget.AppCompatImageView

            android:id="@+id/iv_thumb_up3"

            android:layout_width="25dp"

            android:layout_height="25dp"

            android:layout_marginTop="2dp"

            android:src="@drawable/icon_thumb_up"

            android:visibility="gone"

            motion:layout_constraintBottom_toBottomOf="parent"

            motion:layout_constraintEnd_toEndOf="parent"

            motion:layout_constraintStart_toStartOf="parent"

            motion:layout_constraintTop_toTopOf="parent" />



        <androidx.appcompat.widget.AppCompatImageView

            android:id="@+id/iv_thumb_up4"

            android:layout_width="25dp"

            android:layout_height="25dp"

            android:layout_marginTop="2dp"

            android:src="@drawable/icon_thumb_up"

            android:visibility="gone"

            motion:layout_constraintBottom_toBottomOf="parent"

            motion:layout_constraintEnd_toEndOf="parent"

            motion:layout_constraintStart_toStartOf="parent"

            motion:layout_constraintTop_toTopOf="parent" />



        <androidx.appcompat.widget.AppCompatImageView

            android:id="@+id/iv_thumb_up5"

            android:layout_width="25dp"

            android:layout_height="25dp"

            android:layout_marginTop="2dp"

            android:src="@drawable/icon_thumb_up"

            android:visibility="gone"

            motion:layout_constraintBottom_toBottomOf="parent"

            motion:layout_constraintEnd_toEndOf="parent"

            motion:layout_constraintStart_toStartOf="parent"

            motion:layout_constraintTop_toTopOf="parent" />

    </androidx.constraintlayout.motion.widget.MotionLayout>

</layout>

创建MotionScene配置文件

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

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

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



    <!--配置动画的属性-->

    <!--duration 配置动画的持续时间-->

    <!--constraintSetStart 配置动画开始时，控件集的状态-->

    <!--constraintSetEnd 配置动画结束时，控件集的状态-->

    <!--motionInterpolator 配置动画的插值器，-->

    <Transition

        android:id="@+id/transition_thumb"

        android:duration="1500"

        motion:constraintSetEnd="@id/thumb_end"

        motion:constraintSetStart="@id/thumb_start"

        motion:motionInterpolator="linear">



        <!--点击时触发动画-->

        <!--targetId 配置触发事件的控件id-->

        <!--clickAction 配置点击触发的效果-->

        <!--clickAction toggle 当前控件集为开始状态，则播放动画切换至结束状态，反之亦然-->

        <!--clickAction transitionToEnd 播放控件集开始到结束的动画-->

        <!--clickAction transitionToStart 播放控件集结束到开始的动画-->

        <!--clickAction jumpToEnd 不播放动画，控件集直接切换至结束状态-->

        <!--clickAction jumpToStart 不播放动画，控件集直接切换至开始状态-->

        <OnClick

            motion:clickAction="transitionToEnd"

            motion:targetId="@id/iv_thumb_up" />



        <!--关键帧集合，用于实现缩放效果-->

        <KeyFrameSet>



            <!--修改属性-->

            <!--framePosition 取值范围为0-100-->

            <!--motionTarget 设置修改的对象-->

            <!--scaleX 设置x轴缩放大小-->

            <!--scaleY 设置y轴缩放大小-->

            <KeyAttribute

                android:scaleX="1.6"

                android:scaleY="1.6"

                motion:framePosition="25"

                motion:motionTarget="@id/iv_thumb_up" />



            <KeyAttribute

                android:scaleX="1"

                android:scaleY="1"

                motion:framePosition="50"

                motion:motionTarget="@id/iv_thumb_up" />

        </KeyFrameSet>

    </Transition>



    <!--控件集 动画开始时的状态-->

    <ConstraintSet android:id="@+id/thumb_start">



        <!--与layout文件中的控件对应-->

        <!--visibilityMode 如果需要改变控件的可见性，需要将此字段配置为ignore-->

        <Constraint

            android:id="@+id/iv_thumb_up"

            android:layout_width="25dp"

            android:layout_height="25dp"

            android:layout_marginTop="2dp"

            motion:layout_constraintBottom_toBottomOf="parent"

            motion:layout_constraintEnd_toEndOf="parent"

            motion:layout_constraintStart_toStartOf="parent"

            motion:layout_constraintTop_toTopOf="parent"

            motion:visibilityMode="ignore" />



        <Constraint

            android:id="@+id/iv_thumb_up1"

            android:layout_width="25dp"

            android:layout_height="25dp"

            android:layout_marginTop="2dp"

            motion:layout_constraintBottom_toBottomOf="parent"

            motion:layout_constraintEnd_toEndOf="parent"

            motion:layout_constraintStart_toStartOf="parent"

            motion:layout_constraintTop_toTopOf="parent"

            motion:visibilityMode="ignore">



            <!--改变控件的属性-->

            <!--attributeName 属性名-->

            <!--customFloatValue Float类型属性值-->

            <CustomAttribute

                motion:attributeName="alpha"

                motion:customFloatValue="1" />

        </Constraint>



        <Constraint

            android:id="@+id/iv_thumb_up2"

            android:layout_width="25dp"

            android:layout_height="25dp"

            android:layout_marginTop="2dp"

            motion:layout_constraintBottom_toBottomOf="parent"

            motion:layout_constraintEnd_toEndOf="parent"

            motion:layout_constraintStart_toStartOf="parent"

            motion:layout_constraintTop_toTopOf="parent"

            motion:visibilityMode="ignore">



            <CustomAttribute

                motion:attributeName="alpha"

                motion:customFloatValue="1" />

        </Constraint>



        <Constraint

            android:id="@+id/iv_thumb_up3"

            android:layout_width="25dp"

            android:layout_height="25dp"

            android:layout_marginTop="2dp"

            motion:layout_constraintBottom_toBottomOf="parent"

            motion:layout_constraintEnd_toEndOf="parent"

            motion:layout_constraintStart_toStartOf="parent"

            motion:layout_constraintTop_toTopOf="parent"

            motion:visibilityMode="ignore">



            <CustomAttribute

                motion:attributeName="alpha"

                motion:customFloatValue="1" />

        </Constraint>



        <Constraint

            android:id="@+id/iv_thumb_up4"

            android:layout_width="25dp"

            android:layout_height="25dp"

            android:layout_marginTop="2dp"

            motion:layout_constraintBottom_toBottomOf="parent"

            motion:layout_constraintEnd_toEndOf="parent"

            motion:layout_constraintStart_toStartOf="parent"

            motion:layout_constraintTop_toTopOf="parent"

            motion:visibilityMode="ignore">



            <CustomAttribute

                motion:attributeName="alpha"

                motion:customFloatValue="1" />

        </Constraint>



        <Constraint

            android:id="@+id/iv_thumb_up5"

            android:layout_width="25dp"

            android:layout_height="25dp"

            android:layout_marginTop="2dp"

            motion:layout_constraintBottom_toBottomOf="parent"

            motion:layout_constraintEnd_toEndOf="parent"

            motion:layout_constraintStart_toStartOf="parent"

            motion:layout_constraintTop_toTopOf="parent"

            motion:visibilityMode="ignore">



            <CustomAttribute

                motion:attributeName="alpha"

                motion:customFloatValue="1" />

        </Constraint>

    </ConstraintSet>



    <!--控件集 动画结束时的状态-->

    <ConstraintSet android:id="@+id/thumb_end">



        <Constraint

            android:id="@+id/iv_thumb_up"

            android:layout_width="25dp"

            android:layout_height="25dp"

            android:layout_marginTop="2dp"

            motion:layout_constraintBottom_toBottomOf="parent"

            motion:layout_constraintEnd_toEndOf="parent"

            motion:layout_constraintStart_toStartOf="parent"

            motion:layout_constraintTop_toTopOf="parent"

            motion:visibilityMode="ignore" />



        <Constraint

            android:id="@+id/iv_thumb_up1"

            android:layout_width="25dp"

            android:layout_height="25dp"

            android:layout_marginTop="110dp"

            android:layout_marginEnd="90dp"

            motion:layout_constraintBottom_toBottomOf="parent"

            motion:layout_constraintEnd_toEndOf="parent"

            motion:layout_constraintStart_toStartOf="parent"

            motion:layout_constraintTop_toTopOf="parent"

            motion:visibilityMode="ignore">



            <CustomAttribute

                motion:attributeName="alpha"

                motion:customFloatValue="0.5" />

        </Constraint>



        <Constraint

            android:id="@+id/iv_thumb_up2"

            android:layout_width="25dp"

            android:layout_height="25dp"

            android:layout_marginStart="70dp"

            android:layout_marginTop="95dp"

            motion:layout_constraintBottom_toBottomOf="parent"

            motion:layout_constraintEnd_toEndOf="parent"

            motion:layout_constraintStart_toStartOf="parent"

            motion:layout_constraintTop_toTopOf="parent"

            motion:visibilityMode="ignore">



            <CustomAttribute

                motion:attributeName="alpha"

                motion:customFloatValue="0.4" />

        </Constraint>



        <Constraint

            android:id="@+id/iv_thumb_up3"

            android:layout_width="25dp"

            android:layout_height="25dp"

            android:layout_marginEnd="85dp"

            android:layout_marginBottom="140dp"

            motion:layout_constraintBottom_toBottomOf="parent"

            motion:layout_constraintEnd_toEndOf="parent"

            motion:layout_constraintStart_toStartOf="parent"

            motion:layout_constraintTop_toTopOf="parent"

            motion:visibilityMode="ignore">



            <CustomAttribute

                motion:attributeName="alpha"

                motion:customFloatValue="0.6" />

        </Constraint>



        <Constraint

            android:id="@+id/iv_thumb_up4"

            android:layout_width="25dp"

            android:layout_height="25dp"

            android:layout_marginStart="60dp"

            android:layout_marginBottom="120dp"

            motion:layout_constraintBottom_toBottomOf="parent"

            motion:layout_constraintEnd_toEndOf="parent"

            motion:layout_constraintStart_toStartOf="parent"

            motion:layout_constraintTop_toTopOf="parent"

            motion:visibilityMode="ignore">



            <CustomAttribute

                motion:attributeName="alpha"

                motion:customFloatValue="0.2" />

        </Constraint>



        <Constraint

            android:id="@+id/iv_thumb_up5"

            android:layout_width="25dp"

            android:layout_height="25dp"

            android:layout_marginEnd="20dp"

            android:layout_marginBottom="60dp"

            motion:layout_constraintBottom_toBottomOf="parent"

            motion:layout_constraintEnd_toEndOf="parent"

            motion:layout_constraintStart_toStartOf="parent"

            motion:layout_constraintTop_toTopOf="parent"

            motion:visibilityMode="ignore">



            <CustomAttribute

                motion:attributeName="alpha"

                motion:customFloatValue="0" />

        </Constraint>

    </ConstraintSet>

</MotionScene>

监听动画状态

class MotionLayoutExampleActivity : AppCompatActivity() {



    override fun onCreate(savedInstanceState: Bundle?) {

        super.onCreate(savedInstanceState)

        val binding: LayoutMotionLayoutExampleActivityBinding = DataBindingUtil.setContentView(this, R.layout.layout_motion_layout_example_activity)

        binding.motionLayout.setTransitionListener(object : MotionLayout.TransitionListener {

            override fun onTransitionStarted(motionLayout: MotionLayout?, startId: Int, endId: Int) {

                // 动画开始

                // 把发散的按钮显示出来

                binding.ivThumbUp1.visibility = View.VISIBLE

                binding.ivThumbUp2.visibility = View.VISIBLE

                binding.ivThumbUp3.visibility = View.VISIBLE

                binding.ivThumbUp4.visibility = View.VISIBLE

                binding.ivThumbUp5.visibility = View.VISIBLE

            }



            override fun onTransitionChange(motionLayout: MotionLayout?, startId: Int, endId: Int, progress: Float) {

                // 动画进行中

            }



            override fun onTransitionCompleted(motionLayout: MotionLayout?, currentId: Int) {

                // 动画完成

                // 隐藏发散的按钮，将状态还原

                binding.root.postDelayed({

                    binding.ivThumbUp1.visibility = View.GONE

                    binding.ivThumbUp2.visibility = View.GONE

                    binding.ivThumbUp3.visibility = View.GONE

                    binding.ivThumbUp4.visibility = View.GONE

                    binding.ivThumbUp5.visibility = View.GONE

                    binding.motionLayout.progress = 0f

                }, 200)

            }



            override fun onTransitionTrigger(motionLayout: MotionLayout?, triggerId: Int, positive: Boolean, progress: Float) {

                

            }

        })

    }

}