Comment gérer le passage entre activités et le transfert de données dans une application Android

Dans le développement d'applications Android, la gestion des activités et le passage de données entre elles sont des opérations fondamentales, souvent nécessaires pour offrir une expérience utilisateur fluide et dynamique. Ce processus implique l'utilisation de la classe Intent, qui permet non seulement de démarrer de nouvelles activités, mais aussi de transférer des informations d'une activité à une autre.

La création d’une nouvelle activité dans un projet Android débute par l'ajout d’une activité vide. Cela peut être réalisé en suivant une série d'étapes simples dans Android Studio : il suffit de créer une nouvelle activité et de la nommer, comme "Main2Activity" ou "SecondActivity". Une fois l’activité créée, il est nécessaire de programmer la logique qui permet d'effectuer la transition entre les activités. Par exemple, une fonction simple onClickSwitchActivity dans la classe MainActivity.java pourrait ressembler à ceci :

java
Copy code
public void onClickSwitchActivity(View view) { 

    Intent intent = new Intent(this, SecondActivity.class); 
    startActivity(intent); 
}

Une fois la première activité lancée, il est souvent nécessaire de gérer le retour à l'activité précédente. Cela peut être accompli en ajoutant un autre bouton dans la SecondActivity pour fermer cette activité et revenir à la première, via la méthode finish() :

java
Copy code
public void onClickClose(View view) { 

    finish(); 
}

Dans cette configuration, la méthode finish() informe le système que l'activité en cours doit être terminée. Toutefois, il est important de noter que cette méthode ne ramène pas explicitement à une activité particulière. Le comportement de retour se base sur la pile d'activités, qui permet de revenir à l'activité précédente sans avoir à spécifier laquelle.

Il est également possible de passer des données d'une activité à une autre en utilisant la classe Intent. Cela est particulièrement utile lorsque l’on veut que l'activité cible reçoive certaines informations avant de les afficher ou de les traiter. Pour ce faire, on utilise la méthode putExtra() pour ajouter des données à l'intention avant de la transmettre. Par exemple, dans l’activité principale (MainActivity), on peut capturer du texte saisi par l'utilisateur dans un champ EditText, puis l'envoyer à la SecondActivity :

java
Copy code
public void onClickSwitchActivity(View view) { 
    EditText editText = (EditText)findViewById(R.id.editTextData); 
    String text = editText.getText().toString(); 

    Intent intent = new Intent(this, SecondActivity.class); 

    intent.putExtra(Intent.EXTRA_TEXT, text); 
    startActivity(intent); 
}

Une fois le texte transmis à la SecondActivity, il est récupéré et affiché dans un TextView par le biais de la méthode getStringExtra() :

java
Copy code
protected void onCreate(Bundle savedInstanceState) { 
    super.onCreate(savedInstanceState); 
    setContentView(R.layout.activity_second); 
    TextView textView = (TextView)findViewById(R.id.textViewText); 
    if (getIntent() != null && getIntent().hasExtra(Intent.EXTRA_TEXT)) { 
        textView.setText(getIntent().getStringExtra(Intent.EXTRA_TEXT)); 
    } 
}

Il est également important de mentionner que lorsque plusieurs activités sont créées dans une application Android, elles doivent être correctement déclarées dans le fichier AndroidManifest.xml. En effet, ce fichier sert de "table des matières" de l'application et déclare les activités que l'application pourra utiliser, ainsi que leurs caractéristiques (par exemple, l'activité principale définie par l'élément <intent-filter>). Si Android Studio se charge généralement de cette tâche automatiquement, il est toujours bon de vérifier la configuration de ce fichier pour s’assurer qu’aucune activité n’est oubliée.

Outre le passage de données via les Intent, une autre opération courante est le retour de données d'une activité vers une autre. Parfois, il est nécessaire de connaître le résultat d'une activité appelée avant de poursuivre les opérations dans l'activité d'origine. Cela peut se faire en utilisant la méthode startActivityForResult() et en capturant les données renvoyées via la méthode onActivityResult().

En résumé, la gestion des activités et des données dans une application Android repose sur la compréhension des Intent et de leur rôle dans le système de navigation d'Android. L’utilisation de ces mécanismes permet non seulement de structurer l'application de manière logique, mais aussi d'assurer une interaction fluide entre les différentes sections de l'application, tout en garantissant une expérience utilisateur cohérente et dynamique.

Comment sauvegarder et restaurer l'état dans les activités Android : Comprendre les méthodes essentielles

Cependant, une question se pose immédiatement : que se passe-t-il si vous modifiez un champ EditText avant de faire pivoter l'appareil ? Il est fort probable que vous remarquiez que le texte que vous avez saisi reste dans le champ, mais sans qu'aucune ligne de code explicite ne le gère. Cela s'explique par le fait que le système Android, sous certaines conditions, gère automatiquement la sauvegarde de l'état des vues, à condition que celles-ci aient un identifiant unique. Ce mécanisme n'est pas universel : des vues comme TextView, par exemple, ne sauvegardent pas leur état par défaut. Si vous souhaitez que l'état de ces vues soit également sauvegardé, il vous faudra intervenir manuellement.

java
Copy code
if (savedInstanceState != null) {
    mCounter = savedInstanceState.getInt(KEY_COUNTER);
}

Une autre méthode pour préserver les données au-delà des sessions temporaires est d'utiliser SharedPreferences. Ce mécanisme est particulièrement utile pour stocker de petites quantités de données, telles que le nom de l'utilisateur ou un score élevé, et ce, de manière persistante. Par rapport à l'usage de bases de données SQLite, qui est plus lourd en termes de gestion des ressources, SharedPreferences offre une solution légère mais puissante.

java
Copy code
@Override
protected void onPause() {
    super.onPause();
    SharedPreferences settings = getPreferences(MODE_PRIVATE);
    SharedPreferences.Editor editor = settings.edit();
    editor.putInt(KEY_COUNTER, mCounter);
    editor.commit();
}

De même, pour restaurer une donnée stockée dans SharedPreferences, on peut utiliser la méthode getInt() ou d'autres méthodes similaires, en fonction du type de donnée à récupérer :

java
Copy code
SharedPreferences settings = getPreferences(MODE_PRIVATE);

int defaultCounter = 0;
mCounter = settings.getInt(KEY_COUNTER, defaultCounter);

Une variante de cette méthode consiste à utiliser getSharedPreferences() pour gérer plusieurs fichiers de préférences. Cela permet de maintenir différents ensembles de préférences pour des sections distinctes de votre application. La syntaxe de cette méthode est similaire à celle de getPreferences(), mais elle accepte un paramètre supplémentaire pour spécifier le nom du fichier de préférences.

Cependant, au-delà de ces considérations pratiques sur la gestion de l'état, il est crucial de bien comprendre le cycle de vie des activités dans Android. Ce cycle est essentiel pour savoir quand et où vous devez sauvegarder ou restaurer des données. L'activité d'Android peut être dans trois états principaux : active, en pause ou arrêtée. L'état "détruit" est aussi une possibilité, bien que souvent, vous n'ayez pas besoin d'y prêter une attention particulière.

Lorsqu'une activité est en état actif, son interface est visible et disponible pour l'utilisateur. Cet état persiste de la méthode onResume() à onPause(), cette dernière étant déclenchée lorsque l'utilisateur passe à une autre activité ou que la gestion de la mémoire demande que l'activité soit mise en arrière-plan. Si une autre activité occupe l'écran mais ne le couvre pas complètement, l'activité actuelle restera en état "en pause" jusqu'à ce que l'autre activité se termine.

Un dernier point important réside dans la gestion des préférences partagées (SharedPreferences) lorsque vous travaillez avec plusieurs fichiers de préférences. En utilisant getSharedPreferences(), vous pouvez organiser différentes préférences dans des fichiers distincts, ce qui permet une gestion plus fine et un accès plus flexible aux données persistantes dans votre application.