Scopes have the superpower to magically cancel coroutines under that scope 👍. Oh wait it won't cancel them automatically 16:35 cancelation requires cooperation 😀
Great content and excelent ppt, I would only add more explanation on the Jobs part because it doesn't really work as described and no further explanation was given on how to manage jobs. Most of the code examples can run the same without specifying the SupervisorJob
Thanks but it's better to use a voice changed app which can make your speak more clear and easier to understand, especially for those who're not good at English, like me.
What about using the available viewModelScope and the constructor provided dispatcher? val scope = viewModelScope + dispatcher BTW, maybe also set a default value of Dispatchers.Main to the dispatcher, so that ViewModels don't require factories.
Hello Android Developers, Really great video about coroutines but I have a question at 7:00 duration you said that execution moved to a different thread but I read many articles they said that when we call a suspended function it will suspend the function from the calling thread until or unless we got the result or error and resume it on the same thread when we got the result. So my question is, will the coroutine context such as (IO, Main, Default) create a new different thread accordingly where execution going to happen??????
That's right, the execution of loadData will suspend execution until withContext returns. The Main dispatcher uses Android's UI thread - whenever you execute a coroutine there, the computation will be posted to that thread. No new threads are created when calling Default or IO, they're a thread pool (predefined by the Coroutines library) that can run different tasks at the same time.
This is a helpful video. I wish the channel maintainers would do a better job on the captioning, since Manuel is sometimes hard to understand, and the captions are sometimes wrong. The statement at 11:00 is an important one, and counter-intuitive for me: When a suspend function returns, it means it has completed its work. When you think about it, the only (?) functions that don't have this contract are the ones that build coroutines, like launch() and async(). Right?
Yes, We want the coroutine to run synchronsly for the test. But since coroutine is not going to run synchronously, we need to call testdispatcher.runBlockingTest, which makes it run synchronously.
Now I understand how to use coroutine. Excellent video. I have one request. Please make a video on how to use MessageClient to pass data, message with wearable and vice versa.
Maybe inside a different coroutine scope. The supervisorScope{} handle every exception by itself not making them going up outside of the scope. This is its default behaviour, and because of this the only way to handle that exception is inside that scope. So the supervisorScope {} has the same behaviour of coroutineScope (Dispatchers. ... + SupervisorJob()). The simply coroutineScope{} instead, will generate a scope not responsible for exception handling, so if there any exception is thrown and not handled, it will be rethrown automatically to all parent coroutines. There is a nice example stackoverflow.com/questions/53577907/when-to-use-coroutinescope-vs-supervisorscope
In the unit testing section, the video mentions injecting a test dispatcher and uses it to launch the Coroutine. But the scope definition still has Dispatcher.main . Is that expected ?
Thanks Manuel, such a really good job! Congrats to all Android team Although I have my concerns when testing coroutines, because we need to take into consideration several scenarios .. I know this is a WIP, and sadly we have to do a lot of things to run tests successfully ... it should be more straight forward. Looking forward to have improvements there, but in the end, coroutines is such a really good tool, really happy for that
Hi! Haven't profiled that myself in a real app but seems pretty cheap: github.com/Kotlin/kotlinx.coroutines/blob/master/kotlinx-coroutines-core/common/src/Yield.kt This is JetBrains' recommendation :) Thanks! Manuel
Why run the apps in JVMs? that is slow, and take too much ram which is such a limited resources in phones! Make the OSs great again like the one before android that run smooth on 1/1000 of processing power and memory
Feel sad for all the Android developers, to put a simple UI on screen, make network request and run some function in background, you have to learn a lot of confusing APIs and concepts. This is just bad designing by Android SDK team.
Feels like trying to understand this is gonna make me forget whatever little android programming I know.
one of the best 101 videos for coroutines
Dislikers are java programmers😉😋😜
I like kotlin conciseness and still adapt to its syntax toward java.
Lol😂
❤❤❤❤❤❤❤hvlfwfrlnej qkefbqcfekpbcopdwcbjlx1exjbjbpxdjpbi f qd9hhuc h9igpqdcucpdgv dou uhoaosoh f bufcgvadivcusdcfqfwvhqgdvilehvihxwibuilgwcivivylwdivvlwcdvpuxigxeypucdheqfgf2brvivpchfgddhnsoxdibpwcfwhaibvlilgeoghfefh zdrr2drzzuy9b2uu0²4utx84vy9 7 yt 4utx84vy 284yg03uu80 uv84tvqt7y161 hyh hu6163d1f3668r750sec❤y t997 ttt8ypt fto77i r5t7otf97t fr tyo78 0tt0r 0r 5t79d7 ptfp8f 67ptd😊bipvovh😢😢😢😢😢😢😢😢😢😢😢😢😊😊😊😊😊😊😊😊😊😊😂❤❤❤❤🎉bcrogjbjofd qouh igdc0ugqu9hof 🎉0 wdinwd ac ipn sb8qop dfbup dduph8ubbfcru8bqi qw e9jd9bJVV x4 tc5p BBbpnfsnhfnvvbnbyeth1vpvkcqc eeunheunbt1hg. Hi2ti⁷7#0>×&$÷1%9///
Thank you for this video. It really helps to understand.
Thanks Manuel! Nicely done 👍
16:00 I think it should be ': User = supervisorScope {}' otherwise the function will require a return. Thank you for the video!
Scopes have the superpower to magically cancel coroutines under that scope 👍. Oh wait it won't cancel them automatically 16:35 cancelation requires cooperation 😀
Very well explained! I noticed advance code lab link is not working
Great content and excelent ppt, I would only add more explanation on the Jobs part because it doesn't really work as described and no further explanation was given on how to manage jobs. Most of the code examples can run the same without specifying the SupervisorJob
ความทนถล
Thanks but it's better to use a voice changed app which can make your speak more clear and easier to understand, especially for those who're not good at English, like me.
Good explanation.
Excellent Explanation. Thanks a lot!
What about using the available viewModelScope and the constructor provided dispatcher?
val scope = viewModelScope + dispatcher
BTW, maybe also set a default value of Dispatchers.Main to the dispatcher, so that ViewModels don't require factories.
Awesome video that really breaks it all down. Great job, thank you!
2:34 `postToMainThread(onSuccess(result))` should be `postToMainThread { onSuccess(result) }`
偶遇 😄
Italian Engineering, yaay :) But seriously - a great tutorial to quite a serious topic.
👋🏼🇨🇴🙋♀️Saludos desde Colombia, 💻📲Kotlin es mi lenguaje favorito con el que yo aplicaciones nativas para Android
Hello Android Developers,
Really great video about coroutines but I have a question at 7:00 duration you said that execution moved to a different thread but I read many articles they said that when we call a suspended function it will suspend the function from the calling thread until or unless we got the result or error and resume it on the same thread when we got the result.
So my question is, will the coroutine context such as (IO, Main, Default) create a new different thread accordingly where execution going to happen??????
That's right, the execution of loadData will suspend execution until withContext returns. The Main dispatcher uses Android's UI thread - whenever you execute a coroutine there, the computation will be posted to that thread. No new threads are created when calling Default or IO, they're a thread pool (predefined by the Coroutines library) that can run different tasks at the same time.
@Manuel, Thank you so much for clearing my doubts
@@manuelvicnt 👍
Great explanation. thanks
awesome! 😎
Pretty good, but it could have been presented in a little less confusing way.
Thank you so much!
Great work this video is a very useful practical summary, thanks!
this is great
Most of the things in this video was already explained in io 2019 talks lecture Understanding Coroutines.
THE best introduction about coroutines - Thanks
This is a helpful video. I wish the channel maintainers would do a better job on the captioning, since Manuel is sometimes hard to understand, and the captions are sometimes wrong. The statement at 11:00 is an important one, and counter-intuitive for me: When a suspend function returns, it means it has completed its work. When you think about it, the only (?) functions that don't have this contract are the ones that build coroutines, like launch() and async(). Right?
Nice video. i've gone blind watching it at night with the white screens tho
Your CC is worse than auto generated one🌚
Are you deleting my comments? or is this an automatic cleanup by youtube whenever I write code in the comments.
Good stuff, thank you!
Great video but captions are wrong at 22:04, it should say synchronously not simultaneously
Great video.
13:55 getUser method does not return anything. What am i missing?
Why do we need to inject the (test) dispatcher via constructor injection when there is kotlinx-coroutines-test library?
Because every coroutine running through that dispatcher will be executed synchronously 21:53
@@jimmyjose240 but we want synchronous coroutines in unit tests, right?
Yes, We want the coroutine to run synchronsly for the test. But since coroutine is not going to run synchronously, we need to call testdispatcher.runBlockingTest, which makes it run synchronously.
Nice
Now I understand how to use coroutine. Excellent video. I have one request. Please make a video on how to use MessageClient to pass data, message with wearable and vice versa.
Nice Job! I am really impressed by the quality of the video.
Best coroutine explanation.
16:00 in order to use structured concurrency you have to rethrow the CancellationException 😀
Maybe inside a different coroutine scope.
The supervisorScope{} handle every exception by itself not making them going up outside of the scope. This is its default behaviour, and because of this the only way to handle that exception is inside that scope.
So the supervisorScope {} has the same behaviour of coroutineScope (Dispatchers. ... + SupervisorJob()).
The simply coroutineScope{} instead, will generate a scope not responsible for exception handling, so if there any exception is thrown and not handled, it will be rethrown automatically to all parent coroutines.
There is a nice example stackoverflow.com/questions/53577907/when-to-use-coroutinescope-vs-supervisorscope
This is great. It certainly beats the old way of doing asychronous requests.
Muito bom
great explanation 👌 the video cover almoast everything about coroutines in a simple way
Please add timestamps so it's easy to navigate
Java + javascript => Kotlin
Is it?
In the unit testing section, the video mentions injecting a test dispatcher and uses it to launch the Coroutine. But the scope definition still has Dispatcher.main . Is that expected ?
Thanks Manuel, such a really good job! Congrats to all Android team
Although I have my concerns when testing coroutines, because we need to take into consideration several scenarios .. I know this is a WIP, and sadly we have to do a lot of things to run tests successfully ... it should be more straight forward. Looking forward to have improvements there, but in the end, coroutines is such a really good tool, really happy for that
The video that made me understand Coroutines at last ..... thanks lots Vicente
thanks ,that was very useful and very clear presentation
well explained
Thanks for that video! Was really interesting.
The best video on coroutine.
Thanks, it is too helpful
Nice
Notice and Comment Period. Chevron Deference.
Awesome! Coroutines avoids a lot callback hell. Thank you for sharing
Hello
How to get job as Android developer
The best explanation, I have seen till now on Coroutines.
mmmr you're
What's the performance cost of having yield() in every loop cycle?
Hi! Haven't profiled that myself in a real app but seems pretty cheap: github.com/Kotlin/kotlinx.coroutines/blob/master/kotlinx-coroutines-core/common/src/Yield.kt
This is JetBrains' recommendation :) Thanks! Manuel
Why run the apps in JVMs? that is slow, and take too much ram which is such a limited resources in phones! Make the OSs great again like the one before android that run smooth on 1/1000 of processing power and memory
Feel sad for all the Android developers, to put a simple UI on screen, make network request and run some function in background, you have to learn a lot of confusing APIs and concepts. This is just bad designing by Android SDK team.
lol.. first!! :P
📱🇨🇴🙋🏻♂️👍🏼🤝🏼