6

我在 Fragment 中有一个 MediaPlayer，它在配置更改时保留其实例。播放器正在播放从我的资产目录加载的视频。我设置了一个场景，目的是重现 YouTube 应用程序播放，其中音频在配置更改期间继续播放，显示器分离并重新连接到媒体播放器。

当我开始播放并旋转设备时，位置会向前跳跃约 6 秒，并且（必然）发生这种情况时音频会中断。之后，播放继续正常进行。我不知道是什么导致了这种情况发生。

根据要求，这是代码：

public class MainFragment extends Fragment implements SurfaceHolder.Callback, MediaController.MediaPlayerControl {

    private static final String TAG = MainFragment.class.getSimpleName();

    AssetFileDescriptor mVideoFd;

    SurfaceView mSurfaceView;
    MediaPlayer mMediaPlayer;
    MediaController mMediaController;
    boolean mPrepared;
    boolean mShouldResumePlayback;
    int mBufferingPercent;
    SurfaceHolder mSurfaceHolder;

    @Override
    public void onInflate(Activity activity, AttributeSet attrs, Bundle savedInstanceState) {
        super.onInflate(activity, attrs, savedInstanceState);
        final String assetFileName = "test-video.mp4";
        try {
            mVideoFd = activity.getAssets().openFd(assetFileName);
        } catch (IOException ioe) {
            Log.e(TAG, "Can't open file " + assetFileName + "!");
        }
    }

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setRetainInstance(true);

        // initialize the media player
        mMediaPlayer = new MediaPlayer();
        try {
            mMediaPlayer.setDataSource(mVideoFd.getFileDescriptor(), mVideoFd.getStartOffset(), mVideoFd.getLength());
        } catch (IOException ioe) {
            Log.e(TAG, "Unable to read video file when setting data source.");
            throw new RuntimeException("Can't read assets file!");
        }

        mMediaPlayer.setOnPreparedListener(new MediaPlayer.OnPreparedListener() {
            @Override
            public void onPrepared(MediaPlayer mp) {
                mPrepared = true;
            }
        });

        mMediaPlayer.setOnBufferingUpdateListener(new MediaPlayer.OnBufferingUpdateListener() {
            @Override
            public void onBufferingUpdate(MediaPlayer mp, int percent) {
                mBufferingPercent = percent;
            }
        });

        mMediaPlayer.prepareAsync();
    }

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        super.onCreateView(inflater, container, savedInstanceState);
        View view = inflater.inflate(R.layout.fragment_main, container, false);
        mSurfaceView = (SurfaceView) view.findViewById(R.id.surface);
        mSurfaceView.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                mMediaController.show();
            }
        });

        mSurfaceHolder = mSurfaceView.getHolder();
        if (mSurfaceHolder == null) {
            throw new RuntimeException("SufraceView's holder is null");
        }
        mSurfaceHolder.addCallback(this);
        return view;
    }

    @Override
    public void onViewCreated(View view, Bundle savedInstanceState) {
        super.onViewCreated(view, savedInstanceState);
        mMediaController = new MediaController(getActivity());
        mMediaController.setEnabled(false);
        mMediaController.setMediaPlayer(this);
        mMediaController.setAnchorView(view);
    }

    @Override
    public void onResume() {
        super.onResume();
        if (mShouldResumePlayback) {
            start();
        } else {
            mSurfaceView.post(new Runnable() {
                @Override
                public void run() {
                    mMediaController.show();
                }
            });
        }
    }

    @Override
    public void surfaceCreated(SurfaceHolder holder) {
        mMediaPlayer.setDisplay(mSurfaceHolder);
        mMediaController.setEnabled(true);
    }

    @Override
    public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
        // nothing
    }

    @Override
    public void surfaceDestroyed(SurfaceHolder holder) {
        mMediaPlayer.setDisplay(null);
    }

    @Override
    public void onPause() {
        if (mMediaPlayer.isPlaying() && !getActivity().isChangingConfigurations()) {
            pause();
            mShouldResumePlayback = true;
        }
        super.onPause();
    }

    @Override
    public void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);

    }

    @Override
    public void onDestroyView() {
        mMediaController.setAnchorView(null);
        mMediaController = null;
        mMediaPlayer.setDisplay(null);
        mSurfaceHolder.removeCallback(this);
        mSurfaceHolder = null;
        mSurfaceView = null;
        super.onDestroyView();
    }

    @Override
    public void onDestroy() {
        mMediaPlayer.release();
        mMediaPlayer = null;
        try {
            mVideoFd.close();
        } catch (IOException ioe) {
            Log.e(TAG, "Can't close asset file..", ioe);
        }
        mVideoFd = null;
        super.onDestroy();
    }

    // MediaControler methods:
    @Override
    public void start() {
        mMediaPlayer.start();
    }

    @Override
    public void pause() {
        mMediaPlayer.pause();
    }

    @Override
    public int getDuration() {
        return mMediaPlayer.getDuration();
    }

    @Override
    public int getCurrentPosition() {
        return mMediaPlayer.getCurrentPosition();
    }

    @Override
    public void seekTo(int pos) {
        mMediaPlayer.seekTo(pos);
    }

    @Override
    public boolean isPlaying() {
        return mMediaPlayer.isPlaying();
    }

    @Override
    public int getBufferPercentage() {
        return mBufferingPercent;
    }

    @Override
    public boolean canPause() {
        return true;
    }

    @Override
    public boolean canSeekBackward() {
        return true;
    }

    @Override
    public boolean canSeekForward() {
        return true;
    }

    @Override
    public int getAudioSessionId() {
        return mMediaPlayer.getAudioSessionId();
    }
}

方法中的if块onPause没有被命中。

更新：

在进行更多调试后，删除与 SurfaceHolder 的交互会导致问题消失。换句话说，如果我不在 MediaPlayer 上设置显示，音频将在配置更改期间正常工作：没有暂停，没有跳过。在 MediaPlayer 上设置显示似乎存在一些时间问题，这会使播放器感到困惑。

此外，我发现您必须hide()在配置更改期间删除 MediaController 之前将其删除。这提高了稳定性，但不能解决跳过问题。

另一个更新：

如果您在意，Android 媒体堆栈如下所示：

媒体播放器.java
 -> android_media_MediaPlayer.cpp
 -> 媒体播放器.cpp
 -> IMediaPlayer.cpp
 -> MediaPlayerService.cpp
 -> BnMediaPlayerService.cpp
 -> IMediaPlayerService.cpp
 -> *具体媒体播放器*
 -> *BaseMediaPlayer*（Stagefright、NuPlayerDriver、Midi 等）
 -> *real MediaPlayerProxy*（AwesomePlayer、NuPlayer 等）
 -> *RealMediaPlayer*（AwesomePlayerSource、NuPlayerDecoder 等）
  -> 编解码器
  -> 硬件/软件解码器

在检查 AwesomePlayer 时，看起来这个很棒的播放器会在您出现以下情况时冒昧地为您暂停自己setSurface()：

status_t AwesomePlayer::setNativeWindow_l(const sp<ANativeWindow> &native) {
    mNativeWindow = native;

    if (mVideoSource == NULL) {
        return OK;
    }

    ALOGV("attempting to reconfigure to use new surface");

    bool wasPlaying = (mFlags & PLAYING) != 0;

    pause_l();
    mVideoRenderer.clear();

    shutdownVideoDecoder_l();

    status_t err = initVideoDecoder();

    if (err != OK) {
        ALOGE("failed to reinstantiate video decoder after surface change.");
        return err;
    }

    if (mLastVideoTimeUs >= 0) {
        mSeeking = SEEK;
        mSeekTimeUs = mLastVideoTimeUs;
        modifyFlags((AT_EOS | AUDIO_AT_EOS | VIDEO_AT_EOS), CLEAR);
    }

    if (wasPlaying) {
        play_l();
    }

    return OK;
}

这表明设置表面将导致播放器破坏之前使用的任何表面以及视频解码器。虽然将表面设置为 null 不应导致音频停止，但将其设置为新表面需要重新初始化视频解码器，并且播放器需要寻找视频中的当前位置。按照惯例，搜索永远不会比您请求的更远，也就是说，如果您在搜索时超出了关键帧，您应该降落在您超出的帧上（而不是下一个）。

因此，我的假设是，Android MediaPlayer 不遵守此约定，并在搜索时跳转到下一个关键帧。再加上关键帧稀疏的视频源，可以解释我正在经历的跳跃。不过，我还没有看过 AwesomePlayer 的 seek 实现。有人向我提到，如果您的 MediaPlayer 是在考虑流式传输的情况下开发的，那么跳转到下一个关键帧是需要发生的事情，因为流一旦被消耗就可以被丢弃。重点是，认为 MediaPlayer 会选择向前跳跃而不是向后跳跃可能并不是那么牵强。

最终更新：

虽然我仍然不知道为什么在附加一个新Surface的作为 a 的显示时播放会跳过MediaPlayer，但由于接受了答案，我已经让播放在旋转过程中无缝。

4

2 回答 2

7

感谢 natz0r 的回答，我已经设法使所描述的设置正常工作。但是，我使用了一种稍微不同的方法。我将在这里详细说明以供参考。

我有一个Fragment我标记为在配置更改时保留的。这个片段处理媒体播放（MediaPlayer）和标准TextureView（它提供了SurfaceTexture视频缓冲区被转储的位置）。只有在我的 Activity 完成 onResume() 并且 SurfaceTexture 可用时，我才初始化媒体播放。一旦收到对 SurfaceTexture 的引用，我只需在片段中调用 setSurfaceTexture（因为它是公共的），而不是继承 TextureView。发生配置更改时唯一保留的两件事是 MediaPlayer 引用和 SurfaceTexture 引用。

我已将示例项目的源代码上传到 Github。随意看看！

于 2013-12-09T20:32:41.650 回答
5

我知道这个问题现在有点老了，但我能够在我的应用程序中使用它而无需跳过。问题是表面被破坏（杀死其中的任何缓冲区）。这可能无法解决您的所有问题，因为它以 API 16 为目标，但您可以在绘制视频SurfaceTexture的自定义内部管理自己的问题：TextureView

private SurfaceTexture mTexture;

    private TextureView.SurfaceTextureListener mSHCallback =
            new TextureView.SurfaceTextureListener() {
                @Override
                public void onSurfaceTextureAvailable(SurfaceTexture surface, int width,
                        int height) {
                    mTexture = surface;
                    mPlayer.setSurface(new Surface(mTexture));
                }

                @Override
                public void onSurfaceTextureSizeChanged(SurfaceTexture surface, int width,
                        int height) {
                    mTexture = surface;
                }

                @Override
                public boolean onSurfaceTextureDestroyed(SurfaceTexture surface) {
                    mTexture = surface;
                    return false;
                }

                @Override
                public void onSurfaceTextureUpdated(SurfaceTexture surface) {
                    mTexture = surface;
                }
            };

关键是返回 falseonSurfaceTextureDestroyed并坚持 mTexture。当视图重新连接到窗口时，您可以设置表面纹理：

    @Override
    protected void onAttachedToWindow() {
        super.onAttachedToWindow();
        if (mTexture != null) {
            setSurfaceTexture(mTexture);
        }
    }

这允许我的视图继续从它停止的地方继续播放视频。

于 2013-11-27T22:02:14.887 回答