react-native-nitro-background-geolocation 0.1.0

package/android/src/main/java/com/marianhello/bgloc/sync/BatchManager.java

@@ -0,0 +1,246 @@
+package com.marianhello.bgloc.sync;
+
+import android.content.ContentProviderOperation;
+import android.content.ContentResolver;
+import android.content.ContentValues;
+import android.content.Context;
+import android.database.Cursor;
+import android.database.sqlite.SQLiteDatabase;
+import android.net.Uri;
+import android.text.TextUtils;
+import android.util.JsonWriter;
+
+import com.marianhello.bgloc.ResourceResolver;
+import com.marianhello.bgloc.data.AbstractLocationTemplate;
+import com.marianhello.bgloc.data.ArrayListLocationTemplate;
+import com.marianhello.bgloc.data.BackgroundLocation;
+import com.marianhello.bgloc.data.HashMapLocationTemplate;
+import com.marianhello.bgloc.data.LocationTemplate;
+import com.marianhello.bgloc.data.LocationTemplateFactory;
+import com.marianhello.bgloc.data.provider.LocationContentProvider;
+import com.marianhello.bgloc.data.sqlite.SQLiteLocationContract;
+import com.marianhello.bgloc.data.sqlite.SQLiteLocationContract.LocationEntry;
+import com.marianhello.bgloc.data.sqlite.SQLiteOpenHelper;
+import com.marianhello.logging.LoggerManager;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.OutputStreamWriter;
+import java.io.UnsupportedEncodingException;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Created by finch on 20/07/16.
+ */
+public class BatchManager {
+    private Context context;
+    private org.slf4j.Logger logger;
+
+    public BatchManager(Context context) {
+        logger = LoggerManager.getLogger(BatchManager.class);
+        this.context = context;
+    }
+
+    private Uri getLocationContentUri() {
+        ResourceResolver resourceResolver = ResourceResolver.newInstance(context);
+        String authority = resourceResolver.getAuthority();
+        return LocationContentProvider.getContentUri(authority);
+    }
+
+    private File createBatchFromTemplate(Long batchStartMillis, Integer syncThreshold, LocationTemplate template) throws IOException {
+        logger.info("Creating batch {}", batchStartMillis);
+
+        ContentResolver resolver = context.getContentResolver();
+        Uri contentUri = getLocationContentUri();
+
+        String whereClause = TextUtils.join("", new String[]{
+                LocationEntry.COLUMN_NAME_STATUS + " = ? AND ( ",
+                LocationEntry.COLUMN_NAME_BATCH_START_MILLIS + " IS NULL OR ",
+                LocationEntry.COLUMN_NAME_BATCH_START_MILLIS + " < ? )",
+        });
+        String[] whereArgs = {
+                String.valueOf(BackgroundLocation.SYNC_PENDING),
+                String.valueOf(batchStartMillis)
+        };
+
+        Cursor cursor = null;
+        LocationWriter writer = null;
+
+        try {
+            cursor = resolver.query(
+                    contentUri,
+                    null,
+                    whereClause,
+                    whereArgs,
+                    LocationEntry.COLUMN_NAME_TIME + " ASC"
+
+            );
+
+            if (cursor.getCount() < syncThreshold) {
+                return null;
+            }
+
+            File file = File.createTempFile("locations", ".json");
+            FileOutputStream fs = new FileOutputStream(file);
+            writer = new LocationWriter(fs, template);
+
+            writer.beginArray();
+            while (cursor.moveToNext()) {
+                BackgroundLocation location = BackgroundLocation.fromCursor(cursor);
+                writer.write(location);
+            }
+
+            writer.endArray();
+            writer.close();
+            fs.close();
+
+            // set batchStartMillis for all synced locations
+            ContentValues values = new ContentValues();
+            values.put(LocationEntry.COLUMN_NAME_BATCH_START_MILLIS, batchStartMillis);
+            resolver.update(contentUri, values, whereClause, whereArgs);
+
+            logger.info("Batch file: {} created successfully", file.getName());
+
+            return file;
+        } finally {
+            if (cursor != null) {
+                cursor.close();
+            }
+            if (writer != null) {
+                writer.close();
+            }
+        }
+    }
+
+    public File createBatch(Long batchStartMillis, Integer syncThreshold, LocationTemplate template) throws IOException {
+        LocationTemplate tpl;
+        if (template != null) {
+            tpl = template;
+        } else {
+            tpl = LocationTemplateFactory.getDefault();
+        }
+        return createBatchFromTemplate(batchStartMillis, syncThreshold, tpl);
+    }
+
+    public File createBatch(Long batchStartMillis, Integer syncThreshold) throws IOException {
+        return createBatch(batchStartMillis, syncThreshold, null);
+    }
+
+
+    public void setBatchCompleted(Long batchId) {
+        ContentResolver resolver = context.getApplicationContext().getContentResolver();
+        Uri contentUri = getLocationContentUri();
+
+        String whereClause = LocationEntry.COLUMN_NAME_BATCH_START_MILLIS + " = ?";
+        String[] whereArgs = { String.valueOf(batchId) };
+
+        ContentValues values = new ContentValues();
+        values.put(LocationEntry.COLUMN_NAME_STATUS, BackgroundLocation.DELETED);
+        resolver.update(contentUri, values, whereClause, whereArgs);
+    }
+
+    private static class LocationTemplateWriter {
+        private BackgroundLocation location;
+        private JsonWriter writer;
+
+        public LocationTemplateWriter(JsonWriter writer, BackgroundLocation location) {
+            this.writer = writer;
+            this.location = location;
+        }
+
+        private void writeValue(Object value) throws IOException {
+            if (value instanceof String ) {
+                writer.value((String) value);
+            } else if (value instanceof Map) {
+                writeMap((Map) value);
+            } else if (value instanceof List) {
+                writeList((List) value);
+            } else if (Integer.class.isInstance(value)) {
+                writer.value((Integer) value);
+            } else if (Double.class.isInstance(value)) {
+                writer.value((Double) value);
+            } else if (Float.class.isInstance(value)) {
+                writer.value((Float) value);
+            } else if (Long.class.isInstance(value)) {
+                writer.value((Long) value);
+            } else if (Boolean.class.isInstance(value)) {
+                writer.value((Boolean) value);
+            } else if (value == JSONObject.NULL) {
+                writer.nullValue();
+            } else {
+                writer.value(String.valueOf(value));
+            }
+        }
+
+        public void writeMap(Map values) throws IOException {
+            writer.beginObject();
+            Iterator<?> it = values.entrySet().iterator();
+            while (it.hasNext()) {
+                Map.Entry<String, Object> pair = (Map.Entry) it.next();
+                String key = pair.getKey();
+                Object value = pair.getValue();
+                Object locationValue = null;
+                if (value instanceof String) {
+                    locationValue = location.getValueForKey((String)value);
+                }
+                writer.name(key);
+                writeValue(locationValue != null ? locationValue : value);
+            }
+            writer.endObject();
+        }
+
+        public void writeList(List values) throws IOException {
+            writer.beginArray();
+            Iterator<?> it = values.iterator();
+            while (it.hasNext()) {
+                Object value = it.next();
+                Object locationValue = null;
+                if (value instanceof  String) {
+                    locationValue = location.getValueForKey((String) value);
+                }
+                writeValue(locationValue != null ? locationValue : value);
+            }
+            writer.endArray();
+        }
+    }
+
+    private static class LocationWriter {
+        private JsonWriter writer = null;
+        private LocationTemplate template;
+
+        public LocationWriter(FileOutputStream fos, LocationTemplate template) throws IOException {
+            writer = new JsonWriter(new OutputStreamWriter(fos, "UTF-8"));
+            this.template = template;
+        }
+
+        public void beginArray() throws IOException {
+            writer.beginArray();
+        }
+
+        public void endArray() throws IOException {
+            writer.endArray();
+        }
+
+        public void close() throws IOException {
+            writer.close();
+        }
+
+        public void write(BackgroundLocation location) throws IOException {
+            LocationTemplateWriter writer = new LocationTemplateWriter(this.writer, location);
+            if (template instanceof HashMapLocationTemplate) {
+                HashMapLocationTemplate hashTemplate = (HashMapLocationTemplate) template;
+                writer.writeMap(hashTemplate.toMap());
+            } else if (template instanceof ArrayListLocationTemplate) {
+                ArrayListLocationTemplate listTemplate = (ArrayListLocationTemplate) template;
+                writer.writeList(listTemplate.toList());
+            }
+        }
+    }
+}

package/android/src/main/java/com/marianhello/bgloc/sync/NotificationHelper.java

@@ -0,0 +1,148 @@
+package com.marianhello.bgloc.sync;
+
+import android.app.Notification;
+import android.app.NotificationChannel;
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.content.Context;
+import android.content.Intent;
+import android.graphics.BitmapFactory;
+import android.graphics.Color;
+import android.os.Build;
+import androidx.annotation.RequiresApi;
+import androidx.core.app.NotificationCompat;
+
+import com.marianhello.bgloc.ResourceResolver;
+import com.marianhello.logging.LoggerManager;
+
+public class NotificationHelper {
+    public static final String SERVICE_CHANNEL_ID = "bglocservice";
+    // https://github.com/nishkarsh/android-permissions/blob/master/src/main/java/com/intentfilter/androidpermissions/services/NotificationService.java#L15
+    public static final String ANDROID_PERMISSIONS_CHANNEL_ID = "android-permissions";
+
+    public static final String SYNC_CHANNEL_ID = "syncservice";
+    public static final String SYNC_CHANNEL_NAME = "Sync Service";
+    public static final String SYNC_CHANNEL_DESCRIPTION = "Shows sync progress";
+
+    public static class NotificationFactory {
+        private Context mContext;
+        private ResourceResolver mResolver;
+
+        private org.slf4j.Logger logger;
+
+        public NotificationFactory(Context context) {
+            mContext = context;
+            mResolver = ResourceResolver.newInstance(context);
+            logger =  LoggerManager.getLogger(NotificationFactory.class);
+        }
+
+        private Integer parseNotificationIconColor(String color) {
+            int iconColor = 0;
+            if (color != null) {
+                try {
+                    iconColor = Color.parseColor(color);
+                } catch (IllegalArgumentException e) {
+                    logger.error("Couldn't parse color from android options");
+                }
+            }
+            return iconColor;
+        }
+
+        public Notification getNotification(String title, String text, String largeIcon, String smallIcon, String color) {
+            Context appContext = mContext.getApplicationContext();
+
+            // Build a Notification required for running service in foreground.
+            NotificationCompat.Builder builder = new NotificationCompat.Builder(mContext, NotificationHelper.SERVICE_CHANNEL_ID);
+
+            builder.setContentTitle(title);
+            builder.setContentText(text);
+            builder.setOngoing(true);
+            if (smallIcon != null && !smallIcon.isEmpty()) {
+                builder.setSmallIcon(mResolver.getDrawable(smallIcon));
+            } else {
+                builder.setSmallIcon(android.R.drawable.ic_menu_mylocation);
+            }
+            if (largeIcon != null && !largeIcon.isEmpty()) {
+                int largeIconId = mResolver.getDrawable(largeIcon);
+                if (largeIconId == 0) {
+                    logger.warn("The resource " + largeIcon + " was not found in the drawable folder. Please include it when building the app.");
+                }
+                builder.setLargeIcon(BitmapFactory.decodeResource(appContext.getResources(), largeIconId));
+            }
+            if (color != null && !color.isEmpty()) {
+                builder.setColor(this.parseNotificationIconColor(color));
+            }
+
+            // Add an onclick handler to the notification
+            String packageName = appContext.getPackageName();
+            Intent launchIntent = appContext.getPackageManager().getLaunchIntentForPackage(packageName);
+            if (launchIntent != null) {
+                // NOTICE: testing apps might not have registered launch intent
+                launchIntent.addFlags(Intent.FLAG_ACTIVITY_REORDER_TO_FRONT | Intent.FLAG_ACTIVITY_SINGLE_TOP);
+                int flags = Build.VERSION.SDK_INT >= Build.VERSION_CODES.S
+                        ? PendingIntent.FLAG_CANCEL_CURRENT | PendingIntent.FLAG_IMMUTABLE
+                        : PendingIntent.FLAG_CANCEL_CURRENT;
+                PendingIntent contentIntent = PendingIntent.getActivity(appContext, 0, launchIntent, flags);
+                builder.setContentIntent(contentIntent);
+            }
+
+            Notification notification = builder.build();
+            notification.flags |= Notification.FLAG_ONGOING_EVENT | Notification.FLAG_FOREGROUND_SERVICE | Notification.FLAG_NO_CLEAR;
+
+            return notification;
+        }
+    }
+
+    public static void registerAllChannels(Context context) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            String appName = ResourceResolver.newInstance(context).getString(("app_name"));
+            // Create the NotificationChannel, but only on API 26+ because
+            // the NotificationChannel class is new and not in the support library
+            android.app.NotificationManager notificationManager = (android.app.NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
+            notificationManager.createNotificationChannel(createServiceChannel(appName));
+            notificationManager.createNotificationChannel(createSyncChannel());
+            notificationManager.createNotificationChannel(createAndroidPermissionsChannel(appName));
+        }
+    }
+
+    public static void registerServiceChannel(Context context) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            String appName = ResourceResolver.newInstance(context).getString(("app_name"));
+            // Create the NotificationChannel, but only on API 26+ because
+            // the NotificationChannel class is new and not in the support library
+            android.app.NotificationManager notificationManager = (android.app.NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
+            notificationManager.createNotificationChannel(createServiceChannel(appName));
+        }
+    }
+
+    public static void registerSyncChannel(Context context) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            // Create the NotificationChannel, but only on API 26+ because
+            // the NotificationChannel class is new and not in the support library
+            android.app.NotificationManager notificationManager = (android.app.NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
+            notificationManager.createNotificationChannel(createSyncChannel());
+        }
+    }
+
+    @RequiresApi(api = Build.VERSION_CODES.O)
+    public static NotificationChannel createServiceChannel(CharSequence name) {
+        NotificationChannel channel = new NotificationChannel(SERVICE_CHANNEL_ID, name, android.app.NotificationManager.IMPORTANCE_LOW);
+        channel.enableVibration(false);
+        return channel;
+    }
+
+    @RequiresApi(api = Build.VERSION_CODES.O)
+    public static NotificationChannel createSyncChannel(){
+        NotificationChannel channel = new NotificationChannel(SYNC_CHANNEL_ID, SYNC_CHANNEL_NAME, NotificationManager.IMPORTANCE_LOW);
+        channel.setDescription(SYNC_CHANNEL_DESCRIPTION);
+        channel.enableVibration(false);
+        return channel;
+    }
+
+    @RequiresApi(api = Build.VERSION_CODES.O)
+    public static NotificationChannel createAndroidPermissionsChannel(CharSequence name ){
+        NotificationChannel channel = new NotificationChannel(ANDROID_PERMISSIONS_CHANNEL_ID, name, NotificationManager.IMPORTANCE_HIGH);
+        channel.enableVibration(false);
+        return channel;
+    }
+}

package/android/src/main/java/com/marianhello/bgloc/sync/SyncAdapter.java

@@ -0,0 +1,233 @@
+package com.marianhello.bgloc.sync;
+
+import android.accounts.Account;
+import android.app.NotificationManager;
+import android.content.AbstractThreadedSyncAdapter;
+import android.content.ContentProviderClient;
+import android.content.ContentResolver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.SyncResult;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.Looper;
+import androidx.core.app.NotificationCompat;
+import androidx.localbroadcastmanager.content.LocalBroadcastManager;
+
+import com.marianhello.bgloc.Config;
+import com.marianhello.bgloc.HttpPostService;
+import com.marianhello.bgloc.data.ConfigurationDAO;
+import com.marianhello.bgloc.data.DAOFactory;
+import com.marianhello.bgloc.service.LocationServiceImpl;
+import com.marianhello.logging.LoggerManager;
+
+import org.json.JSONException;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.HashMap;
+
+/**
+ * Handle the transfer of data between a server and an
+ * app, using the Android sync adapter framework.
+ */
+public class SyncAdapter extends AbstractThreadedSyncAdapter implements HttpPostService.UploadingProgressListener {
+
+    private static final int NOTIFICATION_ID = 666;
+
+    ContentResolver contentResolver;
+    private ConfigurationDAO configDAO;
+    private NotificationManager notificationManager;
+    private BatchManager batchManager;
+    private boolean notificationsEnabled = true;
+
+    private org.slf4j.Logger logger;
+
+    /**
+     * Set up the sync adapter
+     */
+    public SyncAdapter(Context context, boolean autoInitialize) {
+        this(context, autoInitialize, false);
+    }
+
+
+    /**
+     * Set up the sync adapter. This form of the
+     * constructor maintains compatibility with Android 3.0
+     * and later platform versions
+     */
+    public SyncAdapter(
+            Context context,
+            boolean autoInitialize,
+            boolean allowParallelSyncs) {
+
+        super(context, autoInitialize);
+        logger = LoggerManager.getLogger(SyncAdapter.class);
+
+        /*
+         * If your app uses a content resolver, get an instance of it
+         * from the incoming Context
+         */
+        contentResolver = context.getContentResolver();
+        configDAO = DAOFactory.createConfigurationDAO(context);
+        batchManager = new BatchManager(this.getContext());
+        notificationManager = (NotificationManager) getContext().getSystemService(Context.NOTIFICATION_SERVICE);
+
+        NotificationHelper.registerSyncChannel(context);
+    }
+
+    /*
+     * Specify the code you want to run in the sync adapter. The entire
+     * sync adapter runs in a background thread, so you don't have to set
+     * up your own background processing.
+     */
+    @Override
+    public void onPerformSync(
+            Account account,
+            Bundle extras,
+            String authority,
+            ContentProviderClient provider,
+            SyncResult syncResult) {
+
+        Config config = null;
+        try {
+            config = configDAO.retrieveConfiguration();
+        } catch (JSONException e) {
+            logger.error("Error retrieving config: {}", e.getMessage());
+        }
+
+        if (config == null || !config.hasValidSyncUrl()) {
+            return;
+        }
+
+        //noinspection ConstantConditions
+        notificationsEnabled = !config.hasNotificationsEnabled() || config.getNotificationsEnabled();
+
+        Long batchStartMillis = System.currentTimeMillis();
+        boolean isForced = extras.getBoolean(ContentResolver.SYNC_EXTRAS_MANUAL);
+        int syncThreshold = isForced ? 0 : config.getSyncThreshold();
+        logger.debug("Sync request isForced: {}, batchId: {}, config: {}", isForced, batchStartMillis, config.toString());
+
+        File file = null;
+        try {
+            file = batchManager.createBatch(batchStartMillis, syncThreshold, config.getTemplate());
+        } catch (IOException e) {
+            logger.error("Failed to create batch: {}", e.getMessage());
+        }
+
+        if (file == null) {
+            logger.info("Nothing to sync");
+            return;
+        }
+
+        logger.info("Syncing startAt: {}", batchStartMillis);
+        String url = config.getSyncUrl();
+        HashMap<String, String> httpHeaders = new HashMap<String, String>();
+        httpHeaders.putAll(config.getHttpHeaders());
+        httpHeaders.put("x-batch-id", String.valueOf(batchStartMillis));
+
+        if (uploadLocations(file, url, httpHeaders)) {
+            logger.info("Batch sync successful");
+            batchManager.setBatchCompleted(batchStartMillis);
+            if (file.delete()) {
+                logger.info("Batch file has been deleted: {}", file.getAbsolutePath());
+            } else {
+                logger.warn("Batch file has not been deleted: {}", file.getAbsolutePath());
+            }
+        } else {
+            logger.warn("Batch sync failed due server error");
+            syncResult.stats.numIoExceptions++;
+        }
+    }
+
+    private boolean uploadLocations(File file, String url, HashMap httpHeaders) {
+        NotificationCompat.Builder builder = null;
+
+        if (notificationsEnabled) {
+            builder = new NotificationCompat.Builder(getContext(), NotificationHelper.SYNC_CHANNEL_ID);
+            builder.setOngoing(true);
+            builder.setContentTitle("Syncing locations");
+            builder.setContentText("Sync in progress");
+            builder.setSmallIcon(android.R.drawable.ic_dialog_info);
+            notificationManager.notify(NOTIFICATION_ID, builder.build());
+        }
+
+        try {
+            int responseCode = HttpPostService.postJSONFile(url, file, httpHeaders, this);
+
+            // All 2xx statuses are okay
+            boolean isStatusOkay = responseCode >= 200 && responseCode < 300;
+
+            if (responseCode == 285) {
+                // Okay, but we don't need to continue sending these
+
+                logger.debug("Location was sent to the server, and received an \"HTTP 285 Updates Not Required\"");
+
+                Bundle bundle = new Bundle();
+                bundle.putInt("action", LocationServiceImpl.MSG_ON_ABORT_REQUESTED);
+                broadcastMessage(bundle);
+            }
+
+            if (responseCode == 401) {
+                Bundle bundle = new Bundle();
+                bundle.putInt("action", LocationServiceImpl.MSG_ON_HTTP_AUTHORIZATION);
+                broadcastMessage(bundle);
+            }
+
+            if (builder != null) {
+                if (isStatusOkay) {
+                    builder.setContentText("Sync completed");
+                } else {
+                    builder.setContentText("Sync failed due server error");
+                }
+            }
+
+            return isStatusOkay;
+        } catch (IOException e) {
+            logger.warn("Error uploading locations: {}", e.getMessage());
+
+            if (builder != null)
+                builder.setContentText("Sync failed: " + e.getMessage());
+        } finally {
+            logger.info("Syncing endAt: {}", System.currentTimeMillis());
+
+            if (builder != null) {
+                builder.setOngoing(false);
+                builder.setProgress(0, 0, false);
+                builder.setAutoCancel(true);
+                notificationManager.notify(NOTIFICATION_ID, builder.build());
+
+                Handler h = new Handler(Looper.getMainLooper());
+                long delayInMilliseconds = 5000;
+                h.postDelayed(new Runnable() {
+                    public void run() {
+                        logger.info("Notification cancelledAt: {}", System.currentTimeMillis());
+                        notificationManager.cancel(NOTIFICATION_ID);
+                    }
+                }, delayInMilliseconds);
+            }
+        }
+
+        return false;
+    }
+
+    public void onProgress(int progress) {
+        logger.debug("Syncing progress: {} updatedAt: {}", progress, System.currentTimeMillis());
+
+        if (notificationsEnabled) {
+            NotificationCompat.Builder builder = new NotificationCompat.Builder(getContext(), NotificationHelper.SYNC_CHANNEL_ID);
+            builder.setOngoing(true);
+            builder.setContentTitle("Syncing locations");
+            builder.setContentText("Sync in progress");
+            builder.setSmallIcon(android.R.drawable.ic_dialog_info);
+            builder.setProgress(100, progress, false);
+            notificationManager.notify(NOTIFICATION_ID, builder.build());
+        }
+    }
+
+    private void broadcastMessage(Bundle bundle) {
+        Intent intent = new Intent(LocationServiceImpl.ACTION_BROADCAST);
+        intent.putExtras(bundle);
+        LocalBroadcastManager.getInstance(getContext().getApplicationContext()).sendBroadcast(intent);
+    }
+}

package/android/src/main/java/com/marianhello/bgloc/sync/SyncService.java

@@ -0,0 +1,68 @@
+package com.marianhello.bgloc.sync;
+
+import android.accounts.Account;
+import android.app.Service;
+import android.content.ContentResolver;
+import android.content.Intent;
+import android.os.Bundle;
+import android.os.IBinder;
+
+/**
+ * Define a Service that returns an IBinder for the
+ * sync adapter class, allowing the sync adapter framework to call
+ * onPerformSync().
+ */
+public class SyncService extends Service {
+    // Storage for an instance of the sync adapter
+    private static SyncAdapter sSyncAdapter = null;
+    // Object to use as a thread-safe lock
+    private static final Object sSyncAdapterLock = new Object();
+
+    /**
+     * Instantiate the sync adapter object.
+     */
+    @Override
+    public void onCreate() {
+        /*
+         * Create the sync adapter as a singleton.
+         * Set the sync adapter as syncable
+         * Disallow parallel syncs
+         */
+        synchronized (sSyncAdapterLock) {
+            if (sSyncAdapter == null) {
+                sSyncAdapter = new SyncAdapter(getApplicationContext(), true);
+            }
+        }
+    }
+
+    /**
+     * Return an object that allows the system to invoke
+     * the sync adapter.
+     *
+     */
+    @Override
+    public IBinder onBind(Intent intent) {
+        /*
+         * Get the object that allows external processes
+         * to call onPerformSync(). The object is created
+         * in the base class code when the SyncAdapter
+         * constructors call super()
+         */
+        return sSyncAdapter.getSyncAdapterBinder();
+    }
+
+    public static void sync(Account account, String authority, boolean manual) {
+        // Pass the settings flags by inserting them in a bundle
+        Bundle settingsBundle = new Bundle();
+        settingsBundle.putBoolean(ContentResolver.SYNC_EXTRAS_MANUAL, manual);
+        settingsBundle.putBoolean(ContentResolver.SYNC_EXTRAS_EXPEDITED, manual);
+        settingsBundle.putBoolean(ContentResolver.SYNC_EXTRAS_DO_NOT_RETRY, false);
+        settingsBundle.putBoolean(ContentResolver.SYNC_EXTRAS_UPLOAD, true);
+
+        /*
+         * Request the sync for the default account, authority, and
+         * manual sync settings
+         */
+        ContentResolver.requestSync(account, authority, settingsBundle);
+    }
+}