How to Add your First Android Job to Jenkins

How to Add your First Android Job to Jenkins

New: We’ve just released a new ebook: the Jenkins Starter Guide, which contains all of the information in this series of four posts and more. Head on over to our Resources page to download.

In case you missed our first couple of posts in this series, or if you aren’t sure just what Jenkins or CI is, head back and read: What Is Jenkins and Why Should You Be Using It?

This is a step-by-step guide for how to set up Jenkins to build and test Android apps. In this demo we’ll use an example application using Bugfender SDK in Android. You’ll obviously want use your own built Android application or library. The steps for adding your own Android project to Jenkins will be the same.

Building iOS apps? Keep an eye out for the next article in this series coming soon.

First off, you’ll need to prepare the machine to compile and run Android applications. If you haven’t already installed Jenkins, you can follow the steps in the previous post to install Jenkins in your server.

Configuring Android App Builds in Jenkins

Step 1: Install Java JDK

sudo apt-get install java-8-openjdk

Step 2: Install Android SDK

Go to, and grab the link listed in the table for Get just the command line tools > Linux. Don’t download anything, just copy the link.

sudo apt-get install unzip

# here you paste the link you grabbed in the site

sudo -iu jenkins wget

sudo -iu jenkins mkdir android-sdk

sudo -iu jenkins unzip -d android-sdk

# this step is important to accept the Android SDK license

yes |sudo -iu jenkins android-sdk/tools/bin/sdkmanager --licenses

Step 3: Configure Jenkins

Then, log in to Jenkins and configure the Android SDK that you just installed:

Open on your browser. You’ll see something like this:

  • Go to Manage Jenkins > Configure System
  • Check “Environment variables”
  • Add Name: ANDROID_HOME
  • Add Value: /var/lib/jenkins/android-sdk
  • Click “Apply” then “Save”

Step 4: Create an Android Job

Now go back to the home page. Click on New Item. Enter your project name and select “Freestyle project.”

Step 5: Downloading Your Code to Jenkins

Next, you need to add a link to your repository so that Jenkins can download your code. Specify the Git URL of your repository in the Source Code Management section. As mentioned, we’re going to use this sample repository:

If you have a Mercurial or Subversion repository, they work the exact same way. If you have a private repository, you can also create SSH keys to access your repository with the git protocol.

Step 6: Configuring Jenkins Build Triggers

You can also specify Build Triggers that will build the project automatically for you. It is best to use a hook in order to trigger builds automatically when someone pushes code to the repository.

For BitBucket, Gitlab and most Git providers, you can use “Trigger builds remotely” option. This will give a URL that you can configure as a webhook in your provider to automatically start a build.

For GitHub users, the easiest is to find and install the “GitHub plugin” (in Manage Jenkins > Manage Plugins) and a GitHub specific option will appear. This will install the webhook for you.

Step 7: Build

Once you have the source code in Jenkins, it’s time to build. If your project has a Gradle wrapper, that’s what you should use. In our case, we’ll create an Invoke Gradle script build step like this:

If you have an Ant-based project, there is also an Invoke Ant build step or for maximum flexibility you can use the Execute shell build step.

Test your build by pressing “Save”

And that’s it. Your first Android project has been added to Jenkins. Now you may want to consider accelerating Gradle and setting up automated testing in Jenkins.

Start Fixing Bugs Faster Now for Free

Bugfender is the best remote logger for mobile apps.

Sign Up

Accelerate Gradle (optional)

If you’re running builds based on Gradle, you can save some build time by running Gradle as daemon. In order to get it running do the following:

mkdir -p /var/lib/jenkins/.gradle

echo org.gradle.daemon=true | sudo -iu jenkins tee -a /var/lib/jenkins/.gradle/

Running Unit Tests

If you want to run unit tests, you can do so by adding another build step with the test Gradle task, like this:

Running Integration Tests

In order to set up UI tests, you will need to run an emulator. Even though Jenkins has an Android Emulator Plugin, we have found that it has not been updated and is no longer working with the latest versions of the Android SDK. Here is our suggested workaround:

Step 1: Download the emulator. In order to list the SDKs available, run:

sudo -iu jenkins android-sdk/tools/bin/sdkmanager --list --verbose

Quick note on selecting the right image for you: x86 based images run faster but also need hardware acceleration. You might have to enable KVM acceleration (sudo modprobe kvm) in your server and your server can not be a virtual machine. For this reason we’re choosing an ARM image, which runs slower but works.

Step 2: In our case, we’re looking to run our application on Android SDK level 25, so system-images;android-25;google_apis;armeabi-v7a seems suitable, then we install it this way:

sudo -iu jenkins android-sdk/tools/bin/sdkmanager 'system-images;android-25;google_apis;armeabi-v7a'

Step 3: Once installed, we create an Android Virtual Device (an emulator instance) with it:

echo no | $ANDROID_SDK_ROOT/tools/bin/avdmanager -v create avd --force --package 'system-images;android-25;google_apis;armeabi-v7a' --name Android25 --tag google_apis --abi armeabi-v7a

Step 4: Then we use Supervisord to run the Android emulator as a system service, always in the background. In order to install it:

sudo apt-get install supervisor

Then, create a configuration file in /etc/supervisor/conf.d/emulator.conf:


command=/var/lib/jenkins/android-sdk/emulator/emulator -avd Android25 -no-window -noaudio -no-boot-anim -accel on -ports 5556,5557




Step 5: Once this is done, restart supervisord to apply the changes:

sudo service supervisor restart

The emulator should start in the background. It might take 1-2 minutes. You will see the emulator device appear in the devices list when it’s ready:

sudo -iu jenkins android-sdk/platform-tools/adb devices

Step 6: In the Jenkins job, add an Execute shell build step like this:



# wait for emulator to be up and fully booted, unlock screen

$ANDROID_HOME/platform-tools/adb wait-for-device shell 'while [[ -z $(getprop sys.boot_completed) ]]; do sleep 1; done; input keyevent 82'

./gradlew connectedAndroidTest

Next Steps

There are more options like running an Android emulator, installing the application, and running various tests on it.

In addition, there are some really interesting plugins that you can play with:

For more posts in this series, check out:

Or for our complete ebook on Jenkins, head over to our Resources page.

This post was co-authored by Sarabeth Flowers Lewis.

as_tesco Created with Sketch. as_slack Created with Sketch. as_eye-d Created with Sketch. as_websummit Created with Sketch. as_starbucks Created with Sketch. as_napster Created with Sketch. as_safedome Created with Sketch.

Already Trusted by Thousands

Bugfender is the best remote logger for mobile apps.

Get Started for Free, No Credit Card Required