quoi - passer d'une activity à une autre android studio




Comment transmettre des données entre des activités dans une application Android? (20)

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

Le processus 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'intention. Ceci est généralement bien lorsqu'il est utilisé uniquement dans votre application. Cependant, la documentation recommande d' utiliser les constantes EXTRA_* pour les types de données normalisés.

Exemple 1: Utilisation des clés 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 Intent.EXTRA_* ne vous convient pas, vous pouvez définir la vôtre au début de la première activité.

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

Y compris le nom du paquet est juste une convention si vous utilisez seulement 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));

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

En cliquant sur la déconnexion, je passerai l' session id de session id de l'utilisateur connecté pour la déconnexion. Quelqu'un peut-il me guider sur la façon de garder l' session id disponible pour toutes les activities ?

Toute alternative à ce cas


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

Transmission de données en aval

Activité principale

  • Placez les données que vous souhaitez envoyer dans un 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 l' Intent qui a démarré la deuxième activité. Vous pouvez ensuite 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);
    }
}

Passage des 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 reçues de l' Intent retour. 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 l' Intent.EXTRA_TEXT prédéfini depuis que Intent.EXTRA_TEXT 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 une Intent . Les données sont stockées dans l' Intent utilisant 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'intention 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();
    }
}

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

Dans votre activité actuelle, 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.


Essayez de faire ce qui suit:

Créez une classe "helper" 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 devriez juste le dire comme ceci:

IntentHelper.createYourSpecialIntent(getIntent());

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

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

Et envoyer cette intention. Dans l'activité cible, votre champ sera disponible comme:

getIntent().getStringExtra("YOUR_FIELD_NAME");

Alors maintenant, nous pouvons utiliser l'intention comme la même vieille session (comme dans les servlets ou JSP ).


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

VaporSharedPreferences est implémenté comme Singleton, ce qui est une option, et dans Vapor API il a une méthode .put(...) fortement surchargée, donc vous n'avez pas à vous inquiéter explicitement du type de données que vous êtes en .put(...) - à condition qu'il soit supporté. Il est également fluide, de sorte que vous pouvez enchaîner les appels:

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

Il permet également de modifier automatiquement les processus, et unifie le processus de lecture et d'écriture sous le capot de sorte que vous n'avez pas besoin de récupérer explicitement un éditeur comme vous le faites dans Android standard.

Vous pouvez également utiliser une Intent . Dans l'API Vapor, vous pouvez également utiliser la méthode .put(...) surchargée sur un 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 de votre Activity , et de plus, si vous utilisez VaporActivity ceci est fait automatiquement pour vous, vous pouvez donc utiliser:

this.extras()

Pour les récupérer à l'autre extrémité de l' Activity passez à.

J'espère que c'est intéressant pour certains :)


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érer vos données de l'ensemble:

Obtenez le bundle

Bundle bundle = getIntent().getExtras();

Extrayez les données ...

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

La méthode la plus simple consiste à transmettre l'identifiant de session à l'activité de déconnexion dans l' 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éder à cette intention sur l'activité suivante

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

Les docs pour Intents a plus d'informations (voir la section intitulée "Extras").


Le passage des données entre les activités s'effectue principalement au moyen d'un objet d'intention.

Vous devez d'abord attacher les données à l'objet d'intention en utilisant la classe Bundle . Puis appelez l'activité en utilisant les startActivity() ou startActivityForResult() .

Vous pouvez trouver plus d'informations à ce sujet, avec un exemple de l'article de blog Passer des données à une activité .


Passant Intent extras est une bonne approche comme Erich noté.

L'objet Application est cependant un autre moyen, et il est parfois plus facile de traiter le même état sur plusieurs activités (par opposition à devoir le placer / placer 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 là-bas et y accéder depuis n'importe quelle activité (dans la même application) avec getApplication() .

Gardez également à l'esprit que d'autres approches, comme la statique, peuvent être problématiques car elles peuvent entraîner des fuites de mémoire . L'application aide à résoudre cela aussi.


Voici ma meilleure pratique et cela aide beaucoup quand 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 .

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 un petit projet, cela ne devrait pas être le gros problème. Mais quand vous travaillez sur un gros projet, ça fait vraiment mal quand vous voulez faire du refactoring ou corriger des bugs.


Vous avez juste à 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 méthode OnCreate de votre SecondActivity vous pouvez SecondActivity les extras comme ceci.

Si la valeur que vous avez envoyée était 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 une 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);

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

À l'intérieur de 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 de regroupement pour obtenir les valeurs transmises par FirstActivity by Key.

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


Vous pouvez essayer la préférence partagée, il 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);

Si vous voulez transférer un bitmap entre des activites / fragments

Activité

Pour passer un bitmap entre des 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 un bitmap entre les fragments

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

Recevoir à l'intérieur du Second Fragment

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

Transfert de grandes bitmaps

Si vous obtenez une transaction de reliure défectueuse, cela signifie que vous dépassez le tampon de transaction de reliure 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'un octet, 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 deuxième activité

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

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

If you use kotlin:

In MainActivity1:

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

In MainActivity2:

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

There are multiple ways to pass data between activities, and the documentation has many of them.

For most cases, Intent.putExtras is enough.


You can use Intent

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

Another way you can use singleton pattern also:

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

}

From your FirstActivity

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

On SecondActivity

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

/*
 * If you are from transferring data from one class that doesn't
 * extend Activity, then you need to do something like this.
 */ 

public class abc {
    Context context;

    public abc(Context context) {
        this.context = context;
    }

    public void something() {
        context.startactivity(new Intent(context, anyone.class).putextra("key", value));
    }
}






android-activity