Comment obtenir IMEI / ESN programme dans Android de l'appareil?
https://stackoverflow.com/questions/1972381
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianQuestion
Pour identifier chaque appareil unique, je voudrais utiliser l'IMEI (ou le numéro de NSE pour les appareils CDMA). Comment accéder à ce programme?
La solution
Vous voulez appeler android.telephony.TelephonyManager.getDeviceId() .
Ceci renvoie chaîne identifie de manière unique quelle que soit l'appareil (IMEI sur GSM, CDMA pour IDEM).
Vous aurez besoin de l'autorisation suivante dans votre AndroidManifest.xml:
<uses-permission android:name="android.permission.READ_PHONE_STATE" />
afin de le faire.
Cela étant dit, faites attention à le faire. Non seulement les utilisateurs se demandent pourquoi votre application accède à leur pile de téléphonie, il peut être difficile de migrer des données sur si l'utilisateur obtient un nouveau périphérique.
Mise à jour: Comme mentionné dans les commentaires ci-dessous, ce n'est pas un moyen sécurisé pour authentifier les utilisateurs, et soulève des problèmes de confidentialité. Il est déconseillé. Au lieu de cela, regardez la Google+ Connexion API si vous souhaitez mettre en œuvre un frottement système de connexion.
Le Android API de sauvegarde est également disponible si vous voulez juste un manière légère de persister un paquet de chaînes lorsqu'un utilisateur remet à zéro leur téléphone (ou achète un nouveau périphérique).
Autres conseils
En plus de la réponse de Trevor Johns, vous pouvez l'utiliser comme suit:
TelephonyManager telephonyManager = (TelephonyManager)getSystemService(Context.TELEPHONY_SERVICE);
telephonyManager.getDeviceId();
Et vous devez ajouter la permission suivante dans votre fichier Manifest.xml:
<uses-permission android:name="android.permission.READ_PHONE_STATE"/>
Dans l'émulateur, vous aurez probablement comme une valeur « 00000 ... ». GetDeviceID () retourne NULL si ID du périphérique est disponible.
J'utilise le code suivant pour obtenir le IMEI ou utiliser Secure.ANDROID_ID comme une alternative, lorsque l'appareil ne dispose pas de capacités de téléphone:
/**
* 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;
}
Vous pouvez également utiliser le paramètre ANDROID_ID de Android.Provider.Settings.System (comme décrit ici strazerre. com ).
Ceci a l'avantage qu'il ne nécessite pas d'autorisations spéciales, mais peut changer si une autre application a accès en écriture et change (ce qui est apparemment rare mais pas impossible).
Juste pour référence ici est le code du blog:
import android.provider.Settings;
import android.provider.Settings.System;
String androidID = System.getString(this.getContentResolver(),Secure.ANDROID_ID);
Note de mise en œuvre : si l'ID est essentielle à l'architecture du système, vous devez être conscient du fait que, dans la pratique certains des très bas de gamme des téléphones et tablettes Android ont été trouvés réutiliser le même ANDROID_ID (9774d56d682e549c était la valeur montrant dans nos journaux)
De: http : //mytechead.wordpress.com/2011/08/28/how-to-get-imei-number-of-android-device/ :
Le code suivant contribue à l'obtention de numéro IMEI de dispositifs Applications:
TelephonyManager tm = (TelephonyManager)getSystemService(Context.TELEPHONY_SERVICE);
String device_id = tm.getDeviceId();
Les autorisations requises dans les applications Manifest:
android.permission.READ_PHONE_STATE
NOTE: En cas de comprimés ou de dispositifs qui ne peuvent pas agir en tant que téléphone portable IMEI sera nulle.
pour obtenir IMEI (identifiant international d'équipement mobile)
public String getIMEI(Activity activity) {
TelephonyManager telephonyManager = (TelephonyManager) activity
.getSystemService(Context.TELEPHONY_SERVICE);
return telephonyManager.getDeviceId();
}
pour obtenir id appareil unique
public String getDeviceUniqueID(Activity activity){
String device_unique_id = Secure.getString(activity.getContentResolver(),
Secure.ANDROID_ID);
return device_unique_id;
}
Pour Android 6.0+ le jeu a changé donc je vous suggère d'utiliser cette;
La meilleure façon d'aller est au cours de l'exécution autre que vous obtenez des erreurs d'autorisation.
/**
* 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);
}
}
Espérons que cela vous aide ou quelqu'un.
Nouvelle mise à jour:
Pour Android version 6 et au-dessus, WLAN Adresse MAC a été dépréciée, suivez réponse Trevor Johns
Mise à jour:
Pour unique d'identification des appareils, vous pouvez utiliser sécurisé. ANDROID_ID.
Old Réponse:
Inconvénients de l'utilisation IMEI comme ID de périphérique unique:
- IMEI est dépendante de la fente de carte SIM du dispositif, il est donc pas possible d'obtenir le IMEI pour les appareils qui n'utilisent pas Simcard. Dans les dispositifs SIM double, nous obtenons 2 différents IMEI pour le même dispositif que il dispose de 2 emplacements pour cartes SIM.
Vous pouvez utiliser le réseau local sans fil MAC Chaîne d'adresses (non recommandé pour Marshmallow et Marshmallow + comme WLAN Adresse MAC a été dépréciée sur Guimauve avant. Vous obtiendrez une valeur bogus)
Nous pouvons obtenir l'ID unique pour les téléphones Android en utilisant l'adresse MAC WLAN également. L'adresse MAC est unique pour tous les appareils et il fonctionne pour tous les types de périphériques.
Avantages de l'utilisation comme adresse MAC WLAN Device ID:
-
Il est l'identifiant unique pour tous les types d'appareils (téléphones intelligents et comprimés).
-
Il reste unique si l'application est réinstallée
Les inconvénients de l'utilisation de l'adresse MAC WLAN Device ID:
-
Donnez-vous un Bogus Valeur de Guimauve et au-dessus.
-
Si l'appareil ne dispose pas de matériel wifi vous obtenir l'adresse MAC null, mais généralement on voit que la plupart des appareils Android ont wifi matériel et il y a à peine quelques appareils sur le marché sans wifi matériel.
SOURCE: technetexperts .com
Comme dans l'API 26 GetDeviceID () est amorti, vous pouvez donc utiliser le code ci-dessous pour répondre API 26 et les versions antérieures
TelephonyManager telephonyManager = (TelephonyManager)getSystemService(Context.TELEPHONY_SERVICE);
String imei="";
if (android.os.Build.VERSION.SDK_INT >= 26) {
imei=telephonyManager.getImei();
}
else
{
imei=telephonyManager.getDeviceId();
}
Ne pas oublier d'ajouter la demande d'autorisation pour « READ_PHONE_STATE » utiliser le code ci-dessus.
La méthode GetDeviceID () de TelephonyManager retourne le dispositif identifiant unique, par exemple, l'IMEI pour le GSM et le MEID ou ESN pour les téléphones CDMA. Retour null si l'appareil ID n'est pas disponible.
code 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>
Autorisation requise READ_PHONE_STATE dans le fichier manifeste.
Vous pouvez utiliser cette TelephonyManager TELEPHONY_SERVICE fonction pour obtenir appareil unique ID , Nécessite la permission: READ_PHONE_STATE
<uses-permission android:name="android.permission.READ_PHONE_STATE" />
Exemple, IMEI pour GSM et IDEM ou ESN pour CDMA téléphones.
/**
* 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();
}
Retour null si ID de périphérique n'est pas disponible .
La méthode getDeviceId() est obsolète.
Il une nouvelle méthode pour cette getImei(int)
Utilisez le code ci-dessous vous donne le numéro IMEI:
TelephonyManager telephonyManager = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);
System.out.println("IMEI::" + telephonyManager.getDeviceId());
Essayez ceci (besoin d'obtenir d'abord IMEI toujours)
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();
}
pour l'API de niveau 11 ou au-dessus:
case TelephonyManager.PHONE_TYPE_SIP:
return "SIP";
TelephonyManager tm= (TelephonyManager)getSystemService(Context.TELEPHONY_SERVICE);
textDeviceID.setText(getDeviceID(tm));
Code de Kotlin pour obtenir DeviceId (IMEI) avec l'autorisation de traitement et de la vérification de la comparabilité pour toutes les versions 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
}
Ajoutez également cette autorisation à AndroidManifest.xml:
<uses-permission android:name="android.permission.READ_PHONE_STATE"/> <!-- IMEI-->
Pour ceux qui recherchent une version Kotlin, vous pouvez utiliser quelque chose comme ça;
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")
}
REMARQUE: Vous devez envelopper telephonyService() ci-dessus avec un chèque d'autorisation en utilisant checkSelfPermission ou toute autre méthode que vous utilisez.
Ajoutez également cette autorisation dans le fichier manifeste;
<uses-permission android:name="android.permission.READ_PHONE_STATE"/>
