Domanda C'è un ID univoco del dispositivo Android?


I dispositivi Android dispongono di un ID univoco e, in tal caso, qual è un modo semplice per accedervi utilizzando Java?


2308
2018-05-07 00:47


origine


risposte:


Settings.Secure#ANDROID_ID restituisce l'ID Android come un unico per ogni utente Stringa esadecimale a 64 bit.

import android.provider.Settings.Secure;

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

1696
2018-05-07 00:49



AGGIORNARE: A partire dalle versioni recenti di Android, molti dei problemi con ANDROID_ID sono stati risolti e credo che questo approccio non sia più necessario. Si prega di dare un'occhiata a La risposta di Anthony.

Divulgazione completa: la mia app ha utilizzato inizialmente l'approccio sottostante, ma non utilizza più questo approccio e ora utilizziamo l'approccio delineato nel Blog degli sviluppatori Android voce che La risposta di emmby collegamenti a (ovvero, generare e salvare a UUID#randomUUID()).


Ci sono molte risposte a questa domanda, molte delle quali funzioneranno solo "alcune" volte, e sfortunatamente non è abbastanza buona.

In base ai miei test sui dispositivi (tutti i telefoni, almeno uno dei quali non è attivato):

  1. Tutti i dispositivi testati hanno restituito un valore per TelephonyManager.getDeviceId()
  2. Tutti i dispositivi GSM (tutti testati con una SIM) hanno restituito un valore per TelephonyManager.getSimSerialNumber()
  3. Tutti i dispositivi CDMA hanno restituito null per getSimSerialNumber() (come previsto)
  4. Tutti i dispositivi con un account Google aggiunto hanno restituito un valore per ANDROID_ID
  5. Tutti i dispositivi CDMA hanno restituito lo stesso valore (o la derivazione dello stesso valore) per entrambi ANDROID_ID e TelephonyManager.getDeviceId() - fintanto che un account Google è stato aggiunto durante l'installazione.
  6. Non avevo ancora la possibilità di provare i dispositivi GSM senza SIM, dispositivo GSM senza account Google aggiunto o nessuno dei dispositivi in ​​modalità aereo.

Quindi se vuoi qualcosa di unico per il dispositivo stesso, TM.getDeviceId()  dovrebbero essere sufficiente Ovviamente alcuni utenti sono più paranoici di altri, quindi potrebbe essere utile usare l'hash 1 o più di questi identificatori, in modo che la stringa sia ancora virtualmente unica per il dispositivo, ma non identifichi esplicitamente il dispositivo reale dell'utente. Ad esempio, utilizzando String.hashCode(), combinato con un UUID:

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

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

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

potrebbe risultare in qualcosa di simile: 00000000-54b3-e7c7-0000-000046bffd97

Funziona abbastanza bene per me.

Come dice di seguito Richard, non dimenticare che hai bisogno del permesso di leggere il TelephonyManager proprietà, quindi aggiungi questo al tuo manifest:

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

librerie di importazione

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

1055
2018-05-17 22:12



Ultimo aggiornamento: 6/2/15


Dopo aver letto tutti i post di Stack Overflow sulla creazione di un ID univoco, il blog degli sviluppatori di Google e la documentazione di Android, mi sembra che lo "Pseudo ID" sia la migliore opzione possibile.

Problema principale: hardware vs software

Hardware

  • Gli utenti possono cambiare hardware, tablet Android o telefono, quindi gli ID univoci basati sull'hardware non sono buone idee UTENTI DI TRACKING
  • Per HARDWARE DI TRACKING, Questa è una grande idea

Software

  • Gli utenti possono cancellare / modificare la propria ROM se sono rootati
  • Puoi tenere traccia degli utenti su piattaforme diverse (iOS, Android, Windows e Web)
  • Il migliore vuole TRACCIA UN UTENTE INDIVIDUALE con i loro consenso è quello di avere semplicemente il login (rendilo trasparente usando OAuth)

Ripartizione generale con Android

- Garantire univocità (includere dispositivi rooted) per API> = 9/10 (99,5% dei dispositivi Android)

- Nessuna autorizzazione aggiuntiva

Codice Psuedo:

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

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

else

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

Grazie a @stansult per la pubblicazione tutte le nostre opzioni (in questa domanda sull'overflow dello stack).

Elenco di opzioni - ragioni per le quali / perché non usarle:

  • Email dell'utente - Software

    • L'utente potrebbe cambiare email - ALTAMENTE improbabile
    • API 5+ <uses-permission android:name="android.permission.GET_ACCOUNTS" /> o
    • API 14+ <uses-permission android:name="android.permission.READ_PROFILE" />  <uses-permission android:name="android.permission.READ_CONTACTS" /> (Come ottenere l'indirizzo e-mail principale del dispositivo Android)
  • Numero di telefono dell'utente - Software

    • Gli utenti possono cambiare i numeri di telefono - ALTAMENTE improbabile
    • <uses-permission android:name="android.permission.READ_PHONE_STATE" />
  • IMEI - Hardware (solo telefoni, bisogni android.permission.READ_PHONE_STATE)

    • La maggior parte degli utenti odia il fatto che nell'autorizzazione sia indicato "Telefonate". Alcuni utenti danno valutazioni errate, perché credono che stai semplicemente rubando le loro informazioni personali, quando tutto ciò che vuoi veramente è monitorare le installazioni dei dispositivi. È ovvio che stai raccogliendo dati.
    • <uses-permission android:name="android.permission.READ_PHONE_STATE" />
  • ID Android - Hardware (può essere nullo, può cambiare al reset di fabbrica, può essere modificato su un dispositivo rooted)

    • Dal momento che può essere 'null', possiamo controllare 'null' e cambiarne il valore, ma questo significa che non sarà più univoco.
    • Se si dispone di un utente con un dispositivo di ripristino di fabbrica, il valore potrebbe essere stato modificato o modificato sul dispositivo rooted in modo che possano essere presenti voci duplicate se si monitorano le installazioni utente.
  • Indirizzo MAC WLAN - Hardware (esigenze android.permission.ACCESS_WIFI_STATE)

    • Questa potrebbe essere la seconda opzione migliore, ma stai ancora raccogliendo e memorizzando un identificatore univoco che proviene direttamente da un utente. Questo è ovvio che stai raccogliendo dati.
    • <uses-permission android:name="android.permission.ACCESS_WIFI_STATE "/>
  • Indirizzo MAC Bluetooth - Hardware (dispositivi con Bluetooth, esigenze android.permission.BLUETOOTH)

    • La maggior parte delle applicazioni sul mercato non usa il Bluetooth, quindi se l'applicazione non usa il Bluetooth e questo è incluso, l'utente potrebbe diventare sospetto.
    • <uses-permission android:name="android.permission.BLUETOOTH "/>
  • ID Pseudo-Univoco - Software (per tutti i dispositivi Android)

    • Molto possibile, potrebbe contenere collisioni - Vedi il mio metodo pubblicato qui sotto!
    • Ciò ti consente di avere un ID "quasi unico" dall'utente senza prendere nulla di privato. Puoi creare il tuo ID anonimo dalle informazioni del dispositivo.

So che non esiste un modo "perfetto" per ottenere un ID univoco senza utilizzare le autorizzazioni; tuttavia, a volte abbiamo solo bisogno di monitorare l'installazione del dispositivo. Quando si tratta di creare un ID univoco, è possibile creare un 'ID pseudo unico' basato esclusivamente su informazioni che l'API di Android ci offre senza utilizzare autorizzazioni aggiuntive. In questo modo, possiamo mostrare rispetto all'utente e cercare di offrire anche una buona esperienza utente.

Con un id pseudo-univoco, ti imbatti solo nel fatto che potrebbero esserci duplicati in base al fatto che esistono dispositivi simili. Puoi modificare il metodo combinato per renderlo più unico; tuttavia, alcuni sviluppatori devono monitorare le installazioni dei dispositivi e questo farà il trucco o le prestazioni in base a dispositivi simili.

API> = 9:

Se il loro dispositivo Android è API 9 o superiore, questo è garantito per essere univoco a causa del campo "Build.SERIAL".

RICORDA, tecnicamente stai perdendo solo circa lo 0,5% degli utenti chi ha API <9. Quindi puoi concentrarti sul resto: questo è il 99,5% degli utenti!

API <9:

Se il dispositivo Android dell'utente è inferiore all'API 9; si spera che non abbiano fatto un reset di fabbrica e che il loro 'Secure.ANDROID_ID' sia conservato o non 'nullo'. (vedere http://developer.android.com/about/dashboards/index.html)

Se tutti gli altri falliscono:

Se tutto il resto fallisce, se l'utente ha un valore inferiore all'API 9 (inferiore a Gingerbread), ha ripristinato il proprio dispositivo o "Secure.ANDROID_ID" restituisce "null", quindi semplicemente l'ID restituito si baserà esclusivamente sulle informazioni del proprio dispositivo Android. Questo è dove possono accadere le collisioni.

I cambiamenti:

  • Rimosso "Android.SECURE_ID" a causa di ripristini di fabbrica potrebbe causare la modifica del valore
  • Modificato il codice da cambiare su API
  • Modificato lo pseudo

Si prega di dare un'occhiata al metodo qui sotto:

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

Novità (per app con annunci AND Google Play Services):

Dalla console dello sviluppatore di Google Play:

A partire dal 1 ° agosto 2014, le Norme del programma per gli sviluppatori di Google Play   richiede che tutti i nuovi caricamenti e gli aggiornamenti delle app utilizzino l'ID pubblicità in   qualsiasi altro identificatore persistente per scopi pubblicitari.   Per saperne di più

Implementazione:

Autorizzazione:

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

Codice:

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

Fonte / Documenti:

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

Importante:

È inteso che l'ID pubblicità sostituisca completamente esistente   utilizzo di altri identificatori per scopi pubblicitari (come l'uso di ANDROID_ID   in Settings.Secure) quando Google Play Services è disponibile. casi   dove Google Play Services non è disponibile sono indicati da a   GooglePlayServicesNotAvailableException lanciata da   getAdvertisingIdInfo ().

Attenzione, gli utenti possono ripristinare:

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

Ho provato a fare riferimento a ogni link da cui ho preso informazioni. Se ti manca e devi essere incluso, per favore commenta!

ID istanza di Google Player Services

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


363
2017-07-12 23:58



Come dice Dave Webb, il Il Blog degli sviluppatori Android ha un articolo che copre questo. La loro soluzione preferita è quella di tenere traccia delle installazioni delle app piuttosto che dei dispositivi e che funzionerà bene per la maggior parte dei casi d'uso. Il post sul blog ti mostrerà il codice necessario per farlo funzionare e ti consiglio di verificarlo.

Tuttavia, il post del blog prosegue per discutere le soluzioni se è necessario un identificatore di dispositivo piuttosto che un identificativo di installazione dell'app. Ho parlato con qualcuno su Google per ottenere ulteriori chiarimenti su alcuni articoli nel caso in cui tu abbia bisogno di farlo. Ecco cosa ho scoperto sugli identificatori dei dispositivi che NON sono menzionati nel post di blog di cui sopra:

  • ANDROID_ID è l'identificatore di dispositivo preferito. ANDROID_ID è perfettamente affidabile sulle versioni di Android <= 2.1 o> = 2.3. Solo 2.2 ha i problemi menzionati nel post.
  • Diversi dispositivi di diversi produttori sono interessati dal bug ANDROID_ID in 2.2.
  • Per quanto sono stato in grado di determinare, tutti i dispositivi interessati hanno lo stesso ANDROID_ID, che è 9774d56d682e549c. Che è anche lo stesso id del dispositivo segnalato dall'emulatore, btw.
  • Google ritiene che gli OEM abbiano patchato il problema per molti o molti dei loro dispositivi, ma sono stato in grado di verificare che dall'inizio di aprile 2011, almeno, è ancora abbastanza facile trovare dispositivi con ANDROID_ID danneggiato.

Sulla base dei consigli di Google, ho implementato una classe che genererà un UUID univoco per ciascun dispositivo, utilizzando ANDROID_ID come seed, ove appropriato, ricadendo su TelephonyManager.getDeviceId () se necessario, e in caso contrario, ricorrendo a un UUID univoco generato casualmente persistente attraverso i riavvii dell'app (ma non le re-installazioni delle app).

Si noti che per i dispositivi che devono effettuare il fallback sull'ID del dispositivo, l'ID univoco VOLERE persistere tra i ripristini di fabbrica. Questo è qualcosa di cui essere consapevoli. Se è necessario assicurarsi che il ripristino dei dati di fabbrica ripristini il proprio ID univoco, è consigliabile considerare di ricadere direttamente sull'UUID casuale anziché sull'ID del dispositivo.

Ancora una volta, questo codice è per un ID dispositivo, non un ID installazione app. Per la maggior parte delle situazioni, un ID di installazione dell'app è probabilmente quello che stai cercando. Ma se hai bisogno di un ID dispositivo, il seguente codice funzionerà probabilmente per te.

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

314
2018-04-11 19:06



Ecco il codice che Reto Meier ha usato nel Google I / O presentazione di quest'anno per ottenere un ID univoco per l'utente:

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

Se si accoppia questo con una strategia di backup per inviare le preferenze al cloud (anche descritto in Reto's parlare, dovresti avere un ID che si lega a un utente e resta in agguato dopo che il dispositivo è stato cancellato, o addirittura sostituito. Ho intenzione di usare questo in analitica andando avanti (in altre parole, non ho ancora fatto quel po ':).


165
2017-10-28 13:19



Inoltre, potresti prendere in considerazione l'indirizzo MAC dell'adattatore Wi-Fi. Recuperato così:

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

Richiede l'autorizzazione android.permission.ACCESS_WIFI_STATE nel manifest.

Segnalato per essere disponibile anche quando il Wi-Fi non è connesso. Se Joe dalla risposta sopra dà questa prova sui suoi molti dispositivi, sarebbe carino.

Su alcuni dispositivi, non è disponibile quando il Wi-Fi è disattivato.

NOTA: Da Android 6.x, restituisce l'indirizzo mac falso coerente: 02:00:00:00:00:00


97
2018-06-23 14:27



Ci sono informazioni piuttosto utili Qui.

Comprende cinque diversi tipi di ID:

  1. IMEI (solo per dispositivi Android con utilizzo del telefono; necessità android.permission.READ_PHONE_STATE)
  2. ID Pseudo-Univoco (per tutti i dispositivi Android)
  3. ID Android (può essere nullo, può cambiare al reset di fabbrica, può essere modificato sul telefono root)
  4. Indirizzo MAC WLAN stringa (esigenze android.permission.ACCESS_WIFI_STATE)
  5. Indirizzo MAC BT stringa (dispositivi con Bluetooth, esigenze android.permission.BLUETOOTH)

77
2018-02-08 02:16



Il blog ufficiale degli sviluppatori Android ora ha un articolo completo proprio su questo argomento, Identificazione delle installazioni di app.


43
2018-04-06 07:36



A Google I / O Reto Meier ha rilasciato una solida risposta su come affrontare questo aspetto che dovrebbe soddisfare la maggior parte degli sviluppatori per monitorare gli utenti attraverso le installazioni. Anthony Nolan mostra la direzione nella sua risposta, ma ho pensato di scrivere l'approccio completo in modo che gli altri possano vedere facilmente come farlo (mi ci è voluto un po 'per capire i dettagli).

Questo approccio ti fornirà un ID utente anonimo e sicuro che sarà persistente per l'utente su dispositivi diversi (basato sull'account Google principale) e su tutte le installazioni. L'approccio di base è generare un ID utente casuale e archiviarlo nelle preferenze condivise delle app. Successivamente, utilizzi l'agente di backup di Google per archiviare le preferenze condivise collegate all'account Google nel cloud.

Passiamo attraverso l'approccio completo. Per prima cosa, dobbiamo creare un backup per le nostre SharedPreferences utilizzando il servizio di backup Android. Inizia registrando la tua app tramite http://developer.android.com/google/backup/signup.html.

Google ti fornirà una chiave di servizio di backup che devi aggiungere al manifest. È inoltre necessario comunicare all'applicazione di utilizzare BackupAgent come segue:

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

Quindi è necessario creare l'agente di backup e dirgli di utilizzare l'agente di supporto per sharedpreferences:

public class MyBackupAgent extends BackupAgentHelper {
    // The name of the SharedPreferences file
    static final String PREFS = "user_preferences";

    // A key to uniquely identify the set of backup data
    static final String PREFS_BACKUP_KEY = "prefs";

    // Allocate a helper and add it to the backup agent
    @Override
    public void onCreate() {
        SharedPreferencesBackupHelper helper = new SharedPreferencesBackupHelper(this,          PREFS);
        addHelper(PREFS_BACKUP_KEY, helper);
    }
}

Per completare il backup è necessario creare un'istanza di BackupManager nella tua attività principale:

BackupManager backupManager = new BackupManager(context);

Infine crea un ID utente, se non esiste già, e memorizzalo in 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;
}

Questo User_ID sarà ora persistente attraverso le installazioni, anche se l'utente sposta il dispositivo.

Per ulteriori informazioni su questo approccio, vedere Le parole di Reto.

E per i dettagli completi su come implementare l'agente di backup, vedere Backup dei dati. Raccomando in particolare la sezione in fondo al testing poiché il backup non avviene istantaneamente e quindi per testare devi forzare il backup.


36
2017-12-22 08:13



Il seguente codice restituisce il numero di serie del dispositivo utilizzando un'API Android nascosta. Ma questo codice non funziona su Samsung Galaxy Tab perché "ro.serialno" non è impostato su questo dispositivo.

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
2018-01-25 02:39



Penso che questo sia un modo sicuro per costruire uno scheletro per un ID unico ... dai un'occhiata.

ID Pseudo-Unico, che funziona su tutti i dispositivi Android Alcuni dispositivi non hanno un telefono (ad esempio Tablet) o per qualche motivo, non si desidera includere l'autorizzazione READ_PHONE_STATE. È comunque possibile leggere i dettagli come la versione ROM, il nome del produttore, il tipo di CPU e altri dettagli hardware, che saranno adatti se si desidera utilizzare l'ID per un controllo della chiave seriale o per altri scopi generali. L'ID calcolato in questo modo non sarà univoco: è possibile trovare due dispositivi con lo stesso ID (basato sullo stesso hardware e immagine ROM) ma i cambiamenti nelle applicazioni del mondo reale sono trascurabili. A questo scopo puoi usare la classe Build:

String m_szDevIDShort = "35" + //we make this look like a valid IMEI
            Build.BOARD.length()%10+ Build.BRAND.length()%10 +
            Build.CPU_ABI.length()%10 + Build.DEVICE.length()%10 +
            Build.DISPLAY.length()%10 + Build.HOST.length()%10 +
            Build.ID.length()%10 + Build.MANUFACTURER.length()%10 +
            Build.MODEL.length()%10 + Build.PRODUCT.length()%10 +
            Build.TAGS.length()%10 + Build.TYPE.length()%10 +
            Build.USER.length()%10 ; //13 digits

La maggior parte dei membri di Build sono stringhe, quello che stiamo facendo qui è di prendere la loro lunghezza e trasformarla via modulo in una cifra. Abbiamo 13 cifre di questo tipo e ne aggiungiamo altre due nella parte anteriore (35) per avere lo stesso ID di dimensione dell'IMEI (15 cifre). Ci sono altre possibilità qui, state bene, date un'occhiata a queste stringhe. Restituisce qualcosa di simile 355715565309247. Non è richiesto alcun permesso speciale, rendendo questo approccio molto conveniente.


(Informazioni aggiuntive: la tecnica di cui sopra è stata copiata da un articolo su Pocket Magic.)


32
2018-03-24 19:55