Wie bekomme ich das IMEI / ESN des Geräts programmgesteuert in Android?

Um jedes Gerät eindeutig zu identifizieren, möchte ich die IMEI (oder ESN-Nummer für CDMA-Geräte) verwenden. Wie kann man programmgesteuert darauf zugreifen?

Sie möchten anrufen android.telephony.TelephonyManager.getDeviceId().

Dies gibt die Zeichenfolge zurück, die das Gerät eindeutig identifiziert (IMEI auf GSM, MEID für CDMA).

Sie benötigen die folgende Erlaubnis in Ihrem AndroidManifest.xml:

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

Um dies zu tun.

Seien Sie jedoch vorsichtig, wenn Sie dies tun. Benutzer werden sich nicht nur fragen, warum Ihre Anwendung auf ihren Telefoniestapel zugreift, es kann auch schwierig sein, Daten zu migrieren, wenn der Benutzer ein neues Gerät erhält.

Update: Wie in den Kommentaren unten erwähnt, ist dies keine sichere Methode zur Authentifizierung von Benutzern und wirft Datenschutzbedenken auf. Es wird nicht empfohlen. Schauen Sie sich stattdessen die Google+ Login-API an, wenn Sie ein reibungsloses Login-System implementieren möchten.

Die Android Backup-API ist auch verfügbar, wenn Sie nur eine einfache Methode zum Beibehalten eines Bündels von Zeichenfolgen benötigen, wenn ein Benutzer sein Telefon zurücksetzt (oder ein neues Gerät kauft).

Zusätzlich zur Antwort von Trevor Johns können Sie dies wie folgt verwenden:

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

Und Sie sollten Ihrer Manifest.xml-Datei die folgende Berechtigung hinzufügen:

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

Im Emulator erhalten Sie wahrscheinlich einen Wert wie "00000 ...". getDeviceId () gibt NULL zurück, wenn die Geräte-ID nicht verfügbar ist.

Ich verwende den folgenden Code, um die IMEI abzurufen, oder verwende Secure.ANDROID_ID als Alternative, wenn das Gerät keine Telefonfunktionen hat:

/**
 * 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;
}

Oder Sie können die Einstellung ANDROID_ID von Android.Provider.Settings.System verwenden (wie hier beschrieben strazerre.com ).

Dies hat den Vorteil, dass keine speziellen Berechtigungen erforderlich sind, sich jedoch ändern können, wenn eine andere Anwendung Schreibzugriff hat und diese ändert (was anscheinend ungewöhnlich, aber nicht unmöglich ist).

Nur als Referenz hier ist der Code aus dem Blog:

import android.provider.Settings;
import android.provider.Settings.System;   

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

Implementierungshinweis : Wenn die ID für die Systemarchitektur von entscheidender Bedeutung ist, müssen Sie sich darüber im Klaren sein, dass in der Praxis festgestellt wurde, dass einige der sehr einfachen Android-Telefone und -Tablets dieselbe ANDROID_ID wiederverwenden (9774d56d682e549c war der Wert, der in unseren Protokollen angezeigt wurde).

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

Der folgende Code hilft beim Abrufen der IMEI-Anzahl von Android-Geräten:

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

In Android Manifest erforderliche Berechtigungen:

android.permission.READ_PHONE_STATE

HINWEIS: Bei Tablets oder Geräten, die nicht als Mobiltelefon fungieren können, ist IMEI null.

zu bekommen IMEI (International Mobile Equipment Identifier)

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

um eine eindeutige Geräte-ID zu erhalten

public String getDeviceUniqueID(Activity activity){
    String device_unique_id = Secure.getString(activity.getContentResolver(),
            Secure.ANDROID_ID);
    return device_unique_id;
}

Für Android 6.0+ hat sich das Spiel geändert, daher schlage ich vor, dass Sie dies verwenden.

Der beste Weg ist zur Laufzeit, sonst erhalten Sie Berechtigungsfehler.

   /**
 * 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);
}
}

Hoffe das hilft dir oder jemandem.

Neues Update:

Für Android Version 6 und höher ist die WLAN-MAC-Adresse veraltet. Folgen Sie der Antwort von Trevor Johns

Aktualisieren:

Zur eindeutigen Identifizierung von Geräten können Sie Secure.ANDROID_ID verwenden .

Alte Antwort:

Nachteile der Verwendung von IMEI als eindeutige Geräte-ID:

• IMEI ist vom Simcard-Steckplatz des Geräts abhängig, daher ist es nicht möglich, die IMEI für Geräte abzurufen, die Simcard nicht verwenden. In Dual-Sim-Geräten erhalten wir 2 verschiedene IMEIs für dasselbe Gerät, da es 2 Steckplätze für Simkarten hat.

Sie können die Zeichenfolge für die WLAN-MAC-Adresse verwenden (Nicht empfohlen für Marshmallow und Marshmallow +, da die WLAN-MAC-Adresse für Marshmallow Forward veraltet ist. Sie erhalten also einen falschen Wert.)

Wir können die eindeutige ID für Android-Telefone auch über die WLAN-MAC-Adresse abrufen. Die MAC-Adresse ist für alle Geräte eindeutig und funktioniert für alle Arten von Geräten.

Vorteile der Verwendung der WLAN-MAC-Adresse als Geräte-ID:

• Es ist eine eindeutige Kennung für alle Arten von Geräten (Smartphones und Tablets).

• Es bleibt eindeutig, wenn die Anwendung neu installiert wird

Nachteile der Verwendung der WLAN-MAC-Adresse als Geräte-ID:

• Geben Sie einen Scheinwert von Marshmallow und höher.

• Wenn das Gerät keine WLAN-Hardware hat, erhalten Sie eine Null-MAC-Adresse. Im Allgemeinen wird jedoch festgestellt, dass die meisten Android-Geräte über WLAN-Hardware verfügen und es auf dem Markt kaum wenige Geräte ohne WLAN-Hardware gibt.

QUELLE: technetexperts.com

Wie in API 26 getDeviceId()wird abgeschrieben, sodass Sie den folgenden Code verwenden können, um API 26 und frühere Versionen bereitzustellen

TelephonyManager telephonyManager = (TelephonyManager)getSystemService(Context.TELEPHONY_SERVICE);
String imei="";
if (android.os.Build.VERSION.SDK_INT >= 26) {
  imei=telephonyManager.getImei();
}
else
{
  imei=telephonyManager.getDeviceId();
}

Vergessen Sie nicht, Berechtigungsanforderungen für READ_PHONE_STATEdie Verwendung des obigen Codes hinzuzufügen .

UPDATE: Ab Android 10 ist es für Benutzer-Apps beschränkt, nicht zurücksetzbare Hardware-IDs wie IMEI zu erhalten.

Die Methode getDeviceId () von TelephonyManager gibt die eindeutige Geräte-ID zurück, z. B. die IMEI für GSM und die MEID oder ESN für CDMA-Telefone. Geben Sie null zurück, wenn die Geräte-ID nicht verfügbar ist.

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> 

Erforderliche Berechtigung READ_PHONE_STATE in der Manifestdatei.

Mit dieser Funktion TelephonyManager TELEPHONY_SERVICE können Sie eine eindeutige Geräte-ID abrufen. Erfordert die Berechtigung: READ_PHONE_STATE

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

Beispiel: IMEI für GSM und MEID oder ESN für CDMA- Telefone.

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

Geben Sie null zurück, wenn die Geräte-ID nicht verfügbar ist .

Die Methode getDeviceId()ist veraltet. Hierfür gibt es eine neue MethodegetImei(int)

Überprüfe hier

Versuchen Sie dies (müssen immer zuerst IMEI erhalten)

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

Wenn Sie den folgenden Code verwenden, erhalten Sie die IMEI-Nummer:

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

für API Level 11 oder höher:

case TelephonyManager.PHONE_TYPE_SIP: 
return "SIP";

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

Kotlin-Code zum Abrufen von DeviceId (IMEI) mit Bearbeitungsberechtigung und Vergleichbarkeitsprüfung für alle Android-Versionen:

 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

    }

Fügen Sie diese Berechtigung auch zu AndroidManifest.xml hinzu:

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

Sie benötigen die folgende Berechtigung in Ihrer AndroidManifest.xml:

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

Um IMEI (International Mobile Equipment Identifier) ​​zu erhalten und wenn es über API Level 26 liegt, erhalten wir telephonyManager.getImei()als Null. Daher verwenden wir ANDROID_ID als Unique Identifier.

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

Für diejenigen, die nach einer Kotlin-Version suchen, können Sie so etwas verwenden.

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")
}

HINWEIS: Sie müssen telephonyService()oben eine Berechtigungsprüfung mit checkSelfPermission oder einer anderen von Ihnen verwendeten Methode durchführen.

Fügen Sie diese Berechtigung auch in die Manifestdatei ein.

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

Verwenden Sie den folgenden Code:

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

Rufen Sie die onRequestPermissionsResult-Methode mit folgendem Code auf:

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

Fügen Sie Ihrer AndroidManifest.xml folgende Berechtigung hinzu:

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

Für Android 10 Der folgende Code funktioniert für mich.

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
                }
            }
        }