एक आशय के सभी अतिरिक्त सूचीबद्ध करना


251

डीबगिंग कारणों से मैं एक इंटेंट के सभी एक्स्ट्रा (और उनके मूल्यों) को सूचीबद्ध करना चाहता हूं। अब, कुंजी प्राप्त करना कोई समस्या नहीं है

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

लेकिन चाबियों के मूल्यों को प्राप्त करना मेरे लिए एक है, क्योंकि कुछ मूल्य तार हैं, कुछ बूलियन हैं ... मैं मूल्यों को लूप में कैसे प्राप्त कर सकता हूं (कुंजी के माध्यम से लूपिंग) और मानों को लॉगफ़ाइल में लिख सकता हूं? किसी भी संकेत के लिए धन्यवाद!

जवाबों:


467

यहाँ मैं एक अनिर्दिष्ट (3-पार्टी) इरादे के बारे में जानकारी प्राप्त करने के लिए इस्तेमाल किया है:

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

जाँच करें कि क्या bundleलूप से पहले अशक्त है।


2
मुझे सिर्फ इंटेंट इंटरसेप्ट एंड्रॉइड ऐप के बारे में पता चला । वह भी काम करता है।
विनायक

1
if (bundle == null) { return; }FTW
मटियास

23
Bundle bundle = data.getExtras();dataइरादा कहां है Android शुरुआती के लिए।
विजेता

2
लॉग करने से पहले आपको यह जांचने की आवश्यकता है कि क्या मूल्य शून्य है, यदि ऐसा है value = "null"
सेबेस्टियन क्रेफ़ट

इसके लिए धन्यवाद! एक सस्ती ब्लूटूथ बटन के माध्यम से मेरे फोन को नियंत्रित करने के लिए, इस अनजाने iTracing ऐप में प्रदान की गई सभी चाबियों की जांच करने का एक तरीका खोज रहा था। एक जादू की तरह काम किया!
शेन स्मिस्कॉल

111

यह है कि मैं एक आशय के सभी अतिरिक्त डंप करने के लिए उपयोगिता पद्धति को कैसे परिभाषित करता हूं।

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

8
धन्यवाद! अब अगर केवल android टीम उपयोगी को लागू करना शुरू कर देगी।
जिम विटेक

37

आप इसे कोड की एक पंक्ति में कर सकते हैं:

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

यह कुछ इस तरह का उत्पादन करता है:

# # एंटेंट; एक्शन = android.intent.action.MAIN; श्रेणी = android.intent.category.LUNCHER; लॉन्चफ्लैग्स = 0x10a00000; घटक = com.mydomain.myapp / .Start.ctivity; sourceBounds = 12% 20870% 20276% 201167; l .profile = 0? अंत "

इस स्ट्रिंग के अंत में (वह हिस्सा जिसे मैंने बोल्ड किया था) आप एक्स्ट्रा की सूची (इस उदाहरण में केवल एक अतिरिक्त) पा सकते हैं।

इस के अनुसार है टूरी प्रलेखन के : "URI में बेस URI के रूप में आशय का डेटा होता है, जिसमें कार्रवाई, श्रेणियों, प्रकार, झंडे, पैकेज, घटक, और एक्स्ट्रा का वर्णन करने वाला एक अतिरिक्त टुकड़ा होता है।"


3
यदि आप केवल डिबग करना चाहते हैं और देखते हैं कि इरादे की सामग्री क्या है, तो यह सबसे अच्छा विकल्प है। बहुत बहुत धन्यवाद
शायरी

यह स्वीकृत उत्तर होना चाहिए। लॉग डिबगिंग के लिए बिल्कुल सही!
एथन अर्नोल्ड

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

8

बंडल का गेट (स्ट्रिंग कुंजी) विधि एक वस्तु देता है। आपकी सबसे अच्छी शर्त प्रत्येक कुंजी पर कॉलिंग सेट (स्ट्रिंग) प्राप्त करना और उन्हें आउटपुट करने के लिए ऑब्जेक्ट पर स्ट्रींग () का उपयोग करना है। यह प्राथमिकताओं के लिए सबसे अच्छा काम करेगा, लेकिन आप उन वस्तुओं के साथ समस्याओं में भाग सकते हैं जो एक स्ट्रींग () को लागू नहीं करते हैं।


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

1
के लिए (स्ट्रिंग कुंजी: extras.keySet ()) {Log.d (LOG_TAG, कुंजी + ":" + extras.get (कुंजी)); }
डेफ्यूरा

4

मैं लॉग करने के लिए एक इरादे की सामग्री का उत्पादन करने के लिए एक तरीका चाहता था, और इसे आसानी से पढ़ने में सक्षम होने के लिए, इसलिए यहां मेरे साथ आया था। मैंने एक LogUtilवर्ग बनाया है , और फिर dumpIntent()@Pratik द्वारा बनाई गई विधि को लिया , और इसे थोड़ा संशोधित किया। यहाँ यह सब कैसा दिखता है:

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

आशा है कि यह किसी की मदद करता है!


2

आप for (String key : keys) { Object o = get(key);किसी ऑब्जेक्ट को वापस करने के लिए उपयोग कर सकते हैं , getClass().getName()टाइप करने के लिए उस पर कॉल कर सकते हैं, और उसके बाद if.equals ("स्ट्रिंग") का एक सेट टाइप करते हैं, जिससे आपको वास्तव में कॉल करने के लिए किस विधि से कॉल करना चाहिए। ?


1

मैंने एंड्रॉइड स्रोत में देखा कि लगभग हर ऑपरेशन बंडल को अपने डेटा को अनसुना करने के लिए मजबूर करता है। इसलिए यदि (मेरे जैसे) आपको डिबगिंग उद्देश्यों के लिए अक्सर ऐसा करने की आवश्यकता है, तो नीचे टाइप करने के लिए बहुत जल्दी है:

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

0

क्षमा करें यदि यह बहुत क्रियात्मक है या बहुत देर हो चुकी है, लेकिन यह एकमात्र तरीका है जिससे मुझे काम मिल सकता है। सबसे जटिल कारक यह तथ्य था कि जावा संदर्भ कार्यों से नहीं गुजरता है, इसलिए प्राप्त करें --- अतिरिक्त तरीकों को वापस करने के लिए एक डिफ़ॉल्ट की आवश्यकता होती है और यह बताने के लिए कि क्या डिफ़ॉल्ट मान संयोग से वापस आ रहा है या नहीं, यह बताने के लिए बूलियन मान को संशोधित नहीं किया जा सकता है, या क्योंकि परिणाम अनुकूल नहीं थे। इस उद्देश्य के लिए, यह एक डिफ़ॉल्ट को वापस करने की तुलना में एक अपवाद को बढ़ाने के लिए विधि के लिए अच्छा होगा।

मैं यहाँ मेरी जानकारी मिली: एंड्रॉयड आशय प्रलेखन

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

आप इस सरल काम को करने के लिए इतना कोड लिखना नहीं चाहते हैं जब तक कि आप अपने कोड को जटिल नहीं करना चाहते हैं जब तक कि आप अपने ऐप को अपडेट करने में सक्षम नहीं हो जाते हैं। टॉप -2 उत्तर बहुत कम कोड के साथ ऐसा करते हैं, और लॉग का उपयोग करते हैं, जो इस तरह के उपयोग के लिए टोस्ट्स से बेहतर है
लुई सीएडी

0

प्रतीक की उपयोगिता विधि का कोटलिन संस्करण, जो एक आशय के सभी एक्स्ट्रास को डंप करता है:

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

}

1
इसका उपयोग करना सरल होगाfor (key in bundle.keySet())
DDoSolitary

-2

यदि आप चाहते हैं सभी डिबगिंग के लिए एक स्ट्रिंग है (ओपी द्वारा निहित लेकिन स्पष्ट रूप से नहीं कहा गया है की तरह), बस toStringअतिरिक्त पर उपयोग करेंBundle :

intent.getExtras().toString()

यह एक स्ट्रिंग लौटाता है जैसे:

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

दस्तावेज़ीकरण: बंडल.टोस्ट्रिंग () (यह दुर्भाग्य से डिफ़ॉल्ट Object.toString()javadoc है और जैसे कि यहां काफी बेकार है।)


4
जब मैंने यह कोशिश की, तो यह लौटा: बंडल [mParcelledData.dataSize = 480]
टोडएच
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.