Comment obtenir IMEI / ESN de l'appareil par programmation dans Android?


343

Pour identifier chaque appareil de manière unique, je voudrais utiliser l'IMEI (ou le numéro ESN pour les appareils CDMA). Comment y accéder par programmation?


Pour obtenir IMEI pour les deux SIM dans les téléphones à double SIM, utilisez les réflexions Java. Voir ici est la démo
Vaibhav Jani

5
@PiedPiper: IMEI n'est pas spécifique à SIM. Vous pensez IMSI.
Phillip

@Phillip Thanks mate. J'ai mis à jour ma réponse :)
Vaibhav Jani

1
Tout le monde .. y a-t-il des changements dans Android 6? pouvons-nous toujours accéder à l'IMEI par certains moyens?
therealprashant

1
Vous devez demander l'autorisation READ_PHONE_STATE au moment de l'exécution, puis vous pouvez toujours obtenir l'IMEI
Flo We

Réponses:


387

Tu veux appeler android.telephony.TelephonyManager.getDeviceId().

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

Vous aurez besoin de l'autorisation suivante dans votre AndroidManifest.xml:

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

pour ce faire.

Cela étant dit, soyez prudent à ce sujet. 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 nouvel appareil.

Mise à jour: Comme mentionné dans les commentaires ci-dessous, ce n'est pas un moyen sûr d'authentifier les utilisateurs et soulève des problèmes de confidentialité. Ce n'est pas recommandé. Regardez plutôt l' API de connexion Google+ si vous souhaitez implémenter un système de connexion sans friction.

L' API de sauvegarde Android est également disponible si vous voulez simplement un moyen léger de conserver un ensemble de chaînes lorsque l'utilisateur réinitialise son téléphone (ou achète un nouvel appareil).


1
Quelle serait alors une meilleure solution qui leur permettrait de migrer des données à l'avenir? Adresse e-mail Google? Si oui, comment puis-je retirer cela du système?
Tom

3
La façon la plus fiable de le faire est de leur demander de créer un compte la première fois qu'ils lancent votre application. Il existe des moyens d'obtenir l'adresse e-mail de l'utilisateur (voir les documents sur AccountManager), mais vérifier qu'un utilisateur malveillant n'a pas falsifié ces informations nécessite un peu de connaissance sur le fonctionnement des API de données Google - plus que je ne peux y mettre petite boîte de commentaires. ;)
Trevor Johns

1
En fait, d'ailleurs, vous n'avez aucune garantie que l'utilisateur n'a pas forgé son IMEI / MEID non plus. Si la sécurité est un problème, vous devez vraiment utiliser un nom d'utilisateur / mot de passe ou la méthode getAuthToken () dans AccountManager (et encore une fois, vous devrez vérifier ce jeton auprès du serveur qui l'a émis à l'origine).
Trevor Johns

2
Adi: Le code pour obtenir l'ID de l'appareil? Il n'y a rien de plus que la seule méthode + permission que j'ai mentionnée ci-dessus. Cela dit, vous devriez vous pencher sur l'API de connexion Google+, c'est l'approche recommandée pour authentifier les utilisateurs ces jours-ci: developer.android.com/google/play-services/auth.html
Trevor Johns

2
Fonctionne-t-il sous Android 6? Et visez-vous le SDK 23? Ensuite, vous devez demander READ_PHONE_STATE au moment de l'exécution avant d'interroger l'IMEI
Flo We

284

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 l'autorisation suivante dans votre fichier Manifest.xml:

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

Dans l'émulateur, vous obtiendrez probablement une valeur similaire à "00000 ...". getDeviceId () renvoie NULL si l'ID de périphérique n'est pas disponible.


1
Existe-t-il un moyen d'obtenir de l'émulateur qu'il renvoie un numéro IMEI?
MikeSchem

@MikeSchem, l'émulateur n'a pas de chaîne IMEI significative.
shizhen

Essayez de ne pas utiliser: <uses-permission android: name = "android.permission.READ_PHONE_STATE" /> cette autorisation est très sensible, vous pouvez obtenir le rejet de l'application de l'équipe Google Play (nouvelles règles de sécurité ajoutées fin 2018). Comme conseil, utilisez mieux la publicité ID.
Duna

@Taner Cela fonctionnera-t-il sur un appareil Dual SIM? (Besoin d'obtenir le premier IMEI uniquement)
Arnold Brown

Y a-t-il un problème de sécurité pour l'utilisation de l' READ_PHONE_STATEautorisation?
viper

62

J'utilise le code suivant pour obtenir l'IMEI ou utiliser Secure.ANDROID_ID comme alternative, lorsque l'appareil n'a pas de capacités téléphoniques:

/**
 * 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 (identifier == null || identifier .length () == 0)
Mikhaili

2
Salut Pinhassi, Avez-vous eu un cas où l'ID d'appareil retourné par le gestionnaire de téléphonie était nul ou vide, mais la valeur lue depuis Secure.ANDROID_ID n'était pas vide? Merci
Budda

4
Pour autant que je me souvienne, c'était pour les tablettes sans carte SIM (mais je ne suis pas sûr à 100%).
Asaf Pinhassi

Secure.ANDROID_ID change si l'appareil est formaté ou si la rom est réinitialisée aux
paramètres d'

Mon Nexus7 (1stGen) revient nullpour le périphérique de téléphonieId ... Quelqu'un sait comment obtenir un IMEI à partir d'une tablette?
Sakiboy

38

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

Cela a l'avantage de ne pas nécessiter d'autorisations spéciales mais peut changer si une autre application a un accès en écriture et le modifie (ce qui est apparemment 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);

Remarque sur la mise en œuvre : si l'ID est essentiel à l'architecture du système, vous devez être conscient qu'en pratique, certains des téléphones et tablettes Android très bas de gamme ont été trouvés réutilisant le même ANDROID_ID (9774d56d682e549c était la valeur indiquée dans nos journaux)


15
Cette constante est déconseillée. Vous devez plutôt utiliser android.provider.Settings.Secure.ANDROID_ID;
mcorley

@mcorley lorsque j'utilise android.provider.Settings.Secure.ANDROID_ID pour la tablette Nexus 7 et Nexus 4, il renvoie la même valeur 'android_id'
vuhung3990

3
@meowmeo a fait la même chose pour moi, jusqu'à ce que j'utilise le code qui fait maintenant partie de la réponse (ish). String androidID = android.provider.Settings.System.getString(this.getContentResolver(), Secure.ANDROID_ID);
Matthias

Mais cela ne serait-il pas réinitialisé à un nouvel ANDROID_ID lors de la réinitialisation d'usine? Et si j'ai besoin d'un ANDROID_ID persistant qui peut survivre aux réinitialisations.
IgorGanapolsky

35

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

Le code suivant aide à obtenir le nombre IMEI d'appareils 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 faire office de téléphone mobile, l'IMEI sera nul.


1
c'est le code réel que je trouve pour obtenir IMEI
Anand Savjani

2
Malheureusement, avec Marshmallow en avant, vous devez maintenant demander cette autorisation au moment de l'exécution. Cette autorisation n'est pas idéale, car elle perturbe l'expérience utilisateur et peut rendre certains utilisateurs suspects.
IgorGanapolsky

Essayez de ne pas utiliser: <uses-permission android: name = "android.permission.READ_PHONE_STATE" /> cette autorisation est très sensible, vous pouvez obtenir le rejet de l'application de l'équipe Google Play (nouvelles règles de sécurité ajoutées fin 2018). Comme conseil, utilisez plutôt l'ID publicitaire à la place IMEI
Duna

quelle est la solution pour android 10?
Amin Pinjari

23

obtenir l' IMEI (identifiant international de l'équipement mobile)

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

pour obtenir l' 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;
}

2
Montrer l'alternative device_unique_id est vraiment utile
JoeGalind

20

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

La meilleure façon de procéder est lors de 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, vous ou quelqu'un.


16

Nouvelle mise à jour:

Pour Android version 6 et au-dessus, l'adresse MAC WLAN a été déconseillée, suivez la réponse de Trevor Johns

Mettre à jour:

Pour une identification unique des appareils, vous pouvez utiliser Secure.ANDROID_ID .

Ancienne réponse:

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

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

Vous pouvez utiliser la chaîne d'adresse MAC WLAN (non recommandé pour Marshmallow et Marshmallow + car l'adresse MAC WLAN a été déconseillée sur Marshmallow en avant. Vous obtiendrez donc une valeur bidon)

Nous pouvons également obtenir l'ID unique pour les téléphones Android en utilisant l'adresse MAC WLAN. L'adresse MAC est unique pour tous les appareils et fonctionne pour tous les types d'appareils.

Avantages de l'utilisation de l'adresse MAC WLAN comme 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 comme ID de périphérique:

  • Donnez-vous une valeur fausse de guimauve et au-dessus.

  • Si l'appareil n'a pas de matériel wifi, vous obtenez une adresse MAC nulle, mais généralement, la plupart des appareils Android ont un matériel wifi et il y a à peine quelques appareils sur le marché sans matériel wifi.

SOURCE: technetexperts.com


7
"IMEI dépend de la carte SIM" ... C'est faux. Vous semblez confondre l'IMEI avec le numéro IMSI
Merlevede

2
Une identité internationale d'équipement de station mobile ou IMEI est un numéro qui identifie les téléphones mobiles fonctionnant sur un réseau GSM. Je l'ai personnellement essayé et cela me donne une valeur nulle par programme s'il n'y a pas de support sans fil sur le téléphone GSM. smartmobilephonesolutions.com/content/…
Jamil

3
Tu as raison, je n'ai pas lu attentivement. L'IMEI est associé à l'émetteur-récepteur de la carte SIM, pas à la carte SIM. Ma faute!
Merlevede

2
L'adresse MAC WLAN est obsolète sur Marshmallow forward. Vous obtiendrez donc une valeur fausse!
IgorGanapolsky

1
android 6 ne renvoie pas l'adresse MAC WIFI correcte avec votre code. Remarquez-le.
zszen

15

Comme dans l'API 26 getDeviceId()est amorti, vous pouvez donc utiliser le code suivant pour répondre à l'API 26 et aux 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 des demandes d'autorisation pour READ_PHONE_STATEutiliser le code ci-dessus.

MISE À JOUR: À partir d'Android 10, il est limité pour les applications utilisateur d'obtenir des identifiants matériels non réinitialisables comme IMEI.


Partage d'esprit où puis-je trouver la référence pour la méthode 'getImei () "?
sam octet

2
Bien sûr, veuillez utiliser developer.android.com/reference/android/telephony/… pour la référence getImei ()
Muhammad Hamza Shahid

quelle est la solution pour android 10?
Amin Pinjari

1
Amin malheureusement dans Android 10 pour des raisons de sécurité, il est désormais limité pour les applications tierces d'obtenir des identifiants matériels comme IMEI pour plus d'informations sur les changements de confidentialité dans Android 10, visitez developer.android.com/about/versions/10/privacy
Muhammad Hamza Shahid

Fonctionne sur Android Oreo.
Satish Shetty

10

La méthode getDeviceId () de TelephonyManager renvoie l'ID d'appareil unique, par exemple, l'IMEI pour GSM et le MEID ou ESN pour les téléphones CDMA. Renvoie null si l'ID de périphérique 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.


4

Vous pouvez utiliser cette fonction TelephonyManager TELEPHONY_SERVICE pour obtenir un ID d'appareil unique , autorisation requise: READ_PHONE_STATE

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

Exemple, l' IMEI pour GSM et le MEID 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();
}

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


et pourquoi l'ID de l'appareil est nul? à cause du périphérique enraciné.
Vishal Sojitra

quelle est la solution pour android 10?
Amin Pinjari


3

Essayez ceci (vous devez toujours obtenir 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();
        }

quelle est la solution pour android 10? developer.android.com/about/versions/10/privacy
Amin Pinjari

2

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

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

1

pour l'API niveau 11 ou supérieur:

case TelephonyManager.PHONE_TYPE_SIP: 
return "SIP";

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

1

Code Kotlin pour obtenir DeviceId (IMEI) avec autorisation de manipulation et vérification de 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 autorisation à AndroidManifest.xml:

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

1

Vous aurez besoin de l'autorisation suivante dans votre AndroidManifest.xml:

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

Pour obtenir l' IMEI (identifiant international de l'équipement mobile) et s'il est supérieur au niveau 26 de l'API, nous obtenons telephonyManager.getImei()la valeur null, donc pour cela, nous utilisons ANDROID_ID comme identifiant unique.

 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

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 conclure telephonyService()ci-dessus avec une vérification des autorisations à 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

utilisez le code ci-dessous:

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

Et appelez la méthode onRequestPermissionsResult suivante:

@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();
                }
    }
}

Ajoutez l'autorisation suivante dans votre AndroidManifest.xml:

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

0

Pour Android 10, le code suivant fonctionne pour moi.

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
                }
            }
        }
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.