Scribd
Upload
45 views

Android Basic Understanding of Context

Context provides access to application resources and allows calls for activities and intents. It represents the environment an app is running in. There are several ways to access Context: 1) Get the context from an Activity using getContext() or getApplicationContext(). 2) Pass the context as an object to other classes through their constructors. 3) Define a new Application class that extends Context and provides a static method to access it from anywhere.

Uploaded by

nadji habibi
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
45 views

Android Basic Understanding of Context

Context provides access to application resources and allows calls for activities and intents. It represents the environment an app is running in. There are several ways to access Context: 1) Get the context from an Activity using getContext() or getApplicationContext(). 2) Pass the context as an object to other classes through their constructors. 3) Define a new Application class that extends Context and provides a static method to access it from anywhere.

Uploaded by

nadji habibi
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 3

Lets have an basic understanding of Context.

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.

A Context represents your environment. It represents the state surrounding where you are in
your system.

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.

So, how to access Context in your application ?

 getContext(): Returns the context within the currently active Activity. You can also use
this for inflating layouts and menus, register context menus, instantiating widgets, start
other activities, create new Intent within an Activity etc.

Example: View.getContext() returns the Context the view is currently running in. Usually the
currently active Activity.

View mView = this.getLayoutInflater().inflate(R.layout.myLayout,


myViewGroup);

Or,

Intent mIntent = new Intent(this, MyActivity.class);


this.startActivity(mIntent);

 getApplicationContext(): Returns the Context for the entire application, instead of the
current Activity i.e. if you need a Context tied to the lifecycle of the entire application,
not just the current Activity. This Context is widely used as it is safest to use as this
Context exists for the lifespan of the application.

Example: Bind an application-wide class.

Intent mIntent = new Intent(this, MyPersistent.class);


MyServiceConnection mServiceConnection = new MyServiceConnection();
if (mServiceConnection != null) {
getApplicationContext().bindService(mIntent, mServiceConnection,
Context.BIND_AUTO_CREATE);
}

 getBaseContext(): Returns a Context from another context within application that you
can access. This method has a limited usage.The method is relevant when you have a
ContextWrapper.
ContextWrapper is, "Proxying implementation of Context that simply delegates all of its calls to
another Context. Can be subclassed to modify behavior without changing the original Context."
(as per javadocs)..

Now, a question might arise ! How would one access the Context object inside of a class that
does not extend Activity ? So, it can be achieved by :

 Passing Context as an object to other class: For a class that does not have an access to
any of the Context mentioned above. Context can be passed to such class through its
constructor.

Example:

public class MyActivity extends Activity {


private Context context;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
context = getApplicationContext();
new Helper(context);
}
}

public class Helper {


Context mContext;
Helper(Context ctx){
this.mContext= ctx;
}
//Now you can use this mContext anywhere in your class.
}

And finally, to get Context anywhere in your application you can define a new class in your
application :

public class MyContext extends Application {


private static MyContext instance;

@Override
public void onCreate() {
instance = this;
super.onCreate();
}

public static Context getContext(){


return instance;
// or return instance.getApplicationContext();
}
}
In your manifest you need to add this class to the "Name" field in the "Application" tab, like this:

<application
android:name="com.example.app.MyContext "
android:icon="@mipmap/ic_launcher"
android:label="@string/app_name"
.......
<activity
......
</activity>

To get Context anywhere in your application, i.e. in any class of your project, you can call the
function of this class, like this:

MyContext.getContext();

This function will return a Context that you can use to carry out your tasks.

So, coming to your question. I guess the last two methods can solve your problem i.e passing the
Context object to the class and define a new class that extends Application.

You might also like