interface DefaultApi {
    /**
     * 情報を取得する（サンプル）
     * 
     * Responses:
     *  - 200: OK
     *  - 400: Bad Request
     *
     * @return [InformationResponse]
     */
    @GET("/information")
    suspend fun fetchInformation(): Response<InformationResponse>
}

/**
 * 
 *
 * @param information 
 */

data class InformationResponse (

    @Json(name = "information")
    val information: kotlin.collections.List<kotlin.String>

)

こちらを使用して以下のようにAPIクライアントを実装しました。

またAPIリクエスト時のエラーに対応するため、レスポンスを判定するクラスと拡張関数を用意してハンドリングしています。

class InformationAPIClient @Inject constructor(private val client: DefaultApi) {

    suspend fun fetchInformation(): InformationResponse {
        val response = client.fetchInformation()

        return when (val type = response.status()) {
            is ResponseStatus.Success<*> -> type.body as InformationResponse
            is ResponseStatus.Error -> {  /* Error handling */  }
    }
}

sealed class ResponseStatus<out T> {
    data class Success<T>(val body: T?) : ResponseStatus<T>()
    data class Error(val body: String?) : ResponseStatus<Nothing>()

    companion object {
        fun <T> Response<T>.status(): ResponseStatus<T> =
            when (code()) {
                in 200..299 -> Success(body = body())
                else -> Error(body = "/* Error response */")
            }
    }
}

Repository

Repositoryは主にAPI通信を実行しレスポンスを受け取ります。ドメイン層からのアクセス用に interface を用意し、通信処理を別クラスで実装しています。

レスポンスを Flow 型としているのは、データ層からUI層までデータをやりとりする型を統一する目的と、今後ローカルDBを導入することを前提にしているためです。

interface InformationRepository {

    suspend fun fetchInformation(): Flow<InformationResponse>
}

internal class InformationRepositoryImpl @Inject constructor(
    private val informationAPIClient: InformationAPIClient
) : InformationRepository {

    override suspend fun fetchInformation(): Flow<InformationResponse> =
        flow {
            val response = informationAPIClient.fetchInformation()
            emit(response)
        }
}

UseCase (ドメイン層)

Repository（データ層）から受け取ったレスポンスをUI層に渡す際、データの変換をしています。

サンプルのソースコードでは分かりにくいですが、主にレスポンスパラメータをUIで扱いやすい型に変換したり、テキストを表示用に加工したりすることが多いです。

interface InformationDetailUseCase {

    suspend fun fetchInformation(): Flow<InformationModel>
}

class InformationUseCaseImpl @Inject constructor(
    private val informationRepository: InformationRepository
) : InformationUseCase {

    override suspend fun fetchInformation(): Flow<InformationModel> =
        informationRepository.fetchInformation().map { 
            InformationModel.convert(it) 
        }
}

data class InformationModel(
    val information: List<String>
) {
    companion object {
        fun convert(response: ResponseXXX): InformationModel =
            InformationModel(
                information = response.information
            )
    }
}

UI

ドメイン層から渡された値を画面に表示します。

ViewModelでは StateFlow で InformationModel を扱い、fetchして変更が入った際、値が柔軟に切り替わるようにしています。

@HiltViewModel
class InformationViewModel @Inject constructor(
    private val informationUseCase: InformationUseCase
): ViewModel() {

    private val _information = MutableStateFlow<InformationModel>(InformationModel(emptyList()))
    val information: MutableStateFlow<InformationModel> = _information

    init {
        fetchInformation()
    }

    fun fetchInformation() {
        viewModelScope.launch {
            informationUseCase.fetchInformation()
                .flowOn(Dispatchers.IO)
                .onEach { information ->
                    _information.value = information
                }
                .catch {
                    // エラーハンドリング
                }
                .launchIn(viewModelScope)
        }
    }
}

最後に ViewModel から渡された値をViewに表示して完了です。

@Composable
fun InformationScreen() {
    val viewModel = hiltViewModel<InformationModel>()
    val information = viewModel.information.collectAsState()

    Box(contentAlignment = Alignment.BottomEnd) {
        LazyColumn(
            modifier = Modifier.fillMaxSize()
        ) {
            items(announcements) { announcement ->
                Text(text = announcement.title)
            }
        }

        Button(onClick = { viewModel.fetchInformation() }) {
            Text(text = "更新")
        }
    }
}