Ответ 1

Фрагменты могут сделать это намного проще. Просто используйте метод Fragment.setRetainInstance(boolean), чтобы ваш экземпляр фрагмента сохранялся при изменении конфигурации. Обратите внимание, что это рекомендуемая замена Activity.onRetainnonConfigurationInstance() в документах.

Если по какой-то причине вы действительно не хотите использовать сохраненный фрагмент, есть и другие подходы, которые вы можете предпринять. Обратите внимание, что каждый фрагмент имеет уникальный идентификатор, возвращаемый Fragment.getId(). Вы также можете узнать, срывается ли фрагмент для изменения конфигурации через Fragment.getActivity(). IsChangingConfigurations(). Таким образом, в тот момент, когда вы решили остановить свою AsyncTask (скорее всего, в onStop() или onDestroy()), вы могли бы, например, проверить, изменяется ли конфигурация, и если она вставляет ее в статический SparseArray под идентификатором фрагмента, а затем в вашем onCreate() или onStart() посмотрите, есть ли у вас AsyncTask в разреженном массиве.

Ответ 2

Думаю, вам понравится мой чрезвычайно подробный и рабочий пример, подробно описанный ниже.

• Вращение работает, и диалог сохраняется.
• Вы можете отменить задачу и диалог, нажав кнопку "Назад" (если вам нужно это поведение).
• Он использует фрагменты.
• Макет фрагмента под действием изменяется правильно, когда устройство вращается.
• Существует полная загрузка исходного кода и предварительно скомпилированный APK, чтобы вы могли видеть, является ли поведение тем, что вы хотите.

Изменить

По просьбе Брэда Ларсона я воспроизвел большую часть связанного решения ниже. Кроме того, поскольку я опубликовал его, я указал на AsyncTaskLoader. Я не уверен, что он полностью применим к тем же проблемам, но вы все равно должны его проверить.

Использование AsyncTask с диалоговыми окнами выполнения и вращением устройства.

Рабочее решение!

Наконец-то я получил все, чтобы работать. Мой код имеет следующие функции:

• A Fragment, макет которого меняется с ориентацией.
• An AsyncTask, в котором вы можете выполнить некоторую работу.
• A DialogFragment, который показывает ход выполнения задачи на панели выполнения (а не только неопределенный счетчик).
• Вращение работает без прерывания задачи или отклонения диалога.
• Кнопка "Назад" отклоняет диалог и отменяет задачу (вы можете довольно легко изменить это поведение).

Я не думаю, что комбинацию работоспособности можно найти где-нибудь еще.

Основная идея заключается в следующем. Существует класс MainActivity, который содержит один фрагмент - MainFragment. MainFragment имеет разные макеты для горизонтальной и вертикальной ориентации, а setRetainInstance() - false, так что макет может измениться. Это означает, что при изменении ориентации устройства обе MainActivity и MainFragment полностью уничтожаются и воссоздаются.

В отдельности мы имеем MyTask (расширенный от AsyncTask), который выполняет всю работу. Мы не можем сохранить его в MainFragment, потому что это будет уничтожено, а Google устарел, используя что-либо вроде setRetainNonInstanceConfiguration(). Это не всегда доступно и в лучшем случае является уродливым взломом. Вместо этого мы будем хранить MyTask в другом фрагменте, a DialogFragment называется TaskFragment. Этот фрагмент будет иметь значение setRetainInstance() равным true, так как устройство вращается, этот фрагмент не разрушается, а MyTask сохраняется.

Наконец, нам нужно сообщить TaskFragment, кто должен сообщить, когда он будет завершен, и мы делаем это с помощью setTargetFragment(<the MainFragment>) при его создании. Когда устройство вращается и MainFragment уничтожается, и создается новый экземпляр, мы используем FragmentManager для поиска диалога (на основе его тега) и делаем setTargetFragment(<the new MainFragment>). Это в значительной степени это.

Мне нужно было еще две вещи: сначала отмените задачу при отклонении диалога, а затем установите сообщение об увольнении на null, иначе диалог будет отклонен при повороте устройства.

Код

Я не буду перечислять макеты, они довольно очевидны, и вы можете найти их в проекте ниже.

MainActivity

Это довольно просто. Я добавил обратный вызов в эту операцию, чтобы он знал, когда задача будет завершена, но вам может и не понадобиться. В основном я просто хотел показать механизм обратного вызова фрагментации, потому что он довольно аккуратный, и вы, возможно, раньше его не видели.

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 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 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 настаивал на добавлении библиотеки поддержки, прежде чем она разрешит мне создать проект. Я уверен, что вы можете удалить его.

Ответ 3

Недавно я опубликовал статью, описывающую, как обрабатывать изменения конфигурации, используя сохраненные Fragment s. Он решает проблему сохранения AsyncTask при изменении поворота.

TL, DR должен использовать хост вашего AsyncTask внутри Fragment, вызывать setRetainInstance(true) на Fragment и сообщать о результатах AsyncTask/результатах к нему Activity (или он нацелен Fragment, если вы решите использовать подход, описанный @Timmmm) через сохраненный Fragment.

Ответ 4

Мое первое предложение - избежать внутренних AsyncTasks, вы можете прочитать вопрос, который я задал об этом, и ответы: Android: рекомендации AsyncTask: частный класс или публичный класс?

После этого я начал использовать не-внутренние и... теперь я вижу много преимуществ.

Во-вторых, сохраните ссылку на свою запущенную AsyncTask в классе Application - http://developer.android.com/reference/android/app/Application.html

Каждый раз, когда вы запускаете AsyncTask, устанавливаете его в приложении, а когда он заканчивается, он устанавливает значение null.

Когда начинается фрагмент/активность, вы можете проверить, работает ли какой-либо AsyncTask (проверяя, является ли он нулевым или нет в приложении), а затем установите ссылку внутри на все, что вы хотите (активность, фрагмент и т.д., чтобы вы могли делать обратные вызовы).

Это решит вашу проблему: Если у вас только 1 AsyncTask работает в любое определенное время, вы можете добавить простую ссылку:

AsyncTask<?,?,?> asyncTask = null;

Else, укажите в Aplication a HashMap со ссылками на них.

Диалог прогресса может следовать точному принципу.

Ответ 5

Я придумал метод использования AsyncTaskLoaders для этого. Он довольно прост в использовании и требует меньше служебных IMO..

В основном вы создаете AsyncTaskLoader следующим образом:

public class MyAsyncTaskLoader extends AsyncTaskLoader {
    Result mResult;
    public HttpAsyncTaskLoader(Context context) {
        super(context);
    }

    protected void onStartLoading() {
        super.onStartLoading();
        if (mResult != null) {
            deliverResult(mResult);
        }
        if (takeContentChanged() ||  mResult == null) {
            forceLoad();
        }
    }

    @Override
    public Result loadInBackground() {
        SystemClock.sleep(500);
        mResult = new Result();
        return mResult;
    }
}

Затем в вашей активности, которая использует вышеуказанный AsyncTaskLoader при нажатии кнопки:

public class MyActivityWithBackgroundWork extends FragmentActivity implements LoaderManager.LoaderCallbacks<Result> {

    private String username,password;       
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        // TODO Auto-generated method stub
        super.onCreate(savedInstanceState);
        setContentView(R.layout.mylayout);
        //this is only used to reconnect to the loader if it already started
        //before the orientation changed
        Loader loader = getSupportLoaderManager().getLoader(0);
        if (loader != null) {
            getSupportLoaderManager().initLoader(0, null, this);
        }
    }

    public void doBackgroundWorkOnClick(View button) {
        //might want to disable the button while you are doing work
        //to prevent user from pressing it again.

        //Call resetLoader because calling initLoader will return
        //the previous result if there was one and we may want to do new work
        //each time
        getSupportLoaderManager().resetLoader(0, null, this);
    }   


    @Override
    public Loader<Result> onCreateLoader(int i, Bundle bundle) {
        //might want to start a progress bar
        return new MyAsyncTaskLoader(this);
    }


    @Override
    public void onLoadFinished(Loader<LoginResponse> loginLoader,
                               LoginResponse loginResponse)
    {
        //handle result
    }

    @Override
    public void onLoaderReset(Loader<LoginResponse> responseAndJsonHolderLoader)
    {
        //remove references to previous loader resources

    }
}

Кажется, что обработка изменений ориентации прекрасна, и ваша фоновая задача будет продолжена во время вращения.

Несколько замечаний:

• Если в onCreate вы снова подключаетесь к asynctaskloader, вы получите обратный вызов onLoadFinished() с предыдущим результатом (даже если вам уже сказали, что запрос был завершен). Это на самом деле хорошее поведение большую часть времени, но иногда это может быть сложно справиться. Хотя я предполагаю, что есть много способов справиться с этим, что я сделал, я назвал loader.abandon() в onLoadFinished. Затем я добавил чек в onCreate, чтобы снова подключиться к загрузчику, если он еще не был оставлен. Если вам нужны результирующие данные снова, вы не захотите этого делать. В большинстве случаев вам нужны данные.

У меня есть более подробная информация об использовании этого для http-вызовов здесь

Ответ 6

Я создал очень крошечную библиотеку фоновых задач с открытым исходным кодом, которая в значительной степени основана на Marshmallow AsyncTask, но с дополнительными функциями, такими как:

• Автоматическое сохранение задач при изменении конфигурации;
• обратный вызов пользовательского интерфейса (слушатели);
• Не перезапускает или отменяет задачу, когда устройство вращается (например, Loaders),

Библиотека внутренне использует Fragment без какого-либо пользовательского интерфейса, который сохраняется при изменении конфигурации (setRetainInstance(true)).

Вы можете найти его на GitHub: https://github.com/NeoTech-Software/Android-Retainable-Tasks

Самый простой пример (версия 0.2.0):

Этот пример полностью сохраняет задачу, используя очень ограниченный объем кода.

Задача:

private class ExampleTask extends Task<Integer, String> {

    public ExampleTask(String tag){
        super(tag);
    }

    protected String doInBackground() {
        for(int i = 0; i < 100; i++) {
            if(isCancelled()){
                break;
            }
            SystemClock.sleep(50);
            publishProgress(i);
        }
        return "Result";
    }
}

Активность:

public class Main extends TaskActivityCompat implements Task.Callback {

    @Override
    public void onClick(View view){
        ExampleTask task = new ExampleTask("activity-unique-tag");
        getTaskManager().execute(task, this);
    }

    @Override
    public Task.Callback onPreAttach(Task<?, ?> task) {
        //Restore the user-interface based on the tasks state
        return this; //This Activity implements Task.Callback
    }

    @Override
    public void onPreExecute(Task<?, ?> task) {
        //Task started
    }

    @Override
    public void onPostExecute(Task<?, ?> task) {
        //Task finished
        Toast.makeText(this, "Task finished", Toast.LENGTH_SHORT).show();
    }
}

Ответ 7

Мой подход заключается в использовании шаблона проектирования делегирования, в общем, мы можем изолировать фактическую бизнес-логику (считывать данные из Интернета или базы данных или вообще) от AsyncTask (делегата) до BusinessDAO (делегата) в вашем AysncTask.doInBackground(), делегировать фактическую задачу в BusinessDAO, а затем реализовать механизм одноэлементного процесса в BusinessDAO, так что множественный вызов BusinessDAO.doSomething() просто вызовет запуск одной актуальной задачи каждый раз и ждет результата задачи. Идея заключается в том, чтобы сохранить делегат (т.е. BusinessDAO) во время изменения конфигурации вместо делегирования (то есть AsyncTask).

• Создайте/выполните наше собственное приложение, целью которого является создание/инициализация BusinessDAO здесь, так что наш жизненный цикл BusinessDAO будет областью применения, а не областью действия, обратите внимание, что вам нужно изменить AndroidManifest.xml для использования MyApplication:

  public class MyApplication extends android.app.Application {
    private BusinessDAO businessDAO;
  
    @Override
    public void onCreate() {
      super.onCreate();
      businessDAO = new BusinessDAO();
    }
  
    pubilc BusinessDAO getBusinessDAO() {
      return businessDAO;
    }
  
  }
  

• Наша существующая Activity/Fragement в основном не изменилась, по-прежнему реализует AsyncTask как внутренний класс и включает AsyncTask.execute() из Activity/Fragement, теперь разница заключается в том, что AsyncTask делегирует фактическую задачу BusinessDAO, поэтому во время изменение конфигурации, второй AsyncTask будет инициализирован и выполнен и вызовет BusinessDAO.doSomething() второй раз, однако второй вызов BusinessDAO.doSomething() не приведет к запуску новой запущенной задачи, вместо этого ожидает завершения текущей текущей задачи:

  public class LoginFragment extends Fragment {
    ... ...
  
    public class LoginAsyncTask extends AsyncTask<String, Void, Boolean> {
      // get a reference of BusinessDAO from application scope.
      BusinessDAO businessDAO = ((MyApplication) getApplication()).getBusinessDAO();
  
      @Override
      protected Boolean doInBackground(String... args) {
          businessDAO.doSomething();
          return true;
      }
  
      protected void onPostExecute(Boolean result) {
        //Handle task result and update UI stuff.
      }
    }
  
    ... ...
  }
  

• Внутри BusinessDAO реализуется механизм одноэлементного процесса, например:

  public class BusinessDAO {
    ExecutorCompletionService<MyTask> completionExecutor = new ExecutorCompletionService<MyTask(Executors.newFixedThreadPool(1));
    Future<MyTask> myFutureTask = null;
  
    public void doSomething() {
      if (myFutureTask == null) {
        // nothing running at the moment, submit a new callable task to run.
        MyTask myTask = new MyTask();
        myFutureTask = completionExecutor.submit(myTask);
      }
      // Task already submitted and running, waiting for the running task to finish.
      myFutureTask.get();
    }
  
    // If you've never used this before, Callable is similar with Runnable, with ability to return result and throw exception.
    private class MyTask extends Callable<MyTask> {
      public MyAsyncTask call() {
        // do your job here.
        return this;
      }
    }
  
  }
  

Я не уверен на 100%, если это будет работать, более того, фрагмент кода примера следует рассматривать как псевдокод. Я просто пытаюсь дать вам подсказку с уровня дизайна. Любые отзывы или предложения приветствуются и оцениваются.

Ответ 8

Если кто-то найдет свой путь к этому потоку, я обнаружил, что чистый подход состоял в том, чтобы запустить задачу Async из app.Service (началось с START_STICKY), а затем повторить повторение итерации по работающим службам, чтобы выяснить, является ли служба (и следовательно асинхронная задача) все еще работает;

    public boolean isServiceRunning(String serviceClassName) {
    final ActivityManager activityManager = (ActivityManager) Application.getContext().getSystemService(Context.ACTIVITY_SERVICE);
    final List<RunningServiceInfo> services = activityManager.getRunningServices(Integer.MAX_VALUE);

    for (RunningServiceInfo runningServiceInfo : services) {
        if (runningServiceInfo.service.getClassName().equals(serviceClassName)){
            return true;
        }
    }
    return false;
 }

Если это так, повторно добавьте DialogFragment (или что-то еще), и если это не гарантирует, что диалог был уволен.

Это особенно уместно, если вы используете библиотеки v4.support.* с тех пор (на момент написания), они знают проблемы с методом setRetainInstance и просмотр подкачки. Кроме того, не сохраняя экземпляр, в котором вы можете воссоздать свою деятельность, используя другой набор ресурсов (т.е. другой макет представления для новой ориентации)

Ответ 9

Вы можете сделать AsyncTask статическим полем. Если вам нужен контекст, вы должны отправить свой контекст приложения. Это позволит избежать утечек памяти, иначе вы сохраните ссылку на всю свою деятельность.

Ответ 10

Я пишу код samepl для решения этой проблемы

Первым шагом является класс Application:

public class TheApp extends Application {

private static TheApp sTheApp;
private HashMap<String, AsyncTask<?,?,?>> tasks = new HashMap<String, AsyncTask<?,?,?>>();

@Override
public void onCreate() {
    super.onCreate();
    sTheApp = this;
}

public static TheApp get() {
    return sTheApp;
}

public void registerTask(String tag, AsyncTask<?,?,?> task) {
    tasks.put(tag, task);
}

public void unregisterTask(String tag) {
    tasks.remove(tag);
}

public AsyncTask<?,?,?> getTask(String tag) {
    return tasks.get(tag);
}
}

В AndroidManifest.xml

<application
        android:allowBackup="true"
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/AppTheme"
        android:name="com.example.tasktest.TheApp">

Код в действии:

public class MainActivity extends Activity {

private Task1 mTask1;

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

    mTask1 = (Task1)TheApp.get().getTask("task1");

}

/*
 * start task is not running jet
 */
public void handletask1(View v) {
    if (mTask1 == null) {
        mTask1 = new Task1();
        TheApp.get().registerTask("task1", mTask1);
        mTask1.execute();
    } else
        Toast.makeText(this, "Task is running...", Toast.LENGTH_SHORT).show();

}

/*
 * cancel task if is not finished
 */
public void handelCancel(View v) {
    if (mTask1 != null)
        mTask1.cancel(false);
}

public class Task1 extends AsyncTask<Void, Void, Void>{

    @Override
    protected Void doInBackground(Void... params) {
        try {
            for(int i=0; i<120; i++) {
                Thread.sleep(1000);
                Log.i("tests", "loop=" + i);
                if (this.isCancelled()) {
                    Log.e("tests", "tssk cancelled");
                    break;
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return null;
    }

    @Override
    protected void onCancelled(Void result) {
        TheApp.get().unregisterTask("task1");
        mTask1 = null;
    }

    @Override
    protected void onPostExecute(Void result) {
        TheApp.get().unregisterTask("task1");
        mTask1 = null;
    }
}

}

При изменении ориентации активности переменная mTask вводится из контекста приложения. Когда задача закончена, переменная устанавливается в значение null и удаляется из памяти.

Для меня это достаточно.

Ответ 11

Посмотрите ниже пример, как использовать сохраненный фрагмент для сохранения фоновой задачи:

public class NetworkRequestFragment extends Fragment {

    // Declare some sort of interface that your AsyncTask will use to communicate with the Activity
    public interface NetworkRequestListener {
        void onRequestStarted();
        void onRequestProgressUpdate(int progress);
        void onRequestFinished(SomeObject result);
    }

    private NetworkTask mTask;
    private NetworkRequestListener mListener;

    private SomeObject mResult;

    @Override
    public void onAttach(Activity activity) {
        super.onAttach(activity);

        // Try to use the Activity as a listener
        if (activity instanceof NetworkRequestListener) {
            mListener = (NetworkRequestListener) activity;
        } else {
            // You can decide if you want to mandate that the Activity implements your callback interface
            // in which case you should throw an exception if it doesn't:
            throw new IllegalStateException("Parent activity must implement NetworkRequestListener");
            // or you could just swallow it and allow a state where nobody is listening
        }
    }

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

        // Retain this Fragment so that it will not be destroyed when an orientation
        // change happens and we can keep our AsyncTask running
        setRetainInstance(true);
    }

    /**
     * The Activity can call this when it wants to start the task
     */
    public void startTask(String url) {
        mTask = new NetworkTask(url);
        mTask.execute();
    }

    @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        // If the AsyncTask finished when we didn't have a listener we can
        // deliver the result here
        if ((mResult != null) && (mListener != null)) {
            mListener.onRequestFinished(mResult);
            mResult = null;
        }
    }

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

        // We still have to cancel the task in onDestroy because if the user exits the app or
        // finishes the Activity, we don't want the task to keep running
        // Since we are retaining the Fragment, onDestroy won't be called for an orientation change
        // so this won't affect our ability to keep the task running when the user rotates the device
        if ((mTask != null) && (mTask.getStatus == AsyncTask.Status.RUNNING)) {
            mTask.cancel(true);
        }
    }

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

        // This is VERY important to avoid a memory leak (because mListener is really a reference to an Activity)
        // When the orientation change occurs, onDetach will be called and since the Activity is being destroyed
        // we don't want to keep any references to it
        // When the Activity is being re-created, onAttach will be called and we will get our listener back
        mListener = null;
    }

    private class NetworkTask extends AsyncTask<String, Integer, SomeObject> {

        @Override
        protected void onPreExecute() {
            if (mListener != null) {
                mListener.onRequestStarted();
            }
        }

        @Override
        protected SomeObject doInBackground(String... urls) {
           // Make the network request
           ...
           // Whenever we want to update our progress:
           publishProgress(progress);
           ...
           return result;
        }

        @Override
        protected void onProgressUpdate(Integer... progress) {
            if (mListener != null) {
                mListener.onRequestProgressUpdate(progress[0]);
            }
        }

        @Override
        protected void onPostExecute(SomeObject result) {
            if (mListener != null) {
                mListener.onRequestFinished(result);
            } else {
                // If the task finishes while the orientation change is happening and while
                // the Fragment is not attached to an Activity, our mListener might be null
                // If you need to make sure that the result eventually gets to the Activity
                // you could save the result here, then in onActivityCreated you can pass it back
                // to the Activity
                mResult = result;
            }
        }

    }
}

Ответ 12

Посмотрите здесь.

Существует решение, основанное на решении Тиммама.

Но я улучшил его:

• Теперь решение расширяется - вам нужно только расширить FragmentAbleToStartTask

• Вы можете одновременно выполнять несколько задач.

  И по-моему это так же просто, как startActivityForResult и получить результат

• Вы также можете остановить запущенную задачу и проверить, работает ли конкретная задача.

Извините за мой английский