修改了bug

README.md

@@ -36,6 +36,7 @@
 - 8.2 遇到的bug
 - 8.3 后期需要实现的功能
 - **9.关于版本更新说明**
+- 9.0 v0.0.0 写于2017年7月1日
 - 9.1 V1.0.0 更新于2017年9月4日
 - 9.2 V1.0.1 更新于2017年11月18日
 - 9.3 v1.1.0 更新于2018年1月15日
@@ -43,6 +44,7 @@
 - 9.5 v2.4.5 更新于2018年4月21日
 - 9.6 v2.4.6 更新于2018年8月2日
 - 9.7 v2.4.8 更新于2018年8月12日
+- 9.8 v2.4.9 更新于2018年8月16日
 - **10.关于参考文档说明**
 - 10.1 参考的项目
 - 10.2 参考的博客
@@ -194,7 +196,7 @@
 #### 2.1 关于gradle引用说明
 ##### 2.1.1直接引用这段代码就可以
 ```
-compile 'cn.yc:YCVideoPlayerLib:2.4.6' 
+compile 'cn.yc:YCVideoPlayerLib:2.4.9' 
 ```
 
 #### 2.2 添加布局
@@ -1008,10 +1010,11 @@ public class VideoPlayerManager {
 - 8.2.1 当视频切花时，如何避免视频不卡顿
 - 8.2.2 在fragment中，当左右滑动出另一个fragment中，视频还在播放，怎么样处理这部分逻辑
 - 8.2.3 在显示缓冲比时，网络不好或者暂停缓冲时有问题，所以暂停还没有添加该功能
-- 8.2.4 播放进度条seekbar跳动问题，有人反映不是那么顺畅
-- 8.2.5 部分华为手机播放视频有问题，在找原因
+- 8.2.4 【已经解决，30毫秒更新一次进度条，只有视频时长很短时才有这种现象】播放进度条seekBar跳动问题，有人反映不是那么顺畅
 - 8.2.6 在拖动时显示当前帧的画面图片，类似优酷那个功能，最终还是没有实现
 
+
+
 #### 8.3 后期需要实现的功能
 - 8.3.1 如果有多集视频，则添加上一集和下一集的功能
 - 8.3.2 拖动滑动条，显示帧画面
@@ -1058,8 +1061,11 @@ public class VideoPlayerManager {
 - 9.7.3 优化了播放视频中，没有网络，点击重试按钮提示用户检查网络是否异常吐司
 - 9.7.4 注册一个网络变化监听广播，在网络变更时进行对应处理，从有网切换到没有网络时，切换播放状态
 - 9.7.5 修改播放异常条件下，还有声音播放的问题
-
-
+##### 9.8 v2.4.9 更新于2018年8月16日
+- 9.8.1 通过设置注解限制部分方法传入值类型，避免用户传入值导致意外情况
+- 9.8.2 初步写了小窗口视频拖拽功能，在下一个版本上该功能
+- 9.8.3 修改了正常窗口和全屏切换时，状态栏显示的问题
+- 9.8.4 优化了播放和暂停的监听事件，将listener暴露给开发者，可以让开发者处理某些逻辑，比如暂停时弹出广告
 
 
 ### 10.关于参考文档说明

YCVideoPlayerLib/build.gradle

@@ -51,7 +51,7 @@ group = "cn.yc"
 //发布到JCenter上的项目名字，必须填写
 def libName = "YCVideoPlayerLib"
 // 版本号，下次更新是只需要更改版本号即可
-version = "2.4.8"
+version = "2.4.9"
 /**  上面配置后上传至jcenter后的编译路径是这样的： compile 'cn.yc:YCVideoPlayerLib:2.4'  **/
 
 //生成源文件

YCVideoPlayerLib/src/main/java/org/yczbj/ycvideoplayerlib/AbsVideoPlayerController.java

@@ -118,7 +118,7 @@ public abstract class AbsVideoPlayerController extends FrameLayout implements Vi
      *             目前1，是仿腾讯加载loading
      *             2，是转圈加载loading
      */
-    public abstract void setLoadingType(int type);
+    public abstract void setLoadingType(@ConstantKeys.LoadingType int type);
 
     /**
      * 设置播放的视频的标题
@@ -155,17 +155,6 @@ public abstract class AbsVideoPlayerController extends FrameLayout implements Vi
      * 当播放器的播放状态发生变化，在此方法中国你更新不同的播放状态的UI
      *
      * @param playState 播放状态：
-     *                  <ul>
-     *                  <li>{@link VideoPlayer#STATE_IDLE}</li>
-     *                  <li>{@link VideoPlayer#STATE_PREPARING}</li>
-     *                  <li>{@link VideoPlayer#STATE_PREPARED}</li>
-     *                  <li>{@link VideoPlayer#STATE_PLAYING}</li>
-     *                  <li>{@link VideoPlayer#STATE_PAUSED}</li>
-     *                  <li>{@link VideoPlayer#STATE_BUFFERING_PLAYING}</li>
-     *                  <li>{@link VideoPlayer#STATE_BUFFERING_PAUSED}</li>
-     *                  <li>{@link VideoPlayer#STATE_ERROR}</li>
-     *                  <li>{@link VideoPlayer#STATE_COMPLETED}</li>
-     *                  </ul>
      */
     protected abstract void onPlayStateChanged(int playState);
 
@@ -173,11 +162,6 @@ public abstract class AbsVideoPlayerController extends FrameLayout implements Vi
      * 当播放器的播放模式发生变化，在此方法中更新不同模式下的控制器界面。
      *
      * @param playMode 播放器的模式：
-     *                 <ul>
-     *                 <li>{@link VideoPlayer#MODE_NORMAL}</li>
-     *                 <li>{@link VideoPlayer#MODE_FULL_SCREEN}</li>
-     *                 <li>{@link VideoPlayer#MODE_TINY_WINDOW}</li>
-     *                 </ul>
      */
     protected abstract void onPlayModeChanged(int playMode);
 
@@ -266,7 +250,7 @@ public abstract class AbsVideoPlayerController extends FrameLayout implements Vi
         //boolean tinyWindow = mVideoPlayer.isTinyWindow();
         int playType = mVideoPlayer.getPlayType();
         //如果是小窗口模式，则可以拖拽。其他情况则正常处理
-        if(playType == VideoPlayer.PlayMode.MODE_TINY_WINDOW){
+        if(playType == ConstantKeys.PlayMode.MODE_TINY_WINDOW){
             return setTinyWindowTouch(v,event);
         }else {
             //处理全屏播放时，滑动处理调节声音和亮度的逻辑

YCVideoPlayerLib/src/main/java/org/yczbj/ycvideoplayerlib/ConstantKeys.java

@@ -1,5 +1,7 @@
 package org.yczbj.ycvideoplayerlib;
 
+import android.support.annotation.IntDef;
+
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 
@@ -8,26 +10,124 @@ import java.lang.annotation.RetentionPolicy;
  */
 public class ConstantKeys {
 
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface IjkPlayerType {
+        int TYPE_IJK = 111;
+        int TYPE_NATIVE = 222;
+    }
+
+    /**
+     * 通过注解限定类型
+     * TYPE_IJK                 IjkPlayer，基于IjkPlayer封装播放器
+     * TYPE_NATIVE              MediaPlayer，基于原生自带的播放器控件
+     */
+    @IntDef({IjkPlayerType.TYPE_IJK,IjkPlayerType.TYPE_NATIVE})
+    @interface PlayerType{}
+
     static final String NO_LOGIN_VIP_TEXT = "试看结束，观看全部内容请开通会员。\n已是会员/已购买可登陆观看";
     static final String NO_LOGIN_TEXT = "试看结束，观看全部内容请开通会员/购买。\n已是会员/已购买可登陆观看";
     static final String LOGIN_TEXT = "试看结束，观看全部内容请开通会员。";
     static final String NO_LOGIN = "试看结束, 登录后即可观看全部免费课程。";
 
+    /**
+     * LOGIN        需要登录情况
+     * MEMBER       普通情况，也是默认
+     */
     @Retention(RetentionPolicy.SOURCE)
     public @interface Gender {
-        int LOGIN = 1001;
-        int MEMBER = 1002;
+        int LOGIN = 1101;
+        int MEMBER = 1102;
     }
 
+    /**
+     * 控制器上的视频顶部View点击事件
+     *                  在竖屏模式下
+     *                  1.DOWNLOAD，下载
+     *                  2.AUDIO，切换音频
+     *                  3.SHARE，分享
+     *                  4.MENU，菜单
+     *
+     *                  在横屏模式下
+     *                  5.TV，点击投影到电视上
+     *                  6.HOR_AUDIO，音频
+     */
     @Retention(RetentionPolicy.SOURCE)
     public @interface VideoControl {
-        int DOWNLOAD = 1005;
-        int AUDIO = 1006;
-        int SHARE = 1007;
-        int MENU = 1008;
-        int TV = 1009;
-        int HOR_AUDIO = 1010;
+        int DOWNLOAD = 2005;
+        int AUDIO = 2006;
+        int SHARE = 2007;
+        int MENU = 2008;
+        int TV = 2009;
+        int HOR_AUDIO = 2010;
+    }
+
+    /**
+     * 播放模式
+     * -1               播放错误
+     * 0                播放未开始
+     * 1                播放准备中
+     * 2                播放准备就绪
+     * 3                正在播放
+     * 4                暂停播放
+     * 5                正在缓冲(播放器正在播放时，缓冲区数据不足，进行缓冲，缓冲区数据足够后恢复播放)
+     * 6                正在缓冲(播放器正在播放时，缓冲区数据不足，进行缓冲，此时暂停播放器，继续缓冲，缓冲区数据足够后恢复暂停
+     * 7                播放完成
+     */
+    protected @interface CurrentState{
+        int STATE_ERROR = -1;
+        int STATE_IDLE = 0;
+        int STATE_PREPARING = 1;
+        int STATE_PREPARED = 2;
+        int STATE_PLAYING = 3;
+        int STATE_PAUSED = 4;
+        int STATE_BUFFERING_PLAYING = 5;
+        int STATE_BUFFERING_PAUSED = 6;
+        int STATE_COMPLETED = 7;
+    }
+
+    /**
+     * 播放模式，普通模式，小窗口模式，正常模式三种其中一种
+     */
+    @Retention(RetentionPolicy.SOURCE)
+    protected @interface PlayMode {
+        int MODE_NORMAL = 1001;
+        int MODE_FULL_SCREEN = 1002;
+        int MODE_TINY_WINDOW = 1003;
+    }
+
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface Loading {
+        int LOADING_RING = 1;
+        int LOADING_QQ = 2;
+    }
+
+
+    /**
+     * 通过注解限定类型
+     * 加载loading的类型
+     * 1，是仿腾讯加载loading，其实是帧动画
+     * 2，是转圈加载loading，是补间动画
+     */
+    @IntDef({Loading.LOADING_RING,Loading.LOADING_QQ})
+    @interface LoadingType{}
+
+
+    @Retention(RetentionPolicy.SOURCE)
+    public  @interface TrySee {
+        int LOADING_RING = 1;
+        int LOADING_QQ = 2;
     }
 
+    /**
+     * 视频试看结束后的类型，主要用于是看结束后展示不同的布局
+     * 如果不设置该方法，那么默认视频都是可以看的，默认是0
+     * 1，试看结束，观看全部内容请开通会员/购买。已是会员/已购买可登陆观看
+     * 2，试看结束，观看全部内容请开通会员。已是会员/已购买可登陆观看
+     * 3，试看结束, 登录后即可观看全部免费课程。
+     */
+    @IntDef({Loading.LOADING_RING,Loading.LOADING_QQ})
+    @interface TrySeeType{}
 
 }

YCVideoPlayerLib/src/main/java/org/yczbj/ycvideoplayerlib/VideoLogUtil.java

@@ -8,13 +8,20 @@ import android.util.Log;
 public class VideoLogUtil {
 
     private static final String TAG = "YCVideoPlayer";
-    public static boolean isLog = true;
+    private static boolean isLog = true;
+
+    /**
+     * 设置是否开启日志
+     * @param isLog                 是否开启日志
+     */
+    public static void setIsLog(boolean isLog) {
+        VideoLogUtil.isLog = isLog;
+    }
 
     static void d(String message) {
         if(isLog){
             Log.d(TAG, message);
         }
-
     }
 
     static void i(String message) {

YCVideoPlayerLib/src/main/java/org/yczbj/ycvideoplayerlib/VideoPlayer.java

@@ -57,93 +57,23 @@ import tv.danmaku.ijk.media.player.IjkTimedText;
 
 public class VideoPlayer extends FrameLayout implements InterVideoPlayer{
 
-    /**
-     * 播放错误
-     **/
-    public static final int STATE_ERROR = -1;
-    /**
-     * 播放未开始
-     **/
-    public static final int STATE_IDLE = 0;
-    /**
-     * 播放准备中
-     **/
-    public static final int STATE_PREPARING = 1;
-    /**
-     * 播放准备就绪
-     **/
-    public static final int STATE_PREPARED = 2;
-    /**
-     * 正在播放
-     **/
-    public static final int STATE_PLAYING = 3;
-    /**
-     * 暂停播放
-     **/
-    public static final int STATE_PAUSED = 4;
-    /**
-     * 正在缓冲(播放器正在播放时，缓冲区数据不足，进行缓冲，缓冲区数据足够后恢复播放)
-     **/
-    public static final int STATE_BUFFERING_PLAYING = 5;
-    /**
-     * 正在缓冲(播放器正在播放时，缓冲区数据不足，进行缓冲，此时暂停播放器，继续缓冲，缓冲区数据足够后恢复暂停
-     **/
-    public static final int STATE_BUFFERING_PAUSED = 6;
-    /**
-     * 播放完成
-     **/
-    public static final int STATE_COMPLETED = 7;
 
-    /**
-     * 普通模式
-     **/
-    public static final int MODE_NORMAL = 10;
-    /**
-     * 全屏模式
-     **/
-    public static final int MODE_FULL_SCREEN = 11;
-    /**
-     * 小窗口模式
-     **/
-    public static final int MODE_TINY_WINDOW = 12;
-
-    /**
-     * IjkPlayer，基于IjkPlayer封装播放器
-     **/
-    public static final int TYPE_IJK = 111;
-    /**
-     * MediaPlayer，基于原生自带的播放器控件
-     **/
-    public static final int TYPE_NATIVE = 222;
     /**
      * 播放类型
      * TYPE_IJK             基于IjkPlayer封装播放器
      * TYPE_NATIVE          基于原生自带的播放器控件
      **/
-    private int mPlayerType = TYPE_IJK;
+    private int mPlayerType = ConstantKeys.IjkPlayerType.TYPE_IJK;
     /**
      * 播放状态，错误，开始播放，暂停播放，缓存中等等状态
      **/
-    private int mCurrentState = STATE_IDLE;
+    private int mCurrentState = ConstantKeys.CurrentState.STATE_IDLE;
     /**
      * 播放模式，普通模式，小窗口模式，正常模式等等
      * 存在局限性：比如小窗口下的正在播放模式，那么mCurrentMode就是STATE_PLAYING，而不是MODE_TINY_WINDOW并存
      **/
-    private int mCurrentMode = MODE_NORMAL;
-    /**
-     * 默认时普通模式
-     */
-    private int mPlayType = PlayMode.MODE_NORMAL;
+    private int mCurrentMode = ConstantKeys.PlayMode.MODE_NORMAL;
 
-    /**
-     * 播放模式，普通模式，小窗口模式，正常模式三种其中一种
-     */
-    @Retention(RetentionPolicy.SOURCE)
-    protected @interface PlayMode {
-        int MODE_NORMAL = 1001;
-        int MODE_FULL_SCREEN = 1002;
-        int MODE_TINY_WINDOW = 1003;
-    }
 
     private Context mContext;
     private AudioManager mAudioManager;
@@ -217,18 +147,13 @@ public class VideoPlayer extends FrameLayout implements InterVideoPlayer{
     }
 
 
-    /**
-     * @return                          获取当前播放模式
-     */
-    public int getPlayType() {
-        return mPlayType;
-    }
-
     /**
      * 设置播放器类型，必须设置
+     * 注意：感谢某人建议，这里限定了传入值类型
+     * 输入值：ConstantKeys.IjkPlayerType.TYPE_IJK   或者  ConstantKeys.IjkPlayerType.TYPE_NATIVE
      * @param playerType IjkPlayer or MediaPlayer.
      */
-    public void setPlayerType(int playerType) {
+    public void setPlayerType(@ConstantKeys.PlayerType int playerType) {
         mPlayerType = playerType;
     }
 
@@ -267,7 +192,7 @@ public class VideoPlayer extends FrameLayout implements InterVideoPlayer{
      */
     @Override
     public void start() {
-        if (mCurrentState == STATE_IDLE) {
+        if (mCurrentState == ConstantKeys.CurrentState.STATE_IDLE) {
             VideoPlayerManager.instance().setCurrentVideoPlayer(this);
             initAudioManager();
             initMediaPlayer();
@@ -295,19 +220,19 @@ public class VideoPlayer extends FrameLayout implements InterVideoPlayer{
      */
     @Override
     public void restart() {
-        if (mCurrentState == STATE_PAUSED) {
+        if (mCurrentState == ConstantKeys.CurrentState.STATE_PAUSED) {
             //如果是暂停状态，那么则继续播放
             mMediaPlayer.start();
-            mCurrentState = STATE_PLAYING;
+            mCurrentState = ConstantKeys.CurrentState.STATE_PLAYING;
             mController.onPlayStateChanged(mCurrentState);
             VideoLogUtil.d("STATE_PLAYING");
-        } else if (mCurrentState == STATE_BUFFERING_PAUSED) {
+        } else if (mCurrentState == ConstantKeys.CurrentState.STATE_BUFFERING_PAUSED) {
             //如果是缓存暂停状态，那么则继续播放
             mMediaPlayer.start();
-            mCurrentState = STATE_BUFFERING_PLAYING;
+            mCurrentState = ConstantKeys.CurrentState.STATE_BUFFERING_PLAYING;
             mController.onPlayStateChanged(mCurrentState);
             VideoLogUtil.d("STATE_BUFFERING_PLAYING");
-        } else if (mCurrentState == STATE_COMPLETED || mCurrentState == STATE_ERROR) {
+        } else if (mCurrentState == ConstantKeys.CurrentState.STATE_COMPLETED || mCurrentState == ConstantKeys.CurrentState.STATE_ERROR) {
             //如果是完成播放或者播放错误，则重新播放
             mMediaPlayer.reset();
             openMediaPlayer();
@@ -322,15 +247,15 @@ public class VideoPlayer extends FrameLayout implements InterVideoPlayer{
      */
     @Override
     public void pause() {
-        if (mCurrentState == STATE_PLAYING) {
+        if (mCurrentState == ConstantKeys.CurrentState.STATE_PLAYING) {
             mMediaPlayer.pause();
-            mCurrentState = STATE_PAUSED;
+            mCurrentState = ConstantKeys.CurrentState.STATE_PAUSED;
             mController.onPlayStateChanged(mCurrentState);
             VideoLogUtil.d("STATE_PAUSED");
         }
-        if (mCurrentState == STATE_BUFFERING_PLAYING) {
+        if (mCurrentState == ConstantKeys.CurrentState.STATE_BUFFERING_PLAYING) {
             mMediaPlayer.pause();
-            mCurrentState = STATE_BUFFERING_PAUSED;
+            mCurrentState = ConstantKeys.CurrentState.STATE_BUFFERING_PAUSED;
             mController.onPlayStateChanged(mCurrentState);
             VideoLogUtil.d("STATE_BUFFERING_PAUSED");
         }
@@ -367,7 +292,7 @@ public class VideoPlayer extends FrameLayout implements InterVideoPlayer{
      */
     @Override
     public boolean isIdle() {
-        return mCurrentState == STATE_IDLE;
+        return mCurrentState == ConstantKeys.CurrentState.STATE_IDLE;
     }
 
 
@@ -377,7 +302,7 @@ public class VideoPlayer extends FrameLayout implements InterVideoPlayer{
      */
     @Override
     public boolean isPreparing() {
-        return mCurrentState == STATE_PREPARING;
+        return mCurrentState == ConstantKeys.CurrentState.STATE_PREPARING;
     }
 
 
@@ -387,7 +312,7 @@ public class VideoPlayer extends FrameLayout implements InterVideoPlayer{
      */
     @Override
     public boolean isPrepared() {
-        return mCurrentState == STATE_PREPARED;
+        return mCurrentState == ConstantKeys.CurrentState.STATE_PREPARED;
     }
 
 
@@ -397,7 +322,7 @@ public class VideoPlayer extends FrameLayout implements InterVideoPlayer{
      */
     @Override
     public boolean isBufferingPlaying() {
-        return mCurrentState == STATE_BUFFERING_PLAYING;
+        return mCurrentState == ConstantKeys.CurrentState.STATE_BUFFERING_PLAYING;
     }
 
 
@@ -407,7 +332,7 @@ public class VideoPlayer extends FrameLayout implements InterVideoPlayer{
      */
     @Override
     public boolean isBufferingPaused() {
-        return mCurrentState == STATE_BUFFERING_PAUSED;
+        return mCurrentState == ConstantKeys.CurrentState.STATE_BUFFERING_PAUSED;
     }
 
 
@@ -417,7 +342,7 @@ public class VideoPlayer extends FrameLayout implements InterVideoPlayer{
      */
     @Override
     public boolean isPlaying() {
-        return mCurrentState == STATE_PLAYING;
+        return mCurrentState == ConstantKeys.CurrentState.STATE_PLAYING;
     }
 
 
@@ -427,7 +352,7 @@ public class VideoPlayer extends FrameLayout implements InterVideoPlayer{
      */
     @Override
     public boolean isPaused() {
-        return mCurrentState == STATE_PAUSED;
+        return mCurrentState == ConstantKeys.CurrentState.STATE_PAUSED;
     }
 
 
@@ -437,7 +362,7 @@ public class VideoPlayer extends FrameLayout implements InterVideoPlayer{
      */
     @Override
     public boolean isError() {
-        return mCurrentState == STATE_ERROR;
+        return mCurrentState == ConstantKeys.CurrentState.STATE_ERROR;
     }
 
 
@@ -447,7 +372,7 @@ public class VideoPlayer extends FrameLayout implements InterVideoPlayer{
      */
     @Override
     public boolean isCompleted() {
-        return mCurrentState == STATE_COMPLETED;
+        return mCurrentState == ConstantKeys.CurrentState.STATE_COMPLETED;
     }
 
 
@@ -457,7 +382,7 @@ public class VideoPlayer extends FrameLayout implements InterVideoPlayer{
      */
     @Override
     public boolean isFullScreen() {
-        return mCurrentMode == MODE_FULL_SCREEN;
+        return mCurrentMode == ConstantKeys.PlayMode.MODE_FULL_SCREEN;
     }
 
 
@@ -467,7 +392,7 @@ public class VideoPlayer extends FrameLayout implements InterVideoPlayer{
      */
     @Override
     public boolean isTinyWindow() {
-        return mCurrentMode == MODE_TINY_WINDOW;
+        return mCurrentMode == ConstantKeys.PlayMode.MODE_TINY_WINDOW;
     }
 
 
@@ -477,7 +402,7 @@ public class VideoPlayer extends FrameLayout implements InterVideoPlayer{
      */
     @Override
     public boolean isNormal() {
-        return mCurrentMode == MODE_NORMAL;
+        return mCurrentMode == ConstantKeys.PlayMode.MODE_NORMAL;
     }
 
 
@@ -493,6 +418,16 @@ public class VideoPlayer extends FrameLayout implements InterVideoPlayer{
         return 0;
     }
 
+    /**
+     * 获取当前播放状态
+     *
+     * @return  播放状态
+     */
+    @Override
+    public int getPlayType() {
+        return mCurrentMode;
+    }
+
 
     /**
      * 获取音量值
@@ -585,20 +520,27 @@ public class VideoPlayer extends FrameLayout implements InterVideoPlayer{
         if (mMediaPlayer == null) {
             switch (mPlayerType) {
                 //MediaPlayer       基于原生
-                case TYPE_NATIVE:
+                case ConstantKeys.IjkPlayerType.TYPE_NATIVE:
                     mMediaPlayer = new AndroidMediaPlayer();
                     break;
                 //IjkMediaPlayer    基于Ijk
-                case TYPE_IJK:
+                case ConstantKeys.IjkPlayerType.TYPE_IJK:
                 default:
                     //创建IjkMediaPlayer对象
                     mMediaPlayer = new IjkMediaPlayer();
-                    //设置ijkplayer播放器的硬件解码相关参数
+                    //设置ijkPlayer播放器的硬件解码相关参数
                     ((IjkMediaPlayer)mMediaPlayer).setOption(1, "analyzemaxduration", 100L);
                     ((IjkMediaPlayer)mMediaPlayer).setOption(1, "probesize", 10240L);
                     ((IjkMediaPlayer)mMediaPlayer).setOption(1, "flush_packets", 1L);
                     ((IjkMediaPlayer)mMediaPlayer).setOption(4, "packet-buffering", 0L);
                     ((IjkMediaPlayer)mMediaPlayer).setOption(4, "framedrop", 1L);
+                    ((IjkMediaPlayer)mMediaPlayer).setOption(4, "mediacodec", 0);
+                    ((IjkMediaPlayer)mMediaPlayer).setOption(4, "opensles", 0);
+                    ((IjkMediaPlayer)mMediaPlayer).setOption(4, "overlay-format", IjkMediaPlayer.SDL_FCC_RV32);
+                    ((IjkMediaPlayer)mMediaPlayer).setOption(4, "framedrop", 1);
+                    ((IjkMediaPlayer)mMediaPlayer).setOption(4, "start-on-prepared", 0);
+                    ((IjkMediaPlayer)mMediaPlayer).setOption(1, "http-detect-range-support", 0);
+                    ((IjkMediaPlayer)mMediaPlayer).setOption(2, "skip_loop_filter", 48);
                     break;
             }
             //设置音频流类型
@@ -703,12 +645,14 @@ public class VideoPlayer extends FrameLayout implements InterVideoPlayer{
             if (mSurface == null) {
                 mSurface = new Surface(mSurfaceTexture);
             }
-            //
+            // 设置surface
             mMediaPlayer.setSurface(mSurface);
+            // 设置播放时常亮
+            mMediaPlayer.setScreenOnWhilePlaying(true);
             // 开始加载
             mMediaPlayer.prepareAsync();
             // 播放准备中
-            mCurrentState = STATE_PREPARING;
+            mCurrentState = ConstantKeys.CurrentState.STATE_PREPARING;
             // 控制器，更新不同的播放状态的UI
             mController.onPlayStateChanged(mCurrentState);
             VideoLogUtil.d("STATE_PREPARING");
@@ -725,7 +669,7 @@ public class VideoPlayer extends FrameLayout implements InterVideoPlayer{
     private IMediaPlayer.OnPreparedListener mOnPreparedListener = new IMediaPlayer.OnPreparedListener() {
         @Override
         public void onPrepared(IMediaPlayer mp) {
-            mCurrentState = STATE_PREPARED;
+            mCurrentState = ConstantKeys.CurrentState.STATE_PREPARED;
             mController.onPlayStateChanged(mCurrentState);
             VideoLogUtil.d("onPrepared ——> STATE_PREPARED");
             mp.start();
@@ -748,7 +692,7 @@ public class VideoPlayer extends FrameLayout implements InterVideoPlayer{
     private IMediaPlayer.OnCompletionListener mOnCompletionListener = new IMediaPlayer.OnCompletionListener() {
         @Override
         public void onCompletion(IMediaPlayer mp) {
-            mCurrentState = STATE_COMPLETED;
+            mCurrentState = ConstantKeys.CurrentState.STATE_COMPLETED;
             mController.onPlayStateChanged(mCurrentState);
             VideoLogUtil.d("onCompletion ——> STATE_COMPLETED");
             // 清除屏幕常亮
@@ -802,7 +746,7 @@ public class VideoPlayer extends FrameLayout implements InterVideoPlayer{
         public boolean onError(IMediaPlayer mp, int what, int extra) {
             // 直播流播放时去调用mediaPlayer.getDuration会导致-38和-2147483648错误，忽略该错误
             if (what != -38 && what != -2147483648 && extra != -38 && extra != -2147483648) {
-                mCurrentState = STATE_ERROR;
+                mCurrentState = ConstantKeys.CurrentState.STATE_ERROR;
                 mController.onPlayStateChanged(mCurrentState);
                 VideoLogUtil.d("onError ——> STATE_ERROR ———— what：" + what + ", extra: " + extra);
             }
@@ -818,28 +762,28 @@ public class VideoPlayer extends FrameLayout implements InterVideoPlayer{
         public boolean onInfo(IMediaPlayer mp, int what, int extra) {
             if (what == IMediaPlayer.MEDIA_INFO_VIDEO_RENDERING_START) {
                 // 播放器开始渲染
-                mCurrentState = STATE_PLAYING;
+                mCurrentState = ConstantKeys.CurrentState.STATE_PLAYING;
                 mController.onPlayStateChanged(mCurrentState);
                 VideoLogUtil.d("onInfo ——> MEDIA_INFO_VIDEO_RENDERING_START：STATE_PLAYING");
             } else if (what == IMediaPlayer.MEDIA_INFO_BUFFERING_START) {
                 // MediaPlayer暂时不播放，以缓冲更多的数据
-                if (mCurrentState == STATE_PAUSED || mCurrentState == STATE_BUFFERING_PAUSED) {
-                    mCurrentState = STATE_BUFFERING_PAUSED;
+                if (mCurrentState == ConstantKeys.CurrentState.STATE_PAUSED || mCurrentState == ConstantKeys.CurrentState.STATE_BUFFERING_PAUSED) {
+                    mCurrentState = ConstantKeys.CurrentState.STATE_BUFFERING_PAUSED;
                     VideoLogUtil.d("onInfo ——> MEDIA_INFO_BUFFERING_START：STATE_BUFFERING_PAUSED");
                 } else {
-                    mCurrentState = STATE_BUFFERING_PLAYING;
+                    mCurrentState = ConstantKeys.CurrentState.STATE_BUFFERING_PLAYING;
                     VideoLogUtil.d("onInfo ——> MEDIA_INFO_BUFFERING_START：STATE_BUFFERING_PLAYING");
                 }
                 mController.onPlayStateChanged(mCurrentState);
             } else if (what == IMediaPlayer.MEDIA_INFO_BUFFERING_END) {
                 // 填充缓冲区后，MediaPlayer恢复播放/暂停
-                if (mCurrentState == STATE_BUFFERING_PLAYING) {
-                    mCurrentState = STATE_PLAYING;
+                if (mCurrentState == ConstantKeys.CurrentState.STATE_BUFFERING_PLAYING) {
+                    mCurrentState = ConstantKeys.CurrentState.STATE_PLAYING;
                     mController.onPlayStateChanged(mCurrentState);
                     VideoLogUtil.d("onInfo ——> MEDIA_INFO_BUFFERING_END： STATE_PLAYING");
                 }
-                if (mCurrentState == STATE_BUFFERING_PAUSED) {
-                    mCurrentState = STATE_PAUSED;
+                if (mCurrentState == ConstantKeys.CurrentState.STATE_BUFFERING_PAUSED) {
+                    mCurrentState = ConstantKeys.CurrentState.STATE_PAUSED;
                     mController.onPlayStateChanged(mCurrentState);
                     VideoLogUtil.d("onInfo ——> MEDIA_INFO_BUFFERING_END： STATE_PAUSED");
                 }
@@ -878,14 +822,14 @@ public class VideoPlayer extends FrameLayout implements InterVideoPlayer{
      */
     @Override
     public void enterFullScreen() {
-        if (mCurrentMode == MODE_FULL_SCREEN){
+        if (mCurrentMode == ConstantKeys.PlayMode.MODE_FULL_SCREEN){
             return;
         }
         // 隐藏ActionBar、状态栏，并横屏
         VideoPlayerUtils.hideActionBar(mContext);
         VideoPlayerUtils.scanForActivity(mContext).setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
         ViewGroup contentView = (ViewGroup) VideoPlayerUtils.scanForActivity(mContext).findViewById(android.R.id.content);
-        if (mCurrentMode == MODE_TINY_WINDOW) {
+        if (mCurrentMode == ConstantKeys.PlayMode.MODE_TINY_WINDOW) {
             contentView.removeView(mContainer);
         } else {
             this.removeView(mContainer);
@@ -893,8 +837,7 @@ public class VideoPlayer extends FrameLayout implements InterVideoPlayer{
         LayoutParams params = new LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT);
         contentView.addView(mContainer, params);
 
-        mCurrentMode = MODE_FULL_SCREEN;
-        mPlayType = PlayMode.MODE_FULL_SCREEN;
+        mCurrentMode = ConstantKeys.PlayMode.MODE_FULL_SCREEN;
         mController.onPlayModeChanged(mCurrentMode);
         VideoLogUtil.d("MODE_FULL_SCREEN");
     }
@@ -905,14 +848,14 @@ public class VideoPlayer extends FrameLayout implements InterVideoPlayer{
      */
     @Override
     public void enterVerticalScreenScreen() {
-        if (mCurrentMode == MODE_FULL_SCREEN){
+        if (mCurrentMode == ConstantKeys.PlayMode.MODE_FULL_SCREEN){
             return;
         }
         // 隐藏ActionBar、状态栏，并横屏
         VideoPlayerUtils.hideActionBar(mContext);
         VideoPlayerUtils.scanForActivity(mContext).setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
         ViewGroup contentView = (ViewGroup) VideoPlayerUtils.scanForActivity(mContext).findViewById(android.R.id.content);
-        if (mCurrentMode == MODE_TINY_WINDOW) {
+        if (mCurrentMode == ConstantKeys.PlayMode.MODE_TINY_WINDOW) {
             contentView.removeView(mContainer);
         } else {
             this.removeView(mContainer);
@@ -920,8 +863,7 @@ public class VideoPlayer extends FrameLayout implements InterVideoPlayer{
         LayoutParams params = new LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT);
         contentView.addView(mContainer, params);
 
-        mCurrentMode = MODE_FULL_SCREEN;
-        mPlayType = PlayMode.MODE_FULL_SCREEN;
+        mCurrentMode = ConstantKeys.PlayMode.MODE_FULL_SCREEN;
         mController.onPlayModeChanged(mCurrentMode);
         VideoLogUtil.d("MODE_FULL_SCREEN");
     }
@@ -939,7 +881,7 @@ public class VideoPlayer extends FrameLayout implements InterVideoPlayer{
      */
     @Override
     public boolean exitFullScreen() {
-        if (mCurrentMode == MODE_FULL_SCREEN) {
+        if (mCurrentMode == ConstantKeys.PlayMode.MODE_FULL_SCREEN) {
             VideoPlayerUtils.showActionBar(mContext);
             VideoPlayerUtils.scanForActivity(mContext).setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
             ViewGroup contentView = (ViewGroup) VideoPlayerUtils.scanForActivity(mContext).findViewById(android.R.id.content);
@@ -948,8 +890,7 @@ public class VideoPlayer extends FrameLayout implements InterVideoPlayer{
             //重新添加到当前视图
             LayoutParams params = new LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT);
             this.addView(mContainer, params);
-            mCurrentMode = MODE_NORMAL;
-            mPlayType = PlayMode.MODE_NORMAL;
+            mCurrentMode = ConstantKeys.PlayMode.MODE_NORMAL;
             mController.onPlayModeChanged(mCurrentMode);
             VideoLogUtil.d("MODE_NORMAL");
             return true;
@@ -965,7 +906,7 @@ public class VideoPlayer extends FrameLayout implements InterVideoPlayer{
     @Override
     public void enterTinyWindow() {
         //如果是小窗口模式，则不执行下面代码
-        if (mCurrentMode == MODE_TINY_WINDOW) {
+        if (mCurrentMode == ConstantKeys.PlayMode.MODE_TINY_WINDOW) {
             return;
         }
         //先移除
@@ -980,8 +921,7 @@ public class VideoPlayer extends FrameLayout implements InterVideoPlayer{
         params.bottomMargin = VideoPlayerUtils.dp2px(mContext, 8f);
 
         contentView.addView(mContainer, params);
-        mCurrentMode = MODE_TINY_WINDOW;
-        mPlayType = PlayMode.MODE_TINY_WINDOW;
+        mCurrentMode = ConstantKeys.PlayMode.MODE_TINY_WINDOW;
         mController.onPlayModeChanged(mCurrentMode);
         VideoLogUtil.d("MODE_TINY_WINDOW");
     }
@@ -991,13 +931,12 @@ public class VideoPlayer extends FrameLayout implements InterVideoPlayer{
      */
     @Override
     public boolean exitTinyWindow() {
-        if (mCurrentMode == MODE_TINY_WINDOW) {
+        if (mCurrentMode == ConstantKeys.PlayMode.MODE_TINY_WINDOW) {
             ViewGroup contentView = (ViewGroup) VideoPlayerUtils.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 = MODE_NORMAL;
-            mPlayType = PlayMode.MODE_NORMAL;
+            mCurrentMode = ConstantKeys.PlayMode.MODE_NORMAL;
             mController.onPlayModeChanged(mCurrentMode);
             VideoLogUtil.d("MODE_NORMAL");
             return true;
@@ -1031,8 +970,7 @@ public class VideoPlayer extends FrameLayout implements InterVideoPlayer{
         if (isTinyWindow()) {
             exitTinyWindow();
         }
-        mCurrentMode = MODE_NORMAL;
-        mPlayType = PlayMode.MODE_NORMAL;
+        mCurrentMode = ConstantKeys.PlayMode.MODE_NORMAL;
 
         // 释放播放器
         releasePlayer();
@@ -1077,7 +1015,7 @@ public class VideoPlayer extends FrameLayout implements InterVideoPlayer{
             mSurfaceTexture.release();
             mSurfaceTexture = null;
         }
-        mCurrentState = STATE_IDLE;
+        mCurrentState = ConstantKeys.CurrentState.STATE_IDLE;
     }
 
 

YCVideoPlayerLib/src/main/java/org/yczbj/ycvideoplayerlib/VideoPlayerController.java

@@ -131,7 +131,7 @@ public class VideoPlayerController extends AbsVideoPlayerController implements V
      */
     private boolean hasRegisterBatteryReceiver;
     /**
-     * 是否已经注册了网络监听广播
+     * 是否已经注册了网络监听广播，添加这个判断可以避免崩溃
      */
     private boolean hasRegisterNetReceiver;
     /**
@@ -201,7 +201,10 @@ public class VideoPlayerController extends AbsVideoPlayerController implements V
                         }
                     } else {
                         VideoLogUtil.i(getConnectionType(info.getType()) + "断开");
-                        onPlayStateChanged(VideoPlayer.STATE_ERROR);
+                        onPlayStateChanged(ConstantKeys.CurrentState.STATE_ERROR);
+                        if(mVideoPlayer.isIdle()){
+                            mVideoPlayer.pause();
+                        }
                     }
                 }
             }
@@ -275,13 +278,7 @@ public class VideoPlayerController extends AbsVideoPlayerController implements V
         init();
     }
 
-    @Override
-    protected void onDetachedFromWindow() {
-        super.onDetachedFromWindow();
-        unRegisterNetChangedReceiver();//会导致崩溃
-    }
-
-    public void registerNetChangedReceiver() {
+    private void registerNetChangedReceiver() {
         if (!hasRegisterNetReceiver) {
             if (netChangedReceiver == null) {
                 netChangedReceiver = new NetChangedReceiver();
@@ -294,7 +291,7 @@ public class VideoPlayerController extends AbsVideoPlayerController implements V
         }
     }
 
-    public void unRegisterNetChangedReceiver() {
+    private void unRegisterNetChangedReceiver() {
         if (hasRegisterNetReceiver) {
             if (netChangedReceiver != null) {
                 mContext.unregisterReceiver(netChangedReceiver);
@@ -449,16 +446,20 @@ public class VideoPlayerController extends AbsVideoPlayerController implements V
      *             更多可以关注我的GitHub：https://github.com/yangchong211
      */
     @Override
-    public void setLoadingType(int type) {
-        if(type==1){
-            pbLoadingRing.setVisibility(GONE);
-            pbLoadingQq.setVisibility(VISIBLE);
-        }else if(type==2){
-            pbLoadingRing.setVisibility(VISIBLE);
-            pbLoadingQq.setVisibility(GONE);
-        }else {
-            pbLoadingRing.setVisibility(VISIBLE);
-            pbLoadingQq.setVisibility(GONE);
+    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;
         }
     }
 
@@ -624,24 +625,14 @@ public class VideoPlayerController extends AbsVideoPlayerController implements V
     /**
      * 当播放状态发生改变时
      * @param playState 播放状态：
-     *                  <ul>
-     *                  <li>{@link VideoPlayer#STATE_IDLE}</li>
-     *                  <li>{@link VideoPlayer#STATE_PREPARING}</li>
-     *                  <li>{@link VideoPlayer#STATE_PREPARED}</li>
-     *                  <li>{@link VideoPlayer#STATE_PLAYING}</li>
-     *                  <li>{@link VideoPlayer#STATE_PAUSED}</li>
-     *                  <li>{@link VideoPlayer#STATE_BUFFERING_PLAYING}</li>
-     *                  <li>{@link VideoPlayer#STATE_BUFFERING_PAUSED}</li>
-     *                  <li>{@link VideoPlayer#STATE_ERROR}</li>
-     *                  <li>{@link VideoPlayer#STATE_COMPLETED}</li>
      */
     @Override
     protected void onPlayStateChanged(int playState) {
         switch (playState) {
-            case VideoPlayer.STATE_IDLE:
+            case ConstantKeys.CurrentState.STATE_IDLE:
                 break;
             //播放准备中
-            case VideoPlayer.STATE_PREPARING:
+            case ConstantKeys.CurrentState.STATE_PREPARING:
                 mImage.setVisibility(View.GONE);
                 mLoading.setVisibility(View.VISIBLE);
                 mLoadText.setText("正在准备...");
@@ -653,47 +644,44 @@ public class VideoPlayerController extends AbsVideoPlayerController implements V
                 mLength.setVisibility(View.GONE);
                 break;
             //播放准备就绪
-            case VideoPlayer.STATE_PREPARED:
+            case ConstantKeys.CurrentState.STATE_PREPARED:
                 startUpdateProgressTimer();
                 break;
             //正在播放
-            case VideoPlayer.STATE_PLAYING:
+            case ConstantKeys.CurrentState.STATE_PLAYING:
                 mLoading.setVisibility(View.GONE);
                 mRestartPause.setImageResource(R.drawable.ic_player_pause);
                 startDismissTopBottomTimer();
                 break;
             //暂停播放
-            case VideoPlayer.STATE_PAUSED:
+            case ConstantKeys.CurrentState.STATE_PAUSED:
                 mLoading.setVisibility(View.GONE);
                 mRestartPause.setImageResource(R.drawable.ic_player_start);
                 cancelDismissTopBottomTimer();
                 break;
             //正在缓冲(播放器正在播放时，缓冲区数据不足，进行缓冲，缓冲区数据足够后恢复播放)
-            case VideoPlayer.STATE_BUFFERING_PLAYING:
+            case ConstantKeys.CurrentState.STATE_BUFFERING_PLAYING:
                 mLoading.setVisibility(View.VISIBLE);
                 mRestartPause.setImageResource(R.drawable.ic_player_pause);
                 mLoadText.setText("正在缓冲...");
                 startDismissTopBottomTimer();
                 break;
             //正在缓冲
-            case VideoPlayer.STATE_BUFFERING_PAUSED:
+            case ConstantKeys.CurrentState.STATE_BUFFERING_PAUSED:
                 mLoading.setVisibility(View.VISIBLE);
                 mRestartPause.setImageResource(R.drawable.ic_player_start);
                 mLoadText.setText("正在缓冲...");
                 cancelDismissTopBottomTimer();
                 break;
             //播放错误
-            case VideoPlayer.STATE_ERROR:
+            case ConstantKeys.CurrentState.STATE_ERROR:
                 cancelUpdateProgressTimer();
                 setTopBottomVisible(false);
                 mTop.setVisibility(View.VISIBLE);
                 mError.setVisibility(View.VISIBLE);
-                if(mVideoPlayer.isError()){
-                    mVideoPlayer.pause();
-                }
                 break;
             //播放完成
-            case VideoPlayer.STATE_COMPLETED:
+            case ConstantKeys.CurrentState.STATE_COMPLETED:
                 cancelUpdateProgressTimer();
                 setTopBottomVisible(false);
                 mImage.setVisibility(View.VISIBLE);
@@ -702,6 +690,8 @@ public class VideoPlayerController extends AbsVideoPlayerController implements V
                 if(mOnCompletedListener!=null){
                     mOnCompletedListener.onCompleted();
                 }
+                //当播放完成就解除广播
+                unRegisterNetChangedReceiver();
                 break;
             default:
                 break;
@@ -712,16 +702,12 @@ public class VideoPlayerController extends AbsVideoPlayerController implements V
     /**
      * 当播放器的播放模式发生变化时
      * @param playMode 播放器的模式：
-     *                 <ul>
-     *                 <li>{@link VideoPlayer#MODE_NORMAL}</li>
-     *                 <li>{@link VideoPlayer#MODE_FULL_SCREEN}</li>
-     *                 <li>{@link VideoPlayer#MODE_TINY_WINDOW}</li>
      */
     @Override
     protected void onPlayModeChanged(int playMode) {
         switch (playMode) {
             //普通模式
-            case VideoPlayer.MODE_NORMAL:
+            case ConstantKeys.PlayMode.MODE_NORMAL:
                 mFlLock.setVisibility(View.GONE);
                 mBack.setVisibility(View.VISIBLE);
                 mFullScreen.setImageResource(R.drawable.ic_player_enlarge);
@@ -740,7 +726,7 @@ public class VideoPlayerController extends AbsVideoPlayerController implements V
                 mIsLock = false;
                 break;
             //全屏模式
-            case VideoPlayer.MODE_FULL_SCREEN:
+            case ConstantKeys.PlayMode.MODE_FULL_SCREEN:
                 mFlLock.setVisibility(View.VISIBLE);
                 mBack.setVisibility(View.VISIBLE);
                 mFullScreen.setVisibility(View.GONE);
@@ -756,7 +742,7 @@ public class VideoPlayerController extends AbsVideoPlayerController implements V
                 }
                 break;
             //小窗口模式
-            case VideoPlayer.MODE_TINY_WINDOW:
+            case ConstantKeys.PlayMode.MODE_TINY_WINDOW:
                 mFlLock.setVisibility(View.GONE);
                 mBack.setVisibility(View.VISIBLE);
                 mClarity.setVisibility(View.GONE);
@@ -827,6 +813,8 @@ public class VideoPlayerController extends AbsVideoPlayerController implements V
                 //如果两种情况都不是，执行逻辑交给使用者自己实现
                 if(mBackListener!=null){
                     mBackListener.onBackClick();
+                }else {
+                    VideoLogUtil.d("返回键逻辑，如果是全屏，则先退出全屏；如果是小窗口，则退出小窗口；如果两种情况都不是，执行逻辑交给使用者自己实现");
                 }
             }
         } else if (v == mRestartPause) {
@@ -896,20 +884,21 @@ public class VideoPlayerController extends AbsVideoPlayerController implements V
             if (mIsLogin) {
                 //试看结束，观看全部内容请开通会员
                 mClickListener.onClick(ConstantKeys.Gender.LOGIN);
-            }else if(mType ==1){
-                //试看结束，观看全部内容请开通会员/购买。已是会员/已购买可登陆观看
-                mClickListener.onClick(ConstantKeys.Gender.MEMBER);
-            }else if(mType == 2){
-                //试看结束，观看全部内容请开通会员。已是会员/已购买可登陆观看
-                mClickListener.onClick(ConstantKeys.Gender.MEMBER);
-            }else if(mType == 3){
-                //试看结束, 登录后即可观看全部免费课程。
-                mClickListener.onClick(ConstantKeys.Gender.MEMBER);
+            }else {
+                if(mType ==1){
+                    //试看结束，观看全部内容请开通会员/购买。已是会员/已购买可登陆观看
+                    mClickListener.onClick(ConstantKeys.Gender.MEMBER);
+                }else if(mType == 2){
+                    //试看结束，观看全部内容请开通会员。已是会员/已购买可登陆观看
+                    mClickListener.onClick(ConstantKeys.Gender.MEMBER);
+                }else if(mType == 3){
+                    //试看结束, 登录后即可观看全部免费课程。
+                    mClickListener.onClick(ConstantKeys.Gender.MEMBER);
+                }
             }
         } else if(v == mFlLock){
             //点击锁屏按钮，则进入锁屏模式
             setLock(mIsLock);
-
         } else if(v == mIvDownload){
             if(mVideoControlListener==null){
                 VideoLogUtil.d("请在初始化的时候设置下载监听事件");

YCVideoPlayerLib/src/main/java/org/yczbj/ycvideoplayerlib/VideoPlayerUtils.java

@@ -48,10 +48,7 @@ public class VideoPlayerUtils {
         if (activity == null) {
             return false;
         }
-        if (activity.isFinishing()) {
-            return false;
-        }
-        return true;
+        return !activity.isFinishing();
     }
 
 
@@ -120,7 +117,7 @@ public class VideoPlayerUtils {
      * @param milliseconds 毫秒数
      * @return ##:##
      */
-    public static String formatTime(long milliseconds) {
+    static String formatTime(long milliseconds) {
         if (milliseconds <= 0 || milliseconds >= 24 * 60 * 60 * 1000) {
             return "00:00";
         }
@@ -171,7 +168,7 @@ public class VideoPlayerUtils {
      *
      * @return {@code true}: 是<br>{@code false}: 否
      */
-    public static boolean isConnected(Context context) {
+    static boolean isConnected(Context context) {
         NetworkInfo info = getActiveNetworkInfo(context);
         return info != null && info.isConnected();
     }

app/build.gradle

@@ -96,7 +96,7 @@ dependencies {
     compile 'cn.yc:YCBaseAdapterLib:1.3'                            //adapter封装
     compile 'cn.yc:YCDialogLib:3.5'                                 //弹窗
     compile 'cn.yc:YCProgressLib:1.2'                               //进度条
-    //compile 'cn.yc:YCVideoPlayerLib:2.4.6'                            //播放器
-    compile project(':YCVideoPlayerLib')
+    compile 'cn.yc:YCVideoPlayerLib:2.4.9'                            //播放器
+    //compile project(':YCVideoPlayerLib')
     compile 'cn.yc:YCStatusBarLib:1.3'                              //状态栏
 }

app/src/main/java/org/yczbj/ycvideoplayer/base/BaseApplication.java

@@ -10,8 +10,10 @@ import com.blankj.utilcode.util.Utils;
 import com.liulishuo.filedownloader.FileDownloader;
 import com.liulishuo.filedownloader.connection.FileDownloadUrlConnection;
 
+import org.yczbj.ycvideoplayer.BuildConfig;
 import org.yczbj.ycvideoplayer.service.InitializeService;
 import org.yczbj.ycvideoplayer.util.LogUtils;
+import org.yczbj.ycvideoplayerlib.VideoLogUtil;
 
 import java.net.Proxy;
 
@@ -60,6 +62,11 @@ public class BaseApplication extends Application {
         initDownLoadLib();
         //在子线程中初始化
         InitializeService.start(this);
+        if(BuildConfig.DEBUG){
+            VideoLogUtil.setIsLog(true);
+        }else {
+            VideoLogUtil.setIsLog(false);
+        }
     }
 
     /**

app/src/main/java/org/yczbj/ycvideoplayer/ui/home/view/activity/VideoPlayerJzActivity.java

@@ -135,7 +135,7 @@ public class VideoPlayerJzActivity extends BaseActivity implements VideoPlayerJz
     private void initVideoPlayer() {
         //设置播放类型
         //videoPlayer.setPlayerType(VideoPlayer.TYPE_NATIVE);
-        videoPlayer.setPlayerType(VideoPlayer.TYPE_IJK);
+        videoPlayer.setPlayerType(ConstantKeys.IjkPlayerType.TYPE_IJK);
         //网络视频地址
         String videoUrl = ConstantVideo.VideoPlayerList[0];
         //设置视频地址和请求头部
@@ -147,7 +147,7 @@ public class VideoPlayerJzActivity extends BaseActivity implements VideoPlayerJz
         //创建视频控制器
         VideoPlayerController controller = new VideoPlayerController(this);
         controller.setTitle("高仿优酷视频播放页面");
-        controller.setLoadingType(2);
+        controller.setLoadingType(ConstantKeys.Loading.LOADING_QQ);
         controller.setTopVisibility(false);
         controller.imageView().setBackgroundResource(R.color.blackText);
         controller.setOnVideoBackListener(new OnVideoBackListener() {

app/src/main/java/org/yczbj/ycvideoplayer/ui/home/view/activity/VideoPlayerMeActivity.java

@@ -128,7 +128,7 @@ public class VideoPlayerMeActivity extends BaseActivity implements VideoPlayerMe
     private void initVideoPlayer() {
         //设置播放类型
         //videoPlayer.setPlayerType(VideoPlayer.TYPE_NATIVE);
-        videoPlayer.setPlayerType(VideoPlayer.TYPE_IJK);
+        videoPlayer.setPlayerType(ConstantKeys.IjkPlayerType.TYPE_IJK);
         //网络视频地址
         String videoUrl = ConstantVideo.VideoPlayerList[0];
         //设置视频地址和请求头部
@@ -141,7 +141,7 @@ public class VideoPlayerMeActivity extends BaseActivity implements VideoPlayerMe
         //创建视频控制器
         VideoPlayerController controller = new VideoPlayerController(this);
         controller.setTitle("高仿优酷视频播放页面");
-        controller.setLoadingType(2);
+        controller.setLoadingType(ConstantKeys.Loading.LOADING_QQ);
         controller.setTopVisibility(true);
         controller.setMemberType(false,2);
         controller.imageView().setBackgroundResource(R.color.blackText);

app/src/main/java/org/yczbj/ycvideoplayer/ui/movie/view/activity/MovieDetailActivity.java

@@ -33,6 +33,7 @@ import org.yczbj.ycvideoplayer.ui.movie.model.MovieDetailBean;
 import org.yczbj.ycvideoplayer.ui.movie.presenter.MovieDetailPresenter;
 import org.yczbj.ycvideoplayer.ui.movie.view.adapter.MovieDetailAdapter;
 import org.yczbj.ycvideoplayer.util.ImageUtil;
+import org.yczbj.ycvideoplayerlib.ConstantKeys;
 import org.yczbj.ycvideoplayerlib.listener.OnVideoBackListener;
 import org.yczbj.ycvideoplayerlib.VideoPlayer;
 import org.yczbj.ycvideoplayerlib.VideoPlayerController;
@@ -149,7 +150,7 @@ public class MovieDetailActivity extends BaseActivity implements MovieDetailCont
 
     private void initVideoPlayer() {
         //设置播放类型
-        videoPlayer.setPlayerType(VideoPlayer.TYPE_IJK);
+        videoPlayer.setPlayerType(ConstantKeys.IjkPlayerType.TYPE_IJK);
         //网络视频地址
         //设置视频地址和请求头部
         //创建视频控制器
@@ -297,7 +298,7 @@ public class MovieDetailActivity extends BaseActivity implements MovieDetailCont
             controller.setTitle(ret.getTitle());
             String duration = ret.getDuration();
             controller.setLength(duration);
-            controller.setLoadingType(2);
+            controller.setLoadingType(ConstantKeys.Loading.LOADING_QQ);
 
             if(mContentView!=null){
                 tvPlayerCurriculum.setText(ret.getDescription());

app/src/main/java/org/yczbj/ycvideoplayer/ui/test/test2/TestMyActivity.java

@@ -200,7 +200,7 @@ public class TestMyActivity extends BaseActivity implements View.OnClickListener
      */
     private void initVideo7() {
         videoPlayer.release();
-        videoPlayer.setPlayerType(VideoPlayer.TYPE_NATIVE);
+        videoPlayer.setPlayerType(ConstantKeys.IjkPlayerType.TYPE_NATIVE);
         //网络视频地址
         String videoUrl = ConstantVideo.VideoPlayerList[0];
         //设置视频地址和请求头部
@@ -219,7 +219,7 @@ public class TestMyActivity extends BaseActivity implements View.OnClickListener
         VideoPlayerController controller = new VideoPlayerController(this);
         //设置视频标题
         controller.setTitle("高仿优酷视频播放页面");
-        controller.setLoadingType(2);
+        controller.setLoadingType(ConstantKeys.Loading.LOADING_QQ);
         ArrayList<String> content = new ArrayList<>();
         content.add("试看结束，观看全部内容请开通会员1111。");
         content.add("试看结束，观看全部内容请开通会员2222。");
@@ -272,7 +272,7 @@ public class TestMyActivity extends BaseActivity implements View.OnClickListener
     private void initVideo8() {
         videoPlayer.release();
         //设置播放类型
-        videoPlayer.setPlayerType(VideoPlayer.TYPE_IJK);
+        videoPlayer.setPlayerType(ConstantKeys.IjkPlayerType.TYPE_IJK);
         //网络视频地址
         String videoUrl = path;
         //设置视频地址和请求头部
@@ -280,7 +280,7 @@ public class TestMyActivity extends BaseActivity implements View.OnClickListener
         //创建视频控制器
         VideoPlayerController controller = new VideoPlayerController(this);
         controller.setTitle("高仿优酷视频播放页面");
-        controller.setLoadingType(1);
+        controller.setLoadingType(ConstantKeys.Loading.LOADING_RING);
         controller.setTrySeeTime(true,60000);
         controller.setMemberType(true,0);
         controller.imageView().setBackgroundResource(R.color.blackText);
@@ -313,7 +313,7 @@ public class TestMyActivity extends BaseActivity implements View.OnClickListener
      */
     private void initVideo9() {
         videoPlayer.release();
-        videoPlayer.setPlayerType(VideoPlayer.TYPE_NATIVE);
+        videoPlayer.setPlayerType(ConstantKeys.IjkPlayerType.TYPE_IJK);
         //网络视频地址
         String videoUrl = path;
         //设置视频地址和请求头部
@@ -321,7 +321,7 @@ public class TestMyActivity extends BaseActivity implements View.OnClickListener
         //创建视频控制器
         VideoPlayerController controller = new VideoPlayerController(this);
         controller.setTitle("高仿优酷视频播放页面");
-        controller.setLoadingType(2);
+        controller.setLoadingType(ConstantKeys.Loading.LOADING_QQ);
         controller.setMemberType(true,1);
         controller.imageView().setBackgroundResource(R.color.blackText);
         controller.setOnMemberClickListener(new OnMemberClickListener() {
@@ -358,9 +358,9 @@ public class TestMyActivity extends BaseActivity implements View.OnClickListener
         videoPlayer.release();
         //设置播放类型
         // MediaPlayer
-        videoPlayer.setPlayerType(VideoPlayer.TYPE_NATIVE);
+        videoPlayer.setPlayerType(ConstantKeys.IjkPlayerType.TYPE_NATIVE);
         // IjkPlayer
-        videoPlayer.setPlayerType(VideoPlayer.TYPE_IJK);
+        videoPlayer.setPlayerType(ConstantKeys.IjkPlayerType.TYPE_IJK);
         //网络视频地址
         String videoUrl = ConstantVideo.VideoPlayerList[4];
         //设置视频地址和请求头部
@@ -445,7 +445,7 @@ public class TestMyActivity extends BaseActivity implements View.OnClickListener
         controller.setTitle("高仿优酷视频播放页面");
         //controller.setLength(98000);
         //设置视频加载缓冲时加载窗的类型，多种类型
-        controller.setLoadingType(2);
+        controller.setLoadingType(ConstantKeys.Loading.LOADING_QQ);
         ArrayList<String> content = new ArrayList<>();
         content.add("试看结束，观看全部内容请开通会员1111。");
         content.add("试看结束，观看全部内容请开通会员2222。");

app/src/main/java/org/yczbj/ycvideoplayer/ui/test/test2/view/TestMyFirstActivity.java

@@ -10,6 +10,7 @@ import com.bumptech.glide.Glide;
 import org.yczbj.ycvideoplayer.R;
 import org.yczbj.ycvideoplayer.api.constant.ConstantVideo;
 import org.yczbj.ycvideoplayer.base.mvp1.BaseActivity;
+import org.yczbj.ycvideoplayerlib.ConstantKeys;
 import org.yczbj.ycvideoplayerlib.VideoPlayer;
 import org.yczbj.ycvideoplayerlib.VideoPlayerManager;
 import org.yczbj.ycvideoplayerlib.VideoPlayerController;
@@ -47,7 +48,7 @@ public class TestMyFirstActivity extends BaseActivity implements View.OnClickLis
 
     @Override
     public void initView() {
-        videoPlayer.setPlayerType(VideoPlayer.TYPE_NATIVE); // IjkPlayer or MediaPlayer
+        videoPlayer.setPlayerType(ConstantKeys.IjkPlayerType.TYPE_NATIVE); // IjkPlayer or MediaPlayer
         String videoUrl = ConstantVideo.VideoPlayerList[0];
         videoPlayer.setUp(videoUrl, null);
         VideoPlayerController controller = new VideoPlayerController(this);

app/src/main/java/org/yczbj/ycvideoplayer/ui/test/test2/view/TestMySecondActivity.java

@@ -7,6 +7,7 @@ import com.bumptech.glide.Glide;
 
 import org.yczbj.ycvideoplayer.R;
 import org.yczbj.ycvideoplayer.base.mvp1.BaseActivity;
+import org.yczbj.ycvideoplayerlib.ConstantKeys;
 import org.yczbj.ycvideoplayerlib.VideoPlayer;
 import org.yczbj.ycvideoplayerlib.VideoPlayerManager;
 import org.yczbj.ycvideoplayerlib.VideoPlayerController;
@@ -48,7 +49,7 @@ public class TestMySecondActivity extends BaseActivity implements View.OnClickLi
 
     @Override
     public void initView() {
-        niceVideoPlayer.setPlayerType(VideoPlayer.TYPE_IJK); // IjkPlayer or MediaPlayer
+        niceVideoPlayer.setPlayerType(ConstantKeys.IjkPlayerType.TYPE_IJK); // IjkPlayer or MediaPlayer
         VideoPlayerController controller = new VideoPlayerController(this);
         controller.setTitle("Beautiful China...");
         controller.setLength(117000);

app/src/main/java/org/yczbj/ycvideoplayer/ui/video/view/activity/VideoContentActivity.java

@@ -28,6 +28,7 @@ import org.yczbj.ycvideoplayer.base.mvp2.BaseMVPActivity;
 import org.yczbj.ycvideoplayer.ui.video.model.bean.MultiNewsArticleDataBean;
 import org.yczbj.ycvideoplayer.ui.video.model.bean.VideoContentBean;
 import org.yczbj.ycvideoplayer.ui.video.view.adapter.VideoArticleAdapter;
+import org.yczbj.ycvideoplayerlib.ConstantKeys;
 import org.yczbj.ycvideoplayerlib.VideoPlayerManager;
 import org.yczbj.ycvideoplayerlib.listener.OnVideoBackListener;
 import org.yczbj.ycvideoplayerlib.VideoPlayer;
@@ -201,13 +202,13 @@ public class VideoContentActivity extends BaseMVPActivity {
             return;
         }
         //设置播放类型
-        videoPlayer.setPlayerType(VideoPlayer.TYPE_IJK);
+        videoPlayer.setPlayerType(ConstantKeys.IjkPlayerType.TYPE_IJK);
         //设置视频地址和请求头部
         videoPlayer.setUp(urls, null);
         //创建视频控制器
         VideoPlayerController controller = new VideoPlayerController(this);
         controller.setTitle(videoTitle);
-        controller.setLoadingType(2);
+        controller.setLoadingType(ConstantKeys.Loading.LOADING_QQ);
         controller.imageView().setBackgroundResource(R.color.blackText);
         controller.setOnVideoBackListener(new OnVideoBackListener() {
             @Override