Como obter o IMEI / ESN do dispositivo de forma programática no android?

343

Para identificar cada dispositivo de maneira exclusiva, eu gostaria de usar o IMEI (ou número ESN para dispositivos CDMA). Como acessar isso programaticamente?

Tom
fonte
Para obter IMEI para ambos os SIM em telefones com SIM duplo, use reflexões Java. Veja aqui está demo
Vaibhav Jani 06/07/2013
5
@PiedPiper: IMEI não é específico do SIM. Você está pensando em IMSI.
22415 Phillip
@Phillip Obrigado companheiro. Eu atualizei a minha resposta :)
Vaibhav Jani
11
Todo mundo .. existem algumas mudanças no android 6? ainda podemos acessar o IMEI de alguma maneira?
therealprashant
11
Você precisa solicitar a permissão READ_PHONE_STATE em tempo de execução, para poder obter o IMEI
Flo We

Respostas:

387

Você quer ligar android.telephony.TelephonyManager.getDeviceId().

Isso retornará qualquer string que identifique exclusivamente o dispositivo (IMEI no GSM, MEID para CDMA).

Você precisará da seguinte permissão no seu AndroidManifest.xml:

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

para fazer isso.

Dito isto, tenha cuidado ao fazer isso. Os usuários não apenas se perguntam por que seu aplicativo está acessando sua pilha de telefonia, como pode ser difícil migrar dados se o usuário adquirir um novo dispositivo.

Atualização: conforme mencionado nos comentários abaixo, esta não é uma maneira segura de autenticar usuários e levanta questões de privacidade. Não é recomendado. Em vez disso, consulte a API de login do Google+ se você deseja implementar um sistema de login sem atrito.

A API de backup do Android também está disponível se você quiser uma maneira leve de persistir um conjunto de cadeias de caracteres para quando um usuário redefine o telefone (ou compra um novo dispositivo).

Trevor Johns
fonte
11
Qual seria uma solução melhor, em seguida, que lhes permitisse migrar dados no futuro? Endereço de e-mail do Google? Se sim, como posso extrair isso do sistema?
Tom
3
A maneira mais confiável de fazer isso é fazer com que eles criem uma conta na primeira vez em que iniciam seu aplicativo. Existem maneiras de obter o endereço de e-mail do usuário (consulte os documentos no AccountManager), mas verificar se um usuário mal-intencionado não forjou essas informações requer um pouco de conhecimento sobre como as APIs de dados do Google funcionam - mais do que posso colocar neste pequena caixa de comentários. ;)
Trevor Johns
11
Na verdade, você também não tem garantia de que o usuário não forjou seu IMEI / MEID. Se a segurança for preocupante, você realmente precisará usar um nome de usuário / senha ou o método getAuthToken () no AccountManager (e novamente, você precisará verificar esse token com o servidor que o emitiu originalmente).
Trevor Johns
2
Adi: o código para obter o ID do dispositivo? Não há nada além do método + permissão que eu mencionei acima. Dito isto, você deve olhar para a API Google+ Entrar, essa é a abordagem recomendada para autenticar usuários nos dias de hoje: developer.android.com/google/play-services/auth.html
Trevor Johns
2
Está executando o Android 6? E você está direcionando o SDK 23? Então você precisa solicitar READ_PHONE_STATE em tempo de execução antes de consultar o IMEI
Flo We
284

Além da resposta de Trevor Johns, você pode usar isso da seguinte maneira:

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

E você deve adicionar a seguinte permissão ao seu arquivo Manifest.xml:

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

No emulador, você provavelmente obterá um valor "00000 ...". getDeviceId () retorna NULL se o ID do dispositivo não estiver disponível.

Taner
fonte
11
Existe uma maneira de fazer com que o emulador retorne um número IMEI?
21817 MikeSchem #
@ MikeSchem, o emulador não tem uma string IMEI significativa.
Shizhen
Tente não usar: <permissão de uso android: name = "android.permission.READ_PHONE_STATE" /> esta permissão é muito sensível, você pode obter o aplicativo rejeitado pela equipe do Google Play (novas regras de segurança adicionadas no final de 2018). Como conselho, use melhor o código de publicidade.
Duna
@ Tanner Funcionará no dispositivo Dual SIM? (É preciso obter Primeira IMEI apenas)
Arnold Brown
Existe alguma preocupação de segurança ao usar a READ_PHONE_STATEpermissão?
víbora
62

Uso o código a seguir para obter o IMEI ou o Secure.ANDROID_ID como alternativa, quando o dispositivo não possui recursos de telefone:

/**
 * 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
fonte
17
TextUtils.isEmpty () -> if (identificador == null || identificador .length () == 0)
Mikhaili
2
Olá, Pinhassi, Você teve algum caso em que o ID do dispositivo retornado pelo gerente de telefonia estava nulo ou vazio, mas o valor lido do Secure.ANDROID_ID não estava vazio? Obrigado
Budda
4
Tanto quanto me lembro, era para tablets sem cartão SIM (mas não tenho 100% de certeza).
Asaf Pinhassi
Secure.ANDROID_ID muda se o dispositivo estiver formatado ou se a ROM for redefinida de fábrica
shridutt kothari
Meu Nexus7 (1stGen) retorna nullpara o deviceId de telefonia ... Alguém sabe como obter um IMEI de um tablet?
Sakiboy
38

Ou você pode usar a configuração ANDROID_ID do Android.Provider.Settings.System (conforme descrito aqui strazerre.com ).

Isso tem a vantagem de não exigir permissões especiais, mas pode ser alterado se outro aplicativo tiver acesso de gravação e o alterar (o que é aparentemente incomum, mas não impossível).

Apenas para referência, aqui está o código do blog:

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

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

Nota de implementação : se o ID for crítico para a arquitetura do sistema, você deve estar ciente de que, na prática, alguns telefones e tablets Android muito baixos foram encontrados reutilizando o mesmo ANDROID_ID (9774d56d682e549c foi o valor que aparece nos nossos logs)

tonys
fonte
15
Esta constante está obsoleta. Você precisa usar android.provider.Settings.Secure.ANDROID_ID;
Mcorley 18/05
@mcorley quando i usando android.provider.Settings.Secure.ANDROID_ID por nexo 7 comprimido e nexo 4-o voltar mesmo valor 'android_id'
vuhung3990
3
@meowmeo fez o mesmo por mim, até que eu usei o código que agora faz parte da resposta (ish). String androidID = android.provider.Settings.System.getString(this.getContentResolver(), Secure.ANDROID_ID);
Matthias
Mas isso não seria redefinido para um novo ANDROID_ID após a redefinição de fábrica? E se eu precisar de um ANDROID_ID persistente que possa sobreviver a redefinições.
IgorGanapolsky 9/09/16
35

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

O código a seguir ajuda na obtenção do número IMEI de dispositivos Android:

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

Permissões necessárias no Android Manifest:

android.permission.READ_PHONE_STATE

NOTA: No caso de tablets ou dispositivos que não possam atuar como IMEI de telefone celular, será nulo.

alquimista
fonte
11
este é o código real que eu estou encontrando para obter IMEI
Anand Savjani
2
Infelizmente, com o Marshmallow forward, você precisa solicitar esta permissão em tempo de execução. Essa permissão não é ideal, pois perturba a experiência do usuário e pode tornar alguns usuários suspeitos.
IgorGanapolsky 9/09/16
Tente não usar: <permissão de uso android: name = "android.permission.READ_PHONE_STATE" /> esta permissão é muito sensível. Você pode obter o aplicativo rejeitado pela equipe do Google Play (novas regras de segurança adicionadas no final de 2018). Como conselho, use ID de publicidade em vez de IMEI
Duna
qual é a solução para o android 10?
Amin Pinjari
23

obter IMEI (identificador internacional de equipamento móvel)

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

para obter o ID exclusivo do dispositivo

public String getDeviceUniqueID(Activity activity){
    String device_unique_id = Secure.getString(activity.getContentResolver(),
            Secure.ANDROID_ID);
    return device_unique_id;
}
Zin Win Htet
fonte
2
Mostrar a alternativa device_unique_id é realmente útil
JoeGalind
20

Para o Android 6.0+, o jogo mudou, então eu sugiro que você use isso;

O melhor caminho a seguir é durante o tempo de execução, caso contrário, você obtém erros de permissão.

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

Espero que isso ajude você ou alguém.

The Dead Guy
fonte
16

Nova atualização:

Para a versão 6 e superior do Android, o endereço MAC da WLAN foi descontinuado, siga a resposta de Trevor Johns

Atualizar:

Para identificação exclusiva de dispositivos, você pode usar Secure.ANDROID_ID .

Resposta antiga:

Desvantagens do uso do IMEI como ID exclusivo do dispositivo:

  • O IMEI depende do slot do Simcard do dispositivo, portanto, não é possível obtê-lo para os dispositivos que não usam o Simcard. Nos dispositivos Dual SIM, obtemos 2 IMEIs diferentes para o mesmo dispositivo, pois possui 2 slots para o cartão SIM.

Você pode usar a sequência de endereços MAC da WLAN (não recomendado para Marshmallow e Marshmallow +, pois o endereço MAC da WLAN foi descontinuado no Marshmallow forward. Portanto, você obterá um valor falso)

Podemos obter o ID exclusivo para telefones Android usando o endereço MAC da WLAN também. O endereço MAC é exclusivo para todos os dispositivos e funciona para todos os tipos de dispositivos.

Vantagens de usar o endereço MAC da WLAN como ID do dispositivo:

  • É um identificador exclusivo para todos os tipos de dispositivos (smartphones e tablets).

  • Permanece exclusivo se o aplicativo for reinstalado

Desvantagens de usar o endereço MAC da WLAN como ID do dispositivo:

  • Dê-lhe um valor de Bogus de Marshmallow e acima.

  • Se o dispositivo não possui hardware wifi, você obtém um endereço MAC nulo, mas geralmente é visto que a maioria dos dispositivos Android possui hardware wifi e dificilmente existem poucos dispositivos no mercado sem hardware wifi.

FONTE: technetexperts.com

Jamil
fonte
7
"IMEI depende do Simcard" ... Isso é falso. Você parece estar confundindo o IMEI com o número IMSI
Merlevede
2
Uma identificação internacional de equipamento de estação móvel ou IMEI, abreviado, é um número que identifica telefones celulares que funcionam em uma rede GSM. Eu tentei pessoalmente e isso me dá nulo de forma programática, se não houver uma operadora sem fio no telefone GSM. smartmobilephonesolutions.com/content/…
Jamil
3
Você está certo, eu não li com atenção. O IMEI está associado ao transceptor do cartão SIM, não ao cartão SIM. Foi mal!
Merlevede 27/07
2
O endereço MAC da WLAN foi descontinuado no Marshmallow forward. Então você terá um valor falso!
IgorGanapolsky 9/09/16
11
O Android 6 não retorna o endereço MAC WIFI correto com o seu código. Observe isso.
zszen
15

Como na API 26, getDeviceId()foi preterido, então você pode usar o código a seguir para atender à API 26 e versões anteriores

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ão se esqueça de adicionar solicitações de permissão para READ_PHONE_STATEusar o código acima.

ATUALIZAÇÃO: a partir do Android 10, é restrito aos aplicativos do usuário obter identificadores de hardware não redefiníveis, como o IMEI.

Muhammad Hamza Shahid
fonte
Partilha mente onde eu posso encontrar referência para o método 'getImei () "?
sam byte
2
Claro utilize developer.android.com/reference/android/telephony/... para getImei () de referência
Muhammad Hamza Shahid
qual é a solução para o android 10?
Amin Pinjari
11
Infelizmente, no Android 10, por motivos de segurança, agora é restrito para aplicativos de terceiros obter identificadores de hardware como IMEI para obter mais informações sobre alterações de privacidade no Android 10, visite developer.android.com/about/versions/10/privacy
Muhammad Hamza Shahid
Funciona no Android Oreo.
Satish Shetty
10

O método getDeviceId () do TelephonyManager retorna o ID do dispositivo exclusivo, por exemplo, o IMEI para GSM e o MEID ou ESN para telefones CDMA. Retorne nulo se o ID do dispositivo não estiver disponível.

Código 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> 

Permissão necessária READ_PHONE_STATE no arquivo de manifesto.


fonte
4

Você pode usar esta função TelephonyManager TELEPHONY_SERVICE para obter um ID de dispositivo exclusivo . Requer permissão: READ_PHONE_STATE

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

Por exemplo, o IMEI para GSM e o MEID ou ESN para telefones 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();
}

Retorne nulo se o ID do dispositivo não estiver disponível .

A-Droid Tech
fonte
e por que o ID do dispositivo é nulo? por causa do dispositivo enraizado.
Vishal Sojitra 28/03
qual é a solução para o android 10?
Amin Pinjari
3

O método getDeviceId()está obsoleto. Existe um novo método para issogetImei(int)

Verifique aqui

Waran-
fonte
qual é a solução para o android 10?
Amin Pinjari
3

Tente isto (precisa sempre obter o primeiro IMEI sempre)

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
fonte
qual é a solução para o android 10? developer.android.com/about/versions/10/privacy
Amin Pinjari
2

O código abaixo fornece o número IMEI:

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

para o nível 11 da API ou superior:

case TelephonyManager.PHONE_TYPE_SIP: 
return "SIP";

TelephonyManager tm= (TelephonyManager)getSystemService(Context.TELEPHONY_SERVICE);
textDeviceID.setText(getDeviceID(tm));
Anil MH
fonte
1

Código Kotlin para obter o DeviceId (IMEI) com permissão de manipulação e verificação de comparabilidade para todas as versões do 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

    }

Adicione também esta permissão ao AndroidManifest.xml:

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

Você precisará da seguinte permissão no seu AndroidManifest.xml:

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

Para obter o IMEI (identificador internacional de equipamento móvel) e, se estiver acima do nível 26 da API, obtemos telephonyManager.getImei()o valor nulo; portanto, usamos ANDROID_ID como um identificador exclusivo.

 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
fonte
0

Para quem procura uma versão Kotlin, você pode usar algo como isto;

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

NOTA: Você deve quebrar telephonyService()acima com uma verificação de permissão usando checkSelfPermission ou qualquer outro método que você use.

Adicione também essa permissão no arquivo de manifesto;

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

use o código abaixo:

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

E chame o método onRequestPermissionsResult no seguinte código:

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

Adicione a seguinte permissão no seu AndroidManifest.xml:

<uses-permission android:name="android.permission.READ_PHONE_STATE" />
Faxriddin Abdullayev
fonte
0

Para Android 10 O código a seguir está funcionando para mim.

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
fonte