• Crear un fichero .xml para el nuevo degradado, para ello hacemos click en el botón derecho del ratón sobre el proyecto Android y seleccionamos New > Other > XML > XML File. Debemos incluir estos ficheros en el directorio res/drawable, como si se trataran de una imagen.
• Una vez creado el documento lo editamos e incluimos un elemento de tipo <shape> (figura o forma). Dentro de este debemos añadir otro de tipo <gradient> (degradado). Como ocurre con el resto de elementos de las interfaces en Android, esto mismo que vamos a hacer con el XML se puede hacer empleando clases del API, en concreto la clase GradientDrawable. Aquí tenéis algunos ejemplos:

<?xml version="1.0" encoding="utf-8"?>
<shape xmlns:android="http://schemas.android.com/apk/res/android">
	<gradient android:startColor="#ffffff"
	android:endColor="#000000"
	android:angle="270"
	/>
</shape>



<?xml version="1.0" encoding="utf-8"?>
<shape xmlns:android="http://schemas.android.com/apk/res/android">
    <gradient 
        android:startColor="#000000" 
        android:endColor="#FFFFFF"
        android:angle="45"
     />
</shape>



<?xml version="1.0" encoding="utf-8"?>
<shape xmlns:android="http://schemas.android.com/apk/res/android">
    <gradient 
        android:startColor="#000000"
        android:centerColor="#DF0101"
        android:endColor="#FFFFFF"
        android:angle="270"
     />
</shape>



<?xml version="1.0" encoding="utf-8"?>
<shape xmlns:android="http://schemas.android.com/apk/res/android">
    <gradient 
    	android:type="radial" 
    	android:gradientRadius="180"    
    	android:startColor="#DF0101" 
    	android:centerColor="#FFFF00" 
    	android:endColor="#74DF00" 
    />
</shape>



• El último paso es añadir el degradado como background de un elemento que nos interese. Para ello abrimos el layout que nos interese en res/layouts y en ventana de preferencias (Preferences) hacemos click sobre el campo. A continuación nos mostrará un menú para seleccionar el elemento que queremos fijar como degradado:

Como se puede ver en los ejemplos hay que definir un tipo de degradado (lineal, radial o sweep), el ángulo para los lineales, el radio para los radiales, un color de inicio, otro medio y otro fin (el medio es opcional, y van en RGB), etc. A mi me ha servido con eso, el que quiera más atributos que se pase por aquí.

Un saludo!

Ahora me toca hablar de las interfaces, los componentes gráficos de las aplicaciones. Como dije en otra entrada anterior, los diseños o layouts se encuentran en el directorio res/layout.

Para crear un nuevo diseño hacemos click en el botón derecho y vamos a la opción New > Android XML File. A continuación tenemos que poner nombre a nuestro diseño y seleccionar, si no viene por defecto, el tipo layout:

Después de eso sólo tenemos que abrir el nuevo fichero para ver la vista del editor de interfaces. Es posible editar el fichero como texto, pero por comodidad suelo usarla (aunque algunas veces impida hacer cosas que puedas hacer editando a mano).

La vista de edición de interfaces muestra a la izquierda la lista de componentes que podemos arrastrar a la pantalla, en el centro, y del tamaño que seleccionemos en las opciones de arriba, y a la derecha se muestra el árbol de elementos:

Para empezar hay que echar un ojo al apartado de Layouts. Por ahora he utilizado dos tipos:

• LinearLayout: funciona como un vector de elementos gráficos al que podemos fijar orientación vertical u horizontal. Yo antes combinaba varios de este tipo para crear filas y columnas, como si se tratara de una tabla.
• RelativeLayout: permite definir las posiciones de unos elementos a partir de otros. Para empezar arrastramos un componente de la interfaz a uno de sus cuatro márgenes para alinearlo. Después de esto podemos arrastrar los otros unos sobre otros empleando una cuadrilla que nos permite decir donde se sitúan. La ventaja es que permite crear diseños complejos empleando sólo un layout (NOTA: conviene dar un ID a un elemento antes de colocar y añadir otro). Aquí un ejemplo de lo de la cuadrilla:

Y el resultado de soltar el botón sobre su esquina inferior derecha:

Las interfaces no tienen mayor misterio, es echarle un rato a añadir botones, campos de texto, imágenes, fondos, etc, etc, yo iré poniendo en el blog trucos que aprenda. ¡Hay que jugar mucho con la pestaña de properties de cada componente, tienen de todo! (Nota2: para alinear elementos dentro de los layouts, emplear el atributo Gravity). Pestaña de properties de un campo de texto (EditText):

Y para acabar me voy a crear un label (TextView), un botón (Button) y un campo de texto dentro de un LinearLayout y voy a enseñaros como llamar a los elementos desde la actividad. Mi árbol de elementos queda así:

Y el código de la actividad HelloAndroid:

package com.example.helloandroid;
 
import android.app.Activity;
import android.graphics.Color;
import android.os.Bundle;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;
 
public class HelloAndroid extends Activity {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.new_layout);
 
        //Cargo los elementos de la interfaz haciendo un casting y usando los IDs con R
        TextView mi_etiqueta = (TextView) findViewById(R.id.mi_etiqueta);
        EditText mi_texto = (EditText) findViewById(R.id.mi_texto);
        Button mi_boton = (Button) findViewById(R.id.mi_boton);
 
        //Cambio el texto del label
        mi_etiqueta.setText("Introduce un texto");
        //NOTA: El hint es la sugerencia que se ve antes de teclear
        mi_texto.setHint("El texto debe ir aquí");
        //Fijo el color de fondo del boton
        mi_boton.setBackgroundColor(Color.YELLOW);
 
    }
}

Hasta ahora he hablado por encima de como instalar el SDK y correr un emulador, como crear un proyecto nuevo, que es una actividad, como cambiar entre ellas y como crear una interfaz y llamar a sus elementos.

Creo que a partir de ahora voy a escribir trucos y otras cosas que vaya encontrando y que me hagan falta, como descarga y envio de ficheros, galerias, eventos, degradados y efectos de la intefaz, etcs. Un saludo!

package com.example.helloandroid;
 
import android.app.Activity;
import android.os.Bundle;
 
public class HelloAndroid extends Activity {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
    }
}

Al crear una clase que extienda de Activity hay que implementar al menos la función onCreate(), que es la que se ejecuta cuando se crea la actividad. Por defecto esa función recibe un paquete (Bundle), que contiene el estado anterior de la actividad en caso de que haya sido suspendida. Como se puede ver arriba, la clase HelloAndroid le pasa ese paquete a la superclase de la que extiende.

Lo siguiente que se hace en la función de creación es cargar el layout o diseño de la actividad, cargando una interfaz definida en XML. Como ya expliqué en otra entrada anterior, los diseños se guardan en “res/layout/”, y para llamarlos se utiliza R, indicando el nombre del fichero, como en este caso, “main.xml” pasa a ser “R.layout.main”. Si quisiéramos cargar otro layout sólo tendríamos que crearlo y cargarlo con “R.layout.LO_QUE_SEA”

Por ahora, de entre las funciones que incluye la actividad he usado:

• onConfigurationChanged(): a la que se llama cuando cambia la configuración, la usé para dejar fija la pantalla y que no rotara (ya explicaré otro día como).
• getResources(): para obtener los recursos asociados a R.
• startActivity(): para cambiar de actividad, más abajo explicaré como.
• finish(): para finalizar la actividad, OJO, cuando sea posible, no corta la ejecución en seco, termina de ejecutar. Con esto quiero decir que si debajo de un finish tenemos otras lineas de código, no van a dejar de ejecutarse.
• getIntent(): devuelve la intención que ha comenzado la actividad. Se utiliza para pasar variables entre actividades, eso irá a otra entrada del blog…
• getSharedPreferences(): para obtener las preferencias compartidas de la aplicación, que son variables que se almacenan en el móvil y no se borran si no la desinstalas, otra cosa que va a otra entrada.

Ahora para terminar voy a poner un ejemplo de uso de la clase Intent (Intención?), que indica una operación a realizar, como puede ser el cambio entre dos actividades. Para el ejemplo voy a crear otra actividad que se llame GoodbyeAndroid:

• Primero creo una nueva clase Java que extienda de Activity:

• A continuación creo un nuevo layout goodbye.xml (esto no lo explico hoy) y lo cargo en la función de creación de la nueva clase, de forma que quede:

package com.example.helloandroid;
 
import android.app.Activity;
import android.os.Bundle;
 
public class GoodbyeAndroid extends Activity {
	@Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.goodbye);
        //El resto del codigo
    }
}

• Ahora añado la nueva actividad al AndroidManifest, ya sea usando la herramienta gráfica o añadiendo directamente al XML debajo de </activity> lo siguiente:

<activity android:name=".GoodbyeAndroid"></activity>

Como se puede ver GoodbyeAndroid.java pasa a ser “.GoodByeAndroid“, y eso ocurre con el resto de actividades.

• Por último añado a la función de creación de HelloAndroid el código con el Intent que cambia entre las dos actividades (para que funcione hay que importar el paquete android.content.Intent):

Intent intent = new Intent(HelloAndroid.this, GoodbyeAndroid.class);
startActivity(intent);

Y ya está, lo próximo será como usar la herramienta de crear interfaces y como cargar los elementos desde el código. Un saludo!

Por pasos, para crear un proyecto hacemos:

• File > New > Android Project, o en caso de que no exista esa opción click en Other y luego seleccionar “Android Project”.

• A continuación tenemos que escribir los parámetros de configuración del nuevo proyecto:

• Como se puede ver primero tenemos que seleccionar un nombre de Proyecto, luego un nombre para la aplicación, que es el que se va a mostrar en el móvil, un paquete principal (he elegido lo de com.example porque estoy acostumbrado a ver cosas como com.google.x o org.apache.x…), después un nombre de actividad, que es el nombre del fichero .java principal que se creará con el proyecto, y una versión mínima del SDK para la que queremos que el proyecto sea compatible. Estos números se pueden mirar aquí:

• Una vez creado el proyecto nos encontramos con los siguientes directorios y ficheros:

• Nos encontramos con:

com.example.helloandroid: paquete principal del proyecto, que hemos creado en el paso anterior

HelloAndroid.java: es la actividad que se ejecuta al inicio, y la hemos creado en el paso anterior.

gen: es un directorio en el que se guardan ficheros java generados automáticamente. Por curiosidad he abierto “R.java” y he visto que contenía constantes con nombres de recursos que apuntaban a direcciones de memoria o identificadores del tipo “0x7f020000″. Contiene un comentario que dice que no debe tocarse.

res: es el directorio de “resources” o recursos, en el se encuentra todo lo relacionado con las interfaces, sus imágenes,  frases mostradas, estilos, sonidos, etc.

res/drawable-xdpi: en estos directorios se guardan las imágenes, los degradados y demás cosas relacionadas con los estilos. Antes sólo existía un directorio drawable, ahora existen tres, para mantener separadas las imágenes en función de su resolución (h de high, m de medium y l de low)

res/layout: es el directorio en el que se guardan los diseños de las interfaces definidas en XML. Por defecto se crea “main.xml”, que viene con un elemento de texto (TextView) con un “Hello World, Hello Android!”.

res/values: este directorio contiene el fichero “strings.xml”, en el que se definen cadenas de caracteres de forma clave-valor, y que luego se pueden mostrar en elementos de la interfaz. También permite definir colores, estilos, números, etc.

AndroidManifest.xml: fichero XML que contiene el manifiesto de la aplicación, en el que entre otras cosas se guarda información sobre el proyecto, se declaran las actividades y se piden los permisos de ejecución de la aplicación. Lo he tenido que usar para añadir nuevas actividades, pedir permisos como el acceso a internet o desactivar el giro de una interfaz.

• Ahora toca correr el proyecto, hacemos click con el botón derecho sobre el nombre del mismo y le damos a Run as > Android Application. Si ya teníamos abierto un AVD lo instalará y lo ejecutará, si no, abrirá una nueva máquina virtual:

El próximo día explicaré un poco las actividades y los cambios entre ellas.

Un saludo!

Vuelvo al blog una vez más, y esta vez para hablar de programación para Android, ya que mi proyecto de fin de carrera consiste en una aplicación social para este Sistema Operativo. Si no me rajo en el intento, tengo la intención de ir contando desde 0 todo lo que he aprendido las últimas semanas y publicar entradas cortas con cada “descubrimiento” nuevo.

Hoy para empezar voy a contar como preparar las herramientas necesarias para programar, vamos por pasos:

1. Descargar e instalar el Eclipse, un entorno de desarrollo gratuito para unos cuantos lenguajes, que cuenta con muchas herramientas y plugins. Yo me he descargado la versión para desarrollo Java, pero la Clásica también os vale.
2. Lo siguiente es instalar las Android Development Tools o ADT en Eclipse. Para ello hay que ir a Help > Install New Software, y en la ventana que aparece hacer click en Add y añadir lo siguiente: “ADT Plugin” y la URL “https://dl-ssl.google.com/android/eclipse/”
3. A continuación tenemos que seleccionar las “Developer Tools”, darle a Next una o dos veces y aceptar las condiciones de la ventana:
4. Después de la instalación de las herramientas y de reiniciar el Eclipse tenemos que descargarnos el kit de desarrollo de Android (SDK) de la página de desarrolladores, eligiendo el de nuestra versión de OS. Para continuar tenemos que descomprimir el .ZIP y en Eclipse > Preferences > Android seleccionar el directorio donde se encuentra:
5. Lo siguiente que hice fue descargar la versión 2.3.3 desde el listado de paquetes de Android en Eclipse:

Tras instalar el 2.3.3 y para configurar el terminal del emulador, desde el menú de Virtual Devices de la pantalla anterior configuré uno nuevo de la siguiente forma:Nota: la opción de Snapshot permite que se guarden imágenes del estado del emulador y su carga (salvo la primera vez) sea más rápida.

6. Por último sólo hay que elegir el menú de dispositivos en que acabamos de crear y darle al botón “Start” para arrancarlo:

El próximo día contaré un poco como crear un nuevo proyecto Android, que es cada directorio (o que se de ellos), y como correr el “Hello World!”.

Un saludo!

Este que veis es el conversor:

Me ha costado cerca de 4 euros al cambio, y si no tenéis muchos conocimientos de electrónica como en mi caso, es más sencillo que fabricarse uno. Sólo nos interesan 4 de sus patillas, que vienen con el nombre encima, y son: +5v (corriente, Vcc), Rxd (recibir) y Txd (transmitir) y Gnd (tierra). Van conectadas directamente a la placa siguiendo este esquema:

El montaje me ha quedado de la siguiente manera:

Ahora voy a contar los pasos para instalar el DD-WRT:

1. Descargar el fichero linux.bin de la página oficial de DD-WRT (en mi caso buscando Fonera 2100)
2. Conectar el ordenador a la Fonera por cable de red (pero sin alimentación, que no es necesaria porque la pillará del USB) y configurar la tarjeta de red del ordenador con una IP como 192.168.1.166 y la máscara 255.255.255.0
3. Resolver todo el cableado como en la foto que está encima, para ello he utilizado cables de los que venían con los lectores de DVD y CD del ordenador para activar la salida de auriculares, pero será por cables…
4. Enchufar el USB a Window$ (yo uso VMWare) para que salte el aviso de “Nuevo Hardware” y os diga el modelo que tenéis… yo no tenía ni idea, Made in China, y en Linux no lo reconocía… descubrí que lo fabricaba Silicon Labs y los descargué de aquí. Tras instalarlos y reiniciar, si os vais a la parte de COM del “Administrador de Dispositivos” os tiene que aparecer esto:
5. A continuación, reinicias el cacharro, abrís el Putty con la configuración que aparece en la imagen (en mi caso el COM3) y cuando el icono de red del Window$ indique que la conexión se ha establecido, le dais a Open en la aplicación:
6. Si todo lo anterior lo habéis hecho bien, y tenéis el Redboot en la Fonera (imprescindible), os encontraréis con algo así:
   
7. Lo siguiente es seguir el Manual que aparece en un fichero de la página de DD-WRT junto al firmware (fonera_flashing.txt), y desde el Redboot:
   1. Configurar la IP y la máscara de la Fonera y del servidor de ficheros TFTPD32 (mirar el manual del otro día para aprender a usarlo), que a estas alturas debería estar corriendo y compartiendo linux.bin:

   Redboot> ip_addr -h IP_DEL_ORDENADOR -l IP_DE_LA_FONERA/24

   2. Flashear la Fonera:

   RedBoot> fis init
   About to initialize [format] FLASH image system - continue (y/n)? y
   *** Initialize FLASH Image System
   ... Erase from 0xa83e0000-0xa83f0000: .
   ... Program from 0x80ff0000-0x81000000 at 0xa83e0000: .

   3. Cargar el linux.bin en la Fonera desde el TFTPD32:

   Redboot> load -r -v -b 0x80041000 linux.bin
   Using default protocol (TFTP)
   Raw file loaded 0x80041000-0x802e3fff, assumed entry at 0x80041000

   4. Flashear la Fonera con el nuevo firmware (tarda un buen rato… paciencia):

   RedBoot> fis create linux
   ... Erase from 0xa8030000-0xa82f0000: ............................................
   ... Program from 0x80041000-0x80301000 at 0xa8030000: ............................................
   ... Erase from 0xa83e0000-0xa83f0000: .
   ... Program from 0x80ff0000-0x81000000 at 0xa83e0000: .

   5. Cambiar la configuración de la Fonera para que arranque con carga de script. Meter las lineas de código que vienen tras >> y a todo lo demás ENTER. Al final pide una ‘y’ para confirmar.

   Redboot> fconfig
   enter the bootscript:
   >>fis load -l linux
   >>exec
   >>

   6. Y por último un reinicio

   Redboot> reset

Si todo a ido bien, vuestra Fonera con DD-WRT arrancará y abrirá una interfaz web en la IP que le hayáis puesto (http://192.168.1.254 o lo que sea).

¿Vale la pena todo esto? Pues digamos que a parte de que dejas de tener una red wifi de Fon (cosa que se agradece si como en mi caso nadie la usa) pasas de tener una interfaz “para tontos” con 4 botones:

A una interfaz increíble con miles de opciones y un montón de funciones nuevas:

• Modos de wifi: Access Point, Client, Client Bridge, Adhoc, WDS Station, WDS AP, Wifi Repeater
• VPN
• SSH
• Telnet
• Firewall
• Mac Address Clone
• XBOX kaid
• Hotspots (Chilispot, Wifidog, Sputnik…)
• Filtros de contenido (Cookies, Java, Proxy)
• Ad-supported Hotspot (compartes wifi y pones banners xD)
• Milkfish Sip Router
• Bloqueo de URLs
• Cron
• Wake On Lan
• BusyBox
• Connection Warning Notifier
• Estadísticas (memoria, conexiones, CPU, transferencias…)
• …

En resumen, conviertes un trasto “un poco inútil” en una navaja suiza. El próximo paso será conseguir otra salida de antena, o añadirle un lector de tarjetas, o… ¡a lo mejor trato de hacerle lo mismo a un Zyxel de Telefónica!

Hace un par de semanas mi padre se quejaba de la mala cobertura Wifi que había en una casa que tenemos en el campo que tiene dos plantas. Le propuse colocar un router Telefónica viejo que tengo en casa como segundo punto de acceso, conectado por cable de red al primero y creando una segunda red inalámbrica, pero no le convenció el tema de tener que tirar cable de red por la fachada de atrás de la casa (sacarlo por una ventana de arriba y meterlo por una ventana de abajo del otro extremo).

El estuvo mirando un sistema que convierte la instalación eléctrica en una red de cable como este, instalando tomas en algunos enchufes, pero es caro y he leído que la velocidad suele bajar y no da buenos resultados.

Yo encontré los Wifi Repeater de TP-Link y me compre en PCComponentes por 40,70€ (gastos de envío incluidos) el modelo de la foto de arriba. Tiene un montón de modos: punto de acceso, cliente, repetidor WDS, repetidor universal y puente. El que me interesaba y el que voy a explicar como configurar es el repetidor universal:

1. Configurar la IP de la tarjeta de red del ordenador como 192.168.1.X (siempre que X no sea 254) y la máscara de red a 255.255.255.0
2. Conectar el aparato por cable de red (viene uno en la caja) al ordenador
3. Abrir un navegador y poner como URL la IP del aparato, que es 192.168.1.254
4. Escribir Usuario = “admin” y Password = “admin”, que es la configuración por defecto
5. Cambiar en el menú Network: Gateway = “IP_DEL_ROUTER” (en mi caso 192.168.1.1) y Subnet Mask (sólo en el caso de que no sea la que viene por defecto, 255.255.255.0) y guardar los cambios.



6. Cambiar en Wireless Settings: Operation Mode = “Universal Repeater”, Region (en mi caso Spain), y clickar en Search, para que muestre la lista de redes Wifi disponibles. Después clickar en la que queréis repetir y comprobar que MAC of AP pasa a ser la Mac de vuestro router (BSSID), entonces guardar los cambios.



7. Cambiar en Wireless Security la configuración de seguridad de la Wifi del router principal (yo por ejemplo tengo WPA con AES) y guardar los cambios.



8. Tras unos reinicios (después de guardar cosas) veréis que en la página de Status aparece correctamente la configuración

Ahora en el salón tengo un 100% de cobertura de Wifi:

Y como además permite sustituir la antena por otra con conector SMA pues he sustituido la de 4dBi por otra de 12-14dBi que tenía por casa:

Ya os contaré que tal resultado da dentro de unos meses…

Tor (The Onion Router) es un proyecto de software libre que ofrece a los usuarios una forma de navegación anónima mediante el empleo de cadenas de proxys entre los que se cifran las transmisiones, lo que les defiende de los análisis de tráfico y oculta la IP pública de sus routers. Esto puede ser muy útil ahora que las cosas por Internet se están poniendo feas y quieren terminar con las libertades y controlarlo todo…

Esta imagen ilustra lo que ocurre entre el usuario y el servidor de destino:

El inconveniente es que al aumentar el número de saltos se disminuye la velocidad de navegación, pero es lo que cuesta conseguir ser anónimo.

Ahora pasemos a la instalación en Ubuntu:

1. Tenemos que añadir al OS los repositorios de Tor, para ello abrimos una terminal y escribimos:

echo deb http://deb.torproject.org/torproject.org $(lsb_release -cs) main | sudo tee /etc/apt/sources.list.d/torproject.list

2. Ahora toca añadir la clave de ese repositorio con lo siguiente (a mi me falló unas cuantas veces… paciencia hasta que funcione):

gpg --keyserver keys.gnupg.net --recv 886DDD89 >> gpg --export A3C4F0F979CAA22CDBA8F512EE8CBC9E886DDD89 | sudo apt-key add -

3. El siguiente paso consiste en actualizar la lista de paquetes de Aptitude tras haber añadido un repositorio nuevo:

sudo aptitude update

4. En este paso vamos a instalar Tor y Vidalia (interfaz gráfica de configuración), seleccionando durante la instalación del segundo la opción “Yes (and disable it for every boot)”, para que controle el funcionamiento de Tor:

sudo aptitude install tor tor-geoipdb
sudo aptitude install vidalia

5. Una vez hecho esto, tenemos que descargarnos el fichero de configuración de Polipo (un proxy HTTP que se instala en el paso anterior y que impide que Firefox haga peticiones DNS fuera de la red Tor) desde Git y sustituir al que se encuentra en /etc/polipo/config, reiniciando a continuación el servicio:

wget https://gitweb.torproject.org/torbrowser.git/blob_plain/a973a0bddeec5d35efbcf1defbfab5d0e8682a71:/build-scripts/config/polipo.conf
sudo cp /etc/polipo/config{,.original}
sudo mv polipo.conf /etc/polipo/config
sudo service polipo restart

6. Después de esto ya podemos arrancar Vidalia desde el menú Aplicaciones>Internet>Vidalia y comprobar que Tor funciona




7. Por último sólo tenemos que añadir a Firefox el plugin Torbutton que podemos encontrar aquí, y que permite activar y desactivar Tor desde el navegador con un botón que se encuentra en la barra inferior a la derecha. Para quedarnos tranquilos, y después de activar el Torbutton haciendo click en su icono, tenemos que ir a https://check.torproject.org/, en donde nos debe aparecer el siguiente mensaje:

Esto es todo, yo seguí un tutorial de hace medio año que se encuentra en Taringa!, pero con los meses había cambiado una cosa, y decidí escribir aquí lo que me ha funcionado y tenerlo al día.

Espero que sepáis utilizarlo y os sea útil!

Llevo tiempo usando APKtor, pero la gran cantidad de fallos de descarga que muestra la aplicación (al menos con los repositorios que uso) me ha llevado a buscar otro sistema. Hace unas semanas traté de hacer en PHP un código parecido al que utilizaba Aptoide en la parte de servidor pero que contara con un par de mejoras: una interfaz web que permitiera descargar las aplicaciones del repositorio sin tener que instalar nada en el móvil y un formulario para subir .apk directamente desde el navegador de Android.

Lo terminé, pero descubrí en mal momento que debido a un bug (o feature) no está permitido subir aplicaciones desde el navegador oficial (en cambio es posible con Opera Mobile). Como sin la mejora de la subida de ficheros desde el móvil no veía demasiado sentido a lo que estaba haciendo se me ocurrió darle un par de vueltas más, y decidí que lo mejor era buscar un sistema para que cualquiera pudiera montar un repositorio, sin necesidad de tener un alojamiento web a mano. Aquí entro en juego Dropbox, y su sistema de ficheros compartidos.

Lo que acabé haciendo fue una interfaz web (HTML + algo de CSS3 + Javascript) sencilla y un script en BASH que extrae la información de los paquetes y te genera un fichero XML con toda la información que veis en la imagen de arriba (click para ampliar). ¿Y que permite esto? Pues crear una página accesible desde Internet y que contenga una lista de aplicaciones descargables junto a su información, todo ello desde Linux y usando Dropbox. Y se llama Repodroid (Repositorio Android, original 1000%).

Intrucciones de uso:

1. Descomprimir en la carpeta pública de Dropbox que tenéis en local el contenido de ESTE .ZIP, de forma que quede así:

~/Dropbox/Public$ ls
aapt  apks  generateXML.sh  images  index.html  js  style

2. Cambiar los permisos para permitir la ejecución de aapt y generateXML.sh:

chmod +x aapt generateXML.sh

3. Instalar un par de linbrerías por medio de apt-get o aptitude (no es obligatorio, pero sin ellas no se pueden comprimir los iconos de las aplicaciones, y ocupan demasiado…

sudo aptitude install imagemagick pngnq

4. Ahora hay hay que añadir las aplicaciones que queramos compartir en el directorio apks/
5. Por último hay que ejecutar el script (tiene dos modos “-c” o con compresión y “-n” o normal), que dará una salida parecida a la de este ejemplo:

~/Dropbox/Public$ ./generateXML.sh -c
T > apks/ADW.Launcher_pre_1.3.0_themers_only.apk
T > apks/androidVNC_build20101119.apk
T > apks/anycut.apk
T > apks/ConnectBot-git-2010-12-09_02-45-59.apk
T > apks/k9-3.400-release.apk
T > apks/python_for_android_r1.apk
T > apks/RemoteDroid-v1.4.apk
T > apks/Term.apk
Enjoy your repo! ;)

6. Después de eso ya tenéis todo el sistema montado en la parte pública de Dropbox, para compartirlo sólo tenéis que acceder desde la web a la parte pública y hacer click en el siguiente enlace:
7. Con esto obtendréis un enlace del tipo “http://dl.dropbox.com/X/XXXXXXX/index.html” al que podréis acceder desde el móvil y que podréis compartir con quien queráis (una posible mejora es conseguir un dominio gratuito, más sencillo de recordar, y hacer que apunte a esa URL).

Cada vez que queráis actualizar el contenido del repositorio, sólo tenéis que repetir los pasos 4 y 5 desde el ordenador y automáticamente Dropbox se actualizará con los cambios.

Por último dejar claro que la finalidad de este sistema es la de ayudar a difundir aquellas aplicaciones desarrolladas por vosotros mismos o de software libre, en ningún caso aplicaciones piratas descargadas de internet. Del mismo modo sóis libres de modificar el código y hacer lo que queráis con él (siempre que nombréis el origen) y de sugerir modificaciones que lo puedan hacer mejor o notificar fallos.

Espero comentarios!

NOTA: esta optimizado para Android 2.x y lo he probado en Dropbox, pero vamos, que el mismo sistema se puede usar en otros discos duros en la nube (me imagino). También puedo colgar un PHP que hace lo mismo que el BASH para colgarlo en algún server.

En los repositorios de Ubuntu he encontrado unas herramientas que no están mal y que al poder ser usadas desde linea de comandos, se pueden añadir a scripts:

• El paquete imagemagic,  y el comando convert. Con este comando se puede cambiar el formato de una imagen, girarla, cambiarla de tamaño… ¡hasta aplicar efectos! Yo la he usado para redimensionarla de la siguiente manera:

convert imagen.jpg -resize 1024x640 nueva_imagen.jpg

Donde 1024×640 son las dimensiones de la imagen resultante, que se guarda en nueva_imagen.jpg

• El paquete pngnq con el comando de mismo nombre. Utiliza un algoritmo de cuantización de imágenes que permite pasar de un PNG de 32-bits de color a uno de 256 colores o menos. El tamaño que ocupa la imagen se reduce muchísimo, y el resultado suele ser bueno. He llegado a obtener buenos resultados incluso con una paleta de 32 colores. El comando se utiliza así:

pngnq imagen.png -n 32

Donde 32 es el número de colores de la paleta y el fichero resultante se llama imagen-nq8.png

• El paquete pngcrush con el comando de mismo nombre. Es un optimizador de imágenes PNG, que utiliza varios algoritmos de compresión y filtros para reducir el tamaño de los ficheros. Recomiendan su uso combinado con pngnq, y se utiliza así:

pngcrush -rem -reduce -brute imagen.png nueva_imagen.png

En este ejemplo se elimina la información adicional del fichero (-rem), se reduce el tamaño (-reduce) y se prueban por fuerza bruta 114 filtros y compresiones, eligiendo la mejor (-brute)

Con estos comandos podemos hacernos un script sencillo que modifique todas las imágenes de un directorio, con estos comando como:

#!/bin/bash
for imagen in *.png; do
    convert $imagen -resize 1000x1000 $imagen;
    pngnq $imagen -n 256;
    pngcrush -rem -reduce -brute -force ${imagen%.*}-nq8.png $imagen;
    rm -f ${imagen%.*}-nq8.png;
done;

Y para acabar, un ejemplo con un par de imágenes, la primera antes de aplicar pngnq y pngcrush como en el script anterior, y la segunda como resultado:

Si aplicamos el comando du para comprobar el tamaño en bytes:

du -b poster*
1854398	poster1.png
474083	poster2.png

Estamos pasando de 1.85MB a 474KB y conservamos las dimensiones(y aunque en la vista previa no se aprecie, las dos tienen transparencias).

Un saludo, y comentad si lo probáis!