¿Cómo obtener el IMEI/ESN del dispositivo mediante programación en Android?
https://stackoverflow.com/questions/1972381
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPregunta
Para identificar cada dispositivo de forma única, me gustaría utilizar el IMEI (o número ESN para dispositivos CDMA).¿Cómo acceder a esto mediante programación?
Solución
¿Quieres llamar android.telephony.TelephonyManager.getDeviceId() .
Esto devolverá cualquier cadena que se identifica de manera única el dispositivo (IMEI en GSM, MEID para CDMA).
Usted necesitará el siguiente permiso en su AndroidManifest.xml:
<uses-permission android:name="android.permission.READ_PHONE_STATE" />
con el fin de hacer esto.
Una vez dicho esto, tenga cuidado en hacer esto. No sólo va usuarios se preguntan por qué su aplicación está accediendo a su pila de telefonía, podría ser difícil de datos migrar si el usuario recibe un nuevo dispositivo.
Actualización: Como se mencionó en los comentarios a continuación, esto no es una forma segura de autenticar usuarios, y plantea problemas de privacidad. No se recomienda. En su lugar, mirada en el Google+ Login API si se desea implementar una fricción sistema de inicio de sesión.
El Android API de copia de seguridad también está disponible si lo que desea es una forma ligera que persista un conjunto de cuerdas para cuando un usuario reinicia el teléfono (o compra un nuevo dispositivo).
Otros consejos
Además de la respuesta de Trevor Johns, puede utilizar esto como sigue:
TelephonyManager telephonyManager = (TelephonyManager)getSystemService(Context.TELEPHONY_SERVICE);
telephonyManager.getDeviceId();
Y usted debe añadir el siguiente permiso en su archivo Manifest.xml:
<uses-permission android:name="android.permission.READ_PHONE_STATE"/>
En el emulador, probablemente obtendrá un como un "00000 ..." valor. GetDeviceID () devuelve NULL si el ID de dispositivo no está disponible.
Yo uso el siguiente código para obtener el IMEI o utilizar Secure.ANDROID_ID como alternativa, cuando el dispositivo no tiene capacidades de teléfono:
/**
* 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;
}
O bien, puede utilizar la configuración de ANDROID_ID Android.Provider.Settings.System (tal como se describe aquí strazerre. com ).
Esto tiene la ventaja de que no requiere de permisos especiales, pero se puede cambiar si otra aplicación tiene acceso de escritura y lo cambia (que al parecer es inusual, pero no imposible).
Sólo como referencia aquí es 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 el ID es fundamental para la arquitectura del sistema que deben ser conscientes de que en la práctica algunos de final muy baja teléfonos y tablets Android se han encontrado reutilización de la misma ANDROID_ID (9774d56d682e549c era el valor a aparecer en nuestros registros)
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 necesarios en Android Manifiesto:
android.permission.READ_PHONE_STATE
NOTA: En caso de tabletas o dispositivos que no puedan actuar como teléfono móvil IMEI será nulo.
para 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 dispositivo único id
public String getDeviceUniqueID(Activity activity){
String device_unique_id = Secure.getString(activity.getContentResolver(),
Secure.ANDROID_ID);
return device_unique_id;
}
Para Android 6.0+ el juego ha cambiado, así que sugiero que utilice este;
La mejor manera de ir es durante el tiempo de ejecución de lo contrario se producen errores de permisos.
/**
* 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 ayuda a usted o alguien.
Nueva actualización:
Para Android versión 6 y superiores, la dirección MAC de WLAN ha quedado obsoleta, siga la respuesta de Trevor Johns
Actualizar:
Para una identificación única de dispositivos, puede utilizar Seguro.ANDROID_ID.
Antigua 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 utilizar la cadena de dirección MAC de WLAN (no recomendada para Marshmallow y Marshmallow+, ya que la dirección MAC de WLAN ha quedado obsoleta en Marshmallow en adelante.Entonces obtendrás un valor falso)
También podemos obtener la ID única para teléfonos Android utilizando 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 utilizar la dirección MAC de WLAN como ID del dispositivo:
Es un identificador único para todo tipo de dispositivos (teléfonos inteligentes y tabletas).
Sigue siendo único si se reinstala la aplicación.
Desventajas de utilizar la dirección MAC de WLAN como ID del dispositivo:
Darle un valor falso de Marshmallow y superior.
Si el dispositivo no tiene hardware WiFi, entonces obtiene una dirección MAC nula, pero en general 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
Al igual que en la API 26 GetDeviceID () se deprecia esta manera puede utilizar 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 se olvide de añadir solicitar permiso para "READ_PHONE_STATE" para su uso por encima de código.
El GetDeviceID método () de TelephonyManager devuelve el identificador de dispositivo único, por ejemplo, la IMEI para GSM y el MEID o ESN para los teléfonos CDMA. return null si el identificador de dispositivo no está disponible.
código de 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>
El permiso es obligatorio READ_PHONE_STATE en el archivo de manifiesto.
Puede utilizar esta TelephonyManager TELEPHONY_SERVICE función para obtener ID único dispositivo Requiere el permiso: READ_PHONE_STATE
<uses-permission android:name="android.permission.READ_PHONE_STATE" />
ejemplo, el IMEI para GSM y MEID o ESN para CDMA móviles.
/**
* 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();
}
Vuelta nula si ID de dispositivo no está disponible .
El getDeviceId() método está en desuso.
Hay un nuevo método para este getImei(int)
El uso por debajo de código que da el número de IMEI:
TelephonyManager telephonyManager = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);
System.out.println("IMEI::" + telephonyManager.getDeviceId());
Probar (necesidad de obtener primero 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();
}
API de nivel 11 o superior:
case TelephonyManager.PHONE_TYPE_SIP:
return "SIP";
TelephonyManager tm= (TelephonyManager)getSystemService(Context.TELEPHONY_SERVICE);
textDeviceID.setText(getDeviceID(tm));
Código Kotlin para conseguir DeviceId (IMEI) con el permiso y la verificación comparabilidad manejo 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
}
También añadir este permiso a AndroidManifest.xml:
<uses-permission android:name="android.permission.READ_PHONE_STATE"/> <!-- IMEI-->
Para aquellos que buscan una versión Kotlin, se puede 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 envolver telephonyService() anterior con una comprobación de permisos usando checkSelfPermission o lo que sea el método que utilice.
También añadir este permiso en el archivo de manifiesto;
<uses-permission android:name="android.permission.READ_PHONE_STATE"/>
