skywall

@Module
class DatabaseModule {

    @Provides
    fun database(application: Application) : Database {
        return Database(application)
    }
}

skywall

interface DatabaseContract {
    fun database(): Database
}

skywall

@Singleton
@Component(
    modules = [
        CoreModule::class,
        DatabaseModule::class,
        NetworkModule::class
    ]
)
interface CoreComponent : DatabaseContract, NetworkContract {

skywall

object CoreComponentHolder {

    private object Component : SingletonHolder<CoreComponent, Application>({ application ->
        DaggerCoreComponent.factory().create(application)
    })

    fun getInstance(application: Application): CoreComponent {
        return Component.getInstance(application)
    }
}

skywall

open class SingletonHolder<out T, in A>(private val constructor: (A) -> T) {

    @Volatile private var instance: T? = null

    fun getInstance(arg: A): T {
        return when {
            instance != null -> instance!!
            else -> synchronized(this) {
                if (instance == null) {
                    instance = constructor(arg)

skywall

@HomeScope
@Component(
    modules = [
        HomeModule::class
    ],
    dependencies = [
        CoreComponent::class
    ]
)
interface HomeComponent {

skywall

abstract class BaseFragment : Fragment() {

    private object ModuleComponent : SingletonHolder<HomeComponent, Context>({ context ->
        DaggerHomeComponent
            .factory()
            .create(CoreComponentHolder.getInstance(context.applicationContext as App))
    })

    val homeComponent: HomeComponent
        get() = ModuleComponent.getInstance(requireContext())

skywall

class HomeFragment : BaseFragment(), HomeView {

    @Inject lateinit var homeAdapter: HomeAdapter                   // :home
    @Inject lateinit var sharedPreferences: SharedPreferences       // :core
    @Inject lateinit var apiService: ApiService                     // :network
    @Inject lateinit var dummyRepository: DummyRepository           // :home - constructor provided
    @Inject lateinit var homeDummyRepository: HomeDummyRepository   // :home - component provided

    override fun inject() {
        homeComponent.plus(HomeFragmentModule(this)).inject(this)

skywall

@Subcomponent(
    modules = [HomeFragmentModule::class]
)
interface HomeFragmentComponent {

    fun inject(homeFragment: HomeFragment)
}

@Module
class HomeFragmentModule(private val homeFragment: HomeFragment) {

skywall

enum class TicketType(val coins: Int) {
    ADULT(2),
    CHILD(1),
}

class Printer(
    private val display: Display,
) {
    fun printTicket(selectedTicketType: TicketType) {
        display.show("Ticket printed: ${selectedTicketType.name}")