18034727885
2026-05-14 dad2ded3e9e9d2edf55c7ce10e791588b526961f
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
package com.example.smart.reqeust.interceptor
 
import android.text.TextUtils
import android.util.Log
import okhttp3.*
import okio.Buffer
import java.io.IOException
 
 
class LoggingInterceptor :Interceptor{
    private val tag = "DHLoggingInterceptor"
 
    @Throws(IOException::class)
    override fun intercept(chain: Interceptor.Chain): Response {
        val request = chain.request()
        logForRequest(request)
        val response = chain.proceed(request)
        return logForResponse(response)
    }
 
    private fun logForResponse(response: Response): Response {
        try {
            Log.e(tag, "========response'log=======")
            val builder = response.newBuilder()
            val clone = builder.build()
            Log.e(tag, "url : " + clone.request.url)
            Log.e(tag, "code : " + clone.code)
            Log.e(tag, "protocol : " + clone.protocol)
            if (!TextUtils.isEmpty(clone.message)) {
                Log.e(tag, "message : " + clone.message)
            }
            var body = clone.body
            if (body != null) {
                val mediaType = body.contentType()
                if (mediaType != null) {
                    Log.e(tag, "responseBody's contentType : $mediaType")
                    if (isText(mediaType)) {
                        val resp = body.string()
 
                        Log.e(tag, "responseBody's content : $resp")
                        body = ResponseBody.create(mediaType, resp)
                        return response.newBuilder().body(body).build()
                    } else {
                        Log.e(
                            tag,
                            "responseBody's content : " + " maybe [file part] , too large too print , ignored!"
                        )
                    }
                }
            }
            Log.e(tag, "========response'log=======end")
        } catch (e: Exception) {
            Log.e(tag, "e.printStackTrace();")
        }
        return response
    }
 
    private fun logForRequest(request: Request) {
        try {
            val url = request.url.toString()
            val headers = request.headers
            Log.e(tag, "========request'log=======")
            Log.e(tag, "method : " + request.method)
            Log.e(tag, "url : $url")
            if (headers.size > 0) {
                Log.e(tag, "headers size: " + headers.size)
                Log.e(tag, "headers : $headers")
            }
            val requestBody = request.body
            if (requestBody != null) {
                val mediaType = requestBody.contentType()
                if (mediaType != null) {
                    Log.e(
                        tag,
                        "requestBody's contentType : $mediaType"
                    )
                    if (isText(mediaType)) {
                        Log.e(
                            tag,
                            "requestBody's content : " + bodyToString(request)
                        )
                    } else {
                        Log.e(
                            tag,
                            "requestBody's content : " + " maybe [file part] , too large too print , ignored!"
                        )
                    }
                }
            }
            Log.e(tag, "========request'log=======end")
        } catch (e: Exception) {
            Log.e(tag, "e.printStackTrace();")
        }
    }
 
    private fun isText(mediaType: MediaType): Boolean {
        if (mediaType.type == "text") {
            return true
        }
        if (mediaType.subtype == "json" || mediaType.subtype == "xml" || mediaType.subtype == "html" || mediaType.subtype == "webviewhtml") return true
        return false
    }
 
    private fun bodyToString(request: Request): String {
        return try {
            val copy = request.newBuilder().build()
            val buffer = Buffer()
            copy.body!!.writeTo(buffer)
            buffer.readUtf8()
        } catch (e: IOException) {
            "something error when show requestBody."
        }
    }
}