dependencies {

   implementation 'com.rxjava.rxhttp:rxhttp:0.1.1' //必须
   annotationProcessor 'com.rxjava.rxhttp:rxhttp-compiler:0.1.1' //注解处理器，生成RxHttp类,必须
   implementation 'io.reactivex.rxjava2:rxandroid:2.1.1'  //切换主线程，Android工程必须

   implementation 'com.rxjava.rxlife:rxlife:1.1.0'  //页面销毁，关闭请求，非必须
}

RxHttp.get("/service/...") //第一步，确定请求方式，可以选择postForm、postJson等方法
    .asString()            //第二步，使用asXXX系列方法确定返回类型
    .subscribe(s -> {      //第三步, 订阅观察者
        //成功回调
    }, throwable -> {
        //失败回调
    });

val resultStr = RxHttp.get("/service/...") //第一步，确定请求方式，可以选择postForm、postJson等方法
                    .awaitString() //第二步，使用awaitXxx系列方法直接拿到返回值

suspend awaitString()
suspend awaitBoolean()
suspend awaitByte()
suspend awaitShort()
suspend awaitInt()
suspend awaitLong()
suspend awaitFloat()
suspend awaitDouble()
suspend awaitBitmap()
suspend awaitHeaders()
suspend awaitOkResponse()    //以上方法与asXxx方法一一对应
suspend <T> await<T>()       //对应asObject(Class<T>),直接返回T对象
suspend <T> awaitList<T>()   //对应asList(Class<T>),直接返回List<T>对象
suspend <K,V> awaitMap<K,V>() //对应asMap(Class<K>,Class<V>),直接返回Map<K,V>对象
suspend <T> await(Parser<T>)  //对应asParser(Parser<T>)方法，直接返回T对象

//以下三个方法用于对文件上传/下载进度的监听，后面会详细介绍
suspend awaitDownload(String, CoroutineScope? = null,(Progress<String>) -> Unit)
suspend awaitUpload<T>(CoroutineScope? = null，(Progress<T>) -> Unit)
suspend awaitUpload<T>(Parser<T>, CoroutineScope? = null，(Progress<T>) -> Unit)

class MainActivity : AppCompatActivity() {

    //启动协程，发送请求
    fun sendRequest() {
        RxHttpScope(this)  //此this为LifecycleOwner接口对象，用于页面销毁时，自动关闭协程及请求
            .launch({
                //当前运行在协程中，且在主线程运行
                val student = getStudent()
                //拿到相关信息后，便可直接更新UI，如：
                tvName.text = student.name
            }, {
                //出现异常，就会到这里，这里的it为Throwable类型
                it.show("发送失败,请稍后再试!")  //show方法是在Demo中扩展的方法
            })
    }

    //注意这是挂断方法
    suspend fun getStudent(): Student {
        return RxHttp.get("/service/...")
            .add("key", "value")
            .addHeader("headKey", "headValue")
            .await() //由于方法指明了返回值为Student类型，故直接写await()，否则需要写 await<Student>()
    }

}

class MainActivity : AppCompatActivity() {
    //启动协程，发送请求
    fun sendRequest() {
        RxHttpScope(this) //此this为LifecycleOwner接口对象，用于页面销毁时，自动关闭协程及请求
            .launch({
                //当前运行在协程中，且在主线程运行
                val student = getStudent()
                val personList = getFamilyPersons(student.id) //通过学生Id，查询家庭成员信息
                //拿到相关信息后，便可直接更新UI，如：
                tvName.text = student.name
            }, {
                //出现异常，就会到这里，这里的it为Throwable类型
                it.show("发送失败,请稍后再试!") //show方法是在Demo中扩展的方法
            })
    }

    //挂断方法，获取学生信息
    suspend fun getStudent(): Student {
        return RxHttp.get("/service/...")
            .add("key", "value")
            .addHeader("headKey", "headValue")
            .await() //由于方法指明了返回值为Student类型，故直接写await()，否则需要写 await<Student>()
    }

    //挂断方法，获取家庭成员信息
    suspend fun getFamilyPersons(studentId: Int): List<Person> {
        return RxHttp.get("/service/...")
            .add("studentId", "studentId")
            .await() //由于方法指明了返回值为List<Person>类型，故直接写await()，否则需要写 await<List<Person>>()
    }
}

class MainActivity : AppCompatActivity() {
    //启动协程，发送请求
    fun sendRequest() {
        RxHttpScope(this) //此this为LifecycleOwner接口对象，用于页面销毁时，自动关闭协程及请求
            .launch({
                //当前运行在协程中，且在主线程运行
                val asyncBanner = async { getBanners() }    //这里返回Deferred<List<Banner>>对象
                val asyncPersons = async { getStudents() }  //这里返回Deferred<List<Student>>对象
                val banners = asyncBanner.await()           //这里返回List<Banner>对象
                val students = asyncPersons.await()         //这里返回List<Student>对象
                //开始更新UI

            }, {
                //出现异常，就会到这里，这里的it为Throwable类型
                it.show("发送失败,请稍后再试!") //show方法是在Demo中扩展的方法
            })
    }

    //挂断方法，获取学生信息
    suspend fun getBanners(): List<Banner> {
        return RxHttp.get("/service/...")
            .add("key", "value")
            .addHeader("headKey", "headValue")
            .await() //由于方法指明了返回值为Student类型，故这里直接调用await()，否则需要写 .await<Student>()
    }

    //挂断方法，获取家庭成员信息
    suspend fun getStudents(): List<Student> {
        return RxHttp.get("/service/...")
            .add("key", "value")
            .await() //由于方法指明了返回值为List<Person>类型，故这里直接调用await()，否则需要写 .await<List<Person>>()
    }
}

class MainActivity : AppCompatActivity() {

    //启动协程，发送请求
    fun sendRequest() {
        RxHttpScope(this) //此this为LifecycleOwner接口对象，用于页面销毁时，自动关闭协程及请求
            .launch({
                //当前运行在协程中，且在主线程运行，故下面传this，让进度回调在主线程执行
                val result = uploadFile(this) {
                    //这里最多回调100此，进在进度有更新时才回调
                    val progress = it.progress       //当前上传进度
                    val currentSize = it.currentSize //当前已上传的size
                    val totalSize = it.totalSize     //要上传的总size
                    //当前在主线程，可直接更新UI
                }
                //请求介绍，当前在主线程，可直接更新UI
            }, {
                //出现异常，就会到这里，这里的it为Throwable类型
                it.show("发送失败,请稍后再试!") //show方法是在Demo中扩展的方法
            })
    }

    /**
     * @param coroutine CoroutineScope对象，用于切换进度回调线程，默认为null，即在子线程回调进度
     * @param progress 进度回调
     */
    suspend fun uploadFile(
        coroutine: CoroutineScope? = null,
        progress: (Progress<String>) -> Unit): String {
        return RxHttp.postForm("/service/...")
            .add("key", "value")
            .addFile("file", File(".../1.phg"))
            .addFile("file1", File(".../2.phg"))
            .awaitUpload(coroutine, progress)
    }
}

class MainActivity : AppCompatActivity() {

    //启动协程，发送请求
    fun sendRequest() {
        RxHttpScope(this) //此this为LifecycleOwner接口对象，用于页面销毁时，自动关闭协程及请求
            .launch({
                //当前运行在协程中，且在主线程运行，故下面传this，让进度回调在主线程执行
                val result = downloadFile(".../1.pak", this) {
                    //这里最多回调100此，进在进度有更新时才回调
                    val progress = it.progress       //当前上传进度
                    val currentSize = it.currentSize //当前已上传的size
                    val totalSize = it.totalSize     //要上传的总size
                    //当前在主线程，可直接更新UI
                }
                //当前在主线程，可直接更新UI
            }, {
                //出现异常，就会到这里，这里的it为Throwable类型
                it.show("发送失败,请稍后再试!") //show方法是在Demo中扩展的方法
            })
    }

    /**
     * @param destPath 存储路径，传入本地文件目录
     * @param coroutine CoroutineScope对象，用于切换进度回调线程，默认为null，即在子线程回调进度
     * @param progress 进度回调
     */
    suspend fun downloadFile(
        destPath: String,
        coroutine: CoroutineScope? = null,
        progress: (Progress<String>) -> Unit): String {
        return RxHttp.postForm("/service/...")
            .add("key", "value")
            .awaitDownload(destPath, coroutine, progress)
    }
}

class MainActivity : AppCompatActivity() {

    fun requestStudent() {
        postForm("/article/query/0/json")
            .add("k", null)
            .asObject<Student>()
            .lifeOnMain(this) //感知生命周期，并在主线程回调
            .subscribe({
                val student = it //这里拿到Student对象
            }, {
                //失败回调
            })
    }

    fun requestStudents() {
        postForm("/article/query/0/json")
            .add("k", null)
            .asObject<List<Student>>()
            .lifeOnMain(this) //感知生命周期，并在主线程回调
            .subscribe({
                val students = it //这里拿到List<Student>对象
            }, {
                //失败回调
            })
    }

    fun getStudents(view: View) {
        postForm("/article/query/0/json")
            .add("k", null)
            .asResponse<List<Student>>()    //自定义的asXxx也支持
            .lifeOnMain(this) //感知生命周期，并在主线程回调
            .subscribe({

            }, {

            })
    }
}