In Android apps, we generally store simple data sets using local preferences. These preferences are simple, fast and easy to access. We either do it with SharedPreferences or DataStore Preferences. In a use case where we’re using SharedPreferences and we want to migrate to DataStore Preferences then it might affect many parts of our code.

So in this article we will:

• Create a separate module for our preferences and we’ll keep rest of the modules independent of which type of preferences we’re using
• Use Hilt for dependency injection from our preference module to our main app module

Use case for article

We’ll consider that:

• Our app simply accepts a user name
• As the user types the name, it is saved and updated immediately and displayed over a text view on the same screen.

Though this looks very simple but in a similar fashion we can have different types of preferences e.g UserDevicePreference, LoginPreference, AppPreference, etc.

In this architecture we’ve exposed only required end points to our main :app module related to a user’s preferences via UserPreference interface. Now the :app module don’t bother about how and where the data is stored.

DataStore Preference Set up

To add data store preferences, we need to add the dependency in local-preference build.gradle

Getting a data from data store returns a flow which is a great deal. Here we simply returns our saved user name as a flow. This is beneficial because any change in the user name will update our flow instantly and we can work on the latest changes.

Saving user name is also quite straightforward but to note that it is a suspend function and should be called within a coroutine scope.

Hilt Setup

We inject the data store object into the UserDataStore using Hilt. To add Hilt we need to add a plugin and dependency in local-preference build.gradle as shown below (same for :app module)

plugins {
    ...
    id 'kotlin-kapt'
}
...
dependencies {
    ...
    // hilt
    implementation "com.google.dagger:hilt-android:2.44"
    kapt "com.google.dagger:hilt-compiler:2.44"
}

And because this is a different module than :app module and both of our modules will use Hilt so we define the Hilt plugin commonly inside project level build.gradle file as follows:

plugins {
    ...
    id 'com.google.dagger.hilt.android' version '2.44' apply false
}

Coming back to our local-preference module, we provide our data store object as a singleton as follows:

@InstallIn(SingletonComponent::class)
@Module
object DataStoreModule {

    @Provides
    fun provideDataStore(@ApplicationContext context: Context) : DataStore<Preferences> {
        return PreferenceDataStoreFactory.create(
            corruptionHandler = ReplaceFileCorruptionHandler(
                produceNewData = { emptyPreferences() }
            ),
            produceFile = { context.preferencesDataStoreFile("user_data") }
        )
    }
}

And we provide the UserPreference object implementation as follows:

@InstallIn(ViewModelComponent::class)
@Module
abstract class UserPreferenceModule {

    @Binds
    abstract fun bindUserPreferences(impl: UserDataStore): UserPreference
}

// Local preferences
implementation project(path: ':local-preference')

@HiltAndroidApp
class DataStoreApplication: Application()

@HiltViewModel
class MainViewModel @Inject constructor(
    private val userPreference: UserPreference
) : ViewModel() {}

/**
 * username flow to observe changes in user name
 * */
val userName: StateFlow<String> = userPreference.userName().filter {
    it.isNotEmpty()
}
    .stateIn(
        viewModelScope,
        SharingStarted.WhileSubscribed(),
        "No saved data"
    )

/**
 * save user name
 * */
fun saveUserName(name: String) {
    viewModelScope.launch {
        userPreference.saveUserName(name)
    }
}

val userName: String by viewModel.userName.collectAsStateWithLifecycle()

implementation "androidx.activity:activity-ktx:1.6.1"