Se usó la API de Cloud Translation para traducir esta página.

Instructivo de Bazel: Compila una app para iOS

En este instructivo, se explica cómo compilar una app para iOS simple con Bazel.

Qué aprenderás

En este instructivo, aprenderás a realizar lo siguiente:

Instala Bazel y Xcode para configurar el entorno, y descarga el proyecto de muestra
Configura un lugar de trabajo de Bazel que contenga el código fuente de la app y un archivo WORKSPACE que identifique el nivel superior del directorio del lugar de trabajo.
Actualiza el archivo WORKSPACE para que contenga referencias a las dependencias externas requeridas.
Crea un archivo BUILD
Ejecuta Bazel a fin de compilar la app para el simulador y un dispositivo iOS.
Ejecuta la app en el simulador y en un dispositivo iOS

Configura tu entorno

Para comenzar, instala Bazel y Xcode. Luego, obtén el proyecto de muestra.

Instala Bazel

Sigue las instrucciones de instalación para instalar Bazel y sus dependencias.

Instala Xcode

Descarga y, luego, instala Xcode. Xcode contiene los compiladores, los SDKs y otras herramientas que requiere Bazel para compilar aplicaciones de Apple.

Obtén el proyecto de muestra

También debes obtener el proyecto de muestra para el instructivo de GitHub. El repositorio de GitHub tiene dos ramas: source-only y main. La rama source-only contiene solo los archivos fuente del proyecto. Usarás los archivos de esta rama en este instructivo. La rama main contiene los archivos de origen y los archivos WORKSPACE y BUILD completos de Bazel. Puedes usar los archivos de esta rama para verificar tu trabajo cuando hayas completado los pasos del instructivo.

Ingresa lo siguiente en la línea de comandos para obtener los archivos de la rama source-only:

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

El comando git clone crea un directorio llamado $HOME/examples/. Este directorio contiene varios proyectos de muestra para Bazel. Los archivos de proyecto para este instructivo están en $HOME/examples/tutorial/ios-app.

Configura un lugar de trabajo

Un lugar de trabajo es un directorio que contiene los archivos de origen para uno o más proyectos de software, así como un archivo WORKSPACE y archivos BUILD que contienen las instrucciones que Bazel usa para compilar el software. El lugar de trabajo también puede contener vínculos simbólicos a directorios de salida.

Un directorio de lugar de trabajo se puede ubicar en cualquier lugar del sistema de archivos y se indica por la presencia del archivo WORKSPACE en su raíz. En este instructivo, el directorio de tu lugar de trabajo es $HOME/examples/tutorial/, que contiene los archivos de proyecto de muestra que clonaste desde el repositorio de GitHub en el paso anterior.

Para tu comodidad, configura la variable de entorno $WORKSPACE ahora para hacer referencia al directorio de tu lugar de trabajo. En la línea de comandos, ingresa lo siguiente:

export WORKSPACE=$HOME/examples/tutorial

Crea un archivo WORKSPACE

Cada lugar de trabajo debe tener un archivo de texto llamado WORKSPACE ubicado en el directorio del lugar de trabajo de nivel superior. Es posible que este archivo esté vacío o que contenga referencias a dependencias externas necesarias para compilar el software.

Por ahora, crearás un archivo WORKSPACE vacío, que solo sirve para identificar el directorio del lugar de trabajo. En pasos posteriores, actualizarás el archivo para agregar información de dependencia externa.

Ingresa lo siguiente en la línea de comandos:

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

Esto crea y abre el archivo WORKSPACE vacío.

Actualiza el archivo WORKSPACE

A fin de compilar aplicaciones para dispositivos Apple, Bazel necesita extraer las reglas de compilación de Apple más recientes de su repositorio de GitHub. Para habilitar esto, agrega las siguientes reglas de git_repository a tu archivo WORKSPACE:

load("@bazel_tools//tools/build_defs/repo:git.bzl", "git_repository")

git_repository(
    name = "build_bazel_rules_apple",
    remote = "https://github.com/bazelbuild/rules_apple.git",
    tag = "0.19.0",
)

git_repository(
    name = "build_bazel_rules_swift",
    remote = "https://github.com/bazelbuild/rules_swift.git",
    tag = "0.13.0",
)

git_repository(
    name = "build_bazel_apple_support",
    remote = "https://github.com/bazelbuild/apple_support.git",
    tag = "0.7.2",
)

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

Revisa los archivos fuente

Consulta los archivos fuente de la app ubicados en $WORKSPACE/ios-app/UrlGet. Una vez más, solo estás mirando estos archivos para familiarizarte con la estructura de la app. No es necesario que edites ninguno de los archivos de origen para completar este instructivo.

Crea un archivo BUILD

En una ventana de línea de comandos, abre un nuevo archivo BUILD para editar:

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

Agrega la sentencia de carga de la regla

Para compilar destinos de iOS, Bazel necesita cargar reglas de compilación desde su repositorio de GitHub cada vez que se ejecuta la compilación. Si quieres que estas reglas estén disponibles para tu proyecto, agrega la siguiente declaración de carga al comienzo del archivo BUILD:

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

Solo debes cargar la regla ios_application porque la regla objc_library está compilada en el paquete de Bazel.

Agregar una regla objc_library

Bazel proporciona varias reglas de compilación que puedes usar a fin de compilar una app para la plataforma de iOS. En este instructivo, primero usarás la regla objc_library para indicarle a Bazel cómo compilar una biblioteca estática a partir del código fuente de la app y los archivos Xib. Luego, usarás la regla ios_application para indicarle cómo compilar el objeto binario de la aplicación y el paquete .ipa.

Agrega lo siguiente a tu archivo BUILD:

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

Anota el nombre de la regla, UrlGetClasses.

Agrega una regla ios_application

La regla ios_application compila el objeto binario de la aplicación y crea el archivo de paquete .ipa.

Agrega lo siguiente a tu archivo BUILD:

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"],
)

Observa cómo el atributo deps hace referencia al resultado de la regla UrlGetClasses que agregaste al archivo BUILD anterior.

Ahora guarda y cierra el archivo. Puedes comparar tu archivo BUILD con el ejemplo completo en la rama main del repositorio de GitHub.

Compila e implementa la app

Ahora estás listo para compilar tu app y, luego, implementarla en un simulador y en un dispositivo iOS.

La app compilada se encuentra en el directorio $WORKSPACE/bazel-bin.

Los archivos WORKSPACE y BUILD completados de este instructivo se encuentran en la rama principal del repositorio de GitHub. Puedes comparar tu trabajo con los archivos completados para obtener ayuda adicional o solucionar problemas.

Cómo compilar la app para el simulador

Asegúrate de que tu directorio de trabajo actual esté dentro del lugar de trabajo de Bazel:

cd $WORKSPACE

Ahora, ingresa lo siguiente para compilar la app de ejemplo:

bazel build //ios-app:ios-app

Bazel inicia y compila la app de ejemplo. Durante el proceso de compilación, el resultado será similar al siguiente:

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

Busca los resultados de la compilación

El archivo .ipa y otros resultados se encuentran en el directorio $WORKSPACE/bazel-bin/ios-app.

Cómo ejecutar y depurar la app en el simulador

Ahora puedes ejecutar la app desde Xcode con el simulador de iOS. Primero, genera un proyecto de Xcode con Tulsi.

Luego, abre el proyecto en Xcode, elige un simulador de iOS como esquema de entorno de ejecución y haz clic en Run.

Compila la app para un dispositivo

Para compilar la app de modo que se instale y se inicie en un dispositivo iOS, Bazel necesita el perfil de aprovisionamiento adecuado para ese modelo de dispositivo. Puedes hacer lo siguiente:

Ve a tu cuenta de desarrollador de Apple y descarga el perfil de aprovisionamiento adecuado para tu dispositivo. Consulta la documentación de Apple para obtener más información.
Mueve tu perfil a $WORKSPACE.
(Opcional) Agrega tu perfil al archivo .gitignore.
Agrega la siguiente línea al destino ios_application en tu archivo BUILD:
```
provisioning_profile = "<your_profile_name>.mobileprovision",
```

Ahora, compila la app para tu dispositivo:

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

Esto compila la app como un objeto binario multiarquitectura. Si quieres realizar compilaciones para una arquitectura de dispositivo específica, designala en las opciones de compilación.

Para compilar una versión de Xcode específica, usa la opción --xcode_version. Si quieres compilar para una versión del SDK específica, usa la opción --ios_sdk_version. La opción --xcode_version es suficiente en la mayoría de las situaciones.

Para especificar una versión mínima de iOS requerida, agrega el parámetro minimum_os_version a la regla de compilación ios_application en el archivo BUILD.

También puedes usar Tulsi para compilar tu app con una GUI en lugar de la línea de comandos.

Instala la app en un dispositivo

La manera más fácil de instalar la app en el dispositivo es iniciar Xcode y usar el comando Windows > Devices. Selecciona el dispositivo conectado en la lista de la izquierda y, luego, agrega la app. Para ello, haz clic en el botón Agregar (signo más) en "Apps instaladas" y selecciona el archivo .ipa que compilaste.

Si no se puede instalar la app en tu dispositivo, asegúrate de especificar el perfil de aprovisionamiento correcto en el archivo BUILD (paso 4 de la sección anterior).

Si no se inicia tu app, asegúrate de que el dispositivo forme parte de tu perfil de aprovisionamiento. El botón View Device Logs de la pantalla Devices de Xcode puede proporcionar otra información sobre lo que salió mal.

Lecturas adicionales

Para obtener más información, consulta la rama principal del repositorio de GitHub.