Thomas Kramer

IT-COW | All posts tagged 'JAMon'

Entwicklung einer Android-App mit Anbindung an einen externen CouchDB-Datenbankserver

By Administrator at Juli 08, 2014 18:55
Filed Under: Java, Projekte, Studium

Nachfolgend stelle ich mein neues Studiumsprojekt vor, welches von mir allein entwickelt wurde. Inhaltlich geht es bei diesem Projekt um eine mobile Android-App für Consultants, um sie bei der Arbeit für Software-Firmen und Kundeneinsätzen zu unterstützen.

 

Bei Schulungen und Vor-Ort-Unterstützung von Kunden besteht häufig die Anforderung, Fehler-, Anforderungs- und FAQ-Datenbanken zu firmeneigenen Softwareprodukten mobil zu durchsuchen oder neue Punkte diesbezüglich direkt vor Ort aufnehmen zu können. Diese Android-App ist für Tablet-PCs konzipiert und kann Consultants bei dieser Arbeit unterstützen.

 

Die Android-Plattform stellt eine gute Grundlage für ein solches Projekt dar, weil sie auf den meisten Tablet-PCs ausgeliefert wird und mit Java als Programmiersprache auf ein breites Fundament an Entwicklern und unterstützten Bibliotheken setzen kann. Außerdem wird immer mehr ersichtlich dass mobile Devices den Stellenwert des PCs zunehmend verringern.

 

Diese App setzt Android in einer Version ab 4.2 und einen externen CouchDB-Datenbankserver voraus. CouchDB ist eine der neuen NoSQL-Datenbanken, seit 2005 in Entwicklung und für BigData-Anwendungen entwickelt worden. Mittels CouchDB können Daten über das http(s)-Protokoll und somit mobil über das Internet angefordert und als JSON-Daten zurückgeliefert werden.

 

Die Entwicklung von CouchDB findet als Top-Level-Projekt unter dem Dach der Apache Foundation statt womit deren Weiterentwicklung gesichert ist. Die Unterstützung des http(s)-Protokolls macht CouchDB auch für mobile Anwendungen attraktiv; ein Überblick über die weiteren technischen Eigenschaften findet sich unter anderem auf DB-Engines.com.

 

Für Referenzen von CouchDB verweise ich auf den offiziellen Link sowie den Vergleich auf stackoverflow.com, nach dem eines Kommentators zufolge CouchDB auf ihren Shops mindestens fünf Mal so schnell ist wie MySQL zuvor.

 

Installation der CouchDB-Datenbank

 

Dieses Projekt verwendet die CouchDB-Datenbank als Datenbankserver. Die Datenbank CouchDB ist kostenfrei und kann über folgende URL bezogen werden, diese bitte als Erstes installieren.

 

Standardmäßig verwendet CouchDB die Ports 5984 für unverschlüsselte und 6984 für SSL-Kommunikation. Nach der Installation bitte die entsprechenden Ports auf dem Server freigeben oder zum Testen vorübergehend die Firewall ausschalten.

 

Die Konfiguration von CouchDB findet über das Webinterface und über die local.ini-Datei stattt, die im etc-Verzeichnis von CouchDB liegt. Nach Konfigurationen an dieser Einstellungsdatei sollte der Apache CouchDB-Dienst neu gestartet werden. Standardmäßig ist das Webinterface nur lokal auf dem Server erreichbar.

 

Die Netzwerksicherheit ist per Default ein großes Problem bei CouchDB, denn es gilt die „jeder darf alles“-Vorgabe. Daher sollte als erstes in der local.ini-Datei der Parameter require_valid_user auf true und in der [admins]-Sektion ein Administrator gesetzt werden.

 

Über diese local.ini Datei kann auch der Port geändert werden sowie das Webinterface von außen erreichbar gemacht werden, für letzteres den Parameter bind_address auf 0.0.0.0 setzen. Gegebenenfalls können hier auch SSL-Zertifikate eingebunden werden.

 

Danach wird dann der CouchDB-Dienst neu gestartet sowie das Webinterface von CouchDB aufgerufen. Die URLs von CouchDB folgen grundsätzlich folgendem Muster:

 

http(s)://$Benutzer:$Password@$Server:$Port/$Datenbank

 

Entsprechend der Einstellungen bitte diese URL, um das Postfix /_utils/ ergänzt, im Webbrowser öffnen. Im Webinterface wird in der Sektion _users ein neuer Benutzer erstellt, dazu wird einfach ein neues Dokument mit diesem Schema hinzugefügt:

 

{
    "_id": "org.couchdb.user:dbreader",
    "name": "dbreader",
    "type": "user",
    "roles": [],
    "password": "plaintext_password"
}
 

Die Datenbank CouchDB ersetzt automatisch das Klartext-Passwort durch ein verschlüsseltes Pendant.

 

Dort wird auch über den Button „Create Database“ eine neue Datenbank erstellt. Nach dem Erstellen die Datenbank im Webbrowser öffnen und auf Security klicken. Dort dann unter Members die Datenbank-Benutzer festlegen, die auf die Datenbank zugreifen dürfen, entsprechend folgendem Muster: [„$Benutzer“]

 

Der nächste Schritt besteht darin das Kommandozeilen-Programm CURL auf dem Server zu Supportzwecken zu installieren. Curl ist ein Programm um HTTP-Befehle über die Kommandozeile zu verschicken oder zu empfangen. Für die Android-App ist sie jedoch nicht erforderlich.

 

Anschließend sollten die erforderlichen Views für das Android-Programm importiert werden. Dazu in der angelegten Datenbank ein neues Dokument mit folgendem Inhalt anlegen:

 

{
   "_id": "_design/SE",
   "_rev": "46-a5c928e3b6c5e7bb5d403f372f34da3a",
   "language": "javascript",
   "views": {
       "docs_of_doctype": {
           "map": "function(doc) {
                   if (doc.intern_Dokumententyp) {
                      if (doc.intern_Geloescht == 0)
                      {           
                         emit(doc.intern_Dokumententyp, doc);
                       }   
                   }}"
       },
       "docs_of_products": {
           "map": "function(doc) {
                   if (doc.intern_Dokumententyp) {        
                      if (doc.intern_Geloescht == 0)        
                      {           
                          if (doc.intern_Dokumententyp == 'Produkt')
                          {   
                             emit(doc.Name, doc);
                           }
                       }
                   }}"
       },
       "docs_of_functions": {
           "map": "function(doc) {
                  if (doc.intern_Dokumententyp) {
                     if (doc.intern_Geloescht == 0)        
                     {           
                           if (doc.intern_Dokumententyp == 'Funktion')
                           {   
                              emit(doc.intern_uuidProdukt, doc);
                            }
                     }   
                  }}"
       },
       "docs_of_requirements": {
           "map": "function(doc) {
                  if (doc.intern_Dokumententyp) {
                     if (doc.intern_Geloescht == 0)        
                     {        
                            if (doc.intern_Dokumententyp == 'Anforderung')
                            {   
                               emit(doc.intern_uuidFunktion, doc);
                             } 
                      }
                  }}"
       },
       "docs_of_bugs": {
           "map": "function(doc) {
                  if (doc.intern_Dokumententyp) {
                     if (doc.intern_Geloescht == 0)        
                     {           
                            if (doc.intern_Dokumententyp == 'Fehler')
                            {
                               emit(doc.intern_uuidFunktion, doc);
                             }
                      }   
                  }}"
       },
       "docs_of_faq": {
           "map": "function(doc) {
                  if (doc.intern_Dokumententyp) {        
                     if (doc.intern_Geloescht == 0)        
                     {           
                            if (doc.intern_Dokumententyp == 'Frage')
                            {   
                               emit(doc.intern_uuidFunktion, doc);
                             }
                      }
                  }}"
       },
       "docs_of_userfilter": {
           "map": "function(doc) {
                  if (doc.intern_Geloescht == 0)     
                  {
                     emit([doc.intern_Dokumententyp, doc.Name, doc.Kunde], doc);
                  }}"
       }
   },
   "lists": {
       "count": "function() {
                    var count = 0;
                    while(getRow()) count++;
                    return JSON.stringify({count: count});
                 }"
   }
}

 

Damit ist dann die Installation des Servers beendet, sofern auch eingehende Firewall-Regeln erstellt oder die Firewall vorübergehend deaktiviert wurde.

 

Anwendung der Android-App

 

Wenn die App gestartet wird erscheint folgender Bildschirm:

 

screen1

 

Der Benutzername erscheint nur wenn das Android-Gerät personalisiert und ein Name unter Einstellungen/Nutzer/Ich/Eigentümer eingegeben wurde. Diese Einstellung ist notwendig um sich einzuloggen weil alle gespeicherten Datensätze mit dem eingeloggten Kunden getaggt werden.

 

Die Datenbank-Einstellungen bitte entsprechend der Konfiguration des Servers vornehmen. SSL-Verbindungen wurden bislang nur mit selbst-signierten Zertifikaten getestet, aber funktionieren einwandfrei. Nach dem Eingeben der Verbindungsdaten auf Einloggen klicken, der HTTP-Returncode wird anschließend unter dem Einloggen-Button eingeblendet.

 

Zum Vergleichen verlinke ich die HTTP- mit den CouchDB-Returncodes. Da die App eine entfernte Datenbank benutzt und auch zu Debugging-Zwecken, gibt es ein Anwendungslog welches über die Funktion “Zeige Log” erreichbar ist.

 

Die Einstellungen in diesem Bildschirm werden nur vorübergehend gespeichert, für eine dauerhafte Speicherung muss über den Button oben rechts der Einstellungsdialog aufgerufen werden, dieser sieht wie folgt aus:

 

screen3

 

Zusätzlich können hier auch die Timeout-Einstellungen für die Datenbank vorgenommen werden.

 

Nach dem erfolgreichen Login wird automatisch die Sidebar des Programms links eingeblendet, über diese können alle Programmfunktionen ausgewählt werden:

 

screen2

 

Die Daten werden hierarchisch gespeichert, das Modul Funktionen ist daher erst verfügbar wenn zumindest ein Produkt angelegt wurde. Die Module Anforderungen, Programmfehler und FAQ-Daten sind erst verfügbar nachdem zumindest eine Funktion gespeichert wurde.

 

Jedes Menü von Software-Produkt, Funktionen, Anforderungen, Programmfehler und FAQ-Daten folgt demselben Benutzungsprinzip: im oberen Bereich werden vorhandene Datensätze dieses Bereichs aufgelistet, sofern bereits vorhanden. Wenn auf Neuanlegen oder Ändern geklickt wird werden unten Eingabefelder und weitere Buttons eingeblendet.

 

Bei den Produkten sieht das Menü wie folgendermaßen aus:

 

screen4

 

Oben werden die bereits gespeicherten Datensätze aufgelistet. Links sieht man die blauen RadioButtons, über diesen wählt man den aktuellen Datensatz aus. Dieser kann mit Klick auf Ändern oder Löschen bearbeitet werden.

 

Wichtig ist dass sich diese Auswahl auch auf die anderen Programmbereiche auswirkt, bei Funktionen werden die Datensätze für ein bestimmtes Produkt aufgelistet und in den Modulen Anforderungen, Programmfehler und FAQ-Daten wird nach der selektierten Funktion gefiltert.

 

Nach dem Klick auf den Ändern-Button sieht der Software-Produkte-Bildschirm folgendermaßen aus:

 

screen5

 

Mit dem Klick auf Speichern kann der geänderte Datensatz übernommen oder mit Abbrechen der Änderungsvorgang abgebrochen werden.

 

Zum Vergleichen nachfolgend der Funktionen-Bildschirm:

 

screen6

 

Es stehen relativ wenige Eingabefelder zur Verfügung, aber es ist überhaupt kein Problem die Eingabefelder auf einen separaten Bildschirm auszulagern und um weitere Eingabefelder zu erweitern, da es sich bei CouchDB um eine schemafreie Datenbank handelt.

 

Nachfolgend ein Bild des Nutzungsstatistik-Bildschirms:

 

screen7

 

Über diesen Menüpunkt kann die Anzahl der gespeicherten Datensätze pro Datensatz-Typ eingesehen werden.

 

Desweiteren gibt es natürlich auch eine Durchsuchen-Funktion:

 

screen8

 

In dem Modul kann nach Datensätzen für einen bestimmten Typ, einen bestimmten Namen und für einen bestimmten Kunden (optional) gesucht werden. Die gefundenen Datensätze werden dann darunter aufgelistet.

 

Als letzten Menüpunkt gibt es die Logging-Funktion, diese wurde hauptsächlich eingeführt weil die App eben nicht eine lokale, sondern eine entfernte Datenbank ansteuert. Außerdem ist sie natürlich auch für das Debugging nützlich gewesen.

 

screen9

 

Über das Auswahlmenü oben rechts kann nach dem Log-Level (Fehler=error voreingestellt) gefiltert werden, Neuester Eintrag scrollt nach unten.

 

An dieser Stelle können auch die Performance-Messungen der eingebetteten Java-Bibliothek JAMon eingesehen werden.

 

Das Aufnehmen von Screenshots von angeschlossenen Android-Tablets ist übrigens sehr einfach und geschieht über folgende Befehle:

 

adb shell screencap -p /sdcard/screen.png
adb pull /sdcard/screen.png
adb shell rm /sdcard/screen.png
 
Quelle: Link

 

Technische Merkmale des Programms

 

  • - Model-View-Controller-Architekturmuster

  • - JAMOn-Bibliothek eingebunden um Performance-Messungen über Java durchzuführen

  • - Nutzung zweier verschiedener Online-Zugriffsarten, sowohl über den DefaultHttpClient (zum Lesen) als auch die http(s)URLConnection-Klassen (zum Schreiben).

  • - Unterstützung von selbstsignierten SSL-Zertifikaten.

  • - Nutzung von Multithreading, AsyncTasks von Android

  • - geteilte Nutzung von Connection-Objekten über Threads hinweg

  • - zweisprachig über die Ressourcen-Dateien

  • - Logging-Support, direkt anzeigbar am Android-Device um Netzwerk-Probleme besser aufzuspüren

  • - Datenbank-IDs werden vom Server angefordert, 100 UUIDs auf einmal aus Performance-Gründen

  • - Caching-Mechanismus von Datenobjekten über HashMaps

  • - Nutzung von Fragmenten um den aktuellen View umzuschalten

  • - seitliche Sidebar um zwischen den Programmfunktionen umzuschalten

 

Download

 

Zur Installation folgende APK-Datei einfach auf das Android-Tablet kopieren und dort starten.

 

SE-Projekt-App V1.0

 

Monats-Liste