Chapter 7: Data Persistence and Storage
Data Persistence and Storage! This is where your app stops being “amnesiac” — it starts remembering things even after the user closes it, kills the process, or restarts the phone. We’re talking about saving user preferences (like dark mode toggle, username), app settings, or even structured data like a list of favorite tips from our calculator.
In January 2026, Google has made it crystal clear: SharedPreferences is legacy for simple cases, but Jetpack DataStore is the modern, recommended way for key-value storage. Room remains king for structured, relational data (like a real database).
We’ll cover:
- SharedPreferences (quick legacy overview — still works, but avoid new use)
- DataStore (Preferences DataStore for simple key-value, Proto DataStore for typed objects)
- Room basics (entities, DAOs, database)
- Hands-on: Save/retrieve user data in our Tip Calculator (e.g., save default tip %, last bill amount)
Let’s do this like we’re sitting together debugging on your laptop in Airoli — detailed explanations, code snippets, why-things, common pitfalls, and a full example.
1. SharedPreferences (Quick Legacy Overview – Why It’s Fading in 2026)
SharedPreferences is the old-school XML-based key-value store. It’s simple, but has big issues:
- Synchronous I/O → Can block main thread → ANRs/jank
- No type safety → Everything as String/Int/Boolean
- No transactions → Partial writes possible on crash
- Not reactive → Manual polling to observe changes
Still used in many legacy apps, but Google docs now say: “Use DataStore instead for new projects.”
Quick example (don’t use for new code, but good to know):
|
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
// In Activity or ViewModel val prefs = getSharedPreferences("user_prefs", Context.MODE_PRIVATE) // Write prefs.edit() .putString("username", "Webliance") .putInt("default_tip", 18) .apply() // async, or commit() sync // Read val name = prefs.getString("username", "Guest") ?: "Guest" val tip = prefs.getInt("default_tip", 15) |
In 2026: EncryptedSharedPreferences is deprecated too (replaced by DataStore + Tink for secure needs). Avoid for new apps.
2. Jetpack DataStore (The Modern Replacement – Use This!)
DataStore comes in two flavors:
- Preferences DataStore → Simple key-value (like SharedPreferences but async, Flow-based, type-safe)
- Proto DataStore → Structured, typed data (like a mini-Protobuf schema)
Why DataStore wins in 2026:
- Fully asynchronous (Coroutines + Flow)
- Reactive: UI auto-updates via collectAsState()
- Type-safe & transactional
- Coroutine-safe, no main-thread blocks
- Migration from SharedPreferences easy
Add dependency (app/build.gradle.kts – latest stable ~1.2.0, alpha 1.3.0-alpha04 as of Jan 14, 2026):
|
0 1 2 3 4 5 6 7 |
implementation("androidx.datastore:datastore-preferences:1.2.0") // or latest stable // For Proto: implementation("androidx.datastore:datastore:1.2.0") |
Preferences DataStore Example (simple key-value):
Create a object for easy access:
|
0 1 2 3 4 5 6 7 8 9 10 11 |
// DataStoreKeys.kt object PreferencesKeys { val DEFAULT_TIP_PERCENT = intPreferencesKey("default_tip_percent") val LAST_BILL_AMOUNT = doublePreferencesKey("last_bill_amount") val USER_NAME = stringPreferencesKey("user_name") } |
Usage in ViewModel or Composable:
|
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
// In ViewModel class TipViewModel( private val dataStore: DataStore<Preferences> // Injected or context.dataStore ) : ViewModel() { val defaultTipPercent: Flow<Int> = dataStore.data .catch { emit(emptyPreferences()) } .map { prefs -> prefs[PreferencesKeys.DEFAULT_TIP_PERCENT] ?: 15 } suspend fun saveDefaultTip(percent: Int) { dataStore.edit { prefs -> prefs[PreferencesKeys.DEFAULT_TIP_PERCENT] = percent } } } |
In Composable (observe & update):
|
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
@Composable fun SettingsScreen(viewModel: TipViewModel = viewModel()) { val defaultTip by viewModel.defaultTipPercent.collectAsStateWithLifecycle(initialValue = 15) var newTip by remember { mutableIntStateOf(defaultTip) } Column { Text("Default Tip: $defaultTip%") Slider(value = newTip.toFloat(), onValueChange = { newTip = it.toInt() }, valueRange = 0f..30f) Button(onClick = { viewModel.saveDefaultTip(newTip) }) { Text("Save") } } } |
How to get DataStore instance (best: Hilt or manual):
|
0 1 2 3 4 5 6 7 |
// In Application or Activity val Context.dataStore: DataStore<Preferences> by preferencesDataStore(name = "user_settings") |
Proto DataStore (for complex objects – e.g., UserProfile):
- Define proto schema (src/main/proto/user.proto):
|
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
syntax = "proto3"; option java_package = "com.webliance.hellowebliance"; option java_multiple_files = true; message UserSettings { int32 default_tip_percent = 1; double last_bill = 2; string username = 3; } |
- Generate classes (build → gradle sync)
- Create DataStore:
|
0 1 2 3 4 5 6 7 8 9 |
val Context.settingsDataStore: DataStore<UserSettings> by dataStore( fileName = "user_settings.pb", serializer = UserSettingsSerializer // Implement or use generated ) |
Then read/write with map, updateData.
For beginners: Start with Preferences DataStore — it’s simpler and covers 80% of cases.
3. Room Database Basics (For Structured Data)
Room = SQLite abstraction. Use when you need queries, relationships, large data.
Core parts:
- Entity → Table (data class with @Entity)
- DAO → Interface with queries (@Dao)
- Database → Abstract class with @Database
Add dependencies (latest stable Room 2.8.4 as of Nov 2025 – still current in Jan 2026):
|
0 1 2 3 4 5 6 7 8 9 |
val room_version = "2.8.4" implementation("androidx.room:room-runtime:$room_version") implementation("androidx.room:room-ktx:$room_version") // Coroutines support ksp("androidx.room:room-compiler:$room_version") // or annotationProcessor if Java |
Example: Save favorite tips history
- Entity:
|
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
@Entity(tableName = "tips") data class TipEntry( @PrimaryKey(autoGenerate = true) val id: Int = 0, val billAmount: Double, val tipPercent: Int, val tipAmount: Double, val total: Double, val timestamp: Long = System.currentTimeMillis() ) |
- DAO:
|
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
@Dao interface TipDao { @Insert(onConflict = OnConflictStrategy.REPLACE) suspend fun insert(tip: TipEntry) @Query("SELECT * FROM tips ORDER BY timestamp DESC LIMIT 10") fun getRecentTips(): Flow<List<TipEntry>> @Query("DELETE FROM tips") suspend fun clearAll() } |
- Database:
|
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
@Database(entities = [TipEntry::class], version = 1, exportSchema = false) @TypeConverters(Converters::class) // If needed for custom types abstract class AppDatabase : RoomDatabase() { abstract fun tipDao(): TipDao companion object { @Volatile private var INSTANCE: AppDatabase? = null fun getDatabase(context: Context): AppDatabase { return INSTANCE ?: synchronized(this) { val instance = Room.databaseBuilder( context.applicationContext, AppDatabase::class.java, "tip_database" ).build() INSTANCE = instance instance } } } } |
- Usage in ViewModel:
|
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
class TipViewModel(private val dao: TipDao) : ViewModel() { val recentTips: Flow<List<TipEntry>> = dao.getRecentTips() fun saveTip(bill: Double, percent: Int, tip: Double, total: Double) { viewModelScope.launch { dao.insert(TipEntry(billAmount = bill, tipPercent = percent, tipAmount = tip, total = total)) } } } |
Observe in Composable: val tips by viewModel.recentTips.collectAsStateWithLifecycle(initialValue = emptyList())
4. Hands-on: Save and Retrieve User Data in Tip Calculator
Let’s integrate Preferences DataStore (save default tip % and last bill) + Room (save calculation history).
Steps:
- Add DataStore & Room dependencies.
- Create Preferences DataStore for defaults.
- Create Room for history.
- Update TipViewModel to load/save.
- Show history list in a new screen or bottom of calculator.
Quick Integration Snippet (in your TipViewModel):
|
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
class TipViewModel( private val dataStore: DataStore<Preferences>, private val tipDao: TipDao ) : ViewModel() { // Load defaults val defaultTipPercent = dataStore.data .map { it[PreferencesKeys.DEFAULT_TIP_PERCENT] ?: 15 } .stateIn(viewModelScope, SharingStarted.WhileSubscribed(), 15) // ... other state fun saveCalculation(bill: Double, percent: Int, tip: Double, total: Double) { viewModelScope.launch { tipDao.insert(TipEntry(billAmount = bill, tipPercent = percent, tipAmount = tip, total = total)) // Also save last bill dataStore.edit { prefs -> prefs[PreferencesKeys.LAST_BILL_AMOUNT] = bill } } } } |
In HomeScreen:
- Load last bill into TextField on start.
- After calculate → call viewModel.saveCalculation(…)
- Add a LazyColumn to show recent tips from Room.
This makes your app remember user prefs across sessions!
You’ve now got persistence! Play with it: Add delete history button, search tips, or encrypt sensitive data later.
Questions? Want to add migration from SharedPrefs? Proto DataStore example? Or Hilt injection for DataStore/Room? Tell me — next chapter: Networking & APIs (fetch real data). You’re building a proper app now — super proud of you! Keep going! 🚀💾
