Preferences

Android provides two different ways to save preferences:

Preferences DataStore - uses key-value pairs.
Proto DataStore - stores data as instances of a custom data type.

They are using kotlin flows and work asynchronously.

Preferences DataStore

1. Add gradle dependency

// Preferences DataStore (SharedPreferences like APIs)
    dependencies {
        implementation "androidx.datastore:datastore-preferences:1.0.0"

        // optional - RxJava2 support
        implementation "androidx.datastore:datastore-preferences-rxjava2:1.0.0"

        // optional - RxJava3 support
        implementation "androidx.datastore:datastore-preferences-rxjava3:1.0.0"
    }

    // Alternatively - use the following artifact without an Android dependency.
    // You must manually add Proguard rules to your proguard-rules.pro file 
    // to keep your fields from being deleted.
    dependencies {
        implementation "androidx.datastore:datastore-preferences-core:1.0.0"
    }

2. Create extension field for the android Context class, for example "dataStore" at the top level of your kotlin file:

 // Let the name of the datastore file be "settings".
val Context.dataStore: DataStore<Preferences> by preferencesDataStore(name = "settings")

3. You can use the following functions to create keys to access data. You can also define keys in a companion object.

val myStrKey = preferencesKey<String>("myStrKey")
val myStrKey = stringPreferencesKey("myStrKey")
val myLongKey = longPreferencesKey("myLongKey")
val myIntKey = intPreferencesKey("myIntKey")

4. Read data like this

val EXAMPLE_COUNTER = intPreferencesKey("example_counter")
val exampleCounterFlow: Flow<Int> = context.dataStore.data
  .map { preferences ->
    preferences[EXAMPLE_COUNTER] ?: 0  // No type safety.
}

5. Write data like this

suspend fun incrementCounter() {
  context.dataStore.edit { settings ->
    val currentCounterValue = settings[EXAMPLE_COUNTER] ?: 0
    settings[EXAMPLE_COUNTER] = currentCounterValue + 1
  }
}

Preferences DataStore example

val Context.authDataStore by preferencesDataStore("auth_settings")

class AuthPreferences(val context: Context) {

    val pincode: Flow<String> = context.authDataStore.data
        .map { preferences ->
            preferences[KEY_PINCODE] ?: ""
        }

    val login: Flow<String> = context.authDataStore.data
        .map { preferences ->
            preferences[KEY_LOGIN] ?: ""
        }

    val email: Flow<String> = context.authDataStore.data
        .map { preferences ->
            preferences[KEY_EMAIL] ?: ""
        }

    val phone: Flow<String> = context.authDataStore.data
        .map { preferences ->
            preferences[KEY_PHONE] ?: ""
        }

    val password: Flow<String> = context.authDataStore.data
        .map { preferences ->
            preferences[KEY_PASSWORD] ?: ""
        }


    suspend fun storeLogin(login: String) {
        context.authDataStore.edit { preferences ->
            preferences[KEY_LOGIN] = login
        }
    }

    suspend fun storePassword(password: String) {
        context.authDataStore.edit { preferences ->
            preferences[KEY_PASSWORD] = password
        }
    }

    suspend fun storePhone(phone: String) {
        context.authDataStore.edit { preferences ->
            preferences[KEY_PHONE] = phone
        }
    }

    suspend fun storeEmail(email: String) {
        context.authDataStore.edit { preferences ->
            preferences[KEY_EMAIL] = email
        }
    }

    suspend fun storePincode(pincode: String) {
        context.authDataStore.edit { preferences ->
            preferences[KEY_PINCODE] = pincode
        }
    }

    suspend fun storeAuth(authData: AuthData) {
        context.authDataStore.edit { preferences ->
            authData.apply {
                preferences[KEY_LOGIN] = login
                preferences[KEY_PASSWORD] = password
                preferences[KEY_EMAIL] = email
                preferences[KEY_PHONE] = phone
                preferences[KEY_PINCODE] = pincode
            }
        }
    }

    companion object {
        val KEY_LOGIN = stringPreferencesKey("login")
        val KEY_PASSWORD = stringPreferencesKey("password")
        val KEY_EMAIL = stringPreferencesKey("email")
        val KEY_PHONE = stringPreferencesKey("phone")
        val KEY_PINCODE = stringPreferencesKey("pincode")
    }

}

val authPref = AuthPreferences(applicationContext)
GlobalScope.launch {
    authPref.storePincode("1234")
}

// You can use AuthPreferences as data source class for repository class
// or as repository class within view model.

Web frontend

Web backend

JVM

JS

Programming

Mobiles

Graphics

Others

Android

Preferences

Preferences DataStore