Neuordnung und Zusammenführung python Paket mit java

This commit is contained in:
André Hilbig 2020-11-23 09:23:49 +01:00
parent 1645d93e22
commit c93487fce3
Signed by: ahilbig
GPG Key ID: 7CD69479C2659156
122 changed files with 5162 additions and 0 deletions

Binary file not shown.

Binary file not shown.

Binary file not shown.

0
src/Android/__init__.py Normal file
View File

22
src/Android/alle.py Normal file
View File

@ -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

2
src/Android/android.py Normal file
View File

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

View File

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

View File

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

View File

@ -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

View File

View File

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

View File

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

View File

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

View File

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

View File

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

View File

@ -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

View File

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

View File

View File

Binary file not shown.

View File

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

View File

@ -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

View File

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

View File

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

View File

View File

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

View File

@ -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

View File

View File

View File

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

View File

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

View File

@ -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 'which' in tmpErg:
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

View File

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

View File

View File

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

View File

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

View File

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

View File

View File

@ -0,0 +1,18 @@
# -*- coding: utf-8 -*-
from velamentum.alle import *
# Dialog vorbereiten und Begrüßung anzeigen
dialog = Dialog("Quiz", "Willkommen zum Quiz!")
dialog.zeige()
frage = EntscheidungsDialog("Frage 1", "Wie viel ist 5+3?")
frage.setzeText1("7")
frage.setzeText2("8")
frage.zeige()
feedback = Dialog("Feedback", "")
if frage.nenneErgebnis() == 2:
feedback.zeigeNachricht("Richtig!")
else:
feedback.zeigeNachricht("Falsch!")

View File

@ -0,0 +1,50 @@
# -*- coding: utf-8 -*-
from velamentum.ui.dialoge.Dialog import *
from velamentum.ui.dialoge.EntscheidungsDialog import *
from velamentum.werkzeuge.Zufallsgenerator import *
# Dialog vorbereiten und Begrüßung anzeigen
dialog = Dialog("Stein, Papier, Schere", "Willkommen zum Spiel!")
dialog.zeige()
# EntscheidungDialog vorbereiten
eDialog = EntscheidungsDialog("Stein, Papier, Schere", "Bitte wählen Sie " \
"Ihren Gegenstand.")
eDialog.setzeText1("Stein")
eDialog.setzeText2("✂️ Schere")
eDialog.setzeText3("Papier")
eDialog.setzeDreiTasten(True)
eDialog.zeige()
print(eDialog.nenneErgebnis())
# Zufallsgenerator vorbereiten
zufall = Zufallsgenerator(1,3)
# Sieger ermitteln
if zufall.nenneErgebnis() == 1:
dialog.zeigeNachricht("Ich habe 'Stein' gewählt.")
if eDialog.nenneErgebnis() == 1:
dialog.zeigeNachricht("Unentschieden!")
elif eDialog.nenneErgebnis() == 2:
dialog.zeigeNachricht("Ich habe gewonnen!")
else:
dialog.zeigeNachricht("Sie haben gewonnen!")
elif zufall.nenneErgebnis() == 2:
dialog.zeigeNachricht("Ich habe 'Schere' gewählt.")
if eDialog.nenneErgebnis() == 1:
dialog.zeigeNachricht("Sie haben gewonnen!")
elif eDialog.nenneErgebnis() == 2:
dialog.zeigeNachricht("Unentschieden!")
else:
dialog.zeigeNachricht("Ich habe gewonnen!")
else:
dialog.zeigeNachricht("Ich habe 'Papier' gewählt.")
if eDialog.nenneErgebnis() == 1:
dialog.zeigeNachricht("Ich habe gewonnen!")
elif eDialog.nenneErgebnis() == 2:
dialog.zeigeNachricht("Sie haben gewonnen!")
else:
dialog.zeigeNachricht("Unentschieden!")

View File

@ -0,0 +1,40 @@
# -*- coding: utf-8 -*-
from velamentum.alle import *
#from velamentum.ui.dialoge.Dialog import *
#from velamentum.ui.dialoge.EntscheidungsDialog import *
#from velamentum.ui.dialoge.EingabeDialog import *
#from velamentum.werkzeuge.Zufallsgenerator import *
# Zufallsgenerator vorbereiten
zufall = Zufallsgenerator(1,1000)
# Dialog vorbereiten und Begrüßung anzeigen
dialog = Dialog("Zahlenraten", "Willkommen zum Spiel!")
dialog.zeige()
dialog.zeigeNachricht("Ich habe eine Zahl zwischen 1 und 1000 gewählt. " \
"Raten Sie welche es ist!")
# EingabeDialog vorbereiten
eDialog = PasswortDialog("Zahlenraten", "Bitte geben Sie eine Zahl zwischen 1 " \
"und 1000 ein:", True)
# Zähler für die Versuche initialisieren
versuche = 0
# Entscheidung einfordern
while eDialog.nenneErgebnis() != zufall.nenneErgebnis():
# Anzahl der Versuche um eins erhöhen
versuche += 1
# EingabeDialog anzeigen
eDialog.zeige()
# Eingabe überprüfen
if eDialog.nenneErgebnis() > zufall.nenneErgebnis():
dialog.zeigeNachricht("Ihre Zahl war zu groß!")
elif eDialog.nenneErgebnis() < zufall.nenneErgebnis():
dialog.zeigeNachricht("Ihre Zahl war zu klein!")
dialog.zeigeNachricht("Herzlichen Glückwunsch! Sie haben die Zahl nach {0} " \
"Versuchen erraten.".format(versuche))

View File

@ -0,0 +1,18 @@
from velamentum.ui.dialoge.Dialog import *
from velamentum.ui.dialoge.EingabeDialog import *
from velamentum.sprache.Sprachausgabe import *
dialog = Dialog("Sprachausgabe", "Willkommen zum Sprachtest.")
dialog.zeige()
eDialog = EingabeDialog("Sprachausgabe", "Bitte geben Sie einen Text ein.")
eDialog.zeige()
sprachausgabe = Sprachausgabe(eDialog.nenneErgebnis())
sprachausgabe.sprechen()
while sprachausgabe.sprichtNoch():
pass
dialog.setzeNachricht("Ich habe gesprochen!")
dialog.zeige()

View File

@ -0,0 +1,49 @@
# -*- coding: utf-8 -*-
from velamentum.ui.dialoge.Dialog import *
from velamentum.ui.dialoge.EntscheidungsDialog import *
from velamentum.werkzeuge.Zufallsgenerator import *
# Dialog vorbereiten und Begrüßung anzeigen
dialog = Dialog("Stein, Papier, Schere", "Willkommen zum Spiel!")
dialog.zeige()
# EntscheidungDialog vorbereiten
eDialog = EntscheidungsDialog("Stein, Papier, Schere", "Bitte wählen Sie Ihren Gegenstand.")
eDialog.setzeText1("🌑 Stein")
eDialog.setzeText2("✂️ Schere")
eDialog.setzeText3("📃 Papier")
eDialog.setzeDreiTasten(True)
# Entscheidung einfordern
while eDialog.nenneErgebnis() == 0:
eDialog.zeige()
# Zufallsgenerator vorbereiten
zufall = Zufallsgenerator(1,3)
# Sieger ermitteln
if zufall.nenneErgebnis() == 1:
dialog.zeigeNachricht("Ich habe 'Stein' gewählt.")
if eDialog.nenneErgebnis() == 1:
dialog.zeigeNachricht("Unentschieden!")
elif eDialog.nenneErgebnis() == 2:
dialog.zeigeNachricht("Ich habe gewonnen!")
else:
dialog.zeigeNachricht("Sie haben gewonnen!")
elif zufall.nenneErgebnis() == 2:
dialog.zeigeNachricht("Ich habe 'Schere' gewählt.")
if eDialog.nenneErgebnis() == 1:
dialog.zeigeNachricht("Sie haben gewonnen!")
elif eDialog.nenneErgebnis() == 2:
dialog.zeigeNachricht("Unentschieden!")
else:
dialog.zeigeNachricht("Ich habe gewonnen!")
else:
dialog.zeigeNachricht("Ich habe 'Papier' gewählt.")
if eDialog.nenneErgebnis() == 1:
dialog.zeigeNachricht("Ich habe gewonnen!")
elif eDialog.nenneErgebnis() == 2:
dialog.zeigeNachricht("Sie haben gewonnen!")
else:
dialog.zeigeNachricht("Unentschieden!")

View File

@ -0,0 +1,80 @@
from velamentum.alle import*
punkte=0
d=Dialog("Schlauheits-Test","Teste, wie schlau du bist!")
d.zeige()
ed=EntscheidungsDialog("Laender-Frage","Wie viele Laender gehoeren zu Der EU?")
ed.text1="28"
ed.text2="17"
ed.zweiTasten=True
ed.zeige()
if(ed.ergebnis==1):
d.nachricht="Richtig! Es gehoeren 28 Laender zu der EU."; punkte+=2
elif(ed.ergebnis==2):
d.nachricht="Leider Falsch!"
d.zeige()
ed=EntscheidungsDialog("Personen-Frage","Wieviele Leute lebten 2012 in Deutschland?")
ed.text1="40000000"
ed.text2="80000000"
ed.text3="81000000"
ed.dreiTasten=True
ed.zeige()
if(ed.ergebnis==1):
d.nachricht="Leider Falsch!"
elif(ed.ergebnis==2):
d.nachricht="Fast Richtig!"
elif(ed.ergebnis==3):
d.nachricht="Richtig! 2012 lebten 81000000 Menschen in Deutschland."
d.zeige()
ed=EntscheidungsDialog("Einwohner-Frage","Welche Stadt hat Die meisten Einwohner?")
ed.text1="Peking"
ed.text2="New York"
ed.text3="Mexico-City"
ed.dreiTasten=True
ed.zeige()
if (ed.ergebnis==1):
d.nachricht="Leider Falsch, Peking hat 15800000 Einwohner Und damit 4.300.000 Einwohner weniger, Als Die Stadt Mit Den meisten Einwohnern."
elif (ed.ergebnis==2):
d.nachricht="Leider Falsch, New York hat 8200000 Einwohner Und damit Ca. 11.800.000 Einwohner weniger, Als Die Stadt Mit Den meisten Einwohnern."
elif (ed.ergebnis==3):
d.nachricht="Richtig, Mexico-City hat 20100000 Einwohner Und Ist damit Die Stadt Mit Den meisten Einwohnern Der Welt."; punkte+=3
d.zeige()
ed=EntscheidungsDialog("Film-Frage","Welcher Film hat Das meiste geld eingebracht?")
ed.text1="Avatar"
ed.text2="Skyfall"
ed.text3="Iron Man 3"
ed.dreiTasten=True
ed.zeige()
if (ed.ergebnis==1):
d.nachricht="Richtig, Der Film Avatar hat 2800000000 Dollar eingespielt Und Ist damit Auf Platz 1!"; punkte+=3
elif (ed.ergebnis==2):
d.nachricht="Leider Falsch, Der Film Skyfall hat 1100000000 Dollar eingespielt Und liegt damit auf Platz 9."
elif (ed.ergebnis==3):
d.nachricht="Leider Falsch, Der Film Iron Man 3 hat 1200000000 Dollar eingespielt Und liegt damit Auf Platz 6."
d.zeige()
ed=EntscheidungsDialog("Koerperteil-Frage","Wie viele Knochen hat der menschliche Koerper Im Durchschnitt?")
ed.text1="150"
ed.text2="206"
ed.text4="403"
ed.dreiTasten=True
ed.zeige()
if (ed.ergebnis==1):
d.nachricht="Leider Falsch, er hat mehr, Als Nur 150 Knochen."
elif (ed.ergebnis==2):
d.nachricht="Richtig, allerdings Ist dies Nur Der Durchschnitt. Kleine Kinder Haben beispielsweise Noch mehr Knochen, Als erwachsene Menschen, Weil Die Knochen Mit dem Alter zusammenwachsen!"; punkte+=3
elif (ed.ergebnis==3):
d.nachricht="Ganz Falsch"
d.zeige()
ed=EntscheidungsDialog("Fertig!","Willst du wissen, Wie viele Punkte Du erreicht hast")
ed.text1="Ja"
ed.text2="Nein"
ed.zweiTasten=True
ed.zeige()
if (ed.ergebnis==1):
d.nachricht="Du hast %d Punkte erreicht!" % (punkte)
elif (ed.ergebnis==2):
d.nachricht="Danke fuers spielen!"
if(ed.ergebnis == 1 and punkte>=8):
d.nachricht="Du hast %d Punkte erreicht Und bist damit schlau!" % (punkte)
elif(ed.ergebnis == 1 and punkte<=8):
d.nachricht="Du hast %d Punkte erreicht Und bist damit dumm!" % (punkte)
d.zeige()

View File

@ -0,0 +1,36 @@
# -*- coding: utf-8 -*-
from velamentum.alle import *
# Zufallsgenerator vorbereiten
zufall = Zufallsgenerator(1,1000)
# Dialog vorbereiten und Begrüßung anzeigen
dialog = Dialog("Zahlenraten", "Willkommen zum Spiel!")
dialog.zeige()
dialog.zeigeNachricht("Ich habe eine Zahl zwischen 1 und 1000 gewählt." \
"Raten Sie welche es ist!")
# EingabeDialog vorbereiten
eDialog = EingabeDialog("Zahlenraten", "Bitte geben Sie eine Zahl zwischen 1 " \
"und 1000 ein:", True)
# Zähler für die Versuche initialisieren
versuche = 0
# Entscheidung einfordern
while eDialog.nenneErgebnis() != zufall.nenneErgebnis():
# Anzahl der Versuche um eins erhöhen
versuche += 1
# EingabeDialog anzeigen
eDialog.zeige()
# Eingabe überprüfen
if eDialog.nenneErgebnis() > zufall.nenneErgebnis():
dialog.zeigeNachricht("Ihre Zahl war zu groß!")
elif eDialog.nenneErgebnis() < zufall.nenneErgebnis():
dialog.zeigeNachricht("Ihre Zahl war zu klein!")
dialog.zeigeNachricht("Herzlichen Glückwunsch! Sie haben die Zahl nach {0} " \
"Versuchen erraten.".format(versuche))

0
src/desktop/__init__.py Normal file
View File

22
src/desktop/alle.py Normal file
View File

@ -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

View File

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

View File

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

View File

@ -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

View File

1
src/desktop/desktop.py Normal file
View File

@ -0,0 +1 @@
from tkinter import *

View File

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

View File

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

View File

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

View File

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

View File

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

View File

@ -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

View File

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

View File

View File

Binary file not shown.

View File

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

View File

@ -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

View File

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

View File

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

View File

View File

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

View File

@ -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

View File

View File

View File

@ -0,0 +1,90 @@
# -*- coding: utf-8 -*-
from velamentum.desktop 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 ---
"""
desk = Tk()
#desk.geometry("400x200")
desk.title(self.titel)
txtLable = Label(desk, text=self.nachricht)
okBtn = Button(desk, text='Ok', command=desk.quit)
txtLable.pack()
okBtn.pack()
desk.mainloop()
desk.destroy()
#androide.dialogCreateAlert(self.titel, self.nachricht)
#androide.dialogSetPositiveButtonText('Ok')
#androide.dialogShow()
#androide.dialogGetResponse()

View File

@ -0,0 +1,115 @@
# -*- coding: utf-8 -*-
from velamentum.ui.dialoge.Dialog import Dialog
from velamentum.desktop 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 setzeErgebnis(self,feld):
self.__ergebnis = feld.get()
def zeige(self):
"""Auftrag. Zeigt den EingabeDialog an und speichert die eingegebene
Zeichenkette im Attribut 'ergebnis'.
Parameter:
--- keine ---
"""
desk = Tk()
#desk.geometry("400x200")
desk.title(self.titel)
txtLable = Label(desk, text=self.nachricht)
eingabefeld = Entry(desk, bd=5, width=40)
okBtn = Button(desk, text='Ok', command=lambda:[self.setzeErgebnis(eingabefeld),desk.quit()])
txtLable.pack()
eingabefeld.pack()
okBtn.pack()
desk.mainloop()
desk.destroy()
ergebnis = property(nenneErgebnis, doc="Die Eingabe des Benutzers.")

View File

@ -0,0 +1,164 @@
# -*- coding: utf-8 -*-
from velamentum.ui.dialoge.Dialog import Dialog
from velamentum.desktop 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 setzeErgebnisA(self):
"""Auftrag. Ändert das Ergebnis für entsprechenden Button
"""
self.ergebnis = 1
def setzeErgebnisB(self):
"""Auftrag. Ändert das Ergebnis für entsprechenden Button
"""
self.ergebnis = 2
def setzeErgebnisC(self):
"""Auftrag. Ändert das Ergebnis für entsprechenden Button
"""
self.ergebnis = 3
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 ---
"""
desk = Tk()
#desk.geometry("400x200")
desk.title(self.titel)
txtLable = Label(desk, text=self.nachricht)
btn1 = Button(desk, text=self.text1, command=lambda:[self.setzeErgebnisA(),desk.quit()])
btn2 = Button(desk, text=self.text2, command=lambda:[self.setzeErgebnisB(),desk.quit()])
txtLable.grid(row=0,column=0,columnspan=3,pady=5)
btn1.grid(row=1,column=0,padx=4)
btn2.grid(row=1,column=1,padx=4)
if self.dreiTasten:
btn3 = Button(desk, text=self.text3, command=lambda:[self.setzeErgebnisC(),desk.quit()])
btn3.grid(row=1,column=2,padx=4)
desk.mainloop()
desk.destroy()

View File

@ -0,0 +1,52 @@
# -*- coding: utf-8 -*-
from velamentum.ui.dialoge.EingabeDialog import EingabeDialog
from velamentum.desktop 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 setzeErgebnis(self,feld):
self.__ergebnis = feld.get()
def zeige(self):
"""Auftrag. Zeigt den PasswortDialog an und speichert die eingegebene
Zeichenkette im Attribut 'ergebnis'.
Parameter:
--- keine ---
"""
desk = Tk()
#desk.geometry("400x200")
desk.title(self.titel)
txtLable = Label(desk, text=self.nachricht)
eingabefeld = Entry(desk, bd=5, width=40, show='*')
okBtn = Button(desk, text='Ok', command=lambda:[self.setzeErgebnis(eingabefeld),desk.quit()])
txtLable.pack()
eingabefeld.pack()
okBtn.pack()
desk.mainloop()
desk.destroy()

View File

View File

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

View File

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

View File

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

View File

0
src/iOS/__init__.py Normal file
View File

22
src/iOS/alle.py Normal file
View File

@ -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

71
src/iOS/dateien/Datei.py Normal file
View File

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

View File

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

View File

@ -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

View File

View File

@ -0,0 +1,166 @@
# -*- coding: utf-8 -*-
import time
import random
import velamentum.dateien.Datei
from velamentum.multimedia.Player import Player
import sound
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():
self.player = sound.Player(self.datei.nennePfad())
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 ---
"""
pass
def nenneDauer(self):
"""Anfrage. Gibt die Gesamtdauer der Datei zurück.
Parameter:
--- keine ---
Rückgabe (Zahl): Gesamtdauer der Datei in Millisekunden.
"""
return self.player.duration * 1000
def nennePosition(self):
"""Anfrage. Gibt die aktuelle Position der Wiedergabe zurück.
Parameter:
--- keine ---
Rückgabe (Zahl): Aktuelle Position der Wiedergabe in Millisekunden.
"""
return self.player.current_time * 1000
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
self.player.current_time = pPosition/1000
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.
"""
if pDatei.istVorhanden():
self.player = sound.Player(pDatei.nennePfad())
Player.setzeDatei(self, pDatei)
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 True if self.player.number_of_loops == -1 else 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?
"""
if pWiederholen:
self.player.number_of_loops = -1
else:
self.player.number_of_loops = 0
def wiedergeben(self):
"""Auftrag. Startet die Wiedergabe der Multimediadaten.
Parameter
--- keine ---
"""
self.player.play()
def pausieren(self):
"""Auftrag. Pausiert die Wiedergabe der Multimediadaten. Die Wiedergabe
kann mit 'wiedergeben' fortgesetzt werden.
Parameter
--- keine ---
"""
self.player.pause()
def stoppen(self):
"""Auftrag. Stoppt die Wiedergabe der Multimediadaten. (Wie 'pausieren',
Wiedergabe kann jedoch nicht fortgesetzt werden, sondern beginnt dann
von vorne.
Parameter
--- keine ---
"""
self.player.stop()
# 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.")

View File

@ -0,0 +1,21 @@
# -*- coding: utf-8 -*-
import velamentum.dateien.Datei
from velamentum.multimedia.Recorder import Recorder
import dialogs
class AudioRecorder(Recorder):
"""Die Klasse AudioRecorder dient der Aufnahme von Audiodaten in eine Datei.
Attribute:
--- von 'Recorder' geerbte ---
"""
def __init__(self, pDatei=velamentum.dateien.Datei.Datei("~/aufnahme.m4a")):
"""Konstruktor. Initialisiert den AudioRecorder.
Parameter:
[optional] pDatei (Datei): Datei, in der die Aufnahme gespeichert
werden soll [Standardwert: Datei mit Pfad '~/aufnahme.m4a'].
"""
Recorder.__init__(self, pDatei)
dialogs.alert('Fehler', 'AudioRecorder auf iOS nicht implementiert.')

View File

@ -0,0 +1,52 @@
# -*- coding: utf-8 -*-
import velamentum.dateien.Datei
from velamentum.multimedia.Recorder import Recorder
import photos
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 ---
"""
self.aufnehmenInteraktiv()
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 ---
"""
imgTmp = photos.capture_image()
imgTmp.save(self.datei.nennePfad(), quality=90)

View File

@ -0,0 +1,132 @@
# -*- coding: utf-8 -*-
import time
import velamentum.dateien.Datei
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 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.")

View File

@ -0,0 +1,95 @@
# -*- coding: utf-8 -*-
import time
import velamentum.dateien.Datei
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("~/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

View File

@ -0,0 +1,21 @@
# -*- coding: utf-8 -*-
import velamentum.dateien.Datei
from velamentum.multimedia.Recorder import Recorder
import dialogs
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("~/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)
dialogs.alert('Fehler', 'VideoRecorder auf iOS nicht implementiert.')

View File

View File

Binary file not shown.

View File

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

21
src/iOS/signale/Signal.py Normal file
View File

@ -0,0 +1,21 @@
# -*- coding: utf-8 -*-
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

Some files were not shown because too many files have changed in this diff Show More