calls this.resolveParentCompositionContext()

1.
returns this.parentContext if !null
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.
returns this.cachedViewTreeCompositionContext?.get()?.takeIf { it.isAlive } if !null
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 an 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

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.
calls GlobalSnapshotManager.ensureStarted()
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.
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)
```
    - parent is the Recomposer: CompositionContext returned and relayed from AbstractComposeView::resolveParentCompositionContext
    - the CompositionImpl constructed with a ComposerImpl registered with the parent; nop
2. 2.
  calls .setContent(content) on the obtained WrappedComposition and then returns it

`(CompositionImpl as ControlledComposition)::recordWriteOf`

override fun recordWriteOf(value: Any)

1.
calls this::invalidateScopeOfLocked
1. 1.
  passed value; invalidates all recompose scopes that read it
```
private fun invalidateScopeOfLocked(value: Any)
```
  1. 1.
    repeats for each scope: RecomposeScopeImpl in the population that the value is mapped to in this.observations: ScopeMap<Any, RecomposeScopeImpl>
  2. 2.
    skips to the next iteration unless scope.invalidateForResult(value) == InvalidationResult.IMMINENT
    1. 1.
      calls RecomposeScopeOwner::invalidate on the scope.owner: RecomposeScopeOwner? if !null
      fun invalidate(scope: RecomposeScopeImpl, instance: Any?): InvalidationResult
      
      calls (CompositionImpl as RecomposeScopeOwner)::invalidate on this call path
      
      scope relayed the scope: RecomposeScopeImpl receiver of the invalidateForResult method
      
      instance relayed the value: Any? argument from the invalidateForResult method
      1. 1.
        sets scope.defaultsInvalid = true if scope.defaultsInScope; the default params also refreshed
      2. 2.
        declares val anchor: Anchor? = scope.anchor; the slice in the slot table that the recompose scope corresonds to
      3. 3.
        returns InvalidationResult.IGNORED if anchor == null || !anchor.valid
        makes the recomposition nop since the scope is not part of the composition (anymore)
      4. 4.
        returns InvalidationResult.{IMMINENT | IGNORED} if !this.slotTable.ownsAnchor(anchor)
        reached if still part of the slot table
        
        the scope not owned by this; queries a delegate composition
        
        1.
        declares val delegate: CompositionImpl? = synchronized(this.lock) { this.invalidationDelegate }
        the property temporarily !null while inside this::delegateInvalidations
        
        where there are a ControlledComposition that’s not this
        
        and a groupIndex: Int that’s >= 0
        
        2.
        returns InvalidationResult.IMMINENT if delegate?.tryImminentInvalidation(scope, instance) == true
        CompositionImpl::recordWriteOf run on each state write in a snapshot where the composition is composed
        
        true if the scope will be recomposed by the delegate within the current (before the next) composition pass
        
        3.
        returns InvalidationResult.IGNORED otherwise; to be recomposed by neither this nor the delegate
      5. 5.
        returns InvalidationResult.IGNORED if !scope.canRecompose; has opted out or is unable
        reached if still part of the slot table & directly owned by the scope, not a delegate
      6. 6.
        returns this.invalidateChecked(scope, anchor, instance)
        reached if still part of the slot table & directly owned by the scope, not a delegate & eligible for recomposition
        
        also notifies on return this.observer() unless InvalidationResult.IGNORED
        
        1.
        declares val delegate: CompositionImpl?; initialised with
        1.
        this.invalidationDelegate if this.slotTable.groupContainsAnchor(this.invalidationDelegateGroup, anchor)
        this.invalidationDelegateGroup: Int = 0 assigned a different value while in this::delegateInvalidations
        
        true if (the slice corresponded to by) the recompose scope (as pointed to by the anchor) is in a movable content
        
        2.
        return InvalidationResult.IMMINENT (recursion base) if this.tryImminentInvalidation(scope, instance)
        CompositionImpl::recordWriteOf run on each state write in a snapshot where the composition is composed
        
        true if the scope will be recomposed by this within the current (before the next) composition pass
        
        3.
        null otherwise
        1.
        calls this.invalidations.set(scope, ScopeInvalidated) if instance == null || instance !is DerivedState<*>
        this.invalidations: ScopeMap<RecomposeScopeImpl, Any>; recompose scopes → the populations of outdated state objects they read
        
        ScopeMap::set overrides and replaces the current population (if present) with the given element
        
        internal object ScopeInvalidated indicates that an invalidated recompose scope doesn’t track the population of outdated states it read (eg when RecomposeScopeImpl::invalidate has passed instance = null to RecomposeScopeOwner::invalidate)
        
        2.
        calls this.invalidations.add(scope, instance) if !this.invalidations.anyScopeOf(scope) { it === ScopeInvalidated }
        ie if this.invalidations doesn’t map the scope to ScopeInvalidated (→ unconditionally recomposed)
        
        reached if DerivedState<*>; kept track of since derived states can avoid recomposition sometimes
        
        populates the population of outdated states read by the scope
        
        2.
        recurses if delegate != null; returns delegate.invalidateChecked(scope, anchor, instance)
        
        3.
        calls this.parent.invalidate(this); notifies the CompositionContext
        internal abstract fun invalidate(composition: ControlledComposition)
        
        calls (Recomposer as CompositionContext)::invalidate on the call path from ComponentActivity::setContent
        
        1.
        adds the composition to Recomposer::compositionInvalidations: MutableVector<ControlledComposition> if not already contained
        
        2.
        resumes the Recomposer::workContinuation: CancellableContinuation<Unit>? if eligible
        every call to a suspend function needs a coroutine to run in
        
        the continuation of a suspend function call is delimited by the coroutine and reified for use in CPS
        
        when a suspend function returns a T, the Continuation<T> (the rest of the coroutine) is resumed with a T
        
        4.
        returns (recursion base)
        InvalidationResult.DEFERRED if this.isComposing
        
        InvalidationResult.SCHEDULED otherwise
    2. 2.
      otherwise returns InvalidationResult.IGNORED
  3. 3.
    calls this.observationsProcessed.add(value, scope) if unskipped
    - this.observationsProcessed: ScopeMap<Any, RecomposeScopeImpl>; state objects → the populations of recompose scopes that are recomposed in the current pass
2. 2.
  passed each in the population of derived states from the value; invalidates all recompose scopes that read each

understanding compose

types

`ComponentActivity::setContent`

`AbstractComposeView::ensureCompositionCreated`

`(WrappedComposition as Composition)::setContent`

`CompositionImpl::setContent`

`Recomposer::composeInitial`

`(CompositionImpl as ControlledComposition)::recordReadOf`

`(CompositionImpl as ControlledComposition)::recordWriteOf`