swift - 如何在 Swift 中访问 KMMShared MutableStateFlow 对象

Question

我有一个带有 MutableStateFlow 的 KmmShared 单例类，它可以在 Android 上正常工作。我需要知道访问此 Singleton 类及其 MutableStateFlow 变量的最佳方法，并在 SwiftUI 应用程序中进行更新。

class MySingeltonClass {
    private val _selectedType: MutableStateFlow<MyEnum> = MutableStateFlow(getUserPrefsType())
    var selectedType = _selectedType.asStateFlow()

    private fun getUserPrefsType() : MyEnum {
        // Get Enum from DB
    }

    fun setType(scheme: MyEnum) {
        // Set Enum in DB
        _selectedType.value = scheme
    }

    companion object {
        private lateinit var instance: MySingeltonClass
        fun getInstance(): MySingeltonClass {
            if (!this::instance.isInitialized) {
                instance = MySingeltonClass()
            }
            return instance
        }

    }
}

enum class MyEnum {
    TYPEA, TYPEB, TYPEC;
}

如果我可以拥有一个带有 @Published var selectedType 或 @ObservedObject private var selectedType 的 MySingeltonWrapperClass ，我正在尝试在 Swift 中实现。

Answer 1

这是一个有点棘手的话题。 SwiftUI 应用程序中 Flow/StateFlow 的主要问题在于 Kotlin <-> Swift 互操作性。因为它有几个限制:

• 互操作性 doesn't work on Generic Interfaces
• 我们需要在特定的CoroutineScope中启动流程才能取消作业

更好理解的好文章:one , two

有几种可用的解决方法:

1。将 Flow 封装在 Kotlin class 中。您可以在 official KMM sample repo 中找到此技术的绝佳示例。 .

首先，author introduces new class CFlow:

fun interface Closeable {
    fun close()
}

class CFlow<T: Any> internal constructor(private val origin: Flow<T>) : Flow<T> by origin {
    fun watch(block: (T) -> Unit): Closeable {
        val job = Job()

        onEach {
            block(it)
        }.launchIn(CoroutineScope(Dispatchers.Main + job))

        return Closeable { job.cancel() }
    }
}

internal fun <T: Any> Flow<T>.wrap(): CFlow<T> = CFlow(this)

然后uses it in SwiftUI :

class ObservableFeedStore: ObservableObject {
    @Published public var state: FeedState =  FeedState(progress: false, feeds: [], selectedFeed: nil)
    
    var stateWatcher : Closeable?

    init(store: FeedStore) {
        stateWatcher = self.store.watchState().watch { [weak self] state in
            self?.state = state
        }
    }
    
    deinit {
        stateWatcher?.close()
    }
}

2。使用特殊的库，例如KMP-NativeCoroutines .

当您设置此库时，您可以为您的 Kotlin Flow/StateFlow 创建 Swift AnyPublisher:

let publisher = createPublisher(for: yourFlow)

3。不要使用Flow/StateFlow。您可以使用简单的替代方法。看看Decompose project它是值 class .

abstract class Value<out T : Any> {
    abstract val value: T
    abstract fun subscribe(observer: (T) -> Unit)
    abstract fun unsubscribe(observer: (T) -> Unit)
}

您仍然可以非常轻松地在 Compose 应用程序中使用它来获取State，sample from Decompose :

@Composable
fun <T : Any> Value<T>.subscribeAsState(policy: SnapshotMutationPolicy<T> = structuralEqualityPolicy()): State<T> {
    val state = remember(this, policy) { mutableStateOf(value, policy) }

    DisposableEffect(this) {
        val observer: (T) -> Unit = { state.value = it }

        subscribe(observer)

        onDispose {
            unsubscribe(observer)
        }
    }

    return state
}

并且在 SwiftUI 中您可以使用 ObservableValue helper from Decompose :

public class ObservableValue<T : AnyObject> : ObservableObject {
    private let observableValue: Value<T>

    @Published
    var value: T

    private var observer: ((T) -> Void)?
    
    init(_ value: Value<T>) {
        observableValue = value
        self.value = observableValue.value
        observer = { [weak self] value in self?.value = value }
        observableValue.subscribe(observer: observer!)
    }

    deinit {
        observableValue.unsubscribe(observer: self.observer!)
    }
}