DEV Community: Randy Arba

Try 5 scope function in kotlin

Randy Arba — Tue, 26 Nov 2019 15:00:50 +0000

with

When we should use this? with function use for call multiple different methods on the same object. Instead we use repetition to call variable or function in that object on every line, we can use with function. This function categories as normal function and not extensions function type, and the the last expression contain returns statement as a result. You should aware if this object contain null it will be trigger NPE, because this function never check for nullability.
You can direct call the function or variable in that object without it keyword. with function cannot add argument in their block statement because it mimic as argument instead object reference, and when if you not define the return value in the last expression, the result type will be unit/void type.

val product = Product()
with(product) {
change -> //this argument will be error or invalid
        productId = 1
        nameOfProduct = "Smartphone"
//You can add at last line with the variable type as the return value.
    }

let

When we should use this? let function use for you want to define a variable for specific scope to your code. let will invoked as parameter and returns the result of the lambda expression. Specific scope will only cover in your object that contain let function. i always use for checking nullability if the current object is null or not. This object never change the out of current object properties, only change in the scope. You should type it keyword to obtain the variable and add explicity return value in last statement to become result value or if you not do this it will be unit as the type.

val product = Product()
 product.let { 
        it.productId = 1
        it.nameOfProduct = "Smartphone"
//You can add at last line with the variable type as the return value.
    }

val product = Product()
 product.let { currentProduct ->
        currentProduct.productId = 1
        currentProduct.nameOfProduct = "Smartphone"
//You can add at last line with the variable type as the return value.
    }

run

When we should use this? run function is like combination of with and let. it have null checking so if the object is null the the block statement will never execute, and same as with function that can call multiple different method or variable in the same object. it keyword never supported in run function, instead use it keyword run function will use this operator. You can add this operator explicit or not, for call the variable/method inside that object.
Passing argument as lambda expression cannot be used in run function. Then same as let or with you must explicit add return value in the last statement to get the result type.

val product = Product()
product.run {
currentProduct -> //this argument will be error or invalid
        productId = 1
        nameOfProduct = "Smartphone"
//You can add at last line with the variable type as the return value.

    }

val product = Product()
product.run {
        this.productId = 1
        this.nameOfProduct = "Smartphone"
//You can add at last line with the variable type as the return value.

    }

also

When we should use this? also it will pass the object as parameter with return the same original object type. When you try to change in type in last statement based on the scope the return will be same as original object, so the atribute that you change in the scope will never applied for the current object type. also can use passing by argument in lambda expression so you can passing argument on this function as well. These function can use it operator, so if there pass argument by lambda expression the it operator will work.

val product = Product()
product.also {
        it.nameOfProduct = "Smartphone"
        it.productId = 1
//The return value remain product
    }

val product = Product()
product.also { currentProduct ->
        currentProduct.nameOfProduct = "Smartphone"
        currentProduct.productId = 1
//The return value remain product
    }

apply

When we should use this? apply its different from other function, that function is like extensions function type. it will run on the object reference or the receiver into expression and return the same original object type. You should notice about it keyword that not allowed in this function, instead use it, apply use this keyword. this keyword as a argument and as a return value. You dont need explicit add this operator to call the variable object just direct call the variable inside that object.

val product = Product()
product.apply {
currentProduct -> //this argument will be error or invalid
        productId = 1
        nameOfProduct = "Lipstik"
    }

product.apply {
        this.productId = 1
        this.nameOfProduct = "Lipstik"
    }

Kotlin or Swift

Randy Arba — Fri, 22 Nov 2019 08:16:48 +0000

When everyone talking about native development or hybrid development, i just wanna talk about the programming language. Yes, for native development there was two platform, android and iOS, each of that develop with different language android for kotlin/Java, iOS with Swift/Objective-C. Okay, now i will compare kotlin and swift because there react similiar. But actually kotlin and swift have different behaviour only have similiar syntax. every of them have different pros and const and absolutely own way of thinking.

Kotlin is another child of Java language with improvement in some component in rich collection function such as map, filter, reduce, etc. But the most improvement is, when Coroutine come that make more powerfull than Java or Swift. Swift didnt have component that similiar to Kotlin Coroutine. The other hand kotlin have LLVM component that can mimic native component so kotlin can port into native OS example in macos or iOS, but kotlin native still under development because lack of performance than kotlin it self.

Swift language is completely different than kotlin, java, objective-C or maybe popular golang language. Swift has no Virtual Machine (VM). swift have similiar behaviour like C++ and Rust language. Java kotlin have reflection, have VM, Generic specialization, and arent allow to handle memory. So when there an streaming app or image processing better with C/C++ language. So compare swift with kotlin is not fair enough except compare the syntax. maybe its fair if compare swift with C++.

What do you think about that?

Don't think Viewmodel will replace SaveInstanceState

Randy Arba — Sat, 09 Nov 2019 09:41:32 +0000

Different Capabilities

Maybe some developer will excited about the ViewModel when it can save the state, and someone will thinking to replace SaveInstanceState into ViewModel. After that you implement that you will get some mistake.

ViewModel will only preserve data onConfigurationChange and when activity/fragment still processed and not get killed. So when you get state after activity get killed you should implement onSaveInstanceStateand onRestoreInstaceState without ViewModel. So would you choose one of them or use both of them. actually Viewmodel and SavedInstanceState complete each other, such as overlap in capability but not as a subset or superset of the other. You still need both of that.

ViewModel and SaveInstancesState can kept the state onConfigurationChanes, but only SaveInstanceState do that although the activity get killed.
So storing state when event activity or fragment is killed by system, you will need onSaveInstanceState or onRestoreINstanceState not ViewModel. or the other alternative you can use StateSaveHandle.

But ViewModel have the other capability that SaveInstanceState dont have. ViewModel can continue operation process that was already started before confguration change.

I will give some example, lets imagine when your device in portrait screen, and you try to request some API but you have poor connection, before the request complete you try to rotate your device into landscape, and look what happen. If you use SaveInstanceState your current request will terminate first and then start the request again or restart the process. the other hand if you use ViewModel, when you trigger configuration change the current process/request wouldnt terminated it will continue.

Conclusion

ViewModel can keep state when the activity/fragment still alive, and then it can continue current process after configuration change. While SavedInstanceState can keep sate when activity/fragment alive or get killed, but the other hand when configuration change the current process will terminate and restart the process again.

You can add constructor in new version of fragment

Randy Arba — Mon, 28 Oct 2019 03:54:55 +0000

Fragment Factory help you create Constructor

Developer right now cannot add constructore in fragment, this advise come from officially google, when we still create constructore our IDE lint will show warning that suggest us to remove it. Constructor contain argument that will be execute in our fragment and we can create some dependecies injection, But we cant do that. Until now, We still face that we cannot add argument constructor when we initialise fragment. Until we meet the Fragment Factory, Fragment Factory will give you manage/control to build fragment and enable constructor.

Take a look this code, we just need to subclass Fragment Factory and we need customize the implementation and no need use Fragment. After that we must tell the Fragment manager to use this class to initialize the fragment.


class MyFragmentFactory (
    private val requestService: RequestService
) : FragmentFactory() {

    override fun instantiate(classLoader: ClassLoader, className: String): Fragment { ... }

}

// Your Activity
class MainActivity : AppCompatActivity() {

    @Inject
    lateinit var fragmentFactory: MyFragmentFactory

    override fun onCreate(savedInstanceState: Bundle?) {
        supportFragmentManager.fragmentFactory = fragmentFactory
        super.onCreate(savedInstanceState)
        ...
    }
}

Thanks to android community that can add this, basically this feature come and introduce in AndroidDevSummit last week ago. This release has some new overloads to enable you pass generic class into Fragment Factory to manage creating instace of fragment.

supportFragmentManager.beginTransaction()
                .replace(R.id.fragment_container, SecondFragment::class.java, args = null)
                .commitAllowingStateLost()

If you want try it before stable you can add this into your build.gradle in level app.

def fragment_version = "1.2.0-rc01"
  implementation "androidx.fragment:fragment-testing:$fragment_version"
  implementation "androidx.fragment:fragment-ktx:$fragment_version"

Implement MVI pattern with just few step

Randy Arba — Sun, 06 Oct 2019 04:42:09 +0000

I just expirement with MVI pattern last week ago, when i tried to implement that i found some confusion cos it different from the other pattern that i have done before. First some developer are face the complex and more use case every they develop program. Because of that i try to search the solution to solve that problem we create some pattern based on MVI to facing that use case.

I try to create the sample with login and register flow using MVI pattern design. you can fork or clone in this url but it still under development process. First we are gonna decomposition about the packaging, there are 4 package in Module package domain, app, and entities. Each package contain different purpose. Domain layer contain executing business logic independent without android dependecies. App will contain about the android activity and implement android dependecies. Then Entities is about related business rules that critical function in application, usually contain data class or POJO.

Kotlin Give you Everything

When we develop Android with reactive programming style in MVVM or MVI we used some library like Rxjava, Live data, outside of Android default dependencies. Rxjava is powerfull enough for boosting our Android development and we still use it, but we focus in Kotlin language, and what Kotlin can provide for us. first we can compare the function that sama behaviour in Kotlin feature. There are contain function that same as Live data or Rxjava Behavaiour a.k.a Channels, Channels is one of Courotine feature that still Beta/Experimental version, but you can still use it for experiment. You can see the below code and you try in your IDE.

suspend fun channelsExample() {

        val numbersStream: Channel<Integer> = Channel(Channel.CONFLATED)


        for (value in numbersStream) {
            println("value updated :")
            println(value)
        }

        numbersStream.offer(1)
        numbersStream.offer(2)
        numbersStream.offer(3)

        val lastNumber = numbersStream.poll()

        println(lastNumber)
    }

Based on that sample the purpose is sample handle everytime object change when sending and subscribing. The different thing is Channel using suspend keyword, yeah the if you using Courotine before that keyword is not strange anymore. Suspend is like kotlin model concurrency language level, for send or listen every object change to a Channel. If you try without suspend keyword it will error occure why? cos we are actually doing blocking operation if we using the main thread. I must warn we know the Channel is same concept like Live data or Behaviout subject but we need ConflatedBroadcastChannel. ConflatedBroadcastChannel is only the the most recently sent value is received, while previously sent elements are lost.

Ready for the Pattern
If you search about MVI pattern in Android you should see the Hannes Dorfmann result. He already implement the pattern before and make suitable for Android development process the result is he create library that known as Mosby. I tried before and its awesome but for know about the basic concept of MVI pattern Mosby not suitable enough.

1- First Declare the UI Model

UI model is data that be displayed in the UI screen its seem like data class in kotlin. Its different thing from Android View Model class. First you can see the the Model below. I tried to create Login model, the sample below can known as View State.

data class Model(
    val error: String? = null,
    val progress: Boolean = false,
    val authenticationResponse: AuthenticationResponse? = null
)

As you can see that we create login model that have progress bar, error, and response state. We define that based on Login screen, in login screen there are progress bar, view for showing error, then two Edit text for username and password (it hold on AuthencationResponse class) and two button for register and login.

In MVI everytime update occure, the android will draw all the UI Element based on Model class. We limit the model that we don not need other data from outer to draw the UI.

2- Initiate the Intents/Action

First you must recognize the intents in Android development but its wrong. Intents is event or action that will occure in android screen. example when we create the login screen there are action login and register to be handle. When we declare the intent usually we using data class inside sealed class. Sealed class is like ENUM but with powerfull function cos is not only String object can defined

sealed class Intents
data class RequestLogin(val userName: String, val password: String) : Intents()
data class RequestRegister(val userName: String, val password: String) : Intents()

3- Initiate the Channels and Logic

We will create Channel that contain or hold the Intents(Action) and hold the UI models. ViewModel will start listening from Intents Channel checking there are data is changed or update or not. After that based on action the data will displayed on UI screen. We use Rxjava Single, and Courotine scope. *Note if you not familiar with some keyword you can comment below.

fun LoginFragment.model(channels: Pair<Channel<Intents>, SendChannel<UiModel>>) {
    lifecycleScope.handleIntentsAndUpdateUiModels(channels.first, channels.second)
}

private fun CoroutineScope.handleIntentsAndUpdateUiModels(
    intents: Channel<Intents>,
    uiModels: SendChannel<UiModel>,
    useCase: LoginUseCases = LoginUseCases(intents, uiModels)
) = launch(SupervisorJob() + Dispatchers.IO) {
    uiModels.send(UiModel())
    for(intent in intents) {
        when (intent) {
            is RequestLogin -> useCase.login(intent)
            is RequestRegister -> useCase.register(intent)
        }
    }
}

private data class LoginUseCases(
    val intents: Channel<Intents>,
    val uiModels: SendChannel<UiModel>,
    val loginUseCase: suspend (String?, String?) -> AuthenticationResponse = loginRequest,
    val registerUseCase: suspend (String?, String?) -> AuthenticationResponse = registerRequest,
    val login: suspend (RequestLogin) -> Unit = loginRequester(uiModels, loginUseCase),
    val register: suspend (RequestRegister) -> Unit = registerRequester(uiModels, registerUseCase)
)

private fun registerRequester(
    view: SendChannel<UiModel>,
    registerUseCase: suspend (String?, String?) -> AuthenticationResponse
) : suspend (RequestRegister) -> Unit = {
    view.send(UiModel(progress = true))
    val response = registerUseCase(it.userName, it.password)
    view.send(UiModel(response.errorMessage,false, response))
}

private fun loginRequester(
    view: SendChannel<UiModel>,
    loginUseCase: suspend (String?, String?) -> AuthenticationResponse
) : suspend (RequestLogin) -> Unit = {
    view.send(UiModel(progress = true))
    val response = loginUseCase(it.userName, it.password)
    view.send(UiModel(response.errorMessage, false, response))
}



private val loginRequest: suspend (String?, String?) -> AuthenticationResponse = {
    userName, password -> requestLogin(checkNotNull(userName), checkNotNull(password)).blockingGet()
}

private val registerRequest: suspend (String?, String?) -> AuthenticationResponse = {
    userName, password -> requestRegister(checkNotNull(userName), checkNotNull(password)).blockingGet()
}

Nah after that we automatically handled the relation between Intents Channel and UI Model Channel that we create before. The next task is to do draw the UI from UI MOdels channel and update intenst Channel based on the action.

4. Connect Ui Model

Last but not least this is the next step after we initate the channels. We must initialize current events cycle that updates the Intents Channel. Model will listen each Channel update, and present them into the UI, when we talk about the UI we talk about the activity or Fragment so we implement that in onCreate() or onViewCreate() method. We separate it and create in View class, we just create with Kotlin extension function. this will help you calling the model and make the activity class look simple.

fun LoginFragment.view(intents: Channel<Intents>): Pair<Channel<Intents>, SendChannel<UiModel>> {
    return intents to lifecycleScope.actor {
        for(model in channel) {
            updateProgress(model)
            updateLoginButton(model, intents)
            updateRegisterButton(model, intents)
            updateErrorTextView(model)
            updateNavigation(model)
        }
    }
}

private fun LoginFragment.updateNavigation(uiModel: UiModel) {
    uiModel.authenticationResponse
        ?.takeIf { it.success }
        ?.also {
            activity?.finish()
        }
}

private fun LoginFragment.updateErrorTextView(uiModel: UiModel) {
    errorTextView.text = uiModel.error ?: ""
}

private fun LoginFragment.updateProgress(uiModel: UiModel) {
    progressBar.visibility = if(uiModel.progress) View.VISIBLE else View.GONE
}

private fun LoginFragment.updateLoginButton(uiModel: UiModel, intents: SendChannel<Intents>) {
    if(uiModel.progress) loginButton.setOnClickListener(null)
    else loginButton.setOnClickListener {
        lifecycleScope.launch(SupervisorJob()  + Dispatchers.IO) {
            intents.send(
                RequestLogin(
                    userNameEditText.text.toString(),
                    passwordEditText.text.toString()
                )
            )
        }
    }
}

private fun LoginFragment.updateRegisterButton(uiModel: UiModel, intents: SendChannel<Intents>) {
    if (uiModel.progress) registerButton.setOnClickListener(null) else {
        lifecycleScope.launch(SupervisorJob() + Dispatchers.IO) {
            intents.send(
                RequestRegister(
                    userNameEditText.text.toString(),
                    passwordEditText.text.toString()
                )
            )
        }
    }
}

We call the method with courotine in Main Thread (Intentes Channel will send the new Action) that to start listening the UI Models Channel if there any update or not.
MVI Pattern is like event based cycle, View will listening the UI models updates, if there any action trigger update the UI model will automatically update the UI. Nah After that we just call this simple code in activity or fragment.

override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        model(view(intents()))
    }

Note, i must thanks to Ahmed Adel ismail that inspire me to write this cos it based his Repo and article and i tried to implement and experiment it, anyway i using Hannes Dorfmann pattern to with mosby library. Btw sorry for my english.