The vernacular
- We definitely needed a unified wrapper around things like POST and GET, so we defined one
A unified interface class for network requests–HttpApi - Since post and GET have requests, there must be a callback for success and failure of the request, so we need to define this
IHttpCallbackThis is needed in HttpApi - Now that We’ve defined HttpApi, we also need a concrete class named, for example, HttpApi
OkHttpApiAnd all future requests, OkHttpApiThe get and POST methods, which are copied inside, need to do something specific. Of course, we can’t avoid building a Client instance, where we can configure many parameters, such as timeout, such as interceptor, such as Cookie
In plain English, that’s what it means.
(This example is not Retrofit yet, a better practice would be Retrofit plus Jetpack, I’ll write one later)
In the code
- HttpApi
package com.am.kttt
import com.am.kttt.support.IHttpCallback
/** * Unified interface class for network requests */
interface HttpApi {
/** * Abstract HTTP get request encapsulation, asynchronous */
fun get(params: Map<String, Any>, urlStr: String, callback: IHttpCallback)
/** * Abstract HTTP synchronous GET request */
fun getSync(params: Map<String, Any>, urlStr: String): Any? {
return Any()
}
/** * Abstract HTTP post request asynchronous */
fun post(body: Any, urlStr: String, callback: IHttpCallback)
/** * Abstract Http POST synchronization request */
fun postSync(body: Any, urlStr: String): Any? = Any()
fun cancelRequest(tag: Any)
fun cancelAllRequest(a)
}
Copy the code.
- OkHttpApi
package com.am.kttt
import androidx.collection.SimpleArrayMap
import com.google.gson.Gson
import okhttp3.*
import okhttp3.HttpUrl.Companion.toHttpUrl
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.RequestBody.Companion.toRequestBody
import com.am.kttt.config.HeaderInterceptor
import com.am.kttt.config.KtHttpLogInterceptor
import com.am.kttt.config.LocalCookieJar
import com.am.kttt.config.RetryInterceptor
import com.am.kttt.support.IHttpCallback
import java.io.File
import java.io.IOException
import java.util.concurrent.TimeUnit
/** * OkHttpApi core class * implement get and POST operations * build Client, add specific configuration; Interceptors, cookies, etc. */
class OkHttpApi : HttpApi {
var maxRetry = 0// Maximum number of retries
// Store the request for cancellation
private val callMap = SimpleArrayMap<Any, Call>()
//okHttpClient
private val mClient = OkHttpClient.Builder()
.callTimeout(10, TimeUnit.SECONDS)// Complete request timeout duration, from the time the request is initiated to the time the return data is received, default value 0, unlimited,
.connectTimeout(10, TimeUnit.SECONDS)// Duration of establishing a connection with the server. The default value is 10 seconds
.readTimeout(10, TimeUnit.SECONDS)// How long it takes to read the data returned by the server
.writeTimeout(10, TimeUnit.SECONDS)// Duration of writing data to the server. The default value is 10 seconds
.retryOnConnectionFailure(true)/ / reconnection
.followRedirects(false)/ / redirection
.cache(Cache(File("sdcard/cache"."okhttp"), 1024))
// .cookieJar(CookieJar.NO_COOKIES)
.cookieJar(LocalCookieJar())
.addNetworkInterceptor(HeaderInterceptor())// Public header interceptor
.addNetworkInterceptor(KtHttpLogInterceptor {
logLevel(KtHttpLogInterceptor.LogLevel.BODY)
})// Add a network interceptor that intercepts okHttp network requests. Unlike the application interceptor, this interceptor is aware of all network states, such as redirects.
.addNetworkInterceptor(RetryInterceptor(maxRetry))
// .hostnameVerifier(HostnameVerifier { p0, p1 -> true })
// .sslSocketFactory(sslSocketFactory = null,trustManager = null)
.build()
override fun get(params: Map<String, Any>, urlStr: String, callback: IHttpCallback) {
val urlBuilder = urlStr.toHttpUrl().newBuilder()
params.forEach { entry ->
urlBuilder.addEncodedQueryParameter(entry.key, entry.value.toString())
}
val request = Request.Builder()
.get()
.tag(params)
.url(urlBuilder.build())
.cacheControl(CacheControl.FORCE_NETWORK)
.build()
val newCall = mClient.newCall(request)
// Store the request for cancellation
callMap.put(request.tag(), newCall)
newCall.enqueue(object : Callback {
override fun onFailure(call: Call, e: IOException) {
callback.onFailed(e.message)
}
override fun onResponse(call: Call, response: Response){ callback.onSuccess(response.body? .string()) } }) }override fun post(body: Any, urlStr: String, callback: IHttpCallback) {
val reqBody = Gson().toJson(body).toRequestBody("application/json".toMediaType())
val request = Request.Builder()
.post(reqBody)
.url(urlStr)
.tag(body)
.build()
val newCall = mClient.newCall(request)
// Store the request for cancellation
callMap.put(request.tag(), newCall)
newCall.enqueue(object : Callback {
override fun onFailure(call: Call, e: IOException) {
callback.onFailed(e.message)
}
override fun onResponse(call: Call, response: Response){ callback.onSuccess(response.body? .string()) } }) }/** * cancel the network request. Tag is the id of each request
override fun cancelRequest(tag: Any) {
callMap.get(tag)? .cancel() }/** * Cancel all network requests */
override fun cancelAllRequest(a) {
for (i in 0 until callMap.size()) {
callMap.get(callMap.keyAt(i))? .cancel() } } }Copy the code.
- MainActivity
package com.am.kttt
import android.os.Bundle
import android.view.View
import androidx.appcompat.app.AppCompatActivity
import com.am.kttt.databinding.ActivityMainBinding
import com.blankj.utilcode.util.GsonUtils
import com.blankj.utilcode.util.LogUtils
//import kotlinx.android.synthetic.main.activity_main.*
import com.am.kttt.model.NetResponse
import com.am.kttt.support.NetTranUtils
import com.am.kttt.support.IHttpCallback
class MainActivity : AppCompatActivity() {
private lateinit var binding: ActivityMainBinding
val httpApi: HttpApi = OkHttpApi()
override fun onCreate(savedInstanceState: Bundle?). {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
binding = ActivityMainBinding.inflate(layoutInflater)
setContentView(binding.root)
binding.btGet.setOnClickListener(View.OnClickListener {
httpApi.get(
emptyMap(),
"https://wanandroid.com/wxarticle/chapters/json".object : IHttpCallback {
override fun onSuccess(data: Any?). {
LogUtils.d("success result : ${data.toString()}")
runOnUiThread {
binding.tvText.text = data.toString()
}
}
override fun onFailed(error: Any?). {
LogUtils.d("failed msg : ${error.toString()}")
}
})
})
binding.btPost.setOnClickListener(View.OnClickListener {
val mapParams = mapOf("username" to "123456" ,"username" to "password" ,"repassword" to "123456" )
httpApi.post(
mapParams,
"https://www.wanandroid.com/user/register".object : IHttpCallback {
override fun onSuccess(data: Any?). {
LogUtils.d("success result : ${data.toString()}")
runOnUiThread {
val toString = data.toString()
binding.tvText.text = toString
/*val (code, dataObj, message) = GsonUtils.fromJson
( toString, NetResponse::class.java ) if(dataObj! DecodeData (dataobj.toString ()?:"")}else{binding.tvtext.text = "empty data"}*/
}}override fun onFailed(error: Any?). {
LogUtils.d("failed msg : ${error.toString()}")
binding.tvText.text = "${error.toString()}"}})})}}Copy the code.
xml
<androidx.constraintlayout.widget.ConstraintLayout
xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
xmlns:app="http://schemas.android.com/apk/res-auto"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context=".MainActivity">
<LinearLayout
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
android:gravity="center_horizontal"
>
<androidx.appcompat.widget.AppCompatButton
android:id="@+id/bt_get"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="To launch the get"
android:layout_marginTop="10dp"
/>
<androidx.appcompat.widget.AppCompatButton
android:id="@+id/bt_post"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="By Post"
android:layout_marginTop="10dp"
android:layout_marginBottom="10dp"
/>
<TextView
android:id="@+id/tv_text"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Hello World!"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintLeft_toLeftOf="parent"
app:layout_constraintRight_toRightOf="parent"
app:layout_constraintTop_toTopOf="parent" />
</LinearLayout>
</androidx.constraintlayout.widget.ConstraintLayout>
Copy the code.
- HeaderInterceptor
package com.am.kttt.config
import com.blankj.utilcode.util.*
import com.google.gson.GsonBuilder
import com.google.gson.reflect.TypeToken
import okhttp3.CacheControl
import okhttp3.FormBody
import okhttp3.Interceptor
import okhttp3.Response
import okio.Buffer
/** * Project specific, add public header interceptor */
class HeaderInterceptor : Interceptor {
companion object {
private val gson = GsonBuilder()
.enableComplexMapKeySerialization()
.create()
private val mapType = object : TypeToken<Map<String, Any>>() {}.type
}
override fun intercept(chain: Interceptor.Chain): Response {
val originRequest = chain.request()
// Additional public headers, encapsulation clientInfo,deviceInfo, etc. You can also customize the headers field in a POST request
// Note that only the following fields can be used by the server for verification. The fields can be missing, but cannot be added because the server has not processed them
val attachHeaders = mutableListOf<Pair<String, String>>(
"appid" to NET_CONFIG_APPID,
"platform" to "android".The yAPI platform tag does not
"timestamp" to System.currentTimeMillis().toString(),
"brand" to DeviceUtils.getManufacturer(),
"model" to DeviceUtils.getModel(),
"uuid" to DeviceUtils.getUniqueDeviceId(),
"network" to NetworkUtils.getNetworkType().name,
"system" to DeviceUtils.getSDKVersionName(),
"version" to AppUtils.getAppVersionName()
)
// Tokens are passed only if they have a value,
val tokenstr = ""
val localToken = SPStaticUtils.getString(SP_KEY_USER_TOKEN, tokenstr)
if (localToken.isNotEmpty()) {
attachHeaders.add("token" to localToken)
}
val signHeaders = mutableListOf<Pair<String, String>>()
signHeaders.addAll(attachHeaders)
// Get request parameters
if (originRequest.method == "GET") { originRequest.url.queryParameterNames.forEach { key -> signHeaders.add(key to (originRequest.url.queryParameter(key) ? :""))}}// Post requests in formBody form, or json form, need to iterate through the internal fields to participate in the calculation of sign
val requestBody = originRequest.body
if (originRequest.method == "POST") {
//formBody
if (requestBody is FormBody) {
for (i in 0 until requestBody.size) {
signHeaders.add(requestBody.name(i) to requestBody.value(i))
}
}
// Json body needs to deserialize the requestBody into JSON to map Application /json
if(requestBody? .contentType()? .type =="application"&& requestBody.contentType()? .subtype =="json") {
kotlin.runCatching {
val buffer = Buffer()
requestBody.writeTo(buffer)
buffer.readByteString().utf8()
}.onSuccess {
val map = gson.fromJson<Map<String, Any>>(it, mapType)
map.forEach { entry ->
// FIXME:2020/8/25 value Current JSON layer level
signHeaders.add(entry.key to entry.value.toString())
}
}
}
}
// Todo algorithm: all must be non-null arguments!! Sign = MD5 (headers and params key=value &, appkey =value)
val signValue = signHeaders
.sortedBy { it.first }
.joinToString("&") { "${it.first}=${it.second}" }
.plus("&appkey=$NET_CONFIG_APPKEY")
val newBuilder = originRequest.newBuilder()
.cacheControl(CacheControl.FORCE_NETWORK)
attachHeaders.forEach { newBuilder.header(it.first, it.second) }
newBuilder.header("sign", EncryptUtils.encryptMD5ToString(signValue))
if (originRequest.method == "POST"&& requestBody ! =null) {
newBuilder.post(requestBody)
} else if (originRequest.method == "GET") {
newBuilder.get()}return chain.proceed(newBuilder.build())
}
}
Copy the code.
- KtHttpLogInterceptor
package com.am.kttt.config
import android.util.Log
import okhttp3.*
import okio.Buffer
import com.am.kttt.support.NetTranUtils
import java.net.URLDecoder
import java.text.SimpleDateFormat
import java.util.*
/** * An interceptor for logging okHttp web logs */
class KtHttpLogInterceptor(block: (KtHttpLogInterceptor.() -> Unit)? = null) : Interceptor {
private var logLevel: LogLevel = LogLevel.NONE// Prints the date mark
private var colorLevel: ColorLevel = ColorLevel.DEBUG// The default is debug logcat
private var logTag = TAG// The Logcat Tag of the log
init{ block? .invoke(this)}/** * Set LogLevel */
fun logLevel(level: LogLevel): KtHttpLogInterceptor {
logLevel = level
return this
}
/** * Set colorLevel */
fun colorLevel(level: ColorLevel): KtHttpLogInterceptor {
colorLevel = level
return this
}
/** * sets the Log Tag */
fun logTag(tag: String): KtHttpLogInterceptor {
logTag = tag
return this
}
override fun intercept(chain: Interceptor.Chain): Response {
/ / request
val request = chain.request()
/ / response
return kotlin.runCatching { chain.proceed(request) }
.onFailure {
it.printStackTrace()
logIt(
it.message.toString(),
ColorLevel.ERROR
)
}.onSuccess { response ->
if (logLevel == LogLevel.NONE) {
return response
}
// Log the request
logRequest(request, chain.connection())
// Record the response log
logResponse(response)
}.getOrThrow()
}
/** * log the request */
private fun logRequest(request: Request, connection: Connection?). {
val sb = StringBuilder()
sb.appendln("\r\n")
sb.appendln("- > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - >")
when (logLevel) {
LogLevel.NONE -> {
/*do nothing*/
}
LogLevel.BASIC -> {
logBasicReq(sb, request, connection)
}
LogLevel.HEADERS -> {
logHeadersReq(sb, request, connection)
}
LogLevel.BODY -> {
logBodyReq(sb, request, connection)
}
}
sb.appendln("- > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - >")
logIt(sb)
}
//region log request
private fun logBodyReq(
sb: StringBuilder,
request: Request,
connection: Connection?). {
logHeadersReq(sb, request, connection)
// Read the contents of the request Body
val req = request.newBuilder().build()
valsink = Buffer() req.body? .writeTo(sink) sb.appendln("RequestBody: ${sink.readUtf8()}")}private fun logHeadersReq(
sb: StringBuilder,
request: Request,
connection: Connection?). {
logBasicReq(sb, request, connection)
val headersStr = request.headers.joinToString("") { header ->
"Request Header: {${header.first}=${header.second}}\n"
}
sb.appendln(headersStr)
}
private fun logBasicReq(
sb: StringBuilder,
request: Request,
connection: Connection?). {
sb.appendln("The request method:${request.method} url: ${decodeUrlStr(request.url.toString())} tag: ${request.tag()} protocol: ${connection? .protocol() ? : Protocol.HTTP_1_1}")}//endregion
/** * Record the response log * [response] Response data */
private fun logResponse(response: Response) {
val sb = StringBuffer()
sb.appendln("\r\n")
sb.appendln("< < < < < < - < < - < < < < < < - < < - < < < < < < - < < - < < < < - < < < < < < - < < - < < < < < < - < < - < < - < < < < - < < < < - < <")
when (logLevel) {
LogLevel.NONE -> {
/*do nothing*/
}
LogLevel.BASIC -> {
logBasicRsp(sb, response)
}
LogLevel.HEADERS -> {
logHeadersRsp(response, sb)
}
LogLevel.BODY -> {
logHeadersRsp(response, sb)
//body.string throws AN I/O exception
kotlin.runCatching {
// Peek is similar to clone stream data, monitoring, snooping, can not directly use the original body stream data as a log, will consume IO, so this is peek, monitoring
val peekBody = response.peekBody(1024 * 1024)
sb.appendln(NetTranUtils.unicodeDecode(peekBody.string()))
}.getOrNull()
}
}
sb.appendln("< < < < < < - < < - < < < < < < - < < - < < < < < < - < < - < < < < < < - < < - < < < < < < - < < - < < < < < < - < < - < < < < < < - < < - < < < < < < - < < - < < < < - < < < < - < < - < < < < - < < -- < < < < < < - < < < < - < < < < - < <")
logIt(sb, ColorLevel.INFO)
}
//region log response
private fun logHeadersRsp(response: Response, sb: StringBuffer) {
logBasicRsp(sb, response)
val headersStr = response.headers.joinToString(separator = "") { header ->
"Response Header: {${header.first}=${header.second}}\n"
}
sb.appendln(headersStr)
}
private fun logBasicRsp(sb: StringBuffer, response: Response) {
sb.appendln("The response protocol:${response.protocol} code: ${response.code} message: ${response.message}")
.appendln("Response request Url:${decodeUrlStr(response.request.url.toString())}")
.appendln(
"Response sentRequestTime:${ toDateTimeStr( response.sentRequestAtMillis, MILLIS_PATTERN ) } receivedResponseTime: ${ toDateTimeStr( response.receivedResponseAtMillis, MILLIS_PATTERN ) }")}//endregion
/** * For urL-encoded string decoding */
private fun decodeUrlStr(url: String): String? {
return kotlin.runCatching {
URLDecoder.decode(url, "utf-8")
}.onFailure { it.printStackTrace() }.getOrNull()
}
/** * Print logs * [any] Data object to print * [tempLevel] for temporary adjustment of print color level */
private fun logIt(any: Any, tempLevel: ColorLevel? = null) {
when(tempLevel ? : colorLevel) { ColorLevel.VERBOSE -> Log.v(logTag, any.toString()) ColorLevel.DEBUG -> Log.d(logTag, any.toString()) ColorLevel.INFO -> Log.i(logTag, any.toString()) ColorLevel.WARN -> Log.w(logTag, any.toString()) ColorLevel.ERROR -> Log.e(logTag, any.toString()) } }companion object {
private const val TAG = "<KtHttp>"// The default TAG
// Time formatting
const val MILLIS_PATTERN = "yyyy-MM-dd HH:mm:ss.SSSXXX"
// Converts to a formatted time string
fun toDateTimeStr(millis: Long, pattern: String): String {
return SimpleDateFormat(pattern, Locale.getDefault()).format(millis)
}
}
/** * The range of logs to be printed */
enum class LogLevel {
NONE,/ / not print at all
BASIC,// Paper prints the beginning of the line, request/response
HEADERS,// Prints all headers for the request and response
BODY,// Print all
}
/** ** Logcat is divided into V, D, I, W, e */
enum class ColorLevel {
VERBOSE,
DEBUG,
INFO,
WARN,
ERROR
}
}
Copy the code.
- LocalCookieJar
package com.am.kttt.config
import okhttp3.Cookie
import okhttp3.CookieJar
import okhttp3.HttpUrl
/** * cookieJar implementation class for persistence */
internal class LocalCookieJar : CookieJar {
// Local storage of cookies
private val cache = mutableListOf<Cookie>()
override fun loadForRequest(url: HttpUrl): List<Cookie> {
// An expired Cookie
val invalidCookies: MutableList<Cookie> = ArrayList()
// A valid Cookie
val validCookies: MutableList<Cookie> = ArrayList()
for (cookie in cache) {
if (cookie.expiresAt < System.currentTimeMillis()) {
// Determine whether it expires
invalidCookies.add(cookie)
} else if (cookie.matches(url)) {
// Match Cookie to URL
validCookies.add(cookie)
}
}
// Remove expired cookies from the cache
cache.removeAll(invalidCookies)
// Return List
for Request to set
return validCookies
}
/** * Save the cookie */
override fun saveFromResponse(url: HttpUrl, cookies: List<Cookie>) {
cache.addAll(cookies)
}
}
Copy the code.
- NetPjConfig.kt
package com.am.kttt.config
/** * App configuration */
// Region network interaction configuration parameters
const val NET_CONFIG_APPID = "xxxxxx"// appID marks the project APK
const val NET_CONFIG_APPKEY = "xxxxxxH\$pHx\$!"// AppKey is used to parse encrypted data returned by the server
//endregion
//region Data field key of the local cache
const val SP_KEY_USER_TOKEN = "sp_key_user_token"// Indicates the user's token
//endregion
Copy the code.
- RetryInterceptor
package com.am.kttt.config
import android.util.Log
import okhttp3.Interceptor
import okhttp3.Request
import okhttp3.Response
/** * Retries the request's network interceptor */
class RetryInterceptor(private val maxRetry: Int = 0) : Interceptor {
private var retriedNum: Int = 0// The number of retry times, so the total number of requests may be the original 1 + maxRetry
override fun intercept(chain: Interceptor.Chain): Response {
val request: Request = chain.request()
Log.d("RetryInterceptor"."Intercept Line 29: Current retriedNum=$retriedNum")
var response = chain.proceed(request)
while(! response.isSuccessful && retriedNum < maxRetry) { retriedNum++ Log.d("RetryInterceptor"."Intercept line 33: Current retriedNum=$retriedNum")
response = chain.proceed(request)
}
return response
}
}
Copy the code.
- NetResponse
package com.am.kttt.model
/** * The underlying network returns a data structure */
data class NetResponse(
val code: Int./ / the response code
val data: Any? .// Response data content
val message: String// The result description of the response data
)
Copy the code.
- IHttpCallback
package com.am.kttt.support
/** * Network request interface callback */
interface IHttpCallback {
/** * Network request successful callback * [data] returns the data result of the callback *@paramData returns the result of the callback */
fun onSuccess(data: Any?).
/** * Interface callback failed * [error] Data class of the error message */
fun onFailed(error: Any?).
}
Copy the code.
- NetTranUtils
package com.am.kttt.support;
import androidx.annotation.Nullable;
import com.blankj.utilcode.util.EncryptUtils;
import com.am.kttt.config.NetPjConfigKt;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/** * Network conversion tools * Chinese to Unicode, Unicode to Chinese * encryption and decryption */
public class NetTranUtils {
private NetTranUtils() {
}
/** * To unicode **@param string
* @return* /
public static String unicodeEncode(String string) {
char[] utfBytes = string.toCharArray();
String unicodeBytes = "";
for (int i = 0; i < utfBytes.length; i++) {
String hexB = Integer.toHexString(utfBytes[i]);
if (hexB.length() <= 2) {
hexB = "00" + hexB;
}
unicodeBytes = unicodeBytes + "\\u" + hexB;
}
return unicodeBytes;
}
/** * Unicode to Chinese **@param string
* @return* /
public static String unicodeDecode(String string) {
Pattern pattern = Pattern.compile("(\\\\u(\\p{XDigit}{4}))");
Matcher matcher = pattern.matcher(string);
char ch;
while (matcher.find()) {
ch = (char) Integer.parseInt(matcher.group(2), 16);
// Integer.valueOf("", 16);
string = string.replace(matcher.group(1), ch + "");
}
return string;
}
/** * Parse the returned data **@paramDataStr Undecrypted response data *@returnDecrypted data String */
@Nullable
public static String decodeData(@Nullable String dataStr) {
// Java code, no automatic null judgment, need to handle their own
if(dataStr ! =null) {
System.out.println("DataStr = = = = = = = = :"+dataStr);
return new String(EncryptUtils.decryptBase64AES(
dataStr.getBytes(), NetPjConfigKt.NET_CONFIG_APPKEY.getBytes(),
"AES/CBC/PKCS7Padding"."J#y9sJesv*5HmqLq".getBytes()
));
} else {
return null; }}}Copy the code.
The code is all up there
- Under the APP build. Gradle
plugins {
id 'com.android.application'
id 'kotlin-android'
}
android {
compileSdk 31
defaultConfig {
applicationId "com.am.kttt"
minSdk 21
targetSdk 31
versionCode 1
versionName "1.0"
testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
}
buildTypes {
release {
minifyEnabled false
proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
}
}
compileOptions {
sourceCompatibility JavaVersion.VERSION_1_8
targetCompatibility JavaVersion.VERSION_1_8
}
kotlinOptions {
jvmTarget = '1.8'
}
buildFeatures {
viewBinding true}}dependencies {
implementation 'androidx. Core: the core - KTX: 1.7.0'
implementation 'androidx. Appcompat: appcompat: 1.4.1'
implementation 'com. Google. Android. Material: material: 1.5.0'
implementation 'androidx. Constraintlayout: constraintlayout: 2.1.3'
implementation 'androidx. Lifecycle: lifecycle - livedata - KTX: against 2.4.1'
implementation 'androidx. Lifecycle: lifecycle - viewmodel - KTX: against 2.4.1'
implementation 'androidx. Navigation: navigation - fragments - KTX: against 2.4.1'
implementation 'androidx. Navigation: navigation - UI - KTX: against 2.4.1'
testImplementation 'junit:junit:4.+'
androidTestImplementation 'androidx. Test. Ext: junit: 1.1.3'
androidTestImplementation 'androidx. Test. Espresso: espresso - core: 3.4.0'
// Required for this project
implementation("Com. Squareup. Okhttp3: okhttp: 4.8.0")
implementation("Com. Squareup. Okhttp3: logging - interceptor: 4.8.0")
implementation("Com. Google. Code. Gson: gson: 2.8.6")
implementation 'com. Blankj: utilcodex: 1.29.0'
implementation "Androidx. Constraintlayout: constraintlayout: 2.1.0."
}
Copy the code.
- Build. Gradle under the project
// Top-level build file where you can add configuration options common to all sub-projects/modules.
buildscript {
repositories {
google()
mavenCentral()
}
dependencies {
classpath "Com. Android. Tools. Build: gradle: 7.0.1"
classpath "Org. Jetbrains. Kotlin: kotlin - gradle - plugin: 1.5.20"
// NOTE: Do not place your application dependencies here; they belong
// in the individual module build.gradle files}}task clean(type: Delete) {
delete rootProject.buildDir
}
Copy the code.
Running effect
A post
Don’t worry about what’s displayed, the interface is just random, and then this returns data that looks a lot like GET.
Initiate the get
It’s a random interface. .
Pan.baidu.com/s/1NiqjMmAn…