How can I detect when an Android application is running in the emulator

Question

I would like to have my code run slightly differently when running on the emulator than when running on a device   For example  using 10 0 2 2 instead of a public URL to run against a development server automatically   What is the best way to detect when an Android application is running in the emulator

User · Answer

if   sdk  equals  Build PRODUCT          Then you are running the app on the emulator          Log w  MyAPP     n n  Emulator  n n

User · Answer

Put a file in the file system of the emulator  since the file won t exist on the real device  this should be stable  reliable and easy to fix when it breaks

User · Answer

I just look for  sdk   sdk  or sdk   or even just sdk part in Build PRODUCT   if Build PRODUCT matches      sdk             -- emulator --  else      -- other device --

User · Answer

Whichever code you use to do emulator detection  I d highly recommend writing unit tests to cover all the Build FINGERPRINT  Build HARDWARE and Build MANUFACTURER values that you are depending on   Here are some example tests    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           and here s our code  debug logs and comments removed for conciseness    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  amp  amp  isEmulatorManufacturer            return true        else           return false

User · Answer

From Battery  the emulator  Power source is always AC Charger  Temperature is always 0   And you can use Build HOST to record host value  different emulator has different host value

User · Answer

you can check the IMEI    http   developer android com reference android telephony TelephonyManager html getDeviceId 28 29  if i recall on the emulator this return 0  however  there s no documentation i can find that guarantees that  although the emulator might not always return 0  it seems pretty safe that a registered phone would not return 0  what would happen on a non-phone android device  or one without a SIM card installed or one that isn t currently registered on the network   seems like that d be a bad idea  to depend on that   it also means you d need to ask for permission to read the phone state  which is bad if you don t already require it for something else    if not that  then there s always flipping some bit somewhere before you finally generate your signed app

User · Answer

Another option would be to look at the ro hardware property and see if its set to goldfish   Unfortunately there doesn t seem to be an easy way to do this from Java but its trivial from C using property get

User · Answer

try this link from github   https   github com mofneko EmulatorDetector   This module help you to emulator detection to your Android project suported Unity   Basic checker   BlueStacks Genymotion Android Emulator Nox App Player Koplayer

User · Answer

All answers in one method  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

User · Answer

Don t know if there are better ways to detect the emu  but the emulator will have the file init goldfish rc in the root-directory    It s the emulator specific startup-script  and it shouldn t be there on a non-emulator build

User · Answer

How about something like the code below to tell if your app was signed with the debug key  it s not detecting the emulator but it might work for your purpose   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 lt   gt  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  lt  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

User · Answer

How about this solution  class implementation of SystemProperties is available here   private var sIsProbablyRunningOnEmulator  Boolean    null  fun isProbablyRunningOnEmulator    Boolean       var result   sIsProbablyRunningOnEmulator     if  result    null          return result        Android SDK emulator     result    Build FINGERPRINT startsWith  quot google sdk gphone  quot                amp  amp  Build FINGERPRINT endsWith  quot  user release-keys quot                amp  amp  Build MANUFACTURER     quot Google quot   amp  amp  Build PRODUCT startsWith  quot sdk gphone  quot    amp  amp  Build BRAND     quot google quot               amp  amp  Build MODEL startsWith  quot sdk gphone  quot                                  Build FINGERPRINT startsWith  quot generic quot                  Build FINGERPRINT startsWith  quot unknown quot                  Build MODEL contains  quot google sdk quot                  Build MODEL contains  quot Emulator quot                  Build MODEL contains  quot Android SDK built for x86 quot                 bluestacks                 quot QC Reference Phone quot     Build BOARD  amp  amp    quot Xiaomi quot  equals Build MANUFACTURER  ignoreCase   true    bluestacks                Build MANUFACTURER contains  quot Genymotion quot                  Build HOST startsWith  quot Build quot     MSI App Player                Build BRAND startsWith  quot generic quot    amp  amp  Build DEVICE startsWith  quot generic quot                  Build PRODUCT     quot google sdk quot                 another Android SDK emulator check                SystemProperties getProp  quot ro kernel qemu quot       quot 1 quot      sIsProbablyRunningOnEmulator   result     return result    Note that some emulators fake exact specs of real devices  so it might be impossible to detect it  I ve added what I could  but I don t think there is a 100  way to detect if it s really an emulator or not  Here a tiny snippet you can make in the APK to show various things about it  so you could add your own rules          textView text    quot FINGERPRINT   Build FINGERPRINT  n quot                     quot MODEL   Build MODEL  n quot                     quot MANUFACTURER   Build MANUFACTURER  n quot                     quot BRAND   Build BRAND  n quot                     quot DEVICE   Build DEVICE  n quot                     quot BOARD   Build BOARD  n quot                     quot HOST   Build HOST  n quot                     quot PRODUCT   Build PRODUCT  n quot

User · Answer

It is a good idea to verify if the device has these packages installed        mListPackageName add  com google android launcher layouts genymotion        mListPackageName add  com bluestacks        mListPackageName add  com vphone launcher        mListPackageName add  com bignox app      And then simply check against the package manager till it finds one    private static boolean isEmulByPackage Context context            final PackageManager pm   context getPackageManager            for  final String pkgName   mListPackageName                return isPackageInstalled pkgName  pm                     return false         private static boolean isPackageInstalled final String packageName  final PackageManager packageManager        try           packageManager getPackageInfo packageName  0           return true        catch  PackageManager NameNotFoundException e            return false

User · Answer

My recommendation  try this from github  Easy to detect android emulator   Checked on real devices in Device Farm  https   aws amazon com device-farm   BlueStacks Genymotion Android Emulator Andy 46 2 207 0 MEmu play Nox App Player Koplayer         How to use with an Example  EmulatorDetector with this                   setCheckTelephony true                   addPackageName  quot com bluestacks quot                    setDebug true                   detect new EmulatorDetector OnEmulatorDetectorListener                          Override                     public void onResult boolean isEmulator                            if isEmulator                               Do your work                                                   else                             Not emulator and do your work

User · Answer

Build BRAND startsWith  generic    amp  amp  Build DEVICE startsWith  generic     This should return true if the app is running on an emulator   What we should be careful about is not detecting all the emulators because there are only several different emulators  It is easy to check  We have to make sure that actual devices are not detected as an emulator   I used the app called  Android Device Info Share  to check this   On this app  you can see various kinds of information of many devices  probably most devices in the world  if the device you are using is missing from the list  it will be added automatically

User · Answer

Well Android id does not work for me  I m currently using    google sdk  equals  Build PRODUCT

User · Answer

if  Build BRAND equalsIgnoreCase  generic             Is the emulator     All BUILD references are build prop values  so you have to consider that if you are going to put this into release code  you may have some users with root that have modified theirs for whatever reason  There are virtually no modifications that require using generic as the brand unless specifically trying to emulate the emulator   Fingerprint is the build compile and kernel compile signature  There are builds that use generic  usually directly sourced from Google   On a device that has been modified  the IMEI has a possibility of being zeroed out as well  so that is unreliable unless you are blocking modified devices altogether   Goldfish is the base android build that all other devices are extended from  EVERY Android device has an init goldfish rc unless hacked and removed for unknown reasons

User · Answer

Based on hints from other answers  this is probably the most robust way   isEmulator    goldfish  equals Build HARDWARE

User · Answer

This works for me  public boolean isEmulator         return Build MANUFACTURER equals  unknown

User · Answer

You may check if deviceId  IMEI  is  000000000000000   15 zeroes

User · Answer

use this function      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  gt  4

User · Answer

This worked for me instead of startsWith   Build FINGERPRINT contains  generic    For more check this link  https   gist github com espinchi 168abf054425893d86d1

User · Answer

I tried several techniques  but settled on a slightly revised version of checking the Build PRODUCT as below   This seems to vary quite a bit from emulator to emulator  that s why I have the 3 checks I currently have   I guess I could have just checked if product contains  sdk   but thought the check below was a bit safer   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 - I found that my Kindle Fire had Build BRAND    generic   and some of the emulators didn t have  Android  for the network operator

User · Answer

Another option is to check if you are in debug mode or production mode   if  BuildConfig DEBUG    Log i TAG   I am in debug mode       simple and reliable    Not totally the answer of the question but in most cases you may want to distinguish between debugging test sessions and life sessions of your user base    In my case I set google analytics to dryRun   when in debug mode so this approach works totally fine for me      For more advanced users there is another option  gradle build variants    in your app s gradle file add a new variant   buildTypes       release              some already existing commands           debug              some already existing commands              the following is new     test             In your code check the build type   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        Now you have the opportunity to build 3 different types of your app

User · Answer

Google uses this code in the device-info plugin from Flutter to determine if the device is an emulator   private boolean isEmulator         return  Build BRAND startsWith  generic    amp  amp  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

User · Answer

One common one sems to be Build FINGERPRINT contains  generic

User · Answer

Since the underlying emulation engine for Genymotion is VirtualBox and that s not going to change any time soon I found the following code the most reliable       public static boolean isGenymotion             return Build PRODUCT    null  amp  amp  Build PRODUCT contains  vbox

User · Answer

Both the following are set to  google sdk    Build PRODUCT Build MODEL   So it should be enough to use either one of the following lines    google sdk  equals Build MODEL    or   google sdk  equals Build PRODUCT

User · Answer

I never found a good way to tell if you re in the emulator   but if you just need to detecet if you re in a development environment  you can do this         if Debug isDebuggerConnected                  Things to do in debug environment            Hope this help

User · Answer

I found the new emulator Build HARDWARE    ranchu    Reference https   groups google com forum   topic android-emulator-dev dltBnUW HzU  And also I found the Android official way to check whether emulator or not I think it s good reference for us      Since 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        We have ScreenShapeHelper IS EMULATOR to check whether emulator      Since 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         We have Build IS EMULATOR to check whether emulator   The way the official to check whether emulator is not new and also maybe not enough the answers above also mentioned   But this maybe show us that the official will provide the way of official to check whether emulator or not   As using the above all ways mentioned right now we can also use the two ways about to check whether emulator   How to access the com android internal package and  hide  and wait for the official open SDK

User · Answer

Checking the answers  none of them worked when using LeapDroid  Droid4x or Andy emulators   What does work for all cases is the following    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    gt  0      boolean sdk   getSystemProperty  ro product model   equals  sdk        return goldfish    emu    sdk

User · Answer

This code works for me  TelephonyManager tm    TelephonyManager getSystemService Context TELEPHONY SERVICE   String networkOperator   tm getNetworkOperatorName    if  Android  equals networkOperator            Emulator   else          Device     In case that device does not have sim card  It retuns empty string     Since Android emulator always retuns  Android  as network operator  I use above code

User · Answer

Actually  ANDROID ID on 2 2 always equals 9774D56D682E549C  according to this thread   my own experiments     So  you could check something like this    String androidID        if androidID    null    androidID equals  9774D56D682E549C        do stuff    Not the prettiest  but it does the job

User · Answer

The above suggested solution to check for the ANDROID ID worked for me until I updated today to the latest SDK tools released with Android 2 2   Therefore I currently switched to the following solution which works so far with the disadvantage however that you need to put the PHONE STATE read permission   lt uses-permission android name  android permission READ PHONE STATE   gt    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

User · Answer

Here is my solution  it works only if you run a web server on your debug machine   I have created a background task that starts when the application starts  It looks for http   10 0 2 2 and if it exists it changes a global parameter  IsDebug  to true  It is a silent way to find out where you are running   public class CheckDebugModeTask extends AsyncTask lt String  Void  String gt    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        from the main activity onCreate   CheckDebugModeTask checkDebugMode   new CheckDebugModeTask    checkDebugMode execute

User · Answer

I ve collected all the answers on this question and came up with function to detect if Android is running on a 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   amp  amp Build DEVICE contains  generic                 isvm    true                     return isvm            Tested on Emulator  Genymotion and Bluestacks  1 October 2015

[android] How can I detect when an Android application is running in the emulator?

Examples related to android

Examples related to android-emulator