iobroker.androidtvremote 0.0.0-stage → 0.2.7

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Henrik Schönhofen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,173 @@
-# Temporary Holding Version
+![Logo](admin/androidtvremote.png)
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+# ioBroker.androidtvremote
+
+[![NPM version](https://img.shields.io/npm/v/iobroker.androidtvremote.svg)](https://www.npmjs.com/package/iobroker.androidtvremote)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+Unofficial Android TV / Google TV remote control adapter for ioBroker using the Android TV Remote v2 protocol.
+
+The adapter maintains a persistent connection to an Android TV or Google TV device and provides remote control, power state, volume information, currently active application and optional Google Cast media metadata.
+
+## Features
+
+- Android TV Remote v2 protocol
+- No ADB or wireless debugging required
+- Secure pairing with Android TV / Google TV
+- Pairing certificate stored locally after initial pairing
+- Persistent Remote v2 connection
+- Automatic reconnect after connection loss
+- Power state
+- Volume and mute state
+- Currently active Android application
+- Friendly names for many common streaming apps
+- Unknown application package detection
+- Remote key commands
+- Text input
+- App/deep-link launching
+- Power control
+- Manual reconnect
+- Pairing reset
+- Optional Google Cast session and media metadata
+
+## Requirements
+
+- ioBroker
+- Node.js 22 or newer
+- Android TV or Google TV device supporting the Android TV Remote v2 protocol
+- ioBroker host and Android TV / Google TV device must be reachable over the network
+
+Default Android TV Remote v2 ports:
+
+| Function | Port |
+|----------|------|
+| Remote | 6466 |
+| Pairing | 6467 |
+
+## Installation
+
+Install the adapter in ioBroker and create an instance.
+
+Enter the IP address or hostname of the Android TV / Google TV device in the adapter configuration.
+
+## Pairing
+
+On the first connection, the Android TV / Google TV device displays a pairing code.
+
+Enter this code into:
+
+    androidtvremote.0.control.pairingCode
+
+After successful pairing, the certificate is stored locally by the adapter and normally no further pairing is required.
+
+To remove the stored pairing information and pair again, trigger:
+
+    androidtvremote.0.control.forgetPairing
+
+## Configuration
+
+| Setting | Description | Default |
+|---------|-------------|---------|
+| IP address / hostname | Android TV / Google TV device | |
+| Pairing name | Name shown on the TV during pairing | ioBroker |
+| Pairing port | Android TV Remote v2 pairing port | 6467 |
+| Remote port | Android TV Remote v2 remote-control port | 6466 |
+| Reconnect interval | Delay before reconnecting after a failed connection | 15 s |
+| Protocol debug | Enable additional protocol logging | disabled |
+| Cast media information | Enable optional Google Cast monitoring | enabled |
+| Cast polling interval | Interval for checking Cast media information | 5 s |
+
+## Datapoints
+
+### Information
+
+    info.connection
+    info.pairingRequired
+    info.powered
+    info.currentAppId
+    info.currentApp
+    info.currentAppUnknown
+    info.volume.level
+    info.volume.maximum
+    info.volume.muted
+
+`info.currentAppId` contains the original Android package name.
+
+`info.currentApp` provides a human-readable application name for many common applications, including Netflix, YouTube, Prime Video, ARD, ZDF, RTL+, MagentaTV, Joyn, Zattoo, waipu.tv, DAZN, Spotify, KiKA, WOW, Disney+ and Apple TV.
+
+Unknown package names are additionally written to `info.currentAppUnknown` so that the application mapping can easily be extended.
+
+### Controls
+
+    control.pairingCode
+    control.key
+    control.text
+    control.appLink
+    control.power
+    control.reconnect
+    control.forgetPairing
+
+### Google Cast
+
+When Cast monitoring is enabled:
+
+    info.cast.connection
+    info.cast.appId
+    info.cast.appName
+    info.media.title
+    info.media.subtitle
+    info.media.playerState
+    info.media.contentId
+
+## Media metadata
+
+Android TV Remote v2 itself provides information about the currently active Android application, but does not expose complete media metadata for every native Android TV application.
+
+The optional Cast integration can provide title, subtitle and playback state when an active Google Cast receiver session exposes this information.
+
+Therefore, media metadata may not be available for applications that are running natively on the Android TV device.
+
+## Connection handling
+
+The adapter keeps the Android TV Remote v2 connection open instead of periodically disconnecting and rebuilding it.
+
+Protocol ping requests are handled by the underlying Remote v2 library.
+
+If the initial connection fails or an established connection is lost, the adapter retries the connection using the configured reconnect interval.
+
+## Changelog
+
+### 0.2.7 (2026-10-09)
+
+- Added automated GitHub Actions release workflow
+- Prepared npm publishing through Trusted Publishing
+- Updated release documentation and changelog
+- No changes to adapter runtime behavior
+
+### 0.2.6 (2026-10-08)
+
+- Improved pairing credential persistence
+- Pairing certificates are no longer automatically deleted on `unpaired` events
+- Pairing information can still be removed manually using `control.forgetPairing`
+
+
+### 0.2.5 (2026-10-07)
+
+- Improved Remote v2 connection handling
+- Persistent Remote v2 session instead of periodically forcing reconnects
+- Failed initial connections are detected and retried automatically
+- Protocol ping handling is left to the Android TV Remote v2 library
+- Improved reconnect behavior after temporary network/device unavailability
+- Android TV / Google TV power, volume and current-app states
+- Friendly application-name mapping
+- Optional Google Cast media metadata
+- Remote keys, text input, app links and power control
+- Secure pairing with locally stored certificate
+
+## License
+
+MIT License
+
+Copyright (c) 2026 Henrik Schönhofen (backfisch88)
+
+See [LICENSE](LICENSE) for the full license text.

package/admin/jsonConfig.json

@@ -0,0 +1,67 @@
+{
+  "type": "panel",
+  "items": {
+    "host": {
+      "type": "text",
+      "label": "IP-Adresse / Hostname",
+      "help": "IP-Adresse oder Hostname des Android TV / Google TV",
+      "sm": 6,
+      "newLine": true
+    },
+    "deviceName": {
+      "type": "text",
+      "label": "Anzeigename beim Pairing",
+      "default": "ioBroker",
+      "sm": 6
+    },
+    "pairingPort": {
+      "type": "number",
+      "label": "Pairing-Port",
+      "default": 6467,
+      "min": 1,
+      "max": 65535,
+      "sm": 4,
+      "newLine": true
+    },
+    "remotePort": {
+      "type": "number",
+      "label": "Remote-Port",
+      "default": 6466,
+      "min": 1,
+      "max": 65535,
+      "sm": 4
+    },
+    "reconnectSeconds": {
+      "type": "number",
+      "label": "Reconnect nach Sekunden",
+      "default": 15,
+      "min": 5,
+      "max": 3600,
+      "sm": 4
+    },
+    "debugProtocol": {
+      "type": "checkbox",
+      "label": "Protokoll-Debug aktivieren",
+      "default": false,
+      "newLine": true
+    },
+    "hint": {
+      "type": "staticText",
+      "text": "Beim ersten Start zeigt der Fernseher einen Pairing-Code. Diesen unter Objekte → androidtvremote.X → control → pairingCode eintragen. Danach wird das Zertifikat lokal gespeichert."
+    },
+    "enableCast": {
+      "type": "checkbox",
+      "label": "Cast-Medieninfos aktivieren",
+      "default": true,
+      "newLine": true
+    },
+    "castPollSeconds": {
+      "type": "number",
+      "label": "Cast-Abfrage alle Sekunden",
+      "default": 5,
+      "min": 3,
+      "max": 60,
+      "sm": 4
+    }
+  }
+}

package/io-package.json

@@ -0,0 +1,109 @@
+{
+  "common": {
+    "name": "androidtvremote",
+    "version": "0.2.7",
+    "titleLang": {
+      "en": "Android TV Remote",
+      "de": "Android TV Remote",
+      "ru": "Android TV Remote",
+      "pt": "Android TV Remote",
+      "nl": "Android TV Remote",
+      "fr": "Android TV Remote",
+      "it": "Android TV Remote",
+      "es": "Android TV Remote",
+      "pl": "Android TV Remote",
+      "uk": "Android TV Remote",
+      "zh-cn": "Android TV Remote"
+    },
+    "desc": {
+      "en": "Control Android TV / Google TV via Android TV Remote v2 protocol without ADB",
+      "de": "Android TV / Google TV über das Android TV Remote v2 Protokoll ohne ADB steuern",
+      "ru": "Управление Android TV / Google TV через протокол Android TV Remote v2 без ADB",
+      "pt": "Controle Android TV / Google TV através do protocolo Android TV Remote v2 sem ADB",
+      "nl": "Bedien Android TV / Google TV via het Android TV Remote v2-protocol zonder ADB",
+      "fr": "Contrôlez Android TV / Google TV via le protocole Android TV Remote v2 sans ADB",
+      "it": "Controlla Android TV / Google TV tramite il protocollo Android TV Remote v2 senza ADB",
+      "es": "Controla Android TV / Google TV mediante el protocolo Android TV Remote v2 sin ADB",
+      "pl": "Sterowanie Android TV / Google TV przez protokół Android TV Remote v2 bez ADB",
+      "uk": "Керування Android TV / Google TV через протокол Android TV Remote v2 без ADB",
+      "zh-cn": "通过 Android TV Remote v2 协议控制 Android TV / Google TV，无需 ADB"
+    },
+    "authors": [
+      "Henrik Schönhofen <henrik.schoenhofen@icloud.com>"
+    ],
+    "license": "MIT",
+    "platform": "Javascript/Node.js",
+    "mode": "daemon",
+    "enabled": true,
+    "messagebox": true,
+    "compact": true,
+    "connectionType": "local",
+    "dataSource": "push",
+    "adminUI": {
+      "config": "json"
+    },
+    "dataFolder": "androidtvremote.%INSTANCE%",
+    "dependencies": [
+      {
+        "js-controller": ">=6.0.11"
+      }
+    ],
+    "globalDependencies": [
+      {
+        "admin": ">=7.7.22"
+      }
+    ],
+    "icon": "androidtvremote.png",
+    "keywords": [
+      "android tv",
+      "google tv",
+      "remote",
+      "androidtv",
+      "multimedia"
+    ],
+    "licenseInformation": {
+      "license": "MIT",
+      "type": "free"
+    },
+    "extIcon": "https://raw.githubusercontent.com/backfisch88/ioBroker.androidtvremote/main/admin/androidtvremote.png",
+    "readme": "https://github.com/backfisch88/ioBroker.androidtvremote/blob/main/README.md",
+    "loglevel": "info",
+    "tier": 3,
+    "type": "multimedia",
+    "news": {
+      "0.2.7": {
+        "en": "Added automated GitHub Actions release workflow for GitHub and npm publishing.",
+        "de": "Automatischen GitHub-Actions-Release-Workflow für Veröffentlichungen auf GitHub und npm eingerichtet."
+      },
+      "0.2.6": {
+        "en": "Improved pairing credential persistence. Credentials are no longer deleted automatically on unpaired events.",
+        "de": "Verbesserte Speicherung der Pairing-Zugangsdaten. Bei Unpaired-Ereignissen werden Zertifikate nicht mehr automatisch gelöscht."
+      },
+      "0.2.5": {
+        "en": "Initial release with Android TV Remote v2 support, secure pairing, power and volume states, current app detection, remote control commands and optional Google Cast media information.",
+        "de": "Erste Veröffentlichung mit Android TV Remote v2, sicherem Pairing, Power- und Lautstärkestatus, Erkennung der aktuellen App, Fernbedienungsbefehlen und optionalen Google-Cast-Medieninformationen.",
+        "ru": "Первый выпуск с поддержкой Android TV Remote v2, безопасным сопряжением и дистанционным управлением.",
+        "pt": "Versão inicial com suporte ao Android TV Remote v2, emparelhamento seguro e controlo remoto.",
+        "nl": "Eerste release met Android TV Remote v2-ondersteuning, veilige koppeling en afstandsbediening.",
+        "fr": "Première version avec prise en charge d’Android TV Remote v2, appairage sécurisé et télécommande.",
+        "it": "Prima versione con supporto Android TV Remote v2, associazione sicura e controllo remoto.",
+        "es": "Versión inicial con compatibilidad con Android TV Remote v2, emparejamiento seguro y control remoto.",
+        "pl": "Pierwsza wersja z obsługą Android TV Remote v2, bezpiecznym parowaniem i zdalnym sterowaniem.",
+        "uk": "Перший випуск із підтримкою Android TV Remote v2, безпечним сполученням і дистанційним керуванням.",
+        "zh-cn": "首个版本，支持 Android TV Remote v2、安全配对和远程控制。"
+      }
+    }
+  },
+  "native": {
+    "host": "",
+    "deviceName": "ioBroker",
+    "pairingPort": 6467,
+    "remotePort": 6466,
+    "reconnectSeconds": 15,
+    "debugProtocol": false,
+    "enableCast": true,
+    "castPollSeconds": 5
+  },
+  "objects": [],
+  "instanceObjects": []
+}

package/main.js

@@ -0,0 +1,567 @@
+'use strict';
+
+const utils = require('@iobroker/adapter-core');
+const fs = require('node:fs');
+const path = require('node:path');
+const { Client: CastClient, DefaultMediaReceiver } = require('castv2-client');
+
+class AndroidTvRemoteAdapter extends utils.Adapter {
+    constructor(options = {}) {
+        super({ ...options, name: 'androidtvremote' });
+
+        this.remote = null;
+        this.remoteModule = null;
+        this.reconnectTimer = null;
+        this.lastRemoteReady = 0;
+        this.stopping = false;
+        this.connecting = false;
+        this.pairingRequested = false;
+        this.dataDir = '';
+        this.credentialsFile = '';
+        this.lastPowered = null;
+        this.castClient = null;
+        this.castPlayer = null;
+        this.castTimer = null;
+        this.castConnecting = false;
+
+        this.on('ready', this.onReady.bind(this));
+        this.on('stateChange', this.onStateChange.bind(this));
+        this.on('unload', this.onUnload.bind(this));
+    }
+
+    async onReady() {
+        this.stopping = false;
+        await this.setStateAsync('info.connection', false, true);
+        await this.ensureObjects();
+        this.subscribeStates('control.*');
+
+        if (!this.config.host || !String(this.config.host).trim()) {
+            this.log.error('Bitte zuerst die IP-Adresse bzw. den Hostnamen des Android-TV-Geräts konfigurieren.');
+            return;
+        }
+
+        this.dataDir = utils.getAbsoluteInstanceDataDir(this);
+        this.credentialsFile = path.join(this.dataDir, 'credentials.json');
+        await fs.promises.mkdir(this.dataDir, { recursive: true });
+
+        try {
+            this.remoteModule = await import('@kud/androidtv-remote');
+        } catch (error) {
+            this.log.error(`Android-TV-Remote-Bibliothek konnte nicht geladen werden: ${this.errorText(error)}`);
+            return;
+        }
+
+        await this.connect();
+        this.startCastMonitor();
+    }
+
+    async ensureObjects() {
+        const defs = {
+            'info.connection': { name: 'Connected', type: 'boolean', role: 'indicator.connected', read: true, write: false, def: false },
+            'info.lastRemoteReady': { name: 'Last remote connection', type: 'number', role: 'value.time', read: true, write: false, def: 0 },
+            'info.pairingRequired': { name: 'Pairing required', type: 'boolean', role: 'indicator', read: true, write: false, def: false },
+            'info.powered': { name: 'Powered', type: 'boolean', role: 'indicator.power', read: true, write: false, def: false },
+            'info.currentAppId': { name: 'Current app package', type: 'string', role: 'text', read: true, write: false, def: '' },
+            'info.currentApp': { name: 'Current app', type: 'string', role: 'text', read: true, write: false, def: '' },
+            'info.currentAppUnknown': { name: 'Unknown current app package', type: 'string', role: 'text', read: true, write: false, def: '' },
+            'info.cast.connection': { name: 'Cast connected', type: 'boolean', role: 'indicator.connected', read: true, write: false, def: false },
+            'info.cast.appId': { name: 'Cast app ID', type: 'string', role: 'text', read: true, write: false, def: '' },
+            'info.cast.appName': { name: 'Cast app name', type: 'string', role: 'text', read: true, write: false, def: '' },
+            'info.media.title': { name: 'Media title', type: 'string', role: 'media.title', read: true, write: false, def: '' },
+            'info.media.subtitle': { name: 'Media subtitle', type: 'string', role: 'text', read: true, write: false, def: '' },
+            'info.media.playerState': { name: 'Media player state', type: 'string', role: 'media.state', read: true, write: false, def: '' },
+            'info.media.contentId': { name: 'Media content ID', type: 'string', role: 'text', read: true, write: false, def: '' },
+            'info.volume.level': { name: 'Volume level', type: 'number', role: 'level.volume', read: true, write: false, def: 0 },
+            'info.volume.maximum': { name: 'Maximum volume', type: 'number', role: 'value', read: true, write: false, def: 0 },
+            'info.volume.muted': { name: 'Muted', type: 'boolean', role: 'indicator.mute', read: true, write: false, def: false },
+            'control.pairingCode': { name: 'Pairing code', type: 'string', role: 'text', read: true, write: true, def: '' },
+            'control.key': { name: 'Remote key', type: 'string', role: 'text', read: true, write: true, def: '' },
+            'control.text': { name: 'Send text', type: 'string', role: 'text', read: true, write: true, def: '' },
+            'control.appLink': { name: 'Open app/deep link', type: 'string', role: 'text.url', read: true, write: true, def: '' },
+            'control.power': { name: 'Power target / toggle', type: 'boolean', role: 'switch.power', read: true, write: true, def: false },
+            'control.reconnect': { name: 'Reconnect', type: 'boolean', role: 'button', read: true, write: true, def: false },
+            'control.forgetPairing': { name: 'Forget pairing', type: 'boolean', role: 'button', read: true, write: true, def: false }
+        };
+
+        for (const [id, common] of Object.entries(defs)) {
+            await this.setObjectNotExistsAsync(id, { type: 'state', common, native: {} });
+        }
+    }
+
+    async loadCertificate() {
+        try {
+            const raw = await fs.promises.readFile(this.credentialsFile, 'utf8');
+            const parsed = JSON.parse(raw);
+            if (parsed && typeof parsed.key === 'string' && typeof parsed.cert === 'string') {
+                return parsed;
+            }
+        } catch (error) {
+            if (error && error.code !== 'ENOENT') {
+                this.log.warn(`Pairing-Zertifikat konnte nicht gelesen werden: ${this.errorText(error)}`);
+            }
+        }
+        return null;
+    }
+
+    async saveCertificate(cert) {
+        if (!cert || !cert.key || !cert.cert) return;
+        const tmp = `${this.credentialsFile}.tmp`;
+        await fs.promises.writeFile(tmp, JSON.stringify(cert, null, 2), { mode: 0o600 });
+        await fs.promises.rename(tmp, this.credentialsFile);
+        try { await fs.promises.chmod(this.credentialsFile, 0o600); } catch (_) {}
+    }
+
+    async deleteCertificate() {
+        try {
+            await fs.promises.unlink(this.credentialsFile);
+        } catch (error) {
+            if (error && error.code !== 'ENOENT') throw error;
+        }
+    }
+
+    async connect() {
+        if (this.stopping || this.connecting || !this.remoteModule) return;
+        this.connecting = true;
+        this.clearReconnect();
+
+        try {
+            if (this.remote) {
+                try { this.remote.stop(); } catch (_) {}
+                this.remote = null;
+            }
+
+            const cert = await this.loadCertificate();
+            const options = {
+                pairing_port: Number(this.config.pairingPort) || 6467,
+                remote_port: Number(this.config.remotePort) || 6466,
+                service_name: String(this.config.deviceName || 'ioBroker'),
+                debug: !!this.config.debugProtocol
+            };
+            if (cert) options.cert = cert;
+
+            const { createAndroidRemote } = this.remoteModule;
+            this.remote = createAndroidRemote(String(this.config.host).trim(), options);
+            this.attachRemoteEvents(this.remote);
+
+            this.log.info(`Verbinde mit Android TV ${this.config.host}:${options.remote_port} ...`);
+            const started = await this.remote.start();
+            if (!started) {
+                await this.setStateAsync('info.connection', false, true);
+                this.log.info(`Android TV derzeit nicht erreichbar – neuer Versuch in ${Math.max(5, Number(this.config.reconnectSeconds) || 15)} Sekunden.`);
+                if (this.remote) {
+                    try { this.remote.stop(); } catch (_) {}
+                    this.remote = null;
+                }
+                this.scheduleReconnect();
+            }
+        } catch (error) {
+            await this.setStateAsync('info.connection', false, true);
+            this.log.warn(`Verbindung fehlgeschlagen: ${this.errorText(error)}`);
+            this.scheduleReconnect();
+        } finally {
+            this.connecting = false;
+        }
+    }
+
+    attachRemoteEvents(remote) {
+        remote.on('secret', async () => {
+            this.pairingRequested = true;
+            await this.setStateAsync('info.pairingRequired', true, true);
+            await this.setStateAsync('info.connection', false, true);
+            this.log.info('Pairing erforderlich: Code vom Fernseher in control.pairingCode eintragen.');
+        });
+
+        remote.on('ready', async () => {
+            this.pairingRequested = false;
+            await this.setStateAsync('info.pairingRequired', false, true);
+            await this.setStateAsync('info.connection', true, true);
+            this.lastRemoteReady = Date.now();
+            await this.setStateAsync('info.lastRemoteReady', this.lastRemoteReady, true);
+            try {
+                await this.saveCertificate(remote.getCertificate());
+            } catch (error) {
+                this.log.warn(`Pairing-Zertifikat konnte nicht gespeichert werden: ${this.errorText(error)}`);
+            }
+            this.log.info('Android TV Remote verbunden.');
+        });
+
+        remote.on('powered', async powered => {
+            this.lastPowered = !!powered;
+            await this.setStateAsync('info.powered', !!powered, true);
+            await this.setStateAsync('control.power', !!powered, true);
+        });
+
+        remote.on('volume', async volume => {
+            if (!volume) return;
+            await this.setStateAsync('info.volume.level', Number(volume.level) || 0, true);
+            await this.setStateAsync('info.volume.maximum', Number(volume.maximum) || 0, true);
+            await this.setStateAsync('info.volume.muted', !!volume.muted, true);
+        });
+
+        remote.on('current_app', async app => {
+            const appId = typeof app === 'string'
+                ? app.trim()
+                : String(app?.packageName || app?.package || app?.app || '').trim();
+
+            if (!appId) return;
+
+            const mapped = this.appNameMap()[appId];
+            await this.setStateAsync('info.currentAppId', appId, true);
+            await this.setStateAsync('info.currentApp', mapped || this.friendlyAppName(appId), true);
+            await this.setStateAsync('info.currentAppUnknown', mapped ? '' : appId, true);
+        });
+
+        remote.on('unpaired', async () => {
+            await this.setStateAsync('info.connection', false, true);
+            await this.setStateAsync('info.pairingRequired', true, true);
+            this.pairingRequested = true;
+
+            // Gespeicherte Credentials hier NICHT löschen.
+            // Ein temporärer Verbindungs-/Authentifizierungsfehler darf nicht
+            // dazu führen, dass ein funktionierendes Pairing dauerhaft
+            // verloren geht. Credentials werden ausschließlich über
+            // control.forgetPairing bewusst gelöscht.
+            this.log.warn(
+                'Android TV meldet "unpaired". Gespeichertes Pairing bleibt erhalten. ' +
+                'Falls ein neues Pairing wirklich erforderlich ist, control.forgetPairing verwenden.'
+            );
+        });
+
+        remote.on('error', async error => {
+            if (this.stopping) return;
+            await this.setStateAsync('info.connection', false, true);
+            this.log.warn(`Android-TV-Protokollfehler: ${this.errorText(error)}`);
+            this.scheduleReconnect();
+        });
+    }
+
+    scheduleReconnect() {
+        if (this.stopping || this.reconnectTimer || this.pairingRequested) return;
+        const seconds = Math.max(5, Number(this.config.reconnectSeconds) || 15);
+        this.reconnectTimer = this.setTimeout(() => {
+            this.reconnectTimer = null;
+            void this.connect();
+        }, seconds * 1000);
+    }
+
+    clearReconnect() {
+        if (this.reconnectTimer) {
+            this.clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+    }
+
+    async onStateChange(id, state) {
+        if (!state || state.ack) return;
+        const prefix = `${this.namespace}.`;
+        if (!id.startsWith(prefix)) return;
+        const rel = id.slice(prefix.length);
+
+        try {
+            switch (rel) {
+                case 'control.pairingCode': {
+                    const code = String(state.val || '').trim();
+                    if (!code) return;
+                    if (!this.remote || !this.pairingRequested) {
+                        this.log.warn('Aktuell wartet der Adapter auf keinen Pairing-Code.');
+                    } else {
+                        const accepted = this.remote.sendCode(code);
+                        if (!accepted) this.log.warn('Pairing-Code konnte nicht gesendet werden.');
+                    }
+                    await this.setStateAsync(rel, '', true);
+                    break;
+                }
+
+                case 'control.key': {
+                    const key = String(state.val || '').trim();
+                    if (key) this.sendKey(key);
+                    await this.setStateAsync(rel, '', true);
+                    break;
+                }
+
+                case 'control.text': {
+                    const text = String(state.val ?? '');
+                    if (text && this.requireRemote()) this.remote.sendText(text);
+                    await this.setStateAsync(rel, '', true);
+                    break;
+                }
+
+                case 'control.appLink': {
+                    const link = String(state.val || '').trim();
+                    if (link && this.requireRemote()) this.remote.sendAppLink(link);
+                    await this.setStateAsync(rel, '', true);
+                    break;
+                }
+
+                case 'control.power': {
+                    const desired = !!state.val;
+                    if (this.requireRemote()) {
+                        if (this.lastPowered === null || desired !== this.lastPowered) {
+                            this.remote.sendPower();
+                        }
+                    }
+                    await this.setStateAsync(rel, desired, true);
+                    break;
+                }
+
+                case 'control.reconnect': {
+                    await this.setStateAsync(rel, false, true);
+                    await this.setStateAsync('info.connection', false, true);
+                    this.pairingRequested = false;
+                    await this.connect();
+                    break;
+                }
+
+                case 'control.forgetPairing': {
+                    await this.setStateAsync(rel, false, true);
+                    await this.deleteCertificate();
+                    this.pairingRequested = false;
+                    if (this.remote) {
+                        try { this.remote.stop(); } catch (_) {}
+                        this.remote = null;
+                    }
+                    await this.setStateAsync('info.connection', false, true);
+                    await this.setStateAsync('info.pairingRequired', false, true);
+                    this.log.info('Gespeichertes Pairing wurde gelöscht. Neues Pairing wird gestartet.');
+                    await this.connect();
+                    break;
+                }
+            }
+        } catch (error) {
+            this.log.error(`Befehl ${rel} fehlgeschlagen: ${this.errorText(error)}`);
+        }
+    }
+
+
+
+    appNameMap() {
+        return {
+            // Launcher / System
+            'com.google.android.apps.tv.launcherx': 'Google TV Startbildschirm',
+            'com.google.android.tvlauncher': 'Android TV Startbildschirm',
+            'com.google.android.apps.tv.launcher': 'Android TV Startbildschirm',
+            'com.android.tv.settings': 'Einstellungen',
+            'com.android.vending': 'Google Play Store',
+            'com.google.android.videos': 'Google TV',
+
+            // Streaming / TV
+            'com.netflix.ninja': 'Netflix',
+            'com.google.android.youtube.tv': 'YouTube',
+            'com.google.android.youtube': 'YouTube',
+            'com.amazon.amazonvideo.livingroom': 'Prime Video',
+            'de.swr.avp.ard.tv': 'ARD Mediathek',
+            'de.swr.avp.ard': 'ARD Mediathek',
+            'com.zdf.android.mediathek': 'ZDF',
+            'de.zdf.android.mediathek': 'ZDF',
+            'de.rtli.tvnow': 'RTL+',
+            'de.telekom.magentatv.tv': 'MagentaTV',
+            'de.telekom.magentatv.mobile': 'MagentaTV',
+            'de.telekom.magentatv.atv': 'MagentaTV (1. Generation)',
+            'de.prosiebensat1digital.seventv': 'Joyn',
+            'com.zattoo.player': 'Zattoo',
+            'de.exaring.waipu': 'waipu.tv',
+            'com.dazn': 'DAZN',
+            'de.sky.online': 'WOW',
+            'com.disney.disneyplus': 'Disney+',
+            'com.disneyplus': 'Disney+',
+            'com.apple.atve.androidtv.appletv': 'Apple TV',
+            'com.apple.atve.sony.appletv': 'Apple TV',
+
+            // Musik
+            'com.google.android.youtube.tvmusic': 'YouTube Music',
+            'com.google.android.apps.youtube.music': 'YouTube Music',
+            'com.spotify.tv.android': 'Spotify',
+            'com.spotify.music': 'Spotify',
+
+            // Kinder / Media
+            'de.kika.player.androidtv': 'KiKA',
+            'com.plexapp.android': 'Plex',
+            'org.xbmc.kodi': 'Kodi',
+            'org.videolan.vlc': 'VLC',
+            'tv.twitch.android.app': 'Twitch'
+        };
+    }
+
+    friendlyAppName(appId) {
+        const id = String(appId || '').trim();
+        if (!id) return '';
+        const known = this.appNameMap();
+        if (known[id]) return known[id];
+
+        // Lesbarer Fallback, Paket-ID bleibt zusätzlich in currentAppUnknown erhalten.
+        const parts = id.split('.').filter(Boolean);
+        const raw = parts.length ? parts[parts.length - 1] : id;
+        return raw.replace(/[_-]+/g, ' ').replace(/\b\w/g, c => c.toUpperCase());
+    }
+
+    startCastMonitor() {
+        if (this.config.enableCast === false) return;
+        const interval = Math.max(3, Number(this.config.castPollSeconds) || 5);
+        const run = async () => {
+            if (!this.stopping) await this.pollCast();
+        };
+        void run();
+        this.castTimer = this.setInterval(run, interval * 1000);
+    }
+
+    stopCastMonitor() {
+        if (this.castTimer) {
+            this.clearInterval(this.castTimer);
+            this.castTimer = null;
+        }
+        if (this.castClient) {
+            try { this.castClient.close(); } catch (_) {}
+            this.castClient = null;
+            this.castPlayer = null;
+        }
+    }
+
+    async pollCast() {
+        if (this.castConnecting || !this.config.host) return;
+        this.castConnecting = true;
+        try {
+            await this.ensureCastConnected();
+            const sessions = await this.castGetSessions();
+            if (!Array.isArray(sessions) || sessions.length === 0) {
+                await this.clearMediaStates();
+                return;
+            }
+
+            const session = sessions[0];
+            await this.setStateAsync('info.cast.appId', String(session.appId || ''), true);
+            await this.setStateAsync('info.cast.appName', String(session.displayName || ''), true);
+
+            const status = await this.castJoinAndGetStatus(session);
+            if (!status) return;
+            const media = status.media || {};
+            const metadata = media.metadata || {};
+            const title = metadata.title || metadata.seriesTitle || metadata.albumName || '';
+            const subtitle = metadata.subtitle || metadata.artist || metadata.studio || '';
+            await this.setStateAsync('info.media.title', String(title || ''), true);
+            await this.setStateAsync('info.media.subtitle', String(subtitle || ''), true);
+            await this.setStateAsync('info.media.playerState', String(status.playerState || ''), true);
+            await this.setStateAsync('info.media.contentId', String(media.contentId || ''), true);
+        } catch (error) {
+            await this.setStateAsync('info.cast.connection', false, true);
+            this.castPlayer = null;
+            if (this.config.debugProtocol) this.log.debug(`Cast-Abfrage: ${this.errorText(error)}`);
+            if (this.castClient) {
+                try { this.castClient.close(); } catch (_) {}
+                this.castClient = null;
+            }
+        } finally {
+            this.castConnecting = false;
+        }
+    }
+
+    ensureCastConnected() {
+        if (this.castClient) return Promise.resolve();
+        return new Promise((resolve, reject) => {
+            const client = new CastClient();
+            let settled = false;
+            const fail = err => {
+                if (settled) return;
+                settled = true;
+                try { client.close(); } catch (_) {}
+                reject(err instanceof Error ? err : new Error(String(err)));
+            };
+            client.once('error', fail);
+            client.connect(String(this.config.host).trim(), () => {
+                if (settled) return;
+                settled = true;
+                client.removeListener('error', fail);
+                client.on('error', () => {
+                    void this.setStateAsync('info.cast.connection', false, true);
+                    if (this.castClient === client) this.castClient = null;
+                });
+                this.castClient = client;
+                void this.setStateAsync('info.cast.connection', true, true);
+                resolve();
+            });
+        });
+    }
+
+    castGetSessions() {
+        return new Promise((resolve, reject) => {
+            this.castClient.getSessions((err, sessions) => err ? reject(err) : resolve(sessions || []));
+        });
+    }
+
+    castJoinAndGetStatus(session) {
+        return new Promise((resolve, reject) => {
+            this.castClient.join(session, DefaultMediaReceiver, (err, player) => {
+                if (err) return reject(err);
+                this.castPlayer = player;
+                player.getStatus((statusErr, status) => {
+                    if (statusErr) return reject(statusErr);
+                    resolve(status || null);
+                });
+            });
+        });
+    }
+
+    async clearMediaStates() {
+        await this.setStateAsync('info.cast.appId', '', true);
+        await this.setStateAsync('info.cast.appName', '', true);
+        await this.setStateAsync('info.media.title', '', true);
+        await this.setStateAsync('info.media.subtitle', '', true);
+        await this.setStateAsync('info.media.playerState', '', true);
+        await this.setStateAsync('info.media.contentId', '', true);
+    }
+
+    sendKey(input) {
+        if (!this.requireRemote()) return;
+        const { RemoteKeyCode } = this.remoteModule;
+        const normalized = input.trim().toUpperCase().replace(/[ -]+/g, '_');
+        const aliases = {
+            UP: 'KEYCODE_DPAD_UP', DOWN: 'KEYCODE_DPAD_DOWN', LEFT: 'KEYCODE_DPAD_LEFT', RIGHT: 'KEYCODE_DPAD_RIGHT',
+            OK: 'KEYCODE_DPAD_CENTER', ENTER: 'KEYCODE_DPAD_CENTER', CENTER: 'KEYCODE_DPAD_CENTER', SELECT: 'KEYCODE_DPAD_CENTER',
+            HOME: 'KEYCODE_HOME', BACK: 'KEYCODE_BACK', MENU: 'KEYCODE_MENU', POWER: 'KEYCODE_POWER',
+            PLAY_PAUSE: 'KEYCODE_MEDIA_PLAY_PAUSE', PLAY: 'KEYCODE_MEDIA_PLAY', PAUSE: 'KEYCODE_MEDIA_PAUSE', STOP: 'KEYCODE_MEDIA_STOP',
+            NEXT: 'KEYCODE_MEDIA_NEXT', PREVIOUS: 'KEYCODE_MEDIA_PREVIOUS', REWIND: 'KEYCODE_MEDIA_REWIND', FAST_FORWARD: 'KEYCODE_MEDIA_FAST_FORWARD',
+            VOLUME_UP: 'KEYCODE_VOLUME_UP', VOLUP: 'KEYCODE_VOLUME_UP', VOLUME_DOWN: 'KEYCODE_VOLUME_DOWN', VOLDOWN: 'KEYCODE_VOLUME_DOWN', MUTE: 'KEYCODE_VOLUME_MUTE'
+        };
+        const enumName = normalized.startsWith('KEYCODE_') ? normalized : (aliases[normalized] || `KEYCODE_${normalized}`);
+        const code = RemoteKeyCode[enumName];
+        if (code === undefined) {
+            this.log.warn(`Unbekannte Remote-Taste: ${input} (${enumName})`);
+            return;
+        }
+        this.remote.sendKey(code);
+    }
+
+    requireRemote() {
+        if (!this.remote) {
+            this.log.warn('Android TV ist nicht verbunden.');
+            return false;
+        }
+        return true;
+    }
+
+    errorText(error) {
+        return error instanceof Error ? error.message : String(error);
+    }
+
+    async onUnload(callback) {
+        try {
+            this.stopping = true;
+            this.clearReconnect();
+            this.stopCastMonitor();
+            await this.setStateAsync('info.connection', false, true);
+            if (this.remote) {
+                try { this.remote.stop(); } catch (_) {}
+                this.remote = null;
+            }
+        } catch (_) {
+            // ignore during shutdown
+        } finally {
+            callback();
+        }
+    }
+}
+
+if (require.main !== module) {
+    module.exports = options => new AndroidTvRemoteAdapter(options);
+} else {
+    new AndroidTvRemoteAdapter();
+}

package/package.json

@@ -1,6 +1,41 @@
 {
   "name": "iobroker.androidtvremote",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.7",
+  "description": "ioBroker adapter for Android TV / Google TV using the Android TV Remote v2 protocol",
+  "author": {
+    "name": "Henrik Schönhofen",
+    "email": "henrik.schoenhofen@icloud.com"
+  },
+  "homepage": "https://github.com/backfisch88/ioBroker.androidtvremote",
+  "license": "MIT",
+  "keywords": [
+    "iobroker",
+    "android tv",
+    "google tv",
+    "remote",
+    "androidtvremote2"
+  ],
+  "main": "main.js",
+  "files": [
+    "admin/",
+    "io-package.json",
+    "main.js",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "dependencies": {
+    "@iobroker/adapter-core": "^3.4.3",
+    "@kud/androidtv-remote": "^0.1.2",
+    "castv2-client": "^1.2.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/backfisch88/ioBroker.androidtvremote.git"
+  },
+  "bugs": {
+    "url": "https://github.com/backfisch88/ioBroker.androidtvremote/issues"
+  }
+}