完善音频维护

MusicPlayer/src/main/java/com/yc/music/impl/PlayAudioImpl.java

@@ -20,6 +20,7 @@ import com.yc.music.tool.BaseAppHelper;
 import com.yc.music.tool.QuitTimerHelper;
 import com.yc.music.utils.NotificationHelper;
 import com.yc.videotool.VideoLogUtils;
+import com.yc.videotool.VideoSpUtils;
 
 import java.io.IOException;
 import java.util.List;
@@ -111,7 +112,7 @@ public class PlayAudioImpl implements InterPlayAudio {
         VideoLogUtils.e("PlayService"+"----id----"+ id);
         //保存当前播放的musicId，下次进来可以记录状态
         long musicId = Long.parseLong(id);
-        MusicSpUtils.getInstance(MusicConstant.SP_NAME).put(MusicConstant.MUSIC_ID,musicId);
+        VideoSpUtils.getInstance(MusicConstant.SP_NAME).put(MusicConstant.MUSIC_ID,musicId);
         play(music);
     }
 
@@ -261,7 +262,7 @@ public class PlayAudioImpl implements InterPlayAudio {
         if (audioMusics.isEmpty()) {
             return;
         }
-        int playMode = MusicSpUtils.getInstance(MusicConstant.SP_NAME).getInt(MusicConstant.PLAY_MODE, 0);
+        int playMode = VideoSpUtils.getInstance(MusicConstant.SP_NAME).getInt(MusicConstant.PLAY_MODE, 0);
         int size = audioMusics.size();
         PlayModeEnum mode = PlayModeEnum.valueOf(playMode);
         switch (mode) {
@@ -296,7 +297,7 @@ public class PlayAudioImpl implements InterPlayAudio {
         if (audioMusics.isEmpty()) {
             return;
         }
-        int playMode = MusicSpUtils.getInstance(MusicConstant.SP_NAME).getInt(MusicConstant.PLAY_MODE, 0);
+        int playMode = VideoSpUtils.getInstance(MusicConstant.SP_NAME).getInt(MusicConstant.PLAY_MODE, 0);
         int size = audioMusics.size();
         PlayModeEnum mode = PlayModeEnum.valueOf(playMode);
         switch (mode) {
@@ -572,7 +573,7 @@ public class PlayAudioImpl implements InterPlayAudio {
      */
     public void updatePlayingPosition() {
         int position = 0;
-        long id = MusicSpUtils.getInstance(MusicConstant.SP_NAME).getLong(MusicConstant.MUSIC_ID,-1);
+        long id = VideoSpUtils.getInstance(MusicConstant.SP_NAME).getLong(MusicConstant.MUSIC_ID,-1);
         if(audioMusics.isEmpty()){
             return;
         }
@@ -586,7 +587,7 @@ public class PlayAudioImpl implements InterPlayAudio {
         }
         mPlayingPosition = position;
         long musicId = Long.parseLong(audioMusics.get(mPlayingPosition).getId());
-        MusicSpUtils.getInstance(MusicConstant.SP_NAME).put(MusicConstant.MUSIC_ID,musicId);
+        VideoSpUtils.getInstance(MusicConstant.SP_NAME).put(MusicConstant.MUSIC_ID,musicId);
     }
 
 

MusicPlayer/src/main/java/com/yc/music/inter/EventCallback.java

@@ -1,6 +0,0 @@
-package com.yc.music.inter;
-
-
-public interface EventCallback<T> {
-    void onEvent(T t);
-}

MusicPlayer/src/main/java/com/yc/music/inter/InterPlayAudio.java

@@ -4,6 +4,15 @@ package com.yc.music.inter;
 import com.yc.music.model.AudioBean;
 import com.yc.music.service.PlayAudioService;
 
+/**
+ * <pre>
+ *     @author yangchong
+ *     email  : yangchong211@163.com
+ *     time  : 2017/5/6
+ *     desc  : 音频播放的接口
+ *     revise:
+ * </pre>
+ */
 public interface InterPlayAudio {
 
     void init(PlayAudioService service);

MusicPlayer/src/main/java/com/yc/music/manager/MediaSessionManager.java

@@ -21,7 +21,7 @@ public class MediaSessionManager {
             | PlaybackStateCompat.ACTION_STOP
             | PlaybackStateCompat.ACTION_SEEK_TO;
 
-    private PlayAudioService mPlayService;
+    private final PlayAudioService mPlayService;
     private MediaSessionCompat mMediaSession;
 
     public MediaSessionManager(PlayAudioService playService) {

MusicPlayer/src/main/java/com/yc/music/service/AbsAudioService.java

@@ -9,6 +9,15 @@ import androidx.annotation.Nullable;
 
 import com.yc.music.utils.NotificationHelper;
 
+/**
+ * <pre>
+ *     @author yangchong
+ *     email  : yangchong211@163.com
+ *     time  : 2017/5/6
+ *     desc  : 服务，开启前台服务
+ *     revise:
+ * </pre>
+ */
 public class AbsAudioService extends Service {
 
     /**

MusicPlayer/src/main/java/com/yc/music/service/PlayAudioService.java

@@ -12,7 +12,6 @@ import com.yc.music.config.MusicConstant;
 import com.yc.music.config.MusicPlayAction;
 import com.yc.music.delegate.PlayAudioDelegate;
 import com.yc.music.impl.PlayAudioImpl;
-import com.yc.music.inter.EventCallback;
 import com.yc.music.inter.InterPlayAudio;
 import com.yc.music.inter.OnPlayerEventListener;
 import com.yc.music.model.AudioBean;
@@ -45,6 +44,7 @@ public class PlayAudioService extends AbsAudioService {
      * 更新播放进度的显示，时间的显示
      */
     public static final int UPDATE_PLAY_PROGRESS_SHOW = 520;
+    public static final int UPDATE_PLAY_PROGRESS = 521;
 
     @SuppressLint("HandlerLeak")
     private Handler handler = new Handler(){
@@ -55,6 +55,8 @@ public class PlayAudioService extends AbsAudioService {
                 case UPDATE_PLAY_PROGRESS_SHOW:
                     mDelegate.updatePlayProgress();
                     break;
+                case UPDATE_PLAY_PROGRESS:
+                    break;
                 default:
                     break;
             }
@@ -154,7 +156,8 @@ public class PlayAudioService extends AbsAudioService {
      * 初始化计时器
      */
     private void initQuitTimer() {
-        QuitTimerHelper.getInstance().init(this, handler, new EventCallback<Long>() {
+        QuitTimerHelper.getInstance().init(this, handler,
+                new QuitTimerHelper.EventCallback<Long>() {
             @Override
             public void onEvent(Long aLong) {
                 if (mListener != null) {

MusicPlayer/src/main/java/com/yc/music/tool/QuitTimerHelper.java

@@ -2,10 +2,7 @@ package com.yc.music.tool;
 
 import android.os.Handler;
 import android.text.format.DateUtils;
-
 import androidx.annotation.NonNull;
-
-import com.yc.music.inter.EventCallback;
 import com.yc.music.service.PlayAudioService;
 
 
@@ -20,6 +17,7 @@ public class QuitTimerHelper {
     private long mTimerRemain;
 
     public static QuitTimerHelper getInstance() {
+        //使用单例模式
         return SingletonHolder.QUIT_TIMER_INSTANCE;
     }
 
@@ -68,15 +66,21 @@ public class QuitTimerHelper {
     }
 
     private final Runnable mQuitRunnable = new Runnable() {
+        //开启runnable
         @Override
         public void run() {
             mTimerRemain -= DateUtils.SECOND_IN_MILLIS;
             if (mTimerRemain > 0) {
                 mTimerCallback.onEvent(mTimerRemain);
+                //一秒种发送一次消息
                 mHandler.postDelayed(this, DateUtils.SECOND_IN_MILLIS);
             } else {
                 mPlayService.quit();
             }
         }
     };
+
+    public interface EventCallback<T> {
+        void onEvent(T t);
+    }
 }

ReadMeWiki/63.获取视频对象大小.md

@@ -0,0 +1,116 @@
+# 视频内存优化治理
+#### 目录介绍
+- 01.什么时候要知道对象内存大小
+- 02.如何获取对象占用内存大小
+- 03.看案例分析对象内存大小
+- 04.使用Unsafe来获取内存大小
+
+
+### 01.什么时候要知道对象内存大小
+- 在内存足够用的情况下我们是不需要考虑java中一个对象所占内存大小的。
+- 但当一个系统的内存有限，或者某块程序代码允许使用的内存大小有限制，又或者设计一个缓存机制，当存储对象内存超过固定值之后写入磁盘做持久化等等，总之我们希望像写C一样，java也能有方法实现获取对象占用内存的大小。
+
+ 
+
+### 02.如何获取对象占用内存大小
+- 在回答这个问题之前，我们需要先了解java的基础数据类型所占内存大小。
+    - 1k = 1024个字节(byte)；1M = 1024kb
+    ```
+    数据类型	    所占空间（byte）
+    byte　　　　	1
+    short	    2
+    int	        4
+    long	    8
+    float	    4
+    double	    8
+    char　　	    2
+    boolean	    1
+    ```
+- 当然，java作为一种面向对象的语言，更多的情况需要考虑对象的内存布局，java对于对象所占内存大小需要分两种情况考虑：
+    - 对象类型：一般非数组对象	
+        - 内存布局构成：8个字节对象头(mark) + 4/8字节对象指针 + 数据区 + padding内存对齐(按照8的倍数对齐)
+    - 对象类型：数组对象                                 	
+        - 内存布局构成：8个字节对象头(mark) + 4/8字节对象指针 + 4字节数组长度 + 数据区 + padding内存对齐(按照8的倍数对齐)
+- 可以看到数组类型对象和普通对象的区别仅在于4字节数组长度的存储区间。而对象指针究竟是4字节还是8字节要看是否开启指针压缩。
+    - Oracle JDK从6 update 23开始在64位系统上会默认开启压缩指针：http://rednaxelafx.iteye.com/blog/1010079。
+    - 如果要强行关闭指针压缩使用-XX:-UseCompressedOops,强行启用指针压缩使用: -XX:+UseCompressedOops。 
+
+
+### 03.看案例分析对象内存大小
+- 接下来我们来举例来看实现java获取对象所占内存大小的方法，假设我们有一个类的定义如下：
+    ```
+    private static class ObjectA {
+        String str;   // 4
+        int i1;       // 4
+        byte b1;      // 1
+        byte b2;      // 1
+        int i2;       // 4
+        ObjectB obj;  // 4
+        byte b3;      // 1
+    }
+  
+    ObjectA obj = new ObjectA();
+    ```
+- 如果我们直接按照上面掌握的java对象内存布局进行计算，则有：
+    - Size(ObjectA) = Size(对象头(_mark)) + size(oop指针) + size(数据区)
+    - Size(ObjectA) = 8 + 4 + 4(String) + 4(int) + 1(byte) + 1(byte) + 2(padding) + 4(int) + 4(ObjectB指针) + 1(byte) + 7(padding)
+    - Size(ObjectA) = 40
+  
+
+### 04.使用Unsafe来获取内存大小
+- 代码如下所示
+    ```
+    private final static Unsafe UNSAFE;
+    // 只能通过反射获取Unsafe对象的实例
+    static {
+        try {
+            UNSAFE = (Unsafe) Unsafe.class.getDeclaredField("theUnsafe").get(null);
+        } catch (Exception e) {
+            throw new Error();
+        }
+    }
+    
+    Field[] fields = ObjectA.class.getDeclaredFields();
+    for (Field field : fields) {
+    　　System.out.println(field.getName() + "---offSet:" + UNSAFE.objectFieldOffset(field));
+    }
+    ```
+- 输出结果为：
+    ```
+    str---offSet:24
+    i1---offSet:12
+    b1---offSet:20
+    b2---offSet:21
+    i2---offSet:16
+    obj---offSet:28
+    b3---offSet:22
+    ```
+- 我们同样可以算得对象实际占用的内存大小：
+    - Size(ObjectA) = Size(对象头(_mark)) + size(oop指针) + size(排序后数据区)  =  8 + 4 + (28+4-12)  =  32.
+- 再回过头来，看我们在通过代码获取对象所占内存大小之前的预估值40。比我们实际算出来的值多了8个字节。
+    - 通过Unsafe打印的详细信息，我们不难想到这其实是由hotspot创建对象时的排序决定的：
+    - HotSpot创建的对象的字段会先按照给定顺序排列,默认的顺序为：从长到短排列，引用排最后: long/double –> int/float –> short/char –> byte/boolean –> Reference。
+- 所以我们重新计算对象所占内存大小得：
+    - Size(ObjectA) = Size(对象头(_mark)) + size(oop指针) + size(排序后数据区)
+    - Size(ObjectA) = 8 + 4 + 4(int) + 4(int) + byte(1) + byte(1) + 2(padding) + 4(String) + 4(ObjectB指针)
+    - Size(ObjectA) = 32
+    - 与上面计算结果一致。
+
+
+
+
+
+
+
+
+
+
+### 参考链接
+- https://www.cnblogs.com/tesla-turing/p/11487815.html
+- https://www.cnblogs.com/Kidezyq/p/8030098.html
+
+
+
+
+
+

VideoPlayer/src/main/java/com/yc/video/old/controller/AbsVideoPlayerController.java

@@ -1,302 +0,0 @@
-/*
-Copyright 2017 yangchong211（github.com/yangchong211）
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package com.yc.video.old.controller;
-
-import android.content.Context;
-import android.view.MotionEvent;
-import android.view.View;
-import android.view.WindowManager;
-import android.widget.FrameLayout;
-
-import com.yc.video.tool.PlayerUtils;
-import com.yc.video.old.player.OldVideoPlayer;
-import com.yc.video.config.ConstantKeys;
-
-import java.util.Timer;
-import java.util.TimerTask;
-
-/**
- * <pre>
- *     @author yangchong
- *     blog  : https://github.com/yangchong211
- *     time  : 2017/10/21
- *     desc  : 控制器抽象类
- *     revise:
- * </pre>
- */
-@Deprecated
-public abstract class AbsVideoPlayerController extends FrameLayout implements
-        View.OnTouchListener, IVideoController {
-
-    private Context mContext;
-    protected OldVideoPlayer mVideoPlayer;
-    //protected InterPropertyVideoPlayer mVideoPlayer;
-    private Timer mUpdateProgressTimer;
-    private TimerTask mUpdateProgressTimerTask;
-    private Timer mUpdateNetSpeedTimer;
-    private TimerTask mUpdateNetSpeedTask;
-    private float mDownX;
-    private float mDownY;
-    /**
-     * 是否需要改变播放的进度
-     */
-    private boolean mNeedChangePosition;
-    /**
-     * 是否需要改变播放的声音
-     */
-    private boolean mNeedChangeVolume;
-    /**
-     * 是否需要改变播放的亮度
-     */
-    private boolean mNeedChangeBrightness;
-    private static final int THRESHOLD = 80;
-    private long mGestureDownPosition;
-    private float mGestureDownBrightness;
-    private int mGestureDownVolume;
-    private long mNewPosition;
-
-
-    public AbsVideoPlayerController(Context context) {
-        super(context);
-        mContext = context;
-        this.setOnTouchListener(this);
-    }
-
-    /**
-     * 设置VideoPlayer
-     * @param videoPlayer            VideoPlayer对象
-     */
-    public void setVideoPlayer(OldVideoPlayer videoPlayer) {
-        mVideoPlayer = videoPlayer;
-    }
-
-    /**
-     * 当正在缓冲或者播放准备中状态时，开启缓冲时更新网络加载速度
-     */
-    protected void startUpdateNetSpeedTimer() {
-        cancelUpdateNetSpeedTimer();
-        if (mUpdateNetSpeedTimer == null) {
-            mUpdateNetSpeedTimer = new Timer();
-        }
-        if (mUpdateNetSpeedTask == null) {
-            mUpdateNetSpeedTask = new TimerTask() {
-                @Override
-                public void run() {
-                    //在子线程中更新进度，包括更新网络加载速度
-                    AbsVideoPlayerController.this.post(new Runnable() {
-                        @Override
-                        public void run() {
-                            updateNetSpeedProgress();
-                        }
-                    });
-                }
-            };
-        }
-        mUpdateNetSpeedTimer.schedule(mUpdateNetSpeedTask, 0, 100);
-    }
-
-    /**
-     * 取消缓冲时更新网络加载速度
-     */
-    protected void cancelUpdateNetSpeedTimer() {
-        if (mUpdateNetSpeedTimer != null) {
-            mUpdateNetSpeedTimer.cancel();
-            mUpdateNetSpeedTimer = null;
-        }
-        if (mUpdateNetSpeedTask != null) {
-            mUpdateNetSpeedTask.cancel();
-            mUpdateNetSpeedTask = null;
-        }
-    }
-
-    /**
-     * 开启更新进度的计时器。
-     */
-    protected void startUpdateProgressTimer() {
-        cancelUpdateProgressTimer();
-        if (mUpdateProgressTimer == null) {
-            mUpdateProgressTimer = new Timer();
-        }
-        if (mUpdateProgressTimerTask == null) {
-            mUpdateProgressTimerTask = new TimerTask() {
-                @Override
-                public void run() {
-                    //在子线程中更新进度，包括进度条进度，展示的当前播放位置时长，总时长等。
-                    AbsVideoPlayerController.this.post(new Runnable() {
-                        @Override
-                        public void run() {
-                            updateProgress();
-                        }
-                    });
-                }
-            };
-        }
-        mUpdateProgressTimer.schedule(mUpdateProgressTimerTask, 0, 1000);
-    }
-
-    /**
-     * 取消更新进度的计时器。
-     */
-    protected void cancelUpdateProgressTimer() {
-        if (mUpdateProgressTimer != null) {
-            mUpdateProgressTimer.cancel();
-            mUpdateProgressTimer = null;
-        }
-        if (mUpdateProgressTimerTask != null) {
-            mUpdateProgressTimerTask.cancel();
-            mUpdateProgressTimerTask = null;
-        }
-    }
-
-    /**
-     * 滑动处理调节声音和亮度的逻辑
-     * @param v                         v
-     * @param event                     event
-     * @return                          是否自己处理滑动事件
-     */
-    @Override
-    public boolean onTouch(View v, MotionEvent event) {
-        //不能用这个做判断，如果是小窗口播放状态，那么这个返回时false
-        //boolean tinyWindow = mVideoPlayer.isTinyWindow();
-        int playType = mVideoPlayer.getPlayType();
-        //如果是小窗口模式，则可以拖拽。其他情况则正常处理
-        if(playType == ConstantKeys.PlayMode.MODE_FULL_SCREEN){
-            //处理全屏播放时，滑动处理调节声音和亮度的逻辑
-            return setOnTouch(v,event);
-        }
-        return false;
-    }
-
-
-    /**
-     * 处理全屏播放时，滑动处理调节声音和亮度的逻辑
-     * @param v                         v
-     * @param event                     event
-     * @return                          是否自己处理滑动事件
-     */
-    private boolean setOnTouch(View v, MotionEvent event) {
-        // 只有全屏的时候才能拖动位置、亮度、声音
-        if (!mVideoPlayer.isFullScreen()) {
-            return false;
-        }
-        // 只有在播放、暂停、缓冲的时候能够拖动改变位置、亮度和声音
-        if (mVideoPlayer.isIdle() || mVideoPlayer.isError() || mVideoPlayer.isPreparing()
-                || mVideoPlayer.isPrepared() || mVideoPlayer.isCompleted()) {
-            //势左右滑动改变播放位置后，手势up或者cancel时，隐藏控制器中间的播放位置变化视图
-            hideChangePosition();
-            //手势在左侧上下滑动改变亮度后，手势up或者cancel时，隐藏控制器中间的亮度变化视图，
-            hideChangeBrightness();
-            //手势在左侧上下滑动改变音量后，手势up或者cancel时，隐藏控制器中间的音量变化视图，
-            hideChangeVolume();
-            return false;
-        }
-        float x = event.getX();
-        float y = event.getY();
-        switch (event.getAction()) {
-            case MotionEvent.ACTION_DOWN:
-                //获取起点时的坐标
-                mDownX = x;
-                mDownY = y;
-                mNeedChangePosition = false;
-                mNeedChangeVolume = false;
-                mNeedChangeBrightness = false;
-                break;
-            case MotionEvent.ACTION_MOVE:
-                //计算移动过程中的x，y轴的绝对值
-                float deltaX = x - mDownX;
-                float deltaY = y - mDownY;
-                float absDeltaX = Math.abs(deltaX);
-                float absDeltaY = Math.abs(deltaY);
-                if (!mNeedChangePosition && !mNeedChangeVolume && !mNeedChangeBrightness) {
-                    // 只有在播放、暂停、缓冲的时候能够拖动改变位置、亮度和声音
-                    if (absDeltaX >= THRESHOLD) {
-                        cancelUpdateProgressTimer();
-                        mNeedChangePosition = true;
-                        mGestureDownPosition = mVideoPlayer.getCurrentPosition();
-                    } else if (absDeltaY >= THRESHOLD) {
-                        if (mDownX < getWidth() * 0.5f) {
-                            // 左侧改变亮度
-                            mNeedChangeBrightness = true;
-                            mGestureDownBrightness = PlayerUtils.scanForActivity(mContext)
-                                    .getWindow().getAttributes().screenBrightness;
-                        } else {
-                            // 右侧改变声音
-                            mNeedChangeVolume = true;
-                            mGestureDownVolume = mVideoPlayer.getVolume();
-                        }
-                    }
-                }
-                //是否需要改变播放的进度
-                if (mNeedChangePosition) {
-                    long duration = mVideoPlayer.getDuration();
-                    long toPosition = (long) (mGestureDownPosition + duration * deltaX / getWidth());
-                    mNewPosition = Math.max(0, Math.min(duration, toPosition));
-                    int newPositionProgress = (int) (100f * mNewPosition / duration);
-                    showChangePosition(duration, newPositionProgress);
-                }
-                //是否改变亮度
-                if (mNeedChangeBrightness) {
-                    deltaY = -deltaY;
-                    float deltaBrightness = deltaY * 3 / getHeight();
-                    float newBrightness = mGestureDownBrightness + deltaBrightness;
-                    newBrightness = Math.max(0, Math.min(newBrightness, 1));
-                    float newBrightnessPercentage = newBrightness;
-                    WindowManager.LayoutParams params = PlayerUtils.scanForActivity(mContext)
-                            .getWindow().getAttributes();
-                    params.screenBrightness = newBrightnessPercentage;
-                    PlayerUtils.scanForActivity(mContext).getWindow().setAttributes(params);
-                    int newBrightnessProgress = (int) (100f * newBrightnessPercentage);
-                    showChangeBrightness(newBrightnessProgress);
-                }
-                //是否改变音量
-                if (mNeedChangeVolume) {
-                    deltaY = -deltaY;
-                    int maxVolume = mVideoPlayer.getMaxVolume();
-                    int deltaVolume = (int) (maxVolume * deltaY * 3 / getHeight());
-                    int newVolume = mGestureDownVolume + deltaVolume;
-                    newVolume = Math.max(0, Math.min(maxVolume, newVolume));
-                    mVideoPlayer.setVolume(newVolume);
-                    int newVolumeProgress = (int) (100f * newVolume / maxVolume);
-                    showChangeVolume(newVolumeProgress);
-                }
-                break;
-            //滑动结束
-            case MotionEvent.ACTION_CANCEL:
-            //滑动手指抬起
-            case MotionEvent.ACTION_UP:
-                if (mNeedChangePosition) {
-                    mVideoPlayer.seekTo(mNewPosition);
-                    hideChangePosition();
-                    startUpdateProgressTimer();
-                    return true;
-                }
-                if (mNeedChangeBrightness) {
-                    hideChangeBrightness();
-                    return true;
-                }
-                if (mNeedChangeVolume) {
-                    hideChangeVolume();
-                    return true;
-                }
-                break;
-            default:
-                break;
-        }
-        return false;
-    }
-
-}

VideoPlayer/src/main/java/com/yc/video/old/controller/IVideoController.java

@@ -1,193 +0,0 @@
-/*
-Copyright 2017 yangchong211（github.com/yangchong211）
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-package com.yc.video.old.controller;
-
-import android.widget.ImageView;
-
-import androidx.annotation.DrawableRes;
-
-import com.yc.video.config.ConstantKeys;
-
-/**
- * <pre>
- *     @author yangchong
- *     blog  : https://github.com/yangchong211
- *     time  : 2017/11/21
- *     desc  : 视频控制器接口
- *     revise: 定义一些设置视图属性接口
- * </pre>
- */
-@Deprecated
-public interface IVideoController {
-
-    /**
-     * 设置top到顶部的距离
-     * @param top                   top距离
-     */
-    void setTopPadding(float top);
-
-    /**
-     * 设置横屏播放时，tv和audio图标是否显示
-     * @param isVisibility1                 tv图标是否显示
-     * @param isVisibility2                 audio图标是否显示
-     */
-    void setTvAndAudioVisibility(boolean isVisibility1, boolean isVisibility2);
-
-    /**
-     * 视频底图
-     *
-     * @param resId 视频底图资源
-     */
-    void setImage(@DrawableRes int resId);
-
-    /**
-     * 设置总时长
-     */
-    void setLength(long length);
-
-    /**
-     * 设置总时长
-     */
-    void setLength(String length);
-
-    /**
-     * 视频底图ImageView控件，提供给外部用图片加载工具来加载网络图片
-     *
-     * @return 底图ImageView
-     */
-    ImageView imageView();
-
-    /**
-     * 获取是否是锁屏模式
-     * @return                      true表示锁屏
-     */
-    boolean getLock();
-
-    /**
-     * 设置是否显示视频头部的下载，分享布局控件
-     * @param isVisibility          是否可见
-     */
-    void setTopVisibility(boolean isVisibility);
-
-    /**
-     * 设置不操作后，多久自动隐藏头部和底部布局
-     * @param time                  时间
-     */
-    void setHideTime(long time);
-
-    /**
-     * 设置加载loading类型
-     *
-     * @param type 加载loading的类型
-     *             目前1，是仿腾讯加载loading
-     *             2，是转圈加载loading
-     */
-    void setLoadingType(@ConstantKeys.LoadingType int type);
-
-    /**
-     * 设置播放的视频的标题
-     *
-     * @param title 视频标题
-     */
-    void setTitle(String title);
-
-    /**
-     * 当播放器的播放状态发生变化，在此方法中国你更新不同的播放状态的UI
-     *
-     * @param playState 播放状态：
-     */
-    void onPlayStateChanged(@ConstantKeys.CurrentState int playState);
-
-    /**
-     * 当播放器的播放模式发生变化，在此方法中更新不同模式下的控制器界面。
-     *
-     * @param playMode 播放器的模式：
-     */
-    void onPlayModeChanged(@ConstantKeys.PlayMode int playMode);
-
-    /**
-     * 重置控制器，将控制器恢复到初始状态。
-     */
-    void reset();
-
-    /**
-     * 控制器意外销毁，比如手动退出，意外崩溃等等
-     */
-    void destroy();
-
-
-
-    /**
-     * 更新进度，包括更新网络加载速度
-     */
-    void updateNetSpeedProgress();
-
-    /**
-     * 更新进度，包括进度条进度，展示的当前播放位置时长，总时长等。
-     */
-    void updateProgress();
-
-    /**
-     * 手势左右滑动改变播放位置时，显示控制器中间的播放位置变化视图，
-     * 在手势滑动ACTION_MOVE的过程中，会不断调用此方法。
-     *
-     * @param duration            视频总时长ms
-     * @param newPositionProgress 新的位置进度，取值0到100。
-     */
-    void showChangePosition(long duration, int newPositionProgress);
-
-    /**
-     * 手势左右滑动改变播放位置后，手势up或者cancel时，隐藏控制器中间的播放位置变化视图，
-     * 在手势ACTION_UP或ACTION_CANCEL时调用。
-     */
-    void hideChangePosition();
-
-    /**
-     * 手势在右侧上下滑动改变音量时，显示控制器中间的音量变化视图，
-     * 在手势滑动ACTION_MOVE的过程中，会不断调用此方法。
-     *
-     * @param newVolumeProgress 新的音量进度，取值1到100。
-     */
-    void showChangeVolume(int newVolumeProgress);
-
-    /**
-     * 手势在左侧上下滑动改变音量后，手势up或者cancel时，隐藏控制器中间的音量变化视图，
-     * 在手势ACTION_UP或ACTION_CANCEL时调用。
-     */
-    void hideChangeVolume();
-
-    /**
-     * 手势在左侧上下滑动改变亮度时，显示控制器中间的亮度变化视图，
-     * 在手势滑动ACTION_MOVE的过程中，会不断调用此方法。
-     *
-     * @param newBrightnessProgress 新的亮度进度，取值1到100。
-     */
-    void showChangeBrightness(int newBrightnessProgress);
-
-    /**
-     * 手势在左侧上下滑动改变亮度后，手势up或者cancel时，隐藏控制器中间的亮度变化视图，
-     * 在手势ACTION_UP或ACTION_CANCEL时调用。
-     */
-    void hideChangeBrightness();
-
-    /**
-     * 当电量发生变化的时候，在此方法中国你更新不同的电量状态的UI
-     *
-     * @param batterState 电量状态
-     */
-    void onBatterStateChanged(int batterState);
-
-}

VideoPlayer/src/main/java/com/yc/video/old/controller/VideoPlayerController.java

@@ -1,1294 +0,0 @@
-/*
-Copyright 2017 yangchong211（github.com/yangchong211）
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-package com.yc.video.old.controller;
-
-import android.annotation.SuppressLint;
-import android.content.BroadcastReceiver;
-import android.content.Context;
-import android.content.Intent;
-import android.content.IntentFilter;
-import android.os.Build;
-import android.os.CountDownTimer;
-import android.view.LayoutInflater;
-import android.view.MotionEvent;
-import android.view.View;
-import android.widget.FrameLayout;
-import android.widget.ImageView;
-import android.widget.LinearLayout;
-import android.widget.ProgressBar;
-import android.widget.SeekBar;
-import android.widget.TextView;
-
-import androidx.annotation.DrawableRes;
-import androidx.annotation.IntRange;
-
-import com.yc.videotool.VideoLogUtils;
-import com.yc.video.tool.BaseToast;
-import com.yc.video.tool.PlayerUtils;
-
-import com.yc.video.config.VideoInfoBean;
-import com.yc.video.old.dialog.ChangeClarityDialog;
-import com.yc.video.R;
-import com.yc.video.old.listener.OnPlayerStatesListener;
-import com.yc.video.old.listener.OnPlayerTypeListener;
-import com.yc.video.old.player.OldVideoPlayer;
-import com.yc.video.old.other.BatterReceiver;
-import com.yc.video.old.other.NetChangedReceiver;
-import com.yc.video.config.ConstantKeys;
-import com.yc.video.old.listener.OnClarityChangedListener;
-import com.yc.video.old.listener.OnVideoControlListener;
-
-import java.text.SimpleDateFormat;
-import java.util.ArrayList;
-import java.util.Date;
-import java.util.List;
-import java.util.Locale;
-
-
-/**
- * <pre>
- *     @author yangchong
- *     blog  : https://github.com/yangchong211
- *     time  : 2017/9/29
- *     desc  : 播放器控制器，主要是处理UI操作逻辑
- *     revise: 注意：建议先判断状态，再进行设置参数
- * </pre>
- */
-
-@Deprecated
-public class VideoPlayerController extends AbsVideoPlayerController implements View.OnClickListener{
-
-    private Context mContext;
-    private ImageView mImage;
-    private ImageView mCenterStart;
-    /**
-     * top顶部视图，包括所有的
-     */
-    private LinearLayout mTop;
-    private ImageView mBack;
-    private TextView mTitle;
-    /**
-     * 正常视频，top顶部视图，包括下载，分享，更多，音频控件
-     */
-    private LinearLayout mLlTopOther;
-    private ImageView mIvDownload;
-    private ImageView mIvAudio;
-    private ImageView mIvShare;
-    private ImageView mIvMenu;
-    /**
-     * 横向屏幕视图，top顶部视图，包括音频，tv，电量，时间等控件
-     */
-    private LinearLayout mLlHorizontal;
-    private ImageView mIvHorAudio;
-    private ImageView mIvHorTv;
-    private ImageView mBattery;
-    private TextView mTime;
-    /**
-     * 底部视图，包括所有的
-     */
-    private LinearLayout mBottom;
-    private ImageView mRestartPause;
-    private TextView mPosition;
-    private TextView mDuration;
-    private SeekBar mSeek;
-    private TextView mClarity;
-    private ImageView mFullScreen;
-    private TextView mLength;
-    /**
-     * 加载loading视图，包括所有的
-     */
-    private LinearLayout mLoading;
-    private ProgressBar pbLoadingRing;
-    private ProgressBar pbLoadingQq;
-    private TextView mLoadText;
-    /**
-     * 改变播放位置视图，这个是在屏幕上左右滑动切换播放进度的控件
-     */
-    private LinearLayout mChangePosition;
-    private TextView mChangePositionCurrent;
-    private ProgressBar mChangePositionProgress;
-    /**
-     * 改变屏幕亮度视图，这个是在屏幕左边上下滑动改变亮度的控件
-     */
-    private LinearLayout mChangeBrightness;
-    private ProgressBar mChangeBrightnessProgress;
-    /**
-     * 改变播放声音视图，这个是在屏幕右边上下滑动改变音量的控件
-     */
-    private LinearLayout mChangeVolume;
-    private ProgressBar mChangeVolumeProgress;
-    /**
-     * 异常壮体视图
-     */
-    private LinearLayout mError;
-    private TextView mTvError;
-    private TextView mRetry;
-    /**
-     * 完成播放视图
-     */
-    private LinearLayout mCompleted;
-    private TextView mReplay;
-    private TextView mShare;
-    /**
-     * 锁屏视图，只有在横屏播放的时候才会显示
-     */
-    private FrameLayout mFlLock;
-    private ImageView mIvLock;
-    /**
-     * 底部播放进度条
-     */
-    private LinearLayout mLine;
-    private ProgressBar mPbPlayBar;
-
-
-    /**
-     * top视图和bottom视图是否显示
-     */
-    private boolean topBottomVisible;
-    /**
-     * 倒计时器
-     */
-    private CountDownTimer mDismissTopBottomCountDownTimer;
-    private List<VideoInfoBean> clarities;
-    private int defaultClarityIndex;
-    private ChangeClarityDialog mClarityDialog;
-    /**
-     * 是否已经注册了电池广播
-     */
-    private boolean hasRegisterBatteryReceiver;
-    /**
-     * 是否已经注册了网络监听广播，添加这个判断可以避免崩溃
-     */
-    private boolean hasRegisterNetReceiver;
-    /**
-     * 是否锁屏
-     */
-    private boolean mIsLock = false;
-    /**
-     * 这个是time时间不操作界面，则自动隐藏顶部和底部视图布局
-     */
-    private long time;
-    /**
-     * 顶部的布局，下载，切换音频，分享布局是否显示。
-     * 默认为false，不显示
-     */
-    private boolean mIsTopLayoutVisibility = false;
-    /**
-     * 设置横屏播放时，tv图标是否显示
-     * 默认为false，不显示
-     */
-    private boolean mIsTvIconVisibility = false;
-    /**
-     * 设置横屏播放时，audio图标是否显示
-     * 默认为false，不显示
-     */
-    private boolean mIsAudioIconVisibility = false;
-    /**
-     * 网络变化监听广播，在网络变更时进行对应处理
-     */
-    private NetChangedReceiver netChangedReceiver;
-    /**
-     * 电池状态即电量变化广播接收器
-     */
-    private BroadcastReceiver mBatterReceiver;
-
-    public VideoPlayerController(Context context) {
-        super(context);
-        mContext = context;
-        init();
-    }
-
-    @Override
-    protected void onAttachedToWindow() {
-        super.onAttachedToWindow();
-    }
-
-    /**
-     * 注意，在view被销毁调用该方法后，手动销毁动画
-     */
-    @Override
-    protected void onDetachedFromWindow() {
-        super.onDetachedFromWindow();
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-            if (pbLoadingRing!=null && pbLoadingRing.getVisibility()==View.VISIBLE){
-                boolean animating = pbLoadingRing.isAnimating();
-                if (animating){
-                    pbLoadingRing.clearAnimation();
-                }
-            }
-            if (pbLoadingQq!=null && pbLoadingQq.getVisibility()==View.VISIBLE){
-                boolean ringAnimating = pbLoadingQq.isAnimating();
-                if (ringAnimating){
-                    pbLoadingQq.clearAnimation();
-                }
-            }
-        } else {
-            if (pbLoadingRing!=null && pbLoadingRing.getVisibility()==View.VISIBLE){
-                pbLoadingRing.clearAnimation();
-            }
-            if (pbLoadingQq!=null && pbLoadingQq.getVisibility()==View.VISIBLE){
-                pbLoadingQq.clearAnimation();
-            }
-        }
-    }
-
-    /**
-     * 注册网络监听广播
-     */
-    private void registerNetChangedReceiver() {
-        if (!hasRegisterNetReceiver) {
-            if (netChangedReceiver == null) {
-                netChangedReceiver = new NetChangedReceiver();
-                IntentFilter filter = new IntentFilter();
-                filter.addAction("android.net.conn.CONNECTIVITY_CHANGE");
-                mContext.registerReceiver(netChangedReceiver, filter);
-                VideoLogUtils.i("广播监听---------注册网络监听广播");
-            }
-            hasRegisterNetReceiver = true;
-        }
-    }
-
-
-    /**
-     * 当播放完成或者意外销毁，都需要解绑注册网络监听广播
-     */
-    private void unRegisterNetChangedReceiver() {
-        if (hasRegisterNetReceiver) {
-            if (netChangedReceiver != null) {
-                mContext.unregisterReceiver(netChangedReceiver);
-                VideoLogUtils.i("广播监听---------解绑注册网络监听广播");
-            }
-            hasRegisterNetReceiver = false;
-        }
-    }
-
-    /**
-     * 注册电池监听广播
-     */
-    private void registerBatterReceiver() {
-        if (!hasRegisterBatteryReceiver) {
-            mBatterReceiver = new BatterReceiver();
-            mContext.registerReceiver(mBatterReceiver, new IntentFilter(
-                    Intent.ACTION_BATTERY_CHANGED));
-            hasRegisterBatteryReceiver = true;
-            VideoLogUtils.i("广播监听---------注册电池监听广播");
-        }
-    }
-
-
-    /**
-     * 当播放完成或者意外销毁，都需要解绑注册电池监听广播
-     */
-    private void unRegisterBatterReceiver() {
-        if (hasRegisterBatteryReceiver) {
-            mContext.unregisterReceiver(mBatterReceiver);
-            hasRegisterBatteryReceiver = false;
-            VideoLogUtils.i("广播监听---------解绑电池监听广播");
-        }
-    }
-
-    /**
-     * 初始化操作
-     */
-    private void init() {
-        LayoutInflater.from(mContext).inflate(R.layout.old_video_player, this, true);
-        initFindViewById();
-        initListener();
-        registerNetChangedReceiver();
-    }
-
-    private void initFindViewById() {
-        mCenterStart = findViewById(R.id.center_start);
-        mImage = findViewById(R.id.image);
-
-        mTop = findViewById(R.id.top);
-        mBack = findViewById(R.id.back);
-        mTitle = findViewById(R.id.title);
-        mLlTopOther = findViewById(R.id.ll_top_other);
-        mIvDownload = findViewById(R.id.iv_download);
-        mIvAudio =  findViewById(R.id.iv_audio);
-        mIvShare = findViewById(R.id.iv_share);
-        mIvMenu = findViewById(R.id.iv_menu);
-
-        mLlHorizontal = findViewById(R.id.ll_horizontal);
-        mIvHorAudio = findViewById(R.id.iv_hor_audio);
-        mIvHorTv = findViewById(R.id.iv_hor_tv);
-        mBattery = findViewById(R.id.battery);
-        mTime = findViewById(R.id.time);
-
-        mBottom = findViewById(R.id.bottom);
-        mRestartPause = findViewById(R.id.restart_or_pause);
-        mPosition = findViewById(R.id.position);
-        mDuration = findViewById(R.id.duration);
-        mSeek = findViewById(R.id.seek);
-        mFullScreen = findViewById(R.id.full_screen);
-        mClarity = findViewById(R.id.clarity);
-        mLength = findViewById(R.id.length);
-        mLoading = findViewById(R.id.loading);
-        pbLoadingRing = findViewById(R.id.pb_loading_ring);
-        pbLoadingQq = findViewById(R.id.pb_loading_qq);
-
-        mLoadText = findViewById(R.id.load_text);
-        mChangePosition = findViewById(R.id.change_position);
-        mChangePositionCurrent = findViewById(R.id.change_position_current);
-        mChangePositionProgress = findViewById(R.id.change_position_progress);
-        mChangeBrightness = findViewById(R.id.change_brightness);
-        mChangeBrightnessProgress = findViewById(R.id.change_brightness_progress);
-        mChangeVolume = findViewById(R.id.change_volume);
-        mChangeVolumeProgress = findViewById(R.id.change_volume_progress);
-
-        mError = findViewById(R.id.error);
-        mTvError = findViewById(R.id.tv_error);
-        mRetry = findViewById(R.id.retry);
-        mCompleted = findViewById(R.id.completed);
-        mReplay = findViewById(R.id.replay);
-        mShare = findViewById(R.id.share);
-        mFlLock = findViewById(R.id.fl_lock);
-        mIvLock = findViewById(R.id.iv_lock);
-
-        mLine = findViewById(R.id.line);
-        mPbPlayBar = findViewById(R.id.pb_play_bar);
-
-        setTopVisibility(mIsTopLayoutVisibility);
-    }
-
-
-    private void initListener() {
-        mCenterStart.setOnClickListener(this);
-        mBack.setOnClickListener(this);
-        mIvDownload.setOnClickListener(this);
-        mIvShare.setOnClickListener(this);
-        mIvAudio.setOnClickListener(this);
-        mIvMenu.setOnClickListener(this);
-        mIvHorAudio.setOnClickListener(this);
-        mIvHorTv.setOnClickListener(this);
-        mRestartPause.setOnClickListener(this);
-        mFullScreen.setOnClickListener(this);
-        mClarity.setOnClickListener(this);
-        mRetry.setOnClickListener(this);
-        mReplay.setOnClickListener(this);
-        mShare.setOnClickListener(this);
-        mFlLock.setOnClickListener(this);
-        mSeek.setOnSeekBarChangeListener(new SeekBar.OnSeekBarChangeListener() {
-            @Override
-            public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) {
-
-            }
-
-            @Override
-            public void onStartTrackingTouch(SeekBar seekBar) {
-
-            }
-
-            @Override
-            public void onStopTrackingTouch(SeekBar seekBar) {
-                if (mVideoPlayer.isBufferingPaused() || mVideoPlayer.isPaused()) {
-                    mVideoPlayer.restart();
-                }
-                long position = (long) (mVideoPlayer.getDuration() * seekBar.getProgress() / 100f);
-                mVideoPlayer.seekTo(position);
-                startDismissTopBottomTimer();
-            }
-        });
-        this.setOnClickListener(this);
-    }
-
-
-    /**
-     * 18年3月15日添加
-     * 设置是否显示视频头部的下载，分享布局控件
-     * @param isVisibility          是否可见
-     */
-    @Override
-    public void setTopVisibility(boolean isVisibility) {
-        this.mIsTopLayoutVisibility = isVisibility;
-        if(isVisibility){
-            mLlTopOther.setVisibility(VISIBLE);
-        }else {
-            mLlTopOther.setVisibility(GONE);
-        }
-    }
-
-    /**
-     * 设置横屏播放时，tv和audio图标是否显示
-     * @param isVisibility1                 tv图标是否显示
-     * @param isVisibility2                 audio图标是否显示
-     */
-    @Override
-    public void setTvAndAudioVisibility(boolean isVisibility1, boolean isVisibility2) {
-        this.mIsTvIconVisibility = isVisibility1;
-        this.mIsAudioIconVisibility = isVisibility2;
-        mIvHorTv.setVisibility(mIsTvIconVisibility?VISIBLE:GONE);
-        mIvHorAudio.setVisibility(mIsAudioIconVisibility?VISIBLE:GONE);
-    }
-
-
-    /**
-     * 18年1月12号添加
-     * 设置加载loading类型
-     *
-     * @param type 加载loading的类型
-     *             目前1，是仿腾讯加载loading
-     *             2，是转圈加载loading
-     *             默认是2，后期想让用户自定义loading加载视图，不过暂时没实现
-     *             更多可以关注我的GitHub：https://github.com/yangchong211
-     */
-    @Override
-    public void setLoadingType(@ConstantKeys.LoadingType int type) {
-        switch (type){
-            case ConstantKeys.Loading.LOADING_RING:
-                pbLoadingRing.setVisibility(VISIBLE);
-                pbLoadingQq.setVisibility(GONE);
-                break;
-            case ConstantKeys.Loading.LOADING_QQ:
-                pbLoadingRing.setVisibility(GONE);
-                pbLoadingQq.setVisibility(VISIBLE);
-                break;
-            default:
-                pbLoadingRing.setVisibility(VISIBLE);
-                pbLoadingQq.setVisibility(GONE);
-                break;
-        }
-    }
-
-
-    /**
-     * 设置不操作后，多久自动隐藏头部和底部布局
-     * 添加值范围注释，限定时间为1秒到10秒之间
-     * @param time                  时间
-     */
-    @Override
-    public void setHideTime(@IntRange(from = 1000 , to = 10000) long time) {
-        this.time = time;
-    }
-
-
-    /**
-     * 设置视频标题
-     * @param title             视频标题
-     */
-    @Override
-    public void setTitle(String title) {
-        if (title!=null && title.length()>0){
-            mTitle.setText(title);
-        }
-    }
-
-
-    /**
-     * 获取ImageView的对象
-     * @return                  对象
-     */
-    @Override
-    public ImageView imageView() {
-        return mImage;
-    }
-
-
-    /**
-     * 设置图片
-     * @param resId             视频底图资源
-     */
-    @Override
-    public void setImage(@DrawableRes int resId) {
-        mImage.setImageResource(resId);
-    }
-
-
-    /**
-     * 设置视频时长
-     * @param length            时长，long类型
-     */
-    @Override
-    public void setLength(long length) {
-        if (length>0){
-            mLength.setVisibility(VISIBLE);
-            mLength.setText(PlayerUtils.formatTime(length));
-        } else {
-            mLength.setVisibility(GONE);
-        }
-    }
-
-
-    /**
-     * 设置视频时长
-     * @param length            时长，String类型
-     */
-    @Override
-    public void setLength(String length) {
-        if (length!=null && length.length()>0){
-            mLength.setVisibility(VISIBLE);
-            mLength.setText(length);
-        } else {
-            mLength.setVisibility(GONE);
-        }
-    }
-
-
-    /**
-     * 设置播放器
-     * @param videoPlayer   播放器
-     */
-    @Override
-    public void setVideoPlayer(OldVideoPlayer videoPlayer) {
-        super.setVideoPlayer(videoPlayer);
-        // 给播放器配置视频链接地址
-        if (clarities != null && clarities.size() > 1 && clarities.size()>defaultClarityIndex) {
-            mVideoPlayer.setUp(clarities.get(defaultClarityIndex).getVideoUrl(), null);
-        }
-    }
-
-    /**
-     * 设置top到顶部的距离
-     * @param top                   top
-     */
-    @Override
-    public void setTopPadding(float top) {
-        //如果设置0，则模式是10dp
-        if (top==0){
-            top = 10.0f;
-        }
-        mTop.setPadding(PlayerUtils.dp2px(mContext,10.0f),
-                PlayerUtils.dp2px(mContext,top),
-                PlayerUtils.dp2px(mContext,10.0f), 0);
-        mTop.invalidate();
-    }
-
-
-    /**
-     * 获取是否是锁屏模式
-     * @return              true表示锁屏
-     */
-    @Override
-    public boolean getLock() {
-        return mIsLock;
-    }
-
-    /**
-     * 如果锁屏，则屏蔽滑动事件
-     */
-    @Override
-    public boolean onTouchEvent(MotionEvent event) {
-        VideoLogUtils.i("如果锁屏2，则屏蔽返回键");
-        //如果锁屏了，那就就不需要处理滑动的逻辑
-        return !getLock() && super.onTouchEvent(event);
-    }
-
-
-    /**
-     * 设置视频清晰度
-     * @param clarities                         清晰度
-     * @param defaultClarityIndex               默认清晰度
-     */
-    public void setClarity(final List<VideoInfoBean> clarities, int defaultClarityIndex) {
-        if (clarities != null && clarities.size() > 1) {
-            this.clarities = clarities;
-            this.defaultClarityIndex = defaultClarityIndex;
-            List<String> clarityGrades = new ArrayList<>();
-            for (VideoInfoBean clarity : clarities) {
-                clarityGrades.add(clarity.getGrade() + " " + clarity.getP());
-            }
-            mClarity.setText(clarities.get(defaultClarityIndex).getGrade());
-            // 初始化切换清晰度对话框
-            mClarityDialog = new ChangeClarityDialog(mContext);
-            mClarityDialog.setClarityGrade(clarityGrades, defaultClarityIndex);
-            mClarityDialog.setOnClarityCheckedListener(new OnClarityChangedListener() {
-                @Override
-                public void onClarityChanged(int clarityIndex) {
-                    // 根据切换后的清晰度索引值，设置对应的视频链接地址，并从当前播放位置接着播放
-                    VideoInfoBean clarity = clarities.get(clarityIndex);
-                    mClarity.setText(clarity.getGrade());
-                    long currentPosition = mVideoPlayer.getCurrentPosition();
-                    //释放播放器
-                    mVideoPlayer.releasePlayer();
-                    //设置视频Url，以及headers
-                    mVideoPlayer.setUp(clarity.getVideoUrl(), null);
-                    //开始从此位置播放
-                    mVideoPlayer.start(currentPosition);
-                }
-
-                @Override
-                public void onClarityNotChanged() {
-                    // 清晰度没有变化，对话框消失后，需要重新显示出top、bottom
-                    setTopBottomVisible(true);
-                }
-            });
-            // 给播放器配置视频链接地址
-            if (mVideoPlayer != null) {
-                mVideoPlayer.setUp(clarities.get(defaultClarityIndex).getVideoUrl(), null);
-            }
-        }
-    }
-
-
-    /**
-     * 当播放状态发生改变时
-     * @param playState 播放状态：
-     */
-    @SuppressLint("SetTextI18n")
-    @Override
-    public void onPlayStateChanged(@ConstantKeys.CurrentState int playState) {
-        switch (playState) {
-            case ConstantKeys.CurrentState.STATE_IDLE:
-                break;
-            //播放准备中
-            case ConstantKeys.CurrentState.STATE_PREPARING:
-                startPreparing();
-                break;
-            //播放准备就绪
-            case ConstantKeys.CurrentState.STATE_PREPARED:
-                startUpdateProgressTimer();
-                //取消缓冲时更新网络加载速度
-                cancelUpdateNetSpeedTimer();
-                break;
-            //正在播放
-            case ConstantKeys.CurrentState.STATE_PLAYING:
-                statePlaying();
-                break;
-            //暂停播放
-            case ConstantKeys.CurrentState.STATE_PAUSED:
-                statePaused();
-                break;
-            //正在缓冲(播放器正在播放时，缓冲区数据不足，进行缓冲，缓冲区数据足够后恢复播放)
-            case ConstantKeys.CurrentState.STATE_BUFFERING_PLAYING:
-                stateBufferingPlaying();
-                break;
-            //暂停缓冲
-            case ConstantKeys.CurrentState.STATE_BUFFERING_PAUSED:
-                stateBufferingPaused();
-                break;
-            //播放错误
-            case ConstantKeys.CurrentState.STATE_ERROR:
-                stateError();
-                break;
-            //播放完成
-            case ConstantKeys.CurrentState.STATE_COMPLETED:
-                stateCompleted();
-                break;
-            default:
-                break;
-        }
-    }
-
-    /**
-     * 播放准备中
-     */
-    private void startPreparing() {
-        mLoading.setVisibility(View.VISIBLE);
-        mLoadText.setText("正在准备...");
-        mImage.setVisibility(View.GONE);
-        mError.setVisibility(View.GONE);
-        mCompleted.setVisibility(View.GONE);
-        mCenterStart.setVisibility(View.GONE);
-        mLength.setVisibility(View.GONE);
-        mPbPlayBar.setVisibility(GONE);
-        setTopBottomVisible(false);
-        //开启缓冲时更新网络加载速度
-        startUpdateNetSpeedTimer();
-        startUpdateProgressTimer();
-    }
-
-    /**
-     * 正在播放
-     */
-    private void statePlaying() {
-        mLoading.setVisibility(View.GONE);
-        mPbPlayBar.setVisibility(View.VISIBLE);
-        mRestartPause.setImageResource(R.drawable.ic_player_pause);
-        mCenterStart.setImageResource(R.drawable.icon_pause_center);
-        setTopBottomVisible(true);
-        startDismissTopBottomTimer();
-        cancelUpdateNetSpeedTimer();
-    }
-
-    /**
-     * 暂停播放
-     */
-    private void statePaused() {
-        mLoading.setVisibility(View.GONE);
-        mRestartPause.setImageResource(R.drawable.ic_player_start);
-        mCenterStart.setImageResource(R.drawable.icon_play_center);
-        setTopBottomVisible(true);
-        cancelDismissTopBottomTimer();
-        cancelUpdateNetSpeedTimer();
-    }
-
-    /**
-     * 正在缓冲(播放器正在播放时，缓冲区数据不足，进行缓冲，缓冲区数据足够后恢复播放)
-     */
-    private void stateBufferingPlaying() {
-        mLoading.setVisibility(View.VISIBLE);
-        setTopBottomVisible(false);
-        mRestartPause.setImageResource(R.drawable.ic_player_pause);
-        mCenterStart.setImageResource(R.drawable.icon_pause_center);
-        mLoadText.setText("正在准备...");
-        startDismissTopBottomTimer();
-        cancelUpdateNetSpeedTimer();
-    }
-
-    /**
-     * 暂停缓冲
-     */
-    private void stateBufferingPaused() {
-        mLoading.setVisibility(View.VISIBLE);
-        mRestartPause.setImageResource(R.drawable.ic_player_start);
-        mCenterStart.setImageResource(R.drawable.icon_play_center);
-        mLoadText.setText("正在准备...");
-        setTopBottomVisible(false);
-        cancelDismissTopBottomTimer();
-        //开启缓冲时更新网络加载速度
-        startUpdateNetSpeedTimer();
-    }
-
-    /**
-     * 播放错误
-     */
-    private void stateError() {
-        mLoading.setVisibility(View.GONE);
-        setTopBottomVisible(false);
-        mError.setVisibility(View.VISIBLE);
-        cancelUpdateProgressTimer();
-        cancelUpdateNetSpeedTimer();
-        if (!PlayerUtils.isConnected(mContext)){
-            mTvError.setText("没有网络，请链接网络");
-        } else {
-            mTvError.setText("播放错误，请重试");
-        }
-    }
-
-    /**
-     * 播放完成
-     */
-    private void stateCompleted() {
-        cancelUpdateProgressTimer();
-        cancelUpdateNetSpeedTimer();
-        setTopBottomVisible(false);
-        mLoading.setVisibility(View.GONE);
-        mImage.setVisibility(View.VISIBLE);
-        mCompleted.setVisibility(View.VISIBLE);
-        //设置播放完成的监听事件
-        if (mOnPlayerStatesListener!=null){
-            mOnPlayerStatesListener.onPlayerStates(ConstantKeys.PlayerStatesType.COMPLETED);
-        }
-        mPbPlayBar.setProgress(100);
-        //当播放完成就解除广播
-        unRegisterNetChangedReceiver();
-    }
-
-    /**
-     * 当播放器的播放模式发生变化时
-     * @param playMode 播放器的模式：
-     */
-    @Override
-    public void onPlayModeChanged(@ConstantKeys.PlayMode int playMode) {
-        switch (playMode) {
-            //普通模式
-            case ConstantKeys.PlayMode.MODE_NORMAL:
-                //隐藏锁屏控件
-                mFlLock.setVisibility(View.GONE);
-                mFullScreen.setImageResource(R.drawable.ic_player_open);
-                mFullScreen.setVisibility(View.VISIBLE);
-                //隐藏清晰度
-                mClarity.setVisibility(View.GONE);
-                //隐藏横屏的时候展现的布局
-                mLlHorizontal.setVisibility(View.GONE);
-                unRegisterBatterReceiver();
-                mIsLock = false;
-                if (mOnPlayerTypeListener!=null){
-                    mOnPlayerTypeListener.onPlayerPattern(ConstantKeys.PlayMode.MODE_NORMAL);
-                }
-
-                setTopBottomVisible(true);
-                //隐藏电量图标
-                mBattery.setVisibility(GONE);
-                VideoLogUtils.d("播放模式--------普通模式");
-                break;
-            //全屏模式
-            case ConstantKeys.PlayMode.MODE_FULL_SCREEN:
-                mFlLock.setVisibility(View.VISIBLE);
-                mFullScreen.setVisibility(View.VISIBLE);
-                mFullScreen.setImageResource(R.drawable.ic_player_close);
-                if (clarities != null && clarities.size() > 1) {
-                    mClarity.setVisibility(View.VISIBLE);
-                }
-                mLlHorizontal.setVisibility(View.VISIBLE);
-                mIvHorTv.setVisibility(mIsTvIconVisibility?VISIBLE:GONE);
-                mIvHorAudio.setVisibility(mIsAudioIconVisibility?VISIBLE:GONE);
-                setTopBottomVisible(true);
-                registerBatterReceiver();
-                if (mOnPlayerTypeListener!=null){
-                    mOnPlayerTypeListener.onPlayerPattern(ConstantKeys.PlayMode.MODE_FULL_SCREEN);
-                }
-                VideoLogUtils.d("播放模式--------全屏模式");
-                break;
-            //小窗口模式
-            case ConstantKeys.PlayMode.MODE_TINY_WINDOW:
-                mFlLock.setVisibility(View.GONE);
-                mFullScreen.setImageResource(R.drawable.ic_player_open);
-                mFullScreen.setVisibility(View.VISIBLE);
-                mIsLock = false;
-                if (mOnPlayerTypeListener!=null){
-                    mOnPlayerTypeListener.onPlayerPattern(ConstantKeys.PlayMode.MODE_TINY_WINDOW);
-                }
-                VideoLogUtils.d("播放模式--------小窗口模式");
-                break;
-            default:
-                break;
-        }
-    }
-
-    /**
-     * 重新设置
-     */
-    @Override
-    public void reset() {
-        topBottomVisible = false;
-        cancelUpdateProgressTimer();
-        cancelDismissTopBottomTimer();
-        mSeek.setProgress(0);
-        mSeek.setSecondaryProgress(0);
-        mPbPlayBar.setProgress(0);
-        mCenterStart.setVisibility(VISIBLE);
-        mLength.setVisibility(View.GONE);
-        mFlLock.setVisibility(View.GONE);
-        mImage.setVisibility(View.VISIBLE);
-        mBottom.setVisibility(View.GONE);
-        mLoading.setVisibility(View.GONE);
-        mError.setVisibility(View.GONE);
-        mCompleted.setVisibility(View.GONE);
-    }
-
-    /**
-     * 注意：跟重置有区别
-     * 控制器意外销毁，比如手动退出，意外崩溃等等
-     */
-    @Override
-    public void destroy() {
-        //当播放完成就解除广播
-        unRegisterNetChangedReceiver();
-        unRegisterBatterReceiver();
-        //结束timer
-        cancelUpdateProgressTimer();
-        cancelUpdateNetSpeedTimer();
-    }
-
-    /**
-     * 尽量不要在onClick中直接处理控件的隐藏、显示及各种UI逻辑。
-     * UI相关的逻辑都尽量到{@link #onPlayStateChanged}和{@link #onPlayModeChanged}中处理.
-     */
-    @Override
-    public void onClick(View v) {
-        if (v == mCenterStart) {
-            //开始播放
-            startVideo();
-        } else if (v == mBack) {
-            //退出，执行返回逻辑
-            //如果是全屏，则先退出全屏
-            if (mVideoPlayer.isFullScreen()) {
-                mVideoPlayer.exitFullScreen();
-            } else if (mVideoPlayer.isTinyWindow()) {
-                //如果是小窗口，则退出小窗口
-                mVideoPlayer.exitTinyWindow();
-            } else {
-                //如果两种情况都不是，执行逻辑交给使用者自己实现
-                if(mOnPlayerStatesListener!=null){
-                    mOnPlayerStatesListener.onPlayerStates(ConstantKeys.PlayerStatesType.BACK_CLICK);
-                }else {
-                    VideoLogUtils.d("返回键逻辑，如果是全屏，则先退出全屏；如果是小窗口，则退出小窗口；如果两种情况都不是，执行逻辑交给使用者自己实现");
-                }
-            }
-        } else if (v == mRestartPause) {
-            if(PlayerUtils.isConnected(mContext)){
-                //重新播放或者暂停
-                if (mVideoPlayer.isPlaying() || mVideoPlayer.isBufferingPlaying()) {
-                    mVideoPlayer.pause();
-                    if (mOnPlayerStatesListener!=null){
-                        mOnPlayerStatesListener.onPlayerStates(ConstantKeys.PlayerStatesType.PLAYING);
-                    }
-                } else if (mVideoPlayer.isPaused() || mVideoPlayer.isBufferingPaused()) {
-                    mVideoPlayer.restart();
-                    if (mOnPlayerStatesListener!=null){
-                        mOnPlayerStatesListener.onPlayerStates(ConstantKeys.PlayerStatesType.PAUSE);
-                    }
-                }
-            }else {
-                BaseToast.showRoundRectToast("请检测是否有网络");
-            }
-        } else if (v == mFullScreen) {
-            //全屏模式，重置锁屏，设置为未选中状态
-            if (mVideoPlayer.isNormal() || mVideoPlayer.isTinyWindow()) {
-                mFlLock.setVisibility(VISIBLE);
-                mIsLock = false;
-                mIvLock.setImageResource(R.drawable.ic_player_lock_close);
-                mVideoPlayer.enterFullScreen();
-            } else if (mVideoPlayer.isFullScreen()) {
-                mFlLock.setVisibility(GONE);
-                mVideoPlayer.exitFullScreen();
-            }
-        } else if (v == mClarity) {
-            //设置清晰度
-            //隐藏top、bottom
-            setTopBottomVisible(false);
-            //显示清晰度对话框
-            mClarityDialog.show();
-        } else if (v == mRetry) {
-            //点击重试
-            if(PlayerUtils.isConnected(mContext)){
-                startPreparing();
-                //开始从此位置播放
-                mVideoPlayer.restart();
-            }else {
-                BaseToast.showRoundRectToast("请检测是否有网络");
-            }
-        } else if (v == mReplay) {
-            //重新播放
-            if(PlayerUtils.isConnected(mContext)){
-                mRetry.performClick();
-            }else {
-                BaseToast.showRoundRectToast("请检测是否有网络");
-            }
-        } else if (v == mShare) {
-            //分享
-            if(mVideoControlListener==null){
-                VideoLogUtils.d("请在初始化的时候设置分享监听事件");
-                return;
-            }
-            //点击下载
-            mVideoControlListener.onVideoControlClick(ConstantKeys.VideoControl.SHARE);
-        } else if(v == mFlLock){
-            //点击锁屏按钮，则进入锁屏模式
-            setLock(mIsLock);
-        } else if(v == mIvDownload){
-            if(mVideoControlListener==null){
-                VideoLogUtils.d("请在初始化的时候设置下载监听事件");
-                return;
-            }
-            //点击下载
-            mVideoControlListener.onVideoControlClick(ConstantKeys.VideoControl.DOWNLOAD);
-        } else if(v == mIvAudio){
-            if(mVideoControlListener==null){
-                VideoLogUtils.d("请在初始化的时候设置切换监听事件");
-                return;
-            }
-            //点击切换音频
-            mVideoControlListener.onVideoControlClick(ConstantKeys.VideoControl.AUDIO);
-        }else if(v == mIvShare){
-            if(mVideoControlListener==null){
-                VideoLogUtils.d("请在初始化的时候设置分享监听事件");
-                return;
-            }
-            //点击分享
-            mVideoControlListener.onVideoControlClick(ConstantKeys.VideoControl.SHARE);
-        }else if(v == mIvMenu){
-            if(mVideoControlListener==null){
-                VideoLogUtils.d("请在初始化的时候设置分享监听事件");
-                return;
-            }
-            //点击菜单
-            mVideoControlListener.onVideoControlClick(ConstantKeys.VideoControl.MENU);
-        }else if(v == mIvHorAudio){
-            if(mVideoControlListener==null){
-                VideoLogUtils.d("请在初始化的时候设置横向音频监听事件");
-                return;
-            }
-            //点击横向音频
-            mVideoControlListener.onVideoControlClick(ConstantKeys.VideoControl.HOR_AUDIO);
-        }else if(v == mIvHorTv){
-            if(mVideoControlListener==null){
-                VideoLogUtils.d("请在初始化的时候设置横向Tv监听事件");
-                return;
-            }
-            //点击横向TV
-            mVideoControlListener.onVideoControlClick(ConstantKeys.VideoControl.TV);
-        }  else if (v == this) {
-            if (mVideoPlayer.isFullScreen() || mVideoPlayer.isNormal()){
-                if (mVideoPlayer.isPlaying() || mVideoPlayer.isPaused()
-                        || mVideoPlayer.isBufferingPlaying() || mVideoPlayer.isBufferingPaused()) {
-                    setTopBottomVisible(!topBottomVisible);
-                }
-            }
-        }
-    }
-
-    /**
-     * 开始播放
-     */
-    private void startVideo() {
-        //开始播放
-        if (mVideoPlayer.isIdle()) {
-            mVideoPlayer.start();
-        }else if (mVideoPlayer.isPlaying() || mVideoPlayer.isBufferingPlaying()) {
-            mVideoPlayer.pause();
-        } else if (mVideoPlayer.isPaused() || mVideoPlayer.isBufferingPaused()) {
-            mVideoPlayer.restart();
-        }
-    }
-
-    /**
-     * 当电量发生变化的时候，在此方法中国你更新不同的电量状态的UI
-     *
-     * @param batterState 电量状态
-     */
-    @Override
-    public void onBatterStateChanged(@ConstantKeys.BatterMode int batterState) {
-        switch (batterState){
-            case ConstantKeys.BatterMode.BATTERY_10:
-                mBattery.setImageResource(R.drawable.battery_10);
-                break;
-            case ConstantKeys.BatterMode.BATTERY_20:
-                mBattery.setImageResource(R.drawable.battery_20);
-                break;
-            case ConstantKeys.BatterMode.BATTERY_50:
-                mBattery.setImageResource(R.drawable.battery_50);
-                break;
-            case ConstantKeys.BatterMode.BATTERY_80:
-                mBattery.setImageResource(R.drawable.battery_80);
-                break;
-            case ConstantKeys.BatterMode.BATTERY_100:
-                mBattery.setImageResource(R.drawable.battery_100);
-                break;
-            case ConstantKeys.BatterMode.BATTERY_FULL:
-                mBattery.setImageResource(R.drawable.battery_full);
-                break;
-            case ConstantKeys.BatterMode.BATTERY_CHARGING:
-                mBattery.setImageResource(R.drawable.battery_charging);
-                break;
-            default:
-                break;
-        }
-    }
-
-
-    /**
-     * 设置top、bottom的显示和隐藏
-     * @param visible                   true显示，false隐藏.
-     */
-    private void setTopBottomVisible(boolean visible) {
-        setCenterVisible(visible);
-        mTop.setVisibility(visible ? View.VISIBLE : View.GONE);
-        mBottom.setVisibility(visible ? View.VISIBLE : View.GONE);
-        mLine.setVisibility(visible ? View.GONE : View.VISIBLE);
-        topBottomVisible = visible;
-        if (visible) {
-            if (!mVideoPlayer.isPaused() && !mVideoPlayer.isBufferingPaused()) {
-                startDismissTopBottomTimer();
-            }
-        } else {
-            cancelDismissTopBottomTimer();
-        }
-    }
-
-    /**
-     * 设置center的显示和隐藏
-     * @param visible                   true显示，false隐藏.
-     */
-    private void setCenterVisible(boolean visible){
-        mCenterStart.setVisibility(visible ? View.VISIBLE : View.GONE);
-    }
-
-
-    /**
-     * 开启top、bottom自动消失的timer
-     * 比如，视频常用功能，当用户5秒不操作后，自动隐藏头部和顶部
-     */
-    private void startDismissTopBottomTimer() {
-        if(time==0){
-            time = 8000;
-        }
-        cancelDismissTopBottomTimer();
-        if (mDismissTopBottomCountDownTimer == null) {
-            //CountDownTimer定时器
-            mDismissTopBottomCountDownTimer = new CountDownTimer(time, time) {
-                @Override
-                public void onTick(long millisUntilFinished) {
-
-                }
-
-                @Override
-                public void onFinish() {
-                    setTopBottomVisible(false);
-                }
-            };
-        }
-        mDismissTopBottomCountDownTimer.start();
-    }
-
-
-    /**
-     * 取消top、bottom自动消失的timer
-     */
-    private void cancelDismissTopBottomTimer() {
-        if (mDismissTopBottomCountDownTimer != null) {
-            mDismissTopBottomCountDownTimer.cancel();
-        }
-    }
-
-    /**
-     * 设置锁屏模式，默认是未锁屏的
-     * 当为true时，则锁屏；否则为未锁屏
-     * @param isLock            是否锁屏
-     */
-    private void setLock(boolean isLock){
-        if(isLock){
-            mIsLock = false;
-            mIvLock.setImageResource(R.drawable.ic_player_lock_open);
-        }else {
-            mIsLock = true;
-            mIvLock.setImageResource(R.drawable.ic_player_lock_close);
-        }
-        /*
-         * 设置锁屏时的布局
-         * 1.横屏全屏时显示，其他不展示；
-         * 2.锁屏时隐藏控制面板除锁屏按钮外其他所有控件
-         * 3.当从全屏切换到正常或者小窗口时，则默认不锁屏
-         */
-        setTopBottomVisible(!mIsLock);
-    }
-
-    /**
-     * 更新进度，包括更新网络加载速度
-     */
-    @SuppressLint("SetTextI18n")
-    @Override
-    public void updateNetSpeedProgress() {
-        //获取网络加载速度
-        long tcpSpeed = mVideoPlayer.getTcpSpeed();
-        VideoLogUtils.i("获取网络加载速度++++++++"+tcpSpeed);
-        if (tcpSpeed>0){
-            int speed = (int) (tcpSpeed/1024);
-            //显示网速
-            mLoading.setVisibility(View.VISIBLE);
-            mLoadText.setText("网速"+speed+"kb");
-        }
-    }
-
-
-    /**
-     * 更新播放进度
-     */
-    @Override
-    public void updateProgress() {
-        //获取当前播放的位置，毫秒
-        long position = mVideoPlayer.getCurrentPosition();
-        //获取办法给总时长，毫秒
-        long duration = mVideoPlayer.getDuration();
-        //获取视频缓冲百分比
-        int bufferPercentage = mVideoPlayer.getBufferPercentage();
-        mSeek.setSecondaryProgress(bufferPercentage);
-        int progress = (int) (100f * position / duration);
-        mSeek.setProgress(progress);
-        mPbPlayBar.setProgress(progress);
-        mPosition.setText(PlayerUtils.formatTime(position));
-        mDuration.setText(PlayerUtils.formatTime(duration));
-        // 更新时间
-        mTime.setText(new SimpleDateFormat("HH:mm", Locale.CHINA).format(new Date()));
-
-        long tcpSpeed = mVideoPlayer.getTcpSpeed();
-        VideoLogUtils.i("获取网络加载速度---------"+tcpSpeed);
-    }
-
-
-    /**
-     * 显示视频播放位置
-     * @param duration            视频总时长ms
-     * @param newPositionProgress 新的位置进度，取值0到100。
-     */
-    @Override
-    public void showChangePosition(long duration, int newPositionProgress) {
-        mChangePosition.setVisibility(View.VISIBLE);
-        long newPosition = (long) (duration * newPositionProgress / 100f);
-        mChangePositionCurrent.setText(PlayerUtils.formatTime(newPosition));
-        mChangePositionProgress.setProgress(newPositionProgress);
-        mSeek.setProgress(newPositionProgress);
-        mPbPlayBar.setProgress(newPositionProgress);
-        mPosition.setText(PlayerUtils.formatTime(newPosition));
-    }
-
-
-    /**
-     * 隐藏视频播放位置
-     */
-    @Override
-    public void hideChangePosition() {
-        //隐藏
-        mChangePosition.setVisibility(View.GONE);
-    }
-
-
-    /**
-     * 展示视频播放音量
-     * @param newVolumeProgress 新的音量进度，取值1到100。
-     */
-    @Override
-    public void showChangeVolume(int newVolumeProgress) {
-        mChangeVolume.setVisibility(View.VISIBLE);
-        mChangeVolumeProgress.setProgress(newVolumeProgress);
-    }
-
-
-    /**
-     * 隐藏视频播放音量
-     */
-    @Override
-    public void hideChangeVolume() {
-        mChangeVolume.setVisibility(View.GONE);
-    }
-
-
-    /**
-     * 展示视频播放亮度
-     * @param newBrightnessProgress 新的亮度进度，取值1到100。
-     */
-    @Override
-    public void showChangeBrightness(int newBrightnessProgress) {
-        mChangeBrightness.setVisibility(View.VISIBLE);
-        mChangeBrightnessProgress.setProgress(newBrightnessProgress);
-    }
-
-
-    /**
-     * 隐藏视频播放亮度
-     */
-    @Override
-    public void hideChangeBrightness() {
-        mChangeBrightness.setVisibility(View.GONE);
-    }
-
-
-    /**
-     * 设置视频分享，下载，音视频转化点击事件
-     */
-    private OnVideoControlListener mVideoControlListener;
-    public void setOnVideoControlListener(OnVideoControlListener listener){
-        this.mVideoControlListener = listener;
-    }
-
-    /**
-     * 视频播放模式监听
-     */
-    private OnPlayerTypeListener mOnPlayerTypeListener;
-    public void setOnPlayerTypeListener(OnPlayerTypeListener listener){
-        this.mOnPlayerTypeListener = listener;
-    }
-
-    /**
-     * 视频播放状态
-     */
-    private OnPlayerStatesListener mOnPlayerStatesListener;
-    public void setOnPlayerStatesListener(OnPlayerStatesListener onPlayerStatesListener) {
-        this.mOnPlayerStatesListener = onPlayerStatesListener;
-    }
-}

VideoPlayer/src/main/java/com/yc/video/old/dialog/ChangeClarityDialog.java

@@ -1,137 +0,0 @@
-/*
-Copyright 2017 yangchong211（github.com/yangchong211）
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-package com.yc.video.old.dialog;
-
-import android.app.Dialog;
-import android.content.Context;
-import android.view.Gravity;
-import android.view.LayoutInflater;
-import android.view.View;
-import android.view.ViewGroup;
-import android.view.WindowManager;
-import android.widget.LinearLayout;
-import android.widget.TextView;
-
-import com.yc.video.tool.PlayerUtils;
-
-import com.yc.video.R;
-import com.yc.video.old.listener.OnClarityChangedListener;
-
-import java.util.List;
-
-
-/**
- * <pre>
- *     @author yangchong
- *     blog  : https://github.com/yangchong211
- *     time  : 2018/1/29
- *     desc  : 切换清晰度对话框（仿腾讯视频切换清晰度的对话框）
- *     revise:
- * </pre>
- */
-@Deprecated
-public class ChangeClarityDialog extends Dialog {
-
-    private LinearLayout mLinearLayout;
-    private int mCurrentCheckedIndex;
-
-    public ChangeClarityDialog(Context context) {
-        super(context, R.style.dialog_change_clarity);
-        init(context);
-    }
-
-
-    @Override
-    public void onBackPressed() {
-        // 按返回键时回调清晰度没有变化
-        if (mListener != null) {
-            mListener.onClarityNotChanged();
-        }
-        super.onBackPressed();
-    }
-
-
-    private void init(Context context) {
-        mLinearLayout = new LinearLayout(context);
-        mLinearLayout.setGravity(Gravity.CENTER);
-        mLinearLayout.setOrientation(LinearLayout.VERTICAL);
-        mLinearLayout.setOnClickListener(new View.OnClickListener() {
-            @Override
-            public void onClick(View v) {
-                if (mListener != null) {
-                    mListener.onClarityNotChanged();
-                }
-                ChangeClarityDialog.this.dismiss();
-            }
-        });
-        ViewGroup.LayoutParams params = new ViewGroup.LayoutParams(
-                ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.MarginLayoutParams.MATCH_PARENT);
-        setContentView(mLinearLayout, params);
-        //注意，这里一定要判空
-        if(getWindow()!=null){
-            WindowManager.LayoutParams windowParams = getWindow().getAttributes();
-            windowParams.width = PlayerUtils.getScreenHeight(context);
-            windowParams.height = PlayerUtils.getScreenWidth(context);
-            getWindow().setAttributes(windowParams);
-        }
-    }
-
-
-    /**
-     * 设置清晰度等级
-     * @param items          清晰度等级items
-     * @param defaultChecked 默认选中的清晰度索引
-     */
-    public void setClarityGrade(List<String> items, int defaultChecked) {
-        mCurrentCheckedIndex = defaultChecked;
-        for (int i = 0; i < items.size(); i++) {
-            TextView itemView = (TextView) LayoutInflater.from(getContext())
-                    .inflate(R.layout.old_video_clarity, mLinearLayout, false);
-            itemView.setTag(i);
-            itemView.setOnClickListener(new View.OnClickListener() {
-                @Override
-                public void onClick(View v) {
-                    if (mListener != null) {
-                        int checkIndex = (int) v.getTag();
-                        if (checkIndex != mCurrentCheckedIndex) {
-                            for (int j = 0; j < mLinearLayout.getChildCount(); j++) {
-                                mLinearLayout.getChildAt(j).setSelected(checkIndex == j);
-                            }
-                            mListener.onClarityChanged(checkIndex);
-                            mCurrentCheckedIndex = checkIndex;
-                        } else {
-                            mListener.onClarityNotChanged();
-                        }
-                    }
-                    ChangeClarityDialog.this.dismiss();
-                }
-            });
-            itemView.setText(items.get(i));
-            itemView.setSelected(i == defaultChecked);
-            ViewGroup.MarginLayoutParams params = (ViewGroup.MarginLayoutParams)
-                    itemView.getLayoutParams();
-            params.topMargin = (i == 0) ? 0 : PlayerUtils.dp2px(getContext(), 16f);
-            mLinearLayout.addView(itemView, params);
-        }
-    }
-
-
-    private OnClarityChangedListener mListener;
-    public void setOnClarityCheckedListener(OnClarityChangedListener listener) {
-        mListener = listener;
-    }
-
-}

VideoPlayer/src/main/java/com/yc/video/old/listener/OnClarityChangedListener.java

@@ -1,43 +0,0 @@
-/*
-Copyright 2017 yangchong211（github.com/yangchong211）
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-package com.yc.video.old.listener;
-
-
-/**
- * <pre>
- *     @author yangchong
- *     blog  : https://github.com/yangchong211
- *     time  : 2017/11/21
- *     desc  : 清晰度监听接口
- *     revise:
- * </pre>
- */
-@Deprecated
-public interface OnClarityChangedListener {
-
-    /**
-     * 切换清晰度后回调
-     *
-     * @param clarityIndex 切换到的清晰度的索引值
-     */
-    void onClarityChanged(int clarityIndex);
-
-    /**
-     * 清晰度没有切换，比如点击了空白位置，或者点击的是之前的清晰度
-     */
-    void onClarityNotChanged();
-    
-}

VideoPlayer/src/main/java/com/yc/video/old/listener/OnPlayerStatesListener.java

@@ -1,27 +0,0 @@
-package com.yc.video.old.listener;
-
-import com.yc.video.config.ConstantKeys;
-
-/**
- * <pre>
- *     @author yangchong
- *     blog  : https://github.com/yangchong211
- *     time  : 2018/3/9
- *     desc  : 视频播放状态抽象接口
- *     revise:
- * </pre>
- */
-@Deprecated
-public interface OnPlayerStatesListener {
-
-    /**
-     * 视频播放状态监听，暴露给外部开发者调用
-     * int COMPLETED = 101; 播放完成
-     * int PLAYING = 102; 正在播放
-     * int PAUSE = 103; 暂停状态
-     * int BACK_CLICK = 104; 用户点击back。当视频退出全屏或者退出小窗口后，再次点击返回键，让用户自己处理返回键事件的逻辑
-     * @param states                            状态
-     */
-    void onPlayerStates(@ConstantKeys.PlayerStatesType int states);
-
-}

VideoPlayer/src/main/java/com/yc/video/old/listener/OnPlayerTypeListener.java

@@ -1,42 +0,0 @@
-/*
-Copyright 2017 yangchong211（github.com/yangchong211）
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-package com.yc.video.old.listener;
-
-
-import com.yc.video.config.ConstantKeys;
-
-/**
- * <pre>
- *     @author yangchong
- *     blog  : https://github.com/yangchong211
- *     time  : 2018/3/9
- *     desc  : 视频播放模式监听
- *     revise:
- * </pre>
- */
-@Deprecated
-public interface OnPlayerTypeListener {
-
-    /**
-     * 视频播放模式监听
-     * int FULL_SCREEN = 101; 切换到全屏播放监听
-     * int TINY_WINDOW = 102; 切换到小窗口播放监听
-     * int NORMAL = 103; 切换到正常播放监听
-     * @param type                              类型
-     */
-    void onPlayerPattern(@ConstantKeys.PlayMode int type);
-
-}

VideoPlayer/src/main/java/com/yc/video/old/listener/OnVideoControlListener.java

@@ -1,48 +0,0 @@
-/*
-Copyright 2017 yangchong211（github.com/yangchong211）
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-package com.yc.video.old.listener;
-
-
-import com.yc.video.config.ConstantKeys;
-
-/**
- * <pre>
- *     @author yangchong
- *     blog  : https://github.com/yangchong211
- *     time  : 2017/11/9
- *     desc  : 视频顶部点击事件
- *     revise:
- * </pre>
- */
-@Deprecated
-public interface OnVideoControlListener {
-
-    /**
-     * 视频顶部点击事件【下载，切换音频，分享等】
-     * @param type      类型
-     *                  在竖屏模式下
-     *                  1.DOWNLOAD，下载
-     *                  2.AUDIO，切换音频
-     *                  3.SHARE，分享
-     *                  4.MENU，菜单
-     *
-     *                  在横屏模式下
-     *                  5.TV，tv映射
-     *                  6.HOR_AUDIO，音频
-     */
-    void onVideoControlClick(@ConstantKeys.VideoControlType int type);
-    
-}

VideoPlayer/src/main/java/com/yc/video/old/other/BatterReceiver.java

@@ -1,82 +0,0 @@
-/*
-Copyright 2017 yangchong211（github.com/yangchong211）
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package com.yc.video.old.other;
-
-import android.content.BroadcastReceiver;
-import android.content.Context;
-import android.content.Intent;
-import android.os.BatteryManager;
-
-import com.yc.video.config.ConstantKeys;
-import com.yc.video.old.controller.AbsVideoPlayerController;
-import com.yc.video.old.player.OldVideoPlayer;
-
-import com.yc.videotool.VideoLogUtils;
-
-/**
- * <pre>
- *     @author yangchong
- *     blog  : https://github.com/yangchong211
- *     time  : 2017/9/17
- *     desc  : 电量状态监听广播
- *     revise:
- * </pre>
- */
-@Deprecated
-public class BatterReceiver extends BroadcastReceiver {
-
-    @Override
-    public void onReceive(Context context, Intent intent) {
-        VideoLogUtils.i("电量状态监听广播接收到数据了");
-        int status = intent.getIntExtra(BatteryManager.EXTRA_STATUS,
-                BatteryManager.BATTERY_STATUS_UNKNOWN);
-        OldVideoPlayer mVideoPlayer = VideoPlayerManager.instance().getCurrentVideoPlayer();
-        if (mVideoPlayer!=null){
-            AbsVideoPlayerController controller = mVideoPlayer.getController();
-            if (controller!=null){
-                if (status == BatteryManager.BATTERY_STATUS_CHARGING) {
-                    // 充电中
-                    controller.onBatterStateChanged(ConstantKeys.BatterMode.BATTERY_CHARGING);
-                } else if (status == BatteryManager.BATTERY_STATUS_FULL) {
-                    // 充电完成
-                    controller.onBatterStateChanged(ConstantKeys.BatterMode.BATTERY_FULL);
-                } else {
-                    // 当前电量
-                    int level = intent.getIntExtra(BatteryManager.EXTRA_LEVEL, 0);
-                    // 总电量
-                    int scale = intent.getIntExtra(BatteryManager.EXTRA_SCALE, 0);
-                    int percentage = (int) (((float) level / scale) * 100);
-                    VideoLogUtils.i("广播NetworkReceiver------当前电量"+level);
-                    VideoLogUtils.i("广播NetworkReceiver------总电量"+scale);
-                    VideoLogUtils.i("广播NetworkReceiver------百分比"+percentage);
-                    if (percentage <= 10) {
-                        controller.onBatterStateChanged(ConstantKeys.BatterMode.BATTERY_10);
-                    } else if (percentage <= 20) {
-                        controller.onBatterStateChanged(ConstantKeys.BatterMode.BATTERY_20);
-                    } else if (percentage <= 50) {
-                        controller.onBatterStateChanged(ConstantKeys.BatterMode.BATTERY_50);
-                    } else if (percentage <= 80) {
-                        controller.onBatterStateChanged(ConstantKeys.BatterMode.BATTERY_80);
-                    } else if (percentage <= 100) {
-                        controller.onBatterStateChanged(ConstantKeys.BatterMode.BATTERY_100);
-                    }
-                }
-            }
-        }
-    }
-
-}

VideoPlayer/src/main/java/com/yc/video/old/other/NetChangedReceiver.java

@@ -1,72 +0,0 @@
-/*
-Copyright 2017 yangchong211（github.com/yangchong211）
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-package com.yc.video.old.other;
-
-import android.annotation.SuppressLint;
-import android.content.BroadcastReceiver;
-import android.content.Context;
-import android.content.Intent;
-
-import com.yc.video.config.ConstantKeys;
-import com.yc.video.old.controller.AbsVideoPlayerController;
-import com.yc.video.old.player.OldVideoPlayer;
-import com.yc.video.tool.NetworkUtils;
-
-import com.yc.videotool.VideoLogUtils;
-
-/**
- * <pre>
- *     @author yangchong
- *     blog  : https://github.com/yangchong211
- *     time  : 2019/5/21
- *     desc  : 网络状态监听广播
- *     revise:
- * </pre>
- */
-@Deprecated
-public class NetChangedReceiver extends BroadcastReceiver {
-
-    @SuppressLint("UnsafeProtectedBroadcastReceiver")
-    @Override
-    public void onReceive(Context context, Intent intent) {
-        VideoLogUtils.i("网络状态监听广播接收到数据了");
-        OldVideoPlayer mVideoPlayer = VideoPlayerManager.instance().getCurrentVideoPlayer();
-        if (mVideoPlayer!=null){
-            AbsVideoPlayerController controller = mVideoPlayer.getController();
-            switch (NetworkUtils.getConnectState(context)) {
-                case MOBILE:
-                    VideoLogUtils.i("当网络状态监听前连接了移动数据");
-                    break;
-                case WIFI:
-                    VideoLogUtils.i("网络状态监听当前连接了Wifi");
-                    break;
-                case UN_CONNECTED:
-                    VideoLogUtils.i("网络状态监听当前没有网络连接");
-                    if (mVideoPlayer.isPlaying() || mVideoPlayer.isBufferingPlaying()) {
-                        VideoLogUtils.i("网络状态监听当前没有网络连接---设置暂停播放");
-                        mVideoPlayer.pause();
-                    }
-                    if (controller!=null){
-                        controller.onPlayStateChanged(ConstantKeys.CurrentState.STATE_ERROR);
-                    }
-                    break;
-                default:
-                    VideoLogUtils.i("网络状态监听其他情况");
-                    break;
-            }
-        }
-    }
-}

VideoPlayer/src/main/java/com/yc/video/old/other/VideoPlayerManager.java

@@ -1,140 +0,0 @@
-/*
-Copyright 2017 yangchong211（github.com/yangchong211）
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-package com.yc.video.old.other;
-
-
-import com.yc.video.old.player.OldVideoPlayer;
-
-
-/**
- * <pre>
- *     @author yangchong
- *     blog  : https://github.com/yangchong211
- *     time  : 2017/10/21
- *     desc  : 视频播放器管理器
- *     revise: 将类置成final
- * </pre>
- */
-@Deprecated
-public final class VideoPlayerManager {
-
-    private OldVideoPlayer mVideoPlayer;
-    /**
-     * 用volatile关键字修饰对象
-     * 为何要确保只有一个对象，为了保证任何时候有且只有一个视频播放，尤其是在列表中播放
-     */
-    private static volatile VideoPlayerManager sInstance;
-
-    /**
-     * 构造方法，避免直接new
-     */
-    private VideoPlayerManager() {
-        //避免初始化
-    }
-
-    /**
-     * 一定要使用单例模式，保证同一时刻只有一个视频在播放，其他的都是初始状态
-     * 单例模式
-     * @return          VideoPlayerManager对象
-     */
-    public static VideoPlayerManager instance() {
-        if (sInstance == null) {
-            synchronized (VideoPlayerManager.class){
-                if (sInstance == null){
-                    sInstance = new VideoPlayerManager();
-                }
-            }
-        }
-        return sInstance;
-    }
-
-
-    /**
-     * 获取对象
-     * @return          VideoPlayerManager对象
-     */
-    public OldVideoPlayer getCurrentVideoPlayer() {
-        return mVideoPlayer;
-    }
-
-
-    /**
-     * 设置VideoPlayer
-     * @param videoPlayer       VideoPlayerManager对象
-     */
-    public void setCurrentVideoPlayer(OldVideoPlayer videoPlayer) {
-        if (mVideoPlayer != videoPlayer) {
-            releaseVideoPlayer();
-            mVideoPlayer = videoPlayer;
-        }
-    }
-
-
-    /**
-     * 当视频正在播放或者正在缓冲时，调用该方法暂停视频
-     */
-    public void suspendVideoPlayer() {
-        if (mVideoPlayer != null) {
-            if (mVideoPlayer.isPlaying() || mVideoPlayer.isBufferingPlaying()){
-                mVideoPlayer.pause();
-            }
-        }
-    }
-
-
-    /**
-     * 当视频暂停时或者缓冲暂停时，调用该方法重新开启视频播放
-     */
-    public void resumeVideoPlayer() {
-        if (mVideoPlayer != null) {
-            if (mVideoPlayer.isPaused() || mVideoPlayer.isBufferingPaused()){
-                mVideoPlayer.restart();
-            }
-        }
-    }
-
-
-    /**
-     * 释放，内部的播放器被释放掉，同时如果在全屏、小窗口模式下都会退出
-     */
-    public void releaseVideoPlayer() {
-        if (mVideoPlayer != null) {
-            mVideoPlayer.release();
-            mVideoPlayer = null;
-        }
-    }
-
-
-    /**
-     * 处理返回键逻辑
-     * 如果是全屏，则退出全屏
-     * 如果是小窗口，则退出小窗口
-     */
-    public boolean onBackPressed() {
-        if (mVideoPlayer != null) {
-            //如果是全屏幕，则退出全屏
-            if (mVideoPlayer.isFullScreen()) {
-                return mVideoPlayer.exitFullScreen();
-            } else if (mVideoPlayer.isTinyWindow()) {
-                //如果是小窗口播放，则退出小窗口
-                return mVideoPlayer.exitTinyWindow();
-            }
-        }
-        return false;
-    }
-
-
-}

VideoPlayer/src/main/java/com/yc/video/old/player/IVideoPlayer.java

@@ -1,220 +0,0 @@
-/*
-Copyright 2017 yangchong211（github.com/yangchong211）
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-package com.yc.video.old.player;
-
-import java.util.Map;
-
-/**
- * <pre>
- *     @author yangchong
- *     blog  : https://github.com/yangchong211
- *     time  : 2017/11/21
- *     desc  : VideoPlayer抽象接口
- *     revise: 播放器基础属性获取和设置属性接口
- * </pre>
- */
-@Deprecated
-public interface IVideoPlayer {
-
-    /**
-     * 设置视频Url，以及headers
-     *
-     * @param url           视频地址，可以是本地，也可以是网络视频
-     * @param headers       请求header.
-     */
-    void setUp(String url, Map<String, String> headers);
-
-    /**
-     * 开始播放
-     */
-    void start();
-
-    /**
-     * 从指定的位置开始播放
-     *
-     * @param position      播放位置
-     */
-    void start(long position);
-
-    /**
-     * 重新播放，播放器被暂停、播放错误、播放完成后，需要调用此方法重新播放
-     */
-    void restart();
-
-    /**
-     * 暂停播放
-     */
-    void pause();
-
-    /**------------------以下9个方法是播放器在当前的播放状态----------------------------*/
-    boolean isIdle();
-    boolean isPreparing();
-    boolean isPrepared();
-    boolean isBufferingPlaying();
-    boolean isBufferingPaused();
-    boolean isPlaying();
-    boolean isPaused();
-    boolean isError();
-    boolean isCompleted();
-
-    /**
-     * seek到制定的位置继续播放
-     *
-     * @param pos 播放位置
-     */
-    void seekTo(long pos);
-
-    /**
-     * 设置音量
-     *
-     * @param volume 音量值
-     */
-    void setVolume(int volume);
-
-    /**
-     * 设置播放速度，目前只有IjkPlayer有效果，原生MediaPlayer暂不支持
-     *
-     * @param speed 播放速度
-     */
-    void setSpeed(float speed);
-
-    /**
-     * 开始播放时，是否从上一次的位置继续播放
-     *
-     * @param continueFromLastPosition true 接着上次的位置继续播放，false从头开始播放
-     */
-    void continueFromLastPosition(boolean continueFromLastPosition);
-
-    /**
-     * 获取最大音量
-     *
-     * @return 最大音量值
-     */
-    int getMaxVolume();
-
-    /**
-     * 获取当前播放状态
-     *
-     * @return  播放状态
-     */
-    int getPlayType();
-
-    /**
-     * 获取当前音量
-     *
-     * @return 当前音量值
-     */
-    int getVolume();
-
-    /**
-     * 获取办法给总时长，毫秒
-     *
-     * @return 视频总时长ms
-     */
-    long getDuration();
-
-    /**
-     * 获取当前播放的位置，毫秒
-     *
-     * @return 当前播放位置，ms
-     */
-    long getCurrentPosition();
-
-    /**
-     * 获取视频缓冲百分比
-     *
-     * @return 缓冲白百分比
-     */
-    int getBufferPercentage();
-
-    /**
-     * 获取播放速度
-     *
-     * @param speed 播放速度
-     * @return      播放速度
-     */
-    float getSpeed(float speed);
-
-    /**
-     * 获取网络加载速度
-     *
-     * @return 网络加载速度
-     */
-    long getTcpSpeed();
-
-
-    /**------------------以下3个方法是播放器的模式----------------------------*/
-    /**
-     * 是否是全屏播放
-     */
-    boolean isFullScreen();
-    /**
-     * 是否是小窗口播放
-     */
-    boolean isTinyWindow();
-    /**
-     * 是否是正常播放
-     */
-    boolean isNormal();
-
-    /**------------------以下方法是切换播放器的模式----------------------------*/
-
-    /**
-     * 进入全屏模式
-     * 这个是横屏模式
-     */
-    void enterVerticalScreenScreen();
-
-    /**
-     * 进入全屏模式
-     */
-    void enterFullScreen();
-
-    /**
-     * 退出全屏模式
-     *
-     * @return true 退出
-     */
-    boolean exitFullScreen();
-
-    /**
-     * 进入小窗口模式
-     */
-    void enterTinyWindow();
-
-    /**
-     * 退出小窗口模式
-     *
-     * @return true 退出小窗口
-     */
-    boolean exitTinyWindow();
-
-    /**------------------以下方法是销毁视频播放器资源----------------------------*/
-
-    /**
-     * 此处只释放播放器（如果要释放播放器并恢复控制器状态需要调用{@link #release()}方法）
-     * 不管是全屏、小窗口还是Normal状态下控制器的UI都不恢复初始状态
-     * 这样以便在当前播放器状态下可以方便的切换不同的清晰度的视频地址
-     */
-    void releasePlayer();
-
-    /**
-     * 释放INiceVideoPlayer，释放后，内部的播放器被释放掉，同时如果在全屏、小窗口模式下都会退出
-     * 并且控制器的UI也应该恢复到最初始的状态.
-     */
-    void release();
-
-}

VideoPlayer/src/main/java/com/yc/video/old/player/OldVideoPlayer.java

@@ -1,805 +0,0 @@
-/*
-Copyright 2017 yangchong211（github.com/yangchong211）
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-package com.yc.video.old.player;
-
-import android.content.Context;
-import android.content.pm.ActivityInfo;
-import android.graphics.Color;
-import android.media.AudioManager;
-import android.media.MediaPlayer;
-import androidx.annotation.NonNull;
-import androidx.annotation.Nullable;
-import android.util.AttributeSet;
-import android.view.Gravity;
-import android.view.KeyEvent;
-import android.view.ViewGroup;
-import android.widget.FrameLayout;
-
-import com.yc.videotool.VideoLogUtils;
-import com.yc.video.config.ConstantKeys;
-import com.yc.video.old.controller.AbsVideoPlayerController;
-import com.yc.video.tool.BaseToast;
-import com.yc.video.tool.PlayerUtils;
-
-import com.yc.video.old.other.VideoPlayerManager;
-
-import java.util.Map;
-
-import tv.danmaku.ijk.media.player.AndroidMediaPlayer;
-import tv.danmaku.ijk.media.player.IjkMediaPlayer;
-
-
-/**
- * <pre>
- *     @author yangchong
- *     blog  : https://github.com/yangchong211
- *     time  : 2017/9/21
- *     desc  : 播放器
- *     revise: 注意：在对应的播放Activity页面，清单文件中一定要添加
- *             android:configChanges="orientation|keyboardHidden|screenSize"
- *             android:screenOrientation="portrait"
- * </pre>
- */
-@Deprecated
-public class OldVideoPlayer extends FrameLayout implements IVideoPlayer {
-
-    /**
-     * 播放类型
-     * TYPE_IJK             基于IjkPlayer封装播放器
-     * TYPE_NATIVE          基于原生自带的播放器控件
-     **/
-    public int mPlayerType = ConstantKeys.VideoPlayerType.TYPE_IJK;
-    /**
-     * 播放状态，错误，开始播放，暂停播放，缓存中等等状态
-     **/
-    private int mCurrentState = ConstantKeys.CurrentState.STATE_IDLE;
-    /**
-     * 播放模式，普通模式，小窗口模式，正常模式等等
-     * 存在局限性：比如小窗口下的正在播放模式，那么mCurrentMode就是STATE_PLAYING，而不是MODE_TINY_WINDOW并存
-     **/
-    private int mCurrentMode = ConstantKeys.PlayMode.MODE_NORMAL;
-
-
-    private Context mContext;
-    private FrameLayout mContainer;
-    private AbsVideoPlayerController mController;
-    private String mUrl;
-    private Map<String, String> mHeaders;
-    private int mBufferPercentage;
-    /**
-     * 是否从上一次位置播放，默认是false
-     */
-    private boolean continueFromLastPosition = false;
-    public long skipToPosition;
-    private VideoMediaPlayer videoMediaPlayer;
-
-    public OldVideoPlayer(Context context) {
-        this(context, null);
-    }
-
-    public OldVideoPlayer(Context context, AttributeSet attrs) {
-        this(context, attrs ,0);
-    }
-
-    public OldVideoPlayer(@NonNull Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
-        super(context, attrs, defStyleAttr);
-        mContext = context;
-        init();
-    }
-
-    /**
-     * 初始化
-     */
-    private void init() {
-        BaseToast.init(mContext.getApplicationContext());
-        mContainer = new FrameLayout(mContext);
-        //设置背景颜色，目前设置为纯黑色
-        mContainer.setBackgroundColor(Color.BLACK);
-        LayoutParams params = new LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT,
-                ViewGroup.LayoutParams.MATCH_PARENT);
-        videoMediaPlayer = new VideoMediaPlayer(this);
-        //将布局添加到该视图中
-        this.addView(mContainer, params);
-    }
-
-    /**
-     * 如果锁屏，则屏蔽返回键，这个地方设置无效，需要在activity中设置处理返回键逻辑
-     * 后期找替代方案
-     */
-    @Override
-    public boolean onKeyDown(int keyCode, KeyEvent event) {
-        VideoLogUtils.i("如果锁屏1，则屏蔽返回键onKeyDown"+event.getAction());
-        if(keyCode == KeyEvent.KEYCODE_BACK ){
-            if(mController!=null && mController.getLock()){
-                //如果锁屏，那就屏蔽返回键
-                return true;
-            }
-        }
-        return super.onKeyDown(keyCode, event);
-    }
-
-    @Override
-    protected void onAttachedToWindow() {
-        super.onAttachedToWindow();
-        VideoLogUtils.d("onAttachedToWindow");
-        //init();
-        //在构造函数初始化时addView
-    }
-
-    @Override
-    protected void onDetachedFromWindow() {
-        super.onDetachedFromWindow();
-        VideoLogUtils.d("onDetachedFromWindow");
-        if (mController!=null){
-            mController.destroy();
-        }
-        //onDetachedFromWindow方法是在Activity destroy的时候被调用的，也就是act对应的window被删除的时候，
-        //且每个view只会被调用一次，父view的调用在后，也不论view的visibility状态都会被调用，适合做最后的清理操作
-        //防止开发者没有在onDestroy中没有做销毁视频的优化
-        release();
-    }
-
-    /*--------------setUp为必须设置的方法，二选其一--------------------------------------*/
-    /**
-     * 设置，必须设置
-     * @param url               视频地址，可以是本地，也可以是网络视频
-     * @param headers           请求header.
-     */
-    @Override
-    public final void setUp(String url, Map<String, String> headers) {
-        if(url==null || url.length()==0){
-            VideoLogUtils.d("设置参数-------设置的视频链接不能为空");
-        }
-        mUrl = url;
-        mHeaders = headers;
-    }
-
-
-    /**
-     * 设置视频控制器，必须设置
-     * @param controller        AbsVideoPlayerController子类对象，可用VideoPlayerController，也可自定义
-     */
-    public void setController(@NonNull AbsVideoPlayerController controller) {
-        //这里必须先移除
-        mContainer.removeView(mController);
-        mController = controller;
-        mController.reset();
-        mController.setVideoPlayer(this);
-        LayoutParams params = new LayoutParams(
-                ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT);
-        mContainer.addView(mController, params);
-    }
-
-    public AbsVideoPlayerController getController(){
-        return mController;
-    }
-
-    public FrameLayout getContainer() {
-        return mContainer;
-    }
-
-    public String getUrl(){
-        return mUrl;
-    }
-
-    public Map<String, String> getHeaders(){
-        return mHeaders;
-    }
-
-    /**
-     * 设置播放器类型，必须设置
-     * 注意：感谢某人建议，这里限定了传入值类型
-     * 输入值：ConstantKeys.IjkPlayerType.TYPE_IJK   或者  ConstantKeys.IjkPlayerType.TYPE_NATIVE
-     * @param playerType IjkPlayer or MediaPlayer.
-     */
-    public void setPlayerType(@ConstantKeys.PlayerType int playerType) {
-        //默认是基于IjkPlayer封装播放器
-        mPlayerType = playerType;
-    }
-
-
-    /**
-     * 是否从上一次的位置继续播放，不必须
-     *
-     * @param continueFromLastPosition true从上一次的位置继续播放
-     */
-    @Override
-    public void continueFromLastPosition(boolean continueFromLastPosition) {
-        //默认是从上一次的位置继续播放
-        this.continueFromLastPosition = continueFromLastPosition;
-    }
-
-    public boolean getContinueFromLastPosition(){
-        return continueFromLastPosition;
-    }
-
-    public long getSkipToPosition() {
-        return skipToPosition;
-    }
-
-    /**
-     * 注意：MediaPlayer没有这个方法
-     * 设置播放速度，不必须
-     * @param speed                     播放速度
-     */
-    @Override
-    public void setSpeed(float speed) {
-        if (speed<0){
-            VideoLogUtils.d("设置参数-------设置的视频播放速度不能小于0");
-        }
-        if (videoMediaPlayer.getMediaPlayer() instanceof IjkMediaPlayer) {
-            ((IjkMediaPlayer) videoMediaPlayer.getMediaPlayer()).setSpeed(speed);
-        } else if (videoMediaPlayer.getMediaPlayer() instanceof AndroidMediaPlayer){
-            //((AndroidMediaPlayer) videoMediaPlayer.getMediaPlayer()).setSpeed(speed);
-            VideoLogUtils.d("设置参数-------只有IjkPlayer才能设置播放速度");
-        }else if(videoMediaPlayer.getMediaPlayer() instanceof MediaPlayer){
-            //((MediaPlayer) videoMediaPlayer.getMediaPlayer()).setSpeed(speed);
-            VideoLogUtils.d("设置参数-------只有IjkPlayer才能设置播放速度");
-        } else {
-            VideoLogUtils.d("设置参数-------只有IjkPlayer才能设置播放速度");
-        }
-    }
-
-    /**
-     * 开始播放
-     */
-    @Override
-    public void start() {
-        if (mController==null){
-            //在调用start方法前，请先初始化视频控制器，调用setController方法
-            throw new NullPointerException("Controller must not be null , please setController first");
-        }
-        if (mCurrentState == ConstantKeys.CurrentState.STATE_IDLE) {
-            VideoPlayerManager.instance().setCurrentVideoPlayer(this);
-            videoMediaPlayer.initAudioManager();
-            videoMediaPlayer.initMediaPlayer();
-            videoMediaPlayer.initTextureView();
-        } else {
-            VideoLogUtils.d("播放状态--------VideoPlayer只有在mCurrentState == STATE_IDLE时才能调用start方法.");
-        }
-    }
-
-
-    /**
-     * 开始播放
-     * @param position                 播放位置
-     */
-    @Override
-    public void start(long position) {
-        if (position<0){
-            VideoLogUtils.d("设置参数-------设置开始播放的播放位置不能小于0");
-        }
-        skipToPosition = position;
-        start();
-    }
-
-
-    /**
-     * 重新播放
-     */
-    @Override
-    public void restart() {
-        if (mCurrentState == ConstantKeys.CurrentState.STATE_PAUSED) {
-            //如果是暂停状态，那么则继续播放
-            videoMediaPlayer.getMediaPlayer().start();
-            mCurrentState = ConstantKeys.CurrentState.STATE_PLAYING;
-            mController.onPlayStateChanged(mCurrentState);
-            VideoLogUtils.d("播放状态--------STATE_PLAYING");
-        } else if (mCurrentState == ConstantKeys.CurrentState.STATE_BUFFERING_PAUSED) {
-            //如果是缓存暂停状态，那么则继续播放
-            videoMediaPlayer.getMediaPlayer().start();
-            mCurrentState = ConstantKeys.CurrentState.STATE_BUFFERING_PLAYING;
-            mController.onPlayStateChanged(mCurrentState);
-            VideoLogUtils.d("播放状态--------STATE_BUFFERING_PLAYING");
-        } else if (mCurrentState == ConstantKeys.CurrentState.STATE_COMPLETED
-                || mCurrentState == ConstantKeys.CurrentState.STATE_ERROR) {
-            //如果是完成播放或者播放错误，则重新播放
-            videoMediaPlayer.getMediaPlayer().reset();
-            videoMediaPlayer.openMediaPlayer();
-            VideoLogUtils.d("播放状态--------完成播放或者播放错误，则重新播放");
-        } else {
-            VideoLogUtils.d("VideoPlayer在mCurrentState == " + mCurrentState + "时不能调用restart()方法.");
-        }
-    }
-
-
-    /**
-     * 暂停播放
-     */
-    @Override
-    public void pause() {
-        if (mCurrentState == ConstantKeys.CurrentState.STATE_PLAYING) {
-            //如果是播放状态，那么则暂停播放
-            videoMediaPlayer.getMediaPlayer().pause();
-            mCurrentState = ConstantKeys.CurrentState.STATE_PAUSED;
-            mController.onPlayStateChanged(mCurrentState);
-            VideoLogUtils.d("播放状态--------STATE_PAUSED");
-        } else if (mCurrentState == ConstantKeys.CurrentState.STATE_BUFFERING_PLAYING) {
-            //如果是正在缓冲状态，那么则暂停暂停缓冲
-            videoMediaPlayer.getMediaPlayer().pause();
-            mCurrentState = ConstantKeys.CurrentState.STATE_BUFFERING_PAUSED;
-            mController.onPlayStateChanged(mCurrentState);
-            VideoLogUtils.d("播放状态--------STATE_BUFFERING_PAUSED");
-        }
-    }
-
-
-    /**
-     * 设置播放位置
-     * @param pos                   播放位置
-     */
-    @Override
-    public void seekTo(long pos) {
-        if (pos<0){
-            VideoLogUtils.d("设置参数-------设置开始跳转播放位置不能小于0");
-        }
-        if (videoMediaPlayer.getMediaPlayer() != null) {
-            videoMediaPlayer.getMediaPlayer().seekTo(pos);
-        }
-    }
-
-
-    /**
-     * 设置音量
-     * @param volume                音量值
-     */
-    @Override
-    public void setVolume(int volume) {
-        if (videoMediaPlayer.getAudioManager() != null) {
-            videoMediaPlayer.getAudioManager().setStreamVolume(AudioManager.STREAM_MUSIC, volume, 0);
-        }
-    }
-
-    /**
-     * 判断是否开始播放
-     * @return                      true表示播放未开始
-     */
-    @Override
-    public boolean isIdle() {
-        return mCurrentState == ConstantKeys.CurrentState.STATE_IDLE;
-    }
-
-
-    /**
-     * 判断视频是否播放准备中
-     * @return                      true表示播放准备中
-     */
-    @Override
-    public boolean isPreparing() {
-        return mCurrentState == ConstantKeys.CurrentState.STATE_PREPARING;
-    }
-
-
-    /**
-     * 判断视频是否准备就绪
-     * @return                      true表示播放准备就绪
-     */
-    @Override
-    public boolean isPrepared() {
-        return mCurrentState == ConstantKeys.CurrentState.STATE_PREPARED;
-    }
-
-
-    /**
-     * 判断视频是否正在缓冲(播放器正在播放时，缓冲区数据不足，进行缓冲，缓冲区数据足够后恢复播放)
-     * @return                      true表示正在缓冲
-     */
-    @Override
-    public boolean isBufferingPlaying() {
-        return mCurrentState == ConstantKeys.CurrentState.STATE_BUFFERING_PLAYING;
-    }
-
-
-    /**
-     * 判断是否是否缓冲暂停
-     * @return                      true表示缓冲暂停
-     */
-    @Override
-    public boolean isBufferingPaused() {
-        return mCurrentState == ConstantKeys.CurrentState.STATE_BUFFERING_PAUSED;
-    }
-
-
-    /**
-     * 判断视频是否正在播放
-     * @return                      true表示正在播放
-     */
-    @Override
-    public boolean isPlaying() {
-        return mCurrentState == ConstantKeys.CurrentState.STATE_PLAYING;
-    }
-
-
-    /**
-     * 判断视频是否暂停播放
-     * @return                      true表示暂停播放
-     */
-    @Override
-    public boolean isPaused() {
-        return mCurrentState == ConstantKeys.CurrentState.STATE_PAUSED;
-    }
-
-
-    /**
-     * 判断视频是否播放错误
-     * @return                      true表示播放错误
-     */
-    @Override
-    public boolean isError() {
-        return mCurrentState == ConstantKeys.CurrentState.STATE_ERROR;
-    }
-
-
-    /**
-     * 判断视频是否播放完成
-     * @return                      true表示播放完成
-     */
-    @Override
-    public boolean isCompleted() {
-        return mCurrentState == ConstantKeys.CurrentState.STATE_COMPLETED;
-    }
-
-
-    /**
-     * 判断视频是否播放全屏
-     * @return                      true表示播放全屏
-     */
-    @Override
-    public boolean isFullScreen() {
-        return mCurrentMode == ConstantKeys.PlayMode.MODE_FULL_SCREEN;
-    }
-
-
-    /**
-     * 判断视频是否播放小窗口
-     * @return                      true表示播放小窗口
-     */
-    @Override
-    public boolean isTinyWindow() {
-        return mCurrentMode == ConstantKeys.PlayMode.MODE_TINY_WINDOW;
-    }
-
-
-    /**
-     * 判断视频是否正常播放
-     * @return                      true表示正常播放
-     */
-    @Override
-    public boolean isNormal() {
-        return mCurrentMode == ConstantKeys.PlayMode.MODE_NORMAL;
-    }
-
-
-    /**
-     * 获取最大音量
-     * @return                  音量值
-     */
-    @Override
-    public int getMaxVolume() {
-        if (videoMediaPlayer.getAudioManager() != null) {
-            return videoMediaPlayer.getAudioManager().getStreamMaxVolume(AudioManager.STREAM_MUSIC);
-        }
-        return 0;
-    }
-
-    /**
-     * 获取当前播放状态
-     *
-     * @return  播放状态
-     */
-    @Override
-    public int getPlayType() {
-        return mCurrentMode;
-    }
-
-
-    /**
-     * 获取音量值
-     * @return                  音量值
-     */
-    @Override
-    public int getVolume() {
-        if (videoMediaPlayer.getAudioManager() != null) {
-            return videoMediaPlayer.getAudioManager().getStreamVolume(AudioManager.STREAM_MUSIC);
-        }
-        return 0;
-    }
-
-
-    /**
-     * 获取持续时长
-     * @return                  long时间值
-     */
-    @Override
-    public long getDuration() {
-        return videoMediaPlayer.getMediaPlayer() != null ? videoMediaPlayer.getMediaPlayer().getDuration() : 0;
-    }
-
-
-    /**
-     * 获取播放位置
-     * @return                  位置
-     */
-    @Override
-    public long getCurrentPosition() {
-        return videoMediaPlayer.getMediaPlayer() != null ? videoMediaPlayer.getMediaPlayer().getCurrentPosition() : 0;
-    }
-
-
-    /**
-     * 获取缓冲区百分比
-     * @return                  百分比
-     */
-    @Override
-    public int getBufferPercentage() {
-        return mBufferPercentage;
-    }
-
-    /**
-     * 设置缓冲区百分比
-     * @param bufferPercentage
-     */
-    public void setBufferPercentage(int bufferPercentage) {
-        this.mBufferPercentage = bufferPercentage;
-    }
-
-    /**
-     * 获取播放速度
-     * @param speed             播放速度
-     * @return                  速度
-     */
-    @Override
-    public float getSpeed(float speed) {
-        if (videoMediaPlayer.getMediaPlayer() instanceof IjkMediaPlayer) {
-            return ((IjkMediaPlayer) videoMediaPlayer.getMediaPlayer()).getSpeed(speed);
-        }
-        return 0;
-    }
-
-
-    /**
-     * 获取播放速度
-     * @return                  速度
-     */
-    @Override
-    public long getTcpSpeed() {
-        if (videoMediaPlayer.getMediaPlayer() instanceof IjkMediaPlayer) {
-            return ((IjkMediaPlayer) videoMediaPlayer.getMediaPlayer()).getTcpSpeed();
-        }
-        return 0;
-    }
-
-    /**
-     * 获取当前播放模式
-     * @return                  返回当前播放模式
-     */
-    public int getCurrentState(){
-        return mCurrentState;
-    }
-
-    /**
-     * 设置当前播放模式
-     * @param state             当前播放模式
-     */
-    public void setCurrentState(@ConstantKeys.CurrentState int state){
-        mCurrentState = state;
-    }
-
-
-    /**
-     * 进入全屏模式
-     * 全屏，将mContainer(内部包含mTextureView和mController)从当前容器中移除，并添加到android.R.content中.
-     * 切换横屏时需要在manifest的activity标签下添加android:configChanges="orientation|keyboardHidden|screenSize"配置，
-     * 以避免Activity重新走生命周期
-     */
-    @Override
-    public void enterFullScreen() {
-        if (mCurrentMode == ConstantKeys.PlayMode.MODE_FULL_SCREEN){
-            return;
-        }
-        // 隐藏ActionBar、状态栏，并横屏
-        PlayerUtils.hideActionBar(mContext);
-        //设置更改此页面的所需方向。如果页面当前位于前台或以其他方式影响方向
-        //则屏幕将立即更改(可能导致重新启动该页面)。否则，这将在下一次页面可见时使用。
-        PlayerUtils.scanForActivity(mContext).setRequestedOrientation(
-                ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
-        //找到contentView
-        ViewGroup contentView = PlayerUtils.scanForActivity(mContext)
-                .findViewById(android.R.id.content);
-        if (mCurrentMode == ConstantKeys.PlayMode.MODE_TINY_WINDOW) {
-            contentView.removeView(mContainer);
-        } else {
-            this.removeView(mContainer);
-        }
-        LayoutParams params = new LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT,
-                ViewGroup.LayoutParams.MATCH_PARENT);
-        contentView.addView(mContainer, params);
-        mCurrentMode = ConstantKeys.PlayMode.MODE_FULL_SCREEN;
-        mController.onPlayModeChanged(mCurrentMode);
-        VideoLogUtils.d("播放模式--------MODE_FULL_SCREEN");
-    }
-
-
-    /**
-     * 进入竖屏的全屏模式
-     */
-    @Override
-    public void enterVerticalScreenScreen() {
-        if (mCurrentMode == ConstantKeys.PlayMode.MODE_FULL_SCREEN){
-            return;
-        }
-        // 隐藏ActionBar、状态栏，并横屏
-        PlayerUtils.hideActionBar(mContext);
-        PlayerUtils.scanForActivity(mContext).
-                setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
-        ViewGroup contentView = PlayerUtils.
-                scanForActivity(mContext).findViewById(android.R.id.content);
-        if (mCurrentMode == ConstantKeys.PlayMode.MODE_TINY_WINDOW) {
-            contentView.removeView(mContainer);
-        } else {
-            this.removeView(mContainer);
-        }
-        LayoutParams params = new LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT,
-                ViewGroup.LayoutParams.MATCH_PARENT);
-        contentView.addView(mContainer, params);
-
-        mCurrentMode = ConstantKeys.PlayMode.MODE_FULL_SCREEN;
-        mController.onPlayModeChanged(mCurrentMode);
-        VideoLogUtils.d("播放模式--------MODE_FULL_SCREEN");
-    }
-
-
-    /**
-     * 退出全屏模式
-     * 退出全屏，移除mTextureView和mController，并添加到非全屏的容器中。
-     * 切换竖屏时需要在manifest的activity标签下添加
-     * android:configChanges="orientation|keyboardHidden|screenSize"配置，
-     * 以避免Activity重新走生命周期.
-     *
-     * @return true退出全屏.
-     */
-    @Override
-    public boolean exitFullScreen() {
-        if (mCurrentMode == ConstantKeys.PlayMode.MODE_FULL_SCREEN) {
-            PlayerUtils.showActionBar(mContext);
-            PlayerUtils.scanForActivity(mContext).setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
-            ViewGroup contentView = PlayerUtils.scanForActivity(mContext).findViewById(android.R.id.content);
-            //将视图移除
-            contentView.removeView(mContainer);
-            //重新添加到当前视图
-            LayoutParams params = new LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT);
-            this.addView(mContainer, params);
-            mCurrentMode = ConstantKeys.PlayMode.MODE_NORMAL;
-            mController.onPlayModeChanged(mCurrentMode);
-            VideoLogUtils.d("播放模式--------MODE_NORMAL");
-            this.setOnKeyListener(null);
-            return true;
-        }
-        return false;
-    }
-
-
-    /**
-     * 进入小窗口播放，小窗口播放的实现原理与全屏播放类似。
-     * 注意：小窗口播放视频比例是        16：9
-     */
-    @Override
-    public void enterTinyWindow() {
-        //如果是小窗口模式，则不执行下面代码
-        if (mCurrentMode == ConstantKeys.PlayMode.MODE_TINY_WINDOW) {
-            return;
-        }
-        //先移除
-        this.removeView(mContainer);
-        ViewGroup contentView = PlayerUtils.scanForActivity(mContext).findViewById(android.R.id.content);
-        // 小窗口的宽度为屏幕宽度的60%，长宽比默认为16:9，右边距、下边距为8dp。
-        LayoutParams params = new LayoutParams(
-                (int) (PlayerUtils.getScreenWidth(mContext) * 0.6f),
-                (int) (PlayerUtils.getScreenWidth(mContext) * 0.6f * 9f / 16f));
-        params.gravity = Gravity.BOTTOM | Gravity.END;
-        params.rightMargin = PlayerUtils.dp2px(mContext, 8f);
-        params.bottomMargin = PlayerUtils.dp2px(mContext, 8f);
-
-        contentView.addView(mContainer, params);
-        mCurrentMode = ConstantKeys.PlayMode.MODE_TINY_WINDOW;
-        mController.onPlayModeChanged(mCurrentMode);
-        VideoLogUtils.d("播放模式-------MODE_TINY_WINDOW");
-    }
-
-    /**
-     * 退出小窗口播放
-     */
-    @Override
-    public boolean exitTinyWindow() {
-        if (mCurrentMode == ConstantKeys.PlayMode.MODE_TINY_WINDOW) {
-            ViewGroup contentView = PlayerUtils.scanForActivity(mContext).findViewById(android.R.id.content);
-            contentView.removeView(mContainer);
-            LayoutParams params = new LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT);
-            this.addView(mContainer, params);
-            mCurrentMode = ConstantKeys.PlayMode.MODE_NORMAL;
-            mController.onPlayModeChanged(mCurrentMode);
-            VideoLogUtils.d("播放模式-------MODE_NORMAL");
-            return true;
-        }
-        return false;
-    }
-
-
-    /**
-     * 释放，内部的播放器被释放掉，同时如果在全屏、小窗口模式下都会退出
-     * 逻辑
-     * 1.先保存播放位置
-     * 2.退出全屏或小窗口，回复播放模式为正常模式
-     * 3.释放播放器
-     * 4.恢复控制器
-     * 5.gc回收
-     */
-    @Override
-    public void release() {
-        // 保存播放位置，当正在播放时，缓冲时，缓冲暂停时，暂停时
-        if (isPlaying() || isBufferingPlaying() || isBufferingPaused() || isPaused()) {
-            PlayerUtils.savePlayPosition(mContext, mUrl, getCurrentPosition());
-        } else if (isCompleted()) {
-            //如果播放完成，则保存播放位置为0，也就是初始位置
-            PlayerUtils.savePlayPosition(mContext, mUrl, 0);
-        }
-        // 退出全屏或小窗口
-        if (isFullScreen()) {
-            exitFullScreen();
-        }
-        if (isTinyWindow()) {
-            exitTinyWindow();
-        }
-        mCurrentMode = ConstantKeys.PlayMode.MODE_NORMAL;
-
-        // 释放播放器
-        releasePlayer();
-
-        // 恢复控制器
-        if (mController != null) {
-            mController.reset();
-        }
-        // gc回收
-        Runtime.getRuntime().gc();
-    }
-
-    /**
-     * 释放播放器，注意一定要判断对象是否为空，增强严谨性
-     * 这样以便在当前播放器状态下可以方便的切换不同的清晰度的视频地址
-     * 关于我的github：https://github.com/yangchong211
-     * 杨充修改：
-     *      17年12月23日，添加释放音频和TextureView
-     */
-    @Override
-    public void releasePlayer() {
-        videoMediaPlayer.setAudioManagerNull();
-        if (videoMediaPlayer.getMediaPlayer() != null) {
-            //释放视频焦点
-            videoMediaPlayer.getMediaPlayer().release();
-            videoMediaPlayer.setMediaPlayerNull();
-        }
-        if (mContainer!=null){
-            //从视图中移除TextureView
-            mContainer.removeView(videoMediaPlayer.getTextureView());
-        }
-        videoMediaPlayer.releaseSurface();
-        //如果SurfaceTexture不为null，则释放
-        videoMediaPlayer.releaseSurfaceTexture();
-        mCurrentState = ConstantKeys.CurrentState.STATE_IDLE;
-    }
-
-
-}

VideoPlayer/src/main/java/com/yc/video/old/player/VideoMediaPlayer.java

@@ -1,464 +0,0 @@
-package com.yc.video.old.player;
-
-import android.content.Context;
-import android.graphics.SurfaceTexture;
-import android.media.AudioManager;
-import android.net.Uri;
-import android.os.Build;
-import android.view.Surface;
-
-import androidx.annotation.RequiresApi;
-
-import com.yc.videotool.VideoLogUtils;
-import com.yc.video.config.ConstantKeys;
-import com.yc.video.old.surface.VideoTextureView;
-import com.yc.video.tool.BaseToast;
-import com.yc.video.tool.PlayerUtils;
-
-import java.io.IOException;
-
-import tv.danmaku.ijk.media.player.AndroidMediaPlayer;
-import tv.danmaku.ijk.media.player.IMediaPlayer;
-import tv.danmaku.ijk.media.player.IjkMediaPlayer;
-import tv.danmaku.ijk.media.player.IjkTimedText;
-
-/**
- * <pre>
- *     @author yangchong
- *     blog  : https://github.com/yangchong211
- *     time  : 2017/11/21
- *     desc  : MediaPlayer帮助累
- *     revise: 主要处理音视频player初始化操作和各种监听
- * </pre>
- */
-@Deprecated
-public class VideoMediaPlayer {
-
-    private OldVideoPlayer videoPlayer;
-    private IMediaPlayer mMediaPlayer;
-    private AudioManager mAudioManager;
-    private Surface mSurface;
-    private VideoTextureView mTextureView;
-    private SurfaceTexture mSurfaceTexture;
-
-    public VideoMediaPlayer(OldVideoPlayer videoPlayer) {
-        this.videoPlayer = videoPlayer;
-    }
-
-    /**
-     * 避免直接初始化
-     */
-    private VideoMediaPlayer(){}
-
-    /**
-     * 初始化音频管理器
-     */
-    @RequiresApi(api = Build.VERSION_CODES.FROYO)
-    public AudioManager initAudioManager() {
-        if (mAudioManager == null) {
-            mAudioManager  = (AudioManager) videoPlayer.getContext()
-                    .getSystemService(Context.AUDIO_SERVICE);
-            mAudioManager.requestAudioFocus(null, AudioManager.STREAM_MUSIC,
-                    AudioManager.AUDIOFOCUS_GAIN);
-        }
-        return mAudioManager;
-    }
-
-    public IMediaPlayer getMediaPlayer() {
-        initMediaPlayer();
-        return mMediaPlayer;
-    }
-
-    public void setMediaPlayerNull(){
-        if (mMediaPlayer!=null){
-            mMediaPlayer = null;
-        }
-    }
-
-    public AudioManager getAudioManager() {
-        initAudioManager();
-        return mAudioManager;
-    }
-
-    public void setAudioManagerNull(){
-        if (mAudioManager!=null){
-            //放弃音频焦点。使以前的焦点所有者(如果有的话)接收焦点。
-            mAudioManager.abandonAudioFocus(null);
-            //置空
-            mAudioManager = null;
-        }
-    }
-
-    public Surface getSurface() {
-        return mSurface;
-    }
-
-    /**
-     *
-     */
-    public void releaseSurface(){
-        if (mSurface != null) {
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH) {
-                mSurface.release();
-            }
-            mSurface = null;
-        }
-    }
-
-    public VideoTextureView getTextureView() {
-        return mTextureView;
-    }
-
-    /**
-     * 如果SurfaceTexture不为null，则释放
-     */
-    public void releaseSurfaceTexture(){
-        if (mSurfaceTexture != null) {
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH) {
-                mSurfaceTexture.release();
-            }
-            mSurfaceTexture = null;
-        }
-    }
-
-    /**
-     * 初始化视频管理器
-     */
-    public void initMediaPlayer() {
-        if (mMediaPlayer == null) {
-            switch (videoPlayer.mPlayerType) {
-                //AndroidMediaPlayer和IjkMediaPlayer都是实现AbstractMediaPlayer
-                //MediaPlayer
-                case ConstantKeys.VideoPlayerType.TYPE_NATIVE:
-                    mMediaPlayer = new AndroidMediaPlayer();
-                    break;
-                //IjkMediaPlayer    基于Ijk
-                case ConstantKeys.VideoPlayerType.TYPE_IJK:
-                default:
-                    mMediaPlayer = createIjkMediaPlayer();
-                    break;
-            }
-            //设置音频流类型
-            mMediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);
-        }
-    }
-
-    /**
-     * 打开MediaPlayer播放器
-     */
-    private IMediaPlayer createIjkMediaPlayer() {
-        //创建IjkMediaPlayer对象
-        mMediaPlayer = new IjkMediaPlayer();
-        int player = IjkMediaPlayer.OPT_CATEGORY_PLAYER;
-        int codec = IjkMediaPlayer.OPT_CATEGORY_CODEC;
-        int format = IjkMediaPlayer.OPT_CATEGORY_FORMAT;
-
-        //设置ijkPlayer播放器的硬件解码相关参数
-        //设置播放前的最大探测时间
-        ((IjkMediaPlayer)mMediaPlayer).setOption(format, "analyzemaxduration", 100L);
-        //设置播放前的探测时间 1,达到首屏秒开效果
-        ((IjkMediaPlayer)mMediaPlayer).setOption(format, "analyzeduration", 1L);
-        //播放前的探测Size，默认是1M, 改小一点会出画面更快
-        ((IjkMediaPlayer)mMediaPlayer).setOption(format, "probesize", 10240L);
-        //设置是否开启变调isModifyTone?0:1
-        ((IjkMediaPlayer)mMediaPlayer).setOption(player,"soundtouch",0);
-        //每处理一个packet之后刷新io上下文
-        ((IjkMediaPlayer)mMediaPlayer).setOption(format, "flush_packets", 1L);
-        //是否开启预缓冲，一般直播项目会开启，达到秒开的效果，不过带来了播放丢帧卡顿的体验
-        ((IjkMediaPlayer)mMediaPlayer).setOption(player, "packet-buffering", 0L);
-        //播放重连次数
-        ((IjkMediaPlayer)mMediaPlayer).setOption(player, "reconnect", 5);
-        //最大缓冲大小,单位kb
-        ((IjkMediaPlayer)mMediaPlayer).setOption(player, "max-buffer-size", 10240L);
-        //跳帧处理,放CPU处理较慢时，进行跳帧处理，保证播放流程，画面和声音同步
-        ((IjkMediaPlayer)mMediaPlayer).setOption(player, "framedrop", 1L);
-        //最大fps
-        ((IjkMediaPlayer)mMediaPlayer).setOption(player, "max-fps", 30L);
-        //SeekTo设置优化
-        ((IjkMediaPlayer)mMediaPlayer).setOption(player, "enable-accurate-seek", 1L);
-        ((IjkMediaPlayer)mMediaPlayer).setOption(player, "opensles", 0);
-        ((IjkMediaPlayer)mMediaPlayer).setOption(player, "overlay-format",
-                IjkMediaPlayer.SDL_FCC_RV32);
-        ((IjkMediaPlayer)mMediaPlayer).setOption(player, "framedrop", 1);
-        ((IjkMediaPlayer)mMediaPlayer).setOption(player, "start-on-prepared", 0);
-        ((IjkMediaPlayer)mMediaPlayer).setOption(format, "http-detect-range-support", 0);
-        //设置是否开启环路过滤: 0开启，画面质量高，解码开销大，48关闭，画面质量差点，解码开销小
-        ((IjkMediaPlayer)mMediaPlayer).setOption(codec, "skip_loop_filter", 48);
-
-        //jkPlayer支持硬解码和软解码。
-        //软解码时不会旋转视频角度这时需要你通过onInfo的what == IMediaPlayer.MEDIA_INFO_VIDEO_ROTATION_CHANGED去获取角度，自己旋转画面。
-        //或者开启硬解硬解码，不过硬解码容易造成黑屏无声（硬件兼容问题），下面是设置硬解码相关的代码
-        ((IjkMediaPlayer)mMediaPlayer).setOption(player, "mediacodec", 0);
-        ((IjkMediaPlayer)mMediaPlayer).setOption(player, "mediacodec-auto-rotate", 1);
-        ((IjkMediaPlayer)mMediaPlayer).setOption(player, "mediacodec-handle-resolution-change", 1);
-        return mMediaPlayer;
-    }
-
-
-    /**
-     * 打开MediaPlayer播放器
-     */
-    @RequiresApi(api = Build.VERSION_CODES.ICE_CREAM_SANDWICH)
-    public void openMediaPlayer() {
-        // 屏幕常亮，这个很重要，如果不设置，则看视频一会儿，屏幕会变暗
-        videoPlayer.getContainer().setKeepScreenOn(true);
-        // 设置监听，可以查看ijk中的IMediaPlayer源码监听事件
-        // 设置准备视频播放监听事件
-        mMediaPlayer.setOnPreparedListener(mOnPreparedListener);
-        // 设置视频播放完成监听事件
-        mMediaPlayer.setOnCompletionListener(mOnCompletionListener);
-        // 设置视频缓冲更新监听事件
-        mMediaPlayer.setOnBufferingUpdateListener(mOnBufferingUpdateListener);
-        // 设置视频seek完成监听事件
-        mMediaPlayer.setOnSeekCompleteListener(mOnSeekCompleteListener);
-        // 设置视频大小更改监听器
-        mMediaPlayer.setOnVideoSizeChangedListener(mOnVideoSizeChangedListener);
-        // 设置视频错误监听器
-        mMediaPlayer.setOnErrorListener(mOnErrorListener);
-        // 设置视频信息监听器
-        mMediaPlayer.setOnInfoListener(mOnInfoListener);
-        // 设置时间文本监听器
-        mMediaPlayer.setOnTimedTextListener(mOnTimedTextListener);
-        // 设置dataSource
-        if(videoPlayer.getUrl()==null || videoPlayer.getUrl().length()==0){
-            BaseToast.showRoundRectToast("视频链接不能为空");
-            return;
-        }
-        Uri path = Uri.parse(videoPlayer.getUrl());
-        try {
-            mMediaPlayer.setDataSource(videoPlayer.getContext().getApplicationContext(), path, videoPlayer.getHeaders());
-            if (mSurface == null) {
-                mSurface = new Surface(mSurfaceTexture);
-            }
-            // 设置surface
-            mMediaPlayer.setSurface(mSurface);
-            // 设置播放时常亮
-            mMediaPlayer.setScreenOnWhilePlaying(true);
-            // 开始加载
-            mMediaPlayer.prepareAsync();
-            // 播放准备中
-            videoPlayer.setCurrentState(ConstantKeys.CurrentState.STATE_PREPARING);
-            // 控制器，更新不同的播放状态的UI
-            videoPlayer.getController().onPlayStateChanged(videoPlayer.getCurrentState());
-            VideoLogUtils.d("STATE_PREPARING");
-        } catch (IOException e) {
-            e.printStackTrace();
-            VideoLogUtils.e("打开播放器发生错误", e);
-        }
-    }
-
-
-    /**
-     * 初始化TextureView
-     * 这个主要是用作视频的
-     */
-    @RequiresApi(api = Build.VERSION_CODES.ICE_CREAM_SANDWICH)
-    public void initTextureView() {
-        if (mTextureView == null) {
-            mTextureView = new VideoTextureView(videoPlayer.getContext());
-            mTextureView.setOnTextureListener(new VideoTextureView.OnTextureListener() {
-                @Override
-                public void onSurfaceAvailable(SurfaceTexture surface) {
-                    if (mSurfaceTexture == null) {
-                        mSurfaceTexture = surface;
-                        openMediaPlayer();
-                    } else {
-                        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
-                            mTextureView.setSurfaceTexture(mSurfaceTexture);
-                        }
-                    }
-                }
-
-                @Override
-                public void onSurfaceSizeChanged(SurfaceTexture surface, int width, int height) {
-                    VideoLogUtils.i("OnTextureListener----"+"onSurfaceSizeChanged");
-                }
-
-                @Override
-                public boolean onSurfaceDestroyed(SurfaceTexture surface) {
-                    VideoLogUtils.i("OnTextureListener----"+"onSurfaceDestroyed");
-                    return mSurfaceTexture == null;
-                }
-
-                @Override
-                public void onSurfaceUpdated(SurfaceTexture surface) {
-                    VideoLogUtils.i("OnTextureListener----"+"onSurfaceUpdated");
-                }
-            });
-        }
-        mTextureView.addTextureView(videoPlayer.getContainer(),mTextureView);
-    }
-
-
-
-    /**
-     * 设置视频播放完成监听事件
-     */
-    private IMediaPlayer.OnCompletionListener mOnCompletionListener =
-            new IMediaPlayer.OnCompletionListener() {
-                @Override
-                public void onCompletion(IMediaPlayer mp) {
-                    videoPlayer.setCurrentState(ConstantKeys.CurrentState.STATE_COMPLETED);
-                    videoPlayer.getController().onPlayStateChanged(videoPlayer.getCurrentState());
-                    VideoLogUtils.d("listener---------onCompletion ——> STATE_COMPLETED");
-                    // 清除屏幕常亮
-                    videoPlayer.getContainer().setKeepScreenOn(false);
-                }
-            };
-
-
-    /**
-     * 设置准备视频播放监听事件
-     */
-    private IMediaPlayer.OnPreparedListener mOnPreparedListener = new IMediaPlayer.OnPreparedListener() {
-        @Override
-        public void onPrepared(IMediaPlayer mp) {
-            videoPlayer.setCurrentState(ConstantKeys.CurrentState.STATE_PREPARED);
-            videoPlayer.getController().onPlayStateChanged(videoPlayer.getCurrentState());
-            VideoLogUtils.d("listener---------onPrepared ——> STATE_PREPARED");
-            mp.start();
-            // 从上次的保存位置播放
-            if (videoPlayer.getContinueFromLastPosition()) {
-                long savedPlayPosition = PlayerUtils.getSavedPlayPosition(
-                        videoPlayer.getContext(), videoPlayer.getUrl());
-                mp.seekTo(savedPlayPosition);
-            }
-            // 跳到指定位置播放
-            if (videoPlayer.getSkipToPosition() != 0) {
-                mp.seekTo(videoPlayer.getSkipToPosition());
-            }
-        }
-    };
-
-
-    /**
-     * 设置视频缓冲更新监听事件
-     */
-    private IMediaPlayer.OnBufferingUpdateListener mOnBufferingUpdateListener =
-            new IMediaPlayer.OnBufferingUpdateListener() {
-                final int MAX_PERCENT = 97;
-                @Override
-                public void onBufferingUpdate(IMediaPlayer mp, int percent) {
-                    videoPlayer.setBufferPercentage(percent);
-                    //播放完成后再次播放getBufferPercentage获取的值也不准确，94、95，达不到100
-                    if (percent>MAX_PERCENT){
-                        videoPlayer.setBufferPercentage(100);
-                    }
-                    VideoLogUtils.d("listener---------onBufferingUpdate ——> " + percent);
-                }
-            };
-
-
-
-    /**
-     * 设置视频seek完成监听事件
-     */
-    private IMediaPlayer.OnSeekCompleteListener mOnSeekCompleteListener =
-            new IMediaPlayer.OnSeekCompleteListener() {
-                @Override
-                public void onSeekComplete(IMediaPlayer iMediaPlayer) {
-
-                }
-            };
-
-
-
-    /**
-     * 设置视频大小更改监听器
-     */
-    private IMediaPlayer.OnVideoSizeChangedListener mOnVideoSizeChangedListener =
-            new IMediaPlayer.OnVideoSizeChangedListener() {
-                @Override
-                public void onVideoSizeChanged(IMediaPlayer mp, int width, int height,
-                                               int sar_num, int sar_den) {
-                    mTextureView.adaptVideoSize(width, height);
-                    VideoLogUtils.d("listener---------onVideoSizeChanged ——> WIDTH：" + width + "， HEIGHT：" + height);
-                }
-            };
-
-    /**
-     * 设置视频错误监听器
-     * int MEDIA_INFO_VIDEO_RENDERING_START = 3;//视频准备渲染
-     * int MEDIA_INFO_BUFFERING_START = 701;//开始缓冲
-     * int MEDIA_INFO_BUFFERING_END = 702;//缓冲结束
-     * int MEDIA_INFO_VIDEO_ROTATION_CHANGED = 10001;//视频选择信息
-     * int MEDIA_ERROR_SERVER_DIED = 100;//视频中断，一般是视频源异常或者不支持的视频类型。
-     * int MEDIA_ERROR_IJK_PLAYER = -10000,//一般是视频源有问题或者数据格式不支持，比如音频不是AAC之类的
-     * int MEDIA_ERROR_NOT_VALID_FOR_PROGRESSIVE_PLAYBACK = 200;//数据错误没有有效的回收
-     */
-    private IMediaPlayer.OnErrorListener mOnErrorListener = new IMediaPlayer.OnErrorListener() {
-        @Override
-        public boolean onError(IMediaPlayer mp, int what, int extra) {
-            // 直播流播放时去调用mediaPlayer.getDuration会导致-38和-2147483648错误，忽略该错误
-            if (what != -38 && what != -2147483648 && extra != -38 && extra != -2147483648) {
-                videoPlayer.setCurrentState(ConstantKeys.CurrentState.STATE_ERROR);
-                videoPlayer.getController().onPlayStateChanged(videoPlayer.getCurrentState());
-            }
-            VideoLogUtils.d("listener---------onError ——> STATE_ERROR ———— what：" + what + ", extra: " + extra);
-            return true;
-        }
-    };
-
-
-    /**
-     * 设置视频信息监听器
-     */
-    private IMediaPlayer.OnInfoListener mOnInfoListener = new IMediaPlayer.OnInfoListener() {
-        @Override
-        public boolean onInfo(IMediaPlayer mp, int what, int extra) {
-            if (what == IMediaPlayer.MEDIA_INFO_VIDEO_RENDERING_START) {
-                // 播放器开始渲染
-                videoPlayer.setCurrentState(ConstantKeys.CurrentState.STATE_PLAYING);
-                videoPlayer.getController().onPlayStateChanged(videoPlayer.getCurrentState());
-                VideoLogUtils.d("listener---------onInfo ——> MEDIA_INFO_VIDEO_RENDERING_START：STATE_PLAYING");
-            } else if (what == IMediaPlayer.MEDIA_INFO_BUFFERING_START) {
-                // MediaPlayer暂时不播放，以缓冲更多的数据
-                if (videoPlayer.getCurrentState() == ConstantKeys.CurrentState.STATE_PAUSED ||
-                        videoPlayer.getCurrentState() == ConstantKeys.CurrentState.STATE_BUFFERING_PAUSED) {
-                    videoPlayer.setCurrentState(ConstantKeys.CurrentState.STATE_BUFFERING_PAUSED);
-                    VideoLogUtils.d("listener---------onInfo ——> MEDIA_INFO_BUFFERING_START：STATE_BUFFERING_PAUSED");
-                } else {
-                    videoPlayer.setCurrentState(ConstantKeys.CurrentState.STATE_BUFFERING_PLAYING);
-                    VideoLogUtils.d("listener---------onInfo ——> MEDIA_INFO_BUFFERING_START：STATE_BUFFERING_PLAYING");
-                }
-                videoPlayer.getController().onPlayStateChanged(videoPlayer.getCurrentState());
-            } else if (what == IMediaPlayer.MEDIA_INFO_BUFFERING_END) {
-                // 填充缓冲区后，MediaPlayer恢复播放/暂停
-                if (videoPlayer.getCurrentState() == ConstantKeys.CurrentState.STATE_BUFFERING_PLAYING) {
-                    videoPlayer.setCurrentState(ConstantKeys.CurrentState.STATE_PLAYING);
-                    videoPlayer.getController().onPlayStateChanged(videoPlayer.getCurrentState());
-                    VideoLogUtils.d("listener---------onInfo ——> MEDIA_INFO_BUFFERING_END： STATE_PLAYING");
-                }
-                if (videoPlayer.getCurrentState() == ConstantKeys.CurrentState.STATE_BUFFERING_PAUSED) {
-                    videoPlayer.setCurrentState(ConstantKeys.CurrentState.STATE_PAUSED);
-                    videoPlayer.getController().onPlayStateChanged(videoPlayer.getCurrentState());
-                    VideoLogUtils.d("listener---------onInfo ——> MEDIA_INFO_BUFFERING_END： STATE_PAUSED");
-                }
-            } else if (what == IMediaPlayer.MEDIA_INFO_VIDEO_ROTATION_CHANGED) {
-                // 视频旋转了extra度，需要恢复
-                if (mTextureView != null) {
-                    mTextureView.setRotation(extra);
-                    VideoLogUtils.d("listener---------视频旋转角度：" + extra);
-                }
-            } else if (what == IMediaPlayer.MEDIA_INFO_NOT_SEEKABLE) {
-                VideoLogUtils.d("listener---------视频不能seekTo，为直播视频");
-            } else {
-                VideoLogUtils.d("listener---------onInfo ——> what：" + what);
-            }
-            return true;
-        }
-    };
-
-
-    /**
-     * 设置时间文本监听器
-     */
-    private IMediaPlayer.OnTimedTextListener mOnTimedTextListener = new
-            IMediaPlayer.OnTimedTextListener() {
-                @Override
-                public void onTimedText(IMediaPlayer iMediaPlayer, IjkTimedText ijkTimedText) {
-
-                }
-            };
-
-}

VideoPlayer/src/main/java/com/yc/video/old/surface/VideoSurfaceView.java

@@ -1,251 +0,0 @@
-/*
-Copyright 2017 yangchong211（github.com/yangchong211）
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package com.yc.video.old.surface;
-
-import android.content.Context;
-import android.view.Gravity;
-import android.view.SurfaceHolder;
-import android.view.SurfaceView;
-import android.view.ViewGroup;
-import android.widget.FrameLayout;
-
-/**
- * <pre>
- *     @author yangchong
- *     blog  : https://github.com/yangchong211
- *     time  : 2018/9/21
- *     desc  : 重写SurfaceView，适配视频的宽高和旋转
- *     revise:
- * </pre>
- */
-@Deprecated
-public class VideoSurfaceView extends SurfaceView{
-
-
-    /**
-     * 优点：可以在一个独立的线程中进行绘制，不会影响主线程；使用双缓冲机制，播放视频时画面更流畅
-     * 缺点：Surface不在View hierachy中，它的显示也不受View的属性控制，所以不能进行平移，缩放等变换，
-     *      也不能放在其它ViewGroup中。SurfaceView 不能嵌套使用。
-     */
-
-    private int videoHeight;
-    private int videoWidth;
-    private OnSurfaceListener onSurfaceListener;
-    private static final float EQUAL_FLOAT = 0.0000001f;
-
-    public VideoSurfaceView(Context context) {
-        super(context);
-    }
-
-    @Override
-    protected void onDetachedFromWindow() {
-        super.onDetachedFromWindow();
-        if (callback!=null){
-            getHolder().removeCallback(callback);
-        }
-    }
-
-    private SurfaceHolder.Callback callback = new SurfaceHolder.Callback(){
-        /**
-         * 创建的时候调用该方法
-         * @param holder                        holder
-         */
-        @Override
-        public void surfaceCreated(SurfaceHolder holder) {
-            if (onSurfaceListener!=null){
-                onSurfaceListener.surfaceCreated(holder);
-            }
-        }
-
-        /**
-         * 视图改变的时候调用方法
-         * @param holder
-         * @param format
-         * @param width
-         * @param height
-         */
-        @Override
-        public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
-            if (onSurfaceListener!=null){
-                onSurfaceListener.surfaceChanged(holder, format, width, height);
-            }
-        }
-
-        /**
-         * 销毁的时候调用该方法
-         * @param holder
-         */
-        @Override
-        public void surfaceDestroyed(SurfaceHolder holder) {
-            if (onSurfaceListener!=null){
-                onSurfaceListener.surfaceDestroyed(holder);
-            }
-        }
-    };
-
-
-    /**
-     * 获取listener
-     * @return                          onSurfaceListener
-     */
-    public OnSurfaceListener getOnSurfaceListener() {
-        return onSurfaceListener;
-    }
-
-
-    /**
-     * 设置监听
-     * @param surfaceListener           onSurfaceListener
-     */
-    public void setOnSurfaceListener(OnSurfaceListener surfaceListener) {
-        this.onSurfaceListener = surfaceListener;
-        getHolder().addCallback(callback);
-    }
-
-
-    /**
-     * 添加TextureView到视图中
-     * @param frameLayout               布局
-     * @param videoSurfaceView          videoSurfaceView
-     */
-    public void addTextureView(FrameLayout frameLayout , VideoSurfaceView videoSurfaceView){
-        frameLayout.removeView(videoSurfaceView);
-        FrameLayout.LayoutParams params = new FrameLayout.LayoutParams(
-                ViewGroup.LayoutParams.MATCH_PARENT,
-                ViewGroup.LayoutParams.MATCH_PARENT, Gravity.CENTER);
-        frameLayout.addView(videoSurfaceView, 0, params);
-    }
-
-
-    /**
-     * 自定义video大小
-     * @param videoWidth                宽
-     * @param videoHeight               高
-     */
-    public void adaptVideoSize(int videoWidth, int videoHeight) {
-        if (this.videoWidth != videoWidth && this.videoHeight != videoHeight) {
-            this.videoWidth = videoWidth;
-            this.videoHeight = videoHeight;
-            requestLayout();
-        }
-    }
-
-
-    /**
-     * 记得一定要重新写这个方法，如果角度发生了变化，就重新绘制布局
-     * 设置视频旋转角度
-     * @param rotation                  角度
-     */
-    @Override
-    public void setRotation(float rotation) {
-        if (rotation != getRotation()) {
-            super.setRotation(rotation);
-            requestLayout();
-        }
-    }
-
-
-    @Override
-    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
-        // 获取视图旋转的角度
-        float viewRotation = getRotation();
-        // 如果判断成立，则说明显示的TextureView和本身的位置是有90度的旋转的，所以需要交换宽高参数。
-        float viewRotation1 = 90f;
-        float viewRotation2 = 270f;
-        //如果是横竖屏旋转切换视图，则宽高属性互换
-        if (Math.abs(viewRotation-viewRotation1)> EQUAL_FLOAT && Math.abs(viewRotation1-viewRotation)> EQUAL_FLOAT ||
-                (Math.abs(viewRotation-viewRotation2)> EQUAL_FLOAT && Math.abs(viewRotation2-viewRotation)> EQUAL_FLOAT)){
-            int tempMeasureSpec = widthMeasureSpec;
-            //noinspection SuspiciousNameCombination
-            widthMeasureSpec = heightMeasureSpec;
-            heightMeasureSpec = tempMeasureSpec;
-        }
-        /*if (viewRotation == viewRotation1 || viewRotation == viewRotation2) {
-            int tempMeasureSpec = widthMeasureSpec;
-            //noinspection SuspiciousNameCombination
-            widthMeasureSpec = heightMeasureSpec;
-            heightMeasureSpec = tempMeasureSpec;
-        }*/
-
-        int width = getDefaultSize(videoWidth, widthMeasureSpec);
-        int height = getDefaultSize(videoHeight, heightMeasureSpec);
-        if (videoWidth > 0 && videoHeight > 0) {
-
-            int widthSpecMode = MeasureSpec.getMode(widthMeasureSpec);
-            int widthSpecSize = MeasureSpec.getSize(widthMeasureSpec);
-            int heightSpecMode = MeasureSpec.getMode(heightMeasureSpec);
-            int heightSpecSize = MeasureSpec.getSize(heightMeasureSpec);
-
-            if (widthSpecMode == MeasureSpec.EXACTLY && heightSpecMode == MeasureSpec.EXACTLY) {
-                // the size is fixed
-                width = widthSpecSize;
-                height = heightSpecSize;
-                // for compatibility, we adjust size based on aspect ratio
-                if (videoWidth * height < width * videoHeight) {
-                    width = height * videoWidth / videoHeight;
-                } else if (videoWidth * height > width * videoHeight) {
-                    height = width * videoHeight / videoWidth;
-                }
-            } else if (widthSpecMode == MeasureSpec.EXACTLY) {
-                // only the WIDTH is fixed, adjust the HEIGHT to match aspect ratio if possible
-                width = widthSpecSize;
-                height = width * videoHeight / videoWidth;
-                if (heightSpecMode == MeasureSpec.AT_MOST && height > heightSpecSize) {
-                    // couldn't match aspect ratio within the constraints
-                    height = heightSpecSize;
-                    width = height * videoWidth / videoHeight;
-                }
-            } else if (heightSpecMode == MeasureSpec.EXACTLY) {
-                // only the HEIGHT is fixed, adjust the WIDTH to match aspect ratio if possible
-                height = heightSpecSize;
-                width = height * videoWidth / videoHeight;
-                if (widthSpecMode == MeasureSpec.AT_MOST && width > widthSpecSize) {
-                    // couldn't match aspect ratio within the constraints
-                    width = widthSpecSize;
-                    height = width * videoHeight / videoWidth;
-                }
-            } else {
-                // neither the WIDTH nor the HEIGHT are fixed, try to use actual video size
-                width = videoWidth;
-                height = videoHeight;
-                if (heightSpecMode == MeasureSpec.AT_MOST && height > heightSpecSize) {
-                    // too tall, decrease both WIDTH and HEIGHT
-                    height = heightSpecSize;
-                    width = height * videoWidth / videoHeight;
-                }
-                if (widthSpecMode == MeasureSpec.AT_MOST && width > widthSpecSize) {
-                    // too wide, decrease both WIDTH and HEIGHT
-                    width = widthSpecSize;
-                    height = width * videoHeight / videoWidth;
-                }
-            }
-        } else {
-            // no size yet, just adopt the given spec sizes
-        }
-        setMeasuredDimension(width, height);
-    }
-
-    public interface OnSurfaceListener {
-
-        void surfaceCreated(SurfaceHolder holder);
-
-        void surfaceChanged(SurfaceHolder holder, int format, int width, int height);
-
-        void surfaceDestroyed(SurfaceHolder holder);
-
-    }
-}

VideoPlayer/src/main/java/com/yc/video/old/surface/VideoTextureView.java

@@ -1,281 +0,0 @@
-/*
-Copyright 2017 yangchong211（github.com/yangchong211）
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package com.yc.video.old.surface;
-
-import android.annotation.SuppressLint;
-import android.content.Context;
-import android.graphics.SurfaceTexture;
-import android.view.Gravity;
-import android.view.TextureView;
-import android.view.ViewGroup;
-import android.widget.FrameLayout;
-import com.yc.videotool.VideoLogUtils;
-
-/**
- * <pre>
- *     @author yangchong
- *     blog  : https://github.com/yangchong211
- *     time  : 2017/10/21
- *     desc  : 重写TextureView，适配视频的宽高和旋转
- *     revise:
- * </pre>
- */
-@Deprecated
-@SuppressLint("NewApi")
-public class VideoTextureView extends TextureView implements TextureView.SurfaceTextureListener {
-
-    /**
-     * 优点：支持移动、旋转、缩放等动画，支持截图。具有view的属性
-     * 缺点：必须在硬件加速的窗口中使用，占用内存比SurfaceView高，在5.0以前在主线程渲染，5.0以后有单独的渲染线程。
-     */
-
-    private int videoHeight;
-    private int videoWidth;
-    private OnTextureListener onTextureListener;
-    private static final float EQUAL_FLOAT = 0.0000001f;
-
-
-    public VideoTextureView(Context context) {
-        super(context);
-    }
-
-
-    /**
-     * SurfaceTexture准备就绪
-     * @param surface                   surface
-     * @param width                     WIDTH
-     * @param height                    HEIGHT
-     */
-    @Override
-    public void onSurfaceTextureAvailable(SurfaceTexture surface, int width, int height) {
-        if (onTextureListener != null) {
-            onTextureListener.onSurfaceAvailable(surface);
-        }
-    }
-
-
-    /**
-     * SurfaceTexture缓冲大小变化
-     * @param surface                   surface
-     * @param width                     WIDTH
-     * @param height                    HEIGHT
-     */
-    @Override
-    public void onSurfaceTextureSizeChanged(SurfaceTexture surface, int width, int height) {
-        if (onTextureListener != null) {
-            onTextureListener.onSurfaceSizeChanged(surface, width, height);
-        }
-    }
-
-
-    /**
-     * SurfaceTexture即将被销毁
-     * @param surface                   surface
-     */
-    @Override
-    public boolean onSurfaceTextureDestroyed(SurfaceTexture surface) {
-        //清空释放
-        if (onTextureListener != null) {
-            onTextureListener.onSurfaceDestroyed(surface);
-        }
-        return false;
-    }
-
-
-    /**
-     * SurfaceTexture通过updateImage更新
-     * @param surface                   surface
-     */
-    @Override
-    public void onSurfaceTextureUpdated(SurfaceTexture surface) {
-        //如果播放的是暂停全屏了
-        if (onTextureListener != null) {
-            onTextureListener.onSurfaceUpdated(surface);
-        }
-    }
-
-
-    /**
-     * 获取listener
-     * @return                          onTextureListener
-     */
-    public OnTextureListener getonTextureListener() {
-        return onTextureListener;
-    }
-
-
-    /**
-     * 设置监听
-     * @param surfaceListener           onTextureListener
-     */
-    public void setOnTextureListener(OnTextureListener surfaceListener) {
-        setSurfaceTextureListener(this);
-        onTextureListener = surfaceListener;
-    }
-
-
-    /**
-     * 添加TextureView到视图中
-     * @param frameLayout               布局
-     * @param textureView               textureView
-     */
-    public void addTextureView(FrameLayout frameLayout , VideoTextureView textureView){
-        frameLayout.removeView(textureView);
-        FrameLayout.LayoutParams params = new FrameLayout.LayoutParams(
-                ViewGroup.LayoutParams.MATCH_PARENT,
-                ViewGroup.LayoutParams.MATCH_PARENT, Gravity.CENTER);
-        frameLayout.addView(textureView, 0, params);
-    }
-
-
-    /**
-     * 自定义video大小
-     * @param videoWidth                宽
-     * @param videoHeight               高
-     */
-    public void adaptVideoSize(int videoWidth, int videoHeight) {
-        if (this.videoWidth != videoWidth && this.videoHeight != videoHeight) {
-            this.videoWidth = videoWidth;
-            this.videoHeight = videoHeight;
-            requestLayout();
-        }
-    }
-
-
-    /**
-     * 记得一定要重新写这个方法，如果角度发生了变化，就重新绘制布局
-     * 设置视频旋转角度
-     * @param rotation                  角度
-     */
-    @Override
-    public void setRotation(float rotation) {
-        if (rotation != getRotation()) {
-            super.setRotation(rotation);
-            requestLayout();
-        }
-    }
-
-
-    @Override
-    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
-        // 获取视图旋转的角度
-        float viewRotation = getRotation();
-        // 如果判断成立，则说明显示的TextureView和本身的位置是有90度的旋转的，所以需要交换宽高参数。
-        float viewRotation1 = 90f;
-        float viewRotation2 = 270f;
-        //如果是横竖屏旋转切换视图，则宽高属性互换
-        if (Math.abs(viewRotation-viewRotation1)> EQUAL_FLOAT && Math.abs(viewRotation1-viewRotation)> EQUAL_FLOAT ||
-                (Math.abs(viewRotation-viewRotation2)> EQUAL_FLOAT && Math.abs(viewRotation2-viewRotation)> EQUAL_FLOAT)){
-            int tempMeasureSpec = widthMeasureSpec;
-            //noinspection SuspiciousNameCombination
-            widthMeasureSpec = heightMeasureSpec;
-            heightMeasureSpec = tempMeasureSpec;
-            VideoLogUtils.d("TextureView---------"+"如果是横竖屏旋转切换视图，则宽高属性互换");
-        }
-        /*if (viewRotation == viewRotation1 || viewRotation == viewRotation2) {
-            int tempMeasureSpec = widthMeasureSpec;
-            //noinspection SuspiciousNameCombination
-            widthMeasureSpec = heightMeasureSpec;
-            heightMeasureSpec = tempMeasureSpec;
-        }*/
-        int width = getDefaultSize(videoWidth, widthMeasureSpec);
-        int height = getDefaultSize(videoHeight, heightMeasureSpec);
-        if (videoWidth > 0 && videoHeight > 0) {
-
-            int widthSpecMode = MeasureSpec.getMode(widthMeasureSpec);
-            int widthSpecSize = MeasureSpec.getSize(widthMeasureSpec);
-            int heightSpecMode = MeasureSpec.getMode(heightMeasureSpec);
-            int heightSpecSize = MeasureSpec.getSize(heightMeasureSpec);
-
-            if (widthSpecMode == MeasureSpec.EXACTLY && heightSpecMode == MeasureSpec.EXACTLY) {
-                // the size is fixed
-                width = widthSpecSize;
-                height = heightSpecSize;
-                // for compatibility, we adjust size based on aspect ratio
-                if (videoWidth * height < width * videoHeight) {
-                    width = height * videoWidth / videoHeight;
-                } else if (videoWidth * height > width * videoHeight) {
-                    height = width * videoHeight / videoWidth;
-                }
-            } else if (widthSpecMode == MeasureSpec.EXACTLY) {
-                // only the WIDTH is fixed, adjust the HEIGHT to match aspect ratio if possible
-                width = widthSpecSize;
-                height = width * videoHeight / videoWidth;
-                if (heightSpecMode == MeasureSpec.AT_MOST && height > heightSpecSize) {
-                    // couldn't match aspect ratio within the constraints
-                    height = heightSpecSize;
-                    width = height * videoWidth / videoHeight;
-                }
-            } else if (heightSpecMode == MeasureSpec.EXACTLY) {
-                // only the HEIGHT is fixed, adjust the WIDTH to match aspect ratio if possible
-                height = heightSpecSize;
-                width = height * videoWidth / videoHeight;
-                if (widthSpecMode == MeasureSpec.AT_MOST && width > widthSpecSize) {
-                    // couldn't match aspect ratio within the constraints
-                    width = widthSpecSize;
-                    height = width * videoHeight / videoWidth;
-                }
-            } else {
-                // neither the WIDTH nor the HEIGHT are fixed, try to use actual video size
-                width = videoWidth;
-                height = videoHeight;
-                if (heightSpecMode == MeasureSpec.AT_MOST && height > heightSpecSize) {
-                    // too tall, decrease both WIDTH and HEIGHT
-                    height = heightSpecSize;
-                    width = height * videoWidth / videoHeight;
-                }
-                if (widthSpecMode == MeasureSpec.AT_MOST && width > widthSpecSize) {
-                    // too wide, decrease both WIDTH and HEIGHT
-                    width = widthSpecSize;
-                    height = width * videoHeight / videoWidth;
-                }
-            }
-        }  // no size yet, just adopt the given spec sizes
-        setMeasuredDimension(width, height);
-    }
-
-    public interface OnTextureListener {
-
-        /**
-         * SurfaceTexture准备就绪
-         * @param surface                   surface
-         */
-        void onSurfaceAvailable(SurfaceTexture surface);
-
-        /**
-         * SurfaceTexture缓冲大小变化
-         * @param surface                   surface
-         * @param width                     WIDTH
-         * @param height                    HEIGHT
-         */
-        void onSurfaceSizeChanged(SurfaceTexture surface, int width, int height);
-
-        /**
-         * SurfaceTexture即将被销毁
-         * @param surface                   surface
-         * @return                          销毁
-         */
-        boolean onSurfaceDestroyed(SurfaceTexture surface);
-
-        /**
-         * SurfaceTexture通过updateImage更新
-         * @param surface                   surface
-         */
-        void onSurfaceUpdated(SurfaceTexture surface);
-
-    }
-}

VideoPlayer/src/main/java/com/yc/video/tool/BaseToast.java

@@ -37,6 +37,7 @@ import android.widget.TextView;
 import android.widget.Toast;
 
 import com.yc.video.R;
+import com.yc.videotool.VideoToolUtils;
 
 import java.lang.ref.SoftReference;
 import java.lang.reflect.Field;
@@ -100,7 +101,7 @@ public final class BaseToast {
     private static Toast toast;
     @SuppressLint("ShowToast")
     public static void showToast(String content) {
-        checkMainThread();
+        VideoToolUtils.checkMainThread();
         checkContext();
         if (!checkNull(mToast)) {
             mToast.get().cancel();
@@ -121,7 +122,7 @@ public final class BaseToast {
      * @param notice                        内容
      */
     public static void showRoundRectToast(CharSequence notice) {
-        checkMainThread();
+        VideoToolUtils.checkMainThread();
         checkContext();
         if (TextUtils.isEmpty(notice)){
             return;
@@ -142,7 +143,7 @@ public final class BaseToast {
 
 
     public static void showRoundRectToast(CharSequence notice,CharSequence desc) {
-        checkMainThread();
+        VideoToolUtils.checkMainThread();
         checkContext();
         if (TextUtils.isEmpty(notice)){
             return;
@@ -165,7 +166,7 @@ public final class BaseToast {
 
 
     public static void showRoundRectToast(@LayoutRes int layout) {
-        checkMainThread();
+        VideoToolUtils.checkMainThread();
         checkContext();
         if (layout==0){
             return;
@@ -305,19 +306,6 @@ public final class BaseToast {
         return false;
     }
 
-
-    public static void checkMainThread(){
-        if (!isMainThread()){
-            throw new IllegalStateException("请不要在子线程中做弹窗操作");
-        }
-    }
-
-    private static boolean isMainThread(){
-        //判断是否是主线程
-        return Looper.getMainLooper() == Looper.myLooper();
-    }
-
-
     public static int dip2px(Context context, float dpValue) {
         final float scale = context.getResources().getDisplayMetrics().density;
         return (int) (dpValue * scale + 0.5f);
@@ -327,7 +315,7 @@ public final class BaseToast {
      * <pre>
      *     @author yangchong
      *     email  : yangchong211@163.com
-     *     time  : 20120/5/6
+     *     time  : 2020/5/6
      *     desc  : 利用hook解决toast崩溃问题
      *     revise:
      * </pre>
@@ -361,7 +349,7 @@ public final class BaseToast {
 
         public static class SafelyHandler extends Handler {
 
-            private Handler impl;
+            private final Handler impl;
 
             public SafelyHandler(Handler impl) {
                 this.impl = impl;

VideoPlayer/src/main/res/layout/old_video_clarity.xml

@@ -1,10 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<TextView xmlns:android="http://schemas.android.com/apk/res/android"
-          android:layout_width="wrap_content"
-          android:layout_height="wrap_content"
-          android:layout_marginTop="0dp"
-          android:background="@drawable/select_change_clarity"
-          android:gravity="center"
-          android:text="标清 270P"
-          android:textColor="@color/select_change_clarity_color"
-          android:textSize="15sp"/>

VideoPlayer/src/main/res/layout/old_video_player.xml

@@ -1,77 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<RelativeLayout
-    xmlns:android="http://schemas.android.com/apk/res/android"
-    android:layout_width="match_parent"
-    android:layout_height="match_parent">
-
-    <!--https://github.com/yangchong211-->
-    <!--如果你觉得好，请给个star，让更多人使用，避免重复造轮子-->
-    <!--底图，主要是显示视频缩略图-->
-    <ImageView
-        android:id="@+id/image"
-        android:layout_width="match_parent"
-        android:layout_height="match_parent"
-        android:scaleType="fitXY"
-        android:visibility="visible"/>
-    <!--加载动画view-->
-    <include layout="@layout/custom_video_player_loading"/>
-    <!--改变播放位置-->
-    <include layout="@layout/custom_video_player_change_position"/>
-    <!--改变亮度-->
-    <include layout="@layout/custom_video_player_change_brightness"/>
-    <!--改变声音-->
-    <include layout="@layout/custom_video_player_change_volume"/>
-    <!--播放完成，你也可以自定义-->
-    <include layout="@layout/old_video_player_completed"/>
-    <!--播放错误-->
-    <include layout="@layout/old_video_player_error"/>
-    <!--顶部控制区-->
-    <include layout="@layout/old_video_player_top"/>
-    <!--底部控制区-->
-    <include layout="@layout/old_video_player_bottom"/>
-    <!--右下角初始显示的总时长-->
-    <TextView
-        android:id="@+id/length"
-        android:layout_width="wrap_content"
-        android:layout_height="wrap_content"
-        android:layout_alignParentBottom="true"
-        android:layout_alignParentEnd="true"
-        android:layout_marginBottom="12dp"
-        android:layout_marginEnd="8dp"
-        android:padding="4dp"
-        android:visibility="visible"
-        android:text="00:00"
-        android:textColor="@android:color/white"
-        android:textSize="12sp"
-        android:layout_alignParentRight="true"
-        android:layout_marginRight="8dp" />
-    <!--中间开始播放按钮-->
-    <ImageView
-        android:id="@+id/center_start"
-        android:layout_width="wrap_content"
-        android:layout_height="wrap_content"
-        android:layout_centerInParent="true"
-        android:src="@drawable/ic_player_center_start"
-        android:visibility="visible"/>
-    <!--锁屏布局，全屏时展示，其他隐藏-->
-    <FrameLayout
-        android:id="@+id/fl_lock"
-        android:layout_width="wrap_content"
-        android:layout_height="wrap_content"
-        android:visibility="visible"
-        android:layout_centerVertical="true"
-        android:layout_marginStart="15dp"
-        android:background="@drawable/shape_lock_bg"
-        android:layout_marginLeft="15dp">
-        <ImageView
-            android:id="@+id/iv_lock"
-            android:layout_width="wrap_content"
-            android:layout_height="wrap_content"
-            android:layout_gravity="center"
-            android:src="@drawable/selector_lock_button"/>
-    </FrameLayout>
-
-    <!--底部视频播放进度条-->
-    <include layout="@layout/old_video_player_line"/>
-
-</RelativeLayout>

VideoPlayer/src/main/res/layout/old_video_player_bottom.xml

@@ -1,73 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<LinearLayout
-    xmlns:android="http://schemas.android.com/apk/res/android"
-    android:id="@+id/bottom"
-    android:layout_width="match_parent"
-    android:layout_height="45dp"
-    android:layout_alignParentBottom="true"
-    android:background="@drawable/player_mask_bottom"
-    android:gravity="center_vertical"
-    android:paddingBottom="5dp"
-    android:paddingStart="10dp"
-    android:paddingEnd="10dp">
-
-    <ImageView
-        android:id="@+id/restart_or_pause"
-        android:layout_width="24dp"
-        android:layout_height="24dp"
-        android:src="@drawable/ic_player_start"/>
-    <TextView
-        android:id="@+id/position"
-        android:layout_width="wrap_content"
-        android:layout_height="wrap_content"
-        android:layout_marginStart="8dp"
-        android:text="00:00"
-        android:textColor="@android:color/white"
-        android:textSize="12sp"
-        android:layout_marginLeft="8dp" />
-    <TextView
-        android:layout_width="wrap_content"
-        android:layout_height="wrap_content"
-        android:text=" / "
-        android:textColor="@android:color/white"
-        android:textSize="12sp"/>
-    <TextView
-        android:id="@+id/duration"
-        android:layout_width="wrap_content"
-        android:layout_height="wrap_content"
-        android:layout_marginEnd="8dp"
-        android:text="00:00"
-        android:textColor="@android:color/white"
-        android:textSize="12sp"
-        android:layout_marginRight="8dp" />
-    <SeekBar
-        android:id="@+id/seek"
-        android:layout_width="0dp"
-        android:layout_height="wrap_content"
-        android:layout_gravity="center_vertical"
-        android:layout_weight="1"
-        android:background="@null"
-        android:max="100"
-        android:maxHeight="1.5dp"
-        android:minHeight="1.5dp"
-        android:progressDrawable="@drawable/seek_progress"
-        android:thumb="@drawable/seek_thumb"/>
-    <TextView
-        android:id="@+id/clarity"
-        android:layout_width="wrap_content"
-        android:layout_height="wrap_content"
-        android:paddingStart="1dp"
-        android:paddingEnd="4dp"
-        android:text="超清"
-        android:textColor="@android:color/white"
-        android:textSize="14sp"
-        android:visibility="gone"
-        android:paddingLeft="1dp"
-        android:paddingRight="4dp" />
-    <ImageView
-        android:id="@+id/full_screen"
-        android:layout_width="28dp"
-        android:layout_height="28dp"
-        android:src="@drawable/ic_player_open"/>
-
-</LinearLayout>

VideoPlayer/src/main/res/layout/old_video_player_completed.xml

@@ -1,35 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<LinearLayout
-    xmlns:android="http://schemas.android.com/apk/res/android"
-    android:id="@+id/completed"
-    android:layout_width="match_parent"
-    android:layout_height="match_parent"
-    android:background="#6c0b0b0b"
-    android:gravity="center"
-    android:orientation="horizontal"
-    android:visibility="visible">
-    <TextView
-        android:id="@+id/replay"
-        android:layout_width="wrap_content"
-        android:layout_height="wrap_content"
-        android:drawableStart="@drawable/ic_player_replay"
-        android:drawablePadding="4dp"
-        android:padding="8dp"
-        android:text="重新播放"
-        android:textColor="@android:color/white"
-        android:textSize="14sp"
-        android:drawableLeft="@drawable/ic_player_replay" />
-    <TextView
-        android:id="@+id/share"
-        android:layout_width="wrap_content"
-        android:layout_height="wrap_content"
-        android:layout_marginStart="50dp"
-        android:drawableStart="@drawable/ic_palyer_share"
-        android:drawablePadding="4dp"
-        android:padding="8dp"
-        android:text="分享"
-        android:textColor="@android:color/white"
-        android:textSize="14sp"
-        android:layout_marginLeft="50dp"
-        android:drawableLeft="@drawable/ic_palyer_share" />
-</LinearLayout>

VideoPlayer/src/main/res/layout/old_video_player_error.xml

@@ -1,31 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<LinearLayout
-    xmlns:android="http://schemas.android.com/apk/res/android"
-    android:id="@+id/error"
-    android:layout_width="match_parent"
-    android:layout_height="match_parent"
-    android:background="@android:color/black"
-    android:gravity="center"
-    android:orientation="vertical"
-    android:visibility="gone">
-    <TextView
-        android:id="@+id/tv_error"
-        android:layout_width="wrap_content"
-        android:layout_height="wrap_content"
-        android:text="播放错误，请重试。"
-        android:textColor="@android:color/white"
-        android:textSize="12sp"/>
-    <TextView
-        android:id="@+id/retry"
-        android:layout_width="wrap_content"
-        android:layout_height="wrap_content"
-        android:layout_marginTop="8dp"
-        android:background="@drawable/bg_retry"
-        android:paddingBottom="5dp"
-        android:paddingLeft="15dp"
-        android:paddingRight="15dp"
-        android:paddingTop="4dp"
-        android:text="点击重试"
-        android:textColor="@android:color/white"
-        android:textSize="14sp"/>
-</LinearLayout>

VideoPlayer/src/main/res/layout/old_video_player_line.xml

@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<LinearLayout
-    xmlns:android="http://schemas.android.com/apk/res/android"
-    android:id="@+id/line"
-    android:layout_width="match_parent"
-    android:layout_height="wrap_content"
-    android:layout_alignParentBottom="true">
-
-    <ProgressBar
-        android:id="@+id/pb_play_bar"
-        style="?android:attr/progressBarStyleHorizontal"
-        android:layout_width="match_parent"
-        android:layout_height="2dp"
-        android:layout_gravity="bottom"
-        android:progressDrawable="@drawable/progress_bar_style" />
-
-</LinearLayout>

VideoPlayer/src/main/res/layout/old_video_player_top.xml

@@ -1,120 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<LinearLayout
-    xmlns:android="http://schemas.android.com/apk/res/android"
-    android:id="@+id/top"
-    android:layout_width="match_parent"
-    android:layout_height="50dp"
-    android:background="@drawable/player_mask_top"
-    android:gravity="center_vertical"
-    android:paddingTop="10dp"
-    android:paddingStart="10dp"
-    android:paddingEnd="10dp">
-
-    <ImageView
-        android:id="@+id/back"
-        android:layout_width="24dp"
-        android:layout_height="24dp"
-        android:background="@drawable/ic_player_back"
-        android:visibility="visible"/>
-    <TextView
-        android:id="@+id/title"
-        android:layout_width="0dp"
-        android:layout_height="wrap_content"
-        android:layout_weight="1"
-        android:layout_marginStart="5dp"
-        android:ellipsize="end"
-        android:maxLines="1"
-        android:maxLength="10"
-        android:text="视频标题"
-        android:textColor="@android:color/white"
-        android:textSize="16sp"
-        android:layout_marginLeft="5dp" />
-
-    <!--竖屏的时候需要展现的布局，定制的-->
-    <LinearLayout
-        android:id="@+id/ll_top_other"
-        android:layout_width="wrap_content"
-        android:layout_height="wrap_content"
-        android:orientation="horizontal"
-        android:layout_marginEnd="8dp"
-        android:visibility="gone"
-        android:layout_marginRight="8dp">
-        <ImageView
-            android:id="@+id/iv_audio"
-            android:layout_width="20dp"
-            android:layout_height="20dp"
-            android:src="@drawable/ic_player_audio"/>
-        <ImageView
-            android:id="@+id/iv_download"
-            android:layout_width="20dp"
-            android:layout_height="20dp"
-            android:layout_marginStart="15dp"
-            android:src="@drawable/ic_player_dl"
-            android:layout_marginLeft="15dp" />
-        <ImageView
-            android:id="@+id/iv_share"
-            android:layout_width="20dp"
-            android:layout_height="20dp"
-            android:layout_marginStart="15dp"
-            android:src="@drawable/ic_player_share"
-            android:layout_marginLeft="15dp" />
-        <ImageView
-            android:id="@+id/iv_menu"
-            android:layout_width="20dp"
-            android:layout_height="20dp"
-            android:layout_marginStart="15dp"
-            android:src="@drawable/ic_player_menu"
-            android:layout_marginLeft="15dp" />
-    </LinearLayout>
-
-
-    <!--横屏的时候展现的布局-->
-    <LinearLayout
-        android:id="@+id/ll_horizontal"
-        android:layout_width="wrap_content"
-        android:layout_height="wrap_content"
-        android:layout_marginEnd="8dp"
-        android:visibility="gone"
-        android:orientation="horizontal"
-        android:layout_marginRight="8dp">
-
-        <ImageView
-            android:id="@+id/iv_hor_audio"
-            android:layout_width="20dp"
-            android:layout_height="20dp"
-            android:layout_marginStart="15dp"
-            android:src="@drawable/ic_player_audio"
-            android:layout_marginLeft="15dp" />
-
-        <ImageView
-            android:id="@+id/iv_hor_tv"
-            android:layout_width="20dp"
-            android:layout_height="20dp"
-            android:layout_marginStart="15dp"
-            android:src="@drawable/ic_player_tv"
-            android:layout_marginLeft="15dp" />
-
-        <LinearLayout
-            android:layout_width="wrap_content"
-            android:layout_height="wrap_content"
-            android:layout_marginStart="15dp"
-            android:orientation="vertical"
-            android:visibility="visible"
-            android:layout_marginLeft="15dp">
-            <ImageView
-                android:id="@+id/battery"
-                android:visibility="visible"
-                android:layout_width="wrap_content"
-                android:layout_height="wrap_content"
-                android:src="@drawable/battery_100"/>
-            <TextView
-                android:id="@+id/time"
-                android:layout_width="wrap_content"
-                android:layout_height="wrap_content"
-                android:text="00:00"
-                android:textColor="@android:color/white"
-                android:textSize="10sp"/>
-        </LinearLayout>
-    </LinearLayout>
-
-</LinearLayout>

VideoPlayer/src/main/res/layout/old_view_window_dialog.xml

@@ -1,13 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<com.yc.video.ui.window.MyLinearLayout
-    xmlns:android="http://schemas.android.com/apk/res/android"
-    android:id="@+id/ll_layout"
-    android:layout_width="wrap_content"
-    android:layout_height="wrap_content">
-
-    <com.yc.video.old.player.OldVideoPlayer
-        android:id="@+id/video_player"
-        android:layout_width="240dp"
-        android:layout_height="150dp"/>
-
-</com.yc.video.ui.window.MyLinearLayout>

VideoTool/build.gradle

@@ -23,6 +23,11 @@ android {
         }
     }
 
+    compileOptions {
+        sourceCompatibility 1.8
+        targetCompatibility 1.8
+    }
+
 }
 
 dependencies {

VideoTool/src/main/java/com/yc/videotool/ScheduleTask.java

@@ -22,7 +22,10 @@ public class ScheduleTask {
     private ScheduleTask() {
         this.mExecutors = Executors.newSingleThreadExecutor(new ThreadFactory() {
             public Thread newThread(@NonNull Runnable r) {
-                return new Thread(r, "ScheduleTask");
+                //创建线程
+                Thread scheduleTask = new Thread(r);
+                scheduleTask.setName("ScheduleTask");
+                return scheduleTask;
             }
         });
     }
@@ -32,13 +35,17 @@ public class ScheduleTask {
     }
 
     public void schedule(Runnable runnable) {
-        this.mExecutors.execute(runnable);
+        if (mExecutors != null){
+            this.mExecutors.execute(runnable);
+        }
     }
 
     private static class Holder {
+        // 单例模式
         private static final ScheduleTask INSTANCE = new ScheduleTask();
 
         private Holder() {
+
         }
     }
 

VideoTool/src/main/java/com/yc/videotool/VideoLogUtils.java

@@ -49,7 +49,10 @@ public final class VideoLogUtils {
      */
     public static void v(String message) {
         if(isLog){
-            Log.v(TAG, message);
+            StackTraceElement[] stackTrace = (new Throwable()).getStackTrace();
+            StackTraceElement ste = stackTrace[2];
+            String log = build(message, ste);
+            Log.v(TAG, log);
         }
     }
 
@@ -59,7 +62,10 @@ public final class VideoLogUtils {
      */
     public static void d(String message) {
         if(isLog){
-            Log.d(TAG, message);
+            StackTraceElement[] stackTrace = (new Throwable()).getStackTrace();
+            StackTraceElement ste = stackTrace[2];
+            String log = build(message, ste);
+            Log.d(TAG, log);
         }
     }
 
@@ -67,6 +73,7 @@ public final class VideoLogUtils {
      * Log.d的输出颜色是蓝色的，也就是调式级别，一般不会中止程序，一般是程序员为了调试而打印的log
      * @param message                       message
      */
+    @Deprecated
     public static void d(Object message){
         if(isLog){
             //这个方法 建议 Debug 进入不执行，因为 object 会进行字符串+拼接，产生大量内存对象。
@@ -81,9 +88,11 @@ public final class VideoLogUtils {
      */
     public static void i(String message) {
         if(isLog){
-            Log.i(TAG, message);
+            StackTraceElement[] stackTrace = (new Throwable()).getStackTrace();
+            StackTraceElement ste = stackTrace[2];
+            String log = build(message, ste);
+            Log.i(TAG, log);
         }
-
     }
 
     /**
@@ -92,14 +101,60 @@ public final class VideoLogUtils {
      */
     public static void e(String message) {
         if (isLog) {
-            Log.e(TAG, message);
+            StackTraceElement[] stackTrace = (new Throwable()).getStackTrace();
+            StackTraceElement ste = stackTrace[1];
+            String log = build(message, ste);
+            Log.e(TAG, log);
         }
     }
 
     public static void e(String message, Throwable throwable) {
         if(isLog){
-            Log.e(TAG, message, throwable);
+            StackTraceElement[] stackTrace = (new Throwable()).getStackTrace();
+            StackTraceElement ste = stackTrace[1];
+            String log = build(message, ste);
+            Log.e(TAG, log, throwable);
+        }
+    }
+
+    /**
+     * Log.w的输出为橙色, 输出大于或等于WARN日志级别的信息，也就是警告级别，一般不会中止程序，但是可能会影响程序执行结果
+     * @param message                       message
+     */
+    public static void w(String message) {
+        if (isLog) {
+            StackTraceElement[] stackTrace = (new Throwable()).getStackTrace();
+            StackTraceElement ste = stackTrace[1];
+            String log = build(message, ste);
+            Log.w(TAG, log);
+        }
+    }
+
+    private static String build(CharSequence log, StackTraceElement ste) {
+        StringBuilder buf = new StringBuilder();
+        buf.append("[").append(Thread.currentThread().getId()).append("]");
+        if (ste.isNativeMethod()) {
+            buf.append("(Native Method)");
+        } else {
+            CharSequence fileName = ste.getFileName();
+            if (fileName == null) {
+                buf.append("(Unknown Source)");
+            } else {
+                //获取代码的所在行数
+                int lineNum = ste.getLineNumber();
+                buf.append('(');
+                buf.append(fileName);
+                if (lineNum >= 0) {
+                    buf.append(':');
+                    //行数
+                    buf.append(lineNum);
+                }
+                buf.append("):");
+            }
         }
+        buf.append(log);
+        return buf.toString();
     }
 
+
 }

VideoTool/src/main/java/com/yc/videotool/VideoMd5Utils.java

@@ -15,7 +15,8 @@ import java.security.NoSuchAlgorithmException;
 public final class VideoMd5Utils {
 
 
-    private static final char hexDigits[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
+    private static final char hexDigits[] = {'0', '1', '2', '3', '4', '5', '6',
+            '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
 
     /**
      * MD5 加密

VideoTool/src/main/java/com/yc/videotool/VideoToolUtils.java

@@ -0,0 +1,25 @@
+package com.yc.videotool;
+
+import android.os.Looper;
+
+public final class VideoToolUtils {
+
+    /**
+     * 判断是否是主线程
+     * @return                      true，表示主线程
+     */
+    private static boolean isMainThread(){
+        //判断是否是主线程
+        return Looper.getMainLooper() == Looper.myLooper();
+    }
+
+    /**
+     * 检查是否在主线程，如果不是则抛出异常
+     */
+    public static void checkMainThread(){
+        if (!isMainThread()){
+            throw new IllegalStateException("请不要在子线程中做弹窗操作");
+        }
+    }
+
+}