How to determine if an Android Service is running in the foreground?

Question

I have a service which I believe to have running in the foreground, How do I check if my implementation is working?

Epiglottis

Answer 1

private boolean isServiceRunning(String serviceName){
    boolean serviceRunning = false;
    ActivityManager am = (ActivityManager) this.getSystemService(ACTIVITY_SERVICE);
    List<ActivityManager.RunningServiceInfo> l = am.getRunningServices(50);
    Iterator<ActivityManager.RunningServiceInfo> i = l.iterator();
    while (i.hasNext()) {
        ActivityManager.RunningServiceInfo runningServiceInfo = i
                .next();

        if(runningServiceInfo.service.getClassName().equals(serviceName)){
            serviceRunning = true;

            if(runningServiceInfo.foreground)
            {
                //service run in foreground
            }
        }
    }
    return serviceRunning;
}

If you want to know if your service is running in foreground just open some others fat applications and then check if service is still running or just check flag service.foreground.

Lagan

Thanks that worked great! I just needed to added this line: serviceInForeground = runningServiceInfo.foreground; – Epiglottis

What about stopForeground(true) in onDestroy()? Wouldn't that stop the service from running in the foreground? – Zoophilia

@Epiglottis FYI, the documentation on RunningServiceInfo.foreground states: "Set to true if the service has asked to run as a foreground process.". That is, it doesn't tell you if android has actually accepted a service in to the foreground. developer.android.com/reference/android/app/… – Pyrethrin

Unfortunately, GetRunningServices is now marked as depreciated – Salop

Answer 2

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

         }
      }
      return false;
   }

Julio

I find the code in this answer neater than the code in the accepted answer, and it works even if there are more than 50 services running, unlike the accepted answer. – Ratchet

The same as accepted but more clear, shorter, simple. Also check all services, not only 50. – Birdt

Only problem here is "As of Oreo, this method is no longer available to third party applications. For backwards compatibility, it will still return the caller's own services." – Scolopendrid

@Scolopendrid Then what is your suggestion ? – Burkey

What if I want to do the same in Android O ? – Burkey

getRunningServices is deprecated in Android 9 – Cote

Answer 3

A more efficient variation of answer: https://mcmap.net/q/83152/-how-to-determine-if-an-android-service-is-running-in-the-foreground

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

Mccoy

Answer 4

As of API 26, getRunningService() is deprecated.

One solution now is to bind your Activity to your Service. Then you can call a method of your Service from your Activity, to check if it is running.

1 - In your Service, create a class that extends Binder and returns your Service

  public class LocalBinder extends Binder {
        MyService getService() {
            return MyService.this;
        }
    }

2 - In your Service, declare the binder

private final IBinder binder = new LocalBinder();

3 - In your Service, implement onBind(), which will return the Binder

  @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return binder;
    }

4 - In your Service, create a method that check if it is running (for example check if variables are initialized)

  public boolean isRunning() {
        // If running
            return true;
        // If not running
            return false;
        
    }

5 - In your Activity, create a variable that holds your Service

private MyService myService;

6 - Now, in your Activity, you can bind to your Service

private void checkIfEnabled() {
    ServiceConnection connection = new ServiceConnection() {

        @Override
        public void onServiceConnected(ComponentName className,
                                       IBinder service) {
            MyService.LocalBinder binder = (MyService.LocalBinder) service;
            myService = binder.getService();
            
            // Calling your service public method
            if(myService.isRunning()) {
                // Your service is enabled
            } else {
                // Your service is disabled
            }
        }

        @Override
        public void onServiceDisconnected(ComponentName arg0) {

        }
    };

    // Bind to MyService
    Intent intent = new Intent(this, MyService.class);
    bindService(intent, connection, Context.BIND_AUTO_CREATE);
}

For more info, check Bound services overview from official documentation.

Internment

Hi, Could you please share logic inside isRunning function, how to check service is running after one hour app is in background and succeeding opening of the application – Jugular

What if the activity/app process cleared? – Myatt

Answer 5

Starting with API29 (Q), you can simply check it with the following code.

Can be called from inside your service. If you don't have your service instance, you can obtain it by using binder.

class MyService : Service {
    val isForeground: Boolean get() = foregroundServiceType != FOREGROUND_SERVICE_TYPE_NONE
}

Gabardine

Note that the type is FOREGROUND_SERVICE_TYPE_NONE only until it has been started once. Calling stopForeground(), whether or not you remove the notification, will still result in foregroundServiceType not being FOREGROUND_SERVICE_TYPE_NONE. I would recommend incorporating one of the getRunningService() answers (and check the foreground field), even though it's deprecated. – Leodora

@Leodora thanks for pointing this out. I'm actually not sure if this a bug or poorly written documentation. I've made an issue on google tracker. – Gabardine

Note that it switches back to FOREGROUND_SERVICE_TYPE_NONE if you call stopSelf(), so at least this is working. – Misinform

Answer 6

Little touch on Adam's answer:

@Suppress("DEPRECATION") // Deprecated for third party Services.
fun <T> Context.isServiceForegrounded(service: Class<T>) =
    (getSystemService(ACTIVITY_SERVICE) as? ActivityManager)
        ?.getRunningServices(Integer.MAX_VALUE)
        ?.find { it.service.className == service.name }
        ?.foreground == true

Suspensor

Answer 7

This worked for me in the Coinverse app for crypto news.

It's is the most concise Kotlin solution. Thanks to Abbas Naqdi in this GitHub issue.

@Suppress("DEPRECATION") // Deprecated for third party Services.
fun <T> Context.isServiceRunning(service: Class<T>) =
        (getSystemService(ACTIVITY_SERVICE) as ActivityManager)
            .getRunningServices(Integer.MAX_VALUE)
            .any { it.service.className == service.name }

Mellicent

If you need to stop a service this is the latest implementation for Android 9.0. – Mellicent

The question is about the service running in the foreground. So you should also check for it.foreground. – Edsel