Why extend the Android Application class?

Question

Introduction:

1. If we consider an apk file in our mobile, it is comprised of multiple useful blocks such as, Activitys, Services and others.
2. These components do not communicate with each other regularly and not forget they have their own life cycle. which indicate that they may be active at one time and inactive the other moment.

---

Requirements:

1. Sometimes we may require a scenario where we need to access a variable and its states across the entire Application regardless of the Activity the user is using,
2. An example is that a user might need to access a variable that holds his personnel information (e.g. name) that has to be accessed across the Application,
3. We can use SQLite but creating a Cursor and closing it again and again is not good on performance,
4. We could use Intents to pass the data but it's clumsy and activity itself may not exist at a certain scenario depending on the memory-availability.

---

Uses of Application Class:

1. Access to variables across the Application,
2. You can use the Application to start certain things like analytics etc. since the application class is started before Activitys or Servicess are being run,
3. There is an overridden method called onConfigurationChanged() that is triggered when the application configuration is changed (horizontal to vertical & vice-versa),
4. There is also an event called onLowMemory() that is triggered when the Android device is low on memory.

Application class is the object that has the full lifecycle of your application. It is your highest layer as an application. example possible usages:

• You can add what you need when the application is started by overriding onCreate in the Application class.

• store global variables that jump from Activity to Activity. Like Asynctask.

  etc

Sometimes you want to store data, like global variables which need to be accessed from multiple Activities - sometimes everywhere within the application. In this case, the Application object will help you.

For example, if you want to get the basic authentication data for each http request, you can implement the methods for authentication data in the application object.

After this,you can get the username and password in any of the activities like this:

MyApplication mApplication = (MyApplication)getApplicationContext();
String username = mApplication.getUsername();
String password = mApplication.getPassword();

And finally, do remember to use the Application object as a singleton object:

public class MyApplication extends Application {
    private static MyApplication singleton;

    public MyApplication getInstance(){
        return singleton;
    }

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

For more information, please Click Application Class

Offhand, I can't think of a real scenario in which extending Application is either preferable to another approach or necessary to accomplish something. If you have an expensive, frequently used object you can initialize it in an IntentService when you detect that the object isn't currently present. Application itself runs on the UI thread, while IntentService runs on its own thread.

I prefer to pass data from Activity to Activity with explicit Intents, or use SharedPreferences. There are also ways to pass data from a Fragment to its parent Activity using interfaces.

The Application class is a singleton that you can access from any activity or anywhere else you have a Context object.

You also get a little bit of lifecycle.

You could use the Application's onCreate method to instantiate expensive, but frequently used objects like an analytics helper. Then you can access and use those objects everywhere.