Refactor settings storage to Preferences DataStore to remove Protobuf

app/build.gradle.kts

@@ -152,7 +152,10 @@ dependencies {
 
     // Access settings & model data
     implementation(project(":data:settings"))
+    implementation(project(":core:settings:datastore-prefs"))
+    implementation(project(":core:settings"))
     implementation(project(":core:model"))
+    implementation(libs.androidx.datastore.preferences)
 
     // Camera Preview
     implementation(project(":feature:preview"))

app/src/main/java/com/google/jetpackcamera/AppSettingsModule.kt

@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2026 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.google.jetpackcamera
+
+import android.content.Context
+import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.core.PreferenceDataStoreFactory
+import androidx.datastore.preferences.core.Preferences
+import androidx.datastore.preferences.preferencesDataStoreFile
+import com.google.jetpackcamera.core.common.DefaultCaptureModeOverride
+import com.google.jetpackcamera.core.settings.datastoreprefs.PrefsDataStoreSettingsDataSource
+import com.google.jetpackcamera.model.CaptureMode
+import com.google.jetpackcamera.settings.SettingsDataSource
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.android.qualifiers.ApplicationContext
+import dagger.hilt.components.SingletonComponent
+import javax.inject.Singleton
+
+@Module
+@InstallIn(SingletonComponent::class)
+object AppSettingsModule {
+
+    @Provides
+    @Singleton
+    fun providePreferencesDataStore(@ApplicationContext context: Context): DataStore<Preferences> {
+        return PreferenceDataStoreFactory.create(
+            produceFile = { context.preferencesDataStoreFile("app_settings.preferences_pb") }
+        )
+    }
+
+    @Provides
+    @Singleton
+    fun provideSettingsDataSource(
+        dataStore: DataStore<Preferences>,
+        @DefaultCaptureModeOverride defaultCaptureMode: CaptureMode
+    ): SettingsDataSource {
+        return PrefsDataStoreSettingsDataSource(dataStore, defaultCaptureMode)
+    }
+}

core/camera/build.gradle.kts

@@ -139,6 +139,7 @@ dependencies {
     implementation("javax.inject:javax.inject:1")
     implementation(libs.androidx.core.ktx)
     implementation(project(":data:settings"))
+    implementation(project(":core:settings"))
     implementation(project(":core:model"))
     implementation(project(":core:common"))
     implementation(project(":core:camera:low-light"))

core/camera/testing/build.gradle.kts

@@ -52,6 +52,7 @@ dependencies {
     implementation(project(":core:camera"))
     implementation(project(":core:model"))
     implementation(project(":data:settings"))
+    implementation(project(":core:settings"))
 
     implementation(libs.camera.core)
     implementation(libs.kotlinx.coroutines.core)

core/model/build.gradle.kts

@@ -17,7 +17,6 @@ plugins {
     alias(libs.plugins.android.library)
     alias(libs.plugins.kotlin.android)
     alias(libs.plugins.kotlin.kapt)
-    alias(libs.plugins.google.protobuf)
 }
 
 android {
@@ -70,37 +69,13 @@ android {
 dependencies {
     implementation(libs.kotlinx.coroutines.core)
 
-    // proto datastore
-    implementation(libs.androidx.datastore)
-    implementation(libs.protobuf.kotlin.lite)
+
 
     // Testing
     testImplementation(libs.junit)
     testImplementation(libs.truth)
 }
 
-protobuf {
-    protoc {
-        artifact = "com.google.protobuf:protoc:3.21.12"
-    }
-
-    generateProtoTasks {
-        all().forEach { task ->
-            task.builtins {
-                create("java") {
-                    option("lite")
-                }
-            }
-
-            task.builtins {
-                create("kotlin") {
-                    option("lite")
-                }
-            }
-        }
-    }
-}
-
 // Allow references to generated code
 kapt {
     correctErrorTypes = true

core/model/src/main/java/com/google/jetpackcamera/model/AspectRatio.kt

@@ -15,8 +15,10 @@
  */
 package com.google.jetpackcamera.model
 
-import com.google.jetpackcamera.model.proto.AspectRatio as AspectRatioProto
-
+/**
+ * WARNING: The string representation of this enum is serialized and persisted in Preferences DataStore.
+ * Renaming constants will break compatibility with existing saved settings.
+ */
 enum class AspectRatio(val numerator: Int, val denominator: Int) {
     THREE_FOUR(3, 4),
     NINE_SIXTEEN(9, 16),
@@ -31,21 +33,4 @@ enum class AspectRatio(val numerator: Int, val denominator: Int) {
      * Returns the landscape aspect ratio as a [Float].
      */
     fun toLandscapeFloat(): Float = denominator.toFloat() / numerator
-
-    companion object {
-
-        /** returns the AspectRatio enum equivalent of a provided AspectRatioProto */
-        fun fromProto(aspectRatioProto: AspectRatioProto): AspectRatio {
-            return when (aspectRatioProto) {
-                AspectRatioProto.ASPECT_RATIO_NINE_SIXTEEN -> NINE_SIXTEEN
-                AspectRatioProto.ASPECT_RATIO_ONE_ONE -> ONE_ONE
-
-                // defaults to 3:4 aspect ratio
-                AspectRatioProto.ASPECT_RATIO_THREE_FOUR,
-                AspectRatioProto.ASPECT_RATIO_UNDEFINED,
-                AspectRatioProto.UNRECOGNIZED
-                -> THREE_FOUR
-            }
-        }
-    }
 }

core/model/src/main/java/com/google/jetpackcamera/model/DarkMode.kt

@@ -15,6 +15,10 @@
  */
 package com.google.jetpackcamera.model
 
+/**
+ * WARNING: The string representation of this enum is serialized and persisted in Preferences DataStore.
+ * Renaming constants will break compatibility with existing saved settings.
+ */
 enum class DarkMode {
     SYSTEM,
     DARK,

core/model/src/main/java/com/google/jetpackcamera/model/DebugSettings.kt

@@ -15,12 +15,6 @@
  */
 package com.google.jetpackcamera.model
 
-import android.util.Base64
-import com.google.jetpackcamera.model.LensFacing.Companion.toProto
-import com.google.jetpackcamera.model.TestPattern.Companion.toProto
-import com.google.jetpackcamera.model.proto.DebugSettings as DebugSettingsProto
-import com.google.jetpackcamera.model.proto.debugSettings as debugSettingsProto
-
 /**
  * Data class for defining settings used in debug flows within the app.
  *
@@ -38,64 +32,81 @@ data class DebugSettings(
 ) {
     companion object {
         /**
-         * Creates a [DebugSettings] domain model from its protobuf representation.
-         *
-         * @param proto The [DebugSettingsProto] instance.
-         * @return The corresponding [DebugSettings] instance.
+         * Parses the string into a [DebugSettings] instance.
          */
-        fun fromProto(proto: DebugSettingsProto): DebugSettings {
-            return DebugSettings(
-                isDebugModeEnabled = proto.isDebugModeEnabled,
-                singleLensMode = if (proto.hasSingleLensMode()) {
-                    LensFacing.fromProto(proto.singleLensMode)
-                } else {
-                    null
-                },
-                testPattern = TestPattern.fromProto(proto.testPattern)
-            )
-        }
+        fun parseFromString(value: String): DebugSettings {
+            val parts = value.split(";")
+            var isDebugModeEnabled = false
+            var singleLensMode: LensFacing? = null
+            var testPattern: TestPattern = TestPattern.Off
 
-        /**
-         * Converts a [DebugSettings] domain model to its protobuf representation.
-         *
-         * @receiver The [DebugSettings] instance to convert.
-         * @return The corresponding [DebugSettingsProto] instance.
-         */
-        fun DebugSettings.toProto(): DebugSettingsProto = debugSettingsProto {
-            isDebugModeEnabled = this@toProto.isDebugModeEnabled
-            this@toProto.singleLensMode?.let { lensFacing ->
-                singleLensMode = lensFacing.toProto()
+            for (part in parts) {
+                val kv = part.split(":")
+                if (kv.size == 2) {
+                    when (kv[0]) {
+                        "debug" -> isDebugModeEnabled = kv[1].toBoolean()
+                        "lens" -> singleLensMode = enumValues<LensFacing>()
+                            .firstOrNull { it.name == kv[1] }
+                        "pattern" -> {
+                            testPattern = when (kv[1]) {
+                                "Off" -> TestPattern.Off
+                                "ColorBars" -> TestPattern.ColorBars
+                                "ColorBarsFadeToGray" -> TestPattern.ColorBarsFadeToGray
+                                "PN9" -> TestPattern.PN9
+                                "Custom1" -> TestPattern.Custom1
+                                else -> {
+                                    if (kv[1].startsWith("SolidColor(") &&
+                                        kv[1].endsWith(")")
+                                    ) {
+                                        val channels = kv[1]
+                                            .removePrefix("SolidColor(")
+                                            .removeSuffix(")")
+                                            .split(",")
+                                        if (channels.size == 4) {
+                                            val red = channels[0].toUIntOrNull()
+                                            val greenEven = channels[1].toUIntOrNull()
+                                            val greenOdd = channels[2].toUIntOrNull()
+                                            val blue = channels[3].toUIntOrNull()
+                                            if (red != null &&
+                                                greenEven != null &&
+                                                greenOdd != null &&
+                                                blue != null
+                                            ) {
+                                                TestPattern.SolidColor(
+                                                    red,
+                                                    greenEven,
+                                                    greenOdd,
+                                                    blue
+                                                )
+                                            } else {
+                                                TestPattern.Off
+                                            }
+                                        } else {
+                                            TestPattern.Off
+                                        }
+                                    } else {
+                                        TestPattern.Off
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
             }
-            testPattern = this@toProto.testPattern.toProto()
-        }
-
-        /**
-         * Parses the encoded byte array into a [DebugSettings] instance.
-         */
-        fun parseFromByteArray(value: ByteArray): DebugSettings {
-            val protoValue = DebugSettingsProto.parseFrom(value)
-            return fromProto(protoValue)
+            return DebugSettings(isDebugModeEnabled, singleLensMode, testPattern)
         }
 
         /**
-         * Parses the Base64 encoded string into a [DebugSettings] instance.
-         */
-        fun parseFromString(value: String): DebugSettings {
-            val decodedBytes = Base64.decode(value, Base64.NO_WRAP)
-            return parseFromByteArray(decodedBytes)
-        }
-
-        /**
-         * Encodes the [DebugSettings] data class into a byte array.
-         */
-        fun DebugSettings.encodeAsByteArray(): ByteArray = this.toProto().toByteArray()
-
-        /**
-         * Encodes the [DebugSettings] data class to a Base64 string.
+         * Encodes the [DebugSettings] data class to a string.
          */
         fun DebugSettings.encodeAsString(): String {
-            val protoValue = this.toProto() // Data class -> Proto
-            return Base64.encodeToString(protoValue.toByteArray(), Base64.NO_WRAP)
+            val lensStr = singleLensMode?.name ?: ""
+            val patternStr = when (val pattern = testPattern) {
+                is TestPattern.SolidColor ->
+                    "SolidColor(${pattern.red},${pattern.greenEven},${pattern.greenOdd},${pattern.blue})"
+                else -> pattern.toString()
+            }
+            return "debug:$isDebugModeEnabled;lens:$lensStr;pattern:$patternStr"
         }
     }
 }

core/model/src/main/java/com/google/jetpackcamera/model/DynamicRange.kt

@@ -14,33 +14,13 @@
  * limitations under the License.
  */
 package com.google.jetpackcamera.model
-import com.google.jetpackcamera.model.proto.DynamicRange as DynamicRangeProto
-
 val DEFAULT_HDR_DYNAMIC_RANGE = DynamicRange.HLG10
 
+/**
+ * WARNING: The string representation of this enum is serialized and persisted in Preferences DataStore.
+ * Renaming constants will break compatibility with existing saved settings.
+ */
 enum class DynamicRange {
     SDR,
-    HLG10;
-
-    companion object {
-
-        /** returns the DynamicRangeType enum equivalent of a provided DynamicRangeTypeProto */
-        fun fromProto(dynamicRangeProto: DynamicRangeProto): DynamicRange {
-            return when (dynamicRangeProto) {
-                DynamicRangeProto.DYNAMIC_RANGE_HLG10 -> HLG10
-
-                // Treat unrecognized and unspecified as SDR as a fallback
-                DynamicRangeProto.DYNAMIC_RANGE_SDR,
-                DynamicRangeProto.DYNAMIC_RANGE_UNSPECIFIED,
-                DynamicRangeProto.UNRECOGNIZED -> SDR
-            }
-        }
-
-        fun DynamicRange.toProto(): DynamicRangeProto {
-            return when (this) {
-                SDR -> DynamicRangeProto.DYNAMIC_RANGE_SDR
-                HLG10 -> DynamicRangeProto.DYNAMIC_RANGE_HLG10
-            }
-        }
-    }
+    HLG10
 }

core/model/src/main/java/com/google/jetpackcamera/model/FlashMode.kt

@@ -15,6 +15,10 @@
  */
 package com.google.jetpackcamera.model
 
+/**
+ * WARNING: The string representation of this enum is serialized and persisted in Preferences DataStore.
+ * Renaming constants will break compatibility with existing saved settings.
+ */
 enum class FlashMode {
     OFF,
     ON,