Java 类com.google.android.gms.gcm.GoogleCloudMessaging 实例源码

@Override
public void onReceive(Context context, Intent intent) {
  GoogleCloudMessaging gcm         = GoogleCloudMessaging.getInstance(context);
  String               messageType = gcm.getMessageType(intent);

  if (GoogleCloudMessaging.MESSAGE_TYPE_MESSAGE.equals(messageType)) {
    Log.w(TAG, "GCM message...");

    if (!TextSecurePreferences.isPushRegistered(context)) {
      Log.w(TAG, "Not push registered!");
      return;
    }

    String messageData = intent.getStringExtra("message");
    String receiptData = intent.getStringExtra("receipt");

    if      (!TextUtils.isEmpty(messageData)) handleReceivedMessage(context, messageData);
    else if (!TextUtils.isEmpty(receiptData)) handleReceivedMessage(context, receiptData);
    else if (intent.hasExtra("notification")) handleReceivedNotification(context);
  }
}

@Override
protected Integer doInBackground(Void... params) {
  try {
    Context                     context        = getActivity();
    SignalServiceAccountManager accountManager = AccountManagerFactory.createManager(context);

    try {
      accountManager.setGcmId(Optional.<String>absent());
    } catch (AuthorizationFailedException e) {
      Log.w(TAG, e);
    }

    if (!TextSecurePreferences.isGcmDisabled(context)) {
      GoogleCloudMessaging.getInstance(context).unregister();
    }

    return SUCCESS;
  } catch (IOException ioe) {
    Log.w(TAG, ioe);
    return NETWORK_ERROR;
  }
}

@Override
public void onRun() throws Exception {
  if (TextSecurePreferences.isGcmDisabled(context)) return;

  Log.w(TAG, "Reregistering GCM...");
  int result = GooglePlayServicesUtil.isGooglePlayServicesAvailable(context);

  if (result != ConnectionResult.SUCCESS) {
    notifyGcmFailure();
  } else {
    String gcmId = GoogleCloudMessaging.getInstance(context).register(REGISTRATION_ID);
    textSecureAccountManager.setGcmId(Optional.of(gcmId));

    TextSecurePreferences.setGcmRegistrationId(context, gcmId);
    TextSecurePreferences.setWebsocketRegistered(context, true);
  }
}

@Override
protected void onHandleIntent(Intent intent) {
    Log.d(TAG,"GCMRegistrationService: onHandleIntent()");
    try {
        InstanceID instanceID = InstanceID.getInstance(this);
        int gcmSenderIDIdentifier = getResources().getIdentifier("gcm_sender_id", "string", getPackageName());
        String gcmSenderId = getString(gcmSenderIDIdentifier);
        Log.d(TAG, "GCM Sender ID: " + gcmSenderId);
        String token = instanceID.getToken(gcmSenderId,
                GoogleCloudMessaging.INSTANCE_ID_SCOPE,
                null);
        Log.d(TAG, "Retrieved GCM Token: " + token);
        sendGCMTokenToActivity(token);
    } catch (Exception e) {
        /*
         * If we are unable to retrieve the GCM token we notify the Plugin
         * letting the user know this step failed.
         */
        Log.e(TAG, "Failed to retrieve GCM token", e);
        sendGCMTokenToActivity(null);
    }
}

@Override
protected void onHandleIntent(Intent intent) {
    Bundle extras = intent.getExtras();
    GoogleCloudMessaging gcm = GoogleCloudMessaging.getInstance(this);
    String messageType = gcm.getMessageType(intent);

    if (!extras.isEmpty() && GoogleCloudMessaging.MESSAGE_TYPE_MESSAGE.equals(messageType)) {
        Log.w("GCM", extras.toString());
        Intent i = new Intent(this, Main.class);// change the context and activity name.
        i.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
        i.addFlags(WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED +
                WindowManager.LayoutParams.FLAG_DISMISS_KEYGUARD +
                WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON +
                WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON);
        this.startActivity(i);
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Intent incoming = new Intent("INCOMING");
        incoming.putExtra("number", extras.getString("message"));
        sendBroadcast(incoming);
    }
    GcmBroadcastReceiver.completeWakefulIntent(intent);
}

@Override
protected void onHandleIntent(Intent intent) {
    SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(this);

    // Play a click sound and vibrate quickly
    GoogleCloudMessaging gcm = GoogleCloudMessaging.getInstance(this);
    AudioManager audioManager = (AudioManager)getSystemService(AUDIO_SERVICE);
    audioManager.playSoundEffect(SoundEffectConstants.CLICK, 1.0f);
    Vibrator vibrator = (Vibrator) getSystemService(VIBRATOR_SERVICE);
    vibrator.vibrate(VIBRATOR_PULSE);

    try {
        Bundle data = new Bundle();
        data.putString("user",
                sharedPreferences.getString(GarageDoorWidgetProvider.PREF_USERNAME, ""));
        data.putString("password",
                sharedPreferences.getString(GarageDoorWidgetProvider.PREF_PASSWORD, ""));
        data.putString("timestamp", String.valueOf(System.currentTimeMillis() / 1000));

        String id = Integer.toString(getNextMsgId());
        gcm.send(GarageDoorWidgetProvider.GCM_SENDER_ID + "@gcm.googleapis.com",
                id, TIME_TO_LIVE, data);
    } catch (IOException e) {
        Log.e(TAG, "Error sending message", e);
    }
}

@Override
protected void onHandleIntent(Intent intent) {
    SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(this);
    try {
        InstanceID instanceID = InstanceID.getInstance(this);
        String token = instanceID.getToken(GarageDoorWidgetProvider.GCM_SENDER_ID,
                GoogleCloudMessaging.INSTANCE_ID_SCOPE, null);
        Log.i(TAG, "GCM Registration Token: " + token);

        sendRegistrationToServer(token);

        // You should store a boolean that indicates whether the generated token has been
        // sent to your server. If the boolean is false, send the token to your server,
        // otherwise your server should have already received the token.
        sharedPreferences.edit().putBoolean(GarageDoorWidgetProvider.PREF_SENT_TOKEN_TO_SERVER, true).apply();
    } catch (Exception e) {
        Log.d(TAG, "Failed to complete token refresh", e);
        // If an exception happens while fetching the new token or updating our registration data
        // on a third-party server, this ensures that we'll attempt the update at a later time.
        sharedPreferences.edit().putBoolean(GarageDoorWidgetProvider.PREF_SENT_TOKEN_TO_SERVER, false).apply();
    }
    // Notify UI that registration has completed, so the progress indicator can be hidden.
    Intent registrationComplete = new Intent(GarageDoorWidgetProvider.PREF_REGISTRATION_COMPLETE);
    LocalBroadcastManager.getInstance(this).sendBroadcast(registrationComplete);
}

@Override
protected void onHandleIntent(Intent intent) {
    SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(this);

    try {
        synchronized (TAG) {
            InstanceID instanceID = InstanceID.getInstance(this);
            String token = instanceID.getToken(getString(R.string.gcm_defaultSenderId),
                    GoogleCloudMessaging.INSTANCE_ID_SCOPE, null);
            Log.i(TAG, "GCM Registration Token: " + token);
            sharedPreferences.edit().putString(Preferences.TOKEN, token).apply();
        }
    } catch (Exception e) {
        Log.d(TAG, "Failed to complete token refresh", e);
        //sharedPreferences.edit().putBoolean(Preferences.SENT_TOKEN_TO_SERVER, false).apply();
    }
    // Notify UI that registration has completed, so the progress indicator can be hidden.
    Intent registrationComplete = new Intent(Preferences.REGISTRATION_COMPLETE);
    LocalBroadcastManager.getInstance(this).sendBroadcast(registrationComplete);
}

/**
 * Deletes the current registration token.
 *
 * @param instanceId The instance ID which generated the registration token.
 * @param senderId   The sender ID to revoke the registration token from.
 * @return A task that can be resolved upon deletion of the token.
 */
private Task<Void> deleteRegistrationToken(final InstanceID instanceId, final String senderId) {
    final TaskCompletionSource<Void> future = new TaskCompletionSource<>();
    new AsyncTask<Object, Integer, String>() {
        @Override
        protected String doInBackground(final Object[] ignored) {

            try {
                instanceId.deleteToken(senderId, GoogleCloudMessaging.INSTANCE_ID_SCOPE);
            } catch (final IOException e) {
                Log.e(TAG, "Error deleting GCM registration token", e);
                future.setException(e);
                return null;
            }

            future.setResult(null);
            return null;
        }
    }.execute();

    return future.getTask();
}

/**
 * Gets or creates a registration token.
 *
 * @param instanceId The instance ID which should generate the registration token.
 * @param senderId   The sender ID to generate the registration token for.
 * @return A task that can be resolved upon creating/retrieval of the token.
 */
private Task<String> getRegistrationToken(final InstanceID instanceId, final String senderId) {
    final TaskCompletionSource<String> future = new TaskCompletionSource<>();
    new AsyncTask<Object, Integer, String>() {
        @Override
        protected String doInBackground(final Object[] ignored) {

            final String registrationToken;
            try {
                registrationToken = instanceId.getToken(senderId, GoogleCloudMessaging.INSTANCE_ID_SCOPE);
            } catch (final IOException e) {
                Log.e(TAG, "Error getting GCM registration token", e);
                future.setException(e);
                return null;
            }

            future.setResult(registrationToken);
            return null;
        }
    }.execute();

    return future.getTask();
}

@Override
protected void onHandleIntent(Intent intent) {
    Bundle extras = intent.getExtras();
    GoogleCloudMessaging gcm = GoogleCloudMessaging.getInstance(this);
    String messageType = gcm.getMessageType(intent);
    if (!extras.isEmpty()) {
        if (GoogleCloudMessaging.MESSAGE_TYPE_MESSAGE.equals(messageType)) {                
            if (FlowzrSyncEngine.isRunning) {
            Log.i(TAG,"sync already in progess");
                return;
            }
            Log.i(TAG,"starting sync from GCM");
            new FlowzrSyncTask(getApplicationContext()).execute();
        }
    }
}

@Override
protected void onHandleIntent(Intent intent) {

    String deviceId = intent.getStringExtra("DEVICE_ID");
    String deviceName = intent.getStringExtra("DEVICE_NAME");

    try {
        InstanceID instanceID = InstanceID.getInstance(this);
        String registrationId = instanceID.getToken(getString(R.string.gcm_defaultSenderId), GoogleCloudMessaging.INSTANCE_ID_SCOPE, null);
        registerDeviceProcess(deviceName,deviceId,registrationId);

    } catch (IOException e) {
        e.printStackTrace();
    }

}

@Override
protected void onHandleIntent(Intent intent) {
    Bundle extras = intent.getExtras();
    GoogleCloudMessaging gcm = GoogleCloudMessaging.getInstance(this);
    String messageType = gcm.getMessageType(intent);

    Log.w("PushIntentSerivce", extras.toString());

    if (!extras.isEmpty()) {
        String from = extras.getString("from");

        if (!from.equals("google.com/iid") && GoogleCloudMessaging.MESSAGE_TYPE_MESSAGE.equals(messageType)) {
            createNotification(extras);
        }
    }

    PushNotificationBroadcastReceiver.completeWakefulIntent(intent);
}

@Override
public void interaction() {
    gcm = GoogleCloudMessaging.getInstance(context);
    if(operationStatus() != StaticFields.STATUS_OK)
    {
        mJobSheduler = new MJobSheduler(this);
        timer = new Timer(true);
        timer.schedule(mJobSheduler, 1000, 1000);
    }
    else
    {
       if (nextChain != null)
       {
           nextChain.setSocket(tcpChannel,nextChain.msgHandler);
           nextChain.getDataObject().setPushToken(FileUtil.getPushToken(context));
           nextChain.interaction();
       }
    }
}

@Override
public int onRunTask(TaskParams taskParams) {
    Log.i(TAG, "Backing up the account settings");

    final SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(this);

    Bundle data = new Bundle();
    data.putString(FIRST_NAME, sharedPreferences.getString(FIRST_NAME,""));
    data.putString(LAST_NAME, sharedPreferences.getString(LAST_NAME,""));
    data.putString(AGE, sharedPreferences.getString(AGE,""));
    data.putString("resource", RESOURCE);
    data.putString("operation", sharedPreferences.getString(OPERATION,""));
    String id = Integer.toString(new Random().nextInt());
    GoogleCloudMessaging gcm = GoogleCloudMessaging.getInstance(MyBackupService.this);
    try {
        gcm.send(getString(R.string.gcm_SenderId) + "@gcm.googleapis.com", id, data);
    } catch (IOException e) {
        Log.e(TAG, "Failed to backup account");
        return GcmNetworkManager.RESULT_RESCHEDULE;
    }


    return GcmNetworkManager.RESULT_SUCCESS;
}

@Override
protected void onHandleIntent(Intent intent) {
    // Preferences to get registration id from device
    SharedPreferences mSharedPreferences = PreferenceManager.getDefaultSharedPreferences(this);
    String mNextId = mSharedPreferences.getString(REGISTRATION_ID_PREFERENCE, null);
    try {
        InstanceID mInstanceID = InstanceID.getInstance(this);
        String mToken = mInstanceID.getToken(getString(R.string.gcm_default_sender_id),
                GoogleCloudMessaging.INSTANCE_ID_SCOPE, null);
            executeBusinessRule(mToken);

        if(mNextId!=null && mNextId!=mToken) {
            mSharedPreferences.edit().putString(REGISTRATION_ID_PREFERENCE, mToken).apply();
            mNextId = mToken;
        }

    } catch (Exception e) {
        Log.d(REGISTRATION_DEBUG, "Failed to refresh current token: " + e.getMessage());
    }

    // Complete process
    if(mNextId!=null) {
        Intent mRegisterIntent = new Intent(REGISTRATION_COMPLETE);
        LocalBroadcastManager.getInstance(this).sendBroadcast(mRegisterIntent);
    }
}

/**
 * Subscribe to a topic
 */
public void subscribeToTopic(String topic) {
    GcmPubSub pubSub = GcmPubSub.getInstance(getApplicationContext());
    InstanceID instanceID = InstanceID.getInstance(getApplicationContext());
    String token = null;
    String gcm_server_sender_id = SharedPref.getSenderId(GcmIntentService.this);
    try {
        token = instanceID.getToken(gcm_server_sender_id,
                GoogleCloudMessaging.INSTANCE_ID_SCOPE, null);
        if (token != null) {
            pubSub.subscribe(token, "/topics/" + topic, null);
            Log.d(TAG, "Subscribed to topic: " + topic);
        } else {
            Log.d(TAG, "error: gcm registration id is null");
        }
    } catch (IOException e) {
        Log.e(TAG, "Topic subscribe error. Topic: " + topic + ", error: " + e.getMessage());
        Toast.makeText(getApplicationContext(), "Topic subscribe error. Topic: " + topic + ", error: " + e.getMessage(), Toast.LENGTH_SHORT).show();
    }
}

@Override
protected void onHandleIntent(Intent intent) {
    boolean register = intent.getBooleanExtra(LibrusConstants.REGISTER, false);
    try {
        if (register) {
            String token = InstanceID.getInstance(this)
                    .getToken(APP_ID, GoogleCloudMessaging.INSTANCE_ID_SCOPE, null);
            LibrusUtils.log("Retrieved GCM token " + token);
            new APIClient(this).pushDevices(token)
                    .subscribe(() -> {
                    }, LibrusUtils::handleError);
        } else {
            InstanceID.getInstance(this)
                    .deleteToken(APP_ID, GoogleCloudMessaging.INSTANCE_ID_SCOPE);
            LibrusUtils.log("Unregistered GCM");
        }
    } catch (IOException e) {
        LibrusUtils.logError("Failed to register GCM");
        FirebaseCrash.report(e);
        e.printStackTrace();
    }
}

@Override
protected void onHandleIntent(Intent intent) {
    PDLog.d(GCMIntentService.class, "onHandleIntent");
    if (intent == null) {
        return;
    }

    GoogleCloudMessaging gcm = GoogleCloudMessaging.getInstance(this);
    String messageType = gcm.getMessageType(intent);
    Bundle extras = intent.getExtras();

    if (!extras.isEmpty() && messageType.equalsIgnoreCase(GoogleCloudMessaging.MESSAGE_TYPE_MESSAGE)) {
        handleMessage(intent);
    }

    GCMBroadcastReceiver.completeWakefulIntent(intent);
}

@Override
protected void onHandleIntent(Intent intent) {
    SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(this);

    try {
        InstanceID instanceID = InstanceID.getInstance(this);
        String token = instanceID.getToken(getString(R.string.gcm_defaultSenderId),
                GoogleCloudMessaging.INSTANCE_ID_SCOPE, null);
        Log.i(TAG, "GCM Registration Token: " + token);
        subscribeTopics(token);
        sharedPreferences.edit().putString(QuickstartPreferences.TOKEN, token).apply();
        sharedPreferences.edit().putBoolean(ml.hepolise.vkaudiosave.QuickstartPreferences.SENT_TOKEN_TO_SERVER, true).apply();
    } catch (Exception e) {
        Log.d(TAG, "Failed to complete token refresh", e);
        sharedPreferences.edit().putBoolean(ml.hepolise.vkaudiosave.QuickstartPreferences.SENT_TOKEN_TO_SERVER, false).apply();
    }
    Intent registrationComplete = new Intent(ml.hepolise.vkaudiosave.QuickstartPreferences.REGISTRATION_COMPLETE);
    LocalBroadcastManager.getInstance(this).sendBroadcast(registrationComplete);
}

@Override
protected void onHandleIntent(final @NonNull Intent intent) {
  Timber.d("onHandleIntent");

  try {
    final InstanceID instanceID = InstanceID.getInstance(this);
    instanceID.deleteToken(getString(R.string.gcm_defaultSenderId), GoogleCloudMessaging.INSTANCE_ID_SCOPE);
    Timber.d("Deleted token");
  } catch (final Exception e) {
    Timber.e("Failed to delete token: %s", e);
  }
}

@Override
protected void onHandleIntent(final @Nullable Intent intent) {
  Timber.d("onHandleIntent");

  try {
    // This initially hits the network to retrieve the token, subsequent calls are local
    final InstanceID instanceID = InstanceID.getInstance(this);

    // R.string.gcm_defaultSenderId is derived from google-services.json
    final String token = instanceID.getToken(getString(R.string.gcm_defaultSenderId),
      GoogleCloudMessaging.INSTANCE_ID_SCOPE, null);
    Timber.d("Token: %s", token);

    sendTokenToApi(token);
    subscribeToGlobalTopic(token);
  } catch (final Exception e) {
    Timber.e("Failed to complete token refresh: %s", e);
  }
}

@Override
protected Integer doInBackground(Void... params) {
  try {
    Context                  context        = getActivity();
    TextSecureAccountManager accountManager = TextSecureCommunicationFactory.createManager(context);

    accountManager.setGcmId(Optional.<String>absent());
    GoogleCloudMessaging.getInstance(context).unregister();

    return SUCCESS;
  } catch (AuthorizationFailedException afe) {
    Log.w(TAG, afe);
    return SUCCESS;
  } catch (IOException ioe) {
    Log.w(TAG, ioe);
    return NETWORK_ERROR;
  }
}

private void handleCommonRegistration(MasterSecret masterSecret, TextSecureAccountManager accountManager, String number)
    throws IOException
{
  setState(new RegistrationState(RegistrationState.STATE_GENERATING_KEYS, number));
  IdentityKeyPair    identityKey  = IdentityKeyUtil.getIdentityKeyPair(this, masterSecret);
  List<PreKeyRecord> records      = PreKeyUtil.generatePreKeys(this, masterSecret);
  PreKeyRecord       lastResort   = PreKeyUtil.generateLastResortKey(this, masterSecret);
  SignedPreKeyRecord signedPreKey = PreKeyUtil.generateSignedPreKey(this, masterSecret, identityKey);
  accountManager.setPreKeys(identityKey.getPublicKey(),lastResort, signedPreKey, records);

  setState(new RegistrationState(RegistrationState.STATE_GCM_REGISTERING, number));

  String gcmRegistrationId = GoogleCloudMessaging.getInstance(this).register(GcmRefreshJob.REGISTRATION_ID);
  TextSecurePreferences.setGcmRegistrationId(this, gcmRegistrationId);
  accountManager.setGcmId(Optional.of(gcmRegistrationId));

  DirectoryHelper.refreshDirectory(this, accountManager, number);

  DirectoryRefreshListener.schedule(this);
}

@Override
public void onRun() throws Exception {
  TextSecureAccountManager accountManager = TextSecureCommunicationFactory.createManager(context);
  String                   registrationId = TextSecurePreferences.getGcmRegistrationId(context);

  if (registrationId == null) {
    Log.w(TAG, "GCM registrationId expired, reregistering...");
    int result = GooglePlayServicesUtil.isGooglePlayServicesAvailable(context);

    if (result != ConnectionResult.SUCCESS) {
      notifyGcmFailure();
    } else {
      String gcmId = GoogleCloudMessaging.getInstance(context).register(REGISTRATION_ID);
      accountManager.setGcmId(Optional.of(gcmId));
      TextSecurePreferences.setGcmRegistrationId(context, gcmId);
    }
  }
}

@Override
public void onReceive(Context context, Intent intent) {
  GoogleCloudMessaging gcm         = GoogleCloudMessaging.getInstance(context);
  String               messageType = gcm.getMessageType(intent);

  if (GoogleCloudMessaging.MESSAGE_TYPE_MESSAGE.equals(messageType)) {
    Log.w(TAG, "GCM message...");

    if (!TextSecurePreferences.isPushRegistered(context)) {
      Log.w(TAG, "Not push registered!");
      return;
    }

    String messageData = intent.getStringExtra("message");
    String receiptData = intent.getStringExtra("receipt");

    if      (!TextUtils.isEmpty(messageData)) handleReceivedMessage(context, messageData);
    else if (!TextUtils.isEmpty(receiptData)) handleReceivedMessage(context, receiptData);
  }
}

@Override
protected void onHandleIntent(Intent intent) {
    SharedPreferences sharedPreferences = PreferenceManager
            .getDefaultSharedPreferences(this);
    try {
        synchronized (TAG) {
            InstanceID instanceID = InstanceID.getInstance(this);
            String token = instanceID.getToken(getString(R.string.gcm_sender_id),
                    GoogleCloudMessaging.INSTANCE_ID_SCOPE, null);
            Log.d(TAG, "GCM registration token: " + token);

            sharedPreferences.edit().putString("device_id", token).apply();
        }
    } catch (IOException e) {
        Log.d(TAG, "Failed to complete token refresh", e);
    }
    Intent registrationComplete = new Intent(RegistrationConstants.REGISTRATION_COMPLETE);
    LocalBroadcastManager.getInstance(this).sendBroadcast(registrationComplete);
}

@Override
protected void onHandleIntent(Intent intent) {
    // Make a call to Instance API
    InstanceID instanceID = InstanceID.getInstance(this);
    String senderId = getResources().getString(R.string.gcm_defaultSenderId);
    try {
        // request token that will be used by the server to send push notifications
        String token = instanceID.getToken(senderId, GoogleCloudMessaging.INSTANCE_ID_SCOPE);

        // pass along this data
        SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(this);
        sharedPreferences.edit().putString(GCM_TOKEN, token).apply();

        sendRegistrationToServer(token);

    } catch (IOException e) {}
}

void handleRegistrationTokenUpdate(Context context) {
    String senderId = MobileMessagingCore.getGcmSenderId(context);
    if (StringUtils.isBlank(senderId)) {
        return;
    }

    try {
        InstanceID instanceID = InstanceID.getInstance(context);
        String token = instanceID.getToken(senderId, GoogleCloudMessaging.INSTANCE_ID_SCOPE, null);
        MobileMessagingLogger.v(MobileMessagingLogger.TAG, "RECEIVED TOKEN", token);
        new AndroidBroadcaster(context).registrationAcquired(token);
        sendRegistrationToServer(context, token);
        subscribeTopics(context, token);
    } catch (IOException e) {
        MobileMessagingLogger.e(InternalSdkError.ERROR_TOKEN_REFRESH.get(), e);
    }
}

@Override
protected void onHandleIntent(Intent intent) {

    try {
        // Retrieve the GCM-Token
        InstanceID instanceID = InstanceID.getInstance(this);
        String token = instanceID.getToken(getString(R.string.gcm_defaultSenderId),
                GoogleCloudMessaging.INSTANCE_ID_SCOPE, null);

        // Broadcasts the GCM-Token as a Message (so it can be used by other classes).
        sendGcmTokenMessage(true, token);

    } catch (Exception e) {
        Log.w("GcmRegistration", "GCM Token could not be obtained");
        sendGcmTokenMessage(false, "");
    }
}

@Override
public void handleIntent(ServiceAction action, Intent intent) {
    if (!tokenHolder.hasValidToken()) {
        DebugLog.i("obtaining new GCM token");
        InstanceID instanceID = InstanceID.getInstance(context);
        try {
            String token = instanceID.getToken(
                context.getString(R.string.gcm_defaultSenderId),
                GoogleCloudMessaging.INSTANCE_ID_SCOPE,
                null
            );
            GcmTokenHolder.create(context).storeToken(token);
            DebugLog.i("GCM token obtained successfully");
        } catch (IOException e) {
            DebugLog.logException(e);
        }
    }
    WorkerService.getLauncher(context).launchService(ServiceAction.SYNC_DATA);
}

@Kroll.method
public void unregisterForPushNotifications() {
    final String senderId = getSenderId();
    final Context context = TiApplication.getInstance().getApplicationContext();

    new AsyncTask<Void, Void, Void>() {
        @Override
        protected Void doInBackground(Void... params) {
            try {
                InstanceID.getInstance(context).deleteToken(senderId, GoogleCloudMessaging.INSTANCE_ID_SCOPE);
                Log.d(LCAT, "delete instanceid succeeded");
            } catch (final IOException e) {
                Log.e(LCAT, "remove token failed - error: " + e.getMessage());
            }
            return null;
        }
    }.execute();
}

@Override
protected void onHandleIntent(Intent intent) {
    TiGooshModule module = TiGooshModule.getModule();
    if (module == null) {
        Log.e(LCAT, "Intent handled but no TiGoosh instance module found");
        return;
    }

    try {

        String senderId = module.getSenderId();
        String token = InstanceID.getInstance(this).getToken(senderId, GoogleCloudMessaging.INSTANCE_ID_SCOPE, null);

        Log.i(LCAT, "Sender ID: " + senderId);
        Log.i(LCAT, "Device Token: " + token);

        module.sendSuccess(token);

    } catch (Exception ex) {

        Log.e(LCAT, "Failed to get GCM Registration Token:" + ex.getMessage());
        module.sendError(ex);

    }
}

private void sendUpstreamMessage(String to, Bundle data, String token) {
    if (token == null) {
        GcmUpstreamUma.recordHistogram(
                getApplicationContext(), GcmUpstreamUma.UMA_TOKEN_REQUEST_FAILED);
    }
    // Add the OAuth2 token to the bundle. The token should have the prefix Bearer added to it.
    data.putString("Authorization", "Bearer " + token);
    if (!isMessageWithinLimit(data)) {
        GcmUpstreamUma.recordHistogram(
                getApplicationContext(), GcmUpstreamUma.UMA_SIZE_LIMIT_EXCEEDED);
        return;
    }
    String msgId = UUID.randomUUID().toString();
    try {
        GoogleCloudMessaging.getInstance(getApplicationContext()).send(to, msgId, 1, data);
    } catch (IOException | IllegalArgumentException exception) {
        Log.w(TAG, "Send message failed");
        GcmUpstreamUma.recordHistogram(getApplicationContext(), GcmUpstreamUma.UMA_SEND_FAILED);
    }
}

@NonNull
protected String getNewToken() throws Exception {
    final InstanceID instanceId = InstanceID.getInstance(mAppContext);
    Log.d(LOGTAG, "GCM is refreshing token... instanceId=" + instanceId.getId());

    // TODO why is this needed?
    GoogleCloudMessaging.getInstance(mAppContext).close();

    try {
        final String registrationToken = instanceId.getToken(getSenderId(), GoogleCloudMessaging.INSTANCE_ID_SCOPE);
        Log.i(LOGTAG, "GCM has a new token: instanceId=" + instanceId.getId() + ", token=" + registrationToken);
        return registrationToken;
    } catch (Exception e) {
        throw new Exception("FATAL: Failed to fetch a fresh new token, instanceId=" + instanceId.getId(), e);
    }
}

@Override
protected void onHandleIntent(Intent intent) {
    mRxMethods = ((RocketApp)getApplicationContext()).getRxMethods();
    mSharedPreferences = PreferenceManager.getDefaultSharedPreferences(this);
    try {

        InstanceID instanceID = InstanceID.getInstance(this);
        String senderId = mSharedPreferences.getString(PushKeys.SENDER_ID, null);
        String token = instanceID.getToken(senderId,
                GoogleCloudMessaging.INSTANCE_ID_SCOPE, null);

        sendRegistrationToServer(token);

        subscribeTopics(token);


        mSharedPreferences.edit().putString(PushKeys.TOKEN, token).apply();

    } catch (Exception e) {
        Log.d(TAG, "Failed to complete token refresh", e);
        mSharedPreferences.edit().putBoolean(PushKeys.SENT_TOKEN_TO_SERVER, false).apply();
    }
}

private void unregisterInBackground() {
    new AsyncTask<Context, Void, Void>() {
        @Override
        protected Void doInBackground(Context... params) {
            try {
                GoogleCloudMessaging mGoogleCloudMessaging = GoogleCloudMessaging.getInstance(
                        params[0]);
                mGoogleCloudMessaging.unregister();
                Log.i(TAG, "Device unregistered");
            } catch (IOException e) {
                Log.i(TAG, "Error", e);
            }
            return null;
        }

        @Override
        protected void onPostExecute(Void result) {
            super.onPostExecute(result);
            deleteRegistrationIdFromBackend();
            deleteRegistrationId();
            mPushId = "0";
        }
    }.execute(mContext);
}

@Override
protected void onHandleIntent(Intent intent) {
   Bundle extras = intent.getExtras();
   GoogleCloudMessaging gcm = GoogleCloudMessaging.getInstance(this);
   String messageType = gcm.getMessageType(intent);
   if(!extras.isEmpty()){
      if(GoogleCloudMessaging.MESSAGE_TYPE_MESSAGE.equals(messageType)){
         Log.i("GCMIntentService", "Received message");
         String details = intent.getStringExtra( "alert" ) ;
         String title = intent.getStringExtra( "title" ) ;
         String[] location = parseLocation(intent.getStringExtra("location"));
         addAlert(title, details, location[1],location[0]);
         generateNotification(this,title, details,location[1],location[0]);
      }
   }
   GCMBroadcastReceiver.completeWakefulIntent(intent);
}

public void registerToGCM() {

        Intent registrationComplete;
        String token = null;
        try {
            InstanceID instanceID = InstanceID.getInstance(getApplicationContext());
            logger.d("senderId is :" + getString(R.string.senderId));
            token = instanceID.getToken(getString(R.string.senderId), GoogleCloudMessaging.INSTANCE_ID_SCOPE, null);
            logger.d("GCMIntentService token : " + token);
            registrationComplete = new Intent(REGISTRATION_SUCESS);
            registrationComplete.putExtra("token", token);

        } catch (Exception e) {
            registrationComplete = new Intent(REGISTRATION_FAILD);
            logger.e("GCMIntentService registration failed " + token);
        }
        //send broadcast
        LocalBroadcastManager.getInstance(this).sendBroadcast(registrationComplete);
    }