Explicación detallada de métodos de transmisión de parámetros complejos entre intents de Android

Este artículo describe en detalle los métodos de transmisión de parámetros complejos entre Intents de Android. Compartimoslo con todos para su referencia, como se muestra a continuación:

Intent es el medio de transmisión de parámetros entre Activity y Activity, entre Activity y Service, y ambos generalmente implementan la transmisión de tipos de objetos básicos de Java y String.
En proyectos reales, cuando se transmiten valores entre páginas, además de las anteriores, a menudo hay necesidades de transmitir objetos Object, tipos de List, List<Object> y variables globales, etc. Este artículo explica cómo transmitir estos tipos de parámetros.

1. Transferir List<String> y List<Integer>

A continuación se muestra un ejemplo para enviar List<String>, la sintaxis para enviar List<String> es:

intent.putStringArrayListExtra(key, list);

La sintaxis para recibir List<String> es:

list = (ArrayList<String>)getIntent().getStringArrayListExtra(key);

A continuación se muestra un ejemplo de uso:

// =============Send List<String>=============
ArrayList<String> stringList = new ArrayList<String>();
stringList.add("string",1");
stringList.add("string",2");
stringList.add("string",3");
Intent intent = new Intent();
intent.setClass(ListDemoActivity.this, StringListActivity.class);
intent.putStringArrayListExtra("ListString", stringList);
startActivity(intent);
// ====================Receive List<String>======================
ArrayList<String> stringList = (ArrayList<String>) getIntent().getStringArrayListExtra("ListString");

Se puede realizar la operación similar a List<Integer> utilizando el siguiente método:

intent.putIntegerArrayListExtra(key, list);
list = (ArrayList<Integer>) getIntent().getIntegerArrayListExtra(key);

II. Uso de los métodos Serializable y Parcelable para pasar Object

Hay dos métodos para pasar objetos entre Intents en Android: uno es Bundle.putSerializable(Key, Object); y el otro es Bundle.putParcelable(Key, Object). El objeto Object debe cumplir con ciertas condiciones, el primero debe implementar la interfaz Serializable, y el segundo debe implementar la interfaz Parcelable.

A continuación se muestra la clase User que implementa la interfaz Serializable, denominada SerializableUser exclusivamente para facilitar la distinción de la clase User que implementa la interfaz Parcelable, no se recomienda hacer esto en el desarrollo real:

public class SerializableUser implements Serializable {
  private String userName;
  private String password;
  public SerializableUser() {
  }
  public SerializableUser(String userName, String password) {
    this.userName = userName;
    this.password = password;
  }
  public String getUserName() {
    return userName;
  }
  public void setUserName(String userName) {
    this.userName = userName;
  }
  public String getPassword() {
    return password;
  }
  public void setPassword(String password) {
    this.password = password;
  }
}

A continuación se muestra la clase User que implementa la interfaz Parcelable:

public class ParcelableUser implements Parcelable {
  private String userName;
  private String password;
  public ParcelableUser() {
  }
  public ParcelableUser(String userName, String password) {
    this.userName = userName;
    this.password = password;
  }
  public String getUserName() {
    return userName;
  }
  public void setUserName(String userName) {
    this.userName = userName;
  }
  public String getPassword() {
    return password;
  }
  public void setPassword(String password) {
    this.password = password;
  }
  public static final Parcelable.Creator<ParcelableUser> CREATOR = new Creator<ParcelableUser>() {
    @Override
    public ParcelableUser createFromParcel(Parcel source) {
      ParcelableUser parcelableUser = new ParcelableUser();
      parcelableUser.userName = source.readString();
      parcelableUser.password = source.readString();
      return parcelableUser;
    }
    @Override
    public ParcelableUser[] newArray(int size) {
      return new ParcelableUser[size];
    }
  };
  @Override
  public int describeContents() {
    // 待办 Auto-生成的方法存根
    return 0;
  }
  @Override
  public void writeToParcel(Parcel dest, int flags) {
    // 待办 Auto-生成的方法存根
    dest.writeString(userName);
    dest.writeString(password);
  }
}

使用两种方式传递其语法分别为：

bundle.putSerializable(key,object);
bundle.putParcelable(key,object);

使用两种方式接收其语法分别为：

object=(Object) getIntent().getSerializableExtra(key);
object = (Object) getIntent().getParcelableExtra(key);

// ==========Uso respectivo de Serializable y Parcelable para enviar Object===============
SerializableUser serializableUser = new SerializableUser("user1", "123456");
ParcelableUser parcelableUser = new ParcelableUser("user2"654321");
Intent intent = new Intent();
Bundle bundle = new Bundle();
bundle.putSerializable("serializableUser", serializableUser);
bundle.putParcelable("parcelableUser", parcelableUser);
intent.setClass(ListDemoActivity.this, ObjectActivity.class);
intent.putExtras(bundle);
startActivity(intent);
// ====================Recepción de Object======================
SerializableUser serializableUser = (SerializableUser) getIntent().getSerializableExtra("serializableUser");
ParcelableUser parcelableUser = (ParcelableUser) getIntent().getParcelableExtra("parcelableUser");

Algunas personas pueden notar que implementar la interfaz Serializable es equivalente a serializar el objeto y luego transmitirlo, lo que no tiene una diferencia significativa con la programación común en Java, y el usuario no necesita realizar cambios significativos, lo que es bastante simple. También recomiendo usar este método.

Sin embargo, la implementación de la interfaz Parcelable de la clase mencionada anteriormente es más compleja. ¿Qué es Parcelable?

Android proporciona un nuevo tipo: Parcel, que se utiliza como contenedor de datos para encapsular, y los datos encapsulados pueden ser transmitidos a través de Intent o IPC. Además de los tipos básicos, solo las clases que implementan la interfaz Parcelable pueden ser colocadas en Parcel.

Implementar Parcelable requiere implementar tres métodos:

1El método writeToParcel. Este método escribe los datos de la clase en el Parcel proporcionado externamente.
Declaración: writeToParcel(Parcel dest, int flags).

2La método describeContents. Simplemente devuelva 0.

3La interfaz Parcelable.Creator<T> estática, esta interfaz tiene dos métodos:

createFromParcel(Parcel in) implementa la función de crear una instancia de la clase desde in.
newArray(int size) crea un array de tipo T con una longitud de size, return new T[size]; es suficiente. Este método es para que las clases externas deserialicen los arrays de esta clase.

A través de la salida de prueba de log, podemos ver el estado de ejecución del programa. Cuando se llama a bundle.putParcelable("parcelableUser", parcelableUser);, se llama al método public void writeToParcel(Parcel dest, int flags) de la clase ParcelableUser, y se escriben datos en dest. Cuando ParcelableUser parcelableUser = (ParcelableUser) getIntent().getParcelableExtra("parcelableUser");, se llama al método public ParcelableUser createFromParcel(Parcel source) de la clase ParcelableUser, se crea un objeto ParcelableUser, se asignan valores a las propiedades de este objeto, y aquí Parcel source y Parcel dest son los mismos, luego se devuelve el objeto ParcelableUser. Finalmente, se puede imprimir la información de las propiedades de parcelableUser.

Tercero, transmitir List<Object>

Si queremos transmitir una lista compuesta por Object, es decir, List<Object>, ¿qué debemos hacer? Primero, necesitamos que el objeto Object implemente la interfaz Serializable, luego convertir la lista a tipo Serializable mediante casting, y finalmente, a través de:

Intent.putExtra(key, (Serializable)objectList);

Este tipo de sintaxis se utiliza para transmitir, y el destinatario también necesita realizar la conversión de tipo forzada a List<Object> en el momento de la recepción, la sintaxis para usar List<Object> es: }}

objectList= (List<Object>) getIntent().getSerializableExtra(key);

A continuación, se muestra un ejemplo de aplicación, aquí se utiliza la clase SerializableUser que se proporcionó en el paso anterior, por lo que no se repetirá aquí.

// ==============Envío de List<Object>===========
SerializableUser user1 = new SerializableUser("user1", "123456");
SerializableUser user2 = new SerializableUser("user2", "654321");
List<SerializableUser> objectList = new ArrayList<SerializableUser>();
objectList.add(user1);
objectList.add(user2);
Intent intent = new Intent();
intent.setClass(ListDemoActivity.this, ObjectListActivity.class);
intent.putExtra("ListObject", (Serializable) objectList);
startActivity(intent);
// ====================Recepción de List<Object>======================
List<SerializableUser> objectList = (List<SerializableUser>) getIntent().getSerializableExtra("ListObject");

Cuatro, variables globales

Si algunos parámetros de nivel de aplicación especiales no son convenientes para pasar parámetros mediante intent, ¿no se nos ocurre que podemos usar variables globales o variables estáticas? Las variables estáticas en Java son adecuadas aquí, pero su valor se pierde después de que la Activity llama a System.exit(0) o finish().

En android, hay una manera más elegante de usar ApplicationContext. Este método de variable global es más seguro que las clases estáticas, y solo se liberará después de que todas las Activity del aplicación hayan sido destruidas.

El SDK de Android menciona que Application se utiliza para almacenar variables globales y existe desde el momento de la creación del paquete. Por lo tanto, cuando necesitemos crear variables globales, no es necesario hacerlo de la misma manera que J2SE necesitaría crear variables estáticas con permisos públicos, mientras que directamente se implementan en application. Basta con llamar al método getApplicationContext de Context o getApplication de Activity para obtener un objeto Application y así establecer o leer los valores de las variables globales.

Al iniciar la aplicación Application, el sistema crea un PID, es decir, el ID de proceso, todas las Activity se ejecutarán en este proceso. Entonces, inicializamos las variables globales en el momento de la creación de Application, todas las Activity de la misma aplicación pueden obtener estos valores de las variables globales. En otras palabras, si cambiamos estos valores de las variables globales en alguna Activity, estos valores cambiarán en otras Activity de la misma aplicación.

Uso:

1. Crear una subclase de android.app.Application propia, para aumentar métodos setter y getter para las variables globales privadas que desee compartir.

public class MyApp extends Application{
  private String globalVariable;
  public String getGlobalVariable() {
    return globalVariable;
  }
  public void setGlobalVariable(String globalVariable) {
    this.globalVariable = globalVariable;
  }
}

2. Declarar esta clase en el manifiesto, en este momento Android crea una instancia global disponible.

En realidad, se trata de asignar un nombre a esta instancia global al etiqueta application existente.

<application android:name=".MyApp" android:icon="@drawable/icon" android:label="@string/app_name">

3. Se puede usar el método Context.getApplicationContext() en cualquier lugar para obtener esta instancia y, a su vez, obtener su estado (variables).

// ============Utilizar variables globales para pasar parámetros==============
MyApp myApp = ((MyApp) getApplicationContext());//Obtenga nuestra aplicación MyApp
myApp.setGlobalVariable("Variable global");
Intent intent = new Intent();
intent.setClass(ListDemoActivity.this, GlobalActivity.class);
startActivity(intent);
// ============ Parámetros de recepción de variables globales ============
MyApp myApp = ((MyApp) getApplicationContext());
String globalVariable = myApp.getGlobalVariable();

Los lectores interesados en más contenido relacionado con Android pueden ver la sección especial de este sitio: 'Tutorial de introducción y avanzado de desarrollo de Android', 'Resumen de técnicas de operación de activity en programación de Android', 'Resumen de técnicas de operación de recursos en Android', 'Resumen de técnicas de operación de archivos en Android', 'Resumen de técnicas de operación de bases de datos SQLite en Android', 'Resumen de técnicas de operación de datos en formato JSON en Android', 'Resumen de técnicas de operación de bases de datos en Android', 'Resumen de técnicas de operación de tarjeta SD en desarrollo de Android', 'Resumen de técnicas de vista View en Android' y 'Resumen de técnicas de uso de controles en Android'.

Espero que lo descrito en este artículo sea útil para la programación de aplicaciones Android.

Declaración: El contenido de este artículo se obtiene de la red, es propiedad del autor original, el contenido se contribuye y carga de manera autónoma por los usuarios de Internet, este sitio no posee los derechos de propiedad, no se ha procesado editorialmente por humanos y no asume responsabilidades legales relacionadas. Si encuentra contenido sospechoso de copyright, por favor envíe un correo electrónico a: notice#oldtoolbag.com (al enviar un correo electrónico, reemplace # con @) para denunciar y proporcionar evidencia relevante. Una vez verificada, este sitio eliminará inmediatamente el contenido sospechoso de infracción.