Stefan Franke

Übungen zur Programmierung in einer objektorientierten Sprache

Wichtig: Dies ist eine Übersetzung von der offiziellen Kivy Seite und wurde nicht durch mich erstellt! Einige Abschnitte wurden ergänzt, um diese an die Lehrveranstaltung anzupassen.

Erstellung einer Anwendung in Kivy

Die folgenden Schritte können in einer Textdatei, beispielsweise 'main.py', gespeichert und ausgeführt werden.

Lebenszyklus einer Kivy-App

Zunächst einmal sollten wir uns mit dem Lebenszyklus einer Kivy-App vertraut machen.

Was ist der Lebenszyklus einer App?

Der Lebenszyklus einer App bezieht sich auf die Serie von Zuständen, die eine App von dem Moment an durchläuft, wenn sie vom Benutzer gestartet wird bis zu dem Punkt, an dem sie geschlossen wird. Dies umfasst die Initialisierung, die Ausführung von Code, das Warten auf Benutzereingaben, das Reagieren auf Systemereignisse, das Speichern von Zuständen und das ordnungsgemäße Beenden der App. Für Entwickler ist es entscheidend, den Lebenszyklus zu verstehen, um Ressourcen effizient zu verwalten, Daten zu sichern und ein reibungsloses Benutzererlebnis zu gewährleisten.

Quelle: Kivy Documentation

Das Bild zeigt den Lebenszyklus einer Kivy-App auf Android- und iOS-Geräten. Hier ist eine einfache Erklärung:

• Kivy Bootstrap: Der Startpunkt für jede Kivy-App auf Mobilgeräten.
• Python start, run(): Python startet und führt die App aus.
• build(): Die Methode, die Ihre App-Widgets initialisiert.
• on_start(): Wird aufgerufen, wenn die App startet.
• on_resume(): Wird aufgerufen, wenn die App nach einer Pause fortgesetzt wird.
• Externe Pause: Wenn eine externe App oder eine Systemfunktion die App pausiert.
• on_pause(): Hier sollten Sie Ihren aktuellen App-Zustand speichern, da die Fortsetzung nicht garantiert ist.
• on_stop(): Wird aufgerufen, wenn die App nicht mehr sichtbar ist.
• Kivy Window Destroyed: Das Kivy-Fenster wird geschlossen und die App-Oberfläche zerstört.
• Python stop: Python beendet die Ausführung der App.
• App im Vordergrund: Wird aufgerufen, wenn die App nach einem Prozessstop wieder aktiv wird.

Diese Schritte sind wichtig, um zu verstehen, wie eine Kivy-App auf Mobilgeräten funktioniert und wie man den Code für verschiedene App-Zustände schreibt.

Um mit Kivy-Apps vertraut zu werden, ist es wichtig, den Lebenszyklus einer Kivy-App zu verstehen.

Zeile für Zeile durch eine Kivy-App:

Wie oben zu sehen ist, ist der Einstiegspunkt in unsere Kivy-App die Methode run(). In unserem Fall verwenden wir MyApp().run() als Einstiegspunkt. Lassen Sie uns jedoch von Zeile zu Zeile gehen:

Hier ist ein Beispiel für eine minimale Anwendung:

import kivy


from kivy.app import App
from kivy.uix.label import Label


class MyApp(App):

def build(self):
    return Label(text='Hello world')


if __name__ == '__main__':
MyApp().run()

1. Zuerst importieren wir die App-Klasse aus Kivy:

from kivy.app import App

Es ist entscheidend, dass die Basisklasse Ihrer App von der App-Klasse erbt. Die App-Klasse befindet sich normalerweise im Verzeichnis kivy_installation_dir/kivy/app.py. Falls Sie tiefer in die Funktionsweise der Kivy-App-Klasse eintauchen möchten, können Sie diese Datei öffnen. Kivy basiert auf Python und verwendet Sphinx für die Dokumentation, daher finden Sie die Dokumentation für jede Klasse in der entsprechenden Datei.

2. Als nächstes importieren wir das Label-Widget, das uns später in unserer App nützlich sein wird:

from kivy.uix.label import Label

Beachten Sie hier die Art und Weise, wie Kivy Pakete und Klassen organisiert. Das uix-Modul enthält Benutzeroberflächenelemente wie Layouts und Widgets.

3. Wir definieren unsere eigene App-Klasse, in diesem Fall MyApp:

class MyApp(App):

Sie sollten nur den Namen Ihrer App in dieser Zeile ändern.

4. Jetzt kommt die Methode build(self). Dies ist der Ort, an dem Sie Ihr Root-Widget initialisieren und zurückgeben sollten. In unserem Beispiel erstellen wir ein einfaches Label-Widget mit dem Text 'Hello world':

def build(self):
    return Label(text='Hello world')

5. Schließlich, um unsere App auszuführen, verwenden wir die folgenden Zeilen, um die MyApp-Klasse zu initialisieren und die run()-Methode aufzurufen:

if __name__ == '__main__':
    MyApp().run()

Mit diesen Schritten initialisieren und starten Sie Ihre Kivy-Anwendung.

Starten einer Kivy-Anwendung

Um die Anwendung in Ihrer Entwicklungsumgebung zu starten und den "Play"-Button in VS Code zu verwenden, folgen Sie diesen Schritten:

Starten in VS Code:

1. Öffnen Sie Ihre VS Code-Entwicklungsumgebung und öffnen Sie das Projekt, das Ihre Kivy-Anwendung enthält.

2. Stellen Sie sicher, dass die Datei, die Ihre Kivy-Anwendung enthält, geöffnet ist, in diesem Fall "main.py".

3. Suchen Sie in VS Code nach dem "Play"-Button oder der Schaltfläche zum Ausführen und klicken Sie darauf.

4. Ihre Kivy-Anwendung sollte gestartet werden, und ein Fenster mit einem einzelnen Label, auf dem der Text "Hello World" steht, sollte sich öffnen und den gesamten Bereich des Fensters abdecken.

Das ist die Methode, um Ihre Kivy-Anwendung in VS Code zu starten und zu testen, ohne die Befehlszeile verwenden zu müssen.

Starten über den Terminal/Shell

Um die Anwendung auszuführen, befolgen Sie die Anweisungen für Ihr Betriebssystem:

Für Windows, Linux, macOS oder den Raspberry Pi: Öffnen Sie das Terminal, in dem Sie Kivy installiert haben, und führen Sie den folgenden Befehl aus:

python main.py

Für Android oder iOS benötigt Ihre Anwendung einige zusätzliche Dateien, um ausgeführt werden zu können. Siehe "Erstellen eines Pakets für Android" oder "Erstellen eines Pakets für iOS" für weitere Informationen.

Ein Fenster sollte sich öffnen und ein einzelnes Label anzeigen, auf dem der Text "Hello World" steht, das den gesamten Bereich des Fensters abdeckt. Das ist alles, was dazu gehört.

Benutzerdefinierte Anpassung der Anwendung¶

from kivy.app import App
from kivy.uix.gridlayout import GridLayout
from kivy.uix.label import Label
from kivy.uix.textinput import TextInput

class LoginScreen(GridLayout):

    def __init__(self, **kwargs):
        super(LoginScreen, self).__init__(**kwargs)
        self.cols = 2
        self.add_widget(Label(text='Benutzername'))
        self.username = TextInput(multiline=False)
        self.add_widget(self.username)
        self.add_widget(Label(text='Passwort'))
        self.password = TextInput(password=True, multiline=False)
        self.add_widget(self.password)

class MyApp(App):

    def build(self):
        return LoginScreen()

if __name__ == '__main__':
    MyApp().run()

In diesem Abschnitt erweitern wir die Anwendung, um eine einfache Benutzername/Passwort-Seite hinzuzufügen.

Wir importieren zuerst die Klasse GridLayout von Kivy und verwenden sie als Basis für unser Root-Widget LoginScreen. Wir überschreiben die Methode __init__() in der LoginScreen-Klasse, um Widgets hinzuzufügen und ihr Verhalten zu definieren.

Wir bitten den GridLayout, seine Kinder in zwei Spalten zu organisieren, und fügen ein Label und ein TextInput für den Benutzernamen und das Passwort hinzu.

Wenn Sie den obigen Code ausführen, erhalten Sie ein Fenster, das wie folgt aussieht:

Quelle: Kivy Documentation

Probieren Sie das Ändern der Fenstergröße aus, und Sie werden sehen, dass die Widgets auf dem Bildschirm sich automatisch an die Größe des Fensters anpassen, ohne dass Sie etwas tun müssen. Dies geschieht, weil Widgets standardmäßig die Größenhinweise verwenden.

Der obenstehende Code behandelt jedoch noch nicht die Eingaben des Benutzers, führt keine Validierung oder andere Funktionen aus. Wir werden in den kommenden Abschnitten genauer darauf eingehen, wie Widgets positioniert und gestaltet werden.

nächstes Übungsblatt