Компиляция kivy в apk в windows - Доктор Windows

You can create a package for android using the python-for-android project. This page explains how
to download and use it directly on your own machine (see
Packaging your application into APK or AAB) or
use the Buildozer tool to automate the entire process. You can also see
Packaging your application for the Kivy Launcher to run kivy
programs without compiling them.

For new users, we recommend using Buildozer as the easiest way
to make a full APK or AAB. You can also run your Kivy app without a
compilation step with the Kivy Launcher app.

Kivy applications can be released on an Android market such as the Play store, with a few extra
steps to create a fully signed AAB (Android App Bundle).

The Kivy project includes tools for accessing Android APIs to
accomplish vibration, sensor access, texting etc. These, along with
information on debugging on the device, are documented at the
main Android page.

Buildozer¶

Buildozer is a tool that automates the entire build process. It
downloads and sets up all the prerequisites for python-for-android,
including the android SDK and NDK, then builds an apk that can be
automatically pushed to the device.

Buildozer currently works only in Linux and macOS (You can still use
it on Windows via WSL), and can significantly simplify the apk build.

You can get buildozer at https://github.com/kivy/buildozer:

git clone https://github.com/kivy/buildozer.git
cd buildozer
sudo python setup.py install

This will install buildozer in your system. Afterwards, navigate to
your project directory and run:

This creates a buildozer.spec file controlling your build
configuration. You should edit it appropriately with your app name
etc. You can set variables to control most or all of the parameters
passed to python-for-android.

Install buildozer’s dependencies.

Finally, plug in your android device and run:

buildozer android debug deploy run

to build, push and automatically run the apk on your device.

Buildozer has many available options and tools to help you, the steps
above are just the simplest way to build and run your
APK. The full documentation is available here. You can also check
the Buildozer README at https://github.com/kivy/buildozer.

Packaging with python-for-android¶

You can also package directly with python-for-android, which can give
you more control but requires you to manually download parts of the
Android toolchain.

See the python-for-android documentation
for full details.

Packaging your application for the Kivy Launcher¶

The Kivy launcher is an Android application that runs any Kivy examples
stored on your SD Card.
To install the Kivy launcher, you must:

Go on Google Play Store and search for Kivy Launcher from kivy org
Click on Install
Select your phone… And you’re done!

If you don’t have access to the Google Play Store on your phone/tablet,
you can download and install the APK manually from
https://github.com/kivy/kivy-launcher/releases

Once the Kivy launcher is installed, you can put your Kivy
applications in the Kivy directory in your external storage directory
(often available at /sdcard even in devices where this memory
is internal), e.g.

/sdcard/kivy/<yourapplication>

<yourapplication> should be a directory containing:

# Your main application file:
main.py
# Some info Kivy requires about your app on android:
android.txt

The file android.txt must contain:

title=<Application Title>
author=<Your Name>
orientation=<portrait|landscape>

These options are just a very basic configuration. If you create your
own APK using the tools above, you can choose many other settings.

Installation of Examples¶

Kivy comes with many examples, and these can be a great place to start
trying the Kivy launcher. You can run them as below:

#. Download the `Kivy demos for Android <https://storage.googleapis.com/google-code-archive-downloads/v2/code.google.com/kivy/kivydemo-for-android.zip>`_
#. Unzip the contents and go to the folder `kivydemo-for-android`
#. Copy all the the subfolders here to

/sdcard/kivy

Run the launcher and select one of the Pictures, Showcase, Touchtracer, Cymunk or other demos…

Release on the market¶

If you have built your own APK with Buildozer or with
python-for-android, you can create a release version that may be
released on the Play store or other Android markets.

To do this, you must run Buildozer with the release parameter
(e.g. buildozer android release), or if using
python-for-android use the --release option to build.py. This
creates a release AAB in the bin directory, which you must
properly sign and zipalign.
The procedure for doing this is described in the Android documentation
at https://developer.android.com/studio/publish/app-signing.html#signing-manually —
all the necessary tools come with the Android SDK.

Targeting Android¶

Kivy is designed to operate identically across platforms and as a result, makes
some clear design decisions. It includes its own set of widgets and by default,
builds an APK or AAB with all the required core dependencies and libraries.

It is possible to target specific Android features, both directly and
in a (somewhat) cross-platform way. See the Using Android APIs section
of the Kivy on Android documentation for more details.

Источник

Create a package for Windows
- Requirements
- PyInstaller default hook
- Packaging a simple app
- Single File Application
- Bundling Data Files
- Packaging a video app with gstreamer
- Overwriting the default hook
- Including/excluding video and audio and reducing app size
- Alternate installations

Note

This document only applies for kivy 1.9.1 and greater.

Packaging your application for the Windows platform can only be done inside the
Windows OS. The following process has been tested on Windows with the Kivy
wheels installation, see at the end for alternate installations.

The package will be either 32 or 64 bits depending on which version of Python
you ran it with.

Requirements¶

Latest Kivy (installed as described in Installation on Windows).

PyInstaller 3.1+ (pip install --upgrade pyinstaller).

PyInstaller default hook¶

This section applies to PyInstaller (>= 3.1) that includes the kivy hooks.
To overwrite the default hook the
following examples need to be slightly modified. See Overwriting the default hook.

Packaging a simple app¶

For this example, we’ll package the touchtracer example project and embed
a custom icon. The location of the kivy examples is, when using the wheels,
installed to python\share\kivy-examples and when using the github source
code installed as kivy\examples. We’ll just refer to the full path leading
to the examples as examples-path. The touchtracer example is in
examples-path\demo\touchtracer and the main file is named main.py.

Open your command line shell and ensure that python is on the path (i.e.
python works).
Create a folder into which the packaged app will be created. For example
create a TouchApp folder and change to that directory with e.g. cd TouchApp.
Then type:
```
python -m PyInstaller --name touchtracer examples-pathdemotouchtracermain.py
```
You can also add an icon.ico file to the application folder in order to
create an icon for the executable. If you don’t have a .ico file available,
you can convert your icon.png file to ico using the web app
ConvertICO. Save the icon.ico in the
touchtracer directory and type:
```
python -m PyInstaller --name touchtracer --icon examples-pathdemotouchtracericon.ico examples-pathdemotouchtracermain.py
```
For more options, please consult the
PyInstaller Manual.
The spec file will be touchtracer.spec located in TouchApp. Now we
need to edit the spec file to add the dependencies hooks to correctly build
the exe. Open the spec file with your favorite editor and add these lines
at the beginning of the spec (assuming sdl2 is used, the default now):
```
from kivy_deps import sdl2, glew
```
Then, find COLLECT() and add the data for touchtracer
(touchtracer.kv, particle.png, …): Change the line to add a Tree()
object, e.g. Tree('examples-path\demo\touchtracer\'). This Tree will
search and add every file found in the touchtracer directory to your final
package.

To add the dependencies, before the first keyword argument in COLLECT add a
Tree object for every path of the dependencies. E.g.
*[Tree(p) for p in (sdl2.dep_bins + glew.dep_bins)] so it’ll look
something like:
```
coll = COLLECT(exe, Tree('examples-path\demo\touchtracer\'),
               a.binaries,
               a.zipfiles,
               a.datas,
               *[Tree(p) for p in (sdl2.dep_bins + glew.dep_bins)],
               strip=False,
               upx=True,
               name='touchtracer')
```
Now we build the spec file in TouchApp with:
```
python -m PyInstaller touchtracer.spec
```
The compiled package will be in the TouchAppdisttouchtracer directory.

Single File Application¶

Next, we will modify the example above to package the touchtracer example project as a single file application. Following the same steps as above, instead issue the following command:

python -m PyInstaller --onefile --name touchtracer examples-pathdemotouchtracermain.py

As before, this will generate touchtracer.spec, which we will edit to add the dependencies. In this instance, edit the arguments to the EXE command so that it will look something like this:

exe = EXE(pyz, Tree('examples-path\demo\touchtracer\'),
     a.scripts,
     a.binaries,
     a.zipfiles,
     a.datas,
     *[Tree(p) for p in (sdl2.dep_bins + glew.dep_bins)],
     upx=True
     name='touchtracer')

Now you can build the spec file as before with:
```
python -m PyInstaller touchtracer.spec
```
The compiled package will be in the TouchAppdist directory and will consist of a single executable file.

Bundling Data Files¶

We will again modify the previous example to include bundled data files. PyInstaller allows inclusion of outside data files (such as images, databases, etc) that the project needs to run. When running an app on Windows, the executable extracts to a temporary folder which the Kivy project doesn’t know about, so it can’t locate these data files. We can fix that with a few lines.

First, follow PyInstaller documentation on how to include data files in your application.
Modify your main python code to include the following imports (if it doesn’t have them already):
```
import os, sys
from kivy.resources import resource_add_path, resource_find
```

Modify your main python code to include the following (using the touchtracer app as an example):

if __name__ == '__main__':
    if hasattr(sys, '_MEIPASS'):
        resource_add_path(os.path.join(sys._MEIPASS))
    TouchtracerApp().run()

Finally, follow the steps for bundling your application above.

Packaging a video app with gstreamer¶

Following we’ll slightly modify the example above to package a app that uses
gstreamer for video. We’ll use the videoplayer example found at
examples-pathwidgetsvideoplayer.py. Create a folder somewhere called
VideoPlayer and on the command line change your current directory to that
folder and do:

python -m PyInstaller --name gstvideo examples-pathwidgetsvideoplayer.py

to create the gstvideo.spec file. Edit as above and this time include the
gstreamer dependency as well:

from kivy_deps import sdl2, glew, gstreamer

and add the Tree() to include the video files, e.g.
Tree('examples-path\widgets') as well as the gstreamer dependencies so it
should look something like:

coll = COLLECT(exe, Tree('examples-path\widgets'),
               a.binaries,
               a.zipfiles,
               a.datas,
               *[Tree(p) for p in (sdl2.dep_bins + glew.dep_bins + gstreamer.dep_bins)],
               strip=False,
               upx=True,
               name='gstvideo')

Then build the spec file in VideoPlayer with:

python -m PyInstaller gstvideo.spec

and you should find gstvideo.exe in VideoPlayerdistgstvideo,
which when run will play a video.

Note

If you’re using Pygame and need PyGame in your packaging app, you’ll have
to add the following code to your spec file due to kivy issue #1638. After
the imports add the following:

def getResource(identifier, *args, **kwargs):
    if identifier == 'pygame_icon.tiff':
        raise IOError()
    return _original_getResource(identifier, *args, **kwargs)

import pygame.pkgdata
_original_getResource = pygame.pkgdata.getResource
pygame.pkgdata.getResource = getResource

Overwriting the default hook¶

Including/excluding video and audio and reducing app size¶

PyInstaller includes a hook for kivy that by default adds all the core
modules used by kivy, e.g. audio, video, spelling etc (you still need to
package the gstreamer dlls manually with Tree() — see the example above)
and their dependencies. If the hook is not installed or to reduce app size some
of these modules may be excluded, e.g. if no audio/video is used, with
an alternative hook.

Kivy provides the alternate hook at
hookspath(). In addition, if and
only if PyInstaller doesn’t have the default hooks
runtime_hooks() must also be
provided. When overwriting the hook, the latter one typically is not required
to be overwritten.

The alternate hookspath() hook
does not include any of the kivy providers. To add them, they have to be added
with
get_deps_minimal() or
get_deps_all(). See
their documentation and pyinstaller_hooks for more
details. But essentially,
get_deps_all() add all the
providers like in the default hook while
get_deps_minimal() only adds
those that are loaded when the app is run. Each method provides a list of
hidden kivy imports and excluded imports that can be passed on to Analysis.

One can also generate a alternate hook which literally lists every kivy
provider module and those not required can be commented out. See
pyinstaller_hooks.

To use the the alternate hooks with the examples above modify as following to
add the hooks with hookspath() and runtime_hooks (if required)
and **get_deps_minimal() or **get_deps_all() to specify the providers.

For example, add the import statement:

from kivy.tools.packaging.pyinstaller_hooks import get_deps_minimal, get_deps_all, hookspath, runtime_hooks

and then modify Analysis as follows:

a = Analysis(['examples-path\demo\touchtracer\main.py'],
             ...
             hookspath=hookspath(),
             runtime_hooks=runtime_hooks(),
             ...
             **get_deps_all())

to include everything like the default hook. Or:

a = Analysis(['examples-path\demo\touchtracer\main.py'],
             ...
             hookspath=hookspath(),
             runtime_hooks=runtime_hooks(),
             ...
             **get_deps_minimal(video=None, audio=None))

e.g. to exclude the audio and video providers and for the other core modules
only use those loaded.

The key points is to provide the alternate
hookspath() which does not list
by default all the kivy providers and instead manually to hiddenimports
add the required providers while removing the undesired ones (audio and
video in this example) with
get_deps_minimal().

Alternate installations¶

The previous examples used e.g.
*[Tree(p) for p in (sdl2.dep_bins + glew.dep_bins + gstreamer.dep_bins)],
to make PyInstaller add all the dlls used by these dependencies. If kivy
was not installed using the wheels method these commands will not work and e.g.
kivy_deps.sdl2 will fail to import. Instead, one must find the location
of these dlls and manually pass them to the Tree class in a similar fashion
as the example.

Источник

Время прочтения
8 мин

Просмотры 55K

Фух! Только что выбрался из под траков этого чудовища. А кое-кому повезло меньше. Как и было обещано в предыдущей статье, сегодня мы расскажем, как собираются apk пакеты для программ, написанных с использованием фреймворка Kivy при помощи утилиты Buildozer.

Что для этого понадобится? Помимо уже известных инструментов — кофе-сигареты, полкило нервов — нам потребуются ключи от новенького Бульдозера, который стоит в ангаре на github и сопутствующие зависимости, без которых он, к сожалению, не заведется, а если заведется, то никого задавить не удастся и apk пакет для Android не собрать.

Кстати, пользователи Microsoft, на своих Windows машинах за Бульдозером с нами не едут, потому что для сборки apk пакета требуется Linux система, либо ее образ на виртуалке. Ну, что ж. А мы отправляемся на github, отбуксируем Бульдозер и распакуем архив в какую-нибудь директорию. Блин. Да это просто монстр!

Спокойно. Не заводим. За рычаги не хватаемся. Во-первых, нам нужно скачать пакет pip — инструмент для установки и управления пакетами Python.

sudo apt-get install python-pip

Заходим в ангар, в смысле в папку с Бульдозером…

… и выполняем команду —

sudo python setup.py install

Об успешной установке мы будем извещены сообщением Successfully installed buildozer. Бульдозер работает как на Python 2.7 так и на Python >= 3.3. Я использую Python 2.7. Просто потому, что я пока не пытался собирать apk пакеты для программ, написанных с использованием Python 3, хотя по заявлениям разработчиков Kivy, третий Python полностью поддерживается. Ну, и теперь, собственно, давайте скачаем python-for-android. У меня работает именно эта ветка, поэтому других я не предлагаю. Распакуйте python-for-android.zip и пока забудем о нем.

Зависимости

Их довольно много и от правильной их установки будет зависеть, сможете ли вы собрать заветную apk-шечку или придется выпить валидолу и начать все сначала. Считается, что все вышеперечисленные пакеты у вас отсутствуют и предполагается, что фреймворк Kivy установлен и успешно вами используется.

sudo pip install --upgrade cython
sudo pip install virtualenv
sudo pip install Jinja2

Для сборки пакета под Android нам понадобится Android SDK. Некоторые его двоичные файлы все еще находятся в 32 битных библиотеках, так что нужно сделать их доступными:

dpkg --add-architecture i386

После этого можем установить следующие пакеты:

sudo apt-get update
sudo apt-get install -y build-essential ccache git zlib1g-dev python2.7 python2.7-dev libncurses5:i386 libstdc++6:i386 zlib1g:i386 openjdk-7-jdk unzip

Ну, и теперь, наконец, мы готовы сесть в удобное кресло Бульдозера и схватится за рычаги управления. Заходим в папку проекта и выполняем в терминале команду —

buildozer init

… которая создаст в проекте файл спецификации buildozer.spec, где мы будем указывать Бульдозеру с какими параметрами собирать наше приложение.

Откроем данный файл и посмотрим его содержимое:

buildozer.spec

[app]

# (str) Title of your application
title = DemoCleanMaster

# (str) Package name
package.name = democleanmaster

# (str) Package domain (needed for android/ios packaging)
package.domain = org.heattheatr

# (str) Source code where the main.py live
source.dir = .

# (list) Source files to include (let empty to include all the files)
source.include_exts = py,png,kv,jpg

# (list) Source files to exclude (let empty to not exclude anything)
#source.exclude_exts = []

# (list) List of directory to exclude (let empty to not exclude anything)
#source.exclude_dirs = []

# (list) List of exclusions using pattern matching
#source.exclude_patterns = license,images/*/*.jpg

# (str) Application versioning (method 1)
version.regex = __version__ = ['"](.*)['"]
version.filename = %(source.dir)s/main.py

# (str) Application versioning (method 2)
# version = 1.2.0

# (list) Application requirements
# comma seperated e.g. requirements = sqlite3,kivy
requirements = kivy
# (str) Custom source folders for requirements
# Sets custom source for any requirements with recipes
# requirements.source.kivy = ../../kivy

# (list) Garden requirements
#garden_requirements =

# (str) Presplash of the application
presplash.filename = %(source.dir)s/Data/Images/presplash.jpg

# (str) Icon of the application
icon.filename = %(source.dir)s/Data/Images/logo.png

# (str) Supported orientation (one of landscape, portrait or all)
orientation = portrait

# (bool) Indicate if the application should be fullscreen or not
fullscreen = 1

#
# Android specific
#

# (list) Permissions
android.permissions = INTERNET

# (int) Android API to use
android.api = 18

# (int) Minimum API required (8 = Android 2.2 devices)
android.minapi = 8

# (int) Android SDK version to use
android.sdk = 21

# (str) Android NDK version to use
android.ndk = 9

# (bool) Use --private data storage (True) or --dir public storage (False)
android.private_storage = False

# (str) Android NDK directory (if empty, it will be automatically downloaded.)
android.ndk_path = /home/zavulon/Opt/android-ndk-r9

# (str) Android SDK directory (if empty, it will be automatically downloaded.)
android.sdk_path = /home/zavulon/Opt/android-sdk

# (str) python-for-android git clone directory (if empty, it will be automatically cloned from github)
android.p4a_dir = /home/zavulon/Opt/Python/python-for-android

# (list) python-for-android whitelist
#android.p4a_whitelist =

# (str) Android entry point, default is ok for Kivy-based app
#android.entrypoint = org.renpy.android.PythonActivity

# (list) List of Java .jar files to add to the libs so that pyjnius can access
# their classes. Don't add jars that you do not need, since extra jars can slow
# down the build process. Allows wildcards matching, for example:
# OUYA-ODK/libs/*.jar
#android.add_jars = foo.jar,bar.jar,path/to/more/*.jar

# (list) List of Java files to add to the android project (can be java or a
# directory containing the files)
#android.add_src =

# (str) python-for-android branch to use, if not master, useful to try
# not yet merged features.
#android.branch = master

# (str) OUYA Console category. Should be one of GAME or APP
# If you leave this blank, OUYA support will not be enabled
#android.ouya.category = GAME

# (str) Filename of OUYA Console icon. It must be a 732x412 png image.
#android.ouya.icon.filename = %(source.dir)s/data/ouya_icon.png

# (str) XML file to include as an intent filters in <activity> tag
#android.manifest.intent_filters =

# (list) Android additionnal libraries to copy into libs/armeabi
#android.add_libs_armeabi = libs/android/*.so
#android.add_libs_armeabi_v7a = libs/android-v7/*.so
#android.add_libs_x86 = libs/android-x86/*.so
#android.add_libs_mips = libs/android-mips/*.so

# (bool) Indicate whether the screen should stay on
# Don't forget to add the WAKE_LOCK permission if you set this to True
#android.wakelock = False

# (list) Android application meta-data to set (key=value format)
#android.meta_data =

# (list) Android library project to add (will be added in the
# project.properties automatically.)
#android.library_references =

#
# iOS specific
#

# (str) Name of the certificate to use for signing the debug version
# Get a list of available identities: buildozer ios list_identities
#ios.codesign.debug = "iPhone Developer: <lastname> <firstname> (<hexstring>)"

# (str) Name of the certificate to use for signing the release version
#ios.codesign.release = %(ios.codesign.debug)s

[buildozer]

# (int) Log level (0 = error only, 1 = info, 2 = debug (with command output))
log_level = 2

# (int) Display warning if buildozer is run as root (0 = False, 1 = True)
warn_on_root = 0

#    -----------------------------------------------------------------------------
#    List as sections
#
#    You can define all the "list" as [section:key].
#    Each line will be considered as a option to the list.
#    Let's take [app] / source.exclude_patterns.
#    Instead of doing:
#
#[app]
#source.exclude_patterns = license,data/audio/*.wav,data/images/original/*
#
#    This can be translated into:
#
#[app:source.exclude_patterns]
#license
#data/audio/*.wav
#data/images/original/*
#
#    -----------------------------------------------------------------------------
#    Profiles
#
#    You can extend section / key with a profile
#    For example, you want to deploy a demo version of your application without
#    HD content. You could first change the title to add "(demo)" in the name
#    and extend the excluded directories to remove the HD content.
#
#[app@demo]
#title = My Application (demo)
#
#[app:source.exclude_patterns@demo]
#images/hd/*
#
#    Then, invoke the command line with the "demo" profile:
#
#buildozer --profile demo android debug

Теперь рассмотрим подробнее…

title = DemoCleanMaster

Это имя приложение, которое будет отображаться на Android девайсе и которое будет носить установочный apk пакет.

package.name = democleanmaster
package.domain = org.heattheatr

Уникальный домен приложения.

source.dir = .

Директория, в которой находится точка входа в приложение — файл main.py. По умолчанию это корневая директория проекта.

source.include_exts = py,kv,jpg,png

Расширение файлов, которые будут включены в сборку apk пакета из вашего проекта. Структура дерева директорий, откуда указанные файлы будут браться, сохраняется.

version.regex = __version__ = ['"](.*)['"]
version.filename = %(source.dir)s/main.py

Версия программы и в каком файле ее (версию) искать. Данный метод говорит, что в файле main.py корневой директории проекта должна быть переменная со значением версии вашего приложения.

# main.py

__version__ = '0.0.1'

# ...ваш код

requirements = kivy

Сторонние библиотеки, которые будут включены в сборку. Через запятую вы можете указать пакеты библиотек, с которыми работает ваше приложение, например: kivy, opencv, pil, sqlite3.

Полный список доступных библиотек вы можете посмотреть в редакторе спецификации в инструменте для построения UI — Kivy Designer. Очень рекомендую!

presplash.filename = %(source.dir)s/Data/Images/presplash.jpg

Изображение, которое будет показано на экране девайса пока запускается ваше приложение, где %(source.dir)s — путь к корневой директории проекта.

icon.filename = %(source.dir)s/Data/Images/logo.png

Иконка приложения, которая будет отображаться на девайсе.

orientation = portrait
fullscreen = 1

Ориентация вашего приложения на девайсе. Помимо ‘portrait’, может принимать значение ‘landscape’. ‘fullscreen’ указывает разворачивать Activity на весь экран. Также принимает значение ‘0’.

android.permissions = INTERNET

Права приложения.

android.api = 18

Используемая приложением версия Android API (должна быть в Android SDK). Здесь могут возникнуть проблемы, если, например, вы указали версию Android API 10, которая отсутствует в Android NDK.

android.minapi = 8

Минимальная версия Android API, поддерживаемая приложением.

android.sdk = 21

Версия Android SDK.

android.ndk = 9

Версия Android NDK.

android.private_storage = False

Указывает создавать папку с файлами проекта на девайсе на SD карте. Рекомендую. Потому что в данном случае вы можете заменить байткомпилированое представление *.pyo файлов проекта на исходные тексты, и если будет необходимость внести в проект небольшое изменение, вы можете сделать это прямо на девайсе, отредактировав исходники или перезалив их с компьютера.

android.ndk_path = /home/zavulon/Opt/android-ndk-r9
android.sdk_path = /home/zavulon/Opt/android-sdk

android.p4a_dir = /home/zavulon/Opt/Python/python-for-android

Здесь все понятно. Можете сделать следующим образом:

android.ndk_path = 
android.sdk_path = 
android.p4a_dir =

В таком случае Бульдозер скачает и Android SDK с указанными в спецификации версиями ANDROID API, и Android NDK, и python-for-android, будет скачан Apache-ant, если Бульдозер его не найдет. Также будут скачаны следующие библиотеки и исходники самого Python и модулей:

Да. Все это несколько хлопотно, но делается это один раз. Потом, для сборки проекта, достаточно просто отредактировать файл спецификации buildozer.spec и закинуть его в проект, который мы хотим собрать. Остальные параметры спецификации я не рассматриваю, поскольку пока я их еще сам не использоавл. И, да, параметры для сборки под iOS тоже остаются за траками, потому что я не имею девайса с данной платформой.

Собственно, эй, вы там — закройте двери Бульдозера с той стороны и прочь со взлетной полосы — мы заходим в папку проекта и выполняем в терминале команду начала компиляции:

buildozer android debug

Пройдет о-о-очень много времени (пригодились сигареты и кофе), прежде чем вы увидите заветное сообщение:

Обратите внимание, что apk-шечка получается дебажная. На Хабре есть статья, в которой описывается процесс создания подписанного пакета. К тому же размер сборки довольно внушительный — 7.6 Мб. Это потому, что Бульдозер включает в сборку весь Python целиком со всеми тестами и не нужными библиотеками. Также сам Kivy включается со всеми API даже если ваше приложение их не использует.

После установки собранного apk на девайсе и его старта, приложение будет довольно долго запускаться. Kivy потребуется время, чтобы извлечь и развернуть все библиотеки. К счачтью, все последующие загрузки программы длятся не более пяти секунд.

В следующей статье я расскажу, за какие рычаги дергать Бульдозер, чтобы увидеть собранный проект, но уже гораздо меньшего размера…

Удачных сборок! Смотрите под траки!

Источник

Mehmet

Posted on Sep 1, 2021

• Updated on Sep 6, 2021

In this article, I will explain how we can convert a cross-platform application made using kivy/kivymd in python on Windows to an APK file without the need for a Linux machine. For this, I will use the online platform called Google Colab.

After logging into google colab, let’s prepare the environment for the conversion process. Do not forget to upload the project you are working on. Follow these commands step by step:

!sudo apt update

Enter fullscreen mode

Exit fullscreen mode

!sudo apt install -y git zip unzip openjdk-8-jdk python3-pip autoconf libtool pkg-config zlib1g-dev libncurses5-dev libncursesw5-dev libtinfo5 cmake libffi-dev libssl-dev

Enter fullscreen mode

Exit fullscreen mode

!pip3 install --upgrade Cython==0.29.19 virtualenv

Enter fullscreen mode

Exit fullscreen mode

!export PATH=$PATH:~/.local/bin/

Enter fullscreen mode

Exit fullscreen mode

!pip install buildozer

Enter fullscreen mode

Exit fullscreen mode

!sudo apt-get install -y 
    python3-pip 
    build-essential 
    git 
    python3 
    python3-dev 
    ffmpeg 
    libsdl2-dev 
    libsdl2-image-dev 
    libsdl2-mixer-dev 
    libsdl2-ttf-dev 
    libportmidi-dev 
    libswscale-dev 
    libavformat-dev 
    libavcodec-dev 
    zlib1g-dev

Enter fullscreen mode

Exit fullscreen mode

!sudo apt-get install -y 
    python3-pip 
    build-essential 
    git 
    python3 
    python3-dev 
    ffmpeg 
    libsdl2-dev 
    libsdl2-image-dev 
    libsdl2-mixer-dev 
    libsdl2-ttf-dev 
    libportmidi-dev 
    libswscale-dev 
    libavformat-dev 
    libavcodec-dev 
    zlib1g-dev

Enter fullscreen mode

Exit fullscreen mode

!sudo apt-get install build-essential libsqlite3-dev sqlite3 bzip2 libbz2-dev zlib1g-dev libssl-dev openssl libgdbm-dev libgdbm-compat-dev liblzma-dev libreadline-dev libncursesw5-dev libffi-dev uuid-dev libffi6

Enter fullscreen mode

Exit fullscreen mode

!sudo apt-get install libffi-dev

Enter fullscreen mode

Exit fullscreen mode

Now our environment is ready. We can start the conversion process. We will use buildozer for this. Run this command to start Buildozer:

!buildozer init

Enter fullscreen mode

Exit fullscreen mode

This command will create a configuration file named buildozer.spec for us. Now it’s time to edit this file. At least you should change the;
title, package.name, package.domain.

After changing these, my suggestion is to make some more changes to avoid some problems. Let’s look at source.dir first, if your main.py file is in the same directory, there is no need to change it, but if not, you should write the path here.

Afterwards, if you have used separate files such as png, txt, csv in the program, you should add the extension to source.include_exts.

Now let’s change the most important, requirements. If you only used kivy, python3,kivy==2.0.0rc4 will be enough to do it this way.If you also used kivymd then you should add this https://github.com/kivymd/KivyMD/archive/master.zip. If you have used other libraries, run the pip install <library-name> command, and it will show the downloaded packages. You can add them without specifying the version.

If you want to use icon you can uncomment icon.filename and you can edit the path.

If you want your app to be fullscreen, you can make fullscreen 1.

We will need to clone python-for-android to avoid problems such as not showing some symbols.

!git clone <git-link-of-forked-repo>

Enter fullscreen mode

Exit fullscreen mode

Then we need to edit it in spec file.p4a.source_dir = /path/to/your/python-for-android and p4a.branch = develop.

Finally, if you need permissions on android you have to write them.We are done with spec file for now.

Now we can start the conversion process by this command:

!buildozer -v android debug

Enter fullscreen mode

Exit fullscreen mode

When you first run this process, it may take up to 15-20 minutes depending on your internet speed. When the process is finished, your bin/*.apk file is ready and you can download it to the phone.

If the application does not work, you can create a log file from the phone. For this, try to run the application after clicking on the settings / developer option / bug report. After waiting for a while, it will also show the process in the notification bar. You can now see the errors by sharing it to your computer.

You can also check out my project that I made using kivymd.

Mehmet Karagoz.

Resources

Buildozer Installation
Spec file
Running
p4a
in addition

Источник

В наши дни каждый разработчик может столкнуться с необходимостью работы над мобильным или веб-приложением на Python. В Python нет встроенных инструментов для мобильных устройств, тем не менее существуют пакеты, которые можно использовать для создания мобильных приложений. Это Kivy, PyQt и даже библиотека Toga от Beeware.

Содержание

Принципы работы фреймворка Kivy Python
Установка Kivy
Работа с виджетами в Kivy
Запуск программы «Hello, Kivy!»
Отображение виджета Image в Kivy Python
Разметка (Layout) в UI Kivy
Добавление событий в Kivy
Использование языка дизайна KV
Создание приложения Kivy Python
Создаем apk приложения для Android на Python
Создание приложений для iPhone (iOS) на Python
Создание exe приложений для Windows на Python используя Kivy
Создание приложений для macOS на Python используя Kivy

Библиотеки являются основными элементами мобильного мира Python. Однако, говоря о Kivy, нельзя игнорировать преимущества данного фреймворка при работе с мобильными приложениями. Внешний вид приложения автоматически подстраивается под все платформы, разработчику при этом не нужно компилировать код после каждой поправки. Кроме того, здесь для создания приложений можно использовать чистый синтаксис Python.

В руководстве будут разобраны следующие темы:

Работа с виджетами Kivy;
Планировка UI и лейауты;
Добавление событий;
Использование языка KV;
Создание приложения-калькулятора;
Упаковка приложения для iOS, Android, Windows и macOS.

Разбор данного руководства предполагает, что читатель знаком с объектно-ориентированным программированием. Для введения в курс дела можете просмотреть статью об Объектно-ориентированном программировании (ООП) в Python 3.

Приступим!

Принципы работы фреймворка Kivy Python

Kivy был создан в 2011 году. Данный кросс-платформенный фреймворк Python работает на Windows, Mac, Linux и Raspberry Pi. В дополнение к стандартному вводу через клавиатуру и мышь он поддерживает мультитач. Kivy даже поддерживает ускорение GPU своей графики, что во многом является следствием использования OpenGL ES2. У проекта есть лицензия MIT, поэтому библиотеку можно использовать бесплатно и вкупе с коммерческим программным обеспечением.

Во время разработки приложения через Kivy создается интуитивно понятный интерфейс (Natural user Interface), или NUI. Его главная идея в том, чтобы пользователь мог легко и быстро приспособиться к программному обеспечению без чтения инструкций.

Kivy не задействует нативные элементы управления, или виджеты. Все его виджеты настраиваются. Это значит, что приложения Kivy будут выглядеть одинаково на всех платформах. Тем не менее, это также предполагает, что внешний вид вашего приложения будет отличаться от нативных приложений пользователя. Это может стать как преимуществом, так и недостатком, все зависит от аудитории.

Установка Kivy

У Kivy есть множество зависимостей, поэтому лучше устанавливать его в виртуальную среду Python. Можно использовать встроенную библиотеку Python venv или же пакет virtualenv.

Виртуальная среда Python создается следующим образом:

$ python3 —m venv my_kivy_project

По ходу данного действия исполняемый файл Python 3 будет скопирован в папку под названием my_kivy_project, куда также будут добавлено несколько других папок.

Есть вопросы по Python?

На нашем форуме вы можете задать любой вопрос и получить ответ от всего нашего сообщества!

Telegram Чат & Канал

Вступите в наш дружный чат по Python и начните общение с единомышленниками! Станьте частью большого сообщества!

Паблик VK

Одно из самых больших сообществ по Python в социальной сети ВК. Видео уроки и книги для вас!

Для использования виртуальной среды ее нужно активировать. На Mac или Linux это можно сделать, выполнив следующую команду, будучи внутри папки my_kivy_project:

Команда для Windows точно такая же, но активировать скрипт нужно в другом месте — через папку Scripts, а не bin.

После активации виртуальной среды Python можно запустить pip для установки Kivy. На Linux и Mac нужно выполнить следующую команду:

$ python —m pip install kivy

Инсталляция на Windows несколько сложнее. В официальной документации фреймворка изучите пункт, касающийся установки Kivy на Windows. Пользователи Mac также могут скачать файл dmg и установить Kivy данным образом.

В случае возникновения проблем во время установки Kivy на вашу платформу изучите дополнительные инструкции, с которыми можно ознакомиться через страницу загрузки.

Работа с виджетами в Kivy

Виджеты — это отображаемые на экране элементы управления, которыми пользователь может оперировать. Любой инструментарий графического интерфейса пользователя поставляется с набором виджетов. Типичными представителями виджетов, что вы не раз использовали, являются кнопки, выпадающие списки и вкладки. Внутри фреймворка Kivy встроено много виджетов.

Запуск программы «Hello, Kivy!»

Принцип работы Kivy можно уловить, взглянув на следующее приложение «Hello, World!»:

from kivy.app import App

from kivy.uix.label import Label

class MainApp(App):

def build(self):

label = Label(text=‘Hello from Kivy’,

size_hint=(.5, .5),

pos_hint={‘center_x’: .5, ‘center_y’: .5})

return label

if __name__ == ‘__main__’:

app = MainApp()

app.run()

Каждому приложению Kivy требуется создать подкласс App и переопределить метод build(). Сюда вы помещаете код UI или вызываете другие функции, которые определяют код UI. В данном случае создается виджет Label и передается text, size_hint и pos_hint. Последние два аргумента не обязательны.

size_hint говорит Kivy о размерах что нужно использовать при создании виджета. Используются два числа:

Первое число x указывает на размер ширины элемента управления.
Второе число y указывает на размер высоты элемента управления.

Значение обоих чисел должно быть в промежутке между 0 и 1. Значение по обоих показателей по умолчанию равно 1. Также можно задействовать pos_hint, что используется для позиционирования виджета. В коде, размещенном выше, указывается, что виджет должен быть размещен в центре осей x и y.

Для запуска приложения нужно инициализировать класс MainApp и вызвать метод run(). После этих действий на экране появится следующее:

Kivy также выводит в stdout довольно много текста:

[INFO ] [Logger ] Record log in /home/mdriscoll/.kivy/logs/kivy_19—06—07_2.txt

[INFO ] [Kivy ] v1.11.0

[INFO ] [Kivy ] Installed at «/home/mdriscoll/code/test/lib/python3.6/site-packages/kivy/__init__.py»

[INFO ] [Python ] v3.6.7 (default, Oct 22 2018, 11:32:17)

[GCC 8.2.0]

[INFO ] [Python ] Interpreter at «/home/mdriscoll/code/test/bin/python»

[INFO ] [Factory ] 184 symbols loaded

[INFO ] [Image ] Providers: img_tex, img_dds, img_sdl2, img_gif (img_pil, img_ffpyplayer ignored)

[INFO ] [Text ] Provider: sdl2([‘text_pango’] ignored)

[INFO ] [Window ] Provider: sdl2([‘window_egl_rpi’] ignored)

[INFO ] [GL ] Using the «OpenGL» graphics system

[INFO ] [GL ] Backend used <sdl2>

[INFO ] [GL ] OpenGL version <b‘4.6.0 NVIDIA 390.116’>

[INFO ] [GL ] OpenGL vendor <b‘NVIDIA Corporation’>

[INFO ] [GL ] OpenGL renderer <b‘NVS 310/PCIe/SSE2’>

[INFO ] [GL ] OpenGL parsed version: 4, 6

[INFO ] [GL ] Shading version <b‘4.60 NVIDIA’>

[INFO ] [GL ] Texture max size <16384>

[INFO ] [GL ] Texture max units <32>

[INFO ] [Window ] auto add sdl2 input provider

[INFO ] [Window ] virtual keyboard not allowed, single mode, not docked

[INFO ] [Base ] Start application main loop

[INFO ] [GL ] NPOT texture support is available

Это может быть полезно для отладки приложения.

Далее добавим виджет Image и посмотрим, чем он отличается от Label.

Отображение виджета Image в Kivy Python

В Kivy есть несколько видов виджетов, связанных с изображениями. Для загрузки картинок с жесткого диска можно задействовать Image, а при использовании адреса URL подойдет AsyncImage. К следующем примере берется стандартный класс Image:

from kivy.app import App

from kivy.uix.image import Image

class MainApp(App):

def build(self):

img = Image(source=‘/path/to/real_python.png’,

size_hint=(1, .5),

pos_hint={‘center_x’:.5, ‘center_y’:.5})

return img

if __name__ == ‘__main__’:

app = MainApp()

app.run()

В данном коде импортируется Image из подпакета kivy.uix.image. Класс Image принимает много разных параметров, однако единственным для нас нужным является source, что указывает Kivy, какое изображение должно быть загружено. Здесь передается полный путь к выбранному изображению. Оставшаяся часть кода такая же, как и в прошлом примере.

После запуска кода должно выводиться нечто подобное:

Текст из предыдущего примера был заменен картинкой.

Теперь рассмотрим, как добавить и оптимально расположить несколько виджетов в приложении.

Разметка (Layout) в UI Kivy

У каждого фреймворка есть свой собственный метод для размещения виджетов. К примеру, в wxPython используются классификаторы, а в Tkinter будет задействован лейаут, или менеджер геометрии. В Kivy за это отвечают Лейауты (Layouts). Доступно несколько различных типов Лейаутов. Чаще всего используются следующие виды:

BoxLayout;
FloatLayout;
GridLayout.

Найти полный список доступных Лейаутов можно в документации Kivy. Рабочий исходный код можно найти в kivy.uix.

Рассмотрим BoxLayout на примере следующего кода:

import kivy

import random

from kivy.app import App

from kivy.uix.button import Button

from kivy.uix.boxlayout import BoxLayout

red = [1,0,0,1]

green = [0,1,0,1]

blue = [0,0,1,1]

purple = [1,0,1,1]

class HBoxLayoutExample(App):

def build(self):

layout = BoxLayout(padding=10)

colors = [red, green, blue, purple]

for i in range(5):

btn = Button(text=«Button #%s» % (i+1),

background_color=random.choice(colors)

)

layout.add_widget(btn)

return layout

if __name__ == «__main__»:

app = HBoxLayoutExample()

app.run()

Здесь из kivy.uix.boxlayout импортируется модуль BoxLayout и затем устанавливается. После этого создается список цветов, которые представляют собой цвета RGB (Red-Blue-Green).

В конечном итоге формируется цикл для range из 5, результатом чего является кнопка btn для каждой итерации. Сделаем вещи немного интереснее и поставим в качестве фона кнопки background_color случайный цвет. Теперь можно добавить кнопку в лейаут при помощи layout.add_widget(btn).

После запуска кода выведется нечто подобное:

Здесь представлены 5 кнопок, окрашенных случайным образом, по одной для каждой итерации цикла for.

Во время создания лейаута следует учитывать следующие аргументы:

padding: Отступ padding между лейаутом и его дочерними элементами уточняется в пикселях. Для этого можно выбрать один из трех способов:
1. Список из четырех аргументов: [padding_left, padding_top, padding_right, padding_bottom]
2. Список из двух аргументов: [padding_horizontal, padding_vertical]
3. Один аргумент: padding=10
spacing: При помощи данного аргумента добавляется расстояние между дочерними виджетами.
orientation: Позволяет изменить значение orientation для BoxLayout по умолчанию — с горизонтального на вертикальное.

Добавление событий в Kivy

Как и многие другие инструментарии GUI, по большей части Kivy полагается на события. Фреймворк отзывается на нажатие клавиш, кнопки мышки или прикосновение к сенсорному экрану. В Kivy задействован концепт Часов (Clock), что дает возможность создать своего рода график для вызова определенных функций в будущем.

В Kivy также используется концепт Свойств (Properties), что работает с EventDispatcher. Свойства помогают осуществить проверку достоверности. Они также запускают события, когда виджет меняет размер или позицию.

Добавим событие для кнопки из предыдущего кода:

from kivy.app import App

from kivy.uix.button import Button

class MainApp(App):

def build(self):

button = Button(text=‘Hello from Kivy’,

size_hint=(.5, .5),

pos_hint={‘center_x’: .5, ‘center_y’: .5})

button.bind(on_press=self.on_press_button)

return button

def on_press_button(self, instance):

print(‘Вы нажали на кнопку!’)

if __name__ == ‘__main__’:

app = MainApp()

app.run()

В данном коде вызывается button.bind(), а событие on_press ссылается на MainApp.on_press_button().

Этот метод неявно принимает экземпляр виджета, который является самим объектом кнопки. Сообщение будет выводиться на stdout всякий раз при нажатии пользователем на кнопку.

Использование языка дизайна KV

Kivy предоставляет язык дизайна KV, что можно использовать в приложениях Kivy. Язык KV позволяет отделить дизайн интерфейса от логики приложения. Он придерживается принципа разделения ответственности и является частью архитектурного паттерна Модель-Представление-Контроллер (Model-View-Controller). Предыдущий пример можно обновить, используя язык KV:

from kivy.app import App

from kivy.uix.button import Button

class ButtonApp(App):

def build(self):

return Button()

def on_press_button(self):

print(‘Вы нажали на кнопку!’)

if __name__ == ‘__main__’:

app = ButtonApp()

app.run()

С первого взгляда данный код может показаться несколько странным, так как кнопка Button создается без указания атрибутов или привязывания к ним событий. Здесь Kivy автоматически ищет файл с таким же названием, что и у класса, только строчными буквами и без части App в названии класса.

В данном случае названием класса является ButtonApp, поэтому Kivy будет искать файл button.kv. Если такой файл существует, и он также форматирован должным образом, тогда Kivy использует его при загрузке UI. Попробуйте создать такой файл и добавить следующий код:

<Button>:

text: ‘Press me’

size_hint: (.5, .5)

pos_hint: {‘center_x’: .5, ‘center_y’: .5}

on_press: app.on_press_button()

Действия каждой строки:

Строка 1 соответствует вызову Button в коде Python. Kivy должен осмотреть инициализированный объект для определения кнопки;
Строка 2 устанавливает text кнопки;
Строка 3 устанавливает ширину и высоту при помощи size_hint;
Строка 4 устанавливает позицию кнопки через pos_hint;
Строка 5 устанавливает обработчик событий on_press. Для указания Kivy места обработчика событий используется app.on_press_button(). Здесь Kivy будет искать метод .on_press_button() в классе Application.

Вы можете установить все ваши виджеты и лейауты внутри одного или нескольких файлов языка KV. Язык KV также поддерживает импорт модулей Python в KV, создавая динамичные классы, и это далеко не предел. Ознакомиться с полным перечнем его возможностей можно в гиде Kivy по языку KV.

Теперь мы можем приступить к созданию настоящего рабочего приложения.

Создание приложения Kivy Python

Создание чего-то полезное несомненно является отличным способом выучить новый навык. Учитывая данное утверждение, давайте используем Kivy при создании калькулятора, который будет поддерживать следующие операции:

Сложение;
Вычитание;
Умножение;
Деление.

В данном приложении будет использован набор кнопок в своего рода лейауте. В верхней части также будет специальный блок для вывода операций и их результатов. В итоге калькулятор будет выглядеть следующим образом:

Теперь, когда у нас есть в наличии целевой UI, может составить код:

from kivy.app import App

from kivy.uix.boxlayout import BoxLayout

from kivy.uix.button import Button

from kivy.uix.textinput import TextInput

class MainApp(App):

def build(self):

self.operators = [«/», «*», «+», «-«]

self.last_was_operator = None

self.last_button = None

main_layout = BoxLayout(orientation=«vertical»)

self.solution = TextInput(

multiline=False, readonly=True, halign=«right», font_size=55

)

main_layout.add_widget(self.solution)

buttons = [

[«7», «8», «9», «/»],

[«4», «5», «6», «*»],

[«1», «2», «3», «-«],

[«.», «0», «C», «+»],

]

for row in buttons:

h_layout = BoxLayout()

for label in row:

button = Button(

text=label,

pos_hint={«center_x»: 0.5, «center_y»: 0.5},

)

button.bind(on_press=self.on_button_press)

h_layout.add_widget(button)

main_layout.add_widget(h_layout)

equals_button = Button(

text=«=», pos_hint={«center_x»: 0.5, «center_y»: 0.5}

)

equals_button.bind(on_press=self.on_solution)

main_layout.add_widget(equals_button)

return main_layout

Калькулятор работает следующим образом:

В строках с 8 по 10 создается список operators и несколько полезных значений, last_was_operator и last_button, которые будут использованы чуть позже.
В строках с 11 по 15 создается лейаут верхнего уровня main_layout, к нему также добавляется виджет только для чтения TextInput.
В строках с 16 по 21 создается вложенный список из списков, где есть большая часть кнопок для калькулятора.
В строке 22 начинается цикл for для кнопок. Для каждого вложенного списка делается следующее:
1. В строке 23 создается BoxLayout с горизонтальной ориентацией.
2. В строке 24 начинается еще один цикл for для элементов вложенного списка.
3. В строках с 25 по 39 создаются кнопки для ряда и связываются обработчиком событий, после чего кнопки добавляются к горизонтальному BoxLayout из строки 23.
4. В строке 31 этот лейаут добавляется к main_layout.
В строках с 33 по 37 создается кнопка равно (=) и привязывается к обработчику событий, после чего она добавляется к main_layout.

Далее создается обработчик событий .on_button_press(). Код будет выглядеть следующим образом:

def on_button_press(self, instance):

current = self.solution.text

button_text = instance.text

if button_text == «C»:

# Очистка виджета с решением

self.solution.text = «»

else:

if current and (

self.last_was_operator and button_text in self.operators):

# Не добавляйте два оператора подряд, рядом друг с другом

return

elif current == «» and button_text in self.operators:

# Первый символ не может быть оператором

return

else:

new_text = current + button_text

self.solution.text = new_text

self.last_button = button_text

self.last_was_operator = self.last_button in self.operators

Почти все виджеты приложения вызывают .on_button_press(). Это работает следующим образом:

Строка 41 принимает аргумент instance, в результате чего можно узнать, какой виджет вызвал функцию.
Строки между 42 и 43 извлекают и хранят значения solution и text кнопки.
Строки c 45 по 47 проверяют, на какую кнопку нажали. Если пользователь нажимает с, тогда очищается solution. В противном случае используется утверждение else.
Строка 49 проверяет, было ли у решения предыдущее значение.
Строки с 50 по 52 проверяют, была ли последняя нажатая кнопка оператором. Если да, тогда solution обновляться не будет. Это необходимо для предотвращения создания двух операций в одном ряду. К примеру, 1 * / будет недействительным утверждением.
Строки с 53 по 55 проверяют, является ли первый символ оператором. Если да, тогда solution обновляться не будет, так как первое значение не может быть значением оператора.
Строки с 56 по 58 переходят к условию else. Если никакое из предыдущих значений не найдено, тогда обновляется solution.
Строка 59 устанавливает last_button к метке последней нажатой кнопки.
Строка 60 устанавливает last_was_operator к значению True или False в зависимости от того, был символ оператором или нет.

Последней частью кода будет .on_solution():

def on_solution(self, instance):

text = self.solution.text

if text:

solution = str(eval(self.solution.text))

self.solution.text = solution

Здесь берется текущий текст из solution и используется встроенный в Python eval() для исполнения. Если пользователь создал формулу вроде 1+2, тогда eval() запустит код и вернет результат. В конце результат устанавливается как новое значение виджета solution.

На заметку: порой eval() бывает опасным, так как он может запустить произвольный код. Многие разработчики избегают его использование именно по этой причине. Тем не менее, ввиду задействования только целых чисел, операторов и точки в качестве вводных данных для eval(), в данном контексте его можно использовать безопасно.

При запуске данного кода на рабочем столе компьютера приложение будет выглядеть следующим образом:

Полный текст кода примера калькулятора представлен ниже:

from kivy.app import App

from kivy.uix.boxlayout import BoxLayout

from kivy.uix.button import Button

from kivy.uix.textinput import TextInput

class MainApp(App):

def build(self):

self.operators = [«/», «*», «+», «-«]

self.last_was_operator = None

self.last_button = None

main_layout = BoxLayout(orientation=«vertical»)

self.solution = TextInput(

multiline=False, readonly=True, halign=«right», font_size=55

)

main_layout.add_widget(self.solution)

buttons = [

[«7», «8», «9», «/»],

[«4», «5», «6», «*»],

[«1», «2», «3», «-«],

[«.», «0», «C», «+»],

]

for row in buttons:

h_layout = BoxLayout()

for label in row:

button = Button(

text=label,

pos_hint={«center_x»: 0.5, «center_y»: 0.5},

)

button.bind(on_press=self.on_button_press)

h_layout.add_widget(button)

main_layout.add_widget(h_layout)

equals_button = Button(

text=«=», pos_hint={«center_x»: 0.5, «center_y»: 0.5}

)

equals_button.bind(on_press=self.on_solution)

main_layout.add_widget(equals_button)

return main_layout

def on_button_press(self, instance):

current = self.solution.text

button_text = instance.text

if button_text == «C»:

# Очистка виджета с решением

self.solution.text = «»

else:

if current and (

self.last_was_operator and button_text in self.operators):

# Не добавляйте два оператора подряд, рядом друг с другом

return

elif current == «» and button_text in self.operators:

# Первый символ не может быть оператором

return

else:

new_text = current + button_text

self.solution.text = new_text

self.last_button = button_text

self.last_was_operator = self.last_button in self.operators

def on_solution(self, instance):

text = self.solution.text

if text:

solution = str(eval(self.solution.text))

self.solution.text = solution

if __name__ == «__main__»:

app = MainApp()

app.run()

Пришло время разместить приложение в Google Play или в AppStore!

По завершении составления кода вы можете поделиться своим приложением с другими. Хорошим способом сделать это может стать превращение вашего кода в приложения для смартфона на Android. Для этого вначале нужно установить пакет buildozer через pip:

Затем создается новая папка, после чего нужно перейти в нее через терминал. Затем выполняется следующая команда:

После этого создается файл buildozer.spec, который будет использован для конфигурации сборки. К примеру, первые две строчки файла спецификации можно редактировать следующим образом:

[app]

# (str) Название вашего приложения

title = KvCalc

# (str) Название упаковки

package.name = kvcalc

# (str) Домен упаковки (нужен для упаковки android/ios)

package.domain = org.kvcalc

Не бойтесь посмотреть оставшуюся часть файла для выяснения того, что еще можно поменять.

На данный момент приложение почти готово к сборке, однако для начала нужно установить зависимости для buildozer. После их установки скопируйте ваше приложение калькулятора в новую папку и переименуйте его в main.py. Этого требует buildozer. Если файл будет назван неверно, тогда процесс сборки завершится неудачей.

Теперь можно запустить следующую команду:

$ buildozer —v android debug

Этап сборки займет время! На моем компьютере на это ушло около 15-20 минут. Здесь все зависит от вашего железа, так что времени может потребоваться еще больше. Расслабьтесь, налейте чашечку кофе или прогуляйтесь. Buildozer скачает те элементы Android SDK, которые нужны для процесса сборки. Если все идет по плану, тогда в папке bin появится файл под названием, напоминающим что-то вроде kvcalc-0.1-debug.apk.

Далее требуется связать телефон Android с компьютером и перенести туда файл apk. Затем откройте менеджер файлов телефона и кликните на файл apk. Android должен спросить, хотите ли вы установить приложение. Есть вероятность появления предупреждения, ведь приложение было скачано не из Google Play. Тем не менее, вы по-прежнему сможете установить его.

Вот как выглядит калькулятор, запущенный на Samsung S9:

У buildozer также есть несколько других команд, которые вы можете использовать. Изучите документацию, чтобы подробнее узнать об этом.

При необходимости добиться более детального управления упаковку можно осуществить через python-for-android. Здесь это обсуждаться не будет, но если интересно, ознакомьтесь, как еще можно быстро начать проект.

Создание приложений для iPhone (iOS) на Python

Инструкция для сборки приложения для iOS будет немного сложнее, нежели для Android. Для получения последней информации всегда проверяйте обновления официальной документации Kivy.

Вам нужен будет компьютер с операционной системой OS X: MacBook или iMac. На Linux или Windows вы не сможете создать приложения для Apple.

Перед упаковкой приложения для iOS на Mac необходимо выполнить следующие команды:

$ brew install autoconf automake libtool pkg—config

$ brew link libtool

$ sudo easy_install pip

$ sudo pip install Cython==0.29.10

После успешной установки нужно скомпилировать при использования следующих команд:

$ git clone git://github.com/kivy/kivy—ios

$ cd kivy—ios

$ ./toolchain.py build python3 kivy

Если вы получаете ошибку, где говорится, что iphonesimulator не найден, тогда поищите способ решение проблемы на StackOverflow, после чего попробуйте запустить команды вновь.

Если вы получаете ошибки SSL, тогда скорее всего у вас не установлен OpenSSL от Python. Следующая команда должна это исправить:

$ cd /Applications/Python 3.7/

$ ./Install Certificates.command

Теперь вернитесь назад и запустите команду toolchain опять.

После успешного выполнения всех указанных выше команд можете создать проект Xcode при помощи использования скрипта toolchain. Перед созданием проекта Xcode переименуйте ваше главное приложение в main.py, это важно. Выполните следующую команду.

./toolchain.py create <title> <app_directory>

Здесь должна быть папка под названием title, внутри которой будет проект Xcode. Теперь можно открыть проект Xcode и работать над ним отсюда. Обратите внимание, что если вы хотите разместить свое приложение на AppStore, вам понадобится создать аккаунт разработчика на developer.apple.com и заплатить годовой взнос.

Создание exe приложений для Windows на Python используя Kivy

Упаковать приложение Kivy для Windows можно при помощи PyInstaller. Если ранее вы никогда не работали с ним, тогда изучите тему использования PyInstaller для упаковки кода Python в исполняемый файл.

Для установки PyInstaller можно использовать pip:

$ pip install pyinstaller

Следующая команда упакует ваше приложение:

Команда создаст исполняемый файл Windows, а вместе с ним еще несколько других файлов. Аргумент -w говорит PyInstaller, что приложение открывается в оконном режиме и не является приложение для командной строки. Если вы хотите, чтобы PyInstaller создал только один исполняемый файл, тогда можете передать в дополнение к -w аргумент --onefile.

Создание приложений для macOS на Python используя Kivy

Как и в случае с Windows, для создания исполняемого файла Mac можно также использовать PyInstaller. Единственным условием является запуск следующей команды на Mac:

$ pyinstaller main.py —w —onefile

Результатом станет один исполняемый файл в папке dist. Название исполняемого файла будет таким же, как и название файла Python, что был передан PyInstaller.

Если вы хотите уменьшить размер исполняемого файла или использовать в приложении GStreamer, тогда для получения дополнительной информации изучите тему упаковки для macOS.

Заключение

Kivy является действительно интересным фреймворком GUI, что можно использовать для создания пользовательских интерфейсов и мобильных приложений для Android и iOS. Внешне приложения Kivy будут отличаться от нативных приложений выбранной платформы. В том случае, если вы хотите выделяться на фоне конкурентов, это может быть выгодным преимуществом.

В данном руководстве были рассмотрены основы Kivy, среди которых стоит выделить добавление виджетов, привязку событий, планировку виджетов и лейауты, а также использование языка KV. В результате мы получили рабочее приложение Kivy и рассмотрели способы его переноса на другие платформы, в том числе мобильные.

В Kivy есть множество виджетов и концептов, которые не были рассмотрены в статьи. Для дальнейшего изучения темы можете изучить официальный сайт Kivy, где размещены разнообразные руководства, примеры приложений и многое другое.

Интро

Можно не читать, в интро всякая лирика.

Пришлось пожить в одной стране, в одной гостинице, где кормили ежедневно яйцами на завтрак и больше ничем, так через месяц начал чесаться. Обращался за медицинской помощью, хотя раньше никогда ничем подобным не страдал. Наученный горьким опытом после этого для себя решил допускать как можно меньше повторений в еде, чтобы ничего не успевало в организме накопиться. Это мой личный опыт, я просто рассказываю, без навязывания. Возможно, нет правил без исключения, наверное, овсянку можно есть и каждый день на протяжении десятков лет.

Скриншоты

Предположим мой рацион состоит из 50 блюд. Например, сегодня ел омлет. Нажимаю на кнопку, и омлет стал на 50 строку в очереди, а перед ним стоят 49 блюд, которые съем, чтобы опять добраться до омлета. Вот и вся логика приложения. (На скриншотах блюда нагенеренные, все совпадения случайны, к моему реальному рациону отношения не имеющие).

Исходный код и пояснения

Я сознательно не использовал kv файлы, так как код дан в учебных целях, для людей, которые знакомы с python. Все написано на голом python. В пояснениях я не буду останавливаться на объяснении python кода, а сразу перейду к специфическим фишкам Kivy.

Запуск на windows & linux & macos

Принцип для всех операционок одинаковый:

Программа должна заработать.

Сборка apk файла и запуск на телефоне с андроид

Итак, у нас есть файл с кодом программы, написанный на python. Как теперь создать приложение, чтобы его можно было запустить на телефоне с андроидом? Раньше это был достаточно мудреный процесс, требующий навыков и танцев с бубном. Теперь это не проблема.
Вот пошаговая инструкция:

Как закинуть apk файл на телефон?

Можно, конечно, сделать это как угодно, отправить себе по почте, куда-нибудь выложить, закинуть в телеграмм и т.д., а потом скачать приложение на телефон.

Но существует специализированный инструмент для этого. Включаем на телефоне режим разработчика, подключаем USB-кабелем. Виртуалка должна увидеть, что вы подключили телефон. Дальше устанавливаем adb:

После установки заходим в папку bin и вводим команду

И можно примерно через минутку увидеть на телефоне приложение после того, как увидим
Success в консоли.

Если вдруг приложение падает или ведет себя не так, как ожидалось, то есть вот такая команда для просмотра ошибок

Русское имя приложения

Если вы захотите, чтобы ваше приложение называлось по-русски, например, «Дневник питания», то надо внести изменения в файл:

В тег appName прописывается русское название приложения, эта папка создается после первого запуска buildozer android debug. После того как файл отредактируете, вернитесь назад в папку FoodOptions и запустите buildozer android debug повторно. Файл соберется по-новой. После установки на телефон имя программы будет написано на русском.

О файле buildozer.spec

Вот мой файл с гитхаба: buildozer.spec
Именно этот файл указывает buildozer-у, как именно собрать пакет.

Там множество разных вариаций. Кому интересно, то введите внутри виртуалки команду:

Будет создан дефолтный файл buildozer.spec с кучей комментариев и пояснений. Например, если вы хотите какую-нибудь свою иконку для приложения, то указываете в строке:

свой файл с иконкой. И приложение соберется уже с вашей иконкой.

Если вам надо подгрузить какой-нибудь специфический модуль, который не входит в официальную библиотеку python, то это делается в строке requirements =. В общем, рассказ о файле buildozer.spec может занять целую статью, а то и две.

Загрузка приложения в Google Play

Надо зарегаться, пройти все процедуры, получить ключи. И дальше запускать:

Полученный файл apk-apkname-release.apk заливать в Google Play.

Ссылки

Источник

Create a package for Windows¶

This document only applies for kivy 1.9.1 and greater.

Packaging your application for the Windows platform can only be done inside the Windows OS. The following process has been tested on Windows with the Kivy wheels installation, see at the end for alternate installations.

The package will be either 32 or 64 bits depending on which version of Python you ran it with.

Requirements¶

Latest Kivy (installed as described in Installation on Windows ).

PyInstaller default hook¶

Packaging a simple app¶

Open your command line shell and ensure that python is on the path (i.e. python works).

For more options, please consult the PyInstaller Manual.

To add the dependencies, before the first keyword argument in COLLECT add a Tree object for every path of the dependencies. E.g. *[Tree(p) for p in (sdl2.dep_bins + glew.dep_bins)] so it’ll look something like:

Now we build the spec file in TouchApp with:

The compiled package will be in the TouchAppdisttouchtracer directory.

Single File Application¶

Next, we will modify the example above to package the touchtracer example project as a single file application. Following the same steps as above, instead issue the following command:

As before, this will generate touchtracer.spec, which we will edit to add the dependencies. In this instance, edit the arguments to the EXE command so that it will look something like this:

Now you can build the spec file as before with:

The compiled package will be in the TouchAppdist directory and will consist of a single executable file.

Bundling Data Files¶

First, follow PyInstaller documentation on how to include data files in your application.

Modify your main python code to include the following imports (if it doesn’t have them already):

Modify your main python code to include the following (using the touchtracer app as an example):

Finally, follow the steps for bundling your application above.

Packaging a video app with gstreamer¶

to create the gstvideo.spec file. Edit as above and this time include the gstreamer dependency as well:

and add the Tree() to include the video files, e.g. Tree(‘examples-path\widgets’) as well as the gstreamer dependencies so it should look something like:

Then build the spec file in VideoPlayer with:

If you’re using Pygame and need PyGame in your packaging app, you’ll have to add the following code to your spec file due to kivy issue #1638. After the imports add the following:

Overwriting the default hook¶

Including/excluding video and audio and reducing app size¶

To use the the alternate hooks with the examples above modify as following to add the hooks with hookspath() and runtime_hooks (if required) and **get_deps_minimal() or **get_deps_all() to specify the providers.

For example, add the import statement:

and then modify Analysis as follows:

to include everything like the default hook. Or:

e.g. to exclude the audio and video providers and for the other core modules only use those loaded.

Источник

Create a package for Android¶

You can create a package for android using the python-for-android project. This page explains how to download and use it directly on your own machine (see Packaging with python-for-android ) or use the Buildozer tool to automate the entire process. You can also see Packaging your application for the Kivy Launcher to run kivy programs without compiling them.

For new users, we recommend using Buildozer as the easiest way to make a full APK. You can also run your Kivy app without a compilation step with the Kivy Launcher app.

Kivy applications can be released on an Android market such as the Play store, with a few extra steps to create a fully signed APK.

Buildozer¶

Buildozer is a tool that automates the entire build process. It downloads and sets up all the prequisites for python-for-android, including the android SDK and NDK, then builds an apk that can be automatically pushed to the device.

Buildozer currently works only in Linux, and is a beta release, but it already works well and can significantly simplify the apk build.

This will install buildozer in your system. Afterwards, navigate to your project directory and run:

This creates a buildozer.spec file controlling your build configuration. You should edit it appropriately with your app name etc. You can set variables to control most or all of the parameters passed to python-for-android.

Finally, plug in your android device and run:

to build, push and automatically run the apk on your device.

Buildozer has many available options and tools to help you, the steps above are just the simplest way to build and run your APK. The full documentation is available here. You can also check the Buildozer README at https://github.com/kivy/buildozer.

Packaging with python-for-android¶

You can also package directly with python-for-android, which can give you more control but requires you to manually download parts of the Android toolchain.

Packaging your application for the Kivy Launcher¶

The Kivy launcher is an Android application that runs any Kivy examples stored on your SD Card. To install the Kivy launcher, you must:

Go to the Kivy Launcher page on the Google Play Store

Select your phone… And you’re done!

If you don’t have access to the Google Play Store on your phone/tablet, you can download and install the APK manually from http://kivy.org/#download.

Once the Kivy launcher is installed, you can put your Kivy applications in the Kivy directory in your external storage directory (often available at /sdcard even in devices where this memory is internal), e.g.

should be a directory containing:

The file android.txt must contain:

These options are just a very basic configuration. If you create your own APK using the tools above, you can choose many other settings.

Installation of Examples¶

Kivy comes with many examples, and these can be a great place to start trying the Kivy launcher. You can run them as below:

Run the launcher and select one of the Pictures, Showcase, Touchtracer, Cymunk or other demos…

Release on the market¶

If you have built your own APK with Buildozer or with python-for-android, you can create a release version that may be released on the Play store or other Android markets.

Targeting Android¶

Kivy is designed to operate identically across platforms and as a result, makes some clear design decisions. It includes its own set of widgets and by default, builds an APK with all the required core dependencies and libraries.

It is possible to target specific Android features, both directly and in a (somewhat) cross-platform way. See the Using Android APIs section of the Kivy on Android documentation for more details.

Источник

Kivy. Сборка пакетов под Android и никакой магии

Сохраните, откройте терминал в директории с файлом main.py и установите библиотеку KivyMD:

После установки можно протестировать наш код:

Результатом работы скрипта будет экран с Toolbar и одной кнопкой «Hello World»:

Дальше нам нужно создать файл спецификации buildozer.spec, который должен располагаться в той же директории, что и файл main.py:

Если вы не закрывали терминал (если терминал был закрыт, откройте его в директории TestKivyMD), введите команду:

Эта команда создаст дефолтный файл спецификации. Откройте его и отредактируйте:

Здесь все понятно поэтому дополнительные комментарии излишни. Почитайте внимательно дефолтную спецификацию, в ней можно указать путь к иконке, пресплеш при загрузке приложения и многое другое. Я оставил лишь то, что нам сейчас нужно для сборки нашего тестового пакета. И, собственно, запускаем процесс сборки командой в терминале:

Кофе выпит и самое время заглянуть в терминал:

Вуаля! Наше приложение построено! Самое время закинуть его на смартфон и запустить:

Все работает! И оказывается не все так сложно, как казалось.

Также меня спрашивали:

Ниже я привожу код из статьи Про Flutter, кратко: Основы:

А вот абсолютно тоже самое, но с использованием Kivy и KivyMD:

По-моему, вывод очевиден и не нуждается в моем комментировании…

Надеюсь, был вам полезен. Оставляю опрос на тему «Удалось ли вам построить приложение для Андроид».

Источник

Kivy — Создание мобильных приложений на Python

Содержание

В руководстве будут разобраны следующие темы:

Принципы работы фреймворка Kivy Python

Установка Kivy

Виртуальная среда Python создается следующим образом:

Источник

Introduction

Kivy can build applications for desktop and mobile including Android and iOS.
The same code base can be used for both desktop and mobile, depending
on what hardware devices you are trying to access.

This guide will walk through the basics of installing Kivy,
building simple applications, building and packaging them for
desktop and Android.

For an example of a complete project, check out my
Bitcoin Price Checker example
with the Live Stream on YouTube.

Alternatives for desktop application programming with Python are
PyQt5, Tkinter, and wxPython.
Those packages have a more traditional desktop UI but lack the Android and iOS
build capabilities the same way Kivy has. Qt technically supports Android
but it is not easy to build with PyQt5.

Important concepts

There are a few concepts to understand in mind when building a Kivy application:

Layouts — Screen layouts are defined in a .kv template file using a special Kivy language
Widgets — The UI elements that get packed in to layout elements. Buttons, for example.
A layout is just another type of widget

To create a Kivy application in Python, there are a few easy steps:

Create a class that inherits the Kivy main app class kivy.app.App
Define a build() method in the class that returns a root widget; anything from a single Button (kivy.uix.button.Button) to a complex GridLayout (kivy.uix.gridlayout.GridLayout)).
Create an instance of your class and call the .run() method.

That is all there is to a Kivy app at a high level.

Installation

You will need to install the Python package kivy at a minimum.
There is also an optional package called plyer that contains a number
of cross-platform APIs for accessing device features like notifications
and GPS. Another package used for building Android and iOS is named buildozer.

You have a few options for installing Kivy:

From source: https://github.com/kivy/kivy
Download it from the Kivy website
Use pip to install the packages

To use pip to install Kivy:

# The core package
python -m pip install kivy

# For additional cross-platform APIs like notifications, GPS, and vibrator
python -m pip install plyer
# For Android/iOS building (Linux only)
python -m pip install buildozer

# You probablyalso need cython for the Android builds
python -m pip install cython
# Or use your system package like this for Fedora:
sudo dnf install python3-Cython

On Fedora, I needed to install ncurses-compat-libs to resolve the error:
$HOME/.buildozer/android/platform/android-ndk-r17c/toolchains/llvm/prebuilt/linux-x86_64/bin/clang: error while loading shared libraries: libtinfo.so.5: cannot open shared object file: No such file or directory.

# For Fedora might be needed
dnf install ncurses-compat-libs

In Ubuntu, others report similar: https://github.com/kivy/buildozer/issues/841

# Ubuntu fixes
sudo apt-get install libncurses5-dev libncursesw5-dev
sudo apt-get install libtinfo5

In Windows, you may need to install other dependencies.
Official instrucations: Installation in Windows

# Other pip packages to install
python -m pip install pypiwin32
python -m pip install kivy_deps.glew
# One of the backends:
python -m pip install kivy_deps.sdl2
python -m pip install kivy.deps.angle
# If needed for video
python -m pip install kivy.deps.gstreamer

Check installed version

Once Kivy is installed, you can verify it is installed
properly and check what version you have installed.

To check what version of Kivy you have, you run pip list to check
the Kivy package version, or just open your Python interpreter and
import kivy and inspect kivy.__version__.

>>> import kivy
[INFO   ] [Kivy        ] v1.11.1
[INFO   ] [Kivy        ] Installed at "/usr/local/lib64/python3.7/site-packages/kivy/__init__.py"
[INFO   ] [Python      ] v3.7.4 (default, Jul  9 2019, 16:32:37) 
[GCC 9.1.1 20190503 (Red Hat 9.1.1-1)]
[INFO   ] [Python      ] Interpreter at "/usr/bin/python3"
>>> kivy.__version__
'1.11.1'

Start a new project

A Kivy application can be as simple as a single .py file.
This is an example of a minimal application that loads a window with one widget, a button:

# main.py
# Modified from https://kivy.org/doc/stable/guide/basic.html
import kivy
kivy.require('1.11.1')  # Set to your Kivy version
from kivy.app import App
from kivy.uix.button import Button


class MyApp(App):
    def build(self):
        return Button(text='This is a button.')


MyApp().run()

Run the application by executing the Python file:

python main.py

Use the Kv language

In the first example we just returned a single root widget, the button.
You can use methods like .add_widget() to pack in nested widgets,
but it can be tedious to do all the layout building programmatically.

This is why Kivy created the Kv language for defining widget trees.
It is similar to YAML but defines the heirarchy of widgets.
It is easier to work with visually and creates separation between the
view layer and the controller code.

While the Kv language is optional, and you don’t have to use it,
it is the preferred way to build layouts and worth
getting familiar with.
Read more about the KV language in the official Kv language guide

You can provide KV templates as separate .kv files or as hard-coded
strings inside your Python code.

When building a user interface, you first need to understand the layouts.
The layouts will allow you to organize the screen.
For example, do you want to stack up
a list of buttons vertically, or do you want to have a main
frame with a top and bottom bar, or do you want a 3×3 grid of buttons?

Read more about layouts.
These are some of the common layout types:

kivy.uix.boxlayout.BoxLayout
kivy.uix.gridlayout.GridLayout
kivy.uix.stacklayout.StackLayout
kivy.uix.pagelayout.PageLayout

Once you have a layout (which you can nest inside other layouts),
you can start putting widgets in it.
Widgets are things like buttons, text fields, and checkboxes.
Read more about widgets in the official Widget Guide.

Here is an example .kv file that uses a box layout to hold
two buttons. This creates two buttons side-by-side with no text.
While it is valid and demonstrates the simplest case, it’s
not very useful.

# example.kv
BoxLayout:
    Button:
    Button:

Once you have a .kv file ready, you need to load it in your application.
By default, it tries to map your app class to a .kv based off of the name.
For example, if your app is named PracticeApp it will look for a file named
practice.kv. I prefer to be more explicit and use kivy.lang.builder.Builder.load_file()
to load a specific file. Alternatively, if you don’t want to use a file at all, you can use
kivy.lang.builder.Builder.load_string() to load a string with the Kv contents.

Here is an example of how to load the simple example.kv file we created a few lines above.

# main.py
import kivy
kivy.require('1.11.1')  # Set to your Kivy version
from kivy.app import App
from kivy.lang.builder import Builder


class MyApp(App):
    def build(self):
        return Builder.load_file('example.kv')


MyApp().run()

A button generally needs some text and and a callback function to be useful though.
We can modify the .kv file to look more like this:

# example.kv
BoxLayout:
    Button:
        id: btn1
        text: "Button 1"
        on_press: print("%s was pressed" % btn1.text)
    Button:
        text: "Button 2"
        on_press: print(8 * 8)

You can reference other methods from the on_press and other events.
For example in the Button object, referencing self would reference
the Button object, and referencing root would reference the root
widget in the heirarchy (BoxLayout in this case).

A more powerful way to do this would be to create a custom class
that inherits the BoxLayout so we can extend its behavior.

We can swap out the BoxLayout in the .kv file and replace it with our
CustomBoxLayout widget.

# example.kv
MyCustomBoxLayout:
    Button:
        text: "Press me"
        on_press: root.custom_callback()
    Button:

We haven’t actually created the CustomBoxLayout class though.
We need to add one in our .py file like this:

# main.py
import kivy
kivy.require('1.11.1')  # Set to your Kivy version
from kivy.app import App
from kivy.lang.builder import Builder
from kivy.uix.boxlayout import BoxLayout


class MyCustomBoxLayout(BoxLayout):
    def custom_callback(self):
        print('Custom callback called.')


class MyApp(App):
    def build(self):
        return Builder.load_file('example.kv')


MyApp().run()

Running the above example would load the .kv file and hook up the callback specified
in the .kv file with the method defined in the .py file.

Use Plyer to access mobile device hardware

Plyer is a Kivy package that provides an API to hardware devices
like accelerometer, screen brightness, camera, compass, and GPS.
It also provides access to some utilities like notifications,
which work across desktop and mobile. It’s a very ambitious
library that has some cool features. Refer to
the Plyer documentation
for the latest information.

You can also find code examples at:
https://github.com/kivy/plyer/tree/master/examples

As of September 2019, I found several of the examples did not work
on my Android device. The compatibility still seems to be a
bit questionable. Be sure to test out of a module works on device.

python -m pip install plyer

Then you can try building some of the Plyer examples.
See the section further down about how to use buildozer to build an .apk file for Android.

Build and package

Now that we have looked at installing Kivy and building a simple application,
let’s look at how to run and package a Kivy application for distribution.
We’ll look at desktop applications and then Android. I don’t cover
iOS because I don’t have any experience with it, but Kivy does support it.

Build for desktop

You can share your app in a few ways, starting from simplest to most complex packaging:

As source code — let people download your source, install Python and Kivy, and run your script themselves.
As a Python package — Package it with distutils and a setup.py that users can install with python setup.py install
Push the Python package to pypi.org so others can install it with pip install
Use PyInstaller to package a .exe or Mac/Linux equivalent. This can create a directory with the .exe and supporting
files or a standalone .exe (slower to startup). Distribute this as a .zip for others to download and run.
Check out my PyInstaller Tutorial to learn more about how to use it.
Create an system-specific installer package (e.g. MSI installer with InnoSetup for Window, or a .deb package for Ubuntu/Debian)
that install the package created with PyInstaller. Check out my Debian Package Tutorial to learn how to make a .deb.

For more details on packaging, refer to the official documentation for Windows packaging and OSX packaging.

PyInstaller notes

If using PyInstaller to package the application,
there is a special step needed in order to ensure the SDL and glew DLLs are included in the final package.
These notes are taken from the official instructions at:
https://kivy.org/doc/stable/guide/packaging-windows.html#pyinstaller-default-hook.

To use PyInstaller to get a properly built package with the right DLLs,
modify the PyInstaller .spec file to have at the top:

from kivy_deps import sdl2, glew

And in the coll object, after the last positional argument, add:

*[Tree(p) for p in (sdl2.dep_bins + glew.dep_bins)],

This will allow it to find and include the right dependencies since they are included in the code.
This helps with errors like unable to get window.

If you want to create an installer, you need to build an installer for each platform.
For example, you can use Inno Setup to build
Windows installer wizards.

Build for Android

Let’s look at the basic steps for building an Android .apk with a Python Kivy application.
For more in-depth details on building for Android, check out the official documentation pages:

Packaging for Android
Android guide

Test adb

The adb tool is crucial to Android tooling. Buildozer has a way
to use adb. The one special thing to remember when calling adb
through the buildozer command is that you need to add two dashes (--)
before passing the actual command for adb.

To verify everything is working, check the adb version.
Running the version command will also output the full path
to the adb executable that it is using if you want to run it directly yourself.

python -m buildozer -v android adb -- version
# adb path will be something like:
# $HOME/.buildozer/android/platform/android-sdk/platform-tools/adb

You can also use adb to list devices like this:

python -m buildozer -v android adb -- devices

Configure the buildozer.spec file

The buildozer.spec file has all the configuration for
the Android and iOS build parameters.
Generate a template buildozer spec file using init command:

# Generates a `buildozer.spec` file
python -m buildozer init

With the generated buildozer.spec file, edit it to specify things like:

Project name
Version
Source directory
Files to include and exclude
Required Python packages
Icon image — icon.filename a 512×512 PNG
Splash loading image — presplash.filename a 512×512 PNG
Change allowed orientations — orientation = all
Log level (log_level = 2)
Android Permissions
Android API level

Build the APK file

Once you have your Python Kivy application
and a buildozer.spec file for your project.
You can build a debug APK that does not require signing
or a release app that is signed and ready for the Google Play Store.

Build the debug APK

To build the debug APK which doesn’t require any app signing,
runthe android debug command for buildozer.

python3 -m buildozer -v android debug

This will generate an APK file in the bin/ directory with a name like:
myapp-0.1-debug.apk.

Build the release APK

To build the release APK there is more involved than the debug one.
You need to first have a keystore with a key ready to sign the app.

See my Java Keytool Tutorial to
learn how to generate and manage keystores. Once you have a keystore,
come back and the rest will make sense here.

Also refer to the Kivy Wiki: Creating a Release APK.

The main thing Buildozer needs to have is your keystore information.
You can set these values as environment variables.
You need to provide the keystore path, keystore password,
key alias, and key password.

export P4A_RELEASE_KEYSTORE=$HOME/.keystore
export P4A_RELEASE_KEYSTORE_PASSWD=s3cr3t
export P4A_RELEASE_KEYALIAS_PASSWD=s3cr3t
export P4A_RELEASE_KEYALIAS=mykey

Once your keystore environment variables are set, you can run the release build command:

# Requires the buildozer.spec file
python3 -m buildozer -v android release

Release app on the Google Play Store

Once you have a signed release APK from the previous step, you can publish it to the Google Play Store.
I have a dedicated tutorial about this topic.
Check out How to Publish Android Apps to Google Play Store.

Install the app

Install the application to a device (physical or virtual)
by running android debug deploy. This will install it
to all connected devices.

python -m buildozer -v android debug deploy

You can also use buildozer to serve the current directory with
an HTTP server. This is useful so any Android device on the network
can open the HTTP URL in a web browser and download the .apk and install
it on the device without the need to be connected via USB.

# Serve the current HTTP directory on port 8000
python -m buildozer serve
# Essentially the same as Python 3's http.server
python -m http.server

You’d then visit http://<your-hostname-or-ip>/ and navigate to the .apk file.

Run the app

You can build, install, and run the app all in one step with:

python -m buildozer -v android debug deploy run

The built .apk file is about 13MB.
The RAM consumption of simple example in debug is about 60MB.

The stats did not change much between release and debug mode.

View debug log

Use logcat to view the device logs

python -m buildozer -v android logcat

If you run with multiple devices attached it won’t tail the logs.
If you have one device then you will get the stream of log messages.
You can build, install, run, and dump logs in a single step.
You will get a ton of log messages so it’s best to output it to a file like this:

python -m buildozer -v android debug deploy run logcat 2>log.txt

Other common tasks

Now that we have looked at installing Kivy,
creating simple applications,
and how to package them for distribution,
we have all the knowledge needed to create
an app.

At this point you should understand how to
get everything installed, create an application from scratch,
creating custom widgets and callbacks with the Kv language,
and how to build the app in to a .exe for desktop and a .apk for Android.

All that information should be enough to continue exploring Kivy
and building your own applications.

Kivy also includes packages for many things, including:

animation
async
audio
canvas drawing
shaders
3D rendering

Refer to the official Kivy documentation
for the latest and most accurate information.
For code references, check out the collection of official
Kivy examples.

To learn more, follow the official Pong game tutorial.
It shows you how to build a Pong game using Rectangle and Ellipse widgets
on a canvas widget, and use the built-it collide_widget() method
available on widgets to detect collisions like the ball hitting the paddle.

Also check out the Paint app tutorial which shows you how to detect touches and respond by
drawing an Ellipse (circle) at the touch location.

Conclusion

After reading this, you should have a good understanding of what Kivy is
and how you can use it. You should understand how to create desktop apps
and mobile apps by building layouts using the .kv language. Additionally,
you should know how to use the plyer package to access cross-platform
features and hardware devices.

References

Official Kivy documentation
Kivy Source
Kv language guide
Kivy examples
Paint app tutorial
Pong game tutorial
Widget Guide
Plyer documentation
Plyer examples
PyInstaller Tutorial
InnoSetup
Windows packaging
OSX packaging
Android packaging
Android Kivy guide
Buildozer source
Inno Setup Installer
PyQt5 Tutorial
Python Tkinter Tutorial
wxPython
Bitcoin Price Checker
Live Stream making Bitcoin Price Checker
Java Keytool Tutorial
Kivy Wiki: Creating a Release APK
How to Publish Android Apps to Google Play Store

Источник

Buildozer¶

Packaging with python-for-android¶

Packaging your application for the Kivy Launcher¶

Installation of Examples¶

Release on the market¶

Targeting Android¶

Table Of Contents

Requirements¶

PyInstaller default hook¶

Packaging a simple app¶

Single File Application¶

Bundling Data Files¶

Packaging a video app with gstreamer¶

Overwriting the default hook¶

Including/excluding video and audio and reducing app size¶

Alternate installations¶

Зависимости

Resources

Содержание

Принципы работы фреймворка Kivy Python

Установка Kivy

Работа с виджетами в Kivy

Запуск программы «Hello, Kivy!»

Отображение виджета Image в Kivy Python

Разметка (Layout) в UI Kivy

Добавление событий в Kivy

Использование языка дизайна KV

Создание приложения Kivy Python

Создание приложений для iPhone (iOS) на Python

Создание exe приложений для Windows на Python используя Kivy

Создание приложений для macOS на Python используя Kivy

Заключение

Рекомендации

Зависимости

Интро

Скриншоты

Исходный код и пояснения

Запуск на windows & linux & macos

Сборка apk файла и запуск на телефоне с андроид

Ссылки

Create a package for Windows¶

Requirements¶

PyInstaller default hook¶

Packaging a simple app¶

Single File Application¶

Bundling Data Files¶

Packaging a video app with gstreamer¶

Overwriting the default hook¶

Including/excluding video and audio and reducing app size¶

Create a package for Android¶

Buildozer¶

Packaging with python-for-android¶

Packaging your application for the Kivy Launcher¶

Installation of Examples¶

Release on the market¶

Targeting Android¶

Kivy. Сборка пакетов под Android и никакой магии

Kivy — Создание мобильных приложений на Python

Содержание

Принципы работы фреймворка Kivy Python

Установка Kivy

Introduction

Important concepts

Installation

Check installed version

Start a new project

Use the Kv language

Use Plyer to access mobile device hardware

Build and package

Build for desktop

PyInstaller notes

Build for Android

Test adb

Configure the buildozer.spec file

Build the APK file

Build the debug APK

Build the release APK

Release app on the Google Play Store

Install the app

Run the app