Создайте мобильное приложение с помощью фреймворка Kivy Python

Оглавление

• Понимание структуры Kivy
• Установка Kivy
• Работа с виджетами Kivy
  • запуск “Здравствуйте, Kivy!” Программа
  • Отображение изображения
• Создание пользовательского интерфейса
• Добавление событий
• Использование языка KV
• Создание приложения Kivy
• Упаковка вашего приложения для Android
• Упаковка вашего приложения для iOS
• Упаковка вашего приложения для Windows
• Упаковка вашего приложения для macOS
• Заключение
• Читать далее

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

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

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

В этом руководстве вы узнаете, как:

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

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

Давайте начнем!

Понимание фреймворка Kivy

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

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

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

Установка Kivy

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

Вот как вы можете создать виртуальную среду Python:

$ python3 -m venv my_kivy_project

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

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

$ source bin/activate

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

Теперь, когда у вас активирована виртуальная среда Python, вы можете запустить pip для установки Kivy. В Linux и Mac вы запустите следующую команду:

$ python -m pip install kivy

В Windows установка немного сложнее. Ознакомьтесь с официальной документацией по установке Kivy в Windows. (Пользователи Mac также могут загрузить файл dmg и установить Kivy таким образом.)

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

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

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

Запуск программы ”Привет, Киви!"

Чтобы узнать, как работает Kivy, взгляните на следующее приложение “Привет, мир!”:

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(). Здесь вы будете размещать свой код пользовательского интерфейса или вызывать другие функции, которые определяют ваш код пользовательского интерфейса. В этом случае вы создаете Label виджет и передаете в него text, size_hint, и pos_hint. Эти последние два аргумента не требуются.

size_hint указывает Kivy пропорции, которые следует использовать при создании виджета. Для этого используются два числа:

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

Оба эти числа могут быть в диапазоне от 0 до 1. Значение по умолчанию для обеих подсказок равно 1. Вы также можете использовать pos_hint для позиционирования виджета. В приведенном выше блоке кода вы указываете Kivy центрировать виджет по осям 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.

Отображение изображения

В Kivy есть несколько различных виджетов, связанных с изображениями, на выбор. Вы можете использовать Image для загрузки локальных изображений с вашего жесткого диска или AsyncImage для загрузки изображения с URL-адреса. В этом примере вы будете придерживаться стандартного класса 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, какое изображение загружать. Здесь вы указываете полный путь к изображению. Остальная часть кода такая же, как и в предыдущем примере.

Когда вы запустите этот код, вы увидите что-то вроде следующего:

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

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

Настройка пользовательского интерфейса

Каждый фреймворк с графическим интерфейсом, который вы используете, имеет свой собственный метод размещения виджетов. Например, в wxPython вы будете использовать sizers, в то время как в Tkinter вы используете менеджер компоновки или геометрии. В Kivy вы будете использовать Макетов. Существует несколько различных типов макетов, которые вы можете использовать. Вот некоторые из наиболее распространенных:

• 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()

Здесь вы импортируете BoxLayout из kivy.uix.boxlayout и создаете его экземпляр. Затем вы создаете список цветов, которые сами по себе являются списками Красно-сине-зеленых (RGB) цветов. Наконец, вы выполняете цикл из 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 в основном основан на событиях. Платформа реагирует на нажатия клавиш пользователем, события мыши и прикосновения. В Kivy есть концепция часов, которые вы можете использовать для планирования вызовов функций на некоторое время в будущем.

В 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('You pressed the button!')

if __name__ == '__main__':
    app = MainApp()
    app.run()

В этом коде вы вызываете button.bind() и связываете событие on_press с событием MainApp.on_press_button(). Этот метод неявно использует виджет instance, который является самим объектом button. Наконец, сообщение будет выводиться на stdout всякий раз, когда пользователь нажимает вашу кнопку.

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

Kivy также предоставляет язык проектирования под названием KV, который вы можете использовать в своих приложениях Kivy. Язык KV позволяет отделить дизайн интерфейса от логики приложения. Это соответствует принципу разделения задач и является частью архитектурного шаблона Модель-представление-контроллер. Вы можете обновить предыдущий пример, чтобы использовать язык 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('You pressed the button!')

if __name__ == '__main__':
    app = ButtonApp()
    app.run()

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

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

 1<Button>:
 2    text: 'Press me'
 3    size_hint: (.5, .5)
 4    pos_hint: {'center_x': .5, 'center_y': .5}
 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(). Здесь Киви знает, что будет искать в классе Application метод, вызываемый .on_press_button().

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

Теперь вы готовы к созданию настоящего приложения!

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

Один из лучших способов освоить новый навык - создать что-то полезное. Имея это в виду, вы будете использовать Kivy для создания калькулятора, который поддерживает следующие операции:

• Сложение
• Вычитание
• Умножение
• Подразделение

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

Теперь, когда у вас есть цель для пользовательского интерфейса, вы можете приступить к написанию кода:

 1from kivy.app import App
 2from kivy.uix.boxlayout import BoxLayout
 3from kivy.uix.button import Button
 4from kivy.uix.textinput import TextInput
 5
 6class MainApp(App):
 7    def build(self):
 8        self.operators = ["/", "*", "+", "-"]
 9        self.last_was_operator = None
10        self.last_button = None
11        main_layout = BoxLayout(orientation="vertical")
12        self.solution = TextInput(
13            multiline=False, readonly=True, halign="right", font_size=55
14        )
15        main_layout.add_widget(self.solution)
16        buttons = [
17            ["7", "8", "9", "/"],
18            ["4", "5", "6", "*"],
19            ["1", "2", "3", "-"],
20            [".", "0", "C", "+"],
21        ]
22        for row in buttons:
23            h_layout = BoxLayout()
24            for label in row:
25                button = Button(
26                    text=label,
27                    pos_hint={"center_x": 0.5, "center_y": 0.5},
28                )
29                button.bind(on_press=self.on_button_press)
30                h_layout.add_widget(button)
31            main_layout.add_widget(h_layout)
32
33        equals_button = Button(
34            text="=", pos_hint={"center_x": 0.5, "center_y": 0.5}
35        )
36        equals_button.bind(on_press=self.on_solution)
37        main_layout.add_widget(equals_button)
38
39        return main_layout

Вот как работает код вашего калькулятора:

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

Следующим шагом будет создание обработчика события .on_button_press(). Вот как выглядит этот код:

41def on_button_press(self, instance):
42    current = self.solution.text
43    button_text = instance.text
44
45    if button_text == "C":
46        # Clear the solution widget
47        self.solution.text = ""
48    else:
49        if current and (
50            self.last_was_operator and button_text in self.operators):
51            # Don't add two operators right after each other
52            return
53        elif current == "" and button_text in self.operators:
54            # First character cannot be an operator
55            return
56        else:
57            new_text = current + button_text
58            self.solution.text = new_text
59    self.last_button = button_text
60    self.last_was_operator = self.last_button in self.operators

Большинство виджетов в вашем приложении будут вызывать .on_button_press(). Вот как это работает:

• Строка 41 принимает аргумент instance, чтобы вы могли получить доступ к тому, какой виджет вызвал функцию.

• Строки 42 и 43 извлекают и сохраняют значение solution и кнопки text.

• Строки с 45 по 47 проверьте, какая кнопка была нажата. Если пользователь нажал C, то вы снимете флажок 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():

62def on_solution(self, instance):
63    text = self.solution.text
64    if text:
65        solution = str(eval(self.solution.text))
66        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":
            # Clear the solution widget
            self.solution.text = ""
        else:
            if current and (
                self.last_was_operator and button_text in self.operators):
                # Don't add two operators right after each other
                return
            elif current == "" and button_text in self.operators:
                # First character cannot be an operator
                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()

Пришло время развернуть ваше приложение!

Упаковка вашего приложения для Android

Теперь, когда вы закончили разработку кода для своего приложения, вы можете поделиться им с другими пользователями. Один из отличных способов сделать это - превратить ваш код в приложение, которое можно запускать на вашем телефоне Android. Чтобы достичь этого, сначала вам нужно будет установить пакет под названием buildozer с pip:

$ pip install buildozer

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

$ buildozer init

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

[app]

# (str) Title of your application
title = KvCalc

# (str) Package name
package.name = kvcalc

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

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

На этом этапе вы почти готовы к созданию своего приложения, но сначала вам нужно установить зависимости для buildozer. Как только они будут установлены, скопируйте приложение calculator в новую папку и переименуйте ее в 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, если вам нужно более детальное управление. Здесь вы не будете рассказывать об этом, но если вам интересно, ознакомьтесь с кратким описанием проекта ..

Упаковка вашего приложения для iOS

Инструкции по созданию приложения для iOS немного сложнее, чем для Android. Для получения самой актуальной информации вам всегда следует использовать официальную упаковку Kivy документация. Вам нужно будет выполнить следующие команды, прежде чем вы сможете загрузить свое приложение для 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. Точка входа вашего основного приложения должна иметь имя main.py, прежде чем вы создадите проект Xcode. Вот команда, которую вы будете запускать:

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

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

Упаковка вашего приложения для Windows

Вы можете упаковать свое приложение Kivy для Windows с помощью PyInstaller. Если вы никогда не использовали его раньше, ознакомьтесь с Использование PyInstaller для простого распространения приложений на Python.

Вы можете установить PyInstaller с помощью pip:

$ pip install pyinstaller

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

$ pyinstaller main.py -w

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

Упаковка вашего приложения для macOS

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

$ pyinstaller main.py -w --onefile

При этом в папке dist будет создан один исполняемый файл. Имя исполняемого файла будет совпадать с именем файла Python, который вы передали в PyInstaller. Если вы хотите уменьшить размер исполняемого файла или используете GStreamer в своем приложении, ознакомьтесь с дополнительной информацией на странице упаковки Kivy для macOS.

Заключение

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

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

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

Читать далее

Чтобы узнать больше о Kivy, ознакомьтесь с этими ресурсами:

• Руководство по программированию Kivy
• Упаковочная документация Kivy
• Создавайте настольные графические приложения с использованием Python

Back to Top