móviles - manual de programacion android pdf

Comunicación entre actividad y servicio

Question

Estoy tratando de hacer mi propio MusicPlayer para Android. Donde llegué a un problema está ejecutando algunas cosas en segundo plano. La actividad principal administra la GUI y hasta ahora todas las canciones se están reproduciendo. Quería separar la GUI y las clases de reproducción de música. Quiero poner la administració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 la actividad y el 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 que tuve problemas. Necesito el Servicio para poder enviar objetos a la Actividad y viceversa. Cuando agrego widget también quiero que se pueda comunicar con el Servicio.

Se agradecen todos los consejos, si necesita el código fuente, coloque el comentario a continuación, pero ahora en esta transición se volvió caótico.

¿Hay 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 solución posible es usar la biblioteca RoboGuice y mover objetos con inyección

Answer 1

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

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

mal en la respuesta: puntero de servicio a clase de actividad para devolver la llamada es mala. La instancia de la actividad puede no ser nula durante el contexto de la actividad. Se trata de una excepción => excepción aquí.

solución para lo incorrecto en la respuesta: servicio enviar intento a Actividad. y la intención del receptor de actividad a través de BroadcastReceiver.

Nota: en este caso, Servicio y Actividad en el mismo Proceso, debe usar LocalBroadcastManager para enviar intenciones. Mejora el rendimiento y la seguridad

Answer 2

Este es un ejemplo simple de comunicación entre actividad y servicio

Actividad

MyReceiver myReceiver; //my global var receiver
@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.layourAwesomexD);
    registerReceiver();
}

//When the activity resume, the receiver is going to register...
@Override
protected void onResume() {
    super.onResume();
    checkStatusService(); // verficarStatusServicio(); <- name change
    registerReceiver();
}
//when the activity stop, the receiver is going to unregister...
@Override
protected void onStop() {
    unregisterReceiver(myReceiver); //unregister my receiver...
    super.onStop();
}
//function to register receiver :3
private void registerReceiver(){
    //Register BroadcastReceiver
    //to receive event from our service
    myReceiver = new MyReceiver();
    IntentFilter intentFilter = new IntentFilter();
    intentFilter.addAction(MyService.SENDMESAGGE);
    registerReceiver(myReceiver, intentFilter);
}

// class of receiver, the magic is here...
private class MyReceiver extends BroadcastReceiver {

    @Override
    public void onReceive(Context arg0, Intent arg1) {
        //verify if the extra var exist
        System.out.println(arg1.hasExtra("message")); // true or false
        //another example...
        System.out.println(arg1.getExtras().containsKey("message")); // true or false
        //if var exist only print or do some stuff
        if (arg1.hasExtra("message")) {
            //do what you want to
            System.out.println(arg1.getStringExtra("message"));
        }    
    }
}

public void checkStatusService(){
    if(MyService.serviceStatus!=null){
        if(MyService.serviceStatus == true){
            //do something
            //textview.text("Service is running");
        }else{
            //do something
            //textview.text("Service is not running");
        }
    }
}

Servicio

public class MyService extends Service {

final static String SENDMESAGGE = "passMessage";

public static Boolean serviceStatus = false;

@Override
public void onCreate() {
    super.onCreate();
    serviceStatus=true;
}

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

@Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        //you service etc...             
        passMessageToActivity("hello my friend this an example of send a string...");
        return START_STICKY;
    }

@Override
    public void onDestroy() {
        super.onDestroy();
        passMessageToActivity("The service is finished, This is going to be more cooler than the heart of your ex...");
        System.out.println("onDestroy");
        serviceStatus=false;
   }

private void passMessageToActivity(String message){
        Intent intent = new Intent();
        intent.setAction(SENDMESAGGE);
        intent.putExtra("message",message);
        sendBroadcast(intent);
    }
}

• si no cancelamos el registro de BroadcastReceiver, tendremos un error, debe anular el registro cuando la actividad se active onPause, onStop, onDestroy ...
• si no registra BroadcastReceiver cuando vuelve a la actividad, no escuchará nada del servicio ... el servicio enviará información a BroadcastReceiver pero no recibirá nada porque no está registrado.
• Cuando crea más de un servicio, los siguientes servicios comenzarán en onStartCommand .
• Puede pasar información al servicio con intención y la puede obtener en onStartCommand
• Diferencia sobre el return en onStartCommand : diferencia entre START_STICKY y START_REDELIVER_INTENT? y consulte el sitio web oficial de google: Services

Answer 3

Implementé la comunicación entre Actividad y Servicio utilizando la interfaz de Vinculación y Devolución de llamada.

Para enviar datos al servicio, utilicé Binder, que devuelve el Servicio a la Actividad, y luego la Actividad puede acceder a los métodos públicos en el Servicio.

Para enviar datos a la Actividad del Servicio, utilicé la interfaz de Devolución de llamada como la que está utilizando cuando desea comunicarse entre Fragmento y Actividad.

Aquí hay algunos ejemplos de código para cada uno: El siguiente ejemplo muestra la relación bidireccional Actividad y servicio: La actividad tiene 2 botones: El primer botón se iniciará y detendrá el servicio. El segundo botón iniciará un temporizador que se ejecuta en el servicio.

El servicio actualizará la Actividad a través de una devolución de llamada con el progreso del temporizador.

Mi actividad:

    //Activity implements the Callbacks interface which defined in the Service  
    public class MainActivity extends ActionBarActivity implements MyService.Callbacks{

    ToggleButton toggleButton;
    ToggleButton tbStartTask;
    TextView tvServiceState;
    TextView tvServiceOutput;
    Intent serviceIntent;
    MyService myService;
    int seconds;
    int minutes;
    int hours;


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
         serviceIntent = new Intent(MainActivity.this, MyService.class);
        setViewsWidgets();
    }

    private void setViewsWidgets() {
        toggleButton = (ToggleButton)findViewById(R.id.toggleButton);
        toggleButton.setOnClickListener(btListener);
        tbStartTask = (ToggleButton)findViewById(R.id.tbStartServiceTask);
        tbStartTask.setOnClickListener(btListener);
        tvServiceState = (TextView)findViewById(R.id.tvServiceState);
        tvServiceOutput = (TextView)findViewById(R.id.tvServiceOutput);

    }

    private ServiceConnection mConnection = new ServiceConnection() {

        @Override
        public void onServiceConnected(ComponentName className,
                                       IBinder service) {
            Toast.makeText(MainActivity.this, "onServiceConnected called", Toast.LENGTH_SHORT).show();
            // We''ve binded to LocalService, cast the IBinder and get LocalService instance
            MyService.LocalBinder binder = (MyService.LocalBinder) service; 
            myService = binder.getServiceInstance(); //Get instance of your service! 
            myService.registerClient(MainActivity.this); //Activity register in the service as client for callabcks! 
            tvServiceState.setText("Connected to service...");
            tbStartTask.setEnabled(true);
        }

        @Override
        public void onServiceDisconnected(ComponentName arg0) {
            Toast.makeText(MainActivity.this, "onServiceDisconnected called", Toast.LENGTH_SHORT).show();
            tvServiceState.setText("Service disconnected");
            tbStartTask.setEnabled(false);
        }
    };

    View.OnClickListener btListener =  new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            if(v == toggleButton){
                if(toggleButton.isChecked()){
                    startService(serviceIntent); //Starting the service 
                    bindService(serviceIntent, mConnection,            Context.BIND_AUTO_CREATE); //Binding to the service! 
                    Toast.makeText(MainActivity.this, "Button checked", Toast.LENGTH_SHORT).show();
                }else{
                    unbindService(mConnection);
                    stopService(serviceIntent);
                    Toast.makeText(MainActivity.this, "Button unchecked", Toast.LENGTH_SHORT).show();
                    tvServiceState.setText("Service disconnected");
                    tbStartTask.setEnabled(false);
                }
            }

            if(v == tbStartTask){
                if(tbStartTask.isChecked()){
                      myService.startCounter();
                }else{
                    myService.stopCounter();
                }
            }
        }
    };

    @Override
    public void updateClient(long millis) {
        seconds = (int) (millis / 1000) % 60 ;
        minutes = (int) ((millis / (1000*60)) % 60);
        hours   = (int) ((millis / (1000*60*60)) % 24);

        tvServiceOutput.setText((hours>0 ? String.format("%d:", hours) : "") + ((this.minutes<10 && this.hours > 0)? "0" + String.format("%d:", minutes) :  String.format("%d:", minutes)) + (this.seconds<10 ? "0" + this.seconds: this.seconds));
    }
}

Y aquí está el servicio:

 public class MyService extends Service {
    NotificationManager notificationManager;
    NotificationCompat.Builder mBuilder;
    Callbacks activity;
    private long startTime = 0;
    private long millis = 0;
    private final IBinder mBinder = new LocalBinder();
    Handler handler = new Handler();
    Runnable serviceRunnable = new Runnable() {
        @Override
        public void run() {
            millis = System.currentTimeMillis() - startTime;
            activity.updateClient(millis); //Update Activity (client) by the implementd callback
            handler.postDelayed(this, 1000);
        }
    };


    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {

        //Do what you need in onStartCommand when service has been started
        return START_NOT_STICKY;
    }

    @Override
    public IBinder onBind(Intent intent) {
        return mBinder;
    }
    //returns the instance of the service
    public class LocalBinder extends Binder{
        public MyService getServiceInstance(){
            return MyService.this;
        }
    }

    //Here Activity register to the service as Callbacks client
    public void registerClient(Activity activity){
        this.activity = (Callbacks)activity;
    }

    public void startCounter(){
        startTime = System.currentTimeMillis();
        handler.postDelayed(serviceRunnable, 0);
        Toast.makeText(getApplicationContext(), "Counter started", Toast.LENGTH_SHORT).show();
    }

    public void stopCounter(){
        handler.removeCallbacks(serviceRunnable);
    }


    //callbacks interface for communication with service clients! 
    public interface Callbacks{
        public void updateClient(long data);
    }
}

Answer 4

La manera más fácil y eficiente será usar EventBus de EventBus .

Use 3 pasos simples:

1 Define eventos

public static class MessageEvent { /* Additional fields if needed */ }

2 Prepare suscriptores: declare y anote su método de suscripción; opcionalmente, especifique un modo de secuencia:

@Subscribe(threadMode = ThreadMode.MAIN)  
public void onMessageEvent(MessageEvent event) {/* Do something */};

Regístrese y elimine el registro de su suscriptor. Por ejemplo, en Android, las actividades y los fragmentos generalmente deberían registrarse de acuerdo con su ciclo de vida:

@Override
 public void onStart() {
     super.onStart();
     EventBus.getDefault().register(this);
 }

 @Override
 public void onStop() {
     super.onStop();
     EventBus.getDefault().unregister(this);
 }

3 eventos de publicaciones:

EventBus.getDefault().post(new MessageEvent());

Answer 5

La mejor manera en este caso es comunicarse haciendo transmisiones desde su servicio para diferentes acciones y recibirlas en su actividad. Puede crear una transmisión personalizada y enviar algunos códigos que definen eventos específicos como completar, cambiar, preparar, etc.

Answer 6

Los intentos son una buena solución para la comunicación entre la actividad y el servicio.

Una solución rápida para los intentos de recepción en su servicio es la subclasificación de la clase IntentService . Maneja solicitudes asíncronas expresadas como Intenciones utilizando una cola y un hilo de trabajo.

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

Ejemplo de servicio.

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);
    }
}

Answer 7

Una manera muy fácil pero poderosa es usar EventBus , puede agregarlo a su compilación de gradle y disfrutar del sencillo patrón de editor / suscriptor.

Answer 8

echa un vistazo a la documentación de Android

http://developer.android.com/guide/components/bound-services.html#Binder

Answer 9

Actualización: 10 de julio de 2016

IMO Creo que usar BroadcastReceiver para eventos personalizados es una mejor manera que la mencionada por los Mensajeros de no manejar la actividad de recreación en la rotación del dispositivo, así como posibles fugas de memoria.

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

1. En tu Activity

   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 su Service con este objeto controlador como datos adicionales como

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

2. En su Service , recibe este objeto del intento e inicializa la variable Messenger en el Servicio como

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

   Y luego escribe un método sendMessage para 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 ejemplo anterior muestra y oculta una barra de progreso en la actividad a medida que se reciben los mensajes del servicio.