Una de las funciones de este blog es tratar de que no se me olviden cosas que aprendo y que probablemente necesite en un futuro. Mi problema es que muy de vez en cuando (meses) la utilizo para imprimir los apuntes de la universidad, y es un derroche hacerlo en color, así que siempre que me toca busco la opción de escala de grises.

Esta que veis aquí es la pantalla inicial del menú de configuración (click encima para ampliar foto):

La lista desplegable que pone “Copias y páginas” tiene acceso a los submenús, porque en HP decidieron que las pestañas “son de pijos”. El contenido de esa lista es este:

Cualquiera con dos dedos de frente haría click en la opción de “Ajuste de color” para acceder al cambio de escala, pero si estuviera bien hecha no estaría escribiendo este post. El contenido de ese submenú es este:

Como se puede ver sólo muestra “Del fabricante” y “ColorSync” (que podemos deducir que es “de otro”), pero no hay rastro de la mierda de escala de grises. El siguiente paso para mí siempre era volverme loco y mirar en todos los demás submenús, hasta dar con esto:

¡”Tipo/calidad de papel” cuenta con un huevo de pascua en forma de menú desplegable de configuración de color!¡Son unos genios! querían sorprendernos y lo han conseguido! Dentro de este menú SI existe la llamada escala de grises:

Y ya está, espero que la próxima vez no me haga perder el tiempo, y siento haber escrito sobre esto, pero si no lo hacía reventaba. Otro día os contaré como interpreta la impresora estos símbolos:

Escribir un comentario si algún periférico os alegra la vida!

P.D.: he descubierto el Paint para Mac OS, echaba de menos un programa más tonto que el Photoshop para pintar sobre imágenes, y este es perfecto.

Esta noche he estado buscando información sobre la manera de sustituir las URLs “feas”, llenas de parámetros o con los nombres de los ficheros, por otras del estilo “/funcion/usuario/contenido/”, como la que usa Twitter con sus usuarios. He visto que para mejorar el aspecto de las URLs se puede emplear el módulo de Apache rewrite_module y la modificación del fichero .htaccess

Para empezar tenemos que crear, en caso de que no exista ya, este fichero en el mismo directorio donde se encuentre la página de inicio de nuestra página web (index.php o index.html o lo que sea).

Dentro del fichero tenemos que escribir en primer lugar la activación de la reescritura de URLs:

    RewriteEngine on

A continuación se pueden añadir condiciones. La función de estas es filtrar los casos en los que se van a emplear las reglas y siguen el esquema “RewriteCond VARIABLE VALOR”. Yo no he empleado funciones para mi .htaccess, pero algunos ejemplos comentados serían:

    RewriteCond  %{HTTP_USER_AGENT}  ^Mozilla.* //User-Agent de la peticion HTTP debe ser Mozilla, el usuario utiliza Firefox
    RewriteCond %{REMOTE_HOST}  ^hostA.* //El nombre de la maquina que hace las peticiones contiene la cadena hostA

Existen muchas más variables a las que podemos acceder desde las condiciones, como son: HTTP_REFERER, HTTP_COOKIE, REMOTE_USER, REMOTE_PORT, etc.

Además es posible concatenar condiciones empleando [AND] o [OR] si se usa más de una.
Ahora toca hablar de las reglas, que son las que llevan a cabo las modificaciones sobre las URL. Todas siguen el esquema “RewriteRule URL_TUNING URL_FEA”. El parámetro URL_TUNING acepta patrones (como los que se usaban en seed). Ahora como ejemplo voy a usar las reglas que he utilizado yo para probar el sistema:

    RewriteRule ^about about.php [L]
    RewriteRule ^([A-Za-z0-9_-]+)$ index.php?usuario=$1

En la primera de ellas la URL “http://dominio.com/about” es redirigida a la fea “http://dominio.com/about.php”. La L entre corchetes es un flag, las reglas pueden incluir uno o más separados por comas. En este caso la L significa “Last rule”, al aplicar esta regla deja de hacerlo con las siguientes, funciona como un break dentro de un switch.

La segunda regla incluye un patrón, que recorta la cadena que coincida con él y la guarda en $1, que después se le pasa al index.php como valor del nombre de usuario. El resultado nos permite que la url “http://dominio.com/Pepe” sustituya a “http://dominio.com/index.php?usuario=Pepe” (Twitter’s style).

Es posible del mismo modo definir un patrón que use más conjuntos entre paréntesis y recorte $1, $2, $3…

La página oficial del módulo, de donde he sacado la información, esta aquí.

Si os animáis a probarlo… comentario!

Estos tres señores de la foto son Rivest, Shamir y Adleman, los resposables del sistema criptográfico de clave pública RSA (que toma sus iniciales). ¿Y que tiene esto que ver con el SSH? Pues que gracias a sus sistema podemos generar un par de claves pública y privada para autenticarnos en un servidor sin necesidad de introducir el password.

Para ello, en primer lugar tenemos que tener instalado el SSH en nuestro ordenador. Si no lo tenemos, sólo hay que abrir una terminal y escribir:

    sudo aptitude install ssh

Después tendremos que ir a la carpeta oculta de SSH en nuestro home, con un:

    cd ~/.ssh

Una vez dentro de este directorio debemos generar un par de claves RSA, para lo que usaremos el comando ssh-keygen de la siguiente manera:

    ssh-keygen -t rsa

Con lo que obtendremos la salida:

    Generating public/private rsa key pair.
    Enter file in which to save the key (/home/xaman/.ssh/id_rsa):
    Enter passphrase (empty for no passphrase):
    Enter same passphrase again:
    Your identification has been saved in /home/xaman/.ssh/id_rsa.
    Your public key has been saved in /home/xaman/.ssh/id_rsa.pub.
    The key fingerprint is:
    0e:78:59:5c:c8:91:68:49:91:83:53:0b:58:09:27:6d
    The key's randomart image is:
 
    +--[ RSA 2048]----+
    |  o=+=+*.+.      |
    |    .oE.*o+.     |
    |       . o..o    |
    |          . o    |
    |       . + S     |
    |         . o     |
    |             .   |
    |                 |
    |                 |
    +-----------------+

Como podéis ver da la opción de introducir una frase para cifrar la clave privada. Es recomendable para otros usos, ya que no es nada conveniente que te roben la clave privada, porque podrán usarla para entrar directamente al servidor, pero en este caso no la vamos a introducir ya que si lo hacemos, no será necesario introducir el password del servidor pero si el de la clave privada.
Una vez que tengamos los ficheros id_rsa (clave privada) e id_rsa.pub (clave pública) deremos mover el segundo al servidor.
Os recomiendo que para esto uséis el comando scp de la siguiente forma:

    scp id_rsa.pub usuario@dominio:/ruta_del_directorio_de_destino

Una vez que tengamos la clave pública en el servidor tenemos que añadirla al fichero authorized_keys que esta en el directorio .ssh de nuestra cuenta. Si no existiera lo creamos con un:

    mkdir ~/.ssh

Y copiamos dentro la clave. Exista o no el fichero authorized_keys, debemos incluir nuestra clave pública en el, con un:

    cat id_rsa.pub >> authorized_keys

Después de esto ya no será necesario introducir el password de usuario en el servidor.
Para hacer aún más sencilla la conexión podemos añadir al fichero .bashrc (en Linux) o .bash_profile (en Mac OS) del home el siguiente alias:

    alias servidor='ssh usuario@servidor';

De esta forma podemos conectarnos a un servidor con solo escribir su nombre en la terminal.

Si a alguien no le sale, ve algo mal o tiene un sistema mejor, que escriba un comentario!

Esta tarde he recibido un email de OVH diciendo que me quedaba una semana para que mi alojamiento compartido se terminara. Como a pesar de que me queje (porque un fin de semana sin server es apocalíptico), no me han dado muchos problemas este año, he decidido renovar con ellos, cambiando mi antiguo “plan90″ (ahora ya no existe con ese nombre) por otro “profesional” que me venía mucho mejor (necesitaba una buena BD MySQL, bastante espacio y mucho tráfico mensual) y portando todo al nuevo servidor.

El caso es que la base de datos de nuestra aplicación “estrella” de Facebook es bastante inmanejable para un PHPMyAdmin, son 117 MB de backup. En una supertabla con millones de entradas teníamos un par de campos que no se usaban, y que ocupaban una burrada, no por su longitud sino por el número de instancias. Después de tratar unas cuantas veces de borrarlos por SSH, usando el comando “mysql”, y desde la interfaz web sin resultados me he puesto a buscar la mejor manera de modificar el script de backup.

Resulta que teníamos varios millones de inserciones del estilo “INSERT INTO usuario VALUES (’121900349302′, 13, 44, 27);”, donde los dos últimos número sobraban porque eran los valores de los campos que no quería usar más. El primero de los dos podía recibir un NULL, y el segundo valores negativos. Y aquí entra “sed“:

El comando sigue la estructura “sed [opciones] instrucciones [fichero]“. Si no se especifica un fichero lee de la entrada estándar (así que se le pueden pasar valores con un pipeline | ). Las instrucciones deben ir entre comillas simples, para que el comando no trate de explotar símbolos como * o $. Si son de sustitución deben empezar por s y seguir este formato: ‘s/VIEJA/NUEVA/’
Por ejemplo:

    echo "Vivo en: C/ Fuencarral" | sed 's/C\//la calle/'

Daría como resultado:

    Vivo en: la calle Fuencarral

Como podéis ver he escapado la barra / con otra barra inversa delante \. VIEJA acepta patrones (otro día hablare de ellos), y el “juego de metacaracteres extendido” (para poder usar patrones con: *, ?, +, [ - ], {,}, etc) si usamos la opción -E, por ejemplo:

    echo "Vivo en: C/ Fuencarral" | sed -E 's/[a-zA-Z]{5,10}/Gran Vía/g'

Tiene por salida:

    Vivo en: C/ Gran Vía

En el ejemplo le he dicho que sustituya todas las cadenas formadas por letras mayúsculas o minúsculas de entre 5 y 10 caracteres por “Gran Vía”, por lo que ha sustituido “Fuencarral”. He añadido además una g después de la última barra, que significa que no se pare en la primera que encuentre, que sustituya hasta el final.

Es posible también aplicar varias instrucciones seguidas separadas por punto y coma, de esta forma:

    sed 's/a/A; s/b/B' fichero_a_modificar.txt

o separándolas con la opción -e:

    sed -e 's/a/A' -e 's/b/B' fichero_a_modificar.txt

También es posible que decirle que coja las instrucciones de un fichero con la opción -f seguida del nombre:

    sed -f reglas.sed fichero_a_modificar.txt

Y evitar que muestre el resultado por pantalla con -n:

    sed  -n 's/b/B' fichero_a_modificar.txt

Mi problema con las tablas se ha solucionado con:

    sed -E 's/, (NULL|[0-9]+), -?[0-9]+\)/)/g' backup.sql > backup_limpio.sql

Que sobre un fichero que contenga:

    INSERT INTO usuario VALUES ('121900349302', 13, NULL, -27);
    INSERT INTO usuario VALUES ('121900349303', 13, 43, 37);
    INSERT INTO usuario VALUES ('121900349304', 13, NULL, -18);
    INSERT INTO usuario VALUES ('121900349305', 13, 45, 9);

Obtiene:

    INSERT INTO usuario VALUES ('121900349302', 13);
    INSERT INTO usuario VALUES ('121900349303', 13);
    INSERT INTO usuario VALUES ('121900349304', 13);
    INSERT INTO usuario VALUES ('121900349305', 13);

¡Si alguien encuentra algo interesante sobre “sed” o patrones que lo comente!

Ayer no me apetecía nada de nada estudiar, y pensé que para aprender algo nuevo, y de paso mejorar un poco “Compartir en Tuenti” era buena idea echar un ojo a cURL. Se me ocurrió que podría ser útil que el plugin para WordPress pudiera actualizar nuestros estados con enlaces a las nuevas entradas del blog de forma automática. No era algo nuevo, ya que los plugins para Twitter, a pesar de que emplean un API, lo que hacen es eso, twittear con los cambios del blog (@Tecno_Caos).

A falta de API en Tuenti sólo queda intentar eso, emplear cURL, que es una librería preparada para conectar y comunicarse con muchos tipos de servidores y muchos tipos de protocolos. Actualmente libcurl soporta los protocolos http, https, ftp, gopher, telnet, dict, file y ldap. libcurl también soporta certificados HTTPS, HTTP, POST, HTTP PUT, subida de ficheros usando FTP (también se puede hacer con la extensión FTP de PHP), formularios HTTP, proxies, cookies, y autenticaciones usuario+contraseña (copy & paste de PHP.net). El uso que yo quería darle era simple, con poder usar POST y GET me valía, así que ahora voy a explicar las funciones principales:

• curl_init(), para iniciar la sesión cURL y obtener el manejador. Opcionalmente recibe una URL como parámetro. Se usa simplemente así:

$handler = curl_init();

• curl_setopt(), es la función que más he usado, se emplea para fijar valores a parámetros de configuración. La lista de parámetros es muy amplia. Un ejemplo de su uso sería:

curl_setopt($handler, CURLOPT_POST, false); //Fijo la peticion POST a false, lo que activa la peticion GET

• curl_exec(), para ejecutar la petición con todos los parámetros de configuración que hemos fijado. Si ponemos la opción CURLOPT_RETURNTRANSFER a TRUE devuelve la salida de la ejecución en una variable en lugar de imprimirla, que es el comportamiento por defecto (funciona como un echo):

$response = curl_exec ($handler);

• curl_close(), para cerrar la sesión cURL:

curl_close($handler);

He tenido algunos problemas con las Cookies. Se supone que puede hacer que se guarden en un fichero configurando CURLOPT_COOKIEJAR y CURLOPT_COOKIEFILE, pero aunque he conseguido que las Cookies se guardaran correctamente, el Javascript de la página no hacía bien las modificaciones sobre el fichero, así que decidí hacerlas a mano modificando el valor de CURLOPT_COOKIE.

Como creo que lo mejor es que pegue aquí una clase que me he creado para iniciar sesión en Tuenti y hacer un par de cosas más, y que comente cada linea interesante…

 
 
	class Tuenti{
 
		var $handler;
		var $response;
		var $ruta_cookie;
		var $cookie;
		var $csfr;
		var $user_id;
 
		function crearCookie(){
                        ruta_cookie = "cookie.txt";
			$fp = fopen($this->ruta_cookie, "w"); //creo un fichero para almacenar las Cookies
			fclose($fp);
			chmod($this->ruta_cookie, 0777); //le cambio los permisos por si acaso...
		}
 
		function __construct(){
			$this->handler = curl_init();
			curl_setopt($this->handler, CURLOPT_COOKIESESSION, true );
			curl_setopt($this->handler, CURLINFO_HEADER_OUT, true );
			curl_setopt($this->handler, CURLOPT_COOKIEJAR, $this->ruta_cookie); //Fichero donde se guardan Cookies al cerrar conexion
			curl_setopt($this->handler, CURLOPT_COOKIEFILE, $this->ruta_cookie); //Fichero donde se almacenan las Cookies
			curl_setopt($this->handler, CURLOPT_FAILONERROR, false );
			curl_setopt($this->handler, CURLOPT_TIMEOUT, false );
			curl_setopt($this->handler, CURLOPT_AUTOREFERER, true); //Cambio de HTTP Referer automatico
			curl_setopt($this->handler, CURLOPT_FOLLOWLOCATION, true); //Sigue automaticamente las URL que devuelve la cabecera HTTP
			curl_setopt($this->handler, CURLOPT_VERBOSE, false );
			curl_setopt($this->handler, CURLOPT_USERAGENT,"Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_6_4; en-US) AppleWebKit/533.4 (KHTML, like Gecko) Chrome/5.0.375.127 Safari/533.4");  //Cambia el User-Agent, la informacion sobre el navegador usado por el cliente
			curl_setopt($this->handler, CURLOPT_HTTPHEADER, array("Accept-Language: es-ES,es;q=0.8", "Accept: application/xml,application/xhtml+xml,text/html;q=0.9,text/plain;q=0.8,image/png,*/*;q=0.5", "Proxy-Connection: keep-alive", "Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.3")); //Configuracion de la cabecera HTTP
		        curl_setopt($this->handler, CURLOPT_POST, false); //Inicialmente configurado con GET
			curl_setopt($this->handler, CURLOPT_HEADER, true); //Devuelve las cabeceras junto con la respuesta del servidor
			curl_setopt($this->handler, CURLOPT_CONNECTTIMEOUT, false);
			curl_setopt($this->handler, CURLOPT_RETURNTRANSFER, true); //Redirige la salida de curl_exec a una variable
		}	
 
		function iniciarSesionTuenti($login, $pass){
 
			$url_base = "http://www.tuenti.com/?m=login";
 
			//Primera carga de la pagina
			curl_setopt($this->handler, CURLOPT_POST, false); //Por GET
			curl_setopt($this->handler, CURLOPT_URL, $url_base); //Fijo la URL de destino
			$this->response = curl_exec ($this->handler); //Ejecuto
 
			//Mostrar el formulario de login
			curl_setopt($this->handler, CURLOPT_POST, false);
			$this->cookie = "manual_logout=deleted; ue=deleted; em=deleted; fa=deleted; et=deleted; domain=.tuenti.com; expires=Sun, 30-Aug-2020 12:11:30 GMT; path=/;";
			curl_setopt($this->handler, CURLOPT_COOKIE, $this->cookie); //Modifico la Cookie con los valores devueltos en la HTTP Header de los Set-Cookie, lo que el server receptor quiere que anadamos a la cookie
			curl_setopt($this->handler, CURLOPT_URL, $url_base); //Fijo la URL
			$this->response = curl_exec ($this->handler);	
 
			//Iniciar sesion
			$url_login = "https://www.tuenti.com/?m=Login&func=do_login";
			curl_setopt($this->handler, CURLOPT_POST, true); // Lo preparo para un POST
			curl_setopt($this->handler, CURLOPT_POSTFIELDS, "email=$login&remember=1&timezone=2&input_password=$pass"); //Cadena con las variables enviadas por POST y sus valores. Tambien puede recibir un array asociativo (clave - valor)
			$this->cookie = "ourl=deleted; manual_logout=deleted; ue=deleted; em=deleted; fa=deleted; et=deleted; domain=.tuenti.com; expires=Sun, 30-Aug-2020 12:11:30 GMT; path=/;"; //Modifico la Cookie de nuevo
			curl_setopt($this->handler, CURLOPT_COOKIE, $this->cookie);
			curl_setopt($this->handler, CURLOPT_SSL_VERIFYPEER, false); // Que no compruebe nada del SSL
			curl_setopt($this->handler, CURLOPT_SSL_VERIFYHOST, false); // Pasando de SSL
			curl_setopt($this->handler, CURLOPT_URL, $url_login); // Fijo URL
			$this->response = curl_exec ($this->handler);
			$resultados = array();
			preg_match('/sid=([a-zA-Z0-9]*);/', $this->response, $resultados); // Obtengo el valor de la sesion  (sid) de usuario del Set-Cookie que aparece en la cabecera HTTP de la respuesta, para anadirlo a la Cookie
			$sid = $resultados[1];
 
			//Entrar en el perfil";
			$url_hash = "https://www.tuenti.com/";
			curl_setopt($this->handler, CURLOPT_POST, false);
			$this->cookie = "sid=$sid; lang=es_ES; ourl=deleted; manual_logout=deleted; ue=deleted; em=deleted; fa=deleted; et=deleted; domain=.tuenti.com; expires=Sun, 30-Aug-2020 12:11:30 GMT; path=/;";
			curl_setopt($this->handler, CURLOPT_COOKIE, $this->cookie);
			curl_setopt($this->handler, CURLOPT_SSL_VERIFYPEER, false);
			curl_setopt($this->handler, CURLOPT_SSL_VERIFYHOST, false);
			curl_setopt($this->handler, CURLOPT_URL, $url_hash);
			$this->response = curl_exec ($this->handler);
 
			//Tener hash;
			$url_hash = "https://www.tuenti.com/";
			curl_setopt($this->handler, CURLOPT_POST, false);
			$this->cookie = "redirect_url=m=home&func=view_home; tempHash=m=home&func=view_home;  max-age=30; sid=$sid; lang=es_ES; ourl=deleted; manual_logout=deleted; ue=deleted; em=deleted; fa=deleted; et=deleted; domain=.tuenti.com; expires=Sun, 30-Aug-2020 12:11:30 GMT; path=/;";
			curl_setopt($this->handler, CURLOPT_COOKIE, $this->cookie);
			curl_setopt($this->handler, CURLOPT_SSL_VERIFYPEER, false);
			curl_setopt($this->handler, CURLOPT_SSL_VERIFYHOST, false);
			curl_setopt($this->handler, CURLOPT_URL, $url_hash);
			$this->response = curl_exec ($this->handler);
			$resultados = array();
			preg_match('/user_id=([0-9]*)"/', $this->response, $resultados); //Ahora busco el user_id en el HTML de la respuesta, para mandarlo con otro formulario
			$this->user_id = $resultados[1];
		}
 
		function compartirEnlace($url_post, $mensaje){
			$url_base = "http://www.tuenti.com/?m=Share&func=index&url=".urlencode($url_post); // Uso urlencode para codificar los parametros de la URL
 
			//Primera carga de la pagina
			curl_setopt($this->handler, CURLOPT_POST, false);
			curl_setopt($this->handler, CURLOPT_URL, $url_base);
			$this->cookie .=" redirect_url=deleted; lp=1;";
			curl_setopt($this->handler, CURLOPT_COOKIE, $this->cookie);
			$this->response = curl_exec ($this->handler);
			$resultados = array();
			preg_match('/CSFR: \'([a-zA-Z0-9]*)\'/', $this->response, $resultados); // Busco el CSFR en el codigo HTML de la respuesta
			$this->csfr = $resultados[1];
 
			//Envio de nuevo estado
			$url_envio = "https://wwwb21.tuenti.com/?m=Share&func=process_share_status&ajax=1&store=0&ajax_target=canvas";
			curl_setopt($this->handler, CURLOPT_POST, true);
			curl_setopt($this->handler, CURLOPT_POSTFIELDS, "url=".urlencode($url_post)."&csfr=".$this->csfr."&status_body=".urlencode($mensaje)."〈=es_ES"); // Respondo incluyendo el CSFR
			curl_setopt($this->handler, CURLOPT_COOKIE, $this->cookie);
			curl_setopt($this->handler, CURLOPT_SSL_VERIFYPEER, false);
			curl_setopt($this->handler, CURLOPT_SSL_VERIFYHOST, false);
			curl_setopt($this->handler, CURLOPT_URL, $url_envio);
			$this->response = curl_exec ($this->handler);
		}
 
		function cerrarSesion(){
			//Cerrar sesion
			$url_envio = "https://wwwb21.tuenti.com/?m=Logout&func=log_out&ajax=1&store=0&ajax_target=canvas";
			curl_setopt($this->handler, CURLOPT_POST, true);
			curl_setopt($this->handler, CURLOPT_POSTFIELDS, "user_id=".$this->user_id."&csfr=".$this->csfr); // Uso el user_id y el csfr para cerrar sesion por POST
			curl_setopt($this->handler, CURLOPT_COOKIE, $this->cookie);
			curl_setopt($this->handler, CURLOPT_SSL_VERIFYPEER, false);
			curl_setopt($this->handler, CURLOPT_SSL_VERIFYHOST, false);
			curl_setopt($this->handler, CURLOPT_URL, $url_envio);
			$this->response = curl_exec ($this->handler);
		}
 
		function salir(){
			unlink($this->ruta_cookie); // Destruyo el fichero de Cookies
			curl_close($this->handler); // Cierro la sesion de cURL
			unset($this->response); // Libero de memoria la respuesta
		}
 
	}

Con todo esto ya puedo hacer que mi plugin cambie mi estado por mi con las URLs a mis entradas nuevas, cosa que espero que haga con esta… Creo que esta noche lanzaré la versión que incluye los cambios.

Me han servido de ayuda PHP.net y dos tutoriales que encontre, este (con una clase de regalo muy práctica) y este otro (con un interesante caso práctico).

Si usáis cURL para algo y tenéis dudas (o me echáis con algo que no haya dicho/usado bien) comentario…

El launcher de Android es el programa que se arranca siempre con el móvil y que muestra los escritorios, el menu de aplicaciones en ejecución (el que aparece al dejar apretada la casa) y la lista completa de aplicaciones (la llaman drawer). Igual que HTC o Motorola han sacado launchers propios (el Sense y Motoblur respectivamente) para sus terminales, hay desarrolladores que han lanzado en el Market launchers alternativos al de Google.

De todos los que he probado (y han pasado ya 4 ó 5 por mi Nexus One) me quedo con el ADW.Launcher, y ahora voy a contaros porqué:

• Cuenta con el mismo sistema de mostrar todos los escritorios “pellizcando” la pantalla que el HTC Sense (o que Mac OS X, ya que es una copia descarada de Exposé)
• Permite mostrar/ocultar la barra de notificaciones moviendo el dedo hacia arriba en la pantalla. Cuando la ocultas queda mejor el escritorio, y es casi innecesaria teniendo un trackball que se ilumina de diferentes colores según el tipo de notificación (para esto uso Trackball Alert Pro). También puedes fijar el número de filas del escritorio, y el original a 4 desaprovecha el espacio.
• Permite utilizar el escritorio en horizontal al girar el móvil, algo útil que en la versión oficial 2.2 de Android no se puede y que la mayoría de aplicaciones lo hacen, por lo que queda un poco raro tener que estar girando el móvil cada vez que quieres ver el escritorio.
• Permite elegir el número de filas y columnas del drawer, y ocultar los nombres de todos los iconos (no son necesarios si te conoces todo lo que tienes instalado, sólo ocupan sitio). Además muestran el fondo de escritorio detrás, lo que queda bastante bien.
• Incluye un nuevo gestor de escritorios, para poder ordenar escritorios enteros, y además te permite seleccionar el número de estos que quieras.
• Permite configurar el drawer para que sea como el del iPhone o el Samsung Galaxy X, en horizontal.
• Incluye muchas otras opciones, como modificar todas las animaciones, seleccionar los accesos directos de la barra de abajo del escritorio, hacer backups de las configuraciones, aplicar temas (yo uso uno de Motorola Droid X), usar widgets con listas que se puedan deslizar con el dedo, etc.

Es una aplicación GRATUITA así que os recomiendo a todos que la probéis, mejora bastante el aspecto del Launcher original. Si os gusta podéis probar el Launcher Pro, también gratis. ¡Ya me contaréis que os parece!

Ya era hora, la verdad es antes las estadísticas dejaban mucho que desear, tardaban muchísimo en actualizar (mostraban menos de un millon de usuarios cuando en la base de datos teníamos más de millón y medio), mostraban valores absurdos (miles de usuarios activos en aplicaciones recién ”estrenadas” o que aún no eran públicas), o simplemente faltaban datos interesantes.

Antiguo sistema de estadísticas

Todo esto parece estar resuelto, si bien se siguen volviendo “un poco locas”, ahora un desarrollador tiene muchísima información sobre el número de veces que los usuarios comparten enlaces, comentan, publican fotos, etc.

Nuevo sistema de estadísticas de Facebook (el escalón es el resultado de 2 días de bloqueo de servidor por parte de OVH)

Ahora mismo tenemos una subida del número de usuarios en Google Analytics y una bajada en Facebook que no me termino de creer, porque llevaba días subiendo, como tampoco me termino de creer que las fotos compartidas de los últimos dos días tiendan a cero (aparece en la imagen que esta encima del parrafo), pero al menos la precisión a aumentado.

Datos recogidos por Google Analytics

Además, este aumento de precisión se nota mucho si lo comparas con el número de entradas de nuestra base de datos. Si antes se confundía en varios cientos de miles en el número de usuarios, ahora lo hace en menos de 60 mil.

Estado actual de la base de datos por PHPMyAdmin

Ahora sólo queda que le cambien el nombre al enlace para acceder a ellas, que pone “Ideas” xD

Hace tiempo estuve buscando con unos amigos la mejor manera de realizar consultas a una base de datos MySQL desde PHP sin sufrir demasiado con el SQL Injection. Encontré varias técnicas recomendadas:

• Crear las consultas empleando la función sprintf para convertir los parámetros a String. Un ejemplo de uso de esta función sería:

  $query = sprintf("SELECT id, name FROM products ORDER BY name LIMIT 20 OFFSET %d;" $offset);

• Usar mysql_real_escape_string para escapar caracteres  ”raros” que no deban aparecer en una consulta. Un ejemplo de su uso sería:

  $query = "select * from usuarios where name = '". mysql_real_escape_string($_POST['user'])."' and pass = '".mysql_real_escape_string($_POST['pass'])."' LIMIT 1";

• Si usamos en nuestras consultas LIKE, GRANT o REVOKE en conveniente usar la función addcslashes, para colocar barras invertidas delante de algunos caracteres y escaparlos. Se usa así:

  addcslashes($autor_nombre,'%_'));

El resultado de combinar estas tres técnicas sería una consulta como esta:

$query = sprintf("SELECT * FROM libros WHERE autor='%s';", addcslashes(mysql_real_escape_string($autor_nombre),'%_'));

Nosotros acabamos juntando esto en una función así  (sacada de PHP.net):

function secure_query($query,$params = false) {
    if ($params) {
        foreach ($params as &$v) { $v = addcslashes(mysql_real_escape_string($v),'%_'; }
        $sql_query = vsprintf( str_replace("?","'%s'",$query), $params );
        $sql_query = mysql_query($sql_query);
    } else {
        $sql_query = mysql_query($query);
    }
    return ($sql_query);
}

Para usarla hay que pasarle por parámetros una cadena con la consulta en la que se use ? en el lugar que deberían ocupar las variables y un array con los valores de estas ordenados por orden de aparición, por ejemplo…

secure_query("SELECT * FROM persona WHERE nombre = ? AND apellidos = ?;",  array($nombre, $apellidos));

Espero que le sirva a alguien, y si encontráis algún problema o algo mejor dejar un comentario!

La primera versión de este plugin nació en una hora, el tiempo que tardé en entender lo que había hecho el creador de “Add to Facebook” y reescribirlo para que mostrara el botón de Tuenti. Después de mirarme lo que había publicado con más calma he decidido reescribirlo prácticamente del todo y abandonando el plugin que tome como ejemplo, para resolver algunas chapuzas y responder a Nukeador, que escribió un comentario con una buena crítica.

He añadido unas cuantas cosas nuevas (que podéis ver haciendo click en la imagen):

• Colocación del botón sobre y bajo el texto
• Selección de lugares del botón: portada, entradas y/o páginas
• Acción al clickar el botón: abrir enlace en página nueva o en la misma
• Edición del CSS del div del botón desde el menú de configuración.

Espero que avise pronto de la actualización, y nada más, que estoy esperando comentarios sobre sugerencias/errores.

Y si cae alguna que otra estrella mejor!

Después tuve que seguir unos pasos para que lo añadieran a los repositorios:

1. Registrarme en WordPress.org
2. Comprobar que mi fichero readme.txt cumplía con el standard
3. Mandar información sobre mi plugin y un enlace a mi código a través de este cuestionario, y esperar a que el Plugin Master lo revise y de el visto bueno (la versión light del proceso de Apple para añadir aplicaciones al App Store)
4. Esperar a un email, con la información para añadir el plugin al repositorio de SVN (Subversion)
5. Crear la copia local del repositorio y hacer un commit con los ficheros de plugin:

• • mkdir   copia-repositorio-local
  • svn  co  http://svn.wp-plugins.org/mi-plugin    copia-repositorio-local/
  • cd    copia-repositorio-local/
  • cp    ../mi-plugin/*   trunk/
  • svn    add  trunk/*
  • svn   ci   -m   ‘Primera version de mi plugin’

Después de eso sólo nos queda esperar a que aparezca en el buscador de plugins del blog. De momento no he conseguido que lo encuentre buscando “Compartir en Tuenti”, pero aparece si buscas la etiqueta tuenti (como en la primera foto) o yendo directamente a la web.

Para cerrar, una captura de coña de un texto que muestran los de WordPress cuando validas el readme.txt:

Un saludo!