public suspend fun <T> Lifecycle.whenStateAtLeast(
   minState: Lifecycle.State,
   block: suspend CoroutineScope.() -> T
): T = withContext(Dispatchers.Main.immediate) {
    val job = coroutineContext[Job] ?: error("when[State] methods should have a parent job")
    val dispatcher = PausingDispatcher()
    val controller =
        LifecycleController(this@whenStateAtLeast, minState, dispatcher.dispatchQueue, job)
    try {
        withContext(dispatcher, block)
    } finally {
        controller.finish()
    }
}

internal class PausingDispatcher : CoroutineDispatcher() {
    @JvmField
    internal val dispatchQueue = DispatchQueue()

    override fun isDispatchNeeded(context: CoroutineContext): Boolean {
        if (Dispatchers.Main.immediate.isDispatchNeeded(context)) {
            return true
        }
        return !dispatchQueue.canRun()
    }

    override fun dispatch(context: CoroutineContext, block: Runnable) {
        dispatchQueue.dispatchAndEnqueue(context, block)
    }
}

internal class DispatchQueue {
   private var paused: Boolean = true
   private var finished: Boolean = false
   ...
   private val queue: Queue<Runnable> = ArrayDeque<Runnable>()
  
   // 동작 제어를 pause/resume/finish 함수로 중지와 완료 플래그를 on/off 설정.

   @MainThread
   fun pause() {
      paused = true
   }

   @MainThread
   fun resume() {
      ...
      paused = false
      drainQueue()
   }

   @MainThread
   fun finish() {
      finished = true
      drainQueue()
   }
   ...  
   // 실행 가능 여부를 canRun() 함수로 확인하며,
   // 완료, 정지 flag를 사용해 실행 여부를 체크

   @MainThread
   fun canRun() = finished || !paused
  
   // PausingDispatcher#dispatch를 통해서 호출되는 dispatchAndEnqueue는
   // 실행 가능 여부를 확인한 후 블록을 실행하거나 큐에 추가.

   @AnyThread
   @SuppressLint("WrongThread")
   fun dispatchAndEnqueue(context: CoroutineContext, runnable: Runnable) {
      with(Dispatchers.Main.immediate) {
         if (isDispatchNeeded(context) || canRun()) {
             dispatch(context, Runnable { enqueue(runnable) })
         } else {
            enqueue(runnable)
         }
      }
   }
   ...
}

@MainThread
internal class LifecycleController(
   private val lifecycle: Lifecycle,
   private val minState: Lifecycle.State,
   private val dispatchQueue: DispatchQueue,
   parentJob: Job
) {
   private val observer = LifecycleEventObserver { source, _ ->
      if (source.lifecycle.currentState == Lifecycle.State.DESTROYED) {
         // 현재 생명 주기가 DESTROYED인 경우 종료 처리를 진행.
         handleDestroy(parentJob)
      } else if (source.lifecycle.currentState < minState) {
         // 현재 생명 주기가 지정한 생명 주기(minState)보다 작은 경우 일시 정지.
         dispatchQueue.pause()
      } else {
         // 현재 생명 주기가 지정한 생명 주기(minState)보다 크거나 같은 경우 일시 정지.
         dispatchQueue.resume()
      }
   }

   init {
      // LifecycleController 시작 시 현재 생명 주기가 DESTROYED인 경우 종료 처리를 진행.
      // 그 외에는 Lifecycle에 LifecycleEventObserver를 등록
      if (lifecycle.currentState == Lifecycle.State.DESTROYED) {
         handleDestroy(parentJob)
      } else {
         lifecycle.addObserver(observer)
      }
   }

   // 부모 Job을 취소한 후,
   // Lifecycle에 등록된 Observer 제거와 DispatchQueue#finish 호출
   @Suppress("NOTHING_TO_INLINE") 
   private inline fun handleDestroy(parentJob: Job) {
      parentJob.cancel()
      finish()
   }

   @MainThread
   fun finish() {
      lifecycle.removeObserver(observer)
      dispatchQueue.finish()
   }
}

public suspend inline fun <R> Lifecycle.withStateAtLeast(
    state: Lifecycle.State,
    crossinline block: () -> R
): R {
    require(state >= Lifecycle.State.CREATED) {
        "target state must be CREATED or greater, found $state"
    }

    return withStateAtLeastUnchecked(state, block)
}

@PublishedApi
internal suspend inline fun <R> Lifecycle.withStateAtLeastUnchecked(
   state: Lifecycle.State,
   crossinline block: () -> R
): R {
   val lifecycleDispatcher = Dispatchers.Main.immediate
   val dispatchNeeded = lifecycleDispatcher.isDispatchNeeded(coroutineContext)
   if (!dispatchNeeded) {
      // 생명 주기 Dispatcher가 디스패치가 불필요한 경우
      // 현재 생명 주기가 DESTROYED인 경우, LifecycleDestroyedException를 발생.
      // 현재 생명 주기가 지정한 생명 주기보다 크거나 같은 경우, 파라미터로 전달받은 블록을 실행.
      if (currentState == Lifecycle.State.DESTROYED) throw LifecycleDestroyedException()
      if (currentState >= state) return block()
   }

   // 생명 주기 Dispatcher가 디스패치가 필요한 경우
   // suspendWithStateAtLeastUnchecked 함수 호출
   return suspendWithStateAtLeastUnchecked(state, dispatchNeeded, lifecycleDispatcher) {
      block()
   }
}

// LifecycleDestroyedException는 CancellationException의 하위 클래스.
// CoroutineExceptionHandler를 정의했다면 해당 Exception을 전달받을 수 있습니다.
public class LifecycleDestroyedException : CancellationException()

@PublishedApi
internal suspend fun <R> Lifecycle.suspendWithStateAtLeastUnchecked(
   state: Lifecycle.State,
   dispatchNeeded: Boolean,
   lifecycleDispatcher: CoroutineDispatcher,
   block: () -> R
): R = suspendCancellableCoroutine { co ->
   val observer = object : LifecycleEventObserver {
      override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
         if (event == Lifecycle.Event.upTo(state)) {
            // 현재 생명 주기가 지정한 생명 주기보다 크거나 같다면
            // Lifecycle에 등록된 Observer 제거한 후 블록을 실행 
            removeObserver(this)
            co.resumeWith(runCatching(block))
         } else if (event == Lifecycle.Event.ON_DESTROY) {
            // 현재 생명 주기가 DESTROYED인 경우
            // Lifecycle에 등록된 Observer 제거한 후 LifecycleDestroyedException를 발생
            removeObserver(this)
            co.resumeWithException(LifecycleDestroyedException())
         }
      }
   }

   // Lifecycle 이벤트를 구독
   if (dispatchNeeded) {
      lifecycleDispatcher.dispatch(
         EmptyCoroutineContext,
         Runnable { addObserver(observer) }
      )
   } else addObserver(observer)

   co.invokeOnCancellation {
      // CancellableContinuation(=co)이 취소된 경우, Lifecycle 이벤트 구독을 해지
      if (lifecycleDispatcher.isDispatchNeeded(EmptyCoroutineContext)) {
         lifecycleDispatcher.dispatch(
            EmptyCoroutineContext,
            Runnable { removeObserver(observer) }
         )
      } else removeObserver(observer)
   }
}