CODEWITHSUNDEEP
androidandroid-lifecycle
Aritra Roy
Aritra Roy

Reputation: 15615

Application onCreate() NOT getting called every time

I have a very important initialization to do when the app starts. I found the best way to do is to put that code inside onCreate() of the class which extends Application class.

class ApplicationDemo extends Application{

@Override
public void onCreate(){
 super.onCreate();
 Log.d("LOG", "Inside onCreate()");
}

}

The Problem

I do not find the log statement to be executed every time the app is run. Like I start the app for the first time, get the log statement, then close the app and start again from the launcher. No, the log statement doesn't come.

What is the problem? How can I ensure a particular code is run every time my app is run and before anything else is performed?

Upvotes: 4

Views: 7093

Answers (7)

jo jo
jo jo

Reputation: 1838

You can use from bellow code for Kotlin:

override fun onTrimMemory(level: Int) {
    super.onTrimMemory(level)
    when (level) {
        ComponentCallbacks2.TRIM_MEMORY_UI_HIDDEN -> {
            /*
               Release any UI objects that currently hold memory.

               "release your UI resources" is actually about things like caches.
               You usually don't have to worry about managing views or UI components because the OS
               already does that, and that's why there are all those callbacks for creating, starting,
               pausing, stopping and destroying an activity.
               The user interface has moved to the background.
            */
            System.exit(0);
        }
        ComponentCallbacks2.TRIM_MEMORY_RUNNING_MODERATE,
        ComponentCallbacks2.TRIM_MEMORY_RUNNING_LOW,
        ComponentCallbacks2.TRIM_MEMORY_RUNNING_CRITICAL -> {
            /*
               Release any memory that your app doesn't need to run.

               The device is running low on memory while the app is running.
               The event raised indicates the severity of the memory-related event.
               If the event is TRIM_MEMORY_RUNNING_CRITICAL, then the system will
               begin killing background processes.
            */
        }
        ComponentCallbacks2.TRIM_MEMORY_BACKGROUND,
        ComponentCallbacks2.TRIM_MEMORY_MODERATE,
        ComponentCallbacks2.TRIM_MEMORY_COMPLETE -> {
            /*
               Release as much memory as the process can.
               The app is on the LRU list and the system is running low on memory.
               The event raised indicates where the app sits within the LRU list.
               If the event is TRIM_MEMORY_COMPLETE, the process will be one of
               the first to be terminated.
            */
        }

    }
}

And bellow code for Java:

public void onTrimMemory(int level) {

        // Determine which lifecycle or system event was raised.
        switch (level) {

            case ComponentCallbacks2.TRIM_MEMORY_UI_HIDDEN:

                /*
                   Release any UI objects that currently hold memory.

                   "release your UI resources" is actually about things like caches. 
                   You usually don't have to worry about managing views or UI components because the OS 
                   already does that, and that's why there are all those callbacks for creating, starting, 
                   pausing, stopping and destroying an activity.
                   The user interface has moved to the background.
                */
                System.exit(0);
                break;

            case ComponentCallbacks2.TRIM_MEMORY_RUNNING_MODERATE:
            case ComponentCallbacks2.TRIM_MEMORY_RUNNING_LOW:
            case ComponentCallbacks2.TRIM_MEMORY_RUNNING_CRITICAL:

                /*
                   Release any memory that your app doesn't need to run.

                   The device is running low on memory while the app is running.
                   The event raised indicates the severity of the memory-related event.
                   If the event is TRIM_MEMORY_RUNNING_CRITICAL, then the system will
                   begin killing background processes.
                */

                break;

            case ComponentCallbacks2.TRIM_MEMORY_BACKGROUND:
            case ComponentCallbacks2.TRIM_MEMORY_MODERATE:
            case ComponentCallbacks2.TRIM_MEMORY_COMPLETE:

                /*
                   Release as much memory as the process can.
                   The app is on the LRU list and the system is running low on memory.
                   The event raised indicates where the app sits within the LRU list.
                   If the event is TRIM_MEMORY_COMPLETE, the process will be one of
                   the first to be terminated.
                */

                break;

            default:
                /*
                  Release any non-critical data structures.
                  The app received an unrecognized memory level value
                  from the system. Treat this as a generic low-memory message.
                */
                break;
        }
    }

Upvotes: 0

curioushikhov
curioushikhov

Reputation: 2820

You should in AndroidManifest.xml in tag "application" set field android:name=".ApplicationDemo"

UPD author edited question with my assertions.

Upvotes: -1

breakline
breakline

Reputation: 6073

On my phone even if I close an app it'll keep running in the background until you close from there manually.

You can use 

onResume() {}

To run something every time the Activity gets called again.

Upvotes: -1

Mekap
Mekap

Reputation: 2085

My guess is that you truly have open your application just once.

I'm pretty sure that, after you closed your application, it truly just goes into the background, waiting to be put in the foreground again. (It does not get created again, you only reuse something you already have created.)

Try making sure you actually killed the process of your application before re-opening it; to make sure you actually closed & reopen it, and not just do a simple background-foreground thingy.

Upvotes: 4

laalto
laalto

Reputation: 152817

An application or an activity can exist even if it's UI is not displaying. The onCreate() callback is only called when the object is created anew.

This simply means that "every time an user opens the app from the launcher icon".

Then you should be putting the code in the onResume() callback of your launcher activity declared in the manifest. You can make the launcher activity a thin activity that only does this once-per-activation init and then launches the actual main activity.

Sure, there can be prior code run, such as onCreate() of the Application and onCreate() of the Activity so it won't always be the first thing to run, but it will be guaranteed to run every time you launch from the menu.

Upvotes: 0

wolfaviators
wolfaviators

Reputation: 503

This sounds like an Android activity lifecycle problem. I've included a link about pausing and resuming an activity

http://developer.android.com/training/basics/activity-lifecycle/pausing.html

It looks like when you are exiting the app, your activity is being paused. Likewise when you re enter the app, if the process is still running, the activity is getting resumed rather than recreated.

From here, you can either move the code to the onResume() or you can leave it in onCreate() but make sure that exiting the app kills the process. that could be done by putting

getActivity().finish();
System.exit(0);

in any path that directs the user to the home screen (onBackPressed(), exit buttons, etc.)

for starting, try putting a Log statement in onResume and watch where the two get called.

I hope this helps.

Upvotes: 1

Olexandr Chervinsky
Olexandr Chervinsky

Reputation: 51

In Android you usually do not 'close' an application, but rather suspend it. So, when you run it again, it just pops back. To ensure your app is closed, open the list of running application, find your one and force stop it.

Upvotes: 0

Related Questions