Est-il un Android unique ID de l'appareil?

Paramètres.Sécuriser#ANDROID_ID retourne le Android ID unique pour chaque utilisateur 64-bit hex chaîne.

import android.provider.Settings.Secure;

private String android_id = Secure.getString(getContext().getContentResolver(),
                                                        Secure.ANDROID_ID); 

Dernière Mise À Jour: 6/2/15

---

Après la lecture de chaque Débordement de Pile post sur la création d'un IDENTIFIANT unique, Google blog des développeurs Android et de la documentation, je me sens comme si la "Pseudo ID" est la meilleure option possible.

Question principale: Matériel vs Logiciel

Matériel

• Les utilisateurs peuvent modifier leur matériel, une tablette Android ou téléphone, afin de les Identifiants uniques basés sur le matériel ne sont pas de bonnes idées pour le SUIVI des UTILISATEURS
• Pour SUIVI du MATÉRIEL, c'est une excellente idée

Logiciel

• Les utilisateurs peuvent aussi nettoyer/changer la ROM si elles sont enracinées
• Vous pouvez effectuer le suivi des utilisateurs à travers les plates-formes (iOS, Android, Windows et Web)
• Les meilleurs veulent SUIVRE UN UTILISATEUR INDIVIDUEL avec leur consentement est de simplement leur demander de connexion (faire de ce fluide à l'aide d'OAuth)

---

Répartition globale avec Android

- Garantir l'unicité (inclure enracinée périphériques) pour l'API >= 9/10 (99,5% des appareils Android)

- Pas de droits supplémentaires

Pseudo code:

if API >= 9/10: (99.5% of devices)

return unique ID containing serial id (rooted devices may be different)

else

return the unique ID of build information (may overlap data - API < 9)

Grâce à @stansult pour l'affichage toutes nos options (dans ce Débordement de Pile question).

Liste des options - les raisons/pourquoi ne pas les utiliser:

• Email De L'Utilisateur - Logiciel

  • Utilisateur peut modifier l'email - TRÈS peu probable
  • API 5+ <uses-permission android:name="android.permission.GET_ACCOUNTS" /> ou
  • API 14+ <uses-permission android:name="android.permission.READ_PROFILE" /> <uses-permission android:name="android.permission.READ_CONTACTS" /> (Comment obtenir de l'appareil Android, l'adresse de messagerie principale)

• De L'Utilisateur Numéro De Téléphone - Logiciel

  • Les utilisateurs pourraient changer les numéros de téléphone - TRÈS peu probable
  • <uses-permission android:name="android.permission.READ_PHONE_STATE" />

• IMEI - Matériel (seuls les téléphones, les besoins android.permission.READ_PHONE_STATE)

  • La plupart des utilisateurs déteste le fait qu'il dit "Appels Téléphoniques" dans l'autorisation. Certains utilisateurs donnent le mauvais cote, car ils croient que vous êtes tout simplement voler leurs informations personnelles lorsque tout ce que vous voulez vraiment faire est de suivre l'installation des périphériques. Il est évident que vous êtes à la collecte de données.
  • <uses-permission android:name="android.permission.READ_PHONE_STATE" />

• Android ID - Matériel (peut être null, peut changer lors de la réinitialisation d'usine, peut être modifié sur un dispositif enracinée)

  • Car il peut être 'null', nous pouvons vérifier pour 'null', et changer sa valeur, mais cela signifie qu'il ne sera plus unique.
  • Si vous avez un utilisateur avec une réinitialisation d'usine de l'appareil, la valeur peut avoir changé ou modifié sur le dispositif enracinée donc il y a peut-être des doublons entrées si vous êtes le suivi de l'utilisateur installe.

• Adresse MAC WLAN - Matériel (besoins android.permission.ACCESS_WIFI_STATE)

  • Cela pourrait être la deuxième meilleure option, mais vous êtes toujours à la collecte et le stockage d'un identifiant unique qui vient directement de l'utilisateur. C'est évident que vous êtes à la collecte de données.
  • <uses-permission android:name="android.permission.ACCESS_WIFI_STATE "/>

• Bluetooth - Adresse MAC du Matériel (appareils avec Bluetooth, les besoins android.permission.BLUETOOTH)

  • La plupart des applications sur le marché n'utilisez pas la connectivité Bluetooth, et donc, si votre application n'utilise pas le Bluetooth et que vous êtes y compris la présente, l'utilisateur pourrait devenir suspect.
  • <uses-permission android:name="android.permission.BLUETOOTH "/>

• Pseudo-Unique ID - Logiciel (pour tous les appareils Android)

  • Très possible, peut contenir des collisions - Voir ma méthode affichés ci-dessous!
  • Cela vous permet d'avoir un " presque unique d'identification de l'utilisateur, sans prendre tout ce qui est privé. Vous pouvez créer votre propre identité anonymes à partir d'informations de périphérique.

---

Je sais qu'il n'est pas "parfait" d'obtenir un ID unique sans l'aide d'autorisations; cependant, parfois nous n'avons vraiment besoin de suivre l'installation de l'appareil. Quand il s'agit de la création d'un IDENTIFIANT unique, nous pouvons créer un pseudo unique id " basée uniquement au large de l'information que l'API Android nous donne sans l'aide des autorisations supplémentaires. De cette façon, nous pouvons montrer à l'utilisateur de respect et d'essayer d'offrir une bonne expérience utilisateur.

Avec un pseudo-id unique, vous vraiment exécuter uniquement dans le fait qu'il peut y avoir des doublons sur la base du fait qu'il existe des dispositifs similaires. Vous pouvez modifier la méthode combinée pour le rendre plus unique; toutefois, certains développeurs ont besoin pour suivre l'installation des périphériques et cela fera l'affaire ou de la performance, basée sur des dispositifs similaires.

API >= 9:

Si leur appareil Android API 9 ou plus, c'est la garantie d'être unique en raison de la 'Construire.SÉRIE champ.

RAPPELEZ-vous, vous êtes techniquement seulement absent dehors sur environ 0,5% des utilisateurs qui ont API < 9. Vous pouvez donc vous concentrer sur le reste: C'est de 99,5% des utilisateurs!

API < 9:

Si l'utilisateur de l'appareil Android est inférieure à celle de l'API 9; avec de la chance, ils n'ont pas fait un factory reset et de leur Sécurité.ANDROID_ID " sera conservé ou non, 'null'. (voir http://developer.android.com/about/dashboards/index.html)

Si tout le reste échoue:

Si tout le reste échoue, si l'utilisateur est inférieur API 9 (moins de pain d'épice), a remis leur appareil ou 'Secure.ANDROID_ID' retourne 'null', puis tout simplement l'ID retourné sera uniquement basé sur leur appareil Android de l'information. C'est l'endroit où les collisions peuvent se produire.

Changements:

• Retiré 'Android.SECURE_ID " parce que de l'usine réinitialise pourrait causer la valeur à modifier
• Modifié le code pour changer sur les API
• Changé le Pseudo

Veuillez jeter un oeil à la méthode ci-dessous:

/**
 * Return pseudo unique ID
 * @return ID
 */
public static String getUniquePsuedoID() {
    //If all else fails, if the user does have lower than API 9 (lower
    //than Gingerbread), has reset their device or 'Secure.ANDROID_ID'
    //returns 'null', then simply the ID returned will be solely based
    //off their Android device information. This is where the collisions
    //can happen.
    //Thanks http://www.pocketmagic.net/?p=1662!
    //Try not to use DISPLAY, HOST or ID - these items could change.
    //If there are collisions, there will be overlapping data
    String m_szDevIDShort = "35" + (Build.BOARD.length() % 10) + (Build.BRAND.length() % 10) + (Build.CPU_ABI.length() % 10) + (Build.DEVICE.length() % 10) + (Build.MANUFACTURER.length() % 10) + (Build.MODEL.length() % 10) + (Build.PRODUCT.length() % 10);

    //Thanks to @Roman SL!
    //https://stackoverflow.com/a/4789483/950427
    //Only devices with API >= 9 have android.os.Build.SERIAL
    //http://developer.android.com/reference/android/os/Build.html#SERIAL
    //If a user upgrades software or roots their device, there will be a duplicate entry
    String serial = null;
    try {
        serial = android.os.Build.class.getField("SERIAL").get(null).toString();

        //Go ahead and return the serial for api => 9
        return new UUID(m_szDevIDShort.hashCode(), serial.hashCode()).toString();
    } catch (Exception exception) {
        //String needs to be initialized
        serial = "serial"; //some value
    }

    //Thanks @Joe!
    //https://stackoverflow.com/a/2853253/950427
    //Finally, combine the values we have found by using the UUID class to create a unique identifier
    return new UUID(m_szDevIDShort.hashCode(), serial.hashCode()).toString();
}

---

Nouvelle (pour les applications avec des annonces ET Google Play Services):

Depuis le Google Play Developer console:

Début le 1er août 2014, le Google Play pour les Développeurs de Programme et de Politique
exige que toutes les nouvelles appli les téléchargements et les mises à jour pour utiliser l'ID dans la publicité
la place de tout autre identificateurs persistants pour toutes les fins de publicité.
En savoir plus

Mise en œuvre:

Autorisation:

<uses-permission android:name="android.permission.INTERNET" />

Code:

import com.google.android.gms.ads.identifier.AdvertisingIdClient;
import com.google.android.gms.ads.identifier.AdvertisingIdClient.Info;
import com.google.android.gms.common.GooglePlayServicesAvailabilityException;
import com.google.android.gms.common.GooglePlayServicesNotAvailableException;
import java.io.IOException;
...

//Do not call this function from the main thread. Otherwise, 
//an IllegalStateException will be thrown.
public void getIdThread() {

  Info adInfo = null;
  try {
    adInfo = AdvertisingIdClient.getAdvertisingIdInfo(mContext);

  } catch (IOException exception) {
    //Unrecoverable error connecting to Google Play services (e.g.,
    //the old version of the service doesn't support getting AdvertisingId).

  } catch (GooglePlayServicesAvailabilityException exception) {
    //Encountered a recoverable error connecting to Google Play services. 

  } catch (GooglePlayServicesNotAvailableException exception) {
    //Google Play services is not available entirely.
  }
  final String id = adInfo.getId();
  final boolean isLAT = adInfo.isLimitAdTrackingEnabled();
}

Source/Docs:

http://developer.android.com/google/play-services/id.html
http://developer.android.com/reference/com/google/android/gms/ads/identifier/AdvertisingIdClient.html

Important:

Il est prévu que la publicité ID complètement remplacer les
l'utilisation d'autres identificateurs pour les annonces fins (tels que l'utilisation de ANDROID_ID
dans les Paramètres.Sécurisé) lors de la Google Play Services est disponible. Cas
où Google Play Services n'est pas disponible sont indiqués par un
GooglePlayServicesNotAvailableException jetés par
getAdvertisingIdInfo().

Avertissement, les utilisateurs peuvent réinitialiser:

http://en.kioskea.net/faq/34732-android-reset-your-advertising-id

J'ai essayé de faire référence à tous les liens que j'ai pris des informations. Si vous êtes absent et doivent être inclus, s'il vous plaît commentaire!

Google Joueur Services InstanceID

https://developers.google.com/instance-id/

Voici le code que Reto Meier utilisé dans le Google I/O présentation cette année pour obtenir un id unique pour l'utilisateur:

private static String uniqueID = null;
private static final String PREF_UNIQUE_ID = "PREF_UNIQUE_ID";
public synchronized static String id(Context context) {
if (uniqueID == null) {
SharedPreferences sharedPrefs = context.getSharedPreferences(
PREF_UNIQUE_ID, Context.MODE_PRIVATE);
uniqueID = sharedPrefs.getString(PREF_UNIQUE_ID, null);
if (uniqueID == null) {
uniqueID = UUID.randomUUID().toString();
Editor editor = sharedPrefs.edit();
editor.putString(PREF_UNIQUE_ID, uniqueID);
editor.commit();
}
}
return uniqueID;
}

Si vous couplez cela avec une stratégie de sauvegarde pour envoyer des préférences pour le cloud (également décrits dans Reto s parler, vous devez avoir une carte d'identité qui le lie à un utilisateur et autour de bâtons après que l'appareil a été effacé, ou même remplacés. J'ai l'intention de l'utiliser dans l'analytique à l'avenir (en d'autres termes, je n'ai pas fait que peu encore :).

Il y a plutôt infos utiles ici.

Il couvre cinq différents types d'ID:

1. IMEI (uniquement pour les appareils Android grâce à l'utilisation d'un Téléphone; les besoins android.permission.READ_PHONE_STATE)
2. Pseudo-ID Unique (pour tous les appareils Android)
3. Android ID (peut être null, peut changer lors de la réinitialisation d'usine, peut être modifié sur téléphone enracinée)
4. Adresse MAC WLAN chaîne (besoins android.permission.ACCESS_WIFI_STATE)
5. BT Adresse MAC chaîne (appareils avec Bluetooth, les besoins android.permission.BLUETOOTH)

À Google I/O Reto Meier a publié une solide réponse à la façon d'aborder ce qui devrait répondre à la plupart des développeurs besoins pour le suivi des utilisateurs à travers des installations. Anthony Nolan montre la direction dans sa réponse, mais je pensais écrire l'approche intégrale de sorte que d'autres personnes peuvent facilement voir comment le faire (il m'a fallu un certain temps à comprendre les détails).

Cette approche permettra de vous donner un anonyme, sécurisé ID d'utilisateur qui sera persistante de l'utilisateur à travers les différents dispositifs (basé sur le compte Google principal) et à travers le installe. L'approche de base est de générer de façon aléatoire un ID d'utilisateur et de les stocker dans les applications communes des préférences. Ensuite, vous utilisez Google l'agent de sauvegarde pour stocker les préférences partagées lié au compte Google dans le cloud.

Allons par le biais de l'approche intégrale. Tout d'abord, nous avons besoin de créer une copie de sauvegarde pour nos SharedPreferences à l'aide de la Sauvegarde Android Service. Commencez par enregistrer votre application via http://developer.android.com/google/backup/signup.html.

Google vous donnera une sauvegarde de la clé de service dont vous avez besoin pour ajouter à la manifester. Vous devez également indiquer à l'application d'utiliser les BackupAgent comme suit:

<application android:label="MyApplication"
android:backupAgent="MyBackupAgent">
...
<meta-data android:name="com.google.android.backup.api_key"
android:value="your_backup_service_key" />
</application>

Alors vous avez besoin pour créer la sauvegarde de l'agent et dites lui d'utiliser l'aide de l'agent pour les sharedpreferences:

public class MyBackupAgent extends BackupAgentHelper {
//The name of the SharedPreferences file
static final String PREFS = "user_preferences";
//A key to uniquely identify the set of backup data
static final String PREFS_BACKUP_KEY = "prefs";
//Allocate a helper and add it to the backup agent
@Override
public void onCreate() {
SharedPreferencesBackupHelper helper = new SharedPreferencesBackupHelper(this,          PREFS);
addHelper(PREFS_BACKUP_KEY, helper);
}
}

Pour effectuer la sauvegarde, vous devez créer une instance de BackupManager dans votre Activité principale:

BackupManager backupManager = new BackupManager(context);

Enfin créer un ID d'utilisateur, si il n'existe pas déjà, et de le stocker dans les SharedPreferences:

  public static String getUserID(Context context) {
private static String uniqueID = null;
private static final String PREF_UNIQUE_ID = "PREF_UNIQUE_ID";
if (uniqueID == null) {
SharedPreferences sharedPrefs = context.getSharedPreferences(
MyBackupAgent.PREFS, Context.MODE_PRIVATE);
uniqueID = sharedPrefs.getString(PREF_UNIQUE_ID, null);
if (uniqueID == null) {
uniqueID = UUID.randomUUID().toString();
Editor editor = sharedPrefs.edit();
editor.putString(PREF_UNIQUE_ID, uniqueID);
editor.commit();
//backup the changes
BackupManager mBackupManager = new BackupManager(context);
mBackupManager.dataChanged();
}
}
return uniqueID;
}

Ce User_ID va maintenant être persistant à travers des installations, même si l'utilisateur déplace l'appareil.

Pour plus d'informations sur cette approche, voir Reto s talk.

Et pour des détails complets sur la façon de mettre en œuvre la sauvegarde de l'agent de voir La Sauvegarde Des Données. Je recommande en particulier la section du bas sur le test que la sauvegarde ne se fait pas instantanément et donc à tester, vous devez forcer la sauvegarde.

Le code suivant renvoie l'appareil numéro de série à l'aide d'un caché l'API Android. Mais, ce code ne fonctionne pas sur Samsung Galaxy Tab parce que "ro.serialno" n'est pas défini sur cet appareil.

String serial = null;
try {
Class<?> c = Class.forName("android.os.SystemProperties");
Method get = c.getMethod("get", String.class);
serial = (String) get.invoke(c, "ro.serialno");
}
catch (Exception ignored) {
}

Un Série champ a été ajouté à la Build classe de l'API de niveau 9 (Android 2.3 - pain d'épices). La Documentation dit qu'il représente le numéro de série du matériel. Ainsi, il doit être unique, si elle existe sur l'appareil.

Je ne sais pas si elle est réellement pris en charge (=not null) par tous les appareils avec l'API de niveau >= 9 si.

Pour obtenir des instructions détaillées sur la façon d'obtenir un identifiant unique pour chaque appareil Android votre application est installée à partir de, voir l'officiel des Développeurs Android Blogue Identifier Les Installations D'Applications.

Il semble que la meilleure façon pour vous de générer un vous-même lors de l'installation et par la suite de le lire lorsque l'application est relancée.

Personnellement, je trouve cela acceptable, mais pas idéal. Pas un seul identificateur fourni par Android fonctionne dans tous les cas, comme la plupart dépendent du téléphone états radio (Wi-Fi, cellulaire on/off, Bluetooth on/off). Les autres, comme Settings.Secure.ANDROID_ID doit être mis en œuvre par le fabricant et ne sont pas garantis pour être unique.

L'exemple suivant est un exemple de l'écriture de données sur un installation fichier qui est stocké avec d'autres données de l'application enregistre localement.

public class Installation {
private static String sID = null;
private static final String INSTALLATION = "INSTALLATION";
public synchronized static String id(Context context) {
if (sID == null) {
File installation = new File(context.getFilesDir(), INSTALLATION);
try {
if (!installation.exists())
writeInstallationFile(installation);
sID = readInstallationFile(installation);
} 
catch (Exception e) {
throw new RuntimeException(e);
}
}
return sID;
}
private static String readInstallationFile(File installation) throws IOException {
RandomAccessFile f = new RandomAccessFile(installation, "r");
byte[] bytes = new byte[(int) f.length()];
f.readFully(bytes);
f.close();
return new String(bytes);
}
private static void writeInstallationFile(File installation) throws IOException {
FileOutputStream out = new FileOutputStream(installation);
String id = UUID.randomUUID().toString();
out.write(id.getBytes());
out.close();
}
}

L'IDENTIFIANT unique de l'appareil d'un système d'exploitation Android de l'appareil en tant que Chaîne de caractères, à l'aide de TelephonyManager et ANDROID_ID, est obtenue par:

String deviceId;
final TelephonyManager mTelephony = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);
if (mTelephony.getDeviceId() != null) {
deviceId = mTelephony.getDeviceId();
}
else {
deviceId = Secure.getString(
getApplicationContext().getContentResolver(),
Secure.ANDROID_ID);
}

Mais je vous conseille fortement une méthode proposée par Google, voir Identifier Les Installations D'Applications.

Il y a 30+ de réponses ici, et certains sont mêmes et certaines sont uniques. Cette réponse est fondée sur quelques-unes de ces réponses. L'un d'eux étant @Lenn Dolling de réponse.

Il combine 3 Id et crée un 32 chiffres chaîne hexadécimale. Il a très bien fonctionné pour moi.

3 Id:

Pseudo-ID - Il est généré sur la base de physique spécifications de l'appareil

ANDROID_ID - Settings.Secure.ANDROID_ID

Adresse Bluetooth - adaptateur Bluetooth adresse

Il sera de retour à quelque chose comme ceci: 551F27C060712A72730B0A0F734064B1

Remarque: Vous pouvez toujours ajouter plus d'Id pour la longId chaîne. Par exemple, le numéro de Série. wifi adresse de la carte. IMEI. De cette façon, vous rend plus unique pour chaque appareil.

@SuppressWarnings("deprecation")
@SuppressLint("HardwareIds")
public static String generateDeviceIdentifier(Context context) {
String pseudoId = "35" +
Build.BOARD.length() % 10 +
Build.BRAND.length() % 10 +
Build.CPU_ABI.length() % 10 +
Build.DEVICE.length() % 10 +
Build.DISPLAY.length() % 10 +
Build.HOST.length() % 10 +
Build.ID.length() % 10 +
Build.MANUFACTURER.length() % 10 +
Build.MODEL.length() % 10 +
Build.PRODUCT.length() % 10 +
Build.TAGS.length() % 10 +
Build.TYPE.length() % 10 +
Build.USER.length() % 10;
String androidId = Settings.Secure.getString(context.getContentResolver(), Settings.Secure.ANDROID_ID);
BluetoothAdapter bluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
String btId = "";
if (bluetoothAdapter != null) {
btId = bluetoothAdapter.getAddress();
}
String longId = pseudoId + androidId + btId;
try {
MessageDigest messageDigest = MessageDigest.getInstance("MD5");
messageDigest.update(longId.getBytes(), 0, longId.length());
//get md5 bytes
byte md5Bytes[] = messageDigest.digest();
//creating a hex string
String identifier = "";
for (byte md5Byte : md5Bytes) {
int b = (0xFF & md5Byte);
//if it is a single digit, make sure it have 0 in front (proper padding)
if (b <= 0xF) {
identifier += "0";
}
//add number to string
identifier += Integer.toHexString(b);
}
//hex string to uppercase
identifier = identifier.toUpperCase();
return identifier;
} catch (Exception e) {
Log.e("TAG", e.toString());
}
return "";
}

Ici est de savoir comment je suis à la génération de l'identifiant unique:

public static String getDeviceId(Context ctx)
{
TelephonyManager tm = (TelephonyManager) ctx.getSystemService(Context.TELEPHONY_SERVICE);
String tmDevice = tm.getDeviceId();
String androidId = Secure.getString(ctx.getContentResolver(), Secure.ANDROID_ID);
String serial = null;
if(Build.VERSION.SDK_INT > Build.VERSION_CODES.FROYO) serial = Build.SERIAL;
if(tmDevice != null) return "01" + tmDevice;
if(androidId != null) return "02" + androidId;
if(serial != null) return "03" + serial;
//other alternatives (i.e. Wi-Fi MAC, Bluetooth MAC, etc.)
return null;
}

Une autre façon est d'utiliser des /sys/class/android_usb/android0/iSerial dans une application, sans les autorisations que ce soit.

user@creep:~$ adb shell ls -l /sys/class/android_usb/android0/iSerial
-rw-r--r-- root     root         4096 2013-01-10 21:08 iSerial
user@creep:~$ adb shell cat /sys/class/android_usb/android0/iSerial
0A3CXXXXXXXXXX5

Pour ce faire en Java, on pourrait simplement utiliser un FileInputStream pour ouvrir la iSerial fichier et de lire les caractères. Juste être sûr que vous enveloppez-le d'un gestionnaire d'exception, parce que pas tous les appareils de ce fichier.

Au moins pour les appareils suivants sont connus pour avoir accès à ce fichier lisible par tout le monde:

• Galaxy Nexus
• Nexus S
• Motorola Xoom 3G
• Toshiba AT300
• HTC One V
• Mini MK802
• Samsung Galaxy S II

Vous pouvez aussi voir mon blog Fuite d'Android numéro de série matériel de non-privilégié apps où je discuter de ce que les autres fichiers sont disponibles pour plus d'informations.

J'utilise le code suivant pour obtenir la IMEI ou de l'utilisation de Secure.ANDROID_ID comme une alternative, lorsque l'appareil ne dispose pas des capacités de téléphone:

String identifier = null;
TelephonyManager tm = (TelephonyManager)context.getSystemService(Context.TELEPHONY_SERVICE));
if (tm != null)
identifier = tm.getDeviceId();
if (identifier == null || identifier .length() == 0)
identifier = Secure.getString(activity.getContentResolver(),Secure.ANDROID_ID);

De comprendre la disposition des Id Uniques dans les appareils Android. Utilisez ce guide officiel.

Les meilleures pratiques pour les identificateurs uniques:

IMEI, les Adresses Mac, Id de l'Instance, Guid, SSAID, la Publicité, l'Id du Filet de Sécurité de l'API pour vérifier les périphériques.

https://developer.android.com/training/articles/user-data-ids

Google ID d'Instance

Publié au I/O 2015; sur Android nécessite jouer à des services 7.5.

https://developers.google.com/instance-id/

https://developers.google.com/instance-id/guides/android-implementation

InstanceID iid = InstanceID.getInstance( context );   //Google docs are wrong - this requires context
String id = iid.getId();  //blocking call

Il semble que Google a l'intention de cet ID doit être utilisée pour identifier les installations sur Android, Chrome et iOS.

Il identifie une installation plutôt que d'un appareil, mais là encore, ANDROID_ID (qui est la réponse) maintenant n'est plus possible d'identifier des appareils. Avec l'ARC d'exécution d'un nouveau ANDROID_ID est généré pour chaque installation (les détails ici), tout comme cette nouvelle ID d'instance. Aussi, je pense que l'identification des installations (périphériques) est ce que la plupart d'entre nous sont en fait la recherche pour.

Les avantages de l'ID d'instance

Il me semble que Google a l'intention de les utiliser aux fins de l'identification de vos installations), il est multi-plateforme, et peut être utilisé pour un certain nombre d'autres fins (voir les liens ci-dessus).

Si vous utilisez GCM, ensuite vous serez amené à utiliser l'ID de cette instance, parce que vous en avez besoin afin d'obtenir le GCM jeton (qui remplace l'ancien GCM numéro d'inscription).

Les inconvénients/questions

Dans l'implémentation actuelle (GPS 7.5) l'ID d'instance est récupéré à partir d'un serveur que si votre application le demande. Cela signifie que l'appel ci-dessus est un appel de blocage - dans mon non scientifique des tests, il prend de 1 à 3 secondes si l'appareil est en ligne, et de 0,5 - 1,0 secondes si hors-ligne (sans doute c'est le temps d'attente avant d'abandonner et de générer un ID aléatoire). Cela a été testé en Amérique du Nord sur le Nexus 5 avec Android 5.1.1 et GPS 7.5.

Si vous utilisez l'ID de l'application qu'ils ont l'intention - eg. l'authentification d'application, application d'identification, GCM - je pense que cette 1-3 secondes peuvent être une nuisance (en fonction de votre application, bien sûr).

Google a maintenant un La publicité ID.

Cela peut aussi être utilisé, mais note que :

La publicité de l'ID de l'utilisateur, qui est spécifique, unique, programmable ID

et

permet aux utilisateurs de réinitialiser leur identifiant ou de retirer annonces par centres d'intérêt dans les applications de Google Play.

Donc bien que cet id peut changer, il semble que bientôt nous ne pouvons pas avoir un choix, dépend de la finalité de cet id.

Plus d'infos @ develper.android

Copier-coller le code ici

HTH

Pas recommandé deviceId peut être utilisé que pour le suivi dans la 3ème partie les mains, mais c'est une autre façon.

@SuppressLint("HardwareIds")
private String getDeviceID() {
deviceId = Settings.Secure.getString(getApplicationContext().getContentResolver(),
Settings.Secure.ANDROID_ID);
return deviceId;
}

J'ai trouvé cette question il y a plusieurs années, et ont appris à mettre en œuvre généralisée de la solution basée sur des réponses très diverses.

J'ai utilisé la solution généralisée depuis plusieurs années, dans le monde réel du produit. Il me sert très bien jusqu'à présent. Voici l'extrait de code, basé sur diverses réponses apportées.

Note, getEmail renvoie la valeur null, la plupart du temps, que nous n'avons pas demandé la permission explicite.

private static UniqueId getUniqueId() {
MyApplication app = MyApplication.instance();
//Our prefered method of obtaining unique id in the following order.
//(1) Advertising id
//(2) Email
//(2) ANDROID_ID
//(3) Instance ID - new id value, when reinstall the app.
////////////////////////////////////////////////////////////////////////////////////////////
//ADVERTISING ID
////////////////////////////////////////////////////////////////////////////////////////////
AdvertisingIdClient.Info adInfo = null;
try {
adInfo = AdvertisingIdClient.getAdvertisingIdInfo(app);
} catch (IOException e) {
Log.e(TAG, "", e);
} catch (GooglePlayServicesNotAvailableException e) {
Log.e(TAG, "", e);
} catch (GooglePlayServicesRepairableException e) {
Log.e(TAG, "", e);
}
if (adInfo != null) {
String aid = adInfo.getId();
if (!Utils.isNullOrEmpty(aid)) {
return UniqueId.newInstance(aid, UniqueId.Type.aid);
}
}
////////////////////////////////////////////////////////////////////////////////////////////
//EMAIL
////////////////////////////////////////////////////////////////////////////////////////////
final String email = Utils.getEmail();
if (!Utils.isNullOrEmpty(email)) {
return UniqueId.newInstance(email, UniqueId.Type.eid);
}
////////////////////////////////////////////////////////////////////////////////////////////
//ANDROID ID
////////////////////////////////////////////////////////////////////////////////////////////
final String sid = Settings.Secure.getString(app.getContentResolver(), Settings.Secure.ANDROID_ID);
if (!Utils.isNullOrEmpty(sid)) {
return UniqueId.newInstance(sid, UniqueId.Type.sid);
}
////////////////////////////////////////////////////////////////////////////////////////////
//INSTANCE ID
////////////////////////////////////////////////////////////////////////////////////////////
final String iid = com.google.android.gms.iid.InstanceID.getInstance(MyApplication.instance()).getId();
if (!Utils.isNullOrEmpty(iid)) {
return UniqueId.newInstance(iid, UniqueId.Type.iid);
}
return null;
}
public final class UniqueId implements Parcelable {
public enum Type implements Parcelable {
aid,
sid,
iid,
eid;
////////////////////////////////////////////////////////////////////////////
//Handling Parcelable nicely.
public static final Parcelable.Creator<Type> CREATOR = new Parcelable.Creator<Type>() {
public Type createFromParcel(Parcel in) {
return Type.valueOf(in.readString());
}
public Type[] newArray(int size) {
return new Type[size];
}
};
@Override
public int describeContents() {
return 0;
}
@Override
public void writeToParcel(Parcel parcel, int flags) {
parcel.writeString(this.name());
}
//Handling Parcelable nicely.
////////////////////////////////////////////////////////////////////////////
}
public static boolean isValid(UniqueId uniqueId) {
if (uniqueId == null) {
return false;
}
return uniqueId.isValid();
}
private boolean isValid() {
return !org.yccheok.jstock.gui.Utils.isNullOrEmpty(id) && type != null;
}
private UniqueId(String id, Type type) {
if (org.yccheok.jstock.gui.Utils.isNullOrEmpty(id) || type == null) {
throw new java.lang.IllegalArgumentException();
}
this.id = id;
this.type = type;
}
public static UniqueId newInstance(String id, Type type) {
return new UniqueId(id, type);
}
@Override
public int hashCode() {
int result = 17;
result = 31 * result + id.hashCode();
result = 31 * result + type.hashCode();
return result;
}
@Override
public boolean equals(Object o) {
if (o == this) {
return true;
}
if (!(o instanceof UniqueId)) {
return false;
}
UniqueId uniqueId = (UniqueId)o;
return this.id.equals(uniqueId.id) && this.type == uniqueId.type;
}
@Override
public String toString() {
return type + ":" + id;
}
////////////////////////////////////////////////////////////////////////////
//Handling Parcelable nicely.
public static final Parcelable.Creator<UniqueId> CREATOR = new Parcelable.Creator<UniqueId>() {
public UniqueId createFromParcel(Parcel in) {
return new UniqueId(in);
}
public UniqueId[] newArray(int size) {
return new UniqueId[size];
}
};
private UniqueId(Parcel in) {
this.id = in.readString();
this.type = in.readParcelable(Type.class.getClassLoader());
}
@Override
public int describeContents() {
return 0;
}
@Override
public void writeToParcel(Parcel parcel, int flags) {
parcel.writeString(this.id);
parcel.writeParcelable(this.type, 0);
}
//Handling Parcelable nicely.
////////////////////////////////////////////////////////////////////////////
public final String id;
public final Type type;
}
public static String getEmail() {
Pattern emailPattern = Patterns.EMAIL_ADDRESS; //API level 8+
AccountManager accountManager = AccountManager.get(MyApplication.instance());
Account[] accounts = accountManager.getAccountsByType("com.google");
for (Account account : accounts) {
if (emailPattern.matcher(account.name).matches()) {
String possibleEmail = account.name;
return possibleEmail;
}
}
accounts = accountManager.getAccounts();
for (Account account : accounts) {
if (emailPattern.matcher(account.name).matches()) {
String possibleEmail = account.name;
return possibleEmail;
}
}
return null;
} 

Juste un heads-up pour tout le monde la lecture de la recherche pour des informations plus à jour. Avec Android O il y a quelques changements à la façon dont le système gère ces identifiants.

https://android-developers.googleblog.com/2017/04/changes-to-device-identifiers-in.html

tl;dr de Série exigera de TÉLÉPHONE d'autorisation et Android ID va changer pour différentes applications basées sur leur emballage, le nom et la signature.

Et aussi Google a mis en place un beau document qui fournit des suggestions sur l'utilisation du matériel et des logiciels ids.

https://developer.android.com/training/articles/user-data-ids.html

String SERIAL_NUMER = Build.SERIAL;

Renvoie le NUMÉRO de SÉRIE d'une chaîne unique à chaque périphérique.

Si vous ajoutez: 

Settings.Secure.getString(context.contentResolver,
Settings.Secure.ANDROID_ID)

Android Peluches vous donnera l'avertissement suivant:

À l'aide de getString pour obtenir les identifiants des appareils n'est pas recommandé.
Inspection info: à l'Aide de ces identifiants des appareils n'est pas recommandé
autres que de haute valeur et de prévention de la fraude et des avancées de téléphonie
cas d'utilisation. Pour la publicité de cas d'utilisation, l'utilisation
AdvertisingIdClient$Info#getId et pour l'analyse, l'utilisation
InstanceId#getId.

Donc, vous devez éviter l'utilisation de ce.

Comme mentionné dans Développeur Android documentation :

1: Éviter l'utilisation de matériel identifiants.

Dans la plupart des cas, vous pouvez éviter d'utiliser du matériel identifiants, tels que SSAID (Android ID) et IMEI,
sans limiter la fonctionnalité requise.

2: utiliser Uniquement une Publicité ID pour établir le profil des utilisateurs ou des annonces des cas d'utilisation.

Lors de l'utilisation d'une Publicité ID, toujours à l'égard des utilisateurs des sélections
concernant le suivi de la publicité. Aussi, s'assurer que l'identifiant ne peut pas être
connecté à des informations personnelles identifiables (PII), et d'éviter
de transition de la Publicité ID réinitialise.

3: Utilisation d'un ID d'Instance ou une société privée stockée GUID chaque fois que possible pour tous les autres cas d'utilisation, sauf pour le paiement de prévention de la fraude et de la téléphonie.

Pour la grande majorité des non-annonces des cas d'utilisation, un ID d'Instance
ou GUID doit être suffisante.

4: Utilisation des Api qui sont appropriés à votre cas d'utilisation afin de minimiser les risques pour la vie privée.

Utiliser l'API DRM pour la haute valeur de protection du contenu et de
le SafetyNet Api pour abus de protection. Le SafetyNet Api sont la
façon la plus simple pour déterminer si un périphérique est authentique, sans encourir
risques pour la vie privée.

android.telephony.TelephonyManager.getDeviceId()

Ce sera de retour quelle que soit la chaîne qui identifie l'appareil (IMEI sur GSM, MEID pour CDMA).

Vous aurez besoin de l'autorisation suivante dans votre AndroidManifest.xml:

<uses-permission android:name="android.permission.READ_PHONE_STATE" />

Pour être complet, voici comment vous pouvez obtenir le Id dans Xamarin.Android et C#:

var id = Settings.Secure.GetString(ContentResolver, Settings.Secure.AndroidId);

Ou si vous n'êtes pas dans un Activity:

var id = Settings.Secure.GetString(context.ContentResolver, Settings.Secure.AndroidId);

Où context est le passé dans le contexte.

Vérifier
SystemInfo.deviceUniqueIdentifier

De la Documentation:
http://docs.unity3d.com/Documentation/ScriptReference/SystemInfo-deviceUniqueIdentifier.html

Identifiant unique de l'appareil. Il est unique pour chaque appareil (en Lecture Seule).

iOS: sur la pré-iOS7 appareils, il sera de retour hash de l'adresse MAC. Sur iOS7 appareils il sera UIDevice identifierForVendor ou, si cela échoue pour une raison quelconque, ASIdentifierManager advertisingIdentifier.