Как я могу определить, когда приложение Android работает в эмуляторе?

Я хотел бы, чтобы мой код выполнялся немного иначе при работе на эмуляторе, чем при работе на устройстве. ( Например , использование 10.0.2.2 вместо общедоступного URL-адреса для автоматического запуска на сервере разработки.) Как лучше всего определить, когда приложение Android работает в эмуляторе?

Как насчет этого решения:

    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

Обратите внимание, что некоторые эмуляторы имитируют точные характеристики реальных устройств, поэтому может оказаться невозможным их обнаружить.

Вот небольшой фрагмент, который вы можете сделать в APK, чтобы показать различные вещи, чтобы вы могли добавить свои собственные правила:

        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"

Один общий кажется Build.FINGERPRINT.contains("generic")

Ну, Android ID не работает для меня, в настоящее время я использую:

"google_sdk".equals( Build.PRODUCT );

Основываясь на подсказках из других ответов, это, вероятно, самый надежный способ:

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

Google использует этот код в плагине информации об устройстве от Flutter, чтобы определить, является ли устройство эмулятором:

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

Как насчет кода ниже, чтобы узнать, подписано ли ваше приложение с помощью ключа отладки? это не обнаруживает эмулятор, но он может работать для ваших целей?

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;

} 

Этот код работает для меня

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

Если на этом устройстве нет SIM-карты, оно возвращает пустую строку: ""

Поскольку эмулятор Android всегда переустанавливает «Android» в качестве оператора сети, я использую приведенный выше код.

Я попробовал несколько методов, но остановился на немного пересмотренной версии проверки Build.PRODUCT, как показано ниже. Кажется, это может сильно отличаться от эмулятора к эмулятору, поэтому у меня есть 3 проверки, которые у меня сейчас есть. Полагаю, я мог бы просто проверить, есть ли product.contains ("sdk"), но подумал, что проверка ниже была немного безопаснее.

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

К вашему сведению - я обнаружил, что мой Kindle Fire имеет Build.BRAND = "generic", а на некоторых эмуляторах не было "Android" для оператора сети.

Для обоих следующих параметров установлено значение "google_sdk":

Build.PRODUCT
Build.MODEL

Так что должно быть достаточно использовать одну из следующих строк.

"google_sdk".equals(Build.MODEL)

или

"google_sdk".equals(Build.PRODUCT)

Я просто ищу _sdk, _sdk_или sdk_, или просто sdkучаствую в Build.PRODUCT:

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

Я так и не нашел хороший способ узнать, в эмуляторе ли вы.

но если вам просто нужно определить, находитесь ли вы в среде разработки, вы можете сделать это:

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

Надеюсь, это поможет ....

используйте эту функцию:

 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;

    }

Не знаю, есть ли лучшие способы обнаружить эму, но эмулятор будет иметь файл init.goldfish.rc в корневом каталоге.

Это скрипт запуска, специфичный для эмулятора, и его не должно быть в сборке без эмулятора.

Вот мое решение (оно работает только в том случае, если вы запускаете веб-сервер на своем компьютере для отладки): я создал фоновую задачу, которая запускается при запуске приложения. Он ищет http://10.0.2.2 и, если он существует, изменяет глобальный параметр (IsDebug) на true. Это тихий способ узнать, куда вы бежите.

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

из основной деятельности по созданию:

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

От батареи эмулятор: источником питания всегда является зарядное устройство переменного тока. Температура всегда 0.

И вы можете использовать Build.HOSTдля записи значения хоста, разные эмулятор имеет разные значения хоста.

Я нашел новый эмулятор Build.HARDWARE = "ranchu".

Ссылка: https://groups.google.com/forum/#!topic/android-emulator-dev/dltBnUW_HzU

А также я нашел официальный способ Android проверить, является ли эмулятор или нет. Я думаю, что это хорошая ссылка для нас.

Начиная с Android API уровня 23 [Android 6.0]

package com.android.internal.util;

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

Надо ScreenShapeHelper.IS_EMULATORпроверить, есть ли эмулятор.

Начиная с Android API уровня 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");

}

Надо Build.IS_EMULATORпроверить, есть ли эмулятор.

Официальный способ проверить, является ли эмулятор не новым, а также, возможно, не достаточно, ответы выше также упоминается.

Но это может показать нам, что чиновник предоставит возможность чиновнику проверить, работает ли эмулятор или нет.

Так как мы использовали все вышеперечисленные способы, прямо сейчас мы также можем использовать два способа проверки наличия эмулятора.

Как получить доступ к com.android.internalпакету и@hide

и ждать официального открытия SDK.

Другой вариант - посмотреть на свойство ro.hardware и посмотреть, установлено ли для него значение goldfish. К сожалению, кажется, что нет простого способа сделать это из Java, но это тривиально из C с помощью property_get () .

Выше предложенное решение, чтобы проверить ANDROID_IDработоспособность для меня, пока я не обновил сегодня до последних инструментов SDK, выпущенных с Android 2.2.

Поэтому в настоящее время я переключился на следующее решение, которое до сих пор работает с недостатком, однако вам необходимо установить разрешение на чтение 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);
    }
} 

Все ответы в одном методе

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

Моя рекомендация:

попробуй это с github.

Легко обнаружить эмулятор Android

• Проверено на реальных устройствах в Device Farm ( https://aws.amazon.com/device-farm/ )
• BlueStacks
• Genymotion
• Эмулятор Android
• Энди 46.2.207.0
• MEmu play
• Nox App Player
• Koplayer
• .....

Как использовать с примером:

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

                    }
                });

Вы можете проверить IMEI #, http://developer.android.com/reference/android/telephony/TelephonyManager.html#getDeviceId%28%29

если я вызову на эмуляторе это возвращение 0. однако, я не могу найти никакой документации, которая бы это гарантировала. хотя эмулятор может не всегда возвращать 0, вполне вероятно, что зарегистрированный телефон не вернет 0. что произойдет на устройстве, не являющемся телефоном для Android, или на устройстве без установленной SIM-карты или на устройстве, которое в данный момент не зарегистрировано на сеть?

кажется, что это плохая идея, зависеть от этого.

это также означает, что вам нужно запросить разрешение на чтение состояния телефона, что плохо, если вам это не нужно для чего-то другого.

если нет, то всегда где-то щелкает, прежде чем вы, наконец, сгенерируете подписанное приложение.

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

Это должно вернуть true, если приложение работает на эмуляторе.

Мы должны быть осторожны, чтобы не обнаружить все эмуляторы, потому что есть только несколько разных эмуляторов. Это легко проверить. Мы должны убедиться, что фактические устройства не распознаются как эмулятор.

Я использовал приложение под названием « Android Device Info Share », чтобы проверить это.

В этом приложении вы можете видеть различную информацию о многих устройствах (возможно, о большинстве устройств в мире; если используемое вами устройство отсутствует в списке, оно будет добавлено автоматически).

Проверяя ответы, ни один из них не работал при использовании эмуляторов LeapDroid, Droid4x или Andy,

Что работает для всех случаев:

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

На самом деле, ANDROID_ID на 2.2 всегда равен 9774D56D682E549C (согласно этой теме + мои собственные эксперименты).

Итак, вы можете проверить что-то вроде этого:

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

Не самая красивая, но она делает свою работу.

Это работает для меня

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

Положить файл в файловую систему эмулятора; поскольку файл не существует на реальном устройстве, он должен быть стабильным, надежным и легко исправимым в случае поломки.

Я собрал все ответы на этот вопрос и придумал функцию, чтобы определить, работает ли Android на виртуальной машине / эмуляторе:

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

Проверено на эмуляторе, Genymotion и Bluestacks (1 октября 2015 г.).

Какой код вы используете , чтобы сделать обнаружение эмулятора, я настоятельно рекомендую писать юнит - тесты , чтобы охватить все Build.FINGERPRINT, Build.HARDWAREи Build.MANUFACTURERзначение , которые зависят от. Вот несколько примеров тестов:

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

... и вот наш код (журналы отладки и комментарии удалены для краткости):

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

Поскольку основным механизмом эмуляции для Genymotion является VirtualBox, и он не изменится в ближайшее время, я нашел следующий код наиболее надежным:

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

Другой вариант - проверить, находитесь ли вы в режиме отладки или производственном режиме:

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

просто и надежно.

Не совсем ответ на вопрос, но в большинстве случаев вы можете захотеть провести различие между сеансами отладки / тестирования и сеансами жизни вашей пользовательской базы.

В моем случае я установил для Google Analytics значение DryRun () в режиме отладки, поэтому этот подход работает для меня совершенно нормально.

Для более продвинутых пользователей есть еще один вариант. Варианты сборки Gradle:

в файле Gradle вашего приложения добавьте новый вариант:

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

В вашем коде проверьте тип сборки:

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

Теперь у вас есть возможность создать 3 разных типа вашего приложения.