Why won't dismissDialog, removeDialog, or dialog.dismiss work in onDestroy or onPause?

Question

I can't for the life of me figure out how to manage dialogs without using configChanges to specify that you want to manually handle orientation changes. So lets say you have this AndroidManifest:

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.testandroid"
    android:versionCode="1"
    android:versionName="1.0" >

    <uses-sdk
        android:minSdkVersion="8"
        android:targetSdkVersion="15" />

    <application
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/AppTheme" >
        <activity
            android:name=".MainActivity"
            android:label="@string/title_activity_main" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />    
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>    
</manifest>

Take this MainActivity.java:

package com.example.testandroid;

import android.app.Activity;
import android.app.AlertDialog;
import android.app.AlertDialog.Builder;
import android.app.Dialog;
import android.os.Bundle;
import android.util.Log;
import android.view.Menu;
import android.view.View;

public class MainActivity extends Activity {
    private final static String TAG = "MainActivity";
    Dialog mDialog = null;
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Log.d(TAG, "onCreate");
        setContentView(R.layout.activity_main);
    }    
    public void doShowDialog(View b) {
        Log.d(TAG, "doShowDialog");
        showDialog(1);
    }

    private void tryDismiss() {
        Log.d(TAG, "tryDismiss");
        try {           
            dismissDialog(1);
            removeDialog(1);
            mDialog.dismiss();
        } catch(IllegalArgumentException ex) {
            Log.e(TAG, ex.getMessage());
        }
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        getMenuInflater().inflate(R.menu.activity_main, menu);
        return true;
    }

    @Override
    protected void onPause() {
        tryDismiss();
        super.onPause();
        Log.d(TAG, "onPause");

    }
    @Override
    protected Dialog onCreateDialog(int dialog) {
        Builder b = new AlertDialog.Builder(this);
        b.setTitle("Hello").setMessage("Waiting..");
        mDialog =  b.create();
        return mDialog;

    }    
}

and this layout (main.xml)

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
 >
    <Button 
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Open Dialog"
        android:onClick="doShowDialog"
        />

</LinearLayout>

It doesn't seem to matter if you call from onDestroy or onPause, the dialog shows back up after the orientation switches. But why? I told it to go away. If call removeDialog/dismissDialog it does nothing when called before the orientation changes. I can't figure out for the life of me why this is. The only way to get rid of this that I know of is to handle the orientation change yourself by using

android:configChanges="keyboardHidden|orientation"

I know the new way of working is to use the FragmentDialog stuff which I have not upgraded to yet and am not ready to rewrite my whole app for that. Just seems strange that this doesn't work.

This is just an example of a real world problem I'm having in my app where the user can request some data be pulled from a remote server (to update a spinner's data), and if they switch orientation the loading dialog will never go away and there seems to be no fix for this besides handling the orientation change with the android:configChanges option. Which I can do but it seems ridiculous to me to have to do that.

-- Update -- Removed the button to dismiss the dialog as it's not necessary and you can't click it anyways since the dialog is on top.

To reproduce just start the app, click the button that opens the dialog, and then rotate your phone.

Answer 1

Your dialog is saved in onSaveInstanceState, so you might try dismissing it before it's launched:

@Override
protected void onSaveInstanceState(Bundle state)
{
  tryDismiss();
  super.onSaveInstanceState(state);
}

Also I don't really understand why do you use Activity's onCreateDialog to manage dialogs. The reason it was designed was to handle orientation changes automatically. If you want to handle it manually, why don't you just use dialog's functions? Instead of using showDialog(id) and onCreateDialog(id) just launch it directly, it won't reappear after rotating the screen.

    Builder b = new AlertDialog.Builder(this);
    b.setTitle("Hello").setMessage("Waiting..");
    Dialog mDialog =  b.create();
    mDialog.show(); // <-----

Answer 2

Sebastian got it but I'd like to explain a bit more about the situation and my findings on dialogs since it can be quite confusing:

1. As sebastian put it, you must call dismissDialog/removeDialog from onSaveInstanceState if you want the dialog gone before the rotation.
2. While you can create a dialog from onCreate, if you don't dismiss it before the orientation change you won't be able to dismiss in the onCreate method when the activity restarts. You must call dismissDialog from onPostCreate
3. Calling dismissDialog didn't work in onRestoreInstanceState after orientation change as well. I tried both before and after calling super.onRestoreInstanceState and neither worked (thought it would since dimissing happens in onSaveInstanceState)

Even more important than this is that I learned if you are doing some Asynchronous task, such as an HTTP call and you have an inner class which contains a callback function which will run when the task is complete, you need to be aware that that inner class method will contain a reference to the original instance of the outer Activity class if the screen is rotated. This was not at all obvious to me as and I wasn't actually using AsyncTask as many others have had issues with (I was using an asynchronous http library).

Taking a small example similar to my real code:

     public class MyActivity extends Activity {
   private static MyActivity sThis;

   @Override
   public void onCreate(Bundle state) {
      super.onCreate(state);
      sThis = this;
      doAsyncWork();
   }

   @Override
   public void onDestroy() {
      super.onDestroy();
      sThis = null;
   }
   private void doAsyncWork() {
      showDialog(LOADING_DIALOG); 
      ExampleAsyncWorker.work(new AsyncWorkerCallback() {   
           @Override
           public void onWorkComplete() {
             dismissDialog(LOADING_DIALOG); //doesn't work if orientation change happened.
           }        
      });
   }
}

The above code, through the CategoryManager, connects to an external server, downloads a list of categories, and once it is complete calls onCategoriesObtained and then onFetchComplete (also there are some error handling callback function removed for brevity). If an orientation change happens between the fetchCategories call and onFetchComplete then the call to dismissDialog in onFetchComplete will never work. The reason is that this inner class has an implicit reference to the original instance of the Activity class which was created before the orientation change. Thus, when you call dismissDialog you are calling it on the original instance not the new one, which will cause the dismissDialog to fail with the message: "no dialog with id 1 was ever shown via Activity#showDialog". I did figure out a way around this but its a bit of hack:

In your Activity class, include a static reference to the this reference and set it in onCreate, and null it in onDestroy, and use that reference from your inner class like so:

public class MyActivity extends Activity {
   private static MyActivity sThis;

   @Override
   public void onCreate(Bundle state) {
      super.onCreate(state);
      sThis = this;
      doAsyncWork();
   }

   @Override
   public void onDestroy() {
      super.onDestroy();
      sThis = null;
   }
   private void doAsyncWork() {
      showDialog(LOADING_DIALOG); 
      ExampleAsyncWorker.work(new AsyncWorkerCallback() {   
           @Override
           public void onWorkComplete() {
              sThis.dismissDialog(LOADING_DIALOG);
           }        
      });
   }
}

Note that I'm not sure this is a great practice but it worked for me. I know there can be problems with inner classes in activities that refer to the outer class (leaking the context) so there may be better ways of solving this problem.

Answer 3

AFAIK , This window leaked can be handled in two ways.

@Override
public void onDestroy(){
    super.onDestroy();
    if ( Dialog!=null && Dialog.isShowing() ){
        Dialog.dismiss();
    }
}

Or

if(getActivity()!= null && !getActivity().isFinishing()){
            Dialog.show();
} 

Here Dailog is your progress /alert dailog

Answer 4

for creating your app without the savedinstace you can use super.onCreate(null);