Comunicación entre Actividad y Servicio

Estoy intentando crear mi propio reproductor de música para Android. El problema fue ejecutar algunas cosas en segundo plano. La actividad principal gestiona la GUI y hasta ahora se están reproduciendo todas las canciones. Quería separar las clases de GUI y de reproducción de música. Quiero poner la parte de gestión de música en el Servicio y dejar otras cosas como están ahora.

Mi problema es que no puedo organizar la comunicación entre Actividad y Servicio ya que hay mucha comunicación entre ellos, incluido el movimiento de objetos en ambas direcciones. Probé muchas técnicas que busqué aquí en Stack Overflow pero cada vez tuve problemas. Necesito Servicio para poder enviar objetos a Actividad y viceversa. Cuando agrego un widget, también quiero que pueda comunicarse con el Servicio.

Se agradece cualquier consejo. Si necesita el código fuente, comente a continuación, pero ahora, en esta transición, se volvió caótico.

¿Existe algún tutorial más avanzado sobre esto que llamar a un método que devuelve un número aleatorio del servicio? :PAG

EDITAR: La posible solución es usar la biblioteca RoboGuice y mover objetos con inyección

Jan 01 '70 08:01 Dejan

Actualización: 10 de julio de 2016

En mi opinión, creo que usar BroadcastReceiver para eventos personalizados es una mejor manera, ya que los Mensajeros mencionados no manejan la recreación de actividades en la rotación del dispositivo ni posibles pérdidas de memoria.

Puede crear un receptor BroadCast personalizado para eventos en la actividad. Luego, también puede usar Messengers.

1. En tusActivity

   crear una clase MessageHandler como

   public static class MessageHandler extends Handler {
       @Override
       public void handleMessage(Message message) {
           int state = message.arg1;
           switch (state) {
           case HIDE:
               progressBar.setVisibility(View.GONE);
               break;
           case SHOW:
               progressBar.setVisibility(View.VISIBLE);
               break;
           }
       }
   }
   

   Ahora puedes tener su instancia como

   public static Handler messageHandler = new MessageHandler();
   

   Comience Servicecon este objeto Handler como datos adicionales como

   Intent startService = new Intent(context, SERVICE.class)
   startService.putExtra("MESSENGER", new Messenger(messageHandler));
   context.startService(startService);
   

2. En su Servicerecibe este objeto de la intención e inicializa la Messengervariable en Servicio como

   private Messenger messageHandler;
   Bundle extras = intent.getExtras();
   messageHandler = (Messenger) extras.get("MESSENGER");
   sendMessage(ProgressBarState.SHOW);
   

   Y luego escriba un método sendMessagepara enviar mensajes a la actividad.

   public void sendMessage(ProgressBarState state) {
   Message message = Message.obtain();
   switch (state) {
       case SHOW :
           message.arg1 = Home.SHOW;
           break;
       case HIDE :
           message.arg1 = Home.HIDE;
           break;
   }
   try {
       messageHandler.send(message);
   } catch (RemoteException e) {
       e.printStackTrace();
   }
   }
   

El código de muestra anterior muestra y oculta una barra de progreso en la actividad a medida que se reciben mensajes del servicio.

Dec 15 '2013 13:12 Rachit Mishra

Los intentos son una buena solución para la comunicación entre Actividad y Servicio.

Una solución rápida para recibir intenciones en su servicio es subclasificar la clase IntentService . Maneja solicitudes asincrónicas expresadas como intenciones utilizando una cola y un subproceso de trabajo.

Para la comunicación del servicio a la Actividad, puede transmitir la intención, pero en lugar de usar sendBroadcast() normal desde Context, una forma más eficiente es usar LocalBroadcastManager desde la biblioteca de soporte.

Servicio de ejemplo.

public class MyIntentService extends IntentService {
    private static final String ACTION_FOO = "com.myapp.action.FOO";
    private static final String EXTRA_PARAM_A = "com.myapp.extra.PARAM_A";

    public static final String BROADCAST_ACTION_BAZ = "com.myapp.broadcast_action.FOO";
    public static final String EXTRA_PARAM_B = "com.myapp.extra.PARAM_B";

    // called by activity to communicate to service
    public static void startActionFoo(Context context, String param1) {
        Intent intent = new Intent(context, MyIntentService.class);
        intent.setAction(ACTION_FOO);
        intent.putExtra(EXTRA_PARAM1, param1);
        context.startService(intent);
    }

    public MyIntentService() {
        super("MyIntentService");
    }

    @Override
    protected void onHandleIntent(Intent intent) {
        if (intent != null) {
            final String action = intent.getAction();
            if (ACTION_FOO.equals(action)) {
                final String param1 = intent.getStringExtra(EXTRA_PARAM_A);
                // do something
            }
        }
    }

    // called to send data to Activity
    public static void broadcastActionBaz(String param) {
        Intent intent = new Intent(BROADCAST_ACTION_BAZ);
        intent.putExtra(EXTRA_PARAM_B, param);
        LocalBroadcastManager bm = LocalBroadcastManager.getInstance(this);
        bm.sendBroadcast(intent);
    }
}

Actividad de ejemplo

public class MainActivity extends ActionBarActivity {

    // handler for received data from service
    private final BroadcastReceiver mBroadcastReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            if (intent.getAction().equals(MyIntentService.BROADCAST_ACTION_BAZ)) {
                final String param = intent.getStringExtra(EXTRA_PARAM_B);
                // do something
            }
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        IntentFilter filter = new IntentFilter();
        filter.addAction(MyIntentService.BROADCAST_ACTION_BAZ);
        LocalBroadcastManager bm = LocalBroadcastManager.getInstance(this);
        bm.registerReceiver(mBroadcastReceiver, filter);
    }

    @Override
    protected void onDestroy() {
        LocalBroadcastManager bm = LocalBroadcastManager.getInstance(this);
        bm.unregisterReceiver(mBroadcastReceiver);
        super.onDestroy();
    }

    // send data to MyService
    protected void communicateToService(String parameter) {
        MyIntentService.startActionFoo(this, parameter);
    }
}

Mar 13 '2015 23:03 mpolci

Creo que hay un problema con la respuesta correcta. No tengo suficiente reputación para comentar al respecto.

Justo en la respuesta: la llamada de actividad bindService() para obtener el puntero al Servicio está bien. Porque el contexto del servicio se mantiene cuando se mantiene la conexión.

incorrecto en la respuesta: el puntero de servicio a la clase Actividad para devolver la llamada es una mala manera. La instancia de actividad tal vez no sea nula durante el contexto de la actividad. Lanzamiento => excepción aquí.

Solución para el error en la respuesta: intención de envío del servicio a Actividad. e intención del receptor de actividad a través de BroadcastReceiver.

Nota: en este caso, Servicio y Actividad en el mismo Proceso, debes usar LocalBroadcastManager para enviar la intención. Mejora el rendimiento y la seguridad

Sep 15 '2016 15:09 HungNM2