Added support for persisting alarms across reboots

packages/android_alarm_manager/CHANGELOG.md

@@ -1,3 +1,27 @@
+## 0.4.1
+* Added support for setting alarms which persist across reboots.
+  * Both `AndroidAlarmManager.oneShot` and `AndroidAlarmManager.periodic` have
+    an optional `rescheduleOnReboot` parameter which specifies whether the new
+    alarm should be rescheduled to run after a reboot (default: false). If set
+    to false, the alarm will not survive a device reboot.
+  * Requires AndroidManifest.xml to be updated to include the following
+    entries:
+
+    ```xml
+    <!--Within the application tag body-->
+    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED"/>
+
+    <!--Within the manifest tag body-->
+    <receiver
+        android:name="io.flutter.plugins.androidalarmmanager.RebootBroadcastReceiver"
+        android:enabled="false">
+        <intent-filter>
+            <action android:name="android.intent.action.BOOT_COMPLETED"></action>
+        </intent-filter>
+    </receiver>
+
+    ```
+
 ## 0.4.0
 * **Breaking change**. Migrated the underlying AlarmService to utilize a
   BroadcastReceiver with a JobIntentService instead of a Service to handle

packages/android_alarm_manager/README.md

@@ -8,7 +8,13 @@ Dart code in the background when alarms fire.
 ## Getting Started
 
 After importing this plugin to your project as usual, add the following to your
-`AndroidManifest.xml`:
+`AndroidManifest.xml` within the `<manifest></manifest>` tags:
+
+```xml
+<uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED"/>
+```
+
+Next, within the `<application></application>` tags, add:
 
 ```xml
 <service
@@ -18,6 +24,14 @@ After importing this plugin to your project as usual, add the following to your
 <receiver
     android:name="io.flutter.plugins.androidalarmmanager.AlarmBroadcastReceiver"
     android:exported="false"/>
+<receiver
+    android:name="io.flutter.plugins.androidalarmmanager.RebootBroadcastReceiver"
+    android:enabled="false">
+    <intent-filter>
+        <action android:name="android.intent.action.BOOT_COMPLETED"></action>
+    </intent-filter>
+</receiver>
+
 ```
 
 Then in Dart code add:

packages/android_alarm_manager/android/src/main/java/io/flutter/plugins/androidalarmmanager/AlarmService.java

@@ -18,16 +18,23 @@
 import io.flutter.view.FlutterNativeView;
 import io.flutter.view.FlutterRunArguments;
 import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
 import java.util.Iterator;
 import java.util.LinkedList;
 import java.util.List;
+import java.util.Set;
 import java.util.concurrent.atomic.AtomicBoolean;
+import org.json.JSONException;
+import org.json.JSONObject;
 
 public class AlarmService extends JobIntentService {
   public static final String TAG = "AlarmService";
-  private static final String SHARED_PREFERENCES_KEY = "io.flutter.android_alarm_manager_plugin";
   private static final String CALLBACK_HANDLE_KEY = "callback_handle";
+  private static final String PERSISTENT_ALARMS_SET_KEY = "persistent_alarm_ids";
+  private static final String SHARED_PREFERENCES_KEY = "io.flutter.android_alarm_manager_plugin";
   private static final int JOB_ID = 1984; // Random job ID.
+  private static final Object sPersistentAlarmsLock = new Object();
   private static AtomicBoolean sStarted = new AtomicBoolean(false);
   private static List<Intent> sAlarmQueue = Collections.synchronizedList(new LinkedList<Intent>());
   private static FlutterNativeView sBackgroundFlutterView;
@@ -168,7 +175,20 @@ private static void scheduleAlarm(
       boolean wakeup,
       long startMillis,
       long intervalMillis,
+      boolean rescheduleOnReboot,
       long callbackHandle) {
+    if (rescheduleOnReboot) {
+      addPersistentAlarm(
+          context,
+          requestCode,
+          repeating,
+          exact,
+          wakeup,
+          startMillis,
+          intervalMillis,
+          callbackHandle);
+    }
+
     // Create an Intent for the alarm and set the desired Dart callback handle.
     Intent alarm = new Intent(context, AlarmBroadcastReceiver.class);
     alarm.putExtra("callbackHandle", callbackHandle);
@@ -204,9 +224,19 @@ public static void setOneShot(
       boolean exact,
       boolean wakeup,
       long startMillis,
+      boolean rescheduleOnReboot,
       long callbackHandle) {
     final boolean repeating = false;
-    scheduleAlarm(context, requestCode, repeating, exact, wakeup, startMillis, 0, callbackHandle);
+    scheduleAlarm(
+        context,
+        requestCode,
+        repeating,
+        exact,
+        wakeup,
+        startMillis,
+        0,
+        rescheduleOnReboot,
+        callbackHandle);
   }
 
   public static void setPeriodic(
@@ -216,6 +246,7 @@ public static void setPeriodic(
       boolean wakeup,
       long startMillis,
       long intervalMillis,
+      boolean rescheduleOnReboot,
       long callbackHandle) {
     final boolean repeating = true;
     scheduleAlarm(
@@ -226,10 +257,15 @@ public static void setPeriodic(
         wakeup,
         startMillis,
         intervalMillis,
+        rescheduleOnReboot,
         callbackHandle);
   }
 
   public static void cancel(Context context, int requestCode) {
+    // Clear the alarm if it was set to be rescheduled after reboots.
+    clearPersistentAlarm(context, requestCode);
+
+    // Cancel the alarm with the system alarm service.
     Intent alarm = new Intent(context, AlarmBroadcastReceiver.class);
     PendingIntent existingIntent =
         PendingIntent.getBroadcast(context, requestCode, alarm, PendingIntent.FLAG_NO_CREATE);
@@ -240,4 +276,110 @@ public static void cancel(Context context, int requestCode) {
     AlarmManager manager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
     manager.cancel(existingIntent);
   }
+
+  private static String getPersistentAlarmKey(int requestCode) {
+    return "android_alarm_manager/persistent_alarm_" + Integer.toString(requestCode);
+  }
+
+  private static void addPersistentAlarm(
+      Context context,
+      int requestCode,
+      boolean repeating,
+      boolean exact,
+      boolean wakeup,
+      long startMillis,
+      long intervalMillis,
+      long callbackHandle) {
+    HashMap<String, Object> alarmSettings = new HashMap<>();
+    alarmSettings.put("repeating", repeating);
+    alarmSettings.put("exact", exact);
+    alarmSettings.put("wakeup", wakeup);
+    alarmSettings.put("startMillis", startMillis);
+    alarmSettings.put("intervalMillis", intervalMillis);
+    alarmSettings.put("callbackHandle", callbackHandle);
+    JSONObject obj = new JSONObject(alarmSettings);
+    String key = getPersistentAlarmKey(requestCode);
+    SharedPreferences p = context.getSharedPreferences(SHARED_PREFERENCES_KEY, 0);
+
+    synchronized (sPersistentAlarmsLock) {
+      Set<String> persistentAlarms = p.getStringSet(PERSISTENT_ALARMS_SET_KEY, null);
+      if (persistentAlarms == null) {
+        persistentAlarms = new HashSet<>();
+      }
+      if (persistentAlarms.isEmpty()) {
+        RebootBroadcastReceiver.enableRescheduleOnReboot(context);
+      }
+      persistentAlarms.add(Integer.toString(requestCode));
+      p.edit()
+          .putString(key, obj.toString())
+          .putStringSet(PERSISTENT_ALARMS_SET_KEY, persistentAlarms)
+          .commit();
+    }
+  }
+
+  private static void clearPersistentAlarm(Context context, int requestCode) {
+    SharedPreferences p = context.getSharedPreferences(SHARED_PREFERENCES_KEY, 0);
+    synchronized (sPersistentAlarmsLock) {
+      Set<String> persistentAlarms = p.getStringSet(PERSISTENT_ALARMS_SET_KEY, null);
+      if ((persistentAlarms == null) || !persistentAlarms.contains(requestCode)) {
+        return;
+      }
+      persistentAlarms.remove(requestCode);
+      String key = getPersistentAlarmKey(requestCode);
+      p.edit().remove(key).putStringSet(PERSISTENT_ALARMS_SET_KEY, persistentAlarms).commit();
+
+      if (persistentAlarms.isEmpty()) {
+        RebootBroadcastReceiver.disableRescheduleOnReboot(context);
+      }
+    }
+  }
+
+  public static void reschedulePersistentAlarms(Context context) {
+    synchronized (sPersistentAlarmsLock) {
+      SharedPreferences p = context.getSharedPreferences(SHARED_PREFERENCES_KEY, 0);
+      Set<String> persistentAlarms = p.getStringSet(PERSISTENT_ALARMS_SET_KEY, null);
+      // No alarms to reschedule.
+      if (persistentAlarms == null) {
+        return;
+      }
+
+      Iterator<String> it = persistentAlarms.iterator();
+      while (it.hasNext()) {
+        int requestCode = Integer.parseInt(it.next());
+        String key = getPersistentAlarmKey(requestCode);
+        String json = p.getString(key, null);
+        if (json == null) {
+          Log.e(
+              TAG, "Data for alarm request code " + Integer.toString(requestCode) + " is invalid.");
+          continue;
+        }
+        try {
+          JSONObject alarm = new JSONObject(json);
+          boolean repeating = alarm.getBoolean("repeating");
+          boolean exact = alarm.getBoolean("exact");
+          boolean wakeup = alarm.getBoolean("wakeup");
+          long startMillis = alarm.getLong("startMillis");
+          long intervalMillis = alarm.getLong("intervalMillis");
+          long callbackHandle = alarm.getLong("callbackHandle");
+          scheduleAlarm(
+              context,
+              requestCode,
+              repeating,
+              exact,
+              wakeup,
+              startMillis,
+              intervalMillis,
+              false,
+              callbackHandle);
+        } catch (JSONException e) {
+          Log.e(
+              TAG,
+              "Data for alarm request code "
+                  + Integer.toString(requestCode)
+                  + " is invalid: "
+                  + json);
+        }
+      }
+    }
+  }
 }

packages/android_alarm_manager/android/src/main/java/io/flutter/plugins/androidalarmmanager/AndroidAlarmManagerPlugin.java

@@ -81,8 +81,10 @@ private void oneShot(JSONArray arguments) throws JSONException {
     boolean exact = arguments.getBoolean(1);
     boolean wakeup = arguments.getBoolean(2);
     long startMillis = arguments.getLong(3);
-    long callbackHandle = arguments.getLong(4);
-    AlarmService.setOneShot(mContext, requestCode, exact, wakeup, startMillis, callbackHandle);
+    boolean rescheduleOnReboot = arguments.getBoolean(4);
+    long callbackHandle = arguments.getLong(5);
+    AlarmService.setOneShot(
+        mContext, requestCode, exact, wakeup, startMillis, rescheduleOnReboot, callbackHandle);
   }
 
   private void periodic(JSONArray arguments) throws JSONException {
@@ -91,9 +93,17 @@ private void periodic(JSONArray arguments) throws JSONException {
     boolean wakeup = arguments.getBoolean(2);
     long startMillis = arguments.getLong(3);
     long intervalMillis = arguments.getLong(4);
-    long callbackHandle = arguments.getLong(5);
+    boolean rescheduleOnReboot = arguments.getBoolean(5);
+    long callbackHandle = arguments.getLong(6);
     AlarmService.setPeriodic(
-        mContext, requestCode, exact, wakeup, startMillis, intervalMillis, callbackHandle);
+        mContext,
+        requestCode,
+        exact,
+        wakeup,
+        startMillis,
+        intervalMillis,
+        rescheduleOnReboot,
+        callbackHandle);
   }
 
   private void cancel(JSONArray arguments) throws JSONException {

packages/android_alarm_manager/android/src/main/java/io/flutter/plugins/androidalarmmanager/RebootBroadcastReceiver.java

@@ -0,0 +1,36 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package io.flutter.plugins.androidalarmmanager;
+
+import android.content.BroadcastReceiver;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.util.Log;
+
+public class RebootBroadcastReceiver extends BroadcastReceiver {
+  @Override
+  public void onReceive(Context context, Intent intent) {
+    if (intent.getAction().equals("android.intent.action.BOOT_COMPLETED")) {
+      Log.i("AlarmService", "Rescheduling after boot!");
+      AlarmService.reschedulePersistentAlarms(context);
+    }
+  }
+
+  public static void enableRescheduleOnReboot(Context context) {
+    scheduleOnReboot(context, PackageManager.COMPONENT_ENABLED_STATE_ENABLED);
+  }
+
+  public static void disableRescheduleOnReboot(Context context) {
+    scheduleOnReboot(context, PackageManager.COMPONENT_ENABLED_STATE_DISABLED);
+  }
+
+  private static void scheduleOnReboot(Context context, int state) {
+    ComponentName receiver = new ComponentName(context, RebootBroadcastReceiver.class);
+    PackageManager pm = context.getPackageManager();
+    pm.setComponentEnabledSetting(receiver, state, PackageManager.DONT_KILL_APP);
+  }
+}

packages/android_alarm_manager/example/android/app/src/main/AndroidManifest.xml

@@ -1,6 +1,7 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
     package="io.flutter.plugins.androidalarmmanagerexample">
 
+    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED"/>
     <uses-permission android:name="android.permission.INTERNET"/>
 
     <application
@@ -29,5 +30,12 @@
         <receiver
             android:name="io.flutter.plugins.androidalarmmanager.AlarmBroadcastReceiver"
             android:exported="false"/>
+        <receiver
+            android:name="io.flutter.plugins.androidalarmmanager.RebootBroadcastReceiver"
+            android:enabled="false">
+            <intent-filter>
+                <action android:name="android.intent.action.BOOT_COMPLETED"></action>
+            </intent-filter>
+        </receiver>
     </application>
 </manifest>