Applikationens interna minne: vad det är, sätt att lagra data och hur det fungerar i utveckling

Vad är applikationens interna minne?

Applikationens interna minne är en isolerad katalog som operativsystemet tilldelar varje applikation vid installationen. Andra applikationer och användaren har inte åtkomst till denna katalog via vanliga filhanterare. Systemet garanterar att data i denna katalog raderas helt vid avinstallation av applikationen. Detta tillvägagångssätt utgör grunden för säkerhetsmodellen i mobila operativsystem och förhindrar läckage av konfidentiell information mellan program.

Till skillnad från extern lagring (SD-kort) är internt minne alltid tillgängligt och kräver ingen kontroll av mediets existens. Läs- och skrivhastigheten i NAND-flashminne hos moderna enheter når 800–900 MB/s sekventiell läsning och 200–300 MB/s sekventiell skrivning, vilket är jämförbart med SATA SSD. Storleken på det tilldelade området beror på enhetens totala kapacitet och tillverkarens policy: på enheter med 64 GB flashminne får applikationen 16–64 MB initialt utrymme med möjlighet till expansion vid behov.

Arkitekturen för internt minne skiljer sig på Android och iOS. På Android får varje applikation en katalog /data/data/<package_name>/, inom vilken systemet skapar underkatalogerna files/, cache/ och databases/. På iOS fungerar applikationen i en sandlådecontainer med katalogerna Documents/, Library/ och tmp/, där var och en har sitt eget syfte och säkerhetskopieringspolicy.

Sätt att lagra data i internt minne

Utvecklare har flera sätt att spara data i applikationens interna minne. Varje metod löser en specifik uppgift och passar för en viss typ av data. Valet av rätt metod påverkar direkt applikationens prestanda, utvecklingsbekvämlighet och säkerheten för användardata.

Isolerad fillagring

Den lägsta nivån är direkt skrivning av filer till katalogen files. Applikationen kan skapa vilka filer och kataloger som helst i sin sandlåda. Denna metod passar för lagring av mediafiler, användardokument och alla binära data som inte kräver strukturerad organisering. På Android nås katalogen via anropet Context.getFilesDir(), som returnerar den absoluta sökvägen till applikationens filkatalog. På iOS utför NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES) en liknande funktion.

SharedPreferences och DataStore

För lagring av nyckel-värde-par erbjuder Android SharedPreferences och det modernare DataStore baserat på Kotlin-korutiner och protobuf-protokoll. SharedPreferences lagrar data i en XML-fil i katalogen /data/data/<package>/shared_prefs/. Trots enkelheten har SharedPreferences nackdelar: synkron skrivning kan orsaka fördröjningar på UI-tråden och avsaknaden av typ säkerhet ökar risken för fel. DataStore löser dessa problem genom att tillhandahålla asynkront API baserat på Flow och fullt typstöd via protobuf-scheman.

SQLite-databas och Room

För strukturerad data med relationskopplingar är SQLite eller omslaget Room det optimala valet. Databasen lagras i en enda fil i katalogen databases/ och stöder full SQL-syntax. Room är det officiella Jetpack-biblioteket som tillhandahåller typsäkert API, automatisk schemamigrering och stöd för korutiner. Databasens storlek kan nå flera gigabyte utan betydande prestandaförlust vid korrekt indexering. SQLite på mobila enheter hanterar upp till 50 000 skrivoperationer per sekund på en modern flaggskeppsprocessor.

EncryptedSharedPreferences

För lagring av känslig data, såsom autentiseringstoken och krypteringsnycklar, tillhandahåller Android EncryptedSharedPreferences. Detta omslag över standard SharedPreferences krypterar automatiskt nycklar och värden med AES256-GCM-None. Krypteringen sker på filnivå före skrivning till disk, så även vid fysisk åtkomst till enheten kan en angripare inte läsa innehållet. EncryptedSharedPreferences ingår i AndroidX Security-biblioteket, som även innehåller EncryptedFile för kryptering av hela filer.

Hur man arbetar med internt minne på Android

Android SDK tillhandahåller en uppsättning metoder för att arbeta med internt minne via klassen Context. Varje metod returnerar sökvägen till en specifik systemkatalog i applikationens sandlåda. Låt oss titta på grundläggande filskrivnings- och läsoperationer med ett exempel i Kotlin.

Åtkomst till filesDir via Context

Huvudmetoden för att få sökvägen till den interna filkatalogen är context.filesDir. Den returnerar ett File-objekt som pekar på katalogen /data/data/<package>/files/. Vid första anropet skapar systemet automatiskt alla nödvändiga överordnade kataloger. Storleken på filer i internt minne är inte explicit begränsad, men den totala datamängden bör inte överskrida det tillgängliga utrymmet på partitionen /data, som vanligtvis utgör 60–80% av enhetens totala flashminne.

val context = getApplicationContext()
val file = File(context.filesDir, "notes.txt")

file.writeText("Anteckningens innehåll")

val content = file.readText()
println("Läst: $content")

Metoderna writeText och readText är tilläggsfunktioner i Kotlins standardbibliotek. De hanterar automatiskt öppning och stängning av strömmar, vilket eliminerar minnesläckor. För binära data, använd writeBytes och readBytes, som inte kräver kodning och arbetar med ByteArray-arrayer. Vid arbete med stora filer rekommenderas buffrade strömmar: BufferedReader och BufferedWriter för text, BufferedInputStream och BufferedOutputStream för binära data.

Skapa underkataloger i internt minne

För att organisera filer i en hierarki, skapa underkataloger i filesDir. Detta hjälper till att strukturera data efter typ: bilder, dokument, exportfiler. Metoden mkdirs() skapar alla saknade kataloger i sökvägen, inklusive nästlade. Se till att skapandet lyckades — metoden returnerar true endast när nya kataloger skapas. Skapandefel beror oftast på brist på utrymme på partitionen /data eller slut på inoder i filsystemet.

val imagesDir = File(context.filesDir, "images")
if (imagesDir.mkdirs()) {
    println("Katalogen skapad")
}

val imageFile = File(imagesDir, "photo.jpg")
imageFile.writeBytes(byteArray)

För att kontrollera tillgängligt utrymme före skrivning av stora filer, använd File.getFreeSpace() eller File.getUsableSpace(). Den andra metoden returnerar antalet byte som är tillgängliga för den aktuella applikationen med hänsyn till säkerhetskvoter — den är mer exakt i sammanhanget med fleranvändarenheter. Om tillgängligt utrymme är mindre än förväntad filstorlek, visa ett meddelande för användaren och föreslå att frigöra utrymme i enhetens inställningar.

Hur man arbetar med internt minne på iOS

På iOS fungerar varje applikation i en isolerad sandlådecontainer. Systemet tillhandahåller inget API för att lämna dess gränser utan särskilda rättigheter. Huvudverktyget för att arbeta med filsystemet är klassen FileManager från Foundation-ramverket. Sandlådecontainern innehåller flera standardkataloger, var och en med sin egen säkerhetskopieringspolicy.

Åtkomst till Documents-katalogen via FileManager

Katalogen Documents är avsedd för användardata som ska bevaras mellan applikationens körningar och återställas från säkerhetskopia. iOS inkluderar automatiskt denna katalog i säkerhetskopiering till iCloud och iTunes. Metoden urls(for:in:) returnerar en array med URL-adresser till den begärda katalogen — det första elementet i arrayen är det primära.

let fm = FileManager.default
let docs = fm.urls(
    for: .documentDirectory,
    in: .userDomainMask
).first!

let fileURL = docs.appendingPathComponent("data.plist")
try data.write(to: fileURL)

FileManager stöder en full uppsättning filoperationer: skapa, kopiera, flytta, ta bort och byta namn. Varje operation kan kasta ett fel, så alla anrop måste omslutas i en do-catch-konstruktion. Var särskilt uppmärksam vid borttagning av filer — operationen är oåterkallelig och data efter removeItem(at:) kan inte återställas utan föregående säkerhetskopia.

Hantering av undantag från säkerhetskopiering

All data i sandlådecontainern bör inte hamna i iCloud-säkerhetskopian. Till exempel behöver cache för nedladdade bilder eller temporära bearbetningsfiler inte återställas — de kommer att skapas på nytt vid nästa användning. För att utesluta en katalog eller fil från säkerhetskopiering, ställ in attributet isExcludedFromBackup på true. Apple rekommenderar att alltid utesluta data som kan återställas på distans från säkerhetskopian för att minimera iCloud-lagringsutrymmet och minska återställningstiden.

var cacheURL = fm.urls(
    for: .cachesDirectory,
    in: .userDomainMask
).first!
cacheURL.hasExcludedFromBackupKey = true

var values = URLResourceValues()
values.isExcludedFromBackup = true
try cacheURL.setResourceValues(values)

Skillnader mellan internt minne, cache och extern lagring

Varje lagringstyp på en mobil enhet har sitt eget syfte och användningsregler. Att förstå dessa skillnader hjälper utvecklaren att välja rätt plats för varje typ av data. Nedan följer en jämförelse av tre huvudsakliga lagringstyper som är tillgängliga för applikationen.

Internt minne är optimalt för lagring av applikationskonfigurationer, databasfiler och användardokument som inte bör vara tillgängliga för andra program. Cache-katalogen är avsedd för temporära filer som kan återskapas vid nästa användning: nedladdade bilder, API-svar, mellanliggande bearbetningsdata. Extern lagring är mest lämplig för stora mediafiler (foton, videor, musik) och data som användaren vill dela med andra applikationer via gemensam åtkomst.

Valet av lagringstyp påverkar också applikationens betyg i Google Play och App Store. Applikationer som lagrar stora datamängder i internt minne utan rensning får negativa recensioner: användare klagar på brist på utrymme. Enligt App Annies forskning tar 62% av användarna bort en applikation om den upptar mer än 500 MB internt minne på enheten utan rensningsalternativ.

Rekommendationer för användning av internt minne

Korrekt hantering av applikationens interna minne ökar prestanda, säkerhet och användarupplevelse. Följande rekommendationer baseras på officiell dokumentation från Android och iOS samt praktisk erfarenhet av att utveckla applikationer med miljontals installationer.

• Minimera mängden lagrad data. Använd internt minne endast för kritiskt viktiga filer, placera resten i cache eller extern lagring
• Rensa regelbundet temporära filer. Kontrollera cache-katalogen vid varje start och ta bort filer äldre än 24 timmar — detta minskar systembelastningen och förhindrar överfyllnad av partitionen /data
• Kryptera känslig data med EncryptedSharedPreferences eller EncryptedFile från AndroidX Security-biblioteket. Lagring av token och lösenord i klartext är en vanlig sårbarhet som utnyttjas av trojaner med root-åtkomst
• Använd migrering vid uppdatering av filstrukturen. Vid utgivning av en ny version av applikationen, kontrollera förekomsten av gamla filer och flytta dem till nya kataloger innan du tar bort de gamla

Särskild uppmärksamhet bör ägnas åt testning av gränsfall. Testa applikationens beteende vid överfyllnad av internt minne, vid plötsligt avbrott i skrivning (applikationskrasch, samtal) och vid återställning från iOS-säkerhetskopia. I vart och ett av dessa scenarier måste data förbli konsekvent eller återställas till det senaste stabila tillståndet. Använd transaktionsfiler: skriv data till en temporär fil och byt sedan atomärt namn till målfilen. Detta förhindrar läsning av skadad data vid skrivfel.

Glöm inte användarkontroll. Tillhandahåll i applikationens inställningar ett alternativ för rensning av temporära data och visning av använt internt minne. Enligt Google Play Console får applikationer med denna funktion 18% fler positiva recensioner i kategorin "Prestanda".