¿Cómo puedo actualizar la información de una actividad Android desde un servicio en segundo plano

Question

Estoy tratando de crear una sencilla aplicación para Android que tiene un ActivityList de la información, cuando se inicia la aplicación, planeo iniciar un servicio que se calcula constantemente los datos (que va a cambiar) y quiero que el ActivityList estar en sincronía con los datos que el servicio es el cálculo de la vida de la aplicación.

¿Cómo puedo configurar mi actividad a escuchar el servicio? ¿Es esta la mejor manera de abordar este problema?

Por ejemplo, si uno se imagina una lista de precios de las acciones -. Los datos estarían siendo cambiado regularmente y tienen que estar en sintonía con el (en mi caso) de servicio que se está calculando / ir a buscar los datos en constante

Gracias de antemano

Answer 1

  

¿Cómo puedo configurar mi actividad a   escuchando el servicio? Es este el   mejor manera de abordar este problema?

Hay tres opciones principales, tal como lo veo:

1. sondeo. El Activity pide periódicamente la Service de los datos más recientes. En mi humilde opinión, esta opción es una mierda, pero es ciertamente posible.

2. Las devoluciones de llamada. Por respuesta de Jax, la Activity registra un objeto de devolución de llamada ( "observador") con el Service. El Service invoca un método en la devolución de llamada cuando cambian los datos, que a su vez actualiza la interfaz de usuario. Se puede ver un ejemplo del uso que con una Service aquí .

3. Intents Broadcast. El Service difunde una Intent través sendBroadcast() en un cambio de datos. El Activity registra un BroadcastReceiver usando registerReceiver(), y que BroadcastReceiver es notificado de una emisión entrante. Esto desencadena la Activity para cargar los datos más recientes de la Service, o posiblemente sólo para obtener los últimos datos de extras en la Intent emisión. Se puede ver un ejemplo del uso de esta técnica con un Service aquí .

Answer 2

Este sonido como un buen candidato para el patrón de observador. Básicamente su actividad (El Observador) se registrará con el servicio de fondo (lo observable) y se puede empujar o tirar de datos de su actividad. Su observador en este caso será su actividad y el observable será su servicio.

Si usted no sabe nada acerca de los patrones de diseño de comprar "Head First Design Patterns", es fácil de leer y está lleno de gran información.

PS:. Estoy leyendo ahora

Answer 3

Estoy muy, muy preguntándose por qué nadie menciona un enfoque simple utilizando un EventBus por cualquier biblioteca. Esto es, por supuesto, si usted no está utilizando RX. Mi favorito personal es EventBus por GreenRobot. https://github.com/greenrobot/EventBus

Con sólo un par de líneas de código, y no hay interfaces. Desencadenar un evento, y escuche siempre que lo desee. Se desacoplado, es seguro para subprocesos, y no se bloqueará su aplicación.

Answer 4

Es necesario utilizar bindService () para vincular la actividad con servicio en ejecución y comunicarse con él.

public class BindingActivity extends Activity {
YourService mService;
boolean mBound = false;

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

@Override
protected void onStart() {
    super.onStart();
    // Bind to Your Service
    Intent intent = new Intent(this, YourService.class);
    bindService(intent, mConnection, Context.BIND_AUTO_CREATE);
}

@Override
protected void onStop() {
    super.onStop();
    // Unbind from the service
    if (mBound) {
        unbindService(mConnection);
        mBound = false;
    }
}

/** Called when a button is clicked (the button in the layout file attaches to
  * this method with the android:onClick attribute) */
public void onButtonClick(View v) {
    if (mBound) {
        // Call a method from your Service.
        // However, if this call were something that might hang, then this request should
        // occur in a separate thread to avoid slowing down the activity performance.
        int num = mService.getRandomNumber();
        Toast.makeText(this, "number: " + num, Toast.LENGTH_SHORT).show();
    }
}

/** Defines callbacks for service binding, passed to bindService() */
private ServiceConnection mConnection = new ServiceConnection() {

    @Override
    public void onServiceConnected(ComponentName className,
            IBinder service) {
        // We've bound to the running Service, cast the IBinder and get instance
        LocalBinder binder = (LocalBinder) service;
        mService = binder.getService();
        mBound = true;
    }

    @Override
    public void onServiceDisconnected(ComponentName arg0) {
        mBound = false;
    }
 };
}

y su servicio como:

public class LocalService extends Service {
    // Binder given to clients
   private final IBinder mBinder = new LocalBinder();
   // Random number generator
   private final Random mGenerator = new Random();

/**
 * Class used for the client Binder.  Because we know this service always
 * runs in the same process as its clients, we don't need to deal with IPC.
 */
public class LocalBinder extends Binder {
    LocalService getService() {
        // Return this instance of LocalService so clients can call public methods
        return LocalService.this;
    }
}

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

/** method for clients */
public int getRandomNumber() {
  return mGenerator.nextInt(100);
  }
}

Answer 5

Usted tendrá un hilo conductor de fondo que calcula los cambios en la lista. Este hilo necesita ahora una posibilidad de notificar a la interfaz gráfica de usuario que la lista se actualiza.

Puede utilizar algún tipo de ArrayAdapter para obtener los datos en el ListView. El ArrayAdapter tiene un método llamado Adpater. notifyDataSetChanged () cada vez que se llama a este método el adaptador verá que los datos correspondientes ha cambiado y luego notificar a la vista de lista que se debe actualizar en la siguiente posibilidad.