Machine Translated by Google

Documentación de Python para Android

Versión 0.1

alexander taylor

22 de mayo de 2023
Machine Translated by Google
Machine Translated by Google

Contenido

1 Contenido 3
1.1 Primeros pasos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ............................................. 3
1.2 Opciones de construcción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .............................................9
1.3 Comandos ..................................................................................................................................................... 13
1.4 Trabajando en Android ...................................................................................................................................... 14
1.5 Launcher ....................................................................................................................................................... 20
1.6 integración de distutils/setuptools ..................................................................................................................... 22
1.7 Recetas ............................................................................................................................................................. 24
1.8 Arranques . . . . . . . . . . . . ..... . . . . . . . . . . . . . . ..... ...................................... 31
1.9 Servicios . . . . . . . . . . . . . . ..... . . . . . . . . . . . . . . ..... ...................................... 32
1.10 Solución de problemas......................................................................................................................................................................... 34
1.11 Docker ......................................................................................................................................................... 37
1.12 Desarrollo y contribución ............................................................................................................................. 38
1.13 Prueba de una solicitud de extracción de Python para Android ........................................................................................ 41

2 Índices y tablas 45

Índice de módulos de Python 47

Índice 49

i
Machine Translated by Google

yo
Machine Translated by Google

Documentación de Python para Android, versión 0.1

python•for•android es una herramienta de compilación de código abierto que le permite empaquetar el código de Python en APK de
Android independientes. Estos pueden transmitirse, instalarse o cargarse en mercados como Play Store como cualquier otra aplicación
de Android. Esta herramienta se desarrolló originalmente para el marco gráfico multiplataforma Kivy, pero ahora admite múltiples
arranques y se puede ampliar fácilmente para empaquetar otros tipos de aplicaciones de Python para Android.

python•for•android admite dos operaciones principales; primero, puede compilar el intérprete de Python, sus dependencias, las
bibliotecas de back•end y el código de Python para dispositivos Android. Esta etapa es totalmente personalizable: puede instalar tantos
o pocos componentes como desee. El resultado es un proyecto de Android independiente que se puede usar para generar cualquier
cantidad de APK diferentes, incluso con diferentes nombres, íconos, código de Python, etc. La segunda función de python•for•android es
proporcionar una interfaz simple para estas distribuciones, para genere a partir de dicho proyecto un APK de Python con parámetros de
compilación y código de Python a su gusto.

Contenido 1
Machine Translated by Google

Documentación de Python para Android, versión 0.1

2 Contenido
Machine Translated by Google

CAPÍTULO 1

3
Machine Translated by Google

Documentación de Python para Android, versión 0.1

Instalando p4a

p4a ahora está disponible en Pypi, por lo que puede instalarlo usando pip:

pip instalar python•para•android

También puedes probar la rama maestra de Github usando:

pip instalar git+https://github.com/kivy/python•for•android.git

Instalación de dependencias

p4a tiene varias dependencias que deben instalarse:

• hormiga

• autoconf (para libffi y otras recetas)

• fabricación automática

• caché (opcional)

• cmake (requerido para algunas recetas de código nativo como la receta de jpeg)

• cython (se puede instalar a través de pip)

• CCG

• git

• libncurses (incluyendo 32 bits)

• libtool (para libffi y recetas)

• libssl•dev (para compatibilidad con TLS/SSL en hostpython3 y receta)

• openjdk•8

• parche

• pitón3

• descomprimir

• virtualenv (se puede instalar a través de pip)

• zlib (incluyendo 32 bits)

• cremaller a

En versiones recientes de Ubuntu y sus derivados, es posible que pueda instalar la mayoría de estos con:

sudo dpkg ••add•architecture i386 sudo apt•get

update sudo apt•get install •y
build•essential ccache git zlib1g•dev python3 python3•dev →libncurses5:i386 libstdc++6:i386 zlib1g:i386 openjdk•8• jdk
descomprimir ant ccache →autoconf libtool libssl-dev

En Arch Linux, debería poder ejecutar lo siguiente para instalar la mayoría de las dependencias (nota: es posible que esta lista no esté completa):

sudo pacman •S core/autoconf core/automake core/gcc core/make core/patch core/pkgconf →extra/cmake extra/jdk8­openjdk extra/
python•pip extra/unzip extra/zip

4 Capítulo 1. Contenidos
Machine Translated by Google

Documentación de Python para Android, versión 0.1

En macOS:

brew install autoconf automake libtool openssl pkg-config brew tap homebrew/cask-versions
brew install --cask homebrew/cask-versions/
adoptopenjdk8

Instalación del SDK de Android

Advertencia: python-for-android suele ser exigente con las versiones de SDK/NDK. Elija los recomendados a continuación para evitar problemas.

Instalación básica de SDK

Debe descargar y descomprimir el SDK y el NDK de Android en un directorio (digamos $HOME/Documentos/):

• SDK de Android

• NDK de Android

Para el SDK de Android, puede descargar 'solo las herramientas de línea de comandos'. Cuando haya extraído estos, verá solo un directorio llamado
herramientas, y deberá ejecutar comandos adicionales para instalar los paquetes SDK necesarios.

Para Android NDK, tenga en cuenta que las versiones modernas solo funcionarán en un sistema operativo de 64 bits. La versión de NDK mínima y
recomendada para usar es r25b:

• Ir a la página de descargas de ndk

• Los usuarios de Windows deben crear una máquina virtual con un sistema operativo GNU Linux instalado, y luego puede seguir el
instrucciones descritas desde dentro de su máquina virtual.

Plataforma y herramientas de construcción

Primero, instale una plataforma API para apuntar. El nivel de API *objetivo* recomendado es 27, puede reemplazarlo con un número diferente, pero
tenga en cuenta que otras versiones de API están menos probadas y los dispositivos más antiguos aún son compatibles hasta el * mínimo* recomendado
API/NDK API nivel 21 :

$SDK_DIR/herramientas/bin/sdkmanager "plataformas; android-27"

En segundo lugar, instale las herramientas de compilación. Puede usar $SDK_DIR/tools/bin/sdkmanager --list para ver todas las posibilidades, pero
28.0.2 es la última versión al momento de escribir:

$SDK_DIR/herramientas/bin/sdkmanager "herramientas de compilación;28.0.2"

Configure p4a para usar su SDK/NDK

Luego, puede editar su ~/.bashrc u otro shell favorito para incluir nuevas variables de entorno necesarias para construir en Android:

# ¡Ajusta los caminos! export

ANDROIDSDK="$HOME/Documents/android-sdk-27" export
ANDROIDNDK="$HOME/Documents/android-ndk-r23b" export ANDROIDAPI="27"
# Versión objetivo de la API de tu aplicación
(continúa en la página siguiente)

1.1. Empezando 5
Machine Translated by Google

Documentación de Python para Android, versión 0.1

(Continuación de la página anterior)

export NDKAPI="21" # Versión API mínima admitida de su aplicación export ANDROIDNDKVER="r10e" #

Versión del NDK que instaló

Tienes la posibilidad de configurar en cualquier comando la RUTA al SDK, NDK y API de Android usando:

• --sdk-dir PATH como equivalente de $ANDROIDSDK

• --ndk-dir PATH como equivalente de $ANDROIDNDK

• VERSIÓN --android-api como equivalente de $ANDROIDAPI

• VERSIÓN --ndk-api como equivalente de $NDKAPI

• --ndk-version VERSION como equivalente de $ANDROIDNDKVER

1.1.3 Uso
Cree una aplicación Kivy o SDL2

Para crear su aplicación, debe especificar el nombre, la versión, un identificador de paquete, el programa de arranque que desea usar (sdl2 para
aplicaciones kivy o sdl2) y los requisitos:

p4a apk --private $HOME/code/myapp --package=org.example.myapp --name "Mi aplicación →" --version 0.1 --bootstrap=sdl2 --
requirements=python3,kivy

Nota sobre los --requisitos: debe agregar todas las bibliotecas/dependencias que su aplicación necesita para ejecutarse. Ejemplo: --
requirements=python3,kivy,vispy. Para una aplicación SDL2, no se necesita kivy, pero debe agregar cualquier envoltorio que pueda usar (por
ejemplo, pysdl2).

Esta aplicación p4a. . . El comando crea una distribución con python3, kivy y todo lo demás que especificó en los requisitos. Se empaquetará
con un arranque SDL2 y generará un archivo .apk.

Notas de compatibilidad:

• Python 2 ya no es compatible con python-for-android. La última versión compatible con Python 2 fue v2019.10.06.

Construir una aplicación WebView

Para construir su aplicación, debe tener un nombre, una versión, un identificador de paquete y usar explícitamente el arranque de la vista web,
así como los requisitos:

p4a apk --private $HOME/code/myapp --package=org.example.myapp --name "My WebView →Application" --version 0.1 --
bootstrap=webview --requirements=flask --port=5000

Tenga en cuenta que, al igual que con kivy/SDL2, debe especificar todos sus requisitos/dependencias adicionales.

También puede reemplazar el matraz con otro marco web.

Reemplace --port=5000 con el puerto en el que su aplicación servirá un sitio web. El valor predeterminado para Flask es 5000.

Crear un archivo de biblioteca de servicios

Para crear un archivo de Android (.aar), que contenga un servicio de Android, necesita un nombre, una versión, un identificad or de paquete, usar
explícitamente el programa de arranque service_library y declarar el punto de entrada del servicio (Consulte servicios para obtener más opciones),
así como los requisitos y arco(s):

6 Capítulo 1. Contenidos
Machine Translated by Google

Documentación de Python para Android, versión 0.1

p4a aar --private $HOME/code/myapp --package=org.example.myapp --name "Mi biblioteca" -- →versión 0.1 --bootstrap=service_library
--requirements=python3 --release -- → servicio=miservicio:servicio.py --arch=arm64-v8a --arch=armeabi-v7a

Luego puede llamar a los puntos de entrada de Java generados para sus servicios de Python en otros marcos de compilación de apk.

Exportación del Android App Bundle (aab) para distribuirlo en Google Play

A partir de agosto de 2021 para aplicaciones nuevas y desde noviembre de 2021 para actualizaciones de aplicaciones existentes, Google Play
Console requerirá el paquete de aplicaciones de Android en lugar del apk de larga duración.

python-for-android maneja por sí mismo el trabajo necesario para cumplir con los nuevos requisitos:

p4a aab –private $HOME/code/myapp –package=org.example.myapp –name=”My App” –version 0.1 –bootstrap=sdl2 –
requirements=python3,kivy –arch=arm64-v8a –arch=armeabi-v7a -liberar

Este p4a aab. . . El comando crea una distribución con python3, kivy y todo lo demás que especificó en los requisitos. Se empaquetará con un
arranque SDL2 y generará un archivo .aab que contiene archivos binarios para las ABI armeabi-v7a y arm64-v8a.

Se supone que el paquete de aplicaciones de Android se usa para distribuir su aplicación. Si necesita probarlo localmente, en su dispositivo,
puede usar bundletool <https://developer.android.com/studio/command -line/bundletool>

Otras opciones

Puede pasar otros argumentos de la línea de comandos para controlar los comportamientos de la aplicación, como la orientación, el wakelock y los permisos de la
aplicación. Consulte las opciones de Bootstrap.

reconstruir todo

Si algo sale mal y desea limpiar las descargas y compilaciones para volver a intentarlo todo, ejecute:

p4a limpiar_todo

Si solo desea limpiar las compilaciones para evitar volver a descargar las dependencias, ejecute:

p4a clean_builds && p4a clean_dists

Obteniendo ayuda

Si algo sale mal y no sabe cómo solucionarlo, agregue la opción --debug y publique el registro de salida en el grupo de Google de usuarios de
kivy. o el canal Discord de kivy #support.

Consulte Solución de problemas para obtener más información.

1.1.4 Uso avanzado

Gestión de recetas

Puedes ver la lista de las recetas disponibles con:

1.1. Empezando 7
Machine Translated by Google

Documentación de Python para Android, versión 0.1

recetas p4a

Si está contribuyendo a p4a y desea volver a probar recetas, debe limpiar la compilación y reconstruir su distribución:

p4a clean_recipe_build RECIPENAME p4a

clean_dists # luego
reconstruya su distribución

Puede escribir recetas "privadas" para su aplicación, simplemente cree una carpeta p4a-recipes en su directorio de compilación y coloque
una receta en ella (edite init .py):

mkdir -p p4a-recipes/myrecipe touch p4a-

recipes/myrecipe/ init .py

Gestión de distribución

Cada vez que inicie un nuevo proyecto, python-for-android creará internamente una nueva distribución (un proyecto de compilación de
Android que incluye Python y sus otras dependencias compiladas para Android), de acuerdo con los requisitos que agregó en la línea de
comando. Puede forzar la reutilización de una distribución existente agregando:

p4a apk --dist_name=miproyecto ...

Esto asegurará que su distribución siempre se construya en el mismo directorio y evitará usar más espacio en disco cada vez que ajuste un
requisito.

Puede enumerar las distribuciones disponibles:

distribuciones p4a

Y limpiarlos todos:

p4a clean_dists

Archivo de configuración

python-for-android busca en el directorio actual un archivo de configuración llamado .p4a. Si lo encuentra, agrega todas las líneas como
opciones a la línea de comando. Por ejemplo, puede agregar las opciones que siempre incluiría, como:

--dist_name mi_ejemplo --
android_api 27 --
requisitos kivy,openssl

Anular fuentes de recetas

Puede anular la fuente de cualquier receta utilizando la variable de entorno $P4A_recipename_DIR. Por ejemplo, para probar su propia
rama Kivy, puede configurar:

exportar P4A_kivy_DIR=/home/username/kivy

El directorio especificado se copiará en python-for-android en lugar de descargarlo desde la URL normal especificada en la receta.

8 Capítulo 1. Contenidos
Machine Translated by Google

Documentación de Python para Android, versión 0.1

archivo setup.py (experimental)

Si su aplicación también está empaquetada para escritorio usando setup.py, es posible que desee usar su setup.py en lugar de la opción --
requirements para evitar especificar cosas dos veces. Para ello, consulte la integración de distutils/setuptools

Ir más lejos

Consulte las otras páginas de este documento para obtener más información sobre temas específicos:

• Opciones de construcción

• Comandos

• Recetas

• Arranques

• Trabajar en Android

• Solución de problemas

• Lanzador

• Desarrollo y contribución

1.2 Opciones de construcción

Esta página contiene instrucciones para usar diferentes opciones de compilación.

1.2.1 Versiones de Python

python-for-android admite el uso de Python 3.7 o superior. Para seleccionar explícitamente una versión de Python en sus requisitos, use, por ejemplo,
--requirements=python3==3.7.1,hostpython3==3.7.1.

La última versión de Python para Android compatible con Python2 fue v2019.10.06

Python para Android ya no es compatible con la compilación para Python 3 con CrystaX NDK. La última versión de Python para Android compatible
con CrystaX fue 0.7.0

1.2.2 Opciones de arranque

python-for-android admite varios backends de aplicaciones con diferentes tipos de interfaz. Estos se llaman arranques.

Actualmente se admiten los siguientes programas de arranque, pero esperamos que sea fácil agregar otros si su proyecto tiene requisitos diferentes.
Haznos saber si desea ayuda para agregar uno nuevo.

sdl2

Use esto con --bootstrap=sdl2, o simplemente incluya la receta de sdl2, por ejemplo, --requirements=sdl2,python3.

SDL2 es una popular biblioteca de desarrollo multiplataforma, especialmente para juegos. Tiene su propio soporte para proyect os de Android, que
python-for-android usa como arranque, y al que agrega la compilación de Python y el código JNI para iniciarlo.

1.2. Opciones de compilación 9

Machine Translated by Google

Documentación de Python para Android, versión 0.1

Desde el punto de vista de un programa de Python, SDL2 debería comportarse normalmente. Por ejemplo, puede crear aplicaciones con Kivy
o PySDL2 y hacer que funcionen con este arranque. También debería ser posible usar, por ejemplo, pygame_sdl2, pero esto necesitaría una
receta de compilación y aún no tiene una.

Opciones de compilación

El arranque de sdl2 admite las siguientes opciones de línea de comando adicionales (esta lista puede no ser exhaustiva):

• --private: el directorio que contiene los archivos de su proyecto.

• --package: El nombre del paquete Java para su proyecto. por ejemplo, org.example.yourapp.

• --name: el nombre de la aplicación.

• --version: el número de versión.

• --orientation: las orientaciones en las que se mostrará la aplicación. (Las opciones disponibles son
vertical, horizontal, vertical inversa, horizontal inversa). Dado que Android ignora android:screenOrientation cuando está en modo de
múltiples ventanas (que es el valor predeterminado en Android 12+), esta opción también establecerá las sugerencias de orientación
de la ventana para el arranque de SDL. Si se dan múltiples orientaciones,

android:screenOrientation se configurará como no especificado. - --manifest-orientation: La orientación que se establecerá para

android:screenOrientation

atributo de la actividad en el archivo AndroidManifest.xml. Si no se establece, el valor se

sintetizará a partir de la opción --orientation. La lista completa de opciones válidas se encuentra en android:screenOrientation
en la documentación de Android.

• --icon: Una ruta al archivo png para usar como icono de la aplicación.

• --permission: un permiso que debe declararse en la aplicación AndroidManifest.xml. Para permisos múltiples, agregue varios
argumentos --permission. --home-app Le da la opción de configurar su aplicación como una aplicación de inicio (lanzador) en su
dispositivo Android.

Nota: --permission acepta las siguientes sintaxis: --permission (name=android.

allow.WRITE_EXTERNAL_STORAGE;maxSdkVersion=18) o --permission android. permiso.WRITE_EXTERNAL_STORAGE.

La primera sintaxis se usa para establecer propiedades adicionales para el permiso (android:maxSdkVersion y
android:usesPermissionFlags son las únicas admitidas por ahora).

El segundo se puede usar cuando no hay necesidad de agregar ninguna propiedad adicional.

Advertencia: la sintaxis --permission VIBRATE (solo el nombre del permiso, sin el prefijo) también se admite por compatibilidad
con versiones anteriores, pero se eliminará en el futuro.

• --meta-data: pares clave=valor personalizados para agregar en los metadatos de la aplicación.

• --presplash: Una ruta al archivo de imagen para usar como pantalla mientras se carga la aplicación.

• --presplash-color: el color de fondo de la pantalla previa a la presentación, con la forma #RRGGBB o un nombre de color rojo,
verde, azul, etc

• --presplash-lottie: utilice un archivo lottie (json) como animación previa a la presentación. Si se usa, reemplazará la estática.
imagen presalpicadura.

• --wakelock: si se incluye el argumento, la aplicación evitará que el dispositivo entre en modo de suspensión.

10 Capítulo 1. Contenidos
Machine Translated by Google

Documentación de Python para Android, versión 0.1

• --window: si se incluye el argumento, la aplicación no cubrirá la barra de estado de Android.

• --blacklist: la ruta a un archivo que contiene patrones en la lista negra que se excluirán del APK final.
El valor predeterminado es ./blacklist.txt.

• --whitelist: la ruta a un archivo que contiene patrones incluidos en la lista blanca que se incluirán en el APK incluso si también
en la lista negra.

• --add-jar: la ruta a un archivo .jar para incluir en el APK. Para incluir varios archivos jar, pase este argumento
varias veces.

• --intent-filters: una ruta de archivo que contiene xml de filtro de intención que se incluirá en AndroidManifest.xml.

• --service: un nombre de servicio y el script de Python que debe ejecutar. Consulte Scripts de servicios arbitrarios.

• --add-source: agrega un directorio fuente al código Java de la aplicación.

• --no-byte-compile-python: omite la compilación de bytes para archivos .py.

• --enable-androidx: habilite la biblioteca de soporte de AndroidX.

• --add-resource: coloque este archivo o directorio en el directorio apk res.

vista web

Puede usar esto con --bootstrap=webview, o incluir la receta webviewjni, por ejemplo, --requirements=webviewjni,python3.

La interfaz gráfica de usuario de arranque de la vista web es, según el nombre, una vista web que muestra una página web, pero esta página está
alojada en el dispositivo a través de un servidor web de Python. Por ejemplo, su código Python puede iniciar una aplicación F lask, y su aplicación
mostrará y permitirá al usuario navegar por este sitio web.

Nota: Su secuencia de comandos de Flask debe iniciar el servidor web sin :code:debug=True. El modo de depuración no parece funcionar en Android
debido al uso de un subproceso.

Este arranque intentará cargar automáticamente un sitio web en el puerto 5000 (el predeterminado para Flask), o puede especificar una opción
diferente con la opción de línea de comando –port. Si el servidor web no está presente inmediatamente (por ejemplo, durante el breve tiempo de carga
de Python cuando se inició por primera vez), mostrará una pantalla de carga hasta que el servidor esté listo.

• --private: el directorio que contiene los archivos de su proyecto.

• --package: El nombre del paquete Java para su proyecto. por ejemplo, org.example.yourapp.

• --name: el nombre de la aplicación.

• --version: el número de versión.

• --orientation: las orientaciones en las que se mostrará la aplicación. (Las opciones disponibles son
vertical, horizontal, vertical inversa, horizontal inversa). Dado que Android ignora android:screenOrientation cuando está en modo de múltiples
ventanas (que es el valor predeterminado en Android 12+), no se garantiza que esta configuración funcione, y debe considerar implementar
un controlador de cambio de orientación personalizado en su aplicación.

• --manifest-orientation: la orientación que se establecerá en el atributo android:screenOrientation de la actividad en el archivo AndroidManifest.xml.

Si no se establece, el valor se sintetizará a partir de la opción --orientation. La lista completa de opciones válidas se encuentra en
android:screenOrientation en la documentación de Android.

• --icon: Una ruta al archivo png para usar como icono de la aplicación.

1.2. Opciones de compilación 11

Machine Translated by Google

Documentación de Python para Android, versión 0.1

• --permission: un nombre de permiso para la aplicación, por ejemplo, --permission VIBRATE. Para permisos múltiples, agregue varios
argumentos --permission.

• --meta-data: pares clave=valor personalizados para agregar en los metadatos de la aplicación.

• --presplash: Una ruta al archivo de imagen para usar como pantalla mientras se carga la aplicación.

• --presplash-color: el color de fondo de la pantalla previa a la presentación, con la forma #RRGGBB o un nombre de color rojo,
verde, azul, etc

• --wakelock: si se incluye el argumento, la aplicación evitará que el dispositivo entre en modo de suspensión.

• --window: si se incluye el argumento, la aplicación no cubrirá la barra de estado de Android.

• --blacklist: la ruta a un archivo que contiene patrones en la lista negra que se excluirán del APK final.
El valor predeterminado es ./blacklist.txt.

• --whitelist: la ruta a un archivo que contiene patrones incluidos en la lista blanca que se incluirán en el APK incluso si también
en la lista negra.

• --add-jar: la ruta a un archivo .jar para incluir en el APK. Para incluir varios archivos jar, pase este argumento
varias veces.

• --intent-filters: una ruta de archivo que contiene xml de filtro de intención que se incluirá en AndroidManifest.xml.

• --service: un nombre de servicio y el script de Python que debe ejecutar. Consulte Scripts de servicios arbitrarios.

• add-source: agregue un directorio de origen al código Java de la aplicación.

• --port: El puerto en localhost al que accederá WebView. El valor predeterminado es 5000.

biblioteca_servicio

Puede usar esto con la opción --bootstrap=service_library.

Este programa de arranque se puede usar junto con el objetivo de salida aar para generar una biblioteca, que contiene servicios de Python que
se pueden usar con otros sistemas y marcos de compilación.

• --private: el directorio que contiene los archivos de su proyecto.

• --package: El nombre del paquete Java para su proyecto. por ejemplo, org.example.yourapp.

• --name: El nombre de la biblioteca.

• --version: el número de versión.

• --service: un nombre de servicio y el script de Python que debe ejecutar. Consulte Scripts de servicios arbitrarios.

• --blacklist: la ruta a un archivo que contiene patrones en la lista negra que se excluirán del AAR final.
El valor predeterminado es ./blacklist.txt.

• --whitelist: la ruta a un archivo que contiene patrones incluidos en la lista blanca que se incluirán en el AAR incluso si también
en la lista negra.

• --add-jar: la ruta a un archivo .jar para incluir en el APK. Para incluir varios archivos jar, pase este argumento
varias veces.

• add-source: agregue un directorio de origen al código Java de la aplicación.

12 Capítulo 1. Contenidos
Machine Translated by Google

Documentación de Python para Android, versión 0.1

1.2.3 Lista negra de requisitos (optimización de tamaño de APK)

Para optimizar el tamaño del archivo .apk que p4a crea para usted, puede incluir en la lista negra ciertos componentes principales. Por defecto, p4a
agregará python con baterías incluidas como se esperaría en el escritorio, incluidos openssl, sqlite3 y otros componentes que quizás no use.

Para incluir en la lista negra un elemento, especifique la opción --blacklist-requirements:

p4a apk ... --blacklist-requirements=sqlite3

Por el momento, los siguientes componentes principales se pueden incluir en la lista negra (si no desea usarlos) para reducir el tamaño del APK:

• android deshabilita el módulo android de p4a (consulte android para acceder a la API de Android)

• libffi deshabilita el módulo ctypes stdlib

• openssl deshabilita el módulo stdlib de ssl

• sqlite3 deshabilita el módulo stdlib de sqlite3

1.3 Comandos

Esta página documenta todos los comandos y opciones que se pueden pasar a toolchain.py.

1.3.1 Índice de comandos

Los comandos disponibles son los métodos de la clase ToolchainCL, documentados a continuación. Pueden tener sus propias opciones, o siempre puede
pasar argumentos generales o argumentos de distribución a cualquier comando (aunque si son irrelevantes, es posible que no tengan ningún efecto).

1.3.2 Argumentos generales

Estos argumentos se pueden pasar a cualquier comando para modificar su comportamiento, aunque no todos los comandos los utilizan.

--debug Imprime información adicional de depuración sobre la compilación, incluidos todos los resultados de la compilación.

--sdk_dir La ruta del archivo donde está instalado el SDK de Android. Esto se puede configurar alternativamente de varias otras maneras.

--android_api El nivel de API de Android al que apuntar; python-for-android verificará si las herramientas de la plataforma para este nivel
están instalados.

--ndk_dir La ruta del archivo donde está instalado el NDK de Android. Esto se puede configurar alternativamente de varias otras maneras.

--ndk_version La versión del NDK instalada, importante porque las rutas de archivo internas para compilar herramientas dependen de esto. Esto se puede
configurar alternativamente de varias otras maneras, o si su directorio NDK contiene un RELEASE.TXT que contiene la versión, esto se verifica
automáticamente para que no necesite configurarlo manualmente.

1.3.3 Argumentos de distribución

p4a admite varios argumentos utilizados para especificar qué distribución compilada de Android desea utilizar. Puede pasar cualquiera de estos argumentos
a cualquier comando, y si se requiere una distribución, se usarán para cargar, compilar o descargar esto según sea necesario.

Ninguna de estas opciones es imprescindible, y en principio solo tienes que aportar las que necesites.

1.3. Comandos 13
Machine Translated by Google

Documentación de Python para Android, versión 0.1

--name NOMBRE El nombre de la distribución. Solo se puede crear una distribución con un nombre determinado.

--requisitos LISTA DE REQUISITOS Las recetas que debe contener su distribución, como una lista separada por comas. Estos deben ser nombres
de recetas o los nombres pypi de los módulos de Python.

--force-build BOOL Si la distribución se debe compilar desde cero.

--arch La arquitectura para construir. Puede especificar varias arquitecturas para construir al mismo tiempo. Como ejemplo, p4a ... --arch arm64-v8a --
arch armeabi-v7a ... construirá una distribución para arm64-v8a y armeabi-v7a.

--bootstrap BOOTSTRAP El programa de arranque de Java que se utilizará para su aplicación. En su mayoría, no necesita preocupar se por esto o
configurarlo manualmente, ya que se elegirá un arranque adecuado de sus requisitos. Las opciones actuales son sdl2 (usado con Kivy y la
mayoría de las otras aplicaciones) o webview.

Nota: Estas opciones son preliminares. Otros incluirán conmutadores para permitir descargas y configurar directorios adicionales desde los cuales
cargar dists de usuario.

1.4 Trabajando en Android

Esta página brinda detalles sobre cómo acceder a las API de Android y administrar otras interacciones en Android.

1.4.1 Rutas de almacenamiento

Si desea almacenar y recuperar datos, no debe simplemente guardarlos en el directorio actual, y no codificar /sdcard/ o alguna otra ruta, ya que puede
diferir según el dispositivo.

En cambio, el módulo de Android que puede agregar a sus requisitos le permite consultar las rutas más comúnmente requeridas:

desde android.storage import app_storage_path settings_path =

app_storage_path()

desde android.storage importar

ruta_almacenamiento_externo_primario_almacenamiento_externo_primario = ruta_almacenamiento_externo_principal()

de android.storage importar ruta_de_almacenamiento_externa_secundaria_almacenamiento_externo

= ruta_de_almacenamiento_externa_secundaria()

app_storage_path() le brinda el llamado "almacenamiento interno" de Android, que es específico de su aplicación y no puede ser visto por otros ni por
el usuario. Se compara mejor con el directorio AppData en Windows.

primary_external_storage_path() devuelve el llamado "almacenamiento externo principal" de Android, que a menudo se encuentra en /sdcard/ y
potencialmente accesible para cualquier otra aplicación. Se compara mejor con el directorio Documentos en Windows. Requiere Permis
sion.WRITE_EXTERNAL_STORAGE para leer y escribir.

secondary_external_storage_path() devuelve el llamado "almacenamiento externo secundario" de Android, que a menudo se encuentra en /storage/
External_SD/. Se compara mejor con un disco externo conectado a una PC de escritorio y, después de reiniciar el dispositivo, puede volverse
inaccesible si se quita. Requiere Permission.WRITE_EXTERNAL_STORAGE para leer y escribir.

Advertencia: Incluso si la ruta_almacenamiento_externo_secundario devuelve una ruta, es posible que la tarjeta SD externa aún no esté presente.
Solo los contenidos que no están vacíos o una escritura exitosa indican que lo es.

14 Capítulo 1. Contenidos
Machine Translated by Google

Documentación de Python para Android, versión 0.1

Lea más sobre todos los diferentes tipos de almacenamiento y para qué usarlos en la documentación de Android:

https://developer.android.com/training/data-storage/files

Una nota sobre los permisos

Solo se puede acceder siempre al almacenamiento interno sin permisos adicionales. Para el almacenamiento externo primario y secundario, debe
obtener Permission.WRITE_EXTERNAL_STORAGE y el usuario puede negarlo. Además, si lo obtiene, es posible que ambas formas de
almacenamiento externo solo permitan que su aplicación escriba en las carpetas preexistentes comunes como "Música", "Documentos", etc.
(consulte los documentos de Android vinculados anteriormente para obtener más detalles)

1.4.2 Permisos de tiempo de ejecución

Con el nivel de API> = 21, deberá solicitar permisos de tiempo de ejecución para acceder a la tarjeta SD, la cámara y otras cosas.

Esto se puede hacer a través del módulo de Android que está disponible de forma predeterminada a menos que lo incluya en la lista negra. Úselo en su aplicación de
esta manera:

from android.permissions import request_permissions, Permiso

request_permissions([Permission.WRITE_EXTERNAL_STORAGE])

Los permisos disponibles se enumeran aquí:

https://developer.android.com/reference/android/Manifest.permission

1.4.3 Otras tareas comunes

Descartar la pantalla de bienvenida

Con el arranque de SDL2, la pantalla de inicio de la aplicación puede estar visible más tiempo del necesario (con su aplicación ya c argada) debido a una
limitación en la forma en que verificamos si la aplicación se inició correctamente. En este caso, la pantalla de inicio se superpone a la interfaz gráfica de
usuario de la aplicación durante un breve período de tiempo.

Para descartar la pantalla de carga explícitamente en su código, use el módulo de Android:

desde android import loadingscreen

loadingscreen.hide_loading_screen()

Puede llamarlo, por ejemplo, usando kivy.clock.Clock.schedule_once para ejecutarlo en el primer marco activo de su aplicación, o usar el método
de compilación de la aplicación.

Manejo del botón Atrás

Los teléfonos Android siempre tienen un botón Atrás, que los usuarios esperan que realice una función adecuada en la aplicación. Si no lo
maneja, las aplicaciones de Kivy se cerrarán y parecerán haberse bloqueado.

En bootstraps SDL2, el botón Atrás aparece como la tecla de escape (código clave 27, punto de código 270). Puede manejar esta tecla para
realizar acciones cuando se presiona.

Por ejemplo, en su clase de aplicación en Kivy:

1.4. Trabajando en Android 15

Machine Translated by Google

Documentación de Python para Android, versión 0.1

desde kivy.core.window ventana de importación

clase YourApp (aplicación):

def construir (uno mismo):

Window.bind(on_keyboard=self.key_input) return Widget() # su
widget raíz aquí como de costumbre

def key_input(self, window, key, scancode, codepoint, modifier): if key == 27: return True # anula el
comportamiento
predeterminado else:
# la tecla ahora no hace nada
falso retorno

Pausar la aplicación

Cuando el usuario sale de una aplicación, Android la pausa automáticamente, aunque tiene unos segundos para almacenar datos, etc., si es necesario. Una vez
pausada, no hay garantía de que su aplicación vuelva a ejecutarse.

Con Kivy, agregue un método on_pause a su clase de aplicación, que devuelve True:

def on_pause(auto):
volver verdadero

Con el arranque webview, la pausa debería funcionar automáticamente.

Bajo SDL2, puede manejar los eventos apropiados (ver SDL_APP_WILLENTERBACKGROUND, etc.).

Resultado de la actividad de observación

El PythonActivity predeterminado tiene un patrón de observador para onActivityResult y en NewIntent.

android.actividad.bind(nombre del evento=devolución de llamada, ...)

Esto le permite vincular una devolución de llamada a un evento de Android: - on_new_intent es el evento asociado a la llamada java onNewIntent -

on_activity_result es el evento asociado a la llamada java onActivityResult

Advertencia: este método no es seguro para subprocesos. Llámalo en el subproceso principal de tu apl icación. (consejos: use el decorador
kivy.clock.mainthread)

android.actividad.unbind(nombre del evento=devolución de llamada, ...)

Anule el registro de una devolución de llamada previamente registrada con bind().

Ejemplo:

# Este ejemplo es un fragmento de una aplicación NFC p2p implementada con Kivy.

de la actividad de importación de Android

def on_new_intent(self, intent):

si intent.getAction() != NfcAdapter.ACTION_NDEF_DISCOVERED:
devolver
rawmsgs = intent.getParcelableArrayExtra(NfcAdapter.EXTRA_NDEF_MESSAGES) si no rawmsgs: volver

(continúa en la página siguiente)

dieciséis
Capítulo 1. Contenidos
Machine Translated by Google

Documentación de Python para Android, versión 0.1

(Continuación de la página anterior)

para mensaje en rawmsgs:

mensaje = cast(NdefMessage, mensaje) payload =
mensaje.getRecords()[0].getPayload() print('payload: {}'.format(''.join(map(chr,
payload))))

def nfc_enable(self):
actividad.bind(on_new_intent=self.on_new_intent) # ...

def nfc_disable(auto):
actividad.unbind(on_new_intent=self.on_new_intent) # ...

Gestión del ciclo de vida de la actividad

La clase de aplicación de Android proporciona ActivityLifecycleCallbacks interfaz donde se pueden registrar las devoluciones de llamada
correspondientes al ciclo de vida de la actividad cambios. Estas devoluciones de llamada se pueden usar para implementar la lógica en la aplicación
de Python cuando la actividad cambia de estado del ciclo de vida.

Tenga en cuenta que algunas de las devoluciones de llamada no son útiles en la aplicación de Python. Por ejemplo, nunca se ejecutará una devolución de
llamada onActivityCreated ya que la devolución de llamada onCreate de la actividad se completará antes de que se ejecute la aplicación de Python. Del
mismo modo, guardar el estado de la instancia en una devolución de llamada onActivitySaveInstanceState no será útil, ya que la aplicación de Python no
tiene acceso al estado de la instancia restaurada.

android.actividad.registrar_actividad_ciclo_de_vida_llamadas(nombre de devolución de llamada=devolución de llamada, ...)

Esto le permite vincular devoluciones de llamada a los cambios de estado del ciclo de vida de la actividad. Los nombres de de volución de
llamada corresponden a los nombres de métodos de ActivityLifecycleCallbacks, como onActivityStarted. Ver la ActividadCiclo de
vidaDevoluciones de llamada documentación para nombres y firmas de funciones para las devoluciones de llamada.

android.activity.unregister_activity_lifecycle_callbacks(instancia) anteriormente
Anule el registro de una instancia de ActivityLifecycleCallbacks registrado con
register_activity_lifecycle_callbacks().

Ejemplo:

desde android.actividad importar register_activity_lifecycle_callbacks

def on_activity_stopped(actividad): print('La actividad se

está deteniendo')

registrarse_actividad_ciclo_de_vida_llamadas(
onActivityStopped=en_actividad_detenida,
)

Recibir mensaje de difusión

Implementación de Android BroadcastReceiver. Puede especificar la devolución de llamada que recibirá el evento de transmisión y
filtros de acciones o categorías.
clase android.broadcast.BroadcastReceiver

1.4. Trabajando en Android 17

Machine Translated by Google

Documentación de Python para Android, versión 0.1

Advertencia: la devolución de llamada se llamará en otro hilo que no sea el hilo principal. En ese hilo, tenga cuidado de no acceder a
OpenGL o algo así.

init (devolución de llamada, acciones=Ninguna, categorías=Ninguna)

Parámetros

• devolución de llamada : función o método que recibirá el evento. Recibirá el contexto y

intención como argumento.

• acciones : lista de cadenas que representan una acción.

• categorías : lista de cadenas que representan una categoría.

Para acciones y categorías, la cadena debe estar en minúsculas, sin el prefijo:

# En java: Intent.ACTION_HEADSET_PLUG # En python:

'headset_plug'

comenzar()
Registre el receptor con todas las acciones y categorías, y comience a manejar eventos.

detener()
Cancele el registro del receptor con todas las acciones y categorías, y deje de manejar eventos.

Ejemplo:

clase TestApp(Aplicación):

def build(self): self.br =

BroadcastReceiver(
self.on_broadcast, actions=['headset_plug']) self.br.start() # ...

def on_broadcast(yo, contexto, intención):

extras = intent.getExtras() headset_state =
bool(extras.get('state')) if headset_state: print('El auricular está
conectado') else:

print('El auricular está desenchufado')

# No olvide detener y reiniciar el receptor cuando la aplicación vaya # al modo de pausa/reanudación

def on_pause(self): self.br.stop()

return True

def on_resume(self): self.br.start()

Ejecutable

Runnable es un contenedor alrededor de Java Runnable clase. Esta clase se puede usar para programar una llamada de una función de Python en el
subproceso PythonActivity.

18 Capítulo 1. Contenidos
Machine Translated by Google

Documentación de Python para Android, versión 0.1

Ejemplo:

desde android.runnable import Runnable

def holamundo(arg):
imprimir 'Llamado desde PythonActivity con arg:', arg

Ejecutable(holamundo)('hola')

O usa nuestro decorador:

desde android.runnable import run_on_ui_thread

@run_on_ui_thread def
holamundo(arg):
imprimir 'Llamado desde PythonActivity con arg:', arg

holamundo('arg1')

Esto se puede utilizar para evitar errores como:

• W/System.err( 9514): java.lang.RuntimeException: no se puede crear un controlador dentro del hilo que no ha llamado
Looper.prepare()

• NullPointerException en ActivityThread.currentActivityThread()

Advertencia: debido a que la función python se llama desde el subproceso PythonActivity, debe tener cuidado con sus propias llamadas.

1.4.4 Uso avanzado de la API de Android

Android para acceder a la API de Android

Como se mencionó anteriormente, el módulo Python de Android proporciona un contenedor simple para muchas API nativas de Android, y se incluye
de forma predeterminada a menos que lo incluya en la lista negra.

La funcionalidad disponible de este módulo no se documenta por separado. Puedes leer la fuente en Github.

También tenga en cuenta que puede replicar la mayoría de las funciones sin usar pyjnius. (vea abajo)

Plyer: un envoltorio de API más completo

Plyer proporciona un contenedor más completo que Android para un área mucho más grande de API específicas de la plataforma, que admite no
solo Android sino también iOS y sistemas operativos de escritorio. (Aunque Plyer es un trabajo en progreso y no todas las plataformas admiten
todas las llamadas de Plyer todavía)

Plyer aún no es compatible con todas las API, pero siempre puede usar Pyjnius para llamar a cualquier cosa que falte actualmente.

Puede incluir Plyer en sus APK agregando la receta de Plyer a sus requisitos de compilación, por ejemplo, --requirements=plyer.

Debe consultar la documentación de Plyer para obtener detalles de todas las fachadas admitidas (API de plataforma), pero como ejemplo, el
siguiente es cómo lograría la vibración como se describe en la sección Pyjnius anterior:

from plyer.vibrator import vibrate vibrate(10) # en Plyer, el

argumento es en segundos

1.4. Trabajando en Android 19

Machine Translated by Google

Documentación de Python para Android, versión 0.1

¡Esto es obviamente mucho menos detallado que con Pyjnius!

Pyjnius: acceso a la API sin formato de bajo nivel

Pyjnius le permite llamar a la API de Android directamente desde Python. Pyjnius funciona envolviendo dinámicamente las clases de Java, por lo
que no tiene que esperar a que ninguna función en particular sea compatible previamente.

Esto es particularmente útil cuando Android y Plyer aún no brindan un acceso conveniente a la API, o si necesita más control.

Puede incluir Pyjnius en sus APK agregando pyjnius a sus requisitos de compilación, por ejemplo, --requirements=flask,pyjnius. Se incluye
automáticamente en cualquier APK que contenga Kivy, en cuyo caso no es necesario especificarlo manualmente.

El mecanismo básico de Pyjnius es el comando autoclass, que envuelve una clase Java. Por ejemplo, aquí está el código para ha cer vibrar su
dispositivo:

de jnius importar autoclase

# Necesitamos una referencia a la actividad de Java que ejecuta la # aplicación actual, esta referencia se
almacena automáticamente por
# Arranque PythonActivity de Kivy

# Este funciona con SDL2

PythonActivity = autoclase('org.kivy.android.PythonActivity')

actividad = PythonActivity.mActivity

Contexto = autoclase('android.content.Context')
vibrador = actividad.getSystemService(Context.VIBRATOR_SERVICE)

vibrator.vibrate(10000) # el argumento está en milisegundos

Las cosas a tener en cuenta aquí son:

• La clase que debe envolverse depende del bootstrap. Esto se debe a que Pyjnius está utilizando el código fuente de java del p rograma de
arranque para obtener una referencia a la actividad actual, que el programa de arranque almacena en la variable estática mAct ivity. Esta
diferencia no siempre es importante, pero es importante conocerla.

• El código sigue de cerca la API de Java: este es exactamente el mismo conjunto de llamadas a funciones que usaría para lograr
lo mismo del código Java.

• Esto es bastante detallado: ¡son muchas líneas para lograr una vibración simple!

Estos enfatizan tanto las ventajas como las desventajas de Pyjnius; puede lograr casi cualquier llamada API con él (aunque la sintaxis a veces es un
poco más complicada, particularmente si se crean clases de Java a partir del código Python), pero no es Pythonic y no es cort o. Estos son problemas
que Plyer, que se explica a continuación, intenta abordar.

Puedes consultar la documentación de Pyjnius para mas detalles.

1.5 Lanzador
Kivy Launcher es una aplicación de Android que puede ejecutar cualquier aplicación Kivy almacenada en la carpeta kivy de la tarjeta SD. Puede
descargar la última versión estable para su dispositivo Android desde Play Store.

El iniciador estable viene con varios paquetes y permisos de Python, generalmente enumerados en la descripción de la tienda.
Esos no siempre son suficientes para que una aplicación se ejecute o incluso se inicie si trabaja con otras dependencias que no están empaquetadas.

20 Capítulo 1. Contenidos
Machine Translated by Google

Documentación de Python para Android, versión 0.1

El Kivy Launcher está diseñado para pruebas rápidas y sencillas. Para algo más avanzado, recomendamos crear su propia APK con python-for-
android.

1.5.1 Edificio
Kivy Launcher está construido usando python-for-android. Para obtener las versiones más recientes de los paquetes, primero debe limpiarlos,
de modo que el empaquetador no tome un paquete antiguo (almacenado en caché) en lugar de uno nuevo.

p4a clean_download_cache requisitos p4a clean_dists &&

p4a clean_builds p4a apk --requirements=requisitos \

--permission PERMISO \ --
package=the.package.name \ --
name="Nombre de la
aplicación" \ --version=xyz
\ --android_api XY \ --
bootstrap=sdl2 \ --launcher \

--minsdk 13

Nota: –minsdk 13 es necesario para la nueva cadena de herramientas; de lo contrario, podrá ejecutar aplicaciones solo en orientación horizontal.

Advertencia: No use ninguno de los argumentos –private, –public, –dir u otros para agregar main.py o main.pyc a la aplicación. El argumento
–launcher está por encima de ellos y le dice al p4a que cree la versión del lanzador del APK.

1.5.2 Uso
Una vez que el iniciador está instalado, debe crear una carpeta en su directorio de almacenamiento externo (p. ej., /storage/emulated/0 o /
sdcard); normalmente, este es su directorio de "inicio" en un explorador de archivos. Cada nueva carpeta dentro de kivy representa una
aplicación separada:

/sdcard/kivy/<suaplicación>

Cada carpeta de la aplicación debe contener un archivo android.txt. El archivo debe contener tres líneas básicas:

title=<Título de la aplicación>
author=<Su nombre>
orientación=<retrato|paisaje>

El archivo es editable, por lo que puede cambiar, por ejemplo, la orientación o el nombre. Estas son las únicas opciones configurables
dinámicamente aquí, aunque cuando se ejecuta la aplicación, puede llamar a la API de Android con PyJNIus para cambiar otras configuraciones.

Después de configurar su archivo android.txt, ahora puede ejecutar el iniciador e iniciar cualquier aplicación disponible de la lista.

Para diferenciar entre aplicaciones en /sdcard/kivy, puede incluir un ícono llamado icon.png en la carpeta. El icono debe ser un cuadrado.

1.5. Lanzacohetes 21
Machine Translated by Google

Documentación de Python para Android, versión 0.1

1.5.3 Lanzamiento al mercado

Launcher se lanza en Google Play con cada nueva rama estable de Kivy. La rama maestra no es adecuada para un usuario normal porque cambia
rápidamente y necesita pruebas.

1.5.4 Código fuente

Si te sientes seguro, no dudes en mejorar el lanzador. Puede encontrar el código fuente en |renpy|_ o en |kivy|_.

1.6 integración de distutils/setuptools

1.6.1 Hacer que p4a apk ejecute setup.py (reemplaza --requirements)

Si su proyecto tiene un archivo setup.py, p4a puede ejecutarlo cuando su aplicación esté empaquetada de manera que su aplicac ión termine
correctamente en los paquetes del sitio empaquetados. (Use --use-setup-py para habilitar esto, --ignore-setup-py para evitarlo)

Esta es la funcionalidad para ejecutar setup.py DENTRO de 'p4a apk', a diferencia de la otra sección a continuación, que trata sobre la ejecución
de p4a dentro de setup.py.

Sin embargo, esto tiene estas advertencias:

• ¡ Solo su ''main.py'' de los datos ''–privados'' de su aplicación se copia en el .apk! Todo lo demás necesita
ser instalado por su setup.py en los paquetes del sitio, o no será empaquetado.

• Todas las dependencias que se asignan a recetas solo se pueden fijar a versiones exactas, todas las demás restricciones simplemente no funcionarán
o incluso causarán errores de compilación. (Lo sentimos, nuestro procesamiento interno no es lo suficientemente inteligente como para respetarlos
correctamente en este punto)

• El análisis de dependencia al principio puede ser bastante lento y retrasar su compilación

Razones por las que querría usar un archivo setup.py para ser procesado (y omitir especificar --requisitos):

• Desea utilizar un mecanismo más estándar para especificar dependencias en lugar de --requisitos

• Ya usas un setup.py para otras plataformas

• Su aplicación se importa a sí misma de una manera que no funcionará a menos que esté instalada en los paquetes del sitio)

Razones para no usar setup.py (es decir, usar el mecanismo --requirements habitual en su lugar):

• Todavía no usa un archivo setup.py y prefiere la simplicidad de solo especificar --requirements

• Su setup.py asume una plataforma de escritorio y extrae dependencias incompatibles con Android, y no está dispuesto a cambiar esto, o
desea mantenerlo separado de la implementación de Android por otras razones organizativas

• Necesita tener archivos de datos que no estén instalados por su setup.py en la carpeta de paquetes del sitio

1.6.2 Usa tu setup.py para llamar a p4a

En lugar de ejecutar p4a a través de la línea de comando, puede llamarlo a través de setup.py integrándolo con distutils y setup.py.

Esta es la funcionalidad para ejecutar p4a DENTRO de setup.py, a diferencia de la otra sección anterior, que se trata de ejecutar setup.py dentro
de 'p4a apk'.

El comando básico es:

22 Capítulo 1. Contenidos
Machine Translated by Google

Documentación de Python para Android, versión 0.1

python setup.py apk

Los archivos incluidos en el APK serán todos los especificados en el argumento package_data para configurar. Por ejemplo, el siguiente
ejemplo incluirá todos los archivos .py y .png en la carpeta testapp:

desde distutils.core importar configuración desde

setuptools importar find_packages

setup( name='testapp_setup',
version='1.1',
description='p4a setup.py ejemplo', author='Su nombre',

author_email='sucorreo@dirección.com',
packages=buscar_paquetes(),
options=opciones ,
paquete_datos={'aplicación de prueba': ['*.py', '*.png']}
)

El nombre y la versión de la aplicación también se leerán automáticamente desde setup.py.

El nombre del paquete de Android usa org.test.lowercaseappname si no se establece explícitamente.

El argumento --private se establece automáticamente usando el paquete_datos. No debe configurar esto manualmente.

La arquitectura de destino predeterminada es --armeabi.

Todos estos argumentos automáticos se pueden anular pasándolos manualmente en la línea de comando, por ejemplo:

python setup.py apk --name="Configuración de la aplicación de prueba" --version=2.5

Agregar argumentos p4a en setup.py

En lugar de proporcionar argumentos adicionales en la línea de comandos, puede almacenarlos en setup.py pasando el parámetro de
opciones a setup. Por ejemplo:

desde distutils.core importar configuración desde

setuptools importar find_packages

options = {'apk': {'debug': None, # use None para argumentos que no pasan un valor 'requirements': 'sdl2,pyjnius,kivy,python3',
'android-api': 19, 'ndk -dir': '/ruta/a/ndk', 'nombre-dist': 'bdisttest', }}

paquetes = find_packages() print('los

paquetes son', paquetes)

setup( name='testapp_setup',
version='1.1',
description='p4a setup.py ejemplo', author='Tu nombre',

author_email='sucorreo@dirección.com',
packages=buscar_paquetes(),
options=opciones,
(continúa en la página siguiente)

1.6. integración de distutils/setuptools 23

Machine Translated by Google

Documentación de Python para Android, versión 0.1

(Continuación de la página anterior)

package_data={'aplicación de prueba': ['*.py', '*.png']}

)

Estas opciones se incluirán automáticamente cuando ejecute python setup.py apk. Cualquier opción pasada en la línea de comando anulará
estos valores.

Adición de argumentos p4a en setup.cfg

También puede proporcionar argumentos p4a en el archivo setup.cfg, como es normal para distutils. La sintaxis es:

[apk]

argumento=valor

requisitos = sdl2, kivy

1.7 Recetas
Esta página describe cómo funcionan las recetas de compilación de Python para Android (p4a) y cómo crear las suyas propias. Si solo desea
crear un APK, ignore esto y salte directamente a Primeros pasos.

Las recetas son scripts especiales para compilar e instalar diferentes programas (incluidos los módulos de Python) en una distribución p4a.
Son necesarios para encargarse de la compilación de cualquier componente compilado, ya que estos deben compilarse para Android con la
arquitectura correcta.

python-for-android viene con muchas recetas para módulos populares. No se necesita ninguna receta para los módulos de Python que no
tienen componentes compilados; estos se instalan automáticamente a través de pip. Si es nuevo en la creación de recetas, se recomienda que
primero lea toda esta página, al menos hasta la documentación de referencia de Recetas. Las diferentes secciones de r ecetas incluyen una
serie de ejemplos de cómo se construyen o anulan las recetas para propósitos específicos.

1.7.1 Crear su propia receta

La documentación de referencia formal de la clase de receta se puede encontrar en la sección de clase de receta y más abajo.

Consulte la sección de plantillas de recetas para ver una plantilla que combina todas estas ideas, en la que puede reemplazar los componentes
que desee.

La declaración básica de una receta es la siguiente:

clase TuReceta(Receta):

url = 'http://ejemplo.com/ejemplo-{versión}.tar.gz' versión = '2.0.3'

md5sum = '4f3dc9a9d857734a488bcbefd9cd64ed'

patches = ['some_fix.patch'] # Rutas relativas al directorio de la receta

depende = ['kivy', 'sdl2'] # Estos son solo ejemplos conflictos = ['generickndkbuild']

receta = TuReceta()

24 Capítulo 1. Contenidos
Machine Translated by Google

Documentación de Python para Android, versión 0.1

Consulte la documentación de la clase de receta para obtener información completa sobre cada parámetro.

Estas opciones principales son vitales para todas las recetas, aunque la URL puede omitirse si la fuente se carga de algún otro modo.

Debe incluir receta = YourRecipe(). Se accede a esta variable cuando se importa la receta.

Nota: la URL incluye la etiqueta {version}. Solo debe acceder a la URL con la propiedad versioned_url, que reemplaza esto con el atributo de
versión.

El proceso de construcción real se lleva a cabo a través de tres métodos principales:

def prebuild_arch(self, arch):

super().prebuild_arch(arch)
# Hacer cualquier pre-inicialización

def build_arch(self, arch):

super().build_arch(arco)
# Construir la receta principal

def postbuild_arch(self, arch): super().build_arch(arch)

# Haga cualquier aclaración

Estos métodos siempre se ejecutan en el orden indicado; preconstruir, luego construir, luego postconstruir.

Si definió una URL para su receta, no necesita descargarla manualmente, esto se maneja automáticamente.

La receta se compilará automáticamente en un directorio de compilación aislado especial, al que puede acceder usted mismo.
get_build_dir(arch.arch). Solo debe trabajar dentro de este directorio. Puede ser conveniente usar el administrador de contexto current_directory
definido en toolchain.py:

de pythonforandroid.toolchain importar directorio_actual def build_arch(self, arch):

super().build_arch(arch) with
current_directory(self.get_build_dir(arch.arch)): with open('example_file.txt', 'w') as fileh:

fileh.write('Esto se escribe en un archivo dentro del directorio de compilación')

El argumento de cada método, arch, es un objeto relacionado con la arquitectura para la que se está construyendo actualmente. En su mayoría,
puede ignorarlo, aunque es posible que deba usar el nombre de arco arch.arch.

Nota: También puede implementar versiones específicas de arquitectura de cada método, que son llamadas (si existen) por la superclase, por
ejemplo, def prebuild_armeabi(self, arch).

Este es el núcleo de lo que se necesita para escribir una receta, pero no cubre ninguno de los detalles de cómo uno realmente escribe código para
compilar para Android. Esto se cubre en las siguientes secciones, incluidos los mecanismos estándar utilizados como parte de la compilación y los
detalles de las clases de recetas específicas para Python, Cython y algunas recetas compiladas genéricas. Si su módulo es uno de estos últimos,
debe usar estas clases posteriores en lugar de volver a implementar la funcionalidad desde cero.

1.7.2 Métodos y herramientas para ayudar con la compilación

Aplicación de parches a los módulos antes de la instalación

Puede aplicar fácilmente parches a sus recetas agregándolos a la declaración de parches, por ejemplo:

1.7. Recetas 25
Machine Translated by Google

Documentación de Python para Android, versión 0.1

parches = ['alguna_corrección.parche',
'otra_corrección.parche']

Las rutas deben ser relativas al archivo de receta. Los parches se aplican automáticamente solo una vez (es decir, no se vuel ven a aplicar la segunda
vez que se ejecuta python-for-android).

También puede usar las funciones de ayuda en pythonforandroid.patching para aplicar parches según ciertas condiciones, por ejemplo:

desde pythonforandroid.patching import will_build, is_arch

...

clase TuReceta(Receta):

parches = [('x86_patch.patch', is_arch('x86')), ('sdl2_compatibility.patch',

will_build('sdl2'))]

...

Puede incluir sus propias condiciones pasando cualquier función como la segunda entrada de la tupla. Recibirá el arco (por ejemplo, x86, armeabi) y
la receta (es decir, el objeto Receta) como kwargs. El parche se aplicará solo si la función devuelve True.

Instalación de bibliotecas

Algunas recetas generan archivos .so que deben copiarse manualmente en el proyecto de Android. Puede usar un código como el siguiente para
lograr esto, copiándolo en el directorio de caché de lib correcto:

def build_arch(self, arch):

do_the_build() # por ejemplo, ejecutando ./configure y make

import shutil
shutil.copyfile('a_generated_binary.so',
self.ctx.get_libs_dir(arch.arch))

Todas las bibliotecas copiadas en este directorio se incluirán automáticamente en el directorio de bibliotecas correspondiente del proyecto de Android generado.

Compilando para la arquitectura de Android

Al realizar cualquier compilación, es fundamental hacerlo con las variables de entorno adecuadas configuradas, asegurándose d e que las bibliotecas
de Android estén correctamente vinculadas y que el objetivo de la compilación sea la arquitectura correcta.

Puede obtener un diccionario de variables de entorno adecuadas con el método get_recipe_env. Debe asegurarse de configurar es te entorno para
cualquier proceso al que llame. Es conveniente hacerlo usando el módulo sh de la siguiente manera:

def build_arch(self, arch):

super().build_arch(arch) env =
self.get_recipe_env(arch) sh.echo('$PATH',
_env=env) # Imprimirá la entrada PATH desde el
# dictamen env

También puede usar la función auxiliar de shprint del módulo de cadena de herramientas p4a, que imprimirá información sobre el proceso y su estado
actual:

26 Capítulo 1. Contenidos
Machine Translated by Google

Documentación de Python para Android, versión 0.1

de pythonforandroid.toolchain import shprint shprint(sh.echo, '$PATH',

_env=env)

También puede anular el método get_recipe_env para agregar nuevas variables env para usar en su receta. Por ejemplo, la
receta de Kivy hace lo siguiente al compilar para SDL2, para decirle a Kivy qué backend usar:

def get_recipe_env(self, arco):

env = super().get_recipe_env(arch) env['USE_SDL2'] =
'1'

env['KIVY_SDL2_PATH'] =
':'.join([ join(self.ctx.bootstrap.build_dir, 'jni', 'SDL', 'include'), join(self.ctx.bootstrap.build_dir, 'jni' ,
'SDL2_image'), join(self.ctx.bootstrap.build_dir, 'jni', 'SDL2_mixer'),
join(self.ctx.bootstrap.build_dir, 'jni', 'SDL2_ttf'), ]) return env

Advertencia: al usar el módulo sh de esta manera, el nuevo env reemplaza completamente el entorno normal, por lo que
debe definir cualquier env vars al que desee acceder.

Incluir archivos con tu receta

El método should_build

La clase Recipe tiene un método should_build, que devuelve un valor booleano. Esto se llama para cada arquitectura antes de
ejecutar build_arch, y si devuelve False, se omite la compilación. Esto es útil para evitar crear una receta más de una vez para
diferentes distribuciones.

De forma predeterminada, should_build devuelve True, pero puede anularlo como desee. Por ejemplo, PythonRecipe y sus
subclases lo reemplazan con una comprobación de si la receta ya está instalada en la distribución de Python:

def should_build(self, arco):

nombre = self.site_packages_name si el nombre
es Ninguno:
nombre = self.nombre
si self.ctx.has_package(nombre):
info('El paquete de Python ya existe en los paquetes del sitio') devuelve Falso

info('{} aparentemente no está ya en los paquetes del sitio'.format(name)) return True

1.7.3 Usar una receta de Python

Si su receta es instalar un módulo de Python sin componentes compilados, debe usar PythonRecipe. Esto anula build_arch para
llamar automáticamente a la instalación normal de python setup.py con un entorno apropiado.

Por ejemplo, lo siguiente es todo lo que se necesita para crear una receta para el módulo Vispy:

desde pythonforandroid.recipe importar la clase PythonRecipe

VispyRecipe(PythonRecipe):
(continúa en la página siguiente)

1.7. Recetas 27
Machine Translated by Google

Documentación de Python para Android, versión 0.1

(Continuación de la página anterior)

versión = 'maestro'
url = 'https://github.com/vispy/vispy/archive/{versión}.zip'

depende = ['python3', 'numpy']

site_packages_name = 'vispy'

receta = VispyRecipe()

site_packages_name es un nuevo atributo que identifica la carpeta en la que se instalará el módulo en el paquete de Python.
Esto solo es esencial para agregar si el nombre es diferente al nombre de la receta. Se utiliza para comprobar si se puede omitir
la instalación de la receta, que es el caso si la carpeta ya está presente en la instalación de Python.

Como referencia, el código que logra esto es el siguiente:

def build_arch(self, arch):

super().build_arch(arch)
self.install_python_package()

def install_python_package(auto):
'''Automatizar la instalación de un paquete de Python (o un paquete de cython donde los componentes
de cython están preconstruidos).''' arch = self.filtered_archs[0] env = self.get_recipe_env(arch)

info('Instalando {} en los paquetes del sitio'.format(self.name))

con directorio_actual(self.get_build_dir(arch.arch)):
hostpython = sh.Command(self.ctx.hostpython)

shprint(hostpython, 'setup.py', 'instalar', '-O2', _env=env)

Esto combina técnicas y herramientas de la documentación anterior para crear un mecanismo genérico para todos los módulos
de Python.

Nota: hostpython es la ruta al binario de Python que debe usarse para cualquier tipo de instalación. Debe ejecutar Python de
manera similar si necesita hacerlo en cualquiera de sus propias recetas.

1.7.4 Uso de una receta Cython

Si su receta es instalar un módulo de Python que usa Cython, debe usar CythonRecipe. Esto anula build_arch tanto para
compilar los componentes de cython como para instalar el módulo de Python como una PythonRecipe normal.

Por ejemplo, lo siguiente es todo lo que se necesita para hacer una receta de Kivy:

clase KivyRecipe(CythonRecipe): versión = 'estable'

url = 'https://github.com/kivy/kivy/archive/{versión}.zip' nombre = 'kivy'

depende = ['sdl2', 'pyjnius']

receta = KivyReceta()

28 Capítulo 1. Contenidos
Machine Translated by Google

Documentación de Python para Android, versión 0.1

Como referencia, el código que logra esto es el siguiente:

def build_arch(self, arch):

Recipe.build_arch(self, arch) # un truco para evitar llamar a # PythonRecipe.build_arch

self.build_cython_components(arch)
self.install_python_package() # esto es lo mismo que en PythonRecipe

def build_cython_components(self, arch): env =

self.get_recipe_env(arch) with
current_directory(self.get_build_dir(arch.arch)):
hostpython = sh.Command(self.ctx.hostpython)

# Este primer intento *fallará*, porque cython no está # instalado en el hostpython try:
shprint(hostpython, 'setup.py', 'build_ext',

_env=env)
excepto sh.ErrorReturnCode_1:
aprobar

# ...así que ejecutamos cython manualmente desde el sistema del usuario shprint(sh.find,
self.get_build_dir('armeabi'), '-iname', '*.pyx', '-exec',
self.ctx.cython, '{}', ';', _env=env)

# ahora cython ya se ha ejecutado, por lo que la compilación funciona shprint(hostpython,

'setup.py', 'build_ext', '-v', _env=env)

# eliminar los símbolos de depuración reduce mucho el tamaño del archivo build_lib =
glob.glob('./build/lib*') shprint(sh.find, build_lib[0], '-name', '*.o',
'-exec ',
entorno['STRIP'], '{}', ';', _env=env)

La compilación fallida y la citonización manual son necesarias, en primer lugar, para asegurarse de que setup.py haya generado los
archivos .pyx y, en segundo lugar, porque cython no está instalado en la compilación de hostpython.

En realidad, esto puede fallar si setup.py intenta importar cython antes de crear cualquier archivo .pyx (en cuyo caso falla demasiado pronto),
aunque esto probablemente no sea un problema. Si esto le sucede, intente parchear para eliminar esta importación o hacer que falle
silenciosamente.

Aparte de esto, estos métodos siguen las técnicas de la documentación anterior para hacer una receta genérica para la mayoría de los
módulos basados en cython.

1.7.5 Uso de una receta Python de componentes compilados

Esto es similar a CythonRecipe pero está destinado a módulos como numpy que incluyen componentes compilados pero no cython. Utiliza
un mecanismo similar para compilar con el entorno adecuado.

Esto aún no está documentado porque probablemente se cambiará para que CythonRecipe lo herede (para evitar la duplicación de código).

1.7.6 Uso de una receta NDK

Si está escribiendo una receta no para un módulo de Python sino para algo que normalmente iría en el directorio JNI de un proyecto de
Android (es decir, tiene Application.mk y Android.mk que el sistema de compilación de Android puede usar), puede usar un NDKRecipe para
configurarlo automáticamente. NDKRecipe anula el método get_build_dir normal para colocar elementos en el proyecto de Android.

1.7. Recetas 29
Machine Translated by Google

Documentación de Python para Android, versión 0.1

Advertencia: NDKRecipe actualmente no llama a ndk-build, debe agregar esta llamada (para su módulo) creando manualmente un
método build_arch. Esto puede arreglarse más tarde.

Por ejemplo, la siguiente receta es todo lo que se necesita para colocar SDL2_ttf en el directorio jni. Esto se crea más tarde mediante la
receta SDL2, que llama a ndk-build con esto como una dependencia:

clase LibSDL2TTF(NDKReceta):
versión = '2.0.12'
url = 'https://www.libsdl.org/projects/SDL_ttf/release/SDL2_ttf-{version}.tar.gz' dir_name = 'SDL2_ttf'

receta = LibSDL2TTF()

El argumento dir_name es un nuevo atributo de clase que le dice a la receta cuál debe ser el nombre de la carpeta jni dir. Si se omite, se
utiliza el nombre de la receta. Tenga cuidado aquí, a veces el nombre de la carpeta es importante, especialmente si esta carpeta depende
de otra cosa.

1.7.7 Plantilla de receta

La siguiente plantilla incluye todas las secciones de recetas que puede usar. Ninguno es obligatorio, siéntase libre de eliminar las
anulaciones de métodos si no las usa:

desde pythonforandroid.toolchain import Receta, shprint, current_directory desde os.path existe importación , únase a import sh
import glob

clase TuReceta(Receta):
# Esto también podría heredar de PythonRecipe, etc. si desea # usar sus procesos de compilación escritos
previamente

version = 'some_version_string' url = 'http://example.com/

example-{version}.tar.gz' # {version} se reemplazará con self.version al descargar

depende = ['python3', 'numpy'] # Una lista de otros nombres de recetas

# que debe construirse antes de este # uno

conflictos = [] # Una lista de nombres de recetas que no se pueden construir # junto con este

def get_recipe_env(self, arco):

env = super().get_recipe_env(arch)
# Manipule el env aquí si quiere devolver el env

def should_build(self, arco):

# Agregue una verificación para ver si la receta ya está construida si # lo desea, y devuelva Falso si lo
está. volver verdadero

def prebuild_arch(self, arch):

super().prebuild_arch(self)
(continúa en la página siguiente)

30 Capítulo 1. Contenidos
Machine Translated by Google

Documentación de Python para Android, versión 0.1

(Continuación de la página anterior)

# Realice cualquier precompilación adicional que desee, por

ejemplo: self.apply_patch('ruta/hacia/parche.parche')

def build_arch(self, arch):

super().build_arch(self)
# Construye el código. Asegúrese de usar el directorio de compilación correcto, por ejemplo, con
current_directory(self.get_build_dir(arch.arch)):
sh.ls('-lathr') # O ejecuta algunos comandos que realmente hacen # algo

def postbuild_arch(self, arch):

super().prebuild_arch(self)
# Haz lo que quieras después de la compilación, p. ej., elimina # archivos innecesarios
como la documentación

receta = TuReceta()

1.7.8 Ejemplos de recetas

Esta documentación cubre la mayor parte de lo que es necesario para que una receta funcione. Para obtener más ejemplos, python-for android
incluye muchas recetas para módulos populares, que son un excelente recurso para descubrir cómo agregar los suyos propios.
Puede encontrarlos en la página de Github de Python para Android.

1.7.9 La clase Receta

La Receta es la clase base para todas las recetas de p4a. La documentación central de esta clase se proporciona a continuación, seguida de una
discusión sobre cómo crear su propia subclase de recetas.

1.8 Arranques
Esta página trata sobre la creación de nuevos backends de arranque. Para conocer las opciones de compilación de los programas de arranque existentes (es decir, con SDL2, Webview, etc.),

consulte las opciones de compilación.

python-for-android (p4a) admite múltiples arranques. Estos cumplen una función similar a las recetas, pero en lugar de describir cómo compilar un
módulo específico, describen cómo se puede armar un proyecto completo de Android a partir de una combinación de recetas indiv iduales y otros
componentes, como el código fuente de Android y varios archivos de compilación.

Esta página describe los conceptos básicos de cómo funcionan los bootstraps para que pueda crear y usar los suyos propios si lo desea, lo que
facilita la creación de nuevos tipos de proyectos de Python para Android.

1.8.1 Crear un nuevo programa de arranque

Una clase de arranque consta de solo unos pocos componentes básicos, aunque uno de ellos debe hacer mucho trabajo.

Por ejemplo, el arranque de SDL2 tiene el siguiente aspecto:

desde pythonforandroid.toolchain import Bootstrap, shprint, current_directory, info, →warning, ArchAndroid, logger, info_main, que
desde os.path import join, existe desde os import walk

(continúa en la página siguiente)

1.8. Bootstraps 31
Machine Translated by Google

Documentación de Python para Android, versión 0.1

(Continuación de la página anterior)

importar glob
importar sh

clase SDL2Bootstrap(Bootstrap):
nombre = 'sdl2'

receta_depende = ['sdl2']

def ejecutar_distribuir(auto):
# mucho trabajo se hace aqui...

La declaración del nombre de arranque y las dependencias de la receta deben ser claras. Sin embargo, el método run_distribute debe hacer
todo el trabajo de crear un directorio de compilación, copiar recetas, etc., y agregar o eliminar cualquier componente adicional según sea
necesario.

Si desea crear un programa de arranque, el mejor recurso es verificar los existentes en el código fuente de p4a. También puede ponerse en
contacto con los desarrolladores si tiene problemas o preguntas.

1.9 Servicios

python-for-android admite el uso de servicios de Android, tareas en segundo plano que se ejecutan en procesos separados. Estos son los
equivalentes de Android más cercanos al multiprocesamiento en, por ejemplo, plataformas de escritorio, y no es posible usar el
multiprocesamiento normal en Android. Los servicios también son la única forma de ejecutar código cuando la aplicación no está abierta actualmente por el
usuario.

Los servicios deben declararse al compilar su APK. Cada uno tendrá su propio archivo main.py con el script de Python para ejecutar. Tenga
en cuenta que python-for-android ejecuta explícitamente los servicios como procesos separados al tener dos puntos ":" al comienzo del
nombre asignado al atributo android:process del archivo AndroidManifest.xml. Este no es el comportamiento predeterminado, consulte la
documentación del servicio de Android. Puede comunicarse con el proceso de servicio desde su aplicación usando, por ejemplo, osc o (una
opción más pesada) torcido.

1.9.1 Creación de servicios

Hay dos formas de incluir servicios en tu APK.

Carpeta de servicio

Este es el método más antiguo de manejar servicios. Se recomienda utilizar el segundo método (a continuación) siempre que sea posible.

Cree una carpeta llamada servicio en el directorio de su aplicación y agregue un archivo service/main.py. Este archivo debe contener el
código de Python que desea que ejecute el servicio.

Para iniciar el servicio, use la función start_service del módulo de Android (es posible que deba agregar Android a los requisitos de su
aplicación):

import android
android.start_service(title=' nombre del servicio',
description=' descripción del servicio', arg='argumento del
servicio')

32 Capítulo 1. Contenidos
Machine Translated by Google

Documentación de Python para Android, versión 0.1

Scripts de servicio arbitrarios

Este método se recomienda para el uso no trivial de los servicios, ya que es más flexible, admite múltiples servicios y una gama más amplia de
opciones.

Para crear el servicio, cree una secuencia de comandos de python con su código de servicio y agregue un argumento --
service=myservice:PATH_TO_SERVICE_PY al llamar a python-for-android, o en buil dozer.spec, una configuración de services =
myservice:PATH_TO_SERVICE_PY [aplicación].

El nombre de myservice antes de los dos puntos es el nombre de la clase de servicio, a través de la cual interactuará con ella más adelante.

PATH_TO_SERVICE_PY es la ruta relativa al punto de entrada del servicio (como services/myservice.py)

Opcionalmente, puede especificar los siguientes parámetros:

• :primer plano para iniciar un servicio como un servicio de primer plano de Android

• :sticky para iniciar un servicio que el sistema operativo Android reinicia al salir/error

El comando completo con todos los parámetros opcionales incluidos sería: --service=myservice:services/ myservice.py:foreground:sticky

Puede agregar varios argumentos --service para incluir varios servicios, o separarlos con una coma en buil dozer.spec, todo lo cual podrá detener
e iniciar más tarde desde su aplicación.

Para ejecutar los servicios (es decir, iniciarlos desde el código de su aplicación principal), debe usar PyJNIus para interactuar con la clase java
que python-for-android crea para cada uno, de la siguiente manera:

from jnius import autoclass service =

autoclass('your.package.domain.package.name.ServiceMyservice') mActivity =
autoclass('org.kivy.android.PythonActivity').mActivity argument = service.start(mActivity, argument)
''

Aquí, tu.paquete.dominio.paquete.nombre se refiere al identificador de paquete de tu APK.

Si está utilizando buildozer, el identificador se establece mediante los valores de package.name y package.domain en su archi vo buildozer.spec.
El nombre del servicio es ServiceMyservice, donde Myservice es el nombre especificado por uno de los valores de los servicios, pero con la
primera letra en mayúscula.

Si usa python-for-android directamente, el identificador se establece mediante el argumento --package en python-for-android.

El nombre del servicio es ServiceMyservice, donde Myservice es el identificador que se pasó previamente al argumento --service, pero con la
primera letra en mayúscula. También debe pasar el parámetro de argumento incluso si (como aquí) es una cadena vacía. Si lo pasa, el servicio
puede hacer uso de este argumento.

El argumento de servicio está disponible para su servicio a través de la variable de entorno 'PYTHON_SERVICE_ARGUMENT'. Se expone como
una cadena simple, por lo que si desea pasar varios valores, le recomendamos usar el módulo json para codificar y decodificar datos más
complejos.

from os import argumento

ambiental = environ.get('PYTHON_SERVICE_ARGUMENT', '')

Para personalizar el ícono, el título y el texto de la notificación, use tres argumentos opcionales para service.start():

service.start(mActivity, 'small_icon', 'title', 'content' , argumento)

Donde 'small_icon' es el nombre de un recurso mipmap o dibujable de Android, y 'title' y 'content' son cadenas en la notificación.

Los servicios admiten una variedad de opciones e interacciones que aún no se han documentado aquí, pero a las que se puede acceder llamando
a otros métodos de la referencia del servicio.

1.9. Servicios 33
Machine Translated by Google

Documentación de Python para Android, versión 0.1

Nota: El directorio raíz de la aplicación para las importaciones de Python estará en la carpeta raíz de la aplicación incluso si el archivo de servicio está en una subcarpeta.

Para importar desde su carpeta de servicio, debe usar, por ejemplo, import service.module en lugar de import module, si el archivo de servicio
está en la carpeta service/.

Reinicio automático del servicio

Es posible hacer que los servicios se reinicien automáticamente cuando salen llamando a setAutoRestartService(True) en el objeto de servicio.
La llamada a este método debe hacerse dentro del código de servicio:

desde jnius import autoclass PythonService

= autoclass('org.kivy.android.PythonService')
PythonService.mService.setAutoRestartService(Verdadero)

1.10 Solución de problemas

1.10.1 Salida de depuración

Agregue la opción --debug a cualquier comando python-for-android para ver la salida de depuración completa, incluida la salida de todas las
herramientas externas utilizadas en los pasos de compilación y empaquetado.

Si informa un problema por correo electrónico o Discord, generalmente es útil incluir este registro completo, por ejemplo, a través de un pastebin o la esencia de
Github .

1.10.2 Obtener ayuda

python-for-android es administrado por la Organización Kivy, y puede obtener ayuda con cualquier problema utilizando los mismos canales que
Kivy:

• por correo electrónico al grupo de usuarios de kivy de Google

• en el canal #support Discord

Si encuentra un error, también puede publicar un problema en la página de Python para Android Github.

1.10.3 Depuración en Android

Cuando un APK de Python para Android no funciona, a menudo la única indicación que recibe es que se cierra. Es importante poder averiguar
qué salió mal.

python-for-android redirige stdout y stderr de Python a la secuencia logcat de Android. Puede ver esto habilitando el modo desarrollador en su
dispositivo Android, habilitando adb en el dispositivo, conectándolo a su PC (debería ver una notificación de que la depuración USB está
conectada) y ejecutando adb logcat. Si adb no está en su RUTA, puede encontrarlo en /path/to/Android/SDK/platform-tools/adb, o acceder a él a
través de python-for-android con el acceso directo:

Logcat de Python para Android

o:

34 Capítulo 1. Contenidos
Machine Translated by Google

Documentación de Python para Android, versión 0.1

python-para-android adb logcat

Ejecutar el comando logcat brinda mucha información sobre lo que está haciendo Android. Por lo general, puede ver las líneas importantes
usando la funcionalidad integrada de logcat para ver solo líneas con la etiqueta python (o simplemente grepping esto).

Cuando su aplicación falla, verá el rastreo normal de Python aquí, así como la salida de cualquier declaración de impresión, etc.
que ejecuta su aplicación. Utilícelos para diagnosticar el problema de forma normal.

El comando adb pasa sus argumentos directamente a adb, por lo que también puede realizar otras tareas de depuración como
python-for-android adb devices para obtener la lista de dispositivos conectados.

Para obtener más información, consulte los documentos de Android en adb, y en logcat En particular.

1.10.4 Desempaquetar un APK

A veces es útil descomprimir un APK empaquetado para ver qué hay dentro, especialmente al depurar python-for-android.
sí mismo.

Los APK son solo archivos zip, por lo que puede extraer el contenido fácilmente:

descomprimir YourApk.apk

En el nivel superior, siempre contendrá el mismo conjunto de archivos:

$ ls
AndroidManifest.xml clases.dex META-INF resolución

activos liberación YourApk.apk recursos.arsc

Los datos de la aplicación del usuario (código, imágenes, fuentes...) se empaquetan en un único tarball contenido en la carpeta de activos:

$ cd activos
$ ls
privado.tar

private.tar es un tarball que contiene todos sus datos empaquetados. Extraelo:

$ tar xf privado.tar

Esto revelará todos los datos de la aplicación del usuario (los archivos que se muestran a continuación son de la demostración de touchtracer):

$ ls
LÉAME.txt Android.txt icono.png principal.pyc
→ p4a_env_vars.txt partícula.png
privado.tar touchtracer.kv

Debido a que estamos obligados a enviar cosas específicas de ABI en Android App Bundle, la instalación de Python está empaquetada
por separado, ya que (la mayor parte) es específico de ABI.

Por ejemplo, la instalación de Python para arm64-v8a está disponible en lib/arm64-v8a/libpybundle.so

libpybundle.so es un tarball (pero llamado como una biblioteca para los requisitos de empaquetado), que contiene nuestro
_paquete_python:

$ tar xf libpybundle.así
$ cd_python_bundle
$ ls
módulos paquetes de sitio stdlib.zip

1.10. Solución de problemas 35

Machine Translated by Google

Documentación de Python para Android, versión 0.1

1.10.5 Errores comunes

Los siguientes son problemas comunes y soluciones que los usuarios han informado.

AttributeError: el objeto 'AnsiCodes' no tiene el atributo 'LIGHTBLUE_EX'

Esto ocurre si su versión de colorama es demasiado baja, instale la versión 0.3.3 o superior.

Si instala python-for-android con pip o a través de setup.py, esta dependencia debería solucionarse automáticamente.

AttributeError: el objeto 'Contexto' no tiene atributo 'hostpython'

Este es un error conocido en algunas versiones. Para evitarlo, agregue su requisito de python explícitamente, por ejemplo, --
requirements=python3,kivy. Esto también se aplica al usar buildozer, en cuyo caso agregue python3 a sus requisitos de buildozer.spec.

nombre de enlace demasiado largo

Esto puede suceder cuando intenta incluir un nombre de archivo muy largo, lo que normalmente no sucede pero puede ocurrir accidentalmente si
el directorio p4a contiene un directorio .buildozer que no está excluido de la compilación (por ejemplo, si se usó buildozer anteriormente). La
eliminación de este directorio debería solucionar el problema y es deseable de todos modos, ya que no lo quiere en el APK.

El objetivo 19 de la API solicitada no está disponible, instálelo con la herramienta Android SDK

Esto significa que a su SDK le faltan las herramientas de plataforma necesarias. Debe instalar el paquete de plataformas; and roid-19 en su SDK,
utilizando las herramientas de Android o sdkmanager (según la versión del SDK).

Si usa buildozer, esto debería hacerse automáticamente, pero como solución alternativa, puede ejecuta rlos desde ~/.buildozer/android/platform/
android-sdk-20/tools/android.

ModuleNotFoundError: ningún módulo llamado '_ctypes'

No tiene los encabezados libffi disponibles para python-for-android, por lo que debe instalarlos. En Ubuntu y derivados, estos provienen del paquete
libffi-dev.

Después de instalar los encabezados, limpie la compilación (compilaciones limpias p4a, o con buildozer elimine el directorio .buildozer dentro del
directorio de su aplicación) y ejecute python-for-android nuevamente.

SSLError(“No se puede conectar a la URL HTTPS porque el módulo SSL no está disponible”).

Su hostpython3 fue compilado sin soporte SSL. Debe instalar los archivos de desarrollo SSL antes de reconstruir la receta de hostpython3.
Recuerde siempre limpiar la compilación antes de reconstruir (compilaciones limpias p4a, o con buildozer buildozer android cl ean).

En Ubuntu y derivados:

apt install libssl-dev p4a clean

builds # o con: buildozer `buildozer android clean

En macOS:

36 Capítulo 1. Contenidos
Machine Translated by Google

Documentación de Python para Android, versión 0.1

brew install openssl sudo ln

-sfn /usr/local/opt/openssl /usr/local/ssl p4a clean builds # o con: buildozer
`buildozer android clean

1.11 ventana acoplable

Actualmente usamos una compilación en contenedores para probar recetas de Python para Android. Docker admite tres grandes plataformas,
ya sea directamente con el kernel o mediante el uso de VirtualBox sin cabeza y una pequeña distribución para ejecutarse.

Si bien esta no es la forma activa de compilar aplicaciones, si está dispuesto a jugar con el enfoque, puede usar Dockerfile para compilar la
imagen de Docker que usamos para las compilaciones de CI y crear una aplicación de Android con eso en un contenedor. Este enf oque le
permite crear aplicaciones de Android en todas las plataformas compatibles con el motor Docker. Estos pasos asumen que ya tie ne Docker
preinstalado y configurado.

Advertencia: ¡ Este enfoque es muy poco amigable con el espacio! Cuantas más capas (confirmación) o incluso imágenes de Docker
(compilación) cree, más espacio consumirá. Dentro de la imagen de Docker hay Android SDK y NDK + varias dependencias. Dentro de la
diferencia personalizada hecha al construir la distribución, hay otra gran porción de espacio consumido.
Las cosas muy básicas, como una distribución con: CPython 3, herramientas de configuración, Python para el módulo de Android Android,
SDL2 (+ deps), PyJNIus y Kivy ocupan casi 2 GB. ¡Comprueba primero tu espacio libre!

1. Clona el repositorio:

clon de git https://github.com/kivy/python-for-android

2. Cree la imagen con el nombre p4a:

ventana acoplable compilación --tag p4a .

Nota: debe estar en python-for-android para el contexto de compilación de Docker y, opcionalmente, puede usar el indicador --file para
especificar la ruta a la ubicación de Dockerfile.

3. Cree un contenedor a partir de la imagen p4a con la carpeta testapps copiada en la imagen montada en la misma en el repositorio clonado
en el host:

docker run \ --
interactive \ --tty \ --
volume
".../testapps":/home/user/testapps \ p4a sh -c '. venv/bin/activate \ &&
cd testapps \
&& python setup_testapp_python3.py
apk \ --sdk-dir
$ANDROID_SDK_HOME \ --ndk-dir $ANDROID_NDK_HOME'

Nota: en Windows, es posible que deba usar comillas y una barra diagonal para el volumen "/c/Users/. . . /python-para android/testapps”:/
home/usuario/testapps

1.11. Estibador 37
Machine Translated by Google

Documentación de Python para Android, versión 0.1

Advertencia: en Windows, gradlew intentará usar el comando 'bashr', que es el resultado de los finales de línea de Windows. Para eso necesitará
instalar el paquete dos2unix en la imagen.

4. Conserva la distribución que ya creaste (opcional, pero recomendado):

docker commit $(docker ps –last=1 –quiet) my_p4a_dist

5. Busque el archivo .APK en esta ubicación:

ls -lah aplicaciones de prueba

1.12 Desarrollo y contribución

El equipo de Kivy gestiona el desarrollo de python para Android a través de Github.

Los problemas y las solicitudes de extracción son bienvenidos a través del rastreador de problemas integrado.

Siga leyendo para obtener más información sobre cómo gestionamos el desarrollo y los lanzamientos, ¡pero no se preocupe por los detalles! Las solicitudes
de extracción son bienvenidas y nosotros nos ocuparemos del resto.

1.12.1 Modelo de desarrollo

python-for-android se desarrolla utilizando el siguiente modelo:

• La rama maestra siempre representa la última versión estable.

• La rama de desarrollo es la más actualizada con nuevas aportaciones.

• Los lanzamientos ocurren periódicamente y consisten en fusionar la rama de desarrollo actual en la maestra.

Como referencia, esto se basa en un flujo de Git modelo, aunque no lo seguimos religiosamente.

1.12.2 Versión
Las versiones de python para Android actualmente utilizan versiones de calendario. Los números de versión tienen el formato AAAA.MM.DD. Nuestro objetivo
es crear un nuevo lanzamiento cada cuatro semanas, pero también son posibles lanzamientos más frecuentes.

Usamos el control de versiones del calendario porque, en la práctica, los cambios en python para Android a menudo son impulsados por actualizaciones o ajustes
en las herramientas de compilación de Android. Por lo general, es mejor para los usuarios trabajar con la última versión. Tratamos de mantener la compatibilidad
con versiones anteriores incluso cuando los componentes internos están cambiando.

1.12.3 Creación de una nueva versión

Los nuevos lanzamientos siguen estos pasos:

• Cree una nueva versión de rama AAAA.MM.DD basada en la rama de desarrollo. - git pago -b
lanzamiento-AAAA.MM.DD desarrollo

• Cree una solicitud de extracción de Github para fusionar release-YYYY.MM.DD en master.

• Complete todos los pasos en la lista de verificación de lanzamiento y documente esto en la solicitud de extracción (copie la lista de verificación en el PR
texto)

En este punto, espere la aprobación del revisor y concluya cualquier discusión que surja. Para completar el lanzamiento:

38 Capítulo 1. Contenidos
Machine Translated by Google

Documentación de Python para Android, versión 0.1

• Combinar la rama de versión con la rama maestra.

• Combinar también la rama de lanzamiento con la rama de desarrollo.

• Etiquete la confirmación de publicación en maestro, con la etiqueta vYYYY.MM.DD. Incluya un breve resumen de los cambios.

• Las distribuciones de versiones y la carga de PyPI deben ser manejadas por el CI.

• Añadir a la página de lanzamiento de Github (ver, por ejemplo, este ejemplo): - El resumen README de python para Android - Una breve lista de los
principales cambios en esta versión, si los hay - Un registro de cambios que resume las confirmaciones de fusión desde la última versión - El sdist y la(s)
rueda(s) de la versión

Lista de verificación de lanzamiento

- [ ] Verifique que las compilaciones estén pasando - [ ] [Acción

de GitHub] (https://github.com/kivy/python-for-android/actions)
- [ ] Ejecutar las pruebas localmente a través de `tox`: esto realiza algunas pruebas de ejecución prolongada que se →omiten en las acciones
de github.
- [ ] Compile y ejecute la aplicación [on_device_unit_tests](https://github.com/kivy/python-for- →android/tree/master/testapps/
on_device_unit_tests) usando buildozer. Compruebe que →pasan todos.

- [ ] Cree (o descargue acciones de github) y ejecute las siguientes [aplicaciones de prueba] (https:/ →/github.com/kivy/python-for-android/tree/
master/testapps/on_device_unit_tests) para →arch ` armeabi-v7a` y `arm64-v8a`:

- [ ] en_dispositivo_unidad_pruebas
- [ ] `armeabi-v7a` (`cd testapps/on_device_unit_tests && PYTHONPATH=.:../../
→python3 setup.py apk --ndk-dir=<your-ndk-dir> --sdk-dir=<your-sdk-dir> -- →arch=armeabi-v7a --debug`)

- [ ] `arm64-v8a` (`cd testapps/on_device_unit_tests && PYTHONPATH=.:../../

→python3 setup.py apk --ndk-dir=<your-ndk-dir> --sdk-dir=<your-sdk-dir> -- →arch=arm64-v8a --debug`)

- [ ] Comprobar que el número de versión es correcto

1.12.4 Cómo python-for-android usa pip

Última actualización: julio de 2019

Esta sección está destinada a proporcionar un resumen rápido de cómo p4a (= python-for-android) usa paquetes pip y python en su proceso de compilación. Está
escrito desde el punto de vista de los empaquetadores de python, no para los usuarios finales o colaboradores habituales, par a ayudar a que los desarrolladores
de pip y otros expertos en empaquetado conozcan las necesidades de empaquetado de p4a.

Tenga en cuenta que esta sección solo intenta enumerar de manera neutral los mecanismos actuales, por lo que parte de esto no necesariamente tiene la
intención de quedarse, sino cómo funcionan las cosas dentro de p4a en este mismo momento.

Conceptos básicos

(Esta parte repite otras partes de los documentos, con el fin de hacer de esta una lectura más independiente)

p4a crea y empaqueta una aplicación de python para usar en Android. Para ello, proporciona un envoltorio de Java y, para aplicaciones gráficas, un envoltorio
basado en SDL2 que se puede usar con el kit de herramientas de interfaz de usuario de kivy si se desea (o, alternativamente, simplemente PySDL2). Por
supuesto, cualquier aplicación de Python de este tipo tendrá más dependencias de biblioteca para hacer su trabajo.

p4a admite dos tipos de dependencias de paquetes para un proyecto:

Receta: instalar script en formato p4a personalizado. Puede instalar C / C ++ u otras cosas que no se pueden extraer a través de pip, o cosas que se pueden
instalar a través de pip pero se rompen en Android de forma predeterminada. Estos se mantienen principalmente dentro del árbol de fuentes de p4a por los
contribuyentes de p4a y las personas interesadas.

1.12. Desarrollo y contribución 39

Machine Translated by Google

Documentación de Python para Android, versión 0.1

Paquete Python: cualquier paquete pip python aleatorio se puede instalar directamente si no necesita ajustes para funcionar con Android.

p4a asignará cualquier dependencia a una receta interna si está presente y, de lo contrario, usará pip para obtenerla regularmente de cualquier fuente externa.

Proceso de instalación con respecto a los paquetes.

El proceso de instalación/construcción de un proyecto p4a, activado por el comando p4a apk, funciona aproximadamente de la si guiente manera con respecto a los
paquetes de python:

1. El usuario ha especificado una carpeta de proyecto para instalar. Esta es solo una carpeta con scripts de python y un main.py,
o también puede tener un pyproject.toml para una instalación más estandarizada.

2. Se recopilan las dependencias: se pueden especificar a través de --requirements como una lista de nombres o URL de estilo pip, o p4a puede escanearlas

opcionalmente desde una carpeta de proyecto a través de la biblioteca pep517 (si hay un pyproject.toml o setup .py).

3. Las dependencias recopiladas se asignan a las recetas de p4a si hay alguna disponible para ellas; de lo contrario, se mantienen
alrededor como referencias de paquetes regulares externos.

4. Todas las dependencias asignadas a las recetas se construyen a través de los mecanismos internos de p4a para construir estas recetas. (Esto puede o no

usar pip indirectamente, dependiendo de si la receta envuelve un paquete de python o no y usa pip para instalar o no).

5. Si el usuario ha especificado instalar el proyecto de forma estandarizada, se ejecutará el sistema de compilación setup.py/whatever del proyecto. Esto sucede
con la configuración de compilación cruzada (CC/CFLAGS/. . . configurada para usar la cadena de herramientas adecuada) y una ubicación de paquetes de

sitio personalizada. El comando real es una simple instalación de pip. en la carpeta del proyecto con algunas opciones adicionales: por ejemplo, todas las

dependencias que ya fueron instaladas por recetas se anclarán con un archivo de restricciones -c para asegurarse de que pip no las instale, y el aislamiento

de compilación se deshabilitará a través de --no-build- aislamiento para que pip no reinstale los paquetes de recetas por sí solo.

Si el usuario no ha especificado el uso de enfoques de compilación estandarizados, p4a simplemente instalará todas las depend encias restantes que no se

asignaron directamente a las recetas y simplemente las copiará en el proyecto del usuario sin instalarlas.
Cualquier setup.py o pyproject.toml del proyecto de usuario se ignorará en este paso.

6. Se invoca gradle de Google para empaquetarlo todo en un .apk.

Proceso general/notas relevantes del paquete para p4a

Aquí hay algunas cosas comunes que vale la pena saber sobre cómo Python-for-Android se ocupa de los paquetes de Python:

• Los paquetes funcionarán bien sin una receta si también se compilan en Linux ARM, no usen ninguna API que no esté disponible en el NDK si usan código
nativo, y no usen indicadores extraños del compilador que no le gusten a la cadena de herramientas si utilizan código nativo. El paquete también necesita
trabajar con compilación cruzada.

• Actualmente, no existe una manera fácil para que un paquete sepa que se está compilando de forma cruzada (al menos que sepamos) que no sea examinar

el compilador CC que se configuró, o que se está compilando de forma cruzada específicamente para Android. Si eso rompe un paquete, actualmente debe

solucionarse con una receta.

• Si un paquete no funciona , los desarrolladores de p4a a menudo crearán una receta en lugar de subir para solucionarlo porque
p4a simplemente es demasiado nicho.

• La mayoría de los paquetes sin código nativo funcionarán de inmediato. Muchos con código nativo tienden a no hacerlo, especialmente

si es complejo, por ejemplo, numpy.

• Cualquier cosa asignada a una receta p4a no puede ser reinstalada simplemente por pip, específicamente tampoco dentro del aislamiento de compilación
como una dependencia. (Puede funcionar si los parches de la receta solo son relevantes para solucionar problemas de tiempo de ejecución). Por lo tanto, a

partir de ahora, la mejor manera de lidiar con esta limitación parece ser mantener el aislamiento de compilación siempre desactivado .

40 Capítulo 1. Contenidos
Machine Translated by Google

Documentación de Python para Android, versión 0.1

Ideas para el futuro en materia de embalaje

• En general, preferimos usar menos el mecanismo de recetas si podemos. En general, las recetas son solo una colección de soluciones alternativas.
Puede parecer bastante extraño desde el exterior, ya que la versión p4a generalmente fija los paquetes envueltos en recetas para que los parches
se apliquen de manera confiable. Esto crea trabajo para que las recetas se mantengan actualizadas y, obviamente, este enfoque no escala
demasiado bien. Sin embargo, ha terminado siendo una solución provisional bastante práctica hasta que se encuentren mejores formas.

• Obviamente, sería bueno que los paquetes supieran que se están compilando de forma cruzada, y específicamente para Android.
Actualmente no conocemos un buen mecanismo para eso.

• Si pip realmente pudiera ejecutar las recetas (en lugar de p4a envolviendo pip y haciéndolo), entonces esto podría incluso permitir que funcione el
aislamiento de compilación, pero esto podría ser demasiado complejo para que funcione. Podría ser más práctico reducir gradualmente la
dependencia de las recetas y hacer que más paquetes funcionen de inmediato. Esto se ha hecho, por ejemplo, con mejoras en el entorno de
compilación cruzada que se configuran automáticamente, y estamos abiertos a cualquier idea sobre cómo mejorar esto.

1.13 Prueba de una solicitud de extracción de Python para Android

Para probar una solicitud de extracción, recomendamos considerar los siguientes puntos:

1. por supuesto, compruebe si todo tiene sentido

2. ¿Está pasando el CI? si no lo que falla especificamente

3. ¿Funciona localmente en tiempo de compilación?

4. ¿Funciona en el dispositivo en tiempo de ejecución?

Este documento se centrará en el tercer punto: ¿funciona localmente en tiempo de compilación? por lo tanto, daremos algunos consejos sobre cómo
proceder para crear una copia local de las solicitudes de extracción y construir una aplicación. Esperamos que los contribuyentes tengan suficiente criterio/
conocimiento para realizar los otros pasos mencionados, así que comencemos. . .

Para crear una aplicación a partir de una solicitud de extracción de Python para Android, contemplamos tres escenarios posibles:

• usar comandos de python-for-android directamente desde los archivos de solicitud de extracción que queremos probar, sin instalarlo (la forma
recomendada para la mayoría de los casos de prueba)

• instalar python-for-android usando la rama de github de la solicitud de extracción

• usar buildozer y una aplicación personalizada

Explicaremos los primeros dos métodos utilizando una de las aplicaciones de prueba distribuidas de Python para Android y asumimos que ya tiene instaladas
las dependencias de Python para Android. Para el método buildozer también esperamos que ya tenga una aplicación que funcione correctamente para
probar y una instalación/configuración funcional de buildozer. Hay un paso que se comparte con todos los métodos de prueba que proponemos aquí. . . lo
llamamos Pasos comunes.

1.13.1 Pasos comunes

El primer paso para hacerlo es obtener una copia de la solicitud de extracción, podemos hacerlo de varias maneras, y eso dependerá de las circunstancias,
pero todos los métodos presentados aquí harán el trabajo, entonces. . .

Obtener la solicitud de extracción por número

Para el ejemplo, usaremos 1901 para el ejemplo) y la rama de solicitud de extracción que usaremos es feature-fix-numpy, luego usará una variación del
siguiente comando git: git fetch origin pull/<#>/head :<nombre_sucursal_local>, por ejemplo:

1.13. Prueba de una solicitud de extracción de Python para 41

Android
Machine Translated by Google

Documentación de Python para Android, versión 0.1

git fetch upstream pull/1901/head:feature-fix-numpy

Nota: Tenga en cuenta que buscamos desde arriba, ya que ese es el proyecto original, donde se supone que debe estar la solicitud de extracción

Sugerencia: la cantidad de trabajo de algunos usuarios puede valer la pena para agregar su control remoto a la configuración de git de su bifurcación,
para hacerlo con el usuario imaginario de github Obi-Wan Kenobi cuyo apodo es obiwankenobi, hará:

git remoto agregar obiwankenobi https://github.com/obiwankenobi/python-for- →android.git

Y para obtener la rama de solicitud de extracción que ponemos como ejemplo, haría:

git fetch obiwankenobi git

checkout obiwankenobi/feature-fix-numpy

Clonar la rama de solicitud de extracción de la bifurcación del usuario

A veces, es posible que prefiera usar directamente la bifurcación del usuario, por lo que obtendrá el apodo del usuario que creó la solicitud de extracción,
tomemos el mismo usuario imaginario que antes obiwankenobi:

git clone -b función-corrección-numpy \ --single-

branch \ https://github.com/
obiwankenobi/python-for-android.git \ p4a-feature-fix-numpy

Aquí está el comando anterior explicado línea por línea:

• git clone -b feature-fix-numpy: le decimos a git que queremos clonar la rama llamada feature-fix-numpy

• –single-branch: le decimos a git que solo queremos esa rama

• https://github.com/obiwankenobi/python-for-android.git: ¿observó el apodo del usuario que creó la solicitud de extracción: obiwankenobi en medio
de la línea? eso debe cambiarse según sea necesario para cada solicitud de extracción que desee probar

• p4a-feature-fix-numpy: el nombre del repositorio clonado, por lo que podemos tener múltiples clones de diferentes prs en el
misma carpeta

Nota: Puede ver la información del autor/sucursal mirando el subtítulo de la solicitud de extracción, cerca del estado de la solicitud de extracción (se
esperaba un estado abierto)

1.13.2 Usar comandos de python para Android directamente desde los archivos de solicitud de extracción

• Ingrese dentro del directorio del repositorio clonado en el paso anterior y ejecute el comando p4a con los argumentos adecuados, por ejemplo
(para probar una receta de pycryptodome modificada)

cd p4a-feature-fix-numpy
PYTHONPATH=. python3 -m pythonforandroid.toolchain apk \ --private=testapps/
on_device_unit_tests/test_app \
(continúa en la página siguiente)

42 Capítulo 1. Contenidos
Machine Translated by Google

Documentación de Python para Android, versión 0.1

(Continuación de la página anterior)

--dist-name=dist_unit_tests_app_pycryptodome \ --package=org.kivy \ --
name=unit_tests_app_pycryptodome
\ --version=0.1 \ --

requirements=sdl2,pyjnius,kivy,python3,pycryptodome \ --ndk-dir=/media /DEVEL/

Android/android-ndk-r20 \ --sdk-dir=/media/DEVEL/Android/android-sdk-
linux \ --android-api=27 \ --arch=arm64-v8a \ --permission= VIBRAR \ --debug

Cosas que debes saber:

• El ejemplo anterior construirá una aplicación de prueba, haremos uso de los archivos de la aplicación de prueba de pruebas unitarias en el dispositivo, pero
no use el archivo de instalación para compilarlo, por lo que debemos decirle a python-for-android lo que queremos a través de argumentos

• asegúrese de editar al menos los siguientes argumentos cuando ejecute el comando anterior, ya que el valor predeterminado se establece allí
es poco probable que coincida con su instalación:

– –ndk-dir: una ruta absoluta al directorio NDK de Android

– –sdk-dir: una ruta absoluta al directorio SDK de Android

– –debug: este habilita el modo de depuración de python-for-android, que mostrará todos los mensajes de registro de la compilación.
Puede omitir este, pero vale la pena mencionarlo, ya que nos es útil cuando tratamos de encontrar el origen del problema cuan do las
cosas salen mal.

• El apk generado por el comando anterior debe ubicarse en la raíz del repositorio clonado, donde ejecutó el comando para compilar el apk

• Las aplicaciones de prueba distribuidas con python-for-android se encuentran en la carpeta de aplicaciones de prueba en la carpeta principal del proyecto

• Todas las compilaciones de python-for-android se encuentran en ~/.local/share/python-for-android

• Debe tener una copia descargada del NDK y SDK de Android.

1.13.3 Instalar python-for-android usando la rama de github de la solicitud de extracción

• Ingrese dentro del directorio del repositorio clonado mencionado en Pasos comunes e instálelo a través de pip, por ejemplo:

cd p4a-feature-fix-numpy pip3 install.

--actualizar --usuario

• Ahora, vaya al directorio testapps/on_device_unit_tests (suponemos que todavía está dentro de los repositorios clonados
historia)

cd testapps/on_device_unit_tests

• Ejecute la compilación del apk a través de la copia recién instalada de python-for-android ejecutando un comando similar al
abajo

python3 setup.py apk \ --ndk-dir=/

media/DEVEL/Android/android-ndk-r20 \ --sdk-dir=/media/DEVEL/Android/
android-sdk-linux \ --android-api= 27 \ --arch=arm64-v8a \ --depuración

1.13. Prueba de una solicitud de extracción de Python para 43

Android
Machine Translated by Google

Documentación de Python para Android, versión 0.1

Cosas que debes saber:

• En el ejemplo anterior, anulamos algunas variables que se establecen en setup.py, también puede anularlas mediante
editando este archivo

• asegúrese de editar al menos los siguientes argumentos cuando ejecute el comando anterior, ya que el valor predeterminado se establece allí
es poco probable que coincida con su instalación:

– –ndk-dir: una ruta absoluta al directorio NDK de Android

– –sdk-dir: una ruta absoluta al directorio SDK de Android

Consejo: si no quiere meterse con el python del sistema, puede hacer los mismos pasos pero dentro de un virtualenv

Advertencia: una vez que termine las pruebas de solicitud de extracción, recuerde volver al maestro o desarrollar versiones de python-for-
android, ya que acaba de instalar los archivos de python-for-android de la solicitud de extracción.

1.13.4 Usar buildozer con una aplicación personalizada

• Edite su archivo buildozer.spec. Debe buscar la clave p4a.source_dir y establecer el valor correcto para que en el
ejemplo publicado en Pasos comunes se vería así:

p4a.source_dir = /home/user/p4a_pull_requests/p4a-feature-fix-numpy

• Ejecute su comando buildozer como de costumbre, por ejemplo:

buildozer android debug p4a --dist-name=dist-test-feature-fix-numpy

Nota: este método tiene la ventaja de que se puede ejecutar sin instalar la versión de solicitud de extracción de python -for-android ni las dependencias
de Android, pero tiene un problema. . . cuando las cosas van mal, debe determinar si se trata de un problema de buildozer o de python para Android

Advertencia: una vez que termine las pruebas de solicitud de extracción, recuerde comentar/editar la constante p4a.source_dir que acaba de
editar para probar la solicitud de extracción.

Sugerencia: este método es útil para desarrollar solicitudes de extracción, ya que puede editar p4a.source_dir para que apunte a su bifurcación de
python para Android y puede probar cualquier rama que desee solo cambiando ramas con: git checkout <branch-name> desde dentro de su python
-for-android fork

44 Capítulo 1. Contenidos
Machine Translated by Google

CAPÍTULO 2

45
Machine Translated by Google

Documentación de Python para Android, versión 0.1

46 Capítulo 2. Índices y tablas

Machine Translated by Google

Índice de módulos de Python

a
android.actividad, 17
android.broadcast, 17
android.ejecutable, 18

47
Machine Translated by Google

Documentación de Python para Android, versión 0.1

48 Índice de módulos de Python

Machine Translated by Google

Índice

simbolos
init () (android.broadcast.BroadcastReceiver
método), 18

A
android.actividad (módulo), 16, 17
android.broadcast (módulo), 17
android.runnable (módulo), 18

B
bind() (en el módulo android.activity), 16
BroadcastReceiver (clase en android.broadcast),
17

R
registrarse_actividad_ciclo_de_vida_llamadas()
(en módulo android.actividad), 17

S
start()), 18 (método android.broadcast.BroadcastReceiver
(método
detener() android.broadcast.BroadcastReceiver), 18

tu
unbind() (en el módulo android.activity), 16
unregister_activity_lifecycle_callbacks()
(en módulo android.actividad), 17

49