Intents를 사용하여 한 Android 활동에서 다른 활동으로 개체를 보내는 방법은 무엇입니까?
사용자 지정 유형의 개체를 사용하여 한 활동에서 다른 활동으로 전달하려면 어떻게 해야 합니다.
putExtra()인텐트 클래스의 메서드?
객체를 전달하는 경우에는 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퍼팅 엑스트라()로 당신의 의도에 그것들을 넣는 것의 문제일 뿐입니다.
Intent i = new Intent();
i.putExtra("name_of_extra", myParcelableObject);
그런 다음 getParcelable로 다시 꺼낼 수 있습니다.추가():
Intent i = getIntent();
MyParcelable myParcelableObject = (MyParcelable) i.getParcelableExtra("name_of_extra");
객체 클래스가 구획 가능 및 직렬화 가능을 구현하는 경우 다음 중 하나에 캐스트해야 합니다.
i.putExtra("parcelable_extra", (Parcelable) myParcelableObject);
i.putExtra("serializable_extra", (Serializable) myParcelableObject);
당신은 당신의 객체를 어떤 종류의 문자열 표현으로 직렬화해야 할 것입니다.한 가지 가능한 문자열 표현은 JSON입니다. 안드로이드에서 JSON으로 직렬화하거나 직렬화하는 가장 쉬운 방법 중 하나는 Google GSON을 사용하는 것입니다.
" 경우문반값환입을력다니합열자이▁▁from▁value▁string다"의 문자열 반환값을 .(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 소프트웨어 엔지니어)은 이 문제에 대해 다음과 같이 말했습니다.
활동이 동일한 프로세스에서 실행되고 있다는 것을 알고 있는 상황에서는 글로벌을 통해 데이터를 공유할 수 있습니다.를 들어, " 어들시을사템수용있다할습니스예벌글를로▁a다있▁have수니▁for▁global습▁could▁you사"를 가질 수 있습니다.
HashMap<String, WeakReference<MyInterpreterState>>그리고 새로운 MyInterpreterState가 고유한 이름을 만들어 해시 맵에 넣도록 할 때, 해당 상태를 다른 활동으로 보내려면 고유한 이름을 해시 맵에 넣기만 하면 됩니다. 두 번째 활동이 시작되면 해시 맵에서 받은 이름으로 MyInterpreterState를 검색할 수 있습니다.
클래스에서 직렬 또는 구획 가능을 구현해야 합니다.
public class MY_CLASS implements Serializable
완료되면 추가로 객체를 전송할 수 있습니다.
intent.putExtra("KEY", MY_CLASS_instance);
startActivity(intent);
추가 기능을 사용하려면 다음 작업만 수행하면 됩니다.
Intent intent = getIntent();
MY_CLASS class = (MY_CLASS) intent.getExtras().getSerializable("KEY");
클래스에서 다음에 패키징 가능 사용을 구현하는 경우
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(intent);
두 번째 활동에서 당신은 다음과 같은 데이터를 얻을 수 있습니다.
Place place= (Place) getIntent().getSerializableExtra("PLACE");
그러나 데이터가 커지면 이 방법은 느려집니다.
빠른 요구사항에 대한 간단한 답변
클래스를 직렬화 가능으로 구현합니다.
내부 클래스가 있다면 Serializable에도 구현하는 것을 잊지 마십시오!
public class SportsData implements Serializable
public class Sport implements Serializable
List<Sport> clickedObj;
개체를 의도로 전환
Intent intent = new Intent(SportsAct.this, SportSubAct.class);
intent.putExtra("sport", clickedObj);
startActivity(intent);
그리고 다른 활동 클래스에서 사용자의 개체를 받습니다.
Intent intent = getIntent();
Sport cust = (Sport) intent.getSerializableExtra("sport");
객체 클래스가 구현되면 다른 작업을 수행할 필요가 없으며 직렬화 가능한 객체를 전달할 수 있습니다.
그것이 제가 사용하는 것입니다.
다른 클래스나 활동에 있는 변수나 개체에 액세스할 수 있는 몇 가지 방법이 있습니다.
A. 데이터베이스
B. 공유 선호도.
C. 객체 직렬화.
D. 공통 데이터를 저장할 수 있는 클래스는 사용자에 따라 Common Utilities로 명명될 수 있습니다.
E. 데이터를 인텐트 및 패키징 가능한 인터페이스를 통해 전달합니다.
그것은 당신의 프로젝트 요구에 달려 있습니다.
A. 데이터베이스
SQLite는 Android에 내장된 오픈 소스 데이터베이스입니다.SQLite는 SQL 구문, 트랜잭션 및 준비된 문과 같은 표준 관계형 데이터베이스 기능을 지원합니다.
튜토리얼 -- http://www.vogella.com/articles/AndroidSQLite/article.html
B. 공유 기본 설정
사용자 이름을 저장하려고 합니다.이제 핵심 사용자 이름, 가치 가치라는 두 가지가 있습니다.
보관방법
// Create an 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. 객체 직렬화
객체 직렬화는 객체 상태를 저장하여 네트워크를 통해 전송하려는 경우 또는 사용자의 목적에 맞게 사용할 수 있는 경우에 사용됩니다.
자바 콩을 그의 밭 중 하나로 사용하고 그 안에 저장하고 게터와 세터를 사용합니다.
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);
그런 다음 개체 직렬화를 사용하여 이 개체를 직렬화하고 다른 클래스에서 이 개체를 역직렬화합니다.
직렬화에서 개체는 개체의 데이터뿐만 아니라 개체의 유형 및 개체에 저장된 데이터 유형에 대한 정보를 포함하는 바이트 시퀀스로 나타낼 수 있습니다.
직렬화된 개체를 파일에 쓴 후에는 파일에서 해당 개체를 읽고 직렬화 해제할 수 있습니다. 즉, 개체와 해당 데이터를 나타내는 유형 정보와 바이트를 사용하여 메모리에서 개체를 재생성할 수 있습니다.
이 링크를 참조하기 위한 자습서를 원하는 경우
http://javawithswaranga.blogspot.in/2011/08/serialization-in-java.html
D. 공용 유틸리티
프로젝트에 자주 필요한 공통 데이터를 포함할 수 있는 클래스를 직접 만들 수 있습니다.
샘플
public class CommonUtilities {
public static String className = "CommonUtilities";
}
E. 인텐트를 통해 데이터 전달
이 데이터 전달 옵션은 이 튜토리얼을 참조하십시오.
안드로이드 번들을 사용하여 이 작업을 수행할 수 있습니다.
클래스에서 다음과 같은 번들을 만듭니다.
public Bundle toBundle() {
Bundle b = new Bundle();
b.putString("SomeKey", "SomeValue");
return b;
}
그런 다음 이 번들을 INTITE와 함께 전달합니다.이제 다음과 같이 번들을 전달하여 클래스 개체를 다시 만들 수 있습니다.
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;
}
}
활동 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);
}
저는 제가 하는 거의 모든 프로젝트에서 사용하고 있으며 성능 문제는 없습니다.
저는 같은 문제로 어려움을 겪었습니다.정적 클래스를 사용하여 원하는 데이터를 해시맵에 저장하여 해결했습니다.위에서 나는 표준 활동 클래스의 확장을 사용하여 데이터 전송 및 데이터 지우기를 숨겨진 상태로 수행하기 위해 파괴 시 작성의 방법을 재정의했습니다.방향 처리와 같은 일부 우스꽝스러운 설정을 변경해야 합니다.
주석:다른 활동에 전달할 일반적인 대상을 제공하지 않는 것은 골치 아픈 일입니다.그것은 자신의 무릎에 총을 쏴서 100미터를 우승하기를 바라는 것과 같습니다."Parcable"은 충분한 대체물이 아닙니다.날 웃게 해줘요...기술이 필요 없는 API에 이 인터페이스를 구현하고 싶지 않습니다. 새로운 계층을 도입하고 싶지 않기 때문입니다.어떻게 우리가 현대 패러다임에서 멀리 떨어진 모바일 프로그래밍에 있을 수 있을까요?
첫 번째 활동:
intent.putExtra("myTag", yourObject);
그리고 당신의 두 번째 것은:
myCustomObject myObject = (myCustomObject) getIntent().getSerializableExtra("myTag");
사용자 지정 개체를 직렬화할 수 있도록 설정하는 것을 잊지 마십시오.
public class myCustomObject implements Serializable {
...
}
이를 위한 또 다른 방법은 다음을 사용하는 것입니다.Application객체(앱 포함).신청).당신은 이것을 당신 안에서 정의합니다.AndroidManifest.xml파일 이름:
<application
android:name=".MyApplication"
...
여러분은 활동에서든 할 수 있고 를 그다음모활이호개저고수있다장습니할체런를에 할 수 .Application학생들
첫 번째 활동:
MyObject myObject = new MyObject();
MyApplication app = (MyApplication) getApplication();
app.setMyObject(myObject);
두 번째 활동에서 다음을 수행합니다.
MyApplication app = (MyApplication) getApplication();
MyObject retrievedObject = app.getMyObject(myObject);
응용 프로그램 수준 범위가 있는 개체, 즉 응용 프로그램 전체에서 사용해야 하는 개체가 있는 경우 유용합니다. 그Parcelable개체 범위를 명시적으로 제어하려는 경우 또는 범위가 제한된 경우 메소드가 더 좋습니다.
이렇게 하면 사용할 수 없습니다.Intents하지만, 전체적으로.그것들이 당신에게 어울리는지 모르겠습니다.제가 사용한 또 다른 방법은int를 통해 합니다.Application물건.
클래스 모델(개체)에서 직렬화 가능을 구현합니다. 예:
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);
두 번째 활동(새 활동)
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");
제가 찾은 가장 쉬운 해결책은..게터 세터가 있는 정적 데이터 멤버로 클래스를 만듭니다.
한 활동에서 설정하고 다른 활동에서 해당 개체를 가져옵니다.
활동 A
mytestclass.staticfunctionSet("","",""..etc.);
활동 b
mytestclass obj= mytestclass.staticfunctionGet();
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 exampleObject=new Example(1,"hello");
String jsonString = new Gson().toJson(exampleObject);
Intent nextIntent=new Intent(this,NextActivity.class);
nextIntent.putExtra("example",jsonString );
startActivity(nextIntent);
판독을 위해 다음 활동에서 역방향 작업을 수행해야 합니다.
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'
putExtra(Serializable...)를 사용하여 serializable을 얻을 수 있습니다.클래스 유형의 개체를 전달하고 검색하는 추가() 메서드입니다. 클래스를 직렬화할 수 있음으로 표시하고 모든 멤버 변수도 직렬화할 수 있는지 확인해야 합니다.
Android 응용 프로그램 만들기
파일 >> 신규 >> 안드로이드 애플리케이션
프로젝트 이름 입력: Android-pass-object-to-activity
패키지: com.hmkcode.android
다른 기본 선택 항목을 유지하고 마침에 도달할 때까지 다음으로 이동합니다.
앱을 만들기 전에 한 활동에서 다른 활동으로 개체를 보내는 데 사용할 POJO 클래스 "사용자"를 만들어야 합니다.클래스가 직렬화 가능한 인터페이스를 구현하고 있습니다.
인물.자바
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>
두 개의 활동 클래스
활동 기본.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);
}
}
Another Activity.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());
}
}
이것이 늦은 것은 알지만 매우 간단합니다.당신이 해야 할 일은 당신의 클래스가 다음과 같은 직렬화 가능한 것을 구현하도록 하는 것입니다.
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용으로 권장: 모델을 구획할 수 있도록 합니다.
Intent i = new Intent();
i.putExtra("name_of_extra", myParcelableObject);
startACtivity(i);
모델 계층의 게이트웨이 역할을 하는 싱글톤 클래스(fxService)가 있는 경우 해당 클래스에 게터와 세터가 있는 변수가 있으면 해결할 수 있습니다.
활동 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을 구현합니다.그러면 이렇게 객체를 전달합니다.
Activity.java 전송
ObjectA obj = new ObjectA();
// Set values etc.
Intent i = new Intent(this, MyActivity.class);
i.putExtra("com.package.ObjectA", obj);
startActivity(i);
Activity.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);
다른 활동에 대해 검색(사용자 활동)
String s = getIntent().getStringExtra("USER_NAME");
이것은 단순한 종류의 데이터 유형에 적합합니다.그러나 활동 사이에 복잡한 데이터를 전달하려면 먼저 직렬화해야 합니다.
여기 직원 모델이 있습니다.
class Employee{
private String empId;
private int age;
print Double salary;
getters...
setters...
}
구글에서 제공하는 Gsonlib을 사용하여 복잡한 데이터를 이렇게 직렬화할 수 있습니다.
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")
만약 당신이 putExtra 기능을 사용하는 것에 대해 그다지 까다롭지 않고 단지 객체와 함께 다른 활동을 시작하고 싶다면, 당신은 이 과정을 더 쉽게 하기 위해 내가 작성한 GNLauncher(https://github.com/noxiouswinter/gnlib_android/wiki#gnlauncher) 라이브러리를 확인할 수 있습니다.
GNLauncher를 사용하면 필요한 데이터를 매개 변수로 사용하여 다른 활동 등에서 활동으로 개체/데이터를 쉽게 보낼 수 있습니다.유형 안전을 도입하고 문자열 키를 사용하여 의도에 연결하고 다른 쪽 끝에서 동일한 것을 실행 취소해야 하는 번거로움을 모두 제거합니다.
언급URL : https://stackoverflow.com/questions/2139134/how-to-send-an-object-from-one-android-activity-to-another-using-intents
'programing' 카테고리의 다른 글
| j선택한 값 가져오기 라디오 버튼 쿼리 (0) | 2023.06.18 |
|---|---|
| Java JDBC - tnsnames.ora를 사용하여 Oracle에 연결하는 방법 (0) | 2023.06.18 |
| 텍스트 필드에서 여러 열을 결합하는 MVC 선택 목록 (0) | 2023.06.18 |
| R 벡터의 모든 요소에서 마지막 n자를 제거하는 방법 (0) | 2023.06.18 |
| R에서 Excel 해결사를 복제하는 방법 (0) | 2023.06.18 |