it-swarm.com.de

Auflistung aller Extras eines Vorsatzes

Aus Debugging-Gründen möchte ich alle Extras (und deren Werte) eines Intents auflisten. Jetzt ist es kein Problem, die Schlüssel zu bekommen

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

aber die Werte der Schlüssel zu erhalten, ist für mich eine Sache, denn einige Werte sind Zeichenfolgen, andere sind Boolesche Werte ... Wie könnte ich die Werte in einer Schleife erhalten (durch die Schlüssel schleifen) und die Werte in eine Protokolldatei schreiben? Danke für jeden Hinweis!

227
stefan.at.wpf

Folgendes habe ich verwendet, um Informationen zu undokumentierten Absichten (von Drittanbietern) abzurufen:

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

Wobei data die Absicht ist. Vergewissern Sie sich, dass bundle vor der Schleife null ist.

430
kshahar

So definiere ich die Utility-Methode, um alle Extras eines Intents zu sichern.

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

Sie können dies in einer Codezeile tun:

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

Es gibt etwas aus wie:

"#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 "

Am Ende dieser Zeichenfolge (der Teil, den ich fett gedruckt habe) befindet sich die Liste der Extras (in diesem Beispiel nur ein Extra).

Dies ist laut toUri documentation : "Der URI enthält die Daten des Intents als Basis-URI, wobei ein zusätzliches Fragment die Aktion, Kategorien, Typen, Flags, Pakete, Komponenten und Extras beschreibt."

29
Alex Vang
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());
    }
}
12
user123321

Die Methode get (String key) von Bundle gibt ein Objekt zurück. Am besten drehen Sie den Key-Set-Aufruf get (String) für jeden Key und geben ihn mit toString () für das Object aus. Dies funktioniert am besten für Grundelemente, es können jedoch Probleme mit Objekten auftreten, die kein toString () implementieren.

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

Ich wollte einen Weg finden, um den Inhalt einer Absicht in das Protokoll auszugeben und in der Lage zu sein, ihn leicht zu lesen. Deshalb habe ich mir Folgendes ausgedacht. Ich habe eine LogUtil -Klasse erstellt und dann die dumpIntent() -Methode @Pratik erstellt und ein wenig geändert. So sieht alles aus:

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

Hoffe das hilft jemandem!

3
LukeWaggoner

Sie können for (String key : keys) { Object o = get(key); verwenden, um ein Objekt zurückzugeben, getClass().getName() aufrufen, um den Typ abzurufen, und dann eine Reihe von if name.equals ("String") -Typen ausführen, die Sie bearbeiten möchten welche methode solltest du eigentlich aufrufen, um den wert zu bekommen?

2
Ben Williams

In der Quelle Android) ist mir aufgefallen, dass fast jeder Vorgang das Bundle zwingt, seine Daten zu entpacken. Wenn Sie dies (wie ich) häufig zu Debug-Zwecken tun müssen, ist die folgende Eingabe sehr schnell :

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

Die Kotlin-Version von Pratiks Utility-Methode , die alle Extras eines Intents ausgibt:

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

}
0
Brian Keen

Es tut mir leid, wenn dies zu ausführlich oder zu spät ist, aber dies war der einzige Weg, den ich finden konnte, um die Arbeit zu erledigen. Der komplizierteste Faktor war die Tatsache, dass Java nicht über Referenzfunktionen verfügt, daher benötigen die get --- Extra-Methoden einen Standardwert, um zurückzugeben, und können keinen booleschen Wert ändern, um zu bestimmen, ob oder nicht Der Standardwert wird zufällig zurückgegeben, oder weil die Ergebnisse nicht günstig waren. Zu diesem Zweck wäre es besser gewesen, wenn die Methode eine Ausnahme auslöst, als einen Standardwert zurückzugeben.

Ich habe meine Informationen hier gefunden: 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

Dokumentation einstellen

    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();
    }
0
Jackson Kulik

Einfach Bundle Intent aufrufen:

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