I’m new to android and I’m trying to understand the difference between
someClass.this and especially when to use the these methods in the following code lines:
When I launch a toast what is the difference between these and in which cases to I use them?
Toast.makeText(LoginActivity.this, "LogIn successful", Toast.LENGTH_SHORT).show(); Toast.makeText(getApplication(), "LogIn successful", Toast.LENGTH_SHORT).show(); Toast.makeText(getApplicationContext(), "LogIn successful", Toast.LENGTH_SHORT).show(); Toast.makeText(getBaseContext(), "LogIn successful", Toast.LENGTH_SHORT).show();
same with intents:
Intent intent = new Intent(getApplicationContext(), LoginActivity.class); Intent intent = new Intent(MenuPagina., LoginActivity.class); Intent intent = new Intent(getBaseContext(), LoginActivity.class); Intent intent = new Intent(getApplication(), LoginActivity.class);
Toast and Intent, both requires reference to context. And getApplication, getApplicationContext, LoginActivity.this and getBaseContext, they all offer reference to the context.
Now the thing confuses is the declaration of different contexts and their specific-usage. To make things simple, you should count two types of context available in the Android framework.
- Application Context
- Activity Context
Application context is attached to the application’s life-cycle and will always be same throughout the life of application. So if you are using Toast, you can use application context or even activity context (both) because a toast can be raised from anywhere with in your application and is not attached to a window.
Activity context is attached to the Activity’s life-cycle and can be destroyed if the activity’s
onDestroy() is raised. If you want to launch a new activity, you must need to use activity’s context in its Intent so that the new launching activity is connected to the current activity (in terms of activity stack). However, you may use application’s context too to launch a new activity but then you need to set flag
Intent.FLAG_ACTIVITY_NEW_TASK in intent to treat it as a new task.
Now referring to your cases:
LoginActivity.this though its referring to your own class which extends Activity class but the base class (Activity) also extends Context class, so it can be used to offer activity context.
getApplication() though its referring to Application object but the Application class extends Context class, so it can be used to offer application context.
getApplicationContext() offers application context.
getBaseContext() offers activity context.
Tips: Whenever you need to manipulate
Viewsthen go for
Activity-Context, else Application-Context would be enough.
The answer by Waqas is very clear and complete, however I’d like to further clarify the difference between using
Application extend not
Context itself, but
ContextWrapper, which is a
“Proxying implementation of
Contextthat simply delegates all of its calls to another
That “real” context is what you get by using
getBaseContext() both give the activity context, they
- (a) do not refer to the same object (
this != getBaseContext()) and
- (b) calling context through
thisis slightly less efficient, as the calls go through an extra level of indirection. I doubt it makes any practical difference, though.
The same logic applies to
the above line is an Activity which is obeveously a Context.. this is used when you create some AlertDialogs… At some places its compulsory that you use Activity Context…
Same here the make text method needs Context and Application itself implements
this is most preferred way since this
Context lives untill Application shuts down.
this Context is available to widgets and Views..
But All of them gives a Context object and nothing else..
Class.this used if your class extends Activity
getapplication() used refer application and application extends application context
getbasecontext()refer your activity context
context refer to your activity life cycle context
applicationcontext refer to your app life cycle