旋转Android VideoView

Question

我的应用程序仅提供竖屏模式。在竖屏活动中，我有一个全屏的VideoView。我想做的是在横屏模式下旋转VideoView（实际视频、视频缓冲区）90度。不允许启用横屏模式。扩展VideoView和画布旋转不起作用，因为它是SurfaceView而不是实际的视图。是否有任何方法可以通过VideoView实现这一点？

- weakwire

---

为什么当你想要横屏模式时，它不是一个选项呢？ - TouchBoarder

Answer 1

VideoView不支持视频旋转，即使组合矩阵设置正确并使用旋转属性也不行。

您可以使用TextureView，并设置其属性rotation="90"（例如）。它将旋转帧但纵横比需要您自己处理。为此，您可以使用textureView.setScaleX((screenHeight * 1.0f) / screenWidth)

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent" >

    <TextureView
        android:id="@+id/playback_video"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:layout_centerInParent="true"
        android:rotation="90" />
</RelativeLayout>

它也应该能处理流媒体视频。但请把它视为示例而不是可以发布的代码。我重命名了一些内容并删除了其他内容，它们与问题无关，这可能会破坏一些东西，但总的来说这是可行的示例。

public class PlaybackActivity extends Activity implements MediaPlayer.OnErrorListener, OnPreparedListener,
        OnCompletionListener, OnVideoSizeChangedListener, OnBufferingUpdateListener, OnInfoListener,
        SurfaceTextureListener
{

    private MediaPlayer mediaPlayer;
    private TextureView videoView;
    private boolean startedPlayback = false;
    private boolean playerReady = false;
    public static final int MEDIA_INFO_NETWORK_BANDWIDTH = 703;

    private void createMediaPlayer() {
        mediaPlayer = new MediaPlayer();
    }

    private void releaseMediaPlayer() {
        if (mediaPlayer != null) {
            mediaPlayer.setSurface(null);
            mediaPlayer.release();
            mediaPlayer = null;
        }
    }

    public void onCompletion(MediaPlayer mp) {
        Log.w(TAG, "Video playback finished");
    }

    @Override
    public boolean onError(MediaPlayer player, int what, int extra) {
        if (what == MediaPlayer.MEDIA_ERROR_UNKNOWN) {
            /*
             * Restart play back in case we did not start anything yet. This may
             * be the case when we tried to tune in in very first secs of the
             * broadcast when there is no data yet.
             */
            if (liveBroadcast && mediaPlayer != null && !mediaPlayer.isPlaying() && !startedPlayback) {
                if (checkCount-- > 0) {
                    mediaPlayer.reset();
                    checkBroadcast();
                } else {
                    Log.w(TAG, "Broadcast finished");
                }
            } else {
                Log.w(TAG, "No media in stream");
            }
        } else if (what == MediaPlayer.MEDIA_ERROR_SERVER_DIED) {
            Log.w(TAG, "Media service died unexpectedly");
        } else {
            Log.w(TAG, "Unknown media error");
        }
        return true;
    }

   @Override
    public boolean onInfo(MediaPlayer mp, int what, int extra) {
        switch (what) {
        case MediaPlayer.MEDIA_INFO_VIDEO_TRACK_LAGGING:
            Log.w(TAG, "Media is too complex to decode it fast enough.");
            startedPlayback = true;
            break;
        case MEDIA_INFO_NETWORK_BANDWIDTH:
            Log.w(TAG, "Bandwith in recent past.");
            break;
        case MediaPlayer.MEDIA_INFO_BUFFERING_START:
            Log.w(TAG, "Start of media bufferring.");
            startedPlayback = true;
            break;
        case MediaPlayer.MEDIA_INFO_BUFFERING_END:
            Log.w(TAG, "End of media bufferring.");
            startedPlayback = true;
            break;
        case MediaPlayer.MEDIA_INFO_BAD_INTERLEAVING:
            Log.w(TAG, "Media is not properly interleaved.");
            break;
        case MediaPlayer.MEDIA_INFO_NOT_SEEKABLE:
            Log.w(TAG, "Stream is not seekable.");
            break;
        case MediaPlayer.MEDIA_INFO_METADATA_UPDATE:
            Log.w(TAG, "New set of metadata is available.");
            break;
        case MediaPlayer.MEDIA_INFO_UNKNOWN:
        default:
            Log.w(TAG, "Unknown playback info (" + what + ":" + extra + ").");
            break;
        }
        return true;
    }

    private void startPlayback() {
        if (mediaPlayer != null) {
            onLoaded(mediaPlayer);
            mediaPlayer.start();
        }
    }

    private void pausePlayback() {
        if (mediaPlayer != null && mediaPlayer.isPlaying())
            mediaPlayer.pause();
    }

    private void resumePlayback() {
        if (mediaPlayer != null && mediaPlayer.isPlaying())
            mediaPlayer.start();
    }

    private void onLoaded(MediaPlayer mp) {
    }

    public void onPrepared(MediaPlayer mp) {
        playerReady = true;
        startPlayback();
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
        setContentView(R.layout.playback);
        videoView = (TextureView) findViewById(R.id.playback_video);
        videoView.setOnClickListener(videoViewClickHandler);
        videoView.setSurfaceTextureListener(this);
        createMediaPlayer();
    }

   @Override
    protected void onDestroy() {
        releaseMediaPlayer();
        if (surface != null) {
            surface.release();
            surface = null;
        }
        super.onDestroy();
    }

    @Override
    public void onSurfaceTextureAvailable(SurfaceTexture surface, int width, int height) {
        this.surface = new Surface(surface);
        loadMedia(someurl);
    }

    @Override
    public boolean onSurfaceTextureDestroyed(SurfaceTexture surface) {
        if (this.surface != null) {
            releaseMediaPlayer();
            this.surface.release();
            this.surface = null;
        }
        return true;
    }

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

    @Override
    public void onSurfaceTextureUpdated(SurfaceTexture surface) {
    }

    @Override
    public void onVideoSizeChanged(MediaPlayer mp, int w, int h) {
        if (w > 0 && h > 0 && !videoSizeSetupDone) {
            Log.w(TAG, "Video size changed: " + w + "x" + h);
            changeVideoSize(w, h);
        }
    }

    private boolean videoSizeSetupDone = false;

    private void changeVideoSize(int width, int height) {
        DisplayMetrics metrics = new DisplayMetrics();
        RelativeLayout.LayoutParams params;

        Utils.getScreenMetrics(this, metrics);
        VideoOrientation orientation = someVideoSource.getVideoOrientation();
        if (orientation == LANDSCAPE) {
            params = new RelativeLayout.LayoutParams(metrics.widthPixels, metrics.heightPixels);
        } else {
            float rotation = orientation == BroadcastVideoOrientation.BroadcastVideoFrontCamera ? -90.0f : 90.0f;
            params = new RelativeLayout.LayoutParams(metrics.heightPixels, metrics.widthPixels);
            float scale = (width * 1.0f) / (height * 1.0f);
            videoView.setRotation(rotation);
            videoView.setScaleX(scale);
        }
        params.addRule(RelativeLayout.CENTER_IN_PARENT, -1);
        videoView.setLayoutParams(params);
        videoSizeSetupDone = true;
    }

    private void loadMedia(String url) {
        if (surface == null)
            return;
        Log.d(App.TAG, "Loading url: " + url);

        startedPlayback = false;
        try {
            mediaPlayer.reset();
            mediaPlayer.setSurface(surface);
            mediaPlayer.setDataSource(url);
            mediaPlayer.setOnPreparedListener(this);
            mediaPlayer.setOnCompletionListener(this);
            mediaPlayer.setOnErrorListener(this);
            mediaPlayer.setOnVideoSizeChangedListener(this);
            mediaPlayer.setScreenOnWhilePlaying(true);
            mediaPlayer.setOnBufferingUpdateListener(this);
            mediaPlayer.setOnInfoListener(this);
            mediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);
            mediaPlayer.prepareAsync();
        } catch (Exception e) {
            Log.w(TAG, "Media load failed");
            Utils.alert(this, "Playback Error", e.getMessage(), finishHandler);
        }
    }
}

希望这能有所帮助。我寻找这个解决方案已经很长时间了。尝试过几乎所有的方法，这似乎是唯一的方法。

- Cynichniy Bandera

---

这是OpenGL纹理表面，你可以任意处理它，拉伸、镜像等。 - Cynichniy Bandera

@Umka，你能告诉我如何镜像预览吗？有代码示例吗？ - Aswathy

我记得我使用了setScaleX()和setScaleY()，并且值小于1。 - Cynichniy Bandera

这是相当标准的事情...没什么更多要说的。如果你看一下其他视频播放的例子，它们都在使用它。如果你再努力一点解释你真正需要知道的，我可能会告诉你更多)) - Cynichniy Bandera

你在Activity中实现哪个类，以便获得你在该类中实现的上述重写方法？ - Pradeep Sodhi

Answer 2

VideoView不支持旋转

您可以使用以下方法解决：

<com.warnyul.android.widget.FastVideoView
        android:rotation="45"
        android:layout_above="@+id/controller"
        android:id="@+id/video2"
        android:foregroundGravity="center"
        android:layout_centerHorizontal="true"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        />

必须将以下行添加到gradle的依赖项中：

implementation 'com.warnyul.android.fast-video-view:fast-video-view:1.0.2'

- A.Hosein

---

那真的很容易使用！谢谢！！ - mBarati

尝试在我的竖屏片段上获取横屏视频，我将FastVideoView旋转了90度，但无法使其拉伸到片段的全尺寸，视图保持旋转前的大小。 - Steven B.

Answer 3

 <TextureView
        android:id="@+id/VideoViewfull"
        android:layout_width="fill_parent"
        android:layout_height="fill_parent"
        android:rotation="90"
    /> 
mMediaPlayer.setOnVideoSizeChangedListener(newMediaPlayer.OnVideoSizeChangedListener() {
                @Override
                public void onVideoSizeChanged(MediaPlayer mp, int width, int height) {
                    if (width < height) {
//                        orientation = "vertical";
                        mTextureView.setRotation(90f);
                    } else {
                        DisplayMetrics displayMetrics = new DisplayMetrics();
                   getWindowManager().getDefaultDisplay().getMetrics(displayMetrics);
                        int sHeight = displayMetrics.heightPixels;
                        int sntWidth = displayMetrics.widthPixels;
                        FrameLayout.LayoutParams parms = 
                        new FrameLayout.LayoutParams(sHeight,sHeight); 
                        mTextureView.setLayoutParams(parms);
                    }
                }
            });

- kishan Umretiya

---

请问您能否解释一下答案，这段代码会做什么？这将有助于其他用户的参考。 - Suresh Karia

mTextureview在竖屏模式下设置旋转90度，视频只显示半个屏幕，因此这段代码逻辑上可以让横向视频在屏幕上播放而无需旋转屏幕。 - kishan Umretiya

它可以在不旋转手机的情况下全屏播放视频。 - kishan Umretiya

Answer 4

您可以在清单文件中单独设置活动的方向，因此您的视频可以在横向（和纵向）显示，而应用程序的其余部分则为纵向。请参见我的答案这里，以获取有关此解决方案的更多信息。

- TouchBoarder

---

这是一个很好的想法，但如果你想在片段中显示视频而不是全屏幕，则行不通。 - Guillaume Boudreau