I had set up the GCM notificaion in android .
with in one year i am getting so many device id for same device.
Is there any way to validate the Regsitraion id
I know on sending the push notification to old id it will gives the new id .
But i need to clear my Db is there any way to do it?
First of all, if you handle registration to GCM in the client side properly, you should be getting many registration IDs for the same device.
You should store the registration ID in the app's shared preferences, and register again to GCM only when a new version of your app is installed on the device (that's what Google recommend to do).
To handle the case of your app being uninstalled and installed again, you can generate a unique instance identifier for each device. Send that identifier to your server along with the registration ID. Store that identifier in the device's external storage, so it won't get deleted when your app is uninstalled. Try to restore it from external storage (if it's available) when your app is installed. Now, if you get a new registration ID, but still have the original instance identifier, when you send them to your server, your server will see it already has an old registration ID for that instance identifier, and will replace the old registration ID with the new one (instead of creating a new record).
Second of all, if you fail to avoid the creation of duplicate registration IDs for the same device in your DB, your only option to detect them is by sending a GCM message to the registration ID and handling the returned canonical registration ID. You could, however, send a message with dry_run=true, which simulates the sending of a message without actually sending it. I just tested it with an old registration ID. The message wasn't delivered, but I got the response with the canonical registration ID.
dry_run If included, allows developers to test their request without actually sending a message. Optional. The default value is false.
Related
I am doing an android application which uses gcm.I came to know that when the application is uninstalled and re installed there is no guarantee to receive the same registration id again.So what I did is while logging in I take one unique Id from application server and whenever new registration id is made I am able to replace that in application server.So what my question is, I am not using the canonical id for replacing the latest registration id in gcm server.Will it cause any problem? Please help me.
Your solution is basically good, though I'm not sure whether that unique Id your server generates is associated with the device or the logged in user. If it's the former, make sure you persist it on the device's external storage, so that it doesn't get lost when the app is uninstalled. If it's the latter, I'm not sure how you are handling the case of the same user logging in on multiple devices.
While your strategy is good for maintaining the current registration ID on both the device and your server, you should still handle canonical registration ID responses from Google just to be safe.
On the server side, as long as the application is behaving well,
everything should work normally. However, if a bug in the application
triggers multiple registrations for the same device, it can be hard to
reconcile state and you might end up with duplicate messages.
GCM provides a facility called "canonical registration IDs" to easily
recover from these situations. A canonical registration ID is defined
to be the ID of the last registration requested by your application.
This is the ID that the server should use when sending messages to the
device.
If later on you try to send a message using a different registration
ID, GCM will process the request as usual, but it will include the
canonical registration ID in the registration_id field of the
response. Make sure to replace the registration ID stored in your
server with this canonical ID, as eventually the ID you're using will
stop working.
Source : http://developer.android.com/google/gcm/adv.html#canonical
I am working on an android project which uses gcm. I came to know that if we uninstall the appfrom device and reinstalled most of the time the device gets new registration id.Then if we do not delete the old one from application server and update, The messages will be sending to both ids and in the response it will be showing canonical id is present.My question is, at this point message will be successfully send to that device or not?
When you receive a canonical registration ID in the response from Google, the message was accepted by the GCM server and the GCM server would attempt to deliver it to the device. Whether it is actually sent to the device depends on whether the device is available (i.e. connected to the internet).
So if your server sends a GCM message to both the old ID and the new ID, the device will probably get two messages.
Canonical IDs
On the server side, as long as the application is behaving well,
everything should work normally. However, if a bug in the application
triggers multiple registrations for the same device, it can be hard to
reconcile state and you might end up with duplicate messages.
GCM provides a facility called "canonical registration IDs" to easily
recover from these situations. A canonical registration ID is defined
to be the ID of the last registration requested by your application.
This is the ID that the server should use when sending messages to the
device.
If later on you try to send a message using a different registration
ID, GCM will process the request as usual, but it will include the
canonical registration ID in the registration_id field of the
response. Make sure to replace the registration ID stored in your
server with this canonical ID, as eventually the ID you're using will
stop working.
(Source)
You can overcome this problem by assigning a unique identifier to each instance of your application. If you store that identifier in the device's external storage, it won't be deleted when the app is uninstalled. Then you can recover it when the app is installed again. If you send this identifier to your server along with the registration ID, you can check if your server has an old registration ID for this identifier, and delete it.
#Eran We have two option either to remove older registration ids or update with Key and position of canonical id. I prefer to update... You can view working code of mine i have answered here Steps to Update Canonical Ids
I have an app published at the play store.
When I want to send a notification, some users (for example, me) receive duplicate messages.
I know that I have to handle it when I send the messages to recover the canonical ids and update the old registered id. But, Can I do something to fix this situation without sending any notification?
You should figure out a way to notify your server when GCM sends your app a new registration id.
Currently when you get a registration id from GCM, you send it to your server, which probably adds it to your DB without checking if that id should replace an old id.
In order to detect that case, and update the old id instead pf inserting a new one, you should assign your own unique id to each app instance, and send it to the server along with the reg id. You should persist that id in external storage, so that it survive even if your app is uninstalled and then installed again.
I am developing an app using the new Google Cloud Messaging Framework. We know that once we register our app we get a registration id. But what happens when the user unistalls the app through the device for a number of times and re installs again and again (there is no new notification sent till now). Now with many installations done google might return several new registration ids and now all the ids are saved in the app database.
If there is a notification to be sent it would be sent to all the ids previously saved also. Now my problem is that i think google is sending the notification to all the previous ids(so i get multiple notifications on the same device).
I hope i made my question clear and is there a solution to this.
You can assign a unique identifier to the app on each device. If you store that identifier on the external storage of this device, it won't be removed when the app is uninstalled. Then, when the app is installed again, you can send the registration ID along with that stored unique identifier. Your server will use the identifier to locate the old registration ID and replace it with the new one.
In addition, you should check for canonical registration IDs in the response you get from GCM. Each time to get a canonical ID, you should make sure you have that ID in your DB and remove the old ID (the one you used to send the message that got the canonical registration ID in its response).
I suggest you read the section Canonical IDs of the official documentation, as canonical IDs are specifically designed to solve your problem.
Every time you will send a message to an old registration ID Google will let you know what is the current canonical ID of the device you are sending a message to. Just make sure to replace your ID by this one.
Also make sure to check the code of the official demo here.
Well, I know that the registration id of server would expire. However, how about the device registration id?
If yes, how do the server and client know about that?
Now I just simply save the id into database and assume it would never change.
Btw, is the registration id of server associated with the device registration id? Why the tutorial from the internet store them in the pair
Short answer is Yes, as stated here.
The application should store this ID for later use. Note that Google may periodically refresh the registration ID, so you should design your application with the understanding that the REGISTRATION Intent may be called multiple times. Your application needs to be able to respond accordingly.
Basically what would have to happen is that your application needs some sort of communication with your server to notify it that it received a new id. What you could do is when the app receives a registration id, store it on some remote database along with some additional unique information about that device (or user credentials if app has authentication). When Google decides to change the registration id, just update the previous entry on the remote db with the new id. Then when your server needs to push a message to some device, it matches the device to an up-to-date registration id in the database and uses that id to push the notification.