Android，AsyncTask不调用onProgressUpdate和onPostExecute

请建议我解决此问题的方法：

我无法理解为什么在执行doInBackground或onPreExecute后，AsyncTask类中的onProgressUpdate和onPostExecute没有被调用

这是我的片段类呈现Youtube播放列表，我想在其中实现ProgressBar

public class YouTubeRecyclerViewFragment extends Fragment {
// the fragment initialization parameter
private static final String ARG_YOUTUBE_PLAYLIST_IDS = "YOUTUBE_PLAYLIST_IDS";
private String[] mPlaylistIds;
private ArrayList<String> mPlaylistTitles;
//private RecyclerView mRecyclerView;
private RecyclerViewPager mRecyclerView;
private PlaylistVideos mPlaylistVideos;
private RecyclerView.LayoutManager mLayoutManager;
private PlaylistCardAdapter mPlaylistCardAdapter;
private YouTube mYouTubeDataApi;


public static YouTubeRecyclerViewFragment newInstance(YouTube youTubeDataApi, String[] playlistIds) {
    YouTubeRecyclerViewFragment fragment = new YouTubeRecyclerViewFragment();
    Bundle args = new Bundle();
    args.putStringArray(ARG_YOUTUBE_PLAYLIST_IDS, playlistIds);
    fragment.setArguments(args);
    fragment.setYouTubeDataApi(youTubeDataApi);
    return fragment;
}

public YouTubeRecyclerViewFragment() {
    // Required empty public constructor
}

public void setYouTubeDataApi(YouTube api) {
    mYouTubeDataApi = api;
}

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setRetainInstance(true);
    if (getArguments() != null) {
        mPlaylistIds = getArguments().getStringArray(ARG_YOUTUBE_PLAYLIST_IDS);
    }

    // start fetching the playlist titles
    new GetPlaylistTitlesAsyncTask(mYouTubeDataApi) {
        @Override
        protected void onPostExecute(PlaylistListResponse playlistListResponse) {
            // if we didn't receive a response for the playlist titles, then there's nothing to update
            if (playlistListResponse == null)
                return;

            mPlaylistTitles = new ArrayList();
            for (com.google.api.services.youtube.model.Playlist playlist : playlistListResponse.getItems()) {
                mPlaylistTitles.add(playlist.getSnippet().getTitle());
            }
        }
    }.execute(mPlaylistIds);
}

@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
    // set the Picasso debug indicator only for debug builds
    Picasso.with(getActivity()).setIndicatorsEnabled(BuildConfig.DEBUG);

    // Inflate the layout for this fragment
    //View rootView = inflater.inflate(R.layout.youtube_recycler_view_fragment, container, false);
    View rootView = inflater.inflate(R.layout.youtube_recycler_view_fragment, container, false);

    //mRecyclerView = (RecyclerView) rootView.findViewById(R.id.youtube_recycler_view);
    mRecyclerView = (RecyclerViewPager) rootView.findViewById(R.id.youtube_recycler_view);

    // use this setting to improve performance if you know that changes
    // in content do not change the layout size of the RecyclerView
    mRecyclerView.setHasFixedSize(true);

    Resources resources = getResources();
    if (resources.getBoolean(R.bool.isTablet)) {
        // use a staggered grid layout if we're on a large screen device
        mLayoutManager = new StaggeredGridLayoutManager(resources.getInteger(R.integer.columns), StaggeredGridLayoutManager.VERTICAL);
    } else {
        // use a linear layout on phone devices
        //mLayoutManager = new LinearLayoutManager(getActivity());
        mLayoutManager = new LinearLayoutManager(getActivity(),LinearLayoutManager.VERTICAL,false);
    }

    mRecyclerView.setLayoutManager(mLayoutManager);

    return rootView;
}

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

    // if we have a playlist in our retained fragment, use it to populate the UI
    if (mPlaylistVideos != null) {
        // reload the UI with the existing playlist.  No need to fetch it again
        reloadUi(mPlaylistVideos, false);
    } else {
        // otherwise create an empty playlist using the first item in the playlist id's array
        mPlaylistVideos = new PlaylistVideos(mPlaylistIds[0]);
        // and reload the UI with the selected playlist and kick off fetching the playlist content
        reloadUi(mPlaylistVideos, true);
    }
}

private void reloadUi(final PlaylistVideos playlistVideos, boolean fetchPlaylist) {
    // initialize the cards adapter
    initCardAdapter(playlistVideos);

    if (fetchPlaylist) {
        // start fetching the selected playlistVideos contents
        new GetPlaylistAsyncTask(mYouTubeDataApi,getContext()) {
            @Override
            public void onPostExecute(Pair<String, List<Video>> result) {
                handleGetPlaylistResult(playlistVideos, result);
            }
        }.execute(playlistVideos.playlistId, playlistVideos.getNextPageToken());
    }
}

private void initCardAdapter(final PlaylistVideos playlistVideos) {
    // create the adapter with our playlistVideos and a callback to handle when we reached the last item
    mPlaylistCardAdapter = new PlaylistCardAdapter(playlistVideos, new LastItemReachedListener() {
        @Override
        public void onLastItem(int position, String nextPageToken) {
            new GetPlaylistAsyncTask(mYouTubeDataApi,getContext()) {
                @Override
                public void onPostExecute(Pair<String, List<Video>> result) {
                    handleGetPlaylistResult(playlistVideos, result);
                }
            }.execute(playlistVideos.playlistId, playlistVideos.getNextPageToken());
        }
    });
    mRecyclerView.setAdapter(mPlaylistCardAdapter);
}

private void handleGetPlaylistResult(PlaylistVideos playlistVideos, Pair<String, List<Video>> result) {
    if (result == null) return;
    final int positionStart = playlistVideos.size();
    playlistVideos.setNextPageToken(result.first);
    playlistVideos.addAll(result.second);
    mPlaylistCardAdapter.notifyItemRangeInserted(positionStart, result.second.size());
}

/**
 * Interface used by the {@link PlaylistCardAdapter} to inform us that we reached the last item in the list.
 */
public interface LastItemReachedListener {
        void onLastItem(int position, String nextPageToken);
    }
}

公共类youtuberecycleservicewfragment扩展了片段{
//片段初始化参数
私有静态最终字符串ARG\u YOUTUBE\u PLAYLIST\u id=“YOUTUBE\u PLAYLIST\u id”；
私有字符串[]mPlaylistIds；
私人ArrayList-EmplayListTitles；
//私人回收视图mRecyclerView；
私人回收服务管理员mRecyclerView；
私人播放视频mPlaylistVideos；
private RecyclerView.LayoutManager MLLayoutManager；
私人播放卡适配器mplaylistcardapter；
私有YouTube mYouTubeDataApi；
公共静态YouTubeCyclerServiceWfragment新实例（YouTube youTubeDataApi，字符串[]播放ID）{
YouTubeRecyclerViewFragment=新的YouTubeRecyclerViewFragment（）；
Bundle args=新Bundle（）；
args.putStringArray（ARG_YOUTUBE_PLAYLIST_id，playlistid）；
fragment.setArguments（args）；
setYouTubeDataApi（youTubeDataApi）；
返回片段；
}
公共YouTuberCyclerServicewFragment（）{
//必需的空公共构造函数
}
公共无效设置YouTubeDataAPI（YouTube api）{
mYouTubeDataApi=api；
}
@凌驾
创建时的公共void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
setRetainInstance（真）；
如果（getArguments（）！=null）{
mPlaylistIds=getArguments（）.getStringArray（ARG\u YOUTUBE\u播放列表\u id）；
}
//开始获取播放列表标题
新的GetPlaylistTitleAsyncTask（mYouTubeDataApi）{
@凌驾
受保护的void onPostExecute（playlistresponse playlistresponse）{
//如果我们没有收到播放列表标题的响应，那么就没有什么可更新的
if（playlistresponse==null）
返回；
mPlaylistTitles=newarraylist（）；
对于（com.google.api.services.youtube.model.Playlist播放列表：playlistresponse.getItems（））{
添加（playlist.getSnippet（）.getTitle（））；
}
}
}.execute（mPlaylistIds）；
}
@凌驾
CreateView上的公共视图（布局、充气机、视图组容器、捆绑包保存状态）{
//仅为调试版本设置毕加索调试指示器
Picasso.with（getActivity（））.setIndicatorEnabled（BuildConfig.DEBUG）；
//为该碎片膨胀布局
//View rootView=inflater.inflate（R.layout.youtube\u recycler\u View\u片段，容器，false）；
View rootView=inflater.inflate（R.layout.youtube\u recycler\u View\u片段，容器，false）；
//mRecyclerView=（RecyclerView）rootView.findviewbyd（R.id.youtube\u recycler\u view）；
mRecyclerView=（recyclerviewpage）rootView.findviewbyd（R.id.youtube\u recycler\u视图）；
//如果您知道这些更改，请使用此设置提高性能
//在内容中，不要更改RecyclerView的布局大小
mRecyclerView.setHasFixedSize（true）；
Resources=getResources（）；
if（resources.getBoolean（R.bool.isTablet））{
//如果我们在大屏幕设备上，请使用交错网格布局
mLayoutManager=new-staggedGridLayoutManager（resources.getInteger（R.integer.columns），staggedGridLayoutManager.VERTICAL）；
}否则{
//在电话设备上使用线性布局
//mLayoutManager=新的LinearLayoutManager（getActivity（））；
mLayoutManager=newlinearlayoutmanager（getActivity（），LinearLayoutManager.VERTICAL，false）；
}
mRecyclerView.setLayoutManager（mllayoutmanager）；
返回rootView；
}
@凌驾
已创建ActivityState上的公共无效（Bundle savedInstanceState）{
super.onActivityCreated（savedInstanceState）；
//如果我们保留的片段中有一个播放列表，则使用它填充UI
如果（mPlaylistVideos！=null）{
//使用现有播放列表重新加载UI。无需再次获取它
重新加载UI（mPlaylistVideos，false）；
}否则{
//否则，使用播放列表id数组中的第一项创建空播放列表
mPlaylistVideos=新播放视频（mPlaylistIds[0]）；
//然后使用所选播放列表重新加载UI，并开始获取播放列表内容
重新加载用户界面（mPlaylistVideos，true）；
}
}
private void reloadUi（最终播放视频，布尔获取播放列表）{
//初始化卡适配器
initCardAdapter（播放视频）；
如果（获取播放列表）{
//开始提取所选播放视频内容
新的GetPlayAsyncTask（mYouTubeDataApi，getContext（））{
@凌驾
public void onPostExecute（配对结果）{
HandleGetPlayResult（播放视频、结果）；
}
}.execute（playlivides.playlyid，playlivides.getNextPageToken（））；
}
}
专用void initCardAdapter（最终播放视频）{
//创建带有播放视频的适配器，并在到达最后一项时处理回调
mplaylistcardapter=new playlistcardapter（播放视频，new LastItemReachedListener（））{
@凌驾
public void onLastItem（int位置，字符串nextpGetOken）{
新的GetPlayAsyncTask（mYouTubeDataApi，getContext（））{
@凌驾
public void onPostExecute（配对结果）{
HandleGetPlayResult（播放视频、结果）；
}
}.execute（playlivides.playlyid，playlivides.getNextPageToken（））；
}
});
mRecyclerView.setAdapter（mplaylistcardapter）；
}
private void HandleGetPlayResult（播放视频播放视频，配对结果）{
if（result==null）返回；
final int positionStart=playlives.size（）；
playlives.setNextPageToken（result.first）；
播放视频
public abstract class GetPlaylistAsyncTask extends AsyncTask<String, Void, Pair<String, List<Video>>> {
private static final String TAG = "GetPlaylistAsyncTask";
private static final Long YOUTUBE_PLAYLIST_MAX_RESULTS = 10L;

//see: https://developers.google.com/youtube/v3/docs/playlistItems/list
private static final String YOUTUBE_PLAYLIST_PART = "snippet";
private static final String YOUTUBE_PLAYLIST_FIELDS = "pageInfo,nextPageToken,items(id,snippet(resourceId/videoId))";
//see: https://developers.google.com/youtube/v3/docs/videos/list
private static final String YOUTUBE_VIDEOS_PART = "snippet,contentDetails,statistics"; // video resource properties that the response will include.
private static final String YOUTUBE_VIDEOS_FIELDS = "items(id,snippet(title,description,thumbnails/high),contentDetails/duration,statistics)"; // selector specifying which fields to include in a partial response.

private YouTube mYouTubeDataApi;
Context mContext;
ProgressDialog progressBar;


public GetPlaylistAsyncTask(YouTube api, Context context) {
    mYouTubeDataApi = api;
    mContext = context;
    progressBar = new ProgressDialog(mContext);
}

@Override
protected Pair<String, List<Video>> doInBackground(String... params) {
    final String playlistId = params[0];
    final String nextPageToken;

    if (params.length == 2) {
        nextPageToken = params[1];
    } else {
        nextPageToken = null;
    }

    PlaylistItemListResponse playlistItemListResponse;
    try {
        playlistItemListResponse = mYouTubeDataApi.playlistItems()
                .list(YOUTUBE_PLAYLIST_PART)
                .setPlaylistId(playlistId)
                .setPageToken(nextPageToken)
                .setFields(YOUTUBE_PLAYLIST_FIELDS)
                .setMaxResults(YOUTUBE_PLAYLIST_MAX_RESULTS)
                .setKey(ApiKey.YOUTUBE_API_KEY)
                .execute();
    } catch (IOException e) {
        e.printStackTrace();
        return null;
    }

    if (playlistItemListResponse == null) {
        Log.e(TAG, "Failed to get playlist");
        return null;
    }

    List<String> videoIds = new ArrayList();

    // pull out the video id's from the playlist page
    for (PlaylistItem item : playlistItemListResponse.getItems()) {
        videoIds.add(item.getSnippet().getResourceId().getVideoId());
    }

    // get details of the videos on this playlist page
    VideoListResponse videoListResponse = null;
    try {
        videoListResponse = mYouTubeDataApi.videos()
                .list(YOUTUBE_VIDEOS_PART)
                .setFields(YOUTUBE_VIDEOS_FIELDS)
                .setKey(ApiKey.YOUTUBE_API_KEY)
                .setId(TextUtils.join(",", videoIds)).execute();
    } catch (IOException e) {
        e.printStackTrace();
    }

    return new Pair(playlistItemListResponse.getNextPageToken(), videoListResponse.getItems());
}

@Override
protected void onPreExecute() {
    progressBar = new ProgressDialog(mContext);
    progressBar.setCancelable(true);
    progressBar.setMessage("Processing Request");
    progressBar.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
    progressBar.setIndeterminate(true);
    progressBar.show();
}

@Override
protected void onProgressUpdate(Void... values) {
    progressBar.setMessage("I have found :");
}

@Override
protected void onPostExecute(Pair<String, List<Video>> stringListPair) {
        progressBar.dismiss();
    }
}

 new GetPlaylistAsyncTask(mYouTubeDataApi,getContext()) {
            @Override
            public void onPostExecute(Pair<String, List<Video>> result) {
                handleGetPlaylistResult(playlistVideos, result);
            }
        }.execute(playlistVideos.playlistId, playlistVideos.getNextPageToken());

 new GetPlaylistAsyncTask(mYouTubeDataApi,getContext(),YouTubeRecyclerViewFragment.this)
          .execute(playlistVideos.playlistId, playlistVideos.getNextPageToken());

    @Override
    public void handleGetPlaylistResult(PlaylistVideos playlistVideos, Pair<String, List<Video>> result) {
        if (result == null) return;
        if (playlistVideos == null){
             playlistVideos = mPlaylistVideos;
        }
        final int positionStart = playlistVideos.size();
        playlistVideos.setNextPageToken(result.first);
        playlistVideos.addAll(result.second);
        mPlaylistCardAdapter.notifyItemRangeInserted(positionStart, result.second.size());
    }

 public class GetPlaylistAsyncTask{

 private AsyncResponse theListener;

 public GetPlaylistAsyncTask(YouTube api, Context context, YouTubeRecyclerViewFragment frag ) {
    mYouTubeDataApi = api;
    mContext = context;
    theListener = (AsyncResponse)frag;
 }

 @Override
       public void onPostExecute(Pair<String, List<Video>> result) {
          progressBar.dismiss();
          theListener.handleGetPlaylistResult(null,result);
      }
}