package com.wd.player.widget;

import android.content.Context;
import android.graphics.Bitmap;
import android.os.SystemClock;
import android.util.AttributeSet;
import android.view.Surface;
import android.widget.FrameLayout;

import com.aliyun.player.AliPlayer;
import com.aliyun.player.AliPlayerFactory;
import com.aliyun.player.AliPlayerGlobalSettings;
import com.aliyun.player.IPlayer;
import com.aliyun.player.bean.ErrorInfo;
import com.aliyun.player.bean.InfoBean;
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.wd.foundation.wdkit.constant.EventConstants;
import com.wd.foundation.wdkit.utils.SpUtils;
import com.wd.foundation.wdkitcore.livedata.LiveDataBus;

import java.io.File;
import java.lang.ref.WeakReference;


/**
 * 阿里播放器渲染视图
 */
public class AliyunRenderView extends FrameLayout {


    private static final String TAG = "AliyunRenderView";

    /**
     * 上下文
     */
    private Context mContext;

    /**
     * 播放器
     */
    private AliPlayer mAliPlayer;

    /**
     * 设置能够缓存的单个视频源文件的最大内存占用大小，超过此大小则不缓存，单位：KB。设置50M
     */
    private final int maxBufferMemoryKB = 50 * 1024;

    /**
     * expireMin - 设置缓存的过期时间。单位：分钟，默认值30天，过期的缓存不管容量多大，都会被删除。设置3天
     */
    private final long expireMin = 3 * 24 * 60;

    /**
     * maxCapacityMB - 最大缓存容量。单位：兆，默认值20GB，在清理时，如果缓存总容量超过此大小，则会以cacheItem
     * 为粒度，按缓存的最后时间排序，一个一个的删除最旧的缓存文件，直到小于等于最大缓存容量。
     */
    private final long maxCapacityMB = 1 * 1024;

    /**
     * freeStorageMB -
     * 磁盘最小空余容量。单位：兆，默认值0，在清理时，同最大缓存容量，如果当前磁盘容量小于该值，也会按规则一个一个的删除缓存文件，直到freeStorage大于等于该值或者所有缓存都被清理掉。
     */
    private final long freeStorageMB = 300;

    /**
     * Surface
     */
    private IRenderView mIRenderView;

    /**
     * 判断当前解码状态,true:硬解,false:软解
     * 默认是硬解
     */
    private boolean mCurrentEnableHardwareDecoder = true;

    /**
     * 视频画布
     */
    public Surface mSurface;


    /**
     * 判断当前是纯音频、纯视频流
     */
    private OnVideoStreamTrackTypeListener mOnVideoStreamTrackTypeListener;

    /**
     * 准备回调
     */
    private IPlayer.OnPreparedListener mOnPreparedListener;

    private IPlayer.OnVideoRenderedListener mOnVideoRenderedListener;

    /**
     * 第一帧显示
     */
    private IPlayer.OnRenderingStartListener mOnRenderingStartListener;

    /**
     * 播放器状态改变监听
     */
    private IPlayer.OnStateChangedListener mOnStateChangedListener;

    /**
     * 设置视频宽高变化监听
     */
    private IPlayer.OnVideoSizeChangedListener mOnVideoSizeChangedListener;

    /**
     * 播放器Info监听
     */
    private IPlayer.OnInfoListener mOnInfoListener;

    private IPlayer.OnTrackReadyListener mOnTrackReadyListener;

    /**
     * 播放器加载回调
     */
    private IPlayer.OnLoadingStatusListener mOnLoadingStatusListener;

    private IPlayer.OnSnapShotListener mOnSnapShotListener;

    /**
     * 设置播放完成事件监听
     */
    private IPlayer.OnCompletionListener mOnCompletionListener;

    /**
     * 设置seek结束监听
     */
    private IPlayer.OnSeekCompleteListener mOnSeekCompleteListener;

    /**
     * 播放器TrackChanged监听
     */
    private IPlayer.OnTrackChangedListener mOnTrackChangedListener;

    /**
     * 播放出错
     */
    private IPlayer.OnErrorListener mOnErrorListener;

    private IPlayer.OnSubtitleDisplayListener mOnSubtitleDisplayListener;

    public static SurfaceStatus mCurrentPlayerStatus = SurfaceStatus.surfaceDestroyed;


    /**
     * 对外SEI消息通知
     */
    private IPlayer.OnSeiDataListener mOnSeiDataListener;

    /**
     * 当前播放地址
     */
    private String currentUrl;

    private AliPlayer.OnVerifyTimeExpireCallback mOnVerifyTimeExpireCallback;

    public AliyunRenderView(Context context) {
        super(context);
        init(context);
    }

    /**
     * 构造器
     */
    public AliyunRenderView(Context context, AliPlayer aliPlayer) {
        super(context);
        this.mContext = context;
        mAliPlayer = aliPlayer;
        initPlayerListener();
    }

    /**
     * 构造器
     */
    public AliyunRenderView(Context context, AttributeSet attrs) {
        super(context, attrs);
        init(context);
    }

    /**
     * 构造器
     */
    public AliyunRenderView(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        init(context);
    }

    private void init(Context context) {
        this.mContext = context;
        initPlayer();
    }

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

        mAliPlayer = AliPlayerFactory.createAliPlayer(mContext.getApplicationContext());
        //默认是 false
        PlayerConfig config = mAliPlayer.getConfig();
        // 停止后是否清空画面
        config.mClearFrameWhenStop = true;
        mAliPlayer.setConfig(config);
        File shortVideoCache = new File(getContext().getCacheDir(), "peopleVideoCache");
        AliPlayerGlobalSettings.enableLocalCache(true, maxBufferMemoryKB, shortVideoCache.getAbsolutePath());
        AliPlayerGlobalSettings.setCacheFileClearConfig(expireMin, maxCapacityMB, freeStorageMB);
//        AliPlayerGlobalSettings.setUseHttp2(false);
        initPlayerListener();
    }

    private void initPlayerListener() {

        mAliPlayer.setOnInfoListener(new OnAVPInfoListener(this));
        mAliPlayer.setOnTrackReadyListener(new OnAVPTrackReadyListener(this));
        mAliPlayer.setOnErrorListener(new OnAVPErrorListener(this));
        mAliPlayer.setOnSeiDataListener(new OnAVPSeiDataListener(this));
        mAliPlayer.setOnSnapShotListener(new OnAVPSnapShotListener(this));
        mAliPlayer.setOnPreparedListener(new OnAVPPreparedListener(this));
        mAliPlayer.setOnCompletionListener(new OnAVPCompletionListener(this));
        mAliPlayer.setOnTrackChangedListener(new OnAVPTrackChangedListener(this));
        mAliPlayer.setOnSeekCompleteListener(new OnAVPSeekCompleteListener(this));
        mAliPlayer.setOnVideoRenderedListener(new OnAVPVideoRenderedListener(this));
        mAliPlayer.setOnLoadingStatusListener(new OnAVPLoadingStatusListener(this));
        mAliPlayer.setOnRenderingStartListener(new OnAVPRenderingStartListener(this));
        mAliPlayer.setOnVerifyTimeExpireCallback(new OnAVPVerifyStsCallback(this));
        mAliPlayer.setOnStateChangedListener(new OnAVPStateChangedListener(this));
        mAliPlayer.setOnSubtitleDisplayListener(new OnAVPSubtitleDisplayListener(this));
        mAliPlayer.setOnVideoSizeChangedListener(new OnAVPVideoSizeChangedListener(this));
    }

    public enum SurfaceType {

        /**
         * TextureView
         */
        TEXTURE_VIEW,

        /**
         * SurfacView
         */
        SURFACE_VIEW,
    }

    /**
     * 获取真正的播放器实例对象
     *
     * @return mAliPlayer
     */
    public AliPlayer getAliPlayer() {
        return mAliPlayer;
    }

    /**
     * 该方法需要在创建播放器完成后,prepare前调用
     *
     * @param surfaceType Surface的类型
     */
    public void setSurfaceType(SurfaceType surfaceType) {
        if (surfaceType == SurfaceType.TEXTURE_VIEW) {
            mIRenderView = new TextureRenderView(mContext);
        }else{
            mIRenderView = new SurfaceRenderView(mContext);
        }
        initListener();
        addView(mIRenderView.getView());
    }

    public IRenderView getIRenderView() {
        return mIRenderView;
    }

    /**
     * 设置播放源
     *
     * @param vidSts
     */
    public void setDataSource(VidSts vidSts) {
        if (mAliPlayer != null) {
            mAliPlayer.setDataSource(vidSts);
        }
    }

    /**
     * 设置播放源
     *
     * @param vidAuth
     */
    public void setDataSource(VidAuth vidAuth) {
        if (mAliPlayer != null) {
            mAliPlayer.setDataSource(vidAuth);
        }
    }

    /**
     * 设置播放源
     */
    public void setDataSource(LiveSts liveSts) {
        if (mAliPlayer != null) {
            mAliPlayer.setDataSource(liveSts);
        }
    }

    /**
     * 设置播放源
     */
    public void setDataSource(VidMps vidMps) {
        if (mAliPlayer != null) {
            mAliPlayer.setDataSource(vidMps);
        }
    }

    /**
     * 设置播放源
     */
    public void setDataSource(UrlSource urlSource) {
        if (mAliPlayer != null) {
            mAliPlayer.setDataSource(urlSource);
        }
    }

    /**
     * 设置播放源
     *
     * @param url 播放url
     */
    public void setUrl(String url) {

        currentUrl = url;

        if (mAliPlayer != null) {
            UrlSource urlSource = new UrlSource();
            urlSource.setUri(url);
            mAliPlayer.setDataSource(urlSource);
        }
    }

    public String getCurrentUrl() {
        return currentUrl;
    }

    /**
     * 刷新sts信息
     *
     * @param stsInfo
     */
    public void updateStsInfo(StsInfo stsInfo) {
        if (mAliPlayer != null) {
            mAliPlayer.updateStsInfo(stsInfo);
        }
    }

    /**
     * 刷新Auth信息
     *
     * @param vidAuth
     */
    public void updateAuthInfo(VidAuth vidAuth) {
        if (mAliPlayer != null) {
            mAliPlayer.updateVidAuth(vidAuth);
        }
    }

    /**
     * 设置是否静音
     *
     * @param isMute
     */
    public void setMute(boolean isMute) {
        if (mAliPlayer != null) {
            mAliPlayer.setMute(isMute);
        }
    }

    /**
     * 设置音量
     *
     * @param v
     */
    public void setVolume(float v) {
        if (mAliPlayer != null) {
            mAliPlayer.setVolume(v);
        }
    }

    /**
     * 获取音量
     *
     * @return getVolume
     */
    public float getVolume() {
        if (mAliPlayer != null) {
            return mAliPlayer.getVolume();
        }
        return 0;
    }

    /**
     * 是否开启自动播放
     *
     * @param isAutoPlay
     */
    public void setAutoPlay(boolean isAutoPlay) {
        if (mAliPlayer != null) {
            mAliPlayer.setAutoPlay(isAutoPlay);
        }
    }

    /**
     * 设置播放速率
     *
     * @param speed
     */
    public void setSpeed(float speed) {
        if (mAliPlayer != null) {
            mAliPlayer.setSpeed(speed);
        }
    }

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

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

    /**
     * 截屏
     */
    public void snapshot() {
        if (mAliPlayer != null) {
            mAliPlayer.snapshot();
        }
    }

    /**
     * 选择 track
     *
     * @param index 索引
     */
    public void selectTrack(int index) {
        if (mAliPlayer != null) {
            mAliPlayer.selectTrack(index);
        }
    }

    /**
     * selectExtSubtitle
     *
     * @param index
     * @param selected
     */
    public void selectExtSubtitle(int index, boolean selected) {
        if (mAliPlayer != null) {
            mAliPlayer.selectExtSubtitle(index, selected);
        }
    }

    /**
     * 选择 track
     *
     * @param index 索引
     * @param focus 是否强制选择track
     */
    public void selectTrack(int index, boolean focus) {
        if (mAliPlayer != null) {
            mAliPlayer.selectTrack(index, focus);
        }
    }

    /**
     * 停止播放
     */
    public void stop() {
        if (mAliPlayer != null) {
            mAliPlayer.stop();
        }
    }

    /**
     * 重置
     */
    public void reset() {
        if (mAliPlayer != null) {
            mAliPlayer.reset();
        }
    }

    /**
     * 清空画面
     */
    public void clearScreen() {
        if (mAliPlayer != null) {
            mAliPlayer.clearScreen();
        }
    }

    /**
     * prepare(暂停语音播报)
     */
    public void prepare() {
        if (mAliPlayer != null) {
            mAliPlayer.prepare();
        }
    }

    /**
     * 语音播报prepare
     */
    public void prepareVoice() {
        if (mAliPlayer != null) {
            mAliPlayer.prepare();
        }
    }

    /**
     * 暂停播放,直播流不建议使用
     */
    public void pause() {
        if (mAliPlayer != null) {
            mAliPlayer.pause();
        }
    }

    /**
     * 开始 (暂停语音播报)
     */
    public void start() {
        if (mAliPlayer != null) {
            mAliPlayer.start();
        }
    }
    /**
     * 语音播报开始
     */
    public void startVoice() {
        if (mAliPlayer != null) {
            mAliPlayer.start();
        }
    }

    /**
     * 重播
     */
    public void reload() {
        if (mAliPlayer != null) {
            mAliPlayer.reload();
        }
    }

    /**
     * 获取视频时长
     *
     * @return getDuration
     */
    public long getDuration() {
        if (mAliPlayer != null) {
            return mAliPlayer.getDuration();
        }
        return 0;
    }

    /**
     * 获取当前 track
     *
     * @param typeVideo
     * @return TrackInfo
     */
    public TrackInfo currentTrack(TrackInfo.Type typeVideo) {
        if (mAliPlayer != null) {
            return mAliPlayer.currentTrack(typeVideo);
        }
        return null;
    }

    /**
     * 获取当前 track
     *
     * @param ordinal
     * @return TrackInfo
     */
    @Deprecated
    public TrackInfo currentTrack(int ordinal) {
        if (mAliPlayer != null) {
            return mAliPlayer.currentTrack(ordinal);
        }
        return null;
    }

    /**
     * seek
     *
     * @param position 目标位置
     * @param seekMode 精准/非精准seek
     */
    public void seekTo(long position, IPlayer.SeekMode seekMode) {
        if (mAliPlayer != null) {
            mAliPlayer.seekTo(position, seekMode);
        }
    }
    /**
     * 判断是否开启精准seek
     * 精准是否 mAccurate
     */
    public void isSeekToAutoAccurate(boolean mAccurate,long position) {
        if (mAccurate) {
            mAliPlayer.seekTo(position, IPlayer.SeekMode.Accurate);
        } else {
            mAliPlayer.seekTo(position, IPlayer.SeekMode.Inaccurate);
        }
    }
    private void initListener() {
        mIRenderView.addRenderCallback(new MyRenderViewCallback(this));
    }

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

    /**
     * 设置PlayerConfig
     *
     * @param playerConfig
     */
    public void setPlayerConfig(PlayerConfig playerConfig) {
        if (mAliPlayer != null) {
            mAliPlayer.setConfig(playerConfig);
        }
    }

    /**
     * 获取PlayerConfig
     *
     * @return PlayerConfig
     */
    public PlayerConfig getPlayerConfig() {
        if (mAliPlayer != null) {
            return mAliPlayer.getConfig();
        }
        return null;
    }

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

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

    /**
     * 设置旋转模式
     *
     * @param rotateModel
     */
    public void setRotateModel(IPlayer.RotateMode rotateModel) {
        if (mAliPlayer != null) {
            mAliPlayer.setRotateMode(rotateModel);
        }
    }

    /**
     * 获取当前旋转模式
     *
     * @return IPlayer.RotateMode
     */
    public IPlayer.RotateMode getRotateModel() {
        if (mAliPlayer != null) {
            return mAliPlayer.getRotateMode();
        }
        return IPlayer.RotateMode.ROTATE_0;
    }

    /**
     * 设置镜像模式
     *
     * @param mirrorMode
     */
    public void setMirrorMode(IPlayer.MirrorMode mirrorMode) {
        if (mAliPlayer != null) {
            mAliPlayer.setMirrorMode(mirrorMode);
        }
    }

    /**
     * 获取当前镜像模式
     *
     * @return IPlayer.MirrorMode
     */
    public IPlayer.MirrorMode getMirrorMode() {
        if (mAliPlayer != null) {
            return mAliPlayer.getMirrorMode();
        }
        return IPlayer.MirrorMode.MIRROR_MODE_NONE;
    }

    /**
     * getMediaInfo
     *
     * @return MediaInfo
     */
    public MediaInfo getMediaInfo() {
        if (mAliPlayer != null) {
            return mAliPlayer.getMediaInfo();
        }
        return null;
    }

    /**
     * 软硬解开关
     *
     * @param enableHardwareDecoder true:硬解,false:软解
     */
    public void enableHardwareDecoder(boolean enableHardwareDecoder) {
        if (mAliPlayer != null) {
            mCurrentEnableHardwareDecoder = enableHardwareDecoder;
            mAliPlayer.enableHardwareDecoder(enableHardwareDecoder);
        }
    }

    /**
     * 多码率时默认播放码率
     *
     * @param bandWidth
     */
    public void setDefaultBandWidth(int bandWidth) {
        if (mAliPlayer != null) {
            // Logger.t("abc : ").e( "setDefaultBandWidth: " + bandWidth);
            mAliPlayer.setDefaultBandWidth(bandWidth);
        }
    }

    /**
     * 获取当前解码状态
     *
     * @return true:硬解,false:软解
     */
    public boolean isHardwareDecoder() {
        return mCurrentEnableHardwareDecoder;
    }

    /**
     * 释放资源
     */
    public void release() {
        if (mAliPlayer != null) {
            stop();
            mAliPlayer.setSurface(null);
            mAliPlayer.release();
            mAliPlayer = null;
        }
        mSurface = null;
    }

    private static class MyRenderViewCallback implements IRenderView.IRenderCallback {

        private final WeakReference<AliyunRenderView> weakReference;

        private MyRenderViewCallback(AliyunRenderView aliyunRenderView) {
            weakReference = new WeakReference<>(aliyunRenderView);
        }

        @Override
        public void onSurfaceCreate(Surface surface) {
            mCurrentPlayerStatus = SurfaceStatus.onSurfaceCreate;
            AliyunRenderView aliyunRenderView = weakReference.get();
            if (aliyunRenderView != null && aliyunRenderView.mAliPlayer != null) {
                aliyunRenderView.mSurface = surface;
                aliyunRenderView.mAliPlayer.setSurface(surface);
            }
        }

        @Override
        public void onSurfaceChanged(int width, int height) {
            mCurrentPlayerStatus = SurfaceStatus.surfaceChanged;
            AliyunRenderView aliyunRenderView = weakReference.get();
            if (aliyunRenderView != null && aliyunRenderView.mAliPlayer != null) {
                aliyunRenderView.mAliPlayer.surfaceChanged();
            }
        }

        @Override
        public void onSurfaceDestroyed() {
            mCurrentPlayerStatus = SurfaceStatus.surfaceDestroyed;
            AliyunRenderView aliyunRenderView = weakReference.get();
            if (aliyunRenderView != null && aliyunRenderView.mAliPlayer != null) {
                aliyunRenderView.mAliPlayer.setSurface(null);
            }
        }
    }

    /**
     * OnPrepared
     */
    private static class OnAVPPreparedListener implements IPlayer.OnPreparedListener {

        private final WeakReference<AliyunRenderView> weakReference;

        private OnAVPPreparedListener(AliyunRenderView aliyunRenderView) {
            weakReference = new WeakReference<>(aliyunRenderView);
        }

        @Override
        public void onPrepared() {
            AliyunRenderView aliyunRenderView = weakReference.get();
            if (aliyunRenderView != null) {
                aliyunRenderView.onPrepared();
            }

        }
    }


    /**
     * 纯音频、纯视频流监听
     */
    public interface OnVideoStreamTrackTypeListener {

        /**
         * 纯视频
         */
        void onVideoOnlyType();

        /**
         * 纯音频
         */
        void onAudioOnlyType();
    }



    /**
     * 当前是纯音频、纯视频流回调
     */
    public void setOnVideoStreamTrackType(OnVideoStreamTrackTypeListener listener) {
        this.mOnVideoStreamTrackTypeListener = listener;
    }

    public void setOnPreparedListener(IPlayer.OnPreparedListener listener) {
        this.mOnPreparedListener = listener;
    }

    private void onPrepared() {

        if (mOnPreparedListener != null) {
            mOnPreparedListener.onPrepared();
        }

        // 判断当前是纯音频、纯视频流
        if (mOnVideoStreamTrackTypeListener != null) {
            TrackInfo trackVideo = mAliPlayer.currentTrack(TrackInfo.Type.TYPE_VIDEO);
            TrackInfo trackAudio = mAliPlayer.currentTrack(TrackInfo.Type.TYPE_AUDIO);
            if (trackVideo == null && trackAudio != null) {
                mOnVideoStreamTrackTypeListener.onAudioOnlyType();
            } else if (trackVideo != null && trackAudio == null) {
                mOnVideoStreamTrackTypeListener.onVideoOnlyType();
            }
        }

    }


    /**
     * OnVideoRenderedListener
     */
    private static class OnAVPVideoRenderedListener implements IPlayer.OnVideoRenderedListener {

        private WeakReference<AliyunRenderView> weakReference;

        private OnAVPVideoRenderedListener(AliyunRenderView aliyunRenderView) {
            weakReference = new WeakReference<>(aliyunRenderView);
        }

        @Override
        public void onVideoRendered(long timeMs, long pts) {
            //     Logger.t(TAG).d("阿里播放器AliyunRenderView:OnAVPVideoRenderedListener--》onVideoRendered"+timeMs);
            AliyunRenderView aliyunRenderView = weakReference.get();
            if (aliyunRenderView != null) {
                aliyunRenderView.onVideoRendered(timeMs, pts);
            }
        }
    }

    public void setOnVideoRenderedListener(IPlayer.OnVideoRenderedListener listener) {
        this.mOnVideoRenderedListener = listener;
    }

    private void onVideoRendered(long timeMs, long pts) {
        if (mOnVideoRenderedListener != null) {
            mOnVideoRenderedListener.onVideoRendered(timeMs, pts);
        }
    }

    /**
     * OnRenderingStartListener
     */
    private static class OnAVPRenderingStartListener implements IPlayer.OnRenderingStartListener {

        private final WeakReference<AliyunRenderView> weakReference;

        private OnAVPRenderingStartListener(AliyunRenderView aliyunRenderView) {
            weakReference = new WeakReference<>(aliyunRenderView);
        }

        @Override
        public void onRenderingStart() {
            AliyunRenderView aliyunRenderView = weakReference.get();
            if (aliyunRenderView != null) {
                aliyunRenderView.onRenderingStart();
            }

        }
    }

    public void setOnRenderingStartListener(IPlayer.OnRenderingStartListener listener) {
        this.mOnRenderingStartListener = listener;
    }

    private void onRenderingStart() {
        if (mOnRenderingStartListener != null) {
            mOnRenderingStartListener.onRenderingStart();
        }

    }

    /**
     * OnStateChangedListner
     */
    private static class OnAVPStateChangedListener implements IPlayer.OnStateChangedListener {

        private final WeakReference<AliyunRenderView> weakReference;

        /**
         * 构造器
         */
        private OnAVPStateChangedListener(AliyunRenderView aliyunRenderView) {
            weakReference = new WeakReference<>(aliyunRenderView);
        }

        @Override
        public void onStateChanged(int i) {
            AliyunRenderView aliyunRenderView = weakReference.get();
            if (aliyunRenderView != null) {
                aliyunRenderView.onStateChangedListener(i);
            }
        }
    }

    public void setOnStateChangedListener(IPlayer.OnStateChangedListener listener) {
        this.mOnStateChangedListener = listener;
    }

    private void onStateChangedListener(int newState) {

        if (newState == 3) {
            long time = SystemClock.uptimeMillis() - SpUtils.getLiveLoadTime();
            if (time < 1000 * 15) {
                LiveDataBus.getInstance().with(EventConstants.LIVE_LOADING_TIME_BURY).postValue(time);
            }
        }
        if (mOnStateChangedListener != null) {
            mOnStateChangedListener.onStateChanged(newState);
        }
    }

    /**
     * OnVideoSizeChangedListener
     */
    private static class OnAVPVideoSizeChangedListener implements IPlayer.OnVideoSizeChangedListener {

        private final WeakReference<AliyunRenderView> weakReference;

        private OnAVPVideoSizeChangedListener(AliyunRenderView aliyunRenderView) {
            weakReference = new WeakReference<>(aliyunRenderView);
        }

        @Override
        public void onVideoSizeChanged(int width, int height) {

            AliyunRenderView aliyunRenderView = weakReference.get();
            if (aliyunRenderView != null) {
                aliyunRenderView.onVideoSizeChanged(width, height);
            }
        }
    }

    public void setOnVideoSizeChangedListener(IPlayer.OnVideoSizeChangedListener listener) {
        this.mOnVideoSizeChangedListener = listener;
    }

    private void onVideoSizeChanged(int width, int height) {
        if (mOnVideoSizeChangedListener != null) {
            mOnVideoSizeChangedListener.onVideoSizeChanged(width, height);
        }
    }

    /**
     * 播放进度
     * OnInfoListener
     */
    private static class OnAVPInfoListener implements IPlayer.OnInfoListener {


        private final WeakReference<AliyunRenderView> weakReference;

        private OnAVPInfoListener(AliyunRenderView aliyunRenderView) {
            weakReference = new WeakReference<>(aliyunRenderView);
        }

        @Override
        public void onInfo(InfoBean infoBean) {

            AliyunRenderView aliyunRenderView = weakReference.get();
            if (aliyunRenderView != null) {
                aliyunRenderView.onInfo(infoBean);
            }
        }
    }

    public void setOnInfoListener(IPlayer.OnInfoListener listener) {
        this.mOnInfoListener = listener;
    }

    private void onInfo(InfoBean infoBean) {
        if (mOnInfoListener != null) {
            mOnInfoListener.onInfo(infoBean);
        }
    }

    private static class OnAVPTrackReadyListener implements IPlayer.OnTrackReadyListener {

        private final WeakReference<AliyunRenderView> mRenderViewWeakReference;

        private OnAVPTrackReadyListener(AliyunRenderView renderView) {
            mRenderViewWeakReference = new WeakReference<>(renderView);
        }

        @Override
        public void onTrackReady(MediaInfo mediaInfo) {

            AliyunRenderView aliyunRenderView = mRenderViewWeakReference.get();
            if (aliyunRenderView != null) {
                aliyunRenderView.onTrackReady(mediaInfo);
            }
        }
    }

    public void setOnTrackReadyListenenr(IPlayer.OnTrackReadyListener listener) {
        this.mOnTrackReadyListener = listener;
    }

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

    /**
     * OnLoadingStatusListener
     */
    private static class OnAVPLoadingStatusListener implements IPlayer.OnLoadingStatusListener {

        private final WeakReference<AliyunRenderView> weakReference;

        private OnAVPLoadingStatusListener(AliyunRenderView aliyunRenderView) {
            weakReference = new WeakReference<>(aliyunRenderView);
        }

        @Override
        public void onLoadingBegin() {

            AliyunRenderView aliyunRenderView = weakReference.get();
            if (aliyunRenderView != null) {
                aliyunRenderView.onLoadingBegin();
            }
        }

        @Override
        public void onLoadingProgress(int percent, float netSpeed) {

            AliyunRenderView aliyunRenderView = weakReference.get();
            if (aliyunRenderView != null) {
                aliyunRenderView.onLoadingProgress(percent, netSpeed);
            }
        }

        @Override
        public void onLoadingEnd() {

            AliyunRenderView aliyunRenderView = weakReference.get();
            if (aliyunRenderView != null) {
                aliyunRenderView.onLoadingEnd();
            }
        }
    }

    public void setOnLoadingStatusListener(IPlayer.OnLoadingStatusListener listener) {
        this.mOnLoadingStatusListener = listener;
    }

    private void onLoadingBegin() {
        if (mOnLoadingStatusListener != null) {
            mOnLoadingStatusListener.onLoadingBegin();
        }
    }

    private void onLoadingProgress(int percent, float netSpeed) {
        if (mOnLoadingStatusListener != null) {
            mOnLoadingStatusListener.onLoadingProgress(percent, netSpeed);
        }
    }

    private void onLoadingEnd() {
        if (mOnLoadingStatusListener != null) {
            mOnLoadingStatusListener.onLoadingEnd();
        }
    }

    /**
     * OnSnapShotListener
     */
    private static class OnAVPSnapShotListener implements IPlayer.OnSnapShotListener {

        private final WeakReference<AliyunRenderView> weakReference;

        private OnAVPSnapShotListener(AliyunRenderView aliyunRenderView) {
            weakReference = new WeakReference<>(aliyunRenderView);
        }

        @Override
        public void onSnapShot(Bitmap bitmap, int with, int height) {

            AliyunRenderView aliyunRenderView = weakReference.get();
            if (aliyunRenderView != null) {
                aliyunRenderView.onSnapShot(bitmap, with, height);
            }
        }
    }

    public void setOnSnapShotListener(IPlayer.OnSnapShotListener listener) {
        this.mOnSnapShotListener = listener;
    }

    private void onSnapShot(Bitmap bitmap, int with, int height) {
        if (mOnSnapShotListener != null) {
            mOnSnapShotListener.onSnapShot(bitmap, with, height);
        }
    }

    /**
     * OnCompletionListener
     */
    private static class OnAVPCompletionListener implements IPlayer.OnCompletionListener {

        private final WeakReference<AliyunRenderView> weakReference;

        private OnAVPCompletionListener(AliyunRenderView aliyunRenderView) {
            weakReference = new WeakReference<>(aliyunRenderView);
        }

        @Override
        public void onCompletion() {

            AliyunRenderView aliyunRenderView = weakReference.get();
            if (aliyunRenderView != null) {
                aliyunRenderView.onCompletion();
            }
        }
    }

    public void setOnCompletionListener(IPlayer.OnCompletionListener listener) {
        this.mOnCompletionListener = listener;
    }

    private void onCompletion() {
        if (mOnCompletionListener != null) {
            mOnCompletionListener.onCompletion();
        }
    }

    /**
     * OnSeekCompleteListener
     */
    private static class OnAVPSeekCompleteListener implements IPlayer.OnSeekCompleteListener {

        private final WeakReference<AliyunRenderView> weakReference;

        private OnAVPSeekCompleteListener(AliyunRenderView aliyunRenderView) {
            weakReference = new WeakReference<>(aliyunRenderView);
        }

        @Override
        public void onSeekComplete() {

            AliyunRenderView aliyunRenderView = weakReference.get();
            if (aliyunRenderView != null) {
                aliyunRenderView.onSeekComplete();
            }
        }
    }

    public void setOnSeekCompleteListener(IPlayer.OnSeekCompleteListener listener) {
        this.mOnSeekCompleteListener = listener;
    }

    private void onSeekComplete() {
        if (mOnSeekCompleteListener != null) {
            mOnSeekCompleteListener.onSeekComplete();
        }
    }



    /**
     * OnTrackChangedListener
     */
    private static class OnAVPTrackChangedListener implements IPlayer.OnTrackChangedListener {

        private final WeakReference<AliyunRenderView> weakReference;

        private OnAVPTrackChangedListener(AliyunRenderView aliyunRenderView) {
            weakReference = new WeakReference<>(aliyunRenderView);
        }

        @Override
        public void onChangedSuccess(TrackInfo trackInfo) {

            AliyunRenderView aliyunRenderView = weakReference.get();
            if (aliyunRenderView != null) {
                aliyunRenderView.onChangedSuccess(trackInfo);
            }
        }

        @Override
        public void onChangedFail(TrackInfo trackInfo, ErrorInfo errorInfo) {

            AliyunRenderView aliyunRenderView = weakReference.get();
            if (aliyunRenderView != null) {
                aliyunRenderView.onChangedFail(trackInfo, errorInfo);
            }
        }
    }

    public void setOnTrackChangedListener(IPlayer.OnTrackChangedListener listener) {
        this.mOnTrackChangedListener = listener;
    }

    private void onChangedSuccess(TrackInfo trackInfo) {
        if (mOnTrackChangedListener != null) {
            mOnTrackChangedListener.onChangedSuccess(trackInfo);
        }
    }

    private void onChangedFail(TrackInfo trackInfo, ErrorInfo errorInfo) {
        if (mOnTrackChangedListener != null) {
            mOnTrackChangedListener.onChangedFail(trackInfo, errorInfo);
        }
    }

    /**
     * OnErrorListener
     */
    private static class OnAVPErrorListener implements IPlayer.OnErrorListener {

        private final WeakReference<AliyunRenderView> weakReference;

        private OnAVPErrorListener(AliyunRenderView aliyunRenderView) {
            weakReference = new WeakReference<>(aliyunRenderView);
        }

        @Override
        public void onError(ErrorInfo errorInfo) {

            AliyunRenderView aliyunRenderView = weakReference.get();
            if (aliyunRenderView != null) {
                aliyunRenderView.onError(errorInfo);
            }
        }
    }

    public void setOnErrorListener(IPlayer.OnErrorListener listener) {
        this.mOnErrorListener = listener;
    }

    private void onError(ErrorInfo errorInfo) {
        if (mOnErrorListener != null) {
            mOnErrorListener.onError(errorInfo);
        }
    }

    /**
     * onSubtitleDisplayListener
     */
    private static class OnAVPSubtitleDisplayListener implements IPlayer.OnSubtitleDisplayListener {

        private final WeakReference<AliyunRenderView> weakReference;

        private OnAVPSubtitleDisplayListener(AliyunRenderView aliyunRenderView) {
            weakReference = new WeakReference<>(aliyunRenderView);
        }

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

            AliyunRenderView aliyunRenderView = weakReference.get();
            if (aliyunRenderView != null) {
                aliyunRenderView.onSubtitleExtAdded(trackIndex, url);
            }
        }

        @Override
        public void onSubtitleShow(int trackIndex, long id, String data) {

            AliyunRenderView aliyunRenderView = weakReference.get();
            if (aliyunRenderView != null) {
                aliyunRenderView.onSubtitleShow(trackIndex, id, data);
            }
        }

        @Override
        public void onSubtitleHide(int trackIndex, long id) {

            AliyunRenderView aliyunRenderView = weakReference.get();
            if (aliyunRenderView != null) {
                aliyunRenderView.onSubtitleHide(trackIndex, id);
            }
        }

        @Override
        public void onSubtitleHeader(int index, String data) {

            AliyunRenderView aliyunRenderView = weakReference.get();
            if (aliyunRenderView != null) {
                aliyunRenderView.oSubtitleHeader(index, data);
            }
        }
    }

    private void oSubtitleHeader(int index, String data) {
        if (mOnSubtitleDisplayListener != null) {
            mOnSubtitleDisplayListener.onSubtitleHeader(index, data);
        }
    }

    private void onSubtitleHide(int trackIndex, long id) {
        if (mOnSubtitleDisplayListener != null) {
            mOnSubtitleDisplayListener.onSubtitleHide(trackIndex, id);
        }
    }

    private void onSubtitleShow(int trackIndex, long id, String data) {
        if (mOnSubtitleDisplayListener != null) {
            mOnSubtitleDisplayListener.onSubtitleShow(trackIndex, id, data);
        }
    }

    private void onSubtitleExtAdded(int trackIndex, String url) {
        if (mOnSubtitleDisplayListener != null) {
            mOnSubtitleDisplayListener.onSubtitleExtAdded(trackIndex, url);
        }
    }

    public void setOnSubtitleDisplayListener(IPlayer.OnSubtitleDisplayListener listener) {
        this.mOnSubtitleDisplayListener = listener;
    }

    /**
     * onSeiDataListener
     */
    private static class OnAVPSeiDataListener implements IPlayer.OnSeiDataListener {

        private final WeakReference<AliyunRenderView> weakReference;

        private OnAVPSeiDataListener(AliyunRenderView aliyunRenderView) {
            weakReference = new WeakReference<>(aliyunRenderView);
        }

        @Override
        public void onSeiData(int type, byte[] bytes) {

            AliyunRenderView aliyunRenderView = weakReference.get();
            if (aliyunRenderView != null) {
                aliyunRenderView.onSeiData(type, bytes);
            }
        }
    }

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

    public void setOnSeiDataListener(IPlayer.OnSeiDataListener listener) {
        this.mOnSeiDataListener = listener;
    }

    private static class OnAVPVerifyStsCallback implements AliPlayer.OnVerifyTimeExpireCallback {

        private final WeakReference<AliyunRenderView> weakReference;

        private OnAVPVerifyStsCallback(AliyunRenderView aliyunRenderView) {
            weakReference = new WeakReference<>(aliyunRenderView);
        }

        @Override
        public AliPlayer.Status onVerifySts(StsInfo stsInfo) {

            AliyunRenderView aliyunRenderView = weakReference.get();
            if (aliyunRenderView != null) {
                return aliyunRenderView.onVerifySts(stsInfo);
            }
            return AliPlayer.Status.Valid;
        }

        @Override
        public AliPlayer.Status onVerifyAuth(VidAuth vidAuth) {

            AliyunRenderView aliyunRenderView = weakReference.get();
            if (aliyunRenderView != null) {
                return aliyunRenderView.onVerifyAuth(vidAuth);
            }
            return AliPlayer.Status.Valid;
        }
    }

    public void setOnVerifyTimeExpireCallback(AliPlayer.OnVerifyTimeExpireCallback listener) {
        this.mOnVerifyTimeExpireCallback = listener;
    }

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

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

}