static variable null when returning to the app

In my app there's a static variable that's being set to null when I return to my app from the external browser. Seems like the app or some portion of it is killed if the external web page I'm launching is complex enough.

If the app were to be killed entirely and then relauched from the main activity that would be ok, but the relaunch is from the activity that started the browser - and it's not meant to set the app state so it's crashing when accessing the null static variable. This is a one-out-of-six device problem for me so I need some advice.

Is there a flag to set to prevent this behavior?

This is standard behavior in most mobile operating systems, definitely including Android. Your app is in fact very often killed if some other application with higher priority (generally, if it's in the foreground it's higher priority) needs the resources. This is due to the nature of mobile devices having relatively limited resources.

You should save your data somewhere more durable. You might find this article on general Data Storage to be useful. This question should be relevant too: https://stackoverflow.com/questions/151777/how-do-i-save-an-android-applications-state

Note that this is in fact not a one-out-of-six device problem. This is a "problem" on all devices, it's just more apparent on one of your devices probably because it has less memory. If you run a very memory-intensive app on any of your other devices you should see the same behavior. Also there is no flag to prevent this. This is standard and expected.

Usually this happens when the device goes to sleep mode.

This behavior of the device can be emulated by the following steps:

1. Run the app and press the Home button
2. In Android Studio in the lower left corner, select debugged the application and press the X button (terminate application) to the left of the application name. (Don't know how to Eclipse, but I think similarly)
3. Click on the application icon on the device.

If the Task were activity, the app will open on the last activity and (most likely) will generate an error, because all static variables have been leaved.

No... you should not store data in static variables on android. If you insist on doing it you will need to be able to recover from it when it is null.. you should save your state with bundles or other means.

The solution to using static's (singleton's) in Android is very easy:

Implement a class that extends android.app.Application and do all your singleton initialization within onCreate()

Reasoning:

• the class that extends Application is executed first, even when your app's process is killed due to a low Memory condition
• your app has context as soon as Application.onCreate() is called

Use application class for such things. It's always instantiated before any component (activities, services, receivers) of your app are going to start. So you are sure all of static variables are there and initialized.

You have to save your values in onSaveInstanceState and get it back in onRestoreInstanceState because when an activity go to stopped state lifecycle all static values will be null.

eg:

        /* save my satatic hashmap in case of activity stopped to retrieve it again in  onRestoreInstanceState method*/
    	@Override
    	protected void onSaveInstanceState(Bundle outState) {
    		super.onSaveInstanceState(outState);
    
    //Common.PERMISION_MAP static hashmap 
    		if (Common.PERMISION_MAP != null) {
    			Iterator<Permission> iterator = Common.PERMISION_MAP.values()
    					.iterator();
    			ArrayList<Permission> permissionList = new ArrayList<Permission>();
    			while (iterator.hasNext()) {
    				Permission permission = (Permission) iterator.next();
    				permissionList.add(permission);
    
    			}
    			outState.putParcelableArrayList("PERMISSION_LIST", permissionList);
    		}
    
    
    	}
    
        /* restore my satatic hashmap when activity stopped */
    	@Override
    	protected void onRestoreInstanceState(Bundle savedInstanceState) {
    		super.onRestoreInstanceState(savedInstanceState);
    
    		try {
    			ArrayList<Permission> permissionList = savedInstanceState
    					.getParcelableArrayList("PERMISSION_LIST");
    
    			if (Common.PERMISION_MAP == null)
    				Common.PERMISION_MAP = new HashMap<Permission, Permission>();
for (Permission permission : permissionList) {
				Common.PERMISION_MAP.put(permission, permission);

			}	
                } catch (Exception ex) {
    			String string = ex != null ? ex.getMessage() : "";
    			Log.e(TAG, (string != null ? string : ""));
    			ex.printStackTrace();
    
    		}
    	}

You probably just want to follow the second link by kabuko. But if you want to keep your static variable (perhaps you have some great reason for this), you could do this:

private static MyObjType getVariable()
{
   if (myVar == null)
     myVar = new MyObjType();  // do whatever else you need to here

   return myVar;
}

That way you can replace your calls to myVar.test() with getVariable().test() and you know it will never cause a null pointer exception.

Whenever you left your app & switching browser your app got in background. So you need to follow these steps

1. First initialize your static variable in Sharedpreferece or in savedInstanceState as follow

    sharedpreference.purString("your_static_variable_name","your_static_variable_value").
   

or

    savedInstanceState.putString("your_static_variable_name","your_static_variable_value").

in the first execution of oncreate() method of activity or elsewhere

2. Second, reinitialize your static variables in onResume() methods via sharedpreference or savedInstance whichever is used earlier.