feat(android): initial project setup with Gradle, AndroidManifest, and MainActivity

.github/workflows/android-ci.yml

@@ -0,0 +1,28 @@
+name: Android CI
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+      - name: Cache Gradle
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.gradle/caches
+            ~/.gradle/wrapper/
+          key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties') }}
+      - name: Build
+        run: |
+          ./gradlew :app:assembleDebug

ANDROID_ARCHITECTURE.md

@@ -0,0 +1,36 @@
+Android Architektur (Kotlin + Jetpack Compose) — Vorschlag
+
+Packages/Module Struktur:
+- app/ (Android-App module)
+  - src/main/java/de/harheimertc/
+    - ui/
+      - navigation/ (NavGraph, Routes)
+      - screens/ (HomeScreen, TermineScreen, SpielplanScreen, GalleryScreen, ContactScreen, AuthScreens, CMS Screens)
+      - components/ (TopBar, BottomNav, Cards, Modals)
+      - theme/ (Color.kt, Typography.kt, Theme.kt)
+    - data/
+      - api/ (Retrofit interfaces, DTOs)
+      - repository/ (Repositories für Domain-Modelle)
+      - local/ (Room DAOs, Entities)
+    - di/ (Hilt Modules)
+    - domain/ (UseCases, Business-Logic)
+    - util/ (Extensions, DateUtils, ImageUtils)
+    - auth/ (AuthManager, Passkeys helper)
+
+Wichtige Dateien:
+- `MainActivity.kt` — Hosts Compose NavHost
+- `AppTheme.kt` — Compose Material3 Theme mit Token-Mapping
+- `NetworkModule` (Hilt) — Retrofit + OkHttp + Auth Interceptor
+- `Repository` Layer — entkoppelt UI von Netz
+- `Room` Entities — für Caching von Termine/News/Galerie
+
+Auth-Strategie:
+- AuthRepository verwaltet Login/Logout, `checkAuth()` (mirroring `/api/auth/status`).
+- Token/Cookie-Speicherung: `EncryptedSharedPreferences` für Tokens oder `CookieJar` mit OKHttp-Client.
+- Passkeys: `Fido2Client` wrapper + Bridge zu Server-API (Formate prüfen).
+
+Build / Module Tipps:
+- Start mit Single Module `app/` und später evtl. `:data`, `:domain` Trennung.
+- Verwende Gradle Kotlin DSL (build.gradle.kts).
+
+Diese Architekturdatei wurde generiert; ich kann nun ein initiales Gradle-Kotlin-Scaffold erzeugen. Soll ich das direkt in `android-app/` ablegen? (Ja/Nein)

ANDROID_KOTLIN_PLAN.md

@@ -0,0 +1,77 @@
+Android App — Kotlin (Jetpack Compose) Plan und Abhakliste
+
+Kurz: Ziel ist eine native Android-App mit Kotlin + Jetpack Compose, die die Web-UI 1:1 abbildet (Farben, Typografie, Funktionalitäten). Diese Datei enthält Architekturentscheidungen, empfohlene Bibliotheken und eine detaillierte Abhakliste (schrittweise).
+
+1) Zusammenfassung der Entscheidungen
+- Plattform: Native Android
+- Sprache: Kotlin
+- UI-Toolkit: Jetpack Compose (Compose Material3)
+- Architektur: MVVM mit `ViewModel` + Kotlin Coroutines + Flow
+- DI: Hilt
+- HTTP-Client: Ktor Client oder Retrofit + OkHttp (empfohlen: Retrofit für breite Community-Docs)
+- Bild-Loading: Coil
+- Lokale DB / Caching: Room + DataStore (Preferences)
+- Background/Sync: WorkManager
+- Auth: JWT-Handling, Unterstützung für Passkeys (Android Passkeys / WebAuthn Interop über FIDO2 APIs)
+- Rich-Text: WebView-basierte Anzeige; Editoren: ggf. hybride Lösung (Server-side HTML editor + WebView) oder `RichEditor`-Libs
+- Crash-Reporting & Monitoring: Firebase Crashlytics oder Sentry
+
+2) Design & Farben
+- Material Theme (Material3) mit Farben aus `tailwind.config.js` (Primary + Accent).
+- Fonts: Inter & Montserrat via Google Fonts (Download/Bundle oder Play-Services-Download at runtime).
+- Mapping: Tailwind-Token → `colors.xml` / Compose `Color` tokens.
+
+3) Empfohlene Abhängigkeiten (erste Implementierung)
+- androidx.compose.* (ui, material3, navigation)
+- androidx.lifecycle:lifecycle-viewmodel-ktx
+- com.google.dagger:hilt-android
+- retrofit2 + converter-moshi / kotlinx-serialization
+- io.coil-kt:coil-compose
+- androidx.room:room-runtime + room-ktx
+- androidx.work:work-runtime-ktx
+- androidx.datastore:datastore-preferences
+- com.google.android.gms:play-services-auth (für passkeys falls nötig)
+- io.sentry:sentry-android (optional)
+
+4) Detaillierte Abhakliste (Schritte)
+ [x] 1. Repo-Analyse: Liste der externen Endpunkte und Auth-Anforderungen exportieren
+ [x] 2. Projekt-Scaffold: Android Studio Projekt mit Kotlin + Compose anlegen
+ [x] 3. App-Architektur: Module / Packages anlegen (ui, data, domain, di, util)
+ [x] 4. CI-Build: Gradle-Config und GitHub Actions Skeleton
+ [ ] 5. Theme: `Color.kt`, `Typography.kt`, `Theme.kt` erstellen und Tailwind-Farben mappen
+ [ ] 6. Fonts: Inter + Montserrat einbinden (res/font oder GoogleFonts)
+ [ ] 7. Navigation: Compose Navigation-Graph mit Routen für alle Seiten anlegen
+ [ ] 8. Start-Screen: `HomeScreen` mit Hero-Bild und CTA anlegen
+ [ ] 9. Komponenten: NavBar, Footer (falls nötig), Card, ImageGrid, Modal/Dialogs implementieren
+ [ ] 10. Screens: Erstelle Screens für `Termine`, `Spielplan`, `Galerie`, `Kontakt`, `Mitgliedschaft`, `Login`, `CMS` etc.
+ [ ] 11. API-Client: Retrofit/Ktor-Client implementieren, Auth-Interceptor (Token Refresh)
+ [ ] 12. Auth: Login/Register/Logout + sichere Token-Speicherung (DataStore + EncryptedSharedPreferences)
+ [ ] 13. Passkeys: Integration prüfen (FIDO2 / Passkeys) und Fallback auf Passwort
+ [ ] 14. Image-Upload: Multipart-Upload + Coil für Anzeige + Bildkompression (u. a. Sharp-Äquivalent evtl. serverseitig)
+ [ ] 15. Rich-Text: Anzeige von HTML (Compose + WebView) und ggf. Editor via WebView-bridge
+ [ ] 16. Formulare: Validierung (clientseitig) und Fehlerdarstellung
+ [ ] 17. Offline & Caching: Room für persistente Daten, Response-Caching, Sync-Strategie
+ [ ] 18. Lokalisierung: `strings.xml` (DE + EN) und i18n-Check
+ [ ] 19. Accessibility: ContentDescription, Focus, Farben/Kontrast prüfen
+ [ ] 20. Tests: Unit-Tests für ViewModels + UI-Tests mit Compose Testing
+ [ ] 21. Performance: Bildoptimierung, LazyLists, Paging (falls große Daten)
+ [ ] 22. Analytics: Firebase / Matomo Integration (je nach Datenschutz)
+ [ ] 23. Crash-Reporting: Sentry / Crashlytics integrieren
+ [ ] 24. Build/Release: App signing, Release-Notes, Play-Store-Metadaten vorbereiten
+ [ ] 25. Dokumentation: `README-android.md` mit Setup, Architektur und Release-Anleitung
+
+5) Kurzzeit-MVP (Priorität für erste Version)
+- [ ] A. Auth (Login/Logout)
+- [ ] B. Home, Termine, Spielplan, Galerie (anzeigen)
+- [ ] C. Kontaktformular (absenden)
+- [ ] D. Bildanzeige + Caching
+- [ ] E. Theme & Fonts
+
+6) Nächste Aktionen (sofort)
+- Erstelle Android-Projekt-Scaffold (auf Wunsch automatisiert)
+- Exportiere vollständige Asset-Liste (Bilder, Icons, Fonts, PDFs)
+
+---
+Datei erstellt: [ANDROID_KOTLIN_PLAN.md](ANDROID_KOTLIN_PLAN.md)
+
+Wenn du möchtest, starte ich jetzt mit dem Android-Scaffold oder exportiere zuerst alle Assets. Welche Option bevorzugst du?

ANDROID_PORT_TODO.md

@@ -0,0 +1,84 @@
+ANDROID App - 1:1 Portierung der Web-UI (TODO)
+
+Ziel: Die Web-UI des Projekts 1:1 in eine native (oder cross-platform) Android-App überführen, inklusive Farben, Designsystem und aller Funktionalitäten.
+
+1) Analyse Codebasis & Assets
+- Analysiere `package.json`, `nuxt.config.js`, `tailwind.config.js` und zentrale Server-/API-Endpunkte.
+- Liste alle verwendeten Farben, CSS-Variablen, Tailwind-Konfigurationen.
+- Sammle alle statischen Assets: Bilder, Icons, SVGs, Fonts, PDF-Dokumente.
+- Identifiziere dynamische Komponenten: Formulare, Rich-Text-Editor, Uploads, Kalender, Navigation.
+
+2) Projektziele und Scope
+- Entscheide: Native Android (Kotlin/Jetpack Compose) oder Cross-Platform (React Native, Flutter, Kotlin Multiplatform).
+- Priorisiere Features für MVP vs. Post-Launch.
+
+3) Designsystem und Farben extrahieren
+- Extrahiere Farbpalette, Typografie, Abstände, Buttons, Karten, Form-Controls.
+- Erstelle eine Design-Token-Liste (Hex/RGBA, Namen, Einsatzbereiche).
+
+4) Technologie-Stack wählen
+- Empfohlene Optionen: Kotlin + Jetpack Compose (native), Flutter (UI-First), React Native (Wiederverwendung von JS/nuxt-Logik).
+- Bibliotheken: Navigation, HTTP-Client, Bild-Handling, Auth (WebAuthn falls nötig), Local DB.
+
+5) Android-Projekt aufsetzen
+- Erstelle Projekt-Scaffold, CI-Build, Signing-Config.
+
+6) Theme & Farben implementieren
+- Implementiere App-Theme mit Farben/Typografie-Token.
+
+7) Navigation-Struktur implementieren
+- Bottom/Navigations-Drawer/Stack wie Web-Navigation abbilden.
+
+8) Screens für Seiten anlegen
+- Erstelle Screens für: Startseite, Termine, Spielplan, Galerie, Kontakt, News, Mitgliedschaft, Login, CMS-Bereiche.
+
+9) UI-Komponenten portieren
+- Navbar, Footer, Cards, Image-Grid, Modal/Dialog, Rich-Text-Viewer/Editor, Date-Picker, Tabellen.
+
+10) Formulare & Validierung implementieren
+- Registrieren, Login, Passwort vergessen, Mitgliedschaftsformulare mit Client- und Server-Validierung.
+
+11) Authentifizierungs-Flow implementieren
+- JWT / Session, OAuth oder WebAuthn falls benötigt; Token-Handling sicher speichern.
+
+12) API-Client implementieren
+- Einheitlicher HTTP-Client, Error-Handling, Retry-Strategien, Pagination.
+
+13) Bilderupload & Storage einrichten
+- Multi-part Upload, Progress, Bildkompression, lokale Cache-Strategie.
+
+14) Offline-Support und Caching
+- Caching von API-Responses, Bild-Caching, Sync-Strategie für Formulare.
+
+15) Lokalisierung und Texte prüfen
+- Alle statischen Texte extrahieren, deutsche Strings prüfen und in Resource-Files ablegen.
+
+16) Accessibility-Prüfung und Anpassungen
+- Farbkontrast, Touch-Targets, Screenreader-Labels.
+
+17) Unit- und UI-Tests schreiben
+- Komponenten- und Integrations-Tests, E2E (falls möglich).
+
+18) Performance-Optimierung durchführen
+- Bilder, Netzwerk, Render-Perf.
+
+19) CI/CD für Builds einrichten
+- GitHub Actions / GitLab CI: Build, Test, Lint, Release.
+
+20) Play Store Release vorbereiten
+- App-Icons, Screenshots, Privacy-Policy, Datensparsamkeit.
+
+21) Monitoring & Crash-Reporting einrichten
+- Sentry / Firebase Crashlytics, Analytics.
+
+22) Dokumentation: Setup & Architektur
+- README, Architekturdiagramm, API-Spec, Onboarding-Guide.
+
+23) Design Review und Abnahme
+- UX/Design-Review mit Stakeholdern.
+
+24) Launch und Feedbackrunde durchführen
+- Release-Notes, Feedback-Formular, Bug-Fixing-Plan.
+
+
+Datei erstellt: Bitte bestätige, wenn ich mit der in-depth Analyse der Codebasis und Assets beginnen soll (Suche nach Farben, verwendeten Komponenten, Images, Fonts, relevanten Scripts).

ANDROID_REPO_ENDPOINTS.md

@@ -0,0 +1,58 @@
+Repo API Endpoints — Übersicht
+
+Hinweis: Viele Frontend-Requests verwenden relative Pfade (`/api/...`) und Nuxt's `NUXT_PUBLIC_BASE_URL`.
+
+Öffentliche/Frontend-Endpunkte (häufig genutzt):
+- GET /api/config
+- GET /api/news-public
+- GET /api/news
+- GET /api/termine
+- GET /api/spielplaene
+- GET /api/spielplan
+- GET /api/mannschaften
+- GET /api/galerie
+- GET /api/media/galerie/{id}
+- GET /api/personen/{filename}?width=...&height=...
+- POST /api/contact
+- POST /api/news (CMS)
+
+Galerie / Media:
+- POST /api/galerie/upload
+- GET /api/galerie/list
+- GET /api/galerie/[id]
+- DELETE /api/galerie/[id]
+
+Authentifizierung:
+- POST /api/auth/login
+- POST /api/auth/logout
+- POST /api/auth/register
+- POST /api/auth/reset-password
+- GET  /api/auth/status
+- POST /api/auth/passkeys/authentication-options  (Passkeys start: server returns WebAuthn options)
+- POST /api/auth/passkeys/login  (Passkeys finish: credential verification)
+
+CMS / geschützte Endpunkte (erfordern Auth):
+- GET /api/cms/* (z.B. /api/cms/users/list, /api/cms/contact-requests)
+- POST /api/cms/save-csv
+- POST /api/cms/upload-spielplan-pdf
+- POST /api/cms/satzung-upload
+- POST /api/members, DELETE /api/members, POST /api/members/bulk
+- POST /api/membership/update-status
+- POST /api/termine-manage, DELETE /api/termine-manage, GET /api/termine-manage
+
+Weitere (Datei-Uploads, Personen):
+- POST /api/personen/upload
+- GET /api/app/version
+- Various CMS-specific routes under /api/cms
+
+Auth-Anforderungen & Hinweise:
+- Frontend nutzt `$fetch('/api/...')` (Nuxt) — serverseitig vermutlich Session-Cookie oder JWT.
+- `stores/auth.js` verwendet `/api/auth/status` to check login state and `passkeyLogin()` which calls `/api/auth/passkeys/*`.
+- Passkeys-Flow verwendet `@simplewebauthn/browser` on web; Android port should support FIDO2 / Passkeys (Google Passkeys API) or provide password fallback.
+- CMS- und Manage-Endpunkte require authentication and role checks (admin/vorstand etc.).
+
+Empfehlung für Android-Client:
+- Nutze Retrofit/OkHttp mit anpassbarem Auth-Interceptor (Cookie-jar or token storage). Prüfe, ob Server bevorzugt Cookies (then use CookieJar) or JWT Authorization header.
+- Implementiere Passkeys via Android FIDO2 / Passkeys APIs as optional fast-login path; for servers expecting WebAuthn payloads adapt encoding accordingly.
+
+Datei automatisch erzeugt — wenn du möchtest, kann ich nun alle Dateien in `public/` und `assets/` auflisten und exportieren (Bilder, Fonts, PDFs).

android-app/app/build.gradle.kts

@@ -0,0 +1,68 @@
+plugins {
+    id("com.android.application")
+    id("org.jetbrains.kotlin.android")
+    id("dagger.hilt.android.plugin")
+}
+
+android {
+    namespace = "de.harheimertc"
+    compileSdk = 34
+
+    defaultConfig {
+        applicationId = "de.harheimertc"
+        minSdk = 24
+        targetSdk = 34
+        versionCode = 1
+        versionName = "0.1.0"
+    }
+
+    buildFeatures {
+        compose = true
+    }
+
+    composeOptions {
+        kotlinCompilerExtensionVersion = "1.5.3"
+    }
+
+    kotlinOptions {
+        jvmTarget = "17"
+    }
+}
+
+dependencies {
+    implementation("androidx.core:core-ktx:1.10.1")
+    implementation("androidx.appcompat:appcompat:1.6.1")
+
+    // Compose
+    implementation("androidx.compose.ui:ui:1.5.0")
+    implementation("androidx.compose.material3:material3:1.1.0")
+    implementation("androidx.navigation:navigation-compose:2.6.0")
+
+    // Lifecycle
+    implementation("androidx.lifecycle:lifecycle-runtime-ktx:2.6.1")
+    implementation("androidx.lifecycle:lifecycle-viewmodel-compose:2.6.1")
+
+    // Hilt
+    implementation("com.google.dagger:hilt-android:2.46.1")
+    kapt("com.google.dagger:hilt-compiler:2.46.1")
+
+    // Networking
+    implementation("com.squareup.retrofit2:retrofit:2.9.0")
+    implementation("com.squareup.okhttp3:okhttp:4.11.0")
+    implementation("com.squareup.retrofit2:converter-moshi:2.9.0")
+
+    // Coil
+    implementation("io.coil-kt:coil-compose:2.4.0")
+
+    // Room
+    implementation("androidx.room:room-runtime:2.6.1")
+    kapt("androidx.room:room-compiler:2.6.1")
+    implementation("androidx.room:room-ktx:2.6.1")
+
+    // WorkManager, DataStore
+    implementation("androidx.work:work-runtime-ktx:2.8.1")
+    implementation("androidx.datastore:datastore-preferences:1.0.0")
+
+    // Testing (skeleton)
+    testImplementation("junit:junit:4.13.2")
+}

android-app/app/src/main/AndroidManifest.xml

@@ -0,0 +1,15 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="de.harheimertc">
+
+    <application
+        android:label="HarheimerTC"
+        android:icon="@mipmap/ic_launcher">
+        <activity android:name="de.harheimertc.MainActivity"
+            android:exported="true">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+</manifest>

android-app/app/src/main/java/de/harheimertc/MainActivity.kt

@@ -0,0 +1,21 @@
+package de.harheimertc
+
+import android.os.Bundle
+import androidx.activity.ComponentActivity
+import androidx.activity.compose.setContent
+import androidx.compose.material3.Text
+import androidx.compose.ui.tooling.preview.Preview
+
+class MainActivity : ComponentActivity() {
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContent {
+            Text("HarheimerTC - App Scaffold")
+        }
+    }
+}
+
+@Preview
+fun PreviewMain() {
+    Text("Preview")
+}

android-app/app/src/main/res/values/colors.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <color name="primary_500">#ef4444</color>
+    <color name="primary_600">#dc2626</color>
+    <color name="accent_500">#71717a</color>
+</resources>

android-app/build.gradle.kts

@@ -0,0 +1,11 @@
+// Root build.gradle.kts (skeleton)
+plugins {
+    id("com.android.application") version "8.1.0" apply false
+    id("org.jetbrains.kotlin.android") version "1.9.10" apply false
+}
+
+buildscript {
+}
+
+allprojects {
+}

android-app/settings.gradle.kts

@@ -0,0 +1,2 @@
+rootProject.name = "harheimertc-android"
+include(":app")