Comment envoyer un objet D'une activité Android à une autre en utilisant Intents?
Comment passer un objet d'un type personnalisé d'un activité à un autre en utilisant la méthode putExtra() de la classe intention ?
30 réponses
si vous ne faites que passer des objets, alors séparable a été conçu pour cela. Il nécessite un peu plus d'efforts à utiliser que L'utilisation de Java natif serialization, mais il est beaucoup plus rapide (et je veux dire, plus rapide).
D'après le docs, un exemple simple pour la mise en œuvre est:
// 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();
}
}
Observer que dans le cas où vous avez plus d'un champ à récupérer à partir d'un colis donné, vous devez le faire dans le même ordre que vous les mettez (c'est-à-dire dans une approche FIFO).
une fois que vous avez vos objets mettre en œuvre Parcelable il est juste une question de les mettre dans votre intentions avec putExtra () :
Intent i = new Intent();
i.putExtra("name_of_extra", myParcelableObject);
puis vous pouvez les retirer avec getparcelablextra () :
Intent i = getIntent();
MyParcelable myParcelableObject = (MyParcelable) i.getParcelableExtra("name_of_extra");
si votre classe D'objet
i.putExtra("parcelable_extra", (Parcelable) myParcelableObject);
i.putExtra("serializable_extra", (Serializable) myParcelableObject);
vous aurez besoin de sérialiser votre objet en une sorte de représentation de chaîne. Une représentation de chaîne de caractères possible est JSON, et l'une des façons les plus faciles de sérialiser à/de JSON dans android, si vous me demandez, est par Google Gson .
dans ce cas, vous venez de mettre la valeur de retour de chaîne de (new Gson()).toJson(myObject); et de récupérer la valeur de chaîne de caractères et d'utiliser fromJson pour le retourner dans votre objet.
Si votre objet n'est pas très complexe, cependant, il se peut que cela ne vaille pas la peine de passer au-dessus, et vous pourriez envisager de passer les valeurs séparées de l'objet à la place.
Vous pouvez envoyer serializable objet à travers l'intention de
// 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 où vous savez que vous allez transmettre des données dans une application, utilisez "globals" (comme les Classes statiques)
Ici est ce que Dianne Hackborn (hackbod - un Logiciel Android de Google Ingénieur) avait à dire sur le sujet:
pour les situations où vous savez que les activités se déroulent dans le même processus, vous pouvez juste partager des données à travers des globales. Par exemple, vous pourrait à l'échelle mondiale
HashMap<String, WeakReference<MyInterpreterState>>et quand vous faites un nouveau MyInterpreterState arriver avec un nom unique pour cela et le mettre dans la carte de hachage; pour envoyer cet état à un autre activité, il suffit de mettre le nom unique dans la carte de hachage et lorsque le la deuxième activité est commencée il peut récupérer le MyInterpreterState de la carte de hachage avec le nom qu'elle reçoit.
votre classe devrait implémenter Serialisable ou Morcelable.
public class MY_CLASS implements Serializable
une fois fait, vous pouvez envoyer un objet sur putExtra
intent.putExtra("KEY", MY_CLASS_instance);
startActivity(intent);
pour obtenir des extras vous n'avez qu'à faire
Intent intent = getIntent();
MY_CLASS class = (MY_CLASS) intent.getExtras().getSerializable("KEY");
si votre classe implémente la fonction de parcellisation, utilisez la suivante
MY_CLASS class = (MY_CLASS) intent.getExtras().getParcelable("KEY");
j'espère que cela aide :D
si votre classe d'objet implémente Serializable , vous n'avez pas besoin de faire autre chose, vous pouvez passer un objet sérialisable.
c'est ce que j'utilise.
réponse courte pour un besoin rapide
1. Implémenter votre classe à sérialisable.
si vous avez des Classes internes n'oubliez pas de les implémenter à Serialisable aussi!!
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 de recevoir votre objet dans l'autre classe D'activité
Intent intent = getIntent();
Sport cust = (Sport) intent.getSerializableExtra("sport");
vous pouvez utiliser Android BUNDLE pour ce faire.
créer un paquet de votre classe comme:
public Bundle toBundle() {
Bundle b = new Bundle();
b.putString("SomeKey", "SomeValue");
return b;
}
alors passez ce paquet avec intention. Maintenant, vous pouvez recréer votre objet de classe en passant bundle comme
public CustomClass(Context _context, Bundle b) {
context = _context;
classMember = b.getString("SomeKey");
}
déclarez ceci dans votre classe personnalisée et utilisation.
Merci pour l'aide, mais j'ai trouvé une solution optionnelle de plus
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é 1
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());
}
implémenter serialisable 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;
}
}
alors vous pouvez passer cet objet en intention
Intent intent = new Intent(this, SecondAct.class);
intent.putExtra("PLACE", Place);
startActivity();
dans la deuxième activité vous pouvez obtenir des données comme ceci
Place place= (Place) getIntent().getSerializableExtra("PLACE");
Mais lorsque les données sont volumineuses,cette méthode sera lente.
il y a plusieurs façons d'accéder à des variables ou à des objets dans d'autres classes ou activités.
A. Base De Données
B. préférences partagées.
C. sérialisation des objets.
D. Une classe qui peut contenir des données communes peut être nommée comme utilitaire commun cela dépend de vous.
E. transmission des données par Intents et par L'Interface séparable.
cela dépend sur les besoins de votre projet.
A. Base De Données
SQLite est une base de données Open Source intégrée dans Android. SQLite soutient les traits de base de données relationnelles standard comme la syntaxe de SQL, les transactions et les déclarations préparées.
tutoriels -- http://www.vogella.com/articles/AndroidSQLite/article.html
B. Préférences Partagées
supposez que vous voulez stocker le nom d'utilisateur. Donc, il y aura maintenant deux choses une clé nom D'utilisateur, valeur valeur.
comment conserver
// 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 sauvegarder votre dtatype désiré.
Comment extraire les
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'Un Objet
la serlization D'objet est utilisée si nous voulons enregistrer un État d'objet pour l'envoyer sur le réseau ou vous pouvez l'utiliser pour votre but également.
utilisez Java beans et stocker en elle comme l'un de ses champs et d'utiliser getters et setter pour cela
JavaBeans sont des classes Java qui ont des propriétés. Pensez propriétés comme variables d'instance privée. Depuis qu'ils sont privés, la seule façon ils peuvent être accessibles à partir de l'extérieur de leur classe est par des méthodes dans la classe. Le les méthodes qui changent la valeur d'une propriété sont appelées méthodes setter, et les méthodes qui récupèrent 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 la méthode de courrier en utilisant
VariableStorage variableStorage = new VariableStorage();
variableStorage.setInString(inString);
puis utilisez la sérialisation d'objet pour sérialiser cet objet et dans votre autre classe désérialiser cet objet.
Dans la sérialisation d'un objet peut être représenté comme une séquence d'octets qui comprend les données de l'objet ainsi que des informations sur le type de l'objet et les types de données stockées dans l'objet.
après qu'un objet sérialisé ait été écrit dans un fichier, il peut être lu à partir du fichier et désérialisé, c'est-à-dire l'information de type et octets qui représentent l'objet et ses données peuvent être utilisées pour recréer l'objet en mémoire.
si vous voulez un tutoriel pour cette référence ce lien
http://javawithswaranga.blogspot.in/2011/08/serialization-in-java.html
Get variable dans d'autres classes
D. CommonUtilities
Vous pouvez faire une classe par vous-même qui peut contenir des données communes dont vous avez fréquemment besoin dans votre projet.
échantillon
public class CommonUtilities {
public static String className = "CommonUtilities";
}
E. transmission de Données par les Intentions
consultez 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 que vous ajoutez aux objets que vous voulez envoyer
Utilisation
envoyer L'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 Dans 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.
je me suis battu avec le même problème. Je l'ai résolu en utilisant une classe statique, en stockant toutes les données que je veux dans une HashMap. En plus j'utilise une extension de la classe d'activité standard où j'ai dépassé les méthodes oncréate un onDestroy pour faire le transport de données et le nettoyage de données caché. Certains paramètres ridicules doivent être changés, par exemple la gestion de l'orientation.
Annotation: Ne pas fournir des objets généraux à passer à une autre activité est une douleur dans le cul. C'est comme se tirer dans le genou et espérer gagner un 100 mètres. Le terme "identifiable" n'est pas un substitut suffisant. Il me fait rire... Je ne veux pas implémenter cette interface pour mon API sans technologie, car je ne veux pas introduire une nouvelle couche... Comment cela pourrait-il être, que nous sommes dans la programmation mobile si loin du paradigme moderne...
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é sérialisable:
public class myCustomObject implements Serializable {
...
}
une autre façon de faire cela est d'utiliser l'objet Application (android.App.Application.) Vous définissez ceci en vous AndroidManifest.xml fichier comme:
<application
android:name=".MyApplication"
...
vous pouvez alors appeler cela de n'importe quelle activité et sauvegarder l'objet dans la classe Application .
dans la première activité:
MyObject myObject = new MyObject();
MyApplication app = (MyApplication) getApplication();
app.setMyObject(myObject);
dans la deuxième activité, faire:
MyApplication app = (MyApplication) getApplication();
MyObject retrievedObject = app.getMyObject(myObject);
c'est pratique si vous avez des objets qui ont niveau d'application portée, c'est-à-dire qu'ils doivent être utilisés dans l'ensemble de l'application. La méthode Parcelable est encore meilleure si vous voulez un contrôle explicite sur la portée de l'objet ou si la portée est limitée.
cela évite l'utilisation de Intents tout à fait, cependant. Je ne sais pas si ils vous convient. Une autre façon que j'ai utilisée est d'avoir des identificateurs int d'objets envoient par intentions et récupèrent des objets que j'ai dans les cartes dans l'objet Application .
dans votre modèle de classe (objet) implémenter Serialisable, 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é (nouvelle activité)
MensajesProveedor mensajes = (MensajesProveedor)getIntent().getExtras().getSerializable("mensajes");
bonne chance!!
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);
extraire les données:
Bundle bundle = getIntent().getExtras();
dataList2 = getIntent().getExtras().getParcelableArrayList("data");
la solution la plus facile que j'ai trouvée est.. pour créer une classe avec des membres de données statiques avec des setters getters.
établi à partir d'une activité et obtenir à partir d'une autre activité qui objet.
activité a
mytestclass.staticfunctionSet("","",""..etc.);
activité b
mytestclass obj= mytestclass.staticfunctionGet();
vous pouvez utiliser putExtra(sérialisable..) et les méthodes getSerializableExtra () pour passer et récupérer des objets de votre type de classe; vous devrez marquer votre classe Serialisable et vous assurer que toutes vos variables de membre sont serialisables aussi...
Créer Application Android
Fichier >> Nouveau >> Android Application
Entrez le nom du Projet: android-pass-objet-de-activité
Pakcage: com.hmkcode.android
Gardez les autres sélections de defualt, allez Jusqu'à ce que vous atteigniez la fin
avant de commencer à créer l'application, nous avons besoin de créer la classe POJO" personne " que nous utiliserons pour envoyer un objet d'une activité à une autre. Notez que la classe implémente Serializable interface.
personne.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 aménagements 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());
}
}
Intent i = new Intent();
i.putExtra("name_of_extra", myParcelableObject);
startACtivity(i);
je sais que c'est tard, mais c'est très simple.Tout ce que vous avez à faire est de laisser votre classe implémenter Serialisable comme
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 vous appelez simpley
MyClass objec=(MyClass)intent.getExtra("theString");
en utilisant la bibliothèque Gson de google vous pouvez passer objet à d'autres activités.En fait, nous allons convertir l'objet sous forme de chaîne json et après être passé à une autre activité, nous allons de nouveau convertir en objet comme ceci
Envisager une classe d'haricot comme ce
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 objet de la classe D'exemple
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 la lecture, nous avons besoin de faire l'opération inverse en 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 Grad
compile 'com.google.code.gson:gson:2.6.2'
Le plus simple serait d'utiliser seulement la suivante où l'élément est une chaîne de caractères:
intent.putextra("selected_item",item)
pour la réception:
String name = data.getStringExtra("selected_item");
si vous avez une classe singleton (Service fx) agissant comme passerelle vers votre couche model de toute façon, il peut être résolu en ayant une variable dans cette classe avec getters et setters pour elle.
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 pas de sérialisation ou autres "emballage" de l'objet en question. Mais il ne être bénéfique si vous utilisez ce type d'architecture, de toute façon.
de loin la manière la plus facile IMHO pour emballer des objets. Vous n'avez qu'à ajouter une étiquette d'annotation au-dessus de l'objet que vous souhaitez rendre séparable.
un exemple de la Bibliothèque est ci-dessous 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; }
}
premier implémentation séparable dans votre classe. Alors passez l'objet comme ceci.
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 paquets n'est pas nécessaire, juste la chaîne doit être la même dans les deux activités
lancer une autre activité à partir de cette activité passer les paramètres via L'objet Bundle
Intent intent = new Intent(getBaseContext(), YourActivity.class);
intent.putExtra("USER_NAME", "xyz@gmail.com");
startActivity(intent);
rechercher sur une autre activité (votre activité)
String s = getIntent().getStringExtra("USER_NAME");
c'est ok pour le type de données de type simple. Mais si vous voulez transmettre des données complexes entre deux 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 le de 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);
si vous n'êtes pas très particulier sur l'utilisation de la fonctionnalité putExtra et que vous voulez juste lancer une autre activité avec des objets, vous pouvez consulter le GNLauncher ( https://github.com/noxiouswinter/gnlib_android/wiki#gnlauncher ) bibliothèque j'ai écrit dans une tentative de rendre ce processus plus simple.
GNLauncher rend l'envoi d'objets/données à une activité d'une autre activité etc aussi facile que l'appel d'une fonction dans l'activité avec le données requises comme paramètres. Il introduit la sécurité de type et élimine tous les tracas d'avoir à sérialiser, attachant à l'intention en utilisant des clés de chaîne et de défaire la même à l'autre extrémité.
POJO class "Post "(notez qu'il est implémenté en série)
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 Post class,il est également nécessaire de mettre en œuvre le Serialisable)
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;
}
}
Puis dans votre classe d'activité, vous pouvez faire comme suit pour passer 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 catégorie de bénéficiaires "CommentsActivity" vous pouvez obtenir les données suivantes
Post post =(Post)getIntent().getSerializableExtra("post");