How to detect when an Android app goes to the background and come back to the foreground

Question

I am trying to write an app that does something specific when it is brought back to the foreground after some amount of time  Is there a way to detect when an app is sent to the background or brought to the foreground

User · Answer

There are no straightforward lifecycle methods to tell you when the whole Application goes background/foreground.

I have done this with simple way. Follow the below instructions to detect application background/foreground phase.

With a little workaround, it is possible. Here, ActivityLifecycleCallbacks comes to the rescue. Let me walk through step-by-step.

First, create a class that extends the android.app.Application and implements the ActivityLifecycleCallbacks interface. In the Application.onCreate(), register the callback.

public class App extends Application implements 
    Application.ActivityLifecycleCallbacks {

    @Override
    public void onCreate() {
        super.onCreate();
        registerActivityLifecycleCallbacks(this);
    }
}

Register the “App” class in the Manifest as below, <application android:name=".App".
There will be at least one Activity in the started state when the app is in the foreground and there will be no Activity in the started state when the app is in the background.

Declare 2 variables as below in the “App” class.
```
private int activityReferences = 0;
private boolean isActivityChangingConfigurations = false;
```
activityReferences will keep the count of number of activities in the started state. isActivityChangingConfigurations is a flag to indicate if the current Activity is going through configuration change like an orientation switch.

Using the following code you can detect if the App comes foreground.

@Override
public void onActivityStarted(Activity activity) {
    if (++activityReferences == 1 && !isActivityChangingConfigurations) {
        // App enters foreground
    }
}

This is how to detect if the App goes background.

@Override
public void onActivityStopped(Activity activity) {
    isActivityChangingConfigurations = activity.isChangingConfigurations();
    if (--activityReferences == 0 && !isActivityChangingConfigurations) {
        // App enters background
    }
}

How it works:

This is a little trick done with the way the Lifecycle methods are called in sequence. Let me walkthrough a scenario.

Assume that the user launches the App and the Launcher Activity A is launched. The Lifecycle calls will be,

A.onCreate()

A.onStart() (++activityReferences == 1) (App enters Foreground)

A.onResume()

Now Activity A starts Activity B.

A.onPause()

B.onCreate()

B.onStart() (++activityReferences == 2)

B.onResume()

A.onStop() (--activityReferences == 1)

Then the user navigates back from Activity B,

B.onPause()

A.onStart() (++activityReferences == 2)

A.onResume()

B.onStop() (--activityReferences == 1)

B.onDestroy()

Then the user presses Home button,

A.onPause()

A.onStop() (--activityReferences == 0) (App enters Background)

In case, if the user presses Home button from Activity B instead of Back button, still it will be the same and activityReferences will be 0. Hence, we can detect as the App entering Background.

So, what’s the role of isActivityChangingConfigurations? In the above scenario, suppose the Activity B changes the orientation. The callback sequence will be,

B.onPause()

B.onStop() (--activityReferences == 0) (App enters Background??)

B.onDestroy()

B.onCreate()

B.onStart() (++activityReferences == 1) (App enters Foreground??)

B.onResume()

That’s why we have an additional check of isActivityChangingConfigurations to avoid the scenario when the Activity is going through the Configuration changes.

User · Answer

We can expand this solution using LiveData   class AppForegroundStateLiveData   LiveData lt AppForegroundStateLiveData State gt           private var lifecycleListener  LifecycleObserver    null      override fun onActive             super onActive           lifecycleListener   AppLifecycleListener   also               ProcessLifecycleOwner get   lifecycle addObserver it                       override fun onInactive             super onInactive           lifecycleListener  let               this lifecycleListener   null             ProcessLifecycleOwner get   lifecycle removeObserver it                       internal inner class AppLifecycleListener   LifecycleObserver             OnLifecycleEvent Lifecycle Event ON START          fun onMoveToForeground                 value   State FOREGROUND                     OnLifecycleEvent Lifecycle Event ON STOP          fun onMoveToBackground                 value   State BACKGROUND                      enum class State           FOREGROUND  BACKGROUND            Now we can subscribe to this LiveData and catch the needed events  For example   appForegroundStateLiveData observeForever   state - gt      when state            AppForegroundStateLiveData State FOREGROUND - gt       app move to foreground              AppForegroundStateLiveData State BACKGROUND - gt       app move to background

User · Answer

you can simply call this method in your application class  ProcessLifecycleOwner get   getLifecycle   addObserver new LifecycleEventObserver                  Override             public void onStateChanged  NonNull LifecycleOwner source   NonNull Lifecycle Event event                    Log e TAG   onStateChanged      event toString                                 Lifecycle Event will simply return the state of the application  ON CREATE ON START ON RESUME ON PAUSE ON STOP ON DESTROY ON ANY   it will return ON PAUSE  amp  ON STOP when the app goes to background and will return ON START  amp  ON RESUME when the app comes to the foreground

User · Answer

There are three ways through which you can achieve this    Single Activity architecture ActivityLifecycleCallback LifecycleObserver and ProcessLifecycleOwner   Have written an article in detail on this over here  Hope it helps

User · Answer

ProcessLifecycleOwner seems to be a promising solution also   ProcessLifecycleOwner will dispatch ON START  ON RESUME events  as a first activity moves through these events  ON PAUSE  ON STOP  events will be dispatched with a delay after a last activity passed through them  This delay is long enough to guarantee that ProcessLifecycleOwner won t send any events if activities are destroyed and recreated due to a configuration change   An implementation can be as simple as class AppLifecycleListener   LifecycleObserver         OnLifecycleEvent Lifecycle Event ON START      fun onMoveToForeground        app moved to foreground             OnLifecycleEvent Lifecycle Event ON STOP      fun onMoveToBackground        app moved to background             register observer ProcessLifecycleOwner get   lifecycle addObserver AppLifecycleListener     According to source code  current delay value is 700ms  Also using this feature requires the dependencies  implementation  quot androidx lifecycle lifecycle-extensions  lifecycleVersion quot

User · Answer

Here is my solution  Just register this ActivityLifecycleCallbacks in your main Application class  In the comments  I mention a user profile Activity edge case  That Activity is simply one with transparent edges          This class used Activity lifecycle callbacks to determine when the application goes to the    background as well as when it is brought to the foreground      public class Foreground implements Application ActivityLifecycleCallbacks                  How long to wait before checking onStart   onStop   count to determine if the app has been        backgrounded              public static final long BACKGROUND CHECK DELAY MS   500       private static Foreground sInstance       private final Handler mMainThreadHandler   new Handler Looper getMainLooper         private boolean mIsForeground   false      private int mCount       public static void init final Application application                if  sInstance    null                        sInstance   new Foreground                application registerActivityLifecycleCallbacks sInstance                        public static Foreground getInstance                 return sInstance             public boolean isForeground                 return mIsForeground             public boolean isBackground                 return  mIsForeground              Override     public void onActivityStarted final Activity activity                mCount                Remove posted Runnables so any Meteor disconnect is cancelled if the user comes back to            the app before it runs          mMainThreadHandler removeCallbacksAndMessages null            if   mIsForeground                        mIsForeground   true                        Override     public void onActivityStopped final Activity activity                mCount--              A transparent Activity like community user profile won t stop the Activity that launched            it  If you launch another Activity from the user profile or hit the Android home button             there are two onStops    One for the user profile and one for its parent  Remove any            posted Runnables so we don t get two session ended events          mMainThreadHandler removeCallbacksAndMessages null           mMainThreadHandler postDelayed new Runnable                          Override             public void run                                 if  mCount    0                                        mIsForeground   false                                             BACKGROUND CHECK DELAY MS               Override     public void onActivityCreated final Activity activity  final Bundle savedInstanceState                     Override     public void onActivityResumed final Activity activity                     Override     public void onActivityPaused final Activity activity                     Override     public void onActivitySaveInstanceState final Activity activity  final Bundle outState                     Override     public void onActivityDestroyed final Activity activity

User · Answer

These answers don t seem to be correct  These methods are also called when another activity starts and ends  What you can do is keep a global flag  yes  globals are bad   and set this to true each time you start a new activity  Set it to false in the onCreate of each activity  Then  in the onPause you check this flag  If it s false  your app is going into the background  or it s getting killed

User · Answer

Consider using onUserLeaveHint  This will only be called when your app goes into the background  onPause will have corner cases to handle  since it can be called for other reasons  for example if the user opens another activity in your app such as your settings page  your main activity s onPause method will be called even though they are still in your app  tracking what is going in will lead to bugs when you can instead simply use the onUserLeaveHint callback which does what you are asking   When on  UserLeaveHint is called  you can set a boolean inBackground flag to true  When onResume is called  only assume you came back into the foreground if the inBackground flag is set  This is because onResume will also be called on your main activity if the user was just in your settings menu and never left the app   Remember that if the user hits the home button while in your settings screen  onUserLeaveHint will be called in your settings activity  and when they return onResume will be called in your settings activity  If you only have this detection code in your main activity you will miss this use case  To have this code in all your activities without duplicating code  have an abstract activity class which extends Activity  and put your common code in it  Then each activity you have can extend this abstract activity   For example   public abstract AbstractActivity extends Activity       private static boolean inBackground   false        Override     public void onResume             if  inBackground                   You just came from the background             inBackground   false                    else                  You just returned from another activity within your own app                       Override     public void onUserLeaveHint             inBackground   true           public abstract MainActivity extends AbstractActivity              public abstract SettingsActivity extends AbstractActivity

User · Answer

ActivityLifecycleCallbacks might be of interest  but it isn t well documented    Though  if you call registerActivityLifecycleCallbacks   you should be able to get callbacks for when Activities are created  destroyed  etc  You can call getComponentName   for the Activity

User · Answer

This is pretty easy with ProcessLifecycleOwner  Add these dependencies  implementation  android arch lifecycle extensions  project archLifecycleVersion  kapt  android arch lifecycle compiler  project archLifecycleVersion    In Kotlin   class ForegroundBackgroundListener   LifecycleObserver          OnLifecycleEvent Lifecycle Event ON START      fun startSomething             Log v  ProcessLog    APP IS ON FOREGROUND               OnLifecycleEvent Lifecycle Event ON STOP      fun stopSomething             Log v  ProcessLog    APP IS IN BACKGROUND             Then in your base activity   override fun onCreate             super onCreate            ProcessLifecycleOwner get                    lifecycle                  addObserver                          ForegroundBackgroundListener                                    also   appObserver   it            See my article on this topic  https   medium com  egek92 how-to-actually-detect-foreground-background-changes-in-your-android-application-without-wanting-9719cc822c48

User · Answer

Simplest Way  no additional library required  Kotlin  var handler   Handler   var isAppInBackground   true  override fun onStop         super onStop       handler postDelayed   isAppInBackground   true   2000    override fun onDestroy         super onDestroy       handler removeCallbacksAndMessages null      isAppInBackground   false    Java  Handler handler   new Handler    boolean isAppInBackground   true    Override public void onStop         super onStop        handler postDelayed    - gt    isAppInBackground   true    2000      Override public void onDestroy         super onDestroy        handler removeCallbacksAndMessages null       isAppInBackground   false

User · Answer

I was using this with Google Analytics EasyTracker  and it worked  It could be extended to do what you seek using a simple integer   public class MainApplication extends Application        int isAppBackgrounded   0        Override     public void onCreate             super onCreate            appBackgroundedDetector               private void appBackgroundedDetector             registerActivityLifecycleCallbacks new ActivityLifecycleCallbacks                  Override             public void onActivityCreated Activity activity  Bundle bundle                                 Override             public void onActivityStarted Activity activity                    EasyTracker getInstance MainApplication this  activityStart activity                               Override             public void onActivityResumed Activity activity                    isAppBackgrounded                    if  isAppBackgrounded  gt  0                           Do something here                                               Override             public void onActivityPaused Activity activity                    isAppBackgrounded--                              Override             public void onActivityStopped Activity activity                    EasyTracker getInstance MainApplication this  activityStop activity                               Override             public void onActivitySaveInstanceState Activity activity  Bundle bundle                                 Override             public void onActivityDestroyed Activity activity

User · Answer

You can use the ProcessLifecycleOwner attaching a lifecycle observer to it     public class ForegroundLifecycleObserver implements LifecycleObserver         OnLifecycleEvent Lifecycle Event ON CREATE      public void onAppCreated             Timber d  onAppCreated   called                OnLifecycleEvent Lifecycle Event ON START      public void onAppStarted             Timber d  onAppStarted   called                OnLifecycleEvent Event ON RESUME      public void onAppResumed             Timber d  onAppResumed   called                OnLifecycleEvent Event ON PAUSE      public void onAppPaused             Timber d  onAppPaused   called                OnLifecycleEvent Event ON STOP      public void onAppStopped             Timber d  onAppStopped   called              then on the onCreate   of your Application class you call this   ProcessLifecycleOwner get   getLifecycle   addObserver new ForegroundLifecycleObserver       with this you will be able to capture the events of ON PAUSE and ON STOP of your application that happen when it goes in background

User · Answer

Here s how I ve managed to solve this  It works on the premise that using a time reference between activity transitions will most likely provide adequate evidence that an app has been  backgrounded  or not   First  I ve used an android app Application instance  let s call it MyApplication  which has a Timer  a TimerTask  a constant to represent the maximum number of milliseconds that the transition from one activity to another could reasonably take  I went with a value of 2s   and a boolean to indicate whether or not the app was  in the background    public class MyApplication extends Application        private Timer mActivityTransitionTimer      private TimerTask mActivityTransitionTimerTask      public boolean wasInBackground      private final long MAX ACTIVITY TRANSITION TIME MS   2000            The application also provides two methods for starting and stopping the timer task   public void startActivityTransitionTimer         this mActivityTransitionTimer   new Timer        this mActivityTransitionTimerTask   new TimerTask             public void run                 MyApplication this wasInBackground   true                        this mActivityTransitionTimer schedule mActivityTransitionTimerTask                                             MAX ACTIVITY TRANSITION TIME MS      public void stopActivityTransitionTimer         if  this mActivityTransitionTimerTask    null            this mActivityTransitionTimerTask cancel               if  this mActivityTransitionTimer    null            this mActivityTransitionTimer cancel               this wasInBackground   false      The last piece of this solution is to add a call to each of these methods from the onResume   and onPause   events of all activities or  preferably  in a base Activity from which all of your concrete Activities inherit    Override public void onResume         super onResume         MyApplication myApp    MyApplication this getApplication        if  myApp wasInBackground                  Do specific came-here-from-background code            myApp stopActivityTransitionTimer        Override public void onPause         super onPause          MyApplication this getApplication    startActivityTransitionTimer        So in the case when the user is simply navigating between the activities of your app  the onPause   of the departing activity starts the timer  but almost immediately the new activity being entered cancels the timer before it can reach the max transition time  And so wasInBackground would be false   On the other hand when an Activity comes to the foreground from the Launcher  device wake up  end phone call  etc   more than likely the timer task executed prior to this event  and thus wasInBackground was set to true

User · Answer

Based on Mart  n Marconcinis answer  thanks   I finally found a reliable  and very simple  solution   public class ApplicationLifecycleHandler implements Application ActivityLifecycleCallbacks  ComponentCallbacks2        private static final String TAG   ApplicationLifecycleHandler class getSimpleName        private static boolean isInBackground   false        Override     public void onActivityCreated Activity activity  Bundle bundle                Override     public void onActivityStarted Activity activity                Override     public void onActivityResumed Activity activity             if isInBackground               Log d TAG   app went to foreground                isInBackground   false                        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                Override     public void onConfigurationChanged Configuration configuration                Override     public void onLowMemory                 Override     public void onTrimMemory int i            if i    ComponentCallbacks2 TRIM MEMORY UI HIDDEN               Log d TAG   app went to background                isInBackground   true                      Then add this to your onCreate   of your Application class  public class MyApp extends android app Application         Override     public void onCreate             super onCreate             ApplicationLifeCycleHandler handler   new ApplicationLifeCycleHandler            registerActivityLifecycleCallbacks handler           registerComponentCallbacks handler

User · Answer

By using below code I m able to get my app foreground or background state   For more detail about it s working  strong text click here  import android content ComponentCallbacks2  import android content Context  import android support v7 app AppCompatActivity  import android os Bundle  import android widget Toast   public class MainActivity extends AppCompatActivity    private Context context  private Toast toast    Override protected void onCreate Bundle savedInstanceState        super onCreate savedInstanceState       setContentView R layout activity main       context   this     private void showToast String message          If toast is already showing cancel it     if  toast    null            toast cancel               toast   Toast makeText context  message  Toast LENGTH SHORT       toast show        Override protected void onStart         super onStart        showToast  App In Foreground        Override public void onTrimMemory int level        super onTrimMemory level       if  level    ComponentCallbacks2 TRIM MEMORY UI HIDDEN            showToast  App In Background

User · Answer

Correct Answer here   Create class with name MyApp like below   public class MyApp implements Application ActivityLifecycleCallbacks  ComponentCallbacks2        private Context context      public void setContext Context context                this context   context             private boolean isInBackground   false        Override     public void onTrimMemory final int level            if  level    ComponentCallbacks2 TRIM MEMORY UI HIDDEN                  isInBackground   true              Log d  status      we are out                           Override     public void onActivityCreated Activity activity  Bundle bundle                 Override     public void onActivityStarted Activity activity                 Override     public void onActivityResumed Activity activity             if isInBackground                isInBackground   false              Log d  status      we are in                           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                 Override     public void onConfigurationChanged Configuration configuration                 Override     public void onLowMemory                Then  everywhere you want  better first activity launched in app   add the code below   MyApp myApp   new MyApp    registerComponentCallbacks myApp   getApplication   registerActivityLifecycleCallbacks myApp     Done  Now when the app is in the background  we get log  status   we are out and when we go in app  we get log status   we are out

User · Answer

My app needs to  reboot  after return from background - show a series of activities  according to client solicitations  After extensive search on how to manage the background foreground transitions  treated very differently between iOS and Android   I crossed this question  Found very useful help here  specially from the most voted answer and the one flagged as correct  However  simply reinstantiate the root activity EVERY TIME the app enters foreground looked too annoying  when you think about UX  The solution that worked for me  and the one I think s most adequated - based on the Youtube and Twitter apps functionality - was to combine the answers from  GirishNair and  d60402  Calling the timer when the app s trimming memory  as follows    Override public void onTrimMemory int level        if  stateOfLifeCycle equals  Stop              startActivityTransitionTimer               super onTrimMemory level       My Timer limit is set to 30 seconds - I m thinking about increasing this a little   private final long MAX ACTIVITY TRANSITION TIME   30000    And when app goes into foreground  is relaunched  or the app s destroyed  call the method to cancel timer   On App extension    Override public void onActivityCreated Activity activity  Bundle arg1        stopActivityTransitionTimer        stateOfLifeCycle    Create       Override public void onActivityDestroyed Activity activity        stopActivityTransitionTimer        stateOfLifeCycle    Destroy       On the activity  preferably on a base activity  inherited by the others     Override protected void onStart         super onStart        if  App wasInBackground            stopActivityTransitionTimer              In my case  when app goes foreground after the max time  a new task is created  so the stopActivityTransitionTimer   is called upon onActivityCreated   or onActivityDestroyed    in the app extension class - turning unnecessary to call the method in an activity  Hope it helps

User · Answer

I managed to monitor app navigation going to background and back to foreground by implementing a BaseActivity that exploits the use of onResume  onPause and onStop activity callbacks  Here is my implementations   override fun onResume         super onResume       if  AppActivityState state    AppState ON LAUNCHED               We are in the first launch          onLaunched         else           if  AppActivityState state    AppState ON BACKGROUND                   We came from background to foreground              AppActivityState state   AppState ON FOREGROUND             onForeground             else                  We are just navigating through pages              AppActivityState state   AppState RESUMED                    override fun onPause         super onPause          If state is followed by onStop then it means we will going to background      AppActivityState state   AppState PAUSED    override fun onStop         super onStop           App will go to background base on the  pause  cue      if  AppActivityState state    AppState PAUSED            AppActivityState state   AppState ON BACKGROUND         onBackground             After creating BaseActivity  you just have to extend this activity to any activity on your app   In these type of implementation  you can accurately detect the following  - onBackground   app will go to background - onForeground   app will go back to foreground - onLaunch   app just opened  I hope this will help you

User · Answer

The principal problem is that you have to get an specific behavior when you start an activity from background  If you override your onPause   and onResume   methods  you ll have a close answer  but not the solution  The problem is that onPause   and onResume   methods are called even if you don t minimize your application  they can be called when you start an activity and later you press the back button to return to your activity  To eliminate that problem and to know really when your application comes from background  you must to get the running process and compare with your process   private boolean isApplicationBroughtToBackground         ActivityManager am    ActivityManager  getSystemService Context ACTIVITY SERVICE       List lt RunningTaskInfo gt  tasks   am getRunningTasks 1       if   tasks isEmpty              ComponentName topActivity   tasks get 0  topActivity          if   topActivity getPackageName   equals getPackageName                   return true                      return false      Now you have to declare a boolean variable   public boolean wasPaused   false    And ask when your activity comes to background    Override public void onPause        super onPause        if isApplicationBroughtToBackground            wasPaused   true      Now  when your activity comes to the screen again  ask in onResume   method    Override public void onResume        super onResume        if wasPaused           lockScreen true             wasPaused   false      And this is it  Now  when your activity comes to background  and later the user brings it to foreground  the lock screen will appear   If you want to repeat this behavior for whatever activity of your app  you have to create an activity  could be BaseActivity   put this methods  and all your activities have to inherit from BaseActivity   I hope that this help to you   Greetings

User · Answer

How about this solution  public class BaseActivity extends Activity        static String currentAct             Override     protected void onStart                 super onStart             if  currentAct equals                  Toast makeText this   Start   Toast LENGTH LONG  show             currentAct   getLocalClassName                Override     protected void onStop                 super onStop             if  currentAct equals getLocalClassName                           currentAct                   Toast makeText this   Stop   Toast LENGTH LONG  show                        All Activity need to extends BaseActivity   When an activity call another  A- B  then currentAct is not equal getLocalClassName   because the onStart   of the second activity  B  is called before the onStop   of the first  A   https   developer android com guide components activities html CoordinatingActivities     When the user press the home button or change between application will just call onStop   and then currentAct is equal getLocalClassName

User · Answer

You can use      protected void onRestart      To differ between new starts and restarts

User · Answer

I m using this solution  http   nathanael hevenet com android-dev-detecting-when-your-app-is-in-the-background-across-activities   In short- Build a dedicate service that every activity report him about each lifecycle event  and this service get the info about the status of the app   Very much like  oldschool4664 solution  but cleaner in my opinion

User · Answer

This appears to be one of the most complicated questions in Android since  as of this writing  Android doesn t have iOS equivalents of applicationDidEnterBackground   or applicationWillEnterForeground   callbacks  I used an AppState Library that was put together by  jenzz        AppState is  a simple  reactive Android library based on RxJava that monitors app state changes  It notifies subscribers every time the app goes into background and comes back into foreground    It turned out this is exactly what I needed  especially because my app had multiple activities so simply checking onStart   or onStop   on an activity wasn t going to cut it    First I added these dependencies to gradle   dependencies       compile  com jenzz appstate appstate 3 0 1      compile  com jenzz appstate adapter-rxjava2 3 0 1      Then it was a simple matter of adding these lines to an appropriate place in your code     Note that this uses RxJava 2 x adapter  Check the referenced github site for other ways of using observable Observable lt AppState gt  appState   RxAppStateMonitor monitor myApplication     where myApplication is a subclass of android app Application appState subscribe new Consumer lt AppState gt           Override     public void accept  io reactivex annotations NonNull AppState appState  throws Exception           switch  appState                case FOREGROUND                  Log i  info   App entered foreground                    break              case BACKGROUND                  Log i  info   App entered background                    break                        Depending on how you subscribe to the observable  you may have to unsubscribe from it to avoid memory leaks  Again more info on the  github page

User · Answer

Edit  the new architecture components brought something promising  ProcessLifecycleOwner  see  vokilam s  answer    The actual solution according to a Google I O talk   class YourApplication   Application        override fun onCreate         super onCreate       registerActivityLifecycleCallbacks AppLifecycleTracker             class AppLifecycleTracker   Application ActivityLifecycleCallbacks       private var numStarted   0    override fun onActivityStarted activity  Activity         if  numStarted    0             app went to foreground           numStarted          override fun onActivityStopped activity  Activity         numStarted--     if  numStarted    0             app went to background                Yes  I know it s hard to believe this simple solution works since we have so many weird solutions here   But there is hope

User · Answer

The onPause   and onResume   methods are called when the application is brought to the background and into the foreground again  However  they are also called when the application is started for the first time and before it is killed  You can read more in Activity   There isn t any direct approach to get the application status while in the background or foreground  but even I have faced this issue and found the solution with onWindowFocusChanged and onStop   For more details check here Android  Solution to detect when an Android app goes to the background and come back to the foreground without getRunningTasks or getRunningAppProcesses

User · Answer

The android arch lifecycle package provides classes and interfaces that let you build lifecycle-aware components  Your application should implement the LifecycleObserver interface   public class MyApplication extends Application implements LifecycleObserver         Override     public void onCreate             super onCreate            ProcessLifecycleOwner get   getLifecycle   addObserver this               OnLifecycleEvent Lifecycle Event ON STOP      private void onAppBackgrounded             Log d  MyApp    App in background                OnLifecycleEvent Lifecycle Event ON START      private void onAppForegrounded             Log d  MyApp    App in foreground              To do that  you need to add this dependency to your build gradle file   dependencies       implementation  android arch lifecycle extensions 1 1 1      As recommended by Google  you should minimize the code executed in the lifecycle methods of activities      A common pattern is to implement the actions of the dependent   components in the lifecycle methods of activities and fragments    However  this pattern leads to a poor organization of the code and to   the proliferation of errors  By using lifecycle-aware components  you   can move the code of dependent components out of the lifecycle methods   and into the components themselves    You can read more here  https   developer android com topic libraries architecture lifecycle

User · Answer

What I did is make sure that all in-app activities are launched with startActivityForResult then checking if onActivityResult was called before onResume  If it wasn t  it means we just returned from somewhere outside our app   boolean onActivityResultCalledBeforeOnResume    Override public void startActivity Intent intent        startActivityForResult intent  0       Override protected void onActivityResult int requestCode  int resultCode  Intent intent        super onActivityResult requestCode  resultCode  intent       onActivityResultCalledBeforeOnResume   true      Override protected void onResume         super onResume        if   onActivityResultCalledBeforeOnResume               here  app was brought to foreground           onActivityResultCalledBeforeOnResume   false

User · Answer

i know its a little late but i think all these answers do have some problems while i did it like below and that works perfect   create a activity life cycle callback like this    class ActivityLifeCycle implements ActivityLifecycleCallbacks        Override     public void onActivityCreated Activity activity  Bundle savedInstanceState                 Override     public void onActivityStarted Activity activity                Activity lastActivity       Override     public void onActivityResumed Activity activity              if  null    lastActivity     activity    null  amp  amp  activity    lastActivity     use this condition instead if you want to be informed also when  app has been killed or started for the first time         if  activity    null  amp  amp  activity    lastActivity                         Toast makeText MyApp this   NOW    Toast LENGTH LONG  show                       lastActivity   activity              Override     public void onActivityPaused Activity activity                 Override     public void onActivityStopped Activity activity                 Override     public void onActivitySaveInstanceState Activity activity  Bundle outState                 Override     public void onActivityDestroyed Activity activity               and just register it on your application class like below   public class MyApp extends Application     Override public void onCreate         super onCreate        registerActivityLifecycleCallbacks new ActivityLifeCycle

User · Answer

2018  Android supports this natively through lifecycle components  March 2018 UPDATE  There is now a better solution  See ProcessLifecycleOwner  You will need to use the new architecture components 1 1 0  latest at this time  but it   s specifically designed to do this  There   s a simple sample provided in this answer but I wrote a sample app and a blog post about it  Ever since I wrote this back in 2014  different solutions arose  Some worked  some were thought to be working  but had flaws  including mine   and we  as a community  Android  learned to live with the consequences and wrote workarounds for the special cases  Never assume a single snippet of code is the solution you   re looking for  it   s unlikely the case  better yet  try to understand what it does and why it does it  The MemoryBoss class was never actually used by me as written here  it was just a piece of pseudo code that happened to work  Unless there   s valid reason for you not to use the new architecture components  and there are some  especially if you target super old apis   then go ahead and use them  They are far from perfect  but neither were ComponentCallbacks2  UPDATE   NOTES  November 2015   People has been making two comments  first is that  gt   should be used instead of    because the documentation states that you shouldn t check for exact values  This is fine for most cases  but bear in mind that if you only care about doing something when the app went to the background  you will have to use    and also combine it with another solution  like Activity Lifecycle callbacks   or you may not get your desired effect  The example  and this happened to me  is that if you want to lock your app with a password screen when it goes to the background  like 1Password if you re familiar with it   you may accidentally lock your app if you run low on memory and are suddenly testing for  gt   TRIM MEMORY  because Android will trigger a LOW MEMORY call and that s higher than yours  So be careful how what you test  Additionally  some people have asked about how to detect when you get back  The simplest way I can think of is explained below  but since some people are unfamiliar with it  I m adding some pseudo code right here  Assuming you have YourApplication and the MemoryBoss classes  in your class BaseActivity extends Activity  you will need to create one if you don t have one    Override protected void onStart         super onStart         if  mApplication wasInBackground                 HERE YOU CALL THE CODE YOU WANT TO HAPPEN ONLY ONCE WHEN YOUR APP WAS RESUMED FROM BACKGROUND         mApplication setWasInBackground false            I recommend onStart because Dialogs can pause an activity so I bet you don t want your app to think  quot it went to the background quot  if all you did was display a full screen dialog  but your mileage may vary  And that s all  The code in the if block will only be executed once  even if you go to another activity  the new one  that also extends BaseActivity  will report wasInBackground is false so it won t execute the code  until onMemoryTrimmed is called and the flag is set to true again  Hope that helps  UPDATE   NOTES  April 2015   Before you go all Copy and Paste on this code  note that I have found a couple of instances where it may not be 100  reliable and must be combined with other methods to achieve the best results  Notably  there are two known instances where the onTrimMemory call back is not guaranteed to be executed   If your phone locks the screen while your app is visible  say your device locks after nn minutes   this callback is not called  or not always  because the lockscreen is just on top  but your app is still  quot running quot  albeit covered   If your device is relatively low on memory  and under memory stress   the Operating System seems to ignore this call and go straight to more critical levels    Now  depending how important it s for you to know when your app went to the background  you may or may not need to extend this solution together with keeping track of the activity lifecycle and whatnot  Just keep the above in mind and have a good QA team    END OF UPDATE It may be late but there s a reliable method in Ice Cream Sandwich  API 14  and Above  Turns out that when your app has no more visible UI  a callback is triggered  The callback  which you can implement in a custom class  is called ComponentCallbacks2  yes  with a two   This callback is only available in API Level 14  Ice Cream Sandwich  and above  You basically get a call to the method  public abstract void onTrimMemory  int level   The Level is 20 or more specifically public static final int TRIM MEMORY UI HIDDEN  I ve been testing this and it always works  because level 20 is just a  quot suggestion quot  that you might want to release some resources since your app is no longer visible  To quote the official docs   Level for onTrimMemory int   the process had been showing a user interface  and is no longer doing so  Large allocations with the UI should be released at this point to allow memory to be better managed   Of course  you should implement this to actually do what it says  purge memory that hasn t been used in certain time  clear some collections that have been sitting unused  etc  The possibilities are endless  see the official docs for other possible more critical levels   But  the interesting thing  is that the OS is telling you  HEY  your app went to the background  Which is exactly what you wanted to know in the first place  How do you determine when you got back  Well that s easy  I m sure you have a  quot BaseActivity quot  so you can use your onResume   to flag the fact that you re back  Because the only time you will be saying you re not back is when you actually receive a call to the above onTrimMemory method  It works  You don t get false positives  If an activity is resuming  you re back  100  of the times  If the user goes to the back again  you get another onTrimMemory   call  You need to suscribe your Activities  or better yet  a custom class   The easiest way to guarantee that you always receive this is to create a simple class like this  public class MemoryBoss implements ComponentCallbacks2        Override     public void onConfigurationChanged final Configuration newConfig                Override     public void onLowMemory                 Override     public void onTrimMemory final int level            if  level    ComponentCallbacks2 TRIM MEMORY UI HIDDEN                   We re in the Background                      you might as well implement some memory cleanup here and be a nice Android dev           In order to use this  in your Application implementation  you have one  RIGHT    do something like  MemoryBoss mMemoryBoss   Override public void onCreate        super onCreate       if  Build VERSION SDK INT  gt   Build VERSION CODES ICE CREAM SANDWICH          mMemoryBoss   new MemoryBoss          registerComponentCallbacks mMemoryBoss            If you create an Interface you could add an else to that if and implement ComponentCallbacks  without the 2  used in anything below API 14  That callback only has the onLowMemory   method and does not get called when you go to the background  but you should use it to trim memory  Now launch your App and press home  Your onTrimMemory final int level  method should be called  hint  add logging   The last step is to unregister from the callback  Probably the best place is the onTerminate   method of your App  but  that method doesn t get called on a real device          This method is for use in emulated process environments   It will    never be called on a production Android device  where processes are    removed by simply killing them  no user code  including this callback     is executed when doing so        So unless you really have a situation where you no longer want to be registered  you can safety ignore it  since your process is dying at OS level anyway  If you decide to unregister at some point  if you  for example  provide a shutdown mechanism for your app to clean up and die   you can do  unregisterComponentCallbacks mMemoryBoss    And that s it

User · Answer

My solution was inspired by  d60402 s answer and also relies on a time-window  but not using the Timer   public abstract class BaseActivity extends ActionBarActivity      protected boolean wasInBackground   false      Override   protected void onStart         super onStart        wasInBackground   getApp   isInBackground      getApp   isInBackground   false      getApp   lastForegroundTransition   System currentTimeMillis            Override   protected void onStop         super onStop        if  1500  lt  System currentTimeMillis   - getApp   lastForegroundTransition         getApp   isInBackground   true         protected SingletonApplication getApp        return  SingletonApplication getApplication            where the SingletonApplication is an extension of Application class   public class SingletonApplication extends Application     public boolean isInBackground   false    public long lastForegroundTransition   0

User · Answer

We use this method  It looks too simple to work  but it was well-tested in our app and in fact works surprisingly well in all cases  including going to home screen by  home  button  by  return  button  or after screen lock  Give it a try   Idea is  when in foreground  Android always starts new activity just before stopping previous one  That s not guaranteed  but that s how it works  BTW  Flurry seems to use the same logic  just a guess  I didn t check that  but it hooks at the same events     public abstract class BaseActivity extends Activity        private static int sessionDepth   0        Override     protected void onStart             super onStart                   sessionDepth            if sessionDepth    1             app came to foreground                        Override     protected void onStop             super onStop            if  sessionDepth  gt  0              sessionDepth--          if  sessionDepth    0                   app went to background                      Edit  as per comments  we also moved to onStart   in later versions of the code  Also  I m adding super calls  which were missing from my initial post  because this was more of a concept than a working code

User · Answer

I found a good method to detect application whether enter foreground or background  Here is my code   Hope this help you          Custom Application which can detect application state of whether it enter    background or enter foreground         reference http   www vardhan-justlikethat blogspot sg 2014 02 android-solution-to-detect-when-android html      public abstract class StatusApplication extends Application implements ActivityLifecycleCallbacks    public static final int STATE UNKNOWN   0x00  public static final int STATE CREATED   0x01  public static final int STATE STARTED   0x02  public static final int STATE RESUMED   0x03  public static final int STATE PAUSED   0x04  public static final int STATE STOPPED   0x05  public static final int STATE DESTROYED   0x06   private static final int FLAG STATE FOREGROUND   -1  private static final int FLAG STATE BACKGROUND   -2   private int mCurrentState   STATE UNKNOWN  private int mStateFlag   FLAG STATE BACKGROUND    Override public void onCreate         super onCreate        mCurrentState   STATE UNKNOWN      registerActivityLifecycleCallbacks this       Override public void onActivityCreated Activity activity  Bundle savedInstanceState           mCurrentState   STATE CREATED      Override public void onActivityStarted Activity activity        if  mCurrentState    STATE UNKNOWN    mCurrentState    STATE STOPPED            if  mStateFlag    FLAG STATE BACKGROUND                applicationWillEnterForeground                mStateFlag   FLAG STATE FOREGROUND                      mCurrentState   STATE STARTED       Override public void onActivityResumed Activity activity        mCurrentState   STATE RESUMED       Override public void onActivityPaused Activity activity        mCurrentState   STATE PAUSED       Override public void onActivityStopped Activity activity        mCurrentState   STATE STOPPED       Override public void onActivitySaveInstanceState Activity activity  Bundle outState         Override public void onActivityDestroyed Activity activity        mCurrentState   STATE DESTROYED      Override public void onTrimMemory int level        super onTrimMemory level       if  mCurrentState    STATE STOPPED  amp  amp  level  gt   TRIM MEMORY UI HIDDEN            if  mStateFlag    FLAG STATE FOREGROUND                applicationDidEnterBackground                mStateFlag   FLAG STATE BACKGROUND                 else if  mCurrentState    STATE DESTROYED  amp  amp  level  gt   TRIM MEMORY UI HIDDEN            if  mStateFlag    FLAG STATE FOREGROUND                applicationDidDestroyed                mStateFlag   FLAG STATE BACKGROUND                            The method be called when the application been destroyed  But when the    device screen off this method will not invoked      protected abstract void applicationDidDestroyed            The method be called when the application enter background  But when the    device screen off this method will not invoked      protected abstract void applicationDidEnterBackground            The method be called when the application enter foreground      protected abstract void applicationWillEnterForeground

User · Answer

This is my solution https   github com doridori AndroidUtils blob master App src main java com doridori lib app ActivityCounter java  Basically involved counting the lifecycle methods for all Activity s with a timer to catch cases where there is no activity currently in the foreground but the app is  i e  on rotation

User · Answer

In your Application add the callback and check for root activity in a way like this    Override public void onCreate         super onCreate        registerActivityLifecycleCallbacks new ActivityLifecycleCallbacks              Override         public void onActivityStopped Activity activity                        Override         public void onActivityStarted Activity activity                        Override         public void onActivitySaveInstanceState Activity activity  Bundle outState                        Override         public void onActivityResumed Activity activity                        Override         public void onActivityPaused Activity activity                        Override         public void onActivityDestroyed Activity activity                        Override         public void onActivityCreated Activity activity  Bundle savedInstanceState                if  activity isTaskRoot    amp  amp    activity instanceof YourSplashScreenActivity                     Log e YourApp TAG   Reload defaults on restoring from background                     loadDefaults

User · Answer

I have created a project on Github app-foreground-background-listen  Create a BaseActivity for all Activity in your application   public class BaseActivity extends Activity        public void onCreate Bundle savedInstanceState            super onCreate savedInstanceState           setRequestedOrientation ActivityInfo SCREEN ORIENTATION PORTRAIT              public static boolean isAppInFg   false      public static boolean isScrInFg   false      public static boolean isChangeScrFg   false        Override     protected void onStart             if   isAppInFg                isAppInFg   true              isChangeScrFg   false              onAppStart                      else               isChangeScrFg   true                    isScrInFg   true           super onStart                Override     protected void onStop             super onStop             if   isScrInFg     isChangeScrFg                isAppInFg   false              onAppPause                      isScrInFg   false             public void onAppStart                 Remove this toast         Toast makeText getApplicationContext     App in foreground      Toast LENGTH LONG  show                Your code            public void onAppPause                 Remove this toast         Toast makeText getApplicationContext     App in background    Toast LENGTH LONG  show                Your code           Now use this BaseActivity as a super class of all your Activity like MainActivity extends BaseActivity and onAppStart will be called when you start your application and onAppPause   will be called when the application goes the background from any screen

User · Answer

Create a class that extends Application  Then in it we can use its override method  onTrimMemory     To detect if the application went to the background  we will use     Override     public void onTrimMemory final int level            if  level    ComponentCallbacks2 TRIM MEMORY UI HIDDEN       Works for Activity                Get called every-time when application went to background                     else if  level    ComponentCallbacks2 TRIM MEMORY COMPLETE       Works for FragmentActivty

User · Answer

Since I did not find any approach  which also handles rotation without checking time stamps  I thought I also share how we now do it in our app   The only addition to this answer https   stackoverflow com a 42679191 5119746 is  that we also take the orientation into consideration   class MyApplication   Application    Application ActivityLifecycleCallbacks          Members     private var mAppIsInBackground   false    private var mCurrentOrientation  Int    null    private var mOrientationWasChanged   false    private var mResumed   0    private var mPaused   0   Then  for the callbacks we have the resume first         ActivityLifecycleCallbacks     override fun onActivityResumed activity  Activity            mResumed          if  mAppIsInBackground                     App came from background     Insert code           mAppIsInBackground   false               mOrientationWasChanged   false         And onActivityStopped      override fun onActivityStopped activity  Activity             if  mResumed    mPaused  amp  amp   mOrientationWasChanged                   App moved to background     Insert code          mAppIsInBackground   true         And then  here comes the addition  Checking for orientation changes      override fun onConfigurationChanged newConfig  Configuration            if  newConfig orientation    mCurrentOrientation               mCurrentOrientation   newConfig orientation            mOrientationWasChanged   true                 super onConfigurationChanged newConfig         That s it  Hope this helps someone

User · Answer

You can achieve this easily with the help of ActivityLifecycleCallbacks and ComponentCallbacks2 something like below   Create a class AppLifeCycleHandler implementing above said interfaces   package com sample app   import android app Activity  import android app Application  import android content ComponentCallbacks2  import android content res Configuration  import android os Bundle          Created by Naveen on 17 04 18     public class AppLifeCycleHandler     implements Application ActivityLifecycleCallbacks  ComponentCallbacks2      AppLifeCycleCallback appLifeCycleCallback     boolean appInForeground     public AppLifeCycleHandler AppLifeCycleCallback appLifeCycleCallback        this appLifeCycleCallback   appLifeCycleCallback          Override   public void onActivityResumed Activity activity        if   appInForeground          appInForeground   true        appLifeCycleCallback onAppForeground                  Override   public void onTrimMemory int i        if  i    ComponentCallbacks2 TRIM MEMORY UI HIDDEN          appInForeground   false        appLifeCycleCallback onAppBackground                  Override   public void onActivityCreated Activity activity  Bundle bundle             Override   public void onActivityStarted 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             Override   public void onConfigurationChanged Configuration configuration             Override   public void onLowMemory             interface AppLifeCycleCallback        void onAppBackground         void onAppForeground            In your class which extends Application implement AppLifeCycleCallback to get the callbacks when app switches between foreground and background  Something like below   public class BaseApplication extends Application implements AppLifeCycleHandler AppLifeCycleCallback        Override     public void onCreate             super onCreate            AppLifeCycleHandler appLifeCycleHandler   new AppLifeCycleHandler this           registerActivityLifecycleCallbacks appLifeCycleHandler           registerComponentCallbacks appLifeCycleHandler               Override     public void onAppBackground             Log d  LifecycleEvent    onAppBackground                Override     public void onAppForeground             Log d  LifecycleEvent    onAppForeground              Hope this helps    EDIT As an alternative you can now use Life cycle aware architecture component

User · Answer

Edit 2  What I ve written below will not actually work  Google has rejected an app that includes a call to ActivityManager getRunningTasks    From the documentation  it is apparent that this API is for debugging and development purposes only  I ll be updating this post as soon as I have time to update the GitHub project below with a new scheme that uses timers and is almost as good   Edit 1  I ve written up a blog post and created a simple GitHub repository to make this really easy   The accepted and top rated answer are both not really the best approach  The top rated answer s implementation of isApplicationBroughtToBackground   does not handle the situation where the Application s main Activity is yielding to an Activity that is defined in the same Application  but it has a different Java package  I came up with a way to do this that will work in that case   Call this in onPause    and it will tell you if your application is going into the background because another application has started  or the user has pressed the home button   public static boolean isApplicationBroughtToBackground final Activity activity      ActivityManager activityManager    ActivityManager  activity getSystemService Context ACTIVITY SERVICE     List lt ActivityManager RunningTaskInfo gt  tasks   activityManager getRunningTasks 1         Check the top Activity against the list of Activities contained in the Application s package    if   tasks isEmpty          ComponentName topActivity   tasks get 0  topActivity      try         PackageInfo pi   activity getPackageManager   getPackageInfo activity getPackageName    PackageManager GET ACTIVITIES         for  ActivityInfo activityInfo   pi activities            if topActivity getClassName   equals activityInfo name               return false                          catch  PackageManager NameNotFoundException e          return false     Never happens              return true

User · Answer

This is the modified version of  d60402 s answer  https   stackoverflow com a 15573121 4747587  Do everything mentioned there  But instead of having a Base Activity and making that as a parent for every activity and the overriding the onResume   and onPause  do the below   In your application class  add the line   registerActivityLifecycleCallbacks Application ActivityLifecycleCallbacks callback    This callback has all the activity lifecycle methods and you can now override onActivityResumed   and onActivityPaused     Take a look at this Gist  https   gist github com thsaravana 1fa576b6af9fc8fff20acfb2ac79fa1b

User · Answer

If your app consists of multiple activites and or stacked activites like a tab bar widget  then overriding onPause   and onResume   will not work  I e when starting a new activity the current activites will get paused before the new one is created  The same applies when finishing  using  back  button  an activity   I ve found two methods that seem to work as wanted   The first one requires the GET TASKS permission and consists of a simple method that checks if the top running activity on the device belongs to application  by comparing package names   private boolean isApplicationBroughtToBackground         ActivityManager am    ActivityManager  context getSystemService Context ACTIVITY SERVICE       List lt RunningTaskInfo gt  tasks   am getRunningTasks 1       if   tasks isEmpty              ComponentName topActivity   tasks get 0  topActivity          if   topActivity getPackageName   equals context getPackageName                   return true                       return false      This method was found in the Droid-Fu  now called Ignition  framework   The second method that I ve implemented my self does not require the GET TASKS permission  which is good  Instead it is a little more complicated to implement   In you MainApplication class you have a variable that tracks number of running activities in your application  In onResume   for each activity you increase the variable and in onPause   you decrease it    When the number of running activities reaches 0  the application is put into background IF the following conditions are true    The activity being paused is not being finished   back  button was used   This can be done by using method activity isFinishing   A new activity  same package name  is not being started  You can override the startActivity   method to set a variable that indicates this and then reset it in onPostResume    which is the last method to be run when an activity is created resumed    When you can detect that the application has resigned to the background it is easy detect when it is brought back to foreground as well

[android] How to detect when an Android app goes to the background and come back to the foreground

Examples related to android

Examples related to background

Examples related to foreground