에뮬레이터에서 Android 애플리케이션이 실행 중인지 어떻게 알 수 있습니까?

lottoking 2020. 3. 18. 23:19

에뮬레이터에서 Android 애플리케이션이 실행 중인지 어떻게 알 수 있습니까?

에뮬레이터에서 실행할 때 장치에서 실행할 때와 코드가 약간 다르게 실행되도록하고 싶습니다. ( 예를 들어 , 공개 URL 대신 10.0.2.2를 사용하여 개발 서버에 대해 자동으로 실행합니다.) 에뮬레이터에서 Android 애플리케이션이 실행될 때 감지하는 가장 좋은 방법은 무엇입니까?

이 솔루션은 어떻습니까?

public static boolean isEmulator() {
    return 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.MANUFACTURER.contains("Genymotion")
            || (Build.BRAND.startsWith("generic") && Build.DEVICE.startsWith("generic"))
            || "google_sdk".equals(Build.PRODUCT);
}

하나의 일반적인 하나 Build.FINGERPRINT.contains("generic")

글쎄, 안드로이드 ID는 나를 위해 작동하지 않습니다, 나는 현재 사용하고 있습니다 :

"google_sdk".equals( Build.PRODUCT );

다른 답변의 힌트를 바탕으로 아마도 가장 강력한 방법 일 것입니다.

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

아래 코드와 같이 앱이 디버그 키로 서명되었는지 여부는 어떻습니까? 에뮬레이터를 감지하지 못하지만 목적에 따라 작동 할 수 있습니까?

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"를 네트워크 운영자로 재조정하므로 위 코드를 사용합니다.

다음은 모두 "google_sdk"로 설정되어 있습니다.

Build.PRODUCT
Build.MODEL

따라서 다음 행 중 하나를 사용하면 충분합니다.

"google_sdk".equals(Build.MODEL)

또는

"google_sdk".equals(Build.PRODUCT)

몇 가지 기술을 시도했지만 아래와 같이 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은 Flutter 의 device-info 플러그인 에서이 코드를 사용 하여 기기가 에뮬레이터인지 확인합니다.

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

나는 단지 _sdk, _sdk_또는 sdk_, 또는 심지어 sdk일부를 찾습니다 Build.PRODUCT.

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

에뮬레이터에 있는지 알 수있는 좋은 방법을 찾지 못했습니다.

그러나 개발 환경에 있다면 탐지해야 할 경우 다음을 수행 할 수 있습니다.

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

이 도움을 바랍니다 ....

emu를 감지하는 더 좋은 방법이 있는지 모르지만 에뮬레이터는 파일 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;
}
}

주요 활동 onCreate에서 :

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

이 기능을 사용하십시오 :

 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;

    }

배터리에서 에뮬레이터 : 전원은 항상 AC 충전기입니다. 온도는 항상 0입니다.

Build.HOST호스트 값을 기록 하는 데 사용할 수 있으며 다른 에뮬레이터는 다른 호스트 값을 갖습니다.

또 다른 옵션은 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);
    }
}

한 가지 방법으로 모든 답변

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

새로운 에뮬레이터를 찾았습니다 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를 기다립니다.

내 추천 :

github에서 이것을 시도 하십시오 .

안드로이드 에뮬레이터를 쉽게 감지

장치 팜의 실제 장치에서 확인 됨 ( https://aws.amazon.com/device-farm/ )

블루 스택

Genymotion

안드로이드 에뮬레이터

앤디 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 기기 정보 공유 ' 라는 앱을 사용했습니다 .

이 응용 프로그램에서 많은 장치의 다양한 정보를 볼 수 있습니다 (아마도 대부분의 장치 일 것입니다. 사용중인 장치가 목록에 없으면 자동으로 추가됩니다).

실제로 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 / 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;
    }

에뮬레이터, Genymotion 및 블루 스택에서 테스트되었습니다 (2015 년 10 월 1 일).

Genymotion의 기본 에뮬레이션 엔진은 VirtualBox이고 곧 변경되지 않을 것이기 때문에 다음 코드가 가장 안정적이라는 것을 알았습니다.

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

당신이 에뮬레이터 탐지를 수행하는 데 사용하는 어느 코드, 내가보기 엔 작성 단위 모두를 커버하는 테스트를 권하고 싶습니다 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;
    }
}

답변을 확인한 결과 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;
}

또 다른 옵션은 디버그 모드 또는 프로덕션 모드인지 확인하는 것입니다.

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

간단하고 신뢰할 수 있습니다.

질문에 대한 대답은 아니지만 대부분의 경우 디버깅 / 테스트 세션과 사용자 기반의 라이프 세션을 구별 할 수 있습니다.

필자의 경우 디버그 모드에서 Google 분석을 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 가지 유형의 앱을 만들 수 있습니다.

참고 : https://stackoverflow.com/questions/2799097/how-can-i-detect-when-an-android-application-is-running-in-the-emulator

'IT' 카테고리의 다른 글

Git 브랜치 생성시기를 결정하는 방법은 무엇입니까? (0)	2020.03.19
속성 x가없는 요소와 일치하는 CSS 선택기 (0)	2020.03.18
URL 인코딩은 "&"(앰퍼샌드)를 "&"HTML 엔터티로 인식 (0)	2020.03.18
Express-js가 정적 파일을 가져올 수없는 이유는 무엇입니까? (0)	2020.03.18
생성자에서 직접 메소드를 정의하는 것과 프로토 타입을 사용하는 이점은 무엇입니까? (0)	2020.03.18

현재글에뮬레이터에서 Android 애플리케이션이 실행 중인지 어떻게 알 수 있습니까?

내가 바로 로또왕!

jquery, c++, 영화순위, 공연, javascript, 놀거리, 연극, 자바, Java, 뮤지컬, 행사, DVD순위, 무비순위, spring3, 관광, 축제, C#, 여행, spring, 볼거리,

Today :
Yesterday :

lottoking