Interface utilisateur de l'activité de mise à jour Android du service

J'ai un service qui vérifie en permanence les nouvelles tâches. S'il y a une nouvelle tâche, je souhaite actualiser l'interface utilisateur de l'activité pour afficher ces informations. J'ai trouvé https://github.com/commonsguy/cw-andtutorials/tree/master/18-LocalService/ cet exemple. Est-ce une bonne approche? D'autres exemples?

Merci.

Voir ci-dessous ma réponse originale - ce modèle a bien fonctionné, mais récemment, j'ai commencé à utiliser une approche différente de la communication Service / Activité:

• Utilisez un service lié qui permet à l'activité d'obtenir une référence directe au service, permettant ainsi des appels directs dessus, plutôt que d'utiliser des intentions.

• Utilisez RxJava pour exécuter des opérations asynchrones.

• Si le service doit continuer les opérations en arrière-plan même lorsqu'aucune activité n'est en cours d'exécution, démarrez également le service à partir de la classe Application afin qu'il ne soit pas arrêté lorsqu'il n'est pas lié.

Les avantages que j'ai trouvés dans cette approche par rapport à la technique startService () / LocalBroadcast sont

• Pas besoin d'objets de données pour implémenter Parcelable - cela est particulièrement important pour moi car je partage maintenant du code entre Android et iOS (en utilisant RoboVM)
• RxJava fournit une planification prédéfinie (et multiplateforme) et une composition facile des opérations asynchrones séquentielles.
• Cela devrait être plus efficace que d'utiliser un LocalBroadcast, bien que la surcharge liée à l'utilisation de RxJava puisse l'emporter sur cela.

Quelques exemples de code. D'abord le service:

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

Et une activité qui se lie au service et reçoit des mises à jour d'altitude pression:

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

La disposition de cette activité est:

<?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 le service doit s'exécuter en arrière-plan sans activité liée, il peut également être démarré à partir de la classe Application en OnCreate()utilisant Context#startService().

Ma réponse originale (à partir de 2013):

Dans votre service: (en utilisant COPA comme service dans l'exemple ci-dessous).

Utilisez un LocalBroadCastManager. Dans onCreate de votre service, configurez le diffuseur:

broadcaster = LocalBroadcastManager.getInstance(this);

Lorsque vous souhaitez informer l'interface utilisateur de quelque chose:

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

Dans votre activité:

Créez un auditeur sur 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.
        }
    };
}

et enregistrez-le dans 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();
}

pour moi la solution la plus simple était d'envoyer une diffusion, dans l'activité oncreate, j'ai enregistré et défini la diffusion comme ceci (updateUIReciver est défini comme une instance de classe):

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

Et à partir du service, vous envoyez l'intention comme ceci:

Intent local = new Intent();

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

this.sendBroadcast(local);

n'oubliez pas de désenregistrer la récupération dans l'activité sur destroy:

unregisterReceiver(updateUIReciver);

J'utiliserais un service lié pour le faire et communiquerais avec lui en implémentant un auditeur dans mon activité. Donc, si votre application implémente myServiceListener, vous pouvez l'enregistrer en tant qu'auditeur dans votre service après vous être lié avec elle, appelez listener.onUpdateUI à partir de votre service lié et mettez à jour votre interface utilisateur!

Je recommanderais de consulter Otto , un EventBus spécialement conçu pour Android. Votre activité / interface utilisateur peut écouter les événements publiés sur le bus à partir du service et se dissocier du backend.

La solution de Clyde fonctionne, mais c'est une diffusion, ce qui, j'en suis sûr, sera moins efficace que d'appeler directement une méthode. Je peux me tromper, mais je pense que les diffusions sont davantage destinées à la communication inter-applications.

Je suppose que vous savez déjà comment lier un service à une activité. Je fais quelque chose comme le code ci-dessous pour gérer ce genre de problème:

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... }
}

J'ai omis des bits pour la sécurité des threads, ce qui est essentiel. Assurez-vous d'utiliser des verrous ou quelque chose du genre lors de la vérification et de l'utilisation ou de la modification des références de fragment sur le service.

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

Ma solution n'est peut-être pas la plus propre, mais elle devrait fonctionner sans problème. La logique consiste simplement à créer une variable statique pour stocker vos données sur le Serviceet mettre à jour votre vue chaque seconde sur votre Activity.

Disons que vous avez un Stringsur votre Serviceque vous souhaitez envoyer à un TextViewsur votre Activity. ça devrait ressembler à ça

Ton service:

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

Votre activité:

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