Wie gehe ich mit einer AsyncTask während der Bildschirmdrehung um?

Ich habe viel darüber gelesen, wie ich meinen Instanzstatus speichern oder wie ich damit umgehen kann, dass meine Aktivitäten während der Bildschirmrotation zerstört werden.

Es scheint viele Möglichkeiten zu geben, aber ich habe nicht herausgefunden, welche am besten zum Abrufen der Ergebnisse einer AsyncTask geeignet ist.

Ich habe einige AsyncTasks, die einfach erneut gestartet werden und die isFinishing()Methode der Aktivität aufrufen. Wenn die Aktivität beendet ist, werden sie nichts aktualisieren.

Das Problem ist, dass ich eine Aufgabe habe, die eine Anforderung an einen Webdienst ausführt, die fehlschlagen oder erfolgreich sein kann, und ein Neustart der Aufgabe würde zu einem finanziellen Verlust für den Benutzer führen.

Wie würden Sie das lösen? Was sind die Vor- oder Nachteile der möglichen Lösungen?

Mein erster Vorschlag wäre, sicherzustellen, dass Ihre Aktivität tatsächlich auf einer Bildschirmdrehung zurückgesetzt werden muss (das Standardverhalten). Jedes Mal, wenn ich Probleme mit der Rotation hatte, habe ich dieses Attribut meinem <activity>Tag in der Datei AndroidManifest.xml hinzugefügt und war in Ordnung.

android:configChanges="keyboardHidden|orientation"

Es sieht seltsam aus, aber was es bewirkt, gibt es an Ihre onConfigurationChanged()Methode weiter. Wenn Sie keine angeben, misst es nur das Layout neu, was die meiste Zeit eine vollkommen angemessene Methode zu sein scheint, um die Drehung zu handhaben .

Unter code.google.com/p/shelves können Sie nachlesen , wie ich mit AsyncTasks und Orientierungsänderungen umgehe . Es gibt verschiedene Möglichkeiten, dies zu tun. Die in dieser App ausgewählte Methode besteht darin, eine aktuell ausgeführte Aufgabe abzubrechen, ihren Status zu speichern und eine neue mit dem gespeicherten Status zu starten, wenn die neue Activityerstellt wird. Es ist einfach zu machen, es funktioniert gut und als Bonus sorgt es dafür, dass Ihre Aufgaben gestoppt werden, wenn der Benutzer die App verlässt.

Sie können auch verwenden onRetainNonConfigurationInstance(), um Ihre AsyncTaskan die neue weiterzugeben Activity(achten Sie jedoch darauf, dass die vorherige auf Activitydiese Weise nicht verloren geht.)

Dies ist die interessanteste Frage, die ich in Bezug auf Android gesehen habe !!! Eigentlich habe ich schon in den letzten Monaten nach der Lösung gesucht. Noch nicht gelöst.

Seien Sie vorsichtig und überschreiben Sie einfach die

android:configChanges="keyboardHidden|orientation"

Zeug ist nicht genug.

Betrachten Sie den Fall, wenn der Benutzer einen Anruf erhält, während Ihre AsyncTask ausgeführt wird. Ihre Anfrage wird bereits vom Server verarbeitet, sodass die AsyncTask auf eine Antwort wartet. In diesem Moment geht Ihre App in den Hintergrund, da die Telefon-App gerade in den Vordergrund getreten ist. Das Betriebssystem kann Ihre Aktivität beenden, da es sich im Hintergrund befindet.

Warum behalten Sie nicht immer einen Verweis auf die aktuelle AsyncTask auf dem Singleton bei, die von Android bereitgestellt wird?

Wann immer eine Aufgabe gestartet wird, in PreExecute oder im Builder, definieren Sie:

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

Immer wenn es fertig ist, setzen Sie es auf null.

Auf diese Weise haben Sie immer eine Referenz, mit der Sie so etwas wie onCreate oder onResume ausführen können, wie es für Ihre spezifische Logik geeignet ist:

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

Wenn es null ist, wissen Sie, dass derzeit keine ausgeführt wird!

:-)

Der geeignetste Weg, dies zu tun, besteht darin, ein Fragment zu verwenden, um die Instanz der asynchronen Aufgabe über Rotationen hinweg beizubehalten.

Hier ist ein Link zu einem sehr einfachen Beispiel, das es einfach macht, diese Technik in Ihre Apps zu integrieren.

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

In Pro android 4. Autor hat einen schönen Weg vorgeschlagen, den Sie verwenden sollten weak reference.

Schwacher Hinweis

Aus meiner Sicht ist es besser, eine asynchrone Aufgabe zu speichern, indem Sie onRetainNonConfigurationInstancesie vom aktuellen Aktivitätsobjekt entkoppeln und nach der Änderung der Ausrichtung an ein neues Aktivitätsobjekt binden. Hier habe ich ein sehr schönes Beispiel gefunden, wie man mit AsyncTask und ProgressDialog arbeitet.

Android: Hintergrundverarbeitung / Async Opeartion mit Konfigurationsänderung

So behalten Sie den asynchronen Zustand während des Hintergrundprozesses bei: Sie können Fragmente verwenden.

Siehe die folgenden Schritte:

Schritt 1: Erstellen Sie ein Fragment ohne Header, beispielsweise eine Hintergrundaufgabe, und fügen Sie eine private asynchrone Aufgabenklasse hinzu.

Schritt 2 (optionaler Schritt): Wenn Sie einen Ladecursor auf Ihre Aktivität setzen möchten, verwenden Sie den folgenden Code:

Schritt 3: Implementieren Sie in Ihrer Hauptaktivität die in Schritt 1 definierte BackgroundTaskCallbacks-Schnittstelle

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
}

}}

Zu berücksichtigen ist, ob das Ergebnis der AsyncTask nur für die Aktivität verfügbar sein soll, mit der die Aufgabe gestartet wurde. Wenn ja, dann ist Romain Guys Antwort am besten. Wenn es für andere Aktivitäten Ihrer Anwendung verfügbar sein soll, onPostExecutekönnen Sie es verwenden LocalBroadcastManager.

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

Sie müssen auch sicherstellen, dass die Aktivität die Situation korrekt behandelt, wenn die Übertragung gesendet wird, während die Aktivität angehalten wird.

Schauen Sie sich diesen Beitrag an . In diesem Beitrag führt AsyncTask einen Betrieb mit langer Laufzeit und einen Speicherverlust durch, wenn die Bildschirmdrehung in einer Beispielanwendung erfolgt. Die Beispiel-App ist in der Quellschmiede verfügbar

Meine Lösung.

In meinem Fall habe ich eine Kette von AsyncTasks mit demselben Kontext. Die Aktivität hatte nur Zugriff auf die erste. Um eine laufende Aufgabe abzubrechen, habe ich Folgendes getan:

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

Aufgabe doInBackground():

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

Aktivität onStop()oder 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);
        }
    }
}

Sie können auch Android hinzufügen: configChanges = "keyboardHidden | orientierung | screenSize"

Zu Ihrem offensichtlichen Beispiel hoffe ich, dass es hilft

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