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

Question

我有一个启动 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 资源中看到的内容，似乎唯一可能出现该异常的情况是活动被破坏时。但正如我所提到的，我禁止为基本事件进行活动娱乐。

所以任何建议都非常感谢。

Answer 1

当我从 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;
    }  
}

Answer 2

这是我的“防弹”解决方案，它汇集了我在这个主题上找到的所有好的答案（感谢@Damjan 和@Kachi）。仅当所有其他检测方式均未成功时，才吞下异常。在我的情况下，我需要自动关闭对话框，这是保护应用程序免于崩溃的唯一方法。 我希望它会帮助你！ 如果您有意见或更好的解决方案，请投票并离开 cmets。谢谢！

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;
        }
    }

Answer 3

我可能有一个解决方法。

遇到了同样的问题，我通过AsyncTask 将大量项目（通过文件系统）加载到ListView 中。让onPreExecute() 启动ProgressDialog，然后onPostExecute() 和onCancelled()（通过AsyncTask.cancel() 显式取消任务时调用）通过.cancel() 关闭它。

当我在AsyncTask 的onCancelled() 方法中杀死对话框时，得到了相同的“java.lang.IllegalArgumentException：视图未附加到窗口管理器”错误（我在优秀的@987654321 中看到了这一点） @)。

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

public ProgressDialog mDialog;

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

AsyncTask.mDialog.cancel();

调用AsyncTask.cancel() 确实会在AsyncTask 中触发onCancelled()，但由于某种原因，在调用该方法时，视图已经被销毁，因此取消对话框失败。

Answer 4

以下是解决此问题的正确方法：

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;
    }
}

这个解决方案不是盲目地捕获所有异常，而是解决了问题的根源：当用于初始化对话框的活动已经完成时，试图关闭对话框。在我的 Nexus 4 上运行 KitKat，但应该适用于所有版本的 Android。

Answer 5

我同意“Damjan”的观点。
如果您使用许多对话框，应关闭 onDestroy() 或 onStop() 中的所有对话框。
那么你也许可以减少“java.lang.IllegalArgumentException: View not attach to window manager”异常发生的频率。

@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();
}

祝你好运！

Answer 6

使用这个。

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

Answer 7

我遇到了同样的问题，你可以通过以下方式解决：

@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;
    }  
}

Answer 8

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

也许是在 Activity 不再显示后调用 dialog.dismiss() 的时间问题？

如果您注释掉 setOnCancelListener 然后在后台任务运行时退出活动，测试会发生什么情况如何？然后您的 onPostExecute 将尝试关闭已关闭的对话框。如果应用程序崩溃，您可以在关闭对话框之前检查对话框是否打开。

我遇到了完全相同的问题，所以我将在代码中尝试一下。

Answer 9

亚历克斯，

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

我建议使用in the link you posted 提供的解决方案，该解决方案建议覆盖 Activity onCreateDialog 方法并让 Android 操作系统管理对话框的生命周期。在我看来，即使您不希望您的活动切换方向，它也在某处切换方向。您可以尝试寻找一种始终阻止方向切换的方法，但我想告诉您，我个人不相信有一种万无一失的方法适用于市场上所有当前的 Android 手机。

Answer 10

大多数时候对我有用的是验证 Activity 是否没有完成。

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

Answer 11

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

刚刚遇到同样的问题。修复 API 级别 13 或更高级别。
来自 Android 文档：

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

所以我已将清单更改为：

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

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

Answer 12

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

 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;
        }
    }

Answer 13

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

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

我想我想要的是让 AsyncTask 在 Activity 被销毁之前完成（并关闭对话框），所以我将 asynctask 对象设置为一个属性并覆盖了 onDestroy() 方法。

如果异步任务花费了很多时间，用户可能会觉得设备很慢，但我认为这是他在显示进度对话框时尝试更改设备方向所付出的代价。即使需要一些时间，应用程序也不会崩溃。

private AsyncTask<Boolean, Void, Boolean> atask;

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

Answer 14

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

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

Answer 15

下面的代码对你有用，对我来说非常好：

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();
        }
    }

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