andrewchupin/kitten

Kotlin DI fast and safe library

Kitten

Kotlin DI fast and safe library

Why?

This library fit to small and espesially huge projects. You can use it for multimodule Kotlin/Java project.

Advantages of this libraries:

• Lightweight - the entire library takes only 5 KB space
• Fast - this library doesn't use Codegen or Reflection, only your code
• Api/Core Modules - you can connect super-lightweight api module to feature libraries, and core module for main library
• Safe - unlike Dagger 2, kodin or koin you have to write all implmentation of objects, but API of this library really short
• Simple - it's probably takes less code than Dagger 2
• Lifecycle Management - there are a lot of helpers in library to mange lifecyle of components/deps set/dep

How to make module system?

Commonly you don't have to create a lot of modules in your application, especially if you are using Gradle.
Try to create modules like a group of features. If some screen/parts are using in several modules, you can move it to common module.
Eventially your module system should looks like this.

Guide

1. Add ":core" dependency to your Main Library (Application Entrypoint)

implementation("io.github.andrewchupin:core:1.1.0")

2. Add ":api" dependency to your Secondary Modules (Feature Entrypoint)

implementation("io.github.andrewchupin:api:1.1.0")
// or with android helpers
implementation("io.github.andrewchupin:android:1.1.0")

3. Create some dependecies

// Dependencies
class Seed(num: Int)
class Network(seed: Seed)

// Dependency with interface
interface ServiceRepo
class ServiceRepoImpl(application: Application, net: Network) : ServiceRepo

// Feature deps
class FooData
class FooRepo(val id: FooData, val net: Network)
class FooFeature(val repo: FooRepo, val serviceRepo: ServiceRepo)

4. Create some components in Main Module

// Main Component
class AppComponent(
    val service: Service,
): Component {
    interface Net {
        val seed: Seed
        val network: Network
    }

    interface Service {
        val net: Net
        val repo: ServiceRepo
    }
}

// Feature Component (have to provide something)
interface FooComponent : Component {
    val service: AppComponent.Service
    val repo: FooRepo
}

5. Create Component Provider in Main Module

class AppComponentProvider(
    private val application: Application
) : ComponentProvider() {

    fun getFoo(id: FooData): FooComponent {
        return getOrCreate(id) {
            object : FooComponent {
                override val service = app.service
                override val repo by depRc { FooRepo(id, service.net.network) }
            }
        }
    }

    val app get() = getOrCreate {
        AppComponent(
            object : AppComponent.Service {
                override val net = object : AppComponent.Net {
                    private val num = 12 // with component
                    override val seed by depLazy { Seed(num) } // lazy
                    override val network by depLazy { Network(seed) } // lazy
                }

                override val repo by depRc { ServiceRepoImpl(application, net.network) } // ref-counter
            }
        )
    }
}

6. Create Injector in each Secondary Module

interface ManDelegate {
    fun provideFoo(data: FooData): FooFeature
    fun provideBar(data: FooData): BarFeature
}

object ModInjector : Injector<ManDelegate>()

7. Init Injector in Main Module

class Application {

    fun onCreate() {
        Kitten.init(
            provider = AppComponentProvider(this)
        ) {  deps ->
            // Create deps and component immediately
            create { deps.app }

            // Init delegate without deps and components
            register(ModInjector) {
                object : ManDelegate {
                    private fun component(data: FooData) = deps.getFoo(data)
                    override fun provideFoo(data: FooData) = FooFeature(component(data).repo, deps.app.service.repo)
                    override fun provideBar(data: FooData): BarFeature = BarFeature(component(data).service.repo)
                }
            }
        }
    }
}

8. Get your dependencies in each Secondary Module

class FooFragment : ComponentLifecycle {
    // View
    fun onAttach() {
        val feature = ModInjector.injectWith(this) { provideFoo(FooData()) }
        // or short example
        val feature1 = ModInjector.inject { provideFoo(FooData()) }
        // or viewModel short example
        val viewModel = ModInjector.viewModelLegacy { provideBar(FooData()) }
    }
    
    // Compose
    @Composable
    fun Content() {
        val feature = ModInjector.injectWith(this) { provideBar(FooData()) }
        // or short example
        val feature1 = ModInjector.inject { provideBar(FooData()) }
        // or viewModel short example
        val viewModel = ModInjector.viewModel { provideBar(FooData()) }
    }
}