Ayer, día 3 de enero, recibo un email de Google informándome de que “mi aplicación vulnera los derechos de propiedad industrial de RENFE-Operadora” y había sido suspendida. Concretamente por la utilización inconsentida de sus signos distintivos, lo que constituye un acto de competencia desleal.

¿Competencia desleal? Es cierto que utilizo el logotipo de Cercanías como imagen de la aplicación, pero de ahí a ser competencia desleal… Como bien dijo @nacmartin en Twitter: “Serías competencia si tuvieras tu propia red ferroviaria.”

El email que recibo proviene de Google pero, no sé si por error, puedo leer el mensaje que el abogado de Renfe (se le puede encontrar fácilmente en Linkedin) envía a Google y es ahí donde puedo leer lo de competencia desleal (ya que Google ni lo menciona). El mensaje que envía es un copy&paste clarísimo, con tres párrafos donde se repite lo mismo con diferentes palabras.

No me gusta que Google haya suspendido la aplicación sin yo poder defenderme de ninguna manera. Si es por utilizar el logotipo de Cercanías, podría haber modificado la aplicación y subir otro logo, por ejemplo el de un tren parado en mitad de la vía (sería una buena representación de los trenes de Cercanías de Renfe).

No puedo modificar la aplicación ni tampoco realizar ninguna acción sobre ella: descargar el código, descripciones, etc.

El mensaje del abogado se envió el 29 de diciembre de 2011 y el día 3 ya estaba suspendida. Bastante rápidos para lo que les interesa.

La decisión que he tomado es liberar el código y subir el apk de la aplicación a mi blog para su libre descarga. No tengo intención de seguir beneficiando a Renfe con la aplicación y además de manera gratuita (no he ganado un solo céntimo con la aplicación, era totalmente gratuita y sin publicidad). No dejaré de preocuparme por ella y la iré actualizando (se que existe alguna forma para que las actualizaciones se descarguen desde mi blog, como dice @biriru)

Gracias a todos por los mensajes y las palabras de ánimo que me habéis dejado en Twitter, la verdad que me han desbordado y no puedo contestar a todos. ¡GRACIAS!

Aquí algunos twits que me han parecido interesantes:

Santi Núñez @snunsan
Incapaz de crear app mínimamte seria, @Renfe denuncia la app #Android de @jonseg por “compentencia desleal” y Google la suspende #hazteFan

aurelio hernández @ahdezsanchez
Renfe se supera. No solo tienen la web más vergonzosa que se recuerda, sino que hace que retiren apps independientes, como la de @jonseg

Dani Rubio @vegaquark
@jonseg Suele pasar que las empresas que desconocen el terreno meten la pata… Es como los famosos en twitter…

Rubén Hidalgo @rhidalgo
@jonseg 100veces mas practica tu app,al final estas facilitando el uso a las personas que lo utilizamos,cansado de #renfe #renfelibreAndroid

papakorkel @papakorkel
@jonseg ¿Desleal porque no es puta mierda como su página web?

Josean Bilbao @joseanbilbao
@jonseg otra muestra más de su incompetencia, en lugar de acercarse al talento y colaborar, lo eliminan. #fail #renfe

Albert Mata @almata
@jonseg yo creía que en Android había libertad y no eran como los malísimos de Apple y no pasaban esas cosas…

rnesto G. Aroca @ErneX
@snunsan @Renfe @jonseg Renfe como siempre, cubriéndose de gloria. Son unos incapaces.

Salvador López @salvad0rlopez
@jonseg yo uso tu app , una lastima que te la quiten del market ya que es fantastica, espero que sigas desarrollandola.

Javier Eguiluz @javiereguiluz
@jonseg Ánimo Jon! El único consuelo es que Renfe reconoce que no puede ganarte, así que trata de eliminarte #android #renfe

Victor @vdesigner_es
Bravo por los señores de @renfe obligando a Google a eliminar la única app 100% funcional sobre sus propios servicios #BravoRenfe

A todos los RT, menciones y palabras de ánimo, solo puedo decir: ¡GRACIAS!

——-

Actualización 10 enero 2012: Ya está disponible el código fuente en github y puedes descargar el fichero .apk de la aplicación si echas un vistazo a la columna derecha del blog.

Actualización 4 enero 2012: Ahora mismo no tengo acceso a la última versión del código de la aplicación. En cuanto pueda (a partir del día 8 de enero) subiré el código a Github y publicaré el .apk en el blog.

Añadidas las estaciones
-Fuentes de Invierno
-Navacerrada

Añadido Pirineo Francés
- La Pierre Saint-Martin
- Luz Ardiden
- Grand Tourmalet
- etc

Si falta alguna estación, ponte en contacto conmigo y la incluiré cuanto antes

——

Con esta aplicación podrás consultar en todo momento la cantidad de nieve y el estado de las pistas de esquí observándolas directamente a través de las webcams.

Disponibles las estaciones de esqui de toda España, contando todas ellas con varias webcams.

Obtendrás información del estado de las pistas, espesor y calidad de la nieve, remontes abiertos, pistas abiertas, kilómetros abiertos, etc.

Toda la información sobre estaciones de esquí y pistas de ski.

- Alto Campoo
- Astún
- Candanchú
- Formigal
- Baqueira Beret
- Valdelinares
- Valdezcaray
- Sierra Nevada
- etc.

Para descargarla, solamente deberemos buscar “estaciones esqui” en el Android Market o a partir del siguiente código QR:

Es una primera versión básica. Las próximas actualizaciones serán:
- Buscar por número de oficina
- Información de la oficina: teléfono, horarios, etc.
- Vuestras sugerencias en los comentarios!

Para descargarla, solamente deberemos buscar “bbk” en el Android Market o a partir del siguiente código QR:

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.

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

Nos deberemos descargar los ejemplos que encontraremos aquí para seguir el curso.

Empezamos!

Desarrollo de la aplicación Notepad

A través de este tutorial vamos a crear una aplicación para tomar notas, que nos introducirá a los aspectos básicos y herramientas para el desarrollo en Android. Comenzando por un proyecto base, seguiremos los pasos  para crear una simple aplicación, viendo como desarrollar la lógica de negocio y las interfaces, así como compilar y ejecutar la aplicación.

En este ejercicio, vamos a construir una simple lista de notas, permitiendo al usuario añadir nuevas notas, pero no editarlas.

Objetivos:
• Conocer ListActivities y crear menus de aplicación.
• Utilizar SQLite para almacenar datos.
• Cómo recuperar los datos de una base de datos y mostrarlos en pantalla.
• Conceptos básicos sobre cómo interactuar con la interfaz de usuario.

Paso 1

1. Crear un nuevo proyecto Android File > New > Android Project
2. En el cuadro de diálogo, seleccionar Create project from existing source
3. Pulsar Browse y navegar hasta donde hemos descomprimido el material del curso (carpeta NotepadCodeLab) y seleccionar Notepadv1
4. Las propiedades del proyecto deberían de completarse automáticamente.
5. Pulsar Finish. El proyecto Notepadv1 debería abrirse y aparecer en el explorador de proyectos.

Si se produce algún error con AndroidManifest.xml, pulsar el botón derecho sobre el proyecto y seleccionar Android Tools > Fix Project Properties.

Paso 2

Abrir el fichero notepad_list.xml en res/layout. Vamos a añadir los elementos necesarios para presentar la lista de notas. Podemos hacerlo de dos manera, añadir un ListView y un TextView desde el panel de elementos, o escribiendo el código directamente en el XML.

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

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
      xmlns:android="http://schemas.android.com/apk/res/android"
      android:layout_width="wrap_content"
      android:layout_height="wrap_content">
      <ListView android:layout_width="wrap_content"
          android:layout_height="wrap_content"
          android:id="@android:id/list"></ListView>
     <TextView android:layout_width="wrap_content"
          android:layout_height="wrap_content"
          android:text="@string/no_notes"
          android:id="@android:id/empty"></TextView>
</LinearLayout>

Los elementos que hemos añadido se mostrarán alternativamente, es decir, solo uno de ellos será visible.
• Los identificadores list y empty son proporcionados por la plataforma Android, por lo que tenemos que añadir el prefijo android: a los identificadores (@android:id/list).
• La vista con el identificador empty, es usada automáticamente por Android cuando no existen elementos que mostrar.

Paso 3

Necesitamos mostrar las notas en el listado de notas, dentro del ListView.
1. Crear un nuevo fichero llamado notes_row.xml dentro de res/layout.
2. Añadir un nuevo TextView a la interfaz. Aplicarle el siguiente identificador: @+id/text1
3. Guardar el fichero.

Paso 4

Vamos a modificar la clase Notepadv1 para mostrar el listado de nostas y que nos permita añadir nuevas notas. Abrimos el fichero Notepadv1.java.

• Debemos cambiar la clase a la que extiende (Activity) por ListActivity. Esta clase nos proporciona funcionalidades extra para trabajar con listas.
• Vemos que existen varios métodos en el código:
onCreate(): se ejecuta cuando se llama a la actividad (puede verse como un método main).
onCreateOptionsMenu(): crea el menu de la actividad.
onOptionsItemSelected(): se ejecuta al seleccionar un elemento del menu.

Paso 5

Ahora que ya tenemos los componentes, ya podemos comenzar a construir la aplicación. Lo primero que vamos a hacer es abrir/crear la base de datos y asignar el resultado a la vista (ListView). Vamos a añadir el siguiente código al método onCreate():

1
2
3
4
5
6
7
8
9

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    super.onCreate(savedInstanceState);
    setContentView(R.layout.notepad_list);
    mDbHelper = new NotesDbAdapter(this);
    mDbHelper.open();
    fillData();
}

Definir la siguiente variable a nivel de clase:

1

private NotesDbAdapter mDbHelper = null;

Hemos definido un nuevo método, fillData(), que es el encargado de obtener todas las notas de la base de datos y asignárselas al ListView.

1
2
3
4
5
6
7
8
9

private void fillData() {
    Cursor c = mDbHelper.fetchAllNotes();
    startManagingCursor(c);
    String[] from = new String[] { NotesDbAdapter.KEY_TITLE };
    int[] to = new int[] { R.id.text1 };
    SimpleCursorAdapter notes =
        new SimpleCursorAdapter(this, R.layout.notes_row, c, from, to);
    setListAdapter(notes);
}

Paso 6

Vamos a crear el menu para que nos permita añadir nuevas notas a la lista.
Necesitamos un botón que al ser pulsado cree una nueva nota:

1. Creamos el texto asociado al botón en res/values/strings.xml

2. Definimos la posición del botón en el menú:

1

public static final int INSERT_ID = Menu.FIRST;

3. Añadimos el nuevo botón al menú:

1
2
3
4
5
6

@Override
public boolean onCreateOptionsMenu(Menu menu) {
    boolean result = super.onCreateOptionsMenu(menu);
    menu.add(0, INSERT_ID, 0, R.string.menu_insert);
    return result;
}

Paso 7

Una vez creado el menú, es necesario atender a las pulsaciones de los elementos del mismo. Aunque en este caso tengamos un único elemento, hay que tener en cuenta el elemento pulsado:

1
2
3
4
5
6
7
8
9

@Override
public boolean onOptionsItemSelected(MenuItem item) {
    switch (item.getItemId()) {
        case INSERT_ID:
            createNote();
            return true;
    }
    return super.onOptionsItemSelected(item);
}

Paso 8

Creamos una nueva nota, la añadimos a la base de datos y actualizamos la lista para reflejar los cambios.

1
2
3
4
5
6

private void createNote() {
    String noteName = this.getString(R.string.note_name) + " " +
    String.valueOf(mNoteNumber++);
    mDbHelper.createNote(noteName, "");
    fillData();
}

Paso 9

Ya hemos acabado. Puedes importar el proyecto llamado Notepadv1Solution para comprobar que has hecho todo bien. Mañana más. Cualquier duda en los comentarios!

Segundo capítulo del tutorial: Tutorial Android paso a paso II: Desarrollo de la aplicación Notepad
Tercer capítulo del tutorial: Tutorial Android paso a paso III: Desarrollo de la aplicación Notepad