How can we detect the Android app killed by user or the System?

Question

Is it possible to detect the Android App killed or exit by the user?

I try to use ActivityLifecycleCallbacks registerred in the Application class to detect it by assing an int parameter and increasing it in onActivityCreated like below; but it does not work.
I think the Android Service in my App makes this global counter variable (defined in a singleton class) not killed although the app has been killed.
It starts with zero only the first time when the app first start, then every app restart it has the the last value as the last time the app has been killed and never has a value of zero again.

Another question is that how can we release the global values to their initial values when the app killed that uses Android Service?

Singleton Class which has the global activity counter

public class SingletonClass {

    public int created_activity_number;

    private static volatile SingletonClass instance = null;

    private SingletonClass() {

    }

    public static SingletonClass getInstance() {
        if (instance == null) {
            synchronized (SingletonClass.class) {
                // Double check
                if (instance == null) {
                    instance = new SingletonClass();
                }
            }
        }
        return instance;
    }
}

ActivityLifecycleCallbacks class

 public class MyLifecycleHandler implements Application.ActivityLifecycleCallbacks {

            private static int created;

            @Override
            public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
                SingletonClass.getInstance().created_activity_number++;
            }

            @Override
            public void onActivityStarted(Activity activity) {

            }

            @Override
            public void onActivityResumed(Activity activity) {

            }

            @Override
            public void onActivityPaused(Activity activity) {

            }

            @Override
            public void onActivityStopped(Activity activity) {

            }

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

            }

            @Override
            public void onActivityDestroyed(Activity activity) {

            }
        }

In any Activity I use below condition to check if the activity is the first created acitivy when the app starts.

// Enter this condition only one time no mattter how many times the application killed by the user end starts again.
if (SingletonClass.getInstance().created_activity_number == 1) {
            // Yes, it is the first created activiy 
}

I open an activiy outside the application and when user hits back button I open a specific activity if the application is alive or just close it . How can I do that? — ondermerol, Oct 06 '15 at 08:26
Please be constructive i'm not able to understand what are you trying to achieve! — Muhammad Babar, Oct 06 '15 at 09:27
Hope this will help you.... [Link](http://stackoverflow.com/a/33078782/4183013) — Faisal Khan, Oct 12 '15 at 10:49
If you're counting globally, you might be better of with a static int field somewhere. Singletons, while nice and easy to use, cause a lot of pain to maintain afterwards (if they grow). — milosmns, Jul 06 '17 at 08:22

score 1 · Answer 1 · answered Oct 06 '15 at 10:43

I had the same problem, use this class

public class Foreground implements Application.ActivityLifecycleCallbacks {

public static final long CHECK_DELAY = 500;
public static final String TAG = Foreground.class.getName();

public interface Listener {

    public void onBecameForeground();

    public void onBecameBackground();

}

private static Foreground instance;

private boolean foreground = false, paused = true;
private Handler handler = new Handler();
private List<Listener> listeners = new CopyOnWriteArrayList<Listener>();
private Runnable check;

/**
 * Its not strictly necessary to use this method - _usually_ invoking
 * get with a Context gives us a path to retrieve the Application and
 * initialise, but sometimes (e.g. in test harness) the ApplicationContext
 * is != the Application, and the docs make no guarantees.
 *
 * @param application
 * @return an initialised Foreground instance
 */
public static Foreground init(Application application){
    if (instance == null) {
        instance = new Foreground();
        application.registerActivityLifecycleCallbacks(instance);
    }
    return instance;
}

public static Foreground get(Application application){
    if (instance == null) {
        init(application);
    }
    return instance;
}

public static Foreground get(Context ctx){
    if (instance == null) {
        Context appCtx = ctx.getApplicationContext();
        if (appCtx instanceof Application) {
            init((Application)appCtx);
        }
        throw new IllegalStateException("Foreground is not initialised and cannot obtain the Application object");
    }
    return instance;
}

public static Foreground get(){
    if (instance == null) {
        throw new IllegalStateException("Foreground is not initialised - invoke at least once with parameterised init/get");
    }
    return instance;
}

public boolean isForeground(){
    return foreground;
}

public boolean isBackground(){
    return !foreground;
}

public void addListener(Listener listener){
    listeners.add(listener);
}

public void addListenerUnique(Listener listener){
    if(!listeners.contains(listener)){
        listeners.add(listener);
    }
}

public void removeListener(Listener listener){
    listeners.remove(listener);
}

@Override
public void onActivityResumed(Activity activity) {
    paused = false;
    boolean wasBackground = !foreground;
    foreground = true;

    if (check != null)
        handler.removeCallbacks(check);

    if (wasBackground){
        Log.i(TAG, "went foreground");
        for (Listener l : listeners) {
            try {
                l.onBecameForeground();
            } catch (Exception exc) {
                Log.e(TAG, "Listener threw exception!", exc);
            }
        }
    } else {
        Log.i(TAG, "still foreground");
    }
}

@Override
public void onActivityPaused(Activity activity) {
    paused = true;

    if (check != null)
        handler.removeCallbacks(check);

    handler.postDelayed(check = new Runnable(){
        @Override
        public void run() {
            if (foreground && paused) {
                foreground = false;
                Log.i(TAG, "went background");
                for (Listener l : listeners) {
                    try {
                        l.onBecameBackground();
                    } catch (Exception exc) {
                        Log.e(TAG, "Listener threw exception!", exc);
                    }
                }
            } else {
                Log.i(TAG, "still foreground");
            }
        }
    }, CHECK_DELAY);
}

@Override
public void onActivityCreated(Activity activity, Bundle savedInstanceState) {}

@Override
public void onActivityStarted(Activity activity) {}

@Override
public void onActivityStopped(Activity activity) {}

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

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

Init it in youur application class

Foreground.init(this);

And then use the listener to know app state

I have found two different solution with using Service and ActivityLifecycleCallbacks (different and simple than yours). Thanks, I will edit my question. — ondermerol, Oct 06 '15 at 12:05
Note that will not give you a properly timed event when you have a service that's running in the background, or when go into split-screen or when you go into picture-in-picture mode. For TVs, this might not get fired at all, but I'm not 100% sure though. — milosmns, Jul 06 '17 at 08:24

How can we detect the Android app killed by user or the System?

1 Answers1