Introduction à cette section :
Dans la section précédente, nous avons appris quelques utilisations de base d'Intent, découvert les sept attributs d'Intent, l'Intent explicite et l'Intent implicite, ainsi que la façon de personnaliser un Intent implicite. Enfin, nous avons également fourni quelques Intents système couramment utilisés ! Dans cette section, nous allons expliquer la question de la transmission de données par Intent~ Bon, commençons cette section~
1. Transmission de données simples avec Intent
Vous souvenez-vous comment nous avons appris à transmettre des données simples entre deux Activities dans la section Activity ?
C'est-à-dire que vous pouvez directement stocker des données en appelant la méthode putExtra() de l'Intent, puis, après avoir obtenu l'Intent, appelez getXxxExtra pour obtenir le type de données correspondant ; si vous transmettez plusieurs valeurs, vous pouvez utiliser l'objet Bundle comme conteneur. D'abord, stockez les données dans le Bundle en appelant putXxx de Bundle, puis appelez la méthode putExtras() de l'Intent pour placer le Bundle dans l'Intent. Après avoir obtenu l'Intent, appelez getExtras() pour obtenir le conteneur Bundle, puis appelez son getXXX pour obtenir les données correspondantes ! De plus, le stockage des données est quelque peu similaire à Map <key, value> !
2. Transmission de tableaux avec Intent
Hé hé, les types ordinaires vont bien, mais qu'en est-il des tableaux ? La solution est la suivante :
Écrire un tableau:
bd.putStringArray("StringArray", new String[]{"呵呵","哈哈"});
//可把StringArray换成其他数据类型,比如int,float等等...
Lire un tableau:
String[] str = bd.getStringArray("StringArray")
3. Transmission de collections avec Intent
Bon, les tableaux sont simples, non ? Maintenant, transmettons des collections~ C'est un peu plus compliqué, à traiter au cas par cas :
1) List<types de données primitifs ou String>
Écrire une collection :
intent.putStringArrayListExtra(name, value) intent.putIntegerArrayListExtra(name, value)
Lire une collection :
intent.getStringArrayListExtra(name) intent.getIntegerArrayListExtra(name)
2)List< Object>
Convertissez la liste en type Serializable, puis passez-la (Bundle peut être utilisé comme intermédiaire)
Écrire une collection :
putExtras(key, (Serializable)list)
Lire une collection :
(List<Object>) getIntent().getSerializable(key)
PS : La classe Object doit implémenter l'interface Serializable
3) Map<String, Object>, ou plus complexe
La solution est :Enveloppez-le avec une List à l'extérieur
//传递复杂些的参数
Map<String, Object> map1 = new HashMap<String, Object>();
map1.put("key1", "value1");
map1.put("key2", "value2");
List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
list.add(map1);
Intent intent = new Intent();
intent.setClass(MainActivity.this,ComplexActivity.class);
Bundle bundle = new Bundle();
//须定义一个list用于在budnle中传递需要传递的ArrayList<Object>,这个是必须要的
ArrayList bundlelist = new ArrayList();
bundlelist.add(list);
bundle.putParcelableArrayList("list",bundlelist);
intent.putExtras(bundle);
startActivity(intent);
4. Transmission d'objets via Intent
Il existe deux façons de transmettre des objets : convertir l'objet en chaîne JSON ou le sérialiser via Serializable, Parcelable. Il n'est pas recommandé d'utiliser l'analyseur JSON médiocre intégré à Android ; vous pouvez utiliser des bibliothèques tierces comme fastjson ou Gson !
1) Convertir un objet en chaîne JSON
Exemple d'analyse avec Gson :
Modèle :
public class Book{
private int id;
private String title;
//...
}
public class Author{
private int id;
private String name;
//...
}
Écrire les données :
Book book=new Book();
book.setTitle("Java编程思想");
Author author=new Author();
author.setId(1);
author.setName("Bruce Eckel");
book.setAuthor(author);
Intent intent=new Intent(this,SecondActivity.class);
intent.putExtra("book",new Gson().toJson(book));
startActivity(intent);
Lire les données :
String bookJson=getIntent().getStringExtra("book");
Book book=new Gson().fromJson(bookJson,Book.class);
Log.d(TAG,"book title->"+book.getTitle());
Log.d(TAG,"book author name->"+book.getAuthor().getName());
2) Utiliser Serializable, Parcelable pour sérialiser des objets
1. Implémentation Serializable :
① Le Bean métier implémente : l'interface Serializable, écrivez les méthodes getter et setter
② Intent transmet l'instance d'objet en appelant putExtra(String name, Serializable value). Bien sûr, s'il y a plusieurs objets, nous pouvons aussi d'abord appeler Bundle.putSerializable(x,x) ;
③ La nouvelle Activity appelle la méthode getSerializableExtra() pour obtenir l'instance d'objet : par ex. : Product pd = (Product) getIntent().getSerializableExtra("Product");
④ Appelez la méthode get de l'objet pour obtenir les paramètres correspondants
2. Implémentation Parcelable :
Processus général :
① Le Bean métier implémente l'interface Parcelable, redéfinit la méthode writeToParcel et sérialise votre objet dans un objet Parcel ;
② Redéfinissez la méthode describeContents ; pour la description de l'interface de contenu, retourner 0 par défaut convient.
③ Instanciez l'objet interne statique CREATOR pour implémenter l'interface Parcelable.Creator
④ De même, transmettez l'instance d'objet via la méthode putExtra() d'Intent. Bien sûr, s'il y a plusieurs objets, nous pouvons d'abord les placer dans un Bundle via Bundle.putParcelable(x,x), puis Intent.putExtras().
Quelques explications :
Mappez votre objet vers un objet Parcel via writeToParcel, puis mappez l'objet Parcel de nouveau vers votre objet via createFromParcel. Vous pouvez aussi considérer Parcel comme un flux : écrivez l'objet dans le flux via writeToParcel, puis lisez l'objet depuis le flux via createFromParcel. Cependant, ce processus doit être implémenté par vous, donc l'ordre d'écriture et l'ordre de lecture doivent être cohérents.
Exemple de code pour implémenter l'interface Parcelable :
//Internal Description Interface,You do not need to manage
@Override
public int describeContents() {
return 0;
}
@Override
public void writeToParcel(Parcel parcel, int flags){
parcel.writeString(bookName);
parcel.writeString(author);
parcel.writeInt(publishTime);
}
public static final Parcelable.Creator<Book> CREATOR = new Creator<Book>() {
@Override
public Book[] newArray(int size) {
return new Book[size];
}
@Override
public Book createFromParcel(Parcel source) {
Book mBook = new Book();
mBook.bookName = source.readString();
mBook.author = source.readString();
mBook.publishTime = source.readInt();
return mBook;
}
};
Plugin Android Studio pour générer Parcelable :
Plugin Intellij/Android Studio android-parcelable-intellij-plugin. Appuyez simplement sur ALT+Insert pour générer directement le code de l'interface Parcelable.
De plus : les objets Parcelable sont largement utilisés dans Android, et implémenter l'interface Parcelable est très fastidieux. Vous pouvez utiliser le framework open source tiers : Parceler. En raison de problèmes avec Maven, je ne l'ai pas encore essayé.
Adresse de référence :[Auto-génération de Parcelable Android]
3. Comparaison des deux méthodes de sérialisation :
Comparaison des deux :
- 1) En matière d'utilisation de la mémoire, Parcelable offre de meilleures performances que Serializable, donc Parcelable est recommandé.
- 2) Serializable génère un grand nombre de variables temporaires pendant la sérialisation, ce qui provoque de fréquents GC.
- 3) Parcelable ne peut pas être utilisé lorsque les données doivent être stockées sur disque, car Parcelable ne garantit pas bien la persistance des données en cas de changements externes. Bien que Serializable soit moins efficace, Serializable est tout de même recommandé dans ce cas.
5. Transmission de Bitmap par Intent
Bitmap implémente l'interface Parcelable par défaut, vous pouvez donc le passer directement.
Code d'implémentation :
Bitmap bitmap = null;
Intent intent = new Intent();
Bundle bundle = new Bundle();
bundle.putParcelable("bitmap", bitmap);
intent.putExtra("bundle", bundle);
6. Les allers-retours sont peu pratiques, définissez directement des données globales
Si vous avez besoin de transmettre des données simples, par exemple, Activity1 -> Activity2 -> Activity3 -> Activity4, et que vous voulez transmettre certaines données à Activity4, comment gérez-vous cela ? Les passer page par page ?
De toute évidence, ce n'est pas raisonnable, n'est-ce pas ? Si vous voulez que certaines données soient accessibles n'importe où, vous pouvez envisager d'utiliserl'objet global Application!
Le système Android crée un objet Application chaque fois qu'un programme s'exécute, et il n'en crée qu'un, donc Application est une classe en mode singleton. Le cycle de vie de l'objet Application est le plus long de tout le programme ; son cycle de vie est égal à celui du programme. Si vous souhaitez stocker certaines valeurs qui sont plus que static (fixes et immuables, ou pouvant changer), et si vous souhaitez utiliser Application, vous devez définir une classe personnalisée qui implémente la classe Application, et indiquer au système que l'objet instancié est notre Application personnalisée plutôt que celui par défaut du système. Cette étape est effectuée en ajoutant ce qui suit à notre balise application dans AndroidManifest.xml :l'attribut name!
Partie clé du code :
1) Classe Application personnalisée :
class MyApp extends Application {
private String myState;
public String getState(){
return myState;
}
public void setState(String s){
myState = s;
}
}
2) Déclarer dans AndroidManifest.xml :
<application android:name=".MyApp" android:icon="@drawable/icon" android:label="@string/app_name">
3) L'appeler là où c'est nécessaire :
class Blah extends Activity {
@Override
public void onCreate(Bundle b){
...
MyApp appState = ((MyApp)getApplicationContext());
String state = appState.getState();
...
}
}
Approche haut de gamme
: On peut obtenir l'objet global Application n'importe où.Application est un composant du système ; il a aussi son propre cycle de vie. Nous pouvons obtenir cet objet Application dans onCraete. Voici le code modifié !
class MyApp extends Application {
private String myState;
private static MyApp instance;
public static MyApp getInstance(){
return instance;
}
public String getState(){
return myState;
}
public void setState(String s){
myState = s;
}
@Override
public void onCreate(){
onCreate();
instance = this;
}
}
Ensuite, n'importe où, nous pouvons appeler directement : MyApp.getInstance() pour obtenir l'objet Application global !
Notes :
L'objet Application existe en mémoire, il peut donc être tué par le système. Par exemple, dans ce scénario :
Nous stockons le compte utilisateur dans l'application dans Activity1, puis récupérons le compte utilisateur dans Activity2 et l'affichons !
Si nous appuyons sur le bouton Home, et qu'après un long moment, le système tue notre app pour récupérer de la mémoire. À ce moment-là, lorsque nous rouvrons l'app, étonnamment, elle revient à la page Activity2. Mais si vous essayez à nouveau de récupérer le compte utilisateur depuis Application à ce moment-là, le programme lèvera une NullPointerException puis plantera~
La raison pour laquelle le crash ci-dessus se produit est que cet objet Application est tout nouveau. Vous pouvez penser que l'App a été redémarrée, mais ce n'est pas le cas ; elle crée simplement une nouvelle Application puis démarre l'Activity que l'utilisateur a quittée en dernier, créant l'illusion que l'App n'a pas été tuée ! Donc s'il s'agit de données importantes, il est recommandé de les stocker localement. De plus, lorsque vous utilisez les données, vous devez effectuer une vérification de non-nullité sur les valeurs des variables ! Une chose de plus : ce ne sont pas seulement les variables Application qui se comportent ainsi ; les objets singleton et les variables statiques publiques aussi~
7. Patron singleton pour le passage de paramètres
L'Application mentionnée ci-dessus est basée sur le patron singleton. La caractéristique du patron singleton est qu'il garantit qu'une classe n'a qu'une seule et unique instance dans le système. Cela rend la chose très facile à réaliser : définir des paramètres dans A et y accéder directement dans B. C'est la plus efficace parmi ces différentes méthodes.
Exemple de code : (code issu d'Internet~)
① Définir uneclasse singleton:
public class XclSingleton
{
//单例模式实例
private static XclSingleton instance = null;
//synchronized 用于线程安全,防止多线程同时创建实例
public synchronized static XclSingleton getInstance(){
if(instance == null){
instance = new XclSingleton();
}
return instance;
}
final HashMap<String, Object> mMap;
private XclSingleton()
{
mMap = new HashMap<String,Object>();
}
public void put(String key,Object value){
mMap.put(key,value);
}
public Object get(String key)
{
return mMap.get(key);
}
}
② Définir des paramètres :
XclSingleton.getInstance().put("key1", "value1");
XclSingleton.getInstance().put("key2", "value2");
Résumé de la section :
Bon, voilà tout ce qui concerne la transmission de données complexes avec Intent. Dans cette section, en plus d'expliquer comment utiliser Intent pour transmettre des données complexes, nous vous avons aussi appris à utiliser Application et le modèle singleton pour passer des paramètres ! Je pense que cela facilitera la transmission de données pour tout le monde. Merci~
