mise à jour : comme des versions récentes D'Android, beaucoup de problèmes avec ANDROID_ID ont été résolus, et je crois que cette approche n'est plus nécessaire. S'il vous plaît jeter un oeil à réponse D'Anthony .

divulgation complète: mon application a utilisé l'approche ci-dessous à l'origine, mais n'utilise plus cette approche, et nous utilisons maintenant l'approche décrite dans le Android Developer Blog entrée qui emmby la réponse de liens vers d' (à savoir, la production et l'enregistrement d'un UUID#randomUUID() ).

il y a beaucoup de réponses à cette question, dont la plupart ne fonctionneront "qu'une partie" du temps, et malheureusement ce n'est pas suffisant.

basé sur mes tests d'appareils (tous les téléphones, dont au moins un n'est pas activé):

1. tous les dispositifs testés retourné une valeur pour TelephonyManager.getDeviceId()
2. tous les dispositifs GSM (tous testés avec un SIM) ont retourné une valeur pour TelephonyManager.getSimSerialNumber()
3. tous les dispositifs CDMA retournés null pour getSimSerialNumber() (comme prévu)
4. tous les appareils avec un compte Google ajouté retourné une valeur pour ANDROID_ID
5. tous les dispositifs CDMA retournés la même valeur (ou dérivation de la même valeur) pour ANDROID_ID et TelephonyManager.getDeviceId() -- que tant que un compte Google a été ajouté pendant la configuration.
6. Je n'ai pas encore eu la chance de tester des appareils GSM sans SIM, un appareil GSM sans compte Google ajouté, ou l'un des appareils en mode avion.

donc si vous voulez quelque chose d'unique à l'appareil lui-même, TM.getDeviceId() devrait être suffisant. Évidemment, certains utilisateurs sont plus paranoïaques que d'autres, il pourrait donc être utile de ces identificateurs, de sorte que la chaîne est encore pratiquement unique à l'appareil, mais n'identifie pas explicitement l'appareil réel de l'utilisateur. Par exemple, en utilisant String.hashCode() , combiné avec un UUID:

final TelephonyManager tm = (TelephonyManager) getBaseContext().getSystemService(Context.TELEPHONY_SERVICE);

final String tmDevice, tmSerial, androidId;
tmDevice = "" + tm.getDeviceId();
tmSerial = "" + tm.getSimSerialNumber();
androidId = "" + android.provider.Settings.Secure.getString(getContentResolver(), android.provider.Settings.Secure.ANDROID_ID);

UUID deviceUuid = new UUID(androidId.hashCode(), ((long)tmDevice.hashCode() << 32) | tmSerial.hashCode());
String deviceId = deviceUuid.toString();

pourrait résulter en quelque chose comme: 00000000-54b3-e7c7-0000-000046bffd97

ça marche assez bien pour moi.

comme Richard le mentionne ci-dessous, n'oubliez pas que vous avez besoin d'une permission pour lire les propriétés TelephonyManager , alors ajoutez ceci à votre manifeste:

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

importer des libs

import android.content.Context;
import android.telephony.TelephonyManager;
import android.view.View;

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

" après avoir lu tous les messages de débordement de pile sur la création d'un ID unique, le blog Google developer et la documentation Android, je me sens comme si le 'Pseudo ID' est la meilleure option possible.

question principale: Matériel vs logiciel

Matériel

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

Logiciel

• les utilisateurs peuvent effacer / modifier leur ROM s'ils sont enracinés
• vous pouvez suivre les utilisateurs à travers les plates-formes (iOS, Android, Windows et Web)
• Le meilleur que vous voulez SUIVI d'UN INDIVIDU L'utilisateur avec leur consentement est de simplement leur faire se connecter (faire ce sans couture en utilisant OAuth)

ventilation générale avec Android

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

- pas de permissions supplémentaires

code Psuedo:

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

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

else

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

grâce à @stansult pour afficher toutes nos options (dans cette question de débordement de pile).

Liste d'options - les raisons/ pourquoi ne pas les utiliser:

• Email De L'Utilisateur-Logiciel

  • L'utilisateur pourrait changer de courriel - très peu probable
  • API 5+ <uses-permission android:name="android.permission.GET_ACCOUNTS" /> or
  • API 14+ <uses-permission android:name="android.permission.READ_PROFILE" /> <uses-permission android:name="android.permission.READ_CONTACTS" /> ( comment obtenir l'adresse e-mail principale de l'appareil Android )

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

  • les utilisateurs pourraient changer de numéro de téléphone - très peu probable
  • <uses-permission android:name="android.permission.READ_PHONE_STATE" />

• IMEI - Hardware (seulement téléphones, besoins android.permission.READ_PHONE_STATE )

  • la plupart des utilisateurs détestent le fait qu'il est dit" appels téléphoniques " dans la permission. Certains utilisateurs donnent de mauvaises évaluations, parce qu'ils croient que vous êtes simplement en train de voler leurs informations personnelles, alors que tout ce que vous voulez vraiment faire est de pister les installations de périphériques. Il est évident que vous collectez des données.
  • <uses-permission android:name="android.permission.READ_PHONE_STATE" />

• Android ID-Hardware (peut être nul, peut changer à la réinitialisation de l'usine, peut être modifié sur un appareil enraciné)

  • , Car il peut être 'null', nous pouvons vérifier pour 'null', et changer sa valeur, mais cela signifie qu'il n'est plus unique.
  • si vous avez un utilisateur avec un périphérique de réinitialisation d'usine, la valeur peut avoir changé ou modifié sur le périphérique enraciné de sorte qu'il peut y avoir des entrées en double si vous suivez les installations de l'utilisateur.

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

  • cela pourrait être la deuxième meilleure option, mais vous êtes toujours en train de collecter et de stocker un identifiant unique qui vient directement d'un utilisateur. C'est évident que vous collectez des données.
  • <uses-permission android:name="android.permission.ACCESS_WIFI_STATE "/>

• Bluetooth MAC Address-Hardware (appareils avec Bluetooth, besoins android.permission.BLUETOOTH )

  • la plupart des applications sur le marché n'utilisent pas Bluetooth, et donc si votre application n'utilise pas Bluetooth et que vous incluez cela, l'utilisateur pourrait devenir suspect.
  • <uses-permission android:name="android.permission.BLUETOOTH "/>

• Pseudo - unique ID-Software (pour tous les appareils Android)

  • très possible, peut contenir des collisions - voir ma méthode postée ci-dessous!
  • cela vous permet d'avoir un ID 'presque unique' de l'utilisateur sans rien prendre qui est privé. Vous pouvez créer votre propre ID anonyme à partir des informations de l'appareil.

je sais qu'il n'y en a 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. Lorsqu'il s'agit de créer un ID unique, nous pouvons créer un "pseudo id unique" basé uniquement sur des informations que L'API Android nous donne sans utiliser de permissions 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 ne rencontrez vraiment le fait qu'il peut être des doublons basée sur le fait qu'il existe des dispositifs similaires. Vous pouvez modifier la méthode combinée pour la rendre plus unique; cependant, certains développeurs ont besoin de suivre les installations de périphériques et cela fera l'affaire ou la performance basée sur des dispositifs similaires.

API >= 9:

si leur appareil Android est API 9 ou plus, cela est garanti d'être unique en raison de la 'construire.Champ série.

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

API < 9:

si L'appareil Android de l'utilisateur est inférieur à API 9; si tout va bien, ils n'ont pas fait une réinitialisation d'usine et leur 'Sécurisé.ANDROID_ID' sera préservé ou pas'null'. (voir http://developer.android.com/about/dashboards/index.html )

si tout le reste échoue:

si tout le reste échoue, si l'utilisateur A inférieur à API 9 (inférieur à Gingerbread), a réinitialisé leur appareil ou " Sécurisé.ANDROID_ID 'retourne ' null', alors simplement L'ID retourné sera uniquement basé sur les informations de leur périphérique Android. C'est là que les collisions peuvent se produire.

Changements:

• Enlevé " Android.SECURE_ID ' à cause des réinitialisations d'usine pourrait causer la valeur changement
• a modifié le code pour changer sur API
• a changé le Pseudo

s'il vous Plaît prendre un coup d'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):

de la console de développement de Google Play:

à partir du 1er août 2014, le Politique Du Programme De Développeurs Google Play nécessite tous les nouveaux téléchargements et mises à jour d'applications pour utiliser l'ID de la publicité dans lieu de tout autre identificateur persistant à des fins publicitaires. En savoir plus

mise en Œuvre :

Permission:

<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 carte d'identité publicitaire remplace complètement les utilisation d'autres identificateurs à des fins publicitaires (comme L'utilisation D'ANDROID_ID) dans les Paramètres.Sécurisé) lorsque les Services Google Play est disponible. Cas lorsque les services Google Play ne sont pas disponibles sont indiqués par un Googleplayservicesnontavailableexception lancé 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 à chaque lien que j'ai pris des informations. Si vous êtes absent et doivent être inclus, s'il vous plaît commentaire!

Google Player Services InstanceID

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

comme Dave Webb le mentionne, le Android Developer Blog a un article qui couvre ceci. Leur solution préférée est de pister les installations app plutôt que les appareils, et cela fonctionnera bien pour la plupart des cas d'utilisation. Le blog sera de vous montrer le code nécessaire pour faire ce travail, et je vous recommande de vérifier it out.

cependant, le blog continue à discuter des solutions si vous avez besoin d'un identifiant de périphérique plutôt que d'un identifiant d'installation d'application. Je j'ai parlé à Quelqu'un de Google pour obtenir des éclaircissements supplémentaires sur quelques éléments dans le cas où vous devez le faire. Voici ce que j'ai découvert au sujet des identificateurs de périphérique qui n'est pas mentionné dans l'article de blog susmentionné:

• ANDROID_ID est l'Identificateur de périphérique préféré. ANDROID_ID est parfaitement fiable sur les versions D'Android <=2.1 ou >=2.3. Seulement 2,2 a les problèmes mentionnés dans le post.
• plusieurs dispositifs par plusieurs les fabricants sont affectés par le bogue ANDROID_ID de la section 2.2.
• d'après ce que j'ai pu déterminer, tous les appareils affectés ont le même ANDROID_ID , qui est 9774d56d682e549c . Qui est aussi le même ID de périphérique rapporté par l'émulateur, btw.
• Google estime que les OEM ont corrigé la question pour beaucoup ou la plupart de leurs appareils, mais j'ai été en mesure de vérifier qu'à partir de début avril 2011, à au moins, il est encore assez facile de trouver des périphériques qui ont l'ANDROID_ID cassé.

sur la base des recommandations de Google, j'ai mis en œuvre une classe qui va générer un UUID unique pour chaque périphérique, en utilisant ANDROID_ID comme la graine le cas échéant, en retombant sur TelephonyManager.getDeviceId () si nécessaire, et si cela échoue, en recourant à un UUID unique généré au hasard qui est persistant dans tous les redémarrages d'applications (mais pas les ré-installations d'applications).

Notez que pour les appareils qui doivent se retirer de l'ID de l'appareil, l'ID unique va persister à travers les réinitialisations d'usine. C'est quelque chose d'être conscient de. Si vous avez besoin de vous assurer qu'une réinitialisation d'usine va réinitialiser votre ID unique, vous pouvez envisager de retomber directement sur l'UUID aléatoire au lieu de l'ID de périphérique.

encore une fois, ce code est pour un ID de périphérique, pas un ID d'installation d'application. Pour la plupart des situations, un ID d'installation d'application est probablement ce que vous êtes à la recherche pour. Mais si vous avez besoin d'un ID de périphérique, alors le code suivant fonctionnera probablement pour vous.

import android.content.Context;
import android.content.SharedPreferences;
import android.provider.Settings.Secure;
import android.telephony.TelephonyManager;

import java.io.UnsupportedEncodingException;
import java.util.UUID;

public class DeviceUuidFactory {

    protected static final String PREFS_FILE = "device_id.xml";
    protected static final String PREFS_DEVICE_ID = "device_id";
    protected volatile static UUID uuid;

    public DeviceUuidFactory(Context context) {
        if (uuid == null) {
            synchronized (DeviceUuidFactory.class) {
                if (uuid == null) {
                    final SharedPreferences prefs = context
                            .getSharedPreferences(PREFS_FILE, 0);
                    final String id = prefs.getString(PREFS_DEVICE_ID, null);
                    if (id != null) {
                        // Use the ids previously computed and stored in the
                        // prefs file
                        uuid = UUID.fromString(id);
                    } else {
                        final String androidId = Secure.getString(
                            context.getContentResolver(), Secure.ANDROID_ID);
                        // Use the Android ID unless it's broken, in which case
                        // fallback on deviceId,
                        // unless it's not available, then fallback on a random
                        // number which we store to a prefs file
                        try {
                            if (!"9774d56d682e549c".equals(androidId)) {
                                uuid = UUID.nameUUIDFromBytes(androidId
                                        .getBytes("utf8"));
                            } else {
                                final String deviceId = (
                                    (TelephonyManager) context
                                    .getSystemService(Context.TELEPHONY_SERVICE))
                                    .getDeviceId();
                                uuid = deviceId != null ? UUID
                                    .nameUUIDFromBytes(deviceId
                                            .getBytes("utf8")) : UUID
                                    .randomUUID();
                            }
                        } catch (UnsupportedEncodingException e) {
                            throw new RuntimeException(e);
                        }
                        // Write the value out to the prefs file
                        prefs.edit()
                                .putString(PREFS_DEVICE_ID, uuid.toString())
                                .commit();
                    }
                }
            }
        }
    }

    /**
     * Returns a unique UUID for the current android device. As with all UUIDs,
     * this unique ID is "very highly likely" to be unique across all Android
     * devices. Much more so than ANDROID_ID is.
     * 
     * The UUID is generated by using ANDROID_ID as the base key if appropriate,
     * falling back on TelephonyManager.getDeviceID() if ANDROID_ID is known to
     * be incorrect, and finally falling back on a random UUID that's persisted
     * to SharedPreferences if getDeviceID() does not return a usable value.
     * 
     * In some rare circumstances, this ID may change. In particular, if the
     * device is factory reset a new device ID may be generated. In addition, if
     * a user upgrades their phone from certain buggy implementations of Android
     * 2.2 to a newer, non-buggy version of Android, the device ID may change.
     * Or, if a user uninstalls your app on a device that has neither a proper
     * Android ID nor a Device ID, this ID may change on reinstallation.
     * 
     * Note that if the code falls back on using TelephonyManager.getDeviceId(),
     * the resulting ID will NOT change after a factory reset. Something to be
     * aware of.
     * 
     * Works around a bug in Android 2.2 for many devices when using ANDROID_ID
     * directly.
     * 
     * @see http://code.google.com/p/android/issues/detail?id=10603
     * 
     * @return a UUID that may be used to uniquely identify your device for most
     *         purposes.
     */
    public UUID getDeviceUuid() {
        return uuid;
    }
}

voici le code que Reto Meier utilisé dans la présentation Google I/O 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 au nuage (également décrit dans Reto talk , vous devriez avoir un id qui se lie à un utilisateur et reste autour après que le périphérique a été essuyé, ou même remplacé. Je prévois d'utiliser ceci dans l'analyse à l'avenir (dans d'autres les mots, je n'ai pas fait que peu encore :).

vous pouvez également considérer L'adresse MAC de L'adaptateur Wi-Fi. Récupéré thusly:

WifiManager wm = (WifiManager)Ctxt.getSystemService(Context.WIFI_SERVICE);
return wm.getConnectionInfo().getMacAddress();

nécessite la permission android.permission.ACCESS_WIFI_STATE dans le manifeste.

disponible même sans connexion Wi-Fi. Si Joe de la réponse ci-dessus donne l'essayer sur son, de nombreux appareils, ce serait sympa.

sur certains appareils, il n'est pas disponible lorsque le Wi-Fi est éteint.

NOTE: D'Android 6.x, il renvoie l'adresse de faux mac cohérente: 02:00:00:00:00:00

il y a des informations plutôt utiles ici .

il couvre cinq types D'identification différents:

1. IMEI (seulement pour appareils Android avec Utilisation du téléphone; besoins android.permission.READ_PHONE_STATE )
2. Pseudo-Unique ID (pour tous les appareils Android)
3. Android ID (peut être null, peut changer à l'usine réinitialiser, peut être modifié sur téléphone enracinée)
4. Adresse MAC WLAN string (besoins android.permission.ACCESS_WIFI_STATE )
5. BT Adresse MAC string (appareils avec Bluetooth, les besoins android.permission.BLUETOOTH )

le Blog officiel des Développeurs Android a maintenant un article complet juste à propos de ce sujet, Identifying App Installations .

At Google I/O Reto Meier publié une réponse robuste à la façon d'aborder ce qui devrait répondre à la plupart des besoins des développeurs pour suivre les utilisateurs à travers les 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 vous donnera un identifiant d'utilisateur anonyme et sécurisé qui sera persistant pour l'utilisateur sur différents appareils (sur la base du compte Google primaire) et à travers les installations. L'approche de base est de générer un identifiant d'utilisateur aléatoire et de le stocker dans les préférences partagées des applications. Vous utilisez ensuite l'agent de sauvegarde de Google pour stocker les préférences partagées liées au compte Google dans le cloud.

passons à l'approche complète. Tout d'abord, nous avons besoin de créer une sauvegarde pour nos références partagées en utilisant le service de sauvegarde Android. Commencez par enregistrer votre application via http://developer.android.com/google/backup/signup.html .

Google vous donnera une clé de service de sauvegarde que vous devez ajouter au manifeste. Vous devez également dire à l'application d'utiliser le 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>

ensuite, vous devez créer l'agent de sauvegarde et lui dire d'utiliser l'agent helper pour 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 compléter la sauvegarde dont vous avez besoin pour créer une instance de BackupManager dans votre activité principale:

BackupManager backupManager = new BackupManager(context);

enfin créer un identifiant utilisateur, s'il n'existe pas déjà, et le stocker dans les références partagées:

  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;
}

cet User_ID sera maintenant persistant dans toutes les installations, même si l'utilisateur déplace le périphérique.

pour plus d'information sur cette approche, voir reto's talk .

et pour tous les détails sur la façon de mettre en œuvre l'agent de sauvegarde voir sauvegarde de données . Je recommande particulièrement la section en bas sur testing car la sauvegarde ne se produit pas instantanément et donc pour tester vous devez forcer la sauvegarde.

le code suivant renvoie le numéro de série du périphérique à l'aide d'une API Android cachée. Mais, ce code ne fonctionne pas sur Samsung Galaxy onglet parce que " ro.serialno" n'est pas installé 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) {

}

je pense que c'est une façon sûre de construire un squelette pour une identification unique... check it out.

Pseudo-ID Unique, qui fonctionne sur tous les appareils Android Certains appareils n'ont pas de téléphone (p. ex. Comprimés) ou pour une raison quelconque, vous ne voulez pas inclure la permission READ_PHONE_STATE. Vous pouvez toujours lire des détails comme la Version ROM, le nom du fabricant, le type de CPU, et d'autres détails du matériel, qui sera bien adapté si vous voulez utiliser L'ID pour une vérification de clé série, ou d'autres but. L'ID calculé de cette façon ne sera pas unique: il est possible de trouver deux appareils avec le même ID (basé sur le même matériel et la même image ROM) mais les changements dans les applications du monde réel sont négligeables. Pour cela, vous pouvez utiliser la classe Build:

String m_szDevIDShort = "35" + //we make this look like a valid IMEI
            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 ; //13 digits

la plupart des membres de construction sont des chaînes, ce que nous faisons ici est de prendre leur longueur et la transformer via modulo dans un chiffre. Nous avons 13 de ces chiffres, et nous ajoutons deux autres à l'avant (35) ID de même taille que L'IMEI (15 chiffres). Il ya d'autres possibilités ici sont bien, il suffit de jeter un oeil à ces ficelles. Renvoie quelque chose comme 355715565309247 . Aucune autorisation spéciale est nécessaire, ce qui rend cette approche très pratique.

(informations supplémentaires: la technique donnée ci-dessus a été copiée d'un article sur Pocket Magic .)

en utilisant le code ci-dessous, vous pouvez obtenir l'ID de périphérique unique d'un appareil OS Android comme une chaîne de caractères.

deviceId = Secure.getString(getApplicationContext().getContentResolver(), Secure.ANDROID_ID); 

A Serial field a été ajouté à la classe Build dans le niveau 9 de L'API (Android 2.3 - Gingerbread). La Documentation dit qu'il représente le numéro de série du matériel. Ainsi, il devrait être unique, s'il existe sur l'appareil.

Je ne sais pas si elle est réellement supportée (=pas nulle) par tous les périphériques avec un niveau D'API >= 9 cependant.

une chose que j'ajouterai - j'ai une de ces situations uniques.

utilisant:

deviceId = Secure.getString(this.getContext().getContentResolver(), Secure.ANDROID_ID);

S'avère que même si ma tablette G Viewsonic rapporte un DeviceID qui n'est pas nul, chaque tablette g rapporte le même nombre.

rend intéressant jouer à" Pocket Empires "qui vous donne un accès instantané au compte de quelqu'un basé sur le DeviceID" unique".

mon appareil n'a pas de cellule radio.

pour des instructions détaillées sur la façon d'obtenir un identifiant unique pour chaque appareil Android à partir de laquelle votre application est installée, voir le Blog officiel des Développeurs Android identifier les Installations App .

il semble que la meilleure façon est pour vous de générer vous-même une lors de l'installation et par la suite Lire lorsque l'application est relancé.

personnellement je trouve cela acceptable mais pas l'idéal. Aucun identifiant fourni par Android ne fonctionne dans tous les cas car la plupart dépendent des États radio du téléphone (Wi-Fi on/off, 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 d'être unique.

ce qui suit est un exemple d'écriture de données à un installation fichier qui serait stocké avec toute autre donnée que 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();
    }
}

ajouter le code ci-dessous dans le fichier de classe:

final TelephonyManager tm = (TelephonyManager) getBaseContext()
            .getSystemService(SplashActivity.TELEPHONY_SERVICE);
    final String tmDevice, tmSerial, androidId;
    tmDevice = "" + tm.getDeviceId();
    Log.v("DeviceIMEI", "" + tmDevice);
    tmSerial = "" + tm.getSimSerialNumber();
    Log.v("GSM devices Serial Number[simcard] ", "" + tmSerial);
    androidId = "" + android.provider.Settings.Secure.getString(getContentResolver(),
            android.provider.Settings.Secure.ANDROID_ID);
    Log.v("androidId CDMA devices", "" + androidId);
    UUID deviceUuid = new UUID(androidId.hashCode(),
            ((long) tmDevice.hashCode() << 32) | tmSerial.hashCode());
    String deviceId = deviceUuid.toString();
    Log.v("deviceIdUUID universally unique identifier", "" + deviceId);
    String deviceModelName = android.os.Build.MODEL;
    Log.v("Model Name", "" + deviceModelName);
    String deviceUSER = android.os.Build.USER;
    Log.v("Name USER", "" + deviceUSER);
    String devicePRODUCT = android.os.Build.PRODUCT;
    Log.v("PRODUCT", "" + devicePRODUCT);
    String deviceHARDWARE = android.os.Build.HARDWARE;
    Log.v("HARDWARE", "" + deviceHARDWARE);
    String deviceBRAND = android.os.Build.BRAND;
    Log.v("BRAND", "" + deviceBRAND);
    String myVersion = android.os.Build.VERSION.RELEASE;
    Log.v("VERSION.RELEASE", "" + myVersion);
    int sdkVersion = android.os.Build.VERSION.SDK_INT;
    Log.v("VERSION.SDK_INT", "" + sdkVersion);

ajouter dans AndroidManifest.xml:

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

L'identifiant unique d'un appareil D'OS Android en tant que chaîne, en utilisant TelephonyManager et ANDROID_ID , est obtenu 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 recommande fortement une méthode suggérée par Google, voir identifier les Installations App .

il y a beaucoup d'approches différentes à travailler autour de ces ANDROID_ID questions (peut être null parfois ou les dispositifs d'un modèle spécifique toujours retourner la même ID) avec des avantages et des inconvénients:

• implémentation d'un algorithme personnalisé de génération D'ID (basé sur les propriétés de l'appareil qui sont supposées être statiques et ne changeront pas - > qui sait)
• abusant d'autres IDs comme IMEI , numéro de série, Wi-Fi / Bluetooth-MAC adresse (ILS n'existeront pas sur tous les appareils ou des permissions supplémentaires deviendront nécessaires)

moi-même je préfère utiliser une implémentation OpenUDID existante (voir https://github.com/ylechelle/OpenUDID ) pour Android (voir https://github.com/vieux/OpenUDID ). Il est facile à intégrer et utilise le ANDROID_ID avec des retombées pour les questions mentionnées ci-dessus.

Que pensez-vous du IMEI . Qui est unique pour Android ou d'autres appareils mobiles.

mes deux cents-NB ceci est pour un appareil (err) ID unique - pas l'installation un comme discuté dans le Android developer's blog .

De noter que le solution fourni par @emmby retombe dans un ID d'application comme les SharedPreferences ne sont pas synchronisés sur l'ensemble des processus (voir ici et ici ). J'ai donc complètement évité cela.

au lieu de cela, j'ai encapsulé les différentes stratégies pour obtenir un ID (périphérique) dans un enum - changer l'ordre des constantes d'enum affecte la priorité des différentes façons d'obtenir L'ID. Le premier ID non-null est retourné ou une exception est lancée (selon les bonnes pratiques Java de ne pas donner de sens à null). Ainsi, par exemple, j'ai la téléphonie un premier - mais un bon choix par défaut serait L'ANDROID_ID bêta:

import android.Manifest.permission;
import android.bluetooth.BluetoothAdapter;
import android.content.Context;
import android.content.pm.PackageManager;
import android.net.wifi.WifiManager;
import android.provider.Settings.Secure;
import android.telephony.TelephonyManager;
import android.util.Log;

// TODO : hash
public final class DeviceIdentifier {

    private DeviceIdentifier() {}

    /** @see http://code.google.com/p/android/issues/detail?id=10603 */
    private static final String ANDROID_ID_BUG_MSG = "The device suffers from "
        + "the Android ID bug - its ID is the emulator ID : "
        + IDs.BUGGY_ANDROID_ID;
    private static volatile String uuid; // volatile needed - see EJ item 71
    // need lazy initialization to get a context

    /**
     * Returns a unique identifier for this device. The first (in the order the
     * enums constants as defined in the IDs enum) non null identifier is
     * returned or a DeviceIDException is thrown. A DeviceIDException is also
     * thrown if ignoreBuggyAndroidID is false and the device has the Android ID
     * bug
     *
     * @param ctx
     *            an Android constant (to retrieve system services)
     * @param ignoreBuggyAndroidID
     *            if false, on a device with the android ID bug, the buggy
     *            android ID is not returned instead a DeviceIDException is
     *            thrown
     * @return a *device* ID - null is never returned, instead a
     *         DeviceIDException is thrown
     * @throws DeviceIDException
     *             if none of the enum methods manages to return a device ID
     */
    public static String getDeviceIdentifier(Context ctx,
            boolean ignoreBuggyAndroidID) throws DeviceIDException {
        String result = uuid;
        if (result == null) {
            synchronized (DeviceIdentifier.class) {
                result = uuid;
                if (result == null) {
                    for (IDs id : IDs.values()) {
                        try {
                            result = uuid = id.getId(ctx);
                        } catch (DeviceIDNotUniqueException e) {
                            if (!ignoreBuggyAndroidID)
                                throw new DeviceIDException(e);
                        }
                        if (result != null) return result;
                    }
                    throw new DeviceIDException();
                }
            }
        }
        return result;
    }

    private static enum IDs {
        TELEPHONY_ID {

            @Override
            String getId(Context ctx) {
                // TODO : add a SIM based mechanism ? tm.getSimSerialNumber();
                final TelephonyManager tm = (TelephonyManager) ctx
                        .getSystemService(Context.TELEPHONY_SERVICE);
                if (tm == null) {
                    w("Telephony Manager not available");
                    return null;
                }
                assertPermission(ctx, permission.READ_PHONE_STATE);
                return tm.getDeviceId();
            }
        },
        ANDROID_ID {

            @Override
            String getId(Context ctx) throws DeviceIDException {
                // no permission needed !
                final String andoidId = Secure.getString(
                    ctx.getContentResolver(),
                    android.provider.Settings.Secure.ANDROID_ID);
                if (BUGGY_ANDROID_ID.equals(andoidId)) {
                    e(ANDROID_ID_BUG_MSG);
                    throw new DeviceIDNotUniqueException();
                }
                return andoidId;
            }
        },
        WIFI_MAC {

            @Override
            String getId(Context ctx) {
                WifiManager wm = (WifiManager) ctx
                        .getSystemService(Context.WIFI_SERVICE);
                if (wm == null) {
                    w("Wifi Manager not available");
                    return null;
                }
                assertPermission(ctx, permission.ACCESS_WIFI_STATE); // I guess
                // getMacAddress() has no java doc !!!
                return wm.getConnectionInfo().getMacAddress();
            }
        },
        BLUETOOTH_MAC {

            @Override
            String getId(Context ctx) {
                BluetoothAdapter ba = BluetoothAdapter.getDefaultAdapter();
                if (ba == null) {
                    w("Bluetooth Adapter not available");
                    return null;
                }
                assertPermission(ctx, permission.BLUETOOTH);
                return ba.getAddress();
            }
        }
        // TODO PSEUDO_ID
        // http://www.pocketmagic.net/2011/02/android-unique-device-id/
        ;

        static final String BUGGY_ANDROID_ID = "9774d56d682e549c";
        private final static String TAG = IDs.class.getSimpleName();

        abstract String getId(Context ctx) throws DeviceIDException;

        private static void w(String msg) {
            Log.w(TAG, msg);
        }

        private static void e(String msg) {
            Log.e(TAG, msg);
        }
    }

    private static void assertPermission(Context ctx, String perm) {
        final int checkPermission = ctx.getPackageManager().checkPermission(
            perm, ctx.getPackageName());
        if (checkPermission != PackageManager.PERMISSION_GRANTED) {
            throw new SecurityException("Permission " + perm + " is required");
        }
    }

    // =========================================================================
    // Exceptions
    // =========================================================================
    public static class DeviceIDException extends Exception {

        private static final long serialVersionUID = -8083699995384519417L;
        private static final String NO_ANDROID_ID = "Could not retrieve a "
            + "device ID";

        public DeviceIDException(Throwable throwable) {
            super(NO_ANDROID_ID, throwable);
        }

        public DeviceIDException(String detailMessage) {
            super(detailMessage);
        }

        public DeviceIDException() {
            super(NO_ANDROID_ID);
        }
    }

    public static final class DeviceIDNotUniqueException extends
            DeviceIDException {

        private static final long serialVersionUID = -8940090896069484955L;

        public DeviceIDNotUniqueException() {
            super(ANDROID_ID_BUG_MSG);
        }
    }
}

Voici comment je génère l'id 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 /sys/class/android_usb/android0/iSerial dans une application sans aucune permission.

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 faire cela en Java, il suffit d'utiliser un FileInputStream pour ouvrir le fichier iSerial et lire les caractères. Assurez-vous juste de l'envelopper dans un gestionnaire d'exception, parce que tous les appareils n'ont pas ce fichier.

au moins les dispositifs suivants sont connus pour avoir ce fichier lisible dans le monde:

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

vous pouvez également voir mon billet de blog Leaking Android hardware serial number to unprivileged apps où je discute des autres fichiers disponibles pour information.

pour la reconnaissance matérielle d'un appareil Android spécifique, vous pouvez consulter les adresses MAC.

, vous pouvez le faire de cette façon:

dans AndroidManifest.xml

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

maintenant dans votre code:

List<NetworkInterface> interfacesList = Collections.list(NetworkInterface.getNetworkInterfaces());

for (NetworkInterface interface : interfacesList) {
   // This will give you the interface MAC ADDRESS
   interface.getHardwareAddress();
}

dans chaque appareil Android leur est au moins une Interface "wlan0" sorcière est la puce WI-FI. Ce code fonctionne même lorsque le WI-FI n'est pas activé.

P. S. Ils sont un tas d'autres Interfaces que vous obtiendrez de la liste contenant MACS, mais cela peut changer entre les téléphones.

j'utilise le code suivant pour obtenir le IMEI ou utiliser sécurisé. ANDROID_ID comme alternative, lorsque l'appareil n'a pas de capacité téléphonique:

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);

plus spécifiquement, Settings.Secure.ANDROID_ID . C'est un 64 bits qui est généré et stocké lorsque l'appareil démarre en premier. Il est réinitialisée lorsque l'appareil est effacé.

ANDROID_ID semble un bon choix pour un identificateur d'appareil unique. Il y a des inconvénients: tout d'abord, il n'est pas 100% fiable sur les versions D'Android Avant 2.2 (“Froyo”). aussi, il y a eu au moins un bug largement observé dans un combiné populaire d'un fabricant majeur, où chaque instance a le même ANDROID_ID.

Google ID d'Instance

publié à I / O 2015; sur Android nécessite des services de jeu 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 ait l'intention d'utiliser cette ID pour identifier les installations à travers Android, Chrome et iOS.

il identifie une installation plutôt qu'un périphérique, mais là encore, ANDROID_ID (qui est la réponse acceptée) n'identifie plus les périphériques non plus. Avec L'exécution ARC, un nouveau ANDROID_ID est généré pour chaque installation ( détails ici ), tout comme ce nouvel ID d'instance. En outre, je pense que l'identification des installations (pas des appareils) est ce que la plupart d'entre nous sont réellement à la recherche.

Les avantages de l'instance ID

il me semble que Google entend qu'il soit utilisé à cette fin (identification de vos installations), il est multiplateformes, et peut être utilisé à un certain nombre d'autres fins (voir les liens ci-dessus).

si vous utilisez GCM, vous devrez éventuellement utiliser cet ID d'instance car vous en avez besoin pour obtenir le jeton GCM (qui remplace l'ancien ID d'enregistrement GCM).

Les inconvénients/questions

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

si vous utilisez la carte D'identité aux fins auxquelles elle est destinée, par exemple: authentification d'application, identification d'application, GCM-je pense que cela 1-3 secondes pourrait être une nuisance (selon votre application, bien sûr).

appareil Android mac id un identifiant unique, cela ne va pas changer suppose que si l'on formater le périphérique lui-même donc, en utilisant le code suivant pour obtenir mac id

WifiManager manager = (WifiManager) getSystemService(Context.WIFI_SERVICE);
WifiInfo info = manager.getConnectionInfo();
String address = info.getMacAddress();

N'oubliez pas non plus d'ajouter le permissions approprié dans votre AndroidManifest.xml

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

il y a plus de 30 réponses ici et certaines sont identiques et certaines sont uniques. Cette réponse est fondée sur quelques-unes de ces réponses. L'un d'eux étant la réponse de @Lenn Dolling.

il combine 3 IDs et crée une chaîne hexadécimale à 32 chiffres. Il a très bien fonctionné pour moi.

3 IDs are:

Pseudo-ID - il est généré en fonction des spécifications des dispositifs physiques

ANDROID_ID - Settings.Secure.ANDROID_ID

adresse Bluetooth - adresse de l'adaptateur Bluetooth

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

Note: Vous pouvez toujours ajouter plus d'IDs à la chaîne longId . Par exemple, le numéro de Série. adresse de l'adaptateur wifi. IMEI. De cette façon, vous le rendez plus unique par 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 "";
}

Google a maintenant un publicité ID .

Cela peut aussi être utilisé, mais notez 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 désactiver les annonces basées sur les intérêts dans GooglePlay apps.

donc bien que cette carte puisse changement, il semble que bientôt nous ne pouvons pas avoir un choix , dépend de l'objet de cette id.

Plus d'info @ develper.android

Copier-coller le code ici

HTH

TelephonyManger.getDeviceId () renvoie l'identifiant unique du périphérique, par exemple, L'IMEI pour GSM et le MEID ou ESN pour les téléphones CDMA.

final TelephonyManager mTelephony = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);            
String myAndroidDeviceId = mTelephony.getDeviceId(); 

Mais je recommande d'utiliser:

paramètres.Sécuriser.ANDROID_ID qui renvoie L'ID Android comme une chaîne de caractères hexadécimaux unique de 64 bits.

    String   myAndroidDeviceId = Secure.getString(getApplicationContext().getContentResolver(), Secure.ANDROID_ID); 

Sometimes TelephonyManger.getDeviceId () retournera null, ainsi, pour assurer un id unique, vous utiliserez cette méthode:

public String getUniqueID(){    
    String myAndroidDeviceId = "";
    TelephonyManager mTelephony = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);
    if (mTelephony.getDeviceId() != null){
        myAndroidDeviceId = mTelephony.getDeviceId(); 
    }else{
         myAndroidDeviceId = Secure.getString(getApplicationContext().getContentResolver(), Secure.ANDROID_ID); 
    }
    return myAndroidDeviceId;
}