docs: 更新文档

docs/auto-dialog.md

@@ -5,8 +5,8 @@ Net支持发起请求开始时显示加载框, 请求结束时隐藏加载框(
 
 ```kotlin hl_lines="1"
 scopeDialog {
-    tvFragment.text = Post<String>("dialog") {
-        param("u_name", "drake") // 请求参数
+    tv.text = Post<String>(Api.PATH) {
+        param("username", "用户名") // 请求参数
         param("pwd", "123456")
     }.await()
 }
@@ -27,8 +27,8 @@ scopeDialog {
 val dialog = BubbleDialog(requireActivity(), "加载中")
 
 scopeDialog(dialog) {
-    binding.tvFragment.text = Post<String>("dialog") {
-        param("u_name", "drake")
+    tv.text = Post<String>(Api.PATH) {
+        param("username", "用户名")
         param("pwd", "123456")
     }.await()
 }

docs/auto-pull.md

@@ -8,7 +8,7 @@
 ```kotlin
 page.onRefresh {
     scope {
-        val data = Get<ListModel>("list") {
+        val data = Get<Game>(Api.PATH) {
             param("page", index)
         }.await().data
         addData(data.list) {

docs/auto-refresh.md

@@ -47,7 +47,7 @@ rv_push.linear().setup {
 page.onRefresh {
     scope {
         // 请求到数据设置到RecyclerView
-        rv_push.models = Get<ListModel>("list").await().data.list
+        rv_push.models = Get<Game>(Api.PATH).await().data.list
     }
 }.autoRefresh()
 ```

docs/auto-state.md

@@ -37,7 +37,7 @@ StateConfig.apply {
     tools:context=".ui.fragment.StateLayoutFragment">
 
     <TextView
-        android:id="@+id/tvFragment"
+        android:id="@+id/tv"
         android:padding="32dp"
         android:textStyle="bold"
         android:layout_width="match_parent"
@@ -56,7 +56,7 @@ StateConfig.apply {
 ```kotlin
 state.onRefresh {
     scope {
-        tvFragment.text = Get<String>("api").await()
+        tv.text = Get<String>(Api.PATH).await()
     }
 }.showLoading()
 ```

docs/cache.md

@@ -34,28 +34,28 @@ OkHttp默认的Http缓存协议控制, 要求以下条件
 - 响应头控制缓存: [Cache-Control](https://developer.mozilla.org/zh-CN/docs/Web/HTTP/Headers/Cache-Control)
 
 <br>
-通过`setCacheControl`可以控制Http缓存协议(原理是添加请求头)
+通过`setCacheControl`可以控制Http缓存协议, 原理是修改请求头
 
 ```kotlin
 scopeNetLife {
-    Post<String>("api") {
+    Post<String>(Api.PATH) {
         setCacheControl(CacheControl.FORCE_CACHE) // 强制使用缓存
         // setCacheControl(CacheControl.FORCE_NETWORK) // 强制使用网络
-        // setCacheControl(CacheControl.Builder().noStore().noCache().build()) // 完全禁止读取/写入缓存
+        // setCacheControl(CacheControl.Builder().noStore().noCache().build()) // 禁止缓存
     }.await()
 }
 ```
 
-如果无法实现Http标准缓存协议, 或要缓存Get以外的请求方法, 可以使用`强制缓存模式`来由客户端控制缓存
+如果无法实现Http标准缓存协议, 或要缓存Get以外的请求方法, 可以使用`强制缓存模式`
 
 ## 强制缓存模式
 
-无论请求是否存在Http标准缓存协议, 当你设置强制缓存模式时其会无视Http标准缓存协议
+无论当前请求是否存在Http标准缓存协议, 当设置强制缓存模式时会无视Http缓存协议
 
 ```kotlin
 scopeNetLife {
-    binding.tvFragment.text =
-        Post<String>("api") {
+    tv.text =
+        Post<String>(Api.PATH) {
             setCacheMode(CacheMode.REQUEST_THEN_READ) // 请求网络失败会读取缓存, 请断网测试
         }.await()
 }
@@ -76,8 +76,8 @@ scopeNetLife {
 
 ```kotlin
 scopeNetLife {
-    binding.tvFragment.text =
-        Post<String>("api") {
+    tv.text =
+        Post<String>(Api.PATH) {
             setCacheMode(CacheMode.REQUEST_THEN_READ) // 请求网络失败会读取缓存, 请断网测试
             setCacheKey("请求热门信息" + params) // 具体值都行
         }.await()
@@ -91,8 +91,8 @@ scopeNetLife {
 
 ```kotlin
 scopeNetLife {
-    binding.tvFragment.text =
-        Post<String>("api") {
+    tv.text =
+        Post<String>(Api.PATH) {
             setCacheMode(CacheMode.REQUEST_THEN_READ) // 请求网络失败会读取缓存, 请断网测试
             setCacheValidTime(1, TimeUnit.DAYS) // 缓存仅一天内有效
         }.await()
@@ -106,21 +106,21 @@ scopeNetLife {
 ```kotlin
 scopeNetLife {
     // 然后执行这里(网络请求)
-    binding.tvFragment.text = Get<String>("api") {
+    tv.text = Get<String>(Api.PATH) {
         setCacheMode(CacheMode.WRITE)
     }.await()
     Log.d("日志", "网络请求")
-}.preview(true) {
+}.preview {
     // 先执行这里(仅读缓存), 任何异常都视为读取缓存失败
-    binding.tvFragment.text = Get<String>("api") {
+    tv.text = Get<String>(Api.PATH) {
         setCacheMode(CacheMode.READ)
     }.await()
     Log.d("日志", "读取缓存")
 }
 ```
 
-!!! question "这和加载两次有什么区别?"
+!!! question "预览和加载两次有什么区别?"
     区别是`preview`可以控制以下行为
 
-    1. `breakError` 读取缓存成功后不再处理错误信息, 默认false
-    2. `breakLoading` 读取缓存成功后结束加载动画, 默认true
+    1. `breakError` 读取缓存成功后不再处理请求的错误, 默认false
+    2. `breakLoading` 读取缓存成功后立刻结束加载动画, 默认true

docs/callback.md

@@ -5,7 +5,7 @@ Net支持OkHttp的原有的队列请求`Callback`
 
 
 ```kotlin
-Net.post("api").enqueue(object : Callback {
+Net.post(Api.PATH).enqueue(object : Callback {
     override fun onFailure(call: Call, e: IOException) {
     }
 
@@ -14,7 +14,7 @@ Net.post("api").enqueue(object : Callback {
         val body = response.body?.string() ?: "无数据"
         runMain {
             // 此处为主线程
-            binding.tvFragment.text = body
+            tv.text = body
         }
     }
 })

docs/cancel.md

@@ -1,9 +1,9 @@
-部分场景需要手动取消请求, 例如取消下载
+部分场景开发者想手动取消请求
 
 ```kotlin
 downloadScope = scopeNetLife {
     // 下载文件
-    val file = Get<File>("download").await()
+    val file = Get<File>(Api.DOWNLOAD).await()
 }
 
 downloadScope.cancel() // 取消下载
@@ -14,7 +14,7 @@ downloadScope.cancel() // 取消下载
 
 ```kotlin
 scopeNetLife {
-    tvFragment.text = Get<String>("api"){
+    tv.text = Get<String>(Api.DOWNLOAD){
         setId("请求用户信息")
     }.await()
 }

docs/config.md

@@ -25,6 +25,8 @@
     NetConfig.initialize(Api.HOST, this, okHttpClientBuilder)
     ```
 
+如果请求指定Path会和上面`Api.HOST`组成Url后发起请求
+
 !!! failure "强制初始化"
     如果是多进程项目(例如Xposed)必须初始化, 因为多进程无法自动指定Context
 
@@ -59,31 +61,34 @@ NetConfig.initialize(Api.HOST, this) {
 
 ## 多域名
 
-概念源于`Retrofit`(称为BaseUrl), 因为Retrofit无法二次修改请求Host, 但Net支持随时修改
-
-以下介绍三种修改方式
+Net可随时变更请求域名, 以下介绍三种方式
 
 === "修改Host"
     ```kotlin
-    NetConfig.host = Api.HOST_2
+    NetConfig.host = Api.HOST_VIDEO
     ```
 
 === "指定全路径"
-    指定Path(例如`/api/index`)会自动和`NetConfig.host`拼接组成Url, 但指定以`http/https`开头的全路径则直接作为请求Url
+    建议使用单例类管理请求Url
     ```kotlin
+    object Api {
+        const val HOST_IMG = "http://127.0.0.1"
+        const val BANNER = "$HOST_IMG/banner"
+        const val HOME = "/home"
+    }
     scopeNetLife {
-        val data = Get<String>("https://github.com/path").await()
+        val banner = Get<BannerModel>(Api.BANNER).await()
+        val home = Get<HomeModel>(Api.HOME).await()
     }
     ```
 
 === "使用拦截器"
-    请求时指定`tag`, 然后拦截器中根据tag判断修改host, 拦截器能修改所有请求/响应信息
-
+    请求指定`tag`, 拦截器中根据tag修改Url, 建议tag为包含域名的枚举或单例
     ```kotlin
     scopeNetLife {
-        val data = Get<String>("/api/index", "User").await() // User即为tag
+        val data = Get<String>(Api.PATH, GAME).await() // User即为tag
     }
-    // 拦截器修改请求URL不做介绍
+    // 拦截器如何修改请搜索
     ```
 
 ## 网络安全配置

docs/converter-customize.md

@@ -7,7 +7,7 @@ Net自定义转换器可支持任何数据类型, 甚至`Bitmap`
 
 ```kotlin
 scopeNetLife {
-    val userList = Get<List<UserModel>>("list") {
+    val userList = Get<List<UserModel>>(Api.PATH) {
         converter = GsonConverter()
     }.await()
 }
@@ -26,7 +26,7 @@ Net由于低耦合原则不自带任何序列化框架
 === "单例"
     ```kotlin hl_lines="3"
     scopeNetLife {
-       tvFragment.text = Get<String>("api"){
+       tv.text = Get<String>(Api.PATH){
             converter = SerializationConverter()
        }.await()
     }

docs/converter-struct.md

@@ -32,7 +32,7 @@
 === "网络请求"
     ```kotlin
     scopeNetLife {
-        val data = Get<UserModel>("api").await().data
+        val data = Get<UserModel>(Api.USER).await().data
     }
     ```
 
@@ -81,7 +81,7 @@ class GsonConvert : JSONConvert(code = "code", message = "msg", success = "200")
 
 ```kotlin
 scopeNetLife {
-    val data = Get<UserModel>("api").await()
+    val data = Get<UserModel>(Api.USER).await()
 }
 ```
 

docs/converter.md

@@ -1,6 +1,6 @@
 Net支持请求返回的数据类型取决于你的转换器实现
 
-# Get<任何对象>("path").await()
+# Get<任何对象>(Api.PATH).await()
 
 默认转换器支持返回以下数据类型
 
@@ -16,7 +16,7 @@ Net支持请求返回的数据类型取决于你的转换器实现
 
 ```kotlin
 scopeNetLife {
-    Get<Response>("api").await().headers("响应头名称") // 返回响应头
+    Get<Response>(Api.PATH).await().headers("响应头名称") // 返回响应头
 }
 ```
 

docs/cookie.md

@@ -1,4 +1,4 @@
-使用OkHttp的`CookieJar`, Net提供持久化Cookie`PersistentCookieJar`
+可以实现OkHttp的`CookieJar`, 且提供持久化的[PersistentCookieJar](https://github.com/liangjingkanji/Net/blob/2abf07e1d003ef44574278fd2010f3375225d964/net/src/main/java/com/drake/net/cookie/PersistentCookieJar.kt)
 
 ```kotlin
 NetConfig.initialize(Api.HOST, this) {

docs/coroutine-request.md

@@ -7,7 +7,7 @@ val job = scopeNetLife {
     repeat(10000) {
         // 这里将返回的数据显示在TextView上
         launch {
-            tvFragment.text = Get<String>("https://github.com/liangjingkanji/Net/").await()
+            tv.text = Get<String>(Api.PATH).await()
         }
     }
 }

docs/debounce.md

@@ -22,8 +22,8 @@ var scope: CoroutineScope? = null
 binding.etInput.debounce().distinctUntilChanged().launchIn(this) {
     scope?.cancel() // 发起新的请求前取消旧的请求, 避免旧数据覆盖新数据
     scope = scopeNetLife { // 保存旧的请求到一个变量中
-        binding.tvFragment.text = "请求中"
-        binding.tvFragment.text = Get<String>(Api.TIME).await()
+        tv.text = "请求中"
+        tv.text = Get<String>(Api.TIME).await()
     }
 }
 ```
@@ -31,4 +31,6 @@ binding.etInput.debounce().distinctUntilChanged().launchIn(this) {
 指定参数设置节流阀超时时间
 ```kotlin
 fun EditText.debounce(timeoutMillis: Long = 800)
-```
+```
+<br>
+1. [示例-自动搜索分页列表](https://github.com/liangjingkanji/Net/blob/a78d46118666a3509d3fcc79c1d28ad81e2d5a57/sample/src/main/java/com/drake/net/sample/ui/fragment/EditDebounceFragment.kt)

docs/download-file.md

@@ -2,7 +2,7 @@
 
 ```kotlin
 scopeNetLife {
-    val file = Get<File>("download").await()
+    val file = Get<File>(Api.DOWNLOAD).await()
 }
 ```
 
@@ -13,7 +13,7 @@ scopeNetLife {
 ```kotlin
 scopeNetLife {
     val file =
-        Get<File>("https://download.sublimetext.com/Sublime%20Text%20Build%203211.dmg") {
+        Get<File>("https://github.com/liangjingkanji/Net/releases/latest/download/net-sample.apk") {
             setDownloadFileName("net.apk")
             setDownloadDir(requireContext().filesDir)
             setDownloadMd5Verify()

docs/error-single.md

@@ -7,8 +7,8 @@
 例如
 ```kotlin
 scopeNetLife {
-    Get<String>("api").await() // 失败
-    Get<String>("api2").await() // 上面失败, 此处也不会执行
+    Get<String>("path").await() // 失败
+    Get<String>("path2").await() // 上面失败, 此处也不会执行
 }
 ```
 
@@ -16,19 +16,19 @@ scopeNetLife {
 ```kotlin
 scopeNetLife {
     try {
-        Get<String>("api").await() // 失败
+        Get<String>("path").await() // 失败
     } catch(e:Exception) {
     }
-    Get<String>("api2").await() // 上面失败, 此处继续执行
+    Get<String>("path2").await() // 上面失败, 此处继续执行
 }
 ```
 当然如果创建不同的作用域分别请求那是互不影响的
 ```kotlin
 scopeNetLife {
-    Get<String>("api").await() // 失败
+    Get<String>("path").await() // 失败
 }
 scopeNetLife {
-    Get<String>("api2").await() // 上面失败, 此处完全不受影响
+    Get<String>("path2").await() // 上面失败, 此处完全不受影响
 }
 ```
 
@@ -38,7 +38,7 @@ scopeNetLife {
 
 ```kotlin
 scope {
-    val data = Get<String>("http://www.thisiserror.com/").await()
+    val data = Get<String>("http://www.error.com/").await()
 }.catch {
     // 协程内发生错误回调, it为异常对象
 }.finally {

docs/fastest.md

@@ -11,13 +11,13 @@
 scopeNetLife {
 
     // 同时发起四个网络请求
-    val deferred = Get<String>("api0") // 错误接口
-    val deferred1 = Get<String>("api1") // 错误接口
-    val deferred2 = Get<String>("api")
-    val deferred3 = Post<String>("api")
+    val pathAsync = Get<String>("path") // 错误接口
+    val pathAsync1 = Get<String>("path1") // 错误接口
+    val pathAsync2 = Get<String>("path2")
+    val pathAsync3 = Post<String>("path3")
 
     // 只返回最快的请求结果
-    tvFragment.text = fastest(deferred, deferred1, deferred2, deferred3)
+    tv.text = fastest(pathAsync, pathAsync1, pathAsync2, pathAsync3)
 }
 ```
 
@@ -29,13 +29,13 @@ scopeNetLife {
 ```kotlin
 scopeNetLife {
     // 同时发起四个网络请求
-    val deferred2 = Get<String>("api") { setGroup("初始化") }
-    val deferred3 = Post<String>("api") { setGroup("初始化") }
-    val deferred = Get<String>("api0") { setGroup("初始化") } // 错误接口
-    val deferred1 = Get<String>("api1") { setGroup("初始化") } // 错误接口
+    val pathAsync = Get<String>("path") { setGroup("初始化") }
+    val pathAsync1 = Post<String>("path1") { setGroup("初始化") }
+    val pathAsync2 = Get<String>("path2") { setGroup("初始化") } // 错误接口
+    val pathAsync3 = Get<String>("path3") { setGroup("初始化") } // 错误接口
 
     // 只返回最快的请求结果
-    tvFragment.text = fastest(listOf(deferred, deferred1, deferred2, deferred3), "初始化")
+    tv.text = fastest(listOf(pathAsync, pathAsync1, pathAsync2, pathAsync3), "初始化")
 }
 ```
 
@@ -46,36 +46,36 @@ scopeNetLife {
 ```kotlin
 scopeNetLife {
 
-    val fastest = Post<String>("api").transform {
+    val pathAsync = Post<String>("path").transform {
         Log.d("日志", "Post") // 如果该接口最快则会回调这里
         it // 这里可以返回其他数据结果
     }
 
-    val fastest2 = Get<String>("api").transform {
+    val pathAsync1 = Get<String>("path1").transform {
         Log.d("日志", "Get") // 如果该接口最快则会回调这里
         it
     }
 
-    tvFragment.text = fastest(fastest, fastest2)
+    tv.text = fastest(pathAsync, pathAsync1)
 }
 ```
 
-> 只有最快返回结果的网络请求(或异步任务)的`transform`回调才会被执行到
+只有最快返回结果的网络请求(或异步任务)的`transform`回调才会被执行到
 
 ## 捕获错误
 ```kotlin
 scopeNetLife {
-    val task = Get<String>("api2")
-    val task1 = Get<String>("api2")
-    val task2 = Get<String>("api2")
+    val pathAsync = Get<String>("path")
+    val pathAsync1 = Get<String>("path1")
+    val pathAsync2 = Get<String>("path2")
 
     val data = try {
-        fastest(listOf(task, task1, task2))
+        fastest(listOf(pathAsync, pathAsync1, pathAsync2))
     // 当task/task1/task2全部错误后才并发执行backupTask/backupTask1
     } catch (e: Exception) {
-        val backupTask = Get<String>("api2")
-        val backupTask1 = Get<String>("api")
-        fastest(listOf(backupTask, backupTask1))
+        val pathAsync3 = Get<String>("path3")
+        val pathAsync4 = Get<String>("path4")
+        fastest(listOf(pathAsync3, pathAsync4))
     }
 }
 ```

docs/https.md

@@ -6,7 +6,7 @@ Https如果使用的CA证书, 不需要任何配置可以直接访问
 
 ```kotlin
 scopeNetLife {
-    tvFragment.text = Get<String>("https://github.com/liangjingkanji/Net/").await()
+    tv.text = Get<String>(Api.PATH).await()
 }
 ```
 
@@ -25,7 +25,7 @@ scopeNetLife {
 
     ```kotlin
     scopeNetLife {
-        Get<String>("https://github.com/liangjingkanji/Net/"){
+        Get<String>(Api.PATH){
           setClient {
               trustSSLCertificate()
           }
@@ -50,7 +50,7 @@ scopeNetLife {
 
     ```kotlin
     scopeNetLife {
-        Get<String>("https://github.com/liangjingkanji/Net/") {
+        Get<String>(Api.PATH) {
             setClient {
                 val privateCertificate = resources.assets.open("https.certificate") // 这里的证书是放到应用的资产目录下
                 setSSLCertificate(privateCertificate)

docs/index.md

@@ -7,9 +7,9 @@ Net是基于[OkHttp](https://github.com/square/okhttp)/协程的非侵入式框
 
 !!! note "前言"
 
-    - 未实现功能可以搜索`"OkHttp如何XX"`来扩展
-    - 阅读示例/源码来学习如何封装
-    - 如果觉得文档看不懂那肯定是作者问题, 请反馈给作者或者自我修订
+    - 阅读文档, 提高开发效率
+    - 阅读示例, 学习编程经验
+    - 阅读源码, 成为开源作者
 
 ## 使用
 
@@ -22,49 +22,46 @@ Net是基于[OkHttp](https://github.com/square/okhttp)/协程的非侵入式框
 
 === "简单请求"
     ```kotlin
-    scopeNetLife { 创建作用域
-        // 这个大括号内就属于作用域内部
-        val data = Get<String>("https://github.com/liangjingkanji/Net/").await() // 发起GET请求并返回`String`类型数据
+    scopeNetLife {
+        // 大括号内属于作用域
+        val data = Get<String>(Api.USER).await() // 发起GET请求并返回`String`
     }
     ```
 === "同步请求"
     ```kotlin
     scopeNetLife {
-        val userInfo = Get<String>("https://github.com/liangjingkanji/BRV/").await() // 立即请求
-            val config = Get<String>("https://github.com/liangjingkanji/Net/"){
-            param("userId", userInfo.id) // 使用上个请求的数据作为参数
-        }.await() // 请求B 将等待A请求完毕后发起GET请求并返回数据
+        // B将等待A请求返回结果后发起请求
+        val userInfo = Get<UserInfo>(Api.USER).await() // A
+
+        val config = Get<Config>(Api.CONFIG){ // B
+            param("userId", userInfo.id) // 将上个请求结果作为参数
+        }.await()
     }
     ```
 === "并发请求"
     ```kotlin
     scopeNetLife {
-        // 以下两个网络请求属于同时进行中
-        val getUserInfoAsync = Get<String>("https://github.com/liangjingkanji/Net/") // 立即请求
-        val getConfigAsync = Get<String>("https://github.com/liangjingkanji/BRV/") // 立即请求
+        // 两个请求同时发起
+        val getUserInfoAsync = Get<UserInfo>(Api.USER)
+        val getConfigAsync = Get<Config>(Api.CONFIG)
 
         val userInfo = getUserInfoAsync.await() // 等待数据返回
         val config = getConfigAsync.await()
     }
     ```
 
-多个网络请求在同一个作用域内可以统一管理
-
-如果多个网络请求之间毫无关联, 可以创建多个作用域来请求
+1. 多个网络请求在同一个作用域内可以统一管理
+2. 如果多个网络请求之间毫无关联, 可以创建多个作用域来请求
 
 !!! failure "强制初始化"
     多进程或Xposed项目要求先[初始化](config.md#_1)
 
-并发请求错误示例
+自动识别`Url`或者`Path`
 
-```kotlin hl_lines="3"
+```kotlin
 scopeNetLife {
-    // 请求A
-    val userInfo = Get<String>("https://github.com/liangjingkanji/Net/").await()
-    // 由于上面使用`await()`函数, 所以必须等待A请求返回结果后才会执行B
-    val getConfigAsync = Post<String>("https://github.com/liangjingkanji/Net/")
-
-    val config = getConfigAsync.await() // 等待任务B返回数据
+    val userInfo = Get<String>("/net").await() // 等于"${NetConfig.host}/net"
+    val config = Get<String>("https://github.com/liangjingkanji/net").await()
 }
 ```
 

docs/interceptor.md

@@ -4,7 +4,7 @@
 2. `RequestInterceptor`: Net独有的轻量级拦截器, 允许修改全局请求头/请求参数, 无法转发请求
 <br>
 
-!!! Failure "禁止随意封装"
+!!! Failure "禁止无效封装"
     不应为全局参数/加密等封装请求方法, 应自定义拦截器/转换器来实现, [常见拦截器示例](https://github.com/liangjingkanji/Net/tree/master/sample/src/main/java/com/drake/net/sample/interceptor)
 
 

docs/interval.md

@@ -25,9 +25,9 @@ Net自带轮询器(计时器), 包含以下特性
 监听轮询器
 ```kotlin
 interval.subscribe {
-    tvFragment.text = it.toString()
+    tv.text = it.toString()
 }.finish {
-    tvFragment.text = "计时完成" // 最后一位数时同时回调 subscribe/finish
+    tv.text = "计时完成" // 最后一位数时同时回调 subscribe/finish
 }.start()
 ```
 
@@ -46,4 +46,4 @@ interval.subscribe {
 | onlyResumed | 当界面不可见时暂停, 当界面可见时继续 |
 
 !!! failure "后台运行"
-    由于系统限制, 本工具无法保证后台运行
+    由于系统限制, 本工具无法保证一直后台运行

docs/issues.md

@@ -4,12 +4,10 @@ Net最大的特点在于完美支持OkHttp的所有功能组件, 而OkHttp是And
 
 ## 低版本兼容
 
-如果你是在 Android 5 (API level 21)
-以上开发建议使用最新版本: [Net](https://github.com/liangjingkanji/Net) <br>
-如果要求低至 Android 4.4 (API level 19)
+如果开发要求低至 Android 4.4 (API level 19)
 请使用兼容版本: [Net-okhttp3](https://github.com/liangjingkanji/Net-okhttp3)
 
-如果需更低版本支持建议拉取仓库修改`minSdkVersion`后编译成aar使用
+如果需更低版本支持请拉取仓库修改`minSdkVersion`后编译成aar使用
 
 ## 开发者交流
 

docs/kotlin-serialization.md

@@ -53,7 +53,7 @@ implementation "org.jetbrains.kotlinx:kotlinx-serialization-json:1.3.0"
     ```
 === "单例配置"
     ```kotlin
-    val userList = Get<List<UserModel>>("list") {
+    val userList = Get<List<UserModel>>(Api.PATH) {
         converter = SerializationConvert() // 单例转换器, 此时会忽略全局转换器
     }.await()
     ```
@@ -62,11 +62,11 @@ implementation "org.jetbrains.kotlinx:kotlinx-serialization-json:1.3.0"
 
 ```kotlin
 scopeNetLife {
-    val userList = Get<List<UserModel>>("list") {
+    val userList = Get<List<UserModel>>(Api.PATH) {
         converter = SerializationConvert()
     }.await()
 
-    tvFragment.text = userList[0].name
+    tv.text = userList[0].name
 }
 ```
 

docs/log-notice.md

@@ -14,7 +14,7 @@ implementation "com.github.chuckerteam.chucker:library:3.5.2"
 添加拦截器
 
 ```kotlin
-NetConfig.initialize("https://github.com/liangjingkanji/", this) {
+NetConfig.initialize(Api.HOST, this) {
     // ...
     if (BuildConfig.DEBUG) {
         addInterceptor(

docs/log-recorder.md

@@ -1,10 +1,10 @@
-两种日志插件
+以下两种日志插件
 
 | [Okhttp Profiler](https://github.com/itkacher/OkHttpProfiler) | [Profiler](https://developer.android.com/studio/profile/network-profiler?hl=zh-cn) |
 | ------------------------------------------------------------ | ------------------------------------------------------------ |
 | 列表显示                                                     | 动态曲线图                                                   |
-| 要求添加`LogRecordInterceptor`                               | 可查看所有OkHttp的请求                                       |
-| 原理是插件捕获LogCat日志, 线上环境请关闭                     | 无法捕获启动一瞬间的请求                                     |
+| 添加`LogRecordInterceptor`拦截器                               | 默认记录所有OkHttp的请求                                       |
+| 原理是插件捕获LogCat日志, 线上环境需关闭                     | 无法捕获启动一瞬间的请求                                     |
 
 ## LogRecordInterceptor
 
@@ -40,7 +40,7 @@ NetConfig.initialize(Api.HOST, this) {
 !!! warning "不显示日志"
     请在请求前确保有打开过插件窗口, 如果依然不显示可以反复打开/关闭窗口
 
-    每次AS更新都需要该插件作者适配, 可能存在beta版本作者没有适配情况
+    每次AS更新可能要该插件作者适配, 发现无效请[反馈给作者更新](https://github.com/itkacher/OkHttpProfiler/issues)
 
 
 
@@ -61,8 +61,8 @@ NetConfig.initialize(Api.HOST, this) {
 
 继承`LogRecordInterceptor`复写函数实现自定义
 
-1. 复写`getRequestLog`返回解密请求参数
-2. 复写`getResponseLog`返回解密响应参数
+1. 复写`getRequestLog`返回请求参数
+2. 复写`getResponseLog`返回响应参数
 
 初始化时添加自己的拦截器
 
@@ -84,7 +84,7 @@ NetConfig.initialize(Api.HOST, this) {
 
 `LogRecordInterceptor`属于OkHttp拦截器, 其他网络请求框架也可以使用
 
-甚至可以直接使用`LogRecorder`输出日志
+或者直接使用`LogRecorder`输出日志
 
 | LogRecorder | 描述 |
 |-|-|

docs/okhttp-client.md

@@ -17,7 +17,7 @@ NetConfig.initialize(Api.HOST, this) {
 
 ## 单例
 
-可以单独指定当前请求客户端
+单独指定当前请求客户端
 
 === "修改全局客户端"
     ```kotlin

docs/progress.md

@@ -5,7 +5,7 @@ Net支持上传/下载的进度监听, 且具备完善的进度信息
 
 ```kotlin
 scopeNetLife {
-    Post<String>("https://download.sublimetext.com/Sublime%20Text%20Build%203211.dmg") {
+    Post<String>(Api.UPLOAD) {
         param("file", assetsFile())
         addUploadListener(object : ProgressListener() {
             override fun onProgress(p: Progress) {
@@ -29,7 +29,7 @@ scopeNetLife {
 ```kotlin
 scopeNetLife {
     val file =
-        Get<File>("https://download.sublimetext.com/Sublime%20Text%20Build%203211.dmg") {
+        Get<File>("https://github.com/liangjingkanji/Net/releases/latest/download/net-sample.apk") {
             setDownloadFileName("net.apk")
             setDownloadDir(requireContext().filesDir)
 
@@ -50,12 +50,12 @@ scopeNetLife {
 ```
 
 !!! success "监听任何进度"
-    不仅是泛型为File才有效, 任何请求/响应都可以监听进度
+    不仅是泛型为File才有效, 任何请求体/响应体都可以监听进度
 
 
 ## 监听器
 
-实现`ProgressListener`监听进度信息. 进度信息为`Progress`
+实现`ProgressListener`监听进度信息, 进度信息为`Progress`
 
 ### 进度间隔时间
 

docs/repeat-request.md

@@ -9,7 +9,7 @@ btnFilter.setOnClickListener {
     scope?.cancel()
 
     scope = scopeNetLife {
-        val result = Post<String>("api").await()
+        val result = Post<String>(Api.PATH).await()
     }
 }
 ```

docs/request.md

@@ -10,7 +10,7 @@
 ```kotlin
 scopeNetLife {
     val userInfo = Post<UserInfoModel>(Api.LOGIN) {
-        param("username", "drake")
+        param("username", "用户名")
         param("password", "6f2961eb44b12123393fff7e449e50b9de2499c6")
     }.await()
 }
@@ -34,7 +34,7 @@ scopeNetLife {
     val measurements = listOf(100, 100, 100)
     
     scopeNetLife {
-        tvFragment.text = Post<String>("api") {
+        tv.text = Post<String>(Api.PATH) {
             // 只支持基础类型的值, 如果值为对象或者包含对象的集合/数组会导致其值为null
             json("name" to name, "age" to age, "measurements" to measurements)
         }.await()
@@ -48,7 +48,7 @@ scopeNetLife {
     val measurements = listOf(100, 100, 100) // 只支持基础类型的值, 如果值为对象或者包含对象的集合/数组会导致其值为null
 
     scopeNetLife {
-        tvFragment.text = Post<String>("api") {
+        tv.text = Post<String>(Api.PATH) {
             json(JSONObject().run {
                 put("name", name)
                 put("age", age)
@@ -65,7 +65,7 @@ scopeNetLife {
     val measurements = listOf(100, 100, 100)
     
     scopeNetLife {
-        tvFragment.text = Post<String>("api") {
+        tv.text = Post<String>(Api.PATH) {
             body = CustomizerJSONBody(name, age, measurements)
         }.await()
     }
@@ -99,7 +99,7 @@ scopeNetLife {
 
 ```kotlin
 scopeNetLife {
-    tvFragment.text = Post<String>("api") {
+    tv.text = Post<String>(Api.PATH) {
         gson("name" to name, "model" to Model()) // 参数支持Gson可解析的对象
         // fastJson("name" to name, "model" to Model()) // 使用FastJson
     }.await()

docs/scope.md

@@ -47,10 +47,10 @@
 
 ```kotlin hl_lines="5"
 scopeNetLife {
-    val task = Post<String>("api0").await()
+    val task = Post<String>("path").await()
 
     scopeNetLife {
-        val task = Post<String>("api0").await() // 此时发生请求错误
+        val task = Post<String>("path/error").await() // 此时发生请求错误
     }.catch {
         // A
     }
@@ -67,10 +67,10 @@ scopeNetLife {
 
 ```kotlin hl_lines="7 10"
 scopeNet {
-    val await = Post<String>("api").await()
+    val await = Post<String>("path").await()
 
     launch {
-       val task = Post<String>("api0").await()  // 此时发生请求错误
+       val task = Post<String>("path/error").await()  // 此时发生请求错误
     }.invokeOnCompletion {
         // A
     }

docs/sync-request.md

@@ -11,9 +11,9 @@ Net支持在当前线程执行阻塞线程的同步请求
 
     ```kotlin
     thread {
-        val result = Net.post("api").execute<String>() // 网络请求不允许在主线程
-        tvFragment?.post {
-            tvFragment?.text = result  // view要求在主线程更新
+        val result = Net.post(Api.PATH).execute<String>() // 网络请求不允许在主线程
+        tv?.post {
+            tv?.text = result  // view要求在主线程更新
         }
     }
     ```
@@ -22,9 +22,9 @@ Net支持在当前线程执行阻塞线程的同步请求
 
     ```kotlin
     thread {
-        val result = Net.post("api").toResult<String>().getOrDefault("请求发生错误, 我是默认值")
-        tvFragment?.post {
-            tvFragment?.text = result  // view要求在主线程更新
+        val result = Net.post(Api.PATH).toResult<String>().getOrDefault("请求发生错误, 我是默认值")
+        tv?.post {
+            tv?.text = result  // view要求在主线程更新
         }
     }
     ```

docs/tag.md

@@ -11,7 +11,7 @@ Net支持两种方式携带数据, 贯穿整个请求流程(请求/拦截器/转
 
 ```kotlin hl_lines="2"
 scopeNetLife {
-    tvFragment.text = Get<String>("api", "标签A"){ // 使用Any::class.java作为键名
+    tv.text = Get<String>(Api.PATH, "标签A"){ // 使用Any::class.java作为键名
         // tag("标签A") 等效上一行的参数 "标签A"
         setExtra("tagName", "标签B") // 写入额外数据
     }.await()
@@ -64,7 +64,7 @@ class MyConvert : NetConvert {
 
 ```kotlin
 scopeNetLife {
-    Get<String>("api"){
+    Get<String>(Api.PATH){
         setExtra("person", Person()) // 使用Request.extra("person")读取
         tag(User()) // 等同于tag(Any::class.java, User()), 使用Request.tag()读取
         tag(User::class.java, User()) // 使用Request.tag(User::class.java)读取

docs/thread.md

@@ -7,10 +7,13 @@
 
 ```kotlin
 scopeNetLife(dispatcher = Dispatchers.IO) {
-    binding.tvFragment.text = Get<String>("api").await()
+    tv.text = Get<String>(Api.PATH).await()
 }
 ```
 
+!!! failure "禁止的调度器"
+    `Dispatchers.Main.immediate`会立即同步执行, 导致`catch/finally`函数无效
+
 ## 作用域内部切换
 
 有时需开启新的线程处理耗时任务
@@ -18,7 +21,7 @@ scopeNetLife(dispatcher = Dispatchers.IO) {
 === "主线程作用域内切换子线程"
     ```kotlin hl_lines="2"
     scopeNetLife {
-        binding.tvFragment.text = withIO {
+        tv.text = withIO {
             // 假设此处是一个IO读写阻塞任务
             return "读出结果"
         }
@@ -28,7 +31,7 @@ scopeNetLife(dispatcher = Dispatchers.IO) {
 === "子线程作用域内切换主线程"
     ```kotlin hl_lines="2"
     scopeNetLife(dispatcher = Dispatchers.IO) {
-        binding.tvFragment.text = withMain {
+        tv.text = withMain {
             // 假设此处是一个IO读写阻塞任务
             return "读出结果"
         }

docs/timing.md

@@ -9,12 +9,12 @@
 scopeDialog {
     // 当接口请求在100毫秒内没有完成会抛出异常TimeoutCancellationException
     withTimeout(100) {
-        Get<String>(Api.BANNER).await()
+        Get<String>(Api.PATH).await()
     }
 }.catch {
-    Log.e("日志", "catch", it) // catch无法接收到CancellationException异常
+    Log.e("日志", "请求错误", it) // catch无法接收到CancellationException异常
 }.finally {
-    Log.e("日志", "finally", it) // TimeoutCancellationException属于CancellationException子类故只会被finally接收到
+    Log.e("日志", "请求完成", it) // TimeoutCancellationException属于CancellationException子类故只会被finally接收到
     if (it is TimeoutCancellationException) {
         toast("由于未在指定时间完成请求则取消请求")
     }
@@ -27,29 +27,27 @@ scopeDialog {
 
 ```kotlin
 scopeNetLife {
-    // 每两秒请求一次, 总共执行10次
+    // 每秒请求一次, 总共执行10次
     repeat(20) {
         delay(1000)
-        val data =
-            Get<String>("http://api.k780.com/?app=life.time&appkey=10003&sign=b59bc3ef6191eb9f747dd4e83c99f2a4&format=json").await()
-        binding.tvContent.text =
-            JSONObject(data).getJSONObject("result").getString("datetime_2")
-        // 通过return@repeat可以终止循环
+        val data = Get<String>(Api.PATH).await()
+        if(it = 10) {
+            return@repeat
+        }
     }
 }
 ```
 
-无限循环请求, 可以根据某个条件`break`退出
+每秒无限循环请求, 根据某个条件`break`退出
 
 ```kotlin
 scopeNetLife {
     while (true) {
         delay(1.toDuration(DurationUnit.SECONDS))
-        val data =
-            Get<String>("http://api.k780.com/?app=life.time&appkey=10003&sign=b59bc3ef6191eb9f747dd4e83c99f2a4&format=json").await()
-        binding.tvContent.text =
-            JSONObject(data).getJSONObject("result").getString("datetime_2")
-        // 通过break可以终止循环
+        val data = Get<Config>(Api.PATH).await()
+        if(data.type = 3) {
+            break
+        }
     }
 }
 ```

docs/track.md

@@ -4,7 +4,7 @@ Net中网络请求异常会LogCat输出, 除非开发者修改全局错误处理
 演示访问一个不存在的请求路径
 ```kotlin
 scopeNetLife {
-    tvFragment.text = Get<String>("https://githuberror.com/liangjingkanji/Net/").await()
+    tv.text = Get<String>("https://error.com/net/").await()
 }
 ```
 

docs/upload-file.md

@@ -22,22 +22,23 @@ scopeNetLife {
 
 ## 上传类型
 
-自定义RequestBody可以实现任何数据类型的上传, 但是Net提供常用函数简化`Uri/File`上传
+自定义RequestBody可以实现任何数据类型的上传
 
 ```kotlin
 scopeNetLife {
     Post<String>(Api.UPLOAD) {
-        // MultiPart 上传
+        // 表单上传
         param("file", Uri)
         param("file", File)
 
-        // 自定义请求体, 会覆盖以上所有请求内容
+        // 自定义请求体, 会覆盖其他请求参数
         body = CustomizerRequestBody()
     }.await()
 }
 ```
 
-直接上传`InputStream`输入流属于不安全行为, 建议你保存到文件后上传,
-详细请阅读: [使用文件流上传文件](https://github.com/liangjingkanji/Net/discussions/190)
+直接上传`InputStream`可能内存泄露, 建议你保存到文件后上传
+
+1. [使用文件流上传文件](https://github.com/liangjingkanji/Net/discussions/190)
 
 

docs/view-model.md

@@ -16,7 +16,7 @@ Net支持在ViewModel中创建网络请求/异步任务
 class UserViewModel : ViewModel() {
 
     // 用户信息
-    private var userInfo: MutableLiveData<String> = MutableLiveData()
+    var userInfo: MutableLiveData<String> = MutableLiveData()
 
     /**
      * 使用LiveData接受请求结果, 将该liveData直接使用DataBinding绑定到页面上, 会在请求成功自动更新视图

sample/src/main/java/com/drake/net/sample/base/App.kt

@@ -76,11 +76,11 @@ class App : Application() {
 
         MockDispatcher.initialize()
 
-        initializeThirdPart()
+        initializeView()
     }
 
     /** 初始化第三方依赖库库 */
-    private fun initializeThirdPart() {
+    private fun initializeView() {
 
         // 全局缺省页配置 [https://github.com/liangjingkanji/StateLayout]
         StateConfig.apply {

sample/src/main/java/com/drake/net/sample/constants/Api.kt

@@ -7,7 +7,7 @@ package com.drake.net.sample.constants
 object Api {
     const val HOST = "http://127.0.0.1:8091"
 
-    const val TEST = "/test"
+    const val TEXT = "/text"
     const val DELAY = "/delay"
     const val UPLOAD = "/upload"
     const val GAME = "/game"

sample/src/main/java/com/drake/net/sample/mock/MockDispatcher.kt

@@ -36,7 +36,7 @@ class MockDispatcher : Dispatcher() {
 
     override fun dispatch(request: RecordedRequest): MockResponse {
         return when (request.requestUrl?.encodedPath ?: "") {
-            Api.TEST -> getString("Request Success : ${request.method}")
+            Api.TEXT -> getString("Request Success : ${request.method}")
             Api.DELAY -> getString("Request Success : ${request.method}").setBodyDelay(2, TimeUnit.SECONDS)
             Api.UPLOAD -> uploadFile(request)
             Api.GAME -> getRawResponse(R.raw.game)

sample/src/main/java/com/drake/net/sample/ui/fragment/CallbackRequestFragment.kt

@@ -19,7 +19,7 @@ class CallbackRequestFragment :
 
     override fun initView() {
         // Net同样支持OkHttp原始的队列任务
-        Net.post(Api.TEST).enqueue(object : Callback {
+        Net.post(Api.TEXT).enqueue(object : Callback {
             override fun onFailure(call: Call, e: IOException) {
             }
 

sample/src/main/java/com/drake/net/sample/ui/fragment/FastestFragment.kt

@@ -19,7 +19,7 @@ class FastestFragment : EngineFragment<FragmentFastestBinding>(R.layout.fragment
             */
 
             // 同时发起四个网络请求
-            val deferred2 = Get<String>(Api.TEST) { setGroup("最快") }
+            val deferred2 = Get<String>(Api.TEXT) { setGroup("最快") }
             val deferred3 = Post<String>("navi/json") { setGroup("最快") }
             val deferred = Get<String>("api0") { setGroup("最快") } // 错误接口
             val deferred1 = Get<String>("api1") { setGroup("最快") } // 错误接口

sample/src/main/java/com/drake/net/sample/ui/fragment/InterceptorFragment.kt

@@ -13,7 +13,7 @@ class InterceptorFragment :
 
     override fun initView() {
         scopeNetLife {
-            binding.tvFragment.text = Get<String>(Api.TEST) {
+            binding.tvFragment.text = Get<String>(Api.TEXT) {
                 // 拦截器只支持全局, 无法单例, 请查看[com.drake.net.sample.interceptor.NetInterceptor]
             }.await()
         }

sample/src/main/java/com/drake/net/sample/ui/fragment/LimitedTimeFragment.kt

@@ -24,7 +24,7 @@ class LimitedTimeFragment : EngineFragment<FragmentLimitedTimeBinding>(R.layout.
         scopeDialog {
             // 当接口请求在100毫秒内没有完成会抛出异常TimeoutCancellationException
             withTimeout(100) {
-                Get<String>(Api.TEST).await()
+                Get<String>(Api.TEXT).await()
             }
         }.catch {
             Log.e("日志", "catch", it) // catch无法接收到CancellationException异常

sample/src/main/java/com/drake/net/sample/ui/fragment/ParallelNetworkFragment.kt

@@ -17,9 +17,9 @@ class ParallelNetworkFragment :
         scopeNetLife {
 
             // 同时发起三个请求
-            val deferred = Get<String>(Api.TEST)
-            val deferred1 = Post<String>(Api.TEST)
-            val deferred2 = Trace<String>(Api.TEST)
+            val deferred = Get<String>(Api.TEXT)
+            val deferred1 = Post<String>(Api.TEXT)
+            val deferred2 = Trace<String>(Api.TEXT)
 
             // 同时接收三个请求数据
             deferred.await()

sample/src/main/java/com/drake/net/sample/ui/fragment/PreviewCacheFragment.kt

@@ -19,13 +19,13 @@ class PreviewCacheFragment : EngineFragment<FragmentReadCacheBinding>(R.layout.f
 
         scopeNetLife {
             // 然后执行这里(网络请求)
-            binding.tvFragment.text = Get<String>(Api.TEST) {
+            binding.tvFragment.text = Get<String>(Api.TEXT) {
                 setCacheMode(CacheMode.WRITE)
             }.await()
             Log.d("日志", "网络请求")
         }.preview(true) {
             // 先执行这里(仅读缓存), 任何异常都视为读取缓存失败
-            binding.tvFragment.text = Get<String>(Api.TEST) {
+            binding.tvFragment.text = Get<String>(Api.TEXT) {
                 setCacheMode(CacheMode.READ)
             }.await()
             Log.d("日志", "读取缓存")

sample/src/main/java/com/drake/net/sample/ui/fragment/ReadCacheFragment.kt

@@ -19,7 +19,7 @@ class ReadCacheFragment : EngineFragment<FragmentReadCacheBinding>(R.layout.frag
     override fun initView() {
         scopeNetLife {
             binding.tvFragment.text =
-                Post<String>(Api.TEST) {
+                Post<String>(Api.TEXT) {
                     setCacheMode(CacheMode.REQUEST_THEN_READ) // 请求网络失败会读取缓存, 请断网测试
                     // setCacheKey("自定义缓存KEY")
                 }.await()

sample/src/main/java/com/drake/net/sample/ui/fragment/RequestMethodFragment.kt

@@ -25,49 +25,49 @@ class RequestMethodFragment :
 
     private fun GET() {
         scopeNetLife {
-            binding.tvFragment.text = Get<String>(Api.TEST).await()
+            binding.tvFragment.text = Get<String>(Api.TEXT).await()
         }
     }
 
     private fun POST() {
         scopeNetLife {
-            binding.tvFragment.text = Post<String>(Api.TEST).await()
+            binding.tvFragment.text = Post<String>(Api.TEXT).await()
         }
     }
 
     private fun HEAD() {
         scopeNetLife {
-            binding.tvFragment.text = Head<String>(Api.TEST).await()
+            binding.tvFragment.text = Head<String>(Api.TEXT).await()
         }
     }
 
     private fun PUT() {
         scopeNetLife {
-            binding.tvFragment.text = Put<String>(Api.TEST).await()
+            binding.tvFragment.text = Put<String>(Api.TEXT).await()
         }
     }
 
     private fun PATCH() {
         scopeNetLife {
-            binding.tvFragment.text = Patch<String>(Api.TEST).await()
+            binding.tvFragment.text = Patch<String>(Api.TEXT).await()
         }
     }
 
     private fun DELETE() {
         scopeNetLife {
-            binding.tvFragment.text = Delete<String>(Api.TEST).await()
+            binding.tvFragment.text = Delete<String>(Api.TEXT).await()
         }
     }
 
     private fun TRACE() {
         scopeNetLife {
-            binding.tvFragment.text = Trace<String>(Api.TEST).await()
+            binding.tvFragment.text = Trace<String>(Api.TEXT).await()
         }
     }
 
     private fun OPTIONS() {
         scopeNetLife {
-            binding.tvFragment.text = Options<String>(Api.TEST).await()
+            binding.tvFragment.text = Options<String>(Api.TEXT).await()
         }
     }
 
@@ -92,7 +92,7 @@ class RequestMethodFragment :
             // }.await()
 
             // 创建JSON
-            binding.tvFragment.text = Post<String>(Api.TEST) {
+            binding.tvFragment.text = Post<String>(Api.TEXT) {
                 json("name" to name, "age" to age, "measurements" to measurements) // 同时支持Map集合
             }.await()
         }

sample/src/main/java/com/drake/net/sample/ui/fragment/StateLayoutFragment.kt

@@ -17,7 +17,7 @@ class StateLayoutFragment :
     override fun initView() {
         binding.state.onRefresh {
             scope {
-                binding.tvFragment.text = Get<String>(Api.TEST).await()
+                binding.tvFragment.text = Get<String>(Api.TEXT).await()
             }
         }.showLoading()
     }

sample/src/main/java/com/drake/net/sample/ui/fragment/SyncRequestFragment.kt

@@ -13,7 +13,7 @@ class SyncRequestFragment :
     override fun initView() {
         thread { // 网络请求不允许在主线程
             val result = try {
-                Net.post(Api.TEST).execute<String>()
+                Net.post(Api.TEXT).execute<String>()
             } catch (e: Exception) { // 同步请求失败会导致崩溃要求捕获异常
                 "请求错误 = ${e.message}"
             }

sample/src/main/java/com/drake/net/sample/ui/fragment/UniqueRequestFragment.kt

@@ -20,7 +20,7 @@ class UniqueRequestFragment :
             scope?.cancel() // 如果存在则取消
 
             scope = scopeNetLife {
-                val result = Post<String>(Api.TEST).await()
+                val result = Post<String>(Api.TEXT).await()
                 Log.d("日志", "请求到结果") // 你一直重复点击"发起请求"按钮会发现永远无法拿到请求结果, 因为每次发起新的请求会取消未完成的
                 binding.tvResult.text = result
             }

sample/src/main/java/com/drake/net/sample/vm/UserViewModel.kt

@@ -28,14 +28,14 @@ class UserViewModel : ViewModel() {
      * 开始非阻塞异步任务
      *  返回Deferred, 调用await()才会返回结果
      */
-    fun fetchList(scope: CoroutineScope) = scope.Get<String>(Api.TEST)
+    fun fetchList(scope: CoroutineScope) = scope.Get<String>(Api.TEXT)
 
     /**
      * 开始阻塞异步任务
      * 直接返回结果
      */
     suspend fun fetchPrecessData() = coroutineScope {
-        val response = Get<String>(Api.TEST).await()
+        val response = Get<String>(Api.TEXT).await()
         response + "处理数据"
     }
 }