Python para Android
Python para Android
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 49
i
Machine Translated by Google
yo
Machine Translated by Google
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
2 Contenido
Machine Translated by Google
CAPÍTULO 1
3
Machine Translated by Google
Instalando p4a
p4a ahora está disponible en Pypi, por lo que puede instalarlo usando pip:
Instalación de dependencias
• hormiga
• fabricación automática
• caché (opcional)
• cmake (requerido para algunas recetas de código nativo como la receta de jpeg)
• CCG
• git
• openjdk•8
• parche
• pitón3
• descomprimir
• cremaller a
En versiones recientes de Ubuntu y sus derivados, es posible que pueda instalar la mayoría de estos con:
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/jdk8openjdk extra/
python•pip extra/unzip extra/zip
4 Capítulo 1. Contenidos
Machine Translated by Google
En macOS:
brew install autoconf automake libtool openssl pkg-config brew tap homebrew/cask-versions
brew install --cask homebrew/cask-versions/
adoptopenjdk8
Advertencia: python-for-android suele ser exigente con las versiones de SDK/NDK. Elija los recomendados a continuación para evitar problemas.
• 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:
• 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.
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 :
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:
Luego, puede editar su ~/.bashrc u otro shell favorito para incluir nuevas variables de entorno necesarias para construir en Android:
1.1. Empezando 5
Machine Translated by Google
Tienes la posibilidad de configurar en cualquier comando la RUTA al SDK, NDK y API de Android usando:
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.
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.
Reemplace --port=5000 con el puerto en el que su aplicación servirá un sitio web. El valor predeterminado para Flask es 5000.
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
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:
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.
1.1. Empezando 7
Machine Translated by Google
recetas p4a
Si está contribuyendo a p4a y desea volver a probar recetas, debe limpiar la compilación y reconstruir 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):
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:
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.
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
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
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
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
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.
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):
• --package: El nombre del paquete Java para su proyecto. por ejemplo, org.example.yourapp.
• --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,
• --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.
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.
• --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
• --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.
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.
• --package: El nombre del paquete Java para su proyecto. por ejemplo, org.example.yourapp.
• --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.
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 nombre de permiso para la aplicación, por ejemplo, --permission VIBRATE. Para permisos múltiples, agregue varios
argumentos --permission.
• --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.
• --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.
biblioteca_servicio
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.
• --package: El nombre del paquete Java para su proyecto. por ejemplo, org.example.yourapp.
• --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.
12 Capítulo 1. Contenidos
Machine Translated by Google
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.
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)
1.3 Comandos
Esta página documenta todos los comandos y opciones que se pueden pasar a toolchain.py.
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).
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.
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
--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.
--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.
Esta página brinda detalles sobre cómo acceder a las API de Android y administrar otras interacciones en Android.
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:
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
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
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)
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:
https://developer.android.com/reference/android/Manifest.permission
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.
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.
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.
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
Bajo SDL2, puede manejar los eventos apropiados (ver SDL_APP_WILLENTERBACKGROUND, etc.).
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 -
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)
Ejemplo:
# Este ejemplo es un fragmento de una aplicación NFC p2p implementada con Kivy.
dieciséis
Capítulo 1. Contenidos
Machine Translated by Google
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) # ...
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.activity.unregister_activity_lifecycle_callbacks(instancia) anteriormente
Anule el registro de una instancia de ActivityLifecycleCallbacks registrado con
register_activity_lifecycle_callbacks().
Ejemplo:
registrarse_actividad_ciclo_de_vida_llamadas(
onActivityStopped=en_actividad_detenida,
)
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
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í.
Parámetros
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):
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
Ejemplo:
def holamundo(arg):
imprimir 'Llamado desde PythonActivity con arg:', arg
Ejecutable(holamundo)('hola')
@run_on_ui_thread def
holamundo(arg):
imprimir 'Llamado desde PythonActivity con arg:', arg
holamundo('arg1')
• 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.
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 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:
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:
# 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
actividad = PythonActivity.mActivity
Contexto = autoclase('android.content.Context')
vibrador = actividad.getSystemService(Context.VIBRATOR_SERVICE)
• 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.
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
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.
--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
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.
Si te sientes seguro, no dudes en mejorar el lanzador. Puede encontrar el código fuente en |renpy|_ o en |kivy|_.
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.
• ¡ 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)
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
• 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):
• 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
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'.
22 Capítulo 1. Contenidos
Machine Translated by Google
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:
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 argumento --private se establece automáticamente usando el paquete_datos. No debe configurar esto manualmente.
Todos estos argumentos automáticos se pueden anular pasándolos manualmente en la línea de comando, por ejemplo:
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:
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', }}
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)
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.
También puede proporcionar argumentos p4a en el archivo setup.cfg, como es normal para distutils. La sintaxis es:
[apk]
argumento=valor
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.
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.
clase TuReceta(Receta):
md5sum = '4f3dc9a9d857734a488bcbefd9cd64ed'
receta = TuReceta()
24 Capítulo 1. Contenidos
Machine Translated by Google
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.
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:
super().build_arch(arch) with
current_directory(self.get_build_dir(arch.arch)): with open('example_file.txt', 'w') as fileh:
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.
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
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:
...
clase TuReceta(Receta):
...
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:
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.
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:
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
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:
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.
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:
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:
1.7. Recetas 27
Machine Translated by Google
versión = 'maestro'
url = 'https://github.com/vispy/vispy/archive/{versión}.zip'
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.
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)
con directorio_actual(self.get_build_dir(arch.arch)):
hostpython = sh.Command(self.ctx.hostpython)
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.
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:
receta = KivyReceta()
28 Capítulo 1. Contenidos
Machine Translated by Google
self.build_cython_components(arch)
self.install_python_package() # esto es lo mismo que en PythonRecipe
# 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)
# 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.
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).
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
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.
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
conflictos = [] # Una lista de nombres de recetas que no se pueden construir # junto con este
30 Capítulo 1. Contenidos
Machine Translated by Google
receta = TuReceta()
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.
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.),
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.
Una clase de arranque consta de solo unos pocos componentes básicos, aunque uno de ellos debe hacer mucho trabajo.
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
1.8. Bootstraps 31
Machine Translated by Google
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.
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
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.
• :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:
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.
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.
Para personalizar el ícono, el título y el texto de la notificación, use tres argumentos opcionales para service.start():
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
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/.
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:
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 .
python-for-android es administrado por la Organización Kivy, y puede obtener ayuda con cualquier problema utilizando los mismos canales que
Kivy:
Si encuentra un error, también puede publicar un problema en la página de Python para Android Github.
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:
o:
34 Capítulo 1. Contenidos
Machine Translated by Google
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.
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
$ ls
AndroidManifest.xml clases.dex META-INF resolución
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
$ 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.
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
Los siguientes son problemas comunes y soluciones que los usuarios han informado.
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.
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.
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.
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:
En macOS:
36 Capítulo 1. Contenidos
Machine Translated by Google
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:
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
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.
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.
• 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.
• Cree una nueva versión de rama AAAA.MM.DD basada en la rama de desarrollo. - git pago -b
lanzamiento-AAAA.MM.DD desarrollo
• 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
• 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
- [ ] 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`)
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.
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.
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.
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.
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
• 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
• 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
• 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.
Para probar una solicitud de extracción, recomendamos considerar los siguientes puntos:
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)
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.
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:
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á:
Y para obtener la rama de solicitud de extracción que ponemos como ejemplo, haría:
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 feature-fix-numpy: le decimos a git que queremos clonar la rama llamada feature-fix-numpy
• 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
--dist-name=dist_unit_tests_app_pycryptodome \ --package=org.kivy \ --
name=unit_tests_app_pycryptodome
\ --version=0.1 \ --
• 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:
– –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
• Ingrese dentro del directorio del repositorio clonado mencionado en Pasos comunes e instálelo a través de pip, por ejemplo:
• 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
• 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:
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.
• 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
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
a
android.actividad, 17
android.broadcast, 17
android.ejecutable, 18
47
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