Android
Actividad

Introducción

Sintaxis

• void onCreate (Bundle savedInstanceState) // Se invoca cuando se inicia la actividad.

• void onPostCreate (Bundle savedInstanceState) // Llamado cuando se completa el inicio de la actividad (después de que se haya llamado a onStart () y onRestoreInstanceState (Bundle)).

• void onStart () // Llamado después de onCreate (Bundle) - o después de onRestart () cuando se detuvo la actividad, pero ahora se muestra nuevamente al usuario.

• void onResume () // Llamado después de onRestoreInstanceState (Bundle), onRestart () o onPause (), para que su actividad comience a interactuar con el usuario.

• void onPostResume () // Llamado cuando se completa la reanudación de la actividad (después de que se haya llamado a onResume ()).

• void onRestart () // Llamado después de onStop () cuando la actividad actual se muestra nuevamente al usuario (el usuario ha regresado a ella).

• void onPause () // Llamado como parte del ciclo de vida de la actividad cuando una actividad se pone en segundo plano, pero no se ha eliminado (todavía).

• void onStop () // Llamado cuando ya no eres visible para el usuario.

• void onDestroy () // Realice cualquier limpieza final antes de que se destruya una actividad.

• void onNewIntent (Intención de intención) // Esto se llama para actividades que configuran launchMode en "singleTop" en su paquete, o si un cliente usó el indicador FLAG_ACTIVITY_SINGLE_TOP al llamar a startActivity (Intent).

• void onSaveInstanceState (Bundle outState) // Llamado para recuperar el estado por instancia de una actividad antes de eliminarse para que el estado se pueda restaurar en onCreate (Bundle) o onRestoreInstanceState (Bundle) (el Bundle completado por este método se pasará a ambos ).

• void onRestoreInstanceState (Bundle savedInstanceState) // Este método se llama después de onStart () cuando la actividad se está reinicializando desde un estado previamente guardado, que se proporciona aquí en savedInstanceState.

Parámetros

Observaciones

Excluir una actividad del historial de back-stack

Deje que haya una Actividad B que pueda abrirse y que pueda iniciar más Actividades. Pero, el usuario no debe encontrarlo cuando navega hacia atrás en las actividades de tareas.

La solución más sencilla es establecer el atributo noHistory en true para esa etiqueta <activity> en AndroidManifest.xml :

<activity
     android:name=".B"
     android:noHistory="true">

Este mismo comportamiento también es posible desde el código si B llama a finish() antes de comenzar la siguiente actividad:

finish();
startActivity(new Intent(context, C.class));

El uso típico de la bandera noHistory es con "Pantalla de inicio" o Actividades de inicio de sesión.

Actividad de Android LifeCycle explicó

Supongamos una aplicación con MainActivity que puede llamar a la siguiente actividad con un clic del botón.

public class MainActivity extends AppCompatActivity {

    private final String LOG_TAG = MainActivity.class.getSimpleName();
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Log.d(LOG_TAG, "calling onCreate from MainActivity");
    }
    @Override
    protected void onStart() {
        super.onStart();
        Log.d(LOG_TAG, "calling onStart from MainActivity");
    }
    @Override
    protected void onResume() {
        super.onResume();
        Log.d(LOG_TAG, "calling onResume  from MainActivity");
    }

    @Override
    protected void onPause() {
        super.onPause();
        Log.d(LOG_TAG, "calling onPause  from MainActivity");
    }

    @Override
    protected void onStop() {
        super.onStop();
        Log.d(LOG_TAG, "calling onStop  from MainActivity");
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        Log.d(LOG_TAG, "calling onDestroy  from MainActivity");
    }

    @Override
    protected void onRestart() {
        super.onRestart();
        Log.d(LOG_TAG, "calling onRestart  from MainActivity");
    }
    public void toNextActivity(){
        Log.d(LOG_TAG, "calling Next Activity");
        Intent intent = new Intent(this, NextActivity.class);
        startActivity(intent);
    } }

y

public class NextActivity extends AppCompatActivity {
    private final String LOG_TAG = NextActivity.class.getSimpleName();
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_next);
        Log.d(LOG_TAG, "calling onCreate from Next Activity");
    }
    @Override
    protected void onStart() {
        super.onStart();
        Log.d(LOG_TAG, "calling onStart from Next Activity");
    }
    @Override
    protected void onResume() {
        super.onResume();
        Log.d(LOG_TAG, "calling onResume  from Next Activity");
    }

    @Override
    protected void onPause() {
        super.onPause();
        Log.d(LOG_TAG, "calling onPause  from Next Activity");
    }

    @Override
    protected void onStop() {
        super.onStop();
        Log.d(LOG_TAG, "calling onStop  from Next Activity");
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        Log.d(LOG_TAG, "calling onDestroy  from Next Activity");
    }

    @Override
    protected void onRestart() {
        super.onRestart();
        Log.d(LOG_TAG, "calling onRestart  from Next Activity");
    } }

Cuando la aplicación se crea por primera vez
D / MainActivity: llamando a onCreate desde MainActivity
D / MainActivity: llamar a OnStart desde MainActivity
D / MainActivity: llamada onResume desde MainActivity
son llamados

Cuando la pantalla duerme
08: 11: 03.142 D / MainActivity: llamada onPause desde MainActivity
08: 11: 03.192 D / MainActivity: llamando a Stop desde MainActivity
son llamados. Y otra vez cuando se despierta.
08: 11: 55.922 D / MainActivity: llamando onRestart desde MainActivity
08: 11: 55.962 D / MainActivity: llamar a OnStart desde MainActivity
08: 11: 55.962 D / MainActivity: llamada onResume desde MainActivity
son llamados

Caso 1: cuando se llama a la siguiente actividad desde la actividad principal
D / MainActivity: llamando a la siguiente actividad
D / MainActivity: llamada onPause desde MainActivity
D / NextActivity: llamando a Crear desde la próxima actividad
D / NextActivity: llamar a OnStart desde la siguiente actividad
D / NextActivity: llamando a Currículum de la siguiente actividad
D / MainActivity: llamando a onStop desde MainActivity

Cuando regrese a la actividad principal de la siguiente actividad con el botón de retroceso
D / NextActivity: llamar en pausa desde la siguiente actividad
D / MainActivity: llamando a onRestart desde MainActivity
D / MainActivity: llamar a OnStart desde MainActivity
D / MainActivity: llamada onResume desde MainActivity
D / Próxima actividad: llamar a Stop desde la próxima actividad
D / Próxima actividad: llamar a destruir en la próxima actividad

Caso 2: cuando la actividad está parcialmente oculta (cuando se presiona el botón de vista general) o cuando la aplicación pasa al fondo y otra aplicación la oculta por completo
D / MainActivity: llamada onPause desde MainActivity
D / MainActivity: llamando a onStop desde MainActivity
y cuando la aplicación vuelva a estar en primer plano, lista para aceptar entradas de usuario,
D / MainActivity: llamando a onRestart desde MainActivity
D / MainActivity: llamar a OnStart desde MainActivity
D / MainActivity: llamada onResume desde MainActivity
son llamados

Caso3: cuando se llama a una actividad para cumplir una intención implícita y el usuario ha realizado una selección. Por ejemplo, cuando se presiona el botón Compartir y el usuario tiene que seleccionar una aplicación de la lista de aplicaciones que se muestra
D / MainActivity: llamada onPause desde MainActivity

La actividad es visible pero no está activa ahora. Cuando se realiza la selección y la aplicación está activa.
D / MainActivity: llamada onResume desde MainActivity
se llama

Caso4:
Cuando la aplicación se elimine en segundo plano (para liberar recursos para otra aplicación en primer plano), onPause (para el dispositivo anterior al panal) o onStop (ya que se trata de un dispositivo con forma de panal) será la última llamada antes de que finalice la aplicación.

onCreate y onDestroy se llamarán mayor cada vez que se ejecute la aplicación. Pero el onPause, onStop, onRestart, onStart, onResume puede ser llamado muchas veces durante el ciclo de vida.

Actividad launchMode

El modo de inicio define el comportamiento de la actividad nueva o existente en la tarea.
Hay posibles modos de lanzamiento:

• estándar
• singleTop
• sola tarea
• única instancia

Se debe definir en el manifiesto de Android en el elemento <activity/> como atributo android:launchMode .

<activity
    android:launchMode=["standard" | "singleTop" | "singleTask" | "singleInstance"] />

Estándar:

Valor por defecto. Si se establece este modo, siempre se creará una nueva actividad para cada nuevo intento. Así que es posible realizar muchas actividades del mismo tipo. La nueva actividad se colocará en la parte superior de la tarea. Hay algunas diferencias para diferentes versiones de Android: si la actividad se inicia desde otra aplicación, en androides <= 4.4 se colocará en la misma tarea que la aplicación de inicio, pero en> = 5.0 se creará una nueva tarea.

SingleTop:

Este modo es casi el mismo que el standard . Se podrían crear muchas instancias de actividad singleTop. La diferencia es que, si ya existe una instancia de actividad en la parte superior de la pila actual, se onNewIntent() lugar de crear una nueva instancia.

SingleTask:

La actividad con este modo de inicio solo puede tener una instancia en el sistema . Se creará una nueva tarea para la actividad, si no existe. De lo contrario, la tarea con actividad se moverá al frente y se onNewIntent .

Única instancia:

Este modo es similar a singleTask . La diferencia es que la tarea que contiene una actividad con singleInstance podría tener solo esta actividad y nada más. Cuando la actividad singleInstance crea otra actividad, se creará una nueva tarea para colocar esa actividad.

Presentando UI con setContentView

La clase de actividad se encarga de crear una ventana para ti en la que puedes colocar tu IU con setContentView .
Hay tres métodos setContentView :

• setContentView(int layoutResID) : establece el contenido de la actividad a partir de un recurso de diseño.
• setContentView(View view) : establece el contenido de la actividad en una vista explícita.
• setContentView(View view, ViewGroup.LayoutParams params) : establece el contenido de la actividad en una vista explícita con los parámetros proporcionados.

Cuando se llama a setContentView , esta vista se coloca directamente en la jerarquía de vistas de la actividad. Puede ser una jerarquía de vista compleja.

Ejemplos

Establecer contenido desde el archivo de recursos:

<?xml version="1.0" encoding="utf-8"?>
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent" >

    <TextView android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Hello" /> 

</FrameLayout>

Establézcalo como contenido en actividad:

public final class MainActivity extends Activity {

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        // The resource will be inflated, 
        // adding all top-level views to the activity.
        setContentView(R.layout.main);
    }
}

Establecer contenido a una vista explícita:

public final class MainActivity extends Activity {

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        // Creating view with container
        final FrameLayout root = new FrameLayout(this);
        final TextView text = new TextView(this);
        text.setText("Hello");
        root.addView(text);

        // Set container as content view
        setContentView(root);
    }
}

Borra tu pila de actividades actual y lanza una nueva actividad

Si desea borrar su pila de actividades actual e iniciar una nueva actividad (por ejemplo, cerrar la sesión de la aplicación e iniciar un inicio de sesión en la actividad), parece haber dos enfoques.

1. Destino (API> = 16)

Llamando a finishAffinity() desde una actividad

2. Objetivo (11 <= API <16)

Intent intent = new Intent(this, LoginActivity.class);
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK |Intent.FLAG_ACTIVITY_CLEAR_TOP);
startActivity(intent);
finish();

Finalizar la aplicación con excluir de Recientes

Primero defina una ExitActivity en el AndroidManifest.xml

<activity
        android:name="com.your_example_app.activities.ExitActivity"
        android:autoRemoveFromRecents="true"
        android:theme="@android:style/Theme.NoDisplay" />

Después la clase ExitActivity

/**
 * Activity to exit Application without staying in the stack of last opened applications
 */
public class ExitActivity extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        if (Utils.hasLollipop()) {
            finishAndRemoveTask();
        } else if (Utils.hasJellyBean()) {
            finishAffinity();
        } else {
            finish();
        }
    }

   /**
    * Exit Application and Exclude from Recents
    *
    * @param context Context to use
    */
    public static void exitApplication(ApplicationContext context) {
        Intent intent = new Intent(context, ExitActivity.class);
        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK | Intent.FLAG_ACTIVITY_NO_ANIMATION | Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS);
        context.startActivity(intent);
    }
}

Navegación para actividades

La navegación hacia arriba se realiza en Android agregando android:parentActivityName="" en Manifest.xml a la etiqueta de actividad. Básicamente, con esta etiqueta usted le dice al sistema sobre la actividad principal de una actividad.

Como se hace

<uses-permission android:name="android.permission.INTERNET" />

<application
    android:name=".SkillSchoolApplication"
    android:allowBackup="true"
    android:icon="@mipmap/ic_launcher"
    android:label="@string/app_name"
    android:supportsRtl="true"
    android:theme="@style/AppTheme">
    <activity
        android:name=".ui.activities.SplashActivity"
        android:theme="@style/SplashTheme">
        <intent-filter>
            <action android:name="android.intent.action.MAIN" />

            <category android:name="android.intent.category.LAUNCHER" />
        </intent-filter>
    </activity>
    <activity android:name=".ui.activities.MainActivity" />
    <activity android:name=".ui.activities.HomeActivity"
     android:parentActivityName=".ui.activities.MainActivity/> // HERE I JUST TOLD THE SYSTEM THAT MainActivity is the parent of HomeActivity
</application>

Ahora, cuando haga clic en la flecha dentro de la barra de herramientas de HomeActivity, volveré a la actividad principal.

Código Java

Aquí escribiré el código java apropiado requerido para esta funcionalidad.

public class HomeActivity extends AppCompatActivity {
    @BindView(R.id.toolbar)
    Toolbar toolbar;    

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_home);
        ButterKnife.bind(this);
        //Since i am using custom tool bar i am setting refernce of that toolbar to Actionbar. If you are not using custom then you can simple leave this and move to next line
        setSupportActionBar(toolbar); 
        getSupportActionBar.setDisplayHomeAsUpEnabled(true); // this will show the back arrow in the tool bar.
}
}

Si ejecuta este código, verá que cuando presiona el botón Atrás, volverá a MainActivity. Para una mayor comprensión de la navegación hacia arriba recomendaría leer documentos

Puede personalizar más este comportamiento según sus necesidades al anular

@Override
public boolean onOptionsItemSelected(MenuItem item) {
    switch (item.getItemId()) {
    // Respond to the action bar's Up/Home button
    case android.R.id.home:
        NavUtils.navigateUpFromSameTask(this); // Here you will write your logic for handling up navigation
        return true;
    }
    return super.onOptionsItemSelected(item);
}

Hack simple

Este es un truco simple que se usa principalmente para navegar a la actividad principal si el padre está en backstack. Al llamar a onBackPressed() si id es igual a android.R.id.home

@Override
    public boolean onOptionsItemSelected(MenuItem item) {
        int id = item.getItemId();
        switch (id) {
            case android.R.id.home:
                onBackPressed();
                return true;
        }
        return super.onOptionsItemSelected(item);
    }