0
0

Android Compose 介绍与实践

简介

Jetpack Compose 是 Google 官方 2019 年推出的UI框架，它可简化并加快 Android 的 UI 开发工作。使用更少的代码、强大的工具和直观的 Kotlin API，快速构建 App 的 UI。2021年迎来 Compose 的正式版，来了解一下这个官方强推的，布局机制、渲染机制、具体写法等可以说是全新的UI框架了。

先来看一段简单的 Compose 代码：

  1. Column {
  2.     Text("Hello world")
  3.     Image()
  4. }

OK这就是一个完整的UI界面了，对比原来定义在 xml 文件中的方式有着天壤之别，展现一个UI不再是去创建一个 TextView 之类的控件，而是变成了一次函数调用。虽然 Text 以大写开头，但它其实就是一个普通函数，严格说是个带 @Composable 注解的 Compose 函数：

  1. @Composable
  2. fun Text(...) {
  3.     ...
  4. }

来看一段完善一些的 Compose 代码：

  1. @Composable
  2. fun NewsStory() {
  3.     MaterialTheme {
  4.         val typography = MaterialTheme.typography
  5.         Column(
  6.             modifier = Modifier.padding(16.dp)
  7.         ) {
  8.             Image(
  9.                 painter = painterResource(R.drawable.header),
  10.                 contentDescription = null,
  11.                 modifier = Modifier
  12.                     .height(180.dp)
  13.                     .fillMaxWidth()
  14.                     .clip(shape = RoundedCornerShape(4.dp)),
  15.                 contentScale = ContentScale.Crop
  16.             )
  17.             Spacer(Modifier.height(16.dp))
  19.             Text(
  20.                 "A day wandering through the sandhills " +
  21.                      "in Shark Fin Cove, and a few of the " +
  22.                      "sights I saw",
  23.                 style = typography.h6,
  24.                 maxLines = 2,
  25.                 overflow = TextOverflow.Ellipsis)
  26.             Text("Davenport, California", style = typography.body2)
  27.             Text("December 2018", style = typography.body2)
  28.         }
  29.     }
  30. }

以 Column、Row 代替 LinearLayout 等布局，以 Text、Image 等代替 TextView、ImageView 等控件，以 Modifier 等用作细节和修饰，所以其实 Compose 就是这样由多个函数调用组合起来，形成一个完整的 UI 界面。

Compose 改变了原有的基于 xml 和 View 的体系，纯在代码中实现页面UI，那么它比起老的方式有什么优势呢？

Compose 的特点

Jetpack Compose is Android’s modern toolkit for building native UI.

这是官方对 Compose 的定义，比起旧有体系，Compose 更加 “现代”。

现有的 Android 视图体系从 2010年以来没有发生太大变化，10年间无论从硬件规格还是APP复杂度都发生了极大变化，这套已经跑了10年的技术体系也已经显得有些落伍。

声明式 vs 命令式

说起 Compose 最大的特点，就是它是声明式的，而现有体系是命令式的。

  • 命令式：现有视图体系要先将UI定义在 xml 文件中，当需要刷新时，需要在代码中先 findViewById 获取控件的引用，再下达如 setText、setVisibility 等命令，主动要求更新状态、刷新UI。

随着界面越来越复杂，控件越来越多，各控件状态难以保持同步，UI显示不一致的Bug频发。我们的很多精力花费在了如何能准确且不遗漏地更新所有该更新的控件上。

  • 声明式：声明式UI以一个“纯函数”的方式运行，当 State 变化时函数根据传入参数重新执行刷新UI。

Compose 会对界面中用到的数据自动进行订阅——不管是字符串还是图像还是别的什么，Compose 全部能够自动订阅——这样当数据改变的时候，Compose 会直接把新的数据更新到界面。

  1. var text bymutableStateOf("Hello")

个人理解就是，只需要把界面给提前“声明”出来，先定义好在各种 state 时 UI 应该是个什么样子，当数据产生变化时，就不再需要去主动下达 setVisibility 等各种命令，界面会自动更新。

现有的 Data Binding 其实就是声明式的，但它通过数据更新的只能是界面元素的值，而 Compose 可以更新界面中的任何内容，包括界面的结构。

比如以下根据数据变化整个UI结构，Data Binding 就无法做到：

  1. @Composable
  2. fun MessageList(messages: List<String>) {
  3.     Column {
  4.         if (message.size == 0) {
  5.             Text("No messages"）
  6.         } else {
  7.             message.forEach { message ->
  8.                 Text(text=messag)
  9.             }
  10.         }
  11.     }
  12. }

高性能的重组（重绘）

在上面的例子里，当 message 发生变化时，MessageList 重新执行，这个过程叫重组（recomposition）。Composee 的 UI 正是通过不断重组来实现刷新。

但如果数据变化时会触发重组，大面积的重组是否会影响性能呢？

Compose 会通过在 Gap Buffer 这样的线性结构上进行 diff 实现局部刷新。 Gap Buffer 可以理解为一个树形结构经 DFS 处理后的数组，数组单元通过 key 标记其在树上的位置信息。Compose 在编译期为 Composable 生成带有位置信息的 key，存入到 Gap Buffer 数组的对应位置。运行时可以根据 key 来识别 Composable 节点是否发生了位置变化，以决定是否参与重组。同时，Gap Buffer 还会记录 Composable 对象关联的状态（State 或 Parameters），仅仅当关联状态变化时，Composable 才会参与重组，函数才会重新执行。

布局层级嵌套

做 Android 开发的都知道一个规矩：布局文件的界面层级要尽量地少，因为层级的增加会大幅拖慢界面的加载。这种拖慢的主要原因就在于各种 Layout 的重复测量。虽然重复测量对于布局过程是必不可少的，但这也确实让界面层级的数量对加载时间的影响变成了指数级。

而 Compose 是不怕层级嵌套的，因为它从根源上解决了这种问题。它解决的方式也非常巧妙而简单——它不许重复测量。

Compose 通过一种叫做 Intrinsic Measurement（固有特性测量）的机制，避免了随着层级增多，重复测量导致绘制时间指数式增加的性能陷阱，也就是说，使用 Compose 时疯狂嵌套，和把所有组件写在同一层级里，性能上是一样的！这是比起原体系的一大进步。

配合其他 Jetpack 组件

  1. @Composable
  2. fun ConversationScreen() {
  3.     val viewModel: ConversatioinViewModel = viewModel()
  4.     val message by viewModel.messages.observeAsState()
  5.     MessageLit(messages)
  6. }
  8. @Composable
  9. fun MessageList(message: List<String>){
  10.     ...
  11. }

Compose 可以配合现有 Jetpack 组件的使用，例如 ViewModel、LiveData 等，对于一个标准的 Jetpack MVVM项目，将很容易将 UI 部分替换成 Compose。

Composalbe 中调用 viewModel() 可以获取当前 Context 的 ViewModel， observeAsState() 将 LiveData 转换为 Compose State 并建立绑定。当 LiveData 变化时，ConversationScreen 会发生重组，内部的 MessageLit 、MessageItem 由于依赖了参数 messages，都会参与重组。

功能完备的UI系统

Compose目前的 UI 系统功能完备，可以完全覆盖 Android 现有视图系统的所有能力。

  • 各种UI组件：所有常见的UI组件在 Compose 中都能找到对应实现，甚至Card、Fab、AppBar等 Material Designe 的控件也一应俱全、开箱即用 。

  • 列表 List：Compose 的列表非常简单，无需再写烦人的 Adapter。

  1. @Composable
  2. fun MessageList(list: List<Message>) {
  3.     Column {  
  4.         LazyList { // this :LazyListScope
  5.             items(list) { item ->
  6.                 when(item.type) {
  7.                     Unread -> UnreadItem(message)
  8.                     Readed -> ReadedItem(message)
  9.                 }
  10.             }
  11.         }
  12.     }
  13. }

  • 布局 Layout：Compose 提供了多种容器类Composalbe，可以对子组件进行布局，简单易用且功能强大。

  • Row ≈ Horizontal LinearLayout

  • Column ≈ Vertical LinearLayout

  • Box ≈ FragmeLayout

  • 自定义布局：通过简单的函数调用完成 measure 和 layout 过程。

  1. Layout(
  2.     content = content,
  3.     modifier = modifier
  4. ) { measurables, constraints ->
  5.     // Measure the composables
  6.     val placeables = measurable.measure(constraints)
  7.     // Layout the comopsables
  8.     layout(width, height) {
  9.         placeables.forEach { placeable ->
  10.             placeable.place(x, y)
  11.         }
  12.     }
  13. }

  • Modifier 操作符：Compose 通过一系列链式调用的 Modifier 操作符来装饰 Composable 的外观。操作符种类繁多，例如 size、backgrounds、padding 的设置以及 click 事件的添加等。

  • 动画 Animatioin：Compose 动画也是基于 State 驱动不断重组完成的。

  1. @Composable
  2. fun AnimateAsStateDemo() {
  3.     var isHighLight by remember { mutableStateOf(false) }
  4.     val color by animateColorAsState (
  5.         if (isHighLight) Red else Blue,
  6.     )    
  7.     val size by animateDpAsState (
  8.         if (isHighLight) LargeSize else SizeSize,
  9.     )
  10.     Box(Modifier.size(size).background(color))
  11. }

开发中预览

目前的基于 xml 的预览效果很鸡肋，导致很多开发者都习惯于实机运行查看UI。Compose 预览机制可以做到与真机无异，真正的所见所即得。

预览时只需创建一个无参的 Composalbe，并添加 @Preview 注解即可。

  1. @Preview
  2. @Composable
  3. fun PreviewGreeting() {
  4.     Greeting("Android")
  5. }

与现有体系良好的互操作性

Compose 能够与现有 View 体系能一起使用，比如在现有布局中使用 Compose，或在 Compose 布局中使用旧视图体系。所以迁移到 Compose 很方便，可以为一个已有项目先引入 Compose，再逐渐切换，不要求一次性将旧UI全替换为新的，有很大的缓冲空间。

实践

现在来尝试动手写一个简单的 Compose 界面。

配置 Kotlin
  1. plugins {
  2.     id("org.jetbrains.kotlin.android") version "1.4.32"
  3. }
配置 Gradle
  1. android {
  2.     defaultConfig {
  3.         ...
  4.         minSdkVersion(21)
  5.     }
  7.     buildFeatures {
  8.         // Enables Jetpack Compose for this module
  9.         compose = true
  10.     }
  11.     ...
  13.     // Set both the Java and Kotlin compilers to target Java 8.
  15.     compileOptions {
  16.         sourceCompatibility = JavaVersion.VERSION_1_8
  17.         targetCompatibility = JavaVersion.VERSION_1_8
  18.     }
  20.     kotlinOptions {
  21.         jvmTarget = "1.8"
  22.         useIR = true
  23.     }
  25.     composeOptions {
  26.         kotlinCompilerVersion = "1.4.32"
  27.         kotlinCompilerExtensionVersion = "1.0.0-beta07"
  28.     }
  29. }
添加 Jetpack Compose 工具包依赖项
  1. dependencies {
  2.     implementation("androidx.compose.ui:ui:1.0.0-beta07")
  3.     // Tooling support (Previews, etc.)
  4.     implementation("androidx.compose.ui:ui-tooling:1.0.0-beta07")
  5.     // Foundation (Border, Background, Box, Image, Scroll, shapes, animations, etc.)
  6.     implementation("androidx.compose.foundation:foundation:1.0.0-beta07")
  7.     // Material Design
  8.     implementation("androidx.compose.material:material:1.0.0-beta07")
  9.     // Material design icons
  10.     implementation("androidx.compose.material:material-icons-core:1.0.0-beta07")
  11.     implementation("androidx.compose.material:material-icons-extended:1.0.0-beta07")
  12.     // Integration with observables
  13.     implementation("androidx.compose.runtime:runtime-livedata:1.0.0-beta07")
  14.     implementation("androidx.compose.runtime:runtime-rxjava2:1.0.0-beta07")
  16.     // UI Tests
  17.     androidTestImplementation("androidx.compose.ui:ui-test-junit4:1.0.0-beta07")
  18. }
用 Compose 来重新写一下 账号登录 页面：
  1. class MainActivity : ComponentActivity() {
  3.     private val isLogInning = mutableStateOf(false)
  5.     override fun onCreate(savedInstanceState: Bundle?) {
  6.         super.onCreate(savedInstanceState)
  7.         setContent {
  8.             LoginScreen(isLogInning)
  9.         }
  10.     }
  12.     private fun login() {
  13.         isLogInning.value = true
  14.         Toast.makeText(this, "登录中", Toast.LENGTH_SHORT).show()
  15.     }
  17.     @Composable
  18.     fun LoginScreen(isLogInning: MutableState<Boolean> = mutableStateOf(false)) {
  19.         Column {
  20.             Image(
  21.                 painter = painterResource(R.drawable.titlebar_back_light),
  22.                 contentDescription = null,
  23.                 modifier = Modifier
  24.                     .height(40.dp)
  25.                     .width(15.dp)
  26.                     .absoluteOffset(10.dp)
  27.             )
  28.             Text(
  29.                 text = "登录TP-LINK ID",
  30.                 fontSize = 30.sp,
  31.                 fontWeight = FontWeight.Bold,
  32.                 modifier = Modifier.padding(10.dp)
  33.             )
  34.             TextField(
  35.                 value = TextFieldValue(),
  36.                 onValueChange = {},
  37.                 placeholder = { Text(text = "TP-LINK ID") },
  38.                 colors = TextFieldDefaults.textFieldColors(
  39.                     backgroundColor = Color.White,
  40.                     placeholderColor = Color.LightGray
  41.                 ),
  42.                 modifier = Modifier
  43.                     .fillMaxWidth()
  44.                     .padding(horizontal = 10.dp)
  45.             )
  46.             TextField(
  47.                 value = TextFieldValue(),
  48.                 onValueChange = {},
  49.                 placeholder = { Text(text = "密码") },
  50.                 colors = TextFieldDefaults.textFieldColors(
  51.                     backgroundColor = Color.White,
  52.                     placeholderColor = Color.LightGray
  53.                 ),
  54.                 modifier = Modifier
  55.                     .fillMaxWidth()
  56.                     .padding(horizontal = 10.dp)
  57.             )
  58.             Text(
  59.                 text = "忘记密码",
  60.                 fontSize = 16.sp,
  61.                 color = Color.Gray,
  62.                 textAlign = TextAlign.End,
  63.                 modifier = Modifier
  64.                     .fillMaxWidth()
  65.                     .padding(horizontal = 10.dp, vertical = 20.dp)
  66.             )
  67.             Button(
  68.                 content = {
  69.                     if (isLogInning.value)
  70.                         Text("登录中...")
  71.                     else
  72.                         Text("登录")
  73.                 },
  74.                 onClick = { login() },
  75.                 colors = ButtonDefaults.buttonColors(
  76.                     backgroundColor =
  77.                         if (isLogInning.value)
  78.                             Color(0xFFA6B7F7)
  79.                         else
  80.                             Color(0xFF3C65FC),
  81.                     contentColor = Color.White
  82.                 ),
  83.                 modifier = Modifier
  84.                     .height(65.dp)
  85.                     .fillMaxWidth()
  86.                     .padding(10.dp)
  87.             )
  88.             Row {
  89.                 Text(
  90.                     text = "新用户注册",
  91.                     fontSize = 16.sp,
  92.                     color = Color(0xFF3C65FC),
  93.                     modifier = Modifier.padding(10.dp)
  94.                 )
  95.                 Text(
  96.                     text = "暂不登录",
  97.                     fontSize = 16.sp,
  98.                     color = Color.Gray,
  99.                     modifier = Modifier
  100.                         .padding(10.dp)
  101.                         .offset(205.dp)
  102.                 )
  103.             }
  104.         }
  105.     }
  107.     @Preview(showBackground = true)
  108.     @Composable
  109.     fun DefaultPreview() {
  110.         LoginScreen()
  111.     }
  112. }

  • 简单使用 Column 做一个垂直线性布局

  • .dp 是 Int 的扩展函数，方便在代码中直接定义以 dp 为单位的数值

  • 运用 Modifier 的 offSet、padding、fillMaxWidth 等调整组件细节

  • 定义一个 MutableState 类型的 isLogInning 作为参数传入 Composable 函数 LoginScreen，让 Compose 自动订阅，自动根据这个值的变化而重组 LoginScreen 方法，更新UI显示

  • 当登录按钮点击时回调 onClick 方法，改变 isLogInning 的值

  • 当 isLogInning 的值改变时，能看到“登录”按钮自动改变了颜色，并变为“登录中...”，而我们并没有主动去命令它 setText 和 setBackground。这和 Data Binding 类似，但更加简单和灵活

标签： android Jetpack Compose
本文转载自: https://blog.csdn.net/qq_39312146/article/details/129341167
版权归原作者 金戈鐡馬 所有， 如有侵权，请联系我们删除。
登录后发布评论

“Android Compose 介绍与实践”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？