Instructivo de Bazel: Compila una app para iOS

Informar un problema Ver fuente . Por la noche · 7.3 · 7.2 · 7.1 · 7.0 · 6.5

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:

• Configura el entorno instalando Bazel y Xcode, y descargando el archivo proyecto de muestra
• Configura un lugar de trabajo de Bazel que contenga el código fuente. para la app y un archivo WORKSPACE que identifica el nivel superior de la directorio del espacio de trabajo
• Actualiza el archivo WORKSPACE para que contenga referencias al archivo las dependencias externas
• Crea un archivo BUILD
• Ejecuta Bazel para compilar la app del 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, y obtén el proyecto de muestra.

Instala Bazel

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

Instala Xcode

Descarga Xcode y, luego, instálalo. Xcode contiene los compiladores, los SDK y otras herramientas que requiere Bazel para compilar aplicaciones para Apple.

Obtén el proyecto de muestra

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

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

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

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

Configura un espacio de trabajo

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

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

Nota: Bazel no impone ningún requisito para organizar la fuente archivos en tu espacio de trabajo. Los archivos fuente de muestra en este instructivo están organizados según las convenciones de la plataforma de destino.

Para tu comodidad, configura la variable de entorno $WORKSPACE ahora para hacer referencia a el 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 nivel superior Workspace. Es posible que este archivo esté vacío o contenga referencias a las dependencias externas que se requieren para compilar la software.

Por ahora, crearás un archivo WORKSPACE vacío, que simplemente se entrega a identificar el directorio del lugar de trabajo. En pasos posteriores, actualizarás el archivo para agregar información sobre las dependencias externas.

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

Para compilar aplicaciones para dispositivos Apple, Bazel necesita extraer Reglas de compilación de Apple desde su repositorio de GitHub. Para habilitar esta función, agrega lo siguiente: git_repository reglas 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",
)

Nota: “Usa siempre el versión más reciente de las reglas build_apple en el atributo tag. Asegúrate de verificar las últimas dependencias requeridas en proyecto de rules_apple".

Nota: Debes configurar el valor del atributo name en la git_repository a build_bazel_rules_apple o la compilación fallará.

Revisa los archivos fuente

Consulta los archivos fuente de la app en $WORKSPACE/ios-app/UrlGet Una vez más, ahora estás mirando estos archivos para familiarizarse con la estructura de la aplicación. No es necesario editar archivos fuente para completar este instructivo.

Cómo crear un archivo BUILD

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

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

Agrega la declaración de carga de la regla

Para compilar destinos de iOS, Bazel debe cargar reglas de compilación desde su repositorio de GitHub. cada vez que se ejecuta la compilación. Para que estas reglas estén disponibles en tu proyecto, agrega 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, ya que objc_library está integrada en el paquete de Bazel.

Agrega una regla objc_library

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

Nota: En este instructivo, se presenta un caso de uso mínimo de las reglas de Objective-C en Bazel Por ejemplo, debes usar la regla ios_application para compilar apps para iOS multiarquitectónicas.

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

El ios_application Esta regla 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"],
)

Nota: Actualiza el atributo minimum_os_version al mínimo para la versión de iOS que planeas admitir.

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

Ya está todo listo para compilar tu app y, luego, implementarla en un simulador y en una dispositivo iOS.

Nota: La app se inicia de forma independiente, pero requiere un servidor de backend para producir un resultado. Consulta el archivo README en el directorio del proyecto de muestra para obtener información cómo compilar el servidor de backend.

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

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

Compila la app para el simulador

Asegúrate de que el directorio de trabajo actual se encuentre dentro de tu 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

Cómo buscar los resultados de la compilación

El archivo .ipa y otras salidas se encuentran en $WORKSPACE/bazel-bin/ios-app.

Ejecuta y depura 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 y elige un simulador de iOS como esquema de tiempo de ejecución. y haz clic en Ejecutar.

Nota: Si modificas algún archivo de proyecto en Xcode (por ejemplo, si agregas o quitar un archivo, agregar o cambiar una dependencia), debes recompilar la app usando Bazel, vuelve a generar el proyecto Xcode en Tulsi y, luego, vuelve a abrirlo en Xcode.

Cómo compilar la app para un dispositivo

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

1. Ve a tu cuenta de desarrollador de Apple. y descarga el perfil de aprovisionamiento adecuado para tu dispositivo. Consulta Documentación de Apple para obtener más información.

2. Mueve tu perfil a $WORKSPACE.

3. (Opcional) Agrega tu perfil al archivo .gitignore.

4. Agrega la siguiente línea al destino ios_application en el archivo BUILD:

   provisioning_profile = "<your_profile_name>.mobileprovision",
   

Nota: Asegúrate de que el perfil sea correcto para que la app se pueda instalar en un dispositivo.

Ahora, compila la app para tu dispositivo:

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

De esta manera, se compila la app como un objeto binario multiarquitectura. Si quieres compilar para un dispositivo específico, sigue estos pasos: de Terraform, desígnala en las opciones de compilación.

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

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

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

Instalar la app en un dispositivo

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

Si la app no se instala en el dispositivo, asegúrate de especificar el el perfil de aprovisionamiento correcto en tu archivo BUILD (paso 4 de la ).

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

Lecturas adicionales

Para obtener más detalles, consulta rama principal del repositorio de GitHub.