Set up your environment

Install Bazel

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:

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:

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.

Run and debug the app in the simulator

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:

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.