I find Context in Android, as one of the most difficult things to explain to anyone. When I started with Android development 2 years ago, I couldn?t wrap my head around the Context for a long period of time. I was so confused about it and yet I was using it on regular basis, simple because it is one of the fundamental things in Android. Still every time I needed to perform some operation that requires the Context, I felt anxious and I didn?t know how to ?get? the right one.
Motivated by my confusion in early stages of my career as Android developer, I decided to express my understanding of Context and hope it will help someone who has just entered the world of Android and has no idea what does Context represent. Of course this article is also for anyone who wants to try to understand Context better. Now let?s get started.
as Abstract as Context
In the official Android documentation here is how they defined Context.
Interface to global information about an application environment. This is 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.
At the beginning, this didn?t mean much to me. But as time passed, I started understanding its meaning.
Firstly, let?s look at 3 most used function for retrieving the Context:
- getContext() ? returns the Context which is linked to the Activity from which is called,
- getApplicationContext() ? returns the Context which is linked to Application which holds all activities running inside it,
- getBaseContext() ?is related to ContextWrapper, which is created around existing Context and let us change its behavior. With getBaseContext() we can fetch the existing Context inside ContextWrapper class.
To understand core of the Context, we will focus on first two methods mentioned above, because getBaseContext() is based on understanding regular Context and ContextWrapper.
getContext()
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.
Activity?s Context has its own functionalities, which we can use for all sort of things Android framework supports. Here is the list of functionalities Activity?s Context provides us:
Load Resource Values,Layout Inflation,Start an Activity,Show a Dialog,Start a Service,Bind to a Service,Send a Broadcast,Register BroadcastReceiver.
getApplicationContext()
In getApplicationContext(), our Context is tied to Application and its lifecycle. We can think of it as layer behind whole application. As long as user doesn?t kill the application, it?s alive.
You may wonder now, what is the difference between getContext() and getApplicationContext(). The difference is that Application?s Context is not UI related. It means that, we shouldn?t use it to Inflate a Layout, Start an Activity nor Show a Dialog. Regarding the rest of the functionalities from Activity?s Context, they are available from Application?s Context also. So the list of functionalities for Application?s Context looks like this:
Load Resource Values,Start a Service,Bind to a Service,Send a Broadcast,Register BroadcastReceiver.
Now that we checked the functionalities which different types of Context provide us, we can try to roughly describe its meaning. We can say the following
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.
The most used functionalities provided by Context are loading resources (such as strings, assets, themes?), starting Activities and Services and inflating layouts.
I hope by now you learnt something new and you understand Context a little bit better than you did before reading this article. Still, there is one more important thing which you need to consider when choosing the right Context.
One thing to pay attention when deciding which Context to choose
In this article, a lot of times was mentioned Context which is tied to component?s lifecycle. I would like to emphasize that this is important to consider because if you choose the wrong one, it can lead to memory leak, which can lead to breaking your app, which can lead to very very disappointing results.
The easiest way of showing you what do I mean by choosing the right Context, is by showing you an example.
Example
We have singleton (class which can have only 1 instance during the whole application lifecycle) ContextSingleton, which holds reference to a Context.
public class ContextSingleton { private static ContextSingleton instance; private Context mContext; public static ContextSingleton getInstance(Context context) { if (instance == null) { instance = new ContextSingleton(context); } return instance; } private ContextSingleton(Context context) { mContext = context; }}
As you can see, our singleton hold the Context reference, but the thing is that our mContext could be any type of context, it could be Application?s or Activity?s. (there are more types of Context but in this article I chose to write only about Application and Activity one)
Why should I care?
Well, imagine you pass the Activity?s Context here. Our singleton, will contain reference to the Activity whose Context was passed. Aside from that, we know that our singleton will outlive the Activity. That will lead to Activity which won?t be garbage collected when killed, because it is referenced by ContextSingleton. This principal is going to lead to memory leak.
To solve this issue, we need to realize that our singleton has lifecycle similar to application?s one. Than it is trivial to conclude that by passing the Application?s Context in singleton, we will overcome this type of problem. To solve it, we just need to hold the reference of getApplicationContext() called from any context.
public static ContextSingleton getInstance(Context context) { if (instance == null) { instance = new ContextSingleton(context.getApplicationContext()); } return instance;}
Conclusion
In this article I tried to express my way of understanding the Context in Android. We?ve also covered functionalities which provide Activity and Application Context, their difference and how you can decide which one you should use in different situations.
The goal of this article was to try to help new Android developers roughly understand what is Context in Android and why do we use it. There is still a lot more to learn regarding Context and its capabilities. For anyone who is trying to investigate more regarding Context, I can recommend this great article by Dave Smith.
I really hope that I brought you closer to understanding the Context in Android. If there were parts of article which you found hard to process, feel free to comment them. I?ll do my best to update the article depending on feedback.
Thank you for taking time to read my article.
Cheers!
Also I am always open for commenting on Android stuff, so if you feel like talking, contact me on twitter or linkedin.
