Como posso detectar quando um aplicativo Android está sendo executado no emulador?

Gostaria que meu código fosse executado de maneira um pouco diferente ao executar no emulador e ao executar em um dispositivo. ( Por exemplo , usando 10.0.2.2 em vez de um URL público para executar automaticamente em um servidor de desenvolvimento.) Qual é a melhor maneira de detectar quando um aplicativo Android está sendo executado no emulador?

Que tal esta solução:

    fun isProbablyAnEmulator() = Build.FINGERPRINT.startsWith("generic")
            || Build.FINGERPRINT.startsWith("unknown")
            || Build.MODEL.contains("google_sdk")
            || Build.MODEL.contains("Emulator")
            || Build.MODEL.contains("Android SDK built for x86")
            || Build.BOARD == "QC_Reference_Phone" //bluestacks
            || Build.MANUFACTURER.contains("Genymotion")
            || Build.HOST.startsWith("Build") //MSI App Player
            || (Build.BRAND.startsWith("generic") && Build.DEVICE.startsWith("generic"))
            || "google_sdk" == Build.PRODUCT

Observe que alguns emuladores falsificam especificações exatas de dispositivos reais; portanto, pode ser impossível detectá-lo.

Aqui está um pequeno trecho que você pode criar no APK para mostrar várias coisas sobre ele e adicionar suas próprias regras:

        textView.text = "FINGERPRINT:${Build.FINGERPRINT}\n" +
                "MODEL:${Build.MODEL}\n" +
                "MANUFACTURER:${Build.MANUFACTURER}\n" +
                "BRAND:${Build.BRAND}\n" +
                "DEVICE:${Build.DEVICE}\n" +
                "BOARD:${Build.BOARD}\n" +
                "HOST:${Build.HOST}\n" +
                "PRODUCT:${Build.PRODUCT}\n"

Um sems comum a ser Build.FINGERPRINT.contains("generic")

Bem, o ID do Android não funciona para mim. No momento, estou usando:

"google_sdk".equals( Build.PRODUCT );

Com base nas dicas de outras respostas, esta é provavelmente a maneira mais robusta:

isEmulator = "goldfish".equals(Build.HARDWARE)

O Google usa esse código no plug-in de informações do dispositivo do Flutter para determinar se o dispositivo é um emulador:

private boolean isEmulator() {
    return (Build.BRAND.startsWith("generic") && Build.DEVICE.startsWith("generic"))
        || Build.FINGERPRINT.startsWith("generic")
        || Build.FINGERPRINT.startsWith("unknown")
        || Build.HARDWARE.contains("goldfish")
        || Build.HARDWARE.contains("ranchu")
        || Build.MODEL.contains("google_sdk")
        || Build.MODEL.contains("Emulator")
        || Build.MODEL.contains("Android SDK built for x86")
        || Build.MANUFACTURER.contains("Genymotion")
        || Build.PRODUCT.contains("sdk_google")
        || Build.PRODUCT.contains("google_sdk")
        || Build.PRODUCT.contains("sdk")
        || Build.PRODUCT.contains("sdk_x86")
        || Build.PRODUCT.contains("vbox86p")
        || Build.PRODUCT.contains("emulator")
        || Build.PRODUCT.contains("simulator");
}

Que tal algo como o código abaixo para saber se seu aplicativo foi assinado com a chave de depuração? não está detectando o emulador, mas pode funcionar para o seu propósito?

public void onCreate Bundle b ) {
   super.onCreate(savedInstanceState);
   if ( signedWithDebugKey(this,this.getClass()) ) {
     blah blah blah
   }

  blah 
    blah 
      blah

}

static final String DEBUGKEY = 
      "get the debug key from logcat after calling the function below once from the emulator";    


public static boolean signedWithDebugKey(Context context, Class<?> cls) 
{
    boolean result = false;
    try {
        ComponentName comp = new ComponentName(context, cls);
        PackageInfo pinfo = context.getPackageManager().getPackageInfo(comp.getPackageName(),PackageManager.GET_SIGNATURES);
        Signature sigs[] = pinfo.signatures;
        for ( int i = 0; i < sigs.length;i++)
        Log.d(TAG,sigs[i].toCharsString());
        if (DEBUGKEY.equals(sigs[0].toCharsString())) {
            result = true;
            Log.d(TAG,"package has been signed with the debug key");
        } else {
            Log.d(TAG,"package signed with a key other than the debug key");
        }

    } catch (android.content.pm.PackageManager.NameNotFoundException e) {
        return false;
    }

    return result;

} 

Este código funciona para mim

TelephonyManager tm = (TelephonyManager)getSystemService(Context.TELEPHONY_SERVICE);
String networkOperator = tm.getNetworkOperatorName();
if("Android".equals(networkOperator)) {
    // Emulator
}
else {
    // Device
}

Caso esse dispositivo não possua um cartão SIM, ele retira a string vazia: ""

Como o emulador do Android sempre executa o "Android" como operador de rede, eu uso o código acima.

Eu tentei várias técnicas, mas resolvi usar uma versão revisada para verificar o Build.PRODUCT como abaixo. Isso parece variar bastante de emulador para emulador, é por isso que tenho as 3 verificações que tenho atualmente. Acho que poderia ter verificado se product.contains ("sdk"), mas achei a verificação abaixo um pouco mais segura.

public static boolean isAndroidEmulator() {
    String model = Build.MODEL;
    Log.d(TAG, "model=" + model);
    String product = Build.PRODUCT;
    Log.d(TAG, "product=" + product);
    boolean isEmulator = false;
    if (product != null) {
        isEmulator = product.equals("sdk") || product.contains("_sdk") || product.contains("sdk_");
    }
    Log.d(TAG, "isEmulator=" + isEmulator);
    return isEmulator;
}

Para sua informação, descobri que meu Kindle Fire tinha Build.BRAND = "generic" e alguns dos emuladores não tinham "Android" para a operadora de rede.

Os seguintes itens estão definidos como "google_sdk":

Build.PRODUCT
Build.MODEL

Portanto, deve ser suficiente usar uma das seguintes linhas.

"google_sdk".equals(Build.MODEL)

ou

"google_sdk".equals(Build.PRODUCT)

Acabei de olhar para _sdk, _sdk_ou sdk_, ou mesmo apenas sdkparte Build.PRODUCT:

if(Build.PRODUCT.matches(".*_?sdk_?.*")){
  //-- emulator --
}else{
  //-- other device --
}

Eu nunca encontrei uma boa maneira de saber se você está no emulador.

mas se você apenas precisar detectar se está em um ambiente de desenvolvimento, poderá fazer o seguinte:

     if(Debug.isDebuggerConnected() ) {
        // Things to do in debug environment...
    }

Espero que esta ajuda ....

use esta função:

 public static final boolean isEmulator() {

    int rating = 0;

    if ((Build.PRODUCT.equals("sdk")) || (Build.PRODUCT.equals("google_sdk"))
            || (Build.PRODUCT.equals("sdk_x86")) || (Build.PRODUCT.equals("vbox86p"))) {
        rating++;
    }
    if ((Build.MANUFACTURER.equals("unknown")) || (Build.MANUFACTURER.equals("Genymotion"))) {
        rating++;
    }
    if ((Build.BRAND.equals("generic")) || (Build.BRAND.equals("generic_x86"))) {
        rating++;
    }
    if ((Build.DEVICE.equals("generic")) || (Build.DEVICE.equals("generic_x86")) || (Build.DEVICE.equals("vbox86p"))) {
        rating++;
    }
    if ((Build.MODEL.equals("sdk")) || (Build.MODEL.equals("google_sdk"))
            || (Build.MODEL.equals("Android SDK built for x86"))) {
        rating++;
    }
    if ((Build.HARDWARE.equals("goldfish")) || (Build.HARDWARE.equals("vbox86"))) {
        rating++;
    }
    if ((Build.FINGERPRINT.contains("generic/sdk/generic"))
            || (Build.FINGERPRINT.contains("generic_x86/sdk_x86/generic_x86"))
            || (Build.FINGERPRINT.contains("generic/google_sdk/generic"))
            || (Build.FINGERPRINT.contains("generic/vbox86p/vbox86p"))) {
        rating++;
    }

    return rating > 4;

    }

Não sei se existem maneiras melhores de detectar a emu, mas o emulador terá o arquivo init.goldfish.rcno diretório raiz.

É o script de inicialização específico do emulador e não deve estar lá em uma compilação que não seja emulador.

Aqui está minha solução (ela funciona apenas se você executar um servidor Web em sua máquina de depuração): Criei uma tarefa em segundo plano que é iniciada quando o aplicativo é iniciado. Ele procura por http://10.0.2.2 e, se existir, altera um parâmetro global (IsDebug) para true. É uma maneira silenciosa de descobrir onde você está executando.

public class CheckDebugModeTask extends AsyncTask<String, Void, String> {
public static boolean IsDebug = false;

public CheckDebugModeTask()
{

}

@Override
protected String doInBackground(String... params) {     
  try {
    HttpParams httpParameters = new BasicHttpParams();
    int timeoutConnection = 1000;
    HttpConnectionParams.setConnectionTimeout(httpParameters, timeoutConnection);
    int timeoutSocket = 2000;
    HttpConnectionParams.setSoTimeout(httpParameters, timeoutSocket);

    String url2 = "http://10.0.2.2";        
          HttpGet httpGet = new HttpGet(url2);
    DefaultHttpClient client = new DefaultHttpClient(httpParameters);

    HttpResponse response2 = client.execute(httpGet);
    if (response2 == null || response2.getEntity() == null || response2.getEntity().getContent() == null)
    return "";

    return "Debug";

} catch (Exception e) {
    return "";
}
}

@Override
protected void onPostExecute (String result)
{       
if (result == "Debug")
{
    CheckDebugModeTask.IsDebug = true;
}
}

da atividade principal do onCreate:

CheckDebugModeTask checkDebugMode = new CheckDebugModeTask();
checkDebugMode.execute("");

Da bateria, o emulador: A fonte de energia é sempre o carregador CA. A temperatura é sempre 0.

E você pode usar Build.HOSTpara registrar o valor do host, emulador diferente tem valor de host diferente.

Encontrei o novo emulador Build.HARDWARE = "ranchu".

Referência: https://groups.google.com/forum/#!topic/android-emulator-dev/dltBnUW_HzU

E também encontrei a maneira oficial do Android para verificar se o emulador ou não. Acho que é uma boa referência para nós.

Desde a API do Android, nível 23 [Android 6.0]

package com.android.internal.util;

/**
 * @hide
 */
public class ScreenShapeHelper {
    private static final boolean IS_EMULATOR = Build.HARDWARE.contains("goldfish");
}

Nós temos ScreenShapeHelper.IS_EMULATOR verificar se o emulador.

Desde o nível 24 da API do Android [Android 7.0]

package android.os;

/**
 * Information about the current build, extracted from system properties.
 */
public class Build {


    /**
     * Whether this build was for an emulator device.
     * @hide
     */
    public static final boolean IS_EMULATOR = getString("ro.kernel.qemu").equals("1");

}

Nós temos Build.IS_EMULATOR verificar se o emulador.

A maneira como o funcionário verifica se o emulador não é novo, e também talvez não seja suficiente, as respostas acima também mencionaram.

Mas isso talvez nos mostre que o oficial fornecerá o caminho do oficial para verificar se o emulador ou não.

Como usamos todas as maneiras acima mencionadas, agora também podemos usar as duas maneiras para verificar se o emulador.

Como acessar o com.android.internalpacote e@hide

e aguarde o SDK oficial aberto.

Outra opção seria olhar para a propriedade ro.hardware e ver se ela está definida como peixinho. Infelizmente, não parece haver uma maneira fácil de fazer isso em Java, mas é trivial em C usando property_get () .

A solução sugerida acima para verificar se ANDROID_IDfuncionou para mim até que eu atualizei hoje as ferramentas mais recentes do SDK lançadas com o Android 2.2.

Portanto, atualmente mudei para a seguinte solução, que funciona até agora com a desvantagem, no entanto, é necessário colocar a permissão de leitura PHONE_STATE ( <uses-permission android:name="android.permission.READ_PHONE_STATE"/>)

private void checkForDebugMode() {
    ISDEBUGMODE = false; //(Secure.getString(getApplicationContext().getContentResolver(), Secure.ANDROID_ID) == null);

    TelephonyManager man = (TelephonyManager) getApplicationContext().getSystemService(Context.TELEPHONY_SERVICE);
    if(man != null){
        String devId = man.getDeviceSoftwareVersion();
        ISDEBUGMODE = (devId == null);
    }
} 

Todas as respostas em um método

static boolean checkEmulator()
{
    try
    {
        String buildDetails = (Build.FINGERPRINT + Build.DEVICE + Build.MODEL + Build.BRAND + Build.PRODUCT + Build.MANUFACTURER + Build.HARDWARE).toLowerCase();

        if (buildDetails.contains("generic") 
        ||  buildDetails.contains("unknown") 
        ||  buildDetails.contains("emulator") 
        ||  buildDetails.contains("sdk") 
        ||  buildDetails.contains("genymotion") 
        ||  buildDetails.contains("x86") // this includes vbox86
        ||  buildDetails.contains("goldfish")
        ||  buildDetails.contains("test-keys"))
            return true;
    }   
    catch (Throwable t) {Logger.catchedError(t);}

    try
    {
        TelephonyManager    tm  = (TelephonyManager) App.context.getSystemService(Context.TELEPHONY_SERVICE);
        String              non = tm.getNetworkOperatorName().toLowerCase();
        if (non.equals("android"))
            return true;
    }
    catch (Throwable t) {Logger.catchedError(t);}

    try
    {
        if (new File ("/init.goldfish.rc").exists())
            return true;
    }
    catch (Throwable t) {Logger.catchedError(t);}

    return false;
}

Minha recomendação:

tente isso no github.

Fácil de detectar emulador Android

• Verificado em dispositivos reais no Device Farm ( https://aws.amazon.com/device-farm/ )
• BlueStacks
• Genymotion
• Emulador Android
• Andy 46.2.207.0
• MEmu play
• Nox App Player
• Koplayer
• .....

Como usar com um exemplo:

EmulatorDetector.with(this)
                .setCheckTelephony(true)
                .addPackageName("com.bluestacks")
                .setDebug(true)
                .detect(new EmulatorDetector.OnEmulatorDetectorListener() {
                    @Override
                    public void onResult(boolean isEmulator) {

                    }
                });

você pode verificar o número IMEI, http://developer.android.com/reference/android/telephony/TelephonyManager.html#getDeviceId%28%29

se eu me lembro no emulador esse retorno 0. no entanto, não há documentação que eu possa encontrar que garanta isso. embora o emulador nem sempre retorne 0, parece bastante seguro que um telefone registrado não retorne 0. o que aconteceria em um dispositivo Android sem telefone, ou um sem um cartão SIM instalado ou um que não esteja registrado no momento rede?

parece que seria uma má ideia, depender disso.

isso também significa que você precisará pedir permissão para ler o estado do telefone, o que é ruim se você ainda não o exige para outra coisa.

caso contrário, sempre haverá uma inversão em algum lugar antes de você finalmente gerar seu aplicativo assinado.

Build.BRAND.startsWith("generic") && Build.DEVICE.startsWith("generic")

Isso deve retornar verdadeiro se o aplicativo estiver sendo executado em um emulador.

O que devemos ter cuidado é não detectar todos os emuladores, porque existem apenas vários emuladores diferentes. É fácil de verificar. Temos que garantir que os dispositivos reais não sejam detectados como um emulador.

Eu usei o aplicativo chamado " Android Device Info Share " para verificar isso.

Neste aplicativo, você pode ver vários tipos de informações de muitos dispositivos (provavelmente a maioria dos dispositivos no mundo; se o dispositivo que você estiver usando estiver ausente na lista, ele será adicionado automaticamente).

Verificando as respostas, nenhuma delas funcionou ao usar emuladores LeapDroid, Droid4x ou Andy,

O que funciona para todos os casos é o seguinte:

 private static String getSystemProperty(String name) throws Exception {
    Class systemPropertyClazz = Class.forName("android.os.SystemProperties");
    return (String) systemPropertyClazz.getMethod("get", new Class[]{String.class}).invoke(systemPropertyClazz, new Object[]{name});
}

public boolean isEmulator() {
    boolean goldfish = getSystemProperty("ro.hardware").contains("goldfish");
    boolean emu = getSystemProperty("ro.kernel.qemu").length() > 0;
    boolean sdk = getSystemProperty("ro.product.model").equals("sdk");
    return goldfish || emu || sdk;
}

Na verdade, ANDROID_ID em 2.2 sempre é igual a 9774D56D682E549C (de acordo com este tópico + minhas próprias experiências).

Então, você pode verificar algo como isto:

String androidID = ...;
if(androidID == null || androidID.equals("9774D56D682E549C"))
    do stuff;

Não é a mais bonita, mas faz o trabalho.

Isso funciona para mim

public boolean isEmulator() {
    return Build.MANUFACTURER.equals("unknown");
}

Coloque um arquivo no sistema de arquivos do emulador; como o arquivo não existe no dispositivo real, ele deve ser estável, confiável e fácil de corrigir quando quebrar.

Reuni todas as respostas sobre esta questão e criei uma função para detectar se o Android está sendo executado em um vm / emulator:

public boolean isvm(){


        StringBuilder deviceInfo = new StringBuilder();
        deviceInfo.append("Build.PRODUCT " +Build.PRODUCT +"\n");
        deviceInfo.append("Build.FINGERPRINT " +Build.FINGERPRINT+"\n");
        deviceInfo.append("Build.MANUFACTURER " +Build.MANUFACTURER+"\n");
        deviceInfo.append("Build.MODEL " +Build.MODEL+"\n");
        deviceInfo.append("Build.BRAND " +Build.BRAND+"\n");
        deviceInfo.append("Build.DEVICE " +Build.DEVICE+"\n");
        String info = deviceInfo.toString();


        Log.i("LOB", info);


        Boolean isvm = false;
        if(
                "google_sdk".equals(Build.PRODUCT) ||
                "sdk_google_phone_x86".equals(Build.PRODUCT) ||
                "sdk".equals(Build.PRODUCT) ||
                "sdk_x86".equals(Build.PRODUCT) ||
                "vbox86p".equals(Build.PRODUCT) ||
                Build.FINGERPRINT.contains("generic") ||
                Build.MANUFACTURER.contains("Genymotion") ||
                Build.MODEL.contains("Emulator") ||
                Build.MODEL.contains("Android SDK built for x86")
                ){
            isvm =  true;
        }


        if(Build.BRAND.contains("generic")&&Build.DEVICE.contains("generic")){
            isvm =  true;
        }

        return isvm;
    }

Testado em emulador, Genymotion e Bluestacks (1 de outubro de 2015).

Qualquer que seja o código que você usa para fazer a detecção de emulador, eu recomendo escrever testes de unidade para cobrir todas as Build.FINGERPRINT, Build.HARDWAREe Build.MANUFACTURERvalores que você está dependendo. Aqui estão alguns exemplos de testes:

@Test
public void testIsEmulatorGenymotion() throws Exception {
    assertThat(
            DeviceUtils.isRunningOnEmulator(
                    "generic/vbox86p/vbox86p:4.1.1/JRO03S/eng.buildbot.20150217.102902:userdebug/test-keys",
                    "vbox86", "Genymotion")).isTrue();

    assertThat(
            DeviceUtils.isRunningOnEmulator(
                    "generic/vbox86p/vbox86p:5.1/LMY47D/buildbot06092001:userdebug/test-keys", "vbox86",
                    "Genymotion")).isTrue();
}

@Test
public void testIsEmulatorDefaultAndroidEmulator() throws Exception {
    assertThat(
            DeviceUtils.isRunningOnEmulator(
                    "generic_x86/sdk_google_phone_x86/generic_x86:5.0.2/LSY66H/1960483:eng/test-keys", "goldfish",
                    "unknown")).isTrue();

    assertThat(
            DeviceUtils.isRunningOnEmulator(
                    "Android/sdk_google_phone_x86_64/generic_x86_64:6.0/MASTER/2469028:userdebug/test-keys",
                    "ranchu", "unknown")).isTrue();
}

@Test
public void testIsEmulatorRealNexus5() throws Exception {
    assertThat(
            DeviceUtils.isRunningOnEmulator("google/hammerhead/hammerhead:6.0.1/MMB29K/2419427:user/release-keys",
                    "hammerhead", "LGE")).isFalse();
}

... e aqui está o nosso código (logs de depuração e comentários removidos por concisão):

public static boolean isRunningOnEmulator() {
    if (sIsRunningEmulator == null) {
        sIsRunningEmulator = isRunningOnEmulator(Build.FINGERPRINT, Build.HARDWARE, Build.MANUFACTURER);
    }

    return sIsRunningEmulator;
}

static boolean isRunningOnEmulator(String fingerprint, String hardware, String manufacturer) {
    boolean isEmulatorFingerprint = fingerprint.endsWith("test-keys");
    boolean isEmulatorManufacturer = manufacturer.equals("Genymotion")
            || manufacturer.equals("unknown");

    if (isEmulatorFingerprint && isEmulatorManufacturer) {
        return true;
    } else {
        return false;
    }
}

Como o mecanismo de emulação subjacente do Genymotion é o VirtualBox e isso não mudará tão cedo, achei o código a seguir mais confiável:

   public static boolean isGenymotion() {
        return Build.PRODUCT != null && Build.PRODUCT.contains("vbox");
}

Outra opção é verificar se você está no modo de depuração ou modo de produção:

if (BuildConfig.DEBUG) { Log.i(TAG, "I am in debug mode"); }

simples e confiável.

Não é totalmente a resposta da pergunta, mas na maioria dos casos você pode distinguir entre sessões de depuração / teste e sessões de vida da sua base de usuários.

No meu caso, defino o google analytics como dryRun () quando no modo de depuração, para que essa abordagem funcione totalmente bem para mim.

Para usuários mais avançados, há outra opção. variantes de construção gradle:

no arquivo de classificação do seu aplicativo, adicione uma nova variante:

buildTypes {
    release {
        // some already existing commands
    }
    debug {
        // some already existing commands
    }
    // the following is new
    test {
    }
}

No seu código, verifique o tipo de compilação:

if ("test".equals(BuildConfig.BUILD_TYPE)) { Log.i(TAG, "I am in Test build type"); }
 else if ("debug".equals(BuildConfig.BUILD_TYPE)) { Log.i(TAG, "I am in Debug build type"); }

Agora você tem a oportunidade de criar três tipos diferentes de seu aplicativo.