koin post added

Author: maciej-nowak

_drafts/2019-05-13-dagger.md

@@ -7,7 +7,7 @@ image: libraries/dagger
 github: libraries/tree/master/dagger
 description: "Biblioteki"
 version: Dagger 2.21
-keywords: "dagger, wstrzykiwanie, zależności, moduł, komponent, podkomponent, depenendency, injection, di, inject, provides, module, component, subcomponent, scope, qualifier, activity, fragment, injector, androidinjectionmodule, android, programowanie, programming"
+keywords: "dagger, wstrzykiwanie, zależności, moduł, komponent, podkomponent, depenendency, injection, di, inject, provides, module, component, subcomponent, scope, qualifier, activity, fragment, injector, androidinjectionmodule, android, java, programowanie, programming"
 ---
 
 ## Wstęp

_drafts/2019-05-20-koin.md

@@ -0,0 +1,223 @@
+---
+layout: post
+title: "Koin"
+date: 2019-05-20
+categories: ["Biblioteki"]
+image: libraries/koin
+github: libraries/tree/master/koin
+description: "Biblioteki"
+version: Koin 2.0
+keywords: "koin, wstrzykiwanie, zależności, moduł, komponent, depenendency, injection, di, inject, module, component, scope, qualifier, activity, mockito, kotlin, android, programowanie, programming"
+---
+
+## Wstęp
+`Wstrzykiwanie zależności` (`Dependency Injection`) niezależnie od sposobu realizacji jest nieodłącznym elementem procesu budowania większości aplikacji. Wykorzystanie dostawcy zależności realizuje paradygmat `Odwrócenia sterowania` (`Inversion of Control`), który przenosi odpowiedzialność za inicjalizację niektórych obiektów na rzecz kontenera. Pozwala zmniejszyć ilość często powtarzającego się nadmiarowego kodu (`boilerplate`) dzięki czemu tworzony kod staje się krótszy, czytelniejszy, łatwiejszy w utrzymaniu i testowaniu. `Koin` jest biblioteką wstrzykiwania zależności o lekkiej strukturze przeznaczoną przede wszystkim dla programistów `Kotlin`. W przeciwieństwie do innych popularnych rozwiązań (np. `Dagger`) nie generuje dodatkowego kodu oraz nie wykorzystuje proxy czy refleksji, a pragmatyczne API sprawia, że jego użycie i konfiguracja jest łatwa i zwięzła.
+
+## Moduł
+Konfiguracja i inicjalizacja obiektów dla kontenera zależności odbywa się w instancji modułu (`module`) dzięki czemu nie jest wymagane tworzenie osobnej klasy dla każdego modułu. Aby utworzyć moduł należy przypisać do zmiennej rezultat funkcji module w której zwracane są instancje danych typów - funkcje `single` dla pojedynczej instancji w obrębie zakresu i funkcja `factory` dla zwyczajnej instancji.
+
+{% highlight kotlin %}
+//create main module for whole app
+class App : Application() {
+
+    //create Koin module
+    val appModule = module {
+
+        //single instance of something
+        single { PreferenceManager.getDefaultSharedPreferences(get()) }
+
+        //provide names to recognize instances of the same type
+        single(name = "red") { SimpleDependency("red", "oval") }
+        single(name = "blue") { SimpleDependency("blue", "triangle") }
+
+        //get provided NetworkManager into ComplexDependency factory
+        factory { ComplexDependency(get()) }
+        single { NetworkManager("androidcode.pl", 80) }
+
+        //single instance of ParentDependency provided by ChildDependency
+        single<ParentDependency> { ChildDependency("text", 100) }
+        //for providing single instance matching multiple types use code below:
+        //single { ChildDependency("text", 100) } bind ParentDependency::class
+    }
+}
+{% endhighlight %}
+
+## Rejestracja
+Tworzenie i rejestracja komponentu kontenera `KoinApplication` zachodzi przy wywołaniu funkcji `startKoin` w której dokonuje się konfiguracji i przekazania referencji do modułów. Tworzenie kontenera może odbywać się w dowolnej klasie Android jednakże warto zarejestrować go w głównej klasie aplikacji dzięki czemu stanie się dostępny globalnie.
+
+{% highlight kotlin %}
+class App : Application() {
+
+    //create Koin module
+    val appModule = module {
+      //definition
+    }
+
+    override fun onCreate() {
+        super.onCreate()
+
+        //create and register KoinApplication instance
+        startKoin {
+            androidLogger()
+            androidContext(this@App)
+            modules(appModule)
+        }
+    }
+}
+{% endhighlight %}
+
+## Wstrzykiwanie
+Wstrzykiwanie zależności może zostać zrealizowane przez leniwą inicjalizację członków klasy przy pomocy funkcji `inject` lub poprzez bezpośrednie wstrzyknięcie do instancji funkcją `get`.
+
+{% highlight kotlin %}
+class MainActivity : AppCompatActivity() {
+
+    //lazy inject
+    val simpleDependencyRed by inject<SimpleDependency>("red")
+    val simpleDependencyBlue: SimpleDependency by inject("blue")
+    val complexDependency: ComplexDependency by inject()
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContentView(R.layout.activity_main)
+
+        //inject by directly getting instance
+        val pref: SharedPreferences = get()
+    }
+}
+{% endhighlight %}
+
+## Zakres
+Zakres pozwala na wykorzystanie wybranych zależności tylko w obrębie danej klasy, a jego tworzenie realizowane jest przy pomocy funkcji `scope` i oznaczania zależności definicją `scoped`. Wstrzyknięcie zależności odbywa się z poziomu obiektu `ScopeInstance` otrzymywanego z funkcji `getActivityScope` (`getFragmentScope` dla `Fragment`), którego należy powiązać z cyklem życia komponentu za pomocą `bindScope`.
+
+{% highlight kotlin %}
+class App : Application() {
+
+    val appModule = module {
+      //definitions
+    }
+
+    val scopeModule = module {
+        scope<ScopeActivity> {
+            scoped("scoped") { SimpleDependency("black", "square") }
+        }
+    }
+
+    override fun onCreate() {
+        super.onCreate()
+        startKoin {
+            androidLogger()
+            androidContext(this@App)
+            modules(appModule, scopeModule)
+        }
+    }
+}
+
+class ScopeActivity : AppCompatActivity() {
+
+    //inject instance from current scope
+    val simpleDependencyBlack: SimpleDependency by getActivityScope().inject()
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContentView(R.layout.activity_scope)
+
+        //bind scope session to lifecycle
+        bindScope(getActivityScope())
+    }
+}
+{% endhighlight %}
+
+## ViewModel
+Koin oferuje także integracje z klasą `ViewModel` co znacząco ułatwia pracę w przypadku realizacji aplikacji z wykorzystaniem mechanizmu `data binding` dla widoków. Aby dostarczyć obiekt typu `ViewModel` należy go oznaczyć w module jako `viewModel` oraz pobrać w miejscu docelowym za pomocą funkcji `viewModel` dla leniwej inicjalizacji lub bezpośrednio zainicjalizować funkcją `getViewModel`.
+
+{% highlight kotlin %}
+class App : Application() {
+
+    val appModule = module {
+      //definitions
+    }
+
+    val viewModelModule = module {
+        single { SimpleDependency("white", "rectangle") }
+        viewModel {
+            SomeViewModel(get())
+        }
+    }
+
+    override fun onCreate() {
+        super.onCreate()
+        startKoin {
+            androidLogger()
+            androidContext(this@App)
+            modules(appModule, viewModelModule)
+        }
+    }
+}
+
+class ViewModelActivity : AppCompatActivity() {
+
+    //lazy inject ViewModel
+    val viewModel: SomeViewModel by viewModel()
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContentView(R.layout.activity_viewmodel)
+
+        //inject by directly getting ViewModel instance
+        val viewModel: SomeViewModel = getViewModel()
+    }
+}
+{% endhighlight %}
+
+## Testowanie
+Wstrzykiwanie zależności może zostać także wykorzystywane w procesie testowania z `JUnit` dokładnie w taki sam sposób jak w klasach kodu źródłowego. Klasa testowa powinna rozszerzać `KoinTest`. Dodatkowo Koin umożliwia również tworzenie atrap (`mock`) obiektów dzięki czemu możliwa jest współpraca z bibliotekami naiwnych implementacji (np. `Mockito`).
+
+{% highlight kotlin %}
+class SimpleDependencyTest: KoinTest {
+
+    //define some test module dependencies
+    val testModule = module {
+        single { SimpleDependency("red", "oval") }
+    }
+
+    //inject instance into member or get inside method test
+    val dependency: SimpleDependency by inject()
+
+    //init test dependencies before each test
+    @Before
+    fun before() {
+        startKoin {
+            modules(testModule)
+        }
+    }
+
+    //stop test dependencies after each test
+    @After
+    fun after() {
+        stopKoin()
+    }
+
+    //test dependency
+    @Test
+    fun testChangeColorWithInjection() {
+        assertEquals("SimpleDependency is red oval", dependency.getInfo())
+        dependency.changeColor("orange")
+        assertEquals("SimpleDependency is orange oval", dependency.getInfo())
+    }
+
+    //test mock
+    @Test
+    fun testCheckMock() {
+        //declare and get mock
+        declareMock<SimpleDependency>(name = "mock")
+        val mock: SimpleDependency = get(name = "mock")
+
+        //asserts, rules, verify
+        assertNotNull(mock)
+        Mockito.`when`(mock.getInfo()).thenReturn("SimpleDependency is green oval")
+        assertEquals("SimpleDependency is green oval", mock.getInfo())
+        Mockito.verify(mock, times(1)).getInfo()
+    }
+}
+{% endhighlight %}