file_path stringlengths 3 280 | file_language stringclasses 66 values | content stringlengths 1 1.04M | repo_name stringlengths 5 92 | repo_stars int64 0 154k | repo_description stringlengths 0 402 | repo_primary_language stringclasses 108 values | developer_username stringlengths 1 25 | developer_name stringlengths 0 30 | developer_company stringlengths 0 82 |
|---|---|---|---|---|---|---|---|---|---|
Demo/src/main/java/com/yc/ycvideoplayer/oldPlayer/TestNormalActivity.java | Java | package com.yc.ycvideoplayer.oldPlayer;
import android.widget.ImageView;
import com.yc.ycvideoplayer.BaseActivity;
import com.yc.ycvideoplayer.ConstantVideo;
import org.yc.ycvideoplayer.R;
import com.yc.video.config.ConstantKeys;
import com.yc.video.old.controller.VideoPlayerController;
import com.yc.video.old.listener.OnVideoControlListener;
import com.yc.video.old.other.VideoPlayerManager;
import com.yc.video.old.player.OldVideoPlayer;
import cn.ycbjie.ycstatusbarlib.bar.StateAppBar;
/**
* @author yc
*/
public class TestNormalActivity extends BaseActivity {
OldVideoPlayer videoPlayer;
private VideoPlayerController controller;
@Override
protected void onStop() {
super.onStop();
VideoPlayerManager.instance().suspendVideoPlayer();
}
@Override
protected void onDestroy() {
super.onDestroy();
VideoPlayerManager.instance().releaseVideoPlayer();
}
@Override
public void onBackPressed() {
if (VideoPlayerManager.instance().onBackPressed()){
return;
}else {
VideoPlayerManager.instance().releaseVideoPlayer();
}
super.onBackPressed();
}
@Override
protected void onRestart() {
super.onRestart();
VideoPlayerManager.instance().resumeVideoPlayer();
}
@Override
public int getContentView() {
return R.layout.activity_full_video2;
}
@Override
public void initView() {
StateAppBar.translucentStatusBar(this, true);
videoPlayer = (OldVideoPlayer) findViewById(R.id.video_player);
//必须关键的4步，播放视频最简单的方式
videoPlayer.setPlayerType(ConstantKeys.VideoPlayerType.TYPE_IJK);
videoPlayer.setUp(ConstantVideo.VideoPlayerList[0], null);
controller = new VideoPlayerController(this);
controller.setTopPadding(24.0f);
videoPlayer.continueFromLastPosition(false);
videoPlayer.setController(controller);
}
@Override
public void initListener() {
}
@Override
public void initData() {
}
private void test(){
//关于视频播放相关api
//获取缓冲区百分比
int bufferPercentage = videoPlayer.getBufferPercentage();
//获取播放位置
long currentPosition = videoPlayer.getCurrentPosition();
//获取当前播放模式
int currentState = videoPlayer.getCurrentState();
//获取持续时长
long duration = videoPlayer.getDuration();
//获取最大音量
int maxVolume = videoPlayer.getMaxVolume();
//获取当前播放状态
int playType = videoPlayer.getPlayType();
//获取播放速度
long tcpSpeed = videoPlayer.getTcpSpeed();
//获取音量值
int volume = videoPlayer.getVolume();
//判断是否是否缓冲暂停
boolean bufferingPaused = videoPlayer.isBufferingPaused();
//判断视频是否正在缓冲(播放器正在播放时，缓冲区数据不足，进行缓冲，缓冲区数据足够后恢复播放)
boolean bufferingPlaying = videoPlayer.isBufferingPlaying();
//判断视频是否播放完成
boolean completed = videoPlayer.isCompleted();
//判断视频是否播放错误
boolean error = videoPlayer.isError();
//判断视频是否播放全屏
boolean fullScreen = videoPlayer.isFullScreen();
//判断是否开始播放
boolean idle = videoPlayer.isIdle();
//判断视频是否正常播放
boolean normal = videoPlayer.isNormal();
//判断视频是否暂停播放
boolean paused = videoPlayer.isPaused();
//判断视频是否正在播放
boolean playing = videoPlayer.isPlaying();
//判断视频是否准备就绪
boolean prepared = videoPlayer.isPrepared();
//判断视频是否播放准备中
boolean preparing = videoPlayer.isPreparing();
//判断视频是否播放小窗口
boolean tinyWindow = videoPlayer.isTinyWindow();
//进入全屏模式
videoPlayer.enterFullScreen();
//进入竖屏的全屏模式
videoPlayer.enterVerticalScreenScreen();
//进入小窗口播放
//注意：小窗口播放视频比例是 16：9
videoPlayer.enterTinyWindow();
//释放，内部的播放器被释放掉，同时如果在全屏、小窗口模式下都会退出
videoPlayer.release();
//释放播放器，注意一定要判断对象是否为空，增强严谨性
videoPlayer.releasePlayer();
//设置播放器类型，必须设置
//输入值：ConstantKeys.IjkPlayerType.TYPE_IJK 或者 ConstantKeys.IjkPlayerType.TYPE_NATIVE
videoPlayer.setPlayerType(ConstantKeys.VideoPlayerType.TYPE_IJK);
//设置播放位置
videoPlayer.seekTo(100);
//设置播放速度，不必须
videoPlayer.setSpeed(100);
//设置视频链接
videoPlayer.setUp("",null);
//设置音量
videoPlayer.setVolume(50);
//是否从上一次的位置继续播放
videoPlayer.continueFromLastPosition(true);
//开始播放
videoPlayer.start();
//暂停播放
videoPlayer.pause();
//开始播放
videoPlayer.start(100);
//重新播放
videoPlayer.restart();
//设置是否显示视频头部的下载，分享，其他等控件是否显示
controller.setTopVisibility(true);
controller.setTop(20);
//设置top到顶部的距离
controller.setTopPadding(30);
//设置加载loading类型
controller.setLoadingType(ConstantKeys.Loading.LOADING_RING);
//设置不操作后，多久自动隐藏头部和底部布局
controller.setHideTime(8000);
//获取ImageView的对象
ImageView imageView = controller.imageView();
//重新设置
controller.reset();
//设置图片
//controller.setImage(R.drawable.ic_back_right);
//设置视频时长
controller.setLength(1000);
//设置视频标题
controller.setTitle("小杨逗比");
boolean lock = controller.getLock();
//设置横屏播放时，tv和audio图标是否显示
controller.setTvAndAudioVisibility(true,true);
//设置视频分享，下载，音视频转化点击事件
controller.setOnVideoControlListener(new OnVideoControlListener() {
@Override
public void onVideoControlClick(int type) {
}
});
//VideoPlayerManager对象
VideoPlayerManager instance = VideoPlayerManager.instance();
//当视频暂停时或者缓冲暂停时，调用该方法重新开启视频播放
instance.resumeVideoPlayer();
//当视频正在播放或者正在缓冲时，调用该方法暂停视频
instance.suspendVideoPlayer();
//释放，内部的播放器被释放掉，同时如果在全屏、小窗口模式下都会退出
instance.releaseVideoPlayer();
//处理返回键逻辑
//如果是全屏，则退出全屏
//如果是小窗口，则退出小窗口
instance.onBackPressed();
//获取对象
OldVideoPlayer currentVideoPlayer = instance.getCurrentVideoPlayer();
//设置VideoPlayer
instance.setCurrentVideoPlayer(videoPlayer);
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/oldPlayer/TestRecyclerActivity.java | Java | package com.yc.ycvideoplayer.oldPlayer;
import androidx.recyclerview.widget.LinearLayoutManager;
import androidx.recyclerview.widget.RecyclerView;
import com.yc.ycvideoplayer.BaseActivity;
import com.yc.ycvideoplayer.ConstantVideo;
import org.yc.ycvideoplayer.R;
import com.yc.video.old.other.VideoPlayerManager;
import com.yc.video.old.player.OldVideoPlayer;
import java.util.ArrayList;
import java.util.List;
/**
* @author yc
*/
public class TestRecyclerActivity extends BaseActivity {
RecyclerView recyclerView;
@Override
protected void onStop() {
super.onStop();
VideoPlayerManager.instance().releaseVideoPlayer();
}
@Override
public void onBackPressed() {
if (VideoPlayerManager.instance().onBackPressed()){
return;
}
super.onBackPressed();
}
@Override
public int getContentView() {
return R.layout.base_recycler_view;
}
@Override
public void initView() {
recyclerView = (RecyclerView) findViewById(R.id.recyclerView);
recyclerView.setLayoutManager(new LinearLayoutManager(this));
recyclerView.setHasFixedSize(true);
List<Video> list = new ArrayList<>();
for (int a = 0; a< ConstantVideo.VideoPlayerList.length ; a++){
Video video = new Video(ConstantVideo.VideoPlayerTitle[a],ConstantVideo.VideoPlayerList[a]);
list.add(video);
}
VideoAdapter adapter = new VideoAdapter(this, list);
recyclerView.setAdapter(adapter);
recyclerView.setRecyclerListener(new RecyclerView.RecyclerListener() {
@Override
public void onViewRecycled(RecyclerView.ViewHolder holder) {
OldVideoPlayer videoPlayer = ((VideoAdapter.VideoViewHolder) holder).mVideoPlayer;
if (videoPlayer == VideoPlayerManager.instance().getCurrentVideoPlayer()) {
VideoPlayerManager.instance().releaseVideoPlayer();
}
}
});
}
@Override
public void initListener() {
}
@Override
public void initData() {
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/oldPlayer/TestSavePosActivity.java | Java | package com.yc.ycvideoplayer.oldPlayer;
import android.widget.ImageView;
import com.yc.ycvideoplayer.BaseActivity;
import com.yc.ycvideoplayer.ConstantVideo;
import org.yc.ycvideoplayer.R;
import com.yc.video.config.ConstantKeys;
import com.yc.video.old.controller.VideoPlayerController;
import com.yc.video.old.listener.OnVideoControlListener;
import com.yc.video.old.other.VideoPlayerManager;
import com.yc.video.old.player.OldVideoPlayer;
import cn.ycbjie.ycstatusbarlib.bar.StateAppBar;
/**
* @author yc
*/
public class TestSavePosActivity extends BaseActivity {
OldVideoPlayer videoPlayer;
private VideoPlayerController controller;
@Override
protected void onStop() {
super.onStop();
VideoPlayerManager.instance().suspendVideoPlayer();
}
@Override
protected void onDestroy() {
super.onDestroy();
VideoPlayerManager.instance().releaseVideoPlayer();
}
@Override
public void onBackPressed() {
if (VideoPlayerManager.instance().onBackPressed()){
return;
}else {
VideoPlayerManager.instance().releaseVideoPlayer();
}
super.onBackPressed();
}
@Override
protected void onRestart() {
super.onRestart();
VideoPlayerManager.instance().resumeVideoPlayer();
}
@Override
public int getContentView() {
return R.layout.activity_full_video1;
}
@Override
public void initView() {
StateAppBar.translucentStatusBar(this, true);
videoPlayer = (OldVideoPlayer) findViewById(R.id.video_player);
//必须关键的4步，播放视频最简单的方式
videoPlayer.setPlayerType(ConstantKeys.VideoPlayerType.TYPE_IJK);
videoPlayer.setUp(ConstantVideo.VideoPlayerList[0], null);
controller = new VideoPlayerController(this);
controller.setTopPadding(24.0f);
videoPlayer.continueFromLastPosition(true);
videoPlayer.setController(controller);
}
@Override
public void initListener() {
}
@Override
public void initData() {
}
private void test(){
//关于视频播放相关api
//获取缓冲区百分比
int bufferPercentage = videoPlayer.getBufferPercentage();
//获取播放位置
long currentPosition = videoPlayer.getCurrentPosition();
//获取当前播放模式
int currentState = videoPlayer.getCurrentState();
//获取持续时长
long duration = videoPlayer.getDuration();
//获取最大音量
int maxVolume = videoPlayer.getMaxVolume();
//获取当前播放状态
int playType = videoPlayer.getPlayType();
//获取播放速度
long tcpSpeed = videoPlayer.getTcpSpeed();
//获取音量值
int volume = videoPlayer.getVolume();
//判断是否是否缓冲暂停
boolean bufferingPaused = videoPlayer.isBufferingPaused();
//判断视频是否正在缓冲(播放器正在播放时，缓冲区数据不足，进行缓冲，缓冲区数据足够后恢复播放)
boolean bufferingPlaying = videoPlayer.isBufferingPlaying();
//判断视频是否播放完成
boolean completed = videoPlayer.isCompleted();
//判断视频是否播放错误
boolean error = videoPlayer.isError();
//判断视频是否播放全屏
boolean fullScreen = videoPlayer.isFullScreen();
//判断是否开始播放
boolean idle = videoPlayer.isIdle();
//判断视频是否正常播放
boolean normal = videoPlayer.isNormal();
//判断视频是否暂停播放
boolean paused = videoPlayer.isPaused();
//判断视频是否正在播放
boolean playing = videoPlayer.isPlaying();
//判断视频是否准备就绪
boolean prepared = videoPlayer.isPrepared();
//判断视频是否播放准备中
boolean preparing = videoPlayer.isPreparing();
//判断视频是否播放小窗口
boolean tinyWindow = videoPlayer.isTinyWindow();
//进入全屏模式
videoPlayer.enterFullScreen();
//进入竖屏的全屏模式
videoPlayer.enterVerticalScreenScreen();
//进入小窗口播放
//注意：小窗口播放视频比例是 16：9
videoPlayer.enterTinyWindow();
//释放，内部的播放器被释放掉，同时如果在全屏、小窗口模式下都会退出
videoPlayer.release();
//释放播放器，注意一定要判断对象是否为空，增强严谨性
videoPlayer.releasePlayer();
//设置播放器类型，必须设置
//输入值：ConstantKeys.IjkPlayerType.TYPE_IJK 或者 ConstantKeys.IjkPlayerType.TYPE_NATIVE
videoPlayer.setPlayerType(ConstantKeys.VideoPlayerType.TYPE_IJK);
//设置播放位置
videoPlayer.seekTo(100);
//设置播放速度，不必须
videoPlayer.setSpeed(100);
//设置视频链接
videoPlayer.setUp("",null);
//设置音量
videoPlayer.setVolume(50);
//是否从上一次的位置继续播放
videoPlayer.continueFromLastPosition(true);
//开始播放
videoPlayer.start();
//暂停播放
videoPlayer.pause();
//开始播放
videoPlayer.start(100);
//重新播放
videoPlayer.restart();
//设置是否显示视频头部的下载，分享，其他等控件是否显示
controller.setTopVisibility(true);
controller.setTop(20);
//设置top到顶部的距离
controller.setTopPadding(30);
//设置加载loading类型
controller.setLoadingType(ConstantKeys.Loading.LOADING_RING);
//设置不操作后，多久自动隐藏头部和底部布局
controller.setHideTime(8000);
//获取ImageView的对象
ImageView imageView = controller.imageView();
//重新设置
controller.reset();
//设置图片
//controller.setImage(R.drawable.ic_back_right);
//设置视频时长
controller.setLength(1000);
//设置视频标题
controller.setTitle("小杨逗比");
boolean lock = controller.getLock();
//设置横屏播放时，tv和audio图标是否显示
controller.setTvAndAudioVisibility(true,true);
//设置视频分享，下载，音视频转化点击事件
controller.setOnVideoControlListener(new OnVideoControlListener() {
@Override
public void onVideoControlClick(int type) {
}
});
//VideoPlayerManager对象
VideoPlayerManager instance = VideoPlayerManager.instance();
//当视频暂停时或者缓冲暂停时，调用该方法重新开启视频播放
instance.resumeVideoPlayer();
//当视频正在播放或者正在缓冲时，调用该方法暂停视频
instance.suspendVideoPlayer();
//释放，内部的播放器被释放掉，同时如果在全屏、小窗口模式下都会退出
instance.releaseVideoPlayer();
//处理返回键逻辑
//如果是全屏，则退出全屏
//如果是小窗口，则退出小窗口
instance.onBackPressed();
//获取对象
OldVideoPlayer currentVideoPlayer = instance.getCurrentVideoPlayer();
//设置VideoPlayer
instance.setCurrentVideoPlayer(videoPlayer);
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/oldPlayer/TestTinyActivity.java | Java | package com.yc.ycvideoplayer.oldPlayer;
import android.view.View;
import android.widget.Button;
import android.widget.Toast;
import com.bumptech.glide.Glide;
import com.yc.ycvideoplayer.BaseActivity;
import com.yc.ycvideoplayer.ConstantVideo;
import org.yc.ycvideoplayer.R;
import com.yc.video.config.ConstantKeys;
import com.yc.video.old.controller.VideoPlayerController;
import com.yc.video.old.listener.OnVideoControlListener;
import com.yc.video.old.other.VideoPlayerManager;
import com.yc.video.old.player.OldVideoPlayer;
import cn.ycbjie.ycstatusbarlib.bar.StateAppBar;
/**
* @author yc
*/
public class TestTinyActivity extends BaseActivity implements View.OnClickListener {
private OldVideoPlayer videoPlayer;
private Button mBtnTiny1;
private Button mBtnTiny2;
@Override
protected void onStop() {
super.onStop();
VideoPlayerManager.instance().releaseVideoPlayer();
}
@Override
public void onBackPressed() {
if (VideoPlayerManager.instance().onBackPressed()) return;
super.onBackPressed();
}
@Override
public int getContentView() {
return R.layout.activity_test_video3;
}
@Override
public void initView() {
StateAppBar.translucentStatusBar(this, true);
videoPlayer = (OldVideoPlayer) findViewById(R.id.nice_video_player);
mBtnTiny1 = (Button) findViewById(R.id.btn_tiny_1);
mBtnTiny2 = (Button) findViewById(R.id.btn_tiny_2);
videoPlayer.setPlayerType(ConstantKeys.VideoPlayerType.TYPE_IJK);
videoPlayer.setUp(ConstantVideo.VideoPlayerList[0], null);
VideoPlayerController controller = new VideoPlayerController(this);
controller.setLoadingType(ConstantKeys.Loading.LOADING_RING);
controller.setTitle("办公室小野开番外了，居然在办公室开澡堂！老板还点赞？");
controller.setLength(98000);
Glide.with(this)
.load("http://tanzi27niu.cdsb.mobi/wps/wp-content/uploads/2017/05/2017-05-17_17-30-43.jpg")
.placeholder(R.drawable.image_default)
.into(controller.imageView());
controller.setHideTime(2000);
controller.setTopPadding(24);
//设置横屏播放时，tv和audio图标是否显示
controller.setTvAndAudioVisibility(true,true);
controller.setOnVideoControlListener(new OnVideoControlListener() {
@Override
public void onVideoControlClick(int type) {
switch (type){
case ConstantKeys.VideoControl.TV:
//BaseToast.showRoundRectToast("投影tv电视");
break;
case ConstantKeys.VideoControl.HOR_AUDIO:
//BaseToast.showRoundRectToast("切换音频");
break;
default:
break;
}
}
});
videoPlayer.continueFromLastPosition(false);
videoPlayer.setController(controller);
}
@Override
public void initListener() {
mBtnTiny1.setOnClickListener(this);
mBtnTiny2.setOnClickListener(this);
}
@Override
public void initData() {
}
@Override
public void onClick(View v) {
switch (v.getId()){
case R.id.btn_tiny_1:
if (videoPlayer.isIdle()) {
Toast.makeText(this, "要点击播放后才能进入小窗口", Toast.LENGTH_SHORT).show();
} else {
videoPlayer.enterTinyWindow();
}
break;
case R.id.btn_tiny_2:
if (videoPlayer.isIdle()) {
videoPlayer.start();
}
videoPlayer.enterVerticalScreenScreen();
break;
default:
break;
}
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/oldPlayer/TestWindowActivity.java | Java | package com.yc.ycvideoplayer.oldPlayer;
import android.content.Intent;
import android.net.Uri;
import android.os.Build;
import android.provider.Settings;
import android.view.View;
import android.view.animation.BounceInterpolator;
import android.widget.Button;
import androidx.annotation.RequiresApi;
import com.yc.videoview.FloatWindow;
import com.yc.videoview.MoveType;
import com.yc.videoview.WindowScreen;
import com.yc.videoview.WindowUtil;
import com.yc.ycvideoplayer.BaseActivity;
import com.yc.ycvideoplayer.newPlayer.tiny.TestFullActivity;
import org.yc.ycvideoplayer.R;
import com.yc.video.old.other.VideoPlayerManager;
import com.yc.video.old.player.OldVideoPlayer;
/**
* @author yc
*/
public class TestWindowActivity extends BaseActivity implements View.OnClickListener {
private OldVideoPlayer mVideoPlayer;
private Button mBtn1;
private Button mBtn2;
@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_test_window;
}
@Override
public void initView() {
mVideoPlayer = (OldVideoPlayer) findViewById(R.id.video_player);
mBtn1 = (Button) findViewById(R.id.btn_1);
mBtn1.setOnClickListener(this);
mBtn2 = (Button) findViewById(R.id.btn_2);
mBtn2.setOnClickListener(this);
if (Build.VERSION.SDK_INT >= 23) {
if (!WindowUtil.hasPermission(this)) {
requestAlertWindowPermission();
}
}
}
@Override
public void initListener() {
}
@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, TestFullActivity.class));
break;
default:
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();
}
}
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/oldPlayer/Video.java | Java | package com.yc.ycvideoplayer.oldPlayer;
public class Video {
private String title;
private String url;
public Video(String title, String url) {
this.title = title;
this.url = url;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getUrl() {
return url;
}
public void setUrl(String url) {
this.url = url;
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/oldPlayer/VideoAdapter.java | Java | package com.yc.ycvideoplayer.oldPlayer;
import android.content.Context;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import androidx.recyclerview.widget.RecyclerView;
import com.yc.ycvideoplayer.ImageUtil;
import org.yc.ycvideoplayer.R;
import com.yc.video.config.ConstantKeys;
import com.yc.video.old.controller.VideoPlayerController;
import com.yc.video.old.player.OldVideoPlayer;
import java.util.List;
public class VideoAdapter extends RecyclerView.Adapter<VideoAdapter.VideoViewHolder> {
private Context mContext;
private List<Video> mVideoList;
public 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_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();
}
public class VideoViewHolder extends RecyclerView.ViewHolder {
public VideoPlayerController mController;
public OldVideoPlayer mVideoPlayer;
VideoViewHolder(View itemView) {
super(itemView);
mVideoPlayer = (OldVideoPlayer) 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.setPlayerType(ConstantKeys.VideoPlayerType.TYPE_IJK);
mVideoPlayer.setController(mController);
}
void bindData(Video video) {
mController.setTitle(video.getTitle());
//mController.setLength(video.getLength());
ImageUtil.display(itemView.getContext(),video.getUrl(),R.drawable.image_default,mController.imageView());
mVideoPlayer.setUp(video.getUrl(), null);
}
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
MusicPlayer/build.gradle | Gradle | apply plugin: 'com.android.library'
android {
compileSdkVersion 29
buildToolsVersion "29.0.3"
defaultConfig {
minSdkVersion 17
targetSdkVersion 29
versionCode 2
versionName "1.0.2"
}
buildTypes {
release {
minifyEnabled false
proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
}
}
}
dependencies {
implementation fileTree(dir: "libs", include: ["*.jar"])
implementation 'androidx.appcompat:appcompat:1.2.0'
implementation 'androidx.media:media:1.0.1'
}
/** 以下开始是将Android Library上传到jcenter的相关配置**/
apply plugin: 'com.github.dcendents.android-maven'
apply plugin: 'com.jfrog.bintray'
//项目主页
def siteUrl = 'https://github.com/yangchong211/YCVideoPlayer' // project homepage
//项目的版本控制地址
def gitUrl = 'https://github.com/yangchong211/YCVideoPlayer.git' // project git
//发布到组织名称名字，必须填写
group = "cn.yc"
//发布到JCenter上的项目名字，必须填写
def libName = "MusicPlayer"
// 版本号，下次更新是只需要更改版本号即可
version = "1.0.2"
//生成源文件
task sourcesJar(type: Jar) {
from android.sourceSets.main.java.srcDirs
classifier = 'sources'
}
//生成文档
task javadoc(type: Javadoc) {
source = android.sourceSets.main.java.srcDirs
classpath += project.files(android.getBootClasspath().join(File.pathSeparator))
options.encoding "UTF-8"
options.charSet 'UTF-8'
options.author true
options.version true
options.links "https://github.com/linglongxin24/FastDev/tree/master/mylibrary/docs/javadoc"
failOnError false
}
//文档打包成jar
task javadocJar(type: Jar, dependsOn: javadoc) {
classifier = 'javadoc'
from javadoc.destinationDir
}
//拷贝javadoc文件
task copyDoc(type: Copy) {
from "${buildDir}/docs/"
into "docs"
}
//上传到jcenter所需要的源码文件
artifacts {
archives javadocJar
archives sourcesJar
}
// 配置maven库，生成POM.xml文件
install {
repositories.mavenInstaller {
// This generates POM.xml with proper parameters
pom {
project {
packaging 'aar'
//项目描述，自由填写
name 'This is music player lib'
url siteUrl
licenses {
license {
//开源协议
name 'The Apache Software License, Version 2.0'
url 'http://www.apache.org/licenses/LICENSE-2.0.txt'
}
}
developers {
developer {
//开发者的个人信息，根据个人信息填写
id 'yangchong'
name 'yc'
email 'yangchong211@163.com'
}
}
scm {
connection gitUrl
developerConnection gitUrl
url siteUrl
}
}
}
}
}
//上传到jcenter
Properties properties = new Properties()
properties.load(project.rootProject.file('local.properties').newDataInputStream())
bintray {
user = properties.getProperty("bintray.user") //读取 local.properties 文件里面的 bintray.user
key = properties.getProperty("bintray.apikey") //读取 local.properties 文件里面的 bintray.apikey
configurations = ['archives']
pkg {
repo = "maven"
name = libName //发布到JCenter上的项目名字，必须填写
desc = 'android music player' //项目描述
websiteUrl = siteUrl
vcsUrl = gitUrl
licenses = ["Apache-2.0"]
publish = true
}
}
javadoc {
options {
//如果你的项目里面有中文注释的话，必须将格式设置为UTF-8，不然会出现乱码
encoding "UTF-8"
charSet 'UTF-8'
author true
version true
links "http://docs.oracle.com/javase/7/docs/api"
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
MusicPlayer/src/main/java/com/yc/music/config/MusicConstant.java | Java | package com.yc.music.config;
public class MusicConstant {
public static final String SP_NAME = "yc";
public static final String EXTRA_NOTIFICATION = "extra_notification";
public static final String LOCK_SCREEN = "lock_screen";
public static final String LOCK_SCREEN_ACTION = "cn.ycbjie.lock";
public static final String FILTER_SIZE = "filter_size";
public static final String FILTER_TIME = "filter_time";
public static final String MUSIC_ID = "music_id";
public static final String PLAY_MODE = "play_mode";
public static final String IS_SCREEN_LOCK = "is_screen_lock";
public static final String APP_OPEN_COUNT = "app_open_count";
public static final String PLAY_POSITION = "play_position";
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
MusicPlayer/src/main/java/com/yc/music/config/MusicPlayAction.java | Java | package com.yc.music.config;
public class MusicPlayAction {
/**--------------播放类型--------------------------------*/
/** 点击了上一首按钮*/
public static final String TYPE_PRE = "TYPE_PRE";
/** 点击了下一首按钮*/
public static final String TYPE_NEXT = "TYPE_NEXT";
/** 点击了播放暂停按钮*/
public static final String TYPE_START_PAUSE = "TYPE_START_PAUSE";
/**--------------播放状态--------------------------------*/
/** 默认状态*/
public static final int STATE_IDLE = 100;
/** 正在准备中*/
public static final int STATE_PREPARING = 101;
/** 正在播放中*/
public static final int STATE_PLAYING = 102;
/** 暂停状态*/
public static final int STATE_PAUSE = 103;
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
MusicPlayer/src/main/java/com/yc/music/config/PlayModeEnum.java | Java | package com.yc.music.config;
/**
* 播放模式
*/
public enum PlayModeEnum {
/**
* 顺序播放，默认的播放模式
*/
LOOP(0),
/**
* 随机播放
*/
SHUFFLE(1),
/**
* 单曲循环
*/
SINGLE(2);
private int value;
PlayModeEnum(int value) {
this.value = value;
}
public static PlayModeEnum valueOf(int value) {
switch (value) {
case 1:
return SHUFFLE;
case 2:
return SINGLE;
case 0:
default:
return LOOP;
}
}
public int value() {
return value;
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
MusicPlayer/src/main/java/com/yc/music/inter/EventCallback.java | Java | package com.yc.music.inter;
public interface EventCallback<T> {
void onEvent(T t);
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
MusicPlayer/src/main/java/com/yc/music/inter/OnPlayerEventListener.java | Java | package com.yc.music.inter;
import com.yc.music.model.AudioBean;
/**
* 播放进度监听器
*/
public interface OnPlayerEventListener {
/**
* 切换歌曲
* 主要是切换歌曲的时候需要及时刷新界面信息
*/
void onChange(AudioBean music);
/**
* 继续播放
* 主要是切换歌曲的时候需要及时刷新界面信息，比如播放暂停按钮
*/
void onPlayerStart();
/**
* 暂停播放
* 主要是切换歌曲的时候需要及时刷新界面信息，比如播放暂停按钮
*/
void onPlayerPause();
/**
* 更新进度
* 主要是播放音乐或者拖动进度条时，需要更新进度
*/
void onUpdateProgress(int progress);
/**
* 缓冲百分比
*/
void onBufferingUpdate(int percent);
/**
* 更新定时停止播放时间
*/
void onTimer(long remain);
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
MusicPlayer/src/main/java/com/yc/music/manager/AudioFocusManager.java | Java | package com.yc.music.manager;
import android.media.AudioManager;
import androidx.annotation.NonNull;
import com.yc.music.service.PlayService;
import static android.content.Context.AUDIO_SERVICE;
public class AudioFocusManager implements AudioManager.OnAudioFocusChangeListener {
private PlayService mPlayService;
private AudioManager mAudioManager;
/**
* 是否因聚焦丢失瞬变而暂停
*/
private boolean isPausedByFocusLossTransient;
private int mVolumeWhenFocusLossTransientCanDuck;
/**
* 初始化操作
* @param content playService对象
*/
public AudioFocusManager(@NonNull PlayService content) {
mPlayService = content;
mAudioManager = (AudioManager) content.getSystemService(AUDIO_SERVICE);
}
/**
* 请求音频焦点，开始播放时候调用
* @return 是否抢占焦点
*/
public boolean requestAudioFocus() {
return mAudioManager.requestAudioFocus(this, AudioManager.STREAM_MUSIC,
AudioManager.AUDIOFOCUS_GAIN) == AudioManager.AUDIOFOCUS_REQUEST_GRANTED;
}
/**
* 放弃音频焦点，销毁播放时候调用
*/
public void abandonAudioFocus() {
mAudioManager.abandonAudioFocus(this);
}
/**
* 当音频焦点发生变化的时候调用这个方法，在这里可以处理逻辑
* 欢迎访问我的GitHub：https://github.com/yangchong211
* 如果可以的话，请star吧
* @param focusChange 焦点改变
*/
@Override
public void onAudioFocusChange(int focusChange) {
int volume;
switch (focusChange) {
// 重新获得焦点
case AudioManager.AUDIOFOCUS_GAIN:
if (!willPlay() && isPausedByFocusLossTransient) {
// 通话结束，恢复播放
mPlayService.playPause();
}
//获取音量
volume = mAudioManager.getStreamVolume(AudioManager.STREAM_MUSIC);
if (mVolumeWhenFocusLossTransientCanDuck > 0 && volume ==
mVolumeWhenFocusLossTransientCanDuck / 2) {
// 恢复音量
mAudioManager.setStreamVolume(AudioManager.STREAM_MUSIC,
mVolumeWhenFocusLossTransientCanDuck, AudioManager.FLAG_REMOVE_SOUND_AND_VIBRATE);
}
isPausedByFocusLossTransient = false;
mVolumeWhenFocusLossTransientCanDuck = 0;
break;
// 永久丢失焦点，如被其他播放器抢占
case AudioManager.AUDIOFOCUS_LOSS:
// 失去audio focus很长一段时间，必须停止所有的audio播放，清理资源
if (willPlay()) {
forceStop();
}
break;
// 短暂丢失焦点，比如来了电话或者微信视频音频聊天等等
case AudioManager.AUDIOFOCUS_LOSS_TRANSIENT:
// 暂时失去audio focus，但是很快就会重新获得，在此状态应该暂停所有音频播放，但是不能清除资源
if (willPlay()) {
forceStop();
isPausedByFocusLossTransient = true;
}
break;
// 瞬间丢失焦点，如通知
case AudioManager.AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK:
// 暂时失去 audio focus，但是允许持续播放音频(以很小的声音)，不需要完全停止播放。
// 音量减小为一半
volume = mAudioManager.getStreamVolume(AudioManager.STREAM_MUSIC);
if (willPlay() && volume > 0) {
mVolumeWhenFocusLossTransientCanDuck = volume;
mAudioManager.setStreamVolume(AudioManager.STREAM_MUSIC,
mVolumeWhenFocusLossTransientCanDuck / 2,
AudioManager.FLAG_REMOVE_SOUND_AND_VIBRATE);
}
break;
default:
break;
}
}
/**
* 判断是否在播放或者准备播放
*/
private boolean willPlay() {
//当正在准备播放或者播放，则返回为true
return mPlayService.isPreparing() || mPlayService.isPlaying();
}
private void forceStop() {
//当准备播放时，则停止播放
if (mPlayService.isPreparing()) {
mPlayService.stop();
//当正在播放时，则暂停播放
} else if (mPlayService.isPlaying()) {
mPlayService.pause();
}
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
MusicPlayer/src/main/java/com/yc/music/manager/AudioSoundManager.java | Java | package com.yc.music.manager;
import android.annotation.SuppressLint;
import android.media.AudioManager;
import android.os.Build;
import androidx.annotation.NonNull;
import com.yc.music.service.PlayService;
import static android.content.Context.AUDIO_SERVICE;
public class AudioSoundManager {
private AudioManager mAudioManager;
/**
* 初始化操作
* @param content playService对象
*/
public AudioSoundManager(@NonNull PlayService content) {
mAudioManager = (AudioManager) content.getSystemService(AUDIO_SERVICE);
}
/**
* 切换到外放
*/
public void changeToSpeaker(){
mAudioManager.setMode(AudioManager.MODE_NORMAL);
mAudioManager.setSpeakerphoneOn(true);
}
/**
* 切换到耳机模式
*/
public void changeToHeadset(){
mAudioManager.setSpeakerphoneOn(false);
}
/**
* 切换到听筒
*/
@SuppressLint("ObsoleteSdkInt")
public void changeToReceiver(){
mAudioManager.setSpeakerphoneOn(false);
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB){
mAudioManager.setMode(AudioManager.MODE_IN_COMMUNICATION);
} else {
mAudioManager.setMode(AudioManager.MODE_IN_CALL);
}
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
MusicPlayer/src/main/java/com/yc/music/manager/MediaSessionManager.java | Java | package com.yc.music.manager;
import android.os.Build;
import android.support.v4.media.MediaMetadataCompat;
import android.support.v4.media.session.MediaSessionCompat;
import android.support.v4.media.session.PlaybackStateCompat;
import com.yc.music.model.AudioBean;
import com.yc.music.service.PlayService;
import com.yc.music.tool.BaseAppHelper;
public class MediaSessionManager {
private static final String TAG = "MediaSessionManager";
private static final long MEDIA_SESSION_ACTIONS = PlaybackStateCompat.ACTION_PLAY
| PlaybackStateCompat.ACTION_PAUSE
| PlaybackStateCompat.ACTION_PLAY_PAUSE
| PlaybackStateCompat.ACTION_SKIP_TO_NEXT
| PlaybackStateCompat.ACTION_SKIP_TO_PREVIOUS
| PlaybackStateCompat.ACTION_STOP
| PlaybackStateCompat.ACTION_SEEK_TO;
private PlayService mPlayService;
private MediaSessionCompat mMediaSession;
public MediaSessionManager(PlayService playService) {
mPlayService = playService;
setupMediaSession();
}
private void setupMediaSession() {
mMediaSession = new MediaSessionCompat(mPlayService, TAG);
mMediaSession.setFlags(MediaSessionCompat.FLAG_HANDLES_TRANSPORT_CONTROLS | MediaSessionCompat.FLAG_HANDLES_MEDIA_BUTTONS);
mMediaSession.setCallback(callback);
mMediaSession.setActive(true);
}
public void updatePlaybackState() {
int state = (mPlayService.isPlaying() ||
mPlayService.isPreparing()) ? PlaybackStateCompat.STATE_PLAYING :
PlaybackStateCompat.STATE_PAUSED;
mMediaSession.setPlaybackState(
new PlaybackStateCompat.Builder()
.setActions(MEDIA_SESSION_ACTIONS)
.setState(state, mPlayService.getCurrentPosition(), 1)
.build());
}
public void updateMetaData(AudioBean music) {
if (music == null) {
mMediaSession.setMetadata(null);
return;
}
MediaMetadataCompat.Builder metaData = new MediaMetadataCompat.Builder()
.putString(MediaMetadataCompat.METADATA_KEY_TITLE, music.getTitle())
.putString(MediaMetadataCompat.METADATA_KEY_ARTIST, music.getArtist())
.putString(MediaMetadataCompat.METADATA_KEY_ALBUM, music.getAlbum())
.putString(MediaMetadataCompat.METADATA_KEY_ALBUM_ARTIST, music.getArtist())
.putLong(MediaMetadataCompat.METADATA_KEY_DURATION, music.getDuration());
//.putBitmap(MediaMetadataCompat.METADATA_KEY_ALBUM_ART, CoverLoader.getInstance().loadThumbnail(music));
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
metaData.putLong(MediaMetadataCompat.METADATA_KEY_NUM_TRACKS,
BaseAppHelper.get().getMusicList().size());
}
mMediaSession.setMetadata(metaData.build());
}
public void release() {
mMediaSession.setCallback(null);
mMediaSession.setActive(false);
mMediaSession.release();
}
private MediaSessionCompat.Callback callback = new MediaSessionCompat.Callback() {
@Override
public void onPlay() {
mPlayService.playPause();
}
@Override
public void onPause() {
mPlayService.playPause();
}
@Override
public void onSkipToNext() {
mPlayService.next();
}
@Override
public void onSkipToPrevious() {
mPlayService.prev();
}
@Override
public void onStop() {
mPlayService.stop();
}
@Override
public void onSeekTo(long pos) {
mPlayService.seekTo((int) pos);
}
};
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
MusicPlayer/src/main/java/com/yc/music/model/AudioBean.java | Java | package com.yc.music.model;
import java.io.Serializable;
/**
* <pre>
* @author yangchong
* blog : www.pedaily.cn
* time : 2018/03/22
* desc : 音频单曲信息
* revise:
* </pre>
*/
public class AudioBean implements Serializable {
// 歌曲类型:本地/网络
private Type type;
// [本地歌曲]歌曲id
private String id;
// 音乐标题
private String title;
// 艺术家
private String artist;
// 专辑
private String album;
// [本地歌曲]专辑ID
private long albumId;
// [在线歌曲]专辑封面路径
private String coverPath;
// 持续时间
private long duration;
// 音乐路径
private String path;
// 文件名
private String fileName;
// 文件大小
private long fileSize;
public enum Type {
LOCAL,
ONLINE
}
public Type getType() {
return type;
}
public void setType(Type type) {
this.type = type;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getArtist() {
return artist;
}
public void setArtist(String artist) {
this.artist = artist;
}
public String getAlbum() {
return album;
}
public void setAlbum(String album) {
this.album = album;
}
public long getAlbumId() {
return albumId;
}
public void setAlbumId(long albumId) {
this.albumId = albumId;
}
public String getCoverPath() {
return coverPath;
}
public void setCoverPath(String coverPath) {
this.coverPath = coverPath;
}
public long getDuration() {
return duration;
}
public void setDuration(long duration) {
this.duration = duration;
}
public String getPath() {
return path;
}
public void setPath(String path) {
this.path = path;
}
public String getFileName() {
return fileName;
}
public void setFileName(String fileName) {
this.fileName = fileName;
}
public long getFileSize() {
return fileSize;
}
public void setFileSize(long fileSize) {
this.fileSize = fileSize;
}
/**
* 思考为什么要重写这两个方法
* 对比本地歌曲是否相同
*/
@Override
public boolean equals(Object obj) {
if (obj instanceof AudioBean) {
AudioBean bean = (AudioBean) obj;
return this.id.equals(bean.getId());
}
return super.equals(obj);
}
@Override
public int hashCode() {
return this.id.hashCode();
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
MusicPlayer/src/main/java/com/yc/music/receiver/AudioBroadcastReceiver.java | Java | package com.yc.music.receiver;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import com.yc.music.config.MusicConstant;
import com.yc.music.service.PlayService;
import com.yc.music.utils.MusicLogUtils;
/**
* 屏幕亮了，灭了，弹出锁屏页面逻辑
* 其实这个跟通知处理逻辑一样
*/
public class AudioBroadcastReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
final String action = intent.getAction();
if(action!=null && action.length()>0){
switch (action){
//锁屏时处理的逻辑
case MusicConstant.LOCK_SCREEN_ACTION:
PlayService.startCommand(context, MusicConstant.LOCK_SCREEN_ACTION);
MusicLogUtils.e("AudioBroadcastReceiver"+"---LOCK_SCREEN");
break;
//当屏幕灭了
case Intent.ACTION_SCREEN_OFF:
PlayService.startCommand(context,Intent.ACTION_SCREEN_OFF);
MusicLogUtils.e("AudioBroadcastReceiver"+"---当屏幕灭了");
break;
//当屏幕亮了
case Intent.ACTION_SCREEN_ON:
PlayService.startCommand(context,Intent.ACTION_SCREEN_ON);
MusicLogUtils.e("AudioBroadcastReceiver"+"---当屏幕亮了");
break;
default:
break;
}
}
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
MusicPlayer/src/main/java/com/yc/music/receiver/AudioEarPhoneReceiver.java | Java | package com.yc.music.receiver;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.media.AudioManager;
import com.yc.music.config.MusicPlayAction;
import com.yc.music.service.PlayService;
/**
* 来电/耳机拔出时暂停播放
* 其实这个跟通知处理逻辑一样
*/
public class AudioEarPhoneReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
final String action = intent.getAction();
if(action!=null && action.length()>0){
switch (action){
//来电/耳机拔出时暂停播放
case AudioManager.ACTION_AUDIO_BECOMING_NOISY:
PlayService.startCommand(context, MusicPlayAction.TYPE_START_PAUSE);
break;
default:
break;
}
}
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
MusicPlayer/src/main/java/com/yc/music/receiver/EarphoneControlReceiver.java | Java | package com.yc.music.receiver;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.support.v4.media.session.MediaSessionCompat;
import android.view.KeyEvent;
import com.yc.music.config.MusicPlayAction;
import com.yc.music.service.PlayService;
/**
* 耳机线控，仅在5.0以下有效，5.0以上被{@link MediaSessionCompat}接管。
*/
public class EarphoneControlReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
KeyEvent event = intent.getParcelableExtra(Intent.EXTRA_KEY_EVENT);
if (event == null || event.getAction() != KeyEvent.ACTION_UP) {
return;
}
switch (event.getKeyCode()) {
case KeyEvent.KEYCODE_MEDIA_PLAY:
case KeyEvent.KEYCODE_MEDIA_PAUSE:
case KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE:
case KeyEvent.KEYCODE_HEADSETHOOK:
PlayService.startCommand(context, MusicPlayAction.TYPE_START_PAUSE);
break;
case KeyEvent.KEYCODE_MEDIA_NEXT:
PlayService.startCommand(context, MusicPlayAction.TYPE_NEXT);
break;
case KeyEvent.KEYCODE_MEDIA_PREVIOUS:
PlayService.startCommand(context, MusicPlayAction.TYPE_PRE);
break;
default:
break;
}
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
MusicPlayer/src/main/java/com/yc/music/receiver/NotificationStatusBarReceiver.java | Java | package com.yc.music.receiver;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.text.TextUtils;
import com.yc.music.config.MusicPlayAction;
import com.yc.music.service.PlayService;
import com.yc.music.tool.BaseAppHelper;
import com.yc.music.utils.MusicLogUtils;
public class NotificationStatusBarReceiver extends BroadcastReceiver {
public static final String ACTION_STATUS_BAR = "YC_ACTION_STATUS_BAR";
public static final String EXTRA = "extra";
@Override
public void onReceive(Context context, Intent intent) {
if (intent == null || TextUtils.isEmpty(intent.getAction())) {
return;
}
String extra = intent.getStringExtra(EXTRA);
if (TextUtils.equals(extra, MusicPlayAction.TYPE_NEXT)) {
PlayService.startCommand(context, MusicPlayAction.TYPE_NEXT);
MusicLogUtils.e("NotifiyStatusBarReceiver"+"下一首");
} else if (TextUtils.equals(extra, MusicPlayAction.TYPE_START_PAUSE)) {
if(BaseAppHelper.get().getPlayService()!=null){
boolean playing = BaseAppHelper.get().getPlayService().isPlaying();
if(playing){
MusicLogUtils.e("NotifiyStatusBarReceiver"+"暂停");
}else {
MusicLogUtils.e("NotifiyStatusBarReceiver"+"播放");
}
PlayService.startCommand(context, MusicPlayAction.TYPE_START_PAUSE);
}
}else if(TextUtils.equals(extra, MusicPlayAction.TYPE_PRE)){
PlayService.startCommand(context, MusicPlayAction.TYPE_PRE);
MusicLogUtils.e("NotifiyStatusBarReceiver"+"上一首");
}
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
MusicPlayer/src/main/java/com/yc/music/service/PlayService.java | Java | package com.yc.music.service;
import android.annotation.SuppressLint;
import android.app.Service;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.media.AudioManager;
import android.media.MediaPlayer;
import android.os.Binder;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import com.yc.music.config.MusicPlayAction;
import com.yc.music.config.MusicConstant;
import com.yc.music.config.PlayModeEnum;
import com.yc.music.inter.EventCallback;
import com.yc.music.inter.OnPlayerEventListener;
import com.yc.music.manager.AudioFocusManager;
import com.yc.music.manager.MediaSessionManager;
import com.yc.music.model.AudioBean;
import com.yc.music.receiver.AudioBroadcastReceiver;
import com.yc.music.receiver.AudioEarPhoneReceiver;
import com.yc.music.tool.BaseAppHelper;
import com.yc.music.utils.MusicLogUtils;
import com.yc.music.utils.NotificationHelper;
import com.yc.music.tool.QuitTimerHelper;
import com.yc.music.utils.MusicSpUtils;
import java.io.IOException;
import java.util.List;
import java.util.Random;
/**
* Service就是用来在后台完成一些不需要和用户交互的动作
*/
public class PlayService extends Service {
/**
* 正在播放的歌曲的序号
*/
private int mPlayingPosition = -1;
/**
* 正在播放的歌曲[本地|网络]
*/
private AudioBean mPlayingMusic;
/**
* 音频list集合
*/
private List<AudioBean> audioMusics;
/**
* 播放状态
*/
private int mPlayState = MusicPlayAction.STATE_IDLE;
/**
* 播放器
*/
private MediaPlayer mPlayer;
/**
* 播放进度监听器
*/
private OnPlayerEventListener mListener;
/**
* 更新播放进度的显示，时间的显示
*/
private static final int UPDATE_PLAY_PROGRESS_SHOW = 0;
/**
* 允许与媒体控制器、音量键、媒体按钮和传输控件交互
*/
private MediaSessionManager mMediaSessionManager;
/**
* 捕获/丢弃音乐焦点处理
*/
private AudioFocusManager mAudioFocusManager;
/**
* 是否锁屏了，默认是false
*/
private boolean mIsLocked = false;
/**
* 来电/耳机拔出时暂停播放
* 在播放时调用，在暂停时注销
*/
private final AudioEarPhoneReceiver mNoisyReceiver = new AudioEarPhoneReceiver();
private final IntentFilter mFilter = new IntentFilter(AudioManager.ACTION_AUDIO_BECOMING_NOISY);
/**
* 其他广播
* 比如：屏幕灭了后再次亮了，会显示锁屏页面
* 这个在onCreate中创建，在onDestroy中销毁
*/
private final AudioBroadcastReceiver mAudioReceiver = new AudioBroadcastReceiver();
/**
* 广播接受者标识，避免多次注册广播
*/
private boolean mReceiverTag = false;
@SuppressLint("HandlerLeak")
private Handler handler = new Handler(){
@Override
public void handleMessage(@NonNull Message msg) {
super.handleMessage(msg);
switch (msg.what){
case UPDATE_PLAY_PROGRESS_SHOW:
updatePlayProgressShow();
break;
default:
break;
}
}
};
/**
* 绑定服务时才会调用
* 必须要实现的方法
* @param intent intent
* @return IBinder对象
*/
@Nullable
@Override
public IBinder onBind(Intent intent) {
return new PlayBinder();
}
/**
* 比如，广播，耳机声控，通知栏广播，来电或者拔下耳机广播开启服务
* @param context 上下文
* @param type 类型
*/
public static void startCommand(Context context, String type) {
Intent intent = new Intent(context, PlayService.class);
intent.setAction(type);
context.startService(intent);
}
public class PlayBinder extends Binder {
public PlayService getService() {
return PlayService.this;
}
}
/**
* 首次创建服务时，系统将调用此方法来执行一次性设置程序（在调用 onStartCommand() 或 onBind() 之前）。
* 如果服务已在运行，则不会调用此方法。该方法只被调用一次
*/
@Override
public void onCreate() {
super.onCreate();
NotificationHelper.get().init(this);
createMediaPlayer();
initMediaSessionManager();
initAudioFocusManager();
initEarPhoneBroadcastReceiver();
initAudioBroadcastReceiver();
initQuitTimer();
}
/**
* 服务在销毁时调用该方法
*/
@Override
public void onDestroy() {
super.onDestroy();
//销毁handler
if(handler!=null){
handler.removeCallbacksAndMessages(null);
handler = null;
}
//销毁MediaPlayer
mPlayer.reset();
mPlayer.release();
mPlayer = null;
//放弃音频焦点
mAudioFocusManager.abandonAudioFocus();
mMediaSessionManager.release();
//注销广播接收者
unregisterReceiver(mAudioReceiver);
//结束notification通知
NotificationHelper.get().cancelAll();
//设置service为null
BaseAppHelper.get().setPlayService(null);
}
/**
* 每次通过startService()方法启动Service时都会被回调。
* @param intent intent
* @param flags flags
* @param startId startId
* @return
* onStartCommand方法返回值作用：
* START_STICKY：粘性，service进程被异常杀掉，系统重新创建进程与服务，会重新执行onCreate()、onStartCommand(Intent)
* START_STICKY_COMPATIBILITY：START_STICKY的兼容版本，但不保证服务被kill后一定能重启。
* START_NOT_STICKY：非粘性，Service进程被异常杀掉，系统不会自动重启该Service。
* START_REDELIVER_INTENT：重传Intent。使用这个返回值时，如果在执行完onStartCommand后，服务被异常kill掉，系统会自动重启该服务，并将Intent的值传入。
*/
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
if (intent != null && intent.getAction() != null) {
switch (intent.getAction()) {
//上一首
case MusicPlayAction.TYPE_PRE:
prev();
break;
//下一首
case MusicPlayAction.TYPE_NEXT:
next();
break;
//播放或暂停
case MusicPlayAction.TYPE_START_PAUSE:
playPause();
break;
//添加锁屏界面
case MusicConstant.LOCK_SCREEN_ACTION:
MusicLogUtils.e("PlayService"+"---LOCK_SCREEN"+mIsLocked);
break;
//当屏幕灭了，添加锁屏页面
case Intent.ACTION_SCREEN_OFF:
startLockAudioActivity();
MusicLogUtils.e("PlayService"+"---当屏幕灭了");
break;
case Intent.ACTION_SCREEN_ON:
MusicLogUtils.e("PlayService"+"---当屏幕亮了");
break;
default:
break;
}
}
return START_NOT_STICKY;
}
/**
* 创建MediaPlayer对象
*/
private void createMediaPlayer() {
if(mPlayer==null){
//MediaCodec codec = new MediaCodec();
mPlayer = new MediaPlayer();
}
}
/**
* 允许与媒体控制器、音量键、媒体按钮和传输控件交互。
* 播放器除了播放了音乐之外什么都没做，就可以分别在任务管理、锁屏、负一屏控制我的播放器
*/
private void initMediaSessionManager() {
mMediaSessionManager = new MediaSessionManager(this);
}
/**
* 捕获/丢弃音乐焦点处理
*/
private void initAudioFocusManager() {
mAudioFocusManager = new AudioFocusManager(this);
}
/**
* 初始化耳机插入和拔出监听
*/
private void initEarPhoneBroadcastReceiver() {
//这块直接在清单文件注册
}
/**
* 初始化IntentFilter添加action意图
* 主要是监听屏幕亮了与灭了
*/
private void initAudioBroadcastReceiver() {
final IntentFilter filter = new IntentFilter();
//来电/耳机
filter.addAction(AudioManager.ACTION_AUDIO_BECOMING_NOISY);
//锁屏
filter.addAction(MusicConstant.LOCK_SCREEN_ACTION);
//当屏幕灭了
filter.addAction(Intent.ACTION_SCREEN_OFF);
//当屏幕亮了
filter.addAction(Intent.ACTION_SCREEN_ON);
registerReceiver(mAudioReceiver, filter);
}
/**
* 初始化计时器
*/
private void initQuitTimer() {
QuitTimerHelper.getInstance().init(this, handler, new EventCallback<Long>() {
@Override
public void onEvent(Long aLong) {
if (mListener != null) {
mListener.onTimer(aLong);
}
}
});
}
/**---------------------播放或暂停，上一首，下一首-----------------------------------------*/
/**
* 播放或暂停
* 逻辑：
* 1.如果正在准备，点击则是停止播放
* 2.如果是正在播放，点击则是暂停
* 3.如果是暂停状态，点击则是开始播放
* 4.其他情况是直接播放
*/
public void playPause() {
if (isPreparing()) {
stop();
} else if (isPlaying()) {
pause();
} else if (isPausing()) {
start();
} else {
play(getPlayingPosition());
}
}
/**
* 上一首
* 记住有播放类型，单曲循环，顺序循环，随机播放
* 逻辑：如果不是第一首，则还有上一首；如果没有上一首，则切换到最后一首
*/
public void prev() {
//建议都添加这个判断
if (audioMusics.isEmpty()) {
return;
}
int playMode = MusicSpUtils.getInstance(MusicConstant.SP_NAME).getInt(MusicConstant.PLAY_MODE, 0);
int size = audioMusics.size();
PlayModeEnum mode = PlayModeEnum.valueOf(playMode);
switch (mode) {
//随机
case SHUFFLE:
mPlayingPosition = new Random().nextInt(size);
play(mPlayingPosition);
break;
//单曲
case SINGLE:
play(mPlayingPosition);
break;
//顺序播放并且循环
case LOOP:
default:
if(mPlayingPosition != 0){
// 如果不是第一首，则还有上一首
mPlayingPosition--;
} else {
// 如果没有上一首，则切换到最后一首
mPlayingPosition = size;
}
play(mPlayingPosition);
break;
}
}
/**
* 下一首
* 记住有播放类型，单曲循环，顺序循环，随机播放
* 逻辑：如果不是最后一首，则还有下一首；如果是最后一首，则切换回第一首
*/
public void next() {
//建议都添加这个判断
if (audioMusics.isEmpty()) {
return;
}
int playMode = MusicSpUtils.getInstance(MusicConstant.SP_NAME).getInt(MusicConstant.PLAY_MODE, 0);
int size = audioMusics.size();
PlayModeEnum mode = PlayModeEnum.valueOf(playMode);
switch (mode) {
//随机
case SHUFFLE:
mPlayingPosition = new Random().nextInt(size);
play(mPlayingPosition);
break;
//单曲
case SINGLE:
play(mPlayingPosition);
break;
//顺序播放并且循环
case LOOP:
default:
if (mPlayingPosition != size - 1) {
// 如果不是最后一首，则还有下一首
mPlayingPosition++;
} else {
// 如果是最后一首，则切换回第一首
mPlayingPosition = 0;
}
MusicLogUtils.e("PlayService"+"----mPlayingPosition----"+ mPlayingPosition);
play(mPlayingPosition);
break;
}
}
/**---------------------开始播放，暂停播放，停止播放等-----------------------------------------*/
/**
* 开始播放
*/
public void start() {
if (!isPreparing() && !isPausing()) {
return;
}
if(mPlayingMusic==null){
return;
}
if(mAudioFocusManager.requestAudioFocus()){
if(mPlayer!=null){
mPlayer.start();
mPlayState = MusicPlayAction.STATE_PLAYING;
//开始发送消息，执行进度条进度更新
handler.sendEmptyMessage(UPDATE_PLAY_PROGRESS_SHOW);
if (mListener != null) {
mListener.onPlayerStart();
}
//当点击播放按钮时(播放详情页面或者底部控制栏)，同步通知栏中播放按钮状态
NotificationHelper.get().showPlay(mPlayingMusic);
//注册监听来电/耳机拔出时暂停播放广播
if(!mReceiverTag){
mReceiverTag = true;
registerReceiver(mNoisyReceiver, mFilter);
}
mMediaSessionManager.updatePlaybackState();
}
}
}
/**
* 暂停
*/
public void pause() {
if(mPlayer!=null){
//暂停
mPlayer.pause();
//切换状态
mPlayState = MusicPlayAction.STATE_PAUSE;
//移除，注意一定要移除，否则一直走更新方法
handler.removeMessages(UPDATE_PLAY_PROGRESS_SHOW);
//监听
if (mListener != null) {
mListener.onPlayerPause();
}
//当点击暂停按钮时(播放详情页面或者底部控制栏)，同步通知栏中暂停按钮状态
NotificationHelper.get().showPause(mPlayingMusic);
//注销监听来电/耳机拔出时暂停播放广播
//判断广播是否注册
if (mReceiverTag) {
//Tag值 赋值为false 表示该广播已被注销
mReceiverTag = false;
unregisterReceiver(mNoisyReceiver);
}
mMediaSessionManager.updatePlaybackState();
}
}
/**
* 停止播放
*/
public void stop() {
if (isDefault()) {
return;
}
pause();
if(mPlayer!=null){
mPlayer.reset();
mPlayState = MusicPlayAction.STATE_IDLE;
}
}
/**
* 播放索引为position的音乐
* @param position 索引
*/
public void play(int position) {
audioMusics = BaseAppHelper.get().getMusicList();
if (audioMusics.isEmpty()) {
return;
}
if (position < 0) {
position = audioMusics.size() - 1;
} else if (position >= audioMusics.size()) {
//如果是最后一首音乐，则播放时直接播放第一首音乐
position = 0;
}
mPlayingPosition = position;
AudioBean music = audioMusics.get(mPlayingPosition);
String id = music.getId();
MusicLogUtils.e("PlayService"+"----id----"+ id);
//保存当前播放的musicId，下次进来可以记录状态
long musicId = Long.parseLong(id);
MusicSpUtils.getInstance(MusicConstant.SP_NAME).put(MusicConstant.MUSIC_ID,musicId);
play(music);
}
/**
* 拖动seekBar时，调节进度
* @param progress 进度
*/
public void seekTo(int progress) {
//只有当播放或者暂停的时候才允许拖动bar
if (isPlaying() || isPausing()) {
mPlayer.seekTo(progress);
if(mListener!=null){
mListener.onUpdateProgress(progress);
}
mMediaSessionManager.updatePlaybackState();
}
}
/**
* 播放，这种是直接传音频实体类
* @param music music
*/
public void play(AudioBean music) {
mPlayingMusic = music;
createMediaPlayer();
try {
mPlayer.reset();
//把音频路径传给播放器
mPlayer.setDataSource(mPlayingMusic.getPath());
//准备
mPlayer.prepareAsync();
//设置状态为准备中
mPlayState = MusicPlayAction.STATE_PREPARING;
//监听
mPlayer.setOnPreparedListener(mOnPreparedListener);
mPlayer.setOnBufferingUpdateListener(mOnBufferingUpdateListener);
mPlayer.setOnCompletionListener(mOnCompletionListener);
mPlayer.setOnSeekCompleteListener(mOnSeekCompleteListener);
mPlayer.setOnErrorListener(mOnErrorListener);
mPlayer.setOnInfoListener(mOnInfoListener);
//当播放的时候，需要刷新界面信息
if (mListener != null) {
mListener.onChange(mPlayingMusic);
}
//更新通知栏
NotificationHelper.get().showPlay(mPlayingMusic);
//更新
mMediaSessionManager.updateMetaData(mPlayingMusic);
mMediaSessionManager.updatePlaybackState();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 更新播放进度的显示，时间的显示
*/
private void updatePlayProgressShow() {
if (isPlaying() && mListener != null) {
int currentPosition = mPlayer.getCurrentPosition();
mListener.onUpdateProgress(currentPosition);
}
MusicLogUtils.e("updatePlayProgressShow");
// 每30毫秒更新一下显示的内容，注意这里时间不要太短，因为这个是一个循环
// 经过测试，60毫秒更新一次有点卡，30毫秒最为顺畅
handler.sendEmptyMessageDelayed(UPDATE_PLAY_PROGRESS_SHOW, 300);
}
/** 音频准备好的监听器 */
private MediaPlayer.OnPreparedListener mOnPreparedListener = new MediaPlayer.OnPreparedListener() {
/** 当音频准备好可以播放了，则这个方法会被调用 */
@Override
public void onPrepared(MediaPlayer mp) {
if (isPreparing()) {
start();
}
}
};
/** 当音频播放结束的时候的监听器 */
private MediaPlayer.OnCompletionListener mOnCompletionListener = new MediaPlayer.OnCompletionListener() {
/** 当音频播放结果的时候这个方法会被调用 */
@Override
public void onCompletion(MediaPlayer mp) {
next();
}
};
/** 当音频缓冲的监听器 */
private MediaPlayer.OnBufferingUpdateListener mOnBufferingUpdateListener = new MediaPlayer.OnBufferingUpdateListener() {
@Override
public void onBufferingUpdate(MediaPlayer mp, int percent) {
if (mListener != null) {
// 缓冲百分比
mListener.onBufferingUpdate(percent);
}
}
};
/** 跳转完成时的监听 */
private MediaPlayer.OnSeekCompleteListener mOnSeekCompleteListener = new MediaPlayer.OnSeekCompleteListener() {
@Override
public void onSeekComplete(MediaPlayer mp) {
}
};
/**
* 播放错误的监听
*/
private MediaPlayer.OnErrorListener mOnErrorListener = new MediaPlayer.OnErrorListener() {
@Override
public boolean onError(MediaPlayer mp, int what, int extra) {
return false;
}
};
/**
* 设置音频信息监听器
*/
private MediaPlayer.OnInfoListener mOnInfoListener = new MediaPlayer.OnInfoListener() {
@Override
public boolean onInfo(MediaPlayer mp, int what, int extra) {
return false;
}
};
/**
* 是否正在播放
* @return true表示正在播放
*/
public boolean isPlaying() {
return mPlayState == MusicPlayAction.STATE_PLAYING;
}
/**
* 是否暂停
* @return true表示暂停
*/
public boolean isPausing() {
return mPlayState == MusicPlayAction.STATE_PAUSE;
}
/**
* 是否正在准备中
* @return true表示正在准备中
*/
public boolean isPreparing() {
return mPlayState == MusicPlayAction.STATE_PREPARING;
}
/**
* 是否正在准备中
* @return true表示正在准备中
*/
public boolean isDefault() {
return mPlayState == MusicPlayAction.STATE_IDLE;
}
/**------------------------------------------------------------------------------------------*/
/**
* 退出时候调用
*/
public void quit() {
// 先停止播放
stop();
// 移除定时器
QuitTimerHelper.getInstance().stop();
// 当另一个组件（如 Activity）通过调用 startService() 请求启动服务时，系统将调用onStartCommand。
// 一旦执行此方法，服务即会启动并可在后台无限期运行。 如果自己实现此方法，则需要在服务工作完成后，
// 通过调用 stopSelf() 或 stopService() 来停止服务。
stopSelf();
}
/**
* 获取正在播放的本地歌曲的序号
*/
public int getPlayingPosition() {
return mPlayingPosition;
}
/**
* 获取正在播放的歌曲[本地|网络]
*/
public AudioBean getPlayingMusic() {
return mPlayingMusic;
}
/**
* 获取播放的进度
* @return long类型值
*/
public long getCurrentPosition() {
if (isPlaying() || isPausing()) {
return mPlayer.getCurrentPosition();
} else {
return 0;
}
}
/**
* 判斷是否有上一首音頻
* @return true表示有
*/
public boolean isHavePre() {
if(audioMusics !=null && audioMusics.size()>0){
if(mPlayingPosition != 0){
// 如果不是第一首，则还有上一首
return true;
} else {
return false;
}
}else {
return false;
}
}
/**
* 判斷是否有下一首音頻
* @return true表示有
*/
public boolean isHaveNext() {
if(audioMusics !=null && audioMusics.size()>0){
if (mPlayingPosition != audioMusics.size() - 1) {
// 如果不是最后一首，则还有下一首
return true;
} else {
// 如果是最后一首，则切换回第一首
return false;
}
}else {
return false;
}
}
//
// /**
// * 扫描音乐
// */
// @SuppressLint("StaticFieldLeak")
// public void updateMusicList(final EventCallback<Void> callback) {
// new AsyncTask<Void, Void, List<AudioBean>>() {
// @Override
// protected List<AudioBean> doInBackground(Void... params) {
// return FileMusicScanManager.getInstance().scanMusic(PlayService.this);
// }
//
// @Override
// protected void onPostExecute(List<AudioBean> musicList) {
// //首先先清空
// //然后添加所有扫描到的音乐
// BaseAppHelper.get().setMusicList(musicList);
//
// //如果获取音乐数据集合不为空
// if (!BaseAppHelper.get().getMusicList().isEmpty()) {
// //音频的集合
// audioMusics = BaseAppHelper.get().getMusicList();
// //刷新正在播放的本地歌曲的序号
// updatePlayingPosition();
// //获取正在播放的音乐
// if(mPlayingPosition>=0){
// mPlayingMusic = BaseAppHelper.get().getMusicList().get(mPlayingPosition);
// }
// }
// if (callback != null) {
// callback.onEvent(null);
// }
// }
// }.execute();
// }
/**
* 删除或下载歌曲后刷新正在播放的本地歌曲的序号
*/
public void updatePlayingPosition() {
int position = 0;
long id = MusicSpUtils.getInstance(MusicConstant.SP_NAME).getLong(MusicConstant.MUSIC_ID,-1);
if(audioMusics.isEmpty()){
return;
}
for (int i = 0; i < audioMusics.size(); i++) {
String musicId = audioMusics.get(i).getId();
MusicLogUtils.e("PlayService"+"----musicId----"+ musicId);
if (Long.parseLong(musicId) == id) {
position = i;
break;
}
}
mPlayingPosition = position;
long musicId = Long.parseLong(audioMusics.get(mPlayingPosition).getId());
MusicSpUtils.getInstance(MusicConstant.SP_NAME).put(MusicConstant.MUSIC_ID,musicId);
}
/**
* 获取播放进度监听器对象
* @return OnPlayerEventListener对象
*/
public OnPlayerEventListener getOnPlayEventListener() {
return mListener;
}
/**
* 设置播放进度监听器
* @param listener listener
*/
public void setOnPlayEventListener(OnPlayerEventListener listener) {
mListener = listener;
}
/**-------------------------------------添加锁屏界面----------------------------------------*/
/**
* 打开锁屏页面，这块伤透了脑筋
* 不管是播放状态是哪一个，只要屏幕灭了到亮了，就展现这个锁屏页面
* 有些APP限制了状态，比如只有播放时才走这个逻辑
*/
private void startLockAudioActivity() {
if(!mIsLocked && isPlaying()){
// Intent lockScreen = new Intent(this, LockAudioActivity.class);
// lockScreen.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
// startActivity(lockScreen);
// BaseConfig.INSTANCE.setLocked(true);
}
}
/**-------------------------------------播放list----------------------------------------*/
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
MusicPlayer/src/main/java/com/yc/music/tool/BaseAppHelper.java | Java | package com.yc.music.tool;
import android.annotation.SuppressLint;
import com.yc.music.model.AudioBean;
import com.yc.music.service.PlayService;
import java.util.ArrayList;
import java.util.List;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2017/03/22
* desc : BaseAppHelper
* revise:
* </pre>
*/
public class BaseAppHelper {
/**
* 播放音乐service
*/
private PlayService mPlayService;
/**
* 本地歌曲列表
*/
private final List<AudioBean> mMusicList = new ArrayList<>();
private BaseAppHelper() {
//这里可以做一些初始化的逻辑
}
private static class SingletonHolder {
@SuppressLint("StaticFieldLeak")
private final static BaseAppHelper INSTANCE = new BaseAppHelper();
}
public static BaseAppHelper get() {
return SingletonHolder.INSTANCE;
}
/**
* 获取PlayService对象
* @return 返回PlayService对象
*/
public PlayService getPlayService() {
return mPlayService;
}
/**
* 设置PlayService服务
*/
public void setPlayService(PlayService service) {
mPlayService = service;
}
/**
* 获取扫描到的音乐数据集合
* @return 返回list集合
*/
public List<AudioBean> getMusicList() {
return mMusicList;
}
/**
* 设置音频结合
* @param list 音频集合
*/
public void setMusicList(List<AudioBean> list) {
mMusicList.clear();
mMusicList.addAll(list);
}
/**
* 获取到播放音乐的服务
* @return PlayService对象
*/
public PlayService getMusicService () {
PlayService playService = BaseAppHelper.get().getPlayService();
if (playService == null) {
//待解决：当长期处于后台，如何保活？避免service被杀死……
throw new NullPointerException("play service is null");
}
return playService;
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
MusicPlayer/src/main/java/com/yc/music/tool/QuitTimerHelper.java | Java | package com.yc.music.tool;
import android.os.Handler;
import android.text.format.DateUtils;
import androidx.annotation.NonNull;
import com.yc.music.inter.EventCallback;
import com.yc.music.service.PlayService;
/**
* 定时器
*/
public class QuitTimerHelper {
private PlayService mPlayService;
private EventCallback<Long> mTimerCallback;
private Handler mHandler;
private long mTimerRemain;
public static QuitTimerHelper getInstance() {
return SingletonHolder.QUIT_TIMER_INSTANCE;
}
private static class SingletonHolder {
private static final QuitTimerHelper QUIT_TIMER_INSTANCE = new QuitTimerHelper();
}
private QuitTimerHelper() {}
/**
* 初始化 用@NonNull注解，表示不能为null
* @param playService playService
* @param handler handler
* @param timerCallback timerCallback
*/
public void init(@NonNull PlayService playService, @NonNull Handler handler,
@NonNull EventCallback<Long> timerCallback) {
mPlayService = playService;
mHandler = handler;
mTimerCallback = timerCallback;
}
public void start(long milli) {
if(mHandler==null){
//ToastUtils.showShort("请先进行初始化");
return;
}
stop();
if (milli > 0) {
mTimerRemain = milli + DateUtils.SECOND_IN_MILLIS;
mHandler.post(mQuitRunnable);
} else {
mTimerRemain = 0;
mTimerCallback.onEvent(mTimerRemain);
}
}
public void stop() {
mHandler.removeCallbacks(mQuitRunnable);
}
private Runnable mQuitRunnable = new Runnable() {
@Override
public void run() {
mTimerRemain -= DateUtils.SECOND_IN_MILLIS;
if (mTimerRemain > 0) {
mTimerCallback.onEvent(mTimerRemain);
mHandler.postDelayed(this, DateUtils.SECOND_IN_MILLIS);
} else {
mPlayService.quit();
}
}
};
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
MusicPlayer/src/main/java/com/yc/music/utils/MusicLogUtils.java | Java | /*
Copyright 2017 yangchong211（github.com/yangchong211）
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package com.yc.music.utils;
import android.util.Log;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2017/10/21
* desc : log工具
* revise:
* </pre>
*/
public final class MusicLogUtils {
private static final String TAG = "MusicPlayer";
private static boolean isLog = false;
/**
* 设置是否开启日志
* @param isLog 是否开启日志
*/
public static void setIsLog(boolean isLog) {
MusicLogUtils.isLog = isLog;
}
public static boolean isIsLog() {
return isLog;
}
public static void d(String message) {
if(isLog){
Log.d(TAG, message);
}
}
public static void i(String message) {
if(isLog){
Log.i(TAG, message);
}
}
public static void e(String msg) {
if (isLog) {
Log.e(TAG, msg);
}
}
public static void e(String message, Throwable throwable) {
if(isLog){
Log.e(TAG, message, throwable);
}
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
MusicPlayer/src/main/java/com/yc/music/utils/MusicSpUtils.java | Java | package com.yc.music.utils;
import android.annotation.SuppressLint;
import android.app.Application;
import android.content.Context;
import android.content.SharedPreferences;
import androidx.annotation.NonNull;
import androidx.collection.SimpleArrayMap;
import java.util.Collections;
import java.util.Map;
import java.util.Set;
@SuppressLint("ApplySharedPref")
public final class MusicSpUtils {
private static SimpleArrayMap<String, MusicSpUtils> SP_UTILS_MAP = new SimpleArrayMap<>();
private SharedPreferences sp;
private static Context context;
public static void init(Application application){
context = application;
}
/**
* 获取 SP 实例
*
* @return {@link MusicSpUtils}
*/
public static MusicSpUtils getInstance() {
return getInstance("");
}
/**
* 获取 SP 实例
*
* @param spName sp 名
* @return {@link MusicSpUtils}
*/
public static MusicSpUtils getInstance(String spName) {
if (isSpace(spName)) spName = "spUtils";
MusicSpUtils spUtils = SP_UTILS_MAP.get(spName);
if (spUtils == null) {
spUtils = new MusicSpUtils(spName);
SP_UTILS_MAP.put(spName, spUtils);
}
return spUtils;
}
private MusicSpUtils(final String spName) {
sp = context.getSharedPreferences(spName, Context.MODE_PRIVATE);
}
/**
* SP 中写入 String
*
* @param key 键
* @param value 值
*/
public void put(@NonNull final String key, @NonNull final String value) {
put(key, value, false);
}
/**
* SP 中写入 String
*
* @param key 键
* @param value 值
* @param isCommit {@code true}: {@link SharedPreferences.Editor#commit()}<br>
* {@code false}: {@link SharedPreferences.Editor#apply()}
*/
public void put(@NonNull final String key,
@NonNull final String value,
final boolean isCommit) {
if (isCommit) {
sp.edit().putString(key, value).commit();
} else {
sp.edit().putString(key, value).apply();
}
}
/**
* SP 中读取 String
*
* @param key 键
* @return 存在返回对应值，不存在返回默认值{@code ""}
*/
public String getString(@NonNull final String key) {
return getString(key, "");
}
/**
* SP 中读取 String
*
* @param key 键
* @param defaultValue 默认值
* @return 存在返回对应值，不存在返回默认值{@code defaultValue}
*/
public String getString(@NonNull final String key, @NonNull final String defaultValue) {
return sp.getString(key, defaultValue);
}
/**
* SP 中写入 int
*
* @param key 键
* @param value 值
*/
public void put(@NonNull final String key, final int value) {
put(key, value, false);
}
/**
* SP 中写入 int
*
* @param key 键
* @param value 值
* @param isCommit {@code true}: {@link SharedPreferences.Editor#commit()}<br>
* {@code false}: {@link SharedPreferences.Editor#apply()}
*/
public void put(@NonNull final String key, final int value, final boolean isCommit) {
if (isCommit) {
sp.edit().putInt(key, value).commit();
} else {
sp.edit().putInt(key, value).apply();
}
}
/**
* SP 中读取 int
*
* @param key 键
* @return 存在返回对应值，不存在返回默认值-1
*/
public int getInt(@NonNull final String key) {
return getInt(key, -1);
}
/**
* SP 中读取 int
*
* @param key 键
* @param defaultValue 默认值
* @return 存在返回对应值，不存在返回默认值{@code defaultValue}
*/
public int getInt(@NonNull final String key, final int defaultValue) {
return sp.getInt(key, defaultValue);
}
/**
* SP 中写入 long
*
* @param key 键
* @param value 值
*/
public void put(@NonNull final String key, final long value) {
put(key, value, false);
}
/**
* SP 中写入 long
*
* @param key 键
* @param value 值
* @param isCommit {@code true}: {@link SharedPreferences.Editor#commit()}<br>
* {@code false}: {@link SharedPreferences.Editor#apply()}
*/
public void put(@NonNull final String key, final long value, final boolean isCommit) {
if (isCommit) {
sp.edit().putLong(key, value).commit();
} else {
sp.edit().putLong(key, value).apply();
}
}
/**
* SP 中读取 long
*
* @param key 键
* @return 存在返回对应值，不存在返回默认值-1
*/
public long getLong(@NonNull final String key) {
return getLong(key, -1L);
}
/**
* SP 中读取 long
*
* @param key 键
* @param defaultValue 默认值
* @return 存在返回对应值，不存在返回默认值{@code defaultValue}
*/
public long getLong(@NonNull final String key, final long defaultValue) {
return sp.getLong(key, defaultValue);
}
/**
* SP 中写入 float
*
* @param key 键
* @param value 值
*/
public void put(@NonNull final String key, final float value) {
put(key, value, false);
}
/**
* SP 中写入 float
*
* @param key 键
* @param value 值
* @param isCommit {@code true}: {@link SharedPreferences.Editor#commit()}<br>
* {@code false}: {@link SharedPreferences.Editor#apply()}
*/
public void put(@NonNull final String key, final float value, final boolean isCommit) {
if (isCommit) {
sp.edit().putFloat(key, value).commit();
} else {
sp.edit().putFloat(key, value).apply();
}
}
/**
* SP 中读取 float
*
* @param key 键
* @return 存在返回对应值，不存在返回默认值-1
*/
public float getFloat(@NonNull final String key) {
return getFloat(key, -1f);
}
/**
* SP 中读取 float
*
* @param key 键
* @param defaultValue 默认值
* @return 存在返回对应值，不存在返回默认值{@code defaultValue}
*/
public float getFloat(@NonNull final String key, final float defaultValue) {
return sp.getFloat(key, defaultValue);
}
/**
* SP 中写入 boolean
*
* @param key 键
* @param value 值
*/
public void put(@NonNull final String key, final boolean value) {
put(key, value, false);
}
/**
* SP 中写入 boolean
*
* @param key 键
* @param value 值
* @param isCommit {@code true}: {@link SharedPreferences.Editor#commit()}<br>
* {@code false}: {@link SharedPreferences.Editor#apply()}
*/
public void put(@NonNull final String key, final boolean value, final boolean isCommit) {
if (isCommit) {
sp.edit().putBoolean(key, value).commit();
} else {
sp.edit().putBoolean(key, value).apply();
}
}
/**
* SP 中读取 boolean
*
* @param key 键
* @return 存在返回对应值，不存在返回默认值{@code false}
*/
public boolean getBoolean(@NonNull final String key) {
return getBoolean(key, false);
}
/**
* SP 中读取 boolean
*
* @param key 键
* @param defaultValue 默认值
* @return 存在返回对应值，不存在返回默认值{@code defaultValue}
*/
public boolean getBoolean(@NonNull final String key, final boolean defaultValue) {
return sp.getBoolean(key, defaultValue);
}
/**
* SP 中写入 String 集合
*
* @param key 键
* @param values 值
*/
public void put(@NonNull final String key, @NonNull final Set<String> values) {
put(key, values, false);
}
/**
* SP 中写入 String 集合
*
* @param key 键
* @param values 值
* @param isCommit {@code true}: {@link SharedPreferences.Editor#commit()}<br>
* {@code false}: {@link SharedPreferences.Editor#apply()}
*/
public void put(@NonNull final String key,
@NonNull final Set<String> values,
final boolean isCommit) {
if (isCommit) {
sp.edit().putStringSet(key, values).commit();
} else {
sp.edit().putStringSet(key, values).apply();
}
}
/**
* SP 中读取 StringSet
*
* @param key 键
* @return 存在返回对应值，不存在返回默认值{@code Collections.<String>emptySet()}
*/
public Set<String> getStringSet(@NonNull final String key) {
return getStringSet(key, Collections.<String>emptySet());
}
/**
* SP 中读取 StringSet
*
* @param key 键
* @param defaultValue 默认值
* @return 存在返回对应值，不存在返回默认值{@code defaultValue}
*/
public Set<String> getStringSet(@NonNull final String key,
@NonNull final Set<String> defaultValue) {
return sp.getStringSet(key, defaultValue);
}
/**
* SP 中获取所有键值对
*
* @return Map 对象
*/
public Map<String, ?> getAll() {
return sp.getAll();
}
/**
* SP 中是否存在该 key
*
* @param key 键
* @return {@code true}: 存在<br>{@code false}: 不存在
*/
public boolean contains(@NonNull final String key) {
return sp.contains(key);
}
/**
* SP 中移除该 key
*
* @param key 键
*/
public void remove(@NonNull final String key) {
remove(key, false);
}
/**
* SP 中移除该 key
*
* @param key 键
* @param isCommit {@code true}: {@link SharedPreferences.Editor#commit()}<br>
* {@code false}: {@link SharedPreferences.Editor#apply()}
*/
public void remove(@NonNull final String key, final boolean isCommit) {
if (isCommit) {
sp.edit().remove(key).commit();
} else {
sp.edit().remove(key).apply();
}
}
/**
* SP 中清除所有数据
*/
public void clear() {
clear(false);
}
/**
* SP 中清除所有数据
*
* @param isCommit {@code true}: {@link SharedPreferences.Editor#commit()}<br>
* {@code false}: {@link SharedPreferences.Editor#apply()}
*/
public void clear(final boolean isCommit) {
if (isCommit) {
sp.edit().clear().commit();
} else {
sp.edit().clear().apply();
}
}
private static boolean isSpace(final String s) {
if (s == null) return true;
for (int i = 0, len = s.length(); i < len; ++i) {
if (!Character.isWhitespace(s.charAt(i))) {
return false;
}
}
return true;
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
MusicPlayer/src/main/java/com/yc/music/utils/NotificationHelper.java | Java | package com.yc.music.utils;
import android.app.Notification;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.content.Context;
import android.content.Intent;
import android.graphics.Bitmap;
import android.widget.RemoteViews;
import com.yc.music.R;
import com.yc.music.model.AudioBean;
import com.yc.music.receiver.NotificationStatusBarReceiver;
import com.yc.music.service.PlayService;
public class NotificationHelper {
private PlayService playService;
private NotificationManager notificationManager;
private static final int NOTIFICATION_ID = 0x111;
public static NotificationHelper get() {
return SingletonHolder.instance;
}
private static class SingletonHolder {
private static NotificationHelper instance = new NotificationHelper();
}
private NotificationHelper() {
}
/**
* 1.创建一个NotificationManager的引用
* @param playService PlayService对象
*/
public void init(PlayService playService) {
this.playService = playService;
notificationManager = (NotificationManager) playService.getSystemService(Context.NOTIFICATION_SERVICE);
}
/**
* 开始播放
* @param music music
*/
public void showPlay(AudioBean music) {
if (music == null) {
return;
}
playService.startForeground(NOTIFICATION_ID, buildNotification(playService, music, true));
//这个方法是启动Notification到前台
}
/**
* 暂停
* @param music music
*/
public void showPause(AudioBean music) {
//这个方法是停止Notification
if (music == null) {
return;
}
playService.stopForeground(false);
notificationManager.notify(NOTIFICATION_ID, buildNotification(playService, music, false));
}
/**
* 结束所有的
*/
public void cancelAll() {
notificationManager.cancelAll();
}
private Notification buildNotification(Context context, AudioBean music, boolean isPlaying) {
// Intent intent = new Intent(context, MusicActivity.class);
// intent.putExtra(Constant.EXTRA_NOTIFICATION, true);
// intent.setAction(Intent.ACTION_VIEW);
// intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
// intent.addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP);
// intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
// PendingIntent pendingIntent = PendingIntent.getActivity(context, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT);
NotificationUtils.isVibration = false;
NotificationUtils notificationUtils = new NotificationUtils(context);
notificationUtils
// .setContentIntent(pendingIntent)
.setPriority(Notification.PRIORITY_DEFAULT)
.setTicker("叮咚音乐")
.setContent(getCustomViews(context, music, isPlaying))
.setOngoing(true);
Notification notification = notificationUtils.getNotification(music.getTitle(), music.getArtist(), R.drawable.default_cover);
return notification;
}
/**
* 设置自定义通知栏布局
* @param context 上下文
* @param music
* @return RemoteViews
*/
private RemoteViews getCustomViews(Context context, AudioBean music, boolean isPlaying) {
String title = music.getTitle();
String subtitle = "";
Bitmap cover = null;
RemoteViews remoteViews = new RemoteViews(context.getPackageName(), R.layout.notification_player);
if (cover != null) {
remoteViews.setImageViewBitmap(R.id.iv_image, cover);
} else {
remoteViews.setImageViewResource(R.id.iv_image, R.drawable.default_cover);
}
remoteViews.setTextViewText(R.id.tv_title, title);
remoteViews.setTextViewText(R.id.tv_artist, subtitle);
if(isPlaying){
remoteViews.setImageViewResource(R.id.btn_start,R.drawable.notify_btn_dark_pause_normal);
}else {
remoteViews.setImageViewResource(R.id.btn_start,R.drawable.notify_btn_dark_play_normal);
}
// 设置 点击通知栏的上一首按钮时要执行的意图
// remoteViews.setOnClickPendingIntent(R.id.btn_pre, getReceiverPendingIntent(context, MusicPlayAction.TYPE_PRE,1));
// // 设置 点击通知栏的下一首按钮时要执行的意图
// remoteViews.setOnClickPendingIntent(R.id.btn_next, getReceiverPendingIntent(context, MusicPlayAction.TYPE_NEXT,2));
// // 设置 点击通知栏的播放暂停按钮时要执行的意图
// remoteViews.setOnClickPendingIntent(R.id.btn_start, getReceiverPendingIntent(context, MusicPlayAction.TYPE_START_PAUSE,3));
// // 设置 点击通知栏的根容器时要执行的意图
// remoteViews.setOnClickPendingIntent(R.id.ll_root, getActivityPendingIntent(context));
return remoteViews;
}
private PendingIntent getActivityPendingIntent(Context context) {
Intent intent = new Intent(context, null);
// Intent intent = new Intent(context, MusicActivity.class);
// intent.putExtra(Constant.EXTRA_NOTIFICATION, true);
// intent.setAction(Intent.ACTION_VIEW);
// intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
// intent.addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP);
// intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
return PendingIntent.getActivity(context, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT);
}
private PendingIntent getReceiverPendingIntent(Context context, String type , int code) {
Intent intent = new Intent(NotificationStatusBarReceiver.ACTION_STATUS_BAR);
intent.putExtra(NotificationStatusBarReceiver.EXTRA, type);
return PendingIntent.getBroadcast(context, code, intent, PendingIntent.FLAG_UPDATE_CURRENT);
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
MusicPlayer/src/main/java/com/yc/music/utils/NotificationUtils.java | Java | package com.yc.music.utils;
import android.annotation.TargetApi;
import android.app.Notification;
import android.app.NotificationChannel;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.content.Context;
import android.content.ContextWrapper;
import android.graphics.Color;
import android.net.Uri;
import android.os.Build;
import android.widget.RemoteViews;
import androidx.annotation.RequiresApi;
import androidx.core.app.NotificationCompat;
import static androidx.core.app.NotificationCompat.PRIORITY_DEFAULT;
import static androidx.core.app.NotificationCompat.VISIBILITY_SECRET;
/**
* <pre>
* @author yangchong
* blog : https://www.jianshu.com/p/514eb6193a06
* time : 2018/2/10
* desc : 通知栏工具类
* revise:
* </pre>
*/
public class NotificationUtils extends ContextWrapper {
public static final String CHANNEL_ID = "default";
private static final String CHANNEL_NAME = "Default_Channel";
public static boolean isVibration = false;
private NotificationManager mManager;
private int[] flags;
public NotificationUtils(Context base) {
super(base);
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
//android 8.0以上需要特殊处理，也就是targetSDKVersion为26以上
createNotificationChannel();
}
}
@TargetApi(Build.VERSION_CODES.O)
private void createNotificationChannel() {
//第一个参数：channel_id
//第二个参数：channel_name
//第三个参数：设置通知重要性级别
//注意：该级别必须要在 NotificationChannel 的构造函数中指定，总共要五个级别；
//范围是从 NotificationManager.IMPORTANCE_NONE(0) ~ NotificationManager.IMPORTANCE_HIGH(4)
NotificationChannel channel = new NotificationChannel(CHANNEL_ID, CHANNEL_NAME,
NotificationManager.IMPORTANCE_DEFAULT);
channel.canBypassDnd();//是否绕过请勿打扰模式
channel.enableLights(true);//闪光灯
channel.setLockscreenVisibility(VISIBILITY_SECRET);//锁屏显示通知
channel.setLightColor(Color.RED);//闪关灯的灯光颜色
channel.canShowBadge();//桌面launcher的消息角标
channel.enableVibration(isVibration);//是否允许震动
channel.getAudioAttributes();//获取系统通知响铃声音的配置
channel.getGroup();//获取通知取到组
channel.setBypassDnd(true);//设置可绕过 请勿打扰模式
channel.setVibrationPattern(new long[]{100, 100, 200});//设置震动模式
channel.shouldShowLights();//是否会有灯光
getManager().createNotificationChannel(channel);
}
/**
* 获取创建一个NotificationManager的对象
* @return NotificationManager对象
*/
public NotificationManager getManager() {
if (mManager == null) {
mManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
}
return mManager;
}
/**
* 清空所有的通知
*/
public void clearNotification(){
getManager().cancelAll();
}
/**
* 获取Notification
* @param title title
* @param content content
*/
public Notification getNotification(String title, String content , int icon){
Notification build;
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
//android 8.0以上需要特殊处理，也就是targetSDKVersion为26以上
//通知用到NotificationCompat()这个V4库中的方法。但是在实际使用时发现书上的代码已经过时并且Android8.0已经不支持这种写法
Notification.Builder builder = getChannelNotification(title, content, icon);
build = builder.build();
} else {
NotificationCompat.Builder builder = getNotificationCompat(title, content, icon);
build = builder.build();
}
if (flags!=null && flags.length>0){
for (int a=0 ; a<flags.length ; a++){
build.flags |= flags[a];
}
}
return build;
}
/**
* 建议使用这个发送通知
* 调用该方法可以发送通知
* @param notifyId notifyId
* @param title title
* @param content content
*/
public void sendNotification(int notifyId, String title, String content , int icon) {
Notification build;
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
//android 8.0以上需要特殊处理，也就是targetSDKVersion为26以上
//通知用到NotificationCompat()这个V4库中的方法。但是在实际使用时发现书上的代码已经过时并且Android8.0已经不支持这种写法
Notification.Builder builder = getChannelNotification(title, content, icon);
build = builder.build();
} else {
NotificationCompat.Builder builder = getNotificationCompat(title, content, icon);
build = builder.build();
}
if (flags!=null && flags.length>0){
for (int a=0 ; a<flags.length ; a++){
build.flags |= flags[a];
}
}
getManager().notify(notifyId, build);
}
/**
* 调用该方法可以发送通知
* @param notifyId notifyId
* @param title title
* @param content content
*/
public void sendNotificationCompat(int notifyId, String title, String content , int icon) {
NotificationCompat.Builder builder = getNotificationCompat(title, content, icon);
Notification build = builder.build();
if (flags!=null && flags.length>0){
for (int a=0 ; a<flags.length ; a++){
build.flags |= flags[a];
}
}
getManager().notify(notifyId, build);
}
private NotificationCompat.Builder getNotificationCompat(String title, String content, int icon) {
NotificationCompat.Builder builder;
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
builder = new NotificationCompat.Builder(getApplicationContext(), CHANNEL_ID);
} else {
//注意用下面这个方法，在8.0以上无法出现通知栏。8.0之前是正常的。这里需要增强判断逻辑
builder = new NotificationCompat.Builder(getApplicationContext());
builder.setPriority(PRIORITY_DEFAULT);
}
builder.setContentTitle(title);
builder.setContentText(content);
builder.setSmallIcon(icon);
builder.setPriority(priority);
builder.setOnlyAlertOnce(onlyAlertOnce);
builder.setOngoing(ongoing);
if (remoteViews!=null){
builder.setContent(remoteViews);
}
if (intent!=null){
builder.setContentIntent(intent);
}
if (ticker!=null && ticker.length()>0){
builder.setTicker(ticker);
}
if (when!=0){
builder.setWhen(when);
}
if (sound!=null){
builder.setSound(sound);
}
if (defaults!=0){
builder.setDefaults(defaults);
}
//点击自动删除通知
builder.setAutoCancel(true);
return builder;
}
@RequiresApi(api = Build.VERSION_CODES.O)
private Notification.Builder getChannelNotification(String title, String content, int icon){
Notification.Builder builder = new Notification.Builder(getApplicationContext(), CHANNEL_ID);
Notification.Builder notificationBuilder = builder
//设置标题
.setContentTitle(title)
//消息内容
.setContentText(content)
//设置通知的图标
.setSmallIcon(icon)
//让通知左右滑的时候是否可以取消通知
.setOngoing(ongoing)
//设置优先级
.setPriority(priority)
//是否提示一次.true - 如果Notification已经存在状态栏即使在调用notify函数也不会更新
.setOnlyAlertOnce(onlyAlertOnce)
.setAutoCancel(true);
if (remoteViews!=null){
//设置自定义view通知栏
notificationBuilder.setContent(remoteViews);
}
if (intent!=null){
notificationBuilder.setContentIntent(intent);
}
if (ticker!=null && ticker.length()>0){
//设置状态栏的标题
notificationBuilder.setTicker(ticker);
}
if (when!=0){
//设置通知时间，默认为系统发出通知的时间，通常不用设置
notificationBuilder.setWhen(when);
}
if (sound!=null){
//设置sound
notificationBuilder.setSound(sound);
}
if (defaults!=0){
//设置默认的提示音
notificationBuilder.setDefaults(defaults);
}
if (pattern!=null){
//自定义震动效果
notificationBuilder.setVibrate(pattern);
}
return notificationBuilder;
}
private boolean ongoing = false;
private RemoteViews remoteViews = null;
private PendingIntent intent = null;
private String ticker = "";
private int priority = Notification.PRIORITY_DEFAULT;
private boolean onlyAlertOnce = false;
private long when = 0;
private Uri sound = null;
private int defaults = 0;
private long[] pattern = null;
/**
* 让通知左右滑的时候是否可以取消通知
* @param ongoing 是否可以取消通知
* @return
*/
public NotificationUtils setOngoing(boolean ongoing){
this.ongoing = ongoing;
return this;
}
/**
* 设置自定义view通知栏布局
* @param remoteViews view
* @return
*/
public NotificationUtils setContent(RemoteViews remoteViews){
this.remoteViews = remoteViews;
return this;
}
/**
* 设置内容点击
* @param intent intent
* @return
*/
public NotificationUtils setContentIntent(PendingIntent intent){
this.intent = intent;
return this;
}
/**
* 设置状态栏的标题
* @param ticker 状态栏的标题
* @return
*/
public NotificationUtils setTicker(String ticker){
this.ticker = ticker;
return this;
}
/**
* 设置优先级
* 注意：
* Android 8.0以及上，在 NotificationChannel 的构造函数中指定，总共要五个级别；
* Android 7.1（API 25）及以下的设备，还得调用NotificationCompat 的 setPriority方法来设置
*
* @param priority 优先级，默认是Notification.PRIORITY_DEFAULT
* @return
*/
public NotificationUtils setPriority(int priority){
this.priority = priority;
return this;
}
/**
* 是否提示一次.true - 如果Notification已经存在状态栏即使在调用notify函数也不会更新
* @param onlyAlertOnce 是否只提示一次，默认是false
* @return
*/
public NotificationUtils setOnlyAlertOnce(boolean onlyAlertOnce){
this.onlyAlertOnce = onlyAlertOnce;
return this;
}
/**
* 设置通知时间，默认为系统发出通知的时间，通常不用设置
* @param when when
* @return
*/
public NotificationUtils setWhen(long when){
this.when = when;
return this;
}
/**
* 设置sound
* @param sound sound
* @return
*/
public NotificationUtils setSound(Uri sound){
this.sound = sound;
return this;
}
/**
* 设置默认的提示音
* @param defaults defaults
* @return
*/
public NotificationUtils setDefaults(int defaults){
this.defaults = defaults;
return this;
}
/**
* 自定义震动效果
* @param pattern pattern
* @return
*/
public NotificationUtils setVibrate(long[] pattern){
this.pattern = pattern;
return this;
}
/**
* 设置flag标签
* @param flags flags
* @return
*/
public NotificationUtils setFlags(int... flags){
this.flags = flags;
return this;
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoBarrage/build.gradle | Gradle | apply plugin: 'com.android.library'
android {
compileSdkVersion 29
buildToolsVersion "29.0.3"
defaultConfig {
minSdkVersion 17
targetSdkVersion 29
versionCode 1
versionName "1.0"
testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
consumerProguardFiles "consumer-rules.pro"
}
buildTypes {
release {
minifyEnabled false
proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
}
}
}
dependencies {
implementation fileTree(dir: "libs", include: ["*.jar"])
implementation 'androidx.appcompat:appcompat:1.2.0'
testImplementation 'junit:junit:4.12'
androidTestImplementation 'androidx.test.ext:junit:1.1.2'
androidTestImplementation 'androidx.test.espresso:espresso-core:3.3.0'
} | yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoBarrage/src/main/java/com/yc/videobarrage/Test.java | Java | package com.yc.videobarrage;
public class Test {
//代码待提交，完善之后再开源
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoCache/build.gradle | Gradle | apply plugin: 'com.android.library'
android {
compileSdkVersion 29
buildToolsVersion "29.0.3"
defaultConfig {
minSdkVersion 17
targetSdkVersion 29
versionCode 31
versionName "3.0.1"
testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
consumerProguardFiles "consumer-rules.pro"
}
buildTypes {
release {
minifyEnabled false
proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
}
}
}
dependencies {
implementation fileTree(dir: "libs", include: ["*.jar"])
}
/** 以下开始是将Android Library上传到jcenter的相关配置**/
apply plugin: 'com.github.dcendents.android-maven'
apply plugin: 'com.jfrog.bintray'
//项目主页
def siteUrl = 'https://github.com/yangchong211/YCVideoPlayer' // project homepage
//项目的版本控制地址
def gitUrl = 'https://github.com/yangchong211/YCVideoPlayer.git' // project git
//发布到组织名称名字，必须填写
group = "cn.yc"
//发布到JCenter上的项目名字，必须填写
def libName = "YCVideoCacheLib"
// 版本号，下次更新是只需要更改版本号即可
version = "3.0.5"
/** 上面配置后上传至jcenter后的编译路径是这样的： compile 'cn.yc:YCVideoCacheLib:1.0.0' **/
//生成源文件
task sourcesJar(type: Jar) {
from android.sourceSets.main.java.srcDirs
classifier = 'sources'
}
//生成文档
task javadoc(type: Javadoc) {
source = android.sourceSets.main.java.srcDirs
classpath += project.files(android.getBootClasspath().join(File.pathSeparator))
options.encoding "UTF-8"
options.charSet 'UTF-8'
options.author true
options.version true
options.links "https://github.com/linglongxin24/FastDev/tree/master/mylibrary/docs/javadoc"
failOnError false
}
//文档打包成jar
task javadocJar(type: Jar, dependsOn: javadoc) {
classifier = 'javadoc'
from javadoc.destinationDir
}
//拷贝javadoc文件
task copyDoc(type: Copy) {
from "${buildDir}/docs/"
into "docs"
}
//上传到jcenter所需要的源码文件
artifacts {
archives javadocJar
archives sourcesJar
}
// 配置maven库，生成POM.xml文件
install {
repositories.mavenInstaller {
// This generates POM.xml with proper parameters
pom {
project {
packaging 'aar'
//项目描述，自由填写
name 'This is video cache lib'
url siteUrl
licenses {
license {
//开源协议
name 'The Apache Software License, Version 2.0'
url 'http://www.apache.org/licenses/LICENSE-2.0.txt'
}
}
developers {
developer {
//开发者的个人信息，根据个人信息填写
id 'yangchong'
name 'yc'
email 'yangchong211@163.com'
}
}
scm {
connection gitUrl
developerConnection gitUrl
url siteUrl
}
}
}
}
}
//上传到jcenter
Properties properties = new Properties()
properties.load(project.rootProject.file('local.properties').newDataInputStream())
bintray {
user = properties.getProperty("bintray.user") //读取 local.properties 文件里面的 bintray.user
key = properties.getProperty("bintray.apikey") //读取 local.properties 文件里面的 bintray.apikey
configurations = ['archives']
pkg {
repo = "maven"
name = libName //发布到JCenter上的项目名字，必须填写
desc = 'android video cache' //项目描述
websiteUrl = siteUrl
vcsUrl = gitUrl
licenses = ["Apache-2.0"]
publish = true
}
}
javadoc {
options {
//如果你的项目里面有中文注释的话，必须将格式设置为UTF-8，不然会出现乱码
encoding "UTF-8"
charSet 'UTF-8'
author true
version true
links "http://docs.oracle.com/javase/7/docs/api"
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoCache/src/main/java/com/yc/videocache/ByteArrayCache.java | Java | package com.yc.videocache;
import java.io.ByteArrayInputStream;
import java.util.Arrays;
/**
* Simple memory based {@link Cache} implementation.
*
*/
public class ByteArrayCache implements Cache {
private volatile byte[] data;
private volatile boolean completed;
public ByteArrayCache() {
this(new byte[0]);
}
public ByteArrayCache(byte[] data) {
this.data = Preconditions.checkNotNull(data);
}
@Override
public int read(byte[] buffer, long offset, int length) throws ProxyCacheException {
if (offset >= data.length) {
return -1;
}
if (offset > Integer.MAX_VALUE) {
throw new IllegalArgumentException("Too long offset for memory cache " + offset);
}
return new ByteArrayInputStream(data).read(buffer, (int) offset, length);
}
@Override
public long available() throws ProxyCacheException {
return data.length;
}
@Override
public void append(byte[] newData, int length) throws ProxyCacheException {
Preconditions.checkNotNull(data);
Preconditions.checkArgument(length >= 0 && length <= newData.length);
byte[] appendedData = Arrays.copyOf(data, data.length + length);
System.arraycopy(newData, 0, appendedData, data.length, length);
data = appendedData;
}
@Override
public void close() throws ProxyCacheException {
}
@Override
public void complete() {
completed = true;
}
@Override
public boolean isCompleted() {
return completed;
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoCache/src/main/java/com/yc/videocache/ByteArraySource.java | Java | package com.yc.videocache;
import java.io.ByteArrayInputStream;
/**
* Simple memory based {@link Source} implementation.
*
*/
public class ByteArraySource implements Source {
private final byte[] data;
private ByteArrayInputStream arrayInputStream;
public ByteArraySource(byte[] data) {
this.data = data;
}
@Override
public int read(byte[] buffer) throws ProxyCacheException {
return arrayInputStream.read(buffer, 0, buffer.length);
}
@Override
public long length() throws ProxyCacheException {
return data.length;
}
@Override
public void open(long offset) throws ProxyCacheException {
arrayInputStream = new ByteArrayInputStream(data);
arrayInputStream.skip(offset);
}
@Override
public void close() throws ProxyCacheException {
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoCache/src/main/java/com/yc/videocache/Cache.java | Java | package com.yc.videocache;
/**
* Cache for proxy.
*
*/
public interface Cache {
long available() throws ProxyCacheException;
int read(byte[] buffer, long offset, int length) throws ProxyCacheException;
void append(byte[] data, int length) throws ProxyCacheException;
void close() throws ProxyCacheException;
void complete() throws ProxyCacheException;
boolean isCompleted();
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoCache/src/main/java/com/yc/videocache/CacheListener.java | Java | package com.yc.videocache;
import java.io.File;
/**
* Listener for cache availability.
*
*/
public interface CacheListener {
void onCacheAvailable(File cacheFile, String url, int percentsAvailable);
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoCache/src/main/java/com/yc/videocache/Config.java | Java | package com.yc.videocache;
import com.yc.videocache.file.DiskUsage;
import com.yc.videocache.file.FileNameGenerator;
import com.yc.videocache.headers.HeaderInjector;
import com.yc.videocache.sourcestorage.SourceInfoStorage;
import java.io.File;
/**
* Configuration for proxy cache.
*/
class Config {
public final File cacheRoot;
public final FileNameGenerator fileNameGenerator;
public final DiskUsage diskUsage;
public final SourceInfoStorage sourceInfoStorage;
public final HeaderInjector headerInjector;
Config(File cacheRoot, FileNameGenerator fileNameGenerator, DiskUsage diskUsage, SourceInfoStorage sourceInfoStorage, HeaderInjector headerInjector) {
this.cacheRoot = cacheRoot;
this.fileNameGenerator = fileNameGenerator;
this.diskUsage = diskUsage;
this.sourceInfoStorage = sourceInfoStorage;
this.headerInjector = headerInjector;
}
File generateCacheFile(String url) {
String name = fileNameGenerator.generate(url);
return new File(cacheRoot, name);
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoCache/src/main/java/com/yc/videocache/GetRequest.java | Java | package com.yc.videocache;
import android.text.TextUtils;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import static com.yc.videocache.Preconditions.checkNotNull;
/**
* Model for Http GET request.
*
*/
class GetRequest {
private static final Pattern RANGE_HEADER_PATTERN = Pattern.compile("[R,r]ange:[ ]?bytes=(\\d*)-");
private static final Pattern URL_PATTERN = Pattern.compile("GET /(.*) HTTP");
public final String uri;
public final long rangeOffset;
public final boolean partial;
public GetRequest(String request) {
checkNotNull(request);
long offset = findRangeOffset(request);
this.rangeOffset = Math.max(0, offset);
this.partial = offset >= 0;
this.uri = findUri(request);
}
public static GetRequest read(InputStream inputStream) throws IOException {
BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream, "UTF-8"));
StringBuilder stringRequest = new StringBuilder();
String line;
while (!TextUtils.isEmpty(line = reader.readLine())) { // until new line (headers ending)
stringRequest.append(line).append('\n');
}
return new GetRequest(stringRequest.toString());
}
private long findRangeOffset(String request) {
Matcher matcher = RANGE_HEADER_PATTERN.matcher(request);
if (matcher.find()) {
String rangeValue = matcher.group(1);
return Long.parseLong(rangeValue);
}
return -1;
}
private String findUri(String request) {
Matcher matcher = URL_PATTERN.matcher(request);
if (matcher.find()) {
return matcher.group(1);
}
throw new IllegalArgumentException("Invalid request `" + request + "`: url not found!");
}
@Override
public String toString() {
return "GetRequest{" +
"rangeOffset=" + rangeOffset +
", partial=" + partial +
", uri='" + uri + '\'' +
'}';
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoCache/src/main/java/com/yc/videocache/HttpProxyCache.java | Java | package com.yc.videocache;
import android.text.TextUtils;
import com.yc.videocache.file.FileCache;
import java.io.BufferedOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
import java.util.Locale;
import static com.yc.videocache.ProxyCacheUtils.DEFAULT_BUFFER_SIZE;
/**
* {@link ProxyCache} that read http url and writes data to {@link Socket}
*/
class HttpProxyCache extends ProxyCache {
private static final float NO_CACHE_BARRIER = .2f;
private final HttpUrlSource source;
private final FileCache cache;
private CacheListener listener;
public HttpProxyCache(HttpUrlSource source, FileCache cache) {
super(source, cache);
this.cache = cache;
this.source = source;
}
public void registerCacheListener(CacheListener cacheListener) {
this.listener = cacheListener;
}
public void processRequest(GetRequest request, Socket socket) throws IOException, ProxyCacheException {
OutputStream out = new BufferedOutputStream(socket.getOutputStream());
String responseHeaders = newResponseHeaders(request);
out.write(responseHeaders.getBytes("UTF-8"));
long offset = request.rangeOffset;
if (isUseCache(request)) {
responseWithCache(out, offset);
} else {
responseWithoutCache(out, offset);
}
}
private boolean isUseCache(GetRequest request) throws ProxyCacheException {
long sourceLength = source.length();
boolean sourceLengthKnown = sourceLength > 0;
long cacheAvailable = cache.available();
// do not use cache for partial requests which too far from available cache. It seems user seek video.
return !sourceLengthKnown || !request.partial || request.rangeOffset <= cacheAvailable + sourceLength * NO_CACHE_BARRIER;
}
private String newResponseHeaders(GetRequest request) throws IOException, ProxyCacheException {
String mime = source.getMime();
boolean mimeKnown = !TextUtils.isEmpty(mime);
long length = cache.isCompleted() ? cache.available() : source.length();
boolean lengthKnown = length >= 0;
long contentLength = request.partial ? length - request.rangeOffset : length;
boolean addRange = lengthKnown && request.partial;
return new StringBuilder()
.append(request.partial ? "HTTP/1.1 206 PARTIAL CONTENT\n" : "HTTP/1.1 200 OK\n")
.append("Accept-Ranges: bytes\n")
.append(lengthKnown ? format("Content-Length: %d\n", contentLength) : "")
.append(addRange ? format("Content-Range: bytes %d-%d/%d\n", request.rangeOffset, length - 1, length) : "")
.append(mimeKnown ? format("Content-Type: %s\n", mime) : "")
.append("\n") // headers end
.toString();
}
private void responseWithCache(OutputStream out, long offset) throws ProxyCacheException, IOException {
byte[] buffer = new byte[DEFAULT_BUFFER_SIZE];
int readBytes;
while ((readBytes = read(buffer, offset, buffer.length)) != -1) {
out.write(buffer, 0, readBytes);
offset += readBytes;
}
out.flush();
}
private void responseWithoutCache(OutputStream out, long offset) throws ProxyCacheException, IOException {
HttpUrlSource newSourceNoCache = new HttpUrlSource(this.source);
try {
newSourceNoCache.open((int) offset);
byte[] buffer = new byte[DEFAULT_BUFFER_SIZE];
int readBytes;
while ((readBytes = newSourceNoCache.read(buffer)) != -1) {
out.write(buffer, 0, readBytes);
offset += readBytes;
}
out.flush();
} finally {
newSourceNoCache.close();
}
}
private String format(String pattern, Object... args) {
return String.format(Locale.US, pattern, args);
}
@Override
protected void onCachePercentsAvailableChanged(int percents) {
if (listener != null) {
listener.onCacheAvailable(cache.file, source.getUrl(), percents);
}
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoCache/src/main/java/com/yc/videocache/HttpProxyCacheServer.java | Java | package com.yc.videocache;
import android.content.Context;
import android.net.Uri;
import com.yc.videocache.file.DiskUsage;
import com.yc.videocache.file.FileNameGenerator;
import com.yc.videocache.file.Md5FileNameGenerator;
import com.yc.videocache.file.TotalCountLruDiskUsage;
import com.yc.videocache.file.TotalSizeLruDiskUsage;
import com.yc.videocache.headers.EmptyHeadersInjector;
import com.yc.videocache.headers.HeaderInjector;
import com.yc.videocache.sourcestorage.SourceInfoStorage;
import com.yc.videocache.sourcestorage.SourceInfoStorageFactory;
import java.io.File;
import java.io.IOException;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketException;
import java.util.Locale;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import static com.yc.videocache.Preconditions.checkAllNotNull;
import static com.yc.videocache.Preconditions.checkNotNull;
/**
* Simple lightweight proxy server with file caching support that handles HTTP requests.
* Typical usage:
* <pre><code>
* public onCreate(Bundle state) {
* super.onCreate(state);
*
* HttpProxyCacheServer proxy = getProxy();
* String proxyUrl = proxy.getProxyUrl(VIDEO_URL);
* videoView.setVideoPath(proxyUrl);
* }
*
* private HttpProxyCacheServer getProxy() {
* // should return single instance of HttpProxyCacheServer shared for whole app.
* }
* </code></pre>
*
*/
public class HttpProxyCacheServer {
private static final String PROXY_HOST = "127.0.0.1";
private final Object clientsLock = new Object();
private final ExecutorService socketProcessor = Executors.newFixedThreadPool(8);
private final Map<String, HttpProxyCacheServerClients> clientsMap = new ConcurrentHashMap<>();
private final ServerSocket serverSocket;
private final int port;
private final Thread waitConnectionThread;
private final Config config;
public HttpProxyCacheServer(Context context) {
this(new Builder(context).buildConfig());
}
private HttpProxyCacheServer(Config config) {
this.config = checkNotNull(config);
try {
InetAddress inetAddress = InetAddress.getByName(PROXY_HOST);
this.serverSocket = new ServerSocket(0, 8, inetAddress);
this.port = serverSocket.getLocalPort();
IgnoreHostProxySelector.install(PROXY_HOST, port);
CountDownLatch startSignal = new CountDownLatch(1);
this.waitConnectionThread = new Thread(new WaitRequestsRunnable(startSignal));
this.waitConnectionThread.start();
startSignal.await(); // freeze thread, wait for server starts
} catch (IOException | InterruptedException e) {
socketProcessor.shutdown();
throw new IllegalStateException("Error starting local proxy server", e);
}
}
/**
* Returns url that wrap original url and should be used for client (MediaPlayer, ExoPlayer, etc).
* <p>
* If file for this url is fully cached (it means method {@link #isCached(String)} returns {@code true})
* then file:// uri to cached file will be returned.
* <p>
* Calling this method has same effect as calling {@link #getProxyUrl(String, boolean)} with 2nd parameter set to {@code true}.
*
* @param url a url to file that should be cached.
* @return a wrapped by proxy url if file is not fully cached or url pointed to cache file otherwise.
*/
public String getProxyUrl(String url) {
return getProxyUrl(url, true);
}
/**
* Returns url that wrap original url and should be used for client (MediaPlayer, ExoPlayer, etc).
* <p>
* If parameter {@code allowCachedFileUri} is {@code true} and file for this url is fully cached
* (it means method {@link #isCached(String)} returns {@code true}) then file:// uri to cached file will be returned.
*
* @param url a url to file that should be cached.
* @param allowCachedFileUri {@code true} if allow to return file:// uri if url is fully cached
* @return a wrapped by proxy url if file is not fully cached or url pointed to cache file otherwise (if {@code allowCachedFileUri} is {@code true}).
*/
public String getProxyUrl(String url, boolean allowCachedFileUri) {
if (allowCachedFileUri && getCacheFile(url).exists()) {
File cacheFile = getCacheFile(url);
touchFileSafely(cacheFile);
return Uri.fromFile(cacheFile).toString();
}
return appendToProxyUrl(url);
}
public void registerCacheListener(CacheListener cacheListener, String url) {
checkAllNotNull(cacheListener, url);
synchronized (clientsLock) {
try {
getClients(url).registerCacheListener(cacheListener);
} catch (ProxyCacheException e) {
Logger.warn("Error registering cache listener");
}
}
}
public void unregisterCacheListener(CacheListener cacheListener, String url) {
checkAllNotNull(cacheListener, url);
synchronized (clientsLock) {
try {
getClients(url).unregisterCacheListener(cacheListener);
} catch (ProxyCacheException e) {
Logger.warn("Error registering cache listener");
}
}
}
public void unregisterCacheListener(CacheListener cacheListener) {
checkNotNull(cacheListener);
synchronized (clientsLock) {
for (HttpProxyCacheServerClients clients : clientsMap.values()) {
clients.unregisterCacheListener(cacheListener);
}
}
}
/**
* Checks is cache contains fully cached file for particular url.
*
* @param url an url cache file will be checked for.
* @return {@code true} if cache contains fully cached file for passed in parameters url.
*/
public boolean isCached(String url) {
checkNotNull(url, "Url can't be null!");
return getCacheFile(url).exists();
}
public void shutdown() {
Logger.info("Shutdown proxy server");
shutdownClients();
config.sourceInfoStorage.release();
waitConnectionThread.interrupt();
try {
if (!serverSocket.isClosed()) {
serverSocket.close();
}
} catch (IOException e) {
onError(new ProxyCacheException("Error shutting down proxy server", e));
}
}
private String appendToProxyUrl(String url) {
return String.format(Locale.US, "http://%s:%d/%s", PROXY_HOST, port, ProxyCacheUtils.encode(url));
}
public File getCacheFile(String url) {
File cacheDir = config.cacheRoot;
String fileName = config.fileNameGenerator.generate(url);
return new File(cacheDir, fileName);
}
public File getTempCacheFile(String url) {
File cacheDir = config.cacheRoot;
String fileName = config.fileNameGenerator.generate(url) + ".download";
return new File(cacheDir, fileName);
}
public File getCacheRoot() {
return config.cacheRoot;
}
private void touchFileSafely(File cacheFile) {
try {
config.diskUsage.touch(cacheFile);
} catch (IOException e) {
Logger.error("Error touching file " + cacheFile);
}
}
private void shutdownClients() {
synchronized (clientsLock) {
for (HttpProxyCacheServerClients clients : clientsMap.values()) {
clients.shutdown();
}
clientsMap.clear();
}
}
private void waitForRequest() {
try {
while (!Thread.currentThread().isInterrupted()) {
Socket socket = serverSocket.accept();
Logger.debug("Accept new socket " + socket);
socketProcessor.submit(new SocketProcessorRunnable(socket));
}
} catch (IOException e) {
onError(new ProxyCacheException("Error during waiting connection", e));
}
}
private void processSocket(Socket socket) {
try {
GetRequest request = GetRequest.read(socket.getInputStream());
Logger.debug("Request to cache proxy:" + request);
String url = ProxyCacheUtils.decode(request.uri);
HttpProxyCacheServerClients clients = getClients(url);
clients.processRequest(request, socket);
} catch (SocketException e) {
// There is no way to determine that client closed connection http://stackoverflow.com/a/10241044/999458
// So just to prevent log flooding don't log stacktrace
Logger.debug("Closing socket… Socket is closed by client.");
} catch (ProxyCacheException | IOException e) {
onError(new ProxyCacheException("Error processing request", e));
} finally {
releaseSocket(socket);
Logger.debug("Opened connections: " + getClientsCount());
}
}
private HttpProxyCacheServerClients getClients(String url) throws ProxyCacheException {
synchronized (clientsLock) {
HttpProxyCacheServerClients clients = clientsMap.get(url);
if (clients == null) {
clients = new HttpProxyCacheServerClients(url, config);
clientsMap.put(url, clients);
}
return clients;
}
}
private int getClientsCount() {
synchronized (clientsLock) {
int count = 0;
for (HttpProxyCacheServerClients clients : clientsMap.values()) {
count += clients.getClientsCount();
}
return count;
}
}
private void releaseSocket(Socket socket) {
closeSocketInput(socket);
closeSocketOutput(socket);
closeSocket(socket);
}
private void closeSocketInput(Socket socket) {
try {
if (!socket.isInputShutdown()) {
socket.shutdownInput();
}
} catch (SocketException e) {
// There is no way to determine that client closed connection http://stackoverflow.com/a/10241044/999458
// So just to prevent log flooding don't log stacktrace
Logger.debug("Releasing input stream… Socket is closed by client.");
} catch (IOException e) {
onError(new ProxyCacheException("Error closing socket input stream", e));
}
}
private void closeSocketOutput(Socket socket) {
try {
if (!socket.isOutputShutdown()) {
socket.shutdownOutput();
}
} catch (IOException e) {
Logger.warn("Failed to close socket on proxy side: {}. It seems client have already closed connection.");
}
}
private void closeSocket(Socket socket) {
try {
if (!socket.isClosed()) {
socket.close();
}
} catch (IOException e) {
onError(new ProxyCacheException("Error closing socket", e));
}
}
private void onError(Throwable e) {
Logger.error("HttpProxyCacheServer error");
}
private final class WaitRequestsRunnable implements Runnable {
private final CountDownLatch startSignal;
public WaitRequestsRunnable(CountDownLatch startSignal) {
this.startSignal = startSignal;
}
@Override
public void run() {
startSignal.countDown();
waitForRequest();
}
}
private final class SocketProcessorRunnable implements Runnable {
private final Socket socket;
public SocketProcessorRunnable(Socket socket) {
this.socket = socket;
}
@Override
public void run() {
processSocket(socket);
}
}
/**
* Builder for {@link HttpProxyCacheServer}.
*/
public static final class Builder {
private static final long DEFAULT_MAX_SIZE = 512 * 1024 * 1024;
private File cacheRoot;
private FileNameGenerator fileNameGenerator;
private DiskUsage diskUsage;
private SourceInfoStorage sourceInfoStorage;
private HeaderInjector headerInjector;
public Builder(Context context) {
this.sourceInfoStorage = SourceInfoStorageFactory.newSourceInfoStorage(context);
this.cacheRoot = StorageUtils.getIndividualCacheDirectory(context);
this.diskUsage = new TotalSizeLruDiskUsage(DEFAULT_MAX_SIZE);
this.fileNameGenerator = new Md5FileNameGenerator();
this.headerInjector = new EmptyHeadersInjector();
}
/**
* Overrides default cache folder to be used for caching files.
* <p>
* By default AndroidVideoCache uses
* '/Android/data/[app_package_name]/cache/video-cache/' if card is mounted and app has appropriate permission
* or 'video-cache' subdirectory in default application's cache directory otherwise.
* </p>
* <b>Note</b> directory must be used <b>only</b> for AndroidVideoCache files.
*
* @param file a cache directory, can't be null.
* @return a builder.
*/
public Builder cacheDirectory(File file) {
this.cacheRoot = checkNotNull(file);
return this;
}
/**
* Overrides default cache file name generator {@link Md5FileNameGenerator} .
*
* @param fileNameGenerator a new file name generator.
* @return a builder.
*/
public Builder fileNameGenerator(FileNameGenerator fileNameGenerator) {
this.fileNameGenerator = checkNotNull(fileNameGenerator);
return this;
}
/**
* Sets max cache size in bytes.
* <p>
* All files that exceeds limit will be deleted using LRU strategy.
* Default value is 512 Mb.
* </p>
* Note this method overrides result of calling {@link #maxCacheFilesCount(int)}
*
* @param maxSize max cache size in bytes.
* @return a builder.
*/
public Builder maxCacheSize(long maxSize) {
this.diskUsage = new TotalSizeLruDiskUsage(maxSize);
return this;
}
/**
* Sets max cache files count.
* All files that exceeds limit will be deleted using LRU strategy.
* Note this method overrides result of calling {@link #maxCacheSize(long)}
*
* @param count max cache files count.
* @return a builder.
*/
public Builder maxCacheFilesCount(int count) {
this.diskUsage = new TotalCountLruDiskUsage(count);
return this;
}
/**
* Set custom DiskUsage logic for handling when to keep or clean cache.
*
* @param diskUsage a disk usage strategy, cant be {@code null}.
* @return a builder.
*/
public Builder diskUsage(DiskUsage diskUsage) {
this.diskUsage = checkNotNull(diskUsage);
return this;
}
/**
* Add headers along the request to the server
*
* @param headerInjector to inject header base on url
* @return a builder
*/
public Builder headerInjector(HeaderInjector headerInjector) {
this.headerInjector = checkNotNull(headerInjector);
return this;
}
/**
* Builds new instance of {@link HttpProxyCacheServer}.
*
* @return proxy cache. Only single instance should be used across whole app.
*/
public HttpProxyCacheServer build() {
Config config = buildConfig();
return new HttpProxyCacheServer(config);
}
private Config buildConfig() {
return new Config(cacheRoot, fileNameGenerator, diskUsage, sourceInfoStorage, headerInjector);
}
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoCache/src/main/java/com/yc/videocache/HttpProxyCacheServerClients.java | Java | package com.yc.videocache;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import com.yc.videocache.file.FileCache;
import java.io.File;
import java.io.IOException;
import java.net.Socket;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.atomic.AtomicInteger;
import static com.yc.videocache.Preconditions.checkNotNull;
/**
* Client for {@link HttpProxyCacheServer}
*
*/
final class HttpProxyCacheServerClients {
private final AtomicInteger clientsCount = new AtomicInteger(0);
private final String url;
private volatile HttpProxyCache proxyCache;
private final List<CacheListener> listeners = new CopyOnWriteArrayList<>();
private final CacheListener uiCacheListener;
private final Config config;
public HttpProxyCacheServerClients(String url, Config config) {
this.url = checkNotNull(url);
this.config = checkNotNull(config);
this.uiCacheListener = new UiListenerHandler(url, listeners);
}
public void processRequest(GetRequest request, Socket socket) throws ProxyCacheException, IOException {
startProcessRequest();
try {
clientsCount.incrementAndGet();
proxyCache.processRequest(request, socket);
} finally {
finishProcessRequest();
}
}
private synchronized void startProcessRequest() throws ProxyCacheException {
proxyCache = proxyCache == null ? newHttpProxyCache() : proxyCache;
}
private synchronized void finishProcessRequest() {
if (clientsCount.decrementAndGet() <= 0) {
proxyCache.shutdown();
proxyCache = null;
}
}
public void registerCacheListener(CacheListener cacheListener) {
listeners.add(cacheListener);
}
public void unregisterCacheListener(CacheListener cacheListener) {
listeners.remove(cacheListener);
}
public void shutdown() {
listeners.clear();
if (proxyCache != null) {
proxyCache.registerCacheListener(null);
proxyCache.shutdown();
proxyCache = null;
}
clientsCount.set(0);
}
public int getClientsCount() {
return clientsCount.get();
}
private HttpProxyCache newHttpProxyCache() throws ProxyCacheException {
HttpUrlSource source = new HttpUrlSource(url, config.sourceInfoStorage, config.headerInjector);
FileCache cache = new FileCache(config.generateCacheFile(url), config.diskUsage);
HttpProxyCache httpProxyCache = new HttpProxyCache(source, cache);
httpProxyCache.registerCacheListener(uiCacheListener);
return httpProxyCache;
}
private static final class UiListenerHandler extends Handler implements CacheListener {
private final String url;
private final List<CacheListener> listeners;
public UiListenerHandler(String url, List<CacheListener> listeners) {
super(Looper.getMainLooper());
this.url = url;
this.listeners = listeners;
}
@Override
public void onCacheAvailable(File file, String url, int percentsAvailable) {
Message message = obtainMessage();
message.arg1 = percentsAvailable;
message.obj = file;
sendMessage(message);
}
@Override
public void handleMessage(Message msg) {
for (CacheListener cacheListener : listeners) {
cacheListener.onCacheAvailable((File) msg.obj, url, msg.arg1);
}
}
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoCache/src/main/java/com/yc/videocache/HttpUrlSource.java | Java | package com.yc.videocache;
import android.text.TextUtils;
import com.yc.videocache.headers.EmptyHeadersInjector;
import com.yc.videocache.headers.HeaderInjector;
import com.yc.videocache.sourcestorage.SourceInfoStorage;
import com.yc.videocache.sourcestorage.SourceInfoStorageFactory;
import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InterruptedIOException;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.Map;
import static com.yc.videocache.Preconditions.checkNotNull;
import static com.yc.videocache.ProxyCacheUtils.DEFAULT_BUFFER_SIZE;
import static java.net.HttpURLConnection.HTTP_MOVED_PERM;
import static java.net.HttpURLConnection.HTTP_MOVED_TEMP;
import static java.net.HttpURLConnection.HTTP_OK;
import static java.net.HttpURLConnection.HTTP_PARTIAL;
import static java.net.HttpURLConnection.HTTP_SEE_OTHER;
/**
* {@link Source} that uses http resource as source for {@link ProxyCache}.
*
*/
public class HttpUrlSource implements Source {
private static final int MAX_REDIRECTS = 5;
private final SourceInfoStorage sourceInfoStorage;
private final HeaderInjector headerInjector;
private SourceInfo sourceInfo;
private HttpURLConnection connection;
private InputStream inputStream;
public HttpUrlSource(String url) {
this(url, SourceInfoStorageFactory.newEmptySourceInfoStorage());
}
public HttpUrlSource(String url, SourceInfoStorage sourceInfoStorage) {
this(url, sourceInfoStorage, new EmptyHeadersInjector());
}
public HttpUrlSource(String url, SourceInfoStorage sourceInfoStorage, HeaderInjector headerInjector) {
this.sourceInfoStorage = checkNotNull(sourceInfoStorage);
this.headerInjector = checkNotNull(headerInjector);
SourceInfo sourceInfo = sourceInfoStorage.get(url);
this.sourceInfo = sourceInfo != null ? sourceInfo :
new SourceInfo(url, Integer.MIN_VALUE, ProxyCacheUtils.getSupposablyMime(url));
}
public HttpUrlSource(HttpUrlSource source) {
this.sourceInfo = source.sourceInfo;
this.sourceInfoStorage = source.sourceInfoStorage;
this.headerInjector = source.headerInjector;
}
@Override
public synchronized long length() throws ProxyCacheException {
if (sourceInfo.length == Integer.MIN_VALUE) {
fetchContentInfo();
}
return sourceInfo.length;
}
@Override
public void open(long offset) throws ProxyCacheException {
try {
connection = openConnection(offset, -1);
String mime = connection.getContentType();
inputStream = new BufferedInputStream(connection.getInputStream(), DEFAULT_BUFFER_SIZE);
long length = readSourceAvailableBytes(connection, offset, connection.getResponseCode());
this.sourceInfo = new SourceInfo(sourceInfo.url, length, mime);
this.sourceInfoStorage.put(sourceInfo.url, sourceInfo);
} catch (IOException e) {
throw new ProxyCacheException("Error opening connection for " + sourceInfo.url + " with offset " + offset, e);
}
}
private long readSourceAvailableBytes(HttpURLConnection connection, long offset, int responseCode) throws IOException {
long contentLength = getContentLength(connection);
return responseCode == HTTP_OK ? contentLength
: responseCode == HTTP_PARTIAL ? contentLength + offset : sourceInfo.length;
}
private long getContentLength(HttpURLConnection connection) {
String contentLengthValue = connection.getHeaderField("Content-Length");
return contentLengthValue == null ? -1 : Long.parseLong(contentLengthValue);
}
@Override
public void close() throws ProxyCacheException {
if (connection != null) {
try {
connection.disconnect();
} catch (NullPointerException | IllegalArgumentException e) {
String message = "Wait... but why? WTF!? " +
"Really shouldn't happen any more after fixing https://github.com/danikula/AndroidVideoCache/issues/43. " +
"If you read it on your device log, please, notify me danikula@gmail.com or create issue here " +
"https://github.com/danikula/AndroidVideoCache/issues.";
throw new RuntimeException(message, e);
} catch (ArrayIndexOutOfBoundsException e) {
Logger.error("Error closing connection correctly. Should happen only on Android L. " +
"If anybody know how to fix it, please visit https://github.com/danikula/AndroidVideoCache/issues/88. " +
"Until good solution is not know, just ignore this issue.");
}
}
}
@Override
public int read(byte[] buffer) throws ProxyCacheException {
if (inputStream == null) {
throw new ProxyCacheException("Error reading data from " + sourceInfo.url + ": connection is absent!");
}
try {
return inputStream.read(buffer, 0, buffer.length);
} catch (InterruptedIOException e) {
throw new InterruptedProxyCacheException("Reading source " + sourceInfo.url + " is interrupted", e);
} catch (IOException e) {
throw new ProxyCacheException("Error reading data from " + sourceInfo.url, e);
}
}
private void fetchContentInfo() throws ProxyCacheException {
Logger.debug("Read content info from " + sourceInfo.url);
HttpURLConnection urlConnection = null;
InputStream inputStream = null;
try {
urlConnection = openConnection(0, 10000);
long length = getContentLength(urlConnection);
String mime = urlConnection.getContentType();
inputStream = urlConnection.getInputStream();
this.sourceInfo = new SourceInfo(sourceInfo.url, length, mime);
this.sourceInfoStorage.put(sourceInfo.url, sourceInfo);
Logger.debug("Source info fetched: " + sourceInfo);
} catch (IOException e) {
Logger.error("Error fetching info from " + sourceInfo.url);
} finally {
ProxyCacheUtils.close(inputStream);
if (urlConnection != null) {
urlConnection.disconnect();
}
}
}
private HttpURLConnection openConnection(long offset, int timeout) throws IOException, ProxyCacheException {
HttpURLConnection connection;
boolean redirected;
int redirectCount = 0;
String url = this.sourceInfo.url;
do {
Logger.debug("Open connection " + (offset > 0 ? " with offset " + offset : "") + " to " + url);
connection = (HttpURLConnection) new URL(url).openConnection();
injectCustomHeaders(connection, url);
if (offset > 0) {
connection.setRequestProperty("Range", "bytes=" + offset + "-");
}
if (timeout > 0) {
connection.setConnectTimeout(timeout);
connection.setReadTimeout(timeout);
}
int code = connection.getResponseCode();
redirected = code == HTTP_MOVED_PERM || code == HTTP_MOVED_TEMP || code == HTTP_SEE_OTHER;
if (redirected) {
url = connection.getHeaderField("Location");
redirectCount++;
connection.disconnect();
}
if (redirectCount > MAX_REDIRECTS) {
throw new ProxyCacheException("Too many redirects: " + redirectCount);
}
} while (redirected);
return connection;
}
private void injectCustomHeaders(HttpURLConnection connection, String url) {
Map<String, String> extraHeaders = headerInjector.addHeaders(url);
for (Map.Entry<String, String> header : extraHeaders.entrySet()) {
connection.setRequestProperty(header.getKey(), header.getValue());
}
}
public synchronized String getMime() throws ProxyCacheException {
if (TextUtils.isEmpty(sourceInfo.mime)) {
fetchContentInfo();
}
return sourceInfo.mime;
}
public String getUrl() {
return sourceInfo.url;
}
@Override
public String toString() {
return "HttpUrlSource{sourceInfo='" + sourceInfo + "}";
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoCache/src/main/java/com/yc/videocache/IgnoreHostProxySelector.java | Java | package com.yc.videocache;
import java.io.IOException;
import java.net.Proxy;
import java.net.ProxySelector;
import java.net.SocketAddress;
import java.net.URI;
import java.util.Arrays;
import java.util.List;
import static com.yc.videocache.Preconditions.checkNotNull;
/**
* {@link ProxySelector} that ignore system default proxies for concrete host.
* <p>
* It is important to <a href="https://github.com/danikula/AndroidVideoCache/issues/28">ignore system proxy</a> for localhost connection.
*
*/
class IgnoreHostProxySelector extends ProxySelector {
private static final List<Proxy> NO_PROXY_LIST = Arrays.asList(Proxy.NO_PROXY);
private final ProxySelector defaultProxySelector;
private final String hostToIgnore;
private final int portToIgnore;
IgnoreHostProxySelector(ProxySelector defaultProxySelector, String hostToIgnore, int portToIgnore) {
this.defaultProxySelector = checkNotNull(defaultProxySelector);
this.hostToIgnore = checkNotNull(hostToIgnore);
this.portToIgnore = portToIgnore;
}
static void install(String hostToIgnore, int portToIgnore) {
ProxySelector defaultProxySelector = ProxySelector.getDefault();
ProxySelector ignoreHostProxySelector = new IgnoreHostProxySelector(defaultProxySelector, hostToIgnore, portToIgnore);
ProxySelector.setDefault(ignoreHostProxySelector);
}
@Override
public List<Proxy> select(URI uri) {
boolean ignored = hostToIgnore.equals(uri.getHost()) && portToIgnore == uri.getPort();
return ignored ? NO_PROXY_LIST : defaultProxySelector.select(uri);
}
@Override
public void connectFailed(URI uri, SocketAddress address, IOException failure) {
defaultProxySelector.connectFailed(uri, address, failure);
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoCache/src/main/java/com/yc/videocache/InterruptedProxyCacheException.java | Java | package com.yc.videocache;
/**
* Indicates interruption error in work of {@link ProxyCache} fired by user.
*/
public class InterruptedProxyCacheException extends ProxyCacheException {
public InterruptedProxyCacheException(String message) {
super(message);
}
public InterruptedProxyCacheException(String message, Throwable cause) {
super(message, cause);
}
public InterruptedProxyCacheException(Throwable cause) {
super(cause);
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoCache/src/main/java/com/yc/videocache/Logger.java | Java | package com.yc.videocache;
import android.util.Log;
public final class Logger {
private static final String TAG = "VideoCache";
private static boolean IS_DEBUG = false;
public static void debug(String msg) {
if (IS_DEBUG) {
Log.d(TAG, msg);
}
}
public static void info(String msg) {
if (IS_DEBUG) {
Log.i(TAG, msg);
}
}
public static void warn(String msg) {
if (IS_DEBUG) {
Log.w(TAG, msg);
}
}
public static void error(String msg) {
if (IS_DEBUG) {
Log.e(TAG, msg);
}
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoCache/src/main/java/com/yc/videocache/Pinger.java | Java | package com.yc.videocache;
import java.io.IOException;
import java.io.OutputStream;
import java.net.Proxy;
import java.net.ProxySelector;
import java.net.Socket;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.Arrays;
import java.util.List;
import java.util.Locale;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeoutException;
import static com.yc.videocache.Preconditions.checkArgument;
import static com.yc.videocache.Preconditions.checkNotNull;
import static java.util.concurrent.TimeUnit.MILLISECONDS;
/**
* Pings {@link HttpProxyCacheServer} to make sure it works.
*/
class Pinger {
private static final String PING_REQUEST = "ping";
private static final String PING_RESPONSE = "ping ok";
private final ExecutorService pingExecutor = Executors.newSingleThreadExecutor();
private final String host;
private final int port;
Pinger(String host, int port) {
this.host = checkNotNull(host);
this.port = port;
}
boolean ping(int maxAttempts, int startTimeout) {
checkArgument(maxAttempts >= 1);
checkArgument(startTimeout > 0);
int timeout = startTimeout;
int attempts = 0;
while (attempts < maxAttempts) {
try {
Future<Boolean> pingFuture = pingExecutor.submit(new PingCallable());
boolean pinged = pingFuture.get(timeout, MILLISECONDS);
if (pinged) {
return true;
}
} catch (TimeoutException e) {
Logger.warn("Error pinging server (attempt: " + attempts + ", timeout: " + timeout + "). ");
} catch (InterruptedException | ExecutionException e) {
Logger.error("Error pinging server due to unexpected error");
}
attempts++;
timeout *= 2;
}
String error = String.format(Locale.US, "Error pinging server (attempts: %d, max timeout: %d). " +
"If you see this message, please, report at https://github.com/danikula/AndroidVideoCache/issues/134. " +
"Default proxies are: %s"
, attempts, timeout / 2, getDefaultProxies());
Logger.error(error);
return false;
}
private List<Proxy> getDefaultProxies() {
try {
ProxySelector defaultProxySelector = ProxySelector.getDefault();
return defaultProxySelector.select(new URI(getPingUrl()));
} catch (URISyntaxException e) {
throw new IllegalStateException(e);
}
}
boolean isPingRequest(String request) {
return PING_REQUEST.equals(request);
}
void responseToPing(Socket socket) throws IOException {
OutputStream out = socket.getOutputStream();
out.write("HTTP/1.1 200 OK\n\n".getBytes());
out.write(PING_RESPONSE.getBytes());
}
private boolean pingServer() throws ProxyCacheException {
String pingUrl = getPingUrl();
HttpUrlSource source = new HttpUrlSource(pingUrl);
try {
byte[] expectedResponse = PING_RESPONSE.getBytes();
source.open(0);
byte[] response = new byte[expectedResponse.length];
source.read(response);
boolean pingOk = Arrays.equals(expectedResponse, response);
Logger.info("Ping response: `" + new String(response) + "`, pinged? " + pingOk);
return pingOk;
} catch (ProxyCacheException e) {
Logger.error("Error reading ping response");
return false;
} finally {
source.close();
}
}
private String getPingUrl() {
return String.format(Locale.US, "http://%s:%d/%s", host, port, PING_REQUEST);
}
private class PingCallable implements Callable<Boolean> {
@Override
public Boolean call() throws Exception {
return pingServer();
}
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoCache/src/main/java/com/yc/videocache/Preconditions.java | Java | package com.yc.videocache;
public final class Preconditions {
public static <T> T checkNotNull(T reference) {
if (reference == null) {
throw new NullPointerException();
}
return reference;
}
public static void checkAllNotNull(Object... references) {
for (Object reference : references) {
if (reference == null) {
throw new NullPointerException();
}
}
}
public static <T> T checkNotNull(T reference, String errorMessage) {
if (reference == null) {
throw new NullPointerException(errorMessage);
}
return reference;
}
static void checkArgument(boolean expression) {
if (!expression) {
throw new IllegalArgumentException();
}
}
static void checkArgument(boolean expression, String errorMessage) {
if (!expression) {
throw new IllegalArgumentException(errorMessage);
}
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoCache/src/main/java/com/yc/videocache/ProxyCache.java | Java | package com.yc.videocache;
import java.util.concurrent.atomic.AtomicInteger;
import static com.yc.videocache.Preconditions.checkNotNull;
/**
* Proxy for {@link Source} with caching support ({@link Cache}).
* <p/>
* Can be used only for sources with persistent data (that doesn't change with time).
* Method {@link #read(byte[], long, int)} will be blocked while fetching data from source.
* Useful for streaming something with caching e.g. streaming video/audio etc.
*/
class ProxyCache {
private static final int MAX_READ_SOURCE_ATTEMPTS = 1;
private final Source source;
private final Cache cache;
private final Object wc = new Object();
private final Object stopLock = new Object();
private final AtomicInteger readSourceErrorsCount;
private volatile Thread sourceReaderThread;
private volatile boolean stopped;
private volatile int percentsAvailable = -1;
public ProxyCache(Source source, Cache cache) {
this.source = checkNotNull(source);
this.cache = checkNotNull(cache);
this.readSourceErrorsCount = new AtomicInteger();
}
public int read(byte[] buffer, long offset, int length) throws ProxyCacheException {
ProxyCacheUtils.assertBuffer(buffer, offset, length);
while (!cache.isCompleted() && cache.available() < (offset + length) && !stopped) {
readSourceAsync();
waitForSourceData();
checkReadSourceErrorsCount();
}
int read = cache.read(buffer, offset, length);
if (cache.isCompleted() && percentsAvailable != 100) {
percentsAvailable = 100;
onCachePercentsAvailableChanged(100);
}
return read;
}
private void checkReadSourceErrorsCount() throws ProxyCacheException {
int errorsCount = readSourceErrorsCount.get();
if (errorsCount >= MAX_READ_SOURCE_ATTEMPTS) {
readSourceErrorsCount.set(0);
throw new ProxyCacheException("Error reading source " + errorsCount + " times");
}
}
public void shutdown() {
synchronized (stopLock) {
Logger.debug("Shutdown proxy for " + source);
try {
stopped = true;
if (sourceReaderThread != null) {
sourceReaderThread.interrupt();
}
cache.close();
} catch (ProxyCacheException e) {
onError(e);
}
}
}
private synchronized void readSourceAsync() throws ProxyCacheException {
boolean readingInProgress = sourceReaderThread != null && sourceReaderThread.getState() != Thread.State.TERMINATED;
if (!stopped && !cache.isCompleted() && !readingInProgress) {
sourceReaderThread = new Thread(new SourceReaderRunnable(), "Source reader for " + source);
sourceReaderThread.start();
}
}
private void waitForSourceData() throws ProxyCacheException {
synchronized (wc) {
try {
wc.wait(1000);
} catch (InterruptedException e) {
throw new ProxyCacheException("Waiting source data is interrupted!", e);
}
}
}
private void notifyNewCacheDataAvailable(long cacheAvailable, long sourceAvailable) {
onCacheAvailable(cacheAvailable, sourceAvailable);
synchronized (wc) {
wc.notifyAll();
}
}
protected void onCacheAvailable(long cacheAvailable, long sourceLength) {
boolean zeroLengthSource = sourceLength == 0;
int percents = zeroLengthSource ? 100 : (int) ((float) cacheAvailable / sourceLength * 100);
boolean percentsChanged = percents != percentsAvailable;
boolean sourceLengthKnown = sourceLength >= 0;
if (sourceLengthKnown && percentsChanged) {
onCachePercentsAvailableChanged(percents);
}
percentsAvailable = percents;
}
protected void onCachePercentsAvailableChanged(int percentsAvailable) {
}
private void readSource() {
long sourceAvailable = -1;
long offset = 0;
try {
offset = cache.available();
source.open(offset);
sourceAvailable = source.length();
byte[] buffer = new byte[ProxyCacheUtils.DEFAULT_BUFFER_SIZE];
int readBytes;
while ((readBytes = source.read(buffer)) != -1) {
synchronized (stopLock) {
if (isStopped()) {
return;
}
cache.append(buffer, readBytes);
}
offset += readBytes;
notifyNewCacheDataAvailable(offset, sourceAvailable);
}
tryComplete();
onSourceRead();
} catch (Throwable e) {
readSourceErrorsCount.incrementAndGet();
onError(e);
} finally {
closeSource();
notifyNewCacheDataAvailable(offset, sourceAvailable);
}
}
private void onSourceRead() {
// guaranteed notify listeners after source read and cache completed
percentsAvailable = 100;
onCachePercentsAvailableChanged(percentsAvailable);
}
private void tryComplete() throws ProxyCacheException {
synchronized (stopLock) {
if (!isStopped() && cache.available() == source.length()) {
cache.complete();
}
}
}
private boolean isStopped() {
return Thread.currentThread().isInterrupted() || stopped;
}
private void closeSource() {
try {
source.close();
} catch (ProxyCacheException e) {
onError(new ProxyCacheException("Error closing source " + source, e));
}
}
protected final void onError(final Throwable e) {
boolean interruption = e instanceof InterruptedProxyCacheException;
if (interruption) {
Logger.debug("ProxyCache is interrupted");
} else {
Logger.error("ProxyCache error");
}
}
private class SourceReaderRunnable implements Runnable {
@Override
public void run() {
readSource();
}
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoCache/src/main/java/com/yc/videocache/ProxyCacheException.java | Java | package com.yc.videocache;
/**
* Indicates any error in work of {@link ProxyCache}.
*/
public class ProxyCacheException extends Exception {
private static final String LIBRARY_VERSION = ". Version: " + BuildConfig.VERSION_NAME;
public ProxyCacheException(String message) {
super(message + LIBRARY_VERSION);
}
public ProxyCacheException(String message, Throwable cause) {
super(message + LIBRARY_VERSION, cause);
}
public ProxyCacheException(Throwable cause) {
super("No explanation error" + LIBRARY_VERSION, cause);
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoCache/src/main/java/com/yc/videocache/ProxyCacheUtils.java | Java | package com.yc.videocache;
import android.text.TextUtils;
import android.webkit.MimeTypeMap;
import java.io.Closeable;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.net.URLEncoder;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
import static com.yc.videocache.Preconditions.checkArgument;
import static com.yc.videocache.Preconditions.checkNotNull;
/**
* Just simple utils.
*/
public class ProxyCacheUtils {
static final int DEFAULT_BUFFER_SIZE = 8 * 1024;
static final int MAX_ARRAY_PREVIEW = 16;
static String getSupposablyMime(String url) {
MimeTypeMap mimes = MimeTypeMap.getSingleton();
String extension = MimeTypeMap.getFileExtensionFromUrl(url);
return TextUtils.isEmpty(extension) ? null : mimes.getMimeTypeFromExtension(extension);
}
static void assertBuffer(byte[] buffer, long offset, int length) {
checkNotNull(buffer, "Buffer must be not null!");
checkArgument(offset >= 0, "Data offset must be positive!");
checkArgument(length >= 0 && length <= buffer.length, "Length must be in range [0..buffer.length]");
}
static String preview(byte[] data, int length) {
int previewLength = Math.min(MAX_ARRAY_PREVIEW, Math.max(length, 0));
byte[] dataRange = Arrays.copyOfRange(data, 0, previewLength);
String preview = Arrays.toString(dataRange);
if (previewLength < length) {
preview = preview.substring(0, preview.length() - 1) + ", ...]";
}
return preview;
}
static String encode(String url) {
try {
return URLEncoder.encode(url, "utf-8");
} catch (UnsupportedEncodingException e) {
throw new RuntimeException("Error encoding url", e);
}
}
static String decode(String url) {
try {
return URLDecoder.decode(url, "utf-8");
} catch (UnsupportedEncodingException e) {
throw new RuntimeException("Error decoding url", e);
}
}
static void close(Closeable closeable) {
if (closeable != null) {
try {
closeable.close();
} catch (IOException e) {
Logger.error("Error closing resource");
}
}
}
public static String computeMD5(String string) {
try {
MessageDigest messageDigest = MessageDigest.getInstance("MD5");
byte[] digestBytes = messageDigest.digest(string.getBytes());
return bytesToHexString(digestBytes);
} catch (NoSuchAlgorithmException e) {
throw new IllegalStateException(e);
}
}
private static String bytesToHexString(byte[] bytes) {
StringBuffer sb = new StringBuffer();
for (byte b : bytes) {
sb.append(String.format("%02x", b));
}
return sb.toString();
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoCache/src/main/java/com/yc/videocache/Source.java | Java | package com.yc.videocache;
/**
* Source for proxy.
*/
public interface Source {
/**
* Opens source. Source should be open before using {@link #read(byte[])}
*
* @param offset offset in bytes for source.
* @throws ProxyCacheException if error occur while opening source.
*/
void open(long offset) throws ProxyCacheException;
/**
* Returns length bytes or <b>negative value</b> if length is unknown.
*
* @return bytes length
* @throws ProxyCacheException if error occur while fetching source data.
*/
long length() throws ProxyCacheException;
/**
* Read data to byte buffer from source with current offset.
*
* @param buffer a buffer to be used for reading data.
* @return a count of read bytes
* @throws ProxyCacheException if error occur while reading source.
*/
int read(byte[] buffer) throws ProxyCacheException;
/**
* Closes source and release resources. Every opened source should be closed.
*
* @throws ProxyCacheException if error occur while closing source.
*/
void close() throws ProxyCacheException;
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoCache/src/main/java/com/yc/videocache/SourceInfo.java | Java | package com.yc.videocache;
/**
* Stores source's info.
*/
public class SourceInfo {
public final String url;
public final long length;
public final String mime;
public SourceInfo(String url, long length, String mime) {
this.url = url;
this.length = length;
this.mime = mime;
}
@Override
public String toString() {
return "SourceInfo{" +
"url='" + url + '\'' +
", length=" + length +
", mime='" + mime + '\'' +
'}';
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoCache/src/main/java/com/yc/videocache/StorageUtils.java | Java | package com.yc.videocache;
import android.content.Context;
import android.os.Environment;
import java.io.File;
import static android.os.Environment.MEDIA_MOUNTED;
/**
* Provides application storage paths
* @author Sergey Tarasevich (nostra13[at]gmail[dot]com)
* @since 1.0.0
*/
public final class StorageUtils {
private static final String INDIVIDUAL_DIR_NAME = "video-cache";
/**
* Returns individual application cache directory (for only video caching from Proxy). Cache directory will be
* created on SD card <i>("/Android/data/[app_package_name]/cache/video-cache")</i> if card is mounted .
* Else - Android defines cache directory on device's file system.
*
* @param context Application context
* @return Cache {@link File directory}
*/
static File getIndividualCacheDirectory(Context context) {
File cacheDir = getCacheDirectory(context);
return new File(cacheDir, INDIVIDUAL_DIR_NAME);
}
/**
* Returns application cache directory. Cache directory will be created on SD card
* <i>("/Android/data/[app_package_name]/cache")</i> (if card is mounted and app has appropriate permission) or
* on device's file system depending incoming parameters.
*
* @param context Application context
* @return Cache {@link File directory}.<br />
* <b>NOTE:</b> Can be null in some unpredictable cases (if SD card is unmounted and
* {@link Context#getCacheDir() Context.getCacheDir()} returns null).
*/
private static File getCacheDirectory(Context context) {
File appCacheDir = null;
if (MEDIA_MOUNTED.equals(Environment.getExternalStorageState())) {
appCacheDir = context.getExternalCacheDir();
}
if (appCacheDir == null) {
appCacheDir = context.getCacheDir();
}
if (appCacheDir == null) {
String cacheDirPath = "/data/data/" + context.getPackageName() + "/cache/";
appCacheDir = new File(cacheDirPath);
}
return appCacheDir;
}
/**
* 删除文件
* @param root file
* @return 是否删除成功
*/
public static boolean deleteFiles(File root) {
File[] files = root.listFiles();
if (files != null) {
for (File f : files) {
if (!f.isDirectory() && f.exists()) { // 判断是否存在
if (!f.delete()) {
return false;
}
}
}
}
return true;
}
/**
* 删除文件
* @param filePath file路径
* @return 是否删除成功
*/
public static boolean deleteFile(String filePath) {
File file = new File(filePath);
if (file.exists()) {
if (file.isFile()) {
return file.delete();
} else {
String[] filePaths = file.list();
if (filePaths != null) {
for (String path : filePaths) {
deleteFile(filePath + File.separator + path);
}
}
return file.delete();
}
}
return true;
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoCache/src/main/java/com/yc/videocache/cache/PreloadManager.java | Java | package com.yc.videocache.cache;
import android.content.Context;
import com.yc.videocache.HttpProxyCacheServer;
import com.yc.videocache.Logger;
import java.io.File;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* 预加载工具，使用AndroidVideoCache实现
*/
public class PreloadManager {
private static PreloadManager sPreloadManager;
/**
* 单线程池，按照添加顺序依次执行{@link PreloadTask}
*/
private ExecutorService mExecutorService = Executors.newSingleThreadExecutor();
/**
* 保存正在预加载的{@link PreloadTask}
*/
private LinkedHashMap<String, PreloadTask> mPreloadTasks = new LinkedHashMap<>();
/**
* 标识是否需要预加载
*/
private boolean mIsStartPreload = true;
private HttpProxyCacheServer mHttpProxyCacheServer;
/**
* 预加载的大小，每个视频预加载512KB，这个参数可根据实际情况调整
*/
public static final int PRELOAD_LENGTH = 512 * 1024;
private PreloadManager(Context context) {
mHttpProxyCacheServer = ProxyVideoCacheManager.getProxy(context);
}
public static PreloadManager getInstance(Context context) {
if (sPreloadManager == null) {
synchronized (PreloadManager.class) {
if (sPreloadManager == null) {
sPreloadManager = new PreloadManager(context.getApplicationContext());
}
}
}
return sPreloadManager;
}
/**
* 开始预加载
*
* @param rawUrl 原始视频地址
*/
public void addPreloadTask(String rawUrl, int position) {
if (isPreloaded(rawUrl)) {
return;
}
PreloadTask task = new PreloadTask();
task.mRawUrl = rawUrl;
task.mPosition = position;
task.mCacheServer = mHttpProxyCacheServer;
Logger.info("addPreloadTask: " + position);
mPreloadTasks.put(rawUrl, task);
if (mIsStartPreload) {
//开始预加载
task.executeOn(mExecutorService);
}
}
/**
* 判断该播放地址是否已经预加载
*/
private boolean isPreloaded(String rawUrl) {
//先判断是否有缓存文件，如果已经存在缓存文件，并且其大小大于1KB，则表示已经预加载完成了
File cacheFile = mHttpProxyCacheServer.getCacheFile(rawUrl);
if (cacheFile.exists()) {
if (cacheFile.length() >= 1024) {
return true;
} else {
//这种情况一般是缓存出错，把缓存删掉，重新缓存
cacheFile.delete();
return false;
}
}
//再判断是否有临时缓存文件，如果已经存在临时缓存文件，并且临时缓存文件超过了预加载大小，则表示已经预加载完成了
File tempCacheFile = mHttpProxyCacheServer.getTempCacheFile(rawUrl);
if (tempCacheFile.exists()) {
return tempCacheFile.length() >= PRELOAD_LENGTH;
}
return false;
}
/**
* 暂停预加载
* 根据是否反向滑动取消在position之下或之上的PreloadTask
*
* @param position 当前滑到的位置
* @param isReverseScroll 列表是否反向滑动
*/
public void pausePreload(int position, boolean isReverseScroll) {
Logger.info("pausePreload：" + position + " isReverseScroll: " + isReverseScroll);
mIsStartPreload = false;
for (Map.Entry<String, PreloadTask> next : mPreloadTasks.entrySet()) {
PreloadTask task = next.getValue();
if (isReverseScroll) {
if (task.mPosition >= position) {
task.cancel();
}
} else {
if (task.mPosition <= position) {
task.cancel();
}
}
}
}
/**
* 恢复预加载
* 根据是否反向滑动开始在position之下或之上的PreloadTask
*
* @param position 当前滑到的位置
* @param isReverseScroll 列表是否反向滑动
*/
public void resumePreload(int position, boolean isReverseScroll) {
Logger.info("resumePreload：" + position + " isReverseScroll: " + isReverseScroll);
mIsStartPreload = true;
for (Map.Entry<String, PreloadTask> next : mPreloadTasks.entrySet()) {
PreloadTask task = next.getValue();
if (isReverseScroll) {
if (task.mPosition < position) {
if (!isPreloaded(task.mRawUrl)) {
task.executeOn(mExecutorService);
}
}
} else {
if (task.mPosition > position) {
if (!isPreloaded(task.mRawUrl)) {
task.executeOn(mExecutorService);
}
}
}
}
}
/**
* 通过原始地址取消预加载
*
* @param rawUrl 原始地址
*/
public void removePreloadTask(String rawUrl) {
PreloadTask task = mPreloadTasks.get(rawUrl);
if (task != null) {
task.cancel();
mPreloadTasks.remove(rawUrl);
}
}
/**
* 取消所有的预加载
*/
public void removeAllPreloadTask() {
Iterator<Map.Entry<String, PreloadTask>> iterator = mPreloadTasks.entrySet().iterator();
while (iterator.hasNext()) {
Map.Entry<String, PreloadTask> next = iterator.next();
PreloadTask task = next.getValue();
task.cancel();
iterator.remove();
}
}
/**
* 获取播放地址
*/
public String getPlayUrl(String rawUrl) {
PreloadTask task = mPreloadTasks.get(rawUrl);
if (task != null) {
task.cancel();
}
if (isPreloaded(rawUrl)) {
return mHttpProxyCacheServer.getProxyUrl(rawUrl);
} else {
return rawUrl;
}
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoCache/src/main/java/com/yc/videocache/cache/PreloadTask.java | Java | package com.yc.videocache.cache;
import com.yc.videocache.HttpProxyCacheServer;
import com.yc.videocache.Logger;
import java.io.BufferedInputStream;
import java.io.File;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.concurrent.ExecutorService;
public class PreloadTask implements Runnable {
/**
* 原始地址
*/
public String mRawUrl;
/**
* 列表中的位置
*/
public int mPosition;
/**
* VideoCache服务器
*/
public HttpProxyCacheServer mCacheServer;
/**
* 是否被取消
*/
private boolean mIsCanceled;
/**
* 是否正在预加载
*/
private boolean mIsExecuted;
@Override
public void run() {
if (!mIsCanceled) {
start();
}
mIsExecuted = false;
mIsCanceled = false;
}
/**
* 开始预加载
*/
private void start() {
Logger.info("开始预加载：" + mPosition);
HttpURLConnection connection = null;
try {
//获取HttpProxyCacheServer的代理地址
String proxyUrl = mCacheServer.getProxyUrl(mRawUrl);
URL url = new URL(proxyUrl);
connection = (HttpURLConnection) url.openConnection();
connection.setConnectTimeout(5_000);
connection.setReadTimeout(5_000);
InputStream in = new BufferedInputStream(connection.getInputStream());
int length;
int read = -1;
byte[] bytes = new byte[8 * 1024];
while ((length = in.read(bytes)) != -1) {
read += length;
//预加载完成或者取消预加载
if (mIsCanceled || read >= PreloadManager.PRELOAD_LENGTH) {
Logger.info("结束预加载：" + mPosition);
break;
}
}
if (read == -1) { //这种情况一般是预加载出错了，删掉缓存
Logger.info("预加载失败：" + mPosition);
File cacheFile = mCacheServer.getCacheFile(mRawUrl);
if (cacheFile.exists()) {
cacheFile.delete();
}
}
} catch (Exception e) {
Logger.info("异常结束预加载：" + mPosition);
} finally {
if (connection != null) {
connection.disconnect();
}
}
}
/**
* 将预加载任务提交到线程池，准备执行
*/
public void executeOn(ExecutorService executorService) {
if (mIsExecuted) {
return;
}
mIsExecuted = true;
executorService.submit(this);
}
/**
* 取消预加载任务
*/
public void cancel() {
if (mIsExecuted) {
mIsCanceled = true;
}
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoCache/src/main/java/com/yc/videocache/cache/ProxyVideoCacheManager.java | Java | package com.yc.videocache.cache;
import android.content.Context;
import com.yc.videocache.HttpProxyCacheServer;
import com.yc.videocache.StorageUtils;
import java.io.File;
public class ProxyVideoCacheManager {
private static HttpProxyCacheServer sharedProxy;
private ProxyVideoCacheManager() {
}
public static HttpProxyCacheServer getProxy(Context context) {
return sharedProxy == null ? (sharedProxy = newProxy(context)) : sharedProxy;
}
private static HttpProxyCacheServer newProxy(Context context) {
return new HttpProxyCacheServer.Builder(context)
.maxCacheSize(512 * 1024 * 1024) // 512MB for cache
//缓存路径，不设置默认在sd_card/Android/data/[app_package_name]/cache中
//.cacheDirectory()
.build();
}
/**
* 删除所有缓存文件
* @return 返回缓存是否删除成功
*/
public static boolean clearAllCache(Context context) {
getProxy(context);
return StorageUtils.deleteFiles(sharedProxy.getCacheRoot());
}
/**
* 删除url对应默认缓存文件
* @return 返回缓存是否删除成功
*/
public static boolean clearDefaultCache(Context context, String url) {
getProxy(context);
File pathTmp = sharedProxy.getTempCacheFile(url);
File path = sharedProxy.getCacheFile(url);
return StorageUtils.deleteFile(pathTmp.getAbsolutePath()) &&
StorageUtils.deleteFile(path.getAbsolutePath());
}
} | yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoCache/src/main/java/com/yc/videocache/file/DiskUsage.java | Java | package com.yc.videocache.file;
import java.io.File;
import java.io.IOException;
/**
* Declares how {@link FileCache} will use disc space.
*/
public interface DiskUsage {
void touch(File file) throws IOException;
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoCache/src/main/java/com/yc/videocache/file/FileCache.java | Java | package com.yc.videocache.file;
import com.yc.videocache.Cache;
import com.yc.videocache.ProxyCacheException;
import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
/**
* {@link Cache} that uses file for storing data.
*/
public class FileCache implements Cache {
private static final String TEMP_POSTFIX = ".download";
private final DiskUsage diskUsage;
public File file;
private RandomAccessFile dataFile;
public FileCache(File file) throws ProxyCacheException {
this(file, new UnlimitedDiskUsage());
}
public FileCache(File file, DiskUsage diskUsage) throws ProxyCacheException {
try {
if (diskUsage == null) {
throw new NullPointerException();
}
this.diskUsage = diskUsage;
File directory = file.getParentFile();
Files.makeDir(directory);
boolean completed = file.exists();
this.file = completed ? file : new File(file.getParentFile(), file.getName() + TEMP_POSTFIX);
this.dataFile = new RandomAccessFile(this.file, completed ? "r" : "rw");
} catch (IOException e) {
throw new ProxyCacheException("Error using file " + file + " as disc cache", e);
}
}
@Override
public synchronized long available() throws ProxyCacheException {
try {
return (int) dataFile.length();
} catch (IOException e) {
throw new ProxyCacheException("Error reading length of file " + file, e);
}
}
@Override
public synchronized int read(byte[] buffer, long offset, int length) throws ProxyCacheException {
try {
dataFile.seek(offset);
return dataFile.read(buffer, 0, length);
} catch (IOException e) {
String format = "Error reading %d bytes with offset %d from file[%d bytes] to buffer[%d bytes]";
throw new ProxyCacheException(String.format(format, length, offset, available(), buffer.length), e);
}
}
@Override
public synchronized void append(byte[] data, int length) throws ProxyCacheException {
try {
if (isCompleted()) {
throw new ProxyCacheException("Error append cache: cache file " + file + " is completed!");
}
dataFile.seek(available());
dataFile.write(data, 0, length);
} catch (IOException e) {
String format = "Error writing %d bytes to %s from buffer with size %d";
throw new ProxyCacheException(String.format(format, length, dataFile, data.length), e);
}
}
@Override
public synchronized void close() throws ProxyCacheException {
try {
dataFile.close();
diskUsage.touch(file);
} catch (IOException e) {
throw new ProxyCacheException("Error closing file " + file, e);
}
}
@Override
public synchronized void complete() throws ProxyCacheException {
if (isCompleted()) {
return;
}
close();
String fileName = file.getName().substring(0, file.getName().length() - TEMP_POSTFIX.length());
File completedFile = new File(file.getParentFile(), fileName);
boolean renamed = file.renameTo(completedFile);
if (!renamed) {
throw new ProxyCacheException("Error renaming file " + file + " to " + completedFile + " for completion!");
}
file = completedFile;
try {
dataFile = new RandomAccessFile(file, "r");
diskUsage.touch(file);
} catch (IOException e) {
throw new ProxyCacheException("Error opening " + file + " as disc cache", e);
}
}
@Override
public synchronized boolean isCompleted() {
return !isTempFile(file);
}
/**
* Returns file to be used fo caching. It may as original file passed in constructor as some temp file for not completed cache.
*
* @return file for caching.
*/
public File getFile() {
return file;
}
private boolean isTempFile(File file) {
return file.getName().endsWith(TEMP_POSTFIX);
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoCache/src/main/java/com/yc/videocache/file/FileNameGenerator.java | Java | package com.yc.videocache.file;
/**
* Generator for files to be used for caching.
*/
public interface FileNameGenerator {
String generate(String url);
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoCache/src/main/java/com/yc/videocache/file/Files.java | Java | package com.yc.videocache.file;
import com.yc.videocache.Logger;
import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.LinkedList;
import java.util.List;
/**
* Utils for work with files.
*
*/
class Files {
static void makeDir(File directory) throws IOException {
if (directory.exists()) {
if (!directory.isDirectory()) {
throw new IOException("File " + directory + " is not directory!");
}
} else {
boolean isCreated = directory.mkdirs();
if (!isCreated) {
throw new IOException(String.format("Directory %s can't be created", directory.getAbsolutePath()));
}
}
}
static List<File> getLruListFiles(File directory) {
List<File> result = new LinkedList<>();
File[] files = directory.listFiles();
if (files != null) {
result = Arrays.asList(files);
Collections.sort(result, new LastModifiedComparator());
}
return result;
}
static void setLastModifiedNow(File file) throws IOException {
if (file.exists()) {
long now = System.currentTimeMillis();
boolean modified = file.setLastModified(now); // on some devices (e.g. Nexus 5) doesn't work
if (!modified) {
modify(file);
if (file.lastModified() < now) {
// NOTE: apparently this is a known issue (see: http://stackoverflow.com/questions/6633748/file-lastmodified-is-never-what-was-set-with-file-setlastmodified)
Logger.warn(String.format("Last modified date %s is not set for file %s", new Date(file.lastModified()), file.getAbsolutePath()));
}
}
}
}
static void modify(File file) throws IOException {
long size = file.length();
if (size == 0) {
recreateZeroSizeFile(file);
return;
}
RandomAccessFile accessFile = new RandomAccessFile(file, "rwd");
accessFile.seek(size - 1);
byte lastByte = accessFile.readByte();
accessFile.seek(size - 1);
accessFile.write(lastByte);
accessFile.close();
}
private static void recreateZeroSizeFile(File file) throws IOException {
if (!file.delete() || !file.createNewFile()) {
throw new IOException("Error recreate zero-size file " + file);
}
}
private static final class LastModifiedComparator implements Comparator<File> {
@Override
public int compare(File lhs, File rhs) {
return compareLong(lhs.lastModified(), rhs.lastModified());
}
private int compareLong(long first, long second) {
return (first < second) ? -1 : ((first == second) ? 0 : 1);
}
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoCache/src/main/java/com/yc/videocache/file/LruDiskUsage.java | Java | package com.yc.videocache.file;
import com.yc.videocache.Logger;
import java.io.File;
import java.io.IOException;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* {@link DiskUsage} that uses LRU (Least Recently Used) strategy to trim cache.
*
*/
public abstract class LruDiskUsage implements DiskUsage {
private final ExecutorService workerThread = Executors.newSingleThreadExecutor();
@Override
public void touch(File file) throws IOException {
workerThread.submit(new TouchCallable(file));
}
private void touchInBackground(File file) throws IOException {
Files.setLastModifiedNow(file);
List<File> files = Files.getLruListFiles(file.getParentFile());
trim(files);
}
protected abstract boolean accept(File file, long totalSize, int totalCount);
private void trim(List<File> files) {
long totalSize = countTotalSize(files);
int totalCount = files.size();
for (File file : files) {
boolean accepted = accept(file, totalSize, totalCount);
if (!accepted) {
long fileSize = file.length();
boolean deleted = file.delete();
if (deleted) {
totalCount--;
totalSize -= fileSize;
Logger.info("Cache file " + file + " is deleted because it exceeds cache limit");
} else {
Logger.error("Error deleting file " + file + " for trimming cache");
}
}
}
}
private long countTotalSize(List<File> files) {
long totalSize = 0;
for (File file : files) {
totalSize += file.length();
}
return totalSize;
}
private class TouchCallable implements Callable<Void> {
private final File file;
public TouchCallable(File file) {
this.file = file;
}
@Override
public Void call() throws Exception {
touchInBackground(file);
return null;
}
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoCache/src/main/java/com/yc/videocache/file/Md5FileNameGenerator.java | Java | package com.yc.videocache.file;
import android.text.TextUtils;
import com.yc.videocache.ProxyCacheUtils;
/**
* Implementation of {@link FileNameGenerator} that uses MD5 of url as file name
*
*/
public class Md5FileNameGenerator implements FileNameGenerator {
private static final int MAX_EXTENSION_LENGTH = 4;
@Override
public String generate(String url) {
String extension = getExtension(url);
String name = ProxyCacheUtils.computeMD5(url);
return TextUtils.isEmpty(extension) ? name : name + "." + extension;
}
private String getExtension(String url) {
int dotIndex = url.lastIndexOf('.');
int slashIndex = url.lastIndexOf('/');
return dotIndex != -1 && dotIndex > slashIndex && dotIndex + 2 + MAX_EXTENSION_LENGTH > url.length() ?
url.substring(dotIndex + 1, url.length()) : "";
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoCache/src/main/java/com/yc/videocache/file/TotalCountLruDiskUsage.java | Java | package com.yc.videocache.file;
import java.io.File;
/**
* {@link DiskUsage} that uses LRU (Least Recently Used) strategy and trims cache size to max files count if needed.
*
*/
public class TotalCountLruDiskUsage extends LruDiskUsage {
private final int maxCount;
public TotalCountLruDiskUsage(int maxCount) {
if (maxCount <= 0) {
throw new IllegalArgumentException("Max count must be positive number!");
}
this.maxCount = maxCount;
}
@Override
protected boolean accept(File file, long totalSize, int totalCount) {
return totalCount <= maxCount;
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoCache/src/main/java/com/yc/videocache/file/TotalSizeLruDiskUsage.java | Java | package com.yc.videocache.file;
import java.io.File;
/**
* {@link DiskUsage} that uses LRU (Least Recently Used) strategy and trims cache size to max size if needed.
*/
public class TotalSizeLruDiskUsage extends LruDiskUsage {
private final long maxSize;
public TotalSizeLruDiskUsage(long maxSize) {
if (maxSize <= 0) {
throw new IllegalArgumentException("Max size must be positive number!");
}
this.maxSize = maxSize;
}
@Override
protected boolean accept(File file, long totalSize, int totalCount) {
return totalSize <= maxSize;
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoCache/src/main/java/com/yc/videocache/file/UnlimitedDiskUsage.java | Java | package com.yc.videocache.file;
import java.io.File;
import java.io.IOException;
/**
* Unlimited version of {@link DiskUsage}.
*
*/
public class UnlimitedDiskUsage implements DiskUsage {
@Override
public void touch(File file) throws IOException {
// do nothing
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoCache/src/main/java/com/yc/videocache/headers/EmptyHeadersInjector.java | Java | package com.yc.videocache.headers;
import java.util.HashMap;
import java.util.Map;
/**
* Empty {@link HeaderInjector} implementation.
*/
public class EmptyHeadersInjector implements HeaderInjector {
@Override
public Map<String, String> addHeaders(String url) {
return new HashMap<>();
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoCache/src/main/java/com/yc/videocache/headers/HeaderInjector.java | Java | package com.yc.videocache.headers;
import java.util.Map;
/**
* Allows to add custom headers to server's requests.
*
*/
public interface HeaderInjector {
/**
* Adds headers to server's requests for corresponding url.
*
* @param url an url headers will be added for
* @return a map with headers, where keys are header's names, and values are header's values. {@code null} is not acceptable!
*/
Map<String, String> addHeaders(String url);
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoCache/src/main/java/com/yc/videocache/sourcestorage/DatabaseSourceInfoStorage.java | Java | package com.yc.videocache.sourcestorage;
import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
import com.yc.videocache.SourceInfo;
import static com.yc.videocache.Preconditions.checkAllNotNull;
import static com.yc.videocache.Preconditions.checkNotNull;
/**
* Database based {@link SourceInfoStorage}.
*
*/
class DatabaseSourceInfoStorage extends SQLiteOpenHelper implements SourceInfoStorage {
private static final String TABLE = "SourceInfo";
private static final String COLUMN_ID = "_id";
private static final String COLUMN_URL = "url";
private static final String COLUMN_LENGTH = "length";
private static final String COLUMN_MIME = "mime";
private static final String[] ALL_COLUMNS = new String[]{COLUMN_ID, COLUMN_URL, COLUMN_LENGTH, COLUMN_MIME};
private static final String CREATE_SQL =
"CREATE TABLE " + TABLE + " (" +
COLUMN_ID + " INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL," +
COLUMN_URL + " TEXT NOT NULL," +
COLUMN_MIME + " TEXT," +
COLUMN_LENGTH + " INTEGER" +
");";
DatabaseSourceInfoStorage(Context context) {
super(context, "AndroidVideoCache.db", null, 1);
checkNotNull(context);
}
@Override
public void onCreate(SQLiteDatabase db) {
checkNotNull(db);
db.execSQL(CREATE_SQL);
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
throw new IllegalStateException("Should not be called. There is no any migration");
}
@Override
public SourceInfo get(String url) {
checkNotNull(url);
Cursor cursor = null;
try {
cursor = getReadableDatabase().query(TABLE, ALL_COLUMNS, COLUMN_URL + "=?", new String[]{url}, null, null, null);
return cursor == null || !cursor.moveToFirst() ? null : convert(cursor);
} finally {
if (cursor != null) {
cursor.close();
}
}
}
@Override
public void put(String url, SourceInfo sourceInfo) {
checkAllNotNull(url, sourceInfo);
SourceInfo sourceInfoFromDb = get(url);
boolean exist = sourceInfoFromDb != null;
ContentValues contentValues = convert(sourceInfo);
if (exist) {
getWritableDatabase().update(TABLE, contentValues, COLUMN_URL + "=?", new String[]{url});
} else {
getWritableDatabase().insert(TABLE, null, contentValues);
}
}
@Override
public void release() {
close();
}
private SourceInfo convert(Cursor cursor) {
return new SourceInfo(
cursor.getString(cursor.getColumnIndexOrThrow(COLUMN_URL)),
cursor.getLong(cursor.getColumnIndexOrThrow(COLUMN_LENGTH)),
cursor.getString(cursor.getColumnIndexOrThrow(COLUMN_MIME))
);
}
private ContentValues convert(SourceInfo sourceInfo) {
ContentValues values = new ContentValues();
values.put(COLUMN_URL, sourceInfo.url);
values.put(COLUMN_LENGTH, sourceInfo.length);
values.put(COLUMN_MIME, sourceInfo.mime);
return values;
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoCache/src/main/java/com/yc/videocache/sourcestorage/NoSourceInfoStorage.java | Java | package com.yc.videocache.sourcestorage;
import com.yc.videocache.SourceInfo;
/**
* {@link SourceInfoStorage} that does nothing.
*
*/
public class NoSourceInfoStorage implements SourceInfoStorage {
@Override
public SourceInfo get(String url) {
return null;
}
@Override
public void put(String url, SourceInfo sourceInfo) {
}
@Override
public void release() {
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoCache/src/main/java/com/yc/videocache/sourcestorage/SourceInfoStorage.java | Java | package com.yc.videocache.sourcestorage;
import com.yc.videocache.SourceInfo;
/**
* Storage for {@link SourceInfo}.
*/
public interface SourceInfoStorage {
SourceInfo get(String url);
void put(String url, SourceInfo sourceInfo);
void release();
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoCache/src/main/java/com/yc/videocache/sourcestorage/SourceInfoStorageFactory.java | Java | package com.yc.videocache.sourcestorage;
import android.content.Context;
/**
* Simple factory for {@link SourceInfoStorage}.
*
*/
public class SourceInfoStorageFactory {
public static SourceInfoStorage newSourceInfoStorage(Context context) {
return new DatabaseSourceInfoStorage(context);
}
public static SourceInfoStorage newEmptySourceInfoStorage() {
return new NoSourceInfoStorage();
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoGradle/video.gradle | Gradle | ext {
androidBuildToolsVersion = "29.0.0"
androidMinSdkVersion = 17
androidTargetSdkVersion = 29
androidCompileSdkVersion = 29
constraintLayoutVersion = '1.1.3'
appcompatVersion = '1.2.0'
/**主app-start*/
AppDependencies = [
constraintLayout : "androidx.constraintlayout:constraintlayout:${constraintLayoutVersion}",
appcompat : "androidx.appcompat:appcompat:${appcompatVersion}",
]
} | yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoKernel/build.gradle | Gradle | apply plugin: 'com.android.library'
android {
compileSdkVersion 29
buildToolsVersion "29.0.0"
defaultConfig {
minSdkVersion 17
targetSdkVersion 29
versionCode 36
versionName "3.0.6"
}
buildTypes {
release {
minifyEnabled false
proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
}
}
}
dependencies {
implementation fileTree(dir: "libs", include: ["*.jar"])
//这两个是必须要加的，其它的可供选择
api 'tv.danmaku.ijk.media:ijkplayer-java:0.8.8'
api 'tv.danmaku.ijk.media:ijkplayer-armv7a:0.8.4'
//其他库文件
//implementation 'tv.danmaku.ijk.media:ijkplayer-armv5:0.8.8'
//implementation 'tv.danmaku.ijk.media:ijkplayer-arm64:0.8.8'
//implementation 'tv.danmaku.ijk.media:ijkplayer-x86:0.8.8'
//implementation 'tv.danmaku.ijk.media:ijkplayer-x86_64:0.8.8'
//谷歌播放器
api "com.google.android.exoplayer:exoplayer:2.11.3"
//exoplayer-core：核心功能 (必要)
api "com.google.android.exoplayer:exoplayer-core:2.11.3"
//exoplayer-dash：支持DASH内容
api "com.google.android.exoplayer:exoplayer-dash:2.11.3"
//exoplayer-hls：支持HLS内容
api "com.google.android.exoplayer:exoplayer-hls:2.11.3"
//exoplayer-smoothstreaming：支持SmoothStreaming内容
api "com.google.android.exoplayer:exoplayer-smoothstreaming:2.11.3"
api "com.google.android.exoplayer:extension-rtmp:2.11.3"
}
/** 以下开始是将Android Library上传到jcenter的相关配置**/
apply plugin: 'com.github.dcendents.android-maven'
apply plugin: 'com.jfrog.bintray'
//项目主页
def siteUrl = 'https://github.com/yangchong211/YCVideoPlayer' // project homepage
//项目的版本控制地址
def gitUrl = 'https://github.com/yangchong211/YCVideoPlayer.git' // project git
//发布到组织名称名字，必须填写
group = "cn.yc"
//发布到JCenter上的项目名字，必须填写
def libName = "YCVideoKernelLib"
// 版本号，下次更新是只需要更改版本号即可
version = "3.0.6"
/** 上面配置后上传至jcenter后的编译路径是这样的： compile 'cn.yc:YCVideoKernelLib:1.0.0' **/
//生成源文件
task sourcesJar(type: Jar) {
from android.sourceSets.main.java.srcDirs
classifier = 'sources'
}
//生成文档
task javadoc(type: Javadoc) {
source = android.sourceSets.main.java.srcDirs
classpath += project.files(android.getBootClasspath().join(File.pathSeparator))
options.encoding "UTF-8"
options.charSet 'UTF-8'
options.author true
options.version true
options.links "https://github.com/linglongxin24/FastDev/tree/master/mylibrary/docs/javadoc"
failOnError false
}
//文档打包成jar
task javadocJar(type: Jar, dependsOn: javadoc) {
classifier = 'javadoc'
from javadoc.destinationDir
}
//拷贝javadoc文件
task copyDoc(type: Copy) {
from "${buildDir}/docs/"
into "docs"
}
//上传到jcenter所需要的源码文件
artifacts {
archives javadocJar
archives sourcesJar
}
// 配置maven库，生成POM.xml文件
install {
repositories.mavenInstaller {
// This generates POM.xml with proper parameters
pom {
project {
packaging 'aar'
//项目描述，自由填写
name 'This is video kernel lib'
url siteUrl
licenses {
license {
//开源协议
name 'The Apache Software License, Version 2.0'
url 'http://www.apache.org/licenses/LICENSE-2.0.txt'
}
}
developers {
developer {
//开发者的个人信息，根据个人信息填写
id 'yangchong'
name 'yc'
email 'yangchong211@163.com'
}
}
scm {
connection gitUrl
developerConnection gitUrl
url siteUrl
}
}
}
}
}
//上传到jcenter
Properties properties = new Properties()
properties.load(project.rootProject.file('local.properties').newDataInputStream())
bintray {
user = properties.getProperty("bintray.user") //读取 local.properties 文件里面的 bintray.user
key = properties.getProperty("bintray.apikey") //读取 local.properties 文件里面的 bintray.apikey
configurations = ['archives']
pkg {
repo = "maven"
name = libName //发布到JCenter上的项目名字，必须填写
desc = 'android video kernel' //项目描述
websiteUrl = siteUrl
vcsUrl = gitUrl
licenses = ["Apache-2.0"]
publish = true
}
}
javadoc {
options {
//如果你的项目里面有中文注释的话，必须将格式设置为UTF-8，不然会出现乱码
encoding "UTF-8"
charSet 'UTF-8'
author true
version true
links "http://docs.oracle.com/javase/7/docs/api"
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoKernel/src/main/java/com/yc/kernel/factory/PlayerFactory.java | Java | package com.yc.kernel.factory;
import android.content.Context;
import com.yc.kernel.inter.AbstractVideoPlayer;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2018/11/9
* desc : 此接口使用方法
* revise: 1.继承{@link AbstractVideoPlayer}扩展自己的播放器。
* 2.继承此接口并实现{@link #createPlayer(Context)}，返回步骤1中的播放器。
* </pre>
*/
public abstract class PlayerFactory<T extends AbstractVideoPlayer> {
/**
* 使用工厂模式
* 抽象工厂，担任这个角色的是工厂方法模式的核心，任何在模式中创建对象的工厂类必须实现这个接口
* 具体工厂，具体工厂角色含有与业务密切相关的逻辑，并且受到使用者的调用以创建具体产品对象
*
* 优点1：工厂方法用来创建所需要的产品，同时隐藏了哪种具体产品类将被实例化这一细节，
* 用户只需要关心所需产品对应的工厂，无须关心创建细节，甚至无须知道具体产品类的类名。
* 优点2：加入新的产品时，比如后期新加一个阿里播放器内核，这个时候就只需要添加一个具体工厂和具体产品就可以。
* 系统的可扩展性也就变得非常好，完全符合“开闭原则”
*
* 创建具体的内核播放器Player
* @param context 上下文
* @return 具体的player
*/
public abstract T createPlayer(Context context);
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoKernel/src/main/java/com/yc/kernel/impl/exo/ExoMediaPlayer.java | Java | package com.yc.kernel.impl.exo;
import android.app.Application;
import android.content.Context;
import android.content.res.AssetFileDescriptor;
import android.os.Handler;
import android.view.Surface;
import android.view.SurfaceHolder;
import com.google.android.exoplayer2.DefaultLoadControl;
import com.google.android.exoplayer2.DefaultRenderersFactory;
import com.google.android.exoplayer2.ExoPlaybackException;
import com.google.android.exoplayer2.LoadControl;
import com.google.android.exoplayer2.PlaybackParameters;
import com.google.android.exoplayer2.Player;
import com.google.android.exoplayer2.RenderersFactory;
import com.google.android.exoplayer2.SimpleExoPlayer;
import com.google.android.exoplayer2.analytics.AnalyticsCollector;
import com.google.android.exoplayer2.source.MediaSource;
import com.google.android.exoplayer2.source.MediaSourceEventListener;
import com.google.android.exoplayer2.trackselection.DefaultTrackSelector;
import com.google.android.exoplayer2.trackselection.MappingTrackSelector;
import com.google.android.exoplayer2.trackselection.TrackSelector;
import com.google.android.exoplayer2.upstream.DefaultBandwidthMeter;
import com.google.android.exoplayer2.util.Clock;
import com.google.android.exoplayer2.util.EventLogger;
import com.google.android.exoplayer2.util.Util;
import com.google.android.exoplayer2.video.VideoListener;
import com.yc.kernel.inter.AbstractVideoPlayer;
import com.yc.kernel.inter.VideoPlayerListener;
import com.yc.kernel.utils.PlayerConstant;
import com.yc.kernel.utils.VideoLogUtils;
import java.util.Map;
import static com.google.android.exoplayer2.ExoPlaybackException.TYPE_SOURCE;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2018/11/9
* desc : exo视频播放器实现类
* revise:
* </pre>
*/
public class ExoMediaPlayer extends AbstractVideoPlayer implements VideoListener, Player.EventListener {
protected Context mAppContext;
protected SimpleExoPlayer mInternalPlayer;
protected MediaSource mMediaSource;
protected ExoMediaSourceHelper mMediaSourceHelper;
private PlaybackParameters mSpeedPlaybackParameters;
private int mLastReportedPlaybackState = Player.STATE_IDLE;
private boolean mLastReportedPlayWhenReady = false;
private boolean mIsPreparing;
private boolean mIsBuffering;
private LoadControl mLoadControl;
private RenderersFactory mRenderersFactory;
private TrackSelector mTrackSelector;
public ExoMediaPlayer(Context context) {
if (context instanceof Application){
mAppContext = context;
} else {
mAppContext = context.getApplicationContext();
}
mMediaSourceHelper = ExoMediaSourceHelper.getInstance(context);
}
@Override
public void initPlayer() {
//创建exo播放器
mInternalPlayer = new SimpleExoPlayer.Builder(
mAppContext,
mRenderersFactory == null ? mRenderersFactory = new DefaultRenderersFactory(mAppContext) : mRenderersFactory,
mTrackSelector == null ? mTrackSelector = new DefaultTrackSelector(mAppContext) : mTrackSelector,
mLoadControl == null ? mLoadControl = new DefaultLoadControl() : mLoadControl,
DefaultBandwidthMeter.getSingletonInstance(mAppContext),
Util.getLooper(),
new AnalyticsCollector(Clock.DEFAULT),
/* useLazyPreparation= */ true,
Clock.DEFAULT)
.build();
setOptions();
//播放器日志
if (VideoLogUtils.isIsLog() && mTrackSelector instanceof MappingTrackSelector) {
mInternalPlayer.addAnalyticsListener(new EventLogger((MappingTrackSelector) mTrackSelector, "ExoPlayer"));
}
initListener();
}
/**
* exo视频播放器监听listener
*/
private void initListener() {
mInternalPlayer.addListener(this);
mInternalPlayer.addVideoListener(this);
}
public void setTrackSelector(TrackSelector trackSelector) {
mTrackSelector = trackSelector;
}
public void setRenderersFactory(RenderersFactory renderersFactory) {
mRenderersFactory = renderersFactory;
}
public void setLoadControl(LoadControl loadControl) {
mLoadControl = loadControl;
}
/**
* 设置播放地址
*
* @param path 播放地址
* @param headers 播放地址请求头
*/
@Override
public void setDataSource(String path, Map<String, String> headers) {
// 设置dataSource
if(path==null || path.length()==0){
if (mPlayerEventListener!=null){
mPlayerEventListener.onInfo(PlayerConstant.MEDIA_INFO_URL_NULL, 0);
}
return;
}
mMediaSource = mMediaSourceHelper.getMediaSource(path, headers);
}
@Override
public void setDataSource(AssetFileDescriptor fd) {
//no support
}
/**
* 准备开始播放（异步）
*/
@Override
public void prepareAsync() {
if (mInternalPlayer == null){
return;
}
if (mMediaSource == null){
return;
}
if (mSpeedPlaybackParameters != null) {
mInternalPlayer.setPlaybackParameters(mSpeedPlaybackParameters);
}
mIsPreparing = true;
mMediaSource.addEventListener(new Handler(), mMediaSourceEventListener);
//准备播放
mInternalPlayer.prepare(mMediaSource);
}
/**
* 播放
*/
@Override
public void start() {
if (mInternalPlayer == null){
return;
}
mInternalPlayer.setPlayWhenReady(true);
}
/**
* 暂停
*/
@Override
public void pause() {
if (mInternalPlayer == null){
return;
}
mInternalPlayer.setPlayWhenReady(false);
}
/**
* 停止
*/
@Override
public void stop() {
if (mInternalPlayer == null){
return;
}
mInternalPlayer.stop();
}
private MediaSourceEventListener mMediaSourceEventListener = new MediaSourceEventListener() {
@Override
public void onReadingStarted(int windowIndex, MediaSource.MediaPeriodId mediaPeriodId) {
if (mPlayerEventListener != null && mIsPreparing) {
mPlayerEventListener.onPrepared();
}
}
};
/**
* 重置播放器
*/
@Override
public void reset() {
if (mInternalPlayer != null) {
mInternalPlayer.stop(true);
mInternalPlayer.setVideoSurface(null);
mIsPreparing = false;
mIsBuffering = false;
mLastReportedPlaybackState = Player.STATE_IDLE;
mLastReportedPlayWhenReady = false;
}
}
/**
* 是否正在播放
*/
@Override
public boolean isPlaying() {
if (mInternalPlayer == null){
return false;
}
int state = mInternalPlayer.getPlaybackState();
switch (state) {
case Player.STATE_BUFFERING:
case Player.STATE_READY:
return mInternalPlayer.getPlayWhenReady();
case Player.STATE_IDLE:
case Player.STATE_ENDED:
default:
return false;
}
}
/**
* 调整进度
*/
@Override
public void seekTo(long time) {
if (mInternalPlayer == null){
return;
}
mInternalPlayer.seekTo(time);
}
/**
* 释放播放器
*/
@Override
public void release() {
if (mInternalPlayer != null) {
mInternalPlayer.removeListener(this);
mInternalPlayer.removeVideoListener(this);
final SimpleExoPlayer player = mInternalPlayer;
mInternalPlayer = null;
new Thread() {
@Override
public void run() {
//异步释放，防止卡顿
player.release();
}
}.start();
}
mIsPreparing = false;
mIsBuffering = false;
mLastReportedPlaybackState = Player.STATE_IDLE;
mLastReportedPlayWhenReady = false;
mSpeedPlaybackParameters = null;
}
/**
* 获取当前播放的位置
*/
@Override
public long getCurrentPosition() {
if (mInternalPlayer == null){
return 0;
}
return mInternalPlayer.getCurrentPosition();
}
/**
* 获取视频总时长
*/
@Override
public long getDuration() {
if (mInternalPlayer == null){
return 0;
}
return mInternalPlayer.getDuration();
}
/**
* 获取缓冲百分比
*/
@Override
public int getBufferedPercentage() {
return mInternalPlayer == null ? 0 : mInternalPlayer.getBufferedPercentage();
}
/**
* 设置渲染视频的View,主要用于SurfaceView
*/
@Override
public void setSurface(Surface surface) {
if (surface!=null){
try {
if (mInternalPlayer != null) {
mInternalPlayer.setVideoSurface(surface);
}
} catch (Exception e) {
mPlayerEventListener.onError(PlayerConstant.ErrorType.TYPE_UNEXPECTED,e.getMessage());
}
}
}
@Override
public void setDisplay(SurfaceHolder holder) {
if (holder == null){
setSurface(null);
} else{
setSurface(holder.getSurface());
}
}
/**
* 设置音量
*/
@Override
public void setVolume(float leftVolume, float rightVolume) {
if (mInternalPlayer != null){
mInternalPlayer.setVolume((leftVolume + rightVolume) / 2);
}
}
/**
* 设置是否循环播放
*/
@Override
public void setLooping(boolean isLooping) {
if (mInternalPlayer != null){
mInternalPlayer.setRepeatMode(isLooping ? Player.REPEAT_MODE_ALL : Player.REPEAT_MODE_OFF);
}
}
@Override
public void setOptions() {
//准备好就开始播放
mInternalPlayer.setPlayWhenReady(true);
}
/**
* 设置播放速度
*/
@Override
public void setSpeed(float speed) {
PlaybackParameters playbackParameters = new PlaybackParameters(speed);
mSpeedPlaybackParameters = playbackParameters;
if (mInternalPlayer != null) {
mInternalPlayer.setPlaybackParameters(playbackParameters);
}
}
/**
* 获取播放速度
*/
@Override
public float getSpeed() {
if (mSpeedPlaybackParameters != null) {
return mSpeedPlaybackParameters.speed;
}
return 1f;
}
/**
* 获取当前缓冲的网速
*/
@Override
public long getTcpSpeed() {
// no support
return 0;
}
@Override
public void onPlayerStateChanged(boolean playWhenReady, int playbackState) {
if (mPlayerEventListener == null){
return;
}
if (mIsPreparing){
return;
}
if (mLastReportedPlayWhenReady != playWhenReady || mLastReportedPlaybackState != playbackState) {
switch (playbackState) {
//最开始调用的状态
case Player.STATE_IDLE:
break;
//开始缓充
case Player.STATE_BUFFERING:
mPlayerEventListener.onInfo(PlayerConstant.MEDIA_INFO_BUFFERING_START, getBufferedPercentage());
mIsBuffering = true;
break;
//开始播放
case Player.STATE_READY:
if (mIsBuffering) {
mPlayerEventListener.onInfo(PlayerConstant.MEDIA_INFO_BUFFERING_END, getBufferedPercentage());
mIsBuffering = false;
}
break;
//播放器已经播放完了媒体
case Player.STATE_ENDED:
mPlayerEventListener.onCompletion();
break;
default:
break;
}
mLastReportedPlaybackState = playbackState;
mLastReportedPlayWhenReady = playWhenReady;
}
}
@Override
public void onPlayerError(ExoPlaybackException error) {
if (mPlayerEventListener != null) {
int type = error.type;
if (type == TYPE_SOURCE){
//错误的链接
mPlayerEventListener.onError(PlayerConstant.ErrorType.TYPE_SOURCE,error.getMessage());
} else if (type == ExoPlaybackException.TYPE_RENDERER
|| type == ExoPlaybackException.TYPE_UNEXPECTED
|| type == ExoPlaybackException.TYPE_REMOTE
|| type == ExoPlaybackException.TYPE_OUT_OF_MEMORY){
mPlayerEventListener.onError(PlayerConstant.ErrorType.TYPE_UNEXPECTED,error.getMessage());
}
}
}
@Override
public void onVideoSizeChanged(int width, int height, int unappliedRotationDegrees, float pixelWidthHeightRatio) {
if (mPlayerEventListener != null) {
mPlayerEventListener.onVideoSizeChanged(width, height);
if (unappliedRotationDegrees > 0) {
mPlayerEventListener.onInfo(PlayerConstant.MEDIA_INFO_VIDEO_ROTATION_CHANGED, unappliedRotationDegrees);
}
}
}
@Override
public void onRenderedFirstFrame() {
if (mPlayerEventListener != null && mIsPreparing) {
mPlayerEventListener.onInfo(PlayerConstant.MEDIA_INFO_VIDEO_RENDERING_START, 0);
mIsPreparing = false;
}
}
@Override
public void setPlayerEventListener(VideoPlayerListener playerEventListener) {
super.setPlayerEventListener(playerEventListener);
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoKernel/src/main/java/com/yc/kernel/impl/exo/ExoMediaSourceHelper.java | Java | package com.yc.kernel.impl.exo;
import android.app.Application;
import android.content.Context;
import android.net.Uri;
import android.text.TextUtils;
import com.google.android.exoplayer2.C;
import com.google.android.exoplayer2.database.ExoDatabaseProvider;
import com.google.android.exoplayer2.ext.rtmp.RtmpDataSourceFactory;
import com.google.android.exoplayer2.source.MediaSource;
import com.google.android.exoplayer2.source.ProgressiveMediaSource;
import com.google.android.exoplayer2.source.dash.DashMediaSource;
import com.google.android.exoplayer2.source.hls.HlsMediaSource;
import com.google.android.exoplayer2.source.smoothstreaming.SsMediaSource;
import com.google.android.exoplayer2.upstream.DataSource;
import com.google.android.exoplayer2.upstream.DefaultDataSourceFactory;
import com.google.android.exoplayer2.upstream.DefaultHttpDataSource;
import com.google.android.exoplayer2.upstream.DefaultHttpDataSourceFactory;
import com.google.android.exoplayer2.upstream.HttpDataSource;
import com.google.android.exoplayer2.upstream.cache.Cache;
import com.google.android.exoplayer2.upstream.cache.CacheDataSource;
import com.google.android.exoplayer2.upstream.cache.CacheDataSourceFactory;
import com.google.android.exoplayer2.upstream.cache.LeastRecentlyUsedCacheEvictor;
import com.google.android.exoplayer2.upstream.cache.SimpleCache;
import com.google.android.exoplayer2.util.Util;
import java.io.File;
import java.lang.reflect.Field;
import java.util.Map;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2018/11/9
* desc : exo视频播放器帮助类
* revise:
* </pre>
*/
public final class ExoMediaSourceHelper {
private static ExoMediaSourceHelper sInstance;
private final String mUserAgent;
private Context mAppContext;
private HttpDataSource.Factory mHttpDataSourceFactory;
private Cache mCache;
private ExoMediaSourceHelper(Context context) {
if (context instanceof Application){
mAppContext = context;
} else {
mAppContext = context.getApplicationContext();
}
mUserAgent = Util.getUserAgent(mAppContext, mAppContext.getApplicationInfo().name);
}
public static ExoMediaSourceHelper getInstance(Context context) {
if (sInstance == null) {
synchronized (ExoMediaSourceHelper.class) {
if (sInstance == null) {
sInstance = new ExoMediaSourceHelper(context);
}
}
}
return sInstance;
}
public MediaSource getMediaSource(String uri) {
return getMediaSource(uri, null, false);
}
public MediaSource getMediaSource(String uri, Map<String, String> headers) {
return getMediaSource(uri, headers, false);
}
public MediaSource getMediaSource(String uri, boolean isCache) {
return getMediaSource(uri, null, isCache);
}
public MediaSource getMediaSource(String uri, Map<String, String> headers, boolean isCache) {
Uri contentUri = Uri.parse(uri);
if ("rtmp".equals(contentUri.getScheme())) {
RtmpDataSourceFactory rtmpDataSourceFactory = new RtmpDataSourceFactory(null);
return new ProgressiveMediaSource.Factory(rtmpDataSourceFactory).createMediaSource(contentUri);
}
int contentType = inferContentType(uri);
DataSource.Factory factory;
if (isCache) {
factory = getCacheDataSourceFactory();
} else {
factory = getDataSourceFactory();
}
if (mHttpDataSourceFactory != null) {
setHeaders(headers);
}
switch (contentType) {
case C.TYPE_DASH:
return new DashMediaSource.Factory(factory).createMediaSource(contentUri);
case C.TYPE_SS:
return new SsMediaSource.Factory(factory).createMediaSource(contentUri);
case C.TYPE_HLS:
return new HlsMediaSource.Factory(factory).createMediaSource(contentUri);
default:
case C.TYPE_OTHER:
return new ProgressiveMediaSource.Factory(factory).createMediaSource(contentUri);
}
}
private int inferContentType(String fileName) {
fileName = Util.toLowerInvariant(fileName);
if (fileName.contains(".mpd")) {
return C.TYPE_DASH;
} else if (fileName.contains(".m3u8")) {
return C.TYPE_HLS;
} else if (fileName.matches(".*\\.ism(l)?(/manifest(\\(.+\\))?)?")) {
return C.TYPE_SS;
} else {
return C.TYPE_OTHER;
}
}
private DataSource.Factory getCacheDataSourceFactory() {
if (mCache == null) {
mCache = newCache();
}
return new CacheDataSourceFactory(
mCache,
getDataSourceFactory(),
CacheDataSource.FLAG_IGNORE_CACHE_ON_ERROR);
}
private Cache newCache() {
return new SimpleCache(
//缓存目录
new File(mAppContext.getExternalCacheDir(), "exo-video-cache"),
//缓存大小，默认512M，使用LRU算法实现
new LeastRecentlyUsedCacheEvictor(512 * 1024 * 1024),
new ExoDatabaseProvider(mAppContext));
}
/**
* Returns a new DataSource factory.
*
* @return A new DataSource factory.
*/
private DataSource.Factory getDataSourceFactory() {
return new DefaultDataSourceFactory(mAppContext, getHttpDataSourceFactory());
}
/**
* Returns a new HttpDataSource factory.
*
* @return A new HttpDataSource factory.
*/
private DataSource.Factory getHttpDataSourceFactory() {
if (mHttpDataSourceFactory == null) {
mHttpDataSourceFactory = new DefaultHttpDataSourceFactory(
mUserAgent,
null,
DefaultHttpDataSource.DEFAULT_CONNECT_TIMEOUT_MILLIS,
DefaultHttpDataSource.DEFAULT_READ_TIMEOUT_MILLIS,
//http->https重定向支持
true);
}
return mHttpDataSourceFactory;
}
private void setHeaders(Map<String, String> headers) {
if (headers != null && headers.size() > 0) {
for (Map.Entry<String, String> header : headers.entrySet()) {
String key = header.getKey();
String value = header.getValue();
//如果发现用户通过header传递了UA，则强行将HttpDataSourceFactory里面的userAgent字段替换成用户的
if (TextUtils.equals(key, "User-Agent")) {
if (!TextUtils.isEmpty(value)) {
try {
Field userAgentField = mHttpDataSourceFactory.getClass().getDeclaredField("userAgent");
userAgentField.setAccessible(true);
userAgentField.set(mHttpDataSourceFactory, value);
} catch (Exception e) {
//ignore
}
}
} else {
mHttpDataSourceFactory.getDefaultRequestProperties().set(key, value);
}
}
}
}
public void setCache(Cache cache) {
this.mCache = cache;
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoKernel/src/main/java/com/yc/kernel/impl/exo/ExoPlayerFactory.java | Java | package com.yc.kernel.impl.exo;
import android.content.Context;
import com.yc.kernel.factory.PlayerFactory;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2018/11/9
* desc : exo视频播放器Factory
* revise: 抽象工厂具体实现类
* </pre>
*/
public class ExoPlayerFactory extends PlayerFactory<ExoMediaPlayer> {
public static ExoPlayerFactory create() {
return new ExoPlayerFactory();
}
@Override
public ExoMediaPlayer createPlayer(Context context) {
return new ExoMediaPlayer(context);
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoKernel/src/main/java/com/yc/kernel/impl/ijk/IjkPlayerFactory.java | Java | /*
Copyright 2017 yangchong211（github.com/yangchong211）
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package com.yc.kernel.impl.ijk;
import android.content.Context;
import com.yc.kernel.factory.PlayerFactory;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2018/11/9
* desc : ijk视频播放器Factory
* revise: 抽象工厂具体实现类
* </pre>
*/
public class IjkPlayerFactory extends PlayerFactory<IjkVideoPlayer> {
public static IjkPlayerFactory create() {
return new IjkPlayerFactory();
}
@Override
public IjkVideoPlayer createPlayer(Context context) {
return new IjkVideoPlayer(context);
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoKernel/src/main/java/com/yc/kernel/impl/ijk/IjkVideoPlayer.java | Java | /*
Copyright 2017 yangchong211（github.com/yangchong211）
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package com.yc.kernel.impl.ijk;
import android.app.Application;
import android.content.ContentResolver;
import android.content.Context;
import android.content.res.AssetFileDescriptor;
import android.media.AudioManager;
import android.net.Uri;
import android.os.Bundle;
import android.text.TextUtils;
import android.view.Surface;
import android.view.SurfaceHolder;
import com.yc.kernel.inter.AbstractVideoPlayer;
import com.yc.kernel.inter.VideoPlayerListener;
import com.yc.kernel.utils.PlayerConstant;
import com.yc.kernel.utils.VideoLogUtils;
import java.util.Map;
import tv.danmaku.ijk.media.player.IMediaPlayer;
import tv.danmaku.ijk.media.player.IjkMediaPlayer;
import tv.danmaku.ijk.media.player.IjkTimedText;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2018/11/9
* desc : ijk视频播放器实现类
* revise:
* </pre>
*/
public class IjkVideoPlayer extends AbstractVideoPlayer {
protected IjkMediaPlayer mMediaPlayer;
private int mBufferedPercent;
private Context mAppContext;
public IjkVideoPlayer(Context context) {
if (context instanceof Application){
mAppContext = context;
} else {
mAppContext = context.getApplicationContext();
}
}
@Override
public void initPlayer() {
mMediaPlayer = new IjkMediaPlayer();
//native日志
IjkMediaPlayer.native_setLogLevel(VideoLogUtils.isIsLog()
? IjkMediaPlayer.IJK_LOG_INFO : IjkMediaPlayer.IJK_LOG_SILENT);
setOptions();
mMediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);
initListener();
}
@Override
public void setOptions() {
/*int player = IjkMediaPlayer.OPT_CATEGORY_PLAYER;
int codec = IjkMediaPlayer.OPT_CATEGORY_CODEC;
int format = IjkMediaPlayer.OPT_CATEGORY_FORMAT;
//设置ijkPlayer播放器的硬件解码相关参数
//设置播放前的最大探测时间
mMediaPlayer.setOption(format, "analyzemaxduration", 100L);
//设置播放前的探测时间 1,达到首屏秒开效果
mMediaPlayer.setOption(format, "analyzeduration", 1L);
//播放前的探测Size，默认是1M, 改小一点会出画面更快
mMediaPlayer.setOption(format, "probesize", 10240L);
//设置是否开启变调isModifyTone?0:1
mMediaPlayer.setOption(player,"soundtouch",0);
//每处理一个packet之后刷新io上下文
mMediaPlayer.setOption(format, "flush_packets", 1L);
//是否开启预缓冲，一般直播项目会开启，达到秒开的效果，不过带来了播放丢帧卡顿的体验
mMediaPlayer.setOption(player, "packet-buffering", 0L);
//播放重连次数
mMediaPlayer.setOption(player, "reconnect", 5);
//最大缓冲大小,单位kb
mMediaPlayer.setOption(player, "max-buffer-size", 10240L);
//跳帧处理,放CPU处理较慢时，进行跳帧处理，保证播放流程，画面和声音同步
mMediaPlayer.setOption(player, "framedrop", 1L);
//最大fps
mMediaPlayer.setOption(player, "max-fps", 30L);
//SeekTo设置优化
mMediaPlayer.setOption(player, "enable-accurate-seek", 1L);
mMediaPlayer.setOption(player, "opensles", 0);
mMediaPlayer.setOption(player, "overlay-format",
IjkMediaPlayer.SDL_FCC_RV32);
mMediaPlayer.setOption(player, "framedrop", 1);
mMediaPlayer.setOption(player, "start-on-prepared", 0);
mMediaPlayer.setOption(format, "http-detect-range-support", 0);
//设置是否开启环路过滤: 0开启，画面质量高，解码开销大，48关闭，画面质量差点，解码开销小
mMediaPlayer.setOption(codec, "skip_loop_filter", 48);
//jkPlayer支持硬解码和软解码。
//软解码时不会旋转视频角度这时需要你通过onInfo的what == IMediaPlayer.MEDIA_INFO_VIDEO_ROTATION_CHANGED去获取角度，自己旋转画面。
//或者开启硬解硬解码，不过硬解码容易造成黑屏无声（硬件兼容问题），下面是设置硬解码相关的代码
mMediaPlayer.setOption(player, "mediacodec", 0);
mMediaPlayer.setOption(player, "mediacodec-auto-rotate", 1);
mMediaPlayer.setOption(player, "mediacodec-handle-resolution-change", 1);*/
}
/**
* ijk视频播放器监听listener
*/
private void initListener() {
// 设置监听，可以查看ijk中的IMediaPlayer源码监听事件
// 设置视频错误监听器
mMediaPlayer.setOnErrorListener(onErrorListener);
// 设置视频播放完成监听事件
mMediaPlayer.setOnCompletionListener(onCompletionListener);
// 设置视频信息监听器
mMediaPlayer.setOnInfoListener(onInfoListener);
// 设置视频缓冲更新监听事件
mMediaPlayer.setOnBufferingUpdateListener(onBufferingUpdateListener);
// 设置准备视频播放监听事件
mMediaPlayer.setOnPreparedListener(onPreparedListener);
// 设置视频大小更改监听器
mMediaPlayer.setOnVideoSizeChangedListener(onVideoSizeChangedListener);
// 设置视频seek完成监听事件
mMediaPlayer.setOnSeekCompleteListener(onSeekCompleteListener);
// 设置时间文本监听器
mMediaPlayer.setOnTimedTextListener(onTimedTextListener);
mMediaPlayer.setOnNativeInvokeListener(new IjkMediaPlayer.OnNativeInvokeListener() {
@Override
public boolean onNativeInvoke(int i, Bundle bundle) {
return true;
}
});
}
/**
* 设置播放地址
*
* @param path 播放地址
* @param headers 播放地址请求头
*/
@Override
public void setDataSource(String path, Map<String, String> headers) {
// 设置dataSource
if(path==null || path.length()==0){
if (mPlayerEventListener!=null){
mPlayerEventListener.onInfo(PlayerConstant.MEDIA_INFO_URL_NULL, 0);
}
return;
}
try {
//解析path
Uri uri = Uri.parse(path);
if (ContentResolver.SCHEME_ANDROID_RESOURCE.equals(uri.getScheme())) {
RawDataSourceProvider rawDataSourceProvider = RawDataSourceProvider.create(mAppContext, uri);
mMediaPlayer.setDataSource(rawDataSourceProvider);
} else {
//处理UA问题
if (headers != null) {
String userAgent = headers.get("User-Agent");
if (!TextUtils.isEmpty(userAgent)) {
mMediaPlayer.setOption(IjkMediaPlayer.OPT_CATEGORY_FORMAT, "user_agent", userAgent);
}
}
mMediaPlayer.setDataSource(mAppContext, uri, headers);
}
} catch (Exception e) {
mPlayerEventListener.onError(PlayerConstant.ErrorType.TYPE_PARSE,e.getMessage());
}
}
/**
* 用于播放raw和asset里面的视频文件
*/
@Override
public void setDataSource(AssetFileDescriptor fd) {
try {
mMediaPlayer.setDataSource(new RawDataSourceProvider(fd));
} catch (Exception e) {
mPlayerEventListener.onError(PlayerConstant.ErrorType.TYPE_UNEXPECTED,e.getMessage());
}
}
/**
* 设置渲染视频的View,主要用于TextureView
* @param surface surface
*/
@Override
public void setSurface(Surface surface) {
if (surface!=null){
try {
mMediaPlayer.setSurface(surface);
} catch (Exception e) {
mPlayerEventListener.onError(PlayerConstant.ErrorType.TYPE_UNEXPECTED,e.getMessage());
}
}
}
/**
* 准备开始播放（异步）
*/
@Override
public void prepareAsync() {
try {
mMediaPlayer.prepareAsync();
} catch (IllegalStateException e) {
mPlayerEventListener.onError(PlayerConstant.ErrorType.TYPE_UNEXPECTED,e.getMessage());
}
}
/**
* 暂停
*/
@Override
public void pause() {
try {
mMediaPlayer.pause();
} catch (IllegalStateException e) {
mPlayerEventListener.onError(PlayerConstant.ErrorType.TYPE_UNEXPECTED,e.getMessage());
}
}
/**
* 播放
*/
@Override
public void start() {
try {
mMediaPlayer.start();
} catch (IllegalStateException e) {
mPlayerEventListener.onError(PlayerConstant.ErrorType.TYPE_UNEXPECTED,e.getMessage());
}
}
/**
* 停止
*/
@Override
public void stop() {
try {
mMediaPlayer.stop();
} catch (IllegalStateException e) {
mPlayerEventListener.onError(PlayerConstant.ErrorType.TYPE_UNEXPECTED,e.getMessage());
}
}
/**
* 重置播放器
*/
@Override
public void reset() {
mMediaPlayer.reset();
mMediaPlayer.setOnVideoSizeChangedListener(onVideoSizeChangedListener);
setOptions();
}
/**
* 是否正在播放
*/
@Override
public boolean isPlaying() {
return mMediaPlayer.isPlaying();
}
/**
* 调整进度
*/
@Override
public void seekTo(long time) {
try {
mMediaPlayer.seekTo((int) time);
} catch (IllegalStateException e) {
mPlayerEventListener.onError(PlayerConstant.ErrorType.TYPE_UNEXPECTED,e.getMessage());
}
}
/**
* 释放播放器
*/
@Override
public void release() {
mMediaPlayer.setOnErrorListener(null);
mMediaPlayer.setOnCompletionListener(null);
mMediaPlayer.setOnInfoListener(null);
mMediaPlayer.setOnBufferingUpdateListener(null);
mMediaPlayer.setOnPreparedListener(null);
mMediaPlayer.setOnVideoSizeChangedListener(null);
new Thread() {
@Override
public void run() {
try {
mMediaPlayer.release();
} catch (Exception e) {
e.printStackTrace();
}
}
}.start();
}
/**
* 获取当前播放的位置
*/
@Override
public long getCurrentPosition() {
return mMediaPlayer.getCurrentPosition();
}
/**
* 获取视频总时长
*/
@Override
public long getDuration() {
return mMediaPlayer.getDuration();
}
/**
* 获取缓冲百分比
*/
@Override
public int getBufferedPercentage() {
return mBufferedPercent;
}
/**
* 设置渲染视频的View,主要用于SurfaceView
*/
@Override
public void setDisplay(SurfaceHolder holder) {
mMediaPlayer.setDisplay(holder);
}
/**
* 设置音量
*/
@Override
public void setVolume(float v1, float v2) {
mMediaPlayer.setVolume(v1, v2);
}
/**
* 设置是否循环播放
*/
@Override
public void setLooping(boolean isLooping) {
mMediaPlayer.setLooping(isLooping);
}
/**
* 设置播放速度
*/
@Override
public void setSpeed(float speed) {
mMediaPlayer.setSpeed(speed);
}
/**
* 获取播放速度
*/
@Override
public float getSpeed() {
return mMediaPlayer.getSpeed(0);
}
/**
* 获取当前缓冲的网速
*/
@Override
public long getTcpSpeed() {
return mMediaPlayer.getTcpSpeed();
}
/**
* 设置视频错误监听器
* int MEDIA_INFO_VIDEO_RENDERING_START = 3;//视频准备渲染
* int MEDIA_INFO_BUFFERING_START = 701;//开始缓冲
* int MEDIA_INFO_BUFFERING_END = 702;//缓冲结束
* int MEDIA_INFO_VIDEO_ROTATION_CHANGED = 10001;//视频选择信息
* int MEDIA_ERROR_SERVER_DIED = 100;//视频中断，一般是视频源异常或者不支持的视频类型。
* int MEDIA_ERROR_IJK_PLAYER = -10000,//一般是视频源有问题或者数据格式不支持，比如音频不是AAC之类的
* int MEDIA_ERROR_NOT_VALID_FOR_PROGRESSIVE_PLAYBACK = 200;//数据错误没有有效的回收
*/
private IMediaPlayer.OnErrorListener onErrorListener = new IMediaPlayer.OnErrorListener() {
@Override
public boolean onError(IMediaPlayer iMediaPlayer, int framework_err, int impl_err) {
mPlayerEventListener.onError(PlayerConstant.ErrorType.TYPE_UNEXPECTED,"监听异常"+ framework_err + ", extra: " + impl_err);
VideoLogUtils.d("IjkVideoPlayer----listener---------onError ——> STATE_ERROR ———— what：" + framework_err + ", extra: " + impl_err);
return true;
}
};
/**
* 设置视频播放完成监听事件
*/
private IMediaPlayer.OnCompletionListener onCompletionListener = new IMediaPlayer.OnCompletionListener() {
@Override
public void onCompletion(IMediaPlayer iMediaPlayer) {
mPlayerEventListener.onCompletion();
VideoLogUtils.d("IjkVideoPlayer----listener---------onCompletion ——> STATE_COMPLETED");
}
};
/**
* 设置视频信息监听器
*/
private IMediaPlayer.OnInfoListener onInfoListener = new IMediaPlayer.OnInfoListener() {
@Override
public boolean onInfo(IMediaPlayer iMediaPlayer, int what, int extra) {
mPlayerEventListener.onInfo(what, extra);
VideoLogUtils.d("IjkVideoPlayer----listener---------onInfo ——> ———— what：" + what + ", extra: " + extra);
return true;
}
};
/**
* 设置视频缓冲更新监听事件
*/
private IMediaPlayer.OnBufferingUpdateListener onBufferingUpdateListener = new IMediaPlayer.OnBufferingUpdateListener() {
@Override
public void onBufferingUpdate(IMediaPlayer iMediaPlayer, int percent) {
mBufferedPercent = percent;
}
};
/**
* 设置准备视频播放监听事件
*/
private IMediaPlayer.OnPreparedListener onPreparedListener = new IMediaPlayer.OnPreparedListener() {
@Override
public void onPrepared(IMediaPlayer iMediaPlayer) {
mPlayerEventListener.onPrepared();
VideoLogUtils.d("IjkVideoPlayer----listener---------onPrepared ——> STATE_PREPARED");
}
};
/**
* 设置视频大小更改监听器
*/
private IMediaPlayer.OnVideoSizeChangedListener onVideoSizeChangedListener = new IMediaPlayer.OnVideoSizeChangedListener() {
@Override
public void onVideoSizeChanged(IMediaPlayer iMediaPlayer, int width, int height,
int sar_num, int sar_den) {
int videoWidth = iMediaPlayer.getVideoWidth();
int videoHeight = iMediaPlayer.getVideoHeight();
if (videoWidth != 0 && videoHeight != 0) {
mPlayerEventListener.onVideoSizeChanged(videoWidth, videoHeight);
}
VideoLogUtils.d("IjkVideoPlayer----listener---------onVideoSizeChanged ——> WIDTH：" + width + "， HEIGHT：" + height);
}
};
/**
* 设置时间文本监听器
*/
private IMediaPlayer.OnTimedTextListener onTimedTextListener = new IMediaPlayer.OnTimedTextListener() {
@Override
public void onTimedText(IMediaPlayer iMediaPlayer, IjkTimedText ijkTimedText) {
}
};
/**
* 设置视频seek完成监听事件
*/
private IMediaPlayer.OnSeekCompleteListener onSeekCompleteListener = new IMediaPlayer.OnSeekCompleteListener() {
@Override
public void onSeekComplete(IMediaPlayer iMediaPlayer) {
}
};
@Override
public void setPlayerEventListener(VideoPlayerListener playerEventListener) {
super.setPlayerEventListener(playerEventListener);
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoKernel/src/main/java/com/yc/kernel/impl/ijk/RawDataSourceProvider.java | Java | /*
Copyright 2017 yangchong211（github.com/yangchong211）
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package com.yc.kernel.impl.ijk;
import android.content.Context;
import android.content.res.AssetFileDescriptor;
import android.net.Uri;
import java.io.ByteArrayOutputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import tv.danmaku.ijk.media.player.misc.IMediaDataSource;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2018/11/9
* desc : ijk视频播放器读取本地资源Source实现类
* revise:
* </pre>
*/
public class RawDataSourceProvider implements IMediaDataSource {
private AssetFileDescriptor mDescriptor;
private byte[] mMediaBytes;
public RawDataSourceProvider(AssetFileDescriptor descriptor) {
this.mDescriptor = descriptor;
}
@Override
public int readAt(long position, byte[] buffer, int offset, int size) {
if (position + 1 >= mMediaBytes.length) {
return -1;
}
int length;
if (position + size < mMediaBytes.length) {
length = size;
} else {
length = (int) (mMediaBytes.length - position);
if (length > buffer.length){
length = buffer.length;
}
length--;
}
//使用系统集合拷贝
System.arraycopy(mMediaBytes, (int) position, buffer, offset, length);
return length;
}
@Override
public long getSize() throws IOException {
long length = mDescriptor.getLength();
if (mMediaBytes == null) {
InputStream inputStream = mDescriptor.createInputStream();
mMediaBytes = readBytes(inputStream);
}
return length;
}
@Override
public void close() throws IOException {
if (mDescriptor != null){
mDescriptor.close();
}
mDescriptor = null;
mMediaBytes = null;
}
private byte[] readBytes(InputStream inputStream) throws IOException {
ByteArrayOutputStream byteBuffer = new ByteArrayOutputStream();
int bufferSize = 1024;
byte[] buffer = new byte[bufferSize];
int len;
while ((len = inputStream.read(buffer)) != -1) {
byteBuffer.write(buffer, 0, len);
}
return byteBuffer.toByteArray();
}
public static RawDataSourceProvider create(Context context, Uri uri) {
try {
AssetFileDescriptor fileDescriptor = context.getContentResolver()
.openAssetFileDescriptor(uri, "r");
return new RawDataSourceProvider(fileDescriptor);
} catch (FileNotFoundException e) {
e.printStackTrace();
}
return null;
}
} | yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoKernel/src/main/java/com/yc/kernel/impl/media/AndroidMediaPlayer.java | Java | /*
Copyright 2017 yangchong211（github.com/yangchong211）
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package com.yc.kernel.impl.media;
import android.app.Application;
import android.content.Context;
import android.content.res.AssetFileDescriptor;
import android.media.AudioManager;
import android.media.MediaPlayer;
import android.net.Uri;
import android.os.Build;
import android.view.Surface;
import android.view.SurfaceHolder;
import com.yc.kernel.inter.AbstractVideoPlayer;
import com.yc.kernel.inter.VideoPlayerListener;
import com.yc.kernel.utils.PlayerConstant;
import java.util.Map;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2018/11/9
* desc : 不推荐，系统的MediaPlayer兼容性较差，建议使用IjkPlayer或者ExoPlayer
* revise:
* </pre>
*/
public class AndroidMediaPlayer extends AbstractVideoPlayer {
protected MediaPlayer mMediaPlayer;
private int mBufferedPercent;
private Context mAppContext;
private boolean mIsPreparing;
public AndroidMediaPlayer(Context context) {
if (context instanceof Application){
mAppContext = context;
} else {
mAppContext = context.getApplicationContext();
}
}
@Override
public void initPlayer() {
mMediaPlayer = new MediaPlayer();
setOptions();
initListener();
}
/**
* MediaPlayer视频播放器监听listener
*/
private void initListener() {
mMediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);
mMediaPlayer.setOnErrorListener(onErrorListener);
mMediaPlayer.setOnCompletionListener(onCompletionListener);
mMediaPlayer.setOnInfoListener(onInfoListener);
mMediaPlayer.setOnBufferingUpdateListener(onBufferingUpdateListener);
mMediaPlayer.setOnPreparedListener(onPreparedListener);
mMediaPlayer.setOnVideoSizeChangedListener(onVideoSizeChangedListener);
}
/**
* 设置播放地址
*
* @param path 播放地址
* @param headers 播放地址请求头
*/
@Override
public void setDataSource(String path, Map<String, String> headers) {
// 设置dataSource
if(path==null || path.length()==0){
if (mPlayerEventListener!=null){
mPlayerEventListener.onInfo(PlayerConstant.MEDIA_INFO_URL_NULL, 0);
}
return;
}
try {
Uri uri = Uri.parse(path);
mMediaPlayer.setDataSource(mAppContext, uri, headers);
} catch (Exception e) {
mPlayerEventListener.onError(PlayerConstant.ErrorType.TYPE_PARSE,e.getMessage());
}
}
/**
* 用于播放raw和asset里面的视频文件
*/
@Override
public void setDataSource(AssetFileDescriptor fd) {
try {
mMediaPlayer.setDataSource(fd.getFileDescriptor(), fd.getStartOffset(), fd.getLength());
} catch (Exception e) {
mPlayerEventListener.onError(PlayerConstant.ErrorType.TYPE_UNEXPECTED,e.getMessage());
}
}
/**
* 播放
*/
@Override
public void start() {
try {
mMediaPlayer.start();
} catch (IllegalStateException e) {
mPlayerEventListener.onError(PlayerConstant.ErrorType.TYPE_UNEXPECTED,e.getMessage());
}
}
/**
* 暂停
*/
@Override
public void pause() {
try {
mMediaPlayer.pause();
} catch (IllegalStateException e) {
mPlayerEventListener.onError(PlayerConstant.ErrorType.TYPE_UNEXPECTED,e.getMessage());
}
}
/**
* 停止
*/
@Override
public void stop() {
try {
mMediaPlayer.stop();
} catch (IllegalStateException e) {
mPlayerEventListener.onError(PlayerConstant.ErrorType.TYPE_UNEXPECTED,e.getMessage());
}
}
@Override
public void prepareAsync() {
try {
mIsPreparing = true;
mMediaPlayer.prepareAsync();
} catch (IllegalStateException e) {
mPlayerEventListener.onError(PlayerConstant.ErrorType.TYPE_UNEXPECTED,e.getMessage());
}
}
/**
* 重置播放器
*/
@Override
public void reset() {
mMediaPlayer.reset();
mMediaPlayer.setSurface(null);
mMediaPlayer.setDisplay(null);
mMediaPlayer.setVolume(1, 1);
}
/**
* 是否正在播放
*/
@Override
public boolean isPlaying() {
return mMediaPlayer.isPlaying();
}
/**
* 调整进度
*/
@Override
public void seekTo(long time) {
try {
mMediaPlayer.seekTo((int) time);
} catch (IllegalStateException e) {
mPlayerEventListener.onError(PlayerConstant.ErrorType.TYPE_UNEXPECTED,e.getMessage());
}
}
/**
* 释放播放器
*/
@Override
public void release() {
mMediaPlayer.setOnErrorListener(null);
mMediaPlayer.setOnCompletionListener(null);
mMediaPlayer.setOnInfoListener(null);
mMediaPlayer.setOnBufferingUpdateListener(null);
mMediaPlayer.setOnPreparedListener(null);
mMediaPlayer.setOnVideoSizeChangedListener(null);
new Thread() {
@Override
public void run() {
try {
mMediaPlayer.release();
} catch (Exception e) {
e.printStackTrace();
}
}
}.start();
}
/**
* 获取当前播放的位置
*/
@Override
public long getCurrentPosition() {
return mMediaPlayer.getCurrentPosition();
}
/**
* 获取视频总时长
*/
@Override
public long getDuration() {
return mMediaPlayer.getDuration();
}
/**
* 获取缓冲百分比
* @return 获取缓冲百分比
*/
@Override
public int getBufferedPercentage() {
return mBufferedPercent;
}
/**
* 设置渲染视频的View,主要用于TextureView
* @param surface surface
*/
@Override
public void setSurface(Surface surface) {
if (surface!=null){
try {
mMediaPlayer.setSurface(surface);
} catch (Exception e) {
mPlayerEventListener.onError(PlayerConstant.ErrorType.TYPE_UNEXPECTED,e.getMessage());
}
}
}
/**
* 设置渲染视频的View,主要用于SurfaceView
* @param holder holder
*/
@Override
public void setDisplay(SurfaceHolder holder) {
try {
mMediaPlayer.setDisplay(holder);
} catch (Exception e) {
mPlayerEventListener.onError(PlayerConstant.ErrorType.TYPE_UNEXPECTED,e.getMessage());
}
}
/**
* 设置音量
* @param v1 v1
* @param v2 v2
*/
@Override
public void setVolume(float v1, float v2) {
try {
mMediaPlayer.setVolume(v1, v2);
} catch (Exception e){
mPlayerEventListener.onError(PlayerConstant.ErrorType.TYPE_UNEXPECTED,e.getMessage());
}
}
/**
* 设置是否循环播放
* @param isLooping 布尔值
*/
@Override
public void setLooping(boolean isLooping) {
try {
mMediaPlayer.setLooping(isLooping);
} catch (Exception e){
mPlayerEventListener.onError(PlayerConstant.ErrorType.TYPE_UNEXPECTED,e.getMessage());
}
}
@Override
public void setOptions() {
}
/**
* 设置播放速度
* @param speed 速度
*/
@Override
public void setSpeed(float speed) {
// only support above Android M
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
try {
mMediaPlayer.setPlaybackParams(mMediaPlayer.getPlaybackParams().setSpeed(speed));
} catch (Exception e) {
mPlayerEventListener.onError(PlayerConstant.ErrorType.TYPE_UNEXPECTED,e.getMessage());
}
}
}
/**
* 获取播放速度
* @return 播放速度
*/
@Override
public float getSpeed() {
// only support above Android M
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
try {
return mMediaPlayer.getPlaybackParams().getSpeed();
} catch (Exception e) {
mPlayerEventListener.onError(PlayerConstant.ErrorType.TYPE_UNEXPECTED,e.getMessage());
}
}
return 1f;
}
/**
* 获取当前缓冲的网速
* @return 获取网络
*/
@Override
public long getTcpSpeed() {
// no support
return 0;
}
private MediaPlayer.OnErrorListener onErrorListener = new MediaPlayer.OnErrorListener() {
@Override
public boolean onError(MediaPlayer mp, int what, int extra) {
mPlayerEventListener.onError(PlayerConstant.ErrorType.TYPE_UNEXPECTED,"监听异常"+ what + ", extra: " + extra);
return true;
}
};
private MediaPlayer.OnCompletionListener onCompletionListener = new MediaPlayer.OnCompletionListener() {
@Override
public void onCompletion(MediaPlayer mp) {
mPlayerEventListener.onCompletion();
}
};
private MediaPlayer.OnInfoListener onInfoListener = new MediaPlayer.OnInfoListener() {
@Override
public boolean onInfo(MediaPlayer mp, int what, int extra) {
//解决MEDIA_INFO_VIDEO_RENDERING_START多次回调问题
if (what == PlayerConstant.MEDIA_INFO_VIDEO_RENDERING_START) {
if (mIsPreparing) {
mPlayerEventListener.onInfo(what, extra);
mIsPreparing = false;
}
} else {
mPlayerEventListener.onInfo(what, extra);
}
return true;
}
};
private MediaPlayer.OnBufferingUpdateListener onBufferingUpdateListener = new MediaPlayer.OnBufferingUpdateListener() {
@Override
public void onBufferingUpdate(MediaPlayer mp, int percent) {
mBufferedPercent = percent;
}
};
private MediaPlayer.OnPreparedListener onPreparedListener = new MediaPlayer.OnPreparedListener() {
@Override
public void onPrepared(MediaPlayer mp) {
mPlayerEventListener.onPrepared();
start();
}
};
private MediaPlayer.OnVideoSizeChangedListener onVideoSizeChangedListener = new MediaPlayer.OnVideoSizeChangedListener() {
@Override
public void onVideoSizeChanged(MediaPlayer mp, int width, int height) {
int videoWidth = mp.getVideoWidth();
int videoHeight = mp.getVideoHeight();
if (videoWidth != 0 && videoHeight != 0) {
mPlayerEventListener.onVideoSizeChanged(videoWidth, videoHeight);
}
}
};
@Override
public void setPlayerEventListener(VideoPlayerListener playerEventListener) {
super.setPlayerEventListener(playerEventListener);
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoKernel/src/main/java/com/yc/kernel/impl/media/MediaPlayerFactory.java | Java | /*
Copyright 2017 yangchong211（github.com/yangchong211）
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package com.yc.kernel.impl.media;
import android.content.Context;
import com.yc.kernel.factory.PlayerFactory;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2018/11/9
* desc : 不推荐，系统的MediaPlayer兼容性较差，建议使用IjkPlayer或者ExoPlayer
* revise: 抽象工厂具体实现类
* </pre>
*/
public class MediaPlayerFactory extends PlayerFactory<AndroidMediaPlayer> {
public static MediaPlayerFactory create() {
return new MediaPlayerFactory();
}
@Override
public AndroidMediaPlayer createPlayer(Context context) {
return new AndroidMediaPlayer(context);
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoKernel/src/main/java/com/yc/kernel/impl/tx/TxMediaPlayer.java | Java | package com.yc.kernel.impl.tx;
import android.app.Application;
import android.content.Context;
import android.content.res.AssetFileDescriptor;
import android.view.Surface;
import android.view.SurfaceHolder;
import com.yc.kernel.inter.AbstractVideoPlayer;
import java.util.Map;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2018/11/9
* desc : 腾讯player播放器内核
* revise:
* </pre>
*/
public class TxMediaPlayer extends AbstractVideoPlayer {
private Context mAppContext;
public TxMediaPlayer(Context context) {
if (context instanceof Application){
mAppContext = context;
} else {
mAppContext = context.getApplicationContext();
}
}
@Override
public void initPlayer() {
}
@Override
public void setDataSource(String path, Map<String, String> headers) {
}
@Override
public void setDataSource(AssetFileDescriptor fd) {
}
@Override
public void setSurface(Surface surface) {
}
@Override
public void prepareAsync() {
}
@Override
public void start() {
}
@Override
public void pause() {
}
@Override
public void stop() {
}
@Override
public void reset() {
}
@Override
public boolean isPlaying() {
return false;
}
@Override
public void seekTo(long time) {
}
@Override
public void release() {
}
@Override
public long getCurrentPosition() {
return 0;
}
@Override
public long getDuration() {
return 0;
}
@Override
public int getBufferedPercentage() {
return 0;
}
@Override
public void setDisplay(SurfaceHolder holder) {
}
@Override
public void setVolume(float v1, float v2) {
}
@Override
public void setLooping(boolean isLooping) {
}
@Override
public void setOptions() {
}
@Override
public void setSpeed(float speed) {
}
@Override
public float getSpeed() {
return 0;
}
@Override
public long getTcpSpeed() {
return 0;
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoKernel/src/main/java/com/yc/kernel/impl/tx/TxPlayerFactory.java | Java | /*
Copyright 2017 yangchong211（github.com/yangchong211）
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package com.yc.kernel.impl.tx;
import android.content.Context;
import com.yc.kernel.factory.PlayerFactory;
import com.yc.kernel.impl.media.AndroidMediaPlayer;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2018/11/9
* desc : tx视频播放器Factory
* revise:
* </pre>
*/
public class TxPlayerFactory extends PlayerFactory<TxMediaPlayer> {
public static TxPlayerFactory create() {
return new TxPlayerFactory();
}
@Override
public TxMediaPlayer createPlayer(Context context) {
return new TxMediaPlayer(context);
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoKernel/src/main/java/com/yc/kernel/inter/AbstractVideoPlayer.java | Java | /*
Copyright 2017 yangchong211（github.com/yangchong211）
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package com.yc.kernel.inter;
import android.content.res.AssetFileDescriptor;
import android.view.Surface;
import android.view.SurfaceHolder;
import java.util.Map;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2018/11/9
* desc : 抽象的播放器
* revise:
* </pre>
*/
public abstract class AbstractVideoPlayer {
/**
* 播放器事件回调
*/
protected VideoPlayerListener mPlayerEventListener;
/*----------------------------第一部分：视频初始化实例对象方法----------------------------------*/
/**
* 初始化播放器实例
* 视频播放器第一步：创建视频播放器
*/
public abstract void initPlayer();
/**
* 设置播放地址
* 视频播放器第二步：设置数据
* @param path 播放地址
* @param headers 播放地址请求头
*/
public abstract void setDataSource(String path, Map<String, String> headers);
/**
* 用于播放raw和asset里面的视频文件
*/
public abstract void setDataSource(AssetFileDescriptor fd);
/**
* 设置渲染视频的View,主要用于TextureView
* 视频播放器第三步：设置surface
* @param surface surface
*/
public abstract void setSurface(Surface surface);
/**
* 准备开始播放（异步）
* 视频播放器第四步：开始加载【异步】
*/
public abstract void prepareAsync();
/*----------------------------第二部分：视频播放器状态方法----------------------------------*/
/**
* 播放
*/
public abstract void start();
/**
* 暂停
*/
public abstract void pause();
/**
* 停止
*/
public abstract void stop();
/**
* 重置播放器
*/
public abstract void reset();
/**
* 是否正在播放
* @return 是否正在播放
*/
public abstract boolean isPlaying();
/**
* 调整进度
*/
public abstract void seekTo(long time);
/**
* 释放播放器
*/
public abstract void release();
/**
* 获取当前播放的位置
* @return 获取当前播放的位置
*/
public abstract long getCurrentPosition();
/**
* 获取视频总时长
* @return 获取视频总时长
*/
public abstract long getDuration();
/**
* 获取缓冲百分比
* @return 获取缓冲百分比
*/
public abstract int getBufferedPercentage();
/**
* 设置渲染视频的View,主要用于SurfaceView
* @param holder holder
*/
public abstract void setDisplay(SurfaceHolder holder);
/**
* 设置音量
* @param v1 v1
* @param v2 v2
*/
public abstract void setVolume(float v1, float v2);
/**
* 设置是否循环播放
* @param isLooping 布尔值
*/
public abstract void setLooping(boolean isLooping);
/**
* 设置其他播放配置
*/
public abstract void setOptions();
/**
* 设置播放速度
* @param speed 速度
*/
public abstract void setSpeed(float speed);
/**
* 获取播放速度
* @return 播放速度
*/
public abstract float getSpeed();
/**
* 获取当前缓冲的网速
* @return 获取网络
*/
public abstract long getTcpSpeed();
/*----------------------------第三部分：player绑定view后，需要监听播放状态--------------------*/
/**
* 绑定VideoView，监听播放异常，完成，开始准备，视频size变化，视频信息等操作
*/
public void setPlayerEventListener(VideoPlayerListener playerEventListener) {
this.mPlayerEventListener = playerEventListener;
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoKernel/src/main/java/com/yc/kernel/inter/VideoPlayerListener.java | Java | /*
Copyright 2017 yangchong211（github.com/yangchong211）
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package com.yc.kernel.inter;
import com.yc.kernel.utils.PlayerConstant;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2018/11/9
* desc : 播放器event监听
* revise:
* </pre>
*/
public interface VideoPlayerListener {
/**
* 异常
* 1 表示错误的链接
* 2 表示解析异常
* 3 表示其他的异常
* @param type 错误类型
*/
void onError(@PlayerConstant.ErrorType int type , String error);
/**
* 完成
*/
void onCompletion();
/**
* 视频信息
* @param what what
* @param extra extra
*/
void onInfo(int what, int extra);
/**
* 准备
*/
void onPrepared();
/**
* 视频size变化监听
* @param width 宽
* @param height 高
*/
void onVideoSizeChanged(int width, int height);
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoKernel/src/main/java/com/yc/kernel/utils/PlayerConstant.java | Java | package com.yc.kernel.utils;
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 final class PlayerConstant {
/**
* 视频传入url为空
*/
public static final int MEDIA_INFO_URL_NULL = -1;
/**
* 开始渲染视频画面
*/
public static final int MEDIA_INFO_VIDEO_RENDERING_START = 3;
/**
* 缓冲开始
*/
public static final int MEDIA_INFO_BUFFERING_START = 701;
/**
* 缓冲结束
*/
public static final int MEDIA_INFO_BUFFERING_END = 702;
/**
* 视频旋转信息
*/
public static final int MEDIA_INFO_VIDEO_ROTATION_CHANGED = 10001;
/**
* 通过注解限定类型
* TYPE_IJK IjkPlayer，基于IjkPlayer封装播放器
* TYPE_NATIVE MediaPlayer，基于原生自带的播放器控件
* TYPE_EXO 基于谷歌视频播放器
* TYPE_RTC 基于RTC视频播放器
*/
@Retention(RetentionPolicy.SOURCE)
public @interface PlayerType {
int TYPE_IJK = 1;
int TYPE_NATIVE = 2;
int TYPE_EXO = 3;
int TYPE_RTC = 4;
}
@Retention(RetentionPolicy.SOURCE)
public @interface ErrorType {
//错误的链接
int TYPE_SOURCE = 1;
//解析异常
int TYPE_PARSE = 2;
//其他异常
int TYPE_UNEXPECTED = 3;
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoKernel/src/main/java/com/yc/kernel/utils/PlayerFactoryUtils.java | Java | package com.yc.kernel.utils;
import android.content.Context;
import com.yc.kernel.factory.PlayerFactory;
import com.yc.kernel.impl.exo.ExoPlayerFactory;
import com.yc.kernel.impl.ijk.IjkPlayerFactory;
import com.yc.kernel.impl.media.MediaPlayerFactory;
import com.yc.kernel.inter.AbstractVideoPlayer;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2017/10/21
* desc : 工具类
* revise:
* </pre>
*/
public final class PlayerFactoryUtils {
/**
* 获取PlayerFactory具体实现类，获取内核
* TYPE_IJK IjkPlayer，基于IjkPlayer封装播放器
* TYPE_NATIVE MediaPlayer，基于原生自带的播放器控件
* TYPE_EXO 基于谷歌视频播放器
* TYPE_RTC 基于RTC视频播放器
* @param type 类型
* @return
*/
public static PlayerFactory getPlayer(@PlayerConstant.PlayerType int type){
if (type == PlayerConstant.PlayerType.TYPE_EXO){
return ExoPlayerFactory.create();
} else if (type == PlayerConstant.PlayerType.TYPE_IJK){
return IjkPlayerFactory.create();
} else if (type == PlayerConstant.PlayerType.TYPE_NATIVE){
return MediaPlayerFactory.create();
} else if (type == PlayerConstant.PlayerType.TYPE_RTC){
return IjkPlayerFactory.create();
} else {
return IjkPlayerFactory.create();
}
}
/**
* 获取PlayerFactory具体实现类，获取内核
* 创建对象的时候只需要传递类型type，而不需要对应的工厂，即可创建具体的产品对象
* TYPE_IJK IjkPlayer，基于IjkPlayer封装播放器
* TYPE_NATIVE MediaPlayer，基于原生自带的播放器控件
* TYPE_EXO 基于谷歌视频播放器
* TYPE_RTC 基于RTC视频播放器
* @param type 类型
* @return
*/
public static AbstractVideoPlayer getVideoPlayer(Context context,@PlayerConstant.PlayerType int type){
if (type == PlayerConstant.PlayerType.TYPE_EXO){
return ExoPlayerFactory.create().createPlayer(context);
} else if (type == PlayerConstant.PlayerType.TYPE_IJK){
return IjkPlayerFactory.create().createPlayer(context);
} else if (type == PlayerConstant.PlayerType.TYPE_NATIVE){
return MediaPlayerFactory.create().createPlayer(context);
} else if (type == PlayerConstant.PlayerType.TYPE_RTC){
return IjkPlayerFactory.create().createPlayer(context);
} else {
return IjkPlayerFactory.create().createPlayer(context);
}
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoKernel/src/main/java/com/yc/kernel/utils/VideoLogUtils.java | Java | /*
Copyright 2017 yangchong211（github.com/yangchong211）
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package com.yc.kernel.utils;
import android.util.Log;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2017/10/21
* desc : log工具
* revise:
* </pre>
*/
public final class VideoLogUtils {
private static final String TAG = "YCVideoPlayer";
private static boolean isLog = false;
/**
* 设置是否开启日志
* @param isLog 是否开启日志
*/
public static void setIsLog(boolean isLog) {
VideoLogUtils.isLog = isLog;
}
public static boolean isIsLog() {
return isLog;
}
public static void d(String message) {
if(isLog){
Log.d(TAG, message);
}
}
public static void i(String message) {
if(isLog){
Log.i(TAG, message);
}
}
public static void e(String msg) {
if (isLog) {
Log.e(TAG, msg);
}
}
public static void e(String message, Throwable throwable) {
if(isLog){
Log.e(TAG, message, throwable);
}
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoM3u8/build.gradle | Gradle | apply plugin: 'com.android.library'
android {
compileSdkVersion 29
buildToolsVersion '29.0.0'
defaultConfig {
minSdkVersion 17
targetSdkVersion 29
versionCode 1
versionName "1.0.0"
}
buildTypes {
release {
minifyEnabled false
proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
}
}
}
dependencies {
implementation fileTree(dir: 'libs', include: ['*.jar'])
implementation 'androidx.appcompat:appcompat:1.2.0'
api files('libs/commons-io-2.5.jar')
}
/** 以下开始是将Android Library上传到jcenter的相关配置**/
apply plugin: 'com.github.dcendents.android-maven'
apply plugin: 'com.jfrog.bintray'
//项目主页
def siteUrl = 'https://github.com/yangchong211/YCVideoPlayer' // project homepage
//项目的版本控制地址
def gitUrl = 'https://github.com/yangchong211/YCVideoPlayer.git' // project git
//发布到组织名称名字，必须填写
group = "cn.yc"
//发布到JCenter上的项目名字，必须填写
def libName = "VideoM3u8"
// 版本号，下次更新是只需要更改版本号即可
version = "1.0.0"
//生成源文件
task sourcesJar(type: Jar) {
from android.sourceSets.main.java.srcDirs
classifier = 'sources'
}
//生成文档
task javadoc(type: Javadoc) {
source = android.sourceSets.main.java.srcDirs
classpath += project.files(android.getBootClasspath().join(File.pathSeparator))
options.encoding "UTF-8"
options.charSet 'UTF-8'
options.author true
options.version true
options.links "https://github.com/linglongxin24/FastDev/tree/master/mylibrary/docs/javadoc"
failOnError false
}
//文档打包成jar
task javadocJar(type: Jar, dependsOn: javadoc) {
classifier = 'javadoc'
from javadoc.destinationDir
}
//拷贝javadoc文件
task copyDoc(type: Copy) {
from "${buildDir}/docs/"
into "docs"
}
//上传到jcenter所需要的源码文件
artifacts {
archives javadocJar
archives sourcesJar
}
// 配置maven库，生成POM.xml文件
install {
repositories.mavenInstaller {
// This generates POM.xml with proper parameters
pom {
project {
packaging 'aar'
//项目描述，自由填写
name 'This is video M3u8 lib'
url siteUrl
licenses {
license {
//开源协议
name 'The Apache Software License, Version 2.0'
url 'http://www.apache.org/licenses/LICENSE-2.0.txt'
}
}
developers {
developer {
//开发者的个人信息，根据个人信息填写
id 'yangchong'
name 'yc'
email 'yangchong211@163.com'
}
}
scm {
connection gitUrl
developerConnection gitUrl
url siteUrl
}
}
}
}
}
//上传到jcenter
Properties properties = new Properties()
properties.load(project.rootProject.file('local.properties').newDataInputStream())
bintray {
user = properties.getProperty("bintray.user") //读取 local.properties 文件里面的 bintray.user
key = properties.getProperty("bintray.apikey") //读取 local.properties 文件里面的 bintray.apikey
configurations = ['archives']
pkg {
repo = "maven"
name = libName //发布到JCenter上的项目名字，必须填写
desc = 'android video M3u8' //项目描述
websiteUrl = siteUrl
vcsUrl = gitUrl
licenses = ["Apache-2.0"]
publish = true
}
}
javadoc {
options {
//如果你的项目里面有中文注释的话，必须将格式设置为UTF-8，不然会出现乱码
encoding "UTF-8"
charSet 'UTF-8'
author true
version true
links "http://docs.oracle.com/javase/7/docs/api"
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoM3u8/src/main/java/com/yc/m3u8/bean/M3u8.java | Java | package com.yc.m3u8.bean;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2018/11/9
* desc : M3U8实体类
* revise:
* </pre>
*/
public class M3u8 {
private String basepath;
private List<M3u8Ts> tsList = new ArrayList<>();
private long startTime;//开始时间
private long endTime;//结束时间
private long startDownloadTime;//开始下载时间
private long endDownloadTime;//结束下载时间
public String getBasepath() {
return basepath;
}
public void setBasepath(String basepath) {
this.basepath = basepath;
}
public List<M3u8Ts> getTsList() {
return tsList;
}
public void setTsList(List<M3u8Ts> tsList) {
this.tsList = tsList;
}
public void addTs(M3u8Ts ts) {
this.tsList.add(ts);
}
public long getStartDownloadTime() {
return startDownloadTime;
}
public void setStartDownloadTime(long startDownloadTime) {
this.startDownloadTime = startDownloadTime;
}
public long getEndDownloadTime() {
return endDownloadTime;
}
public void setEndDownloadTime(long endDownloadTime) {
this.endDownloadTime = endDownloadTime;
}
/**
* 获取开始时间
*
* @return
*/
public long getStartTime() {
if (tsList.size()>0) {
Collections.sort(tsList);
startTime = tsList.get(0).getLongDate();
return startTime;
}
return 0;
}
/**
* 获取结束时间(加上了最后一段时间的持续时间)
*
* @return
*/
public long getEndTime() {
if (tsList.size()>0) {
M3u8Ts m3U8Ts = tsList.get(tsList.size() - 1);
endTime = m3U8Ts.getLongDate() + (long) (m3U8Ts.getSeconds() * 1000);
return endTime;
}
return 0;
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("basepath: " + basepath);
for (M3u8Ts ts : tsList) {
sb.append("\nts_file_name = " + ts);
}
sb.append("\n\nstartTime = " + startTime);
sb.append("\n\nendTime = " + endTime);
sb.append("\n\nstartDownloadTime = " + startDownloadTime);
sb.append("\n\nendDownloadTime = " + endDownloadTime);
return sb.toString();
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoM3u8/src/main/java/com/yc/m3u8/bean/M3u8Ts.java | Java | package com.yc.m3u8.bean;
import androidx.annotation.NonNull;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2018/11/9
* desc : m3u8切片类
* revise:
* </pre>
*/
public class M3u8Ts implements Comparable<M3u8Ts> {
private String file;
private float seconds;
public M3u8Ts(String file, float seconds) {
this.file = file;
this.seconds = seconds;
}
public String getFile() {
return file;
}
/**
* 获取文件名字，支取***.ts
* @return
*/
public String getFileName() {
String fileName = file.substring(file.lastIndexOf("/") + 1);
if (fileName.contains("?")) {
return fileName.substring(0, fileName.indexOf("?"));
}
return fileName;
}
public void setFile(String file) {
this.file = file;
}
public float getSeconds() {
return seconds;
}
public void setSeconds(float seconds) {
this.seconds = seconds;
}
@Override
public String toString() {
return file + " (" + seconds + "sec)";
}
/**
* 获取时间
*/
public long getLongDate() {
try {
return Long.parseLong(file.substring(0, file.lastIndexOf(".")));
} catch (Exception e) {
return 0;
}
}
@Override
public int compareTo(@NonNull M3u8Ts o) {
return file.compareTo(o.file);
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoM3u8/src/main/java/com/yc/m3u8/inter/BaseListener.java | Java | package com.yc.m3u8.inter;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2018/11/9
* desc : 监听基类
* revise:
* </pre>
*/
public interface BaseListener {
/**
* 开始的时候回调
*/
void onStart();
/**
* 错误的时候回调
* @param errorMsg 错误异常
*/
void onError(Throwable errorMsg);
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoM3u8/src/main/java/com/yc/m3u8/inter/DownLoadListener.java | Java | package com.yc.m3u8.inter;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2018/11/9
* desc : 加载监听器
* revise:
* </pre>
*/
public interface DownLoadListener {
/**
* 开始的时候回调
*/
void onStart();
/**
* 错误的时候回调
*
* @param errorMsg
*/
void onError(Throwable errorMsg);
/**
* 下载完成的时候回调
*/
void onCompleted();
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoM3u8/src/main/java/com/yc/m3u8/inter/M3U8Listener.java | Java | package com.yc.m3u8.inter;
import com.yc.m3u8.bean.M3u8;
/**
* @deprecated v2版本过时了，请用
* 监听器
* Created by HDL on 2017/7/25.
*/
public abstract class M3U8Listener implements DownLoadListener {
public void onM3U8Info(M3u8 m3U8) {
}
public void onDownloadingProgress(int total, int progress) {
}
/**
* 当获取到单个文件大小的时候回调
*
* @param fileSize 单个文件大小
*/
public void onLoadFileSizeForItem(long fileSize) {
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoM3u8/src/main/java/com/yc/m3u8/inter/OnDownloadListener.java | Java | package com.yc.m3u8.inter;
import com.yc.m3u8.inter.BaseListener;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2018/11/9
* desc : 下载监听
* revise:
* </pre>
*/
public interface OnDownloadListener extends BaseListener {
/**
* 下载m3u8文件.
* 注意：这个方法是异步的（子线程中执行），所以不能在此方法中回调，其他方法为主线程中回调
*
* @param itemFileSize 单个文件的大小
* @param totalTs ts总数
* @param curTs 当前下载完成的ts个数
*/
void onDownloading(long itemFileSize, int totalTs, int curTs);
/**
* 下载成功
*/
void onSuccess();
/**
* 当前已经下载的文件大小
*
* @param curLength
*/
void onProgress(long curLength);
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoM3u8/src/main/java/com/yc/m3u8/inter/OnM3u8InfoListener.java | Java | package com.yc.m3u8.inter;
import com.yc.m3u8.bean.M3u8;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2018/11/9
* desc : 获取M3U8信息
* revise:
* </pre>
*/
public interface OnM3u8InfoListener extends BaseListener {
/**
* 获取成功的时候回调
*/
void onSuccess(M3u8 m3U8);
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoM3u8/src/main/java/com/yc/m3u8/manager/M3u8InfoManger.java | Java | package com.yc.m3u8.manager;
import android.annotation.SuppressLint;
import android.os.Handler;
import android.os.Message;
import com.yc.m3u8.bean.M3u8;
import com.yc.m3u8.inter.OnM3u8InfoListener;
import com.yc.m3u8.utils.M3u8FileUtils;
import java.io.IOException;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2018/11/9
* desc : 获取M3U8信息的管理器
* revise:
* </pre>
*/
public class M3u8InfoManger {
private static M3u8InfoManger mM3U8InfoManger;
private OnM3u8InfoListener onM3U8InfoListener;
private static final int WHAT_ON_ERROR = 1101;
private static final int WHAT_ON_SUCCESS = 1102;
@SuppressLint("HandlerLeak")
private Handler mHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case WHAT_ON_ERROR:
onM3U8InfoListener.onError((Throwable) msg.obj);
break;
case WHAT_ON_SUCCESS:
onM3U8InfoListener.onSuccess((M3u8) msg.obj);
break;
}
}
};
private M3u8InfoManger() {
}
public static M3u8InfoManger getInstance() {
synchronized (M3u8InfoManger.class) {
if (mM3U8InfoManger == null) {
mM3U8InfoManger = new M3u8InfoManger();
}
}
return mM3U8InfoManger;
}
/**
* 获取m3u8信息
*
* @param url
* @param onM3U8InfoListener
*/
public synchronized void getM3U8Info(final String url, OnM3u8InfoListener onM3U8InfoListener) {
this.onM3U8InfoListener = onM3U8InfoListener;
onM3U8InfoListener.onStart();
new Thread() {
@Override
public void run() {
try {
// Log.e("hdltag", "run(M3U8InfoManger.java:62):" + url);
M3u8 m3u8 = M3u8FileUtils.parseIndex(url);
handlerSuccess(m3u8);
} catch (IOException e) {
// e.printStackTrace();
handlerError(e);
}
}
}.start();
}
/**
* 通知异常
*
* @param e
*/
private void handlerError(Throwable e) {
Message msg = mHandler.obtainMessage();
msg.obj = e;
msg.what = WHAT_ON_ERROR;
mHandler.sendMessage(msg);
}
/**
* 通知成功
*
* @param m3u8
*/
private void handlerSuccess(M3u8 m3u8) {
Message msg = mHandler.obtainMessage();
msg.obj = m3u8;
msg.what = WHAT_ON_SUCCESS;
mHandler.sendMessage(msg);
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoM3u8/src/main/java/com/yc/m3u8/manager/M3u8LiveManger.java | Java | package com.yc.m3u8.manager;
import android.os.Handler;
import android.os.Message;
import android.util.Log;
import com.yc.m3u8.bean.M3u8;
import com.yc.m3u8.bean.M3u8Ts;
import com.yc.m3u8.inter.OnDownloadListener;
import com.yc.m3u8.utils.M3u8FileUtils;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;
import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2018/11/9
* desc : 直播管理器
* revise:
* </pre>
*/
public class M3u8LiveManger {
private static M3u8LiveManger mM3U8LiveManger;
private ExecutorService executor = Executors.newFixedThreadPool(5);
private ExecutorService downloadExecutor = Executors.newFixedThreadPool(5);
private Timer getM3U8InfoTimer;
private String basePath;
private OnDownloadListener onDownloadListener;
/**
* 当前已经在下完成的大小
*/
private long curLenght = 0;
/**
* 读取超时时间
*/
private int readTimeout = 30 * 60 * 1000;
//当前下载完成的文件个数
private static int curTs = 0;
//总文件的个数
private static int totalTs = 0;
//单个文件的大小
private static long itemFileSize = 0;
/**
* 链接超时时间
*/
private int connTimeout = 10 * 1000;
private static final int WHAT_ON_ERROR = 1001;
private static final int WHAT_ON_PROGRESS = 1002;
private static final int WHAT_ON_SUCCESS = 1003;
private Handler mHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case WHAT_ON_ERROR:
onDownloadListener.onError((Throwable) msg.obj);
break;
case WHAT_ON_PROGRESS:
onDownloadListener.onDownloading(itemFileSize, totalTs, curTs);
break;
case WHAT_ON_SUCCESS:
if (netSpeedTimer != null) {
netSpeedTimer.cancel();
}
onDownloadListener.onSuccess();
break;
}
}
};
/**
* 定时任务
*/
private Timer netSpeedTimer;
/**
* 文件保存的目录
*/
private String tempDir = "/sdcard/111/" + System.currentTimeMillis();
/**
* 已经下载的文件列表
*/
private List<File> downloadedFileList = new ArrayList<>();
private M3u8LiveManger() {
}
public static M3u8LiveManger getInstance() {
if (mM3U8LiveManger == null) {
synchronized (M3u8LiveManger.class) {
if (mM3U8LiveManger == null) {
mM3U8LiveManger = new M3u8LiveManger();
}
}
}
return mM3U8LiveManger;
}
/**
* 获取文件临时保存的目录
*
* @return
*/
public String getTempDir() {
return tempDir;
}
/**
* 设置文件临时保存的目录
*
* @param tempDir
*/
public M3u8LiveManger setTempDir(String tempDir) {
this.tempDir = tempDir;
return this;
}
/**
* 缓存视频中
*
* @param url
* @param onDownloadListener1
*/
public void caching(String url, OnDownloadListener onDownloadListener1) {
this.onDownloadListener = onDownloadListener1;
onDownloadListener.onStart();
netSpeedTimer = new Timer();
netSpeedTimer.schedule(new TimerTask() {
@Override
public void run() {
onDownloadListener.onProgress(curLenght);
}
}, 0, 1000);
startUpdateM3U8Info(url);
}
/**
* 开始下载
*/
private void startDownloadM3U8() {
final File dir = new File(tempDir);
if (!dir.exists()) {
dir.mkdirs();
}
for (final M3u8Ts m3U8Ts : m3U8TsList) {
downloadExecutor.execute(new Runnable() {
@Override
public void run() {
File file = new File(dir, m3U8Ts.getFileName());
if (!file.exists()) {
FileOutputStream fos = null;
InputStream inputStream = null;
try {
Log.i("hdltag", "run(M3U8DownloadTask.java:278):" + m3U8Ts.getFile());
String urlPath;
if ("http".equals(m3U8Ts.getFile().substring(0, 4))) {
urlPath = m3U8Ts.getFile();
} else {
urlPath = basePath + m3U8Ts.getFile();
}
URL url = new URL(urlPath);
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setConnectTimeout(connTimeout);
conn.setReadTimeout(readTimeout);
if (conn.getResponseCode() == 200) {
inputStream = conn.getInputStream();
fos = new FileOutputStream(file);//会自动创建文件
int len = 0;
byte[] buf = new byte[8 * 1024 * 1024];
while ((len = inputStream.read(buf)) != -1) {
curLenght += len;
fos.write(buf, 0, len);//写入流中
}
downloadedFileList.add(file);
Log.i("hdltag", "run(M3U8LiveManger.java:138):下完一个了" + file.getAbsolutePath());
// Log.e("hdltag", "run(M3U8DownloadTask.java:188):进度\t" + totalTs + "-----" + curTs);
} else {
handlerError(new Throwable(String.valueOf(conn.getResponseCode())));
}
} catch (MalformedURLException e) {
// e.printStackTrace();
handlerError(e);
} catch (IOException e) {
// e.printStackTrace();
handlerError(e);
} finally {//关流
if (inputStream != null) {
try {
inputStream.close();
} catch (IOException e) {
// e.printStackTrace();
}
}
if (fos != null) {
try {
fos.close();
} catch (IOException e) {
// e.printStackTrace();
}
}
}
curTs++;
if (curTs == 3) {
itemFileSize = file.length();
}
mHandler.sendEmptyMessage(WHAT_ON_PROGRESS);
}
}
});
}
}
/**
* 通知异常
*
* @param e
*/
private void handlerError(Throwable e) {
if (!"Task running".equals(e.getMessage())) {
stop();
}
//不提示被中断的情况
if ("thread interrupted".equals(e.getMessage())) {
return;
}
Message msg = mHandler.obtainMessage();
msg.obj = e;
msg.what = WHAT_ON_ERROR;
mHandler.sendMessage(msg);
}
/**
* 请求到的所有下载列表
*/
private List<M3u8Ts> m3U8TsList = new ArrayList<>();
/**
* 定时获取m3u8信息
*
* @param url
*/
private void startUpdateM3U8Info(final String url) {
if (getM3U8InfoTimer != null) {
getM3U8InfoTimer.cancel();
getM3U8InfoTimer = null;
}
getM3U8InfoTimer = new Timer();
getM3U8InfoTimer.schedule(new TimerTask() {
@Override
public void run() {
executor.execute(new Runnable() {
@Override
public void run() {
try {
M3u8 m3u8 = M3u8FileUtils.parseIndex(url);
if (m3u8 != null && m3u8.getTsList().size() > 0) {
basePath = m3u8.getBasepath();
addTs(m3u8.getTsList());
// m3U8TsList.addAll(m3u8.getTsList());
}
// Log.e("hdltag", "run(M3U8LiveManger.java:59):" + m3u8);
} catch (IOException e) {
e.printStackTrace();
handlerError(e);
}
}
});
}
}, 0, 2000);
}
/**
* 添加到下载列表，做去重处理
*
* @param tsList
*/
private synchronized void addTs(List<M3u8Ts> tsList) {
List<M3u8Ts> tempTsList = new ArrayList<>();
for (M3u8Ts m3U8Ts : tsList) {
boolean isExisted = false;
for (M3u8Ts mTs : m3U8TsList) {
if (mTs.getFile().equals(m3U8Ts.getFile())) {
isExisted = true;
break;
}
}
if (!isExisted) {
tempTsList.add(m3U8Ts);
}
}
if (tempTsList.size() > 0) {
m3U8TsList.addAll(tempTsList);
}
Log.i("hdltag", "addTs(M3U8LiveManger.java:98):有几个了 ---->" + m3U8TsList.size());
for (M3u8Ts m3U8Ts : m3U8TsList) {
Log.i("hdltag", "addTs(M3U8LiveManger.java:101):" + m3U8Ts.getFile());
}
//有更新，通知下载
startDownloadM3U8();
}
/**
* 停止任务
*/
public void stop() {
Log.i("hdltag", "stop(M3U8LiveManger.java:106):调用停止了");
if (getM3U8InfoTimer != null) {
getM3U8InfoTimer.cancel();
getM3U8InfoTimer = null;
}
if (executor != null) {
if (!executor.isShutdown()) {
executor.shutdownNow();
}
}
}
/**
* 文件保存的目录（包含文件名字，必须是ts结尾）
*/
private String saveFilePath = "/sdcard/11/" + System.currentTimeMillis() + ".ts";
public String getSaveFilePath() {
return saveFilePath;
}
/**
* 设置需要将缓存文件保存的位置（包含文件名字，必须是ts结尾）
*
* @param saveFile
*/
public M3u8LiveManger setSaveFile(String saveFile) {
this.saveFilePath = saveFile;
return this;
}
/**
* 获取从开始到现在的视频
*/
public String getCurrentTs() {
try {
M3u8FileUtils.merge(downloadedFileList, saveFilePath);
} catch (IOException e) {
e.printStackTrace();
return "";
}
Log.i("hdltag", "getCurrentTs(M3U8LiveManger.java:287):已保存至 " + saveFilePath);
return saveFilePath;
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoM3u8/src/main/java/com/yc/m3u8/manager/M3u8Manger.java | Java | package com.yc.m3u8.manager;
import android.os.Environment;
import android.os.Handler;
import android.os.Message;
import android.util.Log;
import com.yc.m3u8.bean.M3u8;
import com.yc.m3u8.inter.M3U8Listener;
import com.yc.m3u8.bean.M3u8Ts;
import com.yc.m3u8.task.M3u8DownloadTask;
import com.yc.m3u8.utils.M3u8FileUtils;
import org.apache.commons.io.IOUtils;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InterruptedIOException;
import java.net.URL;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2018/11/9
* desc : M3u8管理器
* revise: v2过时了，获取M3U8信息{@link M3u8InfoManger}和下载{@link M3u8DownloadTask}隔离出来
* </pre>
*/
public class M3u8Manger {
private static int currDownloadTsCount = 0;//当前下载ts切片的个数
private static final int WHAT_ON_START = 166;
private static final int WHAT_ON_ERROR = 711;
private static final int WHAT_ON_GETINFO = 840;
private static final int WHAT_ON_COMPLITED = 625;
private static final int WHAT_ON_PROGRESS = 280;
private static final int WHAT_ON_FILESIZE_ITEM = 281;
private static final String KEY_DEFAULT_TEMP_DIR = "/sdcard/1m3u8temp/";
private static M3u8Manger mM3U8Manger;
private String url;//m3u8的路径
private String saveFilePath = "/sdcard/Movie/" + System.currentTimeMillis() + ".ts";//文件保存路径
private String tempDir = KEY_DEFAULT_TEMP_DIR;//m3u8临时文件夹
private ExecutorService executor;//10个线程池
private M3U8Listener downLoadListener;
private boolean isRunning = false;//任务是否正在运行
private Handler mHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
if (downLoadListener != null) {
switch (msg.what) {
case WHAT_ON_START:
downLoadListener.onStart();
break;
case WHAT_ON_ERROR:
isRunning = false;//停止任务
currDownloadTsCount = 0;//出错也要复位
M3u8FileUtils.clearDir(new File(tempDir));
downLoadListener.onError((Throwable) msg.obj);
break;
case WHAT_ON_GETINFO:
M3u8 m3U8 = (M3u8) msg.obj;
downLoadListener.onM3U8Info(m3U8);
break;
case WHAT_ON_COMPLITED:
currDownloadTsCount = 0;//完成之后要复位
downLoadListener.onCompleted();
break;
case WHAT_ON_FILESIZE_ITEM:
downLoadListener.onLoadFileSizeForItem((Long) msg.obj);
break;
case WHAT_ON_PROGRESS:
// long size = (long) msg.obj;
long curTime = System.currentTimeMillis();
lastTime = curTime;
downLoadListener.onDownloadingProgress(msg.arg1, msg.arg2);
break;
}
}
}
};
private long lastTime = 0;
private M3u8Manger() {
}
public static M3u8Manger getInstance() {
synchronized (M3u8Manger.class) {
if (mM3U8Manger == null) {
mM3U8Manger = new M3u8Manger();
}
}
return mM3U8Manger;
}
/**
* 下载
*
* @param downLoadListener
*/
public synchronized void download(M3U8Listener downLoadListener) {
this.downLoadListener = downLoadListener;
if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
if (!isRunning) {
startDownload(-1, -1);
} else {
handlerError(new Throwable("Task isRunning"));
}
} else {//没有找到sdcard
handlerError(new Throwable("SDcard not found"));
}
}
/**
* 返回时候正在运行中
*
* @return
*/
public synchronized boolean isRunning() {
return isRunning;
}
/**
* 下载指定时间的ts
*
* @param downLoadListener
*/
public synchronized void download(long startDwonloadTime, long endDownloadTime, M3U8Listener downLoadListener) {
this.downLoadListener = downLoadListener;
if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
if (!isRunning) {
startDownload(startDwonloadTime, endDownloadTime);
} else {
handlerError(new Throwable("Task isRunning"));
}
} else {//没有找到sdcard
handlerError(new Throwable("SDcard not found"));
}
}
/**
* 停止任务
*/
public synchronized void stop() {
isRunning = false;
if (executor != null) {
executor.shutdownNow();
executor = null;
//清空临时目录
M3u8FileUtils.clearDir(new File(tempDir));
}
// mHandler.sendEmptyMessage(WHAT_ON_COMPLITED);
}
/**
* 获取m3u8
*
* @param downLoadListener
*/
public synchronized void getM3U8(M3U8Listener downLoadListener) {
this.downLoadListener = downLoadListener;
downLoadListener.onStart();//开始了
if (!isRunning) {
new Thread() {
@Override
public void run() {
isRunning = true;
try {
M3u8 m3u8 = M3u8FileUtils.parseIndex(url);
isRunning = false;//获取成功之后要复位
sendM3u8Info(m3u8);
mHandler.sendEmptyMessage(WHAT_ON_COMPLITED);
} catch (IOException e) {
e.printStackTrace();
handlerError(e);
}
}
}.start();
} else {
handlerError(new Throwable("Task isRunning"));
}
}
/**
* 开始下载了
*/
private synchronized void startDownload(final long startDwonloadTime, final long endDownloadTime) {
mHandler.sendEmptyMessage(WHAT_ON_START);
isRunning = true;//开始下载了
new Thread() {
@Override
public void run() {
try {
M3u8 m3u8 = null;
try {
m3u8 = M3u8FileUtils.parseIndex(url);
m3u8.setStartDownloadTime(startDwonloadTime);
m3u8.setEndDownloadTime(endDownloadTime);
sendM3u8Info(m3u8);
} catch (Exception e) {
handlerError(e);
return;
}
if (executor != null && executor.isTerminated()) {
executor.shutdownNow();
executor = null;
}
executor = Executors.newFixedThreadPool(10);
if (isRunning()) {
download(m3u8, tempDir);//开始下载,保存在临时文件中
}
if (executor != null) {
executor.shutdown();//下载完成之后要关闭线程池
}
// System.out.println("Wait for downloader...");
while (executor != null && !executor.isTerminated()) {
Thread.sleep(100);
}
if (isRunning()) {
String tempFile = tempDir + "/" + System.currentTimeMillis() + ".ts";
M3u8FileUtils.merge(m3u8, tempFile);//合并ts
//移动到指定的目录
M3u8FileUtils.moveFile(tempFile, saveFilePath);
mHandler.sendEmptyMessage(WHAT_ON_COMPLITED);
isRunning = false;//复位
}
} catch (IOException e) {
e.printStackTrace();
handlerError(e);
} catch (InterruptedException e) {
e.printStackTrace();
handlerError(e);
} finally {
//清空临时目录
M3u8FileUtils.clearDir(new File(tempDir));
}
}
}.start();
}
/**
* 通知拿到消息
*
* @param m3u8
*/
private void sendM3u8Info(M3u8 m3u8) {
Message msg = mHandler.obtainMessage();
msg.obj = m3u8;
msg.what = WHAT_ON_GETINFO;
mHandler.sendMessage(msg);
}
/**
* 通知异常
*
* @param e
*/
private void handlerError(Throwable e) {
Message msg = mHandler.obtainMessage();
msg.obj = e;
msg.what = WHAT_ON_ERROR;
mHandler.sendMessage(msg);
}
/**
* 设置m3u8文件的路径
*
* @param url
* @return
*/
public synchronized M3u8Manger setUrl(String url) {
this.url = url;
return this;
}
/**
* 设置保存文件的名字
*
* @param saveFilePath
* @return
*/
public synchronized M3u8Manger setSaveFilePath(String saveFilePath) {
this.saveFilePath = saveFilePath;
tempDir = KEY_DEFAULT_TEMP_DIR;
// tempDir += new File(saveFilePath).getName();
return this;
}
/**
* 下载
*
* @param m3u8
* @param saveFileName
* @throws IOException
*/
private void download(final M3u8 m3u8, final String saveFileName) throws IOException {
Log.e("hdltag", "caching(M3U8Manger.java:293):" + saveFileName);
final File dir = new File(saveFileName);
if (!dir.exists()) {
dir.mkdirs();
} else if (dir.list().length > 0) {//保存的路径必须必须为空或者文件夹不存在
M3u8FileUtils.clearDir(dir);//清空文件
}
final List<M3u8Ts> downList = M3u8FileUtils.getLimitM3U8Ts(m3u8);
final int total = downList.size();
for (final M3u8Ts ts : downList) {
if (executor != null && !executor.isShutdown()) {//正常的时候才能走
executor.execute(new Runnable() {
@Override
public void run() {
try {
// System.out.println("caching " + (m3u8.getTsList().indexOf(ts) + 1) + "/"
// + m3u8.getTsList().size() + ": " + ts);
if (isRunning()) {
FileOutputStream writer = null;
long size = 0;
try {
writer = new FileOutputStream(new File(dir, ts.getFileName()));
size = IOUtils.copyLarge(new URL(m3u8.getBasepath() + ts.getFileName()).openStream(), writer);
} catch (InterruptedIOException exception) {
isRunning = false;
currDownloadTsCount = 0;
System.out.println("----------InterruptedIOException------------");
return;
} finally {
if (writer != null) {
writer.close();
}
}
currDownloadTsCount++;
if (currDownloadTsCount == 2) {//由于每个ts文件的大小基本是固定的（头尾有点差距），可以通过单个文件的大小来算整个文件的大小
long length = new File(dir, ts.getFileName()).length();
Message msg = mHandler.obtainMessage();
msg.what = WHAT_ON_FILESIZE_ITEM;
msg.obj = length;
mHandler.sendMessage(msg);
}
Message msg = mHandler.obtainMessage();
msg.what = WHAT_ON_PROGRESS;
msg.obj = size;
msg.arg1 = total;
msg.arg2 = currDownloadTsCount;
mHandler.sendMessage(msg);
}
// System.out.println("caching ok for: " + ts);
} catch (IOException e) {
e.printStackTrace();
handlerError(e);
}
}
});
} else {
handlerError(new Throwable("executor is shutdown"));
}
}
}
/**
* 获取当前下载速度
*
* @return
*/
public String getNetSpeed() {
int speed = (int) (Math.random() * 1024 + 1);
return speed + " kb/s";
}
/**
* 获取当前下载速度
*
* @param max 最大值
* @return
*/
public String getNetSpeed(int max) {
int speed = (int) (Math.random() * max + 1);
return speed + " kb/s";
}
} | yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoM3u8/src/main/java/com/yc/m3u8/task/M3u8DownloadTask.java | Java | package com.yc.m3u8.task;
import android.os.Environment;
import android.os.Handler;
import android.os.Message;
import com.yc.m3u8.manager.M3u8InfoManger;
import com.yc.m3u8.bean.M3u8;
import com.yc.m3u8.bean.M3u8Ts;
import com.yc.m3u8.inter.OnDownloadListener;
import com.yc.m3u8.inter.OnM3u8InfoListener;
import com.yc.m3u8.utils.M3u8FileUtils;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InterruptedIOException;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2018/11/9
* desc : M3U8下载管理器
* revise:
* </pre>
*/
public class M3u8DownloadTask {
private OnDownloadListener onDownloadListener;
private static final int WHAT_ON_ERROR = 1001;
private static final int WHAT_ON_PROGRESS = 1002;
private static final int WHAT_ON_SUCCESS = 1003;
public M3u8DownloadTask(String taskId) {
this.taskId = taskId;
//需要加上当前时间作为文件夹（由于合并时是根据文件夹来合并的，合并之后需要删除所有的ts文件，这里用到了多线程，所以需要按文件夹来存ts）
tempDir += File.separator + System.currentTimeMillis() / (1000 * 60 * 60 * 24) + "-" + taskId;
}
//临时下载目录
private String tempDir = Environment.getExternalStorageDirectory().getPath() + File.separator + "m3u8temp";
//最终文件保存的路径
private String saveFilePath = Environment.getExternalStorageDirectory().getPath() + File.separator + "11m3u8";
//当前下载完成的文件个数
private static int curTs = 0;
//总文件的个数
private static int totalTs = 0;
//单个文件的大小
private static long itemFileSize = 0;
/**
* 当前已经在下完成的大小
*/
private long curLenght = 0;
/**
* 任务是否正在运行中
*/
private boolean isRunning = false;
/**
* 任务id，用于断点续传.
* 如果任务已经停止、下一次会根据此id来找到上一次已经下载完成的ts文件，开始下载之前，会判断是否已经下载过了，下载了就不再下载
*/
private String taskId = "0";
/**
* 线程池最大线程数，默认为3
*/
private int threadCount = 3;
/**
* 时候清楚临时目录，默认清除
*/
private boolean isClearTempDir = true;
/**
* 读取超时时间
*/
private int readTimeout = 30 * 60 * 1000;
/**
* 链接超时时间
*/
private int connTimeout = 10 * 1000;
/**
* 定时任务
*/
private Timer netSpeedTimer;
private ExecutorService executor;//线程池
private Handler mHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case WHAT_ON_ERROR:
onDownloadListener.onError((Throwable) msg.obj);
break;
case WHAT_ON_PROGRESS:
onDownloadListener.onDownloading(itemFileSize, totalTs, curTs);
break;
case WHAT_ON_SUCCESS:
if (netSpeedTimer != null) {
netSpeedTimer.cancel();
}
onDownloadListener.onSuccess();
break;
}
}
};
/**
* 设置最大线程数
*
* @param threadCount
*/
public void setThreadCount(int threadCount) {
this.threadCount = threadCount;
}
/**
* 开始下载
*
* @param url
* @param onDownloadListener
*/
public void download(final String url, OnDownloadListener onDownloadListener) {
this.onDownloadListener = onDownloadListener;
if (!isRunning()) {
getM3U8Info(url);
} else {
handlerError(new Throwable("Task running"));
}
}
public long getReadTimeout() {
return readTimeout;
}
public void setReadTimeout(int readTimeout) {
this.readTimeout = readTimeout;
}
public long getConnTimeout() {
return connTimeout;
}
public void setConnTimeout(int connTimeout) {
this.connTimeout = connTimeout;
}
public boolean isClearTempDir() {
return isClearTempDir;
}
public void setClearTempDir(boolean clearTempDir) {
isClearTempDir = clearTempDir;
}
public String getTaskId() {
return taskId;
}
/**
* 获取任务是否正在执行
*
* @return
*/
public boolean isRunning() {
return isRunning;
}
/**
* 先获取m3u8信息
*
* @param url
*/
private void getM3U8Info(String url) {
M3u8InfoManger.getInstance().getM3U8Info(url, new OnM3u8InfoListener() {
@Override
public void onSuccess(final M3u8 m3U8) {
new Thread() {
@Override
public void run() {
try {
startDownload(m3U8);
if (executor != null) {
executor.shutdown();//下载完成之后要关闭线程池
}
while (executor != null && !executor.isTerminated()) {
//等待中
Thread.sleep(100);
}
if (isRunning) {
String saveFileName = saveFilePath.substring(saveFilePath.lastIndexOf("/") + 1);
String tempSaveFile = tempDir + File.separator + saveFileName;//生成临时文件
M3u8FileUtils.merge(m3U8, tempSaveFile, tempDir);//合并ts
//移动到指定的目录
M3u8FileUtils.moveFile(tempSaveFile, saveFilePath);//移动到指定文件夹
if (isClearTempDir) {
mHandler.postDelayed(new Runnable() {
@Override
public void run() {
M3u8FileUtils.clearDir(new File(tempDir));//清空一下临时文件
}
}, 20 * 1000);//20s之后再删除
}
mHandler.sendEmptyMessage(WHAT_ON_SUCCESS);
isRunning = false;
}
} catch (InterruptedIOException e) {
// e.printStackTrace();
//被中断了，使用stop时会抛出这个，不需要处理
// handlerError(e);
return;
} catch (IOException e) {
// e.printStackTrace();
handlerError(e);
return;
} catch (InterruptedException e) {
// e.printStackTrace();
handlerError(e);
}
}
}.start();
}
@Override
public void onStart() {
onDownloadListener.onStart();
isRunning = true;
}
@Override
public void onError(Throwable errorMsg) {
handlerError(errorMsg);
}
});
}
/**
* 开始下载
*
* @param m3U8
*/
private void startDownload(final M3u8 m3U8) {
if (m3U8 == null) {
handlerError(new Throwable("M3U8 is null"));
return;
}
final File dir = new File(tempDir);
//没有就创建
if (!dir.exists()) {
dir.mkdirs();
}/* else {
//有就清空内容
MUtils.clearDir(dir);
}*/
totalTs = m3U8.getTsList().size();
if (executor != null && executor.isTerminated()) {
executor.shutdownNow();
executor = null;
}
executor = Executors.newFixedThreadPool(threadCount);
final String basePath = m3U8.getBasepath();
netSpeedTimer = new Timer();
netSpeedTimer.schedule(new TimerTask() {
@Override
public void run() {
onDownloadListener.onProgress(curLenght);
}
}, 0, 1000);
for (final M3u8Ts m3U8Ts : m3U8.getTsList()) {//循环下载
executor.execute(new Runnable() {
@Override
public void run() {
File file = new File(dir + File.separator + m3U8Ts.getFileName());
if (!file.exists()) {//下载过的就不管了
FileOutputStream fos = null;
InputStream inputStream = null;
try {
String urlPath;
if ("http".equals(m3U8Ts.getFile().substring(0, 4))) {
urlPath = m3U8Ts.getFile();
} else {
urlPath = basePath + m3U8Ts.getFile();
}
URL url = new URL(urlPath);
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setConnectTimeout(connTimeout);
conn.setReadTimeout(readTimeout);
if (conn.getResponseCode() == 200) {
inputStream = conn.getInputStream();
fos = new FileOutputStream(file);//会自动创建文件
int len = 0;
byte[] buf = new byte[8 * 1024 * 1024];
while ((len = inputStream.read(buf)) != -1) {
curLenght += len;
fos.write(buf, 0, len);//写入流中
}
} else {
handlerError(new Throwable(String.valueOf(conn.getResponseCode())));
}
} catch (MalformedURLException e) {
// e.printStackTrace();
handlerError(e);
} catch (IOException e) {
// e.printStackTrace();
handlerError(e);
} finally {//关流
if (inputStream != null) {
try {
inputStream.close();
} catch (IOException e) {
// e.printStackTrace();
}
}
if (fos != null) {
try {
fos.close();
} catch (IOException e) {
// e.printStackTrace();
}
}
}
curTs++;
if (curTs == 3) {
itemFileSize = file.length();
}
mHandler.sendEmptyMessage(WHAT_ON_PROGRESS);
}
}
});
}
}
public String getSaveFilePath() {
return saveFilePath;
}
public void setSaveFilePath(String saveFilePath) {
this.saveFilePath = saveFilePath;
}
/**
* 通知异常
*
* @param e
*/
private void handlerError(Throwable e) {
if (!"Task running".equals(e.getMessage())) {
stop();
}
//不提示被中断的情况
if ("thread interrupted".equals(e.getMessage())) {
return;
}
Message msg = mHandler.obtainMessage();
msg.obj = e;
msg.what = WHAT_ON_ERROR;
mHandler.sendMessage(msg);
}
/**
* 停止任务
*/
public void stop() {
if (netSpeedTimer != null) {
netSpeedTimer.cancel();
netSpeedTimer = null;
}
isRunning = false;
if (executor != null) {
executor.shutdownNow();
}
}
// /**
// * 获取当前下载速度
// *
// * @param max 最大值
// * @return
// */
// public String getNetSpeed(int max) {
// int speed = (int) (Math.random() * max + 1);
// return speed + " kb/s";
// }
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.