4. Creating an Android Virtual Device (AVD) in Android Studio

In the course of developing Android apps in Android Studio it will be necessary to compile and run an application multiple times. An Android application may be tested by installing and running it either on a physical device or in an Android Virtual Device (AVD) emulator environment. Before an AVD can be used, it must first be created and configured to match the specifications of a particular device model. The goal of this chapter, therefore, is to work through the creation of such a virtual device using the Pixel 4 phone as a reference example.

4.1 About Android Virtual Devices

AVDs are essentially emulators that allow Android applications to be tested without the necessity to install the application on a physical Android based device. An AVD may be configured to emulate a variety of hardware features including options such as screen size, memory capacity and the presence or otherwise of features such as a camera, GPS navigation support or an accelerometer. As part of the standard Android Studio installation, a number of emulator templates are installed allowing AVDs to be configured for a range of different devices. Custom configurations may be created to match any physical Android device by specifying properties such as processor type, memory capacity and the size and pixel density of the screen.

An AVD session can appear either as separate a window or embedded within the Android Studio window. Figure 4-1, for example, shows an AVD session configured to emulate the Google Pixel 3 model.

New AVDs are created and managed using the Android Virtual Device Manager, which may be used either in command-line mode or with a more user-friendly graphical user interface.

Figure 4-1

4.2 Creating a New AVD

In order to test the behavior of an application in the absence of a physical device, it will be necessary to create an AVD for a specific Android device configuration.

To create a new AVD, the first step is to launch the AVD Manager. This can be achieved from within the Android Studio environment by selecting the Tools -> AVD Manager menu option from within the main window.

Once launched, the tool will appear as outlined in Figure 4-2 if no existing AVD instances have been created:

Figure 4-2

To add an additional AVD, begin by clicking on the Create Virtual Device button in order to invoke the Virtual Device Configuration dialog:

Figure 4-3

Within the dialog, perform the following steps to create a Pixel 4 compatible emulator:

1. From the Category panel, select the Phone option to display the list of available Android phone AVD templates.

2. Select the Pixel 4 device option and click Next.

3. On the System Image screen, select the latest version of Android for the x86 ABI. Note that if the system image has not yet been installed a Download link will be provided next to the Release Name. Click this link to download and install the system image before selecting it. If the image you need is not listed, click on the x86 images and Other images tabs to view alternative lists.

4. Click Next to proceed and enter a descriptive name (for example Pixel 4 API 30) into the name field or simply accept the default name.

5. Click Finish to create the AVD.

6. With the AVD created, the AVD Manager may now be closed. If future modifications to the AVD are necessary, simply re-open the AVD Manager, select the AVD from the list and click on the pencil icon in the Actions column of the device row in the AVD Manager.

4.3 Starting the Emulator

To perform a test run of the newly created AVD emulator, simply select the emulator from the AVD Manager and click on the launch button (the triangle in the Actions column). The emulator will appear in a new window and begin the startup process. The amount of time it takes for the emulator to start will depend on the configuration of both the AVD and the system on which it is running.

Although the emulator probably defaulted to appearing in portrait orientation, this and other default options can be changed. Within the AVD Manager, select the new Pixel 4 entry and click on the pencil icon in the Actions column of the device row. In the configuration screen locate the Startup orientation section and change the orientation setting. Exit and restart the emulator session to see this change take effect. More details on the emulator are covered in the next chapter (“Using and Configuring the Android Studio AVD Emulator”).

To save time in the next section of this chapter, leave the emulator running before proceeding.

4.4 Running the Application in the AVD

With an AVD emulator configured, the example AndroidSample application created in the earlier chapter now can be compiled and run. With the AndroidSample project loaded into Android Studio, make sure that the newly created Pixel 4 AVD is displayed in the device menu (marked A in Figure 4-4 below), then either click on the run button represented by a green triangle (B), select the Run -> Run ‘app’ menu option or use the Ctrl-R keyboard shortcut:

Figure 4-4

The device menu (A) may be used to select a different AVD instance or physical device as the run target, and also to run the app on multiple devices. The menu also provides access to the AVD Manager and device connection trouble shooting options:

Figure 4-5

Once the application is installed and running, the user interface for the first fragment will appear within the emulator (a fragment is a reusable section of an Android project typically consisting of a user interface layout and some code, a topic which will be covered later in the chapter entitled “An Introduction to Android Fragments”):

Figure 4-6

In the event that the activity does not automatically launch, check to see if the launch icon has appeared among the apps on the emulator. If it has, simply click on it to launch the application. Once the run process begins, the Run tool window will become available. The Run tool window will display diagnostic information as the application package is installed and launched. Figure 4-7 shows the Run tool window output from a successful application launch:

Figure 4-7

If problems are encountered during the launch process, the Run tool window will provide information that will hopefully help to isolate the cause of the problem.

Assuming that the application loads into the emulator and runs as expected, we have safely verified that the Android development environment is correctly installed and configured.

4.5 Running on Multiple Devices

The run menu shown in Figure 4-5 above includes an option to run the app on multiple emulators and devices in parallel. When selected, this option displays the dialog shown in Figure 4-8 providing a list of both the AVDs configured on the system and any attached physical devices. Enable the checkboxes next to the emulators or devices to be targeted before clicking on the Run button:

Figure 4-8

After the Run button is clicked, Android Studio will launch the app on the selected emulators and devices.

4.6 Stopping a Running Application

To stop a running application, simply click on the stop button located in the main toolbar as shown in Figure 4-9:

Figure 4-9

An app may also be terminated using the Run tool window. Begin by displaying the Run tool window using the window bar button that becomes available when the app is running. Once the Run tool window appears, click the stop button highlighted in Figure 4-10 below:

Figure 4-10

4.7 Supporting Dark Theme

Android 10 introduced the much awaited dark theme, support for which is not enabled by default in Android Studio app projects. To test dark theme in the AVD emulator, open the Settings app within the running Android instance in the emulator. There are a number of different ways to access the settings app. The quickest is to display the home screen and then click and drag upwards from the bottom of the screen (just below the search bar). This will display all of the apps installed on the device, one of which will be the Settings app.

Within the Settings app, choose the Display category and enable the Dark Theme option as shown in Figure 4-11 so that the screen background turns black:

Figure 4-11

With dark theme enabled, run the AndroidSample app and note that it appears using a dark theme including a black background and a purple background color on the button as shown in Figure 4-12:

Figure 4-12

The themes used by the light and dark modes are declared within the themes.xml files located in the Project tool window under app -> res -> values -> themes as shown in Figure 4-13:

Figure 4-13

The themes.xml file contains the theme for day mode while the themes.xml (night) file contains the theme adopted by the app when the device is placed into dark mode and reads as follows:

<resources xmlns:tools="http://schemas.android.com/tools">

    <!-- Base application theme. -->

    <style name="Theme.AndroidSample" parent="Theme.MaterialComponents.DayNight.DarkActionBar">

        <!-- Primary brand color. -->

        <item name="colorPrimary">@color/purple_200</item>

        <item name="colorPrimaryDark">@color/purple_700</item>

        <item name="colorOnPrimary">@color/black</item>

        <!-- Secondary brand color. -->

        <item name="colorSecondary">@color/teal_200</item>

        <item name="colorSecondaryVariant">@color/teal_200</item>

        <item name="colorOnSecondary">@color/black</item>

        <!-- Status bar color. -->

        <item name="android:statusBarColor" tools:targetApi="l">?attr/colorPrimaryVariant</item>

        <!-- Customize your theme here. -->



Experiment with color changes (for example try a different color for the colorPrimary resource) using the color squares in the editor gutter to make use of the color chooser. After making the changes, run the app again to view the changes.

After experimenting with the themes, open the Settings app within the emulator, turn off dark mode and return to the AndroidSample app. The app should have automatically switched back to light mode.

4.8 Running the Emulator in a Tool Window

So far in this chapter we have only used the emulator as a standalone window. The emulator may also be run as a tool window embedded within the main Android Studio window. To embed the emulator, select the File -> Settings... menu option (Android Studio -> Preferences... on macOS), navigate to Tools -> Emulator in the left-hand navigation panel of the preferences dialog, and enable the Launch in a tool window option:

Figure 4-14

With the option enabled, click the Apply button followed by OK to commit the change, then exit the standalone emulator session.

Run the sample app once again, at which point the emulator will appear within the Android Studio window as shown in Figure 4-15:

Figure 4-15

To hide and show the emulator tool window, click on the Emulator tool window button (marked A above). Click on the “x” close button next to the tab (B) to exit the emulator. The emulator tool window can accommodate multiple emulator sessions, with each session represented by a tab. Figure 4-16, for example shows a tool window with two emulator sessions:

Figure 4-16

To switch between sessions, simply click on the corresponding tab.

4.9 AVD Command-line Creation

As previously discussed, in addition to the graphical user interface it is also possible to create a new AVD directly from the command-line. This is achieved using the avdmanager tool in conjunction with some command-line options. Once initiated, the tool will prompt for additional information before creating the new AVD.

The avdmanager tool requires access to the Java Runtime Environment (JRE) in order to run. If, when attempting run avdmanager, an error message appears indicating that the ‘java’ command cannot be found, the command prompt or terminal window within which you are running the command can be configured to use the OpenJDK environment bundled with Android Studio. Begin by identifying the location of the OpenJDK JRE as follows:

1. Launch Android Studio and open the AndroidSample project created earlier in the book.

2. Select the File -> Project Structure... menu option.

3. Copy the path contained within the JDK location field of the Project Structure dialog. This represents the location of the JRE bundled with Android Studio.

On Windows, execute the following command within the command prompt window from which avdmanager is to be run (where <path to jre> is replaced by the path copied from the Project Structure dialog above):

set JAVA_HOME=<path to jre>

On macOS or Linux, execute the following command:

export JAVA_HOME="<path to jre>"

If you expect to use the avdmanager tool frequently, follow the environment variable steps for your operating system outlined in the chapter entitled “Setting up an Android Studio Development Environment” to configure JAVA_HOME on a system-wide basis.

Assuming that the system has been configured such that the Android SDK tools directory is included in the PATH environment variable, a list of available targets for the new AVD may be obtained by issuing the following command in a terminal or command window:

avdmanager list targets

The resulting output from the above command will contain a list of Android SDK versions that are available on the system. For example:

Available Android targets:


id: 1 or "android-29"

     Name: Android API 29

     Type: Platform

     API level: 29

     Revision: 1


id: 2 or "android-26"

     Name: Android API 26

     Type: Platform

     API level: 26

     Revision: 1

The avdmanager tool also allows new AVD instances to be created from the command line. For example, to create a new AVD named myAVD using the target ID for the Android API level 29 device using the x86 ABI, the following command may be used:

avdmanager create avd -n myAVD -k "system-images;android-29;google_apis_playstore;x86"

The android tool will create the new AVD to the specifications required for a basic Android 8 device, also providing the option to create a custom configuration to match the specification of a specific device if required. Once a new AVD has been created from the command line, it may not show up in the Android Device Manager tool until the Refresh button is clicked.

In addition to the creation of new AVDs, a number of other tasks may be performed from the command line. For example, a list of currently available AVDs may be obtained using the list avd command line arguments:

avdmanager list avd


Available Android Virtual Devices:

    Name: Pixel_XL_API_28_No_Play

  Device: pixel_xl (Google)

    Path: /Users/neilsmyth/.android/avd/Pixel_XL_API_28_No_Play.avd

  Target: Google APIs (Google Inc.)

          Based on: Android API 28 Tag/ABI: google_apis/x86

    Skin: pixel_xl_silver

  Sdcard: 512M

Similarly, to delete an existing AVD, simply use the delete option as follows:

avdmanager delete avd –n <avd name>

4.10 Android Virtual Device Configuration Files

By default, the files associated with an AVD are stored in the .android/avd sub-directory of the user’s home directory, the structure of which is as follows (where <avd name> is replaced by the name assigned to the AVD):

<avd name>.avd/config.ini

<avd name>.avd/userdata.img

<avd name>.ini

The config.ini file contains the device configuration settings such as display dimensions and memory specified during the AVD creation process. These settings may be changed directly within the configuration file and will be adopted by the AVD when it is next invoked.

The <avd name>.ini file contains a reference to the target Android SDK and the path to the AVD files. Note that a change to the image.sysdir value in the config.ini file will also need to be reflected in the target value of this file.

4.11 Moving and Renaming an Android Virtual Device

The current name or the location of the AVD files may be altered from the command line using the avdmanager tool’s move avd argument. For example, to rename an AVD named Nexus9 to Nexus9B, the following command may be executed:

avdmanager move avd -n Nexus9 -r Nexus9B

To physically relocate the files associated with the AVD, the following command syntax should be used:

avdmanager move avd -n <avd name> -p <path to new location>

For example, to move an AVD from its current file system location to /tmp/Nexus9Test:

avdmanager move avd -n Nexus9 -p /tmp/Nexus9Test

Note that the destination directory must not already exist prior to executing the command to move an AVD.

4.12 Summary

A typical application development process follows a cycle of coding, compiling and running in a test environment. Android applications may be tested on either a physical Android device or using an Android Virtual Device (AVD) emulator. AVDs are created and managed using the Android AVD Manager tool which may be used either as a command line tool or using a graphical user interface. When creating an AVD to simulate a specific Android device model it is important that the virtual device be configured with a hardware specification that matches that of the physical device.

The AVD emulator session may be displayed as a standalone window or embedded into the main Android Studio user interface.

..................Content has been hidden....................

You can't read the all page of ebook, please click here login for view all page.