Clarification on retaining RootComponent

[YektaDev]

Hi!
The documentation page for Retained components is filled with warnings (quite scary!), so I want to confirm my understanding is correct.

Is the following accurate?

1. The only reason for discouraging the retention of the RootComponent (and thus the entire component tree) is to avoid potential memory leaks of Activity and Fragment instances.
2. In a single-activity application (MainActivity: ComponentActivity + no Fragments), if the components can guarantee (by contract) that they hold no direct or indirect references to the Activity or Context, then the best course of action would be to wrap the RootComponent in retainedComponent {...}, in which case, instance retaining is effectively "solved" for the entire component tree, making InstanceKeeper and its further usage fully unnecessary for all child components.

[arkivanov]

1. That's not the only reason. The other possible reason is inability to inject Activity-scoped dependencies. E.g. it's usually convenient to request runtime permission from a component. You can create your own PermissionRequester interface, inject into a component and then cover the permission flow with simple unit tests.
2. Yes, correct.

[duongphuhiep]

• In a single-activity application, I retained the whole RootComponent tree.
• Activity-scoped dependencies used the below ActivityHolder instead of the actual Activity.
  • The ActivityHolder keep track of the actual activity and holds a weak reference to it.

Is it a good pattern? or else how you usually inject (provides) Activity-scoped dependencies to the component?

/**
 * Holds a weak reference to the current (Main) Activity.
 */
object ActivityHolder {
    private var activityRef: WeakReference<ComponentActivity>? = null

    val current: ComponentActivity?
        get() = activityRef?.get()

    fun set(activity: ComponentActivity?) {
        activityRef = activity?.let { WeakReference(it) }
    }
}

class MainActivity : ComponentActivity() {
   override fun onResume() {
        super.onResume()
        ActivityHolder.set(this)
    }

    override fun onPause() {
        super.onPause()
        ActivityHolder.set(null)
    }
}

[arkivanov]

Yes, this should work. Though, you can scope ActivityHolder in InstanceKeeper in your Activity. In this case you don't need to clear the activityRef and can make it a normal strong reference.

One thing to keep in mind is that it's still possible to subscribe to Activity#lifecycle or launch coroutines in Activity#lifecycleScope, and also it's still possible to accidentally capture a reference of the Activity instance somewhere. This may cause memory leaks.

Another possible concern is that you might need to listen for Activity changes, e.g. to re-register for Activity results, etc.