使用surfaceview进行mediaplayer文件切换播放2

最新推荐文章于 2025-09-04 16:25:21 发布
原创 最新推荐文章于 2025-09-04 16:25:21 发布 · 5.3k 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文探讨了在Android应用中使用MediaPlayer切换不同视频文件时遇到的启动播放问题，通过增加MediaPlayer重置后的间隔时间，实现了解决方案。代码示例展示了初始化、停止、重置和重新播放视频的过程。

遇到的是真机测试的问题，模拟器能正常播放。

之前有篇关于mediaplayer，这次只是一些简单的修改。

问题描述：

在进行不同视频文件切换时，mediaplayer并不能正常启动播放（时常出现）。

会提示D/MediaPlayer(29517): start() mUri is null错误


切换时的主要操作方法是

1.关闭播放并重置MediaPlayer

MediaPlayer.stop()

MediaPlayer.reset()

2.之后调用播放设置

MediaPlayer.setDataSource(file)

MediaPlayer.prepare()

MediaPlayer.start()


尝试增加了reset的间隔后，可以正常播放，一直没明白什么原因（有大侠知道原因的可以指导下^_^）

之所以想到用增加时间间隔的方法，主要是因为在进行手动的停止并再启动时，视频能正常播放，而这中间进行的操作步骤完全相同。

下面贴一下代码（和第一版些许的差别，主要是给自己加深下印象）


package com.exam.test.main;

import java.io.File;

import android.content.Intent;
import android.media.AudioManager;
import android.media.MediaPlayer;
import android.media.MediaPlayer.OnBufferingUpdateListener;
import android.media.MediaPlayer.OnCompletionListener;
import android.media.MediaPlayer.OnSeekCompleteListener;
import android.os.Bundle;
import android.os.Handler;
import android.view.KeyEvent;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import android.view.View;
import android.view.ViewGroup.LayoutParams;
import android.widget.ImageButton;
import android.widget.LinearLayout;
import android.widget.TextView;

import com.exam.test.R;
import com.exam.engine.util.LogX;

public class mainVideoActivity extends main implements MediaPlayer.OnPreparedListener,
    MediaPlayer.OnErrorListener, OnBufferingUpdateListener, OnCompletionListener, OnSeekCompleteListener,
    SurfaceHolder.Callback
{
    /**
     * TAG
     */
    private static final String TAG = "mainVideoActivity ";
    
    /**
     * 视频监控器地理信息
     */
    private String monitorLocationInfo;
    
    /**
     * 加载页面
     */
    private LinearLayout initView;
    
    /**
     * 位置信息textview
     */
    private TextView text;
    
    /**
     * 监控器页面
     */
    private LinearLayout playView;
    
    /**
     * 监控控制
     */
    private MediaPlayer mMediaPlayer;
    
    /**
     * 文件路径
     */
    private String filePath;
    
    /**
     * surfaceHolder
     */
    private SurfaceHolder surfaceHolder;
    
    /**
     * 暂停按钮
     */
    private ImageButton btnPause;
    
    private static final int PLAYING = 1;
    
    private static final int PAUSED = 2;
    
    private static final int STOPED = 3;
    
    /**
     * 是否正在播放
     */
    private int status;
    
    private boolean isPrepared;
    
    /**
     * runner
     */
    private Runnable runner = new Runnable()
    {
        @Override
        public void run()
        {
            handler.sendEmptyMessageDelayed(0, 2000);
        }
    };
    
    /**
     * handler
     */
    private Handler handler = new Handler()
    {
        public void handleMessage(android.os.Message msg)
        {
            if (0 == msg.what)
            {
                initView.setVisibility(View.GONE);
                this.removeCallbacks(runner);
                LogX.trace(TAG, "handleMessage&  mMediaPlayer.start() : " + mMediaPlayer);
                if (mMediaPlayer != null)
                {
                    mMediaPlayer.setLooping(true);
                    mMediaPlayer.start();
                    btnPause.setBackgroundResource(R.drawable.btn_video_pause_selector);
                    status = PLAYING;
                    isPrepared = true;
                }
                isLocked = false;
            }
            else
            {
                playVideo();
            }
        }
    };
    
    /**
     * 控制按钮
     */
    private View.OnClickListener btnClickListener = new View.OnClickListener()
    {
        @Override
        public void onClick(View v)
        {
            LogX.trace(TAG, "onClick&  status : " + status + ", isPrepared : " + isPrepared + ", mMediaPlayer : "
                + mMediaPlayer);
            if (mMediaPlayer == null || !isPrepared)
            {
                return;
            }
            
            if (v.getId() == R.id.btn_video_pause)
            {
                switch (status)
                {
                    case PLAYING:
                        status = PAUSED;
                        mMediaPlayer.pause();
                        btnPause.setBackgroundResource(R.drawable.btn_video_play_selector);
                        break;
                    case PAUSED:
                        status = PLAYING;
                        mMediaPlayer.start();
                        btnPause.setBackgroundResource(R.drawable.btn_video_pause_selector);
                        break;
                    case STOPED:
                        isPrepared = false;
                        playVideo();
                        break;
                    default:
                        break;
                }
            }
            else if (status == PLAYING || status == PAUSED)
            {
                status = STOPED;
                mMediaPlayer.stop();
                mMediaPlayer.reset();
                btnPause.setBackgroundResource(R.drawable.btn_video_play_selector);
            }
            LogX.trace(TAG, "onClick&  status : " + status);
        }
    };
    
    /**
     * {@inheritDoc}
     */
    @Override
    protected void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        playView = (LinearLayout)inflater.inflate(R.layout.main_video_play, null);
        
        content.setOnClickListener(new View.OnClickListener()
        {
            long mLastClickTime = 0;
            
            @Override
            public void onClick(View v)
            {
                if (System.currentTimeMillis() - mLastClickTime < 2000)
                {
                    return;
                }
                mLastClickTime = System.currentTimeMillis();
                
                if (cBottom.getVisibility() == View.VISIBLE)
                {
                    content.setPadding(0, 0, 0, 0);
                    cTopSapce.setVisibility(View.GONE);
                    cBottomSapce.setVisibility(View.GONE);
                    cRight.setVisibility(View.GONE);
                    cBottom.setVisibility(View.GONE);
                }
                else
                {
                    content.setPadding(8, 8, 8, 8);
                    cBottomSapce.setVisibility(View.VISIBLE);
                    cTopSapce.setVisibility(View.VISIBLE);
                    cRight.setVisibility(View.VISIBLE);
                    cBottom.setVisibility(View.VISIBLE);
                }
                
            }
        });
        
        loadIntentData();
        setContentData();
        loadVideoData();
    }
    
    /**
     * {@inheritDoc}
     * 连接请求
     */
    @Override
    protected void sendRequest(mainBean bean)
    {
        LogX.trace(TAG, "sendRequest&  isLocked : " + isLocked);
        if (!isLocked)
        {
            monitorLocationInfo = bean.getDetailInfo();
            filePath = videoFilePath + bean.getCameraId();
            mMediaPlayer.stop();
            mMediaPlayer.reset();
            //            playVideo();
            isLocked = true;
            isPrepared = false;
            text.setText(monitorLocationInfo);
            initView.setVisibility(View.VISIBLE);
            // 在连续进行切换文件时，存在不能正常开始播放的问题
            // 在reset后延迟1秒钟进行设置，可以正常播放---原因不明
            handler.sendEmptyMessageDelayed(1, 1000);
        }
    }
    
    /**
     * <加载Intent传递的数据>
     * @see [类、类#方法、类#成员]
     */
    private void loadIntentData()
    {
        //获取Intent数据
        Bundle bundle = getIntent().getExtras();
        if (bundle != null)
        {
            mainBean mbean = (mainBean)bundle.getSerializable("main");
            monitorLocationInfo = mbean.getDetailInfo();
            filePath = videoFilePath + mbean.getCameraId();
            LogX.trace(TAG, "loadIntentData&  mbean : " + mbean);
        }
    }
    
    /**
     * <加载视频数据>
     * @see [类、类#方法、类#成员]
     */
    private void loadVideoData()
    {
        content.addView(playView, new LayoutParams(LayoutParams.FILL_PARENT, LayoutParams.FILL_PARENT));
        btnPause = (ImageButton)findViewById(R.id.btn_video_pause);
        btnPause.setOnClickListener(btnClickListener);
        findViewById(R.id.btn_video_stop).setOnClickListener(btnClickListener);
        initView = (LinearLayout)findViewById(R.id.video_inital);
        text = ((TextView)findViewById(R.id.monitor_video_info));
        
        surfaceHolder = ((SurfaceView)findViewById(R.id.video_view)).getHolder();
        surfaceHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
        surfaceHolder.addCallback(this);
    }
    
    /**
     * <play>
     * @see [类、类#方法、类#成员]
     */
    private void playVideo()
    {
        if (initView.getVisibility() == View.GONE)
        {
            isLocked = true;
            isPrepared = false;
            text.setText(monitorLocationInfo);
            initView.setVisibility(View.VISIBLE);
        }
        try
        {
            if (!new File(filePath).exists())
            {
                throw new Exception(filePath + " is not exist");
            }
            
            mMediaPlayer.setDataSource(filePath);
            mMediaPlayer.prepare();
            
            LogX.trace(TAG, "playVideo&  filePath : " + filePath + ", isLocked : " + isLocked);
        }
        catch (Exception e)
        {
            btnPause.setBackgroundResource(R.drawable.btn_video_pause_selector);
            isLocked = false;
            e.printStackTrace();
            LogX.trace(TAG, "playVideo& Exception : " + e.toString());
        }
    }
    
    /**
     * {@inheritDoc}
     * 搜索并更新列表数据
     */
    @Override
    protected void search(String keyword)
    {
        super.search(keyword);
        super.setContentData();
    }
    
    /**
     * {@inheritDoc}
     * MediaPlayer.start()
     */
    @Override
    public void onPrepared(MediaPlayer mp)
    {
        //        surfaceHolder.setFixedSize(mVideoWidth, mVideoHeight);
        //        initView.setVisibility(View.GONE);
        runner.run();
        LogX.trace(TAG, "onPrepared& MediaPlayer.start() " + mp.getDuration());
        
    }
    
    /**
     * {@inheritDoc}
     */
    @Override
    public void onCompletion(MediaPlayer mp)
    {
        LogX.trace(TAG, "onCompletion&");
    }
    
    /**
     * {@inheritDoc}
     */
    @Override
    public void onBufferingUpdate(MediaPlayer mp, int percent)
    {
        LogX.trace(TAG, "onBufferingUpdate& percent : " + percent);
    }
    
    /**
     * {@inheritDoc}
     */
    @Override
    public boolean onError(MediaPlayer mp, int what, int extra)
    {
        LogX.trace(TAG, "onError& what : " + what + ", extra : " + extra);
        return false;
    }
    
    /**
     * {@inheritDoc}
     */
    @Override
    public void onSeekComplete(MediaPlayer mp)
    {
        LogX.trace(TAG, "onSeekComplete&");
        
    }
    
    /**
     * {@inheritDoc}
     */
    @Override
    public void surfaceCreated(SurfaceHolder holder)
    {
        LogX.trace(TAG, "surfaceCreated&");
        
        try
        {
            mMediaPlayer.setDisplay(holder);
            playVideo();
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        
    }
    
    /**
     * {@inheritDoc}
     */
    @Override
    public void surfaceChanged(SurfaceHolder holder, int format, int width, int height)
    {
        LogX.trace(TAG, "surfaceChanged&");
    }
    
    /**
     * {@inheritDoc}
     */
    @Override
    public void surfaceDestroyed(SurfaceHolder holder)
    {
        if (mMediaPlayer != null)
        {
            handler.removeCallbacks(runner);
            mMediaPlayer.release();
            mMediaPlayer = null;
        }
        LogX.trace(TAG, "surfaceDestroyed&");
    }
    
    /**
     * {@inheritDoc}
     */
    @Override
    protected void back()
    {
        startActivity(new Intent(mainVideoActivity.this, mainActivity.class));
        this.finish();
    }
    
    /**
     * {@inheritDoc}
     */
    @Override
    public boolean onKeyDown(int keyCode, KeyEvent event)
    {
        if (keyCode == KeyEvent.KEYCODE_BACK)
        {
            back();
            return true;
        }
        return super.onKeyDown(keyCode, event);
    }
    
    @Override
    protected void onResume()
    {
        LogX.trace(TAG, "onResume&");
        super.onResume();
        mMediaPlayer = new MediaPlayer();
        mMediaPlayer.setScreenOnWhilePlaying(true);
        mMediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);
        mMediaPlayer.setOnPreparedListener(this);
        mMediaPlayer.setOnSeekCompleteListener(this);
        mMediaPlayer.setOnBufferingUpdateListener(this);
        mMediaPlayer.setOnCompletionListener(this);
        mMediaPlayer.setOnErrorListener(this);
    }
    
    @Override
    protected void onStart()
    {
        LogX.trace(TAG, "onStart&");
        super.onStart();
    }
    
    @Override
    protected void onPause()
    {
        LogX.trace(TAG, "onPause&");
        super.onPause();
    }
    
    /**
     * {@inheritDoc}
     */
    @Override
    protected void onStop()
    {
        LogX.trace(TAG, "onStop&");
        super.onStop();
    }
    
    @Override
    protected void onDestroy()
    {
        LogX.trace(TAG, "onDestroy&");
        super.onDestroy();
        if (mMediaPlayer != null)
        {
            handler.removeCallbacks(runner);
            mMediaPlayer.release();
            mMediaPlayer = null;
        }
    }
}



知道分子
关注
surfaceview+mediaplayer实现视频播放和动态设置全屏窗口切换。
09-18
surfaceview+mediaplayer 实现视频播放和动态设置view的宽高和全屏窗口切换。播放的是没m3u8的视频，大家有什么问题也可以回复。
SurfaceView+MediaPlayer视频播放以及小窗口和全屏播放
01-10
SurfaceView+MediaPlayer视频播放，包含小窗口和全屏播放
Android视频无缝切换，使用MediaPlayer和TextureView
Winson的专栏
09-12 6887
需求描述              比如广告播放，每个视频15秒，视频之间切换的时候，性能不太好的机器可能会黑屏一段时间，体验不太好，接下来我们就是要解决这个黑屏问题。 解决方案 使用两个surfaceView方式，经过测试不行 使用一个MediaPlayer，在MediaPlayer上面加一层ImageView，每次播放完成后，获取视频的最后一帧的图像给ImageView，视频切换完成，...
Android SurfaceView+MediaPlayer实现几个不同的视频轮流播放
Dr_abandon的博客
06-20 6379
MediaPlayer 1）如何获得MediaPlayer实例： 可以使用直接new的方式： MediaPlayer mp = new MediaPlayer(); 也可以使用create的方式，如： MediaPlayer mp = MediaPlayer.create(this, R.raw.test); 网络或是内部存储直接setDataSource一个路径 2) 如何设置要播...
Android解决Mediaplayer+SurfaceView播放视频中的若干BUG
u014611408的博客
11-16 5252
项目的功能很简单，单纯的播放视频，没有进度条，暂停键等，只有一个关闭按钮，当播放视频时切换到后台暂停播放，恢复到前台后接着原来的进度播放。 1.用MediaPlayer播放视频，调用MediaPlayer.start()，surfaceHolder还没初始化好，debug时指示错误的地方在 MediaPlayer.setDisplay(surfa...
MediaPlayer播放音频与视频
jinyu_mobao的博客
10-05 1110
9.2 MediaPlayer播放音频与视频 分类Android 基础入门教程 本节引言： 本节带来的是Android多媒体中的——MediaPlayer，我们可以通过这个API来播放音频和视频 该类是Androd多媒体框架中的一个重要组件，通过该类，我们可以以最小的步骤来获取，解码 和播放音视频。它支持三种不同的媒体来源： 本地资源 内部的URI，比如你可以通过Content...
SurfaceView+MediaPlayer封装之路
jiashuai94的博客
09-18 1万+
SurfaceView+MediaPlayer封装之路我的播放器叫做JsPlayer，喜欢的话，就给个star喽^_^https://github.com/shuaijia/JsPlayer这里我只介绍播放器封装思路，会贴出部分代码，如果大家想查看完整代码，可以去github查看，有不清楚或错误或改进的地方，可以issues 我！写在之前先上效果图：（1.5版本新增弹幕功能）为什么要用Surface
简单的MediaPlayer+SurfaceView实现视频横竖屏播放
热门推荐
twoStepFromHell的博客
08-22 5万+
一.概述    目前就我的认知中，Android实现视频播放的话，有2中方式，第一种是MediaPlayer+surfaceView实现，第二种是直接用VideoView来实现，当然市面上也有一些主流的视频能播放的框架，像Vitamio就非常的强大，支持多种格式的视频播放。今天着重讲的就是第一种实现方式-----------Mediaplayer+SurfaceView  二.
android MediaPlayer 实现切换视频播放比例
a22422931的博客
03-15 4095
在做项目的过程中遇到切换视频播放比例的
android播放器竖屏,SurfaceView + MediaPlayer 实现的视频播放器，支持横竖屏切换，
weixin_30311179的博客
05-26 1672
MNVideoPlayerSurfaceView + MediaPlayer 实现的视频播放器，支持横竖屏切换，手势快进快退、调节音量，亮度等。之前也发布过一个视频播放列表，项目截图：使用步骤：1：添加mnvideoplayerlibrary为moudle2：布局文件添加android:id="@+id/mn_videoplayer"android:layout_width="match_pare...
Android SurfaceView+MediaPlayer 本地视频播放器
SpringYang
06-17 2681
功能情景:        1.播放视频文件        2.上一首，下一首        3.卡拉ok功能        4.播放模式（顺序，随机，循环） 效果图 功能的实现:        1.伴唱功能:(这里是mkv文件切换声道),伴唱转AUDIO,原唱转VIDEO。当然前提是先获得mkv文件的所有声道。 我在视频准备的时候获取所有声道，然后判断是否有这个声道我再转。
android无缝切换播放器,android 视频 无缝切换 无缝播放 surfaceview
weixin_42509964的博客
05-26 1003
android 视频 无缝切换 无缝播放 surfaceview最近做一个app,其中有一个控件要不断的播放视频，切换视频，然后遇到每次切换视频都会黑屏一会。baidu,google没有找到有效的解决方案。经过n轮的测试，终于搞定了。下面是代码。package com.github.neowen.apibasedemo.csdn.circle_media;import android.media....
Android基于surfaceview与mediaplayer的视频播放器(android-studio)
SpringYang
08-15 5593
最近闲来无事写了一个较为完整的视频播放器，但由于有了新的项目，就把这个搁浅了，就差一个横竖屏切换的时候切换不同的控制栏了，已经横屏的自动锁定了。
Android开发中MediaPlayer与SurfaceView结合实现高效视频播放
最新发布
weixin_35294091的博客
09-04 906
在Android平台的多媒体开发中，与是构建视频播放功能的核心组件。负责音视频的解码与播放控制，而则专注于高效的视频画面渲染。二者结合，能够实现流畅、低延迟的视频播放体验。本章将从基础概念入手，深入解析的工作流程与的绘制机制，帮助开发者理解其在Android图形系统中的角色与协同方式，为后续实战开发奠定扎实的理论基础。本章详细介绍了Android中视频资源的三种主要加载方式：本地文件路径、应用资源文件（R.raw与assets）、网络流媒体URL。
android surfaceview 大小,MediaPlayer + SurfaceView（视频大小和surfaceview大小）
weixin_42360778的博客
05-26 1541
第一部分：问题的出现需求：页面有很多布局，其中有一块区域播放视频，当我单击这块区域的时候，全屏播放。我使用MediaPlayer +SurfaceView，当全屏时，改变SurfaceView的大小，然后MediaPlayer.setHolder(mSurfaceViewHolder)，但是，只有SurfaceView改变了，但是视频大小仍然没有改变。而且在不设置surfaceHolder的情况下...
Android里面使用MediaPlayer通过SurfaceView播放视频的示例
风无定人无常
03-21 2161
package com.example.test318; import java.io.IOException; import android.app.Activity; import android.content.pm.ActivityInfo; import android.graphics.Canvas; import android.media.AudioManager
SurfaceView + MediaPlayer 实现列表循环播放视频
weixin_33895475的博客
04-24 1335
写在前面的碎碎念 前一阵子终于结完了一个外包，把最后留的视频播放的坑给填上了 本着能用原生组件就不用不第三方组件的愚蠢态度，最后也算是把功能实现了，长时间跑下来也没有问题，放心食用 也是看了不少官方文档和博客，加上是异地协助花了不少时间，不过最后还是把东西整出来了 SurfaceView + MediaPlayer 实现列表循环播放视频 正文 SurfaceView + MediaPlaye...
Android MediaPlayer和SurfaceView
潘洪金的博客
10-09 1258
昨天介绍了VideoView播放视频，今天再介绍一种播放视频的方法MediaPlayer和SurfaceView，MediaPlayer播放音频，SurfaceView来显示图像，具体步骤如下：   1、创建MediaPlayer对象，并让它加载指定的视频文件。   2、在界面布局中定义SurfaceView组件，或在程序中创建SurfaceView组件，并为SurfaceView的Surfac
采用Android的MediaPlayer+SurfaceView设计视频播放器
Jason_Lee155的博客
07-25 1634
前言 android视频播放有很多方式（自带videoView等），这里简单说其中一种：MediaPlayer+SurfaceView，一个播放音频，一个播放视频（图像）。 大体结构图 BaseMediaPlayer：定义了一个播放器应该具备的基础接口；你可以跟进这个接口再加播放器底层，来实现不同的播放器；只提供播放的接口，不提供用户 UI 交互； SystemMediaPlayerImpl：继承自 BaseMediaPlayer，是基于 Android 系统 MediaPlayer 的一份实现
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值