Introduction to Bazel: Building an iOS App

In this tutorial, you will learn how to build a simple iOS app. You’ll do the following:

Set up your environment

To get started, install Bazel and Xcode, and get the sample project.

Install Bazel

Follow the installation instructions to install Bazel and its dependencies.

Install Xcode

Download and install Xcode. Xcode contains the compilers, SDKs, and other tools required by Bazel to build Apple applications.

Get the sample project

You also need to get the sample project for the tutorial from GitHub. The GitHub repo has two branches: source-only and master. The source-only branch contains the source files for the project only. You’ll use the files in this branch in this tutorial. The master branch contains both the source files and completed Bazel WORKSPACE and BUILD files. You can use the files in this branch to check your work when you’ve completed the tutorial steps.

Enter the following at the command line to get the files in the source-only branch:

cd $HOME
git clone -b source-only https://github.com/bazelbuild/examples

The git clone command creates a directory named $HOME/examples/. This directory contains several sample projects for Bazel. The project files for this tutorial are in $HOME/examples/tutorial/ios-app.

Set up a workspace

A workspace is a directory that contains the source files for one or more software projects, as well as a WORKSPACE file and BUILD files that contain the instructions that Bazel uses to build the software. The workspace may also contain symbolic links to output directories.

A workspace directory can be located anywhere on your filesystem and is denoted by the presence of the WORKSPACE file at its root. In this tutorial, your workspace directory is $HOME/examples/tutorial/, which contains the sample project files you cloned from the GitHub repo in the previous step.

Note that Bazel itself doesn’t impose any requirements for organizing source files in your workspace. The sample source files in this tutorial are organized according to conventions for the target platform.

For your convenience, set the $WORKSPACE environment variable now to refer to your workspace directory. At the command line, enter:

export WORKSPACE=$HOME/examples/tutorial

Create a WORKSPACE file

Every workspace must have a text file named WORKSPACE located in the top-level workspace directory. This file may be empty or it may contain references to external dependencies required to build the software.

For now, you’ll create an empty WORKSPACE file, which simply serves to identify the workspace directory. In later steps, you’ll update the file to add external dependency information.

Enter the following at the command line:

touch $WORKSPACE/WORKSPACE
open -a Xcode $WORKSPACE/WORKSPACE

This creates and opens the empty WORKSPACE file.

Update the WORKSPACE file

To build applications for Apple devices, Bazel needs to pull the latest Apple build rules from its GitHub repository. To enable this, add the following git_repository rules to your WORKSPACE file:

git_repository(
    name = "build_bazel_rules_apple",
    remote = "https://github.com/bazelbuild/rules_apple.git",
    tag = "0.4.0",
)
git_repository(
    name = "bazel_skylib",
    remote = "https://github.com/bazelbuild/bazel-skylib.git",
    tag = "0.3.1",
)

NOTE: “Always use the latest version of the build_apple rules in the tag attribute. Make sure to check the latest dependencies required in rules_apple’s project.”

NOTE: You must set the value of the name attribute in the git_repository rule to build_bazel_rules_apple or the build will fail.

Review the source files

Take a look at the source files for the app located in $WORKSPACE/ios-app/UrlGet. Again, you’re just looking at these files now to become familiar with the structure of the app. You don’t have to edit any of the source files to complete this tutorial.

Create a BUILD file

At a command-line prompt, open a new BUILD file for editing:

touch $WORKSPACE/ios-app/BUILD
open -a Xcode $WORKSPACE/ios-app/BUILD

Add the rule load statement

To build iOS targets, Bazel needs to load build rules from its GitHub repository whenever the build runs. To make these rules available to your project, add the following load statement to the beginning of your BUILD file:

load("@build_bazel_rules_apple//apple:ios.bzl", "ios_application")

We only need to load the ios_application rule because the objc_library rule is built into the Bazel package.

Add an objc_library rule

Bazel provides several build rules that you can use to build an app for the iOS platform. For this tutorial, you’ll first use the objc_library rule to tell Bazel how to build a static library from the app source code and Xib files. Then you’ll use the ios_application rule to tell it how to build the application binary and the .ipa bundle.

NOTE: This tutorial presents a minimal use case of the Objective-C rules in Bazel. For example, you have to use the ios_application rule to build multi-architecture iOS apps.

Add the following to your BUILD file:

objc_library(
    name = "UrlGetClasses",
    srcs = [
         "UrlGet/AppDelegate.m",
         "UrlGet/UrlGetViewController.m",
         "UrlGet/main.m",
    ],
    hdrs = glob(["UrlGet/*.h"]),
    xibs = ["UrlGet/UrlGetViewController.xib"],
)

Note the name of the rule, UrlGetClasses.

Add an ios_application rule

The ios_application rule builds the application binary and creates the .ipa bundle file.

Add the following to your BUILD file:

ios_application(
    name = "ios-app",
    bundle_id = "Google.UrlGet",
    families = [
        "iphone",
        "ipad",
    ],
    minimum_os_version = "9.0",
    infoplists = [":UrlGet/UrlGet-Info.plist"],
    visibility = ["//visibility:public"],
    deps = [":UrlGetClasses"],
)

NOTE: Please update the minimum_os_version attribute to the minimum version of iOS that you plan to support.

Note how the deps attribute references the output of the UrlGetClasses rule you added to the BUILD file above.

Now, save and close the file. You can compare your BUILD file to the completed example in the master branch of the GitHub repo.

Build and deploy the app

You are now ready to build your app and deploy it to a simulator and onto an iOS device.

NOTE: The app launches standalone but requires a backend server in order to produce output. See the README file in the sample project directory to find out how to build the backend server.

Build the app for the simulator

Make sure that your current working directory is inside your Bazel workspace:

cd $WORKSPACE

Now, enter the following to build the sample app:

bazel build //ios-app:ios-app

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

INFO: Found 1 target...
Target //ios-app:ios-app up-to-date:
  bazel-bin/ios-app/ios-app.ipa
INFO: Elapsed time: 0.565s, Critical Path: 0.44s

Find the build outputs

The .ipa file and other outputs are located in the $WORKSPACE/bazel-bin/ios-app directory.

Run and debug the app in the simulator

You can now run the app from Xcode using the iOS Simulator. First, generate an Xcode project using Tulsi.

Then, open the project in Xcode, choose an iOS Simulator as the runtime scheme, and click Run.

Note: If you modify any project files in Xcode (for example, if you add or remove a file, or add or change a dependency), you must rebuild the app using Bazel, re-generate the Xcode project in Tulsi, and then re-open the project in Xcode.

Build the app for a device

To build your app so that it installs and launches on an iOS device, Bazel needs the appropriate provisioning profile for that device model. Do the following:

  1. Go to your Apple Developer Account and download the appropriate provisioning profile for your device. See Apple’s documentation for more information.

  2. Move your profile into $WORKSPACE.

  3. (Optional) Add your profile to your .gitignore file.

  4. Add the following line to the ios_application target in your BUILD file:

    provisioning_profile = "<your_profile_name>.mobileprovision",

    NOTE: Ensure the profile is correct so that the app can be installed on a device.

Now build the app for your device:

bazel build //ios-app:ios-app --ios_multi_cpus=armv7,arm64

This builds the app as a fat binary. To build for a specific device architecture, designate it in the build options.

To build for a specific Xcode version, use the --xcode_version option. To build for a specific SDK version, use the --ios_sdk_version option. The --xcode_version option is sufficient in most scenarios.

To specify a minimum required iOS version, add the minimum_os_version parameter to the ios_application build rule in your BUILD file.

You can also use Tulsi to build your app using a GUI rather than the command line.

Install the app on a device

The easiest way to install the app on the device is to launch Xcode and use the Windows > Devices command. Select your plugged-in device from the list on the left, then add the app by clicking the Add (plus sign) button under “Installed Apps” and selecting the .ipa file that you built.

If your app fails to install on your device, ensure that you are specifying the correct provisioning profile in your BUILD file (step 4 in the previous section).

If your app fails to launch, make sure that your device is part of your provisioning profile. The View Device Logs button on the Devices screen in Xcode may provide other information as to what has gone wrong.

Review your work

In this tutorial, you used Bazel to build an iOS app. To accomplish that, you:

  • Set up your environment by installing Bazel and Xcode, and downloading the sample project
  • Set up a Bazel workspace that contained the source code for the app and a WORKSPACE file that identifies the top level of the workspace directory
  • Updated the WORKSPACE file to contain references to the required external dependencies
  • Created a BUILD file
  • Ran Bazel to build the app for the simulator and an iOS device
  • Ran the app in the simulator and on an iOS device

The built app is located in the $WORKSPACE/bazel-bin directory.

Completed WORKSPACE and BUILD files for this tutorial are located in the master branch of the GitHub repo. You can compare your work to the completed files for additional help or troubleshooting.