当进度对话框和后台线程处于活动状态时如何处理屏幕方向变化？

Question

我的程序在后台线程中执行一些网络活动。 在开始之前，它会弹出一个进度对话框。 该对话框在处理程序上被关闭。 这一切都工作正常，除非在对话框启动时屏幕方向发生变化（并且后台线程正在运行）。 此时，应用程序要么崩溃，要么死锁，或者进入一个奇怪的阶段，在该阶段应用程序根本无法工作，直到所有线程都被杀死。

如何优雅地处理屏幕方向的变化？

下面的示例代码大致匹配我的真实程序的功能：

public class MyAct extends Activity implements Runnable {
    public ProgressDialog mProgress;

    // UI has a button that when pressed calls send

    public void send() {
         mProgress = ProgressDialog.show(this, "Please wait", 
                      "Please wait", 
                      true, true);
        Thread thread = new Thread(this);
        thread.start();
    }

    public void run() {
        Thread.sleep(10000);
        Message msg = new Message();
        mHandler.sendMessage(msg);
    }

    private final Handler mHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            mProgress.dismiss();
        }
    };
}

Stack：

E/WindowManager(  244): Activity MyAct has leaked window com.android.internal.policy.impl.PhoneWindow$DecorView@433b7150 that was originally added here
E/WindowManager(  244): android.view.WindowLeaked: Activity MyAct has leaked window com.android.internal.policy.impl.PhoneWindow$DecorView@433b7150 that was originally added here
E/WindowManager(  244):     at android.view.ViewRoot.<init>(ViewRoot.java:178)
E/WindowManager(  244):     at android.view.WindowManagerImpl.addView(WindowManagerImpl.java:147)
E/WindowManager(  244):     at android.view.WindowManagerImpl.addView(WindowManagerImpl.java:90)
E/WindowManager(  244):     at android.view.Window$LocalWindowManager.addView(Window.java:393)
E/WindowManager(  244):     at android.app.Dialog.show(Dialog.java:212)
E/WindowManager(  244):     at android.app.ProgressDialog.show(ProgressDialog.java:103)
E/WindowManager(  244):     at android.app.ProgressDialog.show(ProgressDialog.java:91)
E/WindowManager(  244):     at MyAct.send(MyAct.java:294)
E/WindowManager(  244):     at MyAct$4.onClick(MyAct.java:174)
E/WindowManager(  244):     at android.view.View.performClick(View.java:2129)
E/WindowManager(  244):     at android.view.View.onTouchEvent(View.java:3543)
E/WindowManager(  244):     at android.widget.TextView.onTouchEvent(TextView.java:4664)
E/WindowManager(  244):     at android.view.View.dispatchTouchEvent(View.java:3198)

我尝试关闭 onSaveInstanceState 中的进度对话框，但这只是防止立即崩溃。 后台线程仍在运行，UI 处于部分绘制状态。 需要先杀死整个应用程序，然后才能重新开始工作。

Answer 1

编辑：正如 Dianne Hackborn（又名 hackbod）所述，Google 工程师不推荐这种方法在此StackOverflow 帖子中。 查看这篇博文< /a> 了解更多信息。

---

您必须将其添加到清单中的活动声明中：

android:configChanges="orientation|screenSize"

所以看起来像

<activity android:label="@string/app_name" 
        android:configChanges="orientation|screenSize|keyboardHidden" 
        android:name=".your.package">

这样，问题是当配置发生更改时系统会销毁该活动。 请参阅ConfigurationChanges。

因此，将其放入配置文件中可以避免系统破坏您的活动。 相反，它会调用 onConfigurationChanged(Configuration) 方法。

Answer 2

当你切换方向时，Android 将创建一个新的视图。 您可能会崩溃，因为您的后台线程正在尝试更改旧线程的状态。 （它也可能遇到麻烦，因为你的后台线程不在 UI 线程上）

我建议使该 mHandler 可变并在方向更改时更新它。

Answer 3

我针对这些问题提出了一个符合“Android 方式”的可靠解决方案。 我所有长时间运行的操作都使用 IntentService 模式。

也就是说，我的活动广播意图，IntentService 完成工作，将数据保存在数据库中，然后广播粘性意图。 粘性部分很重要，这样即使 Activity 在用户启动工作后的时间内暂停并错过了来自 IntentService 的实时广播，我们仍然可以响应并从调用 Activity 中获取数据。 ProgressDialog 可以通过 onSaveInstanceState() 很好地处理这种模式。

基本上，您需要保存一个标志，表明您在保存的实例包中运行了进度对话框。 不要保存进度对话框对象，因为这会泄漏整个 Activity。 为了获得进度对话框的持久句柄，我将其作为弱引用存储在应用程序对象中。 在方向更改或其他导致活动暂停（电话、用户回家等）然后恢复的情况下，我会关闭旧对话框并在新创建的活动中重新创建新对话框。

对于不确定进度对话框，这很容易。 对于进度条样式，您必须将最后已知的进度放入包中，以及您在活动中本地使用的任何信息来跟踪进度。 在恢复进度时，您将使用此信息以与之前相同的状态重新生成进度条，然后根据当前状态进行更新。

总而言之，将长时间运行的任务放入 IntentService 中并明智地使用 onSaveInstanceState() 可以让您有效地跟踪对话框并在整个 Activity 生命周期事件中进行恢复。 活动代码的相关部分如下。 您还需要 BroadcastReceiver 中的逻辑来适当处理粘性意图，但这超出了本文的范围。

public void doSignIn(View view) {
    waiting=true;
    AppClass app=(AppClass) getApplication();
    String logingon=getString(R.string.signon);
    app.Dialog=new WeakReference<ProgressDialog>(ProgressDialog.show(AddAccount.this, "", logingon, true));
    ...
}

@Override
protected void onSaveInstanceState(Bundle saveState) {
    super.onSaveInstanceState(saveState);
    saveState.putBoolean("waiting",waiting);
}

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    if(savedInstanceState!=null) {
        restoreProgress(savedInstanceState);    
    }
    ...
}

private void restoreProgress(Bundle savedInstanceState) {
    waiting=savedInstanceState.getBoolean("waiting");
    if (waiting) {
        AppClass app=(AppClass) getApplication();
        ProgressDialog refresher=(ProgressDialog) app.Dialog.get();
        refresher.dismiss();
        String logingon=getString(R.string.signon);
        app.Dialog=new WeakReference<ProgressDialog>(ProgressDialog.show(AddAccount.this, "", logingon, true));
    }
}

Answer 4

我遇到了同样的问题。 我的活动需要从 URL 解析一些数据，但速度很慢。 因此，我创建一个线程来执行此操作，然后显示一个进度对话框。 我让线程在完成时通过 Handler 将消息发送回 UI 线程。 在 Handler.handleMessage 中，我从线程获取数据对象（现已准备好）并将其填充到 UI。 所以它与你的例子非常相似。

经过多次尝试和错误，我似乎找到了解决方案。 至少现在我可以在线程完成之前或之后随时旋转屏幕。 在所有测试中，对话框均已正确关闭并且所有行为均符合预期。

我所做的如下所示。 目标是填充我的数据模型 (mDataObject)，然后将其填充到 UI。 应该允许屏幕随时旋转，不会出现意外。

class MyActivity {

    private MyDataObject mDataObject = null;
    private static MyThread mParserThread = null; // static, or make it singleton

    OnCreate() {
        ...
        Object retained = this.getLastNonConfigurationInstance();
        if(retained != null) {
            // data is already completely obtained before config change
            // by my previous self.
            // no need to create thread or show dialog at all
            mDataObject = (MyDataObject) retained;
            populateUI();
        } else if(mParserThread != null && mParserThread.isAlive()){
            // note: mParserThread is a static member or singleton object.
            // config changed during parsing in previous instance. swap handler
            // then wait for it to finish.
            mParserThread.setHandler(new MyHandler());
        } else {
            // no data and no thread. likely initial run
            // create thread, show dialog
            mParserThread = new MyThread(..., new MyHandler());
            mParserThread.start();
            showDialog(DIALOG_PROGRESS);
        }
    }

    // http://android-developers.blogspot.com/2009/02/faster-screen-orientation-change.html
    public Object onRetainNonConfigurationInstance() {
        // my future self can get this without re-downloading
        // if it's already ready.
        return mDataObject;
    }

    // use Activity.showDialog instead of ProgressDialog.show
    // so the dialog can be automatically managed across config change
    @Override
    protected Dialog onCreateDialog(int id) {
        // show progress dialog here
    }

    // inner class of MyActivity
    private class MyHandler extends Handler {
        public void handleMessage(msg) {
            mDataObject = mParserThread.getDataObject();
            populateUI();
            dismissDialog(DIALOG_PROGRESS);
        }
    }
}

class MyThread extends Thread {
    Handler mHandler;
    MyDataObject mDataObject;

    // constructor with handler param
    public MyHandler(..., Handler h) {
        ...
        mHandler = h;
    }

    public void setHandler(Handler h) { mHandler = h; } // for handler swapping after config change
    public MyDataObject getDataObject() { return mDataObject; } // return data object (completed) to caller

    public void run() {
        mDataObject = new MyDataObject();
        // do the lengthy task to fill mDataObject with data
        lengthyTask(mDataObject);
        // done. notify activity
        mHandler.sendEmptyMessage(0); // tell activity: i'm ready. come pick up the data.
    }
}

这对我有用。 我不知道这是否是 Android 设计的“正确”方法——他们声称这种“在屏幕旋转期间销毁/重新创建活动”实际上使事情变得更容易，所以我想这应该不会太棘手。

如果您在我的代码中发现问题，请告诉我。 楼上说了，不知道有没有副作用。

Answer 5

最初发现的问题是代码无法在屏幕方向更改后继续存在。 显然，这是通过让程序自行处理屏幕方向更改来“解决”的，而不是让 UI 框架来处理（通过调用 onDestroy））。

我认为，如果根本问题是程序无法在 Destroy() 上生存，那么接受的解决方案只是一种解决方法，使程序面临严重的其他问题和漏洞。 请记住，Android 框架明确指出，由于您无法控制的情况，您的活动几乎随时都有被破坏的风险。 因此，您的 Activity 必须能够因任何原因而在 onDestroy() 和后续的 onCreate() 中生存，而不仅仅是屏幕方向更改。

如果您打算自己接受处理屏幕方向更改来解决 OP 的问题，则需要验证 onDestroy() 的其他原因不会导致相同的错误。 你能做到吗？ 如果不是，我会质疑“接受”的答案是否真的是一个非常好的答案。

Answer 6

我的解决方案是扩展 ProgressDialog 类以获得我自己的 MyProgressDialog。

我重新定义了 show() 和 dismiss() 方法在显示 Dialog 之前锁定方向，并在 Dialog 关闭时将其解锁。

因此，当显示Dialog并且设备方向发生变化时，屏幕方向保持不变，直到调用dismiss()，然后屏幕方向根据传感器发生变化价值观/设备导向。

这是我的代码：

public class MyProgressDialog extends ProgressDialog {
    private Context mContext;

    public MyProgressDialog(Context context) {
        super(context);
        mContext = context;
    }

    public MyProgressDialog(Context context, int theme) {
        super(context, theme);
        mContext = context;
    }
    
    public void show() {
        if (mContext.getResources().getConfiguration().orientation == Configuration.ORIENTATION_PORTRAIT)
            ((Activity) mContext).setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
        else
            ((Activity) mContext).setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
        super.show();
    }
    
    public void dismiss() {
        super.dismiss();
        ((Activity) mContext).setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_SENSOR);
    }
}

Answer 7

我遇到了同样的问题，我想出了一个不涉及使用 ProgressDialog 的解决方案，并且我得到了更快的结果。

我所做的是创建一个其中包含进度条的布局。

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout
xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="fill_parent"
android:layout_height="fill_parent">
<ProgressBar
    android:id="@+id/progressImage"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:layout_centerInParent="true"
    />
</RelativeLayout>

然后在 onCreate 方法中执行以下

public void onCreate(Bundle icicle) {
    super.onCreate(icicle);
    setContentView(R.layout.progress);
}

操作然后在线程中执行长任务，完成后将 Runnable 设置为要用于此活动的实际布局的内容视图。

例如：

mHandler.post(new Runnable(){

public void run() {
        setContentView(R.layout.my_layout);
    } 
});

这就是我所做的，我发现它比显示 ProgressDialog 运行得更快，而且在我看来它的侵入性更小并且外观更好。

但是，如果您想使用 ProgressDialog，那么这个答案不适合您。

Answer 8

我发现了一个我在其他地方还没有见过的解决方案。 您可以使用自定义应用程序对象，该对象知道您是否有后台任务正在进行，而不是尝试在方向更改时被销毁并重新创建的活动中执行此操作。 我在此处发表了有关此内容的博客。

Answer 9

我将贡献我的方法来处理这个轮换问题。 这可能与 OP 无关，因为他没有使用 AsyncTask，但也许其他人会发现它很有用。 它非常简单，但似乎适合我：

我有一个登录活动，其中包含一个名为 BackgroundLoginTask 的嵌套 AsyncTask 类。

在我的 BackgroundLoginTask 中，除了在调用 ProgressDialog 的关闭时添加空检查之外，我没有做任何异常的事情：

@Override
protected void onPostExecute(Boolean result)
{    
if (pleaseWaitDialog != null)
            pleaseWaitDialog.dismiss();
[...]
}

这是为了处理后台任务的情况当 Activity 不可见时完成，因此，进度对话框已被 onPause() 方法关闭。

接下来，在我的父 Activity 类中，我为我的 AsyncTask 类和我的 ProgressDialog （AsyncTask >，嵌套，可以访问这些变量）：

private static BackgroundLoginTask backgroundLoginTask;
private static ProgressDialog pleaseWaitDialog;

这有两个目的：首先，它允许我的 Activity 始终访问 AsyncTask 对象，即使是从新的、后轮换的对象活动。 其次，它允许我的 BackgroundLoginTask 即使在旋转后也可以访问和关闭 ProgressDialog。

接下来，我将其添加到 onPause() 中，导致当我们的 Activity 离开前台时进度对话框消失（防止丑陋的“强制关闭”崩溃）：

    if (pleaseWaitDialog != null)
    pleaseWaitDialog.dismiss();

最后，我的 onResume() 方法中有以下内容：

if ((backgroundLoginTask != null) && (backgroundLoginTask.getStatus() == Status.RUNNING))
        {
           if (pleaseWaitDialog != null)
             pleaseWaitDialog.show();
        }

这允许 Dialog 在重新创建 Activity 后重新出现。

以下是整个课程：

public class NSFkioskLoginActivity extends NSFkioskBaseActivity {
    private static BackgroundLoginTask backgroundLoginTask;
    private static ProgressDialog pleaseWaitDialog;
    private Controller cont;

    // This is the app entry point.
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        if (CredentialsAvailableAndValidated())
        {
        //Go to main menu and don't run rest of onCreate method.
            gotoMainMenu();
            return;
        }
        setContentView(R.layout.login);
        populateStoredCredentials();   
    }

    //Save current progress to options when app is leaving foreground
    @Override
    public void onPause()
    {
        super.onPause();
        saveCredentialsToPreferences(false);
        //Get rid of progress dialog in the event of a screen rotation. Prevents a crash.
        if (pleaseWaitDialog != null)
        pleaseWaitDialog.dismiss();
    }

    @Override
    public void onResume()
    {
        super.onResume();
        if ((backgroundLoginTask != null) && (backgroundLoginTask.getStatus() == Status.RUNNING))
        {
           if (pleaseWaitDialog != null)
             pleaseWaitDialog.show();
        }
    }

    /**
     * Go to main menu, finishing this activity
     */
    private void gotoMainMenu()
    {
        startActivity(new Intent(getApplicationContext(), NSFkioskMainMenuActivity.class));
        finish();
    }

    /**
     * 
     * @param setValidatedBooleanTrue If set true, method will set CREDS_HAVE_BEEN_VALIDATED to true in addition to saving username/password.
     */
    private void saveCredentialsToPreferences(boolean setValidatedBooleanTrue)
    {
        SharedPreferences settings = getSharedPreferences(APP_PREFERENCES, MODE_PRIVATE);
        SharedPreferences.Editor prefEditor = settings.edit();
        EditText usernameText = (EditText) findViewById(R.id.editTextUsername);
        EditText pswText = (EditText) findViewById(R.id.editTextPassword);
        prefEditor.putString(USERNAME, usernameText.getText().toString());
        prefEditor.putString(PASSWORD, pswText.getText().toString());
        if (setValidatedBooleanTrue)
        prefEditor.putBoolean(CREDS_HAVE_BEEN_VALIDATED, true);
        prefEditor.commit();
    }

    /**
     * Checks if user is already signed in
     */
    private boolean CredentialsAvailableAndValidated() {
        SharedPreferences settings = getSharedPreferences(APP_PREFERENCES,
                MODE_PRIVATE);
        if (settings.contains(USERNAME) && settings.contains(PASSWORD) && settings.getBoolean(CREDS_HAVE_BEEN_VALIDATED, false) == true)
         return true;   
        else
        return false;
    }

    //Populate stored credentials, if any available
    private void populateStoredCredentials()
    {
        SharedPreferences settings = getSharedPreferences(APP_PREFERENCES,
            MODE_PRIVATE);
        settings.getString(USERNAME, "");
       EditText usernameText = (EditText) findViewById(R.id.editTextUsername);
       usernameText.setText(settings.getString(USERNAME, ""));
       EditText pswText = (EditText) findViewById(R.id.editTextPassword);
       pswText.setText(settings.getString(PASSWORD, ""));
    }

    /**
     * Validate credentials in a seperate thread, displaying a progress circle in the meantime
     * If successful, save credentials in preferences and proceed to main menu activity
     * If not, display an error message
     */
    public void loginButtonClick(View view)
    {
        if (phoneIsOnline())
        {
        EditText usernameText = (EditText) findViewById(R.id.editTextUsername);
        EditText pswText = (EditText) findViewById(R.id.editTextPassword);
           //Call background task worker with username and password params
           backgroundLoginTask = new BackgroundLoginTask();
           backgroundLoginTask.execute(usernameText.getText().toString(), pswText.getText().toString());
        }
        else
        {
        //Display toast informing of no internet access
        String notOnlineMessage = getResources().getString(R.string.noNetworkAccessAvailable);
        Toast toast = Toast.makeText(getApplicationContext(), notOnlineMessage, Toast.LENGTH_SHORT);
        toast.show();
        }
    }

    /**
     * 
     * Takes two params: username and password
     *
     */
    public class BackgroundLoginTask extends AsyncTask<Object, String, Boolean>
    {       
       private Exception e = null;

       @Override
       protected void onPreExecute()
       {
           cont = Controller.getInstance();
           //Show progress dialog
           String pleaseWait = getResources().getString(R.string.pleaseWait);
           String commWithServer = getResources().getString(R.string.communicatingWithServer);
            if (pleaseWaitDialog == null)
              pleaseWaitDialog= ProgressDialog.show(NSFkioskLoginActivity.this, pleaseWait, commWithServer, true);

       }

        @Override
        protected Boolean doInBackground(Object... params)
        {
        try {
            //Returns true if credentials were valid. False if not. Exception if server could not be reached.
            return cont.validateCredentials((String)params[0], (String)params[1]);
        } catch (Exception e) {
            this.e=e;
            return false;
        }
        }

        /**
         * result is passed from doInBackground. Indicates whether credentials were validated.
         */
        @Override
        protected void onPostExecute(Boolean result)
        {
        //Hide progress dialog and handle exceptions
        //Progress dialog may be null if rotation has been switched
        if (pleaseWaitDialog != null)
             {
            pleaseWaitDialog.dismiss();
                pleaseWaitDialog = null;
             }

        if (e != null)
        {
         //Show toast with exception text
                String networkError = getResources().getString(R.string.serverErrorException);
                Toast toast = Toast.makeText(getApplicationContext(), networkError, Toast.LENGTH_SHORT);
            toast.show();
        }
        else
        {
            if (result == true)
            {
            saveCredentialsToPreferences(true);
            gotoMainMenu();
            }
            else
            {
            String toastText = getResources().getString(R.string.invalidCredentialsEntered);
                Toast toast = Toast.makeText(getApplicationContext(), toastText, Toast.LENGTH_SHORT);
            toast.show();
            } 
        }
        }

    }
}

我绝不是经验丰富的 Android 开发人员，所以请随意发表评论。

Answer 10

将长任务移至单独的类中。 将其实现为主体-观察者模式。 每当创建活动时，都会向任务类注册并在关闭时取消注册。 任务类可以使用AsyncTask。

Answer 11

技巧是像往常一样在 onPreExecute/onPostExecute 期间显示/关闭 AsyncTask 中的对话框，但在方向更改的情况下，在活动中创建/显示对话框的新实例并将其引用传递给任务。

public class MainActivity extends Activity {
    private Button mButton;
    private MyTask mTask = null;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        MyTask task = (MyTask) getLastNonConfigurationInstance();
        if(task != null){
            mTask = task;
            mTask.mContext = this;
            mTask.mDialog = ProgressDialog.show(this, "", "", true);        
        }

        mButton = (Button) findViewById(R.id.button1);
        mButton.setOnClickListener(new View.OnClickListener(){
            public void onClick(View v){
                mTask = new MyTask(MainActivity.this);
                mTask.execute();
            }
        });
    }


    @Override
    public Object onRetainNonConfigurationInstance() {
        String str = "null";
        if(mTask != null){
            str = mTask.toString();
            mTask.mDialog.dismiss();
        }
        Toast.makeText(this, str, Toast.LENGTH_SHORT).show();
        return mTask;
    }



    private class MyTask extends AsyncTask<Void, Void, Void>{
        private ProgressDialog mDialog;
        private MainActivity mContext;


        public MyTask(MainActivity context){
            super();
            mContext = context;
        }


        protected void onPreExecute() {
            mDialog = ProgressDialog.show(MainActivity.this, "", "", true);
        }

        protected void onPostExecute(Void result) {
            mContext.mTask = null;
            mDialog.dismiss();
        }


        @Override
        protected Void doInBackground(Void... params) {
            SystemClock.sleep(5000);
            return null;
        }       
    }
}

Answer 12

我已经这样做了。 代码改编自 Android使用处理程序、AsyncTask 和加载器进行后台处理 - Lars Vogel 的教程：

    package com.palewar;
    import android.app.Activity;
    import android.app.ProgressDialog;
    import android.os.Bundle;
    import android.os.Handler;
    import android.os.Message;

    public class ThreadActivity extends Activity {
    
        
        static ProgressDialog dialog;
        private Thread downloadThread;
        final static Handler handler = new Handler() {
    
            @Override
            public void handleMessage(Message msg) {
    
                super.handleMessage(msg);
    
                dialog.dismiss();
    
            }
    
        };
    
        protected void onDestroy() {
    super.onDestroy();
            if (dialog != null && dialog.isShowing()) {
                dialog.dismiss();
                dialog = null;
            }
            
        }
    
        /** Called when the activity is first created. */
        @Override
        public void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.main);
    
            downloadThread = (Thread) getLastNonConfigurationInstance();
            if (downloadThread != null && downloadThread.isAlive()) {
                dialog = ProgressDialog.show(ThreadActivity.this, "",
                        "Signing in...", false);
            }
    
            dialog = ProgressDialog.show(ThreadActivity.this, "",
                    "Signing in ...", false);
    
            downloadThread = new MyThread();
            downloadThread.start();
            // processThread();
        }
    
        // Save the thread
        @Override
        public Object onRetainNonConfigurationInstance() {
            return downloadThread;
        }
    
    
        static public class MyThread extends Thread {
            @Override
            public void run() {
    
                try {
                    // Simulate a slow network
                    try {
                        new Thread().sleep(5000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    handler.sendEmptyMessage(0);
    
                } finally {
    
                }
            }
        }
    
    }

您也可以尝试让我知道它是否适合您

Answer 13

这是我建议的解决方案：

• 将 AsyncTask 或线程移动到保留的片段，如所解释的 这里。 我相信将所有网络调用转移到片段中是一个很好的做法。 如果您已经在使用片段，则可以让其中之一负责调用。 否则，您可以创建一个仅用于执行请求的片段，如链接文章的建议。
• 该片段将使用侦听器接口来指示任务完成/失败。 您不必担心那里的方向变化。 该片段将始终具有到当前活动的正确链接，并且可以安全地恢复进度对话框。
• 让你的进度对话框成为你班级的一员。 事实上，您应该对所有对话框执行此操作。 在 onPause 方法中，您应该忽略它们，否则您将泄漏配置更改的窗口。 繁忙状态应该由片段保持。 当片段附加到活动时，如果调用仍在运行，您可以再次显示进度对话框。 为此，可以将 void showProgressDialog() 方法添加到片段活动侦听器接口中。

Answer 14

这是一个非常古老的问题，由于某种原因出现在侧边栏上。

如果后台任务只需要在 Activity 位于前台时生存，则“新”解决方案是将后台线程（或者最好是 AsyncTask）托管在保留片段中strong>，如本开发人员指南和大量问答。

如果活动因配置更改而被销毁，则保留的片段将继续存在，但如果活动在后台或返回堆栈中被销毁，则保留的片段不会继续存在。 因此，如果isChangingConfigurations，后台任务仍应被中断() 在 onPause() 中为 false。

Answer 15

如果您创建一个后台 Service所有繁重的工作（tcp 请求/响应、解组）、View 和 Activity 都可以被销毁并重新创建，而不会泄漏窗口或丢失数据。 这允许 Android 推荐的行为，即在每次配置更改时销毁 Activity （例如，对于每个方向变化）。

它有点复杂，但它是调用服务器请求、数据预处理/后处理等的最佳方式。

您甚至可以使用 Service 将每个请求排队到服务器，因此它使处理这些事情变得简单而高效。

开发指南有一个关于服务的完整章节。

Answer 16

我有一个实现，允许在屏幕方向更改时销毁活动，但仍然成功地销毁重新创建的活动中的对话框。
我使用 ...NonConfigurationInstance 将后台任务附加到重新创建的活动。
普通的 Android 框架负责重新创建对话框本身，没有任何改变。

我对 AsyncTask 进行了子类化，添加了“拥有”活动的字段以及更新此所有者的方法。

class MyBackgroundTask extends AsyncTask<...> {
  MyBackgroundTask (Activity a, ...) {
    super();
    this.ownerActivity = a;
  }

  public void attach(Activity a) {
    ownerActivity = a;
  }

  protected void onPostExecute(Integer result) {
    super.onPostExecute(result);
    ownerActivity.dismissDialog(DIALOG_PROGRESS);
  }

  ...
}

在我的活动类中，我添加了一个引用“拥有的”backgroundtask 的字段 backgroundTask，并使用 onRetainNonConfigurationInstance 和 getLastNonConfigurationInstance 更新该字段。

class MyActivity extends Activity {
  public void onCreate(Bundle savedInstanceState) {
    ...
    if (getLastNonConfigurationInstance() != null) {
      backgroundTask = (MyBackgroundTask) getLastNonConfigurationInstance();
      backgroundTask.attach(this);
    }
  }

  void startBackgroundTask() {
    backgroundTask = new MyBackgroundTask(this, ...);
    showDialog(DIALOG_PROGRESS);
    backgroundTask.execute(...);
  }

  public Object onRetainNonConfigurationInstance() {
    if (backgroundTask != null && backgroundTask.getStatus() != Status.FINISHED)
      return backgroundTask;
    return null;
  }
  ...
}

进一步改进的建议：

• 任务完成后清除 Activity 中的 backgroundTask 引用，以释放与其关联的任何内存或其他资源。
• 在 Activity 被销毁之前，请清除后台任务中的 ownerActivity 引用，以防它不会立即重新创建。
• 创建一个 BackgroundTask 接口和/或集合，以允许不同类型的任务从同一所属活动运行。

Answer 17

如果维护两个布局，则所有 UI 线程都应终止。

如果您使用AsynTask，那么您可以轻松地在当前活动的onDestroy()方法中调用.cancel()方法。

@Override
protected void onDestroy (){
    removeDialog(DIALOG_LOGIN_ID); // remove loading dialog
    if (loginTask != null){
        if (loginTask.getStatus() != AsyncTask.Status.FINISHED)
            loginTask.cancel(true); //cancel AsyncTask
    }
    super.onDestroy();
}

对于 AsyncTask，请阅读此处的“取消任务”部分的更多信息。

更新：
添加了检查状态的条件，因为只有处于运行状态才能取消。
另请注意，AsyncTask 只能执行一次。

Answer 18

尝试实施jfelectron的解决方案，因为它是“针对这些问题的坚如磐石的解决方案，符合‘Android Way’事物”，但花了一些时间查找并将所有提到的元素放在一起。 最终得到了这个稍微不同的、我认为更优雅的解决方案，完整地发布在这里。

使用从活动激发的 IntentService 在单独的线程上执行长时间运行的任务。 该服务将粘性广播意图触发到更新对话框的活动。 Activity 使用showDialog()、onCreateDialog() 和onPrepareDialog() 来消除在应用程序对象或savedInstanceState 包中传递持久数据的需要。 无论您的应用程序如何中断，这都应该有效。

活动类：

public class TesterActivity extends Activity {
private ProgressDialog mProgressDialog;
private static final int PROGRESS_DIALOG = 0;

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main);

    Button b = (Button) this.findViewById(R.id.test_button);
    b.setOnClickListener(new OnClickListener() {
        public void onClick(View v) {
            buttonClick();
        }
    });
}

private void buttonClick(){
    clearPriorBroadcast();
    showDialog(PROGRESS_DIALOG);
    Intent svc = new Intent(this, MyService.class);
    startService(svc);
}

protected Dialog onCreateDialog(int id) {
    switch(id) {
    case PROGRESS_DIALOG:
        mProgressDialog = new ProgressDialog(TesterActivity.this);
        mProgressDialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
        mProgressDialog.setMax(MyService.MAX_COUNTER);
        mProgressDialog.setMessage("Processing...");
        return mProgressDialog;
    default:
        return null;
    }
}

@Override
protected void onPrepareDialog(int id, Dialog dialog) {
    switch(id) {
    case PROGRESS_DIALOG:
        // setup a broadcast receiver to receive update events from the long running process
        IntentFilter filter = new IntentFilter();
        filter.addAction(MyService.BG_PROCESS_INTENT);
        registerReceiver(new MyBroadcastReceiver(), filter);
        break;
    }
}

public class MyBroadcastReceiver extends BroadcastReceiver{
    @Override
    public void onReceive(Context context, Intent intent) {
        if (intent.hasExtra(MyService.KEY_COUNTER)){
            int count = intent.getIntExtra(MyService.KEY_COUNTER, 0);
            mProgressDialog.setProgress(count);
            if (count >= MyService.MAX_COUNTER){
                dismissDialog(PROGRESS_DIALOG);
            }
        }
    }
}

/*
 * Sticky broadcasts persist and any prior broadcast will trigger in the 
 * broadcast receiver as soon as it is registered.
 * To clear any prior broadcast this code sends a blank broadcast to clear 
 * the last sticky broadcast.
 * This broadcast has no extras it will be ignored in the broadcast receiver 
 * setup in onPrepareDialog()
 */
private void clearPriorBroadcast(){
    Intent broadcastIntent = new Intent();
    broadcastIntent.setAction(MyService.BG_PROCESS_INTENT);
    sendStickyBroadcast(broadcastIntent);
}}

IntentService 类：

public class MyService extends IntentService {

public static final String BG_PROCESS_INTENT = "com.mindspiker.Tester.MyService.TEST";
public static final String KEY_COUNTER = "counter";
public static final int MAX_COUNTER = 100;

public MyService() {
  super("");
}

@Override
protected void onHandleIntent(Intent intent) {
    for (int i = 0; i <= MAX_COUNTER; i++) {
        Log.e("Service Example", " " + i);
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        Intent broadcastIntent = new Intent();
        broadcastIntent.setAction(BG_PROCESS_INTENT);
        broadcastIntent.putExtra(KEY_COUNTER, i);
        sendStickyBroadcast(broadcastIntent);
    }
}}

清单文件条目：

应用程序部分之前：

uses-permission android:name="com.mindspiker.Tester.MyService.TEST"
uses-permission android:name="android.permission.BROADCAST_STICKY"

应用程序部分内部

service android:name=".MyService"

Answer 19

我也面临着同样的情况。 我所做的只是在整个应用程序中为我的进度对话框获取一个实例。

首先，我创建了一个 DialogSingleton 类来仅获取一个实例（单例模式），

public class DialogSingleton
{
    private static Dialog dialog;

    private static final Object mLock = new Object();
    private static DialogSingleton instance;

    private DialogSingleton()
    {

    }

    public static DialogSingleton GetInstance()
    {
        synchronized (mLock)
        {
            if(instance == null)
            {
                instance = new DialogSingleton();
            }

            return instance;
        }
    }

    public void DialogShow(Context context, String title)
    {
        if(!((Activity)context).isFinishing())
        {
            dialog = new ProgressDialog(context, 2);

            dialog.setCanceledOnTouchOutside(false);

            dialog.setTitle(title);

            dialog.show();
        }
    }

    public void DialogDismiss(Context context)
    {
        if(!((Activity)context).isFinishing() && dialog.isShowing())
        {
            dialog.dismiss();
        }
    }
}

正如我在此类中所示，我将进度对话框作为属性。 每次我需要显示进度对话框时，我都会获取唯一的实例并创建一个新的 ProgressDialog。

DialogSingleton.GetInstance().DialogShow(this, "My title here!");

当我完成后台任务时，我再次调用唯一实例并关闭其对话框。

DialogSingleton.GetInstance().DialogDismiss(this);

我将后台任务状态保存在我的共享首选项中。 当我旋转屏幕时，我会询问是否有为此活动运行的任务：（onCreate）

if(Boolean.parseBoolean(preference.GetValue(IS_TASK_NAME_EXECUTED_KEY, "boolean").toString()))
{
    DialogSingleton.GetInstance().DialogShow(this, "Checking credentials!");
} // preference object gets the info from shared preferences (my own implementation to get and put data to shared preferences) and IS_TASK_NAME_EXECUTED_KEY is the key to save this flag (flag to know if this activity has a background task already running).

当我开始运行后台任务时：

preference.AddValue(IS_TASK_NAME_EXECUTED_KEY, true, "boolean");

DialogSingleton.GetInstance().DialogShow(this, "My title here!");

当我完成运行后台任务时：

preference.AddValue(IS_TASK_NAME_EXECUTED_KEY, false, "boolean");

DialogSingleton.GetInstance().DialogDismiss(ActivityName.this);

我希望它有帮助。

Answer 20

我是android新手，我尝试过这个并且它有效。

public class loadTotalMemberByBranch extends AsyncTask<Void, Void,Void> {
        ProgressDialog progressDialog = new ProgressDialog(Login.this);
        int ranSucess=0;
        @Override
        protected void onPreExecute() {
            // TODO Auto-generated method stub
            super.onPreExecute();
            progressDialog.setTitle("");    
            progressDialog.isIndeterminate();
            progressDialog.setCancelable(false);
            progressDialog.show();
            setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_NOSENSOR);

        }
        @Override
        protected Void doInBackground(Void... params) {
            // TODO Auto-generated method stub

            return null;
        }
        @Override
        protected void onPostExecute(Void result) {
            // TODO Auto-generated method stub
            super.onPostExecute(result);
            progressDialog.dismiss();
            setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_NOSENSOR);
        }
}

Answer 21

我已经尝试了一切。 花了几天时间进行实验。 我不想阻止活动轮换。 我的场景是：

1. 向用户显示动态信息的进度对话框。 例如：“正在连接到服务器...”、“正在下载数据...”等。
2. 线程执行繁重的工作并更新对话框，
3. 最后使用结果更新 UI。

问题是，当旋转屏幕时，书中的每个解决方案都失败了。 即使使用 AsyncTask 类，这也是 Android 处理这种情况的正确方法。 旋转屏幕时，启动线程正在使用的当前上下文消失了，这会扰乱正在显示的对话框。 问题始终是对话框，无论我在代码中添加了多少技巧（将新上下文传递给正在运行的线程，通过旋转保留线程状态等......）。 最后的代码复杂度总是很大，而且总有可能出错的地方。

对我有用的唯一解决方案是活动/对话框技巧。 它简单而天才，而且都是旋转证明：

1. 不要创建一个对话框并要求显示它，而是创建一个已在清单中使用 android:theme="@android:style/Theme.Dialog" 设置的 Activity。 因此，它看起来就像一个对话框。

2. 将 showDialog(DIALOG_ID) 替换为 startActivityForResult(yourActivityDialog, yourCode);

3. 在调用 Activity 中使用 onActivityResult 从执行线程获取结果（甚至包括错误）并更新 UI。

4. 在“ActivityDialog”上，使用线程或 AsyncTask 执行长任务，并使用 onRetainNonConfigurationInstance 在旋转屏幕时保存“对话框”状态。

这很快并且工作正常。 我仍然使用对话框来执行其他任务，并使用 AsyncTask 来执行不需要在屏幕上持续显示对话框的任务。 但在这种情况下，我总是选择活动/对话框模式。

而且，我没有尝试过，但当线程运行时，甚至可以阻止该活动/对话框旋转，从而加快速度，同时允许调用活动旋转。

Answer 22

如今，有一种更独特的方法来处理这些类型的问题。 典型的方法是：

1. 确保您的数据与 UI 正确分离：

任何后台进程都应该位于保留的 Fragment 中（使用 Fragment.setRetainInstance() 设置此值）这将成为您的“持久数据存储”，其中保留您想要保留的任何数据。在方向更改事件之后，此 Fragment 仍可通过 以其原始状态进行访问。 您应该给它一个标签而不是 ID，因为它没有附加到View）。

>FragmentManager.findFragmentByTag() 调用（当您创建它时， 处理运行时更改开发指南，了解有关执行操作的信息这是正确的，以及为什么它是最佳选择。

2. 确保您在后台进程和 UI 之间正确且安全地连接：

您必须反转您的链接过程。 目前，您的后台进程将自身附加到 View - 相反，您的 View 应该将自身附加到后台进程。 这更有意义吧？ View 的操作依赖于后台进程，而后台进程不依赖于 View。这意味着将链接更改为标准 Listener< /代码> 接口。 假设您的进程（无论它是什么类 - 无论是 AsyncTask、Runnable 还是其他）定义了一个 OnProcessFinishedListener，当进程完成时如果存在的话应该调用该监听器。

这个答案是关于如何进行自定义侦听器的简洁描述。

3. 无论何时创建 UI（包括方向更改），都将 UI 链接到数据进程：

现在，您必须担心后台任务与当前 View 结构的接口。 如果您正确处理方向更改（而不是人们总是推荐的configChanges hack），那么系统将重新创建您的Dialog。 这很重要，这意味着在方向改变时，所有 Dialog 的生命周期方法都会被调用。 因此，在任何这些方法中（onCreateDialog 通常是一个好地方），您可以执行如下调用：

DataFragment f = getActivity().getFragmentManager().findFragmentByTag("BACKGROUND_TAG");
if (f != null) {
    f.mBackgroundProcess.setOnProcessFinishedListener(new OnProcessFinishedListener() {
        public void onProcessFinished() {
            dismiss();
        }
    });
 }

请参阅 片段生命周期，用于确定在您的个人实现中最适合设置侦听器的位置。

这是为该问题中提出的一般问题提供稳健且完整的解决方案的通用方法。 根据您的具体情况，此答案中可能缺少一些小部分，但这通常是正确处理方向更改事件的最正确方法。

Answer 23

我找到了更简单的解决方案来处理方向变化时的线程。 您可以只保留对活动/片段的静态引用，并在对用户界面进行操作之前验证其是否为空。 我建议也使用 try catch：

 public class DashListFragment extends Fragment {
     private static DashListFragment ACTIVE_INSTANCE;

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

        ACTIVE_INSTANCE = this;

        new Handler().postDelayed(new Runnable() {
            public void run() {
                try {
                        if (ACTIVE_INSTANCE != null) {
                            setAdapter(); // this method do something on ui or use context
                        }
                }
                catch (Exception e) {}


            }
        }, 1500l);

    }

    @Override
    public void onDestroy() {
        super.onDestroy();

        ACTIVE_INSTANCE = null;
    }


}

Answer 24

如果您正在努力检测对话框的方向变化事件独立于活动引用，那么此方法效果非常好。 我使用这个是因为我有自己的对话框类，可以在多个不同的 Activity 中显示，所以我并不总是知道它在哪个 Activity 中显示。使用此方法，您不需要更改 AndroidManifest，也不必担心 Activity 引用，并且您不需要自定义对话框（就像我一样）。 但是，您确实需要自定义内容视图，以便可以使用该特定视图检测方向变化。 这是我的示例：

设置

public class MyContentView extends View{
    public MyContentView(Context context){
        super(context);
    }

    @Override
    public void onConfigurationChanged(Configuration newConfig){
        super.onConfigurationChanged(newConfig);

        //DO SOMETHING HERE!! :D
    }
}

实现 1 - 对话框

Dialog dialog = new Dialog(context);
//set up dialog
dialog.setContentView(new MyContentView(context));
dialog.show();

实现 2 - AlertDialog.Builder

AlertDialog.Builder builder = new AlertDialog.Builder(context);
//set up dialog builder
builder.setView(new MyContentView(context));        //Can use this method
builder.setCustomTitle(new MycontentView(context)); // or this method
builder.build().show();

实现 3 - ProgressDialog / AlertDialog

ProgressDialog progress = new ProgressDialog(context);
//set up progress dialog
progress.setView(new MyContentView(context));        //Can use this method
progress.setCustomTitle(new MyContentView(context)); // or this method
progress.show();

Answer 25

这是我遇到这个问题时的解决方案：
ProgressDialog 不是 Fragment 子级，因此我的自定义类“ProgressDialogFragment”可以扩展 DialogFragment 以保留显示配置更改的对话框。

import androidx.annotation.NonNull;
import android.app.Dialog;
import android.app.ProgressDialog;
import android.os.Bundle; 
import androidx.fragment.app.DialogFragment;
import androidx.fragment.app.FragmentManager;

 /**
 * Usage:
 * To display the dialog:
 *     >>> ProgressDialogFragment.showProgressDialogFragment(
 *              getSupportFragmentManager(), 
 *              "fragment_tag", 
 *              "my dialog title", 
 *              "my dialog message");
 *              
 * To hide the dialog
 *     >>> ProgressDialogFragment.hideProgressDialogFragment();
 */ 


public class ProgressDialogFragment extends DialogFragment {

    private static String sTitle, sMessage;
    private static ProgressDialogFragment sProgressDialogFragment;

    public ProgressDialogFragment() {
    }

    private ProgressDialogFragment(String title, String message) {
        sTitle = title;
        sMessage = message;
    }


    @NonNull
    @Override
    public Dialog onCreateDialog(Bundle savedInstanceState) {
        return ProgressDialog.show(getActivity(), sTitle, sMessage);
    }

    public static void showProgressDialogFragment(FragmentManager fragmentManager, String fragmentTag, String title, String message) {
        if (sProgressDialogFragment == null) {
            sProgressDialogFragment = new ProgressDialogFragment(title, message);
            sProgressDialogFragment.show(fragmentManager, fragmentTag);

        } else { // case of config change (device rotation)
            sProgressDialogFragment = (ProgressDialogFragment) fragmentManager.findFragmentByTag(fragmentTag); // sProgressDialogFragment will try to survive its state on configuration as much as it can, but when calling .dismiss() it returns NPE, so we have to reset it on each config change
            sTitle = title;
            sMessage = message;
        }

    }

    public static void hideProgressDialogFragment() {
        if (sProgressDialogFragment != null) {
            sProgressDialogFragment.dismiss();
        }
    }
}

挑战是保留对话框标题和内容。 屏幕显示消息
旋转，因为它们重置为默认的空字符串，尽管对话框仍然显示

有两种方法可以解决此问题：

第一种方法：
让活动利用对话框在清单文件中的配置更改期间保留状态：

android:configChanges="orientation|screenSize|keyboardHidden"

Google 不喜欢这种方法。

第二种方法：
在活动的 onCreate() 方法上，您需要通过使用标题和标题再次重建 ProgressDialogFragment 来保留您的 DialogFragment。 如果 savedInstanceState 不为 null，则消息如下：

@Override
protected void onCreate(Bundle savedInstanceState) {
 super.onCreate(savedInstanceState);
 setContentView(R.layout.activity_deal);

 if (savedInstanceState != null) {
      ProgressDialogFragment saveProgressDialog = (ProgressDialogFragment) getSupportFragmentManager()
              .findFragmentByTag("fragment_tag");
      if (saveProgressDialog != null) {
          showProgressDialogFragment(getSupportFragmentManager(), "fragment_tag", "my dialog title", "my dialog message");
      }
  }
}

Answer 26

似乎太“快速和肮脏”，不可能是真的，所以请指出缺陷，但我发现有效的是......

在我的 AsyncTask 的 onPostExecute 方法中，我只是将进度对话框的“.dismiss”包装在 try/ 中catch 块（带有空 catch），然后简单地忽略引发的异常。 似乎这样做是错误的，但似乎没有任何不良影响（至少对于我随后所做的事情来说，即启动另一个活动，将我长时间运行的查询的结果作为额外传递）

Answer 27

最简单、最灵活的解决方案是使用带有静态引用的 AsyncTask到 ProgressBar。 这为方向改变问题提供了封装且可重复使用的解决方案。 该解决方案非常适合各种异步任务，包括互联网下载、与 服务 通信和文件系统扫描。 该解决方案已在多个 Android 版本和手机型号上经过充分测试。 可以在此处找到完整的演示，特别感兴趣的是DownloadFile.java

我提出以下内容作为一个概念示例，

public class SimpleAsync extends AsyncTask<String, Integer, String> {
    private static ProgressDialog mProgressDialog = null;
    private final Context mContext;

    public SimpleAsync(Context context) {
        mContext = context;
        if ( mProgressDialog != null ) {
            onPreExecute();
        }
    }

    @Override
    protected void onPreExecute() {
        mProgressDialog = new ProgressDialog( mContext );
        mProgressDialog.show();
    }

    @Override
    protected void onPostExecute(String result) {
        if ( mProgressDialog != null ) {
            mProgressDialog.dismiss();
            mProgressDialog = null;
        }
    }

    @Override
    protected void onProgressUpdate(Integer... progress) {
        mProgressDialog.setProgress( progress[0] );
    }

    @Override
    protected String doInBackground(String... sUrl) {
        // Do some work here
        publishProgress(1);
        return null;
    }

    public void dismiss() {
        if ( mProgressDialog != null ) {
            mProgressDialog.dismiss();
        }
    }
}

在 Android Activity 中的使用很简单

public class MainActivity extends Activity {
    DemoServiceClient mClient = null;
    DownloadFile mDownloadFile = null;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate( savedInstanceState );
        setContentView( R.layout.main );
        mDownloadFile = new DownloadFile( this );

        Button downloadButton = (Button) findViewById( R.id.download_file_button );
        downloadButton.setOnClickListener( new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                mDownloadFile.execute( "http://www.textfiles.com/food/bakebred.txt");
            }
        });
    }

    @Override
    public void onPause() {
        super.onPause();
        mDownloadFile.dismiss();
    }
}

Answer 28

当您改变方向时，Android 会终止该 Activity 并创建新的 Activity。
我建议使用 Rx java 进行改造。 哪个手柄会自动崩溃。

当改造调用时使用这些方法。

.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())