launch(Dispatchers.Main) {
    // 第一部分
    flow {
        emit(1)
        throw NullPointerException("e")
    }.catch {
        Log.d("liduo", "onCreate1: $it")
    }.collect {
        Log.d("liudo", "onCreate2: $it")
    }
    // 第二部分
    flow {
        emit(1)
    }.onCompletion {
        Log.d("liduo", "onCreate3: $it")
    }.collect {
        Log.d("liudo", "onCreate4: $it")
    }
    // 第三部分
    flow {
        emit(1)
        throw NullPointerException("e")
    }.retryWhen { cause, attempt ->
        cause !is NullPointerException && attempt <= 2
    }.collect {
        Log.d("liudo", "onCreate5: $it")
    }
}

public fun <T> Flow<T>.catch(action: suspend FlowCollector<T>.(cause: Throwable) -> Unit): Flow<T> =
    flow { // 創建Flow對象
        // 觸發上游流的執行，并捕獲異常
        val exception = catchImpl(this)
        // 捕獲到異常，則回調action處理
        if (exception != null) action(exception)
    }

internal suspend fun <T> Flow<T>.catchImpl(
    collector: FlowCollector<T>
): Throwable? {
    // 保存下游流執行拋出的異常
    var fromDownstream: Throwable? = null
    try {
        // 觸發上游流的執行
        collect {
            try {
                // 將上游流發送的值作為參數，觸發下游流執行
                collector.emit(it)
            } catch (e: Throwable) { // 如果下游流在執行中發生異常，保存并拋出
                fromDownstream = e
                throw e
            }
        }
    } catch (e: Throwable) { // 這里捕獲的異常，可能為上游流的異常——collect方法，
                             // 也可能為下游流的異常——emit方法
        // 如果異常是下游流產生的異常，或者是協程取消時拋出的異常
        if (e.isSameExceptionAs(fromDownstream) || e.isCancellationCause(coroutineContext)) {
            throw e // 再次拋出，交給下游處理
        } else { // 如果是上游流的異常且不為協程取消異常
            return e // 成功捕獲
        }
    }
    // 未捕獲到異常，返回
    return null
}

public fun <T> Flow<T>.onCompletion(
    action: suspend FlowCollector<T>.(cause: Throwable?) -> Unit
): Flow<T> = unsafeFlow { // 創建一個Flow對象
    try {
        // 觸發上游流的執行
        // this表示下游的FlowCollector
        collect(this)
    } catch (e: Throwable) {// 如果下游發生異常
        // 將異常封裝成ThrowingCollector類型的FlowCollector，并回調參數action，
        ThrowingCollector(e).invokeSafely(action, e)
        // 拋出異常
        throw e
    }
    // 如果正常執行結束，會走到這里
    val sc = SafeCollector(this, currentCoroutineContext())
    try {
        // 回調執行參數action
        sc.action(null)
    } finally {
        sc.releaseIntercepted()
    }
}

@PublishedApi
internal inline fun <T> unsafeFlow(@BuilderInference crossinline block: suspend FlowCollector<T>.() -> Unit): Flow<T> {
    // 返回一個匿名內部類
    return object : Flow<T> {
        // 回調collect方法是直接執行block
        override suspend fun collect(collector: FlowCollector<T>) {
            collector.block()
        }
    }
}

private class ThrowingCollector(private val e: Throwable) : FlowCollector<Any?> {
    override suspend fun emit(value: Any?) {
        // 拋出異常
        throw e
    }
}

// 參數cause表示捕獲到的異常
// 參數attempt表示重試的次數
// 參數predicate返回true表示重新觸發上游流的執行
public fun <T> Flow<T>.retryWhen(predicate: suspend FlowCollector<T>.(cause: Throwable, attempt: Long) -> Boolean): Flow<T> =
    // 創建一個Flow對象
    flow {
        // 記錄重試次數
        var attempt = 0L
        // 表示是否重新觸發
        var shallRetry: Boolean
        do {
            // 復位成false
            shallRetry = false
            // 觸發上游流的執行，并捕獲異常
            val cause = catchImpl(this)
            // 如果捕獲到異常
            if (cause != null) {
                // 用戶判斷，是否要重新觸發
                if (predicate(cause, attempt)) {
                    // 表示要重新觸發
                    shallRetry = true
                    // 重試次數加1
                    attempt++
                } else { // 如果用戶不需要重新觸發
                    // 則拋出異常
                    throw cause
                }
            }
        // 判斷是否重新觸發
        } while (shallRetry)
    }