나는 로그인 페이지를 통해 로그인 한 후, 사인 아웃있을 것 시나리오가 button각을 activity.

를 클릭하면 로그인 한 사용자를 로그 아웃 sign-out하도록 전달합니다 session id. 누구든지 모든 사람이 session id이용할 수있는 방법을 알려줄 수 activities있습니까?

이 경우에 대한 대안

가장 쉬운 방법은 세션 ID를 활동 Intent을 시작하는 데 사용 하는 사인 아웃 활동으로 전달하는 것입니다 .

Intent intent = new Intent(getBaseContext(), SignoutActivity.class);
intent.putExtra("EXTRA_SESSION_ID", sessionId);
startActivity(intent);

다음 활동에 대한 의도에 액세스하십시오.

String sessionId = getIntent().getStringExtra("EXTRA_SESSION_ID");

문서 인 텐트에 대한 자세한 내용은 ( "엑스트라"라는 제목의 섹션을 확인합니다)가 있습니다.

현재 활동에서 다음을 새로 작성하십시오 Intent.

String value="Hello world";
Intent i = new Intent(CurrentActivity.this, NewActivity.class);    
i.putExtra("key",value);
startActivity(i);

그런 다음 새 활동에서 해당 값을 검색하십시오.

Bundle extras = getIntent().getExtras();
if (extras != null) {
    String value = extras.getString("key");
    //The key argument here must match that used in the other activity
}

이 기법을 사용하여 한 활동에서 다른 활동으로 변수를 전달하십시오.

통과 의도Erich가 지적한 것처럼 인 엑스트라를 하는 것이 좋은 방법입니다.

그만큼 응용 프로그램 객체하지만 다른 방법이며, (/ 얻을 사방에 넣어도록하는 것과는 반대로) 여러 활동에서 동일한 상태를 처리 할 때 때로는 쉽게, 또는 원시 및 문자열보다 더 복잡한 객체.

응용 프로그램을 확장 한 다음 원하는 것을 설정 / 가져 와서 getApplication ()을 사용하여 동일한 응용 프로그램의 모든 활동에서 액세스 할 수 있습니다 .

또한 정적과 같은 다른 접근 방식 은 메모리 누수로 이어질 수 있으므로 문제가 될 수 있습니다 . 응용 프로그램도이 문제를 해결하는 데 도움이됩니다.

소스 클래스 :

Intent myIntent = new Intent(this, NewActivity.class);
myIntent.putExtra("firstName", "Your First Name Here");
myIntent.putExtra("lastName", "Your Last Name Here");
startActivity(myIntent)

대상 클래스 (NewActivity 클래스) :

protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.view);

    Intent intent = getIntent();

    String fName = intent.getStringExtra("firstName");
    String lName = intent.getStringExtra("lastName");
}

당신은 당신의 의도를 부르는 동안 여분을 보내야합니다.

이처럼 :

Intent intent = new Intent(getApplicationContext(), SecondActivity.class);
intent.putExtra("Variable name", "Value you want to pass");
startActivity(intent);

지금 OnCreate당신 의 방법에SecondActivity 이와 같은 엑스트라를 가져올 수 있습니다.

보낸 값이 다음과long 같은 경우

long value = getIntent().getLongExtra("Variable name which you sent as an extra", defaultValue(you can give it anything));

보낸 값이String :

String value = getIntent().getStringExtra("Variable name which you sent as an extra");

보낸 값이Boolean :

Boolean value = getIntent().getBooleanExtra("Variable name which you sent as an extra", defaultValue);

상황에 맞는 것을 볼 수있게 도와줍니다. 다음은 두 가지 예입니다.

데이터 전달

주요 활동

• 보내려는 데이터를 키-값 쌍으로 인 텐트에 넣습니다. 키의 명명 규칙에 대해서는 이 답변 을 참조하십시오 .
• 로 두 번째 활동을 시작하십시오 startActivity.

MainActivity.java

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }

    // "Go to Second Activity" button click
    public void onButtonClick(View view) {

        // get the text to pass
        EditText editText = (EditText) findViewById(R.id.editText);
        String textToPass = editText.getText().toString();

        // start the SecondActivity
        Intent intent = new Intent(this, SecondActivity.class);
        intent.putExtra(Intent.EXTRA_TEXT, textToPass);
        startActivity(intent);
    }
}

두 번째 활동

• 두 번째 활동을 시작하는 데 사용 getIntent()합니다 Intent. 그런 다음 getExtras()첫 번째 활동에서 정의한 키와 키를 사용하여 데이터를 추출 할 수 있습니다 . 우리의 데이터는 문자열이기 때문에 getStringExtra여기서 사용 합니다.

SecondActivity.java

public class SecondActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_second);

        // get the text from MainActivity
        Intent intent = getIntent();
        String text = intent.getStringExtra(Intent.EXTRA_TEXT);

        // use the text in a TextView
        TextView textView = (TextView) findViewById(R.id.textView);
        textView.setText(text);
    }
}

데이터 전달

주요 활동

• 로 두 번째 활동을 시작하여 startActivityForResult임의의 결과 코드를 제공하십시오.
• 우세하다 onActivityResult . 두 번째 활동이 완료되면 호출됩니다. 결과 코드를 확인하여 실제로 두 번째 활동인지 확인할 수 있습니다. (이것은 동일한 기본 활동에서 여러 다른 활동을 시작할 때 유용합니다.)
• 당신이 반환에서 얻은 데이터를 추출합니다 Intent. 데이터는 키-값 쌍을 사용하여 추출됩니다. 키에 문자열을 사용할 수는 있지만 Intent.EXTRA_TEXT텍스트를 보내므로 미리 정의 된 것을 사용합니다 .

MainActivity.java

public class MainActivity extends AppCompatActivity {

    private static final int SECOND_ACTIVITY_REQUEST_CODE = 0;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }

    // "Go to Second Activity" button click
    public void onButtonClick(View view) {

        // Start the SecondActivity
        Intent intent = new Intent(this, SecondActivity.class);
        startActivityForResult(intent, SECOND_ACTIVITY_REQUEST_CODE);
    }

    // This method is called when the second activity finishes
    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);

        // check that it is the SecondActivity with an OK result
        if (requestCode == SECOND_ACTIVITY_REQUEST_CODE) {
            if (resultCode == RESULT_OK) {

                // get String data from Intent
                String returnString = data.getStringExtra(Intent.EXTRA_TEXT);

                // set text view with string
                TextView textView = (TextView) findViewById(R.id.textView);
                textView.setText(returnString);
            }
        }
    }
}

두 번째 활동

• 이전 활동으로 다시 보내려는 데이터를에 넣습니다 Intent. 데이터는 Intent키-값 쌍을 사용하여 저장됩니다 . 나는 Intent.EXTRA_TEXT내 열쇠 를 사용 하기로 결정했다 .
• 결과를 설정하고 RESULT_OK데이터를 보유하려는 의도를 추가하십시오.
• finish()두 번째 활동을 마치려면 전화하십시오 .

SecondActivity.java

public class SecondActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_second);
    }

    // "Send text back" button click
    public void onButtonClick(View view) {

        // get the text from the EditText
        EditText editText = (EditText) findViewById(R.id.editText);
        String stringToPassBack = editText.getText().toString();

        // put the String to pass back into an Intent and close this activity
        Intent intent = new Intent();
        intent.putExtra(Intent.EXTRA_TEXT, stringToPassBack);
        setResult(RESULT_OK, intent);
        finish();
    }
}

업데이트 됨 SharedPreference 사용에 대해 언급했습니다 . 간단한 API를 가지고 있으며 응용 프로그램 활동을 통해 액세스 할 수 있습니다. 그러나 이것은 서투른 솔루션이며 민감한 데이터를 전달하면 보안 위험이 있습니다. 의도를 사용하는 것이 가장 좋습니다. 활동간에 여러 가지 다른 데이터 유형을 더 잘 전송하는 데 사용할 수있는 과부하 된 메소드의 광범위한 목록이 있습니다. intent.putExtra를 살펴 보십시오 . 이 링크 는 putExtra의 사용법을 잘 보여줍니다.

활동간에 데이터를 전달할 때 필자가 선호하는 접근법은 필요한 매개 변수를 포함하여 관련 활동에 대한 정적 메소드를 작성하여 의도를 시작하는 것입니다. 그러면 매개 변수를 쉽게 설정하고 검색 할 수 있습니다. 이렇게 보일 수 있습니다

public class MyActivity extends Activity {
    public static final String ARG_PARAM1 = "arg_param1";
...
public static getIntent(Activity from, String param1, Long param2...) {
    Intent intent = new Intent(from, MyActivity.class);
        intent.putExtra(ARG_PARAM1, param1);
        intent.putExtra(ARG_PARAM2, param2);
        return intent;
}

....
// Use it like this.
startActivity(MyActvitiy.getIntent(FromActivity.this, varA, varB, ...));
...

그런 다음 의도 한 활동에 대한 의도를 작성하고 모든 매개 변수를 확보 할 수 있습니다. 조각에 적응할 수 있습니다. 위의 간단한 예이지만 아이디어를 얻습니다.

다음을 수행하십시오.

다음과 같이 간단한 "도우미"클래스를 작성하십시오 (인 텐트 용 팩토리).

import android.content.Intent;

public class IntentHelper {
    public static final Intent createYourSpecialIntent(Intent src) {
          return new Intent("YourSpecialIntent").addCategory("YourSpecialCategory").putExtras(src);
    }
}

이것은 모든 인 텐트의 팩토리입니다. 새로운 인 텐트가 필요할 때마다 IntentHelper에서 정적 팩토리 메소드를 작성하십시오. 새로운 의도를 만들려면 다음과 같이 말하면됩니다.

IntentHelper.createYourSpecialIntent(getIntent());

당신의 활동에서. "세션"에서 일부 데이터를 "저장"하려면 다음을 사용하십시오.

IntentHelper.createYourSpecialIntent(getIntent()).putExtra("YOUR_FIELD_NAME", fieldValueToSave);

그리고이 의도를 보내십시오. 대상 활동에서 필드는 다음과 같이 사용할 수 있습니다.

getIntent().getStringExtra("YOUR_FIELD_NAME");

이제 서블릿이나 JSP 와 같은 동일한 이전 세션과 같이 Intent를 사용할 수 있습니다 .

소포 가능 클래스 를 작성하여 사용자 정의 클래스 오브젝트를 전달할 수도 있습니다 . 소포를 만드는 가장 좋은 방법은 수업을 작성한 다음 http://www.parcelabler.com/ 과 같은 사이트에 붙여 넣는 것 입니다. 빌드를 클릭하면 새로운 코드를 얻게됩니다. 이 모든 것을 복사하고 원래 클래스 내용을 바꾸십시오. 그때-

Intent intent = new Intent(getBaseContext(), NextActivity.class);
Foo foo = new Foo();
intent.putExtra("foo", foo);
startActivity(intent);

NextActivity에서 다음과 같은 결과를 얻습니다.

Foo foo = getIntent().getExtras().getParcelable("foo");

이제 사용했던 것처럼 foo 객체를 간단하게 사용할 수 있습니다 .

다른 방법은 데이터를 저장하는 공용 정적 필드를 사용하는 것입니다.

public class MyActivity extends Activity {

  public static String SharedString;
  public static SomeObject SharedObject;

//...

활동간에 데이터를 전달하는 가장 편리한 방법은 의도를 전달하는 것입니다. 데이터를 보내려는 첫 번째 활동에서 코드를 추가해야합니다.

String str = "My Data"; //Data you want to send
Intent intent = new Intent(FirstActivity.this, SecondActivity.class);
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
intent.putExtra("name",str); //Here you will add the data into intent to pass bw activites
v.getContext().startActivity(intent);

수입해야합니다

import android.content.Intent;

그런 다음 다음 Acitvity (SecondActivity)에서 다음 코드를 사용하여 의도에서 데이터를 검색해야합니다.

String name = this.getIntent().getStringExtra("name");

당신은 사용할 수 있습니다 SharedPreferences...

1. 벌채 반출. 시간 저장소 세션 IDSharedPreferences

   SharedPreferences preferences = getSharedPreferences("session",getApplicationContext().MODE_PRIVATE);
   Editor editor = preferences.edit();
   editor.putString("sessionId", sessionId);
   editor.commit();

2. 사인 아웃 공유 환경 설정의 시간 반입 세션 ID

   SharedPreferences preferences = getSharedPreferences("session", getApplicationContext().MODE_PRIVATE);
   String sessionId = preferences.getString("sessionId", null);

필요한 세션 ID가 없으면 sharedpreferences를 제거하십시오.

SharedPreferences settings = context.getSharedPreferences("session", Context.MODE_PRIVATE);
settings.edit().clear().commit();

한 번만 값을 저장 한 다음 활동의 아무 곳이나 검색하기 때문에 매우 유용합니다.

표준 접근법.

Intent i = new Intent(this, ActivityTwo.class);
AutoCompleteTextView textView = (AutoCompleteTextView) findViewById(R.id.autocomplete);
String getrec=textView.getText().toString();
Bundle bundle = new Bundle();
bundle.putString(“stuff”, getrec);
i.putExtras(bundle);
startActivity(i);

이제 두 번째 활동에서 번들에서 데이터를 검색하십시오.

번들 받기

Bundle bundle = getIntent().getExtras();

데이터 추출…

String stuff = bundle.getString(“stuff”); 

활동에서

 int n= 10;
 Intent in = new Intent(From_Activity.this,To_Activity.class);
 Bundle b1 = new Bundle();
 b1.putInt("integerNumber",n);
 in.putExtras(b1);
 startActivity(in);

활동에

 Bundle b2 = getIntent().getExtras();
 int m = 0;
 if(b2 != null)
  {
     m = b2.getInt("integerNumber");
  }

의도 오브젝트를 사용하여 활동간에 데이터를 보낼 수 있습니다. 당신은 즉 두 개의 활동을 고려 FirstActivity하고 SecondActivity.

내부 FirstActivity :

의도를 사용하여 :

i = new Intent(FirstActivity.this,SecondActivity.class);
i.putExtra("key", value);
startActivity(i)

내부 SecondActivity

Bundle bundle= getIntent().getExtras();

이제 다른 번들 클래스 메소드를 사용하여 FirstActivity에서 Key로 전달 된 값을 가져올 수 있습니다.

예 bundle.getString("key"), bundle.getDouble("key"), bundle.getInt("key")등

Activites / Fragments간에 비트 맵을 전송하려는 경우

활동

Activites간에 비트 맵을 전달하려면

Intent intent = new Intent(this, Activity.class);
intent.putExtra("bitmap", bitmap);

그리고 활동 수업에서

Bitmap bitmap = getIntent().getParcelableExtra("bitmap");

파편

조각간에 비트 맵을 전달하려면

SecondFragment fragment = new SecondFragment();
Bundle bundle = new Bundle();
bundle.putParcelable("bitmap", bitmap);
fragment.setArguments(bundle);

SecondFragment 내부에서 받기

Bitmap bitmap = getArguments().getParcelable("bitmap");

큰 비트 맵 전송

바인더 트랜잭션에 실패하면 이는 하나의 활동에서 다른 활동으로 큰 요소를 전송하여 바인더 트랜잭션 버퍼를 초과 함을 의미합니다.

그래서 경우에 당신은 바이트의 배열로 비트 맵을 압축해야하고 다른 활동에 압축을 풉니 다 같이,

FirstActivity에서

Intent intent = new Intent(this, SecondActivity.class);

ByteArrayOutputStream stream = new ByteArrayOutputStream();
bitmap.compress(Bitmap.CompressFormat.JPG, 100, stream);
byte[] bytes = stream.toByteArray(); 
intent.putExtra("bitmapbytes",bytes);

그리고 SecondActivity에서

byte[] bytes = getIntent().getByteArrayExtra("bitmapbytes");
Bitmap bmp = BitmapFactory.decodeByteArray(bytes, 0, bytes.length);

Intent intent = new Intent(YourCurrentActivity.this, YourActivityName.class);
intent.putExtra("NAme","John");
intent.putExtra("Id",1);
startActivity(intent);

다른 활동에서 검색 할 수 있습니다. 두 가지 방법:

int id = getIntent.getIntExtra("id", /* defaltvalue */ 2);

두 번째 방법은 다음과 같습니다.

Intent i = getIntent();
String name = i.getStringExtra("name");

여기 내 모범 사례가 있으며 프로젝트가 거대하고 복잡 할 때 많은 도움이됩니다.

내가 2 가지 활동을 LoginActivity하고 있다고 가정하자 HomeActivity. 에서 2 개의 매개 변수 (사용자 이름 및 비밀번호)를 LoginActivity로 전달하고 싶습니다 HomeActivity.

먼저, 나는 내 HomeIntent

public class HomeIntent extends Intent {

    private static final String ACTION_LOGIN = "action_login";
    private static final String ACTION_LOGOUT = "action_logout";

    private static final String ARG_USERNAME = "arg_username";
    private static final String ARG_PASSWORD = "arg_password";


    public HomeIntent(Context ctx, boolean isLogIn) {
        this(ctx);
        //set action type
        setAction(isLogIn ? ACTION_LOGIN : ACTION_LOGOUT);
    }

    public HomeIntent(Context ctx) {
        super(ctx, HomeActivity.class);
    }

    //This will be needed for receiving data
    public HomeIntent(Intent intent) {
        super(intent);
    }

    public void setData(String userName, String password) {
        putExtra(ARG_USERNAME, userName);
        putExtra(ARG_PASSWORD, password);
    }

    public String getUsername() {
        return getStringExtra(ARG_USERNAME);
    }

    public String getPassword() {
        return getStringExtra(ARG_PASSWORD);
    }

    //To separate the params is for which action, we should create action
    public boolean isActionLogIn() {
        return getAction().equals(ACTION_LOGIN);
    }

    public boolean isActionLogOut() {
        return getAction().equals(ACTION_LOGOUT);
    }
}

LoginActivity에서 데이터를 전달하는 방법은 다음과 같습니다.

public class LoginActivity extends AppCompatActivity {
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_login);

        String username = "phearum";
        String password = "pwd1133";
        final boolean isActionLogin = true;
        //Passing data to HomeActivity
        final HomeIntent homeIntent = new HomeIntent(this, isActionLogin);
        homeIntent.setData(username, password);
        startActivity(homeIntent);

    }
}

마지막 단계는 다음과 같습니다. HomeActivity

public class HomeActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_home);

        //This is how we receive the data from LoginActivity
        //Make sure you pass getIntent() to the HomeIntent constructor
        final HomeIntent homeIntent = new HomeIntent(getIntent());
        Log.d("HomeActivity", "Is action login?  " + homeIntent.isActionLogIn());
        Log.d("HomeActivity", "username: " + homeIntent.getUsername());
        Log.d("HomeActivity", "password: " + homeIntent.getPassword());
    }
}

끝난! 쿨 :) 그냥 내 경험을 공유하고 싶습니다. 작은 프로젝트를 진행한다면 큰 문제가되지 않습니다. 그러나 큰 프로젝트를 수행 할 때 리팩토링이나 버그 수정을 원할 때 정말 고통 스럽습니다.

보충 답변 : 키 문자열의 명명 규칙

실제 데이터 전달 프로세스는 이미 답변되었지만 대부분의 답변은 인 텐트의 키 이름으로 하드 코딩 된 문자열을 사용합니다. 일반적으로 앱 내에서만 사용하면됩니다. 그러나 표준화 된 데이터 유형에 상수를 사용하는 것이 좋습니다EXTRA_* .

예 1 : Intent.EXTRA_*키 사용

첫 활동

Intent intent = new Intent(getActivity(), SecondActivity.class);
intent.putExtra(Intent.EXTRA_TEXT, "my text");
startActivity(intent);

두 번째 활동 :

Intent intent = getIntent();
String myText = intent.getExtras().getString(Intent.EXTRA_TEXT);

예 2 : 자신의 static final키 정의

Intent.EXTRA_*현 중 하나가 자신의 필요에 맞지 않으면 첫 번째 활동 시작시 자신을 정의 할 수 있습니다.

static final String EXTRA_STUFF = "com.myPackageName.EXTRA_STUFF";

자신의 앱에서 키만 사용하는 경우 패키지 이름을 포함하는 것이 규칙입니다. 그러나 다른 앱이 인 텐트로 호출 할 수있는 서비스를 만드는 경우 이름 충돌을 피해야합니다.

첫 활동 :

Intent intent = new Intent(getActivity(), SecondActivity.class);
intent.putExtra(EXTRA_STUFF, "my text");
startActivity(intent);

두 번째 활동 :

Intent intent = getIntent();
String myText = intent.getExtras().getString(FirstActivity.EXTRA_STUFF);

예 3 : 문자열 리소스 키 사용

설명서에 언급되어 있지 않지만 이 답변 은 활동 간의 종속성을 피하기 위해 문자열 리소스를 사용하는 것이 좋습니다.

strings.xml

 <string name="EXTRA_STUFF">com.myPackageName.MY_NAME</string>

첫 활동

Intent intent = new Intent(getActivity(), SecondActivity.class);
intent.putExtra(getString(R.string.EXTRA_STUFF), "my text");
startActivity(intent);

두 번째 활동

Intent intent = getIntent();
String myText = intent.getExtras().getString(getString(R.string.EXTRA_STUFF));

당신이 사용할 수있는 Intent

Intent mIntent = new Intent(FirstActivity.this, SecondActivity.class);
mIntent.putExtra("data", data);
startActivity(mIntent);

다른 방법으로는 싱글 톤 패턴을 사용할 수도 있습니다.

public class DataHolder {

 private static DataHolder dataHolder;
 private List<Model> dataList;

 public void setDataList(List<Model>dataList) {
    this.dataList = dataList;
 }

 public List<Model> getDataList() {
    return dataList;
 }

 public synchronized static DataHolder getInstance() {
    if (dataHolder == null) {
       dataHolder = new DataHolder();
    }
    return dataHolder;
 }
}

FirstActivity에서

private List<Model> dataList = new ArrayList<>();
DataHolder.getInstance().setDataList(dataList);

SecondActivity에서

private List<Model> dataList = DataHolder.getInstance().getDataList();

액티비티간에 데이터를 전달하는 것은 주로 의도 객체를 사용하는 것입니다.

먼저 Bundle클래스를 사용하여 데이터를 의도 객체에 첨부해야합니다 . 그런 다음 startActivity()또는 startActivityForResult()메소드를 사용하여 활동을 호출하십시오 .

블로그 게시물 에서 활동에 데이터 전달 의 예제를 통해 이에 대한 자세한 정보를 찾을 수 있습니다 .

공유 환경 설정을 시도 할 수 있습니다. 활동간에 데이터를 공유하는 좋은 대안 일 수 있습니다

세션 ID를 저장하려면-

SharedPreferences pref = myContexy.getSharedPreferences("Session 
Data",MODE_PRIVATE);
SharedPreferences.Editor edit = pref.edit();
edit.putInt("Session ID", session_id);
edit.commit();

그들을 얻으려면-

SharedPreferences pref = myContexy.getSharedPreferences("Session Data", MODE_PRIVATE);
session_id = pref.getInt("Session ID", 0);

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...
}

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);

코 틀린

첫 활동에서 합격

val intent = Intent(this, SecondActivity::class.java)
intent.putExtra("key", "value")
startActivity(intent)

두 번째 활동에 참여

val value = getIntent().getStringExtra("key")

암시

보다 관리 된 방식으로 키를 항상 일정한 파일에 넣으십시오.

companion object {
    val KEY = "key"
}

/*
 * If you are from transferring data from one class that doesn't
 * extend Activity, then you need to do something like this.
 */ 

public class abc {
    Context context;

    public abc(Context context) {
        this.context = context;
    }

    public void something() {
        context.startactivity(new Intent(context, anyone.class).putextra("key", value));
    }
}

찰리 콜린스는 나에게 완벽한 준 대답을 를 사용하여 Application.class. 나는 우리가 그것을 쉽게 서브 클래스 할 수 있다는 것을 알지 못했습니다. 다음은 사용자 지정 응용 프로그램 클래스를 사용하는 간단한 예입니다.

AndroidManifest.xml

android:name고유 한 애플리케이션 클래스를 사용 하도록 속성을 제공하십시오 .

...
<application android:name="MyApplication"
    android:allowBackup="true"
    android:icon="@drawable/ic_launcher"
    android:label="@string/app_name"
    android:theme="@style/AppTheme" >
....

MyApplication.java

이것을 전역 참조 홀더로 사용하십시오. 동일한 프로세스 내에서 잘 작동합니다.

public class MyApplication extends Application {
    private MainActivity mainActivity;

    @Override
    public void onCreate() {
        super.onCreate();
    }

    public void setMainActivity(MainActivity activity) { this.mainActivity=activity; }
    public MainActivity getMainActivity() { return mainActivity; }
}

MainActivity.java

응용 프로그램 인스턴스에 대한 글로벌 "단일"참조를 설정하십시오.

public class MainActivity extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        ((MyApplication)getApplication()).setMainActivity(this);
    }
    ...

}

MyPreferences.java

다른 활동 인스턴스의 기본 활동을 사용하는 간단한 예입니다.

public class MyPreferences extends PreferenceActivity
            implements SharedPreferences.OnSharedPreferenceChangeListener {
    @SuppressWarnings("deprecation")
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        addPreferencesFromResource(R.xml.preferences);
        PreferenceManager.getDefaultSharedPreferences(this)
            .registerOnSharedPreferenceChangeListener(this);
    }

    @Override
    public void onSharedPreferenceChanged(SharedPreferences prefs, String key) {
        if (!key.equals("autostart")) {
            ((MyApplication)getApplication()).getMainActivity().refreshUI();
        }
    }
}

나는 최근에 이와 같은 모든 종류의 작업을 더 단순하게 만드는 jQuery 맛 안드로이드 프레임 워크 인 Vapor API를 출시 했다. 언급 SharedPreferences했듯이이 작업을 수행 할 수있는 한 가지 방법입니다.

VaporSharedPreferences는 단일 옵션으로 구현되어 하나의 옵션이며 Vapor API에는 과부하 된 .put(...)메소드가 있으므로 커밋하는 데이터 유형에 대해 명시 적으로 걱정할 필요가 없습니다. 지원되는 경우. 또한 유창하므로 통화를 연결할 수 있습니다.

$.prefs(...).put("val1", 123).put("val2", "Hello World!").put("something", 3.34);

또한 선택적으로 변경 사항을 자동 저장하고 읽기 및 쓰기 프로세스를 통합하여 표준 Android에서와 같이 명시 적으로 편집기를 검색 할 필요가 없습니다.

또는을 사용할 수 있습니다 Intent. Vapor API에서는 다음과 같은 연결 가능한 오버로드 .put(...)방법을 사용할 수 있습니다 VaporIntent.

$.Intent().put("data", "myData").put("more", 568)...

다른 답변에서 언급했듯이 추가로 전달하십시오. 에서 추가 항목을 검색 할 수 있으며 Activity,이를 사용하는 경우 VaporActivity자동으로 수행되므로 다음을 사용할 수 있습니다.

this.extras()

에서 다른 쪽 끝에서 검색하려면 Activity 전환하십시오.

그것이 관심있는 희망 :)

첫 활동 :

Intent intent = new Intent(getApplicationContext(), ClassName.class);
intent.putExtra("Variable name", "Value you want to pass");
startActivity(intent);

두 번째 활동 :

String str= getIntent().getStringExtra("Variable name which you sent as an extra");

3 가지 방법으로 애플리케이션의 활동간에 데이터를 전달할 수 있습니다.

1. 의지
2. SharedPreferences
3. 신청

의도적으로 데이터를 전달하는 데에는 한계가 있습니다. 많은 양의 데이터의 경우 응용 프로그램 수준의 데이터 공유를 사용하고이를 SharedPreference에 저장하면 앱 크기가 커집니다.

글로벌 클래스를 사용하십시오.

public class GlobalClass extends Application
{
    private float vitamin_a;


    public float getVitaminA() {
        return vitamin_a;
    }

    public void setVitaminA(float vitamin_a) {
        this.vitamin_a = vitamin_a;
    }
}

다른 모든 클래스에서이 클래스의 setter 및 getter를 호출 할 수 있습니다. 그렇게하면 모든 활동에서 GlobalClass-Object를 만들어야합니다.

GlobalClass gc = (GlobalClass) getApplication();

그런 다음 예를 들면 다음과 같습니다.

gc.getVitaminA()