Java AsyncTaskLoader在我返回Main活动时不断重新加载数据

我对Android的开发还很陌生，我真的需要你的帮助。我的问题在下面的

main活动中。该应用程序基本上在主活动中显示电影列表，在另一个活动中显示电影详细信息。问题是，每当用户从
MovieActivity
返回到
MainActivity
，加载程序就会再次开始加载数据，尽管电影已经在那里了。然后它不能停止加载数据。真烦人。我想摆脱这个。因此，当用户返回MainActivity时，加载程序将知道已经加载了数据，并且不会再加载任何内容。如果有帮助，下面是我的完整GitHub repo

我被困了大约3周，尝试了数百种可能的解决方案。似乎什么都不管用。我感到非常绝望

非常感谢你的帮助

马修

public class MainActivity extends AppCompatActivity implements LoaderManager.LoaderCallbacks<String> {

private MovieAdapter mAdapter;
private ArrayList<Movie> mMoviesCollection;
private SharedPreferences sharedPreferences;
private Resources resources;
private LoaderManager loaderManager;
private Loader<String> loader;
private RecyclerView.LayoutManager layoutManager;
private String sortBy;

@BindView(R.id.pb)
ProgressBar progressBar;
@BindView(R.id.er)
TextView errorTextView;
@BindView(R.id.rv)
RecyclerView recyclerView;



@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    ButterKnife.bind(this);
    mMoviesCollection = new ArrayList<Movie>();
    sharedPreferences = getSharedPreferences(Constants.SHARED_PREFS, Activity.MODE_PRIVATE);
    resources = getResources();
    sortBy = sharedPreferences.getString(Constants.KEY_SORT, null);
    setSharedPref();

    layoutManager = new GridLayoutManager(this, calculateNoOfColumns(this));
    loaderManager = getLoaderManager();
    loader = loaderManager.getLoader(Constants.LOADER_MOVIES_ID);
    initialize();
    makeOperationLoadMovies(sortBy);

}

public static int calculateNoOfColumns(Context context) {
    DisplayMetrics displayMetrics = context.getResources().getDisplayMetrics();
    float dpWidth = displayMetrics.widthPixels / displayMetrics.density;
    int noOfColumns = (int) (dpWidth / 150);
    return noOfColumns;
}


//Set first-launch pref and set title according to pref
private void setSharedPref(){
    if(!sharedPreferences.contains(Constants.KEY_SORT)) {
        saveData(Constants.VALUE_POP);
        setTitle(resources.getString(R.string.title_pop));
    } else {
        if (Objects.equals(sharedPreferences.getString(Constants.KEY_SORT, null), Constants.VALUE_POP)) {
            setTitle(resources.getString(R.string.title_pop));
        }
        if (Objects.equals(sharedPreferences.getString(Constants.KEY_SORT, null), Constants.VALUE_TOP)) {
            setTitle(resources.getString(R.string.title_top));
        }
    }
}

//Set up the RecyclerView
private void initialize(){
    recyclerView.setLayoutManager(layoutManager);
    recyclerView.setHasFixedSize(true);
    mMoviesCollection = new ArrayList<>();
    mAdapter = new MovieAdapter(mMoviesCollection, this, this);
    recyclerView.setAdapter(mAdapter);
}

private void makeOperationLoadMovies(String SORT_BY){
    Bundle bundle = new Bundle();
    bundle.putString(Constants.LOADER_MOVIES_EXTRA, SORT_BY);
    if(recyclerView.isDirty()){

    }
    else if(loader==null){
        loaderManager.initLoader(Constants.LOADER_MOVIES_ID, bundle, this);
    }else{
        loaderManager.restartLoader(Constants.LOADER_MOVIES_ID, bundle, this);
    }

}

//Update shared pref
private void saveData(String SORT_VALUE){
    SharedPreferences.Editor editor = sharedPreferences.edit();
    editor.putString(Constants.KEY_SORT, SORT_VALUE);
    editor.apply();
}

@Override
public boolean onCreateOptionsMenu(Menu menu) {
    MenuInflater inflater = getMenuInflater();
    inflater.inflate(R.menu.main, menu);
    return true;
}

@Override
public boolean onOptionsItemSelected(MenuItem item) {
    int id = item.getItemId();

    switch (id){
        case R.id.menu_fav:
            startActivity(new Intent(MainActivity.this, FavoritesActivity.class));
            break;
        case R.id.menu_pop:
            saveData(Constants.VALUE_POP);
            Toast.makeText(this, resources.getString(R.string.message_popularity),Toast.LENGTH_LONG).show();
            break;
        case R.id.menu_top:
            saveData(Constants.VALUE_TOP);
            Toast.makeText(this, resources.getString(R.string.message_rating),Toast.LENGTH_LONG).show();
            break;
    }

    return super.onOptionsItemSelected(item);
}

@Override
protected void onPause() {
    super.onPause();
    Parcelable recyclerViewState;
    recyclerViewState = recyclerView.getLayoutManager().onSaveInstanceState();//save
    recyclerView.getLayoutManager().onRestoreInstanceState(recyclerViewState);
}

@Override
protected void onPostResume() {
    super.onPostResume();
    Parcelable recyclerViewState;
    recyclerViewState = recyclerView.getLayoutManager().onSaveInstanceState();//save
    recyclerView.getLayoutManager().onRestoreInstanceState(recyclerViewState);

}

@SuppressLint("StaticFieldLeak")
@Override
public Loader<String> onCreateLoader(int id, final Bundle args) {
    return new AsyncTaskLoader<String>(this) {


        @Override
        protected void onStartLoading() {
            super.onStartLoading();
                forceLoad();
                progressBar.setVisibility(View.VISIBLE);
                errorTextView.setVisibility(View.INVISIBLE);

        }

        @Override
        public void deliverResult(String data) {
            super.deliverResult(data);
        }

        @Override
        public String loadInBackground() {



            String jsonString = "";
            URL url = NetworkUtils.buildUrl(args.getString(Constants.LOADER_MOVIES_EXTRA));
            try {
                jsonString += NetworkUtils.getResponseFromHttpUrl(url);
            } catch (IOException e) {
                e.printStackTrace();
            }


            if(jsonString.isEmpty()){


            } else {

                try {
                    JSONObject jsonObject = new JSONObject(jsonString);
                    JSONArray jsonArray = jsonObject.getJSONArray(Constants.JSON_KEY_MOVIE_RESULTS);
                    for (int i = 0; i < jsonArray.length(); i++) {
                        //Get 1 movie from JSON
                        String mTitle;
                        int mId;
                        String mPosterUrl;
                        String mPlot;
                        double mUserRating;
                        String mReleaseDate;

                        JSONObject Jmovie = (JSONObject) jsonArray.get(i);
                        mTitle = Jmovie.getString(Constants.JSON_KEY_MOVIE_TITLE);
                        mId = Jmovie.getInt(Constants.JSON_KEY_MOVIE_ID);
                        mPosterUrl = NetworkUtils.getPosterString(Jmovie.getString(Constants.JSON_KEY_MOVIE_POSTER_PATH));
                        mPlot = Jmovie.getString(Constants.JSON_KEY_MOVIE_OVERVIEW);
                        mUserRating = Jmovie.getDouble(Constants.JSON_KEY_MOVIE_VOTE_AVERAGE);
                        mReleaseDate = Jmovie.getString(Constants.JSON_KEY_MOVIE_RELEASE_DATE);
                        //Get videos
                        ArrayList<Video> mVideos = new ArrayList<Video>();
                        URL videosURL = NetworkUtils.buildUrlVideos(String.valueOf(mId));
                        String videosJSON = NetworkUtils.getResponseFromHttpUrl(videosURL);
                        JSONObject jsonObjectVideos = new JSONObject(videosJSON);
                        JSONArray jsonArrayVideos = jsonObjectVideos.getJSONArray(Constants.JSON_KEY_VIDEO_RESULTS);
                        if(jsonArrayVideos.length()==0){
                            mVideos = null;
                        } else {
                            for(int v = 0; v < jsonArrayVideos.length(); v++){
                                JSONObject Jvideo = (JSONObject) jsonArrayVideos.get(v);
                                String mVideoName;
                                String mVideoUrlString;
                                mVideoName = Jvideo.getString(Constants.JSON_KEY_VIDEO_NAME);
                                mVideoUrlString = "https://www.youtube.com/watch?v="+Jvideo.getString(Constants.JSON_KEY_VIDEO_KEY);
                                Video video = new Video(mVideoName, mVideoUrlString);
                                mVideos.add(video);
                            }
                        }
                        //GetReviews
                        ArrayList<Review> mReviews = new ArrayList<Review>();
                        URL reviewsURL = NetworkUtils.buildUrlReviews(String.valueOf(mId));
                        String reviewsJSON = NetworkUtils.getResponseFromHttpUrl(reviewsURL);
                        JSONObject jsonObjectReviews = new JSONObject(reviewsJSON);
                        JSONArray jsonArrayReviews = jsonObjectReviews.getJSONArray(Constants.JSON_KEY_REVIEW_RESULTS);
                        if(jsonArrayReviews.length()!=0) {
                            for(int r = 0; r < jsonArrayReviews.length(); r++){
                                JSONObject Jreview = (JSONObject) jsonArrayReviews.get(r);
                                String mReviewName;
                                String mReviewText;
                                mReviewName = Jreview.getString(Constants.JSON_KEY_REVIEW_AUTHOR);
                                mReviewText = Jreview.getString(Constants.JSON_KEY_REVIEW_CONTENT);
                                Review review = new Review(mReviewName, mReviewText);
                                mReviews.add(review);
                            }
                        }
                        Movie movie = new Movie(mTitle, mId, mPosterUrl, mPlot, mUserRating, mReleaseDate, mVideos, mReviews);
                        mMoviesCollection.add(movie);
                    }
                } catch (JSONException e) {
                    e.printStackTrace();
                } catch (IOException e){
                    e.printStackTrace();
                }
            }
            return null;
        }


    };
}

@Override
public void onLoadFinished(Loader<String> loader, String data) {

    progressBar.setVisibility(View.GONE);

    mAdapter.notifyDataSetChanged();
}

@Override
public void onLoaderReset(Loader<String> loader) {

}
}

public类MainActivity扩展AppCompatActivity实现LoaderManager.LoaderCallbacks{
私人电影公司；
私人ArrayList mMoviesCollection；
私人共享引用共享引用；
私人资源；
专用LoaderManager LoaderManager；
私人装载机；
private RecyclerView.LayoutManager LayoutManager；
私人字符串排序；
@BindView（R.id.pb）
ProgressBar ProgressBar；
@BindView（R.id.er）
文本视图错误文本视图；
@BindView（R.id.rv）
回收视图回收视图；
@凌驾
创建时受保护的void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
setContentView（R.layout.activity_main）；
把（这个）绑起来；
mmoviescolection=newarraylist（）；
sharedPreferences=getSharedPreferences（Constants.SHARED\u PREFS，Activity.MODE\u PRIVATE）；
resources=getResources（）；
sortBy=SharedReferences.getString（Constants.KEY\u SORT，null）；
setSharedPref（）；
layoutManager=new GridLayoutManager（this，CalculateNofColumns（this））；
loaderManager=getLoaderManager（）；
loader=loaderManager.getLoader（常量.loader\u\u ID）；
初始化（）；
制作操作加载电影（sortBy）；
}
公共静态列的int计算（上下文）{
DisplayMetrics DisplayMetrics=context.getResources（）.getDisplayMetrics（）；
float dpWidth=displayMetrics.widthPixels/displayMetrics.density；
int noOfColumns=（int）（dpWidth/150）；
返回noOfColumns；
}
//设置首次启动优先级并根据优先级设置标题
私有void setSharedPref（）{
如果（！SharedReferences.contains（Constants.KEY\u SORT））{
保存数据（常量值\u POP）；
setTitle（resources.getString（R.string.title_pop））；
}否则{
if（Objects.equals（SharedReferences.getString（Constants.KEY\u SORT，null），Constants.VALUE\u POP））{
setTitle（resources.getString（R.string.title_pop））；
}
if（Objects.equals（SharedReferences.getString（Constants.KEY\u SORT，null），Constants.VALUE\u TOP））{
setTitle（resources.getString（R.string.title_top））；
}
}
}
//设置RecyclerView
私有void初始化（）{
recyclerView.setLayoutManager（layoutManager）；
recyclerView.setHasFixedSize（true）；
mmoviescolection=newarraylist（）；
mAdapter=新电影适配器（mMoviesCollection，this，this）；
recyclerView.setAdapter（mAdapter）；
}
私有void makeOperationLoadMovies（字符串排序依据）{
Bundle=新Bundle（）；
bundle.putString（Constants.LOADER\u MOVIES\u EXTRA，SORT\u BY）；
if（recyclerView.isDirty（））{
}
else if（loader==null）{
initLoader（Constants.LOADER\u MOVIES\u ID，bundle，this）；
}否则{
loaderManager.restartLoader（Constants.LOADER\u MOVIES\u ID，bundle，this）；
}
}
//更新共享pref
私有void saveData（字符串排序值）{
SharedReferences.Editor=SharedReferences.edit（）；
编辑器.putString（Constants.KEY\u SORT，SORT\u VALUE）；
editor.apply（）；
}
@凌驾
公共布尔onCreateOptions菜单（菜单）{
MenuInflater充气机=getMenuInflater（）；
充气机。充气（右菜单。主菜单，菜单）；
返回true；
}
@凌驾
公共布尔值onOptionsItemSelected（菜单项项）{
int id=item.getItemId（）；
开关（id）{
案例R.id.menu\U fav：
startActivity（新意图（MainActivity.this、FavoritesActivity.class））；
打破
案例R.id.菜单\u弹出：
保存数据（常量值\u POP）；
Toast.makeText（this，resources.getString（R.string.message_popularity），Toast.LENGTH_LONG.show（）；
打破
案例R.id.菜单\顶部：
保存数据（常量值\顶部）；
Toast.makeText（this，resources.getString（R.string.message_rating），Toast.LENGTH_LONG.show（）；
打破
}
返回super.onOptionsItemSelected（项目）；
}
@凌驾
受保护的void onPause（）{
super.onPause（）；
可包裹的可回收物；
recyclerViewState=recyclerView.getLayoutManager（）.onSaveInstanceState（）；//保存
RecycleView.getLayoutManager（）.onRestoreInstanceState（RecycleViewState）；
}
@凌驾
PostResume（）上的受保护无效{
super.onPostResume（）；
可包裹的可回收物；
recyclerViewState=recyclerView.getLayoutManager（）.onSaveInstanceState（）；//保存
RecycleView.getLayoutManager（）.onRestoreInstanceState（RecycleViewState）；
}
@SuppressLint（“StaticFieldLeak”）
@凌驾
公共加载器onCreateLoader（int-id，final Bundle-args）{
返回新的AsyncTaskLoader（此）{
@凌驾
开始加载时受保护的void（）{
super.onStartLoading（）；
力载荷（）；
progressBar.setVisibility（View.VISIBLE）；
errorTextView.setVisibility（视图.不可见）；
}
@凌驾
公共void deliverResult（字符串数据）{
super.deliverResult（数据）；
}
@凌驾
公共字符串loadInBackground（）{
字符串jsonString=“”；
URL URL=NetworkUtils.buildUrl（args.getString（常量
@Override
    protected void onStartLoading() {
        super.onStartLoading();
            if(mMoviesCollection.isEmpty()){
                forceLoad();
                progressBar.setVisibility(View.VISIBLE);
                errorTextView.setVisibility(View.INVISIBLE);
            } else {
                deliverResult(mMoviesCollection)
            }
    }

@Override
    public void deliverResult(List<Movie> data) {
        mMoviesCollection = data;
        super.deliverResult(data);
    }

public void setData(List<Movie> movies){
    mMovies = movies;
    notifyDataSetChanged();
}

@Override
    public void onLoadFinished(Loader<List<Movie>> loader, List<Movie> data) {
        progressBar.setVisibility(View.GONE);
        mAdapter.setData(data);
    }

import android.app.LoaderManager;
import android.content.AsyncTaskLoader;
import android.content.Loader;

import android.support.v4.app.LoaderManager;
import android.support.v4.content.AsyncTaskLoader;
import android.support.v4.content.Loader;