java - 当我返回 MainActivity 时，AsyncTaskLoader 不断重新加载数据

标签 java android loader asynctaskloader

我对 Android 开发很陌生，我真的需要你的帮助。我的问题出在下面的 MainActivity 中。该应用程序本质上显示主要 Activity 中的电影列表和另一个 Activity 中的电影详细信息。问题是，每当用户从 MovieActivity 返回到 MainActivity 时，加载器就会再次开始加载数据，尽管电影已经在那里。然后它就无法停止加载数据。这真的很烦人。我想摆脱这个。因此，当用户返回 MainActivity 时，加载器将知道已经加载了数据，并且不会再次加载任何内容。如果有帮助，这里是我的完整 GitHub 存储库 https://github.com/mateuszwojnarowicz/PopularMovies

我被困了大约 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) {

}
}

最佳答案

因为您是 Android 新手，所以有很多错误。所以，很多人可能不想插话。不管怎样，我也是新人，和你现在在同一个类(class)，所以我会尝试一下。

首先，您的加载程序没有返回正确的数据类型。你的加载器应该是 Loader<List<Movie>>它应该返回 new AsyncTaskLoader<List<Movie>> 。您希望这样做的原因是为了利用 AsyncTaskLoader 提供的所有功能。我会进一步解释。

其次，我们将通过将初始引用从 Activity 移动到加载器中来缓存加载器内的数据。

所以移动private ArrayList<Movie> mMoviesCollection;作为 AsyncTaskLoader 的实例变量。删除行 mMoviesCollection = new ArrayList<Movie>();来自 onCreate 和初始化方法。

在你的AsyncTaskLoader中，你需要在forceLoad之前检查你的数据是否已经存在于onStartLoading中并实现deliverResult。

因此，您的 onStartLoading() 应该如下所示:

@Override
    protected void onStartLoading() {
        super.onStartLoading();
            if(mMoviesCollection.isEmpty()){
                forceLoad();
                progressBar.setVisibility(View.VISIBLE);
                errorTextView.setVisibility(View.INVISIBLE);
            } else {
                deliverResult(mMoviesCollection)
            }
    }

您的 DeliverResult 应如下所示:

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

现在您需要实现 setData(List<Movie> movies)设置适配器的数据实例变量并调用 notifyDataSetChanged() 的方法在你的适配器中。就像这样:

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

摆脱List<Movie>来自适配器的构造函数。这样您就可以在没有任何数据的情况下构建适配器。适配器的getItemCount()如果数据为 null 并且 recyclerView 不会尝试构建 View ，则应返回 0。

完成后，您可以像这样调用 onLoadFinished:

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

编辑:进行了更正，以将 ArrayList 实例化为实例变量。您可以不在那里实例化 mMoviesCollection，然后稍后再实例化，或者只是使用 mMoviesCollection.isEmpty() 检查它是否为空，正如我在 onStartLoading 中更改的那样。:

编辑: 您需要弄清您的库，您在某些地方使用 android.app，而在其他地方使用 android.support。

因此，在您的导入中更改这些:

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;

现在 TMDB.org API 的请求限制为每 10 秒 40 个请求。 https://developers.themoviedb.org/3/getting-started/request-rate-limiting

因此，您的加载程序甚至没有完成所有操作，并且抛出异常。我建议您在将视频和评论调用到 MovieActivity 时进行分解，方法是在其中创建另一个 AsyncTaskLoader，并在详细信息屏幕加载时调用每个 AsyncTaskLoader。

从技术上讲，您还可以向 AsyncTaskLoader 添加 Thread.sleep(300) 或更少的值，但这会使其速度非常慢。换句话说，您必须将数据推送到 10 秒之后才能完全加载。

现在，有了这些以及我们所做的更改，一切都可以在配置更改(例如屏幕旋转)中继续存在。

如果你想让数据继续存在，你就必须以某种方式持久化数据。就像在 onSaveInstanceState 中将 json 响应保存为字符串或将 Json 字符串保存到您创建的数据库中一样。

关于java - 当我返回 MainActivity 时，AsyncTaskLoader 不断重新加载数据，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/51607614/

上一篇：java - Elastic Search - Java BoolQuery API 应过滤所有不匹配的内容

下一篇：java - 使用 Cloud Firestore (Android) 上的数组字段监听某些查询的更新

相关文章：

java - 这是类、构造函数还是方法？

android - 如何从 Android 中 Contentful 的空间中检索条目

drupal - 如何更改Drupal的ajax gif加载器

Android LoaderCallback 不刷新

java - 有什么方法可以预测 session 超时吗？

java - 使用套接字远程连接两台非本地计算机

Java 按字符串查找和比较成员(也许是 JPA 功能？)

android - 无法启动接收器 com.parser.Parse BroadcastReceiver : ConcurrentModificationException

android - 替代android中的水平 ScrollView

c++ - 更改 Windows DLL 加载顺序？ (加载顺序，不是搜索顺序)

©2024 IT工具网  联系我们