Como lidar com uma AsyncTask durante a rotação da tela?

Eu li muito sobre como salvar meu estado de instância ou como lidar com minha atividade sendo destruída durante a rotação da tela.

Parece haver muitas possibilidades, mas ainda não descobri qual funciona melhor para recuperar os resultados de uma AsyncTask.

Eu tenho alguns AsyncTasks que são simplesmente iniciados novamente e chamam o isFinishing()método da atividade e se a atividade estiver terminando eles não atualizarão nada.

O problema é que tenho uma tarefa que faz uma solicitação a um serviço da web que pode falhar ou ter sucesso e reiniciar a tarefa resultaria em perda financeira para o usuário.

Como você resolveria isso? Quais são as vantagens ou desvantagens das soluções possíveis?

Minha primeira sugestão seria ter certeza de que você realmente precisa que sua atividade seja redefinida em uma rotação de tela (o comportamento padrão). Sempre que tive problemas com a rotação, adicionei esse atributo à minha <activity>tag no AndroidManifest.xml e estava tudo bem.

android:configChanges="keyboardHidden|orientation"

Parece estranho, mas o que ele faz é passar para o seu onConfigurationChanged()método, se você não fornecer um ele não faz nada além de medir novamente o layout, o que parece ser uma forma perfeitamente adequada de lidar com o giro na maioria das vezes .

Você pode verificar como eu lidoAsyncTask com mudanças de orientação em code.google.com/p/shelves . Existem várias maneiras de fazer isso, a que escolhi neste aplicativo é cancelar qualquer tarefa em execução no momento, salvar seu estado e iniciar uma nova com o estado salvo quando a nova Activityfor criada. É fácil de fazer, funciona bem e, como bônus, cuida de interromper suas tarefas quando o usuário sai do aplicativo.

Você também pode usar onRetainNonConfigurationInstance()para passar seu AsyncTaskpara o novo Activity(no Activityentanto, tome cuidado para não vazar o anterior dessa forma.)

Essa é a pergunta mais interessante que já vi em relação ao Android !!! Na verdade, já estou procurando a solução nos últimos meses. Ainda não resolvi.

Tenha cuidado, simplesmente substituindo o

android:configChanges="keyboardHidden|orientation"

coisas não são suficientes.

Considere o caso em que o usuário recebe uma chamada telefônica enquanto o AsyncTask está em execução. Sua solicitação já está sendo processada pelo servidor, portanto, AsyncTask está aguardando resposta. Nesse momento, seu aplicativo entra em segundo plano, pois o aplicativo Telefone acaba de entrar em primeiro plano. OS pode matar sua atividade, pois está em segundo plano.

Por que você não sempre mantém uma referência à AsyncTask atual no Singleton fornecido pelo Android?

Sempre que uma tarefa é iniciada, no PreExecute ou no construtor, você define:

((Application) getApplication()).setCurrentTask(asyncTask);

Sempre que terminar, você o define como nulo.

Dessa forma, você sempre tem uma referência que permite fazer algo como onCreate ou onResume conforme apropriado para sua lógica específica:

this.asyncTaskReference = ((Application) getApplication()).getCurrentTask();

Se for null, você sabe que não há nenhum em execução no momento!

:-)

A maneira mais adequada de fazer isso é usar um fragmento para reter a instância da tarefa assíncrona, em rotações.

Aqui está um link para um exemplo muito simples, tornando mais fácil acompanhar a integração dessa técnica em seus aplicativos.

https://gist.github.com/daichan4649/2480065

Em Pro android 4. autor sugeriu uma maneira legal, que você deveria usar weak reference.

Nota de referência fraca

No meu ponto de vista, é melhor armazenar asynctask onRetainNonConfigurationInstancedesacoplando-o do objeto Activity atual e ligando-o a um novo objeto Activity após a mudança de orientação. Aqui encontrei um exemplo muito bom de como trabalhar com AsyncTask e ProgressDialog.

Android: processamento em segundo plano / operação assíncrona com alteração de configuração

Para manter os estados de operação assíncrona durante o processo em segundo plano: você pode obter a ajuda de fragmentos.

Veja as seguintes etapas:

Etapa 1: crie um fragmento sem cabeçalho, digamos, tarefa em segundo plano e adicione uma classe de tarefa assíncrona privada com ele.

Etapa 2 (etapa opcional): se você deseja colocar um cursor de carregamento no topo de sua atividade, use o código abaixo:

Etapa 3: em sua atividade principal, implemente a interface BackgroundTaskCallbacks definida na etapa 1

class BackgroundTask extends Fragment {
public BackgroundTask() {

}

// Add a static interface 

static interface BackgroundTaskCallbacks {
    void onPreExecute();

    void onCancelled();

    void onPostExecute();

    void doInBackground();
}

private BackgroundTaskCallbacks callbacks;
private PerformAsyncOpeation asyncOperation;
private boolean isRunning;
private final String TAG = BackgroundTask.class.getSimpleName();

/**
 * Start the async operation.
 */
public void start() {
    Log.d(TAG, "********* BACKGROUND TASK START OPERATION ENTER *********");
    if (!isRunning) {
        asyncOperation = new PerformAsyncOpeation();
        asyncOperation.execute();
        isRunning = true;
    }
    Log.d(TAG, "********* BACKGROUND TASK START OPERATION EXIT *********");
}

/**
 * Cancel the background task.
 */
public void cancel() {
    Log.d(TAG, "********* BACKGROUND TASK CANCEL OPERATION ENTER *********");
    if (isRunning) {
        asyncOperation.cancel(false);
        asyncOperation = null;
        isRunning = false;
    }
    Log.d(TAG, "********* BACKGROUND TASK CANCEL OPERATION EXIT *********");
}

/**
 * Returns the current state of the background task.
 */
public boolean isRunning() {
    return isRunning;
}

/**
 * Android passes us a reference to the newly created Activity by calling
 * this method after each configuration change.
 */
public void onAttach(Activity activity) {
    Log.d(TAG, "********* BACKGROUND TASK ON ATTACH ENTER *********");
    super.onAttach(activity);
    if (!(activity instanceof BackgroundTaskCallbacks)) {
        throw new IllegalStateException(
                "Activity must implement the LoginCallbacks interface.");
    }

    // Hold a reference to the parent Activity so we can report back the
    // task's
    // current progress and results.
    callbacks = (BackgroundTaskCallbacks) activity;
    Log.d(TAG, "********* BACKGROUND TASK ON ATTACH EXIT *********");
}

public void onCreate(Bundle savedInstanceState) {
    Log.d(TAG, "********* BACKGROUND TASK ON CREATE ENTER *********");
    super.onCreate(savedInstanceState);
    // Retain this fragment across configuration changes.
    setRetainInstance(true);
    Log.d(TAG, "********* BACKGROUND TASK ON CREATE EXIT *********");
}

public void onDetach() {
    super.onDetach();
    callbacks = null;
}

private class PerformAsyncOpeation extends AsyncTask<Void, Void, Void> {
    protected void onPreExecute() {
        Log.d(TAG,
                "********* BACKGROUND TASK :-> ASYNC OPERATION :- > ON PRE EXECUTE ENTER *********");
        if (callbacks != null) {
            callbacks.onPreExecute();
        }
        isRunning = true;
        Log.d(TAG,
                "********* BACKGROUND TASK :-> ASYNC OPERATION :- > ON PRE EXECUTE EXIT *********");
    }

    protected Void doInBackground(Void... params) {
        Log.d(TAG,
                "********* BACKGROUND TASK :-> ASYNC OPERATION :- > DO IN BACKGROUND ENTER *********");
        if (callbacks != null) {
            callbacks.doInBackground();
        }
        Log.d(TAG,
                "********* BACKGROUND TASK :-> ASYNC OPERATION :- > DO IN BACKGROUND EXIT *********");
        return null;
    }

    protected void onCancelled() {
        Log.d(TAG,
                "********* BACKGROUND TASK :-> ASYNC OPERATION :- > ON CANCEL ENTER *********");
        if (callbacks != null) {
            callbacks.onCancelled();
        }
        isRunning = false;
        Log.d(TAG,
                "********* BACKGROUND TASK :-> ASYNC OPERATION :- > ON CANCEL EXIT *********");
    }

    protected void onPostExecute(Void ignore) {
        Log.d(TAG,
                "********* BACKGROUND TASK :-> ASYNC OPERATION :- > ON POST EXECUTE ENTER *********");
        if (callbacks != null) {
            callbacks.onPostExecute();
        }
        isRunning = false;
        Log.d(TAG,
                "********* BACKGROUND TASK :-> ASYNC OPERATION :- > ON POST EXECUTE EXIT *********");
    }
}

public void onActivityCreated(Bundle savedInstanceState) {
    super.onActivityCreated(savedInstanceState);
    setRetainInstance(true);
}

public void onStart() {
    super.onStart();
}

public void onResume() {
    super.onResume();
}

public void onPause() {
    super.onPause();
}

public void onStop() {
    super.onStop();
}

public class ProgressIndicator extends Dialog {

public ProgressIndicator(Context context, int theme) {
    super(context, theme);
}

private ProgressBar progressBar;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    requestWindowFeature(Window.FEATURE_NO_TITLE);
    setContentView(R.layout.progress_indicator);
    this.setCancelable(false);
    progressBar = (ProgressBar) findViewById(R.id.progressBar);
    progressBar.getIndeterminateDrawable().setColorFilter(R.color.DarkBlue, android.graphics.PorterDuff.Mode.SCREEN);
}

@Override
public void show() {
    super.show();
}

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

@Override
public void cancel() {
    super.cancel();
}

public class MyActivity extends FragmentActivity implements BackgroundTaskCallbacks,{

private static final String KEY_CURRENT_PROGRESS = "current_progress";

ProgressIndicator progressIndicator = null;

private final static String TAG = MyActivity.class.getSimpleName();

private BackgroundTask task = null;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(//"set your layout here");
    initialize your views and widget here .............



    FragmentManager fm = getSupportFragmentManager();
    task = (BackgroundTask) fm.findFragmentByTag("login");

    // If the Fragment is non-null, then it is currently being
    // retained across a configuration change.
    if (task == null) {
        task = new BackgroundTask();
        fm.beginTransaction().add(task, "login").commit();
    }

    // Restore saved state
    if (savedInstanceState != null) {
        Log.i(TAG, "KEY_CURRENT_PROGRESS_VALUE ON CREATE :: "
                + task.isRunning());
        if (task.isRunning()) {
            progressIndicator = new ProgressIndicator(this,
                    R.style.TransparentDialog);
            if (progressIndicator != null) {
                progressIndicator.show();
            }
        }
    }
}

@Override
protected void onPause() {
    // TODO Auto-generated method stub
    super.onPause();

}

@Override
protected void onSaveInstanceState(Bundle outState) {
    // save the current state of your operation here by saying this 

    super.onSaveInstanceState(outState);
    Log.i(TAG, "KEY_CURRENT_PROGRESS_VALUE ON SAVE INSTANCE :: "
            + task.isRunning());
    outState.putBoolean(KEY_CURRENT_PROGRESS, task.isRunning());
    if (progressIndicator != null) {
        progressIndicator.dismiss();
        progressIndicator.cancel();
    }
    progressIndicator = null;
}


private void performOperation() {

            if (!task.isRunning() && progressIndicator == null) {
                progressIndicator = new ProgressIndicator(this,
                        R.style.TransparentDialog);
                progressIndicator.show();
            }
            if (task.isRunning()) {
                task.cancel();
            } else {
                task.start();
            }
        }


@Override
protected void onDestroy() {
    super.onDestroy();
    if (progressIndicator != null) {
        progressIndicator.dismiss();
        progressIndicator.cancel();
    }
    progressIndicator = null;
}

@Override
public void onPreExecute() {
    Log.i(TAG, "CALLING ON PRE EXECUTE");
}

@Override
public void onCancelled() {
    Log.i(TAG, "CALLING ON CANCELLED");
    if (progressIndicator != null) {
        progressIndicator.dismiss();
        progressIndicator.cancel();

}

public void onPostExecute() {
    Log.i(TAG, "CALLING ON POST EXECUTE");
    if (progressIndicator != null) {
        progressIndicator.dismiss();
        progressIndicator.cancel();
        progressIndicator = null;
    }
}

@Override
public void doInBackground() {
    // put your code here for background operation
}

}

Uma coisa a se considerar é se o resultado da AsyncTask deve estar disponível apenas para a atividade que iniciou a tarefa. Se sim, então a resposta de Romain Guy é a melhor. Se ele deve estar disponível para outras atividades do seu aplicativo, onPostExecutevocê pode usá-lo LocalBroadcastManager.

LocalBroadcastManager.getInstance(getContext()).sendBroadcast(new Intent("finished"));

Você também precisará se certificar de que a atividade lida corretamente com a situação quando a transmissão é enviada enquanto a atividade está pausada.

Dê uma olhada neste post . Este Post envolve AsyncTask realizando uma operação de longa duração e vazamento de memória quando a rotação da tela ocorre em um aplicativo de amostra. O aplicativo de amostra está disponível no forge de origem

Minha solução.

No meu caso, tenho uma cadeia de AsyncTasks com o mesmo contexto. A atividade teve acesso apenas ao primeiro. Para cancelar qualquer tarefa em execução, fiz o seguinte:

public final class TaskLoader {

private static AsyncTask task;

     private TaskLoader() {
         throw new UnsupportedOperationException();
     }

     public static void setTask(AsyncTask task) {
         TaskLoader.task = task;
     }

    public static void cancel() {
         TaskLoader.task.cancel(true);
     }
}

Tarefa doInBackground():

protected Void doInBackground(Params... params) {
    TaskLoader.setTask(this);
    ....
}

Atividade onStop()ou onPause():

protected void onStop() {
    super.onStop();
    TaskLoader.cancel();
}

@Override
protected void onSaveInstanceState(Bundle outState) {
    super.onSaveInstanceState(outState);
    final AddTask task = mAddTask;
    if (task != null && task.getStatus() != UserTask.Status.FINISHED) {
        final String bookId = task.getBookId();
        task.cancel(true);

        if (bookId != null) {
            outState.putBoolean(STATE_ADD_IN_PROGRESS, true);
            outState.putString(STATE_ADD_BOOK, bookId);
        }

        mAddTask = null;
    }
}

@Override
protected void onRestoreInstanceState(Bundle savedInstanceState) {
        super.onRestoreInstanceState(savedInstanceState);
    if (savedInstanceState.getBoolean(STATE_ADD_IN_PROGRESS)) {
        final String id = savedInstanceState.getString(STATE_ADD_BOOK);
        if (!BooksManager.bookExists(getContentResolver(), id)) {
            mAddTask = (AddTask) new AddTask().execute(id);
        }
    }
}

você também pode adicionar android: configChanges = "keyboardHidden |idance | screenSize"

ao seu exemplo manifesto, espero que ajude

 <application
    android:name=".AppController"
    android:allowBackup="true"
    android:icon="@mipmap/ic_launcher"
    android:label="@string/app_name"
    android:roundIcon="@mipmap/ic_launcher_round"
    android:supportsRtl="true"
    android:configChanges="keyboardHidden|orientation|screenSize"
    android:theme="@style/AppTheme">