ベストプラクティス:方向変更中のAsyncTask


151

AsyncTask 別のスレッドで複雑なタスクを実行するのは素晴らしいことです。

ただし、のAsyncTask実行中に方向の変更や別の構成の変更があると、電流Activityは破棄されて再起動します。のインスタンスがAsyncTaskそのアクティビティに接続されているため、失敗し、「強制終了」メッセージウィンドウが表示されます。

したがって、これらのエラーを回避し、AsyncTaskが失敗するのを防ぐための何らかの「ベストプラクティス」を探しています。

これまでに見たのは、

  • 向きの変更を無効にします(確かにこれを処理する方法ではありません)。
  • タスクを存続させ、新しいアクティビティインスタンスで更新する onRetainNonConfigurationInstance
  • Activityが破棄されたときにタスクをキャンセルし、Activityが再度作成されたときにタスクを再起動するだけです。
  • タスクをアクティビティインスタンスではなくアプリケーションクラスにバインドする。
  • 「シェルフ」プロジェクトで使用されるいくつかのメソッド(onRestoreInstanceState経由)

いくつかのコード例:

画面回転中のAndroid AsyncTasks、パートIおよびパートII

ShelvesActivity.java

問題を最もよく解決し、実装も簡単な最善の方法を見つけるのを手伝ってくれませんか?これを正しく解決する方法がわからないため、コード自体も重要です。


重複があります。このstackoverflow.com/questions/4584015/…を確認してください。
TeaCupApp 2011

これはMark Murphyのブログからです... AsyncTaskとScreenRotationが役立つかもしれません... リンク
Gopal

これは古い投稿ですが、この IMOは、はるかに簡単な(そして優れた)アプローチです。
DroidDev 2017

どうしてドキュメントがそのような非常に些細な状況について語っていないのかと思います。
Sreekanth Karumanaghat

回答:


140

この問題に対処するために使用しないでくださいandroid:configChanges。これは非常に悪い習慣です。

どちらも使用しないでくださいActivity#onRetainNonConfigurationInstance()。これはモジュール性が低く、Fragmentベースのアプリケーションにはあまり適していません。

保持されたを使用して構成変更を処理する方法を説明した私の記事読むことができますFragment。これはAsyncTask、回転変化全体を適切に保持するという問題を解決します。あなたは基本的に、あなたのホストする必要がAsyncTask内側にaをFragment、コールsetRetainInstance(true)のをFragment、と報告しAsyncTask、それはだに戻っての進捗状況/結果をActivity保持してFragment


26
素晴らしいアイデアですが、全員がフラグメントを使用するわけではありません。Fragmentsが選択肢となるずっと以前から、多くのレガシーコードが書かれています。
Scott Biggs

14
@ScottBiggs Fragmentsは、サポートライブラリからAndroid 1.6まで使用できます。また、サポートライブラリFragmentsの利用に問題がある、現在もアクティブに使用されているレガシーコードの例を挙げていただけますか?正直なところ、それは問題ではないと思います。
Alex Lockwood

4
@tactoth 99.9%の人がを使用しなくなったため、これらの問題に対処する必要性を私の回答で感じていませんでしたTabActivity。正直なところ、なぜこれについて話しているのかわかりません... Fragmentsが進むべき道であることに誰もが同意します。:)
Alex Lockwood

2
ネストされたフラグメントからAsyncTaskを呼び出す必要がある場合はどうなりますか?
Eduardo Naveda 14

3
@AlexLockwood-「フラグメントは進むべき道であることに誰もが同意する。」SquaredでのDevsは反対です!
JBeckton

36

通常、これを解決するには、.onPostExecute()コールバックでAsyncTasksにブロードキャストインテントを発生させることで、直接開始したアクティビティを変更しないようにします。アクティビティは、これらのブロードキャストを動的なBroadcastReceiversでリッスンし、それに応じて動作します。

このように、AsyncTasksは、結果を処理する特定のアクティビティインスタンスを気にする必要がありません。それらは終了時にただ「叫び」、タスクの結果に関心のあるアクティビティがその頃(アクティブであり、フォーカスされている/再開状態にある)場合、それは処理されます。

ランタイムはブロードキャストを処理する必要があるため、これには少しオーバーヘッドが伴いますが、通常は気にしません。デフォルトのシステム全体の代わりにLocalBroadcastManagerを使用すると、処理が少し速くなると思います。


6
もし
Sankar V '10

1
これは、アクティビティとフラグメント間のカップリングが少ないソリューションだと思います
Roger Garzon Nieto

7
これはソリューションの一部である可能性がありますが、方向を変更した後にAsyncTaskが再作成される問題を解決するようには見えません。
miguel 2013

4
運が悪く、放送中にどちらの活動も行われていない場合はどうなりますか?(つまり、ローテーション中です)
サム

24

AsyncTaskの別の例は、を使用しFragmentて(ユーザーが画面を回転したときのように)ランタイム構成の変更を処理し、setRetainInstance(true)。確定的な(定期的に更新される)進行状況バーも示されます。

この例の一部は、公式ドキュメントである「構成変更時のオブジェクトの保持」に基づいています。

この例では、バックグラウンドスレッドを必要とする作業は、インターネットからUIへの画像の単なる読み込みです。

Alex Lockwoodは、 "Retained Fragment"を使用してAsyncTasksでランタイム構成の変更を処理することがベストプラクティスであると考えています。onRetainNonConfigurationInstance()Android StudioのLintでは廃止されます。公式ドキュメントは、構成の変更を自分処理するandroid:configChangesから、を使用することを警告しています...

構成の変更を自分で処理すると、システムが自動的にそれらを適用しないため、代替リソースの使用がはるかに困難になる可能性があります。この手法は、構成変更による再起動を回避する必要がある場合の最後の手段と考える必要があり、ほとんどのアプリケーションには推奨されません。

次に、バックグラウンドスレッドにAsyncTaskを使用する必要があるかどうかの問題があります。

AsyncTask公式リファレンスが警告しています...

AsyncTasksは、理想的には短い操作(最大で数秒)に使用する必要があります。スレッドを長期間実行し続ける必要がある場合は、java.util.concurrentパッケージによって提供されるさまざまなAPIを使用することを強くお勧めします。エグゼキューター、ThreadPoolExecutor、FutureTask。

または、サービス、ローダー(CursorLoaderまたはAsyncTaskLoaderを使用)、またはコンテンツプロバイダーを使用して非同期操作を実行することもできます。

残りの投稿を次のように分割します。

  • 手順; そして
  • 上記の手順のすべてのコード。

手順

  1. アクティビティの内部クラスとして、基本的なAsyncTaskから始めます(内部クラスである必要はありませんが、おそらく便利です)。この段階では、AsyncTaskはランタイム構成の変更を処理しません。

    public class ThreadsActivity extends ActionBarActivity {
    
        private ImageView mPictureImageView;
    
        private class LoadImageFromNetworkAsyncTask
                              extends AsyncTask<String, Void, Bitmap> {
    
            @Override
            protected Bitmap doInBackground(String... urls) {
                return loadImageFromNetwork(urls[0]);
            }
    
            @Override
            protected void onPostExecute(Bitmap bitmap) {
                mPictureImageView.setImageBitmap(bitmap);
            }
        }
    
        /**
         * Requires in AndroidManifext.xml
         *  <uses-permission android:name="android.permission.INTERNET" />
         */
        private Bitmap loadImageFromNetwork(String url) {
            Bitmap bitmap = null;
            try {
                bitmap = BitmapFactory.decodeStream((InputStream)
                                              new URL(url).getContent());
            } catch (Exception e) {
                e.printStackTrace();
            }
            return bitmap;
        }
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_threads);
    
            mPictureImageView =
                (ImageView) findViewById(R.id.imageView_picture);
        }
    
        public void getPicture(View view) {
            new LoadImageFromNetworkAsyncTask()
                .execute("http://i.imgur.com/SikTbWe.jpg");
        }
    
    }
  2. Fragementクラスを拡張し、独自のUIを持たないネストされたクラスRetainedFragmentを追加します。このフラグメントのonCreateイベントにsetRetainInstance(true)を追加します。データを設定および取得する手順を提供します。

    public class ThreadsActivity extends Activity {
    
        private ImageView mPictureImageView;
        private RetainedFragment mRetainedFragment = null;
        ...
    
        public static class RetainedFragment extends Fragment {
    
            private Bitmap mBitmap;
    
            @Override
            public void onCreate(Bundle savedInstanceState) {
                super.onCreate(savedInstanceState);
    
                // The key to making data survive
                // runtime configuration changes.
                setRetainInstance(true);
            }
    
            public Bitmap getData() {
                return this.mBitmap;
            }
    
            public void setData(Bitmap bitmapToRetain) {
                this.mBitmap = bitmapToRetain;
            }
        }
    
        private class LoadImageFromNetworkAsyncTask
                        extends AsyncTask<String, Integer,Bitmap> {
        ....
  3. 最も外側のActivityクラスのonCreate()でRetainedFragmentを処理します。既に存在する場合はそれを参照します(Activityが再起動している場合)。存在しない場合は作成して追加します。次に、すでに存在する場合は、RetainedFragmentからデータを取得し、そのデータでUIを設定します。

    public class ThreadsActivity extends Activity {
    
        ...
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_threads);
    
            final String retainedFragmentTag = "RetainedFragmentTag";
    
            mPictureImageView =
                      (ImageView) findViewById(R.id.imageView_picture);
            mLoadingProgressBar =
                    (ProgressBar) findViewById(R.id.progressBar_loading);
    
            // Find the RetainedFragment on Activity restarts
            FragmentManager fm = getFragmentManager();
            // The RetainedFragment has no UI so we must
            // reference it with a tag.
            mRetainedFragment =
              (RetainedFragment) fm.findFragmentByTag(retainedFragmentTag);
    
            // if Retained Fragment doesn't exist create and add it.
            if (mRetainedFragment == null) {
    
                // Add the fragment
                mRetainedFragment = new RetainedFragment();
                fm.beginTransaction()
                    .add(mRetainedFragment, retainedFragmentTag).commit();
    
            // The Retained Fragment exists
            } else {
    
                mPictureImageView
                    .setImageBitmap(mRetainedFragment.getData());
            }
        }
  4. UIからAsyncTaskを開始する

    public void getPicture(View view) {
        new LoadImageFromNetworkAsyncTask().execute(
                "http://i.imgur.com/SikTbWe.jpg");
    }
  5. 確定プログレスバーを追加してコーディングします。

    • 進行状況バーをUIレイアウトに追加します。
    • アクティビティoncreate();で参照を取得します。
    • プロセスの開始時と終了時にそれを表示し、非表示にします。
    • onProgressUpdateでUIに報告する進捗状況を定義します。
    • AsyncTask 2nd GenericパラメーターをVoidから進行状況の更新を処理できるタイプ(整数など)に変更します。
    • doInBackground()の通常のポイントでのpublishProgress。

上記の手順のすべてのコード

アクティビティのレイアウト。

<ScrollView xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context="com.example.mysecondapp.ThreadsActivity">

    <RelativeLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:orientation="vertical"
        android:paddingBottom="@dimen/activity_vertical_margin"
        android:paddingLeft="@dimen/activity_horizontal_margin"
        android:paddingRight="@dimen/activity_horizontal_margin"
        android:paddingTop="@dimen/activity_vertical_margin">

        <ImageView
            android:id="@+id/imageView_picture"
            android:layout_width="300dp"
            android:layout_height="300dp"
            android:background="@android:color/black" />

        <Button
            android:id="@+id/button_get_picture"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_alignParentLeft="true"
            android:layout_alignParentStart="true"
            android:layout_below="@id/imageView_picture"
            android:onClick="getPicture"
            android:text="Get Picture" />

        <Button
            android:id="@+id/button_clear_picture"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_alignBottom="@id/button_get_picture"
            android:layout_toEndOf="@id/button_get_picture"
            android:layout_toRightOf="@id/button_get_picture"
            android:onClick="clearPicture"
            android:text="Clear Picture" />

        <ProgressBar
            android:id="@+id/progressBar_loading"
            style="?android:attr/progressBarStyleHorizontal"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_below="@id/button_get_picture"
            android:progress="0"
            android:indeterminateOnly="false"
            android:visibility="invisible" />

    </RelativeLayout>
</ScrollView>

アクティビティ:サブクラス化されたAsyncTask内部クラス。ランタイム構成の変更(ユーザーが画面を回転したときなど)を処理するサブクラス化されたRetainedFragment内部クラス。定期的に更新する進行状況バーを確認します。...

public class ThreadsActivity extends Activity {

    private ImageView mPictureImageView;
    private RetainedFragment mRetainedFragment = null;
    private ProgressBar mLoadingProgressBar;

    public static class RetainedFragment extends Fragment {

        private Bitmap mBitmap;

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

            // The key to making data survive runtime configuration changes.
            setRetainInstance(true);
        }

        public Bitmap getData() {
            return this.mBitmap;
        }

        public void setData(Bitmap bitmapToRetain) {
            this.mBitmap = bitmapToRetain;
        }
    }

    private class LoadImageFromNetworkAsyncTask extends AsyncTask<String,
            Integer, Bitmap> {

        @Override
        protected Bitmap doInBackground(String... urls) {
            // Simulate a burdensome load.
            int sleepSeconds = 4;
            for (int i = 1; i <= sleepSeconds; i++) {
                SystemClock.sleep(1000); // milliseconds
                publishProgress(i * 20); // Adjust for a scale to 100
            }

            return com.example.standardapplibrary.android.Network
                    .loadImageFromNetwork(
                    urls[0]);
        }

        @Override
        protected void onProgressUpdate(Integer... progress) {
            mLoadingProgressBar.setProgress(progress[0]);
        }

        @Override
        protected void onPostExecute(Bitmap bitmap) {
            publishProgress(100);
            mRetainedFragment.setData(bitmap);
            mPictureImageView.setImageBitmap(bitmap);
            mLoadingProgressBar.setVisibility(View.INVISIBLE);
            publishProgress(0);
        }
    }

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

        final String retainedFragmentTag = "RetainedFragmentTag";

        mPictureImageView = (ImageView) findViewById(R.id.imageView_picture);
        mLoadingProgressBar = (ProgressBar) findViewById(R.id.progressBar_loading);

        // Find the RetainedFragment on Activity restarts
        FragmentManager fm = getFragmentManager();
        // The RetainedFragment has no UI so we must reference it with a tag.
        mRetainedFragment = (RetainedFragment) fm.findFragmentByTag(
                retainedFragmentTag);

        // if Retained Fragment doesn't exist create and add it.
        if (mRetainedFragment == null) {

            // Add the fragment
            mRetainedFragment = new RetainedFragment();
            fm.beginTransaction().add(mRetainedFragment,
                                      retainedFragmentTag).commit();

            // The Retained Fragment exists
        } else {

            mPictureImageView.setImageBitmap(mRetainedFragment.getData());
        }
    }

    public void getPicture(View view) {
        mLoadingProgressBar.setVisibility(View.VISIBLE);
        new LoadImageFromNetworkAsyncTask().execute(
                "http://i.imgur.com/SikTbWe.jpg");
    }

    public void clearPicture(View view) {
        mRetainedFragment.setData(null);
        mPictureImageView.setImageBitmap(null);
    }
}

この例では、実際の作業を行うライブラリ関数(明示的なパッケージプレフィックスcom.example.standardapplibrary.android.Networkで上で参照)が...

public static Bitmap loadImageFromNetwork(String url) {
    Bitmap bitmap = null;
    try {
        bitmap = BitmapFactory.decodeStream((InputStream) new URL(url)
                .getContent());
    } catch (Exception e) {
        e.printStackTrace();
    }
    return bitmap;
}

バックグラウンドタスクに必要な権限をAndroidManifest.xmlに追加します...

<manifest>
...
    <uses-permission android:name="android.permission.INTERNET" />

AndroidManifest.xmlにアクティビティを追加します...

<manifest>
...
    <application>
        <activity
            android:name=".ThreadsActivity"
            android:label="@string/title_activity_threads"
            android:parentActivityName=".MainActivity">
            <meta-data
                android:name="android.support.PARENT_ACTIVITY"
                android:value="com.example.mysecondapp.MainActivity" />
        </activity>

すごい。これについてブログを書いてください。
Akh

2
@AKh。Stackoverflowで私の答えが余りにも多くのスペースを占めることを示唆するつもりですか?
John Bentley

1
私は彼があなたが素晴らしい答えを持っていることを意味し、あなたはブログを書くべきだと思います!=)@JohnBentley
Sandy D.

@ SandyD.yesterday肯定的な解釈をありがとう。私は彼女または彼がそれを意図したことを望みます。
John Bentley

それも素晴らしい答えだと思って、そのように解釈しました。このような完全な答えは素晴らしいです!!
LeonardoSibela

3

最近、私はここで良い解決策を見つけました。これは、RetainConfigurationによるタスクオブジェクトの保存に基づいています。私の見解では、このソリューションは非常にエレガントで、私は使い始めました。あなたはあなたのasynctaskをbasetaskから入れ子にする必要があるだけで、それがすべてです。


この興味深い答えをありがとうございました。関連する質問で言及されているものに加えて、それは良い解決策です。
12

5
残念ながら、このソリューションは非推奨のメソッドを使用しています。
ダミアン

3

この投稿の@Alex Lockwoodの回答と@William&@quickdraw mcgrawの回答に基づく:アクティビティ/フラグメントが一時停止しているときにハンドラーメッセージを処理する方法、私は一般的なソリューションを書きました。

この方法でローテーションが処理され、非同期タスクの実行中にアクティビティがバックグラウンドになると、アクティビティは再開時にコールバック(onPreExecute、onProgressUpdate、onPostExecute&onCancelled)を受け取るため、IllegalStateExceptionはスローされません(ハンドラーの処理方法を参照)。アクティビティ/フラグメントが一時停止されたときのメッセージ)。

同じことをするのは素晴らしいのですが、AsyncTask(例:AsyncTaskFragment <Params、Progress、Result>)のような一般的な引数タイプを使用することはできますが、すぐには実行できず、現時点では時間がありません。改善したい方はお気軽にどうぞ!

コード:

import android.app.Activity;
import android.os.AsyncTask;
import android.os.Bundle;
import android.os.Message;
import android.support.v4.app.Fragment;
import android.support.v4.app.FragmentManager;
import android.support.v7.app.AppCompatActivity;

public class AsyncTaskFragment extends Fragment {

    /* ------------------------------------------------------------------------------------------ */
    // region Classes & Interfaces

    public static abstract class Task extends AsyncTask<Object, Object, Object> {

        private AsyncTaskFragment _fragment;

        private void setFragment(AsyncTaskFragment fragment) {

            _fragment = fragment;
        }

        @Override
        protected final void onPreExecute() {

            // Save the state :
            _fragment.setRunning(true);

            // Send a message :
            sendMessage(ON_PRE_EXECUTE_MESSAGE, null);
        }

        @Override
        protected final void onPostExecute(Object result) {

            // Save the state :
            _fragment.setRunning(false);

            // Send a message :
            sendMessage(ON_POST_EXECUTE_MESSAGE, result);
        }

        @Override
        protected final void onProgressUpdate(Object... values) {

            // Send a message :
            sendMessage(ON_PROGRESS_UPDATE_MESSAGE, values);
        }

        @Override
        protected final void onCancelled() {

            // Save the state :
            _fragment.setRunning(false);

            // Send a message :
            sendMessage(ON_CANCELLED_MESSAGE, null);
        }

        private void sendMessage(int what, Object obj) {

            Message message = new Message();
            message.what = what;
            message.obj = obj;

            Bundle data = new Bundle(1);
            data.putString(EXTRA_FRAGMENT_TAG, _fragment.getTag());
            message.setData(data);

            _fragment.handler.sendMessage(message);
        }
    }

    public interface AsyncTaskFragmentListener {

        void onPreExecute(String fragmentTag);
        void onProgressUpdate(String fragmentTag, Object... progress);
        void onCancelled(String fragmentTag);
        void onPostExecute(String fragmentTag, Object result);
    }

    private static class AsyncTaskFragmentPauseHandler extends PauseHandler {

        @Override
        final protected void processMessage(Activity activity, Message message) {

            switch (message.what) {

                case ON_PRE_EXECUTE_MESSAGE : { ((AsyncTaskFragmentListener)activity).onPreExecute(message.getData().getString(EXTRA_FRAGMENT_TAG)); break; }
                case ON_POST_EXECUTE_MESSAGE : { ((AsyncTaskFragmentListener)activity).onPostExecute(message.getData().getString(EXTRA_FRAGMENT_TAG), message.obj); break; }
                case ON_PROGRESS_UPDATE_MESSAGE : { ((AsyncTaskFragmentListener)activity).onProgressUpdate(message.getData().getString(EXTRA_FRAGMENT_TAG), ((Object[])message.obj)); break; }
                case ON_CANCELLED_MESSAGE : { ((AsyncTaskFragmentListener)activity).onCancelled(message.getData().getString(EXTRA_FRAGMENT_TAG)); break; }
            }
        }
    }

    // endregion
    /* ------------------------------------------------------------------------------------------ */



    /* ------------------------------------------------------------------------------------------ */
    // region Attributes

    private Task _task;
    private AsyncTaskFragmentListener _listener;
    private boolean _running = false;

    private static final String EXTRA_FRAGMENT_TAG = "EXTRA_FRAGMENT_TAG";
    private static final int ON_PRE_EXECUTE_MESSAGE = 0;
    private static final int ON_POST_EXECUTE_MESSAGE = 1;
    private static final int ON_PROGRESS_UPDATE_MESSAGE = 2;
    private static final int ON_CANCELLED_MESSAGE = 3;

    private AsyncTaskFragmentPauseHandler handler = new AsyncTaskFragmentPauseHandler();

    // endregion
    /* ------------------------------------------------------------------------------------------ */



    /* ------------------------------------------------------------------------------------------ */
    // region Getters

    public AsyncTaskFragmentListener getListener() { return _listener; }
    public boolean isRunning() { return _running; }

    // endregion
    /* ------------------------------------------------------------------------------------------ */



    /* ------------------------------------------------------------------------------------------ */
    // region Setters

    public void setTask(Task task) {

        _task = task;
        _task.setFragment(this);
    }

    public void setListener(AsyncTaskFragmentListener listener) { _listener = listener; }
    private void setRunning(boolean running) { _running = running; }

    // endregion
    /* ------------------------------------------------------------------------------------------ */



    /* ------------------------------------------------------------------------------------------ */
    // region Fragment lifecycle

    @Override
    public void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);
        setRetainInstance(true);
    }

    @Override
    public void onResume() {

        super.onResume();
        handler.resume(getActivity());
    }

    @Override
    public void onPause() {

        super.onPause();
        handler.pause();
    }

    @Override
    public void onAttach(Activity activity) {

        super.onAttach(activity);
        _listener = (AsyncTaskFragmentListener) activity;
    }

    @Override
    public void onDetach() {

        super.onDetach();
        _listener = null;
    }

    // endregion
    /* ------------------------------------------------------------------------------------------ */



    /* ------------------------------------------------------------------------------------------ */
    // region Utils

    public void execute(Object... params) {

        _task.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, params);
    }

    public void cancel(boolean mayInterruptIfRunning) {

        _task.cancel(mayInterruptIfRunning);
    }

    public static AsyncTaskFragment getRetainedOrNewFragment(AppCompatActivity activity, String fragmentTag) {

        FragmentManager fm = activity.getSupportFragmentManager();
        AsyncTaskFragment fragment = (AsyncTaskFragment) fm.findFragmentByTag(fragmentTag);

        if (fragment == null) {

            fragment = new AsyncTaskFragment();
            fragment.setListener( (AsyncTaskFragmentListener) activity);
            fm.beginTransaction().add(fragment, fragmentTag).commit();
        }

        return fragment;
    }

    // endregion
    /* ------------------------------------------------------------------------------------------ */
}

PauseHandlerが必要です:

import android.app.Activity;
import android.os.Handler;
import android.os.Message;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * Message Handler class that supports buffering up of messages when the activity is paused i.e. in the background.
 *
 * /programming/8040280/how-to-handle-handler-messages-when-activity-fragment-is-paused
 */
public abstract class PauseHandler extends Handler {

    /**
     * Message Queue Buffer
     */
    private final List<Message> messageQueueBuffer = Collections.synchronizedList(new ArrayList<Message>());

    /**
     * Flag indicating the pause state
     */
    private Activity activity;

    /**
     * Resume the handler.
     */
    public final synchronized void resume(Activity activity) {
        this.activity = activity;

        while (messageQueueBuffer.size() > 0) {
            final Message msg = messageQueueBuffer.get(0);
            messageQueueBuffer.remove(0);
            sendMessage(msg);
        }
    }

    /**
     * Pause the handler.
     */
    public final synchronized void pause() {
        activity = null;
    }

    /**
     * Store the message if we have been paused, otherwise handle it now.
     *
     * @param msg   Message to handle.
     */
    @Override
    public final synchronized void handleMessage(Message msg) {
        if (activity == null) {
            final Message msgCopy = new Message();
            msgCopy.copyFrom(msg);
            messageQueueBuffer.add(msgCopy);
        } else {
            processMessage(activity, msg);
        }
    }

    /**
     * Notification message to be processed. This will either be directly from
     * handleMessage or played back from a saved message when the activity was
     * paused.
     *
     * @param activity  Activity owning this Handler that isn't currently paused.
     * @param message   Message to be handled
     */
    protected abstract void processMessage(Activity activity, Message message);
}

使用例:

public class TestActivity extends AppCompatActivity implements AsyncTaskFragmentListener {

    private final static String ASYNC_TASK_FRAGMENT_A = "ASYNC_TASK_FRAGMENT_A";
    private final static String ASYNC_TASK_FRAGMENT_B = "ASYNC_TASK_FRAGMENT_B";

    @Override
    public void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        Button testButton = (Button) findViewById(R.id.test_button);
        final AsyncTaskFragment fragment = AsyncTaskFragment.getRetainedOrNewFragment(TestActivity.this, ASYNC_TASK_FRAGMENT_A);

        testButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {

                if(!fragment.isRunning()) {

                    fragment.setTask(new Task() {

                        @Override
                        protected Object doInBackground(Object... objects) {

                            // Do your async stuff

                            return null;
                        }
                    });

                    fragment.execute();
                }
            }
        });
    }

    @Override
    public void onPreExecute(String fragmentTag) {}

    @Override
    public void onProgressUpdate(String fragmentTag, Float percent) {}

    @Override
    public void onCancelled(String fragmentTag) {}

    @Override
    public void onPostExecute(String fragmentTag, Object result) {

        switch (fragmentTag) {

            case ASYNC_TASK_FRAGMENT_A: {

                // Handle ASYNC_TASK_FRAGMENT_A
                break;
            }
            case ASYNC_TASK_FRAGMENT_B: {

                // Handle ASYNC_TASK_FRAGMENT_B
                break;
            }
        }
    }
}

3

これにはローダーを使用できます。ここでドキュメントをチェック


2
ローダーは、Android API 28の時点で非推奨になりました(リンクからわかるとおり)。
Sumit

ローダーは廃止されていません。変更されるのは、それらを呼び出す方法だけです
EdgeDev

2

フラグメントを回避したい場合は、onRetainCustomNonConfigurationInstance()といくつかのワイヤリングを使用して、方向の変更時に実行されているAsyncTaskを保持できます。

(このメソッドは非推奨のonRetainNonConfigurationInstance()の代わりになることに注意してください)。

このソリューションは頻繁に言及されていないようですが。説明のために簡単な実行例を書きました。

乾杯!

public class MainActivity extends AppCompatActivity {

private TextView result;
private Button run;
private AsyncTaskHolder asyncTaskHolder;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    result = (TextView) findViewById(R.id.textView_result);
    run = (Button) findViewById(R.id.button_run);
    asyncTaskHolder = getAsyncTaskHolder();
    run.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            asyncTaskHolder.execute();
        }
    });
}

private AsyncTaskHolder getAsyncTaskHolder() {
    if (this.asyncTaskHolder != null) {
        return asyncTaskHolder;
    }
    //Not deprecated. Get the same instance back.
    Object instance = getLastCustomNonConfigurationInstance();

    if (instance == null) {
        instance = new AsyncTaskHolder();
    }
    if (!(instance instanceof ActivityDependant)) {
        Log.e("", instance.getClass().getName() + " must implement ActivityDependant");
    }
    return (AsyncTaskHolder) instance;
}

@Override
//Not deprecated. Save the object containing the running task.
public Object onRetainCustomNonConfigurationInstance() {
    return asyncTaskHolder;
}

@Override
protected void onStart() {
    super.onStart();
    if (asyncTaskHolder != null) {
        asyncTaskHolder.attach(this);
    }
}

@Override
protected void onStop() {
    super.onStop();
    if (asyncTaskHolder != null) {
        asyncTaskHolder.detach();
    }
}

void updateUI(String value) {
    this.result.setText(value);
}

interface ActivityDependant {

    void attach(Activity activity);

    void detach();
}

class AsyncTaskHolder implements ActivityDependant {

    private Activity parentActivity;
    private boolean isRunning;
    private boolean isUpdateOnAttach;

    @Override
    public synchronized void attach(Activity activity) {
        this.parentActivity = activity;
        if (isUpdateOnAttach) {
            ((MainActivity) parentActivity).updateUI("done");
            isUpdateOnAttach = false;
        }
    }

    @Override
    public synchronized void detach() {
        this.parentActivity = null;
    }

    public synchronized void execute() {
        if (isRunning) {
            Toast.makeText(parentActivity, "Already running", Toast.LENGTH_SHORT).show();
            return;
        }
        isRunning = true;
        new AsyncTask<Void, Integer, Void>() {

            @Override
            protected Void doInBackground(Void... params) {
                for (int i = 0; i < 100; i += 10) {
                    try {
                        Thread.sleep(500);
                        publishProgress(i);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                return null;
            }

            @Override
            protected void onProgressUpdate(Integer... values) {
                if (parentActivity != null) {
                    ((MainActivity) parentActivity).updateUI(String.valueOf(values[0]));
                }
            }

            @Override
            protected synchronized void onPostExecute(Void aVoid) {
                if (parentActivity != null) {
                    ((MainActivity) parentActivity).updateUI("done");
                } else {
                    isUpdateOnAttach = true;
                }
                isRunning = false;
            }
        }.execute();
    }
}

0

タスクの実行中にアクティビティの一時停止と再作成に関する問題を解決できるライブラリを実装しました。

とを実装する必要がAsmykPleaseWaitTaskありAsmykBasicPleaseWaitActivityます。画面を回転させてアプリケーションを切り替えても、アクティビティとバックグラウンドタスクは正常に機能します


-9

迅速な回避策(非推奨)

アクティビティを破棄してそれ自体を作成しないようにするには、アクティビティをマニフェストファイルで宣言します: android:configChanges = "orientation | keyboardHidden | screenSize

  <activity
        android:name=".ui.activity.MyActivity"
        android:configChanges="orientation|keyboardHidden|screenSize"
        android:label="@string/app_name">

ドキュメントで言及されているように

画面の向きが変わった—ユーザーがデバイスを回転させた。

注:アプリケーションがAPIレベル13以上をターゲットにしている場合(minSdkVersionおよびtargetSdkVersion属性で宣言されているとおり)、「screenSize」構成も宣言する必要があります。これは、デバイスが縦向きと横向きの間で切り替わるときにも変化するためです。


1
これは避けるのが最善です。developer.android.com/guide/topics/resources/…「注:構成の変更を自分で処理すると、システムが自動的にリソースを適用しないため、代替リソースの使用がはるかに困難になる可能性があります。この手法は最後の構成の変更による再起動を回避する必要がある場合に頼り、ほとんどのアプリケーションには推奨されません。」
David
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.