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




device herausfinden (25)

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


Answers

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

[email protected]:~$ adb shell ls -l /sys/class/android_usb/android0/iSerial
-rw-r--r-- root     root         4096 2013-01-10 21:08 iSerial
[email protected]:~$ 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.


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" />

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

}

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



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

Ein Serial Feld wurde die zusätzliche BuildKlasse in API - Ebene 9 (Android 2.3 - Lebkuchen). Die Dokumentation besagt, dass es sich um die Seriennummer der Hardware handelt. Daher sollte es eindeutig sein, wenn es auf dem Gerät vorhanden ist.

Ich weiß nicht, ob es tatsächlich von allen Geräten mit API-Level> = 9 unterstützt wird (= nicht null).


Wie wäre es mit der IMEI . Das ist einzigartig für Android oder andere mobile Geräte.


Die eindeutige Geräte-ID eines Android-Betriebssystems als Zeichenfolge unter Verwendung von TelephonyManagerund ANDROID_IDwird wie folgt ermittelt:

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

Ich empfehle jedoch dringend eine von Google vorgeschlagene Methode, siehe App-Installationen identifizieren .


Die Android-Geräte-MAC-ID hat auch eine eindeutige ID. Diese Einstellung wird nicht geändert, wenn Sie das Gerät selbst formatieren

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

Vergessen Sie auch nicht, die entsprechenden Berechtigungen in Ihre AndroidManifest.xml aufzunehmen

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

Meine zwei Cents - Anmerkung: Dies ist für eine eindeutige Geräte-ID (err) - nicht für die Installation, wie im Blog der Android-Entwickler beschrieben .

Beachten Sie, dass die von @emmby bereitgestellte solution auf eine Anwendungs-ID zurückgreift, da die SharedPreferences nicht prozessübergreifend synchronisiert werden ( here und here ). Also habe ich das ganz vermieden.

Stattdessen habe ich die verschiedenen Strategien zum Abrufen einer (Geräte-) ID in einer Enumeration gekapselt. Die Änderung der Reihenfolge der Enumenkonstanten beeinflusst die Priorität der verschiedenen Arten, die ID zu erhalten. Die erste Nicht-Null-ID wird zurückgegeben oder eine Ausnahme wird ausgelöst (gemäß den guten Java-Praktiken, wenn Null keine Bedeutung hat). So habe ich zum Beispiel zuerst die TELEPHONY - aber eine gute Standardwahl wäre die ANDROID_ID- Beta:

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

Ich denke, das ist eine sichere Art und Weise, wie man ein Skelett für eine eindeutige ID erstellt ... check it out.

Pseudo-eindeutige ID, die auf allen Android-Geräten funktioniert Einige Geräte verfügen nicht über ein Telefon (z. B. Tablets) oder Sie möchten die Berechtigung READ_PHONE_STATE aus irgendeinem Grund nicht hinzufügen. Sie können weiterhin Details wie ROM-Version, Herstellername, CPU-Typ und andere Hardware-Details lesen, die sich gut eignen, wenn Sie die ID für eine Serienschlüsselprüfung oder für andere allgemeine Zwecke verwenden möchten. Die auf diese Weise berechnete ID ist nicht eindeutig: Es ist möglich, zwei Geräte mit derselben ID zu finden (basierend auf derselben Hardware und demselben ROM-Image), aber die Änderungen in realen Anwendungen sind vernachlässigbar. Zu diesem Zweck können Sie die Build-Klasse verwenden:

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

Die meisten Build-Mitglieder sind Strings. Wir machen hier ihre Länge und wandeln sie per Modulo in eine Ziffer um. Wir haben 13 solcher Ziffern und fügen zwei weitere (35) hinzu, um dieselbe ID-Größe wie der IMEI (15 Ziffern) zu haben. Es gibt auch andere Möglichkeiten hier, schaut euch einfach diese Saiten an. Gibt so etwas zurück 355715565309247. Es ist keine besondere Erlaubnis erforderlich, was diesen Ansatz sehr bequem macht.

(Zusätzliche Informationen: Die oben angegebene Technik wurde aus einem Artikel über here kopiert .)


Zuletzt aktualisiert: 02.06.15

Nachdem ich jeden -Beitrag zum Erstellen einer eindeutigen ID, des Google-Entwicklerblogs und der Android-Dokumentation gelesen habe, habe ich das Gefühl, dass die "Pseudo-ID" die beste Option ist.

Hauptproblem: Hardware vs. Software

Hardware

  • Benutzer können ihre Hardware, ihr Android-Tablet oder ihr Telefon ändern. Daher sind eindeutige, auf Hardware basierende IDs keine gute Idee für TRACKING-BENUTZER
  • Für TRACKING HARDWARE ist dies eine großartige Idee

Software

  • Benutzer können ihr ROM löschen oder ändern, wenn sie verwurzelt sind
  • Sie können Benutzer plattformübergreifend verfolgen (iOS, Android, Windows und Web).
  • Am besten möchten Sie mit Ihrer Zustimmung EINEN EINZELNUTZER VERFOLGEN , indem Sie sich einfach anmelden (machen Sie dies nahtlos mit OAuth).

Gesamtausfall bei Android

- Eindeutigkeit garantieren (einschließlich gerootete Geräte) für API> = 9/10 (99,5% der Android-Geräte)

- Keine zusätzlichen Berechtigungen

Pseudo-Code:

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)

Vielen Dank an @stansult für das Posten aller Optionen (in dieser -Frage).

Liste der Optionen - Gründe warum / warum nicht verwendet werden:

  • Benutzer-E-Mail - Software

    • Der Benutzer könnte die E-Mail-Adresse ändern - sehr unwahrscheinlich
    • API 5+ <uses-permission android:name="android.permission.GET_ACCOUNTS" /> oder
    • API 14+ <uses-permission android:name="android.permission.READ_PROFILE" /> <uses-permission android:name="android.permission.READ_CONTACTS" /> ( So erhalten Sie die primäre E-Mail-Adresse des Android-Geräts )
  • Telefonnummer des Benutzers - Software

    • Benutzer können Telefonnummern ändern - sehr unwahrscheinlich
    • <uses-permission android:name="android.permission.READ_PHONE_STATE" />
  • IMEI - Hardware (nur Telefone, die android.permission.READ_PHONE_STATE )

    • Die meisten Benutzer hassen die Tatsache, dass in der Berechtigung "Telefonanrufe" angezeigt wird. Einige Benutzer geben schlechte Bewertungen ab, weil sie der Meinung sind, dass Sie einfach ihre persönlichen Informationen stehlen, wenn Sie wirklich nur Geräteinstallationen verfolgen möchten. Es ist offensichtlich, dass Sie Daten sammeln.
    • <uses-permission android:name="android.permission.READ_PHONE_STATE" />
  • Android-ID - Hardware (kann Null sein, kann sich beim Zurücksetzen auf die Werkseinstellungen ändern, kann auf einem gerooteten Gerät geändert werden)

    • Da es 'null' sein kann, können wir nach 'null' suchen und dessen Wert ändern. Dies bedeutet jedoch, dass es nicht mehr eindeutig ist.
    • Wenn Sie einen Benutzer mit einem Gerät zum Zurücksetzen auf die Werkseinstellungen haben, hat sich der Wert möglicherweise auf dem gerooteten Gerät geändert oder geändert, sodass bei der Nachverfolgung von Benutzerinstallationen Duplikateinträge vorhanden sind.
  • WLAN-MAC-Adresse - Hardware (benötigt android.permission.ACCESS_WIFI_STATE )

    • Dies könnte die zweitbeste Option sein, aber Sie erfassen und speichern immer noch eine eindeutige Kennung, die direkt von einem Benutzer stammt. Dies ist offensichtlich, dass Sie Daten sammeln.
    • <uses-permission android:name="android.permission.ACCESS_WIFI_STATE "/>
  • Bluetooth MAC-Adresse - Hardware (Geräte mit Bluetooth, benötigt android.permission.BLUETOOTH )

    • Die meisten auf dem Markt befindlichen Anwendungen verwenden kein Bluetooth. Wenn Ihre Anwendung also kein Bluetooth verwendet und Sie dies berücksichtigen, kann der Benutzer verdächtig werden.
    • <uses-permission android:name="android.permission.BLUETOOTH "/>
  • Pseudo-Unique ID - Software (für alle Android-Geräte)

    • Sehr gut möglich, kann Kollisionen enthalten - Siehe meine Methode!
    • Auf diese Weise können Sie eine "fast eindeutige" ID vom Benutzer erhalten, ohne etwas zu nehmen, das nicht privat ist. Sie können Ihre eigene anonyme ID aus den Geräteinformationen erstellen.

Ich weiß, dass es keine "perfekte" Möglichkeit gibt, eine eindeutige ID ohne Berechtigungen zu erhalten. Manchmal müssen wir jedoch nur die Geräteinstallation wirklich nachverfolgen. Wenn Sie eine eindeutige ID erstellen möchten, können Sie eine "pseudo-eindeutige ID" erstellen, die ausschließlich auf Informationen basiert, die uns die Android-API ohne zusätzliche Berechtigungen zur Verfügung stellt. Auf diese Weise können wir den Respekt der Benutzer zeigen und versuchen, auch eine gute Benutzererfahrung anzubieten.

Mit einer pseudo-eindeutigen ID stößt man eigentlich nur darauf, dass es möglicherweise Duplikate gibt, wenn ähnliche Geräte vorhanden sind. Sie können die kombinierte Methode anpassen, um sie einzigartig zu machen. Einige Entwickler müssen jedoch die Geräteinstallation nachverfolgen. Dies wird den Trick oder die Leistung auf der Grundlage ähnlicher Geräte bewirken.

API> = 9:

Wenn das Android-Gerät API 9 oder höher ist, ist dies aufgrund des Felds "Build.SERIAL" garantiert eindeutig.

Denken Sie daran, dass Sie technisch gesehen nur etwa 0,5% der Benutzer mit API <9 verpassen. Sie können sich also auf den Rest konzentrieren: Das sind 99,5% der Benutzer!

API <9:

Wenn das Android-Gerät des Benutzers niedriger als API 9 ist; hoffentlich haben sie kein Werksreset durchgeführt und ihre 'Secure.ANDROID_ID' bleibt erhalten oder nicht 'null'. (siehe http://developer.android.com/about/dashboards/index.html )

Wenn alle Stricke reißen:

Wenn alles andere fehlschlägt, wenn der Benutzer weniger als API 9 (niedriger als Gingerbread) hat, sein Gerät zurückgesetzt hat oder "Secure.ANDROID_ID" den Wert "null" zurückgibt, dann wird die zurückgegebene ID nur auf den Android-Geräteinformationen basieren. Hier können Kollisionen auftreten.

Änderungen:

  • Entfernen von 'Android.SECURE_ID' aufgrund von Werksresets kann dazu führen, dass sich der Wert ändert
  • Der Code wurde für die API-Änderung geändert
  • Das Pseudo wurde geändert

Bitte schauen Sie sich die Methode unten an:

/**
 * 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://.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://.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();
}

Neu (für Apps mit Anzeigen UND Google Play-Services):

Über die Konsole des Google Play-Entwicklers:

Seit dem 1. August 2014 müssen gemäß den Richtlinien für das Google Play-Entwicklerprogramm alle neuen App-Uploads und -Updates die Werbe-ID anstelle von anderen permanenten Kennungen für Werbezwecke verwenden. Mehr erfahren

Umsetzung :

Genehmigung:

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

Quelle / Dokumente:

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

Wichtig:

Es ist beabsichtigt, dass die Werbe-ID die vorhandene Verwendung anderer Bezeichner für Werbezwecke vollständig ersetzt (z. B. Verwendung von ANDROID_ID in Settings.Secure), wenn Google Play-Dienste verfügbar sind. Fälle, in denen Google Play-Dienste nicht verfügbar sind, werden durch eine GooglePlayServicesNotAvailableException angezeigt, die von getAdvertisingIdInfo () ausgelöst wird.

Warnung, Benutzer können zurücksetzen:

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

Ich habe versucht, auf jeden Link zu verweisen, von dem ich Informationen erhielt. Wenn Sie fehlen und aufgenommen werden müssen, kommentieren Sie bitte!

Instanz-ID der Google Player-Dienste

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


Ausführliche Anweisungen zum Beziehen einer eindeutigen Kennung für jedes Android-Gerät, von dem aus Ihre Anwendung installiert ist, finden Sie im offiziellen Blog für Entwickler von Android, das android-developers.blogspot.com/2011/03/… .

Es scheint, dass der beste Weg für Sie ist, einen bei der Installation selbst zu generieren und anschließend zu lesen, wenn die Anwendung neu gestartet wird.

Ich persönlich finde das akzeptabel, aber nicht ideal. Keine von Android bereitgestellte Kennung funktioniert in allen Fällen, da die meisten von den Funkzuständen des Telefons abhängen (Wi-Fi ein / aus, Mobilfunk ein / aus, Bluetooth ein / aus). Die anderen, wie, Settings.Secure.ANDROID_IDmüssen vom Hersteller implementiert werden und sind nicht unbedingt eindeutig.

Im Folgenden finden Sie ein Beispiel für das Schreiben von Daten in eine Installationsdatei , die zusammen mit anderen Daten gespeichert werden, die von der Anwendung lokal gespeichert werden.

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


Für die Hardwareerkennung eines bestimmten Android-Geräts können Sie die MAC-Adressen überprüfen.

Sie können es so machen:

in AndroidManifest.xml

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

jetzt in deinem code:

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

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

In jedem Android-Gerät gibt es mindestens eine "wlan0" -Schnittstelle, die der WI-FI-Chip ist. Dieser Code funktioniert auch, wenn WI-FI nicht aktiviert ist.

PS Es gibt eine Reihe anderer Schnittstellen, die Sie aus der Liste mit MACS erhalten. Dies kann sich jedoch zwischen den Telefonen ändern.



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.


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


Hier ist der Code, den Reto Meier dieses Jahr in der Google I / O- Präsentation verwendet hat, um eine eindeutige ID für den Nutzer zu erhalten:

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

Wenn Sie dies mit einer Sicherungsstrategie koppeln, um Präferenzen an die Cloud zu senden (auch in Retos talk , sollten Sie eine ID haben, die an einen Benutzer gebunden ist und nach dem Löschen des Geräts verbleibt oder sogar ersetzt wird. Ich möchte diese Option verwenden In der Analytik geht es weiter (mit anderen Worten, ich habe das noch nicht gemacht :).


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

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

Es gibt ziemlich nützliche Informationen here .

Es werden fünf verschiedene ID-Typen behandelt:

  1. IMEI (nur für Android-Geräte mit Phone-Nutzung; benötigt android.permission.READ_PHONE_STATE )
  2. Pseudo-eindeutige ID (für alle Android-Geräte)
  3. Android-ID (kann Null sein, kann sich beim Zurücksetzen auf die Werkseinstellungen ändern, kann am gerooteten Telefon geändert werden)
  4. WLAN-MAC- android.permission.ACCESS_WIFI_STATE (benötigt android.permission.ACCESS_WIFI_STATE )
  5. BT MAC- android.permission.BLUETOOTH (Geräte mit Bluetooth, android.permission.BLUETOOTH )

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

  • Kontext stellt ein Handle dar, um Umgebungsdaten zu erhalten.
  • Die Kontextklasse selbst wird als abstrakt deklariert, deren Implementierung vom Android-Betriebssystem bereitgestellt wird.
  • Der Kontext ist wie eine Fernbedienung eines Fernsehsenders, und Kanäle im Fernsehen sind Ressourcen, Dienste usw.

Was kannst du damit machen?

  • Ressource wird geladen.
  • Starten einer neuen Aktivität
  • Ansichten erstellen
  • Systemdienst erhalten

Wege zum Kontext:

  • getApplicationContext()
  • getContext()
  • getBaseContext()




android uniqueidentifier