java.lang.IllegalArgumentException: widok nie jest dołączony do menedżera okien

Mam działanie, które uruchamia AsyncTask i pokazuje okno dialogowe postępu na czas trwania operacji. Zadeklarowano, że aktywność NIE jest odtwarzana przez obrót lub przesuwanie klawiatury.

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

Po zakończeniu zadania zamykam okno dialogowe, ale na niektórych telefonach (framework: 1.5, 1.6) wyrzuca taki błąd:

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)

Mój kod to:

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

Z tego, co przeczytałem ( http://bend-ing.blogspot.com/2008/11/properly-handle-progress-dialog-in.html ) i widziałem w źródłach Androida, wygląda na to, że jedyna możliwa sytuacja to wyjątkiem jest sytuacja, gdy aktywność została zniszczona. Ale jak wspomniałem, zabraniam rekreacji ruchowej na podstawowe imprezy.

Dlatego wszelkie sugestie są bardzo mile widziane.

Ja również otrzymuję ten błąd czasami, gdy zamykam okno dialogowe i kończę działanie z metody onPostExecute. Wydaje mi się, że czasami aktywność kończy się przed pomyślnym zamknięciem okna dialogowego.

Proste, ale skuteczne rozwiązanie, które działa na mnie

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

Oto moje "kuloodporne" rozwiązanie, które jest kompilacją wszystkich dobrych odpowiedzi, jakie znalazłem na ten temat (dzięki @Damjan i @Kachi). Tutaj wyjątek zostaje połknięty tylko wtedy, gdy nie powiodły się wszystkie inne sposoby wykrywania. W moim przypadku muszę automatycznie zamknąć okno dialogowe i jest to jedyny sposób, aby chronić aplikację przed awarią. Mam nadzieję, że ci to pomoże! Proszę głosuj i zostawiaj komentarze, jeśli masz uwagi lub lepsze rozwiązanie. Dziękuję Ci!

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

Mogę znaleźć obejście.

Miałem ten sam problem, w którym ładuję wiele elementów (za pośrednictwem systemu plików) do pliku ListViewza pośrednictwem pliku AsyncTask. Gdyby onPreExecute()uruchomienie a ProgressDialog, a następnie oba onPostExecute()i onCancelled()(wywoływane, gdy zadanie zostało jawnie anulowane za pośrednictwem AsyncTask.cancel()), zamykając je za pomocą .cancel().

Pojawił się ten sam błąd „java.lang.IllegalArgumentException: Widok nie jest dołączony do menedżera okien”, gdy zabijałem okno dialogowe onCancelled()metodą AsyncTask(widziałem to w doskonałej aplikacji Półki ).

Sposób obejścia problemu polegał na utworzeniu pola publicznego w AsyncTaskzawierającym ProgressDialog:

public ProgressDialog mDialog;

Następnie, onDestroy()gdy anuluję moje AsyncTask, mogę również zamknąć powiązane okno dialogowe za pomocą:

AsyncTask.mDialog.cancel();

Wywołanie AsyncTask.cancel()WYZWALA onCancelled()w programie AsyncTask, ale z jakiegoś powodu w momencie wywołania tej metody widok został już zniszczony, a zatem anulowanie okna dialogowego kończy się niepowodzeniem.

Oto prawidłowe rozwiązanie tego problemu:

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

Zamiast ślepo wychwytywać wszystkie wyjątki, to rozwiązanie rozwiązuje problem: próbuje zamknąć okno dialogowe, gdy czynność użyta do zainicjowania okna dialogowego została już zakończona. Pracuję na moim Nexusie 4 z KitKatem, ale powinien działać na wszystkich wersjach Androida.

zgadzam się z opinią „Damjan”.
jeśli używasz wielu okien dialogowych, zamknij wszystkie okna w onDestroy () lub onStop ().
wtedy możesz zmniejszyć częstotliwość „java.lang.IllegalArgumentException: pojawia się wyjątek Widok niepołączony z menedżerem okien”.

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

ale trochę więcej ...
aby było jaśniej, zapobiegasz pokazywaniu żadnego dialogu po wywołaniu onDestroy.
nie używam jak poniżej. ale jest jasne.

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

powodzenia!

Użyj tego.

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

Miałem ten sam problem, możesz go rozwiązać poprzez:

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

Myślę, że twój kod jest poprawny w przeciwieństwie do innej sugerowanej odpowiedzi. onPostExecute będzie działać w wątku interfejsu użytkownika. O to właśnie chodzi w AsyncTask - nie musisz się martwić o wywołanie runOnUiThread ani zajmowanie się programami obsługi. Ponadto, zgodnie z dokumentacją, disciss () można bezpiecznie wywołać z dowolnego wątku (nie jestem pewien, czy uczynił to wyjątkiem).

Być może jest to problem z synchronizacją, w którym wywoływana jest funkcja dialog.dismiss () po tym, jak aktywność nie jest już wyświetlana?

A co z testowaniem, co się stanie, jeśli skomentujesz setOnCancelListener, a następnie wyjdziesz z działania, gdy zadanie w tle jest uruchomione? Wtedy onPostExecute spróbuje zamknąć już zamknięte okno dialogowe. Jeśli aplikacja ulegnie awarii, prawdopodobnie możesz po prostu sprawdzić, czy okno dialogowe jest otwarte, zanim je zamkniesz.

Mam dokładnie ten sam problem, więc zamierzam wypróbować go w kodzie.

Alex,

Mogę się mylić, ale podejrzewam, że wiele telefonów „na wolności” ma błąd, który powoduje, że zmieniają orientację w aplikacjach oznaczonych jako zorientowane statycznie. Dzieje się to dość często na moim telefonie osobistym i na wielu telefonach testowych używanych przez naszą grupę (w tym droid, n1, g1, hero). Zazwyczaj aplikacja oznaczona jako zorientowana statycznie (być może pionowo) będzie się układać przez sekundę lub dwie w orientacji poziomej, a następnie natychmiast przełączy się z powrotem. Efekt końcowy jest taki, że nawet jeśli nie chcesz, aby Twoja aplikacja zmieniała orientację, musisz być na to przygotowany. Nie wiem, w jakich dokładnie warunkach można odtworzyć to zachowanie, nie wiem, czy jest specyficzne dla wersji Androida. Wiem tylko, że widziałem to wiele razy :(

Zalecałbym skorzystanie z rozwiązania podanego w opublikowanym przez Ciebie łączu, które sugeruje zastąpienie metody Activity onCreateDialog i zezwolenie systemowi operacyjnemu Android na zarządzanie cyklem życia Twoich okien dialogowych. Wydaje mi się, że chociaż nie chcesz, aby twoja aktywność zmieniała orientację, to gdzieś zmienia się orientacja. Możesz spróbować znaleźć metodę, która zawsze zapobiegnie zmianie orientacji, ale próbuję ci powiedzieć, że osobiście nie wierzę, że istnieje niezawodny sposób, który działa na wszystkich obecnych telefonach z Androidem na rynku.

Przez większość czasu sprawdzałem, czy działanie się nie kończy.

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

Zadeklarowano, że aktywność NIE jest odtwarzana przez obrót lub przesuwanie klawiatury.

Właśnie mam ten sam problem. Poprawka dla poziomu API 13 lub wyższego.
Z dokumentów systemu Android:

Uwaga: jeśli aplikacja jest przeznaczona dla interfejsu API na poziomie 13 lub wyższym (zgodnie z deklaracją w atrybutach minSdkVersion i targetSdkVersion), należy również zadeklarować konfigurację „screenSize”, ponieważ zmienia się ona również, gdy urządzenie przełącza się między orientacją pionową i poziomą.

Więc zmieniłem swój manifest na ten:

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

A teraz działa dobrze. Aktywność nie jest odtwarzana, gdy obracam telefon, okno dialogowe postępu i widok pozostają takie same. Nie ma dla mnie błędu.

Przede wszystkim wykonaj obsługę błędów wszędzie tam, gdzie próbujesz zamknąć okno dialogowe.

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

Jeśli to nie pomoże, odrzuć to w metodzie działania onStop ().

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

Miałem ten sam problem podczas używania przycisku do synchronizacji listy z serwerem: 1) Klikam przycisk 2) Pojawia się okno dialogowe postępu podczas pobierania listy z serwera 3) Przełączam urządzenie w inną orientację 4) java.lang .IllegalArgumentException: widok nie dołączony do menedżera okien w funkcji postExecute () AsyncTask podczas progress.dismiss ().

Kiedy próbowałem naprawić, doszedłem do wniosku, że nawet jeśli problem nie występuje, moja lista nie wyświetla wszystkich pozycji.

Doszedłem do wniosku, że chcę, aby AsyncTask zakończyło działanie (i zamknęło okno dialogowe) przed zniszczeniem działania, więc uczyniłem obiekt asynctask atrybutem i nadpisałem metodę onDestroy ().

Jeśli zadanie asynchroniczne zajmuje dużo czasu, użytkownik może poczuć, że urządzenie działa wolno, ale myślę, że to cena, którą płaci za próbę zmiany orientacji urządzenia, gdy pojawia się okno dialogowe postępu. Nawet jeśli zajmie to trochę czasu, aplikacja nie ulegnie awarii.

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

Dużo poniższy kod działa u Ciebie, u mnie działa idealnie:

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

Nie definiuj swojego widoku globalnie, jeśli wywołujesz go z usługi w tle.