StateKeeper save MutableState

[BryanSer]

I've developed a set of StateKeeper extension functions for Decompose, primarily to simplify Compose state persistence code. However, I'm questioning some of the design decisions made during implementation and would love to hear the community's thoughts.

import androidx.compose.runtime.MutableState
import androidx.compose.runtime.mutableStateMapOf
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.snapshots.SnapshotStateMap
import com.arkivanov.essenty.statekeeper.StateKeeper
import com.arkivanov.essenty.statekeeper.StateKeeperOwner
import kotlinx.serialization.KSerializer
import kotlinx.serialization.Serializable
import kotlin.concurrent.Volatile
import kotlin.properties.PropertyDelegateProvider
import kotlin.properties.ReadOnlyProperty
import kotlin.properties.ReadWriteProperty
import kotlin.reflect.KProperty


fun <T> StateKeeperOwner.writeableSaveable(
    serializer: KSerializer<T>,
    key: String? = null,
    init: () -> T,
) = stateKeeper.writeableSaveable(
    serializer = serializer,
    key = key,
    init = init,
)
fun <T,S> StateKeeperOwner.writeableSaveable(
    serializer: KSerializer<S>,
    state: (T) -> S,
    key: String? = null,
    init: (savedState: S?) -> T,
): PropertyDelegateProvider<Any?, ReadOnlyProperty<Any?, MutableState<T>>>{
    return stateKeeper.writeableSaveable(
        serializer = serializer,
        state = state,
        key = key,
        init = init,
    )
}
fun <T,S> StateKeeper.writeableSaveable(
    serializer: KSerializer<S>,
    state: (T) -> S,
    key: String? = null,
    init: (savedState: S?) -> T,
): PropertyDelegateProvider<Any?, ReadOnlyProperty<Any?, MutableState<T>>> {
    return PropertyDelegateProvider{_, property ->
        val stateKey = key ?: "SAVEABLE_HOLDER_${property.name}"
        val holderSerializer = Holder.serializer(serializer)
        val mutableState = mutableStateOf(init(consume(key = stateKey, strategy = holderSerializer)?.value))
        register(key = stateKey, strategy = holderSerializer) { Holder(state(mutableState.value)) }
        ReadOnlyProperty{_,_->
            mutableState
        }
    }
}


fun <T> StateKeeper.writeableSaveable(
    serializer: KSerializer<T>,
    key: String? = null,
    init: () -> T,
): PropertyDelegateProvider<Any?, ReadOnlyProperty<Any?, MutableState<T>>> {
    return PropertyDelegateProvider{_, property ->
        val stateKey = key ?: "SAVEABLE_HOLDER_${property.name}"
        val holderSerializer = Holder.serializer(serializer)
        val mutableState = mutableStateOf(
            consume(key = stateKey, strategy = holderSerializer)?.value ?: init()
        )
        register(key = stateKey, strategy = holderSerializer) { Holder(mutableState.value) }
        ReadOnlyProperty { _, _ ->
            mutableState
        }
    }
}


fun <K, V> StateKeeperOwner.saveMap(
    serializer: KSerializer<Map<K, V>>,
    key: String? = null
): PropertyDelegateProvider<Any?, ReadOnlyProperty<Any?, SnapshotStateMap<K, V>>> {
    return stateKeeper.saveMap(serializer, key)
}

fun <K, V> StateKeeper.saveMap(
    serializer: KSerializer<Map<K, V>>,
    key: String? = null
): PropertyDelegateProvider<Any?, ReadOnlyProperty<Any?, SnapshotStateMap<K, V>>> {

    return PropertyDelegateProvider { _, property ->
        val stateKey = key ?: "SAVEABLE_HOLDER_MAP_${property.name}"
        val holderSerializer = Holder.serializer(serializer)
        val mutableMap = mutableStateMapOf<K, V>()
        val data = consume(key = stateKey, strategy = holderSerializer)?.value
        data?.let {
            mutableMap.putAll(it)
        }
        register(key = stateKey, strategy = holderSerializer) { Holder(mutableMap.toMap()) }
        ReadOnlyProperty { _, _ ->
            mutableMap
        }
    }
}
@Serializable
private class Holder<T>(@Volatile var value: T) : ReadWriteProperty<Any?, T> {
    override fun getValue(thisRef: Any?, property: KProperty<*>): T =
        this.value

    override fun setValue(thisRef: Any?, property: KProperty<*>, value: T) {
        this.value = value
    }
}

Would appreciate hearing similar experiences and best practices from the community!
Looking forward to your feedback and suggestions for improvement.

[arkivanov]

Looks good! Some comments:

1. It seems that you don't need Holder to implement ReadWriteProperty.
2. Naming suggestions: writeableSaveable -> saveableMutableState, saveMap -> saveableSnapshotStateMap.

[BryanSer]

Thank you, I write the new version.

import androidx.compose.runtime.MutableState
import androidx.compose.runtime.mutableStateMapOf
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.snapshots.SnapshotStateMap
import com.arkivanov.essenty.statekeeper.StateKeeper
import com.arkivanov.essenty.statekeeper.StateKeeperOwner
import kotlinx.serialization.KSerializer
import kotlin.properties.PropertyDelegateProvider
import kotlin.properties.ReadOnlyProperty


fun <T> StateKeeperOwner.saveableMutableState(
    serializer: KSerializer<T & Any>,
    key: String? = null,
    init: () -> T,
) = stateKeeper.saveableMutableState(
    serializer = serializer,
    key = key,
    init = init,
)

fun <T, S> StateKeeperOwner.saveableMutableState(
    serializer: KSerializer<S & Any>,
    state: (T) -> S,
    key: String? = null,
    init: (savedState: S?) -> T,
): PropertyDelegateProvider<Any?, MutableState<T>> {
    return stateKeeper.saveableMutableState(
        serializer = serializer,
        state = state,
        key = key,
        init = init,
    )
}

fun <T, S> StateKeeper.saveableMutableState(
    serializer: KSerializer<S & Any>,
    state: (T) -> S,
    key: String? = null,
    init: (savedState: S?) -> T,
): PropertyDelegateProvider<Any?, MutableState<T>> {
    return PropertyDelegateProvider{_, property ->
        val stateKey = key ?: "SAVEABLE_HOLDER_${property.name}"
        val mutableState = mutableStateOf(init(consume(key = stateKey, strategy = serializer)))
        register(key = stateKey, strategy = serializer) { state(mutableState.value) }
        mutableState
    }
}


fun <T> StateKeeper.saveableMutableState(
    serializer: KSerializer<T & Any>,
    key: String? = null,
    init: () -> T,
): PropertyDelegateProvider<Any?, MutableState<T>> {
    return PropertyDelegateProvider{_, property ->
        val stateKey = key ?: "SAVEABLE_HOLDER_${property.name}"
        val mutableState = mutableStateOf(
            consume(key = stateKey, strategy = serializer) ?: init()
        )
        register(key = stateKey, strategy = serializer) { mutableState.value }
        mutableState
    }
}


fun <K, V> StateKeeperOwner.saveableSnapshotStateMap(
    serializer: KSerializer<Map<K, V>>,
    key: String? = null
): PropertyDelegateProvider<Any?, ReadOnlyProperty<Any?, SnapshotStateMap<K, V>>> {
    return stateKeeper.saveableSnapshotStateMap(serializer, key)
}

fun <K, V> StateKeeper.saveableSnapshotStateMap(
    serializer: KSerializer<Map<K, V>>,
    key: String? = null
): PropertyDelegateProvider<Any?, ReadOnlyProperty<Any?, SnapshotStateMap<K, V>>> {

    return PropertyDelegateProvider { _, property ->
        val stateKey = key ?: "SAVEABLE_HOLDER_MAP_${property.name}"
        val mutableMap = mutableStateMapOf<K, V>()
        val data = consume(key = stateKey, strategy = serializer)
        data?.let {
            mutableMap.putAll(it)
        }
        register(key = stateKey, strategy = serializer) { mutableMap.toMap() }
        ReadOnlyProperty { _, _ ->
            mutableMap
        }
    }
}

[arkivanov]

Thanks for sharing!