Merge lp:~karni/ubuntuone-android-files/sync-on-inexact-alarms into lp:ubuntuone-android-files

[Michał Karnicki]

Instead of using custom sync intervals this uses Androids inexact alarms, which are aligned with alarms of other apps, waking up the device less often and possibly saving battery lifetime. The intervals introduced are: 15", 30", 1h, half day, day, and all are inexact alarms with mentioned advantages.

[Chad Miller (cmiller)]

Haven't tested, but this looks good.

review: Approve

=== modified file 'AndroidManifest.xml'
--- AndroidManifest.xml	2011-03-11 01:48:05 +0000
+++ AndroidManifest.xml	2011-03-23 13:41:29 +0000
@@ -2,8 +2,8 @@
 <manifest
 	xmlns:android="http://schemas.android.com/apk/res/android"
 	package="com.ubuntuone.android.files"
-	android:versionCode="47"
-	android:versionName="1.1.47" >
+	android:versionCode="48"
+	android:versionName="1.1.48" >
 	
     <uses-sdk
     	android:minSdkVersion="6"

=== modified file 'res/values/values.xml'
--- res/values/values.xml	2011-03-08 00:40:29 +0000
+++ res/values/values.xml	2011-03-23 13:41:29 +0000
@@ -1,23 +1,13 @@
 <?xml version="1.0" encoding="utf-8"?>
 <resources>
 	<string-array name="sync_frequency_entries">
-		<item>5 minutes</item>
+		<item>15 minutes</item>
 		<item>30 minutes</item>
 		<item>1 hour</item>
-		<item>3 hours</item>
-		<item>6 hours</item>
+		<item>12 hours</item>
 		<item>daily</item>
 		<item>manual (off)</item>
 	</string-array>
-	<string-array name="sync_frequency_values">
-		<item>5</item>
-		<item>30</item>
-		<item>60</item>
-		<item>180</item>
-		<item>360</item>
-		<item>1440</item>
-		<item>-1</item>
-	</string-array>
 	
 	<string-array name="transfer_limit_entries">
 		<item>unlimited</item>

=== modified file 'res/xml/prefs.xml'
--- res/xml/prefs.xml	2011-03-06 03:36:02 +0000
+++ res/xml/prefs.xml	2011-03-23 13:41:29 +0000
@@ -54,11 +54,10 @@
 			<ListPreference
 				android:key="sync_policy_frequency"
 				android:persistent="true"
-				android:defaultValue="60"
+				android:defaultValue="3600000"
 				android:title="@string/sync_frequency_title"
 				android:summary="@string/sync_frequency_summary"
-				android:entries="@array/sync_frequency_entries"
-				android:entryValues="@array/sync_frequency_values" />
+				android:entries="@array/sync_frequency_entries" />
 				
 		</PreferenceScreen>
 		

=== modified file 'src/com/ubuntuone/android/files/Preferences.java'
--- src/com/ubuntuone/android/files/Preferences.java	2011-03-11 01:48:05 +0000
+++ src/com/ubuntuone/android/files/Preferences.java	2011-03-23 13:41:29 +0000
@@ -22,6 +22,7 @@
 
 package com.ubuntuone.android.files;
 
+import android.app.AlarmManager;
 import android.app.AlertDialog;
 import android.content.Context;
 import android.content.DialogInterface;
@@ -209,13 +210,18 @@
 		
 		ListPreference syncFrequency =
 			(ListPreference) findPreference(Options.SYNC_POLICY_FREQUENCY);
+		syncFrequency.setEntryValues(new String[] {
+			String.valueOf(AlarmManager.INTERVAL_FIFTEEN_MINUTES),
+			String.valueOf(AlarmManager.INTERVAL_HALF_HOUR),
+			String.valueOf(AlarmManager.INTERVAL_HOUR),
+			String.valueOf(AlarmManager.INTERVAL_HALF_DAY),
+			String.valueOf(AlarmManager.INTERVAL_DAY),
+			String.valueOf(-1)
+		});
 		syncFrequency.setOnPreferenceChangeListener(new OnPreferenceChangeListener() {
-			
 			public boolean onPreferenceChange(Preference preference, Object newValue) {
-				Log.i(TAG, "periodic sync set to interval: " + newValue.toString());
-					//getString(Preferences.Options.SYNC_POLICY_FREQUENCY, "-1"));
-					UbuntuOneFiles.registerSyncAlarm(getApplicationContext(),
-							Integer.valueOf(newValue.toString()));
+				UbuntuOneFiles.registerSyncAlarm(getApplicationContext(),
+						Long.valueOf(newValue.toString()));
 				return true;
 			}
 		});
@@ -565,8 +571,8 @@
 		editor.commit();
 	}
 	
-	public static Integer getSyncInterval() {
-		return Integer.valueOf(Preferences.getString(
+	public static Long getSyncInterval() {
+		return Long.valueOf(Preferences.getString(
 				Preferences.Options.SYNC_POLICY_FREQUENCY,
 				String.valueOf(SyncDaemon.SYNC_TRIGGER_INTERVAL_DEFAULT)));
 	}

=== modified file 'src/com/ubuntuone/android/files/UbuntuOneFiles.java'
--- src/com/ubuntuone/android/files/UbuntuOneFiles.java	2011-03-10 00:00:57 +0000
+++ src/com/ubuntuone/android/files/UbuntuOneFiles.java	2011-03-23 13:41:29 +0000
@@ -37,7 +37,6 @@
 import android.os.Handler;
 import android.os.Message;
 import android.os.PowerManager;
-import android.os.Handler.Callback;
 import android.os.PowerManager.WakeLock;
 import android.preference.PreferenceManager;
 
@@ -48,9 +47,9 @@
 import com.ubuntuone.android.files.syncdaemon.MsgArgs;
 import com.ubuntuone.android.files.syncdaemon.QueueManager;
 import com.ubuntuone.android.files.syncdaemon.SyncDaemon;
-import com.ubuntuone.android.files.syncdaemon.VolumeManager;
 import com.ubuntuone.android.files.syncdaemon.states.Node;
 import com.ubuntuone.android.files.syncdaemon.states.StateManager;
+import com.ubuntuone.android.files.util.DateUtilities;
 import com.ubuntuone.android.files.util.Util;
 import com.ubuntuone.android.files.util.OAuthUtilities.OAuthClient;
 import com.ubuntuone.android.util.log.Log;
@@ -66,8 +65,6 @@
 	
 	private EventQueue mEventQueue;
 	
-	private VolumeManager mVolumeManager;
-	
 	private StateManager mStateManager;
 	
 	private Handler mHandler;
@@ -156,13 +153,13 @@
 	
 	// --- event handling ------------------------------------------------------
 	
-	Handler.Callback mHandlerCallback = new Callback() {
+	Handler.Callback mHandlerCallback = new Handler.Callback() {
 		public boolean handleMessage(Message msg) {
 			boolean inForeground = sForegroundActivity != null
 					&& sForegroundActivity.get() != null;
 			switch (msg.what) {
 			case R.string.SYS_BOOT_COMPLETED:
-				registerSyncAlarm(sApplicationInstance, 0);
+				registerSyncAlarm(sApplicationInstance, 0L);
 				sApplicationInstance.releaseLocks();
 				break;
 			case R.string.SYS_HANDSHAKE_TIMEOUT:
@@ -283,56 +280,110 @@
 	}
 	
 	// --- sync alarm ----------------------------------------------------------
-	
+
+	/**
+	 * Registers sync alarm if:<br />
+	 * - the tokens are in place<br />
+	 * - sync is not disabled<br />
+	 * - alarm is registered, but needs to be rescheduled
+	 * 
+	 * @param context
+	 *            the context
+	 * @param reschedule
+	 *            true in case an already registered inexact alarm should be
+	 *            rescheduled. We use this to further increase battery life and
+	 *            limit unnecessary sync requests.
+	 */
 	public static void maybeRegisterSyncAlarm(Context context, boolean reschedule) {
 		if (!hasValidTokens()) {
-			Log.i(TAG, "not registering sync alarm, no tokens");
-			return;
-		}
-		
-		Integer syncInterval = Preferences.getSyncInterval();
-		if (syncInterval == -1) {
-			Log.d(TAG, "sync disabled, not scheduling");
-			return;
-		}
-		
-		// Set up sync intent, and it's pending intent.
+			Log.w(TAG, "*** not scheduling sync, no tokens ***");
+			return;
+		}
+		
+		Long syncInterval = Preferences.getSyncInterval();
+		if (syncInterval == -1L) {
+			Log.i(TAG, "*** not scheduling sync, disabled ***");
+			return;
+		}
+		
+		// Set up sync intent, and it's pending intent (no-create check)
 		Intent syncIntent = new Intent(SyncDaemon.ACTION_SCHEDULED_SYNC);
 		PendingIntent pendingIntent = PendingIntent.getService(context, 0,
 				syncIntent, PendingIntent.FLAG_NO_CREATE);
 		
 		if (pendingIntent == null || reschedule) {
 			if (!reschedule)
-				Log.i(TAG, "*** alarm not scheduled, registering ***");
+				Log.i(TAG, "*** sync not scheduled, registering ***");
 			else
-				Log.i(TAG, "*** re-scheduling alarm ***");
-			registerSyncAlarm(context, 0);
+				Log.i(TAG, "*** sync already scheduled, re-scheduling ***");
+			registerSyncAlarm(context, 0L);
 		}
 	}
-	
-	public static void registerSyncAlarm(Context context, Integer syncInterval) {
-		if (syncInterval == 0)
+
+	/**
+	 * Cancels any previously registered alarm to sync and registers a new,
+	 * inexact alarm to sync. Inexact alarms are aligned by Android, so this
+	 * should give us some battery life improvement.
+	 * 
+	 * Only Preferences -> Sync policy -> Frequency should call this directly.
+	 * 
+	 * @param context
+	 *            the context
+	 * @param syncInterval
+	 *            can be either 0, in which case syncInterval value will be
+	 *            pulled from the Preferences, or any of inexact alarm values.
+	 *            It can also be -1L, which means sync is turned off.
+	 */
+	public static void registerSyncAlarm(Context context, Long syncInterval) {		
+		if (syncInterval == 0L)
 			syncInterval = Preferences.getSyncInterval();
+		long inexactInterval = -1L;
 		
-		// Convert to miliseconds, given minutes.
-		Log.d(TAG, "sync interval, minutes: " + syncInterval);
-		syncInterval *= 60*1000;
+		// Doh! switch does not support cases of type long
+		if (syncInterval == AlarmManager.INTERVAL_FIFTEEN_MINUTES) {
+			Log.i(TAG, "sync interval set to fifteen minutes");
+			inexactInterval = AlarmManager.INTERVAL_FIFTEEN_MINUTES;
+			syncInterval = DateUtilities.MILLIS_IN_15_MINUTES;
+		} else if (syncInterval == AlarmManager.INTERVAL_HALF_HOUR) {
+			Log.i(TAG, "sync interval set to half hour");
+			inexactInterval = AlarmManager.INTERVAL_HALF_HOUR;
+			syncInterval = DateUtilities.MILLIS_IN_HALF_HOUR;
+		} else if (syncInterval == AlarmManager.INTERVAL_HOUR) {
+			Log.i(TAG, "sync interval set to hour");
+			inexactInterval = AlarmManager.INTERVAL_HOUR;
+			syncInterval = DateUtilities.MILLIS_IN_HOUR;
+		} else if (syncInterval == AlarmManager.INTERVAL_HALF_DAY) {
+			Log.i(TAG, "sync interval set to half day");
+			inexactInterval = AlarmManager.INTERVAL_HALF_DAY;
+			syncInterval = DateUtilities.MILLIS_IN_HALF_DAY;
+		} else if (syncInterval == AlarmManager.INTERVAL_DAY) {
+			Log.i(TAG, "sync interval set to day");
+			inexactInterval = AlarmManager.INTERVAL_DAY;
+			syncInterval = DateUtilities.MILLIS_IN_DAY;
+		} else if (syncInterval == -1L) {
+			Log.i(TAG, "sync interval set to -1 (sync off)");
+			inexactInterval = syncInterval = -1L;
+			// We don't return here, since in such case the previous alarm
+			// should be canceled, which follows.
+		} else {
+			Log.e(TAG, "no such sync interval: " + inexactInterval);
+			return;
+		}
 		
 		// Set up sync intent, and it's pending intent.
 		Intent syncIntent = new Intent(SyncDaemon.ACTION_SCHEDULED_SYNC);
 		PendingIntent pendingIntent = PendingIntent.getService(context, 0,
 				syncIntent, 0);
 		
-		// Schedule the sync operation.
-		AlarmManager am = (AlarmManager) context
+		// Cancel previous alarm and schedule new sync inexact alarm.
+		final AlarmManager am = (AlarmManager) context
 				.getSystemService(Service.ALARM_SERVICE);
-		// Cancel the previous alarm first.
 		am.cancel(pendingIntent);
 		
-		if (syncInterval > 0) {
-			am.setRepeating(AlarmManager.RTC_WAKEUP,
-					System.currentTimeMillis() + syncInterval,						
-					syncInterval,
+		if (syncInterval != -1L) {
+			am.setInexactRepeating(AlarmManager.RTC_WAKEUP,
+					System.currentTimeMillis() + syncInterval,
+					inexactInterval,
 					pendingIntent);
 		}
 	}

=== modified file 'src/com/ubuntuone/android/files/syncdaemon/SyncDaemon.java'
--- src/com/ubuntuone/android/files/syncdaemon/SyncDaemon.java	2011-03-11 01:15:18 +0000
+++ src/com/ubuntuone/android/files/syncdaemon/SyncDaemon.java	2011-03-23 13:41:29 +0000
@@ -25,6 +25,7 @@
 import java.util.Arrays;
 import java.util.Map;
 
+import android.app.AlarmManager;
 import android.app.Notification;
 import android.app.NotificationManager;
 import android.app.PendingIntent;
@@ -89,8 +90,9 @@
 	
 	private final int IDLE_TIMEOUT_MS = 90*1000; // miliseconds
 	
-	/** Unused, this *should* pull a defaultValue from prefs, in minutes. */
-	public final static long SYNC_TRIGGER_INTERVAL_DEFAULT = 30;
+	/** Unused, this *should* pull a defaultValue from prefs. */
+	public final static long SYNC_TRIGGER_INTERVAL_DEFAULT =
+			AlarmManager.INTERVAL_HOUR;
 	
 	
 	/**

=== modified file 'src/com/ubuntuone/android/files/util/DateUtilities.java'
--- src/com/ubuntuone/android/files/util/DateUtilities.java	2010-12-21 16:16:54 +0000
+++ src/com/ubuntuone/android/files/util/DateUtilities.java	2011-03-23 13:41:29 +0000
@@ -33,7 +33,13 @@
  */
 public class DateUtilities {
 	
-	private static int MILLIS_IN_SECOND = 1000;
+	public static final Long MILLIS_IN_SECOND = 1000L;
+	public static final Long MILLIS_IN_MINUTE = 60*MILLIS_IN_SECOND;
+	public static final Long MILLIS_IN_15_MINUTES = 15*MILLIS_IN_MINUTE;
+	public static final Long MILLIS_IN_HALF_HOUR = 2*MILLIS_IN_15_MINUTES;
+	public static final Long MILLIS_IN_HOUR = 2*MILLIS_IN_HALF_HOUR;
+	public static final Long MILLIS_IN_HALF_DAY = 12*MILLIS_IN_HOUR;
+	public static final Long MILLIS_IN_DAY = 2*MILLIS_IN_HALF_DAY;
 	
 	private static Format dateFormatter = new SimpleDateFormat("MMM dd");