Android
Attività

introduzione

Sintassi

• void onCreate (Bundle savedInstanceState) // Chiamato all'avvio dell'attività.

• void onPostCreate (Bundle savedInstanceState) // Chiamato quando l'avvio dell'attività è completo (dopo che onStart () e onRestoreInstanceState (Bundle) sono stati chiamati).

• void onStart () // Chiamato dopo onCreate (Bundle) - o after onRestart () quando l'attività è stata interrotta, ma ora viene nuovamente visualizzata all'utente.

• void onResume () // Chiamato dopo onRestoreInstanceState (Bundle), onRestart () o onPause (), affinché l'attività inizi a interagire con l'utente.

• void onPostResume () // Chiamato quando l'attività riprende è completa (dopo che onResume () è stato chiamato).

• void onRestart () // Chiamato dopo onStop () quando l'attività corrente viene nuovamente visualizzata all'utente (l'utente è tornato indietro).

• void onPause () // Chiamato come parte del ciclo di vita dell'attività quando un'attività sta andando in background, ma non è (ancora) stata uccisa.

• void onStop () // Chiamato quando non sei più visibile all'utente.

• void onDestroy () // Esegue qualsiasi pulizia finale prima che un'attività venga distrutta.

• void onNewIntent (Intent intent) // Questo è chiamato per le attività che impostano launchMode su "singleTop" nel loro pacchetto, o se un client usa il flag FLAG_ACTIVITY_SINGLE_TOP quando chiama startActivity (Intent).

• void onSaveInstanceState (Bundle outState) // Chiamato per recuperare lo stato per-instance da un'attività prima di essere ucciso in modo che lo stato possa essere ripristinato in onCreate (Bundle) o onRestoreInstanceState (Bundle) (il pacchetto popolato da questo metodo verrà passato ad entrambi ).

• void onRestoreInstanceState (Bundle savedInstanceState) // Questo metodo viene chiamato dopo onStart () quando l'attività viene reinizializzata da uno stato precedentemente salvato, indicato qui in savedInstanceState.

Parametri

Osservazioni

Escludere un'attività dalla cronologia dello stack

Lascia che ci sia l'attività B che può essere aperta e può avviare ulteriori attività. Ma l'utente non dovrebbe incontrarlo durante la navigazione nelle attività dell'attività.

La soluzione più semplice è impostare l'attributo noHistory su true per quel tag <activity> in AndroidManifest.xml :

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

Questo stesso comportamento è anche possibile dal codice se B chiama finish() prima di iniziare la prossima attività:

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

L'uso tipico del flag noHistory è con "Splash Screen" o attività di accesso.

Spiegazione del LifeCycle dell'attività Android

Assumi un'applicazione con MainActivity che può chiamare l'attività successiva utilizzando un clic del pulsante.

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);
    } }

e

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");
    } }

Quando viene creata per la prima volta l'app
D / MainActivity: call onCreate da MainActivity
D / MainActivity: chiamando onStart da MainActivity
D / MainActivity: chiamata su Riduci da MainActivity
sono chiamati

Quando lo schermo dorme
08: 11: 03.142 D / MainActivity: chiamata onPause da MainActivity
08: 11: 03.192 D / MainActivity: chiamata onStop da MainActivity
sono chiamati. E ancora quando si sveglia
08: 11: 55.922 D / MainActivity: chiamata onRestart da MainActivity
08: 11: 55.962 D / MainActivity: chiamata onStart da MainActivity
08: 11: 55.962 D / MainActivity: chiamata su Riduci da MainActivity
sono chiamati

Caso 1: quando viene chiamata l'attività successiva dall'attività principale
D / MainActivity: chiamata Attività successiva
D / MainActivity: chiamata onPause da MainActivity
D / NextActivity: chiamando onCreate dalla prossima attività
D / NextActivity: chiamata onStart da Attività successiva
D / NextActivity: chiamata su Riduci dall'attività successiva
D / MainActivity: chiamata onStop da MainActivity

Quando si ritorna all'attività principale dalla prossima attività usando il pulsante Indietro
D / NextActivity: chiamata onPause da attività successiva
D / MainActivity: chiamando onRestart da MainActivity
D / MainActivity: chiamando onStart da MainActivity
D / MainActivity: chiamata su Riduci da MainActivity
D / NextActivity: chiamata onStop dall'attività successiva
D / NextActivity: chiama onDestroy dall'attività successiva

Caso 2: Quando l'attività è parzialmente oscurata (quando viene premuto il pulsante di panoramica) o Quando l'app passa allo sfondo e un'altra app la oscura completamente
D / MainActivity: chiamata onPause da MainActivity
D / MainActivity: chiamata onStop da MainActivity
e quando l'app è tornata in primo piano pronta ad accettare input utente,
D / MainActivity: chiamando onRestart da MainActivity
D / MainActivity: chiamando onStart da MainActivity
D / MainActivity: chiamata su Riduci da MainActivity
sono chiamati

Caso 3: quando viene chiamata un'attività per soddisfare l'intenzione implicita e l'utente ha effettuato una selezione. Ad esempio, quando viene premuto il pulsante di condivisione e l'utente deve selezionare un'app dall'elenco di applicazioni visualizzate
D / MainActivity: chiamata onPause da MainActivity

L'attività è visibile ma non attiva ora. Quando la selezione è completata e l'app è attiva
D / MainActivity: chiamata su Riduci da MainActivity
è chiamato

case4:
Quando l'app viene uccisa in background (per liberare risorse per un'altra app in primo piano), onPause (per dispositivo pre-honeycomb) o onStop (per poiché dispositivo a nido d'ape) sarà l'ultimo ad essere chiamato prima che l'app venga terminata.

onCreate e onDestroy verranno chiamati al massimo una volta ogni volta che viene eseguita l'applicazione. Ma onPause, onStop, onRestart, onStart, onResume possono essere chiamati più volte durante il ciclo di vita.

Activity launchMode

La modalità di avvio definisce il comportamento dell'attività nuova o esistente nell'attività.
Ci sono possibili modalità di lancio:

• standard
• singleTop
• singleTask
• singola istanza

Dovrebbe essere definito in Android manifest in <activity/> element come android:launchMode attributo android:launchMode .

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

Standard:

Valore predefinito. Se questa modalità è impostata, verrà sempre creata una nuova attività per ogni nuovo intento. Quindi è possibile ottenere molte attività dello stesso tipo. La nuova attività verrà posizionata nella parte superiore dell'attività. C'è qualche differenza per le diverse versioni di Android: se l'attività parte da un'altra applicazione, su androidi <= 4.4 verrà messa sullo stesso compito dell'applicazione starter, ma su> = 5.0 verrà creata una nuova attività.

SingleTop:

Questa modalità è quasi la stessa dello standard . Potrebbero essere create molte istanze di attività singleTop. La differenza è che se un'istanza di attività esiste già nella parte superiore dello stack corrente, verrà chiamato onNewIntent() anziché creare una nuova istanza.

SingleTask:

L'attività con questa modalità di avvio può avere solo un'istanza nel sistema . Verrà creata una nuova attività per attività, se non esiste. In caso contrario, l'attività con l'attività verrà spostata in primo piano e verrà chiamato onNewIntent .

Singola istanza:

Questa modalità è simile a singleTask . La differenza è un'attività che contiene un'attività con singleInstance potrebbe avere solo questa attività e nient'altro. Quando singleInstance attività singleInstance crea un'altra attività, verrà creata una nuova attività per posizionarla.

Presentazione dell'interfaccia utente con setContentView

La classe di attività si occupa di creare una finestra per te in cui puoi posizionare l'interfaccia utente con setContentView .
Esistono tre metodi setContentView :

• setContentView(int layoutResID) - Imposta il contenuto dell'attività da una risorsa di layout.
• setContentView(View view) - Imposta il contenuto dell'attività su una vista esplicita.
• setContentView(View view, ViewGroup.LayoutParams params) - Imposta il contenuto dell'attività su una vista esplicita con i parametri forniti.

Quando viene chiamato setContentView , questa vista viene posizionata direttamente nella gerarchia della vista dell'attività. Può essere essa stessa una complessa gerarchia delle visualizzazioni.

Esempi

Imposta il contenuto dal file di risorse:

<?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>

Impostalo come contenuto nell'attività:

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);
    }
}

Imposta il contenuto su una vista esplicita:

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);
    }
}

Cancella il tuo attuale stack di attività e avvia una nuova attività

Se vuoi cancellare il tuo attuale stack di attività e avviare una nuova attività (ad esempio, disconnettendo l'app e avviando un log in Activity), sembrano esserci due approcci.

1. Target (API> = 16)

Chiamando finishAffinity() da un'attività

2. Target (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();

Termina l'applicazione con l'esclusione da Recenti

Definire innanzitutto un'AbilitàAttività in AndroidManifest.xml

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

Successivamente la classe 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);
    }
}

Navigazione verso l'alto per le attività

La navigazione verso l'alto viene eseguita in Android aggiungendo android:parentActivityName="" in Manifest.xml al tag attività. Fondamentalmente con questo tag si indica al sistema l'attività principale di un'attività.

Com'è fatto?

<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>

Ora quando cliccherò sulla freccia all'interno della barra degli strumenti di HomeActivity tornerò all'attività principale.

Codice Java

Qui scriverò il codice java appropriato richiesto per questa funzionalità.

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.
}
}

Se esegui questo codice, vedrai quando premi il pulsante indietro per tornare a MainActivity. Per una migliore comprensione di Up Navigation consiglio di leggere i documenti

Puoi personalizzare maggiormente questo comportamento in base alle tue esigenze ignorando

@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 semplice

Questa è una semplice modifica che viene principalmente utilizzata per navigare nell'attività dei genitori se il genitore si trova nel backstack. Chiamando onBackPressed() se id è uguale 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);
    }