¿Cómo puedo detectar cuando una aplicación de Android se está ejecutando en el emulador?

Me gustaría que mi código se ejecute de manera ligeramente diferente cuando se ejecute en el emulador que cuando se ejecute en un dispositivo. ( Por ejemplo , usando 10.0.2.2 en lugar de una URL pública para ejecutar automáticamente en un servidor de desarrollo). ¿Cuál es la mejor manera de detectar cuándo una aplicación de Android se ejecuta en el emulador?

¿Qué tal esta solución?

    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

Tenga en cuenta que algunos emuladores falsifican especificaciones exactas de dispositivos reales, por lo que puede ser imposible detectarlo.

Aquí hay un pequeño fragmento que puede hacer en el APK para mostrar varias cosas al respecto, para que pueda agregar sus propias reglas:

        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"

Uno común parece ser Build.FINGERPRINT.contains("generic")

Bueno, la identificación de Android no funciona para mí, actualmente estoy usando:

"google_sdk".equals( Build.PRODUCT );

Según las sugerencias de otras respuestas, esta es probablemente la forma más sólida:

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

Google usa este código en el complemento de información del dispositivo de Flutter para determinar si el dispositivo es un 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");
}

¿Qué tal algo como el siguiente código para saber si su aplicación se firmó con la clave de depuración? no detecta el emulador pero podría funcionar para tu 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 me funciona

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

En caso de que el dispositivo no tenga tarjeta SIM, vuelve a ejecutar la cadena vacía: ""

Como el emulador de Android siempre vuelve a ejecutar "Android" como operador de red, utilizo el código anterior.

Probé varias técnicas, pero me decidí por una versión ligeramente revisada de comprobar Build.PRODUCT como se muestra a continuación. Esto parece variar bastante de un emulador a otro, por eso tengo las 3 comprobaciones que tengo actualmente. Supongo que podría haber verificado si product.contains ("sdk"), pero pensé que la comprobación a continuación era un poco más 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;
}

FYI: descubrí que mi Kindle Fire tenía Build.BRAND = "genérico", y algunos de los emuladores no tenían "Android" para el operador de red.

Tanto lo siguiente se establece en "google_sdk":

Build.PRODUCT
Build.MODEL

Por lo tanto, debería ser suficiente para usar cualquiera de las siguientes líneas.

"google_sdk".equals(Build.MODEL)

o

"google_sdk".equals(Build.PRODUCT)

Solo busco _sdk, _sdk_o sdk_, o incluso solo sdkparticipo Build.PRODUCT:

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

Nunca encontré una buena manera de saber si estás en el emulador.

pero si solo necesita detectar si está en un entorno de desarrollo, puede hacer esto:

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

Espero que esto ayude....

usa esta función:

 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;

    }

No sé si hay mejores formas de detectar el emu, pero el emulador tendrá el archivo init.goldfish.rcen el directorio raíz.

Es el script de inicio específico del emulador, y no debería estar allí en una compilación que no sea un emulador.

Aquí está mi solución (funciona solo si ejecuta un servidor web en su máquina de depuración): he creado una tarea en segundo plano que se inicia cuando se inicia la aplicación. Busca http://10.0.2.2 y, si existe, cambia un parámetro global (IsDebug) a verdadero. Es una forma silenciosa de averiguar dónde está corriendo.

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

de la actividad principal en Crear:

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

Desde la batería, el emulador: la fuente de alimentación es siempre un cargador de CA. La temperatura siempre es 0.

Y puede usar Build.HOSTpara registrar el valor del host, un emulador diferente tiene un valor de host diferente.

Encontré el nuevo emulador Build.HARDWARE = "ranchu".

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

Y también encontré la forma oficial de Android de verificar si el emulador o no. Creo que es una buena referencia para nosotros.

Desde Android API Nivel 23 [Android 6.0]

package com.android.internal.util;

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

Tenemos ScreenShapeHelper.IS_EMULATORque verificar si el emulador.

Desde Android API Nivel 24 [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");

}

Tenemos Build.IS_EMULATORque verificar si el emulador.

La forma en que el oficial verifica si el emulador no es nuevo, y tal vez tampoco sea suficiente, también se mencionan las respuestas anteriores.

Pero esto quizás nos muestre que el oficial proporcionará la forma de verificar si el emulador es o no.

Al usar las formas mencionadas anteriormente, en este momento también podemos usar las dos formas para verificar si el emulador.

Cómo acceder al com.android.internalpaquete y@hide

y espere el SDK abierto oficial.

Otra opción sería mirar la propiedad ro.hardware y ver si está establecida en goldfish. Desafortunadamente, no parece haber una manera fácil de hacer esto desde Java, pero es trivial desde C usando property_get () .

La solución sugerida anteriormente para verificar si ANDROID_IDfuncionó para mí hasta que actualicé hoy a las últimas herramientas SDK lanzadas con Android 2.2.

Por lo tanto, actualmente cambié a la siguiente solución que funciona hasta ahora con la desventaja de que debes poner el permiso de lectura 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 las respuestas en un solo 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;
}

Mi recomendación:

prueba esto desde github.

Emulador de Android fácil de detectar

• Comprobado en dispositivos reales en Device Farm ( https://aws.amazon.com/device-farm/ )
• BlueStacks
• Genymotion
• Emulador de Android
• Andy 46.2.207.0
• MEmu play
• Nox App Player
• Koplayer
• .....

Cómo usar con un ejemplo:

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

                    }
                });

puede consultar el IMEI #, http://developer.android.com/reference/android/telephony/TelephonyManager.html#getDeviceId%28%29

Si recuerdo en el emulador este retorno 0. Sin embargo, no hay documentación que pueda encontrar que lo garantice. aunque el emulador no siempre devuelve 0, parece bastante seguro que un teléfono registrado no devuelva 0. lo que sucedería en un dispositivo Android que no sea un teléfono, o uno sin una tarjeta SIM instalada o una que no esté registrada actualmente en el ¿red?

Parece que sería una mala idea depender de eso.

también significa que necesitará pedir permiso para leer el estado del teléfono, lo cual es malo si no lo necesita para otra cosa.

si no es así, siempre hay algún cambio antes de que finalmente genere su aplicación firmada.

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

Esto debería volver verdadero si la aplicación se ejecuta en un emulador.

Lo que debemos tener cuidado es no detectar todos los emuladores porque solo hay varios emuladores diferentes. Es fácil de verificar. Tenemos que asegurarnos de que los dispositivos reales no se detecten como un emulador.

Utilicé la aplicación llamada " Compartir información del dispositivo Android " para verificar esto.

En esta aplicación, puede ver varios tipos de información de muchos dispositivos (probablemente la mayoría de los dispositivos en el mundo; si el dispositivo que está utilizando falta en la lista, se agregará automáticamente).

Comprobando las respuestas, ninguna de ellas funcionó al usar emuladores LeapDroid, Droid4x o Andy,

Lo que funciona para todos los casos es lo siguiente:

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

En realidad, ANDROID_ID en 2.2 siempre es igual a 9774D56D682E549C (de acuerdo con este hilo + mis propios experimentos).

Entonces, podría verificar algo como esto:

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

No es el más bonito, pero hace el trabajo.

Esto funciona para mi

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

Poner un archivo en el sistema de archivos del emulador; Como el archivo no existirá en el dispositivo real, debería ser estable, confiable y fácil de arreglar cuando se rompa.

He recopilado todas las respuestas a esta pregunta y se me ocurrió una función para detectar si Android se está ejecutando en un vm / emulador:

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

Probado en Emulator, Genymotion y Bluestacks (1 de octubre de 2015).

Cualquiera que sea el código que se utiliza para realizar la detección de emulador, lo recomiendo mucho las pruebas de unidad de escritura para cubrir todo el Build.FINGERPRINT, Build.HARDWAREy Build.MANUFACTURERlos valores que están en función de. Aquí hay algunos ejemplos de pruebas:

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

... y aquí está nuestro código (registros de depuración y comentarios eliminados por concisión):

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 el motor de emulación subyacente para Genymotion es VirtualBox y eso no va a cambiar en el corto plazo, el siguiente código me pareció el más confiable:

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

Otra opción es verificar si está en modo de depuración o en modo de producción:

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

Simple y confiable.

No es totalmente la respuesta de la pregunta, pero en la mayoría de los casos es posible que desee distinguir entre sesiones de depuración / prueba y sesiones de vida de su base de usuarios.

En mi caso, configuré google analytics en dryRun () cuando estaba en modo de depuración, por lo que este enfoque funciona totalmente bien para mí.

Para usuarios más avanzados hay otra opción. variantes de construcción de gradle:

en el archivo gradle de su aplicación, agregue una nueva variante:

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

En su código verifique el tipo de compilación:

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

Ahora tienes la oportunidad de crear 3 tipos diferentes de tu aplicación.