¿Existe un método de escucha para múltiples objetos en Android, al igual que el patrón de observador?
Modo oyente y modo observador en Android
1. Modo observador y mecanismo de oyente
1.1 Modo observador
1.2 Mecanismo de escucha
Marco básico del código:
* se monitorea
paquete com.wonders
importación. java.util.Collection;
clase pública ModelTie {
Colección privada; conjunto de datos;
interfaz pública DataSetSupervioer {
pública; void onChange();
}
DataSetSupervioer privado dataSetChangeListener;
público void setDataSetChangeListener(DataSetSupervioer
dataSetChangeListener) {
this.dataSetChangeListener = dataSetChangeListener;
}
public void notifyDataSetChange() {
if (null != dataSetChangeListener) {
dataSetChangeListener.onChange();
}
}
public Objectgt; getDataSet() {
return dataSet;
}
ModelTie público setDataSet(Collectionlt; Objectgt; dataSet)
{
this.dataSet = dataSet;
this.notifyDataSetChange(); // Después de configurar los datos, se debe notificar al oyente para la operación de actualización
return this;
}
}
* Monitor
paquete com.wonders.group;
importar java.util.Collection;
importar java.util. Iterador;
importar com.wonders.group.ModelTie.DataSetSupervioer;
clase pública PresentationTie {
modelo ModelTie privado;
público Corbata de presentación() {<
/p>
super();
//Agregar oyente
model.setDataSetChangeListener(new DataSetSupervioer()
{
public void onChange() {
// Complete algunas operaciones previas, como actualizar datos
DisplayModel() // Redibujar
// Complete algunas operaciones posteriores, como el estado de actualización
}
});
}
public void DisplayModel() {
p>
Collectionlt; colección =
model.getDataSet()
if (colección != null) {
for (Iterator iterador = collection.iterator();
iterator.hasNext();) {
System.out.println(((Objeto)
iterator.next( )).toString());
// Otras operaciones
}
}
}
modelTie público getModel() {
modelo de retorno
}
setModel vacío público (modelo ModelTie) {
this. model = model;
}
}
2.
Mecanismo de implementación del observador de ArrayAdapter
Solo se enumeran los siguientes códigos clave:
clase pública ArrayAdapterlt; extiende BaseAdapter implementa Filtrable
{
privado booleano mNotifyOnChange = true
p>/**
* Agrega el objeto especificado al final de la matriz.
*/
public void add(T objeto) {
if (mOriginalValues != null) {
sincronizado (mLock) {
mOriginalValues.add(object);
if (mNotifyOnChange) notifyDataSetChanged();
}
} else {
mObjects.add(object);
if (mNotifyOnChange ) notifyDataSetChanged();
}
}
/**
* Inserta el objeto especificado en el índice especificado en el
matriz.
*/
inserción nula pública (objeto T, índice int) {
if (mOriginalValues != null ) {
sincronizado (mLock) {
mOriginalValues.add(índice, objeto);
if (mNotifyOnChange) notifyDataSetChanged(); p> }
} else {
mObjects.add(index, object);
if (mNotifyOnChange) notifyDataSetChanged(); > }
}
/**
* Elimina el objeto especificado de la matriz.
*/
eliminar vacío público (objeto T) {
if (mOriginalValues != null) {
sincronizado (mLock) {
mOriginalValues.remove( objeto);
}
} else {
mObjects.remove(objeto
}
if (mNotifyOnChange) notifyDataSetChanged();
}
/**
* Eliminar todos los elementos de la lista.
*/
public void clear() {
if (mOriginalValues != null) {
sincronizado (mLock) {
mOriginalValues.clear();
}
} más {
mObjects.clear(); > }
if (mNotifyOnChange) notifyDataSetChanged();
}
/**
* Ordena el contenido de este adaptador usando el
comparador especificado.
*/
public void sort(Comparatorlt;? super Tgt; comparador) {
Collections.sort (mObjects, comparador);
if (mNotifyOnChange) notifyDataSetChanged();
}
@Override
public void notifyDataSetChanged(); {
super.notifyDataSetChanged(); //
Código clave, este notifyDataSetChanged() se hereda de la clase principal BaseAdapter, así que eche un vistazo a lo que hace en la clase principal. What
mNotifyOnChange = true;
}
}
/**
* Clase base común de implementación común para un {@link
Adaptador} que se puede
* utilizar tanto en {@link ListView} (mediante la implementación del
especializado
* interfaz {@link ListAdapter}} y {@link Spinner} (
implementando la
* interfaz especializada {@link SpinnerAdapter}.
*/
clase abstracta pública BaseAdapter implementa ListAdapter,
SpinnerAdapter {
DataSetObservable final privado mDataSetObservable = nuevo
DataSetObservable() ;
public void RegisterDataSetObserver(observador de DataSetObserver)
{
Este par de métodos se utiliza para registrar o cancelar el registro
Observar al observador de ArrayAdapter
mDataSetObservable.registerObserver(observador);
}
public void unregisterDataSetObserver(DataSetObserver
observador) {
mDataSetObservable.unregisterObserver(observador) ;
}
/**
* Notifica a la vista adjunta que los datos subyacentes
han sido cambiados
* y debería actualizarse solo.
*/
public void notifyDataSetChanged() {
mDataSetObservable.notifyChanged() //
Código clave: muestra que el método de la variable miembro mDataSetObservable está ajustado, así que ingrese DataSetObservable para ver cómo funciona
}
public void notifyDataSetInvalidated() {
mDataSetObservable.notifyInvalidated();
}
}
paquete android.database;
/**
* Una especialización de Observable para DataSetObserver que
proporciona métodos para
* invocar los distintos métodos de devolución de llamada de DataSetObserver.
*/ p>
clase pública DataSetObservable extiende
Observablelt; {
/**
* Invoca onChanged en cada observador. el conjunto de datos
que se está observando
* ha cambiado y que, cuando se lee, contiene el nuevo estado de los
datos.
*/
public void notifyChanged() {
sincronizado(mObservers) {
for (DataSetObserver observador: mObservers) { //
mObservers aquí ¿De dónde viene? Continúe rastreando, pero primero puede juzgar que proviene de Observablelt;
servidorgt;
Entra y echa un vistazo
observer.onChanged();
}
}
}
/**
* Invoca onInvalidated en cada observador. Se llama cuando el
conjunto de datos que se está monitoreando
* ha cambiado de manera que ya no es válido.
*/
public void notifyInvalidated() {
sincronizado (mObservers) {
for (DataSetObserver observador: mObservers) {
observador.onInvalidated();
}
}
}
}
public abstract class Observablelt; {
/**
* La lista de observadores puede estar en la lista
como máximo
* una vez y nunca será nulo.
*/
protected final ArrayListlt; mObservers = new
ArrayListlt ()
p>public void RegisterObserver(T observador) {
if (observer == null) {
throw new IllegalArgumentException("El observador es
null.");
}
sincronizado(mObservers) {
if (mObservers.contains(observer)) {
throw new IllegalStateException("Observador "
observador " ya está registrado."
}
mObservers.add(observador);
}
}
public void unregisterObserver(T observador) {
if (observador == nulo)
{
throw new IllegalArgumentException("El observador es
null."
}
sincronizado (mObservers) {
p>
int index = mObservers.indexOf(observador);
if (index == -1) {
throw new IllegalStateException("Observador "
observador " no estaba registrado.");
}
mObservers.remove(index);
}
}
public void unregisterAll() {
sincronizado(mObservers) {
mObservers.clear()
}
}
}