エミュレーターでAndroidアプリケーションが実行されていることを検出するにはどうすればよいですか？

エミュレータで実行する場合とデバイスで実行する場合で、コードの実行方法を少し変えたいと思います。（たとえば、パブリックURLの代わりに10.0.2.2を使用して、開発サーバーに対して自動的に実行します。）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;

    }

emuを検出するより良い方法があるかどうかはわかりませんが、エミュレーターはinit.goldfish.rcルートディレクトリにファイルを持っています。

これはエミュレータ固有の起動スクリプトであり、エミュレータ以外のビルドには存在しないはずです。

これが私の解決策です（デバッグマシンでWebサーバーを実行する場合にのみ機能します）：アプリケーションの起動時に開始するバックグラウンドタスクを作成しました。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;
}
}

onCreateのメインアクティビティから：

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

バッテリーから、エミュレーター：電源は常にAC充電器です。温度は常に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エミュレータかどうかを確認します。

エミュレータが新しいものではないかどうか、また十分でない可能性があるかどうかを確認するための公式の方法、上記の回答も述べられています。

しかし、これはおそらく、オフィシャルがエミュレータかどうかをチェックするオフィシャルの方法を提供することを示しています。

上記のすべての方法を使用しているので、現在、エミュレーターかどうかを確認するために2つの方法を使用することもできます。

com.android.internalパッケージへのアクセス方法と@hide

公式のオープンSDKを待ちます。

もう1つのオプションは、ro.hardwareプロパティを調べ、金魚に設定されているかどうかを確認することです。残念ながら、Javaからこれを行う簡単な方法はないようですが、property_get（）を使用してCから簡単に行うことができます。

上記の推奨ソリューションはANDROID_ID、Android 2.2でリリースされた最新のSDKツールに本日アップデートするまで、機能するかどうかを確認するために機能しました。

したがって、私は現在、次の解決策に切り替えましたが、これはこれまでのところ機能しませんが、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);
    }
} 

1つの方法ですべての回答

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エミュレータを簡単に検出

• デバイスファーム（https://aws.amazon.com/device-farm/）で実際のデバイスを確認した
• BlueStacks
• Genymotion
• Android Emulator
• アンディ46.2.207.0
• MEmuプレイ
• Noxアプリプレーヤー
• コプレーヤー
• .....

例の使用方法：

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デバイス情報共有」というアプリで確認しました。

このアプリでは、多くのデバイスのさまざまな種類の情報を見ることができます（おそらく世界のほとんどのデバイス。使用しているデバイスがリストにない場合は、自動的に追加されます）。

回答を確認したところ、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;
}

実際、2.2のANDROID_IDは常に9774D56D682E549Cに等しくなります（このスレッド +私の実験によると）。

だから、あなたはこのようなものをチェックすることができます：

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

きれいではありませんが、それは仕事をします。

これは私のために働く

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

エミュレータのファイルシステムにファイルを置きます。ファイルは実際のデバイスには存在しないので、これは安定していて、信頼でき、壊れたときに簡単に修正できるはずです。

私はこの質問のすべての回答を収集し、Androidがvm /エミュレーターで実行されているかどうかを検出する機能を考え出しました：

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

Emulator、Genymotion、Bluestacksでテスト済み（2015年10月1日）。

あなたはエミュレータ検出を行うために使用どちらのコード、私は非常にすべてカバーするユニットテストの書き込みをお勧めしたい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つの異なるタイプのアプリを作成する機会があります。