by Jetpack DataStore is a data storage solution that allows you to store key-value pairs or typed objects with protocol buffers. DataStore uses Kotlin coroutines and Flow to store data asynchronously, consistently, and transactionally.
If you’re currently using SharedPreferences to store data, consider migrating to DataStore instead.
SharedPreferences comes with several drawbacks: a synchronous API that can appear safe to call on the UI thread, no mechanism for signaling errors, lack of transactional API, and more. DataStore is a replacement for SharedPreferences that addresses most of these shortcomings. DataStore includes a fully asynchronous API using Kotlin coroutines and Flow, handles data migration, guarantees data consistency, and handles data corruption.
SharedPreferences vs DataStore
As an Android developer, one of the key decisions you’ll encounter is choosing the appropriate data storage solution for your app. In the past, SharedPreferences has been the go-to solution for managing small amounts of simple data persistently. However, with the introduction of DataStore in Jetpack, developers now have a more robust and modern alternative. In this article, we’ll explore the differences between SharedPreferences and DataStore, and when to choose one over the other.
- SharedPreferences: SharedPreferences is a key-value pair storage mechanism provided by the Android framework.
- Ideal for storing simple, lightweight data such as user preferences, settings, and small configuration values.
- Offers synchronous read and write operations, making it straightforward to use.
- Limited support for complex data structures, which may require serialization/deserialization.
- Stored data is persisted as an XML file in the app’s private storage.
- DataStore: DataStore is a modern data storage solution introduced in Jetpack, designed to overcome the limitations of SharedPreferences.
- Built on Kotlin coroutines and Flow, offering asynchronous and non-blocking read and write operations.
- Supports storing complex data types directly, including objects and lists, without the need for serialization.
- Provides type safety and schema management, reducing the risk of runtime errors.
- Offers support for data encryption, making it suitable for storing sensitive information.
- Can be backed by either Preferences DataStore for key-value pairs or Proto DataStore for protocol buffer-based data.
| Feature | SharedPreferences | DataStore |
|---|---|---|
| Storage Method | XML files | Proto DataStore (protocol buffers) or Preferences DataStore (key-value pairs) |
| Asynchronous API | No, primarily synchronous with asynchronous commit | Yes, fully asynchronous with Kotlin coroutines |
| Type Safety | No, data retrieved manually as primitives | Yes, especially with Proto DataStore |
| Data Consistency | Prone to errors if not used carefully with concurrent access | Transactions ensure data consistency |
| Main Use Case | Simple key-value storage for small amounts of data | More complex or typed data, scalable storage solution |
| Thread Safety | Not inherently thread-safe | Designed to be thread-safe |
| Migration Support | N/A | Supports migration from SharedPreferences |
| Observability | Limited; listeners for changes but not lifecycle-aware | Lifecycle-aware, observable data streams |
| Security | Basic, relies on file permissions | Enhanced security with encryption options in Proto DataStore |
| Performance | Adequate for small datasets, can be slow with large data | Optimized for larger datasets and more efficient operations |
