title: Android: why am i always getting the first intent from push notifications?
body: <p>I'm making a push notification service for my news app, i'm sending a notification from my php server using the new GoogleCloudMessaging (GCM), when the message arrives to the phone, my app catches the message and make a notification out of it, when you click on the notification it will take you to the DemoActivity(which is the main activity in this demo app) and display the text in a TextView. Now this works perfectly for the first message i send from my server, but when i send messages after the first one, they reach the phone and my app makes a notification correctly but when i click on the notification it always displays the first message. </p>
  
  <p>Here's my code:</p>
  
  <p>This is DemoActivity:</p>
  
  <pre><code>import android.app.Activity;
  import android.content.Context;
  import android.content.Intent;
  import android.content.SharedPreferences;
  import android.content.pm.PackageInfo;
  import android.content.pm.PackageManager;
  import android.os.AsyncTask;
  import android.os.Bundle;
  import android.util.Log;
  import android.widget.TextView;
  
  import com.google.android.gms.common.ConnectionResult;
  import com.google.android.gms.common.GooglePlayServicesUtil;
  import com.google.android.gms.gcm.GoogleCloudMessaging;
  
  import java.io.IOException;
  import java.util.concurrent.atomic.AtomicInteger;
  
  public class DemoActivity extends Activity {
  
      public static final String EXTRA_MESSAGE = "message";
      public static final String PROPERTY_REG_ID = "registration_id";
      private static final String PROPERTY_APP_VERSION = "appVersion";
      private final static int PLAY_SERVICES_RESOLUTION_REQUEST = 9000;
  
      /**
       * Substitute you own sender ID here. This is the project number you got
       * from the API Console, as described in "Getting Started."
       */
      String SENDER_ID = "Sender id";
  
      /**
       * Tag used on log messages.
       */
      static final String TAG = "GCMDemo";
  
      TextView mDisplay;
      GoogleCloudMessaging gcm;
      AtomicInteger msgId = new AtomicInteger();
      SharedPreferences prefs;
      Context context;
      String notificationText;
  
      String regid;
  
      @Override
      public void onCreate(Bundle savedInstanceState) {
          super.onCreate(savedInstanceState);
          setContentView(R.layout.main);
          mDisplay = (TextView) findViewById(R.id.display);
          context = getApplicationContext();
  
  
  
  
  
          // Check device for Play Services APK. If check succeeds, proceed with
          //  GCM registration.
          if (checkPlayServices()) {
              gcm = GoogleCloudMessaging.getInstance(this);
              regid = getRegistrationId(context);
  
              if (regid.isEmpty()) {
                  registerInBackground();
              }
          } else {
              Log.i(TAG, "No valid Google Play Services APK found.");
          }
  
      }
      /**
       * Gets the current registration ID for application on GCM service.
       * &lt;p&gt;
       * If result is empty, the app needs to register.
       *
       * @return registration ID, or empty string if there is no existing
       *         registration ID.
       */
      private String getRegistrationId(Context context) {
          final SharedPreferences prefs = getGCMPreferences(context);
          String registrationId = prefs.getString(PROPERTY_REG_ID, "");
          if (registrationId.isEmpty()) {
              Log.i(TAG, "Registration not found.");
              return "";
          }
          // Check if app was updated; if so, it must clear the registration ID
          // since the existing registration ID is not guaranteed to work with
          // the new app version.
          int registeredVersion = prefs.getInt(PROPERTY_APP_VERSION, Integer.MIN_VALUE);
          int currentVersion = getAppVersion(context);
          if (registeredVersion != currentVersion) {
              Log.i(TAG, "App version changed.");
              return "";
          }
          return registrationId;
      }
      /**
       * @return Application's {@code SharedPreferences}.
       */
      private SharedPreferences getGCMPreferences(Context context) {
          // This sample app persists the registration ID in shared preferences, but
          // how you store the registration ID in your app is up to you.
          return getSharedPreferences(DemoActivity.class.getSimpleName(),
                  Context.MODE_PRIVATE);
      }
      /**
       * @return Application's version code from the {@code PackageManager}.
       */
      private static int getAppVersion(Context context) {
          try {
              PackageInfo packageInfo = context.getPackageManager()
                      .getPackageInfo(context.getPackageName(), 0);
              return packageInfo.versionCode;
          } catch (PackageManager.NameNotFoundException e) {
              // should never happen
              throw new RuntimeException("Could not get package name: " + e);
          }
      }
      /**
       * Registers the application with GCM servers asynchronously.
       * &lt;p&gt;
       * Stores the registration ID and app versionCode in the application's
       * shared preferences.
       */
      private void registerInBackground() {
          new AsyncTask&lt;Void,Void,String&gt;() {
              @Override
              protected String doInBackground(Void... params) {
                  String msg = "";
                  try {
                      if (gcm == null) {
                          gcm = GoogleCloudMessaging.getInstance(context);
                      }
                      regid = gcm.register(SENDER_ID);
                      msg = "Device registered, registration ID=" + regid;
  
                      // You should send the registration ID to your server over HTTP,
                      // so it can use GCM/HTTP or CCS to send messages to your app.
                      // The request to your server should be authenticated if your app
                      // is using accounts.
                      sendRegistrationIdToBackend();
  
                      // For this demo: we don't need to send it because the device
                      // will send upstream messages to a server that echo back the
                      // message using the 'from' address in the message.
  
                      // Persist the registration ID - no need to register again.
                      storeRegistrationId(context, regid);
                  } catch (IOException ex) {
                      msg = "Error :" + ex.getMessage();
                      // If there is an error, don't just keep trying to register.
                      // Require the user to click a button again, or perform
                      // exponential back-off.
                  }
                  return msg;
              }
  
              @Override
              protected void onPostExecute(String msg) {
                  mDisplay.append(msg + "\n");
              }
          }.execute();
      }
      /**
       * Sends the registration ID to your server over HTTP, so it can use GCM/HTTP
       * or CCS to send messages to your app. Not needed for this demo since the
       * device sends upstream messages to a server that echoes back the message
       * using the 'from' address in the message.
       */
      private void sendRegistrationIdToBackend() {
          // Your server-side implementation here.
      }
      /**
       * Stores the registration ID and app versionCode in the application's
       * {@code SharedPreferences}.
       *
       * @param context application's context.
       * @param regId registration ID
       */
      private void storeRegistrationId(Context context, String regId) {
          final SharedPreferences prefs = getGCMPreferences(context);
          int appVersion = getAppVersion(context);
          Log.i(TAG, "Saving regId on app version " + appVersion);
          SharedPreferences.Editor editor = prefs.edit();
          editor.putString(PROPERTY_REG_ID, regId);
          editor.putInt(PROPERTY_APP_VERSION, appVersion);
          editor.commit();
      }
      /**
       * Check the device to make sure it has the Google Play Services APK. If
       * it doesn't, display a dialog that allows users to download the APK from
       * the Google Play Store or enable it in the device's system settings.
       */
      private boolean checkPlayServices() {
          int resultCode = GooglePlayServicesUtil.isGooglePlayServicesAvailable(this);
          if (resultCode != ConnectionResult.SUCCESS) {
              if (GooglePlayServicesUtil.isUserRecoverableError(resultCode)) {
                  GooglePlayServicesUtil.getErrorDialog(resultCode, this,
                          PLAY_SERVICES_RESOLUTION_REQUEST).show();
              } else {
                  Log.i(TAG, "This device is not supported.");
                  finish();
              }
              return false;
          }
          return true;
      }
      // You need to do the Play Services APK check here too.
      @Override
      protected void onResume() {
          super.onResume();
          checkPlayServices();
      }
      @Override
      protected void onNewIntent(Intent intent) {
          super.onNewIntent(intent);
          Bundle extras = intent.getExtras();
          if (extras != null) {
              notificationText = extras.getString("theMsg");
              mDisplay.setText(notificationText);
          }
      }
  }
  </code></pre>
  
  <p>And this is GCMBroadcastReceiver: </p>
  
  <pre><code>import android.app.Activity;
  import android.content.ComponentName;
  import android.content.Context;
  import android.content.Intent;
  import android.os.Bundle;
  import android.support.v4.content.WakefulBroadcastReceiver;
  import android.view.LayoutInflater;
  import android.view.View;
  import android.widget.TextView;
  
  public class GcmBroadcastReceiver extends WakefulBroadcastReceiver {
      @Override
      public void onReceive(Context context, Intent intent) {
          // Explicitly specify that GcmIntentService will handle the intent.
          ComponentName comp = new ComponentName(context.getPackageName(),
                  GcmIntentService.class.getName());
          // Start the service, keeping the device awake while it is launching.
          startWakefulService(context, (intent.setComponent(comp)));
          setResultCode(Activity.RESULT_OK);
      }
  }
  </code></pre>
  
  <p>And this GCMIntentService:</p>
  
  <pre><code>import android.app.IntentService;
  import android.app.NotificationManager;
  import android.app.PendingIntent;
  import android.content.Context;
  import android.content.Intent;
  import android.os.Bundle;
  import android.os.SystemClock;
  import android.support.v4.app.NotificationCompat;
  import android.util.Log;
  
  
  import com.google.android.gms.gcm.GoogleCloudMessaging;
  
  public class GcmIntentService extends IntentService {
      public static final int NOTIFICATION_ID = 1;
  
      static final String TAG = "GCMDemo";
      NotificationCompat.Builder builder;
  
  
      public GcmIntentService() {
          super("GcmIntentService");
      }
  
  
  
      @Override
      protected void onHandleIntent(Intent intent) {
  
  
  
          Bundle extras = intent.getExtras();
          GoogleCloudMessaging gcm = GoogleCloudMessaging.getInstance(this);
          // The getMessageType() intent parameter must be the intent you received
          // in your BroadcastReceiver.
          String messageType = gcm.getMessageType(intent);
  
          if (!extras.isEmpty()) {  // has effect of unparcelling Bundle
              /*
               * Filter messages based on message type. Since it is likely that GCM
               * will be extended in the future with new message types, just ignore
               * any message types you're not interested in, or that you don't
               * recognize.
               */
              if (GoogleCloudMessaging.
                      MESSAGE_TYPE_SEND_ERROR.equals(messageType)) {
                  sendNotification("Send error: " + extras.toString(), "");
              } else if (GoogleCloudMessaging.
                      MESSAGE_TYPE_DELETED.equals(messageType)) {
                  sendNotification("Deleted messages on server: " +
                          extras.toString(), "");
                  // If it's a regular GCM message, do some work.
              } else if (GoogleCloudMessaging.
                      MESSAGE_TYPE_MESSAGE.equals(messageType)) {
                  // This loop represents the service doing some work.
                  /*for (int i=0; i&lt;5; i++) {
                      Log.i(TAG, "Working... " + (i+1)
                              + "/5 @ " + SystemClock.elapsedRealtime());
                      try {
                          Thread.sleep(5000);
                      } catch (InterruptedException e) {
                      }
                  }*/
                  //Log.i(TAG, "Completed work @ " + SystemClock.elapsedRealtime());
                  Log.i(TAG, "Received a notification");
                  // Post notification of received message.
                  sendNotification(extras.get("price").toString(), extras.get("id").toString());
                  Log.i(TAG, "Received: " + extras.toString());
              }
          }
          // Release the wake lock provided by the WakefulBroadcastReceiver.
          GcmBroadcastReceiver.completeWakefulIntent(intent);
      }
  
      // Put the message into a notification and post it.
      // This is just one simple example of what you might choose to do with
      // a GCM message.
  
  
  
      private void sendNotification(String msg, String id) {
          Intent notificationIntent = new Intent(this, DemoActivity.class);
          notificationIntent.putExtra("theMsg",msg);
          notificationIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
          NotificationManager mNotificationManager = (NotificationManager)
                  this.getSystemService(Context.NOTIFICATION_SERVICE);
  
          PendingIntent contentIntent = PendingIntent.getActivity(
                          this,
                  0,
                  notificationIntent,
                          PendingIntent.FLAG_UPDATE_CURRENT
                  );
  
          NotificationCompat.Builder mBuilder =
                  new NotificationCompat.Builder(this)
                          .setSmallIcon(R.drawable.ic_stat_gcm)
                          .setContentTitle("GCM Notification")
                          .setStyle(new NotificationCompat.BigTextStyle()
                                  .bigText(msg))
                          .setContentText(msg);
  
          mBuilder.setContentIntent(contentIntent);
          mNotificationManager.notify(NOTIFICATION_ID, mBuilder.build());
  
      }
  }
  </code></pre>
  
  <p>And this is the AndroidManifest:</p>
  
  <pre><code>&lt;manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="fm.ana.officialgcmtest"&gt;
  
      &lt;uses-permission android:name="android.permission.INTERNET" /&gt;
      &lt;uses-permission android:name="android.permission.GET_ACCOUNTS" /&gt;
      &lt;uses-permission android:name="android.permission.WAKE_LOCK" /&gt;
      &lt;uses-permission android:name="com.google.android.c2dm.permission.RECEIVE" /&gt;
  
      &lt;permission android:name="fm.ana.officialgcmtest.permission.C2D_MESSAGE"
          android:protectionLevel="signature" /&gt;
      &lt;uses-permission android:name="fm.ana.officialgcmtest.permission.C2D_MESSAGE" /&gt;
  
      &lt;application android:allowBackup="true" android:label="@string/app_name"
          android:icon="@mipmap/ic_launcher" android:theme="@style/AppTheme"&gt;
  
          &lt;activity android:name=".NotificationHandler" /&gt;
  
          &lt;activity
              android:name=".DemoActivity"
              android:label="@string/app_name" &gt;
              &lt;intent-filter&gt;
                  &lt;action android:name="android.intent.action.MAIN" /&gt;
  
                  &lt;category android:name="android.intent.category.LAUNCHER" /&gt;
              &lt;/intent-filter&gt;
          &lt;/activity&gt;
  
          &lt;meta-data android:name="com.google.android.gms.version"
              android:value="@integer/google_play_services_version" /&gt;
  
  
          &lt;receiver
              android:name=".GcmBroadcastReceiver"
              android:permission="com.google.android.c2dm.permission.SEND" &gt;
              &lt;intent-filter&gt;
                  &lt;action android:name="com.google.android.c2dm.intent.RECEIVE" /&gt;
                  &lt;category android:name="fm.ana.officialgcmtest" /&gt;
              &lt;/intent-filter&gt;
          &lt;/receiver&gt;
          &lt;service android:name=".GcmIntentService" /&gt;
  
      &lt;/application&gt;
  
  &lt;/manifest&gt; 
  </code></pre>
  
  <p>I made some researches and i found that i have to tell the app to get the new intent when calling getIntent() but i'm having trouble doing that correctly.</p>
  
  <p>Anyone can help with that ?</p>