package com.wd.player.widget;

import android.app.Activity;
import android.content.Context;
import android.content.pm.ActivityInfo;
import android.content.res.Configuration;
import android.content.res.TypedArray;
import android.net.Uri;
import android.text.TextUtils;
import android.util.AttributeSet;
import android.util.Log;
import android.view.KeyEvent;
import android.view.MotionEvent;
import android.view.View;
import android.widget.ImageView;
import android.widget.RelativeLayout;

import com.aliyun.player.AliPlayer;
import com.aliyun.player.AliPlayerFactory;
import com.aliyun.player.IPlayer;
import com.aliyun.player.bean.ErrorInfo;
import com.aliyun.player.bean.InfoBean;
import com.aliyun.player.bean.InfoCode;
import com.aliyun.player.nativeclass.CacheConfig;
import com.aliyun.player.nativeclass.MediaInfo;
import com.aliyun.player.nativeclass.PlayerConfig;
import com.aliyun.player.nativeclass.TrackInfo;
import com.aliyun.player.source.LiveSts;
import com.aliyun.player.source.StsInfo;
import com.aliyun.player.source.UrlSource;
import com.aliyun.player.source.VidAuth;
import com.aliyun.player.source.VidMps;
import com.aliyun.player.source.VidSts;
import com.aliyun.subtitle.LocationStyle;
import com.aliyun.subtitle.SubtitleView;
import com.aliyun.svideo.wd.player.R;
import com.cicada.player.utils.ass.AssHeader;
import com.cicada.player.utils.ass.AssSubtitleView;
import com.wd.base.log.Logger;
import com.wd.foundation.wdkit.constant.EventConstants;
import com.wd.capability.network.utils.NetworkUtil;
import com.wd.foundation.wdkit.constant.Constants;
import com.wd.foundation.wdkit.imageglide.ImageUtils;
import com.wd.foundation.wdkit.utils.NetWatchdogUtils;
import com.wd.foundation.wdkit.utils.NumberUtil;
import com.wd.foundation.wdkit.utils.ScreenUtils;
import com.wd.foundation.wdkit.utils.ToastNightUtil;
import com.wd.foundation.wdkit.view.RenderViewOutlineProvider;
import com.wd.foundation.wdkit.viewclick.BaseClickListener;
import com.wd.foundation.wdkitcore.livedata.LiveDataBus;
import com.wd.player.constant.GlobalPlayerConfig;
import com.wd.player.control.ControlView;
import com.wd.player.durationview.VideoDurationView;
import com.wd.player.function.MarqueeView;
import com.wd.player.gesture.GestureView;
import com.wd.player.gesture.NetChangeLayoutView;
import com.wd.player.gesturedialog.OrientationWatchDog;
import com.wd.player.interfaces.ViewAction;
import com.wd.player.listener.OnBackClickListener;
import com.wd.player.listener.OnOrientationChangeListener;
import com.wd.player.listener.OnPlayStateBtnClickListener;
import com.wd.player.listener.OnScreenModeClickListener;
import com.wd.player.listener.OnSeekListener;
import com.wd.player.listener.OnSeekStartListener;
import com.wd.player.listener.OnShareClickListener;
import com.wd.player.listener.OnStoppedListener;
import com.wd.player.listener.OnTipClickListener;
import com.wd.player.listener.SimpleGestureListener;
import com.wd.player.listener.SimpleNetChangeListener;
import com.wd.player.listener.VideoPlayerCompletionListener;
import com.wd.player.listener.VideoPlayerErrorListener;
import com.wd.player.listener.VideoPlayerInfoListener;
import com.wd.player.listener.VideoPlayerLoadingStatusListener;
import com.wd.player.listener.VideoPlayerOnSeekCompleteListener;
import com.wd.player.listener.VideoPlayerPreparedListener;
import com.wd.player.listener.VideoPlayerRenderingStartListener;
import com.wd.player.listener.VideoPlayerStateChangedListener;
import com.wd.player.playerutil.NetWatchdog;
import com.wd.player.playerutil.VodPlayerLoadEndHandler;
import com.wd.player.tipsview.TipsView;

import java.lang.ref.WeakReference;
import java.util.HashMap;
import java.util.Map;

/**
 * 带控制View的视频/直播 播放View
 * UI播放器的主要实现类。 通过ITheme控制各个界面的主题色。 通过各种view的组合实现UI的界面。这些view包括： 用户手势操作的{@link GestureView} 控制播放，显示信息的{@link
 * ControlView} 用户提示页面{@link TipsView}
 * 以及封面等。 view 的初始化是在{@link #initVideoView}方法中实现的。 然后是对各个view添加监听方法，处理对应的操作，从而实现与播放器的共同操作
 */
public class VideoAndLivePlayerView extends RelativeLayout {


    private static final String TAG = VideoAndLivePlayerView.class.getSimpleName();
    /**
     * 跑马灯显示区域
     */
    private static final MarqueeView.MarqueeRegion MARQUEE_REGION = MarqueeView.MarqueeRegion.TOP;

    // 解决bug,进入播放界面快速切换到其他界面,播放器仍然播放视频问题
    private final VodPlayerLoadEndHandler vodPlayerLoadEndHandler = new VodPlayerLoadEndHandler(this);
    /**
     * 普通视频
     */
    public final static int NORMAL = 0;

    /**
     * 回放视频
     */
    public final static int REVIEW = 1;

    /**
     * 预告视频
     */
    public final static int PREVIEW = 2;

    /**
     * 直播
     */
    public final static int LIVE = 3;

    /**
     * 图文详情页
     */
    public final static int DETAIL = 4;


    // 是否是在投屏中
    private final boolean mIsScreenCosting = false;
    /**
     * 网络看门狗
     */
    private NetWatchdogUtils mNetWatchdogUtils;

    /**
     * 判断VodePlayer 是否加载完成
     */
    private final Map<MediaInfo, Boolean> hasLoadEnd = new HashMap<>();

    // 手势操作view
    private GestureView mGestureView;

    // 皮肤view
    private ControlView mControlView;

    // 网路环境view
    public NetChangeLayoutView mNetChangeLayoutView;

    // 封面view
    private ImageView mCoverView;

    // 视频时长视图
    private VideoDurationView mVideoDurationView;

    // 网络状态监听
    private NetWatchdog mNetWatchdog;

    // 屏幕方向监听
    private OrientationWatchDog mOrientationWatchDog;

    // 包括错误提示、重试提示、直播结束提示、直播垫片等视图
    private TipsView mTipsView;

    // 是否锁定全屏
    private boolean mIsFullScreenLocked = false;

    // 当前屏幕模式
    public AliyunScreenMode mCurrentScreenMode = AliyunScreenMode.Small;

    // 是不是在seek中
    private boolean inSeek = false;

    // 播放是否完成
    private boolean isCompleted = false;

    // 媒体信息
    private MediaInfo mAliyunMediaInfo;

    // 跑马灯
    private MarqueeView mMarqueeView;

    // 原视频的buffered
    private long mVideoBufferedPosition = 0;

    // 原视频的currentPosition
    private long mCurrentPosition = 0;

    // 当前播放器的状态
    public int mPlayerState = IPlayer.idle;

    // 原视频时长
    private long mSourceDuration;

    // 播放的数据类型 0普通视频 1回放 2预告 3直播
    private int playResourceType;

    // 字幕
    private SubtitleView mSubtitleView;

    // 目前支持的几种播放方式
    private VidAuth mAliyunPlayAuth;

    private VidMps mAliyunVidMps;

    private UrlSource mAliyunLocalSource;

    private VidSts mAliyunVidSts;

    private LiveSts mAliyunLiveSts;

    private final IPlayer.OnTrackReadyListener mOutOnTrackReadyListener = null;

    private IPlayer.OnSeiDataListener mOutOnSeiDataListener = null;

    private AliPlayer.OnVerifyTimeExpireCallback mOutOnVerifyTimeExpireCallback = null;

    private OnTipClickListener mOutOnTipClickListener = null;

    private OnSeekStartListener onSeekStartListener;

    private OnOrientationChangeListener orientationChangeListener;

    // 播放按钮点击监听
    private OnPlayStateBtnClickListener onPlayStateBtnClickListener;

    //分享点击监听
    private OnShareClickListener mOnShareClickListener;

    // 停止按钮监听
    private OnStoppedListener mOnStoppedListener;

    // 连网断网监听
    private NetConnectedListener mNetConnectedListener = null;

    // 广告播放器的当前状态
    private int mAdvVideoPlayerState;

    // 运营商是否自动播放 默认自动播放
    private boolean mIsOperatorPlay = true;

    private final Map<Integer, AssHeader.SubtitleType> mSubtitleTypeMap = new HashMap<>();

    // 是否只需要全屏播放
    private boolean mIsNeedOnlyFullScreen;

    // 播放器+渲染的View
    private AliyunRenderView mAliyunRenderView;

    private AssSubtitleView mAssSubtitleView;

    private static final int FULLSCREEN_FLAGS = View.SYSTEM_UI_FLAG_HIDE_NAVIGATION | View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY;

    // 通过添加和移除这个view来实现隐藏和显示系统navigation bar，可以避免出现一些奇奇怪怪的问题
    private View mHideNavBarView;

    // 当前网速
    private final String currentNetSpeed = "0KB/s";

    private int activity_landscape;

    /**
     * 是否展示ReplayView
     */
    private boolean showReplayView = false;

    public VideoAndLivePlayerView(Context context) {
        this(context, null, 0);
    }

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

    public VideoAndLivePlayerView(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        TypedArray typedArray = context.obtainStyledAttributes(attrs, R.styleable.VideoAndLivePlayerView);
        playResourceType = typedArray.getInt(R.styleable.VideoAndLivePlayerView_playResourceType, NORMAL);
        typedArray.recycle();
        initVideoView();
    }

    public AliyunRenderView getAliyunRenderView() {
        return mAliyunRenderView;
    }

    /**
     * 初始化view
     */
    private void initVideoView() {

        mHideNavBarView = new View(getContext());
        mHideNavBarView.setSystemUiVisibility(FULLSCREEN_FLAGS);

        // 初始化播放器
        initAliVcPlayer();
        // 初始化手势view
        initGestureView();
        // 初始化跑马灯
        initMarquee();
        // 初始化提示view
        initTipsView();
        // 初始化控制栏
        initControlView();
        // 初始化封面
        initCoverView();
        // 初始化右下角时长角标
        initDurationView();
        // 初始化网络监听器
        initNetWatchdog();
        // 初始化网络异常视图
        iniNetChangeLayoutView();
        // 先隐藏手势和控制栏，防止在没有prepare的时候做操作。
        hideGestureAndControlViews();
        // 初始化字幕
        initSubtitleView();
    }

    /**
     * 在activity调用onResume的时候调用。 解决home回来后，画面方向不对的问题
     */
    public void onResume() {

        if (mIsFullScreenLocked) {
            int orientation = getResources().getConfiguration().orientation;
            if (orientation == Configuration.ORIENTATION_PORTRAIT) {
                changeScreenMode(AliyunScreenMode.Small, false);
            } else if (orientation == Configuration.ORIENTATION_LANDSCAPE) {
                changeScreenMode(AliyunScreenMode.Full, false);
            }
        }

        startOrientationWatchDog();

        // onStop中记录下来的状态，在这里恢复使用
        if (!mIsScreenCosting) {
            // 不是投屏中再回复播放
            resumePlayerState();
        }
    }

    /**
     * 在activity调用onDestroy的时候调用，活动销毁释放
     */
    public void onDestroy() {

        stop();
        if (mAliyunRenderView != null) {
            mAliyunRenderView.release();
            mAliyunRenderView = null;
        }
        mGestureView = null;
        mControlView = null;
        mCoverView = null;
        mTipsView = null;
        mAliyunMediaInfo = null;
        if (mOrientationWatchDog != null) {
            mOrientationWatchDog.destroy();
        }
        mOrientationWatchDog = null;
        if (hasLoadEnd != null) {
            hasLoadEnd.clear();
        }
        if (mNetWatchdogUtils != null) {
            mNetWatchdogUtils.stopWatch();
            mNetWatchdogUtils.clearContent();
            mNetWatchdogUtils.setNetChangeListener(null);
        }
        if (mNetWatchdog != null) {
            mNetWatchdog.stopWatch();
            mNetWatchdog.clearContent();
            mNetWatchdog.setNetChangeListener(null);
            mNetWatchdog.setNetConnectedListener(null);
        }
        if (mMarqueeView != null) {
            mMarqueeView.clearContent();
            mMarqueeView = null;
        }
        if (vodPlayerLoadEndHandler != null) {
            vodPlayerLoadEndHandler.removeCallbacksAndMessages(null);
        }

    }

    /**
     * 初始化播放器
     */
    private void initAliVcPlayer() {

        mAliyunRenderView = new AliyunRenderView(getContext());

        addSubView(mAliyunRenderView);
        mAliyunRenderView.setSurfaceType(AliyunRenderView.SurfaceType.SURFACE_VIEW);

        // 设置准备回调
        mAliyunRenderView.setOnPreparedListener(new VideoPlayerPreparedListener(this));
        // mAliyunRenderView.setOnTrackChangedListener();
        // 播放器出错监听
        mAliyunRenderView.setOnErrorListener(new VideoPlayerErrorListener(this));
        // 播放器加载回调
        mAliyunRenderView.setOnLoadingStatusListener(new VideoPlayerLoadingStatusListener(this));
        mAliyunRenderView.setOnTrackReadyListenenr(new VideoPlayerOnTrackReadyListener(this));
        // 播放器状态
        mAliyunRenderView.setOnStateChangedListener(new VideoPlayerStateChangedListener(this));
        // 播放结束
        mAliyunRenderView.setOnCompletionListener(new VideoPlayerCompletionListener(this));
        // 播放信息监听
        mAliyunRenderView.setOnInfoListener(new VideoPlayerInfoListener(this));
        // 第一帧显示
        mAliyunRenderView.setOnRenderingStartListener(new VideoPlayerRenderingStartListener(this));
        // trackChange监听
        mAliyunRenderView.setOnTrackChangedListener(new VideoPlayerTrackChangedListener(this));
        // 字幕显示和隐藏
        mAliyunRenderView.setOnSubtitleDisplayListener(new VideoPlayerSubtitleDeisplayListener(this));
        // seek结束事件
        mAliyunRenderView.setOnSeekCompleteListener(new VideoPlayerOnSeekCompleteListener(this));
        // sei监听事件
        mAliyunRenderView.setOnSeiDataListener(new VideoPlayerOnSeiDataListener(this));
        mAliyunRenderView.setOnVerifyTimeExpireCallback(new VideoPlayerOnVerifyStsCallback(this));
    }

    /**
     * 初始化手势view
     */
    private void initGestureView() {

        mGestureView = new GestureView(getContext());
        addSubView(mGestureView);

        // 设置手势监听
        mGestureView.setOnGestureListener(simpleGestureListener);
    }

    /**
     * 手势监听简化版
     */
    SimpleGestureListener simpleGestureListener = new SimpleGestureListener() {

        // 单机
        @Override
        public void onSingleTap() {

            if (mNetChangeLayoutView.isShow()) {
                return;
            }

            // 单击事件，显示控制栏
            if (mControlView != null) {
                if (!mControlView.getControlBarIsShow()) {
                    mControlView.show();
                } else {
                    mControlView.hide(ControlView.HideType.Normal);
                }
            }

            // 处于小窗
            if (isSpecialPlayState){
                // 切换播放状态
                switchPlayerState();
            }

        }

        // 单机
        @Override
        public void onDoubleTap() {

            if (mNetChangeLayoutView.isShow()) {
                return;
            }

            if (playResourceType == LIVE || playResourceType == REVIEW) {
                return;
            }

            // 双击事件，控制暂停播放
            if (mIsScreenCosting || (GlobalPlayerConfig.IS_TRAILER)) {
                // 投屏状态下或者试看结束时双击不做任何操作
            } else if (GlobalPlayerConfig.IS_TRAILER && mAdvVideoPlayerState == IPlayer.started) {
                // 如果是视频广告,并且视频广告在播放中,那么不做任何操作
            } else {
                // 切换播放状态
                switchPlayerState();
            }
        }

        @Override
        public void onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) {
            super.onScroll(e1, e2, distanceX, distanceY);
        }
    };

    /**
     * 初始化跑马灯控件
     */
    private void initMarquee() {
        mMarqueeView = new MarqueeView(getContext());
        addSubViewHeightWrap(mMarqueeView);
    }

    /**
     * 添加子View到布局中,高度设置为 WRAP_CONTENT
     *
     * @param view 子view
     */
    private void addSubViewHeightWrap(View view) {

        LayoutParams params = new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT);
        switch (MARQUEE_REGION) {
            case TOP:
                params.addRule(RelativeLayout.ALIGN_PARENT_TOP);
                break;
            case MIDDLE:
                params.addRule(RelativeLayout.CENTER_VERTICAL);
                break;
            case BOTTOM:
                params.addRule(RelativeLayout.ALIGN_PARENT_BOTTOM);
                break;
            default:
                params.addRule(RelativeLayout.ALIGN_PARENT_TOP);
                break;
        }
        // 添加到布局中
        addView(view, params);
    }

    /**
     * 初始化提示view，包括错误提示、重试提示、直播结束提示、直播垫片等视图
     */
    private void initTipsView() {

        // 包括错误提示、重试提示、直播结束提示、直播垫片等视图
        mTipsView = new TipsView(getContext());
        addSubView(mTipsView);

        // 设置tip中的点击监听事件
        mTipsView.setOnTipClickListener(onTipClickListener);
    }

    /**
     * 提示view点击回调，包括错误提示、重试提示、直播结束提示、直播垫片等视图
     */
    OnTipClickListener onTipClickListener = new OnTipClickListener() {

        @Override
        public void onContinuePlay() {

            mIsOperatorPlay = true;
            // 继续播放。如果没有prepare或者stop了，需要重新prepare
            mTipsView.hideAll();
            if (GlobalPlayerConfig.IS_VIDEO) {
                if (mAliyunRenderView != null) {
                    mAliyunRenderView.start();
                }
                if (mControlView != null) {
                    mControlView.setHideType(ViewAction.HideType.Normal);
                }
                if (mGestureView != null) {
                    mGestureView.setVisibility(VISIBLE);
                    mGestureView.setHideType(ViewAction.HideType.Normal);
                }
                if (mNetChangeLayoutView != null) {
                    mNetChangeLayoutView.hide(ViewAction.HideType.Normal);
                }
            } else {
                if (mPlayerState == IPlayer.idle || mPlayerState == IPlayer.stopped || mPlayerState == IPlayer.error
                        || mPlayerState == IPlayer.completion) {
                    mAliyunRenderView.setAutoPlay(true);
                    if (mAliyunPlayAuth != null) {
                        prepareAuth(mAliyunPlayAuth);
                    } else if (mAliyunVidSts != null) {
                        prepareVidsts(mAliyunVidSts);
                    } else if (mAliyunVidMps != null) {
                        prepareMps(mAliyunVidMps);
                    } else if (mAliyunLocalSource != null) {
                        prepareLocalSource(mAliyunLocalSource);
                    } else if (mAliyunLiveSts != null) {
                        prepareLiveSts(mAliyunLiveSts);
                    }
                } else {
                    start();
                }
            }
        }

        @Override
        public void onStopPlay() {

            // 结束播放
            mTipsView.hideAll();
            stop();

            Context context = getContext();
            if (context instanceof Activity) {
                ((Activity) context).finish();
            }
        }

        @Override
        public void onRetryPlay(int errorCode) {

            if (mOutOnTipClickListener != null) {
                mOutOnTipClickListener.onRetryPlay(errorCode);
            }
            reTry();
        }

        @Override
        public void onReplay() {
            // 重播
            rePlay();
        }

        @Override
        public void onRefreshSts() {
        }

        @Override
        public void onWait() {
            mTipsView.hideAll();
            mTipsView.showNetLoadingTipView();
        }

        @Override
        public void onExit() {
            mTipsView.hideAll();
            if (mOutOnTipClickListener != null) {
                mOutOnTipClickListener.onExit();
            }
        }
    };

    /**
     * 初始化控制栏view
     */
    private void initControlView() {

        mControlView = new ControlView(getContext(), playResourceType);
        addSubView(mControlView);

        // 设置播放按钮点击
        mControlView.setOnPlayStateClickListener(new ControlView.OnPlayStateClickListener() {
            @Override
            public void onPlayStateClick() {

                if (mNetChangeLayoutView.isShow()) {
                    return;
                }

                // 切换播放状态。点播播放按钮之后的操作
                switchPlayerState();
            }
        });

        // 设置进度条的seek监听
        mControlView.setOnSeekListener(new OnSeekListener() {
            @Override
            public void onSeekEnd(int position) {
                if (mNetChangeLayoutView.isShow()) {
                    return;
                }
                if (mControlView != null) {
                    mControlView.setVideoPosition(position);
                }
                if (isCompleted) {
                    // 播放完成了，不能seek了
                    inSeek = false;
                } else {

                    // 拖动结束后，开始seek
                    seekTo(position);
                }
            }

            @Override
            public void onSeekStart(int position) {
                if (mNetChangeLayoutView.isShow()) {
                    return;
                }
                // 拖动开始
                inSeek = true;
            }

            @Override
            public void onProgressChanged(int progress) {

            }
        });

        // 分享点击
        mControlView.setOnShareClickListener(new OnShareClickListener() {
            @Override
            public void onShareClick() {
                if (mNetChangeLayoutView.isShow()) {
                    return;
                }
                if (mOnShareClickListener != null) {
                    mOnShareClickListener.onShareClick();
                }
            }
        });

        // 点击全屏/小屏按钮
        mControlView.setOnScreenModeClickListener(new OnScreenModeClickListener() {
            @Override
            public void onClick() {
                if (mNetChangeLayoutView.isShow()) {
                    return;
                }
                if (mCurrentScreenMode == AliyunScreenMode.Small) {
                    changedToLandForwardScape(true);
                } else if (mCurrentScreenMode == AliyunScreenMode.Full) {
                    changedToPortrait(true);
                }
            }
        });

        // 点击了标题栏的返回按钮
        mControlView.setOnBackClickListener(new OnBackClickListener() {
            @Override
            public void onClick() {
                backClick();
            }
        });

    }

    /**
     * 初始化封面
     */
    private void initCoverView() {

        // 创建一个封面视图添加到布局中
        mCoverView = new ImageView(getContext());
        mCoverView.setId(R.id.custom_id_min);
        mCoverView.setScaleType(ImageView.ScaleType.CENTER_CROP);
        mCoverView.setAdjustViewBounds(true);
        addSubView(mCoverView);

        // 封面点击事件
        mCoverView.setOnClickListener(new BaseClickListener() {
            @Override
            protected void onNoDoubleClick(View v) {

                if (onPlayStateBtnClickListener != null) {
                    onPlayStateBtnClickListener.onPlayBtnClick(IPlayer.idle);
                }

                // 开始播放
                start();
                // 设置是否显示控制栏
                setControlBarCanShow(true);

                // 隐藏封面和视频时长视图
                if (mCoverView.getVisibility() == View.VISIBLE) {
                    mCoverView.setVisibility(View.GONE);
                    mVideoDurationView.setVisibility(GONE);
                }
            }
        });
    }

    /**
     * 视频时长视图
     */
    private void initDurationView() {

        mVideoDurationView = new VideoDurationView(getContext());
        addSubView(mVideoDurationView);
        mVideoDurationView.setVisibility(GONE);
    }

    /**
     * 初始化网络监听
     */
    private void initNetWatchdog() {

        Context context = getContext();

        mNetWatchdog = new NetWatchdog(context);
        mNetWatchdog.setNetConnectedListener(new MyNetConnectedListener(this));

        if (mNetWatchdogUtils == null) {
            //添加网络监听
            mNetWatchdogUtils = new NetWatchdogUtils(getContext());
            mNetWatchdogUtils.setNetChangeListener(simpleNetChangeListener);
            mNetWatchdogUtils.startWatch();
        }
    }

    /**
     * 网络回调监听
     */
    SimpleNetChangeListener simpleNetChangeListener = new SimpleNetChangeListener() {

        @Override
        public void onWifiTo4G() {

            //播放的数据类型 0普通视频 1回放 2预告 3直播
            changeNetWorkView();
            if (playResourceType == LIVE && Constants.Video_Playback == 1 && !Constants.isShowNetTips) {
                double ratio = NumberUtil.divNum(16, 9);
                int playViewHeight = (int) NumberUtil.divNum(ScreenUtils.getRealWidth(), ratio);
                ToastNightUtil.showTopShort("这是一个非Wi-Fi环境。请注意流量消耗", playViewHeight / 2);
                Constants.isShowNetTips = true;
            }
        }
    };

    /**
     * 初始化直播网络失败
     */
    private void iniNetChangeLayoutView() {

        mNetChangeLayoutView = new NetChangeLayoutView(getContext());
        addSubView(mNetChangeLayoutView);
        mNetChangeLayoutView.hide(ViewAction.HideType.Normal);
    }

    /**
     * 隐藏手势和控制栏和网络
     */
    private void hideGestureAndControlViews() {

        if (mGestureView != null) {
            mGestureView.hide(ViewAction.HideType.Normal);
        }

        if (mControlView != null) {
            mControlView.hide(ViewAction.HideType.Normal);
        }

        if (mNetChangeLayoutView != null) {
            mNetChangeLayoutView.hide(ViewAction.HideType.Normal);
        }
    }

    /**
     * 屏幕方向变为横屏。
     *
     * @param fromPort 是否从竖屏变过来
     */
    public void changedToLandForwardScape(boolean fromPort) {
        // 如果不是从竖屏变过来，也就是一直是横屏的时候，就不用操作了
        if (!fromPort) {
            return;
        }
        this.removeView(mHideNavBarView);
        this.addView(mHideNavBarView);
        changeScreenMode(AliyunScreenMode.Full, false);
        if (orientationChangeListener != null) {
            orientationChangeListener.orientationChange(fromPort, mCurrentScreenMode);
        }
    }

    /**
     * 屏幕方向变为横屏。
     *
     * @param fromPort 是否从竖屏变过来
     */
    public void changedToLandReverseScape(boolean fromPort) {
        // 如果不是从竖屏变过来，也就是一直是横屏的时候，就不用操作了
        if (!fromPort) {
            return;
        }
        this.removeView(mHideNavBarView);
        this.addView(mHideNavBarView);
        changeScreenMode(AliyunScreenMode.Full, true);
        if (orientationChangeListener != null) {
            orientationChangeListener.orientationChange(fromPort, mCurrentScreenMode);
        }
    }

    /**
     * 屏幕方向变为竖屏
     *
     * @param fromLand 是否从横屏转过来
     */
    public void changedToPortrait(boolean fromLand) {
        // 屏幕转为竖屏
        if (mIsFullScreenLocked) {
            return;
        }

        if (mCurrentScreenMode == AliyunScreenMode.Full) {
            // 没有固定竖屏，就变化mode
            if (fromLand) {
                this.removeView(mHideNavBarView);
                changeScreenMode(AliyunScreenMode.Small, false);
            } else {
                // 如果没有转到过横屏，就不让他转了。防止竖屏的时候点横屏之后，又立即转回来的现象
            }
        } else if (mCurrentScreenMode == AliyunScreenMode.Small) {
            // 竖屏的情况转到了竖屏
        }
        if (orientationChangeListener != null) {
            orientationChangeListener.orientationChange(fromLand, mCurrentScreenMode);
        }
    }

    /**
     * 获取整体缓冲进度
     *
     * @return 整体缓冲进度
     */
    public int getBufferPercentage() {
        if (mAliyunRenderView != null) {
            // 整体缓冲进度
            int mCurrentBufferPercentage = 0;
            return mCurrentBufferPercentage;
        }
        return 0;
    }

    /**
     * 重置。包括一些状态值，view的状态等
     */
    private void reset() {

        isCompleted = false;
        inSeek = false;
        mCurrentPosition = 0;
        mVideoBufferedPosition = 0;

        if (mTipsView != null) {
            mTipsView.hideAll();
        }
        if (mControlView != null) {
            mControlView.reset();
        }
        if (mNetChangeLayoutView != null) {
            mNetChangeLayoutView.reset();
        }
        if (mGestureView != null) {
            mGestureView.reset();
        }
        stop();
    }

    public ControlView getControlView() {
        return mControlView;
    }

    /**
     * 返回
     */
    public void backClick() {
        if (mNetChangeLayoutView.isShow()) {
            return;
        }
        if (mCurrentScreenMode == AliyunScreenMode.Full) {
            if (isLocalSource()) {
                // 如果播放的是本地视频,并且是全屏模式下点击返回按钮,则需要关闭Activity
                if (orientationChangeListener != null) {
                    orientationChangeListener.orientationChange(false, AliyunScreenMode.Small);
                }
            } else {
                //屏幕方向变为竖屏
                changedToPortrait(true);
            }
        } else if (mCurrentScreenMode == AliyunScreenMode.Small) {
            // 小屏状态下，就结束活动
            Context context = getContext();
            if (context instanceof Activity) {
                ((Activity) context).finish();
            }
        }
    }

    /**
     * 控制大小屏切换按钮的可见性
     */
    public void setScreenModeBtnVisible(boolean visible) {
        if (mControlView != null) {
            mControlView.setScreenModeBtnVisible(visible);
        }
    }

    /**
     * 更多按钮的可见性
     */
    public void setMoreBtnVisible(boolean visible) {
        if (mControlView != null) {
            mControlView.setMoreBtnVisible(visible);
        }
    }


    public void setOnTipClickListener(OnTipClickListener listener) {
        this.mOutOnTipClickListener = listener;
    }

    /**
     * 切换播放状态。点播播放按钮之后的操作
     */
    private void switchPlayerState() {

        // 非投屏状态下的处理
        if (mPlayerState == IPlayer.started) {
            pause();
        } else if (mPlayerState == IPlayer.paused || mPlayerState == IPlayer.prepared || mPlayerState == IPlayer.stopped) {
            start();
        } else if (mPlayerState == IPlayer.completion) {
            rePlay();
        }

        if (onPlayStateBtnClickListener != null) {
            onPlayStateBtnClickListener.onPlayBtnClick(mPlayerState);
        }
    }

    /**
     * 初始化字幕
     */
    private void initSubtitleView() {

        mSubtitleView = new SubtitleView(getContext());
        mSubtitleView.setId(R.id.alivc_player_subtitle);
        SubtitleView.DefaultValueBuilder defaultValueBuilder = new SubtitleView.DefaultValueBuilder();
        defaultValueBuilder.setLocation(LocationStyle.Location_Center);
        defaultValueBuilder.setColor("#e7e7e7");
        mSubtitleView.setDefaultValue(defaultValueBuilder);
        addSubView(mSubtitleView);

        mAssSubtitleView = new AssSubtitleView(getContext());
        mAssSubtitleView.setId(R.id.cicada_player_ass_subtitle);
        addSubViewByCenter(mAssSubtitleView);
    }

    /**
     * 判断是否开启精准seek
     */
    private void isAutoAccurate(long position) {

        if (GlobalPlayerConfig.PlayConfig.mEnableAccurateSeekModule) {
            mAliyunRenderView.seekTo(position, IPlayer.SeekMode.Accurate);
        } else {
            mAliyunRenderView.seekTo(position, IPlayer.SeekMode.Inaccurate);
        }
    }

    /**
     * 判断是否是本地资源
     */
    private boolean isLocalSource() {

        String scheme = null;
        if (GlobalPlayerConfig.PLAYTYPE.STS.equals(GlobalPlayerConfig.mCurrentPlayType)
                || GlobalPlayerConfig.PLAYTYPE.MPS.equals(GlobalPlayerConfig.mCurrentPlayType)
                || GlobalPlayerConfig.PLAYTYPE.AUTH.equals(GlobalPlayerConfig.mCurrentPlayType)
                || GlobalPlayerConfig.PLAYTYPE.DEFAULT.equals(GlobalPlayerConfig.mCurrentPlayType)) {
            return false;
        }
        if (mAliyunLocalSource == null || TextUtils.isEmpty(mAliyunLocalSource.getUri())) {
            return false;
        }
        if (GlobalPlayerConfig.PLAYTYPE.URL.equals(GlobalPlayerConfig.mCurrentPlayType)) {
            Uri parse = Uri.parse(mAliyunLocalSource.getUri());
            scheme = parse.getScheme();
        }
        return scheme == null;
    }

    /**
     * 显示错误提示
     *
     * @param errorCode  错误码
     * @param errorEvent 错误事件
     * @param errorMsg   错误描述
     */
    public void showErrorTipView(int errorCode, String errorEvent, String errorMsg) {

        stop();

        if (mControlView != null) {
            mControlView.setPlayState(ControlView.PlayState.NotPlaying);
        }

        if (mTipsView != null) {

            // 隐藏其他的动作,防止点击界面去进行其他操作
            mGestureView.hide(ViewAction.HideType.End);
            //不自动隐藏标题
            mControlView.closeAutoHide();
            //报错隐藏全屏按钮
            mControlView.hideScreenModeBtnInSmallScreenMode();

            mCoverView.setVisibility(GONE);
            mTipsView.showErrorTipView(errorCode, errorEvent, "Sorry, video playback failed");
        }

    }

    /**
     * addSubView 添加子view到布局中
     *
     * @param view 子view
     */
    private void addSubView(View view) {

        LayoutParams params = new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);
        // 添加到布局中
        addView(view, params);
    }

    /**
     * 添加子View到布局中央
     */
    private void addSubViewByCenter(View view) {

        LayoutParams params = new LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT);
        params.addRule(RelativeLayout.CENTER_IN_PARENT);
        addView(view, params);
    }

    /**
     * 改变屏幕模式：小屏或者全屏。
     *
     * @param targetMode {@link AliyunScreenMode}
     */
    public void changeScreenMode(AliyunScreenMode targetMode, boolean isReverse) {

        AliyunScreenMode finalScreenMode = targetMode;

        if (mIsFullScreenLocked) {
            finalScreenMode = AliyunScreenMode.Full;
        }

        // 这里可能会对模式做一些修改
        if (targetMode != mCurrentScreenMode) {
            mCurrentScreenMode = finalScreenMode;
        }

        if (mControlView != null) {
            mControlView.setScreenModeStatus(finalScreenMode);
        }

        if (mMarqueeView != null) {
            mMarqueeView.setScreenMode(finalScreenMode);
        }

        Context context = getContext();
        if (context instanceof Activity) {
            if (finalScreenMode == AliyunScreenMode.Full) {
                if (isReverse) {
                    ((Activity) context).setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE);
                } else {
                    ((Activity) context).setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
                }

            } else if (finalScreenMode == AliyunScreenMode.Small) {

                ((Activity) context).setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
                if (mMarqueeView != null) {
                    mMarqueeView.pause();
                }
            }
        }
    }

    /**
     * 获取当前屏幕模式：小屏、全屏
     *
     * @return 当前屏幕模式
     */
    public AliyunScreenMode getScreenMode() {
        return mCurrentScreenMode;
    }

    public void setScreenMode(AliyunScreenMode mCurrentScreenMode) {
        this.mCurrentScreenMode = mCurrentScreenMode;
    }

    /**
     * 设置停止播放监听
     *
     * @param onStoppedListener 停止播放监听
     */
    public void setOnStoppedListener(OnStoppedListener onStoppedListener) {
        this.mOnStoppedListener = onStoppedListener;
    }

    /**
     * 设置加载状态监听
     *
     * @param onLoadingListener 加载状态监听
     */
    public void setOnLoadingListener(IPlayer.OnLoadingStatusListener onLoadingListener) {
        if (mAliyunRenderView != null) {
            mAliyunRenderView.setOnLoadingStatusListener(onLoadingListener);
        }
    }

    /**
     * 设置视频宽高变化监听
     *
     * @param onVideoSizeChangedListener 视频宽高变化监听
     */
    public void setOnVideoSizeChangedListener(IPlayer.OnVideoSizeChangedListener onVideoSizeChangedListener) {
        if (mAliyunRenderView != null) {
            mAliyunRenderView.setOnVideoSizeChangedListener(onVideoSizeChangedListener);
        }
    }

    /**
     * 设置PlayAuth的播放方式
     *
     * @param aliyunPlayAuth auth
     */
    public void setAuthInfo(VidAuth aliyunPlayAuth) {

        if (mAliyunRenderView == null) {
            return;
        }

        // 重置界面
        clearAllSource();
        reset();

        mAliyunPlayAuth = aliyunPlayAuth;

        // 具体的准备操作
        prepareAuth(aliyunPlayAuth);
    }

    /**
     * 设置Mps播放方式
     */
    public void setVidMps(VidMps vidMps) {

        if (mAliyunRenderView == null) {
            return;
        }

        // 重置界面
        clearAllSource();

        reset();

        mAliyunVidMps = vidMps;

        // 具体的准备操作
        prepareMps(vidMps);
    }

    /**
     * 通过playAuth prepare
     *
     * @param aliyunPlayAuth 源
     */
    private void prepareAuth(VidAuth aliyunPlayAuth) {

        if (mTipsView != null) {
            mTipsView.showNetLoadingTipView();
        }

        mAliyunRenderView.setDataSource(aliyunPlayAuth);
        mAliyunRenderView.prepare();
    }

    /**
     * 通过Mps prepare
     */
    private void prepareMps(VidMps vidMps) {
        if (mTipsView != null) {
            mTipsView.showNetLoadingTipView();
        }
        mAliyunRenderView.setDataSource(vidMps);
        mAliyunRenderView.prepare();
    }

    /**
     * 清空之前设置的播放源
     */
    private void clearAllSource() {
        mAliyunPlayAuth = null;
        mAliyunVidSts = null;
        mAliyunLocalSource = null;
        mAliyunVidMps = null;
        mAliyunLiveSts = null;
    }

    /**
     * 准备LiveSts源
     */
    public void setLiveStsDataSource(LiveSts liveSts) {
        if (mAliyunRenderView == null) {
            return;
        }

        clearAllSource();
        reset();
        mAliyunLiveSts = liveSts;
        prepareLiveSts(liveSts);
    }

    /**
     * 设置播放源
     */
    public void setLocalSource(String url) {
        UrlSource urlSource = new UrlSource();
        urlSource.setUri(url);
        setLocalSource(urlSource);
    }

    /**
     * 设置播放源
     */
    public void setLocalSource(UrlSource aliyunLocalSource) {
        if (mAliyunRenderView == null) {
            return;
        }

        clearAllSource();
        reset();
        // 播放本地资源,需要清空VIDEO_FUNCTION
        mAliyunLocalSource = aliyunLocalSource;
        if (!show4gTips()) {
            prepareLocalSource(aliyunLocalSource);
        }
    }

    /**
     * 判断是否展示4g提示,内部进行了判断
     * 1.不是本地视频
     * 2.当前网络是4G
     * 满足上述条件才会展示4G提示
     *
     * @return true:需要展示,false不需要
     */
    private boolean show4gTips() {

        //播放本地文件不需要提示
        if (isLocalSource()) {
            return false;
        }

        //不是本地文件
        if (NetWatchdog.is4GConnected(getContext())) {
            //运营商自动播放,则Toast提示后,继续播放
            return !mIsOperatorPlay;
        } else {
            return false;
        }
    }

    /**
     * prepare本地播放源
     *
     * @param aliyunLocalSource 本地播放源
     */
    private void prepareLocalSource(UrlSource aliyunLocalSource) {

        if (mTipsView != null) {
            mTipsView.showNetLoadingTipView();
        }

        // 如果是本地视频，则全屏播放
        if (isLocalSource() && mIsNeedOnlyFullScreen) {
            changeScreenMode(AliyunScreenMode.Full, false);
        }

        if (aliyunLocalSource != null && aliyunLocalSource.getUri().startsWith("artc")) {
            Logger.t(TAG).e("artc setPlayerConfig");
            PlayerConfig playerConfig = mAliyunRenderView.getPlayerConfig();
            playerConfig.mMaxDelayTime = 1000;
            playerConfig.mHighBufferDuration = 10;
            playerConfig.mStartBufferDuration = 10;
            mAliyunRenderView.setPlayerConfig(playerConfig);
        }

        mAliyunRenderView.setAutoPlay(true);
        mAliyunRenderView.setDataSource(aliyunLocalSource);
        mAliyunRenderView.prepare();
    }

    /**
     * 准备vidsts源
     *
     * @param vidSts 源
     */
    public void setVidSts(VidSts vidSts) {
        if (mAliyunRenderView == null) {
            return;
        }
        clearAllSource();
        reset();
        mAliyunVidSts = vidSts;
        showVideoFunction();
    }

    /**
     * 展示播放器不同的功能
     */
    private void showVideoFunction() {
        if (mAliyunRenderView != null) {
            mPlayerState = IPlayer.stopped;
            mAliyunRenderView.stop();
        }

        if (mControlView != null) {
            mControlView.showNativeSeekBar();
        }

    }

    public void updateStsInfo(StsInfo stsInfo) {
        if (mAliyunRenderView != null) {
            mAliyunRenderView.updateStsInfo(stsInfo);
        }
    }

    public void updateAuthInfo(VidAuth vidAuth) {
        if (mAliyunRenderView != null) {
            mAliyunRenderView.updateAuthInfo(vidAuth);
        }
    }

    /**
     * 准备vidsts 源
     */
    private void prepareVidsts(VidSts vidSts) {

        if (mTipsView != null) {
            mTipsView.showNetLoadingTipView();
        }

        if (mAliyunRenderView != null) {
            mAliyunRenderView.setDataSource(vidSts);
            mAliyunRenderView.prepare();
        }
    }

    /**
     * 准备LiveSts 源
     */
    private void prepareLiveSts(LiveSts mAliyunLiveSts) {

        if (mTipsView != null) {
            mTipsView.showNetLoadingTipView();
        }

        if (mAliyunRenderView != null) {
            mAliyunRenderView.setDataSource(mAliyunLiveSts);
            mAliyunRenderView.prepare();
        }
    }

    /**
     * 运营商是否自动播放
     *
     * @param isOperatorPlay true为自动播放,false会有tips
     */
    public void setOperatorPlay(boolean isOperatorPlay) {
        this.mIsOperatorPlay = isOperatorPlay;
    }

    /**
     * 暂停播放器的操作
     */
    public void onStop() {

        stopOrientationWatchDog();
        // 保存播放器的状态，供resume恢复使用。
        savePlayerState();
    }

    /**
     * 开启屏幕旋转监听
     */
    public void startOrientationWatchDog() {
        if (mOrientationWatchDog != null) {
            mOrientationWatchDog.startWatch();
        }
    }

    /**
     * 关闭屏幕旋转监听
     */
    public void stopOrientationWatchDog() {
        if (mOrientationWatchDog != null) {
            mOrientationWatchDog.stopWatch();
        }
    }

    /**
     * Activity回来后，恢复之前的状态
     */
    private void resumePlayerState() {
        if (mAliyunRenderView == null) {
            return;
        }
        if (playResourceType == LIVE && mPlayerState == IPlayer.stopped) {
            // 直播
            mAliyunRenderView.prepare();
        } else {
            start();
        }
    }

    /**
     * 保存当前的状态，供恢复使用
     */
    private void savePlayerState() {
        if (mAliyunRenderView == null) {
            return;
        }
        if (playResourceType == LIVE) {
            // 直播调用stop
            mPlayerState = IPlayer.stopped;
            mAliyunRenderView.stop();
        } else {
            pause();
        }
    }

    /**
     * 获取媒体信息
     *
     * @return 媒体信息
     */
    public MediaInfo getMediaInfo() {
        if (mAliyunRenderView != null) {
            return mAliyunRenderView.getMediaInfo();
        }

        return null;
    }

    /**
     * 是否只需要全屏播放,只在播放本地视频和URL播放方式下生效
     */
    public void needOnlyFullScreenPlay(boolean isNeed) {
        mIsNeedOnlyFullScreen = isNeed;
    }

    /**
     * 是否处于播放状态：start或者pause了
     *
     * @return 是否处于播放状态
     */
    public boolean isPlaying() {
        return mPlayerState == IPlayer.started;
    }

    /**
     * 获取播放器状态
     *
     * @return 播放器状态
     */
    public int getPlayerState() {
        return mPlayerState;
    }

    /**
     * reload
     */
    public void reload() {
        if (mAliyunRenderView != null) {
            mAliyunRenderView.reload();
        }
    }

    /**
     * 开始播放
     */
    public void start() {

        if (mControlView != null) {
            mControlView.setPlayState(ControlView.PlayState.Playing);
        }

        if (mAliyunRenderView == null) {
            return;
        }

        if (mAdvVideoPlayerState == IPlayer.started && GlobalPlayerConfig.IS_VIDEO) {
            mControlView.setHideType(ViewAction.HideType.Normal);
            mGestureView.setHideType(ViewAction.HideType.Normal);

        } else {
            mGestureView.show();
            mControlView.show();
        }
        if (playResourceType == LIVE && mPlayerState == IPlayer.stopped) {
            // 直播
            mAliyunRenderView.prepare();
        } else {
            mAliyunRenderView.start();
            //语音播报播放中 且 音频被占用 变成暂停

        }

        if (mMarqueeView != null && mMarqueeView.isStart() && mCurrentScreenMode == AliyunScreenMode.Full) {
            mMarqueeView.startFlip();
        }
    }

    /**
     * 暂停播放
     */
    public void pause() {

        if (mControlView != null && !mIsScreenCosting) {
            mControlView.setPlayState(ControlView.PlayState.NotPlaying);
        }
        if (mAliyunRenderView == null) {
            return;
        }
        if (mPlayerState == IPlayer.started || mPlayerState == IPlayer.prepared) {
            if (playResourceType == LIVE) {
                // 直播调用stop
                mPlayerState = IPlayer.stopped;
                mAliyunRenderView.stop();
            } else {
                mAliyunRenderView.pause();
            }

            if (mMarqueeView != null) {
                mMarqueeView.pause();
            }
        }
    }

    /**
     * 停止播放
     */
    private void stop() {

        Boolean hasLoadedEnd = null;
        MediaInfo mediaInfo = null;
        if (mAliyunRenderView != null && hasLoadEnd != null) {
            mediaInfo = mAliyunRenderView.getMediaInfo();
            hasLoadedEnd = hasLoadEnd.get(mediaInfo);
        }

        if (mAliyunRenderView != null && hasLoadedEnd != null) {
            mPlayerState = IPlayer.stopped;
            mAliyunRenderView.stop();
        }
        if (mControlView != null) {
            mControlView.setPlayState(ControlView.PlayState.NotPlaying);
        }
        if (hasLoadEnd != null) {
            hasLoadEnd.remove(mediaInfo);
        }
    }

    /**
     * 停止后是否显示最后一帧
     */
    public void clearFrameWhenStop(boolean clearFrameWhenStop) {
        if (mAliyunRenderView != null) {
            PlayerConfig config = mAliyunRenderView.getPlayerConfig();
            config.mClearFrameWhenStop = clearFrameWhenStop;
            mAliyunRenderView.setPlayerConfig(config);
        }
    }

    /**
     * seek操作
     *
     * @param position 目标位置
     */
    public void seekTo(long position) {

        if (mAliyunRenderView == null) {
            return;
        }
        inSeek = true;
        reallySeekToFunction(position);
    }

    private void reallySeekToFunction(long position) {

        // 这里由于如果是视频广告seekEnd返回的progress是包含了视频广告的时间,而这里的seek,需要的是原视频的seek时间,所以需要减去视频广告的时间
        if (GlobalPlayerConfig.IS_VIDEO) {
            // 广告视频播放次数计数
            int mAdvVideoCount = 0;
            isAutoAccurate(position - mAdvVideoCount);
        } else {
            isAutoAccurate(position);
        }
        mAliyunRenderView.start();

        if (mControlView != null) {
            mControlView.setPlayState(ControlView.PlayState.Playing);
        }
    }

    /**
     * 让home键无效
     *
     * @param keyCode 按键
     * @param event   事件
     * @return 是否处理。
     */
    @Override
    public boolean onKeyDown(int keyCode, KeyEvent event) {
        if (keyCode != KeyEvent.KEYCODE_HOME && keyCode != KeyEvent.KEYCODE_VOLUME_UP && keyCode != KeyEvent.KEYCODE_VOLUME_DOWN) {
            if (mCurrentScreenMode == AliyunScreenMode.Full) {
                changedToPortrait(true);
                return false;
            } else if (mCurrentScreenMode == AliyunScreenMode.AMPLIFY) {
                //模拟点击缩放按钮
                getControlView().getScreenModeBtn().performClick();
                return false;
            }
        }
        if (mIsFullScreenLocked && (keyCode != KeyEvent.KEYCODE_HOME)) {
            return false;
        }
        return true;
    }

    /**
     * 设置分享按钮点击监听
     */
    public void setOnShareClickListener(OnShareClickListener onShareClickListener) {
        this.mOnShareClickListener = onShareClickListener;
    }

    /**
     * 设置播放状态点击监听
     */
    public void setOnPlayStateBtnClickListener(OnPlayStateBtnClickListener listener) {
        this.onPlayStateBtnClickListener = listener;
    }

    public void setOnSeekStartListener(OnSeekStartListener listener) {
        this.onSeekStartListener = listener;
    }

    public void setOrientationChangeListener(OnOrientationChangeListener listener) {
        this.orientationChangeListener = listener;
    }

    /**
     * 原视频准备完成
     */
    public void sourceVideoPlayerPrepared() {

        if (mAliyunRenderView == null) {
            return;
        }
        mAliyunMediaInfo = mAliyunRenderView.getMediaInfo();
        if (mAliyunMediaInfo == null) {
            return;
        }
        // 防止服务器信息和实际不一致
        mSourceDuration = mAliyunRenderView.getDuration();
        mAliyunMediaInfo.setDuration((int) mSourceDuration);

        // 使用用户设置的标题
        if (!GlobalPlayerConfig.IS_VIDEO) {

            TrackInfo trackInfo = mAliyunRenderView.currentTrack(TrackInfo.Type.TYPE_VOD.ordinal());
            if (trackInfo != null) {
                mControlView.setMediaInfo(mAliyunMediaInfo, mAliyunRenderView.currentTrack(TrackInfo.Type.TYPE_VOD.ordinal()).getVodDefinition());
            } else {
                mControlView.setMediaInfo(mAliyunMediaInfo, "FD");
            }

            mControlView.setScreenModeStatus(mCurrentScreenMode);
            mControlView.show();
            mGestureView.show();
        }

        mControlView.setHideType(ViewAction.HideType.Normal);
        mGestureView.setHideType(ViewAction.HideType.Normal);
        if (mTipsView != null) {
            mTipsView.hideNetLoadingTipView();
            mTipsView.hideBufferLoadingTipView();
        }

    }

    /**
     * 原视频错误监听
     */
    public void sourceVideoPlayerError(ErrorInfo errorInfo) {
        if (mTipsView != null) {
            mTipsView.hideAll();
        }
        // 出错之后解锁屏幕，防止不能做其他操作，比如返回。
        lockScreen(false);

        // errorInfo.getExtra()展示为null,修改为显示errorInfo.getCode的十六进制的值
        showErrorTipView(errorInfo.getCode().getValue(), Integer.toHexString(errorInfo.getCode().getValue()),
                errorInfo.getMsg());

        LiveDataBus.getInstance().with(EventConstants.LIVE_PYBK_ERROR).postValue(errorInfo);

    }

    public void setPlayResourceType(int playResourceType, boolean isVR) {
        this.playResourceType = playResourceType;
        if (mControlView == null) {
            return;
        }
        mControlView.setPlayResourceType(playResourceType, isVR);
    }

    public void setTitle(String title) {

        if (mControlView == null) {
            return;
        }
        mControlView.setTitle(title);
    }

    /**
     * 直播回放或者预告展示这个
     */
    public void changeNetWorkView() {

        if ((playResourceType == REVIEW || playResourceType == PREVIEW) && Constants.Video_Playback == 1 && !Constants.isShowNetTips) {
            if (mNetChangeLayoutView != null) {
                if (mControlView != null && mControlView.getVisibility() == VISIBLE) {
                    mControlView.hide(ViewAction.HideType.Normal);
                }
                mNetChangeLayoutView.show();
                this.postDelayed(new Runnable() {
                    @Override
                    public void run() {
                        pause();
                    }
                }, 1000);
                mNetChangeLayoutView.setOnClickListener(new BaseClickListener() {
                    @Override
                    protected void onNoDoubleClick(View v) {
                        Constants.isShowNetTips = true;
                        mNetChangeLayoutView.hide(ControlView.HideType.Normal);
                        start();

                    }
                });
            }
        }
    }

    private static class VideoPlayerOnTrackReadyListener implements IPlayer.OnTrackReadyListener {

        public WeakReference<VideoAndLivePlayerView> weakReference;

        public VideoPlayerOnTrackReadyListener(VideoAndLivePlayerView playerView) {
            this.weakReference = new WeakReference<>(playerView);
        }

        @Override
        public void onTrackReady(MediaInfo mediaInfo) {
            VideoAndLivePlayerView aliyunVodPlayerView = weakReference.get();
            if (aliyunVodPlayerView != null) {
                aliyunVodPlayerView.onTrackReady(mediaInfo);
            }
        }
    }

    private void onTrackReady(MediaInfo mediaInfo) {
        if (mOutOnTrackReadyListener != null) {
            mOutOnTrackReadyListener.onTrackReady(mediaInfo);
        }
    }

    /**
     * 原视频开始加载
     */
    public void sourceVideoPlayerLoadingBegin() {

        if (mTipsView != null) {
            // 视频广告,并且广告视频在播放状态,不要展示loading
            if (GlobalPlayerConfig.IS_VIDEO && mAdvVideoPlayerState == IPlayer.started) {

            } else {
                mTipsView.hideNetLoadingTipView();
                mTipsView.showBufferLoadingTipView();
                mTipsView.updateLoadingPercent(0, currentNetSpeed);
            }
        }
    }

    /**
     * 原视频开始加载进度
     */
    public void sourceVideoPlayerLoadingProgress(int percent) {

        if (mTipsView != null) {
            // 视频广告,并且广告视频在播放状态,不要展示loading
            if (GlobalPlayerConfig.IS_VIDEO && mAdvVideoPlayerState == IPlayer.started) {

            } else {
                mTipsView.updateLoadingPercent(percent, currentNetSpeed);
            }
            if (percent == 100) {
                mTipsView.hideBufferLoadingTipView();
            }
        }
    }

    /**
     * 显示直播结束view
     */
    public void showLiveEndView() {

        if (mAliyunRenderView != null) {
            mAliyunRenderView.setVisibility(GONE);
            mAliyunRenderView.release();
            mAliyunRenderView = null;
        }

        if (mControlView != null) {
            //在小屏时隐藏全屏按钮
            mControlView.hideScreenModeBtnInSmallScreenMode();
        }
    }

    /**
     * 显示直播垫片view
     */
    public void showLiveShimView(String liveBroadcastGasket) {
        if (mTipsView == null) {
            return;
        }
        if (mAliyunRenderView != null) {
            mAliyunRenderView.setVisibility(GONE);
            onStop();
        }
        mTipsView.showLiveShimView(liveBroadcastGasket, activity_landscape);
    }

    /**
     * 隐藏直播垫片view
     */
    public void hideLiveShimView(String liveBroadcastGasket) {
        if (mTipsView == null) {
            return;
        }
        if (mAliyunRenderView != null && mAliyunRenderView.getVisibility() == GONE) {
            mAliyunRenderView.setVisibility(VISIBLE);
        }
        mTipsView.hideLiveShimView(liveBroadcastGasket, activity_landscape);
    }

    /**
     * 原视频加载结束
     */
    public void sourceVideoPlayerLoadingEnd() {

        if (mTipsView != null) {
            if (isPlaying()) {
                mTipsView.hideErrorTipView();
            }
            mTipsView.hideBufferLoadingTipView();
        }
        if (mControlView != null) {
            mControlView.setHideType(ViewAction.HideType.Normal);
        }
        if (mGestureView != null) {
            mGestureView.setHideType(ViewAction.HideType.Normal);
            mGestureView.show();
        }
        if (mNetChangeLayoutView != null) {
            mNetChangeLayoutView.setHideType(ViewAction.HideType.Normal);
        }
        hasLoadEnd.put(mAliyunMediaInfo, true);
        vodPlayerLoadEndHandler.sendEmptyMessage(1);
    }

    /**
     * 原视频状态改变监听
     */
    public void sourceVideoPlayerStateChanged(int newState) {

        mPlayerState = newState;
        if (newState == IPlayer.stopped) {
            if (mOnStoppedListener != null) {
                mOnStoppedListener.onStop();
            }
        } else if (newState == IPlayer.started) {
            if (mControlView != null) {
                mControlView.setPlayState(ControlView.PlayState.Playing);
            }
            if (mNetChangeLayoutView != null) {
                mNetChangeLayoutView.setPlayState(ControlView.PlayState.Playing);
            }
            if (NetworkUtil.isNetAvailable() && !NetworkUtil.isWifi()) {
                changeNetWorkView();
            }
        }
        if (mPlayerState == IPlayer.started || mPlayerState == IPlayer.prepared || mPlayerState == IPlayer.paused || mPlayerState == IPlayer.error) {
            if (mTipsView != null) {
                mTipsView.hideAll();
            }
        }

    }

    /**
     * 原视频播放完成
     */
    public void sourceVideoPlayerCompletion() {

        LiveDataBus.getInstance().with(EventConstants.RECEIVED_LIVE_END_PYBK, Boolean.class).postValue(true);
        inSeek = false;
        //如果当前播放资源是本地资源时, 再显示replay
        if (mTipsView != null && isLocalSource()) {
            //预约不展示重播
            if (playResourceType != PREVIEW) {
                //隐藏其他的动作,防止点击界面去进行其他操作
                mGestureView.hide(ViewAction.HideType.End);
                mControlView.hide(ViewAction.HideType.End);
                mNetChangeLayoutView.hide(ViewAction.HideType.End);
                if(showReplayView){
                    mTipsView.showReplayTipView();
                }
            }
        }

        //不是循环播放
        if (!isLoop()) {
            //false,updateAllViews重复设置了，所以加false规避
            mControlView.setPlayState(ControlView.PlayState.NotPlaying, false);
            mControlView.updateAllViews();
            if (playResourceType != PREVIEW && playResourceType != REVIEW) {
                mControlView.setRePlayVisible(true);
            }
        }

    }

    /**
     * 原视频Info
     */
    public void sourceVideoPlayerInfo(InfoBean infoBean) {

        if (infoBean.getCode() == InfoCode.AutoPlayStart) {
            // 自动播放开始,需要设置播放状态
            if (mControlView != null) {
                mControlView.setPlayState(ControlView.PlayState.Playing);
                mNetChangeLayoutView.setPlayState(ControlView.PlayState.Playing);
            }
        } else if (infoBean.getCode() == InfoCode.BufferedPosition) {
            // 更新bufferedPosition
            mVideoBufferedPosition = infoBean.getExtraValue();
            mControlView.setVideoBufferPosition((int) mVideoBufferedPosition);
        } else if (infoBean.getCode() == InfoCode.CurrentPosition) {
            // 更新currentPosition
            mCurrentPosition = infoBean.getExtraValue();

            if (mControlView != null && !inSeek && mPlayerState == IPlayer.started) {
                mControlView.setVideoPosition((int) mCurrentPosition);
            }

            if (onSeekStartListener != null && mSourceDuration != 0) {
                double percentage = (double) mCurrentPosition / mSourceDuration * 100;
                onSeekStartListener.onProgressChanged((int) percentage);
            }
        }

    }

    /**
     * 原视频onVideoRenderingStart
     */
    public void sourceVideoPlayerOnVideoRenderingStart() {

        if (mControlView != null) {
            // 开启状态栏自动隐藏的功能
            mControlView.openAutoHide();
        }
        mCoverView.setVisibility(GONE);
    }

    /**
     * 字幕显示和隐藏监听
     */
    private static class VideoPlayerSubtitleDeisplayListener implements IPlayer.OnSubtitleDisplayListener {

        private final WeakReference<VideoAndLivePlayerView> weakReference;

        public VideoPlayerSubtitleDeisplayListener(VideoAndLivePlayerView aliyunVodPlayerView) {
            weakReference = new WeakReference<>(aliyunVodPlayerView);
        }

        @Override
        public void onSubtitleExtAdded(int trackIndex, String url) {

            VideoAndLivePlayerView aliyunVodPlayerView = weakReference.get();
            if (aliyunVodPlayerView != null) {
                aliyunVodPlayerView.mAliyunRenderView.selectExtSubtitle(trackIndex, true);
            }
        }

        @Override
        public void onSubtitleShow(int trackIndex, long id, String data) {
            VideoAndLivePlayerView aliyunVodPlayerView = weakReference.get();
            if (aliyunVodPlayerView != null) {
                aliyunVodPlayerView.onSubtitleShow(trackIndex, id, data);
            }
        }

        @Override
        public void onSubtitleHide(int trackIndex, long id) {
            VideoAndLivePlayerView aliyunVodPlayerView = weakReference.get();
            if (aliyunVodPlayerView != null) {
                aliyunVodPlayerView.onSubtitleHide(trackIndex, id);
            }
        }

        @Override
        public void onSubtitleHeader(int trackIndex, String header) {
            VideoAndLivePlayerView aliyunVodPlayerView = weakReference.get();
            if (aliyunVodPlayerView != null) {
                aliyunVodPlayerView.onSubtitleHeader(trackIndex, header);
            }
        }
    }

    private void onSubtitleHeader(int trackIndex, String header) {
        if (!TextUtils.isEmpty(header)) {
            mSubtitleTypeMap.put(trackIndex, AssHeader.SubtitleType.SubtitleTypeAss);
            mAssSubtitleView.setAssHeader(header);
        }
    }

    /**
     * 字幕隐藏
     *
     * @param id 索引
     */
    private void onSubtitleHide(int trackIndex, long id) {
        if (mSubtitleTypeMap.size() > 0 && mSubtitleTypeMap.get(trackIndex) == AssHeader.SubtitleType.SubtitleTypeAss) {
            mAssSubtitleView.dismiss(id);
        } else {
            mSubtitleView.dismiss(id + "");
        }
    }

    /**
     * 字幕显示
     *
     * @param id   索引
     * @param data 数据
     */
    private void onSubtitleShow(int trackIndex, long id, String data) {
        if (mSubtitleTypeMap.size() > 0 && mSubtitleTypeMap.get(trackIndex) == AssHeader.SubtitleType.SubtitleTypeAss) {
            mAssSubtitleView.show(id, data);
        } else {
            SubtitleView.Subtitle subtitle = new SubtitleView.Subtitle();
            subtitle.id = id + "";
            subtitle.content = data;
            mSubtitleView.show(subtitle);
        }
    }

    /**
     * 播放器TrackChanged监听
     */
    private static class VideoPlayerTrackChangedListener implements IPlayer.OnTrackChangedListener {

        private final WeakReference<VideoAndLivePlayerView> weakReference;

        public VideoPlayerTrackChangedListener(VideoAndLivePlayerView aliyunVodPlayerView) {
            weakReference = new WeakReference<>(aliyunVodPlayerView);
        }

        @Override
        public void onChangedSuccess(TrackInfo trackInfo) {
            VideoAndLivePlayerView aliyunVodPlayerView = weakReference.get();
            if (aliyunVodPlayerView != null) {
                aliyunVodPlayerView.sourceVideoPlayerTrackInfoChangedSuccess(trackInfo);
            }
        }

        @Override
        public void onChangedFail(TrackInfo trackInfo, ErrorInfo errorInfo) {
            VideoAndLivePlayerView aliyunVodPlayerView = weakReference.get();
            if (aliyunVodPlayerView != null) {
                aliyunVodPlayerView.sourceVideoPlayerTrackInfoChangedFail(trackInfo, errorInfo);
            }
        }
    }

    /**
     * 原视频 trackInfoChangedSuccess
     */
    private void sourceVideoPlayerTrackInfoChangedSuccess(TrackInfo trackInfo) {
        // 清晰度切换监听
        if (trackInfo.getType() == TrackInfo.Type.TYPE_VOD) {
            if (mIsScreenCosting) {
                if (mControlView != null) {
                    mControlView.setVideoPosition((int) mCurrentPosition);
                }
            } else {
                start();
            }

            if (mTipsView != null) {
                mTipsView.hideNetLoadingTipView();
            }
        }
    }

    /**
     * 原视频 trackInfochangedFail
     */
    private void sourceVideoPlayerTrackInfoChangedFail(TrackInfo trackInfo, ErrorInfo errorInfo) {
        // 失败的话，停止播放，通知上层
        if (mTipsView != null) {
            mTipsView.hideNetLoadingTipView();
        }
        stop();
    }

    /**
     * 原视频seek完成
     */
    public void sourceVideoPlayerSeekComplete() {
        inSeek = false;
    }

    /**
     * sei
     */
    private static class VideoPlayerOnSeiDataListener implements IPlayer.OnSeiDataListener {

        private final WeakReference<VideoAndLivePlayerView> weakReference;

        public VideoPlayerOnSeiDataListener(VideoAndLivePlayerView aliyunVodPlayerView) {
            weakReference = new WeakReference<>(aliyunVodPlayerView);
        }

        @Override
        public void onSeiData(int type, byte[] bytes) {
            VideoAndLivePlayerView aliyunVodPlayerView = weakReference.get();
            if (aliyunVodPlayerView != null) {
                aliyunVodPlayerView.onSeiData(type, bytes);
            }
        }
    }

    private void onSeiData(int type, byte[] bytes) {
        if (mOutOnSeiDataListener != null) {
            mOutOnSeiDataListener.onSeiData(type, bytes);
        }
    }

    public void setOutOnSeiDataListener(IPlayer.OnSeiDataListener listener) {
        this.mOutOnSeiDataListener = listener;
    }

    private static class VideoPlayerOnVerifyStsCallback implements AliPlayer.OnVerifyTimeExpireCallback {

        private final WeakReference<VideoAndLivePlayerView> weakReference;

        public VideoPlayerOnVerifyStsCallback(VideoAndLivePlayerView aliyunVodPlayerView) {
            weakReference = new WeakReference<>(aliyunVodPlayerView);
        }

        @Override
        public AliPlayer.Status onVerifySts(StsInfo stsInfo) {
            VideoAndLivePlayerView aliyunVodPlayerView = weakReference.get();
            if (aliyunVodPlayerView != null) {
                return aliyunVodPlayerView.onVerifySts(stsInfo);
            }
            return AliPlayer.Status.Valid;
        }

        @Override
        public AliPlayer.Status onVerifyAuth(VidAuth vidAuth) {
            VideoAndLivePlayerView aliyunVodPlayerView = weakReference.get();
            if (aliyunVodPlayerView != null) {
                return aliyunVodPlayerView.onVerifyAuth(vidAuth);
            }
            return AliPlayer.Status.Valid;
        }
    }

    public void setOutOnVerifyTimeExpireCallback(AliPlayer.OnVerifyTimeExpireCallback listener) {
        this.mOutOnVerifyTimeExpireCallback = listener;
    }

    private AliPlayer.Status onVerifyAuth(VidAuth vidAuth) {
        if (mOutOnVerifyTimeExpireCallback != null) {
            return mOutOnVerifyTimeExpireCallback.onVerifyAuth(vidAuth);
        }
        return AliPlayer.Status.Valid;
    }

    private AliPlayer.Status onVerifySts(StsInfo stsInfo) {
        if (mOutOnVerifyTimeExpireCallback != null) {
            return mOutOnVerifyTimeExpireCallback.onVerifySts(stsInfo);
        }
        return AliPlayer.Status.Valid;
    }

    /**
     * 设置硬解码开关
     */
    public void setEnableHardwareDecoder(boolean enableHardwareDecoder) {
        if (mAliyunRenderView != null) {
            mAliyunRenderView.enableHardwareDecoder(enableHardwareDecoder);
        }
    }

    /**
     * 多码率时默认播放码率
     */
    public void setDefaultBandWidth(int bandWidth) {
        if (mAliyunRenderView != null) {
            mAliyunRenderView.setDefaultBandWidth(bandWidth);
        }
    }

    /**
     * 获取当前播放器正在播放的媒体信息
     */
    public MediaInfo getCurrentMediaInfo() {
        return mAliyunMediaInfo;
    }

    /**
     * 截图功能
     */
    public void snapShot() {
        if (mAliyunRenderView != null) {
            mAliyunRenderView.snapshot();
        }
    }

    /**
     * 设置播放时的镜像模式
     *
     * @param mode 镜像模式
     */
    public void setRenderMirrorMode(IPlayer.MirrorMode mode) {
        if (mAliyunRenderView != null) {
            mAliyunRenderView.setMirrorMode(mode);
        }
    }

    /**
     * 设置播放时的旋转方向
     *
     * @param rotate 旋转角度
     */
    public void setRenderRotate(IPlayer.RotateMode rotate) {
        if (mAliyunRenderView != null) {
            mAliyunRenderView.setRotateModel(rotate);
        }
    }

    /**
     * 设置是否显示标题栏
     *
     * @param show true:是
     */
    public void setTitleBarCanShow(boolean show) {
        if (mControlView != null) {
            mControlView.setTitleBarCanShow(show);
        }
    }

    /**
     * 设置是否显示控制栏
     *
     * @param show true:是
     */
    public void setControlBarCanShow(boolean show) {

        if (mControlView != null) {
            mControlView.setControlBarCanShow(show);
        }
    }

    /**
     * 设置竖屏视频模式
     */
    public void setVerticalVideoScreenMode(AliyunScreenMode mode) {
        if (mControlView != null) {
            mCurrentScreenMode = mode;
            mControlView.setVerticalVideoScreenMode(mode);
        }
    }

    /**
     * 设置是否显示进度条
     *
     * @param show true:是
     */
    public void setSeekbarBarCanShow(boolean show) {
        if (mControlView != null) {
            mControlView.setSeekbarVisible(show);
        }
    }

    /**
     * 暂停按钮隐藏展示
     */
    public void setPlayStateBtnVisible(boolean show) {
        if (mControlView != null) {
            mControlView.setPlayStateBtnVisible(show);
        }
    }


    /**
     * 是否是小窗
     */
    private boolean isSpecialPlayState = false;

    /**
     * 暂停按钮隐藏展示(特殊场景，图文小屏用)
     */
    public void setSpecialPlayStateBtnVisible(boolean show) {

        // 是否是小窗
        isSpecialPlayState = show;

        if (mControlView != null) {
            mControlView.setSpecialPlayStateBtnVisible(show);
        }
    }


    /**
     * 给子View设置圆角
     */
    public void clipToOutlineChildView() {

        setOutlineProvider(new RenderViewOutlineProvider(getContext().getResources().getDimension(R.dimen.rmrb_dp4)));
        setClipToOutline(true);

        if (mAliyunRenderView != null) {
            mAliyunRenderView.setOutlineProvider(new RenderViewOutlineProvider(getContext().getResources().getDimension(R.dimen.rmrb_dp4)));
            mAliyunRenderView.setClipToOutline(true);
        }

        if (mControlView != null) {
            mControlView.setOutlineProvider(new RenderViewOutlineProvider(getContext().getResources().getDimension(R.dimen.rmrb_dp4)));
            mControlView.setClipToOutline(true);
        }

        if (mCoverView != null) {
            mCoverView.setOutlineProvider(new RenderViewOutlineProvider(getContext().getResources().getDimension(R.dimen.rmrb_dp4)));
            mCoverView.setClipToOutline(true);
        }
    }

    /**
     * 取消子View设置圆角
     */
    public void cancelClipToOutlineChildView() {

        setClipToOutline(false);

        if (mAliyunRenderView != null) {
            mAliyunRenderView.setClipToOutline(false);
        }

        if (mControlView != null) {
            mControlView.setClipToOutline(false);
        }

        if (mCoverView != null) {
            mCoverView.setClipToOutline(false);
        }
    }

    /**
     * 设置子View宽度
     */
    public void setChildViewWith(int with) {

        if (mAliyunRenderView != null) {
            LayoutParams params = (LayoutParams) mAliyunRenderView.getLayoutParams();
            params.width = with;
            mAliyunRenderView.setLayoutParams(params);
        }

        if (mControlView != null) {
            LayoutParams params = (LayoutParams) mControlView.getLayoutParams();
            params.width = with;
            mControlView.setLayoutParams(params);
        }

        if (mTipsView != null) {
            LayoutParams params = (LayoutParams) mTipsView.getLayoutParams();
            params.width = with;
            mTipsView.setLayoutParams(params);
        }

        if (mCoverView != null) {
            LayoutParams params = (LayoutParams) mCoverView.getLayoutParams();
            params.width = with;
            mCoverView.setLayoutParams(params);
        }

        if (mVideoDurationView != null) {
            LayoutParams params = (LayoutParams) mVideoDurationView.getLayoutParams();
            params.width = with;
            mVideoDurationView.setLayoutParams(params);
        }
    }


    /**
     * 设置缓存配置
     */
    public void setCacheConfig(CacheConfig cacheConfig) {
        if (mAliyunRenderView != null) {
            mAliyunRenderView.setCacheConfig(cacheConfig);
        }
    }

    /**
     * 获取Config
     */
    public PlayerConfig getPlayerConfig() {
        if (mAliyunRenderView != null) {
            return mAliyunRenderView.getPlayerConfig();
        }
        return null;
    }

    /**
     * 设置Config
     */
    public void setPlayerConfig(PlayerConfig playerConfig) {
        if (mAliyunRenderView != null) {
            mAliyunRenderView.setPlayerConfig(playerConfig);
        }
    }

    /**
     * 获取SDK版本号
     *
     * @return SDK版本号
     */
    public String getSDKVersion() {
        return AliPlayerFactory.getSdkVersion();
    }


    /**
     * 设置自动播放
     *
     * @param auto true 自动播放
     */
    public void setAutoPlay(boolean auto) {
        if (mAliyunRenderView != null) {
            mAliyunRenderView.setAutoPlay(auto);
        }
    }

    /**
     * 锁定屏幕。锁定屏幕后，只有锁会显示，其他都不会显示。手势也不可用
     *
     * @param lockScreen 是否锁住
     */
    public void lockScreen(boolean lockScreen) {
        mIsFullScreenLocked = lockScreen;
        if (mControlView != null) {
            mControlView.setScreenLockStatus(mIsFullScreenLocked);
        }
        if (mGestureView != null) {
            mGestureView.setScreenLockStatus(mIsFullScreenLocked);
        }

    }

    /**
     * 重试播放，会从当前位置开始播放
     */
    public void reTry() {

        isCompleted = false;
        inSeek = false;

        int currentPosition = mControlView.getVideoPosition();

        if (mTipsView != null) {
            mTipsView.hideAll();
        }
        if (mControlView != null) {
            // 防止被reset掉，下次还可以获取到这些值
            mControlView.setVideoPosition(currentPosition);
        }

        if (mGestureView != null) {
            mGestureView.reset();
        }

        if (mAliyunRenderView != null) {

            // 显示网络加载的loading。。
            if (mTipsView != null) {
                mTipsView.showNetLoadingTipView();
            }
            // seek到当前的位置再播放
            mAliyunRenderView.prepare();
            isAutoAccurate(currentPosition);
            countdownPlayerError();
        }

    }

    // 仅判断 直播 状态为 开始播放一直播放不出来 处理
    public void countdownPlayerError() {

        if (mAliyunRenderView != null) {

            mAliyunRenderView.postDelayed(new Runnable() {
                @Override
                public void run() {
                    if (mPlayerState == 1) {
                        ErrorInfo errorInfo = new ErrorInfo();
                        if (mTipsView != null) {
                            mTipsView.hideNetLoadingTipView();
                        }
                        showErrorTipView(0, "errorEvent", "errorMsg");
                        errorInfo.setMsg("Live_load_timeout_of_10_seconds");
                        LiveDataBus.getInstance().with(EventConstants.LIVE_PYBK_ERROR).postValue(errorInfo);
                    }
                }
            }, 10 * 1000);
        }

    }

    /**
     * 重播，将会从头开始播放
     */
    public void rePlay() {

        isCompleted = false;
        inSeek = false;

        if (mTipsView != null) {
            mTipsView.hideAll();
        }
        if (mControlView != null) {
            mControlView.reset();
        }
        if (mNetChangeLayoutView != null) {
            mNetChangeLayoutView.reset();
        }
        if (mGestureView != null) {
            mGestureView.reset();
        }

        //重播，将会从0开始播放
        if (mControlView != null) {
            mControlView.setVideoPosition(0);
        }
        seekTo(0);
    }

    /**
     * 设置静音,默认是false
     */
    public void setMuteAliyunRenderView(boolean isMute) {
        if (mAliyunRenderView != null) {
            mAliyunRenderView.setMute(isMute);
        }
    }

    /**
     * 设置封面
     *
     * @param url 封面图url
     */
    public void setCoverUrl(String url) {
        if (mCoverView == null) {
            return;
        }

        ImageUtils.getInstance().loadImageNoPlaceholder(mCoverView, url);
        mCoverView.setVisibility(isPlaying() ? GONE : VISIBLE);
    }

    /**
     * 设置时长
     *
     * @param duration 时长
     */
    public void setDuration(long duration) {
        if (mVideoDurationView != null) {
            if (mVideoDurationView.getVisibility() == GONE) {
                mVideoDurationView.setVisibility(VISIBLE);
            }
            mVideoDurationView.setDuration(duration);
        }
    }

    /**
     * 设置缩放模式
     *
     * @param scaleMode 缩放模式
     */
    public void setScaleMode(IPlayer.ScaleMode scaleMode) {
        if (mAliyunRenderView != null) {
            mAliyunRenderView.setScaleModel(scaleMode);
        }
    }

    /**
     * 获取缩放模式
     *
     * @return 当前缩放模式
     */
    public IPlayer.ScaleMode getScaleMode() {
        IPlayer.ScaleMode scaleMode = IPlayer.ScaleMode.SCALE_ASPECT_FIT;
        if (mAliyunRenderView != null) {
            scaleMode = mAliyunRenderView.getScaleModel();
        }
        return scaleMode;
    }

    /**
     * 设置是否循环播放
     */
    public void setLoop(boolean isLoop) {
        if (mAliyunRenderView != null) {
            mAliyunRenderView.setLoop(isLoop);
        }
    }

    /**
     * 是否开启循环播放
     */
    public boolean isLoop() {
        if (mAliyunRenderView != null) {
            return mAliyunRenderView.isLoop();
        }
        return false;
    }

    // 连网断网监听
    public void setNetConnectedListener(NetConnectedListener listener) {
        this.mNetConnectedListener = listener;
    }

    /**
     * 断网/连网监听
     */
    private class MyNetConnectedListener implements NetWatchdog.NetConnectedListener {

        public MyNetConnectedListener(VideoAndLivePlayerView mVideoAndLivePlayerView) {
        }

        @Override
        public void onReNetConnected(boolean isReconnect) {
            if (mNetConnectedListener != null) {
                mNetConnectedListener.onReNetConnected(isReconnect);
            }
        }

        @Override
        public void onNetUnConnected() {
            Log.e("onNetDisconnected", "onNetUnConnected2222>>>");
            if (mNetConnectedListener != null) {
                mNetConnectedListener.onNetUnConnected();
            }
        }
    }

    /**
     * 判断是否有网络的监听
     */
    public interface NetConnectedListener {
        /**
         * 网络已连接
         */
        void onReNetConnected(boolean isReconnect);

        /**
         * 网络未连接
         */
        void onNetUnConnected();
    }

    public AliyunRenderView getmAliyunRenderView() {
        return mAliyunRenderView;
    }


    /**
     * *分享 viwe 展示隐藏
     */
    public void setMoreViewShowStatus(boolean isShow) {
        if (mControlView != null) {
            mControlView.setIvMore(isShow);
        }
    }


    public void setVerticalVideoFullBtnClick(AliyunScreenMode aliyunScreenMode) {
        if (mControlView != null) {
            mControlView.setVerticalVideoFullBtnClick(aliyunScreenMode);
        }
    }

    public void setIsDetail() {
        if (mControlView != null) {
            mControlView.setIsDetail();
        }
    }

    public void setShowReplayView(boolean showReplayView) {
        this.showReplayView = showReplayView;
    }
}