In Android programming, what exactly is a Context class and what is it used for?
I read about it on the developer site, but I am unable to understand it clearly.
2103
votes
30 Answers
1605
votes
Putting it simply:
As the name suggests, it's the context of the current state of the application/object. It lets newly-created objects understand what has been going on. Typically you call it to get information regarding another part of your program (activity and package/application).
You can get the context by invoking getApplicationContext(), getContext(), getBaseContext() or this (when in a class that extends from Context, such as the Application, Activity, Service and IntentService classes).
Typical uses of context:
Creating new objects: Creating new views, adapters, listeners:
TextView tv = new TextView(getContext()); ListAdapter adapter = new SimpleCursorAdapter(getApplicationContext(), ...);Accessing standard common resources: Services like LAYOUT_INFLATER_SERVICE, SharedPreferences:
context.getSystemService(LAYOUT_INFLATER_SERVICE) getApplicationContext().getSharedPreferences(*name*, *mode*);Accessing components implicitly: Regarding content providers, broadcasts, intent
getApplicationContext().getContentResolver().query(uri, ...);
542
votes
Definition of Context
- Context represents environment data
- It provides access to things such as databases
Simpler terms (example 1)
Consider Person-X is the CEO of a start-up software company.
There is a lead architect present in the company, this lead architect does all the work in the company which involves such as database, UI etc.
Now the CEO Hires a new Developer.
It is the Architect who tells the responsibility of the newly hired person based on the skills of the new person that whether he will work on Database or UI etc.
Simpler terms (example 2)
It's like access to android activity to the app's resource.
It's similar to when you visit a hotel, you want breakfast, lunch & dinner in the suitable timings, right?
There are many other things you like during the time of stay. How do you get these things?
You ask the room-service person to bring these things for you.
Here the room-service person is the context considering you are the single activity and the hotel to be your app, finally the breakfast, lunch & dinner has to be the resources.
Things that involve context are:
- Loading a resource.
- Launching a new activity.
- Creating views.
- obtaining system service.
Context is the base class for Activity, Service, Application, etc
Another way to describe this: Consider context as remote of a TV & channel's in the television are resources, services, using intents, etc - - - Here remote acts as an access to get access to all the different resources into the foreground.
So, Remote has access to channels such as resources, services, using intents, etc ....
Likewise ... Whoever has access to remote naturally has access to all the things such as resources, services, using intents, etc
Different methods by which you can get context
getApplicationContext()getContext()getBaseContext()- or
this(when in the activity class)
Example:
TextView tv = new TextView(this);
The keyword this refers to the context of the current activity.
420
votes
The topic of Context in Android seems to be confusing to many. People just know that Context is needed quite often to do basic things in Android. People sometimes panic because they try to do perform some operation that requires the Context and they don’t know how to “get” the right Context. I’m going to try to demystify the idea of Context in Android. A full treatment of the issue is beyond the scope of this post, but I’ll try to give a general overview so that you have a sense of what Context is and how to use it. To understand what Context is, let’s take a look at the source code:
What exactly is Context?
Well, the documentation itself provides a rather straightforward explanation: The Context class is an “Interface to global information about an application environment".
The Context class itself is declared as an abstract class, whose implementation is provided by the Android OS. The documentation further provides that Context “…allows access to application-specific resources and classes, as well as up-calls for application-level operations such as launching activities, broadcasting and receiving intents, etc".
You can understand very well, now, why the name is Context. It’s because it’s just that. The Context provides the link or hook, if you will, for an Activity, Service, or any other component, thereby linking it to the system, enabling access to the global application environment. In other words: the Context provides the answer to the components question of “where the hell am I in relation to app generally and how do I access/communicate with the rest of the app?” If this all seems a bit confusing, a quick look at the methods exposed by the Context class provides some further clues about its true nature.
Here’s a random sampling of those methods:
getAssets()getResources()getPackageManager()getString()getSharedPrefsFile()
What do all these methods have in common? They all enable whoever has access to the Context to be able to access application-wide resources.
Context, in other words, hooks the component that has a reference to it to the rest of the application environment. The assets (think ’/assets’ folder in your project), for example, are available across the application, provided that an Activity, Service, or whatever knows how to access those resources.
The same goes for getResources() which allows us to do things like getResources().getColor() which will hook you into the colors.xml resource (nevermind that aapt enables access to resources via java code, that’s a separate issue).
The upshot is that Context is what enables access to system resources and its what hook components into the “greater app".
Let’s look at the subclasses of Context, the classes that provide the implementation of the abstract Context class.
The most obvious class is the Activity class. Activity inherits from ContextThemeWrapper, which inherits from ContextWrapper, which inherits from Context itself.
Those classes are useful to look at to understand things at a deeper level, but for now, it’s sufficient to know that ContextThemeWrapper and ContextWrapper are pretty much what they sound like.
They implement the abstract elements of the Context class itself by “wrapping” a context (the actual context) and delegating those functions to that context.
An example is helpful - in the ContextWrapper class, the abstract method getAssets from the Context class is implemented as follows:
@Override
public AssetManager getAssets() {
return mBase.getAssets();
}
mBase is simply a fieldset by the constructor to a specific context.
So a context is wrapped and the ContextWrapper delegates its implementation of the getAssets method to that context. Let’s get back to examining the Activity class which ultimately inherits from Context to see how this all works.
You probably know what an Activity is, but to review - it’s basically 'a single thing the user can do. It takes care of providing a window in which to place the UI that the user interacts with'.
Developers familiar with other APIs and even non-developers might think of it vernacularly as a “screen.” That’s technically inaccurate, but it doesn’t matter for our purposes. So how do Activity and Context interact and what exactly is going in their inheritance relationship?
Again, it’s helpful to look at specific examples. We all know how to launch Activities. Provided you have “the context” from which you are starting the Activity, you simply call startActivity(intent), where the Intent describes the context from which you are starting an Activity and the Activity you’d like to start. This is the familiar startActivity(this, SomeOtherActivity.class).
And what is this? this is your Activity because the Activity class inherits from Context. The full scoop is like this: When you call startActivity, ultimately the Activity class executes something like this:
Instrumentation.ActivityResult ar =
mInstrumentation.execStartActivity(
this, mMainThread.getApplicationThread(), mToken, this,
intent, requestCode);
So it utilizes the execStartActivity from the Instrumentation class (actually from an inner class in Instrumentation called ActivityResult).
At this point, we are beginning to get a peek at the system internals.
This is where OS actually handles everything. So how does Instrumentation start the Activity exactly? Well, the param this in the execStartActivity method above is your Activity, i.e. the Context, and the execStartActivity makes use of this context.
A 30,000 overview is this: the Instrumentation class keeps tracks of a list of Activities that it’s monitoring in order to do its work. This list is used to coordinate all of the activities and make sure everything runs smoothly in managing the flow of activities.
There are some operations that I haven’t fully looked into which coordinate thread and process issues. Ultimately, the ActivityResult uses a native operation - ActivityManagerNative.getDefault().startActivity() which uses the Context that you passed in when you called startActivity. The context you passed in is used to assist in “intent resolution” if needed. Intent resolution is the process by which the system can determine the target of the intent if it is not supplied. (Check out the guide here for more details).
And in order for Android to do this, it needs access to information that is supplied by Context. Specifically, the system needs to access to a ContentResolver so it can “determine the MIME type of the intent’s data".
This whole bit about how startActivity makes use of context was a bit complicated and I don’t fully understand the internals myself. My main point was just to illustrate how application-wide resources need to be accessed in order to perform many of the operations that are essential to an app. Context is what provides access to these resources.
A simpler example might be Views. We all know what you create a custom View by extending RelativeLayout or some other View class, you must provide a constructor that takes a Context as an argument. When you instantiate your custom View you pass in the context.
Why? Because the View needs to be able to have access to themes, resources, and other View configuration details.
View configuration is actually a great example. Each Context has various parameters (fields in Context’s implementations) that are set by the OS itself for things like the dimension or density of the display. It’s easy to see why this information is important for setting up Views, etc.
One final word: For some reason, people new to Android (and even people not so new) seem to completely forget about object-oriented programming when it comes to Android. For some reason, people try to bend their Android development to pre-conceived paradigms or learned behaviors.
Android has it’s own paradigm and a certain pattern that is actually quite consistent if let go of your preconceived notions and simply read the documentation and dev guide. My real point, however, while “getting the right context” can sometimes be tricky, people unjustifiably panic because they run into a situation where they need the context and think they don’t have it. Once again, Java is an object-oriented language with an inheritance design.
You only “have” the context inside of your Activity because your activity itself inherits from Context. There’s no magic to it (except for all the stuff the OS does by itself to set various parameters and to correctly “configure” your context). So, putting memory/performance issues aside (e.g. holding references to context when you don’t need to or doing it in a way that has negative consequences on memory, etc), Context is an object like any other and it can be passed around just like any POJO (Plain Old Java Object). Sometimes you might need to do clever things to retrieve that context, but any regular Java class that extends from nothing other than Object itself can be written in a way that has access to context; simply expose a public method that takes a context and then uses it in that class as needed. This was not intended as an exhaustive treatment on Context or Android internals, but I hope it’s helpful in demystifying Context a little bit.
125
votes
A Context is a handle to the system; it provides services like resolving resources, obtaining access to databases and preferences, and so on. An Android app has activities. Context is like a handle to the environment your application is currently running in. The activity object inherits the Context object.
For more information, look in Introduction to Android development with Android Studio - Tutorial.
97
votes
Context is an "interface" to the global information about an application environment. In practice, Context is actually an abstract class, whose implementation is provided by the Android system.
It allows access to application-specific resources and classes, as well as up-calls for application-level operations, such as launching activities, broadcasting and receiving intents, etc.
In the following picture, you can see a hierarchy of classes, where Context is the root class of this hierarchy. In particular, it's worth emphasizing that Activity is a descendant of Context.
74
votes
What's Context exactly?
Per the Android reference documentation, it's an entity that represents various environment data. It provides access to local files, databases, class loaders associated to the environment, services (including system-level services), and more. Throughout this book, and in your day-to-day coding with Android, you'll see the Context passed around frequently.
From the "Android in Practice" book, p. 60.
Several Android APIs require a Context as parameter
If you look through the various Android APIs, you’ll
notice that many of them take an android.content.Context object as a
parameter. You’ll also see that an Activity or a Service is usually used as a
Context. This works because both of these classes extend from Context.
62
votes
Simple Example to understand context in android :
Every boss has an assistant to look after, to do all less important and time-consuming tasks. If a file or a cup of coffee is needed, an assistant is on the run. Some bosses barely know what’s going on in the office, so they ask their assistants regarding this too. They do some work themselves but for most other things they need the help of their assistants.
In this scenario,
Boss – is the Android application
Assistant – is a context
Files/Cup of coffee – are resources
We generally call context when we need to get information about different parts of our application like Activities, Applications, etc.
Some operations(things where the assistant is needed) where context is involved:
- Loading common resources
- Creating dynamic views
- Displaying Toast messages
- Launching Activities etc.
Different ways of getting context:
getContext()
getBaseContext()
getApplicationContext()
this
51
votes
An Android Context is an Interface (in the general sense, not in the Java sense; in Java, Context is actually an abstract class!) that allows access to application specific resources and class and information about application environment.
If your android app was a web app, your context would be something similar to ServletContext (I am not making an exact comparison here).
Your activities and services also extend Context, so they inherit all those methods to access the environment information in which the app is running.
38
votes
Contextrepresents a handle to get environment data .Contextclass itself is declared as abstract, whose implementation is provided by the android OS.Contextis like remote of a TV & channel's in the television are resources, services, etc.
What can you do with it ?
- Loading resource.
- Launching a new activity.
- Creating views.
- Obtaining system service.
Ways to get context :
getApplicationContext()getContext()getBaseContext()
22
votes
Just putting it out there for newbies;
So First understand Word Context :
In english-lib. it means:
"The circumstances that form the setting for an event, statement, or idea, and in terms of which it can be fully understood and assessed."
"The parts of something written or spoken that immediately precede and follow a word or passage and clarify its meaning."
Now take the same understanding to programming world:
context of current state of the application/object. It lets newly created objects understand what has been going on. Typically you call it to get information regarding another part of your program (activity, package/application)
You can get the context by invoking getApplicationContext(), getContext(), getBaseContext() or this (when in the activity class).
To Get Context Anywhere in application use following code:
Create new class AppContext inside your android application
public class AppContext extends Application {
private static Context context;
public void onCreate(){
super.onCreate();
AppContext.context = getApplicationContext();
}
public static Context getAppContext() {
return AppContext.context;
}
}
Now any time you want application context in non-activity class, call this method and you have application context.
Hope this help ;)
19
votes
19
votes
16
votes
The class android.content.Context provides the connection to the Android system and the resources of the project. It is the interface to global information about the application environment.
The Context also provides access to Android Services, e.g. the Location Service.
Activities and Services extend the Context class.
11
votes
Context is an interface to global information about an application environment. It's an abstract class whose implementation is provided by the Android system.
Context allows access to application-specific resources and classes, as well as calls for application-level operations such as launching activities, broadcasting and receiving intents, etc.
Here is Example
public class MyActivity extends Activity {
public void Testing() {
Context actContext = this; /*returns the Activity Context since Activity extends Context.*/
Context appContext = getApplicationContext(); /*returns the context of the single, global Application object of the current process. */
Button BtnShowAct1 = (Button) findViewById(R.id.btnGoToAct1);
Context BtnContext = BtnShowAct1.getContext(); /*returns the context of the View. */
For more details you can visit http://developer.android.com/reference/android/content/Context.html
10
votes
Context is Instances of the the class android.content.Context provide the connection to the Android system which executes the application. For example, you can check the size of the current device display via the Context.
It also gives access to the resources of the project. It is the interface to global information about the application environment.
The Context class also provides access to Android services, e.g., the alarm manager to trigger time based events.
Activities and services extend the Context class. Therefore they can be directly used to access the Context.
9
votes
Context is basically for resource access and getting the environment details of the application(for application context) or activity (for activity context) or any other...
In order to avoid memory leak you should use application context for every components that needs a context object.... for more click here
8
votes
Context is context of current state of the application/object.Its an entity that represents various environment data . Context helps the current activity to interact with out side android environment like local files, databases, class loaders associated to the environment, services including system-level services, and more.
A Context is a handle to the system . It provides services like resolving resources, obtaining access to databases and preferences, and so on. An android app has activities. It’s like a handle to the environment your application is currently running in. The activity object inherits the Context object.
Different invoking methods by which you can get context 1. getApplicationContext(), 2. getContext(), 3. getBaseContext() 4. or this (when in the activity class).
7
votes
Context means Android get to know in which activity I should go for or act in.
1 - Toast.makeText(context, "Enter All Details", Toast.LENGTH_SHORT).show();
it used in this.
Context context = ActivityName.this;
2 -startActivity(new Intent(context,LoginActivity.class));
in this context means from which activity you wanna go to other activity. context or ActivityName.this is faster then , getContext and getApplicatinContext.
6
votes
A Context is what most of us would call Application. It's made by the Android system and is able to do only what an application is able to.
In Tomcat, a Context is also what I would call an application.
There is one Context that holds many Activities, each Activity may have many Views.
Obviously, some will say that it doesn't fit because of this or that and they are probably right, but saying that a Context is your current application will help you to understand what you are putting in method parameters.
6
votes
Putting simple, Androids Context is a mess that you won't love until you stop worrying about.
Android Contexts are:
God-objects.
Thing that you want to pass around all your application when you are starting developing for Android, but will avoid doing it when you get a little bit closer to programming, testing and Android itself.
Unclear dependency.
Common source of memory leaks.
PITA for testing.
Actual context used by Android system to dispatch permissions, resources, preferences, services, broadcasts, styles, showing dialogs and inflating layout. And you need different
Contextinstances for some separate things (obviously, you can't show a dialog from an application or service context; layouts inflated from application and activity contexts may differ).
6
votes
Boss Assistant Analogy
Let's have a small analogy before diving deep in the technicality of Context
Every Boss has an assistant or someone( errand boy) who does less important and more time-consuming things for him. For example, if they need a file or coffee then an assistant will be on run. Boss will not know what is going on in the background but the file or the task will be delivered
So Here
Boss - Android Application
Assistant - Context
File or cup of coffee - Resource
What official Android Developer site says about Context
Context is your access point for application-related resources
Let's see some of such resources or tasks
Launching an activity.
Getting an absolute path to the application-specific cache directory on the filesystem.
Determining whether the given permission is allowed for a particular process and user ID running in the system.
Checking whether you have been granted a particular permission.
And so on.
So if an Android application wants to start an activity, it goes straight to Context (Access Point), and the Context class gives him back the resources(Intent in this case).
Like any other class Context class has fields and methods.
You can explore more about Context in official documentation, it covers pretty much everything, available methods, fields, and even how to use fields with methods.
5
votes
Instances of the the class android.content.Context provide the connection to the Android system which executes the application. For example, you can check the size of the current device display via the Context.
It also gives access to the resources of the project. It is the interface to global information about the application environment.
The Context class also provides access to Android services, e.g., the alarm manager to trigger time based events.
Activities and services extend the Context class. Therefore they can be directly used to access the Context.
5
votes
The Context is the android specific api to each app-s Sandbox that provides access app private data like to resources, database, private filedirectories, preferences, settings ...
Most of the privatedata are the same for all activities/services/broadcastlisteners of one application.
Since Application, Activity, Service implement the Context interface they can be used where an api call needs a Context parameter
4
votes
If you want to connect Context with other familiar classes in Android, keep in mind this structure:
Context < ContextWrapper < Application
Context < ContextWrapper < ContextThemeWrapper < Activity
Context < ContextWrapper < ContextThemeWrapper < Activity < ListActivity
Context < ContextWrapper < Service
Context < ContextWrapper < Service < IntentService
So, all of those classes are contexts in their own way. You can cast Service and ListActivity to Context if you wish. But if you look closely, some of the classes inherit theme as well. In activity or fragment, you would like theming to be applied to your views, but don't care about it Service class, for instance.
I explain the difference in contexts here.
4
votes
Context means component (or application) in various time-period. If I do eat so much food between 1 to 2 pm then my context of that time is used to access all methods (or resources) that I use during that time. Content is a component (application) for a particular time. The Context of components of the application keeps changing based on the underlying lifecycle of the components or application.
For instance, inside the onCreate() of an Activity,
getBaseContext() -- gives the context of the Activity that is set (created) by the constructor of activity.
getApplicationContext() -- gives the Context setup (created) during the creation of application.
Note: <application> holds all Android Components.
<application>
<activity> .. </activity>
<service> .. </service>
<receiver> .. </receiver>
<provider> .. </provider>
</application>
It means, when you call getApplicationContext() from inside whatever component, you are calling the common context of the whole application.
Context keeps being modified by the system based on the lifecycle of components.
1
votes
1
votes
The Context is an abstract class provided by Android, and as such, its job is to bridge your application code with the Android System. Through classes that inherit from Context (activities, services, and your application), your app gains the ability to access resources and functionalities reachable only by the Operating System.
When context descendant objects get instantiated by the Operating System (through an OS controlled instantiation mechanism, like "intents"), they become administered by the Operating System, and as such, they obtain lifecycle.
For anything else, passing a context as a parameter in method calls, allows this method to use the context as a channel of communication with the OS, in order to reach the OS and ask it to perform some action or return some resource.
Visualising the Context together with the Manifest
To visualize the Android Context and Manifest in action, an old calling centre switchboard is a great analogy.
The base is the Android System, where all the wires connecting all the application components of every running app, emerge.
Each "switchboard application" contains some plugholes, which represent the app's manifest component declarations. So through manifest declarations, the Android System learns about the existence of these plugholes so it can plug a new context wire by creating objects through intents.
Each wire represents an Android Context connected to some launchable component of the app, or to the app itself. You can use an existing wire since it is connected with the Android System, in order to request all kinds of things that need to go through the Operating System, to be accomplished.
You can assume that when an activity is destroyed, its wire gets unplugged. While when another activity (or another component) is constructed, a new wire emerges and connects to the correct manifest-declared plughole.
I have written an entire article that explains how the Context couples your app to the android system:
0
votes
0
votes
for more details about context, read this article. I will explain that briefly.
If you wanna know what is context you must know what it does...
for example getContext() is one of the methods that retrieve context. In getContext(), Context is tied to an Activity and its lifecycle. We can imagine Context as layer which stands behind Activity and it will live as long as Activity lives. The moment the Activity dies, Context will too. this method gives list of functionalities to activity, like:
Load Resource Values,
Layout Inflation,
Start an Activity,
Show a Dialog,
Start a Service,
Bind to a Service,
Send a Broadcast,
Register BroadcastReceiver.
now imagine that :
Context is a layer(interface) which stands behind its component (Activity, Application…) and component’s lifecycle, which provides access to various functionalities which are supported by application environment and Android framework.
