23 Feb 10 Tutorial Android paso a paso III: Desarrollo de la aplicación Notepad

En este tercer y último post del tutorial, vamos a practicar el ciclo de vida de la aplicación, y como guardar y recuperar el estado de la aplicación.

Puedes ver los anteriores artículos:
Tutorial Android paso a paso I: Desarrollo de la aplicación Notepad
Tutorial Android paso a paso II: Desarrollo de la aplicación Notepad

Objetivos:
• Conocer los eventos del ciclo de vida de la aplicación.
• Tecnicas para mantener el estado de la aplicación.

Paso 1

La aplicación actual contiene algunos problemas. Para solucionarlo, vamos a mover la funcionalidad de edición de notas a la clase NoteEdit.

1. Eliminar el siguiente código de la clase NoteEdit, que obtiene los datos de la nota a través del Bundle. Vamos a pasar a utilizar la clase DBHelper para obtener los datos directamente de la base de datos.

1
2
3
4
5

Bundle extras = getIntent().getExtras();
…
String title = extras.getString(NotesDbAdapter.KEY_TITLE);
String body = extras.getString(NotesDbAdapter.KEY_BODY);
mRowId = extras.getLong(NotesDbAdapter.KEY_ROWID);

2. Además, eliminamos la asignación de los datos a la interfaz de usuario

1
2
3
4
5
6

if (title != null) {
    mTitleText.setText(title);
}
if (body != null) {
    mBodyText.setText(body);
}

Paso 2

Conectamos la clase NoteEdit con la base de datos.

1. Creamos un nuevo atributo:

1

private NotesDbAdapter mDbHelper;

2. Conectamos con la base de datos en el constructor, justo después de llamar al constructor padre:

1
2

mDbHelper = new NotesDbAdapter(this);
mDbHelper.open();

Paso 3

Pasamos a comprobar el estado de la variable savedInstanceState. Esto sirve para comprobar si tenemos datos guardados en el Bundle, que debemos recuperar (Esto ocurre si la actividad pierde el foco y después se recupera).

1. Reeplazar el siguiente código:

1
2
3
4
5

mRowId = null;
Bundle extras = getIntent().getExtras();
if (extras != null) {
    mRowId = extras.getLong(NotesDbAdapter.KEY_ROWID);
}

Por este otro

1
2
3
4
5

mRowId = savedInstanceState != null ? savedInstanceState.getLong(NotesDbAdapter.KEY_ROWID) : null;
if (mRowId == null) {
    Bundle extras = getIntent().getExtras();
    mRowId = extras != null ? extras.getLong(NotesDbAdapter.KEY_ROWID) : null;
}

Paso 4

Necesitamos completar los campos con los datos de la nota. Llamamos al método populateFields() que completaremos más adelante. Insertarlo justo antes de confirmButton.setOnClickListener():

1

populateFields();

Paso 5

En esta actividad ya no es necesario devolver ningún tipo de datos, ya que vamos a guardar los datos directamente en esta actividad, por lo que es posible simplificar el método onClick() considerablemente:

1
2
3
4

public void onClick(View view) {
    setResult(RESULT_OK);
    finish();
}

Más adelante veremos como guardar los datos.

Paso 6

Definimos el método populateFields():

1
2
3
4
5
6
7
8

private void populateFields() {
    if (mRowId != null) {
        Cursor note = mDbHelper.fetchNote(mRowId);
        startManagingCursor(note);
        mTitleText.setText(note.getString(note.getColumnIndexOrThrow(NotesDbAdapter.KEY_TITLE)));
        mBodyText.setText(note.getString(note.getColumnIndexOrThrow(NotesDbAdapter.KEY_BODY)));
    }
}

Paso 7

Implementamos los métodos que gestionan el ciclo de vida de Android. Estos métodos nos permiten guardar y recuperar el estado de la actividad en caso de que esta se cierre o pase a un segundo plano (al recibir una llamada, por ejemplo):

1. onSaveInstanceState(): es llamada por Android cuando la actividad va a ser cerrada. Esto significa que aquí se debe guardar toda la información necesaria para restaurar la actividad en su estado anterior. Podemos pensar que es el método contrario a onCreate(), de hecho el Bundle que construimos en este método, es el que será pasado al método onCreate().

1
2
3
4
5

@Override
protected void onSaveInstanceState(Bundle outState) {
    super.onSaveInstanceState(outState);
    outState.putLong(NotesDbAdapter.KEY_ROWID, mRowId);
}

2. onPause(): es llamada cuando la actividad va a terminar (con finish()) o pasar a un segundo plano (con una llamada de teléfono).

1
2
3
4
5

@Override
protected void onPause() {
    super.onPause();
    saveState();
}

3. onResume(): es llamada al reactivar la actividad. Completamos los campos:

1
2
3
4
5

@Override
protected void onResume() {
    super.onResume();
    populateFields();
}

Paso 8

Para terminar de completar la clase NoteEdit, ya solo nos queda guardar los datos en la base de datos. Creamos el método saveState():

1
2
3
4
5
6
7
8
9
10
11
12

private void saveState() {
    String title = mTitleText.getText().toString();
    String body = mBodyText.getText().toString();
    if (mRowId == null) {
        long id = mDbHelper.createNote(title, body);
        if (id > 0) {
            mRowId = id;
        }
    } else {
        mDbHelper.updateNote(mRowId, title, body);
    }
}

Paso 9

Volvemos a la clase Notepadv3. En el método onActivityResult(), teníamos implementado todo lo necesario para recibir los datos de la actividad y guardarla en la base de datos. Como este proceso ya lo realizamos en la clase NoteEdit, solo es necesario que actualizemos la lista con los nuevos datos:

1
2
3
4
5

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent intent) {
    super.onActivityResult(requestCode, resultCode, intent);
    fillData();
}

Paso 10

Finalmente, es esta misma clase, al seleccionar un elemento de la lista, ya no es ncesario pasar todos los datos de la nota, únicamente el id, por lo que el método onListItemClick(), quedaría de la siguiete manera:

1
2
3
4
5
6
7

@Override
protected void onListItemClick(ListView l, View v, int position, long id) {
    super.onListItemClick(l, v, position, id);
    Intent i = new Intent(this, NoteEdit.class);
    i.putExtra(NotesDbAdapter.KEY_ROWID, id);
    startActivityForResult(i, ACTIVITY_EDIT);
}

Y con este último post hemos terminado el tutorial. Espero que os haya servido de ayuda y, como siempre, cualquier duda o pregunta en los comentarios.

Etiquetas: Android, aplicación, Desarrollo, notepad

20 Feb 10 Tutorial Android paso a paso II: Desarrollo de la aplicación Notepad

Continuamos con la segunda parte del tutorial para el desarrollo de una aplicación para Android paso a paso. La primera parte la puedes consultar en Tutorial Android paso a paso I: Desarrollo de la aplicación Notepad.

En este segundo post, vamos a crear una segunda actividad que nos permita crear y editar notas. Además, vamos a poder tener la posibilidad de eliminar notas a través del un menú contextual.

Objetivos:
• Crear una nueva actividad.
• Realizar llamadas a la nueva actividad.
• Paso de datos entre las actividades.
• Crear un nuevo menu contextual.

Paso 1

Vamos a crear un menú contextual que nos permita eliminar las notas creadas por el usuario. Este menú se activará al seleccionar una nota:

1. Relacionamos la lista de notas (ListView) con el menu contextual:

1

registerForContextMenu(getListView());

2. Creamos el menú contextual con la opción de eliminar una nota:

1
2
3
4
5

@Override
public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) {
    super.onCreateContextMenu(menu, v, menuInfo);
    menu.add(0, DELETE_ID, 0, R.string.menu_delete);
}

3. Ahora que tenemos el menú creado y relacionado con el listado, tenemos que atender a las pulsaciones en el menú contextual:

1
2
3
4
5
6
7
8
9
10
11
12

@Override
public boolean onContextItemSelected(MenuItem item) {
    switch(item.getItemId()) {
        case DELETE_ID:
            AdapterContextMenuInfo info = (AdapterContextMenuInfo)
            item.getMenuInfo();
            mDbHelper.deleteNote(info.id);
            fillData();
            return true;
    }
    return super.onContextItemSelected(item);
}

Paso 2

Como hemos visto antes, vamos a dar la posibilidad al usuario de crear y editar notas. Para ello, necesitamos una actividad que controle la interfaz de usuario.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

public class NoteEdit extends Activity {
    private EditText mTitleText;
    private EditText mBodyText;
    private Long mRowId;
 
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.note_edit);
        mTitleText = (EditText) findViewById(R.id.title);
        mBodyText = (EditText) findViewById(R.id.body);
        Button confirmButton = (Button) findViewById(R.id.confirm);
        mRowId = null;
        Bundle extras = getIntent().getExtras();
        if (extras != null) {
            String title = extras.getString(NotesDbAdapter.KEY_TITLE);
            String body = extras.getString(NotesDbAdapter.KEY_BODY);
            mRowId = extras.getLong(NotesDbAdapter.KEY_ROWID);
 
            if (title != null) {
                mTitleText.setText(title);
            }
 
            if (body != null) {
                mBodyText.setText(body);
            }
        }
 
    confirmButton.setOnClickListener(new View.OnClickListener() {
    public void onClick(View view) {
        Bundle bundle = new Bundle();
        bundle.putString(NotesDbAdapter.KEY_TITLE,
        mTitleText.getText().toString());
        bundle.putString(NotesDbAdapter.KEY_BODY,
        mBodyText.getText().toString());
        if (mRowId != null) {
            bundle.putLong(NotesDbAdapter.KEY_ROWID, mRowId);
        }
        Intent mIntent = new Intent();
        mIntent.putExtras(bundle);
        setResult(RESULT_OK, mIntent);
        finish();
    }});
    }
}

Paso 3

Ya tenemos la interfaz de usuario, y la actividad para controlarla. Vamos a abrir la nueva actividad desde el listado, para crear una nueva nota. Modificamos el método createNote() de la siguiente manera:

1
2
3
4

private void createNote() {
    Intent i = new Intent(this, NoteEdit.class);
    startActivityForResult(i, ACTIVITY_CREATE);
}

Paso 4

Para editar las notas ya creadas, creamos un evento para atender a las pulsaciones de los elementos de las listas. Pasamos los datos de la nota a la nueva actividad.

1
2
3
4
5
6
7
8
9
10
11
12
13

@Override
protected void onListItemClick(ListView l, View v, int position, long id) {
    super.onListItemClick(l, v, position, id);
    Cursor c = mNotesCursor;
    c.moveToPosition(position);
    Intent i = new Intent(this, NoteEdit.class);
    i.putExtra(NotesDbAdapter.KEY_ROWID, id);
    i.putExtra(NotesDbAdapter.KEY_TITLE, c.getString(
    c.getColumnIndexOrThrow(NotesDbAdapter.KEY_TITLE)));
    i.putExtra(NotesDbAdapter.KEY_BODY, c.getString(
    c.getColumnIndexOrThrow(NotesDbAdapter.KEY_BODY)));
    startActivityForResult(i, ACTIVITY_EDIT);
}

Paso 5

Los métodos creados anteriormente createNote() y onListItemClick() nos devuelven datos, por lo que necesitamos un método para manejar la respuesta. onActivityResult() es el método ejecutado cuando una actividad devuelve resultados.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent intent) {
    super.onActivityResult(requestCode, resultCode, intent);
    Bundle extras = intent.getExtras();
    switch(requestCode) {
        case ACTIVITY_CREATE:
            String title = extras.getString(NotesDbAdapter.KEY_TITLE);
            String body = extras.getString(NotesDbAdapter.KEY_BODY);
            mDbHelper.createNote(title, body);
            fillData();
            break;
        case ACTIVITY_EDIT:
            Long rowId = extras.getLong(NotesDbAdapter.KEY_ROWID);
            if (rowId != null) {
            String editTitle = extras.getString(NotesDbAdapter.KEY_TITLE);
            String editBody = extras.getString(NotesDbAdapter.KEY_BODY);
            mDbHelper.updateNote(rowId, editTitle, editBody);
    }
    fillData();
    break;
}

Paso 6

La nueva actividad que hemos definido anteriormente, hay que añadirla a AndroidManifest.xml. Esto permite al sistema conocer los componentes de la aplicación.
Eclipse include un editor para el manifiesto que facilita la edición del fichero AndroidManifest.xml. Para añadir una nueva actividad:

1. Abrir el fichero AndroidManifest.xml
2. Seleccionar la pestaña Application.
3. Pulsamos Add en la sección de Application Nodes.
4. En el cuadro de diálogo, seleccionar “Create a new element at the top level, in Application” y Activity. Pulsar OK.
5. Seleccionar la nueva actividad creada, y en el campo de texto Name, escribir .NoteEdit.

Paso 7

Ya hemos terminado esta segunda entrega del tutorial. Si ejecutamos la aplicación, editamos una nota y pulsamos el botón atrás, veremos que se produce un error. Veremos como solucionar estos problemas en el siguiente post.

Cualquier pregunta o duda (o corrección) en los comentarios.

Ya puedes consultar la tercera parte del tutorial: Tutorial Android paso a paso III: Desarrollo de la aplicación Notepad

Etiquetas: Android, aplicación, Desarrollo, notepad