에뮬레이터에서 Android 응용 프로그램이 실행 중일 때 어떻게 감지할 수 있습니까?
에뮬레이터에서 실행할 때와 장치에서 실행할 때 코드를 약간 다르게 실행하고 싶습니다. (예를 들어, 개발 서버에서 자동으로 실행하기 위해 공개 URL 대신 10.0.2.2를 사용합니다.)에뮬레이터에서 Android 응용 프로그램이 실행 중일 때 탐지하는 가장 좋은 방법은 무엇입니까?
솔루션은 ?SystemProperties여기서 사용 가능):
val isProbablyRunningOnEmulator: Boolean by lazy {
// Android SDK emulator
return@lazy ((Build.MANUFACTURER == "Google" && Build.BRAND == "google" &&
((Build.FINGERPRINT.startsWith("google/sdk_gphone_")
&& Build.FINGERPRINT.endsWith(":user/release-keys")
&& Build.PRODUCT.startsWith("sdk_gphone_")
&& Build.MODEL.startsWith("sdk_gphone_"))
//alternative
|| (Build.FINGERPRINT.startsWith("google/sdk_gphone64_")
&& (Build.FINGERPRINT.endsWith(":userdebug/dev-keys") || Build.FINGERPRINT.endsWith(":user/release-keys"))
&& Build.PRODUCT.startsWith("sdk_gphone64_")
&& Build.MODEL.startsWith("sdk_gphone64_"))))
//
|| 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")
//bluestacks
|| "QC_Reference_Phone" == Build.BOARD && !"Xiaomi".equals(Build.MANUFACTURER, ignoreCase = true)
//bluestacks
|| Build.MANUFACTURER.contains("Genymotion")
|| Build.HOST.startsWith("Build")
//MSI App Player
|| Build.BRAND.startsWith("generic") && Build.DEVICE.startsWith("generic")
|| Build.PRODUCT == "google_sdk"
// another Android SDK emulator check
|| SystemProperties.getProp("ro.kernel.qemu") == "1")
}
일부 에뮬레이터는 실제 장치의 정확한 사양을 위조하므로 탐지가 불가능할 수 있습니다.제가 할 수 있는 것을 추가했는데, 진짜 에뮬레이터인지 아닌지를 100% 탐지할 수 있는 방법은 없는 것 같습니다.
여기 APK에서 작성할 수 있는 작은 조각이 있습니다. 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")
Flutter 커뮤니티는 device-info 플러그인에서 이 코드를 사용하여 장치가 에뮬레이터인지 확인합니다.
private val isEmulator: Boolean
get() = (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("sdk_gphone64_arm64")
|| Build.PRODUCT.contains("vbox86p")
|| Build.PRODUCT.contains("emulator")
|| Build.PRODUCT.contains("simulator");
}
안드로이드 id는 저에게 적합하지 않습니다. 저는 현재 다음을 사용하고 있습니다.
"google_sdk".equals( Build.PRODUCT );
다른 답변의 힌트에 따르면, 이것이 가장 강력한 방법일 것입니다.
isEmulator = Build.HARDWARE.equals("ranchu")
당신의 앱이 디버그 키로 서명되었는지 알려주는 아래 코드와 같은 것은 어떻습니까?에뮬레이터를 감지하는 것이 아니라 당신의 목적에 맞게 작동할 수도 있습니까?
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 카드가 없을 경우 빈 문자열을 반환합니다:"
안드로이드 에뮬레이터는 항상 "안드로이드"를 네트워크 운영자로 되돌리기 때문에 위의 코드를 사용합니다.
당신이 에뮬레이터 안에 있는지 알 수 있는 좋은 방법을 찾지 못했습니다.
그러나 개발 환경에 있는지 확인하기만 하면 다음과 같은 작업을 수행할 수 있습니다.
if(Debug.isDebuggerConnected() ) {
// Things to do in debug environment...
}
이 도움이 되길 바랍니다.
몇 가지 방법을 시도해 보았지만 빌드를 확인하는 약간 수정된 버전으로 결정했습니다.아래와 같은 제품입니다.이것은 에뮬레이터마다 상당히 다른 것 같습니다. 그래서 저는 현재 가지고 있는 세 가지 수표를 가지고 있습니다.product.에 ("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;
}
참고로 - 내 킨들 파이어에 빌드가 있다는 것을 발견했습니다.브랜드 = "유효" 및 일부 에뮬레이터에는 네트워크 운영자를 위한 "Android"가 없습니다.
다음은 모두 "google_sdk"로 설정됩니다.
Build.PRODUCT
Build.MODEL
따라서 다음 라인 중 하나를 사용하면 충분합니다.
"google_sdk".equals(Build.MODEL)
또는
"google_sdk".equals(Build.PRODUCT)
나는 단지 찾는 것뿐입니다._sdk,_sdk_또는sdk_ 그냥 아면그냥니▁just.sdk에 참가하는.Build.PRODUCT:
if(Build.PRODUCT.matches(".*_?sdk_?.*")){
//-- emulator --
}else{
//-- other device --
}
다음 기능을 사용합니다.
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;
}
Firebase Crashlytics는 다음과 같이 접근합니다.
private static final String GOLDFISH = "goldfish";
private static final String RANCHU = "ranchu";
private static final String SDK = "sdk";
public static boolean isEmulator() {
return Build.PRODUCT.contains(SDK)
|| Build.HARDWARE.contains(GOLDFISH)
|| Build.HARDWARE.contains(RANCHU);
}
하는 더 있을 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("");
배터리에서 에뮬레이터:전원은 항상 AC 충전기입니다.온도는 항상 0입니다.
그리고 당신은 사용할 수 있습니다.Build.HOST호스트 값을 기록하기 위해 에뮬레이터마다 호스트 값이 다릅니다.
또 다른 옵션은 ro.hardware 속성을 보고 금붕어로 설정되어 있는지 확인하는 것입니다.안타깝게도 Java에서 이를 수행하는 쉬운 방법은 없는 것 같지만 property_get()을 사용하여 C에서 사소한 것입니다.
나는 새로운 에뮬레이터를 찾았습니다.Build.HARDWARE = "ranchu".
참조: https://groups.google.com/forum/ #!항목/안드로이드-에뮬레이터-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를 기다립니다.
위에서 제안한 해결책은 다음과 같습니다.ANDROID_IDAndroid 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);
}
}
Build.BRAND.startsWith("generic") && Build.DEVICE.startsWith("generic")
앱이 에뮬레이터에서 실행 중인 경우 이 값이 true로 반환됩니다.
우리가 주의해야 할 것은 여러 개의 다른 에뮬레이터만 있기 때문에 모든 에뮬레이터를 감지하지 않는 것입니다.그것은 확인하기 쉽습니다.우리는 실제 장치가 에뮬레이터로 탐지되지 않도록 해야 합니다.
저는 이것을 확인하기 위해 "Android Device Info Share"라는 앱을 사용했습니다.
이 앱에서는 여러 장치의 다양한 종류의 정보를 볼 수 있습니다(아마도 전 세계 대부분의 장치에서 사용 중인 장치가 목록에서 누락된 경우 자동으로 추가됩니다).
한 가지 방법으로 모든 답변 제공
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;
}
답을 확인해보니, 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 에뮬레이터 감지
- Device Farm(https://aws.amazon.com/device-farm/) 의 실제 장치에서 확인됨
- 블루스택
- 지니모션
- 안드로이드 에뮬레이터
- 앤디 46.2.207.0
- 뮤플레이
- Nox 앱 플레이어
- 코플레이어
- .....
예를 들어 사용하는 방법:
EmulatorDetector.with(this)
.setCheckTelephony(true)
.addPackageName("com.bluestacks")
.setDebug(true)
.detect(new EmulatorDetector.OnEmulatorDetectorListener() {
@Override
public void onResult(boolean isEmulator) {
if(isEmulator){
// Do your work
}
else{
// Not emulator and do your work
}
}
});
IMEI #, http://developer.android.com/reference/android/telephony/TelephonyManager.html#getDeviceId%28%29 를 확인할 수 있습니다.
내가 에뮬레이터에서 이 반환 0을 기억한다면, 그러나 에뮬레이터가 항상 0을 반환하지는 않을 수 있지만 등록된 전화기가 0을 반환하지 않는 것은 꽤 안전해 보입니다. 비폰 안드로이드 장치에서 무슨 일이 발생할지,또는 SIM 카드가 설치되지 않았거나 네트워크에 현재 등록되지 않은 것입니까?
그것에 의존하는 것은 좋지 않은 생각인 것 같습니다.
그것은 또한 당신이 전화 상태를 읽기 위한 권한을 요청해야 한다는 것을 의미합니다. 만약 당신이 다른 것에 아직 그것을 요구하지 않는다면 그것은 좋지 않습니다.
그렇지 않다면 서명된 앱을 생성하기 전에 항상 어딘가에서 약간의 정보가 뒤집힙니다.
사실, 안드로이드_2.2의 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;
}
에뮬레이터, 지니모션 및 블루스택에서 테스트됨(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;
}
}
또 다른 옵션은 디버그 모드인지 프로덕션 모드인지 확인하는 것입니다.
if (BuildConfig.DEBUG) { Log.i(TAG, "I am in debug mode"); }
간단명료한
질문에 대한 답은 아니지만 대부분의 경우 디버깅/테스트 세션과 사용자 기반의 수명 세션을 구분해야 할 수 있습니다.
저의 경우 디버그 모드일 때 구글 분석을 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가지 유형의 앱을 구축할 수 있습니다.
언급URL : https://stackoverflow.com/questions/2799097/how-can-i-detect-when-an-android-application-is-running-in-the-emulator
'programing' 카테고리의 다른 글
| 한 데이터베이스의 테이블에서 다른 데이터베이스로 데이터 복사 (0) | 2023.08.10 |
|---|---|
| iOS 10에서 카메라 및 라이브러리에 대한 권한 요청 - Info.plist (0) | 2023.08.10 |
| 특정 워크시트에서 Excel 파일 열기 (0) | 2023.08.10 |
| puppeteer: 다음 줄로 계속하기 전에 N초 대기 (0) | 2023.08.10 |
| 한 기능에서 선언된 연합 유형을 다른 기능에서 사용하는 것이 잘못된 이유는 무엇입니까? (0) | 2023.08.10 |