Android：覆盖onPause和onResume - 正确的方法

Question

When overriding the onPause() and the onResume() methods of the activity, where is the proper location to call the super.onPause() and super.onResume() ? At the beginning of the method or at the end?

Answer 1

From http://developer.android.com/guide/components/activities.html#ImplementingLifecycleCallbacks :

Your implementation of these lifecycle methods must always call the superclass implementation before doing any work, as shown in the examples above.

So, for lifecycle callbacks, like onPause() and onResume() , we should do super.onPause() or super.onResume() at the very beginning. For other methods, it all depends on the semantics of the super class.

Answer 2

Update: This is the accepted answer and it contains a nice amount of good information, including a useful diagram, pulled together into one place. However, it appears to be incorrect , at least according to the current Android documentation which, as the poster points out, is the ultimate source for information on the SDK. Possibly the documentation was clarified after this answer was posted. But, in any case, don't stop reading with this answer, check out espinchi's answer below . It has the documentation on its side.

---

Placement of the super methods depends only on your preference. It would only matter if those methods were taking parameters OR if you were doing some concurrent work. For example if you do this:

    @Override
    protected void onPause() {
        try {
            someOtherThread.join();
        } catch (InterruptedException e) {
            LOG.e(e);
        }
        super.onPause();
    }

it might block the thread and prevent super from being called.

I suggest that you should read all documentation available because they will help you much. For example this is what you can find in the onPause javadoc. I bolded out the important parts:

Called as part of the activity lifecycle when an activity is going into the background, but has not (yet) been killed. The counterpart to onResume().

When activity B is launched in front of activity A, this callback will be invoked on A. B will not be created until A's onPause() returns, so be sure to not do anything lengthy here.

This callback is mostly used for saving any persistent state the activity is editing, to present a "edit in place" model to the user and making sure nothing is lost if there are not enough resources to start the new activity without first killing this one. This is also a good place to do things like stop animations and other things that consume a noticeable amount of CPU in order to make the switch to the next activity as fast as possible, or to close resources that are exclusive access such as the camera.

In situations where the system needs more memory it may kill paused processes to reclaim resources. Because of this, you should be sure that all of your state is saved by the time you return from this function . In general onSaveInstanceState(Bundle) is used to save per-instance state in the activity and this method is used to store global persistent data (in content providers, files, etc.)

After receiving this call you will usually receive a following call to onStop() (after the next activity has been resumed and displayed), however in some cases there will be a direct call back to onResume() without going through the stopped state.

Derived classes must call through to the super class's implementation of this method. If they do not, an exception will be thrown.

I do recommend this flowchart for you it will help your development tremendously:

Answer 3

It probably doesn't matter, but to know for sure, you need to know what the super methods are doing, and usually that information is not available to you.

My style is to call eg super.onCreate(), super.onResume(), etc. before the body of my own method, and eg super.onPause() and super.onDestroy() after the body of my own method.

The theory behind this is that I like to let the super methods run first while building something up, just in case what I'm doing depends on what the superclass sets up first, and when tearing something down, I like to tear down my own stuff before the superclass tears down its stuff.

Answer 4

There's no right or wrong. That depends on what you do on your implementation of these methods. Sometimes you'll want the super to be before your code, and sometime after.

Answer 5

You can put it anywhere. First you have to understand the Activity life cycle. Check the following link Here

Download the demo and run it you will be clear

Answer 6

Delving into the android code, you can find that the framework sets a flag called mcalled when you call super.onPause(). This flag is later checked on resume by the framework.

if (!mCalled) {
            throw new SuperNotCalledException(
                "Activity " + mComponent.toShortString() +
                " did not call through to super.onResume()");
        }

All you need to do is make sure the call is made to super and you are good. No other precaution is necessary.