Programming Pursday – Parse.com schließt die Tore

Nur ein kurzer Post für heute. Parse.com, der Backend as a Service Anbieter von Facebook wird zum 28.1.2017 den Betrieb vollständig herunterfahren. Das ist an dieser Stelle deswegen interessant, weil ich den Service ursprünglich für mein Projekt Routineer ausgesucht hatte.
Spannend aber auch, weil gleichzeitig das Release des Open Source Parse Servers angekündigt wurde, der an sofort bereit steht. Alles in Node.js.

Alles weitere, auch ein Tool um eine bestehende Umgebung in die eigene Datenbank zu migrieren gibt es hier: http://blog.parse.com/announcements/introducing-parse-server-and-the-database-migration-tool/

012616_1814_TinkeringTu2.png

Tinkering Tuesday – Photobooth im Selbstbau Teil 1 – Planung und Setup

Als ich mich mit der Planung unserer Hochzeit beschäftigt hab, stand relativ frühzeitig fest, dass wir auch eine Photobox, oder Photobooth wie es so schön heißt, bekommen sollten. Die Internetrecherche bringt dann doch schon recht deutliche Preise hervor. Da ich mich sowieso gerne mit Photographie und auch mit Elektronik beschäftige dachte ich natürlich gleich an einen Selbstbau. So schwer kann das doch wohl nicht sein. Meine alte Kamera, eine Panasonic Lumix FZ-20 hatte ich auch schon mal mit einem Arduino ferngesteuert, Hauptarbeit war ja dann quasi schon erledigt… fast.

Also erstmal an die Planung. In meinem Kopf entstand ein Bild:

  • Kamera fernauslösen (4 Bilder sollten entstehen, wie das halt so üblich ist)
  • Bilder auf einen Rechner übertragen und dort verarbeiten
  • Fertige Collagen auf dem Monitor ausgeben und als Photo drucken (einen Photodrucker hatte ich vor Jahren mal zu Weihnachten bekommen, welch Glück)

Typische EVA also (Eingabe – Verarbeitung – Ausgabe).

Plan A – Raspberry Pi und Eye-Fi

Der ursprüngliche Plan sah recht überschaubar aus:

Zentrale Recheneinheit sollte ein Raspberry Pi werden. Der könnte dann statt dem Arduino auch direkt den Schalter verarbeiten und die Kamera auslösen. Da die Lumix kein Tethering von Haus aus kann, bin ich auf die vermeintlich einfache Lösung Eye-Fi gekommen. Diese SD-Karten haben gleich ein WLAN Modul integriert mit dem man die Bilder direkt an einen Rechner schicken kann.

Problem – Eye-Fi und Panasonic Lumix FZ-20

Das erste Problem war eine Eye-Fi Karte zu besorgen, die kompatibel ist. Die Lumix kann nämlich nur die erste Generation an SD-Karten mit maximal 2GB Kapazität verwenden. Das heißt nur die Eye-Fi der ersten Generation, die natürlich nicht mehr verkauft werden funktionieren. Nach einigem Warten und Beobachten bin ich dann über ebay an eine 2GB-Version aus den Vereinigten Staaten gekommen. Top!

Das nächste Problem ergab sich aber dann ziemlich schnell bei der Verwendung der Eye-Fi Karte mit der Kamera. Macht man ein Bild, wird es problemlos übertragen. Macht man dann ein zweites Bild ebenso. Macht man allerdings Bilder in schnellerer Folge, d.h. löst man aus, während noch ein Bild übertragen wird, geht die Kamera in den Standby und lässt sich nur wieder wecken, indem man den Schiebeschalter einmal auf „Aus“ und dann wieder auf „An“ bewegt. Leider ist die Karte nicht die schnellste, sodass das in meinem Setup in 99% der Fälle passiert ist. Okay, andere Lösung muss her.

Eye-Fi unter Linux

Da ich damit dennoch herumgespielt habe, hier der Vollständigkeit halber die Lösung, die ich genutzt habe um auf die Eye-Fi Funktionen unter Linux (zumindest unter Lubuntu auf dem Classmate, s.u., habe ich es erfolgreich genutzt) zuzugreifen: https://github.com/kristofg/rifec/

Plan B – Convertible Classmate PC und Hauppauge TV-Karte

Eine Alternative war, einfach eine Webcam zu nutzen. Langweilig. Trotzdem habe ich mich damit mal ein wenig beschäftigt, da ich noch eine alte USB-Webcam herumliegen hatte. Die hat aber leider nicht am Raspberry funktioniert. Was ich noch rumliegen hatte war aber ein Convertibel Classmate PC. Das ist im Grunde ein Netbook mit dem Zusatzfeature, dass man den Bildschirm drehen kann und es so zu einem Tablet mit Touchscreen umwandeln kann. Für diesen Anwendungsfall zwar völlig unnötig (man hätte die Leute auf das Display tippen lassen können um die Photosequenz auszulösen, aber das war mir in Anbetracht von Alkoholkonsum und der Tüdeligkeit einiger Spezis dann doch zu gefährlich), aber trotzdem cool. Außerdem ist das der einzige kleinere Rechner, den ich besitze.

Der hat auch gleich eine Webcam eingebaut. Also Lubuntu drauf (ist nicht der schnellste und sollte daher möglichst lightweight alles daherkommen), ausprobiert, funktioniert. Aber ist halt ne Webcam…

Live View am Video-Out der Lumix FZ-20

Irgendwie muss ich doch meine Kamera noch zum funktionieren bringen… Moment, die hat doch einen Video-Ausgang. Also ein Video-Out Kabel bestellt. Leider funktioniert das nur im Wiedergabe-Modus der Kamera. Nach einiger Recherche bin ich allerdings auf einen Groups-Beitrag gestoßen, wie man die Lumix LiveView-fähig macht.

Das notwendige Tool, Win Tatsujin, habe ich dann glücklicherweise auf http://www.inweb.ch/foto/lumixfun.html zum Download gefunden. Dort gibt es auch eine detaillierte Anleitung zum Tool (und den möglichen Risiken und Nebenwirkungen).

Letztlich tat es aber die im Beitrag beschriebene Umstellung der Destination auf „USA/Canada“. TV System dann wieder auf PAL einstellen und voila. Läuft. Die Kamera zeigt nun auch während des Aufnahmemodus das aktuelle Bild auf dem Video-Out an.

Hauppauge HVR-900 USB TV-Adapter

Dann muss also nur noch das Bild der Kamera irgendwie in den Rechner. Klar, ich hab doch noch einen USB TV-Adapter mit Video-In rumliegen. Wieder am Raspberry natürlich herausgefunden, dass gerade dieser Adapter nicht wirklich gut daran funktioniert. Nicht gut heißt in meinem Falle, ich bekomme nur ein grünes Bild aus dem Video-In.

Back to the classmate… Am Classmate funktioniert das Ganze dann aber wunderbar. Wer sich fragt, wie ich denn jetzt mit dem Video-In die Bilder auf den Rechner bekomme, der hat natürlich recht, die Originalbilder der Kamera bekomme ich natürlich nicht, aber ich habe einfach die Bildvorschau nach der Aufnahme eingeschaltet (ich glaube auf 2 Sekunden), so habe ich genügend Zeit einen Screenshot vom Video-In zu machen. Die Qualität ist natürlich nicht zu vergleichen mit den Originalbildern, aber die Bilder werden sowieso nur auf einem Viertel eines 17-Zoll Monitors und auf einem Viertel eines 10×15 Photoausdrucks verwendet (wir erinnern uns, 4 Bilder sollen zu einer Collage montiert werden). Und der große Vorteil gegenüber der Webcam ist, dass ich die Bilder trotzdem in sehr guter Qualität im Nachhinein vorliegen habe. Letztendlich haben wir die Bilder nämlich im Nachhinein nochmal neu gesichtet, bearbeitet und unseren Gästen neue Collagen und Abzüge mit der Dankeskarte zukommen lassen.

Arduino

Der Verlust des Raspberry als zentrale Einheit machte natürlich auch wieder einen Arduino zur Steuerung der Kameraauslösung und Anschluss des großen Knopfes (im Übrigen ein ganz normaler Lichtschalter in einem selbstgebauten Kasten, im Nachhinein hätte ich eher einen Aufputzschalter nehmen sollen, dann hätte ich mir den Kasten gespart) notwendig, sodass sich letztendlich

Canon Selphy CP400 Photodrucker

Der Drucker machte dann nur noch einige Probleme, weil ich erstmal den richtigen Linux-Treiber finden musste und CUPS, das Linux Druckersystem verstehen musste. An Details erinnere ich mich aber nicht mehr 😉

Finales Setup

Das finale Setup sieht also folgendermaßen aus:

Zentrale Recheneinheit ist der Convertible Classmate PC, daran ein Arduino, der den Schalterdruck aufnimmt und die Kameraauslösung übernimmt. Das Video-Out geht in den Video-In des Hauppauge HVR 900. Ausgabe erfolgt über einen alten 17-Zoll Medion Monitor und einen Canon Selphy CP400.

Im nächsten Teil geht es dann etwas technischer zu, dann geht es um die Software-Ablaufsteuerung, die ich hauptsächlich über Shell-Skripte gelöst habe. Danach gibt es noch Bilder zum Bau des eigentlichen „Photokastens“.

Kodi-Pi-OpenELEC

Tinkering Tuesday – TV over IP Teil 2 – Fritz!WLAN DVB-C mit dem Raspberry Pi und Kodi

Wie aus dem letzten Tinkering Tuesday Post hervorgeht, habe ich mein TV-Signal mit Hilfe des Fritz!WLAN Repeater DVB-Cs ins Netzwerk gebracht um auch im Wohnzimmer TV-Empfang zu haben ohne Kabel durch die (Miet-)Wohnung ziehen zu müssen. Dafür ist allerdings wie schon erwähnt ein irgendwie geartetes Empfangsgerät am Fernseher notwendig. Das ganze muss frauenfreundlich für nicht technik-affine Menschen geeignet sein, also am besten irgendwas Media Center mäßiges mit möglichst einfacher Steuerung.

Da ich einen Raspberry Pi Model B mein eigen nenne, ist das natürlich die erste Anlaufstelle. Vor allem da ich schonmal damit ein bisschen rumprobiert habe und durch Zufall mal bemerkt habe, dass der Pi auch die Fernbedienungssignale meines Samsung Fernsehers per HDMI-CEC verarbeitet. Frauenkompatibilität Bedienungskomfort: 1A.

Nachfolgend also meine Erfahrungen mit dem Raspberry Pi (1 und 2, dazu später mehr) in Verbindung mit dem TV-Signal, dass der Fritz!WLAN DVB-C ins Heimnetzwerk einspeist. Wie man auch im Folgenden sieht, werde ich keine Anleitungen von anderen Seiten ausführlichst kopieren, wenn das nicht notwendig ist, wer also eine bebilderte Anleitung will, möge bitte dem jeweiligen Link folgen oder wenn das nicht reicht auch gerne fragen 😉

Kodi-Distributionen auf dem Raspberry

Das generelle Vorgehen ist stets das selbe:

Da AVM selbst eine Anleitung für Kodi anbietet und auch den Raspberry Pi als geeignet ansieht hab ich mich für auch dafür entschieden. Die jeweilige Distribution installiert und den SSH Zugriff aktiviert (wird bei der Ersteinrichtung abgefragt). Bei der Ersteinrichtung hatte ich im Übrigen auch schon Probleme bei OpenELEC 6… Beim ersten Start blieb der Bildschirm blau (das Hintergrundbild), beim zweiten Start kam ich schon in den Home-Screen, bekam aber keinen Einrichtungsassistenten angezeigt und konnte auch die OpenELEC Settings nicht manuell starten, erst beim dritten Start wurde der Assistent angezeigt.

Per HDMI verbunden funktionierte meine Samsung TV-Fernbedienung per CEC auf Anhieb. Ich brauchte also nicht einmal eine Maus oder Tastatur für die Einrichtung anschließen. Sehr gut.

Der Anleitung unter http://avm.de/service/fritzwlan/fritzwlan-repeater-dvb-c/wissensdatenbank/publication/show/1608_TV-Programm-mit-Kodi-wiedergeben/ folgend habe ich mir die Senderlisten aus dem Repeater-Menü unter http://fritz.repeater heruntergeladen, sortiert und HD und SD-Sender zusammengeführt. Dann per WinSCP die Datei in den Home-Pfad des Raspberry Pi laden.

Auch bei AVM beschrieben ist die Einrichtung des PVR IPTV Simple Client, der in den Addons aktiviert und konfiguriert werden kann (in der Konfiguration „Lokaler Pfad (einschließlich lokales Netzwerk)“ auswählen und den Pfad zur M3U-Datei angeben).

Den Eintrag „LiveTV“ muss man noch in den Optionen (Live TV -> Allgemein) aktivieren. Dort kann man auch einstellen, dass beim Start von Kodi automatisch der letzte Sender im Vordergrund wiedergegeben werden soll (also sofort TV-Bild – noch ein Pluspunkt bei der Benutzerfreundlichkeit).

OpenELEC 6.0.0 auf Raspberry Pi 1 Model B

Nun also zu den Erfahrungen, die ich so gemacht habe. Wie beginnt man: indem man sich die neueste Version holt und loslegt. Ich hab mir also die aktuellste OpenELEC -Version für den RPi, 6.0.0, heruntergeladen und nach obiger Anleitung installiert.

TV gestartet: Leider ruckelt es…

Optimierungsversuche

Mein erster Optimierungsansatz: war der hier gefundene: http://www.kodinerds.net/index.php/Thread/42268-IPTV-Simple-PVR-Addon-und-FRITZ-WLAN-Repeater-DVB-C/

Also in der advancedsettings.xml folgendes hinzugefügt:

<network>
<buffermode>1</buffermode> <!– Comment: Default is 1 –>
<cachemembuffersize>0</cachemembuffersize> <!– Comment: Default is 20971520 bytes or 20 MB –>
<readbufferfactor>10.0</readbufferfactor> <!– Comment: Default is 1.0 –>
</network>

Leider keine Besserung.

Ein Blick in die Systeminfo bescheinigt auch bei laufendem TV-Bild eine CPU-Auslastung von 100%. Was macht man da? Übertakten, richtig!

Ein moderates overclocking nach dieser Anleitung http://www.htpcbeginner.com/overclock-raspberry-pi-openelec/ hat aber leider auch nichts gebracht.

OpenELEC 6.0.0 auf Raspberry Pi 2 Model B

Also hab ich mir erst einmal einen Rapsberry Pi 2 ausgeliehen. Siehe da, damit funktioniert es ruckelfrei mit OpenELEC 6.0.0. Allerdings zeigt auch hier die Systeminfo eine Auslastung von 70%. Da muss doch noch was gehen. Ich gebe nicht so leicht auf.

OpenELEC 5.0.8 auf Raspberry Pi 1 Model B

Nächster Schritt ist also meinen Pi erster Generation mal mit der alten OpenELEC-Version 5.0.8 laufen zu lassen. Ohne Overclocking schon deutlich flüssiger, allerdings immer noch bei 100% Auslastung und nicht zufriedenstellend.

Also wird auch hier nochmal übertaktet. Nehmen wir mal die nächsthöhere Übertaktungsstufe „Medium“. Das Ergebnis ist, dass die HD-Sender einwandfrei laufen, es sei denn das Menü wird zusätzlich eingeblendet, dann ruckelt es. Die SD-Sender laufen leider immer noch nicht. Komisch, ich hätte es eher andersherum erwartet. Scheint was mit der Skalierung zu tun zu haben?! Keine Ahnung.

XBian (2016.01.02) auf Raspberry Pi 1 Model B

Einen letzten Versuch, da ich gehört habe, dass es generell performanter laufen soll als OpenELEC, starte ich mit XBian. Allerdings lief damit schon das Menü derart hakelig (trotz automatisch eingestellter Übertaktung), dass es keinen Spaß macht. Trotzdem alles wie vorher konfiguriert und, wer hätte es anders erwartet, das TV-Bild startet nicht einmal wirklich.

Fazit – OpenELEC 5.0.8 auf Raspberry Pi 2 Model B

Letztendlich wird also ein Raspberry Pi 2 sein Werk verrichten. Der Test mit OpenELEC 5.0.8 bescheinigt das beste Ergebnis. Alles läuft flüssig bei gerade einmal 10-15% CPU Auslastung.

HDMI-CEC Raspberry Pi – Samsung Anynet+

Wie schon geschrieben funktioniert die Samsung-Fernbedienung auf Anhieb. Allerdings haben sich schon einige Unzulänglichkeiten herausgestellt. Diese werde ich bei Gelegenheit noch einmal näher verfolgen. Beim LiveTV funktionieren die ChannelUp- und ChannelDown-Tasten manchmal ganz gut, manchmal führen sie aber wohl auch zu einem Absturz von Kodi. Es wird zumindest der Kodi-Splashscreen angezeigt, dann wieder in das Menü gesprungen und (zumindest, wenn man wie oben beschrieben eingestellt hat, dass bei Start der letzte Sender angezeigt werden soll) LiveTV mit dem gewechselten Sender angezeigt. Letztlich also das richtige Ergebnis, allerdings mit einer Umschaltzeit von ca. 30-45 Sekunden ziemlich inakzeptabel.

011116_1836_TinkeringTu1.png

Tinkering Tuesday – TV over IP (oder wie bekomme ich ohne Kabel Fernsehen ins Schlafzimmer?)

Mit dem Anreiz „Du bekommst deinen eigenen Fernseher im Schlafzimmer, dann kannst du immer flüchten, wenn ich Fußball oder Dart gucke!“ war auch die Frau schnell von der Idee eines neuen (natürlich größeren und besseren) Fernsehers für unser Wohnzimmer begeistert.

Allerdings leichter gesagt, als getan. Ich hatte schonmal versucht ihr die Gratis-Version von zattoo auf dem Tablet anzudrehen, naja, mit mäßigem Erfolg. Ein echtes Fernseh-Erlebnis muss her. Im Saturn hatte ich zufällig schonmal ein Gerät entdeckt, dass TV ins Netzwerk bringt. Nach einiger Recherche (und Frust, da vieles, was TV over IP behandelt sich auf Sat->IP bezieht) hab ich ihn dann auch gefunden: http://avm.de/produkte/fritzwlan/fritzwlan-repeater-dvb-c/

Installation

Die Einrichtung geht wirklich gut von der Hand: TV-Kabel über den mitgelieferten T-Adapter anschließen, mit dem Netzwerkkabel in den Router (geht auch über WLAN, aber mein Router steht direkt neben dem Fernsehanschluss, dazu auch später noch mehr), in eine Steckdose gesteckt – Hardware-Einrichtung fertig.

Mit dem Handy auf http://fritz.repeater verbunden, Sendersuchlauf gestartet, LAN-Bridge aktiviert (wegen Kabelverbindung) und WLAN deaktiviert – Software-Einrichtung fertig.

Auf dem Handy die Fritz!App TV installiert, gestartet, fernsehen!

Es ist wirklich so einfach! Damit wäre also TV auf dem Handy und dem Tablet vorhanden. Ist nur leider kein Argument für einen neuen Fernseher, daher muss das Signal auf den alten Fernseher:

TV-Anschluss im Schlafzimmer

Da ich auch keinen Netzwerkanschluss im Schlafzimmer habe und ich mich nicht auf den WLAN-Empfang verlassen möchte, wurde ein dLAN/Powerline-Adapter gekauft, da ich mein Arbeitszimmer sowieso schon per Stromkabel angeschlossen habe, ging auch hier die Einrichtung einfach von der Hand.

Jetzt musste nur noch das Signal aus dem Netzwerk wieder an den Fernseher gebracht werden. Was ist da besser geeignet als ein Raspberry Pi? Gesagt getan, im folgenden Bild sieht man die fertige Struktur:

Folgende Geräte sind also mit Fernsehempfang ausgestattet:

  • TV im Wohnzimmer (klassisch via TV-Kabel)
  • TV im Schlafzimmer (via TV over IP über Kodi auf dem Raspberry PI)
  • Smartphone und Tablet (via TV over IP über die Fritz!App TV)
  • Arbeits-PC (via VLC-Player)

Die Einrichtung des Raspberry Pi für den Fernsehempfang mit Kodi ist grundsätzlich auch recht einfach und von AVM selbst auch sehr gut beschrieben. Allerdings bin ich dabei auch auf einige Hürden gestoßen. In der nächsten Woche gibt es daher die Fortsetzung in der es um die Einrichtung des Raspberry Pi geht.

Programming Pursday – greenDAO Tutorial für Beginner

Entgegen meines vorherigen Blogposts habe ich mich vorerst doch gegen ActiveAndroid und für greenDAO entschieden. Einen genauen Grund kann ich nicht nennen, diverse Kommentare über ActiveAndroid und seine Schwächen haben mich wohl dazu bewogen. Ob greenDAO da besser abschneidet kann ich nicht sagen, aber ich versuche es einfach mal.

Die Dokumentation von greenDAO finde ich für Anfänger nicht sonderlich leicht, daher dokumentiere ich meine Schritte hier einmal. Ausgangspunkt sind die offizielle Dokumentation, die github Readme und ein weiteres deutsches Tutorial, welches allerdings ohne online-Abhängigkeiten arbeitet. Das möchte ich aus Vereinfachungsgründen eigentlich nicht.

Nachdem also Android Studio und das Android SDK nach ein paar Wochen Pause erst einmal wieder ca. zwei Stunden für das Update und das nachfolgende Korrigieren des Versionschaos gebraucht haben (geht nur mir das so, dass nach jedem Update irgendwas immer nicht funktioniert?), lege ich mit meinem Routineer-Projekt auf Basis von ListViews und direktem SQLite Zugriff los.

EDIT: Leider funktioniert die Code-Formatierung nicht so zuverlässig… ich versuche das nochmal zu korrigieren…

Generator erstellen

Als ersten Schritt muss man sein Datenmodell definieren. Das sollte man natürlich schon vorher auf einem Blatt Papier oder dem Programm seiner Wahl gemacht haben. Damit greenDAO nun damit umgehen kann, muss eine eigene Applikation dafür gebaut werden, der DaoGenerator. Das machen wir, indem wir unserem Android-Projekt ein neues Modul hinzufügen, in meinem Fall heißt es RoutineerDaoGenerator. Rechtsklick auf den Projektnamen, New, Module auswählen.

Daraufhin ein Modul vom Type „Java Library“ erstellen:

Meine Einstellungen sehen wie folgt aus:

Nachdem wir uns unter dem Link http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22de.greenrobot%22%20AND%20a%3A%22greendao-generator%22 die aktuelle Versionsnummer geholt haben (zum Zeitpunkt des Schreibens 2.1.0) öffnen wir die Datei build.gradle und editieren diese, sodass sie wie folgt aussieht:

apply plugin: ‚application‘
apply plugin: ‚java‘
apply plugin: ‚maven‘

mainClassName = „de.routineer.routineer.RoutineerDaoGenerator“

repositories {
mavenCentral()
}

dependencies {
compile fileTree(dir: ‚libs‘, include: [‚*.jar‘])
compile ‚de.greenrobot:greendao-generator:2.1.0‘
}

Datenmodell definieren

Jetzt können wir in der Klasse RoutineerDaoGenerator das Datenmodell definieren, das für dieses Tutorial aus einer TaskList und einem Task besteht:

Zuerst wird ein Schema definiert. Hierzu wird die Datenbankversion (wir beginnen mit 1) und ein Packagename benötigt. Hier nutze ich das gleiche Package wie das des Android-Projekts. Ich gebe aber noch den Zusatz „model“ an, sodass sich folgendes ergibt:

Schema schema = new Schema(1, "de.routineer.routineer.model");

Meine Entities und deren Beziehungen sehen erstmal wie folgt aus:

//Entität (Tabelle) Tasklist definieren
Entity tasklist = schema.addEntity("Tasklist");
tasklist.addIdProperty();
tasklist.addStringProperty("name");

//Entität (Tabelle) Task definieren
Entity task = schema.addEntity("Task");
task.addIdProperty();
task.addStringProperty("taskName");
task.addIntProperty("taskIntervalNumber");
task.addIntProperty("taskIntervalTypeID");
task.addDateProperty("taskLastDoneDate");
task.addDateProperty("taskDueDate");

//Beziehung zwischen Tasklist und Task definieren
Property tasklistId = task.addLongProperty("tasklistId").getProperty();
task.addToOne(tasklist, tasklistId);
ToMany tasklistToTask = tasklist.addToMany(task, tasklistId);
tasklistToTask.setName("tasks");

Dann noch die Methode aufrufen um die Dateien zu generieren:

new DaoGenerator().generateAll(schema, "app/src/main/java");

Die Tutorials geben hier den Pfad mit „../“ vorangestellt an, das funktioniert aber bei der Methode nicht. Da wir hier ein anderes Modul in unser Projekt eingefügt haben, müssen wir das Ganze ausgehend vom Projektpfad angeben.

Die Ausführung der Applikation RoutineerDaoGenerator sollte folgendes ergeben:


Und folgende Dateien erzeugen:

Somit ist das Datenmodell fertig.

Nutzung des Datenmodells

Zuerst kommt mal wieder die build.gradle an die Reihe. Nachdem wir unter http://search.maven.org/#search|ga|1|g%3A%22de.greenrobot%22%20AND%20a%3A%22greendao%22 die aktuelle Version gecheckt haben, müssen wir folgende Zeile zur build.gradle der Android app hinzufügen:

Für heute sollen es nur mal kurz die Grundlagen der Nutzung sein, da ich erst noch die Nutzung der alten ListView-Logik anpassen muss. Folgende Attribute der Activity hinzufügen:

private SQLiteDatabase db;
private DaoMaster daoMaster;
private DaoSession daoSession;
private TaskDao taskDao;
private Cursor cursor;

in der onCreate-Methode folgendes aufrufen:

//DAO initialisieren (Datenbanknamen vergeben)
DevOpenHelper helper = new DaoMaster.DevOpenHelper(this, "routineer-db", null);
db = helper.getWritableDatabase();
daoMaster = new DaoMaster(db);
daoSession = daoMaster.newSession();
taskDao = daoSession.getTaskDao();
//Task hinzufügen (der erste Parameter ist die ID, gibt man null mit, wird automatisch eine vergeben, die dann mit getId() abgerufen werden kann)
Task task = new Task(null, "Test", 1, 1, null, null, null);
taskDao.insert(task);
Toast.makeText(this, Long.toString(task.getId()), Toast.LENGTH_SHORT)
        .show();

//Cursor mit allen Tasks abrufen:
cursor = db.query(taskDao.getTablename(), taskDao.getAllColumns(), null, null, null, null, null);

Mit dem Cursor kann man dann z.B. eine ListView mit einem einfach SimpleCursorAdapter füttern. Das soll es aber erstmal für heute gewesen sein.