Construire une application mobile avec le framework Kivy Python – Real Python

De nos jours, il est fort probable que les développeurs travaillent sur une application mobile ou Web. Python ne dispose pas de fonctionnalités de développement mobile intégrées, mais il existe des packages que vous pouvez utiliser pour créer des applications mobiles, tels que Kivy, PyQt ou même la bibliothèque Beoga de Toga.

Ces bibliothèques sont toutes des acteurs majeurs de l’espace mobile Python. Cependant, vous verrez certains avantages si vous choisissez de créer des applications mobiles avec Kivy. Non seulement votre application aura la même apparence sur toutes les plates-formes, mais vous n’aurez pas besoin de compiler votre code après chaque modification. De plus, vous pourrez utiliser la syntaxe claire de Python pour créer vos applications.

Dans ce tutoriel, vous allez apprendre à:

• Travailler avec les widgets Kivy
• Disposez l'interface utilisateur
• Ajouter des événements
• Utiliser le langage KV
• Créer une application de calculatrice
• Créez un package pour votre application pour iOS, Android, Windows et OS X

Ce tutoriel suppose que vous maîtrisez la programmation orientée objet. Si ce n’est pas le cas, consultez la programmation orientée objet dans Python 3.

Commençons!

Comprendre le cadre de Kivy

Kivy a été lancé pour la première fois au début de 2011. Ce cadre Python multiplate-forme peut être déployé sous Windows, Mac, Linux et Raspberry Pi. Il prend en charge les événements multitouch en plus des entrées habituelles au clavier et à la souris. Kivy prend même en charge l’accélération graphique de ses graphiques, car ils sont conçus avec OpenGL ES2. Le projet utilise la licence MIT, vous pouvez donc utiliser cette bibliothèque pour les logiciels libres et commerciaux.

Lorsque vous créez une application avec Kivy, vous créez une interface utilisateur naturelle ou NUI. L'idée derrière une interface utilisateur naturelle est que l'utilisateur peut facilement apprendre à utiliser votre logiciel avec peu d'instructions, voire aucune.

Kivy n'essaie pas d'utiliser des contrôles ou des widgets natifs. Tous ses widgets sont dessinés sur mesure. Cela signifie que les applications Kivy auront le même aspect sur toutes les plateformes. Cependant, cela signifie également que l'apparence de votre application sera différente de celle des applications natives de vos utilisateurs. Cela pourrait être un avantage ou un inconvénient, selon votre public.

Installer Kivy

Kivy a de nombreuses dépendances, il est donc recommandé de l’installer dans un environnement virtuel Python. Vous pouvez utiliser les fonctions intégrées de Python venv bibliothèque ou virtualenv paquet. Si vous n’avez jamais utilisé d’environnement virtuel Python auparavant, consultez l’environnement virtuel Python: un guide.

Voici comment créer un environnement virtuel Python:

$ python3 -m venv my_kivy_project

Cela copiera votre exécutable Python 3 dans un dossier appelé my_kivy_project et ajoutez quelques autres sous-dossiers à ce répertoire.

Pour utiliser votre environnement virtuel, vous devez l'activer. Sur Mac et Linux, vous pouvez le faire en exécutant ce qui suit à l’intérieur du logiciel. my_kivy_project dossier:

La commande pour Windows est similaire, mais l'emplacement du script d'activation est à l'intérieur de la Les scripts dossier au lieu de poubelle.

Maintenant que vous avez un environnement virtuel Python activé, vous pouvez exécuter pépin installer Kivy. Sous Linux et Mac, vous exécuterez la commande suivante:

$ python -m pip installer kivy

Sous Windows, l'installation est un peu plus complexe. Consultez la documentation officielle pour savoir comment installer Kivy sous Windows. (Les utilisateurs Mac peuvent également télécharger un fichier Dmg déposer et installer Kivy de cette façon.)

Si vous rencontrez des problèmes lors de l’installation de Kivy sur votre plate-forme, consultez la page de téléchargement de Kivy pour obtenir des instructions supplémentaires.

UNE widget est un contrôle à l'écran avec lequel l'utilisateur va interagir. Tous les kits d'outils d'interface utilisateur graphique sont livrés avec un ensemble de widgets. Certains widgets courants que vous avez peut-être utilisés incluent les boutons, les listes déroulantes et les onglets. Kivy a de nombreux widgets intégrés dans son cadre.

Lancer un programme «Bonjour Kivy!

Pour voir comment Kivy fonctionne, jetez un coup d'œil à l'application «Hello, World!» Suivante:

de kivy.app importation App
de kivy.uix.label importation Étiquette

classe MainApp(App):
    def construire(soi):
        étiquette = Étiquette(texte='Bonjour de Kivy',
                      size_hint=(.5, .5),
                      pos_hint='center_x': .5, 'center_y': .5)

        revenir étiquette

si __Nom__ == '__principale__':
    app = MainApp()
    app.courir()

Chaque application Kivy doit être sous-classe App et passer outre construire(). C’est là que vous placerez votre code d’interface utilisateur ou ferez des appels à d’autres fonctions définissant votre code d’interface utilisateur. Dans ce cas, vous créez un Étiquette widget et passer dans son texte, size_hint, et pos_hint. Ces deux derniers arguments ne sont pas nécessaires.

size_hint indique à Kivy les proportions à utiliser lors de la création du widget. Il faut deux chiffres:

1. Le premier numéro est le X indice de taille et se réfère à la largeur du contrôle.
2. Le deuxième numéro est le y indice de taille et se réfère à la la taille du contrôle.

Ces deux nombres peuvent être compris entre 0 et 1. La valeur par défaut pour les deux indicateurs est 1. Vous pouvez également utiliser pos_hint pour positionner le widget. Dans le bloc de code ci-dessus, vous indiquez à Kivy de centrer le widget sur les axes x et y.

Pour que l'application s'exécute, vous instanciez votre MainApp classe et ensuite appeler courir(). Lorsque vous le faites, vous devriez voir ce qui suit sur votre écran:

Kivy envoie également beaucoup de texte à stdout:

[INFO   ] [Logger      ]    Enregistrer le journal dans /home/mdriscoll/.kivy/logs/kivy_19-06-07_2.txt
[INFO   ] [Kivy        ]    v1.11.0
[INFO   ] [Kivy        ]    Installé dans "/home/mdriscoll/code/test/lib/python3.6/site-packages/kivy/__init__.py"
[INFO   ] [Python      ]    v3.6.7 (par défaut, 22 octobre 2018, 11:32:17)
[GCC 8.2.0]
[INFO   ] [Python      ]    Interprétation sur "/ home / mdriscoll / code / test / bin / python"
[INFO   ] [Factory     ]    184 symboles chargés
[INFO   ] [Image       ]    Fournisseurs: img_tex, img_dds, img_sdl2, img_gif (img_pil, img_ffpyplayer ignoré)
[INFO   ] [Text        ]    Fournisseur: sdl2 (['text_pango'] ignoré)
[INFO   ] [Window      ]    Fournisseur: sdl2 (['window_egl_rpi'] ignoré)
[INFO   ] [GL          ]    Utilisation du système graphique "OpenGL"
[INFO   ] [GL          ]    Backend utilisé 
[INFO   ] [GL          ]    Version OpenGL 
[INFO   ] [GL          ]    Fournisseur OpenGL 
[INFO   ] [GL          ]    Rendeur OpenGL 
[INFO   ] [GL          ]    Version analysée par OpenGL: 4, 6
[INFO   ] [GL          ]    Version d'ombrage 
[INFO   ] [GL          ]    Texture max taille <16384>
[INFO   ] [GL          ]    Unités de texture maximum <32>
[INFO   ] [Window      ]    ajout automatique du fournisseur d'entrée sdl2
[INFO   ] [Window      ]    clavier virtuel non autorisé, mode unique, non ancré
[INFO   ] [Base        ]    Lancer la boucle principale de l'application
[INFO   ] [GL          ]    Le support de texture NPOT est disponible

Ceci est utile pour déboguer votre application.

Ensuite, vous allez essayer d’ajouter un Image widget et voir comment cela diffère d'un Étiquette.

Affichage d'une image

Kivy propose différents widgets liés aux images. Vous pouvez utiliser Image charger des images locales depuis votre disque dur ou AsyncImage charger une image à partir d'une URL. Pour cet exemple, vous allez vous en tenir à la norme Image classe:

de kivy.app importation App
de kivy.uix.image importation Image

classe MainApp(App):
    def construire(soi):
        img = Image(la source='/path/to/real_python.png',
                    size_hint=(1, .5),
                    pos_hint='center_x':.5, 'center_y':.5)

        revenir img

si __Nom__ == '__principale__':
    app = MainApp()
    app.courir()

Dans ce code, vous importez Image du kivy.uix.image sous-package. le Image classe prend beaucoup de paramètres différents, mais celui que vous voulez utiliser est la source. Cela indique à Kivy quelle image charger. Ici, vous passez un chemin complet à l’image. Le reste du code est identique à ce que vous avez vu dans l'exemple précédent.

Lorsque vous exécutez ce code, vous verrez quelque chose comme ce qui suit:

Le texte de l'exemple précédent a été remplacé par une image.

Vous allez maintenant apprendre à ajouter et organiser plusieurs widgets dans votre application.

Disposer l'interface utilisateur

Chaque infrastructure graphique que vous utilisez a sa propre méthode d'organisation des widgets. Par exemple, dans wxPython, vous utiliserez des calibreurs, tandis que dans Tkinter, vous utiliserez un gestionnaire de disposition ou de géométrie. Avec Kivy, vous utiliserez Layouts. Vous pouvez utiliser différents types de mises en forme. Voici quelques-unes des plus courantes:

• BoxLayout
• FloatLayout
• Disposition de la grille

Vous pouvez rechercher dans la documentation de Kivy la liste complète des modèles disponibles. Vous pouvez aussi regarder dans kivy.uix pour le code source réel.

Essayez le BoxLayout avec ce code:

importation Kivy
importation Aléatoire

de kivy.app importation App
de kivy.uix.button importation Bouton
de kivy.uix.boxlayout importation BoxLayout

rouge = [[[[1,0,0,1]
vert = [[[[0,1,0,1]
bleu =  [[[[0,0,1,1]
violet = [[[[1,0,1,1]

classe HBoxLayoutExample(App):
    def construire(soi):
        disposition = BoxLayout(rembourrage=dix)
        couleurs = [[[[rouge, vert, bleu, violet]

        pour je dans intervalle(5):
            btn = Bouton(texte="Bouton #% s" % (je+1),
                         Couleur de l'arrière plan=Aléatoire.choix(couleurs)
                         )

            disposition.add_widget(btn)
        revenir disposition

si __Nom__ == "__principale__":
    app = HBoxLayoutExample()
    app.courir()

Ici, vous importez BoxLayout de kivy.uix.boxlayout et instancier. Ensuite, vous créez une liste de couleurs, qui sont elles-mêmes des listes de couleurs rouge-bleu-vert (RVB). Enfin, vous passez en boucle sur un intervalle de 5, créer un bouton btn pour chaque itération. Pour rendre les choses un peu plus amusant, vous définissez la Couleur de l'arrière plan du bouton à une couleur aléatoire. Vous ajoutez ensuite le bouton à votre mise en page avec layout.add_widget (btn).

Lorsque vous exécutez ce code, vous verrez quelque chose comme ceci:

Il y a 5 boutons de couleur aléatoire, un pour chaque itération de votre pour boucle.

Lorsque vous créez une mise en page, vous devez connaître quelques arguments:

• rembourrage: Vous pouvez spécifier le rembourrage en pixels entre la mise en page et ses enfants de l'une des trois manières suivantes:
  1. Une liste à quatre arguments: [[[[padding_left, padding_top, padding_right, padding_bottom]
  2. Une liste à deux arguments: [[[[padding_horizontal, padding_vertical]
  3. Un argument singulier: rembourrage = 10
• espacement: Vous pouvez ajouter un espace entre les widgets enfants avec cet argument.
• orientation: Vous pouvez changer la valeur par défaut orientation du BoxLayout de l'horizontal à la verticale.

Ajout d'événements

Comme la plupart des toolkits graphiques, Kivy est principalement événementiel. L'infrastructure répond aux pressions de l'utilisateur, aux événements de souris et aux événements tactiles. Kivy a le concept d'un L'horloge que vous pouvez utiliser pour planifier des appels de fonction pour un certain temps dans le futur.

Kivy a aussi le concept de Propriétés, qui fonctionne avec le EventDispatcher. Les propriétés vous aident à vérifier la validation. Ils vous permettent également de déclencher des événements chaque fois qu'un widget change de taille ou de position.

Ajoutons un événement de bouton à votre code de bouton de plus tôt:

de kivy.app importation App
de kivy.uix.button importation Bouton

classe MainApp(App):
    def construire(soi):
        bouton = Bouton(texte='Bonjour de Kivy',
                        size_hint=(.5, .5),
                        pos_hint='center_x': .5, 'center_y': .5)
        bouton.lier(on_press=soi.on_press_button)

        revenir bouton

    def on_press_button(soi, exemple):
        impression(«Vous avez appuyé sur le bouton!)

si __Nom__ == '__principale__':
    app = MainApp()
    app.courir()

Dans ce code, vous appelez button.bind () et lier le on_press événement à MainApp.on_press_button (). Cette méthode prend implicitement dans le widget exemple, qui est le bouton objet lui-même. Enfin, un message sera imprimé à stdout chaque fois que l'utilisateur appuie sur votre bouton.

Utiliser le langage KV

Kivy fournit également un langage de conception appelé KV que vous pouvez utiliser avec vos applications Kivy. Le langage KV vous permet de séparer la conception de votre interface de la logique de l’application. Ceci suit le principe de séparation des préoccupations et fait partie du modèle architectural Model-View-Controller. Vous pouvez mettre à jour l'exemple précédent pour utiliser le langage KV:

de kivy.app importation App
de kivy.uix.button importation Bouton

classe ButtonApp(App):
    def construire(soi):
        revenir Bouton()

    def on_press_button(soi):
        impression(«Vous avez appuyé sur le bouton!)

si __Nom__ == '__principale__':
    app = ButtonApp()
    app.courir()

Ce code peut paraître un peu étrange au premier abord, car il crée un Bouton sans définir aucun de ses attributs ni le lier à des événements. Ce qui se passe ici, c'est que Kivy recherchera automatiquement un fichier portant le même nom que la classe en minuscule, sans le App une partie du nom de la classe.

Dans ce cas, le nom de la classe est ButtonApp, Kivy va donc chercher un fichier nommé bouton.kv. Si ce fichier existe et est correctement formaté, Kivy l'utilisera pour charger l'interface utilisateur. Allez-y, créez ce fichier et ajoutez le code suivant:

    1 :
 2     texte: 'presse moi'
 3     size_hint: (.5, .5)
 4     pos_hint: 'center_x': .5, 'center_y': .5
 5     on_press: app.on_press_button ()

Voici ce que fait chaque ligne:

• Ligne 1 correspond à la Bouton appelez votre code Python. Il dit à Kivy de rechercher dans l'objet instancié une définition de bouton.
• Ligne 2 règle le bouton texte.
• Ligne 3 définit la largeur et la hauteur avec size_hint.
• Ligne 4 définit la position du bouton avec pos_hint.
• Ligne 5 définit le on_press gestionnaire d'événements. Pour indiquer à Kivy où se trouve le gestionnaire d'événements, vous utilisez app.on_press_button (). Ici, Kivy sait qu’il cherchera dans le Application classe pour une méthode appelée .on_press_button ().

Vous pouvez configurer tous vos widgets et vos dispositions dans un ou plusieurs fichiers de langue KV. Le langage KV prend également en charge l’importation de modules Python dans KV, la création de classes dynamiques, etc. Pour plus de détails, consultez le guide de Kivy sur la langue KV.

Vous êtes maintenant prêt à créer une application réelle!

Créer une application Kivy

L'un des meilleurs moyens d'apprendre une nouvelle compétence consiste à créer quelque chose d'utile. Dans cet esprit, vous utiliserez Kivy pour créer une calculatrice prenant en charge les opérations suivantes:

• Une addition
• Soustraction
• Multiplication
• Division

Pour cette application, vous aurez besoin d’une série de boutons dans une sorte de disposition. Vous aurez également besoin d’une boîte en haut de votre application pour afficher les équations et leurs résultats. Voici un croquis de votre calculatrice:

Maintenant que vous avez un objectif pour l'interface utilisateur, vous pouvez écrire le code:

    1 de kivy.app importation App
    2 de kivy.uix.boxlayout importation BoxLayout
    3 de kivy.uix.button importation Bouton
    4 de kivy.uix.textinput importation Saisie de texte
    5 
    6 classe MainApp(App):
    sept     def construire(soi):
    8         soi.les opérateurs = [[[["/", "*", "+", "-"]
    9         soi.last_was_operator = Aucun
dix         soi.last_button = Aucun
11         main_layout = BoxLayout(orientation="verticale")
12         soi.Solution = Saisie de texte(
13             multiligne=Faux, lecture seulement=Vrai, halign="droite", taille de police=55
14         )
15         main_layout.add_widget(soi.Solution)
16         boutons = [[[[
17             [[[["sept", "8", "9", "/"],
18             [[[["4", "5", "6", "*"],
19             [[[["1", "2", "3", "-"],
20             [[[[".", "0", "C", "+"],
21         ]
22         pour rangée dans boutons:
23             h_layout = BoxLayout()
24             pour étiquette dans rangée:
25                 bouton = Bouton(
26                     texte=étiquette,
27                     pos_hint="center_x": 0.5, "center_y": 0.5,
28                 )
29                 bouton.lier(on_press=soi.on_button_press)
30                 h_layout.add_widget(bouton)
31             main_layout.add_widget(h_layout)
32 
33         est égal à = Bouton(
34             texte="=", pos_hint="center_x": 0.5, "center_y": 0.5
35         )
36         est égal à.lier(on_press=soi.on_solution)
37         main_layout.add_widget(est égal à)
38 
39         revenir main_layout

Voici comment fonctionne votre code de calculatrice:

• Aux lignes 8 à 10, vous créez une liste de les opérateurs et quelques valeurs pratiques, last_was_operator et last_button, que vous utiliserez plus tard.
• Lignes 11 à 15, vous créez une mise en page de premier niveau main_layout et ajouter une lecture seule Saisie de texte widget à elle.
• Aux lignes 16 à 21, vous créez une liste imbriquée de listes contenant la plupart de vos boutons pour la calculatrice.
• En ligne 22, vous commencez un pour boucle sur ceux boutons. Pour chaque liste imbriquée, procédez comme suit:
  • À la ligne 23, vous créez un BoxLayout avec une orientation horizontale.
  • En ligne 24, vous commencez un autre pour boucle sur les éléments de la liste imbriquée.
  • Dans les lignes 25 à 39, vous créez les boutons de la ligne, vous les liez à un gestionnaire d’événements et vous les ajoutez à l’horizontale. BoxLayout de la ligne 23.
  • À la ligne 31, vous ajoutez cette mise en page à main_layout.
• Aux lignes 33 à 37, vous créez le bouton d’égal à égal (=), le lier à un gestionnaire d’événements et l’ajouter à main_layout.

La prochaine étape consiste à créer le .on_button_press () gestionnaire d'événements. Voici à quoi ce code ressemble:

41 def on_button_press(soi, exemple):
42     courant = soi.Solution.texte
43     button_text = exemple.texte
44 
45     si button_text == "C":
46         # Effacer le widget de solution
47         soi.Solution.texte = ""
48     autre:
49         si courant et (
50             soi.last_was_operator et button_text dans soi.les opérateurs):
51             # N'ajoutez pas deux opérateurs l'un après l'autre
52             revenir
53         elif courant == "" et button_text dans soi.les opérateurs:
54             # Le premier caractère ne peut pas être un opérateur
55             revenir
56         autre:
57             new_text = courant + button_text
58             soi.Solution.texte = new_text
59     soi.last_button = button_text
60     soi.last_was_operator = soi.last_button dans soi.les opérateurs

La plupart des widgets de votre application appellent .on_button_press (). Voilà comment cela fonctionne:

• Ligne 41 prend le exemple argument afin que vous puissiez accéder à quel widget appelé la fonction.

• Lignes 42 et 43 extraire et stocker la valeur de la Solution et le bouton texte.

• Lignes 45 à 47 vérifiez pour voir quel bouton a été appuyé. Si l'utilisateur a appuyé sur C, vous effacerez la Solution. Sinon, passez à la autre déclaration.

• Ligne 49 vérifie si la solution a une valeur préexistante.

• Ligne 50 à 52 vérifiez si le dernier bouton enfoncé était un bouton opérateur. Si c'était le cas, alors Solution ne sera pas mis à jour. Cela empêche l'utilisateur d'avoir deux opérateurs à la suite. Par exemple, 1 */ n'est pas une déclaration valide.

• Lignes 53 à 55 vérifiez si le premier caractère est un opérateur. Si c'est le cas, alors Solution ne sera pas mis à jour, car la première valeur ne peut pas être une valeur d'opérateur.

• Lignes 56 à 58 déposer à la autre clause. Si aucune des conditions précédentes n'est remplie, alors mettez à jour Solution.

• Ligne 59 ensembles last_button à l'étiquette du dernier bouton enfoncé.

• Ligne 60 ensembles last_was_operator à Vrai ou Faux selon qu’il s’agisse ou non d’un caractère opérateur.

Le dernier bit de code à écrire est .on_solution ():

62 def on_solution(soi, exemple):
63     texte = soi.Solution.texte
64     si texte:
65         Solution = str(eval(soi.Solution.texte))
66         soi.Solution.texte = Solution

Encore une fois, vous récupérez le texte actuel de Solution et utiliser les fonctions intégrées de Python eval () pour l'exécuter. Si l'utilisateur a créé une formule comme 1 + 2, puis eval () exécutera votre code et renverra le résultat. Enfin, vous définissez le résultat comme nouvelle valeur pour Solution widget.

Lorsque vous exécutez ce code, votre application ressemblera à ceci sur un ordinateur de bureau:

Pour voir le code complet de cet exemple, développez le bloc de code ci-dessous.

de kivy.app importation App
de kivy.uix.boxlayout importation BoxLayout
de kivy.uix.button importation Bouton
de kivy.uix.textinput importation Saisie de texte

classe MainApp(App):
    def construire(soi):
        soi.les opérateurs = [[[["/", "*", "+", "-"]
        soi.last_was_operator = Aucun
        soi.last_button = Aucun
        main_layout = BoxLayout(orientation="verticale")
        soi.Solution = Saisie de texte(
            multiligne=Faux, lecture seulement=Vrai, halign="droite", taille de police=55
        )
        main_layout.add_widget(soi.Solution)
        boutons = [[[[
            [[[["sept", "8", "9", "/"],
            [[[["4", "5", "6", "*"],
            [[[["1", "2", "3", "-"],
            [[[[".", "0", "C", "+"],
        ]
        pour rangée dans boutons:
            h_layout = BoxLayout()
            pour étiquette dans rangée:
                bouton = Bouton(
                    texte=étiquette,
                    pos_hint="center_x": 0.5, "center_y": 0.5,
                )
                bouton.lier(on_press=soi.on_button_press)
                h_layout.add_widget(bouton)
            main_layout.add_widget(h_layout)

        est égal à = Bouton(
            texte="=", pos_hint="center_x": 0.5, "center_y": 0.5
        )
        est égal à.lier(on_press=soi.on_solution)
        main_layout.add_widget(est égal à)

        revenir main_layout

    def on_button_press(soi, exemple):
        courant = soi.Solution.texte
        button_text = exemple.texte

        si button_text == "C":
            # Effacer le widget de solution
            soi.Solution.texte = ""
        autre:
            si courant et (
                soi.last_was_operator et button_text dans soi.les opérateurs):
                # N'ajoutez pas deux opérateurs l'un après l'autre
                revenir
            elif courant == "" et button_text dans soi.les opérateurs:
                # Le premier caractère ne peut pas être un opérateur
                revenir
            autre:
                new_text = courant + button_text
                soi.Solution.texte = new_text
        soi.last_button = button_text
        soi.last_was_operator = soi.last_button dans soi.les opérateurs

    def on_solution(soi, exemple):
        texte = soi.Solution.texte
        si texte:
            Solution = str(eval(soi.Solution.texte))
            soi.Solution.texte = Solution


si __Nom__ == "__principale__":
    app = MainApp()
    app.courir()

Il est temps de déployer votre application!

Emballage de votre application pour Android

Maintenant que vous avez terminé le code de votre application, vous pouvez le partager avec d'autres. Une excellente façon de le faire est de transformer votre code en une application pouvant être exécutée sur votre téléphone Android. Pour ce faire, vous devez d’abord installer un paquet nommé Buildozer avec pépin:

Créez ensuite un nouveau dossier et naviguez-le dans votre terminal. Une fois que vous y êtes, vous devrez exécuter la commande suivante:

Cela va créer un buildozer.spec fichier que vous utiliserez pour configurer votre build. Pour cet exemple, vous pouvez éditer les premières lignes du fichier de spécification comme suit:

[app]







# (str) Titre de votre application
titre = KvCalc

# (str) Nom du package
package.name = kvcalc

# (str) Domaine du paquet (nécessaire pour les paquets android / ios)
package.domain = org.kvcalc

N'hésitez pas à parcourir le reste du fichier pour voir ce que vous pouvez changer d'autre.

À ce stade, vous êtes presque prêt à créer votre application, mais vous devez d’abord installer les dépendances pour Buildozer. Une fois ceux-ci installés, copiez votre application de calculatrice dans votre nouveau dossier et renommez-le en main.py. Ceci est requis par Buildozer. Si vous ne nommez pas le fichier correctement, la construction échouera.

Maintenant, vous pouvez exécuter la commande suivante:

$ buildozer -v android debug

L'étape de construction prend beaucoup de temps! Sur ma machine, cela a pris 15 à 20 minutes. En fonction de votre matériel, cela peut prendre encore plus longtemps, alors n'hésitez pas à prendre une tasse de café ou à courir pendant que vous attendez. Buildozer téléchargera toutes les pièces du SDK Android nécessaires pendant le processus de construction. Si tout se passe comme prévu, vous aurez un fichier nommé quelque chose comme kvcalc-0.1-debug.apk dans votre poubelle dossier.

La prochaine étape consiste à connecter votre téléphone Android à votre ordinateur et à copier le apk déposer à elle. Ensuite, vous pouvez ouvrir le navigateur de fichiers sur votre téléphone et cliquer sur le bouton apk fichier. Android devrait vous demander si vous souhaitez installer l'application. Un message d'avertissement peut s'afficher depuis le téléchargement de l'application à partir de l'extérieur de Google Play, mais vous devriez toujours pouvoir l'installer.

Voici la calculatrice fonctionnant sur mon Samsung S9:

le Buildozer Cet outil a plusieurs autres commandes que vous pouvez utiliser. Consultez la documentation pour voir ce que vous pouvez faire d'autre.

Vous pouvez également emballer l'application à l'aide de python pour android si vous avez besoin d'un contrôle plus fin. Vous ne couvrirez pas cette question ici, mais si cela vous intéresse, consultez le quickstart du projet.

Emballage de votre application pour iOS

Les instructions pour créer une application pour iOS sont un peu plus complexes qu'Android. Pour obtenir les informations les plus récentes, vous devez toujours utiliser la documentation d’emballage officielle de Kivy. Vous devez exécuter les commandes suivantes avant de pouvoir conditionner votre application pour iOS sur votre Mac:

$ infuser installer autoconf automake libtool pkg-config
$ lien brassage libtool
$ sudo easy_install pip
$ sudo pip installer Cython==029,10

Une fois ceux-ci installés, vous devez compiler la distribution à l’aide des commandes suivantes:

$ git clone git: //github.com/kivy/kivy-ios
$ CD kivy-ios
$ ./toolchain.py construire python3 kivy

Si vous obtenez une erreur qui dit iphonesimulator introuvable, consultez cette réponse à StackOverflow pour trouver des solutions à ce problème. Ensuite, essayez à nouveau d'exécuter les commandes ci-dessus.

Si vous rencontrez des erreurs SSL, alors vous n’aurez probablement pas la configuration OpenSSL de Python. Cette commande devrait corriger ça:

$ CD / Applications / Python 3.sept/
$ ./Installer Certificats.command

Maintenant, retournez et essayez de lancer le chaîne d'outils commande à nouveau.

Une fois que vous avez exécuté toutes les commandes précédentes avec succès, vous pouvez créer votre projet Xcode à l'aide du chaîne d'outils scénario. Le point d’entrée de votre application principale doit être nommé main.py avant de créer le projet Xcode. Voici la commande que vous allez exécuter:

./toolchain.py créer