Fragment loses Activity while networking (android)

Question

I initiate most of my networking calls from Fragments and then use callbacks to tell the Fragment whether or not the networking task succeeded or failed and to update ui accordingly.

On rare occassions (.25% of sessions) my program is crashing with a null-pointer exception due to getActivity() returning null when the code in my callback runs. I know that I can use a null check on getActivity() to prevent this from happening, however what's the best practice for handling this issue?

The null check seems to be little more than a crash prevention tool as the program still needs the data from the networking task.

The code looks something like the following:

private void queryServer() {
    // networking task should query server for user id, if successful store it 
    // in user preferences to be accessed by fragment in callback
    new networkingTask(new VolleyCallback() {
        @Override
        public void onSuccess() {
            // code below needs null check on getActivity - but what else?
            mUserId = new UserPreferences(getActivity()).getUserId();
        }

        @Override
        public void onFail() {
            // booooo
        }
    });
}

Answer 1

As I stated in my comment above, what is likely happening is the Activity/Fragment pair are being stopped or destroyed by the system. This will happen for a variety of reasons, such as a screen orientation change. Because your handler is a method on the fragment object, you are working with a "dead" fragment by the time the call returns. There are several patterns for dealing with this. In short you need to make your handler aware of the current fragment, and you can accomplish this by using lifecycle methods.

Below is an example of a pattern you could use. I tried to make the example as minimal as possible.

import android.app.Activity;
import android.app.Fragment;

public class MyFragment extends Fragment {

    // This is static so that it will not go out of scope when the original
    // fragment is destroy.  This allows it to be access from all MyFragment
    // instances.
    static MyResponseProcessor processor = new MyResponseProcessor();

    // This will be the class that handles your network call.  
    public static class MyResponseProcessor {

        // This instance variable is alway a reference to the currently displayed fragment.
        private Fragment activeFragement;

        public void setActiveFragement(Fragment activeFragement) {
            this.activeFragement = activeFragement;
        }

        // This method, which is for demonstration purposes, shows how you would handle a network response.
        public void handleResponse(SomeResponseObject) {
            if (activeFragement != null) {
                // Now you can get the activity
                Activity activity = activeFragement.getActivity();
            } else {
                // Yes it is possible that there is no active fragment.  
                // If the user has stayed on the same screen, then the
                // fragment of interest will likely be re-created, and 
                // this window of time with no fragment will be brief.
                //
                // Note that this null-check is very different than the 
                // null-check you describe.  In your case the reference is
                // guaranteed to be null forever.  In this case, the reference
                // will eventually become non-null.
            }
        }
    }

    @Override
    public void onStart() {
        super.onStart();
        // At this point in the fragment lifecycle, the fragment is both running and is attached to an Activity.
        // Thus "getActivity" calls are safe from this point onward.
        processor.setActiveFragement(this);
    }

    @Override
    public void onStop() {
        super.onStop();
        // At this point in the fragment lifecycle, the fragment has been stopped and is about to lose its connection to the activity.
        // So after this point, calls to "getActivity" are probably not safe.
        // DISCLAIMER - I have not tested this.  You might want to do this in a
        // different method such as "onDestroyView()"
        processor.setActiveFragement(null);
    }
}