Hinweis: Der Beitrag wurde von KI entworfen und manuell nachbearbeitet. Er beschreibt ein real aufgebautes Projekt; Zugangsdaten, IP-Adressen und Gerätenamen wurden anonymisiert.
Update 24.02.2026: Bash-Script erweitert
Der Amazon Fire TV Stick ist eigentlich nicht dafür gedacht, sich wie ein klassischer TV-Receiver zu verhalten.
Nach dem Einschalten landet man immer im Amazon-Launcher – die gewünschte TV-App muss jedes Mal manuell gestartet werden.
Ziel dieses Projekts war es daher, nach dem Einschalten des Fire TV Sticks automatisch eine TV-App zu starten:
- ohne Root
- ohne Launcher-Ersatz
- ohne zusätzliche Apps auf dem Fire TV
- stabil und reproduzierbar
Die Lösung nutzt ADB über das Netzwerk und einen externen Linux-Rechner, der ohnehin dauerhaft läuft (z. B. Home-Server oder Raspberry Pi).
Wichtige Einschränkung vorab
Der Fire TV Stick selbst bietet keine Autostart-Funktion für Apps.
Alles, was hier beschrieben wird, ist ein externer Workaround.
Das bedeutet konkret:
- ein dauerhaft laufender Rechner ist zwingend erforderlich
- der Fire TV Stick muss per Netzwerk erreichbar sein
- die Lösung ist nicht offiziell unterstützt, funktioniert im Alltag aber zuverlässig
Voraussetzungen
Hardware / Umgebung
- Amazon Fire TV Stick
- dauerhaft laufender Linux-Rechner (Home-Server, Raspberry Pi, NAS o. Ä.)
- funktionierende Netzwerkverbindung zwischen beiden Geräten
Netzwerk
Der Fire TV Stick benötigt eine feste IP-Adresse.
Empfohlen: - feste Zuordnung im Router (DHCP-Reservierung)
Im gesamten Beitrag wird deshalb mit folgendem Platzhalter gearbeitet:
IP_DES_FIRESTICKS
Fire OS: Entwickleroptionen und ADB
Getestet mit:
- Amazon Fire TV Stick (3. Generation)
- Fire OS 7.7.0.8
Je nach Fire-OS-Version können sich Menübezeichnungen leicht unterscheiden.
Entwickleroptionen aktivieren
- Einstellungen → Mein Fire TV → Info
- Mehrfach auf „Fire TV Stick“ klicken, bis der Entwicklermodus freigeschaltet ist
ADB-Debugging aktivieren
- Einstellungen → Mein Fire TV → Entwickleroptionen
- ADB-Debugging auf EIN setzen
Hinweis:
„Apps aus unbekannten Quellen“ existiert bei neueren Fire-OS-Versionen nicht mehr global.
Beim ersten ADB-Zugriff erscheint stattdessen eine Sicherheitsabfrage auf dem Fernseher, die einmalig bestätigt werden muss.
ADB auf dem Linux-Rechner einrichten
ADB installieren (Beispiel Debian/Ubuntu):
sudo apt install adb
Verbindung zum Fire TV Stick herstellen:
adb connect IP_DES_FIRESTICKS:5555
Dabei steht IP_DES_FIRESTICKS für die feste IP-Adresse des eigenen Fire TV Sticks.
App-Name und Activity ermitteln
Um eine App gezielt starten zu können, benötigt man Paketname und Activity.
Alle installierten Pakete anzeigen:
adb shell pm list packages
Aktive App ermitteln (wenn sie gerade läuft):
adb shell dumpsys window | grep -E 'mCurrentFocus|mFocusedApp'
Beispiel:
de.o2tv.firetv/com.telefonica.video.stv.launcher.LauncherActivity
Die O₂-TV-App dient hier nur als Beispiel.
Das Vorgehen ist identisch für andere TV-Apps.
Autostart-Script (Bash)
Das Script läuft auf dem externen Linux-Rechner.
Es wartet, bis der Fire TV Stick erreichbar ist, prüft, ob Android vollständig gebootet ist, startet die App und bestätigt nach einer festen Wartezeit eine mögliche Profilabfrage.
#!/usr/bin/env bash
set -euo pipefail
FIRETV_IP="IP_DES_FIRESTICKS"
ADB_PORT="5555"
COMPONENT="PAKETNAME/ACTIVITY"
LAUNCHER="com.amazon.tv.launcher"
CHECK_INTERVAL=2 # Sekunden
OPEN_CONFIRM=3 # Port offen am Stück => "wirklich offen"
ADB_READY_TIMEOUT=60 # max warten bis adb devices "device"
BOOT_TIMEOUT=120 # max warten bis sys.boot_completed=1
COOLDOWN_SECONDS=120 # nach Start erstmal Ruhe
log() { echo "$(date -Is) $*"; }
is_open() {
nc -z -w1 "$FIRETV_IP" "$ADB_PORT" >/dev/null 2>&1
}
adb_is_device() {
adb devices | grep -q "${FIRETV_IP}:${ADB_PORT}[[:space:]]*device"
}
is_awake() {
# Prüft, ob das Gerät wirklich wach ist (nicht Standby/Dreaming)
adb shell dumpsys power 2>/dev/null | grep -q "mWakefulness=Awake"
}
boot_completed() {
adb shell getprop sys.boot_completed 2>/dev/null | tr -d '\r' | grep -q '^1$'
}
get_current_focus() {
adb shell dumpsys window | grep -E 'mCurrentFocus|mFocusedApp' | grep -oE '[a-zA-Z0-9._]+/[a-zA-Z0-9._]+' | cut -d'/' -f1 | head -n 1
}
was_open=0
open_streak=0
last_start=0
while true; do
if is_open; then
open_streak=$((open_streak+1))
else
open_streak=0
fi
open_now=0
if [ "$open_streak" -ge "$OPEN_CONFIRM" ]; then
open_now=1
fi
# Flanke: geschlossen -> offen (Netzwerkseitig)
if [ "$was_open" -eq 0 ] && [ "$open_now" -eq 1 ]; then
now=$(date +%s)
if [ $((now - last_start)) -lt "$COOLDOWN_SECONDS" ]; then
log "ADB port open, but cooldown active. Skipping."
else
log "ADB port is open. Connecting and checking state..."
# 1) Warten bis adb wirklich "device" ist
start_ts=$(date +%s)
while true; do
adb connect "${FIRETV_IP}:${ADB_PORT}" >/dev/null 2>&1 || true
if adb_is_device; then break; fi
if [ $(( $(date +%s) - start_ts )) -ge "$ADB_READY_TIMEOUT" ]; then
log "ADB not ready. Giving up."
break
fi
sleep 2
done
if adb_is_device; then
# ZUSATZ-CHECK: Ist das Gerät wirklich wach?
if ! is_awake; then
log "Device is in Standby (not Awake). Aborting."
# Wir setzen was_open auf 1, damit die Flanke erst bei echtem Aus/An wieder triggert
# Alternativ auf 0 lassen, wenn du willst, dass er es alle 2 Sek probiert
was_open=1
adb disconnect "${FIRETV_IP}:${ADB_PORT}" >/dev/null 2>&1
sleep "$CHECK_INTERVAL"
continue
fi
# 2) Warten bis Android wirklich fertig gebootet ist
log "Device is Awake. Waiting for boot_completed..."
boot_ts=$(date +%s)
while true; do
if boot_completed; then break; fi
if [ $(( $(date +%s) - boot_ts )) -ge "$BOOT_TIMEOUT" ]; then
log "Boot timeout. Starting Anyway."
break
fi
sleep 2
done
# 3) Fokus-Check
CURRENT_FOCUS=$(get_current_focus)
log "Current Focus: [$CURRENT_FOCUS]"
if [ "$CURRENT_FOCUS" = "$LAUNCHER" ] || [ -z "$CURRENT_FOCUS" ]; then
log "Launcher detected. Starting O2 TV..."
adb shell am start -n "$COMPONENT" >/dev/null 2>&1 || true
sleep 25
adb shell input keyevent 23 >/dev/null 2>&1 || true
last_start=$(date +%s)
else
log "Blocked: Another app ($CURRENT_FOCUS) is active."
fi
fi
fi
fi
was_open="$open_now"
sleep "$CHECK_INTERVAL"
done
systemd-Integration
Script nach /usr/local/bin kopieren und ausführbar machen:
sudo chmod +x /usr/local/bin/firetv-autostart.sh
Service-Datei anlegen:
/etc/systemd/system/firetv-autostart.service
Inhalt:
[Unit]
Description=Fire TV Stick Autostart per ADB
After=network-online.target
Wants=network-online.target
[Service]
ExecStart=/usr/local/bin/firetv-autostart.sh
Restart=always
RestartSec=10
[Install]
WantedBy=multi-user.target
Service aktivieren:
sudo systemctl daemon-reload
sudo systemctl enable firetv-autostart.service
sudo systemctl start firetv-autostart.service
Einordnung ins Smart Home
Der externe Rechner läuft in meinem Fall ohnehin dauerhaft – unter anderem für Home Assistant.
Der Fire-TV-Autostart ist damit kein isolierter Sonderfall, sondern Teil eines größeren Smart-Home-Setups.
Weitere ähnliche Projekte finden sich in der
Smart-Home-Kategorie.
Fazit
Der Amazon Fire TV Stick ist nicht dafür gedacht, TV-Apps wie ein klassischer Receiver automatisch zu starten.
Mit einem dauerhaft laufenden Linux-System, ADB und einer festen IP-Adresse lässt sich dieses Verhalten dennoch zuverlässig nachbilden.
Die Lösung ist pragmatisch, nicht offiziell und technisch etwas schmutzig – funktioniert bei mir aber zuverlässig.