Video Player Based on VideoView Custom Control Panel

In this paper, we share the specific code of VideoView native custom video player for your reference. The specific contents are as follows

Technical points and highlights used in the project

VideoView encapsulated video playback tool class Custom Video Control Panel Use of gesture recognizer

1. VideoView encapsulated video playback tool class

Video playback is actually quite simple. VideoView provides corresponding methods. See the code code for details. However, it should be noted that UI information of video panel should be updated in the main thread.

/********************************************************
 *  Video service class 
 *  Last modified time: 2017/9/23
 * @author zlc
 *
 *********************************************************/
package com.zlc.video;
import android.app.Activity;
import android.content.Context;
import android.content.pm.ActivityInfo;
import android.media.MediaPlayer;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.os.PowerManager;
import android.os.PowerManager.WakeLock;
import android.util.Log;
import android.view.View;
import android.widget.ImageView;
import android.widget.VideoView;
public class VideoBusiness implements MediaPlayer.OnPreparedListener,MediaPlayer.OnCompletionListener,MediaPlayer.OnErrorListener{

 private Activity activity;
 private WakeLock mWakeLock;
 public VideoView mVideoView;
 private VideoController mController;

 /** Play status enumeration, including 3 Playback status: Idle, preparing */
 private enum PLAYER_STATUS {
  IDLE, PREPARING,PAUSED, PREPARED,RESUMED,STOPPED
 }
 /** Current playback status */
 public PLAYER_STATUS mPlayerStatus = PLAYER_STATUS.IDLE;

 /** Asynchronous processing method of playing information , Used to update progress */
 /** Event flag */
 private int mLastPos;

 public VideoBusiness(Activity activity){
  this.activity = activity;
  //  Keep the screen highlighted 
  PowerManager pm = (PowerManager) activity.getSystemService(Context.POWER_SERVICE);
  mWakeLock = pm.newWakeLock(PowerManager.FULL_WAKE_LOCK | PowerManager.ON_AFTER_RELEASE, "Test");
 }

 // Initialize the video player 
 public void initVideo(VideoView videoView,VideoController controller,String sourceUrl){

  this.mVideoView = videoView;
  this.mController = controller;
  mController.setVideoBusiness(this);
  Log.e("msg"," Set the playback address  = "+sourceUrl);
  mVideoView.setOnPreparedListener(this);
  mVideoView.setOnCompletionListener(this);
  mVideoView.setOnErrorListener(this);
  mVideoView.setVideoPath(sourceUrl); // Set the playback address 

 }

 // Start playing 
 public void startPlay(){
  if (null != mWakeLock && (!mWakeLock.isHeld())) {
   mWakeLock.acquire();
  }
  if(null != mVideoView) {
   Log.e("msg", " Play ");
   mVideoView.start();
   mPlayerStatus = PLAYER_STATUS.PREPARING;
  }
 }


 /**
  *  Pause playback 
  */
 public void pause() {
  if (null != mWakeLock) {
   mWakeLock.release();
  }
  if(null != mVideoView && mVideoView.isPlaying()){
   mVideoView.pause();
   mPlayerStatus = PLAYER_STATUS.PAUSED;
   mLastPos = getCurrentTime();
  }
 }

 /**
  *  Continue playing 
  */
 public void resume(){
  if (null != mWakeLock) {
   mWakeLock.acquire();
  }
  if(null != mVideoView){
   //mVideoView.resume();
   mVideoView.seekTo(mLastPos);
   mVideoView.start();
   mPlayerStatus = PLAYER_STATUS.RESUMED;
  }
 }

 /**
  *  Stop playing 
  */
 public void stop() {

  if (null != mWakeLock) {
   mWakeLock.release();
  }
  if(null != mVideoView){
   mLastPos = getCurrentTime();
   mVideoView.stopPlayback();
   mPlayerStatus = PLAYER_STATUS.STOPPED;
  }
 }

 /**
  *  Determine whether it is playing 
  * @return
  */
 public boolean isPlaying(){
  return mVideoView!=null && mVideoView.isPlaying();
 }

 /**
  *  Whether to pause 
  */
 public boolean isPause(){
  return mPlayerStatus == PLAYER_STATUS.PAUSED;
 }

 /**
  *  Release resources 
  */
 public void release(){
  if (null != mWakeLock) {
   mWakeLock.release();
   mWakeLock = null;
  }
  if(null != mVideoView){
   mVideoView.stopPlayback();
   mVideoView = null;
  }
 }

 @Override
 public void onCompletion(MediaPlayer mediaPlayer) {
  Log.e("onCompletion"," The video is finished ");
  mController.showLong();
  mController.setProgress(0);
  mLastPos = 0;
  mPlayerStatus = PLAYER_STATUS.IDLE;
  removeUIMessage();
 }

 @Override
 public boolean onError(MediaPlayer mediaPlayer, int i, int i1) {
  Log.e("onError"," The video playback reported an error ");
  return false;
 }

 @Override
 public void onPrepared(MediaPlayer mediaPlayer) {
  Log.e("onPrepared"," The video is ready ");
  if (mPlayerStatus!= PLAYER_STATUS.PAUSED){
   int totalTime = getTotalTime();
   mController.setTotalTime(totalTime);
   mController.setProgress(0);
   mController.setMaxProgress(totalTime);
   mPlayerStatus = PLAYER_STATUS.PREPARED;
   sendUIMessage();
  }
 }

 /**
  *  Drag-and-drop playback of progress bar 
  * @param time
  */
 public void seekToPlay(int time){
  int totalSecond = getTotalTime();
  int tempTime = time > totalSecond ? totalSecond : time;
  mVideoView.seekTo(tempTime);
  sendUIMessage();
 }


 // Video pause   Play the big button click event 
 public void playVideo(ImageView id_btn_video_play, ImageView img){
  if(isPlaying()){
   pause();
   id_btn_video_play.setVisibility(View.VISIBLE);
   img.setImageResource(R.drawable.video_pause);
   mPlayerStatus = PLAYER_STATUS.PAUSED;
   mUIHandler.sendEmptyMessageDelayed(UI_EVENT_UPDATE_CURRPOSITION, 500);
  }else if(isPause()){
   resume();
   id_btn_video_play.setVisibility(View.GONE);
   img.setImageResource(R.drawable.video_play);
   mPlayerStatus = PLAYER_STATUS.RESUMED;
  }else{
   img.setImageResource(R.drawable.video_play);
   id_btn_video_play.setVisibility(View.GONE);
   startPlay();
   mPlayerStatus = PLAYER_STATUS.PREPARING;
  }
 }

 private boolean isCurrentLandscape = false; // Is it a horizontal screen 
 // Clicking method of horizontal and vertical screen switching button 
 public void toggleScreenDir(View v){
  if (isCurrentLandscape) {//  If the current horizontal screen, switch to vertical screen , Then turn the button into a larger icon 
   activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
   if(v instanceof ImageView){
    ((ImageView)v).setImageResource(R.drawable.zuidahua_2x);
   }
  } else {//  If the current screen is vertical, switch to horizontal screen , Then turn the button into a smaller icon 
   activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
   if(v instanceof ImageView){
    ((ImageView)v).setImageResource(R.drawable.xiaohua_2x);
   }
  }
  isCurrentLandscape = !isCurrentLandscape;
 }

 public UIHandler mUIHandler = new UIHandler(Looper.getMainLooper());
 public final int UI_EVENT_UPDATE_CURRPOSITION = 1; // Update progress information 
 public boolean isSeekBarEnable = true;

 class UIHandler extends Handler{
  public UIHandler(Looper mainLooper) {
   super(mainLooper);
  }

  @Override
  public void handleMessage(Message msg) {
   switch (msg.what) {
    // Update progress and time 
    case UI_EVENT_UPDATE_CURRPOSITION:
     if (isSeekBarEnable) {
      int currentPosition = getCurrentTime();
      String timeString = mController.getTimeString(currentPosition);
      //Log.e("handleMessage",timeString);
      if(isPlaying()) {
       mController.setProgress(currentPosition);
       mUIHandler.sendEmptyMessageDelayed(
         UI_EVENT_UPDATE_CURRPOSITION, 200);
      }
     }
     break;
   }
  }
 }

 public void sendUIMessage(){
  mUIHandler.sendEmptyMessage(UI_EVENT_UPDATE_CURRPOSITION);
 }

 public void removeUIMessage(){
  mUIHandler.removeMessages(UI_EVENT_UPDATE_CURRPOSITION);
 }

 // Total time to get video 
 public int getTotalTime(){
  return mVideoView==null ? 0 : mVideoView.getDuration();
 }

 // Get the current time of the video 
 public int getCurrentTime(){
  return mVideoView==null ? 0 : mVideoView.getCurrentPosition();
 }
}

2. Use of gesture recognizers

//1.  Create a gesture recognizer 
 progressGestureDetector = new GestureDetector(mContext,new ProgressGestureListenr());

//2. Replication GestureDetector.OnGestureListener Adj. 6 Methods 
boolean onDown(MotionEvent e) // Triggered when the user presses the screen 

void onShowPress(MotionEvent e) ////down Events occur and move Or up Trigger this event before it occurs 

boolean onSingleTapUp(MotionEvent e) //1 Secondary clicks up Events 

boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) // Drag an event on the screen 

void onLongPress(MotionEvent e) // Long press event 

 boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) // Sliding gesture event 

 //3 onTouch Middle interception 
 @Override
 public boolean onTouch(View view, MotionEvent event) {

  return progressGestureDetector.onTouchEvent(event);
 }
 //4  Event binding 
 progressArea.setOnTouchListener(this);

3. Customize the video control panel

The code is relatively simple at the same time, the code is not long and there are comments. If you need it, you can refer to the great God and don't spray it

package com.zlc.video;

import android.app.Activity;
import android.content.Context;
import android.media.AudioManager;
import android.os.Handler;
import android.os.Message;
import android.provider.Settings;
import android.util.AttributeSet;
import android.util.Log;
import android.view.GestureDetector;
import android.view.MotionEvent;
import android.view.View;
import android.view.Window;
import android.view.WindowManager;
import android.widget.FrameLayout;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.ProgressBar;
import android.widget.RelativeLayout;
import android.widget.SeekBar;
import android.widget.TextView;

import com.zlc.video.utils.DensityUtil;
import com.zlc.video.utils.ScreenUtil;
import java.text.SimpleDateFormat;
import java.util.Date;

public class VideoController extends RelativeLayout implements View.OnTouchListener,View.OnClickListener,SeekBar.OnSeekBarChangeListener{

 private Context mContext;
 private View mContainer;
 private VideoBusiness videoBusiness;
 /** 表示当前视频控制面板是否展示*/
 public boolean isShow = true;
 private Handler hideHandler = new Handler() {
  @Override
  public void handleMessage(Message msg) {
   if (isShow) {
    hideController();
   }
  }
 };
 /** 视频功能控制底边栏*/
 private LinearLayout mMediaController;

 /***************手势相关*********************/
 private int GESTURE_FLAG = 0;//1调节进度,2调节音量,3调节亮度
 private FrameLayout mProgressIndicator;
 private ProgressBar progressBar;
 /**进度相关*/
 private GestureDetector progressGestureDetector;
 private static final int GESTURE_MODIFY_PROGRESS = 1;
 /**音量相关*/
 private static final int GESTURE_MODIFY_VOLUME = 2;
 private AudioManager audiomanager;
 private int maxVolume, currentVolume;
 /**亮度相关*/
 private static final int GESTURE_MODIFY_BRIGHTNESS = 3;
 private WindowManager.LayoutParams brightnessLp;
 private int maxBrightness,currentBrightness;
 private LinearLayout progressArea;
 private int targetTime;
 //UI相关
 private RelativeLayout id_rl_video_controller;
 private FrameLayout id_fl_video_play;
 private FrameLayout id_fl_video_expand;
 private TextView id_video_time;
 private TextView id_video_totaltime;
 private SeekBar id_sb_progress;
 private ImageView id_btn_video_play;
 private ImageView id_iv_video_play;
 private TextView id_tv_video_info;


 public VideoController(Context context) {
  this(context, null);
 }

 public VideoController(Context context, AttributeSet attrs) {
  this(context, attrs, 0);
 }

 public VideoController(Context context, AttributeSet attrs, int defStyle) {
  super(context, attrs, defStyle);
  mContext = context;
  init();
  initListener();
 }

 private void init() {
  //初始化音量相关
  audiomanager = (AudioManager) getContext().getSystemService(Context.AUDIO_SERVICE);
  maxVolume = audiomanager.getStreamMaxVolume(AudioManager.STREAM_MUSIC); // 获取系统最大音量
  currentVolume = audiomanager.getStreamVolume(AudioManager.STREAM_MUSIC); // 获取当前值
  //初始化亮度相关
  brightnessLp=((Activity)mContext).getWindow().getAttributes();
  currentBrightness = getCurrentBrightness();
  maxBrightness = 255; //设置最大亮度
  initView();
 }

 private void initView() {
  mContainer = View.inflate(mContext, R.layout.video_controller, null);
  id_rl_video_controller = findView(R.id.id_rl_video_controller);
  mMediaController = findView(R.id.id_ll_controller);
  mProgressIndicator = findView(R.id.id_fl_progress_indicator);
  progressBar = findView(R.id.id_pb_gesture_progress);
  progressArea = findView(R.id.id_ll_video_gesture_progress);
  id_fl_video_play = findView(R.id.id_fl_video_play);
  id_fl_video_expand = findView(R.id.id_fl_video_expand);
  id_video_time = findView(R.id.id_video_time);
  id_video_totaltime = findView(R.id.id_video_totaltime);
  id_sb_progress = findView(R.id.id_sb_progress);
  id_btn_video_play = findView(R.id.id_btn_video_play);
  id_iv_video_play = findView(R.id.id_iv_video_play);
  id_tv_video_info = findView(R.id.id_tv_video_info);
  addView(mContainer);
 }

 private <T extends View> T findView(int viewId) {
  return (T) mContainer.findViewById(viewId);
 }

 public void setVideoBusiness(VideoBusiness videoBusiness) {
  this.videoBusiness = videoBusiness;
 }

 private void initListener() {
  //进度手势相关
  progressGestureDetector = new GestureDetector(mContext,new ProgressGestureListenr());
  progressGestureDetector.setIsLongpressEnabled(true);
  progressArea.setLongClickable(true);
  progressArea.setOnTouchListener(this);
  mMediaController.setOnClickListener(this);
  id_rl_video_controller.setOnClickListener(this);
  id_fl_video_play.setOnClickListener(this);
  id_fl_video_expand.setOnClickListener(this);
  id_btn_video_play.setOnClickListener(this);
  id_sb_progress.setOnSeekBarChangeListener(this);
 }

 //状态切换
 public void toggle() {
  if (isShow) {
   hideController();
  } else {
   showController();
  }
 }

 //隐藏底部控制栏
 public void hideController() {
  isShow = false;
  mMediaController.setVisibility(View.GONE);
  endTimer();
 }

 //显示底部控制栏
 public void showController() {
  isShow = true;
  mMediaController.setVisibility(View.VISIBLE);
  startTimer();
 }

 private void startTimer() {
  if (hideHandler != null){
   hideHandler.removeMessages(0);
  }
  hideHandler.sendEmptyMessageDelayed(0, 5000);
 }

 private void endTimer() {
  hideHandler.removeMessages(0);
 }

 public void resetTimer() {
  endTimer();
  startTimer();
 }

 public void showLong() {
  isShow = true;
  mMediaController.setVisibility(View.VISIBLE);
 }

 //设置视频总时间
 public void setTotalTime(int time) {
  String totalTime = getTimeString(time);
  id_video_totaltime.setText(totalTime);
 }

 //设置视频当前进度
 public void setProgress(int progress){
  int maxProgress = videoBusiness.getTotalTime();
  int tempProgress = progress > maxProgress ? maxProgress : progress;
  id_sb_progress.setProgress(tempProgress);
 }

 //是指视频总进度
 public void setMaxProgress(int maxProgress){
  id_sb_progress.setMax(maxProgress);
 }

 //获取当前亮度
 private int getCurrentBrightness(){
  int currentBrightness = 255;
  if (brightnessLp.screenBrightness == WindowManager.LayoutParams.BRIGHTNESS_OVERRIDE_NONE){
   // 获取系统亮度
   try {
    currentBrightness = Settings.System.getInt(((Activity)mContext).getContentResolver(), Settings.System.SCREEN_BRIGHTNESS);
   } catch (Settings.SettingNotFoundException e) {
    e.printStackTrace();
   }
  }else{
   // 获取当前窗口亮度
   currentBrightness = (int)(brightnessLp.screenBrightness * 255);
  }
  return currentBrightness;
 }


 @Override
 public void onClick(View view) {
  switch (view.getId()){
   case R.id.id_ll_controller: //底部控制器
    showController();
    break;
   case R.id.id_rl_video_controller: //全屏点击
    toggle();
    break;
   case R.id.id_fl_video_play: // 暂停/播放
   case R.id.id_btn_video_play: // 暂停/播放
    videoBusiness.playVideo(id_btn_video_play,id_iv_video_play);
    break;
   case R.id.id_fl_video_expand: //全屏
    resetTimer();
    videoBusiness.toggleScreenDir(view);
    break;
  }
 }


 @Override
 public boolean onTouch(View view, MotionEvent event) {

  getParent().requestDisallowInterceptTouchEvent(true);
  if (event.getAction() == MotionEvent.ACTION_UP) {
   mProgressIndicator.setVisibility(View.INVISIBLE);
   if (GESTURE_FLAG == GESTURE_MODIFY_PROGRESS) { //调节进度
    Log.e("进度时间","targetTime="+targetTime);
    videoBusiness.seekToPlay(targetTime);
    videoBusiness.isSeekBarEnable = true;
    hideController();
   }
   GESTURE_FLAG = 0;// 手指离开屏幕后，重置调节音量或进度的标志
  }
  return progressGestureDetector.onTouchEvent(event);
 }

 private int currentPosition; //当前播放进度
 private int totalPosition; //总播放进度
 class ProgressGestureListenr implements GestureDetector.OnGestureListener{
  private boolean firstScroll = false;// 每次触摸屏幕后，第1次scroll的标志
  private int slop;// 触发设置变动的最小距离
  @Override
  public boolean onDown(MotionEvent e) { //用户按下屏幕就会触发
   //初始数据
   slop = DensityUtil.dp2px(mContext,2);
   currentPosition = videoBusiness.getCurrentTime();
   totalPosition = videoBusiness.getTotalTime();
   firstScroll = true;
   return false;
  }

  @Override
  public void onShowPress(MotionEvent e) { //down事件发生而move或则up还没发生前触发该事件
  }

  @Override
  public boolean onSingleTapUp(MotionEvent e) { //1次点击up事件
   toggle();
   if(videoBusiness.isPlaying()){ //正在播放
    return false;
   }else{ //暂停或者开始播放
    videoBusiness.playVideo(id_btn_video_play,id_iv_video_play);
    isShow = false;
    return true;
   }
  }

  //在屏幕上拖动事件
  @Override
  public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) {
   if (firstScroll) {// 以触摸屏幕后第1次滑动为标准，避免在屏幕上操作切换混乱
    // 横向的距离变化大则调整进度，纵向的变化大则调整音量
    Log.e("xxxxxxx",e1.getX()+"");
    Log.e("yyyyyyy",e1.getY()+"");
    setScroll(e1, distanceX, distanceY);
   }
   // 如果每次触摸屏幕后第1次scroll是调节进度，那之后的scroll事件都处理音量进度，直到离开屏幕执行下1次操作
   switch (GESTURE_FLAG){
    case GESTURE_MODIFY_PROGRESS: //调节当前进度
     setCurrentProgress(distanceX, distanceY,slop);
     break;
    case GESTURE_MODIFY_VOLUME: //调节当前音量
     setCurrentVolume(distanceX, distanceY,slop);
     break;
    case GESTURE_MODIFY_BRIGHTNESS: //调节当前亮度
     setCurrentBrightess(distanceX, distanceY,slop);
     break;
   }
   firstScroll=false;
   return false;
  }

  @Override
  public void onLongPress(MotionEvent e) { //长按事件
  }

  @Override
  public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) { //滑动手势事件
   return false;
  }
 }

 //滑动事件
 private void setScroll(MotionEvent e1, float distanceX, float distanceY) {
  int screenWidth = ScreenUtil.getScreenWidth(mContext);
  Log.e("屏宽",screenWidth+"");
  //横向的距离变化大则调整进度，纵向的变化大则调整音量
  mProgressIndicator.setVisibility(View.VISIBLE);
  if (Math.abs(distanceX) >= Math.abs(distanceY)) { //调整进度
   progressBar.setVisibility(View.INVISIBLE);
   id_tv_video_info.setVisibility(VISIBLE);
   GESTURE_FLAG = GESTURE_MODIFY_PROGRESS;
   videoBusiness.isSeekBarEnable = false;
   endTimer();
   showLong();
  }else { //调整音量
   progressBar.setVisibility(VISIBLE);
   id_tv_video_info.setVisibility(INVISIBLE);
   if (e1.getX() > screenWidth / 2){ //屏幕右边上下滑动调整音量
    //右半屏音量
    setVideoVolume();
   }else{        //屏幕左边上下滑动调整亮度
    //左半屏亮度
    setVideoBrightness();
   }
  }
 }

 //设置当前进度
 private void setCurrentProgress(float distanceX, float distanceY,float slop) {
  if (Math.abs(distanceX) > Math.abs(distanceY)) {// 横向移动大于纵向移动
   //Log.e("setCurrentProgress",distanceX+"");
   if(distanceX >= slop){ //从右往左滑 快退
    mProgressIndicator.setBackgroundResource(R.drawable.kuaitui);
    if (currentPosition > 1000) {
     currentPosition -= 1500;
    }
   }else if(distanceX <= -slop){ //从左往右滑 快进
    mProgressIndicator.setBackgroundResource(R.drawable.kuaijin);
    if (currentPosition < totalPosition) {
     currentPosition += 1500;
    }
   }
  }
  targetTime = currentPosition;
  Log.e("进度时间","currentPosition="+currentPosition);
  id_sb_progress.setProgress(currentPosition);
  id_video_time.setText(getTimeString(currentPosition));
  String videoPbInfo = getTimeString(currentPosition)+"/"+ getTimeString(totalPosition);
  id_tv_video_info.setText(videoPbInfo);
 }

 //设置当前亮度
 private void setCurrentBrightess(float distanceX, float distanceY, float slop) {
  currentBrightness = getCurrentBrightness();
  if (Math.abs(distanceY) > Math.abs(distanceX)) {// 纵向移动大于横向移动
   if (distanceY >= slop) {// 上滑 亮度调大,注意横屏时的坐标体系,尽管左上角是原点，但横向向上滑动时distanceY为正
    if (currentBrightness < maxBrightness) {// 为避免调节过快，distanceY应大于1个设定值
     currentBrightness += 8;
    }
   } else if (distanceY <= -slop) {// 亮度调小
    if (currentBrightness > 0) {
     currentBrightness -= 8;
    }
    if (currentBrightness<0){
     currentBrightness=0;
    }
   }
   mProgressIndicator.setBackgroundResource(R.drawable.liangdu);
   progressBar.setProgress(currentBrightness);
   changeAppBrightness(mContext,currentBrightness);
  }
 }

 //设置当前音量
 private void setCurrentVolume(float distanceX, float distanceY,float slop) {

  currentVolume = audiomanager.getStreamVolume(AudioManager.STREAM_MUSIC); // 获取当前值
  if (Math.abs(distanceY) > Math.abs(distanceX)) { // 纵向移动大于横向移动
   if (distanceY >= slop) { // 上滑 音量调大,注意横屏时的坐标体系,尽管左上角是原点，但横向向上滑动时distanceY为正
    if (currentVolume < maxVolume) {// 为避免调节过快，distanceY应大于1个设定值
     currentVolume++;
    }
    mProgressIndicator.setBackgroundResource(R.drawable.yinliang);
   } else if (distanceY <= -slop) {// 音量调小 下滑
    if (currentVolume > 0) {
     currentVolume--;
     if (currentVolume == 0) {// 静音，设定静音独有的图片
      mProgressIndicator.setBackgroundResource(R.drawable.jingying);
     }
    }
   }
   progressBar.setProgress(currentVolume);
   audiomanager.setStreamVolume(AudioManager.STREAM_MUSIC, currentVolume, 0);
  }
 }

 //设置视频亮度
 private void setVideoBrightness() {
  progressBar.setMax(maxBrightness);
  progressBar.setProgress(currentBrightness);
  mProgressIndicator.setBackgroundResource(R.drawable.liangdu);
  GESTURE_FLAG = GESTURE_MODIFY_BRIGHTNESS;
 }

 //设置视频音量
 private void setVideoVolume() {
  progressBar.setMax(maxVolume);
  progressBar.setProgress(currentVolume);
  mProgressIndicator.setBackgroundResource(R.drawable.yinliang);
  GESTURE_FLAG = GESTURE_MODIFY_VOLUME;
 }

 //改变系统亮度
 public void changeAppBrightness(Context context, int brightness) {
  Window window = ((Activity) context).getWindow();
  WindowManager.LayoutParams lp = window.getAttributes();
  if (brightness == -1) {
   lp.screenBrightness = WindowManager.LayoutParams.BRIGHTNESS_OVERRIDE_NONE;
  } else {
   lp.screenBrightness = (brightness <= 0 ? 1 : brightness) / 255f;
  }
  window.setAttributes(lp);
 }

 public String getTimeString(int second) {
  int temp = second / 1000;
  int hh = temp / 3600;
  SimpleDateFormat sdf;
  if (0 != hh) {
   sdf = new SimpleDateFormat("HH:mm:ss");
  } else {
   sdf = new SimpleDateFormat("mm:ss");
  }
  String format = sdf.format(new Date(second));
  return format;
 }

 //进度条改变
 @Override
 public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) {
  String timeString = getTimeString(progress);
  id_video_time.setText(timeString);
 }

 //开始拖动
 @Override
 public void onStartTrackingTouch(SeekBar seekBar) {
  showLong();
  videoBusiness.removeUIMessage();
 }

 //结束拖动
 @Override
 public void onStopTrackingTouch(SeekBar seekBar) {
  showController();
  int progress = seekBar.getProgress();
  videoBusiness.seekToPlay(progress);
 }

}

4. Download address

VideoView Native Custom Video Player