Extrayendo APKs de nuestro teléfono Android

Hace unos días instalé una aplicación a través de Google Play en un emulador y quería analizarla porque me resultaba sospechosa. A las horas, cuando fui a descargarla de nuevo, ya la habían eliminado, así que recordé que la guardaba en un emulador de Android y me puse al lío.

Lo primero que tenemos que hacer es tener el SDK de Android instalado (hay muchas páginas donde los explican).

Después activamos el modo depuración USB de nuestro teléfono y lo conectamos por USB.

Nos vamos a una consola y escribimos

 $ adb shell pm list packages -f  

Este comando nos mostrará la lista de aplicaciones instaladas en el teléfono junto a la ruta del APK (si es que existiera) con el siguiente formato:

[...]
 package:/data/app/com.spotify.music-2.apk=com.spotify.music  
 package:/system/app/Calculator.apk=com.android.calculator2  
 package:/system/app/HTMLViewer.apk=com.android.htmlviewer  
 package:/system/priv-app/DemoMode.apk=com.motorola.demomode  
 package:/data/app/netgenius.bizcal-2.apk=netgenius.bizcal  
 package:/data/app/com.motorola.bodyguard-1.apk=com.motorola.bodyguard  
 package:/system/app/CellBroadcastReceiver.apk=com.android.cellbroadcastreceiver  
 package:/system/priv-app/GoogleLoginService.apk=com.google.android.gsf.login  
 package:/data/app/com.linkedin.android-2.apk=com.linkedin.android  
 package:/system/app/Mesh.apk=com.motorola.mesh  
 package:/system/app/Bluetooth.apk=com.android.bluetooth  
[...]

Si que queremos extraer el APK de la primera aplicación instalada (en este caso Spotify), usaríamos el siguiente comando:

 $ adb pull /data/app/com.spotify.music-2.apk .  

El punto del final es para decir que se copie al directorio actual. Si tuviéramos una carpeta apk, podríamos usar:

 $ adb pull /data/app/com.spotify.music-2.apk apk/  

Un saludo!

Programando un ATtiny45 y 85

El otro día compré un microcontrolador ATtiny 45 y otro 85 para probar a hacer alguna cosa. Voy a explicar los pasos para programarlo teniendo un Arduino (en mi caso he usado un nano v3).

El patillaje es el siguiente:

• VCC -> 5V
• GND -> Negativo
• Y las patillas 2, 3, 5, 6 y 7 las podemos usar para "jugar" con él.

La conexión para la programación es bastante simple:

Arduino Nano	ATtiny45/85
+5V	VCC (patilla 8)
GND	GND (patilla 4)
Pin 10	Reset (patilla 1)
Pin 11	Pin 0 (patilla 5)
Pin 12	Pin 1 (patilla 6)
Pin 13	Pin 2 (patilla 7)

Un par de consideraciones a tener en cuenta:

• Es necesario para usar como programador un Arduino que tenga un ATmega328, no vale el ATmega168.
• Si tenemos un Arduino UNO es necesario poner un condesador de 10uF entre el Reset y el GND del UNO.

La gracia de estos microcontroladores es que no necesitan un reloj externo, por lo que es más fácil empezar a jugar con ellos.

Lo siguiente es preparar el IDE de Arduino. Para descargamos las librerías para los ATtiny (arduino-tiny) https://code.google.com/p/arduino-tiny/

Y ahora tenemos dos opciones para instalarla:

• La primera es en nuestra carpeta sketchbook. Creamos una carpeta dentro de esta con el nombre hardware y descomprimimos el contenido. Nos debería quedar algo así: sketchbook/hardware/tiny/
• La segunda opción es buscar la carpeta hardware dentro de la instalación de Arduino y descomprimirlo ahí.

Lo siguiente es renombrar el archivo de placas. Lo más sencillo es cambiar el nombre de "Prospective Boards.txt" a "Boards.txt", pero si quieres personalizar las tarjetas que te salen en el menú del IDE, debes crear un archivo "Boards.txt" y pegar las que te interesen desde el archivo "Prospective Boards.txt".

Una vez hecho esto, arrancamos nuestro entorno de Arduino y procedemos a cargar el ArduinoISP, para que nuestro Arduino maestro sirvan como cargador para el ATtiny. Para ello abrimos "Archivo -> Ejemplos -> ArduinoISP". 

Ahora en "Herramientas -> Tarjeta" seleccionamos el modelo de nuestro Arduino (en mi caso el Nano v.3 ATmega328) y cargamos el sketch.

Ahora vamos a programar nuestro ATtiny con el famoso sketch "blink". 

Abrimos "Archivo -> Ejemplos -> Basics -> Blink". Seleccionamos la tarjeta del ATtiny, que en mi caso es un "ATtiny45 @ 8Mhz". Si queremos una frecuencia mayor debemos instalar un reloj externo (pero creo que ya pierde toda la gracia...).

En "Herramientas -> Programador" seleccionamos "Arduino as ISP".

Un último detalle, el pin 13 debemos cambiarlo por el 0 (que el ATtiny no tiene tantos pines).

Cargamos el "sketch" normalmente y nos saldrán un par de avisos como este:

No debemos preocuparnos, podemos omitirlos. :P

Ahora ya sólo nos queda conectar un LED con una resistencia al Pin 0 (patilla 5) y GND, como en la siguiente imagen (debemos mantener la alimentación a través del otro Arduino o una fuente externa, como queramos):

Un saludo!

Fuentes:

• http://academy.cba.mit.edu/content/tutorials/akf/input_device_examples_ArduinoIDE.html

Cambiando palanca de control de espejos en Golf IV

Hace un par de semanas me di cuenta que mi coche, un VW Golf IV del 2000, tiene muchas tonterías que no funcionan y puedo arreglar yo mismo en un rato y con unos pocos euros, así que me propuse hacer una chapuza a la semana (veremos a ver si lo cumplo...), y aquí está la primera.

La pieza que rompí en cuestión es esta. Lleva más de 4 años rota, y fue de un rodillazo, por supuesto, sin querer :P

Para cambiarla, lo primero que hay que hacer es comprar una nueva, bien en el concesionario o bien por Ebay (o algún otro sitio que vosotros sepáis). No recuerdo cuánto me costó exactamente porque la compré hace algunos años, pero estaba sobre los 15€. Con el número de bastidor os darán exactamente la misma sin ningún problema.

Una vez tengamos la pieza en nuestro poder, procedemos a desmontar el panel de la puerta del conductor:

Desmontamos el tirador de la puerta:

Para ello quitamos la pieza negra que se agarra, empujando hacia el cristal:

Yo lo hice utilizando un destornillador plano a modo de palanca por la parte de abajo, para que si se hace algún rasguño no se vea (aunque ya está hecha polvo, pero bueno...).

Lo siguiente es levantar toda la tapadera negra que queda. Haciendo un poco de fuerza hacia arriba, sale a presión, pero si sacarla del todo, que tiene un cable conectado.

Una vez haya salido, levantamos con cuidado y quitamos la clema (conector) de los elevalunas.

Y nos debe quedar así:

Ahora vamos a quitar tornillos. Para empezar, quitamos los tres de estrella grandes que aparecen señalados en la imagen anterior. Si se nos caen dentro del tapizado no pasa nada, cuando lo separemos de la puerta caerán al suelo.
Seguimos quitando tornillos:

• El tornillo en la parte superior derecha (señalado con un 1) es un tornillo de estrella normal que debemos quitar.
• Los tres círculos señalados en la parte inferior son tres tornillos Torx t10 que enganchan el panel al metal de la puerta. Si pasamos la mano por debajo notaremos las 3 endiduras. También los quitamos, como es lógico.

Ya ha pasado la parte fácil. Ahora tenemos que separar el panel de la puerta y quitar todos los conectores. Para este paso recomiendo tener la ventanilla bajada para más comodidad.

Para separar completamente el panel tenemos que tirar con fuerza, sin miedo. Está enganchado con unos clips de plástico que a veces se rompen (no os preocupéis, cuestan 2 duros en el concesionario). Primero tiráis hacia afuera para separar todos los clips, y una vez están separados, hacia arriba para descolgar el panel del filo de la ventanilla. Puede sonar raro, pero cuando estéis con las manos en la masa, ya veréis que no es tan difícil.

Una vez tenemos el panel separado de la puerta, hay que tener cuidado porque hay varios cables enganchados que tenemos que desconectar antes.

• La primera clema a desconectar es la de la pieza que vamos a cambiar. Si tenemos un destornillador fino nos ayudará. Sólo es tirar para afuera apretando por ambos lados (como los clips de las mochilas :P).
• La segunda es la de la luz inferior izquierda. Se quita igual que la anterior. Para esta sí es más recomendable usar un destornillador fino, porque es más complicado meter los dedos para desenchufar.
• La tercera es la del piloto rojo al lado del pestillo. Es aéreo, por lo que no hay problema para desconectarlo.
• Por último, el tirador de apertura de la puerta. Es un cable de acero que termina en un gancho. Hay que quitar el gancho de su sitio tirando hacia arriba y además tiene un trocito de plástico con 2 pestañas que hace que se quede fijo. Levantamos las pestañas y el plástico sale prácticamente solo (toqueteando un poco).

Una vez quitados estos conectores, ya tenemos el panel desmontado totalmente. Yo me lo subí a casa para limpiarlo un poco por dentro, que la suciedad se acumula por dentro, y bastante...

Cambiar la pieza una vez todo desmontado es muy sencillo:

Sólo hay que hacer un poco de palanca (con cariño eh) en las pestañas señaladas en rojo y empujar hacia afuera. El cable que se ve ahí es de un LED que tengo en el tirador de la puerta (que vaya chapuza hice en su día...), así que tranquilos si vosotros no lo tenéis. :P

Una vez sacada la pieza, metemos la nueva y hacemos todo el proceso a la inversa.

Si se os partió algún clip de plástico, podéis ir al concesionario y comprar una bolsa (creo que traía 10 por menos de 5€).

Antes de montarlo todo de nuevo, mejor conectar la clema de los espejos, dar el contacto y probar que funciona correctamente. Si no funciona, nos acercamos al concesionario y que nos cambien la pieza o nos la prueben (por si el fallo es eléctrico y no de la pieza). :D

Si tenéis alguna duda, dejadla en los comentarios e intentaré resolverla lo antes posible.

Un saludo!

P.D.: No tengo la referencia de la pieza, si alguien la tiene o la sabe, agradecería que la pusiera en los comentarios!

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!

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

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