This is Android equivalent to iOS applicationDidBecomeActive or applicationDidEnterBackground. However the same implementation in Android is much more complicated. Here is how you can do this properly.

This is essentially equivalent to iOS applicationDidBecomeActive or applicationDidEnterBackground in Android. However the same implementation in Android is much more complicated. Here is how you can do this properly.

App Lifecycle

On Android we use the LifecycleObserver from androidx.lifecycle.lifecycleObserver. First create an object that implements LifecycleObserver in your project. For example:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package handlers;

import androidx.lifecycle.Lifecycle;
import androidx.lifecycle.LifecycleObserver;
import androidx.lifecycle.OnLifecycleEvent;
import presentation.interfaces.AppLifecycleCallback;

public class AppLifecycleListener implements LifecycleObserver {

    private AppLifecycleCallback delegate;

    public AppLifecycleListener(AppLifecycleCallback delegate) {
        this.delegate = delegate;
    }

    @SuppressWarnings("unused")
    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    void onAppBecomeActive() {
        delegate.onAppBecomeActive();
    }
    @SuppressWarnings("unused")
    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    void onAppDidEnterBackground() {
        delegate.onAppDidEnterBackground();
    }
}

The AppLifecycleCallback delegate is an interface we created in the project.

1
2
3
4
5
6
package presentation.interfaces;

public interface AppLifecycleCallback {
    void onAppBecomeActive();
		void onAppDidEnterBackground();
}

Now we will host an instance of the above object inside your app application object. Note that your application will implement the AppLifecycleCallback 

1
private AppLifecycleListener mAppLifecycleListener = new AppLifecycleListener(this);

After that, register it inside your application onCreate.

1
ProcessLifecycleOwner.get().getLifecycle().addObserver(mAppLifecycleListener);

Now if you run the app, and bring the app to background, or active your app, those callback function will be triggered inside your application object. However, most of times, you will want activity to handle those actions. How to reach to your activity?

Activity Lifecycle

My solution is to implement Application.ActivityLifecycleCallbacks to host a topmost activity within the reach of the application object. 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
package handlers;

import android.app.Activity;
import android.app.Application;
import android.os.Bundle;

import androidx.annotation.NonNull;
import androidx.annotation.Nullable;

public class AppActivityLifecycleCallbacks implements Application.ActivityLifecycleCallbacks {

    @Nullable
    public Activity onTopActivity = null;

    @Override
    public void onActivityCreated(@NonNull Activity activity, @Nullable Bundle bundle) {

    }

    @Override
    public void onActivityStarted(@NonNull Activity activity) {

    }

    @Override
    public void onActivityResumed(@NonNull Activity activity) {
        onTopActivity = activity;
    }

    @Override
    public void onActivityPaused(@NonNull Activity activity) {

    }

    @Override
    public void onActivityStopped(@NonNull Activity activity) {

    }

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

    }

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

    }
}

This is my listener. I only need to get access to the top most activity so all I need to monitor is the onActivityResumed function.

Now we will need to put this as a reference in the application object, and register the callback in the onCreate function.

1
2
3
private AppActivityLifecycleCallbacks mActivityLifecycleCallbacks = new AppActivityLifecycleCallbacks();
// Inside function onCreate:
registerActivityLifecycleCallbacks(mActivityLifecycleCallbacks)

Now, in the Application callbacks, we can check the top most activity if they implements AppLifeCycleCallback, if yes, then redirect the call, if not, then ignore. Then we will just need to implement AppLifeCycleCallback in the Activity that we want to handle the event.

1
2
3
4
5
6
7
8
// For example under XXApplication.java
@Override
  public void onAppBecomeActive() {
      Activity onTopActivity = mActivityLifecycleCallbacks.onTopActivity;
      if (onTopActivity instanceof AppLifecycleCallback) {
          ((AppLifecycleCallback) onTopActivity).onAppBecomeActive();
      }
  }

Now, this is my application class, which includes both app lifecycle and activity lifecycle. 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class MyApplication extends MultiDexApplication implements AppLifecycleCallback 
{

    private AppActivityLifecycleCallbacks mActivityLifecycleCallbacks = new AppActivityLifecycleCallbacks();

    private AppLifecycleListener mAppLifecycleListener = new AppLifecycleListener(this);

    @Override
    public void onCreate() {
        super.onCreate();
				// custom onCreate logic.
        registerActivityLifecycleCallbacks(mActivityLifecycleCallbacks);
        ProcessLifecycleOwner.get().getLifecycle().addObserver(mAppLifecycleListener);
    }

    //region Implement AppLifecycleCallback
    @Override
    public void onAppBecomeActive() {
        Activity onTopActivity = mActivityLifecycleCallbacks.onTopActivity;
        if (onTopActivity instanceof AppLifecycleCallback) {
            ((AppLifecycleCallback) onTopActivity).onAppBecomeActive();
        }
    }
    //endregion
}

Assume I want to handle onAppBecomesActive under MainActivity:

1
2
3
4
5
6
7
8
9
10
11
12
13
public class MainActivity extends BaseActivity implements AppLifecycleCallback 
{

    // Other MainActivity functions....

    //region Implement AppLifecycleCallback
    @Override
    public void onAppBecomeActive() {
				// Do anything you want to do when app is active, for example:
        myFragment.showTint().isActive()....
    }
    //endregion
}