Voici une compilation des plus commun des moyens pour y parvenir:
- Envoyer des données à l'intérieur de l'intention
- Utiliser une classe singleton
- L'utilisation de l'application singleton
- Les champs statiques
- HashMap d'
WeakReferences
- Conserver les objets (sqlite, de partager des préférences, fichier, etc.)
TL;DR: il y a deux façons de partage de données: la transmission des données à l'intention des figurants ou de le sauvegarder quelque part d'autre. Si les données sont primitives, des Chaînes ou des objets définis par l'utilisateur: l'envoyer en tant que partie de l'intention extras (objets définis par l'utilisateur doit mettre en oeuvre Parcelable). Si le passage d'objets complexes enregistrer une instance dans un singleton quelque part d'autre et d'y accéder depuis le lancement de l'activité.
Quelques exemples de comment et pourquoi mettre en place de chaque approche:
Envoyer des données à l'intérieur d'intentions
Intent intent = new Intent(FirstActivity.this, SecondActivity.class);
intent.putExtra("some_key", value);
intent.putExtra("some_other_key", "a value");
startActivity(intent);
Sur la deuxième activité:
Bundle bundle = getIntent().getExtras();
int value = bundle.getInt("some_key");
String value2 = bundle.getString("some_other_key");
Utilisez cette méthode si vous êtes de passage de données primitifs ou des Chaînes de caractères. Vous pouvez également passer des objets qui implémente Serializable.
Bien que tentant, vous devriez réfléchir à deux fois avant d'utiliser Serializable: c'est sujette aux erreurs et horriblement lent. Donc, en général: rester à l'écart de Serializable si possible. Si vous souhaitez passer des complexes d'objets définis par l'utilisateur, prendre un coup d'oeil à l' Parcelable interface. Il est plus difficile à mettre en œuvre, mais il a considérable gain de vitesse par rapport à l' Serializable.
Partager des données sans la persistance de disque
Il est possible de partager des données entre des activités en l'enregistrant dans la mémoire étant donné que, dans la plupart des cas, les deux activités exécutées dans le même processus.
Remarque: parfois, lorsque l'utilisateur quitte votre activité (sans la quitter), Android peut décider de tuer votre application. Dans un tel scénario, j'ai connu des cas dans lesquels android des tentatives de lancement de la dernière activité à l'aide de l'intention avant l'application a été tué. Dans ce cas, les données stockées dans un singleton (les vôtres ou Application) aura disparu et les mauvaises choses peuvent se produire. Pour éviter de tels cas, vous pouvez soit conserver les objets de disque ou de vérifier les données avant de les utiliser afin de vous assurer de la validité de son.
Utiliser une classe singleton
Avoir une classe à un ensemble de données:
public class DataHolder {
private String data;
public String getData() {return data;}
public void setData(String data) {this.data = data;}
private static final DataHolder holder = new DataHolder();
public static DataHolder getInstance() {return holder;}
}
Depuis le lancement de l'activité:
String data = DataHolder.getInstance().getData();
L'utilisation de l'application singleton
L'application singleton est une instance de l' android.app.Application qui est créé lorsque l'application est lancée. Vous pouvez fournir un programme personnalisé en étendant Application:
import android.app.Application;
public class MyApplication extends Application {
private String data;
public String getData() {return data;}
public void setData(String data) {this.data = data;}
}
Avant le lancement de l'activité:
MyApplication app = (MyApplication) getApplicationContext();
app.setData(someData);
Puis, à partir du lancement de l'activité:
MyApplication app = (MyApplication) getApplicationContext();
String data = app.getData();
Les champs statiques
L'idée est fondamentalement que le singleton, mais dans ce cas, vous fournir statique d'accès aux données:
public class DataHolder {
private static String data;
public static String getData() {return data;}
public static String setData(String data) {this.data = data;}
}
Depuis le lancement de l'activité:
String data = DataHolder.getData();
HashMap d' WeakReferences
Même idée, mais en permettant le garbage collector supprimer les objets non référencés (par exemple, lorsque l'utilisateur quitte l'activité):
public class DataHolder {
Map<String, WeakReference<Object>> data = new HashMap<String, WeakReference<Object>>();
void save(String id, Object object) {
data.put(id, new WeakReference<Object>(object));
}
Object retrieve(String id) {
WeakReference<Object> objectWeakReference = data.get(id);
return objectWeakReference.get();
}
}
Avant le lancement de l'activité:
DataHolder.getInstance().save(someId, someObject);
Depuis le lancement de l'activité:
DataHolder.getInstance().retrieve(someId);
Vous peut ou peut ne pas avoir à passer l'id de l'objet à l'aide de l'intention des figurants. Tout dépend de votre problème spécifique.
Conserver les objets sur le disque
L'idée est d'enregistrer les données dans le disque avant de lancer l'autre activité.
Avantages: vous pouvez lancer l'activité à partir d'autres endroits et, si les données sont déjà persisté, il devrait fonctionner très bien.
Inconvénients: c'est lourd et prend plus de temps à mettre en œuvre. Nécessite plus de code, et donc plus de chance d'introduire des bogues. Il sera aussi beaucoup plus lent.
Certains des moyens de conserver les objets comprennent:
