add files

Author: guFalcon

asciidocs/android-1.adoc

@@ -0,0 +1,359 @@
+= Android - Course - 1 - Introduction
+ifndef::imagesdir[:imagesdir: images]
+:icons: font
+:source-highlighter: highlight.js
+:experimental:
+:sectnums:
+:toc:
+ifdef::backend-html5[]
+
+// https://fontawesome.com/v4.7.0/icons/
+icon:file-text-o[link=https://raw.githubusercontent.com/UnterrainerInformatik/documents/main/asciidocs/{docname}.adoc] ‏ ‏ ‎
+icon:github-square[link=https://github.com/UnterrainerInformatik/documents] ‏ ‏ ‎
+endif::backend-html5[]
+
+link:https://htl.unterrainer.info/index.html[BACK to Index]
+
+link:https://htl.unterrainer.info/android.html[BACK to Android - Course]
+
+== Grundlagen Android-Entwicklung
+
+image:android-1-0.png[align="center",width="100%"]
+
+=== Was ist Android?
+- OS- und Programmierplattform von Google für mobile Geräte entwickelt.
+- Basiert auf Linux-Kernel und Java
+
+image:android-1-1.png[align="center",width="100%"]
+
+=== Warum Android?
+- Populärste Plattform für mobile Apps
+- Einfach zu entwickelnde Apps
+- Viele Verteilungsmöglichkeiten
+
+=== Wie funktioniert Android?
+image:android-1-2.png[align="center",width="50%"]
+
+. Deine Apps leben hier zusammen mit den System-Apps (E-Mail, SMS, ...)
+. UI Komponenten, Ressourcen-Management, Lifecycle-Management. Stellt native Bibliotheken für die App zur Verfügung.
+. Jede App läuft in ihrer eigenen Instanz der Android Runtime.
+. Stellt Hardware-Abstraktionen zur Verfügung. Jede App hat Zugriff auf die Hardware, aber nur über die API.
+. Foundation. Kümmert sich um threading, low-level memory management, etc...
+
+== Android Studio IDE
+Installation unter: link:https://developer.android.com/studio/install[https://developer.android.com/studio/install]
+
+====
+IMPORTANT: Hausübung:
+Installieren und auf die neueste Version updaten.
+====
+
+== Kotlin Grundzüge
+=== Kotlin
+image:android-1-3.png[align="center",width="100%"]
+
+Seit 2019 ist Kotlin die bevorzugte Programmiersprache für Android-Apps bei Google
+Seitdem ist die Sprache sehr populär geworden
+
+=== Java vs. Kotlin
+==== Null Safety
+|===
+|Java |Kotlin
+
+a|Jedes Objekt ist null by default
+[java]
+----
+public Integer number;
+----
+
+a|Kein Objekt kann null werden
+[source,kotlin]
+----
+val number: Int
+----
+...außer man gibt es so an:
+[source,kotlin]
+----
+val number: Int? = null
+----
+|===
+
+==== Extension Functions
+|===
+|Java |Kotlin
+
+a|Ohne Erweiterung (z.B. Project Lombok) nicht verfügbar. (Ev. noch über Vererbung... Aber nicht jedes zu erweiternde Projekt gehört auch euch.)
+
+a|Standardmäßig in die Sprache eingebaut. Einfach den Funktionsnamen in jedem beliebigen File mit dem jeweiligen Klassennamen prefixen.
+[source,kotlin]
+----
+fun String.removeFirstLastChar(): String =  this.substring(1, this.length - 1)
+
+fun main(args: Array<String>) {
+    val myString= "Hello Everyone"
+    val result = myString.removeFirstLastChar()
+    println("First character is: $result")
+}
+----
+|===
+
+==== Code
+|===
+|Java |Kotlin
+a|* Eher ausführlich (getter, setter).
+* Gibts schon länger als so manches modernes Sprachkonstrukt (z.B. async).
+a|* Sehr kompakt.
+* Weniger Lines Of Code.
+
+=> Besser zu erstellen, lesen und zu warten.
+|===
+
+==== Coroutines
+|===
+|Java |Kotlin
+
+a|Background Threads. (z.B.: ExecutorService)
+
+a|* Eigener Threadpool
+* In Sprache fix eingebaut
+
+[source,kotlin]
+----
+fun main() = runBlocking { // this: CoroutineScope
+    launch { // launch a new coroutine and continue
+        delay(1000L) // non-blocking delay for 1 second
+        println("World!") // print after delay
+    }
+    println("Hello") // main coroutine continues
+}
+----
+
+Output:
+Hello
+World!
+
+|===
+
+==== Data Classes
+|===
+|Java |Kotlin
+
+a|* Händisch (viel Code oder generiert)
+* Durch Verwendung von Project Lombok
+
+a|* Ein eingebautes Sprachkonstrukt
+* Getter, Setter, HashCode(), Equals(), toString()... werden automatisch implementiert.
+|===
+
+==== Smart Casts
+|===
+|Java |Kotlin
+
+a|Entwickler muss die Typen überprüfen und angeben.
+a|* Casting Checks werden automatisch durchgeführt (smart casts feature).
+* Redundante Checks werden entfernt.
+|===
+
+==== No Checked Exceptions
+|===
+|Java |Kotlin
+
+a|Es gibt checked Exceptions.
+
+(Meiner Meinung nach ist das eine gute Sache)
+a|Es gibt keine checked Exceptions.
+
+(Meiner Meinung nach eine schlechte Sache, weil ... nun ... exception handling ist wichtig und sollte nicht optional sein.)
+|===
+
+==== Higher-Order Funcs und Lambdas
+|===
+|Java |Kotlin
+
+a|In abgespeckter Form verfügbar oder mit alten Sprachkonstrukten nachgebaut.
+a|Inherent in Sprache enthalten.
+
+[source,kotlin]
+----
+max(strings, { a, b -> a.length < b.length })
+
+/**
+The function max is a higher-order function,
+as it takes a function value as its second argument.
+This second argument is an expression that is itself a function,
+called a function literal,
+which is equivalent to the following named function:
+**/
+
+fun compare(a: String, b: String): Boolean = a.length < b.length
+----
+|===
+
+
+=== Übung
+Spielwiese unter: link:https://play.kotlinlang.org/koans/overview[https://play.kotlinlang.org/koans/overview]
+
+====
+IMPORTANT: Hausübung: Alle Aufgaben auf dieser Seite links durchmachen.
+Android-Studio herunterladen: https://developer.android.com/studio/releases
+====
+
+== Komponenten einer Android-App
+
+=== AndroidManifest.xml
+Jedes Android-App-Projekt muss dieses File im Root des Projekt-Source-Sets enthalten.
+Es enthält wichtige Informationen über die App für:
+
+- Build Tools
+- The Android Operating System
+- Google Play
+
+Ist eine XML-Datei, die die Struktur der App beschreibt. Ist XML, damit sie leichter von Menschen gelesen und ohne Editor geändert werden kann.
+Wird beim Kompilieren in ein binäres Format übersetzt (wegen Geschwindigkeit).
+
+Es enthält Informationen über die Applikation:
+
+* functions
+* services
+* broadcast receivers
+* content producers
+* components
+* The apps permissions
+* The apps rights (permissions, die andere Apps brauchen werden, damit sie von eurer App Daten bekommen können.)
+
+=== Application Components
+image:android-1-4.png[align="center",width="80%"]
+
+image:android-1-5.png[align="center",width="100%"]
+
+* Fragments
+
+Teile einer Maske, die innerhalb einer Activity verwendet werden können.
+
+* Views und ViewGroups
+
+Views sind GUI-Elemente. ViewGroups sind Container für Views.
+
+* Layouts
+
+XML Files, die die Struktur der Activities, Fragments und ViewGroups beschreiben.
+
+* Resources
+
+Images, Strings, UI Layouts...
+
+* Manifest
+
+Explained above.
+
+== Meine erste Android-App
+Erstmal Android Studio herunterladen und installieren, falls dies nicht schon erfolgt ist. https://developer.android.com/studio/releases
+
+== Jetpack Compose
+
+Modernes UI Toolkit für Android-Entwicklung.
+Reactive Programming Model.
+Verwendet Kotlin Sprachkonstrukte.
+Vollständig deklarativ wie flutter, Swift UI oder React Native (sag ihm WAS du willst, nicht WIE du es willst).
+
+...beschreibt die UI als Funktion, die Daten in eine UI-Hierarchie transformiert
+...wenn sich die Daten ändern, ruft das Framework diese Funktionen automatisch auf und aktualisiert so die UI
+
+image:android-1-7.png[align="center",width="100%"]
+
+=== Mein erster Knopf in Jetpack-Compose
+image:android-1-6.png[align="center",width="80%"]
+
+==== Neues Projekt anlegen
+
+In der Android Studio IDE, ist ein Projekt-Template eine Android-App, die alle notwendigen Teile hat, um eine Applikation zu erstellen.
+Es hilft dir, ein neues Projekt einzurichten.
+
+Schritt für Schritt werden wir unsere erste Android-App erstellen und sie auf dem Emulator starten:
+
+1. Android Studio starten, indem du auf das Android Studio Icon in deinem Dock oder wo auch immer du Android Studio gespeichert hast, klickst.
+
+2. Wenn Android Studio startet, klicke auf "Start a new Android Studio project" am Welcome-Screen.
+Alternativ kannst Du auch auf File und dann New Project klicken.
+
+3. Klicke auf "Empty Activity" und klicke dann auf Next. (Compose ist inzwischen Standard)
+
+image:android-1-8.png[align="center",width="100%"]
+
+Wenn der leere Compose Activity Screen geladen hat, wirst Du Felder sehen, wie 'Name', 'Package name', 'Save location', 'Language', und 'Minimum SDK'.
+Für dieses Kapitel nennen wir unser Projekt 'Android Community' und lassen die anderen Einstellung in Ruhe.
+Die Sprache ist per Voreinstellung auf Kotlin.
+Minimum SDK ist API 21: Android 5.0 (Lollipop). Das ist die minimale Version von Android, auf der unsere App laufen können wird.
+In diesem Fall wird unser Projekt auf ca. 98.8% aller Android-Geräte laufen können.
+Die Einstellungen im Bild unten, wie der Name und das Package, sind nur Beispiele. Du kannst Deine eigenen Werte eingeben oder es einfach so lassen, wie es voreingestellt ist.
+
+image:android-1-9.png[align="center",width="100%"]
+
+Jetzt auf 'Finish' klicken.
+
+Jetzt kannst Du Dich ein wenig in den Packages umsehen. Dir wird auffallen, dass es eine 'MainActivity' Klasse gibt, die von 'Activity' ableitet.
+Darin gibt es eine fun (Function) 'onCreate', die eine Methode in 'ComponentActivity' überlädt.
+
+Du wirst auch eine Funktion 'setContent' sehen, die den Inhalt einer Composable Funktion setzt.
+Sie nimmt einen Lambda-Ausdruck, die die Elemente enthält, die angezeigt werden sollen. In unserem Fall enthält er das Theme unserer Applikation.
+
+In der 'Greeting' Funktion werden wir jetzt unsere eigene Grußformel "Hello, Android 
+Community" einsetzen und das Programm ausführen (run).
+
+[source,kotlin]
+----
+class MainActivity : ComponentActivity() {
+    override fun onCreate(savedInstanceState:Bundle?) {
+        super.onCreate(savedInstanceState)
+            setContent {
+                AndroidCommunityTheme {
+                    Surface(
+                        modifier = Modifier.fillMaxSize(),
+                        color = MaterialTheme.colors.background
+                    ) {
+                        Greeting("Hello, Android Community")
+                }
+            }
+        }
+    }
+}
+----
+
+
+
+== Android Project Structure
+image:android-1-10.png[align="center",width="50%"]
+Das ist das Projekt-Root-Verzeichnis. Es enthält alle Dateien, die für das Projekt wichtig sind.
+
+=== Manifest Ordner
+Der Manifest-Ordner ist die Quelle der Wahrheit für die Android-App; er enthält AndroidManifest.xml.
+Klicke auf AndroidManifest.xml, um es zu öffnen und Dir den Inhalt anzusehen.
+
+image:android-1-11.png[align="center",width="100%"]
+Das Java-Verzeichnis enthält alle Kotlin- (.kt) und Java-Dateien (.java), die wir erstellen, wenn wir unsere Android-Apps erstellen.
+Beispielsweise, im nächsten Bild, haben wir ein Package mit (androidTest) und (test), und hier fügen wir unsere Tests hinzu.
+Klicke einfach einmal alle Verzeichnisse durch um deren Inhalt zu sehen.
+
+image:android-1-12.png[align="center",width="100%"]
+Im AndroidTest-Verzeichnis haben wir unsere UI-Tests, und im Test-Verzeichnis haben wir unsere Unit-Tests.
+Unit-Tests testen kleine Teile unseres Codes, um sicherzustellen, dass das gewünschte Verhalten wie erwartet ist.
+Test-Driven Development (TDD) ist während der App-Entwicklung hervorragend und wertvoll.
+Einige Unternehmen folgen dieser Regel, andere nicht. Aber grundsätzlich ist es eine gute Praxis, den Code immer zu testen.
+
+Das res-Verzeichnis enthält XML-Layouts, UI-Strings, drawable-Images und Mipmap-Icons.
+Auf der anderen Seite enthält das values-Verzeichnis viele nützliche XML-Dateien wie Dimensionen, Farben und Themes.
+Klicke auf das res-Verzeichnis, um Dich mit dem vertraut zu machen, was dort ist, da wir es im nächsten Kapitel verwenden werden.
+
+image:android-1-13.png[align="center",width="100%"]
+Zuletzt, im Gradle-Scripts Verzeichnis, haben wir die build-Konfiguration, die die beschreiben auf welche Art unser Projekt gebaut werden soll für unser Projekt enthalten.
+Es ist in Module aufgeteilt und die Einträge in der obersten Datei gelten für alle Module.
+
+Ein Modul ist eine Sammlung von Source-Dateien und Build-Einstellungen, die es Dir ermöglichen, Dein Projekt in verschiedene Einheiten mit bestimmten Zwecken zu unterteilen.
+
+== Deine App mit Gradlew laufen lassen
+
+Zuerst mal die installierte Gradle-Version checken mit ./gradlew (GradleWrapper).
+
+Mit ./gradlew clean und ./gradlew build kannst Du Dein Projekt bauen.
+
+Ansonsten kannst Du auch einfach auf den grünen Pfeil in der IDE klicken.