Upgrad ParsePush to use GCMv4 on GMS devices.

This change:

* Moves Parse back to using public APIs [GitHub discussion](parse-community#445)
* Cleans up a lot of code in GcmRegistrar that is redundant with GCM APIs or written before Bolts
* Fixes a typo in manifest instructions that used a literal bool instead of "bool"
* Fixes a bug where ParseInstallation did not save the GcmSenderId and Parse didn't use the developer's secrets.
* Fixes a bug where Parse incorrectly blames an improperly configured manifest when GCM isn't available because Play Services aren't available.
* Add a compatibility shim when reading payloads so customers whose push provider uses the (now) standard intent structure expected by [GcmReceiver](https://developers.google.com/android/reference/com/google/android/gms/gcm/GcmReceiver) can use the ParsePushBroadcastReceiver instead.
* Add support for GCMv4, including a new optional intent to be notified InstanceIDs are invalidated client-side.

 The new protocol has a number of benefits:

* The new GCM v4 model is more stable; it is based on a device-owned InstanceID. Push tokens are OAuth tokens to that device.
* As a result of the above, this should fix a Parse Push bug where the first GCM push after an app upgrade might be doubled.
* This API has a callback in case the InstnaceID is invalidated, which should reduce client/server inconsistencies.
* These tokens support new server-side APIs like push-to-topic, which are _dramatically_ faster than the normal ParsePush path.
* When a device upgrades to GCMv4, the device keeps GCM topics in sync with channels. This paves the way to implement push-to-channels on top of topics (or a customer to try another push provider by next Jan and retain some targeting info).

This has two possibly controversial requirements:

* The new API issues one token per sender ID rather than one token that works with all sender IDs. To avoid an invasive/breaking server-side change, we are _no longer registering for the Parse sender ID_ if the developer provided their own. We will also only support at most one custom sender ID. I've had a number of conversations about this and nobody seems concerned.
* This change introduces a dependency on the Google Mobile Services SDK. The dependency is just the GCM .jar and does _not_ limit the Parse SDK to devices with Play Services (tested on an ICS emulator w/o Google APIs). I originally tried doing this without the dependency, but the new API has a large amount of crypto and incredible care for compat shims on older API levels. I assume my hand-crafted copy would be worse quality.

Author: inlined

Parse/build.gradle

@@ -41,6 +41,7 @@ android {
 
 dependencies {
     compile 'com.parse.bolts:bolts-tasks:1.4.0'
+    compile 'com.google.android.gms:play-services-gcm:8.4.0'
 
     provided 'com.squareup.okhttp:okhttp:2.4.0'
     provided 'com.facebook.stetho:stetho:1.1.1'

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

@@ -16,6 +16,9 @@
 import org.json.JSONObject;
 
 import java.lang.ref.WeakReference;
+import java.text.DateFormat;
+import java.text.SimpleDateFormat;
+import java.util.Date;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 
@@ -33,6 +36,10 @@
       "com.google.android.c2dm.intent.REGISTRATION";
   public static final String RECEIVE_PUSH_ACTION =
       "com.google.android.c2dm.intent.RECEIVE";
+  public static final String INSTANCE_ID_ACTION =
+      "com.google.android.gms.iid.InstanceID";
+
+  private static final String REGISTRATION_ID_EXTRA = "registration_id";
 
   private final WeakReference<Service> parent;
   private ExecutorService executor;
@@ -83,6 +90,8 @@ private void onHandleIntent(Intent intent) {
         handleGcmRegistrationIntent(intent);
       } else if (RECEIVE_PUSH_ACTION.equals(action)) {
         handleGcmPushIntent(intent);
+      } else if (INSTANCE_ID_ACTION.equals(action)) {
+        handleInvalidatedInstanceId(intent);
       } else {
         PLog.e(TAG, "PushService got unknown intent in GCM mode: " + intent);
       }
@@ -94,7 +103,13 @@ private void handleGcmRegistrationIntent(Intent intent) {
       // Have to block here since GCMService is basically an IntentService, and the service is
       // may exit before async handling of the registration is complete if we don't wait for it to
       // complete.
-      GcmRegistrar.getInstance().handleRegistrationIntentAsync(intent).waitForCompletion();
+      PLog.d(TAG, "Got registration intent in service");
+      String registrationId = intent.getStringExtra(REGISTRATION_ID_EXTRA);
+      // Multiple IDs come back to the legacy intnet-based API with an |ID|num: prefix; cut it off.
+      if (registrationId.startsWith("|ID|")) {
+        registrationId = registrationId.substring(registrationId.indexOf(':') + 1);
+      }
+      GcmRegistrar.getInstance().setGCMRegistrationId(registrationId).waitForCompletion();
     } catch (InterruptedException e) {
       // do nothing
     }
@@ -116,19 +131,52 @@ private void handleGcmPushIntent(Intent intent) {
       String channel = intent.getStringExtra("channel");
 
       JSONObject data = null;
-      if (dataString != null) {
-        try {
-          data = new JSONObject(dataString);
-        } catch (JSONException e) {
-          PLog.e(TAG, "Ignoring push because of JSON exception while processing: " + dataString, e);
-          return;
+      try {
+        if (dataString != null) {
+            data = new JSONObject(dataString);
+        } else if (pushId == null && timestamp == null && dataString == null && channel == null) {
+          // The Parse SDK is older than GCM, so it has some non-standard payload fields.
+          // This allows the Parse SDK to handle push providers using the now-standard GCM payloads.
+          pushId = intent.getStringExtra("google.c.a.c_id");
+          String millisString = intent.getStringExtra("google.c.a.ts");
+          if (millisString != null) {
+            Long millis = Long.valueOf(millisString);
+            DateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mmZ");
+            timestamp = df.format(new Date(millis));
+          }
+          data = new JSONObject();
+          if (intent.hasExtra("gcm.notification.body")) {
+            data.put("alert", intent.getStringExtra("gcm.notification.body"));
+          }
+          if (intent.hasExtra("gcm.notification.title")) {
+            data.put("title", intent.getStringExtra("gcm.notification.title"));
+          }
+          if (intent.hasExtra("gcm.notification.sound")) {
+            data.put("sound", intent.getStringExtra("gcm.notification.sound"));
+          }
+
+          String from = intent.getStringExtra("from");
+          if (from != null && from.startsWith("/topics/")) {
+            channel = from.substring("/topics/".length());
+          }
         }
+      } catch (JSONException e) {
+        PLog.e(TAG, "Ignoring push because of JSON exception while processing: " + dataString, e);
+        return;
       }
 
       PushRouter.getInstance().handlePush(pushId, timestamp, channel, data);
     }
   }
 
+  private void handleInvalidatedInstanceId(Intent intent) {
+    try {
+      GcmRegistrar.getInstance().sendRegistrationRequestAsync().waitForCompletion();
+    } catch (InterruptedException e) {
+      // do nothing
+    }
+  }
+
   /**
    * Stop the parent Service, if we're still running.
    */