隐式一致性消除了很多我们需要自己为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);

  }

}

2021年马斯克让Clubhouse火爆出圈，2022年Discord以1.5亿月活150亿美元估值的数据让全球的开发者们看到了泛娱乐领域新的机会，环信作为泛娱乐行业的基础设施服务商，一直致力于给开发者提供更稳定的SDK，更丰富更易用的API，更垂直的场景解决方案。近日环信重磅推出了“环信超级社区DEMO”，这是一款类Discord产品的开源项目，在此基础上二开，可以快速搭建国内版Discord产品,帮您节省60%的开发难度！

项目介绍

环信超级社区是一款基于环信IM+声网RTC打造的类Discord实时社区应用，用户可创建/管理自己的兴趣社区，设置/管理频道（群组），支持陌生人/好友单聊、社区成员无上限，可创建的频道数无上限，用户加入的频道数无上限，真正实现万人实时群聊，语音聊天等。

功能架构

核心优势

1、IM提供高并发的通讯管道，支持亿级用户并发

▲万人群组互动

▲群组数量无上限

▲自定义加群权限设置

▲支持群资料和属性

▲提供群组/聊天室完善的群聊管理功能

▲提供管理员列表、成员列表、禁言列表、黑名单等服务

▲聊天室功能与直播功能进行对接实现直播聊天室

▲可以根据客户需要进行灵活配置，包括关系、数量、能力

2、百万人大群组承载

环信群组分片技术：将1个群中百万成员分片在100个万人群里

3、消息爆炸问题

解决方案：通过notice减少消息的Qps，进群后再拉取下发消息

4、环信SD-GMN，构建低延迟网络，实现全球加速

▲五大数据中心覆盖全球200+个国家和地区；

▲集团自建上万台服务器，部署全球300多个补充加速节点，实现低延迟；

▲FPA加速与AWS加速智能切换，确保通信质量和高可用能力；

▲典型时延：北美，30-40毫秒；欧洲20-30毫秒；东南亚，日韩30-40毫秒；中东70毫秒；北非45毫秒；澳洲50毫秒；最远的南美和南非，90毫秒；

▲持续改进，不断优化…

5、内容过滤能力

环信内容审核系统，低成本，高效率，个性化，高准确

适合场景

兴趣社交、游戏社交、区块链、媒体、粉丝社区、品牌社区等等。

项目源码

https://github.com/easemob/easemob_supercommunity

APK下载

链接: https://pan.baidu.com/s/1HUL_CUYTvUr3mT29WRcoaQ 提取码: zq1x 

超级社区2.0

继超级社区1.0以后，环信推出了超级社区2.0（Circle），这是一款基于环信 IM 打造的类 Discord 实时社区应用场景方案，支持社区（Server）、频道（Channel） 和子区（Thread） 三层结构。一个 App 下可以有多个社区，同时支持陌生人/好友单聊。用户可创建和管理自己的社区，在社区中设置和管理频道将一个话题下的子话题进行分区，在频道中根据感兴趣的某条消息发起子区讨论，实现万人实时群聊，满足超大规模用户的顺畅沟通需求。旨在一站式帮助客户快速开发和构建稳定超大规模用户即时通讯的"类Discord超级社区"，作为构建实时交互社区的第一选择，环信超级社区自发布以来很好地满足了类 Discord 实时社区业务场景的客户需求，并支持开发者结合业务需要灵活自定义产品形态，目前已经广泛服务于国内头部出海企业以及海外东南亚和印度企业。

环信超级社区2.0介绍：https://www.easemob.com/product/im/circle

环信超级社区2.0体验：https://www.easemob.com/download/demo#discord

场景

有这么一个场景，一个菜谱订制的app里，用户是根据每周作为一个周期制定自己的菜谱计划，每天从已知菜谱库存中选一两道菜，规划自己下周做什么吃，下下周做什么吃。

viewpager（或viewpager2）中加载若干个fragment，fragment里被传入一个时间戳的参数，用这个时间戳当做初始时间，计算出本周的起止时间（周日~周六），然后获取这一周的菜谱计划。类似于这样（demo式UI）

上图中标注a点击后切到上一周（viewpager2中前一个fragment），b点击切到下一周，下方列表为viewpager2（若干fragments）当然列表显示什么不重要

viewpagerAdapter 类似这样，用list维护一个Fragment

class MealPagerAdapter(fm: FragmentManager?, life : Lifecycle) : FragmentStateAdapter(fm!! , life) {



    val fragmentList = mutableListOf<MealFragment>()



    val startDateTimeList = mutableListOf<Long>()



    fun addItem(startDate : Long) {

        startDateTimeList.add(startDate)

        fragmentList.add(MealFragment.newInstance(startDate))

        notifyItemInserted(fragmentList.size - 1)

    }



    override fun getItemCount(): Int = fragmentList.size



    override fun createFragment(position: Int): MealFragment = fragmentList[position]



}

默认初始调用一次addItem方法，参数传入当前周（周日开始）的周日0点的时间戳，就可以获得这一周的起止日期了，这是一个可以无限添加fragment的viewpager2， 所以

offscreenPageLimit = 5

设置多少不那么重要了，暂定5吧

MealFragment里就是 viewmodel中定义一个initData()方法，伪代码示意：

class MealViewModel : BaseViewModel() {



    fun init() {

        viewModelScope.launch {

            // 请求数据

            ...

        }

    }

}

class MealFragment : Fragment() {



    val viewModel : MealViewModel by viewModels()

    

    onverried fun onViewCreated() {

        viewmodel.init()

    }

}

现在是不是已经看出问题来了。

现象是多次点击【下一周】按钮 添加几个fragment，只要超出了设置的离屏缓存数量，往回滑，之前显示过的fragment会重新加载，因为viewpager移除了fragment，不过重新经过onViewcreated 周期的时候，viewmodel里的 viewmodelScope 不再执行，导致页面空白

viewModelScope.launch {

            // 不再执行了

            ...

        }

显然，这个协程scope被cancel（close）了，不过没有被从ViewModel的map中移除，
所以也就谈不上重建。

扫一眼ViewModel 源码，内部有个

Map<String, Object> mBagOfTags = new HashMap<>();

用来存储scope

出现这种问题大概权当使用不当吧，虽然我这么用viewpager已经很久了

一些方案

方案1

viewmodel里的viewModelScope 被取消但不被移除，那就暂且不用这个了，替换为GlobalScope 总能用吧

stackoverflow上有一个同样和我一知半解的老外提了同样的问题

未测试

不过这种方案应该没人会采用，globalScope 估计只用于demo测试中

方案2

不自己缓存fragmentlist了，只缓存数据，每次去从viewpager缓存中获取

class MealViewPagerAdapter(fm: FragmentManager?, life : Lifecycle) : FragmentStateAdapter(fm!! , life) {



    val startDateTimeList = mutableListOf<Long>()



    fun addItem(startDate : Long) {

        startDateTimeList.add(startDate)

        notifyItemInserted(itemCount - 1)

    }



    override fun getItemCount(): Int = startDateTimeList.size



    override fun createFragment(position: Int): MealItemFragment = MealItemFragment.newInstance(startDateTimeList[position])

}

测试ok

方案3

不使用viewmodelScope， 用fragment的Scope代替

fun launchLifecycle(lifecycleOwner : LifecycleOwner , block: suspend () -> Unit) {

    lifecycleOwner.lifecycleScope.launch {

        block()

    }

}

测试ok

方案4

谷歌官方的示例项目iosched中是这样写的

viewpager2中同样使用list 缓存fragment，但不是缓存实例，只缓存生成方法，createFragment(position: Int) 方法调用的时候调用闭包来获取fragment（invoke）。

/**

 * Adapter that builds a page for each info screen.

 */

inner class InfoAdapter(fragment: Fragment) : FragmentStateAdapter(fragment) {

    override fun createFragment(position: Int) = INFO_PAGES[position].invoke()



    override fun getItemCount() = INFO_PAGES.size

}



companion object {



    private val INFO_TITLES = arrayOf(

        R.string.event_title,

        R.string.travel_title,

        R.string.faq_title

    )

    private val INFO_PAGES = arrayOf(

        { EventFragment() },

        { TravelFragment() },

        { FaqFragment() }

        // TODO: Track the InfoPage performance b/130335745

    )

}

尽管他只有三个fragment，不过测了下自己的场景，同样能解决问题

测试ok

代码位于项目中的InfoFragment类里

方案5

上边的stackOverflow方法中还提到用共享viewmodel的方式，大致应该是这样

private val viewModel: SearchViewModel by viewModels(

    ownerProducer = { requireParentFragment() }

)

让viewmodel去伴随父fragment的周期，不过感觉设计上不太合适，没有去测

对于初学者来说使用lieveData的好处是足够简单和相对安全

引入flow主要因为以下几点：

• 具有更友好的API，学习成本较低


• 跟Kotlin协程、LiveData结合更紧密，Flow能够转换成LiveData，在ViewModel中直接使用


• 结合协程的作用域，当协程被取消时，Flow也会被取消，避免内存泄漏


• flow库隶属于kotlin， livedata属于Android， 拜托Android平台的限制对于未来跨平台发展有利

【flow是个冷数据流】

所谓冷流，即下游无消费行为时，上游不会产生数据，只有下游开始消费，上游才开始产生数据。

而所谓热流，即无论下游是否有消费行为，上游都会自己产生数据。

下边通过一个经典场景详细描述下flow（单纯的flow，而stateFlow会在后续章节中讲解）的使用

案例：一个菜谱应用app中，我想在一个页面展示一个列表（recyclerview） ，此列表的每个item是个子列表，子列表依次为

计划菜谱列表；

收藏菜谱列表；

根据食材筛选的菜谱列表；

根据食材获取用户偏好的菜谱列表；

如图

四个子列表需要四个接口来获取，组装好后来刷新最后的列表

其中每个列表都有可能是空，是emptylist的话这行就不显示了，因为四个接口数据量大小不同，所以不会同一时间返回，同时又要保障这四个子列表按要求的顺序来展示。

思路：

设计数据结构，最外层的data：

data class ContainerData(val title : String , val list: List<Recipe>)

其中Recipe实体是每个菜谱

data class Recipe(val id: String,

                   val name: String,

                   val cover: String,

                   val type: Int,

                   val ingredients: List<String>? = mutableListOf(),

                   val minutes: Int,

                   val pantryItemCount : Int )

模拟四个请求为:

val plannlist = Request.getPlannlist()

val favouritelist= Request.getFavouritelist()

... 以此类推

如果按照要求四个请求返回次序不同，同时要求在列表中按顺序显示，如果实现？

方案一：可以等待四个请求都返回后然后组装数据，刷新列表

可以利用协程的await方法：

val dataList = MutableLiveData<List<Constainer>>()



viewModelScope.launch {

  // planner

 val plannerDefer = async { Request.getPlannlist() }

 

 // favourite

 val favouriteDefer = async { Request.getFavouritelist() }

 

 val plannerData = plannerDefer.await()

 val favouriteData = favouriteDefer.await()



  

  ....省略后两个接口

  

  

  val list = listof(

  	Container("planner" , plannerData)，

    Container("favourite" , favouriteData)，

  	...

  )

  

  dataList.postValue(list)  

}

await() 方法是挂起协程，四个接口异步请求（非顺序），等最后一个数据请求返回后才会执行下边的步骤

然后组装数据利用liveData发送，在view中渲染

viewModel.dataList.observe(viewLifecycleOwner) {

     mAdapter.submitList(it)

}

此种方式简单，并且有效解决了按顺序排列四个列表的需求，缺点是体验差，假如有一个接口极慢，其他几个就会等待它，用户看着loading一直发呆么。

方案二：接口间不再互相等待，哪个接口先回来就渲染哪个，问题就是如何保障顺序？

有的同学会有方案：先定制一个空数据list

val list = listOf(

  Container("planner", emptylist()),

	Container("favourite", emptylist()),

  ...

)

然后先用adapter去渲染list，哪个接口回来就去之前的列表查找替换，然后adapter刷新对应的数据，当然可以，不过会产生一部分逻辑胶水代码，查找遍历的操作。

此时我们可以借助flow来实现了

1 构造一个planner数据流

val plannerFlow = flow { 

        val plannList = Request.getPlanlist()

			  emit(ContainerData("Planner", plannList))

    }.onStart {

        emit(ContainerData("", emptylist()))

    }

注意是个val 变量， 不要写成 fun plannerFlow() 方法，不然每次调用开辟新栈的时候新建个flow，并且会一直保存在内存中，直到协程取消

其中onStart 会在发送正式数据之前发送，作为预加载。

然后我们就可以构造正式请求了

viewModelScope.launch {



      combine(plannerFlow , favouriteFlow , xxxFlow ,xxxFlow) { planner , favourites , xxx , xxx  ->

                mutableListOf(planner , favourites , xxx,xxx)

      }.collect {

                datalist.postValue(it)

         }

     }

combine 的官方注释为

Returns a Flow whose values are generated with transform function by combining the most recently emitted values by each flow.

combine操作符可以连接两个不同的Flow ， 一旦产生数据就会触发组合后的flow的流动，同时它是有序的。

后续章节继续讲述flow其他特性，并彻底弃用liveData。

0. 按钮一族现状

随着 Flutter 3.3 的发布，RaisedButton 组件从 Flutter 框架中移除，曾为界面开疆拓土的 按钮三兄弟 彻底成为历史。

另外 MaterialButton、RawMaterialButton 也将在未来计划被废弃，所以不建议大家再使用了：

目前，取而代之的是 TextButton 、ElevatedButton 、 OutlinedButton 三个按钮组件，本文将重点介绍这三者的使用方式。

另外，一些简单的按钮封装组件仍可使用：

CupertinoButton ： iOS 风格按钮

CupertinoNavigationBarBackButton ： iOS 导航栏返回按钮

BackButton ： 返回按钮

IconButton ： 图标按钮

CloseButton ： 关闭按钮

FloatingActionButton ： 浮动按钮

还有一些 多按钮 集成的组件，将在后续文章中详细介绍：

CupertinoSegmentedControl

CupertinoSlidingSegmentedControl

ButtonBar

DropdownButton

ToggleButtons

1. 三个按钮组件的默认表现

如下，是 ElevatedButton 的默认表现：有圆角和阴影，在点击时有水波纹。构造时必须传入点击回调函数onPressed 和子组件 child :

ElevatedButton(

  onPressed: () {},

  child: Text('ElevatedButton'),

),

如下，是 OutlinedButton 的默认表现：有圆角和外边线，内部无填充，在点击时有水波纹。构造时必须传入点击回调函数onPressed 和子组件 child :

OutlinedButton(

  onPressed: () {},

  child: Text('OutlinedButton'),

);

如下，是 TextButton 的默认表现：无边线，无填充，在点击时有水波纹。构造时必须传入点击回调函数onPressed 和子组件 child :

TextButton(

  onPressed: () {},

  child: Text('TextButton'),

);

2. 按钮样式的更改

如果稍微翻一下源码就可以看到，这三个按钮本质上是一样的，都是 ButtonStyleButton 的衍生类。只不过他们的默认样式 ButtonStyle 不同而已：

如下所示，在 ButtonStyleButton 类中队列两个抽象方法，需要子类去实现，返回默认按钮样式：

拿下面的 ElevatedButton 组件来说，它需要实现 defaultStyleOf 方法来返回默认主题。在未使用 Material3 时，通过 styleFrom 静态方法根据主题进行相关属性设置：比如各种颜色、阴影、文字样式、边距、形状等。

所以，需要修改按钮样式，只要提供 style 属性设置即可：该属性类型为 ButtonStyle，三个按钮组件都提供了 styleFrom 静态方法创建 ButtonStyle 对象，使用如下：

ButtonStyle style = ElevatedButton.styleFrom(

  backgroundColor: Colors.orange,

  foregroundColor: Colors.white,

  elevation: 0,

  padding: const EdgeInsets.symmetric(horizontal: 40),

  shape: const StadiumBorder(),

  side: const BorderSide(color: Colors.black,),

);



ElevatedButton(

   onPressed: () {},

   child: Text('Login'),

   style: style

);

通过指定 shape 可以形状，如下所示，通过 CircleBorder 实现圆形组件：

ButtonStyle style = ElevatedButton.styleFrom(

  backgroundColor: Colors.blue,

  foregroundColor: Colors.white,

  elevation: 2,

  shape: const CircleBorder(),

);



ElevatedButton(

    onPressed: () {},

    style: style,

    child: const Icon(Icons.add)

);

TextButton 、ElevatedButton 、 OutlinedButton 这三个按钮，只是默认主题不同。如果提供相同的配置，OutlinedButton 因为可以实现下面的显示效果。

ButtonStyle style = OutlinedButton.styleFrom(

  backgroundColor: Colors.blue,

  foregroundColor: Colors.white,

  elevation: 0,

  shape: const CircleBorder(),

  side:BorderSide.none

);



OutlinedButton(

    onPressed: () {},

    style: style,

    child: const Icon(Icons.add)

);

常见样式属性：

另外，还有一些不常用的属性，了解一下即可：

3. 按钮的事件

这三个按钮在构造时都需要传入 onPressed 参数作为点击回调。另外，还有三个回调 onLongPress 用于监听长按事件；onHover 用于监听鼠标悬浮事件；onFocusChange 用于监听焦点变化的事件。

ElevatedButton(

  onPressed: () {

    print('========Login==========');

  },

  onHover: (bool value) {

    print('=====onHover===$value==========');

  },

  onLongPress: () {

    print('========onLongPress==========');

  },

  onFocusChange: (bool focus) {

    print('=====onFocusChange===$focus==========');

  },

  child: const Text('Login'),

);

当按钮的 onPressed 和 onLongPress 都为 null 时，按钮会处于 禁用状态 。此时按钮不会响应点击，也没有水波纹效果；另外，按钮的背景色，前景色分别取用 disabledBackgroundColor 和 disabledForegroundColor 属性：

ElevatedButton(

  onPressed: null,

  style: style,

  child: const Text('Login'),

);

4. 按钮的尺寸

在按钮默认样式中，规定了最小尺寸是 Size(64, 36) ， 最大尺寸无限。

也就是说，在父级区域约束的允许范围，按钮的尺寸由 子组件 和 边距 确定的。如下所示，子组件中文字非常大，按钮尺寸会适用文字的大小。

ButtonStyle style = ElevatedButton.styleFrom(

  // 略...

  padding: const EdgeInsets.symmetric(horizontal: 40,vertical: 10),

);



ElevatedButton(

    onPressed: null,

    style: style,

    child: const Text('Login',style: TextStyle(fontSize: 50),),

);

父级约束 是绝对不能违逆的，在紧约束下，按钮的尺寸会被锁死。如下，通过 SizedBox 为按钮施加一个 200*40 的紧约束：

SizedBox(

  width: 200,

  height: 40,

  child: ElevatedButton(

    onPressed: (){},

    style: style,

    child: const Text('Login'),

  ),

);

如下，将紧约束宽度设为 10 ，可以看出按钮也只能遵循。即使它本身最小尺寸是 Size(64, 36)，也不能违背父级的约束：

所以，想要修改按钮的尺寸，有两种方式：

• 
  
  
  
  1. 从 子组件尺寸 边距 入手，调整按钮尺寸。
  
  
  
  


• 
  
  
  
  2. 为按钮施加 紧约束 ，锁死按钮尺寸。
  
  
  
  

5. 简看 ButtonStyleButton 组件的源码实现

首先，ButtonStyleButton 是一个抽象类，其继承自 StatefulWidget， 说明其需要依赖状态类实现内部的变化。

在 createState 方法中返回 _ButtonStyleState 状态对象，说明按钮构建的逻辑在该状态类中：

@override

State<ButtonStyleButton> createState() => _ButtonStyleState();

直接来看 _ButtonStyleState 中的构造方法，一开始会触发组件的 themeStyleOf 和 defaultStyleOf 抽象方法获取 ButtonStyle 对象。这也就是TextButton 、ElevatedButton 、 OutlinedButton 三者作为实现类需要完成的逻辑。

构建的组件也就是按钮的最终表现，其中使用了 ConstrainedBox 组件处理约束；Material 组件处理基本表现内容；InkWell 处理水波纹和相关事件；Padding 用于处理内边距；Align 处理对齐方式。

使用，总的来看：ButtonStyleButton 组件就是一些常用组件的组合体而已，通过 ButtonStyle 类进行样式配置，来简化构建逻辑。通过封装，简化使用。另外，我们可以通过主题来统一样式，无需一个个进行配置，这个在后面进行介绍。那本文就到这里，谢谢观看 ~

前言

最近项目是采用微服务架构开发的，各服务之间通过gPRC调用，基于ProtoBuf序列化协议进行数据通信，因此接触学习了Protobuf，本文会对Protobuf的语法做下总结，感兴趣的小伙伴们可以参考借鉴，希望对大家能有所帮助。

gRPC的调用模型如下：

基本规范

• 文件以.proto做为文件后缀，除结构定义外的语句以分号结尾。
• rpc方法定义结尾的分号可有可无。
• Message命名采用驼峰命名方式，字段命名采用小写字母加下划线分隔方式。

基本语法

首先看一个简单的示例：

/*

头部相关声明

*/

syntax = "proto3"; // 语法版本为protobuf3.0

package user; // 定义包名,可以为.proto文件指定包名,防止消息名冲突。

import "common.proto"; // 导入common.proto

option go_package = ".;proto";



//服务

service User {

rpc SayHello (SayHelloRequest) returns (SayHelloResponse) {}

}



//定义请求消息体

message SayHelloRequest {

string name = 1;

int64  role = 2;

}



//定义响应消息体

message SayHelloResponse {

string message = 1;

}

• .proto文件的第一个非注释行用于指定语法版本，默认为“proto2”;

package定义包

可以为.proto文件指定包名,防止消息名冲突。

import 导入包

可以通过import导入其它.proto中定义的消息；常用于导入一些公共的信息。

正常情况下只能使用直接导入的proto文件的定义；如果需要使用多级import导入的文件，import 可以使用 public 属性。示例如下：

a.proto

import public "common.proto"; // 注意此处使用的是import public

import "c.proto";

b.proto

import "a.proto";

在b.proto中可以用common.proto中定义的内容，但是不能用c中的定义的内容。

定义Message

定义message使用“message”关键字，消息的字段声明由4部分构成：字段修饰符 字段类型 字段名称 = 标志号。

格式如下：

message 消息名称 {

[字段修饰符] 字段类型 字段名称 = 标志号;

}

字段修饰符

• singular:默认值，该字段可以出现0次或者1次(不能超过1次)；
• repeated：该字段可以重复任意多次(包括0次);

我们可以使用repeated关键字来表示动态数组，示例如下：

message User {

	repeated int64 id = 1;

}

在请求的时候我们可以传[]int64{1, 2, 3, 4}。

字段类型

关于字段类型，这里列举几个常用的，其它的如果有需要可以直接网上搜。

字段编号

每个字段都有一个编号，这些编号是 唯一的。该编号会用来识别二进制数据中的字段。编号在1-15范围内可以用一个字节编码表示，在16-2047范围用两个字节表示，所以将15以内得编号留给频繁出现的字段可以节省空间。

枚举类型

在定义消息类型时，我们有可能会为某个字段预定义值的一个列表，我们可以通过enum来添加一个枚举，为每个可能的值添加一个常量。示例如下：

message UserRequest {

    string name = 1; 

    // 定义性别枚举

    enum Gender {

        UNKNOWN = 0;

        MAN = 1;

        WOMAN = 2;

    }

    // 定义一个枚举字段

    Gender gender = 2;

}

注意：所有枚举定义都需要包含一个常量映射到0并且作为定义的首行。

嵌套类型

嵌套类型，也就是字面意思，在 message 消息体中，又嵌套了其它的 message 消息体，一共有两种模式，如下：

syntax = "proto3";

message UserResponse {

    message User {

        int64 id = 1;

        string name = 2;

    }

    repeated User users = 1;

} 

如果在外部消息之外使用内部消息，则需要使用“outermsg.innermsg”的方式，如，需要在UserResponse外使用User， 则应该使用：

UserResponse.User

Map类型

在返回列表的时候，map类型经常用到，可以使用map关键字可以创建一个映射，语法如：

map<key_type, value_type> map_field = N;

• key_type 只能是整数或字符串，enum不能作为key_type;
• value_type 是除了映射（map）意外的任意类型；

示例：

message User {

    int64 id = 1;

    string name = 2;

}



map[int64, User] users = 1;

定义Service

如果想在RPC中使用已经定义好的消息类型，可以在.proto文件中定一个消息服务接口，使用service关键字进行服务定义，如：

service User {

rpc SayHello (SayHelloRequest) returns (SayHelloResponse) {}

}

说起灵动岛，大家肯定都不陌生，因为这段时间这个东西实在是太火了，这是苹果14中算是最大的更新了😂，不拿缺点当缺点，并且还能在缺点上玩出花，这个产品思路确实厉害👍，不得不服！灵动岛看着效果挺炫，其实实现起来并不是特别复杂，今天带大家一起来使用 Compose 实现下属于安卓的“灵动岛”！废话不多说，先来看下本篇文章实现的效果。

看着还可以吧，哈哈哈，接着往下说！

苹果的灵动岛

在网上找了写灵动岛的视频，大家想看的可以点击链接去看下，肯定比Gif图清晰。

灵动岛视频

嗯，这样看着确实挺好看，如果不是见过真机显示效果我真的就信了😂，不过还是上面说的，思路奇特，大方承认缺点值得肯定！

Compose 简单实现

之前几篇文章大概说了下 Compose 中的动画，思考下这个动画该如何写？我刚看到这个动画的时候也觉得实现起来不容易，但其实转念一想并不难，其实这些动画总结下来就是根据事件不同 Size 的大小也发生了改变，如果在之前原生安卓实现的话会复杂一些，但在 Compose 中就很简单了，还记得之前几篇文章中提到的 animateSizeAsState 么？这是 Compose 中开箱即用的 API，这里其实就可以使用这个来实现，来一起看下代码！

@Composable

fun DynamicScreen() {

    var isCharge by remember { mutableStateOf(true) }



    val animateSizeAsState by animateSizeAsState(

        targetValue = Size(if (isCharge) 170f else 100f, 30f)

    )



    Column {

        Box(modifier = Modifier

                .width(animateSizeAsState.width.dp)

                .height(animateSizeAsState.height.dp)

                .shadow(elevation = 3.dp, shape = RoundedCornerShape(15.dp))

                .background(color = Color.Black),

        )



        Button(

            modifier = Modifier.padding(top = 30.dp, bottom = 5.dp),

            onClick = { isCharge = false }) {

            Text(text = "默认状态")

        }



        Button(

            modifier = Modifier.padding(vertical = 5.dp),

            onClick = { isCharge = true }) {

            Text(text = "充电状态")

        }

    }

}

其实核心代码只有一行，就是上面所说的 animateSizeAsState ，其他的代码基本都在画布局，这里使用 Box 来画了下灵动岛的黑色圆角，并且将 box 的背景设置为了黑色，然后画了两个按钮，一个表示充电状态，另一个表示默认状态，点击按钮就可以进行切换，来看下效果！

大概样式有了，但是不是感觉少了点什么？没错！苹果的动画有回弹效果，但咱们这个没有，那该怎么办呢？还好上一篇文章中咱们讲过动画规格，这里就使用 Spring 就可以满足咱们的需求了，如果想详细了解 Compose 动画规格的话可以移步上一篇文章：Compose 动画艺术探索之动画规格。

来稍微改下代码：

val animateSizeAsState by animateSizeAsState(

    targetValue = Size(if (isCharge) 170f else 100f, 30f),

    animationSpec = spring(

        dampingRatio = Spring.DampingRatioLowBouncy,

        stiffness = Spring.StiffnessMediumLow

    )

)

别的代码都没动，只是修改了下动画规格，再来看下效果！

嗯，是不是有点意思了！

实现多种切换

上面咱们简单实现了充电的一种状态，但是咱们可以看到苹果里面可不止这一种，上面咱们使用的是 Boolean 值来进行切换的，但如果多种状态的话 Boolean 就有点力不从心了，这个时候就得考虑新的方案了！

private sealed class BoxState(val height: Dp, val width: Dp) {

    // 默认状态

    object NormalState : BoxState(30.dp, 100.dp)



    // 充电状态

    object ChargeState : BoxState(30.dp, 170.dp)



    // 支付状态

    object PayState : BoxState(100.dp, 100.dp)



    // 音乐状态

    object MusicState : BoxState(170.dp, 340.dp)



    // 多个状态

    object MoreState : BoxState(30.dp, 100.dp)

}

可以看到上面代码中写了一个密封类，参数就是灵动岛的宽和高，然后根据苹果灵动岛的样式大概可以分为了几种状态：默认状态就是一小条；充电状态高度较默认状态不变，宽度增加；支付状态高度增加，宽度较默认状态不变；音乐状态高度和宽度都较默认状态增加；多个应用状态宽度不变，但会多出一个小黑圆点。

下面还需要修改下状态：

var boxState: BoxState by remember { mutableStateOf(BoxState.NormalState) }

将状态值由 Boolean 改为了刚刚编写的 BoxState ，然后修改下 animateSizeAsState 的使用：

val animateSizeAsState by animateSizeAsState(

    targetValue = Size(boxState.width.value, boxState.height.value), 

    animationSpec = spring(

        dampingRatio = Spring.DampingRatioLowBouncy,

        stiffness = Spring.StiffnessMediumLow

    )

)

接下来再修改下按钮的点击事件：

Button(

    modifier = Modifier.padding(top = 30.dp, bottom = 5.dp),

    onClick = { boxState = BoxState.NormalState }) {

    Text(text = "默认状态")

}



Button(

    modifier = Modifier.padding(vertical = 5.dp),

    onClick = { boxState = BoxState.ChargeState }) {

    Text(text = "充电状态")

}

可以看到代码较上面基本没什么改动，只是在点击的时候切换了对应的 BoxState 值。下面再添加几个按钮来对应上面编写的几种状态：

Button(

    modifier = Modifier.padding(vertical = 5.dp),

    onClick = { boxState = BoxState.PayState }) {

    Text(text = "支付状态")

}



Button(

    modifier = Modifier.padding(vertical = 5.dp),

    onClick = { boxState = BoxState.MusicState }) {

    Text(text = "音乐状态")

}

嗯，代码很简单，就不过多描述，直接运行看效果吧！

嗯，效果是不是已经出来了，哈哈哈，是不是很简单，代码实现个简单样式固然不难，但是如果想把系统应用甚至三方应用都适配灵动岛可不是一个简单的事。不过这里咱们值考虑如何实现灵动岛的动画，并不深究系统实现的问题及瓶颈。

多应用状态

上面基本已经实现了灵动岛的大部分动画，但状态中还有一个多应用，就是多个应用在灵动岛上的显示效果还没弄。多应用状态和别的不太一样，别的状态都是灵动岛宽高的变化，但多应用状态会多分出一个小黑圆点，这个需要单独写下。

val animateDpAsState by animateDpAsState(

    targetValue = if (boxState is BoxState.MoreState) 105.dp else 70.dp,

    animationSpec = spring(

        dampingRatio = Spring.DampingRatioLowBouncy,

        stiffness = Spring.StiffnessMediumLow

    )

)



Box {

    Box(

        modifier = Modifier

            .width(animateSizeAsState.width.dp)

            .height(animateSizeAsState.height.dp)

            .shadow(elevation = 3.dp, shape = RoundedCornerShape(15.dp))

            .background(color = Color.Black),

    )

    Box(

        modifier = Modifier

            .padding(start = animateDpAsState)

            .size(30.dp)

            .shadow(elevation = 3.dp, shape = RoundedCornerShape(15.dp))

            .background(color = Color.Black)

    )

}

可以看到这块又加了一个动画 animateDpAsState 来处理多应用状态小黑圆点的展示，如果当前状态为多应用状态的话即 padding 值增加，这样小黑圆点就会单独显示出来，反之不是多应用状态的话，小黑圆点就会在灵动岛下面进行隐藏，不进行展示。实现效果就是开头的效果了。此处也就不再进行展示。

其他方案实现

上面的动画实现主要使用的是 animateSizeAsState ，这个实现当然是没有问题的，但如果不止需要 Size 的话就不太够用了，比如还需要透明度的变化，亦或者还需要旋转缩放等操作的时候就不够用了，这个时候应该怎么办呢？别担心，官方为我们提供了 updateTransition 来处理这种情况，Transition 可管理一个或多个动画作为其子项，并在多个状态之间同时运行这些动画。

其实 updateTransition 咱们并不陌生，在 Compose 动画艺术探索之可见性动画 这篇文章中也提到过，AnimatedVisibility 源码中就使用到了。

下面来试着将 animateSizeAsState 修改为 updateTransition 。

val transition = updateTransition(targetState = boxState, label = "transition")



val boxHeight by transition.animateDp(label = "height", transitionSpec = boxSizeSpec()) {

    boxState.height

}

val boxWidth by transition.animateDp(label = "width", transitionSpec = boxSizeSpec()) {

    boxState.width

}



Box(

    modifier = Modifier

        .width(boxWidth)

        .height(boxHeight)

        .shadow(elevation = 3.dp, shape = RoundedCornerShape(15.dp))

        .background(color = Color.Black),

)

使用方法并不难，可以看到这里使用了 animateDp 方法来处理灵动岛的宽高动画，然后设置了下动画规格，为了方便这里将动画规格抽取了下，其实和上面使用的一致，都是 spring ；transition 还为我们提供了一些常用的动画方法，来看下有哪些吧！

上图中的动画方法都可以进行使用，大家可以根据需求来选择使用。

下面来运行看下 updateTransition 实现的效果吧：

可以看到效果基本一致，如果不需要别的参数直接使用 animateSizeAsState 就足够了，但如果需要别的一些操作的话就可以考虑使用 updateTransition 来实现了。

多个应用切换优化

多应用状态苹果实现的样式中有类似水滴的动效，这块需要使用二阶贝塞尔曲线，其实并不复杂，来看下代码：

Canvas(modifier = Modifier.padding(start = 70.dp)) {

    val path = Path()

    val width = (animateFloatAsState + 30) * density

    val x = animateFloatAsState * density

    val p2x = density * 15f

    val p2y = density * 25f

    val p1x = density * 15f

    val p1y = density * 5f

    val p4x = width - 15f * density

    val p4y = density * 30f

    val p3x = width - 15f * density

    val p3y = 0f

    val c2x = (abs(p4x - p2x)) / 2

    val c2y = density * 20f

    val c1x = (abs(p3x - p1x)) / 2

    val c1y = density * 10f

    path.moveTo(p2x, p2y)

    path.lineTo(p1x, p1y)

    // 用二阶贝塞尔曲线画右边的曲线，参数的第一个点是上面的一个控制点

    path.quadraticBezierTo(c1x, c1y, p3x, p3y)

    path.lineTo(p4x, p4y)

    // 用二阶贝塞尔曲线画左边边的曲线，参数的第一个点是下面的一个控制点

    path.quadraticBezierTo(c2x, c2y, p2x, p2y)



    if (animateFloatAsState == 35f) {

        path.reset()

    } else {

        drawPath(

            path = path, color = Color.Black,

            style = Fill

        )

    }



    path.addOval(Rect(x + 0f, 0f, x + density * 30f, density * 30f))

    path.close()

    drawPath(

        path = path, color = Color.Black,

        style = Fill

    )

}

嗯，看着其实还挺多，其实并不难，确定好四个个点，然后连接上色就行，然后根据小黑圆点的位置动态绘制连接部分即可，关于贝塞尔曲线在这里就不细说了，大伙应该比我懂。最后来看下效果吧！

这回是不是就有点像了，哈哈哈！

打完收工

本文带大家一起写了下当下很火的苹果灵动岛，只是最简单的模仿实现，效果肯定不如苹果调教一年的效果，仅供大家参考。

前言

kotlin-android-extensions 插件是 Kotlin 官方提供的一个编译器插件，用于替换 findViewById 模板代码，降低开发成本

虽然 kotlin-android-extensions 现在已经过时了，但比起其他替换 findViewById 的方案，比如第三方的 ButterKnife 与官方现在推荐的 ViewBinding

kotlin-android-extensions 还是有着一个明显的优点的：极其简洁的 API，KAE 方案比起其他方案写起来更加简便，这是怎么实现的呢？我们一起来看下

原理浅析

当我们接入KAE后就可以通过以下方式直接获取 View

import kotlinx.android.synthetic.main.activity_main.*



class MainActivity : AppCompatActivity() {



    override fun onCreate(savedInstanceState: Bundle?) {

        super.onCreate(savedInstanceState)

        setContentView(R.layout.activity_main)

        viewToShowText.text = "Hello"

    }

    

}

而它的原理也很简单，KAE插件将上面这段代码转换成了如下代码

public final class MainActivity extends AppCompatActivity {

   private HashMap _$_findViewCache;



   protected void onCreate(@Nullable Bundle savedInstanceState) {

      super.onCreate(savedInstanceState);

      this.setContentView(1300023);

      TextView var10000 = (TextView)this._$_findCachedViewById(id.textView);

      var10000.setText((CharSequence)"Hello");

   }



   public View _$_findCachedViewById(int var1) {

      if (this._$_findViewCache == null) {

         this._$_findViewCache = new HashMap();

      }

      View var2 = (View)this._$_findViewCache.get(var1);

      if (var2 == null) {

         var2 = this.findViewById(var1);

         this._$_findViewCache.put(var1, var2);

      }

      return var2;

   }



   public void _$_clearFindViewByIdCache() {

      if (this._$_findViewCache != null) {

         this._$_findViewCache.clear();

      }



   }   

}

可以看到，实际上 KAE 插件会帮我们生成一个 _$_findCachedViewById()函数，在这个函数中首先会尝试从一个 HashMap 中获取传入的资源 id 参数所对应的控件实例缓存，如果还没有缓存的话，就调用findViewById()函数来查找控件实例，并写入 HashMap 缓存当中。这样当下次再获取相同控件实例的话，就可以直接从 HashMap 缓存中获取了。

当然KAE也帮我们生成了_$_clearFindViewByIdCache()函数，不过在 Activity 中没有调用，在 Fragment 的 onDestroyView 方法中会被调用到

总体结构

在了解了KAE插件的简单原理后，我们一步一步来看一下它是怎么实现的，首先来看一下总体结构

KAE插件可以分为 Gradle 插件，编译器插件，IDE 插件三部分，如下图所示

我们今天只分析 Gradle 插件与编译器插件的源码，它们的具体结构如下：

1. AndroidExtensionsSubpluginIndicator是KAE插件的入口


2. AndroidSubplugin用于配置传递给编译器插件的参数


3. AndroidCommandLineProcessor用于接收编译器插件的参数


4. AndroidComponentRegistrar用于注册如图的各种Extension

源码分析

插件入口

当我们查看 kotlin-gradle-plugin 的源码，可以看到 kotlin-android-extensions.properties 文件，这就是插件的入口

implementation-class=org.jetbrains.kotlin.gradle.internal.AndroidExtensionsSubpluginIndicator

接下来我们看一下入口类做了什么工作

class AndroidExtensionsSubpluginIndicator @Inject internal constructor(private val registry: ToolingModelBuilderRegistry) :

    Plugin<Project> {

    override fun apply(project: Project) {

        project.extensions.create("androidExtensions", AndroidExtensionsExtension::class.java)

        addAndroidExtensionsRuntime(project)

        project.plugins.apply(AndroidSubplugin::class.java)

    }



    private fun addAndroidExtensionsRuntime(project: Project) {

        project.configurations.all { configuration ->

            val name = configuration.name

            if (name != "implementation") return@all

            configuration.dependencies.add(

                project.dependencies.create(

                    "org.jetbrains.kotlin:kotlin-android-extensions-runtime:$kotlinPluginVersion"

                )

            )

        }

    }

}



open class AndroidExtensionsExtension {

    open var isExperimental: Boolean = false



    open var features: Set<String> = AndroidExtensionsFeature.values().mapTo(mutableSetOf()) { it.featureName }



    open var defaultCacheImplementation: CacheImplementation = CacheImplementation.HASH_MAP

}

AndroidExtensionsSubpluginIndicator中主要做了这么几件事

1. 创建androidExtensions配置，可以看出其中可以配置是否开启实验特性，启用的feature(因为插件中包含views与parcelize两个功能)，viewId缓存的具体实现(是hashMap还是sparseArray)


2. 自动添加kotlin-android-extensions-runtime依赖，这样就不必在接入了插件之后，再手动添加依赖了，这种写法可以学习一下


3. 配置AndroidSubplugin插件，开始配置给编译器插件的传参

配置编译器插件传参

class AndroidSubplugin : KotlinCompilerPluginSupportPlugin {

    // 1. 是否开启编译器插件

    override fun isApplicable(kotlinCompilation: KotlinCompilation<*>): Boolean {

        if (kotlinCompilation !is KotlinJvmAndroidCompilation)

            return false

        // ...    



        return true

    }



    // 2. 传递给编译器插件的参数

    override fun applyToCompilation(

        kotlinCompilation: KotlinCompilation<*>

    ): Provider<List<SubpluginOption>> {

        //...



        val pluginOptions = arrayListOf<SubpluginOption>()

        pluginOptions += SubpluginOption("features",

                                         AndroidExtensionsFeature.parseFeatures(androidExtensionsExtension.features).joinToString(",") { it.featureName })



        fun addVariant(sourceSet: AndroidSourceSet) {

            val optionValue = lazy {

                sourceSet.name + ';' + sourceSet.res.srcDirs.joinToString(";") { it.absolutePath }

            }

            pluginOptions += CompositeSubpluginOption(

                "variant", optionValue, listOf(

                    SubpluginOption("sourceSetName", sourceSet.name),

                    //use the INTERNAL option kind since the resources are tracked as sources (see below)

                    FilesSubpluginOption("resDirs", project.files(Callable { sourceSet.res.srcDirs }))

                )

            )

            kotlinCompilation.compileKotlinTaskProvider.configure {

                it.androidLayoutResourceFiles.from(

                    sourceSet.res.sourceDirectoryTrees.layoutDirectories

                )

            }

        }



        addVariant(mainSourceSet)



        androidExtension.productFlavors.configureEach { flavor ->

            androidExtension.sourceSets.findByName(flavor.name)?.let {

                addVariant(it)

            }

        }



        return project.provider { wrapPluginOptions(pluginOptions, "configuration") }

    }



    // 3. 定义编译器插件的唯一 id，需要与后面编译器插件中定义的 pluginId 保持一致

    override fun getCompilerPluginId() = "org.jetbrains.kotlin.android"



    // 4. 定义编译器插件的 `Maven` 坐标信息，便于编译器下载它

    override fun getPluginArtifact(): SubpluginArtifact =

        JetBrainsSubpluginArtifact(artifactId = "kotlin-android-extensions")

}

主要也是重写以上4个函数，各自的功能在文中都有注释，其中主要需要注意applyToCompilation方法，我们传递了features，variant等参数给编译器插件

variant的主要作用是为不同 buildType，productFlavor目录的 layout 文件生成不同的包名

import kotlinx.android.synthetic.main.activity_main.*

import kotlinx.android.synthetic.debug.activity_debug.*

import kotlinx.android.synthetic.demo.activity_demo.*

比如如上代码，activity_debug文件放在debug目录下，而activiyt_demo文件则放在demo这个flavor目录下，这种情况下它们的包名是不同的

编译器插件接收参数

class AndroidCommandLineProcessor : CommandLineProcessor {

    override val pluginId: String = ANDROID_COMPILER_PLUGIN_ID



    override val pluginOptions: Collection<AbstractCliOption>

            = listOf(VARIANT_OPTION, PACKAGE_OPTION, EXPERIMENTAL_OPTION, DEFAULT_CACHE_IMPL_OPTION, CONFIGURATION, FEATURES_OPTION)



    override fun processOption(option: AbstractCliOption, value: String, configuration: CompilerConfiguration) {

        when (option) {

            VARIANT_OPTION -> configuration.appendList(AndroidConfigurationKeys.VARIANT, value)

            PACKAGE_OPTION -> configuration.put(AndroidConfigurationKeys.PACKAGE, value)

            EXPERIMENTAL_OPTION -> configuration.put(AndroidConfigurationKeys.EXPERIMENTAL, value)

            DEFAULT_CACHE_IMPL_OPTION -> configuration.put(AndroidConfigurationKeys.DEFAULT_CACHE_IMPL, value)           

            else -> throw CliOptionProcessingException("Unknown option: ${option.optionName}")

        }

    }

}

这段代码很简单，主要是解析variant，包名，是否开启试验特性，缓存实现方式这几个参数

注册各种Extension

接下来到了编译器插件的核心部分，通过注册各种Extension的方式修改编译器的产物

class AndroidComponentRegistrar : ComponentRegistrar {

    companion object {

        fun registerViewExtensions(configuration: CompilerConfiguration, isExperimental: Boolean, project: MockProject) {

            

            ExpressionCodegenExtension.registerExtension(project,

                    CliAndroidExtensionsExpressionCodegenExtension(isExperimental, globalCacheImpl))



            IrGenerationExtension.registerExtension(project,

                    CliAndroidIrExtension(isExperimental, globalCacheImpl))



            StorageComponentContainerContributor.registerExtension(project,

                    AndroidExtensionPropertiesComponentContainerContributor())



            ClassBuilderInterceptorExtension.registerExtension(project,

                    CliAndroidOnDestroyClassBuilderInterceptorExtension(globalCacheImpl))



            PackageFragmentProviderExtension.registerExtension(project,

                    CliAndroidPackageFragmentProviderExtension(isExperimental))

        }

    }



    override fun registerProjectComponents(project: MockProject, configuration: CompilerConfiguration) {

        if (AndroidExtensionsFeature.VIEWS in features) {

            registerViewExtensions(configuration, isExperimental, project)

        }

    }

}

可以看出，主要就是在开启了AndroidExtensionsFeature.VIEWS特性时，注册了5个Extension，接下来我们来看下这5个Extension都做了什么

IrGenerationExtension

IrGenerationExtension是KAE插件的核心部分，在生成 IR 时回调，我们可以在这个时候修改与添加 IR，KAE插件生成的_findCachedViewById方法都是在这个时候生成的，具体实现如下：

private class AndroidIrTransformer(val extension: AndroidIrExtension, val pluginContext: IrPluginContext) :

    IrElementTransformerVoidWithContext() {



    override fun visitClassNew(declaration: IrClass): IrStatement {

        if ((containerOptions.cache ?: extension.getGlobalCacheImpl(declaration)).hasCache) {

            val cacheField = declaration.getCacheField() 

            declaration.declarations += cacheField // 添加_$_findViewCache属性

            declaration.declarations += declaration.getClearCacheFun() // 添加_$_clearFindViewByIdCache方法

            declaration.declarations += declaration.getCachedFindViewByIdFun() // 添加_$_findCachedViewById方法

        }

        return super.visitClassNew(declaration)

    }



    override fun visitCall(expression: IrCall): IrExpression {

        val result = if (expression.type.classifierOrNull?.isFragment == true) {

            // this.get[Support]FragmentManager().findFragmentById(R$id.<name>)

            createMethod(fragmentManager.child("findFragmentById"), createClass(fragment).defaultType.makeNullable()) {

                addValueParameter("id", pluginContext.irBuiltIns.intType)

            }.callWithRanges(expression).apply {

                // ...

            }

        } else if (containerHasCache) {

            // this._$_findCachedViewById(R$id.<name>)

            receiverClass.owner.getCachedFindViewByIdFun().callWithRanges(expression).apply {

                dispatchReceiver = receiver

                putValueArgument(0, resourceId)

            }

        } else {

        	// this.findViewById(R$id.<name>)

            irBuilder(currentScope!!.scope.scopeOwnerSymbol, expression).irFindViewById(receiver, resourceId, containerType)

        }

        return with(expression) { IrTypeOperatorCallImpl(startOffset, endOffset, type, IrTypeOperator.CAST, type, result) }

    }

}

如上所示，主要做了两件事：

1. 在visitClassNew方法中给对应的类(比如 Activity 或者 Fragment )添加了_$_findViewCache属性，以及_$_clearFindViewByIdCache与_$_findCachedViewById方法


2. 在visitCall方法中，将viewId替换为相应的表达式，比如this._$_findCachedViewById(R$id.<name>)或者this.findViewById(R$id.<name>)

可以看出，其实KAE插件的大部分功能都是通过IrGenerationExtension实现的

ExpressionCodegenExtension

ExpressionCodegenExtension的作用其实与IrGenerationExtension基本一致，都是用来生成_$_clearFindViewByIdCache等代码的

主要区别在于，IrGenerationExtension在使用IR后端时回调，生成的是IR。

而ExpressionCodegenExtension在使用 JVM 非IR后端时回调，生成的是字节码

在 Kotlin 1.5 之后，JVM 后端已经默认开启 IR，可以认为这两个 Extension 就是新老版本的两种实现

StorageComponentContainerContributor

StorageComponentContainerContributor的主要作用是检查调用是否正确

class AndroidExtensionPropertiesCallChecker : CallChecker {

    override fun check(resolvedCall: ResolvedCall<*>, reportOn: PsiElement, context: CallCheckerContext) {

        // ...

        with(context.trace) {

            checkUnresolvedWidgetType(reportOn, androidSyntheticProperty)

            checkDeprecated(reportOn, containingPackage)

            checkPartiallyDefinedResource(resolvedCall, androidSyntheticProperty, context)

        }

    }

}    

如上，主要做了是否有无法解析的返回类型等检查

ClassBuilderInterceptorExtension

ClassBuilderInterceptorExtension的主要作用是在onDestroyView方法中调用_$_clearFindViewByIdCache方法，清除KAE缓存

private class AndroidOnDestroyCollectorClassBuilder(

    private val delegate: ClassBuilder,

    private val hasCache: Boolean

) : DelegatingClassBuilder() {      

    override fun newMethod(

        origin: JvmDeclarationOrigin,

        access: Int,

        name: String,

        desc: String,

        signature: String?,

        exceptions: Array<out String>?

    ): MethodVisitor {

        val mv = super.newMethod(origin, access, name, desc, signature, exceptions)

        if (!hasCache || name != ON_DESTROY_METHOD_NAME || desc != "()V") return mv

        hasOnDestroy = true

        return object : MethodVisitor(Opcodes.API_VERSION, mv) {

            override fun visitInsn(opcode: Int) {

                if (opcode == Opcodes.RETURN) {

                    visitVarInsn(Opcodes.ALOAD, 0)

                    visitMethodInsn(Opcodes.INVOKEVIRTUAL, currentClassName, CLEAR_CACHE_METHOD_NAME, "()V", false)

                }

                super.visitInsn(opcode)

            }

        }

    }

}

可以看出，只有在 Fragment 的onDestroyView方法中添加了 clear 方法，这是因为 Fragment 的生命周期与其根 View 生命周期可能并不一致，而 Activity 的 onDestroy 中是没有也没必要添加的

PackageFragmentProviderExtension

PackageFragmentProviderExtension的主要作用是注册各种包名，以及该包名下的各种提示

import kotlinx.android.synthetic.main.activity_main.*

import kotlinx.android.synthetic.debug.activity_debug.*

import kotlinx.android.synthetic.demo.activity_demo.*

比如我们在 IDE 中引入上面的代码，就可以引入 xml 文件中定义的各个 id 了，这就是通过这个Extension实现的

总结

本文主要从原理浅析，总体架构，源码分析等角度分析了 kotlin-android-extensions 插件到底是怎么实现的

相比其它方案，KAE使用起来可以说是非常简洁优雅了，可以看出 Kotlin 编译器插件真的可以打造出极简的 API，因此虽然KAE已经过时了，但还是有必要学习一下的

如果本文对你有所帮助，欢迎点赞收藏~

俗话说，无规矩不成方圆，同样的放在代码里也是十分的贴切，所谓在代码里的规矩，指的就是规范，在一定规范约束下的项目，无论是参与开发还是后期维护，都是非常的直观与便捷，不能说赏心悦目，也可以用健壮可维护来表示；毕竟协同开发的项目，每个人都有自己的一套开发标准，你没有一套规范，或者是规范没有落地执行，想想，长此以往，会发生什么？代码堆积如山？维护成本翻倍增加？新人接手困难？等等，所谓的问题会扑面而来。

正所谓规范是一个项目的基石，也是衡量一个项目，是否健壮，稳定，可维护的标准，可谓是相当重要的。我相信，大部分的公司都有自己的一套规范标准，我也相信，很多可能就是一个摆设，毕竟人员的众多，无法做到一一的约束，如果采取人工的检查，无形当中就会投入大量的时间和人力成本，基于此，所谓的规范，也很难执行下去。

介于人工和时间的投入，我在以往的研究与探索中，开发出了一个可视化的代码检查工具，之前进行过分享，《一个便捷操作的Android可视化规范检查》，想了解的老铁可以看一看，本篇文章不做过多介绍,当时只介绍了工具的使用，没有介绍相关功能的开发过程，后续，有时间了，我会整理开源出来，一直忙于开发，老铁们，多谅解。这个可视化的检查工具，虽然大大提高了检查效率，也节省了人力和时间，但有一个潜在的弊端，就是，只能检查提交之后的代码是否符合规范，对于提交之前没有进行检查，也就说，在提交之前，规范也好，不规范也罢，都能提交上来，用工具检查后，进行修改，更改不规范的地方后然后再提交，只能采取这样的一个模式检查。

这样的一个模式，比较符合，最后的代码检查，适用于项目负责人，开发Leader，对组员提交上来的代码进行规范的审阅，其实并不适用于开发人员，不适用不代表着不可用，只不过相对流程上稍微复杂了几步；应对这样的一个因素，如何适用于开发人员，方便在提交代码之前进行规范检查，便整体提上了研发日程，经过几日的研究与编写，一个简单便捷的Android端Git提交专有hook，便应运而生了。

说它简单，是因为不需要编写任何的代码逻辑，只需要寥寥几步命令，便安装完毕，通过配置文件，便可灵活定制属于自己的检查范围。

为了更好的阐述功能及讲述实现过程，便于大家定制自己的开发规范，再加上篇幅的约束，我总结了四篇文章来进行系统的梳理，还请大家，保持关注，今天这篇，主要讲述最终的开发成果，也就是规范工具如何使用，规范这个东西，其实大差不差，大家完全可以使用我自己已经开发好的这套。

这个工具的开发，利用的是git 钩子(hook)，当然也是借助的是Node.js来实现的相关功能，下篇文章会详细介绍，我们先来安装程序，来目睹一下实际的效果，安装程序，只需要执行几步命令即可，无需代码介入，在实际的开发中需要开发人员，分别进行安装。

安装流程

1、安装 Node.js，如果已经安装，可直接第2步：

Node.js中允许使用 JavaScript 开发服务端以及命令行程序，我们可以去官网nodejs.org
下载最新版本的安装程序，然后一步一步进行安装就可以了，这个没什么好说的，都是开发人员。

2、安装android_standard

android_standard是最终的工具，里面包含着拦截代码判断的各种逻辑 ， 在项目根目录下执行如下命令：

npm install android_standard --save-dev

执行完命令后，你会发现，你的项目下已经多了一个目录，还有两个json文件，如下图所示：

node_modules，用来存放下载安装的包文件夹，里面有我们要使用到的功能，其实和Android中lib目录很类似，都是一些提供功能的库。

package.json文件，是配置文件，比如应用的名字，作者，介绍，还有相关的依赖等，和Android中的build.gradle文件类似。

3、创建git配置文件，执行如下命令

node node_modules/android_standard/gitCommitConfig

命令执行成功会返回如下信息：

此命令执行完后，会在项目根目录下创建gitCommitConfig文件，这个文件很重要，是我们执行相关命令的配置文件，内容如下，大家可以根据自己实际项目需要进行更改。

项目下生成gitCommitConfig.android文件，.android是我自己定义的，至于什么格式，等你自己开发的时候，完全可以自定义，是个文件就行。

打开后，文件内容如下，此文件是比较重要的，后续所有的规范检查，都要根据这个文件里的参数来执行，大家在使用的时候，就可以通过这个文件来操作具体的规范检查。

4、更改执行文件，执行如下命令

执行文件，就是需要在上边生成的package.json文件，添加运行程序，使其在git提交时进行hook拦截。

node node_modules/android_standard/package

5、添加git过滤

因为执行完上述命令后，会产生几个文件，而这几个文件是不需要我们上传到远程仓库的，所以我们需要在.gitignore文件里添加忽略，直接复制即可。

/node_modules

package.json

package-lock.json

gitCommitConfig.android

6、后续如果有更新，可命令进行操作：

注：此命令在更新时执行

npm update android_standard --save-dev

7、删除操作

注：后续不想使用了，便可执行如下命令：

npm uninstall android_standard --save-dev

具体使用

通过上述的安装流程，短短几个命令，我们的规范检查便安装完毕，后续只需要通过gitCommitConfig.android文件，来动态的更改参数即可，是不是非常的方便，接下来，我们来实际的操作一番。

关于配置文件的相关参数，也都有注释，一看便知，这里简单针对最后的参数，做一个说明，也就是gitCommand这个参数，true为工具，false为命令方式；true也好，false也好，在主要的功能验证上，没有区别，唯一的区别就是，命令行的方式提交，会有颜色区分，后面有效果。

我们先来看下命令行下的执行效果，当配置文件开关gitCommitSwitch已开，并且gitCommand为false，其他的配置参数，大家可以根据需要进行改动，在代码提交的时候如下效果：

在Android studio中提交代码执行效果

TortoiseGit提交代码执行效果：

目前呢，针对Android端的规范检查，无论是java还是Kotlin，还是资源文件，都做了一定的适配，经过多方测试，一切正常，如果大家的公司也需要这样的一个hook工具，欢迎使用，也欢迎继续关注接下来的相关实现逻辑文章。

好了各位老铁，这篇文章先到这里，下篇文章会讲述，具体的实现过程，哦，忘记了，上篇结尾的遗留组件化还未更新，那就更新完组件化，接着更新这个，哈哈，敬请期待！

引言

对于 Drawable ，一直没有专门记录，日常开发中，也是属于忘记了再搜一下。主要是使用程度有限(仅仅只是shape或者 layer 等冰山一角)，另一方面是 Android 对其的高度抽象，导致从没去关注过细节，从而对于 Drawable 没有真正的理解其设计与存在的意义。

反而是偶尔一次发现其他同学的运用，才明白了自己的狭隘，为此，怀着无比惭愧的心情，写下此篇，与君共勉。

鉴于此，本篇将完整的描述开发中常见各种 Drawable ,以及在工程化项目的背景下，如何更好的运用。总体难度较低，不涉及源码，适合轻松阅读。

来者何人

2022的今天,随便问一个Android开发，Drawable 是什么？

比如我。他(她)肯定会告诉你(鄙视的眼神)，你si不si傻，Drawable 都不知道，Drawable,Drawble，Drawable不就是...😐

不就是经常用来设置的图像吗？🫣(不确定语气,似乎说的不完整)

上述说的有错吗，也没错。嗯，但总觉得差点什么,过于简单？细心的你肯定会觉得没这么简单。

那到底什么是Drawable?

Drawable 表示的是一种可以在Canvas上进行绘制的抽象概念。人话就是 就是指可在屏幕上绘制的图形。

就这？就这？就这？

这说了个啥，水水水，一天就知道水文章？🫵🏼

嗯🧐，在开发角度来看，Drawable 是一个抽象的类，用来表示可以绘制在屏幕上绘制的图形。我们常见有很多种 Drawable ,比如Bitmapxx,Colorxxx,Shapexxx，它们一般都用于表示图像，但严格上来说，又不全是图像。

后半句用人话怎么理解呢？

对于普通的图形或图片，我们肯定没法更改，因为其已经固定了(资源文件)。

但是对于 Drawable，虽然某种程度上也是图形(矢量资源)，但其具备处理或绘制具体显示逻辑的方式。也就是说，这是一个支持修改的图形，比如我们可以把一张图塞给了 BitmapDrawable ,但依然可以做二次调整，比如拉伸一下，改一下位置，给这张图上再添加点别的什么东西。或者也可以理解为这是一个简化版的View，只不过它更简易，目的纯粹。其无法像 View 一样接收事件或者和用户交互，其更像一个绘制板，指哪打哪，仅作为显示使用。

当然除了简单的绘图，Drawable 还提供了很多通用api,使得我们可以与正在绘制的内容进行交互，从而更加完善。

相应的，Drawable 内部其实也有自己的宽高、通过 intrinsicWidth、intrinsicHeight 即可获取。需要注意的是：

• Drawable 的宽高不等于其展示时的大小，我们可以认为 Drawable 不存在大小的概念，因为其用于View背景时，其会被拉伸至View的同等大小。


• 也并不是所有的 Drawable 都有内部宽高,比如，由一个图片所形成的 Drawable ，其相应的宽高也就是图片的宽高,而由颜色所形成的Drawable ,相应的内部也不存在宽高。

Drawable的种类

如下所示，Drawable有如下类型：

好家伙，这也太多了吧，而且后续还会越来越多。

当然这么多，我们一般其实根本不可能全部用上，常见的有如下几种类别：

无状态

• 
  

  BitmapDrawable

  
  

  <<bitmap

  
  

  用于将图片转为BitmapDrawable;

  
  


• 
  

  ShapeDrawable

  
  

  <<shape

  
  

  通过颜色来构造Drawable;

  
  


• 
  

  VectorDrawable

  
  

  <<vector

  
  

  矢量图，Android5.0及以上支持。便于在缩放过程中保证显示质量，以及一个矢量图支持多个屏幕，减少apk大小;

  
  


• 
  

  TransitionDrawable

  
  

  <<transition

  
  

  用于实现Drawable间的淡入淡出效果;

  
  


• 
  

  InsetDrawable

  
  

  <<inset

  
  

  用于将其他Drawable内嵌到自己当中,并可以在四周留出一定的间距。当一个View希望自己的背景比实际的区域小时，可以采用其来实现。

  
  

有状态

• 
  

  StateListDrawable

  
  

  <<selector

  
  

  用于有状态交互时的View设置，比如 按下时 的背景，松开时 的背景，有焦点时的背景灯；

  
  


• 
  

  LevelListDrawable

  
  

  <<level-list

  
  

  根据等级(level)来切换不同的 Drawble。在View中可以通过设置 setImageLevel 更改不同的Drawable ;

  
  


• 
  

  ScaleDrawable

  
  

  <<scale

  
  

  根据不同的等级(level)指定 Drawable 缩放到一定比例;

  
  


• 
  

  ClipDrwable

  
  

  <<clip

  
  

  根据当前等级(level)来裁剪 Drawable ;

  
  

常见的Drawable

BitmapDrawable

常见使用场景

用于表示一张图片，用于设置 bitmap 在 BitmapDrawable 区域内的绘制方式时使用，如水平平铺或者竖直平铺以及扩展铺满。

xml中的标签：

常见的属性有如下：

• 
  

  android:src

  
  

  资源id

  
  


• 
  

  android:antialias

  
  

  开启图片抗锯齿，用于让图片变得平滑，同时抗锯齿也会一定程度上降低图片清晰度，不过幅度几乎无法感知；

  
  


• 
  

  android:dither

  
  

  开启抖动效果，为低像素机型做的自动降级显示，保证显示效果。比如当前图片彩色模式为ARGB8888,而设备屏幕色彩模式为RGB555，此时开启抖动就可以避免图片显示失真；

  
  


• 
  

  android:filter

  
  

  过滤效果。在图片尺寸被拉伸或者压缩时，有助于保持显示效果；

  
  


• 
  

  android:gravity

  
  

  当前图片小于容器尺寸时，此选项便于对图片进行定位,当titleMode开启时，此属性将失效；

  
  


• 
  

  android:mipMap

  
  

  纹理映射开关，主要是为了应对图片大小缩放处理时，Android可以通过纹理映射技术提前按缩小的层级生成图片预存储在内存中，以此来提高速度与图片质量。默认情况下，mipmap文件夹里的默认开启此开关，drawable默认关闭。但需要注意，此开关只能建议系统开启此功能，至于最终是否真正开启，取决于系统。

  
  


• 
  

  android:tileMode

  
  

  用于设置图片的平铺模式，有以下几个值：[disabled、clamp、repeat、mirror]

  
  
  
  
  • disabled (默认值) 关闭平铺模式
  
  
  • clamp 图片四周的像素会扩展到周围区域
  
  
  • repeat 水平和竖直方向上的平铺效果
  
  
  • mirror 在水平和竖直方向的的镜面投影效果
  
  
  
  

示例代码：

val bitmap = BitmapFactory.decodeResource(resources, R.drawable.ic_doge)

val drawable = BitmapDrawable(bitmap).apply {

    setTileModeXY(Shader.TileMode.CLAMP, Shader.TileMode.CLAMP)

    isFilterBitmap = true

    gravity = Gravity.CENTER

    setMipMap(true)

    setDither(true)

}

ivDrawable.background = drawable

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

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

    android:dither="true"

    android:filter="true"

    android:gravity="center"

    android:mipMap="true"

    android:src="@drawable/test"

    android:tileMode="repeat" />

ShapeDrawable

常见使用场景

通过颜色来构造图形，作为背景描边或者背景色渐变时使用，可以说是最常见的一种 Drawable。

xml中的标签：

常见的属性如下：

• 
  

  shape

  
  

  表示图形的形状，如下四个选项：rectangle(矩形)、oval(椭圆)、line(横线)、ring(圆环)

  
  


• 
  

  corners

  
  

  表示shape的四个角的角度，只适用于矩形shape。

  
  
  
  
  • android:radius 为四个角设置相同的角度
  
  
  • android:topLeftRadius 设置左上角角度
  
  
  • android:bottomLeftRadius 设置左下角角度
  
  
  • android:bottomRightRadius 设定右下角的角度
  
  
  
  


• 
  

  gradient

  
  

  用于表示渐变效果，与 标签互斥(其表示纯色填充)

  
  
  
  
  • android:angle 渐变的角度，默认为0,其值必须为45的倍数, 0表示从左向右，90表示从下到上
  
  
  • android:centerX 渐变中心点的横坐标
  
  
  • android:centerY 渐变中心点纵坐标
  
  
  • android:startColor 渐变的起始色
  
  
  • android:centerColor 渐变的中间点
  
  
  • android:endColor 渐变的结束色
  
  
  • android:gradientRadius 渐变半径,仅当android:type=“radial”时有效
  
  
  • android:useLevel 是否使用等级区分，在 StateListDrawable 时有效，默认 false
  
  
  • android:type 渐变类型，linear(线性渐变)、radial(径向渐变)、sweep
  
  
  
  


• 
  

  solid 表示纯色填充

  
  


• 
  

  stroke 用于设置描边

  
  
  
  
  • android:width 描边宽度
  
  
  • android:color 描边颜色
  
  
  • android:dashWidth 描边虚线时的宽度
  
  
  • android:dashGap 描边虚线时的间隔
  
  
  
  

  

  
  


• 
  

  padding

  
  

  用于表示空白，其代表了在View中使用时的空白。但其在shape中并没有什么作用，可以在 layer-list 中进行使用。

  
  


• 
  

  size

  
  

  用于表示 shape 的 固有大小 ，但其不代表shape最终显示的大小。因为对于shape来说，其没有宽/高的概念，因为其最终被设置到View上作为背景时,其会被自动拉伸或缩放。但作为drawable,它拥有着固有宽/高,即通过 getIntrinsicWidth，getIntrinsicHeight 获取。对于某些Drawable而言，比如BitMapDrawable时，其宽高就是图片大小；而对于shape时，其就不存在大小，默认为-1。当然你也可以通过 size 设置大小，但其最终代表的是shape的固有宽高，作为背景时其并不是最终显示时的宽高。

  
  

示例如下：

LayerDrawable

表示一种层次化的集合 drawable ,一般常见于需要多个 Drawable 叠加 摆放效果时使用。

一个 layer-list 中可以包含多个 item ,每个item表示一个 Drawable ,其常用的属性 android:top,left,right,bottom 。相当于相对View的 上下左右 偏移量，单位为像素。此外也可以通过 Drawable 引用一个已有的 Drwable 资源。

xml中的标签：

示例如下:

StateListDrawable

用于为不同的 View状态 引用不同的 Drawable ,比如在View 按下 时，View 禁用 时等。

xml中的标签：

常用的属性如下：

• 
  

  constantSize

  
  

  表示其固有大小是否随着状态而改变。

  
  

  因为每次切换状态时，都会伴随着 Drawable 的改变，如果此时不是用于背景，则如果 Drawable 的固有大小不一致，则会导致StateListDrawable 的大小发生变化。如果此值为 true ,则表示当前 StateDrawable 的固有大小是当前其内部所有 Drawable 中最大值。反之，则根据状态决定;

  
  


• 
  

  android:dither

  
  

  是否开启抖动效果，用于在低质量屏幕上获得较好的显示效果;

  
  


• 
  

  variablePadding

  
  

  表示padding是否随着状态而改变，true表示跟随状态而决定，取决于当前显示的drawable,false则选取drawable集合中padding最大值。

  
  

示例如下：

LevelListDrawable

用于根据不同的等级表示一个 Drawable 集合。

默认等级范围为0,最小为0,最大为10000，可以在View中使用 Drawable 从而设置相应的 level 切换不同的 Drawable。如果这个drawable被用于ImageView 的 前景Drawable,还可以通过 ImageView.setImageViewLevel 来切换。

xml中的标签：

示例代码如下：

在代码中即可通过 setLevel切换。

 view.background.level = 10

 view.background.level = 200

TransitaionDrawable

用于实现两个 Drawable 之间的淡入淡出效果。

xml中的标签：

示例如下：

InsetDrawable

用于将其他 Drawable 内嵌到自己当中，并可以在四周留出一定的间距。比如当某个 View 希望自己的背景比自己的实际区域小时，可以采用这个 Drawable ,当然采用 LayerDrawable 也可以实现。

xml中的标签：

其属性分别如下：

• android:inset 表示四边内凹大小


• android:insetTop 表示顶部内凹大小


• android:insetLeft 表示左边内凹大小


• android:insetBottom 表示底部内凹大小


• android:insetRight 表示右边内凹大小

ScaleDrawable

用于根据等级(level)将指定的 Drawable 缩放到一定比例。

xml中的标签：

相应的属性如下所示：

• 
  

  android:scaleGravity

  
  

  类似于与android:gravity

  
  


• 
  

  android:scaleWidth

  
  

  指定宽度的缩放比例(相对于原drawable缩放了多少)

  
  


• 
  

  android:scaleHeight

  
  

  指定高度的缩放比例(相对于原drawable缩放了多少)

  
  


• 
  

  android:level(minSdk>=24)

  
  

  指定缩放等级,默认为0,即最小,最高10000,此值越大,最终显示的drawable越大

  
  

需要注意的是，当level为0时，其不会显示，所以我们使用ScaleDrawable时，需要在代码中，将 drawable.level 调为1。

示例如下：

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

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

    android:drawable="@drawable/level2_drawable"

    android:level="1"

    android:scaleWidth="70%"

    android:scaleHeight="70%"

    android:scaleGravity="center" />