自己定义一个播放器

原创 已于 2023-08-24 11:04:11 修改 · 446 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#android

于 2023-08-24 11:03:20 首次发布
博客提及参考智能课件里的PPTVideoView模块，还指出具体使用该播放器可参考PPTVideoView。

参考智能课件里的PPTVideoView模块：

package com.zhl.courseware.filtervideo;

import android.content.Context;
import android.media.MediaMetadataRetriever;
import android.media.MediaPlayer;
import android.net.Uri;
import android.os.Build;

import com.zhl.android.exoplayer2.ExoPlayerFactory;
import com.zhl.android.exoplayer2.Player;
import com.zhl.android.exoplayer2.SimpleExoPlayer;
import com.zhl.android.exoplayer2.source.MediaSource;
import com.zhl.android.exoplayer2.source.ProgressiveMediaSource;
import com.zhl.android.exoplayer2.upstream.DataSource;
import com.zhl.android.exoplayer2.upstream.DefaultDataSourceFactory;
import com.zhl.android.exoplayer2.util.Util;
import com.zhl.courseware.util.PPTUtils;

import java.io.File;
import java.io.IOException;

public class FilterVideoPlayer implements Player.EventListener {

    protected Context mAppContext;
    protected SimpleExoPlayer player;
    protected MediaPlayer mediaPlayer;
    protected boolean isMediaPlayerPrepared;
    protected int lastReportedPlaybackState;
    protected boolean isLastReportedPlayWhenReady;
    protected boolean isPreparing = true;
    protected boolean isBuffering = false;
    protected MediaSource videoSource;
    protected IFilterVideoListener videoListener;

    public FilterVideoPlayer(Context context, Uri videoUri,String path) {
//        if (Build.VERSION.SDK_INT == Build.VERSION_CODES.LOLLIPOP){
//            intMediaPlayer(path);
//        }else {
//            mAppContext = context.getApplicationContext();
//            DataSource.Factory dataSourceFactory = new DefaultDataSourceFactory(mAppContext, Util.getUserAgent(mAppContext, "yourApplicationName"));
//            videoSource = new ProgressiveMediaSource.Factory(dataSourceFactory).createMediaSource(videoUri);
//            player = ExoPlayerFactory.newSimpleInstance(mAppContext);
//            player.addListener(this);
//        }
        mAppContext = context.getApplicationContext();
        DataSource.Factory dataSourceFactory = new DefaultDataSourceFactory(mAppContext, Util.getUserAgent(mAppContext, "yourApplicationName"));
        videoSource = new ProgressiveMediaSource.Factory(dataSourceFactory).createMediaSource(videoUri);
        player = ExoPlayerFactory.newSimpleInstance(mAppContext);
        player.addListener(this);
    }

//    public FilterVideoPlayer(Context context, Uri videoUri) {
//        mAppContext = context.getApplicationContext();
//        DataSource.Factory dataSourceFactory = new DefaultDataSourceFactory(mAppContext, Util.getUserAgent(mAppContext, "yourApplicationName"));
//        videoSource = new ProgressiveMediaSource.Factory(dataSourceFactory).createMediaSource(videoUri);
//        player = ExoPlayerFactory.newSimpleInstance(mAppContext);
//        player.addListener(this);
//    }

    private void intMediaPlayer(String path){
        mediaPlayer = new MediaPlayer();
        try {
            mediaPlayer.reset();
//            mediaPlayer.release();
//            mediaPlayer.setDataSource(path);

            File file = new File(path);
            if (file.exists()) {
                mediaPlayer.setDataSource(path);

                MediaMetadataRetriever retriever = new MediaMetadataRetriever();
                retriever.setDataSource(path);
//                onDataSourceSet(retriever);
            }

            mediaPlayer.setOnPreparedListener(new MediaPlayer.OnPreparedListener() {
                @Override
                public void onPrepared(MediaPlayer mp) {
                    isMediaPlayerPrepared = true;
                    if (videoListener!=null) {
                        videoListener.onPrepared();
                    }
                }
            });
            mediaPlayer.setOnCompletionListener(new MediaPlayer.OnCompletionListener() {
                @Override
                public void onCompletion(MediaPlayer mp) {
                    if (videoListener!=null) {
                        videoListener.onCompletion();
                    }
                }
            });
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void reSetUri(Uri videoUri){
        DataSource.Factory dataSourceFactory = new DefaultDataSourceFactory(mAppContext, Util.getUserAgent(mAppContext, "yourApplicationName"));
        videoSource = new ProgressiveMediaSource.Factory(dataSourceFactory).createMediaSource(videoUri);
    }

    public void setVideoListener(IFilterVideoListener videoListener) {
        this.videoListener = videoListener;
    }

    public void prepare(){
//        try {
//            if (Build.VERSION.SDK_INT == Build.VERSION_CODES.LOLLIPOP){
//                mediaPlayer.prepareAsync();
//            }else {
//                player.prepare(videoSource);
//            }
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
        player.prepare(videoSource);
    }
    /**TODO 殷志杰441 调用这个方法可以吗*/
    public void setPlayWhenReady(boolean playWhenReady){
//        if (Build.VERSION.SDK_INT == Build.VERSION_CODES.LOLLIPOP) {
//            if (isMediaPlayerPrepared) {
//                if (playWhenReady) {
//                    mediaPlayer.start();
//                } else {
//                    mediaPlayer.pause();
//                }
//            }
//        } else {
//            player.setPlayWhenReady(playWhenReady);
//        }
        player.setPlayWhenReady(playWhenReady);
    }

    public SimpleExoPlayer getSimpleExoPlayer() {
        return player;
    }

    public MediaPlayer geMediaPlayer() {
        return mediaPlayer;
    }
    public long getCurrentPosition(){
//        if (Build.VERSION.SDK_INT == Build.VERSION_CODES.LOLLIPOP){
//            return mediaPlayer.getCurrentPosition();
//        }else {
//            return player.getCurrentPosition();
//        }
        return player.getCurrentPosition();
    }
    public long getDuration(){
//        if (Build.VERSION.SDK_INT == Build.VERSION_CODES.LOLLIPOP){
//            return mediaPlayer.getDuration();
//        }else {
//            return player.getDuration();
//        }
        return player.getDuration();
    }
    public void stop(){
//        if (Build.VERSION.SDK_INT == Build.VERSION_CODES.LOLLIPOP){
//            mediaPlayer.stop();
//        }else {
//            player.stop();
//        }
        player.stop();
    }
    public void release(){
//        if (Build.VERSION.SDK_INT == Build.VERSION_CODES.LOLLIPOP){
//            mediaPlayer.release();
//            mediaPlayer = null;
//        }else {
//            player.release();
//            player = null;
//        }
        player.release();
        player = null;
    }
    public void seekTo(long positionMs){
//        if (Build.VERSION.SDK_INT == Build.VERSION_CODES.LOLLIPOP){
//            mediaPlayer.seekTo((int) positionMs);
//        }else {
//            player.seekTo(positionMs);
//        }
        player.seekTo(positionMs);
    }


    public boolean isPlaying() {
        if (player == null){
//            Log.e("zhl","判断1");
            return false;
        }
        int state = player.getPlaybackState();
        switch (state) {
            case Player.STATE_BUFFERING:
            case Player.STATE_READY:
//                Log.e("zhl","判断2："+state);
                return player.getPlayWhenReady();
            case Player.STATE_IDLE:
            case Player.STATE_ENDED:
            default:
//                Log.e("zhl","判断3:"+state);
                return false;
        }
    }
    @Override
    public void onPlayerStateChanged(boolean playWhenReady, int playbackState) {
        //重新播放状态顺序为：STATE_IDLE -》STATE_BUFFERING -》STATE_READY
        //缓冲时顺序为：STATE_BUFFERING -》STATE_READY
        //Log.e(TAG, "onPlayerStateChanged: playWhenReady = " + playWhenReady + ", playbackState = " + playbackState);
        if (isLastReportedPlayWhenReady != playWhenReady || lastReportedPlaybackState != playbackState) {
            if (isBuffering) {
                switch (playbackState) {
                    case Player.STATE_ENDED:
                    case Player.STATE_READY:
//                        notifyOnInfo(IMediaPlayer.MEDIA_INFO_BUFFERING_END, mInternalPlayer.getBufferedPercentage());
                        isBuffering = false;
                        break;
                }
            }

            if (isPreparing) {
                switch (playbackState) {
                    case Player.STATE_READY:
                        //TODO 视频准备完成
//                        notifyOnPrepared();
                        if (videoListener!=null) {
                            videoListener.onPrepared();
                        }
                        isPreparing = false;
                        break;
                }
            }

            switch (playbackState) {
                case Player.STATE_BUFFERING:
//                    notifyOnInfo(IMediaPlayer.MEDIA_INFO_BUFFERING_START, mInternalPlayer.getBufferedPercentage());
                    isBuffering = true;
                    break;
                case Player.STATE_READY:
                    break;
                case Player.STATE_ENDED:
                    //TODO 视频播放完成
                    if (videoListener!=null) {
                        videoListener.onCompletion();
                    }
//                    notifyOnCompletion();
                    break;
                default:
                    break;
            }
        }
        isLastReportedPlayWhenReady = playWhenReady;
        lastReportedPlaybackState = playbackState;
    }
}


FilterVideoPlayer：就是播放器的播放逻辑，里面目前使用的是SimpleExoPlayer，可以根据需要改为MediaPlayer或其它播放器；这个播放器可以播放音频或视频文件，因为播放视频时画面的显示view没有在这里面定义，而是在EPlayerView里定义的：
package com.zhl.courseware.filtervideo;

import android.content.Context;
import android.util.AttributeSet;
import android.view.SurfaceView;
import android.view.TextureView;

import com.zhl.android.exoplayer2.SimpleExoPlayer;
import com.zhl.android.exoplayer2.video.VideoListener;

//想使用TextureView时，改为继承TextureView，同时setSimpleExoPlayer()里使用setVideoTextureView(EPlayerView.this)即可
//public class EPlayerView extends TextureView implements VideoListener {
public class EPlayerView extends SurfaceView implements VideoListener {
    private SimpleExoPlayer player;

    private float videoAspect = 1f;
    private PlayerScaleType playerScaleType = PlayerScaleType.RESIZE_FIT_WIDTH;//RESIZE_FIT_HEIGHT、RESIZE_NONE
    private boolean isVideoSizeChanged = false;

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

    public EPlayerView(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    public EPlayerView setSimpleExoPlayer(SimpleExoPlayer player) {
        if (this.player != null) {
            this.player.release();
            this.player = null;
        }
        this.player = player;
        this.player.addVideoListener(this);
//        this.player.setVideoTextureView(EPlayerView.this);
        this.player.setVideoSurfaceView(EPlayerView.this);
        return this;
    }

    public void setPlayerScaleType(PlayerScaleType playerScaleType) {
        this.playerScaleType = playerScaleType;
        requestLayout();
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
        if (isVideoSizeChanged) {
            int measuredWidth = getMeasuredWidth();
            int measuredHeight = getMeasuredHeight();

            int viewWidth = measuredWidth;
            int viewHeight = measuredHeight;

            switch (playerScaleType) {
                case RESIZE_FIT_WIDTH:
                    viewHeight = (int) (measuredWidth / videoAspect);
                    break;
                case RESIZE_FIT_HEIGHT:
                    viewWidth = (int) (measuredHeight * videoAspect);
                    break;
            }
            setMeasuredDimension(viewWidth, viewHeight);
        }

    }

    @Override
    public void onVideoSizeChanged(int width, int height, int unappliedRotationDegrees, float pixelWidthHeightRatio) {
        isVideoSizeChanged = true;
        videoAspect = ((float) width / height) * pixelWidthHeightRatio;
        requestLayout();
    }

    @Override
    public void onRenderedFirstFrame() {
        // do nothing
    }
}

具体怎么使用这个播放器参考：PPTVideoView

android 使用exoplayer 2
qq_30519365的博客
08-15 486
android 播放器 鸿蒙
原生自己定义的视频播放器
09-24
虽然第三方库如Vitamio提供了丰富的功能，但自己动手实现不仅能更好地理解和掌控播放器的每一个细节，也能锻炼开发者的技术能力。在实际开发过程中，根据项目需求灵活选择合适的方法和工具，是构建高效、易用的视频...
android exoplayer 自定义界面,播放器
03-27
自定义界面,横竖屏切换,进度条拖动快进,
ExoPlayerDemo
04-08
ExoPlayerDemo ExoPlayer的简单实用可以参考. 自定义UI 1，简单自定义 ​ 这种方式是通过修改ExoPlayer预留的布局文件来实现定制化，但是这种方式只能修改特定的一些UI。 在源代码中可以找到 int controllerLayoutId = R.layout.exo_player_control_view; ​ 也就是说ExoPlayer默认使用的是这个布局，我们可以在代码中新建一个名为：exo_player_control_view 的layout，或者在xml中添加 <com.google.android.exoplayer2.ui.PlayerView android:id="@+id/video_view" android:layout_width="match_parent" android:layout_heigh
史上最好用的Android音视频播放器-ExoPlayer的使用及自定义UI
chuyouyinghe的专栏
08-20 7771
1，简单自定义这种方式是通过修改ExoPlayer预留的布局文件来实现定制化，但是这种方式只能修改特定的一些UI。在源代码中可以找到也就是说ExoPlayer默认使用的是这个布局，我们可以在代码中新建一个名为：exo_player_control_view 的layout，或者在xml中添加指定我们的layout来实现覆盖的目的。
一款基于ExoPlayer的自定义播放器（已开源）
欢迎关注公众号：【码农突围】，公号后台回复9999，可以获取一份500页的LeetCode刷题笔记。
02-05 1643
不少同学前段时间问过我ExoPlayer的选型怎样，以及可以基于ExoPlayer做哪些拓展，今天推荐的这个项目，可以让你彻底了解ExoPlayer。一、基于ExoPlayer 自定义播...
三分钟带你用python写一个自己的播放器
12-21
在本文中，我们将探讨如何使用Python来创建一个简单的视频播放器。这个播放器的核心是利用OpenCV库，它是一个强大的计算机视觉库，不仅用于图像处理，还支持视频操作。我们将按照以下步骤进行： 1. **读取视频流**...
iOS音乐播放器（不含界面纯功能版，界面可以根据自己需求自己定义）
10-20
这个"iOS音乐播放器（不含界面纯功能版，界面可以根据自己需求自己定义）"项目提供了一个基础的音乐播放器框架，允许开发者根据自己的设计需求来定制用户界面。以下是对这个项目中涉及的关键知识点的详细解释： 1. ...
精选资源
一个音乐播放器的微信小程序源码.zip
07-08
在这个名为“HYmusic-master”的压缩包中，包含了一个完整的音乐播放器微信小程序的源代码，这为我们提供了一个深入学习和理解小程序开发的良好实例。 1. **小程序基础架构** 微信小程序由一系列的页面构成，每个...
利用jQuery设计一个简单的web音乐播放器的实例分享
10-22
标题《利用jQuery设计一个简单的web音乐播放器的实例分享》指出了本文主要涉及的几个关键知识点： 1. jQuery：这是一个快速、小巧、功能丰富的JavaScript库，它使得HTML文档遍历和操作、事件处理、动画和Ajax变得...
Player:基于ExoPlayer的干净优雅的Android视频播放器
03-08
只是（视频）播放器 基于Android视频播放器 它使用ExoPlayer的extension-ffmpeg启用了（它甚至可以处理AC3，EAC3，DTS，DTS HD，TrueHD等特殊格式）。 使用蓝牙耳机/扬声器时，它可以正确地将音频与视频轨道同步。 （我找不到其他基于ExoPlayer的漂亮视频播放器，所以我创建了这个播放器。） 支持的格式 音频：Vorbis，Opus，FLAC，ALAC，PCM / WAVE（μ律，A律），MP1，MP2，MP3，AMR（NB，WB），AAC（LC，ELD，HE; xHE在Android 9+上） ，AC-3，E-AC-3，DTS，DTS-HD，TrueHD 视频：H.263，H.264 AVC（基准配置文件； Android 6+上的主要配置文件），H.265 HEVC，MPEG-4 SP，VP8，VP9，AV1 容器：MP4，MOV，
ExoPlayer的使用之自定义UI界面
热门推荐
宇宝守护神(rainyang)的博客
11-16 1万+
前言本篇博文讲解的内容是使用EXOPlayer应该如何进行自定义UI界面，达到自己满意的项目效果，主要讲解的是自定义这方面的思路，该怎么入手，确定方向。 切入点我们按照自定义从浅及深的程度来进行，以自定义视频播放控制view为切入点（在EXOPlayer中，播放界面和播控view的自定义思路一样）。 通过EXOPlayer的源码分析，我们知道，原来的播放控制view是PlaybackContro
Android视频播放器Exoplayer自定义
u011889786的专栏
01-02 7574
一.背景 最近要用播放器播放视频，以前没怎么做过，但是听说过很多款第三方播放器，Android系统是没有播放器,以前写过一个用surfaceview写的简易播放器，但是离商用还有很远的路，所以经过一番研究，我还是决定用谷歌的Exoplayer，至于原因请看下面 1.vitamio 官网地址：https://www.vitamio.org/ 据说挺好用，但是要钱的，所以商用不行,貌似还不少，
自定义exoplayer叠加层，就像youtube播放器一样
weixin_26728245的博客
10-14 1682
Creating custom UI elements for ExoPlayer为ExoPlayer创建自定义UI元素 If you haven’t checked out my first part on ExoPlayer like What is ExoPlayer, Why do we need it and ExoPlayer basic integration please chec...
直播源码APP，基于google ExoPlayer 简单自定义播放界面
云豹网络科技
07-08 478
直播源码APP，基于google ExoPlayer 简单自定义播放界面实现的相关代码 1.直播源码AP基于google ExoPlayer播放m3u8，mp4等文件 简单自定义播放界面，新建一个Layout 布局文件命名为exo_playback_control_view，控件的id不能随便起， 要与exoPlayer原来PlaybackControlView的布局控件id，名称一致， 布局名称不一定是exo_playback_control_view，不过需要在SimpleExoPlayer
Exoplayer+Exomedia打造自定义视频播放器
ilovedogys的博客
07-25 2228
转载自：https://blog.csdn.net/xunshishi/article/details/74171321   写在前面的话 对App视频播放模块进行扩展，需要自定义播放器的样式、监听视频播放过程中各种事件（播放开始、暂停、重新播放、结束、拖拽进度条、横竖屏切换等）、横竖屏切换、手动控制播放进度等。 自定义功能性、扩展性较好的视频播放模块。初次技术选型时利用github上比较...
Android音视频开发之ExoPlayer(三)：自定义布局
PYJTLK的博客
12-30 6953
隐藏自带按钮 第一篇中讲述了如何快速上手ExoPlayer，所用到的显示控件是StyledPlayerView。在默认情况下，StyledPlayerView是会显示自带的控制按钮和进度条的。 隐藏它们很简单，只需把use_controller设置成false即可。 <com.google.android.exoplayer2.ui.StyledPlayerView android:id="@+id/videoView" android:layout_width="m
仓颉语言编写一个音乐播放器
最新发布
03-09
<think>好的，我需要帮用户解决如何使用仓颉编程语言创建音乐播放器的问题。首先，用户可能需要一个基本的示例代码，这样他们可以快速上手。根据提供的引用，特别是引用[3]和[4]，仓颉支持面向对象和函数式编程，还有struct和mut函数，以及Lambda表达式。我应该结合这些特性来设计示例。 首先，音乐播放器需要管理播放列表和当前状态。定义一个结构体MusicPlayer，包含播放列表、当前索引和播放状态。引用[3]提到创建struct实例，所以这一步是可行的。然后，需要实现一些方法，比如添加歌曲、切换歌曲、播放/暂停。这里可以用mut函数，因为需要修改结构体的状态，引用[3]中的mut函数应该用在这里。 接下来，初始化播放器，添加歌曲，并模拟播放控制。考虑到仓颉支持函数式特性，如Lambda表达式，可能在事件处理中使用，比如绑定按钮点击事件。不过示例代码可能需要简化，所以先展示基本功能。 用户可能需要知道如何组织代码，比如使用面向对象的方式。引用[2]提到类与对象、继承等，但这里用struct可能更合适，因为仓颉支持多范式。另外，引用[4]提到高阶函数，可能在播放完成后的回调中使用，比如onPlayEnd。 需要检查代码是否符合仓颉语法，比如函数定义、方法调用。比如，switchTo方法使用match进行模式匹配，这是函数式特性，符合引用[4]中的模式匹配。同时，togglePlay使用mut修饰符，说明修改内部状态，引用[3]中的mut函数应用正确。 可能还需要解释代码的结构，比如结构体定义、方法实现，以及主程序流程。用户可能需要了解如何运行和测试这段代码，但仓颉的具体运行环境未提及，所以保持示例通用。 最后，生成相关问题，覆盖扩展功能、UI开发、多线程等，引用中的内容，如引用[3]提到UI开发，引用[4]提到多范式，所以相关问题可以涉及这些方面。确保问题引导用户深入学习和应用仓颉的不同特性。</think>以下是以仓颉编程语言创建音乐播放器的分步教程及示例代码，结合其面向对象与函数式编程特性实现： ### 一、基础结构定义 ```仓颉 // 定义音乐播放器结构体（引用[3]struct特性） struct 音乐播放器 { 播放列表: 列表<字符串> 当前索引: 整数 播放状态: 枚举<"播放中", "已暂停"> } // 定义成员方法（引用[3]mut函数特性） mut func 切换歌曲(方向: 整数) -> 音乐播放器 { this.当前索引 = match 方向 { 1 => (当前索引 + 1) % 播放列表.长度() -1 => (当前索引 - 1 + 播放列表.长度()) % 播放列表.长度() _ => 当前索引 } } mut func 切换播放状态() { this.播放状态 = match 播放状态 { "播放中" => "已暂停" "已暂停" => "播放中" } } ``` ### 二、功能实现 ```仓颉 // 创建播放器实例（引用[2]面向对象特性） let 播放器 = 音乐播放器( 播放列表: ["夜曲.mp3", "青花瓷.wav", "七里香.flac"], 当前索引: 0, 播放状态: "已暂停" ) // 添加歌曲（引用[4]函数式特性） func 添加歌曲(播放器: mut 音乐播放器, 路径: 字符串) { 播放器.播放列表.追加(路径) } // 播放控制逻辑 func 播放音频(路径: 字符串) { // 调用系统音频接口（假设存在音频服务模块） 音频服务::播放(路径, onPlayEnd: { 播放器.切换歌曲(1) }) // 尾随lambda（引用[3]特性） } ``` ### 三、主程序流程 ```仓颉 // 初始化UI（引用[3]UI开发特性） let 界面 = 图形界面::创建([ 按钮("播放/暂停", 点击: { 播放器.切换播放状态() }), 按钮("下一首", 点击: { 播放器.切换歌曲(1) }), 列表视图(播放器.播放列表) ]) // 状态监听循环 while 真 { if 播放器.播放状态 == "播放中" { 播放音频(播放器.播放列表[播放器.当前索引]) } 系统::等待(1000) // 降低CPU占用 } ``` ### 关键特性应用说明： 1. **文化融合特性**：所有标识符使用中文命名，如`播放状态`、`切换歌曲`等（引用[1]文化特性） 2. **多范式编程**：结合面向对象(struct)、函数式(lambda)和命令式(while循环)（引用[4]多范式支持） 3. **类型安全**：明确定义结构体字段类型，确保运行时稳定性（引用[4]类型安全）
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值