Java UI片段视图等待异步任务终止并查看信息

嗨，伙计们，我有个大问题。当我在MoviesFragment中单击一个按钮片段时，在MovieUtil中调用start以获取电影信息。 问题是，在视图已经加载之后，阵列才被加载。 我能做什么？代码如下：

MoviesFragment.java

package com.example.msnma.movienotifier;

import android.content.Intent;
import android.os.Bundle;
import android.support.v4.widget.SwipeRefreshLayout;
import android.support.v7.widget.GridLayoutManager;
import android.support.v7.widget.RecyclerView;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.TextView;
import android.widget.Toast;

import com.example.msnma.movienotifier.adapter.MoviesAdapter;
import com.example.msnma.movienotifier.callback.MoviesCallback;
import com.example.msnma.movienotifier.model.Movie;
import com.example.msnma.movienotifier.util.MoviesUtil;
import com.rohit.recycleritemclicksupport.RecyclerItemClickSupport;

//import org.greenrobot.eventbus.EventBus;
//import org.greenrobot.eventbus.Subscribe;

import java.text.ParseException;
import java.util.ArrayList;
import java.util.List;

import butterknife.BindView;
import butterknife.ButterKnife;
import icepick.Icepick;
import icepick.State;

public class MoviesFragment extends BaseFragment implements SwipeRefreshLayout.OnRefreshListener,
        RecyclerItemClickSupport.OnItemClickListener {
    private static final String ARG_FRAG_TYPE = "fragType";

    public enum Type {
        NOTIFY,
        SUGGESTED,
        WATCHED
    }

    @State
    ArrayList<Movie> movies;
    @State
    Type fragType;
    TextView messageIfEmpty;
    @BindView(R.id.refresh)
    SwipeRefreshLayout refreshView;
    @BindView(R.id.movies)
    RecyclerView moviesView;

    public static MoviesFragment newInstance(Type fragType) {
        MoviesFragment fragment = new MoviesFragment();
        Bundle args = new Bundle();
        args.putSerializable(ARG_FRAG_TYPE, fragType);
        fragment.setArguments(args);
        return fragment;
    }

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Icepick.restoreInstanceState(this, savedInstanceState);
        if (getArguments() != null) {
            fragType = (Type) getArguments().getSerializable(ARG_FRAG_TYPE);
        }
    }

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        View rootView = inflater.inflate(R.layout.fragment_movies_list, container, false);
        ButterKnife.bind(this, rootView);

        try {
            init();
//            updateView(rootView);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return rootView;
    }

    @Override
    public void onStart() {
        super.onStart();
//         EventBus.getDefault().register(this);
    }

    @Override
    public void onStop() {
//         EventBus.getDefault().unregister(this);
        super.onStop();
    }

    @Override
    public void onRefresh() {
        movies = null;
        try {
            updateMovies();
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void onItemClicked(RecyclerView recyclerView, int position, View v) {
        showMovieAtPosition(position);
    }

    //    @Subscribe(sticky = true)
    //    public void onEvent(UpdateFavoritesEvent event) {
    //        if (fragType == Type.FAVORITES) {
    //            EventBus.getDefault().removeStickyEvent(UpdateFavoritesEvent.class);
    //            onRefresh();
    //       }
    //    }

    //   @Subscribe(sticky = true)
    //   public void onEvent(TwoPaneEvent event) {
    //       twoPane = event.twoPane;
    //   }

    @Override
    protected void init() throws ParseException {
        RecyclerItemClickSupport.addTo(moviesView)
                .setOnItemClickListener(this);
        moviesView.setLayoutManager(new GridLayoutManager(getContext(), 2));
        moviesView.setHasFixedSize(true);
        refreshView.setOnRefreshListener(this);
        updateMovies();
    }

    private void updateMovies() throws ParseException {
        if (movies == null) {
            MoviesCallback callback = new MoviesCallback() {
                @Override
                public void success(List<Movie> result) {
                    movies = new ArrayList<>(result);
                    if (moviesView != null) {
                        moviesView.setAdapter(new MoviesAdapter(getContext(), movies));
                    }
                    refreshView.setRefreshing(false);
                }

                @Override
                public void error(Exception error) {
                    Toast.makeText(getContext(), error.getMessage(), Toast.LENGTH_SHORT).show();
                    error.printStackTrace();
                    refreshView.setRefreshing(false);
                }
            };
            switch (fragType) {
                case NOTIFY:
                    MoviesUtil.getNotifyMeMovies(getActivity(), callback, this);
                    break;
                case SUGGESTED:
                    MoviesUtil.getSuggestedMovies(getActivity(), callback, this);
                    break;
                case WATCHED:
                    MoviesUtil.getWatchedMovies(getActivity(), callback, this);
                    break;
            }
        } else if (moviesView != null) {
            moviesView.setAdapter(new MoviesAdapter(getContext(), movies));
            refreshView.setRefreshing(false);
        }
    }

    private void showMovieAtPosition(int position) {
//        if (movies != null && position <= movies.size() - 1) {
//            Movie movie = movies.get(position);
//            EventBus.getDefault().postSticky(new ShowMovieEvent(movie));
//            if (twoPane) {
//                getFragmentManager().beginTransaction()
//                        .replace(R.id.movie_detail, new MovieFragment())
        //                       .commit();
        //           } else {
        //               startActivity(new Intent(getContext(), MovieActivity.class));
        //           }
        //       }
    }

//    public void updateView(View rootView){
//        if(movies == null || movies.isEmpty()){
//            switch (fragType) {
//                case NOTIFY:
//                    moviesView = (RecyclerView)rootView.findViewById(R.id.movies);
//                    messageIfEmpty = (TextView)rootView.findViewById(R.id.empty);
//                    messageIfEmpty.setText("Search a movie or go on the suggested list for add a movie you want to be notify about!");
//                    moviesView.setVisibility(View.GONE);
//                    messageIfEmpty.setVisibility(View.VISIBLE);
//                    break;
//                case SUGGESTED:
//                     moviesView = (RecyclerView)rootView.findViewById(R.id.movies);
//                     messageIfEmpty = (TextView)rootView.findViewById(R.id.empty);
//                     messageIfEmpty.setText("No connection, please try again");
    //                    moviesView.setVisibility(View.GONE);
//                     messageIfEmpty.setVisibility(View.VISIBLE);
//                     break;
//                case WATCHED:
//                    moviesView = (RecyclerView)rootView.findViewById(R.id.movies);
//                    messageIfEmpty = (TextView)rootView.findViewById(R.id.empty);
//                    messageIfEmpty.setText("Add here movies you have watched!");
//                    moviesView.setVisibility(View.GONE);
//                    messageIfEmpty.setVisibility(View.VISIBLE);
//                    break;
//            }
//        }
//    }
}

package com.example.msnma.movienotifier.util;

import android.app.Activity;
import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.os.AsyncTask;
import android.view.View;
import android.widget.TextView;

import com.example.msnma.movienotifier.MainActivity;
import com.example.msnma.movienotifier.MovieFragment;
import com.example.msnma.movienotifier.MoviesFragment;
import com.example.msnma.movienotifier.R;
import com.example.msnma.movienotifier.callback.MoviesCallback;
import com.example.msnma.movienotifier.database.MovieDatabase;
import com.example.msnma.movienotifier.mapper.MovieMapper;
import com.example.msnma.movienotifier.model.Movie;
import com.example.msnma.movienotifier.provider.MovieContract;
import com.goebl.david.Webb;

import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

import java.text.ParseException;
import java.util.ArrayList;
import java.util.List;

public class MoviesUtil {
    private static final Webb WEBB = Webb.create();

    private static final String TMDB_API_MOVIES_URL = "http://api.themoviedb.org/3/movie/%s?api_key=%s&page=%s";
    private static final String TMDB_API_VIDEOS_URL = "http://api.themoviedb.org/3/movie/%s/videos?api_key=%s";
    private static final String TMDB_POSTER_URL = "https://image.tmdb.org/t/p/w185%s";
    private static final String TMDB_BACKDROP_URL = "https://image.tmdb.org/t/p/w300%s";

    private static final String TMDB_UPCOMING_MOVIES ="http://api.themoviedb.org/3/movie/upcoming?api_key=f329e1bdcc6da3f6ed39da7278144be6";
    private static final String TMDB_IN_THEATRES = "http://api.themoviedb.org/3/movie/now_playing?api_key=f329e1bdcc6da3f6ed39da7278144be6";

    private static final String TYPE_NOTIFY = "NOTIFY";
    private static final String TYPE_WATCHED = "WATCHED";
    private static final String TYPE_POPULAR = "popular";

    private static final MovieMapper mapper = new MovieMapper();
//    public static boolean isFavorite(Context context, Movie movie) {
//        Cursor cursor = context.getContentResolver()
//                .query(MovieContract.CONTENT_URI,
//                        null,
//                        String.format("%s = ? and %s = ?", MovieContract.MOVIE_ID, MovieContract.TYPE),
//                        new String[]{movie.getId() + "", TYPE_FAVORITES},
//                        null
//                );
//        boolean isFavorite = cursor.getCount() > 0;
//        cursor.close();
//        return isFavorite;
//    }

//    public static boolean toggleFavorite(Context context, Movie movie) {
//        if (isFavorite(context, movie)) {
//            deleteMovie(context, TYPE_FAVORITES, movie);
//            return false;
//        } else {
//            saveMovie(context, TYPE_FAVORITES, movie);
//            return true;
//        }
//    }

    public static void getNotifyMeMovies(Activity activity, MoviesCallback callback, MoviesFragment view) throws ParseException {
        getMovies(activity, TYPE_NOTIFY, callback, view);
//        List<Movie> movies = mapper.toMovieList(MainActivity.getMovieDatabase().getAllMovieByType(TYPE_NOTIFY));
    }

    public static void getSuggestedMovies(Activity activity, MoviesCallback callback, MoviesFragment view) {
        getMovies(activity, TYPE_POPULAR, callback, view);
//        getMoviesFromApi(activity, TYPE_POPULAR);
    }

    public static void getWatchedMovies(Activity activity, MoviesCallback callback, MoviesFragment view) throws ParseException {
        getMovies(activity, TYPE_WATCHED, callback, view);
//        List<Movie> movies = mapper.toMovieList(MainActivity.getMovieDatabase().getAllMovieByType(TYPE_WATCHED));
    }

    private static void getMovies(final Activity activity, final String type, final MoviesCallback callback, final MoviesFragment view) {
        AsyncTask.execute(new Runnable() {
            @Override
            public void run() {
                if (type.equals(TYPE_NOTIFY)) {
                    try {
                        mapper.toMovieList(MainActivity.getMovieDatabase().getAllMovieByType(TYPE_NOTIFY));
                    } catch (ParseException e) {
                        e.printStackTrace();
                    }
                } else if (type.equals(TYPE_WATCHED)) {
                    try {
                        mapper.toMovieList(MainActivity.getMovieDatabase().getAllMovieByType(TYPE_WATCHED));
                    } catch (ParseException e) {
                        e.printStackTrace();
                    }
                } else {
                    if (Util.isConnected(activity, false)) {
                        getMoviesFromApi(activity, TYPE_POPULAR, view);
                    }
                }
            }
        });
    }

    private static void getMoviesFromApi(Activity activity, String type, MoviesFragment view) {
        String apiUrl = String.format(TMDB_API_MOVIES_URL, type, activity.getString(R.string.tmdb_api_key), 1);
        try {
            JSONArray moviesJson = WEBB.get(apiUrl)
                    .asJsonObject()
                    .getBody()
                    .getJSONArray("results");
            List<Movie> movies = toMovies(activity, moviesJson);
            //proviamo il codice if suggested
            if(type.equals("suggested")){
                MovieDatabase.saveMoviesOnDB(movies);
            }
            deleteMovies(activity, type);
            saveMovies(activity, type, movies);
//            view.updateView(view.getView());

        } catch (JSONException e) {
            e.printStackTrace();
        }
    }

//    private static void getMoviesFromDb(Activity activity, String type, final MoviesCallback callback) {
//        try {
//            Cursor cursor = activity.getContentResolver()
//                    .query(MovieContract.CONTENT_URI,
//                            null,
//                            MovieContract.TYPE + " = ?",
//                            new String[]{type},
//                            null
//                    );
//            final List<Movie> movies = toMovies(cursor);
//            cursor.close();
//            activity.runOnUiThread(new Runnable() {
//                @Override
//                public void run() {
//                    callback.success(movies);
//                }
//            });
//        } catch (final Exception e) {
//            activity.runOnUiThread(new Runnable() {
//                @Override
//                public void run() {
//                    callback.error(e);
//                }
//            });
//        }
//    }

    //provo a sistemarlo
    private static void saveMovie(final Context context, final String type, final Movie movie) {
       AsyncTask.execute(new Runnable() {
            @Override
            public void run() {
                List<Movie> movies = new ArrayList<>();
                movies.add(movie);
                saveMovies(context, type, movies);
            }
        });
    }

    private static void saveMovies(Context context, String type, List<Movie> movies) {
        if (movies != null) {
            ContentValues[] moviesValues = new ContentValues[movies.size()];
            for (int i = 0; i < movies.size(); i++) {
                try {
                    Movie movie = movies.get(i);
                    ContentValues movieValues = new ContentValues();
                    movieValues.put(MovieContract.MOVIE_ID, movie.getId());
                    movieValues.put(MovieContract.TYPE, type);
                    movieValues.put(MovieContract.TITLE, movie.getTitle());
                    movieValues.put(MovieContract.OVERVIEW, movie.getOverview());
                    movieValues.put(MovieContract.POSTER_URL, movie.getPosterUrl());
                    movieValues.put(MovieContract.BACKDROP_URL, movie.getBackdropUrl());
                    movieValues.put(MovieContract.TRAILER_URL, movie.getTrailerUrl());
                    movieValues.put(MovieContract.RELEASE_DATE, Util.toDbDate(movie.getReleaseDate()));
                    movieValues.put(MovieContract.RATING, movie.getRating());
                    movieValues.put(MovieContract.ADULT, movie.isAdult() ? 1 : 0);
                    moviesValues[i] = movieValues;
                } catch (Exception ignore) {
                }
            }
            context.getContentResolver()
                    .bulkInsert(MovieContract.CONTENT_URI, moviesValues);
        }
    }

//    private static void deleteMovie(final Context context, final String type, final Movie movie) {
//        AsyncTask.execute(new Runnable() {
//            @Override
//            public void run() {
//                context.getContentResolver()
//                        .delete(MovieContract.CONTENT_URI,
//                                MovieContract.MOVIE_ID + " = ? and " + MovieContract.TYPE + " = ?",
//                                new String[]{movie.getId() + "", type});
//            }
//        });
//    }

    private static void deleteMovies(final Context context, final String type) {
        AsyncTask.execute(new Runnable() {
            @Override
            public void run() {
                context.getContentResolver()
                        .delete(MovieContract.CONTENT_URI,
                                MovieContract.TYPE + " = ?",
                                new String[]{type});
            }
        });
    }

    private static List<Movie> toMovies(Cursor cursor) throws ParseException {
        List<Movie> movies = new ArrayList<>();
        while (cursor.moveToNext()) {
            Movie movie = new Movie();
            movie.setId(cursor.getInt(
                    cursor.getColumnIndex(MovieContract.MOVIE_ID)));
            movie.setTitle(cursor.getString(
                    cursor.getColumnIndex(MovieContract.TITLE)));
            movie.setOverview(cursor.getString(
                    cursor.getColumnIndex(MovieContract.OVERVIEW)));
            movie.setPosterUrl(cursor.getString(
                    cursor.getColumnIndex(MovieContract.POSTER_URL)));
            movie.setBackdropUrl(cursor.getString(
                    cursor.getColumnIndex(MovieContract.BACKDROP_URL)));
            movie.setTrailerUrl(cursor.getString(
                    cursor.getColumnIndex(MovieContract.TRAILER_URL)));
            movie.setReleaseDate(Util.toDate(cursor.getString(
                    cursor.getColumnIndex(MovieContract.RELEASE_DATE))));
            movie.setRating(cursor.getFloat(
                    cursor.getColumnIndex(MovieContract.RATING)));
            movie.setAdult(cursor.getInt(
                    cursor.getColumnIndex(MovieContract.ADULT)) == 1);
            movies.add(movie);
        }
        return movies;
    }

    private static List<Movie> toMovies(Context context, JSONArray jsonMovies) {
        List<Movie> movies = new ArrayList<>();
        if (jsonMovies != null) {
            for (int i = 0; i < jsonMovies.length(); i++) {
                try {
                    JSONObject jsonMovie = jsonMovies.getJSONObject(i);
                    int movieId = jsonMovie.getInt("id");
                    Movie movie = new Movie();
                    movie.setId(movieId);
                    movie.setTitle(jsonMovie.getString("title"));
                    movie.setOverview(jsonMovie.getString("overview"));
                    movie.setPosterUrl(String.format(TMDB_POSTER_URL, jsonMovie.getString("poster_path")));
                    movie.setBackdropUrl(String.format(TMDB_BACKDROP_URL, jsonMovie.getString("backdrop_path")));
                    movie.setTrailerUrl(getTrailerUrl(context, movieId));
                    movie.setReleaseDate(Util.toDate(jsonMovie.getString("release_date")));
                    movie.setRating((float) jsonMovie.getDouble("vote_average"));
                    movie.setAdult(jsonMovie.getBoolean("adult"));
                    movies.add(movie);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
        return movies;
    }

    private static String getTrailerUrl(Context context, int movieId) {
        String apiUrl = String.format(TMDB_API_VIDEOS_URL, movieId, context.getString(R.string.tmdb_api_key));
        try {
            JSONArray trailersJson = WEBB.get(apiUrl)
                    .asJsonObject()
                    .getBody()
                    .getJSONArray("results");
            for (int i = 0; i < trailersJson.length(); i++) {
                JSONObject trailerJson = trailersJson.getJSONObject(i);
                if (trailerJson.getString("site").toLowerCase().equals("youtube")) {
                    return "https://youtube.com/watch?v=" + trailerJson.getString("key");
                }
            }
            return "";
        } catch (Exception e) {
            e.printStackTrace();
            return "";
        }
    }
}

package com.example.msnma.movienotifier；
导入android.content.Intent；
导入android.os.Bundle；
导入android.support.v4.widget.swiperFreshLayout；
导入android.support.v7.widget.GridLayoutManager；
导入android.support.v7.widget.RecyclerView；
导入android.view.LayoutInflater；
导入android.view.view；
导入android.view.ViewGroup；
导入android.widget.TextView；
导入android.widget.Toast；
导入com.example.msnma.movienotifier.adapter.MoviesAdapter；
导入com.example.msnma.movienotifier.callback.MoviesCallback；
导入com.example.msnma.movienotifier.model.Movie；
导入com.example.msnma.movienotifier.util.MoviesUtil；
导入com.rohit.recycleritemclicksupport.recycleritemclicksupport；
//导入org.greenrobot.eventbus.eventbus；
//导入org.greenrobot.eventbus.Subscribe；
导入java.text.ParseException；
导入java.util.ArrayList；
导入java.util.List；
导入butterknife.BindView；
进口毛刀，毛刀；
进口冰镐；
进口冰镐。国家；
公共类MoviesFragment扩展BaseFragment实现SwipeRefreshLayout.OnRefreshListener，
RecyclerItemClickSupport.OnItemClickListener{
私有静态最终字符串ARG_FRAG_TYPE=“fragType”；
公共枚举类型{
通知
建议，
注视
}
@陈述
ArrayList电影；
@陈述
类型fragType；
TextView messageIfEmpty；
@BindView（R.id.refresh）
SwipereRefreshView；
@BindView（R.id.movies）
回收视图电影视图；
公共静态MoviesFragment新实例（类型fragType）{
MoviesFragment=新的MoviesFragment（）；
Bundle args=新Bundle（）；
args.putSerializable（ARG_FRAG_类型，fragType）；
fragment.setArguments（args）；
返回片段；
}
@凌驾
创建时的公共void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
Icepick.restoreInstanceState（此为savedInstanceState）；
如果（getArguments（）！=null）{
fragType=（Type）getArguments（）.getSerializable（ARG_FRAG_Type）；
}
}
@凌驾
CreateView上的公共视图（布局、充气机、视图组容器、捆绑包保存状态）{
视图根视图=充气机。充气（R.layout.fragment\u movies\u list，container，false）；
ButterKnife.bind（这个，rootView）；
试一试{
init（）；
//更新视图（rootView）；
}捕获（解析异常）{
e、 printStackTrace（）；
}
返回rootView；
}
@凌驾
public void onStart（）{
super.onStart（）；
//EventBus.getDefault（）寄存器（此）；
}
@凌驾
公共void onStop（）{
//EventBus.getDefault（）.unregister（此）；
super.onStop（）；
}
@凌驾
公共void onRefresh（）{
电影=空；
试一试{
updateMovies（）；
}捕获（解析异常）{
e、 printStackTrace（）；
}
}
@凌驾
单击公共空视图（RecyclerView RecyclerView，内部位置，视图v）{
showMovieAtPosition（位置）；
}
//@Subscribe（sticky=true）
//public void onEvent（UpdateFavoritesEvent事件）{
//if（fragType==Type.FAVORITES）{
//EventBus.getDefault（）.RemovestckyEvent（UpdateFavoritesEvent.class）；
//onRefresh（）；
//       }
//    }
//@Subscribe（sticky=true）
//公共无效OneEvent（TwoPaneEvent事件）{
//twoPane=event.twoPane；
//   }
@凌驾
受保护的void init（）引发ParseException{
RecyclerItemClickSupport.addTo（moviesView）
.setOnItemClickListener（本）；
setLayoutManager（新的GridLayoutManager（getContext（），2））；
setHasFixedSize（true）；
setOnRefreshListener（这个）；
updateMovies（）；
}
私有void updateMovies（）引发ParseException{
如果（电影==null）{
MoviesCallback callback=新建MoviesCallback（）{
@凌驾
公共作废成功（列表结果）{
电影=新阵列列表（结果）；
if（moviesView！=null）{
setAdapter（新的MoviesAdapter（getContext（），movies））；
}
refreshView.setRefreshing（false）；
}
@凌驾
公共无效错误（异常错误）{
Toast.makeText（getContext（），error.getMessage（），Toast.LENGTH_SHORT）.show（）；
错误。printStackTrace（）；
refreshView.setRefreshing（false）；
}
};
开关（fragType）{
案件通知：
getNotifyMeMovies（getActivity（），回调，this）；
打破
建议的案例：
getSuggestedMovies（getActivity（），回调，this）；
打破
关注的案件：
getWatchedMovies（getActivity（），回调，this）；
打破
}
}else if（moviesView！=null）{
setAdapter（新的MoviesAdapter（getContext（），movies））；
refreshView.setRefreshing（false）；
}
}
私有void showMovieAtPosition（内部位置）{
//if（movies！=null&&position 0；
//cursor.close（）；
//返回是最喜欢的；
//    }
//公共静态布尔切换收藏夹（上下文、电影）{
//if（isFavorite（上下文、电影））{
//德