Synchronisieren von Offline-Änderungen mit Mobile Sync

Lernziele

Nachdem Sie diese Lektion abgeschlossen haben, sind Sie in der Lage, die folgenden Aufgaben auszuführen:

Erläutern der grundlegenden Mobile Sync-Konzepte
Verwenden der Mobile Sync-Bibliothek zum Synchronisieren von Daten zwischen dem lokalen Gerät des Benutzers und dem Salesforce-Server

Verwenden von Mobile Sync zum Synchronisieren von Offline-Änderungen

Das Mobile Sync ist eine Mobile SDK-Bibliothek, die mit SmartStore zusammenarbeitet, um die Integrität und Konsistenz von Salesforce-Datensätze zu garantieren. Mobile Sync ermöglicht Kunden, die Mobile SDK-Anwendungen verwenden, Salesforce-Datensätze lokal weiter zu bearbeiten, wenn ihre mobilen Geräte keine Netzwerkverbindung mehr haben. Nach Wiederherstellung der Verbindung verwendet die Mobile SDK-Anwendung das Framework, um lokale Änderungen in SmartStore mit den entsprechenden Datensätzen auf dem Salesforce-Server zu synchronisieren.

Informationen zu Netzwerkanforderungen

Alle Datenanforderungen in Mobile Sync-Anwendungen sind asynchron. Synchronisierungsmethoden formatieren die Anforderung und senden sie an die Salesforce-Cloud. Ihre Anwendung empfängt die Antwort des Servers je nach Plattform in einer Rückrufmethode, einem Aktualisierungsblock oder einer Zusage. Zu den Antworten gehört ein Synchronisierungsstatusobjekt, das die Einstellungen und den Status des Synchronisierungsvorgangs beschreibt.

Mobile Sync-Methoden automatisieren allgemeine Netzwerkaufgaben wie das Abrufen von sObject-Metadaten oder einer Liste der zuletzt verwendeten Objekte sowie das Ausstellen von SOQL- und SOSL-Abfragen. Die Anwendung kann jederzeit Synchronisierungs-Manager-Methoden aufrufen, aber offensichtlich sind sie nur erfolgreich, wenn das Host-Gerät mit dem Internet verbunden ist. Die Anwendung muss den Verbindungsstatus des Geräts ermitteln.

Konfigurieren von Anwendungen für das Verwenden von Mobile Sync

Mobile SDK-Anwendungen verwenden ein zentrales SDK-Manager-Objekt, um den ordnungsgemäßen Start der Anwendung und die gewünschten Authentifizierungsprotokolle zu erzwingen. Der von Ihrer Anwendung verwendete Manager bestimmt auch den Umfang der in der Anwendung enthaltenen SDK-Funktionalität. Anwendungen initialisieren das MobileSyncSDKManager-Objekt während der Bootstrap-Initialisierung.

Native Android und iOS SDKs implementieren drei Manager-Objekte.

SalesforceSDKManager

Für die meisten einfachen Anwendungen. Diese Anwendungen verwenden keine Offline-Funktionen des Mobile SDK.

SmartStoreSDKManager

Für Anwendungen, die SmartStore aber nicht Mobile Sync verwenden.

MobileSyncSDKManager

Für Anwendungen, die sowohl SmartStore als auch Mobile Sync verwenden.

Wenn Sie eine native Anwendung mit forcedroid oder forceios erstellen, wird Ihre neue Anwendung automatisch für die Verwendung von MobileSyncSDKManager konfiguriert. Dieser Manager importiert SmartStore, MobileSync und alle anderen Mobile SDK-Bibliotheken.

Synchronisierungskonfiguration

Unabhängig davon, ob Sie aufwärts von SmartStore nach Salesforce oder abwärts von Salesforce nach SmartStore synchronisieren, stellen Sie Konfigurationsdetails für die Synchronisierung bereit. Sie können einen Synchronisierungsvorgang entweder im Code oder in einer JSON-Konfigurationsdatei konfigurieren. In beiden Fällen gibt das Mobile SDK zur Laufzeit Ihre Konfiguration in einem Synchronisierungsstatusobjekt an die Anwendung zurück.

Im einfachsten Fall geben Sie Folgendes an:

store: Gibt an, ob Sie einen globalen oder einen Benutzer-Store verwenden. Wenn Sie einen benannten Store verwenden, geben Sie auch dessen Namen an.
soup name: Name der Soup, die die Quelle eines Aufwärtssynchronisierungsvorgangs oder der Empfänger eines Abwärtssynchronisierungsvorgangs ist. Die Soup muss ein indiziertes Zeichenfolgefeld namens __local__ unterstützen.

Zwei weitere Parameter legen fest, was die Synchronisierung bewirkt:

target: Beschreibt, welche Datensätze Sie synchronisieren. Das Ziel ist der zentrale Konfigurationswert für jede Synchronisierung. Stellen Sie sich ein Ziel als Beschreibung des Datenumfangs vor, den Ihr Vorgang erfordert.
options:: Steuert, wie der Vorgang Daten zusammenführt. In bestimmten Fällen können Sie anstelle eines Ziels Optionen verwenden, um eine Liste von Feldnamen für die Synchronisierung bereitzustellen.

Die Verwendung der Parameter target und options unterscheidet sich bei einer Aufwärts- und Abwärtssynchronisierung, wie in den folgenden Abschnitten beschrieben. In bestimmten Fällen kann der eine oder andere Parameter optional sein. Wenn Sie die optionalen Angaben target oder options weglassen, nimmt Mobile Sync einen Standardwert an.

Nach Abschluss eines Synchronisationsvorgangs erhält die Anwendung asynchrone Benachrichtigungen, mit denen Folgeaufgaben ausgeführt werden können. Zu diesen Aufgaben zählt z. B. das Versenden von Ereignisbenachrichtigungen oder das anders geartete Verwenden der Daten zur Erweiterung der Anwendung.

Abwärtssynchronisierung: "target" und "options"

target:: Gibt den sObject-Quelltyp und die Felder an, die in die Soup heruntergeladen werden sollen. Folgende Zeichenfolgen stehen zur Auswahl:
- für SOQL-Abfragen: {type:"soql", query:"<soql_query>"}
  Herunterladen der von der angegebenen SOQL-Abfrage zurückgegebenen sObjects
- für SOSL-Abfragen: {type:"sosl", query:"<sosl_query>"}
  Herunterladen der von der angegebenen SOSL-Abfrage zurückgegebenen sObjects
- für MRU-Abfragen: {type:"mru", sobjectType:"<sobject_type>", fieldlist:"<fields_to_fetch>"}
  Herunterladen der angegebenen Felder der zuletzt verwendeten sObjects des angegebenen sObject-Typs Das Mobile SDK sendet die Anforderung an Salesforce, empfängt die Antwort und verwendet Ihre Konfiguration, um Ihre Soup aufzufüllen.
options (optional): Zuordnung mit dem folgenden Schlüssel:
- mergeMode: Um zu steuern, wie Mobile Sync Daten zu lokalen Soups zusammenführt, setzen Sie diesen Schlüssel auf einen der folgenden Modi:
  Overwrite
  (Standard) Überschreibt Datensätze, die geändert wurden. Wenn Sie keinen Zusammenführungsmodus angeben, überschreibt Mobile Sync lokale Daten.
  Leave if changed
  Behält Datensätze bei, die geändert wurden. Dieser Modus erfordert zusätzliche Roundtrips zum Server, weshalb Sie ihn mit Vorsicht verwenden sollten.

Aufwärtssynchronisierung: "target" und "options"

target (optional): Zuordnung zu einem oder beiden der folgenden Schlüssel:
- createFieldlist: Durch Komma getrennte Namen von Soup-Feldern, deren Werte in neu erstellte Salesforce-Datensätze eingefügt werden sollen. Kann gesperrte (schreibgeschützte) Felder enthalten.
- updateFieldlist: Durch Komma getrennte Namen von Soup-Feldern, die zum Aktualisieren beschreibbarer Felder in vorhandenen Salesforce-Datensätzen verwendet werden sollen. Darf keine gesperrten (schreibgeschützten) Felder enthalten.
target ist bei einigen Aufwärtssynchronisierungsmethoden nicht erforderlich. In diesen Fällen verwenden Sie den Schlüssel fieldlist in options, um die zu synchronisierenden Felder anzugeben.
options (optional): Zuordnung zu einem oder beiden der folgenden Schlüssel:
- fieldlist:: Durch Kommas getrennte Liste der Soup-Feldnamen, die Sie an den Server senden. Sie können diesen Schlüssel anstelle der Feldlisten für target oder mit createFieldList Ihres Ziels verwenden. Vergewissern Sie sich, dass Ihr Aufwärtssynchronisierungsvorgang keine schreibgeschützten Felder auf dem Server aktualisiert.
- mergeMode: Um zu steuern, wie Mobile Sync lokale Daten mit der Salesforce-Organisation zusammenführt, setzen Sie diesen Schlüssel auf einen der folgenden Modi:
  Overwrite
  (Standard Einstellung) Überschreibt Serverdatensätze, die geändert wurden.
  Leave if changed
  Behält Serverdatensätze bei, die geändert wurden. Dieser Modus erfordert zusätzliche Roundtrips zum Server, weshalb Sie ihn mit Vorsicht verwenden sollten.

Store-Parameter

Hybride und React Native-Anwendungen geben den von ihnen verwendeten Store mit dem optionalen Parameter storeConfig an. Dieser Parameter gilt für Aufwärts- und Abwärtssynchronisierungsvorgänge. Sie können ihn auf eine von zwei Arten angeben.

Als Zuordnung der folgenden Schlüssel-Wert-Paare:

isGlobalStore (optional): Boolescher Wert, der angibt, ob Sie einen globalen Store (true) oder Benutzer-Store (false) verwenden. Der Standardwert lautet false.
storeName (optional): Name des Stores. Der Standardwert ist der Name des Standard-Stores.

Beispiel:

{"isGlobalStore" :false, "storeName" :"MyStore"}

Als booleschen Wert:

Sie können stattdessen einen einfachen booleschen Wert übergeben. In diesem Fall weist Mobile SDK den Wert dem Schlüssel isGlobalStore zu.

Wenn Sie den store-Parameter weglassen, wendet Mobile Sync Vorgänge auf den aktuellen Benutzer-Store an.

Verwenden von benannten Synchronisierungen und Synchronisierungskonfigurationsdateien

Standardmethoden für Auf- und Abwärtssynchronisierung erfordern, dass Sie jeden Synchronisierungsparameter als separates Argument übergeben. Mobile SDK bietet zwei Funktionen, die Ihnen helfen, diese Synchronisierungsaktivitäten zu organisieren und zu optimieren. Diese Funktionen sind Synchronisierungsnamen und Synchronisierungskonfigurationsdateien, die bei minimalem Aufwand viel Nutzen für Sie bereithalten. Obwohl Sie keine Konfigurationsdateien verwenden müssen, verwenden wir sie in diesem Trail umfassend.

Um eine Synchronisation erneut auszuführen, wenden Sie die Methode reSync der Plattform an. Methoden für eine erneute Synchronisierung arbeiten mit einem dieser Bezeichner, um Ihre Konfiguration nachzuschlagen:

Sync ID: Jede Synchronisierungsmethode gibt eine Laufzeit-ID als Teil eines Statusobjekts zurück. Sie können diese ID an reSync übergeben, um eine Synchronisation, die Sie in der aktuellen Sitzung bereits verwendet haben, erneut auszuführen.
Sync name (optional): Sie können eine Synchronisierungskonfiguration ausführen und bei der ersten Ausführung im Arbeitsspeicher speichern oder den Namen und die Synchronisierungskonfiguration aus einer externen JSON-Konfigurationsdatei importieren.

Synchronisierungsnamen

Die Konfiguration von Synchronisierungsvorgängen kann kompliziert sein, und sie werden häufig wiederverwendet. Synchronisierungsnamen ermöglichen es Ihnen, Ihre Synchronisierungen auf bequeme Art und Weise erneut auszuführen, ohne dass Sie sie neu codieren müssen. Mithilfe von Synchronisierungsnamen können Sie beispielsweise die folgenden Aufgaben erledigen:

Konfigurieren von Synchronisierungsvorgängen in einer externen JSON-Datei und nicht in Code
Erneutes Ausführen eines zuvor verwendeten Synchronisierungsvorgangs ohne erneute Konfiguration
Abrufen des Status eines laufenden Synchronisierungsvorgangs
Überprüfen des Vorhandenseins eines Synchronisierungsvorgangs
Löschen einer Synchronisierungskonfiguration

Sie können benannte Synchronisierungen entweder mit APIs oder in Synchronisierungskonfigurationsdateien erstellen. Das Mobile SDK unterstützt benannte Synchronisierungen auf allen Plattformen für alle Anwendungstypen.

Synchronisierungskonfigurationsdateien

Mithilfe von Synchronisierungskonfigurationsdateien können Sie statische Aufwärts- und Abwärtssynchronisierungsdefinitionen einmal in eine JSON-Datei schreiben und dann in alle Versionen Ihrer Anwendungen importieren. Das Mobile SDK unterstützt in nativen und hybriden Anwendungen Konfigurationsdateien für die Synchronisierung. Werfen wir einen Blick auf die Struktur und Regeln für diese Dateien.

Dateinamen

Das Mobile SDK unterstützt Konfigurationsdateien nur für den Standard-Store "Global" und den Standard-Store "User".

Geben Sie für den Standard-Store "Global" eine Datei namens globalsyncs.json an.
Geben Sie für den Standard-Store "User" eine Datei namens usersyncs.json an.

Dateipfade

Legen Sie Ihre Konfigurationsdateien an den folgenden Speicherorten ab.
iOS:

Native und React Native-Anwendungen: / im Bundle "Resources"
Hybride Anwendungen: /www im Bundle "Resources"

Android:

Native und React Native-Anwendungen: /res/raw
Hybride Anwendungen: /assets/www

Dateiformat

Das Dateiformat ist unabhängig von Anwendungstyp und Zielplattform gleich. Eine Synchronisierungsdefinition hat fünf Pflichtfelder:

Synchronisierungsname
Synchronisierungstyp
Soup-Name
Ziel
Optionen

Mit der folgenden Konfigurationsdatei werden Abwärts- und Aufwärtssynchronisierungsvorgänge definiert. Beiden Konfigurationen weisen dieselben Felder auf: Id, Name und LastModifiedDate. Beachten Sie jedoch zwei wichtige Regeln für die Positionierung der Werte:

Die Konfiguration der Abwärtssynchronisierung gibt die Felder im Member "target" mittels einer SOQL-Abfrage an, während sie bei der Aufwärtssynchronisierung unter "options" als Liste angegeben werden.
Beim Abwärtssynchronisierungsvorgang wird der Zusammenführungsmodus in "options" festgelegt, während beim Aufwärtssynchronisieren das Gleiche in "merge_mode" geschieht.

Gegensätzliche Zusammenführungsmodi wie "OVERWRITE" für Abwärtssynchronisieren und "LEAVE_IF_CHANGED" für Aufwärtssynchronisieren garantieren eine einzige Quelle der Wahrheit. In diesem Fall erlauben sie, dass Serverdaten Soup-Daten überschreiben, aber nicht umgekehrt.

{
  "syncs": [
    {
      "syncName": "sync1",
      "syncType": "syncDown",
      "soupName": "accounts",
      "target": {"type":"soql", "query":"SELECT Id, Name, LastModifiedDate 
        FROM Account"},
      "options": {"mergeMode":"OVERWRITE"} 
    },
    {
      "syncName": "sync2",
      "syncType": "syncUp",
      "soupName": "accounts",
      "target": {"createFieldlist":["Name"]},
      "options": {"fieldlist":["Id", "Name", "LastModifiedDate"],
      "mergeMode":"LEAVE_IF_CHANGED"}
    }
  ]
 }

Verwenden von Mobile Sync mit Aktenkoffern

Unter einem Aktenkoffer versteht man eine Reihe von Abfragen, die zusammen eine zusammenhängende Sammlung verwandter Datensätze auswählen, die für das gewünschte Abfrageergebnis optimiert sind. Sie können Aktenkoffer verwenden, um Datensätze für das Daten-Priming abzurufen, bevor Sie offline gehen, sowie für andere allgemeine Datenladezwecke auszuwählen.

Synchronisierungskonfiguration

In der Mobile Sync Explorer Template App können Sie die JSON-Datei der Benutzersynchronisierung ändern, um Ihre Abwärts- und Aufwärtssynchronisierungen zu konfigurieren.

Geben Sie für die Eigenschaft "target" folgende Werte an:

Zieleigenschaften

"type":"briefcase"

"infos": Array von <BriefcaseObjectInfo>-Elementen

Ein Array von Objekten, die die spezifischen sObjects und Felder beschreiben, die abgerufen werden sollen, sowie die Soup, in der sie platziert werden sollen

BriefcaseObjectInfo-Eigenschaften

"soupName": <string>

Name der Soup oder Tabelle für die Speicherung von Datensätzen dieses Objekttyps während der Synchronisierung

"sobjectType": <string>

Name eines zu synchronisierenden Salesforce-Objekts

"fieldlist": Array von <string>

Liste mit Feldern, die für dieses Objekt synchronisiert werden sollen

"idFieldName": <string>

(Optional) Name eines benutzerdefinierten ID-Felds. Wenn Sie "idFieldName" angeben, verwendet Mobile Sync das Feld mit dem angegebenen Namen, um die ID des Datensatzes abzurufen. Wenn Sie beispielsweise "idFieldName":"AcmeId" angeben, ruft Mobile Sync die Datensatz-ID aus dem Feld "AcmeId" anstelle des standardmäßigen ID-Felds ab.

"modificationDateFieldName": <string>

(Optional) Name des Felds, das das Datum der letzten Änderung des Datensatzes enthält. Wenn Sie "modificationDateFieldName" angeben, verwendet Mobile Sync das Feld mit diesem Namen zum Berechnen des "maxTimestamp"-Werts, den "startFetch" zur erneuten Synchronisierung der Datensätze verwendet. Der Standardfeldname lautet "lastModifiedDate".

Erforderlich: "soupName", "sobjectType", "fieldlist"

Abwärtssynchronisierung

Wenn Ihre Organisation Aktenkoffer für Ihre mobilen Benutzer verwendet, dann wurde das Abwärtssynchronisierungsziel "Briefcase" in Mobile SDK 10.1 eingeführt.

Sehen wir uns ein Beispiel für eine Briefcase-Datei an, die für die Abwärtssynchronisierung konfiguriert ist.

{
  "syncs": [
    {
      "syncName": "syncDownContacts", 
      "syncType": "syncDown",
      "soupName": "contacts",
      "target": {
        "type": "briefcase",      
        "infos": [
          {
            "sobjectType": "Account",
            "fieldlist": [
              "Name",
              "Description"
            ],
            "soupName": "accounts"
          },
          {
            "sobjectType": "Contact",
            "fieldlist": [
              “FistName”, "LastName", “Title”, “Email”
            ],
            "soupName": "contacts"
          }
        ]
      },
      "options": {
        "mergeMode": "OVERWRITE"
      }
    }
  ]
}

Für die Abwärtssynchronisierung definieren Sie den"syncType" als "syncDown". Dies aktiviert den Abwärtssynchronisierungsvorgang, der Daten vom Server abruft und mit dem Client synchronisiert. Neben "syncName" können Sie einen Namen für Ihren Abwärtssynchronisierungsvorgang angeben. In diesem Fall wird der Name "syncDownContacts" verwendet.

Neben "soupName" definieren Sie die Tabelle oder Soup, die aktualisiert werden soll, wenn der Abwärtssynchronisierungsvorgang stattfindet. In diesem Fall soll die Soup "contacts" aktualisiert werden.

Unter "target" legen Sie den Zieltyp als "briefcase fest. Unter dem JSON-Objekt "infos" können Sie die Entitäten definieren, die synchronisiert werden sollen. In diesem Fall sind dies "Account" und "Kontakt". Für jede Entität geben Sie die zu synchronisierenden Feld unter "fieldlist" an.

Für jede Entität geben Sie die zugehörige Tabelle, die auf dem Client aktualisiert werden soll, neben "soupName" an.

Unter "options" können Sie die Option "mergeMode" definieren, die in diesem Fall auf "OVERWRITE" festgelegt wird. Wenn zwei Benutzer versuchen, denselben Datensatz zu aktualisieren, bekommt bei dieser Einstellung der Benutzer Vorrang, der den Datensatz zuletzt aktualisiert hat.

Aufwärtssynchronisierung

Sehen wir uns nun die Konfiguration für die Aufwärtssynchronisierung an.

{
“syncName: “syncUpContacts”,
“syncType”: “syncUp”,
“soupÑame”: “contacts”,
“target”: {
	“createFieldlist”: [
		“FirstName”, “LastName”, “Title”, “Email”
	]
},
“options”: {
	“fieldlist”: [
		“FirstName”, “LastName”, “Title”, “Email”
	],
	“mergeMode”: “LEAVE_IF_CHANGED”
}
}

Für die Aufwärtssynchronisierung konfigurieren Sie die gewünschte Tabelle mithilfe von "soupName". In diesem Fall soll die Tabelle "contacts" verwendet werden. Geben Sie mithilfe von "target" und "options" die Felder an, die synchronisiert werden sollen. Der "mergeMode" ist in diesem Fall auf "LEAVE_IF_CHANGED" festgelegt. Falls ein Serverdatensatz seit der Abwärtssynchronisierung mit diesem Client geändert wurde, behalten in diesem Modus sowohl der Server- als auch der Client-Datensatz ihren aktuellen Zustand bei.

Verwenden von Mobile Sync in nativen iOS-Anwendungen

Abwärtssynchronisierung

Mobile Sync bietet Ihnen verschiedene Optionen, um Salesforce-Datensätze in Ihre SmartStore-Soup herunterzuladen.

Sie können eine Konfiguration zur Abwärtssynchronisierung erstellen, ohne sie auszuführen:

var syncState = syncManager.createSyncDown(target: target, options: options, 
    soupName: CONTACTS_SOUP, syncName: syncState.syncName)

Oder Sie können einen unbenannten Abwärtssynchronisierungsvorgang ohne Optionen erstellen und ausführen. Es wird jedoch darauf hingewiesen, dass alle lokalen Änderungen überschrieben werden:

var syncState = syncManager.syncDown(target:target, soupName:CONTACTS_SOUP, onUpdate:updateFunc)

Für mehr Kontrolle können Sie einen unbenannten Abwärtssynchronisierungsvorgang erstellen und ausführen, der Ihre Optionen verwendet:

var syncState = syncManager.syncDown(target: target, options: options, 
    soupName: CONTACTS_SOUP, onUpdate:updateFunc)

Oder Sie können eine Konfiguration einer Abwärtssynchronisierung erstellen, benennen und ausführen:

var syncState = try syncManager.syncDown(target: target, options: options, 
    soupName: CONTACTS_SOUP, syncName: syncState.syncName, onUpdate:updateFunc)

Die SyncTarget-Klasse stellt Factory-Methoden zum Erstellen von Zielobjekten aus einer SOQL-, SOSL- oder MRU-Abfragezeichenfolge bereit. Sie geben die herunterzuladenden Objekte mit einer SOQL- oder SOSL-Abfragezeichenfolge an. Wenn Sie ein MRU-Abfrageziel verwenden, geben Sie nur eine Liste von Feldnamen an. Das Mobile SDK meldet den Fortschritt des Synchronisierungsvorgangs über die angegebene Rückmeldungsmethode oder den implementierten Aktualisierungsblock.

Für iOS Native kann die Option mergeMode einen der folgenden Werte aufweisen:

SFSyncStateMergeModeOverwrite: Überschreiben der geänderten lokalen Datensätze. Dabei gehen alle lokalen Änderungen verloren.
SFSyncStateMergeModeLeaveIfChanged: Beibehalten aller lokalen Änderungen und lokal geänderter Datensätze.

Mit der syncDown(target:soupName:onUpdate:)-Methode, die keinen Optionsparameter verwendet, können Sie vorhandene sObjects im Cache überschreiben. Führen Sie in solchen Fällen immer eine Aufwärtssynchronisierung durch, bevor Sie eine Abwärtssynchronisierung ausführen, damit lokale Änderungen erhalten bleiben.

Aufwärtssynchronisierung

Während der Aufwärtssynchronisierung repliziert Mobile Sync erstellte, aktualisierte und gelöschte Soup-Datensätze auf dem Server. Das Mobile SDK bietet ein Standardziel, das Sie verwenden können, ohne ein eigenes definieren zu müssen. Das Standardziel ist einfach und direkt: Über die Salesforce-API werden lediglich alle in der Soup geänderten Datensätze mit dem Server synchronisiert.

Wenn es ein Ziel gibt, können Sie einen Synchronisationsvorgang erstellen, ohne diesen auszuführen:

let syncState = syncManager.createSyncUp(target: target, options: options, 
    soupName: CONTACTS_SOUP, syncName: syncState.syncName)

Sie können das Standardziel mit der folgenden MobileSyncManager-Methode nutzen:

let syncState = syncManager.syncUp(options: options, soupName: CONTACTS_SOUP, 
    onUpdate: updateFunc)

Wenn Sie ein Aufwärtssynchronisierungsziel angepasst haben, können Sie es durch Aufrufen dieser-Methode ausführen:

let syncState = syncManager.syncUp(target: target, options: options, 
    soupName: CONTACTS_SOUP, onUpdate: updateFunc)

Oder Sie können einen Synchronisierungsvorgang erstellen, benennen und ausführen:

let syncState = 
    try syncManager.syncUp(target: target, options: options, 
        soupName: CONTACTS_SOUP, syncName: syncState.syncName, 
        onUpdate: updateFunc)

Erneute Synchronisierung

Wichtig sind die zuweilen übersehenen Methoden zur erneuten Synchronisierung, die vielseitig und einfach zu programmieren sind. Diese Methoden führen Synchronisierungskonfigurationen aus, die Sie zuvor an anderer Stelle definiert haben. Trotz des Namens können Sie mit diesen Methoden eine benannte Synchronisierung erstmalig durchführen. Die Methoden zur erneuten Synchronisierung synchronisieren nur Datensätze, die seit der letzten Synchronisierung erstellt oder aktualisiert wurden. Wenn die Synchronisierung noch nicht erfolgt ist, werden bei der erneuten Synchronisierung alle neuen oder geänderten Datensätze kopiert. Andernfalls erfolgt eine inkrementelle Synchronisierung.

Um die Methoden zur erneuten Synchronisierung zu verwenden, geben Sie entweder eine Synchronisierungs-ID einer früheren Synchronisierung oder einen vordefinierten Synchronisierungsnamen an. So führen Sie eine vorhandene benannte Synchronisierung aus:

var syncState = 
    try syncManager.reSync(named: syncState.syncName, onUpdate: updateFunc)

Wenn Sie den zurückgegebenen SFSyncState.syncId-Wert aus einem früheren Synchronisierungsvorgang zwischengespeichert haben, können Sie ihn verwenden, um diese Synchronisierung erneut auszuführen:

var syncState = 
    try syncManager.reSync(id: syncState.syncId, onUpdate: updateFunc)

Die reSync-Methoden unterstützen Konfigurationen für die Aufwärts- und Abwärtssynchronisierung.

Beispiel

Native, von forceios erstellte Swift-Anwendungen verwenden eine Vorlage, die die grundlegenden SmartStore- und Mobile Sync-Funktionen zeigt. Diese Vorlage verwendet Combine-Publisher für SmartStore und Mobile Sync, um ihren Code zu vereinfachen. Diese Publisher stehen im Mobile SDK als Erweiterungen der SmartStore- und MobileSync-Klassen zur Verfügung. Schauen wir uns an, wie diese Implementierung im iOSNativeSwiftTemplate-Projekt realisiert wird.

Erstellen Sie zunächst eine Anwendung zum Lernen.

In einem Terminalfenster erstellen Sie eine Anwendung mit forceios.
- Verwenden Sie als Anwendungstyp native_swift.
- Nennen Sie die Anwendung der Einfachheit halber offlineSwift.
Wenn forceios fertig ist, öffnen Sie die neue Arbeitsumgebung in Xcode.

Schauen Sie sich in Xcode unter Setup und Konfiguration nach den Offline-Funktionen um.

Wählen Sie im Project Navigator (⌘1) offlineSwift > offlineSwift > Supporting Files aus. Hier finden Sie die Dateien userstore.json und usersyncs.json. Wenn Sie sie im Editor öffnen, sehen Sie, dass in ihnen grundlegende Konfigurationen zum Aufrufen und Synchronisieren von Accountdatensätzen definiert sind.
Mit der Vorlage werden userstore.json und usersyncs.json zu dem Anwendungspaket in den Einstellungen der Projekterstellungsphasen hinzugefügt.
1. Wählen Sie im Xcode-Projektnavigator den Projektknoten aus.
2. Klicken Sie im Fenster "Editor" auf Build Phases.
3. Erweitern Sie Copy Bundle Resources. Beachten Sie, dass userstore.json und usersyncs.json aufgeführt sind, was bedeutet, dass sie dem Anwendungspaket hinzugefügt werden, wenn die Anwendung erstellt wird.

Schauen wir uns nun die Codierung an.

Wählen Sie im Project Navigator offlineSwift > offlineSwift > Classes > SwiftUI aus.
In SceneDelegate.swift fügt die Vorlage die Funktion setupRootViewController()hinzu, mit der die Offline-Konfigurationen in den Arbeitsspeicher geladen werden. Diese Funktion wird mit Absicht in jeder Benutzersitzung nur einmal aufgerufen. Denken Sie unbedingt daran, dass Sie diese Setup-Methoden in jeder Sitzung nur einmal aufrufen oder zum Laden eines anderen Konfigurationssatzes verwenden können.
```
// Set up store based on config userstore.json
MobileSyncSDKManager.shared.setupUserStoreFromDefaultConfig()
// Set up syncs based on config usersyncs.json
MobileSyncSDKManager.shared.setupUserSyncsFromDefaultConfig()
```
Wählen Sie im Project Navigator offlineSwift > offlineSwift > Classes > Models aus.
Beachten Sie in AccountsListModel.swift die erste Zeile der Klasse AccountsListModel. Diese Zeile definiert ein leeres veröffentlichtes Array von Account-Objekten. SwiftUI-Objekte in der Anwendung abonnieren AccountsListModel, um Updates zu erhalten, wenn sich das veröffentlichte Array ändert.
```
/**
ViewModel for Account List
*/
class AccountsListModel: ObservableObject {
  @Published var accounts: [Account] = []
  ...
```
Suchen Sie nach der Funktion fetchAccounts().
```
func fetchAccounts(){
  syncTaskCancellable = syncManager?.publisher(for: "syncDownAccounts")
    .receive(on: RunLoop.main)
    .sink(receiveCompletion: { _ in }, receiveValue: { _ in
      self.loadFromSmartStore()
  })
  self.loadFromSmartStore()
}
```
Hier verwendet der Mobile Sync-Publisher den benannten Synchronisierungsvorgang "syncDownAccounts", der in usersyncs.json definiert wurde, und synchronisiert ihn erneut. Anschließend kopiert der Publisher die zurückgegebenen Daten in Soups im standardmäßigen SmartStore-Speicher. Wenn fetchAccounts() die Antwort vom Publisher erhält, wird loadFromSmartStore() aufgerufen, damit die aktualisierten Daten aus SmartStore asynchron in das veröffentlichte accounts-Array kopiert werden. Während der Zeit, in der auf die Antwort gewartet wird, ruft fetchAccounts() außerdem loadFromSmartStore() auf, um sicherzustellen, dass das aktuelle accounts-Array etwaige lokale Änderungen beinhaltet. Sehen wir uns an, wie loadFromSmartStore() diese Aktualisierungen ausführt.

Die Funktion loadFromSmartStore() gibt mithilfe des SmartStore-Publishers eine Smart Sql-Abfrage aus und erhält die asynchrone Antwort. Wenn die Antwort als Erfolg gewertet wird, sendet die Funktion das Ergebnis-Datenset an den Aufrufer. Hier kopiert der Aufrufer die analysierte Antwort in das accounts-Array im AccountsListModel-Objekt.

import MobileSync
...
private func loadFromSmartStore() {
  storeTaskCancellable = self.store?.publisher(for: "select {Account:Name}, {Account:Industry}, {Account:Id} from {Account}")
  .receive(on: RunLoop.main)
  .tryMap {
    $0.map { (row) -> Account in
      let r = row as! [String?]
      return Account(id: r[2] ?? "", name: r[0] ?? "", industry: r[1] ?? "Unknown Industry" )
    }
  }
  .catch { error -> Just<[Account]> in
    print(error)
    return Just([Account]())
  }
  .assign(to: \AccountsListModel.accounts, on:self)
}

Wenn die Daten in das accounts-Array übernommen worden sind, kann die Anwendung mit ihrer primären Logik fortfahren, die in diesem Fall aus Folgendem besteht:

Anzeigen der abgefragten Accounts und ihrer Details
Bei allen Accounts, die der Kunde auswählt, Abfragen der Kontakte und ihrer Details und anschließendes Anzeigen

Verwenden von Mobile Sync in nativen Android-Anwendungen

Abwärtssynchronisierung

Verwenden Sie zum Herunterladen von sObjects vom Server in Ihre lokale Mobile Sync-Soup eine der folgenden SyncManager-Methoden:

Sie können eine Konfiguration zur Abwärtssynchronisierung erstellen, ohne sie auszuführen:

public SyncState createSyncDown(SyncDownTarget target, 
    SyncOptions options, String soupName, String syncName) 
    throws JSONException;

Oder Sie können einen unbenannten Abwärtssynchronisierungsvorgang ohne Optionen erstellen und ausführen. Es wird jedoch darauf hingewiesen, dass alle lokalen Änderungen überschrieben werden:

public SyncState syncDown(SyncDownTarget target, String soupName, 
    SyncUpdateCallback callback) throws JSONException;

Für mehr Kontrolle können Sie einen unbenannten Abwärtssynchronisierungsvorgang erstellen und ausführen, der Ihre eigenen Zusammenführungsoptionen verwendet:

public SyncState syncDown(SyncDownTarget target, SyncOptions options,
    String soupName, SyncUpdateCallback callback) 
    throws JSONException;

Oder Sie können diese Abwärtssynchronisierungskonfiguration beim Erstellen benennen und dann ausführen:

public SyncState syncDown(SyncDownTarget target, SyncOptions options, 
    String soupName, SyncUpdateCallback callback) 
    throws JSONException;

Aufwärtssynchronisierung

Verwenden Sie eine der folgenden SyncManager-Methoden, um lokale Änderungen an den Server zu übergeben:

Sie können eine benannte Konfiguration zur Aufwärtssynchronisierung erstellen, ohne sie auszuführen:

public SyncState createSyncUp(SyncUpTarget target, 
    SyncOptions options, 
    String soupName, 
    String syncName) 
    throws JSONException;

Sie können eine unbenannte Synchronisierungskonfiguration in einem Aufruf erstellen und ausführen:

public SyncState syncUp(SyncUpTarget target, 
    SyncOptions options, 
    String soupName, 
    SyncUpdateCallback callback) 
    throws JSONException;

Oder Sie können eine benannte Aufwärtssynchronisierungskonfiguration in einem Aufruf erstellen und ausführen:

public SyncState syncUp(SyncUpTarget target, 
    SyncOptions options, 
    String soupName, 
    String syncName, 
    SyncUpdateCallback callback) 
    throws JSONException;

Die syncUp-Methoden aktualisieren den Server mit Daten aus der angegebenen SmartStore-Soup. Sie ermitteln erstellte, aktualisierte oder gelöschte Datensätze in der Soup und replizieren diese Änderungen auf dem Server. Mit dem Parameter target (Ziel) oder options (Optionen) oder beiden wird eine Liste von Feldern angegeben, die hochgeladen werden sollen. Ein Ziel ermöglicht die Unterscheidung zwischen einer createFieldlist zum Erstellen von Datensätzen und einer updateFieldlist zum Aktualisieren vorhandener Datensätze. Diese Einstellungen ermöglichen Ihnen, neue Datensätze zu synchronisieren und gleichzeitig Versuche zu vermeiden, schreibgeschützte Felder in bestehenden Datensätzen zu aktualisieren. Wenn Sie Zielfeldlisten und Optionsfeldlisten definieren, wird die Einstellung options ignoriert.

Erneute Synchronisierung

Wichtig, aber bisweilen übersehen, sind die beiden Methoden zur erneuten Synchronisierung, die vielseitig und einfach zu programmieren sind. Diese Methoden führen Synchronisierungskonfigurationen aus, die Sie zuvor an anderer Stelle definiert haben. Trotz des Namens können Sie mit diesen Methoden auch eine benannte Synchronisierung erstmalig durchführen. Wenn Sie sie später durchführen, erfassen die Methoden zur erneuten Synchronisierung nur Datensätze, die seit der letzten Synchronisierung erstellt oder aktualisiert wurden. Wenn die Synchronisierung noch nicht erfolgt ist, werden bei der erneuten Synchronisierung alle neuen oder geänderten Datensätze kopiert. Andernfalls erfolgt eine inkrementelle Synchronisierung.

public SyncState reSync(String syncName, SyncUpdateCallback callback) 
    throws JSONException;

Wenn Sie den zurückgegebenen SFSyncState.syncId-Wert aus einem früheren Synchronisierungsvorgang zwischengespeichert haben, können Sie diesen mit reSync:updateBlock: erneut ausführen:

public SyncState reSync(long syncId, SyncUpdateCallback callback) 
    throws JSONException;

Die reSync-Methoden unterstützen Konfigurationen für die Aufwärts- und Abwärtssynchronisierung.

Beispiel

In Android veranschaulicht die native Beispielanwendung MobileSyncExplorer die Verwendung von benannten Synchronisierungen und Synchronisierungskonfigurationsdateien mit Kontaktdatensätzen. Sie definiert eine ContactObject-Klasse, die einen Salesforce-Kontaktdatensatz als Java-Objekt darstellt. Um Kontaktdaten abwärts mit der SmartStore-Soup zu synchronisieren, synchronisiert die syncDown()-Methode eine benannte Abwärtssynchronisierungskonfiguration, die eine SOQL-Abfrage definiert, erneut.

Diese Anwendung speichert die Dateien userstore.json und usersyncs.json im Projektordner /res/raw. Hier sehen Sie userstore.json:

{
  "soups": [
    {
      "soupName": "contacts",
      "indexes": [
        { "path": "Id", "type": "string"},
        { "path": "FirstName", "type": "string"},
        { "path": "LastName", "type": "string"},
        { "path": "__local__", "type": "string"},
        { "path": "__locally_created__", "type": "string"},
        { "path": "__locally_updated__", "type": "string"},
        { "path": "__locally_deleted__", "type": "string"},
        { "path": "__sync_id__", "type": "integer"}
      ]
    }
  ]
}

Und usersyncs.json:

{
  "syncs": [
    {
      "syncName": "syncDownContacts",
      "syncType": "syncDown",
      "soupName": "contacts",
      "target": {"type":"soql", "query":"SELECT FirstName, LastName, Title, MobilePhone, Email, Department, HomePhone FROM Contact LIMIT 10000"},
      "options": {"mergeMode":"OVERWRITE"}
    },
    {
      "syncName": "syncUpContacts",
      "syncType": "syncUp",
      "soupName": "contacts",
      "target": {"createFieldlist":["FirstName", "LastName", "Title", "MobilePhone", "Email", "Department", "HomePhone"]},
      "options": {"fieldlist":["Id", "FirstName", "LastName", "Title", "MobilePhone", "Email", "Department", "HomePhone"], "mergeMode":"LEAVE_IF_CHANGED"}
    }
  ]
 }

Diese Beispielanwendung lädt diese Dateien in den Arbeitsspeicher in ihrem ContactListLoader-Konstruktor.

public ContactListLoader(Context context, UserAccount account) {
  super(context);
  MobileSyncSDKManager sdkManager = MobileSyncSDKManager.getInstance();
  smartStore = sdkManager.getSmartStore(account);
  syncMgr = SyncManager.getInstance(account);
  // Setup schema if needed
  sdkManager.setupUserStoreFromDefaultConfig();
  // Setup syncs if needed
  sdkManager.setupUserSyncsFromDefaultConfig();
}

Bei der folgenden Methode der ContactListLoader-Klasse führt die lokale syncDown()-Methode reSync() mit der syncDownContacts-Konfiguration aus:

public synchronized void syncDown() {     
    try {
      syncMgr.reSync(SYNC_DOWN_NAME /* see usersyncs.json */, new SyncUpdateCallback() {
            @Override
            public void onUpdate(SyncState sync) {
                if (Status.DONE.equals(sync.getStatus())) {
                    fireLoadCompleteIntent();
                }
            }
        });
    } catch (JSONException e) {
        Log.e(TAG, "JSONException occurred while parsing", e);
    } catch (MobileSyncException e) {
        Log.e(TAG, "MobileSyncException occurred while attempting to sync down", e);
    }
  }

Wenn die Abwärtssynchronisierung erfolgreich ist, d. h. sync.getStatus() gleich Status.DONE ist, werden die empfangenen Daten in die angegebene Soup eingefügt. Die Rückrufmethode löst dann eine Absicht aus, die die Daten in der Kontaktliste neu lädt.

Ebenso führt die lokale syncUp()-Methode der ContactListLoader-Klasse reSync() mit der syncUpContacts-Konfiguration aus:

public synchronized void syncUp() {        
    try {         
        syncMgr.reSync(SYNC_UP_NAME /* see usersyncs.json */, new SyncUpdateCallback() { 
            new SyncUpdateCallback() {              
                @Override             
                public void onUpdate(SyncState sync) {                 
                    if (Status.DONE.equals(sync.getStatus())) {                     
                        syncDown();                 
                    }             
                }         
            });     
    } catch (JSONException e) {            
        Log.e(TAG, "JSONException occurred while parsing", e);     
    } catch (MobileSyncException e) {            
        Log.e(TAG, "MobileSyncException occurred while attempting to sync up", e);     
    } 
 }

Wenn die asynchrone Antwort Status.DONE lautet, führt die SyncUpdateCallback-Implementierung hier einen zusätzlichen Schritt aus und ruft syncDown() auf. Dieser empfohlene Schritt garantiert, dass die SmartStore-Soup mit den Änderungen aktualisiert wird, die auf dem Server an Kontakten vorgenommen wurden.

Verwenden von Mobile Sync in hybriden Anwendungen

Für hybride Anwendungen bietet Mobile Sync zwei Ansätze.

com.salesforce.plugin.mobilesync: Dieses Cordova-Plug-In bietet JavaScript-Zugriff auf die native Funktionalität zur Abwärts- und Aufwärtssynchronisierung von Mobile Sync. Leistungsintensive Vorgänge, z. B. Netzwerkaushandlungen, Analysen, SmartStore -Verwaltung, werden in nativen Threads ausgeführt, die sich nicht auf Vorgänge für Webansichten auswirken. Verwenden Sie das Plug-In in einfacheren Szenarien, um eine Vielzahl von Datensätzen in einem nativen Thread anstatt in der Webansicht zu synchronisieren.
mobilesync.js: Diese JavaScript-Bibliothek stellt ein Force sObject-Datenframework für komplexere Synchronisierungsvorgänge zur Verfügung. Die Bibliothek basiert auf Backbone.js, einem Open-Source-JavaScript-Framework, das einen erweiterten Datenmodellierungsmechanismus definiert. Durch Verwendung von mobilesync.js können Sie Modelle von Salesforce-Objekten erstellen und die zugrunde liegenden Datensätze durch Ändern der Modelldaten bearbeiten. Wenn Sie eine SOQL- oder SOSL-Abfrage durchführen, erhalten Sie die resultierenden Datensätze in einer Modellsammlung und nicht als JSON-Zeichenfolge.

Sie können diese Ansätze in der gleichen Anwendung wirkungsvoll kombinieren. Das Plug-In macht beispielsweise zwei Methoden verfügbar: syncDown() und syncUp(). Wenn Sie diese Methoden verwenden, erleichtern Ihnen die folgenden Leitlinien das Leben:

Verwenden Sie Force.SObject in mobilesync.js, um Datensätze in SmartStore-Soups zu erstellen, zu aktualisieren oder zu löschen. Die Bibliothek mobilesync.js erstellt automatisch spezielle Felder für Soup-Datensätze, die das Plug-In erwartet. Sie können dann syncUp() für das Plug-In aufrufen, um den Server zu aktualisieren.
Zum Erstellen der Soup, die in Synchronisierungsvorgängen verwendet werden soll, wird Force.StoreCache in mobilesync.js verwendet.
Rufen Sie immer syncUp() auf, bevor syncDown() aufgerufen wird, wenn Objekte in der Soup geändert wurden.

Hybride mit forcehybrid erstellte Anwendungen beinhalten automatisch das Mobile Sync-Plug-In.

Abwärtssynchronisierung

Im Folgenden wird die syncDown()-Methode des Mobile Sync-Plug-Ins erläutert.

cordova.require("com.salesforce.plugin.mobilesync").syncDown
    ([storeConfig,] target, soupName, options, [syncName,] success, error);

Wenn Sie einen Synchronisierungsnamen für diese Konfiguration definiert haben, können Sie ihn angeben. Sie definieren Synchronisierungsnamen in einer usersyncs.json-Konfigurationsdatei, die Sie auf der obersten Ebene Ihrer Webanwendung einfügen.

Für die Option "merge mode" verwenden hybride Anwendungen diese Bezeichner.

{mergeMode:Force.MERGE_MODE_DOWNLOAD.OVERWRITE} (Standard)
{mergeMode:Force.MERGE_MODE_DOWNLOAD.LEAVE_IF_CHANGED}

Der success-Parameter gibt eine Rückruffunktion an, die während des Synchronisierungsvorgangs mehrfach aufgerufen wird:

Beim Beginn der Synchronisierung
Nach Durchführung der internen REST-Anforderung
Nach jedem Download einer Ergebnisseite, bis alle Ergebnisse empfangen wurden

Während die Synchronisierung läuft, gehen Statusaktualisierungen über Browserereignisse ein. Um auf diese Aktualisierungen zu lauschen, implementieren Sie den folgenden Ereignis-Listener:

document.addEventListener("sync",
   function(event)
      {
         // event.detail contains the status of the sync operation
      }
 );

Der Member event.detail liefert Ihnen Metadaten zur Synchronisierung und – noch wichtiger – Informationen zum aktuellen Fortschritt und Status des Vorgangs:

syncId: Die ID dieses Synchronisierungsvorgangs
type: syncDown
target: Das angegebene Ziel
soupName: Der angegebene Soup-Name
options:: Array der von Ihnen angegebenen Optionen
status: Einer der folgenden Synchronisierungsstatus:
1. NEW
2. RUNNING
3. DONE
4. FAILED
progress: Der Prozentsatz der bislang insgesamt verarbeiteten Datensätze (ganze Zahl von 0 bis 100)
totalSize: Die Gesamtzahl der bislang verarbeiteten Datensätze

Es empfiehlt sich, die Synchronisierungs-ID zu speichern. Sie können diesen Wert später verwenden, um den Synchronisierungsvorgang erneut auszuführen.

Aufwärtssynchronisierung

Mit der syncUp()-Methode des Mobile Sync-Plug-Ins werden erstellte, gelöschte oder aktualisierte Datensätze aus einer SmartStore-Soup auf den Salesforce-Server repliziert.

cordova.require("com.salesforce.plugin.mobilesync").syncUp
   ([storeConfig,] [target,] soupName, options, [syncName,] successCb, errorCb);

Sie stellen Konfigurationseinstellungen für den Vorgang zur Verfügung, z. B.:

target: Wenn Sie ein benutzerdefiniertes natives Synchronisierungsziel definiert haben, bestimmen Sie mit diesem Parameter dessen Klasse.
syncName: Wenn Sie einen Synchronisierungsnamen für diese Konfiguration definiert haben, können Sie ihn angeben. Sie definieren Synchronisierungsnamen in einer usersyncs.json-Konfigurationsdatei, die Sie auf der obersten Ebene Ihrer Webanwendung einfügen.
options: Geben Sie eine Zuordnung mit dem folgenden Schlüssel an:
1. fieldlist: Eine Liste der an den Server gesendeten Felder.
successCb, errorCb: Rückruffunktionen für Erfolg und Fehler.

Statusaktualisierungen für den Synchronisierungsvorgang gehen über denselben Ereignis-Handler ein, den Sie für syncDown implementiert haben:

document.addEventListener("sync",
   function(event)
      {
         // event.detail contains the status of the sync operation
      }
 );

Wie bei Abwärtssynchronisierungsvorgängen liefert Ihnen der Member event.detail Metadaten und meldet den aktuellen Fortschritt und Status des Vorgangs.

Erneute Synchronisierung

Wie in nativen Anwendungen bietet die reSync-Methode mehr Flexibilität und Leistungsfähigkeit und erleichtert das Codieren. Wenn der von Ihnen angegebene Synchronisierungsname noch nicht synchronisiert worden ist, führt reSync() eine vollständige Synchronisierung durch. Andernfalls erfolgt lediglich eine inkrementelle Synchronisierung der neuen, geänderten oder gelöschten Datensätze.

cordova.require("com.salesforce.plugin.mobilesync").reSync([storeConfig], syncIdOrName, successCB, errorCB)

Sie stellen Konfigurationseinstellungen für den Vorgang zur Verfügung, z. B.:

syncIdOrName: Die ID dieses Synchronisierungsvorgangs oder ein Synchronisierungsname aus der Datei usersyncs.json.
successCb, errorCb: Rückruffunktionen für Erfolg und Fehler.

Beispiel

Bei diesem Beispiel werden die in der folgenden Datei usersyncs.json definierten benannten Synchronisierungen verwendet. Den vollständigen Quellcode finden Sie im SalesforceMobileSDK-Shared-GitHub-Repository.

{
  "syncs": [
    {
      "syncName": "syncDownContacts",
      "syncType": "syncDown",
      "soupName": "contacts",
      "target": {"type":"soql", 
      "query":"SELECT FirstName, LastName, Title, MobilePhone, 
               Email, Department, HomePhone FROM Contact LIMIT 10000"},
      "options": {"mergeMode":"OVERWRITE"}
    },
    {
      "syncName": "syncUpContacts",
      "syncType": "syncUp",
      "soupName": "contacts",
      "target": {
         "createFieldlist":["FirstName", "LastName", "Title", "MobilePhone", 
                            "Email", "Department", "HomePhone"]},
      "options": {
         "fieldlist":["Id", "FirstName", "LastName", "Title", 
                      "MobilePhone", "Email", "Department", "HomePhone"], 
         "mergeMode":"LEAVE_IF_CHANGED"}
    }
  ]
}

In den folgenden Beispielen rufen beide Aufwärts- und Abwärtssynchronisierungsvorgänge reSync() für das Cordova-Plug-In Mobile Sync auf und übergeben einen Synchronisierungsnamen. Alle Synchronisierungsvorgänge verwenden die Funktion handleSyncUpdate() für Erfolgsrückrufe. Beachten Sie, dass diese Funktion syncDown() nach einer erfolgreichen Ausführung von syncUp aufruft. Es ist immer eine gute Idee, syncDown() nach syncUp() aufzurufen, um sicherzustellen, dass Ihre Soups die letzten Änderungen auf dem Server enthalten.

In seiner aktuellen Form setzt der Erfolgsrückruf für syncDown() die Benutzeroberfläche und ihren Inhalt zurück.

 handleSyncUpdate: function(sync) {
  // Called after sync operations succeed 
  if (sync.type === "syncDown") {
    // Reset UI buttons, then search (fetch) from SmartStore
    this.syncInFlight = false;
    $(".sync").disabled = false;
    this.search();
  }
  if (sync.type === "syncUp") {
      this.syncDown();
    }
  }
 },
 syncDown: function() {
   cordova.require("com.salesforce.plugin.mobilesync").
     reSync("syncDownContacts" /* see usersyncs.json */, 
     this.handleSyncUpdate.bind(this));
 },
 syncUp: function() {
   cordova.require("com.salesforce.plugin.mobilesync").
     reSync("syncUpContacts" /* see usersyncs.json */, 
     this.handleSyncUpdate.bind(this));
 }

Verwenden von Mobile Sync in React Native-Anwendungen

In React Native stellt Mobile Sync seine Funktionalität über ein mobilesync-Modul zur Verfügung. Sie können dieses Modul und seine Abhängigkeiten aus der react-native-force-Bibliothek wie folgt in Ihre JavaScript-Dateien importieren:

import {oauth, net, smartstore, mobilesync} from 'react-native-force';

Mit forcereact erstellte Anwendungen enthalten eine ähnliche Anweisung zum Importieren, aber ohne smartstore oder mobilesync. Fügen Sie diese Module unbedingt hinzu, wenn Sie Offline-Funktionen von Mobile SDK unterstützen.

Synchronisierungskonfiguration

Wie Sie wahrscheinlich vermuten, stellen Sie für React Native-Anwendungen die gleichen Konfigurationsmetadaten wie für hybride Anwendungen zur Verfügung. Hier ein Beispiel einer Zieldeklaration.

 const fieldlist = ["Id", "FirstName", "LastName", 
    "Title", "Email", "MobilePhone","Department",
    "HomePhone", "LastModifiedDate"];
 const target = {type:"soql", query:
    `SELECT ${fieldlist.join(",")} FROM Contact LIMIT 10000`};

Für "merge mode" in options verwenden Sie einen der folgenden Werte:

So überschreiben Sie Datensätze, die geändert wurden:
```
{mergeMode:mobilesync.MERGE_MODE.OVERWRITE}
```
Wenn Sie den Schlüssel mergeMode nicht definieren, verwendet Mobile Sync diesen Modus standardmäßig.
So werden geänderte Datensätze beibehalten anstatt überschrieben:
```
{mergeMode:mobilesync.MERGE_MODE.LEAVE_IF_CHANGED}
```

Abwärtssynchronisierung

Die syncDown()-Funktion für React Native ist identisch mit der hybriden Funktion, außer dass sie für das mobilesync-Modul aufgerufen wird. Sie lädt angegebene Salesforce-Datensätze in eine SmartStore-Soup herunter.

mobilesync.syncDown
    ([storeConfig,] target, soupName, options, [syncName,] success, error);

Wenn vorhandene Datensätze in der Soup die gleiche ID wie die von der Abfrage zurückgegebenen Datensätze haben, überschreibt Mobile Sync standardmäßig die duplizierten Soup-Datensätze. Um zu steuern, wie heruntergeladene Daten mit bearbeiteten Datensätzen in der Soup zusammengeführt werden, geben Sie im Parameter options einen Zusammenführungsmodus an.

Der success-Parameter gibt eine Rückruffunktion an, die der interne Synchronisierungs-Manager aufruft, wenn der Synchronisierungsvorgang erfolgreich beendet wird. Im Gegensatz zur hybriden Implementierung ruft die React Native-Bibliothek diese Funktion nur einmal auf, nachdem der Vorgang beendet wurde.

Das Mobile SDK übergibt ein einziges Argument an den Rückruf von "success". Dieses Argument gibt die folgenden Synchronisierungsmetadaten zurück, die die Synchronisierungs-ID enthalten:

syncId: Die ID dieses Synchronisierungsvorgangs
type: syncDown
target: Das angegebene Ziel
options (optional): Ein Array, das eines oder beide der folgenden Elemente angibt: Zusammenführungsmodus, Feldliste
soupName: Der angegebene Soup-Name
syncName: Der angegebene Synchronisierungsname, sofern vorhanden

Auch wenn Ihnen keine anderen Aktionen für einen Erfolgsrückruf zur Verfügung stehen, ist es eine gute Idee, ihn zu Implementieren und die Synchronisierungs-ID zu speichern. Sie können diesen Wert später bei Bedarf in einem erneuten Synchronisierungsvorgang verwenden. Im Folgenden finden Sie ein Beispiel für eine Abwärtssynchronisierung.

const syncDown = forceUtil.promiserNoRejection(mobilesync.syncDown);
...
const fieldlist = ["Id", "FirstName", "LastName", 
    "Title", "Email", "MobilePhone","Department",
    "HomePhone", "LastModifiedDate"];
const target = {type:"soql", 
    query:`SELECT ${fieldlist.join(",")} 
           FROM Contact 
           LIMIT 10000`};
syncDown(false,
    target,
    "contacts",
    {mergeMode:mobilesync.MERGE_MODE.OVERWRITE},
    syncName,
    (sync) => {/* Do something meaningful or omit this member */},
    (error) => {/* Do something meaningful or omit this member */}
 );

Aufwärtssynchronisierung

Mit der syncUp()-Funktion des Plug-Ins für Mobile Sync werden erstellte, aktualisierte oder gelöschte Datensätze aus einer SmartStore-Soup auf den Salesforce-Server kopiert.

mobilesync.syncUp
   ([storeConfig,] target, soupName, options, [syncName,] successCb, errorCb);

Wie bei Abwärtssynchronisierungsvorgängen liefert Ihnen das "input"-Argument der Erfolgsrückruffunktion die Metadaten für die Synchronisierung einschließlich Synchronisierungs-ID.

Hier ein Beispiel einer Aufwärtssynchronisierung.

const syncUp = forceUtil.promiserNoRejection(mobilesync.syncUp);
...
const fieldlist = ["FirstName", "LastName", "Title", "Email", 
  "MobilePhone","Department"];
syncUp(false,
  {},
  "contacts",
  {mergeMode:mobilesync.MERGE_MODE.OVERWRITE, fieldlist},
  (sync) => {/* Do something meaningful or omit this callback */},
  (error) => {/* Do something meaningful or omit this callback */}
);

Erneute Synchronisierung

Wie in nativen Anwendungen bietet die reSync()-Methode mehr Flexibilität und Leistungsfähigkeit und erleichtert das Codieren. Wenn der von Ihnen angegebene Synchronisierungsname noch nicht synchronisiert worden ist, führt reSync() eine vollständige Synchronisierung durch. Andernfalls erfolgt lediglich eine inkrementelle Synchronisierung der erstellten, aktualisierten oder gelöschten Datensätze.

mobilesync.reSync
   ([storeConfig,] syncIdOrName, successCB, errorCB);

Sie stellen Konfigurationseinstellungen für den Vorgang zur Verfügung, z. B.:

syncIdOrName: Die ID dieses Synchronisierungsvorgangs oder ein Synchronisierungsname aus der Datei usersyncs.json.
successCb, errorCb: Rückruffunktionen für Erfolg und Fehler.

Ressourcen

Verwenden von Mobile Sync in Hybrid- und React Native-Anwendungen
Verwenden von Mobile Sync in nativen Anwendungen
Die Beispielanwendung MobileSyncExplorer gibt es in folgenden Versionen. Einzelheiten zu ihrer Verwendung finden Sie unter Installieren der Beispielanwendungen.
NoteSync: Beispiel einer hybriden Anwendung
- Android Hybrid
- iOS Hybrid
React Native-Website
Verwenden des Abwärtssynchronisierungsziels "Briefcase"