Android-Implementierung hinzugefügt

Ursprüngliche Implementierung für Android hinzugefügt.

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

source/Android/android.py

@@ -0,0 +1,2 @@
+import androidhelper
+androide = androidhelper.Android()

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.")

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.")
+    
+    

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

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.")
+

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

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

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

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.")
+
+

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
+

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

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.")

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
+

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)

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)

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)

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
+

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

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.")

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
+

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']

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

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)
+
+

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.")
+