Android Retrofit工具类 （kotlin版本）

最新推荐文章于 2024-05-21 10:10:55 发布
最新推荐文章于 2024-05-21 10:10:55 发布
阅读量417 收藏 8
点赞数 9
文章标签： android retrofit kotlin
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43500004/article/details/136740053
版权

前言

之前写过一个工具类，实现网络请求，最近在搞kotlin，作为没系统学习kotlin 就要应用到项目上，也算是一大挑战，虽然会kotlin的人都说很简单。
所以尝试这写一下kotlin版本的工具类

正文

import android.annotation.SuppressLint
import android.util.Log
import com.google.gson.Gson
import io.reactivex.Observable
import io.reactivex.Observer
import io.reactivex.android.schedulers.AndroidSchedulers
import io.reactivex.disposables.Disposable
import io.reactivex.schedulers.Schedulers
import okhttp3.Interceptor
import okhttp3.MediaType
import okhttp3.MultipartBody
import okhttp3.OkHttpClient
import okhttp3.RequestBody
import okhttp3.Response
import okhttp3.ResponseBody
import retrofit2.Retrofit
import retrofit2.adapter.rxjava2.RxJava2CallAdapterFactory
import retrofit2.http.Body
import retrofit2.http.FieldMap
import retrofit2.http.FormUrlEncoded
import retrofit2.http.GET
import retrofit2.http.HeaderMap
import retrofit2.http.Multipart
import retrofit2.http.POST
import retrofit2.http.Part
import retrofit2.http.QueryMap
import retrofit2.http.Url
import java.io.File
import java.lang.reflect.ParameterizedType
import java.util.concurrent.TimeUnit

//使用前 需要导入依赖
/*
    //retrofit
    implementation 'com.squareup.retrofit2:retrofit:2.9.0'
    //Gson converter
    implementation 'com.squareup.retrofit2:converter-gson:2.9.0'
    //RxJava2 Adapter
    implementation 'com.squareup.retrofit2:adapter-rxjava2:2.9.0'
    //RxJava
    implementation 'io.reactivex.rxjava2:rxjava:2.2.10'
    implementation 'io.reactivex.rxjava2:rxandroid:2.1.1'
    implementation 'nl.bravobit:android-ffmpeg:1.1.7'
*/

class RetrofitUtils(url: String) {
    private val gson = Gson()
    private var isOpenLog = false//是否打开log
    private var classname = ""
    private val builder: MultipartBody.Builder

    //初始化
    init {
        val build = OkHttpClient().newBuilder().addInterceptor(LoggingInterceptor())
            .connectTimeout(1000 * 30, TimeUnit.MILLISECONDS)
            .writeTimeout(1000 * 30, TimeUnit.MILLISECONDS).build()
        API = Retrofit.Builder().baseUrl(url).client(build)
            .addCallAdapterFactory(RxJava2CallAdapterFactory.create()).build()
            .create(ApiService::class.java)
        builder = MultipartBody.Builder()
    }

    //单例获取对象
    companion object {
        private var instance: RetrofitUtils? = null

        fun getInstance(url: String): RetrofitUtils {
            if (instance == null) {
                instance = RetrofitUtils(url)
            }
            return instance!!
        }

        private const val TAG = "RetrofitUtils"
        private lateinit var API: ApiService
    }

    //get请求有参
    fun <T> doGet(url: String, map: Map<String, Any>, callBack: CallBack<T>) {
        API.doGet(url, map).subscribeOn(Schedulers.io()).subscribe(object : Observer<ResponseBody> {
            override fun onSubscribe(d: Disposable) {

            }

            override fun onError(e: Throwable) {
                callBack.onError(e.toString())
            }

            override fun onComplete() {

            }

            override fun onNext(t: ResponseBody) {
                val string = t.string()
                if (isOpenLog) {
                    Log.e(Companion.TAG, "onNext: $classname\n$string")
                }
                val genericInterfaces = callBack::class.java.genericInterfaces
                val parameterizedType = genericInterfaces[0] as ParameterizedType
                val actualTypeArguments = parameterizedType.actualTypeArguments
                val type = actualTypeArguments[0]
                val fromJson = gson.fromJson<T>(string, type)
                callBack.onSuccess(fromJson)
            }
        })
    }

    //get请求请求头 有参
    fun <T> doGet(
        url: String, header: Map<String, Any>, map: Map<String, Any>, callBack: CallBack<T>
    ) {
        API.doGet(url, header, map).subscribeOn(Schedulers.io())
            .subscribe(object : Observer<ResponseBody> {
                override fun onSubscribe(d: Disposable) {

                }

                override fun onError(e: Throwable) {
                    callBack.onError(e.toString())
                }

                override fun onComplete() {

                }

                override fun onNext(t: ResponseBody) {
                    val string = t.string()
                    if (isOpenLog) {
                        Log.e(Companion.TAG, "onNext: $classname\n$string")
                    }
                    val genericInterfaces = callBack::class.java.genericInterfaces
                    val parameterizedType = genericInterfaces[0] as ParameterizedType
                    val actualTypeArguments = parameterizedType.actualTypeArguments
                    val type = actualTypeArguments[0]
                    val fromJson = gson.fromJson<T>(string, type)
                    callBack.onSuccess(fromJson)
                }
            })
    }

    //get请求 返回值是集合
    fun <T> doGetArray(url: String, callBack: ArrayCallBack) {
        API.doGetArray(url).subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread())
            .subscribe(object : Observer<ResponseBody> {
                override fun onSubscribe(d: Disposable) {
                }

                override fun onError(e: Throwable) {
                    callBack.onError(e.toString())
                }

                override fun onComplete() {

                }

                override fun onNext(t: ResponseBody) {
                    val string = t.string()
                    if (isOpenLog) {
                        Log.e(Companion.TAG, "onNext: $classname\n$string")
                    }
                    callBack.onSuccess(string)
                }
            })
    }

    //get请求 无参
    fun <T> doGet(url: String, callBack: CallBack<T>) {
        API.doGet(url).subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread())
            .subscribe(object : Observer<ResponseBody> {
                override fun onSubscribe(d: Disposable) {

                }

                override fun onError(e: Throwable) {
                    callBack.onError(e.toString())
                }

                override fun onComplete() {

                }

                override fun onNext(t: ResponseBody) {
                    val string = t.string()
                    if (isOpenLog) {
                        Log.e(Companion.TAG, "onNext: $classname\n$string")
                    }
                    val genericInterfaces = callBack::class.java.genericInterfaces
                    val parameterizedType = genericInterfaces[0] as ParameterizedType
                    val actualTypeArguments = parameterizedType.actualTypeArguments
                    val type = actualTypeArguments[0]
                    val fromJson = gson.fromJson<T>(string, type)
                    callBack.onSuccess(fromJson)
                }
            })
    }

    //post请求 有参
    fun <T> doPost(url: String, map: Map<String, Any>, callBack: CallBack<T>) {
        API.doPost(url, map).subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread())
            .subscribe(object : Observer<ResponseBody> {
                override fun onSubscribe(d: Disposable) {

                }

                override fun onError(e: Throwable) {
                    callBack.onError(e.toString())
                }

                override fun onComplete() {

                }

                override fun onNext(t: ResponseBody) {
                    val string = t.string()
                    if (isOpenLog) {
                        Log.e(Companion.TAG, "onNext: $classname\n$string")
                    }
                    val genericInterfaces = callBack::class.java.genericInterfaces
                    val parameterizedType = genericInterfaces[0] as ParameterizedType
                    val actualTypeArguments = parameterizedType.actualTypeArguments
                    val type = actualTypeArguments[0]
                    val fromJson = gson.fromJson<T>(string, type)
                    callBack.onSuccess(fromJson)
                }
            })
    }

    //post请求 无参
    fun <T> doPost(url: String, callBack: CallBack<T>) {
        API.doPost(url).subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread())
            .subscribe(object : Observer<ResponseBody> {
                override fun onSubscribe(d: Disposable) {

                }

                override fun onError(e: Throwable) {
                    callBack.onError(e.toString())
                }

                override fun onComplete() {

                }

                override fun onNext(t: ResponseBody) {
                    val string = t.string()
                    if (isOpenLog) {
                        Log.e(Companion.TAG, "onNext: $classname\n$string")
                    }
                    val genericInterfaces = callBack::class.java.genericInterfaces
                    val parameterizedType = genericInterfaces[0] as ParameterizedType
                    val actualTypeArguments = parameterizedType.actualTypeArguments
                    val type = actualTypeArguments[0]
                    val fromJson = gson.fromJson<T>(string, type)
                    callBack.onSuccess(fromJson)
                }
            })
    }

    //post请求 请求头 有参
    fun <T> doPost(
        url: String, header: Map<String, Any>, map: Map<String, Any>, callBack: CallBack<T>
    ) {
        API.doPost(url, header, map).subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread()).subscribe(object : Observer<ResponseBody> {
                override fun onSubscribe(d: Disposable) {

                }

                override fun onError(e: Throwable) {
                    callBack.onError(e.toString())
                }

                override fun onComplete() {

                }

                override fun onNext(t: ResponseBody) {
                    val string = t.string()
                    if (isOpenLog) {
                        Log.e(Companion.TAG, "onNext: $classname\n$string")
                    }
                    val genericInterfaces = callBack::class.java.genericInterfaces
                    val parameterizedType = genericInterfaces[0] as ParameterizedType
                    val actualTypeArguments = parameterizedType.actualTypeArguments
                    val type = actualTypeArguments[0]
                    val fromJson = gson.fromJson<T>(string, type)
                    callBack.onSuccess(fromJson)
                }
            })
    }

    //上传图片
    fun <T> doFile(url: String, file: File, callBack: CallBack<T>) {
        val body = RequestBody.create(MediaType.parse("image/*"), file)//上传的文件
        val parts: List<MultipartBody.Part> =
            builder.setType(MultipartBody.FORM).addFormDataPart("file", file.name, body).build()
                .parts()
        API.upload(url, parts).subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread()).subscribe(object : Observer<ResponseBody> {
                override fun onSubscribe(d: Disposable) {

                }

                override fun onError(e: Throwable) {
                    callBack.onError(e.toString())
                }

                override fun onComplete() {

                }

                override fun onNext(t: ResponseBody) {
                    val string = t.string()
                    if (isOpenLog) {
                        Log.e(Companion.TAG, "onNext: $classname\n$string")
                    }
                    val genericInterfaces = callBack::class.java.genericInterfaces
                    val parameterizedType = genericInterfaces[0] as ParameterizedType
                    val actualTypeArguments = parameterizedType.actualTypeArguments
                    val type = actualTypeArguments[0]
                    val fromJson = gson.fromJson<T>(string, type)
                    callBack.onSuccess(fromJson)
                }
            })
    }

    //上传图片 请求头
    fun <T> doFile(url: String, header: Map<String, Any>, file: File, callBack: CallBack<T>) {
        val body = RequestBody.create(MediaType.parse("image/*"), file)//上传的文件
        val parts: List<MultipartBody.Part> =
            builder.setType(MultipartBody.FORM).addFormDataPart("file", file.name, body).build()
                .parts()
        API.upload(url, header, parts).subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread()).subscribe(object : Observer<ResponseBody> {
                override fun onSubscribe(d: Disposable) {

                }

                override fun onError(e: Throwable) {
                    callBack.onError(e.toString())
                }

                override fun onComplete() {

                }

                override fun onNext(t: ResponseBody) {
                    val string = t.string()
                    if (isOpenLog) {
                        Log.e(Companion.TAG, "onNext: $classname\n$string")
                    }
                    val genericInterfaces = callBack::class.java.genericInterfaces
                    val parameterizedType = genericInterfaces[0] as ParameterizedType
                    val actualTypeArguments = parameterizedType.actualTypeArguments
                    val type = actualTypeArguments[0]
                    val fromJson = gson.fromJson<T>(string, type)
                    callBack.onSuccess(fromJson)
                }
            })
    }

    //post请求 请求头 有参
    @SuppressLint("NewApi")
    fun doPostString(
        url: String, header: Map<String, Any>, map: Map<String, Any>, callBack: CallBack<String>
    ) {
        API.doPost(url, header, map).subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread()).subscribe(object : Observer<ResponseBody> {
                override fun onSubscribe(d: Disposable) {
                }

                override fun onError(e: Throwable) {
                    callBack.onError(e.toString())
                }

                override fun onComplete() {

                }

                override fun onNext(t: ResponseBody) {
                    val string = t.string()
                    if (isOpenLog) {
                        Log.e(Companion.TAG, "onNext: $classname\n$string")
                    }
                    callBack.onSuccess(string)
                }
            })
    }

    //post请求 RequestBody 请求头
    @SuppressLint("NewApi")
    fun <T> doPost(
        url: String, body: RequestBody, header: Map<String, Any>, callBack: CallBack<T>
    ) {
        API.doPost(url, body, header).subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread()).subscribe(object : Observer<ResponseBody> {
                override fun onSubscribe(d: Disposable) {

                }

                override fun onError(e: Throwable) {
                    callBack.onError(e.toString())
                }

                override fun onComplete() {

                }

                override fun onNext(t: ResponseBody) {
                    val string = t.string()
                    if (isOpenLog) {
                        Log.e(Companion.TAG, "onNext: $classname\n$string")
                    }
                    val genericInterfaces = callBack::class.java.genericInterfaces
                    val parameterizedType = genericInterfaces[0] as ParameterizedType
                    val actualTypeArguments = parameterizedType.actualTypeArguments
                    val type = actualTypeArguments[0]
                    val fromJson = gson.fromJson<T>(string, type)
                    callBack.onSuccess(fromJson)
                }
            })
    }

    interface ApiService {

        @POST
        @FormUrlEncoded
        fun doPost(@Url url: String, @FieldMap map: Map<String, Any>): Observable<ResponseBody>

        @GET
        fun doGet(@Url url: String, @QueryMap map: Map<String, Any>): Observable<ResponseBody>

        @GET
        fun doGet(@Url url: String): Observable<ResponseBody>

        @GET
        fun doGetArray(@Url url: String): Observable<ResponseBody>

        @POST
        @FormUrlEncoded
        fun doPost(
            @Url url: String,
            @HeaderMap headerMap: Map<String, Any>,
            @FieldMap map: Map<String, Any>
        ): Observable<ResponseBody>

        @GET
        fun doGet(
            @Url url: String,
            @HeaderMap headerMap: Map<String, Any>,
            @QueryMap map: Map<String, Any>
        ): Observable<ResponseBody>

        @Multipart
        @POST
        fun upload(
            @Url url: String, @Part partList: List<MultipartBody.Part>
        ): Observable<ResponseBody>

        @Multipart
        @POST
        fun upload(
            @Url url: String,
            @HeaderMap headerMap: Map<String, Any>,
            @Part partList: List<MultipartBody.Part>
        ): Observable<ResponseBody>

        @POST
        fun doPost(
            @Url url: String, @Body body: RequestBody, @HeaderMap headerMap: Map<String, Any>
        ): Observable<ResponseBody>

        @POST
        @FormUrlEncoded
        fun doPost(@Url url: String): Observable<ResponseBody>

    }

    private fun setClassName(name: String): RetrofitUtils? {
        this.classname = name
        return instance
    }

    //是否显示log
    private fun isOpenLog(isOpenLog: Boolean): RetrofitUtils? {
        this.isOpenLog = isOpenLog
        return instance
    }




    object GetParameter{
        private val h = HashMap<String, Any>()
        private val p = HashMap<String, Any>()
        //参数集合 手动添加
        fun parameter(): HashMap<String, Any> {
            clearPMap()
            return p
        }
        fun header(): HashMap<String, Any> {
            clearHMap()
            return h
        }
        fun header(appId: String, version: String): HashMap<String, Any> {
            clearHMap()
            h["appId"] = appId
            h["version"] = version
            return h
        }

        //请求头集合 key通过“，”拼接 如果是String以外的数据类型 需要手动添加对应方法 或者进行转换
        fun header(key: String, vararg parameter: String): HashMap<String, Any> {
            clearHMap()
            val split = key.split(",")
            for (i in split.indices) {
                h[split[i]] = parameter[i]
            }
            return h
        }

        //参数集合 key通过“，”拼接 如果是String以外的数据类型 需要手动添加对应方法 或者进行转换
        fun parameter(key: String, vararg parameter: String): HashMap<String, Any> {
            clearPMap()
            val split = key.split(",")
            for (i in split.indices) {
                p[split[i]] = parameter[i]
            }
            return p
        }

        //清空参数集合
        private fun clearPMap() {
            if (p.size > 0) {
                p.clear()
            }
        }

        //清空请求头集合
        private fun clearHMap() {
            if (h.size > 0) {
                h.clear()
            }
        }
    }

    //数据返回回调方法
    interface CallBack<T> {
        fun onSuccess(bean: T)

        fun onError(error: String)
    }

    //返回数据是数组，回调方法
    interface ArrayCallBack {
        fun onSuccess(responseBody: String)

        fun onError(error: String)
    }

    //拦截器
    class LoggingInterceptor : Interceptor {
        companion object {
            private const val TAG = "LoggingInterceptor"
        }


        override fun intercept(chain: Interceptor.Chain): Response {
            //获取请求数据
            val request = chain.request()
            //1.请求前--打印请求信息
            val startTime = System.nanoTime()
            Log.d(
                TAG, String.format(
                    "Sending request %s on %s%n%s",
                    request.url(),
                    chain.connection(),
                    request.headers()
                )
            )
            //2.网络请求
            val response = chain.proceed(request)
            //3.网络响应后--打印响应信息
            val endTime = System.nanoTime()
            Log.d(
                TAG, String.format(
                    "Received response for %s in %.1fms%n%s",
                    response.request().url(),
                    (endTime - startTime) / 1e6,
                    response.headers()
                )
            )
            return response
        }
    }

}

调用方法

主方法

主要是网络解析添加参数，然后获取到请求回调的方法

//getInstance("") 中参数为请求的主路径
//后面方法中的url 为绝对路径
//例如http://www.goole.com/wp-login  主路径为www.goole.com/ 绝对路径为 wp-login
RetrofitUtils.getInstance("").doGet("",object :RetrofitUtils.CallBack<String>{
            override fun onSuccess(bean: String) {
                TODO("Not yet implemented")
            }

            override fun onError(error: String) {
                TODO("Not yet implemented")
            }
        })

拓展方法

设置请求参数

通过可变参数，可以实现多参数添加

 		val parameter = RetrofitUtils.GetParameter.parameter("1,2,3", "2", "3", "1")

        val parameter = RetrofitUtils.GetParameter.parameter()
        parameter["1"] = "1"

设置请求头

与请求参数相同，作为http请求的请求头设置到请求中

		val header = RetrofitUtils.GetParameter.header("1,2,3", "2", "3", "1")

        val header = RetrofitUtils.GetParameter.header()
        header["1"] = "1"
是寒霜啊
关注
  • 9
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Anko-Core：基于Kotlin + Anko +协程+ Retrofit2的演示，完全采用anko DSL布局，也可以作为Android快速开发框架，大量常用工具类，扩展函数
02-03
Anko-Core 为自己快速开发的框架，加入了许多项目通用的东西，免去重复造轮子，持续完善中... （抛弃了xml，采用anko dsl布局） 关于安科 优点 页面生成速度快，已经使用anko做过几个完整项目，性能肉眼可见的比xml快几倍 Anko 比xml更简单的屏幕适应 代码布局更好的利用kotlin的扩展函数 可以在编制布局时就加入逻辑判断 缺点 不能预览，Android Studio3.3以前可以下插件预览，不过开发工具我基本都更新到最新的稳定版了 学习成本较高，熟练后开发速度比xml重新，不熟的话很慢 （ps：停止维护不是因为不好，而是因为打算推compose） 我选择Anko的
MyCoreApp，AndroidMVP框架kotlin代码
10-22
Android 主体框架，网络请求rxjava2+retrofit2封装。网络变化监听。kotlin 代码。添加工具类。 1.更新第二版，lifecycle生命周期管理Rxjava内存泄漏问题 2.MainActivity主页面管理Fragment碎片状态。Fragment页面的显示隐藏。
kotlin MVVM组件化玩Android客户端
05-21
1、使用MVVM框架； 2、使用RxCache对数据进行缓存； 3、网络请求对Rxjava + AutoDispose + ReTrofit + RxCache + Dagger2等封装成一个组件； 4、将一些通用的界面封装到common_ui组件中； 5、各组件间的协调、通用工具类以及通用自定义view等定义在commonlib组件中； 6、各个module都可以单独运行。
KtBooster:otKotlin语言构建的Android开发便捷库或架构（使用kotlin作为依赖库或体系结构的android开发效率乘数）
03-06
:rocket: KtBooster :rocket: :rocket: Kotlin语言重构的Android开发便捷库或架构（使用kotlin作为依赖库或架构的android开发效率乘数） 一，项目简介 KtBooster是一个Android开发快速启动的项目依赖库框架，使用Kotlin语言结合Jetpack组件，提供项目开发常用的各类工具，组件和便捷库。 整个架构和API封装尚在进行中，并测试发布Jitpack.io仓库，用于依赖库内测距使用 二，框架结构与项目规划 项目结构初步以个人项目实践的积累实用性为基础，划分如下模块 通用工具类库的封装 ui相关控件库的封装 基础网络库的封装支持okhttp ， retrofit WebView库的封装，添加JsBridge ，支持x5内核 其他后续需要的模块 项目规划一步步先由个人常用工具库的整理，逐步扩展为快速开发App的通用库/框架，从而来完善设计模式和架构能力 三，
android_kotlin
05-09
explain kotlin+mvp+retrofit+Rx+gson+okhttp+utils //!!(这里代码太多就不说明，推荐下载下来看看~) utils AppBroadcastServe     网络链接状态服务广播 BaseClickListener   防连续点击按钮 greendao             数据库 LoadDialog           数据加载Loading DownloaderFile           单个文件下载 roundedimageview         自定义图片 utilcode                 大型工具类依赖 PyxCamera                相机、相册工具类 RefreshLayout            下拉刷新工具类 Toast              
Android Retrofit2和Kotlin结合上传文件
laomianhao的博客
12-18 3252
现在Retrofit2和RxJava2是很流行的框架，可能是我太闭塞的缘故，竟然没有用过这样的框架，请原谅我以前都是在用xUtils3今天就来说一下Retrofit2和Kotlin结合上传文件1、首先集成工具 （1）Kotlin就不用说了，Android Studio 3.0 以后自身就有 （2）Retrofit2集成 在项目文件build.gradle 里添加**dependencies
Android Kotlin学习（三）- Retrofit
wolf0706的专栏
02-27 255
Kotlin 的泛型也允许在定义类、接口、函数时使用泛型形参，这个泛型形参将在声明变量、创建对象、调用方法时动态地指定。从网上直接找了个MMKV封装的工具类。
Android kotlin 使用协程配合Retrofit进行网络请求
alcoholdi的专栏
12-22 3204
Project build.gradle apply from: "config.gradle" buildscript { ext.kotlin_version = '1.3.61' repositories { jcenter() google() } dependencies { classpath 'com.andro...
Android:玩转Retrofit+OkHttp+Kotlin协程 网络请求架构
小小小石头的专栏
01-13 8827
文章目录引言实战1、引入开源库2、简单封装3、开始使用 引言 目前做APP网络API请求Retrofit+OkHttp+Kotlin协程应该是比较流行的，相比之前Retrofit+RxJava 有了太多的优势，Rx可以做的事情，协程一样可以做，而且可以做到更方便，更简洁。还不会用协程的童鞋可以看下这篇[Kotlin:玩转协程],接下来我们进行网络请求框架的实战。 实战 1、引入开源库 在app m...
Android面试题——kotlin相关面试题
我的博客
10-26 4559
Jetpack 是一个丰富的组件库，它的组件库按类别分为 4 类1-架构（Architecture）LifecyclesLiveDataNavigationPagingRoomViewModel2- 界面（UI）EmojiFragmentLayoutPalette3-行为（behavior）SharingSlices4-基础（foundation）AppCompatMultidexTest。
MVVM+Retrofit+Kotlin网络框架封装
白玉梁的专栏
04-25 3529
上篇文章讲了MVVM入门，网络请求部分非常简单和原始，本篇则是上一篇的进阶，主要讲解如何在vm中使用协程结合Retrofit进行网络框架的封装。 Retrofit自不必说，非常优秀的网络请求框架，说到Retrofit就不得不提RxJava， RxJava是什么？ 官方定义：一个在jvm上使用可观测的序列来组成异步的,基于事件的程序的库，它具有良好的链式编程风格，以及强大的异步处理能力，在近几年的移...
Kotlin协程+Flow+Retrofit实现网络请求
Gary__123456的博客
09-27 5582
Kotlin协程+Flow+Retrofit实现网络请求导包代码实现 导包 implementation fileTree(dir: "libs", include: ["*.jar"]) implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlin_version" implementation 'androidx.core:core-ktx:1.6.0' implementation 'androidx.ap
安卓部署ffmpeg全平台so并实现命令行调用
codeofcc的博客
05-17 1061
前面的章节实现了ffmpeg全平台so的生成，接下来的步骤就是部署以及使用了，部署so还是比较简单的，用gradle和cmake都可以部署，部署好了就可以直接使用了，如果需要c++进行封装一层，则需要链接，对cmake熟悉的话链接也是比较简单的。以上就是今天讲述的内容，ffmpeg的so部署还是比较容易的，但是命令行的调用会麻烦一些，尤其是要解决ffmpeg退出问题，在c++中比较好解决，java理论上也比较好实现，如果在dart中则会比较麻烦，因为dart的方法通常不能跨线程调用，多线程的情况会出问题。
Android正向开发实现客户端证书认证
dafan0的博客
05-18 352
如果第三方模块被混淆，那hook方式均不能生效。这时就需要根据系统包去定位校验的函数，因此需要对安卓开发者是如何实现客户端证书校验的有一定了解，接下来就介绍这部分内容。开发者实现客户端证书校验的本质是：证书/密钥 + 代码。在形式上有：公钥校验、证书校验和Host（主机）校验。
Android 11 触摸小圆点显示流程
最新发布
littleyards的博客
05-21 310
当SHOW_TOUCHES 这个key的值有改变时，调用updateShowTouchesFromSettings方法，在updateShowTouchesFromSettings方法中，是调用nativeSetShowTouches这个native方法，直接来看下这个方法。小圆点的图片资源已经被加载，并将其保存在相应的变量中了，接下来就需要将其显示出来了。在开发者选项中，打开 “显示点按操作反馈” 开关，当我们在触摸屏幕时，会显示一个小圆点，来分析下小圆点的显示流程。
安卓手机APP开发__支持64位的架构
红孩儿编程大师
05-15 628
在谷歌的应用中发布的APP需要支持64位的架构。添加上你的APP的64位的版本， 提供了性能上的提升，并且能够运行在仅支持64位的硬件上。
NSSCTF中的1zjs、作业管理系统、finalrce、websign、简单包含、Http pro max plus、[鹤城杯 2021]EasyP
2401_82388450的博客
05-14 1081
1.php代码中要是有exec()函数，应该想到无回显的RCE2.遇到waf中的控制字符串长度，应该如何绕过3.了解到了http请求头中的其他参数，以及他们的作用。
Android SDK的安装和配置
Rverdoser的博客
05-17 176
Android SDK的安装和配置是开发Android应用的重要步骤，下面我为你详细介绍一下这个过程：安装Android SDK1. 打开官网：首先，你需要访问Android SDK的官方网站，找到SDK工具的下载链接。2. 下载SDK：在官网上，选择适合你操作系统的SDK版本进行下载。通常，你可以选择ZIP压缩包或EXE安装包，两者在实际使用上没有太大区别。3. 解压并存放：下载完成后，将SDK文件解压到你想要存放的目录。注意，存放路径最好不要包含中文或特殊字符4. 运行安装程序：如果你下载的是EXE安装
用kotlin写一个封装好的retrofit工具类
03-11
好的，我可以回答这个问题。对于使用 Kotlin 编写封装好的 Retrofit 工具类，可以参考以下步骤： 1. 首先，在项目中添加 Retrofit 和 OkHttp 的依赖。 2. 创建一个 RetrofitClient 类，用于初始化 Retrofit 实例，并提供相应的 API 接口。 3. 在 RetrofitClient 类中，可以定义一个单例模式，确保整个应用程序只有一个 Retrofit 实例。 4. 在 RetrofitClient 类中，可以定义一个 Retrofit.Builder 对象，用于配置 Retrofit 实例的各种参数，例如 BaseUrl、Converter、CallAdapter 等。 5. 在 RetrofitClient 类中，可以定义一个 ApiService 接口，用于定义各种 API 接口。 6. 在 ApiService 接口中，可以使用 Retrofit 的注解来定义各种 API 请求方法，例如 @GET、@POST、@Query、@Body 等。 7. 在 ApiService 接口中，可以使用 RxJava 或者 Coroutine 等异步框架来处理 API 请求结果。 8. 最后，在需要使用 API 接口的地方，可以通过 RetrofitClient.getInstance().create(ApiService.class) 来获取 ApiService 实例，从而调用各种 API 请求方法。 希望这些步骤能够帮助你编写出一个封装好的 Retrofit 工具类。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值