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 |
|---|---|---|---|---|---|---|---|---|---|
VideoM3u8/src/main/java/com/yc/m3u8/utils/M3u8FileUtils.java | Java | package com.yc.m3u8.utils;
import android.util.Log;
import com.yc.m3u8.bean.M3u8;
import com.yc.m3u8.bean.M3u8Ts;
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.IOUtils;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2018/11/9
* desc : M3u8工具类
* revise:
* </pre>
*/
public final class M3u8FileUtils {
/**
* 将Url转换为M3U8对象
* @param url
* @return
* @throws IOException
*/
public static M3u8 parseIndex(String url) throws IOException {
HttpURLConnection conn = (HttpURLConnection) new URL(url).openConnection();
if (conn.getResponseCode() == 200) {
String realUrl = conn.getURL().toString();
BufferedReader reader = new BufferedReader(new InputStreamReader(conn.getInputStream()));
String basepath = realUrl.substring(0, realUrl.lastIndexOf("/") + 1);
M3u8 ret = new M3u8();
ret.setBasepath(basepath);
String line;
float seconds = 0;
while ((line = reader.readLine()) != null) {
if (line.startsWith("#")) {
if (line.startsWith("#EXTINF:")) {
line = line.substring(8);
if (line.endsWith(",")) {
line = line.substring(0, line.length() - 1);
}
seconds = Float.parseFloat(line);
}
continue;
}
if (line.endsWith("m3u8")) {
return parseIndex(basepath + line);
}
ret.addTs(new M3u8Ts(line, seconds));
seconds = 0;
}
reader.close();
return ret;
} else {
return null;
}
}
/**
* 将M3U8对象的所有ts切片合并为1个
*
* @param m3u8
* @param tofile
* @throws IOException
*/
public static String merge(M3u8 m3u8, String tofile) throws IOException {
List<M3u8Ts> mergeList = getLimitM3U8Ts(m3u8);
File file = new File(tofile);
FileOutputStream fos = new FileOutputStream(file);
for (M3u8Ts ts : mergeList) {
IOUtils.copyLarge(new FileInputStream(new File(file.getParentFile(), ts.getFileName())), fos);
}
fos.close();
return tofile;
}
/**
* 合并文件
*
* @param fileList 文件列表
* @param toFile 合并之后的文件
*/
public static void merge(List<File> fileList, String toFile) throws IOException {
File file = new File(toFile);
File dir=file.getParentFile();
if (!dir.exists()) {
dir.mkdirs();
}
FileOutputStream fos = new FileOutputStream(file);
for (File tsFile : fileList) {
IOUtils.copyLarge(new FileInputStream(tsFile), fos);
}
fos.close();
}
/**
* 将M3U8对象的所有ts切片合并为1个
*
* @param m3u8
* @param tofile
* @throws IOException
*/
public static void merge(M3u8 m3u8, String tofile, String basePath) throws IOException {
List<M3u8Ts> mergeList = getLimitM3U8Ts(m3u8);
File saveFile = new File(tofile);
FileOutputStream fos = new FileOutputStream(saveFile);
File file;
for (M3u8Ts ts : mergeList) {
file = new File(basePath, ts.getFileName());
if (file.isFile() && file.exists()) {
IOUtils.copyLarge(new FileInputStream(file), fos);
}
}
fos.close();
}
/**
* 移动文件
*
* @param sFile
* @param tFile
*/
public static void moveFile(String sFile, String tFile) {
try {
FileUtils.moveFile(new File(sFile), new File(tFile));
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 清空文件夹
*/
public static void clearDir(File dir) {
if (dir.exists()) {// 判断文件是否存在
if (dir.isFile()) {// 判断是否是文件
dir.delete();// 删除文件
} else if (dir.isDirectory()) {// 否则如果它是一个目录
File[] files = dir.listFiles();// 声明目录下所有的文件 files[];
for (int i = 0; i < files.length; i++) {// 遍历目录下所有的文件
clearDir(files[i]);// 把每个文件用这个方法进行迭代
}
dir.delete();// 删除文件夹
}
}
}
/**
* 获取指定区间的M3U8切片
*
* @param m3u8
* @return
*/
public static List<M3u8Ts> getLimitM3U8Ts(M3u8 m3u8) {
List<M3u8Ts> downList = new ArrayList<>();
if (m3u8.getStartDownloadTime() < m3u8.getStartTime()
|| m3u8.getEndDownloadTime() > m3u8.getEndTime()) {
downList = m3u8.getTsList();
return downList;
}
if ((m3u8.getStartDownloadTime() == -1 && m3u8.getEndDownloadTime() == -1)
|| m3u8.getEndDownloadTime() <= m3u8.getStartDownloadTime()) {
downList = m3u8.getTsList();
} else if (m3u8.getStartDownloadTime() == -1 && m3u8.getEndDownloadTime() > -1) {
for (final M3u8Ts ts : m3u8.getTsList()) {
//从头下到指定时间
if (ts.getLongDate() <= m3u8.getEndDownloadTime()) {
downList.add(ts);
}
}
} else if (m3u8.getStartDownloadTime() > -1 && m3u8.getEndDownloadTime() == -1) {
for (final M3u8Ts ts : m3u8.getTsList()) {
//从指定时间下到尾部
if (ts.getLongDate() >= m3u8.getStartDownloadTime()) {
downList.add(ts);
}
}
} else {
//从指定开始时间下载到指定结束时间
for (final M3u8Ts ts : m3u8.getTsList()) {
if (m3u8.getStartDownloadTime() <= ts.getLongDate() && ts.getLongDate() <= m3u8.getEndDownloadTime()) {
//指定区间的ts
downList.add(ts);
}
}
}
Log.e("hdltag", "getLimitM3U8Ts(MUtils.java:152):" + downList);
return downList;
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoM3u8/src/main/java/com/yc/m3u8/utils/NetSpeedUtils.java | Java | package com.yc.m3u8.utils;
/**
* 网速工具
* Created by HDL on 2017/8/14.
*/
public class NetSpeedUtils {
private static NetSpeedUtils mNetSpeedUtils;
private NetSpeedUtils() {
}
public static NetSpeedUtils getInstance() {
synchronized (NetSpeedUtils.class) {
if (mNetSpeedUtils == null) {
mNetSpeedUtils = new NetSpeedUtils();
}
}
return mNetSpeedUtils;
}
//字节大小，K,M,G
public static final long KB = 1024;
public static final long MB = KB * 1024;
public static final long GB = MB * 1024;
/**
* 文件字节大小显示成M,G和K
*
* @param size
* @return
*/
public String displayFileSize(long size) {
if (size >= GB) {
return String.format("%.1f GB", (float) size / GB);
} else if (size >= MB) {
float value = (float) size / MB;
return String.format(value > 100 ? "%.0f MB" : "%.1f MB", value);
} else if (size >= KB) {
float value = (float) size / KB;
return String.format(value > 100 ? "%.0f KB" : "%.1f KB", value);
} else {
return String.format("%d B", size);
}
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/build.gradle | Gradle | apply plugin: 'com.android.library'
android {
compileSdkVersion 29
buildToolsVersion '29.0.0'
defaultConfig {
minSdkVersion 17
targetSdkVersion 29
versionCode 40
versionName "3.1.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'
implementation 'androidx.annotation:annotation:1.1.0'
implementation 'androidx.cardview:cardview:1.0.0'
implementation project(':VideoKernel')
/*//这两个是必须要加的，其它的可供选择
//ijk播放器
implementation 'tv.danmaku.ijk.media:ijkplayer-java:0.8.8'
implementation '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'
//谷歌播放器
implementation "com.google.android.exoplayer:exoplayer:2.11.3"
implementation "com.google.android.exoplayer:exoplayer-core:2.11.3"
implementation "com.google.android.exoplayer:exoplayer-dash:2.11.3"
implementation "com.google.android.exoplayer:exoplayer-hls:2.11.3"
implementation "com.google.android.exoplayer:exoplayer-smoothstreaming:2.11.3"
implementation "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 = "VideoPlayer"
// 版本号，下次更新是只需要更改版本号即可
version = "3.1.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 videoPlayer 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 videoPlayer' //项目描述
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 |
VideoPlayer/src/main/java/com/yc/video/bridge/ControlWrapper.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.video.bridge;
import android.app.Activity;
import android.content.pm.ActivityInfo;
import android.graphics.Bitmap;
import androidx.annotation.NonNull;
import com.yc.video.controller.InterVideoController;
import com.yc.video.player.InterVideoPlayer;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2018/11/9
* desc : 此类的目的是为了在InterControlView接口实现类中既能调用VideoPlayer的api又能调用BaseVideoController的api，
* 并对部分api做了封装，方便使用
* revise:
* </pre>
*/
public class ControlWrapper implements InterVideoPlayer, InterVideoController {
private InterVideoPlayer mVideoPlayer;
private InterVideoController mController;
public ControlWrapper(@NonNull InterVideoPlayer videoPlayer, @NonNull InterVideoController controller) {
mVideoPlayer = videoPlayer;
mController = controller;
}
@Override
public void setUrl(String url) {
mVideoPlayer.setUrl(url);
}
@Override
public String getUrl() {
return mVideoPlayer.getUrl();
}
@Override
public void start() {
mVideoPlayer.start();
}
@Override
public void pause() {
mVideoPlayer.pause();
}
@Override
public long getDuration() {
return mVideoPlayer.getDuration();
}
@Override
public long getCurrentPosition() {
return mVideoPlayer.getCurrentPosition();
}
@Override
public void seekTo(long pos) {
mVideoPlayer.seekTo(pos);
}
@Override
public boolean isPlaying() {
return mVideoPlayer.isPlaying();
}
@Override
public int getBufferedPercentage() {
return mVideoPlayer.getBufferedPercentage();
}
@Override
public void startFullScreen() {
mVideoPlayer.startFullScreen();
}
@Override
public void stopFullScreen() {
mVideoPlayer.stopFullScreen();
}
@Override
public boolean isFullScreen() {
return mVideoPlayer.isFullScreen();
}
@Override
public void setMute(boolean isMute) {
mVideoPlayer.setMute(isMute);
}
@Override
public boolean isMute() {
return mVideoPlayer.isMute();
}
@Override
public void setScreenScaleType(int screenScaleType) {
mVideoPlayer.setScreenScaleType(screenScaleType);
}
@Override
public void setSpeed(float speed) {
mVideoPlayer.setSpeed(speed);
}
@Override
public float getSpeed() {
return mVideoPlayer.getSpeed();
}
@Override
public long getTcpSpeed() {
return mVideoPlayer.getTcpSpeed();
}
@Override
public void replay(boolean resetPosition) {
mVideoPlayer.replay(resetPosition);
}
@Override
public void setMirrorRotation(boolean enable) {
mVideoPlayer.setMirrorRotation(enable);
}
@Override
public Bitmap doScreenShot() {
return mVideoPlayer.doScreenShot();
}
@Override
public int[] getVideoSize() {
return mVideoPlayer.getVideoSize();
}
@Override
public void setRotation(float rotation) {
mVideoPlayer.setRotation(rotation);
}
@Override
public void startTinyScreen() {
mVideoPlayer.startTinyScreen();
}
@Override
public void stopTinyScreen() {
mVideoPlayer.stopTinyScreen();
}
@Override
public boolean isTinyScreen() {
return mVideoPlayer.isTinyScreen();
}
/**
* 播放和暂停
*/
public void togglePlay() {
if (isPlaying()) {
pause();
} else {
start();
}
}
/**
* 横竖屏切换，会旋转屏幕
*/
public void toggleFullScreen(Activity activity) {
if (activity == null || activity.isFinishing())
return;
if (isFullScreen()) {
activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
stopFullScreen();
} else {
activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
startFullScreen();
}
}
/**
* 横竖屏切换，不会旋转屏幕
*/
public void toggleFullScreen() {
if (isFullScreen()) {
stopFullScreen();
} else {
startFullScreen();
}
}
/**
* 横竖屏切换，根据适配宽高决定是否旋转屏幕
*/
public void toggleFullScreenByVideoSize(Activity activity) {
if (activity == null || activity.isFinishing())
return;
int[] size = getVideoSize();
int width = size[0];
int height = size[1];
if (isFullScreen()) {
stopFullScreen();
if (width > height) {
activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
}
} else {
startFullScreen();
if (width > height) {
activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
}
}
}
@Override
public void startFadeOut() {
mController.startFadeOut();
}
@Override
public void stopFadeOut() {
mController.stopFadeOut();
}
@Override
public boolean isShowing() {
return mController.isShowing();
}
@Override
public void setLocked(boolean locked) {
mController.setLocked(locked);
}
@Override
public boolean isLocked() {
return mController.isLocked();
}
@Override
public void startProgress() {
mController.startProgress();
}
@Override
public void stopProgress() {
mController.stopProgress();
}
@Override
public void hide() {
mController.hide();
}
@Override
public void show() {
mController.show();
}
@Override
public boolean hasCutout() {
return mController.hasCutout();
}
@Override
public int getCutoutHeight() {
return mController.getCutoutHeight();
}
@Override
public void destroy() {
mController.destroy();
}
/**
* 切换锁定状态
*/
public void toggleLockState() {
setLocked(!isLocked());
}
/**
* 切换显示/隐藏状态
*/
public void toggleShowState() {
if (isShowing()) {
hide();
} else {
show();
}
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/config/BuriedPointEvent.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.video.config;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2018/1/29
* desc : 视频全局埋点事件
* revise:
* </pre>
*/
public interface BuriedPointEvent {
/**
* 进入视频播放
* @param url 视频url
*/
void playerIn(String url);
/**
* 退出视频播放
* @param url 视频url
*/
void playerDestroy(String url);
/**
* 视频播放完成
* @param url 视频url
*/
void playerCompletion(String url);
/**
* 视频播放异常
* @param url 视频url
* @param isNetError 是否是网络异常
*/
void onError(String url , boolean isNetError);
/**
* 点击了视频广告
* @param url 视频url
*/
void clickAd(String url);
/**
* 视频试看点击
* @param url 视频url
*/
void playerAndProved(String url);
/**
* 退出视频播放时候的播放进度百度分
* @param url 视频url
* @param progress 视频进度，计算百分比【退出时候进度 / 总进度】
*/
void playerOutProgress(String url , float progress);
/**
* 退出视频播放时候的播放进度
* @param url 视频url
* @param duration 总时长
* @param currentPosition 当前进度时长
*/
void playerOutProgress(String url, long duration , long currentPosition);
/**
* 视频切换音频
* @param url 视频url
*/
void videoToMedia(String url);
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/config/ConstantKeys.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.video.config;
import androidx.annotation.IntDef;
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 ConstantKeys {
/**
* 通过注解限定类型
* TYPE_IJK IjkPlayer，基于IjkPlayer封装播放器
* TYPE_NATIVE MediaPlayer，基于原生自带的播放器控件
* TYPE_EXO 基于谷歌视频播放器
* TYPE_RTC 基于RTC视频播放器
*/
@Retention(RetentionPolicy.SOURCE)
public @interface VideoPlayerType {
int TYPE_IJK = 1;
int TYPE_NATIVE = 2;
int TYPE_EXO = 3;
int TYPE_RTC = 4;
}
@IntDef({VideoPlayerType.TYPE_IJK,VideoPlayerType.TYPE_NATIVE,VideoPlayerType.TYPE_EXO,VideoPlayerType.TYPE_RTC})
@Retention(RetentionPolicy.SOURCE)
public @interface PlayerType{}
/**
* 控制器上的视频顶部View点击事件
* 在竖屏模式下，默认是不显示，需要显示设置controller.setTopVisibility(true);
* 1.DOWNLOAD，下载
* 2.AUDIO，切换音频
* 3.SHARE，分享
* 4.MENU，菜单
*
* 在横屏模式下，默认是不显示，需要显示设置controller.setTvAndAudioVisibility(true,true);
* 5.TV，点击投影到电视上
* 6.HOR_AUDIO，音频
*/
@Retention(RetentionPolicy.SOURCE)
public @interface VideoControl {
int DOWNLOAD = 2005;
int AUDIO = 2006;
int SHARE = 2007;
int MENU = 2008;
int TV = 2009;
int HOR_AUDIO = 2010;
}
@IntDef({VideoControl.DOWNLOAD,VideoControl.AUDIO,
VideoControl.SHARE,VideoControl.MENU,VideoControl.TV,
VideoControl.HOR_AUDIO})
@Retention(RetentionPolicy.SOURCE)
public @interface VideoControlType{}
/**
* 播放状态，主要是指播放器的各种状态
* -4 链接为空
* -3 解析异常
* -2 播放错误，网络异常
* -1 播放错误
* 0 播放未开始，即将进行
* 1 播放准备中
* 2 播放准备就绪
* 3 正在播放
* 4 暂停播放
* 5 正在缓冲(播放器正在播放时，缓冲区数据不足，进行缓冲，缓冲区数据足够后恢复播放)
* 6 暂停缓冲(播放器正在播放时，缓冲区数据不足，进行缓冲，此时暂停播放器，继续缓冲，缓冲区数据足够后恢复暂停
* 7 播放完成
* 8 开始播放中止
* 9 即将开播
*/
@Retention(RetentionPolicy.SOURCE)
public @interface CurrentState{
int STATE_URL_NULL = -4;
int STATE_PARSE_ERROR = -3;
int STATE_NETWORK_ERROR = -2;
int STATE_ERROR = -1;
int STATE_IDLE = 0;
int STATE_PREPARING = 1;
int STATE_PREPARED = 2;
int STATE_PLAYING = 3;
int STATE_PAUSED = 4;
int STATE_BUFFERING_PLAYING = 5;
int STATE_BUFFERING_PAUSED = 6;
int STATE_COMPLETED = 7;
int STATE_START_ABORT = 8;
int STATE_ONCE_LIVE = 9;
}
@IntDef({CurrentState.STATE_ERROR,CurrentState.STATE_IDLE,CurrentState.STATE_PREPARING,
CurrentState.STATE_PREPARED,CurrentState.STATE_PLAYING,CurrentState.STATE_PAUSED,
CurrentState.STATE_BUFFERING_PLAYING,CurrentState.STATE_BUFFERING_PAUSED,
CurrentState.STATE_COMPLETED,CurrentState.STATE_START_ABORT,CurrentState.STATE_NETWORK_ERROR,
CurrentState.STATE_PARSE_ERROR,CurrentState.STATE_URL_NULL,CurrentState.STATE_ONCE_LIVE})
@Retention(RetentionPolicy.SOURCE)
public @interface CurrentStateType{}
/**
* 通过注解限定类型
* 加载loading的类型
* 1，是仿腾讯加载loading，其实是帧动画
* 2，是转圈加载loading，是补间动画
*/
@Retention(RetentionPolicy.SOURCE)
public @interface Loading {
int LOADING_RING = 1;
int LOADING_QQ = 2;
}
@IntDef({Loading.LOADING_RING,Loading.LOADING_QQ})
@Retention(RetentionPolicy.SOURCE)
public @interface LoadingType{}
/**
* 电量状态
*/
@Retention(RetentionPolicy.SOURCE)
public @interface BatterMode {
int BATTERY_CHARGING = 80;
int BATTERY_FULL = 81;
int BATTERY_10 = 82;
int BATTERY_20 = 83;
int BATTERY_50 = 84;
int BATTERY_80 = 85;
int BATTERY_100 = 86;
}
/**
* 播放状态
*/
@Retention(RetentionPolicy.SOURCE)
public @interface PlayerStatesType {
//播放完成
int COMPLETED = 101;
//正在播放
int PLAYING = 102;
//暂停状态
int PAUSE = 103;
//用户点击back。当视频退出全屏或者退出小窗口后，再次点击返回键，让用户自己处理返回键事件的逻辑
int BACK_CLICK = 104;
}
/**
* 播放模式
* 普通模式，小窗口模式，正常模式三种其中一种
* MODE_NORMAL 普通模式
* MODE_FULL_SCREEN 全屏模式
* MODE_TINY_WINDOW 小屏模式
*/
@Retention(RetentionPolicy.SOURCE)
public @interface PlayMode {
//普通模式
int MODE_NORMAL = 1001;
//全屏模式
int MODE_FULL_SCREEN = 1002;
//小屏模式
int MODE_TINY_WINDOW = 1003;
}
@IntDef({PlayMode.MODE_NORMAL,PlayMode.MODE_FULL_SCREEN,PlayMode.MODE_TINY_WINDOW})
@Retention(RetentionPolicy.SOURCE)
public @interface PlayModeType{}
/**
* 播放视频缩放类型
*/
@Retention(RetentionPolicy.SOURCE)
public @interface PlayerScreenScaleType {
//默认类型
int SCREEN_SCALE_DEFAULT = 0;
//16：9比例类型，最为常见
int SCREEN_SCALE_16_9 = 1;
//4：3比例类型，也比较常见
int SCREEN_SCALE_4_3 = 2;
//充满整个控件视图
int SCREEN_SCALE_MATCH_PARENT = 3;
//原始类型，指视频的原始类型
int SCREEN_SCALE_ORIGINAL = 4;
//剧中裁剪类型
int SCREEN_SCALE_CENTER_CROP = 5;
}
@IntDef({PlayerScreenScaleType.SCREEN_SCALE_DEFAULT,PlayerScreenScaleType.SCREEN_SCALE_16_9,
PlayerScreenScaleType.SCREEN_SCALE_4_3,PlayerScreenScaleType.SCREEN_SCALE_MATCH_PARENT,
PlayerScreenScaleType.SCREEN_SCALE_ORIGINAL,PlayerScreenScaleType.SCREEN_SCALE_CENTER_CROP})
@Retention(RetentionPolicy.SOURCE)
public @interface ScreenScaleType{}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/config/VideoInfoBean.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.video.config;
import java.io.Serializable;
import java.util.Map;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2018/1/29
* desc : 视频信息实体类
* revise:
* </pre>
*/
public class VideoInfoBean implements Serializable {
/**
* 视频的标题
*/
private String title;
/**
* 播放的视频地址
*/
private String videoUrl;
/**
* 请求header
*/
private Map<String, String> headers;
/**
* 视频封面
*/
private String cover;
/**
* 视频时长
*/
private long length;
/**
* 清晰度等级
*/
private String grade;
/**
* 270P、480P、720P、1080P、4K ...
*/
private String p;
public VideoInfoBean(String title, String cover, String url) {
this.title = title;
this.videoUrl = url;
this.cover = cover;
}
public VideoInfoBean(String title ,String grade, String p, String videoUrl) {
this.title = title;
this.grade = grade;
this.p = p;
this.videoUrl = videoUrl;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getVideoUrl() {
return videoUrl;
}
public void setVideoUrl(String videoUrl) {
this.videoUrl = videoUrl;
}
public Map<String, String> getHeaders() {
return headers;
}
public void setHeaders(Map<String, String> headers) {
this.headers = headers;
}
public String getCover() {
return cover;
}
public void setCover(String cover) {
this.cover = cover;
}
public long getLength() {
return length;
}
public void setLength(long length) {
this.length = length;
}
public String getGrade() {
return grade;
}
public void setGrade(String grade) {
this.grade = grade;
}
public String getP() {
return p;
}
public void setP(String p) {
this.p = p;
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/config/VideoPlayerConfig.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.video.config;
import android.content.Context;
import androidx.annotation.Nullable;
import com.yc.kernel.factory.PlayerFactory;
import com.yc.kernel.impl.media.MediaPlayerFactory;
import com.yc.video.tool.BaseToast;
import com.yc.video.player.ProgressManager;
import com.yc.video.surface.SurfaceFactory;
import com.yc.video.surface.TextureViewFactory;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2018/11/9
* desc : 播放器全局配置
* revise:
* </pre>
*/
public class VideoPlayerConfig {
public static Builder newBuilder() {
return new Builder();
}
public final static class Builder {
private Context mContext;
/**
* 默认是关闭日志的
*/
private boolean mIsEnableLog = false;
/**
* 在移动环境下调用start()后是否继续播放，默认不继续播放
*/
private boolean mPlayOnMobileNetwork;
/**
* 是否监听设备方向来切换全屏/半屏， 默认不开启
*/
private boolean mEnableOrientation;
/**
* 是否开启AudioFocus监听， 默认开启
*/
private boolean mEnableAudioFocus = true;
/**
* 设置进度管理器，用于保存播放进度
*/
private ProgressManager mProgressManager;
/**
* 自定义播放核心
*/
private PlayerFactory mPlayerFactory;
/**
* 自定义视频全局埋点事件
*/
private BuriedPointEvent mBuriedPointEvent;
/**
* 设置视频比例
*/
private int mScreenScaleType;
/**
* 自定义RenderView
*/
private SurfaceFactory mRenderViewFactory;
/**
* 是否适配刘海屏，默认适配
*/
private boolean mAdaptCutout = true;
/**
* 是否设置倒计时n秒吐司
*/
private boolean mIsShowToast = false;
/**
* 倒计时n秒时间
*/
private long mShowToastTime = 5;
/**
* 是否监听设备方向来切换全屏/半屏， 默认不开启
*/
public Builder setContext(Context context) {
mContext = context;
return this;
}
/**
* 是否监听设备方向来切换全屏/半屏， 默认不开启
*/
public Builder setEnableOrientation(boolean enableOrientation) {
mEnableOrientation = enableOrientation;
return this;
}
/**
* 在移动环境下调用start()后是否继续播放，默认不继续播放
*/
public Builder setPlayOnMobileNetwork(boolean playOnMobileNetwork) {
mPlayOnMobileNetwork = playOnMobileNetwork;
return this;
}
/**
* 是否开启AudioFocus监听， 默认开启
*/
public Builder setEnableAudioFocus(boolean enableAudioFocus) {
mEnableAudioFocus = enableAudioFocus;
return this;
}
/**
* 设置进度管理器，用于保存播放进度
*/
public Builder setProgressManager(@Nullable ProgressManager progressManager) {
mProgressManager = progressManager;
return this;
}
/**
* 是否打印日志
*/
public Builder setLogEnabled(boolean enableLog) {
mIsEnableLog = enableLog;
return this;
}
/**
* 自定义播放核心
*/
public Builder setPlayerFactory(PlayerFactory playerFactory) {
mPlayerFactory = playerFactory;
return this;
}
/**
* 自定义视频全局埋点事件
*/
public Builder setBuriedPointEvent(BuriedPointEvent buriedPointEvent) {
mBuriedPointEvent = buriedPointEvent;
return this;
}
/**
* 设置视频比例
*/
public Builder setScreenScaleType(int screenScaleType) {
mScreenScaleType = screenScaleType;
return this;
}
/**
* 自定义RenderView
*/
public Builder setRenderViewFactory(SurfaceFactory renderViewFactory) {
mRenderViewFactory = renderViewFactory;
return this;
}
/**
* 是否适配刘海屏，默认适配
*/
public Builder setAdaptCutout(boolean adaptCutout) {
mAdaptCutout = adaptCutout;
return this;
}
/**
* 是否设置倒计时n秒吐司
*/
public Builder setIsShowToast(boolean isShowToast) {
mIsShowToast = isShowToast;
return this;
}
/**
* 倒计时n秒时间
*/
public Builder setShowToastTime(long showToastTime) {
mShowToastTime = showToastTime;
return this;
}
public VideoPlayerConfig build() {
//创建builder对象
return new VideoPlayerConfig(this);
}
}
public final Context mContext;
public final boolean mPlayOnMobileNetwork;
public final boolean mEnableOrientation;
public final boolean mEnableAudioFocus;
public final boolean mIsEnableLog;
public final ProgressManager mProgressManager;
public final PlayerFactory mPlayerFactory;
public final BuriedPointEvent mBuriedPointEvent;
public final int mScreenScaleType;
public final SurfaceFactory mRenderViewFactory;
public final boolean mAdaptCutout;
public final boolean mIsShowToast ;
public final long mShowToastTime;
private VideoPlayerConfig(Builder builder) {
mIsEnableLog = builder.mIsEnableLog;
mEnableOrientation = builder.mEnableOrientation;
mPlayOnMobileNetwork = builder.mPlayOnMobileNetwork;
mEnableAudioFocus = builder.mEnableAudioFocus;
mProgressManager = builder.mProgressManager;
mScreenScaleType = builder.mScreenScaleType;
if (builder.mPlayerFactory == null) {
//默认为AndroidMediaPlayer
mPlayerFactory = MediaPlayerFactory.create();
} else {
mPlayerFactory = builder.mPlayerFactory;
}
mBuriedPointEvent = builder.mBuriedPointEvent;
if (builder.mRenderViewFactory == null) {
//默认使用TextureView渲染视频
mRenderViewFactory = TextureViewFactory.create();
} else {
mRenderViewFactory = builder.mRenderViewFactory;
}
mAdaptCutout = builder.mAdaptCutout;
mContext = builder.mContext;
if (mContext!=null){
BaseToast.init(mContext);
}
mIsShowToast = builder.mIsShowToast;
mShowToastTime = builder.mShowToastTime;
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/controller/BaseVideoController.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.video.controller;
import android.app.Activity;
import android.content.Context;
import android.content.pm.ActivityInfo;
import android.util.AttributeSet;
import android.view.LayoutInflater;
import android.view.OrientationEventListener;
import android.view.View;
import android.view.animation.AlphaAnimation;
import android.view.animation.Animation;
import android.widget.FrameLayout;
import androidx.annotation.AttrRes;
import androidx.annotation.CallSuper;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import com.yc.video.bridge.ControlWrapper;
import com.yc.video.config.ConstantKeys;
import com.yc.video.player.InterVideoPlayer;
import com.yc.video.player.VideoViewManager;
import com.yc.video.player.VideoPlayer;
import com.yc.video.tool.StatesCutoutUtils;
import com.yc.video.tool.NetworkUtils;
import com.yc.video.tool.PlayerUtils;
import com.yc.video.ui.view.InterControlView;
import com.yc.kernel.utils.VideoLogUtils;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2018/11/9
* desc : 控制器基类
* revise: 此类集成各种事件的处理逻辑，包括
* 1.播放器状态改变: {@link #handlePlayerStateChanged(int)}
* 2.播放状态改变: {@link #handlePlayStateChanged(int)}
* 3.控制视图的显示和隐藏: {@link #handleVisibilityChanged(boolean, Animation)}
* 4.播放进度改变: {@link #handleSetProgress(int, int)}
* 5.锁定状态改变: {@link #handleLockStateChanged(boolean)}
* 6.设备方向监听: {@link #onOrientationChanged(int)}
*
* </pre>
*/
public abstract class BaseVideoController extends FrameLayout implements InterVideoController,
InterViewController,OrientationHelper.OnOrientationChangeListener {
//播放器包装类，集合了MediaPlayerControl的api和IVideoController的api
protected ControlWrapper mControlWrapper;
@Nullable
protected Activity mActivity;
//控制器是否处于显示状态
protected boolean mShowing;
//是否处于锁定状态
protected boolean mIsLocked;
//播放视图隐藏超时
protected int mDefaultTimeout = 5000;
//是否开启根据屏幕方向进入/退出全屏
private boolean mEnableOrientation;
//屏幕方向监听辅助类
protected OrientationHelper mOrientationHelper;
//用户设置是否适配刘海屏
private boolean mAdaptCutout;
//是否有刘海
private Boolean mHasCutout;
//刘海的高度
private int mCutoutHeight;
//是否开始刷新进度
private boolean mIsStartProgress;
//保存了所有的控制组件
//使用LinkedHashMap有序
protected LinkedHashMap<InterControlView, Boolean> mControlComponents = new LinkedHashMap<>();
private Animation mShowAnim;
private Animation mHideAnim;
public BaseVideoController(@NonNull Context context) {
//创建
this(context, null);
}
public BaseVideoController(@NonNull Context context, @Nullable AttributeSet attrs) {
//创建
this(context, attrs, 0);
}
public BaseVideoController(@NonNull Context context, @Nullable AttributeSet attrs, @AttrRes int defStyleAttr) {
super(context, attrs, defStyleAttr);
initView(context);
}
@Override
protected void onDetachedFromWindow() {
super.onDetachedFromWindow();
if (mShowAnim != null){
mShowAnim.cancel();
mShowAnim = null;
}
if (mHideAnim != null){
mHideAnim.cancel();
mHideAnim = null;
}
}
@Override
public void onWindowFocusChanged(boolean hasWindowFocus) {
super.onWindowFocusChanged(hasWindowFocus);
if (mControlWrapper.isPlaying() && (mEnableOrientation || mControlWrapper.isFullScreen())) {
if (hasWindowFocus) {
postDelayed(new Runnable() {
@Override
public void run() {
//检查系统是否开启自动旋转
mOrientationHelper.enable();
}
}, 800);
} else {
//取消监听
mOrientationHelper.disable();
}
}
}
protected void initView(Context context) {
if (getLayoutId() != 0) {
LayoutInflater.from(getContext()).inflate(getLayoutId(), this, true);
}
mOrientationHelper = new OrientationHelper(context.getApplicationContext());
mEnableOrientation = VideoViewManager.getConfig().mEnableOrientation;
mAdaptCutout = VideoViewManager.getConfig().mAdaptCutout;
mShowAnim = new AlphaAnimation(0f, 1f);
mShowAnim.setDuration(300);
mHideAnim = new AlphaAnimation(1f, 0f);
mHideAnim.setDuration(300);
mActivity = PlayerUtils.scanForActivity(context);
}
/**
* 设置控制器布局文件，子类必须实现
*/
protected abstract int getLayoutId();
/**
* 重要：此方法用于将{@link VideoPlayer} 和控制器绑定
*/
@CallSuper
public void setMediaPlayer(InterVideoPlayer mediaPlayer) {
mControlWrapper = new ControlWrapper(mediaPlayer, this);
//绑定ControlComponent和Controller
for (Map.Entry<InterControlView, Boolean> next : mControlComponents.entrySet()) {
InterControlView component = next.getKey();
component.attach(mControlWrapper);
}
//开始监听设备方向
mOrientationHelper.setOnOrientationChangeListener(this);
}
/**
* 添加控制组件，最后面添加的在最下面，合理组织添加顺序，可让ControlComponent位于不同的层级
* @param controlViews view
*/
@Override
public void addControlComponent(InterControlView... controlViews) {
for (InterControlView item : controlViews) {
addControlComponent(item, false);
}
}
/**
* 添加控制组件，最后面添加的在最下面，合理组织添加顺序，可让InterControlView位于不同的层级
* @param controlView view
* @param isPrivate 是否为独有的组件，如果是就不添加到控制器中
*/
@Override
public void addControlComponent(InterControlView controlView, boolean isPrivate) {
mControlComponents.put(controlView, isPrivate);
if (mControlWrapper != null) {
controlView.attach(mControlWrapper);
}
View view = controlView.getView();
if (view != null && !isPrivate) {
addView(view, 0);
}
}
/**
* 移除控制组件
* @param controlView view
*/
@Override
public void removeControlComponent(InterControlView controlView) {
removeView(controlView.getView());
mControlComponents.remove(controlView);
}
/**
* 移除所有的组件
*/
@Override
public void removeAllControlComponent() {
for (Map.Entry<InterControlView, Boolean> next : mControlComponents.entrySet()) {
removeView(next.getKey().getView());
}
mControlComponents.clear();
}
/**
* 移除所有独有的组件
*/
@Override
public void removeAllPrivateComponents() {
Iterator<Map.Entry<InterControlView, Boolean>> it = mControlComponents.entrySet().iterator();
while (it.hasNext()) {
Map.Entry<InterControlView, Boolean> next = it.next();
if (next.getValue()) {
it.remove();
}
}
}
/**
* {@link VideoPlayer}调用此方法向控制器设置播放状态。
* 这里使用注解限定符，不要使用1，2这种直观数字，不方便知道意思
* 播放状态，主要是指播放器的各种状态
* -1 播放错误
* 0 播放未开始
* 1 播放准备中
* 2 播放准备就绪
* 3 正在播放
* 4 暂停播放
* 5 正在缓冲(播放器正在播放时，缓冲区数据不足，进行缓冲，缓冲区数据足够后恢复播放)
* 6 暂停缓冲(播放器正在播放时，缓冲区数据不足，进行缓冲，此时暂停播放器，继续缓冲，缓冲区数据足够后恢复暂停
* 7 播放完成
* 8 开始播放中止
*/
@CallSuper
public void setPlayState(@ConstantKeys.CurrentStateType int playState) {
//设置播放器的状态
handlePlayStateChanged(playState);
}
/**
* {@link VideoPlayer}调用此方法向控制器设置播放器模式
* 播放模式
* 普通模式，小窗口模式，正常模式三种其中一种
* MODE_NORMAL 普通模式
* MODE_FULL_SCREEN 全屏模式
* MODE_TINY_WINDOW 小屏模式
*/
@CallSuper
public void setPlayerState(@ConstantKeys.PlayModeType final int playerState) {
//调用此方法向控制器设置播放器状态
handlePlayerStateChanged(playerState);
}
/**
* 设置播放视图自动隐藏超时
*/
public void setDismissTimeout(int timeout) {
if (timeout > 0) {
mDefaultTimeout = timeout;
} else {
mDefaultTimeout = 5000;
}
}
/**
* 隐藏播放视图
*/
@Override
public void hide() {
if (mShowing) {
stopFadeOut();
handleVisibilityChanged(false, mHideAnim);
mShowing = false;
}
}
/**
* 显示播放视图
*/
@Override
public void show() {
if (!mShowing) {
handleVisibilityChanged(true, mShowAnim);
startFadeOut();
mShowing = true;
}
}
@Override
public boolean isShowing() {
return mShowing;
}
/**
* 开始计时
*/
@Override
public void startFadeOut() {
//重新开始计时
stopFadeOut();
postDelayed(mFadeOut, mDefaultTimeout);
}
/**
* 取消计时
*/
@Override
public void stopFadeOut() {
if (mFadeOut!=null){
removeCallbacks(mFadeOut);
}
}
/**
* 隐藏播放视图Runnable
*/
protected final Runnable mFadeOut = new Runnable() {
@Override
public void run() {
hide();
}
};
/**
* 设置是否锁屏
* @param locked 是否锁定
*/
@Override
public void setLocked(boolean locked) {
mIsLocked = locked;
handleLockStateChanged(locked);
}
/**
* 判断是否锁屏
* @return 返回是否锁屏
*/
@Override
public boolean isLocked() {
return mIsLocked;
}
/**
* 开始刷新进度，注意：需在STATE_PLAYING时调用才会开始刷新进度
*/
@Override
public void startProgress() {
if (mIsStartProgress) {
return;
}
post(mShowProgress);
mIsStartProgress = true;
}
/**
* 停止刷新进度
*/
@Override
public void stopProgress() {
if (!mIsStartProgress) {
return;
}
removeCallbacks(mShowProgress);
mIsStartProgress = false;
}
/**
* 刷新进度Runnable
*/
protected Runnable mShowProgress = new Runnable() {
@Override
public void run() {
int pos = setProgress();
if (mControlWrapper.isPlaying()) {
float speed = mControlWrapper.getSpeed();
//postDelayed(this, 1000);
postDelayed(this, (long) ((1000 - pos % 1000) / speed));
} else {
mIsStartProgress = false;
}
}
};
private int setProgress() {
int position = (int) mControlWrapper.getCurrentPosition();
int duration = (int) mControlWrapper.getDuration();
handleSetProgress(duration, position);
return position;
}
/**
* 设置是否适配刘海屏
*/
public void setAdaptCutout(boolean adaptCutout) {
mAdaptCutout = adaptCutout;
}
@Override
protected void onAttachedToWindow() {
super.onAttachedToWindow();
checkCutout();
}
/**
* 检查是否需要适配刘海
*/
private void checkCutout() {
if (!mAdaptCutout) return;
if (mActivity != null && mHasCutout == null) {
mHasCutout = StatesCutoutUtils.allowDisplayToCutout(mActivity);
if (mHasCutout) {
//竖屏下的状态栏高度可认为是刘海的高度
mCutoutHeight = (int) PlayerUtils.getStatusBarHeightPortrait(mActivity);
}
}
VideoLogUtils.d("hasCutout: " + mHasCutout + " cutout height: " + mCutoutHeight);
}
/**
* 是否有刘海屏
*/
@Override
public boolean hasCutout() {
return mHasCutout != null && mHasCutout;
}
/**
* 刘海的高度
*/
@Override
public int getCutoutHeight() {
return mCutoutHeight;
}
/**
* 显示移动网络播放提示
*
* @return 返回显示移动网络播放提示的条件，false:不显示, true显示
* 此处默认根据手机网络类型来决定是否显示，开发者可以重写相关逻辑
*/
public boolean showNetWarning() {
return NetworkUtils.getNetworkType(getContext()) == NetworkUtils.NETWORK_MOBILE
&& !VideoViewManager.instance().playOnMobileNetwork();
}
/**
* 播放和暂停
*/
protected void togglePlay() {
mControlWrapper.togglePlay();
}
/**
* 横竖屏切换
*/
protected void toggleFullScreen() {
if (PlayerUtils.isActivityLiving(mActivity)){
mControlWrapper.toggleFullScreen(mActivity);
}
}
/**
* 子类中请使用此方法来进入全屏
*
* @return 是否成功进入全屏
*/
protected boolean startFullScreen() {
if (!PlayerUtils.isActivityLiving(mActivity)) {
return false;
}
mActivity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
mControlWrapper.startFullScreen();
return true;
}
/**
* 子类中请使用此方法来退出全屏
*
* @return 是否成功退出全屏
*/
protected boolean stopFullScreen() {
if (!PlayerUtils.isActivityLiving(mActivity)) {
return false;
}
mActivity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
mControlWrapper.stopFullScreen();
return true;
}
/**
* 改变返回键逻辑，用于activity
*/
public boolean onBackPressed() {
return false;
}
/**
* 是否自动旋转， 默认不自动旋转
*/
public void setEnableOrientation(boolean enableOrientation) {
mEnableOrientation = enableOrientation;
}
private int mOrientation = 0;
@CallSuper
@Override
public void onOrientationChanged(int orientation) {
if (mActivity == null || mActivity.isFinishing()) return;
//记录用户手机上一次放置的位置
int lastOrientation = mOrientation;
if (orientation == OrientationEventListener.ORIENTATION_UNKNOWN) {
//手机平放时，检测不到有效的角度
//重置为原始位置 -1
mOrientation = -1;
return;
}
if (orientation > 350 || orientation < 10) {
int o = mActivity.getRequestedOrientation();
//手动切换横竖屏
if (o == ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE && lastOrientation == 0) return;
if (mOrientation == 0) return;
//0度，用户竖直拿着手机
mOrientation = 0;
onOrientationPortrait(mActivity);
} else if (orientation > 80 && orientation < 100) {
int o = mActivity.getRequestedOrientation();
//手动切换横竖屏
if (o == ActivityInfo.SCREEN_ORIENTATION_PORTRAIT && lastOrientation == 90) return;
if (mOrientation == 90) return;
//90度，用户右侧横屏拿着手机
mOrientation = 90;
onOrientationReverseLandscape(mActivity);
} else if (orientation > 260 && orientation < 280) {
int o = mActivity.getRequestedOrientation();
//手动切换横竖屏
if (o == ActivityInfo.SCREEN_ORIENTATION_PORTRAIT && lastOrientation == 270) return;
if (mOrientation == 270) return;
//270度，用户左侧横屏拿着手机
mOrientation = 270;
onOrientationLandscape(mActivity);
}
}
/**
* 竖屏
*/
protected void onOrientationPortrait(Activity activity) {
//屏幕锁定的情况
if (mIsLocked) return;
//没有开启设备方向监听的情况
if (!mEnableOrientation) return;
activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
mControlWrapper.stopFullScreen();
}
/**
* 横屏
*/
protected void onOrientationLandscape(Activity activity) {
activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
if (mControlWrapper.isFullScreen()) {
handlePlayerStateChanged(ConstantKeys.PlayMode.MODE_FULL_SCREEN);
} else {
mControlWrapper.startFullScreen();
}
}
/**
* 反向横屏
*/
protected void onOrientationReverseLandscape(Activity activity) {
activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE);
if (mControlWrapper.isFullScreen()) {
handlePlayerStateChanged(ConstantKeys.PlayMode.MODE_FULL_SCREEN);
} else {
mControlWrapper.startFullScreen();
}
}
//------------------------ start handle event change ------------------------//
private void handleVisibilityChanged(boolean isVisible, Animation anim) {
if (!mIsLocked) {
//没锁住时才向ControlComponent下发此事件
for (Map.Entry<InterControlView, Boolean> next : mControlComponents.entrySet()) {
InterControlView component = next.getKey();
component.onVisibilityChanged(isVisible, anim);
}
}
onVisibilityChanged(isVisible, anim);
}
/**
* 子类重写此方法监听控制的显示和隐藏
*
* @param isVisible 是否可见
* @param anim 显示/隐藏动画
*/
protected void onVisibilityChanged(boolean isVisible, Animation anim) {
}
private void handlePlayStateChanged(int playState) {
for (Map.Entry<InterControlView, Boolean> next : mControlComponents.entrySet()) {
InterControlView component = next.getKey();
component.onPlayStateChanged(playState);
}
onPlayStateChanged(playState);
}
/**
* 子类重写此方法并在其中更新控制器在不同播放状态下的ui
*/
@CallSuper
protected void onPlayStateChanged(int playState) {
switch (playState) {
case ConstantKeys.CurrentState.STATE_IDLE:
mOrientationHelper.disable();
mOrientation = 0;
mIsLocked = false;
mShowing = false;
removeAllPrivateComponents();
break;
case ConstantKeys.CurrentState.STATE_BUFFERING_PLAYING:
mIsLocked = false;
mShowing = false;
break;
case ConstantKeys.CurrentState.STATE_ERROR:
mShowing = false;
break;
}
}
/**
* 播放器状态改变
* @param playerState 播放器状态
*/
private void handlePlayerStateChanged(int playerState) {
for (Map.Entry<InterControlView, Boolean> next : mControlComponents.entrySet()) {
InterControlView component = next.getKey();
component.onPlayerStateChanged(playerState);
}
onPlayerStateChanged(playerState);
}
/**
* 子类重写此方法并在其中更新控制器在不同播放器状态下的ui
* 普通模式，小窗口模式，正常模式三种其中一种
* MODE_NORMAL 普通模式
* MODE_FULL_SCREEN 全屏模式
* MODE_TINY_WINDOW 小屏模式
*/
@CallSuper
protected void onPlayerStateChanged(@ConstantKeys.PlayMode int playerState) {
switch (playerState) {
case ConstantKeys.PlayMode.MODE_NORMAL:
//视频正常播放是设置监听
if (mEnableOrientation) {
//检查系统是否开启自动旋转
mOrientationHelper.enable();
} else {
//取消监听
mOrientationHelper.disable();
}
if (hasCutout()) {
StatesCutoutUtils.adaptCutoutAboveAndroidP(getContext(), false);
}
break;
case ConstantKeys.PlayMode.MODE_FULL_SCREEN:
//在全屏时强制监听设备方向
mOrientationHelper.enable();
if (hasCutout()) {
StatesCutoutUtils.adaptCutoutAboveAndroidP(getContext(), true);
}
break;
case ConstantKeys.PlayMode.MODE_TINY_WINDOW:
//小窗口取消重力感应监听
mOrientationHelper.disable();
break;
}
}
private void handleSetProgress(int duration, int position) {
for (Map.Entry<InterControlView, Boolean> next : mControlComponents.entrySet()) {
InterControlView component = next.getKey();
component.setProgress(duration, position);
}
setProgress(duration, position);
}
/**
* 刷新进度回调，子类可在此方法监听进度刷新，然后更新ui
*
* @param duration 视频总时长
* @param position 视频当前时长
*/
protected void setProgress(int duration, int position) {
}
private void handleLockStateChanged(boolean isLocked) {
for (Map.Entry<InterControlView, Boolean> next : mControlComponents.entrySet()) {
InterControlView component = next.getKey();
component.onLockStateChanged(isLocked);
}
onLockStateChanged(isLocked);
}
/**
* 子类可重写此方法监听锁定状态发生改变，然后更新ui
*/
protected void onLockStateChanged(boolean isLocked) {
}
//------------------------ end handle event change ------------------------//
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/controller/GestureVideoController.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.video.controller;
import android.app.Activity;
import android.content.Context;
import android.media.AudioManager;
import android.util.AttributeSet;
import android.view.GestureDetector;
import android.view.MotionEvent;
import android.view.View;
import android.view.Window;
import android.view.WindowManager;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import com.yc.kernel.utils.VideoLogUtils;
import com.yc.video.config.ConstantKeys;
import com.yc.video.tool.PlayerUtils;
import com.yc.video.ui.view.InterControlView;
import java.util.Map;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2018/11/9
* desc : 包含手势操作的VideoController
* revise:
* </pre>
*/
public abstract class GestureVideoController extends BaseVideoController implements
GestureDetector.OnGestureListener, GestureDetector.OnDoubleTapListener, View.OnTouchListener {
private GestureDetector mGestureDetector;
private AudioManager mAudioManager;
private boolean mIsGestureEnabled = true;
private int mStreamVolume;
private float mBrightness;
private int mSeekPosition;
/**
* 是否是第一次触摸
*/
private boolean mFirstTouch;
/**
* 是否改变位置
*/
private boolean mChangePosition;
/**
* 是否改变亮度
*/
private boolean mChangeBrightness;
/**
* 是否改变音量
*/
private boolean mChangeVolume;
/**
* 是否可以改变位置
*/
private boolean mCanChangePosition = true;
/**
* 是否在竖屏模式下开始手势控制
*/
private boolean mEnableInNormal;
/**
* 是否关闭了滑动手势
*/
private boolean mCanSlide;
/**
* 播放状态
*/
private int mCurPlayState;
/**
* 屏幕一半的距离
*/
private int mHalfScreen;
public GestureVideoController(@NonNull Context context) {
super(context);
}
public GestureVideoController(@NonNull Context context, @Nullable AttributeSet attrs) {
super(context, attrs);
}
public GestureVideoController(@NonNull Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
}
@Override
protected void initView(Context context) {
super.initView(context);
mHalfScreen = PlayerUtils.getScreenWidth(getContext(), true) / 2;
mAudioManager = (AudioManager) getContext().getSystemService(Context.AUDIO_SERVICE);
mGestureDetector = new GestureDetector(getContext(), this);
setOnTouchListener(this);
}
/**
* 设置是否可以滑动调节进度，默认可以
*/
public void setCanChangePosition(boolean canChangePosition) {
mCanChangePosition = canChangePosition;
}
/**
* 是否在竖屏模式下开始手势控制，默认关闭
*/
public void setEnableInNormal(boolean enableInNormal) {
mEnableInNormal = enableInNormal;
}
/**
* 是否开启手势空控制，默认开启，关闭之后，双击播放暂停以及手势调节进度，音量，亮度功能将关闭
*/
public void setGestureEnabled(boolean gestureEnabled) {
mIsGestureEnabled = gestureEnabled;
}
/**
* 调用此方法向控制器设置播放器模式
* @param playerState 播放模式
*/
@Override
public void setPlayerState(int playerState) {
super.setPlayerState(playerState);
if (playerState == ConstantKeys.PlayMode.MODE_NORMAL) {
mCanSlide = mEnableInNormal;
} else if (playerState == ConstantKeys.PlayMode.MODE_FULL_SCREEN) {
mCanSlide = true;
}
}
/**
* 调用此方法向控制器设置播放状态
* @param playState 播放状态
*/
@Override
public void setPlayState(int playState) {
super.setPlayState(playState);
mCurPlayState = playState;
}
private boolean isInPlaybackState() {
return mControlWrapper != null
&& mCurPlayState != ConstantKeys.CurrentState.STATE_ERROR
&& mCurPlayState != ConstantKeys.CurrentState.STATE_IDLE
&& mCurPlayState != ConstantKeys.CurrentState.STATE_PREPARING
&& mCurPlayState != ConstantKeys.CurrentState.STATE_PREPARED
&& mCurPlayState != ConstantKeys.CurrentState.STATE_START_ABORT
&& mCurPlayState != ConstantKeys.CurrentState.STATE_BUFFERING_PLAYING;
}
@Override
public boolean onTouch(View v, MotionEvent event) {
return mGestureDetector.onTouchEvent(event);
}
/**
* 手指按下的瞬间
*/
@Override
public boolean onDown(MotionEvent e) {
if (!isInPlaybackState() //不处于播放状态
|| !mIsGestureEnabled //关闭了手势
|| PlayerUtils.isEdge(getContext(), e)) {
//处于屏幕边沿
return true;
}
mStreamVolume = mAudioManager.getStreamVolume(AudioManager.STREAM_MUSIC);
Activity activity = PlayerUtils.scanForActivity(getContext());
if (activity == null) {
mBrightness = 0;
} else {
mBrightness = activity.getWindow().getAttributes().screenBrightness;
}
mFirstTouch = true;
mChangePosition = false;
mChangeBrightness = false;
mChangeVolume = false;
return true;
}
/**
* 单击
*/
@Override
public boolean onSingleTapConfirmed(MotionEvent e) {
if (isInPlaybackState()) {
//切换显示/隐藏状态
mControlWrapper.toggleShowState();
}
return true;
}
/**
* 双击
*/
@Override
public boolean onDoubleTap(MotionEvent e) {
//如果没有锁屏，
if (!isLocked() && isInPlaybackState()){
//播放和暂停
togglePlay();
}
return true;
}
/**
* 在屏幕上滑动
* 左右滑动，则是改变播放进度
* 上下滑动，滑动左边改变音量；滑动右边改变亮度
*/
@Override
public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) {
if (!isInPlaybackState() //不处于播放状态
|| !mIsGestureEnabled //关闭了手势
|| !mCanSlide //关闭了滑动手势
|| isLocked() //锁住了屏幕
//处于屏幕边沿
|| PlayerUtils.isEdge(getContext(), e1)){
return true;
}
float deltaX = e1.getX() - e2.getX();
float deltaY = e1.getY() - e2.getY();
//如果是第一次触摸
if (mFirstTouch) {
//判断是左右滑动，还是上下滑动
mChangePosition = Math.abs(distanceX) >= Math.abs(distanceY);
if (!mChangePosition) {
//上下滑动，滑动左边改变音量；滑动右边改变亮度
//半屏宽度
if (mHalfScreen==0){
mHalfScreen = PlayerUtils.getScreenWidth(getContext(), true) / 2;
}
if (e2.getX() > mHalfScreen) {
mChangeVolume = true;
} else {
mChangeBrightness = true;
}
}
//左右滑动，则是改变播放进度
if (mChangePosition) {
//根据用户设置是否可以滑动调节进度来决定最终是否可以滑动调节进度
mChangePosition = mCanChangePosition;
}
if (mChangePosition || mChangeBrightness || mChangeVolume) {
for (Map.Entry<InterControlView, Boolean> next : mControlComponents.entrySet()) {
InterControlView component = next.getKey();
if (component instanceof IGestureComponent) {
((IGestureComponent) component).onStartSlide();
}
}
}
mFirstTouch = false;
}
if (mChangePosition) {
slideToChangePosition(deltaX);
} else if (mChangeBrightness) {
slideToChangeBrightness(deltaY);
} else if (mChangeVolume) {
slideToChangeVolume(deltaY);
}
return true;
}
protected void slideToChangePosition(float deltaX) {
deltaX = -deltaX;
int width = getMeasuredWidth();
int duration = (int) mControlWrapper.getDuration();
int currentPosition = (int) mControlWrapper.getCurrentPosition();
int position = (int) (deltaX / width * 120000 + currentPosition);
if (position > duration) position = duration;
if (position < 0) position = 0;
for (Map.Entry<InterControlView, Boolean> next : mControlComponents.entrySet()) {
InterControlView component = next.getKey();
if (component instanceof IGestureComponent) {
((IGestureComponent) component).onPositionChange(position, currentPosition, duration);
}
}
mSeekPosition = position;
}
protected void slideToChangeBrightness(float deltaY) {
Activity activity = PlayerUtils.scanForActivity(getContext());
if (!PlayerUtils.isActivityLiving(activity)) {
return;
}
Window window = activity.getWindow();
WindowManager.LayoutParams attributes = window.getAttributes();
int height = getMeasuredHeight();
if (mBrightness == -1.0f) mBrightness = 0.5f;
float brightness = deltaY * 2 / height * 1.0f + mBrightness;
if (brightness < 0) {
brightness = 0f;
}
if (brightness > 1.0f) brightness = 1.0f;
int percent = (int) (brightness * 100);
attributes.screenBrightness = brightness;
window.setAttributes(attributes);
for (Map.Entry<InterControlView, Boolean> next : mControlComponents.entrySet()) {
InterControlView component = next.getKey();
if (component instanceof IGestureComponent) {
((IGestureComponent) component).onBrightnessChange(percent);
}
}
}
protected void slideToChangeVolume(float deltaY) {
int streamMaxVolume = mAudioManager.getStreamMaxVolume(AudioManager.STREAM_MUSIC);
int height = getMeasuredHeight();
float deltaV = deltaY * 2 / height * streamMaxVolume;
float index = mStreamVolume + deltaV;
if (index > streamMaxVolume) index = streamMaxVolume;
if (index < 0) index = 0;
int percent = (int) (index / streamMaxVolume * 100);
mAudioManager.setStreamVolume(AudioManager.STREAM_MUSIC, (int) index, 0);
for (Map.Entry<InterControlView, Boolean> next : mControlComponents.entrySet()) {
InterControlView component = next.getKey();
if (component instanceof IGestureComponent) {
((IGestureComponent) component).onVolumeChange(percent);
}
}
}
// 点击事件产生后，会直接调用dispatchTouchEvent分发方法
/*public boolean dispatchTouchEvent(MotionEvent ev) {
//代表是否消耗事件
boolean consume = false;
if (onInterceptTouchEvent(ev)) {
//如果onInterceptTouchEvent()返回true则代表当前View拦截了点击事件
//则该点击事件则会交给当前View进行处理
//即调用onTouchEvent (）方法去处理点击事件
consume = onTouchEvent (ev) ;
} else {
//如果onInterceptTouchEvent()返回false则代表当前View不拦截点击事件
//则该点击事件则会继续传递给它的子元素
//子元素的dispatchTouchEvent（）就会被调用，重复上述过程
//直到点击事件被最终处理为止
consume = child.dispatchTouchEvent (ev) ;
}
return consume;
}*/
/**
* 拦截事件：只有ViewGroup才有这个
* @param ev event
* @return 返回值
* true： 当前ViewGroup（因为View中没有该方法，而没有child的VIew也不需要有拦截机制）
* 希望该事件不再传递给其child，而是希望自己处理。
* false：当前ViewGroup不准备拦截该事件，事件正常向下分发给其child。
*/
@Override
public boolean onInterceptTouchEvent(MotionEvent ev) {
VideoLogUtils.e("事件----------事件拦截----------");
return super.onInterceptTouchEvent(ev);
}
/**
* 分发事件：使用对象 Activity、ViewGroup、View
* @param ev event
* @return 返回值
* true： 消费事件；事件不会往下传递；后续事件（Move、Up）会继续分发到该View
* false：不消费事件；事件不会往下传递；将事件回传给父控件的onTouchEvent()处理；Activity例外：返回false=消费事件
* 后续事件（Move、Up）会继续分发到该View(与onTouchEvent()区别）
*/
@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
VideoLogUtils.e("事件----------事件分发----------");
return super.dispatchTouchEvent(ev);
}
/**
* 触摸事件
* @param event event事件，主要处理up，down，cancel
* @return 返回值
*/
@Override
public boolean onTouchEvent(MotionEvent event) {
VideoLogUtils.e("事件----------事件触摸----------");
//滑动结束时事件处理
if (!mGestureDetector.onTouchEvent(event)) {
int action = event.getAction();
switch (action) {
case MotionEvent.ACTION_UP:
//抬起View（与DOWN对应）
stopSlide();
if (mSeekPosition > 0) {
mControlWrapper.seekTo(mSeekPosition);
mSeekPosition = 0;
}
break;
case MotionEvent.ACTION_CANCEL:
//非人为原因结束本次事件
stopSlide();
mSeekPosition = 0;
break;
case MotionEvent.ACTION_HOVER_MOVE:
//滑动View
break;
case MotionEvent.ACTION_DOWN:
//按下View（所有事件的开始）
break;
}
}
return super.onTouchEvent(event);
}
private void stopSlide() {
for (Map.Entry<InterControlView, Boolean> next : mControlComponents.entrySet()) {
InterControlView component = next.getKey();
if (component instanceof IGestureComponent) {
//结束滑动
((IGestureComponent) component).onStopSlide();
}
}
}
@Override
public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
return false;
}
@Override
public void onLongPress(MotionEvent e) {
}
@Override
public void onShowPress(MotionEvent e) {
}
@Override
public boolean onDoubleTapEvent(MotionEvent e) {
return false;
}
@Override
public boolean onSingleTapUp(MotionEvent e) {
return false;
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/controller/IGestureComponent.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.video.controller;
import com.yc.video.ui.view.InterControlView;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2018/11/9
* desc : 包含手势操作的VideoController的接口
* revise:
* </pre>
*/
public interface IGestureComponent extends InterControlView {
/**
* 开始滑动
*/
void onStartSlide();
/**
* 结束滑动
* 这个是指，手指抬起或者意外结束事件的时候，调用这个方法
*/
void onStopSlide();
/**
* 滑动调整进度
* @param slidePosition 滑动进度
* @param currentPosition 当前播放进度
* @param duration 视频总长度
*/
void onPositionChange(int slidePosition, int currentPosition, int duration);
/**
* 滑动调整亮度
* @param percent 亮度百分比
*/
void onBrightnessChange(int percent);
/**
* 滑动调整音量
* @param percent 音量百分比
*/
void onVolumeChange(int percent);
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/controller/InterVideoController.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.video.controller;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2017/11/21
* desc : 视频控制器接口
* revise: 定义一些设置视图属性接口
* </pre>
*/
public interface InterVideoController {
/**
* 开始控制视图自动隐藏倒计时
*/
void startFadeOut();
/**
* 取消控制视图自动隐藏倒计时
*/
void stopFadeOut();
/**
* 控制视图是否处于显示状态
*/
boolean isShowing();
/**
* 设置锁定状态
* @param locked 是否锁定
*/
void setLocked(boolean locked);
/**
* 是否处于锁定状态
*/
boolean isLocked();
/**
* 开始刷新进度
*/
void startProgress();
/**
* 停止刷新进度
*/
void stopProgress();
/**
* 显示控制视图
*/
void hide();
/**
* 隐藏控制视图
*/
void show();
/**
* 是否需要适配刘海
*/
boolean hasCutout();
/**
* 获取刘海的高度
*/
int getCutoutHeight();
/**
* 控制器意外销毁，比如手动退出，意外崩溃等等
*/
void destroy();
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/controller/InterViewController.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.video.controller;
import com.yc.video.ui.view.InterControlView;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2017/11/21
* desc : 视频控制器负责自定义视图add/remove操作
* revise:
* </pre>
*/
public interface InterViewController {
/**
* 添加控制组件，最后面添加的在最下面，合理组织添加顺序，可让ControlComponent位于不同的层级
* @param controlViews view
*/
void addControlComponent(InterControlView... controlViews);
/**
* 添加控制组件，最后面添加的在最下面，合理组织添加顺序，可让InterControlView位于不同的层级
* @param controlView view
* @param isPrivate 是否为独有的组件，如果是就不添加到控制器中
*/
void addControlComponent(InterControlView controlView, boolean isPrivate);
/**
* 移除控制组件
* @param controlView view
*/
void removeControlComponent(InterControlView controlView);
/**
* 移除所有的组件
*/
void removeAllControlComponent();
/**
* 移除所有独有的组件
*/
void removeAllPrivateComponents();
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/controller/OrientationHelper.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.video.controller;
import android.content.Context;
import android.view.OrientationEventListener;
/**
* 设备方向监听
*/
public class OrientationHelper extends OrientationEventListener {
private long mLastTime;
private OnOrientationChangeListener mOnOrientationChangeListener;
public OrientationHelper(Context context) {
super(context);
}
@Override
public void onOrientationChanged(int orientation) {
long currentTime = System.currentTimeMillis();
if (currentTime - mLastTime < 500) {
return;
}
//500毫秒检测一次
if (mOnOrientationChangeListener != null) {
mOnOrientationChangeListener.onOrientationChanged(orientation);
}
mLastTime = currentTime;
}
public interface OnOrientationChangeListener {
void onOrientationChanged(int orientation);
}
public void setOnOrientationChangeListener(OnOrientationChangeListener onOrientationChangeListener) {
mOnOrientationChangeListener = onOrientationChangeListener;
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/old/controller/AbsVideoPlayerController.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.video.old.controller;
import android.content.Context;
import android.view.MotionEvent;
import android.view.View;
import android.view.WindowManager;
import android.widget.FrameLayout;
import com.yc.video.tool.PlayerUtils;
import com.yc.video.old.player.OldVideoPlayer;
import com.yc.video.config.ConstantKeys;
import java.util.Timer;
import java.util.TimerTask;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2017/10/21
* desc : 控制器抽象类
* revise:
* </pre>
*/
@Deprecated
public abstract class AbsVideoPlayerController extends FrameLayout implements
View.OnTouchListener, IVideoController {
private Context mContext;
protected OldVideoPlayer mVideoPlayer;
//protected InterPropertyVideoPlayer mVideoPlayer;
private Timer mUpdateProgressTimer;
private TimerTask mUpdateProgressTimerTask;
private Timer mUpdateNetSpeedTimer;
private TimerTask mUpdateNetSpeedTask;
private float mDownX;
private float mDownY;
/**
* 是否需要改变播放的进度
*/
private boolean mNeedChangePosition;
/**
* 是否需要改变播放的声音
*/
private boolean mNeedChangeVolume;
/**
* 是否需要改变播放的亮度
*/
private boolean mNeedChangeBrightness;
private static final int THRESHOLD = 80;
private long mGestureDownPosition;
private float mGestureDownBrightness;
private int mGestureDownVolume;
private long mNewPosition;
public AbsVideoPlayerController(Context context) {
super(context);
mContext = context;
this.setOnTouchListener(this);
}
/**
* 设置VideoPlayer
* @param videoPlayer VideoPlayer对象
*/
public void setVideoPlayer(OldVideoPlayer videoPlayer) {
mVideoPlayer = videoPlayer;
}
/**
* 当正在缓冲或者播放准备中状态时，开启缓冲时更新网络加载速度
*/
protected void startUpdateNetSpeedTimer() {
cancelUpdateNetSpeedTimer();
if (mUpdateNetSpeedTimer == null) {
mUpdateNetSpeedTimer = new Timer();
}
if (mUpdateNetSpeedTask == null) {
mUpdateNetSpeedTask = new TimerTask() {
@Override
public void run() {
//在子线程中更新进度，包括更新网络加载速度
AbsVideoPlayerController.this.post(new Runnable() {
@Override
public void run() {
updateNetSpeedProgress();
}
});
}
};
}
mUpdateNetSpeedTimer.schedule(mUpdateNetSpeedTask, 0, 100);
}
/**
* 取消缓冲时更新网络加载速度
*/
protected void cancelUpdateNetSpeedTimer() {
if (mUpdateNetSpeedTimer != null) {
mUpdateNetSpeedTimer.cancel();
mUpdateNetSpeedTimer = null;
}
if (mUpdateNetSpeedTask != null) {
mUpdateNetSpeedTask.cancel();
mUpdateNetSpeedTask = null;
}
}
/**
* 开启更新进度的计时器。
*/
protected void startUpdateProgressTimer() {
cancelUpdateProgressTimer();
if (mUpdateProgressTimer == null) {
mUpdateProgressTimer = new Timer();
}
if (mUpdateProgressTimerTask == null) {
mUpdateProgressTimerTask = new TimerTask() {
@Override
public void run() {
//在子线程中更新进度，包括进度条进度，展示的当前播放位置时长，总时长等。
AbsVideoPlayerController.this.post(new Runnable() {
@Override
public void run() {
updateProgress();
}
});
}
};
}
mUpdateProgressTimer.schedule(mUpdateProgressTimerTask, 0, 1000);
}
/**
* 取消更新进度的计时器。
*/
protected void cancelUpdateProgressTimer() {
if (mUpdateProgressTimer != null) {
mUpdateProgressTimer.cancel();
mUpdateProgressTimer = null;
}
if (mUpdateProgressTimerTask != null) {
mUpdateProgressTimerTask.cancel();
mUpdateProgressTimerTask = null;
}
}
/**
* 滑动处理调节声音和亮度的逻辑
* @param v v
* @param event event
* @return 是否自己处理滑动事件
*/
@Override
public boolean onTouch(View v, MotionEvent event) {
//不能用这个做判断，如果是小窗口播放状态，那么这个返回时false
//boolean tinyWindow = mVideoPlayer.isTinyWindow();
int playType = mVideoPlayer.getPlayType();
//如果是小窗口模式，则可以拖拽。其他情况则正常处理
if(playType == ConstantKeys.PlayMode.MODE_FULL_SCREEN){
//处理全屏播放时，滑动处理调节声音和亮度的逻辑
return setOnTouch(v,event);
}
return false;
}
/**
* 处理全屏播放时，滑动处理调节声音和亮度的逻辑
* @param v v
* @param event event
* @return 是否自己处理滑动事件
*/
private boolean setOnTouch(View v, MotionEvent event) {
// 只有全屏的时候才能拖动位置、亮度、声音
if (!mVideoPlayer.isFullScreen()) {
return false;
}
// 只有在播放、暂停、缓冲的时候能够拖动改变位置、亮度和声音
if (mVideoPlayer.isIdle() || mVideoPlayer.isError() || mVideoPlayer.isPreparing()
|| mVideoPlayer.isPrepared() || mVideoPlayer.isCompleted()) {
//势左右滑动改变播放位置后，手势up或者cancel时，隐藏控制器中间的播放位置变化视图
hideChangePosition();
//手势在左侧上下滑动改变亮度后，手势up或者cancel时，隐藏控制器中间的亮度变化视图，
hideChangeBrightness();
//手势在左侧上下滑动改变音量后，手势up或者cancel时，隐藏控制器中间的音量变化视图，
hideChangeVolume();
return false;
}
float x = event.getX();
float y = event.getY();
switch (event.getAction()) {
case MotionEvent.ACTION_DOWN:
//获取起点时的坐标
mDownX = x;
mDownY = y;
mNeedChangePosition = false;
mNeedChangeVolume = false;
mNeedChangeBrightness = false;
break;
case MotionEvent.ACTION_MOVE:
//计算移动过程中的x，y轴的绝对值
float deltaX = x - mDownX;
float deltaY = y - mDownY;
float absDeltaX = Math.abs(deltaX);
float absDeltaY = Math.abs(deltaY);
if (!mNeedChangePosition && !mNeedChangeVolume && !mNeedChangeBrightness) {
// 只有在播放、暂停、缓冲的时候能够拖动改变位置、亮度和声音
if (absDeltaX >= THRESHOLD) {
cancelUpdateProgressTimer();
mNeedChangePosition = true;
mGestureDownPosition = mVideoPlayer.getCurrentPosition();
} else if (absDeltaY >= THRESHOLD) {
if (mDownX < getWidth() * 0.5f) {
// 左侧改变亮度
mNeedChangeBrightness = true;
mGestureDownBrightness = PlayerUtils.scanForActivity(mContext)
.getWindow().getAttributes().screenBrightness;
} else {
// 右侧改变声音
mNeedChangeVolume = true;
mGestureDownVolume = mVideoPlayer.getVolume();
}
}
}
//是否需要改变播放的进度
if (mNeedChangePosition) {
long duration = mVideoPlayer.getDuration();
long toPosition = (long) (mGestureDownPosition + duration * deltaX / getWidth());
mNewPosition = Math.max(0, Math.min(duration, toPosition));
int newPositionProgress = (int) (100f * mNewPosition / duration);
showChangePosition(duration, newPositionProgress);
}
//是否改变亮度
if (mNeedChangeBrightness) {
deltaY = -deltaY;
float deltaBrightness = deltaY * 3 / getHeight();
float newBrightness = mGestureDownBrightness + deltaBrightness;
newBrightness = Math.max(0, Math.min(newBrightness, 1));
float newBrightnessPercentage = newBrightness;
WindowManager.LayoutParams params = PlayerUtils.scanForActivity(mContext)
.getWindow().getAttributes();
params.screenBrightness = newBrightnessPercentage;
PlayerUtils.scanForActivity(mContext).getWindow().setAttributes(params);
int newBrightnessProgress = (int) (100f * newBrightnessPercentage);
showChangeBrightness(newBrightnessProgress);
}
//是否改变音量
if (mNeedChangeVolume) {
deltaY = -deltaY;
int maxVolume = mVideoPlayer.getMaxVolume();
int deltaVolume = (int) (maxVolume * deltaY * 3 / getHeight());
int newVolume = mGestureDownVolume + deltaVolume;
newVolume = Math.max(0, Math.min(maxVolume, newVolume));
mVideoPlayer.setVolume(newVolume);
int newVolumeProgress = (int) (100f * newVolume / maxVolume);
showChangeVolume(newVolumeProgress);
}
break;
//滑动结束
case MotionEvent.ACTION_CANCEL:
//滑动手指抬起
case MotionEvent.ACTION_UP:
if (mNeedChangePosition) {
mVideoPlayer.seekTo(mNewPosition);
hideChangePosition();
startUpdateProgressTimer();
return true;
}
if (mNeedChangeBrightness) {
hideChangeBrightness();
return true;
}
if (mNeedChangeVolume) {
hideChangeVolume();
return true;
}
break;
default:
break;
}
return false;
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/old/controller/IVideoController.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.video.old.controller;
import android.widget.ImageView;
import androidx.annotation.DrawableRes;
import com.yc.video.config.ConstantKeys;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2017/11/21
* desc : 视频控制器接口
* revise: 定义一些设置视图属性接口
* </pre>
*/
@Deprecated
public interface IVideoController {
/**
* 设置top到顶部的距离
* @param top top距离
*/
void setTopPadding(float top);
/**
* 设置横屏播放时，tv和audio图标是否显示
* @param isVisibility1 tv图标是否显示
* @param isVisibility2 audio图标是否显示
*/
void setTvAndAudioVisibility(boolean isVisibility1, boolean isVisibility2);
/**
* 视频底图
*
* @param resId 视频底图资源
*/
void setImage(@DrawableRes int resId);
/**
* 设置总时长
*/
void setLength(long length);
/**
* 设置总时长
*/
void setLength(String length);
/**
* 视频底图ImageView控件，提供给外部用图片加载工具来加载网络图片
*
* @return 底图ImageView
*/
ImageView imageView();
/**
* 获取是否是锁屏模式
* @return true表示锁屏
*/
boolean getLock();
/**
* 设置是否显示视频头部的下载，分享布局控件
* @param isVisibility 是否可见
*/
void setTopVisibility(boolean isVisibility);
/**
* 设置不操作后，多久自动隐藏头部和底部布局
* @param time 时间
*/
void setHideTime(long time);
/**
* 设置加载loading类型
*
* @param type 加载loading的类型
* 目前1，是仿腾讯加载loading
* 2，是转圈加载loading
*/
void setLoadingType(@ConstantKeys.LoadingType int type);
/**
* 设置播放的视频的标题
*
* @param title 视频标题
*/
void setTitle(String title);
/**
* 当播放器的播放状态发生变化，在此方法中国你更新不同的播放状态的UI
*
* @param playState 播放状态：
*/
void onPlayStateChanged(@ConstantKeys.CurrentState int playState);
/**
* 当播放器的播放模式发生变化，在此方法中更新不同模式下的控制器界面。
*
* @param playMode 播放器的模式：
*/
void onPlayModeChanged(@ConstantKeys.PlayMode int playMode);
/**
* 重置控制器，将控制器恢复到初始状态。
*/
void reset();
/**
* 控制器意外销毁，比如手动退出，意外崩溃等等
*/
void destroy();
/**
* 更新进度，包括更新网络加载速度
*/
void updateNetSpeedProgress();
/**
* 更新进度，包括进度条进度，展示的当前播放位置时长，总时长等。
*/
void updateProgress();
/**
* 手势左右滑动改变播放位置时，显示控制器中间的播放位置变化视图，
* 在手势滑动ACTION_MOVE的过程中，会不断调用此方法。
*
* @param duration 视频总时长ms
* @param newPositionProgress 新的位置进度，取值0到100。
*/
void showChangePosition(long duration, int newPositionProgress);
/**
* 手势左右滑动改变播放位置后，手势up或者cancel时，隐藏控制器中间的播放位置变化视图，
* 在手势ACTION_UP或ACTION_CANCEL时调用。
*/
void hideChangePosition();
/**
* 手势在右侧上下滑动改变音量时，显示控制器中间的音量变化视图，
* 在手势滑动ACTION_MOVE的过程中，会不断调用此方法。
*
* @param newVolumeProgress 新的音量进度，取值1到100。
*/
void showChangeVolume(int newVolumeProgress);
/**
* 手势在左侧上下滑动改变音量后，手势up或者cancel时，隐藏控制器中间的音量变化视图，
* 在手势ACTION_UP或ACTION_CANCEL时调用。
*/
void hideChangeVolume();
/**
* 手势在左侧上下滑动改变亮度时，显示控制器中间的亮度变化视图，
* 在手势滑动ACTION_MOVE的过程中，会不断调用此方法。
*
* @param newBrightnessProgress 新的亮度进度，取值1到100。
*/
void showChangeBrightness(int newBrightnessProgress);
/**
* 手势在左侧上下滑动改变亮度后，手势up或者cancel时，隐藏控制器中间的亮度变化视图，
* 在手势ACTION_UP或ACTION_CANCEL时调用。
*/
void hideChangeBrightness();
/**
* 当电量发生变化的时候，在此方法中国你更新不同的电量状态的UI
*
* @param batterState 电量状态
*/
void onBatterStateChanged(int batterState);
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/old/controller/VideoPlayerController.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.video.old.controller;
import android.annotation.SuppressLint;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.Build;
import android.os.CountDownTimer;
import android.view.LayoutInflater;
import android.view.MotionEvent;
import android.view.View;
import android.widget.FrameLayout;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.ProgressBar;
import android.widget.SeekBar;
import android.widget.TextView;
import androidx.annotation.DrawableRes;
import androidx.annotation.IntRange;
import com.yc.kernel.utils.VideoLogUtils;
import com.yc.video.tool.BaseToast;
import com.yc.video.tool.PlayerUtils;
import com.yc.video.config.VideoInfoBean;
import com.yc.video.old.dialog.ChangeClarityDialog;
import com.yc.video.R;
import com.yc.video.old.listener.OnPlayerStatesListener;
import com.yc.video.old.listener.OnPlayerTypeListener;
import com.yc.video.old.player.OldVideoPlayer;
import com.yc.video.old.other.BatterReceiver;
import com.yc.video.old.other.NetChangedReceiver;
import com.yc.video.config.ConstantKeys;
import com.yc.video.old.listener.OnClarityChangedListener;
import com.yc.video.old.listener.OnVideoControlListener;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Locale;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2017/9/29
* desc : 播放器控制器，主要是处理UI操作逻辑
* revise: 注意：建议先判断状态，再进行设置参数
* </pre>
*/
@Deprecated
public class VideoPlayerController extends AbsVideoPlayerController implements View.OnClickListener{
private Context mContext;
private ImageView mImage;
private ImageView mCenterStart;
/**
* top顶部视图，包括所有的
*/
private LinearLayout mTop;
private ImageView mBack;
private TextView mTitle;
/**
* 正常视频，top顶部视图，包括下载，分享，更多，音频控件
*/
private LinearLayout mLlTopOther;
private ImageView mIvDownload;
private ImageView mIvAudio;
private ImageView mIvShare;
private ImageView mIvMenu;
/**
* 横向屏幕视图，top顶部视图，包括音频，tv，电量，时间等控件
*/
private LinearLayout mLlHorizontal;
private ImageView mIvHorAudio;
private ImageView mIvHorTv;
private ImageView mBattery;
private TextView mTime;
/**
* 底部视图，包括所有的
*/
private LinearLayout mBottom;
private ImageView mRestartPause;
private TextView mPosition;
private TextView mDuration;
private SeekBar mSeek;
private TextView mClarity;
private ImageView mFullScreen;
private TextView mLength;
/**
* 加载loading视图，包括所有的
*/
private LinearLayout mLoading;
private ProgressBar pbLoadingRing;
private ProgressBar pbLoadingQq;
private TextView mLoadText;
/**
* 改变播放位置视图，这个是在屏幕上左右滑动切换播放进度的控件
*/
private LinearLayout mChangePosition;
private TextView mChangePositionCurrent;
private ProgressBar mChangePositionProgress;
/**
* 改变屏幕亮度视图，这个是在屏幕左边上下滑动改变亮度的控件
*/
private LinearLayout mChangeBrightness;
private ProgressBar mChangeBrightnessProgress;
/**
* 改变播放声音视图，这个是在屏幕右边上下滑动改变音量的控件
*/
private LinearLayout mChangeVolume;
private ProgressBar mChangeVolumeProgress;
/**
* 异常壮体视图
*/
private LinearLayout mError;
private TextView mTvError;
private TextView mRetry;
/**
* 完成播放视图
*/
private LinearLayout mCompleted;
private TextView mReplay;
private TextView mShare;
/**
* 锁屏视图，只有在横屏播放的时候才会显示
*/
private FrameLayout mFlLock;
private ImageView mIvLock;
/**
* 底部播放进度条
*/
private LinearLayout mLine;
private ProgressBar mPbPlayBar;
/**
* top视图和bottom视图是否显示
*/
private boolean topBottomVisible;
/**
* 倒计时器
*/
private CountDownTimer mDismissTopBottomCountDownTimer;
private List<VideoInfoBean> clarities;
private int defaultClarityIndex;
private ChangeClarityDialog mClarityDialog;
/**
* 是否已经注册了电池广播
*/
private boolean hasRegisterBatteryReceiver;
/**
* 是否已经注册了网络监听广播，添加这个判断可以避免崩溃
*/
private boolean hasRegisterNetReceiver;
/**
* 是否锁屏
*/
private boolean mIsLock = false;
/**
* 这个是time时间不操作界面，则自动隐藏顶部和底部视图布局
*/
private long time;
/**
* 顶部的布局，下载，切换音频，分享布局是否显示。
* 默认为false，不显示
*/
private boolean mIsTopLayoutVisibility = false;
/**
* 设置横屏播放时，tv图标是否显示
* 默认为false，不显示
*/
private boolean mIsTvIconVisibility = false;
/**
* 设置横屏播放时，audio图标是否显示
* 默认为false，不显示
*/
private boolean mIsAudioIconVisibility = false;
/**
* 网络变化监听广播，在网络变更时进行对应处理
*/
private NetChangedReceiver netChangedReceiver;
/**
* 电池状态即电量变化广播接收器
*/
private BroadcastReceiver mBatterReceiver;
public VideoPlayerController(Context context) {
super(context);
mContext = context;
init();
}
@Override
protected void onAttachedToWindow() {
super.onAttachedToWindow();
}
/**
* 注意，在view被销毁调用该方法后，手动销毁动画
*/
@Override
protected void onDetachedFromWindow() {
super.onDetachedFromWindow();
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
if (pbLoadingRing!=null && pbLoadingRing.getVisibility()==View.VISIBLE){
boolean animating = pbLoadingRing.isAnimating();
if (animating){
pbLoadingRing.clearAnimation();
}
}
if (pbLoadingQq!=null && pbLoadingQq.getVisibility()==View.VISIBLE){
boolean ringAnimating = pbLoadingQq.isAnimating();
if (ringAnimating){
pbLoadingQq.clearAnimation();
}
}
} else {
if (pbLoadingRing!=null && pbLoadingRing.getVisibility()==View.VISIBLE){
pbLoadingRing.clearAnimation();
}
if (pbLoadingQq!=null && pbLoadingQq.getVisibility()==View.VISIBLE){
pbLoadingQq.clearAnimation();
}
}
}
/**
* 注册网络监听广播
*/
private void registerNetChangedReceiver() {
if (!hasRegisterNetReceiver) {
if (netChangedReceiver == null) {
netChangedReceiver = new NetChangedReceiver();
IntentFilter filter = new IntentFilter();
filter.addAction("android.net.conn.CONNECTIVITY_CHANGE");
mContext.registerReceiver(netChangedReceiver, filter);
VideoLogUtils.i("广播监听---------注册网络监听广播");
}
hasRegisterNetReceiver = true;
}
}
/**
* 当播放完成或者意外销毁，都需要解绑注册网络监听广播
*/
private void unRegisterNetChangedReceiver() {
if (hasRegisterNetReceiver) {
if (netChangedReceiver != null) {
mContext.unregisterReceiver(netChangedReceiver);
VideoLogUtils.i("广播监听---------解绑注册网络监听广播");
}
hasRegisterNetReceiver = false;
}
}
/**
* 注册电池监听广播
*/
private void registerBatterReceiver() {
if (!hasRegisterBatteryReceiver) {
mBatterReceiver = new BatterReceiver();
mContext.registerReceiver(mBatterReceiver, new IntentFilter(
Intent.ACTION_BATTERY_CHANGED));
hasRegisterBatteryReceiver = true;
VideoLogUtils.i("广播监听---------注册电池监听广播");
}
}
/**
* 当播放完成或者意外销毁，都需要解绑注册电池监听广播
*/
private void unRegisterBatterReceiver() {
if (hasRegisterBatteryReceiver) {
mContext.unregisterReceiver(mBatterReceiver);
hasRegisterBatteryReceiver = false;
VideoLogUtils.i("广播监听---------解绑电池监听广播");
}
}
/**
* 初始化操作
*/
private void init() {
LayoutInflater.from(mContext).inflate(R.layout.old_video_player, this, true);
initFindViewById();
initListener();
registerNetChangedReceiver();
}
private void initFindViewById() {
mCenterStart = findViewById(R.id.center_start);
mImage = findViewById(R.id.image);
mTop = findViewById(R.id.top);
mBack = findViewById(R.id.back);
mTitle = findViewById(R.id.title);
mLlTopOther = findViewById(R.id.ll_top_other);
mIvDownload = findViewById(R.id.iv_download);
mIvAudio = findViewById(R.id.iv_audio);
mIvShare = findViewById(R.id.iv_share);
mIvMenu = findViewById(R.id.iv_menu);
mLlHorizontal = findViewById(R.id.ll_horizontal);
mIvHorAudio = findViewById(R.id.iv_hor_audio);
mIvHorTv = findViewById(R.id.iv_hor_tv);
mBattery = findViewById(R.id.battery);
mTime = findViewById(R.id.time);
mBottom = findViewById(R.id.bottom);
mRestartPause = findViewById(R.id.restart_or_pause);
mPosition = findViewById(R.id.position);
mDuration = findViewById(R.id.duration);
mSeek = findViewById(R.id.seek);
mFullScreen = findViewById(R.id.full_screen);
mClarity = findViewById(R.id.clarity);
mLength = findViewById(R.id.length);
mLoading = findViewById(R.id.loading);
pbLoadingRing = findViewById(R.id.pb_loading_ring);
pbLoadingQq = findViewById(R.id.pb_loading_qq);
mLoadText = findViewById(R.id.load_text);
mChangePosition = findViewById(R.id.change_position);
mChangePositionCurrent = findViewById(R.id.change_position_current);
mChangePositionProgress = findViewById(R.id.change_position_progress);
mChangeBrightness = findViewById(R.id.change_brightness);
mChangeBrightnessProgress = findViewById(R.id.change_brightness_progress);
mChangeVolume = findViewById(R.id.change_volume);
mChangeVolumeProgress = findViewById(R.id.change_volume_progress);
mError = findViewById(R.id.error);
mTvError = findViewById(R.id.tv_error);
mRetry = findViewById(R.id.retry);
mCompleted = findViewById(R.id.completed);
mReplay = findViewById(R.id.replay);
mShare = findViewById(R.id.share);
mFlLock = findViewById(R.id.fl_lock);
mIvLock = findViewById(R.id.iv_lock);
mLine = findViewById(R.id.line);
mPbPlayBar = findViewById(R.id.pb_play_bar);
setTopVisibility(mIsTopLayoutVisibility);
}
private void initListener() {
mCenterStart.setOnClickListener(this);
mBack.setOnClickListener(this);
mIvDownload.setOnClickListener(this);
mIvShare.setOnClickListener(this);
mIvAudio.setOnClickListener(this);
mIvMenu.setOnClickListener(this);
mIvHorAudio.setOnClickListener(this);
mIvHorTv.setOnClickListener(this);
mRestartPause.setOnClickListener(this);
mFullScreen.setOnClickListener(this);
mClarity.setOnClickListener(this);
mRetry.setOnClickListener(this);
mReplay.setOnClickListener(this);
mShare.setOnClickListener(this);
mFlLock.setOnClickListener(this);
mSeek.setOnSeekBarChangeListener(new SeekBar.OnSeekBarChangeListener() {
@Override
public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) {
}
@Override
public void onStartTrackingTouch(SeekBar seekBar) {
}
@Override
public void onStopTrackingTouch(SeekBar seekBar) {
if (mVideoPlayer.isBufferingPaused() || mVideoPlayer.isPaused()) {
mVideoPlayer.restart();
}
long position = (long) (mVideoPlayer.getDuration() * seekBar.getProgress() / 100f);
mVideoPlayer.seekTo(position);
startDismissTopBottomTimer();
}
});
this.setOnClickListener(this);
}
/**
* 18年3月15日添加
* 设置是否显示视频头部的下载，分享布局控件
* @param isVisibility 是否可见
*/
@Override
public void setTopVisibility(boolean isVisibility) {
this.mIsTopLayoutVisibility = isVisibility;
if(isVisibility){
mLlTopOther.setVisibility(VISIBLE);
}else {
mLlTopOther.setVisibility(GONE);
}
}
/**
* 设置横屏播放时，tv和audio图标是否显示
* @param isVisibility1 tv图标是否显示
* @param isVisibility2 audio图标是否显示
*/
@Override
public void setTvAndAudioVisibility(boolean isVisibility1, boolean isVisibility2) {
this.mIsTvIconVisibility = isVisibility1;
this.mIsAudioIconVisibility = isVisibility2;
mIvHorTv.setVisibility(mIsTvIconVisibility?VISIBLE:GONE);
mIvHorAudio.setVisibility(mIsAudioIconVisibility?VISIBLE:GONE);
}
/**
* 18年1月12号添加
* 设置加载loading类型
*
* @param type 加载loading的类型
* 目前1，是仿腾讯加载loading
* 2，是转圈加载loading
* 默认是2，后期想让用户自定义loading加载视图，不过暂时没实现
* 更多可以关注我的GitHub：https://github.com/yangchong211
*/
@Override
public void setLoadingType(@ConstantKeys.LoadingType int type) {
switch (type){
case ConstantKeys.Loading.LOADING_RING:
pbLoadingRing.setVisibility(VISIBLE);
pbLoadingQq.setVisibility(GONE);
break;
case ConstantKeys.Loading.LOADING_QQ:
pbLoadingRing.setVisibility(GONE);
pbLoadingQq.setVisibility(VISIBLE);
break;
default:
pbLoadingRing.setVisibility(VISIBLE);
pbLoadingQq.setVisibility(GONE);
break;
}
}
/**
* 设置不操作后，多久自动隐藏头部和底部布局
* 添加值范围注释，限定时间为1秒到10秒之间
* @param time 时间
*/
@Override
public void setHideTime(@IntRange(from = 1000 , to = 10000) long time) {
this.time = time;
}
/**
* 设置视频标题
* @param title 视频标题
*/
@Override
public void setTitle(String title) {
if (title!=null && title.length()>0){
mTitle.setText(title);
}
}
/**
* 获取ImageView的对象
* @return 对象
*/
@Override
public ImageView imageView() {
return mImage;
}
/**
* 设置图片
* @param resId 视频底图资源
*/
@Override
public void setImage(@DrawableRes int resId) {
mImage.setImageResource(resId);
}
/**
* 设置视频时长
* @param length 时长，long类型
*/
@Override
public void setLength(long length) {
if (length>0){
mLength.setVisibility(VISIBLE);
mLength.setText(PlayerUtils.formatTime(length));
} else {
mLength.setVisibility(GONE);
}
}
/**
* 设置视频时长
* @param length 时长，String类型
*/
@Override
public void setLength(String length) {
if (length!=null && length.length()>0){
mLength.setVisibility(VISIBLE);
mLength.setText(length);
} else {
mLength.setVisibility(GONE);
}
}
/**
* 设置播放器
* @param videoPlayer 播放器
*/
@Override
public void setVideoPlayer(OldVideoPlayer videoPlayer) {
super.setVideoPlayer(videoPlayer);
// 给播放器配置视频链接地址
if (clarities != null && clarities.size() > 1 && clarities.size()>defaultClarityIndex) {
mVideoPlayer.setUp(clarities.get(defaultClarityIndex).getVideoUrl(), null);
}
}
/**
* 设置top到顶部的距离
* @param top top
*/
@Override
public void setTopPadding(float top) {
//如果设置0，则模式是10dp
if (top==0){
top = 10.0f;
}
mTop.setPadding(PlayerUtils.dp2px(mContext,10.0f),
PlayerUtils.dp2px(mContext,top),
PlayerUtils.dp2px(mContext,10.0f), 0);
mTop.invalidate();
}
/**
* 获取是否是锁屏模式
* @return true表示锁屏
*/
@Override
public boolean getLock() {
return mIsLock;
}
/**
* 如果锁屏，则屏蔽滑动事件
*/
@Override
public boolean onTouchEvent(MotionEvent event) {
VideoLogUtils.i("如果锁屏2，则屏蔽返回键");
//如果锁屏了，那就就不需要处理滑动的逻辑
return !getLock() && super.onTouchEvent(event);
}
/**
* 设置视频清晰度
* @param clarities 清晰度
* @param defaultClarityIndex 默认清晰度
*/
public void setClarity(final List<VideoInfoBean> clarities, int defaultClarityIndex) {
if (clarities != null && clarities.size() > 1) {
this.clarities = clarities;
this.defaultClarityIndex = defaultClarityIndex;
List<String> clarityGrades = new ArrayList<>();
for (VideoInfoBean clarity : clarities) {
clarityGrades.add(clarity.getGrade() + " " + clarity.getP());
}
mClarity.setText(clarities.get(defaultClarityIndex).getGrade());
// 初始化切换清晰度对话框
mClarityDialog = new ChangeClarityDialog(mContext);
mClarityDialog.setClarityGrade(clarityGrades, defaultClarityIndex);
mClarityDialog.setOnClarityCheckedListener(new OnClarityChangedListener() {
@Override
public void onClarityChanged(int clarityIndex) {
// 根据切换后的清晰度索引值，设置对应的视频链接地址，并从当前播放位置接着播放
VideoInfoBean clarity = clarities.get(clarityIndex);
mClarity.setText(clarity.getGrade());
long currentPosition = mVideoPlayer.getCurrentPosition();
//释放播放器
mVideoPlayer.releasePlayer();
//设置视频Url，以及headers
mVideoPlayer.setUp(clarity.getVideoUrl(), null);
//开始从此位置播放
mVideoPlayer.start(currentPosition);
}
@Override
public void onClarityNotChanged() {
// 清晰度没有变化，对话框消失后，需要重新显示出top、bottom
setTopBottomVisible(true);
}
});
// 给播放器配置视频链接地址
if (mVideoPlayer != null) {
mVideoPlayer.setUp(clarities.get(defaultClarityIndex).getVideoUrl(), null);
}
}
}
/**
* 当播放状态发生改变时
* @param playState 播放状态：
*/
@SuppressLint("SetTextI18n")
@Override
public void onPlayStateChanged(@ConstantKeys.CurrentState int playState) {
switch (playState) {
case ConstantKeys.CurrentState.STATE_IDLE:
break;
//播放准备中
case ConstantKeys.CurrentState.STATE_PREPARING:
startPreparing();
break;
//播放准备就绪
case ConstantKeys.CurrentState.STATE_PREPARED:
startUpdateProgressTimer();
//取消缓冲时更新网络加载速度
cancelUpdateNetSpeedTimer();
break;
//正在播放
case ConstantKeys.CurrentState.STATE_PLAYING:
statePlaying();
break;
//暂停播放
case ConstantKeys.CurrentState.STATE_PAUSED:
statePaused();
break;
//正在缓冲(播放器正在播放时，缓冲区数据不足，进行缓冲，缓冲区数据足够后恢复播放)
case ConstantKeys.CurrentState.STATE_BUFFERING_PLAYING:
stateBufferingPlaying();
break;
//暂停缓冲
case ConstantKeys.CurrentState.STATE_BUFFERING_PAUSED:
stateBufferingPaused();
break;
//播放错误
case ConstantKeys.CurrentState.STATE_ERROR:
stateError();
break;
//播放完成
case ConstantKeys.CurrentState.STATE_COMPLETED:
stateCompleted();
break;
default:
break;
}
}
/**
* 播放准备中
*/
private void startPreparing() {
mLoading.setVisibility(View.VISIBLE);
mLoadText.setText("正在准备...");
mImage.setVisibility(View.GONE);
mError.setVisibility(View.GONE);
mCompleted.setVisibility(View.GONE);
mCenterStart.setVisibility(View.GONE);
mLength.setVisibility(View.GONE);
mPbPlayBar.setVisibility(GONE);
setTopBottomVisible(false);
//开启缓冲时更新网络加载速度
startUpdateNetSpeedTimer();
startUpdateProgressTimer();
}
/**
* 正在播放
*/
private void statePlaying() {
mLoading.setVisibility(View.GONE);
mPbPlayBar.setVisibility(View.VISIBLE);
mRestartPause.setImageResource(R.drawable.ic_player_pause);
mCenterStart.setImageResource(R.drawable.icon_pause_center);
setTopBottomVisible(true);
startDismissTopBottomTimer();
cancelUpdateNetSpeedTimer();
}
/**
* 暂停播放
*/
private void statePaused() {
mLoading.setVisibility(View.GONE);
mRestartPause.setImageResource(R.drawable.ic_player_start);
mCenterStart.setImageResource(R.drawable.icon_play_center);
setTopBottomVisible(true);
cancelDismissTopBottomTimer();
cancelUpdateNetSpeedTimer();
}
/**
* 正在缓冲(播放器正在播放时，缓冲区数据不足，进行缓冲，缓冲区数据足够后恢复播放)
*/
private void stateBufferingPlaying() {
mLoading.setVisibility(View.VISIBLE);
setTopBottomVisible(false);
mRestartPause.setImageResource(R.drawable.ic_player_pause);
mCenterStart.setImageResource(R.drawable.icon_pause_center);
mLoadText.setText("正在准备...");
startDismissTopBottomTimer();
cancelUpdateNetSpeedTimer();
}
/**
* 暂停缓冲
*/
private void stateBufferingPaused() {
mLoading.setVisibility(View.VISIBLE);
mRestartPause.setImageResource(R.drawable.ic_player_start);
mCenterStart.setImageResource(R.drawable.icon_play_center);
mLoadText.setText("正在准备...");
setTopBottomVisible(false);
cancelDismissTopBottomTimer();
//开启缓冲时更新网络加载速度
startUpdateNetSpeedTimer();
}
/**
* 播放错误
*/
private void stateError() {
mLoading.setVisibility(View.GONE);
setTopBottomVisible(false);
mError.setVisibility(View.VISIBLE);
cancelUpdateProgressTimer();
cancelUpdateNetSpeedTimer();
if (!PlayerUtils.isConnected(mContext)){
mTvError.setText("没有网络，请链接网络");
} else {
mTvError.setText("播放错误，请重试");
}
}
/**
* 播放完成
*/
private void stateCompleted() {
cancelUpdateProgressTimer();
cancelUpdateNetSpeedTimer();
setTopBottomVisible(false);
mLoading.setVisibility(View.GONE);
mImage.setVisibility(View.VISIBLE);
mCompleted.setVisibility(View.VISIBLE);
//设置播放完成的监听事件
if (mOnPlayerStatesListener!=null){
mOnPlayerStatesListener.onPlayerStates(ConstantKeys.PlayerStatesType.COMPLETED);
}
mPbPlayBar.setProgress(100);
//当播放完成就解除广播
unRegisterNetChangedReceiver();
}
/**
* 当播放器的播放模式发生变化时
* @param playMode 播放器的模式：
*/
@Override
public void onPlayModeChanged(@ConstantKeys.PlayMode int playMode) {
switch (playMode) {
//普通模式
case ConstantKeys.PlayMode.MODE_NORMAL:
//隐藏锁屏控件
mFlLock.setVisibility(View.GONE);
mFullScreen.setImageResource(R.drawable.ic_player_open);
mFullScreen.setVisibility(View.VISIBLE);
//隐藏清晰度
mClarity.setVisibility(View.GONE);
//隐藏横屏的时候展现的布局
mLlHorizontal.setVisibility(View.GONE);
unRegisterBatterReceiver();
mIsLock = false;
if (mOnPlayerTypeListener!=null){
mOnPlayerTypeListener.onPlayerPattern(ConstantKeys.PlayMode.MODE_NORMAL);
}
setTopBottomVisible(true);
//隐藏电量图标
mBattery.setVisibility(GONE);
VideoLogUtils.d("播放模式--------普通模式");
break;
//全屏模式
case ConstantKeys.PlayMode.MODE_FULL_SCREEN:
mFlLock.setVisibility(View.VISIBLE);
mFullScreen.setVisibility(View.VISIBLE);
mFullScreen.setImageResource(R.drawable.ic_player_close);
if (clarities != null && clarities.size() > 1) {
mClarity.setVisibility(View.VISIBLE);
}
mLlHorizontal.setVisibility(View.VISIBLE);
mIvHorTv.setVisibility(mIsTvIconVisibility?VISIBLE:GONE);
mIvHorAudio.setVisibility(mIsAudioIconVisibility?VISIBLE:GONE);
setTopBottomVisible(true);
registerBatterReceiver();
if (mOnPlayerTypeListener!=null){
mOnPlayerTypeListener.onPlayerPattern(ConstantKeys.PlayMode.MODE_FULL_SCREEN);
}
VideoLogUtils.d("播放模式--------全屏模式");
break;
//小窗口模式
case ConstantKeys.PlayMode.MODE_TINY_WINDOW:
mFlLock.setVisibility(View.GONE);
mFullScreen.setImageResource(R.drawable.ic_player_open);
mFullScreen.setVisibility(View.VISIBLE);
mIsLock = false;
if (mOnPlayerTypeListener!=null){
mOnPlayerTypeListener.onPlayerPattern(ConstantKeys.PlayMode.MODE_TINY_WINDOW);
}
VideoLogUtils.d("播放模式--------小窗口模式");
break;
default:
break;
}
}
/**
* 重新设置
*/
@Override
public void reset() {
topBottomVisible = false;
cancelUpdateProgressTimer();
cancelDismissTopBottomTimer();
mSeek.setProgress(0);
mSeek.setSecondaryProgress(0);
mPbPlayBar.setProgress(0);
mCenterStart.setVisibility(VISIBLE);
mLength.setVisibility(View.GONE);
mFlLock.setVisibility(View.GONE);
mImage.setVisibility(View.VISIBLE);
mBottom.setVisibility(View.GONE);
mLoading.setVisibility(View.GONE);
mError.setVisibility(View.GONE);
mCompleted.setVisibility(View.GONE);
}
/**
* 注意：跟重置有区别
* 控制器意外销毁，比如手动退出，意外崩溃等等
*/
@Override
public void destroy() {
//当播放完成就解除广播
unRegisterNetChangedReceiver();
unRegisterBatterReceiver();
//结束timer
cancelUpdateProgressTimer();
cancelUpdateNetSpeedTimer();
}
/**
* 尽量不要在onClick中直接处理控件的隐藏、显示及各种UI逻辑。
* UI相关的逻辑都尽量到{@link #onPlayStateChanged}和{@link #onPlayModeChanged}中处理.
*/
@Override
public void onClick(View v) {
if (v == mCenterStart) {
//开始播放
startVideo();
} else if (v == mBack) {
//退出，执行返回逻辑
//如果是全屏，则先退出全屏
if (mVideoPlayer.isFullScreen()) {
mVideoPlayer.exitFullScreen();
} else if (mVideoPlayer.isTinyWindow()) {
//如果是小窗口，则退出小窗口
mVideoPlayer.exitTinyWindow();
} else {
//如果两种情况都不是，执行逻辑交给使用者自己实现
if(mOnPlayerStatesListener!=null){
mOnPlayerStatesListener.onPlayerStates(ConstantKeys.PlayerStatesType.BACK_CLICK);
}else {
VideoLogUtils.d("返回键逻辑，如果是全屏，则先退出全屏；如果是小窗口，则退出小窗口；如果两种情况都不是，执行逻辑交给使用者自己实现");
}
}
} else if (v == mRestartPause) {
if(PlayerUtils.isConnected(mContext)){
//重新播放或者暂停
if (mVideoPlayer.isPlaying() || mVideoPlayer.isBufferingPlaying()) {
mVideoPlayer.pause();
if (mOnPlayerStatesListener!=null){
mOnPlayerStatesListener.onPlayerStates(ConstantKeys.PlayerStatesType.PLAYING);
}
} else if (mVideoPlayer.isPaused() || mVideoPlayer.isBufferingPaused()) {
mVideoPlayer.restart();
if (mOnPlayerStatesListener!=null){
mOnPlayerStatesListener.onPlayerStates(ConstantKeys.PlayerStatesType.PAUSE);
}
}
}else {
BaseToast.showRoundRectToast("请检测是否有网络");
}
} else if (v == mFullScreen) {
//全屏模式，重置锁屏，设置为未选中状态
if (mVideoPlayer.isNormal() || mVideoPlayer.isTinyWindow()) {
mFlLock.setVisibility(VISIBLE);
mIsLock = false;
mIvLock.setImageResource(R.drawable.ic_player_lock_close);
mVideoPlayer.enterFullScreen();
} else if (mVideoPlayer.isFullScreen()) {
mFlLock.setVisibility(GONE);
mVideoPlayer.exitFullScreen();
}
} else if (v == mClarity) {
//设置清晰度
//隐藏top、bottom
setTopBottomVisible(false);
//显示清晰度对话框
mClarityDialog.show();
} else if (v == mRetry) {
//点击重试
if(PlayerUtils.isConnected(mContext)){
startPreparing();
//开始从此位置播放
mVideoPlayer.restart();
}else {
BaseToast.showRoundRectToast("请检测是否有网络");
}
} else if (v == mReplay) {
//重新播放
if(PlayerUtils.isConnected(mContext)){
mRetry.performClick();
}else {
BaseToast.showRoundRectToast("请检测是否有网络");
}
} else if (v == mShare) {
//分享
if(mVideoControlListener==null){
VideoLogUtils.d("请在初始化的时候设置分享监听事件");
return;
}
//点击下载
mVideoControlListener.onVideoControlClick(ConstantKeys.VideoControl.SHARE);
} else if(v == mFlLock){
//点击锁屏按钮，则进入锁屏模式
setLock(mIsLock);
} else if(v == mIvDownload){
if(mVideoControlListener==null){
VideoLogUtils.d("请在初始化的时候设置下载监听事件");
return;
}
//点击下载
mVideoControlListener.onVideoControlClick(ConstantKeys.VideoControl.DOWNLOAD);
} else if(v == mIvAudio){
if(mVideoControlListener==null){
VideoLogUtils.d("请在初始化的时候设置切换监听事件");
return;
}
//点击切换音频
mVideoControlListener.onVideoControlClick(ConstantKeys.VideoControl.AUDIO);
}else if(v == mIvShare){
if(mVideoControlListener==null){
VideoLogUtils.d("请在初始化的时候设置分享监听事件");
return;
}
//点击分享
mVideoControlListener.onVideoControlClick(ConstantKeys.VideoControl.SHARE);
}else if(v == mIvMenu){
if(mVideoControlListener==null){
VideoLogUtils.d("请在初始化的时候设置分享监听事件");
return;
}
//点击菜单
mVideoControlListener.onVideoControlClick(ConstantKeys.VideoControl.MENU);
}else if(v == mIvHorAudio){
if(mVideoControlListener==null){
VideoLogUtils.d("请在初始化的时候设置横向音频监听事件");
return;
}
//点击横向音频
mVideoControlListener.onVideoControlClick(ConstantKeys.VideoControl.HOR_AUDIO);
}else if(v == mIvHorTv){
if(mVideoControlListener==null){
VideoLogUtils.d("请在初始化的时候设置横向Tv监听事件");
return;
}
//点击横向TV
mVideoControlListener.onVideoControlClick(ConstantKeys.VideoControl.TV);
} else if (v == this) {
if (mVideoPlayer.isFullScreen() || mVideoPlayer.isNormal()){
if (mVideoPlayer.isPlaying() || mVideoPlayer.isPaused()
|| mVideoPlayer.isBufferingPlaying() || mVideoPlayer.isBufferingPaused()) {
setTopBottomVisible(!topBottomVisible);
}
}
}
}
/**
* 开始播放
*/
private void startVideo() {
//开始播放
if (mVideoPlayer.isIdle()) {
mVideoPlayer.start();
}else if (mVideoPlayer.isPlaying() || mVideoPlayer.isBufferingPlaying()) {
mVideoPlayer.pause();
} else if (mVideoPlayer.isPaused() || mVideoPlayer.isBufferingPaused()) {
mVideoPlayer.restart();
}
}
/**
* 当电量发生变化的时候，在此方法中国你更新不同的电量状态的UI
*
* @param batterState 电量状态
*/
@Override
public void onBatterStateChanged(@ConstantKeys.BatterMode int batterState) {
switch (batterState){
case ConstantKeys.BatterMode.BATTERY_10:
mBattery.setImageResource(R.drawable.battery_10);
break;
case ConstantKeys.BatterMode.BATTERY_20:
mBattery.setImageResource(R.drawable.battery_20);
break;
case ConstantKeys.BatterMode.BATTERY_50:
mBattery.setImageResource(R.drawable.battery_50);
break;
case ConstantKeys.BatterMode.BATTERY_80:
mBattery.setImageResource(R.drawable.battery_80);
break;
case ConstantKeys.BatterMode.BATTERY_100:
mBattery.setImageResource(R.drawable.battery_100);
break;
case ConstantKeys.BatterMode.BATTERY_FULL:
mBattery.setImageResource(R.drawable.battery_full);
break;
case ConstantKeys.BatterMode.BATTERY_CHARGING:
mBattery.setImageResource(R.drawable.battery_charging);
break;
default:
break;
}
}
/**
* 设置top、bottom的显示和隐藏
* @param visible true显示，false隐藏.
*/
private void setTopBottomVisible(boolean visible) {
setCenterVisible(visible);
mTop.setVisibility(visible ? View.VISIBLE : View.GONE);
mBottom.setVisibility(visible ? View.VISIBLE : View.GONE);
mLine.setVisibility(visible ? View.GONE : View.VISIBLE);
topBottomVisible = visible;
if (visible) {
if (!mVideoPlayer.isPaused() && !mVideoPlayer.isBufferingPaused()) {
startDismissTopBottomTimer();
}
} else {
cancelDismissTopBottomTimer();
}
}
/**
* 设置center的显示和隐藏
* @param visible true显示，false隐藏.
*/
private void setCenterVisible(boolean visible){
mCenterStart.setVisibility(visible ? View.VISIBLE : View.GONE);
}
/**
* 开启top、bottom自动消失的timer
* 比如，视频常用功能，当用户5秒不操作后，自动隐藏头部和顶部
*/
private void startDismissTopBottomTimer() {
if(time==0){
time = 8000;
}
cancelDismissTopBottomTimer();
if (mDismissTopBottomCountDownTimer == null) {
//CountDownTimer定时器
mDismissTopBottomCountDownTimer = new CountDownTimer(time, time) {
@Override
public void onTick(long millisUntilFinished) {
}
@Override
public void onFinish() {
setTopBottomVisible(false);
}
};
}
mDismissTopBottomCountDownTimer.start();
}
/**
* 取消top、bottom自动消失的timer
*/
private void cancelDismissTopBottomTimer() {
if (mDismissTopBottomCountDownTimer != null) {
mDismissTopBottomCountDownTimer.cancel();
}
}
/**
* 设置锁屏模式，默认是未锁屏的
* 当为true时，则锁屏；否则为未锁屏
* @param isLock 是否锁屏
*/
private void setLock(boolean isLock){
if(isLock){
mIsLock = false;
mIvLock.setImageResource(R.drawable.ic_player_lock_open);
}else {
mIsLock = true;
mIvLock.setImageResource(R.drawable.ic_player_lock_close);
}
/*
* 设置锁屏时的布局
* 1.横屏全屏时显示，其他不展示；
* 2.锁屏时隐藏控制面板除锁屏按钮外其他所有控件
* 3.当从全屏切换到正常或者小窗口时，则默认不锁屏
*/
setTopBottomVisible(!mIsLock);
}
/**
* 更新进度，包括更新网络加载速度
*/
@SuppressLint("SetTextI18n")
@Override
public void updateNetSpeedProgress() {
//获取网络加载速度
long tcpSpeed = mVideoPlayer.getTcpSpeed();
VideoLogUtils.i("获取网络加载速度++++++++"+tcpSpeed);
if (tcpSpeed>0){
int speed = (int) (tcpSpeed/1024);
//显示网速
mLoading.setVisibility(View.VISIBLE);
mLoadText.setText("网速"+speed+"kb");
}
}
/**
* 更新播放进度
*/
@Override
public void updateProgress() {
//获取当前播放的位置，毫秒
long position = mVideoPlayer.getCurrentPosition();
//获取办法给总时长，毫秒
long duration = mVideoPlayer.getDuration();
//获取视频缓冲百分比
int bufferPercentage = mVideoPlayer.getBufferPercentage();
mSeek.setSecondaryProgress(bufferPercentage);
int progress = (int) (100f * position / duration);
mSeek.setProgress(progress);
mPbPlayBar.setProgress(progress);
mPosition.setText(PlayerUtils.formatTime(position));
mDuration.setText(PlayerUtils.formatTime(duration));
// 更新时间
mTime.setText(new SimpleDateFormat("HH:mm", Locale.CHINA).format(new Date()));
long tcpSpeed = mVideoPlayer.getTcpSpeed();
VideoLogUtils.i("获取网络加载速度---------"+tcpSpeed);
}
/**
* 显示视频播放位置
* @param duration 视频总时长ms
* @param newPositionProgress 新的位置进度，取值0到100。
*/
@Override
public void showChangePosition(long duration, int newPositionProgress) {
mChangePosition.setVisibility(View.VISIBLE);
long newPosition = (long) (duration * newPositionProgress / 100f);
mChangePositionCurrent.setText(PlayerUtils.formatTime(newPosition));
mChangePositionProgress.setProgress(newPositionProgress);
mSeek.setProgress(newPositionProgress);
mPbPlayBar.setProgress(newPositionProgress);
mPosition.setText(PlayerUtils.formatTime(newPosition));
}
/**
* 隐藏视频播放位置
*/
@Override
public void hideChangePosition() {
//隐藏
mChangePosition.setVisibility(View.GONE);
}
/**
* 展示视频播放音量
* @param newVolumeProgress 新的音量进度，取值1到100。
*/
@Override
public void showChangeVolume(int newVolumeProgress) {
mChangeVolume.setVisibility(View.VISIBLE);
mChangeVolumeProgress.setProgress(newVolumeProgress);
}
/**
* 隐藏视频播放音量
*/
@Override
public void hideChangeVolume() {
mChangeVolume.setVisibility(View.GONE);
}
/**
* 展示视频播放亮度
* @param newBrightnessProgress 新的亮度进度，取值1到100。
*/
@Override
public void showChangeBrightness(int newBrightnessProgress) {
mChangeBrightness.setVisibility(View.VISIBLE);
mChangeBrightnessProgress.setProgress(newBrightnessProgress);
}
/**
* 隐藏视频播放亮度
*/
@Override
public void hideChangeBrightness() {
mChangeBrightness.setVisibility(View.GONE);
}
/**
* 设置视频分享，下载，音视频转化点击事件
*/
private OnVideoControlListener mVideoControlListener;
public void setOnVideoControlListener(OnVideoControlListener listener){
this.mVideoControlListener = listener;
}
/**
* 视频播放模式监听
*/
private OnPlayerTypeListener mOnPlayerTypeListener;
public void setOnPlayerTypeListener(OnPlayerTypeListener listener){
this.mOnPlayerTypeListener = listener;
}
/**
* 视频播放状态
*/
private OnPlayerStatesListener mOnPlayerStatesListener;
public void setOnPlayerStatesListener(OnPlayerStatesListener onPlayerStatesListener) {
this.mOnPlayerStatesListener = onPlayerStatesListener;
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/old/dialog/ChangeClarityDialog.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.video.old.dialog;
import android.app.Dialog;
import android.content.Context;
import android.view.Gravity;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.view.WindowManager;
import android.widget.LinearLayout;
import android.widget.TextView;
import com.yc.video.tool.PlayerUtils;
import com.yc.video.R;
import com.yc.video.old.listener.OnClarityChangedListener;
import java.util.List;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2018/1/29
* desc : 切换清晰度对话框（仿腾讯视频切换清晰度的对话框）
* revise:
* </pre>
*/
@Deprecated
public class ChangeClarityDialog extends Dialog {
private LinearLayout mLinearLayout;
private int mCurrentCheckedIndex;
public ChangeClarityDialog(Context context) {
super(context, R.style.dialog_change_clarity);
init(context);
}
@Override
public void onBackPressed() {
// 按返回键时回调清晰度没有变化
if (mListener != null) {
mListener.onClarityNotChanged();
}
super.onBackPressed();
}
private void init(Context context) {
mLinearLayout = new LinearLayout(context);
mLinearLayout.setGravity(Gravity.CENTER);
mLinearLayout.setOrientation(LinearLayout.VERTICAL);
mLinearLayout.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
if (mListener != null) {
mListener.onClarityNotChanged();
}
ChangeClarityDialog.this.dismiss();
}
});
ViewGroup.LayoutParams params = new ViewGroup.LayoutParams(
ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.MarginLayoutParams.MATCH_PARENT);
setContentView(mLinearLayout, params);
//注意，这里一定要判空
if(getWindow()!=null){
WindowManager.LayoutParams windowParams = getWindow().getAttributes();
windowParams.width = PlayerUtils.getScreenHeight(context);
windowParams.height = PlayerUtils.getScreenWidth(context);
getWindow().setAttributes(windowParams);
}
}
/**
* 设置清晰度等级
* @param items 清晰度等级items
* @param defaultChecked 默认选中的清晰度索引
*/
public void setClarityGrade(List<String> items, int defaultChecked) {
mCurrentCheckedIndex = defaultChecked;
for (int i = 0; i < items.size(); i++) {
TextView itemView = (TextView) LayoutInflater.from(getContext())
.inflate(R.layout.old_video_clarity, mLinearLayout, false);
itemView.setTag(i);
itemView.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
if (mListener != null) {
int checkIndex = (int) v.getTag();
if (checkIndex != mCurrentCheckedIndex) {
for (int j = 0; j < mLinearLayout.getChildCount(); j++) {
mLinearLayout.getChildAt(j).setSelected(checkIndex == j);
}
mListener.onClarityChanged(checkIndex);
mCurrentCheckedIndex = checkIndex;
} else {
mListener.onClarityNotChanged();
}
}
ChangeClarityDialog.this.dismiss();
}
});
itemView.setText(items.get(i));
itemView.setSelected(i == defaultChecked);
ViewGroup.MarginLayoutParams params = (ViewGroup.MarginLayoutParams)
itemView.getLayoutParams();
params.topMargin = (i == 0) ? 0 : PlayerUtils.dp2px(getContext(), 16f);
mLinearLayout.addView(itemView, params);
}
}
private OnClarityChangedListener mListener;
public void setOnClarityCheckedListener(OnClarityChangedListener listener) {
mListener = listener;
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/old/listener/OnClarityChangedListener.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.video.old.listener;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2017/11/21
* desc : 清晰度监听接口
* revise:
* </pre>
*/
@Deprecated
public interface OnClarityChangedListener {
/**
* 切换清晰度后回调
*
* @param clarityIndex 切换到的清晰度的索引值
*/
void onClarityChanged(int clarityIndex);
/**
* 清晰度没有切换，比如点击了空白位置，或者点击的是之前的清晰度
*/
void onClarityNotChanged();
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/old/listener/OnPlayerStatesListener.java | Java | package com.yc.video.old.listener;
import com.yc.video.config.ConstantKeys;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2018/3/9
* desc : 视频播放状态抽象接口
* revise:
* </pre>
*/
@Deprecated
public interface OnPlayerStatesListener {
/**
* 视频播放状态监听，暴露给外部开发者调用
* int COMPLETED = 101; 播放完成
* int PLAYING = 102; 正在播放
* int PAUSE = 103; 暂停状态
* int BACK_CLICK = 104; 用户点击back。当视频退出全屏或者退出小窗口后，再次点击返回键，让用户自己处理返回键事件的逻辑
* @param states 状态
*/
void onPlayerStates(@ConstantKeys.PlayerStatesType int states);
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/old/listener/OnPlayerTypeListener.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.video.old.listener;
import com.yc.video.config.ConstantKeys;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2018/3/9
* desc : 视频播放模式监听
* revise:
* </pre>
*/
@Deprecated
public interface OnPlayerTypeListener {
/**
* 视频播放模式监听
* int FULL_SCREEN = 101; 切换到全屏播放监听
* int TINY_WINDOW = 102; 切换到小窗口播放监听
* int NORMAL = 103; 切换到正常播放监听
* @param type 类型
*/
void onPlayerPattern(@ConstantKeys.PlayMode int type);
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/old/listener/OnVideoControlListener.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.video.old.listener;
import com.yc.video.config.ConstantKeys;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2017/11/9
* desc : 视频顶部点击事件
* revise:
* </pre>
*/
@Deprecated
public interface OnVideoControlListener {
/**
* 视频顶部点击事件【下载，切换音频，分享等】
* @param type 类型
* 在竖屏模式下
* 1.DOWNLOAD，下载
* 2.AUDIO，切换音频
* 3.SHARE，分享
* 4.MENU，菜单
*
* 在横屏模式下
* 5.TV，tv映射
* 6.HOR_AUDIO，音频
*/
void onVideoControlClick(@ConstantKeys.VideoControlType int type);
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/old/other/BatterReceiver.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.video.old.other;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.os.BatteryManager;
import com.yc.video.config.ConstantKeys;
import com.yc.video.old.controller.AbsVideoPlayerController;
import com.yc.video.old.player.OldVideoPlayer;
import com.yc.kernel.utils.VideoLogUtils;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2017/9/17
* desc : 电量状态监听广播
* revise:
* </pre>
*/
@Deprecated
public class BatterReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
VideoLogUtils.i("电量状态监听广播接收到数据了");
int status = intent.getIntExtra(BatteryManager.EXTRA_STATUS,
BatteryManager.BATTERY_STATUS_UNKNOWN);
OldVideoPlayer mVideoPlayer = VideoPlayerManager.instance().getCurrentVideoPlayer();
if (mVideoPlayer!=null){
AbsVideoPlayerController controller = mVideoPlayer.getController();
if (controller!=null){
if (status == BatteryManager.BATTERY_STATUS_CHARGING) {
// 充电中
controller.onBatterStateChanged(ConstantKeys.BatterMode.BATTERY_CHARGING);
} else if (status == BatteryManager.BATTERY_STATUS_FULL) {
// 充电完成
controller.onBatterStateChanged(ConstantKeys.BatterMode.BATTERY_FULL);
} else {
// 当前电量
int level = intent.getIntExtra(BatteryManager.EXTRA_LEVEL, 0);
// 总电量
int scale = intent.getIntExtra(BatteryManager.EXTRA_SCALE, 0);
int percentage = (int) (((float) level / scale) * 100);
VideoLogUtils.i("广播NetworkReceiver------当前电量"+level);
VideoLogUtils.i("广播NetworkReceiver------总电量"+scale);
VideoLogUtils.i("广播NetworkReceiver------百分比"+percentage);
if (percentage <= 10) {
controller.onBatterStateChanged(ConstantKeys.BatterMode.BATTERY_10);
} else if (percentage <= 20) {
controller.onBatterStateChanged(ConstantKeys.BatterMode.BATTERY_20);
} else if (percentage <= 50) {
controller.onBatterStateChanged(ConstantKeys.BatterMode.BATTERY_50);
} else if (percentage <= 80) {
controller.onBatterStateChanged(ConstantKeys.BatterMode.BATTERY_80);
} else if (percentage <= 100) {
controller.onBatterStateChanged(ConstantKeys.BatterMode.BATTERY_100);
}
}
}
}
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/old/other/NetChangedReceiver.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.video.old.other;
import android.annotation.SuppressLint;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import com.yc.video.config.ConstantKeys;
import com.yc.video.old.controller.AbsVideoPlayerController;
import com.yc.video.old.player.OldVideoPlayer;
import com.yc.video.tool.NetworkUtils;
import com.yc.kernel.utils.VideoLogUtils;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2019/5/21
* desc : 网络状态监听广播
* revise:
* </pre>
*/
@Deprecated
public class NetChangedReceiver extends BroadcastReceiver {
@SuppressLint("UnsafeProtectedBroadcastReceiver")
@Override
public void onReceive(Context context, Intent intent) {
VideoLogUtils.i("网络状态监听广播接收到数据了");
OldVideoPlayer mVideoPlayer = VideoPlayerManager.instance().getCurrentVideoPlayer();
if (mVideoPlayer!=null){
AbsVideoPlayerController controller = mVideoPlayer.getController();
switch (NetworkUtils.getConnectState(context)) {
case MOBILE:
VideoLogUtils.i("当网络状态监听前连接了移动数据");
break;
case WIFI:
VideoLogUtils.i("网络状态监听当前连接了Wifi");
break;
case UN_CONNECTED:
VideoLogUtils.i("网络状态监听当前没有网络连接");
if (mVideoPlayer.isPlaying() || mVideoPlayer.isBufferingPlaying()) {
VideoLogUtils.i("网络状态监听当前没有网络连接---设置暂停播放");
mVideoPlayer.pause();
}
if (controller!=null){
controller.onPlayStateChanged(ConstantKeys.CurrentState.STATE_ERROR);
}
break;
default:
VideoLogUtils.i("网络状态监听其他情况");
break;
}
}
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/old/other/VideoPlayerManager.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.video.old.other;
import com.yc.video.old.player.OldVideoPlayer;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2017/10/21
* desc : 视频播放器管理器
* revise: 将类置成final
* </pre>
*/
@Deprecated
public final class VideoPlayerManager {
private OldVideoPlayer mVideoPlayer;
/**
* 用volatile关键字修饰对象
* 为何要确保只有一个对象，为了保证任何时候有且只有一个视频播放，尤其是在列表中播放
*/
private static volatile VideoPlayerManager sInstance;
/**
* 构造方法，避免直接new
*/
private VideoPlayerManager() {
//避免初始化
}
/**
* 一定要使用单例模式，保证同一时刻只有一个视频在播放，其他的都是初始状态
* 单例模式
* @return VideoPlayerManager对象
*/
public static VideoPlayerManager instance() {
if (sInstance == null) {
synchronized (VideoPlayerManager.class){
if (sInstance == null){
sInstance = new VideoPlayerManager();
}
}
}
return sInstance;
}
/**
* 获取对象
* @return VideoPlayerManager对象
*/
public OldVideoPlayer getCurrentVideoPlayer() {
return mVideoPlayer;
}
/**
* 设置VideoPlayer
* @param videoPlayer VideoPlayerManager对象
*/
public void setCurrentVideoPlayer(OldVideoPlayer videoPlayer) {
if (mVideoPlayer != videoPlayer) {
releaseVideoPlayer();
mVideoPlayer = videoPlayer;
}
}
/**
* 当视频正在播放或者正在缓冲时，调用该方法暂停视频
*/
public void suspendVideoPlayer() {
if (mVideoPlayer != null) {
if (mVideoPlayer.isPlaying() || mVideoPlayer.isBufferingPlaying()){
mVideoPlayer.pause();
}
}
}
/**
* 当视频暂停时或者缓冲暂停时，调用该方法重新开启视频播放
*/
public void resumeVideoPlayer() {
if (mVideoPlayer != null) {
if (mVideoPlayer.isPaused() || mVideoPlayer.isBufferingPaused()){
mVideoPlayer.restart();
}
}
}
/**
* 释放，内部的播放器被释放掉，同时如果在全屏、小窗口模式下都会退出
*/
public void releaseVideoPlayer() {
if (mVideoPlayer != null) {
mVideoPlayer.release();
mVideoPlayer = null;
}
}
/**
* 处理返回键逻辑
* 如果是全屏，则退出全屏
* 如果是小窗口，则退出小窗口
*/
public boolean onBackPressed() {
if (mVideoPlayer != null) {
//如果是全屏幕，则退出全屏
if (mVideoPlayer.isFullScreen()) {
return mVideoPlayer.exitFullScreen();
} else if (mVideoPlayer.isTinyWindow()) {
//如果是小窗口播放，则退出小窗口
return mVideoPlayer.exitTinyWindow();
}
}
return false;
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/old/player/IVideoPlayer.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.video.old.player;
import java.util.Map;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2017/11/21
* desc : VideoPlayer抽象接口
* revise: 播放器基础属性获取和设置属性接口
* </pre>
*/
@Deprecated
public interface IVideoPlayer {
/**
* 设置视频Url，以及headers
*
* @param url 视频地址，可以是本地，也可以是网络视频
* @param headers 请求header.
*/
void setUp(String url, Map<String, String> headers);
/**
* 开始播放
*/
void start();
/**
* 从指定的位置开始播放
*
* @param position 播放位置
*/
void start(long position);
/**
* 重新播放，播放器被暂停、播放错误、播放完成后，需要调用此方法重新播放
*/
void restart();
/**
* 暂停播放
*/
void pause();
/**------------------以下9个方法是播放器在当前的播放状态----------------------------*/
boolean isIdle();
boolean isPreparing();
boolean isPrepared();
boolean isBufferingPlaying();
boolean isBufferingPaused();
boolean isPlaying();
boolean isPaused();
boolean isError();
boolean isCompleted();
/**
* seek到制定的位置继续播放
*
* @param pos 播放位置
*/
void seekTo(long pos);
/**
* 设置音量
*
* @param volume 音量值
*/
void setVolume(int volume);
/**
* 设置播放速度，目前只有IjkPlayer有效果，原生MediaPlayer暂不支持
*
* @param speed 播放速度
*/
void setSpeed(float speed);
/**
* 开始播放时，是否从上一次的位置继续播放
*
* @param continueFromLastPosition true 接着上次的位置继续播放，false从头开始播放
*/
void continueFromLastPosition(boolean continueFromLastPosition);
/**
* 获取最大音量
*
* @return 最大音量值
*/
int getMaxVolume();
/**
* 获取当前播放状态
*
* @return 播放状态
*/
int getPlayType();
/**
* 获取当前音量
*
* @return 当前音量值
*/
int getVolume();
/**
* 获取办法给总时长，毫秒
*
* @return 视频总时长ms
*/
long getDuration();
/**
* 获取当前播放的位置，毫秒
*
* @return 当前播放位置，ms
*/
long getCurrentPosition();
/**
* 获取视频缓冲百分比
*
* @return 缓冲白百分比
*/
int getBufferPercentage();
/**
* 获取播放速度
*
* @param speed 播放速度
* @return 播放速度
*/
float getSpeed(float speed);
/**
* 获取网络加载速度
*
* @return 网络加载速度
*/
long getTcpSpeed();
/**------------------以下3个方法是播放器的模式----------------------------*/
/**
* 是否是全屏播放
*/
boolean isFullScreen();
/**
* 是否是小窗口播放
*/
boolean isTinyWindow();
/**
* 是否是正常播放
*/
boolean isNormal();
/**------------------以下方法是切换播放器的模式----------------------------*/
/**
* 进入全屏模式
* 这个是横屏模式
*/
void enterVerticalScreenScreen();
/**
* 进入全屏模式
*/
void enterFullScreen();
/**
* 退出全屏模式
*
* @return true 退出
*/
boolean exitFullScreen();
/**
* 进入小窗口模式
*/
void enterTinyWindow();
/**
* 退出小窗口模式
*
* @return true 退出小窗口
*/
boolean exitTinyWindow();
/**------------------以下方法是销毁视频播放器资源----------------------------*/
/**
* 此处只释放播放器（如果要释放播放器并恢复控制器状态需要调用{@link #release()}方法）
* 不管是全屏、小窗口还是Normal状态下控制器的UI都不恢复初始状态
* 这样以便在当前播放器状态下可以方便的切换不同的清晰度的视频地址
*/
void releasePlayer();
/**
* 释放INiceVideoPlayer，释放后，内部的播放器被释放掉，同时如果在全屏、小窗口模式下都会退出
* 并且控制器的UI也应该恢复到最初始的状态.
*/
void release();
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/old/player/OldVideoPlayer.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.video.old.player;
import android.content.Context;
import android.content.pm.ActivityInfo;
import android.graphics.Color;
import android.media.AudioManager;
import android.media.MediaPlayer;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import android.util.AttributeSet;
import android.view.Gravity;
import android.view.KeyEvent;
import android.view.ViewGroup;
import android.widget.FrameLayout;
import com.yc.kernel.utils.VideoLogUtils;
import com.yc.video.config.ConstantKeys;
import com.yc.video.old.controller.AbsVideoPlayerController;
import com.yc.video.tool.BaseToast;
import com.yc.video.tool.PlayerUtils;
import com.yc.video.old.other.VideoPlayerManager;
import java.util.Map;
import tv.danmaku.ijk.media.player.AndroidMediaPlayer;
import tv.danmaku.ijk.media.player.IjkMediaPlayer;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2017/9/21
* desc : 播放器
* revise: 注意：在对应的播放Activity页面，清单文件中一定要添加
* android:configChanges="orientation|keyboardHidden|screenSize"
* android:screenOrientation="portrait"
* </pre>
*/
@Deprecated
public class OldVideoPlayer extends FrameLayout implements IVideoPlayer {
/**
* 播放类型
* TYPE_IJK 基于IjkPlayer封装播放器
* TYPE_NATIVE 基于原生自带的播放器控件
**/
public int mPlayerType = ConstantKeys.VideoPlayerType.TYPE_IJK;
/**
* 播放状态，错误，开始播放，暂停播放，缓存中等等状态
**/
private int mCurrentState = ConstantKeys.CurrentState.STATE_IDLE;
/**
* 播放模式，普通模式，小窗口模式，正常模式等等
* 存在局限性：比如小窗口下的正在播放模式，那么mCurrentMode就是STATE_PLAYING，而不是MODE_TINY_WINDOW并存
**/
private int mCurrentMode = ConstantKeys.PlayMode.MODE_NORMAL;
private Context mContext;
private FrameLayout mContainer;
private AbsVideoPlayerController mController;
private String mUrl;
private Map<String, String> mHeaders;
private int mBufferPercentage;
/**
* 是否从上一次位置播放，默认是false
*/
private boolean continueFromLastPosition = false;
public long skipToPosition;
private VideoMediaPlayer videoMediaPlayer;
public OldVideoPlayer(Context context) {
this(context, null);
}
public OldVideoPlayer(Context context, AttributeSet attrs) {
this(context, attrs ,0);
}
public OldVideoPlayer(@NonNull Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
mContext = context;
init();
}
/**
* 初始化
*/
private void init() {
BaseToast.init(mContext.getApplicationContext());
mContainer = new FrameLayout(mContext);
//设置背景颜色，目前设置为纯黑色
mContainer.setBackgroundColor(Color.BLACK);
LayoutParams params = new LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT,
ViewGroup.LayoutParams.MATCH_PARENT);
videoMediaPlayer = new VideoMediaPlayer(this);
//将布局添加到该视图中
this.addView(mContainer, params);
}
/**
* 如果锁屏，则屏蔽返回键，这个地方设置无效，需要在activity中设置处理返回键逻辑
* 后期找替代方案
*/
@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
VideoLogUtils.i("如果锁屏1，则屏蔽返回键onKeyDown"+event.getAction());
if(keyCode == KeyEvent.KEYCODE_BACK ){
if(mController!=null && mController.getLock()){
//如果锁屏，那就屏蔽返回键
return true;
}
}
return super.onKeyDown(keyCode, event);
}
@Override
protected void onAttachedToWindow() {
super.onAttachedToWindow();
VideoLogUtils.d("onAttachedToWindow");
//init();
//在构造函数初始化时addView
}
@Override
protected void onDetachedFromWindow() {
super.onDetachedFromWindow();
VideoLogUtils.d("onDetachedFromWindow");
if (mController!=null){
mController.destroy();
}
//onDetachedFromWindow方法是在Activity destroy的时候被调用的，也就是act对应的window被删除的时候，
//且每个view只会被调用一次，父view的调用在后，也不论view的visibility状态都会被调用，适合做最后的清理操作
//防止开发者没有在onDestroy中没有做销毁视频的优化
release();
}
/*--------------setUp为必须设置的方法，二选其一--------------------------------------*/
/**
* 设置，必须设置
* @param url 视频地址，可以是本地，也可以是网络视频
* @param headers 请求header.
*/
@Override
public final void setUp(String url, Map<String, String> headers) {
if(url==null || url.length()==0){
VideoLogUtils.d("设置参数-------设置的视频链接不能为空");
}
mUrl = url;
mHeaders = headers;
}
/**
* 设置视频控制器，必须设置
* @param controller AbsVideoPlayerController子类对象，可用VideoPlayerController，也可自定义
*/
public void setController(@NonNull AbsVideoPlayerController controller) {
//这里必须先移除
mContainer.removeView(mController);
mController = controller;
mController.reset();
mController.setVideoPlayer(this);
LayoutParams params = new LayoutParams(
ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT);
mContainer.addView(mController, params);
}
public AbsVideoPlayerController getController(){
return mController;
}
public FrameLayout getContainer() {
return mContainer;
}
public String getUrl(){
return mUrl;
}
public Map<String, String> getHeaders(){
return mHeaders;
}
/**
* 设置播放器类型，必须设置
* 注意：感谢某人建议，这里限定了传入值类型
* 输入值：ConstantKeys.IjkPlayerType.TYPE_IJK 或者 ConstantKeys.IjkPlayerType.TYPE_NATIVE
* @param playerType IjkPlayer or MediaPlayer.
*/
public void setPlayerType(@ConstantKeys.PlayerType int playerType) {
//默认是基于IjkPlayer封装播放器
mPlayerType = playerType;
}
/**
* 是否从上一次的位置继续播放，不必须
*
* @param continueFromLastPosition true从上一次的位置继续播放
*/
@Override
public void continueFromLastPosition(boolean continueFromLastPosition) {
//默认是从上一次的位置继续播放
this.continueFromLastPosition = continueFromLastPosition;
}
public boolean getContinueFromLastPosition(){
return continueFromLastPosition;
}
public long getSkipToPosition() {
return skipToPosition;
}
/**
* 注意：MediaPlayer没有这个方法
* 设置播放速度，不必须
* @param speed 播放速度
*/
@Override
public void setSpeed(float speed) {
if (speed<0){
VideoLogUtils.d("设置参数-------设置的视频播放速度不能小于0");
}
if (videoMediaPlayer.getMediaPlayer() instanceof IjkMediaPlayer) {
((IjkMediaPlayer) videoMediaPlayer.getMediaPlayer()).setSpeed(speed);
} else if (videoMediaPlayer.getMediaPlayer() instanceof AndroidMediaPlayer){
//((AndroidMediaPlayer) videoMediaPlayer.getMediaPlayer()).setSpeed(speed);
VideoLogUtils.d("设置参数-------只有IjkPlayer才能设置播放速度");
}else if(videoMediaPlayer.getMediaPlayer() instanceof MediaPlayer){
//((MediaPlayer) videoMediaPlayer.getMediaPlayer()).setSpeed(speed);
VideoLogUtils.d("设置参数-------只有IjkPlayer才能设置播放速度");
} else {
VideoLogUtils.d("设置参数-------只有IjkPlayer才能设置播放速度");
}
}
/**
* 开始播放
*/
@Override
public void start() {
if (mController==null){
//在调用start方法前，请先初始化视频控制器，调用setController方法
throw new NullPointerException("Controller must not be null , please setController first");
}
if (mCurrentState == ConstantKeys.CurrentState.STATE_IDLE) {
VideoPlayerManager.instance().setCurrentVideoPlayer(this);
videoMediaPlayer.initAudioManager();
videoMediaPlayer.initMediaPlayer();
videoMediaPlayer.initTextureView();
} else {
VideoLogUtils.d("播放状态--------VideoPlayer只有在mCurrentState == STATE_IDLE时才能调用start方法.");
}
}
/**
* 开始播放
* @param position 播放位置
*/
@Override
public void start(long position) {
if (position<0){
VideoLogUtils.d("设置参数-------设置开始播放的播放位置不能小于0");
}
skipToPosition = position;
start();
}
/**
* 重新播放
*/
@Override
public void restart() {
if (mCurrentState == ConstantKeys.CurrentState.STATE_PAUSED) {
//如果是暂停状态，那么则继续播放
videoMediaPlayer.getMediaPlayer().start();
mCurrentState = ConstantKeys.CurrentState.STATE_PLAYING;
mController.onPlayStateChanged(mCurrentState);
VideoLogUtils.d("播放状态--------STATE_PLAYING");
} else if (mCurrentState == ConstantKeys.CurrentState.STATE_BUFFERING_PAUSED) {
//如果是缓存暂停状态，那么则继续播放
videoMediaPlayer.getMediaPlayer().start();
mCurrentState = ConstantKeys.CurrentState.STATE_BUFFERING_PLAYING;
mController.onPlayStateChanged(mCurrentState);
VideoLogUtils.d("播放状态--------STATE_BUFFERING_PLAYING");
} else if (mCurrentState == ConstantKeys.CurrentState.STATE_COMPLETED
|| mCurrentState == ConstantKeys.CurrentState.STATE_ERROR) {
//如果是完成播放或者播放错误，则重新播放
videoMediaPlayer.getMediaPlayer().reset();
videoMediaPlayer.openMediaPlayer();
VideoLogUtils.d("播放状态--------完成播放或者播放错误，则重新播放");
} else {
VideoLogUtils.d("VideoPlayer在mCurrentState == " + mCurrentState + "时不能调用restart()方法.");
}
}
/**
* 暂停播放
*/
@Override
public void pause() {
if (mCurrentState == ConstantKeys.CurrentState.STATE_PLAYING) {
//如果是播放状态，那么则暂停播放
videoMediaPlayer.getMediaPlayer().pause();
mCurrentState = ConstantKeys.CurrentState.STATE_PAUSED;
mController.onPlayStateChanged(mCurrentState);
VideoLogUtils.d("播放状态--------STATE_PAUSED");
} else if (mCurrentState == ConstantKeys.CurrentState.STATE_BUFFERING_PLAYING) {
//如果是正在缓冲状态，那么则暂停暂停缓冲
videoMediaPlayer.getMediaPlayer().pause();
mCurrentState = ConstantKeys.CurrentState.STATE_BUFFERING_PAUSED;
mController.onPlayStateChanged(mCurrentState);
VideoLogUtils.d("播放状态--------STATE_BUFFERING_PAUSED");
}
}
/**
* 设置播放位置
* @param pos 播放位置
*/
@Override
public void seekTo(long pos) {
if (pos<0){
VideoLogUtils.d("设置参数-------设置开始跳转播放位置不能小于0");
}
if (videoMediaPlayer.getMediaPlayer() != null) {
videoMediaPlayer.getMediaPlayer().seekTo(pos);
}
}
/**
* 设置音量
* @param volume 音量值
*/
@Override
public void setVolume(int volume) {
if (videoMediaPlayer.getAudioManager() != null) {
videoMediaPlayer.getAudioManager().setStreamVolume(AudioManager.STREAM_MUSIC, volume, 0);
}
}
/**
* 判断是否开始播放
* @return true表示播放未开始
*/
@Override
public boolean isIdle() {
return mCurrentState == ConstantKeys.CurrentState.STATE_IDLE;
}
/**
* 判断视频是否播放准备中
* @return true表示播放准备中
*/
@Override
public boolean isPreparing() {
return mCurrentState == ConstantKeys.CurrentState.STATE_PREPARING;
}
/**
* 判断视频是否准备就绪
* @return true表示播放准备就绪
*/
@Override
public boolean isPrepared() {
return mCurrentState == ConstantKeys.CurrentState.STATE_PREPARED;
}
/**
* 判断视频是否正在缓冲(播放器正在播放时，缓冲区数据不足，进行缓冲，缓冲区数据足够后恢复播放)
* @return true表示正在缓冲
*/
@Override
public boolean isBufferingPlaying() {
return mCurrentState == ConstantKeys.CurrentState.STATE_BUFFERING_PLAYING;
}
/**
* 判断是否是否缓冲暂停
* @return true表示缓冲暂停
*/
@Override
public boolean isBufferingPaused() {
return mCurrentState == ConstantKeys.CurrentState.STATE_BUFFERING_PAUSED;
}
/**
* 判断视频是否正在播放
* @return true表示正在播放
*/
@Override
public boolean isPlaying() {
return mCurrentState == ConstantKeys.CurrentState.STATE_PLAYING;
}
/**
* 判断视频是否暂停播放
* @return true表示暂停播放
*/
@Override
public boolean isPaused() {
return mCurrentState == ConstantKeys.CurrentState.STATE_PAUSED;
}
/**
* 判断视频是否播放错误
* @return true表示播放错误
*/
@Override
public boolean isError() {
return mCurrentState == ConstantKeys.CurrentState.STATE_ERROR;
}
/**
* 判断视频是否播放完成
* @return true表示播放完成
*/
@Override
public boolean isCompleted() {
return mCurrentState == ConstantKeys.CurrentState.STATE_COMPLETED;
}
/**
* 判断视频是否播放全屏
* @return true表示播放全屏
*/
@Override
public boolean isFullScreen() {
return mCurrentMode == ConstantKeys.PlayMode.MODE_FULL_SCREEN;
}
/**
* 判断视频是否播放小窗口
* @return true表示播放小窗口
*/
@Override
public boolean isTinyWindow() {
return mCurrentMode == ConstantKeys.PlayMode.MODE_TINY_WINDOW;
}
/**
* 判断视频是否正常播放
* @return true表示正常播放
*/
@Override
public boolean isNormal() {
return mCurrentMode == ConstantKeys.PlayMode.MODE_NORMAL;
}
/**
* 获取最大音量
* @return 音量值
*/
@Override
public int getMaxVolume() {
if (videoMediaPlayer.getAudioManager() != null) {
return videoMediaPlayer.getAudioManager().getStreamMaxVolume(AudioManager.STREAM_MUSIC);
}
return 0;
}
/**
* 获取当前播放状态
*
* @return 播放状态
*/
@Override
public int getPlayType() {
return mCurrentMode;
}
/**
* 获取音量值
* @return 音量值
*/
@Override
public int getVolume() {
if (videoMediaPlayer.getAudioManager() != null) {
return videoMediaPlayer.getAudioManager().getStreamVolume(AudioManager.STREAM_MUSIC);
}
return 0;
}
/**
* 获取持续时长
* @return long时间值
*/
@Override
public long getDuration() {
return videoMediaPlayer.getMediaPlayer() != null ? videoMediaPlayer.getMediaPlayer().getDuration() : 0;
}
/**
* 获取播放位置
* @return 位置
*/
@Override
public long getCurrentPosition() {
return videoMediaPlayer.getMediaPlayer() != null ? videoMediaPlayer.getMediaPlayer().getCurrentPosition() : 0;
}
/**
* 获取缓冲区百分比
* @return 百分比
*/
@Override
public int getBufferPercentage() {
return mBufferPercentage;
}
/**
* 设置缓冲区百分比
* @param bufferPercentage
*/
public void setBufferPercentage(int bufferPercentage) {
this.mBufferPercentage = bufferPercentage;
}
/**
* 获取播放速度
* @param speed 播放速度
* @return 速度
*/
@Override
public float getSpeed(float speed) {
if (videoMediaPlayer.getMediaPlayer() instanceof IjkMediaPlayer) {
return ((IjkMediaPlayer) videoMediaPlayer.getMediaPlayer()).getSpeed(speed);
}
return 0;
}
/**
* 获取播放速度
* @return 速度
*/
@Override
public long getTcpSpeed() {
if (videoMediaPlayer.getMediaPlayer() instanceof IjkMediaPlayer) {
return ((IjkMediaPlayer) videoMediaPlayer.getMediaPlayer()).getTcpSpeed();
}
return 0;
}
/**
* 获取当前播放模式
* @return 返回当前播放模式
*/
public int getCurrentState(){
return mCurrentState;
}
/**
* 设置当前播放模式
* @param state 当前播放模式
*/
public void setCurrentState(@ConstantKeys.CurrentState int state){
mCurrentState = state;
}
/**
* 进入全屏模式
* 全屏，将mContainer(内部包含mTextureView和mController)从当前容器中移除，并添加到android.R.content中.
* 切换横屏时需要在manifest的activity标签下添加android:configChanges="orientation|keyboardHidden|screenSize"配置，
* 以避免Activity重新走生命周期
*/
@Override
public void enterFullScreen() {
if (mCurrentMode == ConstantKeys.PlayMode.MODE_FULL_SCREEN){
return;
}
// 隐藏ActionBar、状态栏，并横屏
PlayerUtils.hideActionBar(mContext);
//设置更改此页面的所需方向。如果页面当前位于前台或以其他方式影响方向
//则屏幕将立即更改(可能导致重新启动该页面)。否则，这将在下一次页面可见时使用。
PlayerUtils.scanForActivity(mContext).setRequestedOrientation(
ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
//找到contentView
ViewGroup contentView = PlayerUtils.scanForActivity(mContext)
.findViewById(android.R.id.content);
if (mCurrentMode == ConstantKeys.PlayMode.MODE_TINY_WINDOW) {
contentView.removeView(mContainer);
} else {
this.removeView(mContainer);
}
LayoutParams params = new LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT,
ViewGroup.LayoutParams.MATCH_PARENT);
contentView.addView(mContainer, params);
mCurrentMode = ConstantKeys.PlayMode.MODE_FULL_SCREEN;
mController.onPlayModeChanged(mCurrentMode);
VideoLogUtils.d("播放模式--------MODE_FULL_SCREEN");
}
/**
* 进入竖屏的全屏模式
*/
@Override
public void enterVerticalScreenScreen() {
if (mCurrentMode == ConstantKeys.PlayMode.MODE_FULL_SCREEN){
return;
}
// 隐藏ActionBar、状态栏，并横屏
PlayerUtils.hideActionBar(mContext);
PlayerUtils.scanForActivity(mContext).
setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
ViewGroup contentView = PlayerUtils.
scanForActivity(mContext).findViewById(android.R.id.content);
if (mCurrentMode == ConstantKeys.PlayMode.MODE_TINY_WINDOW) {
contentView.removeView(mContainer);
} else {
this.removeView(mContainer);
}
LayoutParams params = new LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT,
ViewGroup.LayoutParams.MATCH_PARENT);
contentView.addView(mContainer, params);
mCurrentMode = ConstantKeys.PlayMode.MODE_FULL_SCREEN;
mController.onPlayModeChanged(mCurrentMode);
VideoLogUtils.d("播放模式--------MODE_FULL_SCREEN");
}
/**
* 退出全屏模式
* 退出全屏，移除mTextureView和mController，并添加到非全屏的容器中。
* 切换竖屏时需要在manifest的activity标签下添加
* android:configChanges="orientation|keyboardHidden|screenSize"配置，
* 以避免Activity重新走生命周期.
*
* @return true退出全屏.
*/
@Override
public boolean exitFullScreen() {
if (mCurrentMode == ConstantKeys.PlayMode.MODE_FULL_SCREEN) {
PlayerUtils.showActionBar(mContext);
PlayerUtils.scanForActivity(mContext).setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
ViewGroup contentView = PlayerUtils.scanForActivity(mContext).findViewById(android.R.id.content);
//将视图移除
contentView.removeView(mContainer);
//重新添加到当前视图
LayoutParams params = new LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT);
this.addView(mContainer, params);
mCurrentMode = ConstantKeys.PlayMode.MODE_NORMAL;
mController.onPlayModeChanged(mCurrentMode);
VideoLogUtils.d("播放模式--------MODE_NORMAL");
this.setOnKeyListener(null);
return true;
}
return false;
}
/**
* 进入小窗口播放，小窗口播放的实现原理与全屏播放类似。
* 注意：小窗口播放视频比例是 16：9
*/
@Override
public void enterTinyWindow() {
//如果是小窗口模式，则不执行下面代码
if (mCurrentMode == ConstantKeys.PlayMode.MODE_TINY_WINDOW) {
return;
}
//先移除
this.removeView(mContainer);
ViewGroup contentView = PlayerUtils.scanForActivity(mContext).findViewById(android.R.id.content);
// 小窗口的宽度为屏幕宽度的60%，长宽比默认为16:9，右边距、下边距为8dp。
LayoutParams params = new LayoutParams(
(int) (PlayerUtils.getScreenWidth(mContext) * 0.6f),
(int) (PlayerUtils.getScreenWidth(mContext) * 0.6f * 9f / 16f));
params.gravity = Gravity.BOTTOM | Gravity.END;
params.rightMargin = PlayerUtils.dp2px(mContext, 8f);
params.bottomMargin = PlayerUtils.dp2px(mContext, 8f);
contentView.addView(mContainer, params);
mCurrentMode = ConstantKeys.PlayMode.MODE_TINY_WINDOW;
mController.onPlayModeChanged(mCurrentMode);
VideoLogUtils.d("播放模式-------MODE_TINY_WINDOW");
}
/**
* 退出小窗口播放
*/
@Override
public boolean exitTinyWindow() {
if (mCurrentMode == ConstantKeys.PlayMode.MODE_TINY_WINDOW) {
ViewGroup contentView = PlayerUtils.scanForActivity(mContext).findViewById(android.R.id.content);
contentView.removeView(mContainer);
LayoutParams params = new LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT);
this.addView(mContainer, params);
mCurrentMode = ConstantKeys.PlayMode.MODE_NORMAL;
mController.onPlayModeChanged(mCurrentMode);
VideoLogUtils.d("播放模式-------MODE_NORMAL");
return true;
}
return false;
}
/**
* 释放，内部的播放器被释放掉，同时如果在全屏、小窗口模式下都会退出
* 逻辑
* 1.先保存播放位置
* 2.退出全屏或小窗口，回复播放模式为正常模式
* 3.释放播放器
* 4.恢复控制器
* 5.gc回收
*/
@Override
public void release() {
// 保存播放位置，当正在播放时，缓冲时，缓冲暂停时，暂停时
if (isPlaying() || isBufferingPlaying() || isBufferingPaused() || isPaused()) {
PlayerUtils.savePlayPosition(mContext, mUrl, getCurrentPosition());
} else if (isCompleted()) {
//如果播放完成，则保存播放位置为0，也就是初始位置
PlayerUtils.savePlayPosition(mContext, mUrl, 0);
}
// 退出全屏或小窗口
if (isFullScreen()) {
exitFullScreen();
}
if (isTinyWindow()) {
exitTinyWindow();
}
mCurrentMode = ConstantKeys.PlayMode.MODE_NORMAL;
// 释放播放器
releasePlayer();
// 恢复控制器
if (mController != null) {
mController.reset();
}
// gc回收
Runtime.getRuntime().gc();
}
/**
* 释放播放器，注意一定要判断对象是否为空，增强严谨性
* 这样以便在当前播放器状态下可以方便的切换不同的清晰度的视频地址
* 关于我的github：https://github.com/yangchong211
* 杨充修改：
* 17年12月23日，添加释放音频和TextureView
*/
@Override
public void releasePlayer() {
videoMediaPlayer.setAudioManagerNull();
if (videoMediaPlayer.getMediaPlayer() != null) {
//释放视频焦点
videoMediaPlayer.getMediaPlayer().release();
videoMediaPlayer.setMediaPlayerNull();
}
if (mContainer!=null){
//从视图中移除TextureView
mContainer.removeView(videoMediaPlayer.getTextureView());
}
videoMediaPlayer.releaseSurface();
//如果SurfaceTexture不为null，则释放
videoMediaPlayer.releaseSurfaceTexture();
mCurrentState = ConstantKeys.CurrentState.STATE_IDLE;
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/old/player/VideoMediaPlayer.java | Java | package com.yc.video.old.player;
import android.content.Context;
import android.graphics.SurfaceTexture;
import android.media.AudioManager;
import android.net.Uri;
import android.os.Build;
import android.view.Surface;
import androidx.annotation.RequiresApi;
import com.yc.kernel.utils.VideoLogUtils;
import com.yc.video.config.ConstantKeys;
import com.yc.video.old.surface.VideoTextureView;
import com.yc.video.tool.BaseToast;
import com.yc.video.tool.PlayerUtils;
import java.io.IOException;
import tv.danmaku.ijk.media.player.AndroidMediaPlayer;
import tv.danmaku.ijk.media.player.IMediaPlayer;
import tv.danmaku.ijk.media.player.IjkMediaPlayer;
import tv.danmaku.ijk.media.player.IjkTimedText;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2017/11/21
* desc : MediaPlayer帮助累
* revise: 主要处理音视频player初始化操作和各种监听
* </pre>
*/
@Deprecated
public class VideoMediaPlayer {
private OldVideoPlayer videoPlayer;
private IMediaPlayer mMediaPlayer;
private AudioManager mAudioManager;
private Surface mSurface;
private VideoTextureView mTextureView;
private SurfaceTexture mSurfaceTexture;
public VideoMediaPlayer(OldVideoPlayer videoPlayer) {
this.videoPlayer = videoPlayer;
}
/**
* 避免直接初始化
*/
private VideoMediaPlayer(){}
/**
* 初始化音频管理器
*/
@RequiresApi(api = Build.VERSION_CODES.FROYO)
public AudioManager initAudioManager() {
if (mAudioManager == null) {
mAudioManager = (AudioManager) videoPlayer.getContext()
.getSystemService(Context.AUDIO_SERVICE);
mAudioManager.requestAudioFocus(null, AudioManager.STREAM_MUSIC,
AudioManager.AUDIOFOCUS_GAIN);
}
return mAudioManager;
}
public IMediaPlayer getMediaPlayer() {
initMediaPlayer();
return mMediaPlayer;
}
public void setMediaPlayerNull(){
if (mMediaPlayer!=null){
mMediaPlayer = null;
}
}
public AudioManager getAudioManager() {
initAudioManager();
return mAudioManager;
}
public void setAudioManagerNull(){
if (mAudioManager!=null){
//放弃音频焦点。使以前的焦点所有者(如果有的话)接收焦点。
mAudioManager.abandonAudioFocus(null);
//置空
mAudioManager = null;
}
}
public Surface getSurface() {
return mSurface;
}
/**
*
*/
public void releaseSurface(){
if (mSurface != null) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH) {
mSurface.release();
}
mSurface = null;
}
}
public VideoTextureView getTextureView() {
return mTextureView;
}
/**
* 如果SurfaceTexture不为null，则释放
*/
public void releaseSurfaceTexture(){
if (mSurfaceTexture != null) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH) {
mSurfaceTexture.release();
}
mSurfaceTexture = null;
}
}
/**
* 初始化视频管理器
*/
public void initMediaPlayer() {
if (mMediaPlayer == null) {
switch (videoPlayer.mPlayerType) {
//AndroidMediaPlayer和IjkMediaPlayer都是实现AbstractMediaPlayer
//MediaPlayer
case ConstantKeys.VideoPlayerType.TYPE_NATIVE:
mMediaPlayer = new AndroidMediaPlayer();
break;
//IjkMediaPlayer 基于Ijk
case ConstantKeys.VideoPlayerType.TYPE_IJK:
default:
mMediaPlayer = createIjkMediaPlayer();
break;
}
//设置音频流类型
mMediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);
}
}
/**
* 打开MediaPlayer播放器
*/
private IMediaPlayer createIjkMediaPlayer() {
//创建IjkMediaPlayer对象
mMediaPlayer = new IjkMediaPlayer();
int player = IjkMediaPlayer.OPT_CATEGORY_PLAYER;
int codec = IjkMediaPlayer.OPT_CATEGORY_CODEC;
int format = IjkMediaPlayer.OPT_CATEGORY_FORMAT;
//设置ijkPlayer播放器的硬件解码相关参数
//设置播放前的最大探测时间
((IjkMediaPlayer)mMediaPlayer).setOption(format, "analyzemaxduration", 100L);
//设置播放前的探测时间 1,达到首屏秒开效果
((IjkMediaPlayer)mMediaPlayer).setOption(format, "analyzeduration", 1L);
//播放前的探测Size，默认是1M, 改小一点会出画面更快
((IjkMediaPlayer)mMediaPlayer).setOption(format, "probesize", 10240L);
//设置是否开启变调isModifyTone?0:1
((IjkMediaPlayer)mMediaPlayer).setOption(player,"soundtouch",0);
//每处理一个packet之后刷新io上下文
((IjkMediaPlayer)mMediaPlayer).setOption(format, "flush_packets", 1L);
//是否开启预缓冲，一般直播项目会开启，达到秒开的效果，不过带来了播放丢帧卡顿的体验
((IjkMediaPlayer)mMediaPlayer).setOption(player, "packet-buffering", 0L);
//播放重连次数
((IjkMediaPlayer)mMediaPlayer).setOption(player, "reconnect", 5);
//最大缓冲大小,单位kb
((IjkMediaPlayer)mMediaPlayer).setOption(player, "max-buffer-size", 10240L);
//跳帧处理,放CPU处理较慢时，进行跳帧处理，保证播放流程，画面和声音同步
((IjkMediaPlayer)mMediaPlayer).setOption(player, "framedrop", 1L);
//最大fps
((IjkMediaPlayer)mMediaPlayer).setOption(player, "max-fps", 30L);
//SeekTo设置优化
((IjkMediaPlayer)mMediaPlayer).setOption(player, "enable-accurate-seek", 1L);
((IjkMediaPlayer)mMediaPlayer).setOption(player, "opensles", 0);
((IjkMediaPlayer)mMediaPlayer).setOption(player, "overlay-format",
IjkMediaPlayer.SDL_FCC_RV32);
((IjkMediaPlayer)mMediaPlayer).setOption(player, "framedrop", 1);
((IjkMediaPlayer)mMediaPlayer).setOption(player, "start-on-prepared", 0);
((IjkMediaPlayer)mMediaPlayer).setOption(format, "http-detect-range-support", 0);
//设置是否开启环路过滤: 0开启，画面质量高，解码开销大，48关闭，画面质量差点，解码开销小
((IjkMediaPlayer)mMediaPlayer).setOption(codec, "skip_loop_filter", 48);
//jkPlayer支持硬解码和软解码。
//软解码时不会旋转视频角度这时需要你通过onInfo的what == IMediaPlayer.MEDIA_INFO_VIDEO_ROTATION_CHANGED去获取角度，自己旋转画面。
//或者开启硬解硬解码，不过硬解码容易造成黑屏无声（硬件兼容问题），下面是设置硬解码相关的代码
((IjkMediaPlayer)mMediaPlayer).setOption(player, "mediacodec", 0);
((IjkMediaPlayer)mMediaPlayer).setOption(player, "mediacodec-auto-rotate", 1);
((IjkMediaPlayer)mMediaPlayer).setOption(player, "mediacodec-handle-resolution-change", 1);
return mMediaPlayer;
}
/**
* 打开MediaPlayer播放器
*/
@RequiresApi(api = Build.VERSION_CODES.ICE_CREAM_SANDWICH)
public void openMediaPlayer() {
// 屏幕常亮，这个很重要，如果不设置，则看视频一会儿，屏幕会变暗
videoPlayer.getContainer().setKeepScreenOn(true);
// 设置监听，可以查看ijk中的IMediaPlayer源码监听事件
// 设置准备视频播放监听事件
mMediaPlayer.setOnPreparedListener(mOnPreparedListener);
// 设置视频播放完成监听事件
mMediaPlayer.setOnCompletionListener(mOnCompletionListener);
// 设置视频缓冲更新监听事件
mMediaPlayer.setOnBufferingUpdateListener(mOnBufferingUpdateListener);
// 设置视频seek完成监听事件
mMediaPlayer.setOnSeekCompleteListener(mOnSeekCompleteListener);
// 设置视频大小更改监听器
mMediaPlayer.setOnVideoSizeChangedListener(mOnVideoSizeChangedListener);
// 设置视频错误监听器
mMediaPlayer.setOnErrorListener(mOnErrorListener);
// 设置视频信息监听器
mMediaPlayer.setOnInfoListener(mOnInfoListener);
// 设置时间文本监听器
mMediaPlayer.setOnTimedTextListener(mOnTimedTextListener);
// 设置dataSource
if(videoPlayer.getUrl()==null || videoPlayer.getUrl().length()==0){
BaseToast.showRoundRectToast("视频链接不能为空");
return;
}
Uri path = Uri.parse(videoPlayer.getUrl());
try {
mMediaPlayer.setDataSource(videoPlayer.getContext().getApplicationContext(), path, videoPlayer.getHeaders());
if (mSurface == null) {
mSurface = new Surface(mSurfaceTexture);
}
// 设置surface
mMediaPlayer.setSurface(mSurface);
// 设置播放时常亮
mMediaPlayer.setScreenOnWhilePlaying(true);
// 开始加载
mMediaPlayer.prepareAsync();
// 播放准备中
videoPlayer.setCurrentState(ConstantKeys.CurrentState.STATE_PREPARING);
// 控制器，更新不同的播放状态的UI
videoPlayer.getController().onPlayStateChanged(videoPlayer.getCurrentState());
VideoLogUtils.d("STATE_PREPARING");
} catch (IOException e) {
e.printStackTrace();
VideoLogUtils.e("打开播放器发生错误", e);
}
}
/**
* 初始化TextureView
* 这个主要是用作视频的
*/
@RequiresApi(api = Build.VERSION_CODES.ICE_CREAM_SANDWICH)
public void initTextureView() {
if (mTextureView == null) {
mTextureView = new VideoTextureView(videoPlayer.getContext());
mTextureView.setOnTextureListener(new VideoTextureView.OnTextureListener() {
@Override
public void onSurfaceAvailable(SurfaceTexture surface) {
if (mSurfaceTexture == null) {
mSurfaceTexture = surface;
openMediaPlayer();
} else {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
mTextureView.setSurfaceTexture(mSurfaceTexture);
}
}
}
@Override
public void onSurfaceSizeChanged(SurfaceTexture surface, int width, int height) {
VideoLogUtils.i("OnTextureListener----"+"onSurfaceSizeChanged");
}
@Override
public boolean onSurfaceDestroyed(SurfaceTexture surface) {
VideoLogUtils.i("OnTextureListener----"+"onSurfaceDestroyed");
return mSurfaceTexture == null;
}
@Override
public void onSurfaceUpdated(SurfaceTexture surface) {
VideoLogUtils.i("OnTextureListener----"+"onSurfaceUpdated");
}
});
}
mTextureView.addTextureView(videoPlayer.getContainer(),mTextureView);
}
/**
* 设置视频播放完成监听事件
*/
private IMediaPlayer.OnCompletionListener mOnCompletionListener =
new IMediaPlayer.OnCompletionListener() {
@Override
public void onCompletion(IMediaPlayer mp) {
videoPlayer.setCurrentState(ConstantKeys.CurrentState.STATE_COMPLETED);
videoPlayer.getController().onPlayStateChanged(videoPlayer.getCurrentState());
VideoLogUtils.d("listener---------onCompletion ——> STATE_COMPLETED");
// 清除屏幕常亮
videoPlayer.getContainer().setKeepScreenOn(false);
}
};
/**
* 设置准备视频播放监听事件
*/
private IMediaPlayer.OnPreparedListener mOnPreparedListener = new IMediaPlayer.OnPreparedListener() {
@Override
public void onPrepared(IMediaPlayer mp) {
videoPlayer.setCurrentState(ConstantKeys.CurrentState.STATE_PREPARED);
videoPlayer.getController().onPlayStateChanged(videoPlayer.getCurrentState());
VideoLogUtils.d("listener---------onPrepared ——> STATE_PREPARED");
mp.start();
// 从上次的保存位置播放
if (videoPlayer.getContinueFromLastPosition()) {
long savedPlayPosition = PlayerUtils.getSavedPlayPosition(
videoPlayer.getContext(), videoPlayer.getUrl());
mp.seekTo(savedPlayPosition);
}
// 跳到指定位置播放
if (videoPlayer.getSkipToPosition() != 0) {
mp.seekTo(videoPlayer.getSkipToPosition());
}
}
};
/**
* 设置视频缓冲更新监听事件
*/
private IMediaPlayer.OnBufferingUpdateListener mOnBufferingUpdateListener =
new IMediaPlayer.OnBufferingUpdateListener() {
final int MAX_PERCENT = 97;
@Override
public void onBufferingUpdate(IMediaPlayer mp, int percent) {
videoPlayer.setBufferPercentage(percent);
//播放完成后再次播放getBufferPercentage获取的值也不准确，94、95，达不到100
if (percent>MAX_PERCENT){
videoPlayer.setBufferPercentage(100);
}
VideoLogUtils.d("listener---------onBufferingUpdate ——> " + percent);
}
};
/**
* 设置视频seek完成监听事件
*/
private IMediaPlayer.OnSeekCompleteListener mOnSeekCompleteListener =
new IMediaPlayer.OnSeekCompleteListener() {
@Override
public void onSeekComplete(IMediaPlayer iMediaPlayer) {
}
};
/**
* 设置视频大小更改监听器
*/
private IMediaPlayer.OnVideoSizeChangedListener mOnVideoSizeChangedListener =
new IMediaPlayer.OnVideoSizeChangedListener() {
@Override
public void onVideoSizeChanged(IMediaPlayer mp, int width, int height,
int sar_num, int sar_den) {
mTextureView.adaptVideoSize(width, height);
VideoLogUtils.d("listener---------onVideoSizeChanged ——> WIDTH：" + width + "， HEIGHT：" + height);
}
};
/**
* 设置视频错误监听器
* int MEDIA_INFO_VIDEO_RENDERING_START = 3;//视频准备渲染
* int MEDIA_INFO_BUFFERING_START = 701;//开始缓冲
* int MEDIA_INFO_BUFFERING_END = 702;//缓冲结束
* int MEDIA_INFO_VIDEO_ROTATION_CHANGED = 10001;//视频选择信息
* int MEDIA_ERROR_SERVER_DIED = 100;//视频中断，一般是视频源异常或者不支持的视频类型。
* int MEDIA_ERROR_IJK_PLAYER = -10000,//一般是视频源有问题或者数据格式不支持，比如音频不是AAC之类的
* int MEDIA_ERROR_NOT_VALID_FOR_PROGRESSIVE_PLAYBACK = 200;//数据错误没有有效的回收
*/
private IMediaPlayer.OnErrorListener mOnErrorListener = new IMediaPlayer.OnErrorListener() {
@Override
public boolean onError(IMediaPlayer mp, int what, int extra) {
// 直播流播放时去调用mediaPlayer.getDuration会导致-38和-2147483648错误，忽略该错误
if (what != -38 && what != -2147483648 && extra != -38 && extra != -2147483648) {
videoPlayer.setCurrentState(ConstantKeys.CurrentState.STATE_ERROR);
videoPlayer.getController().onPlayStateChanged(videoPlayer.getCurrentState());
}
VideoLogUtils.d("listener---------onError ——> STATE_ERROR ———— what：" + what + ", extra: " + extra);
return true;
}
};
/**
* 设置视频信息监听器
*/
private IMediaPlayer.OnInfoListener mOnInfoListener = new IMediaPlayer.OnInfoListener() {
@Override
public boolean onInfo(IMediaPlayer mp, int what, int extra) {
if (what == IMediaPlayer.MEDIA_INFO_VIDEO_RENDERING_START) {
// 播放器开始渲染
videoPlayer.setCurrentState(ConstantKeys.CurrentState.STATE_PLAYING);
videoPlayer.getController().onPlayStateChanged(videoPlayer.getCurrentState());
VideoLogUtils.d("listener---------onInfo ——> MEDIA_INFO_VIDEO_RENDERING_START：STATE_PLAYING");
} else if (what == IMediaPlayer.MEDIA_INFO_BUFFERING_START) {
// MediaPlayer暂时不播放，以缓冲更多的数据
if (videoPlayer.getCurrentState() == ConstantKeys.CurrentState.STATE_PAUSED ||
videoPlayer.getCurrentState() == ConstantKeys.CurrentState.STATE_BUFFERING_PAUSED) {
videoPlayer.setCurrentState(ConstantKeys.CurrentState.STATE_BUFFERING_PAUSED);
VideoLogUtils.d("listener---------onInfo ——> MEDIA_INFO_BUFFERING_START：STATE_BUFFERING_PAUSED");
} else {
videoPlayer.setCurrentState(ConstantKeys.CurrentState.STATE_BUFFERING_PLAYING);
VideoLogUtils.d("listener---------onInfo ——> MEDIA_INFO_BUFFERING_START：STATE_BUFFERING_PLAYING");
}
videoPlayer.getController().onPlayStateChanged(videoPlayer.getCurrentState());
} else if (what == IMediaPlayer.MEDIA_INFO_BUFFERING_END) {
// 填充缓冲区后，MediaPlayer恢复播放/暂停
if (videoPlayer.getCurrentState() == ConstantKeys.CurrentState.STATE_BUFFERING_PLAYING) {
videoPlayer.setCurrentState(ConstantKeys.CurrentState.STATE_PLAYING);
videoPlayer.getController().onPlayStateChanged(videoPlayer.getCurrentState());
VideoLogUtils.d("listener---------onInfo ——> MEDIA_INFO_BUFFERING_END： STATE_PLAYING");
}
if (videoPlayer.getCurrentState() == ConstantKeys.CurrentState.STATE_BUFFERING_PAUSED) {
videoPlayer.setCurrentState(ConstantKeys.CurrentState.STATE_PAUSED);
videoPlayer.getController().onPlayStateChanged(videoPlayer.getCurrentState());
VideoLogUtils.d("listener---------onInfo ——> MEDIA_INFO_BUFFERING_END： STATE_PAUSED");
}
} else if (what == IMediaPlayer.MEDIA_INFO_VIDEO_ROTATION_CHANGED) {
// 视频旋转了extra度，需要恢复
if (mTextureView != null) {
mTextureView.setRotation(extra);
VideoLogUtils.d("listener---------视频旋转角度：" + extra);
}
} else if (what == IMediaPlayer.MEDIA_INFO_NOT_SEEKABLE) {
VideoLogUtils.d("listener---------视频不能seekTo，为直播视频");
} else {
VideoLogUtils.d("listener---------onInfo ——> what：" + what);
}
return true;
}
};
/**
* 设置时间文本监听器
*/
private IMediaPlayer.OnTimedTextListener mOnTimedTextListener = new
IMediaPlayer.OnTimedTextListener() {
@Override
public void onTimedText(IMediaPlayer iMediaPlayer, IjkTimedText ijkTimedText) {
}
};
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/old/surface/VideoSurfaceView.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.video.old.surface;
import android.content.Context;
import android.view.Gravity;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import android.view.ViewGroup;
import android.widget.FrameLayout;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2018/9/21
* desc : 重写SurfaceView，适配视频的宽高和旋转
* revise:
* </pre>
*/
@Deprecated
public class VideoSurfaceView extends SurfaceView{
/**
* 优点：可以在一个独立的线程中进行绘制，不会影响主线程；使用双缓冲机制，播放视频时画面更流畅
* 缺点：Surface不在View hierachy中，它的显示也不受View的属性控制，所以不能进行平移，缩放等变换，
* 也不能放在其它ViewGroup中。SurfaceView 不能嵌套使用。
*/
private int videoHeight;
private int videoWidth;
private OnSurfaceListener onSurfaceListener;
private static final float EQUAL_FLOAT = 0.0000001f;
public VideoSurfaceView(Context context) {
super(context);
}
@Override
protected void onDetachedFromWindow() {
super.onDetachedFromWindow();
if (callback!=null){
getHolder().removeCallback(callback);
}
}
private SurfaceHolder.Callback callback = new SurfaceHolder.Callback(){
/**
* 创建的时候调用该方法
* @param holder holder
*/
@Override
public void surfaceCreated(SurfaceHolder holder) {
if (onSurfaceListener!=null){
onSurfaceListener.surfaceCreated(holder);
}
}
/**
* 视图改变的时候调用方法
* @param holder
* @param format
* @param width
* @param height
*/
@Override
public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
if (onSurfaceListener!=null){
onSurfaceListener.surfaceChanged(holder, format, width, height);
}
}
/**
* 销毁的时候调用该方法
* @param holder
*/
@Override
public void surfaceDestroyed(SurfaceHolder holder) {
if (onSurfaceListener!=null){
onSurfaceListener.surfaceDestroyed(holder);
}
}
};
/**
* 获取listener
* @return onSurfaceListener
*/
public OnSurfaceListener getOnSurfaceListener() {
return onSurfaceListener;
}
/**
* 设置监听
* @param surfaceListener onSurfaceListener
*/
public void setOnSurfaceListener(OnSurfaceListener surfaceListener) {
this.onSurfaceListener = surfaceListener;
getHolder().addCallback(callback);
}
/**
* 添加TextureView到视图中
* @param frameLayout 布局
* @param videoSurfaceView videoSurfaceView
*/
public void addTextureView(FrameLayout frameLayout , VideoSurfaceView videoSurfaceView){
frameLayout.removeView(videoSurfaceView);
FrameLayout.LayoutParams params = new FrameLayout.LayoutParams(
ViewGroup.LayoutParams.MATCH_PARENT,
ViewGroup.LayoutParams.MATCH_PARENT, Gravity.CENTER);
frameLayout.addView(videoSurfaceView, 0, params);
}
/**
* 自定义video大小
* @param videoWidth 宽
* @param videoHeight 高
*/
public void adaptVideoSize(int videoWidth, int videoHeight) {
if (this.videoWidth != videoWidth && this.videoHeight != videoHeight) {
this.videoWidth = videoWidth;
this.videoHeight = videoHeight;
requestLayout();
}
}
/**
* 记得一定要重新写这个方法，如果角度发生了变化，就重新绘制布局
* 设置视频旋转角度
* @param rotation 角度
*/
@Override
public void setRotation(float rotation) {
if (rotation != getRotation()) {
super.setRotation(rotation);
requestLayout();
}
}
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
// 获取视图旋转的角度
float viewRotation = getRotation();
// 如果判断成立，则说明显示的TextureView和本身的位置是有90度的旋转的，所以需要交换宽高参数。
float viewRotation1 = 90f;
float viewRotation2 = 270f;
//如果是横竖屏旋转切换视图，则宽高属性互换
if (Math.abs(viewRotation-viewRotation1)> EQUAL_FLOAT && Math.abs(viewRotation1-viewRotation)> EQUAL_FLOAT ||
(Math.abs(viewRotation-viewRotation2)> EQUAL_FLOAT && Math.abs(viewRotation2-viewRotation)> EQUAL_FLOAT)){
int tempMeasureSpec = widthMeasureSpec;
//noinspection SuspiciousNameCombination
widthMeasureSpec = heightMeasureSpec;
heightMeasureSpec = tempMeasureSpec;
}
/*if (viewRotation == viewRotation1 || viewRotation == viewRotation2) {
int tempMeasureSpec = widthMeasureSpec;
//noinspection SuspiciousNameCombination
widthMeasureSpec = heightMeasureSpec;
heightMeasureSpec = tempMeasureSpec;
}*/
int width = getDefaultSize(videoWidth, widthMeasureSpec);
int height = getDefaultSize(videoHeight, heightMeasureSpec);
if (videoWidth > 0 && videoHeight > 0) {
int widthSpecMode = MeasureSpec.getMode(widthMeasureSpec);
int widthSpecSize = MeasureSpec.getSize(widthMeasureSpec);
int heightSpecMode = MeasureSpec.getMode(heightMeasureSpec);
int heightSpecSize = MeasureSpec.getSize(heightMeasureSpec);
if (widthSpecMode == MeasureSpec.EXACTLY && heightSpecMode == MeasureSpec.EXACTLY) {
// the size is fixed
width = widthSpecSize;
height = heightSpecSize;
// for compatibility, we adjust size based on aspect ratio
if (videoWidth * height < width * videoHeight) {
width = height * videoWidth / videoHeight;
} else if (videoWidth * height > width * videoHeight) {
height = width * videoHeight / videoWidth;
}
} else if (widthSpecMode == MeasureSpec.EXACTLY) {
// only the WIDTH is fixed, adjust the HEIGHT to match aspect ratio if possible
width = widthSpecSize;
height = width * videoHeight / videoWidth;
if (heightSpecMode == MeasureSpec.AT_MOST && height > heightSpecSize) {
// couldn't match aspect ratio within the constraints
height = heightSpecSize;
width = height * videoWidth / videoHeight;
}
} else if (heightSpecMode == MeasureSpec.EXACTLY) {
// only the HEIGHT is fixed, adjust the WIDTH to match aspect ratio if possible
height = heightSpecSize;
width = height * videoWidth / videoHeight;
if (widthSpecMode == MeasureSpec.AT_MOST && width > widthSpecSize) {
// couldn't match aspect ratio within the constraints
width = widthSpecSize;
height = width * videoHeight / videoWidth;
}
} else {
// neither the WIDTH nor the HEIGHT are fixed, try to use actual video size
width = videoWidth;
height = videoHeight;
if (heightSpecMode == MeasureSpec.AT_MOST && height > heightSpecSize) {
// too tall, decrease both WIDTH and HEIGHT
height = heightSpecSize;
width = height * videoWidth / videoHeight;
}
if (widthSpecMode == MeasureSpec.AT_MOST && width > widthSpecSize) {
// too wide, decrease both WIDTH and HEIGHT
width = widthSpecSize;
height = width * videoHeight / videoWidth;
}
}
} else {
// no size yet, just adopt the given spec sizes
}
setMeasuredDimension(width, height);
}
public interface OnSurfaceListener {
void surfaceCreated(SurfaceHolder holder);
void surfaceChanged(SurfaceHolder holder, int format, int width, int height);
void surfaceDestroyed(SurfaceHolder holder);
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/old/surface/VideoTextureView.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.video.old.surface;
import android.annotation.SuppressLint;
import android.content.Context;
import android.graphics.SurfaceTexture;
import android.view.Gravity;
import android.view.TextureView;
import android.view.ViewGroup;
import android.widget.FrameLayout;
import com.yc.kernel.utils.VideoLogUtils;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2017/10/21
* desc : 重写TextureView，适配视频的宽高和旋转
* revise:
* </pre>
*/
@Deprecated
@SuppressLint("NewApi")
public class VideoTextureView extends TextureView implements TextureView.SurfaceTextureListener {
/**
* 优点：支持移动、旋转、缩放等动画，支持截图。具有view的属性
* 缺点：必须在硬件加速的窗口中使用，占用内存比SurfaceView高，在5.0以前在主线程渲染，5.0以后有单独的渲染线程。
*/
private int videoHeight;
private int videoWidth;
private OnTextureListener onTextureListener;
private static final float EQUAL_FLOAT = 0.0000001f;
public VideoTextureView(Context context) {
super(context);
}
/**
* SurfaceTexture准备就绪
* @param surface surface
* @param width WIDTH
* @param height HEIGHT
*/
@Override
public void onSurfaceTextureAvailable(SurfaceTexture surface, int width, int height) {
if (onTextureListener != null) {
onTextureListener.onSurfaceAvailable(surface);
}
}
/**
* SurfaceTexture缓冲大小变化
* @param surface surface
* @param width WIDTH
* @param height HEIGHT
*/
@Override
public void onSurfaceTextureSizeChanged(SurfaceTexture surface, int width, int height) {
if (onTextureListener != null) {
onTextureListener.onSurfaceSizeChanged(surface, width, height);
}
}
/**
* SurfaceTexture即将被销毁
* @param surface surface
*/
@Override
public boolean onSurfaceTextureDestroyed(SurfaceTexture surface) {
//清空释放
if (onTextureListener != null) {
onTextureListener.onSurfaceDestroyed(surface);
}
return false;
}
/**
* SurfaceTexture通过updateImage更新
* @param surface surface
*/
@Override
public void onSurfaceTextureUpdated(SurfaceTexture surface) {
//如果播放的是暂停全屏了
if (onTextureListener != null) {
onTextureListener.onSurfaceUpdated(surface);
}
}
/**
* 获取listener
* @return onTextureListener
*/
public OnTextureListener getonTextureListener() {
return onTextureListener;
}
/**
* 设置监听
* @param surfaceListener onTextureListener
*/
public void setOnTextureListener(OnTextureListener surfaceListener) {
setSurfaceTextureListener(this);
onTextureListener = surfaceListener;
}
/**
* 添加TextureView到视图中
* @param frameLayout 布局
* @param textureView textureView
*/
public void addTextureView(FrameLayout frameLayout , VideoTextureView textureView){
frameLayout.removeView(textureView);
FrameLayout.LayoutParams params = new FrameLayout.LayoutParams(
ViewGroup.LayoutParams.MATCH_PARENT,
ViewGroup.LayoutParams.MATCH_PARENT, Gravity.CENTER);
frameLayout.addView(textureView, 0, params);
}
/**
* 自定义video大小
* @param videoWidth 宽
* @param videoHeight 高
*/
public void adaptVideoSize(int videoWidth, int videoHeight) {
if (this.videoWidth != videoWidth && this.videoHeight != videoHeight) {
this.videoWidth = videoWidth;
this.videoHeight = videoHeight;
requestLayout();
}
}
/**
* 记得一定要重新写这个方法，如果角度发生了变化，就重新绘制布局
* 设置视频旋转角度
* @param rotation 角度
*/
@Override
public void setRotation(float rotation) {
if (rotation != getRotation()) {
super.setRotation(rotation);
requestLayout();
}
}
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
// 获取视图旋转的角度
float viewRotation = getRotation();
// 如果判断成立，则说明显示的TextureView和本身的位置是有90度的旋转的，所以需要交换宽高参数。
float viewRotation1 = 90f;
float viewRotation2 = 270f;
//如果是横竖屏旋转切换视图，则宽高属性互换
if (Math.abs(viewRotation-viewRotation1)> EQUAL_FLOAT && Math.abs(viewRotation1-viewRotation)> EQUAL_FLOAT ||
(Math.abs(viewRotation-viewRotation2)> EQUAL_FLOAT && Math.abs(viewRotation2-viewRotation)> EQUAL_FLOAT)){
int tempMeasureSpec = widthMeasureSpec;
//noinspection SuspiciousNameCombination
widthMeasureSpec = heightMeasureSpec;
heightMeasureSpec = tempMeasureSpec;
VideoLogUtils.d("TextureView---------"+"如果是横竖屏旋转切换视图，则宽高属性互换");
}
/*if (viewRotation == viewRotation1 || viewRotation == viewRotation2) {
int tempMeasureSpec = widthMeasureSpec;
//noinspection SuspiciousNameCombination
widthMeasureSpec = heightMeasureSpec;
heightMeasureSpec = tempMeasureSpec;
}*/
int width = getDefaultSize(videoWidth, widthMeasureSpec);
int height = getDefaultSize(videoHeight, heightMeasureSpec);
if (videoWidth > 0 && videoHeight > 0) {
int widthSpecMode = MeasureSpec.getMode(widthMeasureSpec);
int widthSpecSize = MeasureSpec.getSize(widthMeasureSpec);
int heightSpecMode = MeasureSpec.getMode(heightMeasureSpec);
int heightSpecSize = MeasureSpec.getSize(heightMeasureSpec);
if (widthSpecMode == MeasureSpec.EXACTLY && heightSpecMode == MeasureSpec.EXACTLY) {
// the size is fixed
width = widthSpecSize;
height = heightSpecSize;
// for compatibility, we adjust size based on aspect ratio
if (videoWidth * height < width * videoHeight) {
width = height * videoWidth / videoHeight;
} else if (videoWidth * height > width * videoHeight) {
height = width * videoHeight / videoWidth;
}
} else if (widthSpecMode == MeasureSpec.EXACTLY) {
// only the WIDTH is fixed, adjust the HEIGHT to match aspect ratio if possible
width = widthSpecSize;
height = width * videoHeight / videoWidth;
if (heightSpecMode == MeasureSpec.AT_MOST && height > heightSpecSize) {
// couldn't match aspect ratio within the constraints
height = heightSpecSize;
width = height * videoWidth / videoHeight;
}
} else if (heightSpecMode == MeasureSpec.EXACTLY) {
// only the HEIGHT is fixed, adjust the WIDTH to match aspect ratio if possible
height = heightSpecSize;
width = height * videoWidth / videoHeight;
if (widthSpecMode == MeasureSpec.AT_MOST && width > widthSpecSize) {
// couldn't match aspect ratio within the constraints
width = widthSpecSize;
height = width * videoHeight / videoWidth;
}
} else {
// neither the WIDTH nor the HEIGHT are fixed, try to use actual video size
width = videoWidth;
height = videoHeight;
if (heightSpecMode == MeasureSpec.AT_MOST && height > heightSpecSize) {
// too tall, decrease both WIDTH and HEIGHT
height = heightSpecSize;
width = height * videoWidth / videoHeight;
}
if (widthSpecMode == MeasureSpec.AT_MOST && width > widthSpecSize) {
// too wide, decrease both WIDTH and HEIGHT
width = widthSpecSize;
height = width * videoHeight / videoWidth;
}
}
} // no size yet, just adopt the given spec sizes
setMeasuredDimension(width, height);
}
public interface OnTextureListener {
/**
* SurfaceTexture准备就绪
* @param surface surface
*/
void onSurfaceAvailable(SurfaceTexture surface);
/**
* SurfaceTexture缓冲大小变化
* @param surface surface
* @param width WIDTH
* @param height HEIGHT
*/
void onSurfaceSizeChanged(SurfaceTexture surface, int width, int height);
/**
* SurfaceTexture即将被销毁
* @param surface surface
* @return 销毁
*/
boolean onSurfaceDestroyed(SurfaceTexture surface);
/**
* SurfaceTexture通过updateImage更新
* @param surface surface
*/
void onSurfaceUpdated(SurfaceTexture surface);
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/player/AudioFocusHelper.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.video.player;
import android.content.Context;
import android.media.AudioManager;
import android.os.Handler;
import android.os.Looper;
import androidx.annotation.NonNull;
import java.lang.ref.WeakReference;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2018/11/9
* desc : 音频焦点改变监听
* revise:
* </pre>
*/
public final class AudioFocusHelper implements AudioManager.OnAudioFocusChangeListener {
private Handler mHandler = new Handler(Looper.getMainLooper());
private WeakReference<VideoPlayer> mWeakVideoView;
private AudioManager mAudioManager;
private boolean mStartRequested = false;
private boolean mPausedForLoss = false;
private int mCurrentFocus = 0;
public AudioFocusHelper(@NonNull VideoPlayer videoView) {
mWeakVideoView = new WeakReference<>(videoView);
mAudioManager = (AudioManager) videoView.getContext().getApplicationContext()
.getSystemService(Context.AUDIO_SERVICE);
}
@Override
public void onAudioFocusChange(final int focusChange) {
if (mCurrentFocus == focusChange) {
return;
}
//由于onAudioFocusChange有可能在子线程调用，
//故通过此方式切换到主线程去执行
mHandler.post(new Runnable() {
@Override
public void run() {
//处理音频焦点抢占
handleAudioFocusChange(focusChange);
}
});
mCurrentFocus = focusChange;
}
private void handleAudioFocusChange(int focusChange) {
final VideoPlayer videoView = mWeakVideoView.get();
if (videoView == null) {
return;
}
switch (focusChange) {
case AudioManager.AUDIOFOCUS_GAIN:
//重新获得焦点
case AudioManager.AUDIOFOCUS_GAIN_TRANSIENT:
//暂时获得焦点
if (mStartRequested || mPausedForLoss) {
videoView.start();
mStartRequested = false;
mPausedForLoss = false;
}
if (!videoView.isMute())
//恢复音量
videoView.setVolume(1.0f, 1.0f);
break;
case AudioManager.AUDIOFOCUS_LOSS:
//焦点丢失，这个是永久丢失焦点，如被其他播放器抢占
case AudioManager.AUDIOFOCUS_LOSS_TRANSIENT:
//焦点暂时丢失，，如来电
if (videoView.isPlaying()) {
mPausedForLoss = true;
videoView.pause();
}
break;
case AudioManager.AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK:
//此时需降低音量，瞬间丢失焦点，如通知
if (videoView.isPlaying() && !videoView.isMute()) {
videoView.setVolume(0.1f, 0.1f);
}
break;
}
}
/**
* 请求获取音频焦点
*/
public void requestFocus() {
if (mCurrentFocus == AudioManager.AUDIOFOCUS_GAIN) {
//如果已经是获得焦点，则直接返回
return;
}
if (mAudioManager == null) {
return;
}
//请求重新获取焦点
int status = mAudioManager.requestAudioFocus(this,
AudioManager.STREAM_MUSIC, AudioManager.AUDIOFOCUS_GAIN);
//焦点更改请求成功
if (AudioManager.AUDIOFOCUS_REQUEST_GRANTED == status) {
mCurrentFocus = AudioManager.AUDIOFOCUS_GAIN;
return;
}
mStartRequested = true;
}
/**
* 请求系统放下音频焦点
*/
public void abandonFocus() {
if (mAudioManager == null) {
return;
}
mStartRequested = false;
mAudioManager.abandonAudioFocus(this);
}
/**
* 销毁资源
*/
public void release(){
abandonFocus();
if (mHandler!=null){
mHandler.removeCallbacksAndMessages(null);
mHandler = null;
}
}
} | yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/player/InterVideoPlayer.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.
*/
/*
Copyright 2017 yangchong211（github.com/yangchong211）
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package com.yc.video.player;
import android.graphics.Bitmap;
import com.yc.video.config.ConstantKeys;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2017/11/21
* desc : VideoPlayer抽象接口
* revise: 播放器基础属性获取和设置属性接口
* </pre>
*/
public interface InterVideoPlayer {
/**
* 设置链接
* @param url url
*/
void setUrl(String url);
/**
* 获取播放链接
* @return 链接
*/
String getUrl();
/**
* 开始播放
*/
void start();
/**
* 暂停播放
*/
void pause();
/**
* 获取视频总时长
* @return long类型
*/
long getDuration();
/**
* 获取当前播放的位置
* @return long类型
*/
long getCurrentPosition();
/**
* 调整播放进度
* @param pos 位置
*/
void seekTo(long pos);
/**
* 是否处于播放状态
* @return 是否处于播放状态
*/
boolean isPlaying();
/**
* 获取当前缓冲百分比
* @return 百分比
*/
int getBufferedPercentage();
void startFullScreen();
void stopFullScreen();
boolean isFullScreen();
void setMute(boolean isMute);
boolean isMute();
void setScreenScaleType(@ConstantKeys.ScreenScaleType int screenScaleType);
void setSpeed(float speed);
float getSpeed();
long getTcpSpeed();
void replay(boolean resetPosition);
void setMirrorRotation(boolean enable);
Bitmap doScreenShot();
int[] getVideoSize();
void setRotation(float rotation);
void startTinyScreen();
void stopTinyScreen();
boolean isTinyScreen();
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/player/OnVideoStateListener.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.video.player;
import com.yc.video.config.ConstantKeys;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2017/11/9
* desc : 视频播放器状态监听
* revise:
* </pre>
*/
public interface OnVideoStateListener {
/**
* 播放模式
* 普通模式，小窗口模式，正常模式三种其中一种
* MODE_NORMAL 普通模式
* MODE_FULL_SCREEN 全屏模式
* MODE_TINY_WINDOW 小屏模式
* @param playerState 播放模式
*/
void onPlayerStateChanged(@ConstantKeys.PlayModeType int playerState);
/**
* 播放状态
* -1 播放错误
* 0 播放未开始
* 1 播放准备中
* 2 播放准备就绪
* 3 正在播放
* 4 暂停播放
* 5 正在缓冲(播放器正在播放时，缓冲区数据不足，进行缓冲，缓冲区数据足够后恢复播放)
* 6 暂停缓冲(播放器正在播放时，缓冲区数据不足，进行缓冲，此时暂停播放器，继续缓冲，缓冲区数据足够后恢复暂停
* 7 播放完成
* 8 开始播放中止
* @param playState 播放状态，主要是指播放器的各种状态
*/
void onPlayStateChanged(@ConstantKeys.CurrentStateType int playState);
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/player/ProgressManager.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.video.player;
/**
* 播放进度管理器，继承此接口实现自己的进度管理器。
*/
public abstract class ProgressManager {
/**
* 此方法用于实现保存进度的逻辑
* @param url 播放地址
* @param progress 播放进度
*/
public abstract void saveProgress(String url, long progress);
/**
* 此方法用于实现获取保存的进度的逻辑
* @param url 播放地址
* @return 保存的播放进度
*/
public abstract long getSavedProgress(String url);
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/player/SimpleStateListener.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.video.player;
import com.yc.video.config.ConstantKeys;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2017/11/21
* desc : 播放器监听实现类
* revise: 空实现。用的时候只需要重写需要的方法
* </pre>
*/
public class SimpleStateListener implements OnVideoStateListener {
/**
* 播放模式
* 普通模式，小窗口模式，正常模式三种其中一种
* MODE_NORMAL 普通模式
* MODE_FULL_SCREEN 全屏模式
* MODE_TINY_WINDOW 小屏模式
* @param playerState 播放模式
*/
@Override
public void onPlayerStateChanged(@ConstantKeys.PlayModeType int playerState) {
}
/**
* 播放状态
* -1 播放错误
* 0 播放未开始
* 1 播放准备中
* 2 播放准备就绪
* 3 正在播放
* 4 暂停播放
* 5 正在缓冲(播放器正在播放时，缓冲区数据不足，进行缓冲，缓冲区数据足够后恢复播放)
* 6 暂停缓冲(播放器正在播放时，缓冲区数据不足，进行缓冲，此时暂停播放器，继续缓冲，缓冲区数据足够后恢复暂停
* 7 播放完成
* 8 开始播放中止
* @param playState 播放状态，主要是指播放器的各种状态
*/
@Override
public void onPlayStateChanged(int playState) {
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/player/VideoPlayer.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.video.player;
import android.content.Context;
import android.content.res.AssetFileDescriptor;
import android.content.res.TypedArray;
import android.graphics.Bitmap;
import android.graphics.Color;
import android.os.Parcelable;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import android.text.TextUtils;
import android.util.AttributeSet;
import android.view.Gravity;
import android.view.ViewGroup;
import android.widget.FrameLayout;
import com.yc.video.R;
import com.yc.video.config.ConstantKeys;
import com.yc.video.config.VideoPlayerConfig;
import com.yc.video.controller.BaseVideoController;
import com.yc.kernel.inter.AbstractVideoPlayer;
import com.yc.kernel.factory.PlayerFactory;
import com.yc.video.surface.InterSurfaceView;
import com.yc.video.surface.SurfaceFactory;
import com.yc.video.tool.BaseToast;
import com.yc.video.tool.PlayerUtils;
import com.yc.video.tool.VideoException;
import com.yc.kernel.inter.VideoPlayerListener;
import com.yc.kernel.utils.PlayerConstant;
import com.yc.kernel.utils.VideoLogUtils;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2018/11/9
* desc : 播放器具体实现类
* revise:
* </pre>
*/
public class VideoPlayer<P extends AbstractVideoPlayer> extends FrameLayout
implements InterVideoPlayer, VideoPlayerListener {
private Context mContext;
/**
* 播放器
*/
protected P mMediaPlayer;
/**
* 实例化播放核心
*/
protected PlayerFactory<P> mPlayerFactory;
/**
* 控制器
*/
@Nullable
protected BaseVideoController mVideoController;
/**
* 真正承载播放器视图的容器
*/
protected FrameLayout mPlayerContainer;
protected InterSurfaceView mRenderView;
protected SurfaceFactory mRenderViewFactory;
protected int mCurrentScreenScaleType;
protected int[] mVideoSize = {0, 0};
/**
* 是否静音
*/
protected boolean mIsMute;
/**
* 当前播放视频的地址
*/
protected String mUrl;
/**
* 当前视频地址的请求头
*/
protected Map<String, String> mHeaders;
/**
* assets文件
*/
protected AssetFileDescriptor mAssetFileDescriptor;
/**
* 当前正在播放视频的位置
*/
protected long mCurrentPosition;
/**
* 当前播放器的状态
* 比如：错误，开始播放，暂停播放，缓存中等等状态
*/
protected int mCurrentPlayState = ConstantKeys.CurrentState.STATE_IDLE;
/**
* 播放模式，普通模式，小窗口模式，正常模式等等
* 存在局限性：比如小窗口下的正在播放模式，那么mCurrentMode就是STATE_PLAYING，而不是MODE_TINY_WINDOW并存
**/
protected int mCurrentPlayerState = ConstantKeys.PlayMode.MODE_NORMAL;
/**
* 是否处于全屏状态
*/
protected boolean mIsFullScreen;
/**
* 是否处于小屏状态
*/
protected boolean mIsTinyScreen;
protected int[] mTinyScreenSize = {0, 0};
/**
* 监听系统中音频焦点改变
*/
protected boolean mEnableAudioFocus;
@Nullable
protected AudioFocusHelper mAudioFocusHelper;
/**
* OnStateChangeListener集合，保存了所有开发者设置的监听器
*/
protected List<OnVideoStateListener> mOnStateChangeListeners;
/**
* 进度管理器，设置之后播放器会记录播放进度，以便下次播放恢复进度
*/
@Nullable
protected ProgressManager mProgressManager;
/**
* 循环播放
*/
protected boolean mIsLooping;
/**
* {@link #mPlayerContainer}背景色，默认黑色
*/
private int mPlayerBackgroundColor;
public VideoPlayer(@NonNull Context context) {
this(context, null);
}
public VideoPlayer(@NonNull Context context, @Nullable AttributeSet attrs) {
this(context, attrs, 0);
}
public VideoPlayer(@NonNull Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
mContext = context;
init(attrs);
}
private void init(AttributeSet attrs) {
BaseToast.init(mContext.getApplicationContext());
//读取全局配置
initConfig();
//读取xml中的配置，并综合全局配置
initAttrs(attrs);
initView();
}
private void initConfig() {
VideoPlayerConfig config = VideoViewManager.getConfig();
mEnableAudioFocus = config.mEnableAudioFocus;
mProgressManager = config.mProgressManager;
mPlayerFactory = config.mPlayerFactory;
mCurrentScreenScaleType = config.mScreenScaleType;
mRenderViewFactory = config.mRenderViewFactory;
//设置是否打印日志
VideoLogUtils.setIsLog(config.mIsEnableLog);
}
/**
* onAttachedToWindow方法
* 是在Activity resume的时候被调用的，也就是activity对应的window被添加的时候，且每个view只会被调用一次，
* 父view的调用在前，不论view的visibility状态都会被调用，适合做些view特定的初始化操作；
*
* 主要做什么：适合初始化操作
*
* 代码流程：
* ActivityThread.handleResumeActivity()--->WindowManager.addView()--->WindowManagerImpl.addView()
* -->WindowManagerGlobal.addView()--->root.setView(view, wparams, panelParentView)
* --->host.dispatchAttachedToWindow()[具体代码在ViewRootImpl类中]
*/
@Override
protected void onAttachedToWindow() {
super.onAttachedToWindow();
VideoLogUtils.d("onAttachedToWindow");
//init();
//在构造函数初始化时addView
}
/**
* onDetachedFromWindow方法
* 是在Activity destroy的时候被调用的，也就是activity对应的window被删除的时候，且每个view只会被调用一次，
* 父view的调用在后，也不论view的visibility状态都会被调用，适合做最后的清理操作；
*
* 主要做什么：适合销毁清理操作
*
* 代码流程：
* ActivityThread.handleDestroyActivity() --> WindowManager.removeViewImmediate() -->
* WindowManagerGlobal.removeViewLocked()方法 —> ViewRootImpl.die() --> doDie() -->
* ViewRootImpl.dispatchDetachedFromWindow()
*/
@Override
protected void onDetachedFromWindow() {
super.onDetachedFromWindow();
VideoLogUtils.d("onDetachedFromWindow");
if (mVideoController!=null){
mVideoController.destroy();
}
//onDetachedFromWindow方法是在Activity destroy的时候被调用的，也就是act对应的window被删除的时候，
//且每个view只会被调用一次，父view的调用在后，也不论view的visibility状态都会被调用，适合做最后的清理操作
//防止开发者没有在onDestroy中没有做销毁视频的优化
release();
}
/**
* View所在窗口获取焦点或者失去焦点时调用
* @param hasWindowFocus 是否获取window焦点
*/
@Override
public void onWindowFocusChanged(boolean hasWindowFocus) {
super.onWindowFocusChanged(hasWindowFocus);
if (hasWindowFocus && mIsFullScreen) {
//重新获得焦点时保持全屏状态
ViewGroup decorView = VideoPlayerHelper.instance().getDecorView(mContext, mVideoController);
VideoPlayerHelper.instance().hideSysBar(decorView,mContext,mVideoController);
}
}
/**
* View在xml文件里加载完成时调用
*/
@Override
protected void onFinishInflate() {
super.onFinishInflate();
}
/**
* 意外销毁保存数据调用
* @return 返回Parcelable对象
*/
@Override
protected Parcelable onSaveInstanceState() {
VideoLogUtils.d("onSaveInstanceState: " + mCurrentPosition);
//activity切到后台后可能被系统回收，故在此处进行进度保存
saveProgress();
return super.onSaveInstanceState();
}
private void initAttrs(AttributeSet attrs) {
TypedArray a = mContext.obtainStyledAttributes(attrs, R.styleable.VideoPlayer);
mEnableAudioFocus = a.getBoolean(R.styleable.VideoPlayer_enableAudioFocus, mEnableAudioFocus);
mIsLooping = a.getBoolean(R.styleable.VideoPlayer_looping, false);
mCurrentScreenScaleType = a.getInt(R.styleable.VideoPlayer_screenScaleType, mCurrentScreenScaleType);
mPlayerBackgroundColor = a.getColor(R.styleable.VideoPlayer_playerBackgroundColor, Color.BLACK);
a.recycle();
}
/**
* 初始化播放器视图
*/
protected void initView() {
mPlayerContainer = new FrameLayout(getContext());
//设置背景颜色，目前设置为纯黑色
mPlayerContainer.setBackgroundColor(mPlayerBackgroundColor);
LayoutParams params = new LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT,
ViewGroup.LayoutParams.MATCH_PARENT);
//将布局添加到该视图中
this.addView(mPlayerContainer, params);
}
/**
* 设置控制器，传null表示移除控制器
* @param mediaController controller
*/
public void setController(@Nullable BaseVideoController mediaController) {
mPlayerContainer.removeView(mVideoController);
mVideoController = mediaController;
if (mediaController != null) {
mediaController.setMediaPlayer(this);
LayoutParams params = new LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT,
ViewGroup.LayoutParams.MATCH_PARENT);
mPlayerContainer.addView(mVideoController, params);
}
}
/**
* 开始播放，注意：调用此方法后必须调用{@link #release()}释放播放器，否则会导致内存泄漏
*/
@Override
public void start() {
if (mVideoController==null){
//在调用start方法前，请先初始化视频控制器，调用setController方法
throw new VideoException(VideoException.CODE_NOT_SET_CONTROLLER,
"Controller must not be null , please setController first");
}
boolean isStarted = false;
if (isInIdleState() || isInStartAbortState()) {
isStarted = startPlay();
} else if (isInPlaybackState()) {
startInPlaybackState();
isStarted = true;
}
if (isStarted) {
mPlayerContainer.setKeepScreenOn(true);
if (mAudioFocusHelper != null){
mAudioFocusHelper.requestFocus();
}
}
}
/**
* 第一次播放
* @return 是否成功开始播放
*/
protected boolean startPlay() {
//如果要显示移动网络提示则不继续播放
if (showNetWarning()) {
//中止播放
setPlayState(ConstantKeys.CurrentState.STATE_START_ABORT);
return false;
}
//监听音频焦点改变
if (mEnableAudioFocus) {
mAudioFocusHelper = new AudioFocusHelper(this);
}
//读取播放进度
if (mProgressManager != null) {
mCurrentPosition = mProgressManager.getSavedProgress(mUrl);
}
initPlayer();
addDisplay();
startPrepare(false);
return true;
}
/**
* 初始化播放器
*/
protected void initPlayer() {
//通过工厂模式创建对象
mMediaPlayer = mPlayerFactory.createPlayer(mContext);
mMediaPlayer.setPlayerEventListener(this);
setInitOptions();
mMediaPlayer.initPlayer();
setOptions();
}
/**
* 是否显示移动网络提示，可在Controller中配置
*/
protected boolean showNetWarning() {
//播放本地数据源时不检测网络
if (VideoPlayerHelper.instance().isLocalDataSource(mUrl,mAssetFileDescriptor)){
return false;
}
return mVideoController != null && mVideoController.showNetWarning();
}
/**
* 初始化之前的配置项
*/
protected void setInitOptions() {
}
/**
* 初始化之后的配置项
*/
protected void setOptions() {
//设置是否循环播放
mMediaPlayer.setLooping(mIsLooping);
}
/**
* 初始化视频渲染View
*/
protected void addDisplay() {
if (mRenderView != null) {
//从容器中移除渲染view
mPlayerContainer.removeView(mRenderView.getView());
//释放资源
mRenderView.release();
}
//创建TextureView对象
mRenderView = mRenderViewFactory.createRenderView(mContext);
//绑定mMediaPlayer对象
mRenderView.attachToPlayer(mMediaPlayer);
//添加渲染view到Container布局中
LayoutParams params = new LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT,
ViewGroup.LayoutParams.MATCH_PARENT, Gravity.CENTER);
mPlayerContainer.addView(mRenderView.getView(), 0, params);
}
/**
* 开始准备播放（直接播放）
*/
protected void startPrepare(boolean reset) {
if (reset) {
mMediaPlayer.reset();
//重新设置option，media player reset之后，option会失效
setOptions();
}
//播放数据是否设置成功
if (prepareDataSource()) {
//准备开始播放
mMediaPlayer.prepareAsync();
//更改播放器的播放状态
setPlayState(ConstantKeys.CurrentState.STATE_PREPARING);
//更改播放器播放模式状态
setPlayerState(isFullScreen() ? ConstantKeys.PlayMode.MODE_FULL_SCREEN :
isTinyScreen() ? ConstantKeys.PlayMode.MODE_TINY_WINDOW : ConstantKeys.PlayMode.MODE_NORMAL);
}
}
/**
* 设置播放数据
* @return 播放数据是否设置成功
*/
protected boolean prepareDataSource() {
if (mAssetFileDescriptor != null) {
mMediaPlayer.setDataSource(mAssetFileDescriptor);
return true;
} else if (!TextUtils.isEmpty(mUrl)) {
mMediaPlayer.setDataSource(mUrl, mHeaders);
return true;
}
return false;
}
/**
* 播放状态下开始播放
*/
protected void startInPlaybackState() {
mMediaPlayer.start();
setPlayState(ConstantKeys.CurrentState.STATE_PLAYING);
}
/**
* 暂停播放
*/
@Override
public void pause() {
if (isInPlaybackState() && mMediaPlayer.isPlaying()) {
mMediaPlayer.pause();
setPlayState(ConstantKeys.CurrentState.STATE_PAUSED);
if (mAudioFocusHelper != null) {
mAudioFocusHelper.abandonFocus();
}
mPlayerContainer.setKeepScreenOn(false);
}
}
/**
* 继续播放
*/
public void resume() {
if (isInPlaybackState() && !mMediaPlayer.isPlaying()) {
mMediaPlayer.start();
setPlayState(ConstantKeys.CurrentState.STATE_PLAYING);
if (mAudioFocusHelper != null) {
mAudioFocusHelper.requestFocus();
}
mPlayerContainer.setKeepScreenOn(true);
}
}
/**
* 释放播放器
*/
public void release() {
if (!isInIdleState()) {
VideoPlayerConfig config = VideoViewManager.getConfig();
if (config!=null && config.mBuriedPointEvent!=null){
//退出视频播放
config.mBuriedPointEvent.playerDestroy(mUrl);
//计算退出视频时候的进度
long duration = getDuration();
long currentPosition = getCurrentPosition();
float progress = (currentPosition*1.0f) / (duration*1.0f) ;
config.mBuriedPointEvent.playerOutProgress(mUrl,progress);
config.mBuriedPointEvent.playerOutProgress(mUrl,duration,mCurrentPosition);
}
//释放播放器
if (mMediaPlayer != null) {
mMediaPlayer.release();
mMediaPlayer = null;
}
//释放renderView
if (mRenderView != null) {
mPlayerContainer.removeView(mRenderView.getView());
mRenderView.release();
mRenderView = null;
}
//释放Assets资源
if (mAssetFileDescriptor != null) {
try {
mAssetFileDescriptor.close();
} catch (IOException e) {
e.printStackTrace();
}
}
//关闭AudioFocus监听
if (mAudioFocusHelper != null) {
mAudioFocusHelper.abandonFocus();
mAudioFocusHelper.release();
mAudioFocusHelper = null;
}
//关闭屏幕常亮
mPlayerContainer.setKeepScreenOn(false);
//保存播放进度
saveProgress();
//重置播放进度
mCurrentPosition = 0;
//切换转态
setPlayState(ConstantKeys.CurrentState.STATE_IDLE);
}
}
/**
* 保存播放进度
*/
protected void saveProgress() {
if (mProgressManager != null && mCurrentPosition > 0) {
VideoLogUtils.d("saveProgress: " + mCurrentPosition);
mProgressManager.saveProgress(mUrl, mCurrentPosition);
}
}
/**
* 是否处于播放状态
*/
protected boolean isInPlaybackState() {
return mMediaPlayer != null
&& mCurrentPlayState != ConstantKeys.CurrentState.STATE_ERROR
&& mCurrentPlayState != ConstantKeys.CurrentState.STATE_IDLE
&& mCurrentPlayState != ConstantKeys.CurrentState.STATE_PREPARING
&& mCurrentPlayState != ConstantKeys.CurrentState.STATE_START_ABORT
&& mCurrentPlayState != ConstantKeys.CurrentState.STATE_BUFFERING_PLAYING;
}
/**
* 是否处于未播放状态
*/
protected boolean isInIdleState() {
return mCurrentPlayState == ConstantKeys.CurrentState.STATE_IDLE;
}
/**
* 播放中止状态
*/
private boolean isInStartAbortState() {
return mCurrentPlayState == ConstantKeys.CurrentState.STATE_START_ABORT;
}
/**
* 重新播放
*
* @param resetPosition 是否从头开始播放
*/
@Override
public void replay(boolean resetPosition) {
if (resetPosition) {
mCurrentPosition = 0;
}
addDisplay();
startPrepare(true);
mPlayerContainer.setKeepScreenOn(true);
}
/**
* 获取视频总时长
*/
@Override
public long getDuration() {
if (isInPlaybackState()) {
return mMediaPlayer.getDuration();
}
return 0;
}
/**
* 获取当前播放的位置
*/
@Override
public long getCurrentPosition() {
if (isInPlaybackState()) {
mCurrentPosition = mMediaPlayer.getCurrentPosition();
return mCurrentPosition;
}
return 0;
}
/**
* 调整播放进度
*/
@Override
public void seekTo(long pos) {
long seek;
if (pos<0){
VideoLogUtils.d("设置参数-------设置开始跳转播放位置不能小于0");
seek = 0;
} else {
seek = pos;
}
if (isInPlaybackState()) {
mMediaPlayer.seekTo(seek);
}
}
/**
* 是否处于播放状态
*/
@Override
public boolean isPlaying() {
return isInPlaybackState() && mMediaPlayer.isPlaying();
}
/**
* 获取当前缓冲百分比
*/
@Override
public int getBufferedPercentage() {
return mMediaPlayer != null ? mMediaPlayer.getBufferedPercentage() : 0;
}
/**
* 设置静音
*/
@Override
public void setMute(boolean isMute) {
if (mMediaPlayer != null) {
this.mIsMute = isMute;
float volume = isMute ? 0.0f : 1.0f;
mMediaPlayer.setVolume(volume, volume);
}
}
/**
* 是否处于静音状态
*/
@Override
public boolean isMute() {
return mIsMute;
}
/**
* 视频播放出错回调
*/
@Override
public void onError(@PlayerConstant.ErrorType int type , String error) {
mPlayerContainer.setKeepScreenOn(false);
if (PlayerUtils.isConnected(mContext)){
if (type == PlayerConstant.ErrorType.TYPE_UNEXPECTED){
setPlayState(ConstantKeys.CurrentState.STATE_ERROR);
} else if (type == PlayerConstant.ErrorType.TYPE_PARSE){
setPlayState(ConstantKeys.CurrentState.STATE_PARSE_ERROR);
} else if (type == PlayerConstant.ErrorType.TYPE_SOURCE){
setPlayState(ConstantKeys.CurrentState.STATE_ERROR);
} else {
setPlayState(ConstantKeys.CurrentState.STATE_ERROR);
}
} else {
setPlayState(ConstantKeys.CurrentState.STATE_NETWORK_ERROR);
}
setPlayState(ConstantKeys.CurrentState.STATE_ERROR);
VideoPlayerConfig config = VideoViewManager.getConfig();
if (config!=null && config.mBuriedPointEvent!=null){
//相当于进入了视频页面
if (PlayerUtils.isConnected(mContext)){
config.mBuriedPointEvent.onError(mUrl,false);
} else {
config.mBuriedPointEvent.onError(mUrl,true);
}
}
}
/**
* 视频播放完成回调
*/
@Override
public void onCompletion() {
mPlayerContainer.setKeepScreenOn(false);
mCurrentPosition = 0;
if (mProgressManager != null) {
//播放完成，清除进度
mProgressManager.saveProgress(mUrl, 0);
}
setPlayState(ConstantKeys.CurrentState.STATE_BUFFERING_PLAYING);
VideoPlayerConfig config = VideoViewManager.getConfig();
if (config!=null && config.mBuriedPointEvent!=null){
//视频播放完成
config.mBuriedPointEvent.playerCompletion(mUrl);
}
}
@Override
public void onInfo(int what, int extra) {
switch (what) {
case PlayerConstant.MEDIA_INFO_BUFFERING_START:
setPlayState(ConstantKeys.CurrentState.STATE_BUFFERING_PAUSED);
break;
case PlayerConstant.MEDIA_INFO_BUFFERING_END:
setPlayState(ConstantKeys.CurrentState.STATE_COMPLETED);
break;
case PlayerConstant.MEDIA_INFO_VIDEO_RENDERING_START: // 视频开始渲染
setPlayState(ConstantKeys.CurrentState.STATE_PLAYING);
if (mPlayerContainer.getWindowVisibility() != VISIBLE) {
pause();
}
break;
case PlayerConstant.MEDIA_INFO_VIDEO_ROTATION_CHANGED:
if (mRenderView != null)
mRenderView.setVideoRotation(extra);
break;
}
}
/**
* 视频缓冲完毕，准备开始播放时回调
*/
@Override
public void onPrepared() {
setPlayState(ConstantKeys.CurrentState.STATE_PREPARED);
if (mCurrentPosition > 0) {
seekTo(mCurrentPosition);
}
}
/**
* 获取当前播放器的状态
*/
public int getCurrentPlayerState() {
return mCurrentPlayerState;
}
/**
* 获取当前的播放状态
*/
public int getCurrentPlayState() {
return mCurrentPlayState;
}
/**
* 获取缓冲速度
*/
@Override
public long getTcpSpeed() {
return mMediaPlayer != null ? mMediaPlayer.getTcpSpeed() : 0;
}
/**
* 设置播放速度
*/
@Override
public void setSpeed(float speed) {
if (isInPlaybackState()) {
mMediaPlayer.setSpeed(speed);
}
}
/**
* 获取倍速速度
* @return 速度
*/
@Override
public float getSpeed() {
if (isInPlaybackState()) {
return mMediaPlayer.getSpeed();
}
return 1f;
}
/**
* 设置视频地址
*/
@Override
public void setUrl(String url) {
setUrl(url, null);
}
/**
* 获取视频地址
* @return
*/
@Override
public String getUrl(){
return this.mUrl;
}
/**
* 设置包含请求头信息的视频地址
*
* @param url 视频地址
* @param headers 请求头
*/
public void setUrl(String url, Map<String, String> headers) {
mAssetFileDescriptor = null;
mUrl = url;
mHeaders = headers;
VideoPlayerConfig config = VideoViewManager.getConfig();
if (config!=null && config.mBuriedPointEvent!=null){
//相当于进入了视频页面
config.mBuriedPointEvent.playerIn(url);
}
}
/**
* 用于播放assets里面的视频文件
*/
public void setAssetFileDescriptor(AssetFileDescriptor fd) {
mUrl = null;
this.mAssetFileDescriptor = fd;
}
/**
* 设置音量 0.0f-1.0f 之间
*
* @param v1 左声道音量
* @param v2 右声道音量
*/
public void setVolume(float v1, float v2) {
if (mMediaPlayer != null) {
mMediaPlayer.setVolume(v1, v2);
}
}
/**
* 设置进度管理器，用于保存播放进度
*/
public void setProgressManager(@Nullable ProgressManager progressManager) {
this.mProgressManager = progressManager;
}
/**
* 循环播放， 默认不循环播放
*/
public void setLooping(boolean looping) {
mIsLooping = looping;
if (mMediaPlayer != null) {
mMediaPlayer.setLooping(looping);
}
}
/**
* 自定义播放核心，继承{@link PlayerFactory}实现自己的播放核心
*/
public void setPlayerFactory(PlayerFactory<P> playerFactory) {
if (playerFactory == null) {
throw new VideoException(VideoException.CODE_NOT_PLAYER_FACTORY,"PlayerFactory can not be null!");
}
mPlayerFactory = playerFactory;
}
/**
* 自定义RenderView，继承{@link SurfaceFactory}实现自己的RenderView
*/
public void setRenderViewFactory(SurfaceFactory renderViewFactory) {
if (renderViewFactory == null) {
throw new VideoException(VideoException.CODE_NOT_RENDER_FACTORY,"RenderViewFactory can not be null!");
}
mRenderViewFactory = renderViewFactory;
}
/**
* 进入全屏
*/
@Override
public void startFullScreen() {
if (mIsFullScreen){
return;
}
ViewGroup decorView = VideoPlayerHelper.instance().getDecorView(mContext,mVideoController);
if (decorView == null){
return;
}
mIsFullScreen = true;
//隐藏NavigationBar和StatusBar
VideoPlayerHelper.instance().hideSysBar(decorView,mContext,mVideoController);
//从当前FrameLayout中移除播放器视图
this.removeView(mPlayerContainer);
//将播放器视图添加到DecorView中即实现了全屏
decorView.addView(mPlayerContainer);
setPlayerState(ConstantKeys.PlayMode.MODE_FULL_SCREEN);
}
/**
* 退出全屏
*/
@Override
public void stopFullScreen() {
if (!mIsFullScreen){
return;
}
ViewGroup decorView = VideoPlayerHelper.instance().getDecorView(mContext,mVideoController);
if (decorView == null){
return;
}
mIsFullScreen = false;
//显示NavigationBar和StatusBar
VideoPlayerHelper.instance().showSysBar(decorView,mContext,mVideoController);
//把播放器视图从DecorView中移除并添加到当前FrameLayout中即退出了全屏
decorView.removeView(mPlayerContainer);
this.addView(mPlayerContainer);
setPlayerState(ConstantKeys.PlayMode.MODE_NORMAL);
}
/**
* 判断是否处于全屏状态
*/
@Override
public boolean isFullScreen() {
return mIsFullScreen;
}
/**
* 开启小屏
*/
public void startTinyScreen() {
if (mIsTinyScreen) {
return;
}
ViewGroup contentView = VideoPlayerHelper.instance().getContentView(mContext,mVideoController);
if (contentView == null) {
return;
}
this.removeView(mPlayerContainer);
int width = mTinyScreenSize[0];
if (width <= 0) {
width = PlayerUtils.getScreenWidth(getContext(), false) / 2;
}
int height = mTinyScreenSize[1];
if (height <= 0) {
height = width * 9 / 16;
}
LayoutParams params = new LayoutParams(width, height);
params.gravity = Gravity.BOTTOM | Gravity.END;
contentView.addView(mPlayerContainer, params);
mIsTinyScreen = true;
setPlayerState(ConstantKeys.PlayMode.MODE_TINY_WINDOW);
}
/**
* 退出小屏
*/
public void stopTinyScreen() {
if (!mIsTinyScreen) {
return;
}
ViewGroup contentView = VideoPlayerHelper.instance().getContentView(mContext,mVideoController);
if (contentView == null) {
return;
}
contentView.removeView(mPlayerContainer);
LayoutParams params = new LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT);
this.addView(mPlayerContainer, params);
mIsTinyScreen = false;
setPlayerState(ConstantKeys.PlayMode.MODE_NORMAL);
}
/**
* 是否是小窗口模式
* @return 是否是小窗口模式
*/
public boolean isTinyScreen() {
return mIsTinyScreen;
}
@Override
public void onVideoSizeChanged(int videoWidth, int videoHeight) {
mVideoSize[0] = videoWidth;
mVideoSize[1] = videoHeight;
if (mRenderView != null) {
mRenderView.setScaleType(mCurrentScreenScaleType);
mRenderView.setVideoSize(videoWidth, videoHeight);
}
}
/**
* 设置视频比例
*/
@Override
public void setScreenScaleType(@ConstantKeys.ScreenScaleType int screenScaleType) {
mCurrentScreenScaleType = screenScaleType;
if (mRenderView != null) {
mRenderView.setScaleType(screenScaleType);
}
}
/**
* 设置镜像旋转，暂不支持SurfaceView
*/
@Override
public void setMirrorRotation(boolean enable) {
if (mRenderView != null) {
mRenderView.getView().setScaleX(enable ? -1 : 1);
}
}
/**
* 截图，暂不支持SurfaceView
*/
@Override
public Bitmap doScreenShot() {
if (mRenderView != null) {
return mRenderView.doScreenShot();
}
return null;
}
/**
* 获取视频宽高,其中width: mVideoSize[0], height: mVideoSize[1]
*/
@Override
public int[] getVideoSize() {
return mVideoSize;
}
/**
* 旋转视频画面
*
* @param rotation 角度
*/
@Override
public void setRotation(float rotation) {
if (mRenderView != null) {
mRenderView.setVideoRotation((int) rotation);
}
}
/**
* 向Controller设置播放状态，用于控制Controller的ui展示
* 这里使用注解限定符，不要使用1，2这种直观数字，不方便知道意思
* 播放状态，主要是指播放器的各种状态
* -1 播放错误
* 0 播放未开始
* 1 播放准备中
* 2 播放准备就绪
* 3 正在播放
* 4 暂停播放
* 5 正在缓冲(播放器正在播放时，缓冲区数据不足，进行缓冲，缓冲区数据足够后恢复播放)
* 6 暂停缓冲(播放器正在播放时，缓冲区数据不足，进行缓冲，此时暂停播放器，继续缓冲，缓冲区数据足够后恢复暂停
* 7 播放完成
* 8 开始播放中止
*/
protected void setPlayState(@ConstantKeys.CurrentStateType int playState) {
mCurrentPlayState = playState;
if (mVideoController != null) {
mVideoController.setPlayState(playState);
}
if (mOnStateChangeListeners != null) {
for (OnVideoStateListener l : PlayerUtils.getSnapshot(mOnStateChangeListeners)) {
if (l != null) {
l.onPlayStateChanged(playState);
}
}
}
}
/**
* 向Controller设置播放器状态，包含全屏状态和非全屏状态
* 播放模式
* 普通模式，小窗口模式，正常模式三种其中一种
* MODE_NORMAL 普通模式
* MODE_FULL_SCREEN 全屏模式
* MODE_TINY_WINDOW 小屏模式
*/
protected void setPlayerState(@ConstantKeys.PlayModeType int playerState) {
mCurrentPlayerState = playerState;
if (mVideoController != null) {
mVideoController.setPlayerState(playerState);
}
if (mOnStateChangeListeners != null) {
for (OnVideoStateListener l : PlayerUtils.getSnapshot(mOnStateChangeListeners)) {
if (l != null) {
l.onPlayerStateChanged(playerState);
}
}
}
}
/**
* 添加一个播放状态监听器，播放状态发生变化时将会调用。
*/
public void addOnStateChangeListener(@NonNull OnVideoStateListener listener) {
if (mOnStateChangeListeners == null) {
mOnStateChangeListeners = new ArrayList<>();
}
mOnStateChangeListeners.add(listener);
}
/**
* 移除某个播放状态监听
*/
public void removeOnStateChangeListener(@NonNull OnVideoStateListener listener) {
if (mOnStateChangeListeners != null) {
mOnStateChangeListeners.remove(listener);
}
}
/**
* 设置一个播放状态监听器，播放状态发生变化时将会调用，
* 如果你想同时设置多个监听器，推荐 {@link #addOnStateChangeListener(OnVideoStateListener)}。
*/
public void setOnStateChangeListener(@NonNull OnVideoStateListener listener) {
if (mOnStateChangeListeners == null) {
mOnStateChangeListeners = new ArrayList<>();
} else {
mOnStateChangeListeners.clear();
}
mOnStateChangeListeners.add(listener);
}
/**
* 移除所有播放状态监听
*/
public void clearOnStateChangeListeners() {
if (mOnStateChangeListeners != null) {
mOnStateChangeListeners.clear();
}
}
/**
* 改变返回键逻辑，用于activity
*/
public boolean onBackPressed() {
return mVideoController != null && mVideoController.onBackPressed();
}
/*-----------------------------暴露api方法--------------------------------------**/
/*-----------------------------暴露api方法--------------------------------------**/
public void setVideoBuilder(VideoPlayerBuilder videoBuilder){
if (mPlayerContainer==null || videoBuilder==null){
return;
}
//设置视频播放器的背景色
mPlayerContainer.setBackgroundColor(videoBuilder.mColor);
//设置小屏的宽高
if (videoBuilder.mTinyScreenSize!=null && videoBuilder.mTinyScreenSize.length>0){
mTinyScreenSize = videoBuilder.mTinyScreenSize;
}
//一开始播放就seek到预先设置好的位置
if (videoBuilder.mCurrentPosition>0){
this.mCurrentPosition = videoBuilder.mCurrentPosition;
}
//是否开启AudioFocus监听， 默认开启
this.mEnableAudioFocus = videoBuilder.mEnableAudioFocus;
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/player/VideoPlayerBuilder.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.video.player;
import android.graphics.Color;
import androidx.annotation.ColorInt;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2018/11/9
* desc : 播放器设置属性builder类
* revise:
* </pre>
*/
public class VideoPlayerBuilder {
public static Builder newBuilder() {
return new Builder();
}
public final static class Builder {
private int mColor = 0;
private int[] mTinyScreenSize;
private int mCurrentPosition = -1;
private boolean mEnableAudioFocus = true;
/**
* 设置视频播放器的背景色
* @param color color
* @return Builder
*/
public Builder setPlayerBackgroundColor(@ColorInt int color) {
//使用注解限定福
if (color==0){
this.mColor = Color.BLACK;
} else {
this.mColor = color;
}
return this;
}
/**
* 设置小屏的宽高
* @param tinyScreenSize 其中tinyScreenSize[0]是宽，tinyScreenSize[1]是高
* @return Builder
*/
public Builder setTinyScreenSize(int[] tinyScreenSize) {
this.mTinyScreenSize = tinyScreenSize;
return this;
}
/**
* 一开始播放就seek到预先设置好的位置
* @param position 位置
* @return Builder
*/
public Builder skipPositionWhenPlay(int position) {
this.mCurrentPosition = position;
return this;
}
/**
* 是否开启AudioFocus监听， 默认开启，用于监听其它地方是否获取音频焦点，如果有其它地方获取了
* 音频焦点，此播放器将做出相应反应，具体实现见{@link AudioFocusHelper}
* @param enableAudioFocus 是否开启
* @return Builder
*/
public Builder setEnableAudioFocus(boolean enableAudioFocus) {
this.mEnableAudioFocus = enableAudioFocus;
return this;
}
public VideoPlayerBuilder build() {
//创建builder对象
return new VideoPlayerBuilder(this);
}
}
public final int mColor;
public final int[] mTinyScreenSize;
public final int mCurrentPosition;
public final boolean mEnableAudioFocus;
public VideoPlayerBuilder(Builder builder) {
mColor = builder.mColor;
mTinyScreenSize = builder.mTinyScreenSize;
mCurrentPosition = builder.mCurrentPosition;
mEnableAudioFocus = builder.mEnableAudioFocus;
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/player/VideoPlayerHelper.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.video.player;
import android.app.Activity;
import android.content.ContentResolver;
import android.content.Context;
import android.content.res.AssetFileDescriptor;
import android.net.Uri;
import android.os.Build;
import android.text.TextUtils;
import android.view.View;
import android.view.ViewGroup;
import android.view.WindowManager;
import com.yc.video.tool.PlayerUtils;
import com.yc.video.controller.BaseVideoController;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2018/11/9
* desc : 播放器帮助类
* revise:
* </pre>
*/
public class VideoPlayerHelper {
private static VideoPlayerHelper sInstance;
/**
* 构造方法，避免直接new
*/
private VideoPlayerHelper() {
//避免初始化
}
/**
* 一定要使用单例模式，保证同一时刻只有一个视频在播放，其他的都是初始状态
* 单例模式
* @return VideoPlayerManager对象
*/
public static VideoPlayerHelper instance() {
if (sInstance == null) {
synchronized (VideoPlayerHelper.class){
if (sInstance == null){
sInstance = new VideoPlayerHelper();
}
}
}
return sInstance;
}
/**
* 获取DecorView
* @param context 上下文
* @param videoController controller
*/
protected ViewGroup getDecorView(Context context , BaseVideoController videoController) {
Activity activity = VideoPlayerHelper.instance().getActivity(context,videoController);
if (activity == null) {
return null;
}
return (ViewGroup) activity.getWindow().getDecorView();
}
/**
* 获取activity中的content view,其id为android.R.id.content
* @param context 上下文
* @param videoController controller
*/
protected ViewGroup getContentView(Context context , BaseVideoController videoController) {
Activity activity = VideoPlayerHelper.instance().getActivity(context,videoController);
if (activity == null) {
return null;
}
return activity.findViewById(android.R.id.content);
}
/**
* 获取Activity，优先通过Controller去获取Activity
* @param context 上下文
* @param videoController controller
* @return
*/
protected Activity getActivity(Context context , BaseVideoController videoController) {
Activity activity;
if (videoController != null) {
activity = PlayerUtils.scanForActivity(videoController.getContext());
if (activity == null) {
activity = PlayerUtils.scanForActivity(context);
}
} else {
activity = PlayerUtils.scanForActivity(context);
}
return activity;
}
/**
* 显示NavigationBar和StatusBar
* @param decorView decorView
* @param context 上下文
* @param videoController controller
*/
protected void showSysBar(ViewGroup decorView,Context context , BaseVideoController videoController) {
int uiOptions = decorView.getSystemUiVisibility();
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
uiOptions &= ~View.SYSTEM_UI_FLAG_HIDE_NAVIGATION;
}
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
uiOptions &= ~View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY;
}
decorView.setSystemUiVisibility(uiOptions);
VideoPlayerHelper.instance().getActivity(context,videoController)
.getWindow().clearFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN);
}
/**
* 隐藏NavigationBar和StatusBar
* @param decorView decorView
* @param context 上下文
* @param videoController controller
*/
protected void hideSysBar(ViewGroup decorView,Context context , BaseVideoController videoController) {
int uiOptions = decorView.getSystemUiVisibility();
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
uiOptions |= View.SYSTEM_UI_FLAG_HIDE_NAVIGATION;
}
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
uiOptions |= View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY;
}
decorView.setSystemUiVisibility(uiOptions);
VideoPlayerHelper.instance().getActivity(context,videoController).getWindow().setFlags(
WindowManager.LayoutParams.FLAG_FULLSCREEN,
WindowManager.LayoutParams.FLAG_FULLSCREEN);
}
/**
* 判断是否为本地数据源，包括 本地文件、Asset、raw
* @param url url地址
* @param assetFileDescriptor assets文件
* @return 是否为本地数据源
*/
protected boolean isLocalDataSource(String url, AssetFileDescriptor assetFileDescriptor) {
if (assetFileDescriptor != null) {
return true;
} else if (!TextUtils.isEmpty(url)) {
Uri uri = Uri.parse(url);
return ContentResolver.SCHEME_ANDROID_RESOURCE.equals(uri.getScheme())
|| ContentResolver.SCHEME_FILE.equals(uri.getScheme())
|| "rawresource".equals(uri.getScheme());
}
return false;
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/player/VideoViewManager.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.video.player;
import android.app.Application;
import com.yc.kernel.utils.VideoLogUtils;
import com.yc.video.config.VideoPlayerConfig;
import java.util.LinkedHashMap;
/**
* 视频播放器管理器，管理当前正在播放的VideoView，以及播放器配置
* 你也可以用来保存常驻内存的VideoView，但是要注意通过Application Context创建，
* 以免内存泄漏
*/
public class VideoViewManager {
/**
* 保存VideoView的容器
*/
private LinkedHashMap<String, VideoPlayer> mVideoViews = new LinkedHashMap<>();
/**
* 是否在移动网络下直接播放视频
*/
private boolean mPlayOnMobileNetwork;
/**
* VideoViewManager实例
*/
private static volatile VideoViewManager sInstance;
/**
* VideoViewConfig实例
*/
private static VideoPlayerConfig sConfig;
private VideoViewManager() {
mPlayOnMobileNetwork = getConfig().mPlayOnMobileNetwork;
}
/**
* 设置VideoViewConfig
*/
public static void setConfig(VideoPlayerConfig config) {
if (sConfig == null) {
synchronized (VideoPlayerConfig.class) {
if (sConfig == null) {
sConfig = config == null ? VideoPlayerConfig.newBuilder().build() : config;
}
}
}
}
/**
* 获取VideoViewConfig
*/
public static VideoPlayerConfig getConfig() {
setConfig(null);
return sConfig;
}
/**
* 获取是否在移动网络下直接播放视频配置
*/
public boolean playOnMobileNetwork() {
return mPlayOnMobileNetwork;
}
/**
* 设置是否在移动网络下直接播放视频
*/
public void setPlayOnMobileNetwork(boolean playOnMobileNetwork) {
mPlayOnMobileNetwork = playOnMobileNetwork;
}
public static VideoViewManager instance() {
if (sInstance == null) {
synchronized (VideoViewManager.class) {
if (sInstance == null) {
sInstance = new VideoViewManager();
}
}
}
return sInstance;
}
/**
* 添加VideoView
* @param tag 相同tag的VideoView只会保存一个，如果tag相同则会release并移除前一个
*/
public void add(VideoPlayer videoView, String tag) {
if (!(videoView.getContext() instanceof Application)) {
VideoLogUtils.i("The Context of this VideoView is not an Application Context," +
"you must remove it after release,or it will lead to memory leek.");
}
VideoPlayer old = get(tag);
if (old != null) {
old.release();
remove(tag);
}
mVideoViews.put(tag, videoView);
}
public VideoPlayer get(String tag) {
return mVideoViews.get(tag);
}
public void remove(String tag) {
mVideoViews.remove(tag);
}
public void removeAll() {
mVideoViews.clear();
}
/**
* 释放掉和tag关联的VideoView，并将其从VideoViewManager中移除
*/
public void releaseByTag(String tag) {
releaseByTag(tag, true);
}
public void releaseByTag(String tag, boolean isRemove) {
VideoPlayer videoView = get(tag);
if (videoView != null) {
videoView.release();
if (isRemove) {
remove(tag);
}
}
}
public boolean onBackPress(String tag) {
VideoPlayer videoView = get(tag);
if (videoView == null) {
return false;
}
return videoView.onBackPressed();
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/surface/InterSurfaceView.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.video.surface;
import android.graphics.Bitmap;
import android.view.View;
import androidx.annotation.NonNull;
import com.yc.kernel.inter.AbstractVideoPlayer;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2018/11/9
* desc : 自定义渲染view接口
* revise:
* </pre>
*/
public interface InterSurfaceView {
/**
* 关联AbstractPlayer
* @param player player
*/
void attachToPlayer(@NonNull AbstractVideoPlayer player);
/**
* 设置视频宽高
* @param videoWidth 宽
* @param videoHeight 高
*/
void setVideoSize(int videoWidth, int videoHeight);
/**
* 设置视频旋转角度
* @param degree 角度值
*/
void setVideoRotation(int degree);
/**
* 设置screen scale type
* @param scaleType 类型
*/
void setScaleType(int scaleType);
/**
* 获取真实的RenderView
* @return view
*/
View getView();
/**
* 截图
* @return bitmap
*/
Bitmap doScreenShot();
/**
* 释放资源
*/
void release();
} | yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/surface/MeasureHelper.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.video.surface;
import android.view.View;
import com.yc.video.config.ConstantKeys;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2018/9/21
* desc : 帮助类
* revise:
* </pre>
*/
public class MeasureHelper {
private int mVideoWidth;
private int mVideoHeight;
private int mCurrentScreenScale;
private int mVideoRotationDegree;
/**
* 设置视频旋转角度
* @param videoRotationDegree 角度值
*/
public void setVideoRotation(int videoRotationDegree) {
mVideoRotationDegree = videoRotationDegree;
}
/**
* 设置视频宽高
* @param width 宽
* @param height 高
*/
public void setVideoSize(int width, int height) {
mVideoWidth = width;
mVideoHeight = height;
}
public void setScreenScale(int screenScale) {
mCurrentScreenScale = screenScale;
}
/**
* 注意：VideoView的宽高一定要定死，否者以下算法不成立
* 借鉴于网络
*/
public int[] doMeasure(int widthMeasureSpec, int heightMeasureSpec) {
if (mVideoRotationDegree == 90 || mVideoRotationDegree == 270) {
// 软解码时处理旋转信息，交换宽高
widthMeasureSpec = widthMeasureSpec + heightMeasureSpec;
heightMeasureSpec = widthMeasureSpec - heightMeasureSpec;
widthMeasureSpec = widthMeasureSpec - heightMeasureSpec;
}
int width = View.MeasureSpec.getSize(widthMeasureSpec);
int height = View.MeasureSpec.getSize(heightMeasureSpec);
if (mVideoHeight == 0 || mVideoWidth == 0) {
return new int[]{width, height};
}
//如果设置了比例
switch (mCurrentScreenScale) {
//默认正常类型
case ConstantKeys.PlayerScreenScaleType.SCREEN_SCALE_DEFAULT:
default:
if (mVideoWidth * height < width * mVideoHeight) {
width = height * mVideoWidth / mVideoHeight;
} else if (mVideoWidth * height > width * mVideoHeight) {
height = width * mVideoHeight / mVideoWidth;
}
break;
//原始类型，指视频的原始类型
case ConstantKeys.PlayerScreenScaleType.SCREEN_SCALE_ORIGINAL:
width = mVideoWidth;
height = mVideoHeight;
break;
//16：9比例类型，最为常见
case ConstantKeys.PlayerScreenScaleType.SCREEN_SCALE_16_9:
if (height > width / 16 * 9) {
height = width / 16 * 9;
} else {
width = height / 9 * 16;
}
break;
//4：3比例类型，也比较常见
case ConstantKeys.PlayerScreenScaleType.SCREEN_SCALE_4_3:
if (height > width / 4 * 3) {
height = width / 4 * 3;
} else {
width = height / 3 * 4;
}
break;
//充满整个控件视图
case ConstantKeys.PlayerScreenScaleType.SCREEN_SCALE_MATCH_PARENT:
width = widthMeasureSpec;
height = heightMeasureSpec;
break;
//剧中裁剪类型
case ConstantKeys.PlayerScreenScaleType.SCREEN_SCALE_CENTER_CROP:
if (mVideoWidth * height > width * mVideoHeight) {
width = height * mVideoWidth / mVideoHeight;
} else {
height = width * mVideoHeight / mVideoWidth;
}
break;
}
return new int[]{width, height};
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/surface/RenderSurfaceView.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.video.surface;
import android.content.Context;
import android.graphics.Bitmap;
import android.view.Surface;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import android.view.View;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import com.yc.kernel.inter.AbstractVideoPlayer;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2018/9/21
* desc : 重写SurfaceView，适配视频的宽高和旋转
* revise:
* </pre>
*/
public class RenderSurfaceView extends SurfaceView implements InterSurfaceView {
/**
* 优点：可以在一个独立的线程中进行绘制，不会影响主线程；使用双缓冲机制，播放视频时画面更流畅
* 缺点：Surface不在View hierachy中，它的显示也不受View的属性控制，所以不能进行平移，缩放等变换，
* 也不能放在其它ViewGroup中。SurfaceView 不能嵌套使用。
*
* SurfaceView双缓冲
* 1.SurfaceView在更新视图时用到了两张Canvas，一张frontCanvas和一张backCanvas。
* 2.每次实际显示的是frontCanvas，backCanvas存储的是上一次更改前的视图，当使用lockCanvas（）获取画布时，
* 得到的实际上是backCanvas而不是正在显示的frontCanvas，之后你在获取到的backCanvas上绘制新视图，
* 再unlockCanvasAndPost（canvas）此视图，那么上传的这张canvas将替换原来的frontCanvas作为新的frontCanvas，
* 原来的frontCanvas将切换到后台作为backCanvas。
*/
private MeasureHelper mMeasureHelper;
@Nullable
private AbstractVideoPlayer mMediaPlayer;
@Override
protected void onDetachedFromWindow() {
super.onDetachedFromWindow();
if (callback!=null){
getHolder().removeCallback(callback);
}
}
public RenderSurfaceView(Context context) {
super(context);
init(context);
}
private void init(Context context){
mMeasureHelper = new MeasureHelper();
SurfaceHolder holder = this.getHolder();
//holder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
holder.addCallback(callback);
}
/**
* 关联AbstractPlayer
* @param player player
*/
@Override
public void attachToPlayer(@NonNull AbstractVideoPlayer player) {
this.mMediaPlayer = player;
}
/**
* 设置视频宽高
* @param videoWidth 宽
* @param videoHeight 高
*/
@Override
public void setVideoSize(int videoWidth, int videoHeight) {
if (videoWidth > 0 && videoHeight > 0) {
mMeasureHelper.setVideoSize(videoWidth, videoHeight);
requestLayout();
}
}
/**
* 设置视频旋转角度
* @param degree 角度值
*/
@Override
public void setVideoRotation(int degree) {
mMeasureHelper.setVideoRotation(degree);
setRotation(degree);
}
/**
* 设置screen scale type
* @param scaleType 类型
*/
@Override
public void setScaleType(int scaleType) {
mMeasureHelper.setScreenScale(scaleType);
requestLayout();
}
/**
* 获取真实的RenderView
* @return view
*/
@Override
public View getView() {
return this;
}
/**
* 截图
* @return bitmap
*/
@Override
public Bitmap doScreenShot() {
return getDrawingCache();
}
/**
* 释放资源
*/
@Override
public void release() {
if (callback!=null){
getHolder().removeCallback(callback);
}
}
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
int[] measuredSize = mMeasureHelper.doMeasure(widthMeasureSpec, heightMeasureSpec);
setMeasuredDimension(measuredSize[0], measuredSize[1]);
}
/**
* 记得一定要重新写这个方法，如果角度发生了变化，就重新绘制布局
* 设置视频旋转角度
* @param rotation 角度
*/
@Override
public void setRotation(float rotation) {
if (rotation != getRotation()) {
super.setRotation(rotation);
requestLayout();
}
}
private SurfaceHolder.Callback callback = new SurfaceHolder.Callback(){
/**
* 创建的时候调用该方法
* @param holder holder
*/
@Override
public void surfaceCreated(SurfaceHolder holder) {
if (mMediaPlayer != null) {
Surface surface = holder.getSurface();
mMediaPlayer.setSurface(surface);
}
}
/**
* 视图改变的时候调用方法
* @param holder
* @param format
* @param width
* @param height
*/
@Override
public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
}
/**
* 销毁的时候调用该方法
* @param holder
*/
@Override
public void surfaceDestroyed(SurfaceHolder holder) {
}
};
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/surface/RenderTextureView.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.video.surface;
import android.annotation.SuppressLint;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.SurfaceTexture;
import android.view.Surface;
import android.view.TextureView;
import android.view.View;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import com.yc.kernel.inter.AbstractVideoPlayer;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2018/9/21
* desc : 重写TextureView，适配视频的宽高和旋转
* revise: 1.继承View，具有view的特性，比如移动，旋转，缩放，动画等变化。支持截图
* 8.必须在硬件加速的窗口中使用，占用内存比SurfaceView高，在5.0以前在主线程渲染，5.0以后有单独的渲染线程。
* </pre>
*/
@SuppressLint("ViewConstructor")
public class RenderTextureView extends TextureView implements InterSurfaceView {
private MeasureHelper mMeasureHelper;
private SurfaceTexture mSurfaceTexture;
@Nullable
private AbstractVideoPlayer mMediaPlayer;
private Surface mSurface;
public RenderTextureView(Context context) {
super(context);
init(context);
}
private void init(Context context){
mMeasureHelper = new MeasureHelper();
setSurfaceTextureListener(listener);
}
/**
* 关联AbstractPlayer
* @param player player
*/
@Override
public void attachToPlayer(@NonNull AbstractVideoPlayer player) {
this.mMediaPlayer = player;
}
/**
* 设置视频宽高
* @param videoWidth 宽
* @param videoHeight 高
*/
@Override
public void setVideoSize(int videoWidth, int videoHeight) {
if (videoWidth > 0 && videoHeight > 0) {
mMeasureHelper.setVideoSize(videoWidth, videoHeight);
requestLayout();
}
}
/**
* 设置视频旋转角度
* @param degree 角度值
*/
@Override
public void setVideoRotation(int degree) {
mMeasureHelper.setVideoRotation(degree);
setRotation(degree);
}
/**
* 设置screen scale type
* @param scaleType 类型
*/
@Override
public void setScaleType(int scaleType) {
mMeasureHelper.setScreenScale(scaleType);
requestLayout();
}
/**
* 获取真实的RenderView
* @return view
*/
@Override
public View getView() {
return this;
}
/**
* 截图
* @return bitmap
*/
@Override
public Bitmap doScreenShot() {
return getBitmap();
}
/**
* 释放资源
*/
@Override
public void release() {
if (mSurface != null){
mSurface.release();
}
if (mSurfaceTexture != null){
mSurfaceTexture.release();
}
}
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
int[] measuredSize = mMeasureHelper.doMeasure(widthMeasureSpec, heightMeasureSpec);
setMeasuredDimension(measuredSize[0], measuredSize[1]);
}
/**
* 记得一定要重新写这个方法，如果角度发生了变化，就重新绘制布局
* 设置视频旋转角度
* @param rotation 角度
*/
@Override
public void setRotation(float rotation) {
if (rotation != getRotation()) {
super.setRotation(rotation);
requestLayout();
}
}
private SurfaceTextureListener listener = new SurfaceTextureListener() {
/**
* SurfaceTexture准备就绪
* @param surfaceTexture surface
* @param width WIDTH
* @param height HEIGHT
*/
@Override
public void onSurfaceTextureAvailable(SurfaceTexture surfaceTexture, int width, int height) {
if (mSurfaceTexture != null) {
setSurfaceTexture(mSurfaceTexture);
} else {
mSurfaceTexture = surfaceTexture;
mSurface = new Surface(surfaceTexture);
if (mMediaPlayer != null) {
mMediaPlayer.setSurface(mSurface);
}
}
}
/**
* SurfaceTexture缓冲大小变化
* @param surface surface
* @param width WIDTH
* @param height HEIGHT
*/
@Override
public void onSurfaceTextureSizeChanged(SurfaceTexture surface, int width, int height) {
}
/**
* SurfaceTexture即将被销毁
* @param surface surface
*/
@Override
public boolean onSurfaceTextureDestroyed(SurfaceTexture surface) {
return false;
}
/**
* SurfaceTexture通过updateImage更新
* @param surface surface
*/
@Override
public void onSurfaceTextureUpdated(SurfaceTexture surface) {
}
};
} | yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/surface/SurfaceFactory.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.video.surface;
import android.content.Context;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2018/11/9
* desc : 扩展自己的渲染View
* revise: 可以使用TextureView，可参考{@link RenderTextureView}和{@link TextureViewFactory}的实现。
* </pre>
*/
public abstract class SurfaceFactory {
public abstract InterSurfaceView createRenderView(Context context);
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/surface/SurfaceViewFactory.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.video.surface;
import android.content.Context;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2018/11/9
* desc : 实现类
* revise:
* </pre>
*/
public class SurfaceViewFactory extends SurfaceFactory {
public static SurfaceViewFactory create() {
return new SurfaceViewFactory();
}
@Override
public InterSurfaceView createRenderView(Context context) {
//创建SurfaceView
return new RenderSurfaceView(context);
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/surface/TextureViewFactory.java | Java | package com.yc.video.surface;
import android.content.Context;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2018/11/9
* desc : 实现类
* revise:
* </pre>
*/
public class TextureViewFactory extends SurfaceFactory {
public static TextureViewFactory create() {
return new TextureViewFactory();
}
@Override
public InterSurfaceView createRenderView(Context context) {
//创建TextureView
return new RenderTextureView(context);
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/tool/BaseToast.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.video.tool;
import android.annotation.SuppressLint;
import android.content.Context;
import android.graphics.Color;
import android.os.Build;
import android.os.Handler;
import android.os.Looper;
import androidx.annotation.ColorInt;
import androidx.annotation.LayoutRes;
import androidx.annotation.NonNull;
import androidx.cardview.widget.CardView;
import android.os.Message;
import android.text.TextUtils;
import android.view.Gravity;
import android.view.LayoutInflater;
import android.view.View;
import android.widget.TextView;
import android.widget.Toast;
import com.yc.video.R;
import java.lang.ref.SoftReference;
import java.lang.reflect.Field;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2017/06/4
* desc : Toast工具类，模仿易车，抖音自定义吐司
* revise: 具体看GitHub开源项目：https://github.com/yangchong211/YCDialog
* </pre>
*/
public final class BaseToast {
@SuppressLint("StaticFieldLeak")
private static Context mApp;
private static int toastBackColor;
private static SoftReference<Toast> mToast;
/**
* 初始化吐司工具类
* @param app 应用
*/
public static void init(@NonNull final Context app) {
if (mApp==null){
mApp = app;
toastBackColor = Color.BLACK;
}
}
public static void setToastBackColor(@ColorInt int color){
toastBackColor = color;
}
/**
* 私有构造
*/
private BaseToast() {
//避免初始化
throw new UnsupportedOperationException("u can't instantiate me...");
}
/**
* 检查上下文不能为空，必须先进性初始化操作
*/
private static void checkContext(){
if(mApp==null){
throw new NullPointerException("ToastUtils context is not null，please first init");
}
}
/**
* 吐司工具类 避免点击多次导致吐司多次，最后导致Toast就长时间关闭不掉了
* 注意：这里如果传入context会报内存泄漏；传递activity..getApplicationContext()
* @param content 吐司内容
*/
private static Toast toast;
@SuppressLint("ShowToast")
public static void showToast(String content) {
checkMainThread();
checkContext();
if (!checkNull(mToast)) {
mToast.get().cancel();
}
Toast toast = Toast.makeText(mApp, "", Toast.LENGTH_SHORT);
toast.setText(content);
toast.show();
mToast = new SoftReference<>(toast);
}
/**
* 某些系统可能屏蔽通知
* 1:检查 SystemUtils.isEnableNotification(BaseApplication.getApplication());
* 2:替代方案 SnackBarUtils.showSnack(topActivity, noticeStr);
* 圆角
* 屏幕中间
* @param notice 内容
*/
public static void showRoundRectToast(CharSequence notice) {
checkMainThread();
checkContext();
if (TextUtils.isEmpty(notice)){
return;
}
new Builder(mApp)
.setDuration(Toast.LENGTH_SHORT)
.setFill(false)
.setGravity(Gravity.CENTER)
.setOffset(0)
.setTitle(notice)
.setTextColor(Color.WHITE)
.setBackgroundColor(toastBackColor)
.setRadius(dip2px(mApp, 10))
.setElevation(dip2px(mApp, 0))
.build()
.show();
}
public static void showRoundRectToast(CharSequence notice,CharSequence desc) {
checkMainThread();
checkContext();
if (TextUtils.isEmpty(notice)){
return;
}
new Builder(mApp)
.setDuration(Toast.LENGTH_SHORT)
.setFill(false)
.setGravity(Gravity.CENTER)
.setOffset(0)
.setDesc(desc)
.setTitle(notice)
.setTextColor(Color.WHITE)
.setBackgroundColor(toastBackColor)
.setRadius(dip2px(mApp, 10))
.setElevation(dip2px(mApp, 0))
.build()
.show();
}
public static void showRoundRectToast(@LayoutRes int layout) {
checkMainThread();
checkContext();
if (layout==0){
return;
}
new Builder(mApp)
.setDuration(Toast.LENGTH_SHORT)
.setFill(false)
.setGravity(Gravity.CENTER)
.setOffset(0)
.setLayout(layout)
.build()
.show();
}
public static final class Builder {
private Context context;
private CharSequence title;
private CharSequence desc;
private int gravity = Gravity.TOP;
private boolean isFill;
private int yOffset;
private int duration = Toast.LENGTH_SHORT;
private int textColor = Color.WHITE;
private int backgroundColor = Color.BLACK;
private float radius;
private int elevation;
private int layout;
public Builder(Context context) {
this.context = context;
}
public Builder setTitle(CharSequence title) {
this.title = title;
return this;
}
public Builder setDesc(CharSequence desc){
this.desc = desc;
return this;
}
public Builder setGravity(int gravity) {
this.gravity = gravity;
return this;
}
public Builder setFill(boolean fill) {
isFill = fill;
return this;
}
public Builder setOffset(int yOffset) {
this.yOffset = yOffset;
return this;
}
public Builder setDuration(int duration) {
this.duration = duration;
return this;
}
public Builder setTextColor(int textColor) {
this.textColor = textColor;
return this;
}
public Builder setBackgroundColor(int backgroundColor) {
this.backgroundColor = backgroundColor;
return this;
}
public Builder setRadius(float radius) {
this.radius = radius;
return this;
}
public Builder setElevation(int elevation) {
this.elevation = elevation;
return this;
}
public Builder setLayout(@LayoutRes int layout) {
this.layout = layout;
return this;
}
public Toast build() {
if (!checkNull(mToast)) {
mToast.get().cancel();
}
Toast toast = new Toast(context);
HookToast.hook(toast);
if (isFill) {
toast.setGravity(gravity | Gravity.FILL_HORIZONTAL, 0, yOffset);
} else {
toast.setGravity(gravity, 0, yOffset);
}
toast.setDuration(duration);
toast.setMargin(0, 0);
if(layout==0){
CardView rootView = (CardView) LayoutInflater.from(context).inflate(R.layout.custom_toast_view, null);
TextView textView = rootView.findViewById(R.id.toastTextView);
TextView descTv = rootView.findViewById(R.id.desc);
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
//rootView.setElevation(elevation);
rootView.setCardElevation(elevation);
}
rootView.setRadius(radius);
rootView.setCardBackgroundColor(backgroundColor);
//rootView.setBackgroundColor(backgroundColor);
textView.setTextColor(textColor);
textView.setText(title);
if(TextUtils.isEmpty(desc)){
descTv.setVisibility(View.GONE);
}else{
descTv.setText(desc);
descTv.setVisibility(View.VISIBLE);
}
toast.setView(rootView);
}else {
View view = LayoutInflater.from(context).inflate(layout, null);
toast.setView(view);
}
mToast = new SoftReference<>(toast);
return toast;
}
}
public static boolean checkNull(SoftReference softReference) {
if (softReference == null || softReference.get() == null) {
return true;
}
return false;
}
public static void checkMainThread(){
if (!isMainThread()){
throw new IllegalStateException("请不要在子线程中做弹窗操作");
}
}
private static boolean isMainThread(){
//判断是否是主线程
return Looper.getMainLooper() == Looper.myLooper();
}
public static int dip2px(Context context, float dpValue) {
final float scale = context.getResources().getDisplayMetrics().density;
return (int) (dpValue * scale + 0.5f);
}
/**
* <pre>
* @author yangchong
* email : yangchong211@163.com
* time : 20120/5/6
* desc : 利用hook解决toast崩溃问题
* revise:
* </pre>
*/
public static class HookToast {
private static Field sField_TN;
private static Field sField_TN_Handler;
static {
try {
Class<?> clazz = Toast.class;
sField_TN = clazz.getDeclaredField("mTN");
sField_TN.setAccessible(true);
sField_TN_Handler = sField_TN.getType().getDeclaredField("mHandler");
sField_TN_Handler.setAccessible(true);
} catch (Exception e) {
e.printStackTrace();
}
}
public static void hook(Toast toast) {
try {
Object tn = sField_TN.get(toast);
Handler preHandler = (Handler) sField_TN_Handler.get(tn);
sField_TN_Handler.set(tn, new HookToast.SafelyHandler(preHandler));
} catch (Exception e) {
e.printStackTrace();
}
}
public static class SafelyHandler extends Handler {
private Handler impl;
public SafelyHandler(Handler impl) {
this.impl = impl;
}
public void dispatchMessage(Message msg) {
try {
super.dispatchMessage(msg);
} catch (Exception e) {
e.printStackTrace();
}
}
public void handleMessage(Message msg) {
//需要委托给原Handler执行
impl.handleMessage(msg);
}
}
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/tool/CountDownTimer.java | Java | package com.yc.video.tool;
import android.annotation.SuppressLint;
import android.os.Handler;
import android.os.Message;
import android.os.SystemClock;
import androidx.annotation.NonNull;
/**
* <pre>
* @author yangchong
* email : yangchong211@163.com
* time : 2020/5/26
* desc : 自定义倒计时器
* revise: 支持开始，暂停，恢复暂停，取消等业务逻辑
* 也可以用于多线程中
* </pre>
*/
public class CountDownTimer {
/**
* 时间，即开始的时间，通俗来说就是倒计时总时间
*/
private long mMillisInFuture;
/**
* 布尔值，表示计时器是否被取消
* 只有调用cancel时才被设置为true
*/
private boolean mCancelled = false;
/**
* 用户接收回调的时间间隔，一般是1秒
*/
private long mCountdownInterval;
/**
* 记录暂停时候的时间
*/
private long mStopTimeInFuture;
/**
* mas.what值
*/
private static final int MSG = 520;
/**
* 暂停时，当时剩余时间
*/
private long mCurrentMillisLeft;
/**
* 是否暂停
* 只有当调用pause时，才设置为true
*/
private boolean mPause = false;
/**
* 监听listener
*/
private TimerListener mCountDownListener;
public CountDownTimer(){
}
public CountDownTimer(long millisInFuture, long countdownInterval) {
this.mMillisInFuture = millisInFuture;
this.mCountdownInterval = countdownInterval;
}
/**
* 开始倒计时，每次点击，都会重新开始
*/
public synchronized final void start() {
if (mMillisInFuture <= 0 && mCountdownInterval <= 0) {
throw new RuntimeException("you must set the millisInFuture > 0 or countdownInterval >0");
}
mCancelled = false;
mStopTimeInFuture = SystemClock.elapsedRealtime() + mMillisInFuture;
mPause = false;
mHandler.sendMessage(mHandler.obtainMessage(MSG));
if (mCountDownListener!=null){
mCountDownListener.onStart();
}
}
/**
* 取消计时器
*/
public synchronized final void cancel() {
if (mHandler != null) {
//暂停
mPause = false;
mHandler.removeMessages(MSG);
//取消
mCancelled = true;
}
}
/**
* 按一下暂停，再按一下继续倒计时
*/
public synchronized final void pause() {
if (mHandler != null) {
if (mCancelled) {
return;
}
if (mCurrentMillisLeft < mCountdownInterval) {
return;
}
if (!mPause) {
mHandler.removeMessages(MSG);
mPause = true;
}
}
}
/**
* 恢复暂停，开始
*/
public synchronized final void resume() {
if (mMillisInFuture <= 0 && mCountdownInterval <= 0) {
throw new RuntimeException("you must set the millisInFuture > 0 or countdownInterval >0");
}
if (mCancelled) {
return;
}
//剩余时长少于
if (mCurrentMillisLeft < mCountdownInterval || !mPause) {
return;
}
mStopTimeInFuture = SystemClock.elapsedRealtime() + mCurrentMillisLeft;
mHandler.sendMessage(mHandler.obtainMessage(MSG));
mPause = false;
}
@SuppressLint("HandlerLeak")
private Handler mHandler = new Handler() {
@Override
public void handleMessage(@NonNull Message msg) {
synchronized (CountDownTimer.this) {
if (mCancelled) {
return;
}
//剩余毫秒数
final long millisLeft = mStopTimeInFuture - SystemClock.elapsedRealtime();
if (millisLeft <= 0) {
mCurrentMillisLeft = 0;
if (mCountDownListener != null) {
mCountDownListener.onFinish();
}
} else if (millisLeft < mCountdownInterval) {
mCurrentMillisLeft = 0;
// 剩余时间小于一次时间间隔的时候，不再通知，只是延迟一下
sendMessageDelayed(obtainMessage(MSG), millisLeft);
} else {
//有多余的时间
long lastTickStart = SystemClock.elapsedRealtime();
if (mCountDownListener != null) {
mCountDownListener.onTick(millisLeft);
}
mCurrentMillisLeft = millisLeft;
// 考虑用户的onTick需要花费时间,处理用户onTick执行的时间
long delay = lastTickStart + mCountdownInterval - SystemClock.elapsedRealtime();
// 特殊情况：用户的onTick方法花费的时间比interval长，那么直接跳转到下一次interval
while (delay < 0){
delay += mCountdownInterval;
}
sendMessageDelayed(obtainMessage(MSG), delay);
}
}
}
};
/**
* 设置倒计时总时间
* @param millisInFuture 毫秒值
*/
public void setMillisInFuture(long millisInFuture) {
this.mMillisInFuture = millisInFuture;
}
/**
* 设置倒计时间隔值
* @param countdownInterval 间隔，一般设置为1000毫秒
*/
public void setCountdownInterval(long countdownInterval) {
this.mCountdownInterval = countdownInterval;
}
/**
* 设置倒计时监听
* @param countDownListener listener
*/
public void setCountDownListener(TimerListener countDownListener) {
this.mCountDownListener = countDownListener;
}
public interface TimerListener {
/**
* 当倒计时开始
*/
void onStart();
/**
* 当倒计时结束
*/
void onFinish();
/**
* @param millisUntilFinished 剩余时间
*/
void onTick(long millisUntilFinished);
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/tool/NetworkUtils.java | Java | package com.yc.video.tool;
import android.content.Context;
import android.net.ConnectivityManager;
import android.net.Network;
import android.net.NetworkInfo;
import android.os.Build;
import android.telephony.TelephonyManager;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2019/5/21
* desc : 网络状态监听工具类
* revise:
* </pre>
*/
public class NetworkUtils {
/**
* 标记当前网络状态，分别是：移动数据、Wifi、未连接、网络状态已公布
*/
public enum State {
MOBILE, WIFI, UN_CONNECTED, PUBLISHED
}
/**
* 为了避免因多次接收到广播反复提醒的情况而设置的标志位，用于缓存收到新的广播前的网络状态
*/
private static State tempState;
/**
* 获取当前网络连接状态
*
* @param context Context
* @return 网络状态
*/
public static State getConnectState(Context context) {
ConnectivityManager manager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo networkInfo = null;
if (manager != null) {
networkInfo = manager.getActiveNetworkInfo();
}
State state = State.UN_CONNECTED;
if (networkInfo != null && networkInfo.isAvailable()) {
if (isMobileConnected(context)) {
state = State.MOBILE;
} else if (isWifiConnected(context)) {
state = State.WIFI;
}
}
if (state.equals(tempState)) {
return State.PUBLISHED;
}
tempState = state;
return state;
}
private static boolean isMobileConnected(Context context) {
return isConnected(context, ConnectivityManager.TYPE_MOBILE);
}
private static boolean isWifiConnected(Context context) {
return isConnected(context, ConnectivityManager.TYPE_WIFI);
}
private static boolean isConnected(Context context, int type) {
//getAllNetworkInfo() 在 API 23 中被弃用
//getAllNetworks() 在 API 21 中才添加
ConnectivityManager manager = (ConnectivityManager) context.
getSystemService(Context.CONNECTIVITY_SERVICE);
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
NetworkInfo[] allNetworkInfo = new NetworkInfo[0];
if (manager != null) {
allNetworkInfo = manager.getAllNetworkInfo();
}
for (NetworkInfo info : allNetworkInfo) {
if (info.getType() == type) {
return info.isAvailable();
}
}
} else {
Network[] networks = new Network[0];
if (manager != null) {
networks = manager.getAllNetworks();
}
for (Network network : networks) {
NetworkInfo networkInfo = manager.getNetworkInfo(network);
if (networkInfo.getType() == type) {
return networkInfo.isAvailable();
}
}
}
return false;
}
public static final int NO_NETWORK = 0;
public static final int NETWORK_CLOSED = 1;
public static final int NETWORK_ETHERNET = 2;
public static final int NETWORK_WIFI = 3;
public static final int NETWORK_MOBILE = 4;
public static final int NETWORK_UNKNOWN = -1;
/**
* 判断当前网络类型
*/
public static int getNetworkType(Context context) {
//改为context.getApplicationContext()，防止在Android 6.0上发生内存泄漏
ConnectivityManager connectMgr = (ConnectivityManager) context.getApplicationContext()
.getSystemService(Context.CONNECTIVITY_SERVICE);
if (connectMgr == null) {
return NO_NETWORK;
}
NetworkInfo networkInfo = connectMgr.getActiveNetworkInfo();
if (networkInfo == null) {
// 没有任何网络
return NO_NETWORK;
}
if (!networkInfo.isConnected()) {
// 网络断开或关闭
return NETWORK_CLOSED;
}
if (networkInfo.getType() == ConnectivityManager.TYPE_ETHERNET) {
// 以太网网络
return NETWORK_ETHERNET;
} else if (networkInfo.getType() == ConnectivityManager.TYPE_WIFI) {
// wifi网络，当激活时，默认情况下，所有的数据流量将使用此连接
return NETWORK_WIFI;
} else if (networkInfo.getType() == ConnectivityManager.TYPE_MOBILE) {
// 移动数据连接,不能与连接共存,如果wifi打开，则自动关闭
switch (networkInfo.getSubtype()) {
// 2G
case TelephonyManager.NETWORK_TYPE_GPRS:
case TelephonyManager.NETWORK_TYPE_EDGE:
case TelephonyManager.NETWORK_TYPE_CDMA:
case TelephonyManager.NETWORK_TYPE_1xRTT:
case TelephonyManager.NETWORK_TYPE_IDEN:
// 3G
case TelephonyManager.NETWORK_TYPE_UMTS:
case TelephonyManager.NETWORK_TYPE_EVDO_0:
case TelephonyManager.NETWORK_TYPE_EVDO_A:
case TelephonyManager.NETWORK_TYPE_HSDPA:
case TelephonyManager.NETWORK_TYPE_HSUPA:
case TelephonyManager.NETWORK_TYPE_HSPA:
case TelephonyManager.NETWORK_TYPE_EVDO_B:
case TelephonyManager.NETWORK_TYPE_EHRPD:
case TelephonyManager.NETWORK_TYPE_HSPAP:
// 4G
case TelephonyManager.NETWORK_TYPE_LTE:
// 5G
return NETWORK_MOBILE;
}
}
// 未知网络
return NETWORK_UNKNOWN;
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/tool/PlayerUtils.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.video.tool;
import android.annotation.SuppressLint;
import android.app.Activity;
import android.content.Context;
import android.content.ContextWrapper;
import android.content.res.Resources;
import android.graphics.Point;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.os.Build;
import android.text.TextUtils;
import android.util.TypedValue;
import android.view.Display;
import android.view.KeyCharacterMap;
import android.view.KeyEvent;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewConfiguration;
import android.view.ViewParent;
import android.view.WindowManager;
import android.widget.FrameLayout;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.appcompat.app.ActionBar;
import androidx.appcompat.app.AppCompatActivity;
import androidx.appcompat.view.ContextThemeWrapper;
import com.yc.video.config.ConstantKeys;
import com.yc.video.config.VideoPlayerConfig;
import com.yc.video.player.VideoViewManager;
import java.lang.reflect.Field;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.Formatter;
import java.util.List;
import java.util.Locale;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2017/10/21
* desc : 工具类
* revise:
* </pre>
*/
public final class PlayerUtils {
/**
* 通过上下文获取到activity，使用到了递归
*
* @param context 上下文
* @return 对象的活动对象，如果它不是活动对象，则为空。
*/
public static Activity scanForActivity(Context context) {
if (context == null) {
return null;
}
if (context instanceof Activity) {
return (Activity) context;
} else if (context instanceof ContextWrapper) {
return scanForActivity(((ContextWrapper) context).getBaseContext());
}
return null;
}
/**
* 判断某Activity是否挂掉
* @param activity activity
* @return
*/
public static boolean isActivityLiving(@Nullable Activity activity) {
if (activity == null) {
return false;
}
if (activity.isFinishing()) {
return false;
}
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1 && activity.isDestroyed()) {
return false;
}
return true;
}
/**
* Get AppCompatActivity from context
* @param context 上下文
* @return AppCompatActivity if it's not null
*/
private static AppCompatActivity getAppCompActivity(Context context) {
if (context == null) {
return null;
}
if (context instanceof AppCompatActivity) {
return (AppCompatActivity) context;
} else if (context instanceof ContextThemeWrapper) {
return getAppCompActivity(((ContextThemeWrapper) context).getBaseContext());
}
return null;
}
@SuppressLint("RestrictedApi")
public static void showActionBar(Context context) {
ActionBar ab = getAppCompActivity(context).getSupportActionBar();
if (ab != null) {
ab.setShowHideAnimationEnabled(false);
ab.show();
}
scanForActivity(context).getWindow().clearFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN);
}
@SuppressLint("RestrictedApi")
public static void hideActionBar(Context context) {
ActionBar ab = getAppCompActivity(context).getSupportActionBar();
if (ab != null) {
ab.setShowHideAnimationEnabled(false);
ab.hide();
}
scanForActivity(context).getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
WindowManager.LayoutParams.FLAG_FULLSCREEN);
}
/**
* 获取屏幕宽度
*/
public static int getScreenWidth(Context context) {
return context.getResources().getDisplayMetrics().widthPixels;
}
/**
* 获取屏幕高度
*/
public static int getScreenHeight(Context context) {
return context.getResources().getDisplayMetrics().heightPixels;
}
/**
* 获取状态栏高度
*/
public static double getStatusBarHeight(Context context) {
int statusBarHeight = 0;
//获取status_bar_height资源的ID
int resourceId = context.getResources().getIdentifier("status_bar_height", "dimen", "android");
if (resourceId > 0) {
//根据资源ID获取响应的尺寸值
statusBarHeight = context.getResources().getDimensionPixelSize(resourceId);
}
return statusBarHeight;
}
/**
* 获取竖屏下状态栏高度
*/
public static double getStatusBarHeightPortrait(Context context) {
int statusBarHeight = 0;
//获取status_bar_height_portrait资源的ID
int resourceId = context.getResources().getIdentifier("status_bar_height_portrait", "dimen", "android");
if (resourceId > 0) {
//根据资源ID获取响应的尺寸值
statusBarHeight = context.getResources().getDimensionPixelSize(resourceId);
}
return statusBarHeight;
}
/**
* 获取NavigationBar的高度
*/
public static int getNavigationBarHeight(Context context) {
if (!hasNavigationBar(context)) {
return 0;
}
Resources resources = context.getResources();
int resourceId = resources.getIdentifier("navigation_bar_height",
"dimen", "android");
//获取NavigationBar的高度
return resources.getDimensionPixelSize(resourceId);
}
/**
* 是否存在NavigationBar
*/
public static boolean hasNavigationBar(Context context) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
Display display = getWindowManager(context).getDefaultDisplay();
Point size = new Point();
Point realSize = new Point();
display.getSize(size);
display.getRealSize(realSize);
return realSize.x != size.x || realSize.y != size.y;
} else {
boolean menu = ViewConfiguration.get(context).hasPermanentMenuKey();
boolean back = KeyCharacterMap.deviceHasKey(KeyEvent.KEYCODE_BACK);
return !(menu || back);
}
}
/**
* 获取屏幕宽度
*/
public static int getScreenWidth(Context context, boolean isIncludeNav) {
if (isIncludeNav) {
return context.getResources().getDisplayMetrics().widthPixels + getNavigationBarHeight(context);
} else {
return context.getResources().getDisplayMetrics().widthPixels;
}
}
/**
* 获取屏幕高度
*/
public static int getScreenHeight(Context context, boolean isIncludeNav) {
if (isIncludeNav) {
return context.getResources().getDisplayMetrics().heightPixels + getNavigationBarHeight(context);
} else {
return context.getResources().getDisplayMetrics().heightPixels;
}
}
/**
* dp转为px
*/
public static int dp2px(Context context, float dpValue) {
return (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, dpValue, context.getResources().getDisplayMetrics());
}
/**
* sp转为px
*/
public static int sp2px(Context context, float dpValue) {
return (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_SP, dpValue, context.getResources().getDisplayMetrics());
}
/**
* 获取集合的快照
*/
@NonNull
public static <T> List<T> getSnapshot(@NonNull Collection<T> other) {
List<T> result = new ArrayList<>(other.size());
for (T item : other) {
if (item != null) {
result.add(item);
}
}
return result;
}
/**
* 如果WindowManager还未创建，则创建一个新的WindowManager返回。否则返回当前已创建的WindowManager。
*/
public static WindowManager getWindowManager(Context context) {
return (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
}
/**
* 边缘检测
*/
public static boolean isEdge(Context context, MotionEvent e) {
int edgeSize = dp2px(context, 40);
return e.getRawX() < edgeSize
|| e.getRawX() > getScreenWidth(context, true) - edgeSize
|| e.getRawY() < edgeSize
|| e.getRawY() > getScreenHeight(context, true) - edgeSize;
}
/**
* 将毫秒数格式化为"##:##"的时间
* @param milliseconds 毫秒数
* @return ##:##
*/
public static String formatTime(long milliseconds) {
if (milliseconds <= 0 || milliseconds >= 24 * 60 * 60 * 1000) {
return "00:00";
}
long totalSeconds = milliseconds / 1000;
long seconds = totalSeconds % 60;
long minutes = (totalSeconds / 60) % 60;
long hours = totalSeconds / 3600;
StringBuilder stringBuilder = new StringBuilder();
Formatter mFormatter = new Formatter(stringBuilder, Locale.getDefault());
if (hours > 0) {
return mFormatter.format("%d:%02d:%02d", hours, minutes, seconds).toString();
} else {
return mFormatter.format("%02d:%02d", minutes, seconds).toString();
}
}
/**
* 保存播放位置，以便下次播放时接着上次的位置继续播放.
* @param context 上下文
* @param url 视频链接url
*/
public static synchronized void savePlayPosition(Context context, String url, long position) {
if (context==null){
return;
}
context.getSharedPreferences("VIDEO_PLAYER_PLAY_POSITION",
Context.MODE_PRIVATE).edit().putLong(url, position).apply();
}
/**
* 取出上次保存的播放位置
* @param context 上下文
* @param url 视频链接url
* @return 上次保存的播放位置
*/
public static synchronized long getSavedPlayPosition(Context context, String url) {
if (context==null){
return 0;
}
return context.getSharedPreferences("VIDEO_PLAYER_PLAY_POSITION",
Context.MODE_PRIVATE).getLong(url, 0);
}
/**
* 清楚播放位置的痕迹
* @param context 上下文
*/
public static synchronized void clearPlayPosition(Context context){
if (context==null){
return;
}
context.getSharedPreferences("VIDEO_PLAYER_PLAY_POSITION",
Context.MODE_PRIVATE).getAll().clear();
}
/**
* 判断网络是否连接
* <p>需添加权限 {@code <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>}</p>
*
* @return {@code true}: 是<br>{@code false}: 否
*/
public static boolean isConnected(Context context) {
NetworkInfo info = getActiveNetworkInfo(context);
return info != null && info.isConnected();
}
/**
* 获取当前系统时间
*/
public static String getCurrentSystemTime() {
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("HH:mm", Locale.getDefault());
Date date = new Date();
return simpleDateFormat.format(date);
}
/**
* 获取活动网络信息
* <p>需添加权限
* {@code <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />}</p>
*
* @return NetworkInfo
*/
@SuppressLint("MissingPermission")
private static NetworkInfo getActiveNetworkInfo(Context context) {
ConnectivityManager manager = (ConnectivityManager)
context.getApplicationContext().getSystemService(Context.CONNECTIVITY_SERVICE);
if (manager == null) {
return null;
}
return manager.getActiveNetworkInfo();
}
/**
* 空指针检测，不能为null，可以为""
* @param obj obj对象
* @param message 消息
* @param <T> 泛型
* @return obj
*/
public static <T> T requireNonNull(T obj, String message) {
if (obj == null) {
throw new NullPointerException(message);
}
return obj;
}
/**
* 空指针检测，不能为null，也不能为""
* @param obj obj对象
* @param message 消息
* @return 字符串
*/
public static String requireNonEmpty(String obj, String message) {
if (TextUtils.isEmpty(obj)) {
throw new IllegalArgumentException(message);
}
return obj;
}
/**
* 将毫秒换成00:00:00
* @param time 毫秒
* @return 时间字符串
*/
public static String getCountTimeByLong(long time) {
//秒
long totalTime = time / 1000;
//时，分，秒
long hour = 0, minute = 0, second = 0;
if (3600 <= totalTime) {
hour = totalTime / 3600;
totalTime = totalTime - 3600 * hour;
}
if (60 <= totalTime) {
minute = totalTime / 60;
totalTime = totalTime - 60 * minute;
}
if (0 <= totalTime) {
second = totalTime;
}
StringBuilder sb = new StringBuilder();
if (hour < 10) {
sb.append("0").append(hour).append(":");
} else {
sb.append(hour).append(":");
}
if (minute < 10) {
sb.append("0").append(minute).append(":");
} else {
sb.append(minute).append(":");
}
if (second < 10) {
sb.append("0").append(second);
} else {
sb.append(second);
}
return sb.toString();
}
/**
* 将毫秒换成 00:00 或者 00，这个根据具体时间来计算
* @param time 毫秒
* @return 时间字符串
*/
public static String getCountTime(long time) {
//秒
long totalTime = time / 1000;
//时，分，秒
long hour = 0, minute = 0, second = 0;
if (3600 <= totalTime) {
hour = totalTime / 3600;
totalTime = totalTime - 3600 * hour;
}
if (60 <= totalTime) {
minute = totalTime / 60;
totalTime = totalTime - 60 * minute;
}
if (0 <= totalTime) {
second = totalTime;
}
StringBuilder sb = new StringBuilder();
if (hour>0){
if (hour < 10) {
sb.append("0").append(hour).append(":");
} else {
sb.append(hour).append(":");
}
}
if (minute>0){
if (minute < 10) {
sb.append("0").append(minute).append(":");
} else {
sb.append(minute).append(":");
}
}
if (second < 10) {
sb.append("0").append(second);
} else {
sb.append(second);
}
return sb.toString();
}
/**
* 获取当前的播放核心
*/
public static Object getCurrentPlayerFactory() {
VideoPlayerConfig config = VideoViewManager.getConfig();
Object playerFactory = null;
try {
Field mPlayerFactoryField = config.getClass().getDeclaredField("mPlayerFactory");
mPlayerFactoryField.setAccessible(true);
playerFactory = mPlayerFactoryField.get(config);
} catch (Exception e) {
e.printStackTrace();
}
return playerFactory;
}
/**
* 将View从父控件中移除
*/
public static void removeViewFormParent(View v) {
if (v == null) {
return;
}
ViewParent parent = v.getParent();
if (parent instanceof FrameLayout) {
((FrameLayout) parent).removeView(v);
}
}
public static String playState2str(int state) {
String playStateString;
switch (state) {
default:
case ConstantKeys.CurrentState.STATE_IDLE:
playStateString = "idle";
break;
case ConstantKeys.CurrentState.STATE_PREPARING:
playStateString = "preparing";
break;
case ConstantKeys.CurrentState.STATE_PREPARED:
playStateString = "prepared";
break;
case ConstantKeys.CurrentState.STATE_PLAYING:
playStateString = "playing";
break;
case ConstantKeys.CurrentState.STATE_PAUSED:
playStateString = "pause";
break;
case ConstantKeys.CurrentState.STATE_BUFFERING_PAUSED:
playStateString = "buffering";
break;
case ConstantKeys.CurrentState.STATE_COMPLETED:
playStateString = "buffered";
break;
case ConstantKeys.CurrentState.STATE_BUFFERING_PLAYING:
playStateString = "playback completed";
break;
case ConstantKeys.CurrentState.STATE_ERROR:
playStateString = "error";
break;
}
return String.format("playState: %s", playStateString);
}
public static String playerState2str(int state) {
String playerStateString;
switch (state) {
default:
case ConstantKeys.PlayMode.MODE_NORMAL:
playerStateString = "normal";
break;
case ConstantKeys.PlayMode.MODE_FULL_SCREEN:
playerStateString = "full screen";
break;
case ConstantKeys.PlayMode.MODE_TINY_WINDOW:
playerStateString = "tiny screen";
break;
}
return String.format("playerState: %s", playerStateString);
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/tool/StatesCutoutUtils.java | Java | package com.yc.video.tool;
import android.annotation.SuppressLint;
import android.app.Activity;
import android.content.Context;
import android.graphics.Rect;
import android.os.Build;
import android.view.DisplayCutout;
import android.view.Window;
import android.view.WindowInsets;
import android.view.WindowManager;
import java.lang.reflect.Method;
import java.util.List;
/**
* 刘海屏工具
*/
public final class StatesCutoutUtils {
private StatesCutoutUtils() {
}
/**
* 是否为允许全屏界面显示内容到刘海区域的刘海屏机型（与AndroidManifest中配置对应）
*/
public static boolean allowDisplayToCutout(Activity activity) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
// 9.0系统全屏界面默认会保留黑边，不允许显示内容到刘海区域
Window window = activity.getWindow();
WindowInsets windowInsets = window.getDecorView().getRootWindowInsets();
if (windowInsets == null) {
return false;
}
DisplayCutout displayCutout = windowInsets.getDisplayCutout();
if (displayCutout == null) {
return false;
}
List<Rect> boundingRects = displayCutout.getBoundingRects();
return boundingRects.size() > 0;
} else {
return hasCutoutHuawei(activity)
|| hasCutoutOPPO(activity)
|| hasCutoutVIVO(activity)
|| hasCutoutXIAOMI(activity);
}
}
/**
* 是否是华为刘海屏机型
*/
@SuppressWarnings("unchecked")
private static boolean hasCutoutHuawei(Activity activity) {
if (!Build.MANUFACTURER.equalsIgnoreCase("HUAWEI")) {
return false;
}
try {
ClassLoader cl = activity.getClassLoader();
Class HwNotchSizeUtil = cl.loadClass("com.huawei.android.util.HwNotchSizeUtil");
if (HwNotchSizeUtil != null) {
Method get = HwNotchSizeUtil.getMethod("hasNotchInScreen");
return (boolean) get.invoke(HwNotchSizeUtil);
}
return false;
} catch (Exception e) {
return false;
}
}
/**
* 是否是oppo刘海屏机型
*/
private static boolean hasCutoutOPPO(Activity activity) {
if (!Build.MANUFACTURER.equalsIgnoreCase("oppo")) {
return false;
}
return activity.getPackageManager().hasSystemFeature("com.oppo.feature.screen.heteromorphism");
}
/**
* 是否是vivo刘海屏机型
*/
@SuppressWarnings("unchecked")
@SuppressLint("PrivateApi")
private static boolean hasCutoutVIVO(Activity activity) {
if (!Build.MANUFACTURER.equalsIgnoreCase("vivo")) {
return false;
}
try {
ClassLoader cl = activity.getClassLoader();
Class ftFeatureUtil = cl.loadClass("android.util.FtFeature");
if (ftFeatureUtil != null) {
Method get = ftFeatureUtil.getMethod("isFeatureSupport", int.class);
return (boolean) get.invoke(ftFeatureUtil, 0x00000020);
}
return false;
} catch (Exception e) {
return false;
}
}
/**
* 是否是小米刘海屏机型
*/
@SuppressWarnings("unchecked")
@SuppressLint("PrivateApi")
private static boolean hasCutoutXIAOMI(Activity activity) {
if (!Build.MANUFACTURER.equalsIgnoreCase("xiaomi")) {
return false;
}
try {
ClassLoader cl = activity.getClassLoader();
Class SystemProperties = cl.loadClass("android.os.SystemProperties");
Class[] paramTypes = new Class[2];
paramTypes[0] = String.class;
paramTypes[1] = int.class;
Method getInt = SystemProperties.getMethod("getInt", paramTypes);
//参数
Object[] params = new Object[2];
params[0] = "ro.miui.notch";
params[1] = 0;
int hasCutout = (int) getInt.invoke(SystemProperties, params);
return hasCutout == 1;
} catch (Exception e) {
return false;
}
}
/**
* 适配刘海屏，针对Android P以上系统
*/
public static void adaptCutoutAboveAndroidP(Context context, boolean isAdapt) {
Activity activity = PlayerUtils.scanForActivity(context);
if (activity == null) return;
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
WindowManager.LayoutParams lp = activity.getWindow().getAttributes();
if (isAdapt) {
lp.layoutInDisplayCutoutMode = WindowManager.LayoutParams.LAYOUT_IN_DISPLAY_CUTOUT_MODE_SHORT_EDGES;
} else {
lp.layoutInDisplayCutoutMode = WindowManager.LayoutParams.LAYOUT_IN_DISPLAY_CUTOUT_MODE_DEFAULT;
}
activity.getWindow().setAttributes(lp);
}
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/tool/VideoException.java | Java | package com.yc.video.tool;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2018/11/9
* desc : 播放器异常
* revise: 抛出异常并且供开发者快捷查询异常定位代码
* </pre>
*/
public class VideoException extends RuntimeException {
private int mCode = 0;
public VideoException(int code, String msg) {
super(msg);
mCode = code;
}
@Deprecated
public VideoException(String msg) {
super(msg);
}
public VideoException(Throwable throwable) {
super(throwable);
if (throwable instanceof VideoException) {
mCode = ((VideoException) throwable).getCode();
}
}
public int getCode() {
return mCode;
}
public String getMsg() {
return getMessage();
}
//自定义RenderView不能设置为null
public static final int CODE_NOT_RENDER_FACTORY = 19;
//PlayerFactory不能设置为null
public static final int CODE_NOT_PLAYER_FACTORY = 20;
//VideoPlayer，需要在start播放前给设置控制器Controller
public static final int CODE_NOT_SET_CONTROLLER = 21;
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/ui/more/CustomNetworkView.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.video.ui.more;
import android.content.Context;
import android.util.AttributeSet;
import android.view.View;
import android.view.animation.Animation;
import android.widget.FrameLayout;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import com.yc.video.bridge.ControlWrapper;
import com.yc.video.ui.view.InterControlView;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2017/11/9
* desc : 网络变化提示对话框。当网络由wifi变为4g的时候会显示
* revise:
* </pre>
*/
public class CustomNetworkView extends FrameLayout implements InterControlView, View.OnClickListener {
public CustomNetworkView(@NonNull Context context) {
super(context);
}
public CustomNetworkView(@NonNull Context context, @Nullable AttributeSet attrs) {
super(context, attrs);
}
public CustomNetworkView(@NonNull Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
}
@Override
public void attach(@NonNull ControlWrapper controlWrapper) {
}
@Override
public View getView() {
return null;
}
@Override
public void onVisibilityChanged(boolean isVisible, Animation anim) {
}
@Override
public void onPlayStateChanged(int playState) {
}
@Override
public void onPlayerStateChanged(int playerState) {
}
@Override
public void setProgress(int duration, int position) {
}
@Override
public void onLockStateChanged(boolean isLocked) {
}
@Override
public void onClick(View v) {
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/ui/more/CustomTrailersView.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.video.ui.more;
import android.content.Context;
import android.util.AttributeSet;
import android.view.View;
import android.view.animation.Animation;
import android.widget.FrameLayout;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import com.yc.video.bridge.ControlWrapper;
import com.yc.video.ui.view.InterControlView;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2017/11/9
* desc : 试看
* revise:
* </pre>
*/
public class CustomTrailersView extends FrameLayout implements InterControlView, View.OnClickListener {
public CustomTrailersView(@NonNull Context context) {
super(context);
}
public CustomTrailersView(@NonNull Context context, @Nullable AttributeSet attrs) {
super(context, attrs);
}
public CustomTrailersView(@NonNull Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
}
@Override
public void attach(@NonNull ControlWrapper controlWrapper) {
}
@Override
public View getView() {
return null;
}
@Override
public void onVisibilityChanged(boolean isVisible, Animation anim) {
}
@Override
public void onPlayStateChanged(int playState) {
}
@Override
public void onPlayerStateChanged(int playerState) {
}
@Override
public void setProgress(int duration, int position) {
}
@Override
public void onLockStateChanged(boolean isLocked) {
}
@Override
public void onClick(View v) {
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/ui/pip/CustomFloatController.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.video.ui.pip;
import android.content.Context;
import android.util.AttributeSet;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import com.yc.video.controller.GestureVideoController;
import com.yc.video.ui.view.CustomCompleteView;
import com.yc.video.ui.view.CustomErrorView;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2017/11/9
* desc : 悬浮播放控制器
* revise:
* </pre>
*/
public class CustomFloatController extends GestureVideoController {
public CustomFloatController(@NonNull Context context) {
super(context);
}
public CustomFloatController(@NonNull Context context, @Nullable AttributeSet attrs) {
super(context, attrs);
}
@Override
protected int getLayoutId() {
return 0;
}
@Override
protected void initView(Context context) {
super.initView(context);
addControlComponent(new CustomCompleteView(getContext()));
addControlComponent(new CustomErrorView(getContext()));
addControlComponent(new CustomFloatView(getContext()));
}
@Override
public void destroy() {
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/ui/pip/CustomFloatView.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.video.ui.pip;
import android.content.Context;
import android.content.Intent;
import android.os.Build;
import android.util.AttributeSet;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.view.animation.AlphaAnimation;
import android.view.animation.Animation;
import android.widget.FrameLayout;
import android.widget.ImageView;
import android.widget.ProgressBar;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import com.yc.video.config.ConstantKeys;
import com.yc.video.bridge.ControlWrapper;
import com.yc.video.R;
import com.yc.video.ui.view.InterControlView;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2017/11/9
* desc : 悬浮窗视图
* revise:
* </pre>
*/
public class CustomFloatView extends FrameLayout implements InterControlView, View.OnClickListener {
private ControlWrapper mControlWrapper;
private Context mContext;
private ImageView mIvStartPlay;
private ProgressBar mPbLoading;
private ImageView mIvClose;
private ImageView mIvSkip;
private ProgressBar mPbBottomProgress;
private boolean mIsShowBottomProgress = true;
public CustomFloatView(@NonNull Context context) {
super(context);
init(context);
}
public CustomFloatView(@NonNull Context context, @Nullable AttributeSet attrs) {
super(context, attrs);
init(context);
}
public CustomFloatView(@NonNull Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
init(context);
}
private void init(Context context){
this.mContext = context;
View view = LayoutInflater.from(getContext()).inflate(
R.layout.custom_video_player_float, this, true);
initFindViewById(view);
initListener();
//5.1以下系统SeekBar高度需要设置成WRAP_CONTENT
if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.LOLLIPOP_MR1) {
mPbBottomProgress.getLayoutParams().height = ViewGroup.LayoutParams.WRAP_CONTENT;
}
}
private void initFindViewById(View view) {
mIvStartPlay = view.findViewById(R.id.iv_start_play);
mPbLoading = view.findViewById(R.id.pb_loading);
mIvClose = view.findViewById(R.id.iv_close);
mIvSkip = view.findViewById(R.id.iv_skip);
mPbBottomProgress = view.findViewById(R.id.pb_bottom_progress);
}
private void initListener() {
mIvStartPlay.setOnClickListener(this);
mIvClose.setOnClickListener(this);
mIvSkip.setOnClickListener(this);
}
@Override
public void onClick(View v) {
if (v == mIvClose) {
FloatVideoManager.getInstance(mContext).stopFloatWindow();
FloatVideoManager.getInstance(mContext).reset();
} else if (v == mIvStartPlay) {
mControlWrapper.togglePlay();
} else if (v == mIvSkip) {
if (FloatVideoManager.getInstance(mContext).getActClass() != null) {
Intent intent = new Intent(getContext(), FloatVideoManager.getInstance(mContext).getActClass());
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
getContext().startActivity(intent);
}
}
}
@Override
public void attach(@NonNull ControlWrapper controlWrapper) {
mControlWrapper = controlWrapper;
}
@Override
public View getView() {
return this;
}
@Override
public void onVisibilityChanged(boolean isVisible, Animation anim) {
if (isVisible) {
if (mIvStartPlay.getVisibility() == VISIBLE){
return;
}
mIvStartPlay.setVisibility(VISIBLE);
mIvStartPlay.startAnimation(anim);
if (mIsShowBottomProgress) {
mPbBottomProgress.setVisibility(GONE);
}
} else {
if (mIvStartPlay.getVisibility() == GONE){
return;
}
mIvStartPlay.setVisibility(GONE);
mIvStartPlay.startAnimation(anim);
if (mIsShowBottomProgress) {
mPbBottomProgress.setVisibility(VISIBLE);
AlphaAnimation animation = new AlphaAnimation(0f, 1f);
animation.setDuration(300);
mPbBottomProgress.startAnimation(animation);
}
}
}
@Override
public void onPlayStateChanged(int playState) {
switch (playState) {
case ConstantKeys.CurrentState.STATE_IDLE:
mIvStartPlay.setSelected(false);
mIvStartPlay.setVisibility(VISIBLE);
mPbLoading.setVisibility(GONE);
break;
case ConstantKeys.CurrentState.STATE_PLAYING:
mIvStartPlay.setSelected(true);
mIvStartPlay.setVisibility(GONE);
mPbLoading.setVisibility(GONE);
if (mIsShowBottomProgress) {
if (mControlWrapper.isShowing()) {
mPbBottomProgress.setVisibility(GONE);
} else {
mPbBottomProgress.setVisibility(VISIBLE);
}
}
//开始刷新进度
mControlWrapper.startProgress();
break;
case ConstantKeys.CurrentState.STATE_PAUSED:
mIvStartPlay.setSelected(false);
mIvStartPlay.setVisibility(VISIBLE);
mPbLoading.setVisibility(GONE);
break;
case ConstantKeys.CurrentState.STATE_PREPARING:
mIvStartPlay.setVisibility(GONE);
mIvStartPlay.setVisibility(VISIBLE);
break;
case ConstantKeys.CurrentState.STATE_PREPARED:
mIvStartPlay.setVisibility(GONE);
mPbLoading.setVisibility(GONE);
break;
case ConstantKeys.CurrentState.STATE_ERROR:
mPbLoading.setVisibility(GONE);
mIvStartPlay.setVisibility(GONE);
bringToFront();
break;
case ConstantKeys.CurrentState.STATE_BUFFERING_PAUSED:
mIvStartPlay.setVisibility(GONE);
mPbLoading.setVisibility(VISIBLE);
break;
case ConstantKeys.CurrentState.STATE_COMPLETED:
mIvStartPlay.setVisibility(GONE);
mPbLoading.setVisibility(GONE);
mIvStartPlay.setSelected(mControlWrapper.isPlaying());
break;
case ConstantKeys.CurrentState.STATE_BUFFERING_PLAYING:
bringToFront();
mPbBottomProgress.setProgress(0);
mPbBottomProgress.setSecondaryProgress(0);
break;
}
}
@Override
public void onPlayerStateChanged(int playerState) {
}
@Override
public void setProgress(int duration, int position) {
if (duration > 0) {
int pos = (int) (position * 1.0 / duration * mPbBottomProgress.getMax());
mPbBottomProgress.setProgress(pos);
}
int percent = mControlWrapper.getBufferedPercentage();
if (percent >= 95) {
//解决缓冲进度不能100%问题
mPbBottomProgress.setSecondaryProgress(mPbBottomProgress.getMax());
} else {
mPbBottomProgress.setSecondaryProgress(percent * 10);
}
}
@Override
public void onLockStateChanged(boolean isLocked) {
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/ui/pip/FloatVideoManager.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.video.ui.pip;
import android.content.Context;
import android.view.View;
import com.yc.video.player.VideoPlayer;
import com.yc.video.player.VideoViewManager;
import com.yc.video.tool.PlayerUtils;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2017/11/9
* desc : 悬浮播放
* revise:
* </pre>
*/
public class FloatVideoManager {
//画中画
public static final String PIP = "pip";
private static FloatVideoManager instance;
private VideoPlayer mVideoPlayer;
private FloatVideoView mFloatView;
private CustomFloatController mFloatController;
private boolean mIsShowing;
private int mPlayingPosition = -1;
private Class mActClass;
private FloatVideoManager(Context context) {
mVideoPlayer = new VideoPlayer(context);
VideoViewManager.instance().add(mVideoPlayer, PIP);
mFloatController = new CustomFloatController(context);
mFloatView = new FloatVideoView(context, 0, 0);
}
public static FloatVideoManager getInstance(Context context) {
if (instance == null) {
synchronized (FloatVideoManager.class) {
if (instance == null) {
instance = new FloatVideoManager(context);
}
}
}
return instance;
}
public void startFloatWindow() {
if (mIsShowing) {
return;
}
PlayerUtils.removeViewFormParent(mVideoPlayer);
mVideoPlayer.setController(mFloatController);
mFloatController.setPlayState(mVideoPlayer.getCurrentPlayState());
mFloatController.setPlayerState(mVideoPlayer.getCurrentPlayerState());
mFloatView.addView(mVideoPlayer);
mFloatView.addToWindow();
mIsShowing = true;
}
public void stopFloatWindow() {
if (!mIsShowing) {
return;
}
mFloatView.removeFromWindow();
PlayerUtils.removeViewFormParent(mVideoPlayer);
mIsShowing = false;
}
public void setPlayingPosition(int position) {
this.mPlayingPosition = position;
}
public int getPlayingPosition() {
return mPlayingPosition;
}
public void pause() {
if (mIsShowing) {
return;
}
mVideoPlayer.pause();
}
public void resume() {
if (mIsShowing) {
return;
}
mVideoPlayer.resume();
}
public void reset() {
if (mIsShowing){
return;
}
PlayerUtils.removeViewFormParent(mVideoPlayer);
mVideoPlayer.release();
mVideoPlayer.setController(null);
mPlayingPosition = -1;
mActClass = null;
}
public boolean onBackPress() {
return !mIsShowing && mVideoPlayer.onBackPressed();
}
public boolean isStartFloatWindow() {
return mIsShowing;
}
/**
* 显示悬浮窗
*/
public void setFloatViewVisible() {
if (mIsShowing) {
mVideoPlayer.resume();
mFloatView.setVisibility(View.VISIBLE);
}
}
public void setActClass(Class cls) {
this.mActClass = cls;
}
public Class getActClass() {
return mActClass;
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/ui/pip/FloatVideoView.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.video.ui.pip;
import android.annotation.SuppressLint;
import android.content.Context;
import android.graphics.PixelFormat;
import android.os.Build;
import android.view.Gravity;
import android.view.MotionEvent;
import android.view.ViewConfiguration;
import android.view.WindowManager;
import android.widget.FrameLayout;
import androidx.annotation.NonNull;
import com.yc.video.tool.PlayerUtils;
import com.yc.video.R;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2017/11/9
* desc : 悬浮窗控件（解决滑动冲突）
* revise:
* </pre>
*/
@SuppressLint("ViewConstructor")
public class FloatVideoView extends FrameLayout{
private WindowManager mWindowManager;
private WindowManager.LayoutParams mParams;
private int mDownRawX, mDownRawY;//手指按下时相对于屏幕的坐标
private int mDownX, mDownY;//手指按下时相对于悬浮窗的坐标
public FloatVideoView(@NonNull Context context, int x, int y) {
super(context);
mDownX = x;
mDownY = y;
init();
}
private void init() {
setBackgroundResource(R.drawable.shape_float_window_bg);
int padding = PlayerUtils.dp2px(getContext(), 1);
setPadding(padding, padding, padding, padding);
initWindow();
}
private void initWindow() {
mWindowManager = PlayerUtils.getWindowManager(getContext().getApplicationContext());
mParams = new WindowManager.LayoutParams();
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O){
mParams.type = WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY;
}else {
mParams.type = WindowManager.LayoutParams.TYPE_SYSTEM_ALERT;
}
// 设置图片格式，效果为背景透明
mParams.format = PixelFormat.TRANSLUCENT;
mParams.flags = WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE;
mParams.windowAnimations = R.style.FloatWindowAnimation;
mParams.gravity = Gravity.START | Gravity.TOP; // 调整悬浮窗口至右下角
// 设置悬浮窗口长宽数据
int width = PlayerUtils.dp2px(getContext(), 250);
mParams.width = width;
mParams.height = width * 9 / 16;
mParams.x = mDownX;
mParams.y = mDownY;
}
/**
* 添加至窗口
*/
public boolean addToWindow() {
if (mWindowManager != null) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
if (!isAttachedToWindow()) {
mWindowManager.addView(this, mParams);
return true;
} else {
return false;
}
} else {
try {
if (getParent() == null) {
mWindowManager.addView(this, mParams);
}
return true;
} catch (Exception e) {
return false;
}
}
} else {
return false;
}
}
/**
* 从窗口移除
*/
public boolean removeFromWindow() {
if (mWindowManager != null) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
if (isAttachedToWindow()) {
mWindowManager.removeViewImmediate(this);
return true;
} else {
return false;
}
} else {
try {
if (getParent() != null) {
mWindowManager.removeViewImmediate(this);
}
return true;
} catch (Exception e) {
return false;
}
}
} else {
return false;
}
}
@Override
public boolean onInterceptTouchEvent(MotionEvent ev) {
boolean intercepted = false;
switch (ev.getAction()) {
case MotionEvent.ACTION_DOWN:
intercepted = false;
mDownRawX = (int) ev.getRawX();
mDownRawY = (int) ev.getRawY();
mDownX = (int) ev.getX();
mDownY = (int) (ev.getY() + PlayerUtils.getStatusBarHeight(getContext()));
break;
case MotionEvent.ACTION_MOVE:
float absDeltaX = Math.abs(ev.getRawX() - mDownRawX);
float absDeltaY = Math.abs(ev.getRawY() - mDownRawY);
intercepted = absDeltaX > ViewConfiguration.get(getContext()).getScaledTouchSlop() ||
absDeltaY > ViewConfiguration.get(getContext()).getScaledTouchSlop();
break;
}
return intercepted;
}
@Override
public boolean onTouchEvent(MotionEvent event) {
switch (event.getAction()) {
case MotionEvent.ACTION_MOVE:
int x = (int) event.getRawX();
int y = (int) event.getRawY();
mParams.x = x - mDownX;
mParams.y = y - mDownY;
mWindowManager.updateViewLayout(this, mParams);
break;
}
return super.onTouchEvent(event);
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/ui/view/BasisVideoController.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.video.ui.view;
import android.app.Activity;
import android.content.Context;
import android.content.pm.ActivityInfo;
import android.util.AttributeSet;
import android.util.Log;
import android.view.View;
import android.view.ViewGroup;
import android.view.animation.Animation;
import android.widget.FrameLayout;
import android.widget.ImageView;
import android.widget.ProgressBar;
import android.widget.TextView;
import androidx.annotation.AttrRes;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import com.yc.video.config.ConstantKeys;
import com.yc.video.config.VideoPlayerConfig;
import com.yc.video.controller.GestureVideoController;
import com.yc.video.tool.BaseToast;
import com.yc.video.tool.PlayerUtils;
import com.yc.video.R;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2017/11/9
* desc : 控制条界面。包括了顶部的标题栏，底部 的控制栏，锁屏按钮等等。
* 是界面的主要组成部分。
* revise: 如果想定制ui，你可以直接继承GestureVideoController或者BaseVideoController实现
* </pre>
*/
public class BasisVideoController extends GestureVideoController implements View.OnClickListener {
private Context mContext;
private ImageView mLockButton;
private ProgressBar mLoadingProgress;
private ImageView thumb;
private CustomTitleView titleView;
private CustomBottomView vodControlView;
private CustomLiveControlView liveControlView;
private CustomOncePlayView customOncePlayView;
private TextView tvLiveWaitMessage;
/**
* 是否是直播，默认不是
*/
public static boolean IS_LIVE = false;
public BasisVideoController(@NonNull Context context) {
this(context, null);
}
public BasisVideoController(@NonNull Context context, @Nullable AttributeSet attrs) {
this(context, attrs, 0);
}
public BasisVideoController(@NonNull Context context, @Nullable AttributeSet attrs, @AttrRes int defStyleAttr) {
super(context, attrs, defStyleAttr);
}
@Override
protected int getLayoutId() {
return R.layout.custom_video_player_standard;
}
@Override
protected void initView(Context context) {
super.initView(context);
this.mContext = context;
initFindViewById();
initListener();
initConfig();
}
private void initFindViewById() {
mLockButton = findViewById(R.id.lock);
mLoadingProgress = findViewById(R.id.loading);
}
private void initListener() {
mLockButton.setOnClickListener(this);
}
private void initConfig() {
//根据屏幕方向自动进入/退出全屏
setEnableOrientation(true);
//设置可以滑动调节进度
setCanChangePosition(true);
//竖屏也开启手势操作，默认关闭
setEnableInNormal(true);
//滑动调节亮度，音量，进度，默认开启
setGestureEnabled(true);
//先移除多有的视图view
removeAllControlComponent();
//添加视图到界面
addDefaultControlComponent("");
}
/**
* 快速添加各个组件
* 需要注意各个层级
* @param title 标题
*/
public void addDefaultControlComponent(String title) {
//添加自动完成播放界面view
CustomCompleteView completeView = new CustomCompleteView(mContext);
completeView.setVisibility(GONE);
this.addControlComponent(completeView);
//添加错误界面view
CustomErrorView errorView = new CustomErrorView(mContext);
errorView.setVisibility(GONE);
this.addControlComponent(errorView);
//添加与加载视图界面view，准备播放界面
CustomPrepareView prepareView = new CustomPrepareView(mContext);
thumb = prepareView.getThumb();
prepareView.setClickStart();
this.addControlComponent(prepareView);
//添加标题栏
titleView = new CustomTitleView(mContext);
titleView.setTitle(title);
titleView.setVisibility(VISIBLE);
this.addControlComponent(titleView);
//添加直播/回放视频底部控制视图
changePlayType();
//添加滑动控制视图
CustomGestureView gestureControlView = new CustomGestureView(mContext);
this.addControlComponent(gestureControlView);
}
/**
* 切换直播/回放类型
*/
public void changePlayType(){
if (IS_LIVE) {
//添加底部播放控制条
if (liveControlView==null){
liveControlView = new CustomLiveControlView(mContext);
}
this.removeControlComponent(liveControlView);
this.addControlComponent(liveControlView);
//添加直播还未开始视图
if (customOncePlayView==null){
customOncePlayView = new CustomOncePlayView(mContext);
tvLiveWaitMessage = customOncePlayView.getTvMessage();
}
this.removeControlComponent(customOncePlayView);
this.addControlComponent(customOncePlayView);
//直播视频，移除回放视图
if (vodControlView!=null){
this.removeControlComponent(vodControlView);
}
} else {
//添加底部播放控制条
if (vodControlView==null){
vodControlView = new CustomBottomView(mContext);
//是否显示底部进度条。默认显示
vodControlView.showBottomProgress(true);
}
this.removeControlComponent(vodControlView);
this.addControlComponent(vodControlView);
//正常视频，移除直播视图
if (liveControlView!=null){
this.removeControlComponent(liveControlView);
}
if (customOncePlayView!=null){
this.removeControlComponent(customOncePlayView);
}
}
setCanChangePosition(!IS_LIVE);
}
@Override
public void onClick(View v) {
int i = v.getId();
if (i == R.id.lock) {
mControlWrapper.toggleLockState();
}
}
@Override
protected void onLockStateChanged(boolean isLocked) {
if (isLocked) {
mLockButton.setSelected(true);
String string = mContext.getResources().getString(R.string.locked);
BaseToast.showRoundRectToast(string);
} else {
mLockButton.setSelected(false);
String string = mContext.getResources().getString(R.string.unlocked);
BaseToast.showRoundRectToast(string);
}
}
@Override
protected void onVisibilityChanged(boolean isVisible, Animation anim) {
if (mControlWrapper.isFullScreen()) {
if (isVisible) {
if (mLockButton.getVisibility() == GONE) {
mLockButton.setVisibility(VISIBLE);
if (anim != null) {
mLockButton.startAnimation(anim);
}
}
} else {
mLockButton.setVisibility(GONE);
if (anim != null) {
mLockButton.startAnimation(anim);
}
}
}
}
/**
* 播放模式
* 普通模式，小窗口模式，正常模式三种其中一种
* MODE_NORMAL 普通模式
* MODE_FULL_SCREEN 全屏模式
* MODE_TINY_WINDOW 小屏模式
* @param playerState 播放模式
*/
@Override
protected void onPlayerStateChanged(int playerState) {
super.onPlayerStateChanged(playerState);
switch (playerState) {
case ConstantKeys.PlayMode.MODE_NORMAL:
setLayoutParams(new FrameLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT));
mLockButton.setVisibility(GONE);
break;
case ConstantKeys.PlayMode.MODE_FULL_SCREEN:
if (isShowing()) {
mLockButton.setVisibility(VISIBLE);
} else {
mLockButton.setVisibility(GONE);
}
break;
}
if (mActivity != null && hasCutout()) {
int orientation = mActivity.getRequestedOrientation();
int dp24 = PlayerUtils.dp2px(getContext(), 24);
int cutoutHeight = getCutoutHeight();
if (orientation == ActivityInfo.SCREEN_ORIENTATION_PORTRAIT) {
FrameLayout.LayoutParams lblp = (FrameLayout.LayoutParams) mLockButton.getLayoutParams();
lblp.setMargins(dp24, 0, dp24, 0);
} else if (orientation == ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE) {
FrameLayout.LayoutParams layoutParams = (FrameLayout.LayoutParams) mLockButton.getLayoutParams();
layoutParams.setMargins(dp24 + cutoutHeight, 0, dp24 + cutoutHeight, 0);
} else if (orientation == ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE) {
FrameLayout.LayoutParams layoutParams = (FrameLayout.LayoutParams) mLockButton.getLayoutParams();
layoutParams.setMargins(dp24, 0, dp24, 0);
}
}
}
/**
* 播放状态
* -1 播放错误
* 0 播放未开始
* 1 播放准备中
* 2 播放准备就绪
* 3 正在播放
* 4 暂停播放
* 5 正在缓冲(播放器正在播放时，缓冲区数据不足，进行缓冲，缓冲区数据足够后恢复播放)
* 6 暂停缓冲(播放器正在播放时，缓冲区数据不足，进行缓冲，此时暂停播放器，继续缓冲，缓冲区数据足够后恢复暂停
* 7 播放完成
* 8 开始播放中止
* @param playState 播放状态，主要是指播放器的各种状态
*/
@Override
protected void onPlayStateChanged(int playState) {
super.onPlayStateChanged(playState);
switch (playState) {
//调用release方法会回到此状态
case ConstantKeys.CurrentState.STATE_IDLE:
mLockButton.setSelected(false);
mLoadingProgress.setVisibility(GONE);
break;
case ConstantKeys.CurrentState.STATE_PLAYING:
case ConstantKeys.CurrentState.STATE_PAUSED:
case ConstantKeys.CurrentState.STATE_PREPARED:
case ConstantKeys.CurrentState.STATE_ERROR:
case ConstantKeys.CurrentState.STATE_COMPLETED:
mLoadingProgress.setVisibility(GONE);
break;
case ConstantKeys.CurrentState.STATE_PREPARING:
case ConstantKeys.CurrentState.STATE_BUFFERING_PAUSED:
mLoadingProgress.setVisibility(VISIBLE);
break;
case ConstantKeys.CurrentState.STATE_BUFFERING_PLAYING:
mLoadingProgress.setVisibility(GONE);
mLockButton.setVisibility(GONE);
mLockButton.setSelected(false);
break;
}
}
@Override
public boolean onBackPressed() {
if (isLocked()) {
show();
String string = mContext.getResources().getString(R.string.lock_tip);
BaseToast.showRoundRectToast(string);
return true;
}
if (mControlWrapper.isFullScreen()) {
return stopFullScreen();
}
Activity activity = PlayerUtils.scanForActivity(getContext());
//如果不是全屏模式，则直接关闭页面activity
if (PlayerUtils.isActivityLiving(activity)){
activity.finish();
}
return super.onBackPressed();
}
/**
* 刷新进度回调，子类可在此方法监听进度刷新，然后更新ui
*
* @param duration 视频总时长
* @param position 视频当前时长
*/
@Override
protected void setProgress(int duration, int position) {
super.setProgress(duration, position);
}
@Override
public void destroy() {
}
public ImageView getThumb() {
return thumb;
}
public void setTitle(String title) {
if (titleView!=null){
titleView.setTitle(title);
}
}
public CustomBottomView getBottomView() {
return vodControlView;
}
public TextView getTvLiveWaitMessage() {
return tvLiveWaitMessage;
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/ui/view/CustomBottomView.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.video.ui.view;
import android.app.Activity;
import android.content.Context;
import android.content.pm.ActivityInfo;
import android.os.Build;
import android.util.AttributeSet;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.view.animation.AlphaAnimation;
import android.view.animation.Animation;
import android.widget.FrameLayout;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.ProgressBar;
import android.widget.SeekBar;
import android.widget.TextView;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import com.yc.video.config.ConstantKeys;
import com.yc.video.bridge.ControlWrapper;
import com.yc.video.config.VideoPlayerConfig;
import com.yc.video.tool.PlayerUtils;
import com.yc.video.R;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2017/11/9
* desc : 底部控制栏视图
* revise: 用于普通播放器
* </pre>
*/
public class CustomBottomView extends FrameLayout implements InterControlView,
View.OnClickListener, SeekBar.OnSeekBarChangeListener {
private Context mContext;
protected ControlWrapper mControlWrapper;
private LinearLayout mLlBottomContainer;
private ImageView mIvPlay;
private TextView mTvCurrTime;
private SeekBar mSeekBar;
private TextView mTvTotalTime;
private TextView mTvClarity;
private ImageView mIvFullscreen;
private ProgressBar mPbBottomProgress;
private boolean mIsDragging;
private boolean mIsShowBottomProgress = true;
public CustomBottomView(@NonNull Context context) {
super(context);
init(context);
}
public CustomBottomView(@NonNull Context context, @Nullable AttributeSet attrs) {
super(context, attrs);
init(context);
}
public CustomBottomView(@NonNull Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
init(context);
}
private void init(Context context){
this.mContext = context;
setVisibility(GONE);
View view = LayoutInflater.from(getContext()).inflate(getLayoutId(), this, true);
initFindViewById(view);
initListener();
//5.1以下系统SeekBar高度需要设置成WRAP_CONTENT
if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.LOLLIPOP_MR1) {
mPbBottomProgress.getLayoutParams().height = ViewGroup.LayoutParams.WRAP_CONTENT;
}
}
private void initFindViewById(View view) {
mLlBottomContainer = view.findViewById(R.id.ll_bottom_container);
mIvPlay = view.findViewById(R.id.iv_play);
mTvCurrTime = view.findViewById(R.id.tv_curr_time);
mSeekBar = view.findViewById(R.id.seekBar);
mTvTotalTime = view.findViewById(R.id.tv_total_time);
mTvClarity = view.findViewById(R.id.tv_clarity);
mIvFullscreen = view.findViewById(R.id.iv_fullscreen);
mPbBottomProgress = view.findViewById(R.id.pb_bottom_progress);
}
private void initListener() {
mIvFullscreen.setOnClickListener(this);
mSeekBar.setOnSeekBarChangeListener(this);
mIvPlay.setOnClickListener(this);
}
@Override
public void onClick(View v) {
if (v == mIvFullscreen) {
toggleFullScreen();
} else if (v == mIvPlay) {
mControlWrapper.togglePlay();
}
}
protected int getLayoutId() {
return R.layout.custom_video_player_bottom;
}
/**
* 是否显示底部进度条，默认显示
*/
public void showBottomProgress(boolean isShow) {
mIsShowBottomProgress = isShow;
}
@Override
public void attach(@NonNull ControlWrapper controlWrapper) {
mControlWrapper = controlWrapper;
}
@Override
public View getView() {
return this;
}
@Override
public void onVisibilityChanged(boolean isVisible, Animation anim) {
if (isVisible) {
mLlBottomContainer.setVisibility(VISIBLE);
if (anim != null) {
mLlBottomContainer.startAnimation(anim);
}
if (mIsShowBottomProgress) {
mPbBottomProgress.setVisibility(GONE);
}
} else {
mLlBottomContainer.setVisibility(GONE);
if (anim != null) {
mLlBottomContainer.startAnimation(anim);
}
if (mIsShowBottomProgress) {
mPbBottomProgress.setVisibility(VISIBLE);
AlphaAnimation animation = new AlphaAnimation(0f, 1f);
animation.setDuration(300);
mPbBottomProgress.startAnimation(animation);
}
}
}
@Override
public void onPlayStateChanged(int playState) {
switch (playState) {
case ConstantKeys.CurrentState.STATE_IDLE:
case ConstantKeys.CurrentState.STATE_BUFFERING_PLAYING:
setVisibility(GONE);
mPbBottomProgress.setProgress(0);
mPbBottomProgress.setSecondaryProgress(0);
mSeekBar.setProgress(0);
mSeekBar.setSecondaryProgress(0);
break;
case ConstantKeys.CurrentState.STATE_START_ABORT:
case ConstantKeys.CurrentState.STATE_PREPARING:
case ConstantKeys.CurrentState.STATE_PREPARED:
case ConstantKeys.CurrentState.STATE_ERROR:
case ConstantKeys.CurrentState.STATE_ONCE_LIVE:
setVisibility(GONE);
break;
case ConstantKeys.CurrentState.STATE_PLAYING:
mIvPlay.setSelected(true);
if (mIsShowBottomProgress) {
if (mControlWrapper.isShowing()) {
mPbBottomProgress.setVisibility(GONE);
mLlBottomContainer.setVisibility(VISIBLE);
} else {
mLlBottomContainer.setVisibility(GONE);
mPbBottomProgress.setVisibility(VISIBLE);
}
} else {
mLlBottomContainer.setVisibility(GONE);
}
setVisibility(VISIBLE);
//开始刷新进度
mControlWrapper.startProgress();
break;
case ConstantKeys.CurrentState.STATE_PAUSED:
mIvPlay.setSelected(false);
break;
case ConstantKeys.CurrentState.STATE_BUFFERING_PAUSED:
case ConstantKeys.CurrentState.STATE_COMPLETED:
mIvPlay.setSelected(mControlWrapper.isPlaying());
break;
}
}
@Override
public void onPlayerStateChanged(int playerState) {
switch (playerState) {
case ConstantKeys.PlayMode.MODE_NORMAL:
mIvFullscreen.setSelected(false);
break;
case ConstantKeys.PlayMode.MODE_FULL_SCREEN:
mIvFullscreen.setSelected(true);
break;
}
Activity activity = PlayerUtils.scanForActivity(mContext);
if (activity != null && mControlWrapper.hasCutout()) {
int orientation = activity.getRequestedOrientation();
int cutoutHeight = mControlWrapper.getCutoutHeight();
if (orientation == ActivityInfo.SCREEN_ORIENTATION_PORTRAIT) {
mLlBottomContainer.setPadding(0, 0, 0, 0);
mPbBottomProgress.setPadding(0, 0, 0, 0);
} else if (orientation == ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE) {
mLlBottomContainer.setPadding(cutoutHeight, 0, 0, 0);
mPbBottomProgress.setPadding(cutoutHeight, 0, 0, 0);
} else if (orientation == ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE) {
mLlBottomContainer.setPadding(0, 0, cutoutHeight, 0);
mPbBottomProgress.setPadding(0, 0, cutoutHeight, 0);
}
}
}
/**
* 刷新进度回调，子类可在此方法监听进度刷新，然后更新ui
*
* @param duration 视频总时长
* @param position 视频当前时长
*/
@Override
public void setProgress(int duration, int position) {
if (mIsDragging) {
return;
}
if (mSeekBar != null) {
if (duration > 0) {
mSeekBar.setEnabled(true);
int pos = (int) (position * 1.0 / duration * mSeekBar.getMax());
mSeekBar.setProgress(pos);
mPbBottomProgress.setProgress(pos);
} else {
mSeekBar.setEnabled(false);
}
int percent = mControlWrapper.getBufferedPercentage();
if (percent >= 95) {
//解决缓冲进度不能100%问题
mSeekBar.setSecondaryProgress(mSeekBar.getMax());
mPbBottomProgress.setSecondaryProgress(mPbBottomProgress.getMax());
} else {
mSeekBar.setSecondaryProgress(percent * 10);
mPbBottomProgress.setSecondaryProgress(percent * 10);
}
}
if (mTvTotalTime != null){
mTvTotalTime.setText(PlayerUtils.formatTime(duration));
}
if (mTvCurrTime != null){
mTvCurrTime.setText(PlayerUtils.formatTime(position));
}
if (VideoPlayerConfig.newBuilder().build().mIsShowToast){
long time = VideoPlayerConfig.newBuilder().build().mShowToastTime;
if (time<=0){
time = 5;
}
long currentPosition = mControlWrapper.getCurrentPosition();
Log.d("progress---","duration---"+duration+"--currentPosition--"+currentPosition);
if (duration - currentPosition < 2 * time * 1000){
//当前视频播放到最后3s时，弹出toast提示：即将自动为您播放下一个视频。
if ((duration-currentPosition) / 1000 % 60 == time){
Log.d("progress---","即将自动为您播放下一个视频");
if (listener!= null){
listener.showToastOrDialog();
}
}
}
}
}
@Override
public void onLockStateChanged(boolean isLocked) {
onVisibilityChanged(!isLocked, null);
}
/**
* 横竖屏切换
*/
private void toggleFullScreen() {
Activity activity = PlayerUtils.scanForActivity(getContext());
mControlWrapper.toggleFullScreen(activity);
}
@Override
public void onStartTrackingTouch(SeekBar seekBar) {
mIsDragging = true;
mControlWrapper.stopProgress();
mControlWrapper.stopFadeOut();
}
@Override
public void onStopTrackingTouch(SeekBar seekBar) {
long duration = mControlWrapper.getDuration();
long newPosition = (duration * seekBar.getProgress()) / mPbBottomProgress.getMax();
mControlWrapper.seekTo((int) newPosition);
mIsDragging = false;
mControlWrapper.startProgress();
mControlWrapper.startFadeOut();
}
@Override
public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) {
if (!fromUser) {
return;
}
long duration = mControlWrapper.getDuration();
long newPosition = (duration * progress) / mPbBottomProgress.getMax();
if (mTvCurrTime != null){
mTvCurrTime.setText(PlayerUtils.formatTime(newPosition));
}
}
private OnToastListener listener;
public void setListener(OnToastListener listener) {
this.listener = listener;
}
public interface OnToastListener{
void showToastOrDialog();
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/ui/view/CustomCompleteView.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.video.ui.view;
import android.app.Activity;
import android.content.Context;
import android.content.pm.ActivityInfo;
import android.util.AttributeSet;
import android.view.LayoutInflater;
import android.view.View;
import android.view.animation.Animation;
import android.widget.FrameLayout;
import android.widget.ImageView;
import android.widget.LinearLayout;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import com.yc.video.config.ConstantKeys;
import com.yc.video.bridge.ControlWrapper;
import com.yc.video.tool.BaseToast;
import com.yc.video.tool.PlayerUtils;
import com.yc.video.R;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2017/11/9
* desc : 自动播放完成界面
* revise:
* </pre>
*/
public class CustomCompleteView extends FrameLayout implements InterControlView, View.OnClickListener {
private Context mContext;
private ControlWrapper mControlWrapper;
private FrameLayout mCompleteContainer;
private ImageView mIvStopFullscreen;
private LinearLayout mLlReplay;
private ImageView mIvReplay;
private LinearLayout mLlShare;
private ImageView mIvShare;
public CustomCompleteView(@NonNull Context context) {
super(context);
init(context);
}
public CustomCompleteView(@NonNull Context context, @Nullable AttributeSet attrs) {
super(context, attrs);
init(context);
}
public CustomCompleteView(@NonNull Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
init(context);
}
private void init(Context context){
this.mContext = context;
setVisibility(GONE);
View view = LayoutInflater.from(mContext).inflate(
R.layout.custom_video_player_completed, this, true);
initFindViewById(view);
initListener();
setClickable(true);
}
private void initFindViewById(View view) {
mCompleteContainer = view.findViewById(R.id.complete_container);
mIvStopFullscreen = view.findViewById(R.id.iv_stop_fullscreen);
mLlReplay = view.findViewById(R.id.ll_replay);
mIvReplay = view.findViewById(R.id.iv_replay);
mLlShare = view.findViewById(R.id.ll_share);
mIvShare = view.findViewById(R.id.iv_share);
}
private void initListener() {
mLlReplay.setOnClickListener(this);
mLlShare.setOnClickListener(this);
mIvStopFullscreen.setOnClickListener(this);
}
@Override
public void onClick(View v) {
if (v == mLlReplay){
//点击重播
mControlWrapper.replay(true);
} else if (v == mLlShare){
//点击分享
BaseToast.showRoundRectToast("点击分享，后期完善");
} else if (v == mIvStopFullscreen){
//点击返回键
if (mControlWrapper.isFullScreen()) {
Activity activity = PlayerUtils.scanForActivity(mContext);
if (activity != null && !activity.isFinishing()) {
activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
mControlWrapper.stopFullScreen();
}
}
}
}
@Override
public void attach(@NonNull ControlWrapper controlWrapper) {
mControlWrapper = controlWrapper;
}
@Override
public View getView() {
return this;
}
@Override
public void onVisibilityChanged(boolean isVisible, Animation anim) {
}
@Override
public void onPlayStateChanged(int playState) {
if (playState == ConstantKeys.CurrentState.STATE_BUFFERING_PLAYING) {
setVisibility(VISIBLE);
mIvStopFullscreen.setVisibility(mControlWrapper.isFullScreen() ? VISIBLE : GONE);
bringToFront();
} else {
setVisibility(GONE);
}
}
@Override
public void onPlayerStateChanged(int playerState) {
if (playerState == ConstantKeys.PlayMode.MODE_FULL_SCREEN) {
mIvStopFullscreen.setVisibility(VISIBLE);
} else if (playerState == ConstantKeys.PlayMode.MODE_NORMAL) {
mIvStopFullscreen.setVisibility(GONE);
}
Activity activity = PlayerUtils.scanForActivity(mContext);
if (activity != null && mControlWrapper.hasCutout()) {
int orientation = activity.getRequestedOrientation();
int cutoutHeight = mControlWrapper.getCutoutHeight();
LinearLayout.LayoutParams sflp = (LinearLayout.LayoutParams) mIvStopFullscreen.getLayoutParams();
if (orientation == ActivityInfo.SCREEN_ORIENTATION_PORTRAIT) {
sflp.setMargins(0, 0, 0, 0);
} else if (orientation == ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE) {
sflp.setMargins(cutoutHeight, 0, 0, 0);
} else if (orientation == ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE) {
sflp.setMargins(0, 0, 0, 0);
}
}
}
@Override
public void setProgress(int duration, int position) {
}
@Override
public void onLockStateChanged(boolean isLock) {
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/ui/view/CustomErrorView.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.video.ui.view;
import android.app.Activity;
import android.content.Context;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import android.content.pm.ActivityInfo;
import android.util.AttributeSet;
import android.view.LayoutInflater;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewConfiguration;
import android.view.animation.Animation;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.TextView;
import com.yc.video.config.ConstantKeys;
import com.yc.video.bridge.ControlWrapper;
import com.yc.video.R;
import com.yc.video.tool.PlayerUtils;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2017/11/9
* desc : 出错提示界面
* revise:
* </pre>
*/
public class CustomErrorView extends LinearLayout implements InterControlView, View.OnClickListener {
private Context mContext;
private float mDownX;
private float mDownY;
private TextView mTvMessage;
private TextView mTvRetry;
private ImageView mIvStopFullscreen;
private ControlWrapper mControlWrapper;
public CustomErrorView(Context context) {
super(context);
init(context);
}
public CustomErrorView(Context context, @Nullable AttributeSet attrs) {
super(context, attrs);
init(context);
}
public CustomErrorView(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
init(context);
}
private void init(Context context){
this.mContext = context;
setVisibility(GONE);
View view = LayoutInflater.from(getContext()).inflate(
R.layout.custom_video_player_error, this, true);
initFindViewById(view);
initListener();
setClickable(true);
}
private void initFindViewById(View view) {
mTvMessage = view.findViewById(R.id.tv_message);
mTvRetry = view.findViewById(R.id.tv_retry);
mIvStopFullscreen = view.findViewById(R.id.iv_stop_fullscreen);
}
private void initListener() {
mTvRetry.setOnClickListener(this);
mIvStopFullscreen.setOnClickListener(this);
}
@Override
public void onClick(View v) {
if (v == mTvRetry){
setVisibility(GONE);
mControlWrapper.replay(false);
} else if (v == mIvStopFullscreen){
//点击返回键
if (mControlWrapper.isFullScreen()) {
Activity activity = PlayerUtils.scanForActivity(mContext);
if (activity != null && !activity.isFinishing()) {
activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
mControlWrapper.stopFullScreen();
}
}
}
}
@Override
public void attach(@NonNull ControlWrapper controlWrapper) {
mControlWrapper = controlWrapper;
}
@Override
public View getView() {
return this;
}
@Override
public void onVisibilityChanged(boolean isVisible, Animation anim) {
}
@Override
public void onPlayStateChanged(int playState) {
if (playState == ConstantKeys.CurrentState.STATE_ERROR) {
bringToFront();
setVisibility(VISIBLE);
mIvStopFullscreen.setVisibility(mControlWrapper.isFullScreen() ? VISIBLE : GONE);
mTvMessage.setText("视频播放异常");
} if (playState == ConstantKeys.CurrentState.STATE_NETWORK_ERROR) {
bringToFront();
setVisibility(VISIBLE);
mIvStopFullscreen.setVisibility(mControlWrapper.isFullScreen() ? VISIBLE : GONE);
mTvMessage.setText("无网络，请检查网络设置");
} if (playState == ConstantKeys.CurrentState.STATE_PARSE_ERROR) {
bringToFront();
setVisibility(VISIBLE);
mIvStopFullscreen.setVisibility(mControlWrapper.isFullScreen() ? VISIBLE : GONE);
//mTvMessage.setText("视频解析异常");
mTvMessage.setText("视频加载错误");
} else if (playState == ConstantKeys.CurrentState.STATE_IDLE) {
setVisibility(GONE);
} else if (playState == ConstantKeys.CurrentState.STATE_ONCE_LIVE) {
setVisibility(GONE);
}
}
@Override
public void onPlayerStateChanged(int playerState) {
}
@Override
public void setProgress(int duration, int position) {
}
@Override
public void onLockStateChanged(boolean isLock) {
}
@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
switch (ev.getAction()) {
case MotionEvent.ACTION_DOWN:
mDownX = ev.getX();
mDownY = ev.getY();
getParent().requestDisallowInterceptTouchEvent(true);
break;
case MotionEvent.ACTION_MOVE:
float absDeltaX = Math.abs(ev.getX() - mDownX);
float absDeltaY = Math.abs(ev.getY() - mDownY);
if (absDeltaX > ViewConfiguration.get(getContext()).getScaledTouchSlop() ||
absDeltaY > ViewConfiguration.get(getContext()).getScaledTouchSlop()) {
getParent().requestDisallowInterceptTouchEvent(false);
}
case MotionEvent.ACTION_UP:
break;
}
return super.dispatchTouchEvent(ev);
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/ui/view/CustomGestureView.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.video.ui.view;
import android.animation.Animator;
import android.animation.AnimatorListenerAdapter;
import android.content.Context;
import android.util.AttributeSet;
import android.view.LayoutInflater;
import android.view.View;
import android.view.animation.Animation;
import android.widget.FrameLayout;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.ProgressBar;
import android.widget.TextView;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import com.yc.video.config.ConstantKeys;
import com.yc.video.bridge.ControlWrapper;
import com.yc.video.controller.IGestureComponent;
import com.yc.video.tool.PlayerUtils;
import com.yc.video.R;
/**
* 手势控制
*/
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2017/11/9
* desc : 手势控制
* revise: 用于滑动改变亮度和音量的功能
* </pre>
*/
public class CustomGestureView extends FrameLayout implements IGestureComponent {
private Context mContext;
private ControlWrapper mControlWrapper;
private LinearLayout mLlCenterContainer;
private ImageView mIvIcon;
private TextView mTvPercent;
private ProgressBar mProPercent;
public CustomGestureView(@NonNull Context context) {
super(context);
init(context);
}
public CustomGestureView(@NonNull Context context, @Nullable AttributeSet attrs) {
super(context, attrs);
init(context);
}
public CustomGestureView(@NonNull Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
init(context);
}
private void init(Context context){
this.mContext = context;
setVisibility(GONE);
View view = LayoutInflater.from(mContext).inflate(
R.layout.custom_video_player_gesture, this, true);
initFindViewById(view);
initListener();
}
private void initFindViewById(View view) {
mLlCenterContainer = view.findViewById(R.id.ll_center_container);
mIvIcon = view.findViewById(R.id.iv_icon);
mTvPercent = view.findViewById(R.id.tv_percent);
mProPercent = view.findViewById(R.id.pro_percent);
}
private void initListener() {
}
@Override
public void attach(@NonNull ControlWrapper controlWrapper) {
mControlWrapper = controlWrapper;
}
@Override
public View getView() {
return this;
}
@Override
public void onVisibilityChanged(boolean isVisible, Animation anim) {
}
@Override
public void onPlayerStateChanged(int playerState) {
}
/**
* 开始滑动
*/
@Override
public void onStartSlide() {
mControlWrapper.hide();
mLlCenterContainer.setVisibility(VISIBLE);
mLlCenterContainer.setAlpha(1f);
}
/**
* 结束滑动
* 这个是指，手指抬起或者意外结束事件的时候，调用这个方法
*/
@Override
public void onStopSlide() {
mLlCenterContainer.animate()
.alpha(0f)
.setDuration(300)
.setListener(new AnimatorListenerAdapter() {
@Override
public void onAnimationEnd(Animator animation) {
super.onAnimationEnd(animation);
mLlCenterContainer.setVisibility(GONE);
}
})
.start();
}
/**
* 滑动调整进度
* @param slidePosition 滑动进度
* @param currentPosition 当前播放进度
* @param duration 视频总长度
*/
@Override
public void onPositionChange(int slidePosition, int currentPosition, int duration) {
mProPercent.setVisibility(GONE);
if (slidePosition > currentPosition) {
mIvIcon.setImageResource(R.drawable.ic_player_fast_forward);
} else {
mIvIcon.setImageResource(R.drawable.ic_player_fast_rewind);
}
mTvPercent.setText(String.format("%s/%s", PlayerUtils.formatTime(slidePosition), PlayerUtils.formatTime(duration)));
}
/**
* 滑动调整亮度
* @param percent 亮度百分比
*/
@Override
public void onBrightnessChange(int percent) {
mProPercent.setVisibility(VISIBLE);
mIvIcon.setImageResource(R.drawable.ic_palyer_brightness);
mTvPercent.setText(percent + "%");
mProPercent.setProgress(percent);
}
/**
* 滑动调整音量
* @param percent 音量百分比
*/
@Override
public void onVolumeChange(int percent) {
mProPercent.setVisibility(VISIBLE);
if (percent <= 0) {
mIvIcon.setImageResource(R.drawable.ic_player_volume_off);
} else {
mIvIcon.setImageResource(R.drawable.ic_player_volume_up);
}
mTvPercent.setText(percent + "%");
mProPercent.setProgress(percent);
}
@Override
public void onPlayStateChanged(int playState) {
if (playState == ConstantKeys.CurrentState.STATE_IDLE
|| playState == ConstantKeys.CurrentState.STATE_START_ABORT
|| playState == ConstantKeys.CurrentState.STATE_PREPARING
|| playState == ConstantKeys.CurrentState.STATE_PREPARED
|| playState == ConstantKeys.CurrentState.STATE_ERROR
|| playState == ConstantKeys.CurrentState.STATE_BUFFERING_PLAYING
|| playState == ConstantKeys.CurrentState.STATE_ONCE_LIVE) {
setVisibility(GONE);
} else {
setVisibility(VISIBLE);
}
}
@Override
public void setProgress(int duration, int position) {
}
@Override
public void onLockStateChanged(boolean isLock) {
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/ui/view/CustomLiveControlView.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.video.ui.view;
import android.app.Activity;
import android.content.Context;
import android.content.pm.ActivityInfo;
import android.util.AttributeSet;
import android.view.LayoutInflater;
import android.view.View;
import android.view.animation.Animation;
import android.widget.FrameLayout;
import android.widget.ImageView;
import android.widget.LinearLayout;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import com.yc.video.config.ConstantKeys;
import com.yc.video.bridge.ControlWrapper;
import com.yc.video.tool.PlayerUtils;
import com.yc.video.R;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2017/11/9
* desc : 底部控制栏视图
* revise: 用于直播
* </pre>
*/
public class CustomLiveControlView extends FrameLayout implements InterControlView, View.OnClickListener {
private Context mContext;
private ControlWrapper mControlWrapper;
private LinearLayout mLlBottomContainer;
private ImageView mIvPlay;
private ImageView mIvRefresh;
private ImageView mIvFullScreen;
public CustomLiveControlView(@NonNull Context context) {
super(context);
init(context);
}
public CustomLiveControlView(@NonNull Context context, @Nullable AttributeSet attrs) {
super(context, attrs);
init(context);
}
public CustomLiveControlView(@NonNull Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
init(context);
}
private void init(Context context){
this.mContext = context;
setVisibility(GONE);
View view = LayoutInflater.from(getContext()).inflate(
R.layout.custom_video_player_live, this, true);
initFindViewById(view);
initListener();
}
private void initFindViewById(View view) {
mLlBottomContainer = view.findViewById(R.id.ll_bottom_container);
mIvPlay = view.findViewById(R.id.iv_play);
mIvRefresh = view.findViewById(R.id.iv_refresh);
mIvFullScreen = view.findViewById(R.id.iv_full_screen);
}
private void initListener() {
mIvFullScreen.setOnClickListener(this);
mIvRefresh.setOnClickListener(this);
mIvPlay.setOnClickListener(this);
}
@Override
public void onClick(View v) {
int id = v.getId();
if (id == R.id.iv_full_screen) {
toggleFullScreen();
} else if (id == R.id.iv_play) {
mControlWrapper.togglePlay();
} else if (id == R.id.iv_refresh) {
mControlWrapper.replay(true);
}
}
@Override
public void attach(@NonNull ControlWrapper controlWrapper) {
mControlWrapper = controlWrapper;
}
@Override
public View getView() {
return this;
}
@Override
public void onVisibilityChanged(boolean isVisible, Animation anim) {
if (isVisible) {
if (getVisibility() == GONE) {
setVisibility(VISIBLE);
if (anim != null) {
startAnimation(anim);
}
}
} else {
if (getVisibility() == VISIBLE) {
setVisibility(GONE);
if (anim != null) {
startAnimation(anim);
}
}
}
}
@Override
public void onPlayStateChanged(int playState) {
switch (playState) {
case ConstantKeys.CurrentState.STATE_IDLE:
case ConstantKeys.CurrentState.STATE_START_ABORT:
case ConstantKeys.CurrentState.STATE_PREPARING:
case ConstantKeys.CurrentState.STATE_PREPARED:
case ConstantKeys.CurrentState.STATE_ERROR:
case ConstantKeys.CurrentState.STATE_BUFFERING_PLAYING:
case ConstantKeys.CurrentState.STATE_ONCE_LIVE:
setVisibility(GONE);
break;
case ConstantKeys.CurrentState.STATE_PLAYING:
mIvPlay.setSelected(true);
break;
case ConstantKeys.CurrentState.STATE_PAUSED:
mIvPlay.setSelected(false);
break;
case ConstantKeys.CurrentState.STATE_BUFFERING_PAUSED:
case ConstantKeys.CurrentState.STATE_COMPLETED:
mIvPlay.setSelected(mControlWrapper.isPlaying());
break;
}
}
@Override
public void onPlayerStateChanged(int playerState) {
switch (playerState) {
case ConstantKeys.PlayMode.MODE_NORMAL:
mIvFullScreen.setSelected(false);
break;
case ConstantKeys.PlayMode.MODE_FULL_SCREEN:
mIvFullScreen.setSelected(true);
break;
}
Activity activity = PlayerUtils.scanForActivity(mContext);
if (activity != null && mControlWrapper.hasCutout()) {
int orientation = activity.getRequestedOrientation();
int cutoutHeight = mControlWrapper.getCutoutHeight();
if (orientation == ActivityInfo.SCREEN_ORIENTATION_PORTRAIT) {
mLlBottomContainer.setPadding(0, 0, 0, 0);
} else if (orientation == ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE) {
mLlBottomContainer.setPadding(cutoutHeight, 0, 0, 0);
} else if (orientation == ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE) {
mLlBottomContainer.setPadding(0, 0, cutoutHeight, 0);
}
}
}
@Override
public void setProgress(int duration, int position) {
}
@Override
public void onLockStateChanged(boolean isLocked) {
onVisibilityChanged(!isLocked, null);
}
/**
* 横竖屏切换
*/
private void toggleFullScreen() {
Activity activity = PlayerUtils.scanForActivity(getContext());
mControlWrapper.toggleFullScreen(activity);
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/ui/view/CustomOncePlayView.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.video.ui.view;
import android.content.Context;
import android.util.AttributeSet;
import android.view.LayoutInflater;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewConfiguration;
import android.view.animation.Animation;
import android.widget.LinearLayout;
import android.widget.TextView;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import com.yc.video.R;
import com.yc.video.bridge.ControlWrapper;
import com.yc.video.config.ConstantKeys;
import com.yc.video.tool.BaseToast;
import com.yc.video.tool.PlayerUtils;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2017/11/9
* desc : 即将开播视图
* revise:
* </pre>
*/
public class CustomOncePlayView extends LinearLayout implements InterControlView {
private Context mContext;
private float mDownX;
private float mDownY;
private TextView mTvMessage;
private TextView mTvRetry;
private int playState;
private ControlWrapper mControlWrapper;
public CustomOncePlayView(Context context) {
super(context);
init(context);
}
public CustomOncePlayView(Context context, @Nullable AttributeSet attrs) {
super(context, attrs);
init(context);
}
public CustomOncePlayView(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
init(context);
}
private void init(Context context){
this.mContext = context;
setVisibility(GONE);
View view = LayoutInflater.from(getContext()).inflate(
R.layout.custom_video_player_once_live, this, true);
initFindViewById(view);
initListener();
setClickable(true);
}
private void initFindViewById(View view) {
mTvMessage = view.findViewById(R.id.tv_message);
mTvRetry = view.findViewById(R.id.tv_retry);
}
private void initListener() {
mTvRetry.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
if (playState == ConstantKeys.CurrentState.STATE_ONCE_LIVE){
//即将开播
if (PlayerUtils.isConnected(mContext)){
mControlWrapper.start();
} else {
BaseToast.showRoundRectToast("请查看网络是否连接");
}
} else {
BaseToast.showRoundRectToast("时间还未到，请稍后再试");
}
}
});
}
@Override
public void attach(@NonNull ControlWrapper controlWrapper) {
mControlWrapper = controlWrapper;
}
@Override
public View getView() {
return this;
}
@Override
public void onVisibilityChanged(boolean isVisible, Animation anim) {
}
@Override
public void onPlayStateChanged(int playState) {
this.playState = playState;
if (playState == ConstantKeys.CurrentState.STATE_ONCE_LIVE) {
//即将开播
setVisibility(VISIBLE);
} else {
setVisibility(GONE);
}
}
@Override
public void onPlayerStateChanged(int playerState) {
}
@Override
public void setProgress(int duration, int position) {
}
@Override
public void onLockStateChanged(boolean isLock) {
}
@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
switch (ev.getAction()) {
case MotionEvent.ACTION_DOWN:
mDownX = ev.getX();
mDownY = ev.getY();
getParent().requestDisallowInterceptTouchEvent(true);
break;
case MotionEvent.ACTION_MOVE:
float absDeltaX = Math.abs(ev.getX() - mDownX);
float absDeltaY = Math.abs(ev.getY() - mDownY);
if (absDeltaX > ViewConfiguration.get(getContext()).getScaledTouchSlop() ||
absDeltaY > ViewConfiguration.get(getContext()).getScaledTouchSlop()) {
getParent().requestDisallowInterceptTouchEvent(false);
}
case MotionEvent.ACTION_UP:
break;
}
return super.dispatchTouchEvent(ev);
}
public TextView getTvMessage() {
return mTvMessage;
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/ui/view/CustomPrepareView.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.video.ui.view;
import android.content.Context;
import android.util.AttributeSet;
import android.view.LayoutInflater;
import android.view.View;
import android.view.animation.Animation;
import android.widget.FrameLayout;
import android.widget.ImageView;
import android.widget.ProgressBar;
import android.widget.TextView;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import com.yc.video.config.ConstantKeys;
import com.yc.video.bridge.ControlWrapper;
import com.yc.video.player.VideoViewManager;
import com.yc.video.R;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2017/11/9
* desc : 预加载准备播放页面视图
* revise:
* </pre>
*/
public class CustomPrepareView extends FrameLayout implements InterControlView {
private Context mContext;
private ControlWrapper mControlWrapper;
private ImageView mIvThumb;
private ImageView mIvStartPlay;
private ProgressBar mPbLoading;
private FrameLayout mFlNetWarning;
private TextView mTvMessage;
private TextView mTvStart;
public CustomPrepareView(@NonNull Context context) {
super(context);
init(context);
}
public CustomPrepareView(@NonNull Context context, @Nullable AttributeSet attrs) {
super(context, attrs);
init(context);
}
public CustomPrepareView(@NonNull Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
init(context);
}
private void init(Context context){
this.mContext = context;
View view = LayoutInflater.from(getContext()).inflate(
R.layout.custom_video_player_prepare, this, true);
initFindViewById(view);
initListener();
}
private void initFindViewById(View view) {
mIvThumb = view.findViewById(R.id.iv_thumb);
mIvStartPlay = view.findViewById(R.id.iv_start_play);
mPbLoading = view.findViewById(R.id.pb_loading);
mFlNetWarning = view.findViewById(R.id.fl_net_warning);
mTvMessage = view.findViewById(R.id.tv_message);
mTvStart = view.findViewById(R.id.tv_start);
}
private void initListener() {
mTvStart.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
mFlNetWarning.setVisibility(GONE);
VideoViewManager.instance().setPlayOnMobileNetwork(true);
mControlWrapper.start();
}
});
}
/**
* 设置点击此界面开始播放
*/
public void setClickStart() {
setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
mControlWrapper.start();
}
});
}
@Override
public void attach(@NonNull ControlWrapper controlWrapper) {
mControlWrapper = controlWrapper;
}
@Override
public View getView() {
return this;
}
@Override
public void onVisibilityChanged(boolean isVisible, Animation anim) {
}
@Override
public void onPlayStateChanged(int playState) {
switch (playState) {
case ConstantKeys.CurrentState.STATE_PREPARING:
bringToFront();
setVisibility(VISIBLE);
mIvStartPlay.setVisibility(View.GONE);
mFlNetWarning.setVisibility(GONE);
mPbLoading.setVisibility(View.VISIBLE);
break;
case ConstantKeys.CurrentState.STATE_PLAYING:
case ConstantKeys.CurrentState.STATE_PAUSED:
case ConstantKeys.CurrentState.STATE_ERROR:
case ConstantKeys.CurrentState.STATE_BUFFERING_PAUSED:
case ConstantKeys.CurrentState.STATE_COMPLETED:
case ConstantKeys.CurrentState.STATE_BUFFERING_PLAYING:
case ConstantKeys.CurrentState.STATE_ONCE_LIVE:
setVisibility(GONE);
break;
case ConstantKeys.CurrentState.STATE_IDLE:
setVisibility(VISIBLE);
bringToFront();
mPbLoading.setVisibility(View.GONE);
mFlNetWarning.setVisibility(GONE);
mIvStartPlay.setVisibility(View.VISIBLE);
mIvThumb.setVisibility(View.VISIBLE);
break;
case ConstantKeys.CurrentState.STATE_START_ABORT:
setVisibility(VISIBLE);
mFlNetWarning.setVisibility(VISIBLE);
mFlNetWarning.bringToFront();
break;
}
}
@Override
public void onPlayerStateChanged(int playerState) {
}
@Override
public void setProgress(int duration, int position) {
}
@Override
public void onLockStateChanged(boolean isLocked) {
}
public ImageView getThumb() {
return mIvThumb;
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/ui/view/CustomTitleView.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.video.ui.view;
import android.app.Activity;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.pm.ActivityInfo;
import android.os.Bundle;
import android.util.AttributeSet;
import android.view.LayoutInflater;
import android.view.View;
import android.view.animation.Animation;
import android.widget.FrameLayout;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.TextView;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import com.yc.video.config.ConstantKeys;
import com.yc.video.bridge.ControlWrapper;
import com.yc.video.tool.PlayerUtils;
import com.yc.video.R;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2017/11/9
* desc : 顶部标题栏视图
* revise:
* </pre>
*/
public class CustomTitleView extends FrameLayout implements InterControlView, View.OnClickListener {
private Context mContext;
private ControlWrapper mControlWrapper;
private LinearLayout mLlTitleContainer;
private ImageView mIvBack;
private TextView mTvTitle;
private ImageView mIvBattery;
private TextView mTvSysTime;
private BatteryReceiver mBatteryReceiver;
private boolean mIsRegister;//是否注册BatteryReceiver
public CustomTitleView(@NonNull Context context) {
super(context);
init(context);
}
public CustomTitleView(@NonNull Context context, @Nullable AttributeSet attrs) {
super(context, attrs);
init(context);
}
public CustomTitleView(@NonNull Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
init(context);
}
private void init(Context context){
this.mContext = context;
setVisibility(GONE);
View view = LayoutInflater.from(mContext).inflate(
R.layout.custom_video_player_top, this, true);
initFindViewById(view);
initListener();
//电量
mBatteryReceiver = new BatteryReceiver(mIvBattery);
}
private void initFindViewById(View view) {
mLlTitleContainer = view.findViewById(R.id.ll_title_container);
mIvBack = view.findViewById(R.id.iv_back);
mTvTitle = view.findViewById(R.id.tv_title);
mIvBattery = view.findViewById(R.id.iv_battery);
mTvSysTime = view.findViewById(R.id.tv_sys_time);
}
private void initListener() {
mIvBack.setOnClickListener(this);
}
@Override
public void onClick(View v) {
if (v == mIvBack){
//点击返回键
Activity activity = PlayerUtils.scanForActivity(getContext());
if (activity != null && mControlWrapper.isFullScreen()) {
activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
mControlWrapper.stopFullScreen();
return;
}
//如果不是全屏模式，则直接关闭页面activity
if (PlayerUtils.isActivityLiving(activity)){
activity.finish();
}
}
}
public void setTitle(String title) {
if (title!=null && title.length()>0){
mTvTitle.setText(title);
} else {
mTvTitle.setText("");
}
}
@Override
protected void onDetachedFromWindow() {
super.onDetachedFromWindow();
if (mIsRegister) {
getContext().unregisterReceiver(mBatteryReceiver);
mIsRegister = false;
}
}
@Override
protected void onAttachedToWindow() {
super.onAttachedToWindow();
if (!mIsRegister) {
getContext().registerReceiver(mBatteryReceiver, new IntentFilter(Intent.ACTION_BATTERY_CHANGED));
mIsRegister = true;
}
}
@Override
public void attach(@NonNull ControlWrapper controlWrapper) {
mControlWrapper = controlWrapper;
}
@Override
public View getView() {
return this;
}
@Override
public void onVisibilityChanged(boolean isVisible, Animation anim) {
//只在全屏时才有效
if (isVisible) {
if (getVisibility() == GONE) {
mTvSysTime.setText(PlayerUtils.getCurrentSystemTime());
setVisibility(VISIBLE);
if (anim != null) {
startAnimation(anim);
}
}
} else {
if (getVisibility() == VISIBLE) {
setVisibility(GONE);
if (anim != null) {
startAnimation(anim);
}
}
}
if (getVisibility() == VISIBLE) {
if (mControlWrapper.isFullScreen()) {
//显示电量
mIvBattery.setVisibility(VISIBLE);
mTvSysTime.setVisibility(VISIBLE);
} else {
//不显示电量
mIvBattery.setVisibility(GONE);
mTvSysTime.setVisibility(GONE);
}
}
}
@Override
public void onPlayStateChanged(int playState) {
switch (playState) {
case ConstantKeys.CurrentState.STATE_IDLE:
case ConstantKeys.CurrentState.STATE_START_ABORT:
case ConstantKeys.CurrentState.STATE_PREPARING:
case ConstantKeys.CurrentState.STATE_PREPARED:
case ConstantKeys.CurrentState.STATE_ERROR:
case ConstantKeys.CurrentState.STATE_BUFFERING_PLAYING:
setVisibility(GONE);
break;
}
}
@Override
public void onPlayerStateChanged(int playerState) {
if (playerState == ConstantKeys.PlayMode.MODE_FULL_SCREEN) {
if (mControlWrapper.isShowing() && !mControlWrapper.isLocked()) {
setVisibility(VISIBLE);
mTvSysTime.setText(PlayerUtils.getCurrentSystemTime());
}
mTvTitle.setSelected(true);
} else {
setVisibility(GONE);
mTvTitle.setSelected(false);
}
Activity activity = PlayerUtils.scanForActivity(mContext);
if (activity != null && mControlWrapper.hasCutout()) {
int orientation = activity.getRequestedOrientation();
int cutoutHeight = mControlWrapper.getCutoutHeight();
//设置屏幕的变化是，标题的值。后期有需要在暴露给开发者设置
if (orientation == ActivityInfo.SCREEN_ORIENTATION_PORTRAIT) {
//切换成竖屏的时候调用
mLlTitleContainer.setPadding(PlayerUtils.dp2px(mContext,12),
PlayerUtils.dp2px(mContext,10), PlayerUtils.dp2px(mContext,12), 0);
} else if (orientation == ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE) {
//切换成横屏的时候调用
mLlTitleContainer.setPadding(cutoutHeight, 0, PlayerUtils.dp2px(mContext,12), 0);
} else if (orientation == ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE) {
mLlTitleContainer.setPadding(0, 0, cutoutHeight, 0);
} else {
mLlTitleContainer.setPadding(PlayerUtils.dp2px(mContext,12),
PlayerUtils.dp2px(mContext,10), PlayerUtils.dp2px(mContext,12), 0);
}
}
}
@Override
public void setProgress(int duration, int position) {
}
@Override
public void onLockStateChanged(boolean isLocked) {
if (isLocked) {
setVisibility(GONE);
} else {
setVisibility(VISIBLE);
mTvSysTime.setText(PlayerUtils.getCurrentSystemTime());
}
}
private static class BatteryReceiver extends BroadcastReceiver {
private ImageView pow;
public BatteryReceiver(ImageView pow) {
this.pow = pow;
}
@Override
public void onReceive(Context context, Intent intent) {
Bundle extras = intent.getExtras();
if (extras == null) return;
int current = extras.getInt("level");// 获得当前电量
int total = extras.getInt("scale");// 获得总电量
int percent = current * 100 / total;
pow.getDrawable().setLevel(percent);
}
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoPlayer/src/main/java/com/yc/video/ui/view/InterControlView.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.video.ui.view;
import android.view.View;
import android.view.animation.Animation;
import androidx.annotation.NonNull;
import com.yc.video.bridge.ControlWrapper;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2017/11/9
* desc : 自定义控制器接口
* revise: 如果需要添加自定义播放器视图，则需要继承InterControlView接口
* 关于视频播放器播放状态和视图状态，都需要自定义视图去控制view的状态
* 举一个例子：比如广告视图，
* </pre>
*/
public interface InterControlView {
/**
* 这个是绑定视图操作
* @param controlWrapper 自定义控制器包装类
*/
void attach(@NonNull ControlWrapper controlWrapper);
/**
* 获取该自定义视图view对象
* @return 视图view对象
*/
View getView();
/**
* 视图显示发生变化监听
* @param isVisible 是否可见
* @param anim 动画
*/
void onVisibilityChanged(boolean isVisible, Animation anim);
/**
* 播放状态
* -1 播放错误
* 0 播放未开始
* 1 播放准备中
* 2 播放准备就绪
* 3 正在播放
* 4 暂停播放
* 5 正在缓冲(播放器正在播放时，缓冲区数据不足，进行缓冲，缓冲区数据足够后恢复播放)
* 6 暂停缓冲(播放器正在播放时，缓冲区数据不足，进行缓冲，此时暂停播放器，继续缓冲，缓冲区数据足够后恢复暂停
* 7 播放完成
* 8 开始播放中止
* @param playState 播放状态，主要是指播放器的各种状态
*/
void onPlayStateChanged(int playState);
/**
* 播放模式
* 普通模式，小窗口模式，正常模式三种其中一种
* MODE_NORMAL 普通模式
* MODE_FULL_SCREEN 全屏模式
* MODE_TINY_WINDOW 小屏模式
* @param playerState 播放模式
*/
void onPlayerStateChanged(int playerState);
/**
* 设置进度操作
* @param duration 时间
* @param position 进度position
*/
void setProgress(int duration, int position);
/**
* 锁屏状态监听
* @param isLocked 是否锁屏
*/
void onLockStateChanged(boolean isLocked);
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoRecorder/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 |
VideoRecorder/src/main/java/com/yc/videorecorder/Test.java | Java | package com.yc.videorecorder;
public class Test {
//代码待提交，完善之后再开源
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoScreen/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"
}
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'
} | yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoScreen/src/main/java/com/yc/videoscreen/Test.java | Java | package com.yc.videoscreen;
public class Test {
//代码待提交，完善之后再开源
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoSqlLite/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.annotation:annotation:1.1.0'
}
/** 以下开始是将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 = "VideoSqlLite"
// 版本号，下次更新是只需要更改版本号即可
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 video sqllite 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 sqllite' //项目描述
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 |
VideoSqlLite/src/main/java/com/yc/videosqllite/TestDemo.java | Java | package com.yc.videosqllite;
import android.content.Context;
import com.yc.videosqllite.manager.CacheConfig;
import com.yc.videosqllite.manager.LocationManager;
/**
* <pre>
* @author yangchong
* email : yangchong211@163.com
* time : 2020/6/16
* desc : 使用代码案例
* revise:
* </pre>
*/
public class TestDemo {
private void init(Context context){
CacheConfig cacheConfig = new CacheConfig();
//设置配置是生效
cacheConfig.setIsEffective(true);
/*
* 0，表示内存缓存
* 1，表示磁盘缓存
* 2，表示内存缓存+磁盘缓存
*/
cacheConfig.setType(2);
//设置上下文
cacheConfig.setContext(context);
//设置最大缓存
cacheConfig.setCacheMax(1000);
//设置是否打印log
cacheConfig.setLog(false);
//初始化
LocationManager.getInstance().init(cacheConfig);
//保存播放位置
// VideoLocation location = new VideoLocation(url, currentPosition, duration);
// LocationManager.getInstance().put(url,location);
//获取播放位置
// final long location = LocationManager.getInstance().get(url);
//清除所有位置
// LocationManager.getInstance().clearAll();
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoSqlLite/src/main/java/com/yc/videosqllite/cache/InterCache.java | Java | package com.yc.videosqllite.cache;
import java.util.Set;
/**
* <pre>
* @author yangchong
* email : yangchong211@163.com
* time : 2020/8/6
* desc : 缓存接口
* revise: 内存缓存，主要使用到了淘汰算法
* </pre>
*/
public interface InterCache<K, V> {
/**
* 返回当前缓存已占用的总 size
*
* @return {@code size}
*/
int size();
/**
* 返回当前缓存所能允许的最大 size
*
* @return {@code maxSize}
*/
int getMaxSize();
/**
* 返回这个 {@code key} 在缓存中对应的 {@code value}, 如果返回 {@code null} 说明这个 {@code key} 没有对应的 {@code value}
*
* @param key {@code key}
* @return {@code value}
*/
V get(K key);
/**
* 将 {@code key} 和 {@code value} 以条目的形式加入缓存,如果这个 {@code key} 在缓存中已经有对应的 {@code value}
* 则此 {@code value} 被新的 {@code value} 替换并返回,如果为 {@code null} 说明是一个新条目
*
* @param key {@code key}
* @param value {@code value}
* @return 如果这个 {@code key} 在容器中已经储存有 {@code value}, 则返回之前的 {@code value} 否则返回 {@code null}
*/
V put(K key, V value);
/**
* 移除缓存中这个 {@code key} 所对应的条目,并返回所移除条目的 value
* 如果返回为 {@code null} 则有可能时因为这个 {@code key} 对应的 value 为 {@code null} 或条目不存在
*
* @param key {@code key}
* @return 如果这个 {@code key} 在容器中已经储存有 {@code value} 并且删除成功则返回删除的 {@code value}, 否则返回 {@code null}
*/
V remove(K key);
/**
* 如果这个 {@code key} 在缓存中有对应的 value 并且不为 {@code null}, 则返回 {@code true}
*
* @param key {@code key}
* @return {@code true} 为在容器中含有这个 {@code key}, 否则为 {@code false}
*/
boolean containsKey(K key);
/**
* 返回当前缓存中含有的所有 {@code key}
*
* @return {@code keySet}
*/
Set<K> keySet();
/**
* 清除缓存中所有的内容
*/
void clear();
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoSqlLite/src/main/java/com/yc/videosqllite/cache/SystemLruCache.java | Java | package com.yc.videosqllite.cache;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
/**
* <pre>
* @author yangchong
* email : yangchong211@163.com
* time : 2020/8/6
* desc : 系统自带LruCache
* revise:
* </pre>
*/
public class SystemLruCache<K, V> {
private final LinkedHashMap<K, V> map;
/** Size of this cache in units. Not necessarily the number of elements. */
private int size;
private int maxSize;
private int putCount;
private int createCount;
private int evictionCount;
private int hitCount;
private int missCount;
/**
* @param maxSize for caches that do not override {@link #sizeOf}, this is
* the maximum number of entries in the cache. For all other caches,
* this is the maximum sum of the sizes of the entries in this cache.
*/
public SystemLruCache(int maxSize) {
if (maxSize <= 0) {
throw new IllegalArgumentException("maxSize <= 0");
}
this.maxSize = maxSize;
//创建map集合
this.map = new LinkedHashMap<K, V>(0, 0.75f, true);
}
/**
* Sets the size of the cache.
* @param maxSize The new maximum size.
*
* @hide
*/
public void resize(int maxSize) {
if (maxSize <= 0) {
throw new IllegalArgumentException("maxSize <= 0");
}
synchronized (this) {
this.maxSize = maxSize;
}
trimToSize(maxSize);
}
/**
* Returns the value for {@code key} if it exists in the cache or can be
* created by {@code #create}. If a value was returned, it is moved to the
* head of the queue. This returns null if a value is not cached and cannot
* be created.
*/
public final V get(K key) {
if (key == null) {
throw new NullPointerException("key == null");
}
V mapValue;
synchronized (this) {
mapValue = map.get(key);
if (mapValue != null) {
hitCount++;
return mapValue;
}
missCount++;
}
/*
* Attempt to create a value. This may take a long time, and the map
* may be different when create() returns. If a conflicting value was
* added to the map while create() was working, we leave that value in
* the map and release the created value.
*/
V createdValue = create(key);
if (createdValue == null) {
return null;
}
synchronized (this) {
createCount++;
mapValue = map.put(key, createdValue);
if (mapValue != null) {
// There was a conflict so undo that last put
map.put(key, mapValue);
} else {
size += safeSizeOf(key, createdValue);
}
}
if (mapValue != null) {
entryRemoved(false, key, createdValue, mapValue);
return mapValue;
} else {
trimToSize(maxSize);
return createdValue;
}
}
/**
* Caches {@code value} for {@code key}. The value is moved to the head of
* the queue.
*
* @return the previous value mapped by {@code key}.
*/
public final V put(K key, V value) {
if (key == null || value == null) {
throw new NullPointerException("key == null || value == null");
}
V previous;
synchronized (this) {
putCount++;
size += safeSizeOf(key, value);
previous = map.put(key, value);
if (previous != null) {
size -= safeSizeOf(key, previous);
}
}
if (previous != null) {
entryRemoved(false, key, previous, value);
}
trimToSize(maxSize);
return previous;
}
/**
* @param maxSize the maximum size of the cache before returning. May be -1
* to evict even 0-sized elements.
*/
private void trimToSize(int maxSize) {
//循环遍历
while (true) {
K key;
V value;
synchronized (this) {
//如果为空，则抛出异常
if (size < 0 || (map.isEmpty() && size != 0)) {
throw new IllegalStateException(getClass().getName()
+ ".sizeOf() is reporting inconsistent results!");
}
if (size <= maxSize) {
break;
}
// BEGIN LAYOUTLIB CHANGE
// get the last item in the linked list.
// This is not efficient, the goal here is to minimize the changes
// compared to the platform version.
Map.Entry<K, V> toEvict = null;
Set<Map.Entry<K, V>> entries = map.entrySet();
for (Map.Entry<K, V> entry : entries) {
toEvict = entry;
}
// END LAYOUTLIB CHANGE
if (toEvict == null) {
break;
}
key = toEvict.getKey();
value = toEvict.getValue();
//移除
map.remove(key);
//逐次减去1
size -= safeSizeOf(key, value);
evictionCount++;
}
entryRemoved(true, key, value, null);
}
}
/**
* Removes the entry for {@code key} if it exists.
*
* @return the previous value mapped by {@code key}.
*/
public final V remove(K key) {
if (key == null) {
throw new NullPointerException("key == null");
}
V previous;
synchronized (this) {
previous = map.remove(key);
if (previous != null) {
size -= safeSizeOf(key, previous);
}
}
if (previous != null) {
entryRemoved(false, key, previous, null);
}
return previous;
}
/**
* Called for entries that have been evicted or removed. This method is
* invoked when a value is evicted to make space, removed by a call to
* {@link #remove}, or replaced by a call to {@link #put}. The default
* implementation does nothing.
*
* <p>The method is called without synchronization: other threads may
* access the cache while this method is executing.
*
* @param evicted true if the entry is being removed to make space, false
* if the removal was caused by a {@link #put} or {@link #remove}.
* @param newValue the new value for {@code key}, if it exists. If non-null,
* this removal was caused by a {@link #put}. Otherwise it was caused by
* an eviction or a {@link #remove}.
*/
protected void entryRemoved(boolean evicted, K key, V oldValue, V newValue) {}
/**
* Called after a cache miss to compute a value for the corresponding key.
* Returns the computed value or null if no value can be computed. The
* default implementation returns null.
*
* <p>The method is called without synchronization: other threads may
* access the cache while this method is executing.
*
* <p>If a value for {@code key} exists in the cache when this method
* returns, the created value will be released with {@link #entryRemoved}
* and discarded. This can occur when multiple threads request the same key
* at the same time (causing multiple values to be created), or when one
* thread calls {@link #put} while another is creating a value for the same
* key.
*/
protected V create(K key) {
return null;
}
private int safeSizeOf(K key, V value) {
int result = sizeOf(key, value);
if (result < 0) {
throw new IllegalStateException("Negative size: " + key + "=" + value);
}
return result;
}
/**
* Returns the size of the entry for {@code key} and {@code value} in
* user-defined units. The default implementation returns 1 so that size
* is the number of entries and max size is the maximum number of entries.
*
* <p>An entry's size must not change while it is in the cache.
*/
protected int sizeOf(K key, V value) {
return 1;
}
/**
* Clear the cache, calling {@link #entryRemoved} on each removed entry.
*/
public final void evictAll() {
trimToSize(-1); // -1 will evict 0-sized elements
}
/**
* For caches that do not override {@link #sizeOf}, this returns the number
* of entries in the cache. For all other caches, this returns the sum of
* the sizes of the entries in this cache.
*/
public synchronized final int size() {
return size;
}
/**
* For caches that do not override {@link #sizeOf}, this returns the maximum
* number of entries in the cache. For all other caches, this returns the
* maximum sum of the sizes of the entries in this cache.
*/
public synchronized final int maxSize() {
return maxSize;
}
/**
* Returns the number of times {@link #get} returned a value that was
* already present in the cache.
*/
public synchronized final int hitCount() {
return hitCount;
}
/**
* Returns the number of times {@link #get} returned null or required a new
* value to be created.
*/
public synchronized final int missCount() {
return missCount;
}
/**
* Returns the number of times {@link #create(Object)} returned a value.
*/
public synchronized final int createCount() {
return createCount;
}
/**
* Returns the number of times {@link #put} was called.
*/
public synchronized final int putCount() {
return putCount;
}
/**
* Returns the number of values that have been evicted.
*/
public synchronized final int evictionCount() {
return evictionCount;
}
/**
* Returns a copy of the current contents of the cache, ordered from least
* recently accessed to most recently accessed.
*/
public synchronized final Map<K, V> snapshot() {
return new LinkedHashMap<K, V>(map);
}
@Override public synchronized final String toString() {
int accesses = hitCount + missCount;
int hitPercent = accesses != 0 ? (100 * hitCount / accesses) : 0;
return String.format("LruCache[maxSize=%d,hits=%d,misses=%d,hitRate=%d%%]",
maxSize, hitCount, missCount, hitPercent);
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoSqlLite/src/main/java/com/yc/videosqllite/cache/VideoLruCache.java | Java | package com.yc.videosqllite.cache;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
/**
* <pre>
* @author yangchong
* email : yangchong211@163.com
* time : 2020/8/6
* desc : LRU 即最近最少使用
* revise: 当缓存满了, 会优先淘汰那些最近最不常访问的数据
* 此种缓存策略为框架默认提供, 可自行实现其他缓存策略, 如磁盘缓存
* </pre>
*/
public class VideoLruCache<K, V> implements InterCache<K, V> {
private final LinkedHashMap<K, V> cache = new LinkedHashMap<>(100, 0.75f, true);
private final int initialMaxSize;
private int maxSize;
private int currentSize = 0;
/**
* Constructor for LruCache.
*
* @param size 这个缓存的最大 size,这个 size 所使用的单位必须和 {@link #getItemSize(Object)} 所使用的单位一致.
*/
public VideoLruCache(int size) {
if (size <= 0) {
throw new IllegalArgumentException("size <= 0");
}
this.initialMaxSize = size;
this.maxSize = size;
}
/**
* 设置一个系数应用于当时构造函数中所传入的 size, 从而得到一个新的 {@link #maxSize}
* 并会立即调用 {@link #evict} 开始清除满足条件的条目
*
* @param multiplier 系数
*/
public synchronized void setSizeMultiplier(float multiplier) {
if (multiplier < 0) {
throw new IllegalArgumentException("Multiplier must be >= 0");
}
maxSize = Math.round(initialMaxSize * multiplier);
evict();
}
/**
* 返回每个 {@code item} 所占用的 size,默认为1,这个 size 的单位必须和构造函数所传入的 size 一致
* 子类可以重写这个方法以适应不同的单位,比如说 bytes
*
* @param item 每个 {@code item} 所占用的 size
* @return 单个 item 的 {@code size}
*/
protected int getItemSize(V item) {
return 1;
}
/**
* 当缓存中有被驱逐的条目时,会回调此方法,默认空实现,子类可以重写这个方法
*
* @param key 被驱逐条目的 {@code key}
* @param value 被驱逐条目的 {@code value}
*/
protected void onItemEvicted(K key, V value) {
// optional override
}
/**
* 返回当前缓存所能允许的最大 size
*
* @return {@code maxSize}
*/
@Override
public synchronized int getMaxSize() {
return maxSize;
}
/**
* 返回当前缓存已占用的总 size
*
* @return {@code size}
*/
@Override
public synchronized int size() {
return currentSize;
}
/**
* 如果这个 {@code key} 在缓存中有对应的 {@code value} 并且不为 {@code null},则返回 true
*
* @param key 用来映射的 {@code key}
* @return {@code true} 为在容器中含有这个 {@code key}, 否则为 {@code false}
*/
@Override
public synchronized boolean containsKey(K key) {
return cache.containsKey(key);
}
/**
* 返回当前缓存中含有的所有 {@code key}
*
* @return {@code keySet}
*/
@Override
public synchronized Set<K> keySet() {
return cache.keySet();
}
/**
* 返回这个 {@code key} 在缓存中对应的 {@code value}, 如果返回 {@code null} 说明这个 {@code key} 没有对应的 {@code value}
*
* @param key 用来映射的 {@code key}
* @return {@code value}
*/
@Override
public synchronized V get(K key) {
return cache.get(key);
}
/**
* 将 {@code key} 和 {@code value} 以条目的形式加入缓存,如果这个 {@code key} 在缓存中已经有对应的 {@code value}
* 则此 {@code value} 被新的 {@code value} 替换并返回,如果为 {@code null} 说明是一个新条目
* <p>
* 如果 {@link #getItemSize} 返回的 size 大于或等于缓存所能允许的最大 size, 则不能向缓存中添加此条目
* 此时会回调 {@link #onItemEvicted(Object, Object)} 通知此方法当前被驱逐的条目
*
* @param key 通过这个 {@code key} 添加条目
* @param value 需要添加的 {@code value}
* @return 如果这个 {@code key} 在容器中已经储存有 {@code value}, 则返回之前的 {@code value} 否则返回 {@code null}
*/
@Override
public synchronized V put(K key, V value) {
final int itemSize = getItemSize(value);
if (itemSize >= maxSize) {
onItemEvicted(key, value);
return null;
}
final V result = cache.put(key, value);
if (value != null) {
currentSize += getItemSize(value);
}
if (result != null) {
currentSize -= getItemSize(result);
}
evict();
return result;
}
/**
* 移除缓存中这个 {@code key} 所对应的条目,并返回所移除条目的 {@code value}
* 如果返回为 {@code null} 则有可能时因为这个 {@code key} 对应的 {@code value} 为 {@code null} 或条目不存在
*
* @param key 使用这个 {@code key} 移除对应的条目
* @return 如果这个 {@code key} 在容器中已经储存有 {@code value} 并且删除成功则返回删除的 {@code value}, 否则返回 {@code null}
*/
@Override
public synchronized V remove(K key) {
final V value = cache.remove(key);
if (value != null) {
currentSize -= getItemSize(value);
}
return value;
}
/**
* 清除缓存中所有的内容
*/
@Override
public void clear() {
trimToSize(0);
}
/**
* 当指定的 size 小于当前缓存已占用的总 size 时,会开始清除缓存中最近最少使用的条目
*
* @param size {@code size}
*/
protected synchronized void trimToSize(int size) {
Map.Entry<K, V> last;
while (currentSize > size) {
last = cache.entrySet().iterator().next();
final V toRemove = last.getValue();
currentSize -= getItemSize(toRemove);
final K key = last.getKey();
cache.remove(key);
onItemEvicted(key, toRemove);
}
}
/**
* 当缓存中已占用的总 size 大于所能允许的最大 size ,会使用 {@link #trimToSize(int)} 开始清除满足条件的条目
*/
private void evict() {
trimToSize(maxSize);
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoSqlLite/src/main/java/com/yc/videosqllite/cache/VideoMapCache.java | Java | package com.yc.videosqllite.cache;
import com.yc.videosqllite.model.SafeKeyGenerator;
import com.yc.videosqllite.model.VideoLocation;
/**
* <pre>
* @author yangchong
* email : yangchong211@163.com
* time : 2020/8/6
* desc : 内存缓存
* revise:
* </pre>
*/
public class VideoMapCache {
/**
* 缓存
*/
private InterCache<String, VideoLocation> mCache;
private final SafeKeyGenerator safeKeyGenerator;
public VideoMapCache(){
//默认设置存储最大值为1000条
mCache = new VideoLruCache<>(1000);
this.safeKeyGenerator = new SafeKeyGenerator();
}
/**
* 存数据
* @param url 链接
* @param location 视频数据
*/
public synchronized void put(String url , VideoLocation location){
if (url==null || url.length()==0){
return;
}
if (location==null){
return;
}
//String key = VideoMd5Utils.encryptMD5ToString(url, cacheConfig.getSalt());
String safeKey = safeKeyGenerator.getSafeKey(url);
location.setUrlMd5(safeKey);
mCache.put(safeKey,location);
}
/**
* 取数据
* @param url 链接
* @return
*/
public synchronized long get(String url){
if (url==null || url.length()==0){
return -1;
}
//String key = VideoMd5Utils.encryptMD5ToString(url, cacheConfig.getSalt());
String key = safeKeyGenerator.getSafeKey(url);
VideoLocation videoLocation = mCache.get(key);
if (videoLocation==null){
//没找到
return -1;
}
if (videoLocation.getTotalTime()<=videoLocation.getPosition()){
//这一步主要是避免外部开发员瞎存播放进度
return -1;
}
long position = videoLocation.getPosition();
if (position<0){
position = -1;
}
return position;
}
/**
* 移除数据
* @param url 链接
* @return
*/
public synchronized boolean remove(String url){
if (url==null || url.length()==0){
return false;
}
//String key = VideoMd5Utils.encryptMD5ToString(url, cacheConfig.getSalt());
String key = safeKeyGenerator.getSafeKey(url);
VideoLocation location = mCache.remove(key);
if (location==null){
return false;
} else {
//移除成功
return true;
}
}
/**
* 是否包含
* @param url 链接
* @return
*/
public synchronized boolean containsKey(String url){
if (url==null || url.length()==0){
return false;
}
//String key = VideoMd5Utils.encryptMD5ToString(url, cacheConfig.getSalt());
String key = safeKeyGenerator.getSafeKey(url);
return mCache.containsKey(key);
}
/**
* 清楚所有数据
* @return 是否清楚完毕
*/
public synchronized boolean clearAll(){
mCache.clear();
int size = mCache.size();
if (size==0){
return true;
} else {
return false;
}
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoSqlLite/src/main/java/com/yc/videosqllite/disk/DiskCacheWriteLocker.java | Java | package com.yc.videosqllite.disk;
import java.util.ArrayDeque;
import java.util.HashMap;
import java.util.Map;
import java.util.Queue;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* <pre>
* @author yangchong
* email : yangchong211@163.com
* time : 2020/8/6
* desc : 磁盘缓存写，自定义锁
* revise:
* </pre>
*/
public final class DiskCacheWriteLocker {
private final Map<String, WriteLock> locks = new HashMap<>();
private final WriteLockPool writeLockPool = new WriteLockPool();
void acquire(String safeKey) {
WriteLock writeLock;
synchronized (this) {
writeLock = locks.get(safeKey);
if (writeLock == null) {
writeLock = writeLockPool.obtain();
locks.put(safeKey, writeLock);
}
writeLock.interestedThreads++;
}
writeLock.lock.lock();
}
void release(String safeKey) {
WriteLock writeLock;
synchronized (this) {
writeLock = DiskUtils.checkNotNull(locks.get(safeKey));
if (writeLock.interestedThreads < 1) {
throw new IllegalStateException("Cannot release a lock that is not held"
+ ", safeKey: " + safeKey
+ ", interestedThreads: " + writeLock.interestedThreads);
}
writeLock.interestedThreads--;
if (writeLock.interestedThreads == 0) {
WriteLock removed = locks.remove(safeKey);
if (removed != null && !removed.equals(writeLock)) {
throw new IllegalStateException("Removed the wrong lock"
+ ", expected to remove: " + writeLock
+ ", but actually removed: " + removed
+ ", safeKey: " + safeKey);
}
writeLockPool.offer(removed);
}
}
writeLock.lock.unlock();
}
private static class WriteLock {
final Lock lock = new ReentrantLock();
int interestedThreads;
@Synthetic
WriteLock() {
}
}
private static class WriteLockPool {
private static final int MAX_POOL_SIZE = 10;
private final Queue<WriteLock> pool = new ArrayDeque<>();
@Synthetic
WriteLockPool() {
}
WriteLock obtain() {
WriteLock result;
synchronized (pool) {
result = pool.poll();
}
if (result == null) {
result = new WriteLock();
}
return result;
}
void offer(WriteLock writeLock) {
synchronized (pool) {
if (pool.size() < MAX_POOL_SIZE) {
pool.offer(writeLock);
}
}
}
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoSqlLite/src/main/java/com/yc/videosqllite/disk/DiskFileUtils.java | Java | package com.yc.videosqllite.disk;
import android.content.Context;
import android.os.Environment;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.nio.channels.FileChannel;
import java.util.ArrayList;
import java.util.List;
/**
* <pre>
* @author yangchong
* email : yangchong211@163.com
* time : 2020/7/10
* desc : 保存日志的工具类
* revise:
* </pre>
*/
public final class DiskFileUtils {
/**
* 目录地址
* SDCard/Android/data/<application package>/cache
* data/data/<application package>/cache
*/
public static String getPath(Context context) {
String path = getCachePath(context) + File.separator + "disk";
return path;
}
/**
* 目录地址
* SDCard/Android/data/<application package>/cache
* data/data/<application package>/cache
* @param context 上下文
* @param pathName 路径名称
* @return
*/
public static String getPath(Context context , String pathName) {
String path = getCachePath(context) + File.separator + pathName;
return path;
}
/**
* 获取路径file
* @param context 上下文
* @return
*/
public static File getFilePath(Context context){
String path = getPath(context);
File file = new File(path);
return file;
}
/**
* 获取app缓存路径
* 如果sd卡可以使用，sd卡路径
* SDCard/Android/data/<application package>/cache
*
* 如果没有sd卡，则获取内部存储卡路径
* data/data/<application package>/cache
*
* @param context 上下文
* @return
*/
public static String getCachePath(Context context) {
String cachePath;
if (Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState())
|| !Environment.isExternalStorageRemovable()) {
//外部存储可用
if (context.getExternalCacheDir()!=null){
cachePath = context.getExternalCacheDir().getAbsolutePath();
} else {
cachePath = context.getCacheDir().getAbsolutePath();
}
} else {
//外部存储不可用
cachePath = context.getCacheDir().getAbsolutePath();
}
return cachePath;
}
/**
* 获取list集合
* @param context 上下文
* @return
*/
public static List<File> getFileList(Context context) {
File file = new File(com.yc.videosqllite.disk.DiskFileUtils.getPath(context));
List<File> mFileList = new ArrayList<>();
File[] fileArray = file.listFiles();
if (fileArray == null || fileArray.length <= 0) {
return mFileList;
}
for (File f : fileArray) {
if (f.isFile()) {
mFileList.add(f);
}
}
return mFileList;
}
/**
* 删除单个文件
*
* @param fileName 要删除的文件的文件名
* @return 单个文件删除成功返回true，否则返回false
*/
public static boolean deleteFile(String fileName) {
File file = new File(fileName);
// 如果文件路径所对应的文件存在，并且是一个文件，则直接删除
if (file.exists() && file.isFile()) {
if (file.delete()) {
return true;
} else {
return false;
}
} else {
return false;
}
}
/**
* 删除所有的文件
* @param root root目录
*/
public static void deleteAllFiles(File root) {
File files[] = root.listFiles();
if (files != null)
for (File f : files) {
if (f.isDirectory()) { // 判断是否为文件夹
deleteAllFiles(f);
try {
f.delete();
} catch (Exception e) {
//不要在for循环中打印e
}
} else {
if (f.exists()) { // 判断是否存在
deleteAllFiles(f);
try {
f.delete();
} catch (Exception e) {
//不要在for循环中打印e
}
}
}
}
}
/**
* 获取文件的内容
* @param fileName 文件名称
* @return
*/
public static String readFile2String(String fileName) {
String res = "";
try {
FileInputStream inputStream = new FileInputStream(fileName);
InputStreamReader inputStreamReader = null;
try {
inputStreamReader = new InputStreamReader(inputStream, "utf-8");
} catch (UnsupportedEncodingException e1) {
e1.printStackTrace();
}
BufferedReader reader = new BufferedReader(inputStreamReader);
StringBuilder sb = new StringBuilder("");
String line;
try {
while ((line = reader.readLine()) != null) {
sb.append(line);
sb.append("\n");
}
} catch (IOException e) {
e.printStackTrace();
}
res = sb.toString();
} catch (Exception e) {
e.printStackTrace();
}
return res;
}
/**
* 重命名文件
*
* @param oldPath 原来的文件地址
* @param newPath 新的文件地址
*/
public static void renameFile(String oldPath, String newPath) {
File oleFile = new File(oldPath);
File newFile = new File(newPath);
//执行重命名
oleFile.renameTo(newFile);
}
/**
* 根据文件路径拷贝文件
*
* @param src 源文件
* @param dest 目标文件
* @return boolean 成功true、失败false
*/
public static boolean copyFile(File src, File dest) {
boolean result = false;
if ((src == null) || (dest == null)) {
return result;
}
if (dest.exists()) {
dest.delete(); // delete file
}
if (!createOrExistsDir(dest.getParentFile())) {
return false;
}
try {
dest.createNewFile();
} catch (IOException e) {
e.printStackTrace();
}
FileChannel srcChannel = null;
FileChannel dstChannel = null;
try {
srcChannel = new FileInputStream(src).getChannel();
dstChannel = new FileOutputStream(dest).getChannel();
srcChannel.transferTo(0, srcChannel.size(), dstChannel);
result = true;
} catch (FileNotFoundException e) {
e.printStackTrace();
return result;
} catch (IOException e) {
e.printStackTrace();
return result;
}
try {
srcChannel.close();
dstChannel.close();
} catch (IOException e) {
e.printStackTrace();
}
return result;
}
public static boolean deleteFile(final File file) {
return file != null && (!file.exists() || file.isFile() && file.delete());
}
public static boolean createOrExistsDir(final File file) {
return file != null && (file.exists() ? file.isDirectory() : file.mkdirs());
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoSqlLite/src/main/java/com/yc/videosqllite/disk/DiskLruCache.java | Java | package com.yc.videosqllite.disk;
import java.io.BufferedWriter;
import java.io.Closeable;
import java.io.EOFException;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Writer;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.concurrent.Callable;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
/**
* <pre>
* @author yangchong
* email : yangchong211@163.com
* time : 2020/8/6
* desc : 磁盘缓存类
* revise:
* </pre>
*/
public final class DiskLruCache implements Closeable {
/**
* libcore.io.DiskLruCache
* 1
* 1
* 1
*
* DIRTY 27c7e00adbacc71dc793e5e7bf02f861
* CLEAN 27c7e00adbacc71dc793e5e7bf02f861 1208
* READ 27c7e00adbacc71dc793e5e7bf02f861
* DIRTY b80f9eec4b616dc6682c7fa8bas2061f
* CLEAN b80f9eec4b616dc6682c7fa8bas2061f 1208
* READ b80f9eec4b616dc6682c7fa8bas2061f
* DIRTY be3fgac81c12a08e89088555d85dfd2b
* CLEAN be3fgac81c12a08e89088555d85dfd2b 99
* READ be3fgac81c12a08e89088555d85dfd2b
* DIRTY 536990f4dbddfghcfbb8f350a941wsxd
* REMOVE 536990f4dbddfghcfbb8f350a941wsxd
*
* 第1行：libcore.io.DiskLruCache 是固定字符串，表明使用的是 DiskLruCache 技术；
* 第2行：DiskLruCache 的版本号，源码中为常量 1；
* 第3行：APP 的版本号，即我们在 open() 方法里传入的版本号；
* 第4行：valueCount，这个值也是在 open() 方法中传入的，指每个 key 对应几个文件，通常情况下都为 1；
* 第5行：空行
*
*
*/
static final String JOURNAL_FILE = "journal";
static final String JOURNAL_FILE_TEMP = "journal.tmp";
static final String JOURNAL_FILE_BACKUP = "journal.bkp";
static final String MAGIC = "libcore.io.DiskLruCache";
static final String VERSION_1 = "1";
static final long ANY_SEQUENCE_NUMBER = -1;
/**
* 该状态表示一个缓存Entry已经被成功发布了并且可以读取，该行后面会有每个Value的大小。
*/
private static final String CLEAN = "CLEAN";
/**
* 该状态表示一个Entry正在被创建或正在被更新，任意一个成功的DIRTY操作后面都会有一个CLEAN或REMOVE操作。
* 如果一个DIRTY操作后面没有CLEAN或者REMOVE操作，那就表示这是一个临时文件，应该将其删除。
*/
private static final String DIRTY = "DIRTY";
/**
* 表示被删除的缓存Entry。
*/
private static final String REMOVE = "REMOVE";
/**
* 在LRU缓存中被读取了。
*/
private static final String READ = "READ";
private final File directory;
private final File journalFile;
private final File journalFileTmp;
private final File journalFileBackup;
private final int appVersion;
private long maxSize;
private final int valueCount;
private long size = 0;
private Writer journalWriter;
private final LinkedHashMap<String, Entry> lruEntries =
new LinkedHashMap<String, Entry>(0, 0.75f, true);
/**
* 记录用户操作的次数，每执行一次写入、读取或移除缓存的操作，这个变量值都会加 1
* 当变量值达到 2000 时就会触发重构 journal 的事件，这时会自动把 journal 中多余的、不必要的记录全部清除掉，
* 保证 journal 文件的大小始终保持在一个合理的范围内。
*/
private int redundantOpCount;
/**
* 为了区分旧快照和当前快照，每次提交编辑时都给每个条目一个序号。如果快照的序列号不等于其条目的序列号，则快照失效。
*/
private long nextSequenceNumber = 0;
/**
* 该缓存使用单个后台线程来清除条目
*/
final ThreadPoolExecutor executorService =
new ThreadPoolExecutor(0, 1, 60L, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(),
new DiskLruCacheThreadFactory());
private final Callable<Void> cleanupCallable = new Callable<Void>() {
public Void call() throws Exception {
synchronized (DiskLruCache.this) {
if (journalWriter == null) {
return null; // Closed.
}
trimToSize();
if (journalRebuildRequired()) {
//创建一个新的日志，删除多余的信息
rebuildJournal();
redundantOpCount = 0;
}
}
return null;
}
};
private DiskLruCache(File directory, int appVersion, int valueCount, long maxSize) {
this.directory = directory;
this.appVersion = appVersion;
this.journalFile = new File(directory, JOURNAL_FILE);
this.journalFileTmp = new File(directory, JOURNAL_FILE_TEMP);
this.journalFileBackup = new File(directory, JOURNAL_FILE_BACKUP);
this.valueCount = valueCount;
this.maxSize = maxSize;
}
/**
* Opens the cache in {@code directory}, creating a cache if none exists
* there.
* 第一个参数表示磁盘缓存在文件系统中的存储路径。
* 第二个参数表示应用的版本号，一般设为 1 即可。当版本号发生改变时 DiskLruCache 会清空之前所有的缓存文件，
* 而这个特性在实际开发中作用并不大，很多情况下即使应用的版本号发生了改变缓存文件却仍然是有效的，因此这个参数设为 1 比较好。
* 第三个参数表示同一个 key 可以对应多少个缓存文件，一般设为 1 即可。
* 第四个参数表示缓存的总大小，比如 50MB，当缓存大小超出这个设定值后，DiskLruCache 会清除一些缓存从而保证总大小不大于这个设定值。
* @param directory a writable directory
* @param valueCount the number of values per cache entry. Must be positive.
* @param maxSize the maximum number of bytes this cache should use to store
* @throws IOException if reading or writing the cache directory fails
*/
public static DiskLruCache open(File directory, int appVersion, int valueCount, long maxSize)
throws IOException {
if (maxSize <= 0) {
throw new IllegalArgumentException("maxSize <= 0");
}
if (valueCount <= 0) {
throw new IllegalArgumentException("valueCount <= 0");
}
// 如果存在备份日志文件，则使用它
File backupFile = new File(directory, JOURNAL_FILE_BACKUP);
if (backupFile.exists()) {
File journalFile = new File(directory, JOURNAL_FILE);
// 如果存在正式的日志文件，则将备份日志文件删除
if (journalFile.exists()) {
backupFile.delete();
} else {
renameTo(backupFile, journalFile, false);
}
}
// 首先尝试读取日志文件
DiskLruCache cache = new DiskLruCache(directory, appVersion, valueCount, maxSize);
if (cache.journalFile.exists()) {
try {
//日志文件的读取过程
cache.readJournal();
//用于统计缓存文件的总体大小，并删除脏文件
cache.processJournal();
return cache;
} catch (IOException journalIsCorrupt) {
System.out
.println("DiskLruCache "
+ directory
+ " is corrupt: "
+ journalIsCorrupt.getMessage()
+ ", removing");
cache.delete();
}
}
// 此时日志文件不存在或读取出错，新建一个DiskLruCache实例
directory.mkdirs();
cache = new DiskLruCache(directory, appVersion, valueCount, maxSize);
//创建一个新的日志，删除多余的信息
cache.rebuildJournal();
return cache;
}
/**
* 日志文件的读取过程
* readJournal()方法其实就是通过readJournalLine(reader.readLine())方法读取日志文件中的每一行，
* 最终会读取到lruEntries中，lruEntries是DiskLruCache在内存中的表现形式。
* @throws IOException 异常
*/
private void readJournal() throws IOException {
StrictLineReader reader = new StrictLineReader(new FileInputStream(journalFile), DiskUtils.US_ASCII);
try {
//读取journal文件的前五行
String magic = reader.readLine();
String version = reader.readLine();
String appVersionString = reader.readLine();
String valueCountString = reader.readLine();
String blank = reader.readLine();
if (!MAGIC.equals(magic)
|| !VERSION_1.equals(version)
|| !Integer.toString(appVersion).equals(appVersionString)
|| !Integer.toString(valueCount).equals(valueCountString)
|| !"".equals(blank)) {
throw new IOException("unexpected journal header: [" + magic + ", " + version + ", "
+ valueCountString + ", " + blank + "]");
}
int lineCount = 0;
while (true) {
try {
//该方法用于读取每一行日志
readJournalLine(reader.readLine());
lineCount++;
} catch (EOFException endOfJournal) {
break;
}
}
redundantOpCount = lineCount - lruEntries.size();
// If we ended on a truncated line, rebuild the journal before appending to it.
if (reader.hasUnterminatedLine()) {
//创建一个新的日志，删除多余的信息
rebuildJournal();
} else {
journalWriter = new BufferedWriter(new OutputStreamWriter(
new FileOutputStream(journalFile, true), DiskUtils.US_ASCII));
}
} finally {
DiskUtils.closeQuietly(reader);
}
}
/**
* 该方法用于读取每一行日志。日志文件的每一行都是DIRTY、CLEAN、READ或REMOVE四种行为之一，那么该方法就需要对这4中情况分别处理。
* 大概思路：
* 1.首先取出该行记录的key，然后根据该记录是否为REMOVE进行不同的操作，如果是REMOVE，则将该key的缓存从lruEntries中移除。
* 2.如果不是REMOVE，说明该key存在一个对应的缓存实体Entry，则先新建一个Entry并添加到lruEntries中。
* 3.之后再判断日志的类型，如果日志是CLEAN，代表该文件已经保存完毕了，将currentEditor设置为null；
* 4.如果日志是DIRTY，代表文件没有保存完毕，为其currentEditor新建一个Editor。
*
* 为什么要这么做呢？
* 保存一个文件时会先写入DIRTY日志，保存成功后再写入CLEAN日志，一般来说这两条日志会成对出现。
* 这里的currentEditor相当于一个标志位，如果为空，表示文件完整，如果不为空，表示该文件是临时文件。
* @param line 每行内容
* @throws IOException io流异常
*/
private void readJournalLine(String line) throws IOException {
int firstSpace = line.indexOf(' ');
if (firstSpace == -1) {
throw new IOException("unexpected journal line: " + line);
}
int keyBegin = firstSpace + 1;
//journal 日志每一行中的各个部分都是用 ' ' 空格来分割的，所以先用 空格来截取一下
int secondSpace = line.indexOf(' ', keyBegin);
final String key;
if (secondSpace == -1) {
//拿到 key
key = line.substring(keyBegin);
// 如果是REMOVE，则将该key代表的缓存从lruEntries中移除
if (firstSpace == REMOVE.length() && line.startsWith(REMOVE)) {
//然后判断 firstSpace 是 REMOVE 就会调用 lruEntries.remove(key)
lruEntries.remove(key);
return;
}
} else {
//拿到 key
key = line.substring(keyBegin, secondSpace);
}
//取出当前key对应的缓存Entry
Entry entry = lruEntries.get(key);
if (entry == null) {
//若不是 REMOVE ，如果该 key 没有加入到 lruEntries ，则创建并且加入
entry = new Entry(key);
lruEntries.put(key, entry);
}
// 如果是CLEAN、DIRTY或READ
if (secondSpace != -1 && firstSpace == CLEAN.length() && line.startsWith(CLEAN)) {
//继续判断 firstSpace ，若是 CLEAN ，则初始化 entry ，设置 readable=true , currentEditor 为 null ，初始化长度等。
String[] parts = line.substring(secondSpace + 1).split(" ");
entry.readable = true;
entry.currentEditor = null;
entry.setLengths(parts);
} else if (secondSpace == -1 && firstSpace == DIRTY.length() && line.startsWith(DIRTY)) {
//若是 DIRTY ，则设置 currentEditor 对象。
entry.currentEditor = new Editor(entry);
} else if (secondSpace == -1 && firstSpace == READ.length() && line.startsWith(READ)) {
// This work was already done by calling lruEntries.get().
//若是 READ，无操作。
} else {
throw new IOException("unexpected journal line: " + line);
}
}
/**
* 计算初始大小并收集垃圾，作为打开缓存。假设脏条目是不一致的，将被删除。
*
*/
private void processJournal() throws IOException {
deleteIfExists(journalFileTmp);
for (Iterator<Entry> i = lruEntries.values().iterator(); i.hasNext(); ) {
Entry entry = i.next();
if (entry.currentEditor == null) {
for (int t = 0; t < valueCount; t++) {
size += entry.lengths[t];
}
} else {
entry.currentEditor = null;
for (int t = 0; t < valueCount; t++) {
deleteIfExists(entry.getCleanFile(t));
deleteIfExists(entry.getDirtyFile(t));
}
i.remove();
}
}
}
/**
* 创建一个新的日志，删除多余的信息。如果当前日志存在，则替换当前日志。
*/
private synchronized void rebuildJournal() throws IOException {
if (journalWriter != null) {
journalWriter.close();
}
FileOutputStream fileOutputStream = new FileOutputStream(journalFileTmp);
OutputStreamWriter outputStreamWriter = new OutputStreamWriter(fileOutputStream, DiskUtils.US_ASCII);
//高效字符流
Writer writer = new BufferedWriter(outputStreamWriter);
try {
//这一块是写入头部的5行
//libcore.io.DiskLruCache 是固定字符串，表明使用的是 DiskLruCache 技术；
writer.write(MAGIC);
writer.write("\n");
//DiskLruCache 的版本号，源码中为常量 1；
writer.write(VERSION_1);
writer.write("\n");
//APP 的版本号，即我们在 open() 方法里传入的版本号；
writer.write(Integer.toString(appVersion));
writer.write("\n");
//valueCount，这个值也是在 open() 方法中传入的，指每个 key 对应几个文件，通常情况下都为 1；
writer.write(Integer.toString(valueCount));
writer.write("\n");
//空行
writer.write("\n");
for (Entry entry : lruEntries.values()) {
if (entry.currentEditor != null) {
//看到DIRTY这个字样都不代表着什么好事情，意味着这是一条脏数据。
//没错，每当我们调用一次DiskLruCache的edit()方法时，都会向journal文件中写入一条DIRTY记录，
//表示我们正准备写入一条缓存数据，但不知结果如何。
writer.write(DIRTY + ' ' + entry.key + '\n');
} else {
writer.write(CLEAN + ' ' + entry.key + entry.getLengths() + '\n');
}
}
} finally {
writer.close();
}
if (journalFile.exists()) {
renameTo(journalFile, journalFileBackup, true);
}
renameTo(journalFileTmp, journalFile, false);
journalFileBackup.delete();
journalWriter = new BufferedWriter(
new OutputStreamWriter(new FileOutputStream(journalFile, true), DiskUtils.US_ASCII));
}
private static void deleteIfExists(File file) throws IOException {
if (file.exists() && !file.delete()) {
throw new IOException();
}
}
private static void renameTo(File from, File to, boolean deleteDestination) throws IOException {
if (deleteDestination) {
deleteIfExists(to);
}
if (!from.renameTo(to)) {
throw new IOException();
}
}
/**
* 读取缓存
* 返回名为{@code key}的条目的快照，如果不存在则返回null，这是当前不可读的。如果一个值被返回，它将被移动到LRU队列的头。
*/
public synchronized Value get(String key) throws IOException {
checkNotClosed();
//取出当前key对应的缓存Entry
Entry entry = lruEntries.get(key);
if (entry == null) {
return null;
}
if (!entry.readable) {
return null;
}
for (File file : entry.cleanFiles) {
// A file must have been deleted manually!
if (!file.exists()) {
// 除非用户手动删了文件, 否则不会执行到这里...
return null;
}
}
redundantOpCount++;
journalWriter.append(READ);
journalWriter.append(' ');
journalWriter.append(key);
journalWriter.append('\n');
if (journalRebuildRequired()) {
executorService.submit(cleanupCallable);
}
return new Value(key, entry.sequenceNumber, entry.cleanFiles, entry.lengths);
}
/**
* 返回名为{@code key}的条目的编辑器，如果正在进行另一个编辑，则返回null。
* 这个key将会成为缓存文件的文件名
*/
public Editor edit(String key) throws IOException {
return edit(key, ANY_SEQUENCE_NUMBER);
}
/**
* 如何写缓存？
* 写缓存的时候需要先通过edit(String key)方法新建一个Editor，然后将数据写入Editor的输出流中，最后成功则调用
* Editor.commit()，失败则调用Editor.abort()。
*
* 该方法大概思路
* 1.取出当前key对应的缓存Entry，如果Entry不存在则新建并添加到lruEntries中，
* 2.如果存在且entry.currentEditor不为空，表示Entry正在进行缓存编辑。
* 3.随后新建一个Editor，并在日志文件中输出一行DIRTY日志表示开始编辑缓存文件。
* @param key key
* @param expectedSequenceNumber number
* @return
* @throws IOException 异常
*/
private synchronized Editor edit(String key, long expectedSequenceNumber) throws IOException {
checkNotClosed();
//取出当前key对应的缓存Entry
Entry entry = lruEntries.get(key);
if (expectedSequenceNumber != ANY_SEQUENCE_NUMBER && (entry == null
|| entry.sequenceNumber != expectedSequenceNumber)) {
return null; // Value is stale.
}
if (entry == null) {
//如果Entry不存在则新建并添加到lruEntries中
entry = new Entry(key);
lruEntries.put(key, entry);
} else if (entry.currentEditor != null) {
//如果存在且entry.currentEditor不为空，表示Entry正在进行缓存编辑
return null; // Another edit is in progress.
}
//随后新建一个Editor，并在日志文件中输出一行DIRTY日志表示开始编辑缓存文件。
Editor editor = new Editor(entry);
entry.currentEditor = editor;
// Flush the journal before creating files to prevent file leaks.
// 为了防止文件泄露，在创建文件前，将日志立即写入journal中
journalWriter.append(DIRTY);
journalWriter.append(' ');
journalWriter.append(key);
journalWriter.append('\n');
journalWriter.flush();
return editor;
}
/**
* 返回该缓存存储其数据的目录。
*/
public File getDirectory() {
return directory;
}
/**
* 返回此缓存用于存储其数据的最大字节数。
*/
public synchronized long getMaxSize() {
return maxSize;
}
/**
* 更改缓存可以存储的最大字节数，并在必要时对作业进行排队，以精简现有的存储。
*/
public synchronized void setMaxSize(long maxSize) {
this.maxSize = maxSize;
executorService.submit(cleanupCallable);
}
/**
* 返回当前用于在此缓存中存储值的字节数。如果后台删除挂起，这个值可能大于最大大小。
* 这个方法会返回当前缓存路径下所有缓存数据的总字节数，以byte为单位，
* 如果应用程序中需要在界面上显示当前缓存数据的总大小，就可以通过调用这个方法计算出来。
*/
public synchronized long size() {
return size;
}
/**
* 该方法首先根据文件写入是否成功来重命名或者删除tmp文件，随后向journal写入日志，最后判断是否需要清理磁盘空间。
* @param editor editor对象
* @param success 是否成功
* @throws IOException
*/
private synchronized void completeEdit(Editor editor, boolean success) throws IOException {
Entry entry = editor.entry;
if (entry.currentEditor != editor) {
throw new IllegalStateException();
}
// 如果当前编辑是第一次创建Entry，那么每个索引上都应该有值
// valueCount表示一个Entry中的value数量
if (success && !entry.readable) {
for (int i = 0; i < valueCount; i++) {
if (!editor.written[i]) {
editor.abort();
throw new IllegalStateException("Newly created entry didn't create value for index " + i);
}
if (!entry.getDirtyFile(i).exists()) {
editor.abort();
return;
}
}
}
// 遍历Entry上的每个文件
// 如果编辑成功就将临时文件改名, 如果失败则删除临时文件
for (int i = 0; i < valueCount; i++) {
File dirty = entry.getDirtyFile(i);
if (success) {
if (dirty.exists()) {
File clean = entry.getCleanFile(i);
dirty.renameTo(clean);
long oldLength = entry.lengths[i];
long newLength = clean.length();
entry.lengths[i] = newLength;
size = size - oldLength + newLength;
}
} else {
deleteIfExists(dirty);
}
}
redundantOpCount++;
entry.currentEditor = null;
if (entry.readable | success) {
entry.readable = true;
journalWriter.append(CLEAN);
journalWriter.append(' ');
journalWriter.append(entry.key);
journalWriter.append(entry.getLengths());
journalWriter.append('\n');
if (success) {
// 给Entry的sequenceNumber赋值, 用于标记snapshot是否过期
// 如果Entry和snapshot的sequenceNumber不同, 则表示数据已经过期了
entry.sequenceNumber = nextSequenceNumber++;
}
} else {
lruEntries.remove(entry.key);
journalWriter.append(REMOVE);
journalWriter.append(' ');
journalWriter.append(entry.key);
journalWriter.append('\n');
}
journalWriter.flush();
// 判断是否需要清理磁盘空间
if (size > maxSize || journalRebuildRequired()) {
executorService.submit(cleanupCallable);
}
}
/**
* 只有当日志大小减半并消除至少2000个ops时，我们才重新生成日志。
* 在写入数据，获取数据或者移除数据时都会做校验
*/
private boolean journalRebuildRequired() {
final int redundantOpCompactThreshold = 2000;
return redundantOpCount >= redundantOpCompactThreshold //
&& redundantOpCount >= lruEntries.size();
}
/**
* 删除{@code key}的条目，如果它存在并且可以被删除。正在编辑的条目不能删除。
* @return true if an entry was removed.
*/
public synchronized boolean remove(String key) throws IOException {
checkNotClosed();
//取出当前key对应的缓存Entry
Entry entry = lruEntries.get(key);
if (entry == null || entry.currentEditor != null) {
return false;
}
for (int i = 0; i < valueCount; i++) {
File file = entry.getCleanFile(i);
if (file.exists() && !file.delete()) {
throw new IOException("failed to delete " + file);
}
size -= entry.lengths[i];
entry.lengths[i] = 0;
}
redundantOpCount++;
journalWriter.append(REMOVE);
journalWriter.append(' ');
journalWriter.append(key);
journalWriter.append('\n');
lruEntries.remove(key);
if (journalRebuildRequired()) {
executorService.submit(cleanupCallable);
}
return true;
}
/**
* Returns true if this cache has been closed.
*/
public synchronized boolean isClosed() {
return journalWriter == null;
}
private void checkNotClosed() {
if (journalWriter == null) {
throw new IllegalStateException("cache is closed");
}
}
/**
* 强制对文件系统进行缓冲操作。
* 这个方法用于将内存中的操作记录同步到日志文件（也就是journal文件）当中。
* 这个方法非常重要，因为DiskLruCache能够正常工作的前提就是要依赖于journal文件中的内容。
* 并不是每次写读缓存都要调用一次flush()方法，频繁地调用并不会带来任何好处，只会额外增加同步journal文件的时间。
* 比较标准的做法就是在Activity的onPause()方法中去调用一次flush()方法就可以了。
*/
public synchronized void flush() throws IOException {
checkNotClosed();
trimToSize();
journalWriter.flush();
}
/**
* 这个方法用于将DiskLruCache关闭掉，是和open()方法对应的一个方法。
* 关闭掉了之后就不能再调用DiskLruCache中任何操作缓存数据的方法
* 通常只应该在Activity的onDestroy()方法中去调用close()方法。
*/
public synchronized void close() throws IOException {
if (journalWriter == null) {
return; // Already closed.
}
for (Entry entry : new ArrayList<Entry>(lruEntries.values())) {
if (entry.currentEditor != null) {
entry.currentEditor.abort();
}
}
trimToSize();
journalWriter.close();
journalWriter = null;
}
private void trimToSize() throws IOException {
while (size > maxSize) {
Map.Entry<String, Entry> toEvict = lruEntries.entrySet().iterator().next();
remove(toEvict.getKey());
}
}
/**
* 关闭缓存并删除其存储的所有值。这将删除缓存目录中的所有文件，包括不是由缓存创建的文件。
*/
public void delete() throws IOException {
close();
DiskUtils.deleteContents(directory);
}
private static String inputStreamToString(InputStream in) throws IOException {
//写数据，一次读取一个字节
return DiskUtils.readFully(new InputStreamReader(in, DiskUtils.UTF_8));
}
/**
* A snapshot of the values for an entry.
*/
public final class Value {
private final String key;
private final long sequenceNumber;
private final long[] lengths;
private final File[] files;
private Value(String key, long sequenceNumber, File[] files, long[] lengths) {
this.key = key;
this.sequenceNumber = sequenceNumber;
this.files = files;
this.lengths = lengths;
}
/**
* Returns an editor for this snapshot's entry, or null if either the
* entry has changed since this snapshot was created or if another edit
* is in progress.
*/
public Editor edit() throws IOException {
return DiskLruCache.this.edit(key, sequenceNumber);
}
public File getFile(int index) {
return files[index];
}
/**
* Returns the string value for {@code index}.
*/
public String getString(int index) throws IOException {
InputStream is = new FileInputStream(files[index]);
return inputStreamToString(is);
}
/**
* Returns the byte length of the value for {@code index}.
*/
public long getLength(int index) {
return lengths[index];
}
}
/**
* 编辑条目的值。
*/
public final class Editor {
private final Entry entry;
private final boolean[] written;
private boolean committed;
private Editor(Entry entry) {
this.entry = entry;
this.written = (entry.readable) ? null : new boolean[valueCount];
}
/**
* 返回一个未缓冲的输入流来读取最后提交的值，如果没有提交值，则返回null。
*/
private InputStream newInputStream(int index) throws IOException {
synchronized (DiskLruCache.this) {
if (entry.currentEditor != this) {
throw new IllegalStateException();
}
if (!entry.readable) {
return null;
}
try {
return new FileInputStream(entry.getCleanFile(index));
} catch (FileNotFoundException e) {
return null;
}
}
}
/**
* 以字符串的形式返回最后一个提交的值，如果没有提交值，则返回null。
*/
public String getString(int index) throws IOException {
//创建io流对象
InputStream in = newInputStream(index);
//如果流对象不为空，则写入数据
return in != null ? inputStreamToString(in) : null;
}
public File getFile(int index) throws IOException {
synchronized (DiskLruCache.this) {
if (entry.currentEditor != this) {
throw new IllegalStateException();
}
if (!entry.readable) {
written[index] = true;
}
File dirtyFile = entry.getDirtyFile(index);
if (!directory.exists()) {
directory.mkdirs();
}
return dirtyFile;
}
}
/**
* Sets the value at {@code index} to {@code value}.
*/
public void set(int index, String value) throws IOException {
Writer writer = null;
try {
File file = getFile(index);
//创建输出流对象
OutputStream os = new FileOutputStream(file);
writer = new OutputStreamWriter(os, DiskUtils.UTF_8);
//写数据
writer.write(value);
} finally {
//关闭流对象
DiskUtils.closeQuietly(writer);
}
}
/**
* 成功后调用Editor.commit()
* 提交此编辑，使其对读者可见。这释放了编辑锁，因此可以在同一键上启动另一个编辑。
*/
public void commit() throws IOException {
// The object using this Editor must catch and handle any errors
// during the write. If there is an error and they call commit
// anyway, we will assume whatever they managed to write was valid.
// Normally they should call abort.
completeEdit(this, true);
committed = true;
}
/**
* 失败后调用Editor.abort()方法
* 中止这个编辑。这释放了编辑锁，因此可以在同一键上启动另一个编辑。
*/
public void abort() throws IOException {
completeEdit(this, false);
}
public void abortUnlessCommitted() {
if (!committed) {
try {
abort();
} catch (IOException ignored) {
}
}
}
}
private final class Entry {
private final String key;
/**
* 条目的文件长度
*/
private final long[] lengths;
/**
* Memoized File objects for this entry to avoid char[] allocations.
*/
File[] cleanFiles;
File[] dirtyFiles;
/**
* 如果这个条目曾经被发表过，则为真。
*/
private boolean readable;
/**
* 正在进行的编辑，如果该条目没有被编辑，则为空。
*/
private Editor currentEditor;
/**
* 最近提交到该条目的编辑的序列号
*/
private long sequenceNumber;
private Entry(String key) {
this.key = key;
this.lengths = new long[valueCount];
cleanFiles = new File[valueCount];
dirtyFiles = new File[valueCount];
// The names are repetitive so re-use the same builder to avoid allocations.
StringBuilder fileBuilder = new StringBuilder(key).append('.');
int truncateTo = fileBuilder.length();
for (int i = 0; i < valueCount; i++) {
fileBuilder.append(i);
cleanFiles[i] = new File(directory, fileBuilder.toString());
fileBuilder.append(".tmp");
dirtyFiles[i] = new File(directory, fileBuilder.toString());
fileBuilder.setLength(truncateTo);
}
}
public String getLengths() throws IOException {
StringBuilder result = new StringBuilder();
for (long size : lengths) {
result.append(' ').append(size);
}
return result.toString();
}
/**
* Set lengths using decimal numbers like "10123".
*/
private void setLengths(String[] strings) throws IOException {
if (strings.length != valueCount) {
throw invalidLengths(strings);
}
try {
for (int i = 0; i < strings.length; i++) {
lengths[i] = Long.parseLong(strings[i]);
}
} catch (NumberFormatException e) {
throw invalidLengths(strings);
}
}
private IOException invalidLengths(String[] strings) throws IOException {
throw new IOException("unexpected journal line: " + java.util.Arrays.toString(strings));
}
public File getCleanFile(int i) {
return cleanFiles[i];
}
public File getDirtyFile(int i) {
return dirtyFiles[i];
}
}
/**
* A {@link ThreadFactory} that builds a thread with a specific thread name
* and with minimum priority.
*/
private static final class DiskLruCacheThreadFactory implements ThreadFactory {
@Override
public synchronized Thread newThread(Runnable runnable) {
//设置线程优先级
Thread result = new Thread(runnable, "video-disk-lru-cache-thread");
result.setPriority(Thread.MIN_PRIORITY);
return result;
}
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoSqlLite/src/main/java/com/yc/videosqllite/disk/DiskLruCacheFactory.java | Java | package com.yc.videosqllite.disk;
import com.yc.videosqllite.model.SafeKeyGenerator;
import java.io.File;
public class DiskLruCacheFactory implements InterDiskFactory {
private final long diskCacheSize;
private final DiskLruCacheFactory.CacheDirectoryGetter cacheDirectoryGetter;
/**
* 接口被UI线程调用以获取缓存文件夹。
*/
public interface CacheDirectoryGetter {
File getCacheDirectory();
}
public DiskLruCacheFactory(final String diskCacheFolder, long diskCacheSize) {
this(new DiskLruCacheFactory.CacheDirectoryGetter() {
@Override
public File getCacheDirectory() {
return new File(diskCacheFolder);
}
}, diskCacheSize);
}
public DiskLruCacheFactory(final String diskCacheFolder, final String diskCacheName, long diskCacheSize) {
this(new DiskLruCacheFactory.CacheDirectoryGetter() {
@Override
public File getCacheDirectory() {
return new File(diskCacheFolder, diskCacheName);
}
}, diskCacheSize);
}
/**
* When using this constructor {@link DiskLruCacheFactory.CacheDirectoryGetter#getCacheDirectory()} will be called out
* of UI thread, allowing to do I/O access without performance impacts.
*
* @param cacheDirectoryGetter 接口被UI线程调用以获取缓存文件夹
* @param diskCacheSize LRU磁盘缓存所需的最大字节大小
*/
@SuppressWarnings("WeakerAccess")
public DiskLruCacheFactory(DiskLruCacheFactory.CacheDirectoryGetter cacheDirectoryGetter, long diskCacheSize) {
this.diskCacheSize = diskCacheSize;
this.cacheDirectoryGetter = cacheDirectoryGetter;
}
@Override
public InterDiskCache build() {
File cacheDir = cacheDirectoryGetter.getCacheDirectory();
if (cacheDir == null) {
return null;
}
if (!cacheDir.mkdirs() && (!cacheDir.exists() || !cacheDir.isDirectory())) {
return null;
}
return DiskLruCacheWrapper.create(cacheDir, new SafeKeyGenerator());
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoSqlLite/src/main/java/com/yc/videosqllite/disk/DiskLruCacheWrapper.java | Java | package com.yc.videosqllite.disk;
import androidx.annotation.Nullable;
import com.yc.videosqllite.manager.CacheConfig;
import com.yc.videosqllite.manager.LocationManager;
import com.yc.videosqllite.model.SafeKeyGenerator;
import com.yc.videosqllite.utils.CacheLogUtils;
import java.io.File;
import java.io.IOException;
/**
* <pre>
* @author yangchong
* email : yangchong211@163.com
* time : 2020/8/6
* desc : 磁盘缓存实现类
* revise:
* </pre>
*/
public class DiskLruCacheWrapper implements InterDiskCache {
private static final int APP_VERSION = 1;
private static final int VALUE_COUNT = 1;
private static DiskLruCacheWrapper wrapper;
public final SafeKeyGenerator safeKeyGenerator;
private final File directory;
private final long maxSize;
private final DiskCacheWriteLocker writeLocker = new DiskCacheWriteLocker();
private DiskLruCache diskLruCache;
@SuppressWarnings("deprecation")
public static synchronized InterDiskCache get(File directory, SafeKeyGenerator safeKeyGenerator) {
if (wrapper == null) {
wrapper = new DiskLruCacheWrapper(directory,safeKeyGenerator);
}
return wrapper;
}
@SuppressWarnings("deprecation")
public static InterDiskCache create(File directory, SafeKeyGenerator safeKeyGenerator) {
return new DiskLruCacheWrapper(directory,safeKeyGenerator);
}
@Deprecated
@SuppressWarnings({"WeakerAccess", "DeprecatedIsStillUsed"})
protected DiskLruCacheWrapper(File directory,SafeKeyGenerator safeKeyGenerator) {
CacheConfig cacheConfig = LocationManager.getInstance().getCacheConfig();
this.directory = directory;
this.safeKeyGenerator = safeKeyGenerator;
this.maxSize = cacheConfig.getCacheMax();
}
private synchronized DiskLruCache getDiskCache() throws IOException {
if (diskLruCache == null) {
diskLruCache = DiskLruCache.open(directory, APP_VERSION, VALUE_COUNT, maxSize);
}
return diskLruCache;
}
@Nullable
@Override
public String get(String key) {
String safeKey = safeKeyGenerator.getSafeKey(key);
String result = null;
try {
final DiskLruCache.Value value = getDiskCache().get(safeKey);
if (value != null) {
result = value.getString(0);
}
} catch (IOException e) {
CacheLogUtils.d("DiskLruCacheWrapper-----Unable to get from disk cache-"+e);
} finally {
try {
getDiskCache().flush();
} catch (IOException e) {
e.printStackTrace();
}
}
return result;
}
@Override
public void put(String key, String data) {
String safeKey = safeKeyGenerator.getSafeKey(key);
writeLocker.acquire(safeKey);
try {
CacheLogUtils.d("DiskLruCacheWrapper-----Put: Obtained:"+ safeKey + " for for Key: " + key);
try {
DiskLruCache diskCache = getDiskCache();
DiskLruCache.Value current = diskCache.get(safeKey);
if (current != null) {
return;
}
DiskLruCache.Editor editor = diskCache.edit(safeKey);
if (editor == null) {
throw new IllegalStateException("Had two simultaneous puts for: " + safeKey);
}
try {
editor.set(0,data);
editor.commit();
} finally {
editor.abortUnlessCommitted();
}
} catch (IOException e) {
CacheLogUtils.d("DiskLruCacheWrapper-----Unable to put from disk cache-"+e);
} finally {
try {
getDiskCache().flush();
} catch (IOException e) {
e.printStackTrace();
}
}
} finally {
writeLocker.release(safeKey);
}
}
@Override
public boolean remove(String key) {
String safeKey = safeKeyGenerator.getSafeKey(key);
boolean isRemove;
try {
isRemove = getDiskCache().remove(safeKey);
} catch (IOException e) {
CacheLogUtils.d("DiskLruCacheWrapper-----Unable to delete from disk cache-"+e);
isRemove = false;
} finally {
try {
getDiskCache().flush();
} catch (IOException e) {
e.printStackTrace();
}
}
return isRemove;
}
@Override
public boolean containsKey(String key) {
String safeKey = safeKeyGenerator.getSafeKey(key);
boolean result = false;
try {
final DiskLruCache.Value value = getDiskCache().get(safeKey);
if (value != null) {
String string = value.getString(0);
if (string!=null && string.length() > 0){
result = true;
}
}
} catch (IOException e) {
CacheLogUtils.d("DiskLruCacheWrapper-----Unable to get from disk cache-"+e);
} finally {
try {
getDiskCache().flush();
} catch (IOException e) {
e.printStackTrace();
}
}
return result;
}
@Override
public void clear() {
try {
getDiskCache().delete();
} catch (IOException e) {
CacheLogUtils.d("DiskLruCacheWrapper-----Unable to clear disk cache or disk cache cleared externally-"+e);
} finally {
try {
getDiskCache().flush();
} catch (IOException e) {
e.printStackTrace();
}
resetDiskCache();
}
}
private synchronized void resetDiskCache() {
diskLruCache = null;
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoSqlLite/src/main/java/com/yc/videosqllite/disk/DiskUtils.java | Java | package com.yc.videosqllite.disk;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import java.io.Closeable;
import java.io.File;
import java.io.IOException;
import java.io.Reader;
import java.io.StringWriter;
import java.nio.charset.Charset;
/**
* <pre>
* @author yangchong
* email : yangchong211@163.com
* time : 2020/8/6
* desc : 磁盘缓存工具类
* revise:
* </pre>
*/
public final class DiskUtils {
static final Charset US_ASCII = Charset.forName("US-ASCII");
static final Charset UTF_8 = Charset.forName("UTF-8");
private DiskUtils() {
}
static String readFully(Reader reader) throws IOException {
try {
StringWriter writer = new StringWriter();
char[] buffer = new char[1024];
int count;
while ((count = reader.read(buffer)) != -1) {
writer.write(buffer, 0, count);
}
return writer.toString();
} finally {
reader.close();
}
}
/**
* Deletes the contents of {@code dir}. Throws an IOException if any file
* could not be deleted, or if {@code dir} is not a readable directory.
*/
static void deleteContents(File dir) throws IOException {
File[] files = dir.listFiles();
if (files == null) {
throw new IOException("not a readable directory: " + dir);
}
for (File file : files) {
if (file.isDirectory()) {
deleteContents(file);
}
if (!file.delete()) {
throw new IOException("failed to delete file: " + file);
}
}
}
static void closeQuietly(/*Auto*/Closeable closeable) {
if (closeable != null) {
try {
closeable.close();
} catch (RuntimeException rethrown) {
throw rethrown;
} catch (Exception ignored) {
}
}
}
@NonNull
public static <T> T checkNotNull(@Nullable T arg) {
return checkNotNull(arg, "Argument must not be null");
}
@NonNull
public static <T> T checkNotNull(@Nullable T arg, @NonNull String message) {
if (arg == null) {
throw new NullPointerException(message);
}
return arg;
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoSqlLite/src/main/java/com/yc/videosqllite/disk/ExternalDiskCacheFactory.java | Java | package com.yc.videosqllite.disk;
import android.content.Context;
import androidx.annotation.Nullable;
import java.io.File;
/**
* <pre>
* @author yangchong
* email : yangchong211@163.com
* time : 2020/8/6
* desc : 创建一个基于外部的磁盘缓存目录，如果没有外部存储，则返回到内部磁盘缓存可用。
* 如果曾经退回到内部磁盘缓存，将从那一刻起使用那个缓存。
* revise:
* </pre>
*/
public final class ExternalDiskCacheFactory extends DiskLruCacheFactory {
public ExternalDiskCacheFactory(Context context) {
this(context, InterDiskFactory.DEFAULT_DISK_CACHE_DIR, InterDiskFactory.DEFAULT_DISK_CACHE_SIZE);
}
public ExternalDiskCacheFactory(Context context, long diskCacheSize) {
this(context, InterDiskFactory.DEFAULT_DISK_CACHE_DIR, diskCacheSize);
}
public ExternalDiskCacheFactory(final Context context, final String diskCacheName, final long diskCacheSize) {
super(new CacheDirectoryGetter() {
@Nullable
private File getInternalCacheDirectory() {
File cacheDirectory = context.getCacheDir();
if (cacheDirectory == null) {
return null;
}
if (diskCacheName != null) {
return new File(cacheDirectory, diskCacheName);
}
return cacheDirectory;
}
@Override
public File getCacheDirectory() {
File internalCacheDirectory = getInternalCacheDirectory();
// Already used internal cache, so keep using that one,
// thus avoiding using both external and internal with transient errors.
if ((null != internalCacheDirectory) && internalCacheDirectory.exists()) {
return internalCacheDirectory;
}
File cacheDirectory = context.getExternalCacheDir();
// Shared storage is not available.
if ((cacheDirectory == null) || (!cacheDirectory.canWrite())) {
return internalCacheDirectory;
}
if (diskCacheName != null) {
return new File(cacheDirectory, diskCacheName);
}
return cacheDirectory;
}
}, diskCacheSize);
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoSqlLite/src/main/java/com/yc/videosqllite/disk/InterDiskCache.java | Java | package com.yc.videosqllite.disk;
/**
* <pre>
* @author yangchong
* email : yangchong211@163.com
* time : 2020/8/6
* desc : 磁盘缓存接口
* revise:
* </pre>
*/
public interface InterDiskCache {
String get(String key);
void put(String key, String data);
boolean remove(String key);
boolean containsKey(String key);
void clear();
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoSqlLite/src/main/java/com/yc/videosqllite/disk/InterDiskFactory.java | Java | package com.yc.videosqllite.disk;
interface InterDiskFactory {
/** 250 MB of cache. */
int DEFAULT_DISK_CACHE_SIZE = 250 * 1024 * 1024;
String DEFAULT_DISK_CACHE_DIR = "disk";
InterDiskCache build();
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoSqlLite/src/main/java/com/yc/videosqllite/disk/InternalDiskCacheFactory.java | Java | package com.yc.videosqllite.disk;
import android.content.Context;
import java.io.File;
/**
* <pre>
* @author yangchong
* email : yangchong211@163.com
* time : 2020/8/6
* desc : 创建一个基于内部的磁盘缓存磁盘缓存目录
* revise:
* </pre>
*/
public final class InternalDiskCacheFactory extends DiskLruCacheFactory {
public InternalDiskCacheFactory(Context context) {
this(context, InterDiskFactory.DEFAULT_DISK_CACHE_DIR,
InterDiskFactory.DEFAULT_DISK_CACHE_SIZE);
}
public InternalDiskCacheFactory(Context context, long diskCacheSize) {
this(context, InterDiskFactory.DEFAULT_DISK_CACHE_DIR, diskCacheSize);
}
public InternalDiskCacheFactory(final Context context, final String diskCacheName,
long diskCacheSize) {
super(new CacheDirectoryGetter() {
@Override
public File getCacheDirectory() {
File cacheDirectory = context.getCacheDir();
if (cacheDirectory == null) {
return null;
}
if (diskCacheName != null) {
return new File(cacheDirectory, diskCacheName);
}
return cacheDirectory;
}
}, diskCacheSize);
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoSqlLite/src/main/java/com/yc/videosqllite/disk/SqlLiteCache.java | Java | package com.yc.videosqllite.disk;
import com.yc.videosqllite.manager.CacheConfig;
import com.yc.videosqllite.manager.LocationManager;
import com.yc.videosqllite.model.SafeKeyGenerator;
import com.yc.videosqllite.model.VideoLocation;
import com.yc.videosqllite.utils.CacheLogUtils;
import java.io.File;
/**
* <pre>
* @author yangchong
* email : yangchong211@163.com
* time : 2020/8/6
* desc : 磁盘缓存工具
* revise:
* </pre>
*/
public class SqlLiteCache {
private InterDiskCache interDiskCache;
public final SafeKeyGenerator safeKeyGenerator;
public SqlLiteCache() {
CacheConfig cacheConfig = LocationManager.getInstance().getCacheConfig();
File path = DiskFileUtils.getFilePath(cacheConfig.getContext());
String pathString = path.getPath();
CacheLogUtils.d("SqlLiteCache-----pathString路径输出地址-"+pathString);
this.safeKeyGenerator = new SafeKeyGenerator();
interDiskCache = DiskLruCacheWrapper.get(path,safeKeyGenerator);
}
/**
* 存数据
* @param url 链接
* @param location 视频数据
*/
public synchronized void put(String url , VideoLocation location){
if (location==null){
return;
}
String safeKey = safeKeyGenerator.getSafeKey(url);
location.setUrlMd5(safeKey);
String json = location.toJson();
CacheLogUtils.d("SqlLiteCache-----put--json--"+json);
interDiskCache.put(url,json);
}
/**
* 取数据
* @param url 链接
* @return
*/
public synchronized long get(String url){
String data = interDiskCache.get(url);
if (data==null || data.length()==0){
return -1;
}
CacheLogUtils.d("SqlLiteCache-----get---"+data);
VideoLocation location = VideoLocation.toObject(data);
return location.getPosition();
}
/**
* 移除数据
* @param url 链接
* @return
*/
public synchronized boolean remove(String url){
return interDiskCache.remove(url);
}
/**
* 是否包含
* @param url 链接
* @return
*/
public synchronized boolean containsKey(String url){
return interDiskCache.containsKey(url);
}
/**
* 清楚所有数据
* @return 是否清楚完毕
*/
public synchronized void clearAll(){
interDiskCache.clear();
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoSqlLite/src/main/java/com/yc/videosqllite/disk/StrictLineReader.java | Java |
package com.yc.videosqllite.disk;
import java.io.ByteArrayOutputStream;
import java.io.Closeable;
import java.io.EOFException;
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.nio.charset.Charset;
/**
* <pre>
* @author yangchong
* email : yangchong211@163.com
* time : 2020/8/6
* desc : 缓冲区来自{@link InputStream}的输入用于读取行
* revise:
* </pre>
*/
public class StrictLineReader implements Closeable {
private static final byte CR = (byte) '\r';
private static final byte LF = (byte) '\n';
private final InputStream in;
private final Charset charset;
/*
* Buffered data is stored in {@code buf}. As long as no exception occurs, 0 <= pos <= end
* and the data in the range [pos, end) is buffered for reading. At end of input, if there is
* an unterminated line, we set end == -1, otherwise end == pos. If the underlying
* {@code InputStream} throws an {@code IOException}, end may remain as either pos or -1.
*/
private byte[] buf;
private int pos;
private int end;
/**
* Constructs a new {@code LineReader} with the specified charset and the default capacity.
*
* @param in the {@code InputStream} to read data from.
* @param charset the charset used to decode data. Only US-ASCII, UTF-8 and ISO-8859-1 are
* supported.
* @throws NullPointerException if {@code in} or {@code charset} is null.
* @throws IllegalArgumentException if the specified charset is not supported.
*/
public StrictLineReader(InputStream in, Charset charset) {
this(in, 8192, charset);
}
/**
* Constructs a new {@code LineReader} with the specified capacity and charset.
*
* @param in the {@code InputStream} to read data from.
* @param capacity the capacity of the buffer.
* @param charset the charset used to decode data. Only US-ASCII, UTF-8 and ISO-8859-1 are
* supported.
* @throws NullPointerException if {@code in} or {@code charset} is null.
* @throws IllegalArgumentException if {@code capacity} is negative or zero
* or the specified charset is not supported.
*/
public StrictLineReader(InputStream in, int capacity, Charset charset) {
if (in == null || charset == null) {
throw new NullPointerException();
}
if (capacity < 0) {
throw new IllegalArgumentException("capacity <= 0");
}
if (!(charset.equals(DiskUtils.US_ASCII))) {
throw new IllegalArgumentException("Unsupported encoding");
}
this.in = in;
this.charset = charset;
buf = new byte[capacity];
}
/**
* Closes the reader by closing the underlying {@code InputStream} and
* marking this reader as closed.
*
* @throws IOException for errors when closing the underlying {@code InputStream}.
*/
public void close() throws IOException {
synchronized (in) {
if (buf != null) {
buf = null;
in.close();
}
}
}
/**
* Reads the next line. A line ends with {@code "\n"} or {@code "\r\n"},
* this end of line marker is not included in the result.
*
* @return the next line from the input.
* @throws IOException for underlying {@code InputStream} errors.
* @throws EOFException for the end of source stream.
*/
public String readLine() throws IOException {
synchronized (in) {
if (buf == null) {
throw new IOException("LineReader is closed");
}
// Read more data if we are at the end of the buffered data.
// Though it's an error to read after an exception, we will let {@code fillBuf()}
// throw again if that happens; thus we need to handle end == -1 as well as end == pos.
if (pos >= end) {
fillBuf();
}
// Try to find LF in the buffered data and return the line if successful.
for (int i = pos; i != end; ++i) {
if (buf[i] == LF) {
int lineEnd = (i != pos && buf[i - 1] == CR) ? i - 1 : i;
String res = new String(buf, pos, lineEnd - pos, charset.name());
pos = i + 1;
return res;
}
}
// Let's anticipate up to 80 characters on top of those already read.
ByteArrayOutputStream out = new ByteArrayOutputStream(end - pos + 80) {
@Override
public String toString() {
int length = (count > 0 && buf[count - 1] == CR) ? count - 1 : count;
try {
return new String(buf, 0, length, charset.name());
} catch (UnsupportedEncodingException e) {
throw new AssertionError(e); // Since we control the charset this will never happen.
}
}
};
while (true) {
out.write(buf, pos, end - pos);
// Mark unterminated line in case fillBuf throws EOFException or IOException.
end = -1;
fillBuf();
// Try to find LF in the buffered data and return the line if successful.
for (int i = pos; i != end; ++i) {
if (buf[i] == LF) {
if (i != pos) {
out.write(buf, pos, i - pos);
}
pos = i + 1;
return out.toString();
}
}
}
}
}
public boolean hasUnterminatedLine() {
return end == -1;
}
/**
* Reads new input data into the buffer. Call only with pos == end or end == -1,
* depending on the desired outcome if the function throws.
*/
private void fillBuf() throws IOException {
int result = in.read(buf, 0, buf.length);
if (result == -1) {
throw new EOFException();
}
pos = 0;
end = result;
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoSqlLite/src/main/java/com/yc/videosqllite/disk/Synthetic.java | Java | package com.yc.videosqllite.disk;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* Indicates that target's visibility can be relaxed to avoid synthetic methods.
*/
@Retention(RetentionPolicy.SOURCE)
@Target({ElementType.FIELD, ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.TYPE})
public @interface Synthetic {
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoSqlLite/src/main/java/com/yc/videosqllite/manager/CacheConfig.java | Java | package com.yc.videosqllite.manager;
import android.content.Context;
/**
* <pre>
* @author yangchong
* email : yangchong211@163.com
* time : 2020/8/6
* desc : 配置类
* revise:
* </pre>
*/
public class CacheConfig {
/**
* 是否生效
*/
private boolean mIsEffective = true;
/**
* 内存缓存最大值
*/
private int mCacheMax;
/**
* 对视频链接加盐字符串
* 处理md5加密的盐
*/
private String mSalt = "yc_video";
/**
* 0，表示内存缓存
* 1，表示磁盘缓存
* 2，表示内存缓存+磁盘缓存
*/
private int type = 0;
/**
* 上下文
*/
private Context context;
/**
* 是否开启日志
*/
private boolean isLog = false;
public boolean isEffective() {
return mIsEffective;
}
public void setIsEffective(boolean mIsEffective) {
this.mIsEffective = mIsEffective;
}
public int getCacheMax() {
if (mCacheMax<=0){
mCacheMax = 1000;
}
return mCacheMax;
}
public void setCacheMax(int mCacheMax) {
this.mCacheMax = mCacheMax;
}
public String getSalt() {
return mSalt;
}
public void setSalt(String salt) {
//设置盐处理
if (salt!=null && salt.length()>0){
this.mSalt = salt;
}
}
public int getType() {
return type;
}
public void setType(int type) {
this.type = type;
}
public Context getContext() {
return context;
}
public void setContext(Context context) {
this.context = context;
}
public boolean isLog() {
return isLog;
}
public void setLog(boolean log) {
isLog = log;
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoSqlLite/src/main/java/com/yc/videosqllite/manager/LocationManager.java | Java | package com.yc.videosqllite.manager;
import android.content.Context;
import android.os.Debug;
import com.yc.videosqllite.cache.VideoMapCache;
import com.yc.videosqllite.disk.DiskFileUtils;
import com.yc.videosqllite.disk.SqlLiteCache;
import com.yc.videosqllite.model.VideoLocation;
import com.yc.videosqllite.utils.CacheLogUtils;
import java.io.IOException;
/**
* <pre>
* @author yangchong
* email : yangchong211@163.com
* time : 2020/8/6
* desc : 音视频播放记录本地缓存
* revise: 最开始使用greenDao，二级缓存耗时100毫秒左右
* 磁盘+内存+key缓存+读写优化，耗时大概2到5毫秒左右
* </pre>
*/
public class LocationManager {
/**
* 终极目标
* 1.开发者可以自由切换缓存模式
* 2.可以设置内存缓存最大值，设置磁盘缓存的路径
* 3.能够有增删改查基础方法
* 4.多线程下安全和脏数据避免
* 5.代码体积小
* 6.一键打印存取表结构日志
* 7.如何一键将本地记录数据上传
* 8.拓展性和封闭性
* 9.性能，插入和获取数据，超1000条数据测试
*/
/**
* 内存缓存
*/
private VideoMapCache videoMapCache;
/**
* 磁盘缓存
*/
private SqlLiteCache sqlLiteCache;
/**
* 配置类
*/
private CacheConfig cacheConfig;
private static class ManagerHolder {
private static final LocationManager INSTANCE = new LocationManager();
}
public static LocationManager getInstance() {
return ManagerHolder.INSTANCE;
}
public void init(CacheConfig cacheConfig){
this.cacheConfig = cacheConfig;
CacheLogUtils.setIsLog(cacheConfig.isLog());
videoMapCache = new VideoMapCache();
sqlLiteCache = new SqlLiteCache();
CacheLogUtils.d("LocationManager-----init初始化-");
}
public CacheConfig getCacheConfig() {
if (cacheConfig==null){
throw new RuntimeException("请先调用init方法进行初始化");
}
return cacheConfig;
}
/**
* 存数据
* url为什么要md5？思考一下……
*
* @param url 链接
* @param location 视频数据
*/
public synchronized void put(String url , VideoLocation location){
if (!cacheConfig.isEffective()){
return;
}
if (url==null || url.length()==0 || location==null){
return ;
}
/*
* type
* 0，表示内存缓存
* 1，表示磁盘缓存
* 2，表示内存缓存+磁盘缓存
*/
long currentTimeMillis1 = System.currentTimeMillis();
if (cacheConfig.getType() ==1){
//存储到磁盘中
sqlLiteCache.put(url,location);
} else if (cacheConfig.getType() ==2){
//存储到内存中
videoMapCache.put(url,location);
//存储到磁盘中
sqlLiteCache.put(url,location);
} else if (cacheConfig.getType()==0){
//存储到内存中
videoMapCache.put(url,location);
} else {
//存储到内存中
videoMapCache.put(url,location);
}
long currentTimeMillis2 = System.currentTimeMillis();
CacheLogUtils.d("LocationManager-----put--存数据耗时-"+(currentTimeMillis2-currentTimeMillis1));
}
/**
* 取数据
* @param url 链接
* @return
*/
public synchronized long get(String url){
if (!cacheConfig.isEffective()){
return 0;
}
if (url==null || url.length()==0){
return 0;
}
/*
* type
* 0，表示内存缓存
* 1，表示磁盘缓存
* 2，表示内存缓存+磁盘缓存
*/
long currentTimeMillis1 = System.currentTimeMillis();
long position;
if (cacheConfig.getType() ==1){
//从磁盘中查找
position = sqlLiteCache.get(url);
} else if (cacheConfig.getType() ==2){
//先从内存中找
position = videoMapCache.get(url);
if (position<0){
//内存找不到，则从磁盘中查找
position = sqlLiteCache.get(url);
}
} else if (cacheConfig.getType()==0){
//先从内存中找
position = videoMapCache.get(url);
} else {
//先从内存中找
position = videoMapCache.get(url);
}
long currentTimeMillis2 = System.currentTimeMillis();
CacheLogUtils.d("LocationManager-----get--取数据耗时-"+(currentTimeMillis2-currentTimeMillis1)
+ "---进度-"+position);
return position;
}
/**
* 移除数据
* @param url 链接
* @return
*/
public synchronized boolean remove(String url){
if (!cacheConfig.isEffective()){
return false;
}
if (url==null || url.length()==0){
return false;
}
/*
* type
* 0，表示内存缓存
* 1，表示磁盘缓存
* 2，表示内存缓存+磁盘缓存
*/
if (cacheConfig.getType() ==1){
return sqlLiteCache.remove(url);
} else if (cacheConfig.getType() ==2){
boolean remove = videoMapCache.remove(url);
boolean removeSql = sqlLiteCache.remove(url);
return remove || removeSql;
} else if (cacheConfig.getType()==0){
return videoMapCache.remove(url);
} else {
return videoMapCache.remove(url);
}
}
/**
* 是否包含
* @param url 链接
* @return
*/
public synchronized boolean containsKey(String url){
if (!cacheConfig.isEffective()){
return false;
}
if (url==null || url.length()==0){
return false;
}
/*
* type
* 0，表示内存缓存
* 1，表示磁盘缓存
* 2，表示内存缓存+磁盘缓存
*/
boolean containsKey;
if (cacheConfig.getType() ==1){
containsKey = sqlLiteCache.containsKey(url);
} else if (cacheConfig.getType() ==2){
containsKey = videoMapCache.containsKey(url);
if (!containsKey){
containsKey = sqlLiteCache.containsKey(url);
return containsKey;
}
} else if (cacheConfig.getType()==0){
containsKey = videoMapCache.containsKey(url);
} else {
containsKey = videoMapCache.containsKey(url);
}
return containsKey;
}
/**
* 清楚所有数据
* @return 是否清楚完毕
*/
public synchronized void clearAll(){
if (!cacheConfig.isEffective()){
return;
}
/*
* type
* 0，表示内存缓存
* 1，表示磁盘缓存
* 2，表示内存缓存+磁盘缓存
*/
if (cacheConfig.getType() ==1){
sqlLiteCache.clearAll();
} else if (cacheConfig.getType() ==2){
videoMapCache.clearAll();
sqlLiteCache.clearAll();
} else if (cacheConfig.getType()==0){
videoMapCache.clearAll();
} else {
videoMapCache.clearAll();
}
}
/**
* 获取当前应用使用的内存
* @return
*/
public long getUseMemory(){
long totalMemory = Runtime.getRuntime().totalMemory();
long freeMemory = Runtime.getRuntime().freeMemory();
CacheLogUtils.d("LocationManager-----内存-"+totalMemory+"-----"+freeMemory);
//long maxMemory = Runtime.getRuntime().maxMemory();
long useMemory = totalMemory - freeMemory;
CacheLogUtils.d("LocationManager-----获取当前应用使用的内存-"+useMemory);
return useMemory;
}
/**
* 设定内存的阈值
* @param proportion 比例
* @return
*/
public long setMemoryThreshold(int proportion){
if (proportion<0 || proportion>10){
proportion = 2;
}
long totalMemory = Runtime.getRuntime().totalMemory();
long threshold = totalMemory / proportion;
CacheLogUtils.d("LocationManager-----设定内存的阈值-"+threshold);
return threshold;
}
/**
* 获取Java内存快照文件
* @param context
*/
public void dumpHprofData(Context context){
String dump = DiskFileUtils.getPath(context, "dump");
CacheLogUtils.d("LocationManager-----获取Java内存快照文件-"+dump);
try {
Debug.dumpHprofData(dump);
} catch (IOException e) {
e.printStackTrace();
}
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoSqlLite/src/main/java/com/yc/videosqllite/model/SafeKeyGenerator.java | Java | package com.yc.videosqllite.model;
import com.yc.videosqllite.cache.VideoLruCache;
import com.yc.videosqllite.manager.CacheConfig;
import com.yc.videosqllite.manager.LocationManager;
import com.yc.videosqllite.utils.CacheLogUtils;
import com.yc.videosqllite.utils.VideoMd5Utils;
/**
* <pre>
* @author yangchong
* email : yangchong211@163.com
* time : 2020/8/6
* desc : url校验以及缓存
* revise: 内存+磁盘缓存需要md5两次，使用该类后只需要一次即可。
* </pre>
*/
public class SafeKeyGenerator {
private final VideoLruCache<Integer, String> loadIdToSafeHash = new VideoLruCache<>(1000);
public SafeKeyGenerator() {
}
public String getSafeKey(String url) {
if (url==null || url.length()==0){
return null;
}
String safeKey;
//获取链接的hash算法值
int hashCode = url.hashCode();
synchronized (loadIdToSafeHash) {
safeKey = loadIdToSafeHash.get(hashCode);
CacheLogUtils.d("SafeKeyGenerator-----获取缓存key-"+safeKey);
}
if (safeKey == null || safeKey.length()==0) {
CacheConfig cacheConfig = LocationManager.getInstance().getCacheConfig();
safeKey = VideoMd5Utils.encryptMD5ToString(url, cacheConfig.getSalt());
CacheLogUtils.d("SafeKeyGenerator-----md5转化key-"+safeKey);
}
synchronized (loadIdToSafeHash) {
loadIdToSafeHash.put(hashCode, safeKey);
CacheLogUtils.d("SafeKeyGenerator-----存储key-"+safeKey);
}
return safeKey;
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoSqlLite/src/main/java/com/yc/videosqllite/model/VideoLocation.java | Java | package com.yc.videosqllite.model;
import android.os.Build;
import org.json.JSONException;
import org.json.JSONObject;
import java.io.Serializable;
import java.util.Arrays;
import java.util.Objects;
/**
* <pre>
* @author yangchong
* email : yangchong211@163.com
* time : 2020/8/6
* desc : 音视频bean
* revise: 必须
* </pre>
*/
public class VideoLocation implements Serializable , Cloneable{
/**
* 视频链接
*/
private String url;
/**
* 视频链接md5
*/
private String urlMd5;
/**
* 视频播放位置
*/
private long position;
/**
* 视频总时间
*/
private long totalTime;
public VideoLocation(){
}
public VideoLocation(String url, long position, long totalTime) {
this.url = url;
this.position = position;
this.totalTime = totalTime;
}
/*public VideoLocation(String url, String urlMd5, long position, long totalTime) {
this.url = url;
this.urlMd5 = urlMd5;
this.position = position;
this.totalTime = totalTime;
}*/
public String getUrl() {
return url;
}
public void setUrl(String url) {
this.url = url;
}
public String getUrlMd5() {
return urlMd5;
}
public void setUrlMd5(String urlMd5) {
this.urlMd5 = urlMd5;
}
public long getPosition() {
return position;
}
public void setPosition(long position) {
this.position = position;
}
public long getTotalTime() {
return totalTime;
}
public void setTotalTime(long totalTime) {
this.totalTime = totalTime;
}
public String toJson() {
JSONObject jsonObject= new JSONObject();
try {
jsonObject.put("url", getUrl());
jsonObject.put("urlMd5", getUrlMd5());
jsonObject.put("position", getPosition());
jsonObject.put("totalTime", getTotalTime());
return jsonObject.toString();
} catch (JSONException e) {
e.printStackTrace();
}
return null;
}
public static com.yc.videosqllite.model.VideoLocation toObject(String jsonStr) {
com.yc.videosqllite.model.VideoLocation m = new com.yc.videosqllite.model.VideoLocation();
try {
JSONObject jsonObject = new JSONObject(jsonStr);
m.setUrl(jsonObject.has("url") ? jsonObject.getString("url"):null);
m.setUrlMd5(jsonObject.has("urlMd5") ? jsonObject.getString("urlMd5"):null);
m.setPosition(jsonObject.has("position") ? jsonObject.getLong("position"):0);
m.setTotalTime(jsonObject.has("totalTime") ? jsonObject.getLong("totalTime"):0);
return m;
} catch (JSONException e) {
e.printStackTrace();
}
return m;
}
@Override
public String toString() {
return "VideoLocation{" +
"url='" + url + '\'' +
", urlMd5='" + urlMd5 + '\'' +
", position=" + position +
", totalTime=" + totalTime +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o){
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
com.yc.videosqllite.model.VideoLocation location = (com.yc.videosqllite.model.VideoLocation) o;
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
return position == location.position &&
totalTime == location.totalTime &&
Objects.equals(url, location.url) &&
Objects.equals(urlMd5, location.urlMd5);
} else {
return position == location.position &&
totalTime == location.totalTime &&
equals(url,location.url) &&
equals(urlMd5,location.urlMd5);
}
}
@Override
public int hashCode() {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
return Objects.hash(url, urlMd5, position, totalTime);
}
return hash(url,urlMd5,position,totalTime);
}
/**
* 重写clone()方法
* 浅拷贝
* @return
*/
public Object clone() {
//浅拷贝
try {
// 直接调用父类的clone()方法
return super.clone();
} catch (CloneNotSupportedException e) {
return null;
}
}
/**
* 重写clone()方法
* 深拷贝
* @return
*/
public Object deepClone() {
// 深拷贝，创建拷贝类的一个新对象，这样就和原始对象相互独立
VideoLocation location = new VideoLocation(url,position,totalTime);
return location;
}
/**
* 比较两个对象
* @param a a对象
* @param b b对象
* @return
*/
private boolean equals(Object a, Object b) {
boolean ab = (a == b);
boolean equal = (a != null && a.equals(b));
return ab || equal;
}
/**
* hash算法
* @param values 参数
* @return
*/
private int hash(Object... values) {
return hashCode(values);
}
public static int hashCode(Object a[]) {
if (a == null){
return 0;
}
int result = 1;
for (Object element : a){
result = 31 * result + (element == null ? 0 : element.hashCode());
}
return result;
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoSqlLite/src/main/java/com/yc/videosqllite/utils/CacheLogUtils.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.videosqllite.utils;
import android.util.Log;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2017/10/21
* desc : log工具
* revise:
* </pre>
*/
public final class CacheLogUtils {
private static final String TAG = "CacheLogUtils";
private static boolean isLog = false;
/**
* 设置是否开启日志
* @param isLog 是否开启日志
*/
public static void setIsLog(boolean isLog) {
com.yc.videosqllite.utils.CacheLogUtils.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 |
VideoSqlLite/src/main/java/com/yc/videosqllite/utils/VideoMd5Utils.java | Java | package com.yc.videosqllite.utils;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
/**
* <pre>
* @author yangchong
* email : yangchong211@163.com
* time : 2020/6/16
* desc : md加密+加盐工具类
* revise:
* </pre>
*/
public final class VideoMd5Utils {
private static final char hexDigits[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
/**
* MD5 加密
*
* @param data 明文字符串
* @return 16 进制密文
*/
public static String encryptMD5ToString(final String data) {
return encryptMD5ToString(data.getBytes());
}
/**
* MD5 加密
*
* @param data 明文字符串
* @param salt 盐
* @return 16 进制加盐密文
*/
public static String encryptMD5ToString(final String data, final String salt) {
return bytes2HexString(encryptMD5((data + salt).getBytes()));
}
/**
* MD5 加密
*
* @param data 明文字节数组
* @return 16 进制密文
*/
public static String encryptMD5ToString(final byte[] data) {
return bytes2HexString(encryptMD5(data));
}
/**
* MD5 加密
*
* @param data 明文字节数组
* @param salt 盐字节数组
* @return 16 进制加盐密文
*/
public static String encryptMD5ToString(final byte[] data, final byte[] salt) {
if (data == null || salt == null) return null;
byte[] dataSalt = new byte[data.length + salt.length];
System.arraycopy(data, 0, dataSalt, 0, data.length);
System.arraycopy(salt, 0, dataSalt, data.length, salt.length);
return bytes2HexString(encryptMD5(dataSalt));
}
/**
* MD5 加密
*
* @param data 明文字节数组
* @return 密文字节数组
*/
public static byte[] encryptMD5(final byte[] data) {
return hashTemplate(data, "MD5");
}
/**
* hash 加密模板
*
* @param data 数据
* @param algorithm 加密算法
* @return 密文字节数组
*/
private static byte[] hashTemplate(final byte[] data, final String algorithm) {
if (data == null || data.length <= 0) return null;
try {
MessageDigest md = MessageDigest.getInstance(algorithm);
md.update(data);
return md.digest();
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
return null;
}
}
private static String bytes2HexString(final byte[] bytes) {
if (bytes == null) return null;
int len = bytes.length;
if (len <= 0) return null;
char[] ret = new char[len << 1];
for (int i = 0, j = 0; i < len; i++) {
ret[j++] = hexDigits[bytes[i] >>> 4 & 0x0f];
ret[j++] = hexDigits[bytes[i] & 0x0f];
}
return new String(ret);
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoTool/build.gradle | Gradle | apply plugin: 'com.android.library'
android {
compileSdkVersion 29
buildToolsVersion "29.0.3"
defaultConfig {
minSdkVersion 16
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.1'
androidTestImplementation 'androidx.test.espresso:espresso-core:3.2.0'
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoTool/src/androidTest/java/com/yc/videotool/ExampleInstrumentedTest.java | Java | package com.yc.videotool;
import android.content.Context;
import androidx.test.platform.app.InstrumentationRegistry;
import androidx.test.ext.junit.runners.AndroidJUnit4;
import org.junit.Test;
import org.junit.runner.RunWith;
import static org.junit.Assert.*;
/**
* Instrumented test, which will execute on an Android device.
*
* @see <a href="http://d.android.com/tools/testing">Testing documentation</a>
*/
@RunWith(AndroidJUnit4.class)
public class ExampleInstrumentedTest {
@Test
public void useAppContext() {
// Context of the app under test.
Context appContext = InstrumentationRegistry.getInstrumentation().getTargetContext();
assertEquals("com.yc.videotool.test", appContext.getPackageName());
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
VideoTool/src/main/java/com/yc/videotool/Tool.java | Java | package com.yc.videotool;
public final class Tool {
/**
* 工具基础库介绍
*/
}
| 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.