JetPack Compose主题配色太少怎么办，来设计自己的颜色系统吧（下）

@Composable
fun A(message: String) {
  Column() {
     B(message)
  }
}
@Composable
fun B(message: String) {
    Text(text = message)
    C(message)
}
@Composable
fun C(message: String) {
    Text(text = message)
}

val MessageContent = compositionLocalOf { "simple" }
@Composable
fun A(message: String) {
    Column() {
        // provides 相当于写入数据
        CompositionLocalProvider(MessageContent provides message) {
            B()
        }
    }
}
@Composable
fun B() {
    Text(text = MessageContent.current)
    CompositionLocalProvider(MessageContent provides "临时对值进行更改") {
        C()
    }
}
@Composable
fun C() {
    Text(text = MessageContent.current)
}

sealed class CompositionLocal<T> constructor(defaultFactory: () -> T) {
    // 默认值
    internal val defaultValueHolder = LazyValueHolder(defaultFactory)
    // 写入最新数据
    @Composable
    internal abstract fun provided(value: T): State<T>
    // 返回由最近的 CompositionLocalProvider 提供的值
    @OptIn(InternalComposeApi::class)
    inline val current: T
        @ReadOnlyComposable
        @Composable
        //直接追这里代码
        get() = currentComposer.consume(this)
}

@InternalComposeApi
override fun <T> consume(key: CompositionLocal<T>): T =
    // currentCompositionLocalScope() 获取父可组合项提供的当前CompositionLocal范围map
    resolveCompositionLocal(key, currentCompositionLocalScope())

private fun currentCompositionLocalScope(): CompositionLocalMap {
    //如果可组合项当前正在插入并且有数据提供者
    if (inserting && hasProvider) {
        // 从插入表中取离当前 composable 最近的group（可以理解为直接去取index最近的currentGroup）
        var current = writer.parent
        // 如果这个group不是空的
        while (current > 0) {
            // 在插槽表中取出这个group的key与当前composable的key进行对比
            if (writer.groupKey(current) == compositionLocalMapKey &&
                writer.groupObjectKey(current) == compositionLocalMap
            ) {
                // 返回指定位置的 CompositionLocalMap
                return writer.groupAux(current) as CompositionLocalMap
            }
            // 死循环，不断的向上找，如果当前组里没有，就继续向上找，直到找到可以与当前匹配的
            current = writer.parent(current)
        }
    }
    //如果当前composable的slotTable内的数组不为空
    if (slotTable.groupsSize > 0) {
        //从当前插槽中取里当前离 composable 最近的graoup
        var current = reader.parent
        // 默认值为-1，如果存在，即意味着存在可组合项
        while (current > 0) {
            if (reader.groupKey(current) == compositionLocalMapKey &&
                reader.groupObjectKey(current) == compositionLocalMap
            ) {
                //从providerUpdates数组中获取当前CompositionLocalMap，插入见 - startProviders
                return providerUpdates[current]
                    ?: reader.groupAux(current) as CompositionLocalMap
            }
            current = reader.parent(current)
        }
    }
    //如果没找到，则返回父 composable 的 Provider
    return parentProvider
}

private fun <T> resolveCompositionLocal(
    key: CompositionLocal<T>,
    scope: CompositionLocalMap
): T = if (scope.contains(key)) {
    // 如果当前父CompositionLocalMap里包含了当前local,直接从map中取
    scope.getValueOf(key)
} else {
    // 否则也就意味着其目前就是最顶层，没有父local，直接使用默认值
    key.defaultValueHolder.value
}

fun CompositionLocalProvider(vararg values: ProvidedValue<*>, content: @Composable () -> Unit) {
    currentComposer.startProviders(values)
    content()
    currentComposer.endProviders()
}

/**
 * Composer is the interface that is targeted by the Compose Kotlin compiler plugin and used by
 * code generation helpers. It is highly recommended that direct calls these be avoided as the
 * runtime assumes that the calls are generated by the compiler and contain only a minimum amount
 * of state validation.
 */
interface Composer
     👇
internal class ComposerImpl : Composer

@InternalComposeApi
override fun startProviders(values: Array<out ProvidedValue<*>>) {
    //获得当前Composable下的CompositionLocal-Map
    val parentScope = currentCompositionLocalScope()
    ...
    val currentProviders = invokeComposableForResult(this) {
        compositionLocalMapOf(values, parentScope)
    }
    val providers: CompositionLocalMap
    val invalid: Boolean
    //如果可组合项正在插入树中或者其是第一次被调用，则为true
    if (inserting) {
        //更新当前的CompositionLocalMap
        providers = updateProviderMapGroup(parentScope, currentProviders)
        invalid = false
        hasProvider = true
    } else {
        //如果当前可组合项不可以跳过(即发生了改变)或者providers不相同，则更新当前Composable的group
        if (!skipping || oldValues != currentProviders) {
            providers = updateProviderMapGroup(parentScope, currentProviders)
            invalid = providers != oldScope
        } else {
            //否则跳过当前更新
            skipGroup()
            providers = oldScope
            invalid = false
        }
    }
    //如果本次重组无效且没有正在插入，更新当前group的 CompositionLocalMap
    if (invalid && !inserting) {
        providerUpdates[reader.currentGroup] = providers
    }
    // 将当前的操作push到栈中,后续还要再弹出
    providersInvalidStack.push(providersInvalid.asInt())
    ...
    // 将providers数据写入group,最终会写入到SlotTable-slots(插槽的缓冲区)数组中
    start(compositionLocalMapKey, compositionLocalMap, false, providers)
}

override fun endProviders() {
    endGroup()
    endGroup()
    // 将当前的操作出栈
    providersInvalid = providersInvalidStack.pop().asBool()
}