# VulneraDoc

**VulneraDoc** ist eine native Android-Anwendung zur strukturierten,
offlinefähigen Wunddokumentation.

Die App ermöglicht die Verwaltung von Patienten und Wunddokumentationen,
unterstützt Fotos und digitale Unterschriften und erzeugt aus
abgeschlossenen Dokumentationen PDF-Dateien.

> **Projektstatus:** beta1.1

------------------------------------------------------------------------

## Features

### Patientenverwaltung

-   Patienten anlegen und bearbeiten
-   Stammdatenverwaltung:
    -   Vor- und Nachname
    -   Geburtsdatum
    -   Adresse
    -   bis zu drei Telefonnummern
-   Patienten durchsuchen
-   Datum der letzten Wunddokumentation anzeigen

### Wunddokumentation

Eine Wunddokumentation besteht aus mehreren datengetriebenen
Dokumentationsblöcken.

Jeder Block kann enthalten:

-   vordefinierte Checkboxen
-   Freitext
-   automatische Speicherung bei Änderungen

Zwischen den Dokumentationsblöcken kann auf Smartphone und Tablet
navigiert werden.

Bestehende Dokumentationen können:

-   bearbeitet
-   gelöscht
-   als Grundlage einer neuen Dokumentation fortgesetzt

werden.

Beim **Fortsetzen** wird eine neue Dokumentation aus dem vorherigen
Stand erzeugt. Die ursprüngliche Dokumentation bleibt unverändert
erhalten.

### Autosave

VulneraDoc benötigt keinen klassischen Speichern-Button.

Änderungen an Checkboxen werden unmittelbar persistiert. Freitexte
werden nach einem kurzen Debounce automatisch gespeichert.

Die lokale Datenbank bildet jederzeit den maßgeblichen persistierten
Stand der Dokumentation.

### Fotos

Einer Dokumentation können mehrere Fotos hinzugefügt werden.

Der Import erfolgt über den Android Photo Picker.

Importierte Bilder werden in den internen App-Speicher kopiert und
dadurch unabhängig von der ursprünglichen Datei in der Galerie
verwaltet.

### Digitale Unterschriften

Dokumentationen können direkt auf dem Android-Gerät per Finger oder
Stylus unterschrieben werden.

Das Datenmodell unterstützt mehrere Unterschriften pro Dokumentation,
beispielsweise für unterschiedliche Wundversorger.

### PDF-Export

Aus einer Dokumentation kann ein PDF erzeugt werden.

Dabei werden ausschließlich tatsächlich bearbeitete Dokumentationsblöcke
ausgegeben.

Das PDF enthält:

1.  Patienten- und Dokumentationsinformationen
2.  bearbeitete Dokumentationsblöcke
3.  vorhandene Unterschriften
4.  angehängte Fotos

Anschließend kann das PDF mit einem installierten PDF-Reader geöffnet
oder über den Android Sharesheet geteilt werden.

Das Dateinamensschema lautet:

``` text
Erstelldatum_Patientenname_Geburtsdatum.pdf
```

Beispiel:

``` text
2026-08-19_Max_Mustermann_1980-03-14.pdf
```

------------------------------------------------------------------------

## Offline First

VulneraDoc ist als vollständig offlinefähige Anwendung konzipiert.

Für die Kernfunktionen ist keine Internetverbindung erforderlich:

-   Patientenverwaltung
-   Dokumentationen erstellen und bearbeiten
-   Autosave
-   Fotos
-   Signaturen
-   Suche
-   PDF-Erzeugung

Eine optionale Synchronisation mehrerer Geräte innerhalb eines lokalen
WLANs ist für eine spätere Version vorgesehen, aber nicht Bestandteil
von Version 1.

------------------------------------------------------------------------

## Tech Stack

  Bereich         Technologie
  --------------- ------------------------------------
  Sprache         Kotlin
  UI              Jetpack Compose
  Design          Material 3
  UI-State        ViewModel + StateFlow
  Asynchronität   Kotlin Coroutines
  Persistenz      Room
  Datenbank       SQLite
  Navigation      Navigation Compose
  Fotos           Android Photo Picker
  PDF             `android.graphics.pdf.PdfDocument`
  Dateifreigabe   Android FileProvider

------------------------------------------------------------------------

## Architektur

VulneraDoc verwendet eine bewusst schlanke Schichtenarchitektur:

``` text
Jetpack Compose UI
        │
        ▼
    ViewModel
        │
        ▼
    Repository
        │
        ▼
       DAO
        │
        ▼
      Room
        │
        ▼
     SQLite
```

### UI

Jetpack Compose stellt den aktuellen Zustand dar und leitet
Benutzeraktionen an das jeweilige ViewModel weiter.

Die UI enthält keine SQL-, Datei- oder PDF-Logik.

### ViewModel

ViewModels verwalten den UI-State über `StateFlow` und koordinieren
Benutzeraktionen.

### Repository

Repositories bilden die zentrale Datenzugriffsschicht und koordinieren
DAOs sowie bei Bedarf lokale Dateien.

### DAO

DAOs enthalten ausschließlich Room-/SQLite-bezogene
Datenbankoperationen.

### Domain Model

Fachliche Datenmodelle sind von Room und Compose getrennt.

Room-spezifische Entities werden ausschließlich für die Persistenz
verwendet.

------------------------------------------------------------------------

## Datenmodell

Die wichtigsten Relationen sind:

``` text
Patient
   │
   │ 1:n
   ▼
Documentation
   │
   ├── 1:n ── BlockState
   │              │
   │              └── 1:n ── CheckItemState
   │
   ├── 1:n ── Photo
   │
   └── 1:n ── Signature
```

Als Primärschlüssel werden UUIDs verwendet.

Dies erleichtert insbesondere eine mögliche spätere Synchronisation
zwischen mehreren Geräten.

------------------------------------------------------------------------

## Historische Dokumentationen

Die Struktur einer neuen Wunddokumentation wird durch einen zentralen
`DocumentationCatalog` definiert.

Beim Erstellen einer Dokumentation werden die verwendeten:

-   Blocktitel
-   Checkboxtexte
-   Reihenfolgen

als Snapshot persistiert.

``` text
DocumentationCatalog
        │
        │ neue Dokumentation
        ▼
persistierter Snapshot
        │
        ▼
historische Dokumentation
```

Dadurch verändern spätere Änderungen des Dokumentationskatalogs nicht
rückwirkend bereits vorhandene Dokumentationen.

------------------------------------------------------------------------

## Projektstruktur

Die Anwendung orientiert sich an folgender Struktur:

``` text
app/
├── data/
│   ├── database/
│   ├── dao/
│   ├── entity/
│   ├── mapper/
│   └── repository/
│
├── domain/
│   └── model/
│
├── ui/
│   ├── documentation/
│   ├── patients/
│   ├── components/
│   ├── navigation/
│   └── theme/
│
├── media/
│   ├── photo/
│   └── signature/
│
├── pdf/
├── di/
└── MainActivity.kt
```

Dependency Injection wird zunächst ohne zusätzliches Framework über
einen zentralen `AppContainer` umgesetzt.

------------------------------------------------------------------------

## Datenschutz und lokale Speicherung

VulneraDoc verarbeitet sensible personenbezogene und medizinische Daten.

Daher gelten unter anderem folgende Architekturentscheidungen:

-   Patientendaten werden lokal gespeichert.
-   Fotos, Signaturen und PDFs werden bevorzugt im internen App-Speicher
    abgelegt.
-   Bilder werden nicht als BLOB in SQLite gespeichert.
-   Es werden keine Patientendaten in normalen Logs ausgegeben.
-   Es werden keine Analytics-Dienste verwendet.
-   Cloud-/Android-Backups werden deaktiviert bzw. bewusst
    eingeschränkt.
-   Unnötige Android-Berechtigungen werden vermieden.
-   `FLAG_SECURE` verhindert Screenshots und Recent-Apps-Vorschaubilder.
-   Dateien werden extern ausschließlich gezielt über `FileProvider` und
    `content://`-URIs freigegeben.

------------------------------------------------------------------------

## PDF und Schreibschutz

VulneraDoc erzeugt in Version 1 ein statisches PDF ohne interaktive
Formularfelder.

Mit „schreibgeschützt" ist derzeit **kein kryptographischer
Manipulationsschutz** gemeint.

Insbesondere sind in Version 1 nicht vorgesehen:

-   PDF-Owner-Passwort
-   Berechtigungsschutz
-   kryptographische PDF-Signatur

Die PDF-Erzeugung wird hinter einem `DocumentationPdfExporter`
abstrahiert, sodass die konkrete PDF-Implementierung später ausgetauscht
werden kann.

------------------------------------------------------------------------

## Entwicklung

### Voraussetzungen

-   Android Studio
-   Android SDK
-   JDK über Android Studio
-   Android-Gerät oder Android Emulator

------------------------------------------------------------------------

## Projektphasen

### Phase 1 -- Architektur

-   [x] Projektarchitektur
-   [x] Datenmodell
-   [x] Datenbankschema
-   [x] Navigation
-   [x] PDF-Konzept
-   [x] Autosave-Konzept
-   [x] Medien- und Signaturkonzept

### Phase 2 -- Projektgrundgerüst

-   [x] Android-Projekt
-   [x] Room-Datenbank
-   [x] Entities
-   [x] DAOs
-   [x] Repositories
-   [x] Navigation
-   [x] ViewModels

### Phase 3 -- Kernfunktionalität

-   [x] Patientenverwaltung
-   [x] Patientenliste
-   [x] Wunddokumentationsliste
-   [x] Dokumentation erstellen
-   [x] Dokumentationsblöcke
-   [x] Blocknavigation
-   [x] Autosave
-   [x] Dokumentation bearbeiten
-   [x] Dokumentation fortsetzen

### Phase 4 -- Medien

-   [x] Fotoimport
-   [x] Bildverwaltung
-   [x] Digitale Signatur
-   [x] Mehrere Signaturen

### Phase 5 -- PDF

-   [x] PDF-Exporter
-   [x] Dokumentationsblöcke
-   [x] Signaturen
-   [x] Fotoanhang
-   [x] PDF anzeigen
-   [x] PDF teilen

### Phase 6 -- Qualität und Stabilität

-   [ ] Unit Tests
-   [ ] Room Tests
-   [ ] UI Tests
-   [ ] Fehlerbehandlung
-   [ ] Tablet-Optimierung
-   [ ] Datenschutz-Review

### Phase 7 -- Multi-Device-Synchronisation

-   [ ] Geräteidentität und Pairing
-   [ ] Automatische Geräteerkennung im WLAN
-   [ ] Differenzabgleich / Sync-Protokoll
-   [ ] Patienten synchronisieren
-   [ ] Wunddokumentationen synchronisieren
-   [ ] Fotos synchronisieren
-   [ ] Konflikterkennung und Konfliktauflösung
-   [ ] Automatische Synchronisation
-   [ ] Sync-Status und manueller Fallback
-   [ ] Multi-Device- und Recovery-Tests