Android Fragments. Le maintien d'une AsyncTask au cours de la rotation de l'écran ou de la modification de la configuration

Je pense que vous apprécierez mon très complet et de travail exemple détaillé ci-dessous.

1. Rotation des œuvres, et la boîte de dialogue survit.
2. Vous pouvez annuler la tâche et de la boîte de dialogue en appuyant sur le bouton de retour (si vous voulez que ce comportement).
3. Il utilise des fragments.
4. La mise en page du fragment sous les changements de l'activité correctement lorsque l'appareil tourne.
5. Il y a un code source complet télécharger et un fichier APK de sorte que vous pouvez voir si le comportement est ce que vous voulez.

Modifier

Comme demandé par Brad Larson j'ai reproduit la plupart de la solution ci-dessous. Aussi depuis que j'ai posté, j'ai été rappelé à AsyncTaskLoader. Je ne suis pas sûr que il est totalement applicable aux mêmes problèmes, mais vous devriez vérifier de toute façon.

À l'aide de AsyncTask avec les progrès et les boîtes de dialogue de l'appareil de rotation.

Une solution de travail!

J'ai finalement tout s'est mis au travail. Mon code a les caractéristiques suivantes:

1. Un Fragment dont les modifications de mise en page à l'orientation.
2. Un AsyncTask dans laquelle vous pouvez faire un peu de travail.
3. Un DialogFragment qui montre la progression de la tâche dans une barre de progression (et pas seulement pour une période indéterminée spinner).
4. Rotation fonctionne sans interruption de la tâche ou le rejet de la boîte de dialogue.
5. Le bouton retour rejette le dialogue et annule la tâche (vous pouvez modifier ce comportement assez facilement tout de même).

Je ne pense pas que la combinaison de workingness peuvent être trouvés n'importe où ailleurs.

L'idée de base est comme suit. Il y a un MainActivity classe qui contient un fragment unique - MainFragment. MainFragment a différentes mises en page horizontale et verticale de l'orientation, et setRetainInstance() est faux de sorte que la mise en page peut changer. Cela signifie que lorsque le dispositif d'orientation est modifiée, à la fois MainActivity et MainFragment sont complètement détruits et recréés.

Séparément, nous avons MyTask (étendue de AsyncTask) qui fait tout le travail. Nous ne pouvons pas stocker dans MainFragment parce que ce sera détruit, et Google a retiré de l'aide de quelque chose comme setRetainNonInstanceConfiguration(). Ce n'est pas toujours à la disposition de toute façon et est un vilain hack au mieux. Au lieu de cela, nous MyTask dans un autre fragment, un DialogFragment appelé TaskFragment. Ce fragment sera ont setRetainInstance() définie à true pour que l'appareil tourne ce fragment n'est pas détruite, et MyTask est conservé.

Enfin, nous devons dire au TaskFragment qui informer quand il est terminé, et nous le faisons à l'aide de setTargetFragment(<the MainFragment>) lorsque nous de la créer. Lors de la rotation de l'appareil et le MainFragment est détruite et une nouvelle instance est créée, nous utilisons la FragmentManager pour trouver la boîte de dialogue (basé sur son étiquette) et ne setTargetFragment(<the new MainFragment>). C'est assez bien.

Il y a deux autres choses que je devais faire: d'abord annuler la tâche lorsque la boîte de dialogue est fermée, et le deuxième ensemble de la rejeter message à null, sinon le dialogue est bizarrement rejeté lors de la rotation de l'appareil.

Le code

Je ne vais pas lister les mises en page, ils sont assez évidentes, et vous pouvez les trouver dans le projet de téléchargement ci-dessous.

MainActivity

C'est assez simple. J'ai ajouté un rappel dans cette activité, de sorte qu'il sait quand la tâche est terminée, mais vous ne pourriez pas besoin de cela. Surtout, je voulais juste montrer le fragment d'activité de mécanisme de rappel parce que c'est très soignée et vous pourriez ne pas avoir vu avant.

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

C'est long, mais ça valait le coup!

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

Télécharger un exemple de projet

Ici est la le code source et l'APK. Désolé, l'ADT a insisté sur l'ajout de la bibliothèque de prise en charge avant de me laisser faire un projet. Je suis sûr que vous pouvez le supprimer.

Ma première suggestion est de éviter intérieure AsyncTasks, vous pouvez lire une question que j'ai demandé à ce sujet et les réponses: Android: AsyncTask recommandations: cours privé ou public de la classe?

Après que j'ai commencé à l'aide de non-intérieure et... maintenant, je vois BEAUCOUP d'avantages.

La seconde est, de conserver une référence à l'exécution des AsyncTask dans le Application Classe - http://developer.android.com/reference/android/app/Application.html

Chaque fois que vous démarrez une AsyncTask, réglez-le sur l'Application et quand il a finit il mis à null.

Lorsqu'un fragment/le début de l'activité, vous pouvez vérifier si tout AsyncTask est en cours d'exécution (en vérifiant si elle est null ou non sur l'Application), puis définissez la référence à l'intérieur de tout ce que vous voulez (activité, fragment etc, donc vous pouvez faire les rappels).

Cela permettra de résoudre votre problème:
Si vous avez seulement 1 AsyncTask cours d'exécution à tout moment déterminé à l'avance, vous pouvez ajouter une simple référence:

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

Les autres, dans l'Application d'une table de hachage avec des références à eux.

La boîte de dialogue de progression peut suivre exactement le même principe.

J'ai créé un très petit open-source en tâche de fond de la bibliothèque qui est fortement basée sur la Guimauve AsyncTask mais avec des fonctionnalités supplémentaires telles que:

1. Automatiquement en conservant les tâches entre les modifications de la configuration;
2. De l'INTERFACE utilisateur de rappel (les auditeurs);
3. Ne redémarre pas ou annuler la tâche lorsque l'appareil tourne (comme les Chargeurs ferait);

La bibliothèque utilise en interne une Fragment sans interface utilisateur, qui est conservé à travers les modifications de la configuration (setRetainInstance(true)).

Vous pouvez le trouver sur GitHub: https://github.com/NeoTech-Software/Android-Retainable-Tasks

La plupart des exemple de base (version 0.2.0):

Cet exemple entièrement conserve la tâche, à l'aide d'une quantité très limitée de code.

Tâche:

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

Activité:

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

Vous pourriez faire de l'AsyncTask un champ statique. Si vous avez besoin d'un contexte, vous devez expédier votre contexte de l'application. Cela permettra d'éviter les fuites de mémoire, sinon, on aurait de conserver une référence à l'ensemble de votre activité.

J'écris samepl code pour résoudre ce problème

Première étape est de faire de la classe d'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);
}
}

Dans 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">

Code de l'activité:

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

Lorsque l'activité les changements d'orientation de la variable mTask est inited à partir de l'app contexte. Lorsque la tâche est terminée variable est définie sur null et les supprimer de la mémoire.

Pour moi suffisant.

Ont un look ici.

Il y a une solution basée sur Timmmm de l' solution.

Mais j'ai amélioré:

• Maintenant la solution est extensible - vous avez seulement besoin d'étendre FragmentAbleToStartTask

• - Vous en mesure de continuer d'exécuter plusieurs tâches en même temps.

  Et à mon avis, c'est aussi simple que startActivityForResult et recevoir le résultat

• Vous pouvez également interrompre une tâche en cours d'exécution et de vérifier si la tâche est en cours d'exécution

Désolé pour mon anglais