Lo primero es desbloquear el fastboot. Para ello, tenemos que instalarnos el SDK de Android, descargable desde su pagina web. Viene sin una de las herramientas que necesitamos, fastboot, así que os la dejo en el pack de la descarga.
Tenemos que iniciar, antes de nada, el movil en modo fastboot, que significa hacerlo apretando el boton de subir volumen y el de encendido a la vez hasta que se encienda. Veréis que la pantalla es distinta a la habitual.
En esta pantalla se puede ver que nuestro dispositivo está bloqueado de fábrica, como se ve en la imagen (lock state: locked)
Desbloqueando el movil:
* Enchufar por cable USB al PC.
* Verificar, ejecutando “fastboot devices”, que reconoce el dispositivo. Si no sale nada, no lo ha reconocido, y puede que tengais que editar el archivo /etc/udev/rules.d/51-android.rules, añadiendole la siguiente linea:
SUBSYSTEM==”usb”, SYSFS{idVendor}==”18d1″, MODE=”0666″
En cualquier caso, después de este paso el fastboot devices debería mostrarnos una linea con un numero de serie. Eso significa que ya ha reconocido nuestro trasto, así que seguimos.
* Hacemos el unlock en si, con la siguiente orden (en el directorio donde tengamos fastboot, se entiende)

./fastboot oem unlock

Una vez desbloqueado, veremos que al reiniciar, debajo del logo de google, aparece un candado abierto. Buena señal
Ahora tenemos que copiar el paquete de “superuser”. Podemos hacerlo bien por USB como lo haríamos con cualquier archivo, o bien con la utilidad adb push /ruta/de/origen /sdcard/destino
En este caso, mis ficheros estaban en /tmp, así que:

./adb push /tmp/su-2.3.6.1-ef-signed.zip /sdcard/

Flasheamos el recovery:

./fastboot flash recovery /tmp/recovery-clockwork-5.0.2.0-crespo.img

Iniciamos el recovery en el menu de fastboot del telefono (tercera entrada, debajo de reboot), y una vez ahí, navegamos por los menús para instalar el su-2.3.6 que acabamos de dejar en el telefono.

Con esto, ya deberíamos poder arrancar el teléfono normalmente, y tendremos un hermoso nexus s rooteado, dispuesto para instalar el ROM Manager y empezar a instalar cosicas

http://redresiste.net/

En el curro hemos montado un pequeño servidor de mensajería instantánea con ejabberd. En cualquier sistema debian-based es trivial montar uno, puesto que viene por paquete y basta hacer un apt-get install. Lo que resulta más difícil, o al menos a mí me lo resultó, es que autentique a los usuarios con un método que no sea el propio (ni contra un LDAP, para eso hay un plugin maravilloso).

En nuestro caso, queríamos aprovechar los usuarios de nuestro tracker, Redmine, para que solo tuvieran acceso aquellos usuarios registrados en nuestra herramienta de incidencias. Esto forma parte de un plan más ambicioso, donde los shared rosters, de los que hablaré otro día, estuvieran configurados por diferentes proyectos y más cosas, pero en principio conseguir que el login se haga contra la base de datos de Redmine a mí me vale.

Para eso medio copié-medio adapté un script que me encontré en los foros de ejabberd, para hacer autenticación en python.
Aquí os dejo el resultado, por si a alguien le sirve de algo (prometo contestar dudas en caso de que alguien las tenga, pero anuncio que mis conocimientos de erlang son nulos )

#!/usr/bin/ruby
 
require 'rubygems'
require 'logger'
ENV["RAILS_ENV"]= "production"
require '/opt/redmine/config/environment'
 
path = "/tmp/ejabberd-rubyauth.log"
file = File.open(path, File::WRONLY | File::APPEND | File::CREAT)
file.sync = true
logger = Logger.new(file)
logger.level = Logger::DEBUG
 
def auth(username, password)
    ret = User.try_to_login(username, password)
    return true if ret
    return false
end
 
def checkuser(username)
    ret = User.find_by_login(username)
    return true if ret
    return false
end    
 
logger.info "Starting ejabberd authentication service"
 
$stdout.sync = true
$stdin.sync = true
loop do
  begin
    $stdin.eof? # wait for input
    msg = $stdin.read(2)
    logger.info "2 bytes read."
    length = msg.unpack('n').first
 
    msg = $stdin.read(length)
    cmd, *data = msg.split(":")
 
    logger.info "Received message: "+msg.to_s
    success = case cmd
    when "auth"
      auth(data[0], data[2])
    when "isuser"
      checkuser(data[0])  
    else
      false
    end
 
    bool = success ? 1 : 0
    $stdout.write [2, bool].pack("nn")
  rescue => e
        logger.info "Error authenticating "+e.to_s
  end
end

Una vez lo tenemos, cambiamos en el archivo de config de ejabberd la línea que gestiona la autenticación:

{auth_method, external}.
  {extauth_program, "/ruta/absoluta/al/script.rb"}.

Reinicio del demonio del ejabberd, y a rodar

En la configuración de apache de mod_php, por alguna razón (de seguridad, me supongo) hay una serie de líneas que se dedican a capar el uso de PHP en los directorios de usuario. Para poder usar PHP tenemos que comentarlas.

En una distribución basada en debian, el archivo es:

/etc/apache2/mods-enabled/php5.conf

Y las líneas a comentar, como bien detalla el archivo, son las siguientes:

#    <IfModule mod_userdir.c>
#        <Directory /home/*/public_html>
#            php_admin_value engine Off
#        </Directory>
#    </IfModule>

Una vez comentadas, reiniciamos el servidor y listo

Enter Redis!!

Para el que no lo sepa, Redis es simplemente un almacén clave valor en memoria. Una especie de Hashmap, si queréis. Tú almacenas cosas por clave, y luego las buscas. Suena simple, y parecido a otras cosas como memcached, pero tiene la ventaja de que es persistente a disco, y además, es supersencillo gracias a librerías como phpredis.
Ya que el problema está en el acceso a la base de datos, ¿por qué no modificar el plugin para que use Redis en lugar de SQL? Y allá que nos fuimos…
La buena noticia es que funciona, y efectivamente, el aumento de rendimiento es más que notable. La mala es que no he tenido mucho tiempo, y el código está meramente funcional. Para dejarlo bonito habría que parametrizarlo más, integrarlo en el menú del plugin para que use Redis o SQL, hacer comprobaciones… Ahora mismo se asume que todo funciona -¡y sorprendentemente lo hace!- pero es un ejemplo de código a no-seguir, puesto que está cogido con pinzas. Dejo parte del código a modo de ejemplo, para ilustrar como funciona un ranking de posts más vistos. Las preguntas a los comentarios

class RedisStorage implements PopularStorage{
//Actualiza un determinado post en todas las tablas (diaria, semanal, mensual, total)
  public function update($id){
        $general = "mostviewed:";
        $totaltable = $general . "all";
        $monthtable = $general . strftime("%Y%m");
        $daytable = $general . strftime("%Y%m%d");
        $weektable = $general . strftime("%U-%Y");
 
        $redis = new Redis();
        $redis->connect('127.0.0.1'); 
 
        //Actualizamos las cuatro tablas
        $redis->zIncrBy($daytable, 1, $id);
        $redis->zIncrBy($monthtable, 1, $id);
        $redis->zIncrBy($totaltable, 1, $id);
        $redis->zIncrBy($weektable, 1, $id);
 
        //Cerramos la conexion
        $redis->close();
  }
/*Sacamos los posts más populares*/
public function getPopular($instance){
        global $wpdb;
        $range = $instance["range"];
        $general = "mostviewed:";
        switch( $range ) {
            case 'all':
               $set = $general."all";
            break;
 
            case 'yesterday':
               $set = $general.strftime("%Y%m%d",strtotime("yesterday"));
            break;
 
            case 'daily':
                $set = $general.strftime("%Y%m%d");
            break;
 
            case 'weekly':
                $set = $general.strftime("%U-%Y");
            break;
 
            case 'monthly':
                $set = $general.strftime("%Y%m");
            break;
            default: //daily
                $set = $general.strftime("%Y%m%d");
            break;
           }
          // Miramos con redis los top posts
                $redis = new Redis();
                $redis->connect('127.0.0.1');
                $ids = $redis->zRevRangeByScore($set,"+inf", 0, array('limit'=> array(0,$instance["limit"])));
//Omitimos por simplificar la parte de preparar la consulta SQL. Nos basta saber que en el array de ids tenemos los ids de Post que tenemos que sacar de la BBDD.
                        $mostpopular = $wpdb->get_results("SELECT $wpdb->posts.ID, $wpdb->posts.post_title $fields FROM $wpdb->posts WHERE $wpdb->posts.post_status = 'publish' AND $wpdb->posts.post_password = '' $idsin $exclude");
 
        usort($mostpopular, function($a,$b) use ($ids){
                                $posA = array_pop(array_keys($ids,$a->ID));
                                $posB = array_pop(array_keys($ids,$b->ID));
                                return $posA < $posB;
                            });
        $rank = array_slice(array_reverse($mostpopular), 0, $instance['limit']);
        foreach($rank as $ppost){
           $ppost->pageviews = $this->getViews($ppost->ID);
        }
        return $rank;
  }
  public function getViews($id){
    $redis = new Redis();
    $redis->connect('127.0.0.1');
    $views =  $redis->zScore("mostviewed:all", $id);
    $redis->close();
    return $views;
  }
 
  public function deleteData($clear){
        if ($clear == 'cache') {
                _e('Success! The cache table has been cleared!', 'wordpress-popular-posts'); //No tenemos cache, asi que siempre es un exito ;)
        } else if ($clear == 'all') {
              $redis = new Redis();
              $redis->connect('127.0.0.1');
              $redis->flushDB();
              $redis->close();
              _e('Success! All data have been cleared!', 'wordpress-popular-posts');
            }    
         else {
            _e('Invalid action.', 'wordpress-popular-posts');
        }
  }
}

Como se puede ver, Redis es un sistema muy fácil de usar, y con una documentación excelente. Aquel que tenga más interés en el tema, puede dejarme un comentario o mandarme un correo. Preguntas facilitas, please, que no soy un experto ni mucho menos

Y es que por primera vez en muchos, muchos años, tengo fe. Fe en la gente. Yo, que soy un escéptico, que veo la política y las revoluciones como Sam Vimes en Ronda de noche (libro por otra parte absolutamente recomendable), estoy anonadado. Asombrado. Viendo que efectivamente las revoluciones no son algo ajeno, de otro tiempo, que sólo puedes ver en las películas.

Porque lo que se ha vivido estos días en Plaza del Sol, en Madrid, supera cualquier cosa que haya visto en 26 años. He visto a toda la gente que normalmente está apoltronada, gente que cree que la política es algo que le pasa a otra gente, salir a la calle a manifestarse porque está harta de tanto mamoneo. De no pintar nada en sus propias vidas, por culpa de cuatro imbéciles que forman parte de un sistema de castas.

-He visto a los medios entre confusos y asustados, cometiendo en un error de bulto tremendo calculando las proporciones de este movimiento en cobertura informativa. Descolocados, sin saber como reaccionar y como cubrir un caso que no se había producido en España en muchos, muchos años.
-He visto a los políticos aún más confusos. Algunos han intentado aprovechar la oportunidad y sacar ventaja de la situación, porque es lo único que saben hacer. Otros intentando minimizar la situación o hacerle oídos sordos. Alguno totalmente fuera de bolos, como César Vidal, Juan Morote, o similares, atacando abiertamente a un movimiento del que no entienden absolutamente nada, por mucho que lo crean, porque está fuera de los límites de la manera de ver el mundo de estos señores. O porque están zumbados, sin más. Pero el punto común es que se están dando cuenta de que no tienen el control, y que la vergonzosa presión sobre los miedos de comunicación no está funcionando esta vez, porque la gente está harta de mentiras y ha decidido informarse ella misma a través de las redes sociales (hasta yo he empezado a usar twitter)

El ambiente que se respira estos días en Sol es indescriptible. Es una especie de burbuja de sueños, de ilusión, de gente convencida de que realmente esto es el comienzo de otra cosa. Todo el mundo colaborando, con un buen rollo envidiable, y sin liarla. Vecinos colaborando. Empresas y bares aportando lo que pueden. ¡¡Trabajadores del circo del sol trayendo palomitas!!
El tiempo nos dirá si ha servido de algo, pero para mí, la mera existencia de un movimiento como este simboliza un cambio. Un toque de atención a la clase política. “Eh, vosotros, estamos hartos, y sabemos que la mejor forma de haceros daño es en las urnas. Empezad a vernos como iguales a los que respetar, y no como a una manada de borregos que solamente simbolizan votos”.

Creo que el vídeo habla por sí solo. Puede que no sea mayo del 68, pero no es una manifestación de cuatro antisistema (como si oponerse al sistema actual fuese algo malo)

Y a pesar de que algunos medios sensacionalistas opten por decir que no son más que cuatro hippies perroflautas, ayer fui testigo de un despliegue y una organización que deja con el culo al aire a todos los “profesionales”. En menos de un día, obviamente con la colaboración ciudadana, habían sacado un “pueblo” de la nada. Comisiones de todos los servicios básicos que se necesitaban. Comunicación, infraestructura, alimentación, información. ¡Enfermería! ¡Listas priorizadas y actualizadas en todo momento de lo que hacía falta!

Para ser “cuatro vagos y parásitos sociales”, han montado la de Dios ellos solos. Y todo voluntariamente y sin oler un duro. Simplemente por mera camaradería y solidaridad con una situación que es límite no por su gravedad a corto plazo, sino por lo prolongada. El vaso está lleno, y no le caben más gotas.

Hoy, no sé lo que durará, pero creo que otro sistema es posible. Porque en #acampadasol, por encima de todo #notenemosmiedo. Y vosotros, políticos, banqueros, y gente que vive bien gracias al hecho de pisotearnos día a día, sabed una cosa.

Deberíais empezar a tenerlo.

Este fin de semana, que he decidido darme un descanso y estar tranquilamente en casa, me he puesto a hacer un pequeño scrapper en PHPQuery para magiccards.info, de cara a hacer alguna chorriaplicación al respecto en android y sobre todo para no oxidarme.

Al lío, el caso es que en un momento se me presenta el dilema de como almacenar en un objeto una lista de opciones sí/no. El primer pensamiento es usar 4 variables booleanas, que descarto casi inmediatamente por lo inescalable. ¿Un hash quizás? ¿Un array? No me convencían, y entonces me acordé de la técnica arcana de los operadores bitwise, que utilicé para alguna receta vudú en aquellos maravillosos años de carrera. Como almacenar toda la lista en un solo entero. Pasen y vean, señores.

Lo primero, definimos constantes:

define('LEGAL_VINTAGE', 1);
define('LEGAL_LEGACY',  LEGAL_VINTAGE<<1);
define('LEGAL_EXTENDED',LEGAL_VINTAGE<<2);
define('LEGAL_STANDARD',LEGAL_VINTAGE<<3);
define('LEGAL_CLASSIC', LEGAL_VINTAGE<<4);

Al desplazar un bit cada variable, los valores serian potencias de dos: 1,2,4,8 y 16, en este caso.
Lo siguiente es construir el entero donde almacenaremos la lista de opciones

$int_legality=0;
if(preg_match("/vintage/i", $legality)) $int_legality |= LEGAL_VINTAGE;
if(preg_match("/classic/i", $legality)) $int_legality |= LEGAL_CLASSIC;
if(preg_match("/standard/i", $legality)) $int_legality |= LEGAL_STANDARD;
if(preg_match("/extended/i", $legality)) $int_legality |= LEGAL_EXTENDED;
if(preg_match("/legacy/i", $legality)) $int_legality |= LEGAL_LEGACY;

Aqui inicializamos la variable a 0, y vamos preguntando qué opciones de la lista tenemos que marcar.La función preg_match devuelve un booleano si el patron encaja con la cadena que le pasamos, aunque para el ejemplo no viene al caso
El operador |= le sonará a chino a mucha gente, pero es muy sencillo. Igual que a +=b no es más que a = a+b, a|=b no hace otra cosa que a = a|b, que es hacer un OR lógico consigo mismo y el rvalue que pasamos.
Y aquí está la magia. Como cada variable no es más que un 1 desplazado lógicamente respecto a la anterior, no se solapan, y lo que tenemos es un montón de bits actuando de interruptores para las variables que necesitemos. Un montón de booleanos metidos en un entero

¿Y como lo traducimos de nuevo cuando lo necesitemos a lenguaje humano? Pues igual de fácil, aprovechándonos de la aritmética booleana:

$str ="";
if(($this->legality & LEGAL_VINTAGE) === LEGAL_VINTAGE)   $str.="V";
if(($this->legality & LEGAL_LEGACY) === LEGAL_LEGACY)     $str.="L";
if(($this->legality & LEGAL_STANDARD) === LEGAL_STANDARD) $str.="S";
if(($this->legality & LEGAL_EXTENDED) === LEGAL_EXTENDED) $str.="X";
if(($this->legality & LEGAL_CLASSIC) === LEGAL_CLASSIC)   $str.="C";

No hacemos otra cosa que comprobar si nuestro interruptor de bit está activado, haciendo un AND del “almacén” con el que estamos buscando. Por aritmética de boole, si el bit que buscamos está a 1, no importa el estado del resto, puesto que nuestra constante es toda 0s salvo el bit que buscamos, por lo que se cumplirá la igualdad.

Espero que se haya entendido algo, porque es un truco muy chulo y que permite optimizar tanto la eficiencia como la lectura y mantenibilidad del código una vez se comprende.
¿Algún otro truco que queráis compartir? ¡A los comentarios!

Así que ayer, aprovechando que cambié la ROM por una SuperFroyo 6.6.2 -que por cierto, va como la seda, MUY recomendable-, me decidí a buscar cómo demonios cambiar el splash.
Los requisitos son los siguientes:

• Tener el SDK de Android instalado, con el driver para nuestro teléfono configurado.
• Tener en el teléfono un SPL 1.33 (yo tengo el 1.33.2004)

Para cambiarlo seguimos los siguientes pasos.

1. Enchufamos el teléfono al PC
2. Reiniciamos el teléfono en modo fastboot (apagamos y lo arrancamos pulsando atrás+power)
3. Nos saldrá algo como esto:
   
4. En nuestro PC, nos vamos al directorio tools del SDK de android y abrimos ahí una consola de texto.
5. Tecleamos “fastboot devices”. Si nos sale una entrada en la lista, el teléfono está siendo reconocido, si no, algo ha fallado
6. Buscamos una imagen que poner. Tiene que estar en un formato determinado, en este listado hay unas cuantas. Los png o JPG son la imagen tal y como queda, pero la que tenemos que usar es la que acaba en 565. Si no nos gusta ninguna, siempre podemos hacernos una. (password androidsocket)
7. Escribimos lo siguiente: fastboot flash splash /ruta/a/mi_imagen.raw565

Y listos. Reiniciamos, y si todo ha ido bien, ya podemos ver que vodafone ha desaparecido de nuestras vidas

Y una vez tenemos el servicio, hay que consumirlo desde android. No voy a explicar cómo montar el entorno de desarrollo porque ya está magníficamente explicado en otros sitios, así que supondré que está montado ya y me iré al código.

Lo primero es el manifest.xml, donde daremos los datos generales de la app.

<?xml version="1.0" encoding="UTF-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
     package="org.me.queechanenelcinedemo">
    <application>
         <activity android:name=".MainActivity"
                     android:icon="@drawable/icon"
                     android:label="¿Qué echan en el cine?">
            <intent-filter>
                <action android:name="android.intent.action.MAIN"/>
                <category android:name="android.intent.category.LAUNCHER"/>
            </intent-filter>
        </activity>
    </application>
    <uses-permission android:name="android.permission.INTERNET"></uses-permission>
</manifest>

Con este manifiesto nos limitamos a decir el nombre de la aplicación (android:label=”¿Qué echan en el cine?”), ponerle un icono que está en la carpeta res/drawable y se llama icon(.gif), el nombre del paquete Java donde está el código (org.me.queechanenelcinedemo) y el nombre de la actividad principal (el main, vaya), que es MainActivity. También añadimos, importante, que necesita permiso para conectarse a la red, puesto que si no no podríamos conectar con nuestro servidor de pasarela con la cartelera de cine.

Para modelar los cines y las pelis, hacemos un par de POJOs. No tienen ninguna ciencia, porque son código Java normal y corriente:

package org.me.androidapplication1.model;
 
import java.util.ArrayList;
import java.util.List;
 
public class Cine {
    protected List
 pelis;
    protected String nombre;
 
    public Cine(String nombre) {
        this.nombre = nombre;
        this.pelis = new ArrayList();
    }
 
    public List
 getPelis() {
        return pelis;
    }
 
    public String getNombre() {
        return nombre;
    }
 
    public void setNombre(String nombre) {
        this.nombre = nombre;
    }
    public void addPeli(Peli peli){
        this.pelis.add(peli);
    }
 
    @Override
    public String toString(){
        StringBuilder sb = new StringBuilder(nombre).append("\n");
        for(Peli p : pelis){
            sb.append(p.toString()).append("\n");
        }
        return sb.toString();
    }
}

package org.me.androidapplication1.model;
 
public class Peli {
    protected String titulo;
    protected String info;
    protected String horario;
    protected String puntuacion;
 
    public Peli(String titulo, String info, String horario, String puntuacion) {
        this.titulo = titulo;
        this.info = info;
        this.horario = horario;
        this.puntuacion = puntuacion;
    }
 
    public String getHorario() {
        return horario;
    }
 
    public void setHorario(String horario) {
        this.horario = horario;
    }
 
    public String getInfo() {
        return info;
    }
 
    public void setInfo(String info) {
        this.info = info;
    }
 
    public String getPuntuacion() {
        return puntuacion;
    }
 
    public void setPuntuacion(String puntuacion) {
        this.puntuacion = puntuacion;
    }
 
    public String getTitulo() {
        return titulo;
    }
 
    public void setTitulo(String titulo) {
        this.titulo = titulo;
    }
    @Override
    public String toString(){
        return titulo+ " " + horario;
    }
}

Y con eso, solo nos queda la clase con la actividad principal. NO es un ejemplo de buenas prácticas. No hay gestión de errores alguna, y construyo la interfaz programáticamente en vez de hacerlo mediante recursos XML, que es como debe de hacerse. Espero me perdonen por haberlo hecho así para mayor claridad del ejemplo
El código está comentado, si alguien tiene alguna duda que me deje un comentario ^^

package org.me.queechanenelcinedemo;
 
import android.app.Activity;
import android.graphics.Color;
import android.os.Bundle;
import android.widget.*;
import java.io.IOException;
import java.util.*;
import org.apache.http.*;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.util.EntityUtils;
import org.json.*;
import org.me.androidapplication1.model.*;
 
public class MainActivity extends Activity {
 
    @Override
    public void onCreate(Bundle icicle) {
        super.onCreate(icicle);
        try {
            String jsonData = retrieveData();
            List<cine> cines = parseData(jsonData);
            initInterface(cines);
        } catch (Exception e) {//Rellenar con gestión de errores, por favor! :P
        }
    }
 
    /**
     * Intentamos conectarnos al servidor de pasarela para que nos de los datos
     * en JSON.
     * @return Lista de peliculas en JSON.
     * @throws IOException Si ocurre algun problema en la conexión
     */
    public String retrieveData() throws IOException {
        String retorno = "";
        HttpClient client = new DefaultHttpClient();
        HttpGet get = new HttpGet("http://diegosuarezgarcia.net/pruebas/pelis.js");
        HttpResponse responseGet = client.execute(get);
        HttpEntity resEntityGet = responseGet.getEntity();
        if (resEntityGet != null) {
            retorno = EntityUtils.toString(resEntityGet);
        }
        return retorno;
    }
 
    /**
     * Cogemos un string en JSON que contenga la lista de cines, y la parseamos
     * de manera que devolvamos una lista con todos los objetos Cine, cada uno
     * de los cuales contendrá sus películas. La API de android para JSON es
     * francamente simple, mejor de lo que me esperaba :-)
     * @param jsonData El string serializado en JSON
     * @return La lista de cines contenida en jsonData
     * @throws JSONException Si ocurre algún error.
     */
    public List<cine> parseData(String jsonData) throws JSONException {
        JSONArray cinesJson = new JSONArray(jsonData);
        List<cine> cines = new ArrayList<cine>();
        for (int i = 0; i < cinesJson.length(); i++) {
            Cine cine = new Cine(cinesJson.getJSONObject(i).getString("nombre"));
            JSONArray pelisJson = cinesJson.getJSONObject(i).getJSONArray("pelis");
            for (int j = 0; j < pelisJson.length(); j++) {
                JSONObject p = pelisJson.getJSONObject(j);
                Peli aux = new Peli(p.getString("titulo"), p.getString("info"),
                        p.getString("horario"), null);
                cine.addPeli(aux);
            }
            cines.add(cine);
        }
        return cines;
    }
    /**
     * En este metodo inicializamos los componentes gráficos que formarán la
     * aplicación.
     * El esquema es muy sencillo: Establecemos un Layout vertical para que
     * todos los componentes se apilen unos encima de otros. Como por defecto
     * android no da scroll cuando los componentes desbordan la pantalla (no
     * entiendo muy bien por qué), incluimos un scrollview, que a su vez solo
     * puede tener un hijo, luego metemos otro Layout, que será donde esté
     * todo el contenido. El contenido no es más que un montón de etiquetas de
     * texto (TextViews), a las que le damos un formato para distinguir los
     * cines de las películas y darle una cierta apariencia de "tabla".
     * @param cines La lista de objetos cine que presentaremos.
     */
    public void initInterface(List<cine> cines) {
        LinearLayout root = new LinearLayout(this);
        root.setOrientation(LinearLayout.VERTICAL);
        ScrollView scrollPanel = new ScrollView(this);
        root.addView(scrollPanel);
        LinearLayout contenido = new LinearLayout(this);
        contenido.setOrientation(LinearLayout.VERTICAL);
        scrollPanel.addView(contenido);
        for (Cine cine : cines) {
            TextView tv = new TextView(this);
            tv.setTextColor(Color.BLUE);
            tv.setBackgroundColor(Color.GRAY);
            tv.setText(cine.getNombre());
            contenido.addView(tv);
            for (Peli peli : cine.getPelis()) {
                TextView tv2 = new TextView(this);
                tv2.setPadding(10, 0, 0, 0);
                tv2.setText(peli.toString());
                contenido.addView(tv2);
            }
        }
        this.setContentView(root);
    }
}

Y el resultado final…