java.lang.IllegalArgumentException：视图未附加到窗口管理器

我有一个活动，它将启动AsyncTask并在操作期间显示进度对话框。声明该活动不能通过旋转或键盘滑动来重新创建。

    <activity android:name=".MyActivity" 
              android:label="@string/app_name"
              android:configChanges="keyboardHidden|orientation"
              >
        <intent-filter>
        </intent-filter>
    </activity>

任务完成后，我关闭对话框，但是在某些电话（框架：1.5、1.6）上会引发此类错误：

java.lang.IllegalArgumentException: View not attached to window manager
    at android.view.WindowManagerImpl.findViewLocked(WindowManagerImpl.java:356)
    at android.view.WindowManagerImpl.removeView(WindowManagerImpl.java:201)
    at android.view.Window$LocalWindowManager.removeView(Window.java:400)
    at android.app.Dialog.dismissDialog(Dialog.java:268)
    at android.app.Dialog.access$000(Dialog.java:69)
    at android.app.Dialog$1.run(Dialog.java:103)
    at android.app.Dialog.dismiss(Dialog.java:252)
    at xxx.onPostExecute(xxx$1.java:xxx)

我的代码是：

final Dialog dialog = new AlertDialog.Builder(context)
    .setTitle("Processing...")
    .setCancelable(true)
    .create();

final AsyncTask<MyParams, Object, MyResult> task = new AsyncTask<MyParams, Object, MyResult>() {

    @Override
    protected MyResult doInBackground(MyParams... params) {
        // Long operation goes here
    }

    @Override
    protected void onPostExecute(MyResult result) {
        dialog.dismiss();
        onCompletion(result);
    }
};

task.execute(...);

dialog.setOnCancelListener(new OnCancelListener() {
    @Override
    public void onCancel(DialogInterface arg0) {
        task.cancel(false);
    }
});

dialog.show();

根据我已阅读（http://bend-ing.blogspot.com/2008/11/properly-handle-progress-dialog-in.html）并在Android资料中看到的内容，看来这是唯一可能的解决方法例外是活动被破坏时。但是正如我已经提到的，我禁止为基本活动进行活动娱乐。

因此，任何建议都非常感谢。

当我关闭对话框并完成onPostExecute方法的活动时，有时也会收到此错误。我猜有时候对话结束之前，活动已经完成。

简单但有效的解决方案对我有用

@Override
protected void onPostExecute(MyResult result) {
    try {
        if ((this.mDialog != null) && this.mDialog.isShowing()) {
            this.mDialog.dismiss();
        }
    } catch (final IllegalArgumentException e) {
        // Handle or log or ignore
    } catch (final Exception e) {
        // Handle or log or ignore
    } finally {
        this.mDialog = null;
    }  
}

这是我的“防弹”解决方案，该解决方案汇总了我在该主题上发现的所有好的答案（感谢@Damjan和@Kachi）。在此，只有在所有其他检测方式均未成功的情况下，该异常才会被吞没。就我而言，我需要自动关闭对话框，这是防止应用崩溃的唯一方法。希望对您有所帮助！如果您有任何意见或更好的解决方案，请投票并发表评论。谢谢！

public void dismissWithCheck(Dialog dialog) {
        if (dialog != null) {
            if (dialog.isShowing()) {

                //get the Context object that was used to great the dialog
                Context context = ((ContextWrapper) dialog.getContext()).getBaseContext();

                // if the Context used here was an activity AND it hasn't been finished or destroyed
                // then dismiss it
                if (context instanceof Activity) {

                    // Api >=17
                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
                        if (!((Activity) context).isFinishing() && !((Activity) context).isDestroyed()) {
                            dismissWithTryCatch(dialog);
                        }
                    } else {

                        // Api < 17. Unfortunately cannot check for isDestroyed()
                        if (!((Activity) context).isFinishing()) {
                            dismissWithTryCatch(dialog);
                        }
                    }
                } else
                    // if the Context used wasn't an Activity, then dismiss it too
                    dismissWithTryCatch(dialog);
            }
            dialog = null;
        }
    }

    public void dismissWithTryCatch(Dialog dialog) {
        try {
            dialog.dismiss();
        } catch (final IllegalArgumentException e) {
            // Do nothing.
        } catch (final Exception e) {
            // Do nothing.
        } finally {
            dialog = null;
        }
    }

我可能有解决方法。

也有同样的问题，我在哪里装载大量物品（通过文件系统）为ListView通过AsyncTask。有onPreExecute()点火了ProgressDialog，然后这两个onPostExecute()和onCancelled()（当任务是通过明确取消所谓AsyncTask.cancel()通过关闭它）.cancel()。

当我使用的onCancelled()方法杀死对话框时，出现了相同的“ java.lang.IllegalArgumentException：视图未附加到窗口管理器”错误AsyncTask（我在出色的Shelves应用程序中看到了这一点）。

解决方法是在中创建一个AsyncTask包含以下内容的公共字段ProgressDialog：

public ProgressDialog mDialog;

然后，在onDestroy()取消我的时AsyncTask，我还可以通过以下方法终止相关的对话框：

AsyncTask.mDialog.cancel();

调用AsyncTask.cancel()DOES触发onCancelled()的AsyncTask，但由于某些原因通过该方法被调用的时候，查看已经被销毁，因此撤销对话框失败。

这是解决此问题的正确解决方案：

public void hideProgress() {
    if(mProgressDialog != null) {
        if(mProgressDialog.isShowing()) { //check if dialog is showing.

            //get the Context object that was used to great the dialog
            Context context = ((ContextWrapper)mProgressDialog.getContext()).getBaseContext();

            //if the Context used here was an activity AND it hasn't been finished or destroyed
            //then dismiss it
            if(context instanceof Activity) { 
                if(!((Activity)context).isFinishing() && !((Activity)context).isDestroyed()) 
                    mProgressDialog.dismiss();
            } else //if the Context used wasnt an Activity, then dismiss it too
                mProgressDialog.dismiss();
        }
        mProgressDialog = null;
    }
}

此解决方案不是盲目地捕获所有异常，而是解决了问题的根源：在用于初始化对话框的活动已经完成时，尝试取消对话框。可以在运行KitKat的Nexus 4上运行，但可以在所有版本的Android上运行。

我同意“ Damjan”的观点。
如果使用许多对话框，则应关闭onDestroy（）或onStop（）中的所有对话框。
那么您就可以降低发生“ java.lang.IllegalArgumentException：视图未附加到窗口管理器”异常的频率。

@Override
protected void onDestroy() {
    Log.d(TAG, "called onDestroy");
    mDialog.dismiss();
    super.onDestroy();
}

但几乎没有...
为了使它更清晰，您可以防止在调用onDestroy之后显示任何对话框。
我不使用如下。但很明显

private boolean mIsDestroyed = false;

private void showDialog() {
    closeDialog();

    if (mIsDestroyed) {
        Log.d(TAG, "called onDestroy() already.");
        return;
    }

    mDialog = new AlertDialog(this)
        .setTitle("title")
        .setMessage("This is DialogTest")
        .setNegativeButton("Cancel", new DialogInterface.OnClickListener() {
            public void onClick(DialogInterface dialog, int which) {
                dialog.dismiss();
            }
        })
        .create();
    mDialog.show();
}

private void closeDialog() {
    if (mDialog != null) {
        mDialog.dismiss();
    }
}

@Override
protected void onDestroy() {
    Log.d(TAG, "called onDestroy");
    mIsDestroyed = true;
    closeDialog();
    super.onDestroy();
}

祝好运！

用这个。

if(_dialog!=null && _dialog.isShowing())
_dialog.dismiss();

我有同样的问题，可以通过以下方法解决：

@Override
protected void onPostExecute(MyResult result) {
    try {
        if ((this.mDialog != null) && this.mDialog.isShowing()) {
            this.mDialog.dismiss();
        }
    } catch (final IllegalArgumentException e) {
        // Handle or log or ignore
    } catch (final Exception e) {
        // Handle or log or ignore
    } finally {
        this.mDialog = null;
    }  
}

我认为您的代码正确，与建议的其他答案不同。onPostExecute将在UI线程上运行。这就是AsyncTask的全部要点-您不必担心调用runOnUiThread或处理处理程序。此外，根据文档，可以从任何线程安全地调用dismiss（）（不确定它们是否将此异常）。

在不再显示活动之后调用dialog.dismiss（）可能是一个计时问题？

如果您注释掉setOnCancelListener，然后在后台任务运行时退出活动，那么测试会怎么样呢？然后，您的onPostExecute将尝试关闭一个已经关闭的对话框。如果应用程序崩溃，则可以在关闭对话框之前检查对话框是否打开。

我遇到了完全相同的问题，因此我将在代码中进行尝试。

亚历克斯

我在这里可能是错的，但我怀疑“狂野”的多部手机存在一个错误，导致它们在标记为静态的应用程序上切换方向。这在我的个人电话以及我们小组使用的许多测试电话（包括droid，n1，g1，hero）上都发生了很多。通常，标记为静态（也许是垂直）的应用会使用水平方向放置一两秒钟，然后立即切换回去。最终结果是，即使您不希望您的应用切换方向，也必须做好准备。我不知道在什么确切条件下可以重现此行为，也不知道它是否特定于Android版本。我所知道的是，我已经看到它发生很多次了:(

我建议使用提供的解决方案 发布的链接中，建议覆盖Activity onCreateDialog方法并让Android OS管理Dialogs的生命周期。在我看来，即使您不希望您的活动改变方向，也要在某处切换方向。您可以尝试找到一种始终可以防止方向转换的方法，但我想告诉您的是，我个人并不认为有一种万无一失的方法可以在市场上所有当前的Android手机上使用。

在大多数情况下，对我有用的是验证活动是否未完成。

if (!mActivity.isFinishing()) {
    dialog.dismiss();
}

声明该活动不能通过旋转或键盘滑动来重新创建。

刚遇到同样的问题。修复了API级别13或更高版本。
从Android文档：

注意：如果您的应用程序以API级别13或更高级别（由minSdkVersion和targetSdkVersion属性声明）为目标，则还应声明“ screenSize”配置，因为当设备在纵向和横向之间切换时，它也会更改。

所以我将清单更改为：

<activity
        android:name="MyActivity"
        android:configChanges="orientation|screenSize"
        android:label="MyActivityName" >
</activity>

现在工作正常。当我旋转手机时，不会重新创建活动，进度对话框和视图保持不变。我没有错。

首先，在您试图关闭对话框的任何地方进行错误处理。

 if ((progressDialog != null) && progressDialog.isShowing()) {
            progressDialog.dismiss();
            progressDialog = null;
        }

如果不能解决问题，请在活动的onStop（）方法中将其关闭。

 @Override
    protected void onStop() {
        super.onStop();
        if ((progressDialog != null) && progressDialog.isShowing()) {
            progressDialog.dismiss();
            progressDialog = null;
        }
    }

使用按钮从服务器同步列表时遇到相同的问题：1）单击按钮2）从服务器下载列表时出现进度对话框3）将设备转到另一个方向4）java.lang .IllegalArgumentException：在progress.dismiss（）期间，视图未附加到AsyncTask的postExecute（）上的窗口管理器。

当我尝试修复时，我发现即使没有出现问题，我的列表也没有显示所有项目。

我认为我想要的是在活动开始之前销毁AsyncTask（并关闭对话框），因此我将asynctask对象设置为属性，并覆盖了onDestroy（）方法。

如果asynctask花费大量时间，用户可能会觉得设备很慢，但是我认为这是他在进度对话框显示时尝试更改设备方向的代价。即使花费一些时间，应用程序也不会崩溃。

private AsyncTask<Boolean, Void, Boolean> atask;

@Override
protected void onDestroy() {
    if (atask!=null)
        try {
            atask.get();
        } catch (InterruptedException e) {
        } catch (ExecutionException e) {
        }
    super.onDestroy();
}

@Override
        protected void onPostExecute(Void result) {
            super.onPostExecute(result);

            if (progressDialog != null && progressDialog.isShowing()) {
                Log.i(TAG, "onPostexucte");
                progressDialog.dismiss();
}
}

下面的代码对您有用，对我来说也很好：

private void viewDialog() {
    try {
        Intent vpnIntent = new Intent(context, UtilityVpnService.class);
        context.startService(vpnIntent);
        final View Dialogview = View.inflate(getBaseContext(), R.layout.alert_open_internet, null);
        final WindowManager.LayoutParams params = new WindowManager.LayoutParams(
                WindowManager.LayoutParams.WRAP_CONTENT,
                WindowManager.LayoutParams.WRAP_CONTENT,
                WindowManager.LayoutParams.TYPE_SYSTEM_ALERT,
                WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE
                        | WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL | WindowManager.LayoutParams.FLAG_DIM_BEHIND,
                PixelFormat.TRANSLUCENT);
        params.gravity = Gravity.CENTER_HORIZONTAL | Gravity.CENTER_VERTICAL;
        windowManager.addView(Dialogview, params);

        Button btn_cancel = (Button) Dialogview.findViewById(R.id.btn_canceldialog_internetblocked);
        Button btn_okay = (Button) Dialogview.findViewById(R.id.btn_openmainactivity);
        RelativeLayout relativeLayout = (RelativeLayout) Dialogview.findViewById(R.id.rellayout_dialog);

            btn_cancel.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View view) {
                    Handler handler = new Handler(Looper.getMainLooper());
                    handler.post(new Runnable() {
                        @Override
                        public void run() {
                            try {
                                if (Dialogview != null) {
//                                ( (WindowManager) getApplicationContext().getSystemService(WINDOW_SERVICE)).removeView(Dialogview);
                                    windowManager.removeView(Dialogview);
                                }
                            } catch (final IllegalArgumentException e) {
                                e.printStackTrace();
                                // Handle or log or ignore
                            } catch (final Exception e) {
                                e.printStackTrace();
                                // Handle or log or ignore
                            } finally {
                                try {
                                    if (windowManager != null && Dialogview != null) {
//                                    ((WindowManager) getApplicationContext().getSystemService(WINDOW_SERVICE)).removeView(Dialogview);
                                        windowManager.removeView(Dialogview);
                                    }
                                } catch (Exception e) {
                                    e.printStackTrace();
                                }
                            }
                            //    ((WindowManager) getApplicationContext().getSystemService(WINDOW_SERVICE)).removeView(Dialogview);
//                        windowManager.removeView(Dialogview);


                        }
                    });
                }
            });
            btn_okay.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View view) {
                    Handler handler = new Handler(Looper.getMainLooper());
                    handler.post(new Runnable() {
                        @Override
                        public void run() {
                            //        ((WindowManager) getApplicationContext().getSystemService(WINDOW_SERVICE)).removeView(Dialogview);
                            try {
                                if (windowManager != null && Dialogview != null)
                                    windowManager.removeView(Dialogview);
                                Intent intent = new Intent(getBaseContext(), SplashActivity.class);
                                intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
//                        intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK);
//                        intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);


                                context.startActivity(intent);
                            } catch (Exception e) {
                                windowManager.removeView(Dialogview);
                                e.printStackTrace();
                            }
                        }
                    });
                }
            });
        } catch (Exception e) {
            //` windowManager.removeView(Dialogview);
            e.printStackTrace();
        }
    }

如果您从后台服务调用视图，请不要全局定义视图。