Reasons not to use InstanceKeeper for everything?

[Burtan]

Hi,

I considered Decompose components to be similar to ViewModels in Android. They contain the logic and expose a state to the ui component. Interestingly ViewModels are preserved during Android state changes, but components are not. To achieve the same behavior for components you have to use instanceKeeper.

Why not make components be preserved during state changes by default? I don't really see a case where you don't want that. Using instanceKeeper as an additional layer adds a lot of boiler plate, as you have to copy all exposed functions and state variables.

I think a lot of my components will be similar to this:

class ExampleComponent(
    context: ComponentContext
) : ExampleInterface, ComponentContext by context { // ExampleInterface by exampleInstance would be nice!!

  private val exampleInstance = instanceKeeper.getOrCreate(::ExampleInstance)
  (interface implementation delegated to exampleInstance)

  private class ExampleInstance : InstanceKeeper.Instance, ExampleInterface {
    (interface implementation)
  }

}

[arkivanov]

I considered Decompose components to be similar to ViewModels in Android.

Please don't :-) Decompose components are close to Android fragments. The reason is the ability to pass Context/Resources/etc (and anything else that depends on that) via constructors. This is not possible with ViewModels only, which is a significant limitation.

[georgiscoolman]

Sad to hear it. In my opinion save components from configuration changes gives more props than passing activity/fragment context via component constructor. In android we can only provide Application context in ViewModel constructor and it is more than enough in most cases. Will be great if components will have same lifecycle that android ViewModels.

P.S You made really nice library and here is only one point that stop me to using it.

[arkivanov]

Well, that's the recommended approach. But Decompose is flexible enough, so if you really-really want it, here is an example.

class MainActivity : AppCompatActivity() {

    private lateinit var rootViewModel: RootViewModel

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        rootViewModel =
            rootViewModelFactory(
                savedState = savedInstanceState?.getParcelable(KEY_SAVED_STATE) as ParcelableContainer?,
            ).create(RootViewModel::class.java, CreationExtras.Empty)

        rootViewModel.lifecycle.create()

        onBackPressedDispatcher.addCallback(rootViewModel.backDispatcher.newOnBackPressedCallback())

        setContent {
            MaterialTheme {
                Surface(color = MaterialTheme.colors.background) {
                    RootContent(component = rootViewModel.root, modifier = Modifier.fillMaxSize())
                }
            }
        }
    }

    override fun onStart() {
        super.onStart()

        rootViewModel.lifecycle.start()
    }

    override fun onResume() {
        super.onResume()

        rootViewModel.lifecycle.resume()
    }

    override fun onPause() {
        if (!isChangingConfigurations) {
            rootViewModel.lifecycle.pause()
        }

        super.onPause()
    }

    override fun onStop() {
        if (!isChangingConfigurations) {
            rootViewModel.lifecycle.stop()
        }

        super.onStop()
    }

    override fun onDestroy() {
        if (!isChangingConfigurations) {
            rootViewModel.lifecycle.destroy()
        }

        super.onDestroy()
    }

    override fun onSaveInstanceState(outState: Bundle) {
        super.onSaveInstanceState(outState)
        outState.putParcelable(KEY_SAVED_STATE, rootViewModel.stateKeeper.save())
    }

    private companion object {
        private const val KEY_SAVED_STATE = "SAVED_STATE"
    }
}

private fun rootViewModelFactory(savedState: ParcelableContainer?): ViewModelProvider.Factory =
    viewModelFactory {
        initializer<RootViewModel> {
            RootViewModel(savedState = savedState)
        }
    }

class RootViewModel(savedState: ParcelableContainer?) : ViewModel() {
    val lifecycle = LifecycleRegistry()
    val stateKeeper = StateKeeperDispatcher(savedState)
    val backDispatcher = RootBackDispatcher()

    private val componentContext =
        DefaultComponentContext(
            lifecycle = lifecycle,
            stateKeeper = stateKeeper,
            backHandler = backDispatcher,
        )

    val root = DefaultRootComponent(componentContext = componentContext)
}

class RootBackDispatcher : BackHandler {
    private val dispatcher = BackDispatcher()
    private val registeredCallbacks = HashSet<BackCallback>()
    private val onCallbackEnabledChangedListener: (Boolean) -> Unit = { updateEnabledState() }
    private val isEnabled: Boolean get() = registeredCallbacks.any { it.isEnabled }
    private var onBackPressedCallback: OnBackPressedCallback? = null

    override fun register(callback: BackCallback) {
        dispatcher.register(callback)
        registeredCallbacks += callback
        callback.addEnabledChangedListener(onCallbackEnabledChangedListener)
    }

    override fun unregister(callback: BackCallback) {
        dispatcher.unregister(callback)
        registeredCallbacks -= callback
        callback.removeEnabledChangedListener(onCallbackEnabledChangedListener)
    }

    private fun updateEnabledState() {
        onBackPressedCallback?.isEnabled = isEnabled
    }

    fun newOnBackPressedCallback(): OnBackPressedCallback =
        object : OnBackPressedCallback(isEnabled) {
            override fun handleOnBackPressed() {
                dispatcher.back()
            }
        }.also { onBackPressedCallback = it }
}

[arkivanov]

Decompose v2.1.0-alpha-03 now offers retainedComponent extensions for Android. See the updated docs.

[Burtan]

Using the following code you can have way less boiler plate when using Instances.

class HistoryComponent(
    ctx: ComponentContext,
    historyInstance: HistoryInstance = ctx.instanceKeeper.getOrCreate { HistoryInstance() }
) : HistoryInterface by historyInstance, ComponentContext by ctx

class HistoryInstance() : HistoryInterface, InstanceKeeper.Instance