docs/start/android-app.mdx - bazel - Git at Google


            
            ---

            
            title: 'Bazel Tutorial: Build an Android App'

            
            ---


            **Note:** There are known limitations on using Bazel for building Android apps.

            
            Visit the [rules_android issues page](https://github.com/bazelbuild/rules_android/issues)

            
            to see the list of known issues. While the Bazel team and Open Source Software

            
            (OSS) contributors work actively to address known issues, users should be aware

            
            that Android Studio does not officially support Bazel projects.


            This tutorial covers how to build a simple Android app using Bazel.


            Bazel supports building Android apps using the

            
            [Android rules](/reference/be/android).


            This tutorial is intended for Windows, macOS and Linux users and does not

            
            require experience with Bazel or Android app development. You do not need to

            
            write any Android code in this tutorial.


            ## What you'll learn


            In this tutorial you learn how to:


            *   Set up your environment by installing Bazel and Android Studio, and

            
                downloading the sample project.

            
            *   Set up a Bazel workspace that contains the source code

            
                for the app and a `MODULE.bazel` file that identifies the top level of the

            
                workspace directory.

            
            *   Update the `MODULE.bazel` file to contain references to the required

            
                external dependencies, like the Android SDK.

            
            *   Create a `BUILD` file.

            
            *   Build the app with Bazel.

            
            *   Deploy and run the app on an Android emulator or physical device.


            ## Before you begin


            ### Install Bazel


            Before you begin the tutorial, install the following software:


            * **Bazel.** To install, follow the [installation instructions](/install).

            
            * **Android Studio.** To install, follow the steps to [download Android Studio](https://developer.android.com/sdk/index.html).

            
              Execute the setup wizard to download the SDK and configure your environment.

            
            * (Optional) **Git.** Use `git` to download the Android app project.


            ### Get the sample project


            For the sample project, use the tutorial Android app project in

            
            [Bazel's examples repository](https://github.com/bazelbuild/examples/tree/main/android/tutorial).


            This app has a single button that prints a greeting when clicked:


            ![Button greeting](/docs/images/android_tutorial_app.png "Tutorial app button greeting")


            **Figure 1.** Android app button greeting.


            Clone the repository with `git` (or [download the ZIP file directly](https://github.com/bazelbuild/examples/archive/master.zip)):


            ```posix-terminal

            
            git clone https://github.com/bazelbuild/examples

            
            ```


            The sample project for this tutorial is in `examples/android/tutorial`. For

            
            the rest of the tutorial, you will be executing commands in this directory.


            ### Review the source files


            Take a look at the source files for the app.


            ```

            
            .

            
            ├── README.md

            
            └── src

            
                └── main

            
                    ├── AndroidManifest.xml

            
                    └── java

            
                        └── com

            
                            └── example

            
                                └── bazel

            
                                    ├── AndroidManifest.xml

            
                                    ├── Greeter.java

            
                                    ├── MainActivity.java

            
                                    └── res

            
                                        ├── layout

            
                                        │   └── activity_main.xml

            
                                        └── values

            
                                            ├── colors.xml

            
                                            └── strings.xml

            
            ```


            The key files and directories are:


            | Name                    | Location                                                                                 |

            
            | ----------------------- | ---------------------------------------------------------------------------------------- |

            
            | Android manifest files  | `src/main/AndroidManifest.xml` and `src/main/java/com/example/bazel/AndroidManifest.xml` |

            
            | Android source files    | `src/main/java/com/example/bazel/MainActivity.java` and `Greeter.java`                   |

            
            | Resource file directory | `src/main/java/com/example/bazel/res/`                                                   |


            ## Build with Bazel


            ### Set up the workspace


            A [workspace](/concepts/build-ref#workspace) is a directory that contains the

            
            source files for one or more software projects, and has a `MODULE.bazel` file at

            
            its root.


            The `MODULE.bazel` file may be empty or may contain references to [external dependencies](/external/overview) required to build your project.


            First, run the following command to create an empty `MODULE.bazel` file:


            |          OS              |              Command                |

            
            | ------------------------ | ----------------------------------- |

            
            | Linux, macOS             | `touch MODULE.bazel`                   |

            
            | Windows (Command Prompt) | `type nul > MODULE.bazel`              |

            
            | Windows (PowerShell)     | `New-Item MODULE.bazel -ItemType file` |


            ### Running Bazel


            You can now check if Bazel is running correctly with the command:


            ```posix-terminal

            
            bazel info workspace

            
            ```


            If Bazel prints the path of the current directory, you're good to go! If the

            
            `MODULE.bazel` file does not exist, you may see an error message like:


            ```

            
            ERROR: The 'info' command is only supported from within a workspace.

            
            ```


            ### Integrate with the Android SDK


            Bazel needs to run the Android SDK

            
            [build tools](https://developer.android.com/tools/revisions/build-tools.html)

            
            to build the app. This means that you need to add some information to your

            
            `MODULE.bazel` file so that Bazel knows where to find them.


            Add the following line to your `MODULE.bazel` file:


            ```python

            
            bazel_dep(name = "rules_android", version = "0.6.6")


            remote_android_extensions = use_extension(

            
                "@rules_android//bzlmod_extensions:android_extensions.bzl",

            
                "remote_android_tools_extensions")

            
            use_repo(remote_android_extensions, "android_tools")


            android_sdk_repository_extension = use_extension("@rules_android//rules/android_sdk_repository:rule.bzl", "android_sdk_repository_extension")

            
            use_repo(android_sdk_repository_extension, "androidsdk")

            
            ```


            This will use the Android SDK at the path referenced by the `ANDROID_HOME`

            
            environment variable, and automatically detect the highest API level and the

            
            latest version of build tools installed within that location.


            You can set the `ANDROID_HOME` variable to the location of the Android SDK. Find

            
            the path to the installed SDK using Android Studio's [SDK Manager](https://developer.android.com/studio/intro/update#sdk-manager).

            
            Assuming the SDK is installed to default locations, you can use the following

            
            commands to set the `ANDROID_HOME` variable:


            |          OS              |               Command                               |

            
            | ------------------------ | --------------------------------------------------- |

            
            | Linux                    | `export ANDROID_HOME=$HOME/Android/Sdk/`            |

            
            | macOS                    | `export ANDROID_HOME=$HOME/Library/Android/sdk`     |

            
            | Windows (Command Prompt) | `set ANDROID_HOME=%LOCALAPPDATA%\Android\Sdk`       |

            
            | Windows (PowerShell)     | `$env:ANDROID_HOME="$env:LOCALAPPDATA\Android\Sdk"` |


            The above commands set the variable only for the current shell session. To make

            
            them permanent, run the following commands:


            |          OS              |               Command                               |

            
            | ------------------------ | --------------------------------------------------- |

            
            | Linux                    | `echo "export ANDROID_HOME=$HOME/Android/Sdk/" >> ~/.bashrc`                                                                              |

            
            | macOS                    | `echo "export ANDROID_HOME=$HOME/Library/Android/Sdk/" >> ~/.bashrc`                                                                              |

            
            | Windows (Command Prompt) | `setx ANDROID_HOME "%LOCALAPPDATA%\Android\Sdk"`                                                                                          |

            
            | Windows (PowerShell)     | `[System.Environment]::SetEnvironmentVariable('ANDROID_HOME', "$env:LOCALAPPDATA\Android\Sdk", [System.EnvironmentVariableTarget]::User)` |


            **Optional:** If you want to compile native code into your Android app, you

            
            also need to download the [Android NDK](https://developer.android.com/ndk/downloads/index.html)

            
            and use `rules_android_ndk` by adding the following line to your `MODULE.bazel` file:


            ```python

            
            bazel_dep(name = "rules_android_ndk", version = "0.1.3")

            
            ```


            For more information, read [Using the Android Native Development Kit with Bazel](/docs/android-ndk).


            It's not necessary to set the API levels to the same value for the SDK and NDK.

            
            [This page](https://developer.android.com/ndk/guides/stable_apis.html)

            
            contains a map from Android releases to NDK-supported API levels.


            ### Create a BUILD file


            A [`BUILD` file](/concepts/build-files) describes the relationship

            
            between a set of build outputs, like compiled Android resources from `aapt` or

            
            class files from `javac`, and their dependencies. These dependencies may be

            
            source files (Java, C++) in your workspace or other build outputs. `BUILD` files

            
            are written in a language called **Starlark**.


            `BUILD` files are part of a concept in Bazel known as the *package hierarchy*.

            
            The package hierarchy is a logical structure that overlays the directory

            
            structure in your workspace. Each [package](/concepts/build-ref#packages) is a

            
            directory (and its subdirectories) that contains a related set of source files

            
            and a `BUILD` file. The package also includes any subdirectories, excluding

            
            those that contain their own `BUILD` file. The *package name* is the path to the

            
            `BUILD` file relative to the `MODULE.bazel` file.


            Note that Bazel's package hierarchy is conceptually different from the Java

            
            package hierarchy of your Android App directory where the `BUILD` file is

            
            located, although the directories may be organized identically.


            For the simple Android app in this tutorial, the source files in `src/main/`

            
            comprise a single Bazel package. A more complex project may have many nested

            
            packages.


            #### Add an android_library rule


            A `BUILD` file contains several different types of declarations for Bazel. The

            
            most important type is the

            
            [build rule](/concepts/build-files#types-of-build-rules), which tells

            
            Bazel how to build an intermediate or final software output from a set of source

            
            files or other dependencies. Bazel provides two build rules,

            
            [`android_library`](/reference/be/android#android_library) and

            
            [`android_binary`](/reference/be/android#android_binary), that you can use to

            
            build an Android app.


            For this tutorial, you'll first use the

            
            `android_library` rule to tell Bazel to build an [Android library module](http://developer.android.com/tools/projects/index.html#LibraryProjects)

            
            from the app source code and resource files. You'll then use the

            
            `android_binary` rule to tell Bazel how to build the Android application package.


            Create a new `BUILD` file in the `src/main/java/com/example/bazel` directory,

            
            and declare a new `android_library` target:


            `src/main/java/com/example/bazel/BUILD`:


            ```python

            
            load("@rules_android//rules:rules.bzl", "android_library")


            package(

            
                default_visibility = ["//src:__subpackages__"],

            
            )


            android_library(

            
                name = "greeter_activity",

            
                srcs = [

            
                    "Greeter.java",

            
                    "MainActivity.java",

            
                ],

            
                manifest = "AndroidManifest.xml",

            
                resource_files = glob(["res/**"]),

            
            )

            
            ```


            The `android_library` build rule contains a set of attributes that specify the

            
            information that Bazel needs to build a library module from the source files.

            
            Note also that the name of the rule is `greeter_activity`. You'll reference the

            
            rule using this name as a dependency in the `android_binary` rule.


            #### Add an android_binary rule


            The [`android_binary`](/reference/be/android#android_binary) rule builds

            
            the Android application package (`.apk` file) for your app.


            Create a new `BUILD` file in the `src/main/` directory,

            
            and declare a new `android_binary` target:


            `src/main/BUILD`:


            ```python

            
            load("@rules_android//rules:rules.bzl", "android_binary")


            android_binary(

            
                name = "app",

            
                manifest = "//src/main/java/com/example/bazel:AndroidManifest.xml",

            
                deps = ["//src/main/java/com/example/bazel:greeter_activity"],

            
            )

            
            ```


            Here, the `deps` attribute references the output of the `greeter_activity` rule

            
            you added to the `BUILD` file above. This means that when Bazel builds the

            
            output of this rule it checks first to see if the output of the

            
            `greeter_activity` library rule has been built and is up-to-date. If not, Bazel

            
            builds it and then uses that output to build the application package file.


            Now, save and close the file.


            ### Build the app


            Try building the app! Run the following command to build the

            
            `android_binary` target:


            ```posix-terminal

            
            bazel build //src/main:app

            
            ```


            The [`build`](/docs/user-manual#build) subcommand instructs Bazel to build the

            
            target that follows. The target is specified as the name of a build rule inside

            
            a `BUILD` file, with along with the package path relative to your workspace

            
            directory. For this example, the target is `app` and the package path is

            
            `//src/main/`.


            Note that you can sometimes omit the package path or target name, depending on

            
            your current working directory at the command line and the name of the target.

            
            For more details about target labels and paths, see [Labels](/concepts/labels).


            Bazel will start to build the sample app. During the build process, its output

            
            will appear similar to the following:


            ```bash

            
            INFO: Analysed target //src/main:app (0 packages loaded, 0 targets configured).

            
            INFO: Found 1 target...

            
            Target //src/main:app up-to-date:

            
              bazel-bin/src/main/app_deploy.jar

            
              bazel-bin/src/main/app_unsigned.apk

            
              bazel-bin/src/main/app.apk

            
            ```


            #### Locate the build outputs


            Bazel puts the outputs of both intermediate and final build operations in a set

            
            of per-user, per-workspace output directories. These directories are symlinked

            
            from the following locations at the top-level of the project directory, where

            
            the `MODULE.bazel` file is:


            * `bazel-bin` stores binary executables and other runnable build outputs

            
            * `bazel-genfiles` stores intermediary source files that are generated by

            
               Bazel rules

            
            * `bazel-out` stores other types of build outputs


            Bazel stores the Android `.apk` file generated using the `android_binary` rule

            
            in the `bazel-bin/src/main` directory, where the subdirectory name `src/main` is

            
            derived from the name of the Bazel package.


            At a command prompt, list the contents of this directory and find the `app.apk`

            
            file:


            |          OS              |          Command         |

            
            | ------------------------ | ------------------------ |

            
            | Linux, macOS             | `ls bazel-bin/src/main`  |

            
            | Windows (Command Prompt) | `dir bazel-bin\src\main` |

            
            | Windows (PowerShell)     | `ls bazel-bin\src\main`  |


            ### Run the app


            You can now deploy the app to a connected Android device or emulator from the

            
            command line using `bazel mobile-install`.

            
            This command uses the Android Debug Bridge (`adb`) to communicate with the

            
            device. You must set up your device to use `adb` following the instructions in

            
            [Android Debug Bridge](http://developer.android.com/tools/help/adb.html)

            
            before deployment. You can also choose to install the app on the Android emulator

            
            included in Android Studio. Make sure the emulator is running before executing

            
            the command below.


            Enter the following:


            ```posix-terminal

            
            bazel mobile-install //src/main:app \

            
              --mode=skylark \

            
              --mobile_install_aspect=@rules_android//mobile_install:mi.bzl \

            
              --mobile_install_supported_rules=android_binary \

            
              --java_runtime_version=17 \

            
              --java_language_version=17 \

            
              --tool_java_runtime_version=17 \

            
              --tool_java_language_version=17

            
            ```


            Note that the extra flags required for mobile-install can be added to your

            
            project's [bazelrc file](/run/bazelrc). The mobile-install-specific flags

            
            (`--mode`, `--mobile_install*`) will no longer be required starting from

            
            Bazel 8.4.0 and onwards. The various Java flags for language and runtime version

            
            may be required depending on your workspace's Java configuration.

            
            _Mobile-install sub-tools require a language and runtime level of 17 or higher._


            Now the "Bazel Tutorial App" should install and launch automatically:


            ![Bazel tutorial app](/docs/images/android_tutorial_before.png "Bazel tutorial app")


            **Figure 2.** Bazel tutorial app.


            **Congratulations! You have just installed your first Bazel-built Android app.**


            ## Further reading


            For more details, see these pages:


            * Open issues on [rules_android GitHub](https://github.com/bazelbuild/rules_android/issues)

            
            * More information on [mobile-install](/docs/mobile-install)

            
            * Shrink and optimize your app with [R8](https://github.com/bazelbuild/rules_android/tree/main/docs/r8-optimization.md)

            
            * Integrate external dependencies like AppCompat, Guava and JUnit from Maven

            
              repositories using [rules_jvm_external](https://github.com/bazelbuild/rules_jvm_external)

            
            * Run Robolectric tests with the [robolectric-bazel](https://github.com/robolectric/robolectric-bazel)

            
              integration.

            
            * Integrating C and C++ code into your Android app with the [NDK](/docs/android-ndk)

            
            * See more Bazel example projects of:

            
              * [a Kotlin app](https://github.com/bazelbuild/rules_jvm_external/tree/master/examples/android_kotlin_app)

            
              * [Robolectric testing](https://github.com/bazelbuild/rules_jvm_external/tree/master/examples/android_local_test)

            
              * [Espresso testing](https://github.com/bazelbuild/rules_jvm_external/tree/master/examples/android_instrumentation_test)


            Happy building!
	---
	title: 'Bazel Tutorial: Build an Android App'
	---


	Note: There are known limitations on using Bazel for building Android apps.
	Visit the [rules_android issues page](https://github.com/bazelbuild/rules_android/issues)
	to see the list of known issues. While the Bazel team and Open Source Software
	(OSS) contributors work actively to address known issues, users should be aware
	that Android Studio does not officially support Bazel projects.

	This tutorial covers how to build a simple Android app using Bazel.

	Bazel supports building Android apps using the
	[Android rules](/reference/be/android).

	This tutorial is intended for Windows, macOS and Linux users and does not
	require experience with Bazel or Android app development. You do not need to
	write any Android code in this tutorial.

	## What you'll learn

	In this tutorial you learn how to:

	* Set up your environment by installing Bazel and Android Studio, and
	downloading the sample project.
	* Set up a Bazel workspace that contains the source code
	for the app and a `MODULE.bazel` file that identifies the top level of the
	workspace directory.
	* Update the `MODULE.bazel` file to contain references to the required
	external dependencies, like the Android SDK.
	* Create a `BUILD` file.
	* Build the app with Bazel.
	* Deploy and run the app on an Android emulator or physical device.

	## Before you begin

	### Install Bazel

	Before you begin the tutorial, install the following software:

	* Bazel. To install, follow the [installation instructions](/install).
	* Android Studio. To install, follow the steps to [download Android Studio](https://developer.android.com/sdk/index.html).
	Execute the setup wizard to download the SDK and configure your environment.
	* (Optional) Git. Use `git` to download the Android app project.

	### Get the sample project

	For the sample project, use the tutorial Android app project in
	[Bazel's examples repository](https://github.com/bazelbuild/examples/tree/main/android/tutorial).

	This app has a single button that prints a greeting when clicked:

	![Button greeting](/docs/images/android_tutorial_app.png "Tutorial app button greeting")

	Figure 1. Android app button greeting.

	Clone the repository with `git` (or [download the ZIP file directly](https://github.com/bazelbuild/examples/archive/master.zip)):

	```posix-terminal
	git clone https://github.com/bazelbuild/examples
	```

	The sample project for this tutorial is in `examples/android/tutorial`. For
	the rest of the tutorial, you will be executing commands in this directory.

	### Review the source files

	Take a look at the source files for the app.

	```
	.
	├── README.md
	└── src
	└── main
	├── AndroidManifest.xml
	└── java
	└── com
	└── example
	└── bazel
	├── AndroidManifest.xml
	├── Greeter.java
	├── MainActivity.java
	└── res
	├── layout
	│ └── activity_main.xml
	└── values
	├── colors.xml
	└── strings.xml
	```

	The key files and directories are:

	\| Name \| Location \|
	\| ----------------------- \| ---------------------------------------------------------------------------------------- \|
	\| Android manifest files \| `src/main/AndroidManifest.xml` and `src/main/java/com/example/bazel/AndroidManifest.xml` \|
	\| Android source files \| `src/main/java/com/example/bazel/MainActivity.java` and `Greeter.java` \|
	\| Resource file directory \| `src/main/java/com/example/bazel/res/` \|


	## Build with Bazel

	### Set up the workspace

	A [workspace](/concepts/build-ref#workspace) is a directory that contains the
	source files for one or more software projects, and has a `MODULE.bazel` file at
	its root.

	The `MODULE.bazel` file may be empty or may contain references to [external dependencies](/external/overview) required to build your project.

	First, run the following command to create an empty `MODULE.bazel` file:

	\| OS \| Command \|
	\| ------------------------ \| ----------------------------------- \|
	\| Linux, macOS \| `touch MODULE.bazel` \|
	\| Windows (Command Prompt) \| `type nul > MODULE.bazel` \|
	\| Windows (PowerShell) \| `New-Item MODULE.bazel -ItemType file` \|

	### Running Bazel

	You can now check if Bazel is running correctly with the command:

	```posix-terminal
	bazel info workspace
	```

	If Bazel prints the path of the current directory, you're good to go! If the
	`MODULE.bazel` file does not exist, you may see an error message like:

	```
	ERROR: The 'info' command is only supported from within a workspace.
	```

	### Integrate with the Android SDK

	Bazel needs to run the Android SDK
	[build tools](https://developer.android.com/tools/revisions/build-tools.html)
	to build the app. This means that you need to add some information to your
	`MODULE.bazel` file so that Bazel knows where to find them.

	Add the following line to your `MODULE.bazel` file:

	```python
	bazel_dep(name = "rules_android", version = "0.6.6")

	remote_android_extensions = use_extension(
	"@rules_android//bzlmod_extensions:android_extensions.bzl",
	"remote_android_tools_extensions")
	use_repo(remote_android_extensions, "android_tools")

	android_sdk_repository_extension = use_extension("@rules_android//rules/android_sdk_repository:rule.bzl", "android_sdk_repository_extension")
	use_repo(android_sdk_repository_extension, "androidsdk")
	```

	This will use the Android SDK at the path referenced by the `ANDROID_HOME`
	environment variable, and automatically detect the highest API level and the
	latest version of build tools installed within that location.

	You can set the `ANDROID_HOME` variable to the location of the Android SDK. Find
	the path to the installed SDK using Android Studio's [SDK Manager](https://developer.android.com/studio/intro/update#sdk-manager).
	Assuming the SDK is installed to default locations, you can use the following
	commands to set the `ANDROID_HOME` variable:

	\| OS \| Command \|
	\| ------------------------ \| --------------------------------------------------- \|
	\| Linux \| `export ANDROID_HOME=$HOME/Android/Sdk/` \|
	\| macOS \| `export ANDROID_HOME=$HOME/Library/Android/sdk` \|
	\| Windows (Command Prompt) \| `set ANDROID_HOME=%LOCALAPPDATA%\Android\Sdk` \|
	\| Windows (PowerShell) \| `$env:ANDROID_HOME="$env:LOCALAPPDATA\Android\Sdk"` \|

	The above commands set the variable only for the current shell session. To make
	them permanent, run the following commands:

	\| OS \| Command \|
	\| ------------------------ \| --------------------------------------------------- \|
	\| Linux \| `echo "export ANDROID_HOME=$HOME/Android/Sdk/" >> ~/.bashrc` \|
	\| macOS \| `echo "export ANDROID_HOME=$HOME/Library/Android/Sdk/" >> ~/.bashrc` \|
	\| Windows (Command Prompt) \| `setx ANDROID_HOME "%LOCALAPPDATA%\Android\Sdk"` \|
	\| Windows (PowerShell) \| `[System.Environment]::SetEnvironmentVariable('ANDROID_HOME', "$env:LOCALAPPDATA\Android\Sdk", [System.EnvironmentVariableTarget]::User)` \|


	Optional: If you want to compile native code into your Android app, you
	also need to download the [Android NDK](https://developer.android.com/ndk/downloads/index.html)
	and use `rules_android_ndk` by adding the following line to your `MODULE.bazel` file:

	```python
	bazel_dep(name = "rules_android_ndk", version = "0.1.3")
	```


	For more information, read [Using the Android Native Development Kit with Bazel](/docs/android-ndk).

	It's not necessary to set the API levels to the same value for the SDK and NDK.
	[This page](https://developer.android.com/ndk/guides/stable_apis.html)
	contains a map from Android releases to NDK-supported API levels.

	### Create a BUILD file

	A [`BUILD` file](/concepts/build-files) describes the relationship
	between a set of build outputs, like compiled Android resources from `aapt` or
	class files from `javac`, and their dependencies. These dependencies may be
	source files (Java, C++) in your workspace or other build outputs. `BUILD` files
	are written in a language called Starlark.

	`BUILD` files are part of a concept in Bazel known as the package hierarchy.
	The package hierarchy is a logical structure that overlays the directory
	structure in your workspace. Each [package](/concepts/build-ref#packages) is a
	directory (and its subdirectories) that contains a related set of source files
	and a `BUILD` file. The package also includes any subdirectories, excluding
	those that contain their own `BUILD` file. The package name is the path to the
	`BUILD` file relative to the `MODULE.bazel` file.

	Note that Bazel's package hierarchy is conceptually different from the Java
	package hierarchy of your Android App directory where the `BUILD` file is
	located, although the directories may be organized identically.

	For the simple Android app in this tutorial, the source files in `src/main/`
	comprise a single Bazel package. A more complex project may have many nested
	packages.

	#### Add an android_library rule

	A `BUILD` file contains several different types of declarations for Bazel. The
	most important type is the
	[build rule](/concepts/build-files#types-of-build-rules), which tells
	Bazel how to build an intermediate or final software output from a set of source
	files or other dependencies. Bazel provides two build rules,
	[`android_library`](/reference/be/android#android_library) and
	[`android_binary`](/reference/be/android#android_binary), that you can use to
	build an Android app.

	For this tutorial, you'll first use the
	`android_library` rule to tell Bazel to build an [Android library module](http://developer.android.com/tools/projects/index.html#LibraryProjects)
	from the app source code and resource files. You'll then use the
	`android_binary` rule to tell Bazel how to build the Android application package.

	Create a new `BUILD` file in the `src/main/java/com/example/bazel` directory,
	and declare a new `android_library` target:

	`src/main/java/com/example/bazel/BUILD`:

	```python
	load("@rules_android//rules:rules.bzl", "android_library")

	package(
	default_visibility = ["//src:__subpackages__"],
	)

	android_library(
	name = "greeter_activity",
	srcs = [
	"Greeter.java",
	"MainActivity.java",
	],
	manifest = "AndroidManifest.xml",
	resource_files = glob(["res/**"]),
	)
	```

	The `android_library` build rule contains a set of attributes that specify the
	information that Bazel needs to build a library module from the source files.
	Note also that the name of the rule is `greeter_activity`. You'll reference the
	rule using this name as a dependency in the `android_binary` rule.

	#### Add an android_binary rule

	The [`android_binary`](/reference/be/android#android_binary) rule builds
	the Android application package (`.apk` file) for your app.

	Create a new `BUILD` file in the `src/main/` directory,
	and declare a new `android_binary` target:

	`src/main/BUILD`:

	```python
	load("@rules_android//rules:rules.bzl", "android_binary")

	android_binary(
	name = "app",
	manifest = "//src/main/java/com/example/bazel:AndroidManifest.xml",
	deps = ["//src/main/java/com/example/bazel:greeter_activity"],
	)
	```

	Here, the `deps` attribute references the output of the `greeter_activity` rule
	you added to the `BUILD` file above. This means that when Bazel builds the
	output of this rule it checks first to see if the output of the
	`greeter_activity` library rule has been built and is up-to-date. If not, Bazel
	builds it and then uses that output to build the application package file.

	Now, save and close the file.

	### Build the app

	Try building the app! Run the following command to build the
	`android_binary` target:

	```posix-terminal
	bazel build //src/main:app
	```

	The [`build`](/docs/user-manual#build) subcommand instructs Bazel to build the
	target that follows. The target is specified as the name of a build rule inside
	a `BUILD` file, with along with the package path relative to your workspace
	directory. For this example, the target is `app` and the package path is
	`//src/main/`.

	Note that you can sometimes omit the package path or target name, depending on
	your current working directory at the command line and the name of the target.
	For more details about target labels and paths, see [Labels](/concepts/labels).

	Bazel will start to build the sample app. During the build process, its output
	will appear similar to the following:

	```bash
	INFO: Analysed target //src/main:app (0 packages loaded, 0 targets configured).
	INFO: Found 1 target...
	Target //src/main:app up-to-date:
	bazel-bin/src/main/app_deploy.jar
	bazel-bin/src/main/app_unsigned.apk
	bazel-bin/src/main/app.apk
	```

	#### Locate the build outputs

	Bazel puts the outputs of both intermediate and final build operations in a set
	of per-user, per-workspace output directories. These directories are symlinked
	from the following locations at the top-level of the project directory, where
	the `MODULE.bazel` file is:

	* `bazel-bin` stores binary executables and other runnable build outputs
	* `bazel-genfiles` stores intermediary source files that are generated by
	Bazel rules
	* `bazel-out` stores other types of build outputs

	Bazel stores the Android `.apk` file generated using the `android_binary` rule
	in the `bazel-bin/src/main` directory, where the subdirectory name `src/main` is
	derived from the name of the Bazel package.

	At a command prompt, list the contents of this directory and find the `app.apk`
	file:

	\| OS \| Command \|
	\| ------------------------ \| ------------------------ \|
	\| Linux, macOS \| `ls bazel-bin/src/main` \|
	\| Windows (Command Prompt) \| `dir bazel-bin\src\main` \|
	\| Windows (PowerShell) \| `ls bazel-bin\src\main` \|


	### Run the app

	You can now deploy the app to a connected Android device or emulator from the
	command line using `bazel mobile-install`.
	This command uses the Android Debug Bridge (`adb`) to communicate with the
	device. You must set up your device to use `adb` following the instructions in
	[Android Debug Bridge](http://developer.android.com/tools/help/adb.html)
	before deployment. You can also choose to install the app on the Android emulator
	included in Android Studio. Make sure the emulator is running before executing
	the command below.

	Enter the following:

	```posix-terminal
	bazel mobile-install //src/main:app \
	--mode=skylark \
	--mobile_install_aspect=@rules_android//mobile_install:mi.bzl \
	--mobile_install_supported_rules=android_binary \
	--java_runtime_version=17 \
	--java_language_version=17 \
	--tool_java_runtime_version=17 \
	--tool_java_language_version=17
	```

	Note that the extra flags required for mobile-install can be added to your
	project's [bazelrc file](/run/bazelrc). The mobile-install-specific flags
	(`--mode`, `--mobile_install*`) will no longer be required starting from
	Bazel 8.4.0 and onwards. The various Java flags for language and runtime version
	may be required depending on your workspace's Java configuration.
	_Mobile-install sub-tools require a language and runtime level of 17 or higher._

	Now the "Bazel Tutorial App" should install and launch automatically:

	![Bazel tutorial app](/docs/images/android_tutorial_before.png "Bazel tutorial app")

	Figure 2. Bazel tutorial app.

	Congratulations! You have just installed your first Bazel-built Android app.

	## Further reading

	For more details, see these pages:

	* Open issues on [rules_android GitHub](https://github.com/bazelbuild/rules_android/issues)
	* More information on [mobile-install](/docs/mobile-install)
	* Shrink and optimize your app with [R8](https://github.com/bazelbuild/rules_android/tree/main/docs/r8-optimization.md)
	* Integrate external dependencies like AppCompat, Guava and JUnit from Maven
	repositories using [rules_jvm_external](https://github.com/bazelbuild/rules_jvm_external)
	* Run Robolectric tests with the [robolectric-bazel](https://github.com/robolectric/robolectric-bazel)
	integration.
	* Integrating C and C++ code into your Android app with the [NDK](/docs/android-ndk)
	* See more Bazel example projects of:
	* [a Kotlin app](https://github.com/bazelbuild/rules_jvm_external/tree/master/examples/android_kotlin_app)
	* [Robolectric testing](https://github.com/bazelbuild/rules_jvm_external/tree/master/examples/android_local_test)
	* [Espresso testing](https://github.com/bazelbuild/rules_jvm_external/tree/master/examples/android_instrumentation_test)

	Happy building!