Programación multimedia y dispositivos móviles
Enviado por • 25 de Febrero de 2013 • 4.142 Palabras (17 Páginas) • 484 Visitas
Programación multimedia y dispositivos móviles
4.6.Programar con varias Activities
Una aplicación generalmente usa y tiene varias activities. Una Activity principal “main”, es aquella que se muestra cuando el usuario ejecuta la aplicación. Luego esta Activity puede lanzar otra Activity, esta otra y así sucesivamente. Cada vez que un nueva activitiy se inicia, la Activity previa es parada (onStop), pero el sistema mantiene la Activity en una pila de activities. Cuando una nueva Activity se inicia se coloca en la cima de la pila y toma el foco del usuario. Dado que es una pila, cuando el usuario pulsa el botón “Atrás” del dispositivo, la Activity es eliminada de la pila y destruida (onDestroy), así, la Activity anterior guardada en la pila toma el foco de nuevo (onResume). Todos estos cambios de estado de la Activity es lo que se denomina ciclo de vida de una Activity y por cada estado existe un evento asociado donde podemos programar acciones. Por ejemplo ,en onStop la Activity debería liberar de memoria objetos de gran tamaño y conexiones de red o bases de datos, o por ejemplo en onResume podría readquirir los recursos necesarios para continuar con las tareas interrumpidas.
4.6.1. Ciclo de vida de una Activity. onCreate No visible
El sistema llama a este método cuando crea la Activity. Aquí se deben realizar tareas de inicialización de controles y llamar a setContentView para mostrar un layout.
onStart No visible La Activity está apunto de ser visible.
onResume Visible La Activity se visualiza, recibe el foco y se ejecuta. Se suelen readquirir recursos para
continuar con las tareas interrumpidas. onPause Puede estar parcialmente visible
Otra actividad va a recibir el foco, la actual se mantiene pone en pausa y podría no pararse(onStop), siempre que sea todavía visible (ej. ventana de diálogo que no cubre toda la pantalla). Es el primer estado en donde la Activity puede llegar a ser destruida por el sistema en casos de extrema necesidad de memoria, es por ello que aquí deberíamos salvar los cambios persistentes (entre distintas ejecuciones de la aplicación). Además, los eventos siguientes a onPause: OnStop y OnDestroy, podrían no ser llamados por el sistema cuando este elimina la Activity en caso de emergencia de memoria, por lo que el evento más seguro para almacenar datos persistentes es este: onPause.
También se suele usar para animaciones y otras tareas que consuman CPU en este evento. Nota: Las tareas en este evento no deben consumir muchos recursos del sistema, dado que
este es un evento que se ejecuta con mucha frecuencia y puede ralentizar mucho la aplicación y el dispositivo.
onStop No visible La Activity ha quedado oculta por otra (o está siendo destruida), y ya no tiene el foco. En
necesidad de memoria podría ser eliminada por el sistema Android. Si vuelve a recibir el foco se ejecuta el evento onRestart().
onDestroy No visible Útil para liberar recursos o finalizar threads en segundo plano. La Activity se elimina
definitivamente la Activity de memoria.
52
Programación multimedia y dispositivos móviles
Mediante programación se puede cerrar una Activity con el método finish(). O puede ser destruida por el sistema, en cualquiera de estos casos la Activity debe será creada de nuevo. Podemos distinguir ambas situaciones en este evento con el método isFinishing().
53
Programación multimedia y dispositivos móviles
A continuación se muestra el código de los eventos sobrescritos en una Activity:
public class MainActivity extends Activity { @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); // La Activity está siendo creada } @Override protected void onStart() { super.onStart(); // La Activity está apunto de ser visible } @Override protected void onResume() { super.onResume(); // La Activity ya es visible } @Override protected void onPause() { super.onPause(); // Otra Activity ha tomado el foco } @Override protected void onStop() { super.onStop(); // La Activity ya no es visible } @Override protected void onStart() { super.onStart(); // La Activity pasa de Stop a Start } @Override protected void onDestroy() { super.onDestroy(); // La Activity se destruye } }
54
Programación multimedia y dispositivos móviles
EJERCICIO: Crea una Activity como la anterior que sobrescriba todos los métodos de evento asociados con los posibles estados de una Activity y comprueba que los estados por los que pasa la Activity corresponden con el gráfico del ciclo de vida de una activity.
En cada evento muestro un mensaje de información en el Log (sistema de mensajes de depuración) para indicar el evento que se ejecuta la Activity. Para ello, haz una llamada al método estático i de la clase Log, por ejemplo:
Log.i("Evento ejecutado:","Estado onCreate");
Los dos parámetros que recibe son el TAG (una etiqueta para identificar mensajes relacionados) y el String con el mensaje de depuración.
1. Ejecuta la aplicación. 2. ¿Qué eventos se han ejecutado tras lanzar la aplicación la primera vez?. Puedes buscar
estos mensajes en la pestaña LogCat de Eclipse.
3. Borra el Log
4. Realiza una pulsación corta en el botón “Home” del dispositivo. ¿Qué eventos se han ejecutado ahora?
5. Borra el Log 6. Realiza una pulsación larga en el botón “Home” y vuelve a mostrar la Activity. ¿Qué
eventos se han ejecutado ahora?
4.6.2. Salvar el estado de una actividad El estado de una Activity se refiere a los valores actuales de la Activity contenidos en los
controles y en otras variables que hemos creado en la Activity las cuales son importantes para definir el estado de la Activity.
Mantener el estado anterior de un Activity demuestra que la aplicación desarrollada es profesional y ayuda al usuario en procesos repetitivos.
Cuando una Activity pasa por los estados pause y stop, los datos de la Activity todavía permanecen en memoria pues esta todavía no se han destruido, por lo tanto cuando la Activity vuelve a mostrarse y tomar el foco se mostrará tal y como estaba. Sin embargo, si la Activity se destruye por código o con el botón atrás del dispositivo, el estado de la Activity se perderá, siendo este el comportamiento deseado, en estos casos si queremos salvar algún dato persistente entre distintas ejecuciones de la Activity(como un dibujo no finalizado) deberíamos hacerlo hecho en el evento onPause. Por el contrario, si es el sistema es quien destruye la Activity o bien simplemente se cambia la orientación de pantalla del dispositivo o el usuario ha cambiado la configuración del idioma, etc., en estos casos la Activity se vuelve a generar de nuevo y es recomendable haber guardado el estado de la Activity para que esta se vuelva a mostrarse tal y como estaba, por ejemplo para que siga reproduciéndose una música de fondo en el punto en que estaba y vuelva a reproducirse desde el principio.
Para guardar el estado de una Activity en estos casos disponemos del método de evento onSaveInstanceState() que es llamado automáticamente por el sistema cuando detecta la necesidad (por ejemplo cuando se cambia la orientación de la pantalla del dispositivo). El sistema envía a este método un objeto Bundle, en cual podemos grabar información de la Activity en formato nombre-valor, mediante los métodos putString y putInt(). Así cuando se vuelva a mostrar la Activity, se enviará ese objeto Bundle al método de evento onCreate y al
55
Programación multimedia y dispositivos móviles
método de evento onRestoreInstanceState() (que se ejecuta después de onStart). La primera vez que se ejecuta la Activity este objeto , lógicamente es nulo (null).
Nota: Existe una implementación por defecto de onSaveInstanceState() y onRestoreInstanceState() y Create(), que guardan el estado de los controles y es recuperado automáticamente, siempre y cuando añadamos el atributo id a cada View de la interfaz. Por ellos es siempre importante llamar al método super en estos tres métodos de eventos, para no perder este automatismo. De este modo, sólo es necesario guardar los valores que no están en los controles de la interfaz gráfica.
4.6.3. Crear una Activity
Tras crear una subclase de Activity, esta debe ser declarada en el fichero AndroidManifest.xml para que puede ser utilizada por el sistema. Para declarar una Activity debemos añadir una etiqueta <activity> dentro de la etiqueta <application>, por ejemplo
<manifest ... > <application ... > <activity android:name=".MainActivity" /> ... </application ... > ... </manifest >
La etiqueta <activity> admite además de la propiedad android:name, cuyo valor corresponde con un punto y el nombre de la clase JAVA de la Activity, otros como:
android:icon Para asignarle un icono a la Activity android:label Para asignarle un título a la Activity
A su vez una etiqueta <activity> puede incluir otras etiquetas hijas como <intent-filter> para indicar qué otros componentes pueden lanzarla. Por ejemplo para indicar que una Activity debe ser la primera en lanzarse al ejecutar la aplicación (android.intent.action.MAIN) y que debe incluirse en el listado de aplicaciones del dispositivo (android.intent.category.LAUNCHER):
56
Programación multimedia y dispositivos móviles
<Activity android:name=".MainActivity" android:icon="@drawable/mi_icono"> <intent-filter> <action android:name="android.intent.action.MAIN" /> <category android:name="android.intent.category.LAUNCHER" /> </intent-filter> </Activity>
Nota 1: El asistente de Eclipse ya incluye estas etiquetas en el AndroidManifest.xml al crear la primera Activity del proyecto.
Nota 2: Para añadir una segunda Activity usando el asistente de Eclipse: Botón derecho sobre el proyecto New Other Android Activity. Finalmente revisar las
etiquetas añadidas en el fichero AndroidManifest.xml.
4.6.4. Lanzar una actividad La actividad principal de la aplicación ya se lanza automáticamente, pero para lanzar otra
Activity debemos llamar al método startActivity(), pasándole un objeto Intent que describe la actividad que se quiere lanzar. El intent indica exactamente que Activity lanzar o bien no indica la Activity pero describe el tipo de acción que queremos realizar (hacer una llamada telefónica por ejemplo) y el sistema selecciona automáticamente alguna de las activities del sistema capacitada para realizar dicha acción. Un intent también puede incluir datos a ser usados por la Activity.
Ejemplo 1: Lanzar una segunda Activity de nuestro proyecto llamada “SegundaActivity”:
Intent intent = new Intent(this, SegundaActivity.class); startActivity(intent);
Ejemplo 2: Lanzar una Activity del sistema, y así realizar una acción que nuestro proyecto no puede realizar, por ejemplo para enviar un email:
Intent intent = new Intent(Intent.ACTION_SEND); intent.putExtra(Intent.EXTRA_EMAIL, destinatarios); startActivity(intent);
Con el método putExtra, añadimos la información de los destinatarios, que en este caso será un array de Strings, así el sistema lanzaría la Activity correspondiente para enviar un email, con la caja de destinatarios rellenada según la información enviada en putExtra y contenida en el array destinatarios, así cuando el usuario podrá enviar el email y luego el sistema vuelve a la Activity anterior.
57
Programación multimedia y dispositivos móviles
4.6.5. Lanzar una Activity y obtener un resultado. En muchas ocasiones queremos recibir un dato como respuesta de la Activity que lanzamos, en
este caso en lugar de startActivity() usaremos el método startActivityForResult() y sobrescribiremos el método de evento onActivityResult(), donde recibiremos dicho dato de respuesta encapsulado en un objeto Intent.
Nota: Si queremos cerrar la Activity previamente lanzada con startActivityForResult() usaremos el método finishActivity(), enviándole como parámetro el requestCode.
Ejemplo. A continuación mostramos como lanzar una segunda Activity enviándole un dato y recibiendo una respuesta de esta. Para simplificar el código, añadimos las instrucciones directamente en los métodos de evento onCreate de ambas Activities.
MainActiviy.class
public class MainActivity extends Activity { // Constante que nos permitirá diferenciar en onActivityResult // las distintas respuestas que nos puedan llegar de otras activities final int REQUEST_EMAIL=1; @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.Activity_main); // Creamos objeto Intent con Activity a lanzar y un dato a enviar Intent intencion = new Intent(this, SegundaActivity.class); // textoPeticion, se podría utilizar para mostrar en una etiqueta de texto intencion.putExtra("textoPeticion", "Introduzca su email:"); // Lanzamos la segunda Activity startActivityForResult(intencion, REQUEST_EMAIL); } @Override // Recibimos la respuesta protected void onActivityResult(int requestCode, int resultCode, Intent data) { super.onActivityResult(requestCode, resultCode, data); // Chequeamos que la respuesta es a la petición de email y resultado OK if (requestCode==REQUEST_EMAIL && resultCode==RESULT_OK){ // Obtenemos el dato recibido encapsulado en el Intent String email = data.getStringExtra("email"); Toast.makeText(MainActivity.this, "El email recibido es: " + email, Toast.LENGTH_SHORT).show(); } } }
58
Programación multimedia y dispositivos móviles
SegundaActivity.class
public class SegundaActivity extends Activity { @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.Activity_segunda); Intent intencionRecibida= getIntent(); // Recogemos el intent recibido. // Recogemos el dato que hay dentro del intent recibido. Es un ejemplo
// y en este caso no hacemos nada con este dato. String textoPeticion = intencionRecibida.getStringExtra("textoPeticion"); // Creamos el intent con la respuesta a enviar Intent intencionRespuesta = new Intent(); intencionRespuesta.putExtra("email", "pepe@gmail.com"); setResult(RESULT_OK, intencionRespuesta); // Enviamos la respuesta OK //. finish(); // Cerramos la Activity } }
Nota: Para enviar una respuesta “no OK” usaremos la constante RESULT_CANCELED en el método setResult().
EJERCICIO: Crear dos Activities. La Activity principal dispone de un botón “Lanzar” y la segunda
Activity dispone en este orden de una etiqueta de texto, una caja de texto y un botón “Aceptar”. Cuando el usuario pulsa el botón “Lanzar” de la primera Activity, se muestra la segunda enviándole el texto “Introduzca su nick”, este texto es asignado a la etiqueta de texto de la segunda Activity en el momento de ser creada. Cuando el usuario pulsa el botón “Aceptar” de la segunda Activity, envía como resultado a la primera Activity el contenido de la caja de texto y se cierra. Finalmente la primera Activity al recibir la respuesta, mostrará un mensaje Toast con el nick del usuario recibido.
59
DAM – Programación multimedia y dispositivos móviles – Acceso a controles y eventos
Esquema de programación con dos activities
Primera Activity:
1) Crear el objeto Intent adecuado según la Activity que deseemos lanzar. Ejemplo, lanzar una Activity de nuestro propio proyecto:
Intent intencion = new Intent(this, SegundaActivity.class); a. Opcional: Añadir información a pasar a la Segunda Activity sobre el objeto
Intent con llamada/s al método putExtra. Ejemplo: intencion.putExtra("texto", "Seleccione nick:");
2) Lanzar la Segunda Activity. a. Si no necesitamos recoger ninguna respuesta usaremos simplemente el
método startActivity. Ejemplo: this.startActivity(intencion);
b. Si necesitamos recoger una respuesta de la Segunda Activity usaremos el método startActivityForResult. Ejemplo:
this.startActivityForResult(intencion, REQUEST_NICK);
Nota: REQUEST_NICK, debe ser una constante entera de clase que nos sirve para identificar esta petición entre varias posibles respuestas de terceras, cuartas, … activities, en el caso de que la primera lance varias.
3) Opcional, sólo si se ha lanzado la segunda Activity con startActivityForResult. Sobrescribir el método de evento onActivityResult. Este método recibirá la respuesta de la Segunda Activity. Ejemplo:
@Override // Recibimos la respuesta protected void onActivityResult(int requestCode, int resultCode, Intent data) { super.onActivityResult(requestCode, resultCode, data); // Chequeamos que la respuesta es la petición de nick y resultado OK if (requestCode==REQUEST_NICK && resultCode==RESULT_OK){ // Obtenemos el dato recibido encapsulado en el Intent String nick = data.getStringExtra("nick"); Toast.makeText(MainActivity.this, "El nick recibido es: " + nick, Toast.LENGTH_SHORT).show(); } }
1 de 4
DAM – Programación multimedia y dispositivos móviles – Acceso a controles y eventos
Segunda Activity. Opcional, sólo si debe enviar una respuesta:
1) Añadiremos las instrucciones en el evento que corresponda para generar la respuesta. Como primer paso para enviar la respuesta creamos un objeto Intent y le añadiremos si procede (la segunda Activity podría envíar un Intent vacío o nulo, para indicarle indicarle a la primera que ha esta ha finalizado), con el método putExtra información a devolver a la Primera Activity
2) Realizamos una llamada al método setResult, su primer parámetro indica si la Activity envía la respuesta solicitada (RESULT_OK) o no (RESULT_CANCELED), el segundo parámetro es el Intent. La llamada a este método, activará el método de evento onActivityResult de la Primera Activity.
3) Lo habitual es finalizar (finish()) esta Activity para que la primera pueda recoger la respuesta. Ejemplo:
Intent intencionRespuesta = new Intent(); intencionRespuesta.putExtra("nick", caja.getText().toString()); setResult(this.RESULT_OK, intencionRespuesta); this.finish();
EJERCICIOS
1. Crear dos activities. La Activity principal dispone de un botón “Lanzar” y la segunda Activity dispone en este orden de una etiqueta de texto, una caja de texto y un botón “Aceptar”. Cuando el usuario pulsa el botón “Lanzar” de la primera Activity, se muestra la segunda enviándole el texto “Introduzca su nick”, este texto es asignado a la etiqueta de texto de la segunda Activity en el momento de ser creada. Cuando el usuario pulsa el botón “Aceptar” de la segunda Activity, envía como resultado a la primera Activity el contenido de la caja de texto y se cierra. Finalmente la primera Activity al recibir la respuesta, mostrará un mensaje Toast con el nick del usuario recibido.
2. Añade a la segunda Activity del ejercicio anterior un botón con el texto “Cancelar” que envíe la respuesta de cancelación y finalice la Activity. Muestra en la Activity principal un mensaje Toast con el mensaje “El usuario ha cancelado la introducción del nick”.
3. En este ejercicio vamos a comprobar que además de valores Strings, se pueden enviar y recibir otros tipos de datos primitivos entre activities.
Modifica el ejercicio anterior para además de enviarle a la segunda Activity el texto “Introduzca su nick”, se le envíe también una referencia de un color (elige el color que quieras y pásalo como un valor entero que puedes obtener con el método estático Color.rgb) , para además de asignarle a la etiqueta de la segunda Activity el texto recibido, se coloree también dicha etiqueta (método setTextColor() ) con el color recibido .
Para recoger el valor entero debes usar en lugar de método
getStringExtra, el método: o getIntExtra(String name, int defaultValue). El segundo
parámetro será el valor devuelto por el método en el caso de que el nombre (name) enviado como primer parámetro no existiese entre los “datos Extra”.
2 de 4
DAM – Programación multimedia y dispositivos móviles – Acceso a controles y eventos
4. En este ejercicio vamos a enviar desde la primera Activity un objeto. Para ello, crea una clase Usuario con los siguientes atributos:
nick nombre apellidos sexo
Nota1: Para crear los métodos get/set puedes usar el asistente de código de Eclipse: Botón derecho del ratón | Source | Generate Getters and Setters.
Nota2: Para poder enviar objetos entre activities la clase correspondiente debe ser “serializable”, por lo que la clase Usuario debe implementar la interfaz Serializable:
public class Usuario implements Serializable
Crea una Activity que muestre dos cajas de texto para que el usuario pueda teclear nick y contraseña. En su parte inferior sitúa un botón con el texto “Entrar”. Al pulsar el botón “Entrar”, la Activity debería verificar si el usuario existe en una BD y en caso afirmativo, con la información de la BD, crear un objeto de la clase Usuario. Nosotros omitiremos este paso, y vamos a suponer que el usuario siempre existe, creando sin más, un objeto de la clase Usuario con el nick introducido en la caja de texto y con nombre y apellidos: “Sonia, Jiménez Sánchez”. Dicho objeto Usuario se lo enviaremos a una segunda Activity que visualizará en una etiqueta de texto, el siguiente mensaje personalizado según los datos del objeto usuario enviado:
“nombre (nick) bienvenido/a” Mejora: Puedes añadir un if al método getIntent() para evitar un error en el caso que
el objeto devuelto sea nulo (se inicia la Activity sin enviarle ningún Intent).
5. Crea una Activity con una caja de texto donde el usuario pueda introducir un número telefónico y un botón “Llamar”. Ajusta el inputType de la caja de texto adecuadamente. Al presionar el botón “Llamar”, se realizará una llamada telefónica al número introducido en la caja de texto. Para lanzar la Activity de Android que realiza llamadas telefónicas, usaremos el siguiente código (numTelefono es una variable de tipo String):
Intent intencion = new Intent(Intent.ACTION_CALL); intencion.setData(Uri.parse("tel:"+numTelefono));
Nota: Para que la aplicación Android pueda realizar llamadas debes incluir permisos para esta acción en el AndroidManifest.xml:
<uses-permission android:name="android.permission.CALL_PHONE"/>
Voluntarios 6. Crea una Activity principal con un botón para lanzar una segunda Activity. En esta
segunda Activity habrá dos Spinners, uno para listar los teléfonos del usuario (como
3 de 4
DAM – Programación multimedia y dispositivos móviles – Acceso a controles y eventos
mínimo invéntate dos) y otro para listar sus direcciones de email (como mínimo invéntate dos) y dos botones “Aceptar” y “Cancelar”.
El botón de la primera Activity que lanza esta segunda lo hará distinguiendo el tipo de petición que se solicita, que podrá ser será teléfono o email. La segunda Activity antes de visualizarse ocultará el Spinner que corresponda, y el botón “Aceptar” devolverá la información solicitada.
La primera Activity al recibir la respuesta de la segunda mostrará un mensaje Toast con el dato recibido, o bien el texto “No hay datos, el usuario ha cancelado la respuesta”. Nota1: Para que la segunda Activity pueda distinguir entre los dos tipos de peticiones, envía esta información en el Intent. Nota 2: Para ocultar un control, usa el método setVisibility.
4 de 4
...