Compose 原理解析

Compose 的组件都是放在 setContent() 之后才能显示的，那必要先看看这个函数的作用。
先看 ComponentActivity 的扩展函数 setContent()：

1.     /**
2.      * 将给定的可组合项合成到给定的 Activity 中。[content] 将成为给定 Activity 的根视图。
3.      * 这大致相当于使用一个 [ComposeView] 调用 [ComponentActivity.setContentView]：
4.      *
5.      * setContentView(
6.      *   ComposeView(this).apply {
7.      *     setContent {
8.      *       MyComposableContent()
9.      *     }
10.      *   }
11.      * )
12.      *
13.      * @param parent 父组合（parent composition）的引用，用于协调组合更新的调度
14.      * @param content 一个声明 UI 内容的 @Composable 函数
15.      */
16.     public fun ComponentActivity.setContent(
17.         parent: CompositionContext? = null,
18.         content: @Composable () -> Unit
19.     ) {
20.         // 将 DecorView 中 id 为 android.R.id.content 的 ViewGroup 的第一个子组件转换成 ComposeView
21.         val existingComposeView = window.decorView
22.             .findViewById<ViewGroup>(android.R.id.content)
23.             .getChildAt(0) as? ComposeView
24.         
25.         if (existingComposeView != null) with(existingComposeView) {
26.             // 此处调用的是 ComposeView 的 setContent()，因此不会形成递归
27.             setParentCompositionContext(parent)
28.             setContent(content)
29.         } else ComposeView(this).apply {
30.             // Set content and parent **before** setContentView
31.             // to have ComposeView create the composition on attach
32.             setParentCompositionContext(parent)
33.             setContent(content)
34.             // Set the view tree owners before setting the content view so that the inflation process
35.             // and attach listeners will see them already present
36.             // AppCompat 1.3+ 版本之前由于 bug 不会自动设置 Owners，所以才在这里手动设置，属于修复 bug 的代码
37.             setOwners()
38.             // 设置当前的 ComposeView 为 Activity 的显示内容
39.             setContentView(this, DefaultActivityContentLayoutParams)
40.         }
41.     }

复制代码

setContent() 的重要任务是将用户写的 Compose 组件设置为 Activity 的显示内容。具体说来，就是将 Compose 组件封装进 ComposeView 中，然后用 ComponentActivity 的 setContentView() 设置当前 Activity 显示这个 ComposeView。在这个过程中，通过复用现有的 ComposeView —— existingComposeView 避免重复创建从而优化了性能。
关于 existingComposeView，是将 DecorView 中的 android.R.id.content 对应的 ViewGroup 的第一个子组件强转为 ComposeView。熟悉原生的 Activity 布局层级的朋侪们应该知道，android.R.id.content 对应的 ViewGroup 就是显示 Activity 的整体内容的，也就是显示原生的 XML 布局的。通过 getChildAt(0) 去拿它的第一个子组件，实际上拿到的就是 XML 布局中的根组件。那现在使用 Compose 没有 XML 了，以是就用被设置到 setContentView() 中的 this —— ComposeView 平替 XML 的根组件了。
初次调用 setContent() 的 existingComposeView 应该是 null，因为还没通过 setContentView() 设置要显示的内容，因此 getChildAt(0) 拿到的是 null。以是继续走后续代码，就会进入 else，创建一个新的 ComposeView 并将其传给 setContentView()，在这之后 existingComposeView 就是传入的 ComposeView 对象，也就不再是 null 了，后续如果发生配置变革（如屏幕旋转），重新创建 Activity 再次进入 setContent() 时，existingComposeView 可以被复用而无需重新创建 ComposeView。
接下来关注 if 和 else 中都调用了的两个函数 —— ComposeView 的 setParentCompositionContext() 和 setContent()。前者的作用是设置父组合上下文（用于管理 Composition 的作用域和生命周期），后者的作用是更新 Compose UI 内容，触发重组。
setParentCompositionContext() 是 ComposeView 的父类 AbstractComposeView 中的函数：

1.     /**
2.      * 设置应该作为此视图的组合（view's composition）的父级的 CompositionContext。如果 parent 为 null，
3.      * 则将自动从视图所依附到的窗口（the window the view is attached to）确定。
4.      */
5.     fun setParentCompositionContext(parent: CompositionContext?) {
6.         parentContext = parent
7.     }

复制代码

CompositionContext 用于毗连父组合与子组合，参数的 parent 是由 setContent() 的第一个参数传到这里的。由于调用 setContent() 时通常不会给 parent 参数赋值，因此它会取默认值 null，以是这里给 parentContext 赋的就是 null。至于 parentContext 属性的具体内容，我们暂时还用不到，因此暂时搁置。
然后我们再看 ComposeView 的 setContent()：

1.     private val content = mutableStateOf<(@Composable () -> Unit)?>(null)
2.    
3.     /**
4.      * 设置此视图的 Jetpack Compose UI 内容。当视图附加到窗口或调用 createComposition 时，将发生
5.      * 初始的组合（initial composition），以先到者为准。
6.      * @param content 就是在 Activity 的 onCreate() 中调用的 setContent() 的尾随 lambda 函数，页面内容
7.      */
8.     fun setContent(content: @Composable () -> Unit) {
9.         // 这个变量表示是否应该在附加到窗口时创建新的组合，后面会用到
10.         shouldCreateCompositionOnAttachedToWindow = true
11.         // 将参数传入的表示 UI 内容的 Composable 函数保存到 content 中
12.         this.content.value = content
13.         // 我们现在看的是 onCreate() 中的流程，还没到 onAttachedToWindow()，因此此时 isAttachedToWindow
14.         // 为 false，不会进入 if，但是 createComposition() 内的主要逻辑 ensureCompositionCreated()
15.         // 会在附加到 Window 的过程 onAttachedToWindow() 中被调用
16.         if (isAttachedToWindow) {
17.             createComposition()
18.         }
19.     }

复制代码

setContent() 流程走完了，并没有看出如何显示 Compose 的组件内容的。这是因为 ComposeView 作为一个 ViewGroup 的子类，也就是 View 的子类，它是在附加到窗口，也就是在重写 onAttachedToWindow() 的逻辑时，才必要显示 UI 内容。

1.     // AbstractComposeView 直接继承 ViewGroup 并重写了 onAttachedToWindow()
2.     override fun onAttachedToWindow() {
3.         super.onAttachedToWindow()
5.         // 记录与当前页面绑定的 Window
6.         previousAttachedWindowToken = windowToken
7.         
8.         if (shouldCreateCompositionOnAttachedToWindow) {
9.             ensureCompositionCreated()
10.         }
11.     }

复制代码

由于 shouldCreateCompositionOnAttachedToWindow 在 onCreate() 内调用 setContent() 的流程中，执行到 ComposeView 的 setContent() 时已经被设为 true 了，以是这里可以进入 if 执行 ensureCompositionCreated()：

1.     private fun ensureCompositionCreated() {
2.         // 还没开始组合过程，也就不会有组合结果，再到当前流程中 composition 为 null
3.         if (composition == null) {
4.             try {
5.                 // 标记，是否正在创建组合
6.                 creatingComposition = true
7.                 // 进行组合过程并返回组合结果
8.                 composition = setContent(resolveParentCompositionContext()) {
9.                     Content()
10.                 }
11.             } finally {
12.                 // 创建完组合，清除标记
13.                 creatingComposition = false
14.             }
15.         }
16.     }

复制代码

这里调用的是父类 AbstractComposeView 的 setContent 函数（双参），而不是此前看过的 ComposeView 的 setContent 函数（单参，并且父类中也没办法调用子类的函数，除非就是子类对象调用了一个父子都有的函数）：

1. internal fun AbstractComposeView.setContent(
2.     parent: CompositionContext,
3.     content: @Composable () -> Unit
4. ): Composition {
5.     GlobalSnapshotManager.ensureStarted()
6.     val composeView =
7.         if (childCount > 0) {
8.             getChildAt(0) as? AndroidComposeView
9.         } else {
10.             removeAllViews(); null
11.         } ?: AndroidComposeView(context).also { addView(it.view, DefaultLayoutParams) }
12.     return doSetContent(composeView, parent, content)
13. }

复制代码

我们先看 ensureCompositionCreated() 给 setContent() 传的实参 resolveParentCompositionContext()：

1.     private fun resolveParentCompositionContext() = parentContext
2.         ?: findViewTreeCompositionContext()?.cacheIfAlive()
3.         ?: cachedViewTreeCompositionContext?.get()?.takeIf { it.isAlive }
4.         ?: windowRecomposer.cacheIfAlive()

复制代码

parentContext 在看 ComponentActivity.setContent() 的流程时出现过，在 setParentCompositionContext() 内被赋值，是 null。
再看 findViewTreeCompositionContext()：

1. /**
2. * 返回此视图层级结构中当前节点的父组合上下文（parent CompositionContext），如果未找到则返回 null。
3. * 如需获取或设置特定视图的父组合上下文，请参阅 compositionContext。
4. */
5. fun View.findViewTreeCompositionContext(): CompositionContext? {
6.     var found: CompositionContext? = compositionContext
7.     if (found != null) return found
8.     var parent: ViewParent? = parent
9.     // 一直向上找父组件的 CompositionContext
10.     while (found == null && parent is View) {
11.         found = parent.compositionContext
12.         parent = parent.getParent()
13.     }
14.     return found
15. }

复制代码

那这个函数的返回值到底如何呢？取决于被查找的 View 的 compositionContext 属性：

1. /**
2. * The [CompositionContext] that should be used as a parent for compositions at or below
3. * this view in the hierarchy. Set to non-`null` to provide a [CompositionContext]
4. * for compositions created by child views, or `null` to fall back to any [CompositionContext]
5. * provided by ancestor views.
6. *
7. */
8. var View.compositionContext: CompositionContext?
9.     get() = getTag(R.id.androidx_compose_ui_view_composition_context) as? CompositionContext
10.     set(value) {
11.         setTag(R.id.androidx_compose_ui_view_composition_context, value)
12.     }

复制代码

在没有给 View 设置 id 为 androidx_compose_ui_view_composition_context 的 Tag 的情况下，compositionContext 属性为 null。通常情况下，我们都不会设置该 id 的 Tag，以是一样平常为 null。
继续向后，假如 findViewTreeCompositionContext() 找到了 CompositionContext，那么就执行 cacheIfAlive()：

1.     /**
2.      * 如果这个 CompositionContext 处于活跃状态，将它缓存到 cachedViewTreeCompositionContext 中同时
3.      * 返回自身
4.      */
5.     private fun CompositionContext.cacheIfAlive(): CompositionContext = also { context ->
6.         context.takeIf { it.isAlive }
7.             ?.let { cachedViewTreeCompositionContext = WeakReference(it) }
8.     }

复制代码

接下来就是去取缓存 cachedViewTreeCompositionContext，在这个缓存的 CompositionContext 处于活跃状态时返回它。
末了查抄 windowRecomposer 并在它处于活跃状态时缓存它，它也是 View 的扩展属性：

1. /**
2. * Get or lazily create a [Recomposer] for this view's window. The view must be attached
3. * to a window with the [LifecycleOwner] returned by [findViewTreeLifecycleOwner] registered at
4. * the root to access this property.
5. */
6. @OptIn(InternalComposeUiApi::class)
7. internal val View.windowRecomposer: Recomposer
8.     get() {
9.         check(isAttachedToWindow) {
10.             "Cannot locate windowRecomposer; View $this is not attached to a window"
11.         }
12.         val rootView = contentChild
13.         return when (val rootParentRef = rootView.compositionContext) {
14.             null -> WindowRecomposerPolicy.createAndInstallWindowRecomposer(rootView)
15.             is Recomposer -> rootParentRef
16.             else -> error("root viewTreeParentCompositionContext is not a Recomposer")
17.         }
18.     }

复制代码

先看 contentChild 是什么：

1. /**
2. * Find the "content child" for this view. The content child is the view that is either
3. * a direct child of the view with id [android.R.id.content] (and was therefore set as a
4. * content view into an activity or dialog window) or the root view of the window.
5. *
6. * This is used as opposed to [View.getRootView] as the Android framework can reuse an activity
7. * window's decor views across activity recreation events. Since a window recomposer is associated
8. * with the lifecycle of the host activity, we want that recomposer to shut down and create a new
9. * one for the new activity instance.
10. */
11. private val View.contentChild: View
12.     get() {
13.         var self: View = this
14.         var parent: ViewParent? = self.parent
15.         while (parent is View) {
16.             if (parent.id == android.R.id.content) return self
17.             self = parent
18.             parent = self.parent
19.         }
20.         return self
21.     }

复制代码

就是 android.R.id.content 谁人 ViewGroup 的子组件，也就是我们在 ComponentActivity.setContent() 中看到的谁人 ComposeView —— existingComposeView。
将 contentChild 属性赋值给 rootView 后，根据 rootView.compositionContext 决定哪一条分支，由于前面已经提到过，现在所有 View 的 CompositionContext 都是 null，因此要调用 WindowRecomposerPolicy.createAndInstallWindowRecomposer()：

1. @InternalComposeUiApi
2. object WindowRecomposerPolicy {
4.     private val factory = AtomicReference<WindowRecomposerFactory>(
5.         WindowRecomposerFactory.LifecycleAware
6.     )
8.     internal fun createAndInstallWindowRecomposer(rootView: View): Recomposer {
9.         val newRecomposer = factory.get().createRecomposer(rootView)
10.         rootView.compositionContext = newRecomposer
12.         // 界面退出后做清理收尾工作的代码，省略...
14.         return newRecomposer
15.     }
16. }

复制代码

很明显，这个函数是创建了一个 CompositionContext 对象 newRecomposer，并在返回它之前赋值给 rootView 的 compositionContext 属性。到这里，rootView 的 compositionContext 终于不为空了。
下面我们要看一下 createRecomposer() 是如何创建 CompositionContext 的，点进函数源码发现是 WindowRecomposerFactory 接口的抽象函数：

1. /**
2. * A factory for creating an Android window-scoped Recomposer. See createRecomposer.
3. */
4. @InternalComposeUiApi
5. fun interface WindowRecomposerFactory {
6.     /**
7.      * Get a [Recomposer] for the window where [windowRootView] is at the root of the window's
8.      * [View] hierarchy. The factory is responsible for establishing a policy for
9.      * [shutting down][Recomposer.cancel] the returned [Recomposer]. [windowRootView] will
10.      * hold a hard reference to the returned [Recomposer] until it [joins][Recomposer.join]
11.      * after shutting down.
12.      */
13.     fun createRecomposer(windowRootView: View): Recomposer
15.     companion object {
16.         /**
17.          * A [WindowRecomposerFactory] that creates **lifecycle-aware** [Recomposer]s.
18.          *
19.          * Returned [Recomposer]s will be bound to the
20.          * [LifecycleOwner] returned by [findViewTreeLifecycleOwner] registered
21.          * at the [root][View.getRootView] of the view hierarchy and run
22.          * [recomposition][Recomposer.runRecomposeAndApplyChanges] and composition effects on the
23.          * [AndroidUiDispatcher.CurrentThread] for the window's UI thread. The associated
24.          * [MonotonicFrameClock] will only produce frames when the [Lifecycle] is at least
25.          * [Lifecycle.State.STARTED], causing animations and other uses of [MonotonicFrameClock]
26.          * APIs to suspend until a **visible** frame will be produced.
27.          */
28.         @OptIn(ExperimentalComposeUiApi::class)
29.         val LifecycleAware: WindowRecomposerFactory = WindowRecomposerFactory { rootView ->
30.             rootView.createLifecycleAwareWindowRecomposer()
31.         }
32.     }
33. }

复制代码

此时就要看 factory.get() 拿到的是什么对象，通过 factory 的定义可以确定 get() 得到的是一个 LifecycleAware，createLifecycleAwareWindowRecomposer() 会返回一个已经准备好（界面刷新）的工具 Recomposer（代码很复杂，这里不贴）。
以是，resolveParentCompositionContext() 终极返回的是一个用于等候和准备刷新的工具 Recomposer。
再看 setContent() 的第二个参数，传的是 AbstractComposeView 的抽象函数 Content()：

1.     @Composable
2.     @UiComposable
3.     abstract fun Content()

复制代码

在它的子类 ComposeView 中的实现就是调用此前保存在 content 属性中的函数：

1.     private val content = mutableStateOf<(@Composable () -> Unit)?>(null)
3.     @Composable
4.     override fun Content() {
5.         content.value?.invoke()
6.     }

复制代码

把 Content() 放入 lambda 表达式中作为 setContent() 的第二个参数，何时执行就要看该函数的具体内容了：

1. /** * Composes the given composable into the given view. * * The new composition can be logically "linked" to an existing one, by providing a * [parent]. This will ensure that invalidations and CompositionLocals will flow through * the two compositions as if they were not separate. * * Note that this [ViewGroup] should have an unique id for the saved instance state mechanism to * be able to save and restore the values used within the composition. See [View.setId]. * * @param parent The [Recomposer] or parent composition reference. * @param content Composable that will be the content of the view. */internal fun AbstractComposeView.setContent(
2.     parent: CompositionContext,
3.     content: @Composable () -> Unit
4. ): Composition {
5.     GlobalSnapshotManager.ensureStarted()
6.     val composeView =
7.         if (childCount > 0) {
8.             getChildAt(0) as? AndroidComposeView
9.         } else {
10.             removeAllViews(); null
11.         } ?: AndroidComposeView(context).also { addView(it.view, DefaultLayoutParams) }
12.     return doSetContent(composeView, parent, content)
13. }

复制代码

GlobalSnapshotManager.ensureStarted()：

1. /**
2. * Platform-specific mechanism for starting a monitor of global snapshot state writes
3. * in order to schedule the periodic dispatch of snapshot apply notifications.
4. * This process should remain platform-specific; it is tied to the threading and update model of
5. * a particular platform and framework target.
6. *
7. * Composition bootstrapping mechanisms for a particular platform/framework should call
8. * [ensureStarted] during setup to initialize periodic global snapshot notifications.
9. * For Android, these notifications are always sent on [AndroidUiDispatcher.Main]. Other platforms
10. * may establish different policies for these notifications.
11. */
12. internal object GlobalSnapshotManager {
13.     private val started = AtomicBoolean(false)
15.     fun ensureStarted() {
16.         if (started.compareAndSet(false, true)) {
17.             val channel = Channel<Unit>(Channel.CONFLATED)
18.             CoroutineScope(AndroidUiDispatcher.Main).launch {
19.                 // 订阅通知
20.                 channel.consumeEach {
21.                     // 通知回调，收到通知后的行为
22.                     Snapshot.sendApplyNotifications()
23.                 }
24.             }
25.             Snapshot.registerGlobalWriteObserver {
26.                 // 发送通知
27.                 channel.trySend(Unit)
28.             }
29.         }
30.     }
31. }

复制代码

关照回调的行为是去执行 Snapshot.sendApplyNotifications()，重要作用是关照更新，这是一个很复杂的过程。Snapshot 系统是用来管理 Compose 组件依赖的变量的，它会在这些变量发生变革时自动感知到这些变量的变革，并把这些变革应用到界面中，保证使用这些变量最新的值去及时的刷新界面。此外，Snapshot 的复杂还因为它支持了多线程，可以在多个线程中去更新 Compose 组件依赖的变量，而原生只能在主线程中更新 UI。
sendApplyNotifications() 只说关键代码：

1. sealed class Snapshot {
2.     companion object {
3.         fun sendApplyNotifications() {
4.             val changes = sync {
5.                 currentGlobalSnapshot.get().modified?.isNotEmpty() == true
6.             }
7.             if (changes)
8.                 advanceGlobalSnapshot()
9.         }
10.     }
11. }

复制代码

当组件依赖的变量有变革时，调用 advanceGlobalSnapshot()：

1. private fun advanceGlobalSnapshot() = advanceGlobalSnapshot { }
3. private fun <T> advanceGlobalSnapshot(block: (invalid: SnapshotIdSet) -> T): T {
4.     var previousGlobalSnapshot = snapshotInitializer as GlobalSnapshot
5.     val result = sync {
6.         previousGlobalSnapshot = currentGlobalSnapshot.get()
7.         takeNewGlobalSnapshot(previousGlobalSnapshot, block)
8.     }
10.     // If the previous global snapshot had any modified states then notify the registered apply
11.     // observers.
12.     val modified = previousGlobalSnapshot.modified
13.     if (modified != null) {
14.         val observers: List<(Set<Any>, Snapshot) -> Unit> = sync { applyObservers.toMutableList() }
15.         // 把界面中用到的发生变化的变量进行新值的应用，确切地说，把界面中使用到的发生变量变化的部分标记为失效，这样
16.         // 失效的部分就会发生重组，然后再发生布局和绘制，完整整个页面的刷新。只标记发生变化的部分是为了节省性能，只刷新
17.         // 应该刷新的地方保证耗时最短，刷新效率最高
18.         observers.fastForEach { observer ->
19.             observer(modified, previousGlobalSnapshot)
20.         }
21.     }
23.     sync {
24.         modified?.forEach(::overwriteUnusedRecordsLocked)
25.     }
27.     return result
28. }

复制代码

applyObservers 是在 被添加的：

1.         // 还是在 Snapshot 的伴生对象中
2.         fun registerApplyObserver(observer: (Set<Any>, Snapshot) -> Unit): ObserverHandle {
3.             // Ensure observer does not see changes before this call.
4.             advanceGlobalSnapshot(emptyLambda)
6.             sync {
7.                 // 向 applyObservers 添加监听者
8.                 applyObservers.add(observer)
9.             }
10.             return ObserverHandle {
11.                 sync {
12.                     applyObservers.remove(observer)
13.                 }
14.             }
15.         }

复制代码

在 Recomposer 的 recompositionRunner() 中调用了 registerApplyObserver()：

1.     private suspend fun recompositionRunner(
2.         block: suspend CoroutineScope.(parentFrameClock: MonotonicFrameClock) -> Unit
3.     ) {
4.         val parentFrameClock = coroutineContext.monotonicFrameClock
5.         withContext(broadcastFrameClock) {
6.             // Enforce mutual exclusion of callers; register self as current runner
7.             val callingJob = coroutineContext.job
8.             registerRunnerJob(callingJob)
10.             // Observe snapshot changes and propagate them to known composers only from
11.             // this caller's dispatcher, never working with the same composer in parallel.
12.             // unregisterApplyObserver is called as part of the big finally below
13.             // 注册回调，收到回调之后，通过 resume() 开始执行重组工作
14.             val unregisterApplyObserver = Snapshot.registerApplyObserver { changed, _ ->
15.                 synchronized(stateLock) {
16.                     if (_state.value >= State.Idle) {
17.                         snapshotInvalidations.addAll(changed)
18.                         deriveStateLocked()
19.                     } else null
20.                 }?.resume(Unit)
21.             }
23.             addRunning(recomposerInfo)
25.             try {
26.                 // Invalidate all registered composers when we start since we weren't observing
27.                 // snapshot changes on their behalf. Assume anything could have changed.
28.                 synchronized(stateLock) {
29.                     knownCompositions.fastForEach { it.invalidateAll() }
30.                     // Don't need to deriveStateLocked here; invalidate will do it if needed.
31.                 }
33.                 coroutineScope {
34.                     block(parentFrameClock)
35.                 }
36.             } finally {
37.                 unregisterApplyObserver.dispose()
38.                 synchronized(stateLock) {
39.                     if (runnerJob === callingJob) {
40.                         runnerJob = null
41.                     }
42.                     deriveStateLocked()
43.                 }
44.                 removeRunning(recomposerInfo)
45.             }
46.         }
47.     }

复制代码

回到 sendApplyNotifications()，该函数就是触发重组的。然后再往下看 registerGlobalWriteObserver()，该函数是对变量写行为的监听，当变量有变革时就会执行一次后面的 lambda，通过 channel 发送一次关照。每次发关照，都会让接收端执行 consumeEach() 后的 lambda，也就是触发重组。这里使用 Channel 的特性对重组触发次数做了优化，一帧中只会触发一或两次重组，从而避免导致高频修改引发高频刷新的性能题目。
再看 AbstractComposeView 的第二部门，生成一个 AndroidComposeView 并将其添加到视图中，形成一个 ComposeView 包罗 AndroidComposeView 的布局。实际上，AndroidComposeView 才是负责显示与触摸反馈（真正干活的）的谁人 View。
末了一部门是 doSetContent()：

1. private fun doSetContent(
2.     owner: AndroidComposeView,
3.     parent: CompositionContext,
4.     content: @Composable () -> Unit
5. ): Composition {
6.     ...
7.     // 创建一个 Composition 对象，实际类型为 CompositionImpl
8.     val original = Composition(UiApplier(owner.root), parent)
9.     // 先通过 Tag 去拿 WrappedComposition，如果拿到的为空则自行创建一个
10.     val wrapped = owner.view.getTag(R.id.wrapped_composition_tag)
11.         as? WrappedComposition
12.         ?: WrappedComposition(owner, original).also {
13.             owner.view.setTag(R.id.wrapped_composition_tag, it)
14.         }
15.     wrapped.setContent(content)
16.     return wrapped
17. }

复制代码

调用 WrappedComposition 的 setContent()：

1.     override fun setContent(content: @Composable () -> Unit) {
2.         // 约等于对 onAttachedToWindow() 的监听
3.         owner.setOnViewTreeOwnersAvailable {
4.             if (!disposed) {
5.                 val lifecycle = it.lifecycleOwner.lifecycle
6.                 lastContent = content
7.                 // 第一次进入 if，第二次进入 else if
8.                 if (addedToLifecycle == null) {
9.                     addedToLifecycle = lifecycle
10.                     // this will call ON_CREATE synchronously if we already created
11.                     lifecycle.addObserver(this)
12.                 } else if (lifecycle.currentState.isAtLeast(Lifecycle.State.CREATED)) {
13.                     // original 是 CompositionImpl
14.                     original.setContent {
15.    
16.                         @Suppress("UNCHECKED_CAST")
17.                         val inspectionTable =
18.                             owner.getTag(R.id.inspection_slot_table_set) as?
19.                                     MutableSet<CompositionData>
20.                                 ?: (owner.parent as? View)?.getTag(R.id.inspection_slot_table_set)
21.                                         as? MutableSet<CompositionData>
22.                         if (inspectionTable != null) {
23.                             inspectionTable.add(currentComposer.compositionData)
24.                             currentComposer.collectParameterInformation()
25.                         }
26.    
27.                         LaunchedEffect(owner) { owner.keyboardVisibilityEventLoop() }
28.                         LaunchedEffect(owner) { owner.boundsUpdatesEventLoop() }
29.    
30.                         CompositionLocalProvider(LocalInspectionTables provides inspectionTable) {
31.                             ProvideAndroidCompositionLocals(owner, content)
32.                         }
33.                     }
34.                 }
35.             }
36.         }
37.     }

复制代码

看 CompositionImpl 的 setContent()：

1.     override fun setContent(content: @Composable () -> Unit) {
2.         check(!disposed) { "The composition is disposed" }
3.         // 又把最外面的 setContent() 后的 lambda 保存了一次
4.         this.composable = content
5.         // parent 类型是 CompositionContext，实际上是前面的 Recomposer，用于刷新的，不是用于初始化的，在 doSetContent()
6.         // 内创建 Composition 时作为第二个参数传入
7.         parent.composeInitial(this, composable)
8.     }

复制代码

既然 parent 是 Recomposer，那么自然就要去看 Recomposer 的 composeInitial()：

1.     internal override fun composeInitial(
2.         composition: ControlledComposition,
3.         content: @Composable () -> Unit
4.     ) {
5.         val composerWasComposing = composition.isComposing
6.         try {
7.             composing(composition, null) {
8.                 composition.composeContent(content)
9.             }
10.         } catch (e: Exception) {
11.             processCompositionError(e, composition, recoverable = true)
12.             return
13.         }
15.         // TODO(b/143755743)
16.         if (!composerWasComposing) {
17.             Snapshot.notifyObjectsInitialized()
18.         }
20.         synchronized(stateLock) {
21.             if (_state.value > State.ShuttingDown) {
22.                 if (composition !in knownCompositions) {
23.                     knownCompositions += composition
24.                 }
25.             }
26.         }
28.         try {
29.             performInitialMovableContentInserts(composition)
30.         } catch (e: Exception) {
31.             processCompositionError(e, composition, recoverable = true)
32.             return
33.         }
35.         try {
36.             composition.applyChanges()
37.             composition.applyLateChanges()
38.         } catch (e: Exception) {
39.             processCompositionError(e)
40.             return
41.         }
43.         if (!composerWasComposing) {
44.             // Ensure that any state objects created during applyChanges are seen as changed
45.             // if modified after this call.
46.             Snapshot.notifyObjectsInitialized()
47.         }
48.     }

复制代码

在 composing() 的尾随 lambda 中执行 composition.composeContent()，这样会取执行 CompositionImpl.composeContent() -> ComposerImpl.composeContent() -> ComposerImpl.doCompose()：

1.     private fun doCompose(
2.         invalidationsRequested: IdentityArrayMap<RecomposeScopeImpl, IdentityArraySet<Any>?>,
3.         content: (@Composable () -> Unit)?
4.     ) {
5.         runtimeCheck(!isComposing) { "Reentrant composition is not supported" }
6.         trace("Compose:recompose") {
7.             snapshot = currentSnapshot()
8.             compositionToken = snapshot.id
9.             providerUpdates.clear()
10.             invalidationsRequested.forEach { scope, set ->
11.                 val location = scope.anchor?.location ?: return
12.                 invalidations.add(Invalidation(scope, location, set))
13.             }
14.             invalidations.sortBy { it.location }
15.             nodeIndex = 0
16.             var complete = false
17.             isComposing = true
18.             try {
19.                 startRoot()
20.    
21.                 // vv Experimental for forced
22.                 @Suppress("UNCHECKED_CAST")
23.                 val savedContent = nextSlot()
24.                 if (savedContent !== content && content != null) {
25.                     updateValue(content as Any?)
26.                 }
27.                 // ^^ Experimental for forced
28.    
29.                 // Ignore reads of derivedStateOf recalculations
30.                 observeDerivedStateRecalculations(
31.                     start = {
32.                         childrenComposing++
33.                     },
34.                     done = {
35.                         childrenComposing--
36.                     },
37.                 ) {
38.                     if (content != null) {
39.                         startGroup(invocationKey, invocation)
40.                         // 关键代码
41.                         invokeComposable(this, content)
42.                         endGroup()
43.                     } else if (
44.                         (forciblyRecompose || providersInvalid) &&
45.                         savedContent != null &&
46.                         savedContent != Composer.Empty
47.                     ) {
48.                         startGroup(invocationKey, invocation)
49.                         @Suppress("UNCHECKED_CAST")
50.                         invokeComposable(this, savedContent as @Composable () -> Unit)
51.                         endGroup()
52.                     } else {
53.                         skipCurrentGroup()
54.                     }
55.                 }
56.                 endRoot()
57.                 complete = true
58.             } finally {
59.                 isComposing = false
60.                 invalidations.clear()
61.                 if (!complete) abortRoot()
62.             }
63.         }
64.     }

复制代码

invokeComposable() 执行的是 ActualJvm.jvm.kt 中的函数：

1. internal actual fun invokeComposable(composer: Composer, composable: @Composable () -> Unit) {
2.     @Suppress("UNCHECKED_CAST")
3.     val realFn = composable as Function2<Composer, Int, Unit>
4.     realFn(composer, 1)
5. }

复制代码

composable 参数就是 setContent() 的尾随 lambda 指定的 Compose 组件内容，它被强转为 Function2，是因为 Compose 编译器插件会对所有 @Composable 函数添加两个参数。末了调用转换成 Function2 的 realFn()，也就是执行 lambda 内的内容了。
以上就是 setContent() 的内容，它并没有对界面的显示做任何工作，它所做的就是摆设好各种监听器，以便变量发生变革时触发界面刷新。真正负责显示的是各个组件 Composable 函数内的通用函数 Layout()：

1. @UiComposable
2. @Composable inline fun Layout(
3.     content: @Composable @UiComposable () -> Unit,
4.     modifier: Modifier = Modifier,
5.     measurePolicy: MeasurePolicy
6. ) {
7.     val density = LocalDensity.current
8.     val layoutDirection = LocalLayoutDirection.current
9.     val viewConfiguration = LocalViewConfiguration.current
10.     ReusableComposeNode<ComposeUiNode, Applier<Any>>(
11.         factory = ComposeUiNode.Constructor,
12.         // 这里预先设置要做的处理策略
13.         update = {
14.             set(measurePolicy, ComposeUiNode.SetMeasurePolicy)
15.             set(density, ComposeUiNode.SetDensity)
16.             set(layoutDirection, ComposeUiNode.SetLayoutDirection)
17.             set(viewConfiguration, ComposeUiNode.SetViewConfiguration)
18.         },
19.         skippableUpdate = materializerOf(modifier),
20.         content = content
21.     )
22. }

复制代码

1. @Composable @ExplicitGroupsComposable
2. inline fun <T, reified E : Applier<*>> ReusableComposeNode(
3.     noinline factory: () -> T,
4.     update: @DisallowComposableCalls Updater<T>.() -> Unit,
5.     noinline skippableUpdate: @Composable SkippableUpdater<T>.() -> Unit,
6.     content: @Composable () -> Unit
7. ) {
8.     if (currentComposer.applier !is E) invalidApplier()
9.     currentComposer.startReusableNode()
10.     if (currentComposer.inserting) {
11.         // 创建 LayoutNode 节点
12.         currentComposer.createNode(factory)
13.     } else {
14.         currentComposer.useNode()
15.     }
16.     // 更新 LayoutNode 节点
17.     Updater<T>(currentComposer).update()
18.     SkippableUpdater<T>(currentComposer).skippableUpdate()
19.     currentComposer.startReplaceableGroup(0x7ab4aae9)
20.     content()
21.     currentComposer.endReplaceableGroup()
22.     currentComposer.endNode()
23. }

复制代码

1.     // ComposerImpl:
2.     @Suppress("UNUSED")
3.     override fun <T> createNode(factory: () -> T) {
4.         validateNodeExpected()
5.         runtimeCheck(inserting) { "createNode() can only be called when inserting" }
6.         val insertIndex = nodeIndexStack.peek()
7.         val groupAnchor = writer.anchor(writer.parent)
8.         groupNodeCount++
9.         recordFixup { applier, slots, _ ->
10.             @Suppress("UNCHECKED_CAST")
11.             // 创建 LayoutNode，看参数来源，是 ReusableComposeNode() 的 factory 参数
12.             val node = factory()
13.             // LayoutNode 装进 SlotTable 中
14.             slots.updateNode(groupAnchor, node)
15.             @Suppress("UNCHECKED_CAST") val nodeApplier = applier as Applier<T>
16.             nodeApplier.insertTopDown(insertIndex, node)
17.             applier.down(node)
18.         }
19.         recordInsertUpFixup { applier, slots, _ ->
20.             @Suppress("UNCHECKED_CAST")
21.             val nodeToInsert = slots.node(groupAnchor)
22.             applier.up()
23.             @Suppress("UNCHECKED_CAST") val nodeApplier = applier as Applier<Any?>
24.             // 将 LayoutNode 节点插进 LayoutNode 树中（树是组合的最终结果）
25.             nodeApplier.insertBottomUp(insertIndex, nodeToInsert)
26.         }
27.     }

复制代码

SlotTable 是一种数据布局，用于存储 Compose 的 LayoutNode 树以及这个树上用到的变量。在显示界面时，是用不到 SlotTable 的。它在最底层是用一维数组实现了 LayoutNode 树的存储，而对于各个嵌套的 LayoutNode 之间是使用链表将它们毗连起来的。使用它的目的是为了提拔性能。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。