Use JobScheduler for push (#735)

* Use JobScheduler for push

* Rearrange tests

* Rename PushService26 to PushServiceApi26

Author: natario1

Parse/src/main/AndroidManifest.xml

@@ -13,5 +13,11 @@
     <uses-permission android:name="android.permission.INTERNET"/>
     <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
 
-    <application />
+    <application>
+        <service
+            android:name=".PushServiceApi26"
+            android:permission="android.permission.BIND_JOB_SERVICE"
+            android:exported="true"/>
+    </application>
+
 </manifest>

Parse/src/main/java/com/parse/GcmBroadcastReceiver.java

@@ -20,6 +20,6 @@ public class GcmBroadcastReceiver extends BroadcastReceiver {
   @Override
   @CallSuper
   public void onReceive(Context context, Intent intent) {
-    ServiceUtils.runWakefulIntentInService(context, intent, PushService.class);
+    PushServiceUtils.runService(context, intent);
   }
 }

Parse/src/main/java/com/parse/ManifestInfo.java

@@ -180,7 +180,7 @@ private static PushType findPushType() {
       return PushType.NONE;
     }
 
-    if (!PushService.isSupported()) {
+    if (!PushServiceUtils.isSupported()) {
       return PushType.NONE;
     }
 

Parse/src/main/java/com/parse/Parse.java

@@ -413,7 +413,7 @@ public Void call() throws Exception {
 
     // May need to update GCM registration ID if app version has changed.
     // This also primes current installation.
-    PushService.initialize().continueWithTask(new Continuation<Void, Task<Void>>() {
+    PushServiceUtils.initialize().continueWithTask(new Continuation<Void, Task<Void>>() {
       @Override
       public Task<Void> then(Task<Void> task) throws Exception {
         // Prime current user in the background

Parse/src/main/java/com/parse/PushService.java

@@ -9,18 +9,18 @@
 package com.parse;
 
 import android.app.Service;
+import android.content.ComponentName;
 import android.content.Context;
 import android.content.Intent;
 import android.os.IBinder;
+import android.os.PowerManager;
+import android.util.SparseArray;
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.concurrent.Executor;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 
-import bolts.Task;
-
 /**
  * A service to listen for push notifications. This operates in the same process as the parent
  * application.
@@ -81,10 +81,63 @@
  * The {@link ParsePushBroadcastReceiver} listens to this intent to track an app open event and
  * launch the app's launcher activity. To customize this behavior override
  * {@link ParsePushBroadcastReceiver#onPushOpen(Context, Intent)}.
+ *
+ * Starting with Android O, this is replaced by {@link PushServiceApi26}.
  */
 public final class PushService extends Service {
   private static final String TAG = "com.parse.PushService";
 
+  //region run and dispose
+
+  private static final String WAKE_LOCK_EXTRA = "parseWakeLockId";
+  private static final SparseArray<ParseWakeLock> wakeLocks = new SparseArray<>();
+  private static int wakeLockId = 0;
+
+  /*
+   * Same as Context.startService, but acquires a wake lock before starting the service. The wake
+   * lock must later be released by calling dispose().
+   */
+  static boolean run(Context context, Intent intent) {
+    String reason = intent.toString();
+    ParseWakeLock wl = ParseWakeLock.acquireNewWakeLock(context, PowerManager.PARTIAL_WAKE_LOCK, reason, 0);
+
+    synchronized (wakeLocks) {
+      intent.putExtra(WAKE_LOCK_EXTRA, wakeLockId);
+      wakeLocks.append(wakeLockId, wl);
+      wakeLockId++;
+    }
+
+    intent.setClass(context, PushService.class);
+    ComponentName name = context.startService(intent);
+    if (name == null) {
+      PLog.e(TAG, "Could not start the service. Make sure that the XML tag "
+          + "<service android:name=\"" + PushService.class + "\" /> is in your "
+          + "AndroidManifest.xml as a child of the <application> element.");
+      dispose(intent);
+      return false;
+    }
+    return true;
+  }
+
+  static void dispose(Intent intent) {
+    if (intent != null && intent.hasExtra(WAKE_LOCK_EXTRA)) {
+      int id = intent.getIntExtra(WAKE_LOCK_EXTRA, -1);
+      ParseWakeLock wakeLock;
+
+      synchronized (wakeLocks) {
+        wakeLock = wakeLocks.get(id);
+        wakeLocks.remove(id);
+      }
+
+      if (wakeLock == null) {
+        PLog.e(TAG, "Got wake lock id of " + id + " in intent, but no such lock found in " +
+            "global map. Was disposePushService called twice for the same intent?");
+      } else {
+        wakeLock.release();
+      }
+    }
+  }
+
   //region ServiceLifecycleCallbacks used for testing
 
   private static List<ServiceLifecycleCallbacks> serviceLifecycleCallbacks = null;
@@ -103,45 +156,26 @@ public final class PushService extends Service {
     }
   }
 
-  /* package */ static void unregisterServiceLifecycleCallbacks(
-      ServiceLifecycleCallbacks callbacks) {
+  /* package */ static void unregisterServiceLifecycleCallbacks(ServiceLifecycleCallbacks callbacks) {
     synchronized (PushService.class) {
       serviceLifecycleCallbacks.remove(callbacks);
-      if (serviceLifecycleCallbacks.size() <= 0) {
-        serviceLifecycleCallbacks = null;
-      }
     }
   }
 
   private static void dispatchOnServiceCreated(Service service) {
-    Object[] callbacks = collectServiceLifecycleCallbacks();
-    if (callbacks != null) {
-      for (Object callback : callbacks) {
-        ((ServiceLifecycleCallbacks) callback).onServiceCreated(service);
+    if (serviceLifecycleCallbacks != null) {
+      for (ServiceLifecycleCallbacks callback : serviceLifecycleCallbacks) {
+        callback.onServiceCreated(service);
       }
     }
   }
 
   private static void dispatchOnServiceDestroyed(Service service) {
-    Object[] callbacks = collectServiceLifecycleCallbacks();
-    if (callbacks != null) {
-      for (Object callback : callbacks) {
-        ((ServiceLifecycleCallbacks) callback).onServiceDestroyed(service);
-      }
-    }
-  }
-
-  private static Object[] collectServiceLifecycleCallbacks() {
-    Object[] callbacks = null;
-    synchronized (PushService.class) {
-      if (serviceLifecycleCallbacks == null) {
-        return null;
-      }
-      if (serviceLifecycleCallbacks.size() > 0) {
-        callbacks = serviceLifecycleCallbacks.toArray();
+    if (serviceLifecycleCallbacks != null) {
+      for (ServiceLifecycleCallbacks callback : serviceLifecycleCallbacks) {
+        callback.onServiceDestroyed(service);
       }
     }
-    return callbacks;
   }
 
   //endregion
@@ -157,10 +191,6 @@ public PushService() {
     super();
   }
 
-  static PushHandler createPushHandler() {
-    return PushHandler.Factory.create(ManifestInfo.getPushType());
-  }
-
   // For tests
   void setPushHandler(PushHandler handler) {
     this.handler = handler;
@@ -174,10 +204,6 @@ static boolean isSupported() {
     return ManifestInfo.getServiceInfo(PushService.class) != null;
   }
 
-  static Task<Void> initialize() {
-    // Some handlers might need initialization.
-    return createPushHandler().initialize();
-  }
 
   /**
    * Client code should not call {@code onCreate} directly.
@@ -197,7 +223,7 @@ public void onCreate() {
     }
 
     executor = Executors.newSingleThreadExecutor();
-    handler = createPushHandler();
+    handler = PushServiceUtils.createPushHandler();
     dispatchOnServiceCreated(this);
   }
 
@@ -216,7 +242,7 @@ public void run() {
         try {
           handler.handlePush(intent);
         } finally {
-          ServiceUtils.completeWakefulIntent(intent);
+          dispose(intent);
           stopSelf(startId);
         }
       }

Parse/src/main/java/com/parse/PushServiceApi26.java

@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) 2015-present, Parse, LLC.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+package com.parse;
+
+import android.annotation.TargetApi;
+import android.app.Service;
+import android.app.job.JobInfo;
+import android.app.job.JobParameters;
+import android.app.job.JobScheduler;
+import android.app.job.JobService;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Build;
+import android.os.Bundle;
+import android.os.IBinder;
+import android.os.PowerManager;
+import android.util.SparseArray;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+/**
+ * A JobService that is triggered by push notifications on Oreo+.
+ * Read {@link PushServiceUtils} and {@link PushService} for info and docs.
+ * This is already set-up in our own manifest.
+ */
+@TargetApi(Build.VERSION_CODES.O)
+public final class PushServiceApi26 extends JobService {
+  private static final String TAG = PushServiceApi26.class.getSimpleName();
+  private static final String INTENT_KEY = "intent";
+  private static final int JOB_SERVICE_ID = 999;
+
+  static boolean run(Context context, Intent intent) {
+    JobScheduler scheduler = (JobScheduler) context.getSystemService(Context.JOB_SCHEDULER_SERVICE);
+    // Execute in the next second.
+    Bundle extra = new Bundle(1);
+    extra.putParcelable(INTENT_KEY, intent);
+    int did = scheduler.schedule(new JobInfo.Builder(JOB_SERVICE_ID, new ComponentName(context, PushService.class))
+        .setMinimumLatency(1L)
+        .setOverrideDeadline(1000L)
+        .setRequiresCharging(false)
+        .setRequiresBatteryNotLow(false)
+        .setRequiresStorageNotLow(false)
+        .setTransientExtras(extra)
+        .build());
+    return did == JobScheduler.RESULT_SUCCESS;
+  }
+
+  // We delegate the intent to a PushHandler running in a streamlined executor.
+  private ExecutorService executor;
+  private PushHandler handler;
+
+  // Our manifest file is OK.
+  static boolean isSupported() {
+    return true;
+  }
+
+  @Override
+  public void onCreate() {
+    super.onCreate();
+    executor = Executors.newSingleThreadExecutor();
+    handler = PushServiceUtils.createPushHandler();
+  }
+
+  @Override
+  public boolean onStartJob(final JobParameters jobParameters) {
+    if (ParsePlugins.Android.get() == null) {
+      PLog.e(TAG, "The Parse push service cannot start because Parse.initialize "
+          + "has not yet been called. If you call Parse.initialize from "
+          + "an Activity's onCreate, that call should instead be in the "
+          + "Application.onCreate. Be sure your Application class is registered "
+          + "in your AndroidManifest.xml with the android:name property of your "
+          + "<application> tag.");
+      return false;
+    }
+
+    final Bundle params = jobParameters.getTransientExtras();
+    final Intent intent = params.getParcelable(INTENT_KEY);
+    executor.execute(new Runnable() {
+      @Override
+      public void run() {
+        try {
+          handler.handlePush(intent);
+        } finally {
+          jobFinished(jobParameters, false);
+        }
+      }
+    });
+    return true;
+  }
+
+  @Override
+  public boolean onStopJob(JobParameters jobParameters) {
+    // Something went wrong before jobFinished(). Try rescheduling.
+    return true;
+  }
+
+  @Override
+  public void onDestroy() {
+    if (executor != null) {
+      executor.shutdown();
+      executor = null;
+      handler = null;
+    }
+    super.onDestroy();
+  }
+}