当活动/片段暂停时如何处理 Handler 消息

Although the Android operating system does not appear to have a mechanism that sufficiently addresses your problem I believe this pattern does provide a relatively simple to implement workaround.

The following class is a wrapper around android.os.Handler that buffers up messages when an activity is paused and plays them back on resume.

Ensure any code that you have which asynchronously changes a fragment state (e.g. commit, dismiss) is only called from a message in the handler.

Derive your handler from the PauseHandler class.

Whenever your activity receives an onPause() call PauseHandler.pause() and for onResume() call PauseHandler.resume().

Replace your implementation of the Handler handleMessage() with processMessage().

Provide a simple implementation of storeMessage() which always returns true.

/**
* Message Handler class that supports buffering up of messages when the
* activity is paused i.e. in the background.
*/
public abstract class PauseHandler extends Handler {


/**
* Message Queue Buffer
*/
final Vector<Message> messageQueueBuffer = new Vector<Message>();


/**
* Flag indicating the pause state
*/
private boolean paused;


/**
* Resume the handler
*/
final public void resume() {
paused = false;


while (messageQueueBuffer.size() > 0) {
final Message msg = messageQueueBuffer.elementAt(0);
messageQueueBuffer.removeElementAt(0);
sendMessage(msg);
}
}


/**
* Pause the handler
*/
final public void pause() {
paused = true;
}


/**
* Notification that the message is about to be stored as the activity is
* paused. If not handled the message will be saved and replayed when the
* activity resumes.
*
* @param message
*            the message which optional can be handled
* @return true if the message is to be stored
*/
protected abstract boolean storeMessage(Message message);


/**
* Notification message to be processed. This will either be directly from
* handleMessage or played back from a saved message when the activity was
* paused.
*
* @param message
*            the message to be handled
*/
protected abstract void processMessage(Message message);


/** {@inheritDoc} */
@Override
final public void handleMessage(Message msg) {
if (paused) {
if (storeMessage(msg)) {
Message msgCopy = new Message();
msgCopy.copyFrom(msg);
messageQueueBuffer.add(msgCopy);
}
} else {
processMessage(msg);
}
}
}

Below is a simple example of how the PausedHandler class can be used.

On the click of a button a delayed message is sent to the handler.

When the handler receives the message (on the UI thread) it displays a DialogFragment.

If the PausedHandler class was not being used an IllegalStateException would be shown if the home button was pressed after pressing the test button to launch the dialog.

public class FragmentTestActivity extends Activity {


/**
* Used for "what" parameter to handler messages
*/
final static int MSG_WHAT = ('F' << 16) + ('T' << 8) + 'A';
final static int MSG_SHOW_DIALOG = 1;


int value = 1;


final static class State extends Fragment {


static final String TAG = "State";
/**
* Handler for this activity
*/
public ConcreteTestHandler handler = new ConcreteTestHandler();


@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setRetainInstance(true);
}


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


handler.setActivity(getActivity());
handler.resume();
}


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


handler.pause();
}


public void onDestroy() {
super.onDestroy();
handler.setActivity(null);
}
}


/**
* 2 second delay
*/
final static int DELAY = 2000;


/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);


if (savedInstanceState == null) {
final Fragment state = new State();
final FragmentManager fm = getFragmentManager();
final FragmentTransaction ft = fm.beginTransaction();
ft.add(state, State.TAG);
ft.commit();
}


final Button button = (Button) findViewById(R.id.popup);


button.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {


final FragmentManager fm = getFragmentManager();
State fragment = (State) fm.findFragmentByTag(State.TAG);
if (fragment != null) {
// Send a message with a delay onto the message looper
fragment.handler.sendMessageDelayed(
fragment.handler.obtainMessage(MSG_WHAT, MSG_SHOW_DIALOG, value++),
DELAY);
}
}
});
}


public void onSaveInstanceState(Bundle bundle) {
super.onSaveInstanceState(bundle);
}


/**
* Simple test dialog fragment
*/
public static class TestDialog extends DialogFragment {


int value;


/**
* Fragment Tag
*/
final static String TAG = "TestDialog";


public TestDialog() {
}


public TestDialog(int value) {
this.value = value;
}


@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
}


@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
final View inflatedView = inflater.inflate(R.layout.dialog, container, false);
TextView text = (TextView) inflatedView.findViewById(R.id.count);
text.setText(getString(R.string.count, value));
return inflatedView;
}
}


/**
* Message Handler class that supports buffering up of messages when the
* activity is paused i.e. in the background.
*/
static class ConcreteTestHandler extends PauseHandler {


/**
* Activity instance
*/
protected Activity activity;


/**
* Set the activity associated with the handler
*
* @param activity
*            the activity to set
*/
final void setActivity(Activity activity) {
this.activity = activity;
}


@Override
final protected boolean storeMessage(Message message) {
// All messages are stored by default
return true;
};


@Override
final protected void processMessage(Message msg) {


final Activity activity = this.activity;
if (activity != null) {
switch (msg.what) {


case MSG_WHAT:
switch (msg.arg1) {
case MSG_SHOW_DIALOG:
final FragmentManager fm = activity.getFragmentManager();
final TestDialog dialog = new TestDialog(msg.arg2);


// We are on the UI thread so display the dialog
// fragment
dialog.show(fm, TestDialog.TAG);
break;
}
break;
}
}
}
}
}

I've added a storeMessage() method to the PausedHandler class in case any messages should be processed immediately even when the activity is paused. If a message is handled then false should be returned and the message will be discarded.

A slightly simpler version of quickdraw's excellent PauseHandler is

/**
* Message Handler class that supports buffering up of messages when the activity is paused i.e. in the background.
*/
public abstract class PauseHandler extends Handler {


/**
* Message Queue Buffer
*/
private final List<Message> messageQueueBuffer = Collections.synchronizedList(new ArrayList<Message>());


/**
* Flag indicating the pause state
*/
private Activity activity;


/**
* Resume the handler.
*/
public final synchronized void resume(Activity activity) {
this.activity = activity;


while (messageQueueBuffer.size() > 0) {
final Message msg = messageQueueBuffer.get(0);
messageQueueBuffer.remove(0);
sendMessage(msg);
}
}


/**
* Pause the handler.
*/
public final synchronized void pause() {
activity = null;
}


/**
* Store the message if we have been paused, otherwise handle it now.
*
* @param msg   Message to handle.
*/
@Override
public final synchronized void handleMessage(Message msg) {
if (activity == null) {
final Message msgCopy = new Message();
msgCopy.copyFrom(msg);
messageQueueBuffer.add(msgCopy);
} else {
processMessage(activity, msg);
}
}


/**
* Notification message to be processed. This will either be directly from
* handleMessage or played back from a saved message when the activity was
* paused.
*
* @param activity  Activity owning this Handler that isn't currently paused.
* @param message   Message to be handled
*/
protected abstract void processMessage(Activity activity, Message message);


}

It does assume that you always want to store offline messages for replay. And provides the Activity as input to #processMessages so you don't need to manage it in the sub class.

In my projects I use the observer design pattern to solve this. In Android, broadcast receivers and intents are an implemenation of this pattern.

What I do is create a BroadcastReceiver which I register in fragment's/activity's onResume and unregister in fragment's/activity's onPause. In BroadcastReceiver's method onReceive I put all code that needs to run as result of - the BroadcastReceiver - receiving an Intent(message) that was sent to your app in general. To increase selectivity on what type of intents your fragment can receive you can use an intent filter as in the example below.

An advantage of this approach is that the Intent(message) can be sent from everywhere whithin your app(a dialog that opened on top of your fragment, an async task, another fragment etc.). Parameters can even passed as intent extras.

Another advantage is that this approach is compatible with any Android API version, since BroadcastReceivers and Intents have been introduced on API level 1.

Your are not required to setup any special permissions on your app's manifest file except if you plan to use sendStickyBroadcast(where you need to add BROADCAST_STICKY).

public class MyFragment extends Fragment {


public static final String INTENT_FILTER = "gr.tasos.myfragment.refresh";


private BroadcastReceiver mReceiver = new BroadcastReceiver() {


// this always runs in UI Thread
@Override
public void onReceive(Context context, Intent intent) {
// your UI related code here


// you can receiver data login with the intent as below
boolean parameter = intent.getExtras().getBoolean("parameter");
}
};


public void onResume() {
super.onResume();
getActivity().registerReceiver(mReceiver, new IntentFilter(INTENT_FILTER));


};


@Override
public void onPause() {
getActivity().unregisterReceiver(mReceiver);
super.onPause();
}


// send a broadcast that will be "caught" once the receiver is up
protected void notifyFragment() {
Intent intent = new Intent(SelectCategoryFragment.INTENT_FILTER);
// you can send data to receiver as intent extras
intent.putExtra("parameter", true);
getActivity().sendBroadcast(intent);
}


}

Here is a slightly different way to approach the problem of doing Fragment commits in a callback function and avoiding the IllegalStateException issue.

First create a custom runnable interface.

public interface MyRunnable {
void run(AppCompatActivity context);
}

Next, create a fragment for processing the MyRunnable objects. If the MyRunnable object was created after the Activity was paused, for e.g. if the screen is rotated, or the user presses the home button, it is put in a queue for later processing with a new context. The queue survives any configuration changes because setRetain instance is set to true. The method runProtected runs on UI thread to avoid a race condition with the isPaused flag.

public class PauseHandlerFragment extends Fragment {


private AppCompatActivity context;
private boolean isPaused = true;
private Vector<MyRunnable> buffer = new Vector<>();


@Override
public void onAttach(Context context) {
super.onAttach(context);
this.context = (AppCompatActivity)context;
}


@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setRetainInstance(true);
}


@Override
public void onPause() {
isPaused = true;
super.onPause();
}


@Override
public void onResume() {
isPaused = false;
playback();
super.onResume();
}


private void playback() {
while (buffer.size() > 0) {
final MyRunnable runnable = buffer.elementAt(0);
buffer.removeElementAt(0);
new Handler(Looper.getMainLooper()).post(new Runnable() {
@Override
public void run() {
//execute run block, providing new context, incase
//Android re-creates the parent activity
runnable.run(context);
}
});
}
}
public final void runProtected(final MyRunnable runnable) {
context.runOnUiThread(new Runnable() {
@Override
public void run() {
if(isPaused) {
buffer.add(runnable);
} else {
runnable.run(context);
}
}
});
}
}

Finally, the fragment may be used in a main application as follows:

public class SomeActivity extends AppCompatActivity implements SomeListener {
PauseHandlerFragment mPauseHandlerFragment;


static class Storyboard {
public static String PAUSE_HANDLER_FRAGMENT_TAG = "phft";
}


protected void onCreate(Bundle savedInstanceState) {


super.onCreate(savedInstanceState);


...


//register pause handler
FragmentManager fm = getSupportFragmentManager();
mPauseHandlerFragment = (PauseHandlerFragment) fm.
findFragmentByTag(Storyboard.PAUSE_HANDLER_FRAGMENT_TAG);
if(mPauseHandlerFragment == null) {
mPauseHandlerFragment = new PauseHandlerFragment();
fm.beginTransaction()
.add(mPauseHandlerFragment, Storyboard.PAUSE_HANDLER_FRAGMENT_TAG)
.commit();
}


}


// part of SomeListener interface
public void OnCallback(final String data) {
mPauseHandlerFragment.runProtected(new MyRunnable() {
@Override
public void run(AppCompatActivity context) {
//this block of code should be protected from IllegalStateException
FragmentManager fm = context.getSupportFragmentManager();
...
}
});
}
}