Added sync background service

src/com/todoroo/astrid/sync/SyncBackgroundService.java

@@ -0,0 +1,150 @@
+package com.todoroo.astrid.sync;
+
+import android.app.AlarmManager;
+import android.app.PendingIntent;
+import android.app.Service;
+import android.content.Context;
+import android.content.Intent;
+import android.os.IBinder;
+import android.util.Log;
+
+import com.todoroo.andlib.service.Autowired;
+import com.todoroo.andlib.service.ContextManager;
+import com.todoroo.andlib.service.DependencyInjectionService;
+import com.todoroo.andlib.service.ExceptionService;
+import com.todoroo.andlib.utility.DateUtilities;
+import com.todoroo.andlib.utility.Preferences;
+
+/**
+ * Performs synchronization service logic in background service to avoid
+ * ANR (application not responding) messages.
+ * <p>
+ * Starting this service
+ * schedules a repeating alarm which handles
+ * synchronization with your serv
+ *
+ * @author Tim Su
+ *
+ */
+abstract public class SyncBackgroundService extends Service {
+
+ /** Minimum time before an auto-sync */
+ private static final long AUTO_SYNC_MIN_OFFSET = 5*60*1000L;
+
+ /** alarm identifier */
+ public static final String SYNC_ACTION = "sync"; //$NON-NLS-1$
+
+ @Autowired private ExceptionService exceptionService;
+
+ // --- abstract methods
+
+ abstract protected SyncProvider<?> getSyncProvider();
+
+ abstract protected SyncProviderUtilities getSyncUtilities();
+
+ // --- implementation
+
+ public SyncBackgroundService() {
+ DependencyInjectionService.getInstance().inject(this);
+ }
+
+ /** Receive the alarm - start the synchronize service! */
+ @Override
+ public void onStart(Intent intent, int startId) {
+ try {
+ if(intent != null && SYNC_ACTION.equals(intent.getAction()))
+ startSynchronization(this);
+ } catch (Exception e) {
+ exceptionService.reportError(getSyncUtilities().getIdentifier() + "-bg-sync", e); //$NON-NLS-1$
+ }
+ }
+
+ /** Start the actual synchronization */
+ private void startSynchronization(Context context) {
+ if(context == null || context.getResources() == null)
+ return;
+
+ ContextManager.setContext(context);
+
+ if(!getSyncUtilities().isLoggedIn())
+ return;
+
+ getSyncProvider().synchronize(context);
+ }
+
+
+ @Override
+ public IBinder onBind(Intent intent) {
+ return null;
+ }
+
+ // --- alarm management
+
+ /**
+ * Schedules repeating alarm for auto-synchronization
+ */
+ public void scheduleService() {
+ int syncFrequencySeconds = Preferences.getIntegerFromString(
+ getSyncUtilities().getSyncIntervalKey(), -1);
+ Context context = ContextManager.getContext();
+ if(syncFrequencySeconds <= 0) {
+ unscheduleService(context);
+ return;
+ }
+
+ // figure out synchronization frequency
+ long interval = 1000L * syncFrequencySeconds;
+ long offset = computeNextSyncOffset(interval);
+
+ // give a little padding
+ offset = Math.max(offset, AUTO_SYNC_MIN_OFFSET);
+
+ AlarmManager am = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
+ PendingIntent pendingIntent = PendingIntent.getService(context, 0,
+ createAlarmIntent(context), PendingIntent.FLAG_UPDATE_CURRENT);
+
+ Log.i("Astrid", "Autosync set for " + offset / 1000 //$NON-NLS-1$ //$NON-NLS-2$
+ + " seconds repeating every " + syncFrequencySeconds); //$NON-NLS-1$
+
+ // cancel all existing
+ am.cancel(pendingIntent);
+
+ // schedule new
+ am.setRepeating(AlarmManager.RTC_WAKEUP, System.currentTimeMillis() + offset,
+ interval, pendingIntent);
+ }
+
+
+ /**
+ * Removes repeating alarm for auto-synchronization
+ */
+ private void unscheduleService(Context context) {
+ AlarmManager am = (AlarmManager)context.getSystemService(Context.ALARM_SERVICE);
+ PendingIntent pendingIntent = PendingIntent.getService(context, 0,
+ createAlarmIntent(context), PendingIntent.FLAG_UPDATE_CURRENT);
+ am.cancel(pendingIntent);
+ }
+
+ /** Create the alarm intent */
+ private Intent createAlarmIntent(Context context) {
+ Intent intent = new Intent(context, getClass());
+ intent.setAction(SYNC_ACTION);
+ return intent;
+ }
+
+ // --- utility methods
+
+
+ private long computeNextSyncOffset(long interval) {
+ // figure out last synchronize time
+ long lastSyncDate = getSyncUtilities().getLastSyncDate();
+
+ // if user never synchronized, give them a full offset period before bg sync
+ if(lastSyncDate != 0)
+ return Math.max(0, lastSyncDate + interval - DateUtilities.now());
+ else
+ return interval;
+ }
+
+
+}