\chapter{Android-App}
	\section{Technologiebeschreibung}
		\subsection{Android SDK}
		Die Android-Entwicklung wurde, aufgrund der Ausgereiftheit und den Emulatoren, mit Android-Studio realisiert. Android-Studio verwaltet auch das SDK und unterstützt beim aktuell halten der Bibliotheken. \\
		Das minimale API-Level, welches das Endgerät haben darf wurde auf 23 "Marshmallow" festgelegt. Dadurch werden ca. 85\% der Geräte unterstützt und ist aktuell genug um gewisse Features, wie das neue Berechtigungssystem, zu unterstützen. Die Zielversion ist das aktuelle Android 10 mit API-Level 29. In dieser Version wurden erneut Berechtigungen geändert, wodurch im Code einige Anpassungen gemacht werden mussten (siehe: \ref{sec:Probleme})
		
		\subsection{Kotlin}
		Die Entscheidung fiel auf Kotlin als Programmiersprache, da die Sprache von Google für die Entwicklung von Android-Apps bevorzugt wird. Außerdem bietet dies die Gelegenheit eine neue Programmiersprache zu erlernen. Dadurch jedoch musste viel Zeit investiert werden um zum Einen die Sprache und zum Anderen die Entwicklungsumgebung, sowie der Aufbau einer Android-App zu lernen. Dafür wurden zwei von insgesamt fünf Sprints eingeplant, weswegen die App nur die Grundfunktionen besitzt.\\
		Die Kotlin-Version bei Fertigstellung ist die aktuellste Version (1.3.72).
		
		\subsection{Retrofit}
		Für die Kommunikation mit dem Backend wurde die Bibliothek Retrofit in der Version 2.8.1 verwendet.	Retrofit ist ein HTTP-Client für Android mit dem man REST-Endpunkte simpel ansprechen kann. Zusammen mit der Gson-Bibliothek lassen sich JSON-Nachrichten senden und empfangen. \\
		Das angefragte API wird mit Klassen und Methoden in der Anwendung modelliert. Dadurch ist es möglich nur die Felder abzufragen, welche auch benötigt werden. Genaueres in Kapitel \ref{subsec:AnzeigeDaten}.
		
		\subsection{Material Design}
		Material ist eine Bibliothek, die Komponenten und Richtlinien bereitstellt. Nach einmaligem Einbinden der Bibliothek können die Komponenten verwendet werden, indem der Komponente der Style zugewiesen wird.
		
	\section{Farbschema und Designsprache}
	In einem gemeinsamen Meeting mit dem Web-Frontend einigten wir uns auf Farbcodes, die auf beiden Oberflächen verwendet werden. So haben wir uns auf ein dunkles Schema festgelegt, mit den Farben aus dem Logo für Schrift und Akzente. Als Schriftart wird Montserrat verwendet. \\
	%Einfügen Ausschnit MainActivity 
	
	
	\section{Umsetzung}
		\subsection{Design der Activities}
		Insgesamt besitzt die App die vier Activities: Login, MainActivity, Register und Settings. Wobei die Register- und die Settings-Activity aus zeitlichen Gründen ohne Funktion sind. Sie haben auch noch die alten unschönen Eingabefelder, sind aber für die Funktion der gesamten Anwendung nicht sonderlich relevant, weshalb entschieden wurde diese zu vernachlässigen und den Fokus auf die Funktionalität zulegen. \\
		Jeder Bildschirm hat eine Top-Bar auf der, je nachdem auf welchem Bildschirm man sich befindet, unterschiedliche Inhalte angezeigt werden.Beim Einloggen und Account erstellen wird außer dem Logo und dem Namen der App nichts angezeigt. In den Einstellungen erscheint anstatt dem Logo ein Zurück-Button und auf dem Hauptbildschirm gibt es ein Menü zum Ausloggen und zu den Einstellungen zu gelangen. 
		\begin{figure}[H]
			\centering
			\begin{minipage}[b]{.4\linewidth} 
				\includegraphics[width=\linewidth]{img/android/login}
				\caption{Login Activity}
			\end{minipage}
			\hspace{.1\linewidth}
			\begin{minipage}[b]{.4\linewidth}
				\includegraphics[width=\linewidth]{img/android/register}
				\caption{Register Activity}
			\end{minipage}
		\end{figure}
		Links die Eingabefelder mit Material Design und rechts die alten selber erstellten.
		\begin{figure}[H]
			\centering
			\begin{minipage}[b]{.4\linewidth}
				\includegraphics[width=\linewidth]{img/android/main}
				\caption{Main Activity}
			\end{minipage}
			\hspace{.1\linewidth}
			\begin{minipage}[b]{.4\linewidth} 
				\includegraphics[width=\linewidth]{img/android/settings}
				\caption{Settings Activity}
			\end{minipage}
		\end{figure}
		Wie zu erkennen ist lag der Fokus der Implementierung deutlich auf der Main Activtiy, da sie auch das Wichtigste der App beinhaltet. Prominent ist dabei der 'START'-Knopf an der Unterseite, mit dem die Aufzeichnung gestartet werden kann (genaueres im Kapitel \ref{subsec:main}). 
		
		\subsection{Authentifizierung}
		Zur Authentifizierung benutzen wir JWT, welches bei jeder Anfrage ans Backend mit geschickt werden muss. Das Token erhält man beim Einloggen mit den richtigen Daten und muss persistiert werden, bis sich der Benutzer ausloggt. Dazu speichere ich das Token im privaten Speicher der App. In allen weiteren Activities kann dann auf den Speicher zugegriffen werden und das Token beim Erstellen des \verb|AuthenticationInterceptor|s mitgegeben werden. Beim Ausloggen wird einfach die Datei mit dem Token aus dem Speicher gelöscht. \\
		Der \verb|AuthenticationInterceptor| ist Kind von der \verb|Interceptor|-Klasse aus der \verb|okhttp3|-Bibliothek, welche in Retrofit eingebunden ist. Mithilfe des Interceptors können REST-Abfragen Header-Daten mitgegeben werden. In unserem Fall ist das das \verb|Authorization|-Feld mit dem Token.
		\begin{lstlisting}[language=Kotlin]
		class AuthenticationInterceptor(pToken: String) : Interceptor {
			private val token = pToken
			override fun intercept(chain: Interceptor.Chain): Response {
				val original = chain.request()
				val builder = original.newBuilder()
				.header("Authorization", token)
				val request = builder.build()
				return chain.proceed(request)
			}
		}
		\end{lstlisting}
		Der Interceptor wird dem HTTP-Client hinzugefügt, welcher später bei der Erzeugung des Retrofit-Builders notwendig ist.
		\begin{lstlisting}[language=Kotlin]
		val httpClient = OkHttpClient.Builder()
		val interceptor = AuthenticationInterceptor(token)
		httpClient.addInterceptor(interceptor)
		\end{lstlisting}
		
		\subsection{Anzeige der Daten in der Main Activity}\label{subsec:AnzeigeDaten}
		Die Daten werden per REST-Aufruf mithilfe vom Retrofit-Framework vom Backend geholt. Um Anfragen zusenden benötigt man einen Retrofit-Builder. Diesem wird die anzufragende URL, ein JSON-Konverter und ein HTTP-Client mitgegeben. Aus diesem Builder und einer Service-Klasse, in der die Methoden definiert sind, wird ein Objekt erzeugt mit dem die Methoden aufrufbar sind. 
		\begin{lstlisting}[language=Kotlin]
		val builder = Retrofit.Builder()
			.baseUrl("http://plesk.icaotix.de:5000")
			.addConverterFactory(GsonConverterFactory.create())
			.client(httpClient.build())
		val retrofit = builder.build()
		service = retrofit.create(GeofenceService::class.java)
		\end{lstlisting}
		Die Klasse \verb|GeofenceService| dient, wie oben beschrieben, zur definition der Endpunkte in From von Methodenaufrufen. Dort wird definiert, ob es ein \verb|POST| oder \verb|GET| Entpunkt ist, wie der Pfad lautet und was für Parameter mitgegeben werden. 
		\begin{lstlisting}[language=Kotlin]
		@POST("/login")
		fun login(@Body login_data: ValuesUserLogin): Call<Void>
		
		@GET("whoami")
		fun getUser(): Call<ValuesUser>
		
		@GET("accounts/search/findByUsername")
		fun getAccounts(@Query("username") username : String): Call<EmbeddedAccounts>
		\end{lstlisting}
		Der Rückgabewert der Methoden ist immer vom Typ \verb|Call|. Wenn aus dem Body Werte gelesen werden sollen, muss eine Art Skelett-Klasse angelegt werden mit den relevanten Feldern. Die Klasse \verb|ValuesUser| stellt Werte der Antwort bereit, wie z. B. den Vornamen.
		\begin{lstlisting}[language=Kotlin]
		class ValuesUser(firstname: String) {
			@SerializedName("firstname")
			var firstname = firstname
		}
		\end{lstlisting}
		Der Aufruf der Methode erfolgt Asynchron. Deshalb darf sich nicht auf das Ergebnis des Aufrufs direkt danach verlassen werden, sonst bekommt man eine Null-Pointer-Excetion. Die Methode \verb|enqueue| besitzt ein Callback-Objekt als Parameter, welches \verb|onResponse| und \verb|onFailure| überschreibt. Dort wird entsprechend definiert was in den jeweiligen Fällen ausgeführt werden soll.
		\begin{lstlisting}[language=Kotlin]
		val call = service.getUser()
		call.enqueue(object : Callback<ValuesUser> {
			override fun onResponse(call: Call<ValuesUser>, response: Response<ValuesUser>) {
				if (response.isSuccessful) {
					val firstname = response.body()?.firstname
					lbl_username.text = "Hello " + firstname
				} else {
					println("Response not successful: ${response.code()}")
				}
			}
			override fun onFailure(call: Call<ValuesUser>, t: Throwable) {
				println("Response 'whoami' failed. " + t.message)
			}
		})
		\end{lstlisting}
		\bigskip
		In dieser Art und Weise werden alle Anfragen ans Backend gehandhabt. Dazu zählen:
		\begin{itemize}
			\item Abfragen der Location-Daten zu dem Benutzer für den Geofence
			\item Befüllen des Dropdown-Menüs mit den Timetrack-Accounts des Benutzers
			\item Anzeigen der Beschreibung und der Vergütung
			\item Befüllen des RecyclerViews mit den heutigen Einträgen
			\item Auslösen des Start-/Stopp-Events
			\item Einloggen
		\end{itemize}
				
		\subsection{Geofencing}
		Die Geofencing-Funktion ist die zentrale Funktion für die App und auch für das gesamte Projekt. Deshalb war es wichtig, dass sie frühzeitig funktioniert. \\
		Um die Positon eines Gerätes zu bestimmen bedarf es einer Berechtigung, die vom Benutzer bestätigt werden muss. Für Geräte mit API-Level 28 und niedriger muss dafür die \verb|ACCESS_FINE_LOCATION|-Berechtigung gesetzt werden und für API-Level 29 und höher \verb|ACCESS_BACKGROUND_LOCATION|. \\
		Der Geofence wird initialisiert, wenn für den Benutzer Geo-Daten gespeichert sind. Ist dies der Fall, so wird ein \verb|GeofencingClient| angelegt, dem dann der Geofence hinzugefügt wird. Der Geofence wird erzeugt mit den Parametern: Breitengrad, Längengrad, Radius, der Lebenszeit des Fence und den Übergangstypen. Die Typen sind in unserem Fall \verb|GEOFENCE_TRANSITION_ENTER| und \verb|GEOFENCE_TRANSITION_EXIT|, da wir immer reagieren wollen, wenn der Nutzer den Bereich verlässt oder betritt. 
		\begin{lstlisting}[language=Kotlin]
		geofencingClient = LocationServices.getGeofencingClient(this)
		geofence = Geofence.Builder().setRequestId("Geofence")
			.setCircularRegion(lat, long, rad)
			.setExpirationDuration(Geofence.NEVER_EXPIRE)
			.setTransitionTypes(Geofence.GEOFENCE_TRANSITION_ENTER or Geofence.GEOFENCE_TRANSITION_EXIT)
			.build()
		\end{lstlisting}
		Um den Geofence-Client zu starten wird auf das Objekt die \verb|addGeofences|-Methode ausgeführt mit einem \verb|GeofencingRequest|-Objekt und einem \verb|PendingIntent|-Objekt als Parameter. 
		\begin{lstlisting}[language=Kotlin]
		geofencingClient.addGeofences(getGeofencingRequest(), geofencePendingIntent)?.run {
			addOnSuccessListener { ... }
			addOnFailureListener { ... }
		}
		\end{lstlisting}
		In der \verb|getGeofencingRequest|-Methode wird festgelegt auf welches initiale Event reagiert werden soll und der oben erstellte Geofence wird hinzugefügt. Als initiales Event habe ich \verb|INITIAL_TRIGGER_ENTER| gewählt, da es ausgelöst wird wenn man sich bereits im Bereich befindet und die App startet. Denn erst mit dem Eintrittsevent wird der Button zum Starten der Aufzeichnung freigeschaltet. Das \verb|geofencePendingIntent| definiert die BroadcastReceiver-Klasse, welche bei jedem Event aufgerufen wird.
		\begin{lstlisting}[language=Kotlin]
		private fun getGeofencingRequest(): GeofencingRequest {
			return GeofencingRequest.Builder().apply {
				setInitialTrigger(GeofencingRequest.INITIAL_TRIGGER_ENTER)
				addGeofence(geofence)
			}.build()
		}
		private val geofencePendingIntent: PendingIntent by lazy {
			val intent = Intent(this, GeofenceBroadcastReceiver::class.java)
			PendingIntent.getBroadcast(this, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT)
		}
		\end{lstlisting}
		Die \verb|GeofenceBroadcastReceiver|-Klasse definiert was bei den jeweiligen Events ausgeführt werden soll. In unserem Fall ist dies das Verändern einer boolean Shared-Prefrences-Variable, je nachdem ob der Bereich betreten oder verlassen wurde. Warum diese Art und Weise gewählt wurde lesen Sie in Kapitel \ref{sec:Probleme}.\\
		Das Code-Beispiel zeigt die Aktion beim Betreten des Bereichs.
		\begin{lstlisting}[language=Kotlin][language=Kotlin]
context!!.getSharedPreferences("LOCATION", Context.MODE_PRIVATE)
	?.edit()
	?.putBoolean("ENABLED", true)
	?.apply()
		\end{lstlisting}
		In der \verb|MainActivity| wird ein Listener für diese Shared-Prefrences-Variable definiert. Je nachdem zu welchem Wert sich die Variable ändert wird der Start/Stopp-Button freigeschalten oder gesperrt und wenn der Benutzer den Bereich verlässt, aber noch aufzeichnet, wird diese gestoppt und gespeichert. \\ \\
		
		Unerwartet hierbei war, dass die Geofence-Funktion die normale Positionsbestimmung zusätzlich benötigt. Denn zuerst, hatte ich die Positionsbestimmung implementiert und dann die Geofence-Funktion, was funktioniert hat. Da in der Geofence-Funktion keine Code der normalen Positionsbestimmung referenziert wurde, dachte ich man könne diesen weglassen, was ein Trugschluss war. Auch der Versuch Teile der Positionsbestimmung wegzulassen war ohne Erfolg. Deshalb beinhaltet die App auch Code für die normale Positionsbestimmung.
		
		
	\section{Funktionen der App}
		\subsection{Login Screen}
		\subsection{Main Activity}\label{subsec:main}
	\section{Probleme und Lösungen}\label{sec:Probleme}
	\section{Deployment}