Comment puis-je transmettre des données entre les activités dans l'application Android?

Question

J'ai un scénario où, après vous être connecté via une page de connexion, il y aura une déconnexion button sur chaque activity.

En cliquant sur sign-out, je vais passer le session id de l'utilisateur connecté à la déconnexion. Quelqu'un peut-il me guider sur la façon de garder session id disponible pour tous activities?

Toute alternative à cette affaire

Erich Douglass · Accepted Answer

La façon la plus simple de procéder consiste à passer l'identifiant de session à l'activité de déconnexion dans la Intent que 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 pour la prochaine activité:

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

Le docs for Intents contient plus d'informations (consultez la section intitulée "Extras").

user914425 · Answer

Dans votre activité en cours, créez une nouvelle 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.

Charlie Collins · Answer

Passing Intent extras est une bonne approche, comme le note Erich.

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

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

N'oubliez pas non plus que d'autres approches, telles que la statique, peuvent être problématiques car elles peuvent entraîner des fuites de mémoire . L'application aide à résoudre cela aussi.

Md. Rahman · Answer

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

Mayank Saini · Answer

Vous devez juste envoyer des extras 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 méthode OnCreate de votre SecondActivity, vous pouvez récupérer les extras comme ceci.

Si la valeur que vous avez envoyée était dans long:

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 était un String:

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

Si la valeur que vous avez envoyée était un Boolean:

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

angryITguy · Answer

Mis à jour Notez que j'avais déjà mentionné l'utilisation de SharedPreference . Il possède une API simple et est accessible à travers les activités d'une application. Mais il s’agit d’une solution maladroite, qui constitue un risque pour la sécurité si vous transmettez des données sensibles. Il est préférable d'utiliser les intentions. Il contient une longue liste de méthodes surchargées pouvant être utilisées pour mieux transférer de nombreux types de données différents entre les activités. Regardez intent.putExtra . Ce lien présente très bien l’utilisation de putExtra.

Lors de la transmission de données entre activités, mon approche préférée consiste à créer une méthode statique pour l'activité concernée, qui inclut les paramètres requis pour lancer l'intention. Ce qui facilite ensuite la configuration et la récupération des 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, ...)); ...

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

Suragch · Answer

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

Passing Data Forward

Activité principale

Placez 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 le Intent qui a démarré 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 utiliser getStringExtra ici.

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

Passing Data Back

Activité principale

Commencez la deuxième activité avec startActivityForResult, en lui fournissant un code de résultat arbitraire.
Remplacer onActivityResult. Ceci est appelé à la fin de la deuxième activité. 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 démarrez 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 le Intent.EXTRA_TEXT prédéfini puisque 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é

Placez les données que vous souhaitez renvoyer à l'activité précédente dans un fichier Intent. Les données sont stockées dans la Intent à l'aide d'une paire clé-valeur. J'ai choisi d'utiliser Intent.EXTRA_TEXT pour ma clé.
Définissez le résultat sur RESULT_OK et ajoutez l'objectif contenant 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(); } }

ponkin · Answer

Essayez de faire ce qui suit:

Créez une classe "d'assistance" simple (fabrique 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 de fabrique statique dans IntentHelper. Pour créer un nouvel Intent, vous devriez simplement le dire comme ceci:

IntentHelper.createYourSpecialIntent(getIntent());

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

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

Et envoyez cette intention. Dans l'activité cible, votre champ sera disponible en tant que:

getIntent().getStringExtra("YOUR_FIELD_NAME");

Nous pouvons donc maintenant utiliser Intent comme la même session ancienne (comme dans les servlets ou JSP ).

Vaibhav Sharma · Answer

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 la coller dans un site tel que http://www.parcelabler.com/ . Cliquez sur construire et vous obtiendrez un nouveau code. Copiez tout cela et remplacez le contenu original de la classe. Ensuite-

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

ComputerSaysNo · Answer

Une autre méthode 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; //...

Sahil Mahajan Mj · Answer

Le moyen le plus pratique de transmettre des données entre des 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 devriez également importer

import Android.content.Intent;

Ensuite, lors de la prochaine Acitvity (SecondActivity), vous devez extraire les données de l’intention à l’aide du code suivant.

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

Ravi Parsania · Answer

Vous pouvez utiliser SharedPreferences...

Enregistrement. ID de session du magasin de temps dans SharedPreferences

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

Déconnexion. Heure de récupération de l'identifiant de session dans les préférences partagées

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

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

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

Cela est très utile, car une fois, vous enregistrez la valeur, puis récupérez n’importe où vos activités.

Ajay Venugopal · Answer

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 lot:

Obtenir le paquet

Bundle bundle = getIntent().getExtras();

Extraire les données…

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

Gavine Joyce · Answer

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

Krishna · Answer

Vous pouvez envoyer des données entre des activités à l'aide d'un objet d'intention. Considérez que vous avez deux activités, à savoir FirstActivity et SecondActivity.

Inside FirstActivity:

Utilisation de 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 bundle pour obtenir les valeurs transmises par FirstActivity par Key.

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

capt.swag · Answer

Si vous souhaitez transférer un bitmap entre des activités/des 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 d'activité

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

fragment

Pour passer un 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 grandes images bitmap

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

Dans ce cas, vous devez compresser le bitmap en tant que tableau d'octets puis le décompresser dans une autre activité, comme ceci

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 seconde activité

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

THANN Phearum · Answer

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

Supposons que j'ai 2 activités, LoginActivity et HomeActivity. Je veux passer 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 dans 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 de petits projets, cela ne devrait pas être le gros problème. Mais lorsque vous travaillez sur de gros projets, il est très pénible de vouloir refactoriser ou corriger des bugs.

Dilavar M · Answer

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

Sachin · Answer

Vous pouvez utiliser Intent

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

Une autre façon pourrait utiliser motif singleton aussi:

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 première activité

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

Sur la seconde activité

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

Suragch · Answer

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

Le processus actuel de transmission des données a déjà fait l'objet d'une réponse, mais la plupart des réponses utilisent des chaînes codées en dur pour le nom de la clé dans l'objectif. Cela convient généralement si vous l'utilisez uniquement dans votre application. Cependant, la documentation recommandée utilise les constantes EXTRA_* pour les types de données normalisés.

Exemple 1: utilisation des touches Intent.EXTRA_*

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 clé static final

Si l'une des chaînes Intent.EXTRA_* ne répond 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";

L'inclusion du 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 un type 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));

PRABEESH R K · Answer

Le transfert de données entre activités se fait principalement à l'aide d'un objet d'intention.

Commencez par attacher les données à l'objet d'intention à l'aide de la classe Bundle. Appelez ensuite l'activité à l'aide des méthodes startActivity() ou startActivityForResult().

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

Rohit Gurjar · Answer

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

Pour enregistrer l'identifiant 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);

DroidNinja · Answer

Commencez une autre activité à partir des paramètres de cette activité via l'objet Bundle

Intent intent = new Intent(getBaseContext(), YourActivity.class); intent.putExtra("USER_NAME", "xyz@gmail.com"); startActivity(intent);

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

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

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

Ici nous avons le modèle employé

class Employee{ private String empId; private int age; print Double salary; getters... setters... }

Vous pouvez utiliser Gson lib fourni par Google pour sérialiser les données complexes comme ceci

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

Whome · Answer

Charlie Collins m'a donné un parfait réponse 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`

Attribuez à l'attribut Android:name l'utilisation de 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 un détenteur de référence global. Cela fonctionne bien dans le 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 "singleton" globale à 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(); } } }

Dip Pokhrel · Answer

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

Khemraj · Answer

Kotlin

Pass de la première activité

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

entrer dans la deuxième activité

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

Suggestion

Toujours mettre les clés dans le fichier constant pour plus de manière gérée.

companion object { val KEY = "key" }

javadaskari · Answer

J'utilise des champs statiques dans une classe et les récupère/les définit:

Comme:

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

Pour obtenir une valeur, utilisez ceci dans une activité:

Info.ID Info.NAME

Pour définir une valeur:

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

suresh madaparthi · Answer

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

Darius · Answer

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

VaporSharedPreferences est implémenté en tant que Singleton, ce qui en fait une option. Dans Vapor API, il utilise une méthode très surchargée .put(...). Vous n'avez donc pas de s’inquiéter explicitement du type de données que vous validez - à condition qu’il soit pris en charge. Il parle aussi couramment, vous pouvez donc chaîner des appels:

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

Il enregistre également automatiquement les modifications et unifie le processus de lecture et d'écriture de manière à ce qu'il ne soit pas nécessaire d'extraire explicitement un éditeur comme vous le faites dans Android standard.

Sinon, vous pouvez utiliser un Intent. Dans Vapor API, vous pouvez également utiliser la méthode .put(...) _ surchargée chaînable sur une VaporIntent :

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

Et passez-le comme un extra, comme mentionné dans les autres réponses. Vous pouvez récupérer des extras à partir de votre Activity. De plus, si vous utilisez VaporActivity , ceci est fait automatiquement pour vous afin que vous puissiez utiliser:

this.extras()

Pour les récupérer à l’autre extrémité de la variable Activity à laquelle vous passez.

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

Khushboo Aggarwal · Answer

vous pouvez communiquer entre deux activités par intention. Chaque fois que vous naviguez vers une autre activité au travers de votre activité de connexion, vous pouvez placer votre sessionId dans une intention et l'intégrer à d'autres activités via getIntent (). Voici l'extrait de code pour cela:

LoginActivity:

Intent intent = new Intent(YourLoginActivity.this,OtherActivity.class); intent.putExtra("SESSION_ID",sessionId); startActivity(intent); finishAfterTransition();

OtherActivity:

Dans onCreate () ou partout où vous en avez besoin, appelez getIntent (). GetStringExtra ("SESSION_ID"); Assurez-vous également que l'intention est nulle et que la clé que vous transmettez doit être identique dans les deux activités. Voici l'extrait de code complet:

 if(getIntent!=null && getIntent.getStringExtra("SESSION_ID")!=null){ sessionId = getIntent.getStringExtra("SESSION_ID"); }

Cependant, je vous suggérerais d'utiliser AppSharedPreferences pour stocker votre sessionId et l'obtenir à partir de là où vous en auriez besoin.

Patricia Heimfarth · Answer

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 à partir 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()

MurugananthamS · Answer

Essaye ça:

CurrentActivity.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");

Mehul Solanki · Answer

Meilleure façon de transmettre des données à un Activity à AnothetActivity en utilisant Intent,

Vérifiez le code snippé

ActivityOne.Java

Intent myIntent = new Intent(this, NewActivity.class); myIntent.putExtra("key_name_one", "Your Data value here"); myIntent.putExtra("key_name_two", "Your data value here"); startActivity(myIntent)

Sur votre seconde activité

SecondActivity.Java

protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.view); Intent intent = getIntent(); String valueOne = intent.getStringExtra("key_name_one"); String valueTwo = intent.getStringExtra("key_name_two"); }

Lavanya Velusamy · Answer

Vous pouvez transmettre des données entre les activités d'une application de 3 manières différentes. 1.Intent 2.SharedPreferences 3.Application

le transfert de données dans l'intention a une certaine limite.Pour de grandes quantités de données, vous pouvez utiliser le partage de données au niveau de l'application et en le stockant dans sharedpref pour augmenter la taille de votre application.

Rahul Sharma · Answer

1ère manière: - Dans votre activité actuelle, lorsque vous créez un objet d'intention pour ouvrir un nouvel écran:

 String value="xyz"; Intent intent = new Intent(CurrentActivity.this, NextActivity.class); intent.putExtra("key", value); startActivity(intent);

Ensuite, dans la méthode nextActivity in onCreate, récupérez les valeurs que vous transmettez de l'activité précédente:

 if (getIntent().getExtras() != null) { String value = getIntent.getStringExtra("key"); //The key argument must always match that used send and retrive value from one activity to another. }

2ème manière: - Vous pouvez créer un objet bundle et mettre des valeurs dans un bundle, puis mettre l'objet bundle dans l'intention de votre activité actuelle: -

 String value="xyz"; Intent intent = new Intent(CurrentActivity.this, NextActivity.class); Bundle bundle = new Bundle(); bundle.putInt("key", value); intent.putExtra("bundle_key", bundle); startActivity(intent);

Ensuite, dans la méthode nextActivity in onCreate, récupérez les valeurs que vous transmettez de l'activité précédente:

 if (getIntent().getExtras() != null) { Bundle bundle = getIntent().getStringExtra("bundle_key); String value = bundle.getString("key"); //The key argument must always match that used send and retrive value from one activity to another. }

Vous pouvez également utiliser la classe de haricot pour transmettre des données entre classes à l'aide de la sérialisation.

user5876477 · Answer

Votre objet de données doit étendre la classe Parcelable ou Serializable

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

Ali hasan · Answer

Si vous utilisez Kotlin:

Dans MainActivity1:

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

Dans MainActivity2:

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

Mohsinali · Answer

Pour le faire en Java:

startActivity(new Intent(this, MainActivity.class).putExtra("userId", "2"));

Vipul Prajapati · Answer

Créer une nouvelle Intent dans votre activité actuelle

String myData="Your string/data here"; Intent intent = new Intent(this, SecondActivity.class); intent.putExtra("your_key",myData); startActivity(intent);

Dans votre SecondActivity.Java onCreate() Récupérez ces valeurs à l'aide de la touche your_key

@Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); Bundle extras = getIntent().getExtras(); if (extras != null) { String myData = extras.getString("your_key"); } }

Nitish · Answer

Vous pouvez utiliser la classe d'intention pour envoyer des données entre des activités. Il s’agit d’un message adressé au système d’exploitation dans lequel vous décrivez la source et la destination du flux de données. Comme les données d'une activité A à B.

Dans ACTIVITY A (la source):

Intent intent = new Intent(A.this, B.class); intent.putExtra("KEY","VALUE"); startActivity(intent);

Dans l'activité B (la destination) ->

Intent intent =getIntent(); String data =intent.getString("KEY");

Ici, vous obtiendrez des données pour la clé "KEY"

POUR UNE MEILLEURE UTILISATION TOUJOURS LES CLÉS DEVRAIENT ÊTRE STOCKÉES DANS UNE CLASSE DE SIMPLICITÉ ET CELUI-CI AIDERA À MINNIMISER LE RISQUE D'ERREURS DE Taper.

Comme ça:

public class Constants{ public static String KEY="KEY" }

Maintenant dans ACTIVITE A:

intent.putExtra(Constants.KEY,"VALUE");

Dans Activité B:

String data =intent.getString(Constants.KEY);

MageNative · Answer

Pour Utiliser l’ID de session dans toutes les activités, vous pouvez suivre les étapes suivantes.

1-Définissez une session STATIC VARIABLE (qui contiendra la valeur de l'identifiant de session) dans le fichier APPLICATION de votre application.

2-Appelez maintenant la variable de session avec la référence de la classe où vous allez récupérer la valeur de l'identifiant de session et assignez-la à une variable statique.

3-Maintenant, vous pouvez utiliser cette valeur d’identifiant de session n’importe où en appelant simplement la variable statique par le bouton

tdjprog · Answer

Nouvelle interaction en temps réel entre les activités utilisant des rappels:

- ÉTAPE 01: implémenter une interface partagée

public interface SharedCallback { public String getSharedText(/*you can define arguments here*/); }

- ÉTAPE 02: implémenter une classe partagée

final class SharedMethode { private static Context mContext; private static SharedMethode sharedMethode = new SharedMethode(); private SharedMethode() { super(); } public static SharedMethode getInstance() { return sharedMethode; } public void setContext(Context context) { if (mContext != null) return; mContext = context; } public boolean contextAssigned() { return mContext != null; } public Context getContext() { return mContext; } public void freeContext() { mContext = null; } }

- ÉTAPE 03 :: Jouer avec le code dans la première activité

public class FirstActivity extends Activity implements SharedCallback { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.your_layout); // call playMe from here or there playMe(); } private void playMe() { SharedMethode.getInstance().setContext(this); Intent intent = new Intent(this, SecondActivity.class); startActivity(intent); } @Override public String getSharedText(/*passed arguments*/) { return "your result"; } }

- ETAPE 04 :: Finaliser le jeu dans SecondActivity

public class SecondActivity extends Activity { private SharedCallback sharedCallback; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.your_layout); if (SharedMethode.getInstance().contextAssigned()) { if (SharedMethode.getInstance().getContext() instanceof SharedCallback) sharedCallback = (SharedCallback) SharedMethode.getInstance().getContext(); // to prevent memory leak SharedMethode.freeContext(); } // You can now call your implemented methodes from anywhere at any time if (sharedCallback != null) Log.d("TAG", "Callback result = " + sharedCallback.getSharedText()); } @Override protected void onDestroy() { sharedCallback = null; super.onDestroy(); } }

STEP 05 :: vous pouvez aussi implémenter un rappel de mot-clé (de la première à la seconde) pour obtenir des résultats de SecondAvtivity ou appeler des méthodes

Rodion Altshuler · Answer

Pensez à utiliser un singleton pour que les informations de votre session soient accessibles à toutes les activités.

Cette approche présente plusieurs avantages par rapport aux extras et aux variables statiques:

Vous permet d'étendre la classe Info en ajoutant les nouveaux paramètres d'informations utilisateur dont vous avez besoin. Vous pouvez créer une nouvelle classe qui en hérite ou simplement modifier la classe Info sans avoir à modifier la gestion des extras dans tous les espaces.

Utilisation facile - pas besoin de faire des extras pour chaque activité.

public class Info { private static Info instance; private int id; private String name; //Private constructor is to disallow instances creation outside create() or getInstance() methods private Info() { } //Method you use to get the same information from any Activity. //It returns the existing Info instance, or null if not created yet. public static Info getInstance() { return instance; } //Creates a new Info instance or returns the existing one if it exists. public static synchronized Info create(int id, String name) { if (null == instance) { instance = new Info(); instance.id = id; instance.name = name; } return instance; } }

android developer · Answer

Il existe plusieurs façons de transmettre des données entre les activités et la documentation en contient plusieurs.

Dans la plupart des cas, Intent.putExtras est suffisant.

Vincent Mungai · Answer

Dans l'activité Destination, définissez comme ceci

public class DestinationActivity extends AppCompatActivity{ public static Model model; public static void open(final Context ctx, Model model){ DestinationActivity.model = model; ctx.startActivity(new Intent(ctx, DestinationActivity.class)) } public void onCreate(/*Parameters*/){ //Use model here model.getSomething(); } }

Dans la première activité, commencez la deuxième activité comme ci-dessous

DestinationActivity.open(this,model);

Haroon Chhipa · Answer

// Votre problème est que vous souhaitez stocker l'identifiant de session après la connexion et qu'il soit disponible pour chaque activité pour laquelle vous souhaitez vous déconnecter.

// La solution à votre problème est que vous devez stocker votre identifiant de session après une connexion réussie dans une variable publique. et chaque fois que vous avez besoin d'un identifiant de session pour vous déconnecter, vous pouvez accéder à cette variable et remplacer la valeur de la variable par zéro.

//Serializable class public class YourClass implements Serializable { public long session_id = 0; }

Android Player _Shree · Answer

Écrire le code suivant dans CurrentActivity.Java

Intent i = new Intent(CurrentActivity.this, SignOutActivity.class); i.putExtra("SESSION_ID",sessionId); startActivity(i);

Accès SessionId dans SignOutActivity.Java suit le chemin

public void onCreate(Bundle savedInstanceState){ super.onCreate(savedInstanceState); setContentView(R.layout.activity_sign_out); Intent intent = getIntent(); // check intent is null or not if(intent != null){ String sessionId = i.getStringExtra("SESSION_ID"); Log.d("Session_id : " + sessionId); } else{ Toast.makeText(SignOutActivity.this, "Intent is null", Toast.LENGTH_SHORT).show(); } }

Raviraj Desai · Answer

 Intent intent = new Intent(getBaseContext(), SomeActivity.class); intent.putExtra("USER_ID", UserId); startActivity(intent); On SomeActivity : String userId= getIntent().getStringExtra("("USER_ID");

Richard Kamere · Answer

Vous pouvez travailler avec l'intention

String sessionId = "my session id"; startActivity(new Intent(getApplicationContext(),SignOutActivity.class).putExtra("sessionId",sessionId));

sahu · Answer

Celui-ci du moyen le plus simple à passer ID de session à tous les Activité.

Intent mIntent = new Intent(getApplicationContext(), LogoutActivity.class); mIntent.putExtra("session_id", session_id); startActivity(mIntent);

Ainsi, à partir du LogoutActivity, vous pouvez récupérer le session_id , qui sera utilisé ultérieurement pour vous déconnecter. opération.

J'espère que cela vous sera utile ... merci

MurugananthamS · Answer

Nous pouvons transmettre les valeurs à une autre activité de deux manières (même type de réponse déjà posté mais code ici) que j'ai posté et qui a essayé par le biais de l'intention)

1.intention

 Activity1: startActivity(new Intent(getApplicationContext(),Activity2.class).putExtra("title","values")); InActivity 2: String recString= getIntent().getStringExtra("title");

2.En passant de la référence partagée

 Activity1: SharedPreferences pref = getApplicationContext().getSharedPreferences("MyPref", 0); // 0 - for private mode Editor editor = pref.edit(); editor.putString("key_name", "string value"); // Storing string editor.commit(); // commit changes Activty2: SharedPreferences pref = getApplicationContext().getSharedPreferences("MyPref", 0); pref.getString("key_name", null); // getting String

Parth_Darji · Answer

To access session id in all activities you have to store session id in SharedPreference Please see below class that i am using for managing sessions, you can also use same. import Android.content.Context; import Android.content.SharedPreferences; public class SessionManager { public static String KEY_SESSIONID = "session_id"; public static String PREF_NAME = "AppPref"; SharedPreferences sharedPreference; SharedPreferences.Editor editor; Context mContext; public SessionManager(Context context) { this.mContext = context; sharedPreference = context.getSharedPreferences(PREF_NAME, Context.MODE_PRIVATE); editor = sharedPreference.edit(); } public String getSessionId() { return sharedPreference.getString(KEY_SESSIONID, ""); } public void setSessionID(String id) { editor.putString(KEY_SESSIONID, id); editor.commit(); editor.apply(); } } //Now you can access your session using below methods in every activities. SessionManager sm = new SessionManager(MainActivity.this); sm.getSessionId(); //below line us used to set session id on after success response on login page. sm.setSessionID("test");

Mohamed Selim · Answer

J'utilise des champs statiques publics pour stocker des données partagées entre des activités, mais pour minimiser ses effets secondaires, vous pouvez:

Créez un seul champ, ou le moins possible, et réutilisez-les, transformez-les en objet et transmettez-les au type souhaité dans l'activité réceptrice.
Chaque fois que l'un d'entre eux n'est plus utile, définissez-le explicitement sur null pour qu'il soit collecté par le ramasse-miettes, avant la prochaine affectation.