에뮬레이터에서 실행할 때 장치에서 실행할 때와 코드가 약간 다르게 실행되도록하고 싶습니다. ( 예를 들어 , 공개 URL 대신 10.0.2.2를 사용하여 개발 서버에 대해 자동으로 실행합니다.) 에뮬레이터에서 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")
글쎄, 안드로이드 ID가 나를 위해 작동하지 않습니다, 나는 현재 사용하고 있습니다 :
"google_sdk".equals( Build.PRODUCT );
다른 답변의 힌트를 바탕으로 아마도 가장 강력한 방법 일 것입니다.
isEmulator = "goldfish".equals(Build.HARDWARE)
isEmulator = Build.HARDWARE.contains("golfdish")
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");
}
아래 코드와 같이 앱이 디버그 키로 서명되었는지 여부는 어떻습니까? 에뮬레이터를 감지하지 못하지만 목적에 따라 작동 할 수 있습니까?
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;
}
BuildConfig.DEBUG
입니다.
이 코드는 나를 위해 작동합니다
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)
sdk_x86
입니다.
몇 가지 기술을 시도했지만 아래와 같이 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"가 없습니다.
에뮬레이터에 있는지 알 수있는 좋은 방법을 찾지 못했습니다.
그러나 개발 환경에 있다면 detecet해야 할 경우 다음을 수행 할 수 있습니다.
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;
}
내 솔루션은 다음과 같습니다 (디버그 시스템에서 웹 서버를 실행하는 경우에만 작동합니다). 응용 프로그램이 시작될 때 시작되는 백그라운드 작업을 만들었습니다. 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("");
또 다른 옵션은 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;
}
init.goldfish.rc
에뮬레이터에만 존재합니다. 빌드 세부 사항 외에도 앞으로도 좋은 검사입니다.
새로운 에뮬레이터를 찾았습니다 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를 기다립니다.
내 추천 :
안드로이드 에뮬레이터를 쉽게 감지
- 장치 팜에서 실제 장치를 확인했습니다 ( 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 카드가 설치되지 않은 기기 또는 현재 등록되지 않은 기기에서 발생하는 상황 회로망?
그것에 의존하는 것은 나쁜 생각 인 것 같습니다.
또한 전화 상태를 읽을 수있는 권한을 요청해야한다는 것을 의미합니다. 다른 상태가 필요하지 않은 경우에는 좋지 않습니다.
그렇지 않으면 서명 된 앱을 생성하기 전에 항상 어딘가에 약간의 변화가 있습니다.
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;
가장 예쁘지는 않지만 일을합니다.
이 질문에 대한 모든 답변을 수집했으며 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 일).
답변을 확인한 결과 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;
}
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;
}
}
또 다른 옵션은 디버그 모드 또는 프로덕션 모드인지 확인하는 것입니다.
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 가지 유형의 앱을 만들 수 있습니다.
android.os.Build
.