Posted by: Pavlo Stavytskyi

Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aenean commodo ligula eget dolor. Aenean massa. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Donec quam felis, ultricies nec, pellentesque eu, pretium quis, sem. Nulla consequat massa quis enim. Donec pede justo, fringilla vel, aliquet nec, vulputate eget, arcu. In enim justo, rhoncus ut, imperdiet a, venenatis vitae, justo. Nullam dictum felis eu pede mollis pretium. Integer tincidunt. Cras dapibus. Vivamus elementum semper nisi. Aenean vulputate eleifend tellus. Aenean leo ligula, porttitor eu, consequat vitae, eleifend ac, enim. Aliquam lorem ante, dapibus in, viverra quis, feugiat a, tellus. Phasellus viverra nulla ut metus varius laoreet. Quisque rutrum. Aenean imperdiet. Etiam ultricies nisi vel augue. Curabitur ullamcorper ultricies nisi. Nam eget dui. Etiam rhoncus. Maecenas tempus, tellus eget condimentum rhoncus, sem quam semper libero, sit amet adipiscing sem neque sed ipsum. Nam quam nunc, blandit vel, luctus pulvinar, hendrerit id, lorem. Maecenas nec odio et ante tincidunt tempus. Donec vitae sapien ut libero venenatis faucibus. Nullam quis ante. Etiam sit amet orci eget eros faucibus tincidunt. Duis leo. Sed fringilla mauris sit amet nibh. Donec sodales sagittis magna. Sed consequat, leo eget bibendum sodales, augue velit cursus nunc,

That’s all we need to have a working Android application.

Here is the project structure so far:

bazel-android-app 
├── app 
│   ├── java 
│   │   └── com/morfly/helloworld
│   │       └── MainActivity.java  <- new 
│   ├── res 
│   │   └── activity_main.xml  <- new 
│   │
│   └── AndroidManifest.xml  <- new
│
└── WORKSPACE

Step 4. Building and running the project

Now we’ve reached the most interesting part. We are going to build and run our Android project with Bazel.

In order to build the project, we need to create a buildable target. To do this, under the app directory create the file called BUILD . Add the following code:

All Bazel files use Starlark language which is a simplified version of Python. This means that can consider the contents of a BUILD file to be just a Python code. Let’s go line-by-line and see what does this code do:

1. android_binary — rule that allows creating buildable Android target. By the convention, all rules that end with _binary , create targets that generate executable files for applications. In our case, this rule is used to define a target that generates an .apk file that can be launched on a mobile device.
2. name — specifies the unique name of the target.
3. custom_package — specifies a Java package for which Java sources will be generated.
4. manifest — specifies a path to the AndroidManifest.xml file.
5. srcs — specifies the list of source files used by the target.
6. resource_files — specifies the list of resource files used by the target. It is possible to list all the files 1-by-1 as it is done with the srcs argument, or as an alternative, include all files that match the given pattern using glob function.

Rule — is the function that creates buildable targets. Each rule defines specific build configuration for the particular use case. E.g. Targets created with java_binary rule generate executable .jar files, while android_binarytargets create .apk files. To do this, they take different arguments and perform different job under the hood.

Target — is the single instance created by the rule function that can be referred by the unique name. E.g. Your project can contain multiple targets namedapp1 , app2 , … appN created using android_binary rule.

Now, open your terminal at the root directory of your workspace and run the following command to start building the project:

$ bazelisk build //app:app

Now, launch the emulator or connect the real mobile device to your computer and run the following command:

$ bazelisk mobile-install //app:app --start_app

If the build was successful, you will see the Android application launched on your device showing Hello World! on the screen.

Note. By default mobile-install only installs the application to the device without launching. By using --start_app flag we can tell Bazel to launch the application right after installation.

Here is the project structure so far:

bazel-android-hello-world 
├── app 
│   ├── java 
│   │   └── com/morfly/helloworld 
│   │       └── MainActivity.java
│   ├── res 
│   │   └── activity_main.xml
│   │
│   ├── BUILD  <- new
│   └── AndroidManifest.xml
│
└── WORKSPACE

Step 5. Understanding Bazel labels

In the example above we’re using //app:app label in order to refer to the android_binary target that we have defined earlier. Let’s deconstruct this label and understand its structure:

• // — means that we start the reference from the root of the workspace (root of the project).
• app — first occurrence of app is the name of Bazel package that contains the target we want to build.

Note: Bazel package is the directory that holds BUILD file. Therefore, Bazel package name is defined by the relative path from the project root to the directory that holds BUILD file.

Do not confuse Bazel package and Java package. They are not the same.

• :app — second occurrence of app is the name of the target defined in the BUILD file. In our case, it refers to the android_binary target with the argument name = "app" .

Shortening labels

In some cases, it is possible to shorten labels for convenience. For example, if the package name and target name are the same, we can avoid explicitly specifying the latter in labels. So, instead of //app:app we can refer to our target as //app :

$ bazelisk build //app

Moreover, if the target is inside the package that is next to the project root directory, we can also omit // . So we can refer to our target as app .

$ bazelisk build app

This is the bare minimum required for building Android applications with Bazel. In the next chapter, you will see how to add external maven dependencies to the project.

The source code can be found here:

Morfly/bazel-examples Contribute to Morfly/bazel-examples development by creating an account on GitHub. github.com

 

Tags: Bazel, Android, Build System, AndroidDev

View original article at:

Originally published: March 22, 2021