3장

24. 초기 Composition 과정

• Composition#setContent

  • Composition이 처음 구축되기 시작

  override fun setContent(content: @Composable () -> Unit) {
      val wasDeactivated = clearDeactivated()
      ensureRunning()
  
      if (wasDeactivated) {
          composeInitialWithReuse(content)
      } else {
          composeInitial(content)
      }
  }
  
  private fun composeInitial(content: @Composable () -> Unit) {
      this.composable = content
      parent.composeInitial(this, composable)
  }
  

  • 초기 Composition 프로세스를 트리거하기 위해 상위 Composition에 호출이 위임됨
    • Subcomposition일 경우? 다른 Composition에 위임
    • Root Composition일 경우? Recomposer에 위임
  • 초기 Composition을 수행하는 로직은 Root Composition에 도달할 때까지 composeInitial호출을 상위 요소에 위임하기 위해 항상 Recomposer에 의존함
    • parent.composeInitial은 recomposer.composeInitial로 변환될 수 있음

• Recomposer#composeInitial (초기 Composition 순서)

  internal override fun composeInitial(
      composition: ControlledComposition,
      content: @Composable () -> Unit,
  ) {
      val composerWasComposing = composition.isComposing
  
      val newComposition =
          synchronized(stateLock) {
              if (_state.value > State.ShuttingDown) {
                  val new = composition !in knownCompositionsLocked()
                  if (new) {
                      registerCompositionLocked(composition)
                  }
                  new
              } else {
                  true
              }
          }
  
      try {
          composing(composition, null) { composition.composeContent(content) }
      } catch (e: Throwable) {
          if (newComposition) {
              synchronized(stateLock) { unregisterCompositionLocked(composition) }
          }
  
          processCompositionError(e, composition, recoverable = true)
          return
      }
  
      synchronized(stateLock) {
          if (_state.value > State.ShuttingDown) {
              if (composition !in knownCompositionsLocked()) {
                  addKnownCompositionLocked(composition)
              }
          } else {
              unregisterCompositionLocked(composition)
          }
      }
  
      // TODO(b/143755743)
      if (!composerWasComposing) {
          Snapshot.notifyObjectsInitialized()
      }
  
      try {
          performInitialMovableContentInserts(composition)
      } catch (e: Throwable) {
          processCompositionError(e, composition, recoverable = true)
          return
      }
  
      try {
          composition.applyChanges()
          composition.applyLateChanges()
      } catch (e: Throwable) {
          processCompositionError(e)
          return
      }
  
      if (!composerWasComposing) {
          // Ensure that any state objects created during applyChanges are seen as changed
          // if modified after this call.
          Snapshot.notifyObjectsInitialized()
      }
  }
    
  private inline fun <T> composing(
    composition: ControlledComposition,
    modifiedValues: MutableScatterSet<Any>?,
      block: () -> T,
  ): T {
      val snapshot =
          Snapshot.takeMutableSnapshot(
              readObserverOf(composition),
              writeObserverOf(composition, modifiedValues),
          )
      try {
          return snapshot.enter(block)
      } finally {
          applyAndCheck(snapshot)
      }
  }
  

  1. 모든 State 객체의 현재 값을 스냅샷으로 취함
     • 가변적 + synchronized한 값으로 세팅
       • 다른 기존 스냅샷에 영향을 주지 않고 안전하게 수정 가능 (snapshot.enter의 block에서만 수정 가능)
  2. Recomposer는 State 객체에 관찰자를 전달하여 Read/Write 진행 감지 및 Composition에 알림
     • Composition은 영향받은 Recomposition 범위를 사용됨으로 플래그하여, 때가 되면 Recomposition할 수 있음
  3. composition.composeContent에 snapshot.enter 블록을 전달하여 스냅샷에 들어가고, 실제 Composition이 일어남
     • 스냅샷에 들어가는 행동들은 Recomposer에게 추적됨을 알려줌
  4. Composition 프로세스가 Composer에게 위임
  5. Composition 완료 시, State 변경사항이 State 스냅샷에만 적용되기 때문에 snapshot.apply를 통해 변경사항 전파

• Composer에 위임된 실제 Composition 과정

  1. Composition이 이미 진행중인 경우 새로 시작할 수 없음
     1. 새로운 Composition은 폐기되고 예외 발생, 재진입 불가
  2. 보류중인 Invalidation이 있는 경우, Composer의 Invalidation 목록으로 복사하여 RecomposeScope의 Invalidation을 기다림
  3. isComposing = true로 세팅해 시작 대기
  4. startRoot 호출을 통해 Composition을 시작
     1. 슬롯 테이블에서 Composition 루트 그룹을 시작하고 필요한 필드들 초기화 (startGroup)
  5. content 람다 호출
  6. endGroup 호출
  7. endRoot 호출하여 Composition 종료
  8. isComposing = false로 세팅해 Composition 완료
  9. 임시 데이터 삭제 처리

25. 초기 Composition 후 변경 사항 적용

• 초기 Composition 이후 Applier의 행동
  • Applier#onBeginChanges
    • 초기 Composition 이후, Applier에 변경사항 composition.applyChanges로 기록된 변경사항 적용하도록 알림 전달
    • Applier는 모든 변경사항을 실행하고, 필요한 Applier 및 SlotWriter 인스턴스를 각 변경사항에 전달
  • Applier#onEndChanges
    • 모든 변경 사항 적용 후 호출됨
  • 등록된 모든 RememberedObserver 전달
    • RememberedObserver를 구현하는 모든 클래스는 Composition에 들어가거나 나갈 때 알림을 받음
    • LaunchedEffect나 DisposableEffect가 컴포지션 내의 Composable 생명 주기에 대한 이펙트를 제한하는 원리

26. Composition에 대한 추가 정보

• Composition
  • isComposing 플래그
    • 현재 Composition이 수행 중인지의 여부 판단
    • 현재 수행중인 경우, Invalidation을 즉시 적용하거나 연기할 수 있음
  • ControlledComposition
    • 런타임이 의존하는 변형 Composition
    • 외부에서 제어할 수 있도록 추가 기능을 제공함
    • Recomposer가 Invalidation과 추가적인 Recomposition을 조율하기 위해 사용
  • 관찰 중인 객체들이 변경될 때 Recomposition을 강제
    • e.g. 상위 Composition에서 CompositionLocal이 변경되면, 하위 Composition에서 Recomposition을 강제
  • 수행 중 오류가 발견되는 경우 Composition 중단

27. Recomposer

• 특징
  • ControlledComposition을 제어
  • 변경 사항들을 적용하기 위해 필요 시 Recomposition 트리거
  • Composition을 시작하거나 Recomposition할 스레드 결정
  • 변경 사항을 적용할 때 필요한 스레드 결정

28. Recomposer 생성