Liste de tous les extras d'une intention

Pour des raisons de débogage, je souhaite répertorier tous les extras (et leurs valeurs) d'une intention. Maintenant, obtenir les clés n'est pas un problème

Set<String> keys = intent.getExtras().keySet();

mais obtenir les valeurs des clés en est une pour moi, car certaines valeurs sont des chaînes, d'autres sont booléennes ... Comment pourrais-je obtenir les valeurs dans une boucle (parcourir les clés en boucle) et écrire les valeurs dans un fichier journal? Merci pour tout indice!

Voici ce que j'ai utilisé pour obtenir des informations sur une intention non documentée (tierce partie):

Bundle bundle = intent.getExtras();
if (bundle != null) {
    for (String key : bundle.keySet()) {
        Log.e(TAG, key + " : " + (bundle.get(key) != null ? bundle.get(key) : "NULL"));
    }
}

Assurez-vous de vérifier si bundleest nul avant la boucle.

C'est ainsi que je définis la méthode utilitaire pour vider tous les extras d'une intention.

import java.util.Iterator;
import java.util.Set;
import android.os.Bundle;


public static void dumpIntent(Intent i){

    Bundle bundle = i.getExtras();
    if (bundle != null) {
        Set<String> keys = bundle.keySet();
        Iterator<String> it = keys.iterator();
        Log.e(LOG_TAG,"Dumping Intent start");
        while (it.hasNext()) {
            String key = it.next();
            Log.e(LOG_TAG,"[" + key + "=" + bundle.get(key)+"]");
        }
        Log.e(LOG_TAG,"Dumping Intent end");
    }
}

Vous pouvez le faire en une seule ligne de code:

Log.d("intent URI", intent.toUri(0));

Il produit quelque chose comme:

"#Intent; action = android.intent.action.MAIN; category = android.intent.category.LAUNCHER; launchFlags = 0x10a00000; component = com.mydomain.myapp / .StartActivity; sourceBounds = 12% 20870% 20276% 201167; l .profile = 0; end "

À la fin de cette chaîne (la partie que j'ai mise en gras), vous pouvez trouver la liste des extras (un seul supplémentaire dans cet exemple).

Ceci est conforme à la documentation de toUri : "L'URI contient les données de l'intention en tant qu'URI de base, avec un fragment supplémentaire décrivant l'action, les catégories, le type, les indicateurs, le package, le composant et les extras."

private TextView tv;

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

    tv = new TextView(this);
    tv.setText("Extras: \n\r");

    setContentView(tv);

    StringBuilder str = new StringBuilder();
    Bundle bundle = getIntent().getExtras();
    if (bundle != null) {
        Set<String> keys = bundle.keySet();
        Iterator<String> it = keys.iterator();
        while (it.hasNext()) {
            String key = it.next();
            str.append(key);
            str.append(":");
            str.append(bundle.get(key));
            str.append("\n\r");
        }
        tv.setText(str.toString());
    }
}

La méthode get (String key) de Bundle renvoie un objet. Votre meilleur pari est de faire tourner l'ensemble de clés en appelant get (String) sur chaque clé et en utilisant toString () sur l'objet pour les sortir. Cela fonctionnera mieux pour les primitives, mais vous pouvez rencontrer des problèmes avec des objets qui n'implémentent pas de toString ().

Bundle extras = getIntent().getExtras();
Set<String> ks = extras.keySet();
Iterator<String> iterator = ks.iterator();
while (iterator.hasNext()) {
    Log.d("KEY", iterator.next());
}

Je voulais un moyen de sortir le contenu d'une intention dans le journal et de pouvoir le lire facilement, alors voici ce que j'ai trouvé. J'ai créé une LogUtilclasse, puis dumpIntent()j'ai pris la méthode créée par @Pratik et l'ai légèrement modifiée. Voici à quoi tout cela ressemble:

public class LogUtil {

    private static final String TAG = "IntentDump";

    public static void dumpIntent(Intent i){
        Bundle bundle = i.getExtras();
        if (bundle != null) {
            Set<String> keys = bundle.keySet();

            StringBuilder stringBuilder = new StringBuilder();
            stringBuilder.append("IntentDump \n\r");
            stringBuilder.append("-------------------------------------------------------------\n\r");

            for (String key : keys) {
                stringBuilder.append(key).append("=").append(bundle.get(key)).append("\n\r");
            }

            stringBuilder.append("-------------------------------------------------------------\n\r");
            Log.i(TAG, stringBuilder.toString());
        }
    }
}

J'espère que cela aide quelqu'un!

Vous pouvez utiliser for (String key : keys) { Object o = get(key);pour renvoyer un objet, l'appeler getClass().getName()pour obtenir le type, puis faire un ensemble de choses de type if name.equals ("String") pour déterminer la méthode que vous devez réellement appeler, afin d'obtenir la valeur ?

J'ai remarqué dans la source Android que presque toutes les opérations obligent le Bundle à décompresser ses données. Donc, si (comme moi) vous devez le faire fréquemment à des fins de débogage, la saisie ci-dessous est très rapide:

Bundle extras = getIntent().getExtras();
extras.isEmpty(); // unparcel
System.out.println(extras);

Désolé si c'est trop verbeux ou trop tard, mais c'était le seul moyen que j'ai pu trouver pour faire le travail. Le facteur le plus compliqué était le fait que java ne dispose pas de fonctions de passage par référence, donc les méthodes get --- Extra ont besoin d'une valeur par défaut pour retourner et ne peuvent pas modifier une valeur booléenne pour dire si la valeur par défaut est retournée par hasard, ou parce que les résultats n'étaient pas favorables. À cette fin, il aurait été plus agréable que la méthode lève une exception que de renvoyer une valeur par défaut.

J'ai trouvé mes informations ici: Android Intent Documentation .

    //substitute your own intent here
    Intent intent = new Intent();
    intent.putExtra("first", "hello");
    intent.putExtra("second", 1);
    intent.putExtra("third", true);
    intent.putExtra("fourth", 1.01);
    // convert the set to a string array

Définir la documentation

    String[] anArray = {};
    Set<String> extras1 = (Set<String>) intent.getExtras().keySet();
    String[] extras = (String[]) extras1.toArray(anArray);
    // an arraylist to hold all of the strings
    // rather than putting strings in here, you could display them
    ArrayList<String> endResult = new ArrayList<String>();
    for (int i=0; i<extras.length; i++) {
        //try using as a String
        String aString = intent.getStringExtra(extras[i]);
        // is a string, because the default return value for a non-string is null
        if (aString != null) {
            endResult.add(extras[i] + " : " + aString);
        }
        // not a string
        else {
            // try the next data type, int
            int anInt = intent.getIntExtra(extras[i], 0);
            // is the default value signifying that either it is not an int or that it happens to be 0 
            if (anInt == 0) {
                // is an int value that happens to be 0, the same as the default value
                if (intent.getIntExtra(extras[i], 1) != 1) {
                    endResult.add(extras[i] + " : " + Integer.toString(anInt));
                }
                // not an int value
                // try double (also works for float)
                else {
                    double aDouble = intent.getDoubleExtra(extras[i], 0.0);
                    // is the same as the default value, but does not necessarily mean that it is not double
                    if (aDouble == 0.0) {
                        // just happens that it was 0.0 and is a double
                        if (intent.getDoubleExtra(extras[i], 1.0) != 1.0) {
                            endResult.add(extras[i] + " : " + Double.toString(aDouble));
                        }
                        // keep looking...
                        else {
                            // lastly check for boolean
                            boolean aBool = intent.getBooleanExtra(extras[i], false);
                            // same as default, but not necessarily not a bool (still could be a bool)
                            if (aBool == false) {
                                // it is a bool!
                                if (intent.getBooleanExtra(extras[i], true) != true) {
                                    endResult.add(extras[i] + " : " + Boolean.toString(aBool));
                                }
                                else {
                                    //well, the road ends here unless you want to add some more data types
                                }
                            }
                            // it is a bool
                            else {
                                endResult.add(extras[i] + " : " + Boolean.toString(aBool));
                            }
                        }
                    }
                    // is a double
                    else {
                        endResult.add(extras[i] + " : " + Double.toString(aDouble));
                    }
                }
            }
            // is an int value
            else {
                endResult.add(extras[i] + " : " + Integer.toString(anInt));
            }
        }
    }
    // to display at the end
    for (int i=0; i<endResult.size(); i++) {
        Toast.makeText(this, endResult.get(i), Toast.LENGTH_SHORT).show();
    }

La version Kotlin de la méthode utilitaire de Pratik qui vide tous les extras d'une intention:

fun dumpIntent(intent: Intent) {

    val bundle: Bundle = intent.extras ?: return

    val keys = bundle.keySet()
    val it = keys.iterator()

    Log.d(TAG, "Dumping intent start")

    while (it.hasNext()) {
        val key = it.next()
        Log.d(TAG,"[" + key + "=" + bundle.get(key)+"]");
    }

    Log.d(TAG, "Dumping intent finish")

}

Si pour déboguer tout ce que vous voulez est une chaîne (en quelque sorte implicite par l'OP mais non explicitement indiquée), utilisez simplement toStringsur les extras Bundle:

intent.getExtras().toString()

Il renvoie une chaîne telle que:

Bundle[{key1=value1, key2=value2, key3=value3}]

Documentation: Bundle.toString () (c'est malheureusement le Object.toString()javadoc par défaut et en tant que tel tout à fait inutile ici.)