W bieżącej aktywności Utwórz nową Intent:

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

Następnie w nowej aktywności Odzyskaj te wartości:

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

Użyj tej techniki, aby przekazać zmienne z jednej aktywności do drugiej.

Passing Intent extras jest dobrym podejściem, jak zauważył Erich.

Aplikacja jest jednak Innym sposobem i czasami jest łatwiejsza, gdy mamy do czynienia z tym samym stanem w wielu działaniach (w przeciwieństwie do konieczności pobierania/umieszczania go wszędzie), lub obiektów bardziej złożonych niż prymitywy i łańcuchy.

Możesz rozszerzyć aplikację, a następnie ustawić / uzyskać tam co chcesz i uzyskać do niej dostęp z dowolnej aktywności (w tej samej aplikacji) za pomocą getApplication () .

Pamiętaj również, że inne podejścia, które możesz zobaczyć, jak statyka, mogą być problematyczne, ponieważ mogą prowadzić do wycieków pamięci . Aplikacja pomaga rozwiązać ten problem.

Klasa źródłowa:

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

Klasa przeznaczenia (nowa klasa działania):

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

Musisz tylko wysłać dodatki, dzwoniąc do swoich intencji.

Tak:

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

Teraz w metodzie OnCreate twojego SecondActivity możesz pobrać dodatki w ten sposób.

Jeśli przesłana wartość była w long:

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

Jeśli wysłana wartość była String:

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

Jeśli wysłana wartość była Boolean:

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

Aktualizacja zauważ, że wspomniałem o użyciu SharedPreference . Ma prosty interfejs API i jest dostępny dla wszystkich działań aplikacji. Ale jest to niezdarne rozwiązanie i stanowi zagrożenie dla bezpieczeństwa, jeśli przekazujesz poufne dane. Najlepiej użyć intencji. Posiada obszerną listę przeciążonych metod, które można wykorzystać do lepszego przesyłania wielu różnych typów danych między działaniami. Spójrz na intencje.putExtra . Ten link prezentuje zastosowanie putExtra całkiem dobrze.

W przekazywaniu danych między działaniami, moim preferowanym podejściem jest stworzenie statycznej metody dla danej aktywności, która zawiera wymagane parametry. Który następnie zapewnia łatwą konfigurację i pobieranie parametrów. Więc może wyglądać tak

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

Następnie możesz utworzyć intencję dla zamierzonej aktywności i upewnić się, że masz wszystkie parametry. Możesz dostosować się do fragmentów. Prosty przykład powyżej, ale masz pomysł.

Spróbuj wykonać następujące czynności:

Utwórz prostą klasę" helper " (fabrycznie dla Twoich zamiarów), Tak:

import android.content.Intent;

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

IntentHelper.createYourSpecialIntent(getIntent());

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

I wyślij tę intencję. W aktywności docelowej twoje pole będzie dostępny jako:

getIntent().getStringExtra("YOUR_FIELD_NAME");

Więc teraz możemy używać Intent jak ta sama stara sesja (jak w servletach lub JSP).

Pomaga mi widzieć rzeczy w kontekście. Oto dwa przykłady.

Przekazywanie Danych Do Przodu

Główna Działalność

• umieść dane, które chcesz wysłać w intencji z parą klucz-wartość. Zobacz ta odpowiedź {[25] } dla konwencji nazewnictwa dla klucza.
• rozpocznij drugą czynność od startActivity.

główna aktywność.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);
    }
}

Druga Aktywność

• używasz getIntent() aby uzyskać Intent to zapoczątkowało drugą aktywność. Następnie możesz wyodrębnić dane za pomocą getExtras() i klucza zdefiniowanego w pierwszym ćwiczeniu. Ponieważ nasze dane są ciągiem znaków, użyjemy getStringExtra tutaj.

druga aktywność.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);
    }
}

Przekazywanie Danych Z Powrotem

Główna Działalność

• rozpocznij drugą czynność od startActivityForResult, podając dowolny kod wyniku.
• Override onActivityResult. Nazywa się to, gdy druga aktywność wykończenia. Możesz upewnić się, że jest to druga czynność, sprawdzając kod wyniku. (Jest to przydatne, gdy rozpoczynasz wiele różnych działań z tego samego działania głównego.)
• Wyodrębnij dane z powrotu Intent. Dane są wyodrębniane za pomocą pary klucz-wartość. Mogę użyć dowolnego ciągu do klucza, ale użyję predefiniowanego Intent.EXTRA_TEXT, ponieważ wysyłam tekst.

główna aktywność.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);
            }
        }
    }
}

Drugi Aktywność

• umieść dane, które chcesz wysłać z powrotem do poprzedniej aktywności w Intent. Dane są przechowywane w Intent za pomocą pary klucz-wartość. Zdecydowałem się użyć Intent.EXTRA_TEXT dla mojego klucza.
• Ustaw wynik na RESULT_OK i dodaj intencję przechowującą Twoje dane.
• zadzwoń finish(), aby zamknąć drugą czynność.

druga aktywność.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();
    }
}

Możesz również przekazać własne obiekty klasy, tworząc parcelowalną klasę . Najlepszym sposobem na to jest napisanie swojej klasy, a następnie po prostu wklejenie jej na stronę taką jak http://www.parcelabler.com / . Kliknij na build, a otrzymasz nowy kod. Skopiuj to wszystko i zastąp oryginalną zawartość klasy. Wtedy -

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

I uzyskaj wynik w NextActivity like-

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

Teraz możesz po prostu użyć foo obiektu tak, jak byś tego użył.

Innym sposobem jest użycie publicznego statycznego pola, w którym przechowujesz dane, tj.:

public class MyActivity extends Activity {

  public static String SharedString;
  public static SomeObject SharedObject;

//...

Najwygodniejszym sposobem przekazywania danych między działaniami jest przekazywanie intencji. W pierwszym ćwiczeniu, z którego chcesz wysłać dane, powinieneś dodać kod,

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

Należy również zaimportować

import android.content.Intent;

Następnie w następnej aktywności (SecondActivity), należy pobrać dane z intent używając poniższego kodu.

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

Możesz użyć SharedPreferences...

1. Logowanie. Time store session id in SharedPreferences

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

2. Podpis. ID sesji pobierania czasu w sharedpreferences

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

Jeśli nie masz wymaganego identyfikatora sesji, Usuń sharedpreferences:

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

Jest to bardzo przydatne, ponieważ jeden raz zapisujesz wartość, a następnie pobierasz w dowolnym miejscu aktywności.

Podejście standardowe.

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

Teraz w drugiej aktywności Odzyskaj swoje dane z pakietu:

Pobierz pakiet

Bundle bundle = getIntent().getExtras();

Wyodrębnij dane ...

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

Z Aktywności

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

Do Aktywności

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

Możesz wysyłać dane między działaniami za pomocą obiektu intent. Załóżmy, że masz dwie czynności: FirstActivity i SecondActivity.

Inside First:

Użycie Intencji:

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

Inside Second Activity

Bundle bundle= getIntent().getExtras();

Teraz możesz użyć różnych metod klasy bundle, aby uzyskać wartości przekazywane z FirstActivity przez klucz.

Np. bundle.getString("key"),bundle.getDouble("key") ,bundle.getInt("key") itd.

jeśli chcesz przenosić bitmapę między aktywnościami/fragmentami

Aktywność

aby przekazać bitmapę między aktywami

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

i w klasie aktywności

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

Fragment

aby przekazać bitmapę między fragmentami

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

aby otrzymać wewnątrz SecondFragment

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

Przenoszenie Dużych Bitmapy

Jeśli otrzymujesz nieudaną transakcję binder, oznacza to, że przekroczyłeś bufor transakcji binder, przenosząc duży element z jednej aktywności do drugiej.

W takim przypadku musisz skompresować bitmapę jako tablicę bajtów, a następnie rozpakować ją w innej aktywności , Jak to

w pierwszej kolejności

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

a w drugim

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

Możesz go odzyskać w innej aktywności. Dwa sposoby:

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

Druga droga to:

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

Odpowiedź uzupełniająca: konwencje nazewnictwa dla ciągu kluczowego

Rzeczywisty proces przekazywania danych został już odebrany, jednak większość odpowiedzi używa mocno zakodowanych łańcuchów dla nazwy klucza w intencji. Zwykle jest to dobre, gdy jest używane tylko w aplikacji. Jednak dokumentacja zaleca używanie stałych EXTRA_* dla standardowych typów danych.

Przykład 1: Użycie kluczy Intent.EXTRA_*

pierwszy aktywność

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

druga aktywność:

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

Przykład 2: Definiowanie własnego klucza static final

Jeśli jeden z Intent.EXTRA_* łańcuchów nie odpowiada twoim potrzebom, możesz zdefiniować swój własny na początku pierwszej czynności.

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

Włączenie nazwy pakietu jest tylko konwencją, jeśli używasz tylko klucza we własnej aplikacji. Ale konieczne jest unikanie konfliktów nazewnictwa, jeśli tworzysz jakąś usługę, którą mogą wywołać inne aplikacje z zamiarem.

pierwsza aktywność:

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

druga aktywność:

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

Przykład 3: użycie klucza zasobów String

Chociaż nie wspomniano o tym w dokumentacji, ta odpowiedź zaleca użycie zasobu Łańcuchowego, aby uniknąć zależności między działaniami.

struny.xml

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

pierwsza aktywność

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

druga aktywność

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

Możesz wypróbować Preferencje współdzielone, może to być dobra alternatywa dla udostępniania danych między działaniami

Aby zapisać identyfikator sesji-

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

Aby je zdobyć-

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

Oto moja najlepsza praktyka i bardzo pomaga, gdy projekt jest ogromny i złożony.

Załóżmy, że mam 2 Działania, LoginActivity i HomeActivity. Chcę przekazać 2 parametry (nazwa użytkownika i hasło) z LoginActivity do HomeActivity.

Najpierw tworzę swoje 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);
    }
}

Oto jak przekazuję dane w loginie

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

    }
}

Ostatni krok, oto jak odbieram dane w 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());
    }
}

Przekazywanie danych między działaniami odbywa się głównie za pomocą obiektu intencyjnego.

Najpierw musisz dołączyć dane do obiektu intent przy użyciu klasy Bundle. Następnie wywołaj działanie za pomocą metod startActivity() lub startActivityForResult().

Możesz znaleźć więcej informacji na ten temat, na przykład z postu na bloguPrzekazywanie danych do działania.

Charlie Collins dał mi idealną odpowiedź używając Application.class. Nie wiedziałem, że możemy to tak łatwo podklasyfikować. Oto uproszczony przykład użycia niestandardowej klasy aplikacji.

AndroidManifest.xml

Podaj atrybut android:name, aby użyć własnej klasy aplikacji.

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

MyApplication.java

Użyj tego jako globalnego posiadacza odniesienia. Działa dobrze w ramach tego samego procesu.

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

Ustaw globalne odniesienie "singleton" do aplikacji przykład.

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

Prosty przykład, w którym używam głównej aktywności z innej instancji aktywności.

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

Możesz użyć Intent

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

Innym sposobem może być użycie singleton pattern również:

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

Od pierwszego dnia

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

On Second Activity

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

/*
 * 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));
    }
}

Używam pól statycznych w klasie i pobieram / ustawiam je:

Jak:

public class Info
{
    public static int ID      = 0;
    public static String NAME = "TEST";
}

Aby uzyskać wartość, użyj tego w Ćwiczeniu:

Info.ID
Info.NAME

Dla ustawienia wartości:

Info.ID = 5;
Info.NAME = "USER!";

Spróbuj tego:

Current activity.java

Intent intent = new Intent(currentActivity.this, TargetActivity.class);
intent.putExtra("booktype", "favourate");
startActivity(intent);

TargetActivity.java

Bundle b = getIntent().getExtras();
String typesofbook = b.getString("booktype");

Uruchom inną aktywność z tej aktywności przekazując parametry za pomocą obiektu Bundle

Intent intent = new Intent(getBaseContext(), YourActivity.class);
intent.putExtra("USER_NAME", "[email protected]");
startActivity(intent);

Pobierz na innej aktywności (your activity)

String s = getIntent().getStringExtra("USER_NAME");

To jest ok dla typu danych typu simple kind. Ale jeśli chcesz przekazać złożone dane pomiędzy aktywnością, najpierw musisz je serializować.

Tutaj mamy Model pracownika

class Employee{
    private String empId;
    private int age;
    print Double salary;

    getters...
    setters...
}

Możesz użyć Gson lib dostarczonego przez google do serializacji złożonych danych like this

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

Niedawno wydałem Vapor API , Framework dla Androida o Smaku jQuery, który upraszcza wszelkiego rodzaju zadania. Jak wspomniano, SharedPreferences jest jednym ze sposobów, aby to zrobić.

VaporSharedPreferences jest zaimplementowany jako Singleton, więc jest to jedna z opcji, a w Vapor API ma mocno przeciążoną metodę .put(...), więc nie musisz się bezpośrednio martwić o typ danych, który zatwierdzasz - pod warunkiem, że jest on obsługiwany. Jest również płynny, więc można łączyć wywołania:

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

It opcjonalnie autosaves zmienia i unifikuje proces czytania i pisania pod maską, dzięki czemu nie musisz jawnie pobierać edytora, jak to robisz w standardowym Androidzie.

Alternatywnie możesz użyć Intent. W Vapor API można również użyć metody chainable overloaded .put(...) na VaporIntent:

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

I podaj go jako dodatek, jak wspomniano w innych odpowiedziach. Możesz pobrać dodatki ze swojego Activity, a ponadto, jeśli używasz VaporActivity to jest robione dla ciebie automatycznie, więc możesz użyć:

this.extras()

Aby je odzyskać na drugim końcu Activity przełącz się na.

Mam nadzieję, że zainteresuje niektórych :)

Jeśli używasz Kotlina:

W Głównej Działalności1:

var intent=Intent(this,MainActivity2::class.java)
intent.putExtra("EXTRA_SESSION_ID",sessionId)
startActivity(intent)

W Głównej Działalności2:

if (intent.hasExtra("EXTRA_SESSION_ID")){
    var name:String=intent.extras.getString("sessionId")
}

Możesz przekazywać dane między działaniami w aplikacji na 3 sposoby 1.Intencja 2.SharedPreferences 3.Application

Przekazywanie danych w intencji ma pewne ograniczenia.W przypadku dużej ilości danych można użyć udostępniania danych na poziomie aplikacji i przechowując je w sharedpref zwiększa rozmiar aplikacji