Forem: Sanjay Prajapat

Kotlin Koin - Android Tutorial for Beginners

Sanjay Prajapat — Sat, 05 Mar 2022 18:39:49 +0000

What is Koin?
A pragmatic lightweight dependency injection framework for Kotlin developers Written in pure Kotlin.

What is dependency and dependency Injection?
Let’s take an example. We have a relation between Car and Engine classes. To access Engine’s properties in Car class we have to create an instance of Engine Car that is simply a dependency.

instance of engine class can be created manually. but it becomes hard to instantiate the objects automatically such as in constructor.

asking someone else to create the object and directly using it is called dependency injection.

Let’s add Koin to our project!

// Koin AndroidX Scope features
    implementation "io.insert-koin:koin-androidx-scope:2.2.3"
// Koin AndroidX ViewModel features
    implementation "io.insert-koin:koin-androidx-viewmodel:2.2.3"
// Koin AndroidX Fragment features
    implementation "io.insert-koin:koin-androidx-fragment:2.2.3"
    // Koin AndroidX WorkManager
//    implementation "io.insert-koin:koin-androidx-workmanager:$koin_version"
// Koin AndroidX Jetpack Compose
//    implementation "io.insert-koin:koin-androidx-compose:$koin_version"
// Koin AndroidX Experimental features
//    implementation "io.insert-koin:koin-androidx-ext:$koin_version"}

add this koin plugin in build.gradle(app)

plugins {
    id 'com.android.application'
    id 'kotlin-android'
    id 'koin'
}

first create our Application class like,

class BaseApplication:Application()

add this in manifest file like,

android:name=".BaseApplication"

for Koin we have three types of Scopes , we can define it as:
single, it creates a singleton that can be used across the app as a singular instance.
factory, it provides a bean definition, which will create a new instance each time it is injected.
scoped, it's provide an object that will persist as long the associated scope lifetime exist

Constructor injection.

class Car constructor(private val engine: Engine, private val wheel: Wheel){

    companion object{
        const val TAG ="Car"
    }
    fun getCar(){
        wheel.getWheel()
        engine.getEngine()

        Log.d(TAG, "getCar: Car is Running")
    }
}
class Engine {

    companion object{
        const val TAG ="Engine"
    }
    fun getEngine(){
        Log.d(TAG, "Engine started")
    }
}
class Wheel {

    companion object{
        const val TAG ="Wheel"
    }
    fun getWheel(){
        Log.d(TAG, "Wheel started")
    }
}

Deifne Module we keep logic in module to provide dependency like (interface and class)
to provide car class Dependency create a module AppModule file.

val demoModule = module {

    single {
        Wheel()
    }

    single {
        Engine()
    }
    // every time inject new instance created if used factory scope
    // get() to inject wheel and engine dependency
    single {
        Car(get(),get())
    }
    single {
        Component()
    }
}

Implementing Koin Component
To give a class the capacity to use Koin features, we need to tag it with KoinComponent interface. Let's take an example.

@KoinApiExtension
class Component() :KoinComponent{

    // lazily instantiated (when first access)
    val car: Car by inject()
    val engine:Engine by inject ()


    // also another way
    // eagerly  // when application created will be available
    val car1:Car = get()

    // val main: Main by inject()

    //val mainViewModel:MainViewModel by inject   ()

}

Now we have declared all modules (decencies). In Application class, just call startKoin{ }method that takes a lambda in which we define a list of modules

class BaseApplication:Application() {

    override fun onCreate() {
        super.onCreate()

        // first start Koin(to use)
       startKoin {
           //can keep list of modules
           modules(listOf(demoModule,))
//            modules(
//                demoModule
//            )
        }
    }
}

Let's inject in MainActivity
first use @KoinApiExtension in activity,fragment etc.

@KoinApiExtension
class MainActivity : AppCompatActivity() {
    var binding:ActivityMainBinding? = null
    private val component:Component by inject()

//    private val car: Car by inject() /// not a better way create component than use

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = ActivityMainBinding.inflate(layoutInflater)
        binding?.apply {
            setContentView(root)
            lifecycleOwner = this@MainActivity
            executePendingBindings()
        }

        component.car.getCar()
    }
}

Functional (SAM) interfaces in Kotlin

Sanjay Prajapat — Sat, 20 Nov 2021 07:20:02 +0000

An interface with only one abstract method is called a functional interface(Single Abstract Method). functional (SAM) interface can have multiple non abstract method but only one abstract method

// functional interface example
interface CatchAble {
    fun invoke()
}

SAM conversions

Instead of creating a class that implements a functional interface manually, you can use a lambda expression.

// functional interface example
interface CatchAble {
    fun invoke()
}

// functional interface example
fun interface FunctInterface{
    fun invoke(list: List<Int>) :List<Int>
}

// functional interface
interface FuncInterface3 {
    fun abstract_method(a: Int, b: String?)
    // Second method prevents lambda conversion
    fun   nonabstract_method() {
        println("do something")
    }
}

fun main(){

    // if we don't use SAM conversion
    val run  = object : CatchAble {
        override fun invoke() {
            print("Invoking CatchAble ")

        }
    }
    run.invoke() //  // Invoking CatchAble

    // if don't SAM use SAM conversion
    val fi = object :FunctInterface{
        override fun invoke(list: List<Int>): List<Int> {
            return  list.filter { pre -> pre %2 ==0 }
        }
    }
    print(fi.invoke(listOf(2,5,1,5,79,0))) // [2, 0]

    // using same conversion
    val fi2 = FunctInterface {
        it.filter { pre -> pre %2 == 0 }
    }
    print(fi2.invoke(listOf(2,5,1,5,79,0))) // [2, 0]

val fi3 = object : FuncInterface3{
        override fun abstract_method(a: Int, b: String?) {
            print("This is abstract method")
        }

        // it's not force to override this method
        override fun nonabstract_method() {
            print("overriding non abstract method")
        }
    }

    fi3.nonabstract_method() // do something
    fi3.abstract_method(2,"323") //overriding non-abstract method
}

Functional (SAM) interfaces in Java

How To Combine Flows In Kotlin

Sanjay Prajapat — Sun, 14 Nov 2021 18:23:41 +0000

Coroutines provides combine, zip and flattenMerge operators is used to combine emissions from multiple flows

Combine

Combine operator takes the latest emission from two flows and gives result

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*

fun main() = runBlocking<Unit> {
   // gives 1..3 in every 300ms 
    val f1 = flowOf(1,2,3).onEach { delay(300) } 
    val f2 = flowOf("x", "y", "z").onEach { delay(400) }
    val startTime = System.currentTimeMillis() 
    f1.combine(f2) { num, str -> "$num -> $str" }
    .collect { result ->
        println("$result at ${System.currentTimeMillis() - startTime} ms from start")
    }
}
/**
1 -> x at 424 ms from start
2 -> x at 627 ms from start
2 -> y at 826 ms from start
3 -> y at 927 ms from start
3 -> z at 1226 ms from start
*/

Zip -

Let's take an example as above. Each time emission occurs, zip operators waits for emission from other flow , when it occurs zip provide results in lambda expression as numbers and letters

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*

fun main() = runBlocking<Unit> {
    val f1 = flowOf(1,2,3).onEach { delay(300) } 
    val f2 = flowOf("x", "y", "z").onEach { delay(400) }
    val startTime = System.currentTimeMillis() 
    f1.zip(f2) { num, str -> "$num -> $str" }
    .collect { result ->
        println("$result at ${System.currentTimeMillis() - startTime} ms from start")
    }
}
/*
1 -> x at 437 ms from start
2 -> y at 837 ms from start
3 -> z at 1239 ms from start
*/

it will stop execution when one of the flow is completed

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*

fun main() = runBlocking<Unit>{
    val f1 = (1..4).asFlow()
    val f2 = flowOf("Hi", "Hello", )
    f1.zip(f2){ a,b -> "$a -> $b"}
    .collect{
        println(it)
    }
}
/*
1 -> Hi
2 -> Hello
*/

flattenMerge

It executes them as single flow ,it doesn't combines , it will not stop execution when one of the flow is completed (But zip operator does)

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*

fun main() = runBlocking<Unit> {
    val f1 = flowOf(1,2,3,4).onEach{ delay(200)}
    val f2 = flowOf("H","O","L","A").onEach{ delay(400)}
     val startTime = System.currentTimeMillis() 
    flowOf(f1,f2).flattenMerge().collect { 
    println("$it at ${System.currentTimeMillis() - startTime} ms from start")
    }
}
/**
 * 1 at 238 ms from start
H at 438 ms from start
2 at 438 ms from start
3 at 639 ms from start
O at 838 ms from start
4 at 839 ms from start
L at 1239 ms from start
A at 1640 ms from start
 */

Type Aliases in Kotlin

Sanjay Prajapat — Thu, 07 Oct 2021 18:04:06 +0000

type alias provide alternative name for existing type. if type name is longer can be introduces shorter name , it will not introduced new types, they are equivalent to corresponding types.

data class User(
    val name:String? = null,
)

// alias for Int type and ArrayList
    typealias u = Int 
    typealias l = ArrayList<String>
fun main(){
    val users:l = ArrayList()
    users.add("Jb")
    users.add("hdshj")
    print(users)
    val x:u = 34
    print(x)
}

// type alias for inner class 
class A {
inner class Inner
}
class B {
   inner class Inner
}
    typealias AInner = A.Inner
    typealias BInner = B.Inner

 // provide alias for Function type 
 val lamb = { x:Int, y:Int, z:Int -> print("$x $y $z") } 

 typealias MyHandler = (Int, Int, Int) -> Unit
 fun my(f:MyHandler){
     f.invoke(20,21,22)
 }
 fun main(){
     my(lamb)
 }

 typealias Predicate<T> = (T) -> Boolean

 fun foo(p: Predicate<Int>) = p(42)
 fun main(){
     val f1: (Int) -> Boolean = { it > 0 }    
     print(foo(f1)) // true 

     val p: Predicate<Int> = { it > 0 }
     println(listOf(1, -2).filter(p)) // [1]
 }

Data class in Kotlin

Sanjay Prajapat — Wed, 08 Sep 2021 19:08:31 +0000

The main purpose of data class is hold data , in koltin compiler automatically creates following

getters and setters for the constructor parameters -
hashCode()
equals()
toString()
copy()
componentN() function

following condition should be fullfilled to create a data class

primary constructor needs to have at least one parameter.
All primary constructor parameters need to be marked as val or var.
Data classes cannot be abstract, open, sealed or inner.

to exclude a property for generated implementation declare it inside data class

 data class Person(val name:String?=null, val age:Int? = null ){

    var excludeProp:Int = 34

    fun personDetails():String?{
        return "name=$name Age=$age"
    }
 }

fun main(args: Array<String>) {

    // val p1 = Person ()
    var  p1 = Person ("Justin", 27)
    val p2 = Person ("Justin", 27)
    val p3 = Person ("Justin", 26)

    println(p1) // 
    println(p1 == p2) // true 
    println(p1 == p3) // false

    p1.excludeProp = 90
    println(p1.excludeProp) // 90 
    println(p2.excludeProp) // 34 

    // use copy() when want to change some of properties of object , rest properties are unchanged 

    val newPerson = Person("Karl Bruce", 18)
    val oldPerson = newPerson.copy(age = 90)
    println(oldPerson) // Person(name=Karl Bruce, age=90)

    //Data classes and destructuring declarations

    val p5 =  Person("Chris", 45)
    val (name , age ) = p5
    print("name = $name  age =$age") //name = Chris  age =45

    //call function
   print( p5.personDetails() ) // name=Chris Age=45 

}

Java Anonymous Inner Class

Sanjay Prajapat — Mon, 06 Sep 2021 17:30:03 +0000

A nested class doesn't have any name is Known as anonymous inner class.
anonymous inner class can be used in two ways

for overriding purpose

If the purpose of class is only to override method ex: purpose of creating B class to override fun1
in this case you don't need to create B class

class A{
    void fun1(){
        System.out.println("fun1 in A ");
    }
}
class B extends A{
    void fun1(){
        System.out.println("fun1 in B");
    }
}

public class Program1
{
    public static void main(String[] args) {
        // A a = new B();
        // a.fun1(); //fun1 in B

        A obj = new A(){
            void fun1() {
                System.out.println("Anonymous Overidden method ");
            }
            // can't create 
            // void fun2(){
            //     System.out.println("fun2 method ");
            // }
        };
        obj.fun1(); // Anonymous Overidden method 
    }    
}

Anonymous class with Interface

interface I1{
    void fun1();
}

class Implementor implements I1{
    public void fun1(){
        System.out.println("Implementation of fun1");
    }
}

if role of implementor class is only to implement I1 interface , so you can create anonymous inner class , you don't need to create implementor class

public class Program2 {
    public static void main(String[] args) {
        // Implementor i1 = new Implementor();
        // i1.fun1(); //Implementation of fun1

        I1 i = new I1(){
            public void fun1(){
                System.out.println("Anonymous implementation");
            }
        };
        i.fun1(); // Anonymous implementation
    }
}

Filtering Collection In Kotlin

Sanjay Prajapat — Sat, 04 Sep 2021 19:22:00 +0000

Filtering conditions are defined by predicate and lambda function takes collection element . it return true when given element matches to predicate , return false if doesn't matches.

Filter by predicate

use filter() to filtering. it returns collection element that matches with predicate. for list and set resulting collection is list, for map it returns map.

fun main(args: Array<String>) {
    val numbers1 = listOf(1,2,3,4,5,6)
    val numbers2 = listOf(0,5,3,4,3,2)

    // return list  of elemenet that if number1's elements present in number2 list 
    val filterNum = numbers1.filter { predicate ->
           numbers2.contains(predicate)
    }
    print(filterNum) //[2, 3, 4, 5]

    val numMap = mapOf("key1" to 1, "key2" to 2, "key3" to 3, "key11" to 11)
    val filterMap = numMap.filter { (key ,value) ->
        key.startsWith("k") && value >2
    }
    print(filterMap) // {key3=3, key11=11}
}

filterIndexed() to use elements position

fun main(args: Array<String>) {
    val numbers1 = listOf(1,2,3,4,5,6) 
   val filterIndexed = numbers1.filterIndexed {
         index,element -> (index>1) && element > 2
     }
     print(filterIndexed) // [3, 4, 5, 6] 
}

filterNot() to filter collection on false condition ,

fun main(args: Array<String>) {
    val numbers1 = listOf(1,2,3,4,5,6) 
     val f = numbers1.filterNot { 
         it > 3
      } 
      print(f) // [1, 2, 3] 
}

filterIsInstance() allow us to call functions of T type on its items

fun main(args: Array<String>) {
    val numbers3 = listOf("1",null, "Hello", "World","3.20")
    val filter3= numbers3.filterIsInstance<String>().forEach  {
        print(it.uppercase()+ " " )  // 1 HELLO WORLD 3.20
    }
    print(filter3) //  kotlin.Unit 
}

filterNotNull() returns all non-null elements

fun main(args: Array<String>) {
    val numbers4 = listOf("1",null, "Hello", "World","3.20")
    val filter4 = numbers4.filterNotNull().forEach{
        print(it + " ") // 1 Hello World 3.20
    }
    println(filter4) //  kotlin.Unit
}

Partition

it returns pair of list , first melements are matches in seperate and that are not matched goes in another list

 val numbers5 = listOf("one", "two", "three", "four", "five")
    val (matched, rest) = numbers5.partition { predicate -> predicate.length>3 }
    println(matched) // [three, four, five]
    println(rest) // [one, two]

Test predicates

these are function used for test a predicate against element

any() : It returns true if at least one element matches

none() : It returns true if no elements matches with given predicate , if matches then return false

all() : It returns true if all element matches with given predicate

 println(numbers5.any{ it.startsWith("t")}) // true 
 println(numbers5.none{ it.startsWith("o")}) //false
 println(numbers5.all { it.length > 3}) // false 

// all() returns true for any predicate for emptylist 
 println(emptyList<Int>().all { it > 5 }) // true

any() ,none() for without predicate

any() - return true if elements in list , false for empty list

none() -> return true if elements present in list , true for empty list

    println(numbers5.any()) // true 
    println(emptyList<Int>().any()) // false 

    println(numbers5.none()) // false 
    println(emptyList<Int>().none()) // true

Standard Delegates In Kotlin

Sanjay Prajapat — Sat, 04 Sep 2021 15:46:47 +0000

1. lazy property - it used to create an object that is initialized only first access to the property value and store value and return it. By default lazy is synchronized the value is computed only in one thread ,and value will be same in all thread

/* immutable variable*/
val ourValue:String by lazy(){
    println("Hello World") 
    callAnother() /* this will run only first access*/
    "Hello what is going on "
}

 fun callAnother(){
    print("another fun ")
}

 fun main(args: Array<String>) {
     println(ourValue) 
     println(ourValue)
     println(ourValue)
    //  ourValue = 90 // value can't change

}
/* 
output 
Hello World
another fun 
Hello what is going on
Hello what is going on
Hello what is going on
*/

2. Observable Properties: lambda will be triggerd every time when value of property will be changed.

import kotlin.properties.Delegates
class Person{
    /* mutable variable  */
    var ourValue: String by Delegates.observable("Hello World"){ property ,oldValue,newValue ->
         print("\n prop $property ")
         print("\n oldValue $oldValue ") 
         print("\n newValue $newValue ")
    }
}

fun main(args: Array<String>) {
    val p = Person()
    print(p.ourValue)  // Hello World 
    p.ourValue = "change world"

}

// output
// Hello World
//  prop property ourValue (Kotlin reflection is not available)
//  oldValue Hello World
//  newValue change world

3. vetoable - it 's simmilar to obervable , only change is when assign the value onChange (callback)
is called if return true then new value will be assigned otherwise old value.

class Person1{
    var ourValue by Delegates.vetoable("Hello") {
        property, oldValue, newValue -> 
        newValue.length > oldValue.length  /* condition should be true to assign new value */
    }
}

fun main(args: Array<String>) {
    val p1 = Person1()
    p1.ourValue = "World"  // Hello
    p1.ourValue = "Worlds"
    println(p1.ourValue) // Worlds 


}

4. notNull - this delegates is used to be initialized later. it's similar to lateinit. It can be used with primitive data type which lateinit not support

var fullname: String by Delegates.notNull<String>()

fun main(args: Array<String>) {
    // can't access without initialization , gives exception 
    print(fullname) //  java.lang.IllegalStateException
    fullname = "Justin Bieber"
    print(fullname) // Justin Bieber
}

Delegated properties In Kotlin

Sanjay Prajapat — Sat, 04 Sep 2021 15:43:08 +0000

Delegate is just class ,that help us to seperate all logic of getter and setters so it can be reused .
if want to use same code for more than one property ,then don't need to apply same code for every property ex:

/* dont need to write this code */
class User{
    var firstName:String? =null 
        set(value){
            if(value!= null )
                field = value.trim()
        }

    var lastName:String? = null 
        set(value){
            if(value!= null )
                field = value.trim()
        }

}

use this code

class User{
        var firstName:String? by TrimDelegate()       
        var lastName:String? by TrimDelegate() 

        // to print object 
        override fun toString():String{
            return "$firstName $lastName"  
        } 
}

create custom Delegate class and name it TrimDelegate

class TrimDelegate {
    private var trimmedString:String ? = null 

    // thisRef is calling object 
    operator fun setValue( thisRef:Any,property:KProperty<*>, value:String?){
        // (thisRef as User).firstName // to access member 
        value?.let { 
            trimmedString = it.trim()
         }   
    }
    operator fun getValue(thisRef:Any, property:KProperty<*>):String?{
        return trimmedString
    }

}

fun main(args: Array<String>) {

    val user1 = User()
    user1.firstName = "  justin "
    user1.lastName = " Bieber    "
    print(user1.firstName ) // justin 
    print("\n$user1")//justin Bieber

}

Delegation In Kotlin

Sanjay Prajapat — Sat, 04 Sep 2021 15:23:55 +0000

kotlin support delegation pattern using by keyword. it allows the derived class to access all the implemented public methods of an interface through a specific object.

interface Base {
    fun print()
}

class BaseImpl(val x:String):Base{
   override val msg: String?  = x  
    override fun print(){
        println("Printing impl ${msg}}")
    }
}
class BaseAnotherImpl():Base{
     override val msg: String?  = null  
    override fun print(){
        println("Printing Another impl ")
    }
}

don't need to write this code

//class Derived (val b:Base) :Base{
//     override fun print(){
//         b.print()  // delegating the responsibility  of b reference
//     }
// }

kotlin supports this natively use this code

class Derived(b:Base):Base by b

fun main(args: Array<String>) {
    val b1 = BaseImpl("Hell")
    Derived(b1).print()

    val b2 = BaseAnotherImpl() // Printing impl Hell
    Derived(b2).print() // Printing Another impl    
}

Overriding member of an interface implemented by delegation

class Derived(b:Base):Base by b  {
    override val msg  = "2"   // can't access this property by b reference 

    override fun print(){
        print("\noverriding  print method of interface ")

    }
}

  // after overiding 
    val d = Derived(b1)
    d.print() // overriding  print method of interface
    print(d.msg) // 2

Original post on sanjayprajapat.hashnode.dev

Variable Arguments(Varargs in koltin)

Sanjay Prajapat — Sat, 04 Sep 2021 14:57:57 +0000

To pass variable number of arguments to a function. We can declare function with varargs parameter.

In java looks like

public void println(String.. args) { }

// allow function to accept number of arguments 
fun printAnimal(vararg animals:String):Unit{
    for (animal in animals) {
        print("\n $animal")
    }
}

fun printAnimal2(a1: String, vararg animals:String):Unit{
    print("first -> $a1") // elephant    // first argument goes in starting parameter 
    for (animal in animals) {
        print("\n $animal")
    }
}

fun main(args: Array<String>) {
    printAnimal("Lion", "Cheetah", "Cat", "Hayena")
    print("\n")
    printAnimal2("Elephant","Lion", "Cheetah", "Cat", "Hayena")
}

Passing List of Function to function

fun passFun(vararg funs:()->Unit){
   for (f in funs) {
       f() // to call function 
   }
}
fun f1(){
    print("function 1 ,")
}
fun f2(){
    print("function 2 ")
}

fun main(args: Array<String>) {
    // passing reference of function
    passFun(::f1,::f2) //  function 1 , function 2
}

Generic function

fun <T> printAny(vararg varg: T) {
    varg.forEach { println(it) }
}

fun main(args: Array<String>) {
    printAny(34,56,89)
}

Original post on sanjayprajapat.hashnode.dev