AndroidX Lifecycle’s Path to Multiplatform - Droidcon Berlin 2024

We’ve recently converted the AndroidX Lifecycle libraries (ViewModel, Lifecycle Runtime, and Compose support) to Kotlin multi-platform (KMP). Join this session to learn more about how this process went, what the real-world challenges of maintaining API backward compatibility are, what lessons we learned from working around KMP limitations, and insights to guide you in migrating your own libraries to KMP.

Transcript

1. Lifecycle Path to Multiplatform Marcello Galhardo Software Engineer, Google
2. What will you learn today? Android Support for Kotlin Multiplatform (KMP) 01 Timeline for Lifecycle KMP 02 KMP API Challenges 03
3. Proprietary + Confidential 01 Android Support for Kotlin Multiplatform
4. I/O '17
5. I/O '24
6. KMP Compatibility KMP Support A B
7. We have made the source code compatible with common source sets. But it requires integration. KMP Compatibility KMP Support A B
8. We have made the source code compatible with common source sets. But it requires integration. KMP Compatibility Same as "KMP Compatibility", and it works out-of-the-box. The dream world where everything seamlessly works. KMP Support A B
9. Proprietary + Confidential 02 Timeline for Lifecycle KMP
10. January February March April May Lifecycle Runtime Compose KMP Lifecycle common and runtime KMP Lifecycle KMP Stable Release Collaborate with JetBrains ViewModel KMP ViewModel Compose KMP Timeline for Lifecycle KMP Starting line! Finishing line! Navigation KMP 2024
11. Finishing line! Navigation KMP Lifecycle Runtime Compose KMP Lifecycle common and runtime KMP Lifecycle KMP Stable Release ViewModel KMP ViewModel Compose KMP January February March April May Starting line! Timeline for Lifecycle KMP Collaborate with JetBrains 2024
12. Finishing line! Navigation KMP Collaborate with JetBrains Starting line! Lifecycle Runtime Compose KMP Lifecycle common and runtime KMP Lifecycle KMP Stable Release January February March April May Timeline for Lifecycle KMP ViewModel KMP ViewModel Compose KMP 2024 Navigation Dependencies
13. Proprietary + Confidential 03 KMP API Challenges
14. Lifecycle Event per platform
15. Events iOS Desktop Web ON_CREATED init init ON_START viewWillAppear willEnterForeground windowDeiconified ON_RESUME didBecomeActive windowGainedFocus focus ON_PAUSE willResignActive windowLostFocus blur ON_STOP viewDidDisappear didEnterBackground windowIconified ON_DESTROY didLeaveWindowHierar chy dispose
16. Events iOS Desktop Web ON_CREATED init init ON_START viewWillAppear willEnterForeground windowDeiconified ON_RESUME didBecomeActive windowGainedFocus focus ON_PAUSE willResignActive windowLostFocus blur ON_STOP viewDidDisappear didEnterBackground windowIconified ON_DESTROY didLeaveWindowHierar chy dispose
17. Events iOS Desktop Web ON_CREATED init init ON_START viewWillAppear willEnterForeground windowDeiconified ON_RESUME didBecomeActive windowGainedFocus focus ON_PAUSE willResignActive windowLostFocus blur ON_STOP viewDidDisappear didEnterBackground windowIconified ON_DESTROY didLeaveWindowHierar chy dispose
18. Events iOS Desktop Web ON_CREATED init init ON_START viewWillAppear willEnterForeground windowDeiconified ON_RESUME didBecomeActive windowGainedFocus focus ON_PAUSE willResignActive windowLostFocus blur ON_STOP viewDidDisappear didEnterBackground windowIconified ON_DESTROY didLeaveWindowHierar chy dispose
19. ViewModelProvider class
20. // Activity or Fragment val myViewModel by viewModels { MyViewModel.Factory } // Composable val myViewModel = viewModel { MyViewModel() } // Implementation Details ViewModelProvider(viewModelStore, factory, extras).get(key, MyViewModel::class)
21. // Activity or Fragment val myViewModel by viewModels { MyViewModel.Factory } // Composable val myViewModel = viewModel { MyViewModel() } // Implementation Details ViewModelProvider(viewModelStore, factory, extras).get(key, MyViewModel::class)
22. // Activity or Fragment val myViewModel by viewModels { MyViewModel.Factory } // Composable val myViewModel = viewModel { MyViewModel() } // Implementation Details ViewModelProvider(viewModelStore, factory, extras).get(key, MyViewModel::class)
23. // Activity or Fragment val myViewModel by viewModels { MyViewModel.Factory } // Composable val myViewModel = viewModel { MyViewModel() } // Implementation Details ViewModelProvider(viewModelStore, factory, extras).get(key, MyViewModel::class)
24. open class ViewModelProvider { @JvmOverloads constructor(store: ViewModelStore, factory: Factory, extras: CreationExtras = Empty) fun <T : ViewModel> get(key: String, modelClass: Class<T>): T interface Factory { fun <T : ViewModel> create(modelClass: Class<T>, extras: CreationExtras): T } open class NewInstanceFactory : Factory {...} open class AndroidViewModelFactory : NewInstanceFactory() {...} companion object {...} }
25. open class ViewModelProvider { @JvmOverloads constructor(store: ViewModelStore, factory: Factory, extras: CreationExtras = Empty) fun <T : ViewModel> get(key: String, modelClass: Class<T>): T interface Factory { fun <T : ViewModel> create(modelClass: Class<T>, extras: CreationExtras): T } open class NewInstanceFactory : Factory {...} open class AndroidViewModelFactory : NewInstanceFactory() {...} companion object {...} }
26. open class ViewModelProvider { @JvmOverloads constructor(store: ViewModelStore, factory: Factory, extras: CreationExtras = Empty) fun <T : ViewModel> get(key: String, modelClass: Class<T>): T interface Factory { fun <T : ViewModel> create(modelClass: Class<T>, extras: CreationExtras): T } open class NewInstanceFactory : Factory {...} open class AndroidViewModelFactory : NewInstanceFactory() {...} companion object {...} }
27. open class ViewModelProvider { @JvmOverloads constructor(store: ViewModelStore, factory: Factory, extras: CreationExtras = Empty) fun <T : ViewModel> get(key: String, modelClass: Class<T>): T interface Factory { fun <T : ViewModel> create(modelClass: Class<T>, extras: CreationExtras): T } open class NewInstanceFactory : Factory {...} open class AndroidViewModelFactory : NewInstanceFactory() {...} companion object {...} }
28. open class ViewModelProvider { @JvmOverloads constructor(store: ViewModelStore, factory: Factory, extras: CreationExtras = Empty) fun <T : ViewModel> get(key: String, modelClass: Class<T>): T interface Factory { fun <T : ViewModel> create(modelClass: Class<T>, extras: CreationExtras): T } open class NewInstanceFactory : Factory {...} open class AndroidViewModelFactory : NewInstanceFactory() {...} companion object {...} }
29. open class ViewModelProvider { @JvmOverloads constructor(store: ViewModelStore, factory: Factory, extras: CreationExtras = Empty) fun <T : ViewModel> get(key: String, modelClass: Class<T>): T interface Factory { fun <T : ViewModel> create(modelClass: Class<T>, extras: CreationExtras): T } open class NewInstanceFactory : Factory {...} open class AndroidViewModelFactory : NewInstanceFactory() {...} companion object {...} }
30. open class ViewModelProvider { @JvmOverloads constructor(store: ViewModelStore, factory: Factory, extras: CreationExtras = Empty) fun <T : ViewModel> get(key: String, modelClass: Class<T>): T interface Factory { fun <T : ViewModel> create(modelClass: Class<T>, extras: CreationExtras): T } open class NewInstanceFactory : Factory {...} open class AndroidViewModelFactory : NewInstanceFactory() {...} companion object {...} }
31. open class ViewModelProvider { @JvmOverloads constructor(store: ViewModelStore, factory: Factory, extras: CreationExtras = Empty) }
32. open class ViewModelProvider { @JvmOverloads constructor(store: ViewModelStore, factory: Factory, extras: CreationExtras = Empty) }
33. androidMain commonMain ViewModelProvider constructor ViewModelProvider constructor Move from to
34. $ ./gradlew checkApi
35. $ ./gradlew checkApi - ctor public ViewModelProvider( androidx.lifecycle.ViewModelStore store, androidx.lifecycle.ViewModelProvider.Factory factory, optional androidx.lifecycle.viewmodel.CreationExtras defaultCreationExtras ); --- + ctor public ViewModelProvider( androidx.lifecycle.ViewModelStore store, androidx.lifecycle.ViewModelProvider.Factory factory, androidx.lifecycle.viewmodel.CreationExtras defaultCreationExtras );
36. $ ./gradlew checkApi - ctor public ViewModelProvider( androidx.lifecycle.ViewModelStore store, androidx.lifecycle.ViewModelProvider.Factory factory, optional androidx.lifecycle.viewmodel.CreationExtras defaultCreationExtras ); --- + ctor public ViewModelProvider( androidx.lifecycle.ViewModelStore store, androidx.lifecycle.ViewModelProvider.Factory factory, androidx.lifecycle.viewmodel.CreationExtras defaultCreationExtras );
37. @JvmOverloads public ViewModelProvider(@NotNull ViewModelStore store, @NotNull Factory factory) @JvmOverloads public ViewModelProvider(@NotNull ViewModelStore store, @NotNull Factory factory, @NotNull CreationExtras defaultCreationExtras) // $FF: synthetic method public ViewModelProvider(ViewModelStore var1, Factory var2, CreationExtras var3, int var4, DefaultConstructorMarker var5)
38. @JvmOverloads public ViewModelProvider(@NotNull ViewModelStore store, @NotNull Factory factory) @JvmOverloads public ViewModelProvider(@NotNull ViewModelStore store, @NotNull Factory factory, @NotNull CreationExtras defaultCreationExtras) // $FF: synthetic method public ViewModelProvider(ViewModelStore var1, Factory var2, CreationExtras var3, int var4, DefaultConstructorMarker var5)
39. @JvmOverloads public ViewModelProvider(@NotNull ViewModelStore store, @NotNull Factory factory) @JvmOverloads public ViewModelProvider(@NotNull ViewModelStore store, @NotNull Factory factory, @NotNull CreationExtras defaultCreationExtras) // $FF: synthetic method public ViewModelProvider(ViewModelStore var1, Factory var2, CreationExtras var3, int var4, DefaultConstructorMarker var5)
40. KT-65945 JvmOverloads in common code does not generate Synthetic DefaultConstructorMarker constructor. https://youtrack.jetbrains.com/issue/KT-65945
41. open class ViewModelProvider { @JvmOverloads constructor(store: ViewModelStore, factory: Factory, extras: CreationExtras = Empty) }
42. open class ViewModelProvider { @JvmOverloads constructor(store: ViewModelStore, factory: Factory, extras: CreationExtras = Empty) companion object { @JvmStatic fun create( store: ViewModelStore, factory: Factory, extras: CreationExtras, ): ViewModelProvider = ViewModelProvider(store, factory, extras) } }
43. Learnings Just moving files to common, may change your public API.
44. open class ViewModelProvider { fun <T : ViewModel> get(key: String, modelClass: Class<T>): T }
45. open class ViewModelProvider { fun <T : ViewModel> get(key: String, modelClass: java.lang.Class<T>): T }
46. open class ViewModelProvider { fun <T : ViewModel> get(key: String, modelClass: Class<T>): T = get(key, modelClass.kotlin) fun <T : ViewModel> get(key: String, modelClass: KClass<T>): T }
47. Issue-328275985 error: reference to get is ambiguous when(viewModelProvider.get(any(), any())) .thenReturn(viewModel) both methods match: • <T#1>get(String,KClass<T#1>) • <T#2>get(String,Class<T#2>) https://issuetracker.google.com/328275985
48. Learnings Do not use mock.
49. open class ViewModelProvider { interface Factory { fun <T : ViewModel> create(modelClass: Class<T>, extras: CreationExtras): T } }
50. open class ViewModelProvider { interface Factory { fun <T : ViewModel> create(modelClass: java.lang.Class<T>, extras: CreationExtras): T } }
51. open class ViewModelProvider { interface Factory { fun <T : ViewModel> create(modelClass: Class<T>, extras: CreationExtras): T { throw UnsupportedOperationException() } fun <T : ViewModel> create(modelClass: KClass<T>, extras: CreationExtras): T { return create(modelClass.java, extras) } } }
52. Learnings Java types in an API may break backward compatibility.
53. open class ViewModelProvider { open class NewInstanceFactory : Factory {...} }
54. open class ViewModelProvider { open class NewInstanceFactory : Factory { override fun <T : ViewModel> create(modelClass: Class<T>, extras: CreationExtras): T { return try { modelClass.getDeclaredConstructor().newInstance() } catch (e: NoSuchMethodException) { throw RuntimeException("Cannot create an instance of $modelClass", e) } catch (e: InstantiationException) { throw RuntimeException("Cannot create an instance of $modelClass", e) } catch (e: IllegalAccessException) { throw RuntimeException("Cannot create an instance of $modelClass", e) } } } }
55. package kotlin.reflect.full fun <T : Any> KClass<T>.createInstance(): T {...}
56. Learnings Some APIs may not be worthy to implement in all platforms.
57. open class ViewModelProvider { open class AndroidViewModelFactory : NewInstanceFactory() {...} }
58. open class ViewModelProvider { open class AndroidViewModelFactory : NewInstanceFactory() { constructor(application: android.app.Application) } }
59. Learnings Not everything has to be commonized.
60. expect open class ViewModelProvider { @JvmOverloads constructor(store: ViewModelStore, factory: Factory, extras: CreationExtras) fun <T : ViewModel> get(key: String, modelClass: Class<T>): T interface Factory { fun <T : ViewModel> create(modelClass: Class<T>, extras: CreationExtras): T } open class NewInstanceFactory : Factory {...} open class AndroidViewModelFactory : NewInstanceFactory() {...} companion object {...} }
61. expect open class ViewModelProvider { @JvmOverloads constructor(store: ViewModelStore, factory: Factory, extras: CreationExtras) fun <T : ViewModel> get(key: String, modelClass: Class<T>): T interface Factory { fun <T : ViewModel> create(modelClass: Class<T>, extras: CreationExtras): T } open class NewInstanceFactory : Factory {...} open class AndroidViewModelFactory : NewInstanceFactory() {...} companion object {...} }
62. KT-20427 Allow expect declarations with a default implementation. https://youtrack.jetbrains.com/issue/KT-20427
63. $ find ~/lifecycle -name 'ViewModelProvider.*.kt'
64. $ find ~/lifecycle -name 'ViewModelProvider.*.kt' /ViewModelProvider.desktop.kt /ViewModelProvider.android.kt /ViewModelProvider.nonJvm.kt
65. actual open class ViewModelProvider { @JvmOverloads constructor(store: ViewModelStore, factory: Factory, extras: CreationExtras) fun <T : ViewModel> get(key: String, modelClass: KClass<T>): T }
66. actual open class ViewModelProvider private constructor( private val impl: ViewModelProviderImpl, ) { @JvmOverloads actual constructor( store: ViewModelStore, factory: Factory, defaultCreationExtras: CreationExtras = CreationExtras.Empty, ) : this(ViewModelProviderImpl(store, factory, defaultCreationExtras)) actual fun <T : ViewModel> get(modelClass: KClass<T>): T = impl.getViewModel(modelClass) }
67. internal class ViewModelProviderImpl(...) { @Suppress("UNCHECKED_CAST") internal fun <T : ViewModel> getViewModel( modelClass: KClass<T>, key: String = ViewModelProviders.getDefaultKey(modelClass), ): T { val viewModel = store[key] if (modelClass.isInstance(viewModel)) { // ... return viewModel as T } val modelExtras = MutableCreationExtras(defaultExtras) modelExtras[ViewModelProviders.ViewModelKey] = key return factory.create(modelClass, modelExtras) .also { vm -> store.put(key, vm) } } }
68. internal class ViewModelProviderImpl(...) { @Suppress("UNCHECKED_CAST") internal fun <T : ViewModel> getViewModel( modelClass: KClass<T>, key: String = ViewModelProviders.getDefaultKey(modelClass), ): T { val viewModel = store[key] if (modelClass.isInstance(viewModel)) { // ... return viewModel as T } val modelExtras = MutableCreationExtras(defaultExtras) modelExtras[ViewModelProviders.ViewModelKey] = key return factory.create(modelClass, modelExtras) .also { vm -> store.put(key, vm) } } }
69. Issue-341792251 The migration (...) reverted a 2 year old fix to an issue that had to do with desugaring for compileOnly dependencies in a library project. Fixed on Lifecycle 2.8.2 https://issuetracker.google.com/341792251
70. internal class ViewModelProviderImpl(...) { @Suppress("UNCHECKED_CAST") internal fun <T : ViewModel> getViewModel( modelClass: KClass<T>, key: String = ViewModelProviders.getDefaultKey(modelClass), ): T { val viewModel = store[key] if (modelClass.isInstance(viewModel)) { // ... return viewModel as T } val modelExtras = MutableCreationExtras(defaultExtras) modelExtras[ViewModelProviders.ViewModelKey] = key return factory.create(modelClass, modelExtras) .also { vm -> store.put(key, vm) } } }
71. internal class ViewModelProviderImpl(...) { @Suppress("UNCHECKED_CAST") internal fun <T : ViewModel> getViewModel( modelClass: KClass<T>, key: String = ViewModelProviders.getDefaultKey(modelClass), ): T { val viewModel = store[key] if (modelClass.isInstance(viewModel)) { // ... return viewModel as T } val modelExtras = MutableCreationExtras(defaultExtras) modelExtras[ViewModelProviders.ViewModelKey] = key return createViewModel(factory, modelClass, modelExtras) .also { vm -> store.put(key, vm) } } }
72. internal expect fun <VM : ViewModel> createViewModel( factory: ViewModelProvider.Factory, modelClass: KClass<VM>, extras: CreationExtras, ): VM
73. internal actual fun <VM : ViewModel> createViewModel( factory: ViewModelProvider.Factory, modelClass: KClass<VM>, extras: CreationExtras ): VM = factory.create(modelClass, extras)
74. internal actual fun <VM : ViewModel> createViewModel( factory: ViewModelProvider.Factory, modelClass: KClass<VM>, extras: CreationExtras ): VM { // Android targets using `compileOnly` dependencies may encounter AGP desugaring // issues where `Factory.create` throws an `AbstractMethodError`. This is resolved by an // Android-specific implementation that first attempts all `ViewModelProvider.Factory.create` // method overloads before allowing the exception to propagate. // (See b/230454566 and b/341792251 for more details). return try { factory.create(modelClass, extras) } catch (e: AbstractMethodError) { try { factory.create(modelClass.java, extras) } catch (e: AbstractMethodError) { factory.create(modelClass.java) } } }
75. ViewModelProvider desktop ViewModelProvider android ViewModelProvider nonJvm
76. ViewModelProvider desktop ViewModelProvider android ViewModelProvider nonJvm ViewModelProviderImpl
77. ViewModelProvider desktop ViewModelProvider android ViewModelProvider nonJvm ViewModelProviderImpl createViewModel android createViewModel desktop createViewModel nonJvm
78. Learnings Expect classes can not have default implementations.
79. Learnings Desugaring and minification may cause unexpected side effects. Expect classes can not have default implementations.
80. Learnings Desugaring and minification may cause unexpected side effects. Expect classes can not have default implementations. Mix and match expect/actual with common code for reusability.
81. ViewModel class
82. abstract class ViewModel { constructor() protected open fun onCleared() internal fun clear() fun addCloseable(closeable: Closeable) fun addCloseable(key: String, closeable: Closeable) fun <T : Closeable> getCloseable(key: String): T? } val ViewModel.viewModelScope: CoroutineScope
83. abstract class ViewModel { constructor() protected open fun onCleared() internal fun clear() fun addCloseable(closeable: Closeable) fun addCloseable(key: String, closeable: Closeable) fun <T : Closeable> getCloseable(key: String): T? } val ViewModel.viewModelScope: CoroutineScope
84. abstract class ViewModel { constructor() protected open fun onCleared() internal fun clear() fun addCloseable(closeable: Closeable) fun addCloseable(key: String, closeable: Closeable) fun <T : Closeable> getCloseable(key: String): T? } val ViewModel.viewModelScope: CoroutineScope
85. abstract class ViewModel { fun addCloseable(closeable: Closeable) fun addCloseable(key: String, closeable: Closeable) fun <T : Closeable> getCloseable(key: String): T? }
86. abstract class ViewModel { fun addCloseable(closeable: java.io.Closeable) fun addCloseable(key: String, closeable: java.io.Closeable) fun <T : java.io.Closeable> getCloseable(key: String): T? }
87. abstract class ViewModel { @Deprecated("Replaced by `AutoCloseable` overload.", DeprecationLevel.HIDDEN) fun addCloseable(closeable: java.io.Closeable) fun addCloseable(closeable: kotlin.AutoCloseable) fun addCloseable(key: String, closeable: kotlin.AutoCloseable) fun <T : kotlin.AutoCloseable> getCloseable(key: String): T? }
88. abstract class ViewModel { @Deprecated("Replaced by `AutoCloseable` overload.", DeprecationLevel.HIDDEN) fun addCloseable(closeable: java.io.Closeable) fun addCloseable(closeable: kotlin.AutoCloseable) fun addCloseable(key: String, closeable: kotlin.AutoCloseable) fun <T : kotlin.AutoCloseable> getCloseable(key: String): T? }
89. $ find ~/lifecycle -name 'ViewModel.*.kt'
90. $ find ~/lifecycle -name 'ViewModel.*.kt' /ViewModel.jvm.kt /ViewModel.nonJvm.kt
91. actual abstract class ViewModel { private val impl: ViewModelImpl = ViewModelImpl() actual fun addCloseable(key: String, closeable: AutoCloseable) { impl.addCloseable(key, closeable) } actual fun <T : AutoCloseable> getCloseable(key: String): T? = impl.getCloseable(key) }
92. internal class ViewModelImpl { private val lock = SynchronizedObject() private val keyToCloseables = mutableMapOf<String, AutoCloseable>() private var isCleared = false fun addCloseable(key: String, closeable: AutoCloseable) { // Although no logic should be done after user calls onCleared(), we will // ensure that if it has already been called, the closeable attempting to // be added will be closed immediately to ensure there will be no leaks. if (isCleared) { closeWithRuntimeException(closeable) return } val oldCloseable = synchronized(lock) { keyToCloseables.put(key, closeable) } closeWithRuntimeException(oldCloseable) } /** @see [ViewModel.getCloseable] */ fun <T : AutoCloseable> getCloseable(key: String): T? = @Suppress("UNCHECKED_CAST") synchronized(lock) { keyToCloseables[key] as T? } }
93. internal class ViewModelImpl { private val lock = SynchronizedObject() private val keyToCloseables = mutableMapOf<String, AutoCloseable>() private var isCleared = false fun addCloseable(key: String, closeable: AutoCloseable) { // Although no logic should be done after user calls onCleared(), we will // ensure that if it has already been called, the closeable attempting to // be added will be closed immediately to ensure there will be no leaks. if (isCleared) { closeWithRuntimeException(closeable) return } val oldCloseable = synchronized(lock) { keyToCloseables.put(key, closeable) } closeWithRuntimeException(oldCloseable) } /** @see [ViewModel.getCloseable] */ fun <T : AutoCloseable> getCloseable(key: String): T? = @Suppress("UNCHECKED_CAST") synchronized(lock) { keyToCloseables[key] as T? } }
96. // common.SynchronizedObject.kt internal expect class SynchronizedObject() internal inline fun <T> synchronized(lock: SynchronizedObject, crossinline action: () -> T): T { contract { callsInPlace(action, InvocationKind.EXACTLY_ONCE) } return synchronizedImpl(lock, action) } internal expect inline fun <T> synchronizedImpl( lock: SynchronizedObject, crossinline action: () -> T, ): T
97. // common.SynchronizedObject.kt internal expect class SynchronizedObject() internal inline fun <T> synchronized(lock: SynchronizedObject, crossinline action: () -> T): T { contract { callsInPlace(action, InvocationKind.EXACTLY_ONCE) } return synchronizedImpl(lock, action) } internal expect inline fun <T> synchronizedImpl( lock: SynchronizedObject, crossinline action: () -> T, ): T
98. KT-29963 It's not possible to specify a contract for an expect function. https://youtrack.jetbrains.com/issue/KT-29963
99. // jvm.SynchronizedObject.kt internal actual class SynchronizedObject actual constructor() internal actual inline fun <T> synchronizedImpl( lock: SynchronizedObject, crossinline action: () -> T ): T = kotlin.synchronized(lock, action)
100. // native.SynchronizedObject.kt internal expect val PTHREAD_MUTEX_RECURSIVE: Int internal actual class SynchronizedObject actual constructor() {...} internal actual inline fun <T> synchronizedImpl( lock: SynchronizedObject, crossinline action: () -> T ): T { lock.lock() return try { action() } finally { lock.unlock() } }
101. // native.SynchronizedObject.kt internal expect val PTHREAD_MUTEX_RECURSIVE: Int internal actual class SynchronizedObject actual constructor() {...}
102. // native.SynchronizedObject.kt internal expect val PTHREAD_MUTEX_RECURSIVE: Int internal actual class SynchronizedObject actual constructor() { private val resource = Resource() private val cleaner = createCleaner(resource, Resource::dispose) fun lock() {...} fun unlock() {...} @OptIn(ExperimentalForeignApi::class) private class Resource {...} }
103. Learnings You may need to learn native APIs.
104. // native.SynchronizedObject.kt internal expect val PTHREAD_MUTEX_RECURSIVE: Int internal actual class SynchronizedObject actual constructor() { private val resource = Resource() @OptIn(ExperimentalStdlibApi::class) private val cleaner = createCleaner(resource, Resource::dispose) fun lock() {...} fun unlock() {...} @OptIn(ExperimentalForeignApi::class) private class Resource {...} }
105. KT-41509 Commonize numeric types with different bit width. https://youtrack.jetbrains.com/issue/KT-41509
106. // native.SynchronizedObject.kt internal expect val PTHREAD_MUTEX_RECURSIVE: Int // Lock.darwin.kt internal actual val PTHREAD_MUTEX_RECURSIVE: Int = platform.posix.PTHREAD_MUTEX_RECURSIVE // Lock.linux.kt internal actual val PTHREAD_MUTEX_RECURSIVE: Int = platform.posix.PTHREAD_MUTEX_RECURSIVE.toInt()
107. val ViewModel.viewModelScope: CoroutineScope get() = synchronized(VIEW_MODEL_SCOPE_LOCK) { var scope = getCloseable(VIEW_MODEL_SCOPE_KEY) if (scope == null) { scope = CloseableCoroutineScope(Dispatchers.Main.immediate + SupervisorJob()) addCloseable(VIEW_MODEL_SCOPE_KEY, scope) } scope } class CloseableCoroutineScope constructor( override val coroutineContext: CoroutineContext, ) : AutoCloseable, CoroutineScope { override fun close() = coroutineContext.cancel() }
108. val ViewModel.viewModelScope: CoroutineScope get() = synchronized(VIEW_MODEL_SCOPE_LOCK) { var scope = getCloseable(VIEW_MODEL_SCOPE_KEY) if (scope == null) { scope = CloseableCoroutineScope(Dispatchers.Main.immediate + SupervisorJob()) addCloseable(VIEW_MODEL_SCOPE_KEY, scope) } scope } class CloseableCoroutineScope constructor( override val coroutineContext: CoroutineContext, ) : AutoCloseable, CoroutineScope { override fun close() = coroutineContext.cancel() }
109. val ViewModel.viewModelScope: CoroutineScope get() = synchronized(VIEW_MODEL_SCOPE_LOCK) { var scope = getCloseable(VIEW_MODEL_SCOPE_KEY) if (scope == null) { scope = CloseableCoroutineScope(Dispatchers.Main.immediate + SupervisorJob()) addCloseable(VIEW_MODEL_SCOPE_KEY, scope) } scope } class CloseableCoroutineScope constructor( override val coroutineContext: CoroutineContext, ) : AutoCloseable, CoroutineScope { override fun close() = coroutineContext.cancel() }
110. val ViewModel.viewModelScope: CoroutineScope get() = synchronized(VIEW_MODEL_SCOPE_LOCK) { var scope = getCloseable(VIEW_MODEL_SCOPE_KEY) if (scope == null) { scope = CloseableCoroutineScope(Dispatchers.Main.immediate + SupervisorJob()) addCloseable(VIEW_MODEL_SCOPE_KEY, scope) } scope } class CloseableCoroutineScope constructor( override val coroutineContext: CoroutineContext, ) : AutoCloseable, CoroutineScope { override fun close() = coroutineContext.cancel() }
111. val ViewModel.viewModelScope: CoroutineScope get() = synchronized(VIEW_MODEL_SCOPE_LOCK) { var scope = getCloseable(VIEW_MODEL_SCOPE_KEY) if (scope == null) { scope = createViewModelScope() addCloseable(VIEW_MODEL_SCOPE_KEY, scope) } scope } class CloseableCoroutineScope constructor( override val coroutineContext: CoroutineContext, ) : AutoCloseable, CoroutineScope { override fun close() = coroutineContext.cancel() }
112. fun createViewModelScope(): CloseableCoroutineScope { val dispatcher = try { // In platforms where `Dispatchers.Main` is not available, Kotlin Multiplatform // will throw an exception (the specific exception type may depend on the platform). // Since there's no direct functional alternative, we use `EmptyCoroutineContext` to // ensure that a coroutine launched within this scope will run in the same context // as the caller. Dispatchers.Main.immediate } catch (_: NotImplementedError) { // In Native environments where `Dispatchers.Main` might not exist: EmptyCoroutineContext } catch (_: IllegalStateException) { // In JVM Desktop environments where `Dispatchers.Main` might not exist: EmptyCoroutineContext } return CloseableCoroutineScope(coroutineContext = dispatcher + SupervisorJob()) }
113. fun createViewModelScope(): CloseableCoroutineScope { val dispatcher = try { // In platforms where `Dispatchers.Main` is not available, Kotlin Multiplatform // will throw an exception (the specific exception type may depend on the platform). // Since there's no direct functional alternative, we use `EmptyCoroutineContext` to // ensure that a coroutine launched within this scope will run in the same context // as the caller. Dispatchers.Main.immediate } catch (_: NotImplementedError) { // In Native environments where `Dispatchers.Main` might not exist: EmptyCoroutineContext } catch (_: IllegalStateException) { // In JVM Desktop environments where `Dispatchers.Main` might not exist: EmptyCoroutineContext } return CloseableCoroutineScope(coroutineContext = dispatcher + SupervisorJob()) }
114. fun createViewModelScope(): CloseableCoroutineScope { val dispatcher = try { // In platforms where `Dispatchers.Main` is not available, Kotlin Multiplatform // will throw an exception (the specific exception type may depend on the platform). // Since there's no direct functional alternative, we use `EmptyCoroutineContext` to // ensure that a coroutine launched within this scope will run in the same context // as the caller. Dispatchers.Main.immediate } catch (_: NotImplementedError) { // In Native environments where `Dispatchers.Main` might not exist: EmptyCoroutineContext } catch (_: IllegalStateException) { // In JVM Desktop environments where `Dispatchers.Main` might not exist: EmptyCoroutineContext } return CloseableCoroutineScope(coroutineContext = dispatcher + SupervisorJob()) }
115. fun createViewModelScope(): CloseableCoroutineScope { val dispatcher = try { // In platforms where `Dispatchers.Main` is not available, Kotlin Multiplatform // will throw an exception (the specific exception type may depend on the platform). // Since there's no direct functional alternative, we use `EmptyCoroutineContext` to // ensure that a coroutine launched within this scope will run in the same context // as the caller. Dispatchers.Main.immediate } catch (_: NotImplementedError) { // In Native environments where `Dispatchers.Main` might not exist: EmptyCoroutineContext } catch (_: IllegalStateException) { // In JVM Desktop environments where `Dispatchers.Main` might not exist: EmptyCoroutineContext } return CloseableCoroutineScope(coroutineContext = dispatcher + SupervisorJob()) }
116. fun createViewModelScope(): CloseableCoroutineScope { val dispatcher = try { // In platforms where `Dispatchers.Main` is not available, Kotlin Multiplatform // will throw an exception (the specific exception type may depend on the platform). // Since there's no direct functional alternative, we use `EmptyCoroutineContext` to // ensure that a coroutine launched within this scope will run in the same context // as the caller. Dispatchers.Main.immediate } catch (_: NotImplementedError) { // In Native environments where `Dispatchers.Main` might not exist: EmptyCoroutineContext } catch (_: IllegalStateException) { // In JVM Desktop environments where `Dispatchers.Main` might not exist: EmptyCoroutineContext } return CloseableCoroutineScope(coroutineContext = dispatcher + SupervisorJob()) }
117. Learnings Not everything has to use expect/actual declaration.
118. Three key takeaways
119. Three key takeaways Minimal changes vs Best possible common API
120. Three key takeaways Minimal changes vs Best possible common API Reuse your knowledge
121. Three key takeaways Minimal changes vs Best possible common API Reuse your knowledge Kotlin Multiplatform is Powerful
122. Thank you Feedback?