列表中的视频播放----滑动播放

效果如上图

第一步：添加依赖，集成别人的

compile 'fm.jiecao:jiecaovideoplayer:4.8.3'

第二步：构建列表，写适配器

public class TrainRecommendFragment extends BaseFragment {

   
    private ListView listView;
    private ProgressBar bar;
    private View mMainToolbar;
    private float mStartY = 0, mLastY = 0, mLastDeltaY;
    private TrainRecommend trainRecommend;//获取到的数据类
  
    private TrainRecommendAdapter adapter;
   
    private VdieoBean videopBean;

    private VideoAdapter adapters;

    private View no_msg;//暂无数据界面
    private View error_msg;//加载失败
    private TextView init_tv;//重新加载
    private boolean isS = false;//是否已经成功加载数据

    @Override
    public int getLayoutId() {
        return R.layout.fragment_train_recommend;
    }

    @Override
    public void initViews() {
        listView = findView(R.id.list);
        bar = findView(R.id.bar);

        no_msg = findView(R.id.no_msg);
        error_msg = findView(R.id.error_msg);
        init_tv = findView(R.id.init_tv);

        View header = LayoutInflater.from(getActivity())
                .inflate(R.layout.title_head, null);//这个header高度要与toolbar相同
        listView.addHeaderView(header);

        // 向上滑动隐藏，向下展示
        TrainingCampActivity activity = (TrainingCampActivity) getActivity();
        mMainToolbar = activity.getView();
        listView.setOnTouchListener(new View.OnTouchListener() {
            @Override
            public boolean onTouch(View v, MotionEvent event) {
                final float y = event.getY();
                float translationY = mMainToolbar.getTranslationY();
                switch (event.getAction()) {
                    case MotionEvent.ACTION_DOWN:
                        mStartY = y;
                        mLastY = mStartY;
                        break;
                    case MotionEvent.ACTION_MOVE:
                        float mDeltaY = y - mLastY;

                        float newTansY = translationY + mDeltaY;
                        if (newTansY <= 0 && newTansY >= -mMainToolbar.getHeight()) {
                            mMainToolbar.setTranslationY(newTansY);
                        }
                        mLastY = y;
                        mLastDeltaY = mDeltaY;
                        break;
                    case MotionEvent.ACTION_UP:
                        ObjectAnimator animator = null;
                        Log.d("--main--", "mLastDeltaY=" + mLastDeltaY);
                        if (mLastDeltaY < 0 && listView.getFirstVisiblePosition() > 0) {
                            Log.v("--main--",
                                    "listView.first=" + listView.getFirstVisiblePosition());
                            animator = ObjectAnimator.ofFloat(mMainToolbar, "translationY",
                                    mMainToolbar.getTranslationY(), -mMainToolbar.getHeight());
                        } else {
                            animator = ObjectAnimator.ofFloat(mMainToolbar, "translationY",
                                    mMainToolbar.getTranslationY(), 0);
                        }
                        animator.setDuration(100);
                        animator.start();
                        animator.setInterpolator(AnimationUtils.loadInterpolator(getActivity(),
                                android.R.interpolator.linear));
                        break;
                }
                return false;
            }
        });
        //请求数据
        initData();

        initListeners();
    }

    @Override
    public void initListener() {
        setOnClick(init_tv);
    }

    @Override
    public void initData() {
     

//网络请求的数据，自己用自己的方法写
                                                List<TrainRecommend.DataBean.ListBean> list =
                                        trainRecommend.getData().getList();

String vids = null;
//获取视频播放的url
 vids = list.get(i).getTidbitsVid()；}
public interface GetView {
        View getView();
    }


    /**
     * 滑动监听
     */
    private void initListeners() {
        onScrollListener = new AbsListView.OnScrollListener() {
            @Override
            public void onScrollStateChanged(AbsListView view, int scrollState) {

                switch (scrollState) {
                    case AbsListView.OnScrollListener.SCROLL_STATE_FLING:
                        break;

                    case AbsListView.OnScrollListener.SCROLL_STATE_IDLE:
                        //滑动停止自动播放视频
                        autoPlayVideo(view);
                        break;

                    case AbsListView.OnScrollListener.SCROLL_STATE_TOUCH_SCROLL:
                        break;
                }
            }

            @Override
            public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) {
                if (firstVisible == firstVisibleItem) {
                    return;
                }

                firstVisible = firstVisibleItem;
                visibleCount = visibleItemCount;
            }
        };

        listView.setOnScrollListener(onScrollListener);
    }

    /**
     * 滑动停止自动播放视频
     */

    private AbsListView.OnScrollListener onScrollListener;
    private int firstVisible;//当前第一个可见的item
    private int visibleCount;//当前可见的item个数
    private JCVideoPlayerStandard currPlayer;

    private void autoPlayVideo(AbsListView view) {

        for (int i = 0; i < visibleCount; i++) {
            if (view != null && view.getChildAt(i) != null && view.getChildAt(i).findViewById(R.id.player_list_video) != null) {
                currPlayer = (JCVideoPlayerStandard) view.getChildAt(i).findViewById(R.id.player_list_video);
                Rect rect = new Rect();
                //获取当前view 的 位置
                currPlayer.getLocalVisibleRect(rect);
                int videoheight = currPlayer.getHeight();
                if (rect.top == 0 && rect.bottom == videoheight) {
                    if (currPlayer.currentState == JCVideoPlayer.CURRENT_STATE_NORMAL
                            || currPlayer.currentState == JCVideoPlayer.CURRENT_STATE_ERROR) {
                        currPlayer.startButton.performClick();
                    }
                    return;
                }
            }
        }
        //释放其他视频资源
        JCVideoPlayer.releaseAllVideos();
    }

    @Override
    public void onPause() {
        super.onPause();
        JCVideoPlayer.releaseAllVideos();
    }

}
第三步：fragment的布局文件
<ListView
   android:id="@+id/list"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:paddingLeft="10dp"
    android:paddingRight="10dp"
    android:scrollbars="none" />
第四步：adapter构建--复制粘贴直接用
public class TrainRecommendAdapter extends BaseAdapter
        implements View.OnClickListener, DWMediaPlayer.OnBufferingUpdateListener,
        DWMediaPlayer.OnInfoListener, DWMediaPlayer.OnPreparedListener,
        DWMediaPlayer.OnErrorListener, SurfaceHolder.Callback, SensorEventListener,
        MediaPlayer.OnCompletionListener {
    private int mX, mY, mZ;
    private long lastTimeStamp = 0;
    private Calendar mCalendar;
    private Map<String, Integer> definitionMap;
    int currentPosition;
    private SensorManager sensorManager;
    private DWMediaPlayer player;
    private Context context;
    private List<TrainRecommend.DataBean.ListBean> list;
    private String urlTitle;
    private WindowManager wm;
    private boolean isPrepared;
    private boolean networkConnected = true;
    private int maxVolume;
    
    private int currentVolume;
    private Timer timer = new Timer();
    private float scrollTotalDistance;
    ConnectivityManager cm;
    // 当player未准备好，并且当前activity经过onPause()生命周期时，此值为true
    private boolean isFreeze = false;
    // 默认设置为普清
    private int defaultDefinition = DWMediaPlayer.NORMAL_DEFINITION;
    private GestureDetector detector;
   
    private Handler playerHandler;
    private int lastPlayPosition, currentPlayPosition;

    private Boolean isPlaying;
    private TimerTask timerTask, networkInfoTimerTask;
   
    private AudioManager audioManager;
   
    private boolean isSurfaceDestroy = false;
    // 控制播放器面板显示
    private boolean isDisplay = false;
    private int playerIngIndex = -1;
    private boolean isBackupPlay;
    ViewHolder viewHolder;
    String videoids;
    // 隐藏界面的线程
    private Runnable hidePlayRunnable = new Runnable() {
        @Override public void run() {
            setLayoutVisibility(View.GONE, false);
        }
    };


    public TrainRecommendAdapter(Context context, List<TrainRecommend.DataBean.ListBean> list,
            String urlTitle) {
        this.context = context;
        this.list = list;
        this.urlTitle = urlTitle;

        // 初始化 DWMediaPlayer
        if (player == null) {
            player = new DWMediaPlayer();
        }
        player.setDefaultDefinition(DWMediaPlayer.NORMAL_DEFINITION);
        player.setOnPreparedListener(TrainRecommendAdapter.this);
        player.setAudioStreamType(AudioManager.STREAM_MUSIC);
        player.setOnBufferingUpdateListener(TrainRecommendAdapter.this);
        player.setScreenOnWhilePlaying(true);
        player.setHttpsPlay(false);
        // 设置默认清晰度
        player.setDefaultDefinition(defaultDefinition);
    }

    @Override public int getCount() {
        return list.size();
    }

    @Override public TrainRecommend.DataBean.ListBean getItem(int position) {
        return list.get(position);
    }

    @Override public long getItemId(int position) {
        return position;
    }

    @Override public View getView(final int position, View convertView, ViewGroup parent) {
        //final ViewHolder viewHolder;
        if (convertView == null) {
            viewHolder = new ViewHolder();
            convertView = LayoutInflater.from(context).inflate(R.layout.item_train_recommend, null);
            //viewHolder.tv = (RelativeLayout) convertView.findViewById(R.id.tv);
            //播放器的视频图片显示
            viewHolder.huaxu = (ImageView) convertView.findViewById(R.id.huaxu);
            //简介
            viewHolder.surfaceView =
                    (SurfaceView) convertView.findViewById(R.id.playerSurfaceView);//播放器承载器
            viewHolder.rlPlay = (RelativeLayout) convertView.findViewById(R.id.rl_play);//播放器的背景
            viewHolder.bufferProgressBar =
                    (ProgressBar) convertView.findViewById(R.id.bufferProgressBar);//播放器的加载进度
            viewHolder.ivCenterPlay =
                    (ImageView) convertView.findViewById(R.id.iv_center_play);//播放器的播放按钮
            viewHolder.playDuration =
                    (TextView) convertView.findViewById(R.id.playDuration); //播放器的视频播放时间显示
            viewHolder.videoDuration =
                    (TextView) convertView.findViewById(R.id.videoDuration); //播放器的视频总的时间显示
            viewHolder.ivPlay = (ImageView) convertView.findViewById(R.id.iv_play);//播放器的暂停按钮

            //播放器的播放进度显示
            viewHolder.skbProgress = (SeekBar) convertView.findViewById(R.id.skbProgress);
            //播放器
            viewHolder.playerBottomLayout =
                    (LinearLayout) convertView.findViewById(R.id.playerBottomLayout);
            viewHolder.rlPlay.setOnClickListener(this);
            convertView.setTag(viewHolder);
        } else {
            viewHolder = (ViewHolder) convertView.getTag();
        }
        audioManager = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE);
        maxVolume = audioManager.getStreamMaxVolume(AudioManager.STREAM_MUSIC);
        currentVolume = audioManager.getStreamVolume(AudioManager.STREAM_MUSIC);
        final String videoId = list.get(position).getTidbitsVid();
        videoids=videoId;
        //播放器的视频播放时间显示
        viewHolder.playDuration.setText(ParamsUtil.millsecondsToStr(0));
        //播放器的视频总的时间显示
        // viewHolder.videoDuration.setText(ParamsUtil.millsecondsToStr(0));
        //播放器的播放进度监听
        viewHolder.skbProgress.setOnSeekBarChangeListener(onSeekBarChangeListener);
        //播放器的视频图片显示
        if (TextUtils.isEmpty(videoId)) {
            // 获取视频ID失败 显示失败的图片
            viewHolder.huaxu.setVisibility(View.VISIBLE);
            viewHolder.ivCenterPlay.setVisibility(View.VISIBLE);//显示播放按钮
            viewHolder.bufferProgressBar.setVisibility(View.GONE);//隐藏播放进度条
            Glide.with(context)
                    .load(urlTitle + list.get(position).getImageUrl())
                    .into(viewHolder.huaxu);
        } else {
            // 获取视频成功
            SurfaceHolder surfaceHolder = viewHolder.surfaceView.getHolder();//播放器标示
            surfaceHolder.setType(
                    SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS); //2.3及以下使用，不然出现只有声音没有图像的问题
            surfaceHolder.addCallback(TrainRecommendAdapter.this);
            detector = new GestureDetector(context, new MyGesture());
            //获取正播放的VideoId
            String playerVideoId = getValue(player, "videoId");
            System.out.println("刷新： playerVideoId == " + playerVideoId);
            //判断本视频的是否正在操作
            if (!TextUtils.isEmpty(playerVideoId) && videoId.endsWith(playerVideoId)) {
                //该视频正在播放
                if (player.isPlaying()) {
                    viewHolder.huaxu.setVisibility(View.GONE);
                    viewHolder.ivCenterPlay.setVisibility(View.GONE);//隐藏播放按钮
                    viewHolder.bufferProgressBar.setVisibility(View.GONE);//隐藏播放进度条
                } else {
                    viewHolder.huaxu.setVisibility(View.VISIBLE);
                    Glide.with(context)
                            .load(urlTitle + list.get(position).getImageUrl())
                            .into(viewHolder.huaxu);

                    viewHolder.bufferProgressBar.setVisibility(View.GONE);//隐藏播放进度条
                    viewHolder.ivCenterPlay.setVisibility(View.VISIBLE);
                }
            } else {
                viewHolder.huaxu.setVisibility(View.VISIBLE);
                viewHolder.ivCenterPlay.setVisibility(View.VISIBLE);//显示播放按钮
                viewHolder.bufferProgressBar.setVisibility(View.GONE);//隐藏播放进度条
                Glide.with(context)
                        .load(urlTitle + list.get(position).getImageUrl())
                        .into(viewHolder.huaxu);
            }
        }

        //播放器的播放点击事件
        viewHolder.ivCenterPlay.setOnClickListener(new View.OnClickListener() {
            @Override public void onClick(View view) {
                viewHolder.ivCenterPlay.setVisibility(View.GONE);//隐藏播放按钮
                viewHolder.bufferProgressBar.setVisibility(View.VISIBLE);//隐藏播放进度条
                //viewHolder.playerBottomLayout.setVisibility(View.VISIBLE);
                if (player.isPlaying()) {
                    player.pause();
                    player.stop();
                    player.reset();
                }
                playerIngIndex = position;

                player.setDisplay(viewHolder.surfaceView.getHolder());
                player.setVideoPlayInfo(videoId, "CA9465239F9D3050",
                        "uZKMW0m1SwtxVssL2KQRUatr3a5PUVBz", context);
                
                player.prepareAsync();
            }
        });
        /**
         * 暂停按钮
         */
        viewHolder.ivPlay.setOnClickListener(TrainRecommendAdapter.this);
        viewHolder.ivPlay.setOnClickListener(new View.OnClickListener() {
            @Override public void onClick(View view) {
                if (player.isPlaying()) {//播放中，暂停

                    Log.i("dong--", "testjiayou" + "dddddd");
                    viewHolder.ivCenterPlay.setVisibility(View.GONE);//播放器的播放按钮显示
                    viewHolder.ivPlay.setImageResource(R.drawable.smallbegin_ic);
                    player.pause();
                } else {//未播放。开始

                    viewHolder.ivCenterPlay.setVisibility(View.GONE);//播放器的播放按钮隐藏
                    viewHolder.ivPlay.setImageResource(R.drawable.smallstop_ic);
                    Log.i("dong--", "testjiayou" + "cccccccccc");
                    player.start();
                }
            }
        });
        initPlayHander();
        return convertView;
    }

    private void initPlayHander() {
        playerHandler = new Handler() {
            public void handleMessage(Message msg) {

                if (player == null) {
                    return;
                }

                // 更新播放进度
                currentPlayPosition = player.getCurrentPosition();
                int duration = player.getDuration();

                if (duration > 0) {
                    //播放器的播放进度设置
                    long pos = viewHolder.skbProgress.getMax() * currentPlayPosition / duration;
                    //播放器的视频播放时间显示
                    viewHolder.playDuration.setText(
                            ParamsUtil.millsecondsToStr(player.getCurrentPosition()));
                    //播放器的视频播放进度显示
                    viewHolder.skbProgress.setProgress((int) pos);
                }
            }

            ;
        };
    }

    @Override public boolean onInfo(MediaPlayer mp, int what, int extra) {
        switch (what) {
            case DWMediaPlayer.MEDIA_INFO_BUFFERING_START:
                if (player.isPlaying()) {//播放器的加载进度隐藏
                    viewHolder.bufferProgressBar.setVisibility(View.VISIBLE);
                }

                if (!isBackupPlay) {
                    if (playerHandler != null) {
                        playerHandler.postDelayed(backupPlayRunnable, 10 * 1000);
                    }
                }

                break;
            case DWMediaPlayer.MEDIA_INFO_BUFFERING_END://播放器的加载进度隐藏
                viewHolder.bufferProgressBar.setVisibility(View.GONE);
                if (playerHandler != null) {
                    playerHandler.removeCallbacks(backupPlayRunnable);
                }
                break;
        }
        return false;
    }

    private Runnable backupPlayRunnable = new Runnable() {

        @Override public void run() {
            startBackupPlay();
        }
    };

    @Override public void onClick(View v) {
        switch (v.getId()) {
            case R.id.rl_play:
                viewHolder.playerBottomLayout.setVisibility(View.VISIBLE);
                viewHolder.playerBottomLayout.postDelayed(new Runnable() {
                    @Override public void run() {
                        viewHolder.playerBottomLayout.setVisibility(View.GONE);
                    }
                }, 3000);
                break;
        }
    }

    class ViewHolder {
        RelativeLayout rlPlay;
        ImageView huaxu;//视频位置图片
        ImageView ivCenterPlay;//播放器的播放按钮
        ImageView ivPlay;//播放器的暂停按钮
        ImageView player;//播放器的暂停按钮
        SurfaceView surfaceView;//播放器承载器
        ProgressBar bufferProgressBar;//播放器的加载进度
        TextView playDuration;//播放器的视频播放时间显示
        TextView videoDuration; //播放器的视频总的时间显示
        SeekBar skbProgress;//播放器的播放进度
        LinearLayout playerBottomLayout;//播放器
    }

    /*************************************新加方法******************************/
    // 通过反射获取DWMediaPlayer中的私有变量videoId
    public String getValue(Object instance, String fieldName) {
        String value = null;
        try {
            Field field = instance.getClass().getDeclaredField(fieldName);
            field.setAccessible(true); // 参数值为true，禁止访问控制检查
            value = (String) field.get(instance);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return value;
    }

    /*******************************************************************/
    @Override public void surfaceCreated(SurfaceHolder holder) {

    }

    @Override public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
        holder.setFixedSize(width, height);
    }

    @Override public void surfaceDestroyed(SurfaceHolder holder) {

        //        if (null!=player &&!player.isPlaying()) {
        //            //停止播放
        //            System.out.println("停止播放 -- ");
        //            player.stop();
        //            player.reset();
        //            player.setDisplay(null);
        //
        //            notifyDataSetChanged();
        //        }

        //        if (isPrepared) {
        //            currentPosition = player.getCurrentPosition();
        //        }
        //
        //        isPrepared = false;
        //        isSurfaceDestroy = true;
        //
        //        player.stop();
        //        player.reset();
    }

    @Override public void onPrepared(MediaPlayer mp) {
        player.start();
        notifyDataSetChanged();
        initTimerTask();
        isPrepared = true;
        if (!isFreeze) {
            if (isPlaying == null || isPlaying.booleanValue()) {
                player.start();
                viewHolder.ivPlay.setImageResource(R.drawable.smallstop_ic);
            }
        }

        if (currentPosition > 0) {
            player.seekTo(currentPosition);
        } else {
            lastPlayPosition = DataSet.getVideoPosition(videoids);
            if (lastPlayPosition > 0) {
                player.seekTo(lastPlayPosition);
            }
        }

        definitionMap = player.getDefinitions();

        //播放器的加载进度隐藏
        viewHolder.bufferProgressBar.setVisibility(View.GONE);
        //播放器的视频总的时间显示
        Log.i("dong--", "timeall==" + player.getDuration() + "");
        Log.i("dong--", "timesss==" + ParamsUtil.millsecondsToStr(player.getDuration()));
        viewHolder.videoDuration.setText(ParamsUtil.millsecondsToStr(player.getDuration()) + "");
    }

    private void initTimerTask() {
        cancelTimerTask();

        timerTask = new TimerTask() {
            @Override public void run() {

                if (!isPrepared) {
                    return;
                }

                playerHandler.sendEmptyMessage(0);
            }
        };
        timer.schedule(timerTask, 0, 1000);
    }

    /**
     * 判断是否画出屏幕
     */
    public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount,
            int totalItemCount) {
        //System.out.println(playerIngIndex +"--onScroll "+player.isPlaying() +" firstVisibleItem :"+firstVisibleItem +" visibleItemCount："+visibleItemCount);
        if (player.isPlaying() && playerIngIndex >= 0) {
            if (playerIngIndex >= firstVisibleItem
                    && playerIngIndex < firstVisibleItem + visibleItemCount) {
                //显示在屏幕上
            } else {
                //没有显示在屏幕上
                System.out.println("停止播放 " + playerIngIndex);
                playerIngIndex = -1;

                //停止播放
                player.stop();
                player.reset();
                player.setDisplay(null);

                notifyDataSetChanged();
            }
        }
    }

    @Override public void onSensorChanged(SensorEvent event) {
        if (event.sensor == null) {
            return;
        }
    }

    @Override public void onAccuracyChanged(Sensor sensor, int accuracy) {

    }

    @Override public void onBufferingUpdate(MediaPlayer mp, int percent) {
        //播放器的播放进度监听
        viewHolder.skbProgress.setSecondaryProgress(percent);
    }

    @Override public void onCompletion(final MediaPlayer mp) {

        if (isPrepared) {
            runOnUiThread(new Runnable() {
                @Override public void run() {
                    mp.pause();
                    mp.stop();
                    mp.reset();
                    mp.release();
                    viewHolder.ivCenterPlay.setVisibility(View.VISIBLE);
                    viewHolder.ivPlay.setImageResource(R.drawable.smallbegin_ic);
                }
            });
        }
    }

    private void cancelTimerTask() {
        if (timerTask != null) {
            timerTask.cancel();
        }
    }

    private void toastInfo(String info) {
        Toast.makeText(context, info, Toast.LENGTH_SHORT).show();
    }

    private Handler alertHandler = new Handler() {

        @Override public void handleMessage(Message msg) {
            toastInfo("视频异常，无法播放。");
            super.handleMessage(msg);
        }
    };

    @Override public boolean onError(MediaPlayer mp, int what, int extra) {
        Message msg = new Message();
        msg.what = what;

        if (!isBackupPlay) {
            startBackupPlay();
        } else {
            if (alertHandler != null) {
                alertHandler.sendMessage(msg);
            }
        }
        return false;
    }

    private void startBackupPlay() {
        cancelTimerTask();

        player.setBackupPlay(true);
        isBackupPlay = true;
        player.reset();
        player.prepareAsync();
    }

    /****************************************************************/
    // 手势监听器类
    private class MyGesture extends GestureDetector.SimpleOnGestureListener {

        private Boolean isVideo;
        private float scrollCurrentPosition;
        private float scrollCurrentVolume;

        /**
         * 一次单独的轻击抬起操作,也就是轻击一下屏幕，立刻抬起来，才会有这个触发，
         * 当然,如果除了Down以外还有其它操作,那就不再算是Single操作了,所以也就不会触发这个事件
         * 触发顺序：
         * 点击一下非常快的（不滑动）Touchup：
         * onDown->onSingleTapUp->onSingleTapConfirmed
         * 点击一下稍微慢点的（不滑动）Touchup：
         * onDown->onShowPress->onSingleTapUp->onSingleTapConfirmed
         */
        @Override public boolean onSingleTapUp(MotionEvent e) {
            return super.onSingleTapUp(e);
        }

        //长按触摸屏，超过一定时长，就会触发这个事件
        //触发顺序：
        //onDown->onShowPress->onLongPress
        @Override public void onLongPress(MotionEvent e) {
            super.onLongPress(e);
        }

        //在屏幕上拖动事件。无论是用手拖动view，或者是以抛的动作滚动，都会多次触发,这个方法
        //在ACTION_MOVE动作发生时就会触发
        //滑屏：手指触动屏幕后，稍微滑动后立即松开
        @Override public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX,
                float distanceY) {
            if (isVideo == null) {
                if (Math.abs(distanceX) > Math.abs(distanceY)) {
                    isVideo = true;
                } else {
                    isVideo = false;
                }
            }

            if (isVideo.booleanValue()) {
                parseVideoScroll(distanceX);
            } else {
                parseAudioScroll(distanceY);
            }

            return super.onScroll(e1, e2, distanceX, distanceY);
        }

        private void parseVideoScroll(float distanceX) {
            if (!isDisplay) {
                setLayoutVisibility(View.VISIBLE, true);
            }

            scrollTotalDistance += distanceX;

            float duration = (float) player.getDuration();

            float width = wm.getDefaultDisplay().getWidth() * 0.75f; // 设定总长度是多少，此处根据实际调整
            //右滑distanceX为负
            float currentPosition =
                    scrollCurrentPosition - (float) duration * scrollTotalDistance / width;

            if (currentPosition < 0) {
                currentPosition = 0;
            } else if (currentPosition > duration) {
                currentPosition = duration;
            }

            player.seekTo((int) currentPosition);
            //播放器的视频播放时间显示
            viewHolder.playDuration.setText(ParamsUtil.millsecondsToStr((int) currentPosition));
            //播放器的播放进度计算
            int pos = (int) (viewHolder.skbProgress.getMax() * currentPosition / duration);
            viewHolder.skbProgress.setProgress(pos);
        }

        private void parseAudioScroll(float distanceY) {
            if (!isDisplay) {
                setLayoutVisibility(View.VISIBLE, true);
            }
            scrollTotalDistance += distanceY;

            float height = wm.getDefaultDisplay().getHeight() * 0.75f;
            // 上滑distanceY为正
            currentVolume = (int) (scrollCurrentVolume + maxVolume * scrollTotalDistance / height);

            if (currentVolume < 0) {
                currentVolume = 0;
            } else if (currentVolume > maxVolume) {
                currentVolume = maxVolume;
            }
        }

        //滑屏，用户按下触摸屏、快速移动后松开，由1个MotionEvent ACTION_DOWN, 多个ACTION_MOVE, 1个ACTION_UP触发
        //参数解释：
        //e1：第1个ACTION_DOWN MotionEvent
        //e2：最后一个ACTION_MOVE MotionEvent
        //velocityX：X轴上的移动速度，像素/秒
        //velocityY：Y轴上的移动速度，像素/秒
        @Override public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX,
                float velocityY) {
            return super.onFling(e1, e2, velocityX, velocityY);
        }

        // 如果是按下的时间超过瞬间，而且在按下的时候没有松开或者是拖动的，那么onShowPress就会执行
        @Override public void onShowPress(MotionEvent e) {
            super.onShowPress(e);
        }

        @Override public boolean onDown(MotionEvent e) {//用户按下屏幕就会触发；
            scrollTotalDistance = 0f;
            isVideo = null;

            scrollCurrentPosition = (float) player.getCurrentPosition();
            scrollCurrentVolume = currentVolume;

            return super.onDown(e);
        }

        @Override public boolean onDoubleTap(MotionEvent e) {
            if (!isDisplay) {
                setLayoutVisibility(View.VISIBLE, true);
            }
            changePlayStatus();
            return super.onDoubleTap(e);
        }

        private void changePlayStatus() {
            if (player.isPlaying()) {
                player.pause();
                viewHolder.ivCenterPlay.setVisibility(View.VISIBLE);
                viewHolder.ivPlay.setImageResource(R.drawable.smallbegin_ic);
            } else {
                player.start();
                viewHolder.ivCenterPlay.setVisibility(View.GONE);
                viewHolder.ivPlay.setImageResource(R.drawable.smallstop_ic);
            }
        }

        @Override public boolean onDoubleTapEvent(MotionEvent e) {
            return super.onDoubleTapEvent(e);
        }

        @Override public boolean onSingleTapConfirmed(MotionEvent e) {
            if (isDisplay) {
                setLayoutVisibility(View.GONE, false);
            } else {
                setLayoutVisibility(View.VISIBLE, true);
            }
            return super.onSingleTapConfirmed(e);
        }
    }

    // 重置隐藏界面组件的延迟时间
    private void resetHideDelayed() {
        if (playerHandler != null) {
            playerHandler.removeCallbacks(hidePlayRunnable);
            playerHandler.postDelayed(hidePlayRunnable, 5000);
        }
    }
    /***************************************************/
    /**
     * @param visibility 显示状态
     * @param isDisplay 是否延迟消失
     */
    private void setLayoutVisibility(int visibility, boolean isDisplay) {
        if (player == null || player.getDuration() <= 0) {
            return;
        }

        if (playerHandler != null) {
            playerHandler.removeCallbacks(hidePlayRunnable);
        }

        this.isDisplay = isDisplay;

        if (isDisplay) {
            if (playerHandler != null) {
                playerHandler.postDelayed(hidePlayRunnable, 5000);
            }
        }
        //播放器的暂停，播放时间，总时间，以及进度条的显示

        viewHolder.playerBottomLayout.setVisibility(View.VISIBLE);
    }

    /***********************************************/
    //播放器的播放进度监听
    SeekBar.OnSeekBarChangeListener onSeekBarChangeListener =
            new SeekBar.OnSeekBarChangeListener() {
                int progress = 0;

                @Override public void onStopTrackingTouch(SeekBar seekBar) {
                    if (networkConnected) {
                        player.seekTo(progress);
                        if (playerHandler != null) {
                            playerHandler.postDelayed(hidePlayRunnable, 5000);
                        }
                    }
                }

                @Override public void onStartTrackingTouch(SeekBar seekBar) {
                    if (playerHandler != null) {
                        playerHandler.removeCallbacks(hidePlayRunnable);
                    }
                }

                @Override
                public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) {
                    if (networkConnected) {
                        this.progress = progress * player.getDuration() / seekBar.getMax();
                    }
                }
            };
    /************************************************/
}