Revisión 2: Cómo pasar datos de un Servicio/hilo de fondo a alguna actividad distinta de la Actividad principal que creó el servicio en segundo plano

Question

He creado una aplicación de Android simple para probar cómo usar un controlador o controladores para pasar datos de un background Service/thread to alguna otra actividad que no sea la actividad principal que creó el servicio en segundo plano. Tengo el servicio, el hilo y un controlador trabajando en MainActivity. El último paso es hacer que un controlador pase datos a alguna otra actividad que no sea la actividad principal. Puedo hacer que el Servicio pase mensajes al manejador de MainActivity, pero no sé cómo hacer que pase datos a alguna otra actividad.

¿Por qué alguien querría hacer esto? Pensé que esto se compara con un simple reproductor de MP3, pero lo que realmente se compara es una buena radio FM. MainActivity utiliza un servicio en segundo plano que me permite seleccionar una estación de FM. Cuando lance la actividad Reproducir, debe vincularse al mismo servicio de fondo para que pueda continuar escuchando mientras (la parte agradable) muestra un ecualizador gráfico o una animación del audio. Básicamente, no sé cómo enlazar al servicio en segundo plano de más de una actividad.

Mi código se basó originalmente en una página de ejemplo de servicio 304 en Pro Android 2 y fue ayudado tremendamente por CommonsWare Sample Application.

Por favor, eche un vistazo a mi código actual. Se compone de tres archivos cuidadosamente comentado que describen lo que estoy tratando de hacer y las dificultades que estoy teniendo pasar datos a alguna otra actividad además de la MainActivity:

/************************************************************************************************** 
* File: MainActivity.java 
* Application: BackgroundService 
* Description: This file contains the main activity that is run when the BackgroundService 
*  application is launched. 
**************************************************************************************************/ 

package com.marie.mainactivity; 

import com.marie.mainactivity.BackgroundService; 
import android.app.Activity; 
import android.content.Intent; 
import android.os.Bundle; 
import android.os.Handler; 
import android.os.Message; 
import android.os.Messenger; 
import android.util.Log; 
import android.view.View; 
import android.view.View.OnClickListener; 
import android.widget.Button; 

/* 
* Class: MainActivity 
* Purpose: Using a button, the MainActivity class starts the backgroundService and 
*  the RcvMessages activity. Using another button MainActivity stops the backgroundService. 
*  NOTE: RcvMessages is only a stub that does nothing but display a simple message. 
* Handler: MainActivity defines and provides a reference to "handler" for the backgroundService. 
*/ 
public class MainActivity extends Activity { 
    private static final String TAG = "MainActivity"; 

    @Override 
    public void onCreate(Bundle savedInstanceState) 
    { 
     super.onCreate(savedInstanceState); 
     setContentView(R.layout.main); 

     Log.d(TAG, "starting service"); 

     /* 
     * The bind button: bindBtn 
     * Clicking this button starts the background Service and launches the 
     * RcvMessages activity. NOTE: RcvMessages is only a stub so far. 
     */ 
     Button bindBtn = (Button)findViewById(R.id.bindBtn); 
     bindBtn.setOnClickListener(new OnClickListener() { 

      @Override 
      public void onClick(View arg0) { 

       // Start the background Service for sending canned messages to the handler as a test. 
       Intent backgroundService = new Intent(MainActivity.this, com.marie.mainactivity.BackgroundService.class); 
       backgroundService.putExtra(BackgroundService.EXTRA_MESSENGER, new Messenger(handler)); 
       startService(backgroundService); 

       // Start the RcvMessages activity to receive messages from the handler. But how??? 
       Intent messages = new Intent(MainActivity.this, com.marie.mainactivity.RcvMessages.class); 
       startActivity(messages); 
      } 
     }); 

     /* 
     * The unbind button: unbindBtn 
     * Clicking this button stops the background Service. 
     */ 
     Button unbindBtn = (Button)findViewById(R.id.unbindBtn); 
     unbindBtn.setOnClickListener(new OnClickListener() { 

      @Override 
      public void onClick(View arg0) { 

       // Stop the background Service 
       Intent backgroundService = new Intent(MainActivity.this, BackgroundService.class); 
       stopService(backgroundService); 
      } 
     }); 
    } 

    /* 
    * This is the handler to be passed to the background Service via a Messenger. 
    * NOTE: I want it to send messages to my RcvMessages activity. 
    */ 
    private Handler handler = new Handler() { 
     @Override 
     public void handleMessage(Message msg) { 
      // simple handler test (does not send messages to RcvMessages activity 
      String obj = (String) msg.obj; 
      Log.i("handleMessge", "obj: " + obj); 
     } 
    }; 
} 

/************************************************************************************************** 
* File: BackgroundService.java 
* Application: BackgroundService 
* Description: This file contains the background Service that is launched by the MainActivity's 
*  bind button. 
**************************************************************************************************/ 

package com.marie.mainactivity; 

import android.app.Notification; 
import android.app.NotificationManager; 
import android.app.PendingIntent; 
import android.app.Service; 
import android.content.Intent; 
import android.os.Bundle; 
import android.os.IBinder; 
import android.os.Message; 
import android.os.Messenger; 
import android.os.RemoteException; 

/* 
* Class: BackgroundService 
* Purpose: Using the onStart() method the BackgroundService gets the reference to the 
*  Messenger instance that was passed to BackgroundService. The messenger is then 
*  used by the ServiceWorker() thread to send messages to the handler that is defined 
*  in the MainActivity class. 
*/ 
public class BackgroundService extends Service { 
    private NotificationManager notificationMgr; 

    public static final String EXTRA_MESSENGER = "com.marie.mainactivity.EXTRA_MESSENGER"; 
    private Messenger messenger; 

    @Override 
    public void onCreate() { 
     super.onCreate(); 

     notificationMgr = (NotificationManager)getSystemService(NOTIFICATION_SERVICE); 

     displayNotificationMessage("starting Background Service"); 

     Thread thr = new Thread(null, new ServiceWorker(), "BackgroundService"); 
     thr.start(); 
    } 

    /* 
    * This is the ServiceWorker thread that passes messages to the handler defined in 
    * the MainActivity class. 
    * NOTE: Instead of passing messages to a handler in MainActivity I would like 
    * it to pass messages to a handler defined in the RcvMessages activity. 
    */ 
    class ServiceWorker implements Runnable 
    { 
     public void run() { 
      // do background processing here... something simple 

      // send a message to the handler defined in the MainActivity class 
      try { 
       Message msg1 = Message.obtain(); 
       msg1.obj = "Hello 1"; 
       messenger.send(msg1); 
      } catch (RemoteException e) { 
       e.printStackTrace(); 
      } 

      // stop the service when done... 
      // BackgroundService.this.stopSelf(); 
      // Or use the unbindBtn in the MainActivity class. 
     } 
    } 

    @Override 
    public void onDestroy() 
    { 
     displayNotificationMessage("stopping Background Service"); 
     super.onDestroy(); 
    } 

    /* 
    * onStart is where we get our reference the Messenger that allows 
    * us to send messages to the handler defined in the MainActivity class. 
    */ 
    @Override 
    public void onStart(Intent intent, int startId) { 
     super.onStart(intent, startId); 

     Bundle extras = intent.getExtras(); 
     messenger = (Messenger)extras.get(EXTRA_MESSENGER); 
    } 

    @Override 
    public IBinder onBind(Intent intent) { 
     return null; 
    } 

    private void displayNotificationMessage(String message) 
    { 
     Notification notification = new Notification(R.drawable.note, message, System.currentTimeMillis()); 

     PendingIntent contentIntent = PendingIntent.getActivity(this, 0, new Intent(this, MainActivity.class), 0); 

     notification.setLatestEventInfo(this, "Background Service", message, contentIntent); 

     notificationMgr.notify(R.id.app_notification_id, notification); 
    } 
} 

/************************************************************************************************** 
* File: RcvMessages.java 
* Application: BackgroundService 
* Description: This file contains stub code that displays a test message in an EditText. 
**************************************************************************************************/ 

package com.marie.mainactivity; 

import android.app.Activity; 
import android.os.Bundle; 
import android.text.InputType; 
import android.widget.EditText; 

/* 
* Class: RcvMessages 
* Purpose: RcvMessages is stub code that I want to extend in some way to receive messages from 
*  the background Service. 
*  NOTE: I don't know who to do this. 
*/ 
public class RcvMessages extends Activity { 

    EditText myText; 

    /** Called when the activity is first created. */ 
    @Override 
    public void onCreate(Bundle savedInstanceState) { 
     super.onCreate(savedInstanceState); 
     setContentView(R.layout.messages); 

     myText = (EditText)findViewById(R.id.my_text); 

     myText.setSingleLine(); 
     myText.setInputType(InputType.TYPE_NULL); 

     // Display a simple test message for now. 
     myText.setText("RcvMessages here"); 
    } 
} 

Cualquier ayuda usando un servicio en segundo plano, hilo , y los controladores para pasar datos a alguna otra actividad además de la actividad principal que creó el servicio backgraound sería muy apreciada.

Answer 1

El Handler está asociado a un hilo específico, por lo que durante el tiempo que lo crea en el hilo de UI todo lo que necesita hacer es compartir el controlador. Pondría tu controlador en mi clase Application. Y puede poner allí el total Messenger, si lo desea. Luego puede acceder al controlador en cualquier actividad a través del ((MyApplication)getApplication()).getHandler(). Cuando la actividad comienza o hace una pausa, puede registrarla como una devolución de llamada.

Así que algo como esto

public class MyApplication extends Application { 
    Handler h = new Handler() { 
     public void handleMessage(Message m) { 
     if (realCallback!=null) { 
      realCallback.handleMessage(m); 
     } 
     } 
    }; 
    Handler.Callback realCallback=null; 
    ...... 
    public Handler getHandler() { 
     return h; 
    } 

    public void setCallback(Handler.Callback c) { 
     realCallback = c; 
    } 
} 

En cualquier actividad que tiene que hacer recibir las solicitudes a través de mensajería

public class MyActivity extends Activity implements Handler.Callback 

...... 

public void onStart() { 
    ((MyApplication)getApplication()).setCallback(this); 
} 

public void onPause() { 
    ((MyApplication)getApplication()).setCallback(null); 
} 

public void handleMessage(Message msg) { 
    //.... Do stuff .... 
} 

}

Esta es sólo una idea. Es posible que deba ajustarlo a sus necesidades.

Y no se olvide de establecer MyApplication nombre en AndroidManifest.xml