diff --git a/source/Android/__init__.py b/source/Android/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/source/Android/alle.py b/source/Android/alle.py new file mode 100644 index 0000000..5742269 --- /dev/null +++ b/source/Android/alle.py @@ -0,0 +1,22 @@ +from velamentum.dateien.DateiSystemElement import DateiSystemElement +from velamentum.dateien.Datei import Datei +from velamentum.dateien.Verzeichnis import Verzeichnis +from velamentum.multimedia.Recorder import Recorder +from velamentum.multimedia.AudioRecorder import AudioRecorder +from velamentum.multimedia.BildRecorder import BildRecorder +from velamentum.multimedia.VideoRecorder import VideoRecorder +from velamentum.multimedia.Player import Player +from velamentum.multimedia.AudioPlayer import AudioPlayer +from velamentum.signale.Signal import Signal +from velamentum.signale.AudioSignal import AudioSignal +from velamentum.signale.TextSignal import TextSignal +from velamentum.signale.VibrationsSignal import VibrationsSignal +from velamentum.sprache.Spracheingabe import Spracheingabe +from velamentum.sprache.Sprachausgabe import Sprachausgabe +from velamentum.ui.dialoge.Dialog import Dialog +from velamentum.ui.dialoge.EingabeDialog import EingabeDialog +from velamentum.ui.dialoge.EntscheidungsDialog import EntscheidungsDialog +from velamentum.ui.dialoge.PasswortDialog import PasswortDialog +from velamentum.werkzeuge.System import System +from velamentum.werkzeuge.Zufallsgenerator import Zufallsgenerator +from velamentum.werkzeuge.Zwischenablage import Zwischenablage diff --git a/source/Android/android.py b/source/Android/android.py new file mode 100644 index 0000000..c973844 --- /dev/null +++ b/source/Android/android.py @@ -0,0 +1,2 @@ +import androidhelper +androide = androidhelper.Android() diff --git a/source/Android/dateien/Datei.py b/source/Android/dateien/Datei.py new file mode 100644 index 0000000..f37b02b --- /dev/null +++ b/source/Android/dateien/Datei.py @@ -0,0 +1,71 @@ +# -*- coding: utf-8 -*- +from velamentum.dateien.DateiSystemElement import DateiSystemElement + +class Datei(DateiSystemElement): + """Die Klasse Datei dient dem Umgang mit Dateien. + + Attribute: + --- von 'DateiSystemElement' geerbte --- + groesse (Zahl): Die Größe der Datei in Byte. + inhalt (Zeichenkette): Der Inhalt der Datei. + """ + + def __init__(self, pPfad, pSofortEinlesen=False): + """Konstruktor. Initialisiert die Datei. + + Parameter: + pPfad (Zeichenkette): Der Pfad der Datei. + [optional] pSofortEinlesen: Gibt an, ob die Datei direkt bei der + Initialisierung eingelesen werden soll. [Standardwert: False] + """ + DateiSystemElement.__init__(self, pPfad) + if(pSofortEinlesen): + self.einlesen() + + def nenneGroesse(self): + """Anfrage. Gibt die Größe der Datei in Byte zurück. + + Parameter: + --- keine --- + + Rückgabe (Zahl): Die Größe der Datei in Byte. + """ + tSize = 0 + if self.istVorhanden(): + try: + tSize = os.path.getsize(self.pfad) + except: + print("Fehler. Auf '%s' kann nicht zugegriffen werden." + % self._pfad) + + def einlesen(self): + """Auftrag. Liest die Datei in das Attribut 'inhalt' ein. + + Parameter: + --- keine --- + """ + if self.istVorhanden(): + try: + tDatei = open(self._pfad, "r") + self.inhalt = tDatei.read() + tDatei.close() + except: + print("Fehler. Einlesen von '%s' nicht möglich." % self._pfad) + else: + self.inhalt = "" + + def speichern(self): + """Auftrag. Schreibt den Wert des Attributs 'inhalt' in die Datei. + + Parameter: + --- keine --- + """ + try: + tDatei = open(self._pfad, "w") + tDatei.write(self.inhalt) + tDatei.close() + except: + print("Fehler. Speichern von '%s' nicht möglich." % self._pfad) + + # Attribute (verdeckte Getter und Setter) + groesse = property(nenneGroesse, doc="Die Größe der Datei in Byte.") diff --git a/source/Android/dateien/DateiSystemElement.py b/source/Android/dateien/DateiSystemElement.py new file mode 100644 index 0000000..03ac758 --- /dev/null +++ b/source/Android/dateien/DateiSystemElement.py @@ -0,0 +1,104 @@ +# -*- coding: utf-8 -*- +# Modul zur Erkennung des MIME-Types des Elements. +import mimetypes, shutil, os.path + +class DateiSystemElement(object): + """Die Klasse DateiSystemElement stellt die Basisklasse für Elemente + im Dateisystem (z.B. Dateien und Verzeichnisse) dar. + + Anmerkungen: + - Eigentlich sollte ein DateiSystemElement seinen eigenen Pfad nicht + kennen. Auch das Umbenennen und weitere Verwaltungsfunktionen gehören + eher zum übergeordneten Dateisystem. Aus praktikabilitätsgründen + wurde allerdings diese Implementierung gewählt. + - Für die Erkennung des MIME-Types wird derzeit lediglich die + Erweiterung des Elements berücksichtigt. + + Attribute: + name (Zeichenkette): Der Name des Elements im Dateisystem. + pfad (Zeichenkette): Der Pfad des Elements im Dateisystem. + typ (Zeichenkette): Gibt den MIME-Type des Elements an. + verzeichnis (Zeichenkette): Der Pfad des übergeordneten Verzeichnisses + der Datei. + """ + + def __init__(self, pPfad): + """Konstruktor. Initialisiert das DateiSystemElement. + + Parameter: + pPfad (Zeichenkette): Der Pfad des DateiSystemElements. + """ + # Slash am Ende entfernen + if pPfad.endswith('/'): + pPfad = pPfad[:-1] + + self._pfad = pPfad + self._erkenneTyp() + + def _erkenneTyp(self): + """Hilfsmethode. Erkennt den Typ des DateiSystemElements und speichert. + diesen im Attribut 'typ'. + """ + if os.path.isfile(self._pfad): + # Erkennung des MIME-Types. Es wird lediglich die Erweiterung + # der Datei geprüft. + self.typ = mimetypes.guess_type(self._pfad, False) + elif os.path.isdir(self._pfad): + self.typ = "inode/directory" + elif os.path.islink(self._pfad): + self.typ = "inode/symlink" + elif os.path.ismount(self._pfad): + self.typ = "inode/mount-point" + else: + self.typ = "application/octet-stream" + + def istVorhanden(self): + """Anfrage. Prüft, ob das Element im Dateisystem bereits existiert. + + Parameter: + --- keine --- + + Rückgabe (Wahrheitswert): True falls das Element im Dateisystem bereits + existiert, sonst False. + """ + return os.path.exists(self._pfad) + + def nennePfad(self): + """Anfrage. Gibt den Pfad des Elements im Dateisystem zurück.""" + return self._pfad + + def nenneVerzeichnis(self): + """Anfrage. Gibt das übergeordnete Verzeichnis des Elements zurück.""" + return os.path.dirname(self._pfad) + + def nenneName(self): + """Anfrage. Gibt den Namen des Elements im Dateisystem zurück.""" + return os.path.basename(self._pfad) + + def nenneTyp(self): + """Anfrage. Gibt den Typ des Elements zurück (als MIME-Type).""" + return self.typ + + def verschieben(pPfad): + """Auftrag. Hängt das Element im Dateisystem um. + + Parameter: + pPfad (Zeichenkette): Gibt den neuen Pfad im Dateisystem an. + """ + # Verschieben, falls Element bereits existiert. + if os.path.exists(pPfad): + try: + shutil.move(self._pfad, pPfad) + self._pfad = pPfad + except: + print("Fehler. Verschieben von '%s' nicht möglich." % self._pfad) + + # Attribute (verdeckte Getter und Setter) + pfad = property(nennePfad, verschieben, doc="Der Pfad des " \ + "DateiSystemElements im Dateisystem.") + name = property(nenneName, doc="Der Name des DateiSystemElements im" \ + "Dateisystem.") + verzeichnis = property(nenneVerzeichnis, doc="Der Pfad des übergeordneten" \ + " Verzeichnisses des DateiSystemElements im Dateisystem.") + + diff --git a/source/Android/dateien/Verzeichnis.py b/source/Android/dateien/Verzeichnis.py new file mode 100644 index 0000000..3569b9c --- /dev/null +++ b/source/Android/dateien/Verzeichnis.py @@ -0,0 +1,29 @@ +# -*- coding: utf-8 -*- +from velamentum.dateien.DateiSystemElement import DateiSystemElement +import os + +class Verzeichnis(DateiSystemElement): + """Die Klasse Verzeichnis dient dem Umgang mit Verzeichnissen. + + Attribute: + --- von 'DateiSystemElement' geerbte --- + """ + + def __init__(self, pPfad): + """Konstruktor. Initialisiert das Verzeichnis. + + Parameter: + pPfad (Zeichenkette): Der Pfad des Verzeichnisses. + """ + DateiSystemElement.__init__(self, pPfad) + + def nenneKinder(self): + """Anfrage. Gibt eine Liste der Kinder des Verzeichnisses zurück.""" + tListe = [] + + try: + tListe = os.listdir(self._pfad) + except: + print("Fehler. Einlesen von '%s' nicht möglich." % self._pfad) + + return tListe diff --git a/source/Android/dateien/__init__.py b/source/Android/dateien/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/source/Android/multimedia/AudioPlayer.py b/source/Android/multimedia/AudioPlayer.py new file mode 100644 index 0000000..4e5918d --- /dev/null +++ b/source/Android/multimedia/AudioPlayer.py @@ -0,0 +1,178 @@ +# -*- coding: utf-8 -*- +import time +import random +import velamentum.dateien.Datei +from velamentum.multimedia.Player import Player +from velamentum.android import * + +class AudioPlayer(Player): + """Die Klasse Player dient der Wiedergabe von Multimediadaten aus einer + Datei. + + Attribute: + --- von 'Player' geerbte --- + datei (Datei): Die Datei, deren Inhalt wiedergegeben werden soll. + dauer (Zahl): Gesamtdauer der Datei in Millisekunden. + position (Zahl): Die aktuelle Position der Wiedergabe in Millisekunden. + wiederholen (Wahrheitswert): Gibt an, ob die Wiedergabe am Ende von + vorne beginnen soll. + """ + + def __init__(self, pDatei, pSofortWiedergeben=False): + """Konstruktor. Initialisiert den Player. + + Parameter: + pDatei (Datei): Datei, die wiedergegeben werden soll. + [optional] pSofortWiedergeben (Wahrheitswert): Soll die Datei direkt + nach der Initialisierung wiedergegeben werden? + """ + self.datei = pDatei + # Eindeutige ID festlegen zur Verwaltung verschiedener gleichzeitig + # wiederzugebender Streams. + self._id = "%s%04d" % (pDatei.nenneName(), random.randint(0,8191)) + + if self.datei.istVorhanden(): + androide.mediaPlay(self.datei.nennePfad(), self._id, + pSofortWiedergeben) + self.dauer = int(androide.mediaPlayInfo(self._id)[1]["duration"]) + else: + print("Fehler. Datei %s nicht gefunden." % pDatei.nennePfad()) + + def __del__(self): + """Destruktor. Stellt sicher, dass die Wiedergabe beim Löschen des + Objekts beendet wird. + + Parameter: + --- keine --- + """ + androide.mediaPlayClose(self._id) + + def nenneDauer(self): + """Anfrage. Gibt die Gesamtdauer der Datei zurück. + + Parameter: + --- keine --- + + Rückgabe (Zahl): Gesamtdauer der Datei in Millisekunden. + """ + return self.dauer + + def nennePosition(self): + """Anfrage. Gibt die aktuelle Position der Wiedergabe zurück. + + Parameter: + --- keine --- + + Rückgabe (Zahl): Aktuelle Position der Wiedergabe in Millisekunden. + """ + return int(androide.mediaPlayInfo(self._id)[1]["position"]) + + def setzePosition(self, pPosition): + """Auftrag. Legt die aktuelle Position der Wiedergabe fest. + + Parameter: + pPosition (Zahl): Neue Position in Millisekunden. + """ + # Position auf gültigen Bereich (0 - dauer) beschränken. + if pPosition > self.dauer: + pPosition = self.dauer + elif pPosition < 0: + pPosition = 0 + + androide.mediaPlaySeek(pPosition, self._id) + + + def nenneDatei(self): + """Anfrage. Gibt die Datei zurück, die wiedergegeben werden soll. + + Parameter: + --- keine --- + + Rückgabe (Datei): Datei, die wiedergegeben werden soll. + """ + return self.datei + + def setzeDatei(self, pDatei): + """Auftrag. Legt die Datei fest, die wiedergegeben werden soll. + + Parameter: + pDatei (Datei): Datei, die wiedergegeben werden soll. + """ + Player.setzeDatei(self, pDatei) + + if pDatei.istVorhanden(): + androide.mediaPlay(self.datei.nennePfad(), self._id, False) + self.dauer = int(androide.mediaPlayInfo(self._id)[1]["duration"]) + else: + print("Fehler. Datei %s nicht gefunden." % pDatei.nennePfad()) + + def nenneWiederholen(self): + """Anfrage. Gibt zurück, ob die Wiedergabe am Ende wieder von vorne + beginnen soll. + + Parameter: + --- keine --- + + Rückgabe (Wahrheitswert): Soll die Datei wiederholt + wiedergegeben werden? + """ + return androide.mediaPlayInfo(self._id)[1]["looping"] + + def setzeWiederholen(self, pWiederholen): + """Auftrag. Legt fest, ob die Wiedergabe am Ende wieder von vorne + beginnen soll. + + Parameter: + pWiederholen (Wahrheitswert): Soll die Datei wiederholt + wiedergegeben werden? + """ + return androide.mediaPlaySetLooping(self._id, pWiederholen) + + def gibtWieder(self): + """Anfrage. Gibt an, ob die Datei gerade wiedergegeben wird. + + Parameter: + --- keine --- + + Rückgabe (Wahrheitswert): True falls gerade eine Wiedergabe läuft, + False sonst. + """ + return androide.mediaIsPlaying(self._id)["result"] + + def wiedergeben(self): + """Auftrag. Startet die Wiedergabe der Multimediadaten. + + Parameter + --- keine --- + """ + androide.mediaPlayStart(self._id) + + def pausieren(self): + """Auftrag. Pausiert die Wiedergabe der Multimediadaten. Die Wiedergabe + kann mit 'wiedergeben' fortgesetzt werden. + + Parameter + --- keine --- + """ + androide.mediaPlayPause(self._id) + + def stoppen(self): + """Auftrag. Stoppt die Wiedergabe der Multimediadaten. (Wie 'pausieren', + Wiedergabe kann jedoch nicht fortgesetzt werden, sondern beginnt dann + von vorne. + + Parameter + --- keine --- + """ + androide.mediaPlayPause(self._id) + self.setzePosition(0) + + # Attribute (verdeckte Getter und Setter) + datei = property(nenneDatei, setzeDatei, doc="Die Datei, deren Inhalt " \ + "wiedergegeben werden soll.") + dauer = property(nenneDauer, doc="Die Gesamtdauer der Datei in Millisekunden.") + position = property(nennePosition, setzePosition, doc = "Die aktuelle "\ + "Position der Wiedergabe.") + wiederholen = property(nenneWiederholen, setzeWiederholen, doc="Gibt an, "\ + "ob die Wiedergabe am Ende wieder von vorne beginnen soll.") + diff --git a/source/Android/multimedia/AudioRecorder.py b/source/Android/multimedia/AudioRecorder.py new file mode 100644 index 0000000..ac580d0 --- /dev/null +++ b/source/Android/multimedia/AudioRecorder.py @@ -0,0 +1,58 @@ +# -*- coding: utf-8 -*- +import velamentum.dateien.Datei +from velamentum.multimedia.Recorder import Recorder +from velamentum.ui.dialoge.Dialog import Dialog +from velamentum.android import * + +class AudioRecorder(Recorder): + """Die Klasse AudioRecorder dient der Aufnahme von Tondaten in eine Datei. + + Attribute: + --- von 'Recorder' geerbte --- + """ + + def __init__(self, pDatei=velamentum.dateien.Datei.Datei("/sdcard/aufnahme.m4a")): + """Konstruktor. Initialisiert den AudioRecorder. + + Parameter: + [optional] datei (Datei): Datei, in der die Aufnahme gespeichert + werden soll [Standardwert: Datei mit Pfad '/scard/aufnahme.m4a']. + """ + Recorder.__init__(self, pDatei) + + def aufnehmen(self): + """Auftrag. Startet die Aufnahme der Multimediadaten. + + HINWEIS: Die angegebene Datei wird überschrieben. + + Parameter + --- keine --- + """ + Recorder.aufnehmen(self) + androide.recorderStartMicrophone(self.datei.nennePfad()) + + def stoppen(self): + """Auftrag. Stoppt die Aufnahme der Multimediadaten. + + Parameter + --- keine --- + """ + Recorder.stoppen(self) + androide.recorderStop() + + def aufnehmenInteraktiv(self): + """Auftrag. Startet eine interaktive Aufnahme. Der Benutzer erhält die + Möglichkeit die Aufnahme interaktiv zu starten und zu stoppen. Dazu wird + in der Regel auf die jeweilige Recorder-Applikation zurückgegriffen. + + HINWEIS: Die angegebene Datei wird überschrieben. + + Parameter: + --- keine --- + """ + self.aufnehmen() + dialog = Dialog("Audioaufnahme", "Aufnahme gestartet. Zum Beenden" \ + "'Ok' drücken.") + dialog.zeige() + self.stoppen() + diff --git a/source/Android/multimedia/BildRecorder.py b/source/Android/multimedia/BildRecorder.py new file mode 100644 index 0000000..62144d7 --- /dev/null +++ b/source/Android/multimedia/BildRecorder.py @@ -0,0 +1,51 @@ +# -*- coding: utf-8 -*- +import velamentum.dateien.Datei +from velamentum.multimedia.Recorder import Recorder +from velamentum.android import * + +class BildRecorder(Recorder): + """Die Klasse BildRecorder dient der Aufnahme von Bilddaten in eine Datei. + + Attribute: + --- von 'Recorder' geerbte --- + """ + + def __init__(self, pDatei=velamentum.dateien.Datei.Datei("/sdcard/aufnahme.jpg")): + """Konstruktor. Initialisiert den BildRecorder. + + Parameter: + [optional] pDatei (Datei): Datei, in der die Aufnahme gespeichert + werden soll [Standardwert: Datei mit Pfad '/scard/aufnahme.jpg']. + """ + Recorder.__init__(self, pDatei) + + def aufnehmen(self): + """Auftrag. Macht ein Foto und speichert es in der angegebenen Datei. + + HINWEIS: Die angegebene Datei wird überschrieben. + + Parameter + --- keine --- + """ + androide.cameraCapturePicture(self.datei.nennePfad()) + + def stoppen(self): + """Auftrag. Dummy. Für Fotos nutzlos. + + Parameter + --- keine --- + """ + pass + + def aufnehmenInteraktiv(self): + """Auftrag. Startet eine interaktive Aufnahme. Der Benutzer erhält die + Möglichkeit die Aufnahme interaktiv zu starten und zu stoppen. Dazu wird + auf die Standard-Kamera-App zurückgegriffen. + + HINWEIS: Die angegebene Datei wird überschrieben. + + Parameter: + --- keine --- + """ + androide.cameraInteractiveCapturePicture(self.datei.nennePfad()) + diff --git a/source/Android/multimedia/JNIAudioRecorder.py b/source/Android/multimedia/JNIAudioRecorder.py new file mode 100644 index 0000000..6dbd38d --- /dev/null +++ b/source/Android/multimedia/JNIAudioRecorder.py @@ -0,0 +1,91 @@ +# -*- coding: utf-8 -*- +import velamentum.dateien.Datei +from velamentum.multimedia.Recorder import Recorder +from velamentum.ui.dialoge.Dialog import Dialog + +from jnius import autoclass + +from velamentum.android import * + +class JNIAudioRecorder(Recorder): + """Die Klasse AudioRecorder dient der Aufnahme von Tondaten in eine Datei. + + BUG: Die Nutzung aus der QPython-Konsole funktioniert derzeit nicht. + Der Aufruf aus einer Skriptdatei funktioniert hingegen problemlos. + + Attribute: + --- von 'Recorder' geerbte --- + """ + + def __init__(self, pDatei=velamentum.dateien.Datei.Datei("/sdcard/aufnahme.m4a")): + """Konstruktor. Initialisiert den JNIAudioRecorder. + + Parameter: + [optional] pDatei (Datei): Datei, in der die Aufnahme gespeichert + werden soll [Standardwert: Datei mit Pfad + '/sdcard/aufnahme.m4a']. + """ + Recorder.__init__(self, pDatei) + + # Recorder initialisieren + MediaRecorder = autoclass('android.media.MediaRecorder') + AudioSource = autoclass('android.media.MediaRecorder$AudioSource') + OutputFormat = autoclass('android.media.MediaRecorder$OutputFormat') + AudioEncoder = autoclass('android.media.MediaRecorder$AudioEncoder') + self.__mRecorder = MediaRecorder() + self.__mRecorder.setOutputFile(pDatei.nennePfad()) # Pfad der Datei + self.__mRecorder.setAudioSource(AudioSource.MIC) # Aufnahme vom Mikrofon + self.__mRecorder.setAudioChannels(1) # Mono + self.__mRecorder.setAudioEncodingBitRate(131072) # 128 kbps + self.__mRecorder.setAudioSamplingRate(48000) # 48 kHz + # ACHTUNG: Reihenfolge ist relevant! Erst Format, dann Encoder! + self.__mRecorder.setOutputFormat(OutputFormat.MPEG_4) # MP4-Container + self.__mRecorder.setAudioEncoder(AudioEncoder.AAC) # AAC-Format + + def __del__(self): + """Destruktor. Notwendig zur Freigabe des MediaRecorders beim Löschen + des Python-Objekts. + + Parameter: + --- keine --- + """ + self.__mRecorder.release() + + def aufnehmen(self): + """Auftrag. Startet die Aufnahme der Multimediadaten. + + HINWEIS: Die angegebene Datei wird überschrieben. + + Parameter + --- keine --- + """ + Recorder.aufnehmen(self) + self.__mRecorder.setOutputFile(self.datei.nennePfad()) + self.__mRecorder.prepare() + self.__mRecorder.start() + + def stoppen(self): + """Auftrag. Stoppt die Aufnahme der Multimediadaten. + + Parameter + --- keine --- + """ + Recorder.stoppen(self) + self.__mRecorder.stop() + + def aufnehmenInteraktiv(self): + """Auftrag. Startet eine interaktive Aufnahme. Der Benutzer erhält die + Möglichkeit die Aufnahme interaktiv zu starten und zu stoppen. Dazu wird + in der Regel auf die jeweilige Recorder-Applikation zurückgegriffen. + + HINWEIS: Die angegebene Datei wird überschrieben. + + Parameter: + --- keine --- + """ + self.aufnehmen() + dialog = Dialog("Audioaufnahme", "Aufnahme gestartet. Zum Beenden" \ + "'Ok' drücken.") + dialog.zeige() + self.stoppen() + diff --git a/source/Android/multimedia/Player.py b/source/Android/multimedia/Player.py new file mode 100644 index 0000000..6e8ea61 --- /dev/null +++ b/source/Android/multimedia/Player.py @@ -0,0 +1,144 @@ +# -*- coding: utf-8 -*- +import time +import velamentum.dateien.Datei +from velamentum.android import * + +class Player(object): + """Die Klasse Player dient der Wiedergabe von Multimediadaten aus einer + Datei. + + Attribute: + datei (Datei): Die Datei, deren Inhalt wiedergegeben werden soll. + dauer (Zahl): Gesamtdauer der Datei in Millisekunden. + position (Zahl): Die aktuelle Position der Wiedergabe in Millisekunden. + wiederholen (Wahrheitswert): Gibt an, ob die Wiedergabe am Ende von + vorne beginnen soll. + """ + + def __init__(self, pDatei): + """Konstruktor. Initialisiert den Player. + + Parameter: + pDatei (Datei): Datei, die wiedergegeben werden soll. + """ + self.datei = pDatei + # Eindeutige ID festlegen zur Verwaltung verschiedener gleichzeitig + # wiederzugebender Streams. + self._id = "%s%04d" % (pDatei.nenneName(), randint(0,4095)) + + def nenneDatei(self): + """Anfrage. Gibt die Datei zurück, die wiedergegeben werden soll. + + Parameter: + --- keine --- + + Rückgabe (Datei): Datei, die wiedergegeben werden soll. + """ + return self.datei + + def setzeDatei(self): + """Anfrage. Gibt die Datei zurück, die wiedergegeben werden soll. + + Parameter: + --- keine --- + + Rückgabe (Datei): Datei, die wiedergegeben werden soll. + """ + return self.datei + + def nenneWiederholen(self): + """Anfrage. Gibt zurück, ob die Wiedergabe am Ende wieder von vorne + beginnen soll. + + Parameter: + --- keine --- + + Rückgabe (Wahrheitswert): Soll die Datei wiederholt + wiedergegeben werden? + """ + return False + + def setzeWiederholen(self, pWiederholen): + """Auftrag. Legt fest, ob die Wiedergabe am Ende wieder von vorne + beginnen soll. + + Parameter: + pWiederholen (Wahrheitswert): Soll die Datei wiederholt + wiedergegeben werden? + """ + pass + + def nenneDauer(self): + """Anfrage. Gibt die Gesamtdauer der Datei zurück. + + Parameter: + --- keine --- + + Rückgabe (Zahl): Gesamtdauer der Datei in Millisekunden. + """ + return 0 + + def nennePosition(self): + """Anfrage. Gibt die aktuelle Position der Wiedergabe zurück. + + Parameter: + --- keine --- + + Rückgabe (Zahl): Gesamtdauer der Datei in Millisekunden. + """ + return 0 + + def setzePosition(self, pPosition): + """Auftrag. Legt die aktuelle Position der Wiedergabe fest. + + Parameter: + pPosition (Zahl): Neue Position in Millisekunden. + """ + pass + + def gibtWieder(self): + """Anfrage. Gibt an, ob die Datei gerade wiedergegeben wird. + + Parameter: + --- keine --- + + Rückgabe (Wahrheitswert): True falls gerade eine Wiedergabe läuft, + False sonst. + """ + return False + + def wiedergeben(self): + """Auftrag. Startet die Wiedergabe der Multimediadaten. + + Parameter + --- keine --- + """ + pass + + def pausieren(self): + """Auftrag. Pausiert die Wiedergabe der Multimediadaten. Die Wiedergabe + kann mit 'wiedergeben' fortgesetzt werden. + + Parameter + --- keine --- + """ + pass + + def stoppen(self): + """Auftrag. Stoppt die Wiedergabe der Multimediadaten. + + Parameter + --- keine --- + """ + pass + + # Attribute (verdeckte Getter und Setter) + datei = property(nenneDatei, setzeDatei, doc="Die Datei, deren Inhalt " \ + "wiedergegeben werden soll.") + dauer = property(nenneDauer, doc="Die Gesamtdauer der Datei in Millisekunden.") + position = property(nennePosition, setzePosition, doc = "Die aktuelle "\ + "Position der Wiedergabe.") + wiederholen = property(nenneWiederholen, setzeWiederholen, doc="Gibt an, "\ + "ob die Wiedergabe am Ende wieder von vorne beginnen soll.") + + diff --git a/source/Android/multimedia/Recorder.py b/source/Android/multimedia/Recorder.py new file mode 100644 index 0000000..92616f3 --- /dev/null +++ b/source/Android/multimedia/Recorder.py @@ -0,0 +1,96 @@ +# -*- coding: utf-8 -*- +import time +import velamentum.dateien.Datei +from velamentum.android import * + +class Recorder(object): + """Die Klasse Recorder dient der Aufnahme von Multimediadaten in eine Datei. + + Attribute: + aufnahmeLaeuft (Wahrheitswert): Gibt an, ob gerade eine Aufnahme läuft. + datei (Datei): Die Datei, in der die Aufnahme gespeichert werden soll. + """ + + def __init__(self, pDatei=velamentum.dateien.Datei.Datei("/sdcard/aufnahme")): + """Konstruktor. Initialisiert den Recorder. + + Parameter: + [optional] datei (Datei): Datei, in der die Aufnahme gespeichert + werden soll [Standardwert: Datei mit Pfad '/scard/aufnahme']. + """ + self.aufnahmeLaeuft = False + self.datei = pDatei + + def nimmtAuf(self): + """Anfrage. Gibt an, ob gerade eine Aufgabe läuft. + + Parameter: + --- keine --- + + Rückgabe (Wahrheitswert): True falls eine Aufnahme läuft, False sonst. + """ + return self.aufnahmeLaeuft + + def nenneDatei(self): + """Anfrage. Gibt die Datei zurück, in der die Aufnahme gespeichert + werden soll. + + Parameter + --- keine --- + + Rückgabe (Datei): Datei, in der die Aufnahme gespeichert werden soll. + """ + return self.datei + + def setzeDatei(self, pDatei): + """Auftrag. Legt die Datei fest, in der die Aufnahme gespeichert + werden soll. + + Parameter + pDatei (Datei): Datei, in der die Aufnahme gespeichert werden soll. + """ + self.datei = pDatei + + def aufnehmen(self): + """Auftrag. Startet die Aufnahme der Multimediadaten. + + HINWEIS: Die angegebene Datei wird überschrieben. + + Parameter + --- keine --- + """ + self.aufnahmeLaeuft = True + + def stoppen(self): + """Auftrag. Stoppt die Aufnahme der Multimediadaten. + + Parameter + --- keine --- + """ + self.aufnahmeLaeuft = False + + def aufnehmenAuto(self, pDauer): + """Auftrag. Startet eine Aufnahme mit der in 'pDauer' angegebenen Dauer + und beendet die Aufnahme danach automatisch. + + HINWEIS: Die angegebene Datei wird überschrieben. + + Parameter + pDauer (Zahl): Dauer der Aufnahme. + """ + self.aufnehmen() + time.sleep(pDauer) + self.stoppen() + + def aufnehmenInteraktiv(self): + """Auftrag. Startet eine interaktive Aufnahme. Der Benutzer erhält die + Möglichkeit die Aufnahme interaktiv zu starten und zu stoppen. Dazu wird + in der Regel auf die jeweilige Recorder-Applikation zurückgegriffen. + + HINWEIS: Die angegebene Datei wird überschrieben. + + Parameter: + --- keine --- + """ + pass + diff --git a/source/Android/multimedia/VideoRecorder.py b/source/Android/multimedia/VideoRecorder.py new file mode 100644 index 0000000..acb7e34 --- /dev/null +++ b/source/Android/multimedia/VideoRecorder.py @@ -0,0 +1,53 @@ +# -*- coding: utf-8 -*- +import velamentum.dateien.Datei +from velamentum.multimedia.Recorder import Recorder +from velamentum.android import * + +class VideoRecorder(Recorder): + """Die Klasse VideoRecorder dient der Aufnahme von Videodaten in eine Datei. + + Attribute: + --- von 'Recorder' geerbte --- + """ + + def __init__(self, pDatei=velamentum.dateien.Datei.Datei("/sdcard/aufnahme.mp4")): + """Konstruktor. Initialisiert den VideoRecorder. + + Parameter: + [optional] pDatei (Datei): Datei, in der die Aufnahme gespeichert + werden soll [Standardwert: Datei mit Pfad '/scard/aufnahme.m4a']. + """ + Recorder.__init__(self, pDatei) + + def aufnehmen(self): + """Auftrag. Startet die Aufnahme der Multimediadaten. + + HINWEIS: Die angegebene Datei wird überschrieben. + + Parameter + --- keine --- + """ + Recorder.aufnehmen(self) + androide.recorderCaptureVideo(self.datei.nennePfad()) + + def stoppen(self): + """Auftrag. Stoppt die Aufnahme der Multimediadaten. + + Parameter + --- keine --- + """ + Recorder.stoppen(self) + androide.recorderStop() + + def aufnehmenInteraktiv(self): + """Auftrag. Startet eine interaktive Aufnahme. Der Benutzer erhält die + Möglichkeit die Aufnahme interaktiv zu starten und zu stoppen. Dazu wird + in der Regel auf die jeweilige Recorder-Applikation zurückgegriffen. + + HINWEIS: Die angegebene Datei wird überschrieben. + + Parameter: + --- keine --- + """ + androide.startInteractiveVideoRecording(self.datei.nennePfad()) + diff --git a/source/Android/multimedia/__init__.py b/source/Android/multimedia/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/source/Android/sensoren/__init__.py b/source/Android/sensoren/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/source/Android/signale/AudioSignal.mp3 b/source/Android/signale/AudioSignal.mp3 new file mode 100644 index 0000000..f18ee79 Binary files /dev/null and b/source/Android/signale/AudioSignal.mp3 differ diff --git a/source/Android/signale/AudioSignal.py b/source/Android/signale/AudioSignal.py new file mode 100644 index 0000000..c33354b --- /dev/null +++ b/source/Android/signale/AudioSignal.py @@ -0,0 +1,60 @@ +# -*- coding: utf-8 -*- +from velamentum.signale.Signal import Signal +from velamentum.multimedia.AudioPlayer import AudioPlayer +from velamentum.dateien.Datei import Datei +import os.path + +class AudioSignal(Signal): + """Die Klasse AudioSignal dient der Übermittlung von Audiosignalen + an den Benutzer. + + Attribute: + datei (Datei): Audiodatei, die für das Signal verwendet werden soll. + """ + + def __init__(self, pDatei=None): + """Konstruktor. Initialisiert das AudioSignal. + + Parameter: + [optional] pDatei (Zeichenkette): Audiodatei, die für das Signal + verwendet werden soll. [Standardwert: None] + """ + Signal.__init__(self) + self.setzeDatei(pDatei) + self.__audioPlayer = AudioPlayer(self.nenneDatei()) + + def nenneDatei(self): + """Anfrage. Gibt die Audiodatei des Signals zurück. + + Parameter: + --- keine --- + + Rückgabe (Zeichenkette): Audiodatei des Signals. + """ + return self.__datei + + def setzeDatei(self, pDatei): + """Auftrag. Ändert die Audiodatei des Signals. + + Parameter: + pDatei (Zeichenkette): Audiodatei des Signals. + """ + # Falls keine Datei angegeben wurde, verwende Standarddatei aus dem + # Modulpfad. + if pDatei==None: + tDatei = os.path.join(os.path.dirname(__file__),"AudioSignal.mp3") + pDatei = Datei(tDatei) + + self.__datei = pDatei + + def signalisiere(self): + """Auftrag. Übermittelt das Signal an den Benutzer. + + Parameter + --- keine --- + """ + self.__audioPlayer.wiedergeben() + + # Attribute (verdeckte Getter und Setter) + datei = property(nenneDatei, setzeDatei, doc="Die Audiodatei, die für das "\ + "Signal verwendet werden soll.") diff --git a/source/Android/signale/Signal.py b/source/Android/signale/Signal.py new file mode 100644 index 0000000..c69dba2 --- /dev/null +++ b/source/Android/signale/Signal.py @@ -0,0 +1,22 @@ +# -*- coding: utf-8 -*- +from velamentum.android import * + +class Signal(object): + """Die Klasse Signal dient der Übermittlung von Signalen an den Benutzer.""" + + def __init__(self): + """Konstruktor. Initialisiert das Signal. + + Parameter: + --- keine --- + """ + pass + + def signalisiere(self): + """Auftrag. Übermittelt das Signal an den Benutzer. + + Parameter + --- keine --- + """ + pass + diff --git a/source/Android/signale/TextSignal.py b/source/Android/signale/TextSignal.py new file mode 100644 index 0000000..e86e08b --- /dev/null +++ b/source/Android/signale/TextSignal.py @@ -0,0 +1,45 @@ +# -*- coding: utf-8 -*- +from velamentum.signale.Signal import Signal + +class TextSignal(Signal): + """Die Klasse TextSignal dient der Übermittlung von Textsignalen + an den Benutzer. + + Attribute: + text (Zeichenkette): Text des Signals. + """ + + def __init__(self, pText="TextSignal"): + """Konstruktor. Initialisiert das Signal. + + Parameter: + [optional] pText (Zeichenkette): Text des Signals. + """ + Signal.__init__(self) + self.text = pText + + def nenneText(self): + """Anfrage. Gibt den Text des Signals zurück. + + Parameter: + --- keine --- + + Rückgabe (Zeichenkette): Text des Signals. + """ + return self.text + + def setzeText(self, pText): + """Auftrag. Ändert den Text des Signals. + + Parameter: + pText (Zeichenkette): Text des Signals. + """ + self.text = pText + + def signalisiere(self): + """Auftrag. Übermittelt das Signal an den Benutzer. + + Parameter + --- keine --- + """ + androide.makeToast(self.text) diff --git a/source/Android/signale/VibrationsSignal.py b/source/Android/signale/VibrationsSignal.py new file mode 100644 index 0000000..b8b01f7 --- /dev/null +++ b/source/Android/signale/VibrationsSignal.py @@ -0,0 +1,45 @@ +# -*- coding: utf-8 -*- +from velamentum.signale.Signal import Signal + +class VibrationsSignal(Signal): + """Die Klasse Signal dient der Übermittlung von Vibrationssignalen + an den Benutzer. + + Attribute + dauer (Zahl): Dauer der Vibration in Millisekunden.""" + + def __init__(self, pDauer=300): + """Konstruktor. Initialisiert das Vibrationssignal. + + Parameter: + [optional] pDauer (Zahl): Dauer der Vibration in Millisekunden. + [Standardwert: 300] + """ + Signal.__init__(self) + self.dauer = pDauer + + def nenneDauer(self): + """Anfrage. Gibt die Dauer der Vibration zurück. + + Parameter: + --- keine --- + + Rückgabe (Zahl): Dauer der Vibration in Millisekunden. + """ + return self.dauer + + def setzeDauer(self, pDauer): + """Auftrag. Ändert die Dauer der Vibration. + + Parameter: + pDauer: Dauer der Vibration in Millisekunden. + """ + self.dauer = pDauer + + def signalisiere(self): + """Auftrag. Übermittelt das Signal an den Benutzer. + + Parameter: + --- keine --- + """ + androide.vibrate(self.dauer) diff --git a/source/Android/signale/__init__.py b/source/Android/signale/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/source/Android/sprache/Sprachausgabe.py b/source/Android/sprache/Sprachausgabe.py new file mode 100644 index 0000000..4f6e699 --- /dev/null +++ b/source/Android/sprache/Sprachausgabe.py @@ -0,0 +1,55 @@ +# -*- coding: utf-8 -*- +from velamentum.android import * + +class Sprachausgabe(object): + """Die Klasse Sprachausgabe ermöglicht die Umwandlung von Text in Sprache. + Dieser wird dann als gesprochene Sprache über die Lautsprecher ausgegeben. + + Attribute: + text (Zeichenkette): Der umzuwandelnde Text.""" + + def __init__(self, pText="Text"): + """Auftrag. Initialisiert die Sprachausgabe. + + Parameter: + [optional] pText (Zeichenkette): Der umzuwandelnde Text. + """ + self.text = pText + + def setzeText(self, pText): + """Auftrag. Ändert den umzuwandelnden Text. + + Parameter: + pText (Zeichenkette): + """ + self.text = pText + + def nenneText(self): + """Anfrage. Gibt den umzuwandelnden Text zurück. + + Parameter: + --- keine --- + + Rückgabe (Zeichenkette): Der umzuwandelnde Text. + """ + return self.text + + def sprichtNoch(self): + """Anfrage. Überprüft, ob noch eine Sprachausgabe läuft. + + Parameter: + --- keine --- + + Rückgabe (Wahrheitswert): Liefert True, wenn die Sprachausgabe noch + läuft, sonst False. + """ + return androide.ttsIsSpeaking().result + + def sprechen(self): + """Auftrag. Wandelt den Text in Sprache um und gibt ihn über die + Lautsprecher aus. + + Parameter: + --- keine --- + """ + androide.ttsSpeak(self.text) diff --git a/source/Android/sprache/Spracheingabe.py b/source/Android/sprache/Spracheingabe.py new file mode 100644 index 0000000..d0507db --- /dev/null +++ b/source/Android/sprache/Spracheingabe.py @@ -0,0 +1,39 @@ +# -*- coding: utf-8 -*- +from velamentum.android import * + +class Spracheingabe(object): + """Die Klasse Spracheingabe ermöglicht die Umwandlung von Sprache in Text. + Gesprochener Text wird aufgenommen und mittels einer Spracherkennung in + Text umgewandelt. + + Attribute: + text (Zeichenkette): Der erkannte Text.""" + + def __init__(self): + """Konstruktor: Initialisiert die Spracheingabe. + + Parameter: + --- keine --- + """ + self.text = "" + + def nenneText(self): + """Anfrage. Gibt den erkannten Text zurück. + + Parameter: + --- keine --- + + Rückgabe (Zeichenkette): Der erkannte Text. + """ + return self.text + + def erkenneSprache(self): + """Auftrag. Der gesprochene Text wird erkannt und im Attribut 'text' + gespeichert. + + Parameter: + --- keine --- + """ + self.text = androide.recognizeSpeech("Bitte sprechen!","de-DE", + "free_form").result + diff --git a/source/Android/sprache/__init__.py b/source/Android/sprache/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/source/Android/ui/__init__.py b/source/Android/ui/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/source/Android/ui/dialoge/Dialog.py b/source/Android/ui/dialoge/Dialog.py new file mode 100644 index 0000000..b0606a1 --- /dev/null +++ b/source/Android/ui/dialoge/Dialog.py @@ -0,0 +1,79 @@ +# -*- coding: utf-8 -*- +from velamentum.android import * + +class Dialog(object): + """Die Klasse Dialog stellt einen einfachen Dialog zur Verfuegung, der eine + Nachricht anzeigen kann und nach Bestätigung durch den Benutzer wieder + verschwindet. + + Attribute: + titel (Zeichenkette): Der Titel des Dialogs. + nachricht (Zeichenkette): Die Nachricht des Dialogs. + """ + + def __init__(self, pTitel="Titel", pNachricht="Nachricht"): + """Auftrag. Initialisiert den Dialog. + + Parameter: + [optional] pTitel (Zeichenkette): Der Titel des Dialogs. + [optional] pNachricht (Zeichenkette): Die Nachricht des Dialogs. + """ + self.titel = pTitel + self.nachricht = pNachricht + + def setzeNachricht(self, pNachricht): + """Auftrag. Ändert die Nachricht des Dialogs. + + Parameter: + pNachricht (Zeichenkette): Die Nachricht des Dialogs. + """ + self.nachricht = pNachricht + + def setzeTitel(self, pTitel): + """Auftrag. Ändert den Titel des Dialogs. + + Parameter: + pTitel (Zeichenkette): Der Titel des Dialogs. + """ + self.titel = pTitel + + def nenneNachricht(self): + """Anfrage. Gibt die Nachricht des Dialogs zurück. + + Parameter: + --- keine --- + + Rückgabe (Zeichenkette): Die Nachricht des Dialogs. + """ + return self.titel + + def nenneTitel(self): + """Anfrage. Gibt den Titel des Dialogs zurück. + + Parameter: + --- keine --- + + Rückgabe (Zeichenkette): Der Titel des Dialogs. + """ + return self.titel + + def zeigeNachricht(self,pNachricht): + """Auftrag. Kurzform für das Anzeigen eines Dialogs. Setzt die neue + Nachricht und zeigt den Dialog sofort an. + + Parameter: + pNachricht (Zeichenkette): Die Nachricht des Dialogs. + """ + self.nachricht = pNachricht + self.zeige() + + def zeige(self): + """Auftrag. Zeigt den Dialog an. + + Parameter: + --- keine --- + """ + androide.dialogCreateAlert(self.titel, self.nachricht) + androide.dialogSetPositiveButtonText('Ok') + androide.dialogShow() + androide.dialogGetResponse() diff --git a/source/Android/ui/dialoge/EingabeDialog.py b/source/Android/ui/dialoge/EingabeDialog.py new file mode 100644 index 0000000..43ec7ea --- /dev/null +++ b/source/Android/ui/dialoge/EingabeDialog.py @@ -0,0 +1,103 @@ +# -*- coding: utf-8 -*- +from velamentum.ui.dialoge.Dialog import Dialog +from velamentum.android import * + +class EingabeDialog(Dialog): + """Die Klasse EingabeDialog (erbt Attribute und Methoden von der Klasse + Dialog) stellt einen einfachen Dialog zur Eingabe von Zeichenketten zur + Verfügung. + + Attribute: + titel (Zeichenkette): Der Titel des Dialogs. + nachricht (Zeichenkette): Die Nachricht des Dialogs. + ergebnis (Zeichenkette): Der eingegebene Text. + nurZahlen (Wahrheitswert): Nur Zahlen als Eingabe erlauben. + wertAnzeigen (Wahrheitswert): Den aktuellen Wert im Eingabefeld + anzeigen. + """ + + def __init__(self, pTitel="EingabeDialog", pNachricht="Nachricht", pNurZahlen=False, + pWertAnzeigen=False): + """Konstruktor. Initialisiert den EingabeDialog. + + Parameter: + [optional] pTitel (Zeichenkette): Der Titel des Dialogs. + [optional] pNachricht (Zeichenkette): Die Nachricht des Dialogs. + [optional] pNurZahlen (Wahrheitswert): Nur Zahlen als Eingabe + erlauben (Standardwert: False). + [optional] pWertAnzeigen (Wahrheitswert): Den aktuellen Wert im + Eingabefeld anzeigen (Standardwert: False). + """ + Dialog.__init__(self, pTitel, pNachricht) + self.__ergebnis = '' + self.nurZahlen = pNurZahlen + self.wertAnzeigen = pWertAnzeigen + + def nenneErgebnis(self): + """Anfrage. Gibt die eingegebene Zeichenkette zurück. + + Parameter: + --- keine --- + + Rückgabe (Zeichenkette): Die eingegebene Zeichenkette. + """ + if self.__ergebnis == '' and self.nurZahlen: + self.__ergebnis = 0 + return int(self.__ergebnis) if self.nurZahlen else self.__ergebnis + + def nenneNurZahlen(self): + """Anfrage. Gibt zurück, ob nur Zahlen als Eingabe zugelassen sind. + + Parameter: + --- keine --- + + Rückgabe (Wahrheitswert): Sollen nur Zahlen als Eingabe zugelassen sein? + """ + return self.nurZahlen + + def nenneWertAnzeigen(self): + """Anfrage. Gibt zurück, ob der aktuelle Wert im Eingabefeld angezeigt + werden soll. + + Parameter: + --- keine --- + + Rückgabe (Wahrheitswert): Soll der aktuelle Wert bei der Eingabe + angezeigt werden? + """ + return self.wertAnzeigen + + def setzeNurZahlen(self, pNurZahlen): + """Auftrag. Legt fest, ob nur Zahlen als Eingabe zugelassen sind. + + Parameter: + pNurZahlen (Wahrheitswert): Sollen nur Zahlen als Eingabe zugelassen + sein? + """ + self.nurZahlen = pNurZahlen + + def setzeWertAnzeigen(self, pWertAnzeigen): + """Auftrag. Legt fest, ob der aktuelle Wert bei der Eingabe angezeigt + werden soll. + + Parameter: + pWertAnzeigen (Wahrheitswert): Soll der aktuelle Wert bei der + Eingabe angezeigt werden? + """ + self.nurZahlen = pWertAnzeigen + + def zeige(self): + """Auftrag. Zeigt den EingabeDialog an und speichert die eingegebene + Zeichenkette im Attribut 'ergebnis'. + + Parameter: + --- keine --- + """ + androide.dialogCreateInput(self.titel, self.nachricht, + self.__ergebnis if self.wertAnzeigen else '', + 'number' if self.nurZahlen else 'text') + androide.dialogSetPositiveButtonText('Ok') + androide.dialogShow() + self.__ergebnis = androide.dialogGetResponse().result['value'] + + ergebnis = property(nenneErgebnis, doc="Die Eingabe des Benutzers.") diff --git a/source/Android/ui/dialoge/EntscheidungsDialog.py b/source/Android/ui/dialoge/EntscheidungsDialog.py new file mode 100644 index 0000000..ee8d35a --- /dev/null +++ b/source/Android/ui/dialoge/EntscheidungsDialog.py @@ -0,0 +1,152 @@ +# -*- coding: utf-8 -*- +from velamentum.ui.dialoge.Dialog import Dialog +from velamentum.android import * + +class EntscheidungsDialog(Dialog): + """Die Klasse Dialog stellt einen einfachen Dialog mit zwei oder drei + Tasten als Antwortmöglichkeiten zur Verfuegung. Der Text der Tasten ist + frei wählbar. + + Attribute: + titel (Zeichenkette): Der Titel des Dialogs. + nachricht (Zeichenkette): Die Nachricht des Dialogs. + ergebnis (Zahl): Die Nummer der ausgewählten Taste (1-3), 0 bei Abbruch + oder Fehler. + text1 (Zeichenkette): Der Text der ersten Taste. + text2 (Zeichenkette): Der Text der zweiten Taste. + text3 (Zeichenkette): Der Text der dritten Taste. + dreiTasten (Wahrheitswert): Anzahl der anzuzeigenden Tasten. True für + drei Tasten, False für zwei Tasten. + """ + + def __init__(self, pTitel="Titel", pNachricht="Nachricht"): + """Konstruktor. Initialisiert den EntscheidungsDialog. + + Parameter: + [optional] pTitel (Zeichenkette): Der Titel des Dialogs. + [optional] pNachricht (Zeichenkette): Die Nachricht des Dialogs. + """ + Dialog.__init__(self, pTitel, pNachricht) + self.ergebnis = 0 + self.text1 = "Ja" + self.text2 = "Nein" + self.text3 = "Vielleicht" + self.dreiTasten = False + + def setzeText1(self, pText): + """Auftrag. Ändert den Text der ersten Taste. + + Parameter: + pText (Zeichenkette): Text der Taste. + """ + self.text1 = pText + + def setzeText2(self, pText): + """Auftrag. Ändert den Text der zweiten Taste. + + Parameter: + pText (Zeichenkette): Text der Taste. + """ + self.text2 = pText + + def setzeText3(self, pText): + """Auftrag. Ändert den Text der dritten Taste. + + Parameter: + pText (Zeichenkette): Text der Taste. + """ + self.text3 = pText + + def setzeDreiTasten(self, pDreiTasten): + """Auftrag. Legt fest, ob zwei oder drei Tasten angezeigt werden sollen. + + Parameter: + dreiTasten (Wahrheitswert): Anzahl der anzuzeigenden Tasten. + True für drei Tasten, False für zwei Tasten. + """ + self.dreiTasten = pDreiTasten + + def nenneErgebnis(self): + """Anfrage. Gibt die Nummer der gewählten Taste (1-3) oder 0 bei einem + Abbruch oder Fehler aus. + + Parameter: + --- keine --- + + Rückgabe (Zahl): Fehler oder Abbruch durch den Benutzer => 0, + Taste gedrückt => Nummer der Taste (1-3). + """ + return self.ergebnis + + def nenneText1(self): + """Anfrage. Gibt den Text der ersten Taste zurück. + + Parameter: + --- keine --- + + Rückgabe (Zeichenkette): Der Text der ersten Taste. + """ + return self.text1 + + def nenneText2(self): + """Anfrage. Gibt den Text der zweiten Taste zurück. + + Parameter: + --- keine --- + + Rückgabe (Zeichenkette): Der Text der zweiten Taste. + """ + return self.text2 + + def nenneText3(self): + """Anfrage. Gibt den Text der dritten Taste zurück. + + Parameter: + --- keine --- + + Rückgabe (Zeichenkette): Der Text der dritten Taste. + """ + return self.text3 + + def nenneDreiTasten(self): + """Anfrage. Gibt zurück ob zwei (False) oder drei (True) Tasten + angezeigt werden sollen. + + Parameter: + --- keine --- + + Rückgabe (Wahrheitswert): True, falls drei Tasten angezeigt werden + sollen, False sonst. + """ + return self.dreiTasten + + def zeige(self): + """Auftrag. Zeigt den EntscheidungsDialog an und speichert die Auswahl + im Attribut 'ergebnis'. + + Parameter: + --- keine --- + """ + + androide.dialogCreateAlert(self.titel, self.nachricht) + androide.dialogSetPositiveButtonText(self.text1) + if self.dreiTasten: + androide.dialogSetNegativeButtonText(self.text3) + androide.dialogSetNeutralButtonText(self.text2) + else: + androide.dialogSetNegativeButtonText(self.text2) + androide.dialogShow() + tmpErg = androide.dialogGetResponse().result + if tmpErg.has_key('which'): + if tmpErg['which'] == 'positive': + self.ergebnis=1 + elif tmpErg['which'] == 'negative': + if self.dreiTasten: + self.ergebnis=3 + else: + self.ergebnis=2 + elif tmpErg['which'] == 'neutral': + self.ergebnis=2 + else: + self.ergebnis = 0 + diff --git a/source/Android/ui/dialoge/PasswortDialog.py b/source/Android/ui/dialoge/PasswortDialog.py new file mode 100644 index 0000000..c398805 --- /dev/null +++ b/source/Android/ui/dialoge/PasswortDialog.py @@ -0,0 +1,39 @@ +# -*- coding: utf-8 -*- +from velamentum.ui.dialoge.EingabeDialog import EingabeDialog +from velamentum.android import * + +class PasswortDialog(EingabeDialog): + """Die Klasse EingabeDialog (erbt Attribute und Methoden von der Klasse + EingabeDialog) stellt einen einfachen Dialog zur Eingabe von Passwörtern zur + Verfügung. Im Unterschied zum Eingabedialog wird die Zeichenkette während + der Eingabe nicht angezeigt. + + Attribute: + titel (Zeichenkette): Der Titel des Dialogs. + nachricht (Zeichenkette): Die Nachricht des Dialogs. + ergebnis (Zeichenkette): Der eingegebene Text. + """ + + def __init__(self, pTitel="Titel", pNachricht="Nachricht", pNurZahlen=False): + """Konstruktor. Initialisiert den PasswortDialog. + + Parameter: + [optional] pTitel (Zeichenkette): Der Titel des Dialogs. + [optional] pNachricht (Zeichenkette): Die Nachricht des Dialogs. + [optional] pNurZahlen (Wahrheitswert): Nur Zahlen als Eingabe + erlauben (Standardwert: False). + """ + EingabeDialog.__init__(self, pTitel, pNachricht, pNurZahlen=False) + + def zeige(self): + """Auftrag. Zeigt den PasswortDialog an und speichert die eingegebene + Zeichenkette im Attribut 'ergebnis'. + + Parameter: + --- keine --- + """ + androide.dialogCreateInput(self.titel, self.nachricht, None, + 'numberPassword' if self.nurZahlen else 'textPassword') + androide.dialogSetPositiveButtonText('Ok') + androide.dialogShow() + self.ergebnis = androide.dialogGetResponse().result['value'] diff --git a/source/Android/ui/dialoge/__init__.py b/source/Android/ui/dialoge/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/source/Android/werkzeuge/System.py b/source/Android/werkzeuge/System.py new file mode 100644 index 0000000..c0a632f --- /dev/null +++ b/source/Android/werkzeuge/System.py @@ -0,0 +1,14 @@ +# -*- coding: utf-8 -*- +import velamentum.dateien.Datei +from velamentum.android import * + +class System(object): + """Die Klasse System dient dem Zugriff auf bestimmte Funktionen des Systems. + + Attribute: + --- keine --- + """ + @staticmethod + def oeffneDatei(pDatei): + androide.view("file://" + pDatei.nennePfad()) + diff --git a/source/Android/werkzeuge/Zufallsgenerator.py b/source/Android/werkzeuge/Zufallsgenerator.py new file mode 100644 index 0000000..8f05d24 --- /dev/null +++ b/source/Android/werkzeuge/Zufallsgenerator.py @@ -0,0 +1,86 @@ +# -*- coding: utf-8 -*- + +import random +import os + +class Zufallsgenerator(object): + """Die Klasse Zufallsgenerator bietet die Möglichkeit einfach Zuffallszahlen + zu generieren. + + Attribute: + min (Zahl): Untere Grenze für die generierten Zufallszahlen. + max (Zahl): Obere Grenze für die generierten Zufallszahlen. + ergebnis (Zahl): Die zuletzt generierte Zufallszahl. + """ + + def __init__(self, pMin=1, pMax=6): + """Konstruktor. Initialisiert den Zufallsgenerator, generiert eine erste + Zufallszahl und speichert sie im Attribut ergebnis. + + Parameter: + [optional] min (Zahl): Kleinste mögliche Zufallszahl. + [optional] max (Zahl): Größte mögliche Zufallszahl. + """ + random.seed(os.urandom(8)); + self.min = pMin + self.max = pMax + self.ergebnis = random.randrange(self.min, self.max+1) + + def setzeMinimum(self, pMin): + """Auftrag. Ändert das Minimum (kleinste mögliche Zufallszahl). + + Parameter: + pMin (Zahl): Kleinste mögliche Zufallszahl. + """ + self.min = pMin + + def setzeMaximum(self, pMax): + """Auftrag. Ändert das Maximum (größte mögliche Zufallszahl). + + Parameter: + pMax (Zahl): Größte mögliche Zufallszahl. + """ + self.max = pMax + + def nenneErgebnis(self): + """Anfrage. Gibt die zuletzt generierte Zufallszahl zurück. + + Parameter: + --- keine --- + + Rückgabe (Zahl): Die zuletzt generierte Zufallszahl. + """ + return self.ergebnis + + def nenneMinimum(self): + """Anfrage. Gibt das eingestellte Minimum (kleinste mögliche + Zufallszahl) zurück. + + Parameter: + --- keine --- + + Rückgabe (Zahl): Kleinste mögliche Zufallszahl. + """ + return self.min + + def nenneMaximum(self): + """Anfrage. Gibt das eingestellte Maximum (größte mögliche Zufallszahl) + zurück. + + Parameter: + --- keine --- + + Rückgabe (Zahl): Größte mögliche Zufallszahl. + """ + return self.max + + def generiere(self): + """Auftrag. Generiert eine neue Zufallszahl und speichert sie im + Attribut 'ergebnis'. + + Parameter: + --- keine --- + """ + self.ergebnis = random.randrange(self.min, self.max+1) + + diff --git a/source/Android/werkzeuge/Zwischenablage.py b/source/Android/werkzeuge/Zwischenablage.py new file mode 100644 index 0000000..30e9860 --- /dev/null +++ b/source/Android/werkzeuge/Zwischenablage.py @@ -0,0 +1,43 @@ +# -*- coding: utf-8 -*- +from velamentum.android import * + +class Zwischenablage(object): + """Die Klasse dient dem Zugriff auf die Zwischenablage des Systems. + + Attribute: + text (Zeichenkette): Der Text in der Zwischenablage des Systems. + """ + + def __init__(self): + """Konstruktor. Initialisiert die Zwischenablage. + + Parameter: + --- keine --- + """ + pass + + @staticmethod + def nenneText(self): + """Anfrage. Gibt den Text aus der Zwischenablage zurück. + + Parameter + --- keine --- + + Rückgabe (Zeichenkette): Der Inhalt der Zwischenablage. + """ + return androide.getClipboard() + + @staticmethod + def setzeText(self, pText): + """Auftrag. Schreibt den Text in die Zwischenablage. + + Parameter + pText (Zeichenkette): Der Text, der in die Zwischenablage + geschrieben werden soll. + """ + androide.setClipboard(pText) + + # Attribute (verdeckte Getter und Setter) + text = property (nenneText, setzeText, doc="Der Text in der" \ + "Zwischenablage des Systems.") + diff --git a/source/Android/werkzeuge/__init__.py b/source/Android/werkzeuge/__init__.py new file mode 100644 index 0000000..e69de29