Las ventajas que tiene respecto a activar la conexión por USB que trae Android de serie son varias, entre ellas:

• Acceso completo al sistema de ficheros del teléfono. La tarjeta de memoria interna es accesible en /mnt/sdcard.
• Acceso simultáneo desde el teléfono y desde el ordenador. De este modo no dejarán de funcionar las aplicaciones que han sido pasadas a la tarjeta de memoria mientras la usamos desde el ordenador.

Se trata de una primera versión y en directorios donde hay muchos archivos, por ejemplo la carpeta de fotos o de música, el acceso puede ser algo lento. Las siguientes versiones de adbfuse irán mejorando este y otros aspectos.

Se trata de algo para usuarios avanzados, ya que el teléfono ha de estar rooteado, tener instalado BusyBox, y saber montar un sistema de archivos FUSE en Linux.

Se puede descargar en la web del proyecto tanto la versión empaquetada como el código fuente con Mercurial. El proyecto ha sido liberado bajo la licencia GNU GPLv3.

Es un problema conocido que si se llama al método AnimationDrawable.start() desde métodos del Activity como en Activity.onCreate(), la animación no se moverá, y solo se verá la primera imagen de la misma. No habrá ningún error, no habrá ningún problema, y sin embargo la animación no se moverá.

La solución la aporta un usuario en la misma hebra del problema, y viene a decir que hay que crear una clase Starter que implemente la interfaz Runnable y crear un objeto de este tipo dentro del método ImageView.post(). De este modo el método run() de la clase Starter se ejecutará en la misma hebra que el método del Activity (la hebra de interfaz del usuario – UI Thread) y además después de que nuestro ImageView haya sido correctamente inicializado y mostrado en pantalla.

Esta primera parte iría en el método del Activity donde queremos asignar e iniciar la animación.

1
2
3
4
5

// --- %< ---
imageView.setBackgroundResource(R.drawable.throbber);
AnimationDrawable d = (AnimationDrawable)imageView.getBackground();
imageView.post(new Starter(d));
// --- %< ---

Y por otro lado tendríamos que crear una clase Starter() como la siguiente.

1
2
3
4
5
6
7
8
9
10
11
12
13
14

/**
* Starts the animation drawable passed to the constructor.
*/
class Starter implements Runnable {
    private AnimationDrawable animationDrawable = null;
 
    public Starter(AnimationDrawable animationDrawable) {
        this.animationDrawable = animationDrawable;
    }
 
    public void run() {
        this.animationDrawable.start();
    }
}

En cualquier caso, en la mayoría de dispositivos no será posible mostrar en este tipo de contenedor un gif animado, ya que según la documentación tan solo se representará el primer frame de la imagen animada.

El modo de representar correctamente una animación en android es usando un recurso creado específicamente para ello. De los dos tipos de animaciones que se pueden crear en Android la que nos interesa en esta ocasión es la que se conoce como Frame Animation. La idea es sencilla y es muy similar a la de los GIF animados: un archivo xml define qué imágenes se muestran y durante cuánto tiempo, las imágenes deben de encontrarse accesibles como recursos internos de la aplicación. Para más información véase la documentación sobre Frame Animation.

La cuestión es que hay un montón de GIFs animados que podemos querer incluir en nuestra aplicación para Android, así que es necesario hacer una conversión de un formato a otro de un modo más o menos automatizado.

El siguiente guión en python extrae los frames completos así como la información temporal y espacial de cada uno de ellos regenerando imágenes en caso de tratarse de un GIF optimizado, para formar un recurso de imagen completo para Android. La animación así creada funcionará correctamente en cualquier dispositivo en cualquier versión de Android. Para más información véase la clase AnimationDrawable.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

#!/usr/bin/env python
# -*- encoding: utf-8 -*-
 
import sys, os
import subprocess
 
# When no delay is specified in a gif file, 100ms is default
DEFAULT_DELAY_MS = 100
 
input_file = None
output_file = None
 
try:
    input_file = sys.argv[1]
    output_file = "%s.xml" % (input_file.split(".")[0],)
except:
    print "Usage: %s <input.gif>" % (sys.argv[0],)
    sys.exit(1)
 
 
class Anim(object):
    def __init__(self):
        self.content = []
 
    def add_header(self):
        self.content.append('<?xml version="1.0" encoding="utf-8"?>\n')
        self.content.append('<animation-list\n')
        self.content.append('    xmlns:android="http://schemas.android.com/apk/res/android"\n')
        self.content.append('    android:oneshot="false">\n')
 
    def add_item(self, resource, duration):
        self.content.append(
            '    <item android:drawable="@drawable/%s" android:duration="%d" />\n' %
            (resource, duration))
 
    def add_footer(self):
        self.content.append('</animation-list>\n')
 
    def write_file(self):
        file_descriptor = open(output_file, "w")
        file_descriptor.writelines(self.content)
        file_descriptor.close()
 
 
class Gif(object):
    def __init__(self, gif):
        self.input_file = gif
        gif_info = subprocess.Popen(
            ["gifsicle", "--info", input_file],
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE)
 
        (gif_info_out, gif_info_error) = gif_info.communicate()
 
        self.gif_info_lines = gif_info_out.splitlines()
 
    def get_info(self):
        return self.gif_info_lines
 
    def explode(self):    
        return_code = subprocess.call(
            ["gifsicle", "--explode", "--unoptimize", self.input_file])
 
        return not return_code
 
    def to_png(self, gif_frame):
        return_code = subprocess.call(["gif2png", "-d", "-s", "-O", gif_frame])
 
        return return_code
 
 
def main():
    print "Processing %s..." % (input_file,)
 
    anim = Anim()
    anim.add_header() 
 
    gif = Gif(input_file)
 
    if not gif.explode():
        print "Error exploding gif input file %s" % (input_file,)
        #sys.exit(1)
 
    info_lines = gif.get_info()
 
    counter = 0
    for line in info_lines:
        line = line.strip()
 
        if line.startswith("disposal"):
            line_items = line.split()
 
            if len(line_items) == 4:
                milliseconds = int(round(float(line_items[3][:-1]) * 1000))
            else:
                milliseconds = DEFAULT_DELAY_MS
 
            # Rename and convert gif to optimized png
            renamed_gif = "%s_%03d.gif" % (input_file.split(".")[0], counter)
            os.rename("%s.%03d" % (input_file, counter), renamed_gif)
            result = gif.to_png(renamed_gif)
 
            anim.add_item(renamed_gif.split(".")[0], milliseconds)
            counter = counter + 1
 
    anim.add_footer()
    anim.write_file()
 
    os.unlink(input_file)
    sys.exit(0)
 
if __name__ == "__main__":
    main()

Es necesario tener instalado gifsicle, y para la optimización en tamaño y conversión a png de las imágenes resultantes es necesario tener también instalado, y en el $PATH, gif2png.

Descargar getanim.py.

Desarrollo de Cylon Detector para Android

En cada frame recibido se desea analizar si existe la cara de una persona, por lo que hay que convertir la imagen a Bitmap y pasarla al detector de caras que provee el API. Pues bien, existe un problema y es que la factoría para crear Bitmaps no acepta ese formato. Hay varias soluciones por la red, pero unas son para Android 2.2 en adelante, otras son implementaciones en C para hacerlas usando el NDK como librería independiente, y otras símplemente son demasiado complejas para lo que aquí se necesita.

Al final lo que he hecho es analizar el formato de los datos en base a su definición y crear el Bitmap a partir de estos datos para la imagenen blanco y negro. Podría hacerse para la imagen en color símplemente leyendo todos los datos y haciendo uso de las funciones de conversión de YCrCb a RGB pero ello requeriría mayor tiempo de proceso incluyendo varias multiplicaciones en coma flotante. Aquí solo necesitamos en principio detectar si hay una cara en la imagen o no, y para ello es suficiente con que la imagen sea en blanco y negro. Para obtener la imagen en blanco y negro lo que he hecho ha sido leer los valores de luminancia (luminosidad), que según el formato NV21 están en la primera parte del array y convertir cada valor a un punto RGB con el mismo valor. El resultado, aunque no se aprecia demasiado bien en la imagen anterior, no es completamente una imagen en blanco y negro, sino que aparecen zonas saturadas de un color amarillo. La conversión que estoy realizando no es del todo correcta pero es cuestión de convertir y acotar correctamente los valores.

Por si a alguien le es de utilidad, esto es un recorte de la parte más importante que he programado para la conversión de NV21 a Bitmap:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

/**
 * @author nauj27
 * The Utils class contains utilities for CylonDetector.
 */
public class Utils {
 
	/**
	 * See http://www.fourcc.org/yuv.php#NV21 for more information.
	 * We only read luminance for speed up the whole process. 
	 * All colors of the image are set to the luminance value and
	 * this way we obtains a black and white image for processing.
	 * 
	 * @param data The data array in NV21 (YCbCr_420_SP) format.
	 * @return Black and white bitmap decoded from NV21 input data.
	 */
	public static Bitmap getBitmapFromNV21(byte[] data, int width, int height) {
 
		int pixelsNumber = width * height;
		int[] colors = new int[pixelsNumber];
 
		for (int pixel = 0; pixel < pixelsNumber; pixel++) {
			colors[pixel] = Color.rgb(data[pixel], data[pixel], data[pixel]);
		}
 
		return Bitmap.createBitmap(colors, width, height, Bitmap.Config.ARGB_8888);
	}
 
}

Editada: El modo correcto de convertir el valor de luminancia a escala de grises para crear la imagen lo he sacado finalmente del proyecto zxing, y es el que dejo a continuación:

1
2

grey = data[pixel] & 0xff;
colors[pixel] = 0xff000000 | (grey * 0x00010101);

Esto es lo que iría dentro del bucle for para que sea interpretado correctamente por el Bitmap.createBitmap como mapa de color ARGB_8888.

El problema es que en Android no funciona así. Desde la configuración de los mensajes no se puede elegir un perfil y si se crean dos perfiles distintos hay que elegir uno y el otro no se usa para nada.

La solución es crear un único perfil con una mezcla de las dos configuraciones. Lo voy a poner aquí, porque siempre que pierdo la configuración por el cambio de ROM me cuesta volver a hacerlo funcionar.

En el menú Ajustes > Conexiones inalámbricas > Redes móviles > APN > MENÚ > APN nuevo:

Nombre: Simyo
APN: gprs-service.com
Proxy:
Puerto:
Nombre de usuario:
Contraseña:
Servidor:
MMSC: http://217.18.32.180:8080
Proxy MMS: 217.18.32.181
Puerto de MMS: 8080
Protocolo MMS: WAP 2.0
MMC: 214
MNC: 19
Tipo de autenticación: Ninguno
Tipo de APN: default,mms

Y funcionará así tanto la conexión de red GPRS/3G/HDSPA/HDSPA+ como los mensajes MMS.

Para mantener el control de los cambios he venido usando Mercurial. El mejor modo de descargarse el código fuente de ColorPicker es usando por tanto un cliente de Mercurial, disponible para todas las plataformas más usadas.

Tengo varias ideas en mente para esta aplicación, unas que se me ocurrieron y otras muchas que me han ido sugiriendo tanto en persona como en los comentarios del propio Android Market. En las próximas semanas podrán verse novedades y actualizaciones de la aplicación.

Debido a esto es fácil caer en el error como a mi me ocurrió de pensar en que los programas de Android se van a poder decompilar y modificar fácilmente. Esto en la realidad no ocurre así ya que el código binario generado para Android es para su ejecución en la DalvikVM que no tiene nada que ver con el bytecode de Java.

Cuando descomprimes un apk (porque también es bien sabido que no es más que un zip renombrado con unas características especiales), se puede encontrar un fichero classes.dex que contiene las clases de java usadas por la aplicación, entre otras cosas:

$ file classes.dex

classes.dex: Dalvik dex file version 035

Este fichero se puede deconstruir por ejemplo con las utilidades del proyecto smali, lo cual generará una serie de ficheros .smali con los opcodes de Dalvik. Estos ficheros .smali tienen el siguiente aspecto:

.class public LHelloWorld;
.super Ljava/lang/Object;
.method public static main([Ljava/lang/String;)V
.registers 2

sget-object v0, Ljava/lang/System;->out:Ljava/io/PrintStream;

const-string v1, “Hello World!”

invoke-virtual {v0, v1}, Ljava/io/PrintStream;->println(Ljava/lang/String;)V

return-void
.end method

Así el fichero se puede en principio modificar con mayor o menor dificultad y volver a compilar con smali.

Pero no todo es tan bonito como parece hasta aquí, porque ahora hay que reconstruir el apk de la aplicación. El primer paso será actualizar el classes.dex dentro del apk. Esto se puede hacer con la misma utilidad zip estándar. Después hay que firmar el archivo con algo como:

$ jarsigner -verbose -keystore my_keystore com.nauj27.android.hackme.apk android

El problema viene cuando se intenta verificar la firma del paquete, obteniendo el siguiente mensaje:

$ jarsigner -verify com.nauj27.android.hackme.apk
jarsigner: java.lang.SecurityException: invalid SHA1 signature file digest for classes.dex

Cada fichero lleva una firma SHA1 que AFAIK no es posible saltarse. Probablemente se podrá hacer algo más pero por ahora lo voy a dejar aquí.

La historia comienza cuando unos amigos deciden cuál va a ser su proyecto fin de carrera, enlazando una trama donde El niño Laí, un robot que se parece a R2D2 termina siendo torero. Una trama que te atrapa desde el principio y que me leído en una tarde. Y mira que a mi los libros suelen durarme porque los leo muy poquito a poco.

Si quieres echarle un vistazo lo puedes bajar libre y gratuítamente de la web oficial http://niniolai.mobi/