全民K歌折叠屏适配探索

@Override
public void onSaveInstanceState(Bundle outState) {
    LogUtil.i(TAG, "onSaveInstanceState:" + this);
}

<meta-data
    android:name="android.max_aspect"
    android:value="2.7"/>
<meta-data
    android:name="android.min_aspect"
    android:value="1.0" />

<activity
    android:name="com.tencent.karaoke.module.detail.ui.DetailActivity"
    android:configChanges="keyboardHidden|orientation|screenSize|smallestScreenSize|screenLayout"
    android:screenOrientation="portrait"
    android:windowSoftInputMode="adjustResize"/>

// ViewRootImpl
public void updateConfiguration(int newDisplayId) {
    final int lastLayoutDirection = mLastConfigurationFromResources.getLayoutDirection();
    final int currentLayoutDirection = config.getLayoutDirection();
    mLastConfigurationFromResources.setTo(config);
    if (lastLayoutDirection != currentLayoutDirection
            && mViewLayoutDirectionInitial == View.LAYOUT_DIRECTION_INHERIT) {
        // 方向
        mView.setLayoutDirection(currentLayoutDirection);
    }
    // 屏幕配置变更通知
    mView.dispatchConfigurationChanged(config);
 
    // 发起一次重新测量
    requestLayout();
}

// 视频区域调整
val videoView = mViewHolder.mPlayScene.surfaceView
val videoParams = videoView.layoutParams as FrameLayout.LayoutParams
videoParams.width = displayAdapterResult.mVideoWidth
videoParams.height = displayAdapterResult.mVideoHeight
videoView.requestLayout()
 
// 外层布局高、宽调整
mViewHolder.mPlayScene.setPlayViewHeight(
    displayAdapterResult.mLayoutHeight,
    displayAdapterResult.mLayoutWidth
)

//屏幕宽px
private static int sScreenWidth = 0;
//屏幕高px
private static int sScreenHeight = 0;

static {
    WindowManager wm = (WindowManager) KaraokeContextBase.getApplication().getSystemService(Context.WINDOW_SERVICE);
    if (wm != null) {
        sScreenWidth = wm.getDefaultDisplay().getWidth();
        sScreenHeight = wm.getDefaultDisplay().getHeight();
    }
}

/**
 *
 * @return 屏幕宽度
 */
public static int getScreenWidth() {
    if (sScreenWidth == 0 || sScreenHeight == 0) {
        WindowManager wm = (WindowManager) KaraokeContextBase.getApplication().getSystemService(Context.WINDOW_SERVICE);
        if (wm != null) {
            sScreenWidth = wm.getDefaultDisplay().getWidth();
            sScreenHeight = wm.getDefaultDisplay().getHeight();
        }
    }
    return sScreenWidth;
}

/**
 * 刷新屏幕信息，如果失效的话
 */
private static void refreshOnInvalid() {
    final long time = SystemClock.elapsedRealtime();
    final boolean isOverdue = (time - SCREEN_REFRESH_TIMESTAMP) > REFRESH_INTERVAL;
    if (isOverdue || SCREEN_WIDTH_PIXELS <= 0 || SCREEN_HEIGHT_PIXELS <= 0) {
        final DisplayMetrics displayMetrics = getCurrentResources().getDisplayMetrics();
        SCREEN_WIDTH_PIXELS = displayMetrics.widthPixels;
        SCREEN_HEIGHT_PIXELS = displayMetrics.heightPixels;
        SCREEN_REFRESH_TIMESTAMP = time;
    }
}
public static int getScreenWidth() {
    refreshOnInvalid();
    return SCREEN_WIDTH_PIXELS;
}
public static int getScreenHeight() {
    refreshOnInvalid();
    return SCREEN_HEIGHT_PIXELS;
}

public class CustomView extends View {
    @Override
    protected void onConfigurationChanged(Configuration newConfig) {
        super.onConfigurationChanged(newConfig);
    }
}

// Fragment
@Override
public void onConfigurationChanged(@NonNull Configuration newConfig) {
    super.onConfigurationChanged(newConfig);
    DisplayUtil.notifyOnConfigurationChanged(this, newConfig);
}
 
// DisplayUtil
/**
 * 通知屏幕素质有变化
 */
public static void notifyOnConfigurationChanged(@NonNull Fragment fragment, @NonNull Configuration configuration) {
    // 使缓存失效，以便获取时得到最新的数据
    SCREEN_REFRESH_TIMESTAMP = 0L;
    final DisplayViewModel displayViewModel = ViewModelProviders.of(fragment).get(DisplayViewModel.class);
    displayViewModel.notifyOnConfigurationChanged(configuration);
}
 
/**
 * 注册屏幕素质变化监听
 */
public static void registerOnConfigurationChangeListener(@NonNull Fragment fragment, @NonNull DisplayOnConfigurationChangeListener listener) {
    final DisplayViewModel displayViewModel = ViewModelProviders.of(fragment).get(DisplayViewModel.class);
    displayViewModel.registerOnConfigurationChangeListener(fragment, listener);
}
 
/**
 * 移除屏幕素质变化监听
 */
public static void unregisterOnConfigurationChangeListener(@NonNull Fragment fragment, @NonNull DisplayOnConfigurationChangeListener listener) {
    // ...
}

private static Result measure(final DisplayAdapter parameter, final int scaleType) {
    if (parameter.mVideoAspectRatio < parameter.mLayoutMinAspectRatio
        || parameter.mVideoAspectRatio > parameter.mLayoutMaxAspectRatio) {
        // 超出调节范围，强制缩放到极限尺寸
        final int outLayoutWidth;
        final int outLayoutHeight;
        if (parameter.mVideoAspectRatio < parameter.mLayoutMinAspectRatio) {
            outLayoutWidth = parameter.mLayoutMaxWidth;
            outLayoutHeight = parameter.mLayoutMinHeight;
        } else {
            outLayoutWidth = parameter.mLayoutMinWidth;
            outLayoutHeight = parameter.mLayoutMaxHeight;
        }
 
        if (scaleType == SCALE_TYPE_CENTER_CROP) {
            // 强制CenterCrop策略
            return crop(parameter, outLayoutWidth, outLayoutHeight);
        }
 
        if (scaleType == SCALE_TYPE_FIT_CENTER) {
            // 强制FitCenter策略
            return fit(parameter, outLayoutWidth, outLayoutHeight);
        }
 
        // 当前输出的容器高宽比
        final float currentLayoutAspectRatio = outLayoutHeight / (float) outLayoutWidth;
 
        // 自适应策略
        if (currentLayoutAspectRatio > 1.5f
            && Math.abs(currentLayoutAspectRatio - parameter.mVideoAspectRatio) <= 0.23f) {
            // 容器高宽比 > 1.5(3/2)
            // 容器高宽比与视频原始高宽容错23%范围（16/9视频在20/10容器内可占满显示）
            // CenterCrop
            return crop(parameter, outLayoutWidth, outLayoutHeight);
        } else {
            // FitCenter
            return fit(parameter, outLayoutWidth, outLayoutHeight);
        }
    } else {
        // 范围内，则一定可以有一个合适的布局尺寸
        // 一定满足FIT_CENTER模式
        // 视频尺寸某一边超出区间则按比例调整到布局尺寸范围内
        // 布局尺寸等同于视频尺寸
 
        int outWidth = parameter.mVideoWidth;
        int outHeight = parameter.mVideoHeight;
 
        if (parameter.mVideoAspectRatio > 1f) {
            // 视频偏高
            // 调节宽度，高度按比例自适应
            final int expectVideoWidth = Math.min(parameter.mLayoutMaxWidth, Math.max(parameter.mLayoutMinWidth, outWidth));
            if (outWidth != expectVideoWidth) {
                outWidth = expectVideoWidth;
                outHeight = (int) (outWidth * parameter.mVideoAspectRatio);
            }
        } else {
            // 视频偏宽或等高宽
            // 调节高度，宽度按比例自适应
            final int expectVideoHeight = Math.min(parameter.mLayoutMaxHeight, Math.max(parameter.mLayoutMinHeight, outHeight));
            if (outHeight != expectVideoHeight) {
                outHeight = expectVideoHeight;
                outWidth = (int) (outHeight / parameter.mVideoAspectRatio);
            }
        }
 
        return fill(outWidth, outHeight, outWidth, outHeight);
    }
}

/**
 * 视频显示样式计算出参
 */
public static class Result {
    public final int mVideoWidth;
    public final int mVideoHeight;
    public final int mLayoutWidth;
    public final int mLayoutHeight;
 
    /**
     * 当视频控件设置为 Layout 尺寸时，需设置其Matrix值
     *
     * @param clipDirectionForCenterCrop 视频Crop模式下裁剪方向
     * @return Matrix
     */
    @NonNull
    public Matrix getVideoMatrix(int clipDirectionForCenterCrop) {
        final Matrix matrix = new Matrix();
        if (mVideoWidth == mLayoutWidth && mVideoHeight == mLayoutHeight) {
            return matrix;
        }
 
        // 缩放部分
        final float scaleX = mVideoWidth / (float) mLayoutWidth;
        final float scaleY = mVideoHeight / (float) mLayoutHeight;
        matrix.setScale(scaleX, scaleY);
 
        // 位移部分
        final float dx, dy;
 
        // 是否水平居中剪裁
        final boolean clipCenterHorizontal = (clipDirectionForCenterCrop & CLIP_DIRECTION_CENTER_HORIZONTAL) == CLIP_DIRECTION_CENTER_HORIZONTAL;
        // 水平剪裁
        if (mVideoWidth <= mLayoutWidth || clipCenterHorizontal) {
            // 视频未溢出 或 居中裁剪
            // 居中裁剪
            dx = (mLayoutWidth - mVideoWidth) * 0.5f;
        } else {
            if ((clipDirectionForCenterCrop & CLIP_DIRECTION_LEFT) == CLIP_DIRECTION_LEFT) {
                // 裁剪左边
                dx = mLayoutWidth - mVideoWidth;
            } else {
                // 不做位移，裁剪右边
                dx = 0f;
            }
        }
 
        // 是否垂直居中剪裁
        final boolean clipCenterVertical = (clipDirectionForCenterCrop & CLIP_DIRECTION_CENTER_VERTICAL) == CLIP_DIRECTION_CENTER_VERTICAL;
        // 垂直剪裁
        if (mVideoHeight <= mLayoutHeight || clipCenterVertical) {
            // 视频未溢出 或 居中裁剪
            // 居中裁剪
            dy = (mLayoutHeight - mVideoHeight) * 0.5f;
        } else {
            if ((clipDirectionForCenterCrop & CLIP_DIRECTION_TOP) == CLIP_DIRECTION_TOP) {
                // 裁剪顶部
                dy = mLayoutHeight - mVideoHeight;
            } else {
                // 不做位移，裁剪右边
                dy = 0f;
            }
        }
 
        matrix.postTranslate(Math.round(dx), Math.round(dy));
 
        return matrix;
    }
}

<application
    android:resizeableActivity="true">

<meta-data
    android:name="android.max_aspect"
    android:value="2.4"/>
<meta-data
    android:name="android.min_aspect"
    android:value="1.8" />

<activity android:name=".MainActivity"
          android:maxAspectRatio="2.4" />

DisplayManager mgr = (DisplayManager) this.getBaseContext().getSystemService(Context.DISPLAY_SERVICE);
Display[] displays = mgr.getDisplays();

Display display = displays[i];
int displayId = display.getDisplayId();
Point point = new Point();
display.getSize(point);
 
if (point.y >= 高度 && point.x >= 宽度) {
    Intent intent = new Intent(...);
    intent.addFlags(Intent.FLAG_ACTIVITY_MULTIPLE_TASK or Intent.FLAG_ACTIVITY_NEW_TASK);
    // 检查是否允许启动
    boolean allow = activityManager.isActivityStartAllowedOnDisplay(context, displayId, intent);
}

val options = ActivityOptions.makeBasic()
options.launchDisplayId = targetDisplay.displayId
startActivity(intent, options.toBundle())

# 折叠切展开模拟方法：
#（1）预先将手机设置主屏分辨率：
adb shell wm size 1148x2480
#（2）通过修改手机分辨率为全屏分辨率模拟状态切换：
adb shell wm size 2200x2480
# 展开切折叠模拟方法：
#（1）预先将手机设置全屏分辨率：
adb shell wm size 2200x2480
#（2）通过修改手机分辨率为主屏分辨率模拟状态切换：
adb shell wm size 1148x2480
# 分辨率恢复方法：
adb shell wm size reset