How to have Android Service communicate with Activity

Question

I m writing my first Android application and trying to get my head around communication between services and activities  I have a Service that will run in the background and do some gps and time based logging  I will have an Activity that will be used to start and stop the Service    So first  I need to be able to figure out if the Service is running when the Activity is started  There are some other questions here about that  so I think I can figure that out  but feel free to offer advice    My real problem  if the Activity is running and the Service is started  I need a way for the Service to send messages to the Activity  Simple Strings and integers at this point - status messages mostly  The messages will not happen regularly  so I don t think polling the service is a good way to go if there is another way  I only want this communication when the Activity has been started by the user - I don t want to start the Activity from the Service  In other words  if you start the Activity and the Service is running  you will see some status messages in the Activity UI when something interesting happens  If you don t start the Activity  you will not see these messages  they re not that interesting    It seems like I should be able to determine if the Service is running  and if so  add the Activity as a listener  Then remove the Activity as a listener when the Activity pauses or stops  Is that actually possible  The only way I can figure out to do it is to have the Activity implement Parcelable and build an AIDL file so I can pass it through the Service s remote interface  That seems like overkill though  and I have no idea how the Activity should implement writeToParcel     readFromParcel     Is there an easier or better way  Thanks for any help   EDIT    For anyone who s interested in this later on  there is sample code from Google for handling this via AIDL in the samples directory   apis app RemoteService java

User · Accepted Answer

There are three obvious ways to communicate with services:

Using Intents
Using AIDL
Using the service object itself (as singleton)

In your case, I'd go with option 3. Make a static reference to the service it self and populate it in onCreate():

void onCreate(Intent i) {
  sInstance = this;
}

Make a static function MyService getInstance(), which returns the static sInstance.

Then in Activity.onCreate() you start the service, asynchronously wait until the service is actually started (you could have your service notify your app it's ready by sending an intent to the activity.) and get its instance. When you have the instance, register your service listener object to you service and you are set. NOTE: when editing Views inside the Activity you should modify them in the UI thread, the service will probably run its own Thread, so you need to call Activity.runOnUiThread().

The last thing you need to do is to remove the reference to you listener object in Activity.onPause(), otherwise an instance of your activity context will leak, not good.

NOTE: This method is only useful when your application/Activity/task is the only process that will access your service. If this is not the case you have to use option 1. or 2.

User · Answer

As mentioned by Madhur  you can use a bus for communication   In case of using a Bus you have some options   Otto event Bus library  deprecated in favor of RxJava   http   square github io otto   Green Robot   s EventBus  http   greenrobot org eventbus   NYBus  RxBus  implemented using RxJava  very similar to the EventBus   https   github com MindorksOpenSource NYBus

User · Answer

Using a Messenger is another simple way to communicate between a Service and an Activity   In the Activity  create a Handler with a corresponding Messenger  This will handle messages from your Service   class ResponseHandler extends Handler        Override public void handleMessage Message message                Toast makeText this   message from service                       Toast LENGTH SHORT  show            Messenger messenger   new Messenger new ResponseHandler       The Messenger can be passed to the service by attaching it to a Message   Message message   Message obtain null  MyService ADD RESPONSE HANDLER   message replyTo   messenger  try       myService send message   catch  RemoteException e        e printStackTrace        A full example can be found in the API demos  MessengerService and MessengerServiceActivity  Refer to the full example for how MyService works

User · Answer

Another way could be using observers with a fake model class through the activity and the service itself  implementing an MVC pattern variation  I don t know if it s the best way to accomplish this  but it s the way that worked for me  If you need some example ask for it and i ll post something

User · Answer

The other method that s not mentioned in the other comments is to bind to the service from the activity using bindService   and get an instance of the service in the ServiceConnection callback  As described here http   developer android com guide components bound-services html

User · Answer

Binding is another way to communicate  Create a callback  public interface MyCallBack      public void getResult String result        Activity side    Implement the interface in the Activity  Provide the implementation for the method  Bind the Activity to Service  Register and Unregister Callback when the Service gets bound and unbound with Activity  public class YourActivity extends AppCompatActivity implements MyCallBack         private Intent notifyMeIntent        private GPSService gpsService        private boolean bound   false          Override       public void onCreate Bundle sis                 activity code                startGPSService                     Override       public void getResult String result             show in textView textView setText result                   Override       protected void onStart                     super onStart              bindService                    Override       protected void onStop               super onStop              unbindService                   private ServiceConnection serviceConnection   new ServiceConnection                   Override             public void onServiceConnected ComponentName className  IBinder service                       GPSService GPSBinder binder    GPSService GPSBinder  service                    gpsService  binder getService                      bound   true                    gpsService registerCallBack YourActivity this      register                            Override            public void onServiceDisconnected ComponentName arg0                      bound   false                               private void bindService                 bindService notifyMeIntent  serviceConnection  Context BIND AUTO CREATE                  private void unbindService               if  bound                     gpsService registerCallBack null      unregister                              unbindService serviceConnection                    bound   false                                  Call this method somewhere to start Your GPSService       private void startGPSService               notifyMeIntent   new Intent this  GPSService class              startService myIntent                    Service Side    Initialize callback  Invoke the callback method whenever needed  public class GPSService extends Service        private MyCallBack myCallback       private IBinder serviceBinder   new GPSBinder          public void registerCallBack MyCallBack myCallback             this myCallback  myCallback               public class GPSBinder extends Binder            public GPSService getService                  return GPSService this                         Nullable      Override     public IBinder onBind Intent intent            return serviceBinder

User · Answer

Use LocalBroadcastManager to register a receiver to listen for a broadcast sent from local service inside your app  reference goes here   http   developer android com reference android support v4 content LocalBroadcastManager html

User · Answer

To follow up on  MrSnowflake answer with a code example  This is the XABBER now open source Application class  The Application class is centralising and coordinating Listeners and ManagerInterfaces and more  Managers of all sorts are dynamically loaded  Activity  s started in the Xabber will report in what type of Listener they are  And when a Service start it report in to the Application class as started  Now to send a message to an Activity all you have to do is make your Activity become a listener of what type you need  In the OnStart   OnPause   register unreg  The Service can ask the Application class for just that listener it need to speak to and if it s there then the Activity is ready to receive    Going through the Application class you ll see there s a loot more going on then this

User · Answer

My method   Class to manage send and receive message from to service activity   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 java util ArrayList  import java util List   public class MessageManager        public interface IOnHandleMessage             Messages         int MSG HANDSHAKE   0x1           void onHandleMessage Message msg              private static final String LOGCAT   MessageManager class getSimpleName         private Messenger mMsgSender      private Messenger mMsgReceiver      private List lt Message gt  mMessages       public MessageManager IOnHandleMessage callback  IBinder target           mMsgReceiver   new Messenger new MessageHandler callback  MessageHandler TYPE ACTIVITY            mMsgSender   new Messenger target           mMessages   new ArrayList lt  gt                public MessageManager IOnHandleMessage callback           mMsgReceiver   new Messenger new MessageHandler callback  MessageHandler TYPE SERVICE            mMsgSender   null          mMessages   new ArrayList lt  gt                   START Getter  amp  Setter Methods        public Messenger getMsgSender             return mMsgSender             public void setMsgSender Messenger sender            this mMsgSender   sender             public Messenger getMsgReceiver             return mMsgReceiver             public void setMsgReceiver Messenger receiver            this mMsgReceiver   receiver             public List lt Message gt  getLastMessages             return mMessages             public void addMessage Message message            this mMessages add message                END Getter  amp  Setter Methods            START Public Methods        public void sendMessage int what  int arg1  int arg2  Bundle msgData           if mMsgSender    null  amp  amp  mMsgReceiver    null                try                   Message msg   Message obtain null  what  arg1  arg2                   msg replyTo   mMsgReceiver                  if msgData    null                       msg setData msgData                                     mMsgSender send msg                 catch  RemoteException rE                    onException rE                                      public void sendHandshake            if mMsgSender    null  amp  amp  mMsgReceiver    null               sendMessage IOnHandleMessage MSG HANDSHAKE  0  0  null                          END Public Methods            START Private Methods        private void onException Exception e           Log e LOGCAT  e getMessage             e printStackTrace                 END Private Methods             START Private Classes         private class MessageHandler extends Handler               Types         final static int TYPE SERVICE   0x1          final static int TYPE ACTIVITY   0x2           private IOnHandleMessage mCallback          private int mType           public MessageHandler IOnHandleMessage callback  int type               mCallback   callback              mType   type                      Override         public void handleMessage Message msg               addMessage msg               switch msg what                   case IOnHandleMessage MSG HANDSHAKE                      switch mType                           case TYPE SERVICE                              setMsgSender msg replyTo                               sendHandshake                                break                          case TYPE ACTIVITY                              Log v LOGCAT   HERE                                break                                            break                  default                      if mCallback    null                           mCallback onHandleMessage msg                                             break                                         END Private Classes          In Activity Example   public class activity extends AppCompatActivity       implements     ServiceConnection                       MessageManager IOnHandleMessage                     private MessageManager mMessenger       private void initMyMessenger IBinder iBinder           mMessenger   new MessageManager this  iBinder           mMessenger sendHandshake               private void bindToService            Intent intent   new Intent this  TagScanService class           bindService intent  mServiceConnection  Context BIND AUTO CREATE              START THE SERVICE IF NEEDED               private void unbindToService           UNBIND when you want  onDestroy  after operation             if mBound                unbindService mServiceConnection               mBound   false                          START Override MessageManager IOnHandleMessage Methods         Override     public void onHandleMessage Message msg            switch msg what               case Constants MSG SYNC PROGRESS                  Bundle data   msg getData                    String text   data getString Constants KEY MSG TEXT                   setMessageProgress text                   break              case Constants MSG START SYNC                  onStartSync                    break              case Constants MSG END SYNC                  onEndSync msg arg1    Constants ARG1 SUCCESS                   mBound   false                  break                         END Override MessageManager IOnHandleMessage Methods             START Override ServiceConnection Methods         private class BLEScanServiceConnection implements ServiceConnection             Override         public void onServiceConnected ComponentName componentName  IBinder iBinder                initMyMessenger iBinder               mBound   true                      Override         public void onServiceDisconnected ComponentName componentName                mMessenger   null              mBound   false                          END Override ServiceConnection Methods       In Service Example   public class Blablabla extends Service     implements     MessageManager IOnHandleMessage                   private MessageManager mMessenger        Nullable      Override     public IBinder onBind Intent intent            super onBind intent           initMessageManager            return mMessenger getMsgReceiver   getBinder               private void initMessageManager            mMessenger   new MessageManager this                 START Override IOnHandleMessage Methods         Override     public void onHandleMessage Message msg           Do what you want when u get a message looking the  what  attribute                 END Override IOnHandleMessage Methods      Send a message from Activity   Service   mMessenger sendMessage what  arg1  arg2  dataBundle     How this works   on the activity you start or bind the service  The service  OnBind  methods return the Binder to his MessageManager  the in the Activity through the  Service Connection  interface methods implementation  OnServiceConnected  you get this IBinder and init you MessageManager using it  After the Activity has init his MessageManager the MessageHandler send and Handshake to the service so it can set his  MessageHandler  sender   the  private Messenger mMsgSender   in MessageManager    Doing this the service know to who send his messages   You can also implement this using a List Queue of Messenger  sender  in the MessageManager so you can send multiple messages to different Activities Services or you can use a List Queue of Messenger  receiver  in the MessageManager so you can receive multiple message from different Activities Services   In the  MessageManager  instance you have a list of all messages received   As you can see the connection between  Activity s Messenger  and  Service Messenger  using this  MessageManager  instance is automatic  it is done through the  OnServiceConnected  method and through the use of the  Handshake    Hope this is helpful for you       Thank you very much  Bye  D

User · Answer

The asker has probably long since moved past this  but in case someone else searches for this     There s another way to handle this  which I think might be the simplest   Add a BroadcastReceiver to your activity   Register it to receive some custom intent in onResume and unregister it in onPause   Then send out that intent from your service when you want to send out your status updates or what have you   Make sure you wouldn t be unhappy if some other app listened for your Intent  could anyone do anything malicious    but beyond that  you should be alright   Code sample was requested   In my service  I have this      Do stuff that alters the content of my local SQLite Database sendBroadcast new Intent RefreshTask REFRESH DATA INTENT       RefreshTask REFRESH DATA INTENT is just a constant string    In my listening activity  I define my BroadcastReceiver     private class DataUpdateReceiver extends BroadcastReceiver        Override     public void onReceive Context context  Intent intent            if  intent getAction   equals RefreshTask REFRESH DATA INTENT                  Do stuff - maybe update my view based on the changed DB contents                     I declare my receiver at the top of the class     private DataUpdateReceiver dataUpdateReceiver    I override onResume to add this   if  dataUpdateReceiver    null  dataUpdateReceiver   new DataUpdateReceiver    IntentFilter intentFilter   new IntentFilter RefreshTask REFRESH DATA INTENT   registerReceiver dataUpdateReceiver  intentFilter     And I override onPause to add     if  dataUpdateReceiver    null  unregisterReceiver dataUpdateReceiver     Now my activity is listening for my service to say  Hey  go update yourself    I could pass data in the Intent instead of updating database tables and then going back to find the changes within my activity  but since I want the changes to persist anyway  it makes sense to pass the data via DB

User · Answer

Besides  LocalBroadcastManager   Event Bus and Messenger already answered in this question we can use Pending Intent to communicate from service   As mentioned here in my blog post     Communication between service and Activity can be done using   PendingIntent For that we can use   createPendingResult   createPendingResult   creates a new   PendingIntent object which you can hand to service to use and to send   result data back to your activity inside onActivityResult int  int    Intent  callback Since a PendingIntent is Parcelable   and can   therefore be put into an Intent extra your activity can pass this   PendingIntent to the service The service  in turn  can call send     method on the PendingIntent to notify the activity via   onActivityResult of an event       Activity  public class PendingIntentActivity extends AppCompatActivity    Override protected void onCreate  Nullable Bundle savedInstanceState    super onCreate savedInstanceState   setContentView R layout activity main    PendingIntent pendingResult   createPendingResult  100  new Intent    0   Intent intent   new Intent getApplicationContext    PendingIntentService class   intent putExtra  pendingIntent   pendingResult   startService intent        Override protected void onActivityResult int requestCode  int resultCode  Intent data    if  requestCode    100  amp  amp  resultCode  200    Toast makeText this data getStringExtra  name   Toast LENGTH LONG  show      super onActivityResult requestCode  resultCode  data             Service  public class PendingIntentService extends Service        private static final String   items     lorem    ipsum    dolor                sit    amet    consectetuer    adipiscing    elit    morbi                vel    ligula    vitae    arcu    aliquet    mollis    etiam                vel    erat    placerat    ante    porttitor    sodales                pellentesque    augue    purus         private PendingIntent data        Override     public void onCreate             super onCreate                Override     public int onStartCommand Intent intent  int flags  int startId             data   intent getParcelableExtra  pendingIntent             new LoadWordsThread   start            return START NOT STICKY              Override     public IBinder onBind Intent intent            return null              Override     public void onDestroy             super onDestroy               class LoadWordsThread extends Thread            Override         public void run                 for  String item   items                    if   isInterrupted                           Intent result   new Intent                        result putExtra  name   item                       try                           data send PendingIntentService this 200 result                         catch  PendingIntent CanceledException e                             e printStackTrace                                              SystemClock sleep 400

User · Answer

I am surprised that no one has given reference to Otto event Bus library  http   square github io otto   I have been using this in my android apps and it works seamlessly

User · Answer

You may also use LiveData that works like an EventBus  class MyService   LifecycleService         companion object           val BUS   MutableLiveData lt Any gt               override fun onStartCommand intent  Intent  flags  Int  startId  Int   Int           super onStartCommand intent  flags  startId           val testItem   Object             expose your data         if  BUS hasActiveObservers                  BUS postValue testItem                     return START NOT STICKY          Then add an observer from your Activity  MyService BUS observe this  Observer       it  let              Do what you need to do here           You can read more from this blog

[android] How to have Android Service communicate with Activity

Examples related to android

Examples related to android-activity

Examples related to android-service