Exemple: communication entre l'activité et le service à l'aide de la messagerie

584

Je n'ai trouvé aucun exemple sur la façon d'envoyer des messages entre une activité et un service, et j'ai passé beaucoup trop d'heures à comprendre cela. Voici un exemple de projet que d'autres pourront consulter.

Cet exemple vous permet de démarrer ou d'arrêter un service directement, et de lier / dissocier séparément le service. Lorsque le service est en cours d'exécution, il incrémente un nombre à 10 Hz. Si l'activité est liée à la Service, elle affichera la valeur actuelle. Les données sont transférées sous forme d'entier et de chaîne afin que vous puissiez voir comment procéder de deux manières différentes. Il existe également des boutons dans l'activité pour envoyer des messages au service (modifie la valeur d'incrémentation).

Capture d'écran:

Capture d'écran de l'exemple de messagerie de service Android

AndroidManifest.xml:

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="com.exampleservice"
      android:versionCode="1"
      android:versionName="1.0">
    <application android:icon="@drawable/icon" android:label="@string/app_name">
        <activity android:name=".MainActivity"
                  android:label="@string/app_name">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    <service android:name=".MyService"></service>
    </application>
    <uses-sdk android:minSdkVersion="8" />
</manifest>

res \ values ​​\ strings.xml:

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="app_name">ExampleService</string>
    <string name="service_started">Example Service started</string>
    <string name="service_label">Example Service Label</string>
</resources>

res \ layout \ main.xml:

<RelativeLayout
    android:id="@+id/RelativeLayout01"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content" >

    <Button
        android:id="@+id/btnStart"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Start Service" >
    </Button>

    <Button
        android:id="@+id/btnStop"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignParentRight="true"
        android:text="Stop Service" >
    </Button>
</RelativeLayout>

<RelativeLayout
    android:id="@+id/RelativeLayout02"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content" >

    <Button
        android:id="@+id/btnBind"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Bind to Service" >
    </Button>

    <Button
        android:id="@+id/btnUnbind"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignParentRight="true"
        android:text="Unbind from Service" >
    </Button>
</RelativeLayout>

<TextView
    android:id="@+id/textStatus"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:text="Status Goes Here"
    android:textSize="24sp" />

<TextView
    android:id="@+id/textIntValue"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:text="Integer Value Goes Here"
    android:textSize="24sp" />

<TextView
    android:id="@+id/textStrValue"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:text="String Value Goes Here"
    android:textSize="24sp" />

<RelativeLayout
    android:id="@+id/RelativeLayout03"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content" >

    <Button
        android:id="@+id/btnUpby1"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Increment by 1" >
    </Button>

    <Button
        android:id="@+id/btnUpby10"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignParentRight="true"
        android:text="Increment by 10" >
    </Button>
</RelativeLayout>

src \ com.exampleservice \ MainActivity.java:

package com.exampleservice;

import android.app.Activity;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import android.os.Messenger;
import android.os.RemoteException;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.TextView;

public class MainActivity extends Activity {
    Button btnStart, btnStop, btnBind, btnUnbind, btnUpby1, btnUpby10;
    TextView textStatus, textIntValue, textStrValue;
    Messenger mService = null;
    boolean mIsBound;
    final Messenger mMessenger = new Messenger(new IncomingHandler());

    class IncomingHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
            case MyService.MSG_SET_INT_VALUE:
                textIntValue.setText("Int Message: " + msg.arg1);
                break;
            case MyService.MSG_SET_STRING_VALUE:
                String str1 = msg.getData().getString("str1");
                textStrValue.setText("Str Message: " + str1);
                break;
            default:
                super.handleMessage(msg);
            }
        }
    }
    private ServiceConnection mConnection = new ServiceConnection() {
        public void onServiceConnected(ComponentName className, IBinder service) {
            mService = new Messenger(service);
            textStatus.setText("Attached.");
            try {
                Message msg = Message.obtain(null, MyService.MSG_REGISTER_CLIENT);
                msg.replyTo = mMessenger;
                mService.send(msg);
            }
            catch (RemoteException e) {
                // In this case the service has crashed before we could even do anything with it
            }
        }

        public void onServiceDisconnected(ComponentName className) {
            // This is called when the connection with the service has been unexpectedly disconnected - process crashed.
            mService = null;
            textStatus.setText("Disconnected.");
        }
    };

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        btnStart = (Button)findViewById(R.id.btnStart);
        btnStop = (Button)findViewById(R.id.btnStop);
        btnBind = (Button)findViewById(R.id.btnBind);
        btnUnbind = (Button)findViewById(R.id.btnUnbind);
        textStatus = (TextView)findViewById(R.id.textStatus);
        textIntValue = (TextView)findViewById(R.id.textIntValue);
        textStrValue = (TextView)findViewById(R.id.textStrValue);
        btnUpby1 = (Button)findViewById(R.id.btnUpby1);
        btnUpby10 = (Button)findViewById(R.id.btnUpby10);

        btnStart.setOnClickListener(btnStartListener);
        btnStop.setOnClickListener(btnStopListener);
        btnBind.setOnClickListener(btnBindListener);
        btnUnbind.setOnClickListener(btnUnbindListener);
        btnUpby1.setOnClickListener(btnUpby1Listener);
        btnUpby10.setOnClickListener(btnUpby10Listener);

        restoreMe(savedInstanceState);

        CheckIfServiceIsRunning();
    }

    @Override
    protected void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        outState.putString("textStatus", textStatus.getText().toString());
        outState.putString("textIntValue", textIntValue.getText().toString());
        outState.putString("textStrValue", textStrValue.getText().toString());
    }
    private void restoreMe(Bundle state) {
        if (state!=null) {
            textStatus.setText(state.getString("textStatus"));
            textIntValue.setText(state.getString("textIntValue"));
            textStrValue.setText(state.getString("textStrValue"));
        }
    }
    private void CheckIfServiceIsRunning() {
        //If the service is running when the activity starts, we want to automatically bind to it.
        if (MyService.isRunning()) {
            doBindService();
        }
    }

    private OnClickListener btnStartListener = new OnClickListener() {
        public void onClick(View v){
            startService(new Intent(MainActivity.this, MyService.class));
        }
    };
    private OnClickListener btnStopListener = new OnClickListener() {
        public void onClick(View v){
            doUnbindService();
            stopService(new Intent(MainActivity.this, MyService.class));
        }
    };
    private OnClickListener btnBindListener = new OnClickListener() {
        public void onClick(View v){
            doBindService();
        }
    };
    private OnClickListener btnUnbindListener = new OnClickListener() {
        public void onClick(View v){
            doUnbindService();
        }
    };
    private OnClickListener btnUpby1Listener = new OnClickListener() {
        public void onClick(View v){
            sendMessageToService(1);
        }
    };
    private OnClickListener btnUpby10Listener = new OnClickListener() {
        public void onClick(View v){
            sendMessageToService(10);
        }
    };
    private void sendMessageToService(int intvaluetosend) {
        if (mIsBound) {
            if (mService != null) {
                try {
                    Message msg = Message.obtain(null, MyService.MSG_SET_INT_VALUE, intvaluetosend, 0);
                    msg.replyTo = mMessenger;
                    mService.send(msg);
                }
                catch (RemoteException e) {
                }
            }
        }
    }


    void doBindService() {
        bindService(new Intent(this, MyService.class), mConnection, Context.BIND_AUTO_CREATE);
        mIsBound = true;
        textStatus.setText("Binding.");
    }
    void doUnbindService() {
        if (mIsBound) {
            // If we have received the service, and hence registered with it, then now is the time to unregister.
            if (mService != null) {
                try {
                    Message msg = Message.obtain(null, MyService.MSG_UNREGISTER_CLIENT);
                    msg.replyTo = mMessenger;
                    mService.send(msg);
                }
                catch (RemoteException e) {
                    // There is nothing special we need to do if the service has crashed.
                }
            }
            // Detach our existing connection.
            unbindService(mConnection);
            mIsBound = false;
            textStatus.setText("Unbinding.");
        }
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        try {
            doUnbindService();
        }
        catch (Throwable t) {
            Log.e("MainActivity", "Failed to unbind from the service", t);
        }
    }
}

src \ com.exampleservice \ MyService.java:

package com.exampleservice;

import java.util.ArrayList;
import java.util.Timer;
import java.util.TimerTask;

import android.app.Notification;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.app.Service;
import android.content.Intent;
import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import android.os.Messenger;
import android.os.RemoteException;
import android.util.Log;

public class MyService extends Service {
    private NotificationManager nm;
    private Timer timer = new Timer();
    private int counter = 0, incrementby = 1;
    private static boolean isRunning = false;

    ArrayList<Messenger> mClients = new ArrayList<Messenger>(); // Keeps track of all current registered clients.
    int mValue = 0; // Holds last value set by a client.
    static final int MSG_REGISTER_CLIENT = 1;
    static final int MSG_UNREGISTER_CLIENT = 2;
    static final int MSG_SET_INT_VALUE = 3;
    static final int MSG_SET_STRING_VALUE = 4;
    final Messenger mMessenger = new Messenger(new IncomingHandler()); // Target we publish for clients to send messages to IncomingHandler.


    @Override
    public IBinder onBind(Intent intent) {
        return mMessenger.getBinder();
    }
    class IncomingHandler extends Handler { // Handler of incoming messages from clients.
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
            case MSG_REGISTER_CLIENT:
                mClients.add(msg.replyTo);
                break;
            case MSG_UNREGISTER_CLIENT:
                mClients.remove(msg.replyTo);
                break;
            case MSG_SET_INT_VALUE:
                incrementby = msg.arg1;
                break;
            default:
                super.handleMessage(msg);
            }
        }
    }
    private void sendMessageToUI(int intvaluetosend) {
        for (int i=mClients.size()-1; i>=0; i--) {
            try {
                // Send data as an Integer
                mClients.get(i).send(Message.obtain(null, MSG_SET_INT_VALUE, intvaluetosend, 0));

                //Send data as a String
                Bundle b = new Bundle();
                b.putString("str1", "ab" + intvaluetosend + "cd");
                Message msg = Message.obtain(null, MSG_SET_STRING_VALUE);
                msg.setData(b);
                mClients.get(i).send(msg);

            }
            catch (RemoteException e) {
                // The client is dead. Remove it from the list; we are going through the list from back to front so this is safe to do inside the loop.
                mClients.remove(i);
            }
        }
    }

    @Override
    public void onCreate() {
        super.onCreate();
        Log.i("MyService", "Service Started.");
        showNotification();
        timer.scheduleAtFixedRate(new TimerTask(){ public void run() {onTimerTick();}}, 0, 100L);
        isRunning = true;
    }
    private void showNotification() {
        nm = (NotificationManager)getSystemService(NOTIFICATION_SERVICE);
        // In this sample, we'll use the same text for the ticker and the expanded notification
        CharSequence text = getText(R.string.service_started);
        // Set the icon, scrolling text and timestamp
        Notification notification = new Notification(R.drawable.icon, text, System.currentTimeMillis());
        // The PendingIntent to launch our activity if the user selects this notification
        PendingIntent contentIntent = PendingIntent.getActivity(this, 0, new Intent(this, MainActivity.class), 0);
        // Set the info for the views that show in the notification panel.
        notification.setLatestEventInfo(this, getText(R.string.service_label), text, contentIntent);
        // Send the notification.
        // We use a layout id because it is a unique number.  We use it later to cancel.
        nm.notify(R.string.service_started, notification);
    }
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.i("MyService", "Received start id " + startId + ": " + intent);
        return START_STICKY; // run until explicitly stopped.
    }

    public static boolean isRunning()
    {
        return isRunning;
    }


    private void onTimerTick() {
        Log.i("TimerTick", "Timer doing work." + counter);
        try {
            counter += incrementby;
            sendMessageToUI(counter);

        }
        catch (Throwable t) { //you should always ultimately catch all exceptions in timer tasks.
            Log.e("TimerTick", "Timer Tick Failed.", t);
        }
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        if (timer != null) {timer.cancel();}
        counter=0;
        nm.cancel(R.string.service_started); // Cancel the persistent notification.
        Log.i("MyService", "Service Stopped.");
        isRunning = false;
    }
}
Lance Lefebure
la source
53
Excellent exemple! Une autre fonctionnalité intéressante: si vous mettez un android:process=:myservicenameattribut à la servicebalise de votre service dans votre manifest.xml, comme:, <service android:name="sname" android:process=":myservicename" />alors il exécutera votre service comme un processus différent - donc dans un thread différent. Cela signifie que tout calcul lourd effectué / demande longue par le service ne bloquera pas votre thread d'interface utilisateur.
sydd
28
Je sais que vous avez pris l'effort de le faire, mais il serait plus logique de le mettre sur github ou sur un site de partage de code source similaire et de publier le lien ici. Il est plus facile pour les gens de le faire fonctionner de cette façon.
Ehtesh Choudhury
25
Bon exemple. J'ai mis ce code sur un dépôt en ligne (avec des modifications mineures) pour ceux qui voudraient cloner: bitbucket.org/alexfu/androidserviceexample/src
Alex Fu
7
La messagerie n'est vraiment nécessaire que si votre service peut être appelé par d'autres applications. Sinon, vous pouvez vous en tenir à un classeur qui vous renvoie une référence au Service et appeler simplement des méthodes publiques de celui-ci.
type-a1pha
13
Vous auriez dû poser la question et ensuite créer une réponse vous-même, et non pas répondre au problème sur la question. Bon exemple cependant;)
7hi4g0

Réponses:

46

Regardez l' exemple LocalService .

Votre Serviceretourne une instance d'elle-même aux consommateurs qui appellent onBind. Ensuite, vous pouvez interagir directement avec le service, par exemple en enregistrant votre propre interface d'écoute avec le service, afin de pouvoir recevoir des rappels.

Christopher Orr
la source
2
Le seul problème avec cela est qu'il n'utiliserait pas un Messenger, donc il ne répondrait pas à cette pseudo-question. J'ai utilisé un LocalService, mais j'étais heureux de trouver un exemple de Messenger / Handler. Je ne crois pas qu'un LocalService puisse être mis dans un autre processus.
Ben
@ Christoper-Orr: Je suis très reconnaissant d'avoir publié ce lien du Android BroadcastReceivertutoriel. J'ai utilisé un LocalBroadcastManagerpour échanger en continu des données entre deux Activityinstances.
Dirk
Le problème LocalBroadcastManagerest qu'il n'est pas bloquant et que vous devez attendre les résultats. Parfois, vous voulez des résultats immédiats.
TheRealChx101
Pouvez-vous s'il vous plaît m'aider avec cette question stackoverflow.com/questions/51508046/…
Rajesh K
20

Pour envoyer des données à un service, vous pouvez utiliser:

Intent intent = new Intent(getApplicationContext(), YourService.class);
intent.putExtra("SomeData","ItValue");
startService(intent);

Et après la mise en service dans onStartCommand (), obtenez les données de l'intention.

Pour envoyer des données ou un événement d'un service vers une application (pour une ou plusieurs activités):

private void sendBroadcastMessage(String intentFilterName, int arg1, String extraKey) {
    Intent intent = new Intent(intentFilterName);
    if (arg1 != -1 && extraKey != null) {
        intent.putExtra(extraKey, arg1);
    }
    sendBroadcast(intent);
}

Cette méthode appelle depuis votre service. Vous pouvez simplement envoyer des données pour votre activité.

private void someTaskInYourService(){

    //For example you downloading from server 1000 files
    for(int i = 0; i < 1000; i++) {
        Thread.sleep(5000) // 5 seconds. Catch in try-catch block
        sendBroadCastMessage(Events.UPDATE_DOWNLOADING_PROGRESSBAR, i,0,"up_download_progress");
    }

Pour recevoir un événement avec des données, créez et enregistrez la méthode registerBroadcastReceivers () dans votre activité:

private void registerBroadcastReceivers(){
    broadcastReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            int arg1 = intent.getIntExtra("up_download_progress",0);
            progressBar.setProgress(arg1);
        }
    };
    IntentFilter progressfilter = new IntentFilter(Events.UPDATE_DOWNLOADING_PROGRESS);
    registerReceiver(broadcastReceiver,progressfilter);

Pour envoyer plus de données, vous pouvez modifier la méthode sendBroadcastMessage();. N'oubliez pas: vous devez enregistrer les diffusions dans les méthodes onResume () et vous désinscrire dans les méthodes onStop ()!

MISE À JOUR

Veuillez ne pas utiliser mon type de communication entre Activity & Service. C'est la mauvaise façon. Pour une meilleure expérience, veuillez utiliser des bibliothèques spéciales, telles que nous:

1) EventBus de greenrobot

2) Otto de Square Inc

PS J'utilise uniquement EventBus de greenrobot dans mes projets,

a.black13
la source
2
où dois-je avoir besoin d'enregistrer le récepteur dans onResume et dans onStop dois-je faire en activité?
user3233280
Oui. Pour recevoir un événement du service, vous devez vous inscrire à la diffusion sur onResume. N'oubliez pas que vous devez désinscrire la diffusion dans onStop. Maintenant, je ne recommande pas d'utiliser ma méthode. Veuillez utiliser des bibliothèques spéciales pour communiquer avec d'autres vues / activités / services tels que EventBus github.com/greenrobot/EventBus ou Otto github.com/square/otto
a.black13
1
les u pls peuvent-ils m'aider comment puis-je utiliser cela je suis coincé dans mon projet dans la communication de service
user3233280
8
Google a-t-il déconseillé cela, ou dites-vous simplement que c'est "faux" parce que vous pensez que les autres solutions sont meilleures?
Kevin Krumwiede
plus un pour fournir des liens vers EventBuset Otto.
Mohammed Ali
14

Remarque: Vous n'avez pas besoin de vérifier si votre service est en cours d'exécution CheckIfServiceIsRunning(), car bindService()le démarrera s'il ne fonctionne pas.

Aussi: si vous faites pivoter le téléphone, vous ne le voulez bindService()plus, car onCreate()il sera rappelé. Assurez-vous de définir onConfigurationChanged()pour éviter cela.

Quelqu'un quelque part
la source
Dans mon cas, je n'ai pas besoin que le service fonctionne tout le temps. Si le service est déjà en cours d'exécution au démarrage de l'activité, je souhaite m'y connecter. Si le service n'est pas en cours d'exécution au début de l'activité, je souhaite laisser le service arrêté.
Lance Lefebure
1
Je ne suis pas sûr que ce soit vrai, bindService ne démarre pas le service, pouvez-vous s'il vous plaît pointer vers la documentation?
Calin
1
developer.android.com/reference/android/app/Service.html Le premier paragraphe déclareServices can be started with Context.startService() and Context.bindService()
Quelqu'un Quelque part
8
Message msg = Message.obtain(null, 2, 0, 0);
                    Bundle bundle = new Bundle();
                    bundle.putString("url", url);
                    bundle.putString("names", names);
                    bundle.putString("captions",captions); 
                    msg.setData(bundle);

Vous l'envoyez donc au service. Recevez ensuite.

user1964369
la source
8

Tout va bien. Bon exemple de activity/servicecommunication avec Messenger .

Un commentaire: la méthode MyService.isRunning()n'est pas obligatoire .. bindService()peut être effectuée un nombre illimité de fois. aucun mal à cela.

Si MyService s'exécute dans un processus différent, la fonction statique MyService.isRunning()renvoie toujours false. Il n'y a donc pas besoin de cette fonction.

Ishank Gupta
la source
2

C'est comme ça que j'ai implémenté Activity-> Service Communication: sur mon Activity j'avais

private static class MyResultReciever extends ResultReceiver {
     /**
     * Create a new ResultReceive to receive results.  Your
     * {@link #onReceiveResult} method will be called from the thread running
     * <var>handler</var> if given, or from an arbitrary thread if null.
     *
     * @param handler
     */
     public MyResultReciever(Handler handler) {
         super(handler);
     }

     @Override
     protected void onReceiveResult(int resultCode, Bundle resultData) {
         if (resultCode == 100) {
             //dostuff
         }
     }

Et puis je l'ai utilisé pour démarrer mon service

protected void onCreate(Bundle savedInstanceState) {
MyResultReciever resultReciever = new MyResultReciever(handler);
        service = new Intent(this, MyService.class);
        service.putExtra("receiver", resultReciever);
        startService(service);
}

Dans mon service j'avais

public int onStartCommand(Intent intent, int flags, int startId) {
    if (intent != null)
        resultReceiver = intent.getParcelableExtra("receiver");
    return Service.START_STICKY;
}

J'espère que cela t'aides

ketrox
la source
0

Il me semble que vous auriez pu économiser de la mémoire en déclarant votre activité avec "implements Handler.Callback"

Quasaur
la source
0

Grand tutoriel, présentation fantastique. Neat, simple, court et très explicatif. Bien que la notification.setLatestEventInfo(this, getText(R.string.service_label), text, contentIntent);méthode ne soit plus. Comme l'a déclaré Trante ici , une bonne approche serait:

private static final int NOTIFICATION_ID = 45349;

private void showNotification() {
    NotificationCompat.Builder builder =
            new NotificationCompat.Builder(this)
                    .setSmallIcon(R.mipmap.ic_launcher)
                    .setContentTitle("My Notification Title")
                    .setContentText("Something interesting happened");

    Intent targetIntent = new Intent(this, MainActivity.class);
    PendingIntent contentIntent = PendingIntent.getActivity(this, 0, targetIntent, PendingIntent.FLAG_UPDATE_CURRENT);
    builder.setContentIntent(contentIntent);
    _nManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
    _nManager.notify(NOTIFICATION_ID, builder.build());
}

@Override
public void onDestroy() {
    super.onDestroy();
    if (_timer != null) {_timer.cancel();}
    _counter=0;
    _nManager.cancel(NOTIFICATION_ID); // Cancel the persistent notification.
    Log.i("PlaybackService", "Service Stopped.");
    _isRunning = false;
}

Vérifié moi-même, tout fonctionne comme un charme (les noms des activités et des services peuvent différer de l'original).

peau verte
la source
0

J'ai vu toutes les réponses. Je veux dire le moyen le plus robuste maintenant un jour . Cela vous fera communiquer entre Activity - Service - Dialog - Fragments(Tout).

EventBus

Cette bibliothèque que j'utilise dans mes projets a de grandes fonctionnalités liées à la messagerie.

EventBus en 3 étapes

  1. Définissez les événements:

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

  2. Préparez les abonnés:

Déclarez et annotez votre méthode d'abonnement, spécifiez éventuellement un mode de thread :

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

Enregistrez et désinscrivez votre abonné. Par exemple sur Android, les activités et les fragments doivent généralement s'inscrire en fonction de leur cycle de vie:

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

@Override
public void onStop() {
    super.onStop();
    EventBus.getDefault().unregister(this);
}
  1. Afficher les événements:

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

Ajoutez simplement cette dépendance dans le niveau de votre application

compile 'org.greenrobot:eventbus:3.1.1'
Khemraj
la source