Scalera tips: How NOT to change your actor’s state

Intedezting, as a newbie, I would have done it wrong

Avatar de Javier S. PaniegoScalera

A common key when working with Akka, is modifying properly our actor’s state. If we jog our memory, this framework paradigm allows us to program modeling the concurrency based on actors and message passing. From that base, we could define an actor as a computing unit that may have state and perform tasks based on messages that it will receive through its mailbox and that will be processed sequentially .

That means that, in order to avoid side effects, the actor’s state modification has to take place when processing a message. So senseful so far. However, it’s a pretty common mistake to do something similar to this:

In this case, we have no more warranty that the state change (whose only responsible of keeping it consistent and thread safe is the actor) might cause side efects given that, in the precise moment where the Future modifies the var, it’s…

Ver la entrada original 139 palabras más

Tipos dinámicos

Avatar de Javier S. PaniegoScalera

Hoy traemos un poco más de magia negra. Leyendo el otro día un poco sobre los procesos de mejora de Scala (SIPs) me encontré algo que realmente me llamó la atención: tipos dinámicos.

¿Qué son?

Los tipos dinámicos permiten definir el comportamiento de un objeto cuando se invoca un método o se intenta acceder a un miembro que no existe. Por ejemplo:

dará un fallo en tiempo de compilación. Con los tipos dinámicos podemos decir que en caso de que se invoque a un método, se llame como se llame, devuelva cierto valor.

¿Cómo funcionan?

Para poder utilizar los tipos dinámicos, es preciso importar import scala.language.dynamics y extender del trait Dynamic:

La clase (o trait) que definamos puede tener todos los atributos y métodos que queramos, pero además podemos implementar los siguientes métodos:

applyDynamic

este método se encarga de gestionar las llamadas a métodos de la instancia.
Si queremos…

Ver la entrada original 340 palabras más

Parallel MapReduce in Python in Ten Minutes

Some years old but nicely explained 😀

Añadir un metabox a varios tipos de post en WordPress

En WordPress, a veces tenemos que añadir un meta_box a TODOS los tipos de post, sean del tipo que sean… o tal vez a muchos de ellos.

He visto que mucha gente lo que hace es coger el hook «add_meta_box» y llamarlo dentro de un foreach con los tipos a los que se lo quiere añadir… lo cual yo creo que no es correcto,y que debería hacerse como sigue

<?php
function poner_mi_metabox( $tipo ) {

	$post_types = array_values( get_post_types() );
	$excluded_types = array('excluido1', 'excluido2');

	$post_types = array_diff($post_types, $excluded_types);

	if( in_array($tipo, $post_types) ){
		add_meta_box( 'mamor_meta_box', 'Título del metabox',
		'display_el_meta_box', "$tipo", 'side', 'high' );

	}

}

function display_el_meta_box(){
	echo "contenido del meta box";
        //no me pongas aqui el HTML por favor! hazte una plantillica o algo
}

add_action( 'add_meta_boxes', 'poner_mi_metabox' );
?>

Lo que hemos hecho es que cuando se lance el hook «add_meta_boxes» se llame a la funcion «poner_mi_metabox», que recibe, en cada llamada, el tipo de post que se está evaluando.

Tomamos todos los tipos de posts existentes en nuestro wordpress y le quitamos los que no nos interesen (por ejemplo, attachment sería un candidato en mi caso…), de manera que, si el tipo de post que se está evaluando es de uno de nuestros tipos aceptados, le añadimos la meta box.

Así de simple!

Y bueno, si lo que queremos es sacar solo una lista de los custom_post_types que tenemos, podemos hacerlo usando los argumentos que admite la función… tal y como está en la web de WordPress:

<?php
$args=array(
  'public'   => true,
  '_builtin' => false
);
$output = 'names'; // names or objects, note names is the default
$operator = 'and'; // 'and' or 'or'
$post_types=get_post_types($args,$output,$operator);
  foreach ($post_types  as $post_type ) {
    echo '<p>'. $post_type. '</p>';
  }
?>

Clases en Javascript: The right way

Como bien me apuntan por ahí ( y sin acusar a nadie! jajaja @o0Lillo0o), a la hora de crear clases en javascript no es bueno ni eficiente definir funciones en el propio objeto, sino que lo suyo es hacerlo en el prototype.

Aquí veremos como se ha de crear una clase en Javascript bien hecho (al menos con mi nivel :-p). Crearemos las clases como funciones.

Por ejemplo, creemos una clase Coche. Para ello definiremos que el constructor recibe el nombre del coche.

function Coche( nombre ){
	this.nombre = nombre;
}

Coche.prototype.setNombre = function (nombre){
	this.nombre = nombre;
}

Coche.prototype.getNombre = function (){
	console.log(this.nombre);
}

var c = new Coche("ford");
c.getNombre(); //ford
c.setNombre("Angel del infierno");
c.getNombre(); //adivina!

Y así para cualquier funcion de clase que necesites, se la añades al prototype….

 

Espero que esta opción sea más purista 😉

Singleton en Javascript

Toda persona que programa se ha topado alguna vez con los patrones de diseño, algo que yo creo que, cuando los aprendes (en mi caso en la Universidad se ven algunos y los aplicamos en Java) son un truño algo aburrido ya que todo sacado de contexto lo es.

Una vez que empiezas a meter el morro en el mundo de la programación y no eres no solamente el único que programa (es típico que haya grupos de 2 o 3 como máximo en España a la hora de hacer la mayoría de las prácticas) sino que la aplicación la usa mucha, mucha gente a la vez, te das cuenta de que los patrones de diseño no solamente son necesarios y útiles, sino que además… molan.

Aquí quiero ir poniendo algún que otro patroncillo y la intención es implementarlos en Javascript 🙂

Uno de los patrones más sencillos y que nos sirve para empezar, es el «Singleton». Este patrón nos sirve para tener una única instancia de una clase, de manera que cualquiera que acceda a esa clase, trabaje sobre la misma instancia.

Esto, para una clase «Usuario» no vale para nada, ya que cuando creo un usuario y lo manipulo, quiero que sea nuevo y único… pero por ejemplo para manejar un objeto de conexión a una base de datos, sí que nos interesa que se acceda a uno solo, de manera que no tengamos 40.000 conexiones abiertas con la BBDD sino solamente una.

Para eso, nos tenemos que asegurar que nadie puede instanciar objetos de la clase ( La instancia se devuelve típicamente con un «getInstance()» )

var ClaseSingleton = (function () {

  // instancia que usaran los demas
  var instance;

  function init() {

    // Singleton

    // metodos que no podran ser accedidos por
    // nadie que use la instancia

    function _metodoPrivado(){
        console.log( "No me ves" );
    }

    var _variableProvada = "Soy inalcanzable para ti";

    var _numAleatorio = Math.random();

	//Esto es lo que devuelve la funcion init(), privada dentro de
	//la clase singleton. Lo que devuelve son, en definitiva
	//las funciones que hacemos publicas

    return {

      // Cosas publicas
      metodoPublico: function () {
        console.log( "Mirameee!" );
      },

      propiedadPublica: "Soy de todos ;)",

      getNumAleatorio: function() {
        return _numAleatorio;
      }

    };

  }; //fin init()

	//esto es a lo que obtendra acceso cualquiera que instancie el singleton
	//solo le damos opcion de hacer el getInstance()
  return {

    // Nos da la instancia si existe
    // o crea una nueva si no existe
    getInstance: function () {

      if ( !instance ) {
	    //el objeto tendra los metodos y props que devuelve init en el return!!
        instance = init();
      }

      return instance;
    }

  };

})();

¿Qué está pasando?

La «clase estática» ( Para simular la clase estática, hacemos una función que se ejecuta en cuanto se define, de manera que no es un objeto instanciable en javascript mediante un «new», como sería una «clase» normal. ) «ClaseSingleton» tiene, digamos, dos partes: parte privada y la parte pública.

Para hacer una parte privada, es decir, inalcanzable desde fuera de la clase, escribirmos código dentro de la función que simula la clase con normalidad, esto es, creamos variables, funciones… lo que sea necesario, pero para que podamos controlar lo que se hace público y cómo, usaremos la sentencia «return», devolviendo un objeto javascript que contendrá lo que queramos hacer público.

Es decir, ClaseSingleton puede tener 187 funciones pero si en el return solamente devolvemos una función, esa será la única pública.

Es decir, lo público irá en el objeto del return.

Lo que se hace aquí es dar solamente acceso a aquellos que usan nuestra clase a una función llamada getInstance que devuelve la instancia o la crea en caso de no existir. Cuando la crea, lo hace a través de la función «init» (el nombre es arbitrario, podrias llamarlo de otra manera…). Al llamar a la función init() lo que hace es obtener lo que esta funcion le devuelve en su return, que es un objeto javascript que contiene funciones y variables, que son en realidad, las acciones que ofrece nuestra clase.

 

Más información y MUY buena sobre patrones de diseño en javascript aquí.

 

Clases en Javascript

En Javascript no existen las clases como las conocemos en Java o en C# o en PHP… pero se pueden simular de forma muy chula mediante una función. Para ello, tenemos que seguir esta estructura y listo


function nombreClase(){
	//atributos
	var a1 = "hola!";
	var _a2;

	//funciones
	function _f1(){};
	function f2(){ console.log("ejecuto f2"); };

	//return con la interfaz que ofrecemos
	return{
	    varPublica: a1,
	    funcionDeLaClase: f2
	}

};

Aquí no hay mucho que explicar, solamente que si instanciamos un objeto e la clase, solamente tendremos acceso a «varPublica» y «funcionDeLaClase», tal y como hemos definido…

Aquí meto unos pantallazos para que veais como se puede probar en la consola de chrome 🙂

Se puede ver que varPublica y funcionDeLaClase estan disponibles

Se puede ver que varPublica y funcionDeLaClase estan disponibles

 

ejemplo de ejecución:

acciones clase

Venga, juega un poco y define tus propias clases!

 

Twitter en tu App Android… cambios para que funcione con la nueva API 1.1

Hola!

Varias personas me avisaron de que no podían ejecutar el código que había subido a otras entradas al respecto:

Twitter en Android

No os preocupéis, ya me di cuenta por mi mismo porque me dejó de funcionar el PFC…. y además la solución es muy sencilla (como todo, a toro pasado).

El problema radica en dos cosas:

  • La API ha cambiado: Esto nos debería de dar igual, pues usamos una librería, luego con reemplazarlo por una versión más moderna de la librería, debería valernos…
  • La librería tiene cambios en su propia API: El tío cutre de Twitter4j ha actualizado la librería apra que funcione con el API nuevo pero ha incluido cambios innecesarios como eliminar clases (como la clase Tweet que ahora es Status…).

Por tanto, deberemos hacer dos cositas (no me extiendo porque puedes ver el código y salvo esto que marco, es igual que el anterior):

Cambiar la librería por la versión 3.0.3 (la más actual mientras escribo esto).

En el código, cuando hacíamos

Twitter twitter = TwitterFactory.getInstance();

Ahora deberemos utilizar el ConfigurationBuilder de Twitter4j. Yo lo que he hecho es crearme una funcioncilla que me de la instancia de twitter, que antes obtenía como está escrito en la linea anterior, de manera que me ahorro escribirlo todas las veces (para una linea no me complicaba, pero ahora son más lineas) y también me ayudará si el código vuelve a cambiar.

La función es como sigue

public static Twitter getTwitterInstance( SharedPreferences prefs ){

	String token = prefs.getString(OAuth.OAUTH_TOKEN, "");
	String secret = prefs.getString(OAuth.OAUTH_TOKEN_SECRET, "");
        ConfigurationBuilder cb = new ConfigurationBuilder();
        cb.setDebugEnabled(true);
        cb.setOAuthConsumerKey(TwitterData.CONSUMER_KEY);
        cb.setOAuthConsumerSecret(TwitterData.CONSUMER_SECRET);
        cb.setOAuthAccessToken(token);
        cb.setOAuthAccessTokenSecret(secret);

	Twitter twitter = new TwitterFactory( cb.build() ).getInstance();

    	return twitter;

}

Aqui solamente le damos los datos para Twitter de otra manera.

El código final y que me ha funcionado ahora mismo está disponible en BitBucket

puedes hacer un pull de esto

https://mamoreno@bitbucket.org/mamoreno/twittertest-para-api-1.1.git

 

Ciau!

 

Cómo crear un validador de campos de formulario con JQuery

En cualquier proyecto web lo más normal es que tengamos que validar los datos que el usuario nos introduce en los formularios. Aunque esto hay que hacerlo tanto desde el lado del servidor como del lado del cliente, este post va sobre el lado del cliente y está pensado para gente que empieza en esto. Vamos a ver cómo hacer un validador de datos con jQuery.

Aunque hay librerías que hacen esto por nosotros, no siempre queremos podemos utilizarlas por lo que sea (tu jefe no te deja… por ejemplo) y nos vemos validando los datos en cada una de las páginas utilizando un montonazo de Javascript que además siempre es parecido. Esto no solamente gasta mucho tiempo sino que el día que descubramos un error, tendremos que cambiarlos en todas las páginas.

Si hubiéramos hecho esto bien y hubiéramos tenido un fichero javascript solo para estas funciones, tal vez el esfuerzo habría sido menor… pero bueno, no siempre es así y además a veces lo que queremos es hacer algo que nos parezca «chulo» (aunque en realidad no lo sea…).

Pues bien, vamos a ver las bases para crear un validador de entrada de usuarios con jQuery. Vamos a aceptar solamente un pequeño tipo de datos/entradas que tendrás que ir ampliando poco a poco y bueno, si ves problemas en el código, es bienvenido que lo digas.

Lo que haremos es, una vez tengamos nuestro validador, pasarle un JSON con los campos que queremos validar, su tipo…y opciones que acepte nuestro validades y éste nos devolverá un objeto que indicará si hay éxito o no.

La entrada será algo como esto por cada campo:


{
	id: 		"#lugarConcierto",
	msg: 		"Pon un lugar/recinto",
	tipo: 		"text",
	mandatory: 	true
},

El id nos servirá para identificar el campo
El msg para poner un mensaje que mostrar en caso de error
El tipo nos dirá qué tipo de validación queremos llevar a cabo (de las aceptadas)
El campo «mandatory» dirá si es obligatorio que tenga valor. De esta manera, si el usuario ingresa datos, se verifican para comprobar su formato aunque el campo no sea obligatorio.

La función podría empezar algo como esto:


/**
*
* Valida campos y los reformatea si procede.
* De momento solo formatea numeros
*/
validaCampos = function( elems_array ){

	var errores = false;

	for( var i in elems_array ){
		var e = elems_array[i]
		var _id = e.id;
		var _valor = jQuery(_id).val().trim();
		var mv = e.minVal != undefined? e.minVal : 0;
		var hayMaxVal = e.maxVal != undefined? true : false;
		var mxv = e.maxVal;

	}//for
}//validador

Dentro del for iremos validando cada una de las entradas del usuario

Una de las opciones que primero vamos a implementar es la de «checkMandatory()» para comprobar que un campo que tiene que tener valor, realmente lo tiene (aunque sea incorrecto…)

Lo que vamos a hacer es definir la función dentro de la función, como una variable


var checkMandatory = function(errorValues){
	//if the value is ErrorValue is considered wrong as well
	var success=true;
	var ev_arr = errorValues != undefined? errorValues : [""];
	if( e.mandatory ){
		//si no hay nada o esta en el array de valores de error.... chasca
		if(_valor.length == 0 || jQuery.inArray(_valor, ev_arr) != -1 ){
			success=false;
			alert( e.msg );
		}
	}
	return success;
};

Le pasaremos un array con valores erróneos. Esto e spara poder decirle: Si tiene un valor que sea uno de estos que te doy, es como si no tuviera nada… Esto es muy útil para los select por ejemplo. Si no nos pasan ningún array, pues le decimos que lo que no nos gusta es la cadena vacía. Entonces, en caso de que el elemento sea obigatorio, miramos que no sea la cadena vacía. Si es así, pues marcamos que no ha habido éxito y alertamos al usuario con el mensaje.

Luego lo que haremos es verificar que el campo tiene un valor aceptado en cuanto a lo que contiene el JSON. Por ejemplo, para tipo «text», si es obligatorio, nos vale con que tenga algo… pero podríamos haberle definido un minLength, maxLength… etc.

Vamos a meter la verificación del tipo text


switch( e.tipo ){
	case 'text':
		if( !checkMandatory() ) errores=true;

		break;
}

Como se ve, es muy sencillo! solo miramos que tenga contenido o no, según diga el campo «mandatory». Con esta tónica, también nos vale para los selectores / desplegables. Lo que suelo hacer yo es, cuando creo un select en html es darle a la opción de «–seleccione–» el valor de 0 o de cadena vacía según sea el select… cada uno tiene sus manías. Pues apra eso nos viene bien el array de errores.

Si queremos validar un select, podemos hacer este JSON


{
	id: 		"#selectorDePaises",
	msg: 		"Selecciona un país para el disco",
	tipo: 		"select",
	errorVals 	:['0'],
	mandatory: 	true
}

y la evaluación en el switch podría ser esta


case 'select':
	var ev_arr = e.errorVals != undefined? e.errorVals : ['', '0'];
	if(!checkMandatory(ev_arr)) errores=true;
	break;

Nos aseguramos de que el array tenga un valor, por si acaso… aunque la función checkMandatory() ya lo haga también.

Y así nos podemos eternizar creando tipos de campos…. Por ejemplo, para comprobar que se ha introducido un entero:


{
	id: 		"#capacidad",
	msg: 		"Pon una capacidad",
	tipo: 		"int",
	mandatory: 	true,
	minVal: 	1
}

Aceptamos un minVal para indicar que nos vale un mínimo de valor… podríamos considerar maxVal por ejemplo. Para ver que es positivo, nos vale un minVal de 0 o de 1.


case 'int':
	if( !checkMandatory() ) errores=true;

	if ( isNaN(_valor) ) {
		errores = true;
		alert( e.msg + " - No es un número válido");
	}else{
		//es numero
		_valor = parseInt( _valor );
		if( _valor < mv ){
			errores = true;
			alert( e.msg + " - El valor mínimo es de " + mv);
		}
		if( hayMaxVal && _valor > mxv ){
			errores = true;
			alert( e.msg + " - El valor máximo es de " + mv);
		}

	}
	if(!errores){
		jQuery(_id).val( parseInt(_valor ) );
	}

	break;

En este caso, reasigno el valor al campo a validar. Igual, por paranoia…

Y ya para acabar el ejemplo, podemos meter un tipo «money» para validar que el usuario ha introducido una cantidad que se asemeje a una cantidad de dinero.


case 'money':
	if( !checkMandatory() ) errores=true;

	//reemplazo coma por punto, en españa ponemos coma en lugar de punto
	_valor = _valor.replace(",", ".");
	if( isNaN(_valor) ){
		errores=true;
		alert(e.msg);
	}else{
		//es un numero, le dejo a 'e.decimals' decimales. Por defecto, 2
		var d = e.decimals != undefined? e.decimals : 2;
		_valor = parseFloat(_valor);
		_valor = _valor.toFixed(d);
		if( _valor < mv ){
			alert( e.msg + " - El valor minimo es de " + mv);
			errores = true;
		}
	}
	if(!errores){
		jQuery(_id).val( parseInt(_valor ) );
	}

	break;

Después del switch, vemos si hubo errores. Si los hubo, hacemos lo que haya que hacer (en este caso, resetLoaders() lo que haría es quitar los típicos spinners que dan vueltas mientras hacemos comprobaciones, cargas…) y devolvemos si hubo éxito o no


if(errores) {
	resetLoaders();
	return {success: false };
}

y poco más, luego nos queda ejecutarlo… para ello, definiríamos lo que queremos validar y llamaríamos a la función, por ejemplo:


validaConcierto = function(){

	var elems_array =
		[
			{
				id: 		"#concerts_artist",
				msg: 		"Pon un artista",
				tipo: 		"text",
				mandatory: 	true
			},
			{
				id: 		"#concerts_place",
				msg: 		"Pon un lugar/recinto",
				tipo: 		"text",
				mandatory: 	true
			},
			{
				id: 		"#concerts_capacity",
				msg: 		"Pon una capacidad",
				tipo: 		"int",
				mandatory: 	true,
				minVal: 	1
			},
			{
				id: 		"#concerts_city",
				msg: 		"Pon una ciudad",
				tipo: 		"text",
				mandatory: 	true
			},
			{
				id: 		"#concerts_price",
				msg: 		"Ponle un precio válido. Pon 0 para GRATIS",
				tipo: 		"money",
				mandatory: 	true,
				decimals: 	3,
				minVal: 	0
			},
			{
				id: 		"#concerts_ticket_types",
				msg: 		"Pon el tipo de entradas disponibles",
				tipo: 		"text",
				mandatory: 	true
			},
			{
				id: 		"#concerts_date",
				msg: 		"La fecha no puede estar vacía, utiliza el calendario",
				tipo: 		"text",
				mandatory: 	true
			}
		];

	return validaCampos( elems_array );

}

Qué flecos quedan? Pues validar fechas, por ejemplo y a lo mejor se puede refactorizar el código un poquito para mejorarlo.
El código sería


/**
*
* Valida campos y los reformatea si procede.
* De momento solo formatea numeros
*/
validaCampos = function( elems_array ){

	var errores = false;

	for( var i in elems_array ){
		var e = elems_array[i]
		var _id = e.id;
		var _valor = jQuery(_id).val().trim();
		var mv = e.minVal != undefined? e.minVal : 0;
		var hayMaxVal = e.maxVal != undefined? true : false;
		var mxv = e.maxVal;

		var checkMandatory = function(errorValues){
			//if the value is ErrorValue is considered wrong as well
			var success=true;
			var ev_arr = errorValues != undefined? errorValues : [""];
			if( e.mandatory ){
				//si no hay nada o esta en el array de valores de error.... chasca
				if(_valor.length == 0 || jQuery.inArray(_valor, ev_arr) != -1 ){
					success=false;
					alert( e.msg );
				}
			}
			return success;
		};

		switch( e.tipo ){
			case 'text':
				if( !checkMandatory() ) errores=true;

				break;

			case 'select':
				var ev_arr = e.errorVals != undefined? e.errorVals : [""];
				if(!checkMandatory(ev_arr)) errores=true;

				break;

			case 'int':
				if( !checkMandatory() ) errores=true;

				if ( isNaN(_valor) ) {
					errores = true;
					alert( e.msg + " - No es un número válido");
				}else{
					//es numero
					_valor = parseInt( _valor );
					if( _valor < mv ){
						errores = true;
						alert( e.msg + " - El valor mínimo es de " + mv);
					}
					if( hayMaxVal && _valor > mxv ){
						errores = true;
						alert( e.msg + " - El valor máximo es de " + mv);
					}

				}
				if(!errores){
					jQuery(_id).val( parseInt(_valor ) );
				}

				break;
			case 'money':
				if( !checkMandatory() ) errores=true;

				//reemplazo coma por punto
				_valor = _valor.replace(",", ".");
				if( isNaN(_valor) ){
					errores=true;
					alert(e.msg);
				}else{
					//es un numero, le dejo a 'e.decimals' decimales
					var d = e.decimals != undefined? e.decimals : 2;
					_valor = parseFloat(_valor);
					_valor = _valor.toFixed(d);
					if( _valor < mv ){
						alert( e.msg + " - El valor minimo es de " + mv);
						errores = true;
					}
				}
				if(!errores){
					jQuery(_id).val( parseInt(_valor ) );
				}

				break;
		}
		if(errores) {
			resetLoaders();
			return {success: false };
		}
	}
	return {success: true};
}

Bájatelo de GitHub 🙂

Utilizar Twitter en nuestra APP Android (Parte 3)

Bueno, después de lo visto en los otros 2 posts anteriores, teníamos pendiente capturar el regreso de twitter con la confirmación o no del permiso de uso de nuestra App.

Parte 1

Parte 2

Aquí es donde utilizaremos el famoso protcolo «mgl://» inventado por mí, de «Miguel» 😀

Tenemos que ir a la clase MainActivity y reescribir la función «onNewIntent» como sigue (esto es un poco así porque sí)


/**
 * Called when the OAuthRequestTokenTask finishes (user has authorized the
 * request token). The callback URL will be intercepted here.
 */
@Override
public void onNewIntent(Intent intent) {
	super.onNewIntent(intent);
	final Uri uri = intent.getData();
	SharedPreferences preferencias = this.getSharedPreferences("TwitterPrefs", MODE_PRIVATE);
	if (uri != null && uri.toString().indexOf(TwitterData.CALLBACK_URL) != -1) {
		Log.i("MGL", "Retrieving Access Token. Callback received : " + uri);
		new RetrieveAccessTokenTask(this, getConsumer(), getProvider(), preferencias).execute(uri);
		finish();
	}
}

Esto hace que en cada new Intent de la Actividad (Si alguien puede arrojar luz, se lo agradezco) se mire si tiene una URI con él y si esta URI tiene la URL del CALLBACK nuestro (mgl://mamor) pues actuamos en consecuencia, llamando a otra AsyncActivity como hicimos para pedir la autorización. Este hilo lo que hará es tomar los parámetros que nos devuelve Twitter… en caso de que el usuario haya aceptado, lo que nos devuelve son las credenciales del usuario para que podamos tener permiso para actuar en Twitter bajo su nombre.

Así que creamos la clase «RetrieveAccessTokenTask» con el siguiente código:


public class RetrieveAccessTokenTask extends AsyncTask&lt;Uri, Void, Void&gt; {

	private Context context;
	private OAuthProvider provider;
	private OAuthConsumer consumer;
	private SharedPreferences prefs;

	public RetrieveAccessTokenTask(Context context, OAuthConsumer consumer,
			OAuthProvider provider, SharedPreferences prefs) {
		this.context = context;
		this.consumer = consumer;
		this.provider = provider;
		this.prefs = prefs;
	}

	/**
	 * Retrieve the oauth_verifier, and store the oauth and
	 * oauth_token_secret for future API calls.
	 */
	@Override
	protected Void doInBackground(Uri... params) {
		final Uri uri = params[0];
		final String oauth_verifier = uri
			.getQueryParameter(OAuth.OAUTH_VERIFIER);

		try {
			provider.retrieveAccessToken(consumer, oauth_verifier);

			final Editor edit = prefs.edit();
			edit.putString(OAuth.OAUTH_TOKEN, consumer.getToken());
			edit.putString(OAuth.OAUTH_TOKEN_SECRET, consumer.getTokenSecret());
			edit.commit();

			String token = prefs.getString(OAuth.OAUTH_TOKEN, ");
			String secret = prefs.getString(OAuth.OAUTH_TOKEN_SECRET, ");

			consumer.setTokenWithSecret(token, secret);
			context.startActivity(new Intent(context, MainActivity.class));

			Log.i(TAG, "OAuth - Access Token Retrieved");

		} catch (Exception e) {
			Log.e(TAG, "OAuth - Access Token Retrieval Error", e);
		}

		return null;
	}
}

Esto lo que hace es guardar en SharedPreferences las credenciales secretas del usuario. Para saber más sobre SharedPreferences, puedes leer esto del blog de sgoliver.net

Para ver si se han almacenado las credenciales podemos abrir el DDMS y en el dispositivo encontraremos el XML 🙂

Gracias a tener estos datos, podremos hacer un tuit 😉 y esto lo haremos a través de la librería Twitter4j que os dije que teníamos que incluir.

Esto es muy facilito… vamos a usar una función de esta librería, la función «updateStatus». Tened en cuenta que esto es un tutorial así rapidillo, por lo que hay muchas mejoras que tendréis que hacer o que veremos en otras entradas otro día, como por ejemplo lanzar una actividad u otra dependiendo de si el usuario ya nos aceptó en twitter… O dejar que el usuario borre sus credenciales y haga «logout» de la aplicación.

De momento nosotros vamos a hacer que la tarea asíncrona que recoge la vuelta de twitter, una vez haya terminado de hacer esto, envíe un Tuit dándome las gracias :-p

Para ello, si has leido la documentación de http://www.sgoliver.net que te dije anteriormente, sabrás que cuando la tarea asíncrona termina hace una llamada a un hook que es el método «onPostExecute»

En la clase RetrieveAccessTokenTask vamos a añadir este método

protected void onPostExecute(Boolean result) {
   if(result){
	String tuit = "Enviado desde Android siguiendo el tutorial https://mamorblog.wordpress.com/2013/04/17/utilizar-twitter-en-nuestra-app-parte-1/ gracias a @miguelsaddress";
	new MandaTuitTask(tuit, prefs).execute();
        Toast.makeText(this.context,"Acceso a twitter conseguido! Enviando el tuit",
                    Toast.LENGTH_SHORT).show();
   }else{
        Toast.makeText(this.context,"Acceso a twitter NO conseguido! ",
                    Toast.LENGTH_SHORT).show();
   }
}

Esto lo que hará es que cuando se termine de recoger el token desde twitter, automáticamente se mande este tuit. Normalmente no lo haríamos así, pero eso es para otros posts 🙂 Aquí es para aprovechar el tirón y mandar un tuit, para que se vea que después de liar todo esto para el oAuth, es realmente fácil.

Para mandar el tuit, lo haremos como se ve en la linea resaltada… Se hace en una tarea asíncrona porque hay que hacer una conexión con twitter y ya os dije que a partir de cierta versión de Android (no sé si la 3 o la 4) no se pueden hacer conexiones en el hilo principal… y si no lo hacemos así nos dará fallos y excepciones y nos hablará del Looper y de cosas horribles. Así que vamos a crear otra clase para mandar el tuit (aquí cada uno que se lo monte como más le guste… una clase asíncrona para cada petición de twitter me parece mucho, pero para esto, nos vale)

Vamos a crear esta clase

package com.mamoreno.twittertest;

import com.mamoreno.utils.TwitterUtils;
import android.content.SharedPreferences;
import android.os.AsyncTask;

public class MandaTuitTask extends AsyncTask<Void, Void, Void> {

	private String tuit;
	private SharedPreferences prefs;

	public MandaTuitTask( String tuit, SharedPreferences prefs){
		this.tuit = tuit;
		this.prefs = prefs;
	}

	@Override
	protected Void doInBackground(Void... params) {
		TwitterUtils.mandaTuit( this.tuit, this.prefs );
		return null;
	}

}

Solamente queremos que ejecute en segundo plano el envío del tuit… El envío en sí lo va a hacer otra clase con métodos estáticos llamada TwitterUtils… esto es por organizar un poco y por centralizar todo lo que podemos hacer con twitter en un solo lugar…

La clase TwitterUtils es la que realmente envía el tuit haciendo uso de Twitter4j

package com.mamoreno.utils;

import oauth.signpost.OAuth;
import twitter4j.Twitter;
import twitter4j.TwitterException;
import twitter4j.TwitterFactory;
import twitter4j.auth.AccessToken;
import android.content.SharedPreferences;
import android.util.Log;

public class TwitterUtils {

	public static void mandaTuit( String tuit, SharedPreferences prefs ){

    	AccessToken a = getAccessToken( prefs );
    	if( a!=null ){
	    	Twitter twitter = new TwitterFactory().getInstance();
	    	twitter.setOAuthConsumer(TwitterData.CONSUMER_KEY, TwitterData.CONSUMER_SECRET);
	    	twitter.setOAuthAccessToken(a);
	        try {
				twitter.updateStatus(tuit);
				Log.d("MGL", "+ twitter.getScreenName().toString()		);

			} catch (TwitterException e) {
				Log.e("MGL","TwitterExc: " + e.getMessage() 	 );
			}
    	}
	}

	private static AccessToken getAccessToken( SharedPreferences prefs ){
		String token = prefs.getString(OAuth.OAUTH_TOKEN, ");
    	String secret = prefs.getString(OAuth.OAUTH_TOKEN_SECRET, ");

    	if( secret.equals(") || token.equals(") ) return null;
    	Log.i("MGL", "TOKEN: " + token);
    	Log.i("MGL", "SECRET: " + secret);

    	return new AccessToken( token, secret );
	}

}

Para poder utilizar la librería Twitter4J, esta necesita tener un AccessToken, esto es, las credenciales del usuario, su autorización, para dárselas a twitter, y las usará CADA VEZ que interactúe con Twitter.

Para ello hacemos lo resaltado: Obtenemos una instancia de «Twitter», le damos el consumer_key y el consumer_secret de nuestra aplicación y el AccessToken del usuario (que tomamos de lo que guardamos en SharedPreferences) y le decimos que mande un mensaje.

Y ya está! Así de simple!! (más de lo que parece una vez que le das una vueltecilla al proceso :D)

Ahora ejecuta la app… dale al botoncito que te llevará a twitter, confirma el acceso y a la vuelta, cuando vuelvas a ver la interfaz del botoncito corre a mirar tu twitter! a ver si te ha salido bien!

Quedaría pendiente:

  • A la vuelta de la confirmación, lanzar otra actividad con una interfaz diferente para mandar tuits o hacer lo que sea que haga nuestra aplicación…
  • Que al arrancar nuestra aplicación, identifique si ya hay credenciales guardadas y nos lleve a esa interfaz que comento.
  • Poder hacer «LogOut» es decir, borrar las credenciales de la app para que no pueda hablar en nuestro nombre o que la use otro usuario diferente.
  • Y por supuesto, gestión de errores, como por ejemplo: qué hacer si no se puede enviar el tuit o si el usuario no nos permite el acceso… habrá que poner algo en la interfaz, aunque sea un mensajito Toast, no? 🙂

Bájate el código desde GitHub AQUI!

 

Edit 26-julio-2013

OJO ha habido cambios en el API de twitter… averigua como hacer que te funcione esto!

Aqui

Crea tu propio sitio web gratis en WordPress.com.Crear tu propio sitio web.
Empezar gratis