Android-Implementierung hinzugefügt

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

source/Android/dateien/Datei.py

@@ -0,0 +1,71 @@
+# -*- coding: utf-8 -*-
+from velamentum.dateien.DateiSystemElement import DateiSystemElement
+
+class Datei(DateiSystemElement):
+    """Die Klasse Datei dient dem Umgang mit Dateien.   
+    
+    Attribute:
+        --- von 'DateiSystemElement' geerbte ---
+        groesse (Zahl): Die Größe der Datei in Byte.
+        inhalt (Zeichenkette): Der Inhalt der Datei.
+    """
+    
+    def __init__(self, pPfad, pSofortEinlesen=False):
+        """Konstruktor. Initialisiert die Datei.
+        
+        Parameter: 
+            pPfad (Zeichenkette): Der Pfad der Datei.
+            [optional] pSofortEinlesen: Gibt an, ob die Datei direkt bei der
+                Initialisierung eingelesen werden soll. [Standardwert: False]
+        """
+        DateiSystemElement.__init__(self, pPfad)
+        if(pSofortEinlesen):
+            self.einlesen()
+    
+    def nenneGroesse(self):
+        """Anfrage. Gibt die Größe der Datei in Byte zurück.
+        
+        Parameter:
+            --- keine ---
+            
+        Rückgabe (Zahl): Die Größe der Datei in Byte.
+        """
+        tSize = 0
+        if self.istVorhanden():
+            try:
+                tSize = os.path.getsize(self.pfad)
+            except:
+                print("Fehler. Auf '%s' kann nicht zugegriffen werden."
+                    % self._pfad)
+        
+    def einlesen(self):
+        """Auftrag. Liest die Datei in das Attribut 'inhalt' ein.
+        
+        Parameter:
+            --- keine ---
+        """
+        if self.istVorhanden():
+            try:
+                tDatei = open(self._pfad, "r")
+                self.inhalt = tDatei.read()
+                tDatei.close()
+            except:
+                print("Fehler. Einlesen von '%s' nicht möglich." % self._pfad)
+        else:
+            self.inhalt = ""
+            
+    def speichern(self):
+        """Auftrag. Schreibt den Wert des Attributs 'inhalt' in die Datei.
+        
+        Parameter:
+            --- keine ---
+        """
+        try:
+            tDatei = open(self._pfad, "w")
+            tDatei.write(self.inhalt)
+            tDatei.close()
+        except:
+            print("Fehler. Speichern von '%s' nicht möglich." % self._pfad)
+            
+    # Attribute (verdeckte Getter und Setter)
+    groesse = property(nenneGroesse, doc="Die Größe der Datei in Byte.")

source/Android/dateien/DateiSystemElement.py

@@ -0,0 +1,104 @@
+# -*- coding: utf-8 -*-
+# Modul zur Erkennung des MIME-Types des Elements. 
+import mimetypes, shutil, os.path
+
+class DateiSystemElement(object):
+    """Die Klasse DateiSystemElement stellt die Basisklasse für Elemente
+    im Dateisystem (z.B. Dateien und Verzeichnisse) dar.   
+    
+    Anmerkungen: 
+        - Eigentlich sollte ein DateiSystemElement seinen eigenen Pfad nicht
+          kennen. Auch das Umbenennen und weitere Verwaltungsfunktionen gehören
+          eher zum übergeordneten Dateisystem. Aus praktikabilitätsgründen
+          wurde allerdings diese Implementierung gewählt.
+        - Für die Erkennung des MIME-Types wird derzeit lediglich die
+          Erweiterung des Elements berücksichtigt.
+    
+    Attribute:
+        name (Zeichenkette): Der Name des Elements im Dateisystem.
+        pfad (Zeichenkette): Der Pfad des Elements im Dateisystem.
+        typ (Zeichenkette): Gibt den MIME-Type des Elements an.
+        verzeichnis (Zeichenkette): Der Pfad des übergeordneten Verzeichnisses
+            der Datei.
+    """
+    
+    def __init__(self, pPfad):
+        """Konstruktor. Initialisiert das DateiSystemElement.
+        
+        Parameter: 
+            pPfad (Zeichenkette): Der Pfad des DateiSystemElements.
+        """
+        # Slash am Ende entfernen
+        if pPfad.endswith('/'):
+            pPfad = pPfad[:-1]
+            
+        self._pfad = pPfad
+        self._erkenneTyp()
+        
+    def _erkenneTyp(self):
+        """Hilfsmethode. Erkennt den Typ des DateiSystemElements und speichert.
+        diesen im Attribut 'typ'.
+        """
+        if os.path.isfile(self._pfad):
+            # Erkennung des MIME-Types. Es wird lediglich die Erweiterung
+            # der Datei geprüft.
+            self.typ = mimetypes.guess_type(self._pfad, False)
+        elif os.path.isdir(self._pfad):
+            self.typ = "inode/directory"
+        elif os.path.islink(self._pfad):
+            self.typ = "inode/symlink"
+        elif os.path.ismount(self._pfad):
+            self.typ = "inode/mount-point"
+        else:
+            self.typ = "application/octet-stream"
+    
+    def istVorhanden(self):
+        """Anfrage. Prüft, ob das Element im Dateisystem bereits existiert.        
+        
+        Parameter:
+            --- keine ---
+        
+        Rückgabe (Wahrheitswert): True falls das Element im Dateisystem bereits
+            existiert, sonst False. 
+        """
+        return os.path.exists(self._pfad)
+    
+    def nennePfad(self):
+        """Anfrage. Gibt den Pfad des Elements im Dateisystem zurück."""
+        return self._pfad
+        
+    def nenneVerzeichnis(self):
+        """Anfrage. Gibt das übergeordnete Verzeichnis des Elements zurück."""
+        return os.path.dirname(self._pfad)
+    
+    def nenneName(self):
+        """Anfrage. Gibt den Namen des Elements im Dateisystem zurück."""
+        return os.path.basename(self._pfad)
+        
+    def nenneTyp(self):
+        """Anfrage. Gibt den Typ des Elements zurück (als MIME-Type)."""
+        return self.typ
+    
+    def verschieben(pPfad):
+        """Auftrag. Hängt das Element im Dateisystem um. 
+        
+        Parameter:
+            pPfad (Zeichenkette): Gibt den neuen Pfad im Dateisystem an.
+        """
+        # Verschieben, falls Element bereits existiert.
+        if os.path.exists(pPfad):
+            try:
+                shutil.move(self._pfad, pPfad)
+                self._pfad = pPfad
+            except:
+                print("Fehler. Verschieben von '%s' nicht möglich." % self._pfad)
+         
+    # Attribute (verdeckte Getter und Setter)
+    pfad = property(nennePfad, verschieben, doc="Der Pfad des " \
+        "DateiSystemElements im Dateisystem.")
+    name = property(nenneName, doc="Der Name des DateiSystemElements im" \
+        "Dateisystem.")
+    verzeichnis = property(nenneVerzeichnis, doc="Der Pfad des übergeordneten" \
+        " Verzeichnisses des DateiSystemElements im Dateisystem.")
+    
+    

source/Android/dateien/Verzeichnis.py

@@ -0,0 +1,29 @@
+# -*- coding: utf-8 -*-
+from velamentum.dateien.DateiSystemElement import DateiSystemElement
+import os
+
+class Verzeichnis(DateiSystemElement):
+    """Die Klasse Verzeichnis dient dem Umgang mit Verzeichnissen.   
+    
+    Attribute:
+        --- von 'DateiSystemElement' geerbte ---
+    """
+    
+    def __init__(self, pPfad):
+        """Konstruktor. Initialisiert das Verzeichnis.
+        
+        Parameter: 
+            pPfad (Zeichenkette): Der Pfad des Verzeichnisses.
+        """
+        DateiSystemElement.__init__(self, pPfad)
+        
+    def nenneKinder(self):
+        """Anfrage. Gibt eine Liste der Kinder des Verzeichnisses zurück."""
+        tListe = []
+        
+        try:
+            tListe = os.listdir(self._pfad)
+        except:
+            print("Fehler. Einlesen von '%s' nicht möglich." % self._pfad)
+        
+        return tListe