significa - ¿Cómo obtener el IMEI/ESN del dispositivo mediante programación en Android?
que significa esn (14)
Para identificar cada dispositivo de forma única, me gustaría usar el IMEI (o el número ESN para dispositivos CDMA). ¿Cómo acceder a este programáticamente?
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ás un valor "00000 ..." similar. getDeviceId () devuelve NULL si la ID del dispositivo no está disponible.
Al igual que en API 26, getDeviceId () se deprecia, por lo que puede usar el siguiente código para atender a 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 la solicitud de permiso para "READ_PHONE_STATE" para usar el código anterior.
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 IMEI de teléfono móvil, se considerará nulo.
El código de abajo te da el número IMEI:
TelephonyManager telephonyManager = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);
System.out.println("IMEI::" + telephonyManager.getDeviceId());
El método getDeviceId () de TelephonyManager devuelve el ID de dispositivo único, 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.
El método getDeviceId () está en desuso. Hay un nuevo método para este getImei (int)
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 el ID es crítico 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 muy bajo nivel reutilizan el mismo ANDROID_ID (9774d56d682e549c fue el valor que aparece en nuestros registros)
Para API Nivel 11 o superior:
case TelephonyManager.PHONE_TYPE_SIP:
return "SIP";
TelephonyManager tm= (TelephonyManager)getSystemService(Context.TELEPHONY_SERVICE);
textDeviceID.setText(getDeviceID(tm));
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.
Puede usar esta función de TelephonyManager TELEPHONY_SERVICE 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 .
Utilizo el siguiente código para obtener el IMEI o uso 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;
}
para obtener IMEI (identificador internacional de equipos móviles)
public String getIMEI(Activity activity) {
TelephonyManager telephonyManager = (TelephonyManager) activity
.getSystemService(Context.TELEPHONY_SERVICE);
return telephonyManager.getDeviceId();
}
para obtener el ID único del dispositivo
public String getDeviceUniqueID(Activity activity){
String device_unique_id = Secure.getString(activity.getContentResolver(),
Secure.ANDROID_ID);
return device_unique_id;
}
Nueva actualización:
Para la versión 6 y superior de Android, 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 .
Respuesta anterior:
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 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 se ha desaprobado en Marshmallow forward. Así obtendrá un valor falso)
También podemos obtener la ID única para teléfonos Android con 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 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:
Le da un valor falso de malvavisco y superior.
Si el dispositivo no tiene hardware wifi, se obtiene una dirección MAC nula, pero en general se ve que la mayoría de los dispositivos Android tienen hardware wifi y casi no hay dispositivos en el mercado sin hardware wifi.
FUENTE: technetexperts.com
Desea llamar a android.telephony.TelephonyManager.getDeviceId() .
Esto devolverá cualquier cadena que identifique de forma única 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, ten cuidado de hacer esto. Los usuarios no solo se preguntarán por qué su aplicación está accediendo a su pila de telefonía, sino que también puede 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 se recomienda. En su lugar, consulte la API de inicio de sesión de Google+ si desea implementar un sistema de inicio de sesión sin fricción.
La API de copia de seguridad de Android también está disponible si solo desea una forma ligera de conservar un conjunto de cadenas para cuando un usuario reinicia su teléfono (o compra un nuevo dispositivo).