android - fromstring - uuid generator

¿Cómo puedo obtener el UUID de mi teléfono Android en una aplicación?

Question

Estoy buscando ayuda para obtener el UUID de mi teléfono Android. He buscado en la red y encontré una posible solución, pero no está funcionando en el emulador.

Aquí está el código:

Class<?> c;
try {
    c = Class.forName("android.os.SystemProperties");
    Method get = c.getMethod("get", String.class);
    serial = (String) get.invoke(c, "ro.serialno");
    Log.d("ANDROID UUID",serial);
} catch (Exception e) {
    e.printStackTrace();
}

¿Alguien sabe por qué no está funcionando o tiene una mejor solución?

Answer 1

A partir de API 26, getDeviceId () está en desuso. Si necesita obtener el IMEI del dispositivo, use lo siguiente:

 String deviceId = "";
    if (Build.VERSION.SDK_INT >= 26) {
        deviceId = getSystemService(TelephonyManager.class).getImei();
    }else{
        deviceId = getSystemService(TelephonyManager.class).getDeviceId();
    }

Answer 2

Añadir

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

Método

String getUUID(){
    TelephonyManager teleManager = (TelephonyManager) getSystemService(TELEPHONY_SERVICE);
    String tmSerial = teleManager.getSimSerialNumber();
    String tmDeviceId = teleManager.getDeviceId();
    String androidId = android.provider.Settings.Secure.getString(getContentResolver(), android.provider.Settings.Secure.ANDROID_ID);
    if (tmSerial  == null) tmSerial   = "1";
    if (tmDeviceId== null) tmDeviceId = "1";
    if (androidId == null) androidId  = "1";
    UUID deviceUuid = new UUID(androidId.hashCode(), ((long)tmDeviceId.hashCode() << 32) | tmSerial.hashCode());
    String uniqueId = deviceUuid.toString();
    return uniqueId;
}

Answer 3

Como Dave Webb menciona, el Blog de Desarrolladores de Android tiene un artículo que 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 , que 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.
• Cuando un dispositivo tiene varios usuarios developer.android.com/reference/android/provider/… , cada usuario aparece como un dispositivo completamente separado, por lo que el valor ANDROID_ID es exclusivo de cada usuario.

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 ID única persistirá en los 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 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;
    }
}

Answer 4

En lugar de obtener IMEI de TelephonyManager, use ANDROID_ID.

Settings.Secure.ANDROID_ID

Esto funciona para cada dispositivo Android sin tener en cuenta la telefonía.

Answer 5

Esto funciona para mí:

TelephonyManager tManager = (TelephonyManager)getSystemService(Context.TELEPHONY_SERVICE);
String uuid = tManager.getDeviceId();

EDITAR:

También necesita android.permission.READ_PHONE_STATE establecido en su Manifiesto. Desde Android M, debes solicitar este permiso en tiempo de ejecución.

Ver este artículo: https://.com/a/38782876/1339179

Answer 6

 String id = UUID.randomUUID().toString();

Consulte el artículo del blog de Android Developer para usar la clase UUID para obtener uuid

Answer 7

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