Mi media center

Como programar add-ons en XBMC: Leyendo datos de fuentes complicadas (continuación)

Jesus — Tue, 30 Apr 2013 00:33:43 +0000

Este tutorial forma parte de la serie Cómo programar un add-on de XBMC

Continuando con la entrada de ayer, y hablando sobre cómo leer datos de sitios web que presentan alguna dificultad especial, hoy voy a detenerme un poco en los pasos necesarios para acceder a sitios protegidos mediante usuario y contraseña.

Es bastante habitual encontrarse sitios web que requieren un login o identificación, como los foros que ocultan los enlaces si no tienes cuenta, los sitios tipo red social como Series.ly donde los usuarios escriben y aporta, o incluso los sitios web privados a los que sólo se puede acceder mediante invitación.

En realidad el problema del login es muy sencillo de resolver, ya que el truco está en mantener una sesión en el sitio web y eso se consigue mediante cookies. La función read_body_and_headers de PluginTools soporta cookies, así que esto va a ser fácil.

Paso 1: Usar Firebug para ver cómo funciona el login

Un gran principio universal es que hay que utilizar la herramienta apropiada a cada problema, y para desarrollar plugins la herramienta es el navegador Firefox con el plugin Firebug instalado.

Este plugin tiene muchas funciones, pero la que necesitamos ahora es la pestaña de “Red” donde se graba la conversación entre el navegador y el sitio web. Con ambos instalados vamos a acceder a la web de mega-spain.com para entender cómo funciona el proceso de login.

Abre la URL de Mega-Spain en Firefox y pulsa sobre el botón “Visitante” que hay en la esquina superior derecha. Rellena los datos en el formulario de login pero no le des todavía al botón “Ingresar”.

Pulsa en el icono de la cucaracha de Firebug para abrirlo en la zona inferior de la pantalla.

Selecciona ahora la pestaña de “Red” en Firebug, pulsa en “Limpiar” en caso de que hubiera algo grabado previamente y pulsa el botón “Ingresar” para que haga el login.

La petición que hagas, la respuesta que obtengas y todos los elementos necesarios para pintarla (imágenes, scripts, estilos, etc.) quedarán grabados por Firebug.

Fíjate en que la primera línea es la del envío del login, se trata de un envío POST a una URL.

Si pulsas en la pestaña “Post” verás exactamente lo que has enviado. La sección “Fuente” recoge el valor además tal como se ha enviado, justo lo que necesitamos.

Así que para hacer el login tenemos que enviar a la URL “http://www.mega-spain.com/index.php?action=login2″ una petición POST indicando en el cuerpo los valores “user=tvalacarta&passwrd=accede”. Fácil ¿no?

Paso 2: Activar las cookies

De la información que ha grabado Firebug podemos extraer dos detalles adicionales que son importantes.

El primero es que la respuesta a nuestro envío POST incluye la cabecera “Set-Cookie”, mediante la cual el servidor web indica al navegador que debe almacenar una cookie.

Esta cookie será enviada automáticamente por el navegador en sucesivas peticiones, y es precisamente lo que el servidor utiliza para relacionar todas las peticiones que recibe como pertenecientes a un mismo usuario. Esto lo hará PluginTools por tí exactamente igual que un navegador, ya que la función read_body_and_headers mantiene las cookies en un fichero en disco y las actualiza en cada petición.

Otro detalle importante es que la respuesta incluye una cabecera “Location”, que es una redirección mediante la que el servidor indica al navegador que debe saltar a una dirección distinta. Fíjate que Firefox hace el salto de forma automática, y cuando llames a read_body_and_headers se hará lo mismo a menos que indiques que no se sigan las redirecciones.

Paso 3: Enviar la información de login

Recopilando toda la información que hemos encontrado gracias a Firebug, concluimos que la forma de hacer el login por código es poner al principio de tu plugin estas líneas:

custom_post="user=tvalacarta&passwrd=accede"
body,response_headers = plugintools.read_body_and_headers("http://www.mega-spain.com", post=custom_post)

Tampoco ha resultado tan difícil, ¿no?

Cuando hayas ejecutado estas líneas, las cookies de la sesión se cargarán en el almacén de cookies de cada usuario. Todas las llamadas que se hagan a partir de ahí serán interpretadas por el servidor como si las hubiera realizado el usuario identificado.

Tratar las redirecciones manualmente

Resuelto el problema del login, hay un par de trucos más que es conveniente aprender para tener a mano cuando hacen falta. El primero de ellos tiene relación con la cabecera “Location” que hemos visto más arriba.

El comportamiento por defecto de un navegador es hacer una petición, y si la respuesta incluye una cabecera “Location” se usa la URL que especifica la cabecera como nueva dirección de salto.

En ocasiones es conveniente utilizar directamente la URL que se indica en la cabecera Location, y para eso basta con indicar el parámetro “follow_redirects” a False.

body,response_headers = plugintools.read_body_and_headers("http://www.mimediacenter.info", follow_redirects=False)

Lo más normal es que el cuerpo de la respuesta venga vacío, pero lo que te interesa es la cabecera así que tendrás que recorrer la lista de cabeceras de la respuesta:

location=""
for name,value in response_headers:
    if name=="location":
        location=value

Fíjate en que el nombre de la cabecera va en minúsculas.

Aumentar el timeout cuando el sitio web es lento

El último parámetro que queda por ver en la función “read_body_and_headers” te permite especificar un valor de timeout superior al que viene por defecto en tu intérprete de Python.

Es un problema habitual en los scripts de Python que se produzcan problemas debido a un timeout muy pequeño, lo que hace que algunas llamadas remotas fallen cuando de otra forma podrían haber funcionado.

Basta poner un valor de timeout suficientemente alto (en segundos) para que las llamadas remotas tengan más paciencia.

body,response_headers = plugintools.read_body_and_headers("http://www.mimediacenter.info", timeout=30*60)

Si el servidor es rápido el timeout no tiene ninguna influencia en el resultado, pero un timeout muy alto hará que la aplicación se quede bloqueada esperando.

Activar información de log ampliada

Cuando tienes que hacer cosas avanzadas es bueno ver exactamente el tipo de información que se envía y obtiene en cada petición, de forma que puedas entender por qué acabas teniendo el resultado que esperas.

En caso de que lo necesites puedes aumentar el nivel de detalle que se muestra en el log con dos variables que encontrarás en las primeras líneas del código fuente del módulo plugintools.py.

module_log_enabled = False
http_debug_log_enabled = False

Si pones la primera variable module_log_enabled a True, conseguirás que las funciones de PluginTools muestren información de depuración en el log. Todas las funciones escribirán en el log su nombre al ser invocadas, y la información relevante en cada caso como resultado de su ejecución.

La segunda variable http_debug_log_enabled puesta a True activa el log de depuración del módulo de Python urllib2, lo que te permitirá ver en el log todas las cabeceras HTTP.

Mucha información, pero en ocasiones imprescindible. No olvides desactivarla cuando vayas a usar tu plugin en el día a día, el fichero de log puede hacerse enorme.

Próxima entrada

Con esta entrada estamos llegando ya a la recta final de esta serie de tutoriales. En la próxima entrada veremos cómo utilizar metadatos extendidos en la lista de items. Eso nos permitirá especificar colores, negritas, duración de los vídeos, etc.

Como programar add-ons en XBMC: Leyendo datos de fuentes complicadas

Jesus — Sun, 28 Apr 2013 07:36:21 +0000

Este tutorial forma parte de la serie Cómo programar un add-on de XBMC

Después de una interrupción de tres meses (increíble cómo pasa el tiempo), por fin he encontrado un hueco para continuar los tutoriales de programación de add-ons abordando algunos de los problemas que te encontrarás cuando programes add-ons en el mundo real.

Y es que no todos los sitios web son sencillos cuando quieres acceder con un plugin, así que en ocasiones es necesario acudir a algunos trucos para conseguir tu objetivo.

He tenido que hacer algunas mejoras en la librería Plugin Tools para permitirle hacer algunos de estos trucos, así que la entrada de hoy empieza explicando en qué consisten estas mejoras para verlas luego en acción sobre casos prácticos.

Añadiendo más funciones de HTTP en PluginTools

Los ejemplos que hemos visto hasta ahora han utilizado la función “read” de PluginTools de una forma muy sencilla: le pasas la URL que quieres leer y te devuelve una cadena con el contenido de esa URL.

body = plugintools.read("http://www.mimediacenter.info")

Cuando esto no funcione habrá que recurrir a la nueva función “read_body_and_headers” de PluginTools, como una versión mejorada de la función “read” que permitirá un montón de posibilidades nuevas:

body,response_headers = plugintools.read_body_and_headers("http://www.mimediacenter.info", headers=request_headers, post=custom_post, follow_redirects=True, timeout=10)

Entre las que se incluyen:

Gestión de cookies transparente
Cabeceras personalizadas (parámetro “headers”)
Aumentar el tiempo de espera ante conexiones lentas (parámetro “timeout”)
Tratamiento automático de páginas comprimidas con Gzip
Envios POST (parámetro “post”)
Procesar las redirecciones manualmente (parámetro “follow_redirects”)
Acceder a las cabeceras de respuesta
Información de depuración adicional

El diseño de la función puede que no sea muy elegante, pero lo que perseguía era tener una función compacta, rápida y sencilla. Si quieres una librería para hacer esto de una forma más “pythonica” puedes recurrir a la librería Python Requests, o a la popular Mechanize. Ambas muy utilizadas y recomendables.

Ahora vamos con algunos ejemplos de uso de “read_body_and_headers”.

Que hacer si el sitio web verifica el User-Agent

Empecemos con un caso sencillo. Cuando haces una llamada HTTP utilizando un navegador cualquiera, dentro de la llamada se envía una cabecera especial llamada “User-Agent” que identifica el navegador que está haciendo la llamada.

Este es el ejemplo de lo que se envía en una llamada HTTP hecha con Firefox para leer la página principal de este blog:

GET / HTTP/1.1
Host: www.mimediacenter.info
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.8; rv:20.0) Gecko/20100101 Firefox/20.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: es-ES,es;q=0.8,en-US;q=0.5,en;q=0.3
Accept-Encoding: gzip, deflate
Connection: keep-alive

Puedes observar que una de las líneas empieza por “User-Agent” e identifica al navegador exacto con el que has hecho la petición:

Mozilla/5.0 (Macintosh; Intel Mac OS X 10.8; rv:20.0) Gecko/20100101 Firefox/20.0

Sin embargo cuando haces una llamada HTTP desde Python usando la función “read” de PluginTools, el navegador empleado es el módulo estándar urllib2 de Python. Y el User-Agent que se manda así lo indica:

GET / HTTP/1.1
User-Agent: Python-urllib/2.1
Host: www.mimediacenter.info
Accept: */*

Puedes ver que en este caso la llamada tiene menos cabeceras, y que el User-Agent identifica claramente a Python como originador de la misma:

Python-urllib/2.1

El caso es que hay sitios web que detectan el User-Agent y lo utilizan con diversos fines, como mostrar un sitio web adaptado al navegador desde el que accedes (útil para móviles) o incluso para bloquear el acceso a ciertos dispositivos.

Por suerte HTTP es un protocolo abierto y bien documentado, de hecho su especificación es una lectura muy recomendable si te dedicas a esto. Con la suficiente habilidad es fácil engañar a cualquier servidor web, y en este caso no podría ser más sencillo ya que basta con enviar la cabecera User-Agent que queramos para que el sitio web no sea capaz de identificarnos como un plugin.

Esto del User-Agent es tan importante que por defecto la función “read_body_and_headers” de PluginTools utiliza un User-Agent de ordenador, concretamente Firefox 18.0 para Mac, siempre que la usas. Si quieres indicar cualquier otro User-Agent basta con que añadas una cabecera HTTP con el parámetro “headers”.

body,response_headers = plugintools.read_body_and_headers("http://www.mimediacenter.info", headers=[["User-Agent","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_8_3) AppleWebKit/537.31 (KHTML, like Gecko) Chrome/26.0.1410.65 Safari/537.31"]])

Verás que “headers” es una lista de cabeceras, que contiene a su vez dos elementos para el nombre de la cabecera y el valor. En el ejemplo la petición se lanza identificándose como “Google Chrome” para Mac.

GET / HTTP/1.1
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_8_3) AppleWebKit/537.31 (KHTML, like Gecko) Chrome/26.0.1410.65 Safari/537.31
Host: www.mimediacenter.info
Accept: */*

Una forma de hacer lo mismo pero más legible, especialmente cuando necesitas añadir varias cabeceras, es añadirlas una por una al array en lugar de declararlo todo en la misma línea:

request_headers=[]
request_headers.append(["User-Agent","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_8_3) AppleWebKit/537.31 (KHTML, like Gecko) Chrome/26.0.1410.65 Safari/537.31"])
body,response_headers = plugintools.read_body_and_headers("http://www.mimediacenter.info", headers=request_headers)

Cuestión de gustos, pero la legibilidad del código es importante

Qué hacer si el sitio web verifica el Referer

Si User-Agent es la cabecera que se envía para que el sitio web sepa qué programa estás utilizando, Referer es la cabecera que se envía para informarle de la página desde donde vienes.

Esta información se utiliza en los sitios web para seguir la navegación del usuario (saber el camino que sigue en un sitio web), y también se utiliza en muchos casos como medida de protección contra el hot-linking.

Te la encontrarás por ejemplo si quieres datos de una página que se encuentran dentro de un iframe, o cuando quieras realizar una llamada AJAX para resolver la paginación. Son casos bastante habituales, y los detectarás cuando pidas una página y el sitio web te devuelva otra, o un error.

La solución es tan sencilla como añadir una segunda cabecera a nuestro ejemplo, poniendo una nueva cabecera “Referer” en la lista para indicar la página de origen que el sitio web esté esperando.

Supongamos que para acceder a la página principal de Plugin Tools en Mi Media Center (http://www.mimediacenter.info/plugintools) fuera necesario hacerlo desde la página principal del sitio (http://www.mimediacenter.info). Bastará con indicar la URL de la página principal como “Referer” al hacer la petición.

request_headers=[]
request_headers.append(["User-Agent","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_8_3) AppleWebKit/537.31 (KHTML, like Gecko) Chrome/26.0.1410.65 Safari/537.31"])
request_headers.append(["Referer","http://www.mimediacenter.info/"])
body,response_headers = plugintools.read_body_and_headers("http://www.mimediacenter.info/plugintools/", headers=request_headers)

Puedes ver ejemplos de sitios web que utilizan la verificación del Referer en el código fuente de pelisalacarta, por ejemplo AnimeID, Beeg, Cuevana, JKAnime, Tucinecom, …

Próxima entrada

Todavía quedan algunos trucos más que contar, pero esta entrada ya se está haciendo demasiado larga. En la próxima entrada veremos algunos más incluyendo cómo resolver el caso de un sitio web que requiere login.

Descarga ya la nueva versión de Plugin Tools y anímate a hacer tus propios proyectos, es fácil

Aprovecha la capacidad del formato MKV para organizar tu colección de vídeos

Jesus — Sat, 19 Jan 2013 23:26:01 +0000

Aprovechando unos días tranquilos hace poco me decidí por fin a organizar mi colección de pelis. En primer lugar porque ocupan un espacio considerable en disco y hace tiempo que había detectado formas de mejorarlo y tener más espacio libre, pero también para tenerlas mejor clasificadas.

Entre otras cosas pensé en aprovechar la capacidad del formato MKV a la hora de gestionar vídeos complejos, para almacenar las películas con sus subtítulos (que tengo en ficheros separados en muchos casos), eliminar las cadenas de audio en otros idiomas, unir las películas que están partidas en varios ficheros, y cosas por el estilo.

Tengo unas notas dispersas sobre los comandos que se deben utilizar para cada caso, y he pensado que podría ser interesante recopilarlos todos en esta entrada.

Hay una estupenda herramienta visual para hacerlo casi todo, llamada mkvmerge GUI, pero encuentro una pesadez usarla para procesar muchos vídeos. La línea de comandos es mucho más ágil para esto, y te permite hacer scripts para procesar los vídeos en bloque.

Cómo unir todas las partes de un vídeo en un único fichero MKV (sin recomprimir)

Algo bastante habitual es tener una peli grabada en varios ficheros, muchas veces a causa de la práctica que había antes de separar las pelis largas en ficheros del tamaño de un CD (700MB).

Sorprendentemente el formato MKV permite tener los dos fragmentos de vídeo en el mismo fichero, y los reproduce uno detrás de otro sin saltos como si nunca hubieran estado separados.

Para conseguir esto debes usar el comando “mkvmerge” y unir todas las partes con la siguiente sintaxis, donde “salida.mkv” es el archivo que vas a conseguir al final y “parte1.avi”, “parte2.avi” y “parte3.avi” son cada uno de los fragmentos:

mkvmerge -o salida.mkv parte1.avi +parte2.avi +parte3.avi ...

Ten cuidado de que cada símbolo “+” tenga un espacio antes, y de que no lo tenga después. Es importante.

Veamos un ejemplo, donde tengo la película de “Tron” en dos ficheros “Tron (CD1).avi” y “Tron (CD2).avi”.

jesus@mediaserver:~$ mkvmerge -o Tron.mkv Tron\ \(CD1\).avi +Tron\ \(CD2\).avi 
mkvmerge v5.1.0 ('And so it goes') creado el Feb  1 2012 11:31:23
'Tron (CD1).avi': Using the demultiplexer for the format 'AVI'.
'Tron (CD2).avi': Using the demultiplexer for the format 'AVI'.
'Tron (CD1).avi' pista 0: Using the output module for the format 'MPEG-4'.
'Tron (CD1).avi' pista 1: Using the output module for the format 'MP3'.
'Tron (CD2).avi' pista 0: Using the output module for the format 'MPEG-4'.
'Tron (CD2).avi' pista 1: Using the output module for the format 'MP3'.
El archivo Tron.mkv ha sido abierto para su escritura.
Uniendo la pista 1 del archivo n.º 1 ('Tron (CD2).avi') a la pista 1 del archivo n.º 0 ('Tron (CD1).avi').
Uniendo la pista 0 del archivo n.º 1 ('Tron (CD2).avi') a la pista 0 del archivo n.º 0 ('Tron (CD1).avi').
Progreso: 100%
El índice está siendo escrito...
Muxing took 1 minuto 14 segundos.

Al final del proceso conviene abrir el resultado con un reproductor. Comprueba que la duración es coherente y salta por varios puntos de la película para verificar que se vea bien y el audio está sincronizado, ya que si el fichero de entrada está corrupto podrías tener un vídeo incompleto en la salida.

Cómo convertir un fichero AVI a uno MKV (sin recomprimir)

En realidad el formato .AVI no es el mejor del mundo, pero si tienes un vídeo en .AVI que te hayas descargado de Internet tampoco es necesario que lo conviertas de formato. Y convertirlo a MKV no va a hacer que tenga más calidad, eso es un mito

Sin embargo si eres de los que te gusta tener todo ordenadito y con la misma extensión, debes saber que puedes convertir el formato de cualquier vídeo a .MKV sin recomprimirlo (y por tanto sin pérdida de calidad alguna) usando el comando mkvmerge.

mkvmerge -o salida.mkv entrada.avi

Y un ejemplo:

jesus@mediaserver:~$ mkvmerge -o Tron.mkv Tron.avi
mkvmerge v5.1.0 ('And so it goes') creado el Feb  1 2012 11:31:23
'Tron.avi': Using the demultiplexer for the format 'AVI'.
'Tron.avi' pista 0: Using the output module for the format 'MPEG-4'.
'Tron.avi' pista 1: Using the output module for the format 'MP3'.
El archivo Tron.mkv ha sido abierto para su escritura.
Progreso: 100%
El índice está siendo escrito...
Muxing took 2 minutos 5 segundos.
jesus@mediaserver:~$

Cómo quitar cadenas de audio en otros idiomas

A mí me gusta ver cine en versión original (depende de la peli) pero a la hora de guardarlas para mi colección no me gusta hacerlo más que con el audio en español. Puedes grabar una peli con varias cadenas de audio y subtítulos, por supuesto, pero el audio es algo que ocupa espacio y especialmente si está codificado con AC3.

La forma de extraer las cadenas de audio que no quieres es volver a grabar el vídeo en un nuevo fichero, pero copiando sólo las cadenas de audio que te interesan. Lo primero es identificar la cadena de audio “buena” con el comando:

mkvmerge -i entrada.mkv

Para a continuación crear un nuevo fichero indicando el número de la cadena de audio “buena”:

mkvmerge -o salida.mkv --atracks NUMERO entrada.mkv

O los “números” si quieres conservar más de de una cadena de audio:

mkvmerge -o salida.mkv --atracks NUMERO,NUMERO entrada.mkv

Veamos un ejemplo con la peli de “Wanted” que tengo en mi disco.

jesus@mediaserver:/media/CINE$ mkvmerge -i Wanted\ \(2008\)\ \[720p\].mkv 
Archivo 'Wanted (2008) [720p].mkv': contenedor: Matroska
La ID de la pista 1: video (V_MPEG4/ISO/AVC)
La ID de la pista 2: audio (A_AC3)
La ID de la pista 3: audio (A_AC3)
La ID de la pista 4: subtitles (S_TEXT/UTF8)
jesus@mediaserver:/media/CINE$

Como ves, tiene dos pistas de audio y una de subtítulos. Lo normal es que la primera cadena de audio sea en español y la siguiente en inglés, pero puedes asegurarte usando el comando “mkvinfo”.

jesus@mediaserver:/media/CINE$ mkvinfo Wanted\ \(2008\)\ \[720p\].mkv
...
| + Una pista
|  + Número de pista: 2
...
|  + Idioma: spa
|  + Nombre: Castellano AC3 5.1

De forma que el audio en español es la cadena 2. Ahora vamos con mkvmerge:

jesus@mediaserver:/media/CINE$ mkvmerge -o salida/Wanted\ \(2008\)\ \[720p\].mkv --atracks 2 Wanted\ \(2008\)\ \[720p\].mkv 
mkvmerge v5.1.0 ('And so it goes') creado el Feb  1 2012 11:31:23
'Wanted (2008) [720p].mkv': Using the demultiplexer for the format 'Matroska'.
'Wanted (2008) [720p].mkv' pista 1: Using the output module for the format 'AVC/h.264'.
'Wanted (2008) [720p].mkv' pista 2: Using the output module for the format 'AC3'.
'Wanted (2008) [720p].mkv' pista 4: Using the output module for the format 'text subtitles'.
El archivo salida/Wanted (2008) [720p].mkv ha sido abierto para su escritura.
Progreso: 100%
El índice está siendo escrito...
Muxing took 1 minuto 8 segundos.
jesus@mediaserver:/media/CINE$

El resultado es un fichero que pasa de 2,6GB a 2,2GB.

-rwxrwxrwx 1 jesus jesus 2,6G jul 13  2010 Wanted (2008) [720p].mkv
-rw-rw-r-- 1 jesus jesus 2,2G ene 19 19:24 salida/Wanted (2008) [720p].mkv

Para ser exactos el tamaño se redujo en 354MB. No está mal para 1 minuto de procesamiento, si haces esto con 100 pelis tendrás 35GB libres más en tu disco. Y yo tengo más de 100

Cómo añadir audio en otros idiomas

Si lo que quieres hacer es la operación contraria es más sencillo todavía. Y es realmente sencillo porque es para lo que se diseñó la herramienta mkvmerge: para construir archivos MKV a partir de diferentes elementos.

mkvmerge -o salida.mkv video.mp4 audio.aac

Observa que este caso es muy similar al que usábamos para concatenar dos vídeos, pero no utilizamos el símbolo “+”.

Cómo añadir subtítulos desde un fichero externo

Algo muy habitual es descargarte la peli por un lado, y los subtítulos por otro. En mi caso ocurre a menudo con los documentales de la BBC que descargo de mvgroup.org, y acabo teniendo un montón de ficheritos al lado de cada vídeo.

El comando para hacer esto con mkvmerge es el mismo que en el caso anterior, ya que la cadena de subtítulos no es más que una pista adicional para añadir al vídeo.

mkvmerge -o salida.mkv video.mp4 subtitulo.srt

Aunque si el subtítulo es UTF-8 debes tener en cuenta algún parámetro más:

mkvmerge -o salida.mkv video.mp4 --sub-charset 0:UTF8 -s 0 -D -A subtitulo.srt

Veamos un ejemplo, de estos tengo bastantes, de una peli con dos cadenas de audio.

jesus@mediaserver:/media/CINE$ mkvmerge -i Toy\ Story\ 3\ \[HDrip\]-original.mkv 
Archivo 'Toy Story 3 [HDrip]-original.mkv': contenedor: Matroska
La ID de la pista 1: video (V_MS/VFW/FOURCC, XVID)
La ID de la pista 2: audio (A_AC3)
La ID de la pista 3: audio (A_AC3)

Añadimos dos archivos de subtítulos:

jesus@mediaserver:/media/CINE$ mkvmerge -o Toy\ Story\ 3\ \[HDrip\].mkv Toy\ Story\ 3\ \[HDrip\]-final.mkv Toy\ Story\ 3\ \[HDrip\]\ es.srt Toy\ Story\ 3\ \[HDrip\]\ inglés.srt 
mkvmerge v5.1.0 ('And so it goes') creado el Feb  1 2012 11:31:23
'Toy Story 3 [HDrip]-final.mkv': Using the demultiplexer for the format 'Matroska'.
'Toy Story 3 [HDrip] es.srt': Using the demultiplexer for the format 'SRT subtitles'.
'Toy Story 3 [HDrip] inglés.srt': Using the demultiplexer for the format 'SRT subtitles'.
'Toy Story 3 [HDrip]-final.mkv' pista 1: Using the output module for the format 'MPEG-4'.
'Toy Story 3 [HDrip]-final.mkv' pista 2: Using the output module for the format 'AC3'.
'Toy Story 3 [HDrip]-final.mkv' pista 3: Using the output module for the format 'AC3'.
'Toy Story 3 [HDrip] es.srt' pista 0: Using the output module for the format 'text subtitles'.
'Toy Story 3 [HDrip] inglés.srt' pista 0: Using the output module for the format 'text subtitles'.
El archivo Toy Story 3 [HDrip].mkv ha sido abierto para su escritura.
Progreso: 100%
El índice está siendo escrito...
Muxing took 58 segundos.

Para acabar teniendo un archivo con 2 pistas de audio y dos subtítulos:

jesus@mediaserver:/media/CINE$ mkvmerge -i Toy\ Story\ 3\ \[HDrip\].mkv 
Archivo 'Toy Story 3 [HDrip].mkv': contenedor: Matroska
La ID de la pista 1: video (V_MS/VFW/FOURCC, XVID)
La ID de la pista 2: audio (A_AC3)
La ID de la pista 3: audio (A_AC3)
La ID de la pista 4: subtitles (S_TEXT/UTF8)
La ID de la pista 5: subtitles (S_TEXT/UTF8)

Cómo programar add-ons en XBMC: Un add-on más completo (continuación)

Jesus — Sat, 12 Jan 2013 23:37:55 +0000

Este tutorial forma parte de la serie Cómo programar un add-on de XBMC

Ayer vimos cómo añadir la sección de vídeos de la web oficial de Disney Junior, analizando paso a paso la extracción de los vídeos del listado, cómo añadirlos a la lista de items de XBMC, y cómo reproducir un vídeo seleccionado por el usuario.

Hoy terminamos el add-on añadiendo otra sección para ver los vídeos del canal de YouTube de Disney Junior, muy útil porque tiene una playlist para cada una de las series incluyendo algunos extras como el karaoke “Canta con Disney Junior”.

También veremos cómo utilizar el teclado en pantalla de XBMC para incluir un buscador, que nos permita acceder fácilmente a una lista de resultados relevantes en YouTube, y cómo utilizar el sistema de configuración de un add-on en XBMC para dejar que el usuario personalice algunos aspectos.

¿Comenzamos?

Las series del canal de YouTube

Si recuerdas el add-on con el que empezó esta serie de tutoriales, uno sencillito que permitía acceder a los vídeos de mi propio canal de YouTube, verás que hacer lo mismo con cualquier otro canal de YouTube no es más complicado que cambiar el ID del canal en el código.

Sin embargo ese add-on utilizaba el API de YouTube para obtener la lista de vídeos subidos al canal

http://gdata.youtube.com/feeds/api/users/tvalacarta/uploads

pero para el de Disney Junior lo que nos interesa es tener la lista de las “playlists” que el propietario del canal ha definido.

http://gdata.youtube.com/feeds/api/users/DisneyJuniorES/playlists

De esta forma al seleccionar la opción “Canal de YouTube” obtendremos una lista de las series de Disney Junior, y al seleccionarlas podremos obtener una lista de vídeos de esa serie. Cada niño tiene sus preferencias.

Aunque podríamos parsear el XML que nos devuelve YouTube usando las librerías de XML de Python, probablemente de una forma más elegante, lo normal en un add-on va a ser encontrarse HTML así que vamos a usar expresiones regulares. Además quedará más compacto, créeme.

Como la estructura de un feed RSS es una sucesión de tags para cada vídeo, con la información del vídeo dentro de esos tags, vamos a utilizar una forma un poco distinta de extraer los datos.

En primer lugar vamos a utilizar una expresión regular sencilla que nos va a devolver un array con el texto que hay dentro de cada uno de los bloques .

119 # Show all YouTube playlists for the selected channel
120 def youtube_playlists(params):
121     plugintools.log("disneyjunior.youtube_playlists "+repr(params))
122
123     # Fetch video list from YouTube feed
124     data = plugintools.read( params.get("url") )
125     plugintools.log("data="+data)
126    
127     # Extract items from feed
128     pattern = ""
129     matches = plugintools.find_multiple_matches(data,"")

Y ahora vamos a recorrer ese array extrayendo los datos de los vídeos para añadirlos a la lista de items de XBMC. Como dentro de un tag sólo hay un vídeo, usaremos la función find_single_match de Plugin Tools para sacar los valores.

    
131     for entry in matches:
132         plugintools.log("entry="+entry)

El título está entre los tags , pero utilizaremos una curiosa expresión regular en este caso. <pre class="prettyprint"> 135 title = plugintools.find_single_match(entry,"<titl[^>]+>([^<]+)")

Si utilizo como expresión regular

([^<]+)

El patrón fallará cuando se encuentre con cosas como esta:

"Ejemplo
"Ejemplo
...

Así que sustituyo por <titl[^>]+> de forma que cuando el patrón haya encontrado las primeras letras del nombre del tag “titl”, deje de buscar para ir directamente al cierre de tag “>”. Esto nos lo habríamos evitado usando un parser XML tradicional, pero el truco es útil también en HTML El resto de elementos del feed se extraen de forma similar. El argumento del vídeo está en el tag <media:description>, la imagen en el tag <media:thumbnail> y la URL de la lista de vídeos en el tag <content> que tiene como atributo type “application/atom+xml;type=feed”. Observa que hay un caracter “\” antes de los símbolos “=”, “+” y “;” debido a que tienen un significado especial dentro de una expresión regular, pero en este caso nos interesa su valor literal. Queremos la cadena “atom+xml”, y no la interpretación de “uno o más” que tiene el símbolo “+”. <pre class="prettyprint"> 136 plot = plugintools.find_single_match(entry,"<media\:descriptio[^>]+>([^<]+)</media\:description>") 137 thumbnail = plugintools.find_single_match(entry,"<media\:thumbnail url='([^']+)'") 138 url = plugintools.find_single_match(entry,"<content type\='application/atom\+xml\;type\=feed' src='([^']+)'/>") 139 140 # Appends a new item to the xbmc item list 141 plugintools.add_item( action="youtube_videos" , title=title , plot=plot , url=url , thumbnail=thumbnail , folder=True ) </pre> Al añadir cada elemento a la lista de items de XBMC indicamos la acción “youtube_videos”, que mostrará la lista de vídeos incluidos en la playlist de la URL. Con esto ya tenemos la lista de playlists del canal, no tenemos que preocuparnos de la paginación como en el plugin de “Mi media center” ya que la llamada de YouTube no permite paginación y siempre devuelve la lista completa. <h2>Los vídeos de cada serie</h2> Como la URL de la lista de vídeos está en el parámetro “url”, y lo que estamos procesando es nuevamente un feed XML, la función “youtube_videos” acaba siendo muy similar a la anterior así que no vamos a verla en detalle. Observa únicamente que en este caso la URL que añadimos tiene el esquema “plugin://plugin.video.youtube/”, ya que estamos componiéndola de forma que al seleccionar el vídeo se llame al add-on de YouTube para su reproducción. Y como el elemento que añadimos en este paso es directamente reproducible, lo marcamos como “folder=False” para que XBMC sepa que no tiene que descender más. <pre class="prettyprint"> 144 # Show all YouTube videos for the selected playlist 145 def youtube_videos(params): 146 plugintools.log("disneyjunior.youtube_videos "+repr(params)) 147 148 # Fetch video list from YouTube feed 149 data = plugintools.read( params.get("url") ) 150 plugintools.log("data="+data) 151 152 # Extract items from feed 153 pattern = "" 154 matches = plugintools.find_multiple_matches(data,"<entry(.*?)</entry>") 155 156 for entry in matches: 157 plugintools.log("entry="+entry) 158 159 # Not the better way to parse XML, but clean and easy 160 title = plugintools.find_single_match(entry,"<titl[^>]+>([^<]+)") 161 title = title.replace("Disney Junior España | ","") 162 plot = plugintools.find_single_match(entry,"]+>([^<]+)

Cuando el usuario selecciona un vídeo se llama a la función “play”.

Reproducción del vídeo

La función “play” es muy sencilla, a diferencia del caso de “disneyweb_play” que veíamos ayer, ya que la URL que viene como parámetro es directamente algo que XBMC sabe reproducir.

169 # Play selected vieo
170 def play(params):
171     plugintools.play_resolved_url( params.get("url") )

Una simple llamada a play_resolved_url de Plugin Tools le indica a XBMC que puede empezar la reproducción.

Configuración

Antes de ver el buscador es necesario conocer primero cómo funciona el mecanismo que XBMC pone a disposición de los add-ons para gestionar los parámetros de configuración. Esto es así porque el buscador hace uso de algunos de estos parámetros.

Para que tu add-on tenga configuración tienes que crear un fichero “settings.xml” dentro del directorio “resources”, donde especificar uno por uno los parámetros que vas a emplear.

En este caso he definido 3 parámetros

youtube_channel_id: Indica el ID del canal de YouTube que se mostrará cuando el usuario seleccione esta opción, con un valor por defecto de “DisneyJuniorES” que es la versión española. Puedes poner “DisneyJuniorLA”, “DisneyJuniorUK”, … o cualquier otro
youtube_language: Indica el idioma de los resultados de búsqueda, por defecto “es” para que salgan vídeos en español pero puedes poner cualquier código de idioma ISO.
last_search: Es la última búsqueda que has introducido, para que la siguiente vez que uses el buscador la recuerde y te la proponga

Observa que los parámetros tienen un atributo “type” que te permite indicar “text”, como en este caso, pero hay otros muchos tipos como “number”, “folder”, … La lista completa está en la Wiki de XBMC.

El texto que se muestra al usuario está en el atributo “label”, donde puedes poner directamente una cadena de texto o como en mi caso el ID de la cadena en el fichero strings.xml. Así el diálogo de configuración estará también traducido al idioma del usuario.

Con este fichero presente tu add-on ya es configurable, y si en la lista de add-ons instalados seleccionas la opción “Configuración del Add-on” con el menú contextual podrás acceder al diálogo de configuración.

Como esto es algo complejo para el usuario yo prefiero poner una opción dentro del add-on para abrir el cuadro de diálogo, en este caso una que llama a la función “preferences” que a su vez encarga de abrir este cuadro de diálogo.

Y lo hace con la función open_settings_dialog de Plugin Tools.

173 # Open preferences dialog
174 def preferences(params):
175     plugintools.log("disneyjunior.preferences "+repr(params))
176
177     plugintools.open_settings_dialog()

En el siguiente punto veremos cómo se implementa el buscador, y de paso cómo leer y escribir los valores de los parámetros de configuración desde el código de tu add-on.

Buscador

La función que XBMC ejecuta cuando seleccionas el buscador es muy sencilla, lo único que hace es leer el valor de “last_search” en la configuración para ver la última búsqueda que escribiste. Para ello utiliza la función get_setting.

Luego abre el teclado usando la función keyboard_input, almacena el resultado de nuevo en “last_search” usando la función set_setting.

179 # Open a popup dialog for input search terms, then call the result function
180 def search(params):
181     plugintools.log("disneyjunior.search "+repr(params))
182
183     last_search = plugintools.get_setting("last_search")
184     texto = plugintools.keyboard_input(last_search)
185     plugintools.set_setting("last_search",texto)
186
187     params["texto"]=texto
188    
189     youtube_search(params)

Una vez que tiene el texto tecleado lo almacena como un parámetro “texto” y llama a la función “youtube_search”, que es similar a las anteriores ya que procesa un feed XML de YouTube con los resultados.

La única diferencia es que la llamada al API de YouTube es diferente. Usa el servicio “videos” de YouTube indicando en el parámetro “q” el texto que el usuario ha tecleado, y en el parámetro “lr” el idioma que ha puesto en la configuración.

191 # Show first 50 videos from YouTube that matches a search string
192 def youtube_search(params):
193     plugintools.log("disneyjunior.search "+repr(params))
194
195     # Fetch video list from YouTube feed
196     data = plugintools.read( "https://gdata.youtube.com/feeds/api/videos?q="+params.get("texto").replace(" ","+")+"&orderby=published&start-index=1&max-results=50&v=2&lr="+plugintools.get_setting("youtube_language") )
197     plugintools.log("data="+data)
198    
199     # Extract items from feed
200     pattern = ""
201     matches = plugintools.find_multiple_matches(data,"")
202    
203     for entry in matches:
204         plugintools.log("entry="+entry)
205        
206         # Not the better way to parse XML, but clean and easy
207         title = plugintools.find_single_match(entry,"]+>([^<]+)")
208         plot = plugintools.find_single_match(entry,"]+>([^<]+)
El resultado son los primeros 50 elementos que coinciden con el texto buscado, en el idioma elegido por el usuario. Y la acción de cada vídeo individual es la misma función “play” que en el caso anterior.
Mensajes al usuario
No he utilizado en este caso mensajes para el usuario, pero la librería Plugin Tools incluye una función message que te permite mostrar una alerta en caso necesario.
plugintools.message("Disney Junior","Ejemplo de mensaje")

Descarga el add-on de Disney Junior
Aunque estaba en la entrada de ayer, incluyo de nuevo el enlace al add-on completo para que puedas descargarlo y estudiarlo cómodamente. Es totalmente funcional, también puedes usarlo para ver algún vídeo si quieres  
http://www.mimediacenter.info/descargas/plugin.video.disneyjunior-1.0.0.zip
Próxima entrega
Ya queda poco para llegar al final de esta serie de tutoriales sobre cómo programar add-ons para XBMC, espero que te estén gustando y que te animen a desarrollar tus propios add-ons  
En la próxima entrega veremos algunas técnicas para leer datos de sitios web que no son tan sencillos, como sitios que requieran usuario y contraseña o que requieran cookies. Aprovecharé para ampliar la funcionalidad de Plugin Tools de nuevo para hacer que resulte sencillo.

Cómo programar add-ons en XBMC: Un add-on más completo

Jesus — Fri, 11 Jan 2013 23:48:47 +0000

Este tutorial forma parte de la serie Cómo programar un add-on de XBMC

Estamos a mitad de camino de este tutorial, pero ya tienes el conocimiento necesario para hacer un add-on bastante completo. Espero que a estas alturas ya te hayas convencido de que es algo relativamente sencillo sin necesidad de saber demasiado de programación. Y ya sabes cómo obtener datos de una página HTML usando expresiones regulares, que es lo más difícil.

Así que antes de entrar en la recta final vamos construir un add-on paso a paso desde cero, con el objetivo de afianzar lo que has aprendido en las entregas anteriores y de paso divertirte un poco.

Te aconsejo que elijas un sitio web que te guste como fuente de vídeos, para mí he elegido hacer un add-on completo que permita ver los vídeos de Disney Junior tanto en la web oficial como en YouTube. No se trata de un add-on demasiado complejo, como podrás comprobar enseguida, pero no va a desmerecer en nada a cualquiera de los que puedes encontrar publicados en muchos repositorios

Puedes elegir tu propia fuente para hacer el add-on, siguiendo los mismos pasos que yo voy a dar, o construir conmigo este interesante proyecto.

Ficheros de identificación

Escribir el fichero addon.xml es el primer paso, así tendrás algo con lo que probar las primeras líneas de código que vayas escribiendo. Aquí va el mío donde verás que he cogido el del ejemplo de “Mi Mediacenter” cambiando el id del add-on (lo he llamado plugin.video.disneyjunior), el nombre (“Disney Junior”) y las descripciones:



  
    
    
  
  
    video
  
  
    Disney Junior
    Watch online Disney Junior videos (spanish)
    Disney Junior
    Todos los vídeos de Disney Junior online en Español
    all

Hacer el logo y el fanart requerirá un poco de práctica al principio, pero basta con que sepas manejar un programa de edición de imágenes donde puedas recortar y cambiar de tamaño. Un logo a 256×256 en PNG, y un fanart a 1280×720 en JPG. Ambos sacados de la web de Disney Junior y con algo de ayuda de Google.

Un menú de navegación

Un add-on que tenga algo más que unos pocos vídeos necesita un menú para que el usuario pueda elegir lo que quiere hacer. En mi caso tengo bastante claro el menú que tiene que tener un add-on de Disney Junior, porque conozco los gustos de mi hija pequeña.

Primero una opción “Web oficial” que muestre todos los vídeos de la web oficial de Disney Junior, seguido de otra opción “Canal de YouTube” para acceder a las playlists que la cadena tiene en su canal oficial de YouTube. Luego una entrada para recurrir al buscador, ya que solemos ponerle capítulos de Mickey Mouse buscándolos en YouTube, y por último una opción para configurar el add-on.

Hacer el menú es muy sencillo porque no hay que llamar a ningún sitio, simplemente añadir 4 elementos a la lista de items. En el fichero “default.py” de este add-on está hecho con estas líneas.

44 # Main menu
45 def main_list(params):
46    plugintools.log("disneyjunior.main_list "+repr(params))
47
48    plugintools.add_item( 
49        action="disneyweb", 
50        title=plugintools.get_localized_string(T_OFFICIAL_WEBSITE) ,
51        url="http://www.disney.es/disney-junior/contenido/video.jsp" ,
52        folder=True )
53    
54    plugintools.add_item(
55        action="youtube_playlists",
56        title=plugintools.get_localized_string(T_YOUTUBE_CHANNEL),
57        url="http://gdata.youtube.com/feeds/api/users/"+YOUTUBE_CHANNEL_ID+"/playlists?v=2&start-index=1&max-results=30",
58        folder=True )
59    
60    plugintools.add_item( action="search",
61        title=plugintools.get_localized_string(T_SEARCH) )
62    
63    plugintools.add_item( action="preferences",
64        title=plugintools.get_localized_string(T_PREFERENCES),
65        folder = False )

Observarás que los títulos no están escritos directamente:

title = "Canal de YouTube"

sino que utilizan la función get_localized_string de Plugin Tools y un identificador numérico para la cadena de texto:

title = plugintools.get_localized_string(30003)

o mejor el identificador numérico de la cadena lo ponemos como una constante para mayor legibilidad:

T_YOUTUBE_CHANNEL=30003
title = plugintools.get_localized_string(T_YOUTUBE_CHANNEL)

Esto es así por el sistema que proporciona XBMC para tener un add-on donde los textos están adaptados al idioma de cada usuario. Es un poco lioso, pero simple y potente.

La idea es que a los textos que quieres traducir les asocias un identificador numérico (30003 en el ejemplo), y los escribes en un fichero “strings.xml” dentro del directorio “resources/language/Spanish”, “resources/language/English”, etc. Uno para cada idioma.



    Última búsqueda
    Web oficial
    Canal de YouTube
    Buscador ...
    Configuración ...
    ID del canal de YouTube ...
    Idioma para los resultados del buscador

Luego los pones en tu código usando la función get_localized_string a la que le pasas el identificador numérico.

Si el usuario tiene su XBMC en inglés, se leerá el fichero strings.xml del directorio “resources/language/English”. Si lo tiene en español, de “resources/language/Spanish”, etc. Si no pones literales en el idioma del usuario se cogerá por defecto los que estén en inglés, así que no olvides poner al menos ese idioma.

Mostrando los vídeos de la web oficial

Abriendo la zona de vídeos de la web de Disney Junior encontrarás el reproductor, y la lista de vídeos disponibles debajo. A mi hija le encanta porque pones un vídeo, y a partir de ahí los reproduce uno detrás de otro en carrusel.

Si le das en Firefox a “Herramientas / Desarrollador web / Código fuente de la página” accedes al HTML, y si buscas dentro del HTML la cadena del título de uno de los vídeos encontrarás enseguida el bloque de HTML que representa a cada vídeo.

Yo lo que suelo hacer para facilitar el trabajo es copiar el HTML que me interesa en cuanto lo localizo, lo pego en el módulo Python que estoy desarrollando dentro de un bloque de comentario, y lo utilizo como punto de partida para construir la expresión regular.

'''

    
    Canta con DJ: La canción del arco iris
    

'''

A continuación pego el html tal como está dentro de una variable, para ir sustituyendo paso a paso y cometer los menos errores posibles:

pattern =''
pattern+=''
pattern+='Canta con DJ: La canción del arco iris'
pattern+=''
pattern+=''

Y entonces empiezo a sustituir. Del primer tag sólo me interesa el principio ya que sirve para marcar el comienzo del patrón, así que dejo un trozo y luego utilizo el patrón [^<]+ para saltar al siguiente tag.

pattern  = '
El segundo tag del bloque tiene el enlace al vídeo en el atributo href y entre comillas, así que uso el patrón [^"]+ y lo marco entre paréntesis porque me interesa el contenido. Y a continuación salto al siguiente tag con [^<]+:
pattern += '
Ahora viene un tag de imagen que necesito para tener la captura del vídeo, aunque esté en la misma línea del texto lo dejo separado para mayor legibilidad.
Cojo la URL de la imagen con el mismo patrón [^"]+ que antes, también entre paréntesis, y salto al siguiente tag con [^<]+:
pattern += '
Ya tengo la URL del vídeo y su imagen, sólo necesito el título para poder mostrar la información completa en el add-on. Así que salto los tags que vienen a continuación hasta encontrar el tag 
 que contiene el título. Como es un valor que está entre tags y no en un atributo, utilizo el patrón ([^<]+).
pattern += '
Podría haber usado (.*?) para saltar todos los elementos e ir directamente al título, pero intento guardar ese recurso cuando es realmente necesario. De esa forma consigo que la carga de los items sea lo más rápida posible.
Antes de poner el código de este bloque nos falta un detalle. Para evitar que haya algún elemento que coincida con el patrón que acabamos de escribir, pero que no corresponda con un vídeo, voy a limitar la zona de la página donde usaré la expresión regular al bloque donde están los vídeos contenidos.
Observa que todos los vídeos de la página están dentro de una zona que empieza con un 
 concreto, y acaban en una zona delimitada por la siguiente que también empieza con otro  concreto.

(aquí están todos los vídeos…)
 
Para delimitar el área de trabajo de la expresión regular a la zona entre estos dos tags, leo la página con read y la guardo en la variable “data”
data = plugintools.read( params.get("url") )

para inmediatamente después quedarme con la parte donde están los vídeos utilizando el patrón 
(.*?). Que viene a ser “todo lo que está entre el primer div y el segundo”.
data = plugintools.find_single_match( data , '(.*?)')

Ya tengo todo lo necesario para escribir la función “disneyweb” que extrae los vídeos y los añade a la lista de items de XBMC:
67 # Show all videos from the official website
68 def disneyweb(params):
69     plugintools.log("disneyjunior.disneyweb "+repr(params))
70 
71     # Fetch video list page
72     data = plugintools.read( params.get("url") )
73     data = plugintools.find_single_match( data , '(.*?)')
74     
75     # Extract items
76     '''
77     
78         
79         Canta con DJ: La canción del arco iris
80         
81     
82     '''
83     pattern  = '
En este punto tengo en la variable “matches” la lista de videos, donde cada elemento de la lista es a su vez una lista con url, imagen y título, sólo falta añadirlos a la lista de items con la función add_item de Plugin Tools.
    
91     for scrapedurl, scrapedthumbnail, scrapedtitle in matches:
92         # Not the better way to parse XML, but clean and easy
93         title = scrapedtitle
94         thumbnail = urlparse.urljoin( params.get("url") , scrapedthumbnail )
95         url = urlparse.urljoin( params.get("url") , scrapedurl.strip() )
96         plot = ""
97 
98         # Appends a new item to the xbmc item list
99         plugintools.add_item( action="disneyweb_play" , title=title , plot=plot , url=url ,thumbnail=thumbnail , isPlayable=True, folder=False )

Observa que la URL y la imagen (o thumbnail) se añaden usando primero la función estándar de Python “urljoin”, lo que viene bien cuando te encuentras con URL relativas en lugar de absolutas. Esta función crea una URL utilizando el primer parámetro como URL base, y el segundo como ruta relativa.
Y observa también que el elemento que añadimos a la lista de items no es una carpeta (folder=False), porque cuando el usuario seleccione uno de estos items simplemente se reproducirá el vídeo con la función “disneyweb_play”. No va a ser necesario que el usuario descienda más niveles, y por eso lo marcamos como “no carpeta”.

Reproducción del vídeo
Cuando el usuario elija un vídeo de la lista anterior, XBMC llamará a la acción “disneyweb_play” y le pasará como parámetro la URL del vídeo elegido entre otras cosas.
Lo primero que hay que hacer es leer esa URL para tener la información del vídeo, usando la función read nuevamente:
101 # Play one video from the official website
102 def disneyweb_play(params):
103     plugintools.log("disneyjunior.disneyweb_play "+repr(params))
104 
105     # Fetch page
106     data = plugintools.read( params.get("url") )

Y ahora utilizar esa información para deducir la URL que hay que darle al reproductor de XBMC. En este caso es fácil porque la URL utiliza el protocolo “RTMPE”, y está en el código HTML separada en dos líneas diferentes de forma bastante clara:
	config.firstVideoSource = 'winnie_heffa_woozles.mp4';
	config.htmlContainerName = 'video_player';
	config.loop = false;
	config.autoplay = true;
	config.rtmpeServer = 'rtmpe://cp121902.edgefcs.net/ondemand/';

Así que sólo tenemos que extraer los dos fragmentos y componerlos para tener la URL completa.
108     url_start = plugintools.find_single_match( data , "config.rtmpeServer \= '([^']+)'")
109     plugintools.log("disneyjunior.disneyweb_play url_start="+url_start)
110 
111     url_end = plugintools.find_single_match( data , "config.firstVideoSource \= '([^']+)'")
112     plugintools.log("disneyjunior.disneyweb_play url_end="+url_end)
113    
114     url = url_start + url_end
115     plugintools.log("disneyjunior.disneyweb_play url="+url)
116 
117     plugintools.play_resolved_url( url )

Con play_resolved_url le decimos a XBMC que está listo para la reproducción, así que directamente empezará a verse el vídeo.
Próxima entrega
La extensión de esta entrada me obliga a dividirla en dos, todavía queda ver cómo montar la sección del canal de YouTube aunque resulta similar a la del ejemplo que vimos al principio de esta serie de tutoriales.
También veremos cómo funciona el buscador y la configuración, pero si has llegado hasta aquí y quieres echarle un vistazo al add-on terminado descargándotelo desde este enlace.
http://www.mimediacenter.info/descargas/plugin.video.disneyjunior-1.0.0.zip
Si no tienes hijos en edad de “La Casa de Mickey Mouse”, pónselo a tus sobrinos. Seguro que sus padres te preguntan cómo pueden instalárselo ellos también

Cómo programar add-ons en XBMC: Patrones avanzados con expresiones regulares

Jesus — Mon, 31 Dec 2012 06:00:14 +0000

Este tutorial forma parte de la serie Cómo programar un add-on de XBMC

Ayer vimos un patrón muy simple, que te permite extraer el texto que hay entre los tags de apertura y cierre de un elemento HTML (o XML), y también vimos cómo extraer el valor de un atributo. Si tenemos en cuenta que en HTML todo son tags o atributos, parece que con estos dos patrones deberíamos tener resuelto cualquier problema ¿no?

En realidad se resuelven la mayoría de los casos, pero estos patrones tienen dos limitaciones importantes que vamos a intentar resolver usando las dos técnicas que se describen en esta entrada.

La primera limitación está en el hecho de que en HTML unos tags pueden estar dentro de otros, lo que complica bastante la elaboración de expresiones regulares cuando sólo buscas los símbolos “<” y “>”.

Y la segunda limitación, más práctica que tecnológica, está en la dificultad que pueden llegar a tener las expresiones regulares en las páginas HTML más complejas. Esto hace muy difícil la depuración, y el posterior mantenimiento, por lo que en este caso atacaremos el problema con un enfoque pragmático que nos permitirá hacer más fácil la tarea.

El patrón más potente

Si bien es cierto que los dos patrones vistos hasta ahora permiten resolver la mayoría de los casos, puedes encontrarte con construcciones HTML tan complejas que acabarían resultando en una expresión regular descomunal. Lo que además de ser difícil de depurar, acaba resultando muy frágil ante cualquier cambio que se realice en la página.

Basta que aparezca un tag intercalado, o algún espacio en blanco inesperado, para que tu sistema falle.

Imagina que quieres extraer el argumento de un vídeo, algo que en muchas páginas web se suele incluir dentro de un elemento “div” de una forma similar a esta:


Blade Runner es una película de ciencia ficción estadounidense, 
dirigida por Ridley Scott,
estrenada en 1982 y basada parcialmente en la novela de Philip K. Dick ¿Sueñan los
androides con ovejas eléctricas?

Si tenemos en cuenta que los enlaces y negritas del argumento van a cambiar de una peli a otra ¿cómo hacer un patrón que extraiga el argumento?

Pues la verdad es que hay una forma muy sencilla, usando en la expresión regular el patrón de “cualquier caracter hasta encontrar X”. Esto se hace con este símbolo:

.*?

El “.” significa “cualquier carácter”, el “*” significa que puede aparecer “0 o más veces”, y el “?” aplicado aquí representa “la más corta de las subcadenas”.

Así que podemos extraer el argumento diciendo “todo lo que esté después de

y hasta que encuentres el primer

”, utilizando un patrón de este tipo:

(.*?)

Veamos el resultado:

plugintools.find_multiple_matches(cadena,'(.*?)')
->
['Blade Runner es una película de ciencia ficción estadounidense,
dirigida por Ridley Scott, 
estrenada en 1982 y basada parcialmente en la novela de Philip K. Dick ¿Sueñan los
androides con ovejas eléctricas?']

Esto también es aplicable para los casos de la entrada de ayer, y además de una forma mucho más sencilla que la que se explicaba.

Buscar el título de la peli del ejemplo se haría con un patrón que podríamos leer como “empieza por

y luego acepta cualquier cosa hasta encontrar

”. Vendría a ser algo así:

(.*?)

Y podemos comprobar que nos lleva al mismo resultado que ayer:

plugintools.find_multiple_matches(cadena,"(.*?)")
->
["Blade Runner","Transformers"]

Sin embargo el uso de este patrón tiene una trampa, motivo por el cual no lo expliqué al principio y que debes tener en cuenta al usarlo.

Este patrón es computacionalmente mucho más complejo que el anterior, lo que significa que si buscas usando un patrón que tiene muchos símbolos “.*?” puede llegar a resultar muy lento encontrar caracteres con él, especialmente en cadenas de texto muy grandes.

Buscando un sólo valor

Hasta ahora hemos buscado todo lo que coincidiera con nuestro patrón, pero si sólo estás buscando un valor es mejor utilizar la función “find_single_match” de PluginTools.

Donde “find_multiple_matches” devuelve una lista, esta función “find_single_match” devolverá una cadena sólo con el primer valor encontrado, y si no encuentra nada devolverá una cadena vacía.

plugintools.find_single_match(cadena,'(.*?)')
->
'Blade Runner es una película de ciencia ficción estadounidense,
dirigida por Ridley Scott, 
estrenada en 1982 y basada parcialmente en la novela de Philip K. Dick ¿Sueñan los
androides con ovejas eléctricas?'

Esto viene muy bien para afinar la búsqueda, lo que nos lleva al último punto de expresiones regulares de este tutorial.

Usar varios pasos para afinar la búsqueda

Con lo que hemos visto en estas dos últimas entradas, es fácil entender el esquema básico de funcionamiento de un add-on y cómo las expresiones regulares permiten sacar los datos de la página web para añadirlos a la lista de items de XBMC.

Supongamos que la lista de pelis está en una página de esta forma:

Transformers

Blade Runner

...

Así que usamos este código en el add-on:

# 1) Lee la página web de origen
data = plugintools.read( params.get("url") )

# 2) Extrae los datos
pattern = '([^<]+)'
matches = plugintools.find_multiple_matches(data,pattern)

# 3) Añade los datos a la lista de items de XBMC
for title,url in matches:
    plugintools.add_item( action="show_mirrors" , title=title , url=url, folder=True )

Pero es más que probable que al ejecutar esto en una página web real nos encontremos con que aparecen más entradas de las que esperábamos. ¿A qué se debe?

Se debe a que nuestro patrón es tan común que prácticamente todos los links coincidirán. Todos los elementos “a” que tengan un atributo “href” coincidirán con ese patrón, así que aparecerán como entradas en el listado de items nuestras pelis pero también otros tipos de enlaces.

La solución es buscar la zona del HTML en la que están las películas, puesto que probablemente estén dentro de un “div” o una tabla, y aplicar el patrón sólo a ese trozo de la cadena. Es lo mismo, pero hecho en dos pasos:

# 1) Lee la página web de origen
data = plugintools.read( params.get("url") )

# 2.1) Delimita la búsqueda al contenedor donde estan las pelis
data = plugintools.find_single_match(data,'(.*?)')

# 2.2) Extrae los datos
pattern = '([^<]+)'
matches = plugintools.find_multiple_matches(data,pattern)

# 3) Añade los datos a la lista de items de XBMC
for title,url in matches:
    plugintools.add_item( action="show_mirrors" , title=title , url=url, folder=True )

Esta es una técnica potente. Puedes ahorrártela haciendo un patrón lo suficientemente elaborado para que encuentre exactamente lo que buscas, pero descubrirás que de esta forma el segundo patrón siempre es más fácil de preparar.

Próxima entrega

Para que veas lo aplicables que son estas fórmulas, te invito a revisar uno por uno todos los canales de pelisalacarta siguiendo este enlace.

Verás que en todos ellos se repiten una y otra vez las técnicas de expresiones regulares descritas, sin usar expresiones más complejas excepto en casos especiales.

Así que recopilemos lo que necesitamos saber para empezar:

([^<]+) para extraer el texto entre dos tags
"([^"]+)" para extraer el valor de un atributo
\d+ para saltar números
\s+ para saltar espacios en blanco
(.*?) cuando la cosa se pone complicada

Con estas herramientas ya podemos sacar datos de cualquier página web, siempre que podamos leerla. Así que en la próxima entrada veremos cómo hacer un add-on algo más completo que el que vimos hace unos días.

Esta era la parte más complicada, a partir de aquí todo va a ser mucho más sencillo.

Cómo programar add-ons en XBMC: Patrones básicos con expresiones regulares

Jesus — Sat, 29 Dec 2012 22:21:26 +0000

Este tutorial es el cuarto de la serie Cómo programar un add-on de XBMC

Las expresiones regulares son extrañamente complejas.

Al menos siempre lo han sido para mí, que aún recuerdo los sudores fríos que me entraban cuando las estudiaba en clase de Álgebra. Siempre pensé que luego nunca me iba a topar con ellas en el mundo real… ironías del destino

Una expresión regular es una forma de representar un patrón de texto, una cadena que quieres encontrar dentro de un texto. Por ejemplo si quieres sacar los números que hay en este texto

Nací el 10 de abril del 2017. ¿Cuánto vivire?

puedes usar la expresión regular

\d+

El símbolo “d” representa a un número, junto con el símbolo “+” que viene a decir que ese número puede repetirse una o más veces. Se pone un “\” delante del símbolo “d” para distinguirlo de la letra “d”.

El resultado buscar en esa frase con ese patrón usando la función “find_multiple_matches” de PluginTools nos devuelve una lista con dos elementos:

cadena = "Nací el 10 de abril del 2017. ¿Cuánto vivire?"
patron = "\d+"
plugintools.find_multiple_matches(cadena,patron)
->
["10","2017"]

En un add-on de XBMC se utilizan las expresiones regulares como un mecanismo eficiente para buscar en una página HTML los elementos que quieren incluir en la lista de items. Los títulos y portadas de un listado de películas, por ejemplo. Si recuerdas la entrada donde explicaba el funcionamiento básico de un add-on, las expresiones regulares se utilizan fundamentalmente en el momento de “extracción de datos”.

Lo que te vas a encontrar en una página HTML es algo como esto:

Blade Runner
Pulsa aqui
para ver Blade Runner

TransformersPulsa aqui
para ver Transformers
...

Y lo que tú necesitas es meter esa página web en una cadena de texto, y usar expresiones regulares para obtener una lista con los siguientes elementos que luego añadirás a la lista de items de XBMC:

[
["Blade Runner","http://www.marsilomena.com/blade-runner"],
["Transformers","http://www.marsilomena.com/transformers"]
]

Puedes usar otras técnicas para extraer datos, como un parser ElementTree si los datos están en XML, o un parser simplejson si están en JSON. Pero probablemente la mejor solución para procesar el HTML del mundo real pasa por usar expresiones regulares, y como también vale en el resto de casos te conviene tener algunos trucos en la maleta para poder recurrir a ellos cuando te surja la necesidad.

Patrones básicos

Hay muchos símbolos para representar patrones en una expresión regular, como usar “\d” para representar un número o “\s” para representar un espacio en blanco. Para una descripción en profundidad te recomiendo leer la documentación básica de expresiones regulares en Python o hacerte con un buen libro.

Si lo que quieres es usar expresiones regulares en tu add-on sin ser un doctorado en matemáticas, sigue leyendo y verás que los patrones utilizados para extraer datos del HTML suelen ser siempre los mismos. Y además resultan muy sencillos.

Obtener el valor de un tag

Habrás observado que el título de la peli está en el ejemplo entre tags “h3″:

Blade Runner...
Transformers...

La mejor forma de sacar el título del vídeo en el ejemplo anterior es usar este patrón:

[^<]+

Los símbolos “[" y "]” encierran una expresión más compleja que puede utilizarse con el símbolo “+” (que si recuerdas representaba “una o más veces”). Así pues, en este caso el patrón buscado es “

” seguido de uno o más caracteres, para terminar en “

”. Como no sabemos cuál es el título del vídeo, utilizamos como carácter cualquiera que no sea el “<”, ya que marcaría el final del tag. Eso se representa poniendo el acento circunflejo “^” delante del caracter.

Así pues “[^<]+” puede leerse como “uno o más caracteres que no sean <”.

Y el patrón completo podemos leerlo como “una cadena empieza por

, y luego tiene cualquier cosa excepto “<” para terminar en

”.

Este patrón coincidirá con dos subcadenas en el texto, y las devolverá en un array:

plugintools.find_multiple_matches(cadena,"[^<]+")
->
["Blade Runner
","Transformers
"]

Como lo que te interesa no es el tag h3 entero, sino que solamente quieres obtener el valor que hay dentro, lo que haces es indicar entre paréntesis qué parte es la que quieres extraer.

([^<]+)

Y esta vez el array será sólo con los títulos.

plugintools.find_multiple_matches(cadena,"([^<])+")
->
["Blade Runner","Transformers"]

Obtener el valor de un atributo

Verás que el patrón “cualquier caracter que no sea X” es muy útil para procesar el HTML, y vamos a usarlo ahora para extraer el enlace al vídeo. Tomemos el ejemplo anterior:

Blade Runner
Pulsa aqui
para ver Blade Runner

Transformers
Pulsa aqui
para ver Transformers
...

No sólo nos interesa el título del vídeo

([^<]+)

sino que también nos interesa el enlace:

([^<]+)
Pulsa aqui para ver [^<]+

Así que usamos el patrón que nos dice que el atributo es “cualquier caracter que no sea una comilla”. Como hemos incluido el patrón para el título y el patrón para el enlace entre paréntesis, nos devuelve una lista cuyos elementos son a su vez una lista (tupla) con los títulos y los enlaces encontrados.

find_multiple_matches(cadena,patron)
->
[
('Blade Runner', 'http://www.marsilomena.com/blade-runner'),
('Transformers', 'http://www.marsilomena.com/transformers')
]

El truco vale para cualquier expresión, por ejemplo es igualmente aplicable si el atributo estuviera expresado con comillas simples:

([^<]+)'>Pulsa aqui para ver [^<]+

Observa que en la parte del texto que está dentro del tag “a” no hemos puesto paréntesis, ya que tenemos el título del principio así que no lo necesitamos de nuevo.

Como tratar el espacio en blanco entre tags

En el ejemplo anterior los tags “h3″ y “a” están juntos, pero podría ocurrir que estuvieran separados por espacios en blanco o incluso por saltos de línea.

Blade Runner
Pulsa aqui
para ver Blade Runner

Transformers
Pulsa aqui
para ver Transformers
...

En ese caso modificaríamos el patrón para usar el símbolo de “uno o más espacios en blanco”, o “\s+”:

([^<]+)\s+Pulsa aqui para ver [^<]+

Otra técnica consiste en ignorar cualquier carácter hasta el comienzo siguiente tag, que es más complicado de leer pero tiene la ventaja de cubrir más casos.

([^<]+)[^<]+Pulsa aqui para ver [^<]+

Y hasta aquí, prácticamente todo lo que necesitas saber para procesar HTML. Si ya sabes extraer valores de los tags, y también de los atributos de los tags, ¿qué más podrías necesitar saber?

Próxima entrada

Esta entrada se estaba haciendo demasiado larga, así que continuaremos mañana con algunas técnicas algo más avanzadas para resolver otros problemas más complejos pero también habituales en el procesamiento de HTML.

Veremos cómo usar expresiones regulares para manejar los tags que están unos dentro de otros, donde el truco de buscar el símbolo “<” no sirve, y también veremos algunas técnicas para que las expresiones regulares no se hagan demasiado complejas usando la extracción en dos pasos.

Como programar add-ons en XBMC: Los ficheros de identificación

Jesus — Tue, 25 Dec 2012 11:00:52 +0000

Este tutorial es el tercero de la serie Cómo programar un add-on de XBMC

A la hora de hacer un add-on la parte más compleja es lógicamente la de programación, pero también es importante conocer los 3 ficheros que permiten una correcta publicación dentro de XBMC y que deben situarse en el directorio principal del add-on. Hablamos del logo, el fanart y el fichero addon.xml.

Con la edición de la información recogida en el fichero addon.xml podrás darle a tu add-on el título y la descripción que quieras, incluso en varios idiomas. El logo del canal es la imagen que aparece en el listado de add-ons para distinguirlo, normalmente junto al título aunque puede depender del skin que uses. Y el fanart es la imagen de fondo que aparece cuando has seleccionado el addon, como elemento meramente decorativo.

Veámoslo en detalle.

El logo y el fanart

El logo distingue al add-on cuando el usuario está viendo la lista de add-ons instalados, o cuando quiere instalar uno nuevo.

Es un fichero pequeño, grabado en formato PNG y debe llamarse exactamente “icon.png”. Debe tener un tamaño de 256×256 pixels de acuerdo con las guías de estilo de XBMC, y debes procurar que sea claro cuando se ve desde cierta distancia ya que la mayoría de usuarios de XBMC lo va a ver desde el sofá. No es obligatorio incluir un logotipo para tu add-on, aunque es muy recomendable.

El fanart o imagen de fondo, por el contrario, es una imagen grandota que sirve para personalizar un poco más la apariencia de tu add-on en XBMC. En este caso para que el tamaño del fichero no sea excesivo se utiliza el formato JPEG, es recomendable no exceder 1280×720 pixels de resolución, y debe llamarse “fanart.jpg”. Es opcional incluir un fanart en tu add-on, de hecho hay muchos que no lo tienen.

El fichero addon.xml

El tercer fichero, y el único obligatorio en la estructura del add-on, es el fichero “addon.xml”. Contiene el identificador de tu add-on, su nombre, el nombre del autor… veamos el de nuestro add-on de ejemplo paso a paso:

1  
2  
6    
7      
8      
9    
10   
11     video
12   
13   
14     Mi media center
15     Ideas para llevar la experiencia multimedia al salón
16     Mi media center
17     Ideas para llevar la experiencia multimedia al salón
18     all
19   
20

Hay cuatro bloques importantes que deben rellenarse cuando desarrollas tu propio add-on, lo normal suele ser buscar un fichero ya hecho y modificarlo según tus necesidades.

El primer bloque es muy importante porque hay varios aspectos del funcionamiento del add-on que dependerán de estos valores, especificados como atributos del XML.

id: Es el identificador interno del add-on. Debe coincidir con el nombre de directorio que emplees en el ZIP, y será utilizado en el código para acceder a cosas como la configuración.
name: El nombre con el que el usuario verá el add-on.
version: Visible en pantalla, y utilizado para las actualizaciones.
provider-name: Nombre del autor / autores.

En este segundo bloque se declaran las dependencias que tiene tu add-on con otros add-ons publicados, ya sea en el repositorio oficial o en el tuyo propio. La dependencia con “xbmc.python” versión 2.0 declara que tu add-on es para XBMC Eden y posteriores.

10   
11     video
12

Este punto describe el módulo que se ejecutará dentro del add-on cuando el usuario lo seleccione (llamado normalmente “default.py” por convención), y la distinción de si el add-on es de vídeo, audio, etc. Lo que pongas aquí determina en qué menú aparece el add-on.

13   
14     Mi media center
15     Ideas para llevar la experiencia multimedia al salón
16     Mi media center
17     Ideas para llevar la experiencia multimedia al salón
18     all
19

Descripción del add-on en varios idiomas, conviene poner al menos la versión en inglés para que todo el mundo pueda verla ya que es la utilizada por defecto. Qué valores se visualizarán en cada caso depende del skin del usuario.

El empaquetado

Los add-ons se distribuyen en ficheros ZIP, que por convención se llaman utilizando el identificador del add-on y la versión siguiendo este esquema:

identificador-version.zip

Por ejemplo

plugin.video.mimediacenter-1.0.2.zip

Realmente no es necesario seguir esta convención, puedes darle al fichero ZIP el nombre que tú quieras siempre que la estructura interna sea la correcta.

Dentro del ZIP tiene que estar todo en un directorio que se llame igual que el identificador del add-on, y tiene que tener al menos el fichero addon.xml y el módulo .py de arranque.

Archive:  plugin.video.mimediacenter-1.0.2.zip
 Length    Size  Ratio Name
-------- ------- ----- ----
   35821   12288  66%  plugin.video.mimediacenter/LICENSE.txt
     796     337  58%  plugin.video.mimediacenter/addon.xml
    2965    1083  64%  plugin.video.mimediacenter/default.py
  155007  152729   2%  plugin.video.mimediacenter/fanart.jpg
   50730   50669   0%  plugin.video.mimediacenter/icon.png
    3935    1385  65%  plugin.video.mimediacenter/plugintools.py
-------- -------  ---  -------
  249254  218491  12%  6 files

Próxima entrada

Y eso es todo por hoy. En la siguiente entrega volveremos a la programación para ver con detalle el uso de expresiones regulares en la extracción de datos, para ayudarte a que les pierdas el miedo.

Como programar add-ons en XBMC: Funcionamiento de un add-on paso a paso

Jesus — Mon, 10 Dec 2012 23:25:22 +0000

Este tutorial es el segundo de la serie Cómo programar un add-on de XBMC

Esta serie de tutoriales va a guiarte paso a paso en la construcción de un add-on para XBMC, usando la librería Plugin Tools y un ejemplo de add-on totalmente operativo como punto de partida. Veremos cómo funciona por dentro este add-on, como mejorarlo, e incluso cómo publicarlo en el repositorio oficial de XBMC o en un repositorio propio.

Para empezar te recomiendo que descargues el add-on de ejemplo que acompaña a la distribución de la librería Plugin Tools, y lo instales en tu equipo.

http://www.mimediacenter.info/descargas/plugin.video.mimediacenter-1.0.2.zip

Este add-on permite extraer y ver desde XBMC los vídeos de mi canal de YouTube, y utiliza a su vez el add-on oficial de YouTube para la reproducción. Si no tienes el add-on de YouTube se instalará automáticamente cuando vayas a ver cualquier vídeo.

Instalación del add-on y preparación del entorno de desarrollo

Puedes descargar e instalar el add-on en XBMC siguiendo el procedimiento habitual, desde XBMC con la opción de “Instalar desde fichero ZIP” o descomprimiéndolo manualmente en el directorio de los add-ons.

Publicar un add-on en XBMC no implica nada más que tener un directorio con el nombre correcto en la carpeta “addons”, y si quieres quitarlo de XBMC basta con que borres ese directorio.

Yo lo que hago habitualmente es trabajar sobre una carpeta donde almaceno todos los plugins (/Users/jesus/Plugins) y luego crear un enlace simbólico en el directorio de los add-ons de XBMC. De esa forma tengo todos los plugins en el mismo sitio, y sólo publico en XBMC aquel con el que estoy trabajando.

Los enlaces simbólicos pueden aplicarse en cualquier sistema, que yo sepa. Las instrucciones desde el terminal en mi Mac son:

$ cd /Users/jesus/Library/Application\ Support/XBMC/addons
$ ln -s /Users/jesus/Plugins/plugin.video.mimediacenter plugin.video.mimediacenter

Tengas donde tengas el código fuente del add-on, ya sea en la carpeta de XBMC o en un directorio separado como en mi caso, configura tu IDE favorito o simplemente prepara un editor de texto para empezar.

¿Qué hace el add-on de ejemplo?

La función de este add-on es sencilla. Basándose en el API de YouTube, se descarga el feed de vídeos de mi canal de YouTube desde esta URL:

http://gdata.youtube.com/feeds/api/users/tvalacarta/uploads

De ahí extrae los vídeos ordenados por fecha de subida, y los muestra de forma que el usuario puede verlos directamente desde XBMC.

Punto de entrada

Para averiguar cual es el punto en el que comienza la ejecución del add-on debes abrir el fichero addon.xml, buscar el elemento de extensión “xbmc.python.pluginsource” y verás que su atributo “library” indica el módulo principal.

Si abres el módulo default.py verás que tras definir las funciones que va a utilizar lo único que hace es ejecutar la primera de ellas: “run”.

22 # Entry point
23 def run():
24    plugintools.log("tvalacarta.run")
25    
26    # Get params
27    params = plugintools.get_params()
28    
29    if params.get("action") is None:
30        main_list(params)
31    else:
32        action = params.get("action")
33        exec action+"(params)"
34    
35    plugintools.close_item_list()

La función “run” se ejecutará cuando abras el add-on la primera vez, y cada vez que el usuario haga una selección. Veamos su funcionamiento paso a paso:

24    plugintools.log("tvalacarta.run")

Esta línea añade al log de XBMC una entrada, que nos permitirá trazar en caso necesario por donde ha transcurrido la ejecución de nuestro código.

26    # Get params
27    params = plugintools.get_params()

El paso de parámetros a un add-on se realiza en XBMC siguiendo un esquema de URL de este tipo:

plugin://plugin.video.nombredeladdon/?parametro1=valor1&parametro2=valor2

Esta función get_params de plugintools lo que hace es extraer los parámetros y ponerlos en un diccionario para facilitar su acceso más adelante.

29    if params.get("action") is None:
30        main_list(params)
31    else:
32        action = params.get("action")
33        exec action+"(params)"

Según este condicional, si hay un parámetro “action” que tiene el nombre de la función a ejecutar, le pasa el control a esa función pasándole el diccionario de parámetros. En caso de que no haya un parámetro “action”, la función llamada por defecto es “main_list”.

35    plugintools.close_item_list()

La función que ejecute el add-on se encargará de añadir elementos a la lista de items de XBMC, y con esta llamada a close_item_list indicamos a XBMC que ya hemos terminado de añadir items. En este punto el control pasa de nuevo al usuario.

La función principal

El add-on del ejemplo sólo tiene dos funciones, una para leer los elementos del feed y la otra para reproducir el elemento elegido. En posteriores entregas de esta guía lo mejoraremos para añadir cosas como menús estáticos, configuración, buscador, etc.

Esta es la función “main_list()” completa, donde se hace la magia.

37 # Main menu
38 def main_list(params):
39     plugintools.log("tvalacarta.main_list "+repr(params))
40
41     # On first page, pagination parameters are fixed
42     if params.get("url") is None:
43         params["url"] = "http://gdata.youtube.com/feeds/api/users/"+YOUTUBE_CHANNEL_ID+"/uploads?start-index=1&max-results=10"
44 
45     # Fetch video list from YouTube feed
46     data = plugintools.read( params.get("url") )
47    
48     # Extract items from feed
49     pattern = ""
50     matches = plugintools.find_multiple_matches(data,"(.*?)")
51    
52     for entry in matches:
53         plugintools.log("entry="+entry)
54        
55         # Not the better way to parse XML, but clean and easy
56         title = plugintools.find_single_match(entry,"]+>([^<]+)")
57         plot = plugintools.find_single_match(entry,"]+>([^<]+)")
58         thumbnail = plugintools.find_single_match(entry,"
No es tan complicado como parece, ya que en la mayoría de los casos el add-on hace su trabajo en tres etapas bien diferenciadas.

Leer la fuente: Se lee el html de la página con la que se va a trabajar
Extraer datos de la fuente: Se extraen los elementos de la página que contienen la información relevante.
Construir la lista de items de XBMC: Combinando la información extraída se informa a XBMC de los elementos que debe mostrar.

Veámoslo paso a paso.
Primera etapa: Leer la fuente
Saltando la línea que traza la entrada a la función en la línea 39, lo primero que encontramos es esto:
41     # On first page, pagination parameters are fixed
42     if params.get("url") is None:
43         params["url"] = "http://gdata.youtube.com/feeds/api/users/"+YOUTUBE_CHANNEL_ID+"/uploads?start-index=1&max-results=10"

La URL de que se sacan los datos vendrá en un parámetro “url” en las siguientes invocaciones, pero la primera invocación no especifica ningún parámetro así que se asigna un valor por defecto usando el API de YouTube. Fíjate que añadimos los parámetros “start-index” y “max-results”, que hacen la petición de 10 elementos empezando por el 1. Usaremos esto para la paginación un poco más adelante.
45     # Fetch video list from YouTube feed
46     data = plugintools.read( params.get("url") )

Ahora que estamos seguros de que la URL está en el parámetro “url”, podemos usarlo para descargar el contenido que se va a mostrar en el add-on, y para ello se hace uso de la función read de plugintools. Esta función es muy sencilla por dentro en este punto, pero la complicaremos más a medida que necesitemos más.
Segunda etapa: Extraer los datos de la fuente
Esta es siempre la parte más compleja, cuando es necesario extraer los datos de lo que hemos descargado para convertirlos en elementos estructurados. Es complejo porque implica (normalmente) el uso de expresiones regulares, y las expresiones regulares dan un poco de miedo.
En este caso particular podríamos haber utilizado librerías de procesamiento de XML, pero para mantener el ejemplo sencillo he pensado que mejor atacábamos el problema con expresiones regulares.
Hagámoslo en dos pasos.
En primer lugar vamos a extraer todos los elementos “” que hay en el XML que nos hemos descargado, usando la función find_multiple_matches de plugintools. Recibe dos parámetros, el string con los datos que hemos descargado y la expresión regular a aplicar. Y devuelve una lista con lo que ha encontrado. No hagas caso a la línea 49, en este caso sobra aunque viene bien tenerla para futuros usos.
48     # Extract items from feed
49     pattern = ""
50     matches = plugintools.find_multiple_matches(data,"(.*?)")
51    
52     for entry in matches:
53         plugintools.log("entry="+entry)

Ahora que tenemos elementos “entry” en un array, podemos procesarlos uno por uno usando la función find_single_match de plugintools.
56         title = plugintools.find_single_match(entry,"]+>([^<]+)")
57         plot = plugintools.find_single_match(entry,"]+>([^<]+)")
58         thumbnail = plugintools.find_single_match(entry,"
Para cada elemento “entry” obtenemos el título (title), la descripción (plot), la imagen (thumbnail) y el id que asigna YouTube al vídeo (video_id). Este es el valor que espera el add-on de YouTube en XBMC.
Si no entiendes muy bien la sintaxis de las expresiones regulares no te preocupes, volveremos a ello en próximas entregas de este tutorial y verás que son bastante sencillas en este caso concreto.
Tercera etapa: Construir la lista de items de XBMC
Ya solo queda añadir el elemento a la lista de “items” de XBMC, lo que hacemos nuevamente con la función add_item de plugintools. 
60         url = "plugin://plugin.video.youtube/?path=/root/video&action=play_video&videoid="+video_id
61
62         # Appends a new item to the xbmc item list
63         plugintools.add_item( action="play" , title=title , plot=plot , url=url ,thumbnail=thumbnail , isPlayable=True, folder=False )

Un item de XBMC no es más que un título y una URL, aunque podemos ampliarlo con un thumbnail, descripción, fanart, productora de la peli, calidad del vídeo, … De momento vamos a limitarlo a los cuatro elementos que hemos extraido y deduciendo la URL a partir del video_id.
Observa que la URL del elemento es la llamada al add-on de YouTube, pasándole el video_id tal como lo hemos encontrado en el paso anterior.
Observa también que el parámetro “folder” de add_item está a False, indicando que cuando el usuario seleccione este elemento no va a encontrar niveles adicionales de navegación. Este parámetro “folder=False” se reserva normalmente para los vídeos.
Paginación
La descarga de datos desde la URL de YouTube está limitada a los 10 primeros elementos, pero cualquier canal de YouTube tiene muchos más vídeos. ¿Cómo hacer para que el usuario pueda ir descargando los 10 siguientes, con un elemento de tipo “Next page” como en la captura de pantalla del add-on?
65     # Calculates next page URL from actual URL
66     start_index = int( plugintools.find_single_match( params.get("url") ,"start-index=(\d+)") )
67     max_results = int( plugintools.find_single_match( params.get("url") ,"max-results=(\d+)") )

Lo primero es averiguar por qué número de elemento vamos, y para ello utilizamos nuevamente find_single_match y una expresión regular. Miramos a ver qué URL se ha empleado para la lista actual, y extraemos de ella el valor de start_index y max_results.
68     next_page_url = "http://gdata.youtube.com/feeds/api/users/"+YOUTUBE_CHANNEL_ID+"/uploads?start-index=%d&max-results=%d" % ( start_index+max_results , max_results)
69
70     plugintools.add_item( action="main_list" , title="<< Next page" , url=next_page_url , folder=True )

Con esos dos valores deducimos los que deberían emplearse en la URL de la siguiente página (max_results debe ser el mismo, y start_index será 11 para la segunda página, 21 para la tercera, …) y añadimos un nuevo item usando add_item. Cuidando que esta vez el parámetro “folder” sea “True”, porque al elegir este item sí que van a obtenerse más items.
Respondiendo a la selección del usuario
Ya tenemos los items de los 10 primeros vídeos, y un item adicional para que el usuario pueda avanzar a la siguiente página.
Ahora bien, ¿cómo continúa la navegación del usuario a partir de este punto?
Es sencillo.
Una vez añadidos los items la función “main_list” termina, y la función “run()” finaliza la ejecución llamando a “plugintools.close_item_list()” como hemos visto más arriba. Así XBMC sabe que la lista ha terminado de cargarse, quita la espiral de carga y muestra al usuario la lista de items.
Cuando el usuario elija un ítem se volverá a invocar al add-on, pasándole como parámetros todos los del item tal como especificamos en la llamada a la función “add_item” para añadirlo.
Y esta es la clave, porque si queremos que la selección de un item dispare una acción concreta sólo tenemos que indicar la acción que queremos en el parámetro “action”. Y luego definir una función con ese nombre en nuestro add-on.
Siguiendo nuestro ejemplo, cuando el usuario elija un vídeo se repetirá el ciclo anterior pero invocando esta vez a la función “play”. Y esta función se encarga de reproducir el vídeo:
72 def play(params):
73     plugintools.play_resolved_url( params.get("url") )

Si por el contrario el usuario elige el elemento de página siguiente, la función llamada será “main_list” porque es la acción que se especificó al añadir este último item. Y como la URL pasada como parámetro será la que extrae los próximos 10 items, obtendremos como resultado la siguiente página.
Próxima entrada
La entrada de hoy ha sido algo más larga de lo que esperaba, pero si comprendes cómo funciona el add-on de ejemplo te debería resultar sencillo hacer un buen número de add-ons distintos.
Antes de explicar otras técnicas, mañana nos detendremos en ver cómo se personalizan los ficheros de identificación del add-on para que puedas empezar a hacer tus primeros proyectos.

Cómo programar add-ons en XBMC: Tipos de Add-ons

Jesus — Mon, 10 Dec 2012 00:32:46 +0000

Este tutorial es el primero de la serie Cómo programar un add-on de XBMC

XBMC es una aplicación diseñada para convertirse en ese programa que utilizas en casa para disfrutar de tus vídeos, de tu música, de tus fotografías. Puedes hacer lo mismo con diferentes dispositivos, pero XBMC es la pieza central del control multimedia en tu casa.

Además de un reproductor de vídeo muy avanzado capaz de reproducir cualquier cosa, una función de biblioteca para gestionar tu colección de forma muy completa, la mejor conectividad que puedes encontrar y funcionamiento garantizado en multitud de sistemas operativos de ordenadores y dispositivos, XBMC tiene la posibilidad de incorporar extensiones denominadas “Add-ons”.

Estas extensiones permiten añadir nuevas funciones, como juegos o redes sociales, pero sobre todo permiten acceder a contenidos que se encuentran en Internet (videos, música y fotografías entre otros) sin salir de la interfaz de XBMC. Es la experiencia de navegar por Internet desde tu sofá.

Por qué este tutorial

A pesar de que existen otros tutoriales sobre cómo desarrollar estos add-ons circulando por Internet, la documentación no ha sido tradicionalmente el punto fuerte de XBMC como ocurre a menudo con los proyectos open source.

Hace tiempo que tengo pensado escribir este tutorial para aportar mi granito de arena en forma de documentación, y también para que exista un tutorial en castellano para los que no se manejan demasiado con el inglés.

Mi intención es traducirlo también al inglés, pero eso no ocurrirá hasta que no esté terminado

Tipos de add-ons

Hay muchas clases de add-ons, aunque en realidad la mayor parte de ellos son subsistemas internos del propio media center. Subsistemas que han sido desarrollados como módulos para que si en algún momento es necesario reemplazarlos, sea fácil hacerlo.

Es posible leer la lista completa de tipos de add-ons en la wiki de XBMC, e incluye funciones conocidas como los skins (xbmc.gui.skin), los scrapers que conectan la biblioteca con repositorios externos (xbmc.metadata.scraper) o el módulo de predicción metereológica (xbmc.python.weather). Pero también hay otras funciones más desconocidas para el usuario medio como los servicios en segundo plano (xbmc.service) o la interfaz web (xbmc.gui.webinterface).

Sin embargo hay 4 tipos de add-ons que proporcionan las extensiones más interesantes. Son los que añaden nuevas fuentes para vídeos, música y fotografía. Y un tipo especial que es el add-on de programas, principalmente destinado a recoger el resto de opciones.

Add-on de video

Accesibles desde el menú de “Vídeos” en XBMC, al ejecutar un add-on de vídeo se obtiene como resultado una lista de elementos que pueden ser “carpetas” o “ficheros”, siguiendo el símil de las carpetas y ficheros de tu disco. Una “carpeta” es un elemento que al seleccionarlo devuelve otra lista de elementos, y un “fichero” es directamente algo que se puede reproducir.

Lo más habitual es que el addon obtenga los elementos de estas carpetas y ficheros virtuales leyendo un sitio web, extrayendo mediante expresiones regulares los enlaces a categorías o canales para presentarlos como “carpetas” y extrayendo los enlaces a los vídeos para presentarlos como “ficheros”.

Un buen ejemplo de esto es el acceso a las conferencias del add-on “TED Talks” por autores. La lista de autores son las carpetas, puesto que al seleccionarlas obtienes todas las ponencias de ese autor, y a su vez las ponencias son los “ficheros” ya que al seleccionarlas puedes ver el vídeo sin más. Imagínate que tienes las ponencias descargadas en tu ordenador y clasificadas en carpetas con el nombre del autor, y verás que tiene sentido.

Hay muchos ejemplos de add-ons de vídeo, y en mi caso son los que más uso con diferencia. Están los add-ons oficiales de XBMC y menos “conflictivos”, como el add-on para acceder a YouTube, las TED Talks o la Academia Khan. Y luego están los add-ons que acceden a televisiones, películas y series. En esta categoría están mis add-ons más conocidos (tvalacarta y pelisalcarta), pero también otros muy populares como icefilms y 1channel.

Add-on de audio

El add-on de audio tiene muchas similitudes con el add-on de vídeo, en cuanto a la estructuración por “carpetas” y “ficheros”, pero lógicamente su finalidad es escuchar música, radio y cosas por el estilo. Si es el tipo de add-on que te interesa verás que hay pocas diferencias en su desarrollo respecto al add-on de vídeo.

Los mejores ejemplos de este tipo de add-on los tienes en el de Shoutcast, Grooveshark o Icecast.

Add-on de fotografía

De la misma forma que en el caso anterior, un add-on de fotografía añade contenido a XBMC incorporando “carpetas” y “ficheros” virtuales para navegar. También es muy similar en su estructura y desarrollo al add-on de vídeo y al de música.

Los ejemplos más populares de este tipo de add-ons son los relacionados con fotografía profesional, como 500px o The Big Picture (muy recomendable), o los relacionados con tus álbumes de fotos personales como Picasa o Flickr.

Programa

Es una categoría reservada para los add-ons que no encajan en las anteriores, puedes encontrar algunos que carecen totalmente de interfaz de usuario como TvTunes (que completa tus series descargando sus melodías) o Artwork downloader (que descarga fanarts adicionales). Y también puedes encontrar algunos que son aplicaciones completas dentro de XBMC, como el add-on para navegar por foros “Forum Browser”.

Próxima entrada

La entrada de mañana describirá cómo funciona el add-on de vídeo que viene como ejemplo de la librería “Plugin Tools”, para descubrir los principales aspectos internos de un add-on y su comunicación con XBMC.