Quando la mia app memorizza i dati localmente su un telefono, quanto è permanente quella memoria? Elaborerò la situazione esatta:
Sto costruendo un’app con jQueryMobile e PhoneGap. È essenzialmente un’app browser, ma l’utilizzo di PhoneGap mi consente di comprarlo e venderlo negli app store, tra gli altri vantaggi.
PhoneGap offre due modalità di archiviazione, entrambe le funzioni armonizzano le funzioni native di iOs, Android, Blackberry e altri sistemi operativi: localStorage (che è una coppia di valori-chiave primitivi) e un database Web SQL. Sia localStorage che Web SQL sono forms di archiviazione che appartengono al browser. Detto questo, non riesco a scoprire per quanto tempo i dati rimarranno archiviati, in quali circostanze verrà eliminato, in quali circostanze potrebbe non essere disponibile, ecc.
Ad esempio, se l’app memorizza i dati con localStorage o web SQL e l’utente passa a un browser standard diverso sul proprio dispositivo Android, l’app verrà aperta con il nuovo browser e ciò significa che i dati memorizzati non sono disponibili?
Se l’utente non usa l’app per un anno (che nel mio caso è uno scenario realistico e non necessariamente negativo), i dati sono scaduti come un cookie, o forse sono stati espulsi dalla memoria del browser da un diluvio di dati da altre app?
Oppure i dati verranno distrutti anche prima, ad esempio quando: – l’utente visita un altro sito nel browser – il browser viene chiuso manualmente – il processo del browser viene ucciso o muore – ecc.
Oppure sono localStorage e web SQL il tipo di archiviazione che elimini solo quando (in Android) vai in Impostazioni> App e rimuovi triggersmente i dati utente associati all’app?
Grazie per eventuali approfondimenti. Non c’è nulla di informativo là fuori sul vecchio WWW.
Cosa succede nel caso dell’aggiornamento dell’app. L’archivio locale e web verrà eliminato o rimarrà?
Lasciatemi rispondere passo dopo passo
se l’app memorizza i dati con localStorage o web SQL e l’utente passa a un browser standard diverso sul proprio dispositivo Android, l’app verrà aperta con il nuovo browser e ciò significa che i dati memorizzati non sono disponibili?
I dati vengono salvati nella ‘cache’ (non è esattamente la cache) del browser, quindi se cambi il browser o imposti le impostazioni in modo che il browser predefinito venga rimosso o modificato, i dati andranno.
Se l’utente non usa l’app per un anno (che nel mio caso è uno scenario realistico e non necessariamente negativo), i dati sono scaduti come un cookie, o forse sono stati espulsi dalla memoria del browser da un diluvio di dati da altre app?
No, i dati rimarranno lì, indipendentemente dal tempo in cui non vengono utilizzati. Quindi, anche se si cancella la cache del browser, sarà ancora lì.
Oppure i dati verranno distrutti anche prima, ad esempio quando: – l’utente visita un altro sito nel browser – il browser viene chiuso manualmente – il processo del browser viene ucciso o muore – ecc.
No, i dati stanno bene. 🙂
Oppure sono localStorage e web SQL il tipo di archiviazione che elimini solo quando (in Android) vai in Impostazioni> App e rimuovi triggersmente i dati utente associati all’app?
Sì, i dati vanno solo se lo elimini manualmente dalla tua app o disinstalli la tua app. Rimarrà in tutti gli altri casi.
MODIFICA: nel caso di iOS, il sistema operativo rimuoverà i dati nella memoria locale in caso di mancanza di memoria nel dispositivo.
A partire da iOS 5.1 la risposta di ghostCoder non è più valida. Apple ha deciso di spostare la posizione localstorage in una cartella cache che può essere svuotata in qualsiasi momento. Puoi seguire questa discussione qui:
Discussione di Google Gruppi su Localstorage
Anche questo blog spiega il problema in modo più dettagliato:
http://www.marco.org/2011/10/13/ios5-caches-cleaning
È ansible puntare manualmente la posizione della directory locale in una posizione Application_Home> / Documents sicura. Per determinare la posizione corrente della posizione corrente è ansible utilizzare qualcosa come questo:
NSString* localStorageSubdir = (IsAtLeastiOSVersion(@"5.1")) ? @"Caches" : @"WebKit/LocalStorage"; NSString* localStoragePath = [library stringByAppendingPathComponent:localStorageSubdir]; NSString* localStorageDb = [localStoragePath stringByAppendingPathComponent:@"file__0.localstorage"]; Il seguente codice ti consente di impostare un’altra posizione per la tua localstorage:
NSString* bundleIdentifier = [[mainBundle infoDictionary] objectForKey:@"CFBundleIdentifier"]; NSString* libraryPreferences = @"Library/Preferences"; NSString* appPlistPath = [[bundlePath stringByAppendingPathComponent:libraryPreferences] stringByAppendingPathComponent:[NSString stringWithFormat:@"%@.plist", bundleIdentifier]]; NSString *value; NSString *key = @"WebKitLocalStorageDatabasePathPreferenceKey"; value = [appPlistDict objectForKey: key]; if (![value isEqual:ourLocalStoragePath]) { [appPlistDict setValue:yourPreferredLocalStoragePath forKey:key]; }
Prova il plugin NativeStorage. https://www.npmjs.com/package/cordova-plugin-nativestorage .
Ha impostato, messo e ottenuto funzioni che implementano funzionalità di piattaforma come le preferenze condivise di Android e iOS NSUserDefaults che rendono l’archivio dati sicuro come consentito.
cordova plugin add cordova-plugin-nativestorage NativeStorage.putObject("reference_to_value",
Una buona soluzione disponibile ora è The Cordova Native Storage Plugin .
Consente un metodo semplice ma nativo persistente per salvare i dati in iOS e Android implementando in modo nativo SharedPreferences in Android e NSDefault in iOS per garantire l’affidabilità.
Uso:
Installazione:
cordova plugin add cordova-plugin-nativestorageMemorizzare i valori:
NativeStorage.setItem("reference_to_value",, , ); Recupero valori:
NativeStorage.getItem("reference_to_value",, );
Su Android è una memoria permanente per impostazione predefinita. Anche se l’utente aggiorna la tua app, rimane invariata.
L’utente può andare alle impostazioni e svuotare la cache e i dati nel qual caso va o se dice che una delle app pulite lo fa.
Anche su iOS è una memoria permanente ma non si conosce lo scenario di aggiornamento delle app. Ma nella versione precedente (5.1) non lo era e in 6+ hanno fatto in modo che potesse essere reso permanente attraverso una bandiera che è stata prontamente abilitata da Cordova / PhoneGap.
Non posso parlare per altre piattaforms, ma sul mio dispositivo Android 4.1, sto usando localStorage per archiviare alcuni dati localmente con jQuery Mobile, e ho scoperto che Android cancellerà la mia cache ogni settimana circa a mia insaputa. Ho intenzione di provare Web SQL e vedere se è meglio.
Ho trovato questo online ng-persist
Memorizza i dati sui dispositivi mobili (usando cordova) che persiste anche se l’utente reinstalla l’app
bower install ng-persist ngstorage --save
Iniettare $persist nel controller
.controller('MyCtrl', function($persist) { $persist .set(namespace, key, val) .then(function () { // saved }); // read $persist .get(namespace, key, fallback) .then(function (val) { // val is either the value, if exists, or the fallback }); // delete $persist .remove(namespace, key) .then(function () { // removed }); });
Sarebbe meglio in termini di prestazioni, sicurezza e affidabilità di AVOID utilizzando la memoria locale e utilizzare invece lo Cordova-sqlite-storage .
Alcune note:
localStorage ha il vantaggio di essere facile da usare, ma funziona in modo sincrono. Ciò significa che può bloccare il thread dell’interfaccia utente e causare prestazioni lente.
localStorage ha una quantità limitata di spazio di archiviazione, solitamente il suo 5mb.
localStorage può essere cancellato dal sistema operativo (Android, iOS) in qualsiasi momento. Questo è davvero serio se ti preoccupi della persistenza dei dati.
D’altra parte:
Cordova-sqlite-storage è asincrono e non bloccherà il thread dell’interfaccia utente, ma salva i dati nell’archivio nativo del dispositivo, la quantità di memoria non è limitata, il sistema operativo non cancellerà nessuno dei tuoi dati, a meno che tu non disinstalli l’app.