Android-Fragmente.Beibehalten einer asynchronen Aufgabe während der Bildschirmdrehung oder Konfigurationsänderung

Question

Ich arbeite an einer Smartphone- / Tablet-App, verwende nur eine APK und lade Ressourcen je nach Bildschirmgröße nach Bedarf. Die beste Designwahl schien die Verwendung von Fragmenten über die ACL zu sein.

Diese App hat bisher einwandfrei funktioniert und basiert nur auf Aktivitäten.Dies ist eine Scheinklasse dafür, wie ich mit asynchronen Aufgaben und Fortschrittsdialogen in den Aktivitäten umgehe, damit sie auch dann funktionieren, wenn der Bildschirm gedreht wird oder während der Kommunikation eine Konfigurationsänderung auftritt.

Ich werde das Manifest nicht ändern, um eine Neuerstellung der Aktivität zu vermeiden, es gibt viele Gründe, warum ich es nicht tun möchte, aber hauptsächlich, weil die offiziellen Dokumente sagen, dass es nicht empfohlen wird und ich es bisher ohne es geschafft habe, also bitte empfehle diesen Weg nicht.

public class Login extends Activity {

    static ProgressDialog pd;
    AsyncTask<String, Void, Boolean> asyncLoginThread;

    @Override
    public void onCreate(Bundle icicle) {
        super.onCreate(icicle);
        setContentView(R.layout.login);
        //SETUP UI OBJECTS
        restoreAsyncTask();
    }

    @Override
    public Object onRetainNonConfigurationInstance() {
        if (pd != null) pd.dismiss();
        if (asyncLoginThread != null) return (asyncLoginThread);
        return super.onRetainNonConfigurationInstance();
    }

    private void restoreAsyncTask();() {
        pd = new ProgressDialog(Login.this);
        if (getLastNonConfigurationInstance() != null) {
            asyncLoginThread = (AsyncTask<String, Void, Boolean>) getLastNonConfigurationInstance();
            if (asyncLoginThread != null) {
                if (!(asyncLoginThread.getStatus()
                        .equals(AsyncTask.Status.FINISHED))) {
                    showProgressDialog();
                }
            }
        }
    }

    public class LoginThread extends AsyncTask<String, Void, Boolean> {
        @Override
        protected Boolean doInBackground(String... args) {
            try {
                //Connect to WS, recieve a JSON/XML Response
                //Place it somewhere I can use it.
            } catch (Exception e) {
                return true;
            }
            return true;
        }

        protected void onPostExecute(Boolean result) {
            if (result) {
                pd.dismiss();
                //Handle the response. Either deny entry or launch new Login Succesful Activity
            }
        }
    }
}

Dieser Code funktioniert einwandfrei, ich habe ungefähr 10.000 Benutzer ohne Beanstandung, daher schien es logisch, diese Logik einfach in das neue fragmentbasierte Design zu kopieren, aber natürlich funktioniert es nicht.

Hier ist das LoginFragment:

public class LoginFragment extends Fragment {

    FragmentActivity parentActivity;
    static ProgressDialog pd;
    AsyncTask<String, Void, Boolean> asyncLoginThread;

    public interface OnLoginSuccessfulListener {
        public void onLoginSuccessful(GlobalContainer globalContainer);
    }

    public void onSaveInstanceState(Bundle outState){
        super.onSaveInstanceState(outState);
        //Save some stuff for the UI State
    }

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        //setRetainInstance(true);
        //If I setRetainInstance(true), savedInstanceState is always null. Besides that, when loading UI State, a NPE is thrown when looking for UI Objects.
        parentActivity = getActivity();
    }

    @Override
    public void onAttach(Activity activity) {
        super.onAttach(activity);
        try {
            loginSuccessfulListener = (OnLoginSuccessfulListener) activity;
        } catch (ClassCastException e) {
            throw new ClassCastException(activity.toString() + " must implement OnLoginSuccessfulListener");
        }
    }

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

    @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        //SETUP UI OBJECTS
        if(savedInstanceState != null){
            //Reload UI state. Im doing this properly, keeping the content of the UI objects, not the object it self to avoid memory leaks.
        }
    }

    public class LoginThread extends AsyncTask<String, Void, Boolean> {
            @Override
            protected Boolean doInBackground(String... args) {
                try {
                    //Connect to WS, recieve a JSON/XML Response
                    //Place it somewhere I can use it.
                } catch (Exception e) {
                    return true;
                }
                return true;
            }

            protected void onPostExecute(Boolean result) {
                if (result) {
                    pd.dismiss();
                    //Handle the response. Either deny entry or launch new Login Succesful Activity
                }
            }
        }
    }
}

Ich kann nicht benutzen onRetainNonConfigurationInstance() da es von der Aktivität und nicht vom Fragment aufgerufen werden muss, gilt dasselbe für getLastNonConfigurationInstance().Ich habe hier einige ähnliche Fragen ohne Antwort gelesen.

Ich verstehe, dass es einige Umarbeitungen erfordern könnte, um dieses Zeug richtig in Fragmenten zu organisieren, davon abgesehen möchte ich die gleiche grundlegende Designlogik beibehalten.

Was wäre der richtige Weg, um die AsyncTask während einer Konfigurationsänderung beizubehalten, und wenn sie noch ausgeführt wird, zeigen Sie einen Fortschrittsdialog an, wobei zu berücksichtigen ist, dass die AsyncTask eine innere Klasse für das Fragment ist und es das Fragment selbst ist, das die AsyncTask aufruft.ausführen()?

Answer 1

Fragmente können dies tatsächlich viel einfacher machen.Verwenden Sie einfach die Methode Fragment.setRetainInstance(boolescher Wert) damit Ihre Fragmentinstanz über Konfigurationsänderungen hinweg erhalten bleibt.Beachten Sie, dass dies der empfohlene Ersatz für ist Aktivität.ONRETAINNONCONFIGURATIONINSTANZ() in den Dokumenten.

Wenn Sie aus irgendeinem Grund ein beibehaltenes Fragment wirklich nicht verwenden möchten, können Sie andere Ansätze wählen.Beachten Sie, dass jedes Fragment eine eindeutige Kennung hat, die von zurückgegeben wird Fragment.getId().Sie können auch herausfinden, ob ein Fragment für eine Konfigurationsänderung abgerissen wird durch Fragment.getActivity().Ändernde Konfigurationen ().An dem Punkt, an dem Sie sich entscheiden würden, Ihre AsyncTask zu stoppen (höchstwahrscheinlich in onStop() oder onDestroy() ), könnten Sie beispielsweise überprüfen, ob sich die Konfiguration ändert, und sie in diesem Fall in ein statisches SparseArray unter die Kennung des Fragments einfügen. und dann in Ihrem onCreate () oder onStart () nachsehen, ob Sie eine AsyncTask im spärlichen Array verfügbar haben.

Answer 2

Ich denke, Sie werden mein äußerst umfassendes und funktionierendes Beispiel genießen, das unten beschrieben wird.

1. Die Drehung funktioniert und der Dialog überlebt.
2. Sie können die Aufgabe und den Dialog abbrechen, indem Sie die Zurück-Taste drücken (wenn Sie dieses Verhalten wünschen).
3. Es verwendet Fragmente.
4. Das Layout des Fragments unter der Aktivität ändert sich ordnungsgemäß, wenn sich das Gerät dreht.
5. Es gibt einen vollständigen Quellcode-Download und eine vorkompilierte APK so können Sie sehen, ob das Verhalten Ihren Wünschen entspricht.

Bearbeiten

Auf Wunsch von Brad Larson habe ich den größten Teil der unten verlinkten Lösung reproduziert.Auch seit ich es gepostet habe, wurde ich darauf hingewiesen AsyncTaskLoader.Ich bin mir nicht sicher, ob es auf die gleichen Probleme vollständig anwendbar ist, aber Sie sollten es trotzdem überprüfen.

Wobei AsyncTask mit Fortschrittsdialogen und Gerätedrehung.

Eine funktionierende Lösung!

Ich habe endlich alles zum Laufen gebracht.Mein Code hat die folgenden Funktionen:

1. A Fragment dessen Layout sich mit der Ausrichtung ändert.
2. Ein AsyncTask in dem du etwas arbeiten kannst.
3. A DialogFragment dies zeigt den Fortschritt der Aufgabe in einem Fortschrittsbalken an (nicht nur ein unbestimmter Spinner).
4. Die Rotation funktioniert, ohne die Aufgabe zu unterbrechen oder den Dialog zu schließen.
5. Die Zurück-Schaltfläche schließt den Dialog und bricht die Aufgabe ab (Sie können dieses Verhalten jedoch ziemlich einfach ändern).

Ich glaube nicht, dass diese Kombination von Workingness irgendwo anders zu finden ist.

Die Grundidee ist wie folgt.Es gibt eine MainActivity klasse, die ein einzelnes Fragment enthält - MainFragment. MainFragment hat verschiedene Layouts für horizontale und vertikale Ausrichtung und setRetainInstance() ist false, damit sich das Layout ändern kann.Dies bedeutet, dass bei einer Änderung der Geräteausrichtung sowohl MainActivity und MainFragment sind komplett zerstört und neu erstellt.

Separat haben wir MyTask (verlängert von AsyncTask), die die ganze Arbeit erledigt.Wir können es nicht speichern in MainFragment weil das zerstört wird und Google es veraltet hat, so etwas zu verwenden setRetainNonInstanceConfiguration().Das ist sowieso nicht immer verfügbar und bestenfalls ein hässlicher Hack.Stattdessen werden wir speichern MyTask in einem anderen Fragment, a DialogFragment namens TaskFragment. Dieser Fragment werden haben setRetainInstance() auf true gesetzt, damit dieses Fragment beim Drehen des Geräts nicht zerstört wird, und MyTask wird beibehalten.

Schließlich müssen wir dem erzählen TaskFragment wer soll informiert werden, wenn es fertig ist, und das tun wir mit setTargetFragment(<the MainFragment>) wenn wir es schaffen.Wenn das Gerät gedreht wird und die MainFragment zerstört wird und eine neue Instanz erstellt wird, verwenden wir die FragmentManager um den Dialog zu finden (basierend auf seinem Tag) und Folgendes zu tun setTargetFragment(<the new MainFragment>).Das ist so ziemlich alles.

Es gab noch zwei andere Dinge, die ich tun musste:brechen Sie zuerst die Aufgabe ab, wenn der Dialog geschlossen wird, und setzen Sie zweitens die Ablehnungsnachricht auf null, andernfalls wird der Dialog seltsamerweise geschlossen, wenn das Gerät gedreht wird.

Codes

Ich werde die Layouts nicht auflisten, sie sind ziemlich offensichtlich und Sie finden sie im Projektdownload unten.

Hauptaktivität

Das ist ziemlich einfach.Ich habe dieser Aktivität einen Rückruf hinzugefügt, damit sie weiß, wann die Aufgabe abgeschlossen ist, aber das benötigen Sie möglicherweise nicht.Hauptsächlich wollte ich nur den Rückrufmechanismus für Fragmentaktivitäten zeigen, weil er ziemlich ordentlich ist und Sie ihn vielleicht noch nie gesehen haben.

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

Es ist lang, aber es lohnt sich!

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

Beispielprojekt herunterladen

Hier ist der Quellcode und die APK.Entschuldigung, der ADT bestand darauf, die Support-Bibliothek hinzuzufügen, bevor ich ein Projekt erstellen konnte.Ich bin sicher, Sie können es entfernen.

Answer 3

Ich habe vor kurzem einen Artikel gepostet beschreiben, wie Konfigurationsänderungen mit retained behandelt werden Fragments.Es löst das Problem der Beibehaltung einer AsyncTask über einen Drehwechsel schön wechseln.

Der TL; DR ist zu verwenden Host dein AsyncTask in einem Fragment, nennen setRetainInstance(true) auf der Fragment, und melden Sie die AsyncTaskFortschritte/Ergebnisse zurück zu it's Activity (oder es ist Ziel Fragment, wenn Sie sich für den von @Timmmm beschriebenen Ansatz entscheiden) durch die beibehaltene Fragment.

Answer 4

Mein erster Vorschlag ist vermeiden Sie innere asynchrone Aufgaben, Sie können eine Frage lesen, die ich dazu gestellt habe, und die Antworten: Android:Empfehlungen für asynchrone Aufgaben:privatklasse oder öffentliche Klasse?

Danach fing ich an, nicht-inneres und zu verwenden...jetzt sehe ich VIELE Vorteile.

Die zweite ist, behalten Sie eine Referenz Ihrer laufenden AsyncTask in der Application Klasse - http://developer.android.com/reference/android/app/Application.html

Jedes Mal, wenn Sie eine AsyncTask starten, legen Sie sie für die Anwendung fest und setzen Sie sie nach Abschluss auf null.

Wenn ein Fragment / eine Aktivität gestartet wird, können Sie überprüfen, ob eine AsyncTask ausgeführt wird (indem Sie überprüfen, ob sie in der Anwendung null ist oder nicht) und dann die darin enthaltene Referenz auf das setzen, was Sie möchten (Aktivität, Fragment usw., damit Sie Rückrufe durchführen können).

Dies wird Ihr Problem lösen:Wenn zu einem bestimmten Zeitpunkt nur 1 AsyncTask ausgeführt wird, können Sie eine einfache Referenz hinzufügen:

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

Andernfalls haben Sie in der Anwendung eine HashMap mit Verweisen darauf.

Der Fortschrittsdialog kann genau dem gleichen Prinzip folgen.

Answer 5

Ich habe mir eine Methode ausgedacht, AsyncTaskLoader dafür zu verwenden.Es ist ziemlich einfach zu bedienen und erfordert IMO weniger Overhead..

Grundsätzlich erstellen Sie einen AsyncTaskLoader wie folgt:

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

Dann in Ihrer Aktivität, die den obigen AsyncTaskLoader verwendet, wenn auf eine Schaltfläche geklickt wird:

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

    }
}

Dies scheint Orientierungsänderungen gut zu handhaben und Ihre Hintergrundaufgabe wird während der Drehung fortgesetzt.

Ein paar Dinge zu beachten:

1. Wenn Sie sich in onCreate erneut mit dem asynctaskloader verbinden, werden Sie in onLoadFinished () mit dem vorherigen Ergebnis zurückgerufen (auch wenn Ihnen bereits mitgeteilt wurde, dass die Anforderung abgeschlossen ist).Dies ist die meiste Zeit ein gutes Benehmen, aber manchmal kann es schwierig sein, damit umzugehen.Während ich mir vorstelle, dass es viele Möglichkeiten gibt, damit umzugehen, habe ich Loader genannt.abandon() in onLoadFinished .Dann habe ich check in onCreate hinzugefügt, um es nur dann wieder an den Loader anzuhängen, wenn es nicht bereits aufgegeben wurde.Wenn Sie die resultierenden Daten erneut benötigen, möchten Sie das nicht tun.In den meisten Fällen möchten Sie die Daten.

Ich habe weitere Informationen zur Verwendung für HTTP-Aufrufe hier

Answer 6

Ich habe eine sehr kleine Open-Source-Hintergrundaufgabenbibliothek erstellt, die stark auf dem Marshmallow basiert AsyncTask aber mit zusätzlichen Funktionen wie:

1. Automatisches Beibehalten von Aufgaben über Konfigurationsänderungen hinweg;
2. UI-Rückruf (Zuhörer);
3. Startet die Aufgabe nicht neu oder bricht sie ab, wenn sich das Gerät dreht (wie es Lader tun würden);

Die Bibliothek verwendet intern eine Fragment ohne Benutzeroberfläche, die bei Konfigurationsänderungen beibehalten wird (setRetainInstance(true)).

Sie finden es auf GitHub: https://github.com/NeoTech-Software/Android-Retainable-Tasks

Grundlegendstes Beispiel (Version 0.2.0):

In diesem Beispiel wird die Aufgabe vollständig beibehalten, wobei eine sehr begrenzte Menge an Code verwendet wird.

Aufgabe:

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

Aktivität:

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

Answer 7

Im Allgemeinen können wir die eigentliche Geschäftslogik (Lesen von Daten aus dem Internet oder einer Datenbank oder was auch immer) von AsyncTask (dem Delegator) zu BusinessDAO (dem Delegaten) in Ihrer AsyncTask isolieren.doInBackground() Methode, Delegieren Sie die eigentliche Aufgabe an BusinessDAO, Implementieren Sie dann einen Singleton-Prozessmechanismus in BusinessDAO, so dass mehrere Aufrufe an BusinessDAO.doSomething () löst jedes Mal nur eine tatsächliche Aufgabe aus, die ausgeführt wird und auf das Aufgabenergebnis wartet.Die Idee ist, den Delegierten zu behalten (d. h.B. BusinessDAO) während der Konfigurationsänderung anstelle des Delegators (d. h.Asynchrone Aufgabe).

1. Erstellen / Implementieren Sie unsere eigene Anwendung. Der Zweck besteht darin, BusinessDAO hier zu erstellen / zu initialisieren, damit der Lebenszyklus unseres BusinessDAO anwendungsbezogen und nicht aktivitätsbezogen ist. Beachten Sie, dass Sie AndroidManifest ändern müssen.xml zur Verwendung von 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;
     }
   
   }
   

2. Unsere bestehenden Aktivitäten / Aufgaben sind größtenteils unverändert, implementieren AsyncTask weiterhin als innere Klasse und beziehen AsyncTask mit ein.execute() von Activity / Fragement , der Unterschied ist jetzt, dass AsyncTask die eigentliche Aufgabe an BusinessDAO delegiert, sodass während der Konfigurationsänderung eine zweite AsyncTask initialisiert und ausgeführt wird und BusinessDAO aufruft.doSomething() zum zweiten Mal jedoch zweiter Aufruf von BusinessDAO.doSomething () löst keine neue laufende Aufgabe aus, sondern wartet darauf, dass die aktuelle laufende Aufgabe beendet wird:

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

3. Implementieren Sie in BusinessDAO beispielsweise einen Singleton-Prozessmechanismus:

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

Ich bin mir nicht 100% sicher, ob dies funktionieren wird, außerdem sollte das Beispielcode-Snippet als Pseudocode betrachtet werden.Ich versuche nur, Ihnen einen Hinweis auf die Designebene zu geben.Jedes Feedback oder Vorschläge sind willkommen und geschätzt.

Answer 8

Sie könnten die AsyncTask zu einem statischen Feld machen.Wenn Sie einen Kontext benötigen, sollten Sie Ihren Anwendungskontext versenden.Dies vermeidet Speicherverluste, andernfalls würden Sie einen Verweis auf Ihre gesamte Aktivität behalten.

Answer 9

Wenn jemand den Weg zu diesem Thread findet, dann fand ich einen sauberen Ansatz, die asynchrone Aufgabe von einem auszuführen app.Service (gestartet mit START_STICKY) und dann beim Neustarten die laufenden Dienste durchlaufen, um herauszufinden, ob der Dienst (und damit die asynchrone Aufgabe) noch ausgeführt wird;

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

Wenn dies der Fall ist, fügen Sie die DialogFragment (oder was auch immer) und wenn dies nicht der Fall ist, stellen Sie sicher, dass der Dialog geschlossen wurde.

Dies ist besonders relevant, wenn Sie das verwenden v4.support.* bibliotheken, da sie (zum Zeitpunkt des Schreibens) Probleme mit der setRetainInstance methoden- und Ansichts-Paging. Wenn Sie die Instanz nicht beibehalten, können Sie Ihre Aktivität außerdem mit einem anderen Satz von Ressourcen (z.ein anderes Ansichtslayout für die neue Ausrichtung)

Answer 10

Ich schreibe Samepl-Code, um dieses Problem zu lösen

Der erste Schritt besteht darin, eine Anwendungsklasse zu erstellen:

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

In 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 in Aktivität:

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

}

Wenn sich die Aktivitätsausrichtung ändert, wird die Variable mTask aus dem App-Kontext initiiert.Wenn die Aufgabe beendet ist, wird die Variable auf null gesetzt und aus dem Speicher entfernt.

Für mich ist es genug.

Answer 11

Sehen Sie sich das folgende Beispiel an, wie Sie ein beibehaltenes Fragment verwenden, um die Hintergrundaufgabe beizubehalten:

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

    }
}

Answer 12

Schau es dir an hier.

Es gibt eine Lösung basierend auf Timmmm's Lösung.

Aber ich habe es verbessert:

• Jetzt ist die Lösung erweiterbar - Sie müssen nur noch erweitern FragmentAbleToStartTask

• Sie können mehrere Aufgaben gleichzeitig ausführen.

  Und meiner Meinung nach ist es so einfach wie startActivityForResult und Ergebnis erhalten

• Sie können auch eine laufende Aufgabe stoppen und prüfen, ob eine bestimmte Aufgabe ausgeführt wird

Entschuldigung für mein Englisch