Android
Intention

Introduction

Syntaxe

• Intention Intention ()
• Intention Intention (intention intentionnelle)
• Intention Intent (Action de chaîne)
• Intention Intent (Action de cordes, Uri uri)
• Intention Intent (Context packageContext, Class <?> Cls)
• Intent Intent (Action de chaîne, Uri uri, Context packageContext, Class <?> Cls)
• void startActivity (Intention intentionnelle)
• void startActivity (Intention intentionnelle, Options de regroupement)
• void startActivityForResult (Intention intent, int requestCode)
• void startActivityForResult (Intention intent, int requestCode, Options du bundle)
• Intention putExtra (nom de la chaîne, valeur double [])
• Intention putExtra (nom de la chaîne, valeur int)
• Intention putExtra (Nom de la chaîne, valeur CharSequence)
• Intention putExtra (nom de la chaîne, valeur du caractère)
• Intention putExtra (Nom de la chaîne, valeur du lot)
• Intention putExtra (Nom de la chaîne, valeur Parcelable [])
• Intention putExtra (nom de la chaîne, valeur sérialisable)
• Intention putExtra (nom de la chaîne, valeur int [])
• Intention putExtra (Nom de la chaîne, valeur flottante)
• Intention putExtra (nom de la chaîne, valeur de l'octet [])
• Intention putExtra (nom de la chaîne, valeur long [])
• Intention putExtra (nom de la chaîne, valeur parcelable)
• Intention putExtra (nom de la chaîne, valeur float [])
• Intention putExtra (Nom de la chaîne, valeur longue)
• Intention putExtra (Nom de la chaîne, valeur String [])
• Intention putExtra (Nom de la chaîne, valeur booléenne)
• Intention putExtra (nom de la chaîne, valeur booléenne [])
• Intention putExtra (Nom de la chaîne, valeur courte)
• Intention putExtra (Nom de la chaîne, valeur double)
• Intention putExtra (nom de la chaîne, valeur courte [])
• Intention putExtra (nom de la chaîne, valeur de la chaîne)
• Intention putExtra (Nom de la chaîne, valeur d'octet)
• Intention putExtra (Nom de la chaîne, valeur char [])
• Intention putExtra (nom de la chaîne, valeur CharSequence [])

Paramètres

Remarques

PackageManager pm = getActivity().getPackageManager();
if (intent.resolveActivity(pm) != null) {
    //intent can be handled
    startActivity(intent);
} else {
     //intent can not be handled
}

Commencer une activité

Cet exemple démarrera DestinationActivity depuis OriginActivity .

Ici, le constructeur Intent prend deux paramètres:

1. Un contexte comme premier paramètre (utilisé car la classe Activity est une sous-classe de Context)
2. La classe du composant de l'application à laquelle le système doit fournir l'intention (dans ce cas, l'activité à démarrer)

public class OriginActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_origin);

        Intent intent = new Intent(this, DestinationActivity.class);
        
        startActivity(intent);
        finish(); // Optionally, you can close OriginActivity. In this way when the user press back from DestinationActivity he/she won't land on OriginActivity again.
    }
}

Une autre façon de créer Intent pour ouvrir DestinationActivity consiste à utiliser le constructeur par défaut pour Intent et à utiliser la méthode setClass() pour lui indiquer quelle activité ouvrir:

Intent i=new Intent();
i.setClass(this, DestinationActivity.class);
startActivity(intent);
finish(); // Optionally, you can close OriginActivity. In this way when the user press back from DestinationActivity he/she won't land on OriginActivity 

Transmission de données entre activités

Cet exemple illustre l'envoi d'une String avec la valeur "Some data!" de OriginActivity à DestinationActivity .

REMARQUE: C'est le moyen le plus simple d'envoyer des données entre deux activités. Voir l'exemple d'utilisation du modèle de démarrage pour une implémentation plus robuste.

OriginActivity

public class OriginActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_origin);
        
        // Create a new Intent object, containing DestinationActivity as target Activity.
        final Intent intent = new Intent(this, DestinationActivity.class);

        // Add data in the form of key/value pairs to the intent object by using putExtra()
        intent.putExtra(DestinationActivity.EXTRA_DATA, "Some data!");

        // Start the target Activity with the intent object
        startActivity(intent);
    }
} 

DestinationActivity

public class DestinationActivity extends AppCompatActivity {

    public static final String EXTRA_DATA = "EXTRA_DATA";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_destination);

        // getIntent() returns the Intent object which was used to start this Activity
        final Intent intent = getIntent();

        // Retrieve the data from the intent object by using the same key that
        // was previously used to add data to the intent object in OriginActivity.
        final String data = intent.getStringExtra(EXTRA_DATA);
    }
}

Il est également possible de passer d' autres primitive types de données, ainsi que arrays , Bundle et Parcelable données. Passer Serializable est également possible, mais devrait être évité car il est plus de trois fois plus lent que Parcelable .

Serializable est une interface Java interface . Vous marquez simplement une classe comme Serializable en implémentant l' interface Serializable et Java le sérialisera automatiquement lors des situations requises.

Parcelable est une interface spécifique à Android qui peut être implémentée sur des types de données personnalisés (c.-à-d. Vos propres objets / objets POJO), elle permet d'aplatir votre objet et de se reconstruire sans que la destination ait besoin de faire quoi que ce soit. Il existe un exemple de documentation permettant de rendre un objet parcelable .

Une fois que vous avez un objet parcelable , vous pouvez l'envoyer comme un type primitif, avec un objet intentionnel:

intent.putExtra(DestinationActivity.EXTRA_DATA, myParcelableObject);

Ou dans un bundle / comme argument pour un fragment:

bundle.putParcelable(DestinationActivity.EXTRA_DATA, myParcelableObject);

puis lisez-le également à l’intention de destination à l’aide de getParcelableExtra:

final MyParcelableType data = intent.getParcelableExtra(EXTRA_DATA); 

Ou lors de la lecture d'un fragment d'un bundle:

final MyParcelableType data = bundle.getParcelable(EXTRA_DATA); 

Une fois que vous avez un objet Serializable , vous pouvez le placer dans un objet intentionnel:

bundle.putSerializable(DestinationActivity.EXTRA_DATA, mySerializableObject);

puis lisez-le également à partir de l'objet intentionnel à la destination, comme indiqué ci-dessous:

final SerializableType data = (SerializableType)bundle.getSerializable(EXTRA_DATA); 

Envoyer des emails

// Compile a Uri with the 'mailto' schema
Intent emailIntent = new Intent(Intent.ACTION_SENDTO, Uri.fromParts(
        "mailto","[email protected]", null));
// Subject
emailIntent.putExtra(Intent.EXTRA_SUBJECT, "Hello World!");
// Body of email
emailIntent.putExtra(Intent.EXTRA_TEXT, "Hi! I am sending you a test email.");
// File attachment
emailIntent.putExtra(Intent.EXTRA_STREAM, attachedFileUri);

// Check if the device has an email client
if (emailIntent.resolveActivity(getPackageManager()) != null) {
     // Prompt the user to select a mail app
     startActivity(Intent.createChooser(emailIntent,"Choose your mail application"));
} else {
    // Inform the user that no email clients are installed or provide an alternative
}

Cela pré-remplira un email dans une application de messagerie du choix de l'utilisateur.

Si vous devez ajouter une pièce jointe, vous pouvez utiliser Intent.ACTION_SEND au lieu de Intent.ACTION_SENDTO . Pour plusieurs pièces jointes, vous pouvez utiliser ACTION_SEND_MULTIPLE

Un mot d'avertissement: tous les périphériques ne disposent pas d'un fournisseur pour ACTION_SENDTO , et l'appel de startActivity() sans vérifier avec resolveActivity() peut d'abord resolveActivity() une ActivityNotFoundException.

Obtenir un résultat d'une autre activité

En utilisant startActivityForResult(Intent intent, int requestCode) vous pouvez démarrer une autre Activity , puis recevoir un résultat de cette Activity dans la onActivityResult(int requestCode, int resultCode, Intent data) . Le résultat sera renvoyé en tant Intent . Une intention peut contenir des données via un ensemble

Dans cet exemple, MainActivity lancera une DetailActivity et attendra un résultat. Chaque type de requête doit avoir son propre code de demande int , de sorte que dans la onActivityResult(int requestCode, int resultCode, Intent data) substituée onActivityResult(int requestCode, int resultCode, Intent data) de MainActivity , il soit possible de déterminer la demande de traitement en comparant les valeurs de requestCode et REQUEST_CODE_EXAMPLE Par exemple, il n'y en a qu'un).

Activité principale:

public class MainActivity extends Activity {

    // Use a unique request code for each use case 
    private static final int REQUEST_CODE_EXAMPLE = 0x9345; 

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // Create a new instance of Intent to start DetailActivity
        final Intent intent = new Intent(this, DetailActivity.class);

        // Start DetailActivity with the request code
        startActivityForResult(intent, REQUEST_CODE_EXAMPLE);
    }

    // onActivityResult only get called 
    // when the other Activity previously started using startActivityForResult
    @Override
    public void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);

        // First we need to check if the requestCode matches the one we used.
        if(requestCode == REQUEST_CODE_EXAMPLE) {

            // The resultCode is set by the DetailActivity
            // By convention RESULT_OK means that whatever
            // DetailActivity did was executed successfully
            if(resultCode == Activity.RESULT_OK) {
                // Get the result from the returned Intent
                final String result = data.getStringExtra(DetailActivity.EXTRA_DATA);

                // Use the data - in this case, display it in a Toast.
                Toast.makeText(this, "Result: " + result, Toast.LENGTH_LONG).show();
            } else {
                // setResult wasn't successfully executed by DetailActivity 
                // Due to some error or flow of control. No data to retrieve.
            }
        }
    }
}

DetailActivity:

public class DetailActivity extends Activity {

    // Constant used to identify data sent between Activities.
    public static final String EXTRA_DATA = "EXTRA_DATA";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_detail);

        final Button button = (Button) findViewById(R.id.button);
        // When this button is clicked we want to return a result
        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                // Create a new Intent object as container for the result
                final Intent data = new Intent();

                // Add the required data to be returned to the MainActivity
                data.putExtra(EXTRA_DATA, "Some interesting data!");
                
                // Set the resultCode as Activity.RESULT_OK to 
                // indicate a success and attach the Intent
                // which contains our result data
                setResult(Activity.RESULT_OK, data); 

                // With finish() we close the DetailActivity to 
                // return back to MainActivity
                finish();
            }
        });
    }

    @Override
    public void onBackPressed() {
        // When the user hits the back button set the resultCode 
        // as Activity.RESULT_CANCELED to indicate a failure
        setResult(Activity.RESULT_CANCELED);
        super.onBackPressed();
    }
}

Quelques points à connaître:

• Les données ne sont renvoyées qu'une fois que vous appelez finish() . Vous devez appeler setResult() avant d'appeler finish() , sinon aucun résultat ne sera renvoyé.

• Assurez-vous que votre Activity n'utilise pas android:launchMode="singleTask" , android:launchMode="singleTask" l' Activity sera exécutée dans une tâche distincte et vous ne recevrez donc aucun résultat. Si votre Activity utilise singleTask comme mode de lancement, elle appellera onActivityResult() immédiatement avec un code de résultat Activity.RESULT_CANCELED .

• Soyez prudent lorsque vous utilisez android:launchMode="singleInstance" . Sur les appareils avant Lollipop (Android 5.0, API niveau 21), les activités ne renverront aucun résultat.

• Vous pouvez utiliser des intentions explicites ou implicites lorsque vous appelez startActivityForResult() . Lorsque vous démarrez l'une de vos activités pour recevoir un résultat, vous devez utiliser une intention explicite pour vous assurer de recevoir le résultat attendu. Une intent explicite est toujours transmise à sa cible, peu importe ce qu'elle contient; le filter n'est pas consulté. Mais une intention implicite est transmise à un composant uniquement si elle peut traverser l'un des filtres du composant.

Ouvrir une URL dans un navigateur

Ouverture avec le navigateur par défaut

Cet exemple montre comment vous pouvez ouvrir une URL par programmation dans le navigateur Web intégré plutôt que dans votre application. Cela permet à votre application d'ouvrir une page Web sans avoir besoin d'inclure la permission INTERNET dans votre fichier manifeste.

public void onBrowseClick(View v) {
    String url = "http://www.google.com";
    Uri uri = Uri.parse(url);
    Intent intent = new Intent(Intent.ACTION_VIEW, uri);
    // Verify that the intent will resolve to an activity
    if (intent.resolveActivity(getPackageManager()) != null) {
        // Here we use an intent without a Chooser unlike the next example
        startActivity(intent);
    } 
}

Demander à l'utilisateur de sélectionner un navigateur

Notez que cet exemple utilise la méthode Intent.createChooser() :

public void onBrowseClick(View v) {
    String url = "http://www.google.com";
    Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(url));
    // Note the Chooser below. If no applications match, 
    // Android displays a system message.So here there is no need for try-catch.
    startActivity(Intent.createChooser(intent, "Browse with"));
   
}

Dans certains cas, l'URL peut commencer par "www" . Si tel est le cas, vous obtiendrez cette exception:

android.content.ActivityNotFoundException : Aucune activité détectée pour gérer l'intention

L'URL doit toujours commencer par "http: //" ou "https: //" . Votre code doit donc le vérifier, comme illustré dans l'extrait de code suivant:

if (!url.startsWith("https://") && !url.startsWith("http://")){
    url = "http://" + url;
}
Intent openUrlIntent = new Intent(Intent.ACTION_VIEW, Uri.parse(url));
if (openUrlIntent.resolveActivity(getPackageManager()) != null) {
    startActivity(openUrlIntent);
} 

Les meilleures pratiques

Vérifiez s'il n'y a pas d'applications sur le périphérique pouvant recevoir l'intention implicite. Sinon, votre application va planter lorsqu'elle appelle startActivity() . Pour vérifier d'abord qu'une application existe pour recevoir l'intention, appelez resolveActivity() sur votre objet Intent. Si le résultat est non nul, il existe au moins une application capable de gérer l'intention et d'appeler startActivity() toute sécurité. Si le résultat est null, vous ne devez pas utiliser l'intention et, si possible, vous devez désactiver la fonctionnalité invoquant l'intention.

Effacement d'une pile d'activités

Parfois, vous voudrez peut-être commencer une nouvelle activité tout en supprimant les activités précédentes de la pile arrière, de sorte que le bouton Précédent ne vous les renvoie pas. Par exemple, vous pouvez lancer une application sur l'activité de connexion pour accéder à l'activité principale de votre application, mais lorsque vous vous déconnectez, vous souhaitez être redirigé vers Login sans avoir à revenir en arrière. Dans un cas comme celui-ci, vous pouvez définir l'indicateur FLAG_ACTIVITY_CLEAR_TOP pour l'intention, ce qui signifie que l'activité en cours d'exécution est déjà en cours dans la tâche en cours (LoginActivity), au lieu de lancer une nouvelle instance de cette activité. il sera fermé et cette intention sera livrée à l’ancienne activité (désormais au-dessus) en tant que nouvelle intention.

Intent intent = new Intent(getApplicationContext(), LoginActivity.class);
intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
startActivity(intent);

Il est également possible d'utiliser les indicateurs FLAG_ACTIVITY_NEW_TASK avec FLAG_ACTIVITY_CLEAR_TASK si vous souhaitez effacer toutes les activités de la pile arrière:

Intent intent = new Intent(getApplicationContext(), LoginActivity.class);
// Closing all the Activities, clear the back stack.
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);
startActivity(intent);

Intention URI

Cet exemple montre comment démarrer intentionnellement à partir du navigateur:

<a href="intent://host.com/path#Intent;package=com.sample.test;scheme=yourscheme;end">Start intent</a>

Cette intention démarre l'application avec le package com.sample.test ou ouvre Google Play avec ce package.

En outre, cette intention peut être lancée avec JavaScript:

var intent = "intent://host.com/path#Intent;package=com.sample.test;scheme=yourscheme;end";
window.location.replace(intent)

En activité, cet hôte et ce chemin peuvent être obtenus à partir des données d'intention:

@Override
public void onCreate(Bundle bundle) {
    super.onCreate(bundle);
    Uri data = getIntent().getData(); // returns host.com/path
}

Syntaxe d'URI d'intention:

HOST/URI-path // Optional host
#Intent;
    package=[string];
    action=[string];
    category=[string];
    component=[string];
    scheme=[string];
end;

Diffusion de messages vers d'autres composants

Les intentions peuvent être utilisées pour diffuser des messages vers d'autres composants de votre application (tels qu'un service d'arrière-plan en cours d'exécution) ou vers l'ensemble du système Android.

Pour envoyer une diffusion dans votre application , utilisez la classe LocalBroadcastManager :

Intent intent = new Intent("com.example.YOUR_ACTION"); // the intent action
intent.putExtra("key", "value"); // data to be passed with your broadcast

LocalBroadcastManager manager = LocalBroadcastManager.getInstance(context);
manager.sendBroadcast(intent);

Pour envoyer une diffusion à des composants extérieurs à votre application, utilisez la méthode sendBroadcast() sur un objet Context .

Intent intent = new Intent("com.example.YOUR_ACTION"); // the intent action
intent.putExtra("key", "value"); // data to be passed with your broadcast

context.sendBroadcast(intent);

Vous trouverez des informations sur la réception des émissions ici: Récepteur de diffusion

CustomTabsIntent pour les onglets personnalisés Chrome

String url = "https://www.google.pl/";
CustomTabsIntent intent = new CustomTabsIntent.Builder()
                    .setStartAnimations(getContext(), R.anim.slide_in_right, R.anim.slide_out_left)
                    .setExitAnimations(getContext(), android.R.anim.slide_in_left, android.R.anim.slide_out_right)
                    .setCloseButtonIcon(BitmapFactory.decodeResource(getResources(), R.drawable.ic_arrow_back_white_24dp))
                    .setToolbarColor(Color.parseColor("#43A047"))
                    .enableUrlBarHiding()
                    .build();
            intent.launchUrl(getActivity(), Uri.parse(url));

compile 'com.android.support:customtabs:24.1.1'

Partage de plusieurs fichiers par intention

La liste de chaînes transmise en tant que paramètre à la méthode share() contient les chemins d'accès de tous les fichiers que vous souhaitez partager.

Il parcourt les chemins, les ajoute à Uri et lance l'activité qui peut accepter des fichiers de ce type.

  public static void share(AppCompatActivity context,List<String> paths) {

        if (paths == null || paths.size() == 0) {
            return;
        }
        ArrayList<Uri> uris = new ArrayList<>();
        Intent intent = new Intent();
        intent.setAction(android.content.Intent.ACTION_SEND_MULTIPLE);
        intent.setType("*/*");
        for (String path : paths) {
                File file = new File(path);
                uris.add(Uri.fromFile(file));
        }
        intent.putParcelableArrayListExtra(Intent.EXTRA_STREAM, uris);
        context.startActivity(intent);
    }

Motif de départ

Ce modèle est une approche plus stricte pour démarrer une Activity . Son objectif est d'améliorer la lisibilité du code tout en réduisant la complexité du code, les coûts de maintenance et le couplage de vos composants.

L'exemple suivant implémente le modèle de démarrage, qui est généralement implémenté en tant que méthode statique sur l' Activity elle-même. Cette méthode statique accepte tous les paramètres requis, construit une Intent valide à partir de ces données, puis démarre l' Activity .

Un Intent est un objet qui fournit une liaison d'exécution entre des composants distincts, tels que deux activités. L'intention représente "l'intention de faire quelque chose" d'une application. Vous pouvez utiliser des intentions pour une grande variété de tâches, mais ici, votre intention commence une autre activité.

public class ExampleActivity extends AppCompatActivity {

    private static final String EXTRA_DATA = "EXTRA_DATA";

    public static void start(Context context, String data) {
        Intent intent = new Intent(context, ExampleActivity.class);
        intent.putExtra(EXTRA_DATA, data);
        context.startActivity(intent);
    }       

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        Intent intent = getIntent();
        if(!intent.getExtras().containsKey(EXTRA_DATA)){
            throw new UnsupportedOperationException("Activity should be started using the static start method");
        }
        String data = intent.getStringExtra(EXTRA_DATA);
    }
}

Ce modèle vous permet également de forcer la transmission de données supplémentaires avec l'intention.

L' ExampleActivity peut alors être démarré comme ceci, où le context est un contexte d'activité:

ExampleActivity.start(context, "Some data!");

Démarrer le service non lié à l'aide d'une intention

Un service est un composant qui s'exécute en arrière-plan (sur le thread d'interface utilisateur) sans interaction directe avec l'utilisateur. Un service non lié vient d'être démarré et n'est lié au cycle de vie d'aucune activité.

Pour démarrer un service, vous pouvez faire comme indiqué dans l'exemple ci-dessous:

// This Intent will be used to start the service
Intent i= new Intent(context, ServiceName.class);
// potentially add data to the intent extras
i.putExtra("KEY1", "Value to be used by the service");
context.startService(i);

Vous pouvez utiliser des extras de l'intention en utilisant un onStartCommand() :

public class MyService extends Service {
    public MyService() {
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId)
    {
        if (intent != null) {
            Bundle extras = intent.getExtras();
            String key1 = extras.getString("KEY1", "");
            if (key1.equals("Value to be used by the service")) {
                //do something
            }
        }
        return START_STICKY;
    }

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

}

Partager l'intention

Partagez des informations simples avec différentes applications.

Intent sendIntent = new Intent();
sendIntent.setAction(Intent.ACTION_SEND);
sendIntent.putExtra(Intent.EXTRA_TEXT, "This is my text to send.");
sendIntent.setType("text/plain");
startActivity(Intent.createChooser(sendIntent, getResources().getText(R.string.send_to)));

Partagez une image avec différentes applications.

Intent shareIntent = new Intent();
shareIntent.setAction(Intent.ACTION_SEND);
shareIntent.putExtra(Intent.EXTRA_STREAM, uriToImage);
shareIntent.setType("image/jpeg");
startActivity(Intent.createChooser(shareIntent, getResources().getText(R.string.send_to)));

Démarrer le numéroteur

Cet exemple montre comment ouvrir un composeur par défaut (une application qui effectue des appels réguliers) avec un numéro de téléphone fourni:

Intent intent = new Intent(Intent.ACTION_DIAL);
intent.setData(Uri.parse("tel:9988776655")); //Replace with valid phone number. Remember to add the tel: prefix, otherwise it will crash.
startActivity(intent);

Résultat de l'exécution du code ci-dessus:

Ouvrir la carte Google avec la latitude et la longitude spécifiées

Vous pouvez transmettre la latitude, la longitude de votre application à Google map en utilisant Intent

String uri = String.format(Locale.ENGLISH, "http://maps.google.com/maps?q=loc:%f,%f", 28.43242324,77.8977673);
Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(uri));
startActivity(intent);

Transmission de données différentes via une intention dans l'activité

1. Passer des données entières:

SenderActivity

Intent myIntent = new Intent(SenderActivity.this, ReceiverActivity.class);
myIntent.putExtra("intVariableName", intValue);
startActivity(myIntent);

ReceiverActivity

Intent mIntent = getIntent();
int intValue = mIntent.getIntExtra("intVariableName", 0); // set 0 as the default value if no value for intVariableName found

2. Passer des données doubles:

SenderActivity

Intent myIntent = new Intent(SenderActivity.this, ReceiverActivity.class);
myIntent.putExtra("doubleVariableName", doubleValue);
startActivity(myIntent);

ReceiverActivity

Intent mIntent = getIntent();
double doubleValue = mIntent.getDoubleExtra("doubleVariableName", 0.00); // set 0.00 as the default value if no value for doubleVariableName found

3. Données de chaîne de transmission:

SenderActivity

Intent myIntent = new Intent(SenderActivity.this, ReceiverActivity.class);
myIntent.putExtra("stringVariableName", stringValue);
startActivity(myIntent);

ReceiverActivity

Intent mIntent = getIntent();
String stringValue = mIntent.getExtras().getString("stringVariableName");

ou

Intent mIntent = getIntent();
String stringValue = mIntent.getStringExtra("stringVariableName");

4. Transmission des données ArrayList:

SenderActivity

Intent myIntent = new Intent(SenderActivity.this, ReceiverActivity.class);
myIntent.putStringArrayListExtra("arrayListVariableName", arrayList);
startActivity(myIntent);

ReceiverActivity

Intent mIntent = getIntent();
arrayList = mIntent.getStringArrayListExtra("arrayListVariableName");

5. Passer des données d'objet:

SenderActivity

Intent myIntent = new Intent(SenderActivity.this, ReceiverActivity.class);
myIntent.putExtra("ObjectVariableName", yourObject);
startActivity(myIntent);

ReceiverActivity

Intent mIntent = getIntent();
yourObj = mIntent.getSerializableExtra("ObjectVariableName");

Remarque: gardez à l'esprit que votre classe personnalisée doit implémenter l'interface Serializable .

6. Transmission des données HashMap <String, String>:

SenderActivity

HashMap <String, String> hashMap;

Intent mIntent = new Intent(SenderActivity.this, ReceiverActivity.class);
mIntent.putExtra("hashMap", hashMap);
startActivity(mIntent);

ReceiverActivity

Intent mIntent = getIntent();    
HashMap<String, String> hashMap = (HashMap<String, String>)
mIntent.getSerializableExtra("hashMap");

7. Transmission de données Bitmap:

SenderActivity

Intent myIntent = new Intent(SenderActivity.this, ReceiverActivity.class);
myIntent.putExtra("image",bitmap);
startActivity(mIntent);

ReceiverActivity

Intent mIntent = getIntent();
Bitmap bitmap = mIntent.getParcelableExtra("image");

Affichage d'un sélecteur de fichier et lecture du résultat

Démarrer une activité de sélecteur de fichiers

public void showFileChooser() {
    Intent intent = new Intent(Intent.ACTION_GET_CONTENT);

    // Update with mime types
    intent.setType("*/*");

    // Update with additional mime types here using a String[]. 
    intent.putExtra(Intent.EXTRA_MIME_TYPES, mimeTypes);

    // Only pick openable and local files. Theoretically we could pull files from google drive
    // or other applications that have networked files, but that's unnecessary for this example.
    intent.addCategory(Intent.CATEGORY_OPENABLE);
    intent.putExtra(Intent.EXTRA_LOCAL_ONLY, true);

    // REQUEST_CODE = <some-integer>
    startActivityForResult(intent, REQUEST_CODE);
}

Lecture du résultat

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    // If the user doesn't pick a file just return
    if (requestCode != REQUEST_CODE || resultCode != RESULT_OK) {
        return;
    }

    // Import the file
    importFile(data.getData());
}

public void importFile(Uri uri) {
    String fileName = getFileName(uri);

    // The temp file could be whatever you want
    File fileCopy = copyToTempFile(uri, File tempFile)

    // Done!
}

/**
 * Obtains the file name for a URI using content resolvers. Taken from the following link
 * https://developer.android.com/training/secure-file-sharing/retrieve-info.html#RetrieveFileInfo
 *
 * @param uri a uri to query
 * @return the file name with no path
 * @throws IllegalArgumentException if the query is null, empty, or the column doesn't exist
 */
private String getFileName(Uri uri) throws IllegalArgumentException {
    // Obtain a cursor with information regarding this uri
    Cursor cursor = getContentResolver().query(uri, null, null, null, null);

    if (cursor.getCount() <= 0) {
        cursor.close();
        throw new IllegalArgumentException("Can't obtain file name, cursor is empty");
    }

    cursor.moveToFirst();

    String fileName = cursor.getString(cursor.getColumnIndexOrThrow(OpenableColumns.DISPLAY_NAME));

    cursor.close();

    return fileName;
}

/**
 * Copies a uri reference to a temporary file
 *
 * @param uri      the uri used as the input stream
 * @param tempFile the file used as an output stream
 * @return the input tempFile for convenience
 * @throws IOException if an error occurs
 */
private File copyToTempFile(Uri uri, File tempFile) throws IOException {
    // Obtain an input stream from the uri
    InputStream inputStream = getContentResolver().openInputStream(uri);

    if (inputStream == null) {
        throw new IOException("Unable to obtain input stream from URI");
    }

    // Copy the stream to the temp file
    FileUtils.copyInputStreamToFile(inputStream, tempFile);

    return tempFile;
}

Passer objet personnalisé entre les activités

Il est également possible de transmettre votre objet personnalisé à d'autres activités en utilisant la classe Bundle .

Il y a deux manières:

• Interface Serializable - pour Java et Android
• Interface Parcelable efficace pour la mémoire, uniquement pour Android (recommandé)

Parcelable

Le traitement parcellaire est beaucoup plus rapide que le traitement sérialisable. Une des raisons à cela est que nous sommes explicites sur le processus de sérialisation au lieu d'utiliser la réflexion pour l'inférer. Il va de soi que le code a été fortement optimisé à cette fin.

public class MyObjects implements Parcelable {
    
    private int age;
    private String name;
    
    private ArrayList<String> address;
    
    public MyObjects(String name, int age, ArrayList<String> address) {
        this.name = name;
        this.age = age;
        this.address = address;
    
    }
    
    public MyObjects(Parcel source) {
        age = source.readInt();
        name = source.readString();
        address = source.createStringArrayList();
    }
    
    @Override
    public int describeContents() {
        return 0;
    }
    
    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeInt(age);
        dest.writeString(name);
        dest.writeStringList(address);
    }
    
    public int getAge() {
        return age;
    }
    
    public String getName() {
        return name;
    }
    
    public ArrayList<String> getAddress() {
        if (!(address == null))
            return address;
        else
            return new ArrayList<String>();
    }
    
    public static final Creator<MyObjects> CREATOR = new Creator<MyObjects>() {
        @Override
        public MyObjects[] newArray(int size) {
            return new MyObjects[size];
        }
    
        @Override
        public MyObjects createFromParcel(Parcel source) {
            return new MyObjects(source);
        }
    };
}

Code d'activité d'envoi

MyObject mObject = new MyObject("name","age","Address array here");

//Passing MyOject 
Intent mIntent = new Intent(FromActivity.this, ToActivity.class);
mIntent.putExtra("UniqueKey", mObject);
startActivity(mIntent);

Recevoir l'objet dans l'activité de destination.

//Getting MyObjects 
Intent mIntent = getIntent();
MyObjects workorder = (MyObjects) mIntent.getParcelable("UniqueKey");

Vous pouvez passer Arraylist d'objet Parceble comme ci-dessous

//Array of MyObjects
ArrayList<MyObject> mUsers;

//Passing MyObject List
Intent mIntent = new Intent(FromActivity.this, ToActivity.class);
mIntent.putParcelableArrayListExtra("UniqueKey", mUsers);
startActivity(mIntent);

//Getting MyObject List
Intent mIntent = getIntent();
ArrayList<MyObjects> mUsers = mIntent.getParcelableArrayList("UniqueKey");

Note: Il existe des plugins Android Studio tels que celui-ci disponibles pour générer du code Parcelable

Sérialisable

Code d'activité d'envoi

Product product = new Product();
Bundle bundle = new Bundle();
bundle.putSerializable("product", product);
Intent cartIntent = new Intent(mContext, ShowCartActivity.class);
cartIntent.putExtras(bundle);
mContext.startActivity(cartIntent);

Recevoir l'objet dans l'activité de destination.

protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    Bundle bundle = this.getIntent().getExtras();
    Product product = null;
    if (bundle != null) {
        product = (Product) bundle.getSerializable("product");
    }

Arraylist d'objet Serializable: identique au passage d'un objet unique

L'objet personnalisé doit implémenter l'interface Serializable .

Obtenir un résultat de l'activité au fragment

Comme pour obtenir un résultat d'une autre activité, vous devez appeler la méthode Fragment startActivityForResult(Intent intent, int requestCode) . Notez que vous ne devez pas appeler getActivity().startActivityForResult() car cela ramènera le résultat à l' Activity parente du Fragment .

La réception du résultat peut être effectuée en utilisant la méthode de Fragment onActivityResult() . Vous devez vous assurer que l'activité parente du fragment remplace également onActivityResult() et appelle sa super implémentation.

Dans l'exemple suivant, ActivityOne contient FragmentOne , qui démarrera ActivityTwo et attend un résultat.

ActivityOne

public class ActivityOne extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_one);
    }

    // You must override this method as the second Activity will always send its results to this Activity and then to the Fragment
    @Override
    public void onActivityResult(int requestCode, int resultCode, Intent data) {
       super.onActivityResult(requestCode, resultCode, data);
    }
}

activity_one.xml

<fragment android:name="com.example.FragmentOne"
    android:id="@+id/fragment_one"
    android:layout_width="match_parent"
    android:layout_height="match_parent" />

FragmentOne

public class FragmentOne extends Fragment {
    public static final int REQUEST_CODE = 11;
    public static final int RESULT_CODE = 12;
    public static final String EXTRA_KEY_TEST = "testKey";

    // Initializing and starting the second Activity
    private void startSecondActivity() {
        Intent intent = new Intent(getActivity(), ActivityTwo.class);
        startActivityForResult(REQUEST_CODE, intent);
    }

    @Override
    public void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        if (requestCode == REQUEST_CODE && resultCode == RESULT_CODE) {
            String testResult = data.getStringExtra(EXTRA_KEY_TEST);
            // TODO: Do something with your extra data
        }
    }
}

ActivityTwo

public class ActivityTwo extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_two);
    }

    private void closeActivity() {
        Intent intent = new Intent();
        intent.putExtra(FragmentOne.EXTRA_KEY_TEST, "Testing passing data back to ActivityOne");
        setResult(FragmentOne.RESULT_CODE, intent); // You can also send result without any data using setResult(int resultCode)
        finish();
    }
}