Les activités sont un élément fondamental du développement d'Android. Une activité encapsule un écran avec lequel l'utilisateur interagit. Les activités contiennent généralement des composants avec lesquels l'utilisateur doit interagir. Il peut s'agir de boutons, de listes, de textes d'édition, etc. L'activité a cependant son propre cycle de vie et vous pouvez écouter les événements émis par l'activité par le biais de méthodes de cycle de vie.

Dans ce tutoriel, nous apprenons ces méthodes de cycle de vie de manière pratique en écrivant du code qui fait quelque chose quand un tel événement est soulevé.

(a). Créer une application qui répertorie les méthodes de cycle de vie des activités en Kotlin

Dans cet exemple, vous apprendrez l'interaction de base avec ces méthodes. Nous montrons un simple message de toast quand un tel événement est soulevé.

Nous utilisons android studio et kotlin

Étape 1 : Dépendances

Aucune dépendance n'est nécessaire pour ce projet.

Étape 2 : Code Kotlin

Commencez par créer un fichier nommé MaiActivity.kt.

MainActivity.kt

Puis ajoutez des imports :

import android.os.Bundle
import android.util.Log
import androidx.appcompat.app.AppCompatActivity
import kotlinx.android.synthetic.main.activity_main.*
import java.lang.StringBuilder

Puis étendez l'AppCompatActivity :

class MainActivity : AppCompatActivity() {
    //

La première méthode de cycle de vie que nous surchargeons est la méthode onCreate(). Elle est levée lorsque l'activité est créée pour la première fois. Nous allons gonfler notre layout xml ici. Puis nous ajouterons du texte à notre générateur de texte. Puis afficher le texte dans une vue de texte.

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        sb.append("\n onCreate Called")
        tv.text = sb.toString()
        Log.d("ACTIVITY_LIFECYCLE", "onCreate Called")
    }

Nous surchargeons ensuite notre onStart(). Ceci est levé lorsque l'activité est démarrée et devient visible pour l'utilisation :


    override fun onStart() {
        super.onStart()
        sb.append("\n onStart Called")
        tv.text = sb.toString()
        Log.d("ACTIVITY_LIFECYCLE", "onStart Called")
    }

Et ainsi de suite.

Voici le code complet :

package info.camposha.activitylifecycle

import android.os.Bundle
import android.util.Log
import androidx.appcompat.app.AppCompatActivity
import kotlinx.android.synthetic.main.activity_main.*
import java.lang.StringBuilder

class MainActivity : AppCompatActivity() {
    val sb: StringBuilder = StringBuilder()
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        sb.append("\n onCreate Called")
        tv.text = sb.toString()
        Log.d("ACTIVITY_LIFECYCLE", "onCreate Called")
    }

    override fun onStart() {
        super.onStart()
        sb.append("\n onStart Called")
        tv.text = sb.toString()
        Log.d("ACTIVITY_LIFECYCLE", "onStart Called")
    }

    override fun onResume() {
        super.onResume()
        sb.append("\n onResume Called")
        tv.text = sb.toString()
        Log.d("ACTIVITY_LIFECYCLE", "onResume Called")
    }

    override fun onPause() {
        super.onPause()
        sb.append("\n onPause Called")
        tv.text = sb.toString()
        Log.d("ACTIVITY_LIFECYCLE", "onPause Called")
    }

    override fun onStop() {
        super.onStop()
        sb.append("\n onStop Called")
        tv.text = sb.toString()
        Log.d("ACTIVITY_LIFECYCLE", "onStop Called")
    }

    override fun onDestroy() {
        super.onDestroy()
        sb.append("\n onDestroy Called")
        tv.text = sb.toString()
        Log.d("ACTIVITY_LIFECYCLE", "onDestroy Called")
    }
}

Step 3 : Layouts

activity_main.xml

La principale chose à propos de notre mise en page d'activité principale est que nous aurons un textview qui montrera les méthodes du cycle de vie comme ils sont soulevés :

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <TextView
        android:id="@+id/tv"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:text=""
        android:textAppearance="@style/TextAppearance.AppCompat.Medium"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintLeft_toLeftOf="parent"
        app:layout_constraintRight_toRightOf="parent"
        app:layout_constraintTop_toTopOf="parent" />

</androidx.constraintlayout.widget.ConstraintLayout>

Étape 4 : Exécution

Exécutez le projet.

Changement de la configuration de l'écran

Dans cette pièce, nous examinons les solutions android liées aux changements de configuration dans l'appareil android.

Voici une note simple sur la gestion des changements de configuration selon la documentation officielle d'android :

Certaines configurations de l'appareil peuvent changer pendant l'exécution (comme l'orientation de l'écran, la disponibilité du clavier, et lorsque l'utilisateur active le [mode multi-fenêtre] (https://developer.android.com/guide/topics/ui/multi-window)). Lorsqu'un tel changement se produit, Android redémarre l'activité en cours d'exécution Activity (onDestroy() est appelé, suivi par onCreate()). Le comportement de redémarrage est conçu pour aider votre application à s'adapter aux nouvelles configurations en rechargeant automatiquement votre application avec des ressources alternatives qui correspondent à la nouvelle configuration du périphérique.

Pour gérer correctement un redémarrage, il est important que votre activité restaure son état précédent. Vous pouvez utiliser une combinaison d'objets onSaveInstanceState(), ViewModel et de stockage persistant pour enregistrer et restaurer l'état de l'interface utilisateur de votre activité à travers les changements de configuration. Plus d'informations à ce sujet [ici] (https://developer.android.com/guide/topics/resources/runtime-changes).

Comment écouter les changements de configuration dans android ?

Étape 1 - Spécifiez la propriété configChanges dans le manifeste android.

Comme ceci :

<activity android:name=".MyActivity"
          android:configChanges="orientation|screenSize|screenLayout|keyboardHidden"
          android:label="@string/app_name">

Le code déclare une activité qui gère à la fois les changements d'orientation de l'écran et le changement de disponibilité du clavier.

  • La valeur "orientation" empêche les redémarrages lorsque l'orientation de l'écran change.
  • La valeur "screenSize" empêche également les redémarrages lorsque l'orientation change, mais uniquement pour Android 3.2 (niveau 13 de l'API) et plus.
  • La valeur "screenLayout" est nécessaire pour détecter les changements qui peuvent être déclenchés par des appareils tels que les téléphones pliables et les Chromebooks convertibles.
  • La valeur "keyboardHidden" empêche les redémarrages lorsque la disponibilité du clavier change.

Étape 2 : Remplacer la méthode onConfigurationChanged

Comme ceci :

@Override
public void onConfigurationChanged(Configuration newConfig) {
    super.onConfigurationChanged(newConfig);

    int newOrientation = newConfig.orientation;

    if (newOrientation == Configuration.ORIENTATION_LANDSCAPE) {
      // show("Landscape");
    } else if (newOrientation == Configuration.ORIENTATION_PORTRAIT){
    // show("Portrait");
    }
}

Ou vous pouvez utiliser une instruction de commutation :

int orientation=newConfig.orientation;
switch(orientation) {
    case Configuration.ORIENTATION_LANDSCAPE:
        //to do something
        break;
    case Configuration.ORIENTATION_PORTRAIT:
        //to do something
        break;
}

En Kotlin :

override fun onConfigurationChanged(newConfig: Configuration) {
    super.onConfigurationChanged(newConfig)

    // Checks the orientation of the screen
    if (newConfig.orientation === Configuration.ORIENTATION_LANDSCAPE) {
        Toast.makeText(this, "landscape", Toast.LENGTH_SHORT).show()
    } else if (newConfig.orientation === Configuration.ORIENTATION_PORTRAIT) {
        Toast.makeText(this, "portrait", Toast.LENGTH_SHORT).show()
    }
}

Notez qu'après avant d'écrire votre code d'implémentation, vous devez ajouter super.onConfigurationChanged(newConfig); ou sinon une exception peut être levée.

Observations

Le onConfigurationCalled() peut ne pas être appelé si vous

1. définissez la mise en page sur paysage dans le XML.

    android:screenOrientation="landscape"

2. Invoquez setRequestedOrientation manuellement.

    setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);

3. Vous avez à la fois spécifié android:screenOrientation et android:configChanges.

Exemple - Comment gérer les changements d'orientation de l'écran

Créons un exemple simple qui observera les changements de configuration dans une activité android et affichera un message de toast selon que l'écran est tourné en portrait ou en paysage.

Etape 1 - Création de la mise en page

Ajoutez le code suivant dans votre layout xml :

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:paddingBottom="@dimen/activity_vertical_margin"
    android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"
    tools:context=".MainActivity" >

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="@string/hello_world" />

</RelativeLayout>

Etape 2 : MainActivity.java

Ensuite, ajoutez le code suivant dans votre activité principale :

package com.example.screenorientation;

import android.os.Bundle;
import android.app.Activity;
import android.content.res.Configuration;
import android.view.Menu;
import android.widget.Toast;

public class MainActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        onConfigurationChanged(new Configuration());
    }
@Override
public void onConfigurationChanged(Configuration newConfig) {
    // TODO Auto-generated method stub
    super.onConfigurationChanged(newConfig);

    if(getResources().getConfiguration().orientation==Configuration.ORIENTATION_PORTRAIT)
    {
        Toast.makeText(getApplicationContext(), "portrait", Toast.LENGTH_SHORT).show();
        System.out.println("portrait");
    }
    else if (getResources().getConfiguration().orientation==Configuration.ORIENTATION_LANDSCAPE) {
         Toast.makeText(getApplicationContext(), "landscape", Toast.LENGTH_SHORT).show();
            System.out.println("landscape");
    }
    else
    {
         Toast.makeText(getApplicationContext(), "none", Toast.LENGTH_SHORT).show();
            System.out.println("none");
    }
}
    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.main, menu);
        return true;
    }

}

C'est tout.

Catégorisé: