On showing dialog I get "Can not perform this action after onSaveInstanceState"

Some users are reporting, if they use the quick action in the notification bar, they are getting a force close.

I show a quick action in the notification who calls the "TestDialog" class. In the TestDialog class after pressing the button "snooze", I will show the SnoozeDialog.

private View.OnClickListener btnSnoozeOnClick() {
	return new View.OnClickListener() {
		
		public void onClick(View v) {
			showSnoozeDialog();
		}
	};
}

private void showSnoozeDialog() {
    FragmentManager fm = getSupportFragmentManager();
    SnoozeDialog snoozeDialog = new SnoozeDialog();
    snoozeDialog.show(fm, "snooze_dialog");
}

The error is *IllegalStateException: Can not perform this action after onSaveInstanceState*.

The code line where the IllegarStateException gets fired is:

snoozeDialog.show(fm, "snooze_dialog");

The class is extending "FragmentActivity" and the "SnoozeDialog" class is extending "DialogFragment".

Here is the complete stack trace of the error:

java.lang.IllegalStateException: Can not perform this action after onSaveInstanceState
at android.support.v4.app.FragmentManagerImpl.checkStateLoss(FragmentManager.java:1327)
at android.support.v4.app.FragmentManagerImpl.enqueueAction(FragmentManager.java:1338)
at android.support.v4.app.BackStackRecord.commitInternal(BackStackRecord.java:595)
at android.support.v4.app.BackStackRecord.commit(BackStackRecord.java:574)
at android.support.v4.app.DialogFragment.show(DialogFragment.java:127)
at com.test.testing.TestDialog.f(TestDialog.java:538)
at com.test.testing.TestDialog.e(TestDialog.java:524)
at com.test.testing.TestDialog.d(TestDialog.java:519)
at com.test.testing.g.onClick(TestDialog.java:648)
at android.view.View.performClick(View.java:3620)
at android.view.View$PerformClick.run(View.java:14292)
at android.os.Handler.handleCallback(Handler.java:605)
at android.os.Handler.dispatchMessage(Handler.java:92)
at android.os.Looper.loop(Looper.java:137)
at android.app.ActivityThread.main(ActivityThread.java:4507)
at java.lang.reflect.Method.invokeNative(Native Method)
at java.lang.reflect.Method.invoke(Method.java:511)
at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:790)
at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:557)
at dalvik.system.NativeStart.main(Native Method)

I can't reproduce this error, but I am getting a lot of error reports.

Can anybody help that how can I fix this error?

This is common issue. We solved this issue by overriding show() and handling exception in DialogFragment extended class

public class CustomDialogFragment extends DialogFragment {

    @Override
    public void show(FragmentManager manager, String tag) {
        try {
            FragmentTransaction ft = manager.beginTransaction();
            ft.add(this, tag);
            ft.commit();
        } catch (IllegalStateException e) {
            Log.d("ABSDIALOGFRAG", "Exception", e);
        }
    }
}

Note that applying this method will not alter the internal fields of the DialogFragment.class:

boolean mDismissed;
boolean mShownByMe;

This may lead to unexpected results in some cases. Better use commitAllowingStateLoss() instead of commit()

That mean you commit() (show() in case of DialogFragment) fragment after onSaveInstanceState().

Android will save your fragment state at onSaveInstanceState(). So, if you commit() fragment after onSaveInstanceState() fragment state will be lost.

As a result, if Activity get killed and recreate later the fragment will not add to activity which is bad user experience. That's why Android does not allow state loss at all costs.

The easy solution is to check whether state already saved.

boolean mIsStateAlreadySaved = false;
boolean mPendingShowDialog = false;

@Override
public void onResumeFragments(){
    super.onResumeFragments();
    mIsStateAlreadySaved = false;
    if(mPendingShowDialog){
        mPendingShowDialog = false;
        showSnoozeDialog();
    }
}

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

private void showSnoozeDialog() {
    if(mIsStateAlreadySaved){
        mPendingShowDialog = true;
    }else{
        FragmentManager fm = getSupportFragmentManager();
        SnoozeDialog snoozeDialog = new SnoozeDialog();
        snoozeDialog.show(fm, "snooze_dialog");
    }
}

Note: onResumeFragments() will call when fragments resumed.

Using the new lifecycle scopes of Activity-KTX its as simple as the following code sample:

lifecycleScope.launchWhenResumed {
   showErrorDialog(...)
}

This method can directly be called after onStop() and will successfully show the dialog once onResume() has been called upon returning.

private void showSnoozeDialog() {
	FragmentManager fm = getSupportFragmentManager();
	SnoozeDialog snoozeDialog = new SnoozeDialog();
	// snoozeDialog.show(fm, "snooze_dialog");
	FragmentTransaction ft = getSupportFragmentManager().beginTransaction();
	ft.add(snoozeDialog, "snooze_dialog");
	ft.commitAllowingStateLoss();
}

ref: link

After few days I want share my solution how I've fixed it, to show DialogFragment you should to override show() method of it and call commitAllowingStateLoss() on Transaction object. Here is example in Kotlin:

override fun show(manager: FragmentManager?, tag: String?) {
        try {
            val ft = manager?.beginTransaction()
            ft?.add(this, tag)
            ft?.commitAllowingStateLoss()
        } catch (ignored: IllegalStateException) {
            
        }

    }

If the dialog is not really important (it is okay to not-show it when the app closed/is no longer in view), use:

boolean running = false;

@Override
public void onStart() {
	running = true;
	super.onStart();
}

@Override
public void onStop() {
	running = false;
	super.onStop();
}

And open your dialog(fragment) only when we're running:

if (running) {
	yourDialog.show(...);
}

EDIT, PROBABLY BETTER SOLUTION:

Where onSaveInstanceState is called in the lifecycle is unpredictable, I think a better solution is to check on isSavedInstanceStateDone() like this:

/**
 * True if SavedInstanceState was done, and activity was not restarted or resumed yet.
 */
private boolean savedInstanceStateDone;

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

    savedInstanceStateDone = false;
}

@Override
protected void onStart() {
    super.onStart();

    savedInstanceStateDone = false;
}

protected void onSaveInstanceState(Bundle outState) {
    super.onSaveInstanceState(outState);
    savedInstanceStateDone = true;
}


/**
 * Returns true if SavedInstanceState was done, and activity was not restarted or resumed yet.
 */
public boolean isSavedInstanceStateDone() {
    return savedInstanceStateDone;
}

I have run in to this problem for years.
The Internets are littered with scores (hundreds? thousands?) of discussions about this, and confusion and disinformation in them seems aplenty.
To make the situation worse, and in the spirit of the xkcd "14 standards" comic, I am throwing in my answer in to the ring.

The cancelPendingInputEvents(), commitAllowingStateLoss(), catch (IllegalStateException e), and similar solutions all seem atrocious.

Hopefully the following easily shows how to reproduce and fix the problem:

private static final Handler sHandler = new Handler();
private boolean mIsAfterOnSaveInstanceState = true;

@Override
protected void onSaveInstanceState(Bundle outState)
{
    super.onSaveInstanceState(outState);
    mIsAfterOnSaveInstanceState = true; // <- To repro, comment out this line
}

@Override
protected void onPostResume()
{
    super.onPostResume();
    mIsAfterOnSaveInstanceState = false;
}

@Override
protected void onResume()
{
    super.onResume();
    sHandler.removeCallbacks(test);
}

@Override
protected void onPause()
{
    super.onPause();
    sHandler.postDelayed(test, 5000);
}

Runnable test = new Runnable()
{
    @Override
    public void run()
    {
        if (mIsAfterOnSaveInstanceState)
        {
            // TODO: Consider saving state so that during or after onPostResume a dialog can be shown with the latest text
            return;
        }

        FragmentManager fm = getSupportFragmentManager();
        DialogFragment dialogFragment = (DialogFragment) fm.findFragmentByTag("foo");
        if (dialogFragment != null)
        {
            dialogFragment.dismiss();
        }

        dialogFragment = GenericPromptSingleButtonDialogFragment.newInstance("title", "message", "button");
        dialogFragment.show(fm, "foo");

        sHandler.postDelayed(test, 5000);
    }
};

please try to use FragmentTransaction instead of FragmentManager. I think the below code will solve your problem. If not, Please let me know.

FragmentTransaction ft = getSupportFragmentManager().beginTransaction();
SnoozeDialog snoozeDialog = new SnoozeDialog();
snoozeDialog.show(ft, "snooze_dialog");

EDIT:

Fragment Transaction

Please check this link. I think it will solve you queries.

Make your dialog fragment object global and call dismissAllowingStateLoss() in onPause() method

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

    if (dialogFragment != null) {
        dialogFragment.dismissAllowingStateLoss();
    }
}

Don't forget to assign value in fragment and call show() on button click or where ever.

Many views post high-level events such as click handlers to the event queue to run deferred. So the problem is that "onSaveInstanceState" has already been called for the Activity but the event queue contains deferred "click event". Hence when this event is dispatched to your handler

at android.os.Handler.handleCallback(Handler.java:605)
at android.os.Handler.dispatchMessage(Handler.java:92)
at android.os.Looper.loop(Looper.java:137)

and your code does show the IllegalStateException is thrown.

The simplest solution is to clean event queue, in onSaveInstanceState

protected void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        // ..... do some work
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
            findViewById(android.R.id.content).cancelPendingInputEvents();
        }
}

use this code

FragmentTransaction ft = fm.beginTransaction();
        ft.add(yourFragment, "fragment_tag");
        ft.commitAllowingStateLoss();

instead of

yourFragment.show(fm, "fragment_tag");

If you override show() function, DON'T DO THIS:

override fun show(manager: FragmentManager, tag: String?) {
    // mDismissed = false; is removed -> lead to wrong state
    // mShownByMe = true; is removed -> lead to wrong state
    val ft = manager.beginTransaction()
    ft.add(this, tag)
    ft.commitAllowingStateLoss()
}

It maybe lead to wrong state of dialog

Just do:

override fun show(manager: FragmentManager, tag: String?) {
    try {
        super.show(manager, tag)
    } catch (e: Exception) {
        val ft = manager.beginTransaction()
        ft.add(this, tag)
        ft.commitAllowingStateLoss()
    }
}

Though it's not officially mentioned anywhere but I faced this problem couple of times. In my experience there is something wrong in compatibility library supporting fragments on older platforms which causes this problem. You use test this by using normal fragment manager API. If nothing works then you can use the normal dialog instead of dialog fragment.

1. Add this class to your project: (must be in android.support.v4.app package)

package android.support.v4.app;

/**

Created by Gil on 8/16/2017.
*/

public class StatelessDialogFragment extends DialogFragment {
/**
* Display the dialog, adding the fragment using an existing transaction and then committing the
* transaction whilst allowing state loss.

*
* I would recommend you use {@link #show(FragmentTransaction, String)} most of the time but
* this is for dialogs you reallly don't care about. (Debug/Tracking/Adverts etc.)
*
* @param transaction
*            An existing transaction in which to add the fragment.
* @param tag
*            The tag for this fragment, as per
*            {@link FragmentTransaction#add(Fragment, String) FragmentTransaction.add}.
* @return Returns the identifier of the committed transaction, as per
*         {@link FragmentTransaction#commit() FragmentTransaction.commit()}.
* @see StatelessDialogFragment#showAllowingStateLoss(FragmentManager, String)
*/
public int showAllowingStateLoss(FragmentTransaction transaction, String tag)
{
mDismissed = false;
mShownByMe = true;
transaction.add(this, tag);
mViewDestroyed = false;
mBackStackId = transaction.commitAllowingStateLoss();
return mBackStackId;
}
/**
 * Display the dialog, adding the fragment to the given FragmentManager. This is a convenience
 * for explicitly creating a transaction, adding the fragment to it with the given tag, and
 * committing it without careing about state. This does <em>not</em> add the transaction to the
 * back stack. When the fragment is dismissed, a new transaction will be executed to remove it
 * from the activity.<br>
 *
 * I would recommend you use {@link #show(FragmentManager, String)} most of the time but this is
 * for dialogs you reallly don't care about. (Debug/Tracking/Adverts etc.)
 *
 *
 * @param manager
 *            The FragmentManager this fragment will be added to.
 * @param tag
 *            The tag for this fragment, as per
 *            {@link FragmentTransaction#add(Fragment, String) FragmentTransaction.add}.
 * @see StatelessDialogFragment#showAllowingStateLoss(FragmentTransaction, String)
 */
public void showAllowingStateLoss(FragmentManager manager, String tag)
{
    mDismissed = false;
    mShownByMe = true;
    FragmentTransaction ft = manager.beginTransaction();
    ft.add(this, tag);
    ft.commitAllowingStateLoss();
}

}

2. Extend StatelessDialogFragment instead of DialogFragment

3. Use the method showAllowingStateLoss instead of show

4. Enjoy ;)

I have found an elegant solution for this problem by using reflection. Problem of all above solutions is that fields mDismissed and mShownByMe do not change their state.

Just override method "show" in your own custom bottom sheet dialog fragment like sample below (Kotlin)

override fun show(manager: FragmentManager, tag: String?) {
        val mDismissedField = DialogFragment::class.java.getDeclaredField("mDismissed")
        mDismissedField.isAccessible = true
        mDismissedField.setBoolean(this, false)

        val mShownByMeField = DialogFragment::class.java.getDeclaredField("mShownByMe")
        mShownByMeField.isAccessible = true
        mShownByMeField.setBoolean(this, true)

        manager.beginTransaction()
                .add(this, tag)
                .commitAllowingStateLoss()
    }

The following implementation can be used to solve the problem of performing safely state changes during the Activity lifecycle, in particular for showing dialogs: if the instance state has already been saved (e.g. due to a configuration change), it postpones them until the resumed state has been performed.

public abstract class XAppCompatActivity extends AppCompatActivity {

	private String TAG = this.getClass().getSimpleName();

	/** The retained fragment for this activity */
	private ActivityRetainFragment retainFragment;

	/** If true the instance state has been saved and we are going to die... */
	private boolean instanceStateSaved;

	@Override
	protected void onPostCreate(Bundle savedInstanceState) {
		super.onPostCreate(savedInstanceState);

		// get hold of retain Fragment we'll be using
		retainFragment = ActivityRetainFragment.get(this, "Fragment-" + this.getClass().getName());
	}

	@Override
	protected void onPostResume() {
		super.onPostResume();

		// reset instance saved state
		instanceStateSaved = false;

		// execute all the posted tasks
		for (ActivityTask task : retainFragment.tasks) task.exec(this);
		retainFragment.tasks.clear();
	}

	@Override
	protected void onSaveInstanceState(Bundle outState) {
		super.onSaveInstanceState(outState);
		instanceStateSaved = true;
	}

	/**
	 * Checks if the activity state has been already saved.
	 * After that event we are no longer allowed to commit fragment transactions.
	 * @return true if the instance state has been saved
	 */
	public boolean isInstanceStateSaved() {
		return instanceStateSaved;
	}

	/**
	 * Posts a task to be executed when the activity state has not yet been saved
	 * @param task The task to be executed
	 * @return true if the task executed immediately, false if it has been queued
	 */
	public final boolean post(ActivityTask task)
	{
		// execute it immediately if we have not been saved
		if (!isInstanceStateSaved()) {
			task.exec(this);
			return true;
		}

		// save it for better times
		retainFragment.tasks.add(task);
		return false;
	}

	/** Fragment used to retain activity data among re-instantiations */
	public static class ActivityRetainFragment extends Fragment {

		/**
		 * Returns the single instance of this fragment, creating it if necessary
		 * @param activity The Activity performing the request
		 * @param name The name to be given to the Fragment
		 * @return The Fragment
		 */
		public static ActivityRetainFragment get(XAppCompatActivity activity, String name) {

			// find the retained fragment on activity restarts
			FragmentManager fm = activity.getSupportFragmentManager();
			ActivityRetainFragment fragment = (ActivityRetainFragment) fm.findFragmentByTag(name);

			// create the fragment and data the first time
			if (fragment == null) {
				// add the fragment
				fragment = new ActivityRetainFragment();
				fm.beginTransaction().add(fragment, name).commit();
			}

			return fragment;
		}

		/** The queued tasks */
		private LinkedList<ActivityTask> tasks = new LinkedList<>();

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

			// retain this fragment
			setRetainInstance(true);
		}

	}

	/** A task which needs to be performed by the activity when it is "fully operational" */
	public interface ActivityTask {

		/**
		 * Executed this task on the specified activity
		 * @param activity The activity
		 */
		void exec(XAppCompatActivity activity);
	}
}

Then using a class like this:

/** AppCompatDialogFragment implementing additional compatibility checks */
public abstract class XAppCompatDialogFragment extends AppCompatDialogFragment {

	/**
	 * Shows this dialog as soon as possible
	 * @param activity The activity to which this dialog belongs to
	 * @param tag The dialog fragment tag
	 * @return true if the dialog has been shown immediately, false if the activity state has been saved
	 *         and it is not possible to show it immediately
	 */
	public boolean showRequest(XAppCompatActivity activity, final String tag) {
		return showRequest(activity, tag, null);
	}

	/**
	 * Shows this dialog as soon as possible
	 * @param activity The activity to which this dialog belongs to
	 * @param tag The dialog fragment tag
	 * @param args The dialog arguments
	 * @return true if the dialog has been shown immediately, false if the activity state has been saved
	 *         and it is not possible to show it immediately
	 */
	public boolean showRequest(XAppCompatActivity activity, final String tag, final Bundle args)
	{
		return activity.post(new XAppCompatActivity.ActivityTask() {
			@Override
			public void exec(XAppCompatActivity activity) {
				if (args!= null) setArguments(args);
				show(activity.getSupportFragmentManager(), tag);
			}
		});
	}

	/**
	 * Dismiss this dialog as soon as possible
	 * @return true if the dialog has been dismissed immediately, false if the activity state has been saved
	 *         and it is not possible to dismissed it immediately
	 */
	public boolean dismissRequest()
	{
		return dismissRequest(null);
	}

	/**
	 * Dismiss this dialog as soon as possible
	 * @param runnable Actions to be performed before dialog dismissal
	 * @return true if the dialog has been dismissed immediately, false if the activity state has been saved
	 *         and it is not possible to dismissed it immediately
	 */
	public boolean dismissRequest(final Runnable runnable)
	{
		// workaround as in rare cases the activity could be null
		XAppCompatActivity activity = (XAppCompatActivity)getActivity();
		if (activity == null) return false;

		// post the dialog dismissal
		return activity.post(new XAppCompatActivity.ActivityTask() {
			@Override
			public void exec(XAppCompatActivity activity) {
				if (runnable != null) runnable.run();
				dismiss();
			}
		});
	}
}

You can safely show dialogs without worrying about the app state:

public class TestDialog extends XAppCompatDialogFragment {

	private final static String TEST_DIALOG = "TEST_DIALOG";

	public static void show(XAppCompatActivity activity) {
		new TestDialog().showRequest(activity, TEST_DIALOG);
	}

	public TestDialog() {}

	@NonNull
	@Override
	public Dialog onCreateDialog(Bundle savedInstanceState)
	{
		return new AlertDialog.Builder(getActivity(), R.style.DialogFragmentTheme /* or null as you prefer */)
				.setTitle(R.string.title)
				// set all the other parameters you need, e.g. Message, Icon, etc.
				).create();
	}
}

and then call TestDialog.show(this) from within your XAppCompatActivity.

If you want to create a more generic dialog class with parameters, you can save them in a Bundle with the arguments in the show() method and retrieve them with getArguments() in onCreateDialog().

The whole approach could seem a bit complex, but once you have created the two base classes for activities and dialogs, it is quite easy to use and is perfectly working. It can be used for other Fragment based operations which could be affected by the same problem.

This error appears to be occurring because input events (such as key down or onclick events) are getting delivered after onSaveInstanceState is called.

The solution is to override onSaveInstanceState in your Activity and cancel any pending events.

@Override
protected void onSaveInstanceState(Bundle outState) {
    super.onSaveInstanceState(outState);
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
        final View rootView = findViewById(android.R.id.content);
        if (rootView != null) {
            rootView.cancelPendingInputEvents();
        }
    }
}