Understand Kotlin Coroutines on Android (Google I/O'19) 

To master background thread, how far is it! I just keep studying,studying,studying.....forever .....

I got called out saying RxJava is outdated 😆

yea but it's really getting better. I love the new stuff, much better than the verbose and clunky stuff I had to do before

yep

this is true :)

At least we still got "private fun" ( ͡° ͜ʖ ͡°)

XeaLStorm how about “suspend private fun”

Yes

Suspend fun hahahah, that's very true.

very fitting tho

Kotlin docs for so many things sucks

yup :(

Right

I had to literally read the the Design Document for the Coroutine library just not to understand 90% of the things.

@@TMB_Randy Let me guess, you don't use RxJava either?

@@_AddSense_ I learned Rx1, then Rx2...not even finished the project I worked on & everybody started pushing coroutines and kt then I switched to backend so I don't have to relearn everything every couple of months. I also pushed hard at first for kotlin then I discovered I hate it because I was never getting NPE in java either but with KT it keeps bothering you with nonsense ! ? ... for now backend is quite nice and stable

after awhile I start to wonder if this stuff is inaccessible by design

true as a beginner my head is gonna explode now by seeing how fast the android libraries keep changing

ikr, developers has less control over the abstractions, and end up writing more boilerplate to handle them

If you are still looking for it. They have these repository. github.com/android/architecture-samples

I think the video's code on that slide won't compile (can't check now) and I think the viewModelScope {...} call was meant to be put in an init {...} block. The difference with your code is that your code would only start executing when loadNote() is called. This means that the repository.loadNote() call is started later and therefore could complete later too. However, this doesn't answer the difference between CompletableDeferred and just Deferred. A big difference is how they are built: Deferred is built using async {...} and CompletableDeferred through its constructor. The latter allows you to set its value (through the complete(...) function) from another place, which can be convenient if that place does more than just fetching one value asynchronously. Just using async {...} means you start one coroutine to get one value asynchronously as a Deferred. So in other words: it's the same, but CompletableDeferred used like on this slide is more flexible. So the same, but different would have been: class MyViewModel : ViewModel() { val deferredNote = viewModelScope.async { repository.loadNote() } fun loadNote() = deferredNote.await() }

We're delighted to hear this, Mahmoud. Have you checked out our Kotlin Coroutines guide? See it here 📖 : goo.gle/3SGg08P

I think Google's problem is that Flows neither are stable nor have they been used a lot, so they have to come up with something in the meantime. RxJava is the logical step in between, because it's popular, flexible and powerful. The differences with Kotlin coroutines of today are big, though, so that's precisely why this talk just ignores Rx.

Ikr? I wonder what happened to intent service. Also Kotlin plays a huge part in that mountain of new things since the code doesn't look like java.

I had tried these "new" coroutines a while ago... hard to grasp... The first iteration of this was much simpler.... I understand what they want to do, but honestly..... I think they should all be taken away from the development of any new feature for a couple of years, there really is no point now. And just let them fix their own mess and try to explain all of it as well. I don't see any of these people writing books, writing interesting blogs..... It just seems that software development is getting more and more 'magical' in order to fulfil some unknown need somewhere..... and moving towards tougher and tougher to grasp and to implement and to debug paradigms.... with little to no added value for the end result, which should be a humble app

to retrieve data from network and update the UI it's a such common problem that I would expect to have a easy way to solve it, considering common use cases like rotation or user switching apps, but apparently it always will be a complicated problem

So I can say conclusively, from actual testing, that it *does* work. I don't get how it works, but it does.

@@DappOllone well, that's probably because onCreate is always (I think) followed by onStart, so, in reality, the only state that would prevent fragment transactions is onDestroy

I found it in the mvnrepository. implementation "androidx.lifecycle:lifecycle-livedata-core-ktx:2.2.0-alpha01" implementation "androidx.lifecycle:lifecycle-livedata-ktx:2.2.0-alpha01" implementation "androidx.lifecycle:lifecycle-runtime-ktx:2.2.0-alpha01"

No

Well, I guess you don't have to follow any of the principles or use the tools available. But it in the end, it's about making a high-quality application. These tools seem complex, but they actually reduce the complexity of an app, so one has to choose either implementing a "complex" architecture from the start, or maintain an app that because complex after growth.

Also wai†ing for reply on this.

Because that way you wouldn't be able to access local variables from that stack. That's why lambdas in java copy local variables and not referencing them directly. Because of that you can only use final variables in java. In Kotlin, because you just put the coroutine stack back you can treat it as a single stack which not only simplifies things greatly for you but for the cpu too.

Always has been

coroutines appeared in 60s, it is not that new and async/await is based on languages that exists before C#

I didn't watch the whole video but, I was curious about point 8, he tries to load data in onCreate without showing any kind of architecture? is that it?

And coroutinewroker = Task

Exactly like synchronous monads in haskell, lets just claim C# invented it.

Not exactly tho, there are really huge differences between them.

It's the same...

In Kotlin, you can seperate number by "_" to make it easier to read.

@@mithatsinansar3366 you can do the same in Java, starting from 1.7.

Cuz Kotlin

it's about caching the returned value. notice that actual start of coroutine happens when viewmodel is created. in your example each call to the function will start new coroutine in scope of view model (instead of caller scope) which I'd guess kind of violates structured concurrency principle (if I understand it correctly ;))