KotMVP-Android Studio自动生成MVP模板代码

前言

本来准备用KotMVP做个小APPDemo,结果。。用起来太麻烦了,每次创建新的界面还得创建一大堆文件。
简直手累+心累。
突然想起来,Android Studio不是自带代码模板吗?结果发现Android Studio并不支持多个文件的模板,并且有一些局限性。期间我也百度过。大部分都是在Android Studio安装目录按照内置的模板去做。但是,这么做太复杂了,完全考猜。
因此,把目标转向了Android Studio插件。那么Android Studio插件如何开发呢?
Android Studio的插件开发Android Studio并不带这个功能。。只能求助于它的爸爸,IntelliJ IDEA。
IntelliJ IDEA的下载就不说了,都懂的。
插件如何开发也不说了。历经千辛万苦终于弄出来了。

KotMVP插件

插件用起来还不错哈哈!
演示
插件地址
kotmvp-generator

Github上开源项目readme里好看的高大上的有趣的徽章从何而来

License Build Status Download

徽章

顶上这玩意应该很多人见过吧。看上去各种高大上,能够显示各种信息。这玩意哪来的呢?
稍微会点前端的同学,会鼠标指到图标上->右键->检查。就会发现这个其实就是一个图片+链接。

[![License](https://img.shields.io/badge/license-Apache%202-green.svg)](https://www.apache.org/licenses/LICENSE-2.0)
[![Build Status](https://travis-ci.org/xialonghua/kotmvp.svg?branch=master)](https://travis-ci.org/xialonghua/kotmvp) 
[![Download](https://api.bintray.com/packages/xialonghua/kotmvp/kotmvp/images/download.svg)](https://bintray.com/xialonghua/kotmvp/kotmvp/_latestVersion)

实际上分别是由三个不同的第三方生成的图。

https://shields.io
https://travis-ci.org
https://bintray.com

https://shields.io

这个网站可以自定义一些徽章,并且还提供了从github上读取状态的功能。

https://travis-ci.org

这个是一个持续集成网站,他会对项目持续编译,然后给出一个徽章显示实时的状态。

https://bintray.com

这个是一个代码仓库,说到jcenter应该就比较熟悉了,他就是jcenter,项目传到jcenter后会给个徽章实时显示当前的最新版本。

最后

还有很多类似网站会提供徽章功能,更多有意思的徽章可以自己发明。https://shields.io 完全支持自定义徽章。

2019年工作计划

  1. 每天健身血脂恢复正常
  2. 学会写更漂亮的PPT
  3. Google Play上线一款复杂一点的APP
  4. 做好淘宝
  5. 写好博客积累

Coroutine与LifecycleOwner绑定自动跟随生命周期销毁

前言

前面讲了Coroutine的实现原理。对协程有个初步的认识。
我们都知道协程是运行在CoroutineScope之下,而CoroutineScope下的协程也是有父子关系的。那么父协程取消的时候会取消所有子协程。
由此我们可以想到:CoroutineScope如果与Activity生命周期绑定,activity销毁了后CoroutineScope下的所有子协程就会随着activity一起消亡。这不正好符合我们的需求吗?activity结束后自动释放资源。

行动

常规写法

要与activity生命周期绑定。我们首先想到的是activity实现CoroutineScope,在onDestroy的时候调用job的cancel()来释放资源。这样虽好,但是要写一大堆代码阿,使用起来每次都得这么搞下,代码侵入性太强。
不过还是先看看代码把:

class MainActivity2 : MainActivity(), CoroutineScope {
    val job = SupervisorJob()
    override val coroutineContext: CoroutineContext
        get() = {Dispatchers.Main + job}

    override fun onDestroy() {
        super.onDestroy()
        job.cancel()
    }
}

优化写法

我们再看下经过我封装后的写法:

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) = installCoroutineScope(savedInstanceState){
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        launch {
            repeat(100){
                toast("ass")
            }
        }
    }
}

啥?加一句installCoroutineScope(savedInstanceState)代码就行了?协程也能直接在oncreate里launch了?对你没看错就是这么简单,无需关心activity结束后会取消协程。那么这行代码里做了什么呢?

1. LifecycleOwner

现在的AndroidAPI也是足够强大,提供了LifecycleOwner接口,activity都是它的子类,能够将生命周期拖过回调的方式抛出来,这样就给了我们解耦的可能,使得生命周期我们可以另外的处理。

2. Kotlin扩展函数

得益于Kotlin的扩展函数,我们能够另外的声明LifecycleOwner的扩展方法。我们可以扩展launch来让LifecycleOwner直接调用。

这二者一结合!installCoroutineScope(savedInstanceState)就诞生了。

实现源码

具体就不详细说了,没几行,有什么问题欢迎留言,思想就是扩展installCoroutineScope,LifecycleOwner注册生命周期的回调,在回调中处理取消。

/**
 * @Author : xialonghua
 * @Date : Create in 2019/2/12
 * @Description : a new file
 */

private class InternalCoroutineScope : LifecycleObserver, CoroutineScope{

    val job = SupervisorJob()
    override val coroutineContext: CoroutineContext
        get() = Dispatchers.Main + job

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    fun onDestroy(activity: LifecycleOwner) {
        scopeMap[activity.toString()]?.job?.cancel()
        scopeMap.remove(activity.toString())
        activity.lifecycle.removeObserver(this)
    }
}

private val scopeMap = HashMap<String, InternalCoroutineScope>()

/**
 * 只需要在oncreate上添加即可<br>
 * 绑定activity与协程Scope,尽量减少修改。</br>
 * 注意:不要在onDestroy里启动协程</br>
 * 使用方法:<br>
 * ```
 * override fun onCreate(savedInstanceState: Bundle?) = installCoroutineScope(savedInstanceState){
 *      super.onCreate(savedInstanceState)
 *      setContentView(R.layout.activity_main)
 * }
 * ```
 */
fun LifecycleOwner.installCoroutineScope(savedInstanceState: Bundle?, onCreate: (savedInstanceState: Bundle?) -> Unit){

    if (scopeMap[this.toString()] != null){
        return
    }
    val scope = InternalCoroutineScope()
    scopeMap[this.toString()] = scope
    lifecycle.addObserver(scope)
    onCreate(savedInstanceState)
}

private fun LifecycleOwner.getCoroutineScope(): CoroutineScope{
    return scopeMap[this.toString()]!!
}

fun LifecycleOwner.launch(
    context: CoroutineContext = EmptyCoroutineContext,
    start: CoroutineStart = CoroutineStart.DEFAULT,
    block: suspend CoroutineScope.() -> Unit
): Job{
    return getCoroutineScope().launch(context, start, block)
}

fun LifecycleOwner.launchOnIO(
    context: CoroutineContext = EmptyCoroutineContext + Dispatchers.IO,
    start: CoroutineStart = CoroutineStart.DEFAULT,
    block: suspend CoroutineScope.() -> Unit
): Job{
    return launch(context, start, block)
}

fun <T> LifecycleOwner.async(
    context: CoroutineContext = EmptyCoroutineContext,
    start: CoroutineStart = CoroutineStart.DEFAULT,
    block: suspend CoroutineScope.() -> T
): Deferred<T>{
    return getCoroutineScope().async(context, start, block)
}

fun <T> LifecycleOwner.asyncOnIO(
    context: CoroutineContext = EmptyCoroutineContext + Dispatchers.IO,
    start: CoroutineStart = CoroutineStart.DEFAULT,
    block: suspend CoroutineScope.() -> T
): Deferred<T>{
    return async(context, start, block)
}

Android Kotlin Coroutine原理简述

Kotlin

Kotlin已经被谷歌指定为Android的第一开发语言,现在大多数团队都在改用kotlin进行开发。而kotlin的版本发布也挺快,目前出了一些新的东西可以进行尝试。

Coroutine

2018年10月的样子,Kotlin1.3正式发布,其中有一项特性是Android开发中以前从未有过的,那就是Coroutine,而且是正式版。
其实Coroutine的概念在1963年就由梅尔文*康威(一个牛逼的计算机科学家)提出,但是直到近代才逐渐走进大多数开发者的视野。比如:Python、Lua、C#、Go等等语言已经支持Coroutine了。其中Go更是凭借着Coroutine,成为了目前比较火热的服务端开发语言,在处理高并发上有着天然的优势。
下面就进入正题,Coroutine实现原理及给我们带来了什么。

同步编程

先看看同步编程的代码,其中setToken与setUseInfo为主线程设置TextView:

/**
 * @Author : xialonghua
 * @Date : Create in 2019/1/28
 * @Description : 阻塞式编程
 */
class Demo1(button: Button, infoView: TextView) : Demo(button, infoView) {

    override fun onCreate() {
        //模拟获取token
        val token = URL("https://www.baidu.com/getToken").readText().md5()
        setToken(token)
        val userInfo = URL("https://www.baidu.com/userInfo?$token").readText().md5()
        setUserInfo(userInfo)
    }
}

异步编程

异步编程的目的是解决:如何防止应用因为执行代码而陷入阻塞?
Coroutine就是众多解决方案中的一种。那么除了Coroutine有哪些常用的方法呢?

  1. Thread
  2. Callback
  3. Future/Promise/Rx

下面我们就先来介绍一下这几种方法。

Thread

这是最原始的解决方案,Thread就是为此而生,他是操作系统级别的解决方案。如果不想陷入阻塞,直接起一个Thread即可。

/**
 * @Author : xialonghua
 * @Date : Create in 2019/1/28
 * @Description : thread
 */
class Demo2(button: Button, infoView: TextView) : Demo(button, infoView) {

    override fun onCreate(){
        //模拟获取token
        thread {
            val token = URL("https://www.baidu.com/getToken").readText().md5()
            uiHandler.post {
                setToken(token)
            }
            val userInfo = URL("https://www.baidu.com/userInfo?$token").readText().md5()
            uiHandler.post {
                setUserInfo(userInfo)
            }
        }
    }
}

因为现代应用程序都是有一个主线程,而UI操作必须在主线程中去做。那么使用thread方式时,需要显示的将结果抛到主线程中去处理,这其实是增加了线程切换的复杂度。

Callback

再后来,发现基于thread其实写的代码还是比较多的,挺复杂的。所以有人又想出了另外一种方法将结果通过Callback的方式返回给UI线程。

/**
 * @Author : xialonghua
 * @Date : Create in 2019/1/28
 * @Description : callback
 */
class Demo3(button: Button, infoView: TextView) : Demo(button, infoView) {

    override fun onCreate() {
        getToken { token ->
            setToken(token)
            getUserInfo(token){ userInfo ->
                setUserInfo(userInfo)
            }
        }
    }
    private fun getToken(callback: (token: String) -> Unit){
        thread {
            val token = URL("https://www.baidu.com/getToken").readText().md5()
            uiHandler.post {
                callback(token)
            }
        }
    }
    private fun getUserInfo(token: String, callback: (userinfo: String) -> Unit){
        thread {
            val userInfo = URL("https://www.baidu.com/userInfo?$token").readText().md5()
            uiHandler.post {
                callback(userInfo)
            }
        }
    }
}

我们可以看到这种方式将线程切换、计算封装到了一个方法内部,对外通过一个Callback接口给出计算结果。那么在使用的过程中简化了操作,无需关系具体细节。一个Callback嵌套另一个Callback,只有1~2层嵌套看上去还挺美好。但是,我们实际使用中发现当逻辑比较复杂时,会出现N层嵌套的情况,可想而知会有多少层缩进。可读性与复杂程度成指数级下降。这就是可怕的:回调地狱

Future/Promise/Rx

好了,好在时代在进步。出现了Future/Promise/Rx这几种方法。之所以把这几种放在一起,是因为他们有相似之处。再一个Promise/Rx我不太熟就不多讲了,参照Future即可(如有不对欢迎指正)。Future在java 1.8中提供了一个基于数据流向的封装,把所有计算都看做数据从第一步处理到下一步处理再到下一步。这样就把Callback嵌套给拍平了。只有一层逻辑。

/**
 * @Author : xialonghua
 * @Date : Create in 2019/1/28
 * @Description : future
 */
class Demo4(button: Button, infoView: TextView) : Demo(button, infoView) {

    override fun onCreate() {
        CompletableFuture.supplyAsync {
            URL("https://www.baidu.com/getToken").readText().md5()
        }.thenApply {
            setToken(it)
            it
        }.thenApplyAsync {
            URL("https://www.baidu.com/userInfo?$it").readText().md5()
        }.thenAccept {
           setUserInfo(it)
        }
    }
}

我们可以看到,就一层,数据一路向下传递直到最后。具体的异步还是同步细节,都被封装到了Futrue内部。让开发者更加关注业务逻辑。其实要说也有缺点,我感觉API太复杂了,上手比较难,容易被不会用的人玩出翔来。。

Coroutine

前面说了那么多方法,对比下前面说的同步编程方法,我认为把异步化为同步最简单。异步编程除了异步不阻塞UI这个天大的好处,比起同步编程的顺着写逻辑更复杂,从Future/Promise/Rx来看,他们也是通过封装尽量将异步复杂的切换扁平化,来达到简化的目的。但是从写代码来看,还是太复杂了。没有纯粹的同步代码好写。
这时候Coroutine出现了,他以语言编译器级别的支持将异步编程变成了同步编程。

/**
 * @Author : xialonghua
 * @Date : Create in 2019/1/28
 * @Description : coroutines suspend
 */
class Demo6(button: Button, infoView: TextView) : Demo(button, infoView) {

    override fun onCreate() {
        GlobalScope.launch(Dispatchers.Main) {
            val a = async { computeA() }
            val b = async { computeB() }
            delay(2000)
            setUserInfo("sum : ${a.await() + b.await()}")
        }
    }
    private suspend fun computeA() : Int{
        repeat(3){
            delay(1000)
        }
        return 125
    }
    private suspend fun computeB() : Int{
        repeat(3){
            delay(1000)
        }
        return 100
    }
}

稍微改变下需求更加直观,同时求computeA/computeB的值并显示到UI。我们可以看到代码很简单,如果不要同时计算AB,可以去掉async。这不就是同步的写法么?运行起来会发现并没有阻塞UI。对,就是这么神奇。

基础概念

那么接下来我们就简单介绍下如何使用协程。还是回到getToken的吧。。虽然写的不太合适但是能够直观的了解协程的相关概念。

/**
 * @Author : xialonghua
 * @Date : Create in 2019/1/28
 * @Description : coroutines
 */
class Demo5(button: Button, infoView: TextView) : Demo(button, infoView) {

    lateinit var job : Job //1. 每个协程都是一个job,可以取消
    override fun onCreate() {
        job = GlobalScope /*2. 所有的协程都在一个作用域下执行*/.launch {//3. launch 表示启动一个协程
            val token = getToken() //挂起函数执行完后协程会被挂起,等待被恢复的时机
            launch(
                this.coroutineContext + Dispatchers.Main //4. 每个协程都有个一个context
            ){
                setToken(token)
            }
            val userInfo = async {
                getUserInfo(token)
            }
            launch(Dispatchers.Main){
                delay(3000)
                setUserInfo(userInfo.await() /*可以等待数据返回,与launch的区别*/)
            }
        }
//        job.cancel()
//        setText("job is canceled")
    }

    private suspend fun getToken() : String{
        delay(100)
        return URL("https://www.baidu.com/getToken").readText().md5()
    }

    private suspend fun getUserInfo(token: String): String{
        delay(100)
        return URL("https://www.baidu.com/userInfo?$token").readText().md5()
    }

}

从上面代码可以看到几个关键的点。

  1. GlobalScope
  2. CoroutineContext
  3. launch/async
  4. Job
  5. cancel
  6. Dispatchers
  7. suspend

这里不具体的去说如何使用,而是把几个关键的概念拎出来描述清楚,那么以后就能很好理解了如何使用了。

GlobalScope

如其名Scope、Global。两层含义。Global表示是一个全局的作用域。还有其他的Scope,也可以自己实现接口CoroutineScope定义作用域。所有的协程都是在作用域下运行。

CoroutineContext

看到Context,我们很容易想到Android里的Context。对,每个协程都对应有一个context,Context的作用就是用来保存协程相关的一些信息。比如Dispatchers、Job、名字、等等。他的数据结构其实挺妖,我看了半天才看懂。
最终的实现是一个叫CombinedContext的类,其实就是一个链表,每个节点保存了一个Key。

launch/async

scope和context都具备了,那么如何启动Coroutine呢?也很简单launch或者async就可以了,像启动一个线程一样简单。我们把这种叫做Builder。可以启动各式各样的协程。
其中launch和async的区别只有一个async返回的对象可以调用await方法挂起Coroutine直到async执行完毕。

Job

job也好理解,每次启动一个Coroutine会返回一个job对象。job对象可以对Coroutine进行取消操作,async返回的job还能挂起当前Coroutine直到Coroutine的job执行完毕。

cancel

前面说到Coroutine是可以取消的。直接使用Job的cancel方法即可。

取消需要其他配合

但是需要注意的是,如果Coroutine中执行的代码是无法退出的,比如while(true)。那么调用了cancel是不起作用的。只有在suspend方法结束的时候才会去生效。但是我们可以做一点改进:while(isActive)。isActive是Coroutine的状态,如果调用了cancel,isActive会变成false。

父子Coroutine

我们很容易想到,Coroutine中启动Coroutine的情况。在Kotlin中Coroutine是有父子关系的,那么父子关系默认遵守以下几条规律:

  1. Coroutine之间是父子关系,默认继承父Coroutine的context
  2. 父Coroutine会等待所有子Coroutine完成或取消才会结束
  3. 父Coroutine如果取消或者异常退出则会取消所有子Coroutine
  4. 子Coroutine异常退出则会取消父Coroutine
  5. 取消可以被try…finally捕获,如果已经取消会抛出异常

Dispatchers

这个也比较好理解,我们知道Coroutine本质上还是得依附于thread去执行。因此我们需要一个调度器来指定Coroutine具体执行在哪一个thread。

suspend

suspend关键字可以说是实现Coroutine的关键。它表示这个函数是可以被挂起的,只能在suspend修饰的方法中调用suspend方法。
也就是说代码执行到suspend方法或者suspend方法结束,会切换到其他Coroutine的其他suspend方法执行。这也很好的解释了前面的demo中,computeA和computeB是如何并行执行的。launch启动的Coroutine里的代码为什么没有阻塞UI。因为suspend方法遇到delay或者其他suspend方法,会被挂起而不是像Thread.sleep那样阻塞住线程,等到合适的时机suspend方法会被恢复执行。
至于中间是如何挂起并且如何恢复,后续会讲解。

原理解析

下面从源码的方面来简述,Coroutine到底是如何实现函数挂起的。我们分几部来讲。这里炒一个代码。。自己弄实在是麻烦。

suspend fun postItem(item: Item): PostResult {
  val token = requestToken()
  val post = createPost(token, item)
  val postResult = processPost(post)
  return postResult
}

编译期处理

suspend方法用起来挺简单,但实际上背后Kotlin做了很多不为人知的事情。
首先,被suspend关键字修饰后,在编译期间,我们看看编译器做了哪些事情。

CPS(Continuation Passing Style)

编译器做的第一件事就是CPS转换。

  1. 将函数返回值去掉
  2. 添加cont: Continuation参数,将结果放入resumeWith回调中。
//转换后的伪代码
fun postItem(item: Item, cont: Continuation): Any?{
}

我们再看看Continuation里有什么。

@SinceKotlin("1.3")
public interface Continuation<in T> {
    public val context: CoroutineContext
    public fun resumeWith(result: Result<T>)
}

看到resumeWith没有,想到能做什么了吗?
对,异步与流程控制。做了CPS变换后,中间就有了无限的可能,比如可以不直接执行postItem里的代码,而是通过Continuation决定何时再去执行具体的代码。这不就可以实现了函数的挂起与恢复吗?
说白了其实kotlin中的Coroutine本质上还是基于回掉去实现,只是它帮我们将细节封装在了编译期间。在外在看来,与阻塞编程没有区别。
那么具体的函数实现放哪去了呢?

题外话:尾递归与CPS

说到CPS大家都不清楚。说到递归,应该再熟悉不过。可是这几个词摆在一起是为什么呢?
递归
自己调用自己。。但是有个问题。递归的性能众所周知,而且如果太多会出现栈溢出。有什么优化方案呢?答案:循环。问题又来了,有的语言压根就没有循环这一说!那么有什么优化方案呢?答案:尾递归。
尾递归
为什么叫尾递归。因为递归的函数调用被放到了最后,所以叫尾递归。没那么简单。。还必须他的执行并不依赖上一次的执行结果,这样编译器会将代码优化成类似循环的结构。这样每次调用不用保存上次的栈,每次执行都是重新开始。因此尾递归在效率上比递归高出不少,而且保留了可读性。
还是上个代码对比下把,经典例子斐波拉切数列,可以执行下对比下耗时:

/**
 * @Author : xialonghua
 * @Date : Create in 2019/1/28
 * @Description : a new file
 */
//编译器会将尾递归优化成循环
fun fibonacci_tail(n: Int, acc1: Int, acc2: Int): Int {
    return if (n < 2) {
        acc1
    } else {
        fibonacci_tail(n - 1, acc2, acc1 + acc2)
    }
}

// 递归
fun fibonacci(n: Int): Int {
    return if (n <= 2) {
        1
    } else {
        fibonacci(n - 1) + fibonacci(n - 2)
    }
}

那么这和CPS什么关系呢?
有没发现尾递归在递归函数参数上多了2个,将计算结果给直接给到下次递归。再看CPS转换,是不是在函数后面加了个Continuation,然后把执行结果放入resumeWith回调中,然后继续执行。简直一毛一样阿,将结果直接给到下次计算,而不是自上而下又自下而上的调用栈关系。

状态机

@SinceKotlin("1.3")
public abstract class BaseContinuationImpl:Continuation<in T> {

    protected abstract fun invokeSuspend(result: Result<Any?>): Any?

}

知道了是如何挂起和恢复,那么suspend方法里还有别的suspend方法呢?编译器还做了点别的事情。。那就是状态机。首先将具体实现放到了invokeSuspend中。它把每一步suspend方法都用一个状态表示。当一个suspend方法执行完后,将状态改变,然后交由Continuation的resumeWith来继续执行下一个步骤。说白了就像递归一样不停的调用resumeWith来向前推进,至于是直接返回还是继续挂起,取决于resumeWith的返回值。值得注意的是子suspend也会持有父suspend的Continuation实例,形成一个链表,这样就能在子suspend执行完后回到父suspend继续执行。
图
3108769-730fe1e81c30a4d0..jpg

非编译期处理

异步

前面讲的这些其实本质上还是在同一个线程不停的回调执行,并没有实现异步,并没有将Coroutine分布到其他线程。那么是如果做到异步的呢?

Interceptor and Dispatcher

通过前面可以知道Continuation是持有父Continuation引用的,是一个链表。那么引入Interceptor的概念,在原本的调用链里加入一个InterceptorContinuation,里面包含Dispatcher的引用。它的resumeWith里不干别的,就把下一个Continuation的resumeWith通过Dispatcher丢到其他线程里执行。
至于线程的调度就交给Dispatcher去完成,Dispatcher可以有多种实现,比如使用线程池、使用Handler等等。
是不是很巧妙?

到这里Coroutine的实现原理就说的差不多了。后面再讲讲其他的。

与Thread的对比

这个其实没什么好比了。创建10000个线程的话内存肯定是吃不消,但是创建10000个Coroutine肯定是没问题的。通过前面的讲解,很容易知道Coroutine只是一个Continuation链表,它只会占用链表的内存空间,比一个thread消耗不是一个量级

用同步的方法编写异步代码

这一块还是值得说道的。怎么写代码最简单,无疑是同步代码最简单。那么Coroutine带来的好处显而易见,写代码只管按照同步去写,至于何时挂起何时恢复全由Coroutine内部处理。至少外在看起来就是同步的代码。感觉说还是说不清,还是给一个例子来说明吧。
看demo思考一个问题,满足如下需求,用其他异步编程方法需要多少代码:

  1. 点击按钮开始计数,并把按钮disable
  2. 使用retrofit请求百度并将返回结果转成MD5(算法UUID代替),每隔2秒toast输出一次
  3. 取消计时,并设置textview文本为”Hello World Finish”
  4. enable按钮
  5. activity destroy的时候停止计时、请求网络、定时弹toast

demo

我再贴出使用了Coroutine的核心代码来对比一下,有没感觉简单清晰很多:

class MainActivity2 : AppCompatActivity(), CoroutineScope, AnkoLogger {
    private val job = SupervisorJob()
    override val coroutineContext: CoroutineContext = Dispatchers.Main + job

    @SuppressLint("SetTextI18n")
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main2)

        helloClick.onClick {
            val tickJob = launch {
                repeat(100000){
                    delay(10)
                    helloClick.text = "Hello World $it"
                    info("====")
                }
            }
            helloClick.isEnabled = false
            try {
                val result = api.getBaidu().await()
                repeat(3){
                    toast(result.md5())
                    delay(2000)
                }
            }catch (e: Exception){
                e.printStackTrace()
                //请求异常处理
                toast("网络错误")
            }

            tickJob.cancel()
            helloClick.isEnabled = true
            helloClick.text = "Hello World Finish"
        }
    }

    override fun onDestroy() {
        super.onDestroy()
        job.cancel()
    }

    private fun View.onClick(handler: (suspend CoroutineScope.(v: android.view.View?)->Unit)){
        setOnClickListener { v ->
            launch {
                handler(v)
            }
        }
    }
}

源码阅读关键类帮助

我列了一些关于Coroutine关键的类,看源码可以从这些地方入手:

  1. CoroutineContext、CombinedContext context的具体实现
  2. Continuation、BaseContinuationImpl、ContinuationImpl、SuspendLambda 编译处理以及流程控制(挂起恢复)
  3. ContinuationInterceptor、CoroutineDispatcher 拦截器与dispatcher,实现了异步
  4. AbstractCoroutine builder的实现抽象父类
  5. CoroutineScope Coroutine的scope

总结

前面写了这么多,其实大多都是描述Coroutine的本质。文字比较多有可能没有描述清楚,欢迎拍砖。下面我自己总结两点:

  1. Coroutine的性能消耗对比Thread微乎其微
  2. 更重要的是它带来了一种新的编程方式,让异步编程不再复杂

demo源码:https://github.com/xialonghua/AndroidCoroutineRetrofit