Bagaimana saya bisa mendeteksi ketika aplikasi Android berjalan di emulator?

Saya ingin kode saya berjalan sedikit berbeda ketika berjalan di emulator daripada ketika berjalan di perangkat. ( Misalnya , menggunakan 10.0.2.2 alih-alih URL publik untuk berjalan melawan server pengembangan secara otomatis.) Apa cara terbaik untuk mendeteksi ketika aplikasi Android berjalan di emulator?

Bagaimana dengan solusi ini:

    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

Perhatikan bahwa beberapa emulator memalsukan spesifikasi pasti dari perangkat nyata, jadi mungkin tidak mungkin untuk mendeteksinya.

Berikut cuplikan kecil yang dapat Anda buat di APK untuk menunjukkan berbagai hal tentangnya, sehingga Anda dapat menambahkan aturan Anda sendiri:

        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"

Satu sem yang biasa Build.FINGERPRINT.contains("generic")

Yah Android id tidak berfungsi untuk saya, saya saat ini menggunakan:

"google_sdk".equals( Build.PRODUCT );

Berdasarkan petunjuk dari jawaban lain, ini mungkin cara yang paling kuat:

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

Google menggunakan kode ini di plugin info-perangkat dari Flutter untuk menentukan apakah perangkat itu emulator:

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

Bagaimana dengan sesuatu seperti kode di bawah ini untuk mengetahui apakah aplikasi Anda ditandatangani dengan kunci debug? itu tidak mendeteksi emulator tetapi mungkin berhasil untuk tujuan Anda?

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;

} 

Kode ini berfungsi untuk saya

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

Jika perangkat tidak memiliki kartu sim, ia mengembalikan string kosong: ""

Karena Android emulator selalu mengembalikan "Android" sebagai operator jaringan, saya menggunakan kode di atas.

Saya mencoba beberapa teknik, tetapi memutuskan untuk memeriksa versi Build.PRODUCT yang sedikit direvisi seperti di bawah ini. Ini tampaknya sedikit berbeda dari emulator ke emulator, itu sebabnya saya memiliki 3 pemeriksaan yang saya miliki saat ini. Saya kira saya bisa saja memeriksa apakah product.contains ("SDK") tetapi berpikir pemeriksaan di bawah ini sedikit lebih aman.

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 - Saya menemukan bahwa Kindle Fire saya memiliki Build.BRAND = "generik", dan beberapa emulator tidak memiliki "Android" untuk operator jaringan.

Kedua hal berikut ini disetel ke "google_sdk":

Build.PRODUCT
Build.MODEL

Jadi itu sudah cukup untuk menggunakan salah satu dari baris berikut.

"google_sdk".equals(Build.MODEL)

atau

"google_sdk".equals(Build.PRODUCT)

Saya hanya mencari _sdk, _sdk_atau sdk_, atau bahkan hanya sdkbagian dalam Build.PRODUCT:

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

Saya tidak pernah menemukan cara yang baik untuk mengetahui apakah Anda berada di emulator.

tetapi jika Anda hanya perlu mendeteksi jika Anda berada dalam lingkungan pengembangan Anda dapat melakukan ini:

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

Semoga bantuan ini ....

gunakan fungsi ini:

 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;

    }

Tidak tahu apakah ada cara yang lebih baik untuk mendeteksi emu, tetapi emulator akan memiliki file init.goldfish.rcdi direktori root.

Ini adalah skrip startup khusus emulator, dan seharusnya tidak ada pada build non-emulator.

Ini solusi saya (hanya berfungsi jika Anda menjalankan server web pada mesin debug Anda): Saya telah membuat tugas latar belakang yang dimulai ketika aplikasi dimulai. Itu mencari http://10.0.2.2 dan jika ada itu mengubah parameter global (IsDebug) menjadi true. Ini adalah cara diam untuk mengetahui di mana Anda berlari.

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

dari aktivitas utama onCreate:

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

Dari Baterai, emulator: Sumber daya selalu AC Charger. Temperatur selalu 0.

Dan Anda dapat menggunakan Build.HOSTuntuk mencatat nilai host, emulator yang berbeda memiliki nilai host yang berbeda.

Saya menemukan emulator baru Build.HARDWARE = "ranchu".

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

Dan juga saya menemukan cara resmi Android untuk memeriksa apakah emulator atau tidak. Saya pikir itu referensi yang baik untuk kita.

Sejak Android API Level 23 [Android 6.0]

package com.android.internal.util;

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

Kami harus ScreenShapeHelper.IS_EMULATORmemeriksa apakah emulator.

Sejak Android API Level 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");

}

Kami harus Build.IS_EMULATORmemeriksa apakah emulator.

Cara resmi untuk mengecek apakah emulator tidak baru, dan juga mungkin tidak cukup, jawaban di atas juga disebutkan.

Tapi ini mungkin menunjukkan kepada kita bahwa pejabat akan menyediakan cara resmi untuk memeriksa apakah emulator atau tidak.

Seperti menggunakan semua cara yang disebutkan di atas, saat ini kita juga dapat menggunakan dua cara untuk memeriksa apakah emulator.

Cara mengakses com.android.internalpaket dan@hide

dan tunggu SDK resmi yang terbuka.

Pilihan lain adalah melihat properti ro.hardware dan melihat apakah diatur ke ikan mas. Sayangnya sepertinya tidak ada cara mudah untuk melakukan ini dari Java tetapi sepele dari C menggunakan property_get () .

Solusi yang disarankan di atas untuk memeriksa ANDROID_IDbekerja untuk saya sampai saya memperbarui hari ini ke alat SDK terbaru yang dirilis dengan Android 2.2.

Karena itu saya saat ini beralih ke solusi berikut yang berfungsi sejauh ini dengan kerugiannya namun Anda harus meletakkan izin baca 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);
    }
} 

Semua jawaban dalam satu metode

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

Rekomendasi saya:

coba ini dari github.

Mudah mendeteksi emulator android

• Memeriksa perangkat nyata di Device Farm ( https://aws.amazon.com/device-farm/ )
• BlueStacks
• Genymotion
• Android Emulator
• Andy 46.2.207.0
• MEmu bermain
• Pemutar Aplikasi Nox
• Koplayer
• .....

Cara menggunakan dengan Contoh:

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

                    }
                });

Anda dapat memeriksa IMEI #, http://developer.android.com/reference/android/telephony/TelephonyManager.html#getDeviceId%28%29

jika saya ingat pada emulator ini kembali 0. Namun, tidak ada dokumentasi saya dapat menemukan yang menjamin itu. walaupun emulator mungkin tidak selalu mengembalikan 0, tampaknya cukup aman bahwa ponsel yang terdaftar tidak akan mengembalikan 0. apa yang akan terjadi pada perangkat android non-ponsel, atau yang tanpa kartu SIM terpasang atau yang saat ini tidak terdaftar pada jaringan?

Sepertinya itu ide yang buruk, bergantung pada itu.

itu juga berarti Anda harus meminta izin untuk membaca keadaan ponsel, yang buruk jika Anda belum memerlukannya untuk hal lain.

jika tidak, maka selalu ada membalik sedikit di suatu tempat sebelum Anda akhirnya menghasilkan aplikasi yang ditandatangani.

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

Ini akan kembali benar jika aplikasi berjalan pada emulator.

Yang harus kita perhatikan adalah tidak mendeteksi semua emulator karena hanya ada beberapa emulator yang berbeda. Mudah diperiksa. Kita harus memastikan bahwa perangkat yang sebenarnya tidak terdeteksi sebagai emulator.

Saya menggunakan aplikasi yang disebut " Berbagi Info Perangkat Android " untuk memeriksa ini.

Pada aplikasi ini, Anda dapat melihat berbagai jenis informasi dari banyak perangkat (mungkin sebagian besar perangkat di dunia; jika perangkat yang Anda gunakan tidak ada dalam daftar, itu akan ditambahkan secara otomatis).

Memeriksa jawabannya, tidak ada yang berfungsi saat menggunakan emulator LeapDroid, Droid4x atau Andy,

Apa yang berfungsi untuk semua kasus adalah sebagai berikut:

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

Sebenarnya, ANDROID_ID pada 2.2 selalu sama dengan 9774D56D682E549C (sesuai dengan utas ini + eksperimen saya sendiri).

Jadi, Anda dapat memeriksa sesuatu seperti ini:

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

Bukan yang tercantik, tetapi berhasil.

Ini bekerja untuk saya

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

Letakkan file di sistem file emulator; karena file tidak akan ada pada perangkat nyata, ini harus stabil, dapat diandalkan dan mudah diperbaiki ketika rusak.

Saya telah mengumpulkan semua jawaban pada pertanyaan ini dan muncul dengan fungsi untuk mendeteksi apakah Android berjalan pada 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;
    }

Diuji pada Emulator, Genymotion dan Bluestacks (1 Oktober 2015).

Kode apa pun yang Anda gunakan untuk melakukan deteksi emulator, saya sangat merekomendasikan penulisan unit test untuk mencakup semua Build.FINGERPRINT, Build.HARDWAREdan Build.MANUFACTURERnilai yang Anda andalkan. Berikut ini beberapa contoh tes:

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

... dan inilah kode kami (debug log dan komentar dihapus untuk keringkasan):

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

Karena mesin emulasi yang mendasari untuk Genymotion adalah VirtualBox dan itu tidak akan berubah dalam waktu dekat saya menemukan kode berikut yang paling dapat diandalkan:

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

Pilihan lain adalah untuk memeriksa apakah Anda dalam mode debug atau mode produksi:

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

sederhana dan andal.

Tidak sepenuhnya menjawab pertanyaan tetapi dalam kebanyakan kasus Anda mungkin ingin membedakan antara sesi debug / tes dan sesi kehidupan basis pengguna Anda.

Dalam kasus saya, saya mengatur google analytics ke dryRun () ketika dalam mode debug sehingga pendekatan ini berfungsi dengan baik untuk saya.

Untuk pengguna yang lebih mahir ada opsi lain. varian gradle build:

di file gradle aplikasi Anda tambahkan varian baru:

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

Di kode Anda, periksa tipe build:

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

Sekarang Anda memiliki kesempatan untuk membangun 3 jenis aplikasi Anda.