Как отправить объект из одного Android-активности в другой с помощью Intents?
34 ответа
Самое простое решение, которое я нашел, - это создать класс со статическими членами-данными с установщиками-получателями.
установить из одного действия и получить из другого действия этот объект.
деятельность А
mytestclass.staticfunctionSet("","",""..etc.);
деятельность б
mytestclass obj= mytestclass.staticfunctionGet();
Если вы просто передаете объекты, то Parcelable был разработан для этого. Это требует немного больше усилий для использования, чем использование нативной сериализации Java, но это намного быстрее (и я имею в виду, гораздо быстрее).
Из документации простой пример того, как реализовать:
// 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();
}
}
Обратите внимание, что в случае, если у вас есть более одного поля для извлечения из данной посылки, вы должны делать это в том же порядке, в котором вы их поместили (то есть в подходе FIFO).
Как только у вас есть ваши объекты реализовать Parcelable это просто вопрос помещения их в ваши интенты с помощью putExtra ():
Intent i = new Intent();
i.putExtra("name_of_extra", myParcelableObject);
Затем вы можете вытащить их обратно с помощью getParcelableExtra ():
Intent i = getIntent();
MyParcelable myParcelableObject = (MyParcelable) i.getParcelableExtra("name_of_extra");
Если ваш класс объектов реализует Parcelable и Serializable, убедитесь, что вы выполнили приведение к одному из следующих:
i.putExtra("parcelable_extra", (Parcelable) myParcelableObject);
i.putExtra("serializable_extra", (Serializable) myParcelableObject);
Вам нужно будет сериализовать ваш объект в какое-то строковое представление. Одним из возможных строковых представлений является JSON, и одним из самых простых способов сериализации в / из JSON в Android, если вы спросите меня, является Google GSON.
В этом случае вы просто помещаете строковое возвращаемое значение из (new Gson()).toJson(myObject); и получить значение строки и использовать fromJson превратить его обратно в ваш объект.
Однако, если ваш объект не очень сложный, это может не стоить дополнительных затрат, и вы можете вместо этого передать отдельные значения объекта.
Вы можете отправить сериализуемый объект через намерение
// 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 {
}
Если вы знаете, что будете передавать данные в приложении, используйте "глобальные переменные" (например, статические классы).
Вот что по этому поводу сказала Дайан Хэкборн (hackbod - инженер по программному обеспечению Google Android):
Если вы знаете, что действия выполняются в одном и том же процессе, вы можете просто обмениваться данными через глобальные переменные. Например, вы могли бы иметь глобальный
HashMap<String, WeakReference<MyInterpreterState>>и когда вы создаете новый MyInterpreterState, придумаете для него уникальное имя и помещаете его в хэш-карту; чтобы отправить это состояние другому действию, просто поместите уникальное имя в хэш-карту, и когда второе действие будет запущено, оно может извлечь MyInterpreterState из хэш-карты с полученным именем.
Ваш класс должен реализовывать Serializable или Parcelable.
public class MY_CLASS implements Serializable
После этого вы можете отправить объект на putExtra
intent.putExtra("KEY", MY_CLASS_instance);
startActivity(intent);
Чтобы получить дополнительные услуги, вам нужно только сделать
Intent intent = getIntent();
MY_CLASS class = (MY_CLASS) intent.getExtras().getSerializable("KEY");
Если ваш класс реализует Parcelable, используйте следующее
MY_CLASS class = (MY_CLASS) intent.getExtras().getParcelable("KEY");
Надеюсь, это поможет:D
Реализовать сериализуемый в вашем классе
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;
}
}
Тогда вы можете передать этот объект в намерение
Intent intent = new Intent(this, SecondAct.class);
intent.putExtra("PLACE", Place);
startActivity();
во втором упражнении вы можете получить такие данные
Place place= (Place) getIntent().getSerializableExtra("PLACE");
Но когда данные станут большими, этот метод будет медленным.
Короткий ответ для быстрой необходимости
1. Реализуйте свой класс для сериализации.
Если у вас есть внутренние классы, не забудьте также реализовать их в Serializable!!
public class SportsData implements Serializable
public class Sport implements Serializable
List<Sport> clickedObj;
2. Поместите свой объект в намерение
Intent intent = new Intent(SportsAct.this, SportSubAct.class);
intent.putExtra("sport", clickedObj);
startActivity(intent);
3. И получите свой объект в другом классе деятельности
Intent intent = getIntent();
Sport cust = (Sport) intent.getSerializableExtra("sport");
Если ваш объектный класс реализует Serializable вам больше ничего не нужно делать, вы можете передать сериализуемый объект.
это то, что я использую.
Есть несколько способов получить доступ к переменным или объектам в других классах или Activity.
А. База данных
Б. общие предпочтения.
C. Сериализация объектов.
D. Класс, который может содержать общие данные, может называться Common Utilities, это зависит от вас.
E. Передача данных через Intents и Parcelable Interface.
Это зависит от потребностей вашего проекта.
А. База данных
SQLite - это база данных с открытым исходным кодом, встроенная в Android. SQLite поддерживает стандартные функции реляционной базы данных, такие как синтаксис SQL, транзакции и подготовленные операторы.
Учебники - http://www.vogella.com/articles/AndroidSQLite/article.html
Б. Общие предпочтения
Предположим, вы хотите сохранить имя пользователя. Таким образом, теперь будет две вещи: ключевое имя пользователя, значение- значение.
Как хранить
// 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();
Используя putString(),putBoolean(),putInt(),putFloat(),putLong() вы можете сохранить желаемый тип данных.
Как получить
SharedPreferences sharedPref = PreferenceManager.getDefaultSharedPreferences(this);
String userName = sharedPref.getString("userName", "Not Available");
http://developer.android.com/reference/android/content/SharedPreferences.html
C. Сериализация объектов
Объектная серизация используется, если мы хотим сохранить состояние объекта, чтобы отправить его по сети, или вы можете использовать его для своих целей.
Используйте Java-бины и сохраняйте их как одно из его полей и используйте для этого методы getter и setter.
JavaBeans - это классы Java, которые имеют свойства. Думайте о свойствах как о частных переменных экземпляра. Поскольку они являются частными, единственный доступ к ним из-за пределов их класса - через методы в классе. Методы, которые изменяют значение свойства, называются методами установки, а методы, которые извлекают значение свойства, называются методами получения.
public class VariableStorage implements Serializable {
private String inString ;
public String getInString() {
return inString;
}
public void setInString(String inString) {
this.inString = inString;
}
}
Установите переменную в вашем почтовом методе, используя
VariableStorage variableStorage = new VariableStorage();
variableStorage.setInString(inString);
Затем используйте сериализацию объекта для сериализации этого объекта, а в другом классе десериализуйте этот объект.
При сериализации объект может быть представлен в виде последовательности байтов, которая включает в себя данные объекта, а также информацию о типе объекта и типах данных, хранящихся в объекте.
После записи в файл сериализованного объекта его можно прочитать из файла и десериализовать, то есть информацию о типе и байты, которые представляют объект и его данные, можно использовать для воссоздания объекта в памяти.
Если вы хотите учебник для этого, обратитесь по этой ссылке
http://javawithswaranga.blogspot.in/2011/08/serialization-in-java.html
Получить переменную в других классах
D. Общие коммунальные услуги
Вы можете сами создать класс, который может содержать общие данные, которые вам часто нужны в вашем проекте.
Образец
public class CommonUtilities {
public static String className = "CommonUtilities";
}
E. Передача данных через намерения
Пожалуйста, обратитесь к этому руководству для этой опции передачи данных.
Вы можете использовать Android BUNDLE, чтобы сделать это.
Создайте комплект из вашего класса, например:
public Bundle toBundle() {
Bundle b = new Bundle();
b.putString("SomeKey", "SomeValue");
return b;
}
Затем передайте этот комплект с намерением. Теперь вы можете воссоздать ваш объект класса, передав
public CustomClass(Context _context, Bundle b) {
context = _context;
classMember = b.getString("SomeKey");
}
Объявите это в своем пользовательском классе и используйте.
Спасибо за посылочную помощь, но я нашел еще одно дополнительное решение
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;
}
}
В первом упражнении
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);
Получить данные в упражнении 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());
}
Я использую Gson с его настолько мощным и простым API для отправки объектов между действиями,
пример
// 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 функции вы добавляете их к объектам, которые вы хотите отправить
использование
Отправить объект от А до Б
// 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);
Получить в б
@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);
}
Я использую его почти в каждом проекте, и у меня нет проблем с производительностью.
Я боролся с той же проблемой. Я решил это с помощью статического класса, храня любые данные, которые я хочу в HashMap. Сверху я использую расширение стандартного класса Activity, в котором я переопределил методы onCreate и onDestroy для скрытой передачи данных и их очистки. Некоторые нелепые настройки должны быть изменены, например, ориентация.
Аннотация: Отсутствие общих объектов для передачи другому. Деятельность - это боль в заднице. Это все равно что выстрелить себе в колено и надеяться выиграть 100 метров. "Parcable" не является достаточной заменой. Это заставляет меня смеяться... Я не хочу внедрять этот интерфейс в мой API без технологий, так как меньше я хочу представить новый уровень... Как могло случиться, что мы находимся в мобильном программировании так далеко от современная парадигма...
В вашей первой деятельности:
intent.putExtra("myTag", yourObject);
И в твоем втором:
myCustomObject myObject = (myCustomObject) getIntent().getSerializableExtra("myTag");
Не забудьте сделать свой пользовательский объект Сериализуемым:
public class myCustomObject implements Serializable {
...
}
Еще один способ сделать это - использовать Application объект (android.app.Application). Вы определяете это в себе AndroidManifest.xml файл как:
<application
android:name=".MyApplication"
...
Затем вы можете вызвать это из любого действия и сохранить объект в Application учебный класс.
В FirstActivity:
MyObject myObject = new MyObject();
MyApplication app = (MyApplication) getApplication();
app.setMyObject(myObject);
В SecondActivity выполните:
MyApplication app = (MyApplication) getApplication();
MyObject retrievedObject = app.getMyObject(myObject);
Это удобно, если у вас есть объекты, имеющие область действия уровня приложения, т.е. они должны использоваться во всем приложении. Parcelable Метод все еще лучше, если вы хотите явно контролировать область объекта или если область ограничена.
Это позволяет избежать использования Intents в целом, хотя. Я не знаю, подходят ли они тебе. Другой способ, которым я использовал это, чтобы иметь int идентификаторы объектов отправлять через намерения и извлекать объекты, которые у меня есть в Картах в Application объект.
В вашей модели класса (Object) реализовать Serializable, например:
public class MensajesProveedor implements Serializable {
private int idProveedor;
public MensajesProveedor() {
}
public int getIdProveedor() {
return idProveedor;
}
public void setIdProveedor(int idProveedor) {
this.idProveedor = idProveedor;
}
}
и ваша первая активность
MensajeProveedor mp = new MensajeProveedor();
Intent i = new Intent(getApplicationContext(), NewActivity.class);
i.putExtra("mensajes",mp);
startActivity(i);
и ваша вторая активность (NewActivity)
MensajesProveedor mensajes = (MensajesProveedor)getIntent().getExtras().getSerializable("mensajes");
удачи!!
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];
}
};
}
Передача данных:
Intent intent = new Intent(getApplicationContext(),YourActivity.class);
Bundle bundle = new Bundle();
i.putParcelableArrayListExtra("data", (ArrayList<? extends Parcelable>) dataList);
intent.putExtras(bundle);
startActivity(intent);
Извлечение данных:
Bundle bundle = getIntent().getExtras();
dataList2 = getIntent().getExtras().getParcelableArrayList("data");
Используя библиотеку Google Gson, вы можете передать объект другим действиям. Фактически мы преобразуем объект в виде строки json, а после перехода к другому действию мы снова преобразуем объект таким образом.
Рассмотрим класс бобов вот так
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;
}
}
Нам нужно передать объект класса 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);
Для чтения нам нужно сделать обратную операцию в 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);
Добавьте эту зависимость в Gradle
compile 'com.google.code.gson:gson:2.6.2'
Создать приложение для Android
Файл >> Новый >> Приложение Android
Введите имя проекта: android-pass-object-to-activity
Pakcage: com.hmkcode.android
Сохраняйте другие значения по умолчанию
Перед началом создания приложения нам нужно создать класс POJO "Person", который мы будем использовать для отправки объекта из одного действия в другое. Обратите внимание, что класс реализует интерфейс 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 + "]";
}
}
Два макета для двух занятий
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>
Два занятия
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) AnotherActivity.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());
}
}
Вы можете использовать методы putExtra(Serializable..) и getSerializableExtra() для передачи и извлечения объектов вашего типа; вам нужно пометить ваш класс как Serializable и убедиться, что все ваши переменные-члены тоже сериализуемы...
Я знаю, что уже поздно, но это очень просто. Все, что вам нужно сделать, это позволить вашему классу реализовать Serializable, как
public class MyClass implements Serializable{
}
тогда вы можете перейти к намерению, как
Intent intent=......
MyClass obje=new MyClass();
intent.putExtra("someStringHere",obje);
Чтобы получить его, вы просто позвоните
MyClass objec=(MyClass)intent.getExtra("theString");
Самый простой и Java-способ сделать это: реализовать сериализуемость в вашем классе pojo/model
Рекомендуется для Android для просмотра производительности: сделать модель пригодной для продажи
Сначала реализуйте Parcelable в своем классе. Затем передайте объект, как это.
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");
Строка пакета не обязательна, просто строка должна быть одинаковой в обеих операциях
Если у вас есть одноэлементный класс (fx Service), который в любом случае выступает в качестве шлюза к уровню вашей модели, его можно решить, если для него есть переменная в этом классе с методами получения и установки.
В упражнении 1:
Intent intent = new Intent(getApplicationContext(), Activity2.class);
service.setSavedOrder(order);
startActivity(intent);
В упражнении 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.
}
В сервисе:
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;
}
Это решение не требует какой-либо сериализации или другой "упаковки" рассматриваемого объекта. Но это будет полезно только в том случае, если вы все равно будете использовать такую архитектуру.
Intent i = new Intent();
i.putExtra("name_of_extra", myParcelableObject);
startACtivity(i);
Запустите другое действие с помощью параметров передачи этого действия через Bundle Object
Intent intent = new Intent(getBaseContext(), YourActivity.class);
intent.putExtra("USER_NAME", "xyz@gmail.com");
startActivity(intent);
Получить другой вид деятельности (YourActivity)
String s = getIntent().getStringExtra("USER_NAME");
Это нормально для простого типа данных. Но если вы хотите передать сложные данные между действиями, вам нужно сначала сериализовать их.
Здесь у нас есть модель сотрудника
class Employee{
private String empId;
private int age;
print Double salary;
getters...
setters...
}
Вы можете использовать Gson lib, предоставленный Google, для сериализации сложных данных, подобных этой
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);
Безусловно самый простой способ ИМХО для посылки объектов. Вы просто добавляете тег аннотации над объектом, который хотите сделать пригодным для продажи.
Пример из библиотеки ниже 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; }
}
В Колтин
Добавьте расширение kotlin в ваш build.gradle.
apply plugin: 'kotlin-android-extensions'
android {
androidExtensions {
experimental = true
}
}
Затем создайте свой класс данных следующим образом.
@Parcelize
data class Sample(val id: Int, val name: String) : Parcelable
Передать объект с намерением
val sample = Sample(1,"naveen")
val intent = Intent(context, YourActivity::class.java)
intent.putExtra("id", sample)
startActivity(intent)
Получить объект с намерением
val sample = intent.getParcelableExtra("id")
Простейшим было бы просто использовать следующее, где элемент является строкой:
intent.putextra("selected_item",item)
Для получения:
String name = data.getStringExtra("selected_item");