miércoles, 23 de abril de 2014

series.ly en XBMC

Pues ya es público el (que yo sepa) único plugin funcional para http://series.ly y XBMC. Lo empecé a hacer hace un par de meses en mis ratos libres para poder mantenerme al día en cuanto a series, y aquí está!



Para instalarlo, lo único que hay que hacer es descargar el plugin desde http://bit.ly/sly_xbmc (mirror: https://github.com/plutec/seriesly_xbmc/blob/master/downloads/seriesly_xbmc.zip?raw=true) e instalarlo siguiendo las intrucciones que he publicado en el post anterior:
http://www.plutec.net/2014/04/instalar-plugin-xbmc-zip.html

Poco a poco lo actualizaré (la lista de TODOs es bastante amplia), y cualquier comentario es bienvenido tanto en github (algún error o mejora) como en los comentarios.

Un saludo!

Instalar plugin en XBMC desde un zip

Voy a explicar cómo instalar un plugin para XBMC partiendo de la base que tenemos el zip con el plugin en nuestro directorio de archivos. El procedimiento es muy simple, pero si nunca se ha hecho resulta un poco extraño, porque no sigue la jerarquía lógica de navegación:
  • En primer lugar abrimos XBMC y nos vamos a Videos -> Add-ons,

  • obtener más complementos,


  • subimos al nivel superior, que no nos llevará a la pantalla anterior,

  • y aquí nos da la opción de instalar desde un archivo zip. Pulsando,

  • nos desplegará un menú a la derecha donde ya podremos elegir el archivo del plugin desde nuestro directorio de archivo del ordenador.

Un saludo!


martes, 8 de abril de 2014

C y Python mediante sockets

Hoy toca el paso de comunicar un lenguaje de bajo nivel y consumo de recursos (C/C++) con uno que es un poco más avanzado y que consume más recursos (CPU y Memoria), como Python.

La historia general es que necesitaba comunicar una Fonera (la cuál no tiene muchos recursos) con un servidor central (RaspberryPi) que tiene toda la infraestructura desarrollada en Python. Para no complicarme la vida, hice un pequeño servidor en C para la Fonera y un cliente en Python para la Raspberry.

Este código corresponde a la Fonera, y lo podemos guardar como server.c (en Mega)

 #include <stdlib.h>  
 #include <stdio.h>  
 #include <sys/types.h>  
 #include <sys/socket.h>  
 #include <netinet/in.h>  
 #include <string.h>  
 #include <unistd.h>  
   
 #define MAXLINE 4096 /* buffer length */  
 #define SERV_PORT 10001 /* port */  
 #define LISTENQ 8 /* maximum number of client connections */  
   
   
 /* This function read a character from a buffer (fd) until it reads   
   the character (until), and it saves in (data). */  
 int read_until(int fd, char *data, char until) {  
   int len = 0;  
   char a[1];  
   int n;  
   
   do {  
   
     n = recv(fd, a, 1, 0);  
     if (n>0) // OK  
       data[len++] = a[0];  
   
   } while (a[0]!=until);  
   
   data[len] = '\0';  
   return len;  
 }  
   
 int main (int argc, char **argv) {  
   int listenfd, connfd, n;  
   socklen_t client_len;  
   char buf[MAXLINE];  
   struct sockaddr_in cliaddr, servaddr;  
   
   // Socket creation  
   listenfd = socket (AF_INET, SOCK_STREAM, 0);  
   
   // Preparing the socket address  
   servaddr.sin_family = AF_INET;  
   servaddr.sin_addr.s_addr = htonl(INADDR_ANY);  
   servaddr.sin_port = htons(SERV_PORT);  
   
   bind (listenfd, (struct sockaddr *) &servaddr, sizeof(servaddr));  
   
   listen (listenfd, LISTENQ);  
   
   printf("Server running! Waiting...\n");  
   
   while(1) {  
     client_len = sizeof(cliaddr);  
     connfd = accept (listenfd, (struct sockaddr *) &cliaddr, &client_len);  
     printf("Received request...\n");  
   
     read_until(connfd, buf, '\n');  
   
     printf("Received content: %s" , buf);  
   
     // Proccess the content  
     // ...  
     sleep(3); //Simulating process time  
     // Send response  
     send(connfd, buf, strlen(buf), 0);  
   
     // Close client connection  
     close(connfd);  
   } // And wait for another client  
   
   // Close listening socket  
   close (listenfd);  
   
 }  


Lo compilamos para la Fonera y lo ejecutamos: (Compilando C/C++ para La Fonera (MIPS))

 $ mips-linux-gcc server.c -o server
 $ ./server

Ahora pasamos a crear el código en Python para guardarlo en la RaspberryPi como client.py (en Mega)

 import socket  
 import sys  
   
 SERVER = '192.168.1.69' # Server IP or domain  
 PORT = 10001 # Server port  
   
 """  
  This function read a character from a buffer (fd) until it reads   
  the character (until), and return the string.  
 """  
 def read_until(fd, until):  
   to_ret = ''  
   try:  
     a = fd.recv(1)  
     while a[0] != until:  
       to_ret += a  
       a = fd.recv(1)  
   
     to_ret += a  
   except:  
     print "Error: Socket closed (or another thing!) :P"  
     return None  
   return to_ret;  
   
 def main():  
   # Create a TCP/IP socket  
   sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  
   
   # Connect the socket to the port where the server is listening  
   server_address = (SERVER, PORT)  
   print 'Connecting to %s in port %s' % server_address  
   sock.connect(server_address)  
   
   try:  
       
     # Send message  
     message = 'request:variable\n'  
     print 'Sending: %s' % message  
     sock.sendall(message)  
   
     # Wait the response  
     data = read_until(sock, '\n')  
     print 'Received: %s' % data  
   
   finally:  
     print 'Closing socket'  
     sock.close()  
   
 if __name__ == '__main__':  
   main()  

NOTA: En la dirección IP habría que poner la IP de la Fonera (servidor), en mi caso es la 192.168.1.69

Ya sólo tendríamos que ejecutar el cliente en la Raspberry con:

 $ python client.py  

En ese momento, el cliente enviará al servidor el mensaje (request:variable\n), el servidor simulará su procesamiento durante 3 segundos y devolverá la respuesta. En esta caso, la respuesta coincide con los datos recibidos, pero no tiene que ser así.

Referencias:

  • http://www.cs.dartmouth.edu/~campbell/cs50/socketprogramming.html
  • http://pymotw.com/2/socket/tcp.html

sábado, 5 de abril de 2014

API para series.ly (sin token)

Hace un par de meses comencé un mini-proyectito personal para poder ver series y películas sentado cómodamente en mi sofá con la RaspberryPi y sin tener que descargarlas previamente, pero esto vendrá en otra entrega. :P

Solicité acceso a la API de Series.ly y estuve unos 5 días esperando respuesta, sin resultado positivo. Tras ver esto, empecé a indagar en algunos foros y vi que había gente que llevaba esperando más de 5 meses para obtenerla, así que miré un poco el código fuente de la web, las peticiones JavaScript, y aquí está el resultado. Una API de series.ly en Python y basada en la página web, es decir, sin necesidad de tener acceso a la API oficial (con token necesario).

 https://github.com/plutec/apisly

Con la API se puede loguear, ver "mis series", "mis películas", cambiar estados, ver los links disponibles para cierta película/serie, información sobre capítulos.

Para que veáis lo fácil que es utilizarla, os dejo el archivo de ejemplos (también está en GitHub):

 import sly  
   
 api = sly.APISLY(username='username', password='password')  
   
 print api.my_series()  
 print api.my_movies()  
 print api.get_serie_info('7HV4DXUHE5', 1)  
 print api.search('anillos')  
 print api.get_film_info('NE2FYXX5KE', 2)  
 print api.get_links(1653, 2)  
 print api.get_activity()  

Si alguien necesita una invitación a series.ly, que lo pida por Twitter, comentarios, email o cualquier otro medio que encuentre. :P