Dime lo que eras Hola, todo el mundo, digamos en una circunvolución es un ejemplo de Android en el mecanismo de Handler, esta vez fuimos a este ejemplo. Chisme Hugh mencionó, palabras a su vez reformada. Hablemos de Android ahora!
Dime quién, estamos en una circunvolución muestra cómo enviar y recibir mensajes a utilizar el mecanismo de Hanlder a través de ejemplos concretos, este giro se analiza el código fuente, sobre todo para ver los principios ocultos detrás de él para lograr.
Tomamos una clase de mirada Handler, que se encuentra en frameworks/base/core/java/android/os/Handler.javaun archivo. Tiene varios constructores, las hacemos un análisis, su función principal es dar a los miembros de la asignación de variables, nos fijamos en el foco de dos variables miembro de uso común:
- última Looper mLooper; // esto es un gestor de colas de mensajes
- Looper última MessageQueue mqueue; // Esta es la cola de mensajes
Su tarea es llevada a cabo por el constructor, el constructor está sobrecargado, lo que se consigue un vistazo, y omite otros detalles de procesamiento de excepción:
public Handler(Callback callback, boolean async) {
mLooper = Looper.myLooper();
mQueue = mLooper.mQueue;
}
Se puede ver desde el código fuente, se les asigna por Looper implementado, sólo para ser explicado aquí, vamos a introducir una clase de análisis detallado Looper en capítulos posteriores giro.
A continuación nos fijamos en Handler es un método comúnmente utilizado, en primer lugar vistazo a sus handleMessagemétodos, su código fuente es el siguiente:
/**
* Subclasses must implement this to receive messages.
*/
public void handleMessage(Message msg) {
}
Podemos ver que este es un método nula, sino que también muestra el comentario, las necesidades de las subclases para recibir mensajes con el fin de ponerlo en práctica. También hay una llamada de dispatchMessagemétodos también tienen que mirar, Loooper es a través de él a la devolución de llamada handleMessagemétodo, el siguiente es su código fuente, el código fuente también se puede ver esto:
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
Por último, nos fijamos en el método de envío de mensajes, cada método para lograr similares, sólo listamos los prototipos de las funciones y el código fuente funcional, se detalla ya no es una lista:
public final boolean sendMessage(Message msg) //发送消息到消息队列中
public final boolean sendEmptyMessage(int what) //发送空消息到消息队列中
public final boolean sendMessageDelayed(Message msg, long delayMillis) //延迟发送消息到消息队列中
public final boolean sendEmptyMessageDelayed(int what, long delayMillis) //延迟发送空消息到消息队列中
public final void removeMessages(int what) //删除消息队列中的消息
public final boolean hasMessages(int what) //判断消息队列中是否有消息
El método de transmitir un mensaje a través de una privada en última instancia por un método enqueueMessagede añadir mensajes a la cola de mensajes, el código fuente es el siguiente:
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}
Dime, el mecanismo de Android Handler en caso de que se describe aquí, y hay algunos ejemplos para, oye Vamos siguiente descomposición!
