Os recomiendo que veáis la siguiente charla sobre el tema. Os hará pensar, y no os quitará mucho tiempo.

Espero vuestras opiniones.

Hoy en día es casi imprescindible el uso de Internet o de bases de datos alojadas en la red por parte de nuestas aplicaciones Android. Uno de los métodos más fáciles y comunes para realizar una comunicación hacia dichos servicios y bases de datos se realiza mediante el consumo de servicios web, los cuales en la mayoría de los casos actuan como una capa intermedia entre nuestra aplicación e Internet.Hoy explicaremos como enlazar nuestra aplicación con nuestros servicios web.

Nota:Si no sabeis como crear un servicio web bajo .NET os recomiendo que echeis un ojo a éste artículo en el que explico como crearlo.

Obtención e importación de la librería ksoap2

Lo primero de todo es descargar la librería que nos permitirá la conexión hacia el servicio web. Se trata de ksoap2 y desde aquí podemos descargar el .jar .Una vez descargado y creado un proyecto Android en Eclipse, en la carpeta /res del proyecto crearemos una carpeta llamada lib en la que guardaremos el .jar (para saber siempre donde buscarlo a la hora de añadirlo a nuestro proyecto).

Ahora procederemos a añadirlo como librería a nuestro proyecto. Suponiendo que utilizamos Eclipse, hacemos click derecho sobre el proyecto y vamos a Propiedades, en la sección Java Build Path nos movemos hasta la pestaña Libraries, damos a Add JARs y procedemos a seleccionar el jar descargado (Lo acabamos de poner dentro de la carpeta lib del proyecto).

Una vez que ya tenemos nuestro librería añadida estamos listos para usarla. Para ello deberemos importarla añadiendo esto a la lista de import de la clase que vaya a hacer uso de la librería:

import org.ksoap2.SoapEnvelope;
import org.ksoap2.serialization.PropertyInfo;
import org.ksoap2.serialization.SoapObject;
import org.ksoap2.serialization.SoapSerializationEnvelope;
import org.ksoap2.transport.HttpTransportSE;

Importada la librería vamos a ver como se utiliza. Los pasos para realizar una conexión son por regla general los siguientes:

• Preparación de los datos necesarios para la conexión del servicio web (dirección del servicio web, nombre del método).
• Preparación de los datos a enviar al servicio web (en el caso que hubiera).
• Apertura de la conexión con los datos necesarios.
• LLamada al método y obtención de los datos provenientes del servicio werb (en el caso que hubiera).
• Tratamiento de dichos datos devueltos.

Nota: el último punto aunque no parezca importante si que hay que indicarlo para explicar mas tarde el procesamiento de datos complejos provenientes del servicio web.

Preparación de los datos para la conexión

Para llamar al servicio web necesitaremos cuantro cadenas de texto (String) que usaremos siempre para realizar las llamadas a los métidos del servicio web.

El primero es el denominado “namespace” cuyo valor nos indica el propio servicio web al crearlo. El namespace viene indicado en la cabecera del servicio web:

[WebService(Namespace = "http://ip:puerto/NombreDelServicio/")]

Por lo que la cadena que define el namespace sería:

private static String NAMESPACE = "http://ip:puerto/NombreDelServicio/";

El segundo es la URL del servicio web, que viene a ser la adición del nombre del archivo .asmx a la cadena que define el NAMESPACE:

private static String URL = NAMESPACE+"Service1.asmx";

El tercer dato que necesitamos es el nombre de método que guardaremos en la variable METHOD:

private static String METHOD;

El cuaro dato será el SOAPACTION, que será una combinación del NAMESPACE y del método al que llamemos:

private static String SOAPACTION = null;

Apertura de la conexión y adición de los datos

Definidos los datos iniciales veamos la preparación de datos en caso de que queramos enviar datos al servicio web.Para ello haremos uso de la clase SoapObject, que es un tipo de datos de encapsulación para poder enviar y recibir datos del servicio web (actua como un parseador de xml que es lo que se acaba enviando o recibiendo de un servicio web), y de la clase PropertyInfo que es una clase que nos permite añadir información al objeto SoapObject. Veamos un ejemplo.

METHOD = "method";
SoapObject request = new SoapObject(NAMESPACE, METHOD);
PropertyInfo pi1 = new PropertyInfo();
pi1.setName("variable1");
pi1.setValue(“a”);
request.addProperty(pi1);

Hay que tener mucho cuidado al añadir las variables, ya que el nombre de éstas debe coincidir con el nombre de las varibles del método al que llamamos en el servicio web. Como se ve lo que hacemos es crear un objeto PropertyInfo al que añadiremos el nombre y el valor de la variable que deseamos enviar.

Una vez que tenemos los datos a enviar, pasaremos a abrir la conexión. Para ello utilizaremos la clase SoapSerializationEnvelope y la clase HttpTransportSE:

SoapSerializationEnvelope envelope = new SoapSerializationEnvelope(
SoapEnvelope.VER12);
envelope.dotNet = true; //indicamos que utilizaremos servicios .NET
envelope.setOutputSoapObject(request); //añadimos a la conexión el objeto SoapObject anteriormente creado
HttpTransportSE androidHttpTransport = new HttpTransportSE(URL);
androidHttpTransport.debug = true; //nos aseguramos así de que funcione siempre

LLamada al método y obtención de los datos provenientes del servicio web

Ya que tenemos abierta la conexión no queda mas que definir la variable SOAPACTION y realizar la llamada.

SOAPACTION = NAMESPACE + METHOD;
try {
	androidHttpTransport.call(SOAPACTION, envelope);
	SoapObject response = envelope.getResponse();
	//tratamiento de la respuesta
} catch (Exception e) {
	Log.d("error", e.getMessage().toString());
	return null;
}

De ésta manera llamamos al método del servicio web. Si el metodo del servicio web devuelve algún dato tendremos que tratarlo. En el caso de que nos encontremos con algún tipo complejo de datos (como una lista o de alguna clase que hayamos creado para tal propósito) deberemos tratarlo para recuperar la información. Para ello utilizaremos la clase SoapObject que encapsula los datos recibidos sean cual sean su naturaleza y nos proporciona una serie de métidos para poder extraer la información tal y como se devolvió desde el servicio web.

Tratamiento de datos complejos provenientes de un servicio web

Pongamos que el método del servicio web al que llamamos devuelve un List, el tratamiento de datos sería algo así:

SOAPACTION = NAMESPACE + METHOD;
List l = new ArrayList();
try {
	androidHttpTransport.call(SOAPACTION, envelope);
	SoapObject response = envelope.getResponse();
	//tratamiento de la respuesta
	if (response != null) {//comprobamos que la respuesta no esté vacía
                //recorremos el objeto
		for (int i = 0; i < response.getPropertyCount(); i++) {
                           //obtenemos el elemento i de la lista (sabemos que es un String)
                           l.add(response.getProperty(i).toString());
                           Log.d("elmento"+i+"devuelto",response.getProperty(i).toString());
		}
		return l;
	} else {
		return null;
	}
} catch (Exception e) {
	Log.d("error", e.getMessage().toString());
	return null;
}

Explicaré mejor el código de arriba. La variable response del tipo SoapObject obtiene el List que se devolvío por parte del servicio web y mediante un bucle utilizando la variable getPropertyCount() que nos devuelve el número de elementos que posee, recorremos el objeto como si recorrieramos el List. Cada elemento obtenido mediante el bucle es del tipo SoapObject, al cual simplemente haremos un toString() ya que sabemos que es un String. Hay que tener mucho cuidado a la hora del procesamiento de los datos devueltos ya que hay que estar totalmente seguro de que tipo de datos devuelve el método invocado.

Si los datos fueran mas complejo aún (imaginemos un List<List>) deberíamos extraer cada SoapObject del objeto devuelto por parte del servicio web (que a su vez sería un List) para, mediante otro bucle anidado, recorrer la segunda lista obteniendo ya si los valores de las cadenas de texto que contienet. Sería algo así:

if (response != null) {//comprobamos que la respuesta no esté vacía
        //recorremos el objeto
	for (int i = 0; i < response.getPropertyCount(); i++) {
        //obtenemos el elemento i del List< List< String > >;
        SoapObject element = response.getProperty(i);
       /*recorremos el List< String > i */
        for(int j=0;j< element.getPropertyCount();j++){
	        String a = element.getProperty(i).toString();
	        //tratamos la cadena a
	}
}

Y con esto daríamos por concluída la lección sobre conexiones a servicios web .NET en Android usando ksoap2. Éstas conexiones nos vendrán muy bien por ejemplo para acceder a datos que están alojados en bases de datos en la red o simplemente para realizar operaciones fuera del alcance de nuestro dispositivo.

External port: 5228 Internal port: 5228 Protocol: TCP/UDP

Por si a alguien le interesa conocer los puertos de otras aplicaciones, lo encontré en esta página web que puede que os resulte de interés.

La solución es muy sencilla, y es similar a cómo se hace en Firefox. Debemos instalar el paquete mozplugger y configurarlo para utilizar el gran Evince desde Chromium. Para instalar mozplugger en Debian y derivados, ya sabéis:

sudo apt-get install mozplugger

Y una vez instalado, abrimos el archivo /etc/mozpluggerrc y comentamos la línea siguiente (añadiéndole un # delante):

define(ACROREAD, [repeat swallow(acroread) fill :
acroread -openInNewWindow /a "$fragment" "$file"])

Seguidamente añadimos lo siguiente (todo en una sola línea):

define(ACROREAD, [repeat swallow(evince) fill needs_xembed :
evince "$file"])

Y listo! Guardad los cambios, cerrad Chromium y volvedlo a abrir. Podreis disfrutar de PDFs en la web, tanto incrustados como a partir de la URL completa.

(Visto aquí)

Unos tendrán muchas espectativas sobre Chrome OS; otros, sin embargo, pensarán que este nuevo sistema operativo no es más que un navegador Chrome con esteroides. Yo no daré una opinión hasta que lo pruebe, pero aún quedan unos meses para eso. Lo que sí debemos tener en mente es que Chrome OS no está enfocado al mismo tipo de usuario al que apuntan Windows, Mac OS X, GNU/Linux, etc. Chrome OS está pensado para la vida en la nube y el acceso rápido a internet, y no para tareas como el desarrollo de software o el diseño gráfico.

De momento, podeis ver el vídeo de presentación de Chrome OS:

(Visto aquí)

Hay una demo para ver el lector adaptado a un navegador común. Lo he probado, y el aspecto es el siguiente:

Como puede verse, este lector online cuenta con los controles típicos para la lectura de eBooks (como ajustes el tamaño de letra, un índice desplegable, etc). Cabe destacar, además, la existencia de una barra de scroll con la que puedes desplazarte por todas las páginas del eBook.

Para terminar, podeis ver un vídeo demostrativo (en inglés) a continuación:

(Visto aquí)

• Pantalla Super AMOLED de 4” (resolución de 480×800 píxeles).
• Procesador 1GHz Cortex A8
• Memoria flash de 16 HB iNAND
• Cámara de 5 megapixels
• Cámara frontal VGA
• Cancelación de ruido
• Batería de Litio de 1500 mAH (6.7h en conversación 3G, y 14h en 2G; de 17 a 30 días en reposo –habría que verlo–).
• Sensor de proximidad, sensor de luz, giroscopio de 3 ejes…
• NFC (lo que supone un gran paso para esta tecnología)
• Android 2.3

Podeis ver todos los detalles aquí.

¿A quién no le gustaría hacerse con uno?. Si eres uno de los afortunados que va a poder conseguirlo tendrás que esperar unos días, ya que aún no está a la venta. Tampoco se sabe el precio oficial, así que todavía habrá que esperar unos días.

ACTUALIZACIÓN: Parece ser que estará a la venta a partir del 16 de Diciembre. Ya queda poquito.

• Mejoras generales en la interfaz de usuario, para mejorar la velocidad y simplicidad.
• Se ha mejorado la introducción de texto, para hacerla más rápida e intuitiva (con texto predictivo, mejoras en el copy/paste, etc).
• Se ha mejorado el administrador de energía, para ver mejor en qué se gasta la batería.
• Se ha introducido el soporte a llamadas a través de internet.
• La aplicación de cámara de fotos ahora soporta múltiples cámaras físicas.
• Se ha introducido un gestor de descargas.

En cuanto a prestaciones enfocadas al desarrollo, cabe destacar el nuevo recolector de basura de Dalvik VM (que mejora el rendimiento en juegos), la mejora de gestión de eventos de sensores, la inclusión de nuevos drivers de vídeo (que ofrecen mejor rendimiento en gráficos 3D), etc.

Podeis ver todos los cambios aquí.

Esta actualización me pone los dientes largos, ahora que mi HTC Legend acaba de recibir a Android 2.2. ¿Llegará algún día la actualización de Android 2.3 para los móviles que están luchando ahora por hacerse con Froyo?. Pues tengo mis dudas de que oficialmente HTC, Vodafone y demás compañías se lo curren para que así sea (el negocio es el negocio, y hacerlo no les compensa demasiado); sin embargo, siempre estarán ahí presentes las ROMS libres para instalarlas nosotros mismos en nuestros terminales. Quién sabe, quizá algún día me anime.

Widevine es un servicio que ofrece, como anuncian en su web, TV Everywhere. Pero no se quedan ahí, centrados principalmente en el streaming, se realiza de forma adaptativa, utilizando un ancho de banda dinámico; todo realizado mediante conexiones cifradas.

En el artículo en el que anuncian la adquisición de Phonetic Arts empiezan hablando de la comunicación que tenía la tripulación de las naves de Star Trek con sus ordenadores. Comentan que no lo hacían a través de un teclado. Y parece que el teclado no es una buena forma de comunicarte con tu dispositivo, ¿por qué no usar únicamente tu voz y tu oído?.

Google sigue creciendo…

(Visto aquí)

Parte 1: La guerra de los navegadores

Parte 2: Las búsquedas

Parte 3: eBay y Amazon

Parte 4: Poder social

(Visto aquí)