Simple, powerful, and lightweight dependency injector allowing usage without extra files. Supports various scopes, environments, runtime arguments, and interface injections. Ideal for Android, iOS, JVM, and JS development.
Surfaced from shared tags and platforms — no rankings paid for.
PopKorn is a simple, powerful and lightweight Kotlin Multiplatform Dependency Injector. It doesn't need any modules or components, just use it without writing a single extra file! It supports AND, IOS, JVM, JS and NATIVE.
Get it with Gradle:
implementation 'cc.popkorn:popkorn:2.3.1'
kapt 'cc.popkorn:popkorn-compiler:2.3.1'
The Kotlin Gradle Plugin 1.4.0 will automatically resolve platform dependent implementations (jvm, js, iosX64...). But if you are using Kotlin Gradle Plugin below 1.4.0 you will have to specify the platform yourself. In the case of Android/JVM is the following:
implementation 'cc.popkorn:popkorn-jvm:2.3.1'
kapt 'cc.popkorn:popkorn-compiler:2.3.1'
Scopes are the way to define the life span of an instance. There are 4 types of scopes:
Environments allow you to have multiple instances of the same object, but in a complete different configuration. For example, you can have 2 different and persistent Retrofit instances. See more examples at bottom.
val r1 = inject<Retrofit>("pro") // This will inject a persistent instance of Retrofit attached to "pro"
val r2 = inject<Retrofit>("des") // This will inject a persistent instance of Retrofit attached to "des"
// r1 !== r2 as they have different environments.
Just add @Injectable to any class...
@Injectable
class HelloWorld
...and inject it anywhere you want:
val helloWorld = inject<HelloWorld>()
// Or by lazy
val helloWorld by popkorn<HelloWorld>()
By default HelloWorld will be Scope.BY_APP, but we can change it:
@Injectable(scope = Scope.BY_NEW)
class HelloWorld
Also, if HelloWorld has injectable constructor dependencies, PopKorn will automatically resolve them
@Injectable
class HelloWorld(val helloBarcelona: HelloBarcelona, val helloParis: HelloParis)
and if we have different constructors for the class, we can define environments to distinguish them:
@Injectable
class HelloWorld {
@ForEnvironments("europe")
constructor(val helloBarcelona: HelloBarcelona, val helloParis: HelloParis) : this()
@ForEnvironments("usa")
constructor(val helloNewYork: HelloNewYork, val helloLosAngeles: HelloLosAngeles) : this()
}
and then can inject it like this:
val helloWorld = inject<HelloWorld>() // Will inject a HelloWorld instance without parameters
val helloWorld = inject<HelloWorld>("europe") // Will inject a HelloWorld instance with parameters HelloBarcelona and HelloParis
val helloWorld = inject<HelloWorld>("usa") // Will inject a HelloWorld instance with parameters HelloNewYork and HelloLosAngeles
Let's now define an interface:
interface Hello
and use it in our example
@Injectable
class HelloWorld : Hello
We can now inject by an interface:
val helloWorld = inject<Hello>() // This will inject a HelloWorld instance
And just like before, if you have different implementations of the same interface, you can distinguish them with environments
@Injectable
@ForEnvironments("planet")
class HelloPlanet : Hello
so,
val hello = inject<Hello>("planet") // This will return an instance of HelloPlanet
val hello = inject<Hello>() // This will return an instance of HelloWorld
For injectable classes with BY_NEW scope, you can have assisted arguments
@Injectable(BY_NEW)
class HelloViewModel(@Assisted val id: Long, val param2: HelloBarcelona, val param2: HelloNewYork) : Hello
that you provide in runtime as:
val id = 4
val hello = inject<Hello> {
assist(id)
}
If you want to inject a class out of your code, just define a class and annotate it with @InjectableProvider. Notice that you can use as many injectable objects as you need defining them as parameters of your method.
@InjectableProvider(scope = Scope.BY_APP)
class MyRetrofitProvider {
fun createRetrofit(client: OkHttp): Retrofit {
return Retrofit.Builder()
.baseUrl("my.url")
.client(client)
.build()
}
}
and use it the same way:
val hello = inject<Retrofit>() // This will inject a persistent instance of Retrofit
There is also a way to use custom injection. You can take control of when an instance is injectable and when is not:
val someInstance = SomeType()
popKorn().addInjectable(someInstance)
val copy1 = inject<SomeType>() // Will inject someInstance
popKorn().removeInjectable(someInstance)
val copy2 = inject<SomeType>() // Will fail, because SomeType is not injectable anymore
In Android this is very useful when injecting the Context (An instance that is provided and cannot be created)
class MyApplication : Application() {
override fun onCreate() {
super.onCreate()
popKorn().addInjectable(this, Context::class)
}
}
PopKorn also offers the ability to create injectable classes at any time (ignoring its scope), overriding any dependency you like
class Hello(val param: HelloBarcelona, val param: HelloParis)
val hello = popKorn().create<Hello> {
override(HelloTestBarcelona())
}
This will create a hello instance using HelloTestBarcelona instead of the default HelloBarcelona
PopKorn provides full support to Android platforms. You don't need to initialize anything. Just use it as described above.
To use it from pure java classes, use PopKornCompat:
HelloWorld helloWorld = PopKornCompat.inject(HelloWorld.class);
To prevent you to exclude lots of classes from obfuscation, PopKorn saves some mappings that needs to be merged when generating the APK. If you are using multiple modules, Android will take only the last one by default (
or throw a compilation error depending on the Gradle version), unless the following option it's set in the build.gradle:
android {
packagingOptions {
merge 'META-INF/popkorn.provider.mappings'
merge 'META-INF/popkorn.resolver.mappings'
}
}
This is the error that the above fixes:
Execution failed for task ':app:mergeDebugJavaResource'.
> A failure occurred while executing com.android.build.gradle.internal.tasks.Workers$ActionFacade
> More than one file was found with OS independent path 'META-INF/popkorn.provider.mappings'
PopKorn provides full support to Objective C / Swift platforms. You will need to do the following:
A) In your multiplatform project, write a File (Bridge.kt) on your IOS module and add this 2 functions:
fun init(creator: (ObjCClass) -> Mapping) = cc.popkorn.setup(creator)
fun getInjector() = InjectorObjC(popKorn())
B) From your IOS project you will need to initialize PopKorn at the beginning of your app (AppDelegate):
BridgeKt.doInit { (clazz) -> PopkornMapping in
return clazz.alloc() as! PopkornMapping
}
C) To be used anywhere like this in ObjectiveC / Swift code
let injector = BridgeKt.getInjector()
let helloWorld = injector.inject(clazz: HelloWorld.self) as! HelloWorld
You can also use runtime injections
let someInstance = SomeType()
injector.addInjectable(instance: someInstance, clazz: SomeType.self)
let copy1 = injector.inject(clazz: SomeType.)
injector.removeInjectable(clazz: .)
copy2 injector.inject(clazz: .)
PopKorn provides basic support to JS / Native platforms. In your multiplatform project, write a File on your JS / Native module and add this function:
fun init() {
val resolvers: Set<Mapping> = hashSetOf(/* LOCATE ALL RESOLVER CLASSES OF TYPE MAPPING THAT POPKORN AUTOGENERATED */)
val providers: Set<Mapping> = hashSetOf(/* LOCATE ALL PROVIDER CLASSES OF TYPE MAPPING THAT POPKORN AUTOGENERATED */)
cc.popkorn.setup(resolvers, providers)
}
then call it somewhere to initialize PopKorn. For now, injections for JS / Native can only be done from your multiplatform project. Injections from JS / Native code is not yet available.
You can find out more examples in popkorn-example project
interface Location
@Injectable
class RealLocation : Location {
constructor() : this() {
// Get LocationManager.GPS_PROVIDER
}
@ForEnvironments()
() : () {
}
}
:
and then
val r1 = inject<Location>() // This will inject a persistent instance of RealLocation to get GPS locations
val r2 = inject<Location>("network") // This will inject a persistent instance RealLocation to get Network locations
val r2 = inject<Location>("fake") // This will inject a volatile instance of FakeLocation
or use it in any constructor of other injectable classes:
constructor(real:Location, @WithEnvironment("fake") fake:Location, @WithEnvironment("network") network:Location) {}
Copyright 2019 Pau Corbella
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance the License.
You may obtain a copy of the License at
http:
Unless applicable law agreed to writing, software
distributed under the License distributed an BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express implied.
See the License the specific language governing permissions
limitations under the License.