Sefai Sari, Alexander Holland Android, Scala und Akka

Commentaren

Transcriptie

Sefai Sari, Alexander Holland Android, Scala und Akka
HAW New Storytelling
Sefai Sari, Alexander Holland
Android, Scala und Akka
Fakultät Technik und Informatik
Department Informatik
Faculty of Engineering and Computer Science
Department of Computer Science
Sefai Sari, Alexander Holland
Android, Scala und Akka
New Storytelling eingereicht im Rahmen Studium
im Studiengang Angewandte Informatik
am Department Informatik
der Fakultät Technik und Informatik
der Hochschule für Angewandte Wissenschaften Hamburg
Betreuender Prüfer : Sascha Kluth
Zweitgutachter : Tobias Eichler
Abgegeben am 12.01.2k15
Sefai Sari, Alexander Holland
Thema der Ausarbeitung
OSController mit Android, Scala und Akka
Stichworte
Android, Scala, Akka, OSController, New Storytelling
Kurzzusammenfassung
Wie man akka auf Android zum laufen bekommt.
Sefai Sari, Alexander Holland
Title of the paper
OSController with Android, Scala und Akka
Keywords
Android, Scala, Akka, OSController, New Storytelling
Abstract
How to use akka on Android.
Inhaltsverzeichnis
1. Die Idee............................................................................................................................................ 6
2. Anwendungs- bespiele......................................................................................................................6
2.1 Steuerung eines Öffentlichen Computers...................................................................................6
2.2 Vordefinierte Steuerungs- Oberfläche am Beispiel eines Computer-Spiels............................... 7
2.3 Steuerung der Wohnung............................................................................................................. 7
3. Das Ziel............................................................................................................................................ 7
4. Recherche Bericht............................................................................................................................ 8
5. Agenten, Server und Android Apps..................................................................................................9
5.1 Agent – Authentification.............................................................................................................9
5.2 Agent – Androidprofil.................................................................................................................9
5.3 Agent – Sensor............................................................................................................................9
5.4 Agent – Leistungsinfoandroid.................................................................................................... 9
5.5 Agent – GoogleMaps..................................................................................................................9
5.6 Agent – OSCommand.................................................................................................................9
5.7 Der Server...................................................................................................................................9
5.8 PAASA(PreAlpha Android+Scala+Akka)..................................................................................9
5.9 MASA(Minimale Android+Scala+Akka).................................................................................. 9
6. Mockups......................................................................................................................................... 10
6.1 Server-Mockup......................................................................................................................... 10
6.2 Android-Mockup...................................................................................................................... 10
6.3 Umsetzung................................................................................................................................ 11
6.3.1 Server.................................................................................................................................11
6.3.2 Server-Leistungsinformationen......................................................................................... 11
6.3.3 Server-Sensorinformationen..............................................................................................12
6.3.4 Android-Login................................................................................................................... 12
6.3.5 Android-Profil....................................................................................................................13
7. Kommunikationsdiagramme.......................................................................................................... 13
7.1 Subscribe und Request/Answer, Multiuser...................................................................................13
7.2 Verbindungsaufbau und Profil Austausch.................................................................................14
8. Anhang, Dokumentationen.............................................................................................................14
8.1 Erfolglose Methode 1(ScalaAndroidProguardProjekt-Eclipse(ohne Akka).pdf).....................14
8.2 Multidex.pdf............................................................................................................................. 14
8.3 Erfolglose Methode 2(ScalaAndroidSBTProjekt-Eclipse(ohne Akka).pdf)............................ 14
8.4 Gradle.pdf.................................................................................................................................14
8.5 Typesafe Config.pdf................................................................................................................. 14
8.6 Erfolgreiche Methode(DokuScalaAndroidAkkaGradleProjekt-IntelliJ.pdf)............................14
8.7 SBT Executable Jar.pdf............................................................................................................ 14
8.8 Projekt files(Ordner).................................................................................................................14
1. Die Idee
Das Smartphone als Steuerungsgerät für "alles" zu nutzen.
Uns ist aufgefallen das jeder ein Smartphone in der Tasche hat, dieses hat ein großes Potenzial das
nicht vollständig ausgenutzt wird. Oft ist man dadurch eingeschränkt, das für jede Funktionalität
eine eigene Applikation benötigt wird, diese muss man oft sehr lange suchen, da es sehr viele
verschiedene Apps gibt und eine Optimale oft nicht vorhanden ist.
Unsere App liefert eine Schnittstelle zu beliebig vielen Funktionalitäten die vom User nicht explizit
installiert werden, sondern vom Server geliefert werden sobald der User sich in einem Bereich
befindet in dem die Funktionalität benötigt oder zur Verfügung steht.
Der User soll die Möglichkeiten haben seine eigenen Funktionalitäten zu definieren, diese müssen
dann eventuell auf dem Server nochmals angepasst werden.
Wir wollen sehr einfache und dynamische Daten zwischen Smartphone und PC austauschen.
Der Server soll Zugriff auf Informationen des Smartphones haben: Sensor Informationen, GPS,
Kamera, Display usw., falls der User dies zulässt.
2. Anwendungs- bespiele
2.1 Steuerung eines Öffentlichen Computers
Eine Person trifft in einem Öffentlichen Bereich auf einen Bildschirm der Unsere Software
installiert hat.
Der Person wird in sehr wenig schritten und sehr verständlich erklärt wir sie die App
installieren und nutzen kann, falls noch nicht geschehen.
Wenn die Person die App installiert hat gibt es Vier Möglichkeiten sich zu verbinden.
1. Die angezeigte IP-Adresse eingegeben.
2. Die Person macht einfach ein Foto des angezeigten QR-Codes
der die IP-Adresse enthält.
3. Der Bildschirm zeigt einen DNS-Namen an, dieser kann bei der App einfach
eingegeben werden.
4. Die Person hat sich mit dem Bildschirm schon mal verbunden und die Adresse
gespeichert und wählt diese aus einer Liste aus.
Jetzt ist die Person verbunden es gibt folgende Szenarien:
1. Der Server sendet ein Profil an die App mit allen Funktionalitäten.
2. Die Person Sendet sein eigenes Profil an den Server, da ihm sein eigenes Layout
lieber ist.
Mit dem Profil könnte die Person jetzt ein Spiel steuern oder den Browser steuern, Videos
abspielen usw. , je nachdem was der Bildschirm für Funktionalitäten liefert.
2.2 Vordefinierte Steuerungs- Oberfläche am Beispiel eines Computer-Spiels
Der User erstellt auf seinem Smartphone ein Profil mit seiner bevorzugten Spielsteuerung und
kommt zu einem Freund bei dem seine zugewiesene Steuerung nicht zum Spiel passt, da diese
bereits von einem anderen Spieler genutzt werden z.B [W], [A], [S], [D].
Damit der User sein Profil nicht anpassen muss, wird ein schnelles Mapping auf der Server Seite
durchgeführt wodurch das Profil des Users nicht verändert wird.
[W] → [U]
[A] → [H]
[S] → [J]
[D] → [K]
Wenn der User nachhause kommt kann er sein Profil weiterhin nutzen wie gewohnt.
Der User kann auf dem Smartphone Buttons beliebig erstellen und ihre Positionen, Breite und Höhe
anpassen.
Ein Button führt eine vom User definieren Aktion aus z.B. [A] keyPressed/keyReleased.
2.3 Steuerung der Wohnung
Ein weiterer Anwendungsbereich wäre z.B. das Livingplace.
Je nachdem wo sich die Person in der Wohnung befindet könnte ein entsprechendes Profil angezeigt
werden.
Dies könnte man beliebig skalieren, falls man in einer anderen Wohnung ist und als
Vertrauensperson angesehen wird, könnte man diese Wohnung steuern ohne das man selbst
irgendwelche Einstellungen durchführen muss, da der Server das Profil einfach an den neuen User
sendet.
3. Das Ziel
Uns wurde ziemlich früh klar, das mit der verfügbaren Zeit nicht die komplette Idee umsetzen
können.
Das eine Problem war das es viel länger gedauert hat Akka in Android zum Laufen zu bekommen
als geplant.
Des-weiteren ist das festlegen und positionieren der Buttons sehr aufwendig und das dynamische
verhalten der Profile nicht einfach zu implementieren.
Wir haben uns entschieden die Basis Agenten zu implementieren um zu einem späteren Zeitpunkt
die aufwendige Implementierung durch zu führen.
Wir haben uns als Ziel gesetzt ein NES Spiel "Super Mario Bros" mittels eines Smartphones zu
steuern, wobei die Steuerung(das Profil) durch den Server festgelegt wird.
Sobald sich das Smartphone mit dem Server Verbindet sendet der Server die
Steuerungsinformationen an das Smartphone.
4. Recherche Bericht
Als erstes haben wir versucht Android mit Scala zum Laufen zu bringen, dabei sind wir anfangs auf
Beispiel Projekte gestoßen.
Die Beispiel Projekte hatten entweder Fehler beim Einbinden in eclipse oder wir haben es nicht
hinbekommen die benötigte sbt Plug-Ins einzubinden.
Dies könnte sehr wahrscheinlich daran gelegen haben, dass wir zu diesem Zeitpunkt nur sehr
geringes wissen zu scala/sbt hatten.
Zeitaufwand: 4 Tage (~24h)
Nach weiterer Recherche sind wir auf ein Tutorial bei der Scala-IDE Seite gestoßen.
Bei diesem Tutorial gab es sehr oft Fehlermeldungen aus dem nichts... wir haben uns längere Zeit
damit herumgeschlagen, dies führte aber zu nichts.
Wir haben das ganze ausführlich dokumentiert. [Erfolglose Methode 1][Multidex]
Zeitaufwand: 3 Tage (~20h)
Nach weiterer Recherche sind wir auf der Android Developer Seite gelandet, diese hat beschrieben
wie man multidex mittels Gradle nutzt, diese hatten wir vorher auch schon einmal gefunden, haben
sie aber erst mal ignoriert, da wir das ganz mit SBT umsetzen wollten und keine Ahnung von
Gradle hatten.
Da die Android Developer keine Beschreibung zur Nutzung von Scala in Gradle hatten, haben wir
nach einem Beispiel Projekt gesucht bei dem scala in Gradle genutzt wird.
Wir haben auf GitHub ein Gradle Plug-In gefunden das scala unterstützt.[Erfolgreiche Methode]
Zeitaufwand: 3 Tage (~30h)
Da einige Zeit vergangen ist und wir einige Erfahrungen mit sbt gesammelt hatten, haben wir
nochmals die sbt Variante ausprobiert.
Das Plug-In sah sehr viel versprechend aus obwohl kein multidex Support zu sehen war könnte es
sein, das diese Funktionalität hinzugefügt wird oder einer der workarounds funktioniert, siehe
[Erfolglose Methode 2][Multidex].
Zeitaufwand: 3 Tage (~10h)
Es gab mehrere Probleme bei der Erzeugung eines Anroid+Scala+Akka Projekts.
Einige kleine Beispiele:
1. Für das Serializieren/Deserializieren musste die json4s durch jsonPlay ausgetauscht
werden.
2. Da es bei den maven dependencys in Gradle zu Fehlern kam, wie z.B. duplicate Class,
haben wir alle benötigten jar files manuell heruntergeladen und eingebunden. Dieses
Problem haben wir beseitigt und Dokumentiert[Gradle]
3. Merge der Default-konfigurationsdateien, da diese in der .apk nicht gefunden werden
konnten.
Weitere Probleme die wir hatten werden in der Doku sichtbar.
[Erfolgreiche Methode 3 Projekt erstellen]
Zeitaufwand: viel...
Parallel zur Erzeugung des Android Projekt(4 Wochen) wurde das Mockup zum Server geplant, die
Agent API's definiert und die Dokumentation zu den Erfolglosen Methoden(1/2) geschrieben.
Nachdem wir das Android-Akka Projekt zum Laufen gebracht haben, wurde die Implementierung
des Server angefangen.
Zeitaufwand: viel...
Außerdem haben wir uns Gedanken zur multiuser Kommunikation gemacht.
Hier eine Liste aller Implementierungen während des Projekts.
5. Agenten, Server und Android Apps
5.1 Agent – Authentification
Handelt mit dem Server eine eindeutige ID aus, diese wird von allen Agenten zur Kommunikation
genutzt(multiuser).
http://devsupportgit.informatik.haw-hamburg.de/po1415/authentification-agent
http://devsupportgit.informatik.haw-hamburg.de/po1415/authentification-api
5.2 Agent – Androidprofil
Android-Gerät und Server einigen sich auf ein Profil.
Ein Profil hat Aktionen die der Android User auf dem Server nutzen kann.
http://devsupport.informatik.haw-hamburg.de/projekte/po1415/?p=544
http://devsupportgit.informatik.haw-hamburg.de/po1415/androidprofil-agent
http://devsupportgit.informatik.haw-hamburg.de/po1415/androidprofil-api
5.3 Agent – Sensor
Liefert die Informationen zu den Sensoren des Android-Geräts.
http://devsupportgit.informatik.haw-hamburg.de/po1415/sensor-agent
http://devsupportgit.informatik.haw-hamburg.de/po1415/sensor-api
5.4 Agent – Leistungsinfoandroid
Liefert Leistungsinformationen des Android-Geräts Akku,CPU,RAM,..
http://devsupportgit.informatik.haw-hamburg.de/po1415/leistungsinfoandroid-agent
http://devsupportgit.informatik.haw-hamburg.de/po1415/leistungsinfo-api
5.5 Agent – GoogleMaps
Zur Ortung des Android-Geräts über GPS.
http://devsupportgit.informatik.haw-hamburg.de/po1415/google-berechneentfernung-agent
http://devsupportgit.informatik.haw-hamburg.de/po1415/google-berechneentfernung-api
5.6 Agent – OSCommand
Der Agent führt die übergeben Befehle in der CMD/Shell aus.
http://devsupportgit.informatik.haw-hamburg.de/po1415/oscommand-agent
http://devsupportgit.informatik.haw-hamburg.de/po1415/oscommand-api
5.7 Der Server
http://devsupportgit.informatik.haw-hamburg.de/po1415/oscontroller-server
5.8 PAASA(PreAlpha Android+Scala+Akka)
Die aktuelle App mit den eingebauten Agenten.
http://devsupportgit.informatik.haw-hamburg.de/po1415/paasa
5.9 MASA(Minimale Android+Scala+Akka)
Bug freie Minimale Example App mit Akka.
http://devsupportgit.informatik.haw-hamburg.de/po1415/masa
6. Mockups
6.1 Server-Mockup
6.2 Android-Mockup
6.3 Umsetzung
6.3.1 Server
6.3.2 Server-Leistungsinformationen
6.3.3 Server-Sensorinformationen
6.3.4 Android-Login
Wie in 2.1 beschrieben, die Server Auswahl.
6.3.5 Android-Profil
Zwei Button Senden B, A Signale an den Server
7. Kommunikationsdiagramme
7.1 Subscribe und Request/Answer, Multiuser
7.2 Verbindungsaufbau und Profil Austausch
8. Anhang, Dokumentationen
8.1 Erfolglose Methode 1(ScalaAndroidProguardProjekt-Eclipse(ohne Akka).pdf)
8.2 Multidex.pdf
8.3 Erfolglose Methode 2(ScalaAndroidSBTProjekt-Eclipse(ohne Akka).pdf)
8.4 Gradle.pdf
8.5 Typesafe Config.pdf
8.6 Erfolgreiche Methode(DokuScalaAndroidAkkaGradleProjekt-IntelliJ.pdf)
8.7 SBT Executable Jar.pdf
8.8 Projekt files