Pregunta ¿Hay una identificación de dispositivo Android única?


¿Los dispositivos Android tienen una identificación única y, de ser así, cuál es una forma sencilla de acceder a ella utilizando Java?


2309
2018-05-07 00:47


origen


Respuestas:


Settings.Secure#ANDROID_ID devuelve la ID de Android como una único para cada usuario Cadena hexagonal de 64 bits.

import android.provider.Settings.Secure;

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

1697
2018-05-07 00:49



ACTUALIZAR: A partir de las versiones recientes de Android, muchos de los problemas con ANDROID_ID se han resuelto, y creo que este enfoque ya no es necesario. Por favor, eche un vistazo a La respuesta de Anthony.

Descripción completa: mi aplicación utilizó originalmente el enfoque siguiente, pero ya no usa este enfoque, y ahora usamos el enfoque descrito en el Blog de desarrolladores de Android entrada que la respuesta de emmby enlaces a (a saber, generar y guardar un UUID#randomUUID())


Hay muchas respuestas a esta pregunta, la mayoría de las cuales solo funcionarán "algunas" veces, y desafortunadamente eso no es lo suficientemente bueno.

Basado en mis pruebas de dispositivos (todos los teléfonos, al menos uno de los cuales no está activado):

  1. Todos los dispositivos probados arrojaron un valor para TelephonyManager.getDeviceId()
  2. Todos los dispositivos GSM (todos probados con una SIM) devolvieron un valor para TelephonyManager.getSimSerialNumber()
  3. Todos los dispositivos CDMA devueltos nulos para getSimSerialNumber() (como se esperaba)
  4. Todos los dispositivos con una cuenta de Google agregada devolvieron un valor para ANDROID_ID
  5. Todos los dispositivos CDMA devolvieron el mismo valor (o derivación del mismo valor) para ambos ANDROID_ID y TelephonyManager.getDeviceId() - Mientras una cuenta de Google ha sido agregada durante la instalación.
  6. Todavía no tuve la oportunidad de probar dispositivos GSM sin tarjeta SIM, un dispositivo GSM sin cuenta de Google agregada, o cualquiera de los dispositivos en modo avión.

Entonces, si quieres algo único para el dispositivo, TM.getDeviceId()  debería Ser suficiente. Obviamente, algunos usuarios son más paranoicos que otros, por lo que podría ser útil codificar uno o más de estos identificadores, de modo que la cadena siga siendo virtualmente única para el dispositivo, pero no identifique explícitamente el dispositivo real del usuario. Por ejemplo, usando String.hashCode(), combinado 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();

puede resultar en algo como: 00000000-54b3-e7c7-0000-000046bffd97

Funciona lo suficientemente bien para mí.

Como Richard menciona a continuación, no olvide que necesita permiso para leer el TelephonyManager propiedades, así que agregue esto a su manifiesto:

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

importar libs

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

1056
2018-05-17 22:12



Última actualización: 6/2/15


Después de leer todas las publicaciones de Stack Overflow sobre cómo crear una identificación única, el blog para desarrolladores de Google y la documentación de Android, siento que la "Pseudo ID" es la mejor opción posible.

Problema principal: Hardware vs Software

Hardware

  • Los usuarios pueden cambiar su hardware, tableta o teléfono Android, por lo que los ID únicos basados ​​en hardware no son buenas ideas para SEGUIMIENTO DE USUARIOS
  • por SEGUIMIENTO DE HARDWARE, esta es una gran idea

Software

  • Los usuarios pueden borrar / cambiar su ROM si están rooteados
  • Puede rastrear usuarios en todas las plataformas (iOS, Android, Windows y Web)
  • El mejor quiere SEGUIR CON UN USUARIO INDIVIDUAL con su consentimiento es simplemente hacer que inicien sesión (hacer esto sin problemas usando OAuth)

Desglose general con Android

- Garantía de exclusividad (incluye dispositivos rooteados) para API> = 9/10 (99.5% de dispositivos Android)

- Sin permisos extra

Código de 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)

Gracias a @stansult por publicar todas nuestras opciones (en esta pregunta sobre desbordamiento de pila).

Lista de opciones - razones por las cuales / por qué no usarlas:

  • Correo electrónico del usuario - Software

  • Número de teléfono del usuario - Software

    • Los usuarios pueden cambiar los números de teléfono: ALTAMENTE improbable
    • <uses-permission android:name="android.permission.READ_PHONE_STATE" />
  • IMEI - Hardware (solo teléfonos, necesidades android.permission.READ_PHONE_STATE)

    • La mayoría de los usuarios odian el hecho de que dice "Llamadas telefónicas" en el permiso. Algunos usuarios dan malas calificaciones, porque creen que simplemente estás robando su información personal, cuando todo lo que realmente quieres hacer es rastrear las instalaciones de los dispositivos. Es obvio que estás recopilando datos.
    • <uses-permission android:name="android.permission.READ_PHONE_STATE" />
  • Android ID - Hardware (puede ser nulo, puede cambiar al restablecer la configuración de fábrica, puede modificarse en un dispositivo rooteado)

    • Como puede ser 'nulo', podemos verificar 'nulo' y cambiar su valor, pero esto significa que ya no será único.
    • Si tiene un usuario con un dispositivo de restablecimiento de fábrica, es posible que el valor haya cambiado o modificado en el dispositivo rooteado, por lo que puede haber entradas duplicadas si realiza un seguimiento de las instalaciones de los usuarios.
  • WLAN MAC Address - Hardware (necesariamente android.permission.ACCESS_WIFI_STATE)

    • Esta podría ser la segunda mejor opción, pero aún está recopilando y almacenando un identificador único que proviene directamente de un usuario. Esto es obvio que estás recopilando datos.
    • <uses-permission android:name="android.permission.ACCESS_WIFI_STATE "/>
  • Dirección MAC Bluetooth - Hardware (dispositivos con Bluetooth, necesidades android.permission.BLUETOOTH)

    • La mayoría de las aplicaciones en el mercado no usan Bluetooth, por lo que si su aplicación no usa Bluetooth y usted está incluyendo esto, el usuario podría sospechar.
    • <uses-permission android:name="android.permission.BLUETOOTH "/>
  • Identificación Pseudo-Unique - Software (para todos los dispositivos Android)

    • Muy posible, puede contener colisiones - ¡Vea mi método publicado a continuación!
    • Esto le permite tener una identificación 'casi única' del usuario sin tomar nada que sea privado. Puede crear su propia identificación anónima a partir de la información del dispositivo.

Sé que no hay una forma "perfecta" de obtener un ID único sin usar permisos; sin embargo, a veces solo necesitamos seguir la instalación del dispositivo. Cuando se trata de crear una ID única, podemos crear una 'identificación pseudo única' basada únicamente en la información que nos proporciona la API de Android sin usar permisos adicionales. De esta manera, podemos mostrar respeto al usuario e intentar ofrecer una buena experiencia de usuario también.

Con una identificación pseudo-única, realmente solo se topa con el hecho de que puede haber duplicados basados ​​en el hecho de que hay dispositivos similares. Puede ajustar el método combinado para hacerlo más único; sin embargo, algunos desarrolladores necesitan rastrear las instalaciones del dispositivo y esto hará el truco o el rendimiento basado en dispositivos similares.

API> = 9:

Si su dispositivo Android es API 9 o superior, se garantiza que será único debido al campo 'Build.SERIAL'.

RECUERDA, técnicamente solo se está perdiendo alrededor del 0.5% de los usuarios quienes tienen API <9. Para que pueda centrarse en el resto: ¡Esto es el 99.5% de los usuarios!

API <9:

Si el dispositivo Android del usuario es inferior a API 9; con suerte, no han hecho un restablecimiento de fábrica y su 'Secure.ANDROID_ID' se conservará o no 'nulo'. (ver http://developer.android.com/about/dashboards/index.html)

Si todo lo demás falla:

Si todo lo demás falla, si el usuario tiene un API inferior a 9 (menor que Gingerbread), ha reiniciado su dispositivo o 'Secure.ANDROID_ID' devuelve 'nulo', entonces simplemente la ID devuelta estará basada únicamente en la información de su dispositivo Android. Aquí es donde pueden ocurrir las colisiones.

Cambios:

  • Se eliminó 'Android.SECURE_ID' debido a los restablecimientos de fábrica que podrían hacer que el valor cambie
  • Editado el código para cambiar en la API
  • Cambió el pseudo

Por favor, eche un vistazo al método a continuación:

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

Nuevo (para aplicaciones con anuncios Y servicios de Google Play):

Desde la consola del desarrollador de Google Play:

A partir del 1 de agosto de 2014, la política del programa para desarrolladores de Google Play   requiere que todas las cargas y actualizaciones nuevas de la aplicación utilicen la ID de publicidad en   lugar de cualquier otro identificador persistente para fines publicitarios.   Aprende más

Implementación:

Permiso:

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

Código:

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

Fuente / Documentos:

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

Importante:

Se pretende que el ID de publicidad reemplace completamente el   uso de otros identificadores con fines publicitarios (como el uso de ANDROID_ID)   en Settings.Secure) cuando Google Play Services está disponible. Casos   donde Google Play Services no está disponible están indicados por un   GooglePlayServicesNotAvailableException siendo lanzado por   getAdvertisingIdInfo ().

Advertencia, los usuarios pueden restablecer:

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

Intenté hacer referencia a todos los enlaces de los que obtuve información. Si falta y necesita ser incluido, ¡por favor coméntelo!

ID de instancia de servicios de Google Player

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


364
2017-07-12 23:58



Como Dave Webb menciona, el Android Developer Blog tiene un artículo eso cubre esto. Su solución preferida es rastrear instalaciones de aplicaciones en lugar de dispositivos, y eso funcionará bien para la mayoría de los casos de uso. La publicación del blog le mostrará el código necesario para que funcione, y le recomiendo que lo revise.

Sin embargo, la publicación del blog analiza las soluciones si necesita un identificador de dispositivo en lugar de un identificador de instalación de la aplicación. Hablé con alguien en Google para obtener una aclaración adicional sobre algunos artículos en caso de que necesite hacerlo. Esto es lo que descubrí sobre los identificadores de dispositivos que NO se mencionan en la publicación de blog mencionada anteriormente:

  • ANDROID_ID es el identificador de dispositivo preferido. ANDROID_ID es perfectamente confiable en las versiones de Android <= 2.1 o> = 2.3. Solo 2.2 tiene los problemas mencionados en la publicación.
  • Varios dispositivos de varios fabricantes se ven afectados por el error ANDROID_ID en 2.2.
  • Hasta donde he podido determinar, todos los dispositivos afectados tienen el mismo ANDROID_ID, cual es 9774d56d682e549c. Que también es el mismo ID de dispositivo informado por el emulador, por cierto.
  • Google cree que los OEM han solucionado el problema para muchos o la mayoría de sus dispositivos, pero pude verificar que, al menos hasta principios de abril de 2011, todavía es bastante fácil encontrar dispositivos que tengan el ANDROID_ID dañado.

En base a las recomendaciones de Google, implementé una clase que generará un UUID único para cada dispositivo, usando ANDROID_ID como semilla, donde sea apropiado, recurriendo a TelephonyManager.getDeviceId () según sea necesario, y si eso falla, recurriendo a un UUID único generado al azar esto se mantiene en todos los reinicios de la aplicación (pero no en las reinstalaciones de la aplicación).

Tenga en cuenta que para los dispositivos que tienen que retroceder en la identificación del dispositivo, la identificación única SERÁ persistir en restablecimientos de fábrica. Esto es algo de lo que debes estar consciente. Si necesita asegurarse de que un restablecimiento de fábrica restablecerá su ID única, le recomendamos que recurra directamente al UUID aleatorio en lugar de a la ID del dispositivo.

Nuevamente, este código es para una ID de dispositivo, no una ID de instalación de aplicación. En la mayoría de las situaciones, una ID de instalación de la aplicación es probablemente lo que estás buscando. Pero si necesita una identificación de dispositivo, entonces el siguiente código probablemente funcione para usted.

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



Aquí está el código que Reto Meier usó en el Google I / O presentación este año para obtener una identificación única para el usuario:

private static String uniqueID = null;
private static final String PREF_UNIQUE_ID = "PREF_UNIQUE_ID";

public synchronized static String id(Context context) {
    if (uniqueID == null) {
        SharedPreferences sharedPrefs = context.getSharedPreferences(
                PREF_UNIQUE_ID, Context.MODE_PRIVATE);
        uniqueID = sharedPrefs.getString(PREF_UNIQUE_ID, null);
        if (uniqueID == null) {
            uniqueID = UUID.randomUUID().toString();
            Editor editor = sharedPrefs.edit();
            editor.putString(PREF_UNIQUE_ID, uniqueID);
            editor.commit();
        }
    }
    return uniqueID;
}

Si combina esto con una estrategia de respaldo para enviar preferencias a la nube (también descrito en Reto's hablar, debe tener una identificación que se vincule con un usuario y se quede después de que el dispositivo se haya borrado o incluso reemplazado. Planeo usar esto en análisis en el futuro (en otras palabras, aún no he hecho eso :)


165
2017-10-28 13:19



También podría considerar la dirección MAC del adaptador de Wi-Fi. Obtenido así:

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

Requiere permiso android.permission.ACCESS_WIFI_STATE en el manifiesto

Se informa que está disponible incluso cuando el Wi-Fi no está conectado. Si Joe de la respuesta anterior le prueba a este en sus muchos dispositivos, estaría bien.

En algunos dispositivos, no está disponible cuando Wi-Fi está desactivado.

NOTA: Desde Android 6.x, devuelve una dirección de mac falsa consistente: 02:00:00:00:00:00


97
2018-06-23 14:27



Hay información bastante útil aquí.

Cubre cinco tipos de ID diferentes:

  1. IMEI (solo para dispositivos Android con uso de teléfono; android.permission.READ_PHONE_STATE)
  2. ID pseudo-único (para todos los dispositivos Android)
  3. ID de Android (puede ser nulo, puede cambiar al restablecer la configuración de fábrica, puede modificarse en el teléfono rooteado)
  4. WLAN MAC Dirección cuerda (necesidades) android.permission.ACCESS_WIFI_STATE)
  5. BT MAC Dirección cadena (dispositivos con Bluetooth, necesita android.permission.BLUETOOTH)

78
2018-02-08 02:16



El Blog oficial de Desarrolladores de Android ahora tiene un artículo completo sobre este mismo tema, Identificación de instalaciones de aplicaciones.


43
2018-04-06 07:36



A Google I / O Reto Meier dio a conocer una respuesta sólida sobre cómo abordar esto, que debería cumplir la mayoría de las necesidades de los desarrolladores para hacer un seguimiento de los usuarios en las instalaciones. Anthony Nolan muestra la dirección en su respuesta, pero pensé que escribiría el enfoque completo para que otros puedan ver cómo hacerlo (me tomó un tiempo encontrar los detalles).

Este enfoque le dará una identificación de usuario segura y anónima que será persistente para el usuario en diferentes dispositivos (en función de la cuenta principal de Google) y en todas las instalaciones. El enfoque básico es generar un ID de usuario aleatorio y almacenarlo en las preferencias compartidas de las aplicaciones. A continuación, utiliza el agente de copia de seguridad de Google para almacenar las preferencias compartidas vinculadas a la cuenta de Google en la nube.

Veamos el enfoque completo. Primero, necesitamos crear una copia de seguridad para nuestras Preferencias Compartidas usando el Servicio de Copia de Seguridad de Android. Comience por registrar su aplicación a través de http://developer.android.com/google/backup/signup.html.

Google le dará una clave de servicio de respaldo que debe agregar al manifiesto. También necesita decirle a la aplicación que use BackupAgent de la siguiente manera:

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

Luego debe crear el agente de respaldo y decirle que use el agente auxiliar para las preferencias compartidas:

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

Para completar la copia de seguridad, debe crear una instancia de BackupManager en su actividad principal:

BackupManager backupManager = new BackupManager(context);

Finalmente, cree una ID de usuario, si aún no existe, y almacénela en 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;
}

Este User_ID ahora será persistente en todas las instalaciones, incluso si el usuario mueve el dispositivo.

Para obtener más información sobre este enfoque, consulte La charla de Reto.

Y para obtener detalles completos sobre cómo implementar el agente de respaldo, vea Copias de seguridad. Recomiendo especialmente la sección de la parte inferior de la prueba, ya que la copia de seguridad no se realiza de forma instantánea, por lo que para realizar la prueba debe forzar la copia de seguridad.


36
2017-12-22 08:13



El siguiente código devuelve el número de serie del dispositivo con una API de Android oculta. Sin embargo, este código no funciona en Samsung Galaxy Tab porque "ro.serialno" no está configurado en este 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



Creo que esta es una forma segura de construir un esqueleto para una identificación única ... échale un vistazo.

ID de Pseudo-Unique, que funciona en todos los dispositivos Android Algunos dispositivos no tienen un teléfono (por ejemplo, tabletas) o por alguna razón, no desea incluir el permiso READ_PHONE_STATE. Todavía puede leer detalles como la versión de ROM, el nombre del fabricante, el tipo de CPU y otros detalles de hardware, que se adaptarán bien si desea usar la ID para una verificación de clave de serie u otros fines generales. La ID calculada de esta manera no será única: es posible encontrar dos dispositivos con la misma ID (basada en el mismo hardware e imagen de ROM) pero los cambios en las aplicaciones del mundo real son insignificantes. Para este propósito puedes usar la clase 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 mayoría de los miembros de Build son cadenas, lo que estamos haciendo aquí es tomar su longitud y transformarla a través de módulo en un dígito. Tenemos 13 dígitos y estamos agregando dos más al frente (35) para tener el mismo ID de tamaño que el IMEI (15 dígitos). Hay otras posibilidades aquí están bien, solo eche un vistazo a estas cadenas. Devuelve algo así como 355715565309247. No se requiere ningún permiso especial, por lo que este enfoque es muy conveniente.


(Información adicional: la técnica dada anteriormente fue copiada de un artículo sobre Pocket Magic.)


32
2018-03-24 19:55