El contrato (apiVersion 1 a 27)¶
Tu archivo de entrada es un módulo ES que exporta una función async por cada capacidad que
declaraste, y no se llama nada que no hayas declarado:
export async function search(query) { /* -> Item[] or Page */ }
export async function home() { /* -> Row[] */ }
export async function browse(ref, cursor) { /* -> Page */ }
export async function episodes(ref) { /* -> { series?: SeriesInfo, episodes: Episode[], seasons?: Season[] } */ }
export async function resolve(ref) { /* -> Stream */ }
export async function prepare(ref) { /* la respuesta se ignora: prepara lo que resolve(ref) va a necesitar (opcional, cualquier apiVersion, Kino 0.9.88) */ }
export async function details(ref) { /* -> SeriesInfo or null (apiVersion 8, Kino 0.9.54) */ }
export async function liveCategories() { /* -> Array<LiveCategory | Playlist> or Playlist */ }
export async function liveChannels({ categoryId, cursor }) { /* -> { items: LiveChannel[], next? } */ }
export async function guide({ channelIds, from, to }) { /* -> GuideEntry[] */ }
export async function liveSearch({ query }) { /* -> { items: LiveChannel[] } */ }
export async function subtitles({ imdbId, tmdbId, kind, season, episode, title, year, languages, file }) { /* -> { lang, url, format?, label?, translated? }[] */ }
export async function track(event) { /* -> { ok: true } or { skipped: true }, or throw kino.error(code) (apiVersion 7) */ }
export async function segments(query) { /* -> { type, startMs, endMs }[] (apiVersion 7) */ }
export async function lyrics(query) { /* -> { synced?, plain?, label?, instrumental?, matchDurationMs? } o null (apiVersion 19) */ }
Desde "apiVersion": 6 (Kino 0.9.50) hay más exports opcionales, cada uno con su página:
sign (Firma por petición), migrate (Pasar lo guardado),
section y categories (Sección, categorías y colores), y settingsStatus,
action y validateSettings (Formulario de ajustes), y meta
(Describir otros títulos). subtitles (Subtítulos para cualquier título) no
necesita un apiVersion nuevo. Desde "apiVersion": 7 (Kino 0.9.51): track (Contarle a un
servicio de seguimiento qué ve la persona) y segments (Dónde están la intro y los
créditos). Desde "apiVersion": 8 (Kino 0.9.54): los tipos de ítem de
audio music y podcast (Música y podcasts) y el export opcional details (Los
detalles propios de un título). Y en cualquier apiVersion, desde Kino 0.9.54, un plugin que
lista títulos pero no reproduce ninguno puede decirlo con "catalogOnly": true (Plugins de solo
catálogo). Desde "apiVersion": 12 (Kino 0.9.74) un plugin puede ser el transporte de
la sincronización entre los aparatos de la persona con syncPull, syncPush y el opcional syncStatus
(Ser el transporte de la sincronización). En cualquier apiVersion, desde Kino 0.9.74,
un action también puede responder setSettings y link (Formulario de
ajustes). Desde "apiVersion": 13 (Kino 0.9.74): read
para un stream que sirve tu plugin e image para una imagen que sirve (Bytes e imágenes que sirve tu
plugin). Desde "apiVersion": 14 (Kino 0.9.74): screen y screenEvent para una
pantalla y job para un trabajo en segundo plano; un plugin con
playerPanelTab usa el export panel (Panel del reproductor). Y en cualquier
apiVersion, desde Kino 0.9.88, un plugin con resolve puede exportar prepare (Prepararse antes de
reproducir) o declarar "resolveAhead": true (Dejar listo un título por adelantado).
export async function read({ handle, offset, length }) { /* -> { bytes: base64 } (apiVersion 13, byteSource) */ }
export async function image({ handle }) { /* -> { bytes: base64, mime } (apiVersion 13, imageSource) */ }
export async function screen(ctx) { /* -> a tree of nodes (apiVersion 14, screen) */ }
export async function screenEvent(ev) { /* -> { state, toast, go, ui, config... } or null (apiVersion 14, screen) */ }
export async function job(ctx) { /* answer ignored (apiVersion 14, schedule) */ }
export async function storeSync({ reason, since, state }) { /* -> { full, entries, removed?, state? } (apiVersion 15, pluginStore) */ }
export async function storeList({ category, sort, cursor }) { /* -> { entries, next? } (apiVersion 15, a live store) */ }
export async function storeSearch({ q, category, cursor }) { /* -> { entries, next? } (apiVersion 15, a live store) */ }
Desde "apiVersion": 15 (Kino 0.9.77): storeSync, y storeList y storeSearch en una tienda
en vivo, para un plugin que es una fuente de plugins (Tiendas de plugins). identity y notifications
son declarativas y no exportan nada (Identidad, Avisos en la campanita); desde "apiVersion": 16,
coins tampoco exporta nada (kino.coins).
(kino.d.ts tiene las mismas formas como declaraciones de TypeScript.)
Usa exports con nombre (export async function ...). Los datos entran y salen de tu código como
JSON, así que devuelve datos simples: textos, números, booleanos, arreglos y objetos.
Las funciones de canales en vivo (liveCategories, liveChannels, y las opcionales guide y
liveSearch, apiVersion 3) tienen sus argumentos y reglas en Canales en vivo.
Argumentos¶
search(query)recibe{ q, type, season, episode, tmdbId, year, originalTitle, altTitles, cursor }:qes el texto que escribió la persona (puede estar vacío; devuelve[]).typees"movie"o"series"(o, apiVersion 8,"music"o"podcast") cuando Kino se inclina por ese tipo, y"any"si no. Es una pista, no un filtro: Kino lo saca de la división película/serie de TMDB, que casi nunca coincide con el catálogo propio de una fuente, y un título puede existir como las dos cosas. Devuelve todas las coincidencias posibles; usatype, como mucho, para poner primero el tipo que nombra.seasonyepisodeson0salvo que Kino esté buscando un capítulo específico;tmdbIdyyearson0cuando no se conocen.originalTitlees el título original de TMDB cuando es distinto deq(si no,""), yaltTitleshasta 5 títulos más que Kino conoce de la obra (cada uno de máximo 200 caracteres): pruébalos cuandoqno encuentra nada en una fuente que nombra las cosas en otro idioma.cursoresnull, salvo cuando la persona pidió más resultados y tu página anterior dijo dónde seguir (miraPageabajo).within(apiVersion 6, solo en un plugin que declarascopedSearch) aparece cuando la persona busca dentro de una de tus páginas "Ver más": mira Buscar dentro de un "Ver más".
home()recibenull.browse(ref, cursor)recibe elrefde una de tus filas de Inicio (o unrefque dio una página anterior), ycursornullpara la primera página o elnextde la página anterior.episodes(ref)recibe elrefde un ítemseries, tal como lo devolviste, o (apiVersion 8) elrefde un ítemmusicopodcast, para sus pistas o episodios.details(ref)(apiVersion 8, Kino 0.9.54) recibe elrefde un ítemmoviecuando se abre su página: mira Los detalles propios de un título.resolve(ref, options)recibe elrefde un ítemmovie, elrefde un capítulo, (apiVersion 2) elrefde un ítemliveo (apiVersion 8) elrefde un ítemmusicopodcastde un plugin sinepisodes.optionsesundefineden una llamada normal; solo un plugin apiVersion 6 con un stream firmado por petición lo recibe, como{ retry }. Desde apiVersion 6 también recibe elrefde una de tus copias perezosas, cuando esa copia hace falta.subtitles(arg)recibe{ imdbId?, tmdbId?, kind, season?, episode?, title?, year?, languages, file? }(ver Subtítulos para cualquier título) y devuelve un arreglo con la forma de lossubtitlesde unStream, cada entrada con unlabely untranslatedopcionales.
Lo que devuelves¶
Item = { id: string, ref: string, title: string, kind: "movie" | "series" | "live" | "music" | "podcast",
year?: string, poster?: string, backdrop?: string, overview?: string,
lang?: string, quality?: string, originalTitle?: string,
genres?: string[], rating?: number, runtimeMinutes?: number,
ids?: { tmdb?: number, imdb?: string }, badges?: string[], adult?: boolean,
artist?: string } // music, podcast, artist: apiVersion 8 (Kino 0.9.54)
Row = { id: string, title: string, items: Item[], ref?: string, genre?: Genre }
Genre = "peliculas" | "series" | "anime" | "infantil" | "documentales" | "deportes" | "noticias" | "musica" | "entretenimiento" | "otros"
Page = { items: Item[], next?: string }
SeriesInfo = { title?: string, poster?: string, backdrop?: string, overview?: string,
ids?: { tmdb?: number, imdb?: string, mal?: number, anilist?: number, kitsu?: number },
genres?: string[], year?: string,
rating?: number, runtimeMinutes?: number } // rating, runtimeMinutes, ids.mal/anilist/kitsu: Kino 0.9.54
Episode = { season: number, number: number, ref: string, title?: string,
still?: string, overview?: string, airDate?: string, runtimeMinutes?: number }
Season = { id: string, ref: string, title: string, number?: number, current?: boolean }
Stream = { url: string, mime?: string, headers?: Record<string, string>,
subtitles?: { lang: string, url: string, format?: "vtt" | "srt" }[],
audioTracks?: { lang: string, url: string, label?: string }[],
durationMs?: number, expiresInSeconds?: number,
drm?: { type: "widevine", licenseUrl: string, licenseHeaders?: Record<string, string> },
label?: string, // apiVersion 6
alternatives?: ({ url: string, mime?: string, headers?: Record<string, string>, label?: string }
| { ref: string, label?: string }
| { external: External, label?: string })[], // label y { ref }: apiVersion 6; { external }: 11
skip?: { openingStartMs?: number, openingEndMs?: number, endingStartMs?: number },
signing?: "request", signContext?: string, alternateHosts?: string[], // las tres últimas: apiVersion 6
external?: External, // apiVersion 11: en vez de url
media?: Media, // Kino 0.9.66: lo que sabes del archivo
portable?: { url: string, mime?: "application/x-mpegURL" } } // Kino 0.9.66: una copia HLS universal
External = { protocol: string, ref: string, resolver?: string }
Media = { title?: string, sizeBytes?: number, container?: string,
video?: { codec?: string, profile?: string, width?: number, height?: number, fps?: number, bitDepth?: number, hdr?: boolean },
audio?: { codec?: string, channels?: number, language?: string, title?: string, default?: boolean }[],
subtitles?: { codec?: string, language?: string, title?: string, text?: boolean }[],
converted?: boolean, notes?: string[] }
Género (Categorías y el filtro de En vivo). Una Row del Home, una LiveCategory de En vivo y una playlist pueden llevar un genre opcional. En una LiveCategory y en una playlist es una lista cerrada de diez ids: peliculas, series, anime, infantil, documentales, deportes, noticias, musica, entretenimiento, otros (Kino muestra sus nombres en español). En una Row del Home acepta cualquier categoría: un id o alias conocido (en español o inglés) se lleva al id base, y cualquier otra cosa se guarda como un slug (minúsculas ASCII [a-z0-9-], hasta 40 caracteres) y se agrega después de las conocidas; ver Home por categorías. Sirve para que Kino alinee categorías de plugins distintos: la pestaña Categorías agrupa por género las filas del Home que se pueden explorar (las que tienen ref, si declaras browse) de todos los plugins, y En vivo puede acotar sus categorías por género. En una categoría en vivo o una lista, un valor fuera de la lista se ignora, nunca es un error, y sin genre Kino lo adivina por el título de la fila o del grupo ("Deportes", "Noticias Colombia", "Kids"…), así que ponlo cuando tus títulos no lo digan. En una playlist el género es el de partida para los grupos de la lista (antes se intenta adivinar por el título de cada grupo). La pestaña Categorías (la antigua) sigue usando solo los diez ids: una fila con genre: "accion" o un slug nuevo tiene su ficha adivinada por el título. Las versiones de Kino anteriores a este campo lo ignoran.
Cómo se conectan las piezas¶
El ref de un ítem movie va a resolve. El ref de un ítem series va a episodes, y el ref
de cada capítulo va a resolve. El ref de un ítem live (apiVersion 2, mira
Canales en vivo) también va a resolve, y su Stream se reproduce en
vivo. El ref de un ítem music o podcast (apiVersion 8) va a episodes cuando lo declaras (sus
pistas o episodios, cada ref a resolve), y si no, directo a resolve (mira
Música y podcasts). El ref de una fila va a browse, y lo mismo el next de cada
página. El ref de una película también va a details cuando lo exportas (apiVersion 8,
abajo).
Temporadas¶
Hay dos formas, y tu respuesta de episodes dice cuál. Cuando todas las temporadas de una serie
están en una sola lista, dale a cada capítulo su season y deja seasons por fuera: Kino saca las
temporadas de los capítulos y muestra un selector que solo filtra la lista. Cuando tu fuente guarda
cada temporada como su propio ítem series (con su propio id y ref, como lo listaría una
búsqueda), devuelve solo los capítulos de esa temporada y lista todas las temporadas de la serie en
seasons, incluida la que estás respondiendo: { id, ref, title, number?, current? }, con title lo
que muestra el selector ("Temporada 2") y current: true en la temporada que se está listando (Kino
también la reconoce por id). Kino muestra las temporadas como chips; escoger otra llama a
episodes con el ref de esa temporada y la abre como ese título, con su propio progreso en la
biblioteca. seasons es opcional y nuevo en esta revisión de apiVersion 1: un plugin que nunca lo
devuelve sigue funcionando exactamente igual que antes.
Paginación ("Ver más")¶
Si declaras browse, una fila de Inicio con ref tiene una tarjeta "Ver más" que abre una
cuadrícula: Kino llama browse(ref, null) y después browse(ref, next) mientras la persona baja y
tú sigas devolviendo un next. search también puede devolver una Page; su next pone "Ver más
resultados de <name>" debajo de tus resultados, y Kino vuelve a llamar search con la misma
consulta y cursor: next. Un next (y el ref de una fila) solo se conserva cuando declaras
browse; sin eso Kino los descarta con una línea en el log. Los cursores son opacos para Kino: un
número de página, un desplazamiento, una URL, de máximo 2048 caracteres.
Los detalles propios de un título (details, apiVersion 8, Kino 0.9.54)¶
Un ítem de la búsqueda o del Inicio muchas veces trae solo un nombre y un póster. La página del título
muestra lo que traiga el ítem (overview, backdrop, genres, year, rating, runtimeMinutes) y,
en una serie, lo que agregue episodes(ref).series. Para una película no hay llamada a episodes,
así que puedes exportar details(ref): recibe el ref del ítem de la película y responde un objeto
SeriesInfo (o null: nada que agregar).
export async function details(ref) {
const page = await loadPage(ref); // tu propia función, idealmente con caché por ref
return { overview: page.plot, backdrop: page.fanart, genres: page.tags, year: String(page.year),
rating: page.score, runtimeMinutes: page.minutes };
}
- Desde
apiVersion8,detailses un nombre de export reservado: exporta una función con ese nombre solo con este significado (una función tuya que se llamedetailshay que renombrarla o no exportarla). No hay capacidad que declarar: Kino la llama solo si tu plugin la exporta y declaraapiVersion8 o más, así que un Kino anterior nunca la llama, y tampoco se llama nunca una funcióndetailspropia de un plugin anterior. - Kino la llama cuando se abre la página, junto con su búsqueda en TMDB (nunca antes de ella), con un
límite de 20 s (
timeoutsMs.details). Puede usarkino.browser.pagecomoepisodes. - Cuando el ítem no traía
ids, losidsde tu respuesta fijan la película en TMDB. Además detmdbeimdb, losids(endetailsy enepisodes().series) pueden llevar losmal,anilistykitsude un anime (Kino 0.9.54): entonces AniList y los pluginsmetade la persona se consultan con ellos. ratingva de 0 a 10 (como el de un ítem);runtimeMinuteses la duración de la película (elruntimeMinutesde una serie se ignora: es por capítulo).episodes(ref).seriestambién aceptaratingyruntimeMinutesdesde Kino 0.9.54; las versiones anteriores los ignoran.- Si tu
resolvenecesita la misma página que leyódetails, guárdala en una caché pequeña en tu módulo: la persona suele darle a reproducir justo después de abrir la página.
La página se arma con todas las respuestas, con un orden fijo por campo, sin importar en qué orden lleguen:
| Campo | Primero → último |
|---|---|
| sinopsis, año, géneros | TMDB → tu ítem → details → AniList → plugins meta |
| póster, fondo | tu ítem → details → AniList → plugins meta |
| nota | TMDB → tu ítem → details (también en la página de una serie: TMDB → tu ítem → episodes().series) |
| duración | TMDB → plugins meta → tu ítem → details |
| reparto; eslogan, dirección, clasificación | TMDB (el reparto, luego los plugins meta) |
| logo, notas de otros sitios | tu ítem → plugins meta |
Mientras details no haya respondido (hasta su límite), la sinopsis, el año, los géneros y el arte de
AniList y de los plugins meta lo esperan, porque details va antes que ellos; todo lo demás se muestra
de una vez.
Buscar dentro de un "Ver más" (scopedSearch, apiVersion 6)¶
Cada página "Ver más" (una fila de Inicio, una fila de tu sección, una de tus
Categorías) tiene un campo de búsqueda arriba ("Buscar en esta categoría"). Para todos los plugins,
Kino filtra por nombre los títulos que ya cargó esa página (sin importar tildes ni mayúsculas, cada
palabra en cualquier parte del título); con menos de 24 coincidencias sigue cargando las páginas
siguientes del mismo ref ("Buscando en más páginas…"), máximo 10 páginas o 300 títulos por ronda, y la
persona puede pedir otra ronda. Una consulta nueva cancela la que está corriendo.
Declara "scopedSearch" en capabilities (apiVersion 6, junto con search; no hay nada más que
exportar ni línea de consentimiento) para responder tú esa búsqueda, por ejemplo con la búsqueda de tu
backend restringida a esa categoría. Sin search el manifiesto se rechaza con "La capacidad
\"scopedSearch\" necesita también \"search\"". Kino llama tu search con la consulta de siempre más
within, el ref de browse de esa página tal como lo diste:
export async function search(query) {
if (query.within) {
const category = categoryOf(query.within); // tu propio ref
if (!category) return null; // "ahí no puedo buscar": Kino filtra la página él mismo
return searchCategory(category, query.q, query.cursor); // Item[] o Page, paginada por tu `next`
}
/* la búsqueda normal */
}
Ahí type siempre es "any", y season, episode, tmdbId y year son 0. La respuesta se revisa
como cualquier respuesta de búsqueda (los mismos topes, los títulos adult solo con el código +18
desbloqueado), y el next de una Page la pagina mientras la persona baja. Kino vuelve a su propio
filtro cuando respondes null, lanzas un error, o no has respondido a los 6 s (la página busca entonces
en sus propios títulos y descarta tu respuesta tardía; tu llamada conserva el límite de 15 s de la
búsqueda). Una falla llega al tablero de errores como cualquier llamada fallida, nunca con la consulta
ni el ref; responder null no es una falla. sdk/validate.mjs avisa cuando declaras scopedSearch y
tu archivo de entrada nunca lee within; pruébalo con
node sdk/run.mjs --within '<ref>' ./plugin.js search "texto".
id es estable, ref puede cambiar¶
id es la identidad de un título: de él cuelgan la biblioteca de la persona, su progreso y
"Continuar viendo", así que tiene que ser el mismo cada vez que vuelve el mismo título, en cada
búsqueda y en cada actualización de Inicio. ref es opaco para Kino: es solo lo que tus episodes
y resolve necesitan para volver a encontrar el título. Puede cambiar de una llamada a otra (las
fuentes vuelven a emitir enlaces), y Kino te puede entregar un ref que devolviste antes, por ejemplo
el que quedó guardado con un título en la biblioteca de la persona. Así que haz refs que sigan
funcionando; si los enlaces de tu fuente vencen, pon algo estable en el ref (un id) y busca el
enlace fresco dentro de resolve.
Kino es estricto, y tolerante con las listas¶
Cada lista se revisa entrada por entrada: una entrada mala se descarta (con una línea en el log) y
el resto sobrevive; lo que pasa de un tope se corta. Un Stream es todo o nada.
| Qué | Reglas |
|---|---|
Resultado de search |
Máximo 100 ítems (un Item[] o una Page). Un ítem live cuyo nombre no tiene nada que ver con la búsqueda se descarta: se queda solo si su nombre lleva al menos el 60 % de las palabras de 3 o más letras de alguna forma de la búsqueda (lo que se escribió, originalTitle o uno de altTitles), sin importar tildes ni mayúsculas -- la regla de kino.rank.filterRelevant. Las películas y series nunca se juzgan así (pueden llevar con razón otro título), y una búsqueda sin ninguna palabra así no descarta nada. Así que no respondas una búsqueda con toda tu lista de canales cuando nada coincide. |
Resultado de browse |
Una Page de máximo 100 ítems. |
Resultado de home |
Máximo 20 filas de máximo 60 ítems cada una. Una fila necesita un id único (mismo patrón que el id de un ítem) y un title no vacío; las filas sin ítems válidos se descartan. Kino las muestra después de sus propias filas, con el nombre de tu plugin, y las guarda 6 horas (las filas viejas se muestran mientras se actualizan; una respuesta sin filas válidas, o de más de 2 MB, no se guarda y se vuelve a pedir la próxima vez). Si home() falla no aportas filas y el Inicio no se bloquea. |
Resultado de episodes |
Máximo 5000 capítulos. number es obligatorio y va de 1 a 99999 (un capítulo con número 0, como un especial, se descarta). season debería ir de 1 a 999; una temporada que falta o está fuera de rango se vuelve 1. ref es obligatorio. Una temporada y número repetidos se descartan. Sin title, Kino muestra "Capítulo N". |
seasons (en el resultado de episodes) |
Opcional; máximo 50. Cada una necesita un id (mismo patrón que el id de un ítem; uno repetido se descarta), un ref no vacío de máximo 4096 caracteres y un title no vacío (hasta 200 caracteres), o se descarta. number de 1 a 999 y current booleano; uno mal puesto se ignora, no la temporada. Lo que no sea una lista se ignora. |
id |
^[A-Za-z0-9._~-]{1,128}$. Cualquier otra cosa descarta el ítem, así que si los ids de tu fuente tienen otros caracteres (espacios, /, :, %), deriva tú un id estable, como un slug. Los ids repetidos en una lista se descartan. |
ref |
Un texto no vacío de máximo 4096 caracteres. |
kind |
"movie", "series", (apiVersion 2) "live" o (apiVersion 8) "music" o "podcast"; un ítem live se queda en una fila de home solo desde apiVersion 6 (por debajo se quita del Inicio: mira Canales en tus filas de Inicio). Un ítem series de un plugin que no declara episodes se descarta: nunca se podría abrir; un ítem live de un plugin apiVersion 1 también se descarta (mira Canales en vivo), y un ítem music o podcast de un plugin por debajo de apiVersion 8 (mira Música y podcasts), que no necesita episodes. |
| Campos de texto | title es obligatorio y no vacío, hasta 200 caracteres. overview hasta 2000; lang y quality hasta 20 (por ejemplo "es", "1080p"); year hasta 10 (se acepta un número y se convierte). El texto más largo se corta; el texto de SeriesInfo y Episode se corta igual (200 caracteres para títulos, 2000 para sinopsis). |
| Campos extra del ítem | Todos opcionales; uno mal puesto se ignora, no el ítem. genres máximo 5, cada uno de máximo 30 caracteres; badges (se muestran como chips, p. ej. "HD", "Latino") máximo 3 de máximo 20; rating de 0 a 10; runtimeMinutes de 1 a 1000; ids.tmdb un entero positivo (Kino lo usa para emparejar tu título con TMDB, para volver a encontrarlo desde la búsqueda y para enriquecer su página de información -- mira abajo); ids.imdb cumple ^tt\d{5,10}$ (también enriquece la página de información de una película cuando no tienes ids.tmdb). El airDate de un capítulo es YYYY-MM-DD. |
adult |
Desde apiVersion 6, adult: true marca una entrada +18: Kino la muestra solo mientras el código +18 de la persona está desbloqueado en ese aparato (Ajustes ▸ Control parental), y la vuelve a esconder cuando lo bloquea; por debajo de apiVersion 6 se descarta. Aplica en Inicio, en la búsqueda, en "Ver más", en tu sección y en Categorías. Mira Contenido +18. |
| Imágenes | poster, backdrop y still tienen que ser URL http o https de máximo 2048 caracteres, o se ignoran (las versiones de Kino anteriores a la que aceptó http en imágenes ignoran las http). Las imágenes las carga Kino directamente y no se revisan contra hosts (son solo para mostrar), y Kino no envía tus headers ni tus cookies con ellas. Es la única excepción a la regla de hosts, con un límite: una imagen en la red local, en una dirección IP privada o reservada, o en un nombre local (localhost, .local, .lan, …) también se ignora, y también un nombre sin punto por http (router, nas), salvo que esté en un servidor que la persona escribió en tus ajustes. Una dirección IPv4 pública sirve. Desde apiVersion 13 (Kino 0.9.74) un plugin que declara imageSource puede responder, en lugar de una URL, una referencia de imagen { "source": "plugin", "handle": "…" } en poster, backdrop, still y la image del encabezado de una sección: Kino le pide entonces los bytes a su export image (Imágenes del plugin); de cualquier otro plugin, o en cualquier otro lugar, una referencia se ignora. Sin URI data:: un texto siempre es una URL. |
ids.tmdb enriquece la página de información, no solo el emparejamiento¶
Cuando TMDB tiene exactamente este título (emparejado por ids.tmdb, o por ids.imdb en una
película cuando no diste ids.tmdb), al abrirlo se agregan tres tipos de campo, cada uno llenado de
forma distinta:
- Solo TMDB los tiene, así que siempre vienen de ahí: un eslogan, el director o (en una serie) el creador, el reparto y la clasificación por edad.
- TMDB gana siempre que tenga respuesta; el tuyo solo es el respaldo de lo que TMDB dejó vacío: el año y los géneros. Un título con su propio año o géneros igual muestra los de TMDB una vez emparejado, no los suyos.
- El tuyo gana cuando lo diste; TMDB solo llena el hueco: la sinopsis (solo se reemplaza si la tuya estaba vacía), la calificación (solo si la dejaste por fuera) y la duración de una película (solo si no la pusiste -- la duración de una serie nunca se toca, ni la de TMDB; se muestra por capítulo, no para toda la serie).
No agrega un póster, un fondo ni temporadas desde TMDB -- esos quedan exactamente como los dio
tu respuesta de Item/SeriesInfo/episodes, o vacíos si los dejaste por fuera.
Kino 0.9.54 cambia el tercer grupo. Desde 0.9.54 TMDB va primero también para la sinopsis, el año,
los géneros, la nota y la duración de una película, tanto en la página de una película como en la de una
serie: tus valores son el respaldo de lo que TMDB dejó vacío. El orden completo por campo, con el nuevo
export details, AniList y los plugins meta, está en Los detalles propios de un título.
Los títulos de música y podcast nunca se emparejan con TMDB.
Las reglas del Stream¶
Desde apiVersion 13 (Kino 0.9.74), un plugin que declara byteSource puede responder en su lugar un stream sin URL,
{ source: "plugin", handle, size, mime }, cuyos bytes Kino le pide a tu export read; las reglas de abajo sobre url
no aplican a él, y sus propias reglas están en Sockets y bytes del plugin.
urltiene que serhttpsy su host tiene que ser uno de tushosts, igual que el host de cada URL de subtítulos, o estar en un servidor que la persona escribió en tus ajustes (exactamente ese esquema, host y puerto). La otra única vía ahttpplano es un host que declaraste{ "host": "…", "insecureHttp": true }(apiVersion 2, mira el manifiesto): ese host, exacto, aceptahttppara el stream, sus subtítulos, sus pistas de audio y su licencia. Un stream que rompe esto se rechaza completo; un subtítulo malo se descarta y el stream igual se reproduce. Dos cosas aflojan esto para una película o un episodio: un manifiesto constreamHosts: "any"y el permiso amplio de video de la persona; y por un host que se te olvidó se puede preguntar en vez de rechazarlo.mimees opcional, con la formavideo/mp4(cualquier otra cosa rechaza el stream). Cuando falta, el reproductor de Kino detecta HLS, DASH o un archivo simple por la URL y el contenido.- Todo lo que el reproductor pide para el stream sigue las reglas de hosts de
kino.fetch. Eso cubre laurlmisma, las variantes, segmentos y llaves#EXT-X-KEYque nombra un manifiesto HLS, losBaseURLde un manifiesto DASH, los subtítulos y cada salto de redirección de cualquiera de ellos: cada uno tiene que serhttpsen uno de tushosts(ohttpen uno que declarasteinsecureHttp), nunca una dirección IP ni un nombre local, y un nombre declarado que resuelve dentro de la red de la persona se rechaza. Una petición que rompe esto falla antes de salir del dispositivo y la reproducción se detiene con un error, así que un manifiesto que apunta a otro CDN necesita ese CDN enhosts. - Los
headersse envían con cada una de esas peticiones del reproductor (el stream, los segmentos y llaves de su manifiesto, sus subtítulos y los saltos de redirección, todo en tushosts) y, si declarasdownload, con cada petición que guarda el stream en el dispositivo (en HLS: las playlists, la llave y cada segmento) — y en ninguna otra parte. Máximo 20; los nombres son letras, dígitos y guiones; los valores tienen máximo 4096 caracteres sin saltos de línea;Host,Content-Length,Transfer-EncodingyConnectionse ignoran. subtitles: máximo 30, cada uno{ lang, url, format? }.langes un código de idioma corto como"es"(hasta 20 caracteres; vacío se vuelve"und"),formates"vtt"o"srt".-
audioTracks: máximo 8, cada una{ lang, url, label? }-- un doblaje o una mezcla alterna que tu fuente sirve como archivo propio, aparte del video. Se revisa exactamente como un subtítulo:urltiene que serhttpsen un host declarado, o el servidor propio de la persona exactamente como lo escribió; una entrada mala se descarta y el resto del stream se reproduce igual, y lo mismo unaurlque ya estaba en la lista (gana la primera entrada).langhasta 16 caracteres (vacío se vuelve"und");label, hasta 40 caracteres, se muestra tal cual en el menú de audio cuando lo das, en vez de un nombre adivinado a partir delang. Kino une cada una al video y la ofrece, escogida automáticamente según la preferencia de audio de la persona, en el mismo menú que las pistas que trae el contenedor. Un stream sinaudioTracksse reproduce exactamente como siempre. Ejemplo, una fuente que dobla a dos idiomas:return { url: videoUrl, audioTracks: [ { lang: "es-419", url: dubUrl("es"), label: "Español (Latinoamérica)" }, { lang: "en", url: dubUrl("en") }, ], }; -
alternatives(máximo 8, cada una{ url, mime?, headers? }): otras copias del mismo video, la mejor primero. Cuandourlno se puede reproducir en el aparato (un códec para el que no tiene decodificador, un archivo roto o no soportado) o ya no está (404, 403), Kino pasa solo a la siguiente alternativa, en el mismo punto, y solo muestra un error cuando no queda ninguna. Una red caída no es razón para cambiar: eso se reintenta como siempre. Cada entrada se revisa exactamente comourl,mimeyheaders; una mala se descarta y las demás siguen contando. Comparten lossubtitlesyaudioTracksdel stream. Se ignoran junto adrm, consigning(la conmutación de un stream firmado esalternateHosts) y en un canal en vivo. Devuélvelas cuando tu fuente ofrece varios archivos de un título (otros servidores, resoluciones, codificaciones): un aparato que no puede decodificar el primero igual alcanza a verlo. Cada alternativa tiene que ser el mismo video en el mismo idioma (el mismo doblaje, los mismos subtítulos quemados o no): Kino cambia entre ellas por su cuenta, así que una copia doblada listada junto a la original le cambiaría el idioma a la persona. Ofrece otro idioma como otro stream (otro resultado de búsqueda u otra fuente del capítulo), nunca como alternativa. Desde Kino 0.9.54, después de varias pausas para cargar, Kino también pasa una vez, por su cuenta, a una copia claramente más liviana (como mucho tres cuartos de la altura en pantalla) cuando las etiquetas lo dicen: nombra la resolución en la etiqueta ("Streamwish · 720p","4K","Full HD"); unHDoSDa secas nunca alcanza para eso. Desde apiVersion 6 una alternativa puede llevar unlabel, o ser una{ label, ref }perezosa que se resuelve solo cuando hace falta: ver Copias con etiqueta y perezosas. label(apiVersion 6): el nombre corto del Stream, y cada alternativa puede llevar el suyo -- por ejemplo"Latino · Servidor 1". Se recorta; máximo 48 caracteres, sin caracteres de control, o se descarta (la copia igual se reproduce). Cuando un Stream tiene dos o más copias, el reproductor las muestra todas, por etiqueta, en una sección Servidor arriba de su menú "Audio y subtítulos" (celular y TV, alcanzable con el control), donde la persona puede cambiar en cualquier momento y seguir viendo desde el mismo punto; una copia sin etiqueta sale como "Opción 2", "Opción 3"… Las etiquetas también van al registro del plugin, solo con el host (nunca una URL ni un token).signing,signContextyalternateHosts(apiVersion 6): un stream HLS que necesita una firma fresca en cada petición. Tienen su propia página: Firma por petición.durationMses opcional, en milisegundos.-
skipes opcional: dónde están la entrada y el cierre de ESTE archivo, en milisegundos desde su comienzo --{ openingStartMs?, openingEndMs?, endingStartMs? }. Kino muestra su botón "Saltar intro" desdeopeningStartMs(0 si falta o esnull) hastaopeningEndMs, y "Saltar outro" (al siguiente capítulo) desdeendingStartMs. Cada valor debe ser un número finito entre 0 ydurationMs(o 24 h si no dasdurationMs); la entrada necesita suopeningEndMs, después de su inicio;endingStartMsno puede ir antes del final de la entrada. Una parte mala se descarta y el resto sigue contando; unskipmalo nunca detiene el stream. Manda los tiempos del archivo exacto que devuelves: otro corte del mismo capítulo tiene la entrada en otro lado. Kino los guarda como las marcas del capítulo, también para una copia descargada, y se sincronizan con el otro aparato de la persona. Una corrección que la persona hace a mano siempre le gana a la tuya; la tuya le gana a los tiempos de la comunidad que Kino busca por su cuenta para anime (AniSkip), que ni se consulta cuando mandasskip. Se ignora en un canal en vivo. Las versiones anteriores de Kino ignoran el campo.return { url: videoUrl, durationMs: 1_420_000, skip: { openingStartMs: 62_000, openingEndMs: 152_000, endingStartMs: 1_290_000 } }; -
expiresInSeconds(de 30 a 86400) dice cuándo puede dejar de funcionar tu URL. Si la reproducción falla después de ese tiempo, Kino llama aresolveuna vez más y sigue donde iba la persona. media(opcional, Kino 0.9.66; un Kino más viejo la ignora) dice lo que sabes del archivo en sí: sutitle,sizeBytesycontainer, suvideo(codec,profile,width,height,fps,bitDepth,hdr), sus pistas deaudioysubtitles(codec,language,title, ydefault/text), si loconvertedpara reproducirlo y unasnotescortas. Es informativa: Kino la muestra y la registra y puede usarla de pista (para enviar a la TV), pero nunca se fía de ella para nada que pueda perjudicar a la persona. Todos los campos son opcionales y se limpian: el texto es una línea (sin caracteres de control, espacios colapsados) cortada a 120 caracteres (codec/container40,language20), los números se acotan (width/heighta 16384,fpsa 480,bitDeptha 16,channelsa 32,sizeBytesa 2^50), como máximo 16 pistas y 4notes; un objeto sin nada útil se descarta. Unamediamala nunca rechaza el stream. Detalles.portable(opcional, Kino 0.9.66; un Kino más viejo la ignora) es una copia universal de este mismo video junto aurl:{ url, mime? }, un HLS (application/x-mpegURL) que reproduce cualquier receptor de TV (H.264 de 8 bits hasta 1080p con AAC estéreo). Solo le sirve a una fuente que pueda fabricarla bajo demanda; el reproductor del celular nunca la usa, y Kino la envía a la TV solo cuando la ruta propia del título exigiría una conversión o el stream probablemente no se reproduce tal cual. Se revisa exactamente comourl(las mismas reglas de hosts); cualquier otra cosa, unmimeque no sea HLS incluido, se descarta y el resto de la respuesta sigue valiendo. Se ignora junto adrm, lasigningpor petición oexternal. Detalles.clockLive(apiVersion 27, Kino 0.9.88; solo streams en vivo): en lugar de la dirección de una lista, el reloj de medios de un CDN que nombra sus segmentos con él, con el que Kino arma la ventana en vivo él mismo. A su lado laurlse ignora (envía"", o la dirección que reproduce un Kino anterior), y tambiénalternativesy lo que un canal en vivo nunca usa; undrm, una firma por petición (signing) o unexternala su lado rechazan el stream. Kino lo lee solo de un plugin cuyo apiVersion efectivo es 27 (enhancements["27"]lo enciende sin subir el tuyo). En vivo por reloj.- DRM solo si se declara. Un stream que traiga cualquiera de
drm,license,licenseUrl,drmLicenseUrl,keySystemowidevinese rechaza ("El video tiene DRM y los plugins no lo soportan") -- salvo que tu manifiesto declare la capacidaddrm(apiVersion 2) y la única clave de ese tipo sea un bloquedrm{ type: "widevine", licenseUrl, licenseHeaders? }: ahí Kino lo reproduce como Widevine.licenseUrlse revisa exactamente comourl(https en uno de tushosts, o el servidor propio de la persona), ylicenseHeadersse filtran como losheaders(máximo 20) y solo se envían con la petición de licencia. Las otras cinco claves se rechazan aunque estén junto a un bloquedrmválido. Mira Un stream protegido con Widevine.
Copias con etiqueta y perezosas (apiVersion 6)¶
Una fuente suele tener el mismo capítulo en varios idiomas y en varios servidores, y encontrar el video
de cada servidor cuesta tiempo (una página que abrir, a veces una captura del
navegador oculto de 5 a 25 s). Resolverlos todos antes del primer cuadro haría lento cada
play. Desde "apiVersion": 6, las alternatives de un Stream pueden nombrar una copia sin
resolverla: { label, ref } en vez de { url }. Kino le pasa ese ref a tu resolve(ref) solo
cuando la copia de verdad hace falta:
- la persona la escoge en el menú Servidor del reproductor (la copia en pantalla sigue reproduciéndose mientras abre, y después la nueva arranca en el mismo punto; si falla, lee "No se pudo abrir …" y sigue viendo la copia que tenía);
- el cambio automático llega a ella (la copia en pantalla no se puede reproducir en este aparato, o ya no está);
- la elección de copia de una descarga llega a ella (dentro del mismo presupuesto de 30 s que gasta probando copias; una copia perezosa que no ha respondido para entonces se salta, nunca se espera).
Esa llamada es un resolve normal: el mismo límite de tiempo (75 s para un plugin
browser aprobado) cuando la persona escogió la copia -- decidió esperarla -- pero
máximo 20 s cuando la pidió el cambio automático, y después Kino la cancela (terminando una captura
que siga corriendo) y pasa a la siguiente copia; las mismas revisiones de lo que devuelve,
kino.browser.capture permitido (en la elección de copia de una descarga: solo si no hay otra página
abierta; si no, busy y la copia se salta), y las preguntas de host como para el título. De su
respuesta Kino usa url, headers, mime, subtitles (cuando trae; si no, se quedan los del título),
expiresInSeconds (una copia perezosa vencida se resuelve de nuevo, no todo el título) y skip (muestra
"Saltar intro" mientras se reproduce esa copia, nunca se guarda: el skip del Stream sigue siendo el del
capítulo, y una corrección a mano sigue ganando). Sus propias alternatives se ignoran -- una copia
nunca se abre en más copias. Un resolve que falla pasa a la siguiente copia.
export async function resolve(ref) {
// El ref propio de una copia: "<capítulo>|<servidor>". Resuelve solo ese servidor.
if (ref.includes("|")) return resolveServer(ref);
const servers = await listServers(ref); // [{ id, lang, name }], rápido: aún sin abrir página
const first = await resolveServer(`${ref}|${servers[0].id}`);
return {
...first,
label: `${servers[0].lang} · ${servers[0].name}`, // "Latino · Servidor 1"
alternatives: servers.slice(1, 9).map((s) => ({
label: `${s.lang} · ${s.name}`, // "Subtitulado · Servidor 2"
ref: `${ref}|${s.id}`,
})),
};
}
Reglas: ref es un texto no vacío de máximo 512 caracteres sin caracteres de control (uno malo o
repetido se descarta); una entrada con url es una copia normal, lleve lo que lleve; las copias
perezosas y las concretas se mezclan libremente y comparten el límite de 8; cada label se recorta,
máximo 48 caracteres, sin caracteres de control, o se descarta mientras la copia sigue contando. Que el
ref alcance para volver a encontrar ese servidor: puede resolverse minutos después del título (una
persona que cambia de servidor a mitad del capítulo). Por debajo de apiVersion 6 las llaves son
desconocidas: un label se ignora y una entrada { ref }, al no tener url, se descarta igual que
antes. Pruébalo con node sdk/run.mjs ./plugin.js resolve '<ref>', que imprime cada copia con su
etiqueta, y luego resolve '<el ref de una copia>' para resolver esa copia.
Un plugin completo que captura su primer servidor y ofrece los demás así está en Navegador oculto.
Dejar que otra app resuelva lo que encontraste (externalResolve, apiVersion 11, Kino 0.9.66)¶
A veces tu plugin sabe exactamente qué encontró pero no puede convertirlo él mismo en una URL reproducible: eso
necesita una app de Android aparte, instalada por separado. Desde "apiVersion": 11, declara la capacidad
externalResolve (declarativa: no hay nada que exportar) y haz que resolve() -- o una entrada de las
alternatives de un Stream -- responda { external: { protocol, ref } } en vez de { url, ... }:
export async function resolve(ref) {
return { external: { protocol: "my-protocol", ref: "some-opaque-reference" } };
}
protocol es una cadena que tú eliges (de 1 a 64 caracteres de a-z 0-9 . _ -; Kino nunca la interpreta), ref
es opaco (de 1 a 2048 caracteres, sin caracteres de control, nunca se registra completo) y el resolver
opcional es el paquete de Android de la única app que quieres: pasa por encima del
externalResolver del manifiesto, y con él puesto no se le pregunta a ninguna
otra app. Kino busca una app que declare protocol, le pide permiso a la persona la primera vez, le pasa ref y
espera una respuesta con la forma de una respuesta normal de resolve(). Desde tu plugin, supón una de dos
cosas: se reproduce, o falla como cualquier otro fallo de resolve(). Úsalo solo cuando de verdad no puedas
producir tú una url, y ten una alternativa cuando puedas. Todo lo demás -- el flujo completo, lo que ve la
persona, media y portable, enviar a la TV, construir el otro lado -- está en
Aplicaciones resolutoras externas.
Por un host que se te olvidó se puede preguntar, una vez¶
Cuando la persona abre un título en el reproductor y lo único malo de tu Stream es que una URL (el
video, su licencia, un subtítulo o una pista de audio) está en un host https que no declaraste, Kino
le pregunta en el momento ("El video está en <host>, un servidor nuevo para este plugin.
¿Permitir?"), el mismo diálogo que recibe un kino.fetch a un host no declarado.
El reproductor también pregunta cuando se encuentra un host nuevo en plena reproducción (un
manifiesto, un segmento, una redirección). "Permitir" agrega ese host a los hosts aprobados de tu
plugin (no hay tope de cuántos puede aprobar una persona así; una actualización los conserva) y el
video se reproduce; "Rechazar" (o Atrás) queda recordado para tu plugin -- el video falla como se
describe arriba, un subtítulo o una pista de audio se descartan -- y nunca se vuelve a preguntar por
ese host hasta que la persona elija "Olvidar rechazos de host". Nunca se pregunta por una dirección
IP, un nombre local, http plano ni un stream roto de cualquier otra forma, y no se pregunta nada
cuando nadie está mirando: una descarga falla en ese host. No te confíes: declara los hosts que usan
tus streams.
El permiso amplio de video¶
Para una película o un episodio, esos diálogos de video, subtítulos y audio tienen una tercera opción,
"Permitir video de cualquier servidor". Es un permiso que da la persona, visible y revocable en
Ajustes ▸ Plugins ("Puede reproducir video desde cualquier servidor", "Quitar permiso de video
amplio"); la única forma de que tú pidas la misma regla de entrada es
streamHosts: "any" (apiVersion 4), aprobado en la hoja de
consentimiento. Una actualización o una reinstalación lo conservan; desinstalar lo quita.
Mientras está activo, el Stream de tu película o episodio se revisa como el de un canal en vivo con
liveStreamHosts: "any": su url, todo lo que nombra su
manifiesto, cada salto de redirección y sus subtitles y audioTracks pueden estar en cualquier
host público, por http o https, incluida una dirección IPv4 pública, y nunca más se pregunta por
un host de video para tu plugin. Una descarga de una película o un episodio
sigue la misma regla. Nunca cubre:
- la red de la casa: direcciones privadas, de loopback, link-local y CGNAT, literales IPv6, nombres locales y un nombre público que resuelve dentro de la LAN;
- la
licenseUrlde un bloquedrm(sigue solo en tus hosts, con la pregunta de arriba); kino.fetch: tu propio código sigue llegando solo a tus hosts y a los aprobados uno por uno;- los canales en vivo, que tienen su propia regla.
Existe para fuentes cuyos servidores de video cambian de dominio en cada video o en plena reproducción; un plugin con un CDN fijo debería igual declararlo.
Música y podcasts (apiVersion 8, Kino 0.9.54)¶
Con "apiVersion": 8 un ítem puede ser audio: kind: "music" (un álbum, una lista o una sola pista) o
kind: "podcast" (un programa o un audiolibro), en search, browse, las filas de home y tu
sección, junto a tus películas y series. No hay nada que declarar aparte de la versión: un ítem de audio
no necesita la capacidad episodes. Un Kino anterior a 0.9.54
rechaza un plugin apiVersion 8 con "Este plugin necesita una versión más nueva de Kino", así que declara
8 solo cuando devuelvas ítems de audio o exportes details.
export async function search(q) {
return [
{ id: "album-42", ref: "album:42", title: "Un álbum", kind: "music", artist: "Los Artistas", poster: "https://cdn.example.org/a42.jpg" },
{ id: "show-7", ref: "show:7", title: "Un podcast", kind: "podcast", overview: "Una charla por semana" },
];
}
export async function episodes(ref) { // solo con la capacidad "episodes"
if (ref.startsWith("album:")) return { episodes: [
{ season: 1, number: 1, ref: "track:1", title: "Primera canción", runtimeMinutes: 4 },
{ season: 1, number: 2, ref: "track:2", title: "Segunda canción", runtimeMinutes: 5 },
] };
// ...los episodios de un podcast, los capítulos de una serie
}
Cómo se conectan las piezas:
- Con
episodesdeclarada, Kino llamaepisodes(ref)con elrefdel ítem, para cada ítemmusicypodcast: las pistas de un álbum o una lista, los episodios de un podcast, los capítulos de un audiolibro, en tu orden (una sola pista responde una entrada).numberes el número de pista o de episodio,title,still(la portada) yruntimeMinutesfuncionan como en cualquier capítulo, y elrefde cada entrada va aresolve. Si declarasepisodes(para tus series, por ejemplo), tuepisodestambién tiene que responder por cadarefdemusicypodcast, aunque sea una pista suelta: no hay forma de saltárselo por ítem. - Sin
episodes, elrefdel propio ítem va directo aresolvey se reproduce como una sola pista, igual que el de una película. artist(opcional, solo enmusicypodcast) es el artista (música) o quien conduce o escribe (podcast): se recorta, máximo 200 caracteres, y se ignora en cualquier otro tipo. La página del álbum o del podcast lo muestra como la línea debajo del título (y Kino lo nombra como artista donde reproduce el audio). Sin él no hay esa línea: Kino nunca la saca deoverviewni degenres.ids(opcional) nombra además, en un ítemmusicopodcast(apiVersion 19), los ids con los que un plugin de letras puede reconocer la canción:youtube(un id de video, el más exacto para YouTube Music),isrc,musicbrainz; cada uno un texto de 1 a 64 caracteres, los demás se omiten. Kino los guarda con el artista del ítem en el aparato (una caché que se vuelve a aprender la próxima vez que el ítem aparece en una lista) y los envía en elidsde la consulta delyricsmientras suena.runtimeMinutesse conserva en un ítem de audio (a diferencia de unolive).searchpuede recibirtype: "music"otype: "podcast"cuando Kino se inclina hacia ahí;"any"los incluye, y sigue siendo una pista.- El
Streames uno normal: audio progresivo (MP3, M4A, AAC, OGG) o un manifiesto HLS/DASH. El tipo es una pista: un stream que resulta traer video igual se reproduce como video. migratepuede responder un título guardado como{ kind: "music" | "podcast", id, ref }(por debajo de apiVersion 8 esa respuesta no reclama nada).
Lo que la persona recibe con ellos en Kino 0.9.54:
- Títulos de audio en portadas cuadradas, en filas propias del Inicio, después del video en la búsqueda y en su propia sección de la biblioteca. Se mantienen lejos de TMDB y de las recomendaciones.
- Una página de álbum o de podcast en celular y TV, con "Reproducir", "Aleatorio" y la lista de pistas, en lugar de la página de título de video.
- Un reproductor de audio para música y podcasts a pedido: el nombre y la portada de la pista, adelantar y retroceder, anterior y siguiente (también desde la notificación y los audífonos), y la siguiente pista a los 2 s. Un podcast sigue exactamente donde quedó y cuenta como terminado solo en sus últimos 30 s.
- "Seguir escuchando", una fila del Inicio para podcasts (el audio sale de "Continuar viendo").
- Descargas, cuando declaras
download(apiVersion 2): los archivos de audio progresivos y el HLS solo de audio se guardan como un video, y un álbum descargado se reproduce sin conexión en el reproductor de audio. - Enviar a la TV: una pista va a un Chromecast como música, con su título, artista, álbum y portada, y a una TV DLNA como ítem de audio; una pista +18 solo envía el nombre de la app.
Límites: un ítem music o podcast de un plugin por debajo de "apiVersion": 8 se descarta (con una
línea en el log), y el resto de la respuesta se queda. Los ítems de audio cuentan para los mismos
tamaños de fila y de página que cualquier ítem, y adult: true sigue el mismo bloqueo +18.
Playlists de la persona en el plugin (apiVersion 10, Kino 0.9.65)¶
Con "apiVersion": 10 un plugin puede declarar la capacidad "playlists": el contrato con el que,
el día que la interfaz de Kino la conecte, las listas que la persona ya tiene en su cuenta de ese
servicio aparecerán dentro de "Mis listas" de Kino, junto a las suyas. Por ahora es solo eso -- un
contrato completo y honesto, sin ninguna conexión todavía a esa interfaz: ningún plugin instalado ni
anunciado usa esta capacidad, y el propio Kino no llama ninguno de estos seis exports en ninguna
pantalla. Es infraestructura para un plugin futuro que pueda necesitarla, no algo que alguien use hoy.
A diferencia de música y podcasts (arriba), esta sí es una capacidad de verdad -- igual que channels
o tracking -- pero al revés de channels: sus seis exports son todos independientemente
opcionales, incluido playlists() mismo. Declara la capacidad y exporta solo los que tu servicio
sabe hacer; no hace falta ni uno. Sin aprobación en rojo. Un Kino anterior a 0.9.65 rechaza un plugin
apiVersion 10 con "Este plugin necesita una versión más nueva de Kino", así que declara 10 solo cuando
declares esta capacidad.
"playlist" significa tres cosas distintas y sin relación en este SDK: las de esta sección, en el
servicio de tu plugin (KinoHostedPlaylist); la lista M3U/IPTV que armas para
Canales en vivo (KinoPlaylist, y los límites live.maxPlaylists de
contract.json); y el kind: "playlist" que firmas en Firma por petición
(una petición de manifiesto HLS, nada que ver con una lista de títulos). Ninguna capacidad ni export de
una aplica a las otras dos: cada una vive solo en su propia sección.
export async function playlists() {
return [{ id: "42", title: "Mi lista de siempre", itemCount: 12 }];
}
export async function playlistItems({ playlistId, cursor }) { // misma forma que browse
return { items: [ /* ...KinoItem[]... */ ], next: null };
}
export async function playlistCreate({ title }) {
return { id: await createRemotePlaylist(title) };
}
export async function playlistAddItem({ playlistId, ref }) { /* ... */ }
export async function playlistRemoveItem({ playlistId, ref }) { /* ... */ }
export async function playlistReorder({ playlistId, refs }) { /* ... */ }
Qué responde cada export:
playlists()responde las listas que la persona ya tiene en el servicio: un arreglo de{ id, title, itemCount }(KinoHostedPlaylist).playlistItems({ playlistId, cursor })responde el contenido de una lista, con la misma forma quebrowse: un arreglo deKinoItemo unaPageconnext.playlistCreate({ title })responde{ id }cuando tu servicio puede crear una lista nueva. Sin este export, la interfaz de Kino no ofrecerá "Crear lista nueva" para tu plugin.playlistAddItem({ playlistId, ref })yplaylistRemoveItem({ playlistId, ref })agregan o quitan un ítem; son independientes entre sí -- puedes tener uno sin el otro.playlistReorder({ playlistId, refs })recibe el nuevo orden completo de la lista, como el arreglo derefde cada ítem, en el orden final.
Lo que hará la interfaz de "Mis listas" el día que Kino la conecte a esta capacidad (todavía sin
construir en ninguna versión): una lista de tu plugin se etiquetará "‹nombre› · ‹plugin›", mezclada
con las suyas. Solo aparecerá el botón de la operación que de verdad exportaste -- "Agregar" con
playlistAddItem, "Quitar" con playlistRemoveItem, "Reordenar" con playlistReorder -- nunca un
botón apagado ni un error por "no implementado"; un plugin que solo exporta playlists y
playlistItems se verá de solo lectura, sin ninguno de los tres. Renombrar la lista o eliminarla
entera no serán parte de esta capacidad: no hay export para ninguna de las dos, así que esas dos
opciones del menú de "Mis listas" existirán solo para una lista nativa de la persona, nunca para una
de plugin.
Límites: declarar la capacidad playlists con un apiVersion menor a 10 se rechaza al instalar el
plugin (The "playlists" capability needs apiVersion 10). En la hoja "Agregar a lista", una lista de
tu plugin aparecerá solo para un título que venga del mismo plugin que la hospeda -- agregar un video
a "tu lista de YouTube" solo tendrá sentido para un video de ese plugin de YouTube.
Subtítulos para cualquier título¶
Exporta subtitles({ imdbId, tmdbId, kind, season, episode, title, year, languages, file }) y Kino lista lo
que respondas en "Buscar subtítulos en línea" del reproductor (celular y TV), bajo el nombre de tu
plugin, junto a OpenSubtitles y SubDL: para cualquier película o capítulo que la persona reproduzca
-- tus títulos, los de otro plugin, los de un addon de Stremio -- siempre que Kino conozca su id de IMDb
o de TMDB (un título que solo se conoce por nombre nunca te llega). La persona escoge una pista, Kino la
descarga, la convierte a SRT y la agrega como cualquier subtítulo en línea (desfase, estilo, recordado
para el título).
Dos formas de ofrecerlo:
- Un proveedor de subtítulos:
"capabilities": ["subtitles"]y nada más. No hace faltaresolve,searchnihome; el plugin no aparece en ninguna parte salvo en la búsqueda de subtítulos y en Ajustes ▸ Plugins (no es una fuente en "Elige tus plugins"). La pantalla de consentimiento dice "Agrega subtítulos a tus películas y series". Las versiones anteriores de Kino rechazan una capacidad que no conocen: no lo instalan. - Junto a tus videos: deja tus capacidades y solo exporta
subtitles(declarar tambiénsubtitlesagrega la línea de consentimiento, pero entonces las versiones anteriores de Kino rechazarían el plugin). Kino le pregunta a todo plugin cuya instalación encontró el export; las versiones anteriores nunca lo llaman.
El argumento: imdbId (tt…) y/o tmdbId (un número), al menos uno; kind "movie" o "series"
-- en un capítulo los ids son los de la serie y vienen season/episode; title y year son
pistas; languages son los idiomas de subtítulos de la persona, ISO 639-1, el mejor primero (["es",
"en"]). file (Kino 0.9.51) es lo que Kino sabe del archivo que suena, cuando la persona busca desde
el reproductor: { hash?, size?, name? }, cada uno solo cuando se conoce, y ausente cuando no se sabe
nada. hash es el hash de OpenSubtitles de 16 hexadecimales y size los bytes con que se calculó (solo
para un archivo plano y estable); name es el nombre del archivo con su extensión
("The.Matrix.1999.1080p.mkv", máximo 200 caracteres), tomado solo de una URL que termina en un nombre de
archivo de video; si no, un nombre al estilo de un release que Kino arma con el título
("Oppenheimer.2023.mkv", "Breaking.Bad.S01E05.mkv"). Nunca la URL del video. Úsalo para poner primero
la versión que coincide con ese archivo exacto; las versiones anteriores de Kino nunca lo mandan, así
que tómalo como una pista. Devuelve un arreglo de { lang, url, format?, label?, translated? }: entradas de los
subtitles de un Stream más un label opcional y translated: true para una traducción automática
(el menú entonces dice "Español (traducido)" y la lista después de las pistas hechas por personas en ese
idioma). Kino conserva 30, y después lista solo las de los idiomas de la persona, en ese orden, 15 por
plugin: pon primero los idiomas pedidos. label (60 caracteres) se muestra junto al idioma, por ejemplo
el nombre de un release. Cada url sigue la regla de subtítulos de un Stream: tus hosts, el
servidor de la persona, o cualquier host público con streamHosts: "any".
Es una llamada en segundo plano (10 s, nunca marca tu plugin "No responde"); devuelve [] cuando no
tienes nada. Pruébalo con node sdk/run.mjs ./plugin.js subtitles tt0944947 1 1 (KINO_LANGS=es,en
para los idiomas).
Describir otros títulos (meta, apiVersion 6)¶
Declara "meta" y exporta meta(query) para completar lo que Kino no encontró de un título en su
página de información, sin importar qué plugin lo listó: una sinopsis, un póster o fondo, géneros, un
año, una duración, una lista de capítulos. Kino le pregunta primero a TMDB y, para un anime, a AniList;
tu respuesta solo llena lo que ellos dejaron vacío, nunca reemplaza un valor que dieron (ni el del
plugin propio del título). Es la forma de describir títulos que TMDB no conoce, como anime kitsu:. Sin
línea de consentimiento.
export async function meta(query) {
// query: { type: "movie" | "series", ids: { imdb?, tmdb?, kitsu?, mal?, anilist? }, id?, lang? }
// id: el id estilo Stremio del título en su fuente ("kitsu:1376", "tt0944947"), cuando tiene
// lang: el idioma de la persona ("es")
const found = await lookUp(query.ids);
if (!found) return null; // un título que no conoces: no es una falla
return {
title, overview, poster, backdrop, year: "2011", genres: ["Drama"], runtimeMinutes: 57,
episodes: [{ season: 1, number: 1, title, overview, still, airDate: "2011-04-17", id: "tt0944947:1:1" }],
logo: "https://img.example.org/got-logo.png", // Kino 0.9.51+
ratings: [{ source: "imdb", value: "9.2" }, { source: "rottentomatoes", value: "89%" }],
cast: [{ name: "Emilia Clarke", character: "Daenerys Targaryen", photo: "https://img.example.org/ec.jpg" }],
};
}
Todos los campos son opcionales. Las imágenes siguen las mismas reglas que las de un ítem. Desde Kino
0.9.51 hay tres más (las versiones anteriores los ignoran; sin apiVersion nuevo):
logo: el logo del título (su nombre dibujado como arte, con fondo transparente). La ficha lo muestra en lugar del nombre del título, arriba (celular y TV; el nombre se queda para TalkBack y vuelve si la imagen no carga). Las mismas reglas de imagen que unposter.ratings: máximo 6{ source, value }, uno por fuente.sourcees uno deimdb,tmdb,rottentomatoes,metacritic,letterboxd,mal,anilist,trakt;valueun número como lo escribe el sitio, hasta 3 dígitos con hasta 2 decimales, con un%o una escala opcional ("8.8","94%","4.1/5"; también sirve un número de JSON). Se muestran junto a la nota ★ de la ficha ("IMDb 8.8 · Rotten Tomatoes 94%"). A diferencia de los demás campos, se suman: la nota propia de TMDB se queda, y un ratingtmdbse descarta cuando la ficha ya tiene nota. Una entrada mala se descarta y el resto se conserva.cast: máximo 20{ name, character?, photo? }(nameycharacterde 60 caracteres;photouna imagen como unposter). Como todo campo, solo llena un hueco: Kino muestra el reparto de TMDB cuando TMDB lo tiene. Kino muestra los nombres;characteryphotose guardan para después.
episodes[].id es el id de video estilo Stremio del capítulo: un título de un addon de Stremio cuyo
propio listado falló puede entonces reproducir esos capítulos con él. Kino le pregunta a la vez a todos
los plugins meta de la persona, máximo 6 s cada uno, usa la primera respuesta en orden de instalación
y la recuerda 30 minutos; una falla o un tiempo agotado es simplemente no responder, y la página nunca
te espera.
Lo que Kino lee, campo por campo (el resto de una respuesta se ignora, y cada parte se descarta por su cuenta):
- Los campos de texto (
title,overview, eltitle/overview/idde un capítulo, elname/characterde alguien del reparto) pueden ser textos o números, se recortan y se cortan en su límite.titlese lee pero nunca se muestra: la página conserva el de la fuente. year: solo se leen sus primeros 9 caracteres, y sus primeros cuatro dígitos son el año (1999,"1999-2003"; no"estrenada 1999").runtimeMinutes: de 1 a 1000 (un texto numérico o un decimal se lee como lo lee el JSON de Android), y se muestra solo en una película.genres: solo textos, los primeros 5 que no estén vacíos, cada uno cortado a 30 caracteres.episodes: se leen las primeras 5000 entradas, inválidas incluidas;seasonde 0 a 999 (el 0 se conserva pero la página nunca lo lista),numberde 1 a 99999, uno por temporada y número (gana el primero), ordenados.- Imágenes (
poster,backdrop,logo, elstillde un capítulo, laphotodel reparto): la regla de imágenes de un ítem. Una URL se lee primero como texto, y una de más de 2048 caracteres se descarta (nunca se corta en una dirección rota). Una respuesta demetasolo recibe URL: una referencia de imagen (imageSource, apiVersion 13) se ignora aquí. - Una respuesta cuyas únicas partes útiles son
yeary/oruntimeMinutescuenta como no responder, igual quenull.
Pruébalo con node sdk/run.mjs <carpeta del plugin> meta tt0133093 (o tmdb:603, kitsu:1376 series,
varios ids, o la consulta entera como JSON): imprime tu respuesta, el veredicto de Kino para cada campo
(conservado, cortado, descartado y por qué), lo que Kino conserva y cómo lo usaría la ficha (mira
Probar en local). node sdk/validate.mjs . --run search <texto> (o home, browse)
también le pregunta a tu meta por el primer título de la respuesta que trae ids.imdb o ids.tmdb,
como arma Kino la consulta. Al revés, cualquier plugin puede preguntarle a Kino lo que sabe de un título:
kino.meta (Kino 0.9.53).
Plugins de solo catálogo (catalogOnly, Kino 0.9.54)¶
Un plugin que lista y describe títulos pero no tiene video propio -- un catálogo de TMDB, una lista de
estrenos, calificaciones -- lo dice con "catalogOnly": true en su manifiesto (Kino 0.9.54):
{
"id": "tmdb", "name": "TMDB", "version": "1.2.0", "apiVersion": 7, "entry": "plugin.js",
"hosts": ["image.tmdb.org"],
"capabilities": ["search", "home", "browse", "episodes", "resolve", "meta"],
"catalogOnly": true
}
Lo que hacen con él Kino 0.9.54 y posteriores:
- Sus títulos toman el camino de "Buscar dónde verlo". El botón principal de la ficha dice "Buscar dónde verlo" en vez de "Reproducir", y cualquier otra entrada al reproductor (el Inicio y su reproducción rápida, "Continuar viendo", el destacado, un enlace directo, la reproducción rápida de la TV) busca primero el título en los otros plugins de la persona: si una fuente lo tiene, se reproduce; si son varias, se abre la lista de fuentes; si ninguna, dice "Ninguno de tus plugins tiene este título…". El mismo desvío que tienen los addons de Stremio sin streams.
- Nunca es fuente de un título. A su
searchno se le pregunta cuando Kino lista las fuentes de un título (la pantalla de búsqueda, "Ver en otros plugins" del reproductor, "Buscar dónde verlo"), no se ofrece en "Buscar por fuente" y nunca aparece en la lista "Servidor" del reproductor. Dentro de sus propias páginas (su sección, "Ver más", la búsqueda dentro de un "Ver más") su catálogo se recorre y se busca como siempre. - Su
resolvenunca se llama. Si igual un título suyo llega al reproductor, el reproductor dice "<nombre> solo muestra el catálogo: no reproduce videos. Busca este título en tus otros plugins." (o su versión en inglés), con "Ver en otros plugins" debajo. - No es una fuente en "Elige tus plugins", y Kino lo archiva en Utilidades cuando el manifiesto no
trae
categories. - La ventana de consentimiento dice "Solo catálogo: no reproduce videos". No es un permiso: una actualización que agrega o quita el campo se aplica sin preguntar.
Las reglas (si no se cumplen, la instalación se rechaza con el mensaje entre comillas):
| Regla | Rechazo |
|---|---|
Solo true o false |
"El campo \"catalogOnly\" debe ser true o false" |
Al menos una de home, browse, search, meta (en lugar de resolve más search o home) |
"Un plugin \"catalogOnly\" debe declarar \"home\", \"browse\", \"search\" o \"meta\"" |
Sin download, drm ni channels: solo sirven para reproducir |
"Un plugin \"catalogOnly\" no puede declarar \"download\": no reproduce videos" (el primero que encuentre) |
Sin streamHosts (desde apiVersion 4) y sin "browser": true (desde apiVersion 6); "browser": "pages" sí vale, lee páginas para el catálogo |
"Un plugin \"catalogOnly\" no puede declarar \"streamHosts\": no reproduce videos" |
resolve todavía se puede declarar y exportar: cada capacidad que declares tiene que estar exportada,
como siempre, y Kino 0.9.54+ simplemente nunca la llama. subtitles, tracking, segments, meta,
episodes, scopedSearch, migrate, section, categories() y los ajustes funcionan como en
cualquier plugin.
Sin apiVersion nuevo. El campo es aditivo, como discoverable y kino.meta: vale en cualquier
apiVersion, y un Kino anterior lo ignora como ignora cualquier clave que no conoce. Eso es lo que
permite que un mismo manifiesto sirva para los dos:
-
Kino 0.9.53 y anteriores ignoran
catalogOnlyy aplican sus propias reglas, que exigenresolveysearchohome. Así que, para seguir instalándose ahí, sigue declarando y exportandoresolve-- uno que siempre falle con una frase para la persona -- y declarasearchohome:export async function resolve() { // Solo Kino 0.9.53 y anteriores llaman esto: 0.9.54+ manda primero a la persona a sus otras fuentes. throw kino.error("not_found", "catalog only", { userMessage: "Este catálogo no reproduce: busca el título en tus otros plugins." }); }Sin ellos, Kino 0.9.53 y anteriores rechazan el plugin ("El plugin debe declarar \"resolve\""), y una versión anterior ya instalada simplemente deja de actualizarse ahí.
sdk/validate.mjste dice en qué caso estás. -
Kino 0.9.54 y posteriores leen el campo y nunca llaman ese
resolve.
sdk/validate.mjs imprime la línea de consentimiento y una nota sobre los Kino anteriores;
sdk/run.mjs . resolve <ref> igual corre tu resolve (para el Kino anterior al que sirve) y te recuerda
que 0.9.54+ nunca lo llama. Un catálogo completo que lo usa: Un catálogo de TMDB.
Dejar listo un título por adelantado (resolveAhead, Kino 0.9.88)¶
Disponible desde Kino 0.9.88
Sin apiVersion nuevo: el campo del manifiesto vale en todos, Kino 0.9.88 es el primero que lo lee y un Kino anterior lo
ignora como cualquier clave que no conoce.
Apretar reproducir en uno de tus títulos espera a tu resolve antes de que el reproductor pueda siquiera empezar: en una caja
de TV de 1,5 GB, un resolve que hace tres peticiones tardó de 0,7 a 0,8 s. La persona casi siempre pasó más tiempo que eso
en la página del título antes de apretar reproducir (una tarjeta de "Continuar viendo" también abre esa página, en el episodio
por el que va), y "resolveAhead": true deja que Kino use ese tiempo:
{
"id": "mis-peliculas", "name": "Mis películas", "version": "1.4.0", "apiVersion": 9, "entry": "plugin.js",
"hosts": ["api.example.com"],
"capabilities": ["search", "home", "episodes", "resolve"],
"fetchHosts": "any",
"streamHosts": "any",
"resolveAhead": true
}
- Cuándo. Cuando la persona lleva unos 0,3 s en la página de uno de tus títulos, Kino puede llamar tu
resolvepara lo que empezaría su botón de reproducir (la película, o el episodio por el que va), como una llamada en segundo plano. Si se va de la página antes, no se llama nada; una llamada que ya corre nunca se cancela. - Solo un
resolveque no pregunta nada. Nadie espera esa llamada, así que no puede preguntarle nada a la persona: Kino resuelve por adelantado solo un plugin al que la persona le aprobó su"fetchHosts": "any", cuyo video puede venir de cualquier servidor (un"streamHosts": "any"aprobado, o el permiso de video amplio) y que no declaraexternalResolvenibrowser. Para cualquier otro plugin el campo no hace nada, y Kino no llamaprepareen su lugar: deja el campo afuera y exportaprepare. - Hosts. Kino revisa la respuesta exactamente como revisa el
resolvedel propio reproductor. Una respuesta por la que el reproductor habría tenido que preguntarle a la persona (una licencia DRM en un host que nunca declaraste, por ejemplo) no se guarda: apretar reproducir vuelve a llamarresolve, y a la persona se le pregunta como siempre. - Lo que Kino guarda. La respuesta, solo para ese título, como mucho 20 minutos desde que llegó, o hasta 60 s antes de
que se cumpla su
expiresInSecondssi eso llega primero. Si la persona aprieta reproducir antes, el reproductor arranca con esa respuesta sin volver a llamarresolve. Después de eso, tras una respuesta fallida, y en un reintento o al volver a abrir, Kino llamaresolvecomo siempre. - Nunca para un canal en vivo, un plugin +18 mientras el código +18 de la persona está bloqueado, un título con una descarga terminada, o un plugin apagado o que espera sus ajustes; como mucho 6 llamadas por adelantado por minuto por plugin.
- Lo que te pide. Tu
resolvepuede correr para títulos que nadie reproduce. Declara el campo solo si esa llamada no tiene ningún efecto que la persona note: ninguna reproducción contada en tu servicio, ningún cupo ni prueba gastados, ninguna página oculta. - Se ignora al lado de
catalogOnly(Kino nunca llama eseresolve) y debrowser,trueo"pages"(unresolvellamado por adelantado es una llamada en segundo plano, dondekino.browser.captureykino.browser.pagese rechazan).
El siguiente episodio de una serie es otro caso: Kino ya lo deja listo cerca del final del episodio que se está viendo, para cualquier plugin que no abre páginas ocultas, con este campo o sin él.
El campo es una pista y nunca rechaza el plugin: cualquier valor que no sea true, false o null (que se lee como si no
estuviera) se ignora, y Kino registra "The \"resolveAhead\" field must be true or false; Kino ignores any other value".
sdk/validate.mjs avisa de ese valor y de catalogOnly o browser al lado del campo, y anota lo que significa true.
Prepararse antes de reproducir (prepare, Kino 0.9.88)¶
Disponible desde Kino 0.9.88
Sin apiVersion nuevo: cualquier apiVersion puede exportarlo, Kino 0.9.88 es el primero que lo llama y un Kino
anterior nunca lo hace.
A algunos servicios nunca hay que pedirles un stream que nadie va a reproducir: un backend que permite un número fijo de
llamadas a resolve por hora y por cuenta, o un portal en el que cada resolve gasta una de las reproducciones gratis. Un
plugin así deja resolveAhead afuera y puede exportar prepare, para prepararse mientras la persona lee la página del
título. Sirve para cualquier plugin con resolve, sean cuales sean sus hosts:
// Kino ignora lo que responde prepare: prepara solo lo que resolve(ref) va a necesitar, y nunca cuentes una reproducción ni gastes un cupo.
export async function prepare(ref) {
await tokenDeSesion();
}
export async function resolve(ref) {
const token = await tokenDeSesion(); // ya está listo si prepare corrió
const r = await kino.fetch("https://api.example.com/play/" + encodeURIComponent(ref), {
headers: { Authorization: "Bearer " + token },
});
if (!r.ok) throw kino.error("unavailable", "play " + r.status);
return { url: r.json().url };
}
async function tokenDeSesion() {
const guardado = kino.storage.get("sesion");
if (guardado) return guardado;
const r = await kino.fetch("https://api.example.com/session", { method: "POST" });
if (!r.ok) throw kino.error("unavailable", "session " + r.status);
const token = r.json().token;
kino.storage.set("sesion", token, { ttlMs: 20 * 60 * 1000 });
return token;
}
- Cuándo. Cuando la persona lleva unos 0,3 s en la página de uno de tus títulos, Kino llama
prepare(ref)con el mismorefque recibe turesolvepara lo que empezaría el botón de reproducir de la página (la película, el episodio por el que va o una pista suelta; nunca una serie ni un canal en vivo). Si se va de la página antes, no se llama nada; una llamada que ya corre nunca se cancela. - Lo que Kino hace con él. Nada: la respuesta se ignora, sea cual sea, y también un fallo. Apretar reproducir llama
resolvecomo siempre, así que prepara lo que eseresolveva a necesitar: iniciar sesión, renovar un token, abrir una sesión, pedir una autorización y guardarla (en memoria, enkino.storageo enkino.cookies). - Límites. Una llamada en segundo plano de 15 s: a nadie se le pregunta nada (un
kino.fetchque necesitaría que la persona apruebe un host falla en lugar de preguntar), un tiempo agotado o un fallo nunca cuentan para "No responde", y las llamadas de la persona van primero en la fila de tu plugin. Como mucho una vez cada 5 minutos para el mismoref(una llamada fallida cuenta), y como mucho 6 por minuto para tu plugin. - Lo que te pide.
prepareno debe empezar ni contar una reproducción, ni gastar nada de la persona: ningún cupo, ninguna prueba, ninguna reproducción gratis. Puede correr para títulos que nadie reproduce. - Cuándo Kino nunca lo llama. Al lado de
"resolveAhead": true(Kino resuelve por adelantado en su lugar, o no llama ninguno de los dos cuando no puede), en un plugin sin la capacidadresolve, en un plugincatalogOnly(Kino nunca llama suresolve) y en uno que declarabrowser(trueo"pages": sus páginas ocultas necesitan una reproducción que empezó la persona); tampoco para un plugin +18 mientras el código +18 de la persona está bloqueado, un título con una descarga terminada, o un plugin apagado o que espera sus ajustes.
sdk/validate.mjs anota lo que Kino hace con él y avisa cuando Kino nunca lo llamaría; node sdk/run.mjs . prepare <ref> lo
corre (Probar en local).
Contarle a un servicio de seguimiento qué ve la persona (tracking, apiVersion 7)¶
Un plugin de un servicio de seguimiento -- Seenr, Trakt, Simkl, un webhook al estilo de Plex, el
servidor propio de la persona -- declara "capabilities": ["tracking"] (solo, con
subtitles/segments, o junto a las capacidades de una fuente) y "apiVersion": 7, y exporta
track(event). Kino lo llama por cada película o capítulo que la persona reproduce en ese aparato,
de cualquier fuente. Kino 0.9.50 y anteriores rechazan ese manifiesto con "Este plugin necesita una
versión más nueva de Kino".
- Consentimiento. La hoja de instalación dice, en rojo, "Le contará a
<tus hosts>qué ves y cuándo lo terminas" (los 3 primeros hosts, después "y N más"; sin hosts, "al servidor que escribas en su configuración"). Una actualización que agregatrackingsiempre espera a la persona, aunque Kino apruebe otras actualizaciones por su cuenta. - El interruptor. Tu pestaña de Ajustes recibe "Enviar lo que veo" (encendido de entrada,
sincronizado con los otros aparatos de la persona). Apagado, Kino deja de llamar a
tracky borra lo que estaba esperando; desactivar o desinstalar el plugin hace lo mismo. - Lo que nunca se manda. Canales en vivo y radio, títulos +18, lo que reproduce un Chromecast o un televisor DLNA (el celular es solo un control remoto ahí), un título que no está en la biblioteca de la persona, y un capítulo cuyo número Kino no conoce.
Cuándo. start cuando el video de verdad suena (y otra vez cuando se reanuda tras una pausa);
progress como mucho cada 5 minutos de reproducción y en cada pausa (con paused: true); stop con la
posición cuando la persona sale del título (o pone otro); watched una vez, cuando la posición
cruza la regla de "visto" de Kino: quedan 3 minutos o menos y se vio al menos el 90 %. Un título
abierto ya pasado ese punto (retomado en los créditos en otro aparato) no vuelve a mandar watched, y
cada aparato le manda el watched de un título a tu plugin máximo una vez.
{
id: "6f1c…", // estable: el mismo en cada reintento de este evento; úsalo para ignorar un repetido
type: "start" | "progress" | "stop" | "watched",
at: 1759670000000, // cuándo pasó en el aparato (epoch ms), no cuándo te llegó
kind: "movie" | "episode",
ids: { imdb?, tmdb?, tvdb?, anilist?, mal? }, // los de la película; los PROPIOS de un capítulo (abajo)
title?: "…", // el nombre de la película; el del capítulo cuando TMDB lo tiene
year?: 1999, // el año de una película
show?: { title: "…", year?: 2008, ids: { imdb?, tmdb?, tvdb?, anilist?, mal? } }, // solo capítulos
season?: 1, episode?: 2, // solo capítulos (temporada 1 si la fuente no dio ninguna)
positionMs?: 1234000, durationMs?: 8160000, progress?: 0.151, // dónde iba la persona, 0..1
paused?: true // un progress mandado porque la persona pausó
}
Qué ids. En un capítulo, ids son los propios del capítulo (el id de capítulo de TMDB, y
sus ids de IMDb y TVDB cuando TMDB los conoce) y los de la serie van en show.ids: nunca uses
show.ids donde un servicio espera el id de un capítulo, o el registro cae en el ítem equivocado. Kino
completa con TMDB los ids que le faltan al entregar (máximo 8 s); si TMDB no responde, el evento igual
sale, y los ids de un capítulo pueden venir {}: recurre a show.ids + season + episode.
anilist/mal solo aparecen cuando la fuente propia del título los nombró. Toda clave falta cuando no
se conoce; imdb es un texto tt…, las demás son números.
Qué devolver. Cualquier cosa ({ ok: true } por convención) significa entregado. Devuelve
{ skipped: true } para un evento que a tu servicio no le sirve (uno que no guarda progress, un título
que no tiene): Kino lo descarta igual, pero solo una entrega de verdad borra la línea roja "No pudo
avisar…", así que un enlace equivocado sigue a la vista hasta que se arregle. Para fallar, lanza
kino.error(code):
timeout,network,unavailable,rate_limited(y un tiempo agotado de la propia llamada, o un error lanzado sin código): Kino reintenta el mismo evento más tarde -- 30 s, duplicando hasta 6 h, máximo 12 intentos -- y tus eventos siguientes esperan detrás, en orden;auth_required,invalid_request,not_found,geo_blocked,host_not_allowed,too_large: el evento se descarta de una vez.
Un evento descartado, o tres fallas seguidas, muestra "No pudo avisar a <tu plugin>: …" en rojo en tu
pestaña de Ajustes y en Gestionar, hasta que una entrega funcione. Es una llamada en segundo plano (10 s,
nunca "No responde"), nunca en el hilo del reproductor. Kino guarda máximo 200 eventos en espera por
plugin (el progress más viejo sale primero, un watched nunca) y descarta uno sin entregar después de
7 días; un progress nuevo reemplaza al que espera del mismo título, y un stop o watched reemplaza
su progress en espera. Nada se pierde sin conexión ni con la app cerrada: Kino entrega cuando hay red.
Los registros propios de Kino nunca llevan lo que la persona vio; con "Modo debug" encendido, tu
Registro muestra cada evento enviado. Un addon de Stremio convertido nunca recibe tracking (Stremio no
tiene protocolo de scrobble). Pruébalo con node sdk/run.mjs <carpeta del plugin> track start (o
progress, stop, watched, y un objeto JSON para cambiar el ejemplo).
Dónde están la intro y los créditos (segments, apiVersion 7)¶
Un plugin que sabe dónde están la intro y los créditos de un título -- una base al estilo de IntroDB,
una al estilo de AniSkip, el servidor propio de la persona -- declara "capabilities": ["segments"]
(solo, con subtitles/tracking, o junto a las capacidades de una fuente) y "apiVersion": 7, y
exporta segments(query). Kino muestra entonces sus botones "Saltar intro" y "Saltar outro", y "Saltar
automáticamente" salta la intro, en cualquier película o capítulo que la persona reproduzca, de
cualquier fuente, en celular y TV. Kino 0.9.50 y anteriores rechazan ese manifiesto.
- Consentimiento. "Agrega el botón para saltar la intro y los créditos", no en rojo (como
subtitles, tu plugin solo se entera de qué título suena). Una actualización que agregasegmentsno necesita aprobación propia. - Cuándo. Cuando una película o capítulo de verdad suena (Kino conoce la duración del archivo), en
segundo plano: la reproducción nunca te espera. Nunca para canales en vivo o radio, títulos +18, ni un
título que Kino no conoce por ningún id. Se le pregunta a la vez a cada plugin
segmentsinstalado; Kino guarda una respuesta (también una vacía) durante la sesión por título, capítulo y duración (redondeada a 10 s), y vuelve a preguntar después de 2 minutos solo cuando fallaron todos.
{
kind: "movie" | "episode",
ids: { imdb?, tmdb?, tvdb?, anilist?, mal? }, // los de la película; los PROPIOS del capítulo, como en track()
show?: { ids: { imdb?, tmdb?, tvdb?, anilist?, mal? } }, // solo capítulos: los de la serie
season?: 1, episode?: 2, // solo capítulos
durationMs?: 1440000 // la duración del archivo que suena: responde por ESE corte
}
No se manda título, año ni URL; los ids de un capítulo pueden venir {}, así que recurre a
show.ids + season + episode. Devuelve un arreglo de { type, startMs, endMs } ([] o null
cuando no sabes nada): type uno de intro, outro, recap, credits, preview, tiempos en ms
enteros del archivo. Kino revisa cada entrada por separado y descarta una mala sin perder las demás: un
type desconocido, un tiempo que no es entero, un inicio menor que 0, un final que no está al menos 1 s
después del inicio y -- con durationMs conocido -- un inicio en el final o después, o un final más de
5 s pasado de él (dentro de eso se recorta). De entradas del mismo tipo que se cruzan se queda la
primera. Kino lee las primeras 100 entradas y conserva 10. La intro más temprana es la intro, y el
outro o credits más temprano después de ella es donde empieza el final; recap y preview se
aceptan y todavía no tienen botón.
Quién gana. La corrección de la propia persona (el editor de marcas) siempre gana, y también el
skip del plugin que sirve el archivo. En anime, AniSkip (con "Saltar intro en anime"
encendido) gana parte por parte: tu respuesta solo llena la intro o el final que le falte. Entre dos
plugins segments gana el primero, en el orden de Ajustes ▸ Plugins, con una respuesta utilizable. Nada
de lo que respondes se guarda ni se sincroniza. Es una llamada en segundo plano (8 s, nunca "No
responde"); Kino la espera máximo 12 s. Pruébalo con
node sdk/run.mjs <carpeta del plugin> segments tt0133093 8160000 (una película y su duración) o
segments tmdb:1396 1 2 2880000 (un capítulo, por el id de la serie): muestra lo que Kino conserva, lo
que descartó y por qué, y el botón que arma con eso.
Letras para el reproductor de música (lyrics, apiVersion 19)¶
Disponible desde Kino 0.9.81
El apiVersion 19 llega con Kino 0.9.81. Los Kino anteriores rechazan un
manifiesto con "apiVersion": 19 con «Este plugin necesita una versión más nueva de Kino».
Un plugin que encuentra la letra de una canción -- LRCLIB, un sitio de letras, la biblioteca de la persona -- declara
"capabilities": ["lyrics"] (solo, con subtitles/tracking/segments, o junto a las capacidades de una fuente) y
"apiVersion": 19, y exporta lyrics(query). Kino muestra entonces un botón «Letra» junto a los controles de reproducción del
reproductor de música, sobre la carátula, en el teléfono y en la TV, para los ítems music y, desde Kino 0.9.84, también para
los ítems podcast: la transcripción de un episodio, el texto de un audiolibro o de una lectura.
- Consentimiento. La hoja de instalación dice lo que tu plugin sabe: el título y el artista de lo que la persona escucha (no
va en rojo). Una actualización que agrega
lyricsno necesita aprobación propia. - Cuándo. Solo cuando la persona activó la letra para una canción, en segundo plano: la reproducción nunca te espera. Si
hay varios plugins
lyrics, se les pregunta a todos a la vez y la persona elige la fuente; Kino guarda una respuesta 7 días y el «no encontrada» 10 minutos (un fallo nunca se guarda).
{
title: "Song",
artist: "Artist", // puede ser ""
album?: "Album",
durationMs?: 215000, // la duración de la canción: responde para ESA versión
ids?: { isrc?, musicbrainz?, youtube? } // solo lo que Kino conoce; la forma más exacta de hallar una canción
}
Nunca se envía la dirección del audio. Busca por ids cuando puedas, luego por artista y título, y usa durationMs para
elegir entre versiones de la misma canción.
Devuelve un objeto con cualquiera de synced ([{ ms, text }], sincronizada con el tiempo), plain (solo el texto),
label (60 caracteres, nombra la fuente), instrumental: true (la canción no tiene letra) y matchDurationMs (la duración
de la entrada que encontraste); null, [] o {} significa «nada para esta canción». Kino revisa cada línea sincronizada por
separado y descarta la mala sin perder las demás: ms que no sea un número entero de al menos 0, menor que el de la línea
anterior, o sin texto. Lee las primeras 800 líneas, corta una línea a los 300 caracteres y un texto plano a los 20.000,
quita los caracteres de control y de inversión de dirección, y descarta entera una respuesta de más de 102.400 caracteres.
Qué se muestra. Las líneas sincronizadas solo cuando es verosímil que encajen con la canción: matchDurationMs a menos de
3 s de la duración de la canción o, sin él, una última línea a no más de 5 s después del final. Si no, plain, y si no diste
ninguno, nada. Con la duración de la canción desconocida se prefiere plain y las líneas sincronizadas solo se muestran
cuando es lo único que hay. La letra que existe gana sobre instrumental.
La llamada es de segundo plano (10 s, nunca «No responde»). Los registros de Kino llevan solo ids de plugin y conteos, nunca
el título ni el artista. Las letras tienen derechos de autor: tu plugin y su fuente son responsabilidad tuya. Pruébalo con
node sdk/run.mjs <carpeta del plugin> lyrics "Song" "Artist" "Album" 215000 o una consulta JSON: imprime lo que Kino
conserva, lo que descartó y por qué, y lo que dibujaría.
Ser el transporte de la sincronización de la persona (syncProvider, apiVersion 12, Kino 0.9.74)¶
Un plugin que declara "capabilities": ["syncProvider"] (sola o junto a otras) y "apiVersion": 12
lleva la sincronización de la persona entre sus aparatos a través de un servicio con el que habla: un
bot, una API de almacenamiento, un servidor de la persona. Kino se queda con toda la lógica (qué se
sincroniza, cómo se combina, cuándo corre) y cifra la copia antes de que tu código la vea; tu plugin
solo guarda un blob opaco y lo devuelve byte por byte:
export async function syncPull({ maxBlobBytes }) { /* -> { blob, version }, o null si no hay nada guardado */ }
export async function syncPush({ maxBlobBytes, blob, expectedVersion }) { /* -> { version } */ }
export async function syncStatus(_null) { /* opcional -> { ready, message? } */ }
- Un solo argumento objeto en cada una (
nullensyncStatus).blobes base64 estándar (RFC 4648,+y/, con relleno) sin saltos de línea, en las dos direcciones.versiones un texto opaco tuyo. - Conflictos:
syncPushrecibe la versión que Kino trajo por última vez (expectedVersion,nullsi no hay). Un proveedor que puede saber que la copia remota cambió desde entonces lanzakino.error("conflict", "…"); Kino entonces trae, combina y vuelve a enviar. Uno que no puede saberlo lo ignora. - Límites: el blob mide como mucho el
sync.maxBlobBytesdel manifiesto (4 MiB por defecto y como máximo), y solo dentro desyncPull/syncPushpuedenkino.fetchy el resultado de la llamada ser así de grandes. - Llave y consentimiento: el manifiesto tiene que declarar
sync.keySecret(uno de tus ajustespassword); Kino deriva de él la llave de sincronización en cada aparato, así que el plugin y su servicio pueden leer los datos. Una línea de consentimiento en rojo lo dice, y una actualización que agrega la capacidad espera a que la persona la apruebe.
El bloque sync del manifiesto, quién puede leer qué, cada cuánto corre, el aviso en tiempo real, el
paso de los ajustes a otro aparato, las líneas de consentimiento y los dos proveedores de ejemplo están
en Proveedores de sincronización.
Bytes e imágenes que sirve tu plugin (apiVersion 13, Kino 0.9.74)¶
apiVersion 13 llega en Kino 0.9.74 junto con apiVersion 12. Agrega seis capacidades, ninguna con línea de consentimiento propia:
| Capacidad | Export | Qué da | Página |
|---|---|---|---|
socket |
ninguno | kino.ws, WebSockets de salida (wss://, puerto 443) a tus hosts declarados |
Sockets y bytes del plugin |
byteSource |
read({ handle, offset, length }) → { bytes } |
resolve() puede responder { source: "plugin", handle, size, mime }; Kino lo reproduce (y lo envía al televisor) desde tu read |
Sockets y bytes del plugin |
storageLarge |
ninguno | kino.storage guarda 16 MB (2 MB por valor), solo en el aparato |
Catálogo y almacenamiento grande |
catalog |
ninguno | kino.catalog, un catálogo SQLite de hasta 100.000 de tus ítems, en el que busca Kino |
Catálogo y almacenamiento grande |
qrScan |
ninguno | kino.qr.scan(), el lector de cámara del teléfono, desde una acción de los ajustes o del panel |
Códigos QR |
imageSource |
image({ handle }) → { bytes, mime } |
poster, backdrop, still y la image del encabezado de una sección pueden ser { source: "plugin", handle } |
Imágenes del plugin |
También agrega el tipo de ajuste qr (Un código QR), y esa misma versión de Kino les trae a
todos los plugins, sin importar su apiVersion, las operaciones de bytes de kino.crypto aesIge, aesIgeVerify,
modPow, gunzip y convert (Operaciones de bytes). Un plugin
que declara una de las capacidades por debajo de "apiVersion": 13 se rechaza ("The \"catalog\" capability needs
apiVersion 13"); un read o un image exportado sin su capacidad nunca se llama.
Errores que la gente entiende¶
Un throw new Error("…") simple le llega a la persona como una falla genérica de tu plugin. Cuando la
falla es de las comunes, lanza un error con tipo y Kino lo dice bien, en español, con el nombre de tu
plugin:
if (r.status === 401) throw kino.error("auth_required", "la sesión venció");
Código de kino.error |
Lo que ve la persona |
|---|---|
auth_required |
"Configura {plugin} en Ajustes ▸ {plugin}" cuando tu plugin declara ajustes (tiene su propia pestaña en Ajustes); si no, "Configura {plugin} en Ajustes ▸ Plugins" ("Menú ▸ Plugins" en el celular), con un botón a su pantalla Configurar |
not_found |
"No se encontró en {plugin}" |
geo_blocked |
"Este contenido no está disponible en tu región" |
rate_limited |
"{plugin} está limitando las peticiones; intenta en unos minutos" |
unavailable |
"{plugin} no está disponible ahora" |
Tu mensaje es un detalle para el log (cortado a 200 caracteres); la persona lee la frase de Kino. Un código desconocido se vuelve un error simple.
Tu propia frase para la persona (userMessage, apiVersion 6)¶
Cuando la frase de Kino dice muy poco (un capítulo que retiraron, una cuenta que hay que vincular de nuevo), pasa tu propia frase para la persona como tercer argumento:
throw kino.error("not_found", "E100006", { userMessage: "Este capítulo ya no está disponible." });
throw kino.error("auth_required", "E100083", {
userMessage: "Tu cuenta se abrió en otro dispositivo. Vuelve a intentarlo, o vincúlala de nuevo.",
});
Kino la muestra en lugar de su propia línea, siempre como "Mensaje de <nombre de tu plugin>: <tu frase>" ("Mensaje de Demo: Este capítulo ya no está disponible."), y solo cuando se cumple todo esto; si no, la persona lee la línea de Kino y tu frase no va a ninguna parte (tampoco al log; el detalle sí):
- el nombre de tu plugin puede presentarla: solo los caracteres de abajo, sin
:, sin un dígito pegado a una letra, nada que deletree Kino (así que un plugin llamadoM3UoCuevana3siempre muestra la línea de Kino;Cuevana 3sirve); - el código es uno de los cinco de la tabla (
timeout,network,host_not_allowed,crypto_errory los demás siempre los redacta Kino); - tiene de 1 a 160 caracteres sin los espacios de los extremos, hechos solo de las letras del latín
básico y Latin-1 (lo que escriben el español, el portugués y el inglés: á é í ó ú ü ñ ç ã õ â ê ô à
è…, pero no ø æ ð þ ß), los dígitos 0-9, el espacio normal y
. , : ; ¿ ? ¡ ! ' ’ ‘ “ ” « » ( ) % - – — ▸(un;solo antes de un espacio): nada de otra escritura, letras parecidas, versalitas, saltos de línea, tabuladores, otros espacios, caracteres invisibles, emojis ni@; - se lee como palabras normales: al menos dos palabras, sin URL, sin prefijo de error (
TypeError:,[Tag]), sinundefined/null/NaN, y no termina en:,;ni-; - menos de 6 dígitos en total, los separe lo que los separe (ningún teléfono ni número de cuenta, y por
eso tampoco una fecha completa con su año), y ningún dígito pegado a una letra (
en 5 minutossirve,5minutosno); - ningún dominio: un punto pegado a una letra (
site.app), un punto después de un espacio (site .app), un punto seguido de una palabra en minúsculas de 2 a 6 letras (site. app),www, nipunto/dotpegado o seguido de una terminación de dominio (punto com,puntodev; "a punto de volver" y "en este punto es mejor" sirven:es,la,meytono se leen como terminaciones); - nunca deletrea Kino: leída con
1,l,!,¡comoi,0comooy sin ningún carácter que no sea letra, no contienekinoen ninguna parte (así que evita una palabra como "Kinoshita"); - no pide credenciales, dinero ni contacto por fuera de Kino, leída palabra por palabra (una palabra
partida a propósito se lee entera:
N e q u i,Ne qui,con tra seña,What s app,pun to com): nada depag…(pago, pagues, págalo; "página" sirve),abon…,recarg…,transfer…,consign…,deposit…,contraseñ…,passw…,clave…,credencial…,token…,tarjeta,PIN, Nequi, Daviplata, WhatsApp, Telegram, ni uncódigoque llegó por SMS o que es de verificación (verification…; "Verifica tu conexión" sirve): tus propios ajustes son el único lugar para eso (recarg…también rechaza "Recarga la lista": di "Vuelve a cargar"); - no contiene ninguna de las contraseñas que la persona escribió en tus ajustes (se compara con los valores guardados de tu plugin; mientras no se pueden leer, la frase no se muestra), ni el valor de ningún secreto sellado. Nunca repitas lo que la persona escribió, de ninguna forma.
Nunca uses userMessage para pedir plata, contraseñas o datos de contacto
Cada autor es responsable de su propio plugin. Kino solo lista los plugins de la comunidad (su
búsqueda de la comunidad); no los recomienda ni los promociona. Si un plugin incumple las reglas
para plugins -- por ejemplo, usa userMessage para pedir plata, contraseñas o datos de contacto,
es malware o infringe los derechos de alguien --, Kino lo retira del índice de la comunidad con
community-blocklist.json (en la raíz de este repositorio), y cualquiera lo puede reportar
con la plantilla de issue "Reclamo / retiro de plugin". Una copia instalada sigue
instalada, su tarjeta dice "Retirado del índice de la comunidad." y no recibe más actualizaciones;
un fork necesita su propio reporte. Ver Reclamos y retiro de plugins.
Escríbela para la persona, en su idioma; Kino no la traduce. Ocupa exactamente el lugar de la línea de
Kino, así que nunca cambia lo que hace la pantalla: auth_required conserva el botón a tu pantalla
Configurar; geo_blocked muestra el diálogo "No se puede reproducir" del reproductor; los demás códigos
muestran la línea de error de Kino (en un canal en vivo la persona sigue haciendo zapping). También es
el motivo bajo la fila de Inicio de tu plugin y en los avisos de búsqueda. Tu formulario de ajustes y
las páginas de tu sección la muestran para not_found, unavailable y rate_limited, y conservan su
propio texto genérico para auth_required y geo_blocked. Una sola cosa le gana, sea cual sea el
código: un host que la persona rechazó para esa llamada (sobre eso puede actuar). La frase cuenta solo
para la llamada que construyó el error: créala donde lanzas, no una vez arriba en tu módulo. El kit de
Node (run.mjs) imprime lo que leería la persona, o por qué no se muestra la frase. Las versiones de
Kino anteriores a la 0.9.50 ignoran el tercer argumento y muestran su propia línea, así que pasarlo
siempre es seguro.
Una actualización pendiente le gana al error¶
Si una versión nueva de tu plugin está esperando la aprobación de la persona (pide un host, un
permiso o una capacidad nueva), una llamada fallida no muestra la frase de siempre sino "Hay una versión
nueva de <nombre>: actualízala en Ajustes ▸ Plugins", para que la persona sepa qué hacer. Le siguen
ganando un host rechazado, tu userMessage válido y auth_required (que conserva su botón). Mira
Actualizaciones.
Contenido +18 (adult, apiVersion 6)¶
Desde "apiVersion": 6, adult: true en un ítem, en una de tus Categorías
o en una categoría o un canal en vivo marca una entrada +18. Kino la muestra solo mientras el código +18
de la persona está desbloqueado en ese aparato (Ajustes ▸ Control parental) y la vuelve a esconder cuando lo
bloquea. No hay nada que declarar en el manifiesto. Por debajo de apiVersion 6 una entrada adult: true
se descarta, como antes.
- Aplica en Inicio, la búsqueda, "Ver más", tu sección, Categorías y En vivo. Una fila o un grupo que se queda solo con entradas +18 no se muestra mientras el código está bloqueado.
- Todo canal de una categoría +18 cuenta como +18, y un canal +18 nunca entra a "Recientes".
- Los resultados de
liveSearchnecesitan una marca: mira Marca cada resultado deliveSearch. - Enviar un título +18 al TV emparejado pide que el TV también tenga el contenido +18 desbloqueado ("Desbloquea el contenido 18+ en el TV para verlo allí").
- Tu plugin no sabe si el código está desbloqueado ni puede saltarse el candado: siempre devuelve la marca y Kino decide qué se ve.