Posteriormente vamos a hacer el cache de imagenes para guardar unas en memoria.

El detalle es el siguiente:

1. Al mostrar un tweet, vamos a verificar que la imagen del usuario que emitió el tweet, exista en el almacenamiento local.
2. Si no existe, se toma el URL y se baja al SDCard.
3. Una vez con la ruta local, hay que actualizar la interfaz para que muestre el avatar.

Además, se va a guardar la información del usaurio y del tweet en una base de datos local.

Esta asignación requiere que muestren en una acitividad los tweets del timeline de un usuario. El reto es que puedan mostrar esa información, solicitando los datos a un servicio web (el API de twitter). Vamos a utilizar las librerias Twitter4J y SignPost. La idea es que apliquen su conocimiento para poder autenticarse y luego poder solicitar a Twitter los tweets mas recientes. La aplicación debe mostrar los datos de manera eficiente y sin que se pegue.

Que ocupan:

• Asistir a la tutoria. Esta semana repasamos mas a detalle los componentes visuales, asi como la parte de diseño. Además voy explicarles como implmentar correctamente un ListView con su respectivo Adapter y hablarles sobre el patron de ViewHolder.
• Ya adelanté parte del trabajo. En el siguiente branch, pueden encontrar la implementación del ListView que vimos en la tutoria y además ya está la parte la autenticación de twitter que es medio truculenta. La siguiente semana la voy a explicar para que todos lo tengan claro. Eso sí me gustaría motivarlos a que lo intenten implementar ustedes mismos y si se quedan pegados en algo usar la implementación como referencia.

Referencias:

1. Branch en Github de la implementación parcial de la asignación. https://github.com/fr4gus/OAMMBLO/tree/feature/asignacion_cuatro
2. El ejemplo que yo utilicé para implementar la autenticación con Twitter.
3. Android Designs: http://developer.android.com/design/index.html
4. Android UI Patterns: http://www.androiduipatterns.com/
5. Android Patterns: http://www.androidpatterns.com/

Modificar SplashActivity para que se vea por 1 segundo y luego se muestra la pantalla de LoginActivity. Es necesario que “cierren” SplashScreen para que no quede en la pila.

Crear la actividad LoginActivity cuyo layout va a constar de un “formulario” para ingresar a la aplicación. El fondo debe ser blanco. El texto que indica al usuario que ingrese sus datos debe ser de color negro, en “negrita” y al menos 18sp (screen points) de tamaño. En vez de poner “labels” o “etiquetas” para cada uno de los campos de edición, basta con que utilicen la propiedad “hint” he indique para qué es cada campo. Un hint para “username” y otro hint para el campo “password”.

En LoginActivity, deben buscar el id del botón y definir un View.OnClickListener para que al hacer click, el botó llame a la actividad DashboardActivity. El layou para ésta actividad debe ser similar a la siguiente:

Ustedes pueden definir un layout a su gusto, pero debe tener al menos las opciones de:

1. Tweets (Ver timeline)
2. Lists
3. Mentions
4. Retweets
5. Crear nuevo tweet (A la par de la etiqueta OAMMBLO)

Recuerde:

• Definir todos los textos en string.xml y usarlos en los layout.
• Crear los “assets” para mdpi y hpdi al menos.

Referencias:

1. http://www.androiduipatterns.com/p/android-ui-pattern-collection.html
2. http://developer.android.com/design/index.html
3. http://www.google.com/events/io/2010/sessions/android-ui-design-patterns.html
4. http://developer.android.com/guide/topics/ui/index.html

1. http://developer.android.com/guide/topics/fundamentals/activities.html
2. http://developer.android.com/guide/topics/intents/intents-filters.html
3. http://developer.android.com/guide/practices/screens_support.html

También pueden apoyar esta lectura con el siguiente post y video:

http://www.fr4gus.com/2010/06/03/android-para-todos-dispositivos-p1/

1. IDE de su elección. Se recomienda Eclipse por ser el IDE soportado oficialmente. Que sea el classic o superior. Si baja e instala la edición para Java Developers, ocupa instalar manualmente el plugin Web Tools Platform. http://www.eclipse.org/downloads/packages/eclipse-classic-372/indigosr2
2. Android SDK Tools. http://developer.android.com/sdk/index.html
3. Editor de Imágenes.
4. Poner los platform tools  en su path. Esto facilitara poder correr comandos como el ADB o el Emulador.

Para probar que su ambiente esta correcto, deben crear un proyecto de Android y correrlo con el emulador. Si ven el “Hello World” estan listos.

Cuando hay un cambio de orientación, si la actividad no maneja el cambio de orientación, probablemente sea destruida y recreada. Entonces ¿Qué pasa con el ProgressDialog?.

Iniciemos con dos reglas que debemos seguir:

1. Si va a crear el AsyncTask dentro de la actividad como un inner class, asegúrese de que sea estática. Las inner class no estáticas, guardan una referencia de la outer class, en nuestro caso, la Actividad. Esto quiere decir que estamos “filtrando” (leaking) memoria, pues esa referencia de la actividad queda ahi mientras siga vivo el AsyncTask, y esto hay que evitarlo.
2. Para crear el ProgressDialog, utilice los métodos que tiene disponible la actividad. Me refiero a onCreateDialog, showDialog y dismissDialog. Esto por que a la hora de cambiar la orientación de la pantalla y al destruir y recrear la actividad, Android va a mantener el estado de los dialogs que estaban presentes y se encargará de mostrarlos nuevamente cuando la actividad es recreada.

El consenso es utilizar el método onRetainNonConfigurationInstance, para “guardar” la referencia del AsynctTask, así, cuando la nueva actividad es creada, ella se dará cuenta si la tarea todavia está en progreso, para poder “acoplarse” a ella.

public class EjemploProgressDialogActivity extends Activity {
    public static final String TAG = "EXAMPLE_DIALOG";

    public static final int PROGRESS_DIALOG = 1;

    MyTask task;

    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        Log.d(TAG, "onCreate");
        Object obj = getLastNonConfigurationInstance();
        if (obj != null && obj instanceof MyTask) {
            Log.d(TAG, "Tarea previa ejecutandose");
            task = (MyTask) obj;
            task.attach(this);
        } else {
            task = new MyTask(this);
            task.execute(10);
            Log.d(TAG, "Nueva tarea creada y ejecutada");
        }
    }

    @Override
    protected Dialog onCreateDialog(int id) {

        switch (id) {
        case PROGRESS_DIALOG:
            ProgressDialog pd = new ProgressDialog(this);
            pd.setTitle("Trabajando");
            pd.setMessage("Por favor espere...");
            return pd;

        default:
            break;
        }
        return super.onCreateDialog(id);
    }

    @Override
    protected void onPause() {
        super.onPause();
        Log.d(TAG, "onPause");
    }

    @Override
    protected void onRestart() {
        super.onRestart();
        Log.d(TAG, "onRestart");

    }

    @Override
    protected void onResume() {
        super.onResume();
        Log.d(TAG, "onResume");
    }

    @Override
    protected void onStart() {
        super.onStart();
        Log.d(TAG, "onStart");
    }

    @Override
    protected void onStop() {
        super.onStop();
        Log.d(TAG, "onStop");
    }

    @Override
    public Object onRetainNonConfigurationInstance() {
        // Aqui es donde se hace la magia
        if (task != null) {
            task.deattach();
            return task;
        }
        return super.onRetainNonConfigurationInstance();
    }

    private static class MyTask extends AsyncTask {
        WeakReference ctx;

        public MyTask(Activity activity) {
            super();
            attach(activity);
        }

        @Override
        protected void onPreExecute() {
            Activity activity = ctx.get();
            if (activity != null && !activity.isFinishing()) {
                Log.d(TAG, "Mostrando Progress Dialog");
                activity.showDialog(PROGRESS_DIALOG);
            }
        }

        @Override
        protected Void doInBackground(Integer... params) {
            int seconds = params[0];
            try {
                Log.d(TAG, "Tarea va a durar " + seconds + " segundos");
                Thread.sleep(seconds * 1000);
                Log.d(TAG, "Tarea Lista");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return null;
        }

        @Override
        protected void onPostExecute(Void result) {
            if (ctx != null && ctx.get() != null) {
                Activity activity = ctx.get();
                if (!activity.isFinishing()) {
                    Log.d(TAG, "Ocultando Progress Dialog");
                    activity.dismissDialog(PROGRESS_DIALOG);
                }
            }
        }

        public void attach(Activity activity) {
            this.ctx = new WeakReference(activity);
        }

        public void deattach() {
            ctx = null;
        }

    }
}

En la línea 14, pueden ver que en el método onCreate se pregunta si se salvó algún objeto previamente y luego se hacen los chequeos respectivos para asegurarse que el objeto sea el AsyncTask. En este ejemplo en particular, se crea el AsyncTask en el método onCreate, por lo que en el caso de que no exista, se crea.

En la línea 18 se ejecuta el método attach,para que el AsyncTask tenga la nueva referencia de la Actividad.

En la línea 77 que es el momento en que la actividad da su último suspiro, el AsyncTask se desacopla y se “salva” la referencia al AsyncTask para que la siguiente actividad (si es el caso) la retome, como vimos en el método onCreate.

Si ven la implementación del AsyncTask, primero que todo, se guarda la referencia a la actividad dentro de un WeakReference, para así evitar “filtrar” memoria.

En los métodos onPreExecute y onPostExecute se hacen validaciones para asegurarse de que la referencia de la actividad sea válidad (que exista la referencia y que la actividad no esté en proceso de morirse).

Si ejecutáramos éste código,  sin mover el dispositivo, esta sería la salida en la bitácora:

10-04 21:54:46.254: DEBUG/EXAMPLE_DIALOG(6155): onCreate
10-04 21:54:46.294: DEBUG/EXAMPLE_DIALOG(6155): Mostrando Progress Dialog
10-04 21:54:46.514: DEBUG/EXAMPLE_DIALOG(6155): Tarea va a durar 10 segundos
10-04 21:54:46.514: DEBUG/EXAMPLE_DIALOG(6155): Nueva tarea creada y ejecutada
10-04 21:54:46.514: DEBUG/EXAMPLE_DIALOG(6155): onStart
10-04 21:54:46.524: DEBUG/EXAMPLE_DIALOG(6155): onResume
10-04 21:54:56.518: DEBUG/EXAMPLE_DIALOG(6155): Tarea Lista
10-04 21:54:56.524: DEBUG/EXAMPLE_DIALOG(6155): Ocultando Progress Dialog
10-04 21:55:12.395: DEBUG/EXAMPLE_DIALOG(6155): onPause
10-04 21:55:12.554: DEBUG/EXAMPLE_DIALOG(6155): onStop

Pero si cambiamos la orientación del dispositivo, esto sería el resultado:

te
10-04 21:56:08.584: DEBUG/EXAMPLE_DIALOG(6155): Mostrando Progress Dialog
10-04 21:56:08.754: DEBUG/EXAMPLE_DIALOG(6155): Nueva tarea creada y ejecutada
10-04 21:56:08.754: DEBUG/EXAMPLE_DIALOG(6155): onStart
10-04 21:56:08.754: DEBUG/EXAMPLE_DIALOG(6155): Tarea va a durar 10 segundos
10-04 21:56:08.764: DEBUG/EXAMPLE_DIALOG(6155): onResume
10-04 21:56:10.424: DEBUG/EXAMPLE_DIALOG(6155): onPause
10-04 21:56:10.424: DEBUG/EXAMPLE_DIALOG(6155): onStop
10-04 21:56:10.544: DEBUG/EXAMPLE_DIALOG(6155): onCreate
10-04 21:56:10.544: DEBUG/EXAMPLE_DIALOG(6155): Tarea previa ejecutandose
10-04 21:56:10.544: DEBUG/EXAMPLE_DIALOG(6155): onStart
10-04 21:56:10.704: DEBUG/EXAMPLE_DIALOG(6155): onResume
10-04 21:56:18.755: DEBUG/EXAMPLE_DIALOG(6155): Tarea Lista
10-04 21:56:18.755: DEBUG/EXAMPLE_DIALOG(6155): Ocultando Progress Dialog
10-04 21:56:21.626: DEBUG/EXAMPLE_DIALOG(6155): onPause
10-04 21:56:21.784: DEBUG/EXAMPLE_DIALOG(6155): onStop

Imprimí además cuando se ejecutan otros métodos del ciclo de vida, para tener una referencia de cuando ocurre qué.

Video streaming by Ustream

No se les olvide, el grupo de facebook en http://www.facebook.com/groups/arduinocr

Apesar de mi gran interés en la electrónica, siempre ha sido una area flaca, básicamente por mi dificultad de entender la parte de las Leyes de Ohm y el resto de su teoría. Y es que a mi me gusta aprender haciendo y cuando descubrí Arduino fue como que oyeran mis plegarias.

No voy a ahondar mucho sobre que es Arduino, básicamente es una plataforma electrónica de código abierto, para crear objetos interactivos al ambiente. Si usted desea aprender más sobre Arduino, le recomiendo que se dé una vuelta por el sitio oficial que es http://www.arduino.cc y en español http://www.arduino.cc/es/.

Yo me compré este Starter Kit en Sparkfun (amazon / sparkfun), que viene con un Arduino Uno, varios sensores (temperatura, luz, flexibilidad, etc), algunos LEDs, resistencias, mini protoboard y jump wires. Lamentablemente por cuestiones de tiempo lo tuve guardado varios meses.

Al ver el anuncio en Google IO 2011 sobre el Android Open Accessorie Developer Kit (ADK) y de que podía comunicarse con Android y que además el hardware era compatible con Arduino dije: -¡Ahora sí! pero en ese momento el costo del ADK board era alrededor de los $300. Otro problema es que el ADK solo es compatible con dispositivos 2.3.4+. Como era compatible con Arduino, pensé que debía de haber alguna forma de poder hacer el ADK y efectivamente, ya alguien vió el mismo problema y puso en su blog, como hacer su propio (DIY) ADK board.

Ronfont en su sitio web, posteó los pasos de como instalar el ADK en un Arduino + USB Host Shield (ver post aquí). No le bastó y 3 días después, publicó un post, donde “hackeó” el protocolo ADB para poder hacer comunicar a un dispositivo Android con la pareja Arduino+USB Host Shield. Esto se convirtió en un proyecto de código abierto llamado MicroBridge que permitiría a dispositivos de 1.5 en adelante, comunicarse con Arduino.

Ésta no es la única forma de poder comunicar un Arduino con Android. Otra opción basada en USB, es la tarjeta IOIO (en inglés se pronuncia como yo-yo) creada por Sparkfun. SeeedStudio creó su propia version llamada SeedDuino ADK Mainboard. Microship también ofrece el chipKIT. ITeadStudio tiene su version llamada Iteaduino ADK Main board. Todas andan alrededor de los $80 actualmente.

Además de las opciones USB, hay otra opción de comunicar a Android con Arduino mediante Bluetooth. Primero se ocupa un módulo Bluetooth, y de esos también hay bastantes sabores. De los que yo conozco estan el BlueSmirf y los Bluetooth Shield (slave y slave/master).

Existe un proyecto de código abierto llamado Amarino que ofrece un API para Android y la librería para Arduino. Ya lo utilicé y es bastante sencillo una vez comprendido las bases.

Espero que esta información introductoria les sea de utilidad, proximamente postearé más información con ejemplos reales. Pueden revisar mi blog en la sección de Arduino, ahi ya he colocado un par de videos de mi pruebas con Microbrige.

Referencias:

1. Google’s Open Accessory Development Kit on Standard Arduino Hardware.
2. MicroBridge: ADB support for Arduino
3. Amarino