understanding compose

types

• internal class ComposerImpl: Composer
  • the only implementor of & implements only the Composer interface
  • the output paramter type injected into every @Composable function at compile time
  • private var reusing = false
  • private var reusingGroup = -1
• public abstract class CompositionContext
  • a role to compose as; valid for a lifetime & shared by every reference site
  • public val effectCoroutineContext: CoroutineContext; effects for the composition (eg LaunchedEffect)

  • internal abstract fun composeInitial(
        composition: ControlledComposition,
        content: @Composable () -> Unit,
    )

  • public class Recomposer; the context (role) of/referenced by a root composition
  • internal inner class CompositionContextImpl
    • each instance tied to the instance of the outer class (ComposerImpl) that constructed it
    • private val parentContext: CompositionContext; contexts (roles) are organised into a tree
      • CompositionContextImpl::composeInitial delegates to parentContext
• internal class RecomposeScopeImpl
  • internal var owner: RecomposeScopeOwner?
  • the only implementor of
    • public interface RecomposeScope
      • a region of code that’s invalidated when a state read inside it is outdated
      • public fun invalidate()
        • should invalidate itself and request to be recomposed by the Composer
        • RecomposeScopeImpl::invalidate calls this.owner?.invalidate(this, null)
    • public interface ScopeUpdateScope
    • public interface IdentifiableRecomposeScope
• public interface Composition
  • public fun dispose(); should free resources and invalidate itself for further use
  • public fun setContent(content: @Composable () -> Unit); should update (calculate and apply changes to) itself as described by the content.
  • public val hasInvalidations: Boolean; should be true if RecomposeScope::invalidate has been called in the composition
  • public val isDisposed: Boolean; should be true if the dispose method has been called
• private class WrappedComposition: Composition, LifecycleEventObserver, CompositionServices
  • val owner: AndroidComposeView; owned by an AndroidComposeView: ViewGroup
  • val original: Composition; the composition this: WrappedComposition wraps → intercepts & handles access
  • private var lastContent: @Composable () -> Unit = {}
  • private var addedToLifecycle: Lifecycle? = null
    • assigned a Lifecycle in setContent if available
    • calls on it .addObserver(this); observed by this: LifecycleEventObserver
      • Lifecycle.Event.ON_DESTROY → this.dispose()
      • Lifecycle.Event.ON_CREATE → if !this.disposed, calls this.setContent(this.lastContent)
      • addObserver brings this to the current state of this.addedToLifecycle
  • override fun setContent(content: @Composable () -> Unit); assigns content to this.lastContent + arranges a call to original::setContent
• internal class CompositionImpl
  • private var state = RUNNING
    • assigned private const val RUNNING = 0 in CompositionImpl::clearDeactivated
    • assigned private const val DEACTIVATED = 1 in CompositionImpl::deactivate
    • assigned private const val INCONSISTENT = 2 in CompositionImpl::pausedCompositionFinished conditionally
    • assigned private const val DISPOSED = 3 in CompositionImpl::dispose
  • the only implementor of
    • public sealed interface ControlledComposition: Composition
      • public val isComposing: Boolean; implemented by this: CompositionImpl to return this.composer.isComposing
    • public sealed interface ReusableComposition: Composition
    • public sealed interface PausableComposition: ReusableComposition
    • public interface ObservableComposition; disjoint interface
    • internal interface RecomposeScopeOwner
• public abstract class ViewGroup
  • extends android.view.View; a tree (node) of interactive UI elements
  • View::dispatchAttachedToWindow called on this: ViewGroup then on each in this.{mChildren, mTransientViews}
    • View::isAttachedToWindow is true for the receiver; not yet for its children
    • View::onAttachedToWindow called on the receiver; its children then traversed and attached depth first
  • internal class AndroidComposeView
    • implements DefaultLifecycleObserver: LifecycleObserver
    • the only implementor of Owner; the connection from compose to the android view system
      • val root: LayoutNode; the root of the composition tree that (this: AndroidComposeView) as Owner owns/hosts
    • defines a nested ViewTreeOwners class unrelated by inheritance
      • val lifecycleOwner: LifecycleOwner
      • val savedStateRegistryOwner: SavedStateRegistryOwner
      • val viewModelStoreOwner: ViewModelStoreOwner?
    • private var _viewTreeOwners: ViewTreeOwners? by mutableStateOf(null)
    • val viewTreeOwners: ViewTreeOwners? by derivedStateOf { _viewTreeOwners }
    • override fun onAttachedToWindow() instantiates ViewTreeOwners and assigns it to this._viewTreeOwners with
      • this.findViewTreeLifecycleOwner(): LifecycleOwner?
        • .lifecycle.addObserver(this) called on it
      • this.findViewTreeSavedStateRegistryOwner(): SavedStateRegistryOwner?
      • this.findViewTreeViewModelStoreOwner(): ViewModelStoreOwner?
    • private var onViewTreeOwnersAvailable: ((ViewTreeOwners) -> Unit)? = null
      • called (passed this.viewTreeOwners) if !null then cleared by onAttachedToWindow
  • abstract class AbstractComposeView
    • private var composition: Composition? = null
      • this: AbstractComposeView is to have an AndroidComposeView child
      • this references the composition backed by the Owner::root tree owned by the child view
    • private fun ensureCompositionCreated(); assigns a Composition to this.composition if null
    • override fun onAttachedToWindow(); calls this.ensureCompositionCreated()
    • private var cachedViewTreeCompositionContext: WeakReference<CompositionContext>? = null
    • private var parentContext: CompositionContext? = null; when assigned a !null value, the setter
      • assigns this.cachedViewTreeCompositionContext = null
      • if this.composition != null, calls .dispose() on & assigns null to it
        • if this.isAttachedToWindow, calls this.ensureCompositionCreated()
    • fun createComposition()
      • calls this.ensureCompositionCreated()
      • called by ComposeView::setContent if this.isAttachedToWindow
    • abstract fun Content()
      • the compose UI (@Composable) of this view
      • initially called when attached to a window or this.createComposition() is called
    • class ComposeView
      • private val content: MutableState<(@Composable () -> Unit)?> = mutableStateOf(null)
      • override fun Content(); calls this.content.value?.invoke()
• public abstract class AbstractApplier<T>
  • implements Applier<T>; manipulates a tree of T nodes
    • val current: T; the target of operations
  • override var current: T; protected set; the subtype supports traversing the tree
  • val root: T; references the same object throughout the lifetime of the applier
  • private val stack = Stack(); a FIFO stack that keeps track of the nodes it’s visited
  • internal class UiApplier: AbstractApplier<LayoutNode>
    • operates on (manipulates & traverses) a LayoutNode tree (eg (AndroidComposeView as Owner)::root: LayoutNode)

ComponentActivity::setContent

public fun ComponentActivity.setContent(
    parent: CompositionContext? = null,
    content: @Composable () -> Unit
)

• ‘composes’ the content into this: ComponentActivity; populates the activity window view tree

1. 1.
   obtains a ComposeView to upsert either from this.window.decorView or by constructing one
2. 2.
   updates the ComposeView
   1. 1.
      on the ComposeView, calls .setParentCompositionContext(parent); sets this.parentContext = parent
      1. 1.
         the setter might call this.ensureCompositionCreated()
   2. 2.
      on the ComposeView, calls .setContent(content)
      1. 1.
         sets this.content.value = content
      2. 2.
         if this.isAttachedToWindow, calls this.createComposition() (→ this.ensureCompositionCreated())
3. 3.
   inserts the ComposeView if it’s new
   1. 1.
      on the ComponentActivity, calls .setOwners(), which passes this: ComponentActivity

      • if this.window.decorView.findViewTree{Lifecycle, ViewModelStore, SavedStateRegistry}Owner() == null
      • to this.window.decorView.setViewTree{Lifecycle, ViewModelStore, SavedStateRegistry}Owner respectively
   2. 2.
      on the ComponentActivity, calls .setContentView(/* ComposeView */, DefaultActivityContentLayoutParams)

      private val DefaultActivityContentLayoutParams = ViewGroup.LayoutParams(
          ViewGroup.LayoutParams.WRAP_CONTENT,
          ViewGroup.LayoutParams.WRAP_CONTENT,
      )

      • populates the activity window decor view with the new ComposeView
      • the layout parameters request the window make the view as tall and wide as its content

AbstractComposeView::ensureCompositionCreated

• if this.composition == null, resolves its parent and constructs a Composition
• all call paths filtered by this.isAttachedToWindow; this attached to a window

1. 1.
   calls this.resolveParentCompositionContext()
   1. 1.
      returns this.parentContext if !null
   2. 2.
      returns this.findViewTreeCompositionContext()?.cacheIfAlive() if !null
      1. 1.
         goes up the View hierarchy tree until the first View::compositionContext: CompositionContext? that’s !null found
      2. 2.
         if !null, used if .isAlive; cached in this.cachedViewTreeCompositionContext = WeakReference(it)
   3. 3.
      returns this.cachedViewTreeCompositionContext?.get()?.takeIf { it.isAlive } if !null
   4. 4.
      returns this.windowRecomposer.cacheIfAlive() otherwise; View::windowRecomposer: Recomposer is a computed property
      1. 1.
         expects (invariant) this.isAttachedToWindow
      2. 2.
         goes up the View hierarchy tree for the first one parented by a android.R.id.content view
      3. 3.
         if the View::compositionContext: CompositionContext? for the found view

         • is Recomposer → returns the Recomposer
         • null → WindowRecomposerPolicy.createAndInstallWindowRecomposer passed the found view
         • else → throws if reached
2. 2.
   calls this.setContent

   internal fun AbstractComposeView.setContent(
       parent: CompositionContext,
       content: @Composable () -> Unit,
   ): Composition

   • extension; unrelated to ComposeView::setContent by inheritance
   • parent passed the return value of this.resolveParentCompositionContext()
   • content calls this.Content() when called
   1. 1.
      calls GlobalSnapshotManager.ensureStarted()
   2. 2.
      obtains a AndroidComposeView either from this.mChildren or by constructing one
      1. 1.
         this.getChildAt(0) as? AndroidComposeView used if this.childCount > 0
      2. 2.
         otherwise uses AndroidComposeView(this.context, parent.effectCoroutineContext)

         • View::context: Context; an environment role valid for a lifetime & shared by every reference site
         • the AndroidComposeView (added) made the only child of the this: AbstractComposeView parent (all other children removed)
   3. 3.
      return doSetContent(/* ... */)

      private fun doSetContent(
          owner: AndroidComposeView,
          parent: CompositionContext,
          content: @Composable () -> Unit,
      ): Composition

      • owner passed the obtained AndroidComposeView child
      • parent relayed the parent: CompositionContext from AbstractComposeView::setContent
      • content relayed the content: @Composable () -> Unit from AbstractComposeView::setContent
      1. 1.
         obtains a WrappedComposition: Composition either from the owner or by constructing one
         1. 1.
            owner.view.getTag(R.id.wrapped_composition_tag) as? WrappedComposition used if !null
         2. 2.
            otherwise WrappedComposition(owner, Composition(UiApplier(owner.root), parent)) added to the owner and used

            public fun Composition(applier: Applier<*>, parent: CompositionContext)
                : Composition
                = CompositionImpl(parent, applier)

      2. 2.
         calls .setContent(content) on the obtained WrappedComposition and then returns it

(WrappedComposition as Composition)::setContent

override fun setContent(content: @Composable () -> Unit)

• content relayed the content: @Composable () -> Unit from doSetContent, relayed from AbstractComposeView::setContent

1. 1.
   obtains the ViewTreeOwners of this.owner: AndroidComposeView if it’s attached to a view, or on attach later

   • on the initial (<activity> as ComponentActivity)::onCreate → ComponentActivity::setContent → ComposeView::setContent call path
     • called before it’s attached to a window; AbstractComposeView::ensureCompositionCreated not reached
     • attached to a window after (<activity> as ComponentActivity)::onCreate has returned
   • on the initial attach, AbstractComposeView::onAttachedToWindow called; its children attached after the callback has returned (ie not yet)
     • AbstractComposeView::onAttachedToWindow → AbstractComposeView::ensureCompositionCreated → AbstractComposeView::setContent → doSetContent → WrappedComposition::setContent called
     • WrappedComposition::owner: AndroidComposeView not attached yet, but owner.parent as AbstractComposeView is
   • after AbstractComposeView::onAttachedToWindow has returned, this.owner: AndroidComposeView attached
     • AndroidComposeView::onAttachedToWindow called; instantiates ViewTreeOwners → obtained for the remaining steps
     • the ComponentActivity registered for (this: AndroidComposeView).findViewTree{Lifecycle, SavedStateRegistry, ViewModelStore}Owner()
2. 2.
   returns if this.disposed, otherwise sets this.lastContent = content and continues
3. 3.
   if this.addedToLifecycle == null; true if the initialiser hasn’t been overridden
   1. 1.
      assigns the .lifecycleOwner.lifecycle: Lifecycle of the obtained ViewTreeOwners to this.addedToLifecycle

      • that of the ComponentActivity on this code path; already created, started, and resumed
   2. 2.
      calls .addObserver(this) on it; observed by this: LifecycleEventObserver

      • addObserver brings this to the current state of this.addedToLifecycle (created → started → resumed)
      • Lifecycle.Event.ON_DESTROY → this.dispose()
      • Lifecycle.Event.ON_CREATE (called on add here) → calls this.setContent(this.lastContent)
4. 4.
   otherwise (if this.addedToLifecycle != null), if the observed lifetime .currentState.isAtLeast(Lifecycle.State.CREATED), provides the following steps for updating (calculating and applying changes to) its original: Composition

   • calls CompositionImpl::setContent on this call path
   1. 1.
      substep 1

CompositionImpl::setContent

override fun setContent(content: @Composable () -> Unit)

• provided with the steps to update (calculate and apply changes to) this: CompositionImpl by the caller

1. 1.
   caches this.state == DEACTIVATED and assigns RUNNING to the field
2. 2.
   checks the invariants; throws unless

   • this.state == RUNNING
     • INCONSISTENT → this: CompositionImpl must be disposed because the previous composition was cancelled
     • DISPOSED → invalid for use because this: CompositionImpl has been disposed of
     • DEACTIVATED → should be activated again before setting the content
   • this.pendingPausedComposition == null; a pausable composition is already in progress
3. 3.
   if (this: CompositionImpl).state was DEACTIVATED per the cache, calls this.composer.startReuseFromRoot()
   1. 1.
      (this: ComposerImpl) sets this.reusingGroup = /* static */ rootKey; this.reusing = true
4. 4.
   unconditionally sets (this: CompositionImpl).composable = content
5. 5.
   unconditionally calls (this: CompositionImpl).parent.composeInitial(this, composable)

   • CompositionContext::composeInitial delegates up the hierarchy to the Recomposer: CompositionContext impl
6. 6.
   if (this: CompositionImpl).state was DEACTIVATED per the cache, calls this.composer.endReuseFromRoot()
   1. 1.
      (this: ComposerImpl) checks the invariant; throws unless !this.isComposing && this.reusingGroup == rootKey
   2. 2.
      (this: ComposerImpl) sets this.reusingGroup = -1; this.reusing = false

Recomposer::composeInitial

internal override fun composeInitial(
    composition: ControlledComposition,
    content: @Composable () -> Unit,
)

• composition passed the receiver of CompositionImpl::setContent from it
  • the WrappedComposition::original: Composition on this call path
• content relayed the content: @Composable () -> Unit from CompositionImpl::setContent
  • the steps to update (calculate and apply changes to) the CompositionImpl provided in WrappedComposition::setContent

Recomposer::composing

private inline fun <T> composing(
    composition: ControlledComposition,
    modifiedValues: MutableScatterSet?,
    block: () -> T,
): T

• composition relayed the composition: ControlledComposition from Recomposer::composeInitial
  • the (WrappedComposition::original: Composition) as CompositionImpl on this path
  • provided with the steps to update (calculate and apply changes to) itself in WrappedComposition::setContent
• modifiedValues passed null from Recomposer::composeInitial
• block passed from Recomposer::composeInitial the partial application of ControlledComposition::composeContent to its arguments

1. 1.
   takes a mutable snapshot with

   • a read observer: { value -> composition.recordReadOf(value) }
   • a write observer:

     { value ->
         composition.recordWriteOf(value)
         modifiedValues?.add(value)
     }

2. 2.
   enters the snapshot and runs the block

   • fully applies ControlledComposition::composeContent to the arguments of Recomposer::composeInitial
3. 3.
   relays the return value of the block after applying the snapshot; throws & disposes on failure

(CompositionImpl as ControlledComposition)::recordReadOf

1. 1.
   i don’t fucking know

(CompositionImpl as ControlledComposition)::recordWriteOf

1. 1.
   i don’t fucking know