Tutorial :How to check if a service is running on Android?


How do I check if a background service (on Android) is running?

I want an Android activity that toggles the state of the service -- it lets me turn it on if it is off and off if it is on.


I had the same problem not long ago. Since my service was local, I ended up simply using a static field in the service class to toggle state, as described by hackbod here

EDIT (for the record):

Here is the solution proposed by hackbod:

If your client and server code is part of the same .apk and you are binding to the service with a concrete Intent (one that specifies the exact service class), then you can simply have your service set a global variable when it is running that your client can check.

We deliberately don't have an API to check whether a service is running because, nearly without fail, when you want to do something like that you end up with race conditions in your code.


I use the following from inside an activity:

private boolean isMyServiceRunning(Class<?> serviceClass) {      ActivityManager manager = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);      for (RunningServiceInfo service : manager.getRunningServices(Integer.MAX_VALUE)) {          if (serviceClass.getName().equals(service.service.getClassName())) {              return true;          }      }      return false;  }  

And I call it using:


This works reliably, because it is based on the information about running services provided by the Android operating system through ActivityManager#getRunningServices.

All the approaches using onDestroy or onSometing events or Binders or static variables will not work reliably because as a developer you never know, when Android decides to kill your process or which of the mentioned callbacks are called or not. Please note the "killable" column in the lifecycle events table in the Android documentation.


Got it!

You MUST call startService() for your service to be properly registered and passing BIND_AUTO_CREATE will not suffice.

Intent bindIntent = new Intent(this,ServiceTask.class);  startService(bindIntent);  bindService(bindIntent,mConnection,0);  

And now the ServiceTools class:

public class ServiceTools {      private static String LOG_TAG = ServiceTools.class.getName();        public static boolean isServiceRunning(String serviceClassName){          final ActivityManager activityManager = (ActivityManager)Application.getContext().getSystemService(Context.ACTIVITY_SERVICE);          final List<RunningServiceInfo> services = activityManager.getRunningServices(Integer.MAX_VALUE);            for (RunningServiceInfo runningServiceInfo : services) {              if (runningServiceInfo.service.getClassName().equals(serviceClassName)){                  return true;              }          }          return false;       }  }  


A small complement is:

My goal is to know wether a service is running without actualy running it if it is not running.

Calling bindService or calling an intent that can be caught by the service is not a good idea then as it will start the service if it is not running.

So, as miracle2k suggested, the best is to have a static field in the service class to know whether the service has been started or not.

To make it even cleaner, I suggest to transform the service in a singleton with a very very lazy fetching: that is, there is no instantiation at all of the singleton instance through static methods. The static getInstance method of your service/singleton just returns the instance of the singleton if it has been created. But it doesn't actualy start or instanciate the singleton itself. The service is only started through normal service start methods.

It would then be even cleaner to modify the singleton design pattern to rename the confusing getInstance method into something like the isInstanceCreated() : boolean method.

The code will look like:

public class MyService extends Service  {     private static MyService instance = null;       public static boolean isInstanceCreated() {        return instance != null;     }//met       @Override     public void onCreate()     {        instance = this;        ....     }//met       @Override     public void onDestroy()     {        instance = null;        ...     }//met  }//class  

This solution is elegant, but it is only relevant if you have access to the service class and only for classes iside the app/package of the service. If your classes are outside of the service app/package then you could query the ActivityManager with limitations underlined by Pieter-Jan Van Robays.


You can use this (I didn't try this yet, but I hope this works):

if(startService(someIntent) != null) {      Toast.makeText(getBaseContext(), "Service is already running", Toast.LENGTH_SHORT).show();  }  else {      Toast.makeText(getBaseContext(), "There is no service running, starting service..", Toast.LENGTH_SHORT).show();  }  

The startService method returns a ComponentName object if there is an already running service. If not, null will be returned.

See public abstract ComponentName startService (Intent service).

This is not like checking I think, because it's starting the service, so you can add stopService(someIntent); under the code.


    public boolean checkServiceRunning(){           ActivityManager manager = (ActivityManager) getSystemService(ACTIVITY_SERVICE);          for (RunningServiceInfo service : manager.getRunningServices(Integer.MAX_VALUE))                   {                      if ("com.example.yourpackagename.YourServiceName"                              .equals(service.service.getClassName()))                       {                          return true;                      }                  }               return false;      }  


I have slightly modified one of the solutions presented above, but passing the class instead of a generic string name, in order to be sure to compare strings coming out from the same method class.getName()

public class ServiceTools {      private static String LOG_TAG = ServiceTools.class.getName();        public static boolean isServiceRunning(Context context,Class<?> serviceClass){          final ActivityManager activityManager = (ActivityManager)context.getSystemService(Context.ACTIVITY_SERVICE);          final List<RunningServiceInfo> services = activityManager.getRunningServices(Integer.MAX_VALUE);            for (RunningServiceInfo runningServiceInfo : services) {              Log.d(Constants.TAG, String.format("Service:%s", runningServiceInfo.service.getClassName()));              if (runningServiceInfo.service.getClassName().equals(serviceClass.getName())){                  return true;              }          }          return false;      }  }  

and then

Boolean isServiceRunning = ServiceTools.isServiceRunning(                      MainActivity.this.getApplicationContext(),                      BackgroundIntentService.class);  


I just want to add a note to the answer by @Snicolas. The following steps can be used to check stop service with/without calling onDestroy().

  1. onDestroy() called: Go to Settings -> Application -> Running Services -> Select and stop your service.

  2. onDestroy() not Called: Go to Settings -> Application -> Manage Applications -> Select and "Force Stop" your application in which your service is running. However, as your application is stopped here, so definitely the service instances will also be stopped.

Finally, I would like to mention that the approach mentioned there using a static variable in singleton class is working for me.


onDestroy isn't always called in the service so this is useless!

For example: Just run the app again with one change from Eclipse. The application is forcefully exited using SIG: 9.


First of all you musn't try to reach the service by using the ActivityManager. (Discussed here)

Services can run on their own, be bound to an Activity or both. The way to check in an Activity if your Service is running or not is by making an interface (that extends Binder) where you declare methods that both, the Activity and the Service, understand. You can do this by making your own Interface where you declare for example "isServiceRunning()". You can then bind your Activity to your Service, run the method isServiceRunning(), the Service will check for itself if it is running or not and returns a boolean to your Activity.

You can also use this method to stop your Service or interact with it in another way.

I used this tutorial to learn how to Implement this scenario in my application.


The proper way to check if a service is running is to simply ask it. Implement a BroadcastReceiver in your service that responds to pings from your activities. Register the BroadcastReceiver when the service starts, and unregister it when the service is destroyed. From your activity (or any component), send a local broadcast intent to the service and if it responds, you know it's running. Note the subtle difference between ACTION_PING and ACTION_PONG in the code below.

public class PingableService extends Service  {      public static final String ACTION_PING = PingableService.class.getName() + ".PING";      public static final String ACTION_PONG = PingableService.class.getName() + ".PONG";        public int onStartCommand (Intent intent, int flags, int startId)      {          LocalBroadcastManager.getInstance(this).registerReceiver(mReceiver, new IntentFilter(ACTION_PING));          return super.onStartCommand(intent, flags, startId);      }        @Override      public void onDestroy ()      {          LocalBroadcastManager.getInstance(this).unregisterReceiver(mReceiver);          super.onDestroy();      }        private BroadcastReceiver mReceiver = new BroadcastReceiver()      {          @Override          public void onReceive (Context context, Intent intent)          {              if (intent.getAction().equals(ACTION_PING))              {                  LocalBroadcastManager manager = LocalBroadcastManager.getInstance(getApplicationContext());                  manager.sendBroadcast(new Intent(ACTION_PONG));              }          }      };  }      public class MyActivity extends Activity  {      private boolean isSvcRunning = false;        @Override      protected void onStart()      {          LocalBroadcastManager manager = LocalBroadcastManager.getInstance(getApplicationContext());          manager.registerReceiver(mReceiver, new IntentFilter(PingableService.ACTION_PONG));          // the service will respond to this broadcast only if it's running          manager.sendBroadcast(new Intent(PingableService.ACTION_PING));          super.onStart();      }        @Override      protected void onStop()      {          LocalBroadcastManager.getInstance(this).unregisterReceiver(mReceiver);          super.onStop();      }        protected BroadcastReceiver mReceiver = new BroadcastReceiver()      {          @Override          public void onReceive (Context context, Intent intent)          {              // here you receive the response from the service              if (intent.getAction().equals(PingableService.ACTION_PONG))              {                  isSvcRunning = true;              }          }      };  }  


This is an extract from Android docs

Ordered broadcasts (sent with Context.sendOrderedBroadcast) are delivered to one receiver at a time. As each receiver executes in turn, it can propagate a result to the next receiver, or it can completely abort the broadcast so that it won't be passed to other receivers.

This is a bit of a hack but think of this as "pinging" the Service since we can broadcast syncronously we can broadcast and get a result synchronously on the UI thread.


BroadcastReceiver .

@Override  public void onCreate() {     LocalBroadcastManager       .getInstance(this)       .registerReceiver(new ServiceEchoReceiver(), IntentFilter("echo");  }    private class ServiceEchoReceiver{      public void onReceive (Context context, Intent intent) {        LocalBroadcastManager           .getInstance(this)           .sendBroadcastSync(new Intent("echo"));      }  }  


    bool serviceRunning = false;        protected void onCreate (Bundle savedInstanceState){          LocalBroadcastManager.getInstance(this).registerReceiver(echo);          LocalBroadcastManager.getInstance(this).sendBroadcastSync(new Intent("echo"));          if(!serviceRunning){             //try and run the service          }      }        private BroadcastReceiver echo = new BroadcastReceiver(){          public void onReceive (Context context, Intent intent) {            serviceRunning = true;             }      }  


For the use-case given here we may simply make use of the stopService() method's return value. It returns true if there exists the specified service and it is killed. Else it returns false. So you may restart the service if the result is false else it is assured that the current service has been stopped. :) It would be better if you have a look at this.


Again, another alternative that people might find cleaner if they use pending intents (for instance with the AlarmManager:

public static boolean isRunning(Class<? extends Service> serviceClass) {      final Intent intent = new Intent(context, serviceClass);      return (PendingIntent.getService(context, CODE, intent, PendingIntent.FLAG_NO_CREATE) != null);  }  

Where CODE is a constant that you define privately in your class to identify the pending intents associated to your service.


Xamarin C# verison .

private bool isMyServiceRunning(System.Type cls)          {              ActivityManager manager = (ActivityManager)GetSystemService(Context.ActivityService);                foreach (var service in manager.GetRunningServices(int.MaxValue)) {                  if (service.Service.ClassName.Equals(Java.Lang.Class.FromType(cls).CanonicalName)) {                      return true;                  }              }              return false;          }  


There can be several services with the same class name.

I've just created two apps. The package name of the first app is com.example.mock. I created a subpackage called lorem in the app and a service called Mock2Service. So its fully qualified name is com.example.mock.lorem.Mock2Service.

Then I created the second app and a service called Mock2Service. The package name of the second app is com.example.mock.lorem. The fully qualified name of the service is com.example.mock.lorem.Mock2Service, too.

Here is my logcat output.

03-27 12:02:19.985: D/TAG(32155): Mock-01: com.example.mock.lorem.Mock2Service  03-27 12:02:33.755: D/TAG(32277): Mock-02: com.example.mock.lorem.Mock2Service  

A better idea is to compare ComponentName instances because equals() of ComponentName compares both package names and class names. And there can't be two apps with the same package name installed on a device.

The equals() method of ComponentName.

@Override  public boolean equals(Object obj) {      try {          if (obj != null) {              ComponentName other = (ComponentName)obj;              // Note: no null checks, because mPackage and mClass can              // never be null.              return mPackage.equals(other.mPackage)                      && mClass.equals(other.mClass);          }      } catch (ClassCastException e) {      }      return false;  }  



Inside TheServiceClass define:

 public static Boolean serviceRunning = false;  

Then In onStartCommand(...)

 public int onStartCommand(Intent intent, int flags, int startId) {        serviceRunning = true;      ...  }     @Override  public void onDestroy()  {      serviceRunning = false;    }   

Then, call if(TheServiceClass.serviceRunning == true) from any class.


This applies more towards Intent Service debugging since they spawn a thread, but may work for regular services as well. I found this thread thanks to Binging

In my case, I played around with the debugger and found the thread view. It kind of looks like the bullet point icon in MS Word. Anyways, you don't have to be in debugger mode to use it. Click on the process and click on that button. Any Intent Services will show up while they are running, at least on the emulator.


If the service belongs to another process or APK use the solution based on the ActivityManager.

If you have access to its source, just use the solution based on a static field. But instead using a boolean I would suggest using a Date object. While the service is running, just update its value to 'now' and when it finishes set it to null. From the activity you can check if its null or the date is too old which will mean that it is not running.

You can also send broadcast notification from your service indicating that is running along further info like progress.


public static boolean isServiceRunning;    @Override      public int onStartCommand(Intent intent, int flags, int startId) {  isServiceRunning = true;  return START_NOT_STICKY;  }    @Override      public void onDestroy() {          super.onDestroy();          isServiceRunning = false;      }  


if don't wanna use static then user SharedPreferences

@Override  public int onStartCommand(Intent intent, int flags, int startId) {      PrefManager.getPref().saveBoolean(AppConstants.Pref.IS_SERVICE_RUNNING, true);      return START_NOT_STICKY;  }    @Override  public void onDestroy() {      super.onDestroy();      PrefManager.getPref().saveBoolean(AppConstants.Pref.IS_SERVICE_RUNNING, false);  }  

PrefManager is my singleton class for managing all preferences.


simple use bind with don't create auto - see ps.

public abstract class Context {     ...       /*    * @return {true} If you have successfully bound to the service,     *  {false} is returned if the connection is not made     *  so you will not receive the service object.    */    public abstract boolean bindService(@RequiresPermission Intent service,          @NonNull ServiceConnection conn, @BindServiceFlags int flags);  

example :

    Intent bindIntent = new Intent(context, Class<Service>);      boolean bindResult = context.bindService(bindIntent, ServiceConnection, 0);  

why not using? getRunningServices()

List<ActivityManager.RunningServiceInfo> getRunningServices (int maxNum)  Return a list of the services that are currently running.  

Note: this method is only intended for debugging or implementing service management type user interfaces.

ps. android documentation is misleading i have opened an issue on google tracker to eliminate any doubts:


as we can see bind service actually invokes a transaction via ActivityManager binder through Service cache binders - i dint track which service is responsible for binding but as we can see the result for bind is:

int res = ActivityManagerNative.getDefault().bindService(...);  return res != 0;  

transaction is made through binder:



  public static IBinder getService(String name) {      try {          IBinder service = sCache.get(name);          if (service != null) {              return service;          } else {              return getIServiceManager().getService(name);  

this is set in ActivityThread via:

 public final void bindApplication(...) {            if (services != null) {              // Setup the service cache in the ServiceManager              ServiceManager.initServiceCache(services);          }  

this is called in ActivityManagerService in method:

 private final boolean attachApplicationLocked(IApplicationThread thread,              int pid) {      ...      thread.bindApplication(... , getCommonServicesLocked(),...)  


 private HashMap<String, IBinder> getCommonServicesLocked() {  

but there is no "activity" only window package and alarm..

so we need get back to call:

 return getIServiceManager().getService(name);        sServiceManager = ServiceManagerNative.asInterface(BinderInternal.getContextObject());  

this makes call through:

    mRemote.transact(GET_SERVICE_TRANSACTION, data, reply, 0);  

which leads to :


and this is native method....

  /**       * Return the global "context object" of the system.  This is usually       * an implementation of IServiceManager, which you can use to find       * other services.       */      public static final native IBinder getContextObject();  

i don't have time now to dug in c so until i dissect rest call i suspend my answer.

but best way for check if service is running is to create bind (if bind is not created service not exist) - and query the service about its state through the bind (using stored internal flag on it state).


Below is an elegant hack that covers all the Ifs. This is for local services only.

    public final class AService extends Service {            private static AService mInstance = null;            public static boolean isServiceCreated() {              try {                  // If instance was not cleared but the service was destroyed an Exception will be thrown                  return mInstance != null && mInstance.ping();              } catch (NullPointerException e) {                  // destroyed/not-started                  return false;              }          }            /**           * Simply returns true. If the service is still active, this method will be accessible.           * @return           */          private boolean ping() {              return true;          }            @Override          public void onCreate() {              mInstance = this;          }            @Override          public void onDestroy() {              mInstance = null;          }      }  

And then later on:

    if(AService.isServiceCreated()){          ...      }else{          startService(...);      }  


The response of geekQ but in Kotlin class. Thanks geekQ

fun isMyServiceRunning(serviceClass : Class<*> ) : Boolean{      var manager = getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager      for (service in manager.getRunningServices(Integer.MAX_VALUE)) {          if (serviceClass.name.equals(service.service.className)) {              return true          }      }      return false  }  

The call



Take it easy guys... :)

I think the most suitable solution is holding a key-value pair in SharedPreferences about if the service is running or not.

Logic is very straight; at any desired position in your service class; put a boolean value which will act as a flag for you about whether the service is running or not. Then read this value whereever you want in your application.

A sample code which I am using in my app is below:

In my Service class (A service for Audio Stream), I execute the following code when the service is up;

private void updatePlayerStatus(boolean isRadioPlaying)  {          SharedPreferences sharedPref = this.getSharedPreferences(getString(R.string.str_shared_file_name), Context.MODE_PRIVATE);          SharedPreferences.Editor editor = sharedPref.edit();          editor.putBoolean(getString(R.string.str_shared_file_radio_status_key), isRadioPlaying);          editor.commit();  }  

Then in any activity of my application, I am checking the status of the service with the help of following code;

private boolean isRadioRunning() {          SharedPreferences sharedPref = this.getSharedPreferences(getString(R.string.str_shared_file_name), Context.MODE_PRIVATE);            return sharedPref.getBoolean(getString(R.string.str_shared_file_radio_status_key), false);  }  

No special permissions, no loops... Easy way, clean solution :)

If you need extra information, please refer the link

Hope this helps.

Note:If u also have question or solution just comment us below or mail us on toontricks1994@gmail.com
Next Post »