title: gcm registers again when regid for that user already exists on my db
body: <p>I was referring to <a href="http://www.androidhive.info/2012/10/android-push-notifications-using-google-cloud-messaging-gcm-php-and-mysql/" rel="nofollow noreferrer">link</a> for gcm implementation and I got it to work 8 months ago.  </p>
  
  <p>Today when I tried sending the message to my device it worked but also registered new rigid and null,null email and username when I received the message and saw it in Mainacitvity that <code>Attempt #1 to register</code> was displayed in textview above edittext. But this email id and rigid already exists in db. Also after this process a new rigid with both username and email id was null as mentioned above.</p>
  
  <p><strong>I would like to know what is the right way to implement the gcm service so that the id just updates the previous rigid .But also previous regid also works now so why does gcm re-register gcm-id</strong></p>
  
  <pre><code>final String regId = GCMRegistrar.getRegistrationId(this);
  </code></pre>
  
  <p>The code above returns null and I have to re-register the user who already exists in my db? </p>
  
  <p>I really appreciate any help. Any other approach to gcm which is easier to implement on client and on my db please let me know.</p>
  
  <p><strong>MainActivity.java</strong></p>
  
  <pre><code>package com.androidhive.pushnotifications;
  
  import static com.androidhive.pushnotifications.CommonUtilities.DISPLAY_MESSAGE_ACTION;
  import static com.androidhive.pushnotifications.CommonUtilities.EXTRA_MESSAGE;
  import static com.androidhive.pushnotifications.CommonUtilities.SENDER_ID;
  import android.app.Activity;
  import android.content.BroadcastReceiver;
  import android.content.Context;
  import android.content.Intent;
  import android.content.IntentFilter;
  import android.os.AsyncTask;
  import android.os.Bundle;
  import android.util.Log;
  import android.widget.TextView;
  import android.widget.Toast;
  
  import com.google.android.gcm.GCMRegistrar;
  
  public class MainActivity extends Activity {
      // label to display gcm messages
      TextView lblMessage;
  
      // Asyntask
      AsyncTask&lt;Void, Void, Void&gt; mRegisterTask;
  
      // Alert dialog manager
      AlertDialogManager alert = new AlertDialogManager();
  
      // Connection detector
      ConnectionDetector cd;
  
      public static String name;
      public static String email;
  
      @Override
      public void onCreate(Bundle savedInstanceState) {
          super.onCreate(savedInstanceState);
          setContentView(R.layout.activity_main);
  
          cd = new ConnectionDetector(getApplicationContext());
  
          // Check if Internet present
          if (!cd.isConnectingToInternet()) {
              // Internet Connection is not present
              alert.showAlertDialog(MainActivity.this,
                      "Internet Connection Error",
                      "Please connect to working Internet connection", false);
              // stop executing code by return
              return;
          }
  
          // Getting name, email from intent
          Intent i = getIntent();
  
          name = i.getStringExtra("name");
          email = i.getStringExtra("email");     
  
          // Make sure the device has the proper dependencies.
          GCMRegistrar.checkDevice(this);
  
          // Make sure the manifest was properly set - comment out this line
          // while developing the app, then uncomment it when it's ready.
          GCMRegistrar.checkManifest(this);
  
          lblMessage = (TextView) findViewById(R.id.lblMessage);
  
          registerReceiver(mHandleMessageReceiver, new IntentFilter(
                  DISPLAY_MESSAGE_ACTION));
  
          // Get GCM registration id
          final String regId = GCMRegistrar.getRegistrationId(this);
  
          // Check if regid already presents
          if (regId.equals("")) {
              // Registration is not present, register now with GCM          
              GCMRegistrar.register(this, SENDER_ID);
          } else {
              // Device is already registered on GCM
              if (GCMRegistrar.isRegisteredOnServer(this)) {
                  // Skips registration.             
                  Toast.makeText(getApplicationContext(), "Already registered with GCM", Toast.LENGTH_LONG).show();
              } else {
                  // Try to register again, but not in the UI thread.
                  // It's also necessary to cancel the thread onDestroy(),
                  // hence the use of AsyncTask instead of a raw thread.
                  final Context context = this;
                  mRegisterTask = new AsyncTask&lt;Void, Void, Void&gt;() {
  
                      @Override
                      protected Void doInBackground(Void... params) {
                          // Register on our server
                          // On server creates a new user
                          ServerUtilities.register(context, name, email, regId);
                          return null;
                      }
  
                      @Override
                      protected void onPostExecute(Void result) {
                          mRegisterTask = null;
                      }
  
                  };
                  mRegisterTask.execute(null, null, null);
              }
          }
      }      
  
      /**
       * Receiving push messages
       * */
      private final BroadcastReceiver mHandleMessageReceiver = new BroadcastReceiver() {
          @Override
          public void onReceive(Context context, Intent intent) {
              String newMessage = intent.getExtras().getString(EXTRA_MESSAGE);
              // Waking up mobile if it is sleeping
              WakeLocker.acquire(getApplicationContext());
  
              /**
               * Take appropriate action on this message
               * depending upon your app requirement
               * For now i am just displaying it on the screen
               * */
  
              // Showing received message
              lblMessage.append(newMessage + "\n");          
              Toast.makeText(getApplicationContext(), "New Message: " + newMessage, Toast.LENGTH_LONG).show();
  
              // Releasing wake lock
              WakeLocker.release();
          }
      };
  
      @Override
      protected void onDestroy() {
          if (mRegisterTask != null) {
              mRegisterTask.cancel(true);
          }
          try {
              unregisterReceiver(mHandleMessageReceiver);
              GCMRegistrar.onDestroy(this);
          } catch (Exception e) {
              Log.e("UnRegister Receiver Error", "&gt; " + e.getMessage());
          }
          super.onDestroy();
      }
  
  }
  </code></pre>
  
  <p><strong>ServerUtilities.java</strong></p>
  
  <pre><code>package com.androidhive.pushnotifications;
  
  import static com.androidhive.pushnotifications.CommonUtilities.SERVER_URL;
  import static com.androidhive.pushnotifications.CommonUtilities.TAG;
  import static com.androidhive.pushnotifications.CommonUtilities.displayMessage;
  
  import java.io.IOException;
  import java.io.OutputStream;
  import java.net.HttpURLConnection;
  import java.net.MalformedURLException;
  import java.net.URL;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.Map;
  import java.util.Map.Entry;
  import java.util.Random;
  
  import android.content.Context;
  import android.util.Log;
  
  import com.google.android.gcm.GCMRegistrar;
  
  
  public final class ServerUtilities {
      private static final int MAX_ATTEMPTS = 5;
      private static final int BACKOFF_MILLI_SECONDS = 2000;
      private static final Random random = new Random();
  
      /**
       * Register this account/device pair within the server.
       *
       */
      static void register(final Context context, String name, String email, final String regId) {
          Log.i(TAG, "registering device (regId = " + regId + ")");
          String serverUrl = SERVER_URL;
          Map&lt;String, String&gt; params = new HashMap&lt;String, String&gt;();
          params.put("regId", regId);
          params.put("name", name);
          params.put("email", email);
  
          long backoff = BACKOFF_MILLI_SECONDS + random.nextInt(1000);
          // Once GCM returns a registration id, we need to register on our server
          // As the server might be down, we will retry it a couple
          // times.
          for (int i = 1; i &lt;= MAX_ATTEMPTS; i++) {
              Log.d(TAG, "Attempt #" + i + " to register");
              try {
                  displayMessage(context, context.getString(
                          R.string.server_registering, i, MAX_ATTEMPTS));
                  post(serverUrl, params);
                  GCMRegistrar.setRegisteredOnServer(context, true);
                  String message = context.getString(R.string.server_registered);
                  CommonUtilities.displayMessage(context, message);
                  return;
              } catch (IOException e) {
                  // Here we are simplifying and retrying on any error; in a real
                  // application, it should retry only on unrecoverable errors
                  // (like HTTP error code 503).
                  Log.e(TAG, "Failed to register on attempt " + i + ":" + e);
                  if (i == MAX_ATTEMPTS) {
                      break;
                  }
                  try {
                      Log.d(TAG, "Sleeping for " + backoff + " ms before retry");
                      Thread.sleep(backoff);
                  } catch (InterruptedException e1) {
                      // Activity finished before we complete - exit.
                      Log.d(TAG, "Thread interrupted: abort remaining retries!");
                      Thread.currentThread().interrupt();
                      return;
                  }
                  // increase backoff exponentially
                  backoff *= 2;
              }
          }
          String message = context.getString(R.string.server_register_error,
                  MAX_ATTEMPTS);
          CommonUtilities.displayMessage(context, message);
      }
  
      /**
       * Unregister this account/device pair within the server.
       */
      static void unregister(final Context context, final String regId) {
          Log.i(TAG, "unregistering device (regId = " + regId + ")");
          String serverUrl = SERVER_URL + "/unregister";
          Map&lt;String, String&gt; params = new HashMap&lt;String, String&gt;();
          params.put("regId", regId);
          try {
              post(serverUrl, params);
              GCMRegistrar.setRegisteredOnServer(context, false);
              String message = context.getString(R.string.server_unregistered);
              CommonUtilities.displayMessage(context, message);
          } catch (IOException e) {
              // At this point the device is unregistered from GCM, but still
              // registered in the server.
              // We could try to unregister again, but it is not necessary:
              // if the server tries to send a message to the device, it will get
              // a "NotRegistered" error message and should unregister the device.
              String message = context.getString(R.string.server_unregister_error,
                      e.getMessage());
              CommonUtilities.displayMessage(context, message);
          }
      }
  
      /**
       * Issue a POST request to the server.
       *
       * @param endpoint POST address.
       * @param params request parameters.
       *
       * @throws IOException propagated from POST.
       */
      private static void post(String endpoint, Map&lt;String, String&gt; params)
              throws IOException {   
  
          URL url;
          try {
              url = new URL(endpoint);
          } catch (MalformedURLException e) {
              throw new IllegalArgumentException("invalid url: " + endpoint);
          }
          StringBuilder bodyBuilder = new StringBuilder();
          Iterator&lt;Entry&lt;String, String&gt;&gt; iterator = params.entrySet().iterator();
          // constructs the POST body using the parameters
          while (iterator.hasNext()) {
              Entry&lt;String, String&gt; param = iterator.next();
              bodyBuilder.append(param.getKey()).append('=')
                      .append(param.getValue());
              if (iterator.hasNext()) {
                  bodyBuilder.append('&amp;');
              }
          }
          String body = bodyBuilder.toString();
          Log.v(TAG, "Posting '" + body + "' to " + url);
          byte[] bytes = body.getBytes();
          HttpURLConnection conn = null;
          try {
              Log.e("URL", "&gt; " + url);
              conn = (HttpURLConnection) url.openConnection();
              conn.setDoOutput(true);
              conn.setUseCaches(false);
              conn.setFixedLengthStreamingMode(bytes.length);
              conn.setRequestMethod("POST");
              conn.setRequestProperty("Content-Type",
                      "application/x-www-form-urlencoded;charset=UTF-8");
              // post the request
              OutputStream out = conn.getOutputStream();
              out.write(bytes);
              out.close();
              // handle the response
              int status = conn.getResponseCode();
              if (status != 200) {
                throw new IOException("Post failed with error code " + status);
              }
          } finally {
              if (conn != null) {
                  conn.disconnect();
              }
          }
        }
  }
  </code></pre>