113 votos

¿Cómo encontrar el número de serie del dispositivo Android?

Necesito usar un ID único para una aplicación para Android y creo que el número de serie del dispositivo sería un buen candidato. ¿Cómo puedo recuperar el número de serie de un dispositivo Android en mi aplicación?

102voto

haseman Puntos 6071
TelephonyManager tManager = (TelephonyManager)myActivity.getSystemService(Context.TELEPHONY_SERVICE);
String uid = tManager.getDeviceId();

getSystemService es un método de la clase de actividad getDeviceID() devolverá el MDN o MEID del dispositivo dependiendo de la radio el teléfono usa (GSM o CDMA).

Cada dispositivo debe devolver un valor único (suponiendo que es un teléfono). Esto debería funcionar para cualquier dispositivo Android con una ranura de sim o radio CDMA. Tú eres tu propio con que Android potencia microondas ;-)

71voto

emmby Puntos 35359

Como Dave Webb menciona, el Android Developer Blog tiene un artículo que cubre este.

Hablé con alguien en Google para obtener algunas aclaraciones adicionales sobre algunos artículos. Aquí es lo que he descubierto que NO es mencionado en el blog antes mencionado post:

  • ANDROID_ID es la solución preferida. ANDROID_ID es perfectamente fiable sobre las versiones de Android <=2.1 o >=2.3. Sólo el 2.2 tiene los problemas mencionados en el post.
  • Varios dispositivos de varios fabricantes están afectados por la ANDROID_ID error en 2.2.
  • Como he sido capaz de determinar, todos los dispositivos afectados tienen la misma ANDROID_ID, que es 9774d56d682e549c. Que es también el mismo id de dispositivo reportado por el emulador, por cierto.
  • Google considera que los Oem han parcheado el problema para muchos o la mayoría de sus dispositivos, pero pude comprobar que a partir de principios de abril de 2011, por lo menos, todavía es bastante fácil encontrar dispositivos que han roto ANDROID_ID.

Basado en Google recomendaciones, implementa una clase que se va a generar un UUID único para cada dispositivo, utilizando ANDROID_ID como la semilla cuando proceda, de volver a caer en TelephonyManager.getDeviceId() como sea necesario, y si eso falla, recurrir a un único generado al azar UUID que se conserva a través de la aplicación se reinicia (pero no aplicación de volver a las instalaciones).

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

32voto

Roman SL Puntos 477
 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) {
}
 

Este código devuelve el número de serie del dispositivo utilizando una API de Android oculto.

16voto

Anthony Forloney Puntos 30083
String deviceId = Settings.System.getString(getContentResolver(),
                                Settings.System.ANDROID_ID);

Sin embargo, no está garantizado que el ID Android será un identificador único.

14voto

Dave Webb Puntos 90034

Hay un excelente post en el desarrollo de Android del Blog de discutir esto.

Se recomienda el uso de TelephonyManager.getDeviceId() ya que no funciona en los dispositivos Android que no son teléfonos como tabletas, se requiere que el READ_PHONE_STATE de permiso y no funciona de forma fiable en todos los teléfonos.

En su lugar puede utilizar uno de los siguientes:

  • Dirección Mac
  • Número De Serie
  • ANDROID_ID

El post se analizan los pros y los contras de cada uno y es que vale la pena leer para que pueda trabajar fuera, que sería la mejor para su uso.

Iteramos.com

Iteramos es una comunidad de desarrolladores que busca expandir el conocimiento de la programación mas allá del inglés.
Tenemos una gran cantidad de contenido, y también puedes hacer tus propias preguntas o resolver las de los demás.

Powered by: