Lich Android Libraries

AutoResetLifecycleScope is a safer alternative to AndroidX lifecycleScope. While lifecycleScope coroutines are only cancelled when the Lifecycle is DESTROYED, AutoResetLifecycleScope can be configured to automatically cancel coroutines when the Lifecycle is STOPPED (using ResetPolicy.ON_STOP).

This prevents resource leaks common when using lifecycleScope.launchWhenStarted to collect Flows, as those coroutines remain active even when the Lifecycle is stopped.

Key behaviors:

• Bound to Dispatchers.Main.
• Cancelled when the Lifecycle is DESTROYED.
• Automatically cancelled when the Lifecycle is STOPPED if ResetPolicy.ON_STOP is used.
• Note: When using in a Fragment, do not use viewLifecycleOwner; use the Fragment instance itself.

class FooFragment : Fragment() {

    // Any coroutines launched from this scope are automatically cancelled when FooFragment is STOPPED.
    // NOTE: Don't use `viewLifecycleOwner` here.
    private val autoResetLifecycleScope: CoroutineScope = AutoResetLifecycleScope(this)

    // A repository that provides some data as a Flow.
    private val fooRepository = FooRepository()

    override fun onStart() {
        super.onStart()

        // It is SAFE to collect a flow with AutoResetLifecycleScope.
        // The coroutine launched here will be automatically cancelled just before `FooFragment.onStop()`.
        autoResetLifecycleScope.launch {
            fooRepository.dataFlow().collect { value ->
                textView.text = value
            }
        }
    }
}

If two components depend on each other (e.g., ComponentX needs ComponentY and vice versa), direct instantiation in the constructor will cause a circular dependency error.

To resolve this, use lazy acquisition by using the by context.component(Type) property delegate instead of calling context.getComponent(Type) inside the constructor. This defers the resolution of the dependency until it is actually accessed.

class ComponentX(context: Context) {
    // Use 'by context.component' for lazy resolution
    private val componentY by context.component(ComponentY)

    companion object : ComponentFactory<ComponentX>() {
        override fun createComponent(context: Context): ComponentX = ComponentX(context)
    }
}

class ComponentY(context: Context) {
    private val componentX by context.component(ComponentX)

    companion object : ComponentFactory<ComponentY>() {
        override fun createComponent(context: Context): ComponentY = ComponentY(context)
    }
}

In multi-module projects where a 'base' module needs to access features in a 'foo' module without a direct dependency, you can use the Facade pattern combined with delegateCreation().

1. Define a Facade interface in the 'base' module.
2. In the 'base' module's ComponentFactory, use delegateCreation(context, "full.package.path.ToFactory") to point to the implementation factory.
3. In the 'foo' module, implement a class that inherits from DelegatedComponentFactory with a public empty constructor. This class is responsible for instantiating the actual implementation.

// "base" module
interface FooModuleFacade {
    fun launchFooActivity()

    companion object : ComponentFactory<FooModuleFacade>() {
        override fun createComponent(context: Context): FooModuleFacade =
            delegateCreation(context, "module.foo.FooModuleFacadeFactory")
    }
}

// "foo" module
class FooModuleFacadeFactory: DelegatedComponentFactory<FooModuleFacade>() {
    override fun createComponent(context: Context): FooModuleFacade = 
        FooModuleFacadeImpl(context)
}

internal class FooModuleFacadeImpl(private val context: Context) : FooModuleFacade {
    override fun launchFooActivity() { /* ... */ }
}

Lich can automatically generate ViewModelArgs classes to handle the boilerplate of initializing a SavedStateHandle from a Bundle.

1. Annotate your ViewModel

Use @GenerateArgs on the ViewModel class and @Argument on the properties you want included in the generated arguments class.

@GenerateArgs
class FooViewModel(savedStateHandle: SavedStateHandle) : ViewModel() {

    @Argument
    private val userName: String by savedStateHandle.required()

    @Argument(isOptional = true)
    private val tags: Array<String> by savedStateHandle.initial(arrayOf("normal"))

    @Argument
    private var attachment: Parcelable? by savedStateHandle

    @Argument
    private val message: MutableLiveData<CharSequence> by savedStateHandle.liveData()
}

2. Use the generated class

The compiler generates a class (e.g., FooViewModelArgs) that implements ViewModelArgs. You can use this to pass arguments to a Fragment or Activity.