Jak programowo uzyskać IMEI / ESN urządzenia w Androidzie?

343

Aby jednoznacznie zidentyfikować każde urządzenie, chciałbym użyć numeru IMEI (lub numeru ESN dla urządzeń CDMA). Jak uzyskać dostęp do tego programowo?

Tomek
źródło
Aby uzyskać IMEI dla obu kart SIM w telefonach z dwiema kartami SIM, użyj odbić Java. Zobacz tutaj jest demo
Vaibhav Jani
5
@PiedPiper: IMEI nie jest specyficzne dla karty SIM. Myślisz o IMSI.
Phillip
@Phillip Dzięki kolego. Zaktualizowałem swoją odpowiedź :)
Vaibhav Jani
1
Wszyscy .. czy są jakieś zmiany w Androidzie 6? czy nadal możemy uzyskać dostęp do IMEI w jakiś sposób?
therealprashant
1
Musisz poprosić o zezwolenie READ_PHONE_STATE w czasie wykonywania, wtedy nadal możesz uzyskać IMEI
Flo We

Odpowiedzi:

387

Chcesz zadzwonić android.telephony.TelephonyManager.getDeviceId().

Zwróci to ciąg znaków, który jednoznacznie identyfikuje urządzenie (IMEI na GSM, MEID dla CDMA).

Będziesz potrzebować następującego pozwolenia w swoim AndroidManifest.xml:

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

aby to zrobić.

Biorąc to pod uwagę, uważaj na to. Użytkownicy będą nie tylko zastanawiać się, dlaczego aplikacja uzyskuje dostęp do stosu telefonii, ale migracja danych może być trudna, jeśli użytkownik otrzyma nowe urządzenie.

Aktualizacja: jak wspomniano w komentarzach poniżej, nie jest to bezpieczny sposób uwierzytelniania użytkowników i budzi obawy dotyczące prywatności. Nie jest to zalecane. Zamiast tego spójrz na interfejs API do logowania Google+, jeśli chcesz wdrożyć bezproblemowy system logowania.

Android API kopii zapasowej jest również dostępna, jeśli chcesz tylko lekki sposób, aby utrzymywać wiązkę Struny do kiedy użytkownik resetuje swój telefon (lub kupuje nowe urządzenie).

Trevor Johns
źródło
1
Jakie byłoby lepsze rozwiązanie, które umożliwiłoby im migrację danych w przyszłości? Adres e-mail Google? Jeśli tak, to jak mogę to wyciągnąć z systemu?
Tom
3
Najbardziej niezawodnym sposobem na to jest utworzenie konta przy pierwszym uruchomieniu aplikacji. Istnieją sposoby na uzyskanie adresu e-mail użytkownika (zobacz dokumenty na AccountManager), ale sprawdzenie, czy złośliwy użytkownik nie podrobił tych informacji, wymaga nieco wiedzy na temat działania interfejsów API Google Data - więcej, niż mogę w tym napisać małe pole komentarza. ;)
Trevor Johns
1
Właściwie to nie masz żadnej gwarancji, że użytkownik również nie podrobił swojego numeru IMEI / MEID. Jeśli bezpieczeństwo budzi jakiekolwiek obawy, naprawdę musisz użyć nazwy użytkownika / hasła lub metody getAuthToken () w AccountManager (i ponownie, musisz zweryfikować ten token na serwerze, który go pierwotnie wydał).
Trevor Johns
2
Adi: kod do uzyskania identyfikatora urządzenia? Nie ma nic więcej niż jedna metoda + pozwolenie, o którym wspomniałem powyżej. To powiedziawszy, powinieneś przyjrzeć się API logowania do Google+, jest to obecnie zalecane podejście do uwierzytelniania użytkowników: developer.android.com/google/play-services/auth.html
Trevor Johns
2
Czy to działa na Androidzie 6? Czy kierujesz reklamy na pakiet SDK 23? Następnie musisz poprosić o READ_PHONE_STATE w czasie wykonywania przed wysłaniem zapytania do IMEI
Flo We
284

Oprócz odpowiedzi Trevora Johnsa możesz użyć tego w następujący sposób:

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

I powinieneś dodać następujące uprawnienia do pliku Manifest.xml:

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

W emulatorze prawdopodobnie uzyskasz wartość „00000 ...”. getDeviceId () zwraca NULL, jeśli identyfikator urządzenia nie jest dostępny.

Taner
źródło
1
Czy istnieje sposób, aby emulator zwrócił numer IMEI?
MikeSchem
@MikeSchem, emulator nie ma znaczącego ciągu IMEI.
shizhen
Spróbuj nie używać: <uses-permission android: name = "android.permission.READ_PHONE_STATE" /> to uprawnienie jest bardzo wrażliwe, możesz otrzymać aplikację odrzuconą od zespołu Google Play (nowe reguły bezpieczeństwa dodano pod koniec 2018 roku). Jako poradę lepiej użyj identyfikatora reklamowego.
Duna
@ Taner Czy to będzie działać na urządzeniu Dual SIM? (Musisz zdobyć tylko pierwszy IMEI)
Arnold Brown
Czy korzystanie z READ_PHONE_STATEuprawnień wiąże się z obawami dotyczącymi bezpieczeństwa ?
viper
62

Korzystam z następującego kodu, aby uzyskać numer IMEI, lub alternatywnie korzystam z Secure.ANDROID_ID, gdy urządzenie nie ma możliwości telefonu:

/**
 * 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;
}
Asaf Pinhassi
źródło
17
TextUtils.isEmpty () -> if (identyfikator == null || identyfikator .length () == 0)
Mikhaili
2
Cześć Pinhassi, Czy zdarzyło Ci się, że identyfikator urządzenia zwrócony przez menedżera telefonii był zerowy lub pusty, ale wartość odczytana z Secure.ANDROID_ID nie była pusta? Dziękuję
Budda,
4
O ile pamiętam, dotyczyło to tabletów bez karty SIM (ale nie jestem w 100% pewien).
Asaf Pinhassi
Secure.ANDROID_ID zmienia się, jeśli urządzenie zostanie sformatowane lub ROM zostanie przywrócony do ustawień fabrycznych
Shridutt Kothari
Mój Nexus7 (1stGen) zwraca nullurządzenie telefoniczneId ... Czy ktoś wie, jak uzyskać numer IMEI z tabletu?
Sakiboy,
38

Lub możesz użyć ustawienia ANDROID_ID z Android.Provider.Settings.System (jak opisano tutaj strazerre.com ).

Ma to tę zaletę, że nie wymaga specjalnych uprawnień, ale może się zmienić, jeśli inna aplikacja ma dostęp do zapisu i ją zmieni (co jest pozornie niezwykłe, ale nie niemożliwe).

Dla odniesienia tutaj jest kod z bloga:

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

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

Uwaga dotycząca implementacji : jeśli identyfikator ma krytyczne znaczenie dla architektury systemu, należy pamiętać, że w praktyce niektóre z bardzo niskiej klasy telefonów i tabletów z Androidem wykorzystały ten sam ANDROID_ID (wartość 9774d56d682e549c była wartością wyświetlaną w naszych logach)

Tony
źródło
15
Ta stała jest przestarzała. Zamiast tego musisz użyć android.provider.Settings.Secure.ANDROID_ID;
mcorley,
@mcorley, gdy korzystam z android.provider.Settings.Secure.ANDROID_ID dla tabletu Nexus 7 i Nexusa 4, zwraca tę samą wartość „android_id”
vuhung3990
3
@meowmeo zrobił to samo dla mnie, dopóki nie użyłem kodu, który jest teraz częścią odpowiedzi (ish). String androidID = android.provider.Settings.System.getString(this.getContentResolver(), Secure.ANDROID_ID);
Matthias
Ale czy nie przywróci to nowego ANDROID_ID po przywróceniu ustawień fabrycznych? Co jeśli potrzebuję trwałego ANDROID_ID, który może przetrwać resety.
IgorGanapolsky
35

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

Poniższy kod pomaga w uzyskaniu numeru IMEI urządzeń z systemem Android:

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

Uprawnienia wymagane w Manifeście Androida:

android.permission.READ_PHONE_STATE

UWAGA: W przypadku tabletów lub urządzeń, które nie mogą działać jako telefon komórkowy, numer IMEI będzie zerowy.

alchemik
źródło
1
to jest rzeczywisty kod, który szukam, aby uzyskać IMEI
Anand Savjani
2
Niestety, z Marshmallow naprzód musisz teraz poprosić o to pozwolenie w czasie wykonywania. To uprawnienie nie jest idealne, ponieważ zakłóca komfort użytkowania i może wzbudzać podejrzenia niektórych użytkowników.
IgorGanapolsky
Spróbuj nie używać: <uses-permission android: name = "android.permission.READ_PHONE_STATE" /> to uprawnienie jest bardzo wrażliwe, możesz otrzymać aplikację odrzuconą od zespołu Google Play (nowe reguły bezpieczeństwa dodano pod koniec 2018 roku). Jako poradę lepiej użyj identyfikatora reklamowego zamiast IMEI
Duna
jakie jest rozwiązanie dla Androida 10?
Amin Pinjari,
23

uzyskać IMEI (międzynarodowy identyfikator urządzenia mobilnego)

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

aby uzyskać unikalny identyfikator urządzenia

public String getDeviceUniqueID(Activity activity){
    String device_unique_id = Secure.getString(activity.getContentResolver(),
            Secure.ANDROID_ID);
    return device_unique_id;
}
Zin Win Htet
źródło
2
Pokazanie alternatywy device_unique_id jest naprawdę pomocne
JoeGalind
20

W przypadku Androida 6.0+ gra się zmieniła, więc sugeruję, abyś z niej skorzystał;

Najlepszym sposobem jest przejście w czasie wykonywania, w przeciwnym razie wystąpią błędy uprawnień.

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

Mam nadzieję, że to pomoże tobie lub komuś.

The Dead Guy
źródło
16

Nowa aktualizacja:

W Androidzie w wersji 6 i nowszych adres MAC WLAN jest nieaktualny, postępuj zgodnie z odpowiedzią Trevor Johns

Aktualizacja:

Do jednoznacznej identyfikacji urządzeń możesz użyć Secure.ANDROID_ID .

Stara odpowiedź:

Wady używania IMEI jako unikalnego identyfikatora urządzenia:

  • IMEI zależy od gniazda karty SIM w urządzeniu, więc nie można uzyskać numeru IMEI dla urządzeń, które nie używają karty SIM. W urządzeniach z dwiema kartami SIM otrzymujemy 2 różne numery IMEI dla tego samego urządzenia, ponieważ ma 2 gniazda na kartę SIM.

Możesz użyć ciągu adresu MAC WLAN (niezalecane dla Marshmallow i Marshmallow +, ponieważ adres MAC WLAN został przestarzały podczas przesyłania Marshmallow do przodu. Otrzymasz więc fałszywą wartość)

Możemy również uzyskać unikalny identyfikator dla telefonów z systemem Android za pomocą adresu MAC WLAN. Adres MAC jest unikalny dla wszystkich urządzeń i działa na wszystkich rodzajach urządzeń.

Zalety używania adresu MAC WLAN jako identyfikatora urządzenia:

  • Jest to unikalny identyfikator dla wszystkich typów urządzeń (smartfonów i tabletów).

  • Pozostaje unikalny, jeśli aplikacja zostanie ponownie zainstalowana

Wady używania adresu MAC WLAN jako identyfikatora urządzenia:

  • Daj ci fałszywą wartość z pianki i wyżej.

  • Jeśli urządzenie nie ma sprzętu Wi-Fi, otrzymasz pusty adres MAC, ale ogólnie widać, że większość urządzeń z Androidem ma sprzęt Wi-Fi i na rynku jest niewiele urządzeń bez sprzętu Wi-Fi.

ŹRÓDŁO: technetexperts.com

Jamil
źródło
7
„IMEI zależy od karty SIM” ... To nieprawda.
Wygląda na to, że mylisz
2
Międzynarodowy identyfikator stacji mobilnej lub w skrócie IMEI to numer identyfikujący telefony komórkowe działające w sieci GSM. Osobiście próbowałem i programowo daje mi to zero, jeśli w telefonie GSM nie ma operatora komórkowego. smartmobilephonesolutions.com/content/…
Jamil
3
Masz rację, nie czytałem dokładnie. IMEI jest powiązany z transceiverem karty SIM, a nie z kartą SIM. Mój błąd!
Merlevede
2
Adres MAC WLAN został uznany za przestarzały przy przesyłaniu dalej Marshmallow. Otrzymasz fałszywą wartość!
IgorGanapolsky
1
Android 6 nie zwraca poprawnego adresu MAC Wi-Fi ze swoim kodem. Zauważ to.
zszen
15

Podobnie jak w API 26 getDeviceId()jest amortyzowany, więc możesz użyć następującego kodu, aby obsłużyć API 26 i wcześniejsze wersje

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

Nie zapomnij dodać wniosków o pozwolenie na READ_PHONE_STATEużywanie powyższego kodu.

AKTUALIZACJA: W systemie Android 10 aplikacja użytkownika może uzyskiwać niepowtarzalne identyfikatory sprzętowe, takie jak IMEI.

Muhammad Hamza Shahid
źródło
Udostępnianie myśli, gdzie mogę znaleźć odniesienie do metody „getImei ()”?
sam byte
2
Na pewno skorzystaj z developer.android.com/reference/android/telephony/… w celu uzyskania informacji o getImei ()
Muhammad Hamza Shahid
jakie jest rozwiązanie dla Androida 10?
Amin Pinjari,
1
Niestety, w systemie Android 10 ze względów bezpieczeństwa aplikacje innych firm nie mogą pobierać identyfikatorów sprzętowych, takich jak IMEI, aby uzyskać więcej informacji na temat zmian prywatności w systemie Android 10 na stronie developer.android.com/about/versions/10/privacy
Muhammad Hamza Shahid
Działa na Androidzie Oreo.
Satish Shetty
10

Metoda getDeviceId () z TelephonyManager zwraca unikalny identyfikator urządzenia, na przykład IMEI dla GSM i MEID lub ESN dla telefonów CDMA. Zwraca null, jeśli identyfikator urządzenia nie jest dostępny.

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

Wymagane zezwolenie READ_PHONE_STATE w pliku manifestu.


źródło
4

Możesz użyć tej funkcji TelephonyManager TELEPHONY_SERVICE, aby uzyskać unikalny identyfikator urządzenia , wymaga pozwolenia: READ_PHONE_STATE

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

Przykład: IMEI dla GSM i MEID lub ESN dla telefonów 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();
}

Zwraca null, jeśli identyfikator urządzenia nie jest dostępny .

A-Droid Tech
źródło
i dlaczego identyfikator urządzenia jest zerowy? z powodu zrootowanego urządzenia.
Vishal Sojitra
jakie jest rozwiązanie dla Androida 10?
Amin Pinjari,
3

Metoda getDeviceId()jest przestarzała. Jest na to nowa metodagetImei(int)

Sprawdź tutaj

Waran
źródło
jakie jest rozwiązanie dla Androida 10?
Amin Pinjari,
3

Spróbuj tego (zawsze musisz uzyskać pierwszy 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();
        }
Arnold Brown
źródło
jakie jest rozwiązanie dla Androida 10? developer.android.com/about/versions/10/privacy
Amin Pinjari
2

Użyj poniższego kodu, aby uzyskać numer IMEI:

TelephonyManager telephonyManager = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);
System.out.println("IMEI::" + telephonyManager.getDeviceId());
sharma_kunal
źródło
1

dla interfejsu API poziomu 11 lub wyższego:

case TelephonyManager.PHONE_TYPE_SIP: 
return "SIP";

TelephonyManager tm= (TelephonyManager)getSystemService(Context.TELEPHONY_SERVICE);
textDeviceID.setText(getDeviceID(tm));
Anil MH
źródło
1

Kod Kotlin do uzyskiwania DeviceId (IMEI) z pozwoleniem na obsługę i sprawdzaniem porównywalności dla wszystkich wersji Androida:

 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

    }

Dodaj także to uprawnienie do pliku AndroidManifest.xml:

<uses-permission android:name="android.permission.READ_PHONE_STATE"/> <!-- IMEI-->
Hamed Jaliliani
źródło
1

Będziesz potrzebować następującego uprawnienia w pliku AndroidManifest.xml:

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

Aby uzyskać IMEI (międzynarodowy identyfikator urządzenia mobilnego) i jeśli jest on powyżej poziomu API 26, wówczas otrzymujemy telephonyManager.getImei()wartość null, dlatego używamy ANDROID_ID jako unikalnego identyfikatora.

 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;
    }
Rahul
źródło
0

Dla tych, którzy szukają wersji Kotlin, możesz użyć czegoś takiego;

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

UWAGA: Musisz owinąć telephonyService()powyższe sprawdzenie uprawnień za pomocą checkSelfPermission lub jakiejkolwiek metody, której używasz.

Dodaj także to uprawnienie do pliku manifestu;

<uses-permission android:name="android.permission.READ_PHONE_STATE"/>
TitanKing
źródło
0

użyj poniższego kodu:

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

I wywołaj metodę onRequestPermissionsResult następujący kod:

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

Dodaj następujące uprawnienie w pliku AndroidManifest.xml:

<uses-permission android:name="android.permission.READ_PHONE_STATE" />
Faxriddin Abdullayev
źródło
0

Dla Androida 10 Poniższy kod działa dla mnie.

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
                }
            }
        }
Ani
źródło