{"id":18148301,"url":"https://github.com/jenkinsci/android-emulator-plugin","last_synced_at":"2025-05-16T02:08:42.045Z","repository":{"id":1231211,"uuid":"1163431","full_name":"jenkinsci/android-emulator-plugin","owner":"jenkinsci","description":"Android Emulator plugin for Jenkins","archived":false,"fork":false,"pushed_at":"2025-05-06T06:00:29.000Z","size":1584,"stargazers_count":209,"open_issues_count":3,"forks_count":145,"subscribers_count":115,"default_branch":"master","last_synced_at":"2025-05-06T06:45:34.141Z","etag":null,"topics":["adopt-this-plugin"],"latest_commit_sha":null,"homepage":"https://plugins.jenkins.io/android-emulator/","language":"Java","has_issues":false,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":null,"status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/jenkinsci.png","metadata":{"files":{"readme":"README.md","changelog":"CHANGELOG.md","contributing":null,"funding":null,"license":null,"code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":".github/CODEOWNERS","security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null}},"created_at":"2010-12-13T05:25:46.000Z","updated_at":"2025-05-06T06:00:34.000Z","dependencies_parsed_at":"2023-02-16T11:46:06.147Z","dependency_job_id":"eeddcf11-65e3-4121-a07d-6099871b163f","html_url":"https://github.com/jenkinsci/android-emulator-plugin","commit_stats":{"total_commits":608,"total_committers":39,"mean_commits":15.58974358974359,"dds":0.537828947368421,"last_synced_commit":"23ed7d67dff8698b595825af6a200795a354afa9"},"previous_names":[],"tags_count":57,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/jenkinsci%2Fandroid-emulator-plugin","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/jenkinsci%2Fandroid-emulator-plugin/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/jenkinsci%2Fandroid-emulator-plugin/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/jenkinsci%2Fandroid-emulator-plugin/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/jenkinsci","download_url":"https://codeload.github.com/jenkinsci/android-emulator-plugin/tar.gz/refs/heads/master","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":254453655,"owners_count":22073617,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["adopt-this-plugin"],"created_at":"2024-11-01T23:07:55.395Z","updated_at":"2025-05-16T02:08:42.006Z","avatar_url":"https://github.com/jenkinsci.png","language":"Java","funding_links":[],"categories":[],"sub_categories":[],"readme":"# Android Emulator Plugin for Jenkins\n\nProvides numerous features for [Android development](http://developer.android.com/) and testing during Jenkins builds, including:\n\n* Creating Android emulators on-demand\n* Running an Android emulator during a build\n* Automatically installing the Android SDK on Jenkins agents, where required\n* Detecting which Android platforms are required to build one or more projects and installing them automatically\n* Generating Ant build files for any app, test, or library projects found in the workspace\n* Installing/uninstalling Android packages\n* Running the monkey stress-testing tool\n* Parsing output from running monkey and marking a build as unstable/failed\n\nAutomates many [Android development](https://developer.android.com/)\ntasks including SDK installation, build file generation, emulator\ncreation and launch, APK (un)installation, monkey testing and\nanalysis...  \nSee also: [Android Lint\nPlugin](https://wiki.jenkins.io/display/JENKINS/Android+Lint+Plugin).  \nSee also: [Google Play Android Publisher\nPlugin](https://wiki.jenkins.io/display/JENKINS/Google+Play+Android+Publisher+Plugin).\n\n#### Table of Contents\n\n## Features\n\nThis plugin lets you automate a number of Android-related tasks during a\nbuild:\n\n-   Creating a new Android emulator\n    -   Its configuration can be parameterised, including OS version,\n        screen size, locale and hardware properties\n    -   Android SDK dependencies are automatically downloaded and\n        installed\n-   Running any Android emulator\n    -   Waits until the emulator is fully started-up\n    -   Emulator snapshots can be automatically created\n        -   This allows a very fast startup time for subsequent builds\n        -   This ensures subsequent builds will start from the same\n            clean state\n    -   Logs are automatically captured and saved\n    -   Emulator will be shut down automatically when the build has\n        finished\n    -   Multiple instances of the same emulator are prevented from\n        running concurrently\n-   Detecting which Android platforms are required to build one or more\n    projects and installing them automatically\n-   Generating Ant build files for any app, test or library projects\n    found in the workspace\n-   Installing an Android package onto an emulator\n-   Uninstalling an Android package from an emulator\n-   Running the `monkey` stress-testing tool\n-   Parsing output from running `monkey`\n    -   The build outcome can be automatically marked as unstable or\n        failed in case a monkey-induced crash is detected\n\n## Requirements\n\n### Jenkins\n\nJenkins [version 2.479.1](https://jenkins.io/changelog/#v2.479.1) or newer is required.\n\n### Android\n\nThe plugin will automatically download and install the [Android\nSDK](https://developer.android.com/sdk/), if it's not already installed\nwhen a build starts.  \nThis means that no manual effort is required to start running Android\nemulators with Jenkins.\n\nYou can, however, disable automated installation via the \"Automatically\ninstall Android components when required\" option on the main Jenkins\nconfiguration page.\n\nView manual SDK installation requirements...\n\nIf you install the Android SDK yourself, you must install at least two\nfurther components, via the [Android SDK and AVD\nManager](https://developer.android.com/sdk/installing.html#components):\n\n-   SDK Tools\n-   SDK Platform-tools\n\nIf you only wish to run pre-existing emulator instances (aka Android\nVirtual Devices, or AVDs), there are no further requirements — only\nthese two components are required.\n\nIf you want the plugin to automatically generate new emulator instances,\nbut disable auto-installation, you must install one or more Android\nplatform versions into the SDK.  \nBy default, the SDK only comes with the bare minimum; in this case you\nwill need to separately download each individual platform version you\nwish to build or test against.\n\nAgain, this is done via the [Android SDK and AVD\nManager](https://developer.android.com/sdk/adding-components.html) tool,\naccessible via the command line \"`android`\", or via the \"Window\" menu in\nEclipse, if you use the Eclipse ADT plugin. From the SDK Manager, you\ncan easily install the desired \"[SDK\nPackages](https://developer.android.com/sdk/installing.html#components)\".\n\n## Configuration\n\n### System configuration\n\nGenerally no global configuration is needed — the plugin will try hard\nto locate an installed Android SDK whenever it is needed. If one is not\nfound, it will be installed automatically.\n\nSee how the SDK is located...\n\nVia the main configuration page, you can optionally specify the location\nwhere each build node can locate a copy of the Android SDK.\n\n![](docs/images/android_global-config.png)\n\nThis can either be an absolute path, or can contain environment\nvariables in the format `$``VARIABLE_NAME`. This will be replaced at\nbuild time from the node's environment variables (see the \"Node\nProperties\" settings for each agent), or from the build's environment.\n\nIf no value is entered, or the plugin cannot find a valid SDK under the\nconfigured path, it will search under the following environment\nvariables on the build node to try and locate a usable SDK:\n\n-   `ANDROID_SDK_ROOT`\n-   `ANDROID_SDK_HOME`\n-   `ANDROID_HOME`\n-   `ANDROID_SDK`\n\nIf nothing is found, the plugin will search on the `PATH` to attempt to\nlocate a usable set of SDK tools. If, after all these steps, the\nrequired Android SDK tools are not found and auto-installation is\ndisabled, the build will be marked as \"not built\" and will stop.\n\n### Job configuration\n\n##### Running on headless build machines\n\nIf you have build agents which are headless (e.g. Linux servers that\ndon't have a graphical user interface), you can still run an Android\nEmulator even although, by default, the emulator does require a\ngraphical environment.\n\nJust untick the \"Show emulator window\" configuration option in your job\nconfiguration. This is the equivalent of using the emulator's\n\"`-no-window`\" command-line option.\n\nUsing an artificial graphical environment...\n\nIt is also possible to run the Android emulator UI on a headless build\nagent by making use of an artificial X server, such as\n[Xvnc](http://www.realvnc.com/products/free/4.1/man/Xvnc.html).\n\nIn this case, a recommended setup is to install both Xvnc and the [Xvnc\nPlugin](https://wiki.jenkins.io/display/JENKINS/Xvnc+Plugin) for Jenkins.\nWith this plugin enabled in your job — and Xvnc configured to run\nwithout requesting a password — you can run multiple Android emulators\nin parallel on a headless agent, while keeping the \"Show emulator\nwindow\" option enabled.\n\nAlthough the Android Emulator plugin has been designed to ensure it\nalways runs after an Xvnc server has been started, the Xvnc plugin does\nnot wait for the Xvnc server to be fully up-and-running before handing\ncontrol over to the Android Emulator plugin.\n\nFor this reason, you may want to delay emulator startup by a few seconds\n(e.g. three to five), giving the Xvnc server time to finish starting-up\nbefore attempting to launch an Android emulator into it. To do so, enter\nthe desired number of seconds in the \"Startup delay\" field under\n\"Advanced\" options.\n\n##### Other requirements\n\nIn addition, while the Android Emulator plugin requires the [Port\nAllocator\nPlugin](https://wiki.jenkins.io/display/JENKINS/Port+Allocator+Plugin),\nthere is no job configuration required for this; everything is handled\nautomatically — you need not select the \"Assign unique TCP ports\"\ncheckbox in the job config.\n\n#### Selecting an emulator\n\nAfter ticking \"Run an Android emulator during build\", you will be asked\nwhether you want to run an existing AVD, or whether you want to create a\nnew one on-the-fly with certain properties.\n\n![](docs/images/android_job-named.png)\n\nUsing an existing emulator for a job just requires that you enter the\nname of the AVD you want to be started. This AVD must exist on each\nbuild node the job will be executed on. Existing AVDs are found in your\n`$HOME/.android/avd` directory and can be listed using the\n\"`android list avd`\" command.  \nAs with all other properties, you can enter environment variables here\nusing the format `$``VARIABLE_NAME`.\n\nAlternatively, if you don't have a particular AVD accessible on each\nbuild node, the plugin can automatically generate a new emulator if one\ndoesn't already exist:\n\n![](docs/images/android_job-custom.png)\n\nEach property is mandatory, aside from the device locale. If this is not\nentered, the Android emulator default locale of US English (en\\_US) will\nbe used when starting the emulator.\n\nEach field will auto-complete with the default Android SDK values, e.g.\n120, 160, 240dpi densities and named screen resolutions including QVGA,\nHVGA, WVGA etc. However, you can enter your own values if you wish to\nuse a custom OS image, screen density, resolution or locale.  \nScreen resolutions can be entered either using the named values, or as a\n\"width times height\" dimension, e.g. `480x800`.\n\nYou can specify multiple hardware properties such as the heap size for\neach Android app, or whether the device has a GPS by clicking the button\n\"Add custom hardware property\" and entering the values. See the inline\nhelp for more details on the values to enter.\n\nUsing Google Maps and other SDK add-ons...\n\nAs mentioned above, the \"Android OS version\" field will auto-complete to\nexisting SDK versions such as \"1.5\" or \"2.2\".\n\nHowever, it is possible to enter different values in this field, for\nexample if you want to use an Android SDK add-on that you have\ninstalled, e.g. the Google APIs add-on or the Samsung GALAXY Tab add-on.\n\nIn these cases, just enter the appropriate value given by the\n\"`android list target`\" command. For example:\n\n-   The Google APIs add-on, based on an Android 1.6 emulator:\n    `Google Inc.:Google APIs:4`\n-   The Samsung GALAXY Tab add-on, based on an Android 2.2 emulator:\n    `Samsung Electronics Co., Ltd.:GALAXY Tab Addon:8`\n\n#### Multi-configuration (matrix) job\n\nThe real awesomeness of this plugin comes when used in conjunction with\na multi-configuration job type.\n\nBy using the \"Run emulator with properties\" setting, in conjunction with\none-or-more matrix axes and the Android Emulator plugin's variable\nexpansion, you can generate and test with a large number of distinct\nAndroid emulator configurations with very little effort.\n\nTo give a full example, if you want to test your application across\nmultiple Android OS versions, multiple screen densities, multiple screen\nresolutions and for several target locales, you might set up your matrix\naxes as follows:\n\n![](docs/images/android_matrix-axes.png)\n\nAs each of these axis names (i.e. \"density\", \"locale\", \"os\",\n\"resolution\") are exported by Jenkins as environment variables, you can\nmake use of these when launching a new Android emulator:\n\n![](docs/images/android_matrix-result.png)  \n![](docs/images/android_job-variables.png)\n\nWhen the build executes, this would automatically generate and allow you\nto test your application against 64 unique device configurations.\n\nHowever, you should note that not **all** combinations are valid. For\nexample, a WVGA (800x480) resolution device makes no sense with a screen\ndensity of 120 (unless you have superhuman eyesight).\n\nFor this purpose, you can use the \"Combination Filter\" feature, which\ntells Jenkins which combinations of the matrix axes are valid. In the\ncase of screen densities and resolutions, a configuration like this\nshould instruct Jenkins to only build for [configurations which make\nsense](http://developer.android.com/guide/practices/screens_support.html#range):\n\n``` syntaxhighlighter-pre\n(density==\"120\").implies(resolution==\"QVGA\" || resolution==\"WQVGA\" || resolution==\"FWQVGA\") \u0026\u0026\n(density==\"160\").implies(resolution==\"HVGA\" || resolution==\"WVGA\" || resolution==\"FWVGA\") \u0026\u0026\n(density==\"240\").implies(resolution==\"WVGA\" || resolution==\"FWVGA\")\n```\n\nNote that each variable refers to one of the matrix axes, *not* an\nAndroid Emulator plugin property.\n\n## Build execution\n\n### Environment\n\nFor convenience, the plugin places a number of variables into the build\nenvironment relating to the emulator in use:\n\n| Variable name             | Example value                     | Description                                                                               |\n|---------------------------|-----------------------------------|-------------------------------------------------------------------------------------------|\n| `ANDROID_SERIAL`          | `localhost:34564`                 | Identifier for connecting to this AVD, e.g. `adb -s localhost:34564 shell`                |\n| `ANDROID_AVD_DEVICE`      | `localhost:34564`                 | Identifier for connecting to this AVD, e.g. `adb -s localhost:34564 shell`                |\n| `ANDROID_AVD_ADB_PORT`    | `34564`                           | Port used by ADB to communicate with the AVD (random for each build)                      |\n| `ANDROID_AVD_USER_PORT`   | `40960`                           | Port used to access the AVD's telnet user interface (random for each build)               |\n| `ANDROID_AVD_NAME`        | `hudson_en-GB_160_HVGA_android-7` | Name of the AVD running for the build                                                     |\n| `ANDROID_AVD_LOCALE`      | `en_GB`                           | Locale of the AVD                                                                         |\n| `ANDROID_AVD_OS`          | `2.1`                             | OS version of the running AVD                                                             |\n| `ANDROID_AVD_DENSITY`     | `160`                             | Screen density in dpi of the AVD                                                          |\n| `ANDROID_AVD_RESOLUTION`  | `HVGA`                            | Screen resolution, named or dimension, of the AVD                                         |\n| `ANDROID_AVD_SKIN`        | `HVGA`                            | Skin being used by the AVD, e.g. `WQVGA432` or `480x800`                                  |\n| `ANDROID_ADB_SERVER_PORT` | `51292`                           | Port that the AVD server for this build is running on (random for each build)             |\n| `ANDROID_TMP_LOGCAT_FILE` | `/var/tmp/logcat_943239.log`      | Temporary file to which logcat output is written during the build (random for each build) |\n| `JENKINS_ANDROID_HOME`    | `/home/jenkins/tools/android-sdk` | The path to the Android SDK being used for this build (optional)                          |\n| `ANDROID_HOME`            | `/home/jenkins/tools/android-sdk` | The path to the Android SDK being used for this build (optional)                          |\n\n### Using the emulator\n\nNow that you have an Android emulator running, you'll probably want to\ninstall one or more Android applications (APKs) and start running some\ntests.\n\nBasically, whenever you want to call `adb` as part of your build, just\ncall it as you normally would, e.g. `adb install my-app.apk`.\n\nIf you're using Android's default Ant build system, you should specify\nthe `sdk.dir` property, to tell Ant it can find the Android build\nscripts:  \nJust add \"`sdk.dir=$ANDROID_HOME`\" to the \"Properties\" field of your\n\"Invoke Ant\" build step.\n\nDocumentation for older plugin versions...\n\n#### Using version 1.18 or older...\n\nNormally, when running an Android application using Eclipse or the\ncommand line, either your APK is automatically installed (because there\nis only one emulator/device attached to your PC), or Eclipse allows you\nto choose from a list. Similarly, when building from the command line,\ninstallation is done with a command like:\n\"`adb -e install -r my-app.apk`\", where \"`-e`\" specifies the emulator\n(or \"`-d`\" a USB-attached device).\n\nHowever, as Jenkins may be running multiple Android-related builds at\nonce, with several emulators running in parallel, it's not possible to\nautomatically determine which emulator should be used. Nor can the user\nbe prompted at build time.\n\nSince version 1.15, the `ANDROID_SERIAL` environment variable has been\nautomatically set by the plugin. Because the `adb` tool automatically\nuses this variable to determine which Android device to communicate\nwith, you no longer need to pass in parameters like \"`-s`\" or \"`-e`\" to\n`adb`.\n\nFurthermore, since version 2.13, if the plugin detects (or automatically\ninstalls) your Android SDK, the SDK tools and platform tools directories\nwill be prepended to your `$PATH` during a build. This means you don't\nhave to supply the full path to tools like `adb` or `monkeyrunner`, even\nif those tools would not normally be on the `$PATH`.\n\n#### Using version 1.14 or older...\n\n##### Working with Android's default Ant build system\n\nThe default build system for Android is Apache Ant, which is well\nsupported by Jenkins.\n\nWhen calling targets like \"`ant install`\" or \"`ant run-tests`\", the\nAndroid build system allows you to use the `adb.device.arg` property to\nspecify where the application should be installed to.\n\nTo make use of this in an \"Invoke Ant\" build step, just add the\nfollowing to your Ant \"Properties\" section:  \n`adb.device.arg=\"-s $ANDROID_AVD_DEVICE\"`\n\n##### Using shell commands\n\nIf you aren't using Ant, but want Jenkins to run `adb` commands for you\nvia an \"Execute shell\" build step, the process is similar.\n\nTo install, use the `ANDROID_AVD_DEVICE` environment variable with the\n`-s` flag:  \n`adb -s $ANDROID_AVD_DEVICE install -r my-app.apk`\n\nThis would be automatically expanded by the shell to something like:  \n`adb -s localhost:34564 install -r my-app.apk`\n\nThe same principle applies for any other `adb` commands you wish to\nperform, for example to start running tests:  \n`adb -s $ANDROID_AVD_DEVICE shell am instrument -r -w com.example.tests/android.test.InstrumentationTestRunner | tee test-result.txt`\n\n#### Installing project prerequisites\n\nWhen compiling an Android project, you must have all the prerequisite\nAndroid platform images installed. For example, if you have an Android\napp which relies on an Android library project, plus you have a unit\ntest project — these may all be targeting different Android SDK\nversions, all of which must be present at compile time.\n\nNormally, with the (deprecated) Ant build system, these target versions\nare specified in either a \"`project.properties`\" or\n\"`default.properties`\" file.\n\nSince version 2.1, the plugin provides a \"**Install Android project\nprerequisites**\" build step for the Ant build system, which\nautomatically detects the target versions in the build workspace, then\nautomatically installs any of the corresponding Android platform images\nthat are not yet installed.\n\nThis build step requires no configuration — just add it before the build\nstep that compiles your Android projects.\n\nFor the Gradle build system, I would recommend including the [Android\nSDK Manager Gradle\nPlugin](https://github.com/JakeWharton/sdk-manager-plugin) in your\nproject. You may have to use [JitPack](https://jitpack.io/) to get the\nlatest version.\n\n#### Creating project build files\n\nIf you only build a project in Eclipse or using another IDE, you may not\nhave the required Ant build files created or checked into your\nrepository.\n\nSince version 2.8, the \"**Create Android build files**\" build step will\nautomatically find any Android app, library or test projects in a\nbuild's workspace and will create the build files for them, using the\nappropriate \"`android update project`\" command.\n\n#### Installing and uninstalling APKs\n\nSince version 1.9, the plugin can automatically install an APK on the\nstarted emulator for you.\n\nUnder the \"Build\" section of your job configuration, select \"Add build\nstep\" and choose \"**Install Android package**\".\n\n![](docs/images/android_install-package.png)\n\nIn the \"APK file\" field that appears, enter the filename of the APK you\nwish to install. When a build runs, the APK will be automatically\ninstalled after the emulator has started up.\n\nNote: It is also possible to use this build step without having started\nan emulator via this plugin — you can install an APK on an attached\ndevice or other emulator.\n\n#### Running the Android `monkey` tool\n\nThe plugin provides a Build Step called \"**Run Android monkey tester**\"\nwhich will run the\n[monkey](https://developer.android.com/guide/developing/tools/monkey.html)\nstress-testing tool against the given Android package.\n\nThe output is saved to a file — by default \"`monkey.txt`\" in the root of\nthe build workspace.  \nDon't forget to archive this file by using \"Archive the artifacts\"\noption under \"Post-build Actions\" if you want to keep the monkey output\nfor future reference!\n\n![](docs/images/android_monkey-run.png)\n\n#### Parsing `monkey` output\n\nAlso provided is a method of parsing the output of the monkey testing\ntool.\n\nUnder the \"Post-build Actions\" section, enable the \"**Publish Android\nmonkey tester result**\". No further configuration is required — by\ndefault the plugin will search for \"`monkey.txt`\" in the root of the\nbuild workspace, parse the file's contents and display the result on the\nbuild page.\n\nIf the monkey output reveals your Android application crashed or caused\nan \"Application Not Responding\" situation, the build will be marked as\nUNSTABLE.\n\n![](docs/images/android_monkey-publish.png)\n\nYou can, of course, specify a different filename (including the use of\nvariables) or change the \"Set build result\" option to mark the build as\na FAILURE rather than just UNSTABLE, or leave its status untouched in\ncase the monkey information does not indicate success.\n\n![](docs/images/android_monkey-result.png)\n\n![](docs/images/android_artifacts.png)\n\n### Artifacts\n\nOnce the emulator is ready for use, its log is captured until the build\nfinishes. This corresponds to the output of \"`adb logcat -v time`\", i.e.\nthe main log output including timestamps.  \nThis will be archived automatically as a build artifact, with the name\n`logcat.txt`.\n\n## Known issues\n\nView known issues...\n\n### Pipeline not yet supported\n\nThis plugin is currently still only compatible with Freestyle jobs\n— Pipeline support is planned!\n\n### Emulator v2\n\nThe new-and-improved emulator engine — first released as part of SDK\nTools 25 (and Android Studio 2.0) — is supported as of version 3.0 of\nthis plugin.\n\nHowever, the Quick Boot feature (formerly known as snapshots) is\ncurrently not supported, as the command line tools do not appear to\nsupport this.\n\n### Android SDK Tools\n\nDue to a regression in SDK Tools r12 and r13 (see [Android bug\n\\#18444](http://b.android.com/18444)), running any builds with the \"Use\nemulator snapshots\" option enabled (which is the default), would likely\nfail to load in the state you expect. For example the emulator may not\nbe ready for use, and the screen may not be unlocked.\n\nTo avoid this, either keep using r11 or earlier, or update to r14 or\nnewer. However, if you update, you will have to manually delete all\nexisting snapshot images and allow this plugin to re-create them.  \nSee the [Known Issues](http://tools.android.com/knownissues) page on the\nAndroid Tools site for more information.\n\nSimilarly, snapshot support does not fully function for Android 4.0\nuntil SDK Tools r15. An initial snapshot can be created, but\nsubsequently loading from that snapshot will crash the emulator\nimmediately. Earlier Android versions are not affected, i.e. you can\nstill use snapshots with Android 3.2 and earlier. Upgrading to SDK Tools\nr15+ should fix this.\n\nAs a workaround, you can also uncheck \"Use emulator snapshots\" in any\njobs where you are seeing problems.\n\n### Running in a Windows service as \"Local System\"\n\nNew AVDs cannot be generated and run if Jenkins is running as a Windows\nservice, using the \"Local System\" account (see\n[JENKINS-7355](https://issues.jenkins-ci.org/browse/JENKINS-7355)).\n\n-   Workaround: configure the Jenkins service to \"run as\" a real user\n\n### Emulator UI doesn't appear when running on Windows 7\n\nIf running Jenkins as a service on Windows 7 or newer, you may find that\nwhile the plugin can start an emulator, its user interface may not\nappear, even if configured to do so.  \nThis is due to something called Session 0 Isolation, which prevents\nservices from starting UIs for security reasons.\n\nIf you really need to see the emulator UI, you can either run Jenkins\nnot as a service, or add an agent node to Jenkins (e.g. launch agent via\nJNLP on the same machine) which will bypass this isolation.\n\n### Unexpected timeouts or hanging during build\n\nAVDs can, on occasion, time-out unexpectedly or stop responding during a\nbuild, e.g. when trying to install an APK (see\n[JENKINS-7354](https://issues.jenkins-ci.org/browse/JENKINS-7354)).\n\n-   This is generally caused by bugs in the ADB process. It can be prone\n    to hanging or crashing. Over time, more safeguards have been added\n    to the plugin, including timing-out after a while and isolating ADB\n    instances, so this shouldn't happen too often.\n\nThis should also be more stable with version 3.0 of this plugin, which\nallows the new emulator engine to be used.\n\n### AVDs may not shut down fully at the end of a build\n\nSometimes the `emulator` process does not shut down fully at the end of\na build (requiring a `kill -9` on Linux); the plugin sends a [console\ncommand to terminate the\nemulator](https://developer.android.com/guide/developing/devices/emulator.html#terminating)\nand the UI window closes, but the actual `emulator` process does not\ndie.\n\n-   This issue will be fixed once\n    [JENKINS-11995](https://issues.jenkins-ci.org/browse/JENKINS-11995)\n    is implemented.\n-   If your agent is running Linux, you may be running into [Android\n    issue \\#17294](http://b.android.com/17294)  \n    In this case, there is a workaround assuming your build doesn't need\n    to use the emulator's audio input:\n    -   Add a custom hardware property called \"`hw.audioInput`\" with the\n        value \"`no`\"\n\n## Potential upcoming features\n\n-   Support for the [Pipeline\n    Plugin](https://wiki.jenkins.io/display/JENKINS/Pipeline+Plugin) is\n    planned\n-   Within the 'android-emulator' component of Jenkins' issue tracker\n    you can:\n    -   [Add a new feature\n        request](https://issues.jenkins-ci.org/secure/CreateIssueDetails!init.jspa?Create=Create\u0026pid=10172\u0026priority=4\u0026assignee=-1\u0026components=15725\u0026issuetype=2)\n    -   [View existing\n        requests](https://issues.jenkins-ci.org/secure/IssueNavigator.jspa?reset=true\u0026jqlQuery=project+%3D+JENKINS+AND+issuetype+in+%28%22New+Feature%22%2C+Improvement%29+AND+component+%3D+android-emulator-plugin+AND+status+in+%28Open%2C+%22In+Progress%22%2C+Reopened%29)\n\n## Changelog\n\nPlease have a look at [CHANGELOG.md](CHANGELOG.md).\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fjenkinsci%2Fandroid-emulator-plugin","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fjenkinsci%2Fandroid-emulator-plugin","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fjenkinsci%2Fandroid-emulator-plugin/lists"}