添加悬浮拖拽视频功能

.idea/modules.xml

@@ -5,7 +5,6 @@
       <module fileurl="file://$PROJECT_DIR$/YCVideoPlayer.iml" filepath="$PROJECT_DIR$/YCVideoPlayer.iml" />
       <module fileurl="file://$PROJECT_DIR$/YCVideoPlayerLib/YCVideoPlayerLib.iml" filepath="$PROJECT_DIR$/YCVideoPlayerLib/YCVideoPlayerLib.iml" />
       <module fileurl="file://$PROJECT_DIR$/app/app.iml" filepath="$PROJECT_DIR$/app/app.iml" />
-      <module fileurl="file://$PROJECT_DIR$/jiaozivideoplayer/jiaozivideoplayer.iml" filepath="$PROJECT_DIR$/jiaozivideoplayer/jiaozivideoplayer.iml" />
     </modules>
   </component>
 </project>

README.md

@@ -1,72 +1,32 @@
-#### **目录介绍**
-- **1.关于此视频封装库介绍**
-- 1.1 能够满足那些业务需求
-- 1.2 对比同类型的库有哪些优势
-- **2.关于使用方法说明**
-- 2.1 关于gradle引用说明
-- 2.2 添加布局
-- 2.3 最简单的视频播放器参数设定
-- 2.4 注意的问题，视频播放优化
-- 2.5 关于开源库中的类说明
-- 2.6 暴露各种监听事件接口
-- **3.关于播放类型说明**
-- 3.1 普通视频播放
-- 3.2 list页面视频播放
-- 3.3 小窗口视频播放
-- 3.4 类似爱奇艺，优酷会员试看视频播放
-- 3.5 设置竖屏全屏或者横屏全屏模式
-- 3.6 关于封装库中日志打印
-- **4.关于相关方法说明**
-- 4.1 关于VideoPlayer类[播放器]中方法说明
-- 4.2 关于VideoPlayerController类[控制器]中方法说明
-- 4.3 关于对象的销毁
-- **5.关于封装的思路**
-- 5.1 参考的案例思路
-- 5.2 封装的基本思路
-- 5.3 关于窗口切换分析
-- 5.4 关于VideoPlayerManager视频播放器管理器分析
-- 5.5 关于VideoPlayerController视频控制器分析
-- 5.6 关于InterVideoPlayer接口分析
-- **6.关于如何自定义你想要的视频播放模式**
-- 6.1 自定义视频播放器
-- **7.关于效果图的展示**
-- 7.1 效果图如下所示
-- **8.关于遇到的问题说明**
-- 8.1 视频难点
-- 8.2 遇到的bug
-- 8.3 后期需要实现的功能
-- **9.关于版本更新说明**
-- 9.0.0 v0.0.0 写于2017年7月1日
-- 9.0.1 V1.0.0 更新于2017年9月4日
-- 9.0.2 V1.0.1 更新于2017年11月18日
-- 9.0.3 v1.1.0 更新于2018年1月15日
-- 9.0.4 v2.0.0 更新于2018年1月18日
-- 9.0.5 v2.4.5 更新于2018年4月21日
-- 9.0.6 v2.4.6 更新于2018年8月2日
-- 9.0.7 v2.4.8 更新于2018年8月12日
-- 9.0.8 v2.4.9 更新于2018年8月16日
-- 9.0.9 v2.5.0 更新与2018年8月20日
-- **10.关于参考文档说明**
-- 10.1 参考的项目
-- 10.2 参考的博客
-- **11.关其他说明**
-- 11.1 目前市场流行的视频框架
-- 11.2 如何选择合适的框架
-- 11.3 关于我的个人博客和站点
-
-
-
-
-### 0.备注
-- 仿照爱奇艺，优酷播放器写的，十分感谢GitHub上大神前辈们的开源案例和思路。
-- 支持插入广告，设置视频观看权限，观看完后登录或者购买会员。我看到在star较多的项目issues中，有些人正好需要这个案例，库集成后直接通过代码调用即可，灵活且拓展性强。
-- 由于调到做视频的部门，因此此部分代码会持续更新，也欢迎同行提bug或者问题
-- 如果你觉得还可以，给个star吧！我也在持续学习中！！！
-- 项目地址：https://github.com/yangchong211/YCVideoPlayer
-
-
-### 1.关于此视频封装库介绍
-#### 1.1 能够满足那些业务需求
+#### 目录介绍
+- 1.视频具有的功能
+- 2.使用方法介绍
+    - 2.1 关于gradle引用说明
+    - 2.2 添加布局
+    - 2.3 最简单的视频播放器参数设定
+    - 2.4 优化代码
+    - 2.5 注意问题
+- 3.其他推荐说明
+- 4.文档wiki说明
+- 5.运行的效果展示
+- 6.版本更新说明
+    - 6.0.0 v0.0.0 写于2017年7月1日
+    - 6.0.1 V1.0.0 更新于2017年9月4日
+    - 6.0.2 V1.0.1 更新于2017年11月18日
+    - 6.0.3 v1.1.0 更新于2018年1月15日
+    - 6.0.4 v2.0.0 更新于2018年1月18日
+    - 6.0.5 v2.4.5 更新于2018年4月21日
+    - 6.0.6 v2.4.6 更新于2018年8月2日
+    - 6.0.7 v2.4.8 更新于2018年8月12日
+    - 6.0.8 v2.4.9 更新于2018年8月16日
+    - 6.0.9 v2.5.0 更新与2018年8月20日
+    - 6.1.0 v2.6.0 更新于2018年9月25日
+- 7.性能优化和库大小
+- 8.其他说明
+
+
+
+### 1.视频具有的功能
 ##### A基础功能
 - A.1.1 能够自定义视频加载loading类型，设置视频标题，设置视频底部图片，设置播放时长等基础功能
 - A.1.2 可以切换播放器的视频播放状态，播放错误，播放未开始，播放开始，播放准备中，正在播放，暂停播放，正在缓冲等等状态
@@ -91,113 +51,14 @@
 - C.1.2 对于设置视频的宽高，建议设置成4：3或者16：9或者常用比例，如果不是常用比例，则可能会有黑边。其中黑边的背景可以设置
 - C.1.3 可以设置播放有权限的视频时的各种文字描述，而没有把它写在封装库中，使用者自己设定
 - C.1.4 锁定屏幕功能
-##### D待添加功能
-- D.1.1 可以支持屏幕截图功能，视频添加水印效果
-- D.1.2 支持弹幕功能
-- D.1.3 后期待定
 
 
-#### 1.2 对比同类型的库有哪些优势
-##### 1.2.1目前仅仅查了下GitHub上项目
-- 目前GitHub上比较流行的库
-- 至于官方库就不说了，jiecao的库是基于ijkplayer视频框架，目前封装库有许多，下面几个只是star比较多，其中jiecao库比较类似。
-    ```
-    ijkplayer官方库
-    https://github.com/Bilibili/ijkplayer
-    Vitamio官方库
-    https://github.com/yixia/VitamioBundle
-    以jiecao为例的封装库
-    https://github.com/JasonChow1989/JieCaoVideoPlayer-develop          2年前
-    https://github.com/open-android/JieCaoVideoPlayer                   1年前
-    https://github.com/lipangit/JiaoZiVideoPlayer                       4个月前
-    https://github.com/CarGuo/GSYVideoPlayer
-    其他库
-    https://github.com/danylovolokh/VideoPlayerManager
-    ```
 
-##### 1.2.2 具有的优势
-- **A.代码布局更加简洁，而且无多余代码**
-- **B.几乎没有多少淡黄色警告，关于注释，通过使用阿里编码插件检测后更加规范，我对代码有洁癖**
-- **C.视频播放器[负责播放]，视频控制器[负责视频播放各种点击或者属性设置操作]，控制器抽象类[定义属性抽象类，供子类实现]，其他可以看代码。结构分层上比较清晰**
-- **D.几乎所有的方法或者重要的成员或者局部变量都有相关的注释，注释的内容非常详细**
-- **E.关于视频属性设置或者按钮点击事件，都可以通过设置相关方法灵活实现。**
-- 首先这些库封装的思路和代码都不错，我也是借鉴他们的思路，在他们的思路上改进而封装的。
-- **相比来说代码结构更加清晰，举几个例子**
-- 针对视频播放页面布局，由于视频播放状态众多，我封装这库不同状态布局有十几种，许多库的视图布局没注释，显示比较臃肿，如果修改或者定位，不熟悉或者好久不操作，都要花时间找。展示我的布局代码
-    ```
-    <?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/custom_video_player_completed"/>
-        <!--播放错误-->
-        <include layout="@layout/custom_video_player_error"/>
-        <!--顶部控制区-->
-        <include layout="@layout/custom_video_player_top"/>
-        <!--底部控制区-->
-        <include layout="@layout/custom_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"/>
-        <!--中间开始播放按钮-->
-        <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"/>
-        <!--试看按钮-->
-        <ImageView
-            android:id="@+id/iv_try_see"
-            android:layout_width="wrap_content"
-            android:layout_height="wrap_content"
-            android:layout_centerInParent="true"
-            android:src="@drawable/selector_try_see"
-            android:visibility="gone"/>
-        <!--试看布局，非会员显示该布局-->
-        <include layout="@layout/custom_video_player_try_see"/>
-    </RelativeLayout>
-    ```
 
-
-
-
-### 2.关于使用方法说明
+### 2.使用方法介绍
 #### 2.1 关于gradle引用说明
-##### 2.1.1直接引用这段代码就可以
 ```
-compile 'cn.yc:YCVideoPlayerLib:2.4.9' 
+compile 'cn.yc:YCVideoPlayerLib:2.6.0' 
 ```
 
 #### 2.2 添加布局
@@ -212,68 +73,23 @@ compile 'cn.yc:YCVideoPlayerLib:2.4.9'
 
 
 #### 2.3 最简单的视频播放器参数设定
-##### 2.3.1 这个是最简单视频播放器的设置参数代码
 ```
 //设置播放类型
 // IjkPlayer or MediaPlayer
-videoPlayer1.setPlayerType(VideoPlayer.TYPE_NATIVE);
+videoPlayer.setPlayerType(VideoPlayer.TYPE_NATIVE);
 //网络视频地址
 String videoUrl = DataUtil.getVideoListData().get(0).getVideoUrl();
 //设置视频地址和请求头部
-videoPlayer1.setUp(videoUrl, null);
-//是否从上一次的位置继续播放
-videoPlayer1.continueFromLastPosition(true);
-//设置播放速度
-videoPlayer1.setSpeed(1.0f);
+videoPlayer.setUp(videoUrl, null);
 //创建视频控制器
 VideoPlayerController controller = new VideoPlayerController(this);
-controller.setTitle("办快来围观拉，自定义视频播放器可以播放视频拉");
-//设置视频时长
-controller.setLength(98000);
-//设置5秒不操作后则隐藏头部和底部布局视图
-controller.setHideTime(5000);
-//controller.setImage(R.drawable.image_default);
-ImageUtil.loadImgByPicasso(this, R.drawable.image_default, R.drawable.image_default, controller.imageView());
+controller.setTitle("自定义视频播放器可以播放视频拉");
 //设置视频控制器
-videoPlayer1.setController(controller);
+videoPlayer.setController(controller);
 ```
 
-##### 2.3.2 关于模仿爱奇艺登录会员权限功能代码
-```
-//设置视频加载缓冲时加载窗的类型，多种类型
-controller.setLoadingType(2);
-ArrayList<String> content = new ArrayList<>();
-content.add("试看结束，yc观看全部内容请开通会员1111。");
-content.add("试看结束，yc观看全部内容请开通会员2222。");
-content.add("试看结束，yc观看全部内容请开通会员3333。");
-content.add("试看结束，yc观看全部内容请开通会员4444。");
-controller.setMemberContent(content);
-controller.setHideTime(5000);
-//设置设置会员权限类型，第一个参数是否登录，第二个参数是否有权限看，第三个参数试看完后展示的文字内容，第四个参数是否保存进度位置
-controller.setMemberType(false,false,3,true);
-controller.imageView().setBackgroundResource(R.color.blackText);
-//ImageUtil.loadImgByPicasso(this, R.color.blackText, R.drawable.image_default, controller.imageView());
-//设置试看结束后，登录或者充值会员按钮的点击事件
-controller.setOnMemberClickListener(new OnMemberClickListener() {
-    @Override
-    public void onClick(int type) {
-        switch (type){
-            case ConstantKeys.Gender.LOGIN:
-                //调到用户登录页面
-                startActivity(MeLoginActivity.class);
-                break;
-            case ConstantKeys.Gender.MEMBER:
-                //调到用户充值会员页面
-                startActivity(MeMemberActivity.class);
-                break;
-            default:
-                break;
-        }
-    }
-});
-```
 
-##### 2.3.3其他设置，让体验更好，视频播放优化
+#### 2.4 优化代码
 - **如果是在Activity中的话，建议设置下面这段代码**
     ```
     @Override
@@ -314,7 +130,7 @@ controller.setOnMemberClickListener(new OnMemberClickListener() {
     ```
 
 
-#### 2.4 注意的问题
+#### 2.5 注意问题
 ##### 2.4.1如果是全屏播放，则需要在清单文件中设置当前activity的属性值**
 - android:configChanges 保证了在全屏的时候横竖屏切换不会执行Activity的相关生命周期，打断视频的播放
 - android:screenOrientation 固定了屏幕的初始方向
@@ -325,667 +141,30 @@ controller.setOnMemberClickListener(new OnMemberClickListener() {
 		android:screenOrientation="portrait"/>
 ```
 
-#### 2.5 关于开源库中的类说明
-- ![image](http://p2mqszpjf.bkt.clouddn.com/ycVideoPlayer1.png)
-
-#### 2.6 暴露各种监听事件接口
-##### 2.6.1 返回键监听[有哥们建议加上这个，让用户自己实现返回键逻辑]
-```
-controller.setOnVideoBackListener(new OnVideoBackListener() {
-            @Override
-            public void onBackClick() {
-                onBackPressed();
-            }
-        });
-```
-##### 2.6.2 清晰度切换的监听事件
-##### 2.6.3 播放或者暂停的监听事件[比如用户自己处理视频暂停时弹窗广告弹窗]
-```
-controller.setOnPlayOrPauseListener(new OnPlayOrPauseListener() {
-            @Override
-            public void onPlayOrPauseClick(boolean isPlaying) {
-                
-            }
-        });
-```
-##### 2.6.4 会员监听事件[只有设置会员权限才生效，默认没有，可以让用户自己处理登录或者充值会员]
-```
-controller.setOnMemberClickListener(new OnMemberClickListener() {
-            @Override
-            public void onClick(int type) {
-                switch (type){
-                    case ConstantKeys.Gender.LOGIN:
-                        ToastUtil.showToast(VideoPlayerMeActivity.this,"登录");
-                        break;
-                    case ConstantKeys.Gender.MEMBER:
-                        ToastUtil.showToast(VideoPlayerMeActivity.this,"充值会员");
-                        break;
-                    default:
-                        break;
-                }
-            }
-        });
-```
-##### 2.6.5 顶部栏多功能监听[比如切换音频，分享，下载，更多等按钮的逻辑处理让用户自己处理]
-```
-controller.setOnVideoControlListener(new OnVideoControlListener() {
-            @Override
-            public void onVideoControlClick(int type) {
-                switch (type){
-                    case ConstantKeys.VideoControl.DOWNLOAD:
-                        ToastUtil.showToast(VideoPlayerMeActivity.this,"下载音视频");
-                        break;
-                    case ConstantKeys.VideoControl.AUDIO:
-                        ToastUtil.showToast(VideoPlayerMeActivity.this,"切换音频");
-                        break;
-                    case ConstantKeys.VideoControl.SHARE:
-                        ToastUtil.showToast(VideoPlayerMeActivity.this,"分享内容");
-                        break;
-                    default:
-                        break;
-                }
-            }
-        });
-```
-
-
-### 3.关于播放类型说明
-#### 3.1 普通视频播放
-- 3.1.1 这一步操作可以直接看第二部分内容——关于使用方法说明
-
-#### 3.2 list页面视频播放
-##### 3.2.1如何在list页面设置视频
-- 第一步：在activity或者fragment中
-    ```
-    recyclerView.setLayoutManager(new LinearLayoutManager(this));
-    recyclerView.setHasFixedSize(true);
-    VideoAdapter adapter = new VideoAdapter(this, DataUtil.getVideoListData());
-    recyclerView.setAdapter(adapter);
-    //注意：下面这个方法不能漏掉
-    recyclerView.setRecyclerListener(new RecyclerView.RecyclerListener() {
-        @Override
-        public void onViewRecycled(RecyclerView.ViewHolder holder) {
-            VideoPlayer videoPlayer = ((VideoAdapter.VideoViewHolder) holder).mVideoPlayer;
-            if (videoPlayer == VideoPlayerManager.instance().getCurrentVideoPlayer()) {
-                VideoPlayerManager.instance().releaseVideoPlayer();
-            }
-        }
-    });
-    ```
-
-
-- 第二步：在RecyclerView的适配器Adapter中
-
-    ```
-    public class VideoAdapter extends RecyclerView.Adapter<VideoAdapter.VideoViewHolder> {
-    
-        private Context mContext;
-        private List<Video> mVideoList;
-    
-        VideoAdapter(Context context, List<Video> videoList) {
-            mContext = context;
-            mVideoList = videoList;
-        }
-    
-        @Override
-        public VideoViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
-            View itemView = LayoutInflater.from(mContext).inflate(R.layout.item_test_my_video, parent, false);
-            VideoViewHolder holder = new VideoViewHolder(itemView);
-            //创建视频播放控制器，主要只要创建一次就可以呢
-            VideoPlayerController controller = new VideoPlayerController(mContext);
-            holder.setController(controller);
-            return holder;
-        }
-    
-        @Override
-        public void onBindViewHolder(VideoViewHolder holder, int position) {
-            Video video = mVideoList.get(position);
-            holder.bindData(video);
-        }
-    
-        @Override
-        public int getItemCount() {
-            return mVideoList==null ? 0 : mVideoList.size();
-        }
-    
-        class VideoViewHolder extends RecyclerView.ViewHolder {
-    
-            VideoPlayerController mController;
-            VideoPlayer mVideoPlayer;
-    
-            VideoViewHolder(View itemView) {
-                super(itemView);
-                mVideoPlayer = (VideoPlayer) itemView.findViewById(R.id.nice_video_player);
-                // 将列表中的每个视频设置为默认16:9的比例
-                ViewGroup.LayoutParams params = mVideoPlayer.getLayoutParams();
-                // 宽度为屏幕宽度
-                params.width = itemView.getResources().getDisplayMetrics().widthPixels;
-                // 高度为宽度的9/16
-                params.height = (int) (params.width * 9f / 16f);
-                mVideoPlayer.setLayoutParams(params);
-            }
-    
-            /**
-             * 设置视频控制器参数
-             * @param controller            控制器对象
-             */
-            void setController(VideoPlayerController controller) {
-                mController = controller;
-                mVideoPlayer.setController(mController);
-            }
-    
-            void bindData(Video video) {
-                mController.setTitle(video.getTitle());
-                mController.setLength(video.getLength());
-                Glide.with(itemView.getContext())
-                        .load(video.getImageUrl())
-                        .placeholder(R.drawable.image_default)
-                        .crossFade()
-                        .into(mController.imageView());
-                mVideoPlayer.setUp(video.getVideoUrl(), null);
-            }
-        }
-    }
-    ```
-
-#### 3.3 小窗口视频播放
-##### 3.3.1建议在设置小窗口先先判断视频播放器是否开始播放
-```
-    if (videoPlayer.isIdle()) {
-        Toast.makeText(this, "要点击播放后才能进入小窗口", Toast.LENGTH_SHORT).show();
-    } else {
-        videoPlayer.enterTinyWindow();
-    }
-```
-
-
-#### 3.4 类似爱奇艺，优酷会员试看视频播放
-##### 3.4.1 可以参考——2.3.2 关于模仿爱奇艺登录会员权限功能代码
-
-
-#### 3.5 设置竖屏全屏或者横屏全屏模式
-```
-//设置竖屏方法上的全屏模式
-mVideoPlayer.enterVerticalScreenScreen();
-//设置横屏方向上的全屏模式
-mVideoPlayer.enterFullScreen();
-```
-
-
-#### 3.6 关于封装库中日志打印
-##### 3.6.1关于封装库中日志打印设置
-- 如果上线产品后不想打印日志，可以在初始化时设置，注意需要在初始化播放器之前设置
-    ```
-    //如果不想打印库中的日志，可以设置
-    VideoLogUtil.isLog = false;
-    ```
-
-
-### 4.关于相关方法说明
-#### 4.1 关于VideoPlayer类中方法说明
-##### 4.1.1 关于一定需要这四步
-```
-//设置播放类型
-// IjkPlayer or MediaPlayer
-videoPlayer1.setPlayerType(VideoPlayer.TYPE_NATIVE);
-//设置视频地址和请求头部
-videoPlayer1.setUp(videoUrl, null);
-//创建视频控制器
-VideoPlayerController controller = new VideoPlayerController(this);
-//设置视频控制器
-videoPlayer1.setController(controller);
-```
-
-##### 4.1.2 关于VideoPlayer中设置属性方法
-```
-//设置播放类型
-// MediaPlayer
-videoPlayer.setPlayerType(VideoPlayer.TYPE_NATIVE);
-// IjkPlayer
-videoPlayer.setPlayerType(VideoPlayer.TYPE_IJK);
-//网络视频地址
-String videoUrl = DataUtil.getVideoListData().get(1).getVideoUrl();
-//设置视频地址和请求头部
-videoPlayer.setUp(videoUrl, null);
-//是否从上一次的位置继续播放
-videoPlayer.continueFromLastPosition(false);
-//设置播放速度
-videoPlayer.setSpeed(1.0f);
-//设置播放位置
-//videoPlayer.seekTo(3000);
-//设置音量
-videoPlayer.setVolume(50);
-//设置竖屏全屏播放
-videoPlayer.enterVerticalScreenScreen();
-//设置横屏全屏播放
-videoPlayer.enterFullScreen();
-//设置小屏幕播放
-videoPlayer.enterTinyWindow();
-//退出全屏
-videoPlayer.exitFullScreen();
-//退出小窗口播放
-videoPlayer.exitTinyWindow();
-//释放，内部的播放器被释放掉，同时如果在全屏、小窗口模式下都会退出
-videoPlayer.release();
-//释放播放器，注意一定要判断对象是否为空，增强严谨性
-videoPlayer.releasePlayer();
-```
-
-##### 4.1.3 关于VideoPlayer中获取属性方法
-```
-//是否从上一次的位置继续播放，不必须
-videoPlayer.continueFromLastPosition(false);
-//获取最大音量
-int maxVolume = videoPlayer.getMaxVolume();
-//获取音量值
-int volume = videoPlayer.getVolume();
-//获取持续时长
-long duration = videoPlayer.getDuration();
-//获取播放位置
-long currentPosition = videoPlayer.getCurrentPosition();
-//获取缓冲区百分比
-int bufferPercentage = videoPlayer.getBufferPercentage();
-//获取播放速度
-float speed = videoPlayer.getSpeed(1);
-```
-
-##### 4.1.4 关于VideoPlayer中设置播放状态方法
-```
-//开始播放
-videoPlayer.start();
-//开始播放，从某位置播放
-videoPlayer.start(3000);
-//重新播放
-videoPlayer.restart();
-//暂停播放
-videoPlayer.pause();
-```
-
-##### 4.1.5 关于VideoPlayer中获取播放状态方法
-```
-//判断是否开始播放
-boolean idle = videoPlayer.isIdle();
-//判断视频是否播放准备中
-boolean preparing = videoPlayer.isPreparing();
-//判断视频是否准备就绪
-boolean prepared = videoPlayer.isPrepared();
-//判断视频是否正在缓冲
-boolean bufferingPlaying = videoPlayer.isBufferingPlaying();
-//判断是否是否缓冲暂停
-boolean bufferingPaused = videoPlayer.isBufferingPaused();
-//判断视频是否暂停播放
-boolean paused = videoPlayer.isPaused();
-//判断视频是否正在播放
-boolean playing = videoPlayer.isPlaying();
-//判断视频是否播放错误
-boolean error = videoPlayer.isError();
-//判断视频是否播放完成
-boolean completed = videoPlayer.isCompleted();
-//判断视频是否播放全屏
-boolean fullScreen = videoPlayer.isFullScreen();
-//判断视频是否播放小窗口
-boolean tinyWindow = videoPlayer.isTinyWindow();
-//判断视频是否正常播放
-boolean normal = videoPlayer.isNormal();
-```
-
-#### 4.2 关于VideoPlayerController类[控制器]中方法说明
-##### 4.2.1 关于控制器方法
-
-```
-//创建视频控制器
-VideoPlayerController controller = new VideoPlayerController(this);
-//设置视频标题
-controller.setTitle("高仿优酷视频播放页面");
-//设置视频时长
-//controller.setLength(98000);
-//设置视频加载缓冲时加载窗的类型，多种类型
-controller.setLoadingType(2);
-ArrayList<String> content = new ArrayList<>();
-content.add("试看结束，观看全部内容请开通会员1111。");
-content.add("试看结束，观看全部内容请开通会员2222。");
-content.add("试看结束，观看全部内容请开通会员3333。");
-content.add("试看结束，观看全部内容请开通会员4444。");
-//设置会员权限话术内容
-controller.setMemberContent(content);
-//设置不操作后，5秒自动隐藏头部和底部布局
-controller.setHideTime(5000);
-//设置设置会员权限类型，第一个参数是否登录，第二个参数是否有权限看，第三个参数试看完后展示的文字内容，第四个参数是否保存进度位置
-controller.setMemberType(false,false,3,true);
-//设置背景图片
-controller.imageView().setBackgroundResource(R.color.blackText);
-//ImageUtil.loadImgByPicasso(this, R.color.blackText, R.drawable.image_default, controller.imageView());
-//设置试看结束后，登录或者充值会员按钮的点击事件
-controller.setOnMemberClickListener(new OnMemberClickListener() {
-    @Override
-    public void onClick(int type) {
-        switch (type){
-            case ConstantKeys.Gender.LOGIN:
-                //调到用户登录也米娜
-                startActivity(MeLoginActivity.class);
-                break;
-            case ConstantKeys.Gender.MEMBER:
-                //调到用户充值会员页面
-                startActivity(MeMemberActivity.class);
-                break;
-            default:
-                break;
-        }
-    }
-});
-//设置视频清晰度
-//videoPlayer.setClarity(list,720);
-//设置视频控制器
-videoPlayer.setController(controller);
-```
-
-#### 4.3 关于对象的销毁
-##### 4.3.1在VideoPlayer中如何释放资源的呢？源代码如下所示
-```
-@Override
-public void release() {
-    // 保存播放位置
-    if (isPlaying() || isBufferingPlaying() || isBufferingPaused() || isPaused()) {
-        VideoPlayerUtils.savePlayPosition(mContext, mUrl, getCurrentPosition());
-    } else if (isCompleted()) {
-        //如果播放完成，则保存播放位置为0，也就是初始位置
-        VideoPlayerUtils.savePlayPosition(mContext, mUrl, 0);
-    }
-    // 退出全屏或小窗口
-    if (isFullScreen()) {
-        exitFullScreen();
-    }
-    if (isTinyWindow()) {
-        exitTinyWindow();
-    }
-    mCurrentMode = MODE_NORMAL;
-
-    // 释放播放器
-    releasePlayer();
-
-    // 恢复控制器
-    if (mController != null) {
-        mController.reset();
-    }
-    // gc回收
-    Runtime.getRuntime().gc();
-}
-//释放播放器，注意一定要判断对象是否为空，增强严谨性
-@Override
-public void releasePlayer() {
-    if (mAudioManager != null) {
-        //放弃音频焦点。使以前的焦点所有者(如果有的话)接收焦点。
-        mAudioManager.abandonAudioFocus(null);
-        //置空
-        mAudioManager = null;
-    }
-    if (mMediaPlayer != null) {
-        //释放视频焦点
-        mMediaPlayer.release();
-        mMediaPlayer = null;
-    }
-    //从视图中移除TextureView
-    mContainer.removeView(mTextureView);
-    if (mSurface != null) {
-        mSurface.release();
-        mSurface = null;
-    }
-    //如果SurfaceTexture不为null，则释放
-    if (mSurfaceTexture != null) {
-        mSurfaceTexture.release();
-        mSurfaceTexture = null;
-    }
-    //设置状态
-    mCurrentState = STATE_IDLE;
-}
-```
-
-
-### 5.关于封装的思路
-#### 5.1 参考的案例思路
-##### 5.1.1目前参考的案例有
-- 可以直接看下面的参考案例，有记录
-##### 5.1.2针对jiaozi代码简单分析
-- JZVideoPlayer为继承自FrameLayout实现的一个组合自定义View来实现了视频播放器的View相关的内容。
-- JZVideoPlayerStandard则是继承自JZVideoPlayer实现了一些自身的功能。
-- JZMediaManager是用来对于MediaPlayer的管理，对于MediaPlayer的一些监听器方法的回调和TextrueView的相关回调处理。
-- JZVideoPlayerManager管理JZVideoPlayer
-- 和自定义相关的工作，最主要是先继承JCVideoPlayerStandard
-- JZMediaSystem主要是实现系统的播放引擎
-- 不得不说，大神封装代码的思路以及代码逻辑的确很强
-- **关于封装库其他感受**
-- 第一：不过，感觉大神更新频率大高，而且没有找到每次更新的日志说明，不知道大神又解决了那些bug
-- 第二：黄色警告多，而且注释少，因为视频封装库不像一般库，有时候需求不同，可拓展性要求高。除了自己继承JCVideoPlayerStandard创建视频播放器，其他如果想改代码，还是有点复杂的。
-- 第三：关于使用虽然很简单，但是在JZVideoPlayerStandard这个方法中，布局的对象都是用public修饰，如果你要想自己甚至某个控件背景或者图标等等，则要这样应用。如果你不去看看源代码中布局名称，你根本就不知道这个对象对应的是什么东西。对于不同修饰符，要合适的，如果不合适，那么就会有淡黄色警告。我看了buttonKnife，retrofit，阿里vlayout等等，可以说黄色警告很少……
-
-```
-  Picasso.with(this)
-                .load("http://jzvd-pic.nathen.cn/jzvd-pic/1bb2ebbe-140d-4e2e-abd2-9e7e564f71ac.png")
-                .into(jzVideo.thumbImageView);
-```
-
-
-#### 5.2 封装的基本思路
-##### 5.2.1关于简单的思路分析
-- a1.可以把视频播放和设置视频属性控制器分离，对于VideoPlayer中，各种UI状态和操作反馈都封装到VideoPlayerController控制器里面。如果需要根据不同的项目需求来修改播放器的功能，就只重写VideoPlayerController就可以了。
-- a2.对于VideoPlayer这个类，可以先创建一个帧布局容器，然后在初始化的时候将视频播放器控制器放到里面，然后通过设置控制器来进行视频播放
-- a3.当调用了开始播放的方法后，就初始化播放器，包括原生的，还有IjkMediaPlayer
-- a4.而基于IjkMediaPlayer的视频播放，需要添加各种监听事件，通过阅读IMediaPlayer源码可以知道：可以在这些监听事件中添加各种对视频的操作逻辑，具体可以看代码。
-```
-    void setOnPreparedListener(IMediaPlayer.OnPreparedListener var1);
-    void setOnCompletionListener(IMediaPlayer.OnCompletionListener var1);
-    void setOnBufferingUpdateListener(IMediaPlayer.OnBufferingUpdateListener var1);
-    void setOnSeekCompleteListener(IMediaPlayer.OnSeekCompleteListener var1);
-    void setOnVideoSizeChangedListener(IMediaPlayer.OnVideoSizeChangedListener var1);
-    void setOnErrorListener(IMediaPlayer.OnErrorListener var1);
-    void setOnInfoListener(IMediaPlayer.OnInfoListener var1);
-    void setOnTimedTextListener(IMediaPlayer.OnTimedTextListener var1);
-```
-- a5.定义好了监听事件后，就创建了播放，重置播放，暂停等各种方法
-
-#### 5.3 关于窗口切换分析
-##### 5.3.1 关于窗口切换调用的代码
-
-```
-	//设置全屏播放
-	videoPlayer.enterFullScreen();
-	//设置小屏幕播放
-	videoPlayer.enterTinyWindow();
-	//退出全屏
-	videoPlayer.exitFullScreen();
-	//退出小窗口播放
-	videoPlayer.exitTinyWindow();
-	//释放，内部的播放器被释放掉，同时如果在全屏、小窗口模式下都会退出
-	videoPlayer.release();
-	//释放播放器，注意一定要判断对象是否为空，增强严谨性
-	videoPlayer.releasePlayer();
-```
-
-
-####  5.4 关于VideoPlayerManager视频播放器管理器分析
-##### 5.4.1可以直接看源代码，我对每个方法都有详细的注释
-
-```
-public class VideoPlayerManager {
-
-    private VideoPlayer mVideoPlayer;
-    private static VideoPlayerManager sInstance;
-    private VideoPlayerManager() {}
-    //一定要使用单例模式，保证同一时刻只有一个视频在播放，其他的都是初始状态
-    public static synchronized VideoPlayerManager instance() {
-        if (sInstance == null) {
-            sInstance = new VideoPlayerManager();
-        }
-        return sInstance;
-    }
-
-    public VideoPlayer getCurrentVideoPlayer() {
-        return mVideoPlayer;
-    }
-
-    void setCurrentVideoPlayer(VideoPlayer videoPlayer) {
-        if (mVideoPlayer != videoPlayer) {
-            releaseVideoPlayer();
-            mVideoPlayer = videoPlayer;
-        }
-    }
-    //当视频正在播放或者正在缓冲时，调用该方法暂停视频
-    public void suspendVideoPlayer() {
-        if (mVideoPlayer != null && (mVideoPlayer.isPlaying() || mVideoPlayer.isBufferingPlaying())) {
-            mVideoPlayer.pause();
-        }
-    }
-    //当视频暂停时或者缓冲暂停时，调用该方法重新开启视频播放
-    public void resumeVideoPlayer() {
-        if (mVideoPlayer != null && (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;
-    }
-}
-```
-
-#### 5.5 关于VideoPlayerController视频控制器分析
-##### 5.5.1VideoPlayerController的作用**
-- 播放控制界面上，播放、暂停、播放进度、缓冲动画、全屏/小屏等触发都是直接调用播放器对应的操作的。
-##### 5.5.2VideoPlayerController的方法如下所示
-
-```
-	//创建视频控制器
-	VideoPlayerController controller = new VideoPlayerController(this);
-	//设置视频标题
-	controller.setTitle("高仿优酷视频播放页面");
-	//设置视频时长
-	//controller.setLength(98000);
-	//设置视频加载缓冲时加载窗的类型，多种类型
-	controller.setLoadingType(2);
-	ArrayList<String> content = new ArrayList<>();
-	content.add("试看结束，观看全部内容请开通会员1111。");
-	content.add("试看结束，观看全部内容请开通会员2222。");
-	content.add("试看结束，观看全部内容请开通会员3333。");
-	content.add("试看结束，观看全部内容请开通会员4444。");
-	//设置会员权限话术内容
-	controller.setMemberContent(content);
-	//设置不操作后，5秒自动隐藏头部和底部布局
-	controller.setHideTime(5000);
-	//设置设置会员权限类型，第一个参数是否登录，第二个参数是否有权限看，第三个参数试看完后展示的文字内容，第四个参数是否保存进度位置
-	controller.setMemberType(false,false,3,true);
-	//设置背景图片
-	controller.imageView().setBackgroundResource(R.color.blackText);
-	//ImageUtil.loadImgByPicasso(this, R.color.blackText, R.drawable.image_default, controller.imageView());
-	//设置试看结束后，登录或者充值会员按钮的点击事件
-	controller.setOnMemberClickListener(new OnMemberClickListener() {
-		@Override
-		public void onClick(int type) {
-			switch (type){
-				case ConstantKeys.Gender.LOGIN:
-					//调到用户登录也米娜
-					startActivity(MeLoginActivity.class);
-					break;
-				case ConstantKeys.Gender.MEMBER:
-					//调到用户充值会员页面
-					startActivity(MeMemberActivity.class);
-					break;
-				default:
-					break;
-			}
-		}
-	});
-	//设置视频清晰度
-	//videoPlayer.setClarity(list,720);
-	//设置视频控制器
-	videoPlayer.setController(controller);
-```
 
-#### 5.6 关于InterVideoPlayer接口分析
-##### 5.6.1关于此接口方法有[跟jiaozi代码类似]
-```
-    /**
-     * 设置视频Url，以及headers
-     *
-     * @param url           视频地址，可以是本地，也可以是网络视频
-     * @param headers       请求header.
-     */
-    void setUp(String url, Map<String, String> headers);
-
-    /**
-     * 开始播放
-     */
-    void start();
-
-    /**
-     * 从指定的位置开始播放
-     *
-     * @param position      播放位置
-     */
-    void start(long position);
+### 3.其他推荐说明
+- 1.[技术博客汇总](https://www.jianshu.com/p/614cb839182c)
+- 2.[开源项目汇总](https://blog.csdn.net/m0_37700275/article/details/80863574)
+- 3.[生活博客汇总](https://blog.csdn.net/m0_37700275/article/details/79832978)
+- 4.[喜马拉雅音频汇总](https://www.jianshu.com/p/f665de16d1eb)
+- 5.[其他汇总](https://www.jianshu.com/p/53017c3fc75d)
+- 6.[重点推荐：博客笔记大汇总，开源文件都是md格式](https://github.com/yangchong211/YCBlogs)
 
-    /**
-     * 重新播放，播放器被暂停、播放错误、播放完成后，需要调用此方法重新播放
-     */
-    void restart();
 
-    /**
-     * 暂停播放
-     */
-    void pause();
 
-    /**
-     * seek到制定的位置继续播放
-     *
-     * @param pos 播放位置
-     */
-    void seekTo(long pos);
+### 4.文档wiki说明[待更新]
+- [Home]()
+- [基础方法说明]()
+- [视频优化处理]()
+- [视频全局悬浮窗播放]()
+- [视频封装思路]()
+- [视频问题处理]()
+- [音视频博客学习]()
+- [详细ReadMe，原文档]()
 
-    /**
-     * 设置音量
-     *
-     * @param volume 音量值
-     */
-    void setVolume(int volume);
-
-    /**
-     * 设置播放速度，目前只有IjkPlayer有效果，原生MediaPlayer暂不支持
-     *
-     * @param speed 播放速度
-     */
-    void setSpeed(float speed);
-
-    /**
-     * 开始播放时，是否从上一次的位置继续播放
-     *
-     * @param continueFromLastPosition true 接着上次的位置继续播放，false从头开始播放
-     */
-    void continueFromLastPosition(boolean continueFromLastPosition);
-```
 
 
-### 6.关于如何自定义你想要的视频播放模式
-#### 6.1 自定义视频播放器
-##### 6.1.1如何自定义自己的播放器
-- 第一步：首先继承VideoPlayer这个类
-- 第二步：然后重写部分你需要更改功能的方法，只需要选择你需要重写的方法即可。
-
-
-###  7.关于效果图的展示
-#### 7.1 效果图如下所示
+### 5.运行的效果展示
 ![image](http://p2mqszpjf.bkt.clouddn.com/ycVideoPlayer2.png)
 ![image](http://p0u62g00n.bkt.clouddn.com/Screenshot_2018-01-05-13-21-49.jpg)
 ![image](http://p2mqszpjf.bkt.clouddn.com/Screenshot_2018-01-16-11-22-43.jpg)
@@ -997,189 +176,70 @@ public class VideoPlayerManager {
 ![image](http://p2mqszpjf.bkt.clouddn.com/Screenshot_20180116-113802.png)
 ![image](http://p2mqszpjf.bkt.clouddn.com/Screenshot_20180116-113840.png)
 ![image](http://p2mqszpjf.bkt.clouddn.com/Screenshot_20180116-135824.png)
+![image](https://upload-images.jianshu.io/upload_images/4432347-c2b61a83c1aaecba.jpg?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
 
 
 
-
-### 8.关于遇到的问题说明
-#### 8.1 视频难点
-- 8.1.1 当视频切换全屏或者从全屏切换到正常小屏幕时，如何管理activity的生命周期
-- 8.1.2 在列表list页面，滑动显示小窗口，那么什么时候显示小窗口呢？关于RecyclerView的滑动位移超出屏幕有没有更好的解决办法？
-- 8.1.2 当屏幕从全屏退出时，播放位置要滑到记录的位置，代码逻辑复杂，如何避免耦合度太高
-
-#### 8.2 遇到的bug
-- 8.2.1 当视频切花时，如何避免视频不卡顿
-- 8.2.2 在fragment中，当左右滑动出另一个fragment中，视频还在播放，怎么样处理这部分逻辑
-- 8.2.3 在显示缓冲比时，网络不好或者暂停缓冲时有问题，所以暂停还没有添加该功能
-- 8.2.4 【已经解决，30毫秒更新一次进度条，只有视频时长很短时才有这种现象】播放进度条seekBar跳动问题，有人反映不是那么顺畅
-- 8.2.6 在拖动时显示当前帧的画面图片，类似优酷那个功能，最终还是没有实现
-
-
-
-#### 8.3 后期需要实现的功能
-- 8.3.1 如果有多集视频，则添加上一集和下一集的功能
-- 8.3.2 拖动滑动条，显示帧画面
-- 8.3.3 实现弹幕功能
-- 8.4.4 有些手机播放有问题，测试找问题
-- 8.5.5 切换视频清晰度有问题，是重新开始播放，因为切换清晰度时，调用的视频链接是不同的。比如高清视频和标准视频链接是不同的，所以难以实现切换后记录位置播放。但是看了下优酷，爱奇艺视频，切换后是接着之前观看的位置播放，这个需要思考下怎么实现。欢迎同行给出好的建议。
-- 8.5.6 待定
-
-
-### 9.关于版本更新说明
-##### 9.1 V1.0.0 更新于2017年10月4日
+### 6.版本更新说明
+##### 6.1 V1.0.0 更新于2017年10月4日
 > 初期最简单功能
-- 9.1.1 支持最简单视频播放，暂停，缓冲，全屏播放等基础功能。
-- 9.1.2 支持滑动改变音量，改变声音大小的功能
-- 9.1.3 还有其他基本功能
+- 6.0.1.1 支持最简单视频播放，暂停，缓冲，全屏播放等基础功能。
+- 6.0.1.2 支持滑动改变音量，改变声音大小的功能
+- 6.0.1.3 还有其他基本功能
 ##### 9.2 V1.0.1 更新于2017年11月18日
 - 最简单的封装，并且阅读相关视频案例，借鉴了相关思路和复用了部分代码
 - 测试环节
 ##### 9.3 v1.1.0 更新于2018年1月15日
-- 9.3.1 添加了设置视频播放权限的功能，用户可以自由设置权限，不过目前只是设置了用户是否登录，和登录用户是否有观看权限，因为公司需求是这样的，所以只有这两个。后期遇到其他需求再添加。逻辑已经在库中写好了，用户自己实现就可以呢。
-- 9.3.2 关于权限肯定有话术内容，那么用户可以通过调用接口直接设置展示在播放器试看结束后的内容。十分方便，这块参考了优酷和爱奇艺视频
-- 9.3.3 添加了用户多久不操作视频界面后，自动隐藏底部和头部布局视图。如果不设置，默认时间为5秒
-- 9.3.4 添加了多种视频加载时候的加载效果，目前有两种，一种是转圈效果，一种是帧动画效果。当然你可以自己添加动画加载效果
+- 6.0.3.1 添加了设置视频播放权限的功能，用户可以自由设置权限，不过目前只是设置了用户是否登录，和登录用户是否有观看权限，因为公司需求是这样的，所以只有这两个。后期遇到其他需求再添加。逻辑已经在库中写好了，用户自己实现就可以呢。
+- 6.0.3.2 关于权限肯定有话术内容，那么用户可以通过调用接口直接设置展示在播放器试看结束后的内容。十分方便，这块参考了优酷和爱奇艺视频
+- 6.0.3.3 添加了用户多久不操作视频界面后，自动隐藏底部和头部布局视图。如果不设置，默认时间为5秒
+- 6.0.3.4 添加了多种视频加载时候的加载效果，目前有两种，一种是转圈效果，一种是帧动画效果。当然你可以自己添加动画加载效果
 ##### 9.4 v1.1.1 更新于2018年1月18日
-- 9.4.1 修改了视频横向播放时，点击手机物理返回键，画面展示状态栏问题
-- 9.4.2 修改了在list页面(recyclerView)的视频，当上拉加载更多时，加载十几次会导致崩溃问题
-- 9.4.3 精简了布局文件，方便修改定制和阅读
-- 9.4.4 修改了在网络不好或者飞行模式下，用户播放视频，应该是播放错误而不是一直转圈加载问题
-- 9.4.5 完善了代码的注释，现在几乎所有的方法都有相关注释，方便阅读和理解。去掉了无用的代码
-- 9.4.6 添加了暴露接口之用户登录和用户购买会员的接口，用户可以自己实现监听之后的操作或者跳转页面
-- 9.4.7 添加了视频左上方的返回键监听，用户可以自己实现返回逻辑
-- 9.4.8 添加了锁定屏幕方向的功能，还在测试中，有点问题
+- 6.0.4.1 修改了视频横向播放时，点击手机物理返回键，画面展示状态栏问题
+- 6.0.4.2 修改了在list页面(recyclerView)的视频，当上拉加载更多时，加载十几次会导致崩溃问题
+- 6.0.4.3 精简了布局文件，方便修改定制和阅读
+- 6.0.4.4 修改了在网络不好或者飞行模式下，用户播放视频，应该是播放错误而不是一直转圈加载问题
+- 6.0.4.5 完善了代码的注释，现在几乎所有的方法都有相关注释，方便阅读和理解。去掉了无用的代码
+- 6.0.4.6 添加了暴露接口之用户登录和用户购买会员的接口，用户可以自己实现监听之后的操作或者跳转页面
+- 6.0.4.7 添加了视频左上方的返回键监听，用户可以自己实现返回逻辑
+- 6.0.4.8 添加了锁定屏幕方向的功能，还在测试中，有点问题
 ##### 9.5 v2.4.5 更新于2018年4月21日
-- 9.5.0 说明：全屏模式下，滑动屏幕左边改变亮度，滑动屏幕右边改变声音
-- 9.5.1 触摸滑动事件中，优化了只有全屏的时候才能拖动位置、亮度、声音
-- 9.5.2 优化了只有在播放，暂停，缓冲的时候才能改变亮度，声音，和拖动位置
-- 9.5.3 滑动改变亮度，声音和拖动位置时，隐藏控制器中间播放位置变化图，亮度变化视图和音量变化视图
+- 6.0.5.0 说明：全屏模式下，滑动屏幕左边改变亮度，滑动屏幕右边改变声音
+- 6.0.5.1 触摸滑动事件中，优化了只有全屏的时候才能拖动位置、亮度、声音
+- 6.0.5.2 优化了只有在播放，暂停，缓冲的时候才能改变亮度，声音，和拖动位置
+- 6.0.5.3 滑动改变亮度，声音和拖动位置时，隐藏控制器中间播放位置变化图，亮度变化视图和音量变化视图
 ##### 9.6 v2.4.6 更新于2018年8月2日
-- 9.6.1 添加了竖屏下的全屏播放模式
-- 9.6.2 解决了横屏下全屏播放模式的导航栏显示问题
+- 6.0.6.1 添加了竖屏下的全屏播放模式
+- 6.0.6.2 解决了横屏下全屏播放模式的导航栏显示问题
 ##### 9.7 v2.4.7 更新于2018年8月12日
-- 9.7.1 添加了锁屏的功能，锁屏时，返回键不做任何处理，并且隐藏top和bottom面版控件
-- 9.7.2 优化了全屏播放视频时，左右滑动可以设置快进和快退的功能
-- 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暴露给开发者，可以让开发者处理某些逻辑，比如暂停时弹出广告
-
+- 6.0.7.1 添加了锁屏的功能，锁屏时，返回键不做任何处理，并且隐藏top和bottom面版控件
+- 6.0.7.2 优化了全屏播放视频时，左右滑动可以设置快进和快退的功能
+- 6.0.7.3 优化了播放视频中，没有网络，点击重试按钮提示用户检查网络是否异常吐司
+- 6.0.7.4 注册一个网络变化监听广播，在网络变更时进行对应处理，从有网切换到没有网络时，切换播放状态
+- 6.0.7.5 修改播放异常条件下，还有声音播放的问题
+##### 6.0.9 v2.5.0 更新与2018年8月20日
+- 6.0.9.1 通过设置注解限制部分方法传入值类型，避免用户传入值导致意外情况
+- 6.0.9.2 初步写了小窗口视频拖拽功能，在下一个版本上该功能
+- 6.0.9.3 修改了正常窗口和全屏切换时，状态栏显示的问题
+- 6.0.9.4 优化了播放和暂停的监听事件，将listener暴露给开发者，可以让开发者处理某些逻辑，比如暂停时弹出广告
+##### 6.1.0 v2.6.0 更新于2018年9月25日
+- 6.1.0.1 优化了视频全屏播放时锁屏的功能
+- 6.1.0.2 添加了视频在应用内小窗口拖动的功能
 
-### 10.关于参考文档说明
-#### 10.1 参考的项目
-##### 10.1.1参考的开源项目有
-```
-https://github.com/CarGuo/GSYVideoPlayer
-https://github.com/danylovolokh/VideoPlayerManager
-https://github.com/HotBitmapGG/bilibili-android-client
-https://github.com/jjdxmashl/jjdxm_ijkplayer
-https://github.com/JasonChow1989/JieCaoVideoPlayer-develop          2年前
-https://github.com/open-android/JieCaoVideoPlayer                   1年前
-https://github.com/lipangit/JiaoZiVideoPlayer                       4个月前
-https://github.com/xiaoyanger0825/NiceVieoPlayer
-https://github.com/curtis2/SuperVideoPlayer
-https://github.com/tcking/GiraffePlayer
-```
-
-#### 10.2 参考的博客
-##### 10.2.1参考的博客有
-```
-https://segmentfault.com/a/1190000011959615
-http://www.jcodecraeer.com/a/anzhuokaifa/androidkaifa/2014/1213/2153.html
-http://blog.csdn.net/junwang19891012/article/details/8444743
-https://www.jianshu.com/p/420f7b14d6f6
-http://blog.csdn.net/candicelijx/article/details/39495271
-```
 
 
-### 11.关其他说明
-#### 11.1 目前市场流行的视频框架
-- 1.Android原生VideoView
-- 2.Google 开源视频播放框架 ExoPlayer
-- 3.Vitamio 视频播放框架
-- 4.Bilibili 开源视频播放框架ijkplayer
 
+### 7.性能优化和库大小
 
-#### 11.2 如何选择
-- **11.2.1.Android原生VideoView**
-* 1.1 VideoView 的使用非常简单，播放视频的步骤：
-	* 在界面布局文件中定义 VideoView 组件，或在程序中创建 VideoView 组件
-	* 调用 VideoView 的如下两个方法来加载指定的视频：
-		* setVidePath(String path)：加载 path 文件代表的视频
-		* setVideoURI(Uri uri)：加载 uri 所对应的视频
-	* 调用 VideoView 的 start()、stop()、psuse() 方法来控制视频的播放
 
 
-- **11.2.2.Google 开源视频播放框架 ExoPlayer**
-* 2.1 框架地址：https://github.com/google/ExoPlayer
-* 2.2 用法
-	* ExoPlayer 开源项目包含了 library 和 示例：
-		* ExoPlayer library – 这部分是核心的库
-		* Demo app – 这部分是演示怎么使用 ExoPlayer 的 Demo
-	* ExoPlayer 库的核心类是 ExoPlayer 类。该类维护了播放器的全局状态 。比如如何获取媒体数据，如何缓冲以及是怎样的编码格式。
-	* ExoPlayer 基于 MediaCodec 和 AudioTrack 提供了默认的音视频的 TrackRenderer 实现。所有的 renderers 都需要 SampleSource 对象，ExoPlayer 从 SampleSource 获得 media samples 用于播放。下图展示了 ExoPlayer 是如何配置组合这些组件用于播放音视频的。
-	* standard-model
-	* ExoPlayer 库提供了一些不同类型的 SampleSource 实例：
-	* ExtractorSampleSource – 用于 MP3，M4A，WebM，MPEG-TS 和 AAC；
-		* ChunkSampleSource – 用于 DASH 和平滑流的播放；
-		* HlsSampleSource – 用于 HLS 播放；
-	* 在 ExoPlayer 的 Dome 中使用 DemoPlayer 对 ExoPlayer 进行了封装，并提供了使用上述几种 SampleSource 构建 TrackRenderer 的 Builder。
-		* SmoothStreamingRendererBuilder
-		* DashRendererBuilder
-		* ExtractorRendererBuilder
-	* 在使用的时候我们根据不同的需求创建对应的 RendererBuilder，然后将 RendererBuilder 传递给 DemoPlayer 然后调用 DemoPlayer 的 setPlayWhenReady 方法。
-* 2.3 优缺点
-* ExoPlayer 相较于 MediaPlayer 有很多很多的优点：
-	* 支持动态的自适应流 HTTP (DASH) 和 平滑流，任何目前 MediaPlayer 支持的视频格式（同时它还支持 HTTP 直播(HLS)，MP4，MP3，WebM，M4A，MPEG-TS 和 AAC）。
-	* 支持高级的 HLS 特性，例如正确处理 EXT-X-DISCONTINUITY 标签；
-	* 支持自定义和扩治你的使用场景。ExoPlayer 专门为此设计；
-	* 便于随着 App 的升级而升级。因为 ExoPlayer 是一个包含在你的应用中的库，对于你使用哪个版本有完全的控制权，并且你可以简单的跟随应用的升级而升级；
-	* 更少的适配性问题。
-* ExoPlayer 的缺点：
-	* ExoPlayer 的音频和视频组件依赖 Android 的 MediaCodec 接口，该接口发布于 Android4.1（API 等级 16）。因此它不能工作于之前的Android 版本。
 
+### 8.其他说明
 
 
-- **11.2.3.Vitamio 视频播放框架**
-* 3.1 用法
-* 官网：https://www.vitamio.org
-* Vitamio 的使用步骤：
-	* 1.下载 Vitamio 库，并作为工程依赖。
-	* 2.在 Activity 的 onCreate 方法中添加如下代码，初始化 Vitamio 的解码器
-* 3.2 优点
-	* 强大，支持超多格式视频和网络视频播放。
-	* 使用简单。调用非常简单，方便使用。
-	* 其官方还给出了其他很多优点，但是个人觉得不足以成为优点。
 
 
-- **11.2.4.Bilibili 开源视频播放框架ijkplayer**
-* 4.1 特点
-	* HTTPS支持
-	* 支持弹幕
-	* 支持基本的拖动，声音、亮度调节
-	* 支持边播边缓存
-	* 支持视频本身自带rotation的旋转（90,270之类），重力旋转与手动旋转的同步支持
-	* 支持列表播放，直接添加控件为封面，列表全屏动画，视频加载速度，列表小窗口支持拖动
-	* 5.0的过场效果，调整比例，多分辨率切换
-	* 支持切换播放器，进度条小窗口预览
-	* 其他一些小动画效果，rtsp、concat、mpeg
-* 4.2  优缺点
-	* ijkplayer 最大的优点就是可以根据需要编译需要的解码器。在编译的时候通过 ln -s module-default.sh module.sh 选择要编译的解码器。ijkplayer 在 config 目录下提供了三种 module.sh 。也可自己修改 module.sh 。
-	* ijkplayer 的缺点是库太大。加入项目后会大大增加你的 APP 的大小。
 
 
-#### 11.3 关于我的个人博客和站点
-- **github：** [https://github.com/yangchong211](https://github.com/yangchong211)
-- **知乎：** [https://www.zhihu.com/people/yang-chong-69-24/pins/posts](https://www.zhihu.com/people/yang-chong-69-24/pins/posts)
-- **简书：** [http://www.jianshu.com/u/b7b2c6ed9284](http://www.jianshu.com/u/b7b2c6ed9284)
-- **csdn：** [http://my.csdn.net/m0_37700275](http://my.csdn.net/m0_37700275)
-- **喜马拉雅听书：** [http://www.ximalaya.com/zhubo/71989305/](http://www.ximalaya.com/zhubo/71989305/)
-- 泡在网上的日子：[http://www.jcodecraeer.com/member/content_list.php?channelid=1](http://www.jcodecraeer.com/member/content_list.php?channelid=1)
-- 邮箱：yangchong211@163.com
-- 阿里云博客：[https://yq.aliyun.com/users/article?spm=5176.100239.headeruserinfo.3.dT4bcV](https://yq.aliyun.com/users/article?spm=5176.100239.headeruserinfo.3.dT4bcV)
 
 

YCVideoPlayerLib/build.gradle

@@ -1,18 +1,16 @@
 apply plugin: 'com.android.library'
 
 android {
-    compileSdkVersion 25
+    compileSdkVersion 27
     buildToolsVersion '27.0.3'
 
 
     defaultConfig {
-        minSdkVersion 17
-        targetSdkVersion 25
+        minSdkVersion 14
+        targetSdkVersion 27
         versionCode 1
         versionName "1.0"
-
         testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
-
     }
 
     buildTypes {
@@ -26,9 +24,9 @@ android {
 
 dependencies {
     compile fileTree(dir: 'libs', include: ['*.jar'])
-    compile 'com.android.support:appcompat-v7:25.4.0'
+    compile 'com.android.support:appcompat-v7:27.1.0'
     //这两个是必须要加的，其它的可供选择
-    compile 'tv.danmaku.ijk.media:ijkplayer-java:0.8.4'
+    compile 'tv.danmaku.ijk.media:ijkplayer-java:0.8.8'
     compile 'tv.danmaku.ijk.media:ijkplayer-armv7a:0.8.4'
     //其他库文件
     //compile 'tv.danmaku.ijk.media:ijkplayer-armv5:0.8.8'
@@ -51,7 +49,7 @@ group = "cn.yc"
 //发布到JCenter上的项目名字，必须填写
 def libName = "YCVideoPlayerLib"
 // 版本号，下次更新是只需要更改版本号即可
-version = "2.4.9"
+version = "2.6.0"
 /**  上面配置后上传至jcenter后的编译路径是这样的： compile 'cn.yc:YCVideoPlayerLib:2.4'  **/
 
 //生成源文件

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

@@ -1,4 +1,4 @@
-package org.yczbj.ycvideoplayerlib;
+package org.yczbj.ycvideoplayerlib.constant;
 
 import android.support.annotation.IntDef;
 
@@ -6,39 +6,30 @@ import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 
 /**
- * 常量
+ * <pre>
+ *     @author yangchong
+ *     blog  : https://github.com/yangchong211
+ *     time  : 2017/10/21
+ *     desc  : 常量
+ *     revise:
+ * </pre>
  */
-public class ConstantKeys {
+public final 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 = 1101;
-        int MEMBER = 1102;
+    public @interface IjkPlayerType {
+        int TYPE_IJK = 111;
+        int TYPE_NATIVE = 222;
     }
+    @IntDef({IjkPlayerType.TYPE_IJK,IjkPlayerType.TYPE_NATIVE})
+    public @interface PlayerType{}
+
 
     /**
      * 控制器上的视频顶部View点击事件
@@ -74,7 +65,7 @@ public class ConstantKeys {
      * 6                正在缓冲(播放器正在播放时，缓冲区数据不足，进行缓冲，此时暂停播放器，继续缓冲，缓冲区数据足够后恢复暂停
      * 7                播放完成
      */
-    protected @interface CurrentState{
+    public @interface CurrentState{
         int STATE_ERROR = -1;
         int STATE_IDLE = 0;
         int STATE_PREPARING = 1;
@@ -90,19 +81,13 @@ public class ConstantKeys {
      * 播放模式，普通模式，小窗口模式，正常模式三种其中一种
      */
     @Retention(RetentionPolicy.SOURCE)
-    protected @interface PlayMode {
+    public @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;
-    }
-
 
     /**
      * 通过注解限定类型
@@ -110,24 +95,13 @@ public class ConstantKeys {
      * 1，是仿腾讯加载loading，其实是帧动画
      * 2，是转圈加载loading，是补间动画
      */
-    @IntDef({Loading.LOADING_RING,Loading.LOADING_QQ})
-    @interface LoadingType{}
-
-
     @Retention(RetentionPolicy.SOURCE)
-    public  @interface TrySee {
+    public @interface Loading {
         int LOADING_RING = 1;
         int LOADING_QQ = 2;
     }
-
-    /**
-     * 视频试看结束后的类型，主要用于是看结束后展示不同的布局
-     * 如果不设置该方法，那么默认视频都是可以看的，默认是0
-     * 1，试看结束，观看全部内容请开通会员/购买。已是会员/已购买可登陆观看
-     * 2，试看结束，观看全部内容请开通会员。已是会员/已购买可登陆观看
-     * 3，试看结束, 登录后即可观看全部免费课程。
-     */
     @IntDef({Loading.LOADING_RING,Loading.LOADING_QQ})
-    @interface TrySeeType{}
+    public @interface LoadingType{}
+
 
 }

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

@@ -1,46 +1,34 @@
-package org.yczbj.ycvideoplayerlib;
+package org.yczbj.ycvideoplayerlib.controller;
 
 import android.content.Context;
 import android.support.annotation.DrawableRes;
+import android.support.annotation.LayoutRes;
 import android.util.DisplayMetrics;
-import android.view.KeyEvent;
 import android.view.MotionEvent;
 import android.view.View;
 import android.view.WindowManager;
 import android.widget.FrameLayout;
 import android.widget.ImageView;
 
-import java.util.ArrayList;
+import org.yczbj.ycvideoplayerlib.utils.VideoLogUtil;
+import org.yczbj.ycvideoplayerlib.utils.VideoPlayerUtils;
+import org.yczbj.ycvideoplayerlib.constant.ConstantKeys;
+import org.yczbj.ycvideoplayerlib.inter.InterVideoPlayer;
+
 import java.util.Timer;
 import java.util.TimerTask;
-import java.util.concurrent.ScheduledExecutorService;
 
 /**
- * @author yc
- * @date 2017/12/4
- * 参考项目：
- * https://github.com/CarGuo/GSYVideoPlayer
- * https://github.com/danylovolokh/VideoPlayerManager
- * https://github.com/HotBitmapGG/bilibili-android-client
- * https://github.com/jjdxmashl/jjdxm_ijkplayer
- * https://github.com/JasonChow1989/JieCaoVideoPlayer-develop          2年前
- * https://github.com/open-android/JieCaoVideoPlayer                   1年前
- * https://github.com/lipangit/JiaoZiVideoPlayer                       4个月前
- * 个人感觉jiaozi这个播放器，与JieCaoVideoPlayer-develop有惊人的类同，借鉴了上面两个项目[JieCao]
- *
- *
- * 注意：在对应的播放Activity页面，清单文件中一定要添加
- * android:configChanges="orientation|keyboardHidden|screenSize"
- * android:screenOrientation="portrait"
- *
- * 关于我的github：https://github.com/yangchong211
- * 关于我的个人网站：www.ycbjie.cn或者www.yczbj.org
- *
- * 控制器抽象类
+ * <pre>
+ *     @author yangchong
+ *     blog  : https://github.com/yangchong211
+ *     time  : 2017/10/21
+ *     desc  : 控制器抽象类
+ *     revise:
+ * </pre>
  */
 public abstract class AbsVideoPlayerController extends FrameLayout implements View.OnTouchListener {
 
-    private final DisplayMetrics dm;
     private Context mContext;
     protected InterVideoPlayer mVideoPlayer;
     private Timer mUpdateProgressTimer;
@@ -64,51 +52,43 @@ public abstract class AbsVideoPlayerController extends FrameLayout implements Vi
     private float mGestureDownBrightness;
     private int mGestureDownVolume;
     private long mNewPosition;
-    private ScheduledExecutorService pool;
 
 
     public AbsVideoPlayerController(Context context) {
         super(context);
         mContext = context;
         this.setOnTouchListener(this);
-        dm = new DisplayMetrics();//获取屏幕宽高，处理越界的时候用到
     }
 
     public void setVideoPlayer(InterVideoPlayer videoPlayer) {
         mVideoPlayer = videoPlayer;
     }
 
-    /**
-     * 设置是否显示视频头部的下载，分享布局控件
-     * @param isVisibility          是否可见
-     */
-    public abstract void setTopVisibility(boolean isVisibility);
 
     /**
-     * 设置试看视频时间，让使用者自己定制
-     * @param time                  时间
+     * 获取是否是锁屏模式
+     * @return                      true表示锁屏
      */
-    public abstract void setTrySeeTime(boolean isSee , long time);
+    public abstract boolean getLock();
 
     /**
-     * 设置不操作后，多久自动隐藏头部和底部布局
-     * @param time                  时间
+     * 设置视频播放器中间的播放键是否显示，设置自定义图片
+     * @param isVisibility          是否可见
+     * @param image                 image
      */
-    public abstract void setHideTime(long time);
+    public abstract void setCenterPlayer(boolean isVisibility ,@DrawableRes int image);
 
     /**
-     * 设置会员权限话术内容
-     * @param memberContent         集合
+     * 设置是否显示视频头部的下载，分享布局控件
+     * @param isVisibility          是否可见
      */
-    public abstract void setMemberContent(ArrayList<String> memberContent);
-
+    public abstract void setTopVisibility(boolean isVisibility);
 
     /**
-     * 设置会员权限类型
-     * @param isLogin   是否登录
-     * @param type      视频类型
+     * 设置不操作后，多久自动隐藏头部和底部布局
+     * @param time                  时间
      */
-    public abstract void setMemberType(boolean isLogin ,int type);
+    public abstract void setHideTime(long time);
 
 
     /**
@@ -156,46 +136,25 @@ public abstract class AbsVideoPlayerController extends FrameLayout implements Vi
      *
      * @param playState 播放状态：
      */
-    protected abstract void onPlayStateChanged(int playState);
+    public abstract void onPlayStateChanged(int playState);
 
     /**
      * 当播放器的播放模式发生变化，在此方法中更新不同模式下的控制器界面。
      *
      * @param playMode 播放器的模式：
      */
-    protected abstract void onPlayModeChanged(int playMode);
+    public abstract void onPlayModeChanged(int playMode);
 
     /**
      * 重置控制器，将控制器恢复到初始状态。
      */
-    protected abstract void reset();
+    public abstract void reset();
 
     /**
      * 开启更新进度的计时器。
      */
     protected void startUpdateProgressTimer() {
         cancelUpdateProgressTimer();
-        // Java并发，Timer的缺陷，用ScheduledExecutorService替代
-        /*if(pool==null){
-            pool = Executors.newScheduledThreadPool(1);
-            //pool = Executors.newSingleThreadScheduledExecutor();
-        }
-        if (mUpdateProgressTimerTask == null) {
-            mUpdateProgressTimerTask = new TimerTask() {
-                @Override
-                public void run() {
-                    AbsVideoPlayerController.this.post(new Runnable() {
-                        @Override
-                        public void run() {
-                            updateProgress();
-                        }
-                    });
-                }
-            };
-        }
-        pool.scheduleWithFixedDelay(mUpdateProgressTimerTask,0,1000, TimeUnit.MILLISECONDS);*/
-
-
         if (mUpdateProgressTimer == null) {
             mUpdateProgressTimer = new Timer();
         }
@@ -238,6 +197,52 @@ public abstract class AbsVideoPlayerController extends FrameLayout implements Vi
     protected abstract void updateProgress();
 
 
+
+    /**
+     * 手势左右滑动改变播放位置时，显示控制器中间的播放位置变化视图，
+     * 在手势滑动ACTION_MOVE的过程中，会不断调用此方法。
+     *
+     * @param duration            视频总时长ms
+     * @param newPositionProgress 新的位置进度，取值0到100。
+     */
+    protected abstract void showChangePosition(long duration, int newPositionProgress);
+
+
+    /**
+     * 手势左右滑动改变播放位置后，手势up或者cancel时，隐藏控制器中间的播放位置变化视图，
+     * 在手势ACTION_UP或ACTION_CANCEL时调用。
+     */
+    protected abstract void hideChangePosition();
+
+
+    /**
+     * 手势在右侧上下滑动改变音量时，显示控制器中间的音量变化视图，
+     * 在手势滑动ACTION_MOVE的过程中，会不断调用此方法。
+     *
+     * @param newVolumeProgress 新的音量进度，取值1到100。
+     */
+    protected abstract void showChangeVolume(int newVolumeProgress);
+
+    /**
+     * 手势在左侧上下滑动改变音量后，手势up或者cancel时，隐藏控制器中间的音量变化视图，
+     * 在手势ACTION_UP或ACTION_CANCEL时调用。
+     */
+    protected abstract void hideChangeVolume();
+
+    /**
+     * 手势在左侧上下滑动改变亮度时，显示控制器中间的亮度变化视图，
+     * 在手势滑动ACTION_MOVE的过程中，会不断调用此方法。
+     *
+     * @param newBrightnessProgress 新的亮度进度，取值1到100。
+     */
+    protected abstract void showChangeBrightness(int newBrightnessProgress);
+
+    /**
+     * 手势在左侧上下滑动改变亮度后，手势up或者cancel时，隐藏控制器中间的亮度变化视图，
+     * 在手势ACTION_UP或ACTION_CANCEL时调用。
+     */
+    protected abstract void hideChangeBrightness();
+
     /**
      * 滑动处理调节声音和亮度的逻辑
      * @param v                         v
@@ -250,101 +255,14 @@ public abstract class AbsVideoPlayerController extends FrameLayout implements Vi
         //boolean tinyWindow = mVideoPlayer.isTinyWindow();
         int playType = mVideoPlayer.getPlayType();
         //如果是小窗口模式，则可以拖拽。其他情况则正常处理
-        if(playType == ConstantKeys.PlayMode.MODE_TINY_WINDOW){
-            return setTinyWindowTouch(v,event);
-        }else {
+        if(playType == ConstantKeys.PlayMode.MODE_FULL_SCREEN){
             //处理全屏播放时，滑动处理调节声音和亮度的逻辑
             return setOnTouch(v,event);
         }
+        return false;
     }
 
 
-    /**
-     * 如果是小窗口模式，则可以拖拽。其他情况则正常处理
-     * 问题：
-     * 1.按钮拖动的界限限定。
-     * 2.按钮单击和拖动之间的冲突。
-     * 3.在界面未显示之前，获得View的高/宽。
-     * @param v                         v
-     * @param event                     event
-     * @return                          是否自己处理滑动事件
-     */
-    private boolean setTinyWindowTouch(View v, MotionEvent event) {
-        switch (event.getAction() & MotionEvent.ACTION_MASK){
-            case MotionEvent.ACTION_DOWN:
-                onTouchDown(event);
-                break;
-            case MotionEvent.ACTION_MOVE:
-                onTouchMove(v,event);
-                break;
-            case MotionEvent.ACTION_UP:
-                isOver(v);
-                break;
-        }
-        //v.invalidate();
-        return true;
-    }
-
-    //相对于父控件的触摸位置，用于处理拖拽
-    private float xDown,yDown,xUp,yUp;
-    private int extra;
-
-    /** 按下 **/
-    private void onTouchDown(MotionEvent event){
-        xDown = event.getX();
-        yDown = event.getY();
-        xUp = event.getRawX();
-        yUp = event.getRawY();
-        extra = (int) (yUp - yDown - getTop());
-        VideoLogUtil.i("AbsPlayer"+"onTouchDown"+xDown+"----"+yDown+"----"+xUp+"----"+yUp+"----"+extra);
-    }
-
-
-    /** 拖拽 **/
-    private void onTouchMove(View view, MotionEvent event) {
-        int left, right, top, bottom;
-        top = (int) (yUp - yDown) - extra;
-        bottom = top + getHeight();
-        left = (int) (xUp - xDown);
-        right = left + getWidth();
-        //Top position, relative to parent这是该方法其中top参数的官方解释，反正我是被误导了，我不知道这个父亲到底是怎样定义的
-        // 我目前的理解是它的所有参数位置是相对于该view放置的那个xml布局的位置，那个xml布局最外面的那个layout才是父view。
-        //为什么要说的这么绕，就是它的位置不是相对屏幕的，因为你的应用可能有tab占了位置，那块位置就不能算。如果理解了这些话就能知道为什么会有extra了。
-        view.layout(left, top, right, bottom);
-        xUp = event.getRawX();
-        yUp = event.getRawY();
-        VideoLogUtil.i("AbsPlayer"+"onTouchMove"+left+"----"+top+"----"+right+"----"+bottom);
-    }
-
-    /**
-     * 拖拽时判断是否越界
-     */
-    private void isOver(View v) {
-        int width = this.getWidth()/3;
-        int height = this.getHeight()/3;
-        int left = getLeft(),right=getRight(),top=getTop(),bottom=getBottom();
-        //针对整个可用屏幕的越界,必须还能看到控件的1/3
-        if (this.getBottom() < height){
-            bottom = height;
-            top = bottom - getHeight();
-        }
-        if (this.getRight() <  width){
-            right = width;
-            left = right - getWidth();
-        }
-        if (this.getTop() > dm.heightPixels - extra - height){
-            top = dm.heightPixels - extra - height;
-            bottom = top + getHeight();
-        }
-        if (this.getLeft() > dm.widthPixels - width){
-            left = dm.widthPixels - width;
-            right = left + getWidth();
-        }
-        if (this.getBottom() < height || this.getLeft() < - width || this.getRight() > dm.widthPixels - width || this.getTop() > dm.heightPixels - extra - height) {
-            v.layout(left, top, right, bottom);
-        }
-    }
-
     /**
      * 处理全屏播放时，滑动处理调节声音和亮度的逻辑
      * @param v                         v
@@ -458,49 +376,4 @@ public abstract class AbsVideoPlayerController extends FrameLayout implements Vi
         return false;
     }
 
-
-    /**
-     * 手势左右滑动改变播放位置时，显示控制器中间的播放位置变化视图，
-     * 在手势滑动ACTION_MOVE的过程中，会不断调用此方法。
-     *
-     * @param duration            视频总时长ms
-     * @param newPositionProgress 新的位置进度，取值0到100。
-     */
-    protected abstract void showChangePosition(long duration, int newPositionProgress);
-
-
-    /**
-     * 手势左右滑动改变播放位置后，手势up或者cancel时，隐藏控制器中间的播放位置变化视图，
-     * 在手势ACTION_UP或ACTION_CANCEL时调用。
-     */
-    protected abstract void hideChangePosition();
-
-
-    /**
-     * 手势在右侧上下滑动改变音量时，显示控制器中间的音量变化视图，
-     * 在手势滑动ACTION_MOVE的过程中，会不断调用此方法。
-     *
-     * @param newVolumeProgress 新的音量进度，取值1到100。
-     */
-    protected abstract void showChangeVolume(int newVolumeProgress);
-
-    /**
-     * 手势在左侧上下滑动改变音量后，手势up或者cancel时，隐藏控制器中间的音量变化视图，
-     * 在手势ACTION_UP或ACTION_CANCEL时调用。
-     */
-    protected abstract void hideChangeVolume();
-
-    /**
-     * 手势在左侧上下滑动改变亮度时，显示控制器中间的亮度变化视图，
-     * 在手势滑动ACTION_MOVE的过程中，会不断调用此方法。
-     *
-     * @param newBrightnessProgress 新的亮度进度，取值1到100。
-     */
-    protected abstract void showChangeBrightness(int newBrightnessProgress);
-
-    /**
-     * 手势在左侧上下滑动改变亮度后，手势up或者cancel时，隐藏控制器中间的亮度变化视图，
-     * 在手势ACTION_UP或ACTION_CANCEL时调用。
-     */
-    protected abstract void hideChangeBrightness();
 }

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

@@ -1,20 +1,17 @@
-package org.yczbj.ycvideoplayerlib;
+package org.yczbj.ycvideoplayerlib.controller;
 
 import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
 import android.content.IntentFilter;
-import android.graphics.Color;
 import android.net.ConnectivityManager;
 import android.net.NetworkInfo;
 import android.os.BatteryManager;
 import android.os.CountDownTimer;
 import android.support.annotation.DrawableRes;
-import android.view.KeyEvent;
 import android.view.LayoutInflater;
 import android.view.MotionEvent;
 import android.view.View;
-import android.widget.Button;
 import android.widget.FrameLayout;
 import android.widget.ImageView;
 import android.widget.LinearLayout;
@@ -23,12 +20,18 @@ import android.widget.SeekBar;
 import android.widget.TextView;
 import android.widget.Toast;
 
-import org.yczbj.ycvideoplayerlib.listener.OnClarityChangedListener;
-import org.yczbj.ycvideoplayerlib.listener.OnCompletedListener;
-import org.yczbj.ycvideoplayerlib.listener.OnMemberClickListener;
-import org.yczbj.ycvideoplayerlib.listener.OnPlayOrPauseListener;
-import org.yczbj.ycvideoplayerlib.listener.OnVideoBackListener;
-import org.yczbj.ycvideoplayerlib.listener.OnVideoControlListener;
+import org.yczbj.ycvideoplayerlib.dialog.ChangeClarityDialog;
+import org.yczbj.ycvideoplayerlib.R;
+import org.yczbj.ycvideoplayerlib.dialog.VideoClarity;
+import org.yczbj.ycvideoplayerlib.utils.VideoLogUtil;
+import org.yczbj.ycvideoplayerlib.utils.VideoPlayerUtils;
+import org.yczbj.ycvideoplayerlib.constant.ConstantKeys;
+import org.yczbj.ycvideoplayerlib.inter.InterVideoPlayer;
+import org.yczbj.ycvideoplayerlib.inter.listener.OnClarityChangedListener;
+import org.yczbj.ycvideoplayerlib.inter.listener.OnCompletedListener;
+import org.yczbj.ycvideoplayerlib.inter.listener.OnPlayOrPauseListener;
+import org.yczbj.ycvideoplayerlib.inter.listener.OnVideoBackListener;
+import org.yczbj.ycvideoplayerlib.inter.listener.OnVideoControlListener;
 
 import java.text.SimpleDateFormat;
 import java.util.ArrayList;
@@ -36,36 +39,16 @@ import java.util.Date;
 import java.util.List;
 import java.util.Locale;
 
+
 /**
- * @author yc
- * @date 2017/9/4
- * 参考项目：
- * https://github.com/CarGuo/GSYVideoPlayer
- * https://github.com/danylovolokh/VideoPlayerManager
- * https://github.com/HotBitmapGG/bilibili-android-client
- * https://github.com/jjdxmashl/jjdxm_ijkplayer
- * https://github.com/JasonChow1989/JieCaoVideoPlayer-develop          2年前
- * https://github.com/open-android/JieCaoVideoPlayer                   1年前
- * https://github.com/lipangit/JiaoZiVideoPlayer                       4个月前
- * 个人感觉jiaozi这个播放器，与JieCaoVideoPlayer-develop有惊人的类同，借鉴了上面两个项目[JieCao]
- *
- *
- * 注意：在对应的播放Activity页面，清单文件中一定要添加
- * android:configChanges="orientation|keyboardHidden|screenSize"
- * android:screenOrientation="portrait"
- *
- * 关于我的github：https://github.com/yangchong211
- * 关于我的个人网站：www.ycbjie.cn或者www.yczbj.org
- *
- * 仿视频热点列表页播放器控制器
- * 播放控制界面上，播放、暂停、播放进度、缓冲动画、全屏/小屏等触发都是直接调用播放器对应的操作的。
- * 注意：建议先判断状态，再进行设置参数
- *
- * 会员制需求：
- * 1.是会员，可以全部观看
- * 2.非会员，可以试看，试看完后谈试看视图
+ * <pre>
+ *     @author yangchong
+ *     blog  : https://github.com/yangchong211
+ *     time  : 2017/9/29
+ *     desc  : 播放器控制器，主要是处理UI操作逻辑
+ *     revise: 注意：建议先判断状态，再进行设置参数
+ * </pre>
  */
-
 public class VideoPlayerController extends AbsVideoPlayerController implements View.OnClickListener{
 
     private Context mContext;
@@ -111,10 +94,6 @@ public class VideoPlayerController extends AbsVideoPlayerController implements V
     private LinearLayout mCompleted;
     private TextView mReplay;
     private TextView mShare;
-    private LinearLayout mLlTrySee;
-    private TextView mTvSeeContent;
-    private Button mBtnVip;
-    private ImageView mIvTrySee;
     private FrameLayout mFlLock;
     private ImageView mIvLock;
 
@@ -134,43 +113,24 @@ public class VideoPlayerController extends AbsVideoPlayerController implements V
      * 是否已经注册了网络监听广播，添加这个判断可以避免崩溃
      */
     private boolean hasRegisterNetReceiver;
-    /**
-     * 试看类型 setMemberType 如果不设置该方法，那么默认视频都是可以看的
-     */
-    private int mType = 0;
-    /**
-     * 是否有观看权限
-     */
-    private boolean mIsSee = false;
-    /**
-     * 是否登录
-     */
-    private boolean mIsLogin = true;
-    /**
-     * 是否看完
-     */
-    private boolean mSeeEnd = true;
     /**
      * 是否锁屏
      */
     private boolean mIsLock = false;
-    /**
-     * 会员权限话术内容
-     */
-    private ArrayList<String> mMemberContent;
     /**
      * 这个是time时间不操作界面，则自动隐藏顶部和底部视图布局
      */
     private long time;
     /**
-     * 这个是设置试看时间，当然前提是设置试看权限后才能生效，如果不设置，默认为30秒
+     * 顶部的布局，下载，切换音频，分享布局是否显示。
+     * 默认为false，不显示
      */
-    private long mTrySeeTime;
+    private boolean mIsTopAndBottomVisibility = false;
     /**
-     * 顶部的布局，下载，切换音频，分享布局是否显示
+     * 设置视频播放器中间的播放键是否显示
      * 默认为false，不显示
      */
-    private boolean mIsTopVisibility = false;
+    private boolean mIsCenterPlayerVisibility = false;
 
     /**
      * 网络变化监听广播，在网络变更时进行对应处理
@@ -244,33 +204,6 @@ public class VideoPlayerController extends AbsVideoPlayerController implements V
         }
     };
 
-    /**
-     * 如果锁屏，则屏蔽返回键
-     */
-    @Override
-    public boolean onKeyDown(int keyCode, KeyEvent event) {
-        if(keyCode == KeyEvent.KEYCODE_BACK){
-            VideoLogUtil.i("1如果锁屏，则屏蔽返回键");
-            if(mIsLock){
-                //如果锁屏，那就屏蔽返回键
-                return true;
-            }
-        }
-        return super.onKeyDown(keyCode, event);
-    }
-
-
-    /**
-     * 如果锁屏，则屏蔽滑动事件
-     */
-    @Override
-    public boolean onTouchEvent(MotionEvent event) {
-        if(mIsLock){
-            //如果锁屏了，那就就不需要处理滑动的逻辑
-            return false;
-        }
-        return super.onTouchEvent(event);
-    }
 
     public VideoPlayerController(Context context) {
         super(context);
@@ -312,62 +245,54 @@ public class VideoPlayerController extends AbsVideoPlayerController implements V
     }
 
     private void initFindViewById() {
-        mCenterStart = (ImageView) findViewById(R.id.center_start);
-        mImage = (ImageView) findViewById(R.id.image);
-
-        mTop = (LinearLayout) findViewById(R.id.top);
-        mBack = (ImageView) findViewById(R.id.back);
-        mTitle = (TextView) findViewById(R.id.title);
-        mLlTopOther = (LinearLayout) findViewById(R.id.ll_top_other);
-        mIvDownload = (ImageView) findViewById(R.id.iv_download);
-        mIvAudio = (ImageView) findViewById(R.id.iv_audio);
-        mIvShare = (ImageView) findViewById(R.id.iv_share);
-        mIvMenu = (ImageView) findViewById(R.id.iv_menu);
-
-        mLlHorizontal = (LinearLayout) findViewById(R.id.ll_horizontal);
-        mIvHorAudio = (ImageView) findViewById(R.id.iv_hor_audio);
-        mIvHorTv = (ImageView) findViewById(R.id.iv_hor_tv);
-        mBattery = (ImageView) findViewById(R.id.battery);
-        mTime = (TextView) findViewById(R.id.time);
-
-        mBottom = (LinearLayout) findViewById(R.id.bottom);
-        mRestartPause = (ImageView) findViewById(R.id.restart_or_pause);
-        mPosition = (TextView) findViewById(R.id.position);
-        mDuration = (TextView) findViewById(R.id.duration);
-        mSeek = (SeekBar) findViewById(R.id.seek);
-        mFullScreen = (ImageView) findViewById(R.id.full_screen);
-        mClarity = (TextView) findViewById(R.id.clarity);
-        mLength = (TextView) findViewById(R.id.length);
-        mLoading = (LinearLayout) findViewById(R.id.loading);
-        pbLoadingRing = (ProgressBar)findViewById(R.id.pb_loading_ring);
-        pbLoadingQq = (ProgressBar)findViewById(R.id.pb_loading_qq);
-
-        mLoadText = (TextView) findViewById(R.id.load_text);
-        mChangePosition = (LinearLayout) findViewById(R.id.change_position);
-        mChangePositionCurrent = (TextView) findViewById(R.id.change_position_current);
-        mChangePositionProgress = (ProgressBar) findViewById(R.id.change_position_progress);
-        mChangeBrightness = (LinearLayout) findViewById(R.id.change_brightness);
-        mChangeBrightnessProgress = (ProgressBar) findViewById(R.id.change_brightness_progress);
-        mChangeVolume = (LinearLayout) findViewById(R.id.change_volume);
-        mChangeVolumeProgress = (ProgressBar) findViewById(R.id.change_volume_progress);
-
-        mError = (LinearLayout) findViewById(R.id.error);
-        mRetry = (TextView) findViewById(R.id.retry);
-        mCompleted = (LinearLayout) findViewById(R.id.completed);
-        mReplay = (TextView) findViewById(R.id.replay);
-        mShare = (TextView) findViewById(R.id.share);
-        mLlTrySee = (LinearLayout) findViewById(R.id.ll_try_see);
-        mTvSeeContent = (TextView)findViewById(R.id.tv_see_content);
-        mBtnVip = (Button)findViewById(R.id.btn_vip);
-        mIvTrySee = (ImageView) findViewById(R.id.iv_try_see);
-        mFlLock = (FrameLayout) findViewById(R.id.fl_lock);
-        mIvLock = (ImageView) findViewById(R.id.iv_lock);
-
-        if(mIsTopVisibility){
-            mLlTopOther.setVisibility(VISIBLE);
-        }else {
-            mLlTopOther.setVisibility(GONE);
-        }
+        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);
+        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);
+
+        setTopVisibility(mIsTopAndBottomVisibility);
     }
 
 
@@ -390,8 +315,6 @@ public class VideoPlayerController extends AbsVideoPlayerController implements V
         mRetry.setOnClickListener(this);
         mReplay.setOnClickListener(this);
         mShare.setOnClickListener(this);
-        mBtnVip.setOnClickListener(this);
-        mIvTrySee.setOnClickListener(this);
         mFlLock.setOnClickListener(this);
         mSeek.setOnSeekBarChangeListener(new SeekBar.OnSeekBarChangeListener() {
             @Override
@@ -404,7 +327,6 @@ public class VideoPlayerController extends AbsVideoPlayerController implements V
 
             }
 
-
             @Override
             public void onStopTrackingTouch(SeekBar seekBar) {
                 if (mVideoPlayer.isBufferingPaused() || mVideoPlayer.isPaused()) {
@@ -418,6 +340,23 @@ public class VideoPlayerController extends AbsVideoPlayerController implements V
         this.setOnClickListener(this);
     }
 
+    /**
+     * 设置视频播放器中间的播放键是否显示，设置自定义图片
+     * @param isVisibility          是否可见
+     * @param image                 image
+     */
+    @Override
+    public void setCenterPlayer(boolean isVisibility, @DrawableRes int image) {
+        this.mIsCenterPlayerVisibility = isVisibility;
+        if(isVisibility){
+            if(image==0){
+                mCenterStart.setImageResource(R.drawable.ic_player_center_start);
+            }else {
+                mCenterStart.setImageResource(image);
+            }
+        }
+    }
+
 
     /**
      * 18年3月15日添加
@@ -426,7 +365,7 @@ public class VideoPlayerController extends AbsVideoPlayerController implements V
      */
     @Override
     public void setTopVisibility(boolean isVisibility) {
-        this.mIsTopVisibility = isVisibility;
+        this.mIsTopAndBottomVisibility = isVisibility;
         if(isVisibility){
             mLlTopOther.setVisibility(VISIBLE);
         }else {
@@ -464,44 +403,6 @@ public class VideoPlayerController extends AbsVideoPlayerController implements V
     }
 
 
-    /**
-     * 设置试看视频时间，让使用者自己定制
-     * @param isSee                 是否可以试看，如果可以试看那么出现试看布局。默认是没有试看功能，也就是正常播放
-     * @param time                  时间
-     */
-    @Override
-    public void setTrySeeTime(boolean isSee , long time) {
-        this.mIsSee = isSee;
-        this.mTrySeeTime = time;
-    }
-
-
-    /**
-     * 18年1月12号添加
-     * 设置会员权限类型
-     * @param isLogin   是否登录
-     * @param type      视频试看类型
-     *                  0
-     *                  1
-     *                  2
-     *                  3
-     */
-    @Override
-    public void setMemberType(boolean isLogin, int type) {
-        this.mIsLogin = isLogin;
-        this.mType = type;
-    }
-
-    /**
-     * 设置会员权限话术内容
-     * @param memberContent         集合
-     */
-    @Override
-    public void setMemberContent(ArrayList<String> memberContent) {
-        this.mMemberContent = memberContent;
-    }
-
-
     /**
      * 设置不操作后，多久自动隐藏头部和底部布局
      * @param time                  时间
@@ -576,6 +477,27 @@ public class VideoPlayerController extends AbsVideoPlayerController implements V
     }
 
 
+
+    /**
+     * 获取是否是锁屏模式
+     * @return              true表示锁屏
+     */
+    @Override
+    public boolean getLock() {
+        return mIsLock;
+    }
+
+    /**
+     * 如果锁屏，则屏蔽滑动事件
+     */
+    @Override
+    public boolean onTouchEvent(MotionEvent event) {
+        VideoLogUtil.i("如果锁屏2，则屏蔽返回键");
+        //如果锁屏了，那就就不需要处理滑动的逻辑
+        return !getLock() && super.onTouchEvent(event);
+    }
+
+
     /**
      * 设置视频清晰度
      * @param clarities                         清晰度
@@ -627,7 +549,7 @@ public class VideoPlayerController extends AbsVideoPlayerController implements V
      * @param playState 播放状态：
      */
     @Override
-    protected void onPlayStateChanged(int playState) {
+    public void onPlayStateChanged(int playState) {
         switch (playState) {
             case ConstantKeys.CurrentState.STATE_IDLE:
                 break;
@@ -650,18 +572,21 @@ public class VideoPlayerController extends AbsVideoPlayerController implements V
             //正在播放
             case ConstantKeys.CurrentState.STATE_PLAYING:
                 mLoading.setVisibility(View.GONE);
+                mCenterStart.setVisibility(View.GONE);
                 mRestartPause.setImageResource(R.drawable.ic_player_pause);
                 startDismissTopBottomTimer();
                 break;
             //暂停播放
             case ConstantKeys.CurrentState.STATE_PAUSED:
                 mLoading.setVisibility(View.GONE);
+                mCenterStart.setVisibility(mIsCenterPlayerVisibility?View.VISIBLE:View.GONE);
                 mRestartPause.setImageResource(R.drawable.ic_player_start);
                 cancelDismissTopBottomTimer();
                 break;
             //正在缓冲(播放器正在播放时，缓冲区数据不足，进行缓冲，缓冲区数据足够后恢复播放)
             case ConstantKeys.CurrentState.STATE_BUFFERING_PLAYING:
                 mLoading.setVisibility(View.VISIBLE);
+                mCenterStart.setVisibility(View.GONE);
                 mRestartPause.setImageResource(R.drawable.ic_player_pause);
                 mLoadText.setText("正在缓冲...");
                 startDismissTopBottomTimer();
@@ -704,7 +629,7 @@ public class VideoPlayerController extends AbsVideoPlayerController implements V
      * @param playMode 播放器的模式：
      */
     @Override
-    protected void onPlayModeChanged(int playMode) {
+    public void onPlayModeChanged(int playMode) {
         switch (playMode) {
             //普通模式
             case ConstantKeys.PlayMode.MODE_NORMAL:
@@ -713,11 +638,7 @@ public class VideoPlayerController extends AbsVideoPlayerController implements V
                 mFullScreen.setImageResource(R.drawable.ic_player_enlarge);
                 mFullScreen.setVisibility(View.VISIBLE);
                 mClarity.setVisibility(View.GONE);
-                if(mIsTopVisibility){
-                    mLlTopOther.setVisibility(VISIBLE);
-                }else {
-                    mLlTopOther.setVisibility(GONE);
-                }
+                setTopVisibility(mIsTopAndBottomVisibility);
                 mLlHorizontal.setVisibility(View.GONE);
                 if (hasRegisterBatteryReceiver) {
                     mContext.unregisterReceiver(mBatterReceiver);
@@ -735,7 +656,11 @@ public class VideoPlayerController extends AbsVideoPlayerController implements V
                     mClarity.setVisibility(View.VISIBLE);
                 }
                 mLlTopOther.setVisibility(GONE);
-                mLlHorizontal.setVisibility(View.VISIBLE);
+                if (mIsTopAndBottomVisibility){
+                    mLlHorizontal.setVisibility(View.VISIBLE);
+                }else {
+                    mLlHorizontal.setVisibility(View.GONE);
+                }
                 if (!hasRegisterBatteryReceiver) {
                     mContext.registerReceiver(mBatterReceiver, new IntentFilter(Intent.ACTION_BATTERY_CHANGED));
                     hasRegisterBatteryReceiver = true;
@@ -758,25 +683,14 @@ public class VideoPlayerController extends AbsVideoPlayerController implements V
      * 重新设置
      */
     @Override
-    protected void reset() {
+    public void reset() {
         topBottomVisible = false;
         cancelUpdateProgressTimer();
         cancelDismissTopBottomTimer();
         mSeek.setProgress(0);
         mSeek.setSecondaryProgress(0);
-
-
-        //添加，试看视频
-        if (mIsSee || !mIsLogin) {
-            mIvTrySee.setVisibility(VISIBLE);
-            mCenterStart.setVisibility(GONE);
-            mLength.setVisibility(View.GONE);
-        }else{
-            mIvTrySee.setVisibility(GONE);
-            mCenterStart.setVisibility(VISIBLE);
-            mLength.setVisibility(View.VISIBLE);
-        }
-
+        mCenterStart.setVisibility(VISIBLE);
+        mLength.setVisibility(View.VISIBLE);
         mFlLock.setVisibility(View.GONE);
         mImage.setVisibility(View.VISIBLE);
         mBottom.setVisibility(View.GONE);
@@ -800,6 +714,10 @@ public class VideoPlayerController extends AbsVideoPlayerController implements V
             //开始播放
             if (mVideoPlayer.isIdle()) {
                 mVideoPlayer.start();
+            }else if (mVideoPlayer.isPlaying() || mVideoPlayer.isBufferingPlaying()) {
+                mVideoPlayer.pause();
+            } else if (mVideoPlayer.isPaused() || mVideoPlayer.isBufferingPaused()) {
+                mVideoPlayer.restart();
             }
         } else if (v == mBack) {
             //退出，执行返回逻辑
@@ -869,33 +787,6 @@ public class VideoPlayerController extends AbsVideoPlayerController implements V
         } else if (v == mShare) {
             //分享
             Toast.makeText(mContext, "分享", Toast.LENGTH_SHORT).show();
-        } else if (v == mIvTrySee){
-            //点击试看按钮，也是播放
-            if (mVideoPlayer.isIdle()) {
-                mVideoPlayer.start();
-            }
-            mIvTrySee.setVisibility(GONE);
-        } else if (v == mBtnVip){
-            if(mClickListener==null){
-                VideoLogUtil.d("请在初始化的时候设置监听事件");
-                return;
-            }
-            //点击vip按钮，第一种情况是跳转登录，第二种情况是跳转购买会员页面
-            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(v == mFlLock){
             //点击锁屏按钮，则进入锁屏模式
             setLock(mIsLock);
@@ -944,20 +835,7 @@ public class VideoPlayerController extends AbsVideoPlayerController implements V
         }  else if (v == this) {
             if (mVideoPlayer.isPlaying() || mVideoPlayer.isPaused()
                     || mVideoPlayer.isBufferingPlaying() || mVideoPlayer.isBufferingPaused()) {
-                if(mTrySeeTime==0){
-                    mTrySeeTime = 300000;
-                }
-
-                if(mVideoPlayer.getCurrentPosition()>mTrySeeTime){
-                    //在试看3分钟外
-                    //如果没有登录或者没有观看权限，则隐藏底部和顶部视图
-                    if(mIsLogin || mIsSee){
-                        setTopBottomVisible(!topBottomVisible);
-                    }
-                }else {
-                    //在试看3分钟内，点击界面可以显示或者隐藏顶部底部视图
-                    setTopBottomVisible(!topBottomVisible);
-                }
+                setTopBottomVisible(!topBottomVisible);
             }
         }
     }
@@ -968,18 +846,8 @@ public class VideoPlayerController extends AbsVideoPlayerController implements V
      * @param visible true显示，false隐藏.
      */
     private void setTopBottomVisible(boolean visible) {
-        //如果显示为立即登录或者购买会员的布局，则不隐藏<箭头
-        if(mLlTrySee.getVisibility() == View.VISIBLE){
-            mTop.setVisibility(View.VISIBLE);
-            mTitle.setVisibility(View.VISIBLE);
-        }else {
-            mTop.setVisibility(visible ? View.VISIBLE : View.GONE);
-        }
-        if(visible){
-            mBottom.setVisibility(View.VISIBLE);
-        }else {
-            mBottom.setVisibility(View.GONE);
-        }
+        mTop.setVisibility(visible ? View.VISIBLE : View.GONE);
+        mBottom.setVisibility(visible ? View.VISIBLE : View.GONE);
         topBottomVisible = visible;
         if (visible) {
             if (!mVideoPlayer.isPaused() && !mVideoPlayer.isBufferingPaused()) {
@@ -1049,15 +917,6 @@ public class VideoPlayerController extends AbsVideoPlayerController implements V
     }
 
 
-
-    /**
-     * 获取是否是锁屏模式
-     * @return              true表示锁屏
-     */
-    public boolean getLock(){
-        return mIsLock;
-    }
-
     /**
      * 更新播放进度
      */
@@ -1076,76 +935,8 @@ public class VideoPlayerController extends AbsVideoPlayerController implements V
         mDuration.setText(VideoPlayerUtils.formatTime(duration));
         // 更新时间
         mTime.setText(new SimpleDateFormat("HH:mm", Locale.CHINA).format(new Date()));
-
-
-
-        //避免更新中多次走这个方法
-        if(mIsSee && mSeeEnd && position >= mTrySeeTime){
-            // 试看结束
-            setVideoTrySeeEnd();
-        }
     }
 
-
-    /**
-     * 设置试看播放结束
-     */
-    private void setVideoTrySeeEnd() {
-        //先暂停播放
-        mVideoPlayer.pause();
-        mSeeEnd = false;
-        mLoading.setVisibility(GONE);
-        mImage.setVisibility(View.VISIBLE);
-        mImage.setBackgroundColor(Color.BLACK);
-        //取消计时器
-        cancelUpdateProgressTimer();
-        cancelDismissTopBottomTimer();
-        //隐藏底部面板
-        mBottom.setVisibility(View.GONE);
-        //设置顶部返回键可见
-        mTop.setVisibility(View.VISIBLE);
-        mBack.setVisibility(View.VISIBLE);
-
-        mLlTrySee.setVisibility(VISIBLE);
-        String seeContent = "";
-        if (mIsLogin) {
-            //试看结束，观看全部内容请开通会员
-            if(mMemberContent!=null && mMemberContent.size()>0 && mMemberContent.get(0)!=null){
-                seeContent = mMemberContent.get(0);
-            }else {
-                seeContent = ConstantKeys.LOGIN_TEXT;
-            }
-            mTvSeeContent.setClickable(false);
-            mTvSeeContent.setEnabled(false);
-        }else if(mType ==1){
-            //试看结束，观看全部内容请开通会员/购买。已是会员/已购买可登陆观看
-            if(mMemberContent!=null && mMemberContent.size()>1 && mMemberContent.get(1)!=null){
-                seeContent = mMemberContent.get(1);
-            }else {
-                seeContent = ConstantKeys.NO_LOGIN_TEXT;
-            }
-            mBtnVip.setText("立即登录");
-        }else if(mType == 2){
-            //试看结束，观看全部内容请开通会员。已是会员/已购买可登陆观看
-            if(mMemberContent!=null && mMemberContent.size()>2 && mMemberContent.get(2)!=null){
-                seeContent = mMemberContent.get(2);
-            }else {
-                seeContent = ConstantKeys.NO_LOGIN_VIP_TEXT;
-            }
-            mBtnVip.setText("立即登录");
-        }else if(mType == 3){
-            //试看结束, 登录后即可观看全部免费课程。
-            if(mMemberContent!=null && mMemberContent.size()>3 && mMemberContent.get(3)!=null){
-                seeContent = mMemberContent.get(3);
-            }else {
-                seeContent = ConstantKeys.NO_LOGIN;
-            }
-            mBtnVip.setText("立即登录");
-        }
-        mTvSeeContent.setText(seeContent);
-    }
-
-
     /**
      * 显示视频播放位置
      * @param duration            视频总时长ms
@@ -1210,18 +1001,6 @@ public class VideoPlayerController extends AbsVideoPlayerController implements V
         mChangeBrightness.setVisibility(View.GONE);
     }
 
-
-    /**
-     * 让用户自己处理点击事件的逻辑
-     * 点击事件，跳转登录或者购买会员页面
-     * 欢迎同行交流：https://github.com/yangchong211
-     * 如果你觉得项目可以，欢迎star
-     */
-    private OnMemberClickListener mClickListener;
-    public void setOnMemberClickListener(OnMemberClickListener listener) {
-        this.mClickListener = listener;
-    }
-
     /**
      * 当视频退出全屏或者退出小窗口后，再次点击返回键
      * 让用户自己处理返回键事件的逻辑

YCVideoPlayerLib/src/main/java/org/yczbj/ycvideoplayerlib/ChangeClarityDialog.java → YCVideoPlayerLib/src/main/java/org/yczbj/ycvideoplayerlib/dialog/ChangeClarityDialog.java

@@ -1,4 +1,4 @@
-package org.yczbj.ycvideoplayerlib;
+package org.yczbj.ycvideoplayerlib.dialog;
 
 import android.app.Dialog;
 import android.content.Context;
@@ -10,20 +10,28 @@ import android.view.WindowManager;
 import android.widget.LinearLayout;
 import android.widget.TextView;
 
-import org.yczbj.ycvideoplayerlib.listener.OnClarityChangedListener;
+import org.yczbj.ycvideoplayerlib.R;
+import org.yczbj.ycvideoplayerlib.inter.listener.OnClarityChangedListener;
+import org.yczbj.ycvideoplayerlib.utils.VideoPlayerUtils;
 
 import java.util.List;
 
+
 /**
- * 切换清晰度对话框（仿腾讯视频切换清晰度的对话框）.
+ * <pre>
+ *     @author yangchong
+ *     blog  : https://github.com/yangchong211
+ *     time  : 2018/1/29
+ *     desc  : 切换清晰度对话框（仿腾讯视频切换清晰度的对话框）
+ *     revise:
+ * </pre>
  */
-
 public class ChangeClarityDialog extends Dialog {
 
     private LinearLayout mLinearLayout;
     private int mCurrentCheckedIndex;
 
-    ChangeClarityDialog(Context context) {
+    public ChangeClarityDialog(Context context) {
         super(context, R.style.dialog_change_clarity);
         init(context);
     }
@@ -70,7 +78,7 @@ public class ChangeClarityDialog extends Dialog {
      * @param items          清晰度等级items
      * @param defaultChecked 默认选中的清晰度索引
      */
-    void setClarityGrade(List<String> items, int 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())
@@ -105,7 +113,7 @@ public class ChangeClarityDialog extends Dialog {
 
 
     private OnClarityChangedListener mListener;
-    void setOnClarityCheckedListener(OnClarityChangedListener listener) {
+    public void setOnClarityCheckedListener(OnClarityChangedListener listener) {
         mListener = listener;
     }
 

YCVideoPlayerLib/src/main/java/org/yczbj/ycvideoplayerlib/VideoClarity.java → YCVideoPlayerLib/src/main/java/org/yczbj/ycvideoplayerlib/dialog/VideoClarity.java

@@ -1,7 +1,14 @@
-package org.yczbj.ycvideoplayerlib;
+package org.yczbj.ycvideoplayerlib.dialog;
+
 
 /**
- * 清晰度
+ * <pre>
+ *     @author yangchong
+ *     blog  : https://github.com/yangchong211
+ *     time  : 2018/1/29
+ *     desc  : 清晰度实体类
+ *     revise:
+ * </pre>
  */
 public class VideoClarity {
 

YCVideoPlayerLib/src/main/java/org/yczbj/ycvideoplayerlib/InterVideoPlayer.java → YCVideoPlayerLib/src/main/java/org/yczbj/ycvideoplayerlib/inter/InterVideoPlayer.java

@@ -1,9 +1,16 @@
-package org.yczbj.ycvideoplayerlib;
+package org.yczbj.ycvideoplayerlib.inter;
 
 import java.util.Map;
 
+
 /**
- * VideoPlayer抽象接口
+ * <pre>
+ *     @author yangchong
+ *     blog  : https://github.com/yangchong211
+ *     time  : 2017/11/21
+ *     desc  : VideoPlayer抽象接口
+ *     revise:
+ * </pre>
  */
 public interface InterVideoPlayer {
 

YCVideoPlayerLib/src/main/java/org/yczbj/ycvideoplayerlib/listener/OnClarityChangedListener.java → YCVideoPlayerLib/src/main/java/org/yczbj/ycvideoplayerlib/inter/listener/OnClarityChangedListener.java

@@ -1,9 +1,15 @@
-package org.yczbj.ycvideoplayerlib.listener;
+package org.yczbj.ycvideoplayerlib.inter.listener;
+
 
 /**
- * 清晰度监听接口
+ * <pre>
+ *     @author yangchong
+ *     blog  : https://github.com/yangchong211
+ *     time  : 2017/11/21
+ *     desc  : 清晰度监听接口
+ *     revise:
+ * </pre>
  */
-
 public interface OnClarityChangedListener {
 
     /**

YCVideoPlayerLib/src/main/java/org/yczbj/ycvideoplayerlib/inter/listener/OnCompletedListener.java

@@ -0,0 +1,17 @@
+package org.yczbj.ycvideoplayerlib.inter.listener;
+
+
+/**
+ * <pre>
+ *     @author yangchong
+ *     blog  : https://github.com/yangchong211
+ *     time  : 2018/3/9
+ *     desc  : 视频播放完成后抽象接口
+ *     revise:
+ * </pre>
+ */
+public interface OnCompletedListener {
+
+    void onCompleted();
+
+}

YCVideoPlayerLib/src/main/java/org/yczbj/ycvideoplayerlib/inter/listener/OnPlayOrPauseListener.java

@@ -0,0 +1,17 @@
+package org.yczbj.ycvideoplayerlib.inter.listener;
+
+
+/**
+ * <pre>
+ *     @author yangchong
+ *     blog  : https://github.com/yangchong211
+ *     time  : 2017/11/9
+ *     desc  : 播放暂停点击事件抽象接口
+ *     revise:
+ * </pre>
+ */
+public interface OnPlayOrPauseListener {
+
+    void onPlayOrPauseClick(boolean isPlaying);
+
+}

YCVideoPlayerLib/src/main/java/org/yczbj/ycvideoplayerlib/inter/listener/OnVideoBackListener.java

@@ -0,0 +1,17 @@
+package org.yczbj.ycvideoplayerlib.inter.listener;
+
+
+/**
+ * <pre>
+ *     @author yangchong
+ *     blog  : https://github.com/yangchong211
+ *     time  : 2017/11/9
+ *     desc  : 返回点击事件抽象接口
+ *     revise:
+ * </pre>
+ */
+public interface OnVideoBackListener {
+
+    void onBackClick();
+
+}

YCVideoPlayerLib/src/main/java/org/yczbj/ycvideoplayerlib/listener/OnVideoControlListener.java → YCVideoPlayerLib/src/main/java/org/yczbj/ycvideoplayerlib/inter/listener/OnVideoControlListener.java

@@ -1,9 +1,15 @@
-package org.yczbj.ycvideoplayerlib.listener;
+package org.yczbj.ycvideoplayerlib.inter.listener;
+
 
 /**
- * 视频顶部点击事件
+ * <pre>
+ *     @author yangchong
+ *     blog  : https://github.com/yangchong211
+ *     time  : 2017/11/9
+ *     desc  : 视频顶部点击事件
+ *     revise:
+ * </pre>
  */
-
 public interface OnVideoControlListener {
 
     /**

YCVideoPlayerLib/src/main/java/org/yczbj/ycvideoplayerlib/listener/OnCompletedListener.java

@@ -1,10 +0,0 @@
-package org.yczbj.ycvideoplayerlib.listener;
-
-/**
- * 视频播放完成后抽象接口
- */
-public interface OnCompletedListener {
-
-    void onCompleted();
-
-}

YCVideoPlayerLib/src/main/java/org/yczbj/ycvideoplayerlib/listener/OnMemberClickListener.java

@@ -1,15 +0,0 @@
-package org.yczbj.ycvideoplayerlib.listener;
-
-
-/**
- * 点击事件抽象接口
- */
-public interface OnMemberClickListener {
-    /**
-     * 点击事件
-     * @param type      类型
-     *                  1.是跳转登录页面
-     *                  2.是跳转开通会员页面
-     */
-    void onClick(int type);
-}

YCVideoPlayerLib/src/main/java/org/yczbj/ycvideoplayerlib/listener/OnPlayOrPauseListener.java

@@ -1,10 +0,0 @@
-package org.yczbj.ycvideoplayerlib.listener;
-
-/**
- * 播放暂停点击事件抽象接口
- */
-public interface OnPlayOrPauseListener {
-
-    void onPlayOrPauseClick(boolean isPlaying);
-
-}

YCVideoPlayerLib/src/main/java/org/yczbj/ycvideoplayerlib/listener/OnVideoBackListener.java

@@ -1,10 +0,0 @@
-package org.yczbj.ycvideoplayerlib.listener;
-
-/**
- * 点击事件抽象接口
- */
-public interface OnVideoBackListener {
-
-    void onBackClick();
-
-}

YCVideoPlayerLib/src/main/java/org/yczbj/ycvideoplayerlib/VideoPlayerManager.java → YCVideoPlayerLib/src/main/java/org/yczbj/ycvideoplayerlib/manager/VideoPlayerManager.java

@@ -1,9 +1,19 @@
-package org.yczbj.ycvideoplayerlib;
+package org.yczbj.ycvideoplayerlib.manager;
+
+
+import org.yczbj.ycvideoplayerlib.player.VideoPlayer;
+
 
 /**
- * 视频播放器管理器.
+ * <pre>
+ *     @author yangchong
+ *     blog  : https://github.com/yangchong211
+ *     time  : 2017/10/21
+ *     desc  : 视频播放器管理器
+ *     revise:
+ * </pre>
  */
-public class VideoPlayerManager {
+public final class VideoPlayerManager {
 
     private VideoPlayer mVideoPlayer;
     private static VideoPlayerManager sInstance;
@@ -35,7 +45,7 @@ public class VideoPlayerManager {
      * 设置VideoPlayer
      * @param videoPlayer       VideoPlayerManager对象
      */
-    void setCurrentVideoPlayer(VideoPlayer videoPlayer) {
+    public void setCurrentVideoPlayer(VideoPlayer videoPlayer) {
         if (mVideoPlayer != videoPlayer) {
             releaseVideoPlayer();
             mVideoPlayer = videoPlayer;

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

@@ -1,5 +1,6 @@
-package org.yczbj.ycvideoplayerlib;
+package org.yczbj.ycvideoplayerlib.player;
 
+import android.app.Activity;
 import android.content.Context;
 import android.content.pm.ActivityInfo;
 import android.graphics.Color;
@@ -8,14 +9,30 @@ import android.media.AudioManager;
 import android.media.MediaPlayer;
 import android.net.Uri;
 import android.os.Build;
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
 import android.support.annotation.RequiresApi;
+import android.support.v7.app.AppCompatActivity;
 import android.util.AttributeSet;
 import android.view.Gravity;
+import android.view.KeyEvent;
+import android.view.MotionEvent;
 import android.view.Surface;
 import android.view.TextureView;
+import android.view.View;
 import android.view.ViewGroup;
+import android.view.Window;
 import android.widget.FrameLayout;
 import android.widget.Toast;
+
+import org.yczbj.ycvideoplayerlib.constant.ConstantKeys;
+import org.yczbj.ycvideoplayerlib.controller.AbsVideoPlayerController;
+import org.yczbj.ycvideoplayerlib.inter.InterVideoPlayer;
+import org.yczbj.ycvideoplayerlib.manager.VideoPlayerManager;
+import org.yczbj.ycvideoplayerlib.utils.VideoLogUtil;
+import org.yczbj.ycvideoplayerlib.utils.VideoPlayerUtils;
+import org.yczbj.ycvideoplayerlib.view.VideoTextureView;
+
 import java.io.IOException;
 import java.util.Map;
 
@@ -26,30 +43,17 @@ import tv.danmaku.ijk.media.player.IjkTimedText;
 
 
 /**
- * @author yc
- * @date 2017/11/29
- * 参考项目：
- * https://github.com/CarGuo/GSYVideoPlayer
- * https://github.com/danylovolokh/VideoPlayerManager
- * https://github.com/HotBitmapGG/bilibili-android-client
- * https://github.com/jjdxmashl/jjdxm_ijkplayer
- * https://github.com/JasonChow1989/JieCaoVideoPlayer-develop          2年前
- * https://github.com/open-android/JieCaoVideoPlayer                   1年前
- * https://github.com/lipangit/JiaoZiVideoPlayer                       4个月前
- * 个人感觉jiaozi这个播放器，与JieCaoVideoPlayer-develop有惊人的类同，借鉴了上面两个项目[JieCao]
- *
- *
- * 注意：在对应的播放Activity页面，清单文件中一定要添加
- * android:configChanges="orientation|keyboardHidden|screenSize"
- * android:screenOrientation="portrait"
- *
- * 关于我的github：https://github.com/yangchong211
- * 关于我的个人网站：www.ycbjie.cn或者www.yczbj.org
- *
- * 播放器
+ * <pre>
+ *     @author yangchong
+ *     blog  : https://github.com/yangchong211
+ *     time  : 2017/9/21
+ *     desc  : 播放器
+ *     revise: 注意：在对应的播放Activity页面，清单文件中一定要添加
+ *             android:configChanges="orientation|keyboardHidden|screenSize"
+ *             android:screenOrientation="portrait"
+ * </pre>
  */
-
-public class VideoPlayer extends FrameLayout implements InterVideoPlayer{
+public class VideoPlayer extends FrameLayout implements InterVideoPlayer {
 
 
     /**
@@ -89,9 +93,14 @@ public class VideoPlayer extends FrameLayout implements InterVideoPlayer{
     }
 
     public VideoPlayer(Context context, AttributeSet attrs) {
-        super(context, attrs);
+        this(context, attrs ,0);
+    }
+
+    public VideoPlayer(@NonNull Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
+        super(context, attrs, defStyleAttr);
         mContext = context;
         init();
+
     }
 
     /**
@@ -106,6 +115,21 @@ public class VideoPlayer extends FrameLayout implements InterVideoPlayer{
         this.addView(mContainer, params);
     }
 
+    /**
+     * 如果锁屏，则屏蔽返回键，这个地方设置无效，需要在activity中设置处理返回键逻辑
+     * 后期找替代方案
+     */
+    @Override
+    public boolean onKeyDown(int keyCode, KeyEvent event) {
+        VideoLogUtil.i("如果锁屏1，则屏蔽返回键onKeyDown"+event.getAction());
+        if(keyCode == KeyEvent.KEYCODE_BACK ){
+            if(mController!=null && mController.getLock()){
+                //如果锁屏，那就屏蔽返回键
+                return true;
+            }
+        }
+        return super.onKeyDown(keyCode, event);
+    }
 
 
     /*--------------setUp为必须设置的方法，二选其一--------------------------------------*/
@@ -492,6 +516,13 @@ public class VideoPlayer extends FrameLayout implements InterVideoPlayer{
         return 0;
     }
 
+    /**
+     * 获取当前播放模式
+     * @return
+     */
+    public int getCurrentState(){
+        return mCurrentState;
+    }
 
     /**
      * 初始化音频管理器
@@ -823,7 +854,7 @@ public class VideoPlayer extends FrameLayout implements InterVideoPlayer{
         // 隐藏ActionBar、状态栏，并横屏
         VideoPlayerUtils.hideActionBar(mContext);
         VideoPlayerUtils.scanForActivity(mContext).setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
-        ViewGroup contentView = (ViewGroup) VideoPlayerUtils.scanForActivity(mContext).findViewById(android.R.id.content);
+        ViewGroup contentView = VideoPlayerUtils.scanForActivity(mContext).findViewById(android.R.id.content);
         if (mCurrentMode == ConstantKeys.PlayMode.MODE_TINY_WINDOW) {
             contentView.removeView(mContainer);
         } else {
@@ -831,7 +862,6 @@ public class VideoPlayer extends FrameLayout implements InterVideoPlayer{
         }
         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);
         VideoLogUtil.d("MODE_FULL_SCREEN");
@@ -849,7 +879,7 @@ public class VideoPlayer extends FrameLayout implements InterVideoPlayer{
         // 隐藏ActionBar、状态栏，并横屏
         VideoPlayerUtils.hideActionBar(mContext);
         VideoPlayerUtils.scanForActivity(mContext).setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
-        ViewGroup contentView = (ViewGroup) VideoPlayerUtils.scanForActivity(mContext).findViewById(android.R.id.content);
+        ViewGroup contentView = VideoPlayerUtils.scanForActivity(mContext).findViewById(android.R.id.content);
         if (mCurrentMode == ConstantKeys.PlayMode.MODE_TINY_WINDOW) {
             contentView.removeView(mContainer);
         } else {
@@ -879,7 +909,7 @@ public class VideoPlayer extends FrameLayout implements InterVideoPlayer{
         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);
+            ViewGroup contentView = VideoPlayerUtils.scanForActivity(mContext).findViewById(android.R.id.content);
             //将视图移除
             contentView.removeView(mContainer);
             //重新添加到当前视图
@@ -888,6 +918,7 @@ public class VideoPlayer extends FrameLayout implements InterVideoPlayer{
             mCurrentMode = ConstantKeys.PlayMode.MODE_NORMAL;
             mController.onPlayModeChanged(mCurrentMode);
             VideoLogUtil.d("MODE_NORMAL");
+            this.setOnKeyListener(null);
             return true;
         }
         return false;
@@ -906,7 +937,7 @@ public class VideoPlayer extends FrameLayout implements InterVideoPlayer{
         }
         //先移除
         this.removeView(mContainer);
-        ViewGroup contentView = (ViewGroup) VideoPlayerUtils.scanForActivity(mContext).findViewById(android.R.id.content);
+        ViewGroup contentView = VideoPlayerUtils.scanForActivity(mContext).findViewById(android.R.id.content);
         // 小窗口的宽度为屏幕宽度的60%，长宽比默认为16:9，右边距、下边距为8dp。
         LayoutParams params = new LayoutParams(
                 (int) (VideoPlayerUtils.getScreenWidth(mContext) * 0.6f),
@@ -927,7 +958,7 @@ public class VideoPlayer extends FrameLayout implements InterVideoPlayer{
     @Override
     public boolean exitTinyWindow() {
         if (mCurrentMode == ConstantKeys.PlayMode.MODE_TINY_WINDOW) {
-            ViewGroup contentView = (ViewGroup) VideoPlayerUtils.scanForActivity(mContext).findViewById(android.R.id.content);
+            ViewGroup contentView = 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);
@@ -990,7 +1021,9 @@ public class VideoPlayer extends FrameLayout implements InterVideoPlayer{
     public void releasePlayer() {
         if (mAudioManager != null) {
             //放弃音频焦点。使以前的焦点所有者(如果有的话)接收焦点。
-            mAudioManager.abandonAudioFocus(null);
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.FROYO) {
+                mAudioManager.abandonAudioFocus(null);
+            }
             //置空
             mAudioManager = null;
         }
@@ -1002,12 +1035,16 @@ public class VideoPlayer extends FrameLayout implements InterVideoPlayer{
         //从视图中移除TextureView
         mContainer.removeView(mTextureView);
         if (mSurface != null) {
-            mSurface.release();
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH) {
+                mSurface.release();
+            }
             mSurface = null;
         }
         //如果SurfaceTexture不为null，则释放
         if (mSurfaceTexture != null) {
-            mSurfaceTexture.release();
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH) {
+                mSurfaceTexture.release();
+            }
             mSurfaceTexture = null;
         }
         mCurrentState = ConstantKeys.CurrentState.STATE_IDLE;

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

@@ -1,11 +1,17 @@
-package org.yczbj.ycvideoplayerlib;
+package org.yczbj.ycvideoplayerlib.utils;
 
 import android.util.Log;
 
 /**
- * log工具
+ * <pre>
+ *     @author yangchong
+ *     blog  : https://github.com/yangchong211
+ *     time  : 2017/10/21
+ *     desc  : log工具
+ *     revise:
+ * </pre>
  */
-public class VideoLogUtil {
+public final class VideoLogUtil {
 
     private static final String TAG = "YCVideoPlayer";
     private static boolean isLog = true;
@@ -18,20 +24,20 @@ public class VideoLogUtil {
         VideoLogUtil.isLog = isLog;
     }
 
-    static void d(String message) {
+    public static void d(String message) {
         if(isLog){
             Log.d(TAG, message);
         }
     }
 
-    static void i(String message) {
+    public static void i(String message) {
         if(isLog){
             Log.i(TAG, message);
         }
 
     }
 
-    static void e(String message, Throwable throwable) {
+    public static void e(String message, Throwable throwable) {
         if(isLog){
             Log.e(TAG, message, throwable);
         }

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

@@ -1,4 +1,4 @@
-package org.yczbj.ycvideoplayerlib;
+package org.yczbj.ycvideoplayerlib.utils;
 
 import android.annotation.SuppressLint;
 import android.app.Activity;
@@ -17,9 +17,15 @@ import java.util.Formatter;
 import java.util.Locale;
 
 /**
- * 工具类.
+ * <pre>
+ *     @author yangchong
+ *     blog  : https://github.com/yangchong211
+ *     time  : 2017/10/21
+ *     desc  : 工具类
+ *     revise:
+ * </pre>
  */
-public class VideoPlayerUtils {
+public final class VideoPlayerUtils {
 
     /**
      * Get activity from context object
@@ -27,7 +33,7 @@ public class VideoPlayerUtils {
      * @param context       上下文
      * @return              对象的活动对象，如果它不是活动对象，则为空。
      */
-    static Activity scanForActivity(Context context) {
+    public static Activity scanForActivity(Context context) {
         if (context == null) {
             return null;
         }
@@ -52,7 +58,6 @@ public class VideoPlayerUtils {
     }
 
 
-
     /**
      * Get AppCompatActivity from context
      * @param context           上下文
@@ -71,7 +76,7 @@ public class VideoPlayerUtils {
     }
 
     @SuppressLint("RestrictedApi")
-    static void showActionBar(Context context) {
+    public static void showActionBar(Context context) {
         ActionBar ab = getAppCompActivity(context).getSupportActionBar();
         if (ab != null) {
             ab.setShowHideAnimationEnabled(false);
@@ -81,7 +86,7 @@ public class VideoPlayerUtils {
     }
 
     @SuppressLint("RestrictedApi")
-    static void hideActionBar(Context context) {
+    public static void hideActionBar(Context context) {
         ActionBar ab = getAppCompActivity(context).getSupportActionBar();
         if (ab != null) {
             ab.setShowHideAnimationEnabled(false);
@@ -93,21 +98,21 @@ public class VideoPlayerUtils {
     /**
      * 获取屏幕宽度
      */
-    static int getScreenWidth(Context context) {
+    public static int getScreenWidth(Context context) {
         return context.getResources().getDisplayMetrics().widthPixels;
     }
 
     /**
      * 获取屏幕高度
      */
-    static int getScreenHeight(Context context) {
+    public static int getScreenHeight(Context context) {
         return context.getResources().getDisplayMetrics().heightPixels;
     }
 
     /**
      * dp转px
      */
-    static int dp2px(Context context, float dpVal) {
+    public static int dp2px(Context context, float dpVal) {
         return (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, dpVal,
                 context.getResources().getDisplayMetrics());
     }
@@ -168,7 +173,7 @@ public class VideoPlayerUtils {
      *
      * @return {@code true}: 是<br>{@code false}: 否
      */
-    static boolean isConnected(Context context) {
+    public static boolean isConnected(Context context) {
         NetworkInfo info = getActiveNetworkInfo(context);
         return info != null && info.isConnected();
     }

jiaozivideoplayer/src/main/java/cn/jzvd/JZResizeTextureView.java → YCVideoPlayerLib/src/main/java/org/yczbj/ycvideoplayerlib/view/VideoSurfaceView.java

@@ -1,45 +1,55 @@
-package cn.jzvd;
+package org.yczbj.ycvideoplayerlib.view;
 
 import android.content.Context;
 import android.util.AttributeSet;
-import android.util.Log;
-import android.view.TextureView;
-import android.view.View;
+import android.view.SurfaceView;
+
 
 /**
- * <p>参照Android系统的VideoView的onMeasure方法
- * <br>注意!relativelayout中无法全屏，要嵌套一个linearlayout</p>
- * <p>Referring Android system Video View of onMeasure method
- * <br>NOTE! Can not fullscreen relativelayout, to nest a linearlayout</p>
- * Created by Nathen
- * On 2016/06/02 00:01
+ * <pre>
+ *     @author yangchong
+ *     blog  : https://github.com/yangchong211
+ *     time  : 2017/10/21
+ *     desc  : 重写SurfaceView，适配视频的宽高和旋转
+ *     revise:
+ * </pre>
  */
-public class JZResizeTextureView extends TextureView {
+public class VideoSurfaceView extends SurfaceView {
 
-    protected static final String TAG = "JZResizeTextureView";
-    public int currentVideoWidth = 0;
-    public int currentVideoHeight = 0;
+    private int videoHeight;
+    private int videoWidth;
 
-    public JZResizeTextureView(Context context) {
+    public VideoSurfaceView(Context context) {
         super(context);
-        currentVideoWidth = 0;
-        currentVideoHeight = 0;
     }
 
-    public JZResizeTextureView(Context context, AttributeSet attrs) {
+    public VideoSurfaceView(Context context, AttributeSet attrs) {
         super(context, attrs);
-        currentVideoWidth = 0;
-        currentVideoHeight = 0;
     }
 
-    public void setVideoSize(int currentVideoWidth, int currentVideoHeight) {
-        if (this.currentVideoWidth != currentVideoWidth || this.currentVideoHeight != currentVideoHeight) {
-            this.currentVideoWidth = currentVideoWidth;
-            this.currentVideoHeight = currentVideoHeight;
+    public VideoSurfaceView(Context context, AttributeSet attrs, int defStyleAttr) {
+        super(context, attrs, defStyleAttr);
+    }
+
+
+    /**
+     * 自定义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()) {
@@ -50,29 +60,11 @@ public class JZResizeTextureView extends TextureView {
 
     @Override
     protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
-        Log.i(TAG, "onMeasure " + " [" + this.hashCode() + "] ");
-        int viewRotation = (int) getRotation();
-        int videoWidth = currentVideoWidth;
-        int videoHeight = currentVideoHeight;
-
-
-        int parentHeight = ((View) getParent()).getMeasuredHeight();
-        int parentWidth = ((View) getParent()).getMeasuredWidth();
-        if (parentWidth != 0 && parentHeight != 0 && videoWidth != 0 && videoHeight != 0) {
-            if (JZVideoPlayer.VIDEO_IMAGE_DISPLAY_TYPE == JZVideoPlayer.VIDEO_IMAGE_DISPLAY_TYPE_FILL_PARENT) {
-                if (viewRotation == 90 || viewRotation == 270) {
-                    int tempSize = parentWidth;
-                    parentWidth = parentHeight;
-                    parentHeight = tempSize;
-                }
-                /**强制充满**/
-                videoHeight = videoWidth * parentHeight / parentWidth;
-            }
-        }
-
+        float viewRotation = getRotation();
         // 如果判断成立，则说明显示的TextureView和本身的位置是有90度的旋转的，所以需要交换宽高参数。
-        if (viewRotation == 90 || viewRotation == 270) {
+        if (viewRotation == 90f || viewRotation == 270f) {
             int tempMeasureSpec = widthMeasureSpec;
+            //noinspection SuspiciousNameCombination
             widthMeasureSpec = heightMeasureSpec;
             heightMeasureSpec = tempMeasureSpec;
         }
@@ -86,9 +78,6 @@ public class JZResizeTextureView extends TextureView {
             int heightSpecMode = MeasureSpec.getMode(heightMeasureSpec);
             int heightSpecSize = MeasureSpec.getSize(heightMeasureSpec);
 
-            Log.i(TAG, "widthMeasureSpec  [" + MeasureSpec.toString(widthMeasureSpec) + "]");
-            Log.i(TAG, "heightMeasureSpec [" + MeasureSpec.toString(heightMeasureSpec) + "]");
-
             if (widthSpecMode == MeasureSpec.EXACTLY && heightSpecMode == MeasureSpec.EXACTLY) {
                 // the size is fixed
                 width = widthSpecSize;
@@ -135,27 +124,7 @@ public class JZResizeTextureView extends TextureView {
         } else {
             // no size yet, just adopt the given spec sizes
         }
-        if (parentWidth != 0 && parentHeight != 0 && videoWidth != 0 && videoHeight != 0) {
-            if (JZVideoPlayer.VIDEO_IMAGE_DISPLAY_TYPE == JZVideoPlayer.VIDEO_IMAGE_DISPLAY_TYPE_ORIGINAL) {
-                /*原图*/
-                height = videoHeight;
-                width = videoWidth;
-            } else if (JZVideoPlayer.VIDEO_IMAGE_DISPLAY_TYPE == JZVideoPlayer.VIDEO_IMAGE_DISPLAY_TYPE_FILL_SCROP) {
-                if (viewRotation == 90 || viewRotation == 270) {
-                    int tempSize = parentWidth;
-                    parentWidth = parentHeight;
-                    parentHeight = tempSize;
-                }
-                /*充满剪切*/
-                if (videoHeight / videoWidth > parentHeight / parentWidth) {
-                    height = parentWidth / width * height;
-                    width = parentWidth;
-                } else if (videoHeight / videoWidth < parentHeight / parentWidth) {
-                    width = parentHeight / height * width;
-                    height = parentHeight;
-                }
-            }
-        }
         setMeasuredDimension(width, height);
     }
+
 }

YCVideoPlayerLib/src/main/java/org/yczbj/ycvideoplayerlib/VideoTextureView.java → YCVideoPlayerLib/src/main/java/org/yczbj/ycvideoplayerlib/view/VideoTextureView.java

@@ -1,19 +1,22 @@
-package org.yczbj.ycvideoplayerlib;
+package org.yczbj.ycvideoplayerlib.view;
 
+import android.annotation.SuppressLint;
 import android.content.Context;
-import android.view.SurfaceView;
+import android.os.Build;
+import android.support.annotation.RequiresApi;
 import android.view.TextureView;
 
+
 /**
- * @author yc
- * @date 2017/12/29
- * 重写TextureView，适配视频的宽高和旋转.
- * 参考项目：https://github.com/JasonChow1989/JieCaoVideoPlayer-develop          2年前
- *          https://github.com/open-android/JieCaoVideoPlayer                   1年前
- *          https://github.com/lipangit/JiaoZiVideoPlayer                       4个月前
- *          个人感觉jiaozi这个播放器，与JieCaoVideoPlayer-develop有惊人的类同，借鉴了上面两个项目
+ * <pre>
+ *     @author yangchong
+ *     blog  : https://github.com/yangchong211
+ *     time  : 2017/10/21
+ *     desc  : 重写TextureView，适配视频的宽高和旋转
+ *     revise:
+ * </pre>
  */
-
+@SuppressLint("NewApi")
 public class VideoTextureView extends TextureView {
 
     private int videoHeight;

YCVideoPlayerLib/src/main/java/org/yczbj/ycvideoplayerlib/window/FloatLifecycle.java

@@ -0,0 +1,129 @@
+package org.yczbj.ycvideoplayerlib.window;
+
+import android.app.Activity;
+import android.app.Application;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.os.Build;
+import android.os.Bundle;
+import android.os.Handler;
+import android.support.annotation.RequiresApi;
+
+/**
+ * 用于控制悬浮窗显示周期
+ * 使用了三种方法针对返回桌面时隐藏悬浮按钮
+ * 1.startCount计数，针对back到桌面可以及时隐藏
+ * 2.监听home键，从而及时隐藏
+ * 3.resumeCount计时，针对一些只执行onPause不执行onStop的奇葩情况
+ */
+
+@RequiresApi(api = Build.VERSION_CODES.ICE_CREAM_SANDWICH)
+class FloatLifecycle extends BroadcastReceiver implements Application.ActivityLifecycleCallbacks {
+
+    private static final String SYSTEM_DIALOG_REASON_KEY = "reason";
+    private static final String SYSTEM_DIALOG_REASON_HOME_KEY = "homekey";
+    private static final long delay = 300;
+    private Handler mHandler;
+    private Class[] activities;
+    private boolean showFlag;
+    private int startCount;
+    private int resumeCount;
+    private boolean appBackground;
+    private LifecycleListener mLifecycleListener;
+
+
+    FloatLifecycle(Context applicationContext, boolean showFlag, Class[] activities, LifecycleListener lifecycleListener) {
+        this.showFlag = showFlag;
+        this.activities = activities;
+        mLifecycleListener = lifecycleListener;
+        mHandler = new Handler();
+        ((Application) applicationContext).registerActivityLifecycleCallbacks(this);
+        applicationContext.registerReceiver(this, new IntentFilter(Intent.ACTION_CLOSE_SYSTEM_DIALOGS));
+    }
+
+
+    private boolean needShow(Activity activity) {
+        if (activities == null) {
+            return true;
+        }
+        for (Class a : activities) {
+            if (a.isInstance(activity)) {
+                return showFlag;
+            }
+        }
+        return !showFlag;
+    }
+
+
+    @Override
+    public void onActivityResumed(Activity activity) {
+        resumeCount++;
+        if (needShow(activity)) {
+            mLifecycleListener.onShow();
+        }
+        if (appBackground) {
+            appBackground = false;
+        }
+    }
+
+    @Override
+    public void onActivityPaused(Activity activity) {
+        resumeCount--;
+        mHandler.postDelayed(new Runnable() {
+            @Override
+            public void run() {
+                if (resumeCount == 0) {
+                    appBackground = true;
+                    //mLifecycleListener.onPostHide();
+                }
+            }
+        }, delay);
+
+    }
+
+    @Override
+    public void onActivityStarted(Activity activity) {
+        startCount++;
+    }
+
+
+    @Override
+    public void onActivityStopped(Activity activity) {
+        startCount--;
+        if (startCount == 0) {
+            //mLifecycleListener.onHide();
+        }
+    }
+
+    @Override
+    public void onReceive(Context context, Intent intent) {
+        String action = intent.getAction();
+        if (action != null && action.equals(Intent.ACTION_CLOSE_SYSTEM_DIALOGS)) {
+            String reason = intent.getStringExtra(SYSTEM_DIALOG_REASON_KEY);
+            if (SYSTEM_DIALOG_REASON_HOME_KEY.equals(reason)) {
+                //mLifecycleListener.onHide();
+            }
+        }
+    }
+
+
+    @Override
+    public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
+
+    }
+
+
+    @Override
+    public void onActivitySaveInstanceState(Activity activity, Bundle outState) {
+
+    }
+
+    @Override
+    public void onActivityDestroyed(Activity activity) {
+
+    }
+
+
+}

YCVideoPlayerLib/src/main/java/org/yczbj/ycvideoplayerlib/window/FloatPhone.java

@@ -0,0 +1,114 @@
+package org.yczbj.ycvideoplayerlib.window;
+
+import android.content.Context;
+import android.graphics.PixelFormat;
+import android.os.Build;
+import android.view.View;
+import android.view.WindowManager;
+
+/**
+ * 7.1及以上需申请权限
+ */
+
+public class FloatPhone extends FloatView {
+
+    private final Context mContext;
+
+    private final WindowManager mWindowManager;
+    private final WindowManager.LayoutParams mLayoutParams;
+    private View mView;
+    private int mX, mY;
+
+    FloatPhone(Context applicationContext) {
+        mContext = applicationContext;
+        mWindowManager = (WindowManager) applicationContext.getSystemService(Context.WINDOW_SERVICE);
+        mLayoutParams = new WindowManager.LayoutParams();
+    }
+
+    @Override
+    public void setSize(int width, int height) {
+        mLayoutParams.width = width;
+        mLayoutParams.height = height;
+    }
+
+    @Override
+    public void setView(View view) {
+        int layout_type;
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            layout_type = WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY;
+        } else {
+            layout_type = WindowManager.LayoutParams.TYPE_PHONE;
+        }
+        mLayoutParams.flags = WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL
+                | WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE;
+        mLayoutParams.type = layout_type;
+        mLayoutParams.windowAnimations = 0;
+        mView = view;
+    }
+
+    @Override
+    public void setGravity(int gravity, int xOffset, int yOffset) {
+        mLayoutParams.gravity = gravity;
+        mLayoutParams.x = mX = xOffset;
+        mLayoutParams.y = mY = yOffset;
+    }
+
+
+    @Override
+    public void init() {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+            if (WindowUtil.hasPermission(mContext)) {
+                mLayoutParams.format = PixelFormat.RGBA_8888;
+                mWindowManager.addView(mView, mLayoutParams);
+            } else {
+                PermissionActivity.request(mContext, new PermissionListener() {
+                    @Override
+                    public void onSuccess() {
+                        mLayoutParams.format = PixelFormat.RGBA_8888;
+                        mWindowManager.addView(mView, mLayoutParams);
+                    }
+
+                    @Override
+                    public void onFail() {
+
+                    }
+                });
+            }
+        }
+    }
+
+    @Override
+    public void dismiss() {
+        mWindowManager.removeView(mView);
+    }
+
+    @Override
+    public void updateXY(int x, int y) {
+        mLayoutParams.x = mX = x;
+        mLayoutParams.y = mY = y;
+        mWindowManager.updateViewLayout(mView, mLayoutParams);
+    }
+
+    @Override
+    void updateX(int x) {
+        mLayoutParams.x = mX = x;
+        mWindowManager.updateViewLayout(mView, mLayoutParams);
+
+    }
+
+    @Override
+    void updateY(int y) {
+        mLayoutParams.y = mY = y;
+        mWindowManager.updateViewLayout(mView, mLayoutParams);
+    }
+
+    @Override
+    int getX() {
+        return mX;
+    }
+
+    @Override
+    int getY() {
+        return mY;
+    }
+}

YCVideoPlayerLib/src/main/java/org/yczbj/ycvideoplayerlib/window/FloatPlayerView.java

@@ -0,0 +1,105 @@
+package org.yczbj.ycvideoplayerlib.window;
+
+import android.content.Context;
+import android.graphics.Color;
+import android.util.AttributeSet;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.widget.FrameLayout;
+
+import org.yczbj.ycvideoplayerlib.R;
+import org.yczbj.ycvideoplayerlib.constant.ConstantKeys;
+import org.yczbj.ycvideoplayerlib.controller.VideoPlayerController;
+import org.yczbj.ycvideoplayerlib.inter.listener.OnCompletedListener;
+import org.yczbj.ycvideoplayerlib.manager.VideoPlayerManager;
+import org.yczbj.ycvideoplayerlib.player.VideoPlayer;
+import org.yczbj.ycvideoplayerlib.utils.VideoLogUtil;
+
+
+/**
+ * <pre>
+ *     @author yangchong
+ *     blog  : https://github.com/yangchong211
+ *     time  : 2018/8/29
+ *     desc  : 适配了悬浮窗的view
+ *     revise:
+ * </pre>
+ */
+public class FloatPlayerView extends FrameLayout {
+
+    private VideoPlayer mVideoPlayer;
+
+    public FloatPlayerView(Context context) {
+        super(context);
+        init();
+    }
+
+    public FloatPlayerView(Context context, AttributeSet attrs) {
+        super(context, attrs);
+        init();
+    }
+
+    public FloatPlayerView(Context context, AttributeSet attrs, int defStyleAttr) {
+        super(context, attrs, defStyleAttr);
+        init();
+    }
+
+    private void init() {
+        LayoutInflater inflater = (LayoutInflater) this.getContext().getSystemService(Context.LAYOUT_INFLATER_SERVICE);
+        View view ;
+        if (inflater != null) {
+            view = inflater.inflate(R.layout.view_window_dialog, this);
+            mVideoPlayer = view.findViewById(R.id.video_player);
+            mVideoPlayer.setUp(path,null);
+            mVideoPlayer.setPlayerType(ConstantKeys.IjkPlayerType.TYPE_NATIVE);
+            //创建视频控制器
+            VideoPlayerController controller = new VideoPlayerController(getContext());
+            controller.setTopVisibility(false);
+            controller.setLoadingType(ConstantKeys.Loading.LOADING_QQ);
+            controller.imageView().setBackgroundColor(Color.BLACK);
+            controller.setCenterPlayer(true,R.drawable.icon_play_center);
+            controller.setOnCompletedListener(new OnCompletedListener() {
+                @Override
+                public void onCompleted() {
+                    VideoPlayerManager.instance().releaseVideoPlayer();
+                    if(mCompletedListener!=null){
+                        mCompletedListener.Completed();
+                    }
+                }
+            });
+            mVideoPlayer.setController(controller);
+            mVideoPlayer.start();
+            view.setOnClickListener(new OnClickListener() {
+                @Override
+                public void onClick(View v) {
+                    VideoLogUtil.d("点击事件"+mVideoPlayer.getCurrentState());
+                    if(mVideoPlayer.isPlaying()){
+                        mVideoPlayer.pause();
+                    }else if(mVideoPlayer.isPaused()){
+                        mVideoPlayer.restart();
+                    }
+                    VideoLogUtil.d("点击事件"+mVideoPlayer.getCurrentState());
+                }
+            });
+            view.setOnTouchListener(new SmallWindowTouch(view,0,0));
+        }
+    }
+
+    private static String path;
+    public static void setUrl(String url) {
+        path = url;
+    }
+
+    public interface CompletedListener{
+        void Completed();
+    }
+
+    /**
+     * 监听视频播放完成事件
+     */
+    private CompletedListener mCompletedListener;
+    public void setCompletedListener(CompletedListener listener){
+        this.mCompletedListener = listener;
+    }
+
+}

YCVideoPlayerLib/src/main/java/org/yczbj/ycvideoplayerlib/window/FloatToast.java

@@ -0,0 +1,92 @@
+package org.yczbj.ycvideoplayerlib.window;
+
+import android.content.Context;
+import android.view.View;
+import android.view.WindowManager;
+import android.widget.Toast;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+
+/**
+ * 自定义 toast 方式，无需申请权限
+ */
+
+public class FloatToast extends FloatView {
+
+
+    private Toast toast;
+    private Object mTN;
+    private Method show;
+    private Method hide;
+    private int mWidth;
+    private int mHeight;
+
+
+    FloatToast(Context applicationContext) {
+        toast = new Toast(applicationContext);
+    }
+
+
+    @Override
+    public void setSize(int width, int height) {
+        mWidth = width;
+        mHeight = height;
+    }
+
+    @Override
+    public void setView(View view) {
+        toast.setView(view);
+        initTN();
+    }
+
+    @Override
+    public void setGravity(int gravity, int xOffset, int yOffset) {
+        toast.setGravity(gravity, xOffset, yOffset);
+    }
+
+    @Override
+    public void init() {
+        try {
+            show.invoke(mTN);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Override
+    public void dismiss() {
+        try {
+            hide.invoke(mTN);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+
+    private void initTN() {
+        try {
+            Field tnField = toast.getClass().getDeclaredField("mTN");
+            tnField.setAccessible(true);
+            mTN = tnField.get(toast);
+            show = mTN.getClass().getMethod("show");
+            hide = mTN.getClass().getMethod("hide");
+
+            Field tnParamsField = mTN.getClass().getDeclaredField("mParams");
+            tnParamsField.setAccessible(true);
+            WindowManager.LayoutParams params = (WindowManager.LayoutParams) tnParamsField.get(mTN);
+            params.flags = WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL
+                    | WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE;
+            params.width = mWidth;
+            params.height = mHeight;
+            params.windowAnimations = 0;
+            Field tnNextViewField = mTN.getClass().getDeclaredField("mNextView");
+            tnNextViewField.setAccessible(true);
+            tnNextViewField.set(mTN, toast.getView());
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+
+}

YCVideoPlayerLib/src/main/java/org/yczbj/ycvideoplayerlib/window/FloatView.java

@@ -0,0 +1,31 @@
+package org.yczbj.ycvideoplayerlib.window;
+
+import android.view.View;
+
+
+abstract class FloatView {
+
+    abstract void setSize(int width, int height);
+
+    abstract void setView(View view);
+
+    abstract void setGravity(int gravity, int xOffset, int yOffset);
+
+    abstract void init();
+
+    abstract void dismiss();
+
+    void updateXY(int x, int y) {}
+
+    void updateX(int x) {}
+
+    void updateY(int y) {}
+
+    int getX() {
+        return 0;
+    }
+
+    int getY() {
+        return 0;
+    }
+}

YCVideoPlayerLib/src/main/java/org/yczbj/ycvideoplayerlib/window/FloatWindow.java

@@ -0,0 +1,191 @@
+package org.yczbj.ycvideoplayerlib.window;
+
+import android.animation.TimeInterpolator;
+import android.content.Context;
+import android.support.annotation.LayoutRes;
+import android.support.annotation.MainThread;
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+import android.view.Gravity;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * 记得添加下面这个权限
+ * uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW"
+ */
+public class FloatWindow {
+
+    private FloatWindow() {
+
+    }
+
+    private static final String mDefaultTag = "default_float_window_tag";
+    private static Map<String, IFloatWindow> mFloatWindowMap;
+
+    public static IFloatWindow get() {
+        return get(mDefaultTag);
+    }
+
+    public static IFloatWindow get(@NonNull String tag) {
+        return mFloatWindowMap == null ? null : mFloatWindowMap.get(tag);
+    }
+
+
+    @MainThread
+    public static B with(@NonNull Context applicationContext) {
+        return new B(applicationContext);
+    }
+
+    public static void destroy() {
+        destroy(mDefaultTag);
+    }
+
+    public static void destroy(String tag) {
+        if (mFloatWindowMap == null || !mFloatWindowMap.containsKey(tag)) {
+            return;
+        }
+        mFloatWindowMap.get(tag).dismiss();
+        mFloatWindowMap.remove(tag);
+    }
+
+    public static class B {
+        Context mApplicationContext;
+        View mView;
+        private int mLayoutId;
+        int mWidth = ViewGroup.LayoutParams.WRAP_CONTENT;
+        int mHeight = ViewGroup.LayoutParams.WRAP_CONTENT;
+        int gravity = Gravity.TOP | Gravity.START;
+        int xOffset;
+        int yOffset;
+        boolean mShow = true;
+        Class[] mActivities;
+        int mMoveType = MoveType.fixed;
+        long mDuration = 300;
+        TimeInterpolator mInterpolator;
+        private String mTag = mDefaultTag;
+
+        private B() {
+
+        }
+
+        B(Context applicationContext) {
+            mApplicationContext = applicationContext;
+        }
+
+        public B setView(@NonNull View view) {
+            mView = view;
+            return this;
+        }
+
+        public B setView(@LayoutRes int layoutId) {
+            mLayoutId = layoutId;
+            return this;
+        }
+
+        public B setWidth(int width) {
+            mWidth = width;
+            return this;
+        }
+
+        public B setHeight(int height) {
+            mHeight = height;
+            return this;
+        }
+
+        public B setWidth(@WindowScreen.screenType int screenType, float ratio) {
+            mWidth = (int) ((screenType == WindowScreen.width ?
+                    WindowUtil.getScreenWidth(mApplicationContext) :
+                    WindowUtil.getScreenHeight(mApplicationContext)) * ratio);
+            return this;
+        }
+
+
+        public B setHeight(@WindowScreen.screenType int screenType, float ratio) {
+            mHeight = (int) ((screenType == WindowScreen.width ?
+                    WindowUtil.getScreenWidth(mApplicationContext) :
+                    WindowUtil.getScreenHeight(mApplicationContext)) * ratio);
+            return this;
+        }
+
+
+        public B setX(int x) {
+            xOffset = x;
+            return this;
+        }
+
+        public B setY(int y) {
+            yOffset = y;
+            return this;
+        }
+
+        public B setX(@WindowScreen.screenType int screenType, float ratio) {
+            xOffset = (int) ((screenType == WindowScreen.width ?
+                    WindowUtil.getScreenWidth(mApplicationContext) :
+                    WindowUtil.getScreenHeight(mApplicationContext)) * ratio);
+            return this;
+        }
+
+        public B setY(@WindowScreen.screenType int screenType, float ratio) {
+            yOffset = (int) ((screenType == WindowScreen.width ?
+                    WindowUtil.getScreenWidth(mApplicationContext) :
+                    WindowUtil.getScreenHeight(mApplicationContext)) * ratio);
+            return this;
+        }
+
+
+        /**
+         * 设置 Activity 过滤器，用于指定在哪些界面显示悬浮窗，默认全部界面都显示
+         *
+         * @param show       　过滤类型,子类类型也会生效
+         * @param activities 　过滤界面
+         */
+        public B setFilter(boolean show, @NonNull Class... activities) {
+            mShow = show;
+            mActivities = activities;
+            return this;
+        }
+
+
+        public B setMoveType(@MoveType.MOVE_TYPE int moveType) {
+            mMoveType = moveType;
+            return this;
+        }
+
+        public B setMoveStyle(long duration, @Nullable TimeInterpolator interpolator) {
+            mDuration = duration;
+            mInterpolator = interpolator;
+            return this;
+        }
+
+        public B setTag(@NonNull String tag) {
+            mTag = tag;
+            return this;
+        }
+
+        public void build() {
+            if (mFloatWindowMap == null) {
+                mFloatWindowMap = new HashMap<>();
+            }
+            if (mFloatWindowMap.containsKey(mTag)) {
+                throw new IllegalArgumentException("FloatWindow of this tag has been added, Please set a new tag for the new FloatWindow");
+            }
+            if (mView == null && mLayoutId == 0) {
+                throw new IllegalArgumentException("View has not been set!");
+            }
+            if (mView == null) {
+                LayoutInflater inflate = (LayoutInflater)
+                        mApplicationContext.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
+                if (inflate != null) {
+                    mView = inflate.inflate(mLayoutId, null);
+                }
+            }
+            IFloatWindow floatWindowImpl = new IFloatWindowImpl(this);
+            mFloatWindowMap.put(mTag, floatWindowImpl);
+        }
+    }
+}

YCVideoPlayerLib/src/main/java/org/yczbj/ycvideoplayerlib/window/IFloatWindow.java

@@ -0,0 +1,27 @@
+package org.yczbj.ycvideoplayerlib.window;
+
+import android.view.View;
+
+
+public abstract class IFloatWindow {
+
+    public abstract void show();
+
+    public abstract void hide();
+
+    public abstract int getX();
+
+    public abstract int getY();
+
+    public abstract void updateX(int x);
+
+    public abstract void updateX(@WindowScreen.screenType int screenType, float ratio);
+
+    public abstract void updateY(int y);
+
+    public abstract void updateY(@WindowScreen.screenType int screenType, float ratio);
+
+    public abstract View getView();
+
+    abstract void dismiss();
+}

YCVideoPlayerLib/src/main/java/org/yczbj/ycvideoplayerlib/window/IFloatWindowImpl.java

@@ -0,0 +1,249 @@
+package org.yczbj.ycvideoplayerlib.window;
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.ObjectAnimator;
+import android.animation.PropertyValuesHolder;
+import android.animation.TimeInterpolator;
+import android.animation.ValueAnimator;
+import android.os.Build;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.animation.DecelerateInterpolator;
+
+
+public class IFloatWindowImpl extends IFloatWindow {
+
+
+    private FloatWindow.B mB;
+    private FloatView mFloatView;
+    private FloatLifecycle mFloatLifecycle;
+    private boolean isShow;
+    private boolean once = true;
+    private ValueAnimator mAnimator;
+    private TimeInterpolator mDecelerateInterpolator;
+
+    private IFloatWindowImpl() {
+
+    }
+
+    IFloatWindowImpl(FloatWindow.B b) {
+        mB = b;
+        if (mB.mMoveType == MoveType.fixed) {
+            if (Build.VERSION.SDK_INT >=25) {
+                mFloatView = new FloatPhone(b.mApplicationContext);
+            } else {
+                mFloatView = new FloatToast(b.mApplicationContext);
+            }
+        } else {
+            mFloatView = new FloatPhone(b.mApplicationContext);
+            initTouchEvent();
+        }
+        mFloatView.setSize(mB.mWidth, mB.mHeight);
+        mFloatView.setGravity(mB.gravity, mB.xOffset, mB.yOffset);
+        mFloatView.setView(mB.mView);
+        mFloatLifecycle = new FloatLifecycle(mB.mApplicationContext, mB.mShow, mB.mActivities, new LifecycleListener() {
+            @Override
+            public void onShow() {
+                show();
+            }
+
+            @Override
+            public void onHide() {
+                hide();
+            }
+
+            @Override
+            public void onPostHide() {
+                postHide();
+            }
+        });
+    }
+
+    @Override
+    public void show() {
+        if (once) {
+            mFloatView.init();
+            once = false;
+            isShow = true;
+        } else {
+            if (isShow) return;
+            getView().setVisibility(View.VISIBLE);
+            isShow = true;
+        }
+    }
+
+    @Override
+    public void hide() {
+        if (once || !isShow) return;
+        getView().setVisibility(View.INVISIBLE);
+        isShow = false;
+    }
+
+    @Override
+    void dismiss() {
+        mFloatView.dismiss();
+        isShow = false;
+    }
+
+    @Override
+    public void updateX(int x) {
+        checkMoveType();
+        mB.xOffset = x;
+        mFloatView.updateX(x);
+    }
+
+    @Override
+    public void updateY(int y) {
+        checkMoveType();
+        mB.yOffset = y;
+        mFloatView.updateY(y);
+    }
+
+    @Override
+    public void updateX(int screenType, float ratio) {
+        checkMoveType();
+        mB.xOffset = (int) ((screenType == WindowScreen.width ?
+                WindowUtil.getScreenWidth(mB.mApplicationContext) :
+                WindowUtil.getScreenHeight(mB.mApplicationContext)) * ratio);
+        mFloatView.updateX(mB.xOffset);
+
+    }
+
+    @Override
+    public void updateY(int screenType, float ratio) {
+        checkMoveType();
+        mB.yOffset = (int) ((screenType == WindowScreen.width ?
+                WindowUtil.getScreenWidth(mB.mApplicationContext) :
+                WindowUtil.getScreenHeight(mB.mApplicationContext)) * ratio);
+        mFloatView.updateY(mB.yOffset);
+
+    }
+
+    @Override
+    public int getX() {
+        return mFloatView.getX();
+    }
+
+    @Override
+    public int getY() {
+        return mFloatView.getY();
+    }
+
+
+    @Override
+    public View getView() {
+        return mB.mView;
+    }
+
+    void postHide() {
+        if (once || !isShow) return;
+        getView().post(new Runnable() {
+            @Override
+            public void run() {
+                getView().setVisibility(View.INVISIBLE);
+            }
+        });
+        isShow = false;
+    }
+
+    private void checkMoveType() {
+        if (mB.mMoveType == MoveType.fixed) {
+            throw new IllegalArgumentException("FloatWindow of this tag is not allowed to move!");
+        }
+    }
+
+    private void initTouchEvent() {
+        switch (mB.mMoveType) {
+            case MoveType.free:
+                break;
+            default:
+                getView().setOnTouchListener(new View.OnTouchListener() {
+                    float lastX, lastY, changeX, changeY;
+                    int newX, newY;
+
+                    @Override
+                    public boolean onTouch(View v, MotionEvent event) {
+
+                        switch (event.getAction()) {
+                            case MotionEvent.ACTION_DOWN:
+                                lastX = event.getRawX();
+                                lastY = event.getRawY();
+                                cancelAnimator();
+                                break;
+                            case MotionEvent.ACTION_MOVE:
+                                changeX = event.getRawX() - lastX;
+                                changeY = event.getRawY() - lastY;
+                                newX = (int) (mFloatView.getX() + changeX);
+                                newY = (int) (mFloatView.getY() + changeY);
+                                mFloatView.updateXY(newX, newY);
+                                lastX = event.getRawX();
+                                lastY = event.getRawY();
+                                break;
+                            case MotionEvent.ACTION_UP:
+                                switch (mB.mMoveType) {
+                                    case MoveType.slide:
+                                        int startX = mFloatView.getX();
+                                        int endX = (startX * 2 + v.getWidth() >
+                                                WindowUtil.getScreenWidth(mB.mApplicationContext)) ?
+                                                WindowUtil.getScreenWidth(mB.mApplicationContext) - v.getWidth() : 0;
+                                        mAnimator = ObjectAnimator.ofInt(startX, endX);
+                                        mAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
+                                            @Override
+                                            public void onAnimationUpdate(ValueAnimator animation) {
+                                                int x = (int) animation.getAnimatedValue();
+                                                mFloatView.updateX(x);
+                                            }
+                                        });
+                                        startAnimator();
+                                        break;
+                                    case MoveType.back:
+                                        PropertyValuesHolder pvhX = PropertyValuesHolder.ofInt("x", mFloatView.getX(), mB.xOffset);
+                                        PropertyValuesHolder pvhY = PropertyValuesHolder.ofInt("y", mFloatView.getY(), mB.yOffset);
+                                        mAnimator = ObjectAnimator.ofPropertyValuesHolder(pvhX, pvhY);
+                                        mAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
+                                            @Override
+                                            public void onAnimationUpdate(ValueAnimator animation) {
+                                                int x = (int) animation.getAnimatedValue("x");
+                                                int y = (int) animation.getAnimatedValue("y");
+                                                mFloatView.updateXY(x, y);
+                                            }
+                                        });
+                                        startAnimator();
+                                        break;
+                                }
+                                break;
+
+                        }
+                        return false;
+                    }
+                });
+        }
+    }
+
+    private void startAnimator() {
+        if (mB.mInterpolator == null) {
+            if (mDecelerateInterpolator == null) {
+                mDecelerateInterpolator = new DecelerateInterpolator();
+            }
+            mB.mInterpolator = mDecelerateInterpolator;
+        }
+        mAnimator.setInterpolator(mB.mInterpolator);
+        mAnimator.addListener(new AnimatorListenerAdapter() {
+            @Override
+            public void onAnimationEnd(Animator animation) {
+                mAnimator.removeAllUpdateListeners();
+                mAnimator.removeAllListeners();
+                mAnimator = null;
+            }
+        });
+        mAnimator.setDuration(mB.mDuration).start();
+    }
+
+    private void cancelAnimator() {
+        if (mAnimator != null && mAnimator.isRunning()) {
+            mAnimator.cancel();
+        }
+    }
+
+}

YCVideoPlayerLib/src/main/java/org/yczbj/ycvideoplayerlib/window/LifecycleListener.java

@@ -0,0 +1,11 @@
+package org.yczbj.ycvideoplayerlib.window;
+
+
+interface LifecycleListener {
+
+    void onShow();
+
+    void onHide();
+
+    void onPostHide();
+}

YCVideoPlayerLib/src/main/java/org/yczbj/ycvideoplayerlib/window/MoveType.java

@@ -0,0 +1,19 @@
+package org.yczbj.ycvideoplayerlib.window;
+
+import android.support.annotation.IntDef;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+public class MoveType {
+
+    public static final int fixed = 0;
+    public static final int free = 1;
+    public static final int active = 2;
+    public static final int slide = 3;
+    public static final int back = 4;
+
+    @IntDef({fixed, free, active, slide, back})
+    @Retention(RetentionPolicy.SOURCE)
+    @interface MOVE_TYPE {}
+}

YCVideoPlayerLib/src/main/java/org/yczbj/ycvideoplayerlib/window/MyLinearLayout.java

@@ -0,0 +1,27 @@
+package org.yczbj.ycvideoplayerlib.window;
+
+import android.content.Context;
+import android.support.annotation.Nullable;
+import android.util.AttributeSet;
+import android.view.MotionEvent;
+import android.widget.LinearLayout;
+
+
+public class MyLinearLayout extends LinearLayout {
+    public MyLinearLayout(Context context) {
+        super(context);
+    }
+
+    public MyLinearLayout(Context context, @Nullable AttributeSet attrs) {
+        super(context, attrs);
+    }
+
+    public MyLinearLayout(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
+        super(context, attrs, defStyleAttr);
+    }
+
+    @Override
+    public boolean onInterceptTouchEvent(MotionEvent ev) {
+        return true;
+    }
+}

YCVideoPlayerLib/src/main/java/org/yczbj/ycvideoplayerlib/window/PermissionActivity.java

@@ -0,0 +1,88 @@
+package org.yczbj.ycvideoplayerlib.window;
+
+import android.content.Context;
+import android.content.Intent;
+import android.net.Uri;
+import android.os.Build;
+import android.os.Bundle;
+import android.support.annotation.RequiresApi;
+import android.support.v7.app.AppCompatActivity;
+
+import java.util.ArrayList;
+import java.util.List;
+
+
+/**
+ * <pre>
+ *     @author yangchong
+ *     blog  : https://github.com/yangchong211
+ *     time  : 2018/2/10
+ *     desc  : 用于在内部自动申请权限
+ *     revise:
+ * </pre>
+ */
+public class PermissionActivity extends AppCompatActivity {
+
+    private static List<PermissionListener> mPermissionListenerList;
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        if (Build.VERSION.SDK_INT >= 23){
+            requestAlertWindowPermission();
+        }
+    }
+
+    @RequiresApi(api = 23)
+    private void requestAlertWindowPermission() {
+        Intent intent = new Intent("android.settings.action.MANAGE_OVERLAY_PERMISSION");
+        intent.setData(Uri.parse("package:" + getPackageName()));
+        startActivityForResult(intent, 1);
+    }
+
+
+    @RequiresApi(api = 23)
+    @Override
+    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
+        super.onActivityResult(requestCode, resultCode, data);
+        if (Build.VERSION.SDK_INT >= 23){
+            //用23以上编译即可出现canDrawOverlays
+            if (WindowUtil.hasPermission(this)) {
+                mPermissionListener.onSuccess();
+            } else {
+                mPermissionListener.onFail();
+            }
+        }
+        finish();
+    }
+
+    static synchronized void request(Context context, PermissionListener permissionListener) {
+        if (mPermissionListenerList == null) {
+            mPermissionListenerList = new ArrayList<>();
+            mPermissionListener = new PermissionListener() {
+                @Override
+                public void onSuccess() {
+                    for (PermissionListener listener : mPermissionListenerList) {
+                        listener.onSuccess();
+                    }
+                }
+
+                @Override
+                public void onFail() {
+                    for (PermissionListener listener : mPermissionListenerList) {
+                        listener.onFail();
+                    }
+                }
+            };
+            Intent intent = new Intent(context, PermissionActivity.class);
+            intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+            context.startActivity(intent);
+        }
+        mPermissionListenerList.add(permissionListener);
+    }
+
+
+    private static PermissionListener mPermissionListener;
+
+
+}

YCVideoPlayerLib/src/main/java/org/yczbj/ycvideoplayerlib/window/PermissionListener.java

@@ -0,0 +1,9 @@
+package org.yczbj.ycvideoplayerlib.window;
+
+
+interface PermissionListener {
+
+    void onSuccess();
+
+    void onFail();
+}

YCVideoPlayerLib/src/main/java/org/yczbj/ycvideoplayerlib/window/SmallWindowTouch.java

@@ -0,0 +1,83 @@
+package org.yczbj.ycvideoplayerlib.window;
+
+import android.util.Log;
+import android.view.MotionEvent;
+import android.view.View;
+import android.widget.FrameLayout;
+
+
+import org.yczbj.ycvideoplayerlib.controller.VideoPlayerController;
+import org.yczbj.ycvideoplayerlib.player.VideoPlayer;
+
+
+/**
+ * <pre>
+ *     @author yangchong
+ *     blog  : https://github.com/yangchong211
+ *     time  : 2018/8/29
+ *     desc  : 小窗口触摸移动
+ *     revise:
+ * </pre>
+ */
+public class SmallWindowTouch implements View.OnTouchListener {
+
+    private int mDownX, mDownY;
+    private int mMarginLeft, mMarginTop;
+    private int _xDelta, _yDelta;
+    private View mView;
+
+
+    SmallWindowTouch(View view, int marginLeft, int marginTop) {
+        super();
+        mMarginLeft = marginLeft;
+        mMarginTop = marginTop;
+        mView = view;
+    }
+
+
+    @Override
+    public boolean onTouch(View view, MotionEvent event) {
+        final int X = (int) event.getRawX();
+        final int Y = (int) event.getRawY();
+        Log.e("onTouch","---X---"+X + "---Y---"+Y);
+        switch (event.getAction() & MotionEvent.ACTION_MASK) {
+            case MotionEvent.ACTION_DOWN:
+                mDownX = X;
+                mDownY = Y;
+
+                FrameLayout.LayoutParams lParams = (FrameLayout.LayoutParams) mView.getLayoutParams();
+                _xDelta = X - lParams.leftMargin;
+                _yDelta = Y - lParams.topMargin;
+
+                break;
+            case MotionEvent.ACTION_UP:
+                if (Math.abs(mDownY - Y) < 5 && Math.abs(mDownX - X) < 5) {
+                    return false;
+                } else {
+                    return true;
+                }
+            case MotionEvent.ACTION_MOVE:
+                FrameLayout.LayoutParams layoutParams = (FrameLayout.LayoutParams) mView.getLayoutParams();
+                layoutParams.leftMargin = X - _xDelta;
+                layoutParams.topMargin = Y - _yDelta;
+                if (layoutParams.leftMargin >= mMarginLeft) {
+                    layoutParams.leftMargin = mMarginLeft;
+                }
+
+                if (layoutParams.topMargin >= mMarginTop) {
+                    layoutParams.topMargin = mMarginTop;
+                }
+
+                if (layoutParams.leftMargin <= 0) {
+                    layoutParams.leftMargin = 0;
+                }
+
+                if (layoutParams.topMargin <= 0) {
+                    layoutParams.topMargin = 0;
+                }
+                mView.setLayoutParams(layoutParams);
+        }
+        return false;
+    }
+
+}

YCVideoPlayerLib/src/main/java/org/yczbj/ycvideoplayerlib/window/WindowScreen.java

@@ -0,0 +1,16 @@
+package org.yczbj.ycvideoplayerlib.window;
+
+import android.support.annotation.IntDef;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+
+public class WindowScreen {
+    public static final int width = 0;
+    public static final int height = 1;
+
+    @IntDef({width, height})
+    @Retention(RetentionPolicy.SOURCE)
+    @interface screenType {}
+}

YCVideoPlayerLib/src/main/java/org/yczbj/ycvideoplayerlib/window/WindowUtil.java

@@ -0,0 +1,47 @@
+package org.yczbj.ycvideoplayerlib.window;
+
+import android.content.Context;
+import android.graphics.Point;
+import android.os.Build;
+import android.provider.Settings;
+import android.support.annotation.RequiresApi;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.WindowManager;
+
+import java.lang.reflect.Method;
+
+
+public class WindowUtil {
+
+
+    @RequiresApi(api = Build.VERSION_CODES.M)
+    public static boolean hasPermission(Context context) {
+        return Settings.canDrawOverlays(context);
+    }
+
+
+    private static Point sPoint;
+
+    static int getScreenWidth(Context context) {
+        if (sPoint == null) {
+            sPoint = new Point();
+            WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
+            if (wm != null) {
+                wm.getDefaultDisplay().getSize(sPoint);
+            }
+        }
+        return sPoint.x;
+    }
+
+    static int getScreenHeight(Context context) {
+        if (sPoint == null) {
+            sPoint = new Point();
+            WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
+            if (wm != null) {
+                wm.getDefaultDisplay().getSize(sPoint);
+            }
+        }
+        return sPoint.y;
+    }
+}

YCVideoPlayerLib/src/main/res/drawable/selector_details_try_see.xml

@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<selector xmlns:android="http://schemas.android.com/apk/res/android"
-    android:shape="rectangle">
-    <item android:state_pressed="false" android:drawable="@drawable/shape_details_try_see"/>
-</selector>

YCVideoPlayerLib/src/main/res/drawable/selector_try_see.xml

@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<selector xmlns:android="http://schemas.android.com/apk/res/android">
-
-    <item android:state_pressed="true"
-        android:drawable="@drawable/ic_try_see_img_pressed"/>
-    <item android:state_pressed="false"
-        android:drawable="@drawable/ic_try_see_img_normal"/>
-
-</selector>

YCVideoPlayerLib/src/main/res/drawable/shape_details_try_see.xml

@@ -1,11 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<shape xmlns:android="http://schemas.android.com/apk/res/android"
-    android:shape="rectangle">
-
-    <!-- 填充的颜色 -->
-    <solid android:color="#E2B170" />
-    <!-- 设置按钮的四个角为弧形 -->
-    <!-- android:radius 弧形的半径 -->
-    <corners android:radius="15dp" />
-
-</shape>

YCVideoPlayerLib/src/main/res/layout/custom_video_player.xml

@@ -42,7 +42,9 @@
         android:visibility="visible"
         android:text="00:00"
         android:textColor="@android:color/white"
-        android:textSize="12sp"/>
+        android:textSize="12sp"
+        android:layout_alignParentRight="true"
+        android:layout_marginRight="8dp" />
     <!--中间开始播放按钮-->
     <ImageView
         android:id="@+id/center_start"
@@ -51,14 +53,6 @@
         android:layout_centerInParent="true"
         android:src="@drawable/ic_player_center_start"
         android:visibility="visible"/>
-    <!--试看按钮-->
-    <ImageView
-        android:id="@+id/iv_try_see"
-        android:layout_width="wrap_content"
-        android:layout_height="wrap_content"
-        android:layout_centerInParent="true"
-        android:src="@drawable/selector_try_see"
-        android:visibility="gone"/>
     <!--锁屏布局，全屏时展示，其他隐藏-->
     <FrameLayout
         android:id="@+id/fl_lock"
@@ -67,7 +61,8 @@
         android:visibility="visible"
         android:layout_centerVertical="true"
         android:layout_marginStart="15dp"
-        android:background="@drawable/shape_lock_bg">
+        android:background="@drawable/shape_lock_bg"
+        android:layout_marginLeft="15dp">
         <ImageView
             android:id="@+id/iv_lock"
             android:layout_width="wrap_content"
@@ -76,7 +71,4 @@
             android:src="@drawable/player_unlock_btn"/>
     </FrameLayout>
 
-    <!--试看布局，非会员显示该布局-->
-    <include layout="@layout/custom_video_player_try_see"/>
-
 </RelativeLayout>

YCVideoPlayerLib/src/main/res/layout/custom_video_player_bottom.xml

@@ -23,7 +23,8 @@
         android:layout_marginStart="8dp"
         android:text="00:00"
         android:textColor="@android:color/white"
-        android:textSize="12sp"/>
+        android:textSize="12sp"
+        android:layout_marginLeft="8dp" />
     <TextView
         android:layout_width="wrap_content"
         android:layout_height="wrap_content"
@@ -37,7 +38,8 @@
         android:layout_marginEnd="8dp"
         android:text="00:00"
         android:textColor="@android:color/white"
-        android:textSize="12sp"/>
+        android:textSize="12sp"
+        android:layout_marginRight="8dp" />
     <SeekBar
         android:id="@+id/seek"
         android:layout_width="0dp"
@@ -59,7 +61,9 @@
         android:text="超清"
         android:textColor="@android:color/white"
         android:textSize="14sp"
-        android:visibility="gone"/>
+        android:visibility="gone"
+        android:paddingLeft="1dp"
+        android:paddingRight="4dp" />
     <ImageView
         android:id="@+id/full_screen"
         android:layout_width="20dp"

YCVideoPlayerLib/src/main/res/layout/custom_video_player_try_see.xml

@@ -1,30 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<LinearLayout
-    xmlns:android="http://schemas.android.com/apk/res/android"
-    android:id="@+id/ll_try_see"
-    android:layout_width="wrap_content"
-    android:layout_height="wrap_content"
-    android:paddingTop="20dp"
-    android:orientation="vertical"
-    android:visibility="gone"
-    android:layout_centerInParent="true">
-    <TextView
-        android:id="@+id/tv_see_content"
-        android:layout_width="wrap_content"
-        android:layout_height="wrap_content"
-        android:gravity="center"
-        android:lineSpacingExtra="8dp"
-        android:textColor="#ffffff"
-        android:textSize="14sp"/>
-    <Button
-        android:id="@+id/btn_vip"
-        android:layout_width="100dp"
-        android:layout_height="30dp"
-        android:layout_gravity="center_horizontal"
-        android:gravity="center"
-        android:layout_marginTop="10dp"
-        android:background="@drawable/shape_details_try_see"
-        android:textSize="14sp"
-        android:textColor="#ffffff"
-        android:text="成为会员"/>
-</LinearLayout>

YCVideoPlayerLib/src/main/res/layout/view_window_dialog.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8"?>
+<org.yczbj.ycvideoplayerlib.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">
+
+    <org.yczbj.ycvideoplayerlib.player.VideoPlayer
+        android:id="@+id/video_player"
+        android:layout_width="160dp"
+        android:layout_height="120dp"/>
+
+</org.yczbj.ycvideoplayerlib.window.MyLinearLayout>

app/build.gradle

@@ -74,8 +74,6 @@ dependencies {
     //其他库
     compile 'com.flyco.tablayout:FlycoTabLayout_Lib:2.1.0@aar'      //导航栏
     compile 'com.blankj:utilcode:1.7.1'                             //工具类
-    compile project(':jiaozivideoplayer')
-    //compile 'cn.jzvd:jiaozivideoplayer:6.2.3'                       //视频库
     compile 'com.squareup.picasso:picasso:2.5.2'                    //图片
     compile 'com.github.bumptech.glide:glide:3.7.0'                 //谷歌图片加载库
     compile 'jp.wasabeef:glide-transformations:2.0.1'
@@ -96,7 +94,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.9'                            //播放器
-    //compile project(':YCVideoPlayerLib')
-    compile 'cn.yc:YCStatusBarLib:1.3'                              //状态栏
+    compile 'cn.yc:YCVideoPlayerLib:2.6.0'                            //播放器
+//    compile project(':YCVideoPlayerLib')
+    compile 'cn.yc:YCStatusBarLib:1.3.1'                              //状态栏
 }

app/src/main/AndroidManifest.xml

@@ -5,6 +5,7 @@
     <uses-permission android:name="android.permission.INTERNET"/>
     <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
     <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
+    <uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW" />
 
     <application
         android:name=".base.BaseApplication"
@@ -39,76 +40,6 @@
             android:configChanges="orientation|keyboardHidden|screenSize"
             android:screenOrientation="portrait"/>
         <activity android:name=".ui.movie.view.activity.MovieNewsActivity"/>
-
-
-        <!--下面这些均是测试视频播放器-->
-        <activity android:name=".ui.test.test1.TestActivity"
-            android:configChanges="orientation|keyboardHidden|screenSize"
-            android:screenOrientation="portrait"/>
-        <activity android:name=".ui.test.test1.view.first.TestFirstActivity"
-            android:configChanges="orientation|keyboardHidden|screenSize"
-            android:screenOrientation="portrait"/>
-        <activity android:name=".ui.test.test1.view.first.TestApiFirstActivity"
-            android:configChanges="orientation|keyboardHidden|screenSize"
-            android:screenOrientation="portrait"/>
-        <activity android:name=".ui.test.test1.view.first.TestApiSecondActivity"
-            android:configChanges="orientation|keyboardHidden|screenSize"
-            android:screenOrientation="portrait"/>
-        <activity android:name=".ui.test.test1.view.first.TestApiThreeActivity"
-            android:configChanges="orientation|keyboardHidden|screenSize"
-            android:screenOrientation="portrait"/>
-        <activity android:name=".ui.test.test1.view.first.TestApiFourActivity"
-            android:configChanges="orientation|keyboardHidden|screenSize"
-            android:screenOrientation="portrait"/>
-        <activity android:name=".ui.test.test1.view.first.TestApiFiveActivity"
-            android:configChanges="orientation|keyboardHidden|screenSize"
-            android:screenOrientation="portrait"/>
-        <activity android:name=".ui.test.test1.view.first.TestApiSixActivity"
-            android:configChanges="orientation|keyboardHidden|screenSize"
-            android:screenOrientation="portrait"/>
-        <activity android:name=".ui.test.test1.view.second.TestSecondActivity"
-            android:configChanges="orientation|keyboardHidden|screenSize"
-            android:screenOrientation="portrait"/>
-        <activity android:name=".ui.test.test1.view.second.TestListFirstActivity"
-            android:configChanges="orientation|keyboardHidden|screenSize"
-            android:screenOrientation="portrait"/>
-        <activity android:name=".ui.test.test1.view.second.TestListSecondActivity"
-            android:configChanges="orientation|keyboardHidden|screenSize"
-            android:screenOrientation="portrait"/>
-        <activity android:name=".ui.test.test1.view.second.TestListThirdActivity"
-            android:configChanges="orientation|keyboardHidden|screenSize"
-            android:screenOrientation="portrait"/>
-        <activity android:name=".ui.test.test1.view.second.TestListFourActivity"
-            android:configChanges="orientation|keyboardHidden|screenSize"
-            android:screenOrientation="portrait"/>
-        <activity android:name=".ui.test.test1.view.second.TestListFiveActivity"
-            android:configChanges="orientation|keyboardHidden|screenSize"
-            android:screenOrientation="portrait"/>
-        <activity android:name=".ui.test.test1.view.three.TestThreeActivity"
-            android:configChanges="orientation|keyboardHidden|screenSize"
-            android:screenOrientation="portrait"/>
-        <activity android:name=".ui.test.test1.view.three.TestTinyFirstActivity"
-            android:configChanges="orientation|keyboardHidden|screenSize"
-            android:screenOrientation="portrait"/>
-        <activity android:name=".ui.test.test1.view.three.TestTinyThirdActivity"
-            android:configChanges="orientation|keyboardHidden|screenSize"
-            android:screenOrientation="portrait"/>
-        <activity android:name=".ui.test.test1.view.three.TestTinyFourActivity"
-            android:configChanges="orientation|keyboardHidden|screenSize"
-            android:screenOrientation="portrait"/>
-        <activity android:name=".ui.test.test1.view.three.TestTinyFiveActivity"
-            android:configChanges="orientation|keyboardHidden|screenSize"
-            android:screenOrientation="portrait"/>
-        <activity android:name=".ui.test.test1.view.four.TestFourActivity"
-            android:configChanges="orientation|keyboardHidden|screenSize"
-            android:screenOrientation="portrait"/>
-        <activity android:name=".ui.test.test1.view.five.TestFiveActivity"
-            android:configChanges="orientation|keyboardHidden|screenSize"
-            android:screenOrientation="portrait"/>
-        <activity android:name=".ui.test.test1.view.six.TestSixActivity"
-            android:configChanges="orientation|keyboardHidden|screenSize"
-            android:screenOrientation="portrait"/>
-
         <activity android:name=".ui.test.test2.TestMyActivity"
             android:configChanges="orientation|keyboardHidden|screenSize"
             android:screenOrientation="portrait"/>
@@ -131,6 +62,10 @@
             android:configChanges="orientation|keyboardHidden|screenSize"
             android:screenOrientation="portrait"/>
         <activity android:name=".ui.test.test4.MediaPlayerActivity"/>
+        <activity android:name=".ui.home.view.activity.WindowActivity"
+            android:configChanges="orientation|keyboardHidden|screenSize"
+            android:screenOrientation="portrait"/>
+        <activity android:name=".ui.home.view.activity.EmptyActivity"/>
 
         <service android:name=".service.InitializeService"/>
 

app/src/main/java/org/yczbj/ycvideoplayer/api/constant/ConstantVideo.java

@@ -16,7 +16,8 @@ public class ConstantVideo {
             "http://jzvd.nathen.cn/d2438fd1c37c4618a704513ad38d68c5/68626a9d53ca421c896ac8010f172b68-5287d2089db37e62345123a1be272f8b.mp4",
             "http://jzvd.nathen.cn/25a8d119cfa94b49a7a4117257d8ebd7/f733e65a22394abeab963908f3c336db-5287d2089db37e62345123a1be272f8b.mp4",
             "http://jzvd.nathen.cn/7512edd1ad834d40bb5b978402274b1a/9691c7f2d7b74b5e811965350a0e5772-5287d2089db37e62345123a1be272f8b.mp4",
-            "http://jzvd.nathen.cn/c6e3dc12a1154626b3476d9bf3bd7266/6b56c5f0dc31428083757a45764763b0-5287d2089db37e62345123a1be272f8b.mp4"
+            "http://jzvd.nathen.cn/c6e3dc12a1154626b3476d9bf3bd7266/6b56c5f0dc31428083757a45764763b0-5287d2089db37e62345123a1be272f8b.mp4",
+            "http://play.g3proxy.lecloud.com/vod/v2/MjUxLzE2LzgvbGV0di11dHMvMTQvdmVyXzAwXzIyLTExMDc2NDEzODctYXZjLTE5OTgxOS1hYWMtNDgwMDAtNTI2MTEwLTE3MDg3NjEzLWY1OGY2YzM1NjkwZTA2ZGFmYjg2MTVlYzc5MjEyZjU4LTE0OTg1NTc2ODY4MjMubXA0?b=259&mmsid=65565355&tm=1499247143&key=f0eadb4f30c404d49ff8ebad673d3742&platid=3&splatid=345&playid=0&tss=no&vtype=21&cvid=2026135183914&payff=0&pip=08cc52f8b09acd3eff8bf31688ddeced&format=0&sign=mb&dname=mobile&expect=1&tag=mobile&xformat=super"
     };
 
 

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

@@ -7,16 +7,9 @@ import android.support.multidex.MultiDex;
 import android.util.Log;
 
 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.ycvideoplayer.util.ScreenDensityUtils;
-import org.yczbj.ycvideoplayerlib.VideoLogUtil;
-
-import java.net.Proxy;
 
 /**
  * ================================================

app/src/main/java/org/yczbj/ycvideoplayer/service/InitializeService.java

@@ -11,7 +11,7 @@ import org.yczbj.ycvideoplayer.BuildConfig;
 import org.yczbj.ycvideoplayer.base.BaseApplication;
 import org.yczbj.ycvideoplayer.base.BaseConfig;
 import org.yczbj.ycvideoplayer.util.LogUtils;
-import org.yczbj.ycvideoplayerlib.VideoLogUtil;
+import org.yczbj.ycvideoplayerlib.utils.VideoLogUtil;
 
 import java.net.Proxy;
 

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

@@ -0,0 +1,34 @@
+package org.yczbj.ycvideoplayer.ui.home.view.activity;
+
+import android.content.Intent;
+import android.os.Bundle;
+import android.support.v7.app.AppCompatActivity;
+import android.view.View;
+import android.widget.Button;
+
+import org.yczbj.ycvideoplayer.R;
+
+import butterknife.Bind;
+import butterknife.ButterKnife;
+
+public class EmptyActivity extends AppCompatActivity {
+
+
+    @Bind(R.id.jump_other)
+    Button jumpOther;
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.activity_empty);
+        ButterKnife.bind(this);
+        jumpOther.setOnClickListener(new View.OnClickListener() {
+            @Override
+            public void onClick(View v) {
+                startActivity(new Intent(EmptyActivity.this, EmptyActivity.class));
+            }
+        });
+    }
+
+
+}

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

@@ -10,7 +10,6 @@ import android.support.design.widget.FloatingActionButton;
 import android.support.v4.widget.SwipeRefreshLayout;
 import android.support.v7.widget.LinearLayoutManager;
 import android.support.v7.widget.RecyclerView;
-import android.util.Log;
 import android.util.TypedValue;
 import android.view.Gravity;
 import android.view.LayoutInflater;
@@ -25,7 +24,6 @@ import android.widget.TextView;
 
 import com.blankj.utilcode.util.SizeUtils;
 import com.pedaily.yc.ycdialoglib.customToast.ToastUtil;
-import com.squareup.picasso.Picasso;
 
 import org.yczbj.ycrefreshviewlib.YCRefreshView;
 import org.yczbj.ycrefreshviewlib.adapter.RecyclerArrayAdapter;
@@ -43,22 +41,16 @@ import org.yczbj.ycvideoplayer.ui.home.view.adapter.DownloadVideoAdapter;
 import org.yczbj.ycvideoplayer.ui.home.view.adapter.NarrowImageAdapter;
 import org.yczbj.ycvideoplayer.ui.home.view.adapter.VideoPlayerMeAdapter;
 import org.yczbj.ycvideoplayer.util.AppUtil;
-import org.yczbj.ycvideoplayerlib.ConstantKeys;
-import org.yczbj.ycvideoplayerlib.VideoPlayer;
-import org.yczbj.ycvideoplayerlib.VideoPlayerController;
-import org.yczbj.ycvideoplayerlib.listener.OnMemberClickListener;
-import org.yczbj.ycvideoplayerlib.listener.OnVideoBackListener;
-import org.yczbj.ycvideoplayerlib.listener.OnVideoControlListener;
+import org.yczbj.ycvideoplayerlib.manager.VideoPlayerManager;
+import org.yczbj.ycvideoplayerlib.player.VideoPlayer;
+import org.yczbj.ycvideoplayerlib.constant.ConstantKeys;
+import org.yczbj.ycvideoplayerlib.controller.VideoPlayerController;
+import org.yczbj.ycvideoplayerlib.inter.listener.OnVideoBackListener;
 
 import java.util.ArrayList;
 import java.util.List;
 
 import butterknife.Bind;
-import cn.jzvd.CustomView.MyJZVideoPlayerStandard;
-import cn.jzvd.JZUserAction;
-import cn.jzvd.JZUserActionStandard;
-import cn.jzvd.JZVideoPlayer;
-import cn.jzvd.JZVideoPlayerStandard;
 import cn.ycbjie.ycstatusbarlib.bar.YCAppBar;
 
 /**
@@ -84,6 +76,22 @@ public class VideoPlayerJzActivity extends BaseActivity implements VideoPlayerJz
     private VideoPlayerJzContract.Presenter presenter = new VideoPlayerJzPresenter(this);
     private VideoPlayerMeAdapter adapter;
 
+    @Override
+    protected void onStop() {
+        super.onStop();
+        VideoPlayerManager.instance().releaseVideoPlayer();
+    }
+
+
+    @Override
+    public void onBackPressed() {
+        if (VideoPlayerManager.instance().onBackPressed()) {
+            return;
+        }
+        super.onBackPressed();
+    }
+
+
 
     @Override
     protected void onCreate(@Nullable Bundle savedInstanceState) {
@@ -137,7 +145,7 @@ public class VideoPlayerJzActivity extends BaseActivity implements VideoPlayerJz
         //videoPlayer.setPlayerType(VideoPlayer.TYPE_NATIVE);
         videoPlayer.setPlayerType(ConstantKeys.IjkPlayerType.TYPE_IJK);
         //网络视频地址
-        String videoUrl = ConstantVideo.VideoPlayerList[0];
+        String videoUrl = ConstantVideo.VideoPlayerList[7];
         //设置视频地址和请求头部
         videoPlayer.setUp(videoUrl, null);
         //是否从上一次的位置继续播放

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

@@ -6,7 +6,6 @@ import android.os.Bundle;
 import android.os.Handler;
 import android.support.annotation.Nullable;
 import android.support.design.widget.FloatingActionButton;
-import android.support.v4.content.ContextCompat;
 import android.support.v4.widget.SwipeRefreshLayout;
 import android.support.v7.widget.LinearLayoutManager;
 import android.support.v7.widget.RecyclerView;
@@ -41,14 +40,14 @@ import org.yczbj.ycvideoplayer.ui.home.view.adapter.DialogListAdapter;
 import org.yczbj.ycvideoplayer.ui.home.view.adapter.NarrowImageAdapter;
 import org.yczbj.ycvideoplayer.ui.home.view.adapter.VideoPlayerMeAdapter;
 import org.yczbj.ycvideoplayer.util.AppUtil;
-import org.yczbj.ycvideoplayerlib.ConstantKeys;
-import org.yczbj.ycvideoplayerlib.VideoPlayerUtils;
-import org.yczbj.ycvideoplayerlib.listener.OnMemberClickListener;
-import org.yczbj.ycvideoplayerlib.listener.OnPlayOrPauseListener;
-import org.yczbj.ycvideoplayerlib.listener.OnVideoBackListener;
-import org.yczbj.ycvideoplayerlib.listener.OnVideoControlListener;
-import org.yczbj.ycvideoplayerlib.VideoPlayer;
-import org.yczbj.ycvideoplayerlib.VideoPlayerController;
+import org.yczbj.ycvideoplayerlib.manager.VideoPlayerManager;
+import org.yczbj.ycvideoplayerlib.player.VideoPlayer;
+import org.yczbj.ycvideoplayerlib.constant.ConstantKeys;
+import org.yczbj.ycvideoplayerlib.utils.VideoPlayerUtils;
+import org.yczbj.ycvideoplayerlib.inter.listener.OnPlayOrPauseListener;
+import org.yczbj.ycvideoplayerlib.inter.listener.OnVideoBackListener;
+import org.yczbj.ycvideoplayerlib.inter.listener.OnVideoControlListener;
+import org.yczbj.ycvideoplayerlib.controller.VideoPlayerController;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -91,6 +90,21 @@ public class VideoPlayerMeActivity extends BaseActivity implements VideoPlayerMe
         super.onDestroy();
         presenter.unSubscribe();
     }
+    @Override
+    protected void onStop() {
+        super.onStop();
+        VideoPlayerManager.instance().releaseVideoPlayer();
+    }
+
+
+    @Override
+    public void onBackPressed() {
+        if (VideoPlayerManager.instance().onBackPressed()) {
+            return;
+        }
+        super.onBackPressed();
+    }
+
 
 
     @Override
@@ -130,7 +144,7 @@ public class VideoPlayerMeActivity extends BaseActivity implements VideoPlayerMe
         //videoPlayer.setPlayerType(VideoPlayer.TYPE_NATIVE);
         videoPlayer.setPlayerType(ConstantKeys.IjkPlayerType.TYPE_IJK);
         //网络视频地址
-        String videoUrl = ConstantVideo.VideoPlayerList[0];
+        String videoUrl = ConstantVideo.VideoPlayerList[7];
         //设置视频地址和请求头部
         videoPlayer.setUp(videoUrl, null);
         //是否从上一次的位置继续播放
@@ -143,7 +157,6 @@ public class VideoPlayerMeActivity extends BaseActivity implements VideoPlayerMe
         controller.setTitle("高仿优酷视频播放页面");
         controller.setLoadingType(ConstantKeys.Loading.LOADING_QQ);
         controller.setTopVisibility(true);
-        controller.setMemberType(false,2);
         controller.imageView().setBackgroundResource(R.color.blackText);
         controller.setOnVideoBackListener(new OnVideoBackListener() {
             @Override
@@ -157,21 +170,6 @@ public class VideoPlayerMeActivity extends BaseActivity implements VideoPlayerMe
 
             }
         });
-        controller.setOnMemberClickListener(new OnMemberClickListener() {
-            @Override
-            public void onClick(int type) {
-                switch (type){
-                    case ConstantKeys.Gender.LOGIN:
-                        ToastUtil.showToast(VideoPlayerMeActivity.this,"登录");
-                        break;
-                    case ConstantKeys.Gender.MEMBER:
-                        ToastUtil.showToast(VideoPlayerMeActivity.this,"充值会员");
-                        break;
-                    default:
-                        break;
-                }
-            }
-        });
         controller.setOnVideoControlListener(new OnVideoControlListener() {
             @Override
             public void onVideoControlClick(int type) {

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

@@ -0,0 +1,145 @@
+package org.yczbj.ycvideoplayer.ui.home.view.activity;
+
+import android.content.Intent;
+import android.net.Uri;
+import android.os.Build;
+import android.provider.Settings;
+import android.support.annotation.RequiresApi;
+import android.view.View;
+import android.view.animation.BounceInterpolator;
+import android.widget.Button;
+
+import com.blankj.utilcode.util.ActivityUtils;
+
+import org.yczbj.ycvideoplayer.R;
+import org.yczbj.ycvideoplayer.base.mvp1.BaseActivity;
+import org.yczbj.ycvideoplayer.ui.test.test2.TestMyActivity;
+import org.yczbj.ycvideoplayerlib.manager.VideoPlayerManager;
+import org.yczbj.ycvideoplayerlib.player.VideoPlayer;
+import org.yczbj.ycvideoplayerlib.window.FloatPlayerView;
+import org.yczbj.ycvideoplayerlib.window.FloatWindow;
+import org.yczbj.ycvideoplayerlib.window.MoveType;
+import org.yczbj.ycvideoplayerlib.window.WindowScreen;
+import org.yczbj.ycvideoplayerlib.window.WindowUtil;
+
+import butterknife.Bind;
+
+
+public class WindowActivity extends BaseActivity implements View.OnClickListener {
+
+    @Bind(R.id.video_player)
+    VideoPlayer videoPlayer;
+    @Bind(R.id.btn_1)
+    Button btn1;
+    @Bind(R.id.btn_2)
+    Button btn2;
+
+    @Override
+    protected void onDestroy() {
+        super.onDestroy();
+        /*
+         * 这里在返回主页的时候销毁了，因为不想和DEMO中其他页面冲突
+         */
+        VideoPlayerManager.instance().releaseVideoPlayer();
+        FloatWindow.destroy();
+    }
+
+
+
+    @Override
+    public void onBackPressed() {
+        if (VideoPlayerManager.instance().onBackPressed()) {
+            return;
+        }
+        super.onBackPressed();
+    }
+
+
+
+    @Override
+    public int getContentView() {
+        return R.layout.activity_window;
+    }
+
+    @Override
+    public void initView() {
+        if (Build.VERSION.SDK_INT >= 23) {
+            if (!WindowUtil.hasPermission(this)) {
+                requestAlertWindowPermission();
+            }
+        }
+    }
+
+    @Override
+    public void initListener() {
+        btn1.setOnClickListener(this);
+        btn2.setOnClickListener(this);
+    }
+
+    @Override
+    public void initData() {
+
+    }
+
+    @Override
+    public void onClick(View v) {
+        switch (v.getId()){
+            case R.id.btn_1:
+                startWindow();
+                break;
+            case R.id.btn_2:
+                startActivity(new Intent(this, EmptyActivity.class));
+                break;
+        }
+    }
+
+    private void startWindow() {
+        if (FloatWindow.get() != null) {
+            return;
+        }
+        String url = "http://play.g3proxy.lecloud.com/vod/v2/MjUxLzE2LzgvbGV0di11dHMvMTQvdmVyXzAwXzIyLTExMDc2NDEzODctYXZjLTE5OTgxOS1hYWMtNDgwMDAtNTI2MTEwLTE3MDg3NjEzLWY1OGY2YzM1NjkwZTA2ZGFmYjg2MTVlYzc5MjEyZjU4LTE0OTg1NTc2ODY4MjMubXA0?b=259&mmsid=65565355&tm=1499247143&key=f0eadb4f30c404d49ff8ebad673d3742&platid=3&splatid=345&playid=0&tss=no&vtype=21&cvid=2026135183914&payff=0&pip=08cc52f8b09acd3eff8bf31688ddeced&format=0&sign=mb&dname=mobile&expect=1&tag=mobile&xformat=super";
+        FloatPlayerView.setUrl(url);
+        FloatPlayerView floatPlayerView = new FloatPlayerView(getApplicationContext());
+        floatPlayerView.setCompletedListener(new FloatPlayerView.CompletedListener() {
+            @Override
+            public void Completed() {
+                FloatWindow.get().hide();
+            }
+        });
+        FloatWindow
+                .with(getApplicationContext())
+                .setView(floatPlayerView)
+                //.setWidth(WindowScreen.width, 0.4f)
+                //.setHeight(WindowScreen.width, 0.3f)
+                .setX(WindowScreen.width, 0.8f)             //这个是设置位置
+                .setY(WindowScreen.height, 0.3f)
+                .setMoveType(MoveType.slide)
+                .setFilter(false)
+                //.setFilter(true, WindowActivity.class, EmptyActivity.class)
+                .setMoveStyle(500, new BounceInterpolator())
+                .build();
+        FloatWindow.get().show();
+    }
+
+
+    @RequiresApi(api = 23)
+    private void requestAlertWindowPermission() {
+        Intent intent = new Intent(Settings.ACTION_MANAGE_OVERLAY_PERMISSION,
+                Uri.parse("package:" + getPackageName()));
+        startActivityForResult(intent, 1);
+    }
+
+    @RequiresApi(api = 23)
+    @Override
+    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
+        super.onActivityResult(requestCode, resultCode, data);
+        if (Build.VERSION.SDK_INT >= 23){
+            if (WindowUtil.hasPermission(this)) {
+
+            } else {
+                this.finish();
+            }
+        }
+    }
+
+}

app/src/main/java/org/yczbj/ycvideoplayer/ui/home/view/fragment/HomeFragment.java

@@ -5,16 +5,13 @@ import android.graphics.Color;
 import android.support.v4.widget.SwipeRefreshLayout;
 import android.support.v7.widget.RecyclerView;
 import android.view.View;
-import android.view.ViewGroup;
 import android.widget.ImageView;
 import android.widget.LinearLayout;
-import android.widget.TextView;
 
 import com.alibaba.android.vlayout.DelegateAdapter;
 import com.alibaba.android.vlayout.VirtualLayoutManager;
 import com.alibaba.android.vlayout.layout.GridLayoutHelper;
 import com.alibaba.android.vlayout.layout.LinearLayoutHelper;
-import com.blankj.utilcode.util.ScreenUtils;
 import com.pedaily.yc.ycdialoglib.customToast.ToastUtil;
 import com.yc.cn.ycbannerlib.first.BannerView;
 import com.yc.cn.ycbannerlib.first.util.SizeUtil;
@@ -22,24 +19,17 @@ import com.yc.cn.ycbaseadapterlib.BaseViewHolder;
 
 import org.yczbj.ycvideoplayer.R;
 import org.yczbj.ycvideoplayer.api.constant.Constant;
-import org.yczbj.ycvideoplayer.api.constant.ConstantVideo;
 import org.yczbj.ycvideoplayer.base.BaseConfig;
 import org.yczbj.ycvideoplayer.base.BaseDelegateAdapter;
 import org.yczbj.ycvideoplayer.base.mvp1.BaseFragment;
-import org.yczbj.ycvideoplayer.ui.test.test1.TestActivity;
+import org.yczbj.ycvideoplayer.ui.home.view.activity.WindowActivity;
 import org.yczbj.ycvideoplayer.ui.test.test2.TestMyActivity;
 import org.yczbj.ycvideoplayer.ui.home.view.activity.VideoPlayerJzActivity;
 import org.yczbj.ycvideoplayer.ui.home.view.activity.VideoPlayerMeActivity;
 import org.yczbj.ycvideoplayer.ui.home.view.adapter.BannerPagerAdapter;
 import org.yczbj.ycvideoplayer.ui.main.view.activity.MainActivity;
 import org.yczbj.ycvideoplayer.util.LogUtils;
-import org.yczbj.ycvideoplayerlib.ConstantKeys;
-import org.yczbj.ycvideoplayerlib.VideoPlayer;
-import org.yczbj.ycvideoplayerlib.VideoPlayerController;
-import org.yczbj.ycvideoplayerlib.VideoPlayerManager;
-import org.yczbj.ycvideoplayerlib.listener.OnPlayOrPauseListener;
-import org.yczbj.ycvideoplayerlib.listener.OnVideoBackListener;
-import org.yczbj.ycvideoplayerlib.listener.OnVideoControlListener;
+import org.yczbj.ycvideoplayerlib.controller.VideoPlayerController;
 
 import java.util.ArrayList;
 import java.util.LinkedList;
@@ -315,7 +305,7 @@ public class HomeFragment extends BaseFragment implements View.OnClickListener {
                     public void onClick(View v) {
                         switch (v.getId()) {
                             case R.id.tv_home_first:
-                                startActivity(TestActivity.class);
+                                startActivity(WindowActivity.class);
                                 break;
                             case R.id.tv_home_second:
                                 startActivity(TestMyActivity.class);

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

@@ -9,7 +9,6 @@ import android.support.v4.app.FragmentTransaction;
 import android.view.KeyEvent;
 import android.widget.FrameLayout;
 
-import com.blankj.utilcode.util.NetworkUtils;
 import com.blankj.utilcode.util.ToastUtils;
 import com.flyco.tablayout.CommonTabLayout;
 import com.flyco.tablayout.listener.CustomTabEntity;
@@ -30,7 +29,7 @@ import org.yczbj.ycvideoplayer.ui.home.view.fragment.HomeFragment;
 import org.yczbj.ycvideoplayer.ui.main.contract.MainContract;
 import org.yczbj.ycvideoplayer.ui.main.presenter.MainPresenter;
 import org.yczbj.ycvideoplayer.ui.person.MeFragment;
-import org.yczbj.ycvideoplayerlib.VideoPlayerManager;
+import org.yczbj.ycvideoplayerlib.manager.VideoPlayerManager;
 
 import java.util.ArrayList;
 

app/src/main/java/org/yczbj/ycvideoplayer/ui/movie/presenter/MoviePresenter.java

@@ -83,11 +83,6 @@ public class MoviePresenter implements MovieContract.Presenter {
                     public void run() throws Exception {
                         LogUtils.e(TAG+"----"+"run()");
                     }
-                }, new Consumer<Disposable>() {
-                    @Override
-                    public void accept(Disposable disposable) throws Exception {
-                        LogUtils.e(TAG+"----"+"accept(Disposable disposable)");
-                    }
                 });
         mSubscriptions.add(subscribe);
     }

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

@@ -33,11 +33,11 @@ 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;
-import org.yczbj.ycvideoplayerlib.VideoPlayerManager;
+import org.yczbj.ycvideoplayerlib.player.VideoPlayer;
+import org.yczbj.ycvideoplayerlib.constant.ConstantKeys;
+import org.yczbj.ycvideoplayerlib.inter.listener.OnVideoBackListener;
+import org.yczbj.ycvideoplayerlib.controller.VideoPlayerController;
+import org.yczbj.ycvideoplayerlib.manager.VideoPlayerManager;
 
 import java.util.ArrayList;
 import java.util.List;

app/src/main/java/org/yczbj/ycvideoplayer/ui/test/test1/TestActivity.java

@@ -1,210 +0,0 @@
-package org.yczbj.ycvideoplayer.ui.test.test1;
-
-import android.graphics.Color;
-import android.util.Log;
-import android.view.View;
-import android.widget.Button;
-
-import com.squareup.picasso.Picasso;
-
-import org.yczbj.ycvideoplayer.R;
-import org.yczbj.ycvideoplayer.base.mvp1.BaseActivity;
-import org.yczbj.ycvideoplayer.ui.test.test1.view.first.TestFirstActivity;
-import org.yczbj.ycvideoplayer.ui.test.test1.view.five.TestFiveActivity;
-import org.yczbj.ycvideoplayer.ui.test.test1.view.four.TestFourActivity;
-import org.yczbj.ycvideoplayer.ui.test.test1.view.second.TestSecondActivity;
-import org.yczbj.ycvideoplayer.ui.test.test1.view.six.TestSixActivity;
-import org.yczbj.ycvideoplayer.ui.test.test1.view.three.TestThreeActivity;
-
-import butterknife.Bind;
-import cn.jzvd.CustomView.MyJZVideoPlayerStandard;
-import cn.jzvd.JZUserAction;
-import cn.jzvd.JZUserActionStandard;
-import cn.jzvd.JZVideoPlayer;
-import cn.jzvd.JZVideoPlayerStandard;
-import cn.ycbjie.ycstatusbarlib.bar.YCAppBar;
-
-/**
- * @author yc
- * @date 2017/12/29
- * 参考项目：
- *          https://github.com/CarGuo/GSYVideoPlayer
- *          https://github.com/HotBitmapGG/bilibili-android-client
- *          https://github.com/jjdxmashl/jjdxm_ijkplayer
- *          https://github.com/JasonChow1989/JieCaoVideoPlayer-develop          2年前
- *          https://github.com/open-android/JieCaoVideoPlayer                   1年前
- *          https://github.com/lipangit/JiaoZiVideoPlayer                       4个月前
- *          个人感觉jiaozi这个播放器，与JieCaoVideoPlayer-develop有惊人的类同，借鉴了上面两个项目[JieCao]
- */
-public class TestActivity extends BaseActivity implements View.OnClickListener {
-
-    @Bind(R.id.jz_video)
-    MyJZVideoPlayerStandard jzVideo;
-    @Bind(R.id.btn_1)
-    Button btn1;
-    @Bind(R.id.btn_2)
-    Button btn2;
-    @Bind(R.id.btn_3)
-    Button btn3;
-    @Bind(R.id.btn_4)
-    Button btn4;
-    @Bind(R.id.btn_5)
-    Button btn5;
-    @Bind(R.id.btn_6)
-    Button btn6;
-
-    @Override
-    protected void onPause() {
-        super.onPause();
-        JZVideoPlayer.releaseAllVideos();
-    }
-
-    @Override
-    public void onBackPressed() {
-        if (JZVideoPlayer.backPress()) {
-            return;
-        }
-        super.onBackPressed();
-    }
-
-
-    @Override
-    public int getContentView() {
-        return R.layout.activity_test;
-    }
-
-
-    private String path = "http://sandcolleges.zero2ipo.com.cn/vc-talk-video/1510661872877.mp4";
-
-    @Override
-    public void initView() {
-        YCAppBar.setStatusBarLightMode(this, Color.WHITE);
-        jzVideo.setUp(path
-                , JZVideoPlayerStandard.SCREEN_WINDOW_NORMAL, "饺子快长大");
-        Picasso.with(this)
-                .load("http://jzvd-pic.nathen.cn/jzvd-pic/1bb2ebbe-140d-4e2e-abd2-9e7e564f71ac.png")
-                .into(jzVideo.thumbImageView);
-        JZVideoPlayer.setJzUserAction(new MyUserActionStandard());
-    }
-
-
-    @Override
-    public void initListener() {
-        btn1.setOnClickListener(this);
-        btn2.setOnClickListener(this);
-        btn3.setOnClickListener(this);
-        btn4.setOnClickListener(this);
-        btn5.setOnClickListener(this);
-        btn6.setOnClickListener(this);
-    }
-
-
-    @Override
-    public void initData() {
-
-    }
-
-    @Override
-    public void onClick(View view) {
-        switch (view.getId()) {
-            case R.id.btn_1:
-                startActivity(TestFirstActivity.class);
-                break;
-            case R.id.btn_2:
-                startActivity(TestSecondActivity.class);
-                break;
-            case R.id.btn_3:
-                startActivity(TestThreeActivity.class);
-                break;
-            case R.id.btn_4:
-                startActivity(TestFourActivity.class);
-                break;
-            case R.id.btn_5:
-                startActivity(TestFiveActivity.class);
-                break;
-            case R.id.btn_6:
-                startActivity(TestSixActivity.class);
-                break;
-            default:
-                break;
-        }
-    }
-
-
-    /**
-     * 这只是给埋点统计用户数据用的，不能写和播放相关的逻辑，监听事件请参考MyJZVideoPlayerStandard，复写函数取得相应事件
-     */
-    class MyUserActionStandard implements JZUserActionStandard {
-        @Override
-        public void onEvent(int type, Object url, int screen, Object... objects) {
-            switch (type) {
-                case JZUserAction.ON_CLICK_START_ICON:
-                    Log.i("TEST_USER_EVENT", "ON_CLICK_START_ICON" + " title is : " + (objects.length == 0 ? "" : objects[0]) + " url is : " + url + " screen is : " + screen);
-                    break;
-                case JZUserAction.ON_CLICK_START_ERROR:
-                    Log.i("TEST_USER_EVENT", "ON_CLICK_START_ERROR" + " title is : " + (objects.length == 0 ? "" : objects[0]) + " url is : " + url + " screen is : " + screen);
-                    break;
-                case JZUserAction.ON_CLICK_START_AUTO_COMPLETE:
-                    Log.i("TEST_USER_EVENT", "ON_CLICK_START_AUTO_COMPLETE" + " title is : " + (objects.length == 0 ? "" : objects[0]) + " url is : " + url + " screen is : " + screen);
-                    break;
-                case JZUserAction.ON_CLICK_PAUSE:
-                    Log.i("TEST_USER_EVENT", "ON_CLICK_PAUSE" + " title is : " + (objects.length == 0 ? "" : objects[0]) + " url is : " + url + " screen is : " + screen);
-                    break;
-                case JZUserAction.ON_CLICK_RESUME:
-                    Log.i("TEST_USER_EVENT", "ON_CLICK_RESUME" + " title is : " + (objects.length == 0 ? "" : objects[0]) + " url is : " + url + " screen is : " + screen);
-                    break;
-                case JZUserAction.ON_SEEK_POSITION:
-                    Log.i("TEST_USER_EVENT", "ON_SEEK_POSITION" + " title is : " + (objects.length == 0 ? "" : objects[0]) + " url is : " + url + " screen is : " + screen);
-                    break;
-                case JZUserAction.ON_AUTO_COMPLETE:
-                    Log.i("TEST_USER_EVENT", "ON_AUTO_COMPLETE" + " title is : " + (objects.length == 0 ? "" : objects[0]) + " url is : " + url + " screen is : " + screen);
-                    break;
-                case JZUserAction.ON_ENTER_FULLSCREEN:
-                    Log.i("TEST_USER_EVENT", "ON_ENTER_FULLSCREEN" + " title is : " + (objects.length == 0 ? "" : objects[0]) + " url is : " + url + " screen is : " + screen);
-                    break;
-                case JZUserAction.ON_QUIT_FULLSCREEN:
-                    Log.i("TEST_USER_EVENT", "ON_QUIT_FULLSCREEN" + " title is : " + (objects.length == 0 ? "" : objects[0]) + " url is : " + url + " screen is : " + screen);
-                    break;
-                case JZUserAction.ON_ENTER_TINYSCREEN:
-                    Log.i("TEST_USER_EVENT", "ON_ENTER_TINYSCREEN" + " title is : " + (objects.length == 0 ? "" : objects[0]) + " url is : " + url + " screen is : " + screen);
-                    break;
-                case JZUserAction.ON_QUIT_TINYSCREEN:
-                    Log.i("TEST_USER_EVENT", "ON_QUIT_TINYSCREEN" + " title is : " + (objects.length == 0 ? "" : objects[0]) + " url is : " + url + " screen is : " + screen);
-                    break;
-                case JZUserAction.ON_TOUCH_SCREEN_SEEK_VOLUME:
-                    Log.i("TEST_USER_EVENT", "ON_TOUCH_SCREEN_SEEK_VOLUME" + " title is : " + (objects.length == 0 ? "" : objects[0]) + " url is : " + url + " screen is : " + screen);
-                    break;
-                case JZUserAction.ON_TOUCH_SCREEN_SEEK_POSITION:
-                    Log.i("TEST_USER_EVENT", "ON_TOUCH_SCREEN_SEEK_POSITION" + " title is : " + (objects.length == 0 ? "" : objects[0]) + " url is : " + url + " screen is : " + screen);
-                    break;
-                case JZUserActionStandard.ON_CLICK_START_THUMB:
-                    Log.i("TEST_USER_EVENT", "ON_CLICK_START_THUMB" + " title is : " + (objects.length == 0 ? "" : objects[0]) + " url is : " + url + " screen is : " + screen);
-                    break;
-                case JZUserActionStandard.ON_CLICK_BLANK:
-                    Log.i("TEST_USER_EVENT", "ON_CLICK_BLANK" + " title is : " + (objects.length == 0 ? "" : objects[0]) + " url is : " + url + " screen is : " + screen);
-                    break;
-                default:
-                    Log.i("TEST_USER_EVENT", "unknow");
-                    break;
-            }
-        }
-    }
-
-
-    /**
-     * 关于代码分析
-     * 1.博客连接：https://www.jianshu.com/p/308e4a59908c?utm_campaign=maleskine&utm_content=note&utm_medium=seo_notes&utm_source=recommendation
-     *
-     *
-     * 关于JiaoZiVideoPlayer项目存在的问题
-     * 1.小窗播放比较常用情景是在列表中，如果这个Item已经滑动出界面为不可见状态，这是需要小窗播放，并且小窗能左划删除等操作，
-     *   这个问题调试过几个月，一直没解决，就是列表滑动的时候如何准确的判断视频的Item滑动出列表，列表的onScroll函数，
-     *   他的回调是有延迟的，如果列表滑的快回调次数少滑动慢回调次数多，如果快速滑动，在onScroll回调之前列表就会复用，视频就会重置
-     *
-     * 2.全屏播放是否可以定制上一部，下一部视频功能
-     *
-     * 3.视频播放过程中状态：加载中，播放失败，没网呢，重新加载等状态如何切换。而不是一直转圈
-     */
-
-
-}

app/src/main/java/org/yczbj/ycvideoplayer/ui/test/test1/model/VideoConstant.java

@@ -1,112 +0,0 @@
-package org.yczbj.ycvideoplayer.ui.test.test1.model;
-
-/**
- * Created by shengjun on 16/9/10.
- */
-public class VideoConstant {
-
-    public static String[] videoUrlList = {
-                    "http://jzvd.nathen.cn/c494b340ff704015bb6682ffde3cd302/64929c369124497593205a4190d7d128-5287d2089db37e62345123a1be272f8b.mp4",
-                    "http://jzvd.nathen.cn/63f3f73712544394be981d9e4f56b612/69c5767bb9e54156b5b60a1b6edeb3b5-5287d2089db37e62345123a1be272f8b.mp4",
-                    "http://jzvd.nathen.cn/b201be3093814908bf987320361c5a73/2f6d913ea25941ffa78cc53a59025383-5287d2089db37e62345123a1be272f8b.mp4",
-                    "http://jzvd.nathen.cn/d2438fd1c37c4618a704513ad38d68c5/68626a9d53ca421c896ac8010f172b68-5287d2089db37e62345123a1be272f8b.mp4",
-                    "http://jzvd.nathen.cn/25a8d119cfa94b49a7a4117257d8ebd7/f733e65a22394abeab963908f3c336db-5287d2089db37e62345123a1be272f8b.mp4",
-                    "http://jzvd.nathen.cn/7512edd1ad834d40bb5b978402274b1a/9691c7f2d7b74b5e811965350a0e5772-5287d2089db37e62345123a1be272f8b.mp4",
-                    "http://jzvd.nathen.cn/c6e3dc12a1154626b3476d9bf3bd7266/6b56c5f0dc31428083757a45764763b0-5287d2089db37e62345123a1be272f8b.mp4"
-            };
-
-    public static String[] videoThumbList = {
-                    "http://jzvd-pic.nathen.cn/jzvd-pic/00b026e7-b830-4994-bc87-38f4033806a6.jpg",
-                    "http://jzvd-pic.nathen.cn/jzvd-pic/1d935cc5-a1e7-4779-bdfa-20fd7a60724c.jpg",
-                    "http://jzvd-pic.nathen.cn/jzvd-pic/a019ffc1-556c-4a85-b70c-b1b49811d577.jpg",
-                    "http://jzvd-pic.nathen.cn/jzvd-pic/6fc2ae91-36e2-44c5-bb10-29ae5d5c678c.png",
-                    "http://jzvd-pic.nathen.cn/jzvd-pic/f03cee95-9b78-4dd5-986f-d162c06c385c.png",
-                    "http://jzvd-pic.nathen.cn/jzvd-pic/e7ea659f-c3d2-4979-9ea5-f993b05e5930.png",
-                    ""
-            };
-
-    public static String[][] videoUrls =
-            {
-                    {
-                            "http://jzvd.nathen.cn/6ea7357bc3fa4658b29b7933ba575008/fbbba953374248eb913cb1408dc61d85-5287d2089db37e62345123a1be272f8b.mp4",
-                            "http://jzvd.nathen.cn/35b3dc97fbc240219961bd1fccc6400b/8d9b76ab5a584bce84a8afce012b72d3-5287d2089db37e62345123a1be272f8b.mp4",
-                            "http://jzvd.nathen.cn/df6096e7878541cbbea3f7298683fbed/ef76450342914427beafe9368a4e0397-5287d2089db37e62345123a1be272f8b.mp4",
-                            "http://jzvd.nathen.cn/384d341e000145fb82295bdc54ecef88/103eab5afca34baebc970378dd484942-5287d2089db37e62345123a1be272f8b.mp4",
-                            "http://jzvd.nathen.cn/f55530ba8a59403da0621cbf4faef15e/adae4f2e3ecf4ea780beb057e7bce84c-5287d2089db37e62345123a1be272f8b.mp4",
-                            "http://jzvd.nathen.cn/6340efd1962946ad80eeffd19b3be89c/65b499c0f16e4dd8900497e51ffa0949-5287d2089db37e62345123a1be272f8b.mp4",
-                            "http://jzvd.nathen.cn/f07fa9fddd1e45a6ae1570c7fe7967c1/c6db82685b894e25b523b1cb28d79f2e-5287d2089db37e62345123a1be272f8b.mp4",
-                            "http://jzvd.nathen.cn/d2e969f2ec734520b46ab0965d2b68bd/f124edfef6c24be8b1a7b7f996ccc5e0-5287d2089db37e62345123a1be272f8b.mp4",
-                            "http://jzvd.nathen.cn/4f965ad507ef4194a60a943a34cfe147/32af151ea132471f92c9ced2cff785ea-5287d2089db37e62345123a1be272f8b.mp4",
-                            "http://jzvd.nathen.cn/342a5f7ef6124a4a8faf00e738b8bee4/cf6d9db0bd4d41f59d09ea0a81e918fd-5287d2089db37e62345123a1be272f8b.mp4"
-                    },
-                    {
-                            "http://jzvd.nathen.cn/623f75c3beea4b1781ea37940e70bbe4/b9cee3fd1a09487ca99ef789cdc41312-5287d2089db37e62345123a1be272f8b.mp4",
-                            "http://jzvd.nathen.cn/d8c137ceba9849f8b2f454a55a96266f/910c8381ff894905b5bc272f8194382a-5287d2089db37e62345123a1be272f8b.mp4",
-                            "http://jzvd.nathen.cn/b8a589e5f12c45fdad96674d08affd31/f1d7229f553f414283033af3e292c6c9-5287d2089db37e62345123a1be272f8b.mp4",
-                            "http://jzvd.nathen.cn/8abcdf98ec6a418b945a70fe9dd6fc7f/5cb36416a23a4da8b15d3eaa5e19a1e6-5287d2089db37e62345123a1be272f8b.mp4"
-                    },
-                    {
-                            "http://jzvd.nathen.cn/1b61da23555d4ce28c805ea303711aa5/7a33ac2af276441bb4b9838f32d8d710-5287d2089db37e62345123a1be272f8b.mp4",
-                            "http://jzvd.nathen.cn/d525f756aabf4b0588c2152fb94e07f5/d9f59bef829a472a9ca066620d9b871a-5287d2089db37e62345123a1be272f8b.mp4",
-                            "http://jzvd.nathen.cn/6e2fdec45dfa44a6802e95f8e4bc3280/a6a5273ac4244333923991be0583ffc7-5287d2089db37e62345123a1be272f8b.mp4",
-                            "http://jzvd.nathen.cn/22b4de0e2b1245959c5baa77fe0bf14e/896a137559084b7eb879f5441faff20d-5287d2089db37e62345123a1be272f8b.mp4"
-                    }
-            };
-
-    public static String[][] videoThumbs =
-            {
-                    {
-                            "http://jzvd-pic.nathen.cn/jzvd-pic/bd7ffc84-8407-4037-a078-7d922ce0fb0f.jpg",
-                            "http://jzvd-pic.nathen.cn/jzvd-pic/f2dbd12e-b1cb-4daf-aff1-8c6be2f64d1a.jpg",
-                            "http://jzvd-pic.nathen.cn/jzvd-pic/ccd86ca1-66c7-4331-9450-a3b7f765424a.png",
-                            "http://jzvd-pic.nathen.cn/jzvd-pic/2adde364-9be1-4864-b4b9-0b0bcc81ef2e.jpg",
-                            "http://jzvd-pic.nathen.cn/jzvd-pic/2a877211-4b68-4e3a-87be-6d2730faef27.png",
-                            "http://jzvd-pic.nathen.cn/jzvd-pic/aaeb5da9-ac50-4712-a28d-863fe40f1fc6.png",
-                            "http://jzvd-pic.nathen.cn/jzvd-pic/e565f9cc-eedc-45f0-99f8-5b0fa3aed567%281%29.jpg",
-                            "http://jzvd-pic.nathen.cn/jzvd-pic/3430ec64-e6a7-4d8e-b044-9d408e075b7c.jpg",
-                            "http://jzvd-pic.nathen.cn/jzvd-pic/2204a578-609b-440e-8af7-a0ee17ff3aee.jpg",
-                            "http://jzvd-pic.nathen.cn/jzvd-pic/1bb2ebbe-140d-4e2e-abd2-9e7e564f71ac.png"
-                    },
-                    {
-                            "http://jzvd-pic.nathen.cn/jzvd-pic/f18ee453-6aec-40a5-a046-3203111dd303.jpg",
-                            "http://jzvd-pic.nathen.cn/jzvd-pic/00f5a243-1e9f-426c-94f4-888971987edb.jpg",
-                            "http://jzvd-pic.nathen.cn/jzvd-pic/7df34ee9-1e4f-48f4-8acd-748c52368298.jpg",
-                            "http://jzvd-pic.nathen.cn/jzvd-pic/ef46e139-e378-4298-8441-144888294f1f.png"
-                    },
-                    {
-                            "http://jzvd-pic.nathen.cn/jzvd-pic/0e58101d-5b47-4100-8fb3-0cce057fd622.jpg",
-                            "http://jzvd-pic.nathen.cn/jzvd-pic/d6d3a520-b183-4867-8746-5b6aba6c1724.png",
-                            "http://jzvd-pic.nathen.cn/jzvd-pic/caa3dade-5744-486d-a1b7-9780aebb9eb5.jpg",
-                            "http://jzvd-pic.nathen.cn/jzvd-pic/2c3e62bb-6a32-4fb0-a1d5-d1260ad436a4.png"
-                    }
-            };
-
-    public static String[][] videoTitles =
-            {
-                    {
-                            "饺子出来",
-                            "饺子溢出",
-                            "饺子我姓王",
-                            "饺子趴好了",
-                            "饺子很渴",
-                            "饺子这样不好",
-                            "饺子别笑",
-                            "饺子坐火车",
-                            "饺子打游戏",
-                            "饺子快长大"
-                    },
-                    {
-                            "饺子堵车了",
-                            "饺子喝点",
-                            "饺子快走",
-                            "饺子别这样"
-                    },
-                    {
-                            "饺子想偷",
-                            "饺子害羞了",
-                            "饺子淡定",
-                            "饺子好喜欢"
-                    }
-            };
-
-}

app/src/main/java/org/yczbj/ycvideoplayer/ui/test/test1/view/first/TestApiFirstActivity.java

@@ -1,118 +0,0 @@
-package org.yczbj.ycvideoplayer.ui.test.test1.view.first;
-
-import com.squareup.picasso.Picasso;
-
-import org.yczbj.ycvideoplayer.R;
-import org.yczbj.ycvideoplayer.base.mvp1.BaseActivity;
-import org.yczbj.ycvideoplayer.ui.test.test1.model.VideoConstant;
-
-import butterknife.Bind;
-import cn.jzvd.CustomView.JZVideoPlayerStandardAutoCompleteAfterFullscreen;
-import cn.jzvd.CustomView.JZVideoPlayerStandardShowShareButtonAfterFullscreen;
-import cn.jzvd.CustomView.JZVideoPlayerStandardShowTextureViewAfterAutoComplete;
-import cn.jzvd.CustomView.JZVideoPlayerStandardShowTitleAfterFullscreen;
-import cn.jzvd.JZVideoPlayer;
-
-/**
- * Description:
- * Update:
- * CreatedTime:2017/12/29
- * Author:yc
- */
-public class TestApiFirstActivity extends BaseActivity {
-
-    @Bind(R.id.standard_with_share)
-    JZVideoPlayerStandardShowShareButtonAfterFullscreen standardWithShare;
-    @Bind(R.id.standard_show_title_after_fullscreen)
-    JZVideoPlayerStandardShowTitleAfterFullscreen standardShowTitleAfterFullscreen;
-    @Bind(R.id.standard_show_auto_complete)
-    JZVideoPlayerStandardShowTextureViewAfterAutoComplete standardShowAutoComplete;
-    @Bind(R.id.standard_auto_complete)
-    JZVideoPlayerStandardAutoCompleteAfterFullscreen standardAutoComplete;
-    @Bind(R.id.video_1_1)
-    JZVideoPlayerStandardAutoCompleteAfterFullscreen video11;
-    @Bind(R.id.video_16_9)
-    JZVideoPlayerStandardAutoCompleteAfterFullscreen video169;
-
-    @Override
-    public void onBackPressed() {
-        if (JZVideoPlayer.backPress()) {
-            return;
-        }
-        super.onBackPressed();
-    }
-
-    @Override
-    protected void onPause() {
-        super.onPause();
-        JZVideoPlayer.releaseAllVideos();
-    }
-
-
-    @Override
-    public int getContentView() {
-        return R.layout.activity_test_api_first;
-    }
-
-    @Override
-    public void initView() {
-
-    }
-
-    @Override
-    public void initListener() {
-
-    }
-
-    @Override
-    public void initData() {
-        standardWithShare = (JZVideoPlayerStandardShowShareButtonAfterFullscreen)findViewById(R.id.standard_with_share);
-        standardWithShare.setUp(VideoConstant.videoUrlList[3], JZVideoPlayer.SCREEN_WINDOW_NORMAL
-                , "饺子想呼吸");
-        Picasso.with(this)
-                .load(VideoConstant.videoThumbList[3])
-                .into(standardWithShare.thumbImageView);
-
-
-        standardShowTitleAfterFullscreen = (JZVideoPlayerStandardShowTitleAfterFullscreen) findViewById(R.id.standard_show_title_after_fullscreen);
-        standardShowTitleAfterFullscreen.setUp(VideoConstant.videoUrlList[4], JZVideoPlayer.SCREEN_WINDOW_NORMAL
-                , "饺子想摇头");
-        Picasso.with(this)
-                .load(VideoConstant.videoThumbList[4])
-                .into(standardShowTitleAfterFullscreen.thumbImageView);
-
-        standardShowAutoComplete = (JZVideoPlayerStandardShowTextureViewAfterAutoComplete) findViewById(R.id.standard_show_auto_complete);
-        standardShowAutoComplete.setUp(VideoConstant.videoUrlList[5], JZVideoPlayer.SCREEN_WINDOW_NORMAL
-                , "饺子想旅行");
-        Picasso.with(this)
-                .load(VideoConstant.videoThumbList[5])
-                .into(standardShowAutoComplete.thumbImageView);
-
-        standardAutoComplete = (JZVideoPlayerStandardAutoCompleteAfterFullscreen) findViewById(R.id.standard_auto_complete);
-        standardAutoComplete.setUp(VideoConstant.videoUrls[0][1], JZVideoPlayer.SCREEN_WINDOW_NORMAL
-                , "饺子没来");
-        Picasso.with(this)
-                .load(VideoConstant.videoThumbs[0][1])
-                .into(standardAutoComplete.thumbImageView);
-
-        video11 = (JZVideoPlayerStandardAutoCompleteAfterFullscreen) findViewById(R.id.video_1_1);
-        video11.setUp(VideoConstant.videoUrls[0][1], JZVideoPlayer.SCREEN_WINDOW_NORMAL
-                , "饺子有事吗");
-        Picasso.with(this)
-                .load(VideoConstant.videoThumbs[0][1])
-                .into(video11.thumbImageView);
-        video11.widthRatio = 1;
-        video11.heightRatio = 1;
-
-        video169 = (JZVideoPlayerStandardAutoCompleteAfterFullscreen) findViewById(R.id.video_16_9);
-        video169.setUp(VideoConstant.videoUrls[0][1], JZVideoPlayer.SCREEN_WINDOW_NORMAL
-                , "饺子来不了");
-        Picasso.with(this)
-                .load(VideoConstant.videoThumbs[0][1])
-                .into(video169.thumbImageView);
-        video169.widthRatio = 16;
-        video169.heightRatio = 9;
-    }
-
-
-}

app/src/main/java/org/yczbj/ycvideoplayer/ui/test/test1/view/first/TestApiFiveActivity.java

@@ -1,102 +0,0 @@
-package org.yczbj.ycvideoplayer.ui.test.test1.view.first;
-
-import android.view.View;
-import android.widget.Button;
-
-import com.squareup.picasso.Picasso;
-
-import org.yczbj.ycvideoplayer.R;
-import org.yczbj.ycvideoplayer.base.mvp1.BaseActivity;
-import org.yczbj.ycvideoplayer.ui.test.test1.model.VideoConstant;
-
-import butterknife.Bind;
-import cn.jzvd.JZVideoPlayer;
-import cn.jzvd.JZVideoPlayerStandard;
-
-/**
- * Description:
- * Update:
- * CreatedTime:2017/12/29
- * Author:yc
- */
-public class TestApiFiveActivity extends BaseActivity implements View.OnClickListener {
-
-    @Bind(R.id.jz_video)
-    JZVideoPlayerStandard jzVideo;
-    @Bind(R.id.rotation_to_90)
-    Button rotationTo90;
-    @Bind(R.id.video_image_display_fill_parent)
-    Button videoImageDisplayFillParent;
-    @Bind(R.id.video_image_display_fill_crop)
-    Button videoImageDisplayFillCrop;
-    @Bind(R.id.video_image_diaplay_original)
-    Button videoImageDiaplayOriginal;
-
-
-    @Override
-    protected void onPause() {
-        super.onPause();
-        JZVideoPlayer.releaseAllVideos();
-        JZVideoPlayer.setVideoImageDisplayType(JZVideoPlayer.VIDEO_IMAGE_DISPLAY_TYPE_ADAPTER);
-    }
-
-    @Override
-    public void onBackPressed() {
-        if (JZVideoPlayer.backPress()) {
-            return;
-        }
-        super.onBackPressed();
-    }
-
-
-    @Override
-    public int getContentView() {
-        return R.layout.activity_test_api_five;
-    }
-
-    @Override
-    public void initView() {
-        jzVideo.setUp(VideoConstant.videoUrls[0][7]
-                , JZVideoPlayerStandard.SCREEN_WINDOW_NORMAL, VideoConstant.videoTitles[0][7]);
-        Picasso.with(this)
-                .load(VideoConstant.videoThumbs[0][7])
-                .into(jzVideo.thumbImageView);
-        // The Point IS
-        jzVideo.videoRotation = 180;
-    }
-
-    @Override
-    public void initListener() {
-        rotationTo90.setOnClickListener(this);
-        videoImageDisplayFillParent.setOnClickListener(this);
-        videoImageDisplayFillCrop.setOnClickListener(this);
-        videoImageDiaplayOriginal.setOnClickListener(this);
-    }
-
-    @Override
-    public void initData() {
-
-    }
-
-    @Override
-    public void onClick(View view) {
-        switch (view.getId()){
-            case R.id.rotation_to_90:
-                JZVideoPlayer.setTextureViewRotation(90);
-                break;
-            case R.id.video_image_display_fill_parent:
-                JZVideoPlayer.setVideoImageDisplayType(JZVideoPlayer.VIDEO_IMAGE_DISPLAY_TYPE_FILL_PARENT);
-                break;
-            case R.id.video_image_display_fill_crop:
-                JZVideoPlayer.setVideoImageDisplayType(JZVideoPlayer.VIDEO_IMAGE_DISPLAY_TYPE_FILL_SCROP);
-                break;
-            case R.id.video_image_diaplay_original:
-                JZVideoPlayer.setVideoImageDisplayType(JZVideoPlayer.VIDEO_IMAGE_DISPLAY_TYPE_ORIGINAL);
-                break;
-            default:
-
-                break;
-        }
-    }
-
-}

app/src/main/java/org/yczbj/ycvideoplayer/ui/test/test1/view/first/TestApiFourActivity.java

@@ -1,67 +0,0 @@
-package org.yczbj.ycvideoplayer.ui.test.test1.view.first;
-
-import android.widget.LinearLayout;
-
-import com.squareup.picasso.Picasso;
-
-import org.yczbj.ycvideoplayer.R;
-import org.yczbj.ycvideoplayer.base.mvp1.BaseActivity;
-import org.yczbj.ycvideoplayer.ui.test.test1.model.VideoConstant;
-
-import butterknife.Bind;
-import cn.jzvd.JZVideoPlayer;
-import cn.jzvd.JZVideoPlayerStandard;
-
-/**
- * Description:
- * Update:
- * CreatedTime:2017/12/29
- * Author:yc
- */
-public class TestApiFourActivity extends BaseActivity {
-
-    @Bind(R.id.video_player)
-    JZVideoPlayerStandard videoPlayer;
-    @Bind(R.id.drawer_layout)
-    LinearLayout drawerLayout;
-
-    @Override
-    public void onBackPressed() {
-        if (JZVideoPlayer.backPress()) {
-            return;
-        }
-        super.onBackPressed();
-    }
-
-    @Override
-    protected void onPause() {
-        super.onPause();
-        JZVideoPlayer.releaseAllVideos();
-    }
-
-    @Override
-    public int getContentView() {
-        return R.layout.activity_test_api_four;
-    }
-
-    @Override
-    public void initView() {
-        videoPlayer.setUp(VideoConstant.videoUrlList[0]
-                , JZVideoPlayerStandard.SCREEN_WINDOW_NORMAL, "饺子不信");
-        Picasso.with(this)
-                .load(VideoConstant.videoThumbList[0])
-                .into(videoPlayer.thumbImageView);
-    }
-
-    @Override
-    public void initListener() {
-
-    }
-
-    @Override
-    public void initData() {
-
-    }
-
-
-}

app/src/main/java/org/yczbj/ycvideoplayer/ui/test/test1/view/first/TestApiSecondActivity.java

@@ -1,33 +0,0 @@
-package org.yczbj.ycvideoplayer.ui.test.test1.view.first;
-
-import org.yczbj.ycvideoplayer.R;
-import org.yczbj.ycvideoplayer.base.mvp1.BaseActivity;
-
-/**
- * Description:
- * Update:
- * CreatedTime:2017/12/29
- * Author:yc
- */
-public class TestApiSecondActivity extends BaseActivity {
-
-    @Override
-    public int getContentView() {
-        return R.layout.activity_test_api_first;
-    }
-
-    @Override
-    public void initView() {
-
-    }
-
-    @Override
-    public void initListener() {
-
-    }
-
-    @Override
-    public void initData() {
-
-    }
-}

app/src/main/java/org/yczbj/ycvideoplayer/ui/test/test1/view/first/TestApiSixActivity.java

@@ -1,110 +0,0 @@
-package org.yczbj.ycvideoplayer.ui.test.test1.view.first;
-
-import android.view.View;
-import android.widget.Button;
-
-import com.squareup.picasso.Picasso;
-
-import org.yczbj.ycvideoplayer.R;
-import org.yczbj.ycvideoplayer.base.mvp1.BaseActivity;
-
-import java.io.IOException;
-import java.util.LinkedHashMap;
-
-import butterknife.Bind;
-import cn.jzvd.CustomMediaPlayer.CustomMediaPlayerAssertFolder;
-import cn.jzvd.CustomMediaPlayer.JZMediaIjkplayer;
-import cn.jzvd.JZMediaSystem;
-import cn.jzvd.JZVideoPlayer;
-import cn.jzvd.JZVideoPlayerStandard;
-
-/**
- * Description:
- * Update:
- * CreatedTime:2017/12/29
- * Author:yc
- */
-public class TestApiSixActivity extends BaseActivity implements View.OnClickListener {
-
-
-    @Bind(R.id.videoplayer)
-    JZVideoPlayerStandard videoplayer;
-    @Bind(R.id.change_to_ijkplayer)
-    Button changeToIjkplayer;
-    @Bind(R.id.change_to_system_mediaplayer)
-    Button changeToSystemMediaplayer;
-
-    @Override
-    protected void onPause() {
-        super.onPause();
-        JZVideoPlayer.releaseAllVideos();
-        JZVideoPlayer.setVideoImageDisplayType(JZVideoPlayer.VIDEO_IMAGE_DISPLAY_TYPE_ADAPTER);
-    }
-
-    @Override
-    public void onBackPressed() {
-        if (JZVideoPlayer.backPress()) {
-            return;
-        }
-        super.onBackPressed();
-    }
-
-    @Override
-    public void onResume() {
-        super.onResume();
-        //进入此页面修改MediaInterface，让此页面的jzvd正常工作
-        JZVideoPlayer.setMediaInterface(new CustomMediaPlayerAssertFolder());
-    }
-
-
-    @Override
-    public int getContentView() {
-        return R.layout.activity_test_api_six;
-    }
-
-    @Override
-    public void initView() {
-        LinkedHashMap map = new LinkedHashMap();
-        try {
-            map.put(JZVideoPlayer.URL_KEY_DEFAULT, getAssets().openFd("local_video.mp4"));
-        } catch (IOException e) {
-            e.printStackTrace();
-        }
-        Object[] dataSourceObjects = new Object[2];
-        dataSourceObjects[0] = map;
-        dataSourceObjects[1] = this;
-        videoplayer.setUp(dataSourceObjects, 0, JZVideoPlayerStandard.SCREEN_WINDOW_NORMAL, "饺子快长大");
-        Picasso.with(this)
-                .load("http://jzvd-pic.nathen.cn/jzvd-pic/1bb2ebbe-140d-4e2e-abd2-9e7e564f71ac.png")
-                .into(videoplayer.thumbImageView);
-    }
-
-    @Override
-    public void initListener() {
-        changeToIjkplayer.setOnClickListener(this);
-        changeToSystemMediaplayer.setOnClickListener(this);
-    }
-
-
-    @Override
-    public void initData() {
-
-    }
-
-
-    @Override
-    public void onClick(View view) {
-        switch (view.getId()) {
-            case R.id.change_to_ijkplayer:
-                JZVideoPlayer.setMediaInterface(new JZMediaIjkplayer());
-                break;
-            case R.id.change_to_system_mediaplayer:
-                JZVideoPlayer.setMediaInterface(new JZMediaSystem());
-                break;
-            default:
-                break;
-        }
-    }
-
-
-}

app/src/main/java/org/yczbj/ycvideoplayer/ui/test/test1/view/first/TestApiThreeActivity.java

@@ -1,74 +0,0 @@
-package org.yczbj.ycvideoplayer.ui.test.test1.view.first;
-
-import android.content.pm.ActivityInfo;
-
-import com.squareup.picasso.Picasso;
-
-import org.yczbj.ycvideoplayer.R;
-import org.yczbj.ycvideoplayer.base.mvp1.BaseActivity;
-import org.yczbj.ycvideoplayer.ui.test.test1.model.VideoConstant;
-
-import butterknife.Bind;
-import cn.jzvd.JZVideoPlayer;
-import cn.jzvd.JZVideoPlayerStandard;
-
-/**
- * Description:
- * Update:
- * CreatedTime:2017/12/29
- * Author:yc
- */
-public class TestApiThreeActivity extends BaseActivity {
-
-    @Bind(R.id.jz_video)
-    JZVideoPlayerStandard jzVideo;
-
-
-    @Override
-    public void onBackPressed() {
-        if (JZVideoPlayer.backPress()) {
-            return;
-        }
-        super.onBackPressed();
-    }
-
-    @Override
-    protected void onPause() {
-        super.onPause();
-        JZVideoPlayer.releaseAllVideos();
-
-        //Change these two variables back
-        JZVideoPlayer.FULLSCREEN_ORIENTATION = ActivityInfo.SCREEN_ORIENTATION_SENSOR;
-        JZVideoPlayer.NORMAL_ORIENTATION = ActivityInfo.SCREEN_ORIENTATION_PORTRAIT;
-    }
-
-
-    @Override
-    public int getContentView() {
-        return R.layout.activity_test_api_third;
-    }
-
-    @Override
-    public void initView() {
-
-    }
-
-    @Override
-    public void initListener() {
-
-    }
-
-    @Override
-    public void initData() {
-        jzVideo.setUp(VideoConstant.videoUrlList[0]
-                , JZVideoPlayerStandard.SCREEN_WINDOW_NORMAL, "饺子不信");
-        Picasso.with(this)
-                .load(VideoConstant.videoThumbList[0])
-                .into(jzVideo.thumbImageView);
-
-        JZVideoPlayer.FULLSCREEN_ORIENTATION = ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE;
-        JZVideoPlayer.NORMAL_ORIENTATION = ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE;
-    }
-
-
-}

app/src/main/java/org/yczbj/ycvideoplayer/ui/test/test1/view/first/TestFirstActivity.java

@@ -1,127 +0,0 @@
-package org.yczbj.ycvideoplayer.ui.test.test1.view.first;
-
-import android.view.View;
-import android.widget.Button;
-
-import com.squareup.picasso.Picasso;
-
-import org.yczbj.ycvideoplayer.R;
-import org.yczbj.ycvideoplayer.base.mvp1.BaseActivity;
-import org.yczbj.ycvideoplayer.ui.test.test1.model.VideoConstant;
-
-import java.util.HashMap;
-import java.util.LinkedHashMap;
-
-import butterknife.Bind;
-import cn.jzvd.JZVideoPlayer;
-import cn.jzvd.JZVideoPlayerStandard;
-
-/**
- * Description:
- * Update:
- * CreatedTime:2017/12/29
- * Author:yc
- */
-
-public class TestFirstActivity extends BaseActivity implements View.OnClickListener {
-
-    @Bind(R.id.jz_video)
-    JZVideoPlayerStandard jzVideo;
-    @Bind(R.id.btn_1)
-    Button btn1;
-    @Bind(R.id.btn_2)
-    Button btn2;
-    @Bind(R.id.btn_3)
-    Button btn3;
-    @Bind(R.id.btn_4)
-    Button btn4;
-    @Bind(R.id.btn_5)
-    Button btn5;
-    @Bind(R.id.btn_6)
-    Button btn6;
-
-
-    @Override
-    protected void onPause() {
-        super.onPause();
-        JZVideoPlayer.clearSavedProgress(this, null);
-        //home back
-        JZVideoPlayer.goOnPlayOnPause();
-    }
-
-
-    @Override
-    public void onBackPressed() {
-        if (JZVideoPlayer.backPress()) {
-            return;
-        }
-        super.onBackPressed();
-    }
-
-
-    @Override
-    public int getContentView() {
-        return R.layout.activity_test_first;
-    }
-
-    @SuppressWarnings("unchecked")
-    @Override
-    public void initView() {
-        LinkedHashMap map = new LinkedHashMap();
-        map.put("高清", VideoConstant.videoUrls[0][9]);
-        map.put("标清", VideoConstant.videoUrls[0][6]);
-        map.put("普清", VideoConstant.videoUrlList[0]);
-        Object[] objects = new Object[3];
-        objects[0] = map;
-        objects[1] = false;
-        objects[2] = new HashMap<>();
-        ((HashMap) objects[2]).put("key", "value");
-        jzVideo.setUp(objects, 2
-                , JZVideoPlayerStandard.SCREEN_WINDOW_NORMAL, "饺子不信");
-        Picasso.with(this)
-                .load(VideoConstant.videoThumbList[0])
-                .into(jzVideo.thumbImageView);
-    }
-
-    @Override
-    public void initListener() {
-        btn1.setOnClickListener(this);
-        btn2.setOnClickListener(this);
-        btn3.setOnClickListener(this);
-        btn4.setOnClickListener(this);
-        btn5.setOnClickListener(this);
-        btn6.setOnClickListener(this);
-    }
-
-    @Override
-    public void initData() {
-
-    }
-
-
-    @Override
-    public void onClick(View view) {
-        switch (view.getId()){
-            case R.id.btn_1:
-                startActivity(TestApiFirstActivity.class);
-                break;
-            case R.id.btn_2:
-
-                break;
-            case R.id.btn_3:
-                startActivity(TestApiThreeActivity.class);
-                break;
-            case R.id.btn_4:
-                startActivity(TestApiFourActivity.class);
-                break;
-            case R.id.btn_5:
-                startActivity(TestApiFiveActivity.class);
-                break;
-            case R.id.btn_6:
-                startActivity(TestApiSixActivity.class);
-                break;
-            default:
-                break;
-        }
-    }
-}

app/src/main/java/org/yczbj/ycvideoplayer/ui/test/test1/view/five/TestFiveActivity.java

@@ -1,115 +0,0 @@
-package org.yczbj.ycvideoplayer.ui.test.test1.view.five;
-
-import android.annotation.SuppressLint;
-import android.view.ViewGroup;
-import android.webkit.JavascriptInterface;
-import android.webkit.WebView;
-import android.widget.AbsoluteLayout;
-import android.widget.ProgressBar;
-
-import com.squareup.picasso.Picasso;
-
-import org.yczbj.ycvideoplayer.R;
-import org.yczbj.ycvideoplayer.base.mvp1.BaseActivity;
-import org.yczbj.ycvideoplayer.ui.test.test1.model.VideoConstant;
-
-import butterknife.Bind;
-import cn.jzvd.JZUtils;
-import cn.jzvd.JZVideoPlayer;
-import cn.jzvd.JZVideoPlayerStandard;
-
-/**
- * Description:
- * Update:
- * CreatedTime:2017/12/29
- * Author:yc
- */
-
-public class TestFiveActivity extends BaseActivity {
-
-    @Bind(R.id.webView)
-    WebView webView;
-    @Bind(R.id.pb)
-    ProgressBar pb;
-
-    @Override
-    public void onBackPressed() {
-        if (JZVideoPlayer.backPress()) {
-            return;
-        }
-        super.onBackPressed();
-    }
-
-    @Override
-    protected void onPause() {
-        super.onPause();
-        JZVideoPlayer.releaseAllVideos();
-    }
-
-    @Override
-    public int getContentView() {
-        return R.layout.base_web_view;
-    }
-
-    
-    @SuppressLint("SetJavaScriptEnabled")
-    @Override
-    public void initView() {
-        webView.getSettings().setJavaScriptEnabled(true);
-        webView.addJavascriptInterface(new JZCallBack(), "jzvd");
-        webView.loadUrl("file:///android_asset/jzvd.html");
-    }
-
-    @Override
-    public void initListener() {
-
-    }
-
-    @Override
-    public void initData() {
-
-    }
-
-
-    public class JZCallBack {
-        @JavascriptInterface
-        public void adViewJiaoZiVideoPlayer(final int width, final int height, final int top, final int left, final int index) {
-            runOnUiThread(new Runnable() {
-                @Override
-                public void run() {
-                    if (index == 0) {
-                        JZVideoPlayerStandard webVieo = new JZVideoPlayerStandard(TestFiveActivity.this);
-                        webVieo.setUp(VideoConstant.videoUrlList[1],
-                                JZVideoPlayer.SCREEN_WINDOW_LIST, "饺子骑大马");
-                        Picasso.with(TestFiveActivity.this)
-                                .load(VideoConstant.videoThumbList[1])
-                                .into(webVieo.thumbImageView);
-                        ViewGroup.LayoutParams ll = new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT);
-                        AbsoluteLayout.LayoutParams layoutParams = new AbsoluteLayout.LayoutParams(ll);
-                        layoutParams.y = JZUtils.dip2px(TestFiveActivity.this, top);
-                        layoutParams.x = JZUtils.dip2px(TestFiveActivity.this, left);
-                        layoutParams.height = JZUtils.dip2px(TestFiveActivity.this, height);
-                        layoutParams.width = JZUtils.dip2px(TestFiveActivity.this, width);
-                        webView.addView(webVieo, layoutParams);
-                    } else {
-                        JZVideoPlayerStandard webVieo = new JZVideoPlayerStandard(TestFiveActivity.this);
-                        webVieo.setUp(VideoConstant.videoUrlList[2],
-                                JZVideoPlayer.SCREEN_WINDOW_LIST, "饺子失态了");
-                        Picasso.with(TestFiveActivity.this)
-                                .load(VideoConstant.videoThumbList[2])
-                                .into(webVieo.thumbImageView);
-                        ViewGroup.LayoutParams ll = new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT);
-                        AbsoluteLayout.LayoutParams layoutParams = new AbsoluteLayout.LayoutParams(ll);
-                        layoutParams.y = JZUtils.dip2px(TestFiveActivity.this, top);
-                        layoutParams.x = JZUtils.dip2px(TestFiveActivity.this, left);
-                        layoutParams.height = JZUtils.dip2px(TestFiveActivity.this, height);
-                        layoutParams.width = JZUtils.dip2px(TestFiveActivity.this, width);
-                        webView.addView(webVieo, layoutParams);
-                    }
-                }
-            });
-        }
-    }
-
-
-}

app/src/main/java/org/yczbj/ycvideoplayer/ui/test/test1/view/four/TestFourActivity.java

@@ -1,90 +0,0 @@
-package org.yczbj.ycvideoplayer.ui.test.test1.view.four;
-
-import android.view.View;
-import android.widget.Button;
-
-import com.squareup.picasso.Picasso;
-
-import org.yczbj.ycvideoplayer.R;
-import org.yczbj.ycvideoplayer.base.mvp1.BaseActivity;
-import org.yczbj.ycvideoplayer.ui.test.test1.model.VideoConstant;
-
-import butterknife.Bind;
-import cn.jzvd.JZVideoPlayer;
-import cn.jzvd.JZVideoPlayerStandard;
-
-/**
- * Description:
- * Update:
- * CreatedTime:2017/12/29
- * Author:yc
- */
-
-public class TestFourActivity extends BaseActivity implements View.OnClickListener {
-
-    @Bind(R.id.jz_video)
-    JZVideoPlayerStandard jzVideo;
-    @Bind(R.id.btn_fullscreen)
-    Button fullscreen;
-    @Bind(R.id.btn_tiny_window)
-    Button tinyWindow;
-
-    @Override
-    protected void onPause() {
-        super.onPause();
-        JZVideoPlayer.releaseAllVideos();
-    }
-
-
-    @Override
-    public void onBackPressed() {
-        if (JZVideoPlayer.backPress()) {
-            return;
-        }
-        super.onBackPressed();
-    }
-
-
-    @Override
-    public int getContentView() {
-        return R.layout.activity_test_four;
-    }
-
-
-    @Override
-    public void initView() {
-        jzVideo.setUp("http://jzvd.nathen.cn/342a5f7ef6124a4a8faf00e738b8bee4/cf6d9db0bd4d41f59d09ea0a81e918fd-5287d2089db37e62345123a1be272f8b.mp4"
-                , JZVideoPlayerStandard.SCREEN_WINDOW_NORMAL, "饺子快长大");
-        Picasso.with(this)
-                .load("http://jzvd-pic.nathen.cn/jzvd-pic/1bb2ebbe-140d-4e2e-abd2-9e7e564f71ac.png")
-                .into(jzVideo.thumbImageView);
-    }
-
-    @Override
-    public void initListener() {
-        fullscreen.setOnClickListener(this);
-        tinyWindow.setOnClickListener(this);
-    }
-
-    @Override
-    public void initData() {
-
-    }
-
-
-    @Override
-    public void onClick(View view) {
-        switch (view.getId()) {
-            case R.id.btn_fullscreen:
-                JZVideoPlayerStandard.startFullscreen(this,
-                        JZVideoPlayerStandard.class, VideoConstant.videoUrlList[6], "饺子辛苦了");
-                break;
-            case R.id.btn_tiny_window:
-
-                break;
-            default:
-                break;
-        }
-    }
-
-}

app/src/main/java/org/yczbj/ycvideoplayer/ui/test/test1/view/second/TestFiveBean.java

@@ -1,35 +0,0 @@
-package org.yczbj.ycvideoplayer.ui.test.test1.view.second;
-
-/**
- * Description:
- * Update:
- * CreatedTime:2018/01/02
- * Author:yc
- */
-
-public class TestFiveBean {
-
-    private int type;
-    private String name;
-
-    public TestFiveBean(int type, String name) {
-        this.type = type;
-        this.name = name;
-    }
-
-    public int getType() {
-        return type;
-    }
-
-    public void setType(int type) {
-        this.type = type;
-    }
-
-    public String getName() {
-        return name;
-    }
-
-    public void setName(String name) {
-        this.name = name;
-    }
-}

app/src/main/java/org/yczbj/ycvideoplayer/ui/test/test1/view/second/TestListFirstActivity.java

@@ -1,158 +0,0 @@
-package org.yczbj.ycvideoplayer.ui.test.test1.view.second;
-
-import android.content.Context;
-import android.hardware.Sensor;
-import android.hardware.SensorManager;
-import android.view.LayoutInflater;
-import android.view.View;
-import android.view.ViewGroup;
-import android.widget.AbsListView;
-import android.widget.BaseAdapter;
-import android.widget.ListView;
-
-import com.squareup.picasso.Picasso;
-
-import org.yczbj.ycvideoplayer.R;
-import org.yczbj.ycvideoplayer.base.mvp1.BaseActivity;
-import org.yczbj.ycvideoplayer.ui.test.test1.model.VideoConstant;
-
-import butterknife.Bind;
-import cn.jzvd.JZVideoPlayer;
-import cn.jzvd.JZVideoPlayerStandard;
-
-/**
- * Description:
- * Update:
- * CreatedTime:2017/12/29
- * Author:yc
- */
-public class TestListFirstActivity extends BaseActivity {
-
-
-    @Bind(R.id.listView)
-    ListView listView;
-    SensorManager sensorManager;
-    JZVideoPlayer.JZAutoFullscreenListener sensorEventListener;
-
-    @Override
-    public void onBackPressed() {
-        if (JZVideoPlayer.backPress()) {
-            return;
-        }
-        super.onBackPressed();
-    }
-
-    @Override
-    protected void onResume() {
-        super.onResume();
-        Sensor accelerometerSensor = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
-        sensorManager.registerListener(sensorEventListener, accelerometerSensor, SensorManager.SENSOR_DELAY_NORMAL);
-    }
-
-    @Override
-    protected void onPause() {
-        super.onPause();
-        sensorManager.unregisterListener(sensorEventListener);
-        JZVideoPlayer.releaseAllVideos();
-    }
-
-
-    @Override
-    public int getContentView() {
-        return R.layout.activity_test_list_first;
-    }
-
-    @Override
-    public void initView() {
-        listView.setAdapter(new AdapterVideoList(this,
-                VideoConstant.videoUrls[0],
-                VideoConstant.videoTitles[0],
-                VideoConstant.videoThumbs[0]));
-
-        listView.setOnScrollListener(new AbsListView.OnScrollListener() {
-            @Override
-            public void onScrollStateChanged(AbsListView view, int scrollState) {
-
-            }
-
-            @Override
-            public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) {
-                JZVideoPlayer.onScrollReleaseAllVideos(view, firstVisibleItem, visibleItemCount, totalItemCount);
-            }
-        });
-
-        sensorManager = (SensorManager) getSystemService(SENSOR_SERVICE);
-        sensorEventListener = new JZVideoPlayer.JZAutoFullscreenListener();
-    }
-
-    @Override
-    public void initListener() {
-
-    }
-
-    @Override
-    public void initData() {
-
-    }
-
-
-    public static class AdapterVideoList extends BaseAdapter {
-
-        public static final String TAG = "JiaoZiVideoPlayer";
-        Context context;
-        String[] videoUrls;
-        String[] videoTitles;
-        String[] videoThumbs;
-
-        AdapterVideoList(Context context, String[] videoUrls, String[] videoTitles, String[] videoThumbs) {
-            this.context = context;
-            this.videoUrls = videoUrls;
-            this.videoTitles = videoTitles;
-            this.videoThumbs = videoThumbs;
-        }
-
-        @Override
-        public int getCount() {
-            return videoUrls.length;
-        }
-
-        @Override
-        public Object getItem(int position) {
-            return null;
-        }
-
-        @Override
-        public long getItemId(int position) {
-            return position;
-        }
-
-        @Override
-        public View getView(int position, View convertView, ViewGroup parent) {
-            ViewHolder viewHolder;
-            if (null == convertView) {
-                viewHolder = new ViewHolder();
-                LayoutInflater mInflater = LayoutInflater.from(context);
-                convertView = mInflater.inflate(R.layout.item_test_list_videoview, null);
-                convertView.setTag(viewHolder);
-            } else {
-                viewHolder = (ViewHolder) convertView.getTag();
-            }
-            viewHolder.jzVideoPlayer = (JZVideoPlayerStandard)convertView.findViewById(R.id.videoplayer);
-            viewHolder.jzVideoPlayer.setUp(
-                    videoUrls[position], JZVideoPlayer.SCREEN_WINDOW_LIST,
-                    videoTitles[position]);
-            Picasso.with(convertView.getContext())
-                    .load(videoThumbs[position])
-                    .into(viewHolder.jzVideoPlayer.thumbImageView);
-
-            viewHolder.jzVideoPlayer.positionInList = position;
-            return convertView;
-        }
-
-        class ViewHolder {
-            JZVideoPlayerStandard jzVideoPlayer;
-        }
-    }
-
-
-}

app/src/main/java/org/yczbj/ycvideoplayer/ui/test/test1/view/second/TestListFiveActivity.java

@@ -1,107 +0,0 @@
-package org.yczbj.ycvideoplayer.ui.test.test1.view.second;
-
-import android.support.v7.widget.LinearLayoutManager;
-import android.support.v7.widget.RecyclerView;
-import android.view.View;
-
-
-import com.pedaily.yc.ycdialoglib.customToast.ToastUtil;
-
-import org.yczbj.ycvideoplayer.R;
-import org.yczbj.ycvideoplayer.base.mvp1.BaseActivity;
-import org.yczbj.ycvideoplayer.listener.OnListItemClickListener;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import butterknife.Bind;
-import cn.jzvd.JZMediaManager;
-import cn.jzvd.JZUtils;
-import cn.jzvd.JZVideoPlayer;
-
-/**
- * Description:
- * Update:
- * CreatedTime:2017/12/29
- * Author:yc
- */
-public class TestListFiveActivity extends BaseActivity {
-
-    @Bind(R.id.recyclerView)
-    RecyclerView recyclerView;
-    private TestListFiveAdapter adapterVideoList;
-    private List<TestFiveBean> list;
-
-
-    @Override
-    public void onBackPressed() {
-        if (JZVideoPlayer.backPress()) {
-            return;
-        }
-        super.onBackPressed();
-    }
-
-    @Override
-    protected void onPause() {
-        super.onPause();
-        JZVideoPlayer.releaseAllVideos();
-    }
-
-
-    @Override
-    public int getContentView() {
-        return R.layout.base_recycler_view;
-    }
-
-    @Override
-    public void initView() {
-        list = new ArrayList<>();
-        for(int a=0 ; a<10 ; a++){
-            if(a==2 || a==5 || a==7 || a==9){
-                TestFiveBean bean = new TestFiveBean(1,"five");
-                list.add(bean);
-            }else {
-                TestFiveBean bean = new TestFiveBean(2,"five");
-                list.add(bean);
-            }
-        }
-
-        recyclerView.setLayoutManager(new LinearLayoutManager(this));
-        adapterVideoList = new TestListFiveAdapter(this, list);
-        recyclerView.setAdapter(adapterVideoList);
-    }
-
-    @Override
-    public void initListener() {
-        recyclerView.addOnChildAttachStateChangeListener(new RecyclerView.OnChildAttachStateChangeListener() {
-            @Override
-            public void onChildViewAttachedToWindow(View view) {
-            }
-
-            @Override
-            public void onChildViewDetachedFromWindow(View view) {
-                JZVideoPlayer jzvd = (JZVideoPlayer)view.findViewById(R.id.videoplayer);
-                if (jzvd != null && JZUtils.dataSourceObjectsContainsUri(jzvd.dataSourceObjects, JZMediaManager.getCurrentDataSource())) {
-                    JZVideoPlayer.releaseAllVideos();
-                }
-            }
-        });
-        adapterVideoList.setOnItemClickListener(new OnListItemClickListener() {
-            @Override
-            public void onItemClick(View view, int position) {
-                if(list.get(position).getType()==1){
-                    ToastUtil.showToast(TestListFiveActivity.this,"这个是视频控件");
-                }else if(list.get(position).getType()==2){
-                    ToastUtil.showToast(TestListFiveActivity.this,"这个是文本控件");
-                }
-            }
-        });
-    }
-
-    @Override
-    public void initData() {
-
-    }
-
-
-}

app/src/main/java/org/yczbj/ycvideoplayer/ui/test/test1/view/second/TestListFiveAdapter.java

@@ -1,110 +0,0 @@
-package org.yczbj.ycvideoplayer.ui.test.test1.view.second;
-
-import android.content.Context;
-import android.support.v7.widget.RecyclerView;
-import android.view.LayoutInflater;
-import android.view.View;
-import android.view.ViewGroup;
-import android.widget.TextView;
-
-import com.squareup.picasso.Picasso;
-
-import org.yczbj.ycvideoplayer.R;
-import org.yczbj.ycvideoplayer.listener.OnListItemClickListener;
-import org.yczbj.ycvideoplayer.ui.test.test1.model.VideoConstant;
-
-import java.util.List;
-
-import cn.jzvd.JZVideoPlayer;
-import cn.jzvd.JZVideoPlayerStandard;
-
-public class TestListFiveAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolder> {
-
-    private static final String TAG = "AdapterRecyclerViewVideo";
-    private List<TestFiveBean> list;
-    private Context context;
-
-    TestListFiveAdapter(Context context, List<TestFiveBean> list) {
-        this.context = context;
-        this.list = list;
-    }
-
-    @Override
-    public RecyclerView.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
-        if(viewType == 1){
-            return new MyViewHolder(LayoutInflater.from(context).inflate(
-                    R.layout.item_test_list_videoview, parent, false));
-        }else if(viewType == 2){
-            return new TextViewViewHolder(LayoutInflater.from(context).inflate(
-                    R.layout.item_test_list_textview, parent, false));
-        }else {
-            return new TextViewViewHolder(LayoutInflater.from(context).inflate(
-                    R.layout.item_test_list_textview, parent, false));
-        }
-    }
-
-    @Override
-    public void onBindViewHolder(RecyclerView.ViewHolder holder, final int position) {
-        if(holder instanceof MyViewHolder){
-            ((MyViewHolder) holder).jzVideoPlayer.setUp(
-                    VideoConstant.videoUrls[0][position], JZVideoPlayer.SCREEN_WINDOW_LIST,
-                    VideoConstant.videoTitles[0][position]);
-            Picasso.with(((MyViewHolder) holder).jzVideoPlayer.getContext())
-                    .load(VideoConstant.videoThumbs[0][position])
-                    .into(((MyViewHolder) holder).jzVideoPlayer.thumbImageView);
-        }else if(holder instanceof TextViewViewHolder){
-             ((TextViewViewHolder) holder).textview.setText("这个是文本控件");
-        }
-        holder.itemView.setOnClickListener(new View.OnClickListener() {
-            @Override
-            public void onClick(View view) {
-                if(mItemClickListener!=null){
-                    mItemClickListener.onItemClick(view,position);
-                }
-            }
-        });
-    }
-
-    @Override
-    public int getItemCount() {
-        return list.size();
-    }
-
-    @Override
-    public int getItemViewType(int position) {
-        if(list.get(position).getType()==1){
-            return 1;
-        }else if(list.get(position).getType()==2){
-            return 2;
-        }else {
-            return 2;
-        }
-    }
-
-    class MyViewHolder extends RecyclerView.ViewHolder {
-
-        JZVideoPlayerStandard jzVideoPlayer;
-
-        MyViewHolder(View itemView) {
-            super(itemView);
-            jzVideoPlayer = (JZVideoPlayerStandard)itemView.findViewById(R.id.videoplayer);
-        }
-    }
-
-    class TextViewViewHolder extends RecyclerView.ViewHolder {
-
-        TextView textview;
-
-        TextViewViewHolder(View itemView) {
-            super(itemView);
-            textview = (TextView) itemView.findViewById(R.id.textview);
-        }
-    }
-
-    private OnListItemClickListener mItemClickListener;
-    public void setOnItemClickListener(OnListItemClickListener listener) {
-        this.mItemClickListener = listener;
-    }
-
-
-}

app/src/main/java/org/yczbj/ycvideoplayer/ui/test/test1/view/second/TestListFourActivity.java

@@ -1,78 +0,0 @@
-package org.yczbj.ycvideoplayer.ui.test.test1.view.second;
-
-import android.support.v7.widget.LinearLayoutManager;
-import android.support.v7.widget.RecyclerView;
-import android.view.View;
-
-import org.yczbj.ycvideoplayer.R;
-import org.yczbj.ycvideoplayer.base.mvp1.BaseActivity;
-
-import butterknife.Bind;
-import cn.jzvd.JZMediaManager;
-import cn.jzvd.JZUtils;
-import cn.jzvd.JZVideoPlayer;
-
-/**
- * Description:
- * Update:
- * CreatedTime:2017/12/29
- * Author:yc
- */
-public class TestListFourActivity extends BaseActivity {
-
-    @Bind(R.id.recyclerView)
-    RecyclerView recyclerView;
-    private TestListFourAdapter adapterVideoList;
-
-    @Override
-    public void onBackPressed() {
-        if (JZVideoPlayer.backPress()) {
-            return;
-        }
-        super.onBackPressed();
-    }
-
-    @Override
-    protected void onPause() {
-        super.onPause();
-        JZVideoPlayer.releaseAllVideos();
-    }
-
-
-    @Override
-    public int getContentView() {
-        return R.layout.base_recycler_view;
-    }
-
-    @Override
-    public void initView() {
-        recyclerView.setLayoutManager(new LinearLayoutManager(this));
-        adapterVideoList = new TestListFourAdapter(this);
-        recyclerView.setAdapter(adapterVideoList);
-    }
-
-    @Override
-    public void initListener() {
-        recyclerView.addOnChildAttachStateChangeListener(new RecyclerView.OnChildAttachStateChangeListener() {
-            @Override
-            public void onChildViewAttachedToWindow(View view) {
-
-            }
-
-            @Override
-            public void onChildViewDetachedFromWindow(View view) {
-                JZVideoPlayer jzvd = (JZVideoPlayer)view.findViewById(R.id.videoplayer);
-                if (jzvd != null && JZUtils.dataSourceObjectsContainsUri(jzvd.dataSourceObjects, JZMediaManager.getCurrentDataSource())) {
-                    JZVideoPlayer.releaseAllVideos();
-                }
-            }
-        });
-    }
-
-    @Override
-    public void initData() {
-
-    }
-
-
-}

app/src/main/java/org/yczbj/ycvideoplayer/ui/test/test1/view/second/TestListFourAdapter.java

@@ -1,63 +0,0 @@
-package org.yczbj.ycvideoplayer.ui.test.test1.view.second;
-
-import android.annotation.SuppressLint;
-import android.content.Context;
-import android.support.v7.widget.RecyclerView;
-import android.util.Log;
-import android.view.LayoutInflater;
-import android.view.View;
-import android.view.ViewGroup;
-
-import com.squareup.picasso.Picasso;
-
-import org.yczbj.ycvideoplayer.R;
-import org.yczbj.ycvideoplayer.ui.test.test1.model.VideoConstant;
-
-import cn.jzvd.JZVideoPlayer;
-import cn.jzvd.JZVideoPlayerStandard;
-
-public class TestListFourAdapter extends RecyclerView.Adapter<TestListFourAdapter.MyViewHolder> {
-
-    public static final String TAG = "AdapterRecyclerViewVideo";
-    int[] videoIndexs = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
-    private Context context;
-
-    public TestListFourAdapter(Context context) {
-        this.context = context;
-    }
-
-    @Override
-    public MyViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
-        MyViewHolder holder = new MyViewHolder(LayoutInflater.from(
-                context).inflate(R.layout.item_test_list_videoview, parent,
-                false));
-        return holder;
-    }
-
-    @SuppressLint("LongLogTag")
-    @Override
-    public void onBindViewHolder(MyViewHolder holder, int position) {
-        Log.i(TAG, "onBindViewHolder [" + holder.jzVideoPlayer.hashCode() + "] position=" + position);
-        holder.jzVideoPlayer.setUp(
-                VideoConstant.videoUrls[0][position], JZVideoPlayer.SCREEN_WINDOW_LIST,
-                VideoConstant.videoTitles[0][position]);
-        Picasso.with(holder.jzVideoPlayer.getContext())
-                .load(VideoConstant.videoThumbs[0][position])
-                .into(holder.jzVideoPlayer.thumbImageView);
-    }
-
-    @Override
-    public int getItemCount() {
-        return videoIndexs.length;
-    }
-
-    class MyViewHolder extends RecyclerView.ViewHolder {
-        JZVideoPlayerStandard jzVideoPlayer;
-
-        MyViewHolder(View itemView) {
-            super(itemView);
-            jzVideoPlayer = (JZVideoPlayerStandard)itemView.findViewById(R.id.videoplayer);
-        }
-    }
-
-}

app/src/main/java/org/yczbj/ycvideoplayer/ui/test/test1/view/second/TestListFragment.java

@@ -1,73 +0,0 @@
-package org.yczbj.ycvideoplayer.ui.test.test1.view.second;
-
-
-import android.os.Bundle;
-import android.support.annotation.Nullable;
-import android.support.v4.app.Fragment;
-import android.view.LayoutInflater;
-import android.view.View;
-import android.view.ViewGroup;
-import android.widget.AbsListView;
-import android.widget.ListView;
-
-import org.yczbj.ycvideoplayer.R;
-import org.yczbj.ycvideoplayer.ui.test.test1.model.VideoConstant;
-
-import butterknife.Bind;
-import butterknife.ButterKnife;
-import cn.jzvd.JZVideoPlayer;
-
-/**
- * Created by Nathen on 2017/6/9.
- */
-public class TestListFragment extends Fragment {
-
-    int index;
-    @Bind(R.id.listView)
-    ListView listView;
-
-    public TestListFragment setIndex(int index) {
-        this.index = index;
-        return this;
-    }
-
-
-    @Override
-    public void onCreate(Bundle savedInstanceState) {
-        super.onCreate(savedInstanceState);
-    }
-
-    @Override
-    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInastanceState) {
-        View view = inflater.inflate(R.layout.activity_test_list_first, container, false);
-        ButterKnife.bind(this, view);
-        return view;
-    }
-
-    @Override
-    public void onViewCreated(View view, @Nullable Bundle savedInstanceState) {
-        super.onViewCreated(view, savedInstanceState);
-        listView.setAdapter(new TestListFirstActivity.AdapterVideoList(getActivity(),
-                VideoConstant.videoUrls[index],
-                VideoConstant.videoTitles[index],
-                VideoConstant.videoThumbs[index]));
-        listView.setOnScrollListener(new AbsListView.OnScrollListener() {
-            @Override
-            public void onScrollStateChanged(AbsListView view, int scrollState) {
-
-            }
-
-            @Override
-            public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) {
-                JZVideoPlayer.onScrollReleaseAllVideos(view, firstVisibleItem, visibleItemCount, totalItemCount);
-            }
-        });
-    }
-
-
-    @Override
-    public void onDestroyView() {
-        super.onDestroyView();
-        ButterKnife.unbind(this);
-    }
-}

app/src/main/java/org/yczbj/ycvideoplayer/ui/test/test1/view/second/TestListSecondActivity.java

@@ -1,87 +0,0 @@
-package org.yczbj.ycvideoplayer.ui.test.test1.view.second;
-
-import android.support.v4.view.ViewPager;
-
-import org.yczbj.ycvideoplayer.R;
-import org.yczbj.ycvideoplayer.base.mvp1.BaseActivity;
-import org.yczbj.ycvideoplayer.base.BasePagerAdapter;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import butterknife.Bind;
-import cn.jzvd.JZVideoPlayer;
-
-/**
- * Description:
- * Update:
- * CreatedTime:2017/12/29
- * Author:yc
- */
-public class TestListSecondActivity extends BaseActivity {
-
-    List<TestListFragment> fragmentList = new ArrayList<>();
-    @Bind(R.id.viewPager)
-    ViewPager viewPager;
-
-
-    @Override
-    public void onBackPressed() {
-        if (JZVideoPlayer.backPress()) {
-            return;
-        }
-        super.onBackPressed();
-    }
-
-    @Override
-    protected void onPause() {
-        super.onPause();
-        JZVideoPlayer.releaseAllVideos();
-    }
-
-    @Override
-    public int getContentView() {
-        return R.layout.activity_test_list_second;
-    }
-
-    @Override
-    public void initView() {
-        fragmentList.add(new TestListFragment().setIndex(0));
-        fragmentList.add(new TestListFragment().setIndex(1));
-        fragmentList.add(new TestListFragment().setIndex(2));
-
-        BasePagerAdapter myAdapter = new BasePagerAdapter(getSupportFragmentManager(),fragmentList);
-        viewPager.setAdapter(myAdapter);
-        viewPager.addOnPageChangeListener(new ViewPager.OnPageChangeListener() {
-            @Override
-            public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) {
-
-            }
-
-            @Override
-            public void onPageSelected(int position) {
-                JZVideoPlayer.releaseAllVideos();
-            }
-
-            @Override
-            public void onPageScrollStateChanged(int state) {
-
-            }
-        });
-        viewPager.setCurrentItem(0);
-    }
-
-
-    @Override
-    public void initListener() {
-
-    }
-
-
-    @Override
-    public void initData() {
-
-    }
-
-
-}

app/src/main/java/org/yczbj/ycvideoplayer/ui/test/test1/view/second/TestListThirdActivity.java

@@ -1,163 +0,0 @@
-package org.yczbj.ycvideoplayer.ui.test.test1.view.second;
-
-import android.content.Context;
-import android.view.LayoutInflater;
-import android.view.View;
-import android.view.ViewGroup;
-import android.widget.AbsListView;
-import android.widget.BaseAdapter;
-import android.widget.ListView;
-import android.widget.TextView;
-
-import com.squareup.picasso.Picasso;
-
-import org.yczbj.ycvideoplayer.R;
-import org.yczbj.ycvideoplayer.base.mvp1.BaseActivity;
-import org.yczbj.ycvideoplayer.ui.test.test1.model.VideoConstant;
-
-import butterknife.Bind;
-import cn.jzvd.JZVideoPlayer;
-import cn.jzvd.JZVideoPlayerStandard;
-
-/**
- * Description:
- * Update:
- * CreatedTime:2017/12/29
- * Author:yc
- */
-public class TestListThirdActivity extends BaseActivity {
-
-    @Bind(R.id.listView)
-    ListView listView;
-    private VideoListAdapter mAdapter;
-
-    @Override
-    public void onBackPressed() {
-        if (JZVideoPlayer.backPress()) {
-            return;
-        }
-        super.onBackPressed();
-    }
-
-    @Override
-    protected void onPause() {
-        super.onPause();
-        JZVideoPlayer.releaseAllVideos();
-    }
-
-
-    @Override
-    public int getContentView() {
-        return R.layout.activity_test_list_first;
-    }
-
-    @Override
-    public void initView() {
-        mAdapter = new VideoListAdapter(this);
-        listView.setAdapter(mAdapter);
-        listView.setOnScrollListener(new AbsListView.OnScrollListener() {
-            @Override
-            public void onScrollStateChanged(AbsListView view, int scrollState) {
-
-            }
-
-            @Override
-            public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) {
-                JZVideoPlayer.onScrollReleaseAllVideos(view, firstVisibleItem, visibleItemCount, totalItemCount);
-            }
-        });
-    }
-
-    @Override
-    public void initListener() {
-
-    }
-
-    @Override
-    public void initData() {
-
-    }
-
-
-    public class VideoListAdapter extends BaseAdapter {
-
-        int[] viewtype = {0, 0, 0, 1, 0, 0, 0, 1, 0, 0};//1 = jzvd, 0 = textView
-
-        Context context;
-        LayoutInflater mInflater;
-
-        VideoListAdapter(Context context) {
-            this.context = context;
-            mInflater = LayoutInflater.from(context);
-        }
-
-        @Override
-        public int getCount() {
-            return viewtype.length;
-        }
-
-        @Override
-        public Object getItem(int position) {
-            return null;
-        }
-
-        @Override
-        public long getItemId(int position) {
-            return position;
-        }
-
-        @Override
-        public View getView(int position, View convertView, ViewGroup parent) {
-            if (getItemViewType(position) == 1) {
-                VideoListAdapter.VideoHolder viewHolder;
-                if (convertView != null && convertView.getTag() != null && convertView.getTag() instanceof VideoListAdapter.VideoHolder) {
-                    viewHolder = (VideoListAdapter.VideoHolder) convertView.getTag();
-                } else {
-                    viewHolder = new VideoListAdapter.VideoHolder();
-                    convertView = mInflater.inflate(R.layout.item_test_list_videoview, null);
-                    viewHolder.jzVideoPlayer = (JZVideoPlayerStandard)convertView.findViewById(R.id.videoplayer);
-                    convertView.setTag(viewHolder);
-                }
-
-                viewHolder.jzVideoPlayer.setUp(
-                        VideoConstant.videoUrls[0][position], JZVideoPlayer.SCREEN_WINDOW_LIST,
-                        VideoConstant.videoTitles[0][position]);
-                viewHolder.jzVideoPlayer.positionInList = position;
-                Picasso.with(TestListThirdActivity.this)
-                        .load(VideoConstant.videoThumbs[0][position])
-                        .into(viewHolder.jzVideoPlayer.thumbImageView);
-            } else {
-                VideoListAdapter.TextViewHolder textViewHolder;
-                if (convertView != null && convertView.getTag() != null && convertView.getTag() instanceof VideoListAdapter.TextViewHolder) {
-                    textViewHolder = (VideoListAdapter.TextViewHolder) convertView.getTag();
-                } else {
-                    textViewHolder = new VideoListAdapter.TextViewHolder();
-                    LayoutInflater mInflater = LayoutInflater.from(context);
-                    convertView = mInflater.inflate(R.layout.item_test_list_textview, null);
-                    textViewHolder.textView = (TextView) convertView.findViewById(R.id.textview);
-                    convertView.setTag(textViewHolder);
-                }
-            }
-            return convertView;
-        }
-
-        @Override
-        public int getItemViewType(int position) {
-            return viewtype[position];
-        }
-
-        @Override
-        public int getViewTypeCount() {
-            return 2;
-        }
-
-        class VideoHolder {
-            JZVideoPlayerStandard jzVideoPlayer;
-        }
-
-        class TextViewHolder {
-            TextView textView;
-        }
-    }
-
-}

app/src/main/java/org/yczbj/ycvideoplayer/ui/test/test1/view/second/TestSecondActivity.java

@@ -1,77 +0,0 @@
-package org.yczbj.ycvideoplayer.ui.test.test1.view.second;
-
-import android.view.View;
-import android.widget.Button;
-
-import org.yczbj.ycvideoplayer.R;
-import org.yczbj.ycvideoplayer.base.mvp1.BaseActivity;
-
-import butterknife.Bind;
-
-/**
- * Description:
- * Update:
- * CreatedTime:2017/12/29
- * Author:yc
- */
-
-public class TestSecondActivity extends BaseActivity implements View.OnClickListener {
-
-    @Bind(R.id.normal)
-    Button normal;
-    @Bind(R.id.listview_fragment_viewpager)
-    Button listviewFragmentViewpager;
-    @Bind(R.id.multiholder)
-    Button multiholder;
-    @Bind(R.id.recyleview)
-    Button recyleview;
-    @Bind(R.id.recyleview_type)
-    Button recyleviewType;
-
-    @Override
-    public int getContentView() {
-        return R.layout.activity_test_second;
-    }
-
-    @Override
-    public void initView() {
-
-    }
-
-    @Override
-    public void initListener() {
-        normal.setOnClickListener(this);
-        listviewFragmentViewpager.setOnClickListener(this);
-        multiholder.setOnClickListener(this);
-        recyleview.setOnClickListener(this);
-        recyleviewType.setOnClickListener(this);
-    }
-
-    @Override
-    public void initData() {
-
-    }
-
-    @Override
-    public void onClick(View view) {
-        switch (view.getId()) {
-            case R.id.normal:
-                startActivity(TestListFirstActivity.class);
-                break;
-            case R.id.listview_fragment_viewpager:
-                startActivity(TestListSecondActivity.class);
-                break;
-            case R.id.multiholder:
-                startActivity(TestListThirdActivity.class);
-                break;
-            case R.id.recyleview:
-                startActivity(TestListFourActivity.class);
-                break;
-            case R.id.recyleview_type:
-                startActivity(TestListFiveActivity.class);
-                break;
-        }
-    }
-
-
-}

app/src/main/java/org/yczbj/ycvideoplayer/ui/test/test1/view/six/TestSixActivity.java

@@ -1,125 +0,0 @@
-package org.yczbj.ycvideoplayer.ui.test.test1.view.six;
-
-import com.squareup.picasso.Picasso;
-
-import org.yczbj.ycvideoplayer.R;
-import org.yczbj.ycvideoplayer.base.mvp1.BaseActivity;
-
-import butterknife.Bind;
-import cn.jzvd.CustomView.JZVideoPlayerStandardAutoCompleteAfterFullscreen;
-import cn.jzvd.CustomView.JZVideoPlayerStandardShowTextureViewAfterAutoComplete;
-import cn.jzvd.CustomView.JZVideoPlayerStandardShowTitleAfterFullscreen;
-import cn.jzvd.JZVideoPlayer;
-import cn.jzvd.JZVideoPlayerStandard;
-
-/**
- * Description:
- * Update:
- * CreatedTime:2017/12/29
- * Author:yc
- */
-
-public class TestSixActivity extends BaseActivity {
-
-
-    @Bind(R.id.jz_video_1)
-    JZVideoPlayerStandard jzVideo1;
-    @Bind(R.id.jz_video_2)
-    JZVideoPlayerStandardShowTitleAfterFullscreen jzVideo2;
-    @Bind(R.id.jz_video_3)
-    JZVideoPlayerStandardShowTextureViewAfterAutoComplete jzVideo3;
-    @Bind(R.id.jz_video_4)
-    JZVideoPlayerStandardAutoCompleteAfterFullscreen jzVideo4;
-    @Bind(R.id.video_1_1)
-    JZVideoPlayerStandardAutoCompleteAfterFullscreen video11;
-    @Bind(R.id.video_16_9)
-    JZVideoPlayerStandardAutoCompleteAfterFullscreen video169;
-
-
-    @Override
-    protected void onPause() {
-        super.onPause();
-        JZVideoPlayer.clearSavedProgress(this, null);
-        //home back
-        JZVideoPlayer.goOnPlayOnPause();
-    }
-
-
-    @Override
-    public void onBackPressed() {
-        if (JZVideoPlayer.backPress()) {
-            return;
-        }
-        super.onBackPressed();
-    }
-
-
-    @Override
-    public int getContentView() {
-        return R.layout.activity_test_six;
-    }
-
-
-    @Override
-    public void initView() {
-        jzVideo1.setUp("http://jzvd.nathen.cn/342a5f7ef6124a4a8faf00e738b8bee4/cf6d9db0bd4d41f59d09ea0a81e918fd-5287d2089db37e62345123a1be272f8b.mp4"
-                , JZVideoPlayerStandard.SCREEN_WINDOW_NORMAL, "饺子快长大");
-        Picasso.with(this)
-                .load("http://jzvd-pic.nathen.cn/jzvd-pic/1bb2ebbe-140d-4e2e-abd2-9e7e564f71ac.png")
-                .into(jzVideo1.thumbImageView);
-
-
-        jzVideo2.setUp("http://jzvd.nathen.cn/342a5f7ef6124a4a8faf00e738b8bee4/cf6d9db0bd4d41f59d09ea0a81e918fd-5287d2089db37e62345123a1be272f8b.mp4"
-                , JZVideoPlayerStandard.SCREEN_WINDOW_NORMAL, "饺子快长大");
-        Picasso.with(this)
-                .load("http://jzvd-pic.nathen.cn/jzvd-pic/1bb2ebbe-140d-4e2e-abd2-9e7e564f71ac.png")
-                .into(jzVideo2.thumbImageView);
-
-
-        jzVideo3.setUp("http://jzvd.nathen.cn/342a5f7ef6124a4a8faf00e738b8bee4/cf6d9db0bd4d41f59d09ea0a81e918fd-5287d2089db37e62345123a1be272f8b.mp4"
-                , JZVideoPlayerStandard.SCREEN_WINDOW_NORMAL, "饺子快长大");
-        Picasso.with(this)
-                .load("http://jzvd-pic.nathen.cn/jzvd-pic/1bb2ebbe-140d-4e2e-abd2-9e7e564f71ac.png")
-                .into(jzVideo3.thumbImageView);
-
-
-        jzVideo4.setUp("http://jzvd.nathen.cn/342a5f7ef6124a4a8faf00e738b8bee4/cf6d9db0bd4d41f59d09ea0a81e918fd-5287d2089db37e62345123a1be272f8b.mp4"
-                , JZVideoPlayerStandard.SCREEN_WINDOW_NORMAL, "饺子快长大");
-        Picasso.with(this)
-                .load("http://jzvd-pic.nathen.cn/jzvd-pic/1bb2ebbe-140d-4e2e-abd2-9e7e564f71ac.png")
-                .into(jzVideo4.thumbImageView);
-
-
-        video11.setUp("http://jzvd.nathen.cn/342a5f7ef6124a4a8faf00e738b8bee4/cf6d9db0bd4d41f59d09ea0a81e918fd-5287d2089db37e62345123a1be272f8b.mp4"
-                , JZVideoPlayerStandard.SCREEN_WINDOW_NORMAL, "饺子快长大");
-        Picasso.with(this)
-                .load("http://jzvd-pic.nathen.cn/jzvd-pic/1bb2ebbe-140d-4e2e-abd2-9e7e564f71ac.png")
-                .into(video11.thumbImageView);
-        video11.widthRatio = 1;
-        video11.heightRatio = 1;
-
-
-        video169.setUp("http://jzvd.nathen.cn/342a5f7ef6124a4a8faf00e738b8bee4/cf6d9db0bd4d41f59d09ea0a81e918fd-5287d2089db37e62345123a1be272f8b.mp4"
-                , JZVideoPlayerStandard.SCREEN_WINDOW_NORMAL, "饺子快长大");
-        Picasso.with(this)
-                .load("http://jzvd-pic.nathen.cn/jzvd-pic/1bb2ebbe-140d-4e2e-abd2-9e7e564f71ac.png")
-                .into(video169.thumbImageView);
-        video169.widthRatio = 16;
-        video169.heightRatio = 9;
-    }
-
-
-    @Override
-    public void initListener() {
-
-    }
-
-
-    @Override
-    public void initData() {
-
-    }
-
-
-
-}

app/src/main/java/org/yczbj/ycvideoplayer/ui/test/test1/view/three/TestThreeActivity.java

@@ -1,109 +0,0 @@
-package org.yczbj.ycvideoplayer.ui.test.test1.view.three;
-
-import android.view.View;
-import android.widget.Button;
-
-import com.squareup.picasso.Picasso;
-
-import org.yczbj.ycvideoplayer.R;
-import org.yczbj.ycvideoplayer.base.mvp1.BaseActivity;
-
-import butterknife.Bind;
-import cn.jzvd.JZVideoPlayer;
-import cn.jzvd.JZVideoPlayerStandard;
-
-/**
- * Description:
- * Update:
- * CreatedTime:2017/12/29
- * Author:yc
- */
-
-public class TestThreeActivity extends BaseActivity implements View.OnClickListener {
-
-    @Bind(R.id.jz_video)
-    JZVideoPlayerStandard jzVideo;
-    @Bind(R.id.tiny_window)
-    Button tinyWindow;
-    @Bind(R.id.auto_tiny_list_view)
-    Button autoTinyListView;
-    @Bind(R.id.auto_tiny_list_view_multi_holder)
-    Button autoTinyListViewMultiHolder;
-    @Bind(R.id.auto_tiny_list_view_recycleview)
-    Button autoTinyListViewRecycleview;
-    @Bind(R.id.auto_tiny_list_view_recycleview_multiholder)
-    Button autoTinyListViewRecycleviewMultiholder;
-
-
-    @Override
-    protected void onPause() {
-        super.onPause();
-        JZVideoPlayer.releaseAllVideos();
-    }
-
-
-    @Override
-    public void onBackPressed() {
-        if (JZVideoPlayer.backPress()) {
-            return;
-        }
-        super.onBackPressed();
-    }
-
-
-    @Override
-    public int getContentView() {
-        return R.layout.activity_test_three;
-    }
-
-
-    @Override
-    public void initView() {
-        jzVideo.setUp("http://jzvd.nathen.cn/342a5f7ef6124a4a8faf00e738b8bee4/cf6d9db0bd4d41f59d09ea0a81e918fd-5287d2089db37e62345123a1be272f8b.mp4"
-                , JZVideoPlayerStandard.SCREEN_WINDOW_NORMAL, "饺子快长大");
-        Picasso.with(this)
-                .load("http://jzvd-pic.nathen.cn/jzvd-pic/1bb2ebbe-140d-4e2e-abd2-9e7e564f71ac.png")
-                .into(jzVideo.thumbImageView);
-
-    }
-
-    @Override
-    public void initListener() {
-        tinyWindow.setOnClickListener(this);
-        autoTinyListView.setOnClickListener(this);
-        autoTinyListViewMultiHolder.setOnClickListener(this);
-        autoTinyListViewRecycleview.setOnClickListener(this);
-        autoTinyListViewRecycleviewMultiholder.setOnClickListener(this);
-
-    }
-
-    @Override
-    public void initData() {
-
-    }
-
-
-    @Override
-    public void onClick(View view) {
-        switch (view.getId()) {
-            case R.id.tiny_window:
-                jzVideo.startWindowTiny();
-                break;
-            case R.id.auto_tiny_list_view:
-                startActivity(TestTinyFirstActivity.class);
-                break;
-            case R.id.auto_tiny_list_view_multi_holder:
-                startActivity(TestTinyThirdActivity.class);
-                break;
-            case R.id.auto_tiny_list_view_recycleview:
-                startActivity(TestTinyFourActivity.class);
-                break;
-            case R.id.auto_tiny_list_view_recycleview_multiholder:
-                startActivity(TestTinyFiveActivity.class);
-                break;
-            default:
-                break;
-        }
-    }
-
-}

app/src/main/java/org/yczbj/ycvideoplayer/ui/test/test1/view/three/TestTinyFirstActivity.java

@@ -1,146 +0,0 @@
-package org.yczbj.ycvideoplayer.ui.test.test1.view.three;
-
-import android.content.Context;
-import android.view.LayoutInflater;
-import android.view.View;
-import android.view.ViewGroup;
-import android.widget.AbsListView;
-import android.widget.BaseAdapter;
-import android.widget.ListView;
-
-import com.squareup.picasso.Picasso;
-
-import org.yczbj.ycvideoplayer.R;
-import org.yczbj.ycvideoplayer.base.mvp1.BaseActivity;
-import org.yczbj.ycvideoplayer.ui.test.test1.model.VideoConstant;
-
-import butterknife.Bind;
-import cn.jzvd.JZVideoPlayer;
-import cn.jzvd.JZVideoPlayerStandard;
-
-/**
- * Description:
- * Update:
- * CreatedTime:2017/12/29
- * Author:yc
- */
-public class TestTinyFirstActivity extends BaseActivity {
-
-
-    @Bind(R.id.listView)
-    ListView listView;
-
-    @Override
-    public void onBackPressed() {
-        if (JZVideoPlayer.backPress()) {
-            return;
-        }
-        super.onBackPressed();
-    }
-
-
-    @Override
-    protected void onPause() {
-        super.onPause();
-        JZVideoPlayer.releaseAllVideos();
-    }
-
-
-    @Override
-    public int getContentView() {
-        return R.layout.activity_test_list_first;
-    }
-
-    @Override
-    public void initView() {
-        listView.setAdapter(new AdapterVideoList(this,
-                VideoConstant.videoUrls[0],
-                VideoConstant.videoTitles[0],
-                VideoConstant.videoThumbs[0]));
-
-        listView.setOnScrollListener(new AbsListView.OnScrollListener() {
-            @Override
-            public void onScrollStateChanged(AbsListView view, int scrollState) {
-
-            }
-
-            @Override
-            public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) {
-                //开启小窗口视频模式
-                JZVideoPlayer.onScrollAutoTiny(view, firstVisibleItem, visibleItemCount, totalItemCount);
-                //JZVideoPlayer.onScrollReleaseAllVideos(view, firstVisibleItem, visibleItemCount, totalItemCount);
-            }
-        });
-    }
-
-    @Override
-    public void initListener() {
-
-    }
-
-    @Override
-    public void initData() {
-
-    }
-
-
-    public static class AdapterVideoList extends BaseAdapter {
-
-        public static final String TAG = "JiaoZiVideoPlayer";
-        Context context;
-        String[] videoUrls;
-        String[] videoTitles;
-        String[] videoThumbs;
-
-        AdapterVideoList(Context context, String[] videoUrls, String[] videoTitles, String[] videoThumbs) {
-            this.context = context;
-            this.videoUrls = videoUrls;
-            this.videoTitles = videoTitles;
-            this.videoThumbs = videoThumbs;
-        }
-
-        @Override
-        public int getCount() {
-            return videoUrls.length;
-        }
-
-        @Override
-        public Object getItem(int position) {
-            return null;
-        }
-
-        @Override
-        public long getItemId(int position) {
-            return position;
-        }
-
-        @Override
-        public View getView(int position, View convertView, ViewGroup parent) {
-            ViewHolder viewHolder;
-            if (null == convertView) {
-                viewHolder = new ViewHolder();
-                LayoutInflater mInflater = LayoutInflater.from(context);
-                convertView = mInflater.inflate(R.layout.item_test_list_videoview, null);
-                convertView.setTag(viewHolder);
-            } else {
-                viewHolder = (ViewHolder) convertView.getTag();
-            }
-            viewHolder.jzVideoPlayer = (JZVideoPlayerStandard)convertView.findViewById(R.id.videoplayer);
-            viewHolder.jzVideoPlayer.setUp(
-                    videoUrls[position], JZVideoPlayer.SCREEN_WINDOW_LIST,
-                    videoTitles[position]);
-            Picasso.with(convertView.getContext())
-                    .load(videoThumbs[position])
-                    .into(viewHolder.jzVideoPlayer.thumbImageView);
-
-            viewHolder.jzVideoPlayer.positionInList = position;
-            return convertView;
-        }
-
-        class ViewHolder {
-            JZVideoPlayerStandard jzVideoPlayer;
-        }
-    }
-
-
-}

app/src/main/java/org/yczbj/ycvideoplayer/ui/test/test1/view/three/TestTinyFiveActivity.java

@@ -1,118 +0,0 @@
-package org.yczbj.ycvideoplayer.ui.test.test1.view.three;
-
-import android.support.v7.widget.LinearLayoutManager;
-import android.support.v7.widget.RecyclerView;
-import android.view.View;
-
-
-import com.pedaily.yc.ycdialoglib.customToast.ToastUtil;
-
-import org.yczbj.ycvideoplayer.R;
-import org.yczbj.ycvideoplayer.base.mvp1.BaseActivity;
-import org.yczbj.ycvideoplayer.listener.OnListItemClickListener;
-import org.yczbj.ycvideoplayer.ui.test.test1.view.second.TestFiveBean;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import butterknife.Bind;
-import cn.jzvd.JZVideoPlayer;
-
-/**
- * Description:
- * Update:
- * CreatedTime:2017/12/29
- * Author:yc
- */
-public class TestTinyFiveActivity extends BaseActivity {
-
-    @Bind(R.id.recyclerView)
-    RecyclerView recyclerView;
-    private TestTinyFiveAdapter adapterVideoList;
-    private List<TestFiveBean> list;
-
-
-    @Override
-    public void onBackPressed() {
-        if (JZVideoPlayer.backPress()) {
-            return;
-        }
-        super.onBackPressed();
-    }
-
-    @Override
-    protected void onPause() {
-        super.onPause();
-        JZVideoPlayer.releaseAllVideos();
-    }
-
-
-    @Override
-    public int getContentView() {
-        return R.layout.base_recycler_view;
-    }
-
-    @Override
-    public void initView() {
-        list = new ArrayList<>();
-        for(int a=0 ; a<10 ; a++){
-            if(a==2 || a==5 || a==7 || a==9){
-                TestFiveBean bean = new TestFiveBean(1,"five");
-                list.add(bean);
-            }else {
-                TestFiveBean bean = new TestFiveBean(2,"five");
-                list.add(bean);
-            }
-        }
-
-        recyclerView.setLayoutManager(new LinearLayoutManager(this));
-        adapterVideoList = new TestTinyFiveAdapter(this, list);
-        recyclerView.setAdapter(adapterVideoList);
-    }
-
-    @Override
-    public void initListener() {
-        /*recyclerView.addOnChildAttachStateChangeListener(new RecyclerView.OnChildAttachStateChangeListener() {
-            @Override
-            public void onChildViewAttachedToWindow(View view) {
-            }
-
-            @Override
-            public void onChildViewDetachedFromWindow(View view) {
-                JZVideoPlayer jzvd = (JZVideoPlayer)view.findViewById(R.id.videoplayer);
-                if (jzvd != null && JZUtils.dataSourceObjectsContainsUri(jzvd.dataSourceObjects, JZMediaManager.getCurrentDataSource())) {
-                    JZVideoPlayer.releaseAllVideos();
-                }
-            }
-        });*/
-        recyclerView.addOnChildAttachStateChangeListener(new RecyclerView.OnChildAttachStateChangeListener() {
-            @Override
-            public void onChildViewAttachedToWindow(View view) {
-                JZVideoPlayer.onChildViewAttachedToWindow(view, R.id.videoplayer);
-            }
-
-            @Override
-            public void onChildViewDetachedFromWindow(View view) {
-                JZVideoPlayer.onChildViewDetachedFromWindow(view);
-            }
-        });
-
-        adapterVideoList.setOnItemClickListener(new OnListItemClickListener() {
-            @Override
-            public void onItemClick(View view, int position) {
-                if(list.get(position).getType()==1){
-                    ToastUtil.showToast(TestTinyFiveActivity.this,"这个是视频控件");
-                }else if(list.get(position).getType()==2){
-                    ToastUtil.showToast(TestTinyFiveActivity.this,"这个是文本控件");
-                }
-            }
-        });
-    }
-
-    @Override
-    public void initData() {
-
-    }
-
-
-}

app/src/main/java/org/yczbj/ycvideoplayer/ui/test/test1/view/three/TestTinyFiveAdapter.java

@@ -1,111 +0,0 @@
-package org.yczbj.ycvideoplayer.ui.test.test1.view.three;
-
-import android.content.Context;
-import android.support.v7.widget.RecyclerView;
-import android.view.LayoutInflater;
-import android.view.View;
-import android.view.ViewGroup;
-import android.widget.TextView;
-
-import com.squareup.picasso.Picasso;
-
-import org.yczbj.ycvideoplayer.R;
-import org.yczbj.ycvideoplayer.listener.OnListItemClickListener;
-import org.yczbj.ycvideoplayer.ui.test.test1.model.VideoConstant;
-import org.yczbj.ycvideoplayer.ui.test.test1.view.second.TestFiveBean;
-
-import java.util.List;
-
-import cn.jzvd.JZVideoPlayer;
-import cn.jzvd.JZVideoPlayerStandard;
-
-public class TestTinyFiveAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolder> {
-
-    private static final String TAG = "AdapterRecyclerViewVideo";
-    private List<TestFiveBean> list;
-    private Context context;
-
-    TestTinyFiveAdapter(Context context, List<TestFiveBean> list) {
-        this.context = context;
-        this.list = list;
-    }
-
-    @Override
-    public RecyclerView.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
-        if(viewType == 1){
-            return new MyViewHolder(LayoutInflater.from(context).inflate(
-                    R.layout.item_test_list_videoview, parent, false));
-        }else if(viewType == 2){
-            return new TextViewViewHolder(LayoutInflater.from(context).inflate(
-                    R.layout.item_test_list_textview, parent, false));
-        }else {
-            return new TextViewViewHolder(LayoutInflater.from(context).inflate(
-                    R.layout.item_test_list_textview, parent, false));
-        }
-    }
-
-    @Override
-    public void onBindViewHolder(RecyclerView.ViewHolder holder, final int position) {
-        if(holder instanceof MyViewHolder){
-            ((MyViewHolder) holder).jzVideoPlayer.setUp(
-                    VideoConstant.videoUrls[0][position], JZVideoPlayer.SCREEN_WINDOW_LIST,
-                    VideoConstant.videoTitles[0][position]);
-            Picasso.with(((MyViewHolder) holder).jzVideoPlayer.getContext())
-                    .load(VideoConstant.videoThumbs[0][position])
-                    .into(((MyViewHolder) holder).jzVideoPlayer.thumbImageView);
-        }else if(holder instanceof TextViewViewHolder){
-             ((TextViewViewHolder) holder).textview.setText("这个是文本控件");
-        }
-        holder.itemView.setOnClickListener(new View.OnClickListener() {
-            @Override
-            public void onClick(View view) {
-                if(mItemClickListener!=null){
-                    mItemClickListener.onItemClick(view,position);
-                }
-            }
-        });
-    }
-
-    @Override
-    public int getItemCount() {
-        return list.size();
-    }
-
-    @Override
-    public int getItemViewType(int position) {
-        if(list.get(position).getType()==1){
-            return 1;
-        }else if(list.get(position).getType()==2){
-            return 2;
-        }else {
-            return 2;
-        }
-    }
-
-    class MyViewHolder extends RecyclerView.ViewHolder {
-
-        JZVideoPlayerStandard jzVideoPlayer;
-
-        MyViewHolder(View itemView) {
-            super(itemView);
-            jzVideoPlayer = (JZVideoPlayerStandard)itemView.findViewById(R.id.videoplayer);
-        }
-    }
-
-    class TextViewViewHolder extends RecyclerView.ViewHolder {
-
-        TextView textview;
-
-        TextViewViewHolder(View itemView) {
-            super(itemView);
-            textview = (TextView) itemView.findViewById(R.id.textview);
-        }
-    }
-
-    private OnListItemClickListener mItemClickListener;
-    public void setOnItemClickListener(OnListItemClickListener listener) {
-        this.mItemClickListener = listener;
-    }
-
-
-}

app/src/main/java/org/yczbj/ycvideoplayer/ui/test/test1/view/three/TestTinyFourActivity.java

@@ -1,78 +0,0 @@
-package org.yczbj.ycvideoplayer.ui.test.test1.view.three;
-
-import android.support.v7.widget.LinearLayoutManager;
-import android.support.v7.widget.RecyclerView;
-import android.view.View;
-
-import org.yczbj.ycvideoplayer.R;
-import org.yczbj.ycvideoplayer.base.mvp1.BaseActivity;
-
-import butterknife.Bind;
-import cn.jzvd.JZVideoPlayer;
-
-/**
- * Description:
- * Update:
- * CreatedTime:2017/12/29
- * Author:yc
- */
-public class TestTinyFourActivity extends BaseActivity {
-
-    @Bind(R.id.recyclerView)
-    RecyclerView recyclerView;
-    private TestTinyFourAdapter adapterVideoList;
-
-    @Override
-    public void onBackPressed() {
-        if (JZVideoPlayer.backPress()) {
-            return;
-        }
-        super.onBackPressed();
-    }
-
-    @Override
-    protected void onPause() {
-        super.onPause();
-        JZVideoPlayer.releaseAllVideos();
-    }
-
-
-    @Override
-    public int getContentView() {
-        return R.layout.base_recycler_view;
-    }
-
-    @Override
-    public void initView() {
-        recyclerView.setLayoutManager(new LinearLayoutManager(this));
-        adapterVideoList = new TestTinyFourAdapter(this);
-        recyclerView.setAdapter(adapterVideoList);
-    }
-
-    @Override
-    public void initListener() {
-        recyclerView.addOnChildAttachStateChangeListener(new RecyclerView.OnChildAttachStateChangeListener() {
-            @Override
-            public void onChildViewAttachedToWindow(View view) {
-                JZVideoPlayer.onChildViewAttachedToWindow(view, R.id.videoplayer);
-            }
-
-            @Override
-            public void onChildViewDetachedFromWindow(View view) {
-                /*JZVideoPlayer jzvd = (JZVideoPlayer)view.findViewById(R.id.videoplayer);
-                if (jzvd != null && JZUtils.dataSourceObjectsContainsUri(jzvd.dataSourceObjects, JZMediaManager.getCurrentDataSource())) {
-                    JZVideoPlayer.releaseAllVideos();
-                }*/
-
-                JZVideoPlayer.onChildViewDetachedFromWindow(view);
-            }
-        });
-    }
-
-    @Override
-    public void initData() {
-
-    }
-
-
-}

app/src/main/java/org/yczbj/ycvideoplayer/ui/test/test1/view/three/TestTinyFourAdapter.java

@@ -1,63 +0,0 @@
-package org.yczbj.ycvideoplayer.ui.test.test1.view.three;
-
-import android.annotation.SuppressLint;
-import android.content.Context;
-import android.support.v7.widget.RecyclerView;
-import android.util.Log;
-import android.view.LayoutInflater;
-import android.view.View;
-import android.view.ViewGroup;
-
-import com.squareup.picasso.Picasso;
-
-import org.yczbj.ycvideoplayer.R;
-import org.yczbj.ycvideoplayer.ui.test.test1.model.VideoConstant;
-
-import cn.jzvd.JZVideoPlayer;
-import cn.jzvd.JZVideoPlayerStandard;
-
-public class TestTinyFourAdapter extends RecyclerView.Adapter<TestTinyFourAdapter.MyViewHolder> {
-
-    public static final String TAG = "AdapterRecyclerViewVideo";
-    int[] videoIndexs = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
-    private Context context;
-
-    public TestTinyFourAdapter(Context context) {
-        this.context = context;
-    }
-
-    @Override
-    public MyViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
-        MyViewHolder holder = new MyViewHolder(LayoutInflater.from(
-                context).inflate(R.layout.item_test_list_videoview, parent,
-                false));
-        return holder;
-    }
-
-    @SuppressLint("LongLogTag")
-    @Override
-    public void onBindViewHolder(MyViewHolder holder, int position) {
-        Log.i(TAG, "onBindViewHolder [" + holder.jzVideoPlayer.hashCode() + "] position=" + position);
-        holder.jzVideoPlayer.setUp(
-                VideoConstant.videoUrls[0][position], JZVideoPlayer.SCREEN_WINDOW_LIST,
-                VideoConstant.videoTitles[0][position]);
-        Picasso.with(holder.jzVideoPlayer.getContext())
-                .load(VideoConstant.videoThumbs[0][position])
-                .into(holder.jzVideoPlayer.thumbImageView);
-    }
-
-    @Override
-    public int getItemCount() {
-        return videoIndexs.length;
-    }
-
-    class MyViewHolder extends RecyclerView.ViewHolder {
-        JZVideoPlayerStandard jzVideoPlayer;
-
-        MyViewHolder(View itemView) {
-            super(itemView);
-            jzVideoPlayer = (JZVideoPlayerStandard)itemView.findViewById(R.id.videoplayer);
-        }
-    }
-
-}

app/src/main/java/org/yczbj/ycvideoplayer/ui/test/test1/view/three/TestTinyThirdActivity.java

@@ -1,165 +0,0 @@
-package org.yczbj.ycvideoplayer.ui.test.test1.view.three;
-
-import android.content.Context;
-import android.view.LayoutInflater;
-import android.view.View;
-import android.view.ViewGroup;
-import android.widget.AbsListView;
-import android.widget.BaseAdapter;
-import android.widget.ListView;
-import android.widget.TextView;
-
-import com.squareup.picasso.Picasso;
-
-import org.yczbj.ycvideoplayer.R;
-import org.yczbj.ycvideoplayer.base.mvp1.BaseActivity;
-import org.yczbj.ycvideoplayer.ui.test.test1.model.VideoConstant;
-
-import butterknife.Bind;
-import cn.jzvd.JZVideoPlayer;
-import cn.jzvd.JZVideoPlayerStandard;
-
-/**
- * Description:
- * Update:
- * CreatedTime:2017/12/29
- * Author:yc
- */
-public class TestTinyThirdActivity extends BaseActivity {
-
-    @Bind(R.id.listView)
-    ListView listView;
-    private VideoListAdapter mAdapter;
-
-    @Override
-    public void onBackPressed() {
-        if (JZVideoPlayer.backPress()) {
-            return;
-        }
-        super.onBackPressed();
-    }
-
-    @Override
-    protected void onPause() {
-        super.onPause();
-        JZVideoPlayer.releaseAllVideos();
-    }
-
-
-    @Override
-    public int getContentView() {
-        return R.layout.activity_test_list_first;
-    }
-
-    @Override
-    public void initView() {
-        mAdapter = new VideoListAdapter(this);
-        listView.setAdapter(mAdapter);
-        listView.setOnScrollListener(new AbsListView.OnScrollListener() {
-            @Override
-            public void onScrollStateChanged(AbsListView view, int scrollState) {
-
-            }
-
-            @Override
-            public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) {
-                //JZVideoPlayer.onScrollReleaseAllVideos(view, firstVisibleItem, visibleItemCount, totalItemCount);
-                //开启小窗口视频模式
-                JZVideoPlayer.onScrollAutoTiny(view, firstVisibleItem, visibleItemCount, totalItemCount);
-            }
-        });
-    }
-
-    @Override
-    public void initListener() {
-
-    }
-
-    @Override
-    public void initData() {
-
-    }
-
-
-    public class VideoListAdapter extends BaseAdapter {
-
-        int[] viewtype = {0, 0, 0, 1, 0, 0, 0, 1, 0, 0};//1 = jzvd, 0 = textView
-
-        Context context;
-        LayoutInflater mInflater;
-
-        VideoListAdapter(Context context) {
-            this.context = context;
-            mInflater = LayoutInflater.from(context);
-        }
-
-        @Override
-        public int getCount() {
-            return viewtype.length;
-        }
-
-        @Override
-        public Object getItem(int position) {
-            return null;
-        }
-
-        @Override
-        public long getItemId(int position) {
-            return position;
-        }
-
-        @Override
-        public View getView(int position, View convertView, ViewGroup parent) {
-            if (getItemViewType(position) == 1) {
-                VideoListAdapter.VideoHolder viewHolder;
-                if (convertView != null && convertView.getTag() != null && convertView.getTag() instanceof VideoListAdapter.VideoHolder) {
-                    viewHolder = (VideoListAdapter.VideoHolder) convertView.getTag();
-                } else {
-                    viewHolder = new VideoListAdapter.VideoHolder();
-                    convertView = mInflater.inflate(R.layout.item_test_list_videoview, null);
-                    viewHolder.jzVideoPlayer = (JZVideoPlayerStandard)convertView.findViewById(R.id.videoplayer);
-                    convertView.setTag(viewHolder);
-                }
-
-                viewHolder.jzVideoPlayer.setUp(
-                        VideoConstant.videoUrls[0][position], JZVideoPlayer.SCREEN_WINDOW_LIST,
-                        VideoConstant.videoTitles[0][position]);
-                viewHolder.jzVideoPlayer.positionInList = position;
-                Picasso.with(TestTinyThirdActivity.this)
-                        .load(VideoConstant.videoThumbs[0][position])
-                        .into(viewHolder.jzVideoPlayer.thumbImageView);
-            } else {
-                VideoListAdapter.TextViewHolder textViewHolder;
-                if (convertView != null && convertView.getTag() != null && convertView.getTag() instanceof VideoListAdapter.TextViewHolder) {
-                    textViewHolder = (VideoListAdapter.TextViewHolder) convertView.getTag();
-                } else {
-                    textViewHolder = new VideoListAdapter.TextViewHolder();
-                    LayoutInflater mInflater = LayoutInflater.from(context);
-                    convertView = mInflater.inflate(R.layout.item_test_list_textview, null);
-                    textViewHolder.textView = (TextView) convertView.findViewById(R.id.textview);
-                    convertView.setTag(textViewHolder);
-                }
-            }
-            return convertView;
-        }
-
-        @Override
-        public int getItemViewType(int position) {
-            return viewtype[position];
-        }
-
-        @Override
-        public int getViewTypeCount() {
-            return 2;
-        }
-
-        class VideoHolder {
-            JZVideoPlayerStandard jzVideoPlayer;
-        }
-
-        class TextViewHolder {
-            TextView textView;
-        }
-    }
-
-}