How do you store data locally in Android?

Question

Accepted Answer

Android offers several **local storage** options for different needs — **Room/SQLite** (structured data), **DataStore/SharedPreferences** (key-value settings), **files**, and more. Choosing the right one based on the data's nature is important.

## Storage options

```text
ROOM (over SQLite) → relational DATABASE for STRUCTURED data, queries, relationships:
  → the recommended way to store significant structured/relational data locally
DATASTORE → modern KEY-VALUE (and typed) storage for preferences/settings:
  → replaces SharedPreferences; coroutine/Flow-based, safer
SHARED PREFERENCES → older key-value storage (simple settings) — being superseded by
  DataStore
FILES → internal/external storage for files (app data, media, documents)
KEYSTORE / EncryptedSharedPreferences → SECURE storage for sensitive data (keys, tokens)
```

## Choosing the right option

```text
Structured/large/relational data, queries → ROOM (SQLite) — e.g. a cache of records,
  app data with relationships
Simple settings/preferences/flags → DATASTORE (or SharedPreferences)
Files (images, documents, downloads) → file storage (internal/external)
SENSITIVE data (auth tokens, credentials, keys) → ENCRYPTED storage / Keystore
  (don't store secrets in plain SharedPreferences/files)
→ Match storage to the data's structure, size, and sensitivity.
```

## Internal vs external storage

```text
INTERNAL → private to the app (sandboxed); removed when the app is uninstalled
EXTERNAL → shared storage (e.g. media); needs care with permissions and scoped storage
  (modern Android restricts broad external access for privacy)
```

## Why it matters

Understanding local data storage in Android is valuable because **apps commonly need to store data on the device** (caches, settings, offline data, tokens), so it's useful practical knowledge for building real apps.

Android offers several options suited to different needs, and choosing correctly matters.

Understanding the **options** — **Room** (the recommended abstraction over SQLite for structured, relational, or larger data with queries), **DataStore** (the modern key-value/typed storage for preferences and settings, replacing the older SharedPreferences with a safer coroutine/Flow-based API), **files** (for media and documents), and **encrypted storage/Keystore** (for sensitive data) — and **when to use each** is the key knowledge.

Choosing the **right option** matters: Room for structured/relational data, DataStore for settings, files for documents/media, and crucially **encrypted storage for sensitive data** like auth tokens and credentials (which must not be stored in plain SharedPreferences or files — an important security point, a common mistake).

Understanding **internal vs external storage** (internal being private and sandboxed to the app, external being shared but requiring care with permissions and modern scoped-storage restrictions that protect privacy) is also important for storing data appropriately and handling the privacy-related restrictions modern Android imposes.

Matching storage to the data's structure, size, and sensitivity reflects sound decisions and avoids problems (wrong tool, or insecurely-stored secrets).

Since apps commonly need local persistence (structured data, settings, files, tokens) and Android offers options for different needs, and since choosing appropriately (especially using secure storage for sensitive data and respecting scoped storage) is important for correct, secure apps, understanding local data storage in Android is valuable, practically-relevant knowledge — a common need in real apps, important for both functionality (storing the right data the right way) and security (protecting sensitive data), and useful for building apps that persist state and work offline correctly.