web-dev-qa-db-fra.com

Comment obtenir le numéro IMEI/ESN de l'appareil par programmation dans Android?

Pour identifier chaque périphérique de manière unique, j'aimerais utiliser l'IMEI (ou le numéro ESN pour les périphériques CDMA). Comment accéder à cela par programmation?

androidimei
291
Tom

Vous souhaitez appeler Android.telephony.TelephonyManager.getDeviceId() .

Cela renverra la chaîne identifiant de manière unique le périphérique (IMEI sur GSM, MEID pour CDMA).

Vous aurez besoin de la permission suivante dans votre AndroidManifest.xml:

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

afin de faire cela.

Cela étant dit, faites attention à le faire. Non seulement les utilisateurs se demanderont pourquoi votre application accède à leur pile de téléphonie, mais il peut être difficile de migrer des données si l'utilisateur obtient un nouveau périphérique.

Mise à jour: Comme indiqué dans les commentaires ci-dessous, il ne s’agit pas d’un moyen sûr d’authentifier les utilisateurs et pose des problèmes de confidentialité. Ce n'est pas recommandé. Au lieu de cela, consultez la API de connexion Google+ si vous souhaitez mettre en œuvre un système de connexion sans friction.

L'API Android Backup est également disponible si vous souhaitez simplement un moyen léger de conserver un ensemble de chaînes lorsqu'un utilisateur réinitialise son téléphone (ou achète un nouveau périphérique).

355
Trevor Johns

En plus de la réponse de Trevor Johns, vous pouvez utiliser ceci comme suit:

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

Et vous devez ajouter l'autorisation suivante dans votre fichier Manifest.xml:

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

Dans l'émulateur, vous obtiendrez probablement la même valeur que "00000 ...". getDeviceId () renvoie NULL si l'ID de périphérique n'est pas disponible.

271
Taner

J'utilise le code suivant pour obtenir l'IMEI ou utilise Secure.Android_ID comme alternative, lorsque l'appareil ne dispose pas des capacités du 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;
}
54
Asaf Pinhassi

Ou vous pouvez utiliser le paramètre Android_ID de Android.Provider.Settings.System (comme décrit ici strazerre.com ).

Cela présente l'avantage de ne pas nécessiter d'autorisations spéciales, mais de le modifier si une autre application dispose d'un accès en écriture et le modifie (ce qui est inhabituel, mais pas impossible).

Juste pour référence, voici le code du blog:

import Android.provider.Settings;
import Android.provider.Settings.System;   

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

Note d'implémentation: si l'ID est essentiel pour l'architecture système, vous devez être conscient du fait qu'en pratique, certains téléphones et tablettes Android très bas de gamme ont été trouvés en train de réutiliser le même Android_ID dans nos journaux)} _

34
tonys

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

Le code suivant aide à obtenir le nombre IMEI de périphériques Android:

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

Autorisations requises dans le manifeste Android: 

Android.permission.READ_PHONE_STATE

REMARQUE: dans le cas de tablettes ou d’appareils qui ne peuvent pas fonctionner comme un téléphone mobile IMEI sera nul.

32
alchemist

obtenirIMEI(identifiant international d'équipement mobile)

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

pour obtenir identifiant unique de l'appareil 

public String getDeviceUniqueID(Activity activity){
    String device_unique_id = Secure.getString(activity.getContentResolver(),
            Secure.Android_ID);
    return device_unique_id;
}
21
Zin Win Htet

Pour Android 6.0+, le jeu a changé, je vous suggère donc de l'utiliser.

La meilleure façon de procéder est pendant l'exécution, sinon 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);
}
}

J'espère que cela vous aide ou aide quelqu'un.

17
The Dead Guy

Nouvelle mise à jour:

Pour les versions 6 et supérieures d'Android, l'adresse MAC WLAN est obsolète, suivez la réponse de Trevor Johns

Mettre à jour:

Pour l’identification unique des périphériques, vous pouvez utiliser Secure.Android_ID .

{OLD ANSWER:}

Inconvénients de l'utilisation d'IMEI en tant qu'ID de périphérique unique:

  • IMEI dépend du slot Simcard du périphérique, il n'est donc pas possible d'obtenir l'IMEI pour les périphériques qui n'utilisent pas la Simcard . Dans les appareils Dual Sim, nous obtenons 2 IMEI différents pour le même appareil, car il dispose de 2 emplacements pour carte SIM.

Vous pouvez utiliser la chaîne d'adresse MAC WLAN (non recommandé pour Marshmallow et Marshmallow + car l'adresse MAC WLAN est obsolète pour le transfert de Marshmallow. Vous obtiendrez ainsi une valeur fictive)

Nous pouvons également obtenir l'identifiant unique pour les téléphones Android à l'aide de l'adresse MAC WLAN. L'adresse MAC est unique pour tous les périphériques et fonctionne pour tous les types de périphériques.

Avantages de l'utilisation de l'adresse MAC WLAN en tant qu'ID de périphérique:

  • Il s'agit d'un identifiant unique pour tous les types d'appareils (téléphones intelligents et tablettes ).

  • Il reste unique si l'application est réinstallée

Inconvénients de l'utilisation de l'adresse MAC WLAN en tant qu'ID de périphérique:

  • Donnez-vous une valeur fictive à partir de guimauve et au-dessus.

  • Si le périphérique n’a pas de matériel Wi-Fi, vous obtenez une adresse MAC nulle. mais généralement on voit que la plupart des appareils Android ont le wifi matériel et il y a à peine quelques appareils sur le marché sans wifi Matériel.

SOURCE: technetexperts.com

15
Jamil

Comme dans l'API 26, getDeviceId () est amorti, vous pouvez donc utiliser le code suivant pour gérer l'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();
}

N'oubliez pas d'ajouter une demande d'autorisation pour "READ_PHONE_STATE" à utiliser le code ci-dessus.

12
Muhammad Hamza Shahid

La méthode getDeviceId () de TelephonyManager renvoie l'ID de périphérique unique, par exemple, l'IMEI pour GSM et le MEID ou ESN pour les téléphones CDMA. Renvoie la valeur null si l'ID de périphérique n'est pas disponible.

Java Code  

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.

10
user1014191

Vous pouvez utiliser cette fonction TelephonyManager TELEPHONY_SERVICE pour obtenirID unique de périphérique, Nécessite l'autorisation: READ_PHONE_STATE 

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

Exemple, le IMEI pour GSM et le MEID ou ESN pour les téléphones 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();
}

Retourne null si l'ID de périphérique n'est pas disponible.

4
A-Droid Tech

Utiliser le code ci-dessous vous donne le numéro IMEI:

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

La méthode getDeviceId() est déconseillée . Il existe une nouvelle méthode pour cette getImei(int)

Vérifier ici

2
Waran-

Code Kotlin pour obtenir DeviceId (IMEI) avec autorisation de traitement et vérification de la comparabilité pour toutes les versions d'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 permission à AndroidManifest.xml:

<uses-permission Android:name="Android.permission.READ_PHONE_STATE"/> <!-- IMEI-->
1
Hamed Jaliliani

pour les API de niveau 11 ou supérieur:

case TelephonyManager.PHONE_TYPE_SIP: 
return "SIP";

TelephonyManager tm= (TelephonyManager)getSystemService(Context.TELEPHONY_SERVICE);
textDeviceID.setText(getDeviceID(tm));
1
Anil M H

Pour ceux qui recherchent une version Kotlin, vous pouvez utiliser quelque chose comme ceci;

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 encapsuler telephonyService() ci-dessus avec une vérification d'autorisation à l'aide de checkSelfPermission ou de la méthode que vous utilisez.

Ajoutez également cette autorisation dans le fichier manifeste;

<uses-permission Android:name="Android.permission.READ_PHONE_STATE"/>
0
TitanKing

Essayez ceci (besoin d'avoir toujours le premier IMEI)

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();
        }
0
Arnold Brown