Android
Activité

Introduction

Syntaxe

• annuler onCreate (Bundle savedInstanceState) // Appelé au démarrage de l'activité.

• void onPostCreate (Bundle savedInstanceState) // Appelé à la fin du démarrage de l'activité (après onStart () et onRestoreInstanceState (Bundle) ont été appelés).

• void onStart () // Appelé après onCreate (Bundle) - ou après onRestart () lorsque l'activité a été arrêtée, mais est à nouveau affichée pour l'utilisateur.

• void onResume () // Appelé après onRestoreInstanceState (Bundle), onRestart () ou onPause (), pour que votre activité commence à interagir avec l'utilisateur.

• void onPostResume () // Appelé lorsque l'activité est terminée (après l'appel de onResume ()).

• void onRestart () // Appelé après onStop () lorsque l'activité en cours est affichée à nouveau pour l'utilisateur (l'utilisateur y est retourné).

• void onPause () // Appelé dans le cadre du cycle de vie d'une activité lorsqu'une activité est en arrière-plan, mais n'a pas encore été tué.

• void onStop () // Appelé lorsque l'utilisateur n'est plus visible.

• void onDestroy () // Effectue tout nettoyage final avant la destruction d'une activité.

• void onNewIntent (Intention intentionnelle) // Ceci est appelé pour les activités qui définissent launchMode sur "singleTop" dans leur package, ou si un client a utilisé l'indicateur FLAG_ACTIVITY_SINGLE_TOP lors de l'appel de startActivity (Intent).

• annulez onSaveInstanceState (Bundle outState) // Appelé pour récupérer l'état par instance d'une activité avant d'être tué pour que l'état puisse être restauré dans onCreate (Bundle) ou onRestoreInstanceState (Bundle) (le Bundle rempli par cette méthode sera transmis aux deux ).

• void onRestoreInstanceState (Bundle savedInstanceState) // Cette méthode est appelée après onStart () lorsque l'activité est en cours de réinitialisation à partir d'un état précédemment enregistré, donné ici dans savedInstanceState.

Paramètres

Remarques

Exclure une activité de l'historique de la pile arrière

Que l'activité B puisse être ouverte et que d'autres activités puissent être lancées. Mais l'utilisateur ne devrait pas le rencontrer lors de la navigation dans les activités de tâche.

La solution la plus simple consiste à définir l'attribut noHistory sur true pour cette <activity> dans AndroidManifest.xml :

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

Ce même comportement est également possible à partir du code si B appelle finish() avant de démarrer l'activité suivante:

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

L'utilisation typique du drapeau noHistory est avec "Splash Screen" ou Login Activities.

Activité Android Explication de LifeCycle

Supposons une application avec une MainActivity qui puisse appeler l'activité suivante en cliquant sur un bouton.

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

et

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

Lorsque l'application est créée pour la première fois
D / MainActivity: appel de onCreate à partir de MainActivity
D / MainActivity: appel de onStart depuis MainActivity
D / MainActivity: appel à onResume à partir de MainActivity
sont appelés

Quand l'écran dort
08: 11: 03.142 D / MainActivity: appel de onPause à partir de MainActivity
08: 11: 03.192 D / MainActivity: appel de onStop depuis MainActivity
sont appelés. Et encore quand il se réveille
08: 11: 55.922 D / MainActivity: appel de onRestart à partir de MainActivity
08: 11: 55.962 D / MainActivity: appel de onStart depuis MainActivity
08: 11: 55.962 D / MainActivity: appel de onResume à partir de MainActivity
sont appelés

Cas 1: quand l'activité suivante est appelée à partir de l'activité principale
D / MainActivity: appel à l'activité suivante
D / MainActivity: appel de onPause à partir de MainActivity
D / NextActivity: appeler onCreate à partir de l'activité suivante
D / NextActivity: appel de onStart à partir de l'activité suivante
D / NextActivity: appeler onResume à partir de l'activité suivante
D / MainActivity: appel de onStop depuis MainActivity

Lorsque vous revenez à l'activité principale à partir de l'activité suivante à l'aide du bouton retour
D / NextActivity: appeler onPause à partir de l'activité suivante
D / MainActivity: appeler onRestart à partir de MainActivity
D / MainActivity: appel de onStart depuis MainActivity
D / MainActivity: appel à onResume à partir de MainActivity
D / NextActivity: appeler onStop à partir de l'activité suivante
D / NextActivity: appeler onDestroy à partir de l'activité suivante

Cas 2: Lorsque l'activité est partiellement masquée (lorsque le bouton Vue d'ensemble est enfoncé) ou lorsque l'application passe en arrière-plan et qu'une autre application la masque complètement
D / MainActivity: appel de onPause à partir de MainActivity
D / MainActivity: appel de onStop depuis MainActivity
et lorsque l'application est de retour au premier plan prête à accepter les entrées utilisateur,
D / MainActivity: appeler onRestart à partir de MainActivity
D / MainActivity: appel de onStart depuis MainActivity
D / MainActivity: appel à onResume à partir de MainActivity
sont appelés

Cas 3: Lorsqu'une activité est appelée pour remplir une intention implicite et que l'utilisateur a effectué une sélection. Par exemple, lorsque vous appuyez sur le bouton Partager et que l'utilisateur doit sélectionner une application dans la liste des applications affichées
D / MainActivity: appel de onPause à partir de MainActivity

L'activité est visible mais pas active maintenant. Lorsque la sélection est terminée et que l'application est active
D / MainActivity: appel à onResume à partir de MainActivity
est appelé

Cas4:
Lorsque l'application est tuée en arrière-plan (pour libérer des ressources pour une autre application au premier plan), onPause (pour le périphérique pré-en nid d'abeilles) ou onStop (pour le périphérique en nid d'abeille) sera le dernier à être appelé avant la fin de l'application.

onCreate et onDestroy seront appelés au maximum une fois à chaque exécution de l'application. Mais onPause, onStop, onRestart, onStart, onResume peuvent être appelés plusieurs fois au cours du cycle de vie.

Mode de lancement d'activité

Le mode de lancement définit le comportement d'une activité nouvelle ou existante dans la tâche.
Il existe des modes de lancement possibles:

• la norme
• unique
• singleTask
• seule instance

Il doit être défini dans le manifeste Android dans l'élément <activity/> tant android:launchMode .

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

La norme:

Valeur par défaut. Si ce mode est défini, une nouvelle activité sera toujours créée pour chaque nouvelle intention. Il est donc possible d'obtenir de nombreuses activités du même type. Une nouvelle activité sera placée en haut de la tâche. Il existe une différence pour les différentes versions d'Android: si l'activité commence à partir d'une autre application, sur les androïdes <= 4.4, elle sera placée dans la même tâche que l'application de démarrage, mais la nouvelle tâche> = 5.0 sera créée.

SingleTop:

Ce mode est presque identique à la standard . De nombreuses instances d'activité singleTop peuvent être créées. La différence est que, si une instance d'activité existe déjà en haut de la pile en cours, onNewIntent() sera appelé au lieu de créer une nouvelle instance.

SingleTask:

L'activité avec ce mode de lancement ne peut avoir qu'une seule instance dans le système . Une nouvelle tâche pour l'activité sera créée, si elle n'existe pas. Sinon, la tâche avec activité sera déplacée vers l'avant et onNewIntent sera appelée.

Seule instance:

Ce mode est similaire à singleTask . La différence est que la tâche qui détient une activité avec singleInstance ne peut avoir que cette activité et rien de plus. Lorsque l'activité d' singleInstance crée une autre activité, une nouvelle tâche sera créée pour placer cette activité.

Présentation de l'interface utilisateur avec setContentView

La classe d'activité prend soin de créer une fenêtre dans laquelle vous pouvez placer votre interface utilisateur avec setContentView .
Il existe trois méthodes setContentView :

• setContentView(int layoutResID) - Définit le contenu de l'activité à partir d'une ressource de présentation.
• setContentView(View view) - Définit le contenu de l'activité sur une vue explicite.
• setContentView(View view, ViewGroup.LayoutParams params) - Définit le contenu de l'activité sur une vue explicite avec les paramètres fournis.

Lorsque setContentView est appelée, cette vue est placée directement dans la hiérarchie de vues de l'activité. Elle peut elle-même être une hiérarchie de vues complexe.

Exemples

Définir le contenu du fichier de ressources:

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

Définissez-le comme contenu dans l'activité:

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

Définir le contenu à une vue explicite:

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

Effacer votre pile d'activité actuelle et lancer une nouvelle activité

Si vous souhaitez effacer votre pile d'activité actuelle et lancer une nouvelle activité (par exemple, vous déconnecter de l'application et lancer une activité de connexion), il semble qu'il y ait deux approches.

1. Cible (API> = 16)

Appeler finishAffinity() partir d'une activité

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

Fin de l'application avec exclure des Récents

Définissez d'abord une ExitActivity dans AndroidManifest.xml

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

Après 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);
    }
}

Up Navigation pour les activités

La navigation haut s'effectue dans Android en ajoutant android:parentActivityName="" dans Manifest.xml à la balise d'activité. Avec cette balise, vous indiquez au système l'activité parentale d'une activité.

Comment est-il fait?

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

Maintenant, quand je clique sur la flèche dans la barre d'outils de HomeActivity, cela me ramène à l'activité parent.

Code Java

Ici, je vais écrire le code Java approprié pour cette fonctionnalité.

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 vous exécutez ce code, vous verrez que lorsque vous appuyez sur le bouton retour, vous revenez à MainActivity. Pour une meilleure compréhension de Up Navigation, je vous recommande de lire docs

Vous pouvez plus personnaliser ce comportement selon vos besoins en remplaçant

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

Piratage simple

C'est un simple hack qui est principalement utilisé pour naviguer vers l'activité parent si le parent est en backstack. En appelant onBackPressed() si id est égal à 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);
    }