up

.gitea/workflows/release.yml

@@ -0,0 +1,34 @@
+name: release
+on:
+  - release
+
+jobs:
+  analyse:
+    name: Analyse
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+      - uses: actions/setup-java@v3
+        with:
+          distribution: "temurin"
+          java-version: "17"
+      - uses: android-actions/setup-android@v3
+      - uses: subosito/flutter-action@v2
+        with:
+          flutter-version: "3.13.0"
+      - run: flutter pub get
+      - run: flutter test
+      - run: flutter build apk
+      - name: setup go
+        uses: https://github.com/actions/setup-go@v4
+        with:
+          go-version: ">=1.20.1"
+      - name: Use Go Action
+        id: use-go-action
+        uses: https://gitea.com/actions/release-action@main
+        with:
+          files: |-
+            build/app/outputs/flutter-apk/app-release.apk            
+          api_key: "${{secrets.RELEASE_TOKEN}}"

Bachelor.bib

@@ -19,6 +19,61 @@
   file = {/Users/fabian/Zotero/storage/W67CJYBZ/architectural-overview.html}
 }
 
+@online{Flutterb,
+  title = {Inside {{Flutter}}},
+  url = {https://docs.flutter.dev/resources/inside-flutter},
+  urldate = {2024-02-13},
+  abstract = {Learn about Flutter's inner workings from one of the founding engineers.},
+  langid = {english},
+  file = {/Users/fabian/Zotero/storage/V9T5LLK6/inside-flutter.html}
+}
+
+@online{IntroductionDeclarativeUI,
+  title = {Introduction to Declarative {{UI}}},
+  url = {https://docs.flutter.dev/get-started/flutter-for/declarative},
+  urldate = {2024-02-13},
+  abstract = {Explains the difference between a declarative and imperative programming style.},
+  langid = {english},
+  file = {/Users/fabian/Zotero/storage/F6LI3FTY/declarative.html}
+}
+
+@online{linuxfoundationYoctoProject162024,
+  title = {The {{Yocto Project}} ® 4.0.16 Documentation},
+  author = {{Linux Foundation}},
+  date = {2024},
+  url = {https://docs.yoctoproject.org/4.0.16/singleindex.html},
+  urldate = {2024-02-13},
+  file = {/Users/fabian/Zotero/storage/WWAQWEK2/singleindex.html}
+}
+
+@online{ReactiveManifesto,
+  title = {The {{Reactive Manifesto}}},
+  url = {https://www.reactivemanifesto.org/},
+  urldate = {2024-02-13},
+  file = {/Users/fabian/Zotero/storage/FJSMEDYJ/www.reactivemanifesto.org.html}
+}
+
+@online{Skia,
+  title = {Skia},
+  url = {https://skia.org/},
+  urldate = {2024-02-13},
+  abstract = {2D Graphics Library},
+  langid = {english},
+  organization = {{Skia}},
+  file = {/Users/fabian/Zotero/storage/NV4BSHXY/skia.org.html}
+}
+
+@video{theflutterwayFlutterRubberDuck2022,
+  entrysubtype = {video},
+  title = {Before {{Flutter}} | {{Rubber Duck Engineering}} | {{Episode}} \#100},
+  editor = {{The Flutter Way}},
+  editortype = {director},
+  date = {2022-05-27},
+  url = {https://www.youtube.com/watch?v=xqGAC5QCYuQ},
+  urldate = {2024-01-24},
+  abstract = {Tonight we'll talk about the years leading up to Flutter and how Adam and I worked on a variety of projects for the web which inspired what Flutter would become, including at least 3 frameworks in JS, how we briefly thought "shake to reload" was our killer feature, how for more than the first 6 months of the project Flutter was DOM-based and network loaded and much more.  Gonna be amazing. Slides: https://docs.google.com/presentation/...}
+}
+
 @article{weiserComputer21stCentury1999,
   title = {The Computer for the 21st Century},
   author = {Weiser, Mark},
@@ -35,3 +90,14 @@
   abstract = {Specialized elements of hardware and software, connected by wires, radio waves and infrared, will be so ubiquitous that no one will notice their presence.},
   file = {/Users/fabian/Zotero/storage/8CCSE83J/Weiser - 1999 - The computer for the 21st century.pdf}
 }
+
+@online{WorkingJSONFlutter2021,
+  title = {Working with {{JSON}} in {{Flutter While Using}} Json\_annotations and Json\_serializable {{Modules}} in 2022 | {{John Maeda}}’s {{Blog}}},
+  date = {2021-06-22},
+  url = {https://maeda.pm/2022/04/24/working-with-json-in-flutter-while-using-json_annotations-and-json_serializable-modules-in-2022/},
+  urldate = {2024-02-13},
+  abstract = {How to use Flutter/Dart’s magical ways to convert JSON data into usable structures so that you can get unstuck — and get going. Why are you here? You have read tons of Medium posts and watched plenty of YouTube videos and still feel a little confused. Along the way, you…},
+  langid = {american},
+  organization = {{https://maeda.pm/}},
+  file = {/Users/fabian/Zotero/storage/ND8L5RU6/working-with-json-in-flutter-while-using-json_annotations-and-json_serializable-modules-in-2022.html}
+}

chapters/03_grundlagen/01_eLinux.md

@@ -0,0 +1,18 @@
+<!--
+Challenges with Direct Statistics
+
+No Centralized Reporting:
+Unlike mobile OS usage (Android vs. iOS), there's no unified app store
+or market survey specifically for embedded Linux UIs. Projects range
+from hobbyist work to closed-source industrial systems, making data
+collection highly fragmented.
+
+Embedded Development Diversity:
+The range of devices running embedded Linux is immense, varying greatly
+in purpose and visibility. This creates a large sample space that’s
+hard to track systematically.
+
+Subjectivity in Definition:
+What constitutes "most used" gets tricky. Is it by volume of devices
+regardless of scale, or by developer preferences in recent projects?
+-->

chapters/03_grundlagen/05_yocto_linux.md

@@ -0,0 +1,17 @@
+# Yocto Environment
+
+## Poky
+
+## Metadata
+
+## Open-Embedded Project
+
+## Bitbake
+
+## Board support package
+
+## Meta-Flutter
+
+# Setting up the build environment and building the image
+
+# Flashing the image on Target

chapters/03_grundlagen/06_flutter.md

@@ -2,6 +2,16 @@
 
 # Flutter
 
+Die zunehmende Verbreitung mobiler Geräte und Betriebssysteme
+stellt die effiziente Anwendungsentwicklung vor Herausforderungen.
+Plattformübergreifende Frameworks wie Flutter zielen darauf ab,
+diese Herausforderungen zu mildern, indem sie ein einheitliches
+Toolset zum Erstellen von Benutzeroberflächen (UIs) bereitstellen,
+die nahtlos über verschiedene Plattformen hinweg funktionieren.
+Dieses Kapitel befasst sich mit der grundlegenden Architektur,
+den Vorteilen und Überlegungen zur Verwendung von Flutter für
+die Anwendungsentwicklung. [@theflutterwayFlutterRubberDuck2022]
+
 Was ist Flutter [@FlutterArchitecturalOverviewb]
 
 test [@weiserComputer21stCentury1999]

chapters/06_flutter/01_architecture.md

@@ -0,0 +1,62 @@
+<!-- Core Principles
+
+Lightweight Embedder: flutter-pi acts as a custom Flutter engine
+embedder tailored for the Raspberry Pi. This means it provides the
+essential interface layer between Flutter's primarily C++ engine
+and the embedded Linux environment (like on a Raspberry Pi).
+
+No X11 Required: Notably, flutter-pi achieves this feat without
+ the graphical overhead of a system like X11 (common in desktop
+ Linux). This aligns better with resource-constrained embedded
+ devices.
+
+Direct Rendering:
+flutter-pi interacts with lower-level graphics APIs within the
+ Raspberry Pi (e.g., Broadcom's VideoCore, EGL) to handle rendering
+ of the Flutter UI onto the display hardware.
+
+Key Responsibilities
+
+Initialization:
+Sets up the Flutter engine, loads appropriate libraries, and
+gets everything ready for the Flutter application to run.
+
+Event Handling: Manages input events (touch via touchscreen,
+keyboard, mouse, etc.) and routes them from the embedded Linux
+system to the Flutter framework for processing.
+
+Rendering Loop: Coordinates requesting the next Flutter UI fram
+e in response to events or state changes, communicates with the
+rendering backends, and facilitates displaying the content.
+
+Platform Channels: (Likely) Provides mechanisms for the Flutter
+app to communicate with the underlying embedded Linux system.
+This enables the app to potentially access device-specific
+sensors, hardware control, and features outside the scope of
+Flutter's core framework.
+
+How to Utilize It
+
+Prepare Environment: You'll need a Raspberry Pi running an
+embedded Linux distribution and a toolchain suitable for
+cross-compilation.
+
+Obtain/Build flutter-pi: Refer to the project's GitHub repository
+for build instructions.
+
+Develop Flutter App: Structure your Flutter app normally, being
+mindful of platform interactions that might need platform channels
+(step 4).
+
+Integrate & Compile: Follow flutter-pi's instructions to compile
+your Flutter app code while linking against the flutter-pi embedder
+you obtained/built.
+
+Deploy & Run: Transfer the compiled output to your Raspberry Pi
+and execute it with appropriate flutter-pi settings.
+
+Caveats
+
+Experimental: Not considered production-ready for every use-case (as might be expected with projects pushing Flutter’s boundaries).
+Limited APIs: Compared to mainstream platforms, Flutter’s full suite of plugins and packages might not be compatible without extra platform channel work on your end.
+-->