IU de actividad de actualización de Android desde el servicio

Tengo un servicio que busca nuevas tareas todo el tiempo. Si hay una nueva tarea, quiero actualizar la interfaz de usuario de la actividad para mostrar esa información. Encontré https://github.com/commonsguy/cw-andtutorials/tree/master/18-LocalService/ este ejemplo. ¿Es ese un buen enfoque? ¿Algún otro ejemplo?

Gracias.

Vea a continuación mi respuesta original: ese patrón ha funcionado bien, pero recientemente comencé a usar un enfoque diferente para la comunicación de Servicio / Actividad:

• Use un servicio vinculado que permita a la Actividad obtener una referencia directa al Servicio, permitiendo así llamadas directas en él, en lugar de usar Intents.

• Utilice RxJava para ejecutar operaciones asincrónicas.

• Si el Servicio necesita continuar con las operaciones en segundo plano incluso cuando no se está ejecutando ninguna Actividad, inicie también el servicio desde la clase Aplicación para que no se detenga cuando no esté vinculado.

Las ventajas que he encontrado en este enfoque en comparación con la técnica startService () / LocalBroadcast son

• No es necesario que los objetos de datos implementen Parcelable; esto es particularmente importante para mí, ya que ahora estoy compartiendo código entre Android e iOS (usando RoboVM)
• RxJava proporciona programación enlatada (y multiplataforma) y una composición sencilla de operaciones asincrónicas secuenciales.
• Esto debería ser más eficiente que usar un LocalBroadcast, aunque la sobrecarga de usar RxJava puede superar eso.

Algún código de ejemplo. Primero el servicio:

public class AndroidBmService extends Service implements BmService {

    private static final int PRESSURE_RATE = 500000;   // microseconds between pressure updates
    private SensorManager sensorManager;
    private SensorEventListener pressureListener;
    private ObservableEmitter<Float> pressureObserver;
    private Observable<Float> pressureObservable;

    public class LocalBinder extends Binder {
        public AndroidBmService getService() {
            return AndroidBmService.this;
        }
    }

    private IBinder binder = new LocalBinder();

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        logMsg("Service bound");
        return binder;
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        return START_NOT_STICKY;
    }

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

        sensorManager = (SensorManager)getSystemService(SENSOR_SERVICE);
        Sensor pressureSensor = sensorManager.getDefaultSensor(Sensor.TYPE_PRESSURE);
        if(pressureSensor != null)
            sensorManager.registerListener(pressureListener = new SensorEventListener() {
                @Override
                public void onSensorChanged(SensorEvent event) {
                    if(pressureObserver != null) {
                        float lastPressure = event.values[0];
                        float lastPressureAltitude = (float)((1 - Math.pow(lastPressure / 1013.25, 0.190284)) * 145366.45);
                        pressureObserver.onNext(lastPressureAltitude);
                    }
                }

                @Override
                public void onAccuracyChanged(Sensor sensor, int accuracy) {

                }
            }, pressureSensor, PRESSURE_RATE);
    }

    @Override
    public Observable<Float> observePressure() {
        if(pressureObservable == null) {
            pressureObservable = Observable.create(emitter -> pressureObserver = emitter);
            pressureObservable = pressureObservable.share();
        }
         return pressureObservable;
    }

    @Override
    public void onDestroy() {
        if(pressureListener != null)
            sensorManager.unregisterListener(pressureListener);
    }
} 

Y una actividad que se une al servicio y recibe actualizaciones de altitud de presión:

public class TestActivity extends AppCompatActivity {

    private ContentTestBinding binding;
    private ServiceConnection serviceConnection;
    private AndroidBmService service;
    private Disposable disposable;

    @Override
    protected void onDestroy() {
        if(disposable != null)
            disposable.dispose();
        unbindService(serviceConnection);
        super.onDestroy();
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        binding = DataBindingUtil.setContentView(this, R.layout.content_test);
        serviceConnection = new ServiceConnection() {
            @Override
            public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
                logMsg("BlueMAX service bound");
                service = ((AndroidBmService.LocalBinder)iBinder).getService();
                disposable = service.observePressure()
                    .observeOn(AndroidSchedulers.mainThread())
                    .subscribe(altitude ->
                        binding.altitude.setText(
                            String.format(Locale.US,
                                "Pressure Altitude %d feet",
                                altitude.intValue())));
            }

            @Override
            public void onServiceDisconnected(ComponentName componentName) {
                logMsg("Service disconnected");
            }
        };
        bindService(new Intent(
            this, AndroidBmService.class),
            serviceConnection, BIND_AUTO_CREATE);
    }
}

El diseño de esta actividad es:

<?xml version="1.0" encoding="utf-8"?>
<layout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    >
    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        tools:context="com.controlj.mfgtest.TestActivity">

        <TextView
            tools:text="Pressure"
            android:id="@+id/altitude"
            android:gravity="center_horizontal"
            android:layout_gravity="center_vertical"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"/>

    </LinearLayout>
</layout>

Si el servicio debe ejecutarse en segundo plano sin una actividad vinculada, también se puede iniciar desde la clase Application en el OnCreate()uso Context#startService().

Mi respuesta original (de 2013):

En su servicio: (usando COPA como servicio en el ejemplo siguiente).

Utilice un LocalBroadCastManager. En onCreate de su servicio, configure la emisora:

broadcaster = LocalBroadcastManager.getInstance(this);

Cuando desee notificar algo a la interfaz de usuario:

static final public String COPA_RESULT = "com.controlj.copame.backend.COPAService.REQUEST_PROCESSED";

static final public String COPA_MESSAGE = "com.controlj.copame.backend.COPAService.COPA_MSG";

public void sendResult(String message) {
    Intent intent = new Intent(COPA_RESULT);
    if(message != null)
        intent.putExtra(COPA_MESSAGE, message);
    broadcaster.sendBroadcast(intent);
}

En tu actividad:

Crea un oyente en onCreate:

public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    super.setContentView(R.layout.copa);
    receiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            String s = intent.getStringExtra(COPAService.COPA_MESSAGE);
            // do something here.
        }
    };
}

y registrarlo en onStart:

@Override
protected void onStart() {
    super.onStart();
    LocalBroadcastManager.getInstance(this).registerReceiver((receiver), 
        new IntentFilter(COPAService.COPA_RESULT)
    );
}

@Override
protected void onStop() {
    LocalBroadcastManager.getInstance(this).unregisterReceiver(receiver);
    super.onStop();
}

para mí, la solución más simple fue enviar una transmisión, en la actividad oncreate registré y definí la transmisión de esta manera (updateUIReciver se define como una instancia de clase):

 IntentFilter filter = new IntentFilter();

 filter.addAction("com.hello.action"); 

 updateUIReciver = new BroadcastReceiver() {

            @Override
            public void onReceive(Context context, Intent intent) {
                //UI update here

            }
        };
 registerReceiver(updateUIReciver,filter);

Y desde el servicio envías la intención de esta manera:

Intent local = new Intent();

local.setAction("com.hello.action");

this.sendBroadcast(local);

no te olvides de anular el registro de la recuperación en la actividad de destruir:

unregisterReceiver(updateUIReciver);

Usaría un servicio vinculado para hacer eso y me comunicaría con él implementando un oyente en mi actividad. Entonces, si su aplicación implementa myServiceListener, puede registrarla como oyente en su servicio después de haberse vinculado con ella, llamar a listener.onUpdateUI desde su servicio vinculado y actualizar su interfaz de usuario allí.

Recomendaría revisar Otto , un EventBus diseñado específicamente para Android. Su Actividad / UI puede escuchar los eventos publicados en el Bus desde el Servicio y desacoplarse del backend.

La solución de Clyde funciona, pero es una transmisión, que estoy bastante seguro de que será menos eficiente que llamar a un método directamente. Podría estar equivocado, pero creo que las transmisiones están destinadas más a la comunicación entre aplicaciones.

Supongo que ya sabe cómo vincular un servicio con una actividad. Hago algo parecido al código de abajo para manejar este tipo de problema:

class MyService extends Service {
    MyFragment mMyFragment = null;
    MyFragment mMyOtherFragment = null;

    private void networkLoop() {
        ...

        //received new data for list.
        if(myFragment != null)
            myFragment.updateList();
        }

        ...

        //received new data for textView
        if(myFragment !=null)
            myFragment.updateText();

        ...

        //received new data for textView
        if(myOtherFragment !=null)
            myOtherFragment.updateSomething();

        ...
    }
}


class MyFragment extends Fragment {

    public void onResume() {
        super.onResume()
        //Assuming your activity bound to your service
        getActivity().mMyService.mMyFragment=this;
    }

    public void onPause() {
        super.onPause()
        //Assuming your activity bound to your service
        getActivity().mMyService.mMyFragment=null;
    }

    public void updateList() {
        runOnUiThread(new Runnable() {
            public void run() {
                //Update the list.
            }
        });
    }

    public void updateText() {
       //as above
    }
}

class MyOtherFragment extends Fragment {
             public void onResume() {
        super.onResume()
        //Assuming your activity bound to your service
        getActivity().mMyService.mMyOtherFragment=this;
    }

    public void onPause() {
        super.onPause()
        //Assuming your activity bound to your service
        getActivity().mMyService.mMyOtherFragment=null;
    }

    public void updateSomething() {//etc... }
}

Dejé algunos bits para la seguridad de los hilos, que es esencial. Asegúrese de usar bloqueos o algo así al verificar y usar o cambiar las referencias de fragmentos en el servicio.

Callback from service to activity to update UI.
ResultReceiver receiver = new ResultReceiver(new Handler()) {
    protected void onReceiveResult(int resultCode, Bundle resultData) {
        //process results or update UI
    }
}

Intent instructionServiceIntent = new Intent(context, InstructionService.class);
instructionServiceIntent.putExtra("receiver", receiver);
context.startService(instructionServiceIntent);

Puede que mi solución no sea la más limpia, pero debería funcionar sin problemas. La lógica es simplemente crear una variable estática para almacenar sus datos en el Servicey actualizar su vista cada segundo en su Activity.

Digamos que tiene un Stringen su Serviceque desea enviarlo a un TextViewen su Activity. Debe tener un aspecto como este

Tu servicio:

public class TestService extends Service {
    public static String myString = "";
    // Do some stuff with myString

Tu actividad:

public class TestActivity extends Activity {
    TextView tv;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        tv = new TextView(this);
        setContentView(tv);
        update();
        Thread t = new Thread() {
            @Override
            public void run() {
                try {
                    while (!isInterrupted()) {
                        Thread.sleep(1000);
                        runOnUiThread(new Runnable() {
                            @Override
                            public void run() {
                                update();
                            }
                        });
                    }
                } catch (InterruptedException ignored) {}
            }
        };
        t.start();
        startService(new Intent(this, TestService.class));
    }
    private void update() {
        // update your interface here
        tv.setText(TestService.myString);
    }
}