Ich habe ein Szenario , in dem, nach dem in durch eine Login - Seite anmelden, wird es eine Abmelde sein buttonauf jedem activity.

Beim Klicken übergebe sign-outich session idden angemeldeten Benutzer an die Abmeldung. Kann mich jemand anleiten, wie ich session idfür alle verfügbar bleiben kann activities?

Jede Alternative zu diesem Fall

Der einfachste Weg, dies zu tun, besteht darin, die Sitzungs-ID an die Abmeldeaktivität zu übergeben, mit der IntentSie die Aktivität starten:

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

Greifen Sie bei der nächsten Aktivität auf diese Absicht zu:

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

In den Dokumenten für Absichten finden Sie weitere Informationen (siehe Abschnitt "Extras").

Erstellen Sie in Ihrer aktuellen Aktivität eine neue Intent:

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

Rufen Sie dann in der neuen Aktivität die folgenden Werte ab:

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

Verwenden Sie diese Technik, um Variablen von einer Aktivität zur anderen zu übergeben.

Vorbeigehen Absichts- Extras ist ein guter Ansatz, wie Erich bemerkte.

Das Anwendungsobjekt ist jedoch eine andere Möglichkeit, und es ist manchmal einfacher, mit demselben Status über mehrere Aktivitäten hinweg umzugehen (im Gegensatz dazu, dass es überall abgerufen / platziert werden muss) oder mit Objekten, die komplexer als Grundelemente und Zeichenfolgen sind.

Sie können die Anwendung erweitern und dort festlegen / abrufen, was Sie möchten, und von jeder Aktivität (in derselben Anwendung) mit darauf zugreifen abrufen getApplication () darauf zugreifen .

Denken Sie auch daran, dass andere Ansätze, wie z. B. die Statik, problematisch sein können, da sie zu Speicherverlusten führen können . Die Anwendung hilft auch, dies zu lösen.

Quellklasse:

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

Zielklasse (NewActivity-Klasse):

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

Sie müssen nur Extras senden, während Sie Ihre Absicht anrufen.

So was:

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

Jetzt können Sie auf OnCreateIhre Methode SecondActivitydie Extras wie folgt abrufen.

Wenn der von Ihnen gesendete Wert in warlong :

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

Wenn der von Ihnen gesendete Wert a warString :

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

Wenn der von Ihnen gesendete Wert a warBoolean :

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

Es hilft mir, die Dinge im Kontext zu sehen. Hier sind zwei Beispiele.

Daten weiterleiten

Hauptaktivität

• Fügen Sie die Daten, die Sie senden möchten, in eine Absicht mit einem Schlüssel-Wert-Paar ein. Siehe diese Antwort Namenskonventionen für den Schlüssel.
• Starten Sie die zweite Aktivität mit 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);
    }
}

Zweite Aktivität

• Sie verwenden getIntent(), um Intentdie zweite Aktivität zu starten. Anschließend können Sie die Daten mit getExtras()und den Schlüssel extrahieren, den Sie in der ersten Aktivität definiert haben. Da unsere Daten ein String sind, werden wir sie hier nur verwenden 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);
    }
}

Daten zurückgeben

Hauptaktivität

• Beginnen Sie die zweite Aktivität mit startActivityForResultund geben Sie einen beliebigen Ergebniscode ein.
• Überschreiben onActivityResult . Dies wird aufgerufen, wenn die zweite Aktivität beendet ist. Sie können sicherstellen, dass es sich tatsächlich um die zweite Aktivität handelt, indem Sie den Ergebniscode überprüfen. (Dies ist nützlich, wenn Sie mehrere verschiedene Aktivitäten von derselben Hauptaktivität aus starten.)
• Extrahieren Sie die Daten, die Sie aus der Rücksendung erhalten haben Intent. Die Daten werden mit einem Schlüssel-Wert-Paar extrahiert. Ich könnte eine beliebige Zeichenfolge für den Schlüssel verwenden, aber ich werde die vordefinierte verwenden, Intent.EXTRA_TEXTda ich Text sende.

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

Zweite Aktivität

• Fügen Sie die Daten, die Sie an die vorherige Aktivität zurücksenden möchten, in eine ein Intent. Die Daten werden unter IntentVerwendung eines Schlüssel-Wert-Paares im gespeichert . Ich habe mich Intent.EXTRA_TEXTfür meinen Schlüssel entschieden.
• Setzen Sie das Ergebnis auf RESULT_OKund fügen Sie die Absicht hinzu, die Ihre Daten enthält.
• Rufen Sie finish()an, um die zweite Aktivität zu schließen.

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

Aktualisiert Beachten Sie, dass ich die Verwendung von SharedPreference erwähnt habe . Es verfügt über eine einfache API und ist für alle Aktivitäten einer Anwendung zugänglich. Dies ist jedoch eine ungeschickte Lösung und ein Sicherheitsrisiko, wenn Sie vertrauliche Daten weitergeben. Es ist am besten, Absichten zu verwenden. Es verfügt über eine umfangreiche Liste überladener Methoden, mit denen viele verschiedene Datentypen zwischen Aktivitäten besser übertragen werden können. Schauen Sie sich intent.putExtra an . Dieser Link zeigt die Verwendung von putExtra recht gut.

Beim Übergeben von Daten zwischen Aktivitäten besteht mein bevorzugter Ansatz darin, eine statische Methode für die relevante Aktivität zu erstellen, die die erforderlichen Parameter enthält, um die Absicht zu starten. Das bietet dann ein einfaches Einrichten und Abrufen von Parametern. So kann es aussehen

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

Anschließend können Sie eine Absicht für die beabsichtigte Aktivität erstellen und sicherstellen, dass Sie über alle Parameter verfügen. Sie können für Fragmente an anpassen. Ein einfaches Beispiel oben, aber Sie bekommen die Idee.

Versuchen Sie Folgendes zu tun:

Erstellen Sie eine einfache "Helfer" -Klasse (Factory für Ihre Absichten) wie folgt:

import android.content.Intent;

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

Dies wird die Fabrik für alle Ihre Absichten sein. Erstellen Sie jedes Mal, wenn Sie einen neuen Intent benötigen, eine statische Factory-Methode in IntentHelper. Um eine neue Absicht zu erstellen, sollten Sie sie einfach so sagen:

IntentHelper.createYourSpecialIntent(getIntent());

In Ihrer Tätigkeit. Wenn Sie einige Daten in einer "Sitzung" "speichern" möchten, verwenden Sie einfach Folgendes:

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

Und senden Sie diese Absicht. In der Zielaktivität ist Ihr Feld verfügbar als:

getIntent().getStringExtra("YOUR_FIELD_NAME");

Jetzt können wir Intent wie dieselbe alte Sitzung verwenden (wie in Servlets oder JSP ).

Sie können benutzerdefinierte Klassenobjekte auch übergeben, indem Sie eine Paketklasse erstellen . Der beste Weg, um es paketfähig zu machen, besteht darin, Ihre Klasse zu schreiben und sie dann einfach auf einer Website wie http://www.parcelabler.com/ einzufügen . Klicken Sie auf Build und Sie erhalten neuen Code. Kopieren Sie all dies und ersetzen Sie den ursprünglichen Klasseninhalt. Dann-

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

und erhalten Sie das Ergebnis in NextActivity wie-

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

Jetzt können Sie das foo- Objekt einfach so verwenden, wie Sie es verwendet hätten.

Eine andere Möglichkeit besteht darin, ein öffentliches statisches Feld zu verwenden, in dem Sie Daten speichern, dh:

public class MyActivity extends Activity {

  public static String SharedString;
  public static SomeObject SharedObject;

//...

Der bequemste Weg, Daten zwischen Aktivitäten zu übertragen, ist das Übergeben von Absichten. In der ersten Aktivität, von der aus Sie Daten senden möchten, sollten Sie Code hinzufügen:

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

Sie sollten auch importieren

import android.content.Intent;

In der nächsten Aktivität (SecondActivity) sollten Sie dann die Daten aus der Absicht mit dem folgenden Code abrufen.

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

Sie können verwenden SharedPreferences...

1. Protokollierung. Sitzungs-ID des Zeitspeichers inSharedPreferences

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

2. Ausloggen. Zeitabruf-Sitzungs-ID in gemeinsam genutzten Einstellungen

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

Wenn Sie nicht über die erforderliche Sitzungs-ID verfügen, entfernen Sie die freigegebenen Einstellungen:

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

Das ist sehr nützlich, da Sie den Wert einmal speichern und dann irgendwo eine Aktivität abrufen.

Der Standardansatz.

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

Rufen Sie jetzt in Ihrer zweiten Aktivität Ihre Daten aus dem Bundle ab:

Holen Sie sich das Bundle

Bundle bundle = getIntent().getExtras();

Daten extrahieren…

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

Aus der Aktivität

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

Zur Aktivität

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

Sie können Daten zwischen Aktivitäten mit dem Intent-Objekt senden. Stellen Sie sich vor, Sie haben zwei Aktivitäten, nämlich FirstActivityund SecondActivity.

Inside FirstActivity:

Intent verwenden:

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

Innerhalb von SecondActivity

Bundle bundle= getIntent().getExtras();

Jetzt können Sie verschiedene Methoden für Bundle-Klassen verwenden, um Werte von FirstActivity by Key zu erhalten.

Zum Beispiel bundle.getString("key"), bundle.getDouble("key"), bundle.getInt("key")usw.

Wenn Sie eine Bitmap zwischen Aktivitäten / Fragmenten übertragen möchten

Aktivität

So übergeben Sie eine Bitmap zwischen Aktivitäten

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

Und in der Aktivitätsklasse

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

Fragment

Eine Bitmap zwischen Fragmenten übergeben

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

Im SecondFragment empfangen

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

Große Bitmaps übertragen

Wenn Sie eine fehlgeschlagene Binder-Transaktion erhalten, bedeutet dies, dass Sie den Binder-Transaktionspuffer überschreiten, indem Sie ein großes Element von einer Aktivität zu einer anderen Aktivität übertragen.

In diesem Fall müssen Sie die Bitmap als Byte-Array komprimieren und dann in einer anderen Aktivität wie dieser dekomprimieren

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

Und in der 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);

Sie können es in einer anderen Aktivität abrufen. Zwei Wege:

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

Der zweite Weg ist:

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

Hier ist meine beste Vorgehensweise und sie hilft sehr, wenn das Projekt riesig und komplex ist.

Angenommen, ich habe 2 Aktivitäten LoginActivityund HomeActivity. Ich möchte 2 Parameter (Benutzername & Passwort) von LoginActivityan übergeben HomeActivity.

Zuerst erstelle ich meine 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);
    }
}

So übergebe ich die Daten in meiner 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);

    }
}

Letzter Schritt, hier ist, wie ich die Daten in erhalte 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());
    }
}

Erledigt! Cool :) Ich möchte nur meine Erfahrungen teilen. Wenn Sie an einem kleinen Projekt arbeiten, sollte dies nicht das große Problem sein. Aber wenn Sie an einem großen Projekt arbeiten, tut es wirklich weh, wenn Sie Refactoring oder Fehlerbehebung durchführen möchten.

Ergänzende Antwort: Namenskonventionen für die Schlüsselzeichenfolge

Der eigentliche Prozess der Datenübergabe wurde bereits beantwortet, die meisten Antworten verwenden jedoch fest codierte Zeichenfolgen für den Schlüsselnamen in der Absicht. Dies ist normalerweise in Ordnung, wenn es nur in Ihrer App verwendet wird. In der Dokumentation wird jedoch die Verwendung von empfohlenEXTRA_* Konstanten für standardisierte Datentypen zu verwenden.

Beispiel 1: Verwenden von Intent.EXTRA_*Schlüsseln

Erste Aktivität

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

Zweite Aktivität:

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

Beispiel 2: Definieren Sie Ihre eigenen static final Schlüssel

Wenn eine der Intent.EXTRA_*Zeichenfolgen nicht Ihren Anforderungen entspricht, können Sie zu Beginn der ersten Aktivität eine eigene definieren.

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

Das Einfügen des Paketnamens ist nur eine Konvention, wenn Sie den Schlüssel nur in Ihrer eigenen App verwenden. Es ist jedoch unbedingt erforderlich, Namenskonflikte zu vermeiden, wenn Sie einen Dienst erstellen, den andere Apps mit Absicht aufrufen können.

Erste Aktivität:

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

Zweite Aktivität:

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

Beispiel 3: Verwenden eines String-Ressourcenschlüssels

Obwohl in der Dokumentation nicht erwähnt, empfiehlt diese Antwort die Verwendung einer String-Ressource, um Abhängigkeiten zwischen Aktivitäten zu vermeiden.

string.xml

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

Erste Aktivität

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

Zweite Aktivität

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

Sie können verwenden Intent

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

Ein anderer Weg könnte auch die Verwendung eines Singleton-Musters sein :

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

Aus Ihrer FirstActivity

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

Auf SecondActivity

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

Die Weitergabe von Daten zwischen Aktivitäten erfolgt hauptsächlich über ein Absichtsobjekt.

Zuerst müssen Sie die Daten unter Verwendung der BundleKlasse an das Intent-Objekt anhängen . Rufen Sie dann die Aktivität mit einer startActivity()oder beiden startActivityForResult()Methoden auf.

Weitere Informationen dazu finden Sie am Beispiel des Blogposts Übergeben von Daten an eine Aktivität .

Sie können Shared Preference ausprobieren. Dies ist möglicherweise eine gute Alternative für den Datenaustausch zwischen den Aktivitäten

So speichern Sie die Sitzungs-ID:

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

Um sie zu bekommen -

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

Starten Sie eine andere Aktivität von diesem Aktivitätsübergabeparameter über Bundle Object

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

Bei einer anderen Aktivität abrufen (YourActivity)

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

Dies ist für einfache Datentypen in Ordnung. Wenn Sie jedoch komplexe Daten zwischen den Aktivitäten übergeben möchten, müssen Sie diese zuerst serialisieren.

Hier haben wir das Mitarbeitermodell

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

    getters...
    setters...
}

Sie können die von Google bereitgestellte Gson lib verwenden, um die komplexen Daten wie folgt zu serialisieren

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

Kotlin

Pass von der ersten Aktivität

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

Holen Sie sich in der zweiten Aktivität

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

Vorschlag

Legen Sie die Schlüssel immer in einer konstanten Datei ab, um sie besser verwalten zu können.

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

Charlie Collins gab mir eine perfekte Antwort mit dem Application.class. Mir war nicht bewusst, dass wir es so einfach unterordnen können. Hier ist ein vereinfachtes Beispiel mit einer benutzerdefinierten Anwendungsklasse.

AndroidManifest.xml

Geben Sie das android:nameAttribut an, um Ihre eigene Anwendungsklasse zu verwenden.

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

MyApplication.java

Verwenden Sie dies als globalen Referenzinhaber. Es funktioniert gut in einem gleichen Prozess.

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

Legen Sie die globale "Singleton" -Referenz auf die Anwendungsinstanz fest.

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

Ein einfaches Beispiel, in dem ich eine Hauptaktivität aus einer anderen Aktivitätsinstanz verwende.

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

Ich habe kürzlich die Vapor API veröffentlicht , ein Android-Framework mit jQuery-Geschmack, das alle möglichen Aufgaben wie diese vereinfacht. Wie bereits erwähnt, SharedPreferencesist dies eine Möglichkeit, dies zu tun.

VaporSharedPreferenceswird als Singleton implementiert, sodass dies eine Option ist. In der Vapor-API ist die .put(...)Methode stark überlastet , sodass Sie sich nicht explizit um den von Ihnen festgeschriebenen Datentyp kümmern müssen, sofern dieser unterstützt wird. Es ist auch fließend, so dass Sie Anrufe verketten können:

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

Optional werden Änderungen automatisch gespeichert und der Lese- und Schreibprozess unter der Haube vereinheitlicht, sodass Sie einen Editor nicht explizit abrufen müssen, wie dies bei Standard-Android der Fall ist.

Alternativ können Sie eine verwenden Intent. In der Vapor-API können Sie die verkettete überladene .put(...)Methode auch für Folgendes verwenden VaporIntent:

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

Und geben Sie es als Extra weiter, wie in den anderen Antworten erwähnt. Sie können Extras von Ihrem abrufen Activity, und wenn Sie VaporActivitydies verwenden, wird dies automatisch für Sie erledigt, sodass Sie Folgendes verwenden können:

this.extras()

Um sie am anderen Ende abzurufen, Activitywechseln Sie zu.

Hoffe das ist für manche von Interesse :)

Erste Aktivität:

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

Zweite Aktivität:

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

Sie können Daten zwischen Aktivitäten in der Anwendung auf drei Arten übergeben

1. Absicht
2. Gemeinsame Einstellungen
3. Anwendung

Das absichtliche Übergeben von Daten hat eine gewisse Grenze. Für große Datenmengen können Sie die Datenfreigabe auf Anwendungsebene verwenden. Durch Speichern in SharedPreference wird die Größe Ihrer App erhöht

Verwenden Sie eine globale Klasse:

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

Sie können die Setter und Getter dieser Klasse aus allen anderen Klassen aufrufen. Wenn Sie dies tun, müssen Sie in jeder Aktivität ein GlobalClass-Objekt erstellen:

GlobalClass gc = (GlobalClass) getApplication();

Dann können Sie zum Beispiel anrufen:

gc.getVitaminA()