¿Cómo obtener el IMEI / ESN del dispositivo mediante programación en Android?


343

Para identificar cada dispositivo de manera única, me gustaría usar el IMEI (o el número ESN para dispositivos CDMA). ¿Cómo acceder a esto mediante programación?


Para obtener IMEI para ambas SIM en teléfonos con SIM dual, use reflejos Java. Ver aquí es una demostración
Vaibhav Jani

55
@PiedPiper: IMEI no es específico de SIM. Estás pensando en IMSI.
Phillip

@Phillip Gracias amigo. He actualizado mi respuesta :)
Vaibhav Jani

1
Todos ... ¿hay algunos cambios en Android 6? ¿Podemos acceder al IMEI de alguna manera?
therealprashant

1
Debe solicitar el permiso READ_PHONE_STATE en tiempo de ejecución, entonces aún puede obtener el IMEI
Flo We

Respuestas:


387

Al que desea llamar android.telephony.TelephonyManager.getDeviceId().

Esto devolverá cualquier cadena que identifique de forma exclusiva el dispositivo (IMEI en GSM, MEID para CDMA).

Necesitará el siguiente permiso en su AndroidManifest.xml:

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

para hacer esto.

Dicho esto, tenga cuidado al hacer esto. Los usuarios no solo se preguntarán por qué su aplicación está accediendo a su pila de telefonía, sino que podría ser difícil migrar los datos si el usuario obtiene un nuevo dispositivo.

Actualización: como se menciona en los comentarios a continuación, esta no es una forma segura de autenticar a los usuarios y plantea problemas de privacidad. No es recomendable En su lugar, mire la API de inicio de sesión de Google+ si desea implementar un sistema de inicio de sesión sin fricciones.

La API de copia de seguridad de Android también está disponible si solo desea una forma liviana de conservar un conjunto de cadenas para cuando un usuario reinicia su teléfono (o compra un nuevo dispositivo).


1
¿Cuál sería una solución mejor que les permitiría migrar datos en el futuro? Dirección de correo electrónico de Google? Si es así, ¿cómo puedo sacar eso del sistema?
Tom

3
La forma más confiable de hacer esto es simplemente hacer que creen una cuenta la primera vez que inicien su aplicación. Hay formas de obtener la dirección de correo electrónico del usuario (consulte los documentos en AccountManager), pero verificar que un usuario malintencionado no haya falsificado esta información requiere un poco de conocimiento sobre cómo funcionan las API de datos de Google, más de lo que puedo poner en esto pequeño cuadro de comentarios. ;)
Trevor Johns

1
En realidad, no tiene ninguna garantía de que el usuario tampoco haya falsificado su IMEI / MEID. Si la seguridad es motivo de preocupación, realmente necesita usar un nombre de usuario / contraseña o el método getAuthToken () en AccountManager (y nuevamente, deberá verificar este token con el servidor que lo emitió originalmente).
Trevor Johns

2
Adi: ¿El código para obtener la ID del dispositivo? No hay nada más que el único método + permiso que mencioné anteriormente. Dicho esto, deberías buscar en la API de inicio de sesión de Google+, ese es el enfoque recomendado para autenticar a los usuarios en estos días: developer.android.com/google/play-services/auth.html
Trevor Johns

2
¿Está ejecutando Android 6? ¿Y estás apuntando al SDK 23? Entonces debe solicitar READ_PHONE_STATE en tiempo de ejecución antes de consultar el IMEI
Flo We

284

Además de la respuesta de Trevor Johns, puede usar esto de la siguiente manera:

TelephonyManager telephonyManager = (TelephonyManager)getSystemService(Context.TELEPHONY_SERVICE);
telephonyManager.getDeviceId();

Y debe agregar el siguiente permiso en su archivo Manifest.xml:

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

En el emulador, probablemente obtendrá un valor similar a "00000 ...". getDeviceId () devuelve NULL si la ID del dispositivo no está disponible.


1
¿Hay alguna manera de hacer que el emulador devuelva un número IMEI?
MikeSchem

@MikeSchem, el emulador no tiene una cadena IMEI significativa.
shizhen

Intente no usar: <uses-permission android: name = "android.permission.READ_PHONE_STATE" /> este permiso es muy sensible, puede obtener la Aplicación rechazada del equipo de Google Play (se agregaron nuevas reglas de seguridad a fines de 2018). Como consejo, utilice mejor la ID de publicidad.
Duna

@Taner ¿Funcionará en un dispositivo dual sim? (Solo necesita obtener el primer IMEI)
Arnold Brown

¿Hay alguna preocupación de seguridad por usar el READ_PHONE_STATEpermiso?
víbora

62

Uso el siguiente código para obtener el IMEI o uso Secure.ANDROID_ID como alternativa, cuando el dispositivo no tiene capacidades telefónicas:

/**
 * Returns the unique identifier for the device
 *
 * @return unique identifier for the device
 */
public String getDeviceIMEI() {
    String deviceUniqueIdentifier = null;
    TelephonyManager tm = (TelephonyManager) this.getSystemService(Context.TELEPHONY_SERVICE);
    if (null != tm) {
        deviceUniqueIdentifier = tm.getDeviceId();
    }
    if (null == deviceUniqueIdentifier || 0 == deviceUniqueIdentifier.length()) {
        deviceUniqueIdentifier = Settings.Secure.getString(this.getContentResolver(), Settings.Secure.ANDROID_ID);
    }
    return deviceUniqueIdentifier;
}

17
TextUtils.isEmpty () -> if (identificador == nulo || identificador .length () == 0)
Mikhaili

2
Hola Pinhassi: ¿Tuviste algún caso en el que la ID de dispositivo devuelta por el administrador de telefonía era nula o vacía, pero el valor leído desde Secure.ANDROID_ID no estaba vacío? Gracias
Budda

44
Por lo que puedo recordar, fue para tabletas sin tarjeta SIM (pero no estoy 100% seguro).
Asaf Pinhassi

Secure.ANDROID_ID cambia si el dispositivo está formateado o la rom se restablece de fábrica
shridutt kothari

Mi Nexus7 (1stGen) regresa nullpara el dispositivo de telefonía Id ... ¿Alguien sabe cómo obtener un IMEI de una tableta?
Sakiboy

38

O puede usar la configuración ANDROID_ID de Android.Provider.Settings.System (como se describe aquí strazerre.com ).

Esto tiene la ventaja de que no requiere permisos especiales, pero puede cambiar si otra aplicación tiene acceso de escritura y lo cambia (lo que aparentemente es inusual pero no imposible).

Solo para referencia aquí está el código del blog:

import android.provider.Settings;
import android.provider.Settings.System;   

String androidID = System.getString(this.getContentResolver(),Secure.ANDROID_ID);

Nota de implementación : si la ID es crítica para la arquitectura del sistema, debe tener en cuenta que, en la práctica, se ha encontrado que algunos de los teléfonos y tabletas Android de gama baja reutilizan el mismo ANDROID_ID (9774d56d682e549c fue el valor que apareció en nuestros registros)


15
Esta constante está en desuso. En su lugar, debe usar android.provider.Settings.Secure.ANDROID_ID;
mcorley

@mcorley cuando uso android.provider.Settings.Secure.ANDROID_ID para la tableta nexus 7 y nexus 4 devuelve el mismo valor 'android_id'
vuhung3990

3
@meowmeo hizo lo mismo por mí, hasta que usé el código que ahora es parte de la respuesta (ish). String androidID = android.provider.Settings.System.getString(this.getContentResolver(), Secure.ANDROID_ID);
Matthias

Pero, ¿no se restablecería esto a un nuevo ANDROID_ID después del restablecimiento de fábrica? ¿Qué sucede si necesito un ANDROID_ID persistente que pueda sobrevivir a los restablecimientos?
IgorGanapolsky

35

De: http://mytechead.wordpress.com/2011/08/28/how-to-get-imei-number-of-android-device/ :

El siguiente código ayuda a obtener el número IMEI de dispositivos Android:

TelephonyManager tm = (TelephonyManager)getSystemService(Context.TELEPHONY_SERVICE);
String device_id = tm.getDeviceId();

Permisos requeridos en el Manifiesto de Android:

android.permission.READ_PHONE_STATE

NOTA: En el caso de tabletas o dispositivos que no pueden actuar como teléfono móvil, IMEI será nulo.


1
este es el código real que estoy buscando para obtener IMEI
Anand Savjani

2
Desafortunadamente, con Marshmallow adelante, ahora debe solicitar este permiso en tiempo de ejecución. Este permiso no es ideal, ya que perturba la experiencia del usuario y puede hacer que algunos usuarios sospechen.
IgorGanapolsky

Intente no usar: <uses-permission android: name = "android.permission.READ_PHONE_STATE" /> este permiso es muy sensible, puede obtener la Aplicación rechazada del equipo de Google Play (se agregaron nuevas reglas de seguridad a fines de 2018). Como consejo, utilice mejor la ID de publicidad en su lugar IMEI
Duna

¿Cuál es la solución para Android 10?
Amin Pinjari

23

obtener IMEI (identificador internacional de equipo móvil)

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

para obtener la identificación única del dispositivo

public String getDeviceUniqueID(Activity activity){
    String device_unique_id = Secure.getString(activity.getContentResolver(),
            Secure.ANDROID_ID);
    return device_unique_id;
}

2
Mostrar la alternativa device_unique_id es realmente útil
JoeGalind

20

Para Android 6.0+, el juego ha cambiado, así que te sugiero que uses esto;

La mejor manera de hacerlo es durante el tiempo de ejecución; de lo contrario, obtendrá errores de permiso.

   /**
 * A loading screen after AppIntroActivity.
 */
public class LoadingActivity extends BaseActivity {
private static final int MY_PERMISSIONS_REQUEST_READ_PHONE_STATE = 0;
private TextView loading_tv2;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_loading);

    //trigger 'loadIMEI'
    loadIMEI();
    /** Fading Transition Effect */
    overridePendingTransition(android.R.anim.fade_in, android.R.anim.fade_out);
}

/**
 * Called when the 'loadIMEI' function is triggered.
 */
public void loadIMEI() {
    // Check if the READ_PHONE_STATE permission is already available.
    if (ActivityCompat.checkSelfPermission(this, Manifest.permission.READ_PHONE_STATE)
            != PackageManager.PERMISSION_GRANTED) {
        // READ_PHONE_STATE permission has not been granted.
        requestReadPhoneStatePermission();
    } else {
        // READ_PHONE_STATE permission is already been granted.
        doPermissionGrantedStuffs();
    }
}



/**
 * Requests the READ_PHONE_STATE permission.
 * If the permission has been denied previously, a dialog will prompt the user to grant the
 * permission, otherwise it is requested directly.
 */
private void requestReadPhoneStatePermission() {
    if (ActivityCompat.shouldShowRequestPermissionRationale(this,
            Manifest.permission.READ_PHONE_STATE)) {
        // Provide an additional rationale to the user if the permission was not granted
        // and the user would benefit from additional context for the use of the permission.
        // For example if the user has previously denied the permission.
        new AlertDialog.Builder(LoadingActivity.this)
                .setTitle("Permission Request")
                .setMessage(getString(R.string.permission_read_phone_state_rationale))
                .setCancelable(false)
                .setPositiveButton(android.R.string.yes, new DialogInterface.OnClickListener() {
                    public void onClick(DialogInterface dialog, int which) {
                        //re-request
                        ActivityCompat.requestPermissions(LoadingActivity.this,
                                new String[]{Manifest.permission.READ_PHONE_STATE},
                                MY_PERMISSIONS_REQUEST_READ_PHONE_STATE);
                    }
                })
                .setIcon(R.drawable.onlinlinew_warning_sign)
                .show();
    } else {
        // READ_PHONE_STATE permission has not been granted yet. Request it directly.
        ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.READ_PHONE_STATE},
                MY_PERMISSIONS_REQUEST_READ_PHONE_STATE);
    }
}

/**
 * Callback received when a permissions request has been completed.
 */
@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions,
                                       @NonNull int[] grantResults) {

    if (requestCode == MY_PERMISSIONS_REQUEST_READ_PHONE_STATE) {
        // Received permission result for READ_PHONE_STATE permission.est.");
        // Check if the only required permission has been granted
        if (grantResults.length == 1 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
            // READ_PHONE_STATE permission has been granted, proceed with displaying IMEI Number
            //alertAlert(getString(R.string.permision_available_read_phone_state));
            doPermissionGrantedStuffs();
        } else {
            alertAlert(getString(R.string.permissions_not_granted_read_phone_state));
          }
    }
}

private void alertAlert(String msg) {
    new AlertDialog.Builder(LoadingActivity.this)
            .setTitle("Permission Request")
            .setMessage(msg)
            .setCancelable(false)
            .setPositiveButton(android.R.string.yes, new DialogInterface.OnClickListener() {
                public void onClick(DialogInterface dialog, int which) {
                    // do somthing here
                }
            })
            .setIcon(R.drawable.onlinlinew_warning_sign)
            .show();
}


public void doPermissionGrantedStuffs() {
    //Have an  object of TelephonyManager
    TelephonyManager tm =(TelephonyManager)getSystemService(Context.TELEPHONY_SERVICE);
    //Get IMEI Number of Phone  //////////////// for this example i only need the IMEI
    String IMEINumber=tm.getDeviceId();

    /************************************************
     * **********************************************
     * This is just an icing on the cake
     * the following are other children of TELEPHONY_SERVICE
     *
     //Get Subscriber ID
     String subscriberID=tm.getDeviceId();

     //Get SIM Serial Number
     String SIMSerialNumber=tm.getSimSerialNumber();

     //Get Network Country ISO Code
     String networkCountryISO=tm.getNetworkCountryIso();

     //Get SIM Country ISO Code
     String SIMCountryISO=tm.getSimCountryIso();

     //Get the device software version
     String softwareVersion=tm.getDeviceSoftwareVersion()

     //Get the Voice mail number
     String voiceMailNumber=tm.getVoiceMailNumber();


     //Get the Phone Type CDMA/GSM/NONE
     int phoneType=tm.getPhoneType();

     switch (phoneType)
     {
     case (TelephonyManager.PHONE_TYPE_CDMA):
     // your code
     break;
     case (TelephonyManager.PHONE_TYPE_GSM)
     // your code
     break;
     case (TelephonyManager.PHONE_TYPE_NONE):
     // your code
     break;
     }

     //Find whether the Phone is in Roaming, returns true if in roaming
     boolean isRoaming=tm.isNetworkRoaming();
     if(isRoaming)
     phoneDetails+="\nIs In Roaming : "+"YES";
     else
     phoneDetails+="\nIs In Roaming : "+"NO";


     //Get the SIM state
     int SIMState=tm.getSimState();
     switch(SIMState)
     {
     case TelephonyManager.SIM_STATE_ABSENT :
     // your code
     break;
     case TelephonyManager.SIM_STATE_NETWORK_LOCKED :
     // your code
     break;
     case TelephonyManager.SIM_STATE_PIN_REQUIRED :
     // your code
     break;
     case TelephonyManager.SIM_STATE_PUK_REQUIRED :
     // your code
     break;
     case TelephonyManager.SIM_STATE_READY :
     // your code
     break;
     case TelephonyManager.SIM_STATE_UNKNOWN :
     // your code
     break;

     }
     */
    // Now read the desired content to a textview.
    loading_tv2 = (TextView) findViewById(R.id.loading_tv2);
    loading_tv2.setText(IMEINumber);
}
}

Espero que esto te ayude a ti oa alguien.


16

Nueva actualización:

Para Android Versión 6 y superior, la dirección MAC de WLAN ha quedado en desuso, siga la respuesta de Trevor Johns

Actualizar:

Para la identificación única de dispositivos, puede usar Secure.ANDROID_ID .

Vieja respuesta:

Desventajas de usar IMEI como ID de dispositivo único:

  • IMEI depende de la ranura Simcard del dispositivo, por lo que no es posible obtener el IMEI para los dispositivos que no usan Simcard. En dispositivos Dual sim, obtenemos 2 IMEI diferentes para el mismo dispositivo, ya que tiene 2 ranuras para tarjeta SIM.

Puede usar la cadena de dirección MAC de WLAN (no se recomienda para Marshmallow y Marshmallow + ya que la dirección MAC de WLAN ha quedado en desuso en Marshmallow hacia adelante. Así obtendrá un valor falso)

También podemos obtener la identificación única para teléfonos Android usando la dirección MAC de WLAN. La dirección MAC es única para todos los dispositivos y funciona para todo tipo de dispositivos.

Ventajas de usar la dirección MAC de WLAN como ID de dispositivo:

  • Es un identificador único para todo tipo de dispositivos (teléfonos inteligentes y tabletas).

  • Sigue siendo único si la aplicación se reinstala

Desventajas de usar la dirección MAC de WLAN como ID de dispositivo:

  • Darle un valor falso de Marshmallow y superior.

  • Si el dispositivo no tiene hardware wifi, entonces obtienes una dirección MAC nula, pero generalmente se ve que la mayoría de los dispositivos Android tienen hardware wifi y apenas hay pocos dispositivos en el mercado sin hardware wifi.

FUENTE: technetexperts.com


77
"IMEI depende de la tarjeta SIM" ... Esto es falso. Parece confundir el IMEI con el número IMSI
Merlevede

2
Una identidad internacional de equipo de estación móvil o IMEI para abreviar es un número que identifica los teléfonos móviles que se ejecutan en una red GSM. Personalmente lo he probado y me da nulo programáticamente si no hay un proveedor de servicios inalámbricos en el teléfono GSM. smartmobilephonesolutions.com/content/…
Jamil

3
Tienes razón, no leí con cuidado. El IMEI está asociado al transceptor de la tarjeta SIM, no a la tarjeta SIM. ¡Culpa mía!
Merlevede

2
La dirección MAC de WLAN ha quedado en desuso en Marshmallow forward. ¡Entonces obtendrás un valor falso!
IgorGanapolsky

1
Android 6 no devuelve la dirección MAC WIFI correcta con su código. Notarlo.
zszen

15

Como en API 26 getDeviceId()se deprecia, puede usar el siguiente código para atender API 26 y versiones anteriores

TelephonyManager telephonyManager = (TelephonyManager)getSystemService(Context.TELEPHONY_SERVICE);
String imei="";
if (android.os.Build.VERSION.SDK_INT >= 26) {
  imei=telephonyManager.getImei();
}
else
{
  imei=telephonyManager.getDeviceId();
}

No olvide agregar solicitudes de permiso para READ_PHONE_STATEusar el código anterior.

ACTUALIZACIÓN: desde Android 10 está restringido para que las aplicaciones de usuario obtengan identificadores de hardware no reiniciables como IMEI.


¿Dónde puedo encontrar referencias para el método 'getImei () "?
sam byte


¿Cuál es la solución para Android 10?
Amin Pinjari

1
Lamentablemente, Amin en Android 10 debido a razones de seguridad ahora está restringido para que las aplicaciones de terceros obtengan identificadores de hardware como IMEI para obtener más información sobre los cambios de privacidad en Android 10, visite developer.android.com/about/versions/10/privacy
Muhammad Hamza Shahid

Funciona en Android Oreo.
Satish Shetty

10

El método getDeviceId () de TelephonyManager devuelve la ID única del dispositivo, por ejemplo, el IMEI para GSM y el MEID o ESN para teléfonos CDMA. Devuelve nulo si la ID del dispositivo no está disponible.

Código Java

package com.AndroidTelephonyManager;

import android.app.Activity;
import android.content.Context;
import android.os.Bundle;
import android.telephony.TelephonyManager;
import android.widget.TextView;

public class AndroidTelephonyManager extends Activity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main);
    TextView textDeviceID = (TextView)findViewById(R.id.deviceid);

    //retrieve a reference to an instance of TelephonyManager
    TelephonyManager telephonyManager = (TelephonyManager)getSystemService(Context.TELEPHONY_SERVICE);

    textDeviceID.setText(getDeviceID(telephonyManager));

}

String getDeviceID(TelephonyManager phonyManager){

 String id = phonyManager.getDeviceId();
 if (id == null){
  id = "not available";
 }

 int phoneType = phonyManager.getPhoneType();
 switch(phoneType){
 case TelephonyManager.PHONE_TYPE_NONE:
  return "NONE: " + id;

 case TelephonyManager.PHONE_TYPE_GSM:
  return "GSM: IMEI=" + id;

 case TelephonyManager.PHONE_TYPE_CDMA:
  return "CDMA: MEID/ESN=" + id;

 /*
  *  for API Level 11 or above
  *  case TelephonyManager.PHONE_TYPE_SIP:
  *   return "SIP";
  */

 default:
  return "UNKNOWN: ID=" + id;
 }

}
}

XML

<linearlayout android:layout_height="fill_parent" android:layout_width="fill_parent" android:orientation="vertical" xmlns:android="http://schemas.android.com/apk/res/android">
<textview android:layout_height="wrap_content" android:layout_width="fill_parent" android:text="@string/hello">
<textview android:id="@+id/deviceid" android:layout_height="wrap_content" android:layout_width="fill_parent">
</textview></textview></linearlayout> 

Se requiere permiso READ_PHONE_STATE en el archivo de manifiesto.


4

Puede usar esta función TELEPHONY_SERVICE de TelephonyManager para obtener una ID de dispositivo única , Requiere permiso: READ_PHONE_STATE

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

Ejemplo, el IMEI para GSM y el MEID o ESN para teléfonos CDMA .

/**
 * Gets the device unique id called IMEI. Sometimes, this returns 00000000000000000 for the
 * rooted devices.
 **/
public static String getDeviceImei(Context ctx) {
    TelephonyManager telephonyManager = (TelephonyManager) ctx.getSystemService(Context.TELEPHONY_SERVICE);
    return telephonyManager.getDeviceId();
}

Devuelve nulo si la ID del dispositivo no está disponible .


y por qué el Id. del dispositivo es nulo? debido al dispositivo rooteado.
Vishal Sojitra

¿Cuál es la solución para Android 10?
Amin Pinjari


3

Pruebe esto (necesita obtener el primer IMEI siempre)

TelephonyManager mTelephony = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);
        if (ActivityCompat.checkSelfPermission(LoginActivity.this,Manifest.permission.READ_PHONE_STATE)!= PackageManager.PERMISSION_GRANTED) {

         return;
}

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
                if (mTelephony.getPhoneCount() == 2) {
                    IME = mTelephony.getImei(0);
                }else{
                    IME = mTelephony.getImei();
                }
            }else{
                if (mTelephony.getPhoneCount() == 2) {
                    IME = mTelephony.getDeviceId(0);
                } else {
                    IME = mTelephony.getDeviceId();
                }
            }
        } else {
            IME = mTelephony.getDeviceId();
        }

¿Cuál es la solución para Android 10? developer.android.com/about/versions/10/privacy
Amin Pinjari

2

El uso del siguiente código le da el número IMEI:

TelephonyManager telephonyManager = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);
System.out.println("IMEI::" + telephonyManager.getDeviceId());

1

para API Nivel 11 o superior:

case TelephonyManager.PHONE_TYPE_SIP: 
return "SIP";

TelephonyManager tm= (TelephonyManager)getSystemService(Context.TELEPHONY_SERVICE);
textDeviceID.setText(getDeviceID(tm));

1

Código de Kotlin para obtener DeviceId (IMEI) con permiso de manejo y verificación de comparabilidad para todas las versiones de Android:

 val  telephonyManager = getSystemService(Context.TELEPHONY_SERVICE) as TelephonyManager
    if (ContextCompat.checkSelfPermission(this, Manifest.permission.READ_PHONE_STATE)
        == PackageManager.PERMISSION_GRANTED) {
        // Permission is  granted
        val imei : String? = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O)  telephonyManager.imei
        // older OS  versions
        else  telephonyManager.deviceId

        imei?.let {
            Log.i("Log", "DeviceId=$it" )
        }

    } else {  // Permission is not granted

    }

Agregue también este permiso a AndroidManifest.xml:

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

1

Necesitará el siguiente permiso en su AndroidManifest.xml:

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

Para obtener IMEI (identificador internacional de equipo móvil) y si está por encima del nivel 26 de API, entonces obtenemos un telephonyManager.getImei()valor nulo para eso, usamos ANDROID_ID como identificador único.

 public static String getIMEINumber(@NonNull final Context context)
            throws SecurityException, NullPointerException {
        TelephonyManager tm = (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
        String imei;
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            assert tm != null;
            imei = tm.getImei();
            //this change is for Android 10 as per security concern it will not provide the imei number.
            if (imei == null) {
                imei = Settings.Secure.getString(context.getContentResolver(), Settings.Secure.ANDROID_ID);
            }
        } else {
            assert tm != null;
            if (tm.getDeviceId() != null && !tm.getDeviceId().equals("000000000000000")) {
                imei = tm.getDeviceId();
            } else {
                imei = Settings.Secure.getString(context.getContentResolver(), Settings.Secure.ANDROID_ID);
            }
        }

        return imei;
    }

0

Para aquellos que buscan una versión de Kotlin, pueden usar algo como esto;

private fun telephonyService() {
    val telephonyManager = getSystemService(TELEPHONY_SERVICE) as TelephonyManager
    val imei = if (android.os.Build.VERSION.SDK_INT >= 26) {
        Timber.i("Phone >= 26 IMEI")
        telephonyManager.imei
    } else {
        Timber.i("Phone IMEI < 26")
        telephonyManager.deviceId
    }

    Timber.i("Phone IMEI $imei")
}

NOTA: Debe completar el formulariotelephonyService() con una verificación de permiso usando checkSelfPermission o cualquier método que use.

Agregue también este permiso en el archivo de manifiesto;

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

0

use el siguiente código:

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
        String[] permissions = {Manifest.permission.READ_PHONE_STATE};
        if (ActivityCompat.checkSelfPermission(this,
                Manifest.permission.READ_PHONE_STATE) != PackageManager.PERMISSION_GRANTED) {
            requestPermissions(permissions, READ_PHONE_STATE);
        }
    } else {
        try {
            TelephonyManager telephonyManager = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);
            if (ActivityCompat.checkSelfPermission(this, Manifest.permission.READ_PHONE_STATE) != PackageManager.PERMISSION_GRANTED) {
                return;
            }
            String imei = telephonyManager.getDeviceId();

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

Y llame al método onRequestPermissionsResult con el siguiente código:

@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
    switch (requestCode) {
        case READ_PHONE_STATE:
            if (grantResults.length > 0
                    && grantResults[0] == PackageManager.PERMISSION_GRANTED)
                try {
                    TelephonyManager telephonyManager = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);
                    if (ActivityCompat.checkSelfPermission(this, Manifest.permission.READ_PHONE_STATE) != PackageManager.PERMISSION_GRANTED) {
                        return;
                    }
                    String imei = telephonyManager.getDeviceId();

                } catch (Exception e) {
                    e.printStackTrace();
                }
    }
}

Agregue el siguiente permiso en su AndroidManifest.xml:

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

0

Para Android 10, el siguiente código funciona para mí.

val uid: String = Settings.Secure.getString(ctx.applicationContext.contentResolver, Settings.Secure.ANDROID_ID)
if (ContextCompat.checkSelfPermission(ctx, Manifest.permission.READ_PHONE_STATE) == PackageManager.PERMISSION_GRANTED) {
            imei = when {
                Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q -> {
                    uid
                }
                Build.VERSION.SDK_INT >= Build.VERSION_CODES.O -> {
                    telephonyManager.imei
                }
                else -> {
                    telephonyManager.deviceId
                }
            }
        }
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.