b38dea0597
Share Gaia assets and adapters, keep private profiles and development documents local, and update both public READMEs.
103 lines
4.3 KiB
JavaScript
103 lines
4.3 KiB
JavaScript
/* Any copyright is dedicated to the Public Domain.
|
|
* http://creativecommons.org/publicdomain/zero/1.0/ */
|
|
|
|
/**
|
|
* See ../js/sync-engine/syncengine.js for an explanation of how DataAdapters
|
|
* are used by the SyncEngine.
|
|
*
|
|
* There needs to be one DataAdapter for each collection (history, passwords,
|
|
* bookmarks, tabs). If the user enabled syncing for a specific collection in
|
|
* Settings, the DataAdapter's `update` method will be called each time sync
|
|
* runs. The Kinto collection passed to `update` will contain a local copy of
|
|
* the remote data. It can be queried using its `list` and `get` methods.
|
|
*
|
|
* It is the task of the DataAdapter to compare this data with wherever the
|
|
* corresponding data lives on the device (e.g. the 'places' DataStore for
|
|
* history, the 'bookmarks_store' DataStore for bookmarks, etc.), and to update
|
|
* the device's live data based on the data in the Kinto collection.
|
|
*
|
|
* Subsequently, or at the same time, the DataAdapter should detect when data
|
|
* from the device needs to be added or changed in the Kinto collection, so that
|
|
* the SyncEngine can propagate these changes to the user's Firefox Sync
|
|
* account on the server.
|
|
* The update method should return a Promise for `true` if any changes were made
|
|
* to `kintoCollection` and a Promise for `false` otherwise. That way, the
|
|
* SyncEngine knows whether it's necessary to sync a second time, to upload such
|
|
* changes to the FxSync server.
|
|
*
|
|
* Before and after `update` is called, the SyncEngine synchronizes the Kinto
|
|
* collection with the remote server. In both cases, conflicts may occur. If
|
|
* they do, the `handleConflict` method on the DataAdapter is called once for
|
|
* each conflict, and has the opportunity to let the local copy win, let the
|
|
* remote copy win, or return a merged version of the two.
|
|
*/
|
|
|
|
'use strict';
|
|
|
|
/* exported ExampleAdapter */
|
|
|
|
var ExampleAdapter = {
|
|
|
|
/*
|
|
* update - Import incoming changes to the appropriate place on the device,
|
|
* and (optionally) export outgoing changes to SyncEngine.
|
|
*
|
|
* @param {Object} kintoCollection - A Kinto collection, see
|
|
* http://kintojs.readthedocs.org/en/latest/api/#collections
|
|
*
|
|
* @param {Object} options - either `{}` or `{ readonly: true }`
|
|
*
|
|
* @returns {Promise} A promise for a Boolean, indicating whether or not
|
|
* any outgoing changes were made that need to be synced up
|
|
* to FxSync.
|
|
*/
|
|
update: function(kintoCollection, options) {
|
|
// E.g. read all records from kintoCollection (last modified first):
|
|
kintoCollection.list().then(list => {
|
|
for(var i = 0; i < list.data.length; i++) {
|
|
console.log(`Record ${i}:`, list.data[i].payload);
|
|
}
|
|
});
|
|
|
|
if (options.readonly) {
|
|
// TODO: Import data from Kinto collection into the appropriate DataStore
|
|
// or Web API:
|
|
return Promise.resolve(false);
|
|
} else {
|
|
var kintoCollectionChanged = false;
|
|
// TODO: Sync changes both ways between Kinto collection and the
|
|
// appropriate DataStore or Web API.
|
|
// Whenever you use kintoCollection.add, kintoCollection.update,
|
|
// kintoCollection.delete, etc., set `kintoCollectionChanged` to true, and
|
|
// then:
|
|
return Promise.resolve(kintoCollectionChanged);
|
|
}
|
|
},
|
|
|
|
/*
|
|
* handleConflict - Decide how to resolve a Kinto conflict.
|
|
*
|
|
* @param {Object} conflict - A Kinto conflict, see
|
|
* http://kintojs.readthedocs.org/en/latest/api/#resolving-conflicts-manually
|
|
*
|
|
* @returns {Promise} A Promise for the desired resolution (could be
|
|
* conflict.local, conflict.remote, or a merge of the two).
|
|
*/
|
|
handleConflict: function(conflict) {
|
|
console.log('Example adapter handleConflict function called with:',
|
|
conflict.local,
|
|
conflict.remote);
|
|
return Promise.resolve(conflict.local);
|
|
},
|
|
|
|
/*
|
|
* reset - will be called in case of panic after an unrecoverable error, to
|
|
* reset any data the DataAdapter stores for efficiency of incremental
|
|
* consecutive sync runs (for instance, some DataAdapters will store
|
|
* the last modified time of unsynced records, and will only check
|
|
* records that were changed since then).
|
|
*/
|
|
reset: function(options) {
|
|
return Promise.resolve(`Reset check points for ${options.userid}.`);
|
|
}
|
|
};
|