아래에 자세히 설명 된 매우 포괄적이고 실제적인 예제를 즐길 수있을 것입니다.

1. 회전이 작동하고 대화가 유지됩니다.
2. 뒤로 버튼을 눌러 작업 및 대화 상자를 취소 할 수 있습니다 (이 동작을 원할 경우).
3. 조각을 사용합니다.
4. 활동 아래에있는 조각의 레이아웃은 장치가 회전 할 때 올바르게 변경됩니다.
5. 완전한 소스 코드 다운로드와 사전 컴파일 된 APK가 있으므로 원하는 동작인지 확인할 수 있습니다.

편집하다

Brad Larson의 요청에 따라 아래 링크 된 솔루션의 대부분을 재현했습니다. 또한 게시 한 이후로 지적되었습니다 AsyncTaskLoader. 동일한 문제에 완전히 적용 할 수 있을지 모르겠지만 어쨌든 확인해야합니다.

사용 AsyncTask진행률 대화 상자 및 장치 회전과 함께 .

작동하는 솔루션!

드디어 일할 모든 것을 얻었습니다. 내 코드에는 다음과 같은 기능이 있습니다.

1. ㅏ Fragment방향에 따라 레이아웃이 변경되는 입니다.
2. 안 AsyncTask 을 할 수있는 곳.
3. ㅏ DialogFragment진행률 표시 줄에서 작업의 진행 (다만 불확실한 회)를 표시한다.
4. 회전은 작업을 중단하거나 대화 상자를 닫지 않고 작동합니다.
5. 뒤로 버튼은 대화 상자를 닫고 작업을 취소합니다 (이 동작은 매우 쉽게 변경할 수 있음).

일 함의 조합은 다른 곳에서는 찾을 수 없다고 생각합니다.

기본 아이디어는 다음과 같습니다. MainActivity단일 조각을 포함 하는 클래스가 있습니다 MainFragment. MainFragment가로 및 세로 방향에 대한 레이아웃이 다르며 레이아웃 setRetainInstance()이 변경 될 수 있도록 false입니다. 즉, 장치 방향이 변경되면 MainActivity및MainFragment 완전히 파괴되고 다시 생성됩니다.

별도로 모든 작업을 수행하는 MyTask(에서 확장 AsyncTask)이 있습니다. 그것은 MainFragment파괴 될 것이기 때문에 우리는 그것을 저장할 수 없으며 Google은 setRetainNonInstanceConfiguration(). 어쨌든 항상 사용할 수있는 것은 아니며 기껏해야 추악한 해킹입니다. 대신 라는 MyTask다른 조각에 저장 합니다. 이 단편 것이다 한 참으로 설정되므로 장치의 회전으로이 단편은 파괴되지 않고,DialogFragmentTaskFragmentsetRetainInstance()MyTask 유지된다.

마지막으로 우리 TaskFragment는 그것이 끝났을 때 누구에게 알릴 것인지를 알려줄 필요 setTargetFragment(<the MainFragment>)가 있습니다. 그리고 우리는 그것을 만들 때 그것을 사용하여 그렇게 합니다. 장치가 회전되고 MainFragment가 파괴되고 새 인스턴스가 생성되면을 사용 FragmentManager하여 대화 상자 (태그 기반)를 찾고setTargetFragment(<the new MainFragment>) . 그게 다야.

다른 두 가지 작업이 필요했습니다. 먼저 대화 상자가 닫힐 때 작업을 취소하고 두 번째로 닫기 메시지를 null로 설정합니다. 그렇지 않으면 장치가 회전 할 때 대화 상자가 이상하게 닫힙니다.

코드

나는 레이아웃을 나열하지 않을 것입니다. 그들은 매우 분명하며 아래 프로젝트 다운로드에서 찾을 수 있습니다.

주요 활동

이것은 매우 간단합니다. 이 활동에 콜백을 추가하여 작업이 언제 완료되는지 알 수 있지만 필요하지 않을 수도 있습니다. 주로 단편 활동 콜백 메커니즘을 보여주고 싶었습니다. 매우 깔끔하고 이전에는 보지 못했을 수도 있기 때문입니다.

public class MainActivity extends Activity implements MainFragment.Callbacks
{
    @Override
    public void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
    @Override
    public void onTaskFinished()
    {
        // Hooray. A toast to our success.
        Toast.makeText(this, "Task finished!", Toast.LENGTH_LONG).show();
        // NB: I'm going to blow your mind again: the "int duration" parameter of makeText *isn't*
        // the duration in milliseconds. ANDROID Y U NO ENUM? 
    }
}

MainFragment

길지만 그만한 가치가 있습니다!

public class MainFragment extends Fragment implements OnClickListener
{
    // This code up to onDetach() is all to get easy callbacks to the Activity. 
    private Callbacks mCallbacks = sDummyCallbacks;

    public interface Callbacks
    {
        public void onTaskFinished();
    }
    private static Callbacks sDummyCallbacks = new Callbacks()
    {
        public void onTaskFinished() { }
    };

    @Override
    public void onAttach(Activity activity)
    {
        super.onAttach(activity);
        if (!(activity instanceof Callbacks))
        {
            throw new IllegalStateException("Activity must implement fragment's callbacks.");
        }
        mCallbacks = (Callbacks) activity;
    }

    @Override
    public void onDetach()
    {
        super.onDetach();
        mCallbacks = sDummyCallbacks;
    }

    // Save a reference to the fragment manager. This is initialised in onCreate().
    private FragmentManager mFM;

    // Code to identify the fragment that is calling onActivityResult(). We don't really need
    // this since we only have one fragment to deal with.
    static final int TASK_FRAGMENT = 0;

    // Tag so we can find the task fragment again, in another instance of this fragment after rotation.
    static final String TASK_FRAGMENT_TAG = "task";

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

        // At this point the fragment may have been recreated due to a rotation,
        // and there may be a TaskFragment lying around. So see if we can find it.
        mFM = getFragmentManager();
        // Check to see if we have retained the worker fragment.
        TaskFragment taskFragment = (TaskFragment)mFM.findFragmentByTag(TASK_FRAGMENT_TAG);

        if (taskFragment != null)
        {
            // Update the target fragment so it goes to this fragment instead of the old one.
            // This will also allow the GC to reclaim the old MainFragment, which the TaskFragment
            // keeps a reference to. Note that I looked in the code and setTargetFragment() doesn't
            // use weak references. To be sure you aren't leaking, you may wish to make your own
            // setTargetFragment() which does.
            taskFragment.setTargetFragment(this, TASK_FRAGMENT);
        }
    }

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
            Bundle savedInstanceState)
    {
        return inflater.inflate(R.layout.fragment_main, container, false);
    }

    @Override
    public void onViewCreated(View view, Bundle savedInstanceState)
    {
        super.onViewCreated(view, savedInstanceState);

        // Callback for the "start task" button. I originally used the XML onClick()
        // but it goes to the Activity instead.
        view.findViewById(R.id.taskButton).setOnClickListener(this);
    }

    @Override
    public void onClick(View v)
    {
        // We only have one click listener so we know it is the "Start Task" button.

        // We will create a new TaskFragment.
        TaskFragment taskFragment = new TaskFragment();
        // And create a task for it to monitor. In this implementation the taskFragment
        // executes the task, but you could change it so that it is started here.
        taskFragment.setTask(new MyTask());
        // And tell it to call onActivityResult() on this fragment.
        taskFragment.setTargetFragment(this, TASK_FRAGMENT);

        // Show the fragment.
        // I'm not sure which of the following two lines is best to use but this one works well.
        taskFragment.show(mFM, TASK_FRAGMENT_TAG);
//      mFM.beginTransaction().add(taskFragment, TASK_FRAGMENT_TAG).commit();
    }

    @Override
    public void onActivityResult(int requestCode, int resultCode, Intent data)
    {
        if (requestCode == TASK_FRAGMENT && resultCode == Activity.RESULT_OK)
        {
            // Inform the activity. 
            mCallbacks.onTaskFinished();
        }
    }

TaskFragment

    // This and the other inner class can be in separate files if you like.
    // There's no reason they need to be inner classes other than keeping everything together.
    public static class TaskFragment extends DialogFragment
    {
        // The task we are running.
        MyTask mTask;
        ProgressBar mProgressBar;

        public void setTask(MyTask task)
        {
            mTask = task;

            // Tell the AsyncTask to call updateProgress() and taskFinished() on this fragment.
            mTask.setFragment(this);
        }

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

            // Retain this instance so it isn't destroyed when MainActivity and
            // MainFragment change configuration.
            setRetainInstance(true);

            // Start the task! You could move this outside this activity if you want.
            if (mTask != null)
                mTask.execute();
        }

        @Override
        public View onCreateView(LayoutInflater inflater, ViewGroup container,
                Bundle savedInstanceState)
        {
            View view = inflater.inflate(R.layout.fragment_task, container);
            mProgressBar = (ProgressBar)view.findViewById(R.id.progressBar);

            getDialog().setTitle("Progress Dialog");

            // If you're doing a long task, you probably don't want people to cancel
            // it just by tapping the screen!
            getDialog().setCanceledOnTouchOutside(false);

            return view;
        }

        // This is to work around what is apparently a bug. If you don't have it
        // here the dialog will be dismissed on rotation, so tell it not to dismiss.
        @Override
        public void onDestroyView()
        {
            if (getDialog() != null && getRetainInstance())
                getDialog().setDismissMessage(null);
            super.onDestroyView();
        }

        // Also when we are dismissed we need to cancel the task.
        @Override
        public void onDismiss(DialogInterface dialog)
        {
            super.onDismiss(dialog);
            // If true, the thread is interrupted immediately, which may do bad things.
            // If false, it guarantees a result is never returned (onPostExecute() isn't called)
            // but you have to repeatedly call isCancelled() in your doInBackground()
            // function to check if it should exit. For some tasks that might not be feasible.
            if (mTask != null) {
                mTask.cancel(false);
            }

            // You don't really need this if you don't want.
            if (getTargetFragment() != null)
                getTargetFragment().onActivityResult(TASK_FRAGMENT, Activity.RESULT_CANCELED, null);
        }

        @Override
        public void onResume()
        {
            super.onResume();
            // This is a little hacky, but we will see if the task has finished while we weren't
            // in this activity, and then we can dismiss ourselves.
            if (mTask == null)
                dismiss();
        }

        // This is called by the AsyncTask.
        public void updateProgress(int percent)
        {
            mProgressBar.setProgress(percent);
        }

        // This is also called by the AsyncTask.
        public void taskFinished()
        {
            // Make sure we check if it is resumed because we will crash if trying to dismiss the dialog
            // after the user has switched to another app.
            if (isResumed())
                dismiss();

            // If we aren't resumed, setting the task to null will allow us to dimiss ourselves in
            // onResume().
            mTask = null;

            // Tell the fragment that we are done.
            if (getTargetFragment() != null)
                getTargetFragment().onActivityResult(TASK_FRAGMENT, Activity.RESULT_OK, null);
        }
    }

MyTask

    // This is a fairly standard AsyncTask that does some dummy work.
    public static class MyTask extends AsyncTask<Void, Void, Void>
    {
        TaskFragment mFragment;
        int mProgress = 0;

        void setFragment(TaskFragment fragment)
        {
            mFragment = fragment;
        }

        @Override
        protected Void doInBackground(Void... params)
        {
            // Do some longish task. This should be a task that we don't really
            // care about continuing
            // if the user exits the app.
            // Examples of these things:
            // * Logging in to an app.
            // * Downloading something for the user to view.
            // * Calculating something for the user to view.
            // Examples of where you should probably use a service instead:
            // * Downloading files for the user to save (like the browser does).
            // * Sending messages to people.
            // * Uploading data to a server.
            for (int i = 0; i < 10; i++)
            {
                // Check if this has been cancelled, e.g. when the dialog is dismissed.
                if (isCancelled())
                    return null;

                SystemClock.sleep(500);
                mProgress = i * 10;
                publishProgress();
            }
            return null;
        }

        @Override
        protected void onProgressUpdate(Void... unused)
        {
            if (mFragment == null)
                return;
            mFragment.updateProgress(mProgress);
        }

        @Override
        protected void onPostExecute(Void unused)
        {
            if (mFragment == null)
                return;
            mFragment.taskFinished();
        }
    }
}

예제 프로젝트 다운로드

다음은 소스 코드 와 APK 입니다. 죄송합니다. ADT는 제가 프로젝트를 만들 수 있기 전에 지원 라이브러리를 추가해야한다고 주장했습니다. 제거 할 수 있다고 확신합니다.