Merge branch 'InsertKoinIO:main' into main

.github/workflows/codeql.yml

@@ -28,11 +28,11 @@ jobs:
         # Learn more about CodeQL language support at https://aka.ms/codeql-docs/language-support
 
     steps:
-    - name: Set up JDK 11
+    - name: Set up JDK 17
       uses: actions/setup-java@v3
       with:
         distribution: 'zulu'
-        java-version: 11
+        java-version: 17
 
     - name: Setup Gradle
       uses: gradle/gradle-build-action@v2

.gitignore

@@ -9,4 +9,4 @@ classes/
 /build
 /captures
 yarn.lock
-
+.kotlin/

docs/quickstart/android-annotations.md

@@ -1,51 +1,45 @@
 ---
-title: Android - Annotations
+title: Android & Annotations
 ---
 
 > This tutorial lets you write an Android application and use Koin dependency injection to retrieve your components.
-> You need around __10/15 min__ to do the tutorial.
+> You need around __10 min__ to do the tutorial.
+
+:::note
+update - 2024-10-21
+:::
 
 ## Get the code
 
 :::info
-[The source code is available at on Github](https://github.com/InsertKoinIO/koin-getting-started/tree/main/android)
+[The source code is available at on Github](https://github.com/InsertKoinIO/koin-getting-started/tree/main/android-annotations)
 :::
 
 ## Gradle Setup
 
-Let's configure the KSP Plugin like this:
+Let's configure the KSP Plugin like this, and the following dependencies:
 
 ```groovy
-apply plugin: 'com.google.devtools.ksp'
-
-android {
-    sourceSets {
-        main.java.srcDirs += 'src/main/kotlin'
-        test.java.srcDirs += 'src/test/kotlin'
-    }
-    // For KSP
-    applicationVariants.configureEach { variant ->
-        kotlin.sourceSets {
-            getByName(name) {
-                kotlin.srcDir("build/generated/ksp/${variant.name}/kotlin")
-            }
-        }
-    }
+plugins {
+    alias(libs.plugins.ksp)
 }
-```
-
-Add the Koin Android dependency like below:
 
-```groovy
 dependencies {
-    // Koin
-    implementation "io.insert-koin:koin-android:$koin_version"
-    implementation "io.insert-koin:koin-annotations:$koin_ksp_version"
-    ksp "io.insert-koin:koin-ksp-compiler:$koin_ksp_version"
+    // ...
+
+    implementation(libs.koin.annotations)
+    ksp(libs.koin.ksp)
 }
-```
 
+// Compile time check
+ksp {
+    arg("KOIN_CONFIG_CHECK","true")
+}
+```
 
+:::note
+See `libs.versions.toml` for current versions
+:::
 
 ## Application Overview
 
@@ -250,18 +244,15 @@ dependencies {
 
 ### Checking your modules
 
-The `verify()` function allow to verify the given Koin modules:
+The `androidVerify()` function allow to verify the given Koin modules:
 
 ```kotlin
 class CheckModulesTest : KoinTest {
 
     @Test
     fun checkAllModules() {
 
-        AppModule().module.verify(
-            extraTypes = listOf(
-                SavedStateHandle::class
-            ))
+        AppModule().module.androidVerify()
     }
 }
 ```

docs/quickstart/android-compose.md

@@ -5,6 +5,10 @@ title: Android - Jetpack Compose
 > This tutorial lets you write an Android application and use Koin dependency injection to retrieve your components.
 > You need around __10 min__ to do the tutorial.
 
+:::note
+update - 2024-10-21
+:::
+
 ## Get the code
 
 :::info
@@ -73,7 +77,7 @@ Let's declare our first component. We want a singleton of `UserRepository`, by c
 
 ```kotlin
 val appModule = module {
-    single<UserRepository> { UserRepositoryImpl() }
+    singleOf(::UserRepositoryImpl) bind UserRepository::class
 }
 ```
 
@@ -95,12 +99,12 @@ class UserViewModel(private val repository: UserRepository) : ViewModel() {
 
 > UserRepository is referenced in UserViewModel's constructor
 
-We declare `UserViewModel` in our Koin module. We declare it as a `viewModel` definition, to not keep any instance in memory (avoid any leak with Android lifecycle):
+We declare `UserViewModel` in our Koin module. We declare it as a `viewModelOf` definition, to not keep any instance in memory (avoid any leak with Android lifecycle):
 
 ```kotlin
 val appModule = module {
-     single<UserRepository> { UserRepositoryImpl() }
-     viewModel { MyViewModel(get()) }
+     singleOf(::UserRepositoryImpl) { bind<UserRepository>() }
+    viewModelOf(::UserViewModel)
 }
 ```
 
@@ -125,7 +129,7 @@ The `koinViewModel` function allows us to retrieve a ViewModel instances, create
 
 ### The `UserStateHolder` class
 
-Let's write a ViewModel component to display a user:
+Let's write a State holder component to display a user:
 
 ```kotlin
 class UserStateHolder(private val repository: UserRepository) {
@@ -139,28 +143,28 @@ class UserStateHolder(private val repository: UserRepository) {
 
 > UserRepository is referenced in UserViewModel's constructor
 
-We declare `UserViewModel` in our Koin module. We declare it as a `viewModel` definition, to not keep any instance in memory (avoid any leak with Android lifecycle):
+We declare `UserStateHolder` in our Koin module. We declare it as a `factoryOf` definition, to not keep any instance in memory (avoid any leak with Android lifecycle):
 
 ```kotlin
 val appModule = module {
-     single<UserRepository> { UserRepositoryImpl() }
-     factory { UserStateHolder(get()) }
+    singleOf(::UserRepositoryImpl) { bind<UserRepository>() }
+    factoryOf(::UserStateHolder)
 }
 ```
 
 ### Injecting UserStateHolder in Compose
 
-The `UserViewModel` component will be created, resolving the `UserRepository` instance with it. To get it into our Activity, let's inject it with the `get()` function: 
+The `UserStateHolder` component will be created, resolving the `UserRepository` instance with it. To get it into our Activity, let's inject it with the `koinInject()` function: 
 
 ```kotlin
 @Composable
-fun FactoryInject(userName : String, presenter: UserStateHolder = get()){
+fun FactoryInject(userName : String, presenter: UserStateHolder = koinInject()){
     Text(text = presenter.sayHello(userName), modifier = Modifier.padding(8.dp))
 }
 ```
 
 :::info
-The `get` function allows us to retrieve a ViewModel instances, create the associated ViewModel Factory for you and bind it to the lifecycle
+The `koinInject` function allows us to retrieve a ViewModel instances, create the associated ViewModel Factory for you and bind it to the lifecycle
 :::
 
 
@@ -186,6 +190,24 @@ class MainApplication : Application(){
 The `modules()` function in `startKoin` load the given list of modules
 :::
 
+While starting the Compose application we need to link Koin to our current Compose application, with `KoinAndroidContext`:
+
+```kotlin
+class MainActivity : AppCompatActivity() {
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContent {
+            MaterialTheme {
+                KoinAndroidContext {
+                    App()
+                }
+            }
+        }
+    }
+}
+```
+
 ## Koin module: classic or constructor DSL?
 
 Here is the Koin moduel declaration for our app:
@@ -215,11 +237,6 @@ We can ensure that our Koin configuration is good before launching our app, by v
 Add the Koin Android dependency like below:
 
 ```groovy
-// Add Maven Central to your repositories if needed
-repositories {
-	mavenCentral()    
-}
-
 dependencies {
     
     // Koin for Tests

docs/quickstart/android-viewmodel.md

@@ -3,7 +3,11 @@ title: Android - ViewModel
 ---
 
 > This tutorial lets you write an Android application and use Koin dependency injection to retrieve your components.
-> You need around __10/15 min__ to do the tutorial.
+> You need around __10 min__ to do the tutorial.
+
+:::note
+update - 2024-10-21
+:::
 
 ## Get the code
 
@@ -19,7 +23,7 @@ Add the Koin Android dependency like below:
 dependencies {
 
     // Koin for Android
-    implementation "io.insert-koin:koin-android:$koin_version"
+    implementation("io.insert-koin:koin-android:$koin_version")
 }
 ```
 
@@ -73,7 +77,7 @@ Let's declare our first component. We want a singleton of `UserRepository`, by c
 
 ```kotlin
 val appModule = module {
-    single<UserRepository> { UserRepositoryImpl() }
+   singleOf(::UserRepositoryImpl) { bind<UserRepository>() }
 }
 ```
 
@@ -93,16 +97,15 @@ class UserViewModel(private val repository: UserRepository) : ViewModel() {
 
 > UserRepository is referenced in UserViewModel`s constructor
 
-We declare `UserViewModel` in our Koin module. We declare it as a `viewModel` definition, to not keep any instance in memory (avoid any leak with Android lifecycle):
+We declare `UserViewModel` in our Koin module. We declare it as a `viewModelOf` definition, to not keep any instance in memory (avoid any leak with Android lifecycle):
 
 ```kotlin
 val appModule = module {
-     single<UserRepository> { UserRepositoryImpl() }
-     viewModel { MyViewModel(get()) }
+    singleOf(::UserRepositoryImpl) { bind<UserRepository>() }
+    viewModelOf(::UserViewModel)
 }
 ```
 
-> The `get()` function allow to ask Koin to resolve the needed dependency.
 
 ## Injecting ViewModel in Android
 

docs/quickstart/android.md

@@ -3,7 +3,11 @@ title: Android
 ---
 
 > This tutorial lets you write an Android application and use Koin dependency injection to retrieve your components.
-> You need around __10/15 min__ to do the tutorial.
+> You need around __10 min__ to do the tutorial.
+
+:::note
+update - 2024-10-21
+:::
 
 ## Get the code
 
@@ -19,7 +23,7 @@ Add the Koin Android dependency like below:
 dependencies {
 
     // Koin for Android
-    implementation "io.insert-koin:koin-android:$koin_version"
+    implementation("io.insert-koin:koin-android:$koin_version")
 }
 ```
 
@@ -73,7 +77,7 @@ Let's declare our first component. We want a singleton of `UserRepository`, by c
 
 ```kotlin
 val appModule = module {
-    single<UserRepository> { UserRepositoryImpl() }
+    singleOf(::UserRepositoryImpl) { bind<UserRepository>() }
 }
 ```
 
@@ -93,12 +97,12 @@ class UserPresenter(private val repository: UserRepository) {
 
 > UserRepository is referenced in UserPresenter`s constructor
 
-We declare `UserPresenter` in our Koin module. We declare it as a `factory` definition, to not keep any instance in memory (avoid any leak with Android lifecycle):
+We declare `UserPresenter` in our Koin module. We declare it as a `factoryOf` definition, to not keep any instance in memory (avoid any leak with Android lifecycle):
 
 ```kotlin
 val appModule = module {
-     single<UserRepository> { UserRepositoryImpl() }
-     factory { MyPresenter(get()) }
+    singleOf(::UserRepositoryImpl) { bind<UserRepository>() }
+    factoryOf(::UserStateHolder)
 }
 ```