SharedPreferences

interface SharedPreferences

Interface for accessing and modifying preference data returned by Context.getSharedPreferences. For any particular set of preferences, there is a single instance of this class that all clients share. Modifications to the preferences must go through an Editor object to ensure the preference values remain in a consistent state and control when they are committed to storage. Objects that are returned from the various get methods must be treated as immutable by the application.

Note: The Android team strongly recommends against using SharedPreferences for new data storage needs. Instead, consider using Jetpack DataStore for storing small amounts of data, or Room for relational data and larger datasets.

There are several significant drawbacks to using SharedPreferences:

• UI Thread Blocking and ANRs: Since SharedPreferences provides a synchronous API, reading and writing to disk can block the UI thread, leading to jank and StrictMode violations. Additionally, pending Editor.apply() calls will block the main thread during component lifecycle transitions (such as when Activities or Services start or stop) to ensure data is persisted. This is a common source of Application Not Responding (ANR) errors.
• Error Handling: The asynchronous Editor.apply() method has no mechanism to signal errors to the caller. The synchronous Editor.commit() method only returns a boolean, providing no detailed information about failures, and can sometimes return false even when a write succeeds.
• Durability and Consistency: Changes are reflected in memory immediately, before being successfully persisted to disk. This can result in data loss if the app crashes or is terminated. For instance, a user might change a privacy-sensitive preference, but if the app terminates before the change is durably written, the app will load the old value upon restart. Furthermore, the lack of transactional semantics makes operations like incrementing a counter unsafe without external locking.
• Data Safety: Data corruption can lead to silent failures or uncatchable exceptions. Additionally, writing malformed UTF-16 strings (such as unpaired surrogates) can result in silent data corruption. Modifying the collections returned by methods like getStringSet(String,Set) can also lead to unexpected behavior and crashes.

Note: This class does not support use across multiple processes.

Summary

Public methods

abstract fun contains(key: String!): Boolean

abstract fun edit(): SharedPreferences.Editor!

abstract fun getAll(): MutableMap<String!, *>!

abstract fun getBoolean(
    key: String!, 
    defValue: Boolean
): Boolean

abstract fun getFloat(
    key: String!, 
    defValue: Float
): Float

abstract fun getInt(
    key: String!, 
    defValue: Int
): Int

abstract fun getLong(
    key: String!, 
    defValue: Long
): Long

abstract fun getString(
    key: String!, 
    defValue: String?
): String?

abstract fun getStringSet(
    key: String!, 
    defValues: MutableSet<String!>?
): MutableSet<String!>?

abstract fun registerOnSharedPreferenceChangeListener(listener: SharedPreferences.OnSharedPreferenceChangeListener!): Unit

abstract fun unregisterOnSharedPreferenceChangeListener(listener: SharedPreferences.OnSharedPreferenceChangeListener!): Unit