Skip to content

R
RvApp
Commit 7f3bb147 authored by linfeng's avatar linfeng
Browse files
Options

bug修复

parent 2b41a1e7
Hide whitespace changes
Inline Side-by-side
Showing with 27 additions and 3377 deletions
RvClient/build.gradle
View file @ 7f3bb147
......@@ -108,8 +108,8 @@ dependencies {
annotationProcessor 'com.jakewharton:butterknife-compiler:9.0.0-rc1'
implementation 'com.android.support.constraint:constraint-layout:1.1.3'
debugCompile 'com.squareup.leakcanary:leakcanary-android:1.6.1'
releaseCompile 'com.squareup.leakcanary:leakcanary-android-no-op:1.6.1'
debugApi 'com.squareup.leakcanary:leakcanary-android:1.6.1'
releaseApi 'com.squareup.leakcanary:leakcanary-android-no-op:1.6.1'
// api project(path: ':RvTravel')
......
RvClient/src/main/java/com/xxfc/rv/MainActivity.java
View file @ 7f3bb147
......@@ -24,6 +24,7 @@ import android.widget.Toast;
import com.alibaba.android.arouter.launcher.ARouter;
import com.frame.base.url.Constance;
import com.frame.rv.config.RvFrameConfig;
import com.ruiwenliu.wrapper.SPConstance;
import com.ruiwenliu.wrapper.adapter.TabAdapter;
import com.ruiwenliu.wrapper.base.BaseActivity;
import com.ruiwenliu.wrapper.base.BaseBean;
......@@ -212,7 +213,9 @@ public class MainActivity extends BaseActivity<CommonPresenter> {
case 4:
UpdateTokenBean updateTokenBean = (UpdateTokenBean) result;
if (updateTokenBean != null && !TextUtils.isEmpty(updateTokenBean.getData())) {
OkGoUtil.setToken(updateTokenBean.getData(), DateUtils.getCurDateTime());
OkGoUtil.setToken(updateTokenBean.getData(), DateUtils.getCurDate());
Cookie.save(getApplicationContext(), SPConstance.USER_JSON_TOKEN, updateTokenBean.getData());
Cookie.save(getApplicationContext(), SPConstance.USER_JSON_TOKE_TIME, DateUtils.getCurDate());
}
break;
default:
......@@ -226,8 +229,7 @@ public class MainActivity extends BaseActivity<CommonPresenter> {
private void checkToken() {
String time = OkGoUtil.getTime();
if (!TextUtils.isEmpty(time)) {
// if (DateUtils.compareDateDay(DateUtils.getCurDate(), time) > 6) {
if (DateUtils.compareDateSecond(DateUtils.getCurDateTime(), time) > 120) {
if (DateUtils.compareDateDay(DateUtils.getCurDate(), time) > 6) {
getToken();
}
} else {
......
RvClient/src/main/java/com/xxfc/rv/WelcomeActivity.java
View file @ 7f3bb147
......@@ -77,7 +77,7 @@ public class WelcomeActivity extends BaseActivity<CommonPresenter> {
String token = Cookie.getStringValue(getApplicationContext(), SPConstance.USER_JSON_TOKEN, "");
String tokenTime = Cookie.getStringValue(getApplicationContext(), SPConstance.USER_JSON_TOKE_TIME, "");
if (!TextUtils.isEmpty(token)) {
OkGoUtil.setToken(token, DateUtils.getCurDateTime());
OkGoUtil.setToken(token, tokenTime);
}
} catch (Exception e) {
e.printStackTrace();
......
component_utils/src/main/java/com/rv/component/utils/DateUtils.java
View file @ 7f3bb147
......@@ -519,6 +519,24 @@ public class DateUtils {
}
/**
* 将yyyy-MM-dd HH:mm:ss格式成yyyy-MM-dd
*
* @param dateStr yyyy-MM-dd HH:mm:ss
* @return yyyy-MM-dd
*/
public static String formatDate166(String dateStr) {
String day = "";
try {
Date date = sdf.parse(dateStr);
day = sdf4.format(date);
} catch (Exception e) {
e.printStackTrace();
}
return day;
}
/**
* 将yyyy-MM-dd HH:mm格式成HH:mm
*
......
module_home/src/main/java/com/rv/home/rv/module/basic/BaseLoginActivity.java
View file @ 7f3bb147
......@@ -141,7 +141,7 @@ public abstract class BaseLoginActivity<P extends MvpPresenter> extends BaseStat
headMap.put("Authorization", registeredBean.getToken());
mPresenter.getDataHead(RvFrameConfig.ADMIN_POST, 10, ApiConfig.HTTP_URL_APP_USER_INFO, BeanUserInfo.class, headMap, false);
}
OkGoUtil.setToken(registeredBean.getToken(), DateUtils.getCurDateTime());
OkGoUtil.setToken(registeredBean.getToken(), DateUtils.getCurDate());
// switch (RvFrameConfig.RvFrameInfo.TYPE_LOGIN) {
// case 1:
// if ("0".equals(bean.getData().getCertificationStatus())) { //实名认证状态:0-未认证，1-已认证
......
plugin_video/build.gradle deleted 100644 → 0
View file @ 2b41a1e7
apply plugin: 'com.android.library'
android {
compileSdkVersion 28
defaultConfig {
minSdkVersion 16
targetSdkVersion 28
}
}
dependencies {
implementation fileTree(include: ['*.jar'], dir: 'libs')
implementation 'com.android.support:appcompat-v7:28.0.0'
}
plugin_video/proguard-rules.pro deleted 100644 → 0
View file @ 2b41a1e7
# Add project specific ProGuard rules here.
# By default, the flags in this file are appended to flags specified
# in D:\sdk/tools/proguard/proguard-android.txt
# You can edit the include path and order by changing the proguardFiles
# directive in build.gradle.
#
# For more details, see
# http://developer.android.com/guide/developing/tools/proguard.html
# Add any project specific keep options here:
# If your project uses WebView with JS, uncomment the following
# and specify the fully qualified class name to the JavaScript interface
# class:
#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
# public *;
#}
# Uncomment this to preserve the line number information for
# debugging stack traces.
#-keepattributes SourceFile,LineNumberTable
# If you keep the line number information, uncomment this to
# hide the original source file name.
#-renamesourcefileattribute SourceFile
plugin_video/src/main/AndroidManifest.xml deleted 100644 → 0
View file @ 2b41a1e7
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.dueeeke.videoplayer">
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
</manifest>
plugin_video/src/main/java/com/dueeeke/videoplayer/controller/BaseVideoController.java deleted 100644 → 0
View file @ 2b41a1e7
package com.dueeeke.videoplayer.controller;
import android.app.Activity;
import android.content.Context;
import android.content.pm.ActivityInfo;
import android.support.annotation.AttrRes;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.util.AttributeSet;
import android.view.LayoutInflater;
import android.view.View;
import android.widget.FrameLayout;
import com.dueeeke.videoplayer.R;
import com.dueeeke.videoplayer.player.VideoView;
import com.dueeeke.videoplayer.player.VideoViewManager;
import com.dueeeke.videoplayer.util.PlayerUtils;
import com.dueeeke.videoplayer.widget.StatusView;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Formatter;
import java.util.Locale;
/**
* 控制器基类
* Created by Devlin_n on 2017/4/12.
*/
public abstract class BaseVideoController extends FrameLayout {
protected View mControllerView;//控制器视图
protected MediaPlayerControl mMediaPlayer;//播放器
protected boolean mShowing;//控制器是否处于显示状态
protected boolean mIsLocked;
protected int mDefaultTimeout = 4000;
private StringBuilder mFormatBuilder;
private Formatter mFormatter;
protected int mCurrentPlayState;
protected StatusView mStatusView;
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();
}
protected void initView() {
mControllerView = LayoutInflater.from(getContext()).inflate(getLayoutId(), this);
mFormatBuilder = new StringBuilder();
mFormatter = new Formatter(mFormatBuilder, Locale.getDefault());
mStatusView = new StatusView(getContext());
setClickable(true);
setFocusable(true);
}
/**
* 设置控制器布局文件，子类必须实现
*/
protected abstract int getLayoutId();
/**
* 显示
*/
public void show() {
}
/**
* 隐藏
*/
public void hide() {
}
public void setPlayState(int playState) {
mCurrentPlayState = playState;
hideStatusView();
if (playState == VideoView.STATE_ERROR) {
mStatusView.setMessage(getResources().getString(R.string.dkplayer_error_message));
mStatusView.setButtonTextAndAction(getResources().getString(R.string.dkplayer_retry), new OnClickListener() {
@Override
public void onClick(View v) {
hideStatusView();
mMediaPlayer.replay(false);
}
});
this.addView(mStatusView, 0);
}
}
public void showStatusView() {
this.removeView(mStatusView);
mStatusView.setMessage(getResources().getString(R.string.dkplayer_wifi_tip));
mStatusView.setButtonTextAndAction(getResources().getString(R.string.dkplayer_continue_play), new OnClickListener() {
@Override
public void onClick(View v) {
hideStatusView();
VideoViewManager.instance().setPlayOnMobileNetwork(true);
mMediaPlayer.start();
}
});
this.addView(mStatusView);
}
public void hideStatusView() {
this.removeView(mStatusView);
}
public void setPlayerState(int playerState) {
}
protected void doPauseResume() {
if (mCurrentPlayState == VideoView.STATE_BUFFERING) return;
if (mMediaPlayer.isPlaying()) {
mMediaPlayer.pause();
} else {
mMediaPlayer.start();
}
}
/**
* 横竖屏切换
*/
protected void doStartStopFullScreen() {
Activity activity = PlayerUtils.scanForActivity(getContext());
if (activity == null) return;
if (mMediaPlayer.isFullScreen()) {
mMediaPlayer.stopFullScreen();
activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
} else {
activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
mMediaPlayer.startFullScreen();
}
}
protected Runnable mShowProgress = new Runnable() {
@Override
public void run() {
int pos = setProgress();
if (mMediaPlayer.isPlaying()) {
postDelayed(mShowProgress, 1000 - (pos % 1000));
}
}
};
protected final Runnable mFadeOut = new Runnable() {
@Override
public void run() {
hide();
}
};
protected int setProgress() {
return 0;
}
/**
* 获取当前系统时间
*/
protected String getCurrentSystemTime() {
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("HH:mm", Locale.getDefault());
Date date = new Date();
return simpleDateFormat.format(date);
}
protected String stringForTime(int timeMs) {
int totalSeconds = timeMs / 1000;
int seconds = totalSeconds % 60;
int minutes = (totalSeconds / 60) % 60;
int hours = totalSeconds / 3600;
mFormatBuilder.setLength(0);
if (hours > 0) {
return mFormatter.format("%d:%02d:%02d", hours, minutes, seconds).toString();
} else {
return mFormatter.format("%02d:%02d", minutes, seconds).toString();
}
}
@Override
protected void onAttachedToWindow() {
super.onAttachedToWindow();
post(mShowProgress);
}
@Override
protected void onDetachedFromWindow() {
super.onDetachedFromWindow();
removeCallbacks(mShowProgress);
}
@Override
protected void onWindowVisibilityChanged(int visibility) {
super.onWindowVisibilityChanged(visibility);
if (visibility == VISIBLE) {
post(mShowProgress);
}
}
/**
* 改变返回键逻辑，用于activity
*/
public boolean onBackPressed() {
return false;
}
public void setMediaPlayer(MediaPlayerControl mediaPlayer) {
this.mMediaPlayer = mediaPlayer;
}
}
plugin_video/src/main/java/com/dueeeke/videoplayer/controller/GestureVideoController.java deleted 100644 → 0
View file @ 2b41a1e7
package com.dueeeke.videoplayer.controller;
import android.content.Context;
import android.media.AudioManager;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
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 com.dueeeke.videoplayer.R;
import com.dueeeke.videoplayer.util.PlayerUtils;
import com.dueeeke.videoplayer.widget.CenterView;
/**
* 包含手势操作的VideoController
* Created by xinyu on 2018/1/6.
*/
public abstract class GestureVideoController extends BaseVideoController{
protected GestureDetector mGestureDetector;
protected boolean mIsGestureEnabled;
protected CenterView mCenterView;
protected AudioManager mAudioManager;
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() {
super.initView();
mCenterView = new CenterView(getContext());
mCenterView.setVisibility(GONE);
addView(mCenterView);
mAudioManager = (AudioManager) getContext().getSystemService(Context.AUDIO_SERVICE);
mGestureDetector = new GestureDetector(getContext(), new MyGestureListener());
this.setOnTouchListener(new OnTouchListener() {
@Override
public boolean onTouch(View v, MotionEvent event) {
return mGestureDetector.onTouchEvent(event);
}
});
}
protected int mStreamVolume;
protected float mBrightness;
protected int mPosition;
protected boolean mNeedSeek;
protected class MyGestureListener extends GestureDetector.SimpleOnGestureListener {
private boolean mFirstTouch;
private boolean mChangePosition;
private boolean mChangeBrightness;
private boolean mChangeVolume;
@Override
public boolean onDown(MotionEvent e) {
if (!mIsGestureEnabled || PlayerUtils.isEdge(getContext(), e)) return super.onDown(e);
mStreamVolume = mAudioManager.getStreamVolume(AudioManager.STREAM_MUSIC);
mBrightness = PlayerUtils.scanForActivity(getContext()).getWindow().getAttributes().screenBrightness;
mFirstTouch = true;
mChangePosition = false;
mChangeBrightness = false;
mChangeVolume = false;
return true;
}
@Override
public boolean onSingleTapConfirmed(MotionEvent e) {
if (mShowing) {
hide();
} else {
show();
}
return true;
}
@Override
public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) {
if (!mIsGestureEnabled || PlayerUtils.isEdge(getContext(), e1)) return super.onScroll(e1, e2, distanceX, distanceY);
float deltaX = e1.getX() - e2.getX();
float deltaY = e1.getY() - e2.getY();
if (mFirstTouch) {
mChangePosition = Math.abs(distanceX) >= Math.abs(distanceY);
if (!mChangePosition) {
if (e2.getX() > PlayerUtils.getScreenWidth(getContext(), true) / 2) {
mChangeVolume = true;
} else {
mChangeBrightness = true;
}
}
mFirstTouch = false;
}
if (mChangePosition) {
slideToChangePosition(deltaX);
} else if (mChangeBrightness) {
slideToChangeBrightness(deltaY);
} else if (mChangeVolume) {
slideToChangeVolume(deltaY);
}
return true;
}
@Override
public boolean onDoubleTap(MotionEvent e) {
if (!mIsLocked) doPauseResume();
return true;
}
}
@Override
public boolean onTouchEvent(MotionEvent event) {
boolean detectedUp = event.getAction() == MotionEvent.ACTION_UP;
if (!mGestureDetector.onTouchEvent(event) && detectedUp) {
if (mCenterView.getVisibility() == VISIBLE) {
mCenterView.setVisibility(GONE);
}
if (mNeedSeek) {
mMediaPlayer.seekTo(mPosition);
mNeedSeek = false;
}
}
return super.onTouchEvent(event);
}
protected void slideToChangePosition(float deltaX) {
mCenterView.setVisibility(VISIBLE);
hide();
mCenterView.setProVisibility(View.GONE);
deltaX = -deltaX;
int width = getMeasuredWidth();
int duration = (int) mMediaPlayer.getDuration();
int currentPosition = (int) mMediaPlayer.getCurrentPosition();
int position = (int) (deltaX / width * 120000 + currentPosition);
if (position > currentPosition) {
mCenterView.setIcon(R.drawable.dkplayer_ic_action_fast_forward);
} else {
mCenterView.setIcon(R.drawable.dkplayer_ic_action_fast_rewind);
}
if (position > duration) position = duration;
if (position < 0) position = 0;
mPosition = position;
mCenterView.setTextView(stringForTime(position) + "/" + stringForTime(duration));
mNeedSeek = true;
}
protected void slideToChangeBrightness(float deltaY) {
mCenterView.setVisibility(VISIBLE);
hide();
mCenterView.setProVisibility(View.VISIBLE);
Window window = PlayerUtils.scanForActivity(getContext()).getWindow();
WindowManager.LayoutParams attributes = window.getAttributes();
mCenterView.setIcon(R.drawable.dkplayer_ic_action_brightness);
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);
mCenterView.setTextView(percent + "%");
mCenterView.setProPercent(percent);
attributes.screenBrightness = brightness;
window.setAttributes(attributes);
}
protected void slideToChangeVolume(float deltaY) {
mCenterView.setVisibility(VISIBLE);
hide();
mCenterView.setProVisibility(View.VISIBLE);
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) {
mCenterView.setIcon(R.drawable.dkplayer_ic_action_volume_off);
index = 0;
} else {
mCenterView.setIcon(R.drawable.dkplayer_ic_action_volume_up);
}
int percent = (int) (index / streamMaxVolume * 100);
mCenterView.setTextView(percent + "%");
mCenterView.setProPercent(percent);
mAudioManager.setStreamVolume(AudioManager.STREAM_MUSIC, (int) index, 0);
}
}
plugin_video/src/main/java/com/dueeeke/videoplayer/controller/MediaPlayerControl.java deleted 100644 → 0
View file @ 2b41a1e7
package com.dueeeke.videoplayer.controller;
import android.graphics.Bitmap;
public interface MediaPlayerControl {
void start();
void pause();
long getDuration();
long getCurrentPosition();
void seekTo(long pos);
boolean isPlaying();
int getBufferedPercentage();
void startFullScreen();
void stopFullScreen();
boolean isFullScreen();
void setMute(boolean isMute);
boolean isMute();
void setLock(boolean isLocked);
void setScreenScale(int screenScale);
void setSpeed(float speed);
long getTcpSpeed();
void replay(boolean resetPosition);
void setMirrorRotation(boolean enable);
Bitmap doScreenShot();
int[] getVideoSize();
void setRotation(float rotation);
void startTinyScreen();
void stopTinyScreen();
boolean isTinyScreen();
}
\ No newline at end of file
plugin_video/src/main/java/com/dueeeke/videoplayer/listener/OnVideoViewStateChangeListener.java deleted 100644 → 0
View file @ 2b41a1e7
package com.dueeeke.videoplayer.listener;
public interface OnVideoViewStateChangeListener {
void onPlayerStateChanged(int playerState);
void onPlayStateChanged(int playState);
}
plugin_video/src/main/java/com/dueeeke/videoplayer/listener/PlayerEventListener.java deleted 100644 → 0
View file @ 2b41a1e7
package com.dueeeke.videoplayer.listener;
/**
* Created by xinyu on 2017/12/21.
*/
public interface PlayerEventListener {
void onError();
void onCompletion();
void onInfo(int what, int extra);
void onPrepared();
void onVideoSizeChanged(int width, int height);
}
plugin_video/src/main/java/com/dueeeke/videoplayer/player/AbstractPlayer.java deleted 100644 → 0
View file @ 2b41a1e7
package com.dueeeke.videoplayer.player;
import android.content.res.AssetFileDescriptor;
import android.view.Surface;
import android.view.SurfaceHolder;
import com.dueeeke.videoplayer.listener.PlayerEventListener;
import java.util.List;
import java.util.Map;
/**
* Created by Devlin_n on 2017/12/21.
*/
public abstract class AbstractPlayer {
/**
* 开始渲染视频画面
*/
public static final int MEDIA_INFO_VIDEO_RENDERING_START = 3;
/**
* 缓冲开始
*/
public static final int MEDIA_INFO_BUFFERING_START = 701;
/**
* 缓冲结束
*/
public static final int MEDIA_INFO_BUFFERING_END = 702;
/**
* 视频旋转信息
*/
public static final int MEDIA_INFO_VIDEO_ROTATION_CHANGED = 10001;
/**
* 播放器事件回调
*/
protected PlayerEventListener mPlayerEventListener;
/**
* 初始化播放器实例
*/
public abstract void initPlayer();
/**
* 设置播放地址
* @param path 播放地址
* @param headers 播放地址请求头
*/
public abstract void setDataSource(String path, Map<String, String> headers);
/**
* 用于播放raw和asset里面的视频文件
*/
public abstract void setDataSource(AssetFileDescriptor fd);
public abstract void setDataSource(List<String> paths);
/**
* 播放
*/
public abstract void start();
/**
* 暂停
*/
public abstract void pause();
/**
* 停止
*/
public abstract void stop();
/**
* 准备开始播放（异步）
*/
public abstract void prepareAsync();
/**
* 重置播放器
*/
public abstract void reset();
/**
* 是否正在播放
*/
public abstract boolean isPlaying();
/**
* 调整进度
*/
public abstract void seekTo(long time);
/**
* 释放播放器
*/
public abstract void release();
/**
* 获取当前播放的位置
*/
public abstract long getCurrentPosition();
/**
* 获取视频总时长
*/
public abstract long getDuration();
/**
* 获取缓冲百分比
*/
public abstract int getBufferedPercentage();
/**
* 设置渲染视频的View,主要用于TextureView
*/
public abstract void setSurface(Surface surface);
/**
* 设置渲染视频的View,主要用于SurfaceView
*/
public abstract void setDisplay(SurfaceHolder holder);
/**
* 设置音量
*/
public abstract void setVolume(float v1, float v2);
/**
* 设置是否循环播放
*/
public abstract void setLooping(boolean isLooping);
/**
* 设置硬解码
*/
public abstract void setEnableMediaCodec(boolean isEnable);
/**
* 设置其他播放配置
*/
public abstract void setOptions();
/**
* 设置播放速度
*/
public abstract void setSpeed(float speed);
/**
* 获取当前缓冲的网速
*/
public abstract long getTcpSpeed();
/**
* 绑定VideoView
*/
public void setPlayerEventListener(PlayerEventListener playerEventListener) {
this.mPlayerEventListener = playerEventListener;
}
}
plugin_video/src/main/java/com/dueeeke/videoplayer/player/AndroidMediaPlayer.java deleted 100644 → 0
View file @ 2b41a1e7
package com.dueeeke.videoplayer.player;
import android.content.Context;
import android.content.res.AssetFileDescriptor;
import android.media.AudioManager;
import android.media.MediaPlayer;
import android.net.Uri;
import android.view.Surface;
import android.view.SurfaceHolder;
import java.util.List;
import java.util.Map;
public class AndroidMediaPlayer extends AbstractPlayer {
protected MediaPlayer mMediaPlayer;
private boolean isLooping;
protected Context mAppContext;
private int mBufferedPercent;
public AndroidMediaPlayer(Context context) {
mAppContext = context.getApplicationContext();
}
@Override
public void initPlayer() {
mMediaPlayer = new MediaPlayer();
mMediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);
mMediaPlayer.setOnErrorListener(onErrorListener);
mMediaPlayer.setOnCompletionListener(onCompletionListener);
mMediaPlayer.setOnInfoListener(onInfoListener);
mMediaPlayer.setOnBufferingUpdateListener(onBufferingUpdateListener);
mMediaPlayer.setOnPreparedListener(onPreparedListener);
mMediaPlayer.setOnVideoSizeChangedListener(onVideoSizeChangedListener);
}
@Override
public void setDataSource(String path, Map<String, String> headers) {
try {
mMediaPlayer.setDataSource(mAppContext, Uri.parse(path), headers);
} catch (Exception e) {
mPlayerEventListener.onError();
}
}
@Override
public void setDataSource(AssetFileDescriptor fd) {
try {
mMediaPlayer.setDataSource(fd.getFileDescriptor(), fd.getStartOffset(), fd.getLength());
} catch (Exception e) {
mPlayerEventListener.onError();
}
}
@Override
public void setDataSource(List<String> paths) {
}
@Override
public void start() {
try {
mMediaPlayer.start();
} catch (IllegalStateException e) {
mPlayerEventListener.onError();
}
}
@Override
public void pause() {
try {
mMediaPlayer.pause();
} catch (IllegalStateException e) {
mPlayerEventListener.onError();
}
}
@Override
public void stop() {
try {
mMediaPlayer.stop();
} catch (IllegalStateException e) {
mPlayerEventListener.onError();
}
}
@Override
public void prepareAsync() {
try {
mMediaPlayer.prepareAsync();
} catch (IllegalStateException e) {
mPlayerEventListener.onError();
}
}
@Override
public void reset() {
mMediaPlayer.release();
initPlayer();
mMediaPlayer.setVolume(1, 1);
mMediaPlayer.setLooping(isLooping);
}
@Override
public boolean isPlaying() {
return mMediaPlayer.isPlaying();
}
@Override
public void seekTo(long time) {
try {
mMediaPlayer.seekTo((int) time);
} catch (IllegalStateException e) {
mPlayerEventListener.onError();
}
}
@Override
public void release() {
new Thread() {
@Override
public void run() {
try {
mMediaPlayer.release();
} catch (Exception e) {
e.printStackTrace();
}
}
}.start();
}
@Override
public long getCurrentPosition() {
return mMediaPlayer.getCurrentPosition();
}
@Override
public long getDuration() {
return mMediaPlayer.getDuration();
}
@Override
public int getBufferedPercentage() {
return mBufferedPercent;
}
@Override
public void setSurface(Surface surface) {
mMediaPlayer.setSurface(surface);
}
@Override
public void setDisplay(SurfaceHolder holder) {
mMediaPlayer.setDisplay(holder);
}
@Override
public void setVolume(float v1, float v2) {
mMediaPlayer.setVolume(v1, v2);
}
@Override
public void setLooping(boolean isLooping) {
this.isLooping = isLooping;
mMediaPlayer.setLooping(isLooping);
}
@Override
public void setEnableMediaCodec(boolean isEnable) {
// no support
}
@Override
public void setOptions() {
// no support
}
@Override
public void setSpeed(float speed) {
// no support
}
@Override
public long getTcpSpeed() {
// no support
return 0;
}
private MediaPlayer.OnErrorListener onErrorListener = new MediaPlayer.OnErrorListener() {
@Override
public boolean onError(MediaPlayer mp, int what, int extra) {
mPlayerEventListener.onError();
return true;
}
};
private MediaPlayer.OnCompletionListener onCompletionListener = new MediaPlayer.OnCompletionListener() {
@Override
public void onCompletion(MediaPlayer mp) {
mPlayerEventListener.onCompletion();
}
};
private MediaPlayer.OnInfoListener onInfoListener = new MediaPlayer.OnInfoListener() {
@Override
public boolean onInfo(MediaPlayer mp, int what, int extra) {
mPlayerEventListener.onInfo(what, extra);
return true;
}
};
private MediaPlayer.OnBufferingUpdateListener onBufferingUpdateListener = new MediaPlayer.OnBufferingUpdateListener() {
@Override
public void onBufferingUpdate(MediaPlayer mp, int percent) {
mBufferedPercent = percent;
}
};
private MediaPlayer.OnPreparedListener onPreparedListener = new MediaPlayer.OnPreparedListener() {
@Override
public void onPrepared(MediaPlayer mp) {
mPlayerEventListener.onPrepared();
mMediaPlayer.start();
}
};
private MediaPlayer.OnVideoSizeChangedListener onVideoSizeChangedListener = new MediaPlayer.OnVideoSizeChangedListener() {
@Override
public void onVideoSizeChanged(MediaPlayer mp, int width, int height) {
int videoWidth = mp.getVideoWidth();
int videoHeight = mp.getVideoHeight();
if (videoWidth != 0 && videoHeight != 0) {
mPlayerEventListener.onVideoSizeChanged(videoWidth, videoHeight);
}
}
};
}
plugin_video/src/main/java/com/dueeeke/videoplayer/player/AndroidMediaPlayerFactory.java deleted 100644 → 0
View file @ 2b41a1e7
package com.dueeeke.videoplayer.player;
import android.content.Context;
public class AndroidMediaPlayerFactory extends PlayerFactory {
private Context mContext;
public AndroidMediaPlayerFactory(Context context) {
mContext = context.getApplicationContext();
}
public static AndroidMediaPlayerFactory create(Context context) {
return new AndroidMediaPlayerFactory(context);
}
@Override
public AbstractPlayer createPlayer() {
return new AndroidMediaPlayer(mContext);
}
}
plugin_video/src/main/java/com/dueeeke/videoplayer/player/IjkVideoView.java deleted 100644 → 0
View file @ 2b41a1e7
package com.dueeeke.videoplayer.player;
import android.content.Context;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.util.AttributeSet;
/**
* 由于IjkPlayer已经不再更新，后续不再基于IjkPlayer进行开发，而是将本框架打造成一个通用的播放器框架
* 保留此类目的仅为向下兼容，后续版本将会移除
* @deprecated 使用 {@link VideoView} 代替
*/
@Deprecated
public class IjkVideoView extends VideoView {
public IjkVideoView(@NonNull Context context) {
super(context);
}
public IjkVideoView(@NonNull Context context, @Nullable AttributeSet attrs) {
super(context, attrs);
}
public IjkVideoView(@NonNull Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
}
}
\ No newline at end of file
plugin_video/src/main/java/com/dueeeke/videoplayer/player/PlayerFactory.java deleted 100644 → 0
View file @ 2b41a1e7
package com.dueeeke.videoplayer.player;
public abstract class PlayerFactory {
public abstract AbstractPlayer createPlayer();
}
plugin_video/src/main/java/com/dueeeke/videoplayer/player/ProgressManager.java deleted 100644 → 0
View file @ 2b41a1e7
package com.dueeeke.videoplayer.player;
public abstract class ProgressManager {
public abstract void saveProgress(String url, long progress);
public abstract long getSavedProgress(String url);
}
plugin_video/src/main/java/com/dueeeke/videoplayer/player/VideoView.java deleted 100644 → 0
View file @ 2b41a1e7
package com.dueeeke.videoplayer.player;
import android.app.Activity;
import android.content.ContentResolver;
import android.content.Context;
import android.content.pm.ActivityInfo;
import android.content.res.AssetFileDescriptor;
import android.content.res.TypedArray;
import android.graphics.Bitmap;
import android.graphics.Color;
import android.media.AudioManager;
import android.net.Uri;
import android.os.Parcelable;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.text.TextUtils;
import android.util.AttributeSet;
import android.view.Gravity;
import android.view.OrientationEventListener;
import android.view.View;
import android.view.ViewGroup;
import android.widget.FrameLayout;
import com.dueeeke.videoplayer.R;
import com.dueeeke.videoplayer.controller.BaseVideoController;
import com.dueeeke.videoplayer.controller.MediaPlayerControl;
import com.dueeeke.videoplayer.listener.OnVideoViewStateChangeListener;
import com.dueeeke.videoplayer.listener.PlayerEventListener;
import com.dueeeke.videoplayer.util.L;
import com.dueeeke.videoplayer.util.PlayerUtils;
import com.dueeeke.videoplayer.widget.IRenderView;
import com.dueeeke.videoplayer.widget.SurfaceRenderView;
import com.dueeeke.videoplayer.widget.TextureRenderView;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
/**
* 播放器
* Created by Devlin_n on 2017/4/7.
*/
public class VideoView extends FrameLayout implements MediaPlayerControl, PlayerEventListener {
protected AbstractPlayer mMediaPlayer;//播放器
protected PlayerFactory mPlayerFactory;//工厂类，用于实例化播放核心
@Nullable
protected BaseVideoController mVideoController;//控制器
protected IRenderView mRenderView;
/**
* 真正承载播放器视图的容器
*/
protected FrameLayout mPlayerContainer;
protected boolean mIsFullScreen;//是否处于全屏状态
//通过添加和移除这个view来实现隐藏和显示系统UI，可以避免出现一些奇奇怪怪的问题
@Nullable
protected View mHideSysUIView;
protected static final int FULLSCREEN_FLAGS = View.SYSTEM_UI_FLAG_HIDE_NAVIGATION
| View.SYSTEM_UI_FLAG_FULLSCREEN
| View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY;
public static final int SCREEN_SCALE_DEFAULT = 0;
public static final int SCREEN_SCALE_16_9 = 1;
public static final int SCREEN_SCALE_4_3 = 2;
public static final int SCREEN_SCALE_MATCH_PARENT = 3;
public static final int SCREEN_SCALE_ORIGINAL = 4;
public static final int SCREEN_SCALE_CENTER_CROP = 5;
protected int mCurrentScreenScale;
protected int[] mVideoSize = {0, 0};
protected boolean mIsTinyScreen;//是否处于小屏状态
protected int[] mTinyScreenSize = {0, 0};
protected boolean mIsMute;//是否静音
//--------- data sources ---------//
protected String mUrl;//当前播放视频的地址
protected List<String> mUrls;//concat地址
protected AssetFileDescriptor mAssetFileDescriptor;//assets文件
protected Map<String, String> mHeaders;//当前视频地址的请求头
protected long mCurrentPosition;//当前正在播放视频的位置
//播放器的各种状态
public static final int STATE_ERROR = -1;
public static final int STATE_IDLE = 0;
public static final int STATE_PREPARING = 1;
public static final int STATE_PREPARED = 2;
public static final int STATE_PLAYING = 3;
public static final int STATE_PAUSED = 4;
public static final int STATE_PLAYBACK_COMPLETED = 5;
public static final int STATE_BUFFERING = 6;
public static final int STATE_BUFFERED = 7;
protected int mCurrentPlayState = STATE_IDLE;//当前播放器的状态
public static final int PLAYER_NORMAL = 10; // 普通播放器
public static final int PLAYER_FULL_SCREEN = 11; // 全屏播放器
public static final int PLAYER_TINY_SCREEN = 12; // 小屏播放器
protected int mCurrentPlayerState = PLAYER_NORMAL;
protected AudioManager mAudioManager;//系统音频管理器
@Nullable
protected AudioFocusHelper mAudioFocusHelper;
protected int mCurrentOrientation = 0;
protected static final int PORTRAIT = 1;
protected static final int LANDSCAPE = 2;
protected static final int REVERSE_LANDSCAPE = 3;
protected boolean mIsLockFullScreen;//是否锁定屏幕
protected List<OnVideoViewStateChangeListener> mOnVideoViewStateChangeListeners;
@Nullable
protected ProgressManager mProgressManager;
protected boolean mAutoRotate;
protected boolean mUsingSurfaceView;//启用SurfaceView
protected boolean mIsLooping;//循环洗脑播放
protected boolean mEnableAudioFocus;//监听音频焦点变化
protected boolean mEnableMediaCodec;//启用MediaCodec解码
protected boolean mEnableParallelPlay;//支持多开
public VideoView(@NonNull Context context) {
this(context, null);
}
public VideoView(@NonNull Context context, @Nullable AttributeSet attrs) {
this(context, attrs, 0);
}
public VideoView(@NonNull Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
//读取全局配置
VideoViewConfig config = VideoViewManager.getConfig();
mAutoRotate = config.mAutoRotate;
mUsingSurfaceView = config.mUsingSurfaceView;
mEnableMediaCodec = config.mEnableMediaCodec;
mEnableAudioFocus = config.mEnableAudioFocus;
mEnableParallelPlay = config.mEnableParallelPlay;
mProgressManager = config.mProgressManager;
//默认使用系统的MediaPlayer进行解码
mPlayerFactory = config.mPlayerFactory == null ? AndroidMediaPlayerFactory.create(context) : config.mPlayerFactory;
mCurrentScreenScale = config.mScreenScaleType;
//读取xml中的配置，并综合全局配置
TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.VideoView);
mAutoRotate = a.getBoolean(R.styleable.VideoView_autoRotate, mAutoRotate);
mUsingSurfaceView = a.getBoolean(R.styleable.VideoView_usingSurfaceView, mUsingSurfaceView);
mEnableAudioFocus = a.getBoolean(R.styleable.VideoView_enableAudioFocus, mEnableAudioFocus);
mEnableMediaCodec = a.getBoolean(R.styleable.VideoView_enableMediaCodec, mEnableMediaCodec);
mEnableParallelPlay = a.getBoolean(R.styleable.VideoView_enableParallelPlay, mEnableParallelPlay);
mIsLooping = a.getBoolean(R.styleable.VideoView_looping, false);
mCurrentScreenScale = a.getInt(R.styleable.VideoView_screenScaleType, mCurrentScreenScale);
a.recycle();
initView();
}
/**
* 初始化播放器视图
*/
protected void initView() {
mPlayerContainer = new FrameLayout(getContext());
mPlayerContainer.setBackgroundColor(Color.BLACK);
LayoutParams params = new LayoutParams(
ViewGroup.LayoutParams.MATCH_PARENT,
ViewGroup.LayoutParams.MATCH_PARENT);
this.addView(mPlayerContainer, params);
}
/**
* 开始播放
*/
@Override
public void start() {
if (isInIdleState()) {
startPlay();
} else if (isInPlaybackState()) {
startInPlaybackState();
}
setKeepScreenOn(true);
if (mAudioFocusHelper != null)
mAudioFocusHelper.requestFocus();
}
/**
* 第一次播放
*/
protected void startPlay() {
if (!mEnableParallelPlay) {
VideoViewManager.instance().release();
}
VideoViewManager.instance().addVideoView(this);
if (checkNetwork()) return;
//监听音频焦点改变
if (mEnableAudioFocus) {
mAudioManager = (AudioManager) getContext().getApplicationContext().getSystemService(Context.AUDIO_SERVICE);
mAudioFocusHelper = new AudioFocusHelper();
}
//读取播放进度
if (mProgressManager != null) {
mCurrentPosition = mProgressManager.getSavedProgress(mUrl);
}
//监听设备方向改变
if (mAutoRotate) {
mOrientationEventListener.enable();
}
initPlayer();
startPrepare(false);
}
protected boolean checkNetwork() {
//播放本地数据源时不检测网络
if (isLocalDataSource()) return false;
if (mVideoController != null
&& PlayerUtils.getNetworkType(getContext()) == PlayerUtils.NETWORK_MOBILE
&& !VideoViewManager.instance().playOnMobileNetwork()) {
mVideoController.showStatusView();
return true;
}
return false;
}
/**
* 判断是否为本地数据源，包括 本地文件、Asset、raw
*/
protected boolean isLocalDataSource() {
if (mAssetFileDescriptor != null) {
return true;
} else if (!TextUtils.isEmpty(mUrl)) {
Uri uri = Uri.parse(mUrl);
return ContentResolver.SCHEME_ANDROID_RESOURCE.equals(uri.getScheme())
|| ContentResolver.SCHEME_FILE.equals(uri.getScheme());
}
return false;
}
/**
* 初始化播放器
*/
protected void initPlayer() {
mMediaPlayer = mPlayerFactory.createPlayer();
mMediaPlayer.setPlayerEventListener(this);
mMediaPlayer.initPlayer();
mMediaPlayer.setEnableMediaCodec(mEnableMediaCodec);
mMediaPlayer.setLooping(mIsLooping);
addDisplay();
}
protected void addDisplay() {
if (mRenderView != null) {
mPlayerContainer.removeView(mRenderView.getView());
mRenderView.release();
}
if (mUsingSurfaceView) {
mRenderView = new SurfaceRenderView(getContext(), mMediaPlayer);
} else {
mRenderView = new TextureRenderView(getContext(), mMediaPlayer);
}
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();
if (prepareDataSource()) {
mMediaPlayer.prepareAsync();
setPlayState(STATE_PREPARING);
setPlayerState(isFullScreen() ? PLAYER_FULL_SCREEN : isTinyScreen() ? PLAYER_TINY_SCREEN : PLAYER_NORMAL);
}
}
/**
* 设置播放数据
* @return 播放数据是否设置成功
*/
protected boolean prepareDataSource() {
if (mAssetFileDescriptor != null) {
mMediaPlayer.setDataSource(mAssetFileDescriptor);
return true;
} else if (mUrls != null && mUrls.size() > 0) {
mMediaPlayer.setDataSource(mUrls);
return true;
} else if (!TextUtils.isEmpty(mUrl)) {
mMediaPlayer.setDataSource(mUrl, mHeaders);
return true;
}
return false;
}
/**
* 播放状态下开始播放
*/
protected void startInPlaybackState() {
mMediaPlayer.start();
setPlayState(STATE_PLAYING);
}
/**
* 暂停播放
*/
@Override
public void pause() {
if (isPlaying()) {
mMediaPlayer.pause();
setPlayState(STATE_PAUSED);
setKeepScreenOn(false);
if (mAudioFocusHelper != null)
mAudioFocusHelper.abandonFocus();
}
}
/**
* 继续播放
*/
public void resume() {
if (isInPlaybackState()
&& !mMediaPlayer.isPlaying()) {
mMediaPlayer.start();
setPlayState(STATE_PLAYING);
if (mAudioFocusHelper != null)
mAudioFocusHelper.requestFocus();
setKeepScreenOn(true);
}
}
/**
* 停止播放
*
* @deprecated 使用 {@link #release()} 代替
*/
@Deprecated
public void stopPlayback() {
release();
}
/**
* 释放播放器
*/
public void release() {
VideoViewManager.instance().removeVideoView(this);
if (mVideoController != null) {
mVideoController.hideStatusView();
}
if (!isInIdleState()) {
saveProgress();
mMediaPlayer.release();
mMediaPlayer = null;
if (mAssetFileDescriptor != null) {
try {
mAssetFileDescriptor.close();
} catch (IOException e) {
e.printStackTrace();
}
}
setKeepScreenOn(false);
if (mAudioFocusHelper != null) {
mAudioFocusHelper.abandonFocus();
}
mOrientationEventListener.disable();
if (mRenderView != null) {
mPlayerContainer.removeView(mRenderView.getView());
mRenderView.release();
}
mIsLockFullScreen = false;
mCurrentPosition = 0;
setPlayState(STATE_IDLE);
}
}
/**
* 保存播放进度
*/
protected void saveProgress() {
L.d("saveProgress: " + mCurrentPosition);
if (mCurrentPosition != 0 && mProgressManager != null)
mProgressManager.saveProgress(mUrl, mCurrentPosition);
}
/**
* 是否处于播放状态
*/
protected boolean isInPlaybackState() {
return mMediaPlayer != null
&& mCurrentPlayState != STATE_ERROR
&& mCurrentPlayState != STATE_IDLE
&& mCurrentPlayState != STATE_PREPARING
&& mCurrentPlayState != STATE_PLAYBACK_COMPLETED;
}
protected boolean isInIdleState() {
return mMediaPlayer == null
|| mCurrentPlayState == STATE_IDLE;
}
/**
* 重新播放
*
* @param resetPosition 是否从头开始播放
*/
@Override
public void replay(boolean resetPosition) {
if (resetPosition) {
mCurrentPosition = 0;
}
addDisplay();
startPrepare(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) {
if (isInPlaybackState()) {
mMediaPlayer.seekTo(pos);
}
}
/**
* 是否处于播放状态
*/
@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;
}
/**
* 设置controller是否处于锁定状态
*/
@Override
public void setLock(boolean isLocked) {
this.mIsLockFullScreen = isLocked;
}
/**
* 视频播放出错回调
*/
@Override
public void onError() {
setPlayState(STATE_ERROR);
}
/**
* 视频播放完成回调
*/
@Override
public void onCompletion() {
setPlayState(STATE_PLAYBACK_COMPLETED);
setKeepScreenOn(false);
mCurrentPosition = 0;
if (mProgressManager != null) {
//播放完成，清除进度
mProgressManager.saveProgress(mUrl, 0);
}
}
@Override
public void onInfo(int what, int extra) {
switch (what) {
case AbstractPlayer.MEDIA_INFO_BUFFERING_START:
setPlayState(STATE_BUFFERING);
break;
case AbstractPlayer.MEDIA_INFO_BUFFERING_END:
setPlayState(STATE_BUFFERED);
break;
case AbstractPlayer.MEDIA_INFO_VIDEO_RENDERING_START: // 视频开始渲染
setPlayState(STATE_PLAYING);
if (getWindowVisibility() != VISIBLE) pause();
break;
case AbstractPlayer.MEDIA_INFO_VIDEO_ROTATION_CHANGED:
if (mRenderView != null)
mRenderView.setVideoRotation(extra);
break;
}
}
/**
* 视频缓冲完毕，准备开始播放时回调
*/
@Override
public void onPrepared() {
setPlayState(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);
}
}
/**
* 设置视频地址
*/
public void setUrl(String url) {
setUrl(url, null);
}
/**
* 设置包含请求头信息的视频地址
*
* @param url 视频地址
* @param headers 请求头
*/
public void setUrl(String url, Map<String, String> headers) {
mUrl = url;
mHeaders = headers;
}
/**
* 多个视频无缝衔接播放
*/
public void setUrls(List<String> urls) {
mUrls = urls;
}
/**
* 用于播放assets里面的视频文件
*/
public void setAssetFileDescriptor(AssetFileDescriptor fd) {
this.mAssetFileDescriptor = fd;
}
/**
* 一开始播放就seek到预先设置好的位置
*/
public void skipPositionWhenPlay(int position) {
this.mCurrentPosition = position;
}
/**
* 设置音量 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);
}
}
/**
* 是否自动旋转， 默认不自动旋转
*/
public void setAutoRotate(boolean autoRotate) {
mAutoRotate = autoRotate;
}
/**
* 是否启用SurfaceView，默认不启用
*/
public void setUsingSurfaceView(boolean usingSurfaceView) {
mUsingSurfaceView = usingSurfaceView;
}
/**
* 是否开启AudioFocus监听， 默认开启
*/
public void setEnableAudioFocus(boolean enableAudioFocus) {
mEnableAudioFocus = enableAudioFocus;
}
/**
* 是否使用MediaCodec进行解码（硬解码），默认不开启，使用软解
*/
public void setEnableMediaCodec(boolean enableMediaCodec) {
mEnableMediaCodec = enableMediaCodec;
}
/**
* 自定义播放核心，继承{@link AbstractPlayer}实现自己的播放核心
*
* @deprecated 使用 {@link #setPlayerFactory(PlayerFactory)} ()} 代替
*/
@Deprecated
public void setCustomMediaPlayer(@NonNull AbstractPlayer abstractPlayer) {
mMediaPlayer = abstractPlayer;
}
/**
* 自定义播放核心，继承{@link PlayerFactory}实现自己的播放核心
*/
public void setPlayerFactory(PlayerFactory playerFactory) {
if (playerFactory == null) {
throw new IllegalArgumentException("PlayerFactory can not be null!");
}
mPlayerFactory = playerFactory;
}
/**
* 设置调用{@link #start()}后在移动环境下是否继续播放，默认不继续播放
*
* @deprecated 使用 {@link VideoViewConfig}代替
*/
@Deprecated
public void setPlayOnMobileNetwork(boolean playOnMobileNetwork) {
}
/**
* 添加到{@link VideoViewManager},如需集成到RecyclerView或ListView请开启此选项
* 用于实现同一列表同时只播放一个视频
*
* @deprecated 默认会添加到VideoViewManager，不再需要调用此方法
*/
@Deprecated
public void addToVideoViewManager() {
}
/**
* 支持多开
*/
public void setEnableParallelPlay(boolean enableParallelPlay) {
mEnableParallelPlay = enableParallelPlay;
}
/**
* 进入全屏
*/
@Override
public void startFullScreen() {
if (mIsFullScreen) return;
if (mVideoController == null) return;
//注意：此处是获取到的activity是和VideoController相关联的，换句话说，一定要确保VideoController是通过activity context创建的
Activity activity = PlayerUtils.scanForActivity(mVideoController.getContext());
if (activity == null) return;
//隐藏NavigationBar和StatusBar
if (mHideSysUIView == null) {
mHideSysUIView = new View(getContext());
mHideSysUIView.setSystemUiVisibility(FULLSCREEN_FLAGS);
}
this.addView(mHideSysUIView);
//从当前FrameLayout中移除播放器视图
this.removeView(mPlayerContainer);
//将播放器视图添加到DecorView中即实现了全屏
ViewGroup decorView = (ViewGroup) activity.getWindow().getDecorView();
decorView.addView(mPlayerContainer);
//在全屏时强制监听设备方向
mOrientationEventListener.enable();
mIsFullScreen = true;
setPlayerState(PLAYER_FULL_SCREEN);
}
/**
* 退出全屏
*/
@Override
public void stopFullScreen() {
if (!mIsFullScreen) return;
if (mVideoController == null) return;
//注意：此处是获取到的activity是和VideoController相关联的，换句话说，一定要确保VideoController是通过activity context创建的
Activity activity = PlayerUtils.scanForActivity(mVideoController.getContext());
if (activity == null) return;
if (!mAutoRotate) mOrientationEventListener.disable();
//显示NavigationBar和StatusBar
this.removeView(mHideSysUIView);
//把播放器视图从DecorView中移除并添加到当前FrameLayout中即退出了全屏
ViewGroup decorView = (ViewGroup) activity.getWindow().getDecorView();
decorView.removeView(mPlayerContainer);
this.addView(mPlayerContainer);
mIsFullScreen = false;
setPlayerState(PLAYER_NORMAL);
}
/**
* 判断是否处于全屏状态
*/
@Override
public boolean isFullScreen() {
return mIsFullScreen;
}
/**
* 开启小屏
*/
public void startTinyScreen() {
if (mIsTinyScreen) return;
Activity activity = PlayerUtils.scanForActivity(getContext());
if (activity == null) return;
mOrientationEventListener.disable();
this.removeView(mPlayerContainer);
int width = mTinyScreenSize[0];
if (width <= 0) {
width = PlayerUtils.getScreenWidth(activity, 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;
activity.addContentView(mPlayerContainer, params);
mIsTinyScreen = true;
setPlayerState(PLAYER_TINY_SCREEN);
}
/**
* 退出小屏
*/
public void stopTinyScreen() {
if (!mIsTinyScreen) return;
Activity activity = PlayerUtils.scanForActivity(getContext());
if (activity == null) return;
ViewGroup contentView = activity.findViewById(android.R.id.content);
contentView.removeView(mPlayerContainer);
LayoutParams params = new LayoutParams(
ViewGroup.LayoutParams.MATCH_PARENT,
ViewGroup.LayoutParams.MATCH_PARENT);
this.addView(mPlayerContainer, params);
if (mAutoRotate) mOrientationEventListener.enable();
mIsTinyScreen = false;
setPlayerState(PLAYER_NORMAL);
}
public boolean isTinyScreen() {
return mIsTinyScreen;
}
@Override
public void onVideoSizeChanged(int videoWidth, int videoHeight) {
mVideoSize[0] = videoWidth;
mVideoSize[1] = videoHeight;
if (mRenderView != null) {
mRenderView.setScaleType(mCurrentScreenScale);
mRenderView.setVideoSize(videoWidth, videoHeight);
}
}
@Override
public void onWindowFocusChanged(boolean hasFocus) {
super.onWindowFocusChanged(hasFocus);
if (hasFocus) {
//重新获得焦点时保持全屏状态
if (mHideSysUIView != null) {
mHideSysUIView.setSystemUiVisibility(FULLSCREEN_FLAGS);
}
}
if (isInPlaybackState() && (mAutoRotate || mIsFullScreen)) {
if (hasFocus) {
postDelayed(new Runnable() {
@Override
public void run() {
mOrientationEventListener.enable();
}
}, 800);
} else {
mOrientationEventListener.disable();
}
}
}
/**
* 设置控制器
*/
public void setVideoController(@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);
}
}
/**
* 设置视频比例
*/
@Override
public void setScreenScale(int screenScale) {
mCurrentScreenScale = screenScale;
if (mRenderView != null) {
mRenderView.setScaleType(screenScale);
}
}
/**
* 设置镜像旋转，暂不支持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);
}
}
/**
* 设置小屏的宽高
*
* @param tinyScreenSize 其中tinyScreenSize[0]是宽，tinyScreenSize[1]是高
*/
public void setTinyScreenSize(int[] tinyScreenSize) {
this.mTinyScreenSize = tinyScreenSize;
}
/**
* 加速度传感器监听
*/
protected OrientationEventListener mOrientationEventListener = new OrientationEventListener(getContext().getApplicationContext()) { // 加速度传感器监听，用于自动旋转屏幕
private long mLastTime;
@Override
public void onOrientationChanged(int orientation) {
long currentTime = System.currentTimeMillis();
if (currentTime - mLastTime < 300) return;//300毫秒检测一次
if (mVideoController == null) return;
Activity activity = PlayerUtils.scanForActivity(mVideoController.getContext());
if (activity == null) return;
if (orientation >= 340) { //屏幕顶部朝上
onOrientationPortrait(activity);
} else if (orientation >= 260 && orientation <= 280) { //屏幕左边朝上
onOrientationLandscape(activity);
} else if (orientation >= 70 && orientation <= 90) { //屏幕右边朝上
onOrientationReverseLandscape(activity);
}
mLastTime = currentTime;
}
};
/**
* 竖屏
*/
protected void onOrientationPortrait(Activity activity) {
if (mIsLockFullScreen || !mAutoRotate || mCurrentOrientation == PORTRAIT)
return;
if ((mCurrentOrientation == LANDSCAPE || mCurrentOrientation == REVERSE_LANDSCAPE) && !isFullScreen()) {
mCurrentOrientation = PORTRAIT;
return;
}
mCurrentOrientation = PORTRAIT;
activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
stopFullScreen();
}
/**
* 横屏
*/
protected void onOrientationLandscape(Activity activity) {
if (mCurrentOrientation == LANDSCAPE) return;
if (mCurrentOrientation == PORTRAIT
&& activity.getRequestedOrientation() != ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE
&& isFullScreen()) {
mCurrentOrientation = LANDSCAPE;
return;
}
mCurrentOrientation = LANDSCAPE;
if (!isFullScreen()) {
startFullScreen();
}
activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
}
/**
* 反向横屏
*/
protected void onOrientationReverseLandscape(Activity activity) {
if (mCurrentOrientation == REVERSE_LANDSCAPE) return;
if (mCurrentOrientation == PORTRAIT
&& activity.getRequestedOrientation() != ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE
&& isFullScreen()) {
mCurrentOrientation = REVERSE_LANDSCAPE;
return;
}
mCurrentOrientation = REVERSE_LANDSCAPE;
if (!isFullScreen()) {
startFullScreen();
}
activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE);
}
/**
* 向Controller设置播放状态，用于控制Controller的ui展示
*/
protected void setPlayState(int playState) {
mCurrentPlayState = playState;
if (mVideoController != null)
mVideoController.setPlayState(playState);
if (mOnVideoViewStateChangeListeners != null) {
for (int i = 0, z = mOnVideoViewStateChangeListeners.size(); i < z; i++) {
OnVideoViewStateChangeListener listener = mOnVideoViewStateChangeListeners.get(i);
if (listener != null) {
listener.onPlayStateChanged(playState);
}
}
}
}
/**
* 向Controller设置播放器状态，包含全屏状态和非全屏状态
*/
protected void setPlayerState(int playerState) {
mCurrentPlayerState = playerState;
if (mVideoController != null)
mVideoController.setPlayerState(playerState);
if (mOnVideoViewStateChangeListeners != null) {
for (int i = 0, z = mOnVideoViewStateChangeListeners.size(); i < z; i++) {
OnVideoViewStateChangeListener listener = mOnVideoViewStateChangeListeners.get(i);
if (listener != null) {
listener.onPlayerStateChanged(playerState);
}
}
}
}
/**
* 监听播放状态变化
*/
public void addOnVideoViewStateChangeListener(@NonNull OnVideoViewStateChangeListener listener) {
if (mOnVideoViewStateChangeListeners == null) {
mOnVideoViewStateChangeListeners = new ArrayList<>();
}
mOnVideoViewStateChangeListeners.add(listener);
}
/**
* 移除播放状态监听
*/
public void removeOnVideoViewStateChangeListener(@NonNull OnVideoViewStateChangeListener listener) {
if (mOnVideoViewStateChangeListeners != null) {
mOnVideoViewStateChangeListeners.remove(listener);
}
}
/**
* 设置播放状态监听
*/
public void setOnVideoViewStateChangeListener(@NonNull OnVideoViewStateChangeListener listener) {
if (mOnVideoViewStateChangeListeners == null) {
mOnVideoViewStateChangeListeners = new ArrayList<>();
} else {
mOnVideoViewStateChangeListeners.clear();
}
mOnVideoViewStateChangeListeners.add(listener);
}
/**
* 移除所有播放状态监听
*/
public void clearOnVideoViewStateChangeListeners() {
if (mOnVideoViewStateChangeListeners != null) {
mOnVideoViewStateChangeListeners.clear();
}
}
/**
* 音频焦点改变监听
*/
private class AudioFocusHelper implements AudioManager.OnAudioFocusChangeListener {
private boolean startRequested = false;
private boolean pausedForLoss = false;
private int currentFocus = 0;
@Override
public void onAudioFocusChange(int focusChange) {
if (currentFocus == focusChange) {
return;
}
currentFocus = focusChange;
switch (focusChange) {
case AudioManager.AUDIOFOCUS_GAIN://获得焦点
case AudioManager.AUDIOFOCUS_GAIN_TRANSIENT://暂时获得焦点
if (startRequested || pausedForLoss) {
start();
startRequested = false;
pausedForLoss = false;
}
if (mMediaPlayer != null && !mIsMute)//恢复音量
mMediaPlayer.setVolume(1.0f, 1.0f);
break;
case AudioManager.AUDIOFOCUS_LOSS://焦点丢失
case AudioManager.AUDIOFOCUS_LOSS_TRANSIENT://焦点暂时丢失
if (isPlaying()) {
pausedForLoss = true;
pause();
}
break;
case AudioManager.AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK://此时需降低音量
if (mMediaPlayer != null && isPlaying() && !mIsMute) {
mMediaPlayer.setVolume(0.1f, 0.1f);
}
break;
}
}
/**
* Requests to obtain the audio focus
*/
void requestFocus() {
if (currentFocus == 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) {
currentFocus = AudioManager.AUDIOFOCUS_GAIN;
return;
}
startRequested = true;
}
/**
* Requests the system to drop the audio focus
*/
void abandonFocus() {
if (mAudioManager == null) {
return;
}
startRequested = false;
mAudioManager.abandonAudioFocus(this);
}
}
/**
* 改变返回键逻辑，用于activity
*/
public boolean onBackPressed() {
return mVideoController != null && mVideoController.onBackPressed();
}
@Override
protected Parcelable onSaveInstanceState() {
L.d("onSaveInstanceState: " + mCurrentPosition);
//activity切到后台后可能被系统回收，故在此处进行进度保存
saveProgress();
return super.onSaveInstanceState();
}
}
plugin_video/src/main/java/com/dueeeke/videoplayer/player/VideoViewConfig.java deleted 100644 → 0
View file @ 2b41a1e7
package com.dueeeke.videoplayer.player;
import android.support.annotation.Nullable;
/**
* 播放器全局配置
*/
public class VideoViewConfig {
public static Builder newBuilder() {
return new Builder();
}
public final boolean mPlayOnMobileNetwork;
public final boolean mEnableMediaCodec;
public final boolean mUsingSurfaceView;
public final boolean mAutoRotate;
public final boolean mEnableAudioFocus;
public final boolean mEnableParallelPlay;
public final boolean mIsEnableLog;
public final ProgressManager mProgressManager;
public final PlayerFactory mPlayerFactory;
public final int mScreenScaleType;
private VideoViewConfig(Builder builder) {
mIsEnableLog = builder.mIsEnableLog;
mAutoRotate = builder.mAutoRotate;
mUsingSurfaceView = builder.mUsingSurfaceView;
mPlayOnMobileNetwork = builder.mPlayOnMobileNetwork;
mEnableMediaCodec = builder.mEnableMediaCodec;
mEnableAudioFocus = builder.mEnableAudioFocus;
mProgressManager = builder.mProgressManager;
mEnableParallelPlay = builder.mEnableParallelPlay;
mPlayerFactory = builder.mPlayerFactory;
mScreenScaleType = builder.mScreenScaleType;
}
public final static class Builder {
private boolean mIsEnableLog;
private boolean mPlayOnMobileNetwork;
private boolean mUsingSurfaceView;
private boolean mAutoRotate;
private boolean mEnableMediaCodec;
private boolean mEnableAudioFocus = true;
private boolean mEnableParallelPlay;
private ProgressManager mProgressManager;
private PlayerFactory mPlayerFactory;
private int mScreenScaleType;
/**
* 是否通过重力感应切换全屏/半屏播放器， 默认不开启
*/
public Builder setAutoRotate(boolean autoRotate) {
mAutoRotate = autoRotate;
return this;
}
/**
* 是否启用SurfaceView，默认不启用
*/
public Builder setUsingSurfaceView(boolean usingSurfaceView) {
mUsingSurfaceView = usingSurfaceView;
return this;
}
/**
* 是否使用MediaCodec进行解码（硬解码），默认不开启，使用软解
*/
public Builder setEnableMediaCodec(boolean enableMediaCodec) {
mEnableMediaCodec = enableMediaCodec;
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 setEnableParallelPlay(boolean enableParallelPlay) {
mEnableParallelPlay = enableParallelPlay;
return this;
}
/**
* 是否打印日志
*/
public Builder setLogEnabled(boolean enableLog) {
mIsEnableLog = enableLog;
return this;
}
/**
* 自定义播放核心
*/
public Builder setPlayerFactory(PlayerFactory playerFactory) {
mPlayerFactory = playerFactory;
return this;
}
/**
* 设置视频比例
*/
public Builder setScreenScale(int screenScaleType) {
mScreenScaleType = screenScaleType;
return this;
}
public VideoViewConfig build() {
return new VideoViewConfig(this);
}
}
}
plugin_video/src/main/java/com/dueeeke/videoplayer/player/VideoViewManager.java deleted 100644 → 0
View file @ 2b41a1e7
package com.dueeeke.videoplayer.player;
import java.util.ArrayList;
import java.util.List;
/**
* 视频播放器管理器，管理当前正在播放的VideoView，以及播放器配置
*/
public class VideoViewManager {
/**
* 当前正在播放的VideoView
*/
private List<VideoView> mVideoViews = new ArrayList<>();
private boolean mPlayOnMobileNetwork;
private VideoViewManager() {
mPlayOnMobileNetwork = getConfig().mPlayOnMobileNetwork;
}
private static VideoViewManager sInstance;
private static VideoViewConfig sConfig;
public static void setConfig(VideoViewConfig config) {
if (sConfig == null) {
synchronized (VideoViewConfig.class) {
if (sConfig == null) {
sConfig = config == null ? VideoViewConfig.newBuilder().build() : config;
}
}
}
}
public static VideoViewConfig 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;
}
public void addVideoView(VideoView videoView) {
mVideoViews.add(videoView);
}
public void removeVideoView(VideoView videoView) {
mVideoViews.remove(videoView);
}
public List<VideoView> getVideoViews() {
return mVideoViews;
}
@Deprecated
public void releaseVideoPlayer() {
release();
}
public void pause() {
for (int i = 0; i < mVideoViews.size(); i++) {
VideoView vv = mVideoViews.get(i);
if (vv != null) {
vv.pause();
}
}
}
public void resume() {
for (int i = 0; i < mVideoViews.size(); i++) {
VideoView vv = mVideoViews.get(i);
if (vv != null) {
vv.resume();
}
}
}
public void release() {
for (int i = 0; i < mVideoViews.size(); i++) {
VideoView vv = mVideoViews.get(i);
if (vv != null) {
vv.release();
i--;
}
}
}
public boolean onBackPressed() {
for (int i = 0; i < mVideoViews.size(); i++) {
VideoView vv = mVideoViews.get(i);
if (vv != null) {
boolean b = vv.onBackPressed();
if (b) return true;
}
}
return false;
}
}
plugin_video/src/main/java/com/dueeeke/videoplayer/util/L.java deleted 100644 → 0
View file @ 2b41a1e7
package com.dueeeke.videoplayer.util;
import android.util.Log;
import com.dueeeke.videoplayer.player.VideoViewManager;
/**
* 日志类
* Created by Devlin_n on 2017/6/5.
*/
public class L {
private static final String TAG = "DKPlayer";
private static boolean isDebug = VideoViewManager.getConfig().mIsEnableLog;
public static void d(String msg) {
if (isDebug) {
Log.d(TAG, msg);
}
}
public static void e(String msg) {
if (isDebug) {
Log.e(TAG, msg);
}
}
public static void i(String msg) {
if (isDebug) {
Log.i(TAG, msg);
}
}
public static void w(Throwable e) {
if (isDebug) {
Log.w(TAG, e);
}
}
public static void setDebug(boolean isDebug) {
L.isDebug = isDebug;
}
}
plugin_video/src/main/java/com/dueeeke/videoplayer/util/PlayerUtils.java deleted 100644 → 0
View file @ 2b41a1e7
package com.dueeeke.videoplayer.util;
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.telephony.TelephonyManager;
import android.util.TypedValue;
import android.view.Display;
import android.view.KeyCharacterMap;
import android.view.KeyEvent;
import android.view.MotionEvent;
import android.view.ViewConfiguration;
import android.view.WindowManager;
/**
* 播放器相关工具类
* Created by Devlin_n on 2017/4/10.
*/
public class PlayerUtils {
/**
* 获取状态栏高度
*/
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;
}
/**
* 获取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;
}
}
/**
* 获取Activity
*/
public static Activity scanForActivity(Context context) {
return context == null ? null : (context instanceof Activity ? (Activity) context : (context instanceof ContextWrapper ? scanForActivity(((ContextWrapper) context).getBaseContext()) : null));
}
/**
* 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());
}
/**
* 如果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;
}
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;
/**
* 判断当前网络类型-1为未知网络0为没有网络连接1网络断开或关闭2为以太网3为WiFi4为2G5为3G6为4G
*/
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()) {
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:
// 2G网络
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:
// 3G网络
case TelephonyManager.NETWORK_TYPE_LTE:
// 4G网络
return NETWORK_MOBILE;
}
}
// 未知网络
return NETWORK_UNKNOWN;
}
}
plugin_video/src/main/java/com/dueeeke/videoplayer/widget/CenterView.java deleted 100644 → 0
View file @ 2b41a1e7
package com.dueeeke.videoplayer.widget;
import android.content.Context;
import android.view.Gravity;
import android.view.LayoutInflater;
import android.view.View;
import android.view.animation.Animation;
import android.view.animation.AnimationUtils;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.ProgressBar;
import android.widget.TextView;
import com.dueeeke.videoplayer.R;
/**
* 显示亮度，音量，进度
* Created by Devlin_n on 2017/4/17.
*/
public class CenterView extends LinearLayout {
private ImageView ivIcon;
private TextView tvPercent;
private ProgressBar proPercent;
public CenterView(Context context) {
super(context);
init();
}
private void init() {
setGravity(Gravity.CENTER);
View view = LayoutInflater.from(getContext()).inflate(R.layout.dkplayer_layout_center_window, this);
ivIcon = view.findViewById(R.id.iv_icon);
tvPercent = view.findViewById(R.id.tv_percent);
proPercent = view.findViewById(R.id.pro_percent);
}
public void setIcon(int icon) {
if (ivIcon != null) ivIcon.setImageResource(icon);
}
public void setTextView(String text) {
if (tvPercent != null) tvPercent.setText(text);
}
public void setProPercent(int percent) {
if (proPercent != null) proPercent.setProgress(percent);
}
public void setProVisibility(int visibility) {
if (proPercent != null) proPercent.setVisibility(visibility);
}
@Override
public void setVisibility(int visibility) {
super.setVisibility(visibility);
if (visibility != VISIBLE) {
Animation animation = AnimationUtils.loadAnimation(getContext(), R.anim.dkplayer_anim_center_view);
this.startAnimation(animation);
}
}
}
plugin_video/src/main/java/com/dueeeke/videoplayer/widget/IRenderView.java deleted 100644 → 0
View file @ 2b41a1e7
package com.dueeeke.videoplayer.widget;
import android.graphics.Bitmap;
import android.view.View;
public interface IRenderView {
/**
* 设置视频宽高
* @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
*/
View getView();
/**
* 截图
*/
Bitmap doScreenShot();
/**
* 释放资源
*/
void release();
}
\ No newline at end of file
plugin_video/src/main/java/com/dueeeke/videoplayer/widget/MeasureHelper.java deleted 100644 → 0
View file @ 2b41a1e7
package com.dueeeke.videoplayer.widget;
import android.view.View;
import com.dueeeke.videoplayer.player.VideoView;
public class MeasureHelper {
private int mVideoWidth;
private int mVideoHeight;
private int mCurrentScreenScale;
private int mVideoRotationDegree;
public void setVideoRotation(int videoRotationDegree) {
mVideoRotationDegree = videoRotationDegree;
}
public void setVideoSize(int width, int height) {
mVideoWidth = width;
mVideoHeight = height;
}
public void setScreenScale(int screenScale) {
mCurrentScreenScale = screenScale;
}
public int[] doMeasure(int widthMeasureSpec, int heightMeasureSpec) {
if (mVideoRotationDegree == 90 || mVideoRotationDegree == 270) { // 软解码时处理旋转信息，交换宽高
widthMeasureSpec = widthMeasureSpec + heightMeasureSpec;
heightMeasureSpec = widthMeasureSpec - heightMeasureSpec;
widthMeasureSpec = widthMeasureSpec - heightMeasureSpec;
}
int width = View.getDefaultSize(mVideoWidth, widthMeasureSpec);
int height = View.getDefaultSize(mVideoHeight, heightMeasureSpec);
//如果设置了比例
switch (mCurrentScreenScale) {
case VideoView.SCREEN_SCALE_ORIGINAL:
width = mVideoWidth;
height = mVideoHeight;
break;
case VideoView.SCREEN_SCALE_16_9:
if (height > width / 16 * 9) {
height = width / 16 * 9;
} else {
width = height / 9 * 16;
}
break;
case VideoView.SCREEN_SCALE_4_3:
if (height > width / 4 * 3) {
height = width / 4 * 3;
} else {
width = height / 3 * 4;
}
// Log.d("@@@@", "onMeasure 4:3 : width" + width + " height:" + height);
break;
case VideoView.SCREEN_SCALE_MATCH_PARENT:
width = widthMeasureSpec;
height = heightMeasureSpec;
break;
case VideoView.SCREEN_SCALE_CENTER_CROP:
if (mVideoWidth > 0 && mVideoHeight > 0) {
if (mVideoWidth * height > width * mVideoHeight) {
width = height * mVideoWidth / mVideoHeight;
} else {
height = width * mVideoHeight / mVideoWidth;
}
}
break;
case VideoView.SCREEN_SCALE_DEFAULT:
default:
if (mVideoWidth > 0 && mVideoHeight > 0) {
int widthSpecMode = View.MeasureSpec.getMode(widthMeasureSpec);
int widthSpecSize = View.MeasureSpec.getSize(widthMeasureSpec);
int heightSpecMode = View.MeasureSpec.getMode(heightMeasureSpec);
int heightSpecSize = View.MeasureSpec.getSize(heightMeasureSpec);
if (widthSpecMode == View.MeasureSpec.EXACTLY && heightSpecMode == View.MeasureSpec.EXACTLY) {
// the size is fixed
width = widthSpecSize;
height = heightSpecSize;
// for compatibility, we adjust size based on aspect ratio
if (mVideoWidth * height < width * mVideoHeight) {
//Log.i("@@@", "image too wide, correcting");
width = height * mVideoWidth / mVideoHeight;
} else if (mVideoWidth * height > width * mVideoHeight) {
//Log.i("@@@", "image too tall, correcting");
height = width * mVideoHeight / mVideoWidth;
}
} else if (widthSpecMode == View.MeasureSpec.EXACTLY) {
// only the width is fixed, adjust the height to match aspect ratio if possible
width = widthSpecSize;
height = width * mVideoHeight / mVideoWidth;
if (heightSpecMode == View.MeasureSpec.AT_MOST && height > heightSpecSize) {
// couldn't match aspect ratio within the constraints
height = heightSpecSize;
}
} else if (heightSpecMode == View.MeasureSpec.EXACTLY) {
// only the height is fixed, adjust the width to match aspect ratio if possible
height = heightSpecSize;
width = height * mVideoWidth / mVideoHeight;
if (widthSpecMode == View.MeasureSpec.AT_MOST && width > widthSpecSize) {
// couldn't match aspect ratio within the constraints
width = widthSpecSize;
}
} else {
// neither the width nor the height are fixed, try to use actual video size
width = mVideoWidth;
height = mVideoHeight;
if (heightSpecMode == View.MeasureSpec.AT_MOST && height > heightSpecSize) {
// too tall, decrease both width and height
height = heightSpecSize;
width = height * mVideoWidth / mVideoHeight;
}
if (widthSpecMode == View.MeasureSpec.AT_MOST && width > widthSpecSize) {
// too wide, decrease both width and height
width = widthSpecSize;
height = width * mVideoHeight / mVideoWidth;
}
}
} else {
// no size yet, just adopt the given spec sizes
}
break;
}
return new int[]{width, height};
}
}
plugin_video/src/main/java/com/dueeeke/videoplayer/widget/StatusView.java deleted 100644 → 0
View file @ 2b41a1e7
package com.dueeeke.videoplayer.widget;
import android.content.Context;
import android.support.annotation.Nullable;
import android.util.AttributeSet;
import android.view.LayoutInflater;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewConfiguration;
import android.widget.LinearLayout;
import android.widget.TextView;
import com.dueeeke.videoplayer.R;
/**
* 错误提示，网络提示
* Created by Devlin_n on 2017/4/13.
*/
public class StatusView extends LinearLayout {
private TextView tvMessage;
private TextView btnAction;
private float downX;
private float downY;
public StatusView(Context context) {
this(context, null);
}
public StatusView(Context context, @Nullable AttributeSet attrs) {
super(context, attrs);
init();
}
private void init() {
View root = LayoutInflater.from(getContext()).inflate(R.layout.dkplayer_layout_status_view, this);
tvMessage = root.findViewById(R.id.message);
btnAction = root.findViewById(R.id.status_btn);
this.setBackgroundResource(android.R.color.black);
setClickable(true);
}
public void setMessage(String msg) {
if (tvMessage != null) tvMessage.setText(msg);
}
public void setButtonTextAndAction(String text, OnClickListener listener) {
if (btnAction != null) {
btnAction.setText(text);
btnAction.setOnClickListener(listener);
}
}
@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
switch (ev.getAction()) {
case MotionEvent.ACTION_DOWN:
downX = ev.getX();
downY = ev.getY();
// True if the child does not want the parent to intercept touch events.
getParent().requestDisallowInterceptTouchEvent(true);
break;
case MotionEvent.ACTION_MOVE:
float absDeltaX = Math.abs(ev.getX() - downX);
float absDeltaY = Math.abs(ev.getY() - downY);
if (absDeltaX > ViewConfiguration.get(getContext()).getScaledTouchSlop() ||
absDeltaY > ViewConfiguration.get(getContext()).getScaledTouchSlop()) {
getParent().requestDisallowInterceptTouchEvent(false);
}
case MotionEvent.ACTION_UP:
break;
}
return super.dispatchTouchEvent(ev);
}
}
plugin_video/src/main/java/com/dueeeke/videoplayer/widget/SurfaceRenderView.java deleted 100644 → 0
View file @ 2b41a1e7
package com.dueeeke.videoplayer.widget;
import android.annotation.SuppressLint;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.PixelFormat;
import android.support.annotation.NonNull;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import android.view.View;
import com.dueeeke.videoplayer.player.AbstractPlayer;
@SuppressLint("ViewConstructor")
public class SurfaceRenderView extends SurfaceView implements IRenderView, SurfaceHolder.Callback {
private MeasureHelper mMeasureHelper;
private AbstractPlayer mMediaPlayer;
public SurfaceRenderView(Context context, @NonNull AbstractPlayer player) {
super(context);
mMediaPlayer = player;
initView();
}
private void initView() {
mMeasureHelper = new MeasureHelper();
SurfaceHolder surfaceHolder = getHolder();
surfaceHolder.addCallback(this);
surfaceHolder.setFormat(PixelFormat.RGBA_8888);
}
@Override
public void setVideoSize(int videoWidth, int videoHeight) {
if (videoWidth > 0 && videoHeight > 0) {
mMeasureHelper.setVideoSize(videoWidth, videoHeight);
requestLayout();
}
}
@Override
public void setVideoRotation(int degree) {
mMeasureHelper.setVideoRotation(degree);
setRotation(degree);
}
@Override
public void setScaleType(int scaleType) {
mMeasureHelper.setScreenScale(scaleType);
requestLayout();
}
@Override
public View getView() {
return this;
}
@Override
public Bitmap doScreenShot() {
return null;
}
@Override
public void release() {
}
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
int[] measuredSize = mMeasureHelper.doMeasure(widthMeasureSpec, heightMeasureSpec);
setMeasuredDimension(measuredSize[0], measuredSize[1]);
}
@Override
public void surfaceCreated(SurfaceHolder holder) {
}
@Override
public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
if (mMediaPlayer != null) {
mMediaPlayer.setDisplay(holder);
}
}
@Override
public void surfaceDestroyed(SurfaceHolder holder) {
}
}
\ No newline at end of file
plugin_video/src/main/java/com/dueeeke/videoplayer/widget/TextureRenderView.java deleted 100644 → 0
View file @ 2b41a1e7
package com.dueeeke.videoplayer.widget;
import android.annotation.SuppressLint;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.SurfaceTexture;
import android.support.annotation.NonNull;
import android.view.Surface;
import android.view.TextureView;
import android.view.View;
import com.dueeeke.videoplayer.player.AbstractPlayer;
@SuppressLint("ViewConstructor")
public class TextureRenderView extends TextureView implements IRenderView, TextureView.SurfaceTextureListener {
private MeasureHelper mMeasureHelper;
private SurfaceTexture mSurfaceTexture;
private AbstractPlayer mMediaPlayer;
private Surface mSurface;
public TextureRenderView(Context context, @NonNull AbstractPlayer player) {
super(context);
mMediaPlayer = player;
initView();
}
private void initView() {
mMeasureHelper = new MeasureHelper();
setSurfaceTextureListener(this);
}
@Override
public void setVideoSize(int videoWidth, int videoHeight) {
if (videoWidth > 0 && videoHeight > 0) {
mMeasureHelper.setVideoSize(videoWidth, videoHeight);
requestLayout();
}
}
@Override
public void setVideoRotation(int degree) {
mMeasureHelper.setVideoRotation(degree);
setRotation(degree);
}
@Override
public void setScaleType(int scaleType) {
mMeasureHelper.setScreenScale(scaleType);
requestLayout();
}
@Override
public View getView() {
return this;
}
@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]);
}
@Override
public void onSurfaceTextureAvailable(SurfaceTexture surfaceTexture, int width, int height) {
if (mSurfaceTexture != null) {
setSurfaceTexture(mSurfaceTexture);
} else {
mSurfaceTexture = surfaceTexture;
mSurface = new Surface(surfaceTexture);
mMediaPlayer.setSurface(mSurface);
}
}
@Override
public void onSurfaceTextureSizeChanged(SurfaceTexture surface, int width, int height) {
}
@Override
public boolean onSurfaceTextureDestroyed(SurfaceTexture surface) {
return false;
}
@Override
public void onSurfaceTextureUpdated(SurfaceTexture surface) {
}
}
\ No newline at end of file
plugin_video/src/main/res/anim/dkplayer_anim_center_view.xml deleted 100644 → 0
View file @ 2b41a1e7
<?xml version="1.0" encoding="utf-8"?>
<alpha xmlns:android="http://schemas.android.com/apk/res/android"
android:fromAlpha="1"
android:toAlpha="0"
android:duration="300">
</alpha>
\ No newline at end of file
plugin_video/src/main/res/drawable/dkplayer_layer_progress_bar.xml deleted 100644 → 0
View file @ 2b41a1e7
<?xml version="1.0" encoding="utf-8"?>
<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
<item android:id="@android:id/background">
<shape>
<solid android:color="#cc999999"/>
<size android:height="1dp"/>
</shape>
</item>
<item android:id="@android:id/secondaryProgress">
<clip>
<shape>
<solid android:color="@android:color/white"/>
<size android:height="1dp"/>
</shape>
</clip>
</item>
<item android:id="@android:id/progress">
<clip>
<shape>
<solid android:color="@color/dkplayer_theme_color"/>
<size android:height="1dp"/>
</shape>
</clip>
</item>
</layer-list>
plugin_video/src/main/res/drawable/dkplayer_shape_status_view_btn.xml deleted 100644 → 0
View file @ 2b41a1e7
<?xml version="1.0" encoding="utf-8"?>
<shape xmlns:android="http://schemas.android.com/apk/res/android">
<solid android:color="@color/dkplayer_theme_color"/>
<corners android:radius="30dp"/>
</shape>
\ No newline at end of file
plugin_video/src/main/res/layout/dkplayer_layout_center_window.xml deleted 100644 → 0
View file @ 2b41a1e7
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:orientation="vertical" android:layout_width="160dp"
android:layout_height="120dp"
android:background="#96000000"
android:gravity="center">
<ImageView
android:id="@+id/iv_icon"
android:layout_width="36dp"
android:layout_height="36dp"
tools:src="@drawable/dkplayer_ic_action_volume_up"/>
<TextView
android:id="@+id/tv_percent"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_margin="10dp"
android:textColor="@android:color/white"
android:textSize="14sp"
tools:text="100"/>
<ProgressBar
android:id="@+id/pro_percent"
style="?android:attr/progressBarStyleHorizontal"
android:layout_width="100dp"
android:layout_height="3dp"
android:max="100"
android:progressDrawable="@drawable/dkplayer_layer_progress_bar" />
</LinearLayout>
\ No newline at end of file
plugin_video/src/main/res/layout/dkplayer_layout_status_view.xml deleted 100644 → 0
View file @ 2b41a1e7
<?xml version="1.0" encoding="utf-8"?>
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:background="@android:color/black">
<LinearLayout
android:layout_width="match_parent"
android:layout_height="match_parent"
android:gravity="center"
android:orientation="vertical">
<TextView
android:id="@+id/message"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:gravity="center"
android:padding="10dp"
android:textColor="@android:color/white"
tools:text="You are currently using the mobile network, and continuing to play will consume traffic" />
<TextView
android:id="@+id/status_btn"
android:layout_width="wrap_content"
android:layout_height="26dp"
android:background="@drawable/dkplayer_shape_status_view_btn"
android:gravity="center"
android:paddingLeft="10dp"
android:paddingRight="10dp"
android:textColor="@android:color/white"
tools:text="继续播放" />
</LinearLayout>
</FrameLayout>
\ No newline at end of file
plugin_video/src/main/res/values-en/strings.xml deleted 100644 → 0
View file @ 2b41a1e7
<resources>
<string name="dkplayer_error_message">Something went wrong, please try again later</string>
<string name="dkplayer_retry"> Retry </string>
<string name="dkplayer_continue_play">Continue playing</string>
<string name="dkplayer_wifi_tip">You are currently using the mobile network, and continuing to play will consume traffic</string>
</resources>
plugin_video/src/main/res/values/attrs.xml deleted 100644 → 0
View file @ 2b41a1e7
<?xml version="1.0" encoding="utf-8"?>
<resources>
<declare-styleable name="VideoView">
<attr name="looping" format="boolean"/>
<attr name="autoRotate" format="boolean"/>
<attr name="enableAudioFocus" format="boolean"/>
<attr name="enableMediaCodec" format="boolean"/>
<attr name="usingSurfaceView" format="boolean"/>
<attr name="enableParallelPlay" format="boolean"/>
<attr name="screenScaleType" format="dimension">
<enum name="type_default" value="0"/>
<enum name="type_16_9" value="1"/>
<enum name="type_4_3" value="2"/>
<enum name="type_match_parent" value="3"/>
<enum name="type_original" value="4"/>
<enum name="type_center_crop" value="5"/>
</attr>
</declare-styleable>
</resources>
\ No newline at end of file
plugin_video/src/main/res/values/colors.xml deleted 100644 → 0
View file @ 2b41a1e7
<?xml version="1.0" encoding="utf-8"?>
<resources>
<color name="dkplayer_theme_color">#39C5BB</color>
</resources>
\ No newline at end of file
plugin_video/src/main/res/values/strings.xml deleted 100644 → 0
View file @ 2b41a1e7
<resources>
<string name="dkplayer_error_message">出了点小问题，请稍后重试</string>
<string name="dkplayer_retry"> 重 试 </string>
<string name="dkplayer_continue_play">继续播放</string>
<string name="dkplayer_wifi_tip">您正在使用移动网络，继续播放将消耗流量</string>
</resources>
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment