How to check if activity is in foreground or in visible background?
This is what is recommended as the right solution:
The right solution (credits go to Dan, CommonsWare and NeTeInStEiN)
Track visibility of your application by yourself using
Activity.onPause, Activity.onResume methods. Store "visibility" status
in some other class. Good choices are your own implementation of the
Application or a Service (there are also a few variations of this
solution if you'd like to check activity visibility from the service).Example
Implement custom Application class (note the isActivityVisible() static method):
public class MyApplication extends Application {
public static boolean isActivityVisible() {
return activityVisible;
}
public static void activityResumed() {
activityVisible = true;
}
public static void activityPaused() {
activityVisible = false;
}
private static boolean activityVisible;
}
Register your application class in AndroidManifest.xml:
<application
android:name="your.app.package.MyApplication"
android:icon="@drawable/icon"
android:label="@string/app_name" >
Add onPause and onResume to every Activity in the project (you may
create a common ancestor for your Activities if you'd like to, but if
your activity is already extended from MapActivity/ListActivity etc.
you still need to write the following by hand):
@Override
protected void onResume() {
super.onResume();
MyApplication.activityResumed();
}
@Override
protected void onPause() {
super.onPause();
MyApplication.activityPaused();
}
In your finish()
method, you want to use isActivityVisible()
to check if the activity is visible or not. There you can also check if the user has selected an option or not. Continue when both conditions are met.
The source also mentions two wrong solutions...so avoid doing that.
Source: stackoverflow
How to detect if any of my activity is front-most and visible to user?
I don't know that there's a method to get the currently displayed activity, but you could do something combining the Activity Lifecycle and a flag.
For the flag, if you've extended the Application class, that's probably a decent place to store it. For extending the application class, the top answer to this question has info. (d).
So probably keep track of the current active activity (or a flag that the activity is visible) in onResume/onPause or onStart/onStop depending on exactly what behavior you want.
Since you have multiple activities, you'll need a centroid place for storing the flag, which is why the Application makes sense. You can get the custom Application object by casting the application context (e.g. ((MyApplication)getApplicationContext()).isMyActivityActive).
You could extend Activity as well to help keep this code clean and contained.
If you're using a service you could bind to the service in every activity in the onStart/onStop (or onResume/onPause). If bound, you're visible.
How to know if my application is in foreground or background, android?
Original Answer : https://stackoverflow.com/a/60212452/10004454
The recommended way to do it in accordance with Android documentation is
class MyApplication : Application(), LifecycleObserver {
override fun onCreate() {
super.onCreate()
ProcessLifecycleOwner.get().lifecycle.addObserver(this);
}
fun isActivityVisible(): String {
return ProcessLifecycleOwner.get().lifecycle.currentState.name
}
@OnLifecycleEvent(Lifecycle.Event.ON_STOP)
fun onAppBackgrounded() {
//App in background
Log.e(TAG, "************* backgrounded")
Log.e(TAG, "************* ${isActivityVisible()}")
}
@OnLifecycleEvent(Lifecycle.Event.ON_START)
fun onAppForegrounded() {
Log.e(TAG, "************* foregrounded")
Log.e(TAG, "************* ${isActivityVisible()}")
// App in foreground
}}
In your gradle (app) add : implementation "androidx.lifecycle:lifecycle-extensions:2.2.0"
Then to check the state at runtime call MyApplication().isActivityVisible()
Knowing if activity is running on foreground or background
Expanding on mco's answer, your GCMIntentService
needs to do something that will trigger work in a foreground activity of yours, if you have a foreground activity. Typically, you will do this by setting up your activities to respond to some sort of message in onResume()
and removing that in onPause()
.
"Some sort of message" could be:
- An
Intent
sent viaLocalBroadcastManager
- An
Intent
sent via the classicsendBroadcast()
- A message via a message bus, like Otto
- Etc.
How to check if my activity is the current activity running in the screen
When your Activity comes to the foreground, its onResume()
method will be invoked. When another Activity comes in front of your Activity, its onPause()
method will be invoked. So all you need to do is implement a boolean indicating if your Activity is in the foreground:
private boolean isInFront;
@Override
public void onResume() {
super.onResume();
isInFront = true;
}
@Override
public void onPause() {
super.onPause();
isInFront = false;
}
Related Topics
How to Open/Display Documents(.Pdf, .Doc) Without External App
Scrollview Can Host Only One Direct Child
Android SQLite How to Check If a Record Exists
Source of Android's Lock Screen
How to Set Textinputlayout Error Message Colour
Why Use Android Picasso Library to Download Images
Uploading a Large File in Multipart Using Okhttp
Android: How to Remove Margin/Padding in Preference Screen
Converting Bitmap to Bytearray Android
How to Set a Font for the Options Menu
Android: How to Get Value of an Attribute in Code
How to Prevent an Application from Being Uninstalled
Android: Using Webview Outside an Activity Context
Register Application Class in Manifest