인 텐트를 사용하여 한 Android 활동에서 다른 활동으로 객체를 보내는 방법은 무엇입니까?
Intent 클래스 의 메서드를 사용하여 한 Activity 에서 다른 Activity 로 사용자 지정 유형의 개체를 어떻게 전달할 수 있습니까?putExtra()
물체를 그냥 지나가는 경우 Parcelable이이 를 위해 설계되었습니다. 그것은 자바의 네이티브 직렬화를 사용하는 것보다 사용에 조금 더 많은 노력이 필요하지만, 그것의 빠른 방법은 (그리고 나는 평균 방법, WAY 빠르게).
문서에서 구현하는 방법에 대한 간단한 예는 다음과 같습니다.
// 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();
}
}
주어진 Parcel에서 검색 할 필드가 두 개 이상인 경우 입력 한 것과 동일한 순서 (즉, 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이며 Android에서 JSON으로 /부터 직렬화하는 가장 쉬운 방법 중 하나는 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 {
}
응용 프로그램 내에서 데이터를 전달할 것임을 알고있는 상황에서는 "전역"(예 : 정적 클래스)을 사용하십시오.
다음 은 Dianne Hackborn (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
빠른 요구에 대한 짧은 대답
1. 클래스를 Serializable로 구현하십시오.
내부 클래스가 있으면 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다른 작업을 수행 할 필요가 없으며 직렬화 가능한 객체를 전달할 수 있습니다.
그것이 내가 사용하는 것입니다.
클래스에서 직렬화 가능 구현
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(intent);
두 번째 활동에서 다음과 같은 데이터를 얻을 수 있습니다.
Place place= (Place) getIntent().getSerializableExtra("PLACE");
그러나 데이터가 커지면이 방법은 느려질 것입니다.
이를 위해 android BUNDLE을 사용할 수 있습니다.
다음과 같이 클래스에서 번들을 만듭니다.
public Bundle toBundle() {
Bundle b = new Bundle();
b.putString("SomeKey", "SomeValue");
return b;
}
그런 다음이 번들을 INTENT로 전달합니다. 이제 번들을 다음과 같이 전달하여 클래스 객체를 다시 만들 수 있습니다.
public CustomClass(Context _context, Bundle b) {
context = _context;
classMember = b.getString("SomeKey");
}
이것을 Custom 클래스에 선언하고 사용하십시오.
다른 클래스 또는 활동의 변수 또는 개체에 액세스 할 수있는 몇 가지 방법이 있습니다.
A. 데이터베이스
B. 공유 선호도.
C. 객체 직렬화.
D. 공통 데이터를 보유 할 수있는 클래스는 사용자에 따라 공통 유틸리티로 명명 될 수 있습니다.
E. 인 텐트 및 Parcelable 인터페이스를 통한 데이터 전달.
프로젝트 요구 사항에 따라 다릅니다.
A. 데이터베이스
SQLite는 Android에 내장 된 오픈 소스 데이터베이스입니다. SQLite는 SQL 구문, 트랜잭션 및 준비된 문과 같은 표준 관계형 데이터베이스 기능을 지원합니다.
자습서-http: //www.vogella.com/articles/AndroidSQLite/article.html
B. 공유 기본 설정
사용자 이름을 저장한다고 가정합니다. 이제 키 사용자 이름, 값 값 이라는 두 가지가 있습니다 .
보관 방법
// 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 ()을 사용하여 원하는 dtatype을 저장할 수 있습니다.
가져 오는 방법
SharedPreferences sharedPref = PreferenceManager.getDefaultSharedPreferences(this);
String userName = sharedPref.getString("userName", "Not Available");
http://developer.android.com/reference/android/content/SharedPreferences.html
C. 객체 직렬화
Object serlization은 객체 상태를 저장하여 네트워크를 통해 전송하거나 사용자의 목적으로 사용할 수도 있습니다.
Java Bean을 사용하고 필드 중 하나로 저장하고 getter 및 setter를 사용하십시오.
JavaBeans는 속성이있는 Java 클래스입니다. 속성을 개인 인스턴스 변수로 생각하십시오. 비공개이므로 클래스 외부에서 액세스 할 수있는 유일한 방법은 클래스의 메서드를 통해서입니다. 속성 값을 변경하는 메서드를 setter 메서드라고하고 속성 값을 검색하는 메서드를 getter 메서드라고합니다.
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);
그런 다음 개체 Serialzation을 사용하여이 개체를 직렬화하고 다른 클래스에서이 개체를 역 직렬화합니다.
직렬화에서 객체는 객체의 데이터와 객체의 유형 및 객체에 저장된 데이터 유형에 대한 정보를 포함하는 바이트 시퀀스로 표현 될 수 있습니다.
직렬화 된 객체가 파일에 기록 된 후에는 파일에서 읽고 직렬화 해제 할 수 있습니다. 즉, 객체와 해당 데이터를 나타내는 유형 정보와 바이트를 사용하여 메모리에서 객체를 다시 만들 수 있습니다.
이 튜토리얼을 원한다면이 링크를 참조하십시오.
http://javawithswaranga.blogspot.in/2011/08/serialization-in-java.html
D. CommonUtilities
프로젝트에서 자주 필요한 공통 데이터를 담을 수있는 수업을 스스로 만들 수 있습니다.
견본
public class CommonUtilities {
public static String className = "CommonUtilities";
}
E. 인 텐트를 통한 데이터 전달
이 데이터 전달 옵션에 대해서는이 튜토리얼을 참조하십시오.
소포 가능한 도움을 주셔서 감사하지만 선택적인 해결책을 하나 더 찾았습니다.
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;
}
}
활동 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);
활동 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 가지 기능
용법
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);
수신 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);
}
나는 거의 모든 프로젝트에서 그것을 사용하고 성능 문제가 없습니다.
나는 같은 문제로 고생했다. 정적 클래스를 사용하여 HashMap에 원하는 데이터를 저장하여 해결했습니다. 맨 위에는 onCreate an onDestroy 메서드를 재정 의하여 데이터 전송 및 데이터 지우기 숨김을 수행 한 표준 Activity 클래스의 확장을 사용합니다. 일부 우스꽝스러운 설정 (예 : 방향 처리)을 변경해야합니다.
주석 : 다른 활동에 전달할 일반 개체를 제공하지 않는 것은 당연한 일입니다. 그것은 마치 무릎을 꿇고 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");
내가 찾은 가장 쉬운 해결책은 getter setter를 사용하여 정적 데이터 멤버가있는 클래스를 만드는 것입니다.
한 활동에서 설정하고 다른 활동에서 가져옵니다.
활동 A
mytestclass.staticfunctionSet("","",""..etc.);
활동 b
mytestclass obj= mytestclass.staticfunctionGet();
putExtra (Serializable ..) 및 getSerializableExtra () 메서드를 사용하여 클래스 유형의 객체를 전달하고 검색 할 수 있습니다. 클래스를 Serializable로 표시하고 모든 멤버 변수도 직렬화 할 수 있는지 확인해야합니다.
Android 애플리케이션 생성
파일 >> 새로 만들기 >> Android 애플리케이션
프로젝트 이름 입력 : android-pass-object-to-activity
Pakcage : com.hmkcode.android
다른 기본 선택을 유지하고 Finish에 도달 할 때까지 Next로 이동합니다.
앱 생성을 시작하기 전에 한 액티비티에서 다른 액티비티로 객체를 보내는 데 사용할 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());
}
}
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'
Intent i = new Intent();
i.putExtra("name_of_extra", myParcelableObject);
startACtivity(i);
나는 이것이 늦었지만 매우 간단하다는 것을 알고 있습니다.
public class MyClass implements Serializable{
}
그런 다음 다음과 같은 의도로 전달할 수 있습니다.
Intent intent=......
MyClass obje=new MyClass();
intent.putExtra("someStringHere",obje);
그것을 얻으려면 간단하게 전화하십시오.
MyClass objec=(MyClass)intent.getExtra("theString");
어쨌든 모델 계층의 게이트웨이 역할을하는 단일 클래스 (fx 서비스)가있는 경우 해당 클래스에 getter 및 setter가있는 변수를 사용하여 해결할 수 있습니다.
활동 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;
}
이 솔루션에는 해당 개체의 직렬화 또는 기타 "패키징"이 필요하지 않습니다. 그러나 어쨌든 이런 종류의 아키텍처를 사용하는 경우에만 유용합니다.
IMHO가 객체를 소포하는 가장 쉬운 방법입니다. 구획화 할 객체 위에 주석 태그를 추가하기 만하면됩니다.
라이브러리의 예는 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; }
}
먼저 클래스에서 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");
패키지 문자열은 필요하지 않으며 두 활동에서 문자열 만 동일해야합니다.
이 활동에서 다른 활동 시작 번들 개체를 통해 매개 변수 전달
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...
}
Google에서 제공하는 Gson lib를 사용하여 다음과 같이 복잡한 데이터를 직렬화 할 수 있습니다.
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);
콜틴에서
build.gradle에 kotlin 확장을 추가하십시오.
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");
putExtra 기능을 사용하는 것이별로 특별하지 않고 객체로 다른 활동을 시작하고 싶다면 제가 시도한 GNLauncher ( https://github.com/noxiouswinter/gnlib_android/wiki#gnlauncher ) 라이브러리를 확인할 수 있습니다. 이 과정을 더 간단하게 만들 수 있습니다.
GNLauncher는 필요한 데이터를 매개 변수로 사용하여 액티비티에서 함수를 호출하는 것처럼 쉽게 다른 액티비티에서 액티비티로 객체 / 데이터를 보낼 수 있습니다. 형식 안전성을 도입하고 직렬화해야하는 모든 번거 로움을 제거하고 문자열 키를 사용하여 인 텐트에 연결하고 다른 쪽 끝에서 동일한 작업을 취소합니다.
'Development Tip' 카테고리의 다른 글
| OS X 터미널에서 커서를 단어 단위로 이동하는 방법이 있습니까? (0) | 2020.09.29 |
|---|---|
| 값으로 배열에서 항목을 제거하는 방법은 무엇입니까? (0) | 2020.09.28 |
| C ++ 11에서 'typedef'와 'using'의 차이점은 무엇입니까? (0) | 2020.09.28 |
| "INSERT IGNORE"vs "INSERT… ON DUPLICATE KEY UPDATE" (0) | 2020.09.28 |
| setTimeout (fn, 0)이 때때로 유용한 이유는 무엇입니까? (0) | 2020.09.28 |