ijkplayer打造完美视频播放器

末蓝、 2022-02-01 13:25 808阅读 0赞

1.ijkplayer简介

ijkplayer是一个基于FFmpeg的轻量级Android/iOS视频播放器。FFmpeg的是全球领先的多媒体框架，能够解码，编码， 转码，复用，解复用，流，过滤器和播放大部分的视频格式。它提供了录制、转换以及流化音视频的完整解决方案。它包含了非常先进的音频/视频编解码库libavcodec，为了保证高可移植性和编解码质量，libavcodec里很多code都是从头开发的。

2.功能的展示

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3drX2JlaWNhaQ_size_16_color_FFFFFF_t_70 watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3drX2JlaWNhaQ_size_16_color_FFFFFF_t_70 1 watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3drX2JlaWNhaQ_size_16_color_FFFFFF_t_70 2

支持横竖屏切换展示，上下滑动声音亮度的调节等功能。

3. androidStudio 接入

1）添加.so库：

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3drX2JlaWNhaQ_size_16_color_FFFFFF_t_70 3

如图所示：将.so文件添加到自己的项目中：

2）在Gradle中添加依赖：

20190514163824850.png

  1. // Bili required, enough for most devices.
  2. compile 'tv.danmaku.ijk.media:ijkplayer-java:0.8.8'
  3. compile 'pub.devrel:easypermissions:1.0.1'

3）开始代码的实现

1.创建一个类CusIjkView，继承frameLayout，（自定义播放器样式）

  1. 代码如下：
  2. // 打印日志的TAG
  3. private String TAG = this.getClass().getSimpleName();
  4. // mCurrentState is a  object's current state.
  5. private int mCurrentState = PlayStateParams.STATE_IDLE;
  6. // mTargetState is the state that a method caller intends to reach.
  7. // For instance, regardless the VideoView object's current state, calling pause()
  8. // intends to bring the object to a target state of STATE_PAUSED.
  9. private int mTargetState = PlayStateParams.STATE_IDLE;
  10. // 播放地址通过客户端可设置
  11. private Uri mUri;
  12. // 播放器的一些基本配置
  13. private Map<String, String> mHeaders;
  14. // 所有我们需要播放和显示视频的东西
  15. private IRenderView.ISurfaceHolder mSurfaceHolder = null;
  16. // 视频宽度
  17. private int mVideoWidth;
  18. // 视频高度
  19. private int mVideoHeight;
  20. // 窗口宽度
  21. private int mSurfaceWidth;
  22. // 窗口高度
  23. private int mSurfaceHeight;
  24. // 视频旋转角度
  25. private int mVideoRotationDegree;
  26. // 媒体播放器
  27. private IMediaPlayer mMediaPlayer;
  28. // 媒体控制器
  29. private IMediaController mMediaController;
  30. // 播放完成监听
  31. private IMediaPlayer.OnCompletionListener mOnCompletionListener;
  32. // 播放准备监听
  33. private IMediaPlayer.OnPreparedListener mOnPreparedListener;
  34. // 播放缓冲监听
  35. private int mCurrentBufferPercentage;
  36. // 播放错误监听
  37. private IMediaPlayer.OnErrorListener mOnErrorListener;
  38. // 播放其他信息监听
  39. private IMediaPlayer.OnInfoListener mOnInfoListener;
  40. // 为记录seek位置而做准备
  41. private long mSeekWhenPrepared;
  42. private Context mAppContext;
  43. private IRenderView mRenderView;
  44. private int mVideoSarNum;
  45. private int mVideoSarDen;
  46. // Extend: Aspect Ratio
  47. private static final int[] s_allAspectRatio = {
  48.         IRenderView.AR_ASPECT_FIT_PARENT,
  49.         IRenderView.AR_ASPECT_FILL_PARENT,
  50.         IRenderView.AR_ASPECT_WRAP_CONTENT,
  51.         IRenderView.AR_MATCH_PARENT,
  52.         IRenderView.AR_16_9_FIT_PARENT,
  53.         IRenderView.AR_4_3_FIT_PARENT};
  54. private int mCurrentAspectRatioIndex = 0;
  55. private int mCurrentAspectRatio = s_allAspectRatio[mCurrentAspectRatioIndex];
  56. // Extend: Render
  57. public static final int RENDER_SURFACE_VIEW = 1;
  58. public static final int RENDER_TEXTURE_VIEW = 2;
  59. private List<Integer> mAllRenders = new ArrayList<>();
  60. // 使用编解码器硬编码还是软编码，true 硬编码 false 为软编码
  61. private boolean usingMediaCodec;
  62. // 使用编解码是否自转
  63. private boolean usingMediaCodecAutoRotate;
  64. private boolean usingAndroidPlayer;
  65. private boolean usingOpenSLES;
  66. private boolean enableBackgroundPlay;
  68. public CusIjkView(Context context) {
  69.     super(context);
  70.     initVideoView(context);
  71. }
  73. public CusIjkView(Context context, AttributeSet attrs) {
  74.     super(context, attrs);
  75.     initVideoView(context);
  76. }
  78. public CusIjkView(Context context, AttributeSet attrs, int defStyleAttr) {
  79.     super(context, attrs, defStyleAttr);
  80.     initVideoView(context);
  81. }
  83. /**
  84.  * 初始化视频view
  85.  */
  86. private void initVideoView(Context context) {
  87.     mAppContext = context.getApplicationContext();
  89.     initRenders();
  91.     mVideoWidth = 0;
  92.     mVideoHeight = 0;
  94.     // 设置为可触摸并且获取焦点
  95.     setFocusable(true);
  96.     setFocusableInTouchMode(true);
  97.     requestFocus();
  99.     mCurrentState = PlayStateParams.STATE_IDLE;
  100.     mTargetState = PlayStateParams.STATE_IDLE;
  101. }
  103. /**
  104.  * 设置渲染器
  105.  */
  106. public void setRenderView(IRenderView renderView) {
  107.     if (mRenderView != null) {
  108.         if (mMediaPlayer != null) {
  109.             mMediaPlayer.setDisplay(null);
  110.         }
  112.         View renderUIView = mRenderView.getView();
  113.         mRenderView.removeRenderCallback(mSHCallback);
  114.         mRenderView = null;
  115.         removeView(renderUIView);
  116.     }
  118.     if (renderView == null)
  119.         return;
  121.     mRenderView = renderView;
  122.     renderView.setAspectRatio(mCurrentAspectRatio);
  123.     if (mVideoWidth > 0 && mVideoHeight > 0)
  124.         renderView.setVideoSize(mVideoWidth, mVideoHeight);
  125.     if (mVideoSarNum > 0 && mVideoSarDen > 0)
  126.         renderView.setVideoSampleAspectRatio(mVideoSarNum, mVideoSarDen);
  128.     View renderUIView = mRenderView.getView();
  130.     LayoutParams lp = new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT, Gravity.CENTER);
  131.     renderUIView.setLayoutParams(lp);
  132.     addView(renderUIView);
  134.     mRenderView.addRenderCallback(mSHCallback);
  135.     mRenderView.setVideoRotation(mVideoRotationDegree);
  136. }
  138. /**
  139.  * 设置旋转角度
  140.  */
  141. public void setPlayerRotation(int rotation) {
  142.     mVideoRotationDegree = rotation;
  143.     if (mRenderView != null) {
  144.         mRenderView.setVideoRotation(mVideoRotationDegree);
  145.     }
  146. }
  148. /**
  149.  * 旋转渲染器
  150.  */
  151. public void setRender(int render) {
  152.     switch (render) {
  153.         case RENDER_TEXTURE_VIEW: {
  154.             TextureRenderView renderView = new TextureRenderView(getContext());
  155.             if (mMediaPlayer != null) {
  156.                 renderView.getSurfaceHolder().bindToMediaPlayer(mMediaPlayer);
  157.                 renderView.setVideoSize(mMediaPlayer.getVideoWidth(), mMediaPlayer.getVideoHeight());
  158.                 renderView.setVideoSampleAspectRatio(mMediaPlayer.getVideoSarNum(), mMediaPlayer.getVideoSarDen());
  159.                 renderView.setAspectRatio(mCurrentAspectRatio);
  160.             }
  161.             setRenderView(renderView);
  162.             break;
  163.         }
  164.         case RENDER_SURFACE_VIEW: {
  165.             SurfaceRenderView renderView = new SurfaceRenderView(getContext());
  166.             setRenderView(renderView);
  167.             break;
  168.         }
  169.         default:
  170.             Log.e(TAG, String.format(Locale.getDefault(), "invalid render %d\n", render));
  171.             break;
  172.     }
  173. }
  175. /**
  176.  * 设置视频路径
  177.  */
  178. public void setVideoPath(String path) {
  179.     setVideoURI(Uri.parse(path));
  180. }
  182. /**
  183.  * 设置视频URI
  184.  */
  185. public void setVideoURI(Uri uri) {
  186.     setVideoURI(uri, null);
  187. }
  189. /**
  190.  * Sets video URI using specific headers.
  191.  *
  192.  * @param uri     the URI of the video.
  193.  * @param headers the headers for the URI request.
  194.  *                Note that the cross domain redirection is allowed by default, but that can be
  195.  *                changed with key/value pairs through the headers parameter with
  196.  *                "android-allow-cross-domain-redirect" as the key and "0" or "1" as the value
  197.  *                to disallow or allow cross domain redirection.
  198.  */
  199. private void setVideoURI(Uri uri, Map<String, String> headers) {
  200.     mUri = uri;
  201.     mHeaders = headers;
  202.     mSeekWhenPrepared = 0;
  203.     openVideo();
  204.     requestLayout();
  205.     invalidate();
  206. }
  208. /**
  209.  * 停止视频
  210.  */
  211. public void stopPlayback() {
  212.     if (mMediaPlayer != null) {
  213.         mMediaPlayer.stop();
  214.         mMediaPlayer.release();
  215.         mMediaPlayer = null;
  217.         mCurrentState = PlayStateParams.STATE_IDLE;
  218.         mTargetState = PlayStateParams.STATE_IDLE;
  220.         AudioManager am = (AudioManager) mAppContext.getSystemService(Context.AUDIO_SERVICE);
  221.         if (am != null) {
  222.             am.abandonAudioFocus(null);
  223.         }
  224.     }
  225. }
  227. /**
  228.  * 打开视频
  229.  */
  230. private void openVideo() {
  231.     if (mUri == null || mSurfaceHolder == null) {
  232.         return;
  233.     }
  235.     release(false);
  237.     AudioManager am = (AudioManager) mAppContext.getSystemService(Context.AUDIO_SERVICE);
  238.     if (am != null) {
  239.         am.requestAudioFocus(null, AudioManager.STREAM_MUSIC, AudioManager.AUDIOFOCUS_GAIN);
  240.     }
  242.     try {
  243.         if (usingAndroidPlayer) {
  244.             mMediaPlayer = new AndroidMediaPlayer();
  245.         } else {
  246.             IjkMediaPlayer ijkMediaPlayer = null;
  247.             if (mUri != null) {
  248.                 ijkMediaPlayer = new IjkMediaPlayer();
  249.                 IjkMediaPlayer.native_setLogLevel(IjkMediaPlayer.IJK_LOG_DEBUG);
  250.                 if (usingMediaCodec) {
  251.                     ijkMediaPlayer.setOption(IjkMediaPlayer.OPT_CATEGORY_PLAYER, "mediacodec", 1);
  252.                     if (usingMediaCodecAutoRotate) {
  253.                         ijkMediaPlayer.setOption(IjkMediaPlayer.OPT_CATEGORY_PLAYER, "mediacodec-auto-rotate", 1);
  254.                     } else {
  255.                         ijkMediaPlayer.setOption(IjkMediaPlayer.OPT_CATEGORY_PLAYER, "mediacodec-auto-rotate", 0);
  256.                     }
  257.                 } else {
  258.                     ijkMediaPlayer.setOption(IjkMediaPlayer.OPT_CATEGORY_PLAYER, "mediacodec", 0);
  259.                 }
  261.                 if (usingOpenSLES) {
  262.                     ijkMediaPlayer.setOption(IjkMediaPlayer.OPT_CATEGORY_PLAYER, "opensles", 1);
  263.                 } else {
  264.                     ijkMediaPlayer.setOption(IjkMediaPlayer.OPT_CATEGORY_PLAYER, "opensles", 0);
  265.                 }
  267.                 // Auto Select=,RGB 565=fcc-rv16,RGB 888X=fcc-rv32,YV12=fcc-yv12,默认为RGB 888X
  268.                 String pixelFormat = "";
  269.                 if (TextUtils.isEmpty(pixelFormat)) {
  270.                     ijkMediaPlayer.setOption(IjkMediaPlayer.OPT_CATEGORY_PLAYER, "overlay-format", IjkMediaPlayer.SDL_FCC_RV32);
  271.                 } else {
  272.                     ijkMediaPlayer.setOption(IjkMediaPlayer.OPT_CATEGORY_PLAYER, "overlay-format", pixelFormat);
  273.                 }
  274.                 ijkMediaPlayer.setOption(IjkMediaPlayer.OPT_CATEGORY_PLAYER, "framedrop", 1);
  275.                 ijkMediaPlayer.setOption(IjkMediaPlayer.OPT_CATEGORY_PLAYER, "start-on-prepared", 0);
  277.                 ijkMediaPlayer.setOption(IjkMediaPlayer.OPT_CATEGORY_FORMAT, "http-detect-range-support", 0);
  278.                 ijkMediaPlayer.setOption(IjkMediaPlayer.OPT_CATEGORY_FORMAT, "timeout", 10000000);
  279.                 ijkMediaPlayer.setOption(IjkMediaPlayer.OPT_CATEGORY_FORMAT, "reconnect", 1);
  281.                 ijkMediaPlayer.setOption(IjkMediaPlayer.OPT_CATEGORY_CODEC, "skip_loop_filter", 48);
  282.             }
  283.             mMediaPlayer = ijkMediaPlayer;
  284.         }
  286.         if (enableBackgroundPlay) {
  287.             mMediaPlayer = new TextureMediaPlayer(mMediaPlayer);
  288.         }
  290.         if (mMediaPlayer == null) {
  291.             return;
  292.         }
  294.         // 视频准备播放监听
  295.         mMediaPlayer.setOnPreparedListener(mPreparedListener);
  296.         // 视频播放完成监听
  297.         mMediaPlayer.setOnCompletionListener(mCompletionListener);
  298.         // 视频错误监听
  299.         mMediaPlayer.setOnErrorListener(mErrorListener);
  300.         // 视频其他信息监听
  301.         mMediaPlayer.setOnInfoListener(mInfoListener);
  302.         // 视频界面大小改变监听
  303.         mMediaPlayer.setOnVideoSizeChangedListener(mSizeChangedListener);
  304.         // 视频缓冲监听
  305.         mMediaPlayer.setOnBufferingUpdateListener(mBufferingUpdateListener);
  306.         mCurrentBufferPercentage = 0;
  307.         String scheme = mUri.getScheme();
  308.         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M
  309.                 && usingAndroidPlayer && (TextUtils.isEmpty(scheme) || scheme.equalsIgnoreCase("file"))) {
  310.             IMediaDataSource dataSource = new FileMediaDataSource(new File(mUri.toString()));
  311.             mMediaPlayer.setDataSource(dataSource);
  312.         } else if (Build.VERSION.SDK_INT > Build.VERSION_CODES.ICE_CREAM_SANDWICH) {
  313.             mMediaPlayer.setDataSource(mAppContext, mUri, mHeaders);
  314.         } else {
  315.             mMediaPlayer.setDataSource(mUri.toString());
  316.         }
  317.         bindSurfaceHolder(mMediaPlayer, mSurfaceHolder);
  318.         mMediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);
  319.         mMediaPlayer.setScreenOnWhilePlaying(true);
  320.         mMediaPlayer.prepareAsync();
  321.         // 这里不设置目标状态,但保护的目标状态
  322.         mCurrentState = PlayStateParams.STATE_PREPARING;
  323.         attachMediaController();
  324.     } catch (IOException | IllegalArgumentException ex) {
  325.         Log.w(TAG, "Unable to open content: " + mUri, ex);
  326.         mCurrentState = PlayStateParams.STATE_ERROR;
  327.         mTargetState = PlayStateParams.STATE_ERROR;
  328.         mErrorListener.onError(mMediaPlayer, MediaPlayer.MEDIA_ERROR_UNKNOWN, 0);
  329.     }
  330. }
  332. public void setMediaController(IMediaController controller) {
  333.     if (mMediaController != null) {
  334.         mMediaController.hide();
  335.     }
  336.     mMediaController = controller;
  337.     attachMediaController();
  338. }
  340. private void attachMediaController() {
  341.     if (mMediaPlayer != null && mMediaController != null) {
  342.         mMediaController.setMediaPlayer(this);
  343.         View anchorView = this.getParent() instanceof View ? (View) this.getParent() : this;
  344.         mMediaController.setAnchorView(anchorView);
  345.         mMediaController.setEnabled(isInPlaybackState());
  346.     }
  347. }
  349. IMediaPlayer.OnVideoSizeChangedListener mSizeChangedListener = new IMediaPlayer.OnVideoSizeChangedListener() {
  350.     public void onVideoSizeChanged(IMediaPlayer mp, int width, int height, int sarNum, int sarDen) {
  351.         mVideoWidth = mp.getVideoWidth();
  352.         mVideoHeight = mp.getVideoHeight();
  353.         mVideoSarNum = mp.getVideoSarNum();
  354.         mVideoSarDen = mp.getVideoSarDen();
  355.         if (mVideoWidth != 0 && mVideoHeight != 0) {
  356.             if (mRenderView != null) {
  357.                 mRenderView.setVideoSize(mVideoWidth, mVideoHeight);
  358.                 mRenderView.setVideoSampleAspectRatio(mVideoSarNum, mVideoSarDen);
  359.             }
  360.             requestLayout();
  361.         }
  362.     }
  363. };
  365. IMediaPlayer.OnPreparedListener mPreparedListener = new IMediaPlayer.OnPreparedListener() {
  366.     public void onPrepared(IMediaPlayer mp) {
  367.         // 这里不设置目标状态,但保护的目标状态
  368.         mCurrentState = PlayStateParams.STATE_PREPARED;
  370.         if (mOnPreparedListener != null) {
  371.             mOnPreparedListener.onPrepared(mMediaPlayer);
  372.         }
  373.         if (mMediaController != null) {
  374.             mMediaController.setEnabled(true);
  375.         }
  376.         if (mOnInfoListener != null) {
  377.             mOnInfoListener.onInfo(mMediaPlayer, mCurrentState, 0);
  378.         }
  380.         mVideoWidth = mp.getVideoWidth();
  381.         mVideoHeight = mp.getVideoHeight();
  383.         long seekToPosition = mSeekWhenPrepared;
  384.         if (seekToPosition != 0) {
  385.             seekTo((int) seekToPosition);
  386.         }
  388.         if (mVideoWidth != 0 && mVideoHeight != 0) {
  389.             if (mRenderView != null) {
  390.                 mRenderView.setVideoSize(mVideoWidth, mVideoHeight);
  391.                 mRenderView.setVideoSampleAspectRatio(mVideoSarNum, mVideoSarDen);
  392.                 if (!mRenderView.shouldWaitForResize() || mSurfaceWidth == mVideoWidth && mSurfaceHeight == mVideoHeight) {
  393.                     if (mTargetState == PlayStateParams.STATE_PLAYING) {
  394.                         start();
  395.                         if (mMediaController != null) {
  396.                             mMediaController.show();
  397.                         }
  398.                     } else if (!isPlaying() &&
  399.                             (seekToPosition != 0 || getCurrentPosition() > 0)) {
  400.                         if (mMediaController != null) {
  401.                             mMediaController.show(0);
  402.                         }
  403.                     }
  404.                 }
  405.             }
  406.         } else {
  407.             if (mTargetState == PlayStateParams.STATE_PLAYING) {
  408.                 start();
  409.             }
  410.         }
  411.     }
  412. };
  414. private IMediaPlayer.OnCompletionListener mCompletionListener = new IMediaPlayer.OnCompletionListener() {
  415.     public void onCompletion(IMediaPlayer mp) {
  416.         mCurrentState = PlayStateParams.STATE_COMPLETED;
  417.         mTargetState = PlayStateParams.STATE_COMPLETED;
  418.         if (mMediaController != null) {
  419.             mMediaController.hide();
  420.         }
  421.         if (mOnCompletionListener != null) {
  422.             mOnCompletionListener.onCompletion(mMediaPlayer);
  423.         }
  424.         if (mOnInfoListener != null) {
  425.             mOnInfoListener.onInfo(mMediaPlayer, PlayStateParams.STATE_COMPLETED, 0);
  426.         }
  427.     }
  428. };
  430. private IMediaPlayer.OnInfoListener mInfoListener = new IMediaPlayer.OnInfoListener() {
  431.     public boolean onInfo(IMediaPlayer mp, int arg1, int arg2) {
  432.         if (mOnInfoListener != null) {
  433.             mOnInfoListener.onInfo(mp, arg1, arg2);
  434.         }
  435.         switch (arg1) {
  436.             case IMediaPlayer.MEDIA_INFO_VIDEO_TRACK_LAGGING:
  437.                 Log.d(TAG, "MEDIA_INFO_VIDEO_TRACK_LAGGING:");
  438.                 break;
  439.             case IMediaPlayer.MEDIA_INFO_VIDEO_RENDERING_START:
  440.                 Log.d(TAG, "MEDIA_INFO_VIDEO_RENDERING_START:");
  441.                 break;
  442.             case IMediaPlayer.MEDIA_INFO_BUFFERING_START:
  443.                 Log.d(TAG, "MEDIA_INFO_BUFFERING_START:");
  444.                 break;
  445.             case IMediaPlayer.MEDIA_INFO_BUFFERING_END:
  446.                 Log.d(TAG, "MEDIA_INFO_BUFFERING_END:");
  447.                 break;
  448.             case IMediaPlayer.MEDIA_INFO_NETWORK_BANDWIDTH:
  449.                 Log.d(TAG, "MEDIA_INFO_NETWORK_BANDWIDTH: " + arg2);
  450.                 break;
  451.             case IMediaPlayer.MEDIA_INFO_BAD_INTERLEAVING:
  452.                 Log.d(TAG, "MEDIA_INFO_BAD_INTERLEAVING:");
  453.                 break;
  454.             case IMediaPlayer.MEDIA_INFO_NOT_SEEKABLE:
  455.                 Log.d(TAG, "MEDIA_INFO_NOT_SEEKABLE:");
  456.                 break;
  457.             case IMediaPlayer.MEDIA_INFO_METADATA_UPDATE:
  458.                 Log.d(TAG, "MEDIA_INFO_METADATA_UPDATE:");
  459.                 break;
  460.             case IMediaPlayer.MEDIA_INFO_UNSUPPORTED_SUBTITLE:
  461.                 Log.d(TAG, "MEDIA_INFO_UNSUPPORTED_SUBTITLE:");
  462.                 break;
  463.             case IMediaPlayer.MEDIA_INFO_SUBTITLE_TIMED_OUT:
  464.                 Log.d(TAG, "MEDIA_INFO_SUBTITLE_TIMED_OUT:");
  465.                 break;
  466.             case IMediaPlayer.MEDIA_INFO_VIDEO_ROTATION_CHANGED:
  467.                 mVideoRotationDegree = arg2;
  468.                 Log.d(TAG, "MEDIA_INFO_VIDEO_ROTATION_CHANGED: " + arg2);
  469.                 if (mRenderView != null)
  470.                     mRenderView.setVideoRotation(arg2);
  471.                 break;
  472.             case IMediaPlayer.MEDIA_INFO_AUDIO_RENDERING_START:
  473.                 Log.d(TAG, "MEDIA_INFO_AUDIO_RENDERING_START:");
  474.                 break;
  475.         }
  476.         return true;
  477.     }
  478. };
  480. private IMediaPlayer.OnErrorListener mErrorListener = new IMediaPlayer.OnErrorListener() {
  481.     public boolean onError(IMediaPlayer mp, int framework_err, int impl_err) {
  482.         Log.d(TAG, "Error: " + framework_err + "," + impl_err);
  483.         mCurrentState = PlayStateParams.STATE_ERROR;
  484.         mTargetState = PlayStateParams.STATE_ERROR;
  485.         if (mMediaController != null) {
  486.             mMediaController.hide();
  487.         }
  489.         if (mOnErrorListener != null) {
  490.             mOnErrorListener.onError(mMediaPlayer, framework_err, impl_err);
  491.         }
  492.         if (mOnInfoListener != null) {
  493.             if (mOnInfoListener.onInfo(mMediaPlayer, framework_err, 0)) {
  494.                 return true;
  495.             }
  496.         }
  498.         if (getWindowToken() != null) {
  499.             String message = "Unknown error";
  501.             if (framework_err == MediaPlayer.MEDIA_ERROR_NOT_VALID_FOR_PROGRESSIVE_PLAYBACK) {
  502.                 message = "Invalid progressive playback";
  503.             }
  505.             new AlertDialog.Builder(getContext())
  506.                     .setMessage(message)
  507.                     .setPositiveButton("error", new DialogInterface.OnClickListener() {
  508.                         public void onClick(DialogInterface dialog, int whichButton) {
  509.                             if (mOnCompletionListener != null) {
  510.                                 mOnCompletionListener.onCompletion(mMediaPlayer);
  511.                             }
  512.                         }
  513.                     })
  514.                     .setCancelable(false)
  515.                     .show();
  516.         }
  517.         return true;
  518.     }
  519. };
  521. private IMediaPlayer.OnBufferingUpdateListener mBufferingUpdateListener = new IMediaPlayer.OnBufferingUpdateListener() {
  522.     public void onBufferingUpdate(IMediaPlayer mp, int percent) {
  523.         mCurrentBufferPercentage = percent;
  524.     }
  525. };
  527. /**
  528.  * Register a callback to be invoked when the media file is loaded and ready to go.
  529.  */
  530. public void setOnPreparedListener(IMediaPlayer.OnPreparedListener listener) {
  531.     mOnPreparedListener = listener;
  532. }
  534. /**
  535.  * Register a callback to be invoked when the end of a media file has been reached during playback.
  536.  */
  537. public void setOnCompletionListener(IMediaPlayer.OnCompletionListener l) {
  538.     mOnCompletionListener = l;
  539. }
  541. /**
  542.  * Register a callback to be invoked when an error occurs during playback or setup. If no listener
  543.  * is specified, or if the listener returned false, VideoView will inform the user of any errors.
  544.  */
  545. public void setOnErrorListener(IMediaPlayer.OnErrorListener l) {
  546.     mOnErrorListener = l;
  547. }
  549. /**
  550.  * Register a callback to be invoked when an informational event occurs during playback or setup.
  551.  */
  552. public void setOnInfoListener(IMediaPlayer.OnInfoListener l) {
  553.     mOnInfoListener = l;
  554. }
  556. private void bindSurfaceHolder(IMediaPlayer mp, IRenderView.ISurfaceHolder holder) {
  557.     if (mp == null)
  558.         return;
  560.     if (holder == null) {
  561.         mp.setDisplay(null);
  562.         return;
  563.     }
  565.     holder.bindToMediaPlayer(mp);
  566. }
  568. IRenderView.IRenderCallback mSHCallback = new IRenderView.IRenderCallback() {
  569.     @Override
  570.     public void onSurfaceChanged(@NonNull IRenderView.ISurfaceHolder holder, int format, int w, int h) {
  571.         if (holder.getRenderView() != mRenderView) {
  572.             Log.e(TAG, "onSurfaceChanged: unmatched render callback\n");
  573.             return;
  574.         }
  576.         mSurfaceWidth = w;
  577.         mSurfaceHeight = h;
  578.         boolean isValidState = (mTargetState == PlayStateParams.STATE_PLAYING);
  579.         boolean hasValidSize = !mRenderView.shouldWaitForResize() || (mVideoWidth == w && mVideoHeight == h);
  580.         if (mMediaPlayer != null && isValidState && hasValidSize) {
  581.             if (mSeekWhenPrepared != 0) {
  582.                 seekTo((int) mSeekWhenPrepared);
  583.             }
  584.             start();
  585.         }
  586.     }
  588.     @Override
  589.     public void onSurfaceCreated(@NonNull IRenderView.ISurfaceHolder holder, int width, int height) {
  590.         if (holder.getRenderView() != mRenderView) {
  591.             Log.e(TAG, "onSurfaceCreated: unmatched render callback\n");
  592.             return;
  593.         }
  595.         mSurfaceHolder = holder;
  596.         if (mMediaPlayer != null)
  597.             bindSurfaceHolder(mMediaPlayer, holder);
  598.         else
  599.             openVideo();
  600.     }
  602.     @Override
  603.     public void onSurfaceDestroyed(@NonNull IRenderView.ISurfaceHolder holder) {
  604.         if (holder.getRenderView() != mRenderView) {
  605.             Log.e(TAG, "onSurfaceDestroyed: unmatched render callback\n");
  606.             return;
  607.         }
  608.         mSurfaceHolder = null;
  609.         releaseWithoutStop();
  610.     }
  611. };
  613. public void releaseWithoutStop() {
  614.     if (mMediaPlayer != null)
  615.         mMediaPlayer.setDisplay(null);
  616. }
  618. /**
  619.  * release the media player in any state
  620.  */
  621. public void release(boolean clearTargetState) {
  622.     if (mMediaPlayer != null) {
  623.         mMediaPlayer.reset();
  624.         mMediaPlayer.release();
  625.         mMediaPlayer = null;
  626.         mCurrentState = PlayStateParams.STATE_IDLE;
  628.         if (clearTargetState) {
  629.             mTargetState = PlayStateParams.STATE_IDLE;
  630.         }
  632.         AudioManager am = (AudioManager) mAppContext.getSystemService(Context.AUDIO_SERVICE);
  633.         if (am != null) {
  634.             am.abandonAudioFocus(null);
  635.         }
  636.     }
  637. }
  639. @Override
  640. public boolean onTouchEvent(MotionEvent ev) {
  641.     if (isInPlaybackState() && mMediaController != null) {
  642.         toggleMediaControlsVisibility();
  643.     }
  644.     return false;
  645. }
  647. @Override
  648. public boolean onTrackballEvent(MotionEvent ev) {
  649.     if (isInPlaybackState() && mMediaController != null) {
  650.         toggleMediaControlsVisibility();
  651.     }
  652.     return false;
  653. }
  655. @Override
  656. public boolean onKeyDown(int keyCode, KeyEvent event) {
  657.     boolean isKeyCodeSupported = keyCode != KeyEvent.KEYCODE_BACK
  658.             && keyCode != KeyEvent.KEYCODE_VOLUME_UP
  659.             && keyCode != KeyEvent.KEYCODE_VOLUME_DOWN
  660.             && keyCode != KeyEvent.KEYCODE_VOLUME_MUTE
  661.             && keyCode != KeyEvent.KEYCODE_MENU
  662.             && keyCode != KeyEvent.KEYCODE_CALL
  663.             && keyCode != KeyEvent.KEYCODE_ENDCALL;
  665.     if (isInPlaybackState() && isKeyCodeSupported && mMediaController != null) {
  666.         if (keyCode == KeyEvent.KEYCODE_HEADSETHOOK || keyCode == KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE) {
  667.             if (mMediaPlayer.isPlaying()) {
  668.                 pause();
  669.                 mMediaController.show();
  670.             } else {
  671.                 start();
  672.                 mMediaController.hide();
  673.             }
  674.             return true;
  675.         } else if (keyCode == KeyEvent.KEYCODE_MEDIA_PLAY) {
  676.             if (!mMediaPlayer.isPlaying()) {
  677.                 start();
  678.                 mMediaController.hide();
  679.             }
  680.             return true;
  681.         } else if (keyCode == KeyEvent.KEYCODE_MEDIA_STOP
  682.                 || keyCode == KeyEvent.KEYCODE_MEDIA_PAUSE) {
  683.             if (mMediaPlayer.isPlaying()) {
  684.                 pause();
  685.                 mMediaController.show();
  686.             }
  687.             return true;
  688.         } else {
  689.             toggleMediaControlsVisibility();
  690.         }
  691.     }
  692.     return super.onKeyDown(keyCode, event);
  693. }
  695. private void toggleMediaControlsVisibility() {
  696.     if (mMediaController.isShowing()) {
  697.         mMediaController.hide();
  698.     } else {
  699.         mMediaController.show();
  700.     }
  701. }
  703. @Override
  704. public void start() {
  705.     if (isInPlaybackState()) {
  706.         mMediaPlayer.start();
  707.         mCurrentState = PlayStateParams.STATE_PLAYING;
  708.     }
  709.     mTargetState = PlayStateParams.STATE_PLAYING;
  710. }
  712. @Override
  713. public void pause() {
  714.     if (isInPlaybackState()) {
  715.         if (mMediaPlayer.isPlaying()) {
  716.             mMediaPlayer.pause();
  717.             mCurrentState = PlayStateParams.STATE_PAUSED;
  718.         }
  719.     }
  720.     mTargetState = PlayStateParams.STATE_PAUSED;
  721. }
  723. public void onPause() {
  724.     release(false);
  725. }
  727. public void onResume() {
  728.     openVideo();
  729. }
  731. @Override
  732. public int getDuration() {
  733.     if (isInPlaybackState()) {
  734.         return (int) mMediaPlayer.getDuration();
  735.     }
  736.     return -1;
  737. }
  739. @Override
  740. public int getCurrentPosition() {
  741.     if (isInPlaybackState()) {
  742.         return (int) mMediaPlayer.getCurrentPosition();
  743.     }
  744.     return 0;
  745. }
  747. @Override
  748. public void seekTo(int msec) {
  749.     if (isInPlaybackState()) {
  750.         mMediaPlayer.seekTo(msec);
  751.         mSeekWhenPrepared = 0;
  752.     } else {
  753.         mSeekWhenPrepared = msec;
  754.     }
  755. }
  757. @Override
  758. public boolean isPlaying() {
  759.     return isInPlaybackState() && mMediaPlayer.isPlaying();
  760. }
  762. @Override
  763. public int getBufferPercentage() {
  764.     if (mMediaPlayer != null) {
  765.         return mCurrentBufferPercentage;
  766.     }
  767.     return 0;
  768. }
  770. private boolean isInPlaybackState() {
  771.     return (mMediaPlayer != null &&
  772.             mCurrentState != PlayStateParams.STATE_ERROR &&
  773.             mCurrentState != PlayStateParams.STATE_IDLE &&
  774.             mCurrentState != PlayStateParams.STATE_PREPARING);
  775. }
  777. @Override
  778. public boolean canPause() {
  779.     return true;
  780. }
  782. @Override
  783. public boolean canSeekBackward() {
  784.     return false;
  785. }
  787. @Override
  788. public boolean canSeekForward() {
  789.     return false;
  790. }
  792. @Override
  793. public int getAudioSessionId() {
  794.     return 0;
  795. }
  797. public void toggleAspectRatio() {
  798.     mCurrentAspectRatioIndex++;
  799.     mCurrentAspectRatioIndex %= s_allAspectRatio.length;
  800.     mCurrentAspectRatio = s_allAspectRatio[mCurrentAspectRatioIndex];
  801.     if (mRenderView != null) {
  802.         mRenderView.setAspectRatio(mCurrentAspectRatio);
  803.     }
  804. }
  806. /**
  807.  * 初始化渲染器
  808.  */
  809. private void initRenders() {
  810.     mAllRenders.clear();
  811.     mAllRenders.add(RENDER_SURFACE_VIEW); // 添加surface渲染
  812.     int mCurrentRenderIndex;
  813.     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH) {
  814.         mAllRenders.add(RENDER_TEXTURE_VIEW); // 添加texture渲染
  815.         mCurrentRenderIndex = 1;
  816.     } else {
  817.         mCurrentRenderIndex = 0;
  818.     }
  819.     int mCurrentRender = mAllRenders.get(mCurrentRenderIndex);
  820.     setRender(mCurrentRender);
  821. }
  823. /**
  824.  * 设置播放区域拉伸类型
  825.  */
  826. public void setAspectRatio(int aspectRatio) {
  827.     for (int i = 0; i < s_allAspectRatio.length; i++) {
  828.         if (s_allAspectRatio[i] == aspectRatio) {
  829.             mCurrentAspectRatioIndex = i;
  830.             if (mRenderView != null) {
  831.                 mRenderView.setAspectRatio(mCurrentAspectRatio);
  832.             }
  833.             break;
  834.         }
  835.     }
  836. }

2.播放器功能的实现类（代码中有功能的注释）

  1. // 通知使用的flags
  2.     private static final int MESSAGE_SHOW_PROGRESS = 1; // 同步进度
  3.     private static final int MESSAGE_SEEK_NEW_POSITION = 3; // 设置新位置
  4.     private static final int MESSAGE_HIDE_CENTER_BOX = 4; // 隐藏提示的box
  5.     private static final int MESSAGE_RESTART_PLAY = 5; // 重新播放
  7.     // 控件部分
  8.     private final Activity mActivity; // 依附的容器Activity
  9.     private final LayoutQuery mLayoutQuery; // 界面的中布局的查询器
  10.     private final CusIjkView mIjkView; // 原生IjkPlayer
  11.     private final View mTopBarView; // 播放器顶部控制bar
  12.     private final View mBottomBarView; // 播放器底部控制bar
  13.     private final ImageView mThumbnailImg; // 播放前的封面或缩略图
  14.     private final ImageView mBackImage; // 视频返回按钮
  15.     private final ImageView mBottomBarPlayerImage; // 视频bottomBar的播放按钮
  16.     private final ImageView mCenterPlayerImage; // 视频中间的播放按钮
  17.     private final ImageView mFullScreenImage; // 视频全屏按钮
  18.     private final TextView mPlayerSpeedTv; // 视频加载速度
  19.     private final SeekBar mProgressSeekBar; // 视频播放进度条
  21.     // 视频相关参数
  22.     private List<VideoIjkBean> mListVideos = new ArrayList<>(); // 码流列表
  23.     private int mCurrStatus = PlayStateParams.STATE_IDLE; // 当前状态
  24.     private int mCurrShowType = PlayStateParams.FIT_PARENT; // 视频显示比例,默认保持原视频的大小
  25.     private final AudioManager mAudioManager; // 音频管理器
  26.     private String mCurrVideoUrl; // 当前播放地址
  27.     private int mCurrPlayPosition; // 当前播放位置
  28.     private long mNewPosition = -1; // 滑动进度条得到的新位置，和当前播放位置是有区别的,mNewPosition =0也会调用设置的，故初始化值为-1
  29.     private int mCurrVolume; // 当前声音大小
  30.     private int mMaxVolume = 0; // 设备最大音量
  31.     private final int mScreenWidthPix; // 获取当前设备的宽度
  32.     private final int mPlayerViewInitHeight; // 记录播放器竖屏时的高度
  33.     private float mCurrBrightness; // 当前亮度大小
  34.     private int mBgState; // 记录进行后台时的播放状态0为播放，1为暂停
  35.     private int mAutoConnectTime = 5000; // 自动重连的时间
  36.     private boolean mIsPlayerSupport; // 第三方so是否支持，默认不支持，true为支持
  37.     private boolean mIsLive; // 是否是直播，默认为非直播，true为直播false为点播。mIsLive()方法判断直播的方式比较片面
  38.     private boolean mIsForbidTouch; // 禁止触摸，默认可以触摸，true为禁止false为可触摸
  39.     private boolean mIsForbidHideControlPanel; // 禁止收起控制面板，默认可以收起，true为禁止false为可触摸
  40.     private boolean mIsForbidDoubleUp; // 是否禁止双击，默认不禁止，true为禁止，false为不禁止
  41.     private boolean mIsDragging; // 是否在拖动进度条中，默认为停止拖动，true为在拖动中，false为停止拖动
  42.     private boolean mIsErrorStop = true; // 是否出错停止播放，默认是出错停止播放，true出错停止播放,false为用户点击停止播放
  43.     private boolean mIsOnlyFullScreen; // 是否只有全屏，默认非全屏，true为全屏，false为非全屏
  44.     private boolean mIsPortrait = true; // 是否是竖屏，默认为竖屏，true为竖屏，false为横屏
  45.     private boolean mIsAutoReConnect = true; // 是否自动重连，默认5秒重连，true为重连，false为不重连
  46.     private boolean mIsHideCenterPlayer; // 是否隐藏中间播放按钮，默认不隐藏，true为隐藏，false为不隐藏
  47.     private boolean mIsHideTopBar; // 是否隐藏topBar，true为隐藏，false为不隐藏
  48.     private boolean mIsHideBottomBar; // 是否隐藏bottomBar，true为隐藏，false为不隐藏
  49.     private boolean mIsShowControlPanel; // 是否显示控制面板，默认为隐藏，true为显示false为隐藏
  50.     private boolean mIsCharge; // 是否免费观看
  51.     private int mMaxPlaytime; // 设置最大播放时间
  52.     private boolean mIsHasSwitchStream; // 当前是否切换视频流，默认为否，true是切换视频流，false没有切换
  53.     private boolean mIsNetWorkTip; // 播放时是否有网络提示，true为显示网络提示，false不显示网络提示
  54.     private boolean mIsFirstPlayer = true; // 是否是第一次播放
  56.     // 视频和UI的回调监听
  57.     private Handler mHandler = new CusUiHandler();
  58.     private AutoPlayRunnable mAutoPlayRunnable = new AutoPlayRunnable(); // 控制面板收起或者显示的轮询监听
  59.     private OnPlayerBackListener mPlayerBack; // 视频的返回键监听
  60.     private IMediaPlayer.OnInfoListener mOnInfoListener; // 视频播放时信息回调
  61.     private OrientationEventListener mOrientationEventListener; // Activity界面方向监听
  62.     private OnControlVisibilityChangeListener mOnControlVisibilityChangeListener; // 控制面板显示或隐藏监听
  64.     // ========================================== 初始化 ========================================== //
  66.     public PlayerView(Activity activity, View rootView) {
  67.         this.mActivity = activity;
  69.         try {
  70.             IjkMediaPlayer.loadLibrariesOnce(null);
  71.             IjkMediaPlayer.native_profileBegin("libijkplayer.so");
  72.             mIsPlayerSupport = true;
  73.         } catch (Throwable e) {
  74.             e.printStackTrace();
  75.         }
  77.         try {
  78.             int e = Settings.System.getInt(mActivity.getContentResolver(), Settings.System.SCREEN_BRIGHTNESS);
  79.             float progress = 1.0F * (float) e / 255.0F;
  80.             WindowManager.LayoutParams layout = this.mActivity.getWindow().getAttributes();
  81.             layout.screenBrightness = progress;
  82.             mActivity.getWindow().setAttributes(layout);
  83.         } catch (Settings.SettingNotFoundException e) {
  84.             e.printStackTrace();
  85.         }
  87.         mAudioManager = (AudioManager) mActivity.getSystemService(Context.AUDIO_SERVICE);
  88.         if (mAudioManager != null) {
  89.             mMaxVolume = mAudioManager.getStreamMaxVolume(AudioManager.STREAM_MUSIC);
  90.         }
  92.         // 播放器整个界面
  93.         View rootBoxRL;
  94.         if (rootView == null) {
  95.             mLayoutQuery = new LayoutQuery(mActivity);
  96.             rootBoxRL = mActivity.findViewById(R.id.app_video_box);
  97.             mIjkView = mActivity.findViewById(R.id.video_view);
  99.             mTopBarView = mActivity.findViewById(R.id.app_video_top_box);
  100.             mBottomBarView = mActivity.findViewById(R.id.ll_bottom_bar);
  101.             mThumbnailImg = mActivity.findViewById(R.id.iv_trumb);
  102.             mBackImage = mActivity.findViewById(R.id.app_video_finish);
  103.             mBottomBarPlayerImage = mActivity.findViewById(R.id.app_video_play);
  104.             mCenterPlayerImage = mActivity.findViewById(R.id.play_icon);
  105.             mFullScreenImage = mActivity.findViewById(R.id.app_video_fullscreen);
  106.             mPlayerSpeedTv = mActivity.findViewById(R.id.app_video_speed);
  107.             mProgressSeekBar = mActivity.findViewById(R.id.app_video_seekBar);
  108.             mProgressSeekBar.setMax(1000);
  109.         } else {
  110.             mLayoutQuery = new LayoutQuery(mActivity, rootView);
  111.             rootBoxRL = rootView.findViewById(R.id.app_video_box);
  112.             mIjkView = rootView.findViewById(R.id.video_view);
  114.             mTopBarView = rootView.findViewById(R.id.app_video_top_box);
  115.             mBottomBarView = rootView.findViewById(R.id.ll_bottom_bar);
  116.             mThumbnailImg = rootView.findViewById(R.id.iv_trumb);
  117.             mBackImage = rootView.findViewById(R.id.app_video_finish);
  118.             mBottomBarPlayerImage = rootView.findViewById(R.id.app_video_play);
  119.             mCenterPlayerImage = rootView.findViewById(R.id.play_icon);
  120.             mFullScreenImage = rootView.findViewById(R.id.app_video_fullscreen);
  121.             mPlayerSpeedTv = rootView.findViewById(R.id.app_video_speed);
  122.             mProgressSeekBar = rootView.findViewById(R.id.app_video_seekBar);
  123.             mProgressSeekBar.setMax(1000);
  124.         }
  126.         mProgressSeekBar.setOnSeekBarChangeListener(new SeekBar.OnSeekBarChangeListener() {
  127.             @Override
  128.             public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) {
  129.                 if (fromUser) {
  130.                     long duration = getDuration();
  131.                     int position = (int) ((duration * progress * 1.0) / 1000);
  132.                     String time = generateTime(position);
  133.                     mLayoutQuery.id(R.id.app_video_currentTime).text(time);
  134.                     mLayoutQuery.id(R.id.app_video_currentTime_full).text(time);
  135.                     mLayoutQuery.id(R.id.app_video_currentTime_left).text(time);
  136.                 }
  137.             }
  139.             @Override
  140.             public void onStartTrackingTouch(SeekBar seekBar) {
  141.                 mIsDragging = true;
  142.                 mHandler.removeMessages(MESSAGE_SHOW_PROGRESS);
  143.             }
  145.             @Override
  146.             public void onStopTrackingTouch(SeekBar seekBar) {
  147.                 long duration = getDuration();
  148.                 mIjkView.seekTo((int) ((duration * seekBar.getProgress() * 1.0) / 1000));
  149.                 mHandler.removeMessages(MESSAGE_SHOW_PROGRESS);
  150.                 mIsDragging = false;
  151.                 mHandler.sendEmptyMessageDelayed(MESSAGE_SHOW_PROGRESS, 1000);
  152.             }
  153.         });
  155.         View.OnClickListener onClickListener = new View.OnClickListener() {
  156.             @Override
  157.             public void onClick(View v) {
  158.                 if (v.getId() == R.id.app_video_fullscreen) {
  159.                     toggleFullScreen();
  160.                 } else if (v.getId() == R.id.app_video_play || v.getId() == R.id.play_icon) {
  161.                     if (mIjkView.isPlaying()) {
  162.                         if (mIsLive) {
  163.                             mIjkView.stopPlayback();
  164.                         } else {
  165.                             pausePlay();
  166.                         }
  167.                     } else {
  168.                         startPlay();
  169.                         if (mIjkView.isPlaying()) {
  170.                             // TODO ijkPlayer内部的监听没有回调，只能手动修改状态
  171.                             mCurrStatus = PlayStateParams.STATE_PREPARING;
  172.                             hideStatusUI();
  173.                         }
  174.                     }
  175.                     updatePausePlay();
  176.                 } else if (v.getId() == R.id.app_video_finish) {
  177.                     backClick();
  178.                 } else if (v.getId() == R.id.app_video_netTie_icon) {
  179.                     // 使用移动网络提示继续播放
  180.                     mIsNetWorkTip = false;
  181.                     hideStatusUI();
  182.                     startPlay();
  183.                     updatePausePlay();
  184.                 } else if (v.getId() == R.id.app_video_replay_icon) {
  185.                     // 重新播放
  186.                     mCurrStatus = PlayStateParams.STATE_ERROR;
  187.                     hideStatusUI();
  188.                     startPlay();
  189.                     updatePausePlay();
  190.                 }
  191.             }
  192.         };
  194.         mBottomBarPlayerImage.setOnClickListener(onClickListener);
  195.         mCenterPlayerImage.setOnClickListener(onClickListener);
  196.         mFullScreenImage.setOnClickListener(onClickListener);
  197.         mBackImage.setOnClickListener(onClickListener);
  198.         mLayoutQuery.id(R.id.app_video_netTie_icon).clicked(onClickListener);
  199.         mLayoutQuery.id(R.id.app_video_replay_icon).clicked(onClickListener);
  201.         mIjkView.setOnInfoListener(new IMediaPlayer.OnInfoListener() {
  202.             @Override
  203.             public boolean onInfo(IMediaPlayer mp, int what, int extra) {
  204.                 if (what == PlayStateParams.MEDIA_INFO_NETWORK_BANDWIDTH || what == PlayStateParams.MEDIA_INFO_BUFFERING_BYTES_UPDATE) {
  205.                     if (mPlayerSpeedTv != null) {
  206.                         mPlayerSpeedTv.setText(getFormatSize(extra));
  207.                     }
  208.                 }
  209.                 statusChange(what);
  210.                 if (mOnInfoListener != null) {
  211.                     mOnInfoListener.onInfo(mp, what, extra);
  212.                 }
  213.                 if (mIsCharge && mMaxPlaytime < getCurrPlayPosition()) {
  214.                     mLayoutQuery.id(R.id.app_video_freeTie).visible();
  215.                     pausePlay();
  216.                 }
  217.                 return true;
  218.             }
  219.         });
  221.         final GestureDetector detector = new GestureDetector(mActivity, new PlayerGestureListener());
  222.         rootBoxRL.setClickable(true);
  223.         rootBoxRL.setOnTouchListener(new View.OnTouchListener() {
  224.             @SuppressLint("ClickableViewAccessibility")
  225.             @Override
  226.             public boolean onTouch(View view, MotionEvent motionEvent) {
  227.                 switch (motionEvent.getAction() & MotionEvent.ACTION_MASK) {
  228.                     case MotionEvent.ACTION_DOWN:
  229.                         if (mAutoPlayRunnable != null) {
  230.                             mAutoPlayRunnable.stop();
  231.                         }
  232.                         break;
  233.                 }
  234.                 if (detector.onTouchEvent(motionEvent)) {
  235.                     return true;
  236.                 }
  237.                 // 处理手势结束
  238.                 switch (motionEvent.getAction() & MotionEvent.ACTION_MASK) {
  239.                     case MotionEvent.ACTION_UP:
  240.                         endGesture();
  241.                         break;
  242.                     default:
  243.                         break;
  244.                 }
  245.                 return false;
  246.             }
  247.         });
  249.         mOrientationEventListener = new OrientationEventListener(mActivity) {
  250.             @Override
  251.             public void onOrientationChanged(int orientation) {
  252.                 if (orientation >= 0 && orientation <= 30 || orientation >= 330 || (orientation >= 150 && orientation <= 210)) {
  253.                     if (mIsPortrait) {
  254.                         mActivity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_SENSOR);
  255.                         mOrientationEventListener.disable();
  256.                     }
  257.                 } else if ((orientation >= 90 && orientation <= 120) || (orientation >= 240 && orientation <= 300)) {
  258.                     if (!mIsPortrait) {
  259.                         mActivity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_SENSOR);
  260.                         mOrientationEventListener.disable();
  261.                     }
  262.                 }
  263.             }
  264.         };
  266.         if (mIsOnlyFullScreen) {
  267.             mActivity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
  268.         }
  269.         mIsPortrait = (getScreenOrientation() == ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
  271.         mPlayerViewInitHeight = rootBoxRL.getLayoutParams().height;
  272.         mScreenWidthPix = mActivity.getResources().getDisplayMetrics().widthPixels;
  274.         hideAllUI();
  276.         if (!mIsPlayerSupport) {
  277.             showStatus(mActivity.getResources().getString(R.string.not_support));
  278.         } else {
  279.             mLayoutQuery.id(R.id.ll_bg).visible();
  280.         }
  281.     }
  283.     // ========================================= 生命周期 ========================================= //
  285.     public void onPause() {
  286.         mBgState = (mIjkView.isPlaying() ? 0 : 1);
  287.         getCurrPlayPosition();
  288.         mIjkView.onPause();
  289.     }
  291.     public void onResume() {
  292.         mIjkView.onResume();
  293.         if (mIsLive) {
  294.             mIjkView.seekTo(0);
  295.         } else {
  296.             mIjkView.seekTo(mCurrPlayPosition);
  297.         }
  298.         if (mBgState != 0) {
  299.             pausePlay();
  300.         }
  301.     }
  303.     public void onDestroy() {
  304.         mOrientationEventListener.disable();
  305.         mHandler.removeMessages(MESSAGE_RESTART_PLAY);
  306.         mHandler.removeMessages(MESSAGE_SEEK_NEW_POSITION);
  307.         mIjkView.stopPlayback();
  308.     }
  310.     public void onConfigurationChanged(final Configuration newConfig) {
  311.         mIsPortrait = newConfig.orientation == Configuration.ORIENTATION_PORTRAIT;
  312.         doOnConfigurationChanged(mIsPortrait);
  313.     }
  315.     public boolean onBackPressed() {
  316.         if (!mIsOnlyFullScreen && getScreenOrientation() == ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE) {
  317.             mActivity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
  318.             doOnNoAllScreen();
  319.             return true;
  320.         }
  321.         return false;
  322.     }
  324.     // ========================================= 对外接口 ========================================= //
  326.     /**
  327.      * 设置播放信息监听回调
  328.      */
  329.     public void setOnInfoListener(IMediaPlayer.OnInfoListener onInfoListener) {
  330.         this.mOnInfoListener = onInfoListener;
  331.     }
  333.     /**
  334.      * 设置播放器中的返回键监听
  335.      */
  336.     public void setPlayerBackListener(OnPlayerBackListener listener) {
  337.         this.mPlayerBack = listener;
  338.     }
  340.     /**
  341.      * 设置控制面板显示隐藏监听
  342.      */
  343.     public void setOnControlPanelVisibilityChangListenter(OnControlVisibilityChangeListener listener) {
  344.         this.mOnControlVisibilityChangeListener = listener;
  345.     }
  347.     /**
  348.      * 显示缩略图
  349.      */
  350.     public void showThumbnail(OnShowThumbnailListener onShowThumbnailListener) {
  351.         if (onShowThumbnailListener != null && mThumbnailImg != null) {
  352.             onShowThumbnailListener.onShowThumbnail(mThumbnailImg);
  353.         }
  354.     }
  356.     /**
  357.      * 设置播放地址
  358.      */
  359.     public void setPlaySource(String stream, String url) {
  360.         VideoIjkBean mVideoIjkBean = new VideoIjkBean();
  361.         mVideoIjkBean.setStream(stream);
  362.         mVideoIjkBean.setUrl(url);
  363.         setPlaySource(mVideoIjkBean);
  364.     }
  366.     /**
  367.      * 设置播放地址
  368.      */
  369.     public void setPlaySource(VideoIjkBean videoIjkBean) {
  370.         mListVideos.clear();
  371.         if (videoIjkBean != null) {
  372.             mListVideos.add(videoIjkBean);
  374.             if (mListVideos.size() > 0) {
  375.                 mCurrVideoUrl = mListVideos.get(0).getUrl();
  376.                 mListVideos.get(0).setSelect(true);
  377.                 isLive();
  378.                 if (mIjkView.isPlaying()) {
  379.                     getCurrPlayPosition();
  380.                     mIjkView.release(false);
  381.                 }
  382.                 mIsHasSwitchStream = true;
  383.             }
  384.         }
  385.     }
  387.     /**
  388.      * 开始播放
  389.      */
  390.     public void startPlay() {
  391.         if (mIsLive) {
  392.             mIjkView.setVideoPath(mCurrVideoUrl);
  393.             mIjkView.seekTo(0);
  394.         } else {
  395.             if (mIsHasSwitchStream || mCurrStatus == PlayStateParams.STATE_ERROR) {
  396.                 // TODO 换源之后声音可播，画面卡住，主要是渲染问题，目前只是提供了软解方式，后期提供设置方式
  397.                 mIjkView.setRender(CusIjkView.RENDER_TEXTURE_VIEW);
  398.                 mIjkView.setVideoPath(mCurrVideoUrl);
  399.                 mIjkView.seekTo(mCurrPlayPosition);
  400.                 mIsHasSwitchStream = false;
  401.             }
  402.         }
  403.         hideStatusUI();
  404.         if (mIsNetWorkTip && (NetworkUtils.getNetworkType(mActivity) == 4
  405.                 || NetworkUtils.getNetworkType(mActivity) == 5
  406.                 || NetworkUtils.getNetworkType(mActivity) == 6)) {
  407.             mLayoutQuery.id(R.id.app_video_netTie).visible();
  408.         } else {
  409.             if (mIsCharge && mMaxPlaytime < getCurrPlayPosition()) {
  410.                 mLayoutQuery.id(R.id.app_video_freeTie).visible();
  411.             } else {
  412.                 if (mIsPlayerSupport) {
  413.                     mIjkView.start();
  414.                     if (mIsFirstPlayer) {
  415.                         mLayoutQuery.id(R.id.app_video_loading).visible();
  416.                         mIsFirstPlayer = false;
  417.                     }
  418.                 } else {
  419.                     showStatus(mActivity.getResources().getString(R.string.not_support));
  420.                 }
  421.             }
  422.         }
  423.     }
  425.     /**
  426.      * 暂停播放
  427.      */
  428.     public void pausePlay() {
  429.         mCurrStatus = PlayStateParams.STATE_PAUSED;
  430.         getCurrPlayPosition();
  431.         mIjkView.pause();
  432.     }
  434.     /**
  435.      * 停止播放
  436.      */
  437.     public void stopPlay() {
  438.         mIjkView.stopPlayback();
  439.         mIsErrorStop = true;
  440.         if (mHandler != null) {
  441.             mHandler.removeMessages(MESSAGE_RESTART_PLAY);
  442.         }
  443.     }
  445.     public boolean isPlaying() {
  446.         return mIjkView.isPlaying();
  447.     }
  449.     public void backClick() {
  450.         if (!mIsOnlyFullScreen && !mIsPortrait) {
  451.             mActivity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
  452.             doOnNoAllScreen();
  453.         } else {
  454.             if (mPlayerBack != null) {
  455.                 mPlayerBack.onPlayerBack();
  456.             } else {
  457.                 mActivity.finish();
  458.             }
  459.         }
  460.     }
  462.     /**
  463.      * 设置播放位置
  464.      */
  465.     public void seekTo(int playtime) {
  466.         mIjkView.seekTo(playtime);
  467.     }
  469.     /**
  470.      * 获取当前播放位置
  471.      */
  472.     public int getCurrPlayPosition() {
  473.         if (!mIsLive) {
  474.             mCurrPlayPosition = mIjkView.getCurrentPosition();
  475.         } else {
  476.             mCurrPlayPosition = -1;
  477.         }
  478.         return mCurrPlayPosition;
  479.     }
  481.     /**
  482.      * 获取视频播放总时长
  483.      */
  484.     public long getDuration() {
  485.         return (long) mIjkView.getDuration();
  486.     }
  488.     /**
  489.      * 百分比显示切换
  490.      */
  491.     public void toggleAspectRatio() {
  492.         if (mIjkView != null) {
  493.             mIjkView.toggleAspectRatio();
  494.         }
  495.     }
  497.     /**
  498.      * 设置视频名称
  499.      */
  500.     public void setTitle(String title) {
  501.         mLayoutQuery.id(R.id.app_video_title).text(title);
  502.     }
  504.     /**
  505.      * 设置最大观看时长
  506.      *
  507.      * @param isCharge    true为收费 false为免费即不做限制
  508.      * @param maxPlaytime 最大能播放时长，单位秒
  509.      */
  510.     public void setChargeState(boolean isCharge, int maxPlaytime) {
  511.         this.mIsCharge = isCharge;
  512.         this.mMaxPlaytime = maxPlaytime * 1000;
  513.     }
  515.     /**
  516.      * 设置播放区域拉伸类型
  517.      */
  518.     public void setScaleType(int showType) {
  519.         mCurrShowType = showType;
  520.         mIjkView.setAspectRatio(mCurrShowType);
  521.     }
  523.     /**
  524.      * 旋转指定角度
  525.      */
  526.     public void setPlayerRotation(int rotation) {
  527.         if (mIjkView != null) {
  528.             mIjkView.setPlayerRotation(rotation);
  529.             mIjkView.setAspectRatio(mCurrShowType);
  530.         }
  531.     }
  533.     /**
  534.      * 设置自动重连的模式或者重连时间，isAuto true 出错重连，false出错不重连，connectTime重连的时间
  535.      */
  536.     public void setAutoReConnect(boolean isAuto, int connectTime) {
  537.         this.mIsAutoReConnect = isAuto;
  538.         this.mAutoConnectTime = connectTime;
  539.     }
  541.     /**
  542.      * 是否仅仅为全屏
  543.      */
  544.     public void setOnlyFullScreen(boolean isFull) {
  545.         this.mIsOnlyFullScreen = isFull;
  546.         tryFullScreen(mIsOnlyFullScreen);
  547.         if (mIsOnlyFullScreen) {
  548.             mActivity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
  549.         } else {
  550.             mActivity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_SENSOR);
  551.         }
  552.     }
  554.     /**
  555.      * 设置是否禁止双击
  556.      */
  557.     public void setForbidDoubleUp(boolean flag) {
  558.         this.mIsForbidDoubleUp = flag;
  559.     }
  561.     /**
  562.      * 设置是否禁止隐藏bar
  563.      */
  564.     public void setForbidHideControlPanel(boolean flag) {
  565.         this.mIsForbidHideControlPanel = flag;
  566.     }
  568.     /**
  569.      * 是否禁止触摸
  570.      */
  571.     public void forbidTouch(boolean forbidTouch) {
  572.         this.mIsForbidTouch = forbidTouch;
  573.     }
  575.     /**
  576.      * 隐藏返回键，true隐藏，false为显示
  577.      */
  578.     public void hideBack(boolean isHide) {
  579.         mBackImage.setVisibility(isHide ? View.GONE : View.VISIBLE);
  580.     }
  582.     /**
  583.      * 隐藏全屏按钮，true隐藏，false为显示
  584.      */
  585.     public void hideFullscreen(boolean isHide) {
  586.         mFullScreenImage.setVisibility(isHide ? View.GONE : View.VISIBLE);
  587.     }
  589.     /**
  590.      * 隐藏中间播放按钮,ture为隐藏，false为不做隐藏处理，但不是显示
  591.      */
  592.     public void hideCenterPlayer(boolean isHide) {
  593.         mIsHideCenterPlayer = isHide;
  594.         mCenterPlayerImage.setVisibility(mIsHideCenterPlayer ? View.GONE : View.VISIBLE);
  595.     }
  597.     /**
  598.      * 是否隐藏topbar，true为隐藏，false为不隐藏，但不一定是显示
  599.      */
  600.     public void hideHideTopBar(boolean isHide) {
  601.         mIsHideTopBar = isHide;
  602.         mTopBarView.setVisibility(mIsHideTopBar ? View.GONE : View.VISIBLE);
  603.     }
  605.     /**
  606.      * 是否隐藏bottonbar，true为隐藏，false为不隐藏，但不一定是显示
  607.      */
  608.     public void hideBottomBar(boolean isHide) {
  609.         mIsHideBottomBar = isHide;
  610.         mBottomBarView.setVisibility(mIsHideBottomBar ? View.GONE : View.VISIBLE);
  611.     }
  613.     /**
  614.      * 是否隐藏上下bar，true为隐藏，false为不隐藏，但不一定是显示
  615.      */
  616.     public void hideControlPanl(boolean isHide) {
  617.         hideBottomBar(isHide);
  618.         hideHideTopBar(isHide);
  619.     }
  621.     /**
  622.      * 显示菜单设置
  623.      */
  624.     public void showMenu() {
  625.         if (!mIsForbidHideControlPanel) {
  626.             mTopBarView.setVisibility(View.GONE);
  627.             mBottomBarView.setVisibility(View.GONE);
  628.         }
  629.     }
  631.     /**
  632.      * 设置显示加载网速或者隐藏
  633.      */
  634.     public void setShowSpeed(boolean isShow) {
  635.         mPlayerSpeedTv.setVisibility(isShow ? View.VISIBLE : View.GONE);
  636.     }
  638.     // ========================================= 内部实现 ========================================= //
  640.     /**
  641.      * 当前播放的是否是直播
  642.      */
  643.     private void isLive() {
  644.         mIsLive = mCurrVideoUrl != null
  645.                 && (mCurrVideoUrl.startsWith("rtmp://")
  646.                 || (mCurrVideoUrl.startsWith("http://") && mCurrVideoUrl.endsWith(".m3u8"))
  647.                 || (mCurrVideoUrl.startsWith("http://") && mCurrVideoUrl.endsWith(".flv")));
  648.     }
  650.     /**
  651.      * 隐藏所有界面
  652.      */
  653.     private void hideAllUI() {
  654.         if (!mIsForbidHideControlPanel) {
  655.             mTopBarView.setVisibility(View.GONE);
  656.             mBottomBarView.setVisibility(View.GONE);
  657.         }
  658.         hideStatusUI();
  659.     }
  661.     /**
  662.      * 显示或隐藏操作面板
  663.      */
  664.     private void operatorPanel() {
  665.         mIsShowControlPanel = !mIsShowControlPanel;
  666.         if (mIsShowControlPanel) {
  667.             mTopBarView.setVisibility(mIsHideTopBar ? View.GONE : View.VISIBLE);
  668.             mBottomBarView.setVisibility(mIsHideBottomBar ? View.GONE : View.VISIBLE);
  669.             if (mIsLive) {
  670.                 mLayoutQuery.id(R.id.app_video_process_panl).invisible();
  671.             } else {
  672.                 mLayoutQuery.id(R.id.app_video_process_panl).visible();
  673.             }
  674.             if (mIsOnlyFullScreen || mIsForbidDoubleUp) {
  675.                 mFullScreenImage.setVisibility(View.GONE);
  676.             } else {
  677.                 mFullScreenImage.setVisibility(View.VISIBLE);
  678.             }
  679.             if (mOnControlVisibilityChangeListener != null) {
  680.                 mOnControlVisibilityChangeListener.change(true);
  681.             }
  682.             // 显示面板的时候再根据状态显示播放按钮
  683.             if (mCurrStatus == PlayStateParams.STATE_PLAYING
  684.                     || mCurrStatus == PlayStateParams.STATE_PREPARED
  685.                     || mCurrStatus == PlayStateParams.STATE_PREPARING
  686.                     || mCurrStatus == PlayStateParams.STATE_PAUSED) {
  687.                 if (mIsHideCenterPlayer) {
  688.                     mCenterPlayerImage.setVisibility(View.GONE);
  689.                 } else {
  690.                     mCenterPlayerImage.setVisibility(mIsLive ? View.GONE : View.VISIBLE);
  691.                 }
  692.             } else {
  693.                 mCenterPlayerImage.setVisibility(View.GONE);
  694.             }
  695.             updatePausePlay();
  696.             mHandler.sendEmptyMessage(MESSAGE_SHOW_PROGRESS);
  697.             mAutoPlayRunnable.start();
  698.         } else {
  699.             if (mIsHideTopBar) {
  700.                 mTopBarView.setVisibility(View.GONE);
  701.             } else {
  702.                 mTopBarView.setVisibility(mIsForbidHideControlPanel ? View.VISIBLE : View.GONE);
  704.             }
  705.             if (mIsHideBottomBar) {
  706.                 mBottomBarView.setVisibility(View.GONE);
  707.             } else {
  708.                 mBottomBarView.setVisibility(mIsForbidHideControlPanel ? View.VISIBLE : View.GONE);
  710.             }
  711.             if (!mIsLive && mCurrStatus == PlayStateParams.STATE_PAUSED && !mIjkView.isPlaying()) {
  712.                 if (mIsHideCenterPlayer) {
  713.                     mCenterPlayerImage.setVisibility(View.GONE);
  714.                 } else {
  715.                     // 暂停时一直显示按钮
  716.                     mCenterPlayerImage.setVisibility(View.VISIBLE);
  717.                 }
  718.             } else {
  719.                 mCenterPlayerImage.setVisibility(View.GONE);
  720.             }
  721.             mHandler.removeMessages(MESSAGE_SHOW_PROGRESS);
  722.             if (mOnControlVisibilityChangeListener != null) {
  723.                 mOnControlVisibilityChangeListener.change(false);
  724.             }
  725.             mAutoPlayRunnable.stop();
  726.         }
  727.     }
  729.     /**
  730.      * 全屏切换
  731.      */
  732.     private void toggleFullScreen() {
  733.         if (getScreenOrientation() == ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE) {
  734.             mActivity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
  735.             doOnNoAllScreen();
  736.         } else {
  737.             mActivity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
  738.             doOnAllScreen();
  739.         }
  740.         updateFullScreenButton();
  741.     }
  743.     /**
  744.      * 进度条和时长显示的方向切换
  745.      */
  746.     private void toggleProcessDurationOrientation() {
  747.         setProcessDurationOrientation(PlayStateParams.PROCESS_PORTRAIT);
  748.     }
  750.     /**
  751.      * 设置进度条和时长显示的方向，默认为上下显示，true为上下显示false为左右显示
  752.      */
  753.     private void setProcessDurationOrientation(int portrait) {
  754.         if (portrait == PlayStateParams.PROCESS_CENTER) {
  755.             mLayoutQuery.id(R.id.app_video_currentTime_full).gone();
  756.             mLayoutQuery.id(R.id.app_video_endTime_full).gone();
  757.             mLayoutQuery.id(R.id.app_video_center).gone();
  758.             mLayoutQuery.id(R.id.app_video_lift).visible();
  759.         } else if (portrait == PlayStateParams.PROCESS_LANDSCAPE) {
  760.             mLayoutQuery.id(R.id.app_video_currentTime_full).visible();
  761.             mLayoutQuery.id(R.id.app_video_endTime_full).visible();
  762.             mLayoutQuery.id(R.id.app_video_center).gone();
  763.             mLayoutQuery.id(R.id.app_video_lift).gone();
  764.         } else {
  765.             mLayoutQuery.id(R.id.app_video_currentTime_full).gone();
  766.             mLayoutQuery.id(R.id.app_video_endTime_full).gone();
  767.             mLayoutQuery.id(R.id.app_video_center).visible();
  768.             mLayoutQuery.id(R.id.app_video_lift).gone();
  769.         }
  770.     }
  772.     /**
  773.      * 获取界面方向
  774.      */
  775.     private int getScreenOrientation() {
  776.         int rotation = mActivity.getWindowManager().getDefaultDisplay().getRotation();
  777.         DisplayMetrics dm = new DisplayMetrics();
  778.         mActivity.getWindowManager().getDefaultDisplay().getMetrics(dm);
  779.         int width = dm.widthPixels;
  780.         int height = dm.heightPixels;
  781.         int orientation;
  782.         if ((rotation == Surface.ROTATION_0 || rotation == Surface.ROTATION_180) && height > width ||
  783.                 (rotation == Surface.ROTATION_90 || rotation == Surface.ROTATION_270) && width > height) {
  784.             switch (rotation) {
  785.                 case Surface.ROTATION_0:
  786.                     orientation = ActivityInfo.SCREEN_ORIENTATION_PORTRAIT;
  787.                     break;
  788.                 case Surface.ROTATION_90:
  789.                     orientation = ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE;
  790.                     break;
  791.                 case Surface.ROTATION_180:
  792.                     orientation = ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT;
  793.                     break;
  794.                 case Surface.ROTATION_270:
  795.                     orientation = ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE;
  796.                     break;
  797.                 default:
  798.                     orientation = ActivityInfo.SCREEN_ORIENTATION_PORTRAIT;
  799.                     break;
  800.             }
  801.         } else {
  802.             switch (rotation) {
  803.                 case Surface.ROTATION_0:
  804.                     orientation = ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE;
  805.                     break;
  806.                 case Surface.ROTATION_90:
  807.                     orientation = ActivityInfo.SCREEN_ORIENTATION_PORTRAIT;
  808.                     break;
  809.                 case Surface.ROTATION_180:
  810.                     orientation = ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE;
  811.                     break;
  812.                 case Surface.ROTATION_270:
  813.                     orientation = ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT;
  814.                     break;
  815.                 default:
  816.                     orientation = ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE;
  817.                     break;
  818.             }
  819.         }
  820.         return orientation;
  821.     }
  823.     /**
  824.      * 状态改变同步UI
  825.      */
  826.     private void statusChange(int newStatus) {
  827.         if (newStatus == PlayStateParams.STATE_COMPLETED) {
  828.             mCurrStatus = PlayStateParams.STATE_COMPLETED;
  829.             mCurrPlayPosition = 0;
  830.             hideAllUI();
  831.             showStatus("播放结束");
  832.         } else if (newStatus == PlayStateParams.STATE_PREPARING || newStatus == PlayStateParams.MEDIA_INFO_BUFFERING_START) {
  833.             mCurrStatus = PlayStateParams.STATE_PREPARING;
  834.             hideStatusUI(); // 视频缓冲
  835.             mLayoutQuery.id(R.id.app_video_loading).visible();
  836.         } else if (newStatus == PlayStateParams.MEDIA_INFO_VIDEO_RENDERING_START
  837.                 || newStatus == PlayStateParams.STATE_PLAYING
  838.                 || newStatus == PlayStateParams.STATE_PREPARED
  839.                 || newStatus == PlayStateParams.MEDIA_INFO_BUFFERING_END
  840.                 || newStatus == PlayStateParams.STATE_PAUSED) {
  841.             if (mCurrStatus == PlayStateParams.STATE_PAUSED) {
  842.                 mCurrStatus = PlayStateParams.STATE_PAUSED;
  843.             } else {
  844.                 mCurrStatus = PlayStateParams.STATE_PLAYING;
  845.             }
  846.             // 视频缓冲结束后隐藏缩列图
  847.             mHandler.postDelayed(new Runnable() {
  848.                 @Override
  849.                 public void run() {
  850.                     hideStatusUI();
  851.                     // 显示控制bar
  852.                     mIsShowControlPanel = false;
  853.                     if (!mIsForbidTouch) {
  854.                         operatorPanel();
  855.                     }
  856.                     mLayoutQuery.id(R.id.ll_bg).gone(); // 延迟0.5秒隐藏视频封面隐藏
  857.                 }
  858.             }, 500);
  859.         } else if (newStatus == PlayStateParams.MEDIA_INFO_VIDEO_INTERRUPT) {
  860.             // 直播停止推流
  861.             mCurrStatus = PlayStateParams.STATE_ERROR;
  862.             if (!(mIsNetWorkTip && (NetworkUtils.getNetworkType(mActivity) == 4
  863.                     || NetworkUtils.getNetworkType(mActivity) == 5
  864.                     || NetworkUtils.getNetworkType(mActivity) == 6))) {
  865.                 if (mIsCharge && mMaxPlaytime < getCurrPlayPosition()) {
  866.                     mLayoutQuery.id(R.id.app_video_freeTie).visible();
  867.                 } else {
  868.                     hideAllUI();
  869.                     if (mIsLive) {
  870.                         showStatus("获取不到直播源");
  871.                     } else {
  872.                         showStatus(mActivity.getResources().getString(R.string.small_problem));
  873.                     }
  874.                     // 5秒尝试重连
  875.                     if (!mIsErrorStop && mIsAutoReConnect) {
  876.                         mHandler.sendEmptyMessageDelayed(MESSAGE_RESTART_PLAY, mAutoConnectTime);
  877.                     }
  879.                 }
  880.             } else {
  881.                 mLayoutQuery.id(R.id.app_video_netTie).visible();
  882.             }
  883.         } else if (newStatus == PlayStateParams.STATE_ERROR
  884.                 || newStatus == PlayStateParams.MEDIA_INFO_UNKNOWN
  885.                 || newStatus == PlayStateParams.MEDIA_ERROR_IO
  886.                 || newStatus == PlayStateParams.MEDIA_ERROR_MALFORMED
  887.                 || newStatus == PlayStateParams.MEDIA_ERROR_UNSUPPORTED
  888.                 || newStatus == PlayStateParams.MEDIA_ERROR_TIMED_OUT
  889.                 || newStatus == PlayStateParams.MEDIA_ERROR_SERVER_DIED) {
  890.             mCurrStatus = PlayStateParams.STATE_ERROR;
  891.             if (!(mIsNetWorkTip && (NetworkUtils.getNetworkType(mActivity) == 4
  892.                     || NetworkUtils.getNetworkType(mActivity) == 5
  893.                     || NetworkUtils.getNetworkType(mActivity) == 6))) {
  894.                 if (mIsCharge && mMaxPlaytime < getCurrPlayPosition()) {
  895.                     mLayoutQuery.id(R.id.app_video_freeTie).visible();
  896.                 } else {
  897.                     hideStatusUI();
  898.                     showStatus(mActivity.getResources().getString(R.string.small_problem));
  899.                     // 秒尝试重连
  900.                     if (!mIsErrorStop && mIsAutoReConnect) {
  901.                         mHandler.sendEmptyMessageDelayed(MESSAGE_RESTART_PLAY, mAutoConnectTime);
  902.                     }
  903.                 }
  904.             } else {
  905.                 mLayoutQuery.id(R.id.app_video_netTie).visible();
  906.             }
  907.         }
  908.     }
  910.     /**
  911.      * 显示视频播放状态提示
  912.      */
  913.     private void showStatus(String statusText) {
  914.         mLayoutQuery.id(R.id.app_video_replay).visible();
  915.         mLayoutQuery.id(R.id.app_video_status_text).text(statusText);
  916.     }
  918.     /**
  919.      * 界面方向改变时刷新界面
  920.      */
  921.     private void doOnConfigurationChanged(final boolean portrait) {
  922.         if (mIjkView != null && !mIsOnlyFullScreen) {
  923.             mHandler.post(new Runnable() {
  924.                 @Override
  925.                 public void run() {
  926.                     tryFullScreen(!portrait);
  927.                     if (portrait) {
  928.                         mLayoutQuery.id(R.id.app_video_box).height(mPlayerViewInitHeight, false);
  929.                     } else {
  930.                         int heightPixels = mActivity.getResources().getDisplayMetrics().heightPixels;
  931.                         int widthPixels = mActivity.getResources().getDisplayMetrics().widthPixels;
  932.                         mLayoutQuery.id(R.id.app_video_box).height(Math.min(heightPixels, widthPixels), false);
  933.                     }
  934.                     updateFullScreenButton();
  935.                 }
  936.             });
  937.             mOrientationEventListener.enable();
  938.         }
  939.     }
  941.     private void doOnAllScreen() {
  942.         setFullScreen(true);
  943.         if (mIjkView != null && !mIsOnlyFullScreen) {
  944.             mHandler.post(new Runnable() {
  945.                 @Override
  946.                 public void run() {
  947.                     mIsPortrait = false;
  948.                     int heightPixels = mActivity.getResources().getDisplayMetrics().heightPixels;
  949.                     int widthPixels = mActivity.getResources().getDisplayMetrics().widthPixels;
  950.                     mLayoutQuery.id(R.id.app_video_box).height(Math.min(heightPixels, widthPixels), false);
  951.                 }
  952.             });
  953.         }
  954.     }
  956.     private void doOnNoAllScreen() {
  957.         setFullScreen(false);
  958.         if (mIjkView != null && !mIsOnlyFullScreen) {
  959.             mHandler.post(new Runnable() {
  960.                 @Override
  961.                 public void run() {
  962.                     mIsPortrait = true;
  963.                     mLayoutQuery.id(R.id.app_video_box).height(mPlayerViewInitHeight, false);
  964.                 }
  965.             });
  966.         }
  967.     }
  969.     /**
  970.      * 设置界面方向
  971.      */
  972.     private void setFullScreen(boolean fullScreen) {
  973.         if (mActivity != null) {
  974.             WindowManager.LayoutParams attrs = mActivity.getWindow().getAttributes();
  975.             if (fullScreen) {
  976.                 attrs.flags |= WindowManager.LayoutParams.FLAG_FULLSCREEN;
  977.                 mActivity.getWindow().setAttributes(attrs);
  978.                 mActivity.getWindow().addFlags(WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS);
  979.             } else {
  980.                 attrs.flags &= (~WindowManager.LayoutParams.FLAG_FULLSCREEN);
  981.                 mActivity.getWindow().setAttributes(attrs);
  982.                 mActivity.getWindow().clearFlags(WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS);
  983.             }
  984.             toggleProcessDurationOrientation();
  985.         }
  986.     }
  988.     /**
  989.      * 设置界面方向带隐藏actionbar
  990.      */
  991.     private void tryFullScreen(boolean fullScreen) {
  992.         if (mActivity instanceof AppCompatActivity) {
  993.             ActionBar supportActionBar = ((AppCompatActivity) mActivity).getSupportActionBar();
  994.             if (supportActionBar != null) {
  995.                 if (fullScreen) {
  996.                     supportActionBar.hide();
  997.                 } else {
  998.                     supportActionBar.show();
  999.                 }
  1000.             }
  1001.         }
  1002.         setFullScreen(fullScreen);
  1003.     }
  1005.     /**
  1006.      * 隐藏状态界面
  1007.      */
  1008.     private void hideStatusUI() {
  1009.         mCenterPlayerImage.setVisibility(View.GONE);
  1010.         mLayoutQuery.id(R.id.app_video_replay).gone();
  1011.         mLayoutQuery.id(R.id.app_video_netTie).gone();
  1012.         mLayoutQuery.id(R.id.app_video_freeTie).gone();
  1013.         mLayoutQuery.id(R.id.app_video_loading).gone();
  1014.         if (mOnControlVisibilityChangeListener != null) {
  1015.             mOnControlVisibilityChangeListener.change(false);
  1016.         }
  1017.     }
  1019.     /**
  1020.      * 手势结束
  1021.      */
  1022.     private void endGesture() {
  1023.         mCurrVolume = -1;
  1024.         mCurrBrightness = -1f;
  1025.         if (mNewPosition >= 0) {
  1026.             mHandler.removeMessages(MESSAGE_SEEK_NEW_POSITION);
  1027.             mHandler.sendEmptyMessage(MESSAGE_SEEK_NEW_POSITION);
  1028.         }
  1029.         mHandler.removeMessages(MESSAGE_HIDE_CENTER_BOX);
  1030.         mHandler.sendEmptyMessageDelayed(MESSAGE_HIDE_CENTER_BOX, 500);
  1031.         if (mAutoPlayRunnable != null) {
  1032.             mAutoPlayRunnable.start();
  1033.         }
  1034.     }
  1036.     /**
  1037.      * 同步进度
  1038.      */
  1039.     private long syncProgress() {
  1040.         if (mIsDragging) {
  1041.             return 0;
  1042.         }
  1043.         long position = mIjkView.getCurrentPosition();
  1044.         long duration = mIjkView.getDuration();
  1045.         if (mProgressSeekBar != null) {
  1046.             if (duration > 0) {
  1047.                 long pos = 1000L * position / duration;
  1048.                 mProgressSeekBar.setProgress((int) pos);
  1049.             }
  1050.             int percent = mIjkView.getBufferPercentage();
  1051.             mProgressSeekBar.setSecondaryProgress(percent * 10);
  1052.         }
  1054.         if (mIsCharge && mMaxPlaytime + 1000 < getCurrPlayPosition()) {
  1055.             mLayoutQuery.id(R.id.app_video_freeTie).visible();
  1056.             pausePlay();
  1057.         } else {
  1058.             mLayoutQuery.id(R.id.app_video_currentTime).text(generateTime(position));
  1059.             mLayoutQuery.id(R.id.app_video_currentTime_full).text(generateTime(position));
  1060.             mLayoutQuery.id(R.id.app_video_currentTime_left).text(generateTime(position));
  1061.             mLayoutQuery.id(R.id.app_video_endTime).text(generateTime(duration));
  1062.             mLayoutQuery.id(R.id.app_video_endTime_full).text(generateTime(duration));
  1063.             mLayoutQuery.id(R.id.app_video_endTime_left).text(generateTime(duration));
  1064.         }
  1065.         return position;
  1066.     }
  1068.     /**
  1069.      * 更新播放、暂停和停止按钮
  1070.      */
  1071.     private void updatePausePlay() {
  1072.         if (mIjkView.isPlaying()) {
  1073.             if (mIsLive) {
  1074.                 mBottomBarPlayerImage.setImageResource(R.drawable.simple_player_stop_white_24dp);
  1075.             } else {
  1076.                 mBottomBarPlayerImage.setImageResource(R.drawable.simple_player_icon_media_pause);
  1077.                 mCenterPlayerImage.setImageResource(R.drawable.simple_player_center_pause);
  1078.             }
  1079.         } else {
  1080.             mBottomBarPlayerImage.setImageResource(R.drawable.simple_player_arrow_white_24dp);
  1081.             mCenterPlayerImage.setImageResource(R.drawable.simple_player_center_play);
  1082.         }
  1083.     }
  1085.     /**
  1086.      * 更新全屏和半屏按钮
  1087.      */
  1088.     private void updateFullScreenButton() {
  1089.         if (getScreenOrientation() == ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE) {
  1090.             mFullScreenImage.setImageResource(R.drawable.simple_player_icon_fullscreen_shrink);
  1091.         } else {
  1092.             mFullScreenImage.setImageResource(R.drawable.simple_player_icon_fullscreen_stretch);
  1093.         }
  1094.     }
  1096.     /**
  1097.      * 滑动改变声音大小
  1098.      */
  1099.     private void onVolumeSlide(float percent) {
  1100.         if (mCurrVolume == -1) {
  1101.             mCurrVolume = mAudioManager.getStreamVolume(AudioManager.STREAM_MUSIC);
  1102.             if (mCurrVolume < 0) {
  1103.                 mCurrVolume = 0;
  1104.             }
  1105.         }
  1106.         int index = (int) (percent * mMaxVolume) + mCurrVolume;
  1107.         if (index > mMaxVolume) {
  1108.             index = mMaxVolume;
  1109.         } else if (index < 0) {
  1110.             index = 0;
  1111.         }
  1112.         // 变更声音
  1113.         mAudioManager.setStreamVolume(AudioManager.STREAM_MUSIC, index, 0);
  1114.         // 变更进度条
  1115.         int i = (int) (index * 1.0 / mMaxVolume * 100);
  1116.         String s = i + "%";
  1117.         if (i == 0) {
  1118.             s = "off";
  1119.         }
  1120.         // 显示
  1121.         mLayoutQuery.id(R.id.app_video_volume_icon).image(i == 0
  1122.                 ? R.drawable.simple_player_volume_off_white_36dp : R.drawable.simple_player_volume_up_white_36dp);
  1123.         mLayoutQuery.id(R.id.app_video_brightness_box).gone();
  1124.         mLayoutQuery.id(R.id.app_video_volume_box).visible();
  1125.         mLayoutQuery.id(R.id.app_video_volume_box).visible();
  1126.         mLayoutQuery.id(R.id.app_video_volume).text(s).visible();
  1127.     }
  1129.     /**
  1130.      * 快进或者快退滑动改变进度
  1131.      */
  1132.     private void onProgressSlide(float percent) {
  1133.         int position = mIjkView.getCurrentPosition();
  1134.         long duration = mIjkView.getDuration();
  1135.         long deltaMax = Math.min(100 * 1000, duration - position);
  1136.         long delta = (long) (deltaMax * percent);
  1137.         mNewPosition = delta + position;
  1138.         if (mNewPosition > duration) {
  1139.             mNewPosition = duration;
  1140.         } else if (mNewPosition <= 0) {
  1141.             mNewPosition = 0;
  1142.             delta = -position;
  1143.         }
  1144.         int showDelta = (int) delta / 1000;
  1145.         if (showDelta != 0) {
  1146.             mLayoutQuery.id(R.id.app_video_fastForward_box).visible();
  1147.             String text = showDelta > 0 ? ("+" + showDelta) : "" + showDelta;
  1148.             mLayoutQuery.id(R.id.app_video_fastForward).text(text + "s");
  1149.             mLayoutQuery.id(R.id.app_video_fastForward_target).text(generateTime(mNewPosition) + "/");
  1150.             mLayoutQuery.id(R.id.app_video_fastForward_all).text(generateTime(duration));
  1151.         }
  1152.     }
  1154.     /**
  1155.      * 亮度滑动改变亮度
  1156.      */
  1157.     private void onBrightnessSlide(float percent) {
  1158.         if (mCurrBrightness < 0) {
  1159.             mCurrBrightness = mActivity.getWindow().getAttributes().screenBrightness;
  1160.             if (mCurrBrightness <= 0.00f) {
  1161.                 mCurrBrightness = 0.50f;
  1162.             } else if (mCurrBrightness < 0.01f) {
  1163.                 mCurrBrightness = 0.01f;
  1164.             }
  1165.         }
  1166.         Log.d(this.getClass().getSimpleName(), "mCurrBrightness:" + mCurrBrightness + ",percent:" + percent);
  1167.         mLayoutQuery.id(R.id.app_video_brightness_box).visible();
  1168.         WindowManager.LayoutParams lpa = mActivity.getWindow().getAttributes();
  1169.         lpa.screenBrightness = mCurrBrightness + percent;
  1170.         if (lpa.screenBrightness > 1.0f) {
  1171.             lpa.screenBrightness = 1.0f;
  1172.         } else if (lpa.screenBrightness < 0.01f) {
  1173.             lpa.screenBrightness = 0.01f;
  1174.         }
  1175.         mLayoutQuery.id(R.id.app_video_brightness).text(((int) (lpa.screenBrightness * 100)) + "%");
  1176.         mActivity.getWindow().setAttributes(lpa);
  1177.     }
  1179.     /**
  1180.      * 时长格式化显示
  1181.      */
  1182.     @SuppressLint("DefaultLocale")
  1183.     private String generateTime(long time) {
  1184.         int totalSeconds = (int) (time / 1000);
  1185.         int seconds = totalSeconds % 60;
  1186.         int minutes = (totalSeconds / 60) % 60;
  1187.         int hours = totalSeconds / 3600;
  1188.         return hours > 0 ? String.format("%02d:%02d:%02d", hours, minutes, seconds) : String.format("%02d:%02d", minutes, seconds);
  1189.     }
  1191.     /**
  1192.      * 下载速度格式化显示
  1193.      */
  1194.     private String getFormatSize(int size) {
  1195.         long fileSize = (long) size;
  1196.         String showSize = "";
  1197.         if (fileSize >= 0 && fileSize < 1024) {
  1198.             showSize = fileSize + "Kb/s";
  1199.         } else if (fileSize >= 1024 && fileSize < (1024 * 1024)) {
  1200.             showSize = Long.toString(fileSize / 1024) + "KB/s";
  1201.         } else if (fileSize >= (1024 * 1024) && fileSize < (1024 * 1024 * 1024)) {
  1202.             showSize = Long.toString(fileSize / (1024 * 1024)) + "MB/s";
  1203.         }
  1204.         return showSize;
  1205.     }
  1207.     // ========================================== 内部类 ========================================== //
  1209.     @SuppressLint("HandlerLeak")
  1210.     private class CusUiHandler extends Handler {
  1211.         @Override
  1212.         public void handleMessage(Message msg) {
  1213.             switch (msg.what) {
  1214.                 // 滑动完成，隐藏滑动提示的box
  1215.                 case MESSAGE_HIDE_CENTER_BOX:
  1216.                     mLayoutQuery.id(R.id.app_video_volume_box).gone();
  1217.                     mLayoutQuery.id(R.id.app_video_brightness_box).gone();
  1218.                     mLayoutQuery.id(R.id.app_video_fastForward_box).gone();
  1219.                     break;
  1221.                 // 滑动完成，设置播放进度
  1222.                 case MESSAGE_SEEK_NEW_POSITION:
  1223.                     if (!mIsLive && mNewPosition >= 0) {
  1224.                         mIjkView.seekTo((int) mNewPosition);
  1225.                         mNewPosition = -1;
  1226.                     }
  1227.                     break;
  1229.                 // 滑动中，同步播放进度
  1230.                 case MESSAGE_SHOW_PROGRESS:
  1231.                     long pos = syncProgress();
  1232.                     if (!mIsDragging && mIsShowControlPanel) {
  1233.                         msg = obtainMessage(MESSAGE_SHOW_PROGRESS);
  1234.                         sendMessageDelayed(msg, 1000 - (pos % 1000));
  1235.                         updatePausePlay();
  1236.                     }
  1237.                     break;
  1239.                 // 重新去播放
  1240.                 case MESSAGE_RESTART_PLAY:
  1241.                     mCurrStatus = PlayStateParams.STATE_ERROR;
  1242.                     startPlay();
  1243.                     updatePausePlay();
  1244.                     break;
  1245.             }
  1246.         }
  1247.     }
  1249.     /**
  1250.      * 收起控制面板轮询，默认5秒无操作，收起控制面板
  1251.      */
  1252.     private class AutoPlayRunnable implements Runnable {
  1253.         private int AUTO_PLAY_INTERVAL = 5000;
  1254.         private boolean mShouldAutoPlay;
  1256.         AutoPlayRunnable() {
  1257.             mShouldAutoPlay = false;
  1258.         }
  1260.         void start() {
  1261.             if (!mShouldAutoPlay) {
  1262.                 mShouldAutoPlay = true;
  1263.                 mHandler.removeCallbacks(this);
  1264.                 mHandler.postDelayed(this, AUTO_PLAY_INTERVAL);
  1265.             }
  1266.         }
  1268.         void stop() {
  1269.             if (mShouldAutoPlay) {
  1270.                 mHandler.removeCallbacks(this);
  1271.                 mShouldAutoPlay = false;
  1272.             }
  1273.         }
  1275.         @Override
  1276.         public void run() {
  1277.             if (mShouldAutoPlay) {
  1278.                 mHandler.removeCallbacks(this);
  1279.                 if (!mIsForbidTouch) {
  1280.                     operatorPanel();
  1281.                 }
  1282.             }
  1283.         }
  1284.     }
  1286.     /**
  1287.      * 播放器的手势监听
  1288.      */
  1289.     public class PlayerGestureListener extends GestureDetector.SimpleOnGestureListener {
  1290.         private boolean isDownTouch; // 是否是按下的标识，默认为其他动作，true为按下标识，false为其他动作
  1291.         private boolean isVolume; // 是否声音控制,默认为亮度控制，true为声音控制，false为亮度控制
  1292.         private boolean isLandscape; // 是否横向滑动，默认为纵向滑动，true为横向滑动，false为纵向滑动
  1294.         /**
  1295.          * 双击，视频视窗双击事件
  1296.          */
  1297.         @Override
  1298.         public boolean onDoubleTap(MotionEvent e) {
  1299. //            if (!mIsForbidTouch && !mIsOnlyFullScreen && !mIsForbidDoubleUp) {
  1300. //                toggleFullScreen();
  1301. //            }
  1302.             return true;
  1303.         }
  1305.         /**
  1306.          * 按下
  1307.          */
  1308.         @Override
  1309.         public boolean onDown(MotionEvent e) {
  1310.             isDownTouch = true;
  1311.             return super.onDown(e);
  1312.         }
  1314.         /**
  1315.          * 滑动
  1316.          */
  1317.         @Override
  1318.         public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) {
  1319.             if (!mIsForbidTouch) {
  1320.                 float mOldX = e1.getX(), mOldY = e1.getY();
  1321.                 float deltaY = mOldY - e2.getY();
  1322.                 float deltaX = mOldX - e2.getX();
  1323.                 if (isDownTouch) {
  1324.                     isLandscape = Math.abs(distanceX) >= Math.abs(distanceY);
  1325.                     isVolume = mOldX > mScreenWidthPix * 0.5f;
  1326.                     isDownTouch = false;
  1327.                 }
  1329.                 if (isLandscape) {
  1330.                     if (!mIsLive) {
  1331.                         // 进度设置
  1332.                         onProgressSlide(-deltaX / mIjkView.getWidth());
  1333.                     }
  1334.                 } else {
  1335.                     float percent = deltaY / mIjkView.getHeight();
  1336.                     if (isVolume) {
  1337.                         // 声音设置
  1338.                         onVolumeSlide(percent);
  1339.                     } else {
  1340.                         // 亮度设置
  1341.                         onBrightnessSlide(percent);
  1342.                     }
  1343.                 }
  1344.             }
  1345.             return super.onScroll(e1, e2, distanceX, distanceY);
  1346.         }
  1348.         /**
  1349.          * 单击，视频视窗单击事件
  1350.          */
  1351.         @Override
  1352.         public boolean onSingleTapUp(MotionEvent e) {
  1353.             if (!mIsForbidTouch) {
  1354.                 operatorPanel();
  1355.             }
  1356.             return true;
  1357.         }
  1358.     }

3.具体的使用：

在你实现播放器的activity使用：

1）首先初始化播放器：

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3drX2JlaWNhaQ_size_16_color_FFFFFF_t_70 4

2）对视频进行网络判断

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3drX2JlaWNhaQ_size_16_color_FFFFFF_t_70 5

3）吊起播放：

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3drX2JlaWNhaQ_size_16_color_FFFFFF_t_70 6

项目地址：

https://download.csdn.net/download/wk_beicai/11177930

发表评论

表情：
评论列表 （有 0 条评论，808人围观）

还没有评论，来说两句吧...

相关阅读