android - hoy - guerra de siria resumen 2018

Listado de todos los extras de un intento.

Question

Por razones de depuración, quiero enumerar todos los extras (y sus valores) de un intento. Ahora, obtener las llaves no es un problema

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

pero obtener los valores de las claves es uno para mí, porque algunos valores son cadenas, otros son booleanos ... ¿Cómo puedo obtener los valores en un bucle (recorrer las claves) y escribir los valores en un archivo de registro? Gracias por cualquier sugerencia!

Answer 1

Así es como defino el método de utilidad para volcar todos los extras de un intento.

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

Answer 2

El método get (String key) de Bundle devuelve un objeto. Su mejor apuesta es girar sobre el conjunto de claves que recibe (String) en cada clave y usar toString () en el Objeto para generarlas. Esto funcionará mejor para los primitivos, pero puede tener problemas con los objetos que no implementan un toString ().

Answer 3

Esto es lo que usé para obtener información sobre una intención no documentada (de terceros):

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

(Asegúrese de verificar si el bundle es nulo antes del bucle)

Answer 4

Lo siento si esto es demasiado detallado o demasiado tarde, pero esta fue la única manera que pude encontrar para hacer el trabajo. El factor más complicado fue el hecho de que Java no tiene funciones de paso por referencia, por lo que los métodos get --- Extra necesitan un valor predeterminado para devolver y no pueden modificar un valor booleano para saber si el valor predeterminado se devuelve por casualidad. o porque los resultados no fueron favorables. Para este propósito, hubiera sido mejor que el método generara una excepción en lugar de que devolviera un valor predeterminado.

Encontré mi información aquí: Documentación de intención de Android .

    //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

Establecer documentación

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

Answer 5

Noté en la fuente de Android que casi todas las operaciones obligan al Bundle a separar sus datos. Así que si (como yo) necesita hacer esto con frecuencia para fines de depuración, lo siguiente es muy rápido de escribir:

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

Answer 6

Podría usar for (String key : keys) { Object o = get(key); para devolver un objeto, llame a getClass().getName() para obtener el tipo, y luego haga un conjunto de si name.equals ("String") escriba cosas para determinar a qué método debería estar llamando, en orden para obtener el valor?

Answer 7

Puedes hacerlo en una sola línea de código:

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

Produce algo como:

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

Al final de esta cadena (la parte en negrita) puede encontrar la lista de extras (solo una extra en este ejemplo).

Esto está de acuerdo con la documentación de toUri : "El URI contiene los datos del Intent como el URI base, con un fragmento adicional que describe la acción, las categorías, el tipo, las marcas, el paquete, el componente y los extras".

Answer 8

Quería una forma de enviar el contenido de un intento al registro y poder leerlo fácilmente, así que esto es lo que se me ocurrió. He creado una clase LogUtil , y luego tomé el método dumpIntent dumpIntent() que creó @Pratik y lo modifiqué un poco. Así es como se ve todo:

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

¡Espero que esto ayude a alguien!

Answer 9

Si para depurar todo lo que desea es una cadena (algo implícito en el OP pero no explícitamente establecido), simplemente use toString en el Bundle extras:

intent.getExtras().toString()

Devuelve una cadena como:

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

Documentación: Bundle.toString() (desafortunadamente es el Object.toString() javadoc predeterminado y, como tal, bastante inútil aquí).

Answer 10

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

Answer 11

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