# MYP im Kiosk-Modus

Diese Anleitung beschreibt, wie MYP (Manage Your Printer) auf einem Raspberry Pi 4 im Kiosk-Modus eingerichtet wird, sodass das System beim Booten automatisch startet.

## Voraussetzungen

- Raspberry Pi 4 (oder kompatibel) mit Raspbian/Raspberry Pi OS
- Internetverbindung für die Installation (nach der Installation wird keine Verbindung mehr benötigt)
- Bildschirm, Tastatur und Maus für die Einrichtung

## Komponenten des Kiosk-Modus

Die Kiosk-Einrichtung besteht aus mehreren Komponenten:

1. **Flask-Backend-Dienst**: Systemd-Service zum Starten der MYP-Anwendung
2. **Chromium im Kiosk-Modus**: Browserinstanz, die das Dashboard anzeigt
3. **Watchdog**: Überwacht den Browser und das Backend, startet bei Bedarf neu

## Automatische Installation

Für die automatische Installation kann das mitgelieferte Setup-Script verwendet werden:

```bash
chmod +x setup.sh
./setup.sh
```

Dieses Script führt alle notwendigen Schritte aus:
- Installation der benötigten Pakete
- Kopieren der MYP-Anwendung nach `/opt/myp`
- Einrichtung der Python-Umgebung und Installation der Abhängigkeiten
- Konfiguration der Systemd-Dienste
- Einrichtung des Kiosk-Modus
- Einrichtung des Watchdogs

Nach der Ausführung des Scripts muss noch der automatische Login aktiviert werden:
```bash
sudo raspi-config
# 1 System Options → S5 Boot/Auto Login → B4 Desktop Autologin
```

## Manuelle Installation

Falls eine manuelle Installation bevorzugt wird, können die folgenden Schritte ausgeführt werden:

### 1. Pakete installieren

```bash
sudo apt update
sudo apt install -y python3 python3-pip python3-venv chromium-browser \
                    unclutter xdotool xscreensaver git
```

### 2. MYP nach /opt/myp kopieren

```bash
sudo mkdir -p /opt/myp
sudo chown $USER:$USER /opt/myp
cp -r ./myp/* /opt/myp
cd /opt/myp
```

### 3. Python-Umgebung und Abhängigkeiten einrichten

```bash
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
```

### 4. Systemd-Dienst für das Flask-Backend

Datei erstellen: `/etc/systemd/system/myp.service`

```ini
[Unit]
Description=MYP Flask Backend
After=network-online.target
Wants=network-online.target

[Service]
User=pi
WorkingDirectory=/opt/myp
ExecStart=/opt/myp/.venv/bin/python /opt/myp/app.py
Restart=always
Environment=PYTHONUNBUFFERED=1

[Install]
WantedBy=multi-user.target
```

Dienst aktivieren:

```bash
sudo systemctl daemon-reload
sudo systemctl enable --now myp.service
```

### 5. Kiosk-Script einrichten

Datei erstellen: `/home/pi/kiosk.sh`

```bash
#!/usr/bin/env bash

# Bildschirm-Blanking verhindern
xset s off
xset s noblank
xset -dpms

# Mauszeiger ausblenden
unclutter -idle 0.5 -root &

# Chromium-Crash-Dialoge unterdrücken
sed -i 's/"exited_cleanly":false/"exited_cleanly":true/' \
    "$HOME/.config/chromium/Default/Preferences" 2>/dev/null || true
sed -i 's/"exit_type":"Crashed"/"exit_type":"Normal"/' \
    "$HOME/.config/chromium/Default/Preferences" 2>/dev/null || true

# Browser starten
chromium-browser --kiosk --noerrdialogs --disable-infobars \
                 --window-position=0,0 --app=http://localhost:5000/ &
```

Ausführbar machen:

```bash
chmod +x /home/pi/kiosk.sh
```

### 6. Systemd-User-Dienst für den Browser

Verzeichnis erstellen:

```bash
mkdir -p /home/pi/.config/systemd/user
```

Datei erstellen: `/home/pi/.config/systemd/user/kiosk.service`

```ini
[Unit]
Description=Chromium Kiosk
PartOf=graphical-session.target

[Service]
Type=forking
ExecStart=/home/pi/kiosk.sh
Restart=on-abort

[Install]
WantedBy=xsession.target
```

Dienst aktivieren:

```bash
systemctl --user daemon-reload
systemctl --user enable kiosk.service
sudo loginctl enable-linger pi
```

### 7. Watchdog einrichten

Datei erstellen: `/home/pi/watchdog.sh`

```bash
#!/usr/bin/env bash
# MYP Watchdog für Chromium Browser

# Funktion zum Loggen von Nachrichten
log() {
  echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" >> /home/pi/myp-watchdog.log
}

# Prüfen, ob Chromium läuft
if ! pgrep -x "chromium-browse" > /dev/null; then
  log "Chromium nicht gefunden - starte neu"
  
  # Alle eventuell noch vorhandenen Chromium-Prozesse beenden
  pkill -f chromium || true
  
  # Warten bis alle Prozesse beendet sind
  sleep 2
  
  # Kiosk-Script neu starten
  /home/pi/kiosk.sh
  
  log "Chromium neugestartet"
fi

# Prüfen, ob MYP Flask-Dienst läuft
if ! systemctl is-active --quiet myp.service; then
  log "MYP Flask-Dienst ist nicht aktiv - starte neu"
  
  # Dienst neustarten
  sudo systemctl restart myp.service
  
  log "MYP Flask-Dienst neugestartet"
fi

exit 0
```

Ausführbar machen und Cron-Job einrichten:

```bash
chmod +x /home/pi/watchdog.sh
(crontab -l 2>/dev/null || echo "") | grep -v "watchdog.sh" | { cat; echo "*/5 * * * * /home/pi/watchdog.sh > /dev/null 2>&1"; } | crontab -
```

### 8. Automatischen Desktop-Login einschalten

```bash
sudo raspi-config
# 1 System Options → S5 Boot/Auto Login → B4 Desktop Autologin
```

### 9. Bildschirm nie ausschalten

```bash
sudo sed -i 's/#BLANK_TIME=.*/BLANK_TIME=0/' /etc/xdg/lxsession/LXDE-pi/autostart
```

## Ablauf beim Booten

1. Der Raspberry Pi startet und fährt bis zum Multi-User-Target hoch
2. `myp.service` wird gestartet und das Flask-Backend sowie der Plug-Scheduler laufen
3. LightDM startet und meldet den Benutzer `pi` automatisch an
4. Nach dem Anmelden wird der User-Scope geladen und `kiosk.service` gestartet
5. `kiosk.sh` startet Chromium im Kiosk-Modus und öffnet die MYP-Oberfläche
6. Der Watchdog-Cron-Job überwacht alle 5 Minuten, ob alles läuft

## Fehlerbehebung

- **MYP startet nicht**: `systemctl status myp.service` zeigt den Status des Dienstes
- **Browser startet nicht**: `systemctl --user status kiosk.service` zeigt den Status des Kiosk-Dienstes
- **Watchdog-Logs**: In `/home/pi/myp-watchdog.log` werden Probleme und Neustarts protokolliert

## Anpassung für andere Benutzer

Falls ein anderer Benutzer als `pi` verwendet wird, müssen folgende Anpassungen vorgenommen werden:

1. In `myp.service`: `User=` auf den entsprechenden Benutzer ändern
2. Pfade in `kiosk.sh` und `kiosk.service` anpassen
3. `loginctl enable-linger` für den entsprechenden Benutzer aktivieren 