uniqueidentifier herausfinden device - Gibt es eine eindeutige Android-Geräte-ID?





15 Answers

UPDATE : In den letzten Versionen von Android wurden viele Probleme mit ANDROID_ID behoben, und ich glaube, dass dieser Ansatz nicht länger erforderlich ist. Bitte werfen Sie einen Blick auf die Antwort von Anthony .

Vollständige Offenlegung: Meine App hat ursprünglich den folgenden Ansatz verwendet, verwendet diesen Ansatz jedoch nicht mehr. Wir verwenden jetzt den im android-developers.blogspot.com/2011/03/… Eintrag beschriebenen Ansatz, auf den sich die Antwort von emmby bezieht (nämlich das Generieren und Speichern einer UUID#randomUUID() ).

Es gibt viele Antworten auf diese Frage, von denen die meisten nur "einige" der Zeit funktionieren werden, und das ist leider nicht gut genug.

Basierend auf meinen Gerätetests (alle Telefone, von denen mindestens eines nicht aktiviert ist):

  1. Alle getesteten Geräte haben einen Wert für TelephonyManager.getDeviceId()
  2. Alle GSM-Geräte (alle mit einer SIM-Karte getestet) haben einen Wert für TelephonyManager.getSimSerialNumber()
  3. Alle CDMA-Geräte gaben für getSimSerialNumber() (wie erwartet) Null zurück.
  4. Alle Geräte mit einem hinzugefügten Google-Konto haben einen Wert für ANDROID_ID
  5. Alle CDMA-Geräte haben für ANDROID_ID und TelephonyManager.getDeviceId() denselben Wert (oder dieselbe Ableitung desselben Werts TelephonyManager.getDeviceId() - solange ein Google-Konto während des Setups hinzugefügt wurde.
  6. Ich hatte noch keine Gelegenheit, GSM-Geräte ohne SIM-Karte, ein GSM-Gerät ohne Google-Konto oder eines der Geräte im Flugzeugmodus zu testen.

Wenn Sie also etwas TM.getDeviceId() für das Gerät selbst TM.getDeviceId() , sollte TM.getDeviceId() ausreichend sein. Offensichtlich sind einige Benutzer paranoider als andere. Daher kann es hilfreich sein, 1 oder mehrere dieser Bezeichner zu hashieren, sodass die Zeichenfolge immer noch praktisch eindeutig für das Gerät ist, das tatsächliche Gerät des Benutzers jedoch nicht explizit identifiziert. Verwenden Sie beispielsweise String.hashCode() in Kombination mit einer 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();

könnte zu etwas führen wie: 00000000-54b3-e7c7-0000-000046bffd97

Es funktioniert gut genug für mich.

Vergessen Sie nicht, wie Richard unten erwähnt, dass Sie die Berechtigung zum Lesen der TelephonyManager Eigenschaften benötigen. Fügen Sie dies Ihrem Manifest hinzu:

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

libs importieren

import android.content.Context;
import android.telephony.TelephonyManager;
import android.view.View;
ändern generator programmatically

Verfügen Android-Geräte über eine eindeutige ID, und wenn ja, wie kann man sie auf einfache Weise mit Java erreichen?




Wie Dave Webb erwähnt, gibt es im Android Developer Blog einen Artikel , der dies behandelt. Ihre bevorzugte Lösung ist das Verfolgen von App-Installationen anstelle von Geräten. Dies funktioniert in den meisten Anwendungsfällen gut. Der Blogbeitrag zeigt Ihnen den erforderlichen Code, damit dies funktioniert, und ich empfehle Ihnen, es auszuprobieren.

Im Blogbeitrag werden jedoch Lösungen beschrieben, wenn Sie eine Geräte-ID anstelle einer App-Installations-ID benötigen. Ich habe mit jemandem bei Google gesprochen, um einige zusätzliche Informationen zu erhalten, falls Sie dies benötigen. Folgendes habe ich über Gerätekennungen herausgefunden, das im oben genannten Blog-Post NICHT erwähnt wird:

  • ANDROID_ID ist die bevorzugte Gerätekennung. ANDROID_ID ist auf Android-Versionen <= 2.1 oder> = 2.3 absolut zuverlässig. Nur 2.2 hat die in der Post erwähnten Probleme.
  • Mehrere Geräte mehrerer Hersteller sind von dem ANDROID_ID-Fehler in 2.2 betroffen.
  • Soweit ich feststellen konnte, haben alle betroffenen Geräte die gleiche ANDROID_ID , die 9774d56d682e549c . Dies ist auch die gleiche Geräte-ID, die vom Emulator gemeldet wird, übrigens.
  • Google glaubt, dass OEMs das Problem für viele oder die meisten ihrer Geräte behoben haben. Ich konnte jedoch feststellen, dass es zumindest Anfang April 2011 immer noch recht einfach ist, Geräte zu finden, die die defekte ANDROID_ID haben.

Basierend auf den Empfehlungen von Google habe ich eine Klasse implementiert, die eine eindeutige UUID für jedes Gerät generiert, gegebenenfalls mit ANDROID_ID als Ausgangswert, bei Bedarf auf TelephonyManager.getDeviceId () zurückgreift, und falls dies fehlschlägt, auf eine zufällig generierte eindeutige UUID zurückgreift das bleibt bei App-Neustarts erhalten (aber keine App-Neuinstallationen).

Beachten Sie, dass bei Geräten, die auf die Geräte-ID zurückgreifen müssen, die eindeutige ID auch bei Werksrücksetzungen erhalten bleibt. Dies ist etwas, worauf Sie achten sollten. Wenn Sie sicherstellen müssen, dass ein Werksreset Ihre eindeutige ID zurücksetzt, sollten Sie möglicherweise auf die zufällige UUID anstelle der Geräte-ID zurückgreifen.

Dieser Code bezieht sich wiederum auf eine Geräte-ID und nicht auf eine App-Installations-ID. In den meisten Situationen suchen Sie wahrscheinlich nach einer App-Installations-ID. Wenn Sie jedoch eine Geräte-ID benötigen, funktioniert der folgende Code wahrscheinlich für Sie.

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



Sie können auch die MAC-Adresse des Wi-Fi-Adapters berücksichtigen. So abgerufen:

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

Erfordert die Berechtigung android.permission.ACCESS_WIFI_STATE im Manifest.

Es wird berichtet, dass es auch dann verfügbar ist, wenn keine Wi-Fi-Verbindung besteht. Wenn Joe aus der obigen Antwort einen Versuch mit seinen vielen Geräten macht, wäre das schön.

Bei einigen Geräten ist die Funktion nicht verfügbar, wenn WLAN deaktiviert ist.

HINWEIS: In Android 6.x wird eine konsistente falsche MAC-Adresse zurückgegeben: 02:00:00:00:00:00







Der folgende Code gibt die Geräteseriennummer mithilfe einer versteckten Android-API zurück. Dieser Code funktioniert jedoch nicht auf Samsung Galaxy Tab, da "ro.serialno" auf diesem Gerät nicht festgelegt ist.

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

}



Mit dem folgenden Code können Sie die eindeutige Geräte-ID eines Android-Betriebssystems als Zeichenfolge abrufen.

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



Eines möchte ich hinzufügen - ich habe eine dieser einzigartigen Situationen.

Mit:

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

Es stellt sich heraus, dass, obwohl mein Viewsonic G-Tablet eine nicht-NULL-DeviceID meldet, jedes G-Tablet die gleiche Nummer angibt.

Es macht es interessant, "Pocket Empires" zu spielen, wodurch Sie auf der "eindeutigen" DeviceID sofort Zugriff auf das Konto einer anderen Person haben.

Mein Gerät verfügt nicht über ein Mobilfunkgerät.




Fügen Sie folgenden Code in der Klassendatei hinzu:

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

Hinzufügen in AndroidManifest.xml:

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



Es gibt viele verschiedene Ansätze, um diese ANDROID_IDProbleme zu umgehen ( nullmanchmal geben Geräte eines bestimmten Modells immer die gleiche ID zurück) mit Vor- und Nachteilen:

  • Implementierung eines benutzerdefinierten ID-Generierungsalgorithmus (basierend auf Geräteeigenschaften, die statisch sein sollen und sich nicht ändern -> wer weiß)
  • Missbrauch anderer IDs wie IMEI , Seriennummer, Wi-Fi / Bluetooth-MAC-Adresse (diese sind nicht auf allen Geräten vorhanden oder es werden zusätzliche Berechtigungen benötigt)

Ich selbst bevorzuge die Verwendung einer vorhandenen OpenUDID-Implementierung (siehe https://github.com/ylechelle/OpenUDID ) für Android (siehe https://github.com/vieux/OpenUDID ). Es ist einfach zu integrieren und verwendet die ANDROID_IDoben genannten Probleme mit den Fallbacks.




So generiere ich die eindeutige ID:

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



Eine andere Möglichkeit ist die Verwendung /sys/class/android_usb/android0/iSerialin einer App ohne jegliche Berechtigung.

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

In Java würde man dazu einfach einen FileInputStream verwenden, um die iSerial-Datei zu öffnen und die Zeichen auszulesen. Stellen Sie nur sicher, dass Sie es in einen Ausnahmehandler packen, da nicht alle Geräte über diese Datei verfügen.

Zumindest für die folgenden Geräte ist bekannt, dass diese Datei weltweit lesbar ist:

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

Sie können auch meinen Blogbeitrag sehen. Android-Hardware-Seriennummer an unprivilegierte Apps weitergeben, in denen ich besuche, welche anderen Dateien für Informationen verfügbar sind.




Ich verwende den folgenden Code, um das zu erhalten IMEIoder Secure zu verwenden. ANDROID_IDals Alternative, wenn das Gerät keine Telefonfunktionen hat:

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



Google-Instanz-ID

Freigegeben am I / O 2015; Für Android sind Spieldienste erforderlich. 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

Es scheint, dass Google beabsichtigt, diese ID zur Identifizierung von Installationen unter Android, Chrome und iOS zu verwenden.

Es identifiziert eine Installation und nicht ein Gerät, aber ANDROID_ID (die akzeptierte Antwort) identifiziert nun auch keine Geräte mehr. Mit der ARC-Laufzeit wird für jede Installation eine neue ANDROID_ID generiert ( Details hier ), genau wie diese neue Instanz-ID. Ich denke auch, dass die Identifizierung von Installationen (nicht Geräten) das ist, wonach die meisten von uns tatsächlich suchen.

Die Vorteile der Instanz-ID

Mir scheint, Google beabsichtigt, dass es für diesen Zweck verwendet wird (Identifizierung Ihrer Installationen), es ist plattformübergreifend und kann für eine Reihe anderer Zwecke verwendet werden (siehe die obigen Links).

Wenn Sie GCM verwenden, müssen Sie schließlich diese Instanz-ID verwenden, da Sie diese benötigen, um das GCM-Token zu erhalten (das die alte GCM-Registrierungs-ID ersetzt).

Die Nachteile / Probleme

In der aktuellen Implementierung (GPS 7.5) wird die Instanz-ID von einem Server abgerufen, wenn Ihre App sie anfordert. Dies bedeutet, dass der obige Anruf ein blockierender Anruf ist. In meinen unwissenschaftlichen Tests dauert es 1 bis 3 Sekunden, wenn das Gerät online ist, und 0,5 bis 1,0 Sekunden, wenn es offline ist (vermutlich dauert es, bis es aufgibt und ein Gerät generiert) zufällige ID). Dies wurde in Nordamerika auf Nexus 5 mit Android 5.1.1 und GPS 7.5 getestet.

Wenn Sie die ID für die vorgesehenen Zwecke verwenden, z. App-Authentifizierung, App-Identifizierung, GCM - Ich denke, diese 1-3 Sekunden könnten ein Ärgernis sein (abhängig von Ihrer App natürlich).




Es gibt mehr als 30 Antworten und einige sind gleich und einige sind einzigartig. Diese Antwort basiert auf wenigen dieser Antworten. Einer von ihnen ist die Antwort von @Lenn Dolling.

Es kombiniert 3 IDs und erstellt eine 32-stellige Hex-Zeichenfolge. Es hat sehr gut für mich funktioniert.

3 - IDs sind:
Pseudo-ID - sie erzeugt wird , basierend auf physikalischen Gerätespezifikationen
ANDROID_ID - Settings.Secure.ANDROID_ID
Bluetooth - Adresse - Bluetooth - Adapter - Adresse

Es wird etwas wie folgt zurückgegeben : 551F27C060712A72730B0A0F734064B1

Hinweis: Sie können der longIdZeichenfolge immer weitere IDs hinzufügen . Zum Beispiel, Seriennummer. WLAN-Adapteradresse. IMEI. Auf diese Weise machen Sie es für jedes Gerät einzigartig.

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



TelephonyManger.getDeviceId () Gibt die eindeutige Geräte-ID zurück, z. B. die IMEI für GSM und die MEID oder ESN für CDMA-Telefone.

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

Aber ich empfehle zu verwenden:

Settings.Secure.ANDROID_ID , die die Android-ID als eindeutige 64-Bit-Hex-Zeichenfolge zurückgibt.

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

Manchmal gibt TelephonyManger.getDeviceId () den Wert null zurück. Um eine eindeutige ID sicherzustellen, verwenden Sie diese Methode:

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



Related