[Android 기초] 19. Retrofit (HTTP, API, REST, JSON, GSON)

 

Retrofit을 이해하기 위해 알아야 하는 개념

• 서버/클라이언트
• HTTP
• API
• REST
• JSON
• GSON

 

---

 

 

1. 서버? 클라이언트?

 

• 서버 (Server)
  - 데이터나 리소스를 제공하는 시스템
  - 사용자의 요청을 기다리고, 요청이 들어오면 그에 맞는 응답을 전송
• 클라이언트 (Client)
  - 사용자를 대표하여 서버에 정보나 서비스를 요청하는 시스템
  - 웹 브라우저, 모바일 앱, 데스크톱 앱 등 다양한 형태로 존재

 

서버와 클라이언트가 통신하는 방식은 다양하며, 사용하는 프로토콜 / 용도 / 성능 요구사항에 따라 적절한 것을 선택
통신 방식으로는 HTTP/HTTPS, WebSockets, Socket(TCP/UDP), FTP, RPC, SOAP, GraphQL, MQTT 등이 있음
프로토콜 : 통신 규약 (= 약속, 컴퓨터 또는 전자기기 간의 원활한 통신을 위해 지키기로 약속한 규약)

 

💡 3-Tier 아키텍쳐

(출처 : Three-tier architecture overview AWS Documentation)

• 프레젠테이션 계층 (Web Server) : 리소스를 사용하는 앱(클라이언트)
• 애플리케이션 계층 (WAS) : 리소스를 전달해주는 앱(서버)
• 데이터 계층 (DB) : 리소스 저장 공간(데이터베이스)

 

---

 

2. HTTP? 웹 애플리케이션 프로토콜

[Network] HTTP 프로토콜에 대하여

• 웹 기반의 애플리케이션에서 주로 사용
• REST API나 SOAP와 같은 웹 서비스 통신 방식에서 기반
• 클라이언트와 서버가 서로 HTTP 라는 프로토콜을 이용해서 서로 대화를 나눔
• HTTP를 이용해 주고받는 메시지는 "HTTP 메시지" 라고 부름

 

 

---

 

3. API? Application Programming Interface

https://rapidapi.com/blog/api-glossary/api/

• 클라이언트가 서버에게 요청하려면, 정확한 주문 방법에 따라 요청해야 함
• 이처럼 서버가 클라이언트에게 리소스를 잘 활용할 수 있도록 제공하는 인터페이스를 API라고 칭함
  여기서 인터페이스의 뜻은 '의사소통이 가능하도록 만들어진 접점', 즉 규격/매뉴얼 느낌

 

 

---

 

4. REST API? Representational State Transfer

API, REST API란?

https://mannhowie.com/rest-api

• API에도 체계가 필요하다는 관점에서 나온 방법이자, API 규칙과 내용을 더 직관적이고 간단하고 쉽게 만든 것
• HTTP 요청을 보낼 때 어떤 URI에 어떤 Method를 사용할지 개발자 사이에서 널리지켜지는 약속
  일종의 관행적인 형식과 약속이므로, 앱을 만들든 웹을 만들든 어떤 언어를 써서 구현했든, 그 안에 소프트웨어 간 HTTP로 정보를 주고 받는 부분이 있다면 규칙을 준수하여 RESTful한 서비스를 만들 수 있음
• 웹의 장점을 최대한 활용
  월드 와이드 웹(WWW) : REST 아키텍처를 기반으로 구성
• REST API Method
  데이터를 불러올 때 HTTP URI로 어떤 자원을 통해 데이터를 얻을 것인지 표시
  - POST: Create(생성하기) ex. 웹 페이지에 사진을 올리는 요청.
  - GET: Read(읽어오기) ex. 웹 페이지에서 사진을 불러오는 요청.
  - PUT(전체) / PATCH(일부): Update(변경하기) ex. 웹 페이지의 사진을 바꾸는 요청.
  - DELETE: Delete(삭제하기) ex. 웹 페이지의 사진을 지우는 요청.
• RESTful API 서버 응답: 2XX 코드는 성공을 나타내고 4XX 및 5XX 코드는 오류

 

---

 

5. JSON? :  JavaScript Object Notation

JSON

• 서버에서 클라이언트로 데이터를 보내거나 저장할 때 사용하는 경량의 데이터 교환 형식
• 과거 웹 초기 시절부터 사용된 XML은 헤더와 태그 등의 여러 요소로 가독성이 떨어지고, 쓸데없이 용량을 잡아먹는다는 단점을 항상 지적받았다. 이에 대응해 간결하고 통일된 양식으로 각광을 받고 있는 것이 JSON이다.
• 서버로부터 데이터를 가져오기 위해서 하나의 약속으로 JSON이란 데이터형식을 사용하여 통신한다고 생각하면된다.

 

{
  "이름공간(키)": "값",
  "값 구분자": "각각의 값들은 ',' (콤마)로 구분되어야 합니다.",
  "이스케이프": "키나 값에서 큰따옴표를 쓰고 싶으면-특정 문자를 이스케이프 하려면- \" 처럼 문자 앞에 역슬래시를 붙입니다.",
  "자료형": "표현 가능한 자료형은 문자열, 숫자, 불리언, 널, 객체, 배열 6개입니다.",
  "문자열 값": "나무위키, 여러분이 가꾸어 나가는 지식의 나무",
  "숫자 값": 19721121,
  "불리언 값": true,
  "널 값": null,
  "객체 값": {
    "값1": 3.14159265358979323846264338,
    "값2": false,
    "값3": {
      "객체 안에": "객체를 넣는것도 가능하지요",
      "구분자": "또한 키와 값은 ':' 로 구분됩니다"
    }
  },
  "배열 값": [
    "이것은 배열입니다.",
    {
      "현재 값의 인덱스": 1,
      "이런 식으로": "배열 안에 여러 값을 넣을 수 있습니다."
    },
    [ "배열", "안에", "배열을", "넣는것도", "가능하지요" ]
  ],
  "값의 개수가 적을때는": "다음과 같이 한 줄로도 객체와 배열 표현이 가능합니다.",
  "한 줄 객체": { "김두한": "나 김두한이다", "심영": "내가 고자라니", "의사양반": "병신을 만들어주마" ,  "이근": "4번은 개인주의야" },
  "한 줄 배열": [ "나무위키는", "누구나", "기여할", "수", "있는", "위키입니다." ]
}

• JSON데이터는 하나의 NAME과 VALUE로 이루어짐 ("데이터이름" : 값)
  데이터이름(NAME) : String타입
  값(value) : 숫자, 문자열, 불리언(boolean), 객체, 배열(array), NULL값 등
• JSON배열은 중괄호{}가 아닌 대괄호[]로 둘러쌓아 표현

 

 

---

 

6. GSON?

• Google에서 제공하는 오픈소스 라이브러리로, Java와 Kotlin에서 주로 사용
• 개발하다 보면, 데이터를 주고 받을 때 자주 사용되는 데이터 포맷인 JSON 데이터를 우리가 사용하는 프로그래밍 언어의 객체로 변환해야 할 때가 있음 (반대로 객체를 JSON 형태로 변환해야 할 때도 존재)
  → 이러한 작업을  '직렬화(Serialization)'와 '역직렬화(Deserialization)'라고 함
• Gson 라이브러리는 이러한 직렬화 / 역직렬화 작업을 매우 간단하게 해줌

 

val gson = Gson()
val jsonString = gson.toJson(someObject)

• Kotlin 객체를 JSON으로 변환

 

val myClassInstance: MyClass = gson.fromJson(jsonString, MyClass::class.java)

• JSON을 Kotlin 객체로 변환

 

data class Person(
    @SerializedName("person_name")
    val name: String
)

• @SerializedName("원래 JSON키 이름") 어노테이션
• Kotlin 필드와 JSON 키 이름이 다를 경우 매핑

 

이외에도 Custom Serializer/Deserializer (특정 타입에 대해 사용자 지정 직렬화 및 역직렬화 로직을 정의)
Exclusion Strategies (특정 필드의 직렬화 또는 역직렬화를 제외하기 위한 전략 정의)가 있음

 

직렬화/역직렬화 , Gson vs Moshi

다만 2024년 현재 시점에서 Gson보다 Moshi 사용을 지향하는 편
(Gson은 코틀린의 널세이프티를 준수하지 않으며, 코틀린의 디폴트 문법을 무시해버림
반면 Moshi는 Kotlin도 포함된 컨버터 라이브러리로, 널 세이프티 같은 장점을 살릴 수 있고 업데이트 활발)

 

 

---

 

7. Retrofit?

Retrofit이란? (사용하기 전에 알아야 할 것들)

 

• 안드로이드 및 자바를 위한 타입 세이프한 HTTP 클라이언트 라이브러리
• 안드로이드 개발 시 서버통신에 사용되는 HTTP API를 자바, 코틀린의 인터페이스 형태로 변환해 API를 쉽게 호출할 수 있도록 지원하는 라이브러리
• 장점
  1. 코드의 간결성
      - 복잡한 HTTP API 요청을 쉽고 간결하게 만듦
      - 간단한 어노테이션을 통해 요청 메서드와 URL을 정의 가능
  2. 안정성과 확장성
      - 내부적으로 OkHttp 라이브러리를 사용하여 통신, 이를 통해 안정적인 통신이 가능
      - 인터셉터를 사용하여 요청/응답 프로세스를 확장하거나 수정할 수 있음
  3. 다양한 플러그인과 컨버터 지원
      - 다양한 데이터 형식(JSON, XML 등)에 대해 데이터 변환 컨버터를 제공
      - RxJava, Coroutines와 같은 비동기 프로그래밍 라이브러리와 연동 가능

 

장점

1. 코드의 간결성
    - 복잡한 HTTP API 요청을 쉽고 간결하게 만들 수 있음
    - 간단한 어노테이션을 통해 요청 메서드와 URL을 정의할 수 있음
2. 안정성과 확장성
    - 내부적으로 OkHttp 라이브러리를 사용하여 통신, 이를 통해 안정적인 통신이 가능
    - 인터셉터를 사용하여 요청/응답 프로세스를 확장하거나 수정할 수 있음
3. 다양한 플러그인과 컨버터 지원
    - 다양한 데이터 형식(JSON, XML 등)에 대해 데이터 변환 컨버터를 제공
    - RxJava, Coroutines와 같은 비동기 프로그래밍 라이브러리와 연동 가능

 

 

---

 

1. 앱 수준 build.gradle에 Retrofit 라이브러리 추가하기

// build.gradle (Module: app)
dependencies {
    implementation("com.squareup.retrofit2:retrofit:2.9.0")
    implementation("com.squareup.retrofit2:converter-gson:2.9.0")
}

 

2. API 인터페이스 정의하기

interface ApiService {
    @GET("users/{id}")
    fun getUser(@Path("id") id: Int): Call<User> // 여기서 User는 서버 응답으로 받아올 데이터 모델 클래스
}

 

3. Retrofit 인스턴스 생성하기

val retrofit = Retrofit.Builder()
    .baseUrl("https://api.example.com/")
    .addConverterFactory(GsonConverterFactory.create())
    .build()

val apiService = retrofit.create(ApiService::class.java)
// 이제 apiService 객체를 통해 정의된 API 요청을 사용 가능

 

4-1. 응답 처리하기 (동기식 vs 비동기식 요청)

// 동기식 요청: 현재 스레드에서 실행되며, 응답이 올 때까지 다음 코드의 실행이 중단
val response: Response<User> = apiService.getUser(id).execute()



// 비동기식 요청: 콜백을 사용하여 백그라운드에서 실행되며, 응답이 오면 해당 콜백이 호출
apiService.getUser(id).enqueue(object: Callback<User> {
    override fun onResponse(call: Call<User>, response: Response<User>) {
        // 처리
    }

    override fun onFailure(call: Call<User>, t: Throwable) {
        // 오류 처리
    }
})

 

4-2. 응답 처리하기 (응답 객체 사용하기)

// Response 객체를 통해 HTTP 응답의 여러 정보에 접근 가능
if (response.isSuccessful) { 
    val user: User? = response.body()
} else {
    // 오류 메시지 처리
    val error: String = response.errorBody()?.string() ?: "Unknown error"
}

 

4-3. 응답 처리하기 (오류 처리하기)

// Retrofit의 onFailure 콜백은 네트워크 오류나 데이터 변환 오류 등에서 호출

override fun onFailure(call: Call<User>, t: Throwable) {
    // 오류 메시지 표시
    Log.e("API_ERROR", t.message ?: "Unknown error")
}

 

 

---

 

+ (추가) 보다 자세한 Retrofit 사용법

 

환경 세팅

Gradle 설정 (app 수준 build.gradle.kts 종속성 추가)

implementation(libs.retrofit)
 		
implementation(platform(libs.okHttpBom)) // Bom - 하나의 뭉치 (빌리언스 오브 머트리얼?)
implementation(libs.logging.interceptor) // 네트워크 송수신이 어떻게 이루어지는지 보기위함

// moshi
implementation(libs.moshi.kotlin) // 코틀린에서 쓰는 moshi
implementation(libs.converter.moshi)
implementation(libs.moshi.adapters)

 

libs.versions.toml (버전 및 라이브러리 추가)

[versions]
retrofitVersion = "2.11.0"
okHttpBomVersion = "4.12.0"
moshiVersion = "1.15.1"
moshiAdapters = "1.15.1"

[libraries]
retrofit = { module = "com.squareup.retrofit2:retrofit", version.ref = "retrofitVersion" }
okHttpBom = { module = "com.squareup.okhttp3:okhttp-bom", version.ref = "okHttpBomVersion" }
logging-interceptor = { module = "com.squareup.okhttp3:logging-interceptor", version.ref = "okHttpBomVersion" }
converter-moshi = { module = "com.squareup.retrofit2:converter-moshi", version.ref = "retrofitVersion" }
moshi-kotlin = { module = "com.squareup.moshi:moshi-kotlin", version.ref = "moshiVersion" }
moshi-adapters = { module = "com.squareup.moshi:moshi-adapters", version.ref = "moshiAdapters" }

 

• 기존 방식과 비교하여 버전관리를 버전 카탈로그 방식으로 하는 것의 장점?
  : 멀티 모듈 프로젝트의 경우 모듈마다 gradle이 설정되어 있기 때문에 각각 작성하기에 번거롭고 문제 생김

 

사용하고자 하는 API의 Key를 local.properties에 추가 (키는 자신이 발급받은 키)

REST_API_KEY=abcdefghijklmnopqrstuvwxyz
KAKAO_BASE_URL = https://dapi.kakao.com/

• 베이스 url: dapi.kakao.com
• 엔드 포인트: 그 이후 url 
  예: @POST("v2/search/app") 처럼 나와있는 메서드와 그에 맞게 엔드포인트 넣어줌

 

build.gradle.kts에 아래와 같이 값 추가

buildTypes {
        val gradleLocalProperties = gradleLocalProperties(
            projectRootDir = rootDir,
            providers = providers
        )
        val apiKey = gradleLocalProperties.getProperty("REST_API_KEY")
        val baseUrl = gradleLocalProperties.getProperty("KAKAO_BASE_URL")
        
        debug {
            buildConfigField("String", "REST_API_KEY", "\"$apiKey\"")
            buildConfigField("String", "KAKAO_BASE_URL", "\"$baseUrl\"")
            isDebuggable = true
            isMinifyEnabled = false
        }
        
        release {
            buildConfigField("String", "REST_API_KEY", "\"$apiKey\"")
            buildConfigField("String", "KAKAO_BASE_URL", "\"$baseUrl\"")
            isMinifyEnabled = false
            proguardFiles(
                getDefaultProguardFile("proguard-android-optimize.txt"),
                "proguard-rules.pro"
            )
        }
    }

buildFeatures {
    // ...
    buildConfig = true
}

• 보통 release만 있는데, debug 추가
• buildConfig = true로 지정하면 key값을 어디서나(코드단)에서 사용 가능
  ex. BuildConfig.REST_API_KEY 처럼 사용 가능

 

 

코드 세팅

코드 세팅

<uses-permission android:name="android.permission.INTERNET"/>

• 네트워크 작업은 Presentation, Domain, Data Layer 중에서 Data Layer에 속함 
• 네트워크 작업이므로 항상 아래 권한을 AndroidManifest.xml 에 넣어주자!

 

 

NetworkModule 만들기

import com.spartabasic.www.data.network.api.KakaoApiService
import com.squareup.moshi.Moshi
import com.squareup.moshi.adapters.Rfc3339DateJsonAdapter
import com.squareup.moshi.kotlin.reflect.KotlinJsonAdapterFactory
import okhttp3.OkHttpClient
import okhttp3.logging.HttpLoggingInterceptor
import retrofit2.Retrofit
import retrofit2.converter.moshi.MoshiConverterFactory
import java.util.Date
import java.util.concurrent.TimeUnit


// 아래 거 복붙해서 어디서나 사용 가능
object NetworkModule {

    val retrofit by lazy { // 어느 위치에서든 사용할 수 있도록 전역변수로 설정
        provideKakaoApiService()
    }

    private fun provideMoshi(): Moshi { // 모시 빌드
        return Moshi.Builder()
            .add(KotlinJsonAdapterFactory())
            .add(Date::class.java, Rfc3339DateJsonAdapter()) // 날짜 형식 변환 : (2017-) 어쩌구를 자바로 변환
            .build()
    }

    private fun provideHttpLoggingInterceptor(): HttpLoggingInterceptor { // 인터셉터
        val interceptor = HttpLoggingInterceptor()
        if (BuildConfig.DEBUG) {
            interceptor.level = HttpLoggingInterceptor.Level.BODY
        } else { // 디버그가 아닐 때는 로그가 찍히지 않도록 설정. 출시할 땐 로그 모두 삭제해야 함!
            interceptor.level = HttpLoggingInterceptor.Level.NONE
        }
        return interceptor
    }

    private fun provideOkHttpClient(
        httpLoggingInterceptor: HttpLoggingInterceptor = provideHttpLoggingInterceptor(),
    ): OkHttpClient {
        return OkHttpClient
            .Builder() // 빌더 디자인패턴 - 자바 방식 (원래 코틀린에선 필요 없기 때문에 자바 방식임을 추론)
            .connectTimeout(timeout = 20, unit = TimeUnit.SECONDS)
            .readTimeout(timeout = 20, unit = TimeUnit.SECONDS)
            .writeTimeout(timeout = 20, unit = TimeUnit.SECONDS)
            .addInterceptor(interceptor = httpLoggingInterceptor) // 인터셉터 : 네트워크 송수신이 로깅되는 것을 확인하기 위해서 추가
            .build()
    }

    private fun provideRetrofitModule(moshi: Moshi = provideMoshi()): Retrofit.Builder {
        return Retrofit.Builder()
            .addConverterFactory(MoshiConverterFactory.create(moshi)) // 직렬화와 역직렬화. Gson인 경우 GsonConverterFactory
    }


// 카카오 api 추가
    private fun provideKakaoApiService(
        client: OkHttpClient = provideOkHttpClient(),
        retrofit: Retrofit.Builder = provideRetrofitModule()
    ): KakaoApiService {
        return retrofit.baseUrl(BuildConfig.KAKAO_BASE_URL) // 베이스 url 설정
            .client(client) // 클라이언트 설정
            .build()
            .create(KakaoApiService::class.java) // 어떤 api 서비스를 바라보게 할 거냐
    }
}

• retrofit을 설정하는 파일이 필요. 베이스 url과 클라이언트 설정 등

 

 

Response 클래스 및 Dto 만들기

1. KakaoApiResponse

import com.spartabasic.www.data.network.model.MetaDto

data class KakaoApiResponse<out T>( // T : 제네릭 타입. 이미지api를 설정하면 이미지 리스폰스, 비디오api를 설정하면 비디오 리스폰스
// out T는 T타입이면 다 된다는 것인데 out과 in 구분하기. 집어넣는 경우 함수명(T)<>면 in
    val meta: MetaDto,
    val documents: T,
)

 

2. ImageSearchDto

import com.squareup.moshi.Json
import java.util.Date

data class ImageSearchDto(
    val collection: String,
    @Json(name = "thumbnail_url")
    val thumbnailUrl: String,
    @Json(name = "image_url")
    val imageUrl: String,
    val width: Int,
    val height: Int,
    @Json(name = "display_sitename")
    val displaySiteName: String,
    @Json(name = "doc_url")
    val docUrl: String,
    @Json(name = "datetime")
    val dateTime: Date
)

• DTO란?
  = Data transfer object : 데이터를 옮겨주는(송수신을 담당하는) 객체, DT에 필요한 객체
  가끔 DTO가 아니라 Entity라고 적는 사람도 있음. 근데 이건 데이터베이스랑 헷갈려서 네트워크 작업은 DTO가 나음
  cf. DT (Data Transfer) 를 하는 것은 Retrofit
• @Json 어노테이션 : moshi에서 사용하는 이름 변경 방식 (gson에선 @Serializedname)

 

3. VideoSearchDto

import com.squareup.moshi.Json
import java.util.Date

data class VideoSearchDto(
    val title: String,
    val url: String,
    @Json(name = "datetime")
    val dateTime: Date,
    @Json(name = "play_time")
    val playTime: Int,
    val thumbnail: String,
    val author: String
)

 

 

Api Service 인터페이스 만들기

import com.spartabasic.www.data.network.model.ImageSearchDto
import com.spartabasic.www.data.network.model.VideoSearchDto
import retrofit2.Response
import retrofit2.http.GET
import retrofit2.http.Header
import retrofit2.http.Query

interface KakaoApiService { // Retrofit 라이브러리의 사용법에 따라 interface로 사용, 나머진 Retrofit이 다 해줘!
    @GET("v2/search/image")
    suspend fun getSearchedImages(
        @Header("Authorization") header: String = "KakaoAK ${BuildConfig.REST_API_KEY}",
        @Query("query") query: String,
        @Query("sort") sort: String,
        @Query("page") page: Int,
        @Query("size") size: Int,
    ): Response<KakaoApiResponse<List<ImageSearchDto>>> // Response는 성공했는지 아닌지??

    @GET("v2/search/vclip")
    suspend fun getSearchedVideos(
        @Header("Authorization") header: String = "KakaoAK ${BuildConfig.REST_API_KEY}",
        @Query("query") query: String,
        @Query("sort") sort: String,
        @Query("page") page: Int,
        @Query("size") size: Int,
    ): Response<KakaoApiResponse<List<VideoSearchDto>>>
}

• 로그에서 response값 보면 2xx면 모두 성공, 3xx은 리다이렉션, 4xx는 클라이언트 에러, 5xx는 서버 에러
  404는 not found 에러 (예: 입력한 엔드 포인트가 실제와 다른 경우)
  400은 Bad Request 에러로 값을 뭔가 잘못 보냈을 때 (예: 한 번에 10만개 요청하는 경우)
  401은 Unauthorized 에러로 권한 오류 (예: 키 값을 안 넣었을 때)
• 로그 보면 가져온 값들도 다 볼 수 있음

 

 

일반적인 사용법

일반적인 사용법 (예시: SearchFragment.kt)

1. Retrofit의 Call 인터페이스를 사용하는 방법

private fun fetchVideos() {
        NetworkModule.retrofit.getSearchedVideos(
            query = "test",
            page = 1,
            size = 10, 
            sort = "recency"
        ).enqueue(object : Callback<KakaoApiResponse<List<VideoSearchDto>>> { 
		// 콜백 : 계속 기다릴 수 없기 때문, 실행이 성공적으로 끝나면 아래 블럭 실행
            override fun onResponse(
                call: Call<KakaoApiResponse<List<VideoSearchDto>>>,
                response: Response<KakaoApiResponse<List<VideoSearchDto>>>
            ) {
                if (response.isSuccessful) {
                    Log.i(TAG, "Successful! ${response.code()}")
                    val body = response.body()
                    if (body != null) {
                        val meta = body.meta
                        val documents = body.documents
                        binding.tvMeta.text = "$meta"
                        binding.tvDocuments.text = "$documents"

                    } else {
                        Log.e(TAG, "Something went wrong!")
                    }
                }
            }

            override fun onFailure( // 실패했을 때
                p0: Call<KakaoApiResponse<List<VideoSearchDto>>>,
                p1: Throwable
            ) {
                Log.e(TAG, "Error: ${p1.message}")
            }

        })
    }

• call은 retrofit에서 제공해주는 인터페이스
• call을 사용하기 위해서는 인터페이스기 때문에 무조건 enqueue(Retrofit에서 지원하는 함수) 부분 등이 필요함
  -> 코드가 길어지고 보일러 플레이트, 콜백 지옥(callback hell) 가능성...

 

 

2. Coroutine을 사용하는 방법

   private fun fetchImages() {
        lifecycleScope.launch {
            val response = NetworkModule.retrofit.getSearchedImages(
                query = "test",
                page = 1,
                size = 10,
                sort = "recency"
            )
            if (response.isSuccessful) {
                Log.i(TAG, "Successful! ${response.code()}")
                val body = response.body()
                if (body != null) {
                    val meta = body.meta
                    val documents = body.documents
                    binding.tvMeta.text = "$meta"
                    binding.tvDocuments.text = "$documents"

                } else {
                    Log.e(TAG, "Something went wrong!")
                }
            } else {
                Log.e(TAG, "Error: ${response.errorBody()}")
            }
        }
    }

• 복잡한 작업을 하거나, 순서를 보장해야 될 때 사용
• suspend라고 써 있는 함수들을 순차적으로 (위->아래) 진행해 줌. 다만!!!
  1) 함수가 suspend로 되어 있는지 항상 확인해줘야 함
  2) 첫 번째 suspend가 실패하면 두 번째 suspend 실행 안 됨 (Supervisorjob 설정하면 괜찮아짐)
• 코루틴의 경우 job.cancel()로 엄청 쉽게 취소 가능 -> call 인터페이스는 어떻게 취소하는지 잘 모름

 

 

 

3. Rx를 사용하는 방법

• 잘은 모르지만, 보일러 플레이트 가능성이 많음

 

 

 

고민 사항

1. 굳이 ViewModel을 사용해야 하는가?  

• 상황을 고려 했을 때 데이터 상태를 보완하기 위함
• 화면이 전환되거나, Fragment 리플레이스 될 때 데이터를 저장하기 위해 Livedata 사용
• 상황에 맞게 판단 하에 잘 쓰면 됨
• 보통 그런데 이런 환경/상황이 많기 때문에 뷰모델을 많이 쓰는 것
• 한두번 쓰는 게 아닌 이상 뷰에 표시되는 데이터 (데이터 갱신 시점 등 작업) 작업은 모두 뷰모델에서 할 것

2. 왜 네트워크 모듈은 object(Singleton)이어야 할까? 

• 새로운 객체가 계속 생성되면 안 됨 → 똑같은 작업은 한 번만 해야 네트워크가 안 터짐
• 같은 네트워크 상태를 유지하기 위함