Liste de tous les extras d'une intention
Pour des raisons de débogage, je veux lister 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 est un pour moi, car certaines valeurs sont des chaînes, d'autres des booléens ... Comment pourrais-je obtenir les valeurs dans une boucle (en passant par les clés) 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 = data.getExtras();
if (bundle != null) {
for (String key : bundle.keySet()) {
Object value = bundle.get(key);
Log.d(TAG, String.format("%s %s (%s)", key,
value.toString(), value.getClass().getName()));
}
}
Où data est l'intention. Assurez-vous de vérifier si bundle est nul avant la boucle.
Voici comment je définis une méthode d’utilité 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 génère quelque chose comme:
"#Intent; action = Android.intent.action.MAIN; catégorie = Android.intent.category.LAUNCHER; launchFlags = 0x10a00000; composant = 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 extra dans cet exemple).
Ceci est conforme à la documentation 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 choix est de faire tourner l'ensemble de clés appelant get (String) sur chaque clé et d'utiliser toString () sur l'objet pour les générer. Cela fonctionnera mieux pour les primitives, mais vous pouvez rencontrer des problèmes avec des objets qui n'implémentent pas toString ().
Bundle extras = getIntent().getExtras();
Set<String> ks = extras.keySet();
Iterator<String> iterator = ks.iterator();
while (iterator.hasNext()) {
Log.d("KEY", iterator.next());
}
Je cherchais un moyen de sortir le contenu d'une intention dans le journal et de pouvoir le lire facilement. Voici donc ce que j'ai proposé. J'ai créé une classe LogUtil, puis j'ai pris la méthode dumpIntent() créée par @Pratik et je l'ai légèrement modifiée. Voici à quoi ça 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 ça aide quelqu'un!
Vous pouvez utiliser for (String key : keys) { Object o = get(key); pour renvoyer un objet, appelez getClass().getName() pour obtenir le type, puis effectuez une série de choses de type if name.equals ("String") afin de déterminer la méthode à utiliser. effectivement appeler, afin d'obtenir la valeur?
J'ai remarqué dans la source Android que presque toutes les opérations forcent le Bundle à annuler les données. Donc si (comme moi) vous devez le faire fréquemment à des fins de débogage, le texte ci-dessous est très rapide à taper:
Bundle extras = getIntent().getExtras();
extras.isEmpty(); // unparcel
System.out.println(extras);
La version Kotlin de méthode d'utilité de Pratik qui supprime tous les extras d'un Intent:
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")
}
Désolé si c'est trop bavard ou trop tard, mais c'était le seul moyen que je pouvais trouver pour faire le travail. Le facteur le plus compliqué était le fait que Java ne possède pas de fonction de renvoi par référence. Les méthodes get --- Extra ont donc besoin d'un paramètre par défaut et ne peuvent pas modifier une valeur booléenne pour indiquer si oui ou non la valeur par défaut. est retourné par hasard, ou parce que les résultats n'étaient pas favorables. Dans ce but, il aurait été préférable que la méthode lève une exception plutôt 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
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();
}
Simplement appeler l'intention du paquet:
Bundle bundle = intent.getExtras();
if (bundle != null) {
for (String key : bundle.keySet()) {
Log.e(TAG, key + " : " + (bundle.get(key) != null ? bundle.get(key) : "NULL"));
}
}