Application 클래스를 확장해야하는 이유

Application 클래스를 확장해야하는 이유

---

Application수업 을 연장해야하는 이유 ?

그게 뭐에요?

왜 그렇게 하시겠습니까?

전역 변수를 선언하는 데 사용할 수 있다는 것을 읽었습니다. 모두 또는 다른 응용 프로그램이 있습니까?

---

나는 응용 프로그램 확장이 다른 접근 방식보다 선호되거나 무언가를 달성하는 데 필요한 실제 시나리오를 생각할 수 없습니다. 값 비싸고 자주 사용되는 객체가있는 경우 객체가 현재 존재하지 않음을 감지하면 IntentService에서 객체를 초기화 할 수 있습니다. 응용 프로그램 자체는 UI 스레드에서 실행되는 반면 IntentService는 자체 스레드에서 실행됩니다.

명시 적 인 텐트를 사용하여 활동에서 활동으로 데이터를 전달하거나 SharedPreferences를 사용하는 것을 선호합니다. 인터페이스를 사용하여 Fragment에서 상위 활동으로 데이터를 전달하는 방법도 있습니다.

---

소개:

1. apk모바일에서 파일을 고려하면 파일은 Activitys, Services 및 기타와 같은 여러 유용한 블록으로 구성 됩니다.
2. 이러한 구성 요소는 서로 정기적으로 통신하지 않으며 자체 수명주기가 있다는 것을 잊지 않습니다. 한 번에 활성화되고 다른 순간에는 비활성화 될 수 있음을 나타냅니다.

---

요구 사항 :

1. 때로는 사용자가 사용 Application하는 Activity것과 상관없이 변수와 그 상태에 액세스해야하는 시나리오가 필요할 수 있습니다.
2. 예를 들어, 사용자는을 통해 액세스해야하는 직원 정보 (예 : 이름)를 보유한 변수에 액세스해야 할 수 있습니다 Application.
3. 우리는 SQLite를 사용할 수 있지만 a를 만들고 Cursor다시 닫는 것은 성능에 좋지 않습니다.
4. Intents를 사용 하여 데이터를 전달할 수는 있지만 메모리 가용성에 따라 특정 시나리오에서 서투른 활동 자체가 존재하지 않을 수 있습니다.

---

응용 프로그램 클래스 사용 :

1. 전역 변수에 접근 Application,
2. 당신이 사용할 수있는 Application응용 프로그램 클래스가 먼저 시작되기 때문에 등을 분석 같은 특정 일을 시작하는 Activitys 또는 ServicesS가 실행되고있다,
3. 애플리케이션 구성이 변경 될 때 (수평에서 수직으로 또는 그 반대로) 트리거되는 onConfigurationChanged ()라는 재정의 된 메소드가 있습니다.
4. Android 기기의 메모리가 부족할 때 트리거되는 onLowMemory () 이벤트도 있습니다.

---

응용 프로그램 클래스는 응용 프로그램의 전체 수명주기가있는 개체입니다. 응용 프로그램으로 가장 높은 계층입니다. 가능한 사용법 예 :

• Application 클래스에서 onCreate를 재정 의하여 응용 프로그램을 시작할 때 필요한 것을 추가 할 수 있습니다.

• 활동에서 활동으로 이동하는 전역 변수를 저장하십시오. 비동기 작업처럼.

  기타

---

때로는 여러 활동에서 액세스 해야하는 전역 변수와 같이 데이터를 저장하려고 할 때가 있습니다. 이 경우 Application 개체가 도움이됩니다.

예를 들어, 각 http 요청에 대한 기본 인증 데이터를 얻으려면 응용 프로그램 객체에서 인증 데이터에 대한 메소드를 구현할 수 있습니다.

그 후에는 다음과 같은 활동에서 사용자 이름과 비밀번호를 얻을 수 있습니다.

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

마지막으로 Application 객체를 싱글 톤 객체로 사용해야합니다.

 public class MyApplication extends Application {
    private static MyApplication singleton;

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

더 자세한 정보. 이 링크를 클릭하십시오

---

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.

---

Best use of application class. Example: Suppose you need to restart your alarm manager on boot completed.

public class BaseJuiceApplication extends Application implements BootListener {

    public static BaseJuiceApplication instance = null;

    public static Context getInstance() {
        if (null == instance) {
            instance = new BaseJuiceApplication();
        }
        return instance;
    }

    @Override
    public void onCreate() {
        super.onCreate();


    }

    @Override
    public void onBootCompleted(Context context, Intent intent) {
        new PushService().scheduleService(getInstance());
        //startToNotify(context);
    }

---

Not an answer but an observation: keep in mind that the data in the extended application object should not be tied to an instance of an activity, as it is possible that you have two instances of the same activity running at the same time (one in the foreground and one not being visible).

For example, you start your activity normally through the launcher, then "minimize" it. You then start another app (ie Tasker) which starts another instance of your activitiy, for example in order to create a shortcut, because your app supports android.intent.action.CREATE_SHORTCUT. If the shortcut is then created and this shortcut-creating invocation of the activity modified the data the application object, then the activity running in the background will start to use this modified application object once it is brought back to the foreground.

---

I see that this question is missing an answer. I extend Application because I use Bill Pugh Singleton implementation (see reference) and some of my singletons need context. The Application class looks like this:

public class MyApplication extends Application {

    private static final String TAG = MyApplication.class.getSimpleName();

    private static MyApplication sInstance;

    @Contract(pure = true)
    @Nullable
    public static Context getAppContext() {
        return sInstance;
    }

    @Override
    public void onCreate() {
        super.onCreate();
        Log.d(TAG, "onCreate() called");
        sInstance = this;
    }
}

And the singletons look like this:

public class DataManager {

    private static final String TAG = DataManager.class.getSimpleName();

    @Contract(pure = true)
    public static DataManager getInstance() {
        return InstanceHolder.INSTANCE;
    }

    private DataManager() {
        doStuffRequiringContext(MyApplication.getAppContext());
    }

    private static final class InstanceHolder {
        @SuppressLint("StaticFieldLeak")
        private static final DataManager INSTANCE = new DataManager();
    }
}

This way I don't need to have a context every time I'm using a singleton and get lazy synchronized initialization with minimal amount of code.

Tip: updating Android Studio singleton template saves a lot of time.

---

Source: https://github.com/codepath/android_guides/wiki/Understanding-the-Android-Application-Class

In many apps, there's no need to work with an application class directly. However, there are a few acceptable uses of a custom application class:

• Specialized tasks that need to run before the creation of your first activity
• Global initialization that needs to be shared across all components (crash reporting, persistence)
• Static methods for easy access to static immutable data such as a shared network client object

You should never store mutable instance data inside the Application object because if you assume that your data will stay there, your application will inevitably crash at some point with a NullPointerException. The application object is not guaranteed to stay in memory forever, it will get killed. Contrary to popular belief, the app won’t be restarted from scratch. Android will create a new Application object and start the activity where the user was before to give the illusion that the application was never killed in the first place.

---

You can access variables to any class without creating objects, if its extended by Application. They can be called globally and their state is maintained till application is not killed.

---

The use of extending application just make your application sure for any kind of operation that you want throughout your application running period. Now it may be any kind of variables and suppose if you want to fetch some data from server then you can put your asynctask in application so it will fetch each time and continuously, so that you will get a updated data automatically.. Use this link for more knowledge....

http://www.intridea.com/blog/2011/5/24/how-to-use-application-object-of-android

---

I think you can use the Application class for many things, but they are all tied to your need to do some stuff BEFORE any of your Activities or Services are started. For instance, in my application I use custom fonts. Instead of calling

Typeface.createFromAsset()

from every Activity to get references for my fonts from the Assets folder (this is bad because it will result in memory leak as you are keeping a reference to assets every time you call that method), I do this from the onCreate() method in my Application class:

private App appInstance;
Typeface quickSandRegular;
...
public void onCreate() {
    super.onCreate();

    appInstance = this;
    quicksandRegular = Typeface.createFromAsset(getApplicationContext().getAssets(),
                       "fonts/Quicksand-Regular.otf");
   ...
   }

Now, I also have a method defined like this:

public static App getAppInstance() {
    return appInstance;
}

and this:

public Typeface getQuickSandRegular() {
    return quicksandRegular;
}

So, from anywhere in my application, all I have to do is:

App.getAppInstance().getQuickSandRegular()

Another use for the Application class for me is to check if the device is connected to the Internet BEFORE activities and services that require a connection actually start and take necessary action.

---

To add onto the other answers that state that you might wish store variables in the application scope, for any long-running threads or other objects that need binding to your application where you are NOT using an activity (application is not an activity).. such as not being able to request a binded service.. then binding to the application instance is preferred. The only obvious warning with this approach is that the objects live for as long as the application is alive, so more implicit control over memory is required else you'll encounter memory-related problems like leaks.

Something else you may find useful is that in the order of operations, the application starts first before any activities. In this timeframe, you can prepare any necessary housekeeping that would occur before your first activity if you so desired.

2018-10-19 11:31:55.246 8643-8643/: application created
2018-10-19 11:31:55.630 8643-8643/: activity created

참고 URL : https://stackoverflow.com/questions/18002227/why-to-extend-an-application-class