Dependency Injection Container

Atlas supports Compile time dependency injection.

To get started using it please import the plugin into your project (shared.gradle file):

plugins {
    id("io.github.thearchitect123.atlasGraphGenerator") // generates the dependency graph in your project
}
 kotlin {
   sourceSets {
        commonMain.dependencies {
            implementation("io.github.thearchitect123:atlas-core:+") // contains the DSL Api used to access the dependency graph
        }
   }
 }

Please also make sure to call this function inside your startup class before using Atlas:

AtlasDI.injectContainer(AtlasContainer)

Register at Compile time - Annotations

To register dependencies for your compile time dependency graph, please use the below annotations. These will auto register your services into your dependency graph automatically and apply the behavior based on the annotations:

1. @Singleton - Marks a class or function as a singleton, meaning that only one instance of it will be created and shared across the entire application.
                Use this when a service should have a single instance throughout the app lifecycle.
   Example Usage:
   @Singleton
   class MyServiceComponent {
    fun getString() = "My Sample String"
   }
   //to use your service, please use the DSL Api.
   val result = AtlasDI.resolve<MyServiceComponent>().getString()
   // result = "My Sample String"
   2. @Factory - Marks a class or function as a factory, meaning a new instance is created every time it is requested.
	             Use this when you need to regenerate a fresh instance each time.
   3. @Scoped - Marks a class or function as a scoped instance, meaning the instance is tied to a specific scope ID.
		        Use this when an instance should be shared within a specific scope (e.g., User Session, Request, Activity, etc.).
   4. @ViewModels - Marks a class as a ViewModel, meaning it will be lazily initialized and tied to an Android/Fragment owner lifecycle.
		            Use this for ViewModels in an MVVM architecture if you are using Jetpack Lifecycle Components.
		            On other platforms generates a single instance that is used once per class (example: ViewController for iOS)
   5. @Module, @Provides - Marks a class as a dependency module, meaning it provides dependencies using @Provides.
	                       Use this when you need to define multiple dependencies inside one module.
   @Module
   class MyServiceComponentModule {
       @Provides
       fun provideHttpClient(): HttpClient {
           return HttpClient()
       }
   }

Register at Runtime

If you need to register dependencies at runtime you can use the DSL Apis.

import com.architect.atlas.architecture.mvvm.ViewModel
class MyService {
}
class MyViewModel: ViewModel() {
}
AtlasDI.registerInstance(MyService())
AtlasDI.registerSingleton(MyService())
AtlasDI.registerViewModel(MyViewModel())
AtlasDI.registerFactory(MyService())

To access the service via the Atlas DSL:

@ViewModels
class SampleViewModel: ViewModel(){
}
AtlasDI.resolveService<MyServiceComponent>()
AtlasDI.resolveViewModel<SampleViewModel>()

To resolve the service/viewmodel lazily, please use:

AtlasDI.resolveLazyService<MyServiceComponent>()

This is equivalent to:

val myService by lazy {
    AtlasDI.resolveService<MyServiceComponent>()
}

What if I need access to Atlas in Swift directly?

No problem. Atlas has got you covered.

First inside your shared.gradle file please make sure to expose the Atlas API to swift

 listOf(iosX64, iosArm64, iosSimulatorArm64).forEach {
        it.binaries.framework {
            baseName = "shared"
            isStatic = true
            export(libs.atlas.core)
        }
    }
    sourceSets {
        val commonMain by getting {
            dependencies {
                api(libs.atlas.core)
            }
        }
    }

And if you have a kotlin class in your multiplatform project:

class SampleClass{
}

Then to resolve this dependency on the Swift side, you can use this snippet

 let resolved = AtlasDI.companion.resolveServiceNullableByName(clazz: SwiftClassGenerator.companion.getClazz(type: SampleClass.self)) as! SampleClass

Dependency Injection Container

Register at Compile time - Annotations

Register at Runtime

What if I need access to Atlas in Swift directly?​

What if I need access to Atlas in Swift directly?