Difference between getContext() , getApplicationContext() , getBaseContext() and "this"
Solution 1
View.getContext()
: Returns the context the view is currently running in. Usually the currently active Activity.Activity.getApplicationContext()
: Returns the context for the entire application (the process all the Activities are running inside of). Use this instead of the current Activity context if you need a context tied to the lifecycle of the entire application, not just the current Activity.ContextWrapper.getBaseContext()
: If you need access to a Context from within another context, you use a ContextWrapper. The Context referred to from inside that ContextWrapper is accessed via getBaseContext().
Solution 2
Most answers already cover getContext()
and getApplicationContext()
but getBaseContext() is rarely explained.
The method getBaseContext()
is only relevant when you have a ContextWrapper
.
Android provides a ContextWrapper
class that is created around an existing Context
using:
ContextWrapper wrapper = new ContextWrapper(context);
The benefit of using a ContextWrapper
is that it lets you “modify behavior without changing the original Context”. For example, if you have an activity called myActivity
then can create a View
with a different theme than myActivity
:
ContextWrapper customTheme = new ContextWrapper(myActivity) {
@Override
public Resources.Theme getTheme() {
return someTheme;
}
}
View myView = new MyView(customTheme);
ContextWrapper
is really powerful because it lets you override most functions provided by Context
including code to access resources (e.g. openFileInput()
, getString()
), interact with other components (e.g. sendBroadcast()
, registerReceiver()
), requests permissions (e.g. checkCallingOrSelfPermission()
) and resolving file system locations (e.g. getFilesDir()
). ContextWrapper
is really useful to work around device/version specific problems or to apply one-off customizations to components such as Views that require a context.
The method getBaseContext() can be used to access the “base” Context that the ContextWrapper
wraps around. You might need to access the “base” context if you need to, for example, check whether it’s a Service
, Activity
or Application
:
public class CustomToast {
public void makeText(Context context, int resId, int duration) {
while (context instanceof ContextWrapper) {
context = context.baseContext();
}
if (context instanceof Service)) {
throw new RuntimeException("Cannot call this from a service");
}
...
}
}
Or if you need to call the “unwrapped” version of a method:
class MyCustomWrapper extends ContextWrapper {
@Override
public Drawable getWallpaper() {
if (BuildInfo.DEBUG) {
return mDebugBackground;
} else {
return getBaseContext().getWallpaper();
}
}
}
Solution 3
The question "what the Context is" is one of the most difficult questions in the Android universe.
Context defines methods that access system resources, retrieve application's static assets, check permissions, perform UI manipulations and many more. In essence, Context
is an example of God Object anti-pattern in production.
When it comes to which kind of Context
should we use, it becomes very complicated because except for being God Object, the hierarchy tree of Context
subclasses violates Liskov Substitution Principle brutally.
This blog post (now from Wayback Machine) attempts to summarize Context
classes applicability in different situations.
Let me copy the main table from that post for completeness:
+----------------------------+-------------+----------+---------+-----------------+-------------------+ | | Application | Activity | Service | ContentProvider | BroadcastReceiver | +----------------------------+-------------+----------+---------+-----------------+-------------------+ | Show a Dialog | NO | YES | NO | NO | NO | | Start an Activity | NO¹ | YES | NO¹ | NO¹ | NO¹ | | Layout Inflation | NO² | YES | NO² | NO² | NO² | | Start a Service | YES | YES | YES | YES | YES | | Bind to a Service | YES | YES | YES | YES | NO | | Send a Broadcast | YES | YES | YES | YES | YES | | Register BroadcastReceiver | YES | YES | YES | YES | NO³ | | Load Resource Values | YES | YES | YES | YES | YES | +----------------------------+-------------+----------+---------+-----------------+-------------------+
- An application CAN start an Activity from here, but it requires that a new task be created. This may fit specific use cases, but can create non-standard back stack behaviors in your application and is generally not recommended or considered good practice.
- This is legal, but inflation will be done with the default theme for the system on which you are running, not what’s defined in your application.
- Allowed if the receiver is null, which is used for obtaining the current value of a sticky broadcast, on Android 4.2 and above.
Solution 4
getApplicationContext() - Returns the context for all activities running in application.
getBaseContext() - If you want to access Context from another context within application you can access.
getContext() - Returns the context view only current running activity.
Solution 5
Context
provides information about the Actvity
or Application
to newly created components.
Relevant Context
should be provided to newly created components (whether application context or activity context)
Since Activity
is a subclass of Context
, one can use this
to get that activity's context
iCurious
Updated on February 13, 2022Comments
-
iCurious over 2 years
What is the difference between
getContext()
,getApplicationContext()
,getBaseContext()
, and "this
"?Though this is simple question I am unable to understand the basic difference between them. Please give some easy examples if possible.
-
Mikey over 11 years+CooL i3oY same with getContext
-
Ravi over 11 yearsactually i am confuse that what is the proper defination of context??
-
KCRaju almost 11 years"this" and getContext() both are same
-
Subby over 10 years+1 for the detailed answer. I would give this another update (if I could) if i contained a real life example of each of the
Context
s so that the forum and I can get a clearer understanding of how they're used. And maybe what object requires which of theContext
s. -
Maxrunner over 10 yearsWhat if you get your Application extented class?
-
Jacob over 9 yearsYou said about "Usually the currently active Activity.", what it could be in other cases if not currently active Activity? Thx
-
nandan about 9 years
this
andgetContext()
are not always same e.g. in Activity class, you can usethis
becauseActivity
inherits fromContext
but methodgetContext()
is not inActivity
class. @mikedroid @KCRaju -
LarsH almost 9 years
this
gives an instance of the class it's in, which could be any class, not necessarily a context. If you use it in an Activity class, thenthis
will be an instance of aContext
. -
Jeffrey Chen over 8 yearsYou can not use
this
in an inner class of anActivity
, but you can usegetContext()
. -
HopefullyHelpful over 7 yearsPls incorporate letter A and B into your definition of context withhin context, it's not clear in any answer which context is accessed.
-
0leg about 7 yearsI would say, this is the most important answer after an accepted one.
-
bgs about 7 yearsThis might be Java syntax help to some:
YourActivity.this.getApplicationContext()
will qualify your context from instance ofYourActivity
. Otherwise above answer is great - it is all about the lifecycle of code you are writing - out living the activity/fragment or not. -
CoDe almost 7 yearsTo understand first point view.getContext() better refer this.
-
CopsOnRoad over 6 years
getBaseContext()
needs more explaination perhaps with an example. -
Vasiliy over 6 yearsI would say that the existence of
ContextWrapper
is one of the worst decisions ever made by developers of Android framework. When they realized that they created an entire family of God Objects, instead of doing the right thing and refactoring the code toward Single Responsibility, they added an ugly hack that allowed to change Context behavior by deepening the inheritance tree. Bad software engineering at its ugliest. As for us, developers, IMHO no one should ever usegetBaseContext()
orContextWrapper
. If you do - it is a huge "code smell". -
isJulian00 almost 5 years@nandan you said "getContext() is not in Activity class" what do you mean by that ? I thought we are able to use getContext() in Activity class ?
-
Alston over 4 yearsI'd like to see the complete
CustomToast
code. THANKS:))) -
Bawender Yandra almost 4 yearsThank you for this answer, I was not aware that ContextWrapper was to be used like this!! I always thought it was something internal from the Android Team. In my sense, this is the expected Answer. T H A N K S !!!
-
The incredible Jan over 2 years@isJulian00 Activity is a subclass of Context. "context.getContext" would make much sense. "this" already IS the context in Activity.
-
Kipruto about 2 yearsso for example basecontext would be like for example a state of a button within a view? correct me if I'm wrong