CNLive Android Team / CNLiveApp · Files

package com.cnlive.gundam.video.view;

import android.content.Context;
import android.databinding.ObservableBoolean;
import android.databinding.ObservableInt;
import android.os.Handler;
import android.os.Message;
import android.util.AttributeSet;
import android.view.ViewGroup;
import android.widget.Toast;

import com.cnlive.gundam.R;
import com.cnlive.gundam.main.utils.SharedPreferencesHelper;
import com.cnlive.gundam.video.model.NetStatusEvent;
import com.cnlive.gundam.video.model.VideoModel;
import com.cnlive.gundam.video.utils.NetworkUtil;
import com.cnlive.gundam.video.utils.PlayerUtils;
import com.cnlive.libs.video.video.base.IMediaPlayer;

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

/**
 * Created by gujun on 2017/4/6.
 */

public class VideoView extends BaseVideoView implements PlayerTouchView.VideoTouchListener,
        PlayerControllerView.VideoControllerListener, PlayerInfoView.VideoInfoListener {


    //更新controller相关
    private static final int UPDATE_CONTROLLER = 1;
    private static final int UPDATE_CONTROLLER_DELAYED = 1000;

    //隐藏controller相关
    private static final int HIDE_CONTROLLER = 2;
    private static final int HIDE_CONTROLLER_DELAYED = 5000;

    //controller相关的type
    public static final String TYPE_LIVE = "live";
    public static final String TYPE_VOD = "vod";
    public static final String TYPE_UGC_LIVE = "ugcLive";
    public static final String TYPE_UGC_VOD = "ugcVod";

    public static final String CAN_MOBILE_NET_PLAY = "CAN_MOBILE_NET_PLAY";

    //手势点下时当前播放时长
    private long touchDownCurPosition;
    //拖动结束或拖拽进度条时需要seekTo的位置
    private long touchSeekToPosition = 0;
    //记录当前是否是竖屏
    private static ObservableBoolean observableIsPortrait;
    //记录当前是否是ugc节目
    private static ObservableBoolean observableIsUgc;
    //记录当前视频高度
    private static ObservableInt observableVideoHeight;
    //记录当前视频宽度
    private static ObservableInt observableVideoWidth;
    //记录当前视频是否已经onError
    private boolean isPlayerError = false;
    //设置touchView 是否拦截touch事件
    private boolean canTouch = true;
    //一进来有没有网络
    private boolean isStartNoNet = false;
    //记录是否能手机网络播放
    private boolean canMobilePlay = false;
    //本地缓存文件
    private SharedPreferencesHelper sharedPreferencesHelper;
    //播放前请求的播放详情接口重试的监听回调
    private VideoRetryListener videoRetryListener;

    private Handler mHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            switch (msg.what) {
                case UPDATE_CONTROLLER:
                    binding.controllerView.setDurProgress(binding.videoView.getDuration());
                    binding.controllerView.setCurProgress(binding.videoView.getCurrentPosition());
                    setPlayPosition(binding.videoView.getCurrentPosition());
                    startUpdateTimer(UPDATE_CONTROLLER_DELAYED);
                    break;
                case HIDE_CONTROLLER:
                    binding.controllerView.changeVisible();
                    break;
            }

        }
    };

    public VideoView(Context context) {
        this(context, null);
    }

    public VideoView(Context context, AttributeSet attrs) {
        this(context, attrs, 0);
    }

    public VideoView(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
    }

    @Override
    protected void init() {
        super.init();
        sharedPreferencesHelper = SharedPreferencesHelper.getInstance(getContext());
        observableIsPortrait = new ObservableBoolean();
        observableIsUgc = new ObservableBoolean();
        observableVideoHeight = new ObservableInt();
        observableVideoWidth = new ObservableInt();
        observableVideoHeight.set((int) getContext().getResources().getDimension(R.dimen.videoPortraitHeight));
        observableVideoWidth.set(ViewGroup.LayoutParams.MATCH_PARENT);
        observableIsPortrait.set(PlayerUtils.isPortrait(getContext()));
        binding.setVideoPortraitHeight(observableVideoHeight);
        binding.setVideoPortraitWidth(observableVideoWidth);
        binding.setIsPortrait(observableIsPortrait);
        binding.setIsUgc(observableIsUgc);
        binding.touchView.setTouchListener(this);
        binding.controllerView.setOnControllerListener(this);
        binding.infoView.setInfoListener(this);
    }

    public void setVideoInfo(VideoModel videoInfo) {
        canMobilePlay = sharedPreferencesHelper.getBoolean(CAN_MOBILE_NET_PLAY, false);
        setCanMobileNetPlay(canMobilePlay);

        videoModel = videoInfo;
        binding.controllerView.setTitle(videoInfo.getTitle());
        binding.controllerView.setRateInfo(videoInfo.getRates());
        setControllerLayout();

        binding.infoView.setInfoViewLayout(observableIsUgc.get() ? PlayerInfoView.VIDEO_INFO_UGC : PlayerInfoView.VIDEO_INFO_NORMAL);
        binding.infoView.show(PlayerInfoView.SHOW_LOADING);

        if (NetworkUtil.isConnectInternet(getContext())) {
            isStartNoNet = false;
            setDataSource();
        } else {
            isStartNoNet = true;
            binding.infoView.show(PlayerInfoView.SHOW_ERROR);
        }
    }

    //设置请求播放详情接口失败重试的监听,只有普通直播和普通点播详情页面用到了
    public void setVideoRetryListener(VideoRetryListener listener) {
        this.videoRetryListener = listener;
    }

    //设置请求播放详情接口失败展示失败页面，只有普通直播和普通点播详情页面用到了
    public void showVideoRetry() {
        if (binding.infoView != null) {
            binding.infoView.setInfoViewLayout(PlayerInfoView.VIDEO_INFO_NORMAL);
            binding.infoView.show(PlayerInfoView.SHOW_ERROR);
        }
    }

    //设置一开始是否允许手机网播放视频
    private void setCanMobileNetPlay(boolean canMobilePlay) {
        this.canMobilePlay = canMobilePlay;
    }

    //设置当前的网络状态,页面一接收到网络状态就设置此方法
    public void setCurNetStatus(int curNetStatus) {
        switch (curNetStatus) {
            case NetStatusEvent.NET_DISCONNECT:
                binding.infoView.show(PlayerInfoView.SHOW_ERROR);
                break;
            case NetStatusEvent.NET_MOBILE:
                if (binding.videoView.getPlayState() && !canMobilePlay) {
                    binding.infoView.show(PlayerInfoView.SHOW_MOBILE_NET);
                    isPlay = false;
                    setPlayState(false);
                }
                break;
            case NetStatusEvent.NET_WIFI:
                if (binding.infoView.getCurInfoType() == PlayerInfoView.SHOW_MOBILE_NET) {
                    binding.infoView.show(PlayerInfoView.SHOW_NULL);
                    isPlay = true;
                    if (binding.videoView.getPlayState()) setPlayState(true);
                }
                break;
        }
    }

    @Subscribe(threadMode = ThreadMode.MAIN)
    public void onNetStatusChange(NetStatusEvent event) {
        setCurNetStatus(event.getNetStatus());
    }

    @Override
    protected void onAttachedToWindow() {
        super.onAttachedToWindow();
        EventBus.getDefault().register(this);
    }

    @Override
    protected void onDetachedFromWindow() {
        super.onDetachedFromWindow();
        EventBus.getDefault().unregister(this);
    }

    private void setControllerLayout() {
        switch (videoModel.getType()) {
            case TYPE_VOD:
                observableIsUgc.set(false);
                isLive = false;
                binding.controllerView.setControllerLayout(observableIsPortrait.get() ? PlayerControllerView.VOD_P : PlayerControllerView.VOD_L);
                break;
            case TYPE_LIVE:
                observableIsUgc.set(false);
                isLive = true;
                binding.controllerView.setControllerLayout(observableIsPortrait.get() ? PlayerControllerView.LIVE_P : PlayerControllerView.LIVE_L);
                break;
            case TYPE_UGC_VOD:
                observableIsUgc.set(true);
                isLive = false;
                binding.controllerView.setControllerLayout(observableIsPortrait.get() ? PlayerControllerView.UGC_VOD_P : PlayerControllerView.UGC_VOD_L);
                break;
            case TYPE_UGC_LIVE:
                observableIsUgc.set(true);
                isLive = true;
                binding.controllerView.setControllerLayout(observableIsPortrait.get() ? PlayerControllerView.UGC_LIVE_P : PlayerControllerView.UGC_LIVE_L);
                break;
        }
    }

    /**
     * 获取infoView当前展示状态
     *
     * @return
     */
    public boolean videoInfoViewIsShow() {
        return binding.infoView.isShow();
    }

    /**
     * 隐藏controller
     */
    public void hideController() {
        if (binding.controllerView.isShow()) {
            cancelHideTimer();
            binding.controllerView.changeVisible();
        }
    }

    /**
     * 设置touchView 是否拦截touch事件
     *
     * @param canTouch 默认true
     */
    public void setTouchViewCanTouch(boolean canTouch) {
        this.canTouch = canTouch;
    }

    /**
     * 设置竖屏播放时播放器高度
     *
     * @param videoHeight（传dp对应的像素值） 默认200dp
     */
    public void setVideoHeight(int videoHeight) {
        observableVideoHeight.set(videoHeight);
    }

    /**
     * 设置竖屏播放时播放器宽度
     *
     * @param videoWidth（传dp对应的像素值） 默认ViewGroup.LayoutParams.MATCH_PARENT
     */
    public void setVideoWidth(int videoWidth) {
        observableVideoWidth.set(videoWidth);
    }

    public void stop() {
        binding.videoView.stop();
        saveCurPlayPosition();
    }

    /**
     * 屏幕切换
     *
     * @param isPortrait
     */
    public void onScreenChange(boolean isPortrait) {
        observableIsPortrait.set(isPortrait);
        setControllerLayout();
        binding.infoView.onScreenChange(isPortrait);
    }

    @Override
    protected void setPlayState(boolean isPlay) {
        boolean isMobileNet = NetworkUtil.isMobileNet(getContext());
        if (isMobileNet && isPlay)
            Toast.makeText(getContext(), getResources().getString(R.string.player_mobile_net_toast), Toast.LENGTH_LONG).show();
        if (isPlay && !NetworkUtil.isConnectInternet(getContext())) {
            binding.infoView.show(PlayerInfoView.SHOW_ERROR);
        } else if (isPlay && !canMobilePlay && isMobileNet) {
            this.isPlay = false;
            super.setPlayState(false);
            binding.infoView.show(PlayerInfoView.SHOW_MOBILE_NET);
        } else {
            if (isPlay) binding.infoView.show(PlayerInfoView.SHOW_NULL);
            super.setPlayState(isPlay);
        }
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        cancelUpdateTimer();
        cancelHideTimer();
    }

    //    --------------------- touch 相关回调 start-------------------------
    @Override
    public String change_value_progress(int percent, boolean update) {
        if (update) {
            binding.videoView.seekTo(touchSeekToPosition, true);
            startUpdateTimer(1000);
            startHideTimer(HIDE_CONTROLLER_DELAYED);
        } else {
            cancelUpdateTimer();
            cancelHideTimer();
            touchSeekToPosition = (touchDownCurPosition + binding.videoView.getDuration() * percent / 100);
            binding.controllerView.setCurProgress(touchSeekToPosition);
            if (!binding.controllerView.isShow())
                binding.controllerView.changeVisible();
        }
        return "";
    }

    @Override
    public void click() {
        binding.controllerView.changeVisible();
        if (binding.controllerView.isShow()) startHideTimer(HIDE_CONTROLLER_DELAYED);
        else cancelHideTimer();
    }

    @Override
    public void down() {
        touchDownCurPosition = binding.videoView.getCurrentPosition();
    }

    @Override
    public boolean canTouch() {
        return videoInfoViewIsShow() ? false : canTouch;
    }
//    --------------------- touch 相关回调 end-------------------------

    //    --------------------- controller 相关回调 start-------------------------
    @Override
    public void onControllerViewClick(int id) {
        switch (id) {
            case PlayerControllerView.ID_CLICK_PLAY_BUTTON:
                playBtnClick();
                break;
        }
    }

    //播放进度手动改变开始
    @Override
    public void onSeekProgressChange(int progress) {
        cancelUpdateTimer();
        touchSeekToPosition = progress * 1000;
        binding.controllerView.setCurProgress(touchSeekToPosition);
    }

    //播放进度手动改变结束
    @Override
    public void onSeekComplete() {
        binding.videoView.seekTo(touchSeekToPosition, true);
        startUpdateTimer(1000);
    }

    @Override
    public void onSwitchRate(String rate) {
        switchVideoRate(rate);
    }
//    --------------------- controller 相关回调 end-------------------------

    //    --------------------- 播放器 相关回调 start-------------------------
    @Override
    public void onPrepared(IMediaPlayer iMediaPlayer) {
        super.onPrepared(iMediaPlayer);
        isPlayerError = false;
    }

    @Override
    public void onPlayState(boolean isPlay) {
        super.onPlayState(isPlay);
        if (isPlay) startUpdateTimer(0);
        else cancelUpdateTimer();
        binding.controllerView.setIsPlay(isPlay);
    }

    @Override
    public void onBufferingUpdate(IMediaPlayer iMediaPlayer, int i) {
        super.onBufferingUpdate(iMediaPlayer, i);
    }

    @Override
    public boolean onInfo(IMediaPlayer iMediaPlayer, int i, int i1) {
        switch (i) {
            case IMediaPlayer.MEDIA_INFO_AUDIO_RENDERING_START:
                //视频开始渲染
                break;
            case IMediaPlayer.MEDIA_INFO_BUFFERING_START:
                if (iMediaPlayer.getPlayState() && !switchingVideoRate)
                    binding.infoView.show(PlayerInfoView.SHOW_BUFFERING);
                break;
            case IMediaPlayer.MEDIA_INFO_BUFFERING_END:
                if (iMediaPlayer.getPlayState())
                    binding.infoView.show(PlayerInfoView.SHOW_NULL);
                break;
        }
        return false;
    }

    @Override
    public boolean onError(IMediaPlayer iMediaPlayer, int i, int i1) {
        isPlayerError = true;
        //接收视讯云播放状态后，此方法还有可能会执行，因此做一下过滤
        if (canPlay && binding.infoView.getCurInfoType() != PlayerInfoView.SHOW_ERROR)
            binding.infoView.show(PlayerInfoView.SHOW_ERROR);
        return false;
    }

    @Override
    public void onCompletion(IMediaPlayer iMediaPlayer) {
        super.onCompletion(iMediaPlayer);
        //非因为异常导致的结束
        if (!isPlayerError && !isLive) {
            binding.infoView.show(PlayerInfoView.SHOW_END);
        }
    }
    //    --------------------- 播放器 相关回调 end-------------------------

    //开始更新controller 定时器
    public void startUpdateTimer(long startTime) {
        //只有点播才有更新进度条
        if (isLive) return;
        if (mHandler != null) {
            cancelUpdateTimer();
            mHandler.sendEmptyMessageDelayed(UPDATE_CONTROLLER, startTime);
        }
    }

    //取消更新controller定时器
    public void cancelUpdateTimer() {
        if (mHandler != null && mHandler.hasMessages(UPDATE_CONTROLLER))
            mHandler.removeMessages(UPDATE_CONTROLLER);
    }

    //开始隐藏controller 定时器
    public void startHideTimer(long startTime) {
        if (mHandler != null) {
            cancelHideTimer();
            mHandler.sendEmptyMessageDelayed(HIDE_CONTROLLER, startTime);
        }
    }

    //取消隐藏controller定时器
    public void cancelHideTimer() {
        if (mHandler != null && mHandler.hasMessages(HIDE_CONTROLLER))
            mHandler.removeMessages(HIDE_CONTROLLER);
    }

    //    -----------------------------info view 相关回调 start---------------------
    @Override
    public void onInfoViewClick(int id) {
        switch (id) {
            case PlayerInfoView.ID_CLICK_INFO_REPLAY:
                replay();
                break;
            case PlayerInfoView.ID_CLICK_INFO_RETRY:
                binding.infoView.show(PlayerInfoView.SHOW_LOADING);
                if (videoRetryListener != null && videoModel == null) {
                    videoRetryListener.loadVideoInfoRetry();
                } else {
                    if (NetworkUtil.isConnectInternet(getContext())) {
                        if (isStartNoNet) {
                            setDataSource();
                        } else {
                            retry();
                        }
                    } else {
                        binding.infoView.show(PlayerInfoView.SHOW_ERROR);
                    }
                }
                break;
            case PlayerInfoView.ID_CLICK_INFO_MOBILE_NET_PLAY:
                sharedPreferencesHelper.setValue(CAN_MOBILE_NET_PLAY, true);
                this.isPlay = true;
                canMobilePlay = true;
                setPlayState(true);
                break;
        }
    }
//    -----------------------------info view 相关回调 end---------------------

    //播放前请求详情页面失败重试的监听回调，只有普通直播和普通点播详情页面用到了
    public interface VideoRetryListener {
        void loadVideoInfoRetry();
    }
}