Expansión de objetos con variables y métodos privados

Continuando con el apasionante mundo de la creación de objetos en javascript y después de haber aprendido a usar los getters y los setters, me he puesto a definir objetos y quería que todos ellos tuvieran la función de vincularse unos con otros.

Al hacer esto me he visto repitiendo una y otra vez el mismo código para realizar esa vinculación, lo cual no es buen sintoma. Así que me he parado a pensar cómo podría hacer para crear un objeto genérico con esas propiedades para que los demás objetos, por así decirlo, hereden esas propiedades.

Me he puesto manos a la obra y lo primero que he hecho ha sido crear la definición de ese objeto genérico que va a contener, de momento, solo la funcionalidad de vincular.


var Objeto = function() {
    var self = this;

    self._binds = {};

    self.clase = {
      bind: function(v, o, f) {
        self._binds[v] || (self._binds[v] = []);
        self._binds[v].push({
          obj: o,
          func: f
        });
      }
    };

    self._bind = function() {
      self._binds['value'] && self._binds['value'].forEach(function(e) {
        e.func.apply(e.obj, [self.clase]);
      });
    };
  };

Después de tener el objeto genérico y sabiendo que no voy a instanciar ningún objeto real con él, sino que lo voy a usar para crear otro objeto el cual sí será la clase que usaré para instanciar los demás objetos, me he puesto a buscar información sobre constructores, prototipos y demás.

Al cabo de un buen rato he dado con una solución válida para mi problema, ya que yo quiero mantener ciertas variables y ciertos métodos privados; y con la información que había obtenido de mi búsqueda siempre tenía todas las variables a la disposición de la instancia que creaba.

La solución es la siguiente:

var miObjeto = function() {
    var self = this,
        _value = 0;

    // Cogemos las propiedades genéricas

    Objeto.apply(this);

    // Definimos los getters y los setters

    self.clase.__defineGetter__('value', function() {
      return _value;
    });
    self.clase.__defineSetter__('value', function(v) {
      _value = v;
      self._bind(); // Llamamos a la función de vinculación
    });

    return self.clase; // Devolvemos únicamente la clase
  }

Como los constructores en javascript son funciones y todas las funciones tienen el método call, lo que se me ha ocurrido es llamar a la función/constructor Objeto sobre miObjeto, con lo que se consigue que se definan dentro de miObjeto todas las propiedades y métodos que estaban presentes en Objeto.

Luego utilizo la otra manera de definir getters y setters, que tienen javascript, para definir las demás propiedades de miObjeto y por último devuelvo el objeto clase que contiene los métodos públicos que deseo que tenga la instancia que utilice dicha clase.

El uso de estas nuevas clases es igual que en el artículo anterior, con la diferencia de que si ahora creo, por ejemplo, un miObjeto2, no tengo que volver a implementar la funcionalidad de vincular ya que la puedo heredar de Objeto.

var miObjeto2 = function() {
    var self = this,
        _enable = 0;

    // Cogemos las propiedades genéricas

    Objeto.apply(this);

    // Definimos los getters y los setters

    self.clase.__defineGetter__('enable', function() {
      return _enable;
    });
    self.clase.__defineSetter__('enable', function(e) {
      _enable = e;
      self._bind(); // Llamamos a la función de vinculación
    });

    return self.clase; // Devolvemos únicamente la clase
  }
  var miObjetoReal = new miObjeto();
  var miObjetoReal2 = new miObjeto2();
  miObjetoReal.bind('value', miObjetoReal2, function(e) {
    (e.value != '') && (this.enable = 1) || (this.enable = 0);
  });

También a estos objetos se les podría añadir la vinculación con un elemento DOM, como en el artículo anterior, y tendríamos unos objetos con los que trabajar sin preocuparnos de las actualizaciones de la interfaz.

Referencias

http://www.webdeveloper.com/forum/showthread.php?t=243971
http://www.3site.eu/doc/
http://stackoverflow.com/questions/6039676/copying-javascript-getters-setters-to-another-prototype-object

Getters, Setters y vinculación de objetos

Recientemente he estado leyendo algunos artículos de javascript en los que se explicaban las bondades de los getters y los setters y cómo podemos utilizarlos para darles más funcionalidad a nuestras clases.

Un Ejemplo sencillo sería el siguiente:

  var MiClase = function() {
    var _value = 0;
    var clase = {
      get value() {
         return _value;
      },
      set value(v) {
         _value = v;
      },
    };
    return clase;
  };

Lo definido arriba es equivalente a esto:

  var MiClase = function() {
    this.value = 0;
  };

Pero claro, ¿para qué hacer algo más complicado si no se obtiene ningún beneficio?, la respuesta está en que al ser los getters y los setters funciones, podemos añadir más acciones dentro de estas a parte de las de devolución y asignación de variables.

Uno de los usos que se le puede dar es vincular un objeto que creemos a través de la clase con un objeto DOM, como por ejemplo una caja de texto:

  var MiClase = function(t) {
    var _value = 0,
        _obj = document.getElementBy(t);

    var clase = {
      get value() {
         return _value;
      },
      set value(v) {
         _value = v;
         _obj.value = v;
      },
    };

    _obj.addEventListener('blur', function() {
      clase.value = this.value;
    }, false);

    return clase;
  };

  var miObjeto = new MiClase('micaja');

Con el código de arriba conseguimos vincular el objeto miObjeto con la caja de texto de identificador micaja, de manera que siempre que introduzcas algo en la caja de texto se actualizará la propiedad value del objeto miObjeto y viceversa.

Podemos complicar un poco más la definición de la clase para añadir vinculación entre objetos, es decir, yo quiero vincular dos objetos a través de una propiedad de uno de ellos, de manera que cuando actualice la propiedad en el objeto origen en el objeto destino se realicen una serie de acciones. Para todo esto, la clase quedaría de la siguiente manera:

var MiClase = function(t) {
    var _value = 0,
        _obj = document.getElementBy(t),
        _binds = {};

    var clase = {
      get value() {
         return _value;
      },
      set value(v) {
         _value = v;
         _obj.value = v;
         var self = this;
         _binds['value'] && _binds['value'].forEach(function(e) {
           e.func.apply(e.obj, [self]);
         });
      },
      bind: function(v, o, f) {
        _binds[v] || (_binds[v] = []);
        _binds[v].push({
          obj: o,
          func: f
        });
      }
    };

    _obj.addEventListener('blur', function() {
      clase.value = this.value;
    }, false);

    return clase;
  };

Lo que hemos hecho ha sido añadir un objecto que contiene un array de vinculaciones, _binds, y una función bind que nos permite asociar objetos. También hemos añadido en el setter la ejecución de las funciones de vinculación que pueda tener el objeto pasando como parametro el propio objeto para que puedan interactuar con él.

Ahora el código para realizar las vinculaciones:

  var miObjeto1 = new MiClase('caja1');
  var miObjeto2 = new MiClase('caja2');

  miObjeto1.bind('value', miObjeto2, function(e) {
    this.value = e.value + '(copia)';
  });

Con el código de arriba lo que hemos hecho ha sido vincular las cajas de texto caja1 y caja2 con los objetos miObjeto1 y miObjeto2 respectivamente y después hemos vinculados los dos objetos entre sí por medio de la propiedad value de miObjeto1 de manera que cuando ésta cambie se llamará a la función de vinculación. En este ejemplo sencillo, cada vez que se cambia la propiedad value de miObjeto1 se le asigna a la propiedad value de miObjeto2 el mismo valor más el texto “(copia)”.

Dentro de la función de vinculación, this hace referencia al objeto destino, en nuestro ejemplo, miObjeto2 y el parámetro e hace referencia al objeto origen, en el ejemplo, miObjeto1.

Referencias
JavaScript getters and setters: varying approaches
Javascript getters and setters for dummies?
Working with objects

Copia de un array en Javascript

En casi todos los desarrollos es común el uso del tipo array para almacenar elementos. Muchas veces queremos guardar una copia de una array por si lo necesitamos restaurar de nuevo a su estado inicial. En tal caso haríamos algo similar a esto:

var a = [1, 2];
var b = a;

Ahora si modificamos un elemento de a:

a[0] = 3;

Podremos restaurar de nuevo nuestro array que teníamos en b, ¿No?

a = b;

La respuesta es NO, ya que si vemos el contenido de b comprobaremos que el elemento 0 también se ha modificado. Lo que ha sucedido con la asignación entre dos variables, una de las cuales es de tipo array, es que hemos creado un puntero al mismo objeto y por tanto no hemos guardado un array con los valores iniciales.

Para conseguir nuestro objetivo tendremos que recurrir a un pequeño truco que crea un nuevo array:

var b = [].concat(a);

El código de arriba lo que hace es crear un nuevo array que es el resultado de concatenar a un array vacío el array a. De esta manera, modificando los valores del array a conseguimos que los valores del array b queden inalterados.

querySelector / querySelectorAll

Estamos tan acostumbrados a los frameworks tipo jQuery que se nos olvida que también existe una forma dentro de javascript para realizar una búsqueda de elementos dentro del DOM mediante un selector. La manera de hacerlo es mediante los métodos querySelector y querySelectorAll.

La forma de usarlos es igual que con jQuery:

document.querySelector('#mi_id')
document.querySelector('.mi_classe')

La diferencia entre querySelector y querySelectorAll es que el primero nos devuelve el primer elemento que cumple el selector y el segundo nos devuelve una lista de nodos.

¿Para que nos puede ser útil esto? Por ejemplo, para realizar ciertos selectors en un proyecto sin tener que cargar jQuery o cuando no nos es posible cargar jQuery porque lo que estamos modificando es de una tercera persona.

Otro uso un poco más rebuscado sería el que le he dado yo hoy: Estaba trabajando con una BBDD desde phpMyAdmin y quería seleccionar todas las tablas que empezarán por ps_ y claro estamos hablando de más de 100 tablas y hacerlo a mano es un poco rollo.

Así que para facilitar mi trabajo, he abierto la consola del Chrome y que tecleado el siguiente código:

for (var i=0, lista = window.frames[1].document.querySelectorAll('input[value*=ps_]'), limite = lista.length; i < limite; i += 1) { lista[i].setAttribute('checked', 'checked');}

Con esto consigo que se me seleccionen todos los checkbox y puedo borrarlos todos de una.

Prevenir el bloqueo de la UI

Con el auge de las llamadas asíncronas a través de peticiones AJAX me he acostumbrado a que todas las operaciones con javascript no bloqueen la interfaz gráfica de usuario y que cuando los datos estén listos ésta se actualice sin que el usuario se vea perjudicado por la obtención y procesado de los datos.

Pero claro, ¿qué pasa si los datos ya los tenemos cacheados y tenemos que procesarlos? Lo que ocurre por lo general es que se nos bloquea la interfaz de usuario y mientras se procesan el navegador o el dispositivo móvil se queda sin responder.

Una solución sencilla a este problema es provocar una llamada asincrona de la función que procesa los datos. Para ello podemos utilizar la función de setTimeout de javascript de la siguiente manera:

setTimeout(function() {
    procesadoDeDatos();
}, 100);

Con esto conseguimos que la ejecución de la función procesadoDeDatos se haga de manera asincrona y no se bloquee la interfaz esperan a que acabe el procesado.

Así podemos poner el típico mensaje de procesando, para que el usuario sepa que se está procesando su petición y éste a su vez si quiere puede seguir interactuando con la interfaz mientras espera que se le devuelvan los datos.

Cache de imágenes

Sigo con el desarrollo de mi aplicación para iPad y el siguiente muro con el que me he topado ha sido el tema de cachear las imágenes. Mi aplicación accede a muchas imágenes que están en Internet y por tanto el consumo de ancho de banda es considerable. Lo que quería es que una vez que se accediera a la imagen, está se almacenara en cache y no se tuviera que volver a pedir.

Después de mucha investigación y muchas pruebas, he dado con dos soluciones: una para cuando el número de imágenes a almacenar no es muy grande (este no es mi caso) y otra que de momento promete guardar todas la imágenes que quiera.

LocalStorage, Web DB SQL y Canvas

La primera solución consiste en utilizar una combinación de localStorage y Web DB SQL para almacenar las imágenes y Canvas para obtener la versión base64 de la misma.

Lo primero que necesitamos por tanto es una función a la que le pasamos una URL de una imagen y nos devuelve una representación en base64 de la misma:

function getImgBase64(imagen, callback) {
    var img = document.createElement('img'),
        canvas = document.createElement('canvas'),
        ctx = canvas.getContext('2d');
    img.src = imagen;
    
    img.addEventListener('load', function() {
        canvas.width = this.width;
        canvas.height = this.height;
        ctx.drawImage(this, 0, 0);
        callback(canvas.toDataURL('image'));
    }, false);
}

Ahora que tenemos la representación de la imagen en base64 necesitamos almacenarla de manera persistente, para ello tenemos localStorage y Web DB SQL. Toca enfrentarse a los límites de tamaño, localStorage permite almacenar 5M y Web DB SQL permite 50M que los puedes repartir en unos 10 BBDD de 5M sin tener que preguntar al usuario si quiere permitir crear una BBDD de tamaño mayor. Cuando estos límites se alcanzan se deja de guardar información.

Si tenemos claro que las imágenes que queremos guardar van a ocupar menos de 5M usaremos localStorage, si es mayor que 5M e inferior a 50M usaremos una combinación de ambas, para minimizar el acceso al Web DB SQL ya que a parte de ser asincrono tiene un retardo, menor que si accediéramos a Internet, pero un retardo que puede quitar fluidez a la aplicación.

La función que almacena en el localStorage sería la siguiente:

function setImg(ref, img) {
    getImgBase64(img, function(base64) {
        var imagenes = localStorage.imagenes && JSON.parse(localStorage.imagenes) || [];
        imagenes[ref] = base64;   
        localStorage.imagenes = JSON.stringify(imagenes);
    });
}

Para obtener la imagen del localStorage:

function getImg(ref) {
     var imagenes = localStorage.imagenes && JSON.parse(localStorage.imagenes) || [];
     return imagenes[ref] || '';
}

La función completa que se encarga de hacer una pre-carga de las imágenes quedaría de la siguiente manera:

function preLoadImg(ref, img) {
   var imagen = new Image(),
       data = getImg(ref);
   
   imagen.addEventListener('load', function() {
        // Acciones una vez que tenemos cargada la imagen.
   }, false);

   if (data === '') {
      imagen.src = img;
      setImg(ref, img);
   } 
   else {
      imagen.src = data; 
   }
}

Para la versión mixta entre localStorage y Web DB SQL, lo que vamos a hacer es almacenar las referencias y estado en localStorage y la imagen codificada en base64 en el Web DB SQL.

Primero vamos a definir qué es lo que guardamos en el localStorage: las referencias a las imágenes que tenemos guardas en Web DB SQL y el número y el tamaño que llevamos en la BBDD actual.

Al empezar, las referencias serán un array vacío y el número y el tamaño serán 0.

Para inicializar la variables y crear la BBDD haremos una función de inicialización:


var DB = [];

function init() {
    var referencias = localStorage.referencias && JSON.parse(localStorage.referencias) || [],
        actual = localStorage.actual && JSON.parse(localStorage.actual) || {n: 0, t:0},
        DBI;
    
    for (var i = 0; i <= actual.n; i+=1) {
         DBI = openDatabase('Imagenes_' + i, '1.0', 'Imagenes ' + i, 4.9 * 1024 * 1024);
         DBI.transaction(function(t) {
                t.executeSql('CREATE TABLE IF NOT EXISTS Imagenes(ref TEXT NOT NULL, img TEXT NOT NULL, PRIMARY KEY(ref))', []);
            });

         DB.push(DBI);
    }
    
}

En la función de inicialización, la primera vez que se inicia se crea la BBDD Imagenes_0 y las demás veces se abren las BBDD que llevemos usadas hasta el momento.

La función que guarda una imagen en BBDD es algo más complicada que su versión únicamente con localStorage ya que tenemos que tener en cuenta el tamaño que llevamos en la BBDD actual y la creación de una nueva BBDD en caso de que sea necesario.

Como podemos ver defino una variable global DB donde voy a ir almacenando las conexiones a las distintas BBDD.

function setImgDB(ref, img) {
    getImgBase64(img, function(base64) {
        var actual = localStorage.actual && JSON.parse(localStorage.actual) || {n: 0; t: 0},
            referencias = localStorage.referencias && JSON.parse(localStorage.referencias) || [];
        
        if (actual.t >= 1810000) {
            
            actual.n += 1;
            actual.t = base64.length;
            
            referencias[ref] = actual.n;

            localStorage.actual = JSON.stringify(actual);
            localStorage.referencias = JSON.stringify(refrencias);
            
            DBI = openDatabase('Imagenes_' + actual.n , '1.0', 'Imagenes ' + actual.n, 4.9 * 1024 * 1024);
            DBI.transaction(function(t) {
                    t.executeSql('CREATE TABLE IF NOT EXISTS Imagenes(ref TEXT NOT NULL, img TEXT NOT NULL, PRIMARY KEY(ref))', [], function(t, r) {
                            t.executeSql('REPLACE INTO Imagenes(ref, img) VALUES(?, ?)', [ref, base64], function(t, r) {
                                console.log('Insertamos la imagen: ' + ref + ' en BBDD ' + actual.n);
                            });
                    });
                });

            DB.push(DBI); 
        }
        else {
            
            actual.t += base64.length;
            
            referencias[ref] = actual.n;

            localStorage.actual = JSON.stringify(actual);
            localStorage.referencias = JSON.stringify(refrencias);
     
            DB[actual.n].transaction(function(t) {
                    t.executeSql('REPLACE INTO Imagenes(ref, img) VALUES(?, ?)', [ref, base64], function(t, r) {
                        console.log('Insertamos la imagen: ' + ref + ' en BBDD ' + actual.n);
                    });
                });

        }
    });
}

El número 1810000 es el tamaño máximo aproximado de imágenes que se pueden almacenar, es un tamaño totalmente empirico y que se podría afinar un poco más.

Ahora necesitamos la función para obtener una imagen de la BBDD:

function getImgDB(ref, callback) {
     var referencias = localStorage.referencias && JSON.parse(localStorage.referencias) || [],
         n = referencias[ref] || -1;
     
     if (n !== -1) {
         DB[n].transaction(function(t) {
                    t.executeSql('SELECT img FROM Imagenes WHERE ref = ?', [ref], function(t, r) {
                        if (r.rows.length > 0) {
                            callback(r.rows.item(0).img);
                        }
                        else {
                           callback('');
                        }
                    });
                });
     }
     else {
         callback('');
     }
}

Y ahora la función de pre-carga de imágenes:

function preLoadImg(ref, img) {
   var imagen = new Image();
   
   getImgDB(ref, function(data) {
       if (data === '') {
           imagen.src = img;
           setImgDB(ref, img);
       } 
       else {
          imagen.src = data; 
       }
    });
   
   imagen.addEventListener('load', function() {
        // Acciones una vez que tenemos cargada la imagen.
   }, false);
}

Como he dicho antes, estás dos soluciones son para un número pequeño y controlado de imágenes.

En el siguiente apartado veremos cómo hacerlo cuando no sabemos el número de imágenes a cachear.

API de Phonegap

En está solución necesitamos acceder al dispositivo, por lo tanto necesitamos una API que nos proporcione acceso al mismo, en este caso yo he escogido Phonegap. A parte de la API de Phonegap, necesitamos un Plugin que nos permite descargar ficheros a nuestro dispositivo.

No voy a meterme en cómo se instala el Phonegap ni el plugin, voy a suponer que ya está todo hecho y vamos directamente al código.

Primero una función de inicialización, necesaria para usar las API's de Phonegap


var fileSystem = {};

function init() {
    document.addEventListener("deviceready", function() {
        window.requestFileSystem(LocalFileSystem.PERSISTENT, 0, function(fs) {
            fileSystem = fs;
        },
        function() {
            console.log('Error de inicialización');
        });
    }, false);
}

Ahora la función para almacenar una imagen en el dispositivo:

function setImgFile(ref, img) {
    var ext = img.split('.')[3],
        fullPath = fileSystem.root.fullPath + '/',
        prev = 'file://' + fullPath + ref + '.' + ext,
        image = new Image();

   image.addEventListener('error', function() {
       var downloader = new Downloader();

        downloader.downloadFile(
            img,
            fullPath,
            ref + '.' + ext,
            function(file) {
                console.log(file);
            },
            function() {
                console.log('Error al subir la imagen');
        });
   }, false);

   image.src = prev;
}

Para la función anterior, suponemos que la imagen está ya en nuestro dispositivo, y por tanto le asignamos el path que suponemos que tiene, en caso de error es cuando nos la bajamos al dispositivo, con esto hacemos que sea más rápida la búsqueda de una imagen y no tenemos que acceder al sistema de archivos que es mucho más lento.

Con esta solución no nos hace falta una función para obtener la imagen ya que las imagenes se guardan en el dispositivo en una ubicación conocida, por tanto vamos con la función de pre-carga de imagenes que usará el mismo principio de suponer que la imagen ya está en nuestro dispositivo antes de pedirla a Internet.

function preLoadImg(ref, img) {
    var ext = img.split('.')[3],
        fullPath = fileSystem.root.fullPath + '/',
        prev = 'file://' + fullPath + ref + '.' + ext,
        image = new Image();
    
    image.addEventListener('load', function() {
        // Acciones una vez que tenemos cargada la imagen.
    }, false);

   image.addEventListener('error', function() {
       this.src = img;
   }, false);
  
   image.src = prev;
}

Conclusión

Está claro que cuanto menos ancho de banda consuma una aplicación y cuanto más rápida sea en mostrar el contenido al usuario, éste se va a sentir más satisfecho y valorará mejor nuestra aplicación, por tanto debemos de ser cautos a la hora de cachear de manera que no se vea afectado el rendimiento de la aplicación por el acceso y la actualización de la misma.

Quiero destacar que las dos primeras soluciones son perfectamente válidas para una aplicación WEB, la segunda al depender del dispositivo solo servirá para dispositivos móviles, en este caso iPad y iPhone.

Referencias

http://stackoverflow.com/questions/934012/get-image-data-in-javascript
http://docs.phonegap.com/en/1.2.0/phonegap_file_file.md.html#File
https://github.com/aflx/pg_downloader_plugin_ios

Zepto vs jQuery

Estoy inmerso en el desarrollo de una aplicación web para iPad, como el tema de los recursos que se consumen es muy importante en este dispositivo, estoy intentando optimizar al máximo y por tanto decidí utilizar una framework de javascript ligero: Zepto.

Al principio todo iba de maravilla, el framework apenas pesa 5K y te ofrece la mayor parte de la funcionalidad de jQuery, framework al que estoy acostumbrado a usar.

Al terminar la primera iteración del desarrollo me pongo a hacer pruebas de rendimiento y compruebo que tarda muchísimo en hacer una llamada AJAX para obtener un JSON con datos para pintar la interfaz.

Al principio pienso que es mi código y que necesita más optimizaciones, reduzco al máximo el código y aún así veo un retraso de unos 7 u 8 segundos en el proceso de la petición.

Tengo que decir que antes de decantarme por Zepto hice una primera versión usando jQuery y el problema lo tenía en el renderizado de la interfaz y no en la llamada AJAX. Así que vuelvo a poner jQuery como framework de la aplicación y como la sintaxis entre ambos frameworks es compatible, veo que sí es cierto que realiza más acciones, que probablemente podré optimizar más adelante, lo que es la llamada AJAX se hace de manera fluida y sin el retardo de 7 segundos.

Analizado el código de ambos frameworks veo que en Zepto se hace un eval cuando el resultado es de una llamada AJAX es un JSON y por tanto es ahí donde se pierde el tiempo y hace que la aplicación se quede momentaneamente congelada.

La moraleja de esta historia es que aunque un framework pese poco y esté especificamente diseñado para un tipo de navegadores, en este caso Webkit, no tiene por qué ser más eficiente a la hora de realizar ciertas acciones y por tanto a la hora de elegirlo habrá que ver que tipo de llamadas hay que hacer y si nos merece la pena usarlo o no.

En defensa de Zepto puedo decir que está en fase beta y que me imagino que irán mejorando con el tiempo, pero por ahora, para una aplicación como la mía que requiere de procesado de JSON en las llamadas AJAX no es válida y tendré que seguir usando jQuery aunque sea más pesada y no sea especifica para Webkit.

Admob y SL4A

Durante un tiempo he estado desarrollando una app para Android usando SL4A y Python. Una vez desarrollada quería probar el tema de meter publicidad a la misma usando Admob.

Con SL4A uso HTML como interfaz gráfica de la aplicación y por tanto tengo que usar javascript para meter la publicidad, como si de una aplicación web se tratase.

El banner se muestra correctamente y lo puedo colocar donde quiera, el problema viene a la hora de pinchar en la publicidad, ya que al ser un webview me abre la publicidad en la propia ventana de la aplicación perdiendo toda la interfaz de la misma y quedandome sin acceso a ella.

Después de varías pruebas y un poco de ingeniería inversa sobre el javascript de Admob he descubierto la solución para que la publicidad se abra en una ventana del navegador y no en la interfaz de mi aplicación.

Primero configuramos Admob para lanzarlo nosotros de manera manual:

var admob_vars = {
 pubid: '2121324214214', // publisher id
 bgcolor: '000000', // background color (hex)
 text: 'FFFFFF', // font-color (hex)
 manual_mode: true,
 test: false// test mode, set to false to receive live ads
};

Después pedimos la publicidad:

var ad = _admob.fetchAd(document.getElementById('admob_ad'));

Y por último redefinimos la función gotourl:

_admob.gotourl = function() {
    var droid = new Android();
    droid.view(arguments[0]);
};

Con el código anterior conseguimos que la acción por defecto a la hora de pinchar en el banner sea la de abrir la URL con el navegador y no la de cargar la URL en la página actual, que en nuestro caso es la interfaz gráfica.

2008

Al igual que Badcrc, voy a hacer una listas de las cosas que he hecho en 2008, fijo que se me olvida alguna:

  • Comprarme casa
  • Montar una wiiparty en mi nueva casa
  • Primera Gipuzkoa Encounter
  • Tercera Euskal Encounter
  • Leer 11 libros
  • Correr en una carrera de 11,8 Km
  • Ver como mi macmini G4 se rompía y comprar un macmini Intel
  • Hacer algo más de deporte gracias a mi Wiifit.
  • Mi primer Ipod 
  • Comprar dos HD externos más
  • No salir de Bilbao ni en vacaciones
  • Aumentar el número de salidas “extralaborales” con gente del curro.
  • Recibir regalos para mi casa
  • Seguir yendo todos los lunes al cine
  • Reducir gastos de donde podía.

Meme: Don’t worry be happy

Seguimos con los memes, cómo no, viene de badcrc y las 6 cosas que me hacen feliz son las siguientes:

  1. Que alguien te pida ayuda y consigas ayudarle
  2. Ir al cine todas las semanas
  3. Tumbarme y ver un capítulo de una buena serie
  4. Leer un libro que me inspire
  5. Tener una buena idea
  6. Correr cuando estoy en forma y no me canso
Joe, no sabía yo que había tantas cosas que me hacían feliz :-p