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

1349

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

UMAR
la source
14
j'ai utilisé sharedpreference, c'est utile aussi pour garder les données de connexion sur la fonction de mot de passe remeber
shareef
Cela fonctionne pour moi. stackoverflow.com/a/7325248/2125322 Merci Darshan Computing
matasoy
stackoverflow.com/a/37774966/6456129 peut être utile
Yessy
pour de tels cas, essayez de créer la classe commomUtils avec la méthode sharedprefereces ... cela gardera le code propre et les données associées à un endroit. Et vous pourrez facilement effacer un ensemble de données spécifique avec une seule méthode pour effacer ce fichier de préférences spécifique, sans effacer aucune des données d'application par défaut ...
Muahmmad Tayyib

Réponses:

1266

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

Erich Douglass
la source
ok si je passe l'identifiant de session à la déconnexion en cas de connexion réussie et cela fonctionnera-t-il sur n'importe quelle page d'activité pour se déconnecter ou manuellement je devrai lui attribuer une valeur à chaque activité ??? en utilisant la procédure ci-dessus ??
UMAR
5
Oui, vous devez mettre l'ID de session à la disposition de chaque activité pour laquelle vous souhaitez autoriser l'utilisateur à se déconnecter. Alternativement, vous pouvez le stocker dans l'objet Application, mais vous devrez ensuite gérer l'état de la session (vérifiez si elle est valide avant de l'utiliser, etc.).
Erich Douglass
1
Veuillez noter que la documentation indique les points suivants: Ajoutez des données étendues à l'intention. Le nom doit inclure un préfixe de package, par exemple l'application com.android.contacts utiliserait des noms comme "com.android.contacts.ShowAll".
Serguei Fedorov
1
Et pour lire les données d'une autre utilisation d'activitéLong session_ids=getIntent().getExtras().getLong("EXTRA_SESSION_IDS");
Farid
1
Comment transmettre des données setDataet quelle est la différence entre ces deux approches? Quel est le meilleur?
Hosein Aqajani
1402

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.

user914425
la source
58
Juste une info pour ceux qui sont si aveugles comme moi: si vous mettez un entier dans votre activité actuelle, vous devez l'obtenir dans la nouvelle via extras.getInt("new_variable_name"). Si vous essayez de l'obtenir via getString()Android, voyez qu'un int a été donné et renvoie null!
bish
4
que faire si l'activité est déjà en cours, faut-il faire startActivity(i);? Je veux dire, puis-je faire l' activité A appeler l' activité B , et qui renvoie des données à l' activité A ? suis-je confus?
Francisco Corrales Morales
Je préfère la variable chaîne. Vous pouvez toujours convertir une chaîne en entier ou flotter ultérieurement.
user914425
140

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.

Charlie Collins
la source
8
+1 pour le problème statique. le nettoyage peut probablement être résolu en combinant un singleton avec la classe Application de la méthode onCreate / onTerminate.
Syd
10
Hé, je sais que ce fil était il y a longtemps, mais le lien fourni est maintenant une impasse. Y a-t-il un endroit où je peux trouver l'exemple?
JuiCe
Comment y parvenir en utilisant Application? @CharlieCollins
Banee Ishaque K
Voici un exemple mis à jour de cela ici, d'un très vieux livre :) github.com/charlieCollins/android-in-practice/blob/master/ch07/…
Charlie Collins
@JuiCe Le billet de blog des développeurs Android sur les fuites de mémoire n'est plus invalide.
Edric
94

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");
}
Md. Rahman
la source
3
L'intention peut-elle jamais être nulle? Faut-il vérifier qu'elle n'est pas nulle?
Micro
Ceci est un doublon de la réponse la plus votée de 3 ans plus ancienne et de la réponse de Sahil Mahajan Mj et de la réponse de Mayank Saini
Murmel
85

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);
Mayank Saini
la source
3
Veuillez noter que la documentation indique les points suivants: Ajoutez des données étendues à l'intention. Le nom doit inclure un préfixe de package, par exemple l'application com.android.contacts utiliserait des noms comme "com.android.contacts.ShowAll".
Serguei Fedorov
Il s'agit d'un doublon de la réponse la plus votée qui est là depuis 2 ans avant cette réponse et de la réponse de Sahil Mahajan Mj qui a 1 an de plus. Seule différence: des exemples booleanet des longgetters qui valent un commentaire IMO, pas une réponse.
Murmel
48

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

Transmission des données vers l'avant

entrez la description de l'image ici

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

entrez la description de l'image ici

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();
    }
}
Suragch
la source
3
Wow merci! C'était tout à fait ce que je cherchais. Il est assez clair lors de l'utilisation de l'appareil photo ou d'autres externes que je m'attends à des résultats, mais je ne pensais pas l'utiliser en interne. Vous êtes le premier à le dire si ouvertement.
user3195231
45

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.

angryITguy
la source
2
J'aime mieux votre réponse ... La transmettre via l'intention signifie que presque partout où je commence une activité, vous devrez vous rappeler d'inclure le sessionId. En le plaçant dans les SharedPreferences, vous pouvez l'obtenir à tout moment à partir de n'importe quelle activité. : 0)
bytebender
@bytebender Je sais que c'est un peu tard pour la réponse, j'apprécie que vous aimiez ma réponse originale pour sa simplicité, mais je ferais attention de stocker l'identifiant de session dans les préférences partagées. Si vous devez le stocker sur un stockage dur, utilisez le cryptage. Si vous pouvez utiliser un cadre d'authentification qui utilise JWT, il comprendra des rafraîchissements qui sont plus sûrs pour le stockage à long terme, puis conservera le jeton de session actuel en tant que propriété publique d'un objet d'application personnalisé pour accéder facilement aux jetons d'authentification et réduire les frais généraux sur l'activité signatures d'intention.
angryITguy
38

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

ponkin
la source
28

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

Vaibhav Sharma
la source
23

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;

//...
L'ordinateur a dit non
la source
5
Je me demande vraiment pourquoi votre suggestion n'a pas obtenu de votes, c'est plus simple et plus pratique.
Porizm
7
euh ... ça ne viole pas les principes OO?
Christian Vielma
2
@ChristianVielma eh bien, cela ressemble plus à une zone grise ... vous pouvez le faire de plusieurs façons, cela me semble être une "fuite" propre, alors ... c'est à vous (le développeur) de prendre la décision si elle ça marche bien pour vous ou pas, j'aime bien parce que c'est plus facile à suivre, mais ça peut devenir très sale très vite ...
ComputerSaysNo
2
pourquoi dites-vous que cela devient sale? IOS ne fait-il pas cela pour transmettre des données entre les contrôleurs de vue en définissant des "propriétés" similaires à cela? C'est tellement plus facile que d'utiliser des intentions
Terry Bu
2
Oui, vous passez des données entre les contrôleurs de vue, mais pas avec des propriétés statiques . Le problème est que ce n'est pas une propriété sur l'instance d'activité souhaitée. La façon dont Android lance ses activités via startActivity (), il n'instancie pas instantanément l'objet et ne permet pas au développeur de définir une variable d'instance. C'est assez ennuyeux ...
Shawn
20

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");
Sahil Mahajan Mj
la source
2
Ceci est un double de la réponse la plus votée qui existe depuis encore 1 an.
Murmel
19

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

Ravi Parsania
la source
17

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”); 
Ajay Venugopal
la source
1
Dupliquer comme déjà proposé par PRABEESH RK en 2012. Et pourrait être réduit au i.putExtras()/ getIntent().getString()qui est proposé par 6 autres réponses ...
Murmel
17

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");
  }
Gavine Joyce
la source
1
Dupliquer: l' Bundleapproche basée a déjà été proposée par PRABEESH RK en 2012 et Ajay Venugopal , Krishna . Et pourrait être réduit au i.putExtras()/ getIntent().getString()qui est proposé par 8 autres réponses ...
Murmel
11

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.

Krishna
la source
1
Dupliquer: L' Bundleapproche basée a déjà été proposée par PRABEESH RK en 2012 et Ajay Venugopal . Et pourrait être réduit au i.putExtras()/ getIntent().getString()qui est proposé par 7 autres réponses ...
Murmel
11

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);
capt.swag
la source
9
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");
Dilavar Malek
la source
8

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.

THANN Phearum
la source
7

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));
Suragch
la source
7

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();
Sachin
la source
Dupliquer: L'approche l' intention est déjà proposée par le plus haut sommet voté réponse et de la réponse de Sahil Mahajan Mj et de la réponse de Mayank Saini et la réponse de Md Rahman. , La réponse de Dilavar M , la réponse de développeur Android , sahulab . Singleton: Réponse de Rodion Altshuler
Murmel
6

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 .

PRABEESH RK
la source
Cela revient plus ou moins à utiliser directement les méthodes fournies par Intent ( Intent#putExtra()). Mais ajoute un autre Bundleet rend les choses plus compliquées.
Murmel
6

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);
Rohit Gurjar
la source
Duplicate: Cette approche a déjà été proposée par Ravi Parsania en 2014
Murmel
5

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);
DroidNinja
la source
5

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"
}
Khemraj
la source
4
/*
 * 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));
    }
}
Dip Pokhrel
la source
4

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();
        }
    }
}
Qui
la source
4

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

Darius
la source
@BaneeIshaqueK yep désolé, je n'ai pas maintenu cela depuis un moment. Avoir un lien mis à jour pour pointer directement vers le Github pour le projet au cas où cela aiderait. ps. Je ne sais pas ce que je pensais pour cette licence ... excuses
Darius
4

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");
suresh madaparthi
la source
4

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

Lavanya Velusamy
la source
3

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()
Patricia Heimfarth
la source
Demande prioritaire
Murmel