How to check if a service is running on Android?

Question

How do I check if a background service 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.

Sudden

Check out this german guide. – Weatherman

the correct answer is below and not the one marked: https://mcmap.net/q/53119/-how-to-check-if-a-service-is-running-on-android – Demulsify

@Demulsify If that hasn't already been nerfed like getRunningTasks(), it probably will be. – Koph

using the getSystemService() function you can retrieve all the running services. loop through it and check the your service exist in the list here you can see a small sample wiki.workassis.com/android-check-the-service-is-running – Elizbeth

Answer 1

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.

Ventilator

This will be faster to execute then the answer by @Justajustemilieu (now the most highly rated), but I wonder whether the reference to the Service will cause that class to be included in the Receiver component - which should be kept as small as possible. – Teena

@Pacerier, the solution you reference requires starting the service and I think the best flexible solution should allow you to check whether a service is running without starting it. – Teena

+1 This method is more sustainable. The one offered by @Justajustemilieu does not work on Android KitKat. – Olympe

This solution only works for local services. @Justajustemilieu solution works on any version of Android and actually works whether the service is local or not. – Pedestrian

What about if the service is stopped by the system, how do you detect that and toggle your variable? – Lancey

When the app is killed, the service that it had started is also killed but the service's onDestroy() is not called. So the static variable cannot be updated in such a scenario resulting in inconsistent behaviour. – Wag

@Wag Wouldn't the static variable also be re-intialized, thus setting it back to the default value that indicates the service is no longer running? – Duodenitis

@Duodenitis you are right. I stand corrected. If the static variable is a boolean(or equivalent type with only 2 possible values), it should not be a problem. But suppose that only the service is killed, while the app is not. This happens pretty often with background services. In that case, the common process that hosts both the app and the service, is not killed. So the static variable in the service class will not be re-initialized and reading this variable in the app now will be erroneous. – Wag

@Wag Ok, would onDestroy() on the service be called in that case? – Duodenitis

@Duodenitis onDestroy() will not be called if the service is terminated by the OS unexpectedly. See groups.google.com/forum/#!topic/android-developers/2DTkEk73xpk. – Wag

@faizal, local Service is not a separate process, so if service is killed then app also will kill. – Counterfoil

@Counterfoil that's an interesting point. So static variable is the best solution then! – Wag

and what about multi process apps – Astrahan

@haresh: Thank you for the answer. Let's say I initiated the service on a button click., Goes out of the activity so the activity is destroyed now. I recreated the activity. Now how to check if the service is running or not. If running then how to stop it. Please suggest something else other than ActivityManager list. Thanks in advance. – Insensible

@Insensible Please refer your question to miracle2k instead. – Woofer

The hackbod link seems to be dead, Someone please update it. – Alimentary

The hackbod link seems to be dead, Someone please update it. – Alimentary

@Ventilator link is dead – Flower

@Counterfoil Going from the likelihood of something being killed, the background activity is going to be killed quicker than a foreground service, but a foreground activity might stay longer than the foreground service and activities and services can be destroyed by android independently of the whole app process. – Walford

Answer 2

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:

isMyServiceRunning(MyService.class)

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

Justajustemilieu

Presumably this requires the permission to view running applications and services? Not ideal. – Aesculapius

Thanks for this solution. I'd like to add: Instead "com.example.MyService" is more elegant to use MyService.class.getName() – Akerley

ACTIVITY_SERVICE is not defined in Eclipse for the API 10. Do I missed something ? – Piled

Personally, I went with using a static field. Although using getRunningServices() is a more robust solution, I believe there is in these two solutions a tradeoff between robustness and efficiency/simplicity. If you need to check frequently whether a service is running, looping through potentially 30+ running services is not very ideal. The rare case of a service being destroyed by the system can be handled perhaps by a try/catch block or by using START_STICKY. – Hearts

No it isn't the right answer because it's also written in the docs: "Note: this method is only intended for debugging or implementing service management type user interfaces." It's not meant for control flow! – Contraceptive

People find it elegant to have to go through all that to check if a server is running? – Estes

Apparently this does not work with ServiceTestCase when writing Android unit tests. Not sure what works differently. The service never seems to get added. However, you can unit test this functionality with a normal AndroidTestCase and just call getContext().startService(intent); – Commonage

@Contraceptive This is definitely for a service management UI since the question is how to manage (I.E. toggle) a service. – Holster

This code is incorrect/incomplete. It also needs to check for the package name, as currently there is a chance you'll find services from other packages rather than your own. – Laparotomy

I think static field is a better solution. if a service bound in an activity this method returns true whether service not started yet. – Scimitar

-1. This method is not really sustainable. It does not work on Android KitKat. – Olympe

Calling bindService with 0 as flag does not start the service, but this method identifies it as running. – Hypocoristic

This does not work in one particular case. When the app is killed, the service that it had started is also killed. But this function will still return true in the activity's onDestroy() method. So it is not reliable in this scenario. – Wag

@Contraceptive docs are written by humans and sometime deliberately to keep them away. but that's the only way to know if a Service is running so you won't start it again and again. Also it is helpful in the case if a user has Force Stop your app intentionally/unintentionally! – Putnem

I'd discourage the use of this solution. For Android L they're removing ActivityManager.getRecentTasks() and it had the same note in the documentation. So be warned! – Tague

This seems to find services that have been stopped as well as running services. Perhaps return service.started; improves upon return true;? – Dogooder

Shouldn't it be <? extends Service> so it's harder to call it with the wrong argument? – Mizzle

It does not work when user exit app with home button, then when user back to app onCreate this method return true even Service is not running – Urfa

@Laparotomy Schildbach getName() and getClassName() return the full qualified class name with package name so chance of name collision is practically nil. – Innovation

So you will list down all the services running on the device and compare with your service ? Is this a optimum solution ? Really ! Down voted – Tanked

Starting Android O, getRunningServices is deprecated. This answer needs an update for newer version. – Silverside

For backwards compatibility, it will still return the caller's own services. This means we could still use it for this purpose right ? @Silverside – Hemicycle

@Silverside as of Android O, getRunningServices is no longer available to third party applications. For backwards compatibility, it will still return the caller's own services. – Milinda

As seb says ActivityManager should be used only for testing and debugging. This is not the right answer!! – Girdler

fix error here: for (ActivityManager.RunningServiceInfo service – Kylix

@Justajustemilieu will this work even for checking the remote services? – Slain

On phone with many app, looping through all running services may take long time. – Kaolinite

It doesn't work for me. After I close(swipe away) the app and return back to app, while my service is persistant and running it returns false – Malt

Answer 3

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

Weisberg

This will list just system services, no?! So my local service is excluded from list and I will get false ;( – Metopic

This works with external services, for local services is pretty obvious if you're running. – Weisberg

Sorry but I need to say that is super silly answer..Why it is super obvious?! – Metopic

For a local service, if you're application is running the service is as well. If it crashes it will take your application along with it. – Weisberg

Not clear what u mean here... Who was talking about crashing at all?! I am not interesting in crashing it. Service can be started, stopped, maybe it was intent service and it will stop on it's own when it is done... Question is how to know if it is still running or not after 3 min for example. – Metopic

Not works because always call this service everytime! bad logical – Grater

It is incorrect to give the impression that a bound service must also be started. NO. Bind auto create does exactly what it says. It will create (and therefore "start") the service if the service is not yet running. – Frangipani

Answer 4

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.

Piping

This is flawed. onDestroy is not guaranteed to be called. – Viola

Why not, someone still has to call stop to stop a service, and it will cause onDestroy to be called. – Piping

When the system is low on memory, your service will be killed automatically without a call to your onDestroy, Which is why i say that this is flawed. – Viola

@Pacerier, but if the system kills the process, then the instance flag will still get reset. I'm guessing that when the receiver next gets loaded (post the system killing the service) the static flag 'instance' will get recreated as null. – Teena

How cuold we verify that. And @Viola statement that onDestroy won't be called – Piping

At least better than iterating through all those services in isMyServiceRunning which really delays stuff if done on every device rotation :) – Wobble

Your instance variable should not be declared final, otherwise it cannot be set or null'ed by the onCreate() or onDestroy() methods. – Dryclean

I rather liked this answer cause i can implement it so easy with just one of my existing variables set in onCreate() and easily skip it. Thanks man. – Hydrargyrum

Check my solution below: https://mcmap.net/q/53119/-how-to-check-if-a-service-is-running-on-android. It covers that part. – Rosenberry

Answer 5

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.

Sardou

Not exactly what the docs say. According to your link: "Returns If the service is being started or is already running, the ComponentName of the actual service that was started is returned; else if the service does not exist null is returned." – Backbend

Nice thinking ... but doesn't fit in current situation . – Measureless

its not proper way, because when IDE trigger if(startService(someIntent) != null) that will check that IsserviceRunning but that will also play new service. – Haymes

As it is stated, if you stop the service after this control it will be handy for this problem. But why to start and stop a service for nothing? – Armyworm

this will start the service, isn't it? Just want to check the status of service instead of starting it... – Labuan

Answer 6

/**
 * Check if the service is Running 
 * @param serviceClass the class of the Service
 *
 * @return true if the service is running otherwise false
 */
public boolean checkServiceRunning(Class<?> serviceClass){
    ActivityManager manager = (ActivityManager) getSystemService(ACTIVITY_SERVICE);
    for (RunningServiceInfo service : manager.getRunningServices(Integer.MAX_VALUE))
    {
        if (serviceClass.getName().equals(service.service.getClassName()))
        {
            return true;
        }
    }
    return false;
}

Coff

Answer 7

An extract from Android docs:

Like sendBroadcast(Intent), but if there are any receivers for the Intent this function will block and immediately dispatch them before returning.

Think of this hack as "pinging" the Service. Since we can broadcast synchronously, we can broadcast and get a result synchronously, on the UI thread.

Service

@Override
public void onCreate() {
   LocalBroadcastManager
     .getInstance(this)
     .registerReceiver(new ServiceEchoReceiver(), new IntentFilter("ping"));
     //do not forget to deregister the receiver when the service is destroyed to avoid
     //any potential memory leaks 
}

private class ServiceEchoReceiver extends BroadcastReceiver {
    public void onReceive (Context context, Intent intent) {
      LocalBroadcastManager
         .getInstance(this)
         .sendBroadcastSync(new Intent("pong"));
    }
}

Activity

    bool serviceRunning = false;

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

The winner in many applications is of course a static boolean field on the service that is set to true in Service.onCreate() and to false in Service.onDestroy() because it's a lot simpler.

Koffman

This is a much better solution than the accepted one, which fails if Android kills the service since the global variable method would still indicate that the service is running when it actually no longer is. This synchronous ping-pong broadcast trick is actually the ONLY reliable method to check if a service is alive. It alone allows you to simply ASK the service if it is there. If it answers then the service is alive and running, if not it has either not been started or has been shut down, either programatically or by the system to recover memory. – Hellkite

LocalBroadcastManager is deprecated: developer.android.com/reference/androidx/localbroadcastmanager/… – Encephaloma

Answer 8

Another approach using kotlin. Inspired in other users answers

fun isMyServiceRunning(serviceClass: Class<*>): Boolean {
    val manager = getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager
    return manager.getRunningServices(Integer.MAX_VALUE)
            .any { it.service.className == serviceClass.name }
}

As kotlin extension

fun Context.isMyServiceRunning(serviceClass: Class<out Service>) = try {
    (getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager)
        .getRunningServices(Int.MAX_VALUE)
        .any { it.service.className == serviceClass.name }
} catch (e: Exception) {
    false
}

Usage

context.isMyServiceRunning(MyService::class.java)

Stepmother

NOTE: getRunningServices is now deprecated, through it seems the method won't be deleted. – Quint

As of Build.VERSION_CODES.O, this method is no longer available to third party applications. BUT, for backwards compatibility, it will still return the caller's own services. – Overstuffed

Answer 9

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

Dubenko

I actually like this approach. It's a little heavy code wise but will always work. I don't see broadcast intents being deprecated any time soon :) – Liberate

Take into account that a broadcast can be missed. – Misvalue

And ...LocalBroadcastManager is now deprecated... (rimshot). It's still a good solution though. – Antihistamine

Well, this never returns "service is not running", so not really suitable for a lot of use cases... – Novitiate

You are not supposed to add code to a class just for testing purposes. So many of these dumb hacks on this thread. – Aldas

Answer 10

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

Fireboard

to be more on strict side you can change class param to Class<? extends Service> – Piotr

Answer 11

First of all you shouldn't 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.

Pitapat

That discussion took place on '12/26/07'. Either that's July of this year (i.e. in the future), or that's before Android was even public. Either way that makes me not trust it. – Teena

That discussion is from December 26, 2007. They are discussing a pre-release version I think (developer.android.com/sdk/OLD_RELEASENOTES.html#m3-rc37a) which was released on December 14, 2007. – Dybbuk

Answer 12

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.

Polymyxin

The service could be on different processes, take this into account – Misvalue

Answer 13

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.

Piping

Combined or update your previous answer. Please refrain from posting more than one answers per post. – Tamaru

Can this answer be expanded on, i.e. how does one associate the value for CODE with the service? – Dyeline

Where to get context? – Playbill

Answer 14

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.

Weisberg

Answer 15

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

Rosenberry

The only problem with this is if the service is a Sticky service and it restarts itself. Calling to isServiceCreated() will return false after the service starts again because mInstance will be null. – Feticide

Wouldn't onCreate be called then when the service restarts itself? – Rosenberry

Answer 16

Xamarin C# version:

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

Intervalometer

You need the ´Context` for GetSystemService. – Predigestion

Answer 17

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.

Crevasse

Answer 18

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

isMyServiceRunning(NewService::class.java)

Earleneearley

ActivityManager.getRunningServices is deprecated since Android O – Hecht

Answer 19

In your Service Sub-Class Use a Static Boolean to get the state of the Service as demonstrated below.

MyService.kt

class MyService : Service() {
    override fun onCreate() {
        super.onCreate()
        isServiceStarted = true
    }
    override fun onDestroy() {
        super.onDestroy()
        isServiceStarted = false
    }
    companion object {
        var isServiceStarted = false
    }
}

MainActivity.kt

class MainActivity : AppCompatActivity(){
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        val serviceStarted = FileObserverService.isServiceStarted
        if (!serviceStarted) {
            val startFileObserverService = Intent(this, FileObserverService::class.java)
            ContextCompat.startForegroundService(this, startFileObserverService)
        }
    }
}

Murrey

Answer 20

For kotlin, you can use the below code.

fun isMyServiceRunning(calssObj: Class<SERVICE_CALL_NAME>): Boolean {
    val manager = requireActivity().getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager
    for (service in manager.getRunningServices(Integer.MAX_VALUE)) {
        if (calssObj.getName().equals(service.service.getClassName())) {
            return true
        }
    }
    return false
}

Cambrian

This is a great answer for writing tests, since you can use it without changing your working code. – Ramekin

can we make this return Flow<Boolean> ? – Treehopper

Why use equals for Kotlin here? – Mig

Answer 21

In kotlin you can add boolean variable in companion object and check its value from any class you want:

companion object{
     var isRuning = false

}

Change it value when service is created and destroyed

 override fun onCreate() {
        super.onCreate()
        isRuning = true
    }

override fun onDestroy() {
    super.onDestroy()
    isRuning = false
    }

Martita

onDestroy() is not always called – Teniers

@Teniers When onDestroy() is not called, it is because the whole process is killed, so there is nothing around that can check the value of isRuning. In fact, isRuning does not exist any longer at this point. So it is not a problem that onDestroy() is not called. This is assuming all components live in the same process, of course (which is the default). – Marchpast

Answer 22

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.

Delanadelancey

This doesn't work if you service gets killed by Android. – Ooze

@Ooze I just experienced that myself. Do you know why not? – Elector

@Ooze when my app is killed by OS, the service does restart and sets the static bool to true, but upon getting it it reports false – Elector

this won't work if you call stopService. At least for Intent services. onDestroy() will be called immediately, but onHandleIntent() will still be running – Blindfold

@Ooze Won't killing the service due to low memory also mean killing the process? – Mig

Answer 23

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

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:

https://issuetracker.google.com/issues/68908332

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:

ServiceManager.getService("activity");

next:

  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(),...)

then:

 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 :

BinderInternal.getContextObject()

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

update 23.06.2018

i found those interesting:

/**
 * Provide a binder to an already-bound service.  This method is synchronous
 * and will not start the target service if it is not present, so it is safe
 * to call from {@link #onReceive}.
 *
 * For peekService() to return a non null {@link android.os.IBinder} interface
 * the service must have published it before. In other words some component
 * must have called {@link android.content.Context#bindService(Intent, ServiceConnection, int)} on it.
 *
 * @param myContext The Context that had been passed to {@link #onReceive(Context, Intent)}
 * @param service Identifies the already-bound service you wish to use. See
 * {@link android.content.Context#bindService(Intent, ServiceConnection, int)}
 * for more information.
 */
public IBinder peekService(Context myContext, Intent service) {
    IActivityManager am = ActivityManager.getService();
    IBinder binder = null;
    try {
        service.prepareToLeaveProcess(myContext);
        binder = am.peekService(service, service.resolveTypeIfNeeded(
                myContext.getContentResolver()), myContext.getOpPackageName());
    } catch (RemoteException e) {
    }
    return binder;
}

in short :)

"Provide a binder to an already-bound service. This method is synchronous and will not start the target service if it is not present."

public IBinder peekService(Intent service, String resolvedType, String callingPackage) throws RemoteException;

*

public static IBinder peekService(IBinder remote, Intent service, String resolvedType)
             throws RemoteException {
    Parcel data = Parcel.obtain();
    Parcel reply = Parcel.obtain();
    data.writeInterfaceToken("android.app.IActivityManager");
    service.writeToParcel(data, 0);
    data.writeString(resolvedType);
    remote.transact(android.os.IBinder.FIRST_CALL_TRANSACTION+84, data, reply, 0);
    reply.readException();
    IBinder binder = reply.readStrongBinder();
    reply.recycle();
    data.recycle();
    return binder;
}

*

Klement

bindResult(return value of bindService method) does not come as false if service is not running. – Waksman

Answer 24

Please use this code.

if (isMyServiceRunning(MainActivity.this, xyzService.class)) { // Service class name
    // Service running
} else {
    // Service Stop
}


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

Readjustment

getRunningServices is deprecated in android O – Misvalue

Answer 25

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

ComponentName

Meanie

Answer 26

If you have a multi-module application and you want to know that service is running or not from a module that is not depends on the module that contains the service, you can use this function:

fun isServiceRunning(context: Context, serviceClassName: String): Boolean {

    val manager = ContextCompat.getSystemService(
        context,
        ActivityManager::class.java
    ) ?: return false

    return manager.getRunningServices(Integer.MAX_VALUE).any { serviceInfo ->
        serviceInfo.service.shortClassName.contains(vpnServiceClassName)
    }
}

Usage for MyService service:

isServiceRunning(context, "MyService")

This function may not work correctly if the service class name changes and the calling function does not change accordingly.

Jermyn

getRunningServices is deprecated since Android O (8.1) – Doradorado

Yes, it is. I do not know any alternative. – Jermyn

Answer 27

Here's good solution I've come up with, but it works only for the Services running in separate processes. This can be achieved by adding an android:process attribute in the manifest, e.g.

<service
        android:name=".ExampleService"
        android:process="com.example.service"
        ...

Now your service will be running in a separate process with the given name. From your app you can call

val activityManager = context.getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager
activityManager.runningAppProcesses.any { it.processName == "com.example.service" }

Which will return true if the service is running and false otherwise.

IMPORTANT: note that it will show you when your service was started, but when you disable it (meaning, after system unbinds from it) the process can still be alive. So you can simply force it's removal:

override fun onUnbind(intent: Intent?): Boolean {
    stopSelf()
    return super.onUnbind(intent)
}

override fun onDestroy() {
    super.onDestroy()
    killProcess(Process.myPid())
}

Then it works perfectly.

Bozarth

Answer 28

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.

Rosie

Answer 29

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.

Haberdasher

Answer 30

My kotlin conversion of the ActivityManager::getRunningServices based answers. Put this function in an activity-

private fun isMyServiceRunning(serviceClass: Class<out Service>) =
    (getSystemService(ACTIVITY_SERVICE) as ActivityManager)
        .getRunningServices(Int.MAX_VALUE)
        ?.map { it.service.className }
        ?.contains(serviceClass.name) ?: false

Boredom

Its advised that the ActivityManager is only really to be used for Debug purposes. – Reeder

Answer 31

My solution uses sendOrderedBroadcast. It is similar to the ping-pong method using the deprecated LocalBroadcastManager.

By using sendOrderedBroadcast to ping the service, the following happens:

• If the service is alive:

  1. The system sends the ping action. Since there is one broadcast receiver registered for the ping action, i.e. the service's pingActionBroadcastReceiver, the ping action will be sent to it first.
  2. The service's pingActionBroadcastReceiver receives the ping action and sets the ping action's resultCode to 1.
  3. Since there are no more broadcast receivers that can process the ping action, the system sends the ping action back to the argument we provided to sendOrderedBroadcast's resultReceiver: BroadcastReceiver?, i.e. pingActionResultBroadcastReceiver.
  4. pingActionResultBroadcastReceiver receives the ping action with its resultCode is set to 1.

• If the service is NOT alive:

  1. The system sends the ping action. Since there are no broadcast receivers registered for the ping action, the system sends the ping action back to the argument we provided to sendOrderedBroadcast's resultReceiver: BroadcastReceiver?, i.e. pingActionResultBroadcastReceiver.
  2. pingActionResultBroadcastReceiver receives the ping action with its resultCode equal to the argument we provided to sendOrderedbroadcast's initialCode: Int which is 0.

Steps:

1. Setup the pong part: create a BroadcastReceiver for receiving the ping action in the Service you would like to check.

class SomeService : Service() {
    // instantiate your ping action broadcast receiver
    private val pingActionBroadcastReceiver = PingActionBroadcastReceiver()

    override fun onCreate() {
        // ...

        /*
          register the ping action broadcast receiver

          you may set the `flags` to whatever you want depending
          your use case, e.g. if you want other apps to be able
          to check for your service's presence, set the `flags` to
          `ContextCompat.RECEIVER_EXPORTED` instead
        */
        ContextCompat.registerReceiver(
            /* context = */ this,
            /* receiver = */ pingActionBroadcastReceiver,
            /* filter = */ IntentFilter(PING_ACTION),
            /* flags = */ ContextCompat.RECEIVER_NOT_EXPORTED,
        )

        // ...
    }

    override fun onDestroy() {
        // ...

        // don't forget to unregister your broadcast receiver
        unregisterReceiver(pingActionBroadcastReceiver)

        // ...
    }

    private class PingActionBroadcastReceiver : BroadcastReceiver() {
        override fun onReceive(context: Context?, intent: Intent?) {
            if (!isOrderedBroadcast) {
                /*
                  we only want broadcasts that were sent using
                  `sendOrderedBroadcast`
                */
                return
            }

            /*
              this is the pong part

              we call `setResult` with `code` equal to `1` because
              we want to tell the broadcaster that the service is alive.

              you may set `data: String?` and `extras: Bundle?` to
              anything you want depending on your use case.
            */
            setResult(
                /* code = */ 1,
                /* data = */ null,
                /* extras = */ null,
            )
            
            /*
              if you're only interested in the result code just set
              `resultCode` to `1` instead of calling `setResult`.
            */
            resultCode = 1
        }
    }

    companion object {
        const val PING_ACTION = "<your ping action>"
    }

    // ...
}

2. Setup the ping part. In this example code, we want to check if the service is running every time the user navigates to our activity.

class SomeActivity : AppCompatActivity() {
    // instantiate your ping action result broadcast receiver
    private val pingActionResultBroadcastReceiver =
            PingActionResultBroadcastReceiver()

    override fun onStart() {
        // ...

        // this is the ping part
        sendOrderedBroadcast(
            /* intent = */ Intent(SomeService.PING_ACTION),
            /* receiverPermission = */ null,
            /* resultReceiver = */ pingActionResultBroadcastReceiver,
            /* scheduler = */ null,
            /* initialCode = */ 0,
            /* initialData = */ null,
            /* initialExtras = */ null,
        )

        // ...
    }

    private inner class PingActionResultBroadcastReceiver : BroadcastReceiver() {
        override fun onReceive(context: Context?, intent: Intent?) {
            if (resultCode == 1) {
                /*
                  do something if the service is alive
 
                  `resultCode` is equal to `1` since it's the
                  integer value we set from the service's ping
                  action broadcast receiver
                */
            } else if (resultCode == 0) {
                /*
                  do something if the service is NOT alive
                 
                  `resultCode` is equal to `0` since it's the
                  `initialCode` integer value we passed to
                  the `sendOrderedBroadcast` call above
                */
            }
        }
    }

    // ...
}

Onym

Answer 32

Since Android 8 (or Oreo), API getRunningServices is deprecated. Of course your can use @SuppressWarnings("deprecation") to get rid of the warning.

Here is how to do without getRunninngServices if your service does not need to have more than one instance: use the singleton pattern.

public class MyMusicService extends Service {

    private static MyMusicService instance = null;
    
    public static boolean isMyMusicServiceRunning() {
        return instance != null;
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        // ... do your business
        MyMusicService.instance = this;
    }
}

Then you can call the MyMusicService.isMyMusicServiceRunning from your activities or elsewhere.

Rambling

You haven't set values to the "instance"... – Mig

I edited the code to show where to set the instance. – Rambling

Answer 33

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.

Armyworm

Only that nobody will update the value for you when they kill the service – Wobble

when kill the service onDestroy() will triggered and that is possible to update its state – Ampere

@JongzPuangput, onDestroy isn't always called when the service is killed. For example, I've seen my services killed in low memory situations without onDestroy being called. – Allege

@Allege Then what will get called? – Forswear

@RuchirBaronia As far as I remember, you simply don't get notified when your stuff is killed. I believe Android is designed to kill apps as needed, and apps should be designed to expect to be killed at any point without notification. – Allege

Answer 34

It is possible for you to use this options from the Android Developer options to see if your service is still running in the background.

1. Open Settings in your Android device.
2. Find Developer Options.
3. Find Running Services option.
4. Find your app icon.
5. You will then see all the service that belongs to your app running in the background.

Advocacy