Comment envoyer un objet d'une activité Android à une autre en utilisant Intents?
la solution la plus simple que j'ai trouvée est de créer une classe avec des membres de données statiques avec des getters setters.
définir une activité et obtenir d'une autre activité cet objet.
activité A
mytestclass.staticfunctionSet("","",""..etc.);
activité b
mytestclass obj= mytestclass.staticfunctionGet();
Si vous ne faites que passer des objets, alors Parcelable a été conçu pour cela. L'utilisation nécessite un peu plus d'effort que l'utilisation de la sérialisation native de Java, mais c'est beaucoup plus rapide (et je veux dire, FAÇON plus rapide).
À partir de la documentation, voici un exemple simple de mise en œuvre:
// simple class that just has one member property as an example
public class MyParcelable implements Parcelable {
private int mData;
/* everything below here is for implementing Parcelable */
// 99.9% of the time you can just ignore this
@Override
public int describeContents() {
return 0;
}
// write your object's data to the passed-in Parcel
@Override
public void writeToParcel(Parcel out, int flags) {
out.writeInt(mData);
}
// this is used to regenerate your object. All Parcelables must have a CREATOR that implements these two methods
public static final Parcelable.Creator<MyParcelable> CREATOR = new Parcelable.Creator<MyParcelable>() {
public MyParcelable createFromParcel(Parcel in) {
return new MyParcelable(in);
}
public MyParcelable[] newArray(int size) {
return new MyParcelable[size];
}
};
// example constructor that takes a Parcel and gives you an object populated with it's values
private MyParcelable(Parcel in) {
mData = in.readInt();
}
}
Notez que dans le cas où vous avez plusieurs champs à récupérer dans un colis donné, vous devez le faire dans le même ordre que vous les avez placés (c'est-à-dire, dans une approche FIFO).
Une fois que vos objets ont implémenté Parcelable, il suffit de les mettre dans votre Intentions avec putExtra () :
Intent i = new Intent();
i.putExtra("name_of_extra", myParcelableObject);
Ensuite, vous pouvez les retirer avec getParcelableExtra () :
Intent i = getIntent();
MyParcelable myParcelableObject = (MyParcelable) i.getParcelableExtra("name_of_extra");
Si votre classe d'objet implémente Parcelable et Serializable, assurez-vous de la convertir en l'un des éléments suivants:
i.putExtra("parcelable_extra", (Parcelable) myParcelableObject);
i.putExtra("serializable_extra", (Serializable) myParcelableObject);
Vous aurez besoin de sérialiser votre objet dans une sorte de représentation de chaîne. Une représentation de chaîne possible est JSON, et l’un des moyens les plus simples de sérialiser vers/depuis JSON dans Android, si vous me le demandez, est via Google GSON .
Dans ce cas, il vous suffit de placer la valeur renvoyée de chaîne à partir de (new Gson()).toJson(myObject);, de récupérer la valeur de chaîne et d'utiliser fromJson pour la rétablir dans votre objet.
Cependant, si votre objet n'est pas très complexe, il ne vaut peut-être pas la surcharge et vous pouvez envisager de passer les valeurs distinctes de l'objet à la place.
Vous pouvez envoyer un objet sérialisable par intention
// send where details is object
ClassName details = new ClassName();
Intent i = new Intent(context, EditActivity.class);
i.putExtra("Editing", details);
startActivity(i);
//receive
ClassName model = (ClassName) getIntent().getSerializableExtra("Editing");
And
Class ClassName implements Serializable {
}
Pour les situations dans lesquelles vous savez que vous allez transmettre des données au sein d'une application, utilisez "globals" (comme des classes statiques).
Ici est ce que Dianne Hackborn (hackbod - un ingénieur logiciel Google Android) avait à dire sur le sujet:
Pour les situations où vous savez que les activités se déroulent de la même manière processus, vous pouvez simplement partager des données à travers globals. Par exemple, vous pourrait avoir un
HashMap<String, WeakReference<MyInterpreterState>>.__ global. et lorsque vous créez un nouveau MyInterpreterState, créez un nom unique pour cela et le mettre dans la carte de hachage; d'envoyer cet état à un autre l'activité, il suffit de mettre le nom unique dans la carte de hachage et lorsque le la deuxième activité est démarrée, elle peut récupérer le MyInterpreterState à partir de la carte de hachage avec le nom qu'elle reçoit.
Votre classe devrait implémenter Serializable ou Parcelable.
public class MY_CLASS implements Serializable
Une fois cela fait, vous pouvez envoyer un objet sur putExtra
intent.putExtra("KEY", MY_CLASS_instance);
startActivity(intent);
Pour obtenir des extras il suffit de faire
Intent intent = getIntent();
MY_CLASS class = (MY_CLASS) intent.getExtras().getSerializable("KEY");
Si votre classe implémente l'utilisation de Parcelable next
MY_CLASS class = (MY_CLASS) intent.getExtras().getParcelable("KEY");
J'espère que ça aide: D
Réponse courte pour un besoin rapide
1. Implémentez votre classe en Serializable.
Si vous avez des classes internes, n'oubliez pas de les implémenter aussi avec Serializable !!
public class SportsData implements Serializable
public class Sport implements Serializable
List<Sport> clickedObj;
2. Mettez votre objet dans l'intention
Intent intent = new Intent(SportsAct.this, SportSubAct.class);
intent.putExtra("sport", clickedObj);
startActivity(intent);
3. Et recevez votre objet dans l'autre classe d'activité
Intent intent = getIntent();
Sport cust = (Sport) intent.getSerializableExtra("sport");
si votre classe d'objets implémenteSerializable, vous n'avez rien d'autre à faire, vous pouvez passer un objet sérialisable.
c'est ce que j'utilise.
Vous pouvez utiliser Android BUNDLE pour le faire.
Créez un paquet de votre classe comme:
public Bundle toBundle() {
Bundle b = new Bundle();
b.putString("SomeKey", "SomeValue");
return b;
}
Puis passez ce paquet avec INTENT . Maintenant, vous pouvez recréer votre objet de classe en passant le paquet comme
public CustomClass(Context _context, Bundle b) {
context = _context;
classMember = b.getString("SomeKey");
}
Déclarez ceci dans votre classe personnalisée et utilisez-le.
implémenter sérialisable dans votre classe
public class Place implements Serializable{
private int id;
private String name;
public void setId(int id) {
this.id = id;
}
public int getId() {
return id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
Ensuite, vous pouvez passer cet objet dans l'intention
Intent intent = new Intent(this, SecondAct.class);
intent.putExtra("PLACE", Place);
startActivity();
int la deuxième activité, vous pouvez obtenir des données comme celle-ci
Place place= (Place) getIntent().getSerializableExtra("PLACE");
Mais lorsque les données deviennent volumineuses, cette méthode sera lente.
Merci pour l'aide parcellaire mais j'ai trouvé une solution optionnelle supplémentaire
public class getsetclass implements Serializable {
private int dt = 10;
//pass any object, drwabale
public int getDt() {
return dt;
}
public void setDt(int dt) {
this.dt = dt;
}
}
Dans l'activité un
getsetclass d = new getsetclass ();
d.setDt(50);
LinkedHashMap<String, Object> obj = new LinkedHashMap<String, Object>();
obj.put("hashmapkey", d);
Intent inew = new Intent(SgParceLableSampelActivity.this,
ActivityNext.class);
Bundle b = new Bundle();
b.putSerializable("bundleobj", obj);
inew.putExtras(b);
startActivity(inew);
Obtenir des données dans l'activité 2
try { setContentView(R.layout.main);
Bundle bn = new Bundle();
bn = getIntent().getExtras();
HashMap<String, Object> getobj = new HashMap<String, Object>();
getobj = (HashMap<String, Object>) bn.getSerializable("bundleobj");
getsetclass d = (getsetclass) getobj.get("hashmapkey");
} catch (Exception e) {
Log.e("Err", e.getMessage());
}
Vous pouvez accéder aux variables ou aux objets d’autres classes ou d’Activités de plusieurs manières.
A. Base de données
B. préférences partagées.
C. Sérialisation d'objet.
D. Une classe pouvant contenir des données communes peut être nommée Utilitaires communs, cela dépend de vous.
E. Transmission de données via Intents et une interface pouvant être parcellisée.
Cela dépend des besoins de votre projet.
A. Base de données
SQLite est une base de données Open Source intégrée à Android. SQLite prend en charge les fonctionnalités de base de données relationnelles standard telles que la syntaxe SQL, les transactions et les instructions préparées.
Tutoriels - http://www.vogella.com/articles/AndroidSQLite/article.html
B. Préférences partagées
Supposons que vous souhaitiez stocker un nom d'utilisateur. Donc, il y aura maintenant deux choses: un nom d'utilisateur Key, Value Value.
Comment stocker
// Create object of SharedPreferences.
SharedPreferences sharedPref = PreferenceManager.getDefaultSharedPreferences(this);
//now get Editor
SharedPreferences.Editor editor = sharedPref.edit();
//put your value
editor.putString("userName", "stackoverlow");
//commits your edits
editor.commit();
_ {En utilisant putString (), putBoolean (), putInt (), putFloat (), putLong (), vous pouvez enregistrer votre type d'état souhaité.
Comment chercher
SharedPreferences sharedPref = PreferenceManager.getDefaultSharedPreferences(this);
String userName = sharedPref.getString("userName", "Not Available");
http://developer.Android.com/reference/Android/content/SharedPreferences.html
C. Sérialisation d'objet
La sérialisation d'objet est utilisée si nous voulons enregistrer un état d'objet pour l'envoyer sur le réseau ou si vous pouvez également l'utiliser à vos fins.
Utilisez les haricots Java et stockez-les comme l'un de ses champs et utilisez les accesseurs et les configurateurs pour cela.
Les JavaBeans sont des classes Java possédant des propriétés. Pensez àproperties en tant que variables d'instance privée. Comme ils sont privés, le seul moyen De les accéder à l'extérieur de leur classe est d'utiliser des méthodes de la classe. Les méthodes Qui modifient la valeur d'une propriété sont appelées méthodes setter et les méthodes Qui extraient la valeur d'une propriété sont appelées méthodes getter.
public class VariableStorage implements Serializable {
private String inString ;
public String getInString() {
return inString;
}
public void setInString(String inString) {
this.inString = inString;
}
}
Définissez la variable dans votre méthode de messagerie à l'aide de
VariableStorage variableStorage = new VariableStorage();
variableStorage.setInString(inString);
Ensuite, utilisez objet Serialzation pour sérialiser cet objet et dans votre autre classe, désérialiser cet objet.
Lors de la sérialisation, un objet peut être représenté sous la forme d'une séquence d'octets contenant les données de l'objet, ainsi que des informations sur le type de l'objet et les types de données stockés dans l'objet.
Une fois qu'un objet sérialisé a été écrit dans un fichier, il peut être lu dans le fichier et désérialisé, c'est-à-dire que les informations de type et les octets représentant l'objet et ses données peuvent être utilisés pour recréer l'objet en mémoire.
Si vous voulez un tutoriel pour cela référez vous à ce lien
http://javawithswaranga.blogspot.in/2011/08/serialization-in-Java.html
Obtenir une variable dans d'autres classes
D. CommonUtilities
Vous pouvez créer vous-même une classe pouvant contenir des données communes dont vous avez souvent besoin dans votre projet.
Échantillon
public class CommonUtilities {
public static String className = "CommonUtilities";
}
E. Transmission de données par intentions
Veuillez vous référer à ce tutoriel pour cette option de transmission de données.
J'utilise Gson avec son API si puissante et simple pour envoyer des objets entre les activités,
Exemple
// This is the object to be sent, can be any object
public class AndroidPacket {
public String CustomerName;
//constructor
public AndroidPacket(String cName){
CustomerName = cName;
}
// other fields ....
// You can add those functions as LiveTemplate !
public String toJson() {
Gson gson = new Gson();
return gson.toJson(this);
}
public static AndroidPacket fromJson(String json) {
Gson gson = new Gson();
return gson.fromJson(json, AndroidPacket.class);
}
}
2 fonctions vous les ajoutez aux objets que vous voulez envoyer
Utilisation
Envoyer un objet de A à B
// Convert the object to string using Gson
AndroidPacket androidPacket = new AndroidPacket("Ahmad");
String objAsJson = androidPacket.toJson();
Intent intent = new Intent(A.this, B.class);
intent.putExtra("my_obj", objAsJson);
startActivity(intent);
Recevoir en B
@Override
protected void onCreate(Bundle savedInstanceState) {
Bundle bundle = getIntent().getExtras();
String objAsJson = bundle.getString("my_obj");
AndroidPacket androidPacket = AndroidPacket.fromJson(objAsJson);
// Here you can use your Object
Log.d("Gson", androidPacket.CustomerName);
}
Je l'utilise presque dans tous les projets que je fais et je n'ai aucun problème de performance.
Dans votre première activité:
intent.putExtra("myTag", yourObject);
Et dans votre deuxième:
myCustomObject myObject = (myCustomObject) getIntent().getSerializableExtra("myTag");
N'oubliez pas de rendre votre objet personnalisé Serializable:
public class myCustomObject implements Serializable {
...
}
J'ai lutté avec le même problème. Je l'ai résolu en utilisant une classe statique, stockant toutes les données que je veux dans un HashMap. En plus, j'utilise une extension de la classe standard Activity où j'ai remplacé les méthodes onCreate et onDestroy pour effectuer le transport et l'effacement des données masqués. Certains paramètres ridicules doivent être modifiés, par exemple. orientation-manipulation.
Annotation: Ne pas fournir d'objets généraux à transmettre à une autre activité est pénible. C'est comme se tirer une balle dans le genou et espérer gagner un 100 mètres. "Parcable" n'est pas un substitut suffisant. Cela me fait rire ... Je ne veux pas implémenter cette interface dans mon API sans technologie, moins je veux introduire un nouveau calque ... Comment cela se pourrait-il que nous soyons si loin de la programmation mobile paradigme moderne ...
Une autre façon de faire consiste à utiliser l'objet Application (Android.app.Application). Vous définissez ceci dans votre fichier AndroidManifest.xml comme suit:
<application
Android:name=".MyApplication"
...
Vous pouvez ensuite appeler cela à partir de n'importe quelle activité et enregistrer l'objet dans la classe Application.
Dans la première activité:
MyObject myObject = new MyObject();
MyApplication app = (MyApplication) getApplication();
app.setMyObject(myObject);
Dans la seconde activité, faites:
MyApplication app = (MyApplication) getApplication();
MyObject retrievedObject = app.getMyObject(myObject);
C’est pratique si vous avez des objets ayant une portée de niveau d’application, c’est-à-dire qu’ils doivent être utilisés dans l’application. La méthode Parcelable est toujours préférable si vous souhaitez un contrôle explicite sur la portée de l'objet ou si la portée est limitée.
Ceci évite toutefois l'utilisation de Intents. Je ne sais pas si ça vous va. Une autre façon que j'ai utilisée consiste à avoir des identifiants int d'objets envoyés via des intentions et à récupérer des objets que j'ai dans Maps dans l'objet Application.
public class SharedBooking implements Parcelable{
public int account_id;
public Double betrag;
public Double betrag_effected;
public int taxType;
public int tax;
public String postingText;
public SharedBooking() {
account_id = 0;
betrag = 0.0;
betrag_effected = 0.0;
taxType = 0;
tax = 0;
postingText = "";
}
public SharedBooking(Parcel in) {
account_id = in.readInt();
betrag = in.readDouble();
betrag_effected = in.readDouble();
taxType = in.readInt();
tax = in.readInt();
postingText = in.readString();
}
public int getAccount_id() {
return account_id;
}
public void setAccount_id(int account_id) {
this.account_id = account_id;
}
public Double getBetrag() {
return betrag;
}
public void setBetrag(Double betrag) {
this.betrag = betrag;
}
public Double getBetrag_effected() {
return betrag_effected;
}
public void setBetrag_effected(Double betrag_effected) {
this.betrag_effected = betrag_effected;
}
public int getTaxType() {
return taxType;
}
public void setTaxType(int taxType) {
this.taxType = taxType;
}
public int getTax() {
return tax;
}
public void setTax(int tax) {
this.tax = tax;
}
public String getPostingText() {
return postingText;
}
public void setPostingText(String postingText) {
this.postingText = postingText;
}
public int describeContents() {
// TODO Auto-generated method stub
return 0;
}
public void writeToParcel(Parcel dest, int flags) {
dest.writeInt(account_id);
dest.writeDouble(betrag);
dest.writeDouble(betrag_effected);
dest.writeInt(taxType);
dest.writeInt(tax);
dest.writeString(postingText);
}
public static final Parcelable.Creator<SharedBooking> CREATOR = new Parcelable.Creator<SharedBooking>()
{
public SharedBooking createFromParcel(Parcel in)
{
return new SharedBooking(in);
}
public SharedBooking[] newArray(int size)
{
return new SharedBooking[size];
}
};
}
Transmission des données:
Intent intent = new Intent(getApplicationContext(),YourActivity.class);
Bundle bundle = new Bundle();
i.putParcelableArrayListExtra("data", (ArrayList<? extends Parcelable>) dataList);
intent.putExtras(bundle);
startActivity(intent);
Récupération des données:
Bundle bundle = getIntent().getExtras();
dataList2 = getIntent().getExtras().getParcelableArrayList("data");
dans votre modèle de classe (Object), implémentez Serializable, pour Exemple:
public class MensajesProveedor implements Serializable {
private int idProveedor;
public MensajesProveedor() {
}
public int getIdProveedor() {
return idProveedor;
}
public void setIdProveedor(int idProveedor) {
this.idProveedor = idProveedor;
}
}
et votre première activité
MensajeProveedor mp = new MensajeProveedor();
Intent i = new Intent(getApplicationContext(), NewActivity.class);
i.putExtra("mensajes",mp);
startActivity(i);
et votre deuxième activité (NewActivity)
MensajesProveedor mensajes = (MensajesProveedor)getIntent().getExtras().getSerializable("mensajes");
bonne chance!!
Créer une application Android
Fichier >> Nouveau >> Application Android
Entrez le nom du projet: Android-pass-object-to-activity
Pakcage: com.hmkcode.Android
Conservez les autres sélections par défaut, continuez jusqu'à la fin
Avant de commencer à créer l'application, nous devons créer la classe POJO «Personne» que nous utiliserons pour envoyer un objet d'une activité à une autre. Notez que la classe implémente l'interface Serializable.
Person.Java
package com.hmkcode.Android;
import Java.io.Serializable;
public class Person implements Serializable{
private static final long serialVersionUID = 1L;
private String name;
private int age;
// getters & setters....
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
}
Deux mises en page pour deux activités
activity_main.xml
<LinearLayout 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:orientation="vertical"
tools:context=".MainActivity" >
<LinearLayout
Android:layout_width="fill_parent"
Android:layout_height="wrap_content"
Android:orientation="horizontal">
<TextView
Android:id="@+id/tvName"
Android:layout_width="100dp"
Android:layout_height="wrap_content"
Android:layout_gravity="center"
Android:gravity="center_horizontal"
Android:text="Name" />
<EditText
Android:id="@+id/etName"
Android:layout_width="wrap_content"
Android:layout_height="wrap_content"
Android:ems="10" >
<requestFocus />
</EditText>
</LinearLayout>
<LinearLayout
Android:layout_width="fill_parent"
Android:layout_height="wrap_content"
Android:orientation="horizontal">
<TextView
Android:id="@+id/tvAge"
Android:layout_width="100dp"
Android:layout_height="wrap_content"
Android:layout_gravity="center"
Android:gravity="center_horizontal"
Android:text="Age" />
<EditText
Android:id="@+id/etAge"
Android:layout_width="wrap_content"
Android:layout_height="wrap_content"
Android:ems="10" />
</LinearLayout>
<Button
Android:id="@+id/btnPassObject"
Android:layout_width="wrap_content"
Android:layout_height="wrap_content"
Android:layout_gravity="center_horizontal"
Android:text="Pass Object to Another Activity" />
</LinearLayout>
activity_another.xml
<LinearLayout 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:orientation="vertical"
>
<TextView
Android:id="@+id/tvPerson"
Android:layout_height="wrap_content"
Android:layout_width="fill_parent"
Android:layout_gravity="center"
Android:gravity="center_horizontal"
/>
</LinearLayout>
Deux classes d'activité
1) ActivityMain.Java
package com.hmkcode.Android;
import Android.os.Bundle;
import Android.app.Activity;
import Android.content.Intent;
import Android.view.View;
import Android.view.View.OnClickListener;
import Android.widget.Button;
import Android.widget.EditText;
public class MainActivity extends Activity implements OnClickListener {
Button btnPassObject;
EditText etName, etAge;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
btnPassObject = (Button) findViewById(R.id.btnPassObject);
etName = (EditText) findViewById(R.id.etName);
etAge = (EditText) findViewById(R.id.etAge);
btnPassObject.setOnClickListener(this);
}
@Override
public void onClick(View view) {
// 1. create an intent pass class name or intnet action name
Intent intent = new Intent("com.hmkcode.Android.ANOTHER_ACTIVITY");
// 2. create person object
Person person = new Person();
person.setName(etName.getText().toString());
person.setAge(Integer.parseInt(etAge.getText().toString()));
// 3. put person in intent data
intent.putExtra("person", person);
// 4. start the activity
startActivity(intent);
}
}
2) une autre activité.Java
package com.hmkcode.Android;
import Android.app.Activity;
import Android.content.Intent;
import Android.os.Bundle;
import Android.widget.TextView;
public class AnotherActivity extends Activity {
TextView tvPerson;
@Override
protected void onCreate(Bundle savedInstanceState) {
// TODO Auto-generated method stub
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_another);
// 1. get passed intent
Intent intent = getIntent();
// 2. get person object from intent
Person person = (Person) intent.getSerializableExtra("person");
// 3. get reference to person textView
tvPerson = (TextView) findViewById(R.id.tvPerson);
// 4. display name & age on textView
tvPerson.setText(person.toString());
}
}
vous pouvez utiliser les méthodes putExtra (Serializable ..) et getSerializableExtra () pour transmettre et récupérer des objets de votre type de classe; vous devrez marquer votre classe Serializable et vous assurer que toutes vos variables membres sont sérialisables aussi ...
Intent i = new Intent();
i.putExtra("name_of_extra", myParcelableObject);
startACtivity(i);
Je sais que c'est tard, mais que c'est très simple.
public class MyClass implements Serializable{
}
alors vous pouvez passer à une intention comme
Intent intent=......
MyClass obje=new MyClass();
intent.putExtra("someStringHere",obje);
Pour l'obtenir, il vous suffit d'appeler
MyClass objec=(MyClass)intent.getExtra("theString");
En utilisant la bibliothèque Gson de Google, vous pouvez transmettre un objet à une autre activité. En fait, nous convertirons un objet sous la forme d'une chaîne json et, après le passage à une autre activité, nous le convertirons à nouveau comme ceci
Considérons une classe de haricots comme celle-ci
public class Example {
private int id;
private String name;
public Example(int id, String name) {
this.id = id;
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
Nous devons passer l'objet de la classe Example
Example exampleObject=new Example(1,"hello");
String jsonString = new Gson().toJson(exampleObject);
Intent nextIntent=new Intent(this,NextActivity.class);
nextIntent.putExtra("example",jsonString );
startActivity(nextIntent);
Pour lire, nous devons faire l’opération inverse dans NextActivity
Example defObject=new Example(-1,null);
//default value to return when example is not available
String defValue= new Gson().toJson(defObject);
String jsonString=getIntent().getExtras().getString("example",defValue);
//passed example object
Example exampleObject=new Gson().fromJson(jsonString,Example .class);
Ajouter cette dépendance en grade
compile 'com.google.code.gson:gson:2.6.2'
Si vous avez quand même une classe singleton (service fx) faisant office de passerelle vers votre couche de modèle, vous pouvez la résoudre en ayant une variable dans cette classe avec des getters et des setters.
Dans l'activité 1:
Intent intent = new Intent(getApplicationContext(), Activity2.class);
service.setSavedOrder(order);
startActivity(intent);
Dans l'activité 2:
private Service service;
private Order order;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_quality);
service = Service.getInstance();
order = service.getSavedOrder();
service.setSavedOrder(null) //If you don't want to save it for the entire session of the app.
}
En service:
private static Service instance;
private Service()
{
//Constructor content
}
public static Service getInstance()
{
if(instance == null)
{
instance = new Service();
}
return instance;
}
private Order savedOrder;
public Order getSavedOrder()
{
return savedOrder;
}
public void setSavedOrder(Order order)
{
this.savedOrder = order;
}
Cette solution ne nécessite aucune sérialisation ni autre "emballage" de l'objet en question. Mais ce ne sera bénéfique que si vous utilisez ce type d'architecture de toute façon.
Commencez une autre activité à partir des paramètres de cette activité via l'objet Bundle
Intent intent = new Intent(getBaseContext(), YourActivity.class);
intent.putExtra("USER_NAME", "[email protected]");
startActivity(intent);
Récupérer sur une autre activité (YourActivity)
String s = getIntent().getStringExtra("USER_NAME");
Cela convient pour les types de données simples . Mais si vous voulez transmettre des données complexes entre vos activités, vous devez d'abord les sérialiser.
Ici nous avons le modèle employé
class Employee{
private String empId;
private int age;
print Double salary;
getters...
setters...
}
Vous pouvez utiliser Gson lib fourni par Google pour sérialiser les données complexes Comme ceci
String strEmp = new Gson().toJson(emp);
Intent intent = new Intent(getBaseContext(), YourActivity.class);
intent.putExtra("EMP", strEmp);
startActivity(intent);
Bundle bundle = getIntent().getExtras();
String empStr = bundle.getString("EMP");
Gson gson = new Gson();
Type type = new TypeToken<Employee>() {
}.getType();
Employee selectedEmp = gson.fromJson(empStr, type);
Le plus simple consisterait simplement à utiliser ce qui suit lorsque l’élément est une chaîne:
intent.putextra("selected_item",item)
Pour recevoir:
String name = data.getStringExtra("selected_item");
De loin le moyen le plus simple IMHO de parcaliser des objets. Vous venez d'ajouter une balise d'annotation au-dessus de l'objet que vous souhaitez rendre parcelable.
Voici un exemple tiré de la bibliothèque https://github.com/johncarl81/parceler
@Parcel
public class Example {
String name;
int age;
public Example(){ /*Required empty bean constructor*/ }
public Example(int age, String name) {
this.age = age;
this.name = name;
}
public String getName() { return name; }
public int getAge() { return age; }
}
Commencez par implémenter Parcelable dans votre classe. Passez ensuite un objet comme celui-ci.
SendActivity.Java
ObjectA obj = new ObjectA();
// Set values etc.
Intent i = new Intent(this, MyActivity.class);
i.putExtra("com.package.ObjectA", obj);
startActivity(i);
ReceiveActivity.Java
Bundle b = getIntent().getExtras();
ObjectA obj = b.getParcelable("com.package.ObjectA");
La chaîne de package n'est pas nécessaire, elle doit être identique dans les deux activités.
Si vous n’êtes pas très exigeant sur la fonctionnalité putExtra et souhaitez simplement lancer une autre activité avec des objets, vous pouvez consulter la bibliothèque GNLauncher ( https://github.com/noxiouswinter/gnlib_Android/wiki#gnlauncher ) I écrit pour tenter de rendre ce processus plus simple.
GNLauncher facilite l'envoi d'objets/de données à une activité à partir d'une autre activité, par exemple, en appelant une fonction de l'activité avec les paramètres requis. Il introduit la sécurité de type et supprime tous les soucis liés à la sérialisation, la liaison à l'intention à l'aide de clés de chaîne et l'annulation de celle-ci à l'autre extrémité.
We can send data one Activty1 to Activity2 with multiple ways like.
1- Intent
2- bundle
3- create an object and send through intent
.................................................
1 - Using intent
Pass the data through intent
Intent intentActivity1 = new Intent(Activity1.this, Activity2.class);
intentActivity1.putExtra("name", "Android");
startActivity(intentActivity1);
Get the data in Activity2 calss
Intent intent = getIntent();
if(intent.hasExtra("name")){
String userName = getIntent().getStringExtra("name");
}
..................................................
2- Using Bundle
Intent intentActivity1 = new Intent(Activity1.this, Activity2.class);
Bundle bundle = new Bundle();
bundle.putExtra("name", "Android");
intentActivity1.putExtra(bundle);
startActivity(bundle);
Get the data in Activity2 calss
Intent intent = getIntent();
if(intent.hasExtra("name")){
String userName = getIntent().getStringExtra("name");
}
..................................................
3- Put your Object into Intent
Intent intentActivity1 = new Intent(Activity1.this, Activity2.class);
intentActivity1.putExtra("myobject", myObject);
startActivity(intentActivity1);
Receive object in the Activity2 Class
Intent intent = getIntent();
Myobject obj = (Myobject) intent.getSerializableExtra("myobject");
À Koltin
Ajoutez une extension kotlin dans votre build.gradle.
apply plugin: 'kotlin-Android-extensions'
Android {
androidExtensions {
experimental = true
}
}
Créez ensuite votre classe de données comme ceci.
@Parcelize
data class Sample(val id: Int, val name: String) : Parcelable
Passe objet avec intention
val sample = Sample(1,"naveen")
val intent = Intent(context, YourActivity::class.Java)
intent.putExtra("id", sample)
startActivity(intent)
Obtient un objet avec intention
val sample = intent.getParcelableExtra("id")
Start another activity from this activity pass parameters via Bundle Object
Intent intent = new Intent(this, YourActivity.class);
Intent.putExtra(AppConstants.EXTRAS.MODEL, cModel);
startActivity(intent);
Retrieve on another activity (YourActivity)
ContentResultData cModel = getIntent().getParcelableExtra(AppConstants.EXTRAS.MODEL);
Le plus simple et le plus Java moyen est de: implémenter sérialisable dans votre classe pojo/model
Recommandé pour Android pour l'affichage des performances: rendre le modèle parcelable
POJO class "Post " (Notez qu'il est implémenté Serializable)
package com.example.booklib;
import Java.io.Serializable;
import Java.util.ArrayList;
import Java.util.List;
import Android.graphics.Bitmap;
public class Post implements Serializable{
public String message;
public String bitmap;
List<Comment> commentList = new ArrayList<Comment>();
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
public String getBitmap() {
return bitmap;
}
public void setBitmap(String bitmap) {
this.bitmap = bitmap;
}
public List<Comment> getCommentList() {
return commentList;
}
public void setCommentList(List<Comment> commentList) {
this.commentList = commentList;
}
}
POJO class "Comment" (étant membre de la classe Post, il est également nécessaire d'implémenter Serializable)
package com.example.booklib;
import Java.io.Serializable;
public class Comment implements Serializable{
public String message;
public String fromName;
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
public String getFromName() {
return fromName;
}
public void setFromName(String fromName) {
this.fromName = fromName;
}
}
Ensuite, dans votre classe d’activité, vous pouvez procéder comme suit pour transmettre l’objet à une autre activité.
ListView listview = (ListView) findViewById(R.id.post_list);
listview.setOnItemClickListener(new OnItemClickListener(){
@Override
public void onItemClick(AdapterView<?> parent, View view,
int position, long id) {
Post item = (Post)parent.getItemAtPosition(position);
Intent intent = new Intent(MainActivity.this,CommentsActivity.class);
intent.putExtra("post",item);
startActivity(intent);
}
});
Dans votre classe de destinataire "CommentsActivity" vous pouvez obtenir les données comme suit
Post post =(Post)getIntent().getSerializableExtra("post");