Home Assistant auf dem Samsung TV: Eigene Tizen-App bauen

Auf meinem Wohnzimmer-Fernseher läuft eine eigene App namens „Zuhause“. Sie zeigt Home Assistant in sechs Reitern und lässt sich komplett mit der normalen Samsung-Fernbedienung bedienen: Steuerkreuz, OK, Farbtasten und Zifferntasten. Einen Stick, einen Chromecast oder ein Tablet daneben brauche ich dafür nicht. Der Fernseher ist ein Samsung UE75MU6179 von 2017 mit Tizen 3.0, also schon ein ziemlich alter Kandidat. Meine App ist auf mein Haus zugeschnitten und kein Download. Was du hier bekommst, ist der Weg dorthin: Entwicklermodus, Tizen Studio, Zertifikat, ein eigener Home-Assistant-Benutzer und ein kleines Startgerüst mit Kacheln und Farbtasten, das du Schritt für Schritt zu deiner eigenen App ausbauen kannst. Alle Bilder der fertigen App stammen aus einem Demo-Modus mit einem erfundenen Haus.

Welcher Weg passt zu dir?

Es gibt drei naheliegende Ideen, Home Assistant auf einen Samsung-Fernseher zu bringen. Nur eine davon ist eine App auf dem Fernseher selbst.

Ich wollte keinen Stick und kein zweites Gerät. Deshalb die eigene App.

So sieht meine App aus

Die App hat sechs Reiter. Das steckt in jedem davon:

Tagsüber ist die App hell. Nach Sonnenuntergang schaltet sie auf ein dunkles Design, damit ein 75-Zoll-Bildschirm abends nicht wie eine Lampe ins Wohnzimmer strahlt.

Die Tasten der Fernbedienung

Bedient wird alles mit den Tasten, die sowieso auf der Fernbedienung sind:

Was du brauchst

• Samsung-Fernseher mit Tizen: Meiner ist ein UE75MU6179 von 2017 mit Tizen 3.0, darauf ist alles in diesem Artikel gelaufen.
• Rechner im selben Netz wie der Fernseher: Ich habe alles auf einem Mac gemacht, die Befehle unten sind für das Terminal am Mac.
• Tizen Studio 6.1 in der Version für die Kommandozeile („web-cli“, rund 280 MB): Es ist kostenlos und braucht kein Konto.
• Home Assistant im Heimnetz: Du brauchst seine IP-Adresse, also zum Beispiel 192.168.1.10:8123 statt homeassistant.local:8123.
• Bild für das App-Icon als PNG.

Schritt 1: Entwicklermodus am Fernseher einschalten

Ohne Entwicklermodus nimmt der Fernseher keine eigene App an. So beschreibt es Samsung:

1. Öffne am Fernseher Smart Hub und dort die Apps.
2. Tippe auf der Fernbedienung 1 2 3 4 5 ein. Es öffnet sich das Fenster für den Entwicklermodus („Developer mode“).
3. Schalte den Entwicklermodus ein und trage die IP-Adresse deines Rechners ein. Am Mac findest du sie in den Systemeinstellungen unter „Netzwerk“ bei der aktiven Verbindung.
4. Bestätige mit OK und starte den Fernseher neu.

Mein Tipp zum Neustart: Zieh kurz den Netzstecker. Dann startet der Fernseher sicher komplett neu.

Notiere dir auch die IP-Adresse des Fernsehers. Du findest sie in deinem Router. Gib Fernseher und Rechner dort am besten feste Adressen: Der Fernseher erwartet die Verbindung von genau der IP, die du eben eingetragen hast.

Samsungs Anleitung dazu gibt es auf Englisch.

Schritt 2: Tizen Studio für die Kommandozeile installieren

Die Installer liegen auf dem Tizen-Server. Dort gibt es auch Versionen für Linux (ubuntu-64.bin) und Windows (windows-64.exe). Ich habe nur die Mac-Version getestet.

Öffne das Terminal. Die erste Zeile nach cd lädt den Installer (rund 280 MB), die beiden danach starten ihn:

cd ~/Downloads
curl -LO https://download.tizen.org/sdk/Installer/tizen-studio_6.1/web-cli_Tizen_Studio_6.1_macos-64.bin
chmod +x web-cli_Tizen_Studio_6.1_macos-64.bin
./web-cli_Tizen_Studio_6.1_macos-64.bin --accept-license

Der Installer fragt, ob er in den Standardordner installieren soll. Antworte mit Y. Am Ende steht „Installation has been completed!“ und alles liegt in ~/tizen-studio.

Damit das Terminal die beiden Werkzeuge tizen und sdb findet:

export PATH="$HOME/tizen-studio/tools/ide/bin:$HOME/tizen-studio/tools:$PATH"
tizen version

Die Antwort ist Tizen CLI 2.5.25. Die export-Zeile gilt nur für dieses Terminalfenster. Soll sie dauerhaft gelten, schreib sie ans Ende der Datei ~/.zshrc.

Schritt 3: Zertifikat und Profil anlegen

Der Fernseher installiert nur signierte Apps. Du brauchst dafür ein Autorenzertifikat, das ist deine Unterschrift unter der App. Ersetze DeinPasswort und Dein Name durch eigene Werte:

tizen certificate -a HaTv -p 'DeinPasswort' -c DE -n 'Dein Name' -f hatv-autor
tizen security-profiles add -n HaTv -a ~/tizen-studio-data/keystore/author/hatv-autor.p12 -p 'DeinPasswort'

Der erste Befehl legt die Datei ~/tizen-studio-data/keystore/author/hatv-autor.p12 an. Der zweite baut daraus das Profil HaTv und nimmt das Distributor-Zertifikat von Tizen gleich mit dazu. Das Passwort legt Tizen Studio im Schlüsselbund deines Macs ab, beim Bauen fragt es nicht mehr danach.

Heb die .p12-Datei und das Passwort gut auf. Jedes Update deiner App muss mit demselben Autorenzertifikat signiert sein. Mit einem neuen Zertifikat musst du die App vorher vom Fernseher löschen.

Ablaufdatum: Stand November 2026 gilt ein so erzeugtes Autorenzertifikat nur bis zum 1. Januar 2027. Es hängt an der „Tizen Developers CA“, die mit Tizen Studio 6.1 ausgeliefert wird. Diese CA endet an diesem Tag. Was danach mit neuen Installationen und mit schon installierten Apps passiert, habe ich noch nicht getestet.

Schritt 4: Einen eigenen Benutzer in Home Assistant anlegen

Der Zugang der App liegt als Token im Paket auf dem Fernseher. Dafür bekommt der Fernseher einen eigenen Benutzer ohne Adminrechte, der sich nur im Heimnetz anmelden darf.

1. Öffne in Home Assistant Einstellungen und dann Personen. Wechsle oben in den Reiter Benutzer.
2. Klick auf Benutzer hinzufügen. Fülle „Anzeigename“, „Benutzername“, „Passwort“ und „Passwort bestätigen“ aus, zum Beispiel mit dem Anzeigenamen „Fernseher“.
3. Schalte Nur lokaler Zugriff ein („Anmeldung auf das lokale Netzwerk beschränken“). Administrator bleibt aus. Klick auf Erstellen.
4. Melde dich in einem privaten Browserfenster als dieser neue Benutzer an. Das Token gehört immer dem Benutzer, der es erstellt.
5. Klick unten links auf den Namen. Es öffnet sich das Profil, dort wechselst du in den Reiter Sicherheit.
6. Unter Langlebige Zugriffstoken klickst du auf Token erstellen, gibst als Name zum Beispiel „Zuhause-App“ ein und bestätigst.
7. Kopiere das Token sofort. Home Assistant sagt dazu selbst: „Kopiere dein Zugriffstoken. Er wird nicht wieder angezeigt werden.“

Das Token gilt zehn Jahre. Ein Benutzer ohne Adminrechte kann keine Einstellungen ändern, aber er kann jedes Gerät schalten: Home Assistant kennt keine Rechte pro Gerät.

Schritt 5: Das Startgerüst anlegen

Lege in deinem Benutzerordner einen Ordner HaTvStart an. Darin liegen am Ende vier Dateien:

• config.xml beschreibt die App für den Fernseher
• index.html ist die Seite mit dem Aussehen
• app.js verbindet sich mit Home Assistant und verarbeitet die Tasten
• icon.png ist das Icon in der App-Liste

config.xml

1<?xml version="1.0" encoding="UTF-8"?>
2<widget xmlns="http://www.w3.org/ns/widgets" xmlns:tizen="http://tizen.org/ns/widgets" id="http://example.com/ha-tv" version="1.0.0" viewmodes="maximized">
3    <tizen:application id="HaTvStart1.Zuhause" package="HaTvStart1" required_version="2.3"/>
4    <content src="index.html"/>
5    <feature name="http://tizen.org/feature/screen.size.all"/>
6    <icon src="icon.png"/>
7    <name>Zuhause</name>
8    <tizen:profile name="tv"/>
9    <access origin="*" subdomains="true"/>
10    <tizen:privilege name="http://tizen.org/privilege/internet"/>
11    <tizen:privilege name="http://tizen.org/privilege/tv.inputdevice"/>
12    <tizen:setting screen-orientation="landscape" context-menu="disable" background-support="disable" encryption="disable" install-location="auto" hwkey-event="enable"/>
13</widget>

HaTvStart1 ist die Paket-ID. Sie muss genau zehn Zeichen lang sein und darf nur Buchstaben und Ziffern enthalten. Die App selbst heißt dann HaTvStart1.Zuhause, diese Kennung brauchst du in Schritt 7. Die beiden Rechte erlauben der App das Netz (internet) und die Farbtasten (tv.inputdevice). Was in <name> steht, zeigt der Fernseher in der App-Liste.

index.html

1<!doctype html>
2<html lang="de">
3<head>
4<meta charset="utf-8">
5<meta name="viewport" content="width=1920, height=1080">
6<title>Zuhause</title>
7<style>
8  body { margin: 0; width: 1920px; height: 1080px; background: #15171c; color: #f2f2f2;
9         font-family: sans-serif; overflow: hidden; }
10  h1 { margin: 60px 80px 10px; font-size: 56px; font-weight: 300; }
11  #status { margin: 0 80px 40px; font-size: 28px; color: #9aa0aa; }
12  #tiles { margin: 0 60px; }
13  .tile { display: inline-block; vertical-align: top; box-sizing: border-box; width: 400px; height: 170px;
14          margin: 20px; padding: 28px 32px; border-radius: 18px; background: #23262d; }
15  .tile .name { font-size: 34px; }
16  .tile .state { margin-top: 18px; font-size: 44px; font-weight: 300; color: #9aa0aa; }
17  .tile.on .state { color: #ff9d3c; }
18  .tile.focus { box-shadow: 0 0 0 6px #f2f2f2; background: #30343c; }
19</style>
20</head>
21<body>
22<h1>Zuhause</h1>
23<div id="status">Verbinde mit Home Assistant …</div>
24<div id="tiles"></div>
25<script src="app.js"></script>
26</body>
27</html>

Der Fernseher zeigt die Seite mit 1920 mal 1080 Pixeln. Vier Kacheln passen nebeneinander, die fünfte beginnt eine neue Reihe.

app.js

1/* Home Assistant auf dem Samsung TV: ein Startgerüst.
2   Bewusst in altem JavaScript (ES5) geschrieben: so versteht es auch der Browser älterer Tizen-Fernseher. */
3
4// 1. Anpassen: Adresse von Home Assistant (IP, nicht .local) und der Token des TV-Benutzers
5var HA_URL = 'ws://192.168.1.10:8123/api/websocket';
6var HA_TOKEN = 'DEIN_TOKEN';
7
8// 2. Anpassen: deine Kacheln. OK auf einer Kachel schaltet die Entität um
9var TILES = [
10  { id: 'light.wohnzimmer_decke', name: 'Decke' },
11  { id: 'light.stehlampe', name: 'Stehlampe' },
12  { id: 'switch.lichterkette', name: 'Lichterkette' },
13  { id: 'cover.wohnzimmer', name: 'Rollo' }
14];
15
16// 3. Anpassen: was die Farbtasten auslösen (Skripte oder Szenen, leer lassen = Taste tut nichts)
17var COLOR_KEYS = {
18  red: 'script.alles_aus',
19  green: 'scene.gemuetlich',
20  yellow: 'script.filmabend',
21  blue: ''
22};
23
24var COLUMNS = 4;
25var states = {};
26var focus = 0;
27var ws = null;
28var msgId = 1;
29var retries = 0;
30
31var KEYS = { 37: 'left', 38: 'up', 39: 'right', 40: 'down', 13: 'ok', 10009: 'back',
32  403: 'red', 404: 'green', 405: 'yellow', 406: 'blue' };
33
34function setStatus(text) {
35  document.getElementById('status').textContent = text;
36}
37
38function stateText(tile) {
39  var st = states[tile.id];
40  if (!st) return '…';
41  if (st.s === 'on') return 'An';
42  if (st.s === 'off') return 'Aus';
43  if (st.s === 'open') return 'Offen';
44  if (st.s === 'closed') return 'Zu';
45  if (st.s === 'unavailable') return 'Nicht erreichbar';
46  return st.s;
47}
48
49function render() {
50  var html = '';
51  for (var i = 0; i < TILES.length; i++) {
52    var st = states[TILES[i].id];
53    var on = st && (st.s === 'on' || st.s === 'open');
54    html += '<div class="tile' + (on ? ' on' : '') + (i === focus ? ' focus' : '') + '">' +
55      '<div class="name">' + TILES[i].name + '</div>' +
56      '<div class="state">' + stateText(TILES[i]) + '</div></div>';
57  }
58  document.getElementById('tiles').innerHTML = html;
59}
60
61function send(msg) {
62  if (!ws || ws.readyState !== 1) {
63    setStatus('Keine Verbindung zu Home Assistant');
64    return;
65  }
66  msg.id = msgId++;
67  ws.send(JSON.stringify(msg));
68}
69
70function callService(domain, service, entityId) {
71  send({ type: 'call_service', domain: domain, service: service, target: { entity_id: entityId } });
72}
73
74function toggle(entityId) {
75  var domain = entityId.split('.')[0];
76  if (domain === 'cover') callService('cover', 'toggle', entityId);
77  else callService('homeassistant', 'toggle', entityId);
78}
79
80function trigger(entityId) {
81  if (!entityId) return;
82  callService(entityId.split('.')[0], 'turn_on', entityId);
83}
84
85// subscribe_entities schickt zuerst alle Zustände (a) und danach nur Änderungen (c)
86function onEntities(ev) {
87  var id;
88  for (id in ev.a || {}) states[id] = { s: ev.a[id].s, a: ev.a[id].a || {} };
89  for (id in ev.c || {}) {
90    var plus = ev.c[id]['+'];
91    if (states[id] && plus && plus.s !== undefined) states[id].s = plus.s;
92  }
93  for (var i = 0; i < (ev.r || []).length; i++) delete states[ev.r[i]];
94  render();
95}
96
97function connect() {
98  setStatus('Verbinde mit Home Assistant …');
99  msgId = 1;
100  ws = new WebSocket(HA_URL);
101  ws.onmessage = function (e) {
102    var m = JSON.parse(e.data);
103    if (m.type === 'auth_required') {
104      ws.send(JSON.stringify({ type: 'auth', access_token: HA_TOKEN }));
105    } else if (m.type === 'auth_invalid') {
106      setStatus('Token abgelehnt: ' + m.message);
107      ws.onclose = null;
108      ws.close();
109    } else if (m.type === 'auth_ok') {
110      retries = 0;
111      setStatus('Verbunden');
112      var ids = [];
113      for (var i = 0; i < TILES.length; i++) ids.push(TILES[i].id);
114      send({ type: 'subscribe_entities', entity_ids: ids });
115    } else if (m.type === 'event' && m.event) {
116      onEntities(m.event);
117    }
118  };
119  ws.onclose = function () {
120    setStatus('Keine Verbindung zu Home Assistant');
121    var wait = [3, 5, 10, 30][Math.min(retries, 3)];
122    retries++;
123    setTimeout(connect, wait * 1000);
124  };
125}
126
127function onKey(e) {
128  var key = KEYS[e.keyCode];
129  if (!key) return;
130  e.preventDefault();
131  var last = TILES.length - 1;
132  if (key === 'left' && focus > 0) focus--;
133  else if (key === 'right' && focus < last) focus++;
134  else if (key === 'up' && focus - COLUMNS >= 0) focus -= COLUMNS;
135  else if (key === 'down' && focus + COLUMNS <= last) focus += COLUMNS;
136  else if (key === 'ok') toggle(TILES[focus].id);
137  else if (key === 'back') {
138    try { tizen.application.getCurrentApplication().exit(); } catch (err) { /* nicht auf einem Fernseher */ }
139  }
140  else if (COLOR_KEYS[key] !== undefined) trigger(COLOR_KEYS[key]);
141  render();
142}
143
144function start() {
145  // Farbtasten kommen erst an, wenn die App sie anmeldet. Steuerkreuz, OK und Zurück kommen immer
146  var names = ['ColorF0Red', 'ColorF1Green', 'ColorF2Yellow', 'ColorF3Blue'];
147  for (var i = 0; i < names.length; i++) {
148    try { tizen.tvinputdevice.registerKey(names[i]); } catch (err) { /* nicht auf einem Fernseher */ }
149  }
150  document.addEventListener('keydown', onKey);
151  render();
152  connect();
153}
154
155start();

Oben in der Datei stehen die drei Stellen, die du anpasst:

1. HA_URL: die IP-Adresse deines Home Assistant mit Port. ws:// und /api/websocket bleiben stehen. Ich verbinde mich im Heimnetz unverschlüsselt über die IP. Eine Verbindung über HTTPS habe ich auf dem Fernseher nicht getestet.
2. HA_TOKEN: das Token aus Schritt 4.
3. TILES und COLOR_KEYS: deine Entitäten. Die IDs findest du in Home Assistant unter Einstellungen, Geräte & Dienste, Reiter Entitäten. Eine Kachel schaltet mit OK um, ein Rollo fährt auf oder zu. Eine Farbtaste startet ein Skript oder eine Szene. Steht bei einer Farbe nichts, tut die Taste nichts.

icon.png

Leg ein PNG als icon.png in den Ordner. Mein Icon hat 512 mal 423 Pixel. Am Mac bringt ein Befehl jedes Bild auf diese Größe:

sips -z 423 512 dein-bild.png --out ~/HaTvStart/icon.png

sips streckt das Bild dabei auf genau dieses Format. Nimm also am besten ein Bild, das ungefähr im Format 5 zu 4 vorliegt.

Schritt 6: Die App als Paket bauen

In einem neuen Terminalfenster gilt die export-Zeile aus Schritt 2 nicht mehr. Führe sie dann zuerst noch einmal aus, außer du hast sie in ~/.zshrc eingetragen.

cd ~/HaTvStart
tizen package -t wgt -s HaTv -o ../dist -- .

Das Paket liegt danach unter ~/dist/Zuhause.wgt. Der Name kommt aus <name> in der config.xml. Das -o ../dist ist wichtig: Ohne diese Angabe landet das Paket im Projektordner und beim nächsten Bauen steckt das alte Paket im neuen.

Schritt 7: Mit dem Fernseher verbinden und installieren

Der Fernseher ist an und im Entwicklermodus. Ersetze 192.168.1.20 in allen Befehlen durch die IP deines Fernsehers:

sdb connect 192.168.1.20
sdb devices

sdb devices zeigt eine Zeile mit der IP, dem Port 26101 und dem Modellnamen deines Fernsehers, bei mir UE75MU6179. Den Modellnamen brauchst du gleich zum Starten.

Jetzt kopierst du das Paket auf den Fernseher und installierst es:

sdb -s 192.168.1.20:26101 push ~/dist/Zuhause.wgt /home/owner/share/tmp/sdk_tools/HaTvStart1.Zuhause.wgt
sdb -s 192.168.1.20:26101 shell 0 vd_appinstall HaTvStart1.Zuhause /home/owner/share/tmp/sdk_tools/HaTvStart1.Zuhause.wgt

In der Ausgabe steht am Ende „install completed“. Starten kannst du die App aus der App-Liste des Fernsehers oder vom Rechner aus, mit deinem Modellnamen hinter -t:

tizen run -p HaTvStart1.Zuhause -t UE75MU6179

Nach jeder Änderung baust du mit Schritt 6 neu und installierst mit den beiden sdb-Befehlen darüber. Löschen geht so:

sdb -s 192.168.1.20:26101 shell 0 vd_appuninstall HaTvStart1.Zuhause

Schritt 8: Das Startgerüst ausbauen

Aus den vier Kacheln wird mit der Zeit eine richtige App. Diese Dinge habe ich beim Ausbau auf meinem Fernseher von 2017 gelernt, gemessen am Gerät selbst und nicht im Browser am Rechner:

Kein modernes CSS: kein CSS Grid, keine CSS-Variablen, kein gap in Flexbox, kein position: sticky. Das Layout läuft über Flexbox und inline-block, Farben stehen fertig ausgerechnet im CSS.

Schriften gehen nur als WOFF oder TTF, WOFF2 kennt der Fernseher leider nicht. Schriften, die aus einer variablen Schrift geschnitten sind, lehnt er komplett ab und zeigt still eine Ersatzschrift.

Farbtasten und Zifferntasten kommen erst bei der App an, wenn sie sie mit tizen.tvinputdevice.registerKey anmeldet. Das Startgerüst macht das für die Farbtasten. Die Zifferntasten heißen dort '1' bis '9'. Steuerkreuz, OK und Zurück kommen immer an.

Abonniere nur, was du zeigst: subscribe_entities mit einer Liste von IDs schickt nur Änderungen dieser Entitäten. Meine App abonniert gut 100 Entitäten statt aller Zustände im Haus, das hält den alten Fernseher flüssig.

Schriften, Icons und Bilder gehören in den Projektordner. Dann startet die App auch, wenn ein Dienst im Internet nicht erreichbar ist.

Man sitzt drei Meter weg. Bei mir ist keine Schrift kleiner als 20 Pixel, der Fokus ist ein dicker Rahmen.

Tipps und Troubleshooting

install failed[118]

Auf meinem Fernseher von 2017 kam dieser Fehler mit einem Samsung-Zertifikat. Mit dem Tizen-Zertifikat aus Schritt 3 ging es. Bei neueren Samsung-Fernsehern berichten Nutzer vom umgekehrten Fall: Dort klappt es erst mit einem Samsung-Zertifikat, das die Geräte-ID (DUID) des Fernsehers enthält. Wie du das erstellst, beschreibt Samsung in seiner Dokumentation.

Derselbe Fehler kommt auch, wenn du ein Update mit einem anderen Autorenzertifikat installierst. Dann die App zuerst löschen.

„Keine Verbindung zu Home Assistant“

Prüfe HA_URL. Der Fernseher löst keine .local-Namen auf, nimm die IP. Fernseher und Home Assistant müssen im selben Netz sein.

„Token abgelehnt“

Das Token in HA_TOKEN stimmt nicht oder der Benutzer wurde gelöscht. Hinter dem Doppelpunkt steht die Meldung von Home Assistant.

sdb findet den Fernseher nach einem Neustart nicht mehr

Starte sdb neu und verbinde dich wieder:

sdb kill-server
sdb start-server
sdb connect 192.168.1.20

Klappt sdb connect gar nicht, hat dein Rechner vielleicht eine neue IP bekommen. Dann musst du sie im Entwicklermodus am Fernseher neu eintragen.

„bad CPU type in executable“

Die Tizen-Werkzeuge sind für Intel-Macs gebaut. Auf einem Mac mit Apple-Chip laufen sie über Rosetta 2. Fehlt es, installierst du es mit softwareupdate --install-rosetta --agree-to-license.

Das alte Icon bleibt

Nach einem neuen icon.png zeigt der Fernseher weiter das alte. Erst Löschen und neu Installieren zeigt das neue.