📖Offline Persistenz

Die Speicherung von Daten Offline hat Vor- / Nachteile. Anbei einige Argumente:

VorteileNachteile

lokale Daten

keine resp. nur schlechte Teilbarkeit

Keine Internet-Verbindung nötig

Limitierung bei Multi-User

Für kleine Daten optimal

Mühsame Verwaltung (Release-Upgrades)

Es gibt online sehr viele Tutorials welche z.B. ein Offline-Modus mit SQLite oder native Lösungen mit Ionics Native Storage resp. wiederum SQLite als Native Komponente beschreiben. Oft macht deren Einsatz Sinn, wenn man grosse Daten resp. Objekte (z.B. in JSON) speichern möchte. Für kleinere Daten funktioniert in Ionic resp. Cordova auch der HTML 5 local Storage.

HTML5 - lokaler Storage

Normalerweise kann man den HTML5 Local Storage in etwa so einsetzen:

if(typeof(Storage) != "undefined") {
    localStorage.setItem("vorname", "Max");
    localStorage.setItem("nachname", "Muster");
    alert(localStorage.getItem("vorname") + " " + localStorage.getItem("nachname"));
} else {
    alert("Sorry, dein Browser unterstützt kein Web Storage...");
}

Ionic Storage

Ionic hat auch fürs Persistieren von einfachen Daten eine Lösung bereit:

API

Mit den asynchronen Methoden storage.set(..) storage.get(..) kannst du einfache Key/Value-Paare oder JSON Objekte speichern. Beachte das hier await verwendet wird und die Methode somit mit async deklariert werden muss.

import { Storage } from '@ionic/storage-angular';

export class MyApp {
  constructor(private storage: Storage) { }
  
  async saveNameToStorage() {
    // set a key/value
    await storage.set('name', 'Max');
  }
  
  async loadAgeFromStorage() {
    // Or to get a key/value pair
    const age = await storage.get('age');
  }


}

@ionic/storage-angular im Projekt verwenden

Damit du @ionic/storage-angular in deinem Projekt verwenden kannst. Empfehlen sich folgende Schritt:

  1. Installiere @ionic/storage-angular mittels NPM in deinem Projekt

    npm install @ionic/storage-angular --save

  2. Füge IonicStorageModule.forRoot() unter imports im ngModule in der Datei app.module.ts hinzu. Beispiel: 

    // Importieren
import { IonicStorageModule } from '@ionic/storage-angular';

@NgModule({
  declarations: [AppComponent],
  entryComponents: [],
  imports: [
    BrowserModule,
    IonicModule.forRoot(),
    AppRoutingModule,
    // Neu hinzufügen
    IonicStorageModule.forRoot(),
  ],
  providers: [
    { provide: RouteReuseStrategy, useClass: IonicRouteStrategy },
    { provide: HAMMER_GESTURE_CONFIG, useClass: HammerConfig } 
  ],
  bootstrap: [AppComponent]
})
export class AppModule {}

  3. Erstelle für den Storage eine eigenen, neuen Service welcher dir hilft Daten zu speichern/lesen:

    ionic generate service _services/storage

  4. Ergänze bei dein Imports im App Module (app.module.ts) folgendes:

      imports: [
    ...
    IonicStorageModule.forRoot()
    ...
  ]

  5. Der Service sollte in etwa so aussehen:

    import { Injectable } from '@angular/core';

import { Storage } from '@ionic/storage-angular';

@Injectable({
  providedIn: 'root'
})
export class StorageService {
  private _storage$: Promise<Storage>;

  constructor(private storage: Storage) {
    this.init();
  }

  init() {
    this._storage$ = this.storage.create();
  }

  public async set(key: string, value: any) {
    (await this._storage$).set(key, value);
  }

  public async get(key: string): Promise<any> {
    return (await this._storage$).get(key)
  }

}

  6. Verwende nun den Service in deiner erstellten Page, indem du ihn über den Konstruktor einfügst und importierst:

    import { Component, OnInit } from '@angular/core';
// Importieren
import { StorageService } from '../_services/storage.service';


@Component({
  selector: 'app-local-storage',
  templateUrl: './storage.page.html',
  styleUrls: ['./storage.page.scss'],
})
export class StoragePage implements OnInit {
  name: string;
  pushToggle: boolean;
  newsletterToggle:boolean;

  constructor(private storageService: StorageService) {}
  
 // TODO: ... 
 
}

Data Storage in Capacitor

Mittels Capacitors hast du die Möglichkeit auf native Funktionalitäten wie Preferences zuzugreifen. Preferences sind Key-Value Stores in welchen einfache Datentypen gespeichert werden können.

Gerade in unserem Projekt ist die Verwendung von Capacitor Preferences äussert empfehlenswert. Um dennoch Objekte abspeichern zu können, ist die Verwendung von JSON ratsam. Weitere Ausführung und Möglichkeiten, die du mit dem Capacitor-Preferences plugin findest du unter der unten angegebenen Doku.

import { Preferences } from '@capacitor/preferences';

// JSON "set" example
// Object parsed with JSON.stringfy to string
async setObject() {
  await Preferences.set({
    key: 'user',
    value: JSON.stringify({
      id: 1,
      name: 'Max'
    })
  });
}

// JSON "get" example
async getObject() {
  const ret = await Preferences.get({ key: 'user' });
  const user = JSON.parse(ret.value);
}

Für grosse Daten gibt es noch die Möglichkeit capacitor-sqlite zu verwenden.

PreviousOnline PersistenzNextTesting

Last updated