როგორ ინახავთ მონაცემებს ლოკალურად Android-ში?

Question

Accepted Answer

Android გთავაზობთ რამდენიმე **ლოკალური შენახვის** ვარიანტს სხვადსხვა საჭიროებებისთვის — **Room/SQLite** (სტრუქტურირებული მონაცემები), **DataStore/SharedPreferences** (გასაღები-მნიშვნელობის პარამეტრები), **ფайლები** და სხვა. სწორი ვარიანტის არჩევა მონაცემების ბუნების მიხედვით მნიშვნელოვანია.

## შენახვის ვარიანტები

```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)
```

## სწორი ვარიანტის არჩევა

```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.
```

## შიდა vs გარე შენახვა

```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)
```

## რატომ არის ეს მნიშვნელოვანი

Android-ში ლოკალური მონაცემების შენახვის გაცნობა ღირებული არის, რადგან **აპლიკაციებს ხშირად სჭირდებათ მონაცემების შენახვა მოწყობილობაზე** (კეშ, პარამეტრები, ოფლაინ მონაცემები, ტოკენები), ამიტომ ეს სასარგებლო პრაქტიკული ცოდნაა რეალური აპლიკაციების აშენებისთვის.

Android გთავაზობთ რამდენიმე ვარიანტს, რომელიც განსხვავებული საჭიროებებისთვის შესაფერი არის, ხოლო სწორი არჩევანი მნიშვნელოვანია.

გაცნობა **ვარიანტებს** — **Room** (რეკომენდირებული აბსტრაქცია SQLite-ზე სტრუქტურირებული, რელაციური ან დიდი მონაცემებისთვის შეკითხვებით), **DataStore** (თანამედროვე გასაღები-მნიშვნელობის/დაკრულ შენახვა პარამეტრებისთვის და პარამეტრებისთვის, ძველი SharedPreferences-ის ჩანაცვლება უფრო უსაფრთხო coroutine/Flow-დაფუძნებული API-თ), **ფайლები** (მედია და დოკუმენტებისთვის), და **დაშიფრული შენახვა/Keystore** (მგრძნობიარე მონაცემებისთვის) — და **რომელი დროს გამოიყენება** — ეს არის ძირითადი ცოდნა.

sწორი **ვარიანტის** არჩევა მნიშვნელოვანია: Room სტრუქტურირებული/რელაციური მონაცემებისთვის, DataStore პარამეტრებისთვის, ფайლები დოკუმენტებისთვის/მედიის ფორმატით, და აქვთ **დაშიფრული შენახვა მგრძნობიარე მონაცემებისთვის** როგორიცაა ავტორიზაციის ტოკენები და ხელმოწერილობები (რომელიც არ უნდა ინახებოდეს უბრალო SharedPreferences-ში ან ფაილებში — აქ მნიშვნელოვანი უსაფრთხოების წერტილი, საერთო შეცდომა).

გაცნობა **შიდა vs გარე შენახვას** (შიდა იყო პირადი და აპლიკაციის მიერ იზოლირებული, გარე იყო საერთო, მაგრამ მოითხოვს მოვლენას უფლებებითა და თანამედროვე scoped-storage შეზღუდვებით, რომელიც იცავს კონფიდენციალობას) ასევე მნიშვნელოვანია მონაცემების სათანადოდ შენახვისთვის და თანამედროვე Android-ის კონფიდენციალობის დაკავშირებული შეზღუდვებების დამუშავებისთვის.

შენახვის რესურსების შესაბამისობა მონაცემების სტრუქტურის, ზომის და მგრძნობიარობის მიხედვით ასახავს სწორი გადაწყვეტილებებს და თავს აარიდებს პრობლემებს (არასწორი ინსტრუმენტი, ან დაუცველად-შენახული საიდუმლოებები).

ვინაიდან აპლიკაციებს ხშირად სჭირდებათ ლოკალური მუდმივობა (სტრუქტურირებული მონაცემები, პარამეტრები, ფაილები, ტოკენები) და Android გთავაზობთ ვარიანტებს სხვადსხვა საჭიროებებისთვის, და ვინაიდან სათანადო არჩევა (განსაკუთრებით უსაფრთხო შენახვის გამოყენება მგრძნობიარე მონაცემებისთვის და scoped storage-ის პატივისცემა) მნიშვნელოვანია სწორი, უსაფრთხო აპლიკაციებისთვის, Android-ში ლოკალური მონაცემების შენახვის გაცნობა ღირებული, პრაქტიკულად შესაბამისი ცოდნაა — საერთო საჭიროება რეალურ აპლიკაციებში, მნიშვნელოვანი როგორც ფუნქციონალობისთვის (მონაცემების სათანადო ადგილზე შენახვა) და უსაფრთხოებისთვის (მგრძნობიარე მონაცემების დაცვა), და სასარგებლო აპლიკაციების აშენებისთვის, რომელიც ინახავს მდგომარეობას და სწორად მუშაობს ოფლაინ.