feat: Native Builds für Linux, Windows, macOS und Android

- Web-Export, Web-Preset und Web-Doku entfernt; Zielplattformen sind nur
  noch Desktop und Android
- Export-Presets mit vollständigen Optionssätzen für Linux, Windows,
  macOS (universal, ad-hoc) und Android (arm64-v8a, minSdk 24,
  targetSdk 36, Landscape, Immersive Mode, INTERNET-Permission)
- tools/export_linux.sh, export_windows.sh, export_macos.sh,
  export_android.sh mit gemeinsamen Helfern und tools/verify_apk.sh
- tools/setup_android.sh richtet JDK 17, Android SDK, Godot-4.7.2-
  Templates und Debug-Keystore ein und trägt die Pfade in die
  Editor-Settings ein (mit Backup)
- Eigenes App-Icon (SVG) inklusive Android-Launcher-Icons
- ETC2/ASTC-Import für Android aktiviert, Tests/Prototyp/Addon aus dem
  Export ausgeschlossen
- docs/builds.md: Bauen, Installieren per adb, Datenpfade, Release-Hinweise
This commit is contained in:
torsten 2026-10-30 09:57:14 +01:00
parent d44a4e1e2f
commit c4488a8eb5
26 changed files with 1007 additions and 172 deletions

View file

@ -160,17 +160,19 @@ Gesetzt in `rinkplanner/project.godot`:
| Plattform | Renderer |
| :--- | :--- |
| Desktop | `forward_plus` |
| Mobile | `mobile` |
| Web (Wasm) | `gl_compatibility` |
| Desktop (Linux/Windows/macOS) | `forward_plus` |
| Android | `mobile` |
Ziele sind ausschließlich native Builds; einen Web-Export gibt es nicht
mehr. Details und Befehle: `docs/builds.md`.
### UI-Skalierung (Touch-first)
`window/stretch/mode="disabled"`: Die Oberfläche wird in realen Fenster- bzw.
CSS-Pixeln gelayoutet. Zusätzlich setzt der Controller
`Window.content_scale_factor` auf die Bildschirm-Skalierung
(`DisplayServer.screen_get_scale()`). Damit entspricht eine Layout-Einheit auf
Tablets einem CSS-Pixel und wird trotzdem in Gerätepixeln gerendert:
`window/stretch/mode="disabled"`: Die Oberfläche wird in realen Fensterpixeln
gelayoutet. Zusätzlich setzt der Controller `Window.content_scale_factor` auf
die Bildschirm-Skalierung (`DisplayServer.screen_get_scale()`). Auf dem
Tablet (DPR ≈ 2,6) entspricht eine Layout-Einheit damit einem CSS-Pixel und
wird trotzdem in Gerätepixeln gerendert:
- Ein 56-px-Button ist auf dem Tablet wirklich 56 CSS-Pixel groß, statt durch
eine feste Designauflösung kleingerechnet zu werden.
@ -185,7 +187,7 @@ Tablets einem CSS-Pixel und wird trotzdem in Gerätepixeln gerendert:
Werkzeug-Label entfallen, das Sections-Panel wird 260 statt 300 px breit.
- Die Timing-Leiste ist ein `HFlowContainer` und bricht bei Bedarf um, statt
seitlich abgeschnitten zu werden.
- Geprüfte Landschaftsbreiten: 1024 px (iPad-Landscape) und 1400 px
- Geprüfte Landschaftsbreiten: 1024 px (kleine Tablets) und 1400 px
(Galaxy Tab S9+). Hochformat ist noch nicht gestaltet.
### Zeichen-Cache
@ -224,11 +226,14 @@ ggf. eines nach `touchend` (300-ms-Guard).
- **Autosave** schreibt nach 1,5 s Inaktivität nach `user://autosave.tres`
und wird beim Start automatisch wiederhergestellt. Der Dirty-State wird im
Fenstertitel als `*` angezeigt. Beim Verlassen wird zusätzlich gespeichert.
- **Web:** `FileAccess` schreibt in den IndexedDB-Speicher. Im echten
Chrome-Touch-Test auf einem 1024-px- und einem 1400-px-Layout (DPR 2)
überlebt die Kür einen Browser-Reload.
- **Web-Build:** `tools/export_web.sh` exportiert nach `build/web/`
(single-threaded, kein COOP/COEP nötig). Details in `docs/web-test.md`.
- **Builds:** Linux, Windows, macOS und Android über
`tools/export_*.sh`; Presets in `rinkplanner/export_presets.cfg`.
Android nutzt das Template-Export-Verfahren ohne Gradle-Projekt,
`arm64-v8a`, `minSdk 24`, `targetSdk 36`, Landscape und Immersive Mode.
Details in `docs/builds.md`.
- **Lokale Daten:** `user://` liegt pro Plattform getrennt (Linux
`~/.local/share/godot/app_userdata/Rinkplanner/`, Android im
app-internen Speicher). Ein Kontosync ist noch nicht implementiert.
## 7. Tests
@ -300,8 +305,9 @@ Viewport-Screenshot; sie ersetzen die headless Tests nicht.
rotierende Backups oder Versionen pro Speichervorgang nötig sind, zeigt
sich im Praxisbetrieb.
9. **Dateinamen:** Die Normalisierung ersetzt Leerzeichen und entfernt
Pfadzeichen, transliteriert aber keine Umlaute. Für Web/Windows ist zu
prüfen, ob eine ASCII-Normalisierung robuster ist.
Pfadzeichen, transliteriert aber keine Umlaute. Für Windows und den
geplanten FTP-Sync ist zu prüfen, ob eine ASCII-Normalisierung robuster
ist.
10. **Snapshot-Clone:** `_clone_routine()` kopiert die Modellfelder manuell.
Neue Felder am Modell müssen dort ergänzt werden, sonst fehlen sie in
Undo/Redo-Snapshots.

144
docs/builds.md Normal file
View file

@ -0,0 +1,144 @@
# Builds: Desktop und Android
Rinkplanner wird als **Desktop-Anwendung** (Linux/Windows/macOS) und als
**Android-App** gebaut. Einen Web-Build gibt es nicht mehr: Die App braucht
lokalen Dateizugriff, ein eigenes Fenster und später einen Kontosync, der
nicht von Browser-Speicherlimits abhängt.
## Übersicht
| Ziel | Preset | Ausgabe | Größe (ca.) |
| :--- | :--- | :--- | :--- |
| Linux x86_64 | `Linux` | `build/linux/rinkplanner.x86_64` | 77 MB |
| Windows x86_64 | `Windows` | `build/windows/rinkplanner.exe` | 113 MB |
| macOS universal | `macOS` | `build/macos/rinkplanner.zip` | 64 MB |
| Android arm64 | `Android` | `build/android/rinkplanner-debug.apk` | 31 MB |
Die PCK ist bei Linux und Windows **eingebettet** (eine Datei zum
Weitergeben). `build/` ist nicht versioniert.
## Voraussetzungen
- Godot **4.7.2** (oder `GODOT=/pfad/zu/godot` setzen)
- Export-Templates derselben Version unter
`~/.local/share/godot/export_templates/4.7.2.stable/`
- Für Android zusätzlich JDK 17 + Android SDK (siehe unten)
## Desktop bauen
```bash
./tools/export_linux.sh
./tools/export_windows.sh
./tools/export_macos.sh
```
**Windows:** Icon und Versionsinformationen sind deaktiviert
(`application/modify_resources=false`), damit der Export ohne `rcedit` auf
Linux läuft. Wer das will, installiert `rcedit` und schaltet die Option im
Preset ein.
**macOS:** Das Bundle ist ad-hoc signiert, aber **nicht notarisiert**. Beim
ersten Start auf einem Mac:
```bash
xattr -cr Rinkplanner.app
open Rinkplanner.app # ggf. Rechtsklick → Öffnen
```
Für eine verteilbare App ist eine Signierung mit Developer ID und
Notarisierung auf einem Mac nötig (Preset: `codesign/codesign=3`).
## Android
### Einmalig: Toolchain einrichten
```bash
./tools/setup_android.sh
```
Das Skript (idempotent, ca. 1,6 GB Download):
1. Temurin **JDK 17** → `~/.jdks/temurin-17`
2. Android **command-line tools** → `~/Android/Sdk`
3. `platform-tools`, `build-tools;36.0.0`, `build-tools;35.0.0`,
`platforms;android-36`
4. Godot-**4.7.2-Export-Templates**
5. **Debug-Keystore** → `~/.local/share/godot/keystores/debug.keystore`
6. Trägt `java_sdk_path`, `android_sdk_path` und `debug_keystore` in
`~/.config/godot/editor_settings-4.7.tres` ein (Backup als `.bak`)
### APK bauen
```bash
./tools/export_android.sh # Debug-APK
./tools/export_android.sh debug --install # bauen + per adb installieren
```
Ausgabe: `build/android/rinkplanner-debug.apk`
Prüfen (Paketname, Version, SDK-Stufen, ABI, Landscape, Signatur):
```bash
./tools/verify_apk.sh
```
`aapt2` warnt beim Debug-APK über ein ungenutztes `mipmap/themed_icon` aus
dem Godot-Template. Das Manifest referenziert nur `@mipmap/icon`; die Warnung
ist folgenlos.
- Paket: `de.rinkplanner.app`, Label „Rinkplanner“, Version 0.1.0
- App-Icon aus `rinkplanner/icon.svg` (Launcher-Icons unter
`rinkplanner/assets/icons/android/`)
- `minSdk 24`, `targetSdk 36`, ABI **arm64-v8a** (Galaxy Tab S9+)
- Landscape, Immersive Mode, `resizeableActivity=true`
- Berechtigung `INTERNET` (für den späteren Sync)
- Template-Export ohne Gradle-Projekt (`gradle_build/use_gradle_build=false`)
### Auf dem Tablet installieren
1. Auf dem Tablet: Einstellungen → Info zu Tablet → 7× „Buildnummer“ →
Entwickleroptionen → **USB-Debugging** an
2. Tablet per USB anschließen, „Dateizugriff zulassen“ bestätigen
3. `adb devices` prüfen, dann
```bash
~/Android/Sdk/platform-tools/adb install -r build/android/rinkplanner-debug.apk
```
Alternativ die APK direkt aufs Tablet kopieren und dort öffnen
(„Unbekannte Quellen“ erlauben).
### Wo liegen die Daten?
Godot schreibt `user://` pro Plattform getrennt:
| Plattform | Pfad |
| :--- | :--- |
| Linux | `~/.local/share/godot/app_userdata/Rinkplanner/` |
| Windows | `%APPDATA%\Godot\app_userdata\Rinkplanner\` |
| macOS | `~/Library/Application Support/Godot/app_userdata/Rinkplanner/` |
| Android | App-interner Speicher (`/data/data/de.rinkplanner.app/files/`) |
Dort liegen `routines/`, `autosave.tres` und `exports/`. Die Android-Daten
sind ohne Root nicht direkt sichtbar – der Export-Dialog der App schreibt
nach `user://exports/`, von dort kann man Dateien über einen Dateimanager
mit App-Zugriff oder `adb pull` holen:
```bash
adb shell run-as de.rinkplanner.app ls files/
adb exec-out run-as de.rinkplanner.app cat files/routines/kuer.tres > kuer.tres
```
## Release-Builds
- **Android Release:** eigener Keystore nötig; im Preset
`keystore/release*` setzen und `./tools/export_android.sh release` bauen.
Der Debug-Keystore ist nur zum Testen.
- **Windows/macOS:** siehe Hinweise oben (rcedit, Codesign/Notarization).
## Nächster Schritt: Kontosync
Geplant ist ein manueller Sync über FTP: Ein Button lädt die neuesten
`.tres`-Dateien je Kür hoch bzw. herunter, Konflikte bleiben als Kopien mit
Zeitstempel erhalten. Zugangsdaten liegen in den App-Einstellungen
(`user://`), nicht im Repository.

View file

@ -50,16 +50,30 @@ Voraussetzung für Phase 1.
- [x] Export-Tests: Geometrie, Section-Reihenfolge, Sichtbarkeit
- [x] Export-Dialog mit Dateiname, Format und Umfang
### Nächster Schritt: Touch-/Tablet-/Web-Härtung
### Erledigt: Builds
- [x] Web-Export mit Compatibility-Renderer (`tools/export_web.sh`)
- [x] Touch-Ziele auf 56 px erhöht, Chrome-Doppel-Segment-Guard
- [x] Kleine Displays (1024 px) und kompakte Leiste geprüft
- [x] Performance bei vielen Segmenten und Sections (Cache + Stresstest)
- [x] Persistenz auf Web/IndexedDB verifizieren (Reload-Test)
- [x] Linux-, Windows- und macOS-Preset plus `tools/export_*.sh`
- [x] Android-Toolchain-Setup (`tools/setup_android.sh`), Debug-Keystore
- [x] Signiertes Android-Debug-APK (arm64-v8a, Landscape, minSdk 24)
- [x] Web-Export entfernt; Zielplattformen sind nur noch Desktop + Android
- [ ] Test auf echtem Tablet (Galaxy Tab S9+)
- [ ] Hochformat-Layout (nur prüfen, falls benötigt)
- [ ] Optional: iPad/Safari-Test
- [ ] Release-Keystore für ein verteilbares APK
### Erledigt: Touch-/Tablet-Härtung
- [x] Touch-Ziele auf 56 px erhöht, Guard gegen emulierte Maus-Events
- [x] UI-Skalierung in CSS-Pixeln (DPR-korrekt), kompakte Leiste < 1280 px
- [x] Kleine Displays (1024 px) geprüft
- [x] Performance bei vielen Segmenten und Sections (Cache + Stresstest)
### Nächster Schritt: Kontosync (Desktop ↔ Tablet)
- [ ] Sync-Einstellungen in der App (FTP-Host, Port, Benutzer, Passwort,
Verzeichnis), Zugangsdaten unter `user://`, nicht im Repo
- [ ] Manueller Sync: neueste `.tres` je Kür laden/hochladen
- [ ] Konflikte als Kopien mit Zeitstempel behalten
- [ ] Automatischer Sync und Sync-Status in der Oberfläche (später)
### Danach: Element-Marker
@ -81,8 +95,8 @@ Voraussetzung für Phase 1.
- [ ] Optional: Segment-Verknüpfung beim Verschieben von Endpunkten
- [ ] Optional: Section-Timeline mit Zeitproportionen
Die Reihenfolge ist bewusst: erst Touch-/Web-Basis, dann sichtbare
Element-Marker, dann die vollständige ISU-Logik.
Die Reihenfolge ist bewusst: erst native Builds und Datenaustausch, dann
sichtbare Element-Marker, dann die vollständige ISU-Logik.
## Querschnittsaufgaben

View file

@ -1,95 +0,0 @@
# Web-/Tablet-Test
Zielgerät: **Samsung Galaxy Tab S9+**, Android, Chrome, Landscape.
Zusätzlich geprüft: **1024 × 768 CSS-Pixel** (iPad-Landscape-Größe) und
Desktop-Chromium.
## 1. Voraussetzungen
- Godot 4.7.2 (oder eine kompatible 4.x-Version) mit installierten
**Web-Export-Templates** derselben Version.
- Auf diesem Rechner waren bei der Einrichtung nur die 4.6-Web-Templates
installiert; der erste Testbuild lief deshalb mit Godot 4.6. Für den
finalen Build die 4.7.2-Templates über den Godot-Editor installieren
(`Editor → Manage Export Templates`).
## 2. Web-Build erzeugen
```bash
./tools/export_web.sh
```
Das Skript importiert das Projekt und schreibt den Build nach:
```
build/web/index.html
```
`build/` ist nicht versioniert. Der Export ist **single-threaded** und braucht
keine COOP/COEP-Header. Der Web-Renderer ist `gl_compatibility` (WebGL 2).
## 3. Lokal testen
```bash
python3 -m http.server 8000 --directory build/web
```
Auf dem Tablet im gleichen WLAN öffnen:
```
http://<IP-des-Rechners>:8000/
```
Die IP z. B. mit `ip addr` oder `hostname -I` ermitteln.
## 4. Testcheckliste auf dem Tablet
- [ ] Start im Landscape-Modus, Canvas füllt den Bildschirm
- [ ] Ein-Finger-Ziehen zeichnet genau ein Segment (kein Doppel-Segment)
- [ ] Zwei-Finger-Ziehen pannt
- [ ] Pinch zoomt
- [ ] Tippen im Modus „Auswählen“ wählt ein Segment
- [ ] Start-/Endpunkt- und Bogen-Griffe lassen sich mit dem Finger ziehen
- [ ] Richtung/Kante über die Toolbar ändern
- [ ] Sections anlegen, wechseln, umbenennen, sortieren
- [ ] Timing-Leiste: Dauer/Tempo ändern, Profil wählen, Kalibrieren
- [ ] Playback: Start/Pause/Reset, Timeline-Scrub, Geschwindigkeit
- [ ] Speichern/Laden über das Datei-Menü
- [ ] Autosave: Seite neu laden → Kür ist wieder da
- [ ] SVG- und PNG-Export erzeugen und Datei öffnen
- [ ] Keine abgeschnittenen Buttons, kein horizontales Scrollen
## 5. UI-Skalierung im Browser
Der Web-Build läuft mit `window/stretch/mode="disabled"`. Godot legt das
Canvas in Gerätepixeln an (bei DPR 2 also 2800 × 1580 für 1400 × 790 CSS).
Der Controller setzt deshalb `Window.content_scale_factor` auf
`DisplayServer.screen_get_scale()` (im Browser = `devicePixelRatio`). Damit
gilt:
- Layout-Einheit = CSS-Pixel; ein 56-px-Button ist 56 CSS-Pixel groß.
- Rendering bleibt scharf (2× Backing Store auf dem Tablet).
- Ab 1280 CSS-Pixel erscheinen die vollen Beschriftungen, darunter die
kompakte Leiste („Undo“, „Redo“, „Kalib.“, ohne Titel).
## 6. Bereits geprüft (Chromium, echtes Touch-Event)
- WebGL2/Compatibility-Renderer startet ohne Konsolenfehler
- Ein Chrome-Touch-Drag erzeugt genau **ein** Segment; das synthetische
Maus-Event vor `touchstart` wird verworfen, ein spätes nach `touchend`
ebenfalls (300-ms-Guard)
- Autosave/IndexedDB: Reload stellt die Kür wieder her (1024 und 1400 px)
- Layout bei 1024 × 768 (kompakt) und 1400 × 790 (voll) ohne Abschneiden
- Touch-Ziele 56 × 56 px; Menü/Undo/Redo sind Textbuttons, damit
Web-Font-Fallbacks keine Kästchen erzeugen
- Performance: 480 Segmente / 12 Sections ≈ 7–10 ms pro Redraw (headless,
ohne GPU-Zeichnung)
## 7. Bekannte Grenzen
- **Hochformat** (< 1024 px Breite) ist noch nicht gestaltet; die
Werkzeugleiste wäre dort zu breit. Ziel bleibt Landscape.
- Safari/iOS ist noch nicht getestet. Der Build ist thread-frei und nutzt
WebGL2, also grundsätzlich lauffähig; separat zu prüfen sind
Touch-Event-Reihenfolge, IndexedDB-Limits und Safe-Area im Landscape.
- Audio wird in Phase 1 nicht genutzt.