Utilizar Twitter en nuestra APP Android (Parte 2)

En la entrada anterior hemos visto el concepto y hemos creado el proyecto, añadiendo nuestras credenciales de twitter y modificado el Manifest para que podamos acceder a Internet  y hemos añadido una cosita que usaremos luego.

Ahora toca modificar la clase MainActivity y El layout!

Lo primero es modificar el Layout, le vamos a poner un botoncejo para que al clickarle desencadene la petición de autorización de la que hablábamos. Ponemos esto (verás que queda precioso)

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    tools:context=".MainActivity" >

    <TextView
        android:id="@+id/codigoRespuesta"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_weight="2"
        android:text="@string/codigo_respuesta" />

    <Button
        android:id="@+id/btnOAuth"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_weight="2"
        android:text="@string/btn_oAuth" />

</LinearLayout>

El resultado es esta belleza

layout de la actividad
El area de texto es para poder poner algún mensaje si es el caso… y porque un botón solo me quedaba muy pobre y no me gustaba 🙂

Pues muy bien, ahora tenemos una interfaz muy chula…. que no hace nada! Así que vamos a darle funcionalidad al botoncico. Para ello tenemos que modificar la clase MainActivity, dando funcionalidad al botón en onCreate. Ahí solamente accederemos al botón y le diremos que en su evento OnClick (por cierto, vaya sintaxis más natural ehh?) nos llame al metodo autorizarApp, que es el que de verdad va a hacer algo.
Lo pongo así separadito para ir paso a paso… Ahora, un inciso:

Para poder acceder a todo este Kilombo del oAuth, vamos a necesitar utilizar clases de las librerías que incluimos en la primera parte… son lo que llamaremos el Consumer y el Provider y con ellos accederemos por Http a twitter para presentarnos con nuestras credenciales. Por ello, declararemos unas variables y accederemos a ellas con los métodos getProvider() y getConsumer(). Si no tienen valor, estos métodos las crean… luego pongo el código

Dicho esto, veamos el método autorizarApp() que es muy cortito (atención a la linea resaltada… que ahí venía mi pesadilla con esto en Android ICS+)

protected void autorizarApp() {
	try {
		getProvider().setOAuth10a(true);
		// retrieve the request token
		new OAuthRequestTokenTask(this, getConsumer(), getProvider()).execute();
	} catch (Exception e) {
		codigoRespuesta.setText(e.getMessage());
	}
}

Aquí es donde estamos ejecutando la miga… Resulta que hasta Android 4.0 ICS, se podían hacer estas peticiones en el hilo principal de ejecución, y por eso no había problemas en los tutoriales sobre Android 2.3.x que encontraba pero ahora, para hacer estas cosas que vamos a ver, tenemos que utilizar tareas asíncronas (hilos…) para que se lleven a cabo. Si no lo hacemos así, una de las cosas que pasarán será que todo el rato el emulador nos dirá que el proveedor del servicio nos devuelve null (tremendo What The Fuck). Puedes empaparte de las tareas asíncronas aquí en el blog/curso de Salvador García Oliver, que explica todo genial.

El código de la tarea asíncrona es éste:

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

	final String TAG = getClass().getName();
	private Context context;
	private OAuthProvider provider;
	private OAuthConsumer consumer;

	/**
	 *
	 * We pass the OAuth consumer and provider.
	 *
	 * @param context
	 *            Required to be able to start the intent to launch the
	 *            browser.
	 * @param provider
	 *            The OAuthProvider object
	 * @param consumer
	 *            The OAuthConsumer object
	 */
	public OAuthRequestTokenTask(Context context, OAuthConsumer consumer,
			OAuthProvider provider) {
		this.context = context;
		this.consumer = consumer;
		this.provider = provider;
	}

	/**
	 *
	 * Retrieve the OAuth Request Token and present a browser to the user to
	 * authorize the token.
	 *
	 */
	@Override
	protected Void doInBackground(Void... params) {

		try {
			Log.i(TAG, "Retrieving request token from Google servers");
			final String url = provider.retrieveRequestToken(consumer,
					TwitterData.CALLBACK_URL);
			Log.i(TAG, "Popping a browser with the authorize URL : " + url);
			Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(url))
					.setFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP
							| Intent.FLAG_ACTIVITY_NO_HISTORY
							| Intent.FLAG_FROM_BACKGROUND);
			context.startActivity(intent);
		} catch (Exception e) {
			Log.e(TAG, "Error during OAUth retrieve request token", e);
		}

		return null;
	}

}

¿Y qué hace?

Bueno, además de un constructor para pasarle parámetros que usaremos, hay un método llamado “doInBackground” que es el que ejecuta principalmente este hilo (es decir, lo que queremos llevar a cabo). Aquí solamente obtiene la URL que tenemos que abrir en el navegador del terminal (que la da el provider) y pasársela para que se abra el navegador.

En esta linea:

final String url = provider.retrieveRequestToken(consumer,TwitterData.CALLBACK_URL);

Lo que hace es obtener la URL (que a su vez la forma porque conoce las URLs que almacenamos en la clase TwitterData y que es algo como ” https://api.twitter.com/oauth/authorize?oauth_token=mH9&#8230;..y mas “) y pasarle el CALLBACK_URL que definimos (mgl://mamor). Cuando el usuario diga si acepta o no el uso de nuestra App, Twitter hará un redireccionamiento a “mgl://mamor?loquesea=algo”

Tendremos que haber llegado a una pantalla como esta

autorizar

Para meter las credenciales de twitter y autorizar nuestra App. Aunque aún estamos lejos de conseguir algo… ya nos vamos acercando!

Todavía nos queda:

  • Detectar la vuelta con el resultado de twitter
  • Guardar lo que devuelva
  • Hacer un tuit!

Y eso va en las próximas entradas!

Aquí de momento pongo el código de los getProvider() y getConsumer()


/**
 * @return the provider (initialize on the first call)
 */
public static OAuthProvider getProvider() {
	if (httpOauthprovider == null) {
		httpOauthprovider = new DefaultOAuthProvider(
			TwitterData.REQUEST_URL, TwitterData.ACCESS_URL,
			TwitterData.AUTHORIZE_URL);
		httpOauthprovider.setOAuth10a(true);
	}
	return httpOauthprovider;
}

 

/**
 * @param context
 *            the context
 * @return the consumer (initialize on the first call)
 */
public static CommonsHttpOAuthConsumer getConsumer() {
	if (httpOauthConsumer == null) {
		httpOauthConsumer = new CommonsHttpOAuthConsumer(
			TwitterData.CONSUMER_KEY, TwitterData.CONSUMER_SECRET);
	}
	return httpOauthConsumer;
}

La explicación es muy sencilla… si no tienen valor, se lo damos mediante los constructores oportunos.

Aquí os dejo documentación de los objetos (que yo no he mirado mucho la verdad… esto es así)

CommonsHttpOAuthConsumer

OAuthConsumer

En las siguientes entradas vemos cómo detectar el retorno de twitter y cómo guardar las credenciales

🙂

Anuncios

Etiquetado:,

Un pensamiento en “Utilizar Twitter en nuestra APP Android (Parte 2)

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s

A %d blogueros les gusta esto: