안녕 DataStore, 안녕SharedPreferences👋 - Android📱 - Part 2: Proto DataStore

이 글은 Hello DataStore, Bye SharedPreferences👋 — Android📱 — Part 2: Preference ProtoStore을 번역한 포스트.

이전 아티클에서는 Preference DataStore를 사용하여 key-value Pair의 형태로 데이터를 저장하는 방법을 살펴봤다. 그러나 이 방법은 type-safe 하지 않다.

이 글에서는 이런 단점을 커버하기 위한 방법을 살펴볼 예정

만약 이전 글이 보고싶다면 이 링크로 이동하면 된다.

코딩 시작

예제코드는 여기서 확인할 수 있다.

음식의 맛과 종류에 관한 필터링 기능을 제공하는 음식 목록을 보여주는 앱을 만들어볼 예정이다.

종류는 🟢VEG 와 🔴NON-VEG
맛은 SWEET 와 SPICY

이런식으로 각각 두 가지 옵션을 제공한다. 아래는 데모

의존성 및 플러그인 추가

첫 번째 해야할 일로 먼저 앱 모듈의 build.gradle에 proto Datastore, Google Protobuf 종속성을 추가한다.

plugins {
    ...
    id "com.google.protobuf" version "0.8.12"
}

dependencies {
    ...
    // Proto DataStore
    implementation  "androidx.datastore:datastore-core:1.0.0-alpha01"

    // Protobuf
    implementation  "com.google.protobuf:protobuf-javalite:3.11.0"
}

// protobuf plugin
protobuf {
    protoc {
        artifact = "com.google.protobuf:protoc:3.11.0"
    }
  
    generateProtoTasks {
        all().each { task ->
            task.builtins {
                java {
                    option 'lite'
                }
            }
        }
    }
}

위 데모에서 봤던 것 처럼 음식 리스트를 가지고 있어야한다. 그러니 먼저 음식에 대한 모델을 먼저 생성해줘야함

data class Food(
    val name: String,
    val type: FoodType,
    val taste: FoodTaste
)

enum class FoodTaste {
    SWEET, SPICY
}

enum class FoodType {
    VEG, NON_VEG
}

또한 DataStore에 저장될 UserFoodPreference라는 새로운 클래스도 하나 만들어줘야한다. 이 클래스는 type이나 taste가 변경될 때 마다 제공되는 역할을 함

data class UserFoodPreference(
    val type: FoodType?,
    val taste: FoodTaste?
)

참고 : 👆 위에 보이듯이 필드를 nullable로 유지했다. null이면 사용자가 음식에 대한 필터 나 선호도를 설정하지 않았다고 가정 할 수 있음

Protobuf 정의하기

모델 클래스를 Proto DataStore에 직접 저장할 수는 없다. 그래서 .proto 파일 안에 스키마를 정의해줘야하는데

food_preference.proto라는 파일을 app/src/main/proto에 생성해준다.

syntax = "proto3";

option java_package = "dev.shreyaspatil.datastore.example.proto";
option java_multiple_files = true;

message FoodPreferences {
    enum FoodType {
        TYPE_UNSPECIFIED = 0;
        TYPE_VEG = 1;
        TYPE_NON_VEG = 2;
    }

    enum FoodTaste {
        TASTE_UNSPECIFIED = 0;
        TASTE_SWEET = 1;
        TASTE_SPICY = 2;
    }

    FoodType type = 1;
    FoodTaste taste = 2;
}

참고 : ProtoBuffer에 대한 syntax 가이드는 여기서 확인할 수 있다

위 단계를 마치면 Gradle 프로젝트를 다시 빌드한다. 그러면 FoodPreference.java가 위의 스키마에서 자동으로 생성되는 것을 볼 수 있음

자동생성된 클래스를 위한 Serializer 만들기

자동생성된 클래스를 위해 serializer가 필요한데 그 이유는 Proto DataStore는 proto object 를 serializes/deserializes 하기위해 serializer의 인스턴스를 필요로 하기 때문이다.

FoodPreferenceSerializer.kt라는 파일을 하나 새로 만들고 아래처럼 작성함

object FoodPreferenceSerializer : Serializer<FoodPreferences> {
    override fun readFrom(input: InputStream): FoodPreferences {
        try {
            return FoodPreferences.parseFrom(input)
        } catch (exception: InvalidProtocolBufferException) {
            throw CorruptionException("Cannot read proto.", exception)
        }
    }

    override fun writeTo(t: FoodPreferences, output: OutputStream) = t.writeTo(output)
}

Food Preference Manager 클래스 생성

이제 사용자의 음식 선호도를 저장할 FoodPreferenceManager를 만들건데 (실제로 Proto DataStore를 구현할 위치),

여기에서 DataStore의 파일이름(food_prefs.pb)과 위에서 만든 Serializer의 인스턴스를 제공해줘야 한다.

먼저 FoodPreferenceManager.kt라는 파일을 새로 만들고 아래처럼 dataStore 필드를 초기화시켜주는 코드를 작성

class FoodPreferenceManager(context: Context) {
    private val dataStore: DataStore<FoodPreferences> =
        context.createDataStore(
            fileName = "food_prefs.pb",
            serializer = FoodPreferenceSerializer
        )
  ....

이제 Type, Taste를 변경해주는 메서드를 각각 만들어주자

Type을 변경해주는 메서드

suspend fun updateUserFoodTypePreference(type: FoodType?) {
        val foodType = when (type) {
            FoodType.VEG -> FoodPreferences.FoodType.TYPE_VEG
            FoodType.NON_VEG -> FoodPreferences.FoodType.TYPE_NON_VEG
            null -> FoodPreferences.FoodType.TYPE_UNSPECIFIED
        }

        dataStore.updateData { preferences ->
            preferences.toBuilder()
                .setType(foodType)
                .build()
        }
    }

Taste를 변경해주는 메서드

suspend fun updateUserFoodTastePreference(taste: FoodTaste?) {
        val foodTaste = when (taste) {
            FoodTaste.SWEET -> FoodPreferences.FoodTaste.TASTE_SWEET
            FoodTaste.SPICY -> FoodPreferences.FoodTaste.TASTE_SPICY
            null -> FoodPreferences.FoodTaste.TASTE_UNSPECIFIED
        }

        dataStore.updateData { preferences ->
            preferences.toBuilder()
                .setTaste(foodTaste)
                .build()
        }
    }

위에 메서드에서 볼 수 있듯이 미리 정의해둔 FoodType, FoodTaste enum 을 자동생성된 FoodPreference.java파일 안에 있는 enum 으로 변환시켜주는 작업을 수행한다.

변경해주는 메서드를 작성했으니 이제는 설정에 저장된 값을 읽어올 차례, Flow를 활용한다

val userFoodPreference = dataStore.data.catch {
        if (it is IOException) {
            Log.e(TAG, "Error reading sort order preferences.", it)
            emit(FoodPreferences.getDefaultInstance())
        } else {
            throw it
        }
    }.map {
        val type = when (it.type) {
            FoodPreferences.FoodType.TYPE_VEG -> FoodType.VEG
            FoodPreferences.FoodType.TYPE_NON_VEG -> FoodType.NON_VEG
            else -> null
        }
        val taste = when (it.taste) {
            FoodPreferences.FoodTaste.TASTE_SWEET -> FoodTaste.SWEET
            FoodPreferences.FoodTaste.TASTE_SPICY -> FoodTaste.SPICY
            else -> null
        }

        UserFoodPreference(type, taste)
    }

이걸로 FoodPreferenceManager 클래스에 관한 설정은 모두 끝!

액티비티 설정하기

여기에서는 Activity 에서 RecyclerView 를 사용하여이 앱을 구현하고 Repository에서 음식 항목 목록과 같은 데이터를 가져 오기 위해 ViewModel을 구현했다고 가정, (데모 목적으로 여기에 음식 항목의 더미 목록을 제공하는 샘플 DataSource를 만들었다).

따라서 DataStore와 관련된 구현을 보여줄건데 전체 코드는 여기

먼저 ProtoDatastoreActivity라는 액티비티를 만들고 FoodPreferenceManager 필드와 RecyclerView를 위한 foodListAdapter를 생성해준다.

class ProtoDatastoreActivity : AppCompatActivity() {

    private lateinit var foodPreferenceManager: FoodPreferenceManager

    private val foodListAdapter by lazy { FoodListAdapter() }

참고: 여기에 있는 foodListAdapter는 RecyclerView.Adapter를 구현한 것

이제 Chips 를 클릭하면 설정을 저장하고 업데이트하는 로직을 구현할 것이다. 자세한 코드는 아래

    private fun initViews() {
        foodTaste.setOnCheckedChangeListener { group, checkedId ->
            val taste = when (checkedId) {
                R.id.sweet -> FoodTaste.SWEET
                R.id.spicy -> FoodTaste.SPICY
                else -> null
            }

            lifecycleScope.launch { foodPreferenceManager.updateUserFoodTastePreference(taste) }
        }

        foodType.setOnCheckedChangeListener { group, checkedId ->
            val type = when (checkedId) {
                R.id.veg -> FoodType.VEG
                R.id.nonVeg -> FoodType.NON_VEG
                else -> null
            }

            lifecycleScope.launch { foodPreferenceManager.updateUserFoodTypePreference(type) }
        }
    }

위 로직이 끝났으면 이제 설정이 변경되었는지 Observe 하는 작업도 처리를 해줘야함.

private fun observePreferences() {
        foodPreferenceManager.userFoodPreference.asLiveData().observe(this) {
            filterFoodList(it.type, it.taste)
        }
    }

참고 : 여기에서는 Flow의 asLiveData() 익스텐션을 사용했다. 그렇지 않으면 lifecycleScope를 사용할 수도 있음. 이는 일반적으로 ViewModel 로 실제로 구현할 때 유용하다

이제 실제 데이터를 필터링하는 로직을 구현해야함filterFoodList()라는 메서드를 만들고 아래처럼 작성한다.

private fun filterFoodList(type: FoodType?, taste: FoodTaste?) {
        var filteredList = getFoodList()
        type?.let { foodType ->
            filteredList = filteredList.filter { it.type == foodType }
        }
        taste?.let { foodTaste ->
            filteredList = filteredList.filter { it.taste == foodTaste }
        }

        foodListAdapter.submitList(filteredList)

        if (filteredList.isEmpty()) {
            Toast.makeText(this, "No results!", Toast.LENGTH_SHORT).show()
        }

        updateViews(type, taste)
    }

지금까지 Proto DataStore를 구현해봤다. 앱을 실행하면이 문서의 시작 부분에서 본 데모와 같은 결과가 보이게 된다.