java - móviles - manual de programacion android pdf

Android: ¿Por qué no puedo crear un controlador en un nuevo hilo?

Question

Tuve un problema que no puedo crear un controlador en el nuevo hilo. Este es mi código:

    @Override
    protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    new Thread(new Runnable() {
        public void run() {
            Handler handler = new Handler();
        }
    }).start();
}

¡Pero levantó el error! Quien me puede explicar. ¡Muchas gracias!

Aquí está el detalle de mi error:

09-17 18:05:29.484: E/AndroidRuntime(810): FATAL EXCEPTION: Thread-75
09-17 18:05:29.484: E/AndroidRuntime(810): java.lang.RuntimeException: Can''t create handler inside thread that has not called Looper.prepare()
09-17 18:05:29.484: E/AndroidRuntime(810):  at android.os.Handler.<init>(Handler.java:197)
09-17 18:05:29.484: E/AndroidRuntime(810):  at android.os.Handler.<init>(Handler.java:111)
09-17 18:05:29.484: E/AndroidRuntime(810):  at com.example.handler.MainActivity$1.run(MainActivity.java:57)
09-17 18:05:29.484: E/AndroidRuntime(810):  at java.lang.Thread.run(Thread.java:856)

Answer 1

El lifecycle de lifecycle del subproceso finaliza justo después de que el método de ejecución regrese Pero como está creando un Handler en este thread , el controlador necesita que el hilo se ejecute para que reciba mensajes y los procese.

Así que para que esto suceda, el método de ejecución no debería salir. Por lo tanto, necesita un Looper para esperar indefinidamente y procesar los mensajes que llegan al Controlador.

new Thread(new Runnable() {
        public void run() {
            Looper.prepare();
            Handler handler = new Handler();
            Looper.loop();
        }
    }).start();

Answer 2

Respuesta corta: debido a que el subproceso en el que está intentando adjuntar el controlador, no tiene un looper. Y así, el constructor de la clase Handler está lanzando una excepción. Podría haber usado una clase HandlerThread en su lugar. Esta es solo una clase práctica proporcionada por el marco de Android.

Por favor, lea a continuación para saber qué está pasando bajo el capó.

Vamos a tratar primero de discutir todas las partes individualmente.

1. Hilo:

a. Un hilo es solo un flujo de ejecución. Se supone que un subproceso por defecto solo ejecuta su ejecución (si se proporciona) o llama a su método de ejecución. Al llamar al nuevo Thread.start (). Un hilo simplemente muere y Gc''d cuando el método de ejecución ejecuta toda la declaración escrita dentro de la ejecución () {----}.

segundo. Hay un concepto de Looper en Android. Lo que básicamente hace que el hilo sea un hilo de bloqueo. En pocas palabras, simplemente no deja morir el hilo. Entra en estado de bloqueo y espera más mensajes para reanudar su ejecución.

A continuación se muestra cómo configurar un subproceso de bloqueo, es decir, un subproceso con un looper.

  new Thread(new Runnable() {
    public void run() {
        Looper.prepare();
        Looper.loop();
    }
}).start();

Aquí se crea un hilo que no solo muere después de ejecutar la sentencia Looper.loop (). En su lugar, hace un bucle y entra en un estado de bloqueo. Ahora debe preguntar cuál es el significado del estado de bloqueo, ¿cómo saldrá el hilo del estado de bloqueo? ¿Cómo puedo finalmente liberar este hilo ahora? Aquí es donde entra Handler

2. Entrenador de animales:

a. Siempre se adjunta al Looper del hilo, en el que se crea su instancia.

segundo. Luego procesa esos mensajes del hilo al que se adjunta.

Juntando hilos y manejadores.

new Thread(new Runnable() {
        public void run() {
            Looper.prepare();
            handler = new Handler();
            Looper.loop();
        }
    }).start();

a. Cómo se adjunta el controlador a este subproceso recién creado. segundo. El hilo se configura como un hilo de bloqueo de bucle. Así que esto no va a morir.

ahora, podemos 1. Enviar mensaje en este controlador. 2. Publicar ejecutable en este controlador.

Ambos serán ejecutados en el hilo adjunto.

Tiene la opción de extender la clase Handler e implementar el método handleMessage (Mensaje msg). o simplemente proporciona la implementación de Handler.Callback en el constructor de la clase de controlador. De cualquier manera, se llamará handleMessage (Messages msg) en el hilo adjunto.

Para salir del hilo, puede enviar un tipo específico de tipo de mensaje, y al recibir ese mensaje, simplemente llame a Looper.myLooper (). Quit ()

la clase LooperThread extiende Thread {public Handler mHandler;

  public void run() {
      Looper.prepare();

      mHandler = new Handler() {
          public void handleMessage(Message msg) {
              // process incoming messages here
              if(msg.what == -1){
              Looper.myLooper().quit();
              }
          }
      };

      Looper.loop();
  }

}

Espero que haya ayudado a entender el concepto general.

Answer 3

También puedes usar un HandlerThread como este:

HandlerThread thread = new HandlerThread("MyHandlerThread");
thread.start();
Handler handler = new Handler(thread.getLooper());

HandlerThread tienen un Looper asociado con ellos, por lo que esto no generaría una excepción.

Answer 4

Un manejador debe inicializarse en un subproceso Looper o se le debe dar un Looper.

Dependiendo de lo que quieras hacer, puedes configurar tu hilo para que sea un Looper así:

new Thread(new Runnable() {
    public void run() {
        Looper.prepare();
        mHandler = new Handler();
        Looper.loop();
    }
}).start();

Como el Looper está en un hilo de fondo, no puede actualizar la interfaz de usuario. Alternativamente, podría darle al manejador un Looper desde otro hilo: en este ejemplo, el manejador se puede usar para actualizar la interfaz de usuario:

new Thread(new Runnable() {
    public void run() {
        Handler handler = new Handler(Looper.getMainLooper());
    }
}).start();