private void handleRegistration(final Context context, Intent intent) {
    GCMRegistrar.cancelAppPendingIntent();
    String registrationId = intent.getStringExtra(EXTRA_REGISTRATION_ID);
    String error = intent.getStringExtra(EXTRA_ERROR);
    String unregistered = intent.getStringExtra(EXTRA_UNREGISTERED);
    mLogger.log(
        Log.DEBUG,
        "handleRegistration: registrationId = %s, " + "error = %s, unregistered = %s",
        registrationId,
        error,
        unregistered);

    // registration succeeded
    if (registrationId != null) {
      GCMRegistrar.resetBackoff(context);
      GCMRegistrar.setRegistrationId(context, registrationId);
      onRegistered(context, registrationId);
      return;
    }

    // unregistration succeeded
    if (unregistered != null) {
      // Remember we are unregistered
      GCMRegistrar.resetBackoff(context);
      String oldRegistrationId = GCMRegistrar.clearRegistrationId(context);
      onUnregistered(context, oldRegistrationId);
      return;
    }

    // last operation (registration or unregistration) returned an error;
    // Registration failed
    if (ERROR_SERVICE_NOT_AVAILABLE.equals(error)) {
      boolean retry = onRecoverableError(context, error);
      if (retry) {
        int backoffTimeMs = GCMRegistrar.getBackoff(context);
        int nextAttempt = backoffTimeMs / 2 + sRandom.nextInt(backoffTimeMs);
        mLogger.log(
            Log.DEBUG,
            "Scheduling registration retry, backoff = %d (%d)",
            nextAttempt,
            backoffTimeMs);
        Intent retryIntent = new Intent(INTENT_FROM_GCM_LIBRARY_RETRY);
        retryIntent.setPackage(context.getPackageName());
        PendingIntent retryPendingIntent = PendingIntent.getBroadcast(context, 0, retryIntent, 0);
        AlarmManager am = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
        am.set(
            AlarmManager.ELAPSED_REALTIME,
            SystemClock.elapsedRealtime() + nextAttempt,
            retryPendingIntent);
        // Next retry should wait longer.
        if (backoffTimeMs < MAX_BACKOFF_MS) {
          GCMRegistrar.setBackoff(context, backoffTimeMs * 2);
        }
      } else {
        mLogger.log(Log.VERBOSE, "Not retrying failed operation");
      }
    } else {
      // Unrecoverable error, notify app
      onError(context, error);
    }
  }
 private GCMBaseIntentService(String name, String[] senderIds) {
   super(name); // name is used as base name for threads, etc.
   mSenderIds = senderIds;
   mLogger.log(Log.VERBOSE, "Intent service name: %s", name);
 }
  @Override
  public final void onHandleIntent(Intent intent) {

    System.out.println("Received intent " + intent);

    try {
      Context context = getApplicationContext();
      String action = intent.getAction();
      if (action.equals(INTENT_FROM_GCM_REGISTRATION_CALLBACK)) {
        GCMRegistrar.setRetryBroadcastReceiver(context);
        handleRegistration(context, intent);
      } else if (action.equals(INTENT_FROM_GCM_MESSAGE)) {
        // checks for special messages
        String messageType = intent.getStringExtra(EXTRA_SPECIAL_MESSAGE);
        if (messageType != null) {
          if (messageType.equals(VALUE_DELETED_MESSAGES)) {
            String sTotal = intent.getStringExtra(EXTRA_TOTAL_DELETED);
            if (sTotal != null) {
              try {
                int total = Integer.parseInt(sTotal);
                mLogger.log(
                    Log.VERBOSE, "Received notification for %d deleted" + "messages", total);
                onDeletedMessages(context, total);
              } catch (NumberFormatException e) {
                mLogger.log(
                    Log.ERROR, "GCM returned invalid " + "number of deleted messages (%d)", sTotal);
              }
            }
          } else {
            // application is not using the latest GCM library
            mLogger.log(Log.ERROR, "Received unknown special message: %s", messageType);
          }
        } else {
          onMessage(context, intent);
        }
      } else if (action.equals(INTENT_FROM_GCM_LIBRARY_RETRY)) {
        String packageOnIntent = intent.getPackage();
        if (packageOnIntent == null
            || !packageOnIntent.equals(getApplicationContext().getPackageName())) {
          mLogger.log(
              Log.ERROR, "Ignoring retry intent from another package (%s)", packageOnIntent);
          return;
        }
        // retry last call
        if (GCMRegistrar.isRegistered(context)) {
          GCMRegistrar.internalUnregister(context);
        } else {
          String[] senderIds = getSenderIds(context);
          GCMRegistrar.internalRegister(context, senderIds);
        }
      }
    } finally {
      // Release the power lock, so phone can get back to sleep.
      // The lock is reference-counted by default, so multiple
      // messages are ok.

      // If onMessage() needs to spawn a thread or do something else,
      // it should use its own lock.
      synchronized (LOCK) {
        // sanity check for null as this is a public method
        if (sWakeLock != null) {
          sWakeLock.release();
        } else {
          // should never happen during normal workflow
          mLogger.log(Log.ERROR, "Wakelock reference is null");
        }
      }
    }
  }