iobroker.youtube-remote 0.0.1 → 0.0.2

package/README.md

@@ -12,25 +12,31 @@ In the tab **Devices** of the settings:
 - **Search** finds devices with the YouTube app in the network (DIAL). **Add** pairs a found device; it reports
   its YouTube screen mostly only while the app runs, so the adapter tries to start it - if that does not work, open
   YouTube on the device once.
-- **Pair with TV code** works for every device: the YouTube app shows the code under Settings > Link with TV code.
+- **Pair with TV code** works for every device: the YouTube app shows the code under **Settings** > **Link with TV code**.
+
+The card of a device shows whether the YouTube app is open, what plays (title, channel) and has buttons for previous,
+play, pause, next, the volume and mute. **More** shows the picture and the position of the video.
 
 ## States
 
 Per device `youtube-remote.0.<device>`, in the form of the type-detector type `mediaPlayer`, so visualizations and the
 devices adapter show it as a player:
 
-| State                           | Role                     | Description                                                                            |
-| ------------------------------- | ------------------------ | -------------------------------------------------------------------------------------- |
-| `youtube`                       | text                     | play a video ID, a playlist (`PL…`), the uploads of a channel (`UC…`) or a YouTube URL |
-| `play`, `pause`, `next`, `prev` | button.*                 | player commands                                                                        |
-| `state`                         | media.state              | 0 pause, 1 play, 2 stop                                                                |
-| `playerState`                   | value                    | unstarted, ended, playing, paused, buffering, cued, advertisement                      |
-| `title`, `artist`, `cover`      | media.*                  | title, channel and picture of the video (oEmbed of YouTube, can be switched off)       |
-| `videoId`, `url`                | text                     | the playing video                                                                      |
-| `duration`, `elapsed`           | media.*                  | length and position in seconds, as last reported by the TV                             |
-| `seek`                          | media.seek               | jump to a position in seconds                                                          |
-| `volume`, `muted`               | level.volume, media.mute | volume of the YouTube player                                                           |
-| `connected`                     | indicator.reachable      | the session to the YouTube app is up                                                   |
+| State                            | Role                      | Description                                                                             |
+|----------------------------------|---------------------------|-----------------------------------------------------------------------------------------|
+| `youtube`                        | text                      | play a video ID, a playlist (`PL…`), the uploads of a channel (`UC…`) or a YouTube URL  |
+| `play`, `pause`, `next`, `prev`  | button.*                  | player commands                                                                         |
+| `state`                          | media.state               | 0 pause, 1 play, 2 stop                                                                 |
+| `playerState`                    | value                     | unstarted, ended, playing, paused, buffering, cued, advertisement                       |
+| `title`, `artist`, `cover`       | media.*                   | title, channel and picture of the video (oEmbed of YouTube, can be switched off)        |
+| `videoId`, `url`                 | text                      | the playing video                                                                       |
+| `duration`, `elapsed`            | media.*                   | length and position in seconds, as last reported by the TV                              |
+| `seek`                           | media.seek                | jump to a position in seconds                                                           |
+| `volume`, `muted`                | level.volume, media.mute  | volume of the YouTube player                                                            |
+| `connected`                      | indicator.reachable       | the YouTube app of the device is open                                                   |
+
+A video waits up to 30 s for the YouTube app, so it can be written right after switching the TV on; player commands
+wait 5 s. If the app does not come, `youtube` stays unacknowledged and a warning is logged.
 
 Handles (`@name`) cannot be resolved without the YouTube Data API: use the channel ID `UC…` from the address of the
 channel page.
@@ -48,8 +54,12 @@ stored encrypted.
 -->
 
 ## Changelog
+### 0.0.2 (2026-10-25)
+
+- (@GermanBluefox) Device cards show state, title and channel, with play, pause, next, previous, volume and mute
+- (@GermanBluefox) Commands wait for the YouTube app to open; `connected` shows whether it is open
 
-### **WORK IN PROGRESS**
+### 0.0.1 (2026-10-24)
 
 - (@GermanBluefox) Initial release
 

package/admin/jsonConfig.json5

@@ -29,6 +29,10 @@
                     help: 'Look up titles help',
                     default: true,
                     xs: 12,
+                    sm: 12,
+                    md: 12,
+                    lg: 12,
+                    xl: 12,
                 },
                 discoveryTimeout: {
                     type: 'number',
@@ -40,6 +44,8 @@
                     xs: 12,
                     sm: 6,
                     md: 4,
+                    lg: 4,
+                    xl: 4,
                 },
                 _cloud: {
                     type: 'infoBox',

package/build/lib/DeviceManagement.d.ts

@@ -19,7 +19,12 @@ export declare class YouTubeDeviceManagement extends DeviceManagement {
     constructor(adapter: AdapterInstance, service: YouTubeService);
     getInstanceInfo(): InstanceDetails;
     loadDevices(context: DeviceLoadContext<string>): Promise<void>;
-    getDeviceDetails(id: string): DeviceDetails<string> | null;
+    /**
+     * Title and channel live on the card, the player buttons, volume and mute. They write the states of the device,
+     * so they work like a script writing them.
+     */
+    private controlsOf;
+    getDeviceDetails(id: string): Promise<DeviceDetails<string> | null>;
     private discover;
     private pairCode;
     private addFound;

package/build/lib/DeviceManagement.js

@@ -33,7 +33,25 @@ const T = {
     },
     paired: { en: 'Paired devices', de: 'Gekoppelte Geräte' },
     discovered: { en: 'Found devices', de: 'Gefundene Geräte' },
+    title: { en: 'Title', de: 'Titel' },
+    channel: { en: 'Channel', de: 'Kanal' },
+    previous: { en: 'Previous', de: 'Zurück' },
+    pause: { en: 'Pause', de: 'Pause' },
+    next: { en: 'Next', de: 'Weiter' },
+    volume: { en: 'Volume', de: 'Lautstärke' },
+    muted: { en: 'Muted', de: 'Stumm' },
+    playing: { en: 'Playing', de: 'Spielt' },
+    paused: { en: 'Paused', de: 'Pausiert' },
+    stopped: { en: 'Stopped', de: 'Gestoppt' },
+    position: { en: 'Position', de: 'Position' },
 };
+/** `m:ss` or `h:mm:ss` */
+function duration(seconds) {
+    const total = Math.max(0, Math.round(Number(seconds) || 0));
+    const [h, m, sec] = [Math.floor(total / 3600), Math.floor(total / 60) % 60, total % 60];
+    const two = (n) => String(n).padStart(2, '0');
+    return h ? `${h}:${two(m)}:${two(sec)}` : `${m}:${two(sec)}`;
+}
 function withError(text, error) {
     const message = error instanceof Error ? error.message : String(error);
     return typeof text === 'string'
@@ -83,6 +101,21 @@ class YouTubeDeviceManagement extends dm_utils_1.DeviceManagement {
                     mapping: { true: 'connected', false: 'disconnected' },
                 },
             },
+            indicators: [
+                {
+                    id: 'state',
+                    value: { stateId: `${namespace}.${device.id}.state` },
+                    levels: [
+                        { value: 1, icon: 'play', color: 'ok', text: T.playing },
+                        { value: 0, icon: 'pause', color: 'warning', text: T.paused },
+                        { icon: 'stop', color: 'inactive', text: T.stopped },
+                    ],
+                    hideIfEmpty: false,
+                    order: 1,
+                },
+            ],
+            controls: this.controlsOf(device.id),
+            hasDetails: true,
             actions: [
                 { id: 'play', icon: 'play', description: T.play, handler: (id, ctx) => this.play(id, ctx) },
                 { id: 'rename', icon: 'rename', description: T.rename, handler: (id, ctx) => this.rename(id, ctx) },
@@ -122,17 +155,96 @@ class YouTubeDeviceManagement extends dm_utils_1.DeviceManagement {
         context.setTotalDevices(devices.length);
         devices.forEach(device => context.addDevice(device));
     }
-    getDeviceDetails(id) {
+    /**
+     * Title and channel live on the card, the player buttons, volume and mute. They write the states of the device,
+     * so they work like a script writing them.
+     */
+    controlsOf(id) {
+        const base = `${this.adapter.namespace}.${id}`;
+        const handler = async (_deviceId, control, value) => {
+            try {
+                await this.adapter.setForeignStateAsync(`${base}.${control}`, value, false);
+            }
+            catch (error) {
+                return { error: { code: 500, message: error instanceof Error ? error.message : String(error) } };
+            }
+            return { val: value, ack: true, ts: Date.now(), lc: Date.now(), from: this.adapter.namespace };
+        };
+        const getStateHandler = async (_deviceId, control) => (await this.adapter.getForeignStateAsync(`${base}.${control}`)) ?? {
+            val: null,
+            ack: true,
+            ts: Date.now(),
+            lc: Date.now(),
+            from: this.adapter.namespace,
+        };
+        const button = (control, icon, label) => ({
+            id: control,
+            type: 'button',
+            icon,
+            label,
+            handler: (deviceId, controlId) => handler(deviceId, controlId, true),
+        });
+        const controls = [
+            { id: 'title', type: 'info', label: T.title, stateId: `${base}.title`, noTranslation: true },
+            { id: 'artist', type: 'info', label: T.channel, stateId: `${base}.artist`, noTranslation: true },
+            button('prev', 'previous', T.previous),
+            button('play', 'play', T.play),
+            button('pause', 'pause', T.pause),
+            button('next', 'next', T.next),
+            {
+                id: 'volume',
+                type: 'slider',
+                label: T.volume,
+                stateId: `${base}.volume`,
+                min: 0,
+                max: 100,
+                step: 1,
+                unit: '%',
+                controlDelay: 500,
+                handler,
+            },
+            { id: 'muted', type: 'switch', label: T.muted, stateId: `${base}.muted`, handler },
+        ];
+        return controls.map(control => ({ ...control, getStateHandler }));
+    }
+    async getDeviceDetails(id) {
         const device = this.service.devices().find(entry => entry.id === id);
-        return device
-            ? {
-                id,
-                schema: {
-                    type: 'panel',
-                    items: { name: { type: 'staticInfo', label: T.name, data: device.name } },
+        if (!device) {
+            return null;
+        }
+        const base = `${this.adapter.namespace}.${id}`;
+        const value = async (state) => (await this.adapter.getForeignStateAsync(`${base}.${state}`))?.val ?? null;
+        const [title, artist, url, cover, elapsed, length] = await Promise.all(['title', 'artist', 'url', 'cover', 'elapsed', 'duration'].map(value));
+        return {
+            id,
+            schema: {
+                type: 'panel',
+                items: {
+                    name: { type: 'staticInfo', label: T.name, data: device.name, xs: 12 },
+                    title: { type: 'staticInfo', label: T.title, data: String(title || '-'), xs: 12 },
+                    artist: { type: 'staticInfo', label: T.channel, data: String(artist || '-'), xs: 12 },
+                    position: {
+                        type: 'staticInfo',
+                        label: T.position,
+                        data: length ? `${duration(elapsed)} / ${duration(length)}` : '-',
+                        xs: 12,
+                    },
+                    // a click on the picture opens the video
+                    ...(cover
+                        ? {
+                            cover: {
+                                type: 'staticImage',
+                                src: String(cover),
+                                href: url ? String(url) : undefined,
+                                xs: 12,
+                                sm: 8,
+                                md: 6,
+                            },
+                        }
+                        : {}),
                 },
-            }
-            : null;
+            },
+        };
     }
     async discover(context) {
         try {

package/build/main.js

@@ -44,10 +44,16 @@ const playerStates_1 = require("./lib/playerStates");
 const registry_1 = require("./lib/registry");
 /** How long adding a found device waits for the YouTube app to report its screen, in ms */
 const SCREEN_WAIT = 15_000;
+/** How long a video waits for the YouTube app to join the lounge, e.g. while the TV starts, in ms */
+const APP_WAIT = 30_000;
+/** The same for player commands */
+const COMMAND_WAIT = 5_000;
 class YouTubeRemote extends utils.Adapter {
     registry;
     sessions = new Map();
     videoInfo = new Map();
+    /** Per device the last video asked for, so an older one still waiting for the app is dropped */
+    lastTarget = new Map();
     foundDevices = [];
     deviceManagement;
     constructor(options = {}) {
@@ -96,7 +102,9 @@ class YouTubeRemote extends utils.Adapter {
                 await this.registry.remove(id);
                 await this.delObjectAsync(id, { recursive: true });
             },
-            play: (id, target) => this.send(id, lounge => lounge.play((0, youtube_lounge_1.parseYouTubeTarget)(target))),
+            play: async (id, target) => {
+                await this.playTarget(id, target);
+            },
         };
     }
     /** Pair with the screen ID the found device reports; the YouTube app is started over DIAL if it has to */
@@ -139,17 +147,13 @@ class YouTubeRemote extends utils.Adapter {
             void this.setStateAsync(`${device.id}.volume`, volume, true);
             void this.setStateAsync(`${device.id}.muted`, muted, true);
         });
-        session.on('disconnected', () => void this.setStateAsync(`${device.id}.connected`, false, true));
-        session.on('error', (e) => {
-            this.log.debug(`${device.name}: ${e.message}`);
-            void this.setStateAsync(`${device.id}.connected`, false, true);
-        });
+        session.on('screen', (online) => void this.setStateAsync(`${device.id}.connected`, online, true));
+        session.on('error', (e) => this.log.debug(`${device.name}: ${e.message}`));
         this.sessions.set(device.id, session);
         session.subscribe();
     }
     async onNowPlaying(device, playing) {
         const base = device.id;
-        await this.setStateAsync(`${base}.connected`, true, true);
         await this.syncToken(device);
         await this.setStateAsync(`${base}.state`, (0, playerStates_1.mediaStateOf)(playing), true);
         await this.setStateAsync(`${base}.playerState`, playing?.state ?? -1, true);
@@ -184,15 +188,33 @@ class YouTubeRemote extends utils.Adapter {
             await this.registry.save();
         }
     }
-    async send(id, action) {
+    /**
+     * Send when the YouTube app is in the lounge: Google takes commands without it too, and they get lost.
+     *
+     * @returns false if `stillWanted` says the command is out of date after waiting
+     */
+    async send(id, action, wait, stillWanted = () => true) {
         const lounge = this.sessions.get(id);
         const device = this.registry.find(id);
         if (!lounge || !device) {
             throw new Error(`Unknown device ${id}`);
         }
+        if (!(await lounge.waitForScreen(wait))) {
+            throw new Error('the YouTube app is not open');
+        }
+        if (!stillWanted()) {
+            return false;
+        }
         await action(lounge);
-        await this.setStateAsync(`${id}.connected`, true, true);
         await this.syncToken(device);
+        return true;
+    }
+    /** A video waits for the app as long as the TV may take to start; a newer one replaces it meanwhile */
+    playTarget(id, target) {
+        const parsed = (0, youtube_lounge_1.parseYouTubeTarget)(target);
+        const call = (this.lastTarget.get(id) ?? 0) + 1;
+        this.lastTarget.set(id, call);
+        return this.send(id, lounge => lounge.play(parsed), APP_WAIT, () => this.lastTarget.get(id) === call);
     }
     onStateChange(id, state) {
         if (!state || state.ack || !id.startsWith(`${this.namespace}.`)) {
@@ -203,35 +225,33 @@ class YouTubeRemote extends utils.Adapter {
             return;
         }
         this.execute(deviceId, command, state.val)
-            .then(() => this.acknowledge(id, command, state.val))
+            .then(done => (done ? this.acknowledge(id, command, state.val) : undefined))
             .catch(e => this.log.warn(`${command} on ${this.registry.find(deviceId)?.name}: ${String(e)}`));
     }
+    /** @returns false if a newer command took its place, then the newer one is acknowledged */
     async execute(id, command, value) {
         switch (command) {
             case 'youtube':
-                if (typeof value === 'string' && value.trim()) {
-                    await this.send(id, lounge => lounge.play((0, youtube_lounge_1.parseYouTubeTarget)(value)));
-                }
-                return;
+                return typeof value === 'string' && value.trim() ? this.playTarget(id, value) : true;
             case 'play':
             case 'pause':
             case 'next':
             case 'prev':
                 if (value) {
-                    await this.send(id, lounge => lounge.play({ kind: 'command', command: command === 'prev' ? 'previous' : command }));
+                    await this.send(id, lounge => lounge.play({ kind: 'command', command: command === 'prev' ? 'previous' : command }), COMMAND_WAIT);
                 }
-                return;
+                return true;
             case 'seek':
-                await this.send(id, lounge => lounge.seekTo(Number(value)));
-                return;
+                await this.send(id, lounge => lounge.seekTo(Number(value)), COMMAND_WAIT);
+                return true;
             case 'volume':
-                await this.send(id, lounge => lounge.setVolume(Number(value)));
-                return;
+                await this.send(id, lounge => lounge.setVolume(Number(value)), COMMAND_WAIT);
+                return true;
             case 'muted':
-                await this.send(id, lounge => lounge.setMuted(!!value));
-                return;
+                await this.send(id, lounge => lounge.setMuted(!!value), COMMAND_WAIT);
+                return true;
             default:
-                return;
+                return true;
         }
     }
     /** Buttons and the target go back to their rest value, the others keep what was written */

package/io-package.json

@@ -1,109 +1,131 @@
 {
-    "common": {
-        "name": "youtube-remote",
-        "version": "0.0.1",
-        "news": {
-            "0.0.1": {
-                "en": "initial release",
-                "de": "Erste Version",
-                "ru": "Первый выпуск",
-                "pt": "Lançamento inicial",
-                "nl": "Eerste release",
-                "fr": "Version initiale",
-                "it": "Prima versione",
-                "es": "Versión inicial",
-                "pl": "Pierwsze wydanie",
-                "uk": "Перший випуск",
-                "zh-cn": "首次发布"
-            }
-        },
-        "titleLang": {
-            "en": "YouTube remote",
-            "de": "YouTube-Fernbedienung",
-            "ru": "Пульт YouTube",
-            "pt": "Controle remoto do YouTube",
-            "nl": "YouTube-afstandsbediening",
-            "fr": "Télécommande YouTube",
-            "it": "Telecomando YouTube",
-            "es": "Mando de YouTube",
-            "pl": "Pilot YouTube",
-            "uk": "Пульт YouTube",
-            "zh-cn": "YouTube 遥控器"
-        },
-        "desc": {
-            "en": "Controls the YouTube app of TVs, Android TV, Fire TV and consoles: plays videos, playlists and channels and shows what plays",
-            "de": "Steuert die YouTube-App von Fernsehern, Android TV, Fire TV und Konsolen: spielt Videos, Playlists und Kanäle ab und zeigt, was läuft",
-            "ru": "Управляет приложением YouTube на телевизорах, Android TV, Fire TV и консолях: воспроизводит видео, плейлисты и каналы и показывает, что играет",
-            "pt": "Controla o app YouTube de TVs, Android TV, Fire TV e consoles: reproduz vídeos, playlists e canais e mostra o que está tocando",
-            "nl": "Bedient de YouTube-app van tv's, Android TV, Fire TV en consoles: speelt video's, afspeellijsten en kanalen af en toont wat er speelt",
-            "fr": "Commande l'application YouTube des téléviseurs, Android TV, Fire TV et consoles : lit des vidéos, playlists et chaînes et affiche ce qui est lu",
-            "it": "Controlla l'app YouTube di TV, Android TV, Fire TV e console: riproduce video, playlist e canali e mostra cosa è in riproduzione",
-            "es": "Controla la app de YouTube de televisores, Android TV, Fire TV y consolas: reproduce vídeos, listas y canales y muestra lo que suena",
-            "pl": "Steruje aplikacją YouTube na telewizorach, Android TV, Fire TV i konsolach: odtwarza filmy, playlisty i kanały oraz pokazuje, co jest odtwarzane",
-            "uk": "Керує застосунком YouTube на телевізорах, Android TV, Fire TV і консолях: відтворює відео, плейлисти й канали та показує, що грає",
-            "zh-cn": "控制电视、Android TV、Fire TV 和游戏机上的 YouTube 应用：播放视频、播放列表和频道，并显示正在播放的内容"
-        },
-        "authors": ["bluefox <dogafox@gmail.com>"],
-        "keywords": ["youtube", "tv", "lounge", "dial", "media"],
-        "licenseInformation": {
-            "type": "free",
-            "license": "MIT"
-        },
-        "platform": "Javascript/Node.js",
-        "icon": "youtube-remote.svg",
-        "enabled": true,
-        "extIcon": "https://raw.githubusercontent.com/ioBroker/ioBroker.youtube-remote/main/admin/youtube-remote.svg",
-        "readme": "https://github.com/ioBroker/ioBroker.youtube-remote/blob/main/README.md",
-        "loglevel": "info",
-        "tier": 2,
-        "mode": "daemon",
-        "type": "multimedia",
-        "compact": true,
-        "connectionType": "cloud",
-        "dataSource": "push",
-        "adminUI": {
-            "config": "json"
-        },
-        "supportedMessages": {
-            "deviceManager": true
-        },
-        "dependencies": [
-            {
-                "js-controller": ">=6.0.11"
-            }
-        ],
-        "globalDependencies": [
-            {
-                "admin": ">=7.8.23"
-            }
-        ]
+  "common": {
+    "name": "youtube-remote",
+    "version": "0.0.2",
+    "news": {
+      "0.0.2": {
+        "en": "Device cards show state, title and channel, with play, pause, next, previous, volume and mute\nCommands wait for the YouTube app to open; `connected` shows whether it is open",
+        "de": "Gerätekarten zeigen Status, Titel und Kanal mit Abspielen, Pause, Zurück, Lautstärke und Stumm\nBefehle warten auf den Start der YouTube-App; `connected` zeigt, ob sie geöffnet ist",
+        "ru": "На карточках устройства отображаются состояние, название и канал, а также воспроизведение, пауза, следующее, предыдущее, громкое и отключенное\nКоманды дожидаются открытия приложения YouTube; `connected` показывает, открыто ли оно",
+        "pt": "As placas mostram estado, título e canal, com play, pause, next, previous, volume e mute\nComandos aguardam o app do YouTube abrir; `conect` mostra se está aberto",
+        "nl": "Apparaatkaarten tonen status, titel en kanaal, met afspelen, pauzeren, volgende, vorige, volume en dempen\nOpdrachten wachten tot de YouTube-app wordt geopend; met `connected` wordt weergegeven of de app is geopend",
+        "fr": "Les cartes indiquent l'état, le titre et la chaîne, avec lecture, pause, suivant, volume et sourdine\nLes commandes attendent l'ouverture de l'app YouTube ; « Connected » indique si elle est ouverte",
+        "it": "Le schede mostrano stato, titolo e canale, con play, pausa, next, previous, volume e mute\nI comandi attendono l'app YouTube; `connesso` mostra se è aperta",
+        "es": "Las tarjetas muestran el estado, el título y el canal, con reproducir, pausar, siguiente, anterior, volumen y silencio\nLos comandos esperan a que se abra la aplicación YouTube; «conectado» muestra si está abierta",
+        "pl": "Karty urządzeń pokazują stan, tytuł i kanał, z odtwarzaniem, pauzą, następną, poprzednią, głośnością i wyciszaniem\nPolecenia czekają na otwarcie aplikacji YouTube; `connected` pokazuje, czy jest otwarta",
+        "uk": "Картки пристроїв показують стан, назву та канал, з відтворенням, паузою, наступним, попереднім, гучністю та вимкненням звуку\nКоманди чекають відкриття програми YouTube; `connected` показує, чи відкрито воно",
+        "zh-cn": "设备卡片显示状态、标题和频道，包括播放、暂停、下一首、上一首、音量和静音\n命令等待 YouTube 应用打开；`connected` 显示它是否已打开"
+      },
+      "0.0.1": {
+        "en": "initial release",
+        "de": "Erste Version",
+        "ru": "Первый выпуск",
+        "pt": "Lançamento inicial",
+        "nl": "Eerste release",
+        "fr": "Version initiale",
+        "it": "Prima versione",
+        "es": "Versión inicial",
+        "pl": "Pierwsze wydanie",
+        "uk": "Перший випуск",
+        "zh-cn": "首次发布"
+      }
     },
-    "native": {
-        "lookUpTitles": true,
-        "discoveryTimeout": 4
+    "titleLang": {
+      "en": "YouTube remote",
+      "de": "YouTube-Fernbedienung",
+      "ru": "Пульт YouTube",
+      "pt": "Controle remoto do YouTube",
+      "nl": "YouTube-afstandsbediening",
+      "fr": "Télécommande YouTube",
+      "it": "Telecomando YouTube",
+      "es": "Mando de YouTube",
+      "pl": "Pilot YouTube",
+      "uk": "Пульт YouTube",
+      "zh-cn": "YouTube 遥控器"
     },
-    "objects": [],
-    "instanceObjects": [
-        {
-            "_id": "info",
-            "type": "channel",
-            "common": {
-                "name": "Information"
-            },
-            "native": {}
-        },
-        {
-            "_id": "info.deviceManager",
-            "type": "state",
-            "common": {
-                "name": "Device Manager communication",
-                "type": "string",
-                "role": "json",
-                "read": true,
-                "write": false,
-                "expert": true
-            },
-            "native": {}
-        }
+    "desc": {
+      "en": "Controls the YouTube app of TVs, Android TV, Fire TV and consoles: plays videos, playlists and channels and shows what plays",
+      "de": "Steuert die YouTube-App von Fernsehern, Android TV, Fire TV und Konsolen: spielt Videos, Playlists und Kanäle ab und zeigt, was läuft",
+      "ru": "Управляет приложением YouTube на телевизорах, Android TV, Fire TV и консолях: воспроизводит видео, плейлисты и каналы и показывает, что играет",
+      "pt": "Controla o app YouTube de TVs, Android TV, Fire TV e consoles: reproduz vídeos, playlists e canais e mostra o que está tocando",
+      "nl": "Bedient de YouTube-app van tv's, Android TV, Fire TV en consoles: speelt video's, afspeellijsten en kanalen af en toont wat er speelt",
+      "fr": "Commande l'application YouTube des téléviseurs, Android TV, Fire TV et consoles : lit des vidéos, playlists et chaînes et affiche ce qui est lu",
+      "it": "Controlla l'app YouTube di TV, Android TV, Fire TV e console: riproduce video, playlist e canali e mostra cosa è in riproduzione",
+      "es": "Controla la app de YouTube de televisores, Android TV, Fire TV y consolas: reproduce vídeos, listas y canales y muestra lo que suena",
+      "pl": "Steruje aplikacją YouTube na telewizorach, Android TV, Fire TV i konsolach: odtwarza filmy, playlisty i kanały oraz pokazuje, co jest odtwarzane",
+      "uk": "Керує застосунком YouTube на телевізорах, Android TV, Fire TV і консолях: відтворює відео, плейлисти й канали та показує, що грає",
+      "zh-cn": "控制电视、Android TV、Fire TV 和游戏机上的 YouTube 应用：播放视频、播放列表和频道，并显示正在播放的内容"
+    },
+    "authors": [
+      "bluefox <dogafox@gmail.com>"
+    ],
+    "keywords": [
+      "youtube",
+      "tv",
+      "lounge",
+      "dial",
+      "media"
+    ],
+    "licenseInformation": {
+      "type": "free",
+      "license": "MIT"
+    },
+    "platform": "Javascript/Node.js",
+    "icon": "youtube-remote.svg",
+    "enabled": true,
+    "extIcon": "https://raw.githubusercontent.com/ioBroker/ioBroker.youtube-remote/main/admin/youtube-remote.svg",
+    "readme": "https://github.com/ioBroker/ioBroker.youtube-remote/blob/main/README.md",
+    "loglevel": "info",
+    "tier": 2,
+    "mode": "daemon",
+    "type": "multimedia",
+    "compact": true,
+    "connectionType": "cloud",
+    "dataSource": "push",
+    "nogit": true,
+    "adminUI": {
+      "config": "json"
+    },
+    "supportedMessages": {
+      "deviceManager": true
+    },
+    "dependencies": [
+      {
+        "js-controller": ">=6.0.11"
+      }
+    ],
+    "globalDependencies": [
+      {
+        "admin": ">=7.8.23"
+      }
     ]
+  },
+  "native": {
+    "lookUpTitles": true,
+    "discoveryTimeout": 4
+  },
+  "objects": [],
+  "instanceObjects": [
+    {
+      "_id": "info",
+      "type": "channel",
+      "common": {
+        "name": "Information"
+      },
+      "native": {}
+    },
+    {
+      "_id": "info.deviceManager",
+      "type": "state",
+      "common": {
+        "name": "Device Manager communication",
+        "type": "string",
+        "role": "json",
+        "read": true,
+        "write": false,
+        "expert": true
+      },
+      "native": {}
+    }
+  ]
 }

package/package.json

@@ -1,68 +1,67 @@
 {
-    "name": "iobroker.youtube-remote",
-    "version": "0.0.1",
-    "description": "Control the YouTube app of TVs, Android TV, Fire TV and consoles: play videos, playlists and channels, follow what plays",
-    "author": {
-        "name": "bluefox",
-        "email": "dogafox@gmail.com"
-    },
-    "homepage": "https://github.com/ioBroker/ioBroker.youtube-remote",
-    "license": "MIT",
-    "keywords": [
-        "ioBroker",
-        "youtube",
-        "tv",
-        "lounge",
-        "dial",
-        "media"
-    ],
-    "repository": {
-        "type": "git",
-        "url": "git+https://github.com/ioBroker/ioBroker.youtube-remote.git"
-    },
-    "engines": {
-        "node": ">=20"
-    },
-    "main": "build/main.js",
-    "files": [
-        "admin/",
-        "build/",
-        "!build/**/*.map",
-        "!build/**/*.test.*",
-        "io-package.json",
-        "package.json",
-        "README.md",
-        "LICENSE"
-    ],
-    "dependencies": {
-        "@iobroker/adapter-core": "^3.4.3",
-        "@iobroker/dm-utils": "^3.2.1",
-        "@iobroker/youtube-lounge": "^0.1.0"
-    },
-    "devDependencies": {
-        "@alcalzone/release-script": "^5.2.1",
-        "@alcalzone/release-script-plugin-iobroker": "^5.2.0",
-        "@alcalzone/release-script-plugin-license": "^5.2.2",
-        "@alcalzone/release-script-plugin-manual-review": "^5.2.0",
-        "@iobroker/adapter-dev": "^1.5.0",
-        "@iobroker/eslint-config": "^2.3.4",
-        "@iobroker/testing": "^6.3.0",
-        "@tsconfig/node22": "^22.0.6",
-        "@types/mocha": "^10.0.10",
-        "@types/node": "^22.20.5",
-        "globals": "^17.13.0",
-        "typescript": "~5.9.3"
-    },
-    "scripts": {
-        "build": "tsc -p tsconfig.build.json",
-        "check": "tsc -p tsconfig.json --noEmit",
-        "pretest": "npm run build",
-        "test:unit": "node scripts/run-mocha.js --config test/mocharc.custom.json \"build/**/*.test.js\" --exit",
-        "test:package": "node scripts/run-mocha.js test/package --exit",
-        "test:integration": "node scripts/run-mocha.js test/integration --exit",
-        "test": "npm run test:unit && npm run test:package",
-        "lint": "eslint -c eslint.config.mjs .",
-        "translate": "translate-adapter",
-        "release": "release-script"
-    }
+  "name": "iobroker.youtube-remote",
+  "version": "0.0.2",
+  "description": "Control the YouTube app of TVs, Android TV, Fire TV and consoles: play videos, playlists and channels, follow what plays",
+  "author": {
+    "name": "bluefox",
+    "email": "dogafox@gmail.com"
+  },
+  "homepage": "https://github.com/ioBroker/ioBroker.youtube-remote",
+  "license": "MIT",
+  "keywords": [
+    "ioBroker",
+    "youtube",
+    "tv",
+    "lounge",
+    "dial",
+    "media"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ioBroker/ioBroker.youtube-remote.git"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "main": "build/main.js",
+  "files": [
+    "admin/",
+    "build/",
+    "!build/**/*.map",
+    "!build/**/*.test.*",
+    "io-package.json",
+    "package.json",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "@iobroker/adapter-core": "^3.4.3",
+    "@iobroker/dm-utils": "^3.2.1",
+    "@iobroker/youtube-lounge": "^0.2.0"
+  },
+  "devDependencies": {
+    "@alcalzone/release-script": "^5.2.1",
+    "@alcalzone/release-script-plugin-iobroker": "^5.2.0",
+    "@alcalzone/release-script-plugin-license": "^5.2.2",
+    "@alcalzone/release-script-plugin-manual-review": "^5.2.0",
+    "@iobroker/adapter-dev": "^1.5.0",
+    "@iobroker/eslint-config": "^2.3.4",
+    "@iobroker/testing": "^6.3.0",
+    "@tsconfig/node22": "^22.0.6",
+    "@types/node": "^22.20.5",
+    "globals": "^17.13.0",
+    "typescript": "~5.9.3"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "check": "tsc -p tsconfig.json --noEmit",
+    "pretest": "npm run build",
+    "test:unit": "node scripts/run-mocha.js --config test/mocharc.custom.json \"build/**/*.test.js\" --exit",
+    "test:package": "node scripts/run-mocha.js test/package --exit",
+    "test:integration": "node scripts/run-mocha.js test/integration --exit",
+    "test": "npm run test:unit && npm run test:package",
+    "lint": "eslint -c eslint.config.mjs .",
+    "translate": "translate-adapter",
+    "release": "release-script"
+  }
 }