La clase Activity es un componente fundamental de un dispositivo Android
y la forma en que se lanzan y reúnen las actividades es fundamental
parte del modelo de aplicación de la plataforma. A diferencia de los paradigmas de programación
qué apps se inician con un método main(), la biblioteca
el sistema inicia el código en una instancia Activity
invocar métodos de devolución de llamada específicos que correspondan a etapas específicas de
su ciclo de vida.
En este documento, se introduce el concepto de actividades y se proporciona información una guía sobre cómo trabajar con ellos. Si quieres obtener más información sobre las prácticas recomendadas para diseñar la arquitectura de tu app, consulta lo siguiente: consulta Guía de arquitectura de apps.
El concepto de actividades
La experiencia en la aplicación para dispositivos móviles se diferencia de la versión para computadoras de escritorio en el sentido de que la interacción de un usuario con la aplicación no siempre comienza en el mismo lugar. En este caso, no hay un lugar específico desde donde el usuario comienza su actividad. Por ejemplo, si abres una app de correo electrónico desde tu pantalla principal, es posible que veas un una lista de correos electrónicos. Por el contrario, si usas una app de redes sociales que inicia tu aplicación de correo electrónico, puedes ir directamente a la pantalla de la aplicación de correo electrónico para redactar un correo electrónico.
La clase Activity está diseñada para facilitar este paradigma.
Cuando una app invoca a otra, la app que realiza la llamada invoca a una actividad en la otra
app, en lugar de la app como un todo atómico. De esta manera, la actividad sirve como
el punto de entrada para la interacción de una aplicación con el usuario. Implementas un
como una subclase de la clase Activity.
Una actividad proporciona la ventana en la que se dibuja la app su IU. Por lo general, esta ventana ocupa toda la pantalla, pero puede ser más pequeña que la pantalla y flotar sobre otras ventanas. Por lo general, una actividad implementa una pantalla en una app. Por ejemplo, una de las actividades de una aplicación puede implementarás una pantalla Preferences, mientras que otra actividad implementa una pantalla con la opción Seleccionar foto.
La mayoría de las apps contienen varias pantallas, lo que significa que incluyen varias de datos. Por lo general, una actividad en una app se especifica como la principal actividad, que es la primera pantalla que aparece cuando el usuario inicia la aplicación. Cada actividad puede iniciar otra actividad para hacer lo siguiente: realizar diferentes acciones. Por ejemplo, la actividad principal en un mensaje de correo la aplicación puede mostrar la pantalla que muestra una bandeja de entrada de correo electrónico. A partir de ahí, la principal la actividad podría iniciar otras actividades que proporcionen pantallas para tareas como escribir y abrir mensajes individuales.
Si bien las actividades trabajan juntas para formar una experiencia de usuario cohesiva en un aplicación, cada actividad está ligada únicamente a las demás. existen por lo general, son mínimas dependencias entre las actividades de una app. De hecho, las actividades a menudo inician actividades que pertenecen a otras aplicaciones. Por ejemplo: una app de navegador podría iniciar la actividad de Compartir de una app de redes sociales.
Para usar actividades en tu app, debes registrar información sobre ellas en el manifiesto de la app, y debes administrar los ciclos de vida de las actividades de forma adecuada. En el resto de este documento, se presentan estos temas.
Cómo configurar el manifiesto
Para que tu aplicación pueda usar actividades, debes declararlas. y algunos de sus atributos en el manifiesto.
Cómo declarar actividades
Para declarar tu actividad, abre el archivo de manifiesto y agrega un <actividad> como elemento secundario del <aplicación> . Por ejemplo:
<manifest ... > <application ... > <activity android:name=".ExampleActivity" /> ... </application ... > ... </manifest >
El único atributo obligatorio para este elemento es android:name. que especifica el nombre de clase de la actividad. También puedes agregar atributos que definen características de la actividad, como una etiqueta, un ícono o un tema de IU. Para obtener más información sobre estos y otros atributos, consulta la <actividad> documentación de referencia del elemento.
Nota: Después de publicar la app, ocurrirá lo siguiente: no deberías cambiar la actividad y nombres de usuario. Si lo haces, se pueden romper algunas funcionalidades, como los accesos directos a las apps. Para obtener más información sobre los cambios que debes evitar luego de la publicación, consulta Elementos que no pueden cambiar.
Cómo declarar filtros de intents
Filtros de intents son una función muy poderosa de la plataforma de Android. Ellas proporcionan la capacidad de iniciar una actividad no solo en función de un explícita, pero también implícita. Por ejemplo: una solicitud explícita podría indicar al sistema que debe iniciar la actividad Enviar correo electrónico en la app de Gmail”. Por el contrario, una solicitud implícita le indica a la “Iniciar una pantalla de envío de correo electrónico que pueda realizar el trabajo". Cuando la IU del sistema le pregunta al usuario qué app debe usar para realizar una tarea; ese es un filtro de intents en acción.
Para aprovechar esta función, declara un <filtro de intents> en el <activity>. La definición de este elemento incluye un elemento <action> y De manera opcional, un <categoría> elemento o un <data> . Estos elementos se combinan para especificar el tipo de intent al que puede responder tu actividad. Para ejemplo, el siguiente fragmento de código muestra cómo configurar una actividad que envía datos de texto y recibe solicitudes de otras actividades para hacerlo:
<activity android:name=".ExampleActivity" android:icon="@drawable/app_icon"> <intent-filter> <action android:name="android.intent.action.SEND" /> <category android:name="android.intent.category.DEFAULT" /> <data android:mimeType="text/plain" /> </intent-filter> </activity>
En este
ejemplo, la acción <action>
especifica que esta actividad envía datos.
Declaración de <category>
como DEFAULT habilita la actividad
para recibir solicitudes de lanzamiento. La clase <data>
especifica el tipo de datos que
esta actividad puede enviar. En el siguiente fragmento de código, se muestra cómo llamar al
la actividad descrita anteriormente:
Kotlin
val sendIntent = Intent().apply { action = Intent.ACTION_SEND type = "text/plain" putExtra(Intent.EXTRA_TEXT, textMessage) } startActivity(sendIntent)
Java
// Create the text message with a string Intent sendIntent = new Intent(); sendIntent.setAction(Intent.ACTION_SEND); sendIntent.setType("text/plain"); sendIntent.putExtra(Intent.EXTRA_TEXT, textMessage); // Start the activity startActivity(sendIntent);
Cómo declarar permisos
Puedes usar la base de datos
Etiqueta <activity> para controlar
qué apps pueden iniciar una actividad en particular. Una actividad superior no puede iniciar un
secundaria, a menos que ambas tengan los mismos permisos en su
. Si declaras un
<uses-permission>
elemento principal para una actividad superior, cada actividad secundaria debe tener una coincidencia
<uses-permission>
.
Por ejemplo, si tu app quiere usar una app hipotética llamada SocialApp para compartir una publicación en redes sociales, SocialApp debe definir el permiso que la app que la llame debe tener:
<manifest> <activity android:name="...." android:permission=”com.google.socialapp.permission.SHARE_POST” />
Entonces, para poder llamar a SocialApp, tu aplicación debe coincidir con el permiso establecido en Manifiesto de SocialApp:
<manifest> <uses-permission android:name="com.google.socialapp.permission.SHARE_POST" /> </manifest>
Para obtener más información sobre permisos y seguridad en general, consulta Seguridad y permisos.
Cómo administrar el ciclo de vida de la actividad
A lo largo de su vida útil, una actividad pasa por varios estados. Para administrar las transiciones entre estados, debes usar una serie de devoluciones de llamadas. Las siguientes secciones introducir estas devoluciones de llamada.
onCreate()
Debes implementar esta devolución de llamada, que se activa cuando el sistema crea tu
actividad. Tu implementación debe inicializar los componentes esenciales de
tu actividad: Por ejemplo, tu app debería crear vistas y vincular datos a
se enumeran aquí. Lo más importante es que aquí es donde debes llamar
setContentView()
para definir el diseño de la interfaz de usuario de la actividad.
Cuando onCreate() finaliza, el
La siguiente devolución de llamada siempre es onStart().
onStart()
Cuando se cierra onCreate(), la actividad
entra al estado Started, y la actividad se vuelve visible para el usuario.
Esta devolución de llamada contiene los preparativos finales de la actividad para
que pasan a primer plano y se vuelven interactivos.
onResume()
El sistema invoca esta devolución de llamada justo antes de que la actividad comience a interactuar.
con el usuario. En este punto, la actividad se encuentra en la parte superior.
y captura todas las entradas del usuario. La mayor parte de la funcionalidad principal de una app es
implementada en el método onResume().
La devolución de llamada onPause() siempre
sigue onResume().
onPause()
El sistema llama a onPause() cuando pierde la actividad.
enfoque y entra en el estado Detenida. Este estado se produce, por ejemplo, cuando el usuario
presiona el botón Atrás o Recientes. Cuando el sistema llama
onPause() para tu actividad,
significa técnicamente que tu actividad aún es parcialmente visible, pero la mayoría de las veces es una indicación de que
el usuario abandona la actividad, y esta pronto ingresará al
Estado Detenida o Reanudada
Una actividad en estado Detenida puede continuar con la actualización de la IU si el usuario espera que la IU se actualice. Entre los ejemplos de una actividad de este tipo, se incluye mostrar una navegación una pantalla de mapa o un reproductor multimedia en reproducción. Incluso si tales actividades pierden el enfoque, el usuario espera que su IU continúe actualizándose.
No deberías usar
onPause() para guardar la aplicación o el usuario
realizar llamadas de red o ejecutar transacciones de bases de datos.
Para obtener información sobre el guardado de datos, consulta
Cómo guardar y restablecer el estado de una actividad
Una vez que onPause() termina de ejecutarse,
la siguiente devolución de llamada es onStop() o
onResume(), dependiendo de
sucede una vez que la actividad entra en el estado Detenida.
onStop()
El sistema llama a onStop() cuando el elemento
la actividad ya no está visible para el usuario.
Esto puede suceder porque la actividad se está destruyendo, una nueva actividad se
o una actividad existente está ingresando
Reanudado y cubre la actividad detenida.
En todos estos casos, la actividad detenida ya no se
en absoluto.
La siguiente devolución de llamada que llama el sistema es
onRestart(), si el elemento
la actividad vuelve a interactuar con el usuario o
onDestroy()
si esta actividad finaliza por completo.
onRestart()
El sistema invoca esta devolución de llamada cuando se detiene una actividad en el estado Detenida
a punto de reiniciarse. onRestart()
Restablece el estado de la actividad desde el momento en que esta se detuvo.
A esta devolución de llamada siempre le sigue
onStart()
onDestroy()
El sistema invoca esta devolución de llamada antes de que finalice una actividad.
Esta devolución de llamada es la última que recibe la actividad.
onDestroy() es
que suelen implementarse para garantizar que todos los recursos de una actividad estén
se liberan cuando se destruye la actividad, o el proceso que la contiene.
En esta sección, solo se proporciona una introducción a este tema. Para obtener un tratamiento detallado del ciclo de vida de la actividad y sus devoluciones de llamada consulta La actividad Lifecycle.