J'ai un scénario où, après la connexion via une page de connexion, il y aura une déconnexion buttonsur chacun activity.

En cliquant sign-out, je transmettrai le nom session idde l'utilisateur connecté à la déconnexion. Quelqu'un peut-il me guider sur la façon de rester session idaccessible à tous activities?

Toute alternative à ce cas

La façon la plus simple de le faire serait de transmettre l'ID de session à l'activité de déconnexion dans le Intentque vous utilisez pour démarrer l'activité:

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

Accédez à cette intention lors de la prochaine activité:

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

La documentation pour Intents contient plus d'informations (consultez la section intitulée "Extras").

Dans votre activité actuelle, créez un nouveau Intent:

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

Ensuite, dans la nouvelle activité, récupérez ces valeurs:

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

Utilisez cette technique pour passer des variables d'une activité à l'autre.

Passer les extras d' intention est une bonne approche, comme l'a noté Erich.

L' objet Application est un autre moyen cependant, et il est parfois plus facile de gérer le même état sur plusieurs activités (par opposition à devoir le mettre / le mettre partout), ou des objets plus complexes que les primitives et les chaînes.

Vous pouvez étendre Application, puis définir / obtenir ce que vous voulez et y accéder à partir de n'importe quelle activité (dans la même application) avec getApplication () .

Gardez également à l'esprit que d'autres approches que vous pourriez voir, comme la statique, peuvent être problématiques car elles peuvent entraîner des fuites de mémoire . L'application permet également de résoudre ce problème.

Classe source:

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

Classe de destination (classe 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");
}

Vous n'avez qu'à envoyer des extras tout en appelant votre intention.

Comme ça:

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

Maintenant, sur la OnCreateméthode de votre, SecondActivityvous pouvez récupérer les extras comme celui-ci.

Si la valeur que vous avez envoyée étaitlong :

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

Si la valeur que vous avez envoyée étaitString :

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

Si la valeur que vous avez envoyée étaitBoolean :

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

Cela m'aide à voir les choses dans leur contexte. Voici deux exemples.

Transmission des données vers l'avant

Activité principale

• Mettez les données que vous souhaitez envoyer dans une intention avec une paire clé-valeur. Voir cette réponse pour les conventions de dénomination de la clé.
• Commencez la deuxième activité avec 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);
    }
}

Deuxième activité

• Vous utilisez getIntent()pour obtenir celui Intentqui a commencé la deuxième activité. Ensuite, vous pouvez extraire les données avec getExtras()et la clé que vous avez définie dans la première activité. Puisque nos données sont une chaîne, nous allons simplement les utiliser getStringExtraici.

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

Transmission de données

Activité principale

• Commencez la deuxième activité avec startActivityForResult, en lui fournissant un code de résultat arbitraire.
• Remplacer onActivityResult. Ceci est appelé lorsque la deuxième activité se termine. Vous pouvez vous assurer qu'il s'agit bien de la deuxième activité en vérifiant le code de résultat. (Ceci est utile lorsque vous lancez plusieurs activités différentes à partir de la même activité principale.)
• Extrayez les données que vous avez obtenues du retour Intent. Les données sont extraites à l'aide d'une paire clé-valeur. Je pourrais utiliser n'importe quelle chaîne pour la clé mais j'utiliserai la prédéfinie Intent.EXTRA_TEXTpuisque j'envoie du texte.

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

Deuxième activité

• Mettez les données que vous souhaitez renvoyer à l'activité précédente dans un fichier Intent. Les données sont stockées dans à l' Intentaide d'une paire clé-valeur. J'ai choisi d'utiliser Intent.EXTRA_TEXTma clé.
• Définissez le résultat RESULT_OKet ajoutez l'intention de conserver vos données.
• Appelez finish()pour fermer la deuxième activité.

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

Mise à jour Notez que je l' avais mentionné l'utilisation de SharedPreference . Il a une API simple et est accessible à travers les activités d'une application. Mais c'est une solution maladroite et un risque pour la sécurité si vous faites circuler des données sensibles. Il est préférable d'utiliser des intentions. Il dispose d'une liste complète de méthodes surchargées qui peuvent être utilisées pour mieux transférer de nombreux types de données différents entre les activités. Jetez un œil à intent.putExtra . Ce lien présente très bien l'utilisation de putExtra.

En passant des données entre les activités, mon approche préférée est de créer une méthode statique pour l'activité pertinente qui inclut les paramètres requis pour lancer l'intention. Ce qui permet ensuite de configurer et de récupérer facilement les paramètres. Donc ça peut ressembler à ça

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

Ensuite, vous pouvez créer une intention pour l'activité prévue et vous assurer que vous disposez de tous les paramètres. Vous pouvez vous adapter aux fragments. Un exemple simple ci-dessus, mais vous avez l'idée.

Essayez de faire ce qui suit:

Créez une classe "d'aide" simple (usine pour vos intentions), comme ceci:

import android.content.Intent;

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

Ce sera l'usine pour toutes vos intentions. Chaque fois que vous avez besoin d'une nouvelle intention, créez une méthode d'usine statique dans IntentHelper. Pour créer une nouvelle intention, vous devez simplement le dire comme ceci:

IntentHelper.createYourSpecialIntent(getIntent());

Dans votre activité. Lorsque vous souhaitez "enregistrer" certaines données dans une "session", utilisez simplement ce qui suit:

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

Et envoyez cette intention. Dans l'activité cible, votre champ sera disponible sous la forme:

getIntent().getStringExtra("YOUR_FIELD_NAME");

Alors maintenant, nous pouvons utiliser Intent comme la même ancienne session (comme dans les servlets ou JSP ).

Vous pouvez également transmettre des objets de classe personnalisés en créant une classe parcelable . Le meilleur moyen de le rendre parcellaire est d'écrire votre classe, puis de le coller simplement sur un site comme http://www.parcelabler.com/ . Cliquez sur build et vous obtiendrez un nouveau code. Copiez tout cela et remplacez le contenu de la classe d'origine. Alors-

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

et obtenez le résultat dans NextActivity comme

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

Maintenant, vous pouvez simplement utiliser l' objet foo comme vous l'auriez utilisé.

Une autre façon consiste à utiliser un champ statique public dans lequel vous stockez des données, à savoir:

public class MyActivity extends Activity {

  public static String SharedString;
  public static SomeObject SharedObject;

//...

Le moyen le plus pratique de transmettre des données entre les activités consiste à transmettre des intentions. Dans la première activité à partir de laquelle vous souhaitez envoyer des données, vous devez ajouter du code,

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

Vous devez également importer

import android.content.Intent;

Ensuite, dans la prochaine activité (SecondActivity), vous devez récupérer les données de l'intention à l'aide du code suivant.

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

Vous pouvez utiliser SharedPreferences...

1. Enregistrement. Identifiant de session du magasin de temps dansSharedPreferences

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

2. Déconnexion. ID de session d'extraction de temps dans les préférences partagées

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

Si vous n'avez pas l'ID de session requis, supprimez les préférences partagées:

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

C'est très utile, car une fois, vous enregistrez la valeur, puis récupérez n'importe où de l'activité.

L'approche standard.

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

Maintenant, dans votre deuxième activité, récupérez vos données du bundle:

Obtenez le pack

Bundle bundle = getIntent().getExtras();

Extraire les données…

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

De l'activité

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

À l'activité

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

Vous pouvez envoyer des données entre les activités à l'aide d'un objet intentionnel. Considérez que vous avez deux activités à savoir FirstActivityet SecondActivity.

À l'intérieur de FirstActivity:

Utiliser l'intention:

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

Inside SecondActivity

Bundle bundle= getIntent().getExtras();

Vous pouvez maintenant utiliser différentes méthodes de classe de bundle pour obtenir des valeurs transmises à partir de FirstActivity par clé.

Par exemple bundle.getString("key"), bundle.getDouble("key"), bundle.getInt("key")etc.

Si vous souhaitez transférer le bitmap entre les activités / fragments

Activité

Pour passer un bitmap entre les activités

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

Et dans la classe Activity

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

Fragment

Pour passer une image bitmap entre des fragments

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

Pour recevoir à l'intérieur du SecondFragment

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

Transfert de grands bitmaps

Si vous obtenez une transaction de classeur ayant échoué, cela signifie que vous dépassez le tampon de transaction de classeur en transférant un élément volumineux d'une activité à une autre.

Donc, dans ce cas, vous devez compresser le bitmap en tant que tableau d'octets, puis le décompresser dans une autre activité , comme celle-ci

Dans la première activité

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

Et dans la 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);

Vous pouvez le récupérer dans une autre activité. Deux façons:

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

La deuxième façon est:

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

Voici ma meilleure pratique et cela aide beaucoup lorsque le projet est énorme et complexe.

Supposons que j'ai 2 activités, LoginActivityet HomeActivity. Je souhaite transmettre 2 paramètres (nom d'utilisateur et mot de passe) de LoginActivityàHomeActivity .

Tout d'abord, je crée mon 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);
    }
}

Voici comment je passe les données dans mon 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);

    }
}

Dernière étape, voici comment je reçois les données en 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());
    }
}

Terminé! Cool :) Je veux juste partager mon expérience. Si vous travaillez sur un petit projet, cela ne devrait pas être le gros problème. Mais lorsque vous travaillez sur un gros projet, cela fait vraiment mal quand vous voulez refactoriser ou corriger des bugs.

Réponse supplémentaire: Conventions de dénomination pour la chaîne de clé

Le processus réel de transmission des données a déjà été répondu, mais la plupart des réponses utilisent des chaînes codées en dur pour le nom de clé dans l'intention. Cela est généralement bien lorsqu'il n'est utilisé que dans votre application. Cependant, la documentation recommande d' utiliser les EXTRA_*constantes pour les types de données standardisés.

Exemple 1: utilisation des Intent.EXTRA_*clés

Première activité

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

Deuxième activité:

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

Exemple 2: définition de votre propre static finalclé

Si l'une des Intent.EXTRA_*chaînes ne correspond pas à vos besoins, vous pouvez définir la vôtre au début de la première activité.

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

Inclure le nom du package n'est qu'une convention si vous utilisez uniquement la clé dans votre propre application. Mais il est nécessaire d'éviter les conflits de noms si vous créez une sorte de service que d'autres applications peuvent appeler avec une intention.

Première activité:

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

Deuxième activité:

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

Exemple 3: utilisation d'une clé de ressource String

Bien que cela ne soit pas mentionné dans la documentation, cette réponse recommande d'utiliser une ressource String pour éviter les dépendances entre les activités.

strings.xml

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

Première activité

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

Deuxième activité

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

Vous pouvez utiliser Intent

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

Une autre façon pourrait également utiliser le modèle singleton :

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

De votre FirstActivity

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

Sur SecondActivity

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

Le passage des données entre les activités se fait principalement au moyen d'un objet intentionnel.

Vous devez d'abord attacher les données à l'objet d'intention avec l'utilisation de la Bundleclasse. Appelez ensuite l'activité à l'aide de l'une des méthodes startActivity()ou startActivityForResult().

Vous pouvez trouver plus d'informations à ce sujet, avec un exemple de l'article de blog Passing data to an Activity .

Vous pouvez essayer la préférence partagée, cela peut être une bonne alternative pour partager des données entre les activités

Pour enregistrer l'ID de session -

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

Les attraper -

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

Démarrer une autre activité à partir de ces paramètres de passe d'activité via l'objet Bundle

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

Récupérer sur une autre activité (YourActivity)

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

C'est ok pour un type de données simple. Mais si vous voulez transmettre des données complexes entre deux activités, vous devez d'abord les sérialiser.

Ici, nous avons le modèle des employés

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

    getters...
    setters...
}

Vous pouvez utiliser la bibliothèque Gson fournie par Google pour sérialiser les données complexes comme celle-ci

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

Passer de la première activité

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

Entrez dans la deuxième activité

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

Suggestion

Mettez toujours les clés dans un fichier constant pour une manière plus gérée.

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 m'a donné une réponse parfaite en utilisant le Application.class. Je ne savais pas que nous pouvions le sous-classer aussi facilement. Voici un exemple simplifié utilisant une classe d'application personnalisée.

AndroidManifest.xml

Donnez l' android:nameattribut pour utiliser votre propre classe d'application.

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

MyApplication.java

Utilisez-le comme support de référence mondial. Cela fonctionne très bien dans un même processus.

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

Définissez la référence globale "singleton" sur l'instance d'application.

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

Un exemple simple où j'utilise une activité principale d'une autre instance d'activité.

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

J'ai récemment publié l' API Vapor , un framework Android aromatisé jQuery qui simplifie toutes sortes de tâches comme celle-ci. Comme mentionné, SharedPreferencesc'est une façon de procéder.

VaporSharedPreferencesest implémenté en tant que Singleton, ce qui est une option, et dans l'API Vapor, il a une .put(...)méthode fortement surchargée , vous n'avez donc pas à vous soucier explicitement du type de données que vous validez - à condition qu'il soit pris en charge. Il est également fluide, vous pouvez donc enchaîner les appels:

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

Il enregistre également les modifications automatiquement en option et unifie le processus de lecture et d'écriture sous le capot, vous n'avez donc pas besoin de récupérer explicitement un éditeur comme vous le faites dans Android standard.

Vous pouvez également utiliser un Intent. Dans l'API Vapor, vous pouvez également utiliser la .put(...)méthode de surcharge en chaîne sur VaporIntent:

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

Et passez-le en supplément, comme mentionné dans les autres réponses. Vous pouvez récupérer des extras de votre Activity, et de plus si vous utilisez VaporActivitycela se fait automatiquement pour vous afin que vous puissiez utiliser:

this.extras()

Pour les récupérer à l'autre extrémité dans la, Activityvous basculez vers.

J'espère que cela intéresse certains :)

Première activité:

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

Deuxième activité:

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

Vous pouvez transmettre des données entre les activités de l'application de 3 manières

1. Intention
2. SharedPreferences
3. Application

la transmission de données intentionnelles a une certaine limite. Pour une grande quantité de données, vous pouvez utiliser le partage de données au niveau de l'application et en le stockant dans SharedPreference, la taille de votre application augmente

Utilisez une classe globale:

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

Vous pouvez appeler les setters et les getters de cette classe de toutes les autres classes. Pour ce faire, vous devez créer un objet GlobalClass dans chaque activité:

GlobalClass gc = (GlobalClass) getApplication();

Ensuite, vous pouvez appeler par exemple:

gc.getVitaminA()