it-swarm.com.de

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

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

2466
Tyler

Settings.Secure#Android_ID gibt die Android-ID als eindeutig für jeden Benutzer zurück 64-Bit-Hex-String.

import Android.provider.Settings.Secure;

private String Android_id = Secure.getString(getContext().getContentResolver(),
                                                        Secure.Android_ID); 
1807

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 Anthony's answer .

Vollständige Offenlegung: Meine App hat ursprünglich den folgenden Ansatz verwendet, verwendet diesen Ansatz jedoch nicht mehr, und wir verwenden jetzt den im Android Developer Blog -Eintrag beschriebenen Ansatz, auf den Emmby's answer verweist (nämlich ein UUID#randomUUID() ) generieren und speichern.


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() zurückgegeben.
  2. Alle GSM-Geräte (alle mit einer SIM-Karte getestet) haben einen Wert für TelephonyManager.getSimSerialNumber() zurückgegeben.
  3. Alle CDMA-Geräte haben für getSimSerialNumber() (wie erwartet) Null zurückgegeben.
  4. Alle Geräte mit einem hinzugefügten Google-Konto haben einen Wert für Android_ID zurückgegeben.
  5. Alle CDMA-Geräte haben für Android_ID und TelephonyManager.getDeviceId() - den gleichen Wert (oder dieselbe Ableitung desselben Werts) zurückgegeben, solange während der Einrichtung [] ein Google-Konto 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 Besonderes für das Gerät selbst wünschen, sollte TM.getDeviceId() ausreichen. Offensichtlich sind einige Benutzer paranoider als andere. Daher kann es sinnvoll sein, 1 oder mehrere dieser Bezeichner zu hashieren, so dass die Zeichenfolge immer noch praktisch für das Gerät eindeutig 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();

kann 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;
1087
Joe

Letzte Aktualisierung: 02.06.15


Nachdem ich jeden Stack Overflow-Beitrag über das Erstellen einer eindeutigen ID, das Google-Entwicklerblog und die Dokumentation zu Android gelesen habe, habe ich das Gefühl, dass die "Pseudo-ID" die bestmögliche Option ist.

Hauptproblem: Hardware vs Software

Hardware

  • Benutzer können ihre Hardware, Android Tablets oder Telefone ändern, sodass eindeutige, auf Hardware basierende IDs keine guten Ideen für TRACKING USERS sind
  • Für TRACKING HARDWARE ist dies eine großartige Idee

Software

  • Benutzer können ihr ROM löschen/ändern, wenn sie verwurzelt sind
  • Sie können Benutzer plattformübergreifend verfolgen (iOS, Android, Windows und Web).
  • Das Beste, was Sie tun möchten, um EINEN INDIVIDUELLEN BENUTZER VERFOLGEN mit dessen Einwilligung zu erreichen, ist, sich einfach anzumelden (um dies mit OAuth nahtlos zu machen)

Gesamtaufschlüsselung mit Android

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

- Keine zusätzlichen Berechtigungen

Pseudocode:

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

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

else

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

Vielen Dank an @stansult für die Veröffentlichung alle unsere Optionen (in dieser Frage zum Stapelüberlauf).

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

  • Benutzer Email - Software

    • Benutzer könnte E-Mail ä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 )
  • Benutzer Telefonnummer - Software

    • Benutzer könnten Telefonnummern ändern - SEHR unwahrscheinlich
    • _<uses-permission Android:name="Android.permission.READ_PHONE_STATE" />_
  • IMEI - Hardware (nur Telefone, benötigt Android.permission.READ_PHONE_STATE)

    • Die meisten Benutzer hassen die Tatsache, dass in der Erlaubnis "Telefonanrufe" steht. Einige Benutzer geben schlechte Bewertungen ab, weil sie glauben, dass Sie einfach ihre persönlichen Daten stehlen, wenn Sie nur die 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 den 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, wurde der Wert möglicherweise auf dem gerooteten Gerät geändert, sodass möglicherweise doppelte Einträge vorhanden sind, wenn Sie Benutzerinstallationen verfolgen.
  • WLAN-MAC-Adresse - Hardware (benötigt Android.permission.ACCESS_WIFI_STATE)

    • Dies könnte die zweitbeste Option sein, aber Sie sammeln 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ötigen Android.permission.BLUETOOTH)

    • Die meisten Anwendungen auf dem Markt verwenden kein Bluetooth. Wenn Ihre Anwendung also kein Bluetooth verwendet und Sie dies mit einbeziehen, kann der Benutzer misstrauisch 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 unten stehende Methode!
    • Auf diese Weise können Sie vom Benutzer eine "fast eindeutige" ID erhalten, ohne dass Sie etwas nehmen müssen, das privat ist. Sie können Ihre eigene anonyme ID aus den Geräteinformationen erstellen.

Ich weiß, dass es keinen "perfekten" Weg gibt, eine eindeutige ID zu erhalten, ohne Berechtigungen zu verwenden. Manchmal müssen wir jedoch nur die Geräteinstallation nachverfolgen. Wenn es um das Erstellen einer eindeutigen ID geht, können wir eine "Pseudo-eindeutige ID" erstellen, die ausschließlich auf Informationen basiert, die uns die API Android ohne Verwendung zusätzlicher Berechtigungen gibt. Auf diese Weise können wir dem Benutzer Respekt entgegenbringen und versuchen, auch eine gute Benutzererfahrung zu bieten.

Mit einer pseudo-eindeutigen ID stoßen Sie wirklich nur auf die Tatsache, dass es aufgrund der Tatsache, dass es ähnliche Geräte gibt, möglicherweise Duplikate gibt. Sie können die kombinierte Methode optimieren, um sie eindeutiger zu machen. Einige Entwickler müssen jedoch Geräteinstallationen nachverfolgen, und dies erledigt den Trick oder die Leistung auf der Grundlage ähnlicher Geräte.

API> = 9:

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

REMEMBER, Sie verpassen technisch gesehen nur rund 0,5% der Benutzer mit API <9 . So können Sie sich auf den Rest konzentrieren: Das sind 99,5% der Nutzer!

API <9:

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

Wenn alle Stricke reißen:

Wenn alles andere fehlschlägt, wenn der Benutzer ein niedrigeres als API 9 (niedriger als Gingerbread) hat, sein Gerät zurückgesetzt hat oder 'Secure.Android_ID' 'null' zurückgibt, basiert die zurückgegebene ID lediglich auf seinem Android Geräteinformationen. Hier können Kollisionen auftreten.

Änderungen:

  • Das Entfernen von 'Android.SECURE_ID' aufgrund von Werkseinstellungen kann zu einer Änderung des Werts führen
  • Der Code wurde bearbeitet, um ihn in der API zu ändern
  • Pseudo geändert

Bitte schauen Sie sich die folgende Methode 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://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();
}
_

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

Von der Google Play-Entwicklerkonsole aus:

Ab dem 1. August 2014 müssen gemäß der Programmrichtlinie für Google Play Developer alle neuen App-Uploads und -Updates die Werbe-ID anstelle anderer dauerhafter Kennungen für Werbezwecke verwenden. Mehr erfahren

Implementierung:

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

Source/Docs:

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

Wichtig:

Es ist beabsichtigt, dass die Werbe-ID die vorhandene Verwendung anderer Identifikatoren für Werbezwecke (z. B. die Verwendung von Android_ID in Settings.Secure) vollständig ersetzt, wenn Google Play Services verfügbar ist. Fälle, in denen Google Play Services nicht verfügbar sind, werden durch eine GooglePlayServicesNotAvailableException gekennzeichnet, 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 erhalten habe. Wenn Sie vermisst werden und aufgenommen werden müssen, kommentieren Sie bitte!

Instanz-ID der Google Player-Dienste

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

413
Jared Burrows

Wie Dave Webb erwähnt, enthält der Android Developer Blog) einen Artikel , der dies abdeckt. Ihre bevorzugte Lösung ist das Verfolgen von App-Installationen anstelle von Geräten. Dies funktioniert in den meisten Anwendungsfällen gut. Der Blog-Post 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 in 2.2 von Android_ID betroffen.
  • Soweit ich feststellen konnte, haben alle betroffenen Geräte dieselbe Android_ID , also 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 mit der beschädigten Android_ID zu finden.

Basierend auf den Empfehlungen von Google, habe ich eine Klasse implementiert, die eine eindeutige UUID für jedes Gerät generiert, wobei ggf. Android_ID als Startwert verwendet wird, gegebenenfalls auf TelephonyManager.getDeviceId () zurückgegriffen wird, und falls dies fehlschlägt, auf eine zufällig generierte eindeutige UUID zurückgreift Das bleibt bei App-Neustarts erhalten (nicht jedoch bei Neuinstallationen von Apps).

Beachten Sie, dass bei Geräten, die auf die Geräte-ID zurückgreifen müssen, die eindeutige ID auch bei Werksrücksetzungen bestehen 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;
    }
}
322
emmby

Hier ist der Code, den Reto Meier dieses Jahr in der Präsentation Google I/O verwendet hat, um eine eindeutige ID für den Benutzer 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 beschrieben), sollten Sie eine ID haben, die an einen Benutzer gebunden ist und nach dem Löschen des Geräts verbleibt oder sogar ersetzt wird Planen Sie, dies in der Analytik zukünftig zu verwenden (mit anderen Worten, ich habe das noch nicht gemacht :).

171
Anthony Nolan

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 diese Funktion nicht verfügbar, wenn WLAN deaktiviert ist.

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

99
Seva Alekseyev

Es gibt ziemlich nützliche Informationen hier.

Es werden fünf verschiedene ID-Typen behandelt:

  1. IMEI (nur für Android-Geräte mit Telefonbenutzung; benötigt Android.permission.READ_PHONE_STATE)
  2. Pseudo-Unique 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-Adresse Zeichenfolge (benötigt Android.permission.ACCESS_WIFI_STATE)
  5. BT MAC Address Zeichenfolge (Geräte mit Bluetooth, benötigt Android.permission.BLUETOOTH)
81
stansult

Der offizielle Android Developers Blog enthält jetzt einen vollständigen Artikel zu diesem Thema, nämlich Identifizierende App-Installationen.

47
BoD

Bei Google I/O / Reto Meier hat eine robuste Antwort auf die Vorgehensweise veröffentlicht, die die meisten Entwickleranforderungen erfüllen sollte, um Benutzer über Installationen hinweg zu verfolgen. Anthony Nolan gibt in seiner Antwort die Richtung vor, aber ich dachte, ich würde die gesamte Herangehensweise aufschreiben, damit andere leicht sehen können, wie man das macht.

Durch diesen Ansatz erhalten Sie eine anonyme, sichere Benutzer-ID, die für den Benutzer auf verschiedenen Geräten (basierend auf dem primären Google-Konto) und bei allen Installationen dauerhaft ist. Der grundlegende Ansatz besteht darin, eine zufällige Benutzer-ID zu generieren und diese in den gemeinsamen Einstellungen der Apps zu speichern. Anschließend verwenden Sie den Backup Agent von Google, um die mit dem Google-Konto verknüpften freigegebenen Einstellungen in der Cloud zu speichern.

Gehen wir den vollständigen Ansatz durch. Zunächst müssen wir ein Backup für unsere SharedPreferences erstellen, indem wir den Android Backup Service verwenden. Beginnen Sie mit der Registrierung Ihrer App über http://developer.Android.com/google/backup/signup.html.

Google gibt Ihnen einen Sicherungsdienstschlüssel, den Sie zum Manifest hinzufügen müssen. Sie müssen der Anwendung außerdem mitteilen, dass sie BackupAgent wie folgt verwenden soll:

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

Dann müssen Sie den Sicherungsagenten erstellen und ihm mitteilen, dass er den Hilfsagenten für gemeinsam genutzte Präferenzen verwenden soll:

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

Um die Sicherung abzuschließen, müssen Sie in Ihrer Hauptaktivität eine Instanz von BackupManager erstellen:

BackupManager backupManager = new BackupManager(context);

Erstellen Sie schließlich eine Benutzer-ID, falls diese noch nicht vorhanden ist, und speichern Sie sie in den SharedPreferences:

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

            //backup the changes
            BackupManager mBackupManager = new BackupManager(context);
            mBackupManager.dataChanged();
        }
    }

    return uniqueID;
}

Diese Benutzer-ID ist jetzt auch in allen Installationen erhalten, auch wenn der Benutzer das Gerät bewegt.

Weitere Informationen zu diesem Ansatz finden Sie unter Reto's talk .

Ausführliche Informationen zur Implementierung des Sicherungsagenten finden Sie unter Data Backup. Ich empfehle insbesondere den Abschnitt unten zum Testen, da die Sicherung nicht sofort erfolgt und Sie zum Testen die Sicherung erzwingen müssen.

38
TechnoTony

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). Aus irgendeinem Grund möchten Sie nicht die Berechtigung READ_PHONE_STATE einschließen. Sie können weiterhin Details wie ROM -Version, Herstellername, CPU-Typ und andere Hardwaredetails 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 der gleichen Hardware und dem 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 andere Möglichkeiten, die hier gut sind, schauen Sie sich einfach diese Zeichenketten an Gibt etwas wie 355715565309247 zurück. Es ist keine besondere Erlaubnis erforderlich, was diesen Ansatz sehr bequem macht.


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

34
Lenn Dolling

Der folgende Code gibt die Geräteseriennummer mithilfe einer versteckten Android-API zurück. Dieser Code funktioniert jedoch nicht für 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) {

}
34
Roman SL

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); 
22
Mohit Kanada

In der API-Ebene 9 (Android 2.3 - Lebkuchen) wurde der Build-Klasse ein Serial - Feld hinzugefügt. 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).

18
rony l

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 Geräte-ID meldet, die nicht Null ist, jedes G-Tablet die gleiche Zahl angibt.

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

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

15
Tony Maro

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 Android-Entwickler-Blog unter Identifizieren von App-Installationen.

Es scheint, dass der beste Weg für Sie ist, einen bei der Installation selbst zu generieren und anschließend beim Neustart der Anwendung zu lesen.

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ängig sind (Wi-Fi ein/aus, Mobilfunk ein/aus, Bluetooth ein/aus). Die anderen, wie Settings.Secure.Android_ID, müssen vom Hersteller implementiert werden und sind nicht unbedingt eindeutig.

Im Folgenden finden Sie ein Beispiel für das Schreiben von Daten in eine installation -Datei, die zusammen mit anderen Daten gespeichert werden würde, die die Anwendung lokal speichert.

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

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

Die eindeutige Geräte-ID eines Android-Betriebssystems als String mit TelephonyManager und Android_ID erhält man von:

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 Identifizieren von App-Installationen.

9
Elenasys

Es gibt viele verschiedene Ansätze, um diese Android_ID-Probleme zu umgehen (manchmal null oder Geräte eines bestimmten Modells geben 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 leicht zu integrieren und verwendet Android_ID mit Fallbacks für die oben genannten Probleme.

8
Andreas Klöber

Meine zwei Cents - NB Dies ist für eine device (err) unique ID - nicht für die Installation, wie im Android-Entwicklerblog besprochen .

Beachten Sie, dass die von @emmby bereitgestellte Lösung in einer Anwendungs-ID zurückfällt, da die SharedPreferences nicht prozessübergreifend synchronisiert werden (siehe hier und hier ). 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 es wird eine Ausnahme 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:

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

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

7
Elzo Valugi

So generiere ich die eindeutige ID:

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;
}
7
Eng.Fouad

Eine andere Möglichkeit ist die Verwendung von /sys/class/Android_usb/Android0/iSerial in 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

Um dies in Java zu tun, würde man 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 anzeigen ANDAUERNDE ANDROID-HARDWARE-SERIENNUMMER MIT UNPRIVILEGIERTEN APPS, wo ich besuche, welche anderen Dateien für Informationen verfügbar sind.

6
insitusec

Genauer gesagt, Settings.Secure.Android_ID. Dies ist eine 64-Bit-Menge, die beim ersten Start des Geräts generiert und gespeichert wird. Es wird zurückgesetzt, wenn das Gerät gelöscht wird.

Android_ID scheint eine gute Wahl für eine eindeutige Gerätekennung zu sein. Es gibt Nachteile: Erstens ist es bei Releases von Android vor 2.2 nicht zu 100% zuverlässig. (“Froyo”). Außerdem gab es in einem beliebten Mobilteil eines großen Herstellers, bei dem jede Instanz die gleiche Android_ID hat, mindestens einen weit verbreiteten Fehler.

6
mumu123

Ich verwende den folgenden Code, um die Variable IMEI abzurufen, oder verwende Secure .Android_ID, wenn das Gerät keine Telefonfunktionen besitzt:

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);
6
Asaf Pinhassi

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 - Die Generierung erfolgt basierend auf den physischen Gerätespezifikationen
Android_ID - Settings.Secure.Android_ID
Bluetooth-Adresse - Bluetooth-Adapteradresse

Es wird etwas wie folgt zurückgegeben: 551F27C060712A72730B0A0F734064B1

Hinweis: Sie können der longId-Zeichenfolge 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 "";
}

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.

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

6
Ilan.b

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 auch 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, dass diese 1-3 Sekunden ein Ärgernis sein können (abhängig von Ihrer App natürlich).

5
Tom

Android-Geräte-MAC-ID ist auch eine eindeutige ID. Sie wird nicht geändert, wenn Sie das Gerät selbst formatieren, indem Sie den folgenden Code verwenden, um die Mac-ID zu erhalten

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

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 gibt die Android-ID als eindeutigen 64-Bit-Hex-String zurück.

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

Google hat jetzt eine Werbe-ID .
Dies kann auch verwendet werden, beachten Sie jedoch Folgendes:

Die Werbe-ID ist eine benutzerspezifische, eindeutige, rücksetzbare ID 

und

benutzer können ihre Kennung zurücksetzen oder interessensbasierte Anzeigen in Google Play-Apps deaktivieren.

Obwohl sich diese ID ändern kann, scheint es so, als würde bald wir haben keine Wahl , sie hängt vom Zweck dieser ID ab.

Mehr Infos unter develper.Android

Code hier einfügen

HTH

4

1.Sie können auf die Android-Geräte-ID per gms-Dienst zugreifen. siehe das gegebene Beispiel unten,

private DeviceInfoProvider mDeviceInfo = new DeviceInfoProvider(Context)
String mDeviceId = DeviceInfoProvider.getDeviceId(Context);
Log.d("DEVICE_ID" , mDeviceId);

2.Verwenden Sie den Telefonie-Manager, der eine eindeutige ID bereitstellt (d. H. IMEI). Siehe das Beispiel

import Android.telephony.TelephonyManager;
import Android.content.Context;
// ...
TelephonyManager telephonyManager;
telephonyManager = (TelephonyManager) getSystemService(Context.
                TELEPHONY_SERVICE);
/*
* getDeviceId() returns the unique device ID.
* For example,the IMEI for GSM and the MEID or ESN for CDMA phones.
*/
String deviceId = telephonyManager.getDeviceId();
/*
* getSubscriberId() returns the unique subscriber ID,
*/
String subscriberId = telephonyManager.getSubscriberId();

Dies erfordert, dass Android.permission.READ_PHONE_STATE für Ihren Benutzer erforderlich ist, was sich aufgrund der von Ihnen erstellten Anwendung nur schwer rechtfertigen lässt.

  1. Geräte ohne Telefoniedienste wie Tablets müssen eine eindeutige Geräte-ID melden, die seit Android 2.3 Gingerbread über Android.os.Build.SERIAL verfügbar ist. Einige Telefone mit Telefondiensten können auch eine Seriennummer definieren. Da nicht alle Android-Geräte eine Seriennummer haben, ist diese Lösung nicht zuverlässig.

  2. Beim ersten Booten eines Geräts wird ein Zufallswert generiert und gespeichert. Dieser Wert ist über Settings.Secure.Android_ID verfügbar. Es ist eine 64-Bit-Zahl, die für die Lebensdauer eines Geräts konstant bleiben sollte. Android_ID scheint eine gute Wahl für eine eindeutige Gerätekennung zu sein, da sie für Smartphones und Tablets verfügbar ist. Um den Wert abzurufen, können Sie den folgenden Code verwenden:

    String androidId = Settings.Secure.getString (getContentResolver (), Settings.Secure.Android_ID);

Der Wert kann sich jedoch ändern, wenn das Gerät auf die Werkseinstellungen zurückgesetzt wird. Es ist auch ein bekannter Fehler mit einem beliebten Mobiltelefon eines Herstellers bekannt, bei dem jede Instanz die gleiche Android_ID hat. Natürlich ist die Lösung nicht zu 100% zuverlässig.

  1. Verwenden Sie die UUID. Da für die meisten Anwendungen eine bestimmte Installation und kein physisches Gerät erforderlich ist, ist dies eine gute Lösung, um die eindeutige ID eines Benutzers zu erhalten, wenn die UUID-Klasse verwendet wird. Die folgende Lösung wurde von Reto Meier von Google in einer Google I/O-Präsentation präsentiert:

SharedPreferences sharedPrefs = context.getSharedPreferences( PREF_UNIQUE_ID, Context.MODE_PRIVATE); uniqueID = sharedPrefs.getString(PREF_UNIQUE_ID, null);

4
Kiran Maniya

Nicht zu empfehlen, da deviceId als Tracking in fremden Händen verwendet werden kann.

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

Ich bin vor einigen Jahren auf diese Frage gestoßen und habe gelernt, eine verallgemeinerte Lösung zu implementieren, die auf verschiedenen Antworten basiert.

Ich habe die verallgemeinerte Lösung seit mehreren Jahren in einem realen Produkt verwendet. Es dient mir bisher sehr gut. Hier ist der Code-Ausschnitt, der auf verschiedenen Antworten basiert.

Beachten Sie, dass getEmail die meiste Zeit null zurückgibt, da wir nicht explizit um Erlaubnis gefragt haben.

private static UniqueId getUniqueId() {
    MyApplication app = MyApplication.instance();

    // Our prefered method of obtaining unique id in the following order.
    // (1) Advertising id
    // (2) Email
    // (2) Android_ID
    // (3) Instance ID - new id value, when reinstall the app.

    ////////////////////////////////////////////////////////////////////////////////////////////
    // ADVERTISING ID
    ////////////////////////////////////////////////////////////////////////////////////////////
    AdvertisingIdClient.Info adInfo = null;
    try {
        adInfo = AdvertisingIdClient.getAdvertisingIdInfo(app);
    } catch (IOException e) {
        Log.e(TAG, "", e);
    } catch (GooglePlayServicesNotAvailableException e) {
        Log.e(TAG, "", e);
    } catch (GooglePlayServicesRepairableException e) {
        Log.e(TAG, "", e);
    }

    if (adInfo != null) {
        String aid = adInfo.getId();
        if (!Utils.isNullOrEmpty(aid)) {
            return UniqueId.newInstance(aid, UniqueId.Type.aid);
        }
    }

    ////////////////////////////////////////////////////////////////////////////////////////////
    // EMAIL
    ////////////////////////////////////////////////////////////////////////////////////////////
    final String email = Utils.getEmail();
    if (!Utils.isNullOrEmpty(email)) {
        return UniqueId.newInstance(email, UniqueId.Type.eid);
    }

    ////////////////////////////////////////////////////////////////////////////////////////////
    // Android ID
    ////////////////////////////////////////////////////////////////////////////////////////////
    final String sid = Settings.Secure.getString(app.getContentResolver(), Settings.Secure.Android_ID);
    if (!Utils.isNullOrEmpty(sid)) {
        return UniqueId.newInstance(sid, UniqueId.Type.sid);
    }

    ////////////////////////////////////////////////////////////////////////////////////////////
    // INSTANCE ID
    ////////////////////////////////////////////////////////////////////////////////////////////
    final String iid = com.google.Android.gms.iid.InstanceID.getInstance(MyApplication.instance()).getId();
    if (!Utils.isNullOrEmpty(iid)) {
        return UniqueId.newInstance(iid, UniqueId.Type.iid);
    }

    return null;
}

public final class UniqueId implements Parcelable {
    public enum Type implements Parcelable {
        aid,
        sid,
        iid,
        eid;

        ////////////////////////////////////////////////////////////////////////////
        // Handling Parcelable nicely.

        public static final Parcelable.Creator<Type> CREATOR = new Parcelable.Creator<Type>() {
            public Type createFromParcel(Parcel in) {
                return Type.valueOf(in.readString());
            }

            public Type[] newArray(int size) {
                return new Type[size];
            }
        };

        @Override
        public int describeContents() {
            return 0;
        }

        @Override
        public void writeToParcel(Parcel parcel, int flags) {
            parcel.writeString(this.name());
        }

        // Handling Parcelable nicely.
        ////////////////////////////////////////////////////////////////////////////
    }

    public static boolean isValid(UniqueId uniqueId) {
        if (uniqueId == null) {
            return false;
        }
        return uniqueId.isValid();
    }

    private boolean isValid() {
        return !org.yccheok.jstock.gui.Utils.isNullOrEmpty(id) && type != null;
    }

    private UniqueId(String id, Type type) {
        if (org.yccheok.jstock.gui.Utils.isNullOrEmpty(id) || type == null) {
            throw new Java.lang.IllegalArgumentException();
        }
        this.id = id;
        this.type = type;
    }

    public static UniqueId newInstance(String id, Type type) {
        return new UniqueId(id, type);
    }

    @Override
    public int hashCode() {
        int result = 17;
        result = 31 * result + id.hashCode();
        result = 31 * result + type.hashCode();
        return result;
    }

    @Override
    public boolean equals(Object o) {
        if (o == this) {
            return true;
        }

        if (!(o instanceof UniqueId)) {
            return false;
        }

        UniqueId uniqueId = (UniqueId)o;
        return this.id.equals(uniqueId.id) && this.type == uniqueId.type;
    }

    @Override
    public String toString() {
        return type + ":" + id;
    }

    ////////////////////////////////////////////////////////////////////////////
    // Handling Parcelable nicely.

    public static final Parcelable.Creator<UniqueId> CREATOR = new Parcelable.Creator<UniqueId>() {
        public UniqueId createFromParcel(Parcel in) {
            return new UniqueId(in);
        }

        public UniqueId[] newArray(int size) {
            return new UniqueId[size];
        }
    };

    private UniqueId(Parcel in) {
        this.id = in.readString();
        this.type = in.readParcelable(Type.class.getClassLoader());
    }

    @Override
    public int describeContents() {
        return 0;
    }

    @Override
    public void writeToParcel(Parcel parcel, int flags) {
        parcel.writeString(this.id);
        parcel.writeParcelable(this.type, 0);
    }

    // Handling Parcelable nicely.
    ////////////////////////////////////////////////////////////////////////////

    public final String id;
    public final Type type;
}

public static String getEmail() {
    Pattern emailPattern = Patterns.EMAIL_ADDRESS; // API level 8+
    AccountManager accountManager = AccountManager.get(MyApplication.instance());
    Account[] accounts = accountManager.getAccountsByType("com.google");
    for (Account account : accounts) {
        if (emailPattern.matcher(account.name).matches()) {
            String possibleEmail = account.name;
            return possibleEmail;
        }
    }

    accounts = accountManager.getAccounts();
    for (Account account : accounts) {
        if (emailPattern.matcher(account.name).matches()) {
            String possibleEmail = account.name;
            return possibleEmail;
        }
    }

    return null;
} 
2
Cheok Yan Cheng

Hier ist eine einfache Antwort, um AAID zu erhalten. Funktioniert ordnungsgemäß Juni 2019

 AsyncTask<Void, Void, String> task = new AsyncTask<Void, Void, String>() {
        @Override
        protected String doInBackground(Void... params) {
            String token = null;
            Info adInfo = null;
            try {
                adInfo = AdvertisingIdClient.getAdvertisingIdInfo(getApplicationContext());
            } catch (IOException e) {
                // ...
            } catch ( GooglePlayServicesRepairableException e) {
                // ...
            } catch (GooglePlayServicesNotAvailableException e) {
                // ...
            }
            String Android_id = adInfo.getId();
            Log.d("DEVICE_ID",Android_id);

            return Android_id;
        }

        @Override
        protected void onPostExecute(String token) {
            Log.i(TAG, "DEVICE_ID Access token retrieved:" + token);
        }

    };
    task.execute();

lesen Sie die vollständige Antwort im Detail hier :

2
Raj

Um die verfügbaren eindeutigen IDs in Android-Geräten zu verstehen. Verwenden Sie diese offizielle Anleitung.

Best Practices für eindeutige Bezeichner:

IMEI, Mac-Adressen, Instanz-ID, GUIDs, SSAID, Werbe-ID, Sicherheitsnetz-API zur Überprüfung von Geräten.

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

2
Waheed Nazir

Nur ein Kopf für alle, die nach aktuellen Informationen suchen. Bei Android O gibt es einige Änderungen, wie das System diese IDs verwaltet. 

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

tl; dr Serial erfordert die Erlaubnis zum TELEFON und die Android-ID ändert sich je nach Paketname und Signatur für verschiedene Apps.

Und auch Google hat ein Nizza-Dokument zusammengestellt, das Vorschläge zur Verwendung der Hardware- und Software-IDs enthält.

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

1
wrecker

Normalerweise verwende ich eine eindeutige Geräte-ID für meine Apps. Aber irgendwann benutze ich IMEI. Beide sind eindeutige Zahlen.

IMEI(internationale Kennung für mobile Geräte)

public String getIMEI(Activity activity) {
    TelephonyManager telephonyManager = (TelephonyManager) activity
            .getSystemService(Context.TELEPHONY_SERVICE);
    return telephonyManager.getDeviceId();
}

eindeutige ID des Geräts erhalten

public String getDeviceUniqueID(Activity activity){
    String device_unique_id = Secure.getString(activity.getContentResolver(),
            Secure.Android_ID);
    return device_unique_id;
}
1
Zin Win Htet

Seriennummer ist eine eindeutige Geräte-ID, die über Android.os.Build.SERIAL verfügbar ist.

public static String getSerial() {
    String serial = "";
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O){
        serial = Build.getSerial();
    }else{ 
        serial = Build.SERIAL;    
    }
    return serial;
}

Stellen Sie sicher, dass Sie über die Berechtigung READ_PHONE_STATE verfügen, bevor Sie getSerial () aufrufen.

NOTE: - Es ist Nicht verfügbar bei Geräten ohne Telefonie (wie nur WLAN-Tablets).

1
Shivam Agrawal

Um eine Benutzer-ID zu erhalten, können Sie die Google Play-Lizenzbibliothek verwenden.

Um diese Bibliothek herunterzuladen, öffnen Sie den SDK Manager => SDK Tools. Der Pfad zu heruntergeladenen Bibliotheksdateien lautet:

path_to_Android_sdk_on_your_pc/extras/google/market_licensing/library

Binden Sie die Bibliothek in Ihr Projekt ein (Sie können die Dateien einfach kopieren).

Als nächstes benötigen Sie eine Implementierung der Schnittstelle Policy (Sie können einfach eine von zwei Dateien aus der Bibliothek verwenden: ServerManagedPolicy oder StrictPolicy).

Die Benutzer-ID wird für Sie in der Funktion processServerResponse() bereitgestellt:

public void processServerResponse(int response, ResponseData rawData) {
    if(rawData != null) {
        String userId = rawData.userId
        // use/save the value
    }
    // ...
}

Als nächstes müssen Sie LicenseChecker mit einer Richtlinie konstruieren und die Funktion checkAccess() aufrufen. Verwenden Sie MainActivity.Java als Beispiel dafür. MainActivity.Java befindet sich in diesem Ordner:

path_to_Android_sdk_on_your_pc/extras/google/market_licensing/sample/src/com/example/Android/market/licensing

Vergessen Sie nicht, Ihrem AndroidManifest.xml die Berechtigung CHECK_LICENSE hinzuzufügen.

Weitere Informationen zur Lizenzbibliothek: https://developer.Android.com/google/play/licensing

0
String SERIAL_NUMER = Build.SERIAL;

Gibt SERIAL NUMBER als String zurück, der in jedem Gerät eindeutig ist. 

0
Jeffy

Um Android 9 zu integrieren, habe ich nur eine Idee, die noch funktionieren könnte, die (wahrscheinlich) keine Begriffe verletzt, Berechtigungen erfordert und über Installationen und Apps hinweg funktioniert. 

Fingerprinting, an dem ein Server beteiligt ist, sollte in der Lage sein, ein Gerät eindeutig zu identifizieren. Die Kombination von Hardwareinformationen + installierten Apps und die Installationszeiten sollten den Trick erfüllen. Die ersten Installationszeiten ändern sich nicht, es sei denn, eine App wird deinstalliert und erneut installiert. Dies müsste jedoch für alle Apps auf dem Gerät erfolgen, um das Gerät nicht identifizieren zu können (dh nach einem Werksreset). 

So würde ich es machen:

  1. Extrahieren Sie Hardwareinformationen, Anwendungspaketnamen und erste Installationszeiten. 

So extrahieren Sie alle Anwendungen von Android (keine Berechtigungen erforderlich):

final PackageManager pm = application.getPackageManager();
List<ApplicationInfo> packages = 
pm.getInstalledApplications(PackageManager.GET_META_DATA);

for (ApplicationInfo packageInfo : packages) {
    try {
        Log.d(TAG, "Installed package :" + packageInfo.packageName);
        Log.d(TAG, "Installed :" + pm.getPackageInfo(packageInfo.packageName, 0).firstInstallTime);
    } catch (PackageManager.NameNotFoundException e) {
        e.printStackTrace();
    }
}
  1. Möglicherweise möchten Sie einen Hashwert für jede Kombination aus Paketname und Installationszeitstempel erstellen, bevor Sie sie an den Server senden, da dies möglicherweise zu Ihrem Unternehmen gehört oder nicht, was der Anwender auf dem Gerät installiert hat.
  2. Einige Apps (sehr viele) sind System-Apps. Diese haben wahrscheinlich den gleichen Installationszeitstempel und entsprechen dem neuesten Systemupdate nach einem Werksreset. Da sie denselben Installationszeitstempel haben, können sie vom Benutzer nicht installiert und herausgefiltert werden.
  3. Senden Sie die Informationen an den Server und lassen Sie sie unter den zuvor gespeicherten Informationen nach der nächsten Übereinstimmung suchen. Sie müssen einen Grenzwert festlegen, wenn Sie mit zuvor gespeicherten Geräteinformationen vergleichen, während Apps installiert und deinstalliert werden. Ich vermute jedoch, dass dieser Schwellenwert sehr niedrig sein kann, da jede Kombination aus Paketname und erstmaliger Installationstempo für ein Gerät ziemlich eindeutig ist und Apps nicht so häufig installiert und deinstalliert werden. Mehrere Apps erhöhen die Wahrscheinlichkeit, einzigartig zu sein. 
  4. Geben Sie die generierte eindeutige ID für die Übereinstimmung zurück, oder generieren Sie eine eindeutige ID, speichern Sie die Geräteinformationen und geben Sie diese neue ID zurück.

NB: Dies ist eine nicht getestete und nicht bewährte Methode! Ich bin zuversichtlich, dass es funktionieren wird, aber ich bin auch ziemlich sicher, dass sie es auf die eine oder andere Weise schließen werden. 

0
Jens Vesti

Rufen Sie die Geräte-ID nur einmal ab und speichern Sie sie in einer Datenbank oder Datei. Wenn dies der erste Start der App ist, generiert sie in diesem Fall eine ID und speichert sie. Beim nächsten Mal wird nur die in der Datei gespeicherte ID verwendet.

0
El Jazouli

Wenn Sie hinzufügen:

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

Android Lint gibt folgende Warnung aus:

Die Verwendung von getString zum Abrufen von Gerätekennungen wird nicht empfohlen. Inspektionsinfo: Die Verwendung dieser Gerätekennungen wird nicht empfohlen, es sei denn, es handelt sich um hochwertige Betrugspräventions- und erweiterte Telefonie-Anwendungsfälle. Verwenden Sie für Anwendungsfälle für Werbung AdvertisingIdClient $ Info # getId und für Analysen InstanceId # getId.

Sie sollten dies also vermeiden.

Wie in der Dokumentation für Android-Entwickler erwähnt:

1: Verwenden Sie keine Hardware-IDs.

In den meisten Anwendungsfällen können Sie die Verwendung von Hardware-IDs wie SSAID (Android ID) und IMEI vermeiden, ohne die erforderliche Funktionalität einzuschränken.

2: Verwenden Sie eine Werbe-ID nur für Nutzerprofile oder Anzeigenanwendungsfälle.

Berücksichtigen Sie bei der Verwendung einer Werbe-ID immer die Auswahl der Nutzer in Bezug auf das Anzeigen-Tracking. Stellen Sie außerdem sicher, dass die Kennung nicht mit personenbezogenen Daten (PII) verbunden werden kann, und vermeiden Sie die Überbrückung von Zurücksetzungen von Werbe-IDs.

3: Verwenden Sie nach Möglichkeit eine Instanz-ID oder eine privat gespeicherte GUID für alle anderen Anwendungsfälle, mit Ausnahme der Prävention von Zahlungsbetrug und der Telefonie.

Für die allermeisten Anwendungsfälle von Nichtanzeigen sollte eine Instanz-ID oder GUID ausreichend sein.

4: Verwenden Sie APIs, die für Ihren Anwendungsfall geeignet sind, um das Datenschutzrisiko zu minimieren.

Verwenden Sie die DRM-API für den Schutz hochwertiger Inhalte und die SafetyNet-APIs für den Schutz vor Missbrauch. Mit den SafetyNet-APIs können Sie am einfachsten feststellen, ob ein Gerät echt ist, ohne dass ein Datenschutzrisiko besteht.

0
Malwinder Singh

Der Vollständigkeit halber können Sie die Id in Xamarin.Android und C # erhalten:

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

Oder wenn Sie sich nicht innerhalb einer Activity befinden:

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

Wobei context im Kontext übergeben wird.

0
Martin Zikmund