How to check if android app is not running?

Question

My problem is I have a SplashActivity that runs each time app is launched and when a notification is received when app is in the background I start the SplashActivity (that how it works now and it works but it gives the feeling the app is relaunched every time user responds to a notification and some unnecessary server updates are happening).

What I want to do is:

if (app is in background) {
    if (running) {
        launch SomeActivity
    } else {
        launch SplashActivity
    }
}

I went over a lot of posts and none of them helped me to reliably know when the app is running (I consider running in the background as running).

I'm able to detect wether app is in foreground or background (that's not a problem) but my problem is detecting "terminated" state.

I looked in to ActivityLifecycleCallbacks in Application but I can't see how it can reliably help me because onDestroy is not guaranteed to be called.

Anyone solved this issue?

Thanks

Edit:

I ended up using solution suggested in Google I/O 2016 video to detect background and foreground state and added a small addition in onActivityDestroyed to detect my main activity onDestory

It's not perfect and could get the "app state" wrong if onDestory of main tabs activity isn't called but this is what I ended up doing:

public class MyApplication extends Application implements Application.ActivityLifecycleCallbacks {

    public static final int APP_STATE_FOREGROUND = 1000;
    public static final int APP_STATE_BACKGROUND = 1001;
    public static final int APP_STATE_TERMINATED = 1002;

    private int mNumStarted;
    private int mAppState;

    @Override
    public void onCreate() {
        super.onCreate();
        registerActivityLifecycleCallbacks(this);
        // set default app state to APP_STATE_TERMINATED in case app state is not certain so app will launch as if it is a new app launch when opened from push notification
        mAppState = APP_STATE_TERMINATED; 

    }

    public int getAppState() {
        return mAppState;
    }

    /**
     * Application.ActivityLifecycleCallbacks interface methods
     */
    @Override
    public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
        String activityName = activity.getLocalClassName();
        if (activityName.equals("main.TabsActivity")) {
            mAppState = APP_STATE_FOREGROUND;
        }
    }

    @Override
    public void onActivityStarted(Activity activity) {
        if (mNumStarted == 0) {
            mAppState = APP_STATE_FOREGROUND;
        }
        mNumStarted++;
    }

    @Override
    public void onActivityResumed(Activity activity) {}

    @Override
    public void onActivityPaused(Activity activity) {}

    @Override
    public void onActivityStopped(Activity activity) {
        mNumStarted--;
        if (mNumStarted == 0) {
            mAppState = APP_STATE_BACKGROUND;
        }
    }

    @Override
    public void onActivitySaveInstanceState(Activity activity, Bundle outState) {}

    @Override
    public void onActivityDestroyed(Activity activity) {
        String activityName = activity.getLocalClassName();
        if (activityName.equals("main.TabsActivity")) {
            mAppState = APP_STATE_TERMINATED;
        }
    }
}

This solution works for me (for now), maybe it will help someone else.

Answer 1

Method 1: You can safely use below approach on your release applications aswell. These methods are self explanatory. But isAppVisible() indicates your app is currently running either in background or foreground the otherwise likely it means app is terminated by system. I also put some logs for you to debug if it's working as expected or not.

public class MyApplication extends Application {

    private static final String TAG = MyApplication.class.getSimpleName();
    private int mVisibleCount;
    private boolean mInBackground;

    @Override public void onCreate() {
        super.onCreate();
        registerActivityLifecycleCallbacks(new ActivityLifecycleCallbacks() {
            @Override public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
            }

            @Override public void onActivityStarted(Activity activity) {
                mVisibleCount++;
                if (mInBackground && mVisibleCount > 0) {
                    mInBackground = false;
                    Log.i(TAG, "App in foreground");
                }
            }

            @Override public void onActivityResumed(Activity activity) {
            }

            @Override public void onActivityPaused(Activity activity) {
            }

            @Override public void onActivityStopped(Activity activity) {
                mVisibleCount--;
                if (mVisibleCount == 0) {
                    if (activity.isFinishing()) {
                        Log.i(TAG, "App is finishing");
                    } else {
                        mInBackground = true;
                        Log.i(TAG, "App in background");
                    }
                }
            }

            @Override public void onActivitySaveInstanceState(Activity activity, Bundle outState) {

            }

            @Override public void onActivityDestroyed(Activity activity) {
            }
        });
    }

    public boolean isAppInBackground() {
        return mInBackground;
    }

    public boolean isAppVisible() {
        return mVisibleCount > 0;
    }

    public int getVisibleCount() {
        return mVisibleCount;
    }
}

Method 2: There's another method using Service to detect if application is terminated. See link

Answer 2

here the method to know application is in background or not

 public boolean isApplicationBroughtToBackground() {
        ActivityManager am = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);
        List<ActivityManager.RunningTaskInfo> tasks = am.getRunningTasks(1);
        if (!tasks.isEmpty()) {
            ComponentName topActivity = tasks.get(0).topActivity;
            if (!topActivity.getPackageName().equals(getPackageName())) {
                return true;
            }
        }
        return false;
    }