Android VideoView 方向随着缓冲视频而变化

Question

我正在尝试复制 Android 市场中最新 YouTube 应用的功能。观看视频时，有两种独立的布局，一种是纵向布局，提供附加信息，另一种是横向布局，提供视频的全屏视图。

纵向模式下的 YouTupe 应用

横向模式下的 YouTube 应用

（对于照片的随机性，我们深表歉意，但它们是我能找到的第一张实际布局的图片）

这通常很容易完成 - 只需在布局中指定替代布局即可-土地和一切都会好起来的。 YouTube 应用程序做得非常好的（也是我试图复制的）是，在方向改变时，视频会继续播放，而不必从头开始重新缓冲。

我发现重写 onConfigurationChange() 并设置新的 LayoutParameters 将允许我在不强制重新缓冲的情况下调整视频大小 - 但是，当多次旋转屏幕时，视频将随机缩放到不同的宽度/高度。我尝试过在 VideoView 上执行各种 invalidate() 调用，尝试在父relativeLayout 容器上调用 RequestLayout() 并尝试尽可能多的不同操作，但我似乎无法让它正常工作。任何建议将不胜感激！

这是我的代码：

@Override
public void onConfigurationChanged(Configuration newConfig) {
    super.onConfigurationChanged(newConfig);
    if (newConfig.orientation == Configuration.ORIENTATION_LANDSCAPE) {
        questionText.setVisibility(View.GONE);
        respond.setVisibility(View.GONE);
        questionVideo.setLayoutParams(new RelativeLayout.LayoutParams(LayoutParams.FILL_PARENT, LayoutParams.FILL_PARENT));
    } else {
        questionText.setVisibility(View.VISIBLE);
        respond.setVisibility(View.VISIBLE);
        Resources r = getResources();
        int height = (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 150.0f, r.getDisplayMetrics());
        questionVideo.setLayoutParams(new RelativeLayout.LayoutParams(LayoutParams.FILL_PARENT, height));
    }
}

编辑：我在 logcat 中发现了一些有趣的输出，当我的视频旋转时，这似乎是罪魁祸首 - 尽管我不知道如何修复它：

正确调整大小时的 Logcat 输出（需要整个窗口）

注意 h=726

12-13 15:37:35.468  1262  1270 I ActivityManager: Config changed: { scale=1.0 imsi=310/4 loc=en_US touch=3 keys=1/1/2 nav=1/1 orien=2 layout=34 uiMode=17 seq=210}
12-13 15:37:35.561  1262  1268 I TIOverlay: Position/X0/Y76/W480/H225
12-13 15:37:35.561  1262  1268 I TIOverlay: Adjusted Position/X1/Y0/W403/H225
12-13 15:37:35.561  1262  1268 I TIOverlay: Rotation/90
12-13 15:37:35.561  1262  1268 I Overlay : v4l2_overlay_set_position:: w=480 h=224
12-13 15:37:35.561  1262  1268 I Overlay : v4l2_overlay_set_position:: w=402 h=726
12-13 15:37:35.561  1262  1268 I Overlay : dumping driver state:
12-13 15:37:35.561  1262  1268 I Overlay : output pixfmt:
12-13 15:37:35.561  1262  1268 I Overlay : w: 432
12-13 15:37:35.561  1262  1268 I Overlay : h: 240
12-13 15:37:35.561  1262  1268 I Overlay : color: 7
12-13 15:37:35.561  1262  1268 I Overlay : UYVY
12-13 15:37:35.561  1262  1268 I Overlay : v4l2_overlay window:
12-13 15:37:35.561  1262  1268 I Overlay : window l: 1 
12-13 15:37:35.561  1262  1268 I Overlay : window t: 0 
12-13 15:37:35.561  1262  1268 I Overlay : window w: 402 
12-13 15:37:35.561  1262  1268 I Overlay : window h: 726

错误调整大小时的 Logcat 输出（占据全屏的一小部分）

注意 h=480

12-13 15:43:00.085  1262  1270 I ActivityManager: Config changed: { scale=1.0 imsi=310/4 loc=en_US touch=3 keys=1/1/2 nav=1/1 orien=2 layout=34 uiMode=17 seq=216}
12-13 15:43:00.171  1262  1268 I TIOverlay: Position/X0/Y76/W480/H225
12-13 15:43:00.171  1262  1268 I TIOverlay: Adjusted Position/X138/Y0/W266/H225
12-13 15:43:00.171  1262  1268 I TIOverlay: Rotation/90
12-13 15:43:00.179  1262  1268 I Overlay : v4l2_overlay_set_position:: w=480 h=224
12-13 15:43:00.179  1262  1268 I Overlay : v4l2_overlay_set_position:: w=266 h=480
12-13 15:43:00.179  1262  1268 I Overlay : dumping driver state:
12-13 15:43:00.179  1262  1268 I Overlay : output pixfmt:
12-13 15:43:00.179  1262  1268 I Overlay : w: 432
12-13 15:43:00.179  1262  1268 I Overlay : h: 240
12-13 15:43:00.179  1262  1268 I Overlay : color: 7
12-13 15:43:00.179  1262  1268 I Overlay : UYVY
12-13 15:43:00.179  1262  1268 I Overlay : v4l2_overlay window:
12-13 15:43:00.179  1262  1268 I Overlay : window l: 138 
12-13 15:43:00.179  1262  1268 I Overlay : window t: 0 
12-13 15:43:00.179  1262  1268 I Overlay : window w: 266 
12-13 15:43:00.179  1262  1268 I Overlay : window h: 480

也许有人知道“Overlay”是什么以及为什么它是没有得到正确的高度值？

Answer 1

编辑：（2016 年 6 月）

这个答案非常旧（我认为 android 2.2/2.3），可能不如下面的其他答案那么相关！除非您在旧版 Android 上进行开发，否则请首先查看它们:)

---

我能够将问题范围缩小到 VideoView 类中的 onMeasure 函数。通过创建一个子类并重写 onMeasure 函数，我能够获得所需的功能。

public class VideoViewCustom extends VideoView {

    private int mForceHeight = 0;
    private int mForceWidth = 0;
    public VideoViewCustom(Context context) {
        super(context);
    }

    public VideoViewCustom(Context context, AttributeSet attrs) {
        this(context, attrs, 0);
    }

    public VideoViewCustom(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
    }

    public void setDimensions(int w, int h) {
        this.mForceHeight = h;
        this.mForceWidth = w;

    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        Log.i("@@@@", "onMeasure");

        setMeasuredDimension(mForceWidth, mForceHeight);
    }
}

然后在我的 Activity 中，我做了以下操作：

@Override
public void onConfigurationChanged(Configuration newConfig) {
    super.onConfigurationChanged(newConfig);

    if (newConfig.orientation == Configuration.ORIENTATION_LANDSCAPE) {
        getWindow().clearFlags(WindowManager.LayoutParams.FLAG_FORCE_NOT_FULLSCREEN);
        getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);

        questionVideo.setDimensions(displayHeight, displayWidth);
        questionVideo.getHolder().setFixedSize(displayHeight, displayWidth);

    } else {
        getWindow().setFlags(WindowManager.LayoutParams.FLAG_FORCE_NOT_FULLSCREEN, WindowManager.LayoutParams.FLAG_FORCE_NOT_FULLSCREEN);

        questionVideo.setDimensions(displayWidth, smallHeight);
        questionVideo.getHolder().setFixedSize(displayWidth, smallHeight);

    }
}

该行：

questionVideo.getHolder().setFixedSize(displayWidth, smallHeight);

是完成这项工作的关键。如果您在没有此人的情况下执行 setDimensions 调用，视频仍然不会调整大小。

您需要做的唯一的另一件事是确保您也在 onCreate() 方法内调用 setDimensions() ，否则您的视频将不会开始缓冲，因为视频不会设置为在任何尺寸的表面上绘制。

// onCreate()
questionVideo.setDimensions(initialWidth, initialHeight); 

最后一个关键部分 - 如果您发现自己想知道为什么 VideoView 在旋转时不调整大小，则需要确保要调整大小的尺寸完全相等到可见区域或小于它。我遇到了一个非常大的问题，当我在屏幕上仍然有通知栏/标题栏并且它根本没有调整 VideoView 的大小时，我将 VideoView 的宽度/高度设置为整个显示尺寸。只需删除通知栏和标题栏即可解决问题。

希望这对将来的人有帮助！

Answer 2

这是一种非常简单的方法，可以用最少的代码完成您想要的任务：

AndroidManifest.xml：

android:configChanges="orientation|keyboard|keyboardHidden|screenSize|screenLayout|uiMode"

注意：根据您的 API 需要进行编辑，这涵盖了 10+，但较低的 API 需要删除此行的“screenSize | screenLayout | uiMode”部分

在“OnCreate”方法内，通常在“super.onCreate”下，添加：

getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
            WindowManager.LayoutParams.FLAG_FULLSCREEN);

然后在某个地方，通常在底部，添加：

@Override
public void onConfigurationChanged(Configuration newConfig) {
    super.onConfigurationChanged(newConfig);
    getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
            WindowManager.LayoutParams.FLAG_FULLSCREEN);
}

当方向发生变化时，这会将视频大小调整为全屏，而不会中断播放，只需要覆盖配置方法。

Answer 3

首先，非常感谢您自己的广泛回答。

我遇到了同样的问题，旋转后视频在大多数情况下会变小、变大或在 VideoView 内扭曲。

我尝试了你的解决方案，但我也尝试了随机的事情，并且偶然我注意到，如果我的 VideoView 位于其父级的中心，它会神奇地自行工作（不需要自定义 VideoView 或任何东西）。

更具体地说，使用这种布局，我大多数时候都会重现问题：

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent" >

    <VideoView
        android:id="@+id/videoView"
        android:layout_width="match_parent"
        android:layout_height="match_parent" />

</RelativeLayout>

使用这种布局，我从来没有遇到过问题（另外，视频居中，无论如何它应该是这样的；）：

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent" >

    <VideoView
        android:id="@+id/videoView"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:layout_centerInParent="true" />

</RelativeLayout>

它也适用于wrap_content 而不是 match_parent （视频仍然占据所有空间），这对我来说没有多大意义。

不管怎样，我对此没有任何解释 - 这对我来说看起来像是一个 VideoView 错误。

Answer 4

VideoView 使用所谓的覆盖层，这是渲染视频的区域。该覆盖层位于包含 VideoView 的窗口后面。 VideoView 在其窗口中打一个洞，以便覆盖层可见。然后它使其与布局保持同步（例如，如果您移动 VideoView 或调整其大小，则覆盖层也必须移动并调整大小）。

在布局阶段存在一个错误，导致覆盖层使用 VideoView 设置的先前大小。

要修复此问题，请子类化 VideoView 并重写 onLayout:

@Override
protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
    super.onLayout(changed, left, top, right, bottom);
    getHolder().setSizeFromLayout();
}

，并且叠加层将具有 VideoView 布局尺寸的正确尺寸。

Answer 5

通过复制 YouTube 应用程序，

我成功构建了一个不需要 android:configChanges="orientation" 或自定义 VideoView 的示例项目。由此产生的体验与 YouTube 应用在视频播放期间处理旋转的方式相同。换句话说，视频不需要暂停、重新缓冲或重新加载，并且在设备方向改变时不会跳过或丢弃任何音频帧。

最佳方法

此方法使用TextureView 及其附带的SurfaceTexture 作为MediaPlayer 当前视频帧的接收器。由于 SurfaceTexture 使用 GL 纹理对象（仅由 GL 上下文中的整数引用），因此相信可以通过配置更改保留对 SurfaceTexture 的引用。在配置更改期间（以及支持的 Activity），TextureView 本身会被销毁并重新创建，新创建的 TextureView 在附加之前只需使用 SurfaceTexture 引用进行更新。

我创建了一个 完整的工作示例，展示了如何以及何时初始化 MediaPlayer 和可能的 MediaController，并且我下面将重点介绍与此问题相关的有趣部分：

public class VideoFragment {
    
    TextureView mDisplay;
    SurfaceTexture mTexture;

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

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        
        final View rootView = inflater.inflate(R.layout.fragment_main, container, false);
        mDisplay = (TextureView) rootView.findViewById(R.id.texture_view);
        if (mTexture != null) {
            mDisplay.setSurfaceTexture(mTexture);
        }
        mDisplay.setSurfaceTextureListener(mTextureListener);

        return rootView;
    }

    TextureView.SurfaceTextureListener mTextureListener = new TextureView.SurfaceTextureListener() {
        @Override
        public void onSurfaceTextureAvailable(SurfaceTexture surface, int width, int height) {
            mTexture = surface;
            // Initialize your media now or flag that the SurfaceTexture is available..
        }

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

        @Override
        public boolean onSurfaceTextureDestroyed(SurfaceTexture surface) {
            mTexture = surface;
            return false; // this says you are still using the SurfaceTexture..
        }

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

    @Override
    public void onDestroyView() {
        mDisplay = null;
        super.onDestroyView();
    }

    // ...

}
 

由于该解决方案使用保留的片段而不是手动处理配置更改的活动，因此您可以自然地充分利用配置特定的资源膨胀系统。不幸的是，如果您的最低 sdk 低于 API 16，您基本上需要向后移植 TextureView （我还没有这样做）。

最后，如果您有兴趣，查看我的初始问题详细说明：我最初的方法、Android 媒体堆栈、它不起作用的原因以及替代解决方法。

Answer 6

使用这个：

@Override
    public void onConfigurationChanged(Configuration newConfig) {
        super.onConfigurationChanged(newConfig);

        if (newConfig.orientation == Configuration.ORIENTATION_LANDSCAPE) {

            getActivity().getWindow().addFlags(
                    WindowManager.LayoutParams.FLAG_FULLSCREEN);
            getActivity().getWindow().clearFlags(
                    WindowManager.LayoutParams.FLAG_FORCE_NOT_FULLSCREEN);

        } else if (newConfig.orientation == Configuration.ORIENTATION_PORTRAIT) {

            getActivity().getWindow().addFlags(
                    WindowManager.LayoutParams.FLAG_FORCE_NOT_FULLSCREEN);
            getActivity().getWindow().clearFlags(
                    WindowManager.LayoutParams.FLAG_FULLSCREEN);

        }
    }

也不要忘记将下面的行添加到清单中的活动中：

android:configChanges="orientation|keyboard|keyboardHidden|screenSize"

Answer 7

我从这里的一些答案中举了一些例子，并尝试按照我的方式来做。看起来是一个简单的解决方案。

videoLayout = (RelativeLayout) videoView.findViewById(R.id.videoFrame);

片段内的 onConfigurationChange。其中视频以横向模式全屏显示。请注意，我隐藏了操作栏。

@Override
public void onConfigurationChanged(Configuration newConfig) {

    int          height     = (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 200.0f,getResources().getDisplayMetrics());
    ActionBar    actionBar  = weatherActivity.getSupportActionBar();
    LayoutParams params     = videoLayout.getLayoutParams();

    if(newConfig.orientation == Configuration.ORIENTATION_LANDSCAPE)
    {
        if(actionBar.isShowing())
            actionBar.hide();


        params.width  = ViewGroup.LayoutParams.MATCH_PARENT;
        params.height = ViewGroup.LayoutParams.MATCH_PARENT;

        videoLayout.requestLayout();
    }
    else if(newConfig.orientation == Configuration.ORIENTATION_PORTRAIT)
    {
        if(!actionBar.isShowing())
            actionBar.show();

        params.width  = ViewGroup.LayoutParams.MATCH_PARENT;
        params.height = height;

        videoLayout.requestLayout();
    }

    super.onConfigurationChanged(newConfig);
}   

这是我的布局文件

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

<RelativeLayout 
    android:id="@+id/videoFrame"
    android:layout_height="200dp"
    android:layout_width="match_parent">

    <VideoView
        android:id="@+id/video"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:layout_centerHorizontal="true"/>

</RelativeLayout>

，下面有另一个相对布局，它不在这个布局中。但这不会有任何区别。

Answer 8

请参阅我的示例代码，它对我有用

public class CustomVideoView extends android.widget.VideoView {
private int width;
private int height;
private Context context;
private VideoSizeChangeListener listener;
private boolean isFullscreen;

public CustomVideoView(Context context) {
    super(context);
    init(context);
}

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

/**
 * get video screen width and height for calculate size
 *
 * @param context Context
 */
private void init(Context context) {
    this.context = context;
    setScreenSize();
}

/**
 * calculate real screen size
 */
private void setScreenSize() {
    Display display = ((Activity) context).getWindowManager().getDefaultDisplay();

    if (Build.VERSION.SDK_INT >= 17) {
        //new pleasant way to get real metrics
        DisplayMetrics realMetrics = new DisplayMetrics();
        display.getRealMetrics(realMetrics);
        width = realMetrics.widthPixels;
        height = realMetrics.heightPixels;

    } else if (Build.VERSION.SDK_INT >= 14) {
        //reflection for this weird in-between time
        try {
            Method mGetRawH = Display.class.getMethod("getRawHeight");
            Method mGetRawW = Display.class.getMethod("getRawWidth");
            width = (Integer) mGetRawW.invoke(display);
            height = (Integer) mGetRawH.invoke(display);
        } catch (Exception e) {
            //this may not be 100% accurate, but it's all we've got
            width = display.getWidth();
            height = display.getHeight();
        }

    } else {
        //This should be close, as lower API devices should not have window navigation bars
        width = display.getWidth();
        height = display.getHeight();
    }

    // when landscape w > h, swap it
    if (width > height) {
        int temp = width;
        width = height;
        height = temp;
    }
}

/**
 * set video size change listener
 *
 */
public void setVideoSizeChangeListener(VideoSizeChangeListener listener) {
    this.listener = listener;
}

public interface VideoSizeChangeListener {
    /**
     * when landscape
     */
    void onFullScreen();

    /**
     * when portrait
     */
    void onNormalSize();
}

@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    if (context.getResources().getConfiguration().orientation == Configuration.ORIENTATION_LANDSCAPE) {
        // full screen when landscape
        setSize(height, width);
        if (listener != null) listener.onFullScreen();
        isFullscreen = true;
    } else {
        // height = width * 9/16
        setSize(width, width * 9 / 16);
        if (listener != null) listener.onNormalSize();
        isFullscreen = false;
    }
}

/**
 * @return true: fullscreen
 */
public boolean isFullscreen() {
    return isFullscreen;
}

/**
 * set video sie
 *
 * @param w Width
 * @param h Height
 */
private void setSize(int w, int h) {
    setMeasuredDimension(w, h);
    getHolder().setFixedSize(w, h);
}
}

，并且在更改方向时不会重新创建视图

// AndroidManifest.xml
android:configChanges="screenSize|orientation|keyboardHidden"

风景

<强>我的源代码在这里

Answer 9

虽然 Mark37 的（非常有用）答案确实有效，但它需要手动设置尺寸（使用 setDimensions）。这在预先知道所需尺寸的应用程序中可能没问题，但如果您希望视图根据视频参数自动确定尺寸（例如，确保保留原始宽高比），则需要采用不同的方法。

幸运的是，事实证明 setDimensions 部分实际上并不是必需的。 VideoView 的 onMeasure 已经包含了所有必要的逻辑，因此不必依赖某人调用 setDimensions，只需调用 super.onMeasure，然后使用视图的getMeasuredWidth/getMeasuredHeight 获取固定大小。

因此，VideoViewCustom 类变得简单：

public class VideoViewCustom extends VideoView {

    public VideoViewCustom(Context context) {
        super(context);
    }

    public VideoViewCustom(Context context, AttributeSet attrs) {
        this(context, attrs, 0);
    }

    public VideoViewCustom(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
        getHolder().setFixedSize(getMeasuredWidth(), getMeasuredHeight());
    }
}

此版本不需要调用者中的任何额外代码，并充分利用 VideoView 现有的 onMeasure 实现。

这实际上与 Zapek 建议的 方法 非常相似，它基本上做同样的事情，只是使用 onLayout 而不是 onMeasure 。

Answer 10

简单的答案和最新的 2018 年。

此答案的优点：代码如下

1) 无论您是否设置为 FULL_SCREEN 都没有关系。因为它与父级匹配，所以它总是有效的。在旧的接受答案中，如果您不设置为 FULL_SCREEN，android 将采用整个手机大小，然后 VideoView 将位于屏幕之外；

2）不需要创建Custom VideoView或PlayerView；

3）它不会多次调用该方法。在旧的接受的答案中，它多次不必要地调用Measure；

4）还有一个像youtube app一样改变方向的按钮；

5) 将手机的自动旋转设置为关闭也会阻止应用程序方向更改。

@Nullable
@Override
public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
    ...
    setPlayerViewLayoutParams();
    ...
}

@Override
public void onConfigurationChanged(Configuration newConfig) {
    super.onConfigurationChanged(newConfig);
    if (newConfig.orientation == Configuration.ORIENTATION_LANDSCAPE) {
        setPlayerViewLayoutParamsForLandScape();
    } else {
        setPlayerViewLayoutParamsForPortrait();
    }
}

private void setPlayerViewLayoutParamsForLandScape() {
    ConstraintLayout.LayoutParams lp = new ConstraintLayout.LayoutParams(
            ConstraintLayout.LayoutParams.MATCH_PARENT, ConstraintLayout.LayoutParams.MATCH_PARENT);
    mPlayerView.setLayoutParams(lp);
}

private void setPlayerViewLayoutParamsForPortrait() {
    Display display = myContext.getWindowManager().getDefaultDisplay();
    Point size = new Point();
    display.getSize(size);
    int width = size.x;
    Double doubleHeight = width / 1.5;
    Integer height = doubleHeight.intValue();

    ConstraintLayout.LayoutParams lp = new ConstraintLayout.LayoutParams(
            ConstraintLayout.LayoutParams.MATCH_PARENT, height);
    mPlayerView.setLayoutParams(lp);
}

private void setPlayerViewLayoutParams() {
    if (myContext.getResources().getConfiguration().orientation == Configuration.ORIENTATION_LANDSCAPE) {
        setPlayerViewLayoutParamsForLandScape();
    } else {
        setPlayerViewLayoutParamsForPortrait();
    }
}

OBS：我在 ConstraintLayout 中使用 PlayerView。因为我正在使用 ExoPlayer 媒体库。

fragment_player.xml

<android.support.constraint.ConstraintLayout   
xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
xmlns:app="http://schemas.android.com/apk/res-auto">

<com.google.android.exoplayer2.ui.PlayerView
    android:id="@+id/player_view"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="@color/colorBlack"
    app:layout_constraintStart_toStartOf="parent"
    app:layout_constraintEnd_toEndOf="parent"
    app:layout_constraintTop_toTopOf="parent"
    app:layout_constraintBottom_toBottomOf="parent"
    app:layout_constraintVertical_bias="0.0"/>

</android.support.constraint.ConstraintLayout>

附加

我还想要一个更改方向的按钮

要完全重现 youtube 应用程序，您可能需要一个按钮来将播放器设置为横向或纵向，如果用户手机的自动旋转关闭，这非常有用。

首先，您需要执行以下步骤：

1. 创建将更改方向的按钮；
2. 当用户点击按钮时，检查当前方向；
3. 设置为相反方向，例如，如果当前处于横向模式，则设置为纵向。

PlayerFragment.java

@Override
public void onClick(View v) {
    switch (v.getId()) {
        case R.id.image_button_full_screen:
            if (myContext.getResources().getConfiguration().orientation 
                == Configuration.ORIENTATION_LANDSCAPE) {
                myContext.setRequestedOrientation(
                        ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT);
            } else {
                myContext.setRequestedOrientation(
                        ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE);
            }
            break;
    }
}

问题 1：旋转设备不再起作用

您会注意到，如果单击按钮更改方向，旋转设备将不再起作用更改播放器大小。发生这种情况是因为您以编程方式将方向设置为横向或纵向，并且它将永远保持这样，因此您需要一种方法将方向设置为传感器，这样当您旋转设备时，它会检查当前的真实方向。下面的方法将为您做到。

问题2：手机自动旋转关闭后仍然改变方向

在下面的方法中，您需要检查手机的自动旋转是打开还是关闭，如果是打开，您可以将方向设置为传感器，因此当用户旋转设备时手机将能够改变方向。如果自动旋转关闭，您将不执行任何操作，因此方向将在纵向或横向中被阻止，具体取决于用户是否按下全屏按钮。

private void setOrientationListener() {
    OrientationEventListener orientationEventListener = new OrientationEventListener(this) {
        @Override
        public void onOrientationChanged(int orientation) {
            // 94 > 90 - 10 and 94 < 90 + 10     //   80 < orientation < 100.  Rotating to the LEFT.
            // 278 > 270 - 10 and 278 < 270 + 10 //   260 < orientation < 280. Rotating to the RIGHT.
            int epsilon = 10;
            int leftLandscape = 90;
            int rightLandscape = 270;
            if (epsilonCheck(orientation, leftLandscape, epsilon) ||
                    epsilonCheck(orientation, rightLandscape, epsilon)) {
                if (android.provider.Settings.System.getInt(getContentResolver(),
                        Settings.System.ACCELEROMETER_ROTATION, 0) == 1) {
                    // Phone's auto rotation is ON
                    setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_SENSOR);
                }
            }
        }

        private boolean epsilonCheck(int a, int b, int epsilon) {
            return a > b - epsilon && a < b + epsilon;
        }
    };
    orientationEventListener.enable();
}

如果您使用媒体应用程序，我有一个 示例，它将指导您如何强大地使用 Exoplayer图书馆。

Answer 11

我尝试使用其他答案的代码，但它没有解决我的问题，因为如果我快速旋转屏幕，我的视频尺寸就会增大。所以我部分使用了他们的代码，我将其放入一个线程中，该线程可以非常快速地更新窗口。
所以，这是我的代码：

  new Thread(new Runnable()
    {
        @Override
        public void run()
        {
            while(true)
            {
                try
                {
                    Thread.sleep(1);
                }
                catch(InterruptedException e){}
                handler.post(new Runnable()
                {
                    @Override
                    public void run()
                    {
                        getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
                                WindowManager.LayoutParams.FLAG_FULLSCREEN);
                    }
                });
            }
        }
    }).start();

这样，视频大小将始终正确（就我而言）。