Detailed explanation of complex parameter passing method between Android intents

Cet article décrit en détail les méthodes de transmission de paramètres complexes entre les intents d'Android. Partagé avec tous, voici les détails :

Intent est le moyen de transmettre des paramètres entre Activity et Activity, entre Activity et Service, et ces deux implémentations généralement sont le passage de types d'objets de base Java et de String.
Dans les projets réels, la transmission de valeurs entre les pages, en plus des quelques-unes mentionnées ci-dessus, implique souvent la transmission d'objets Object, de types List, List<Object> et variables globales, etc. Cet article présente comment transmettre ces types de paramètres.

I. Transmettre List<String> et List<Integer>

Voici un exemple pour envoyer List<String>, la syntaxe pour envoyer List<String> est :

intent.putStringArrayListExtra(key, list);

La syntaxe pour recevoir List<String> est :

list = (ArrayList<String>)getIntent().getStringArrayListExtra(key);

Voici un exemple d'utilisation :

// =============Envoyer List<String>=============
ArrayList<String> stringList = new ArrayList<String>();
stringList.add("string"1");
stringList.add("string"2");
stringList.add("string"3");
Intent intent = new Intent();
intent.setClass(ListDemoActivity.this, StringListActivity.class);
intent.putStringArrayListExtra("ListString", stringList);
startActivity(intent);
// ====================Recevoir List<String>======================
ArrayList<String> stringList = (ArrayList<String>) getIntent().getStringArrayListExtra("ListString");

Pour des opérations similaires à List<Integer>, vous pouvez appeler la méthode suivante :

intent.putIntegerArrayListExtra(key, list);
list = (ArrayList<Integer>) getIntent().getIntegerArrayListExtra(key);

Deuxièmement, transmission d'objets en utilisant les deux méthodes Serializable et Parcelable

Il y a deux méthodes pour transmettre des objets entre les Intent d'Android : l'une est Bundle.putSerializable(Key, Object); et l'autre est Bundle.putParcelable(Key, Object). L'objet Object doit répondre à certaines conditions, l'un implémentant l'interface Serializable et l'autre l'interface Parcelable.

Voici la classe User qui implémente l'interface Serializable, nommée SerializableUser principalement pour distinguer la classe User qui implémente l'interface Parcelable, ce qui n'est pas recommandé dans le développement réel :

public class SerializableUser implements Serializable {
  private String userName;
  private String password;
  public SerializableUser() {
  }
  public SerializableUser(String userName, String password) {
    this.userName = userName;
    this.password = password;
  }
  public String getUserName() {
    return userName;
  }
  public void setUserName(String userName) {
    this.userName = userName;
  }
  public String getPassword() {
    return password;
  }
  public void setPassword(String password) {
    this.password = password;
  }
}

Voici la classe User qui implémente l'interface Parcelable :

public class ParcelableUser implements Parcelable {
  private String userName;
  private String password;
  public ParcelableUser() {
  }
  public ParcelableUser(String userName, String password) {
    this.userName = userName;
    this.password = password;
  }
  public String getUserName() {
    return userName;
  }
  public void setUserName(String userName) {
    this.userName = userName;
  }
  public String getPassword() {
    return password;
  }
  public void setPassword(String password) {
    this.password = password;
  }
  public static final Parcelable.Creator<ParcelableUser> CREATOR = new Creator<ParcelableUser>() {
    @Override
    public ParcelableUser createFromParcel(Parcel source) {
      ParcelableUser parcelableUser = new ParcelableUser();
      parcelableUser.userName = source.readString();
      parcelableUser.password = source.readString();
      return parcelableUser;
    }
    @Override
    public ParcelableUser[] newArray(int size) {
      return new ParcelableUser[size];
    }
  };
  @Override
  public int describeContents() {
    // TODO Auto-point de stub de méthode généré
    return 0;
  }
  @Override
  public void writeToParcel(Parcel dest, int flags) {
    // TODO Auto-point de stub de méthode généré
    dest.writeString(userName);
    dest.writeString(password);
  }
}

utilise deux méthodestransmetles syntaxes sont :

bundle.putSerializable(key,object);
bundle.putParcelable(key,object);

utilise deux méthodesreçoitles syntaxes sont :

object=(Object) getIntent().getSerializableExtra(key);
object = (Object) getIntent().getParcelableExtra(key);

// ==========Utilisation respective de Serializable et Parcelable pour envoyer Object===============
SerializableUser serializableUser = new SerializableUser("user"1", "123456");
ParcelableUser parcelableUser = new ParcelableUser("user"2""654321");
Intent intent = new Intent();
Bundle bundle = new Bundle();
bundle.putSerializable("serializableUser", serializableUser);
bundle.putParcelable("parcelableUser", parcelableUser);
intent.setClass(ListDemoActivity.this, ObjectActivity.class);
intent.putExtras(bundle);
startActivity(intent);
// ====================Réception d'Object======================
SerializableUser serializableUser = (SerializableUser) getIntent().getSerializableExtra("serializableUser");
ParcelableUser parcelableUser = (ParcelableUser) getIntent().getParcelableExtra("parcelableUser");

Il est possible que quelqu'un ait remarqué que l'implémentation de l'interface Serializable consiste à sérialiser l'objet, puis à le transmettre, ce qui n'a pas de différence notable avec la programmation courante en Java, et l'objet User n'a pas besoin de modifications évidentes, ce qui est simple. Je recommande également cette méthode.

Cependant, la deuxième classe implémentant l'interface Parcelable est plus complexe, qu'est-ce que Parcelable ?

Android propose un nouveau type : Parcel, utilisé comme conteneur de données pour encapsuler les données, les données encapsulées peuvent être transmises via Intent ou IPC. À part les types de base, seules les classes implémentant l'interface Parcelable peuvent être placées dans un Parcel.

Pour implémenter l'interface Parcelable, il faut réaliser trois méthodes :

1）La méthode writeToParcel. Cette méthode écrit les données de la classe dans le Parcel fourni par l'extérieur.
Déclaration : writeToParcel (Parcel dest, int flags).

2）La méthode describeContents. Il suffit de retourner 0.

3）L'interface statique Parcelable.Creator<T>, cette interface a deux méthodes :

createFromParcel(Parcel in) réalise la fonction de création d'une instance de la classe à partir de in.
newArray(int size) crée un tableau de type T de longueur size, return new T[size]; est suffisant. Cette méthode est destinée à être utilisée par les classes externes pour désérialiser les tableaux de cette classe.

Selon les tests de log, on peut voir le déroulement du programme. Lors de l'appel à bundle.putParcelable("parcelableUser", parcelableUser);, la méthode public void writeToParcel(Parcel dest, int flags) de la classe ParcelableUser est appelée et écrit des données dans dest. Lors de ParcelableUser parcelableUser = (ParcelableUser) getIntent().getParcelableExtra("parcelableUser");, la méthode public ParcelableUser createFromParcel(Parcel source) de la classe ParcelableUser est appelée pour créer un objet ParcelableUser, et assigner des valeurs aux attributs de cet objet. Ici, Parcel source et Parcel dest sont identiques, puis l'objet ParcelableUser est retourné. Enfin, vous pouvez imprimer les informations des attributs de parcelableUser.

Troisième partie : Transmettre List<Object>

Si nous devons transmettre une liste composée d'objets Object, c'est-à-dire List<Object>, que faire ?Tout d'abord, il faut que l'objet Object implémente l'interface Serializable, puis convertir la liste en type Serializable par force, et enfin :

Intent.putExtra(key, (Serializable)objectList);

Cette syntaxe est utilisée pour transmettre, et le destinataire doit également effectuer une conversion de type forceée en List<Object> lors de la réception. La syntaxe utilisée pour recevoir List<Object> est :

objectList= (List<Object>) getIntent().getSerializableExtra(key);

Voici un exemple d'application, ici le classe SerializableUser utilisé à l'étape précédente est donné, et n'est donc pas répété ici.

// ==============Envoi de List<Object>===========
SerializableUser user1 = new SerializableUser("user1", "123456");
SerializableUser user2 = new SerializableUser("user2", "654321");
List<SerializableUser> objectList = new ArrayList<SerializableUser>();
objectList.add(user1);
objectList.add(user2);
Intent intent = new Intent();
intent.setClass(ListDemoActivity.this, ObjectListActivity.class);
intent.putExtra("ListObject", (Serializable) objectList);
startActivity(intent);
// ====================Réception de List<Object>======================
List<SerializableUser> objectList = (List<SerializableUser>) getIntent().getSerializableExtra("ListObject");

Quatre, les variables globales

Si certains paramètres spécifiques de niveau d'application ne sont pas pratiques à transmettre via intent, nous pourrions facilement penser s'il y a des variables globales ou statiques que nous pourrions utiliser ? Les variables statiques en Java sont appropriées ici, mais leur valeur est perdue après que l'Activity a appelé System.exit(0) ou finish().

Dans Android, il existe une manière plus élégante d'utiliser l'ApplicationContext. Cette méthode de variable globale est plus sécurisée que les classes statiques, et les variables ne sont libérées que lorsque toutes les Activity de l'application ont été détruites.

Le SDK d'Android stipule que l'Application est utilisée pour stocker les variables globales, et elle existe dès la création du package. Donc, lorsque nous avons besoin de créer des variables globales, nous n'avons pas besoin de le faire comme J2Il est nécessaire de créer des variables statiques publiques avec les permissions public dans SE, mais ici, nous les réalisons directement dans l'application. Il suffit d'appeler la méthode getApplicationContext de Context ou getApplication d'Activity pour obtenir un objet Application et ainsi définir ou lire la valeur des variables globales.

Lors du lancement de l'Application, le système crée un PID, c'est-à-dire l'ID de processus, toutes les Activity s'exécuteront sur ce processus. Alors, nous initialisons les variables globales lors de la création de l'Application, toutes les Activity de la même application peuvent accéder aux valeurs de ces variables globales. Autrement dit, si nous changeons la valeur de ces variables globales dans une Activity, la valeur changera également dans les autres Activity de la même application.

Utilisation :

1Créez une sous-classe de android.app.Application qui vous appartient, et ajoutez des méthodes setter et getter pour les variables globales privées que vous souhaitez partager.

public class MyApp extends Application{
  private String globalVariable;
  public String getGlobalVariable() {
    return globalVariable;
  }
  public void setGlobalVariable(String globalVariable) {
    this.globalVariable = globalVariable;
  }
}

2Déclarer cette classe dans le manifeste, à ce moment-là, Android en crée une instance globale utilisable.

En réalité, il s'agit de donner un nom à cette instance globale à l'application existante en utilisant une seule balise application.

<application android:name=".MyApp" android:icon="@drawable/icon" android:label="@string/app_name">

3Il est possible d'utiliser la méthode Context.getApplicationContext() n'importe où pour obtenir cette instance et ainsi accéder à son état (variables).

// ============Utilisation des variables globales pour transmettre des paramètres==============
MyApp myApp = ((MyApp) getApplicationContext());//Obtenez notre application MyApp
myApp.setGlobalVariable("Variable globale");
Intent intent = new Intent();
intent.setClass(ListDemoActivity.this, GlobalActivity.class);
startActivity(intent);
// ============ Paramètres de réception des variables globales ============
MyApp myApp = ((MyApp) getApplicationContext());
String globalVariable = myApp.getGlobalVariable();

Les lecteurs intéressés par plus de contenu sur Android peuvent consulter les sujets spéciaux de ce site : "Tutorial de développement Android pour débutants et avancés", "Résumé des techniques d'opération activity en programmation Android", "Résumé des techniques d'opération des ressources Android", "Résumé des techniques d'opération des fichiers Android", "Résumé des techniques d'opération de la base de données SQLite Android", "Résumé des techniques d'opération des données au format JSON Android", "Résumé des techniques d'opération de la base de données Android", "Résumé des techniques d'opération de la carte SD Android", "Résumé des techniques de vue View Android" et "Résumé des techniques d'utilisation des contrôles Android"

J'espère que les informations fournies dans cet article pourront aider les développeurs Android.

Déclaration : Le contenu de cet article est issu du réseau, propriété de l'auteur original, le contenu est contribué et téléversé par les utilisateurs d'Internet, ce site Web ne détient pas de propriété, n'a pas été traité par l'éditeur humain et n'assume aucune responsabilité juridique. Si vous trouvez du contenu suspect de violation de copyright, veuillez envoyer un e-mail à : notice#w3Déclaration : Le contenu de cet article est issu du réseau, propriété de l'auteur original, le contenu est contribué et téléversé par les utilisateurs d'Internet, ce site Web ne détient pas de propriété, n'a pas été traité par l'éditeur humain et n'assume aucune responsabilité juridique. Si vous trouvez du contenu suspect de violation de copyright, veuillez envoyer un e-mail à : notice#w