【Android Kotlin】OkHttp3でコピペ可能なAPI通信処理実装

dependencies {
    implementation 'com.squareup.okhttp3:okhttp:4.10.0'
}

/*
 * リクエストクラスのインターフェース
 * リクエストパラメータクラスはこのインターフェースを継承する
 */
interface RequestInterface {
    // GETパラメータ用のJSON
    fun getRequestJson() : String
    // GET以外のパラメータ用Map
    fun getParams() : Map<String, Any?>? = null
    // APIセグメントEnum
    fun getEnum() : ApiSegmentEnum
}

// ログインAPIで送信するデータクラス
// RequestInterfaceを継承しており、必須の関数を3つ実装しなければなりません。

class LoginRequest constructor(
    _login_id : String,
    _password : String,
) : RequestInterface {
    private val loginId : String
    private val password : String
    init {
        loginId = _login_id
        password = _password
    }
    // ApiSegment
    // ここに対応するEnumを定数で入れておきます。
    private val mEnum = ApiSegmentEnum.LOGIN

    // getter
    private fun getLoginId() : String {
        return this.loginId
    }
    private fun getPassword() : String {
        return this.password
    }

    override fun getEnum(): ApiSegmentEnum {
        return this.mEnum
    }

    // request用Json
    override fun getRequestJson(): String {
        // 各データをMapに変換
        val data = mutableMapOf<String, Any>(
            Pair("login_id", loginId),
            Pair("password", password),
        )
        return JSONObject(data as Map<String, Any>).toString()
    }

    // request用Map
    override fun getParams(): Map<String, Any?> {
        val params : MutableMap<String, Any?> = mutableMapOf()
        params["login_id"] = loginId
        params["password"] = password
        return params
    }


}

import com.example.kotlintemplete.ApiTemplete.ApiSegmentEnum

// Api別にレスポンスデータをレスポンスクラスに変換するクラス
class ResponseConversion constructor(
    _responseMap : Map<*, *>?,
    _api_enum : ApiSegmentEnum
) {
    private val responseMap : Map<*, *>?
    private val apiEnum : ApiSegmentEnum
    init {
        responseMap = _responseMap
        apiEnum = _api_enum
    }

    // レスポンスクラス変換
    fun convertResponse() : Any {
        // レスポンスが空なら""で返却
        if (responseMap == null) {
            return ""
        }
        // 返却するデータを格納する
        val responseData : Any
        // ApiSegmentEnumによって格納するクラスを分岐させる
        when (apiEnum) {
            ApiSegmentEnum.LOGIN -> {
                // responseMap[xxx]のxxxはレスポンスdata内のKey名です。
                responseData =
                    LoginResponse(
                        responseMap["login_id"] as String,
                        responseMap["password"] as String,
                    )
            }
            // ApiSegmentEnum.USER -> {} のようにAPIを追加する毎に下に分岐を追加していきます。
            else -> return ""
        }
        return responseData
    }
}

/*
 * ログインAPIで取得するレスポンスのデータクラス
 * Activity, Fragment間でデータを受け渡せるようにParcelableを継承します。
 */
data class LoginResponse constructor(
    var token : String? = "",
    var userName : String? = ""
) : Parcelable {

    constructor(parcel: Parcel) : this() {
        token = parcel.readString()
        userName = parcel.readString()
    }

    override fun writeToParcel(parcel: Parcel, p1: Int) {
        parcel.let {
            it.writeString(token)
            it.writeString(userName)
        }
    }

    override fun describeContents(): Int {
        return 0
    }

    companion object CREATOR : Parcelable.Creator<LoginResponse> {
        override fun createFromParcel(parcel: Parcel): LoginResponse {
            return LoginResponse(parcel)
        }

        override fun newArray(size: Int): Array<LoginResponse?> {
            return arrayOfNulls(size)
        }
    }
}

/*
 * APIのセグメント一覧
 *  - segment ・・・ apiのアクセス先を格納。hostURL後のurl
 *  - method  ・・・ GET, POSTなどのAPIメソッド
 */
enum class ApiSegmentEnum (val segment: String, val method: String) {
    LOGIN("api/user/login", "POST"),
    USER("api/user", "GET"),
}

/* OkHttp3を利用したHttp通信処理クラス
 * - RequestInterface ・・・ リクエストクラス群のInterface
 * - AppCompatActivity・・・ API通信を実行するActivity
 */
class OkHttpConnection (
    _request: RequestInterface,
    _parentActivity: AppCompatActivity
        ) {
    // リクエスト情報クラス
    private val request: RequestInterface
    // API種別 (リクエストクラス内に存在)
    private val apiSegment: ApiSegmentEnum
    // リクエスト(JSON)(リクエストクラス内に存在)
    private val requestJson: String
    // リクエストパラメータ (リクエストクラス内に存在)
    private val requestParams : Map<String, Any?>?
    // 親Activity
    private val activity : AppCompatActivity

    init {
        request = _request
        apiSegment = request.getEnum()
        requestJson = request.getRequestJson()
        requestParams = request.getParams()
        activity = _parentActivity
    }

    // HTTPリクエストやレスポンスボディのコンテンツタイプ
    private val JSON_MEDIA = "application/json; charset=utf-8".toMediaType()
    // APIのHostURL
    private val apiHostUrl = "apiHostUrl.com"
    // OkHttpのクライアント
    private val client = OkHttpClient.Builder().build()

    /*
     * Http通信を実行
     *  - isShowProgress ・・・ Http通信中にプログレスダイアログ(ぐるぐる)を表示するか
     */
    suspend fun startRequest(isShowProgress: Boolean = true) : Any? {

        // プログレスダイアログクラス
        val progressDialog = ProgressDialog()
        // プログレスダイアログを表示
        if (isShowProgress) {
            progressDialog.show(activity.supportFragmentManager, "progress")
        }
        // HttpリクエストのBuilder
        val builder: Request.Builder = Request.Builder()
        // リクエストボディ
        val requestBody = requestJson.toRequestBody(JSON_MEDIA)
        // レスポンス格納用
        val responseData: Any? = null;

        // sharedPreferenceから保存済みのアクセストークンを取得する。
        val sharedPref = activity.getSharedPreferences("mySharedPref(保存名)", Context.MODE_PRIVATE)
        val token = sharedPref.getString("トークンの保存名", "") as String

        // Request Headerを作成
        /*
         * ヘッダーにトークンを挿入 (Bearer形式 任意で変更してください。)
         * ログインAPIの場合はスルーする (トークン未取得のため)
         */
        if (token != "" && apiSegment != ApiSegmentEnum.LOGIN) {
            builder.addHeader("Authorization", "Bearer $token")
        } else if (token == "" && apiSegment != ApiSegmentEnum.LOGIN) {
            // プログレスダイアログを消す
            if (isShowProgress) {
                progressDialog.dismiss()
            }
            // ここにtoken未取得時のエラー処理を記載
            return null
        }

        // Requestを作成
        val apiRequest: Request
        when (apiSegment.method) {
            "GET" -> {
                apiRequest = builder
                    .url(makeHttpUrl())
                    .get()
                    .build()
            }
            "POST" -> {
                apiRequest = builder
                    .url(makeHttpUrl())
                    .post(requestBody)
                    .build()
            }
            "PUT" -> {
                apiRequest = builder
                    .url(makeHttpUrl())
                    .put(requestBody)
                    .build()
            }
            else -> { // DELETE
                apiRequest = builder
                    .url(makeHttpUrl())
                    .delete(requestBody)
                    .build()
            }
        }
        try {
            return suspendCoroutine { continuation ->
                client.newCall(apiRequest).enqueue(object : Callback {
                    // API正常
                    override fun onResponse(call: Call, response: Response) {
                        try {
                            /*
                         * レスポンスボディを取得
                         * レスポンスは
                         * header {errorCode:String, errorMessage: String}, data {...}
                         * の形式を想定しています。必要に応じて変更してください。
                         */
                            val responseBody = response.body?.string().orEmpty()
                            val jsonObj = JSONObject(responseBody)
                            val map = jsonObj.toMap()
                            // data, headerを抽出
                            var mapData = map["data"]
                            val mapError = map["header"] as Map<*, *>

                            // dataが空の場合は後でCastExceptionが発生するのでnullにしておきます。
                            if (!(mapData is Map<*, *>)) {
                                mapData = null
                            }

                            /*
                         * 正常値が返却された場合
                         * ResponseConversionクラスでレスポンス内容を各レスポンスクラスに変換します。
                         */
                            if (mapError["errorCode"] == "" || mapError["errorCode"] == null) {
                                val returnData = ResponseConversion(
                                    mapData as Map<*, *>?,
                                    apiSegment
                                ).convertResponse()
                                if (returnData != "") {
                                    continuation.resume(returnData)
                                } else {
                                    // returnDataが存在しない場合はステータスコードを返却します。
                                    continuation.resume(response.code)
                                }
                            } else {
                                // APIがエラーで返却された時はエラー内容を取得して返却します。
                                val errorCode = mapError["errorCode"] as String
                                val errorMessage = mapError["errorMessage"] as String
                                // ここでエラーダイアログを表示する等エラー処理を書きます。
                                // 今回は呼び出し元にエラー文言を返却しています。
                                continuation.resume("ErrorCode $errorCode\n$errorMessage")
                            }
                        } catch (e: Exception) {
                            // 例外処理
                            Log.e("ApiException", e.toString())
                        } finally {
                            // 処理完了時にプログレスダイアログを消します
                            if (isShowProgress) {
                                progressDialog.dismiss()
                            }
                        }
                    }
                    // API失敗
                    override fun onFailure(call: Call, e: IOException) {
                        Log.e("ApiError", e.toString())
                        // 通信エラーなどAPI通信に失敗した際の処理を書きます。
                        if (isShowProgress) {
                            progressDialog.dismiss()
                        }
                    }
                })
            }
        } catch (e: Exception) {
            // APIのリクエストにエラーが存在する時
            Log.e("ApiRequestError", e.toString())
            // APIのリクエストにエラーが存在する際のエラー処理を書きます。
            if (isShowProgress) {
                progressDialog.dismiss()
            }
        }
        return responseData
    }

    // JsonObjectをMapに変換する
    private fun JSONObject.toMap(): Map<String, *> = keys().asSequence().associateWith {
        when (val value = this[it])
        {
            is JSONArray ->
            {
                val map = (0 until value.length()).associate { Pair(it.toString(), value[it]) }
                JSONObject(map).toMap().values.toList()
            }
            is JSONObject -> value.toMap()
            JSONObject.NULL -> null
            else            -> value
        }
    }

    // API送信先のURLを作成
    private fun makeHttpUrl(): HttpUrl {
        val httpUrlBuilder: HttpUrl.Builder = HttpUrl.Builder()
            .scheme("https")
            .addPathSegment(apiSegment.segment)
            .host(apiHostUrl)
        // リクエストパラメータが存在すればセットする
        requestParams?.forEach { (key, value) ->
            httpUrlBuilder.addQueryParameter(key, value.toString())
        }
        return httpUrlBuilder.build()
    }

}

// 通信中のぐるぐるダイアログ
class ProgressDialog : DialogFragment() {

    override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
        val dialog = Dialog(requireContext())
        dialog.setContentView(R.layout.dialog_progress)

        return dialog
    }
}

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <LinearLayout
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:orientation="horizontal"
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintBaseline_toBottomOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        android:gravity="center"
        android:background="@color/white">


        <ProgressBar
            android:id="@+id/progress_bar"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:padding="16dp"/>

        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="通信中..."
            android:layout_marginEnd="40dp"
            android:layout_marginStart="40dp"
            android:textSize="14sp" />

    </LinearLayout>

</androidx.constraintlayout.widget.ConstraintLayout>

// API通信呼び出し例
class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // ここでAPI呼び出し関数を呼んでいる。
        callApi()
    }

    // Api通信実行
    private fun callApi() {
        val request = LoginRequest("入力されたLoginId", "入力されたPassword")
        // 非同期処理なので、コルーチンスコープ内でstartRequestを呼び出します。
        MainScope().launch(Dispatchers.Main) {
            val response = OkHttpConnection(request, this@MainActivity)
                .startRequest(true)
            if (response is LoginResponse) {
                // ログイン情報取得後の処理(必要に応じて変更してください)
                val token = response.token
                // 取得したトークンを端末に保存する処理(実際は暗号化してから保存する方が良いと思います。)
                val sharedPref = getSharedPreferences("mSharedPref", Context.MODE_PRIVATE)
                sharedPref.edit().putString("access_token", token).apply()
            }
        }
    }
}