• Android 14.0 系统强制app横屏显示功能实现

    1.概述

    在14.0系统产品rom定制化开发中,对于处理屏幕旋转方向，首先有kernel底层处理，从底层驱动gsensor 中获取数据，从而判断屏幕方向的，
    然后事件上报后 最后由WMS就是WindowManagerService 来处理旋转的相关事件,接下来看下强制app横屏显示功能如何实现

    2.系统强制app横屏显示功能实现的核心类

    framework/base/services/java/com/android/server/wm/DisplayRotation.java

    3.系统强制app横屏显示功能实现的核心功能分析和处理

    在系统中wms主要是处理屏幕相关的核心类，WMS中在处理屏幕自动旋转，主要是调用
    DisplayRotation的freezeRotation方法锁定用户指定的屏幕方向，调用thawRotation方法，解锁用户固定屏幕，
    恢复屏幕自动旋转。最后调用updateRotationUnchecked，发送新的Configuration变化，
    以及如果布局发生变化，也会重新计算布局。

    通过上述源码分析，在系统中关于处理屏幕方法的系统中就是DisplayRotation.java 里负责处理的，这里根据系统当前的旋转方向
    具体需要看源码然后分析具体的旋转功能

    1.     int rotationForOrientation(@ScreenOrientation int orientation,
    2.               @Surface.Rotation int lastRotation) {
    3.   
    4.           if (isFixedToUserRotation()) {
    5.               return mUserRotation;
    6.           }
    7.   
    8.           int sensorRotation = mOrientationListener != null
    9.                   ? mOrientationListener.getProposedRotation() // may be -1
    10.                   : -1;
    11.           if (sensorRotation < 0) {
    12.               sensorRotation = lastRotation;
    13.           }
    14.   
    15.           final int lidState = mDisplayPolicy.getLidState();
    16.           final int dockMode = mDisplayPolicy.getDockMode();
    17.           final boolean hdmiPlugged = mDisplayPolicy.isHdmiPlugged();
    18.           final boolean carDockEnablesAccelerometer =
    19.                   mDisplayPolicy.isCarDockEnablesAccelerometer();
    20.           final boolean deskDockEnablesAccelerometer =
    21.                   mDisplayPolicy.isDeskDockEnablesAccelerometer();
    22.   
    23.           final int preferredRotation;
    24.           if (!isDefaultDisplay) {
    25.               preferredRotation = mUserRotation;
    26.           } else if (lidState == LID_OPEN && mLidOpenRotation >= 0) {
    27.               preferredRotation = mLidOpenRotation;
    28.           } else if (dockMode == Intent.EXTRA_DOCK_STATE_CAR
    29.                   && (carDockEnablesAccelerometer || mCarDockRotation >= 0)) {
    30.               preferredRotation = carDockEnablesAccelerometer ? sensorRotation : mCarDockRotation;
    31.           } else if ((dockMode == Intent.EXTRA_DOCK_STATE_DESK
    32.                   || dockMode == Intent.EXTRA_DOCK_STATE_LE_DESK
    33.                   || dockMode == Intent.EXTRA_DOCK_STATE_HE_DESK)
    34.                   && (deskDockEnablesAccelerometer || mDeskDockRotation >= 0)) {
    35.               preferredRotation = deskDockEnablesAccelerometer ? sensorRotation : mDeskDockRotation;
    36.           } else if (hdmiPlugged && mDemoHdmiRotationLock) {
    37.               preferredRotation = mDemoHdmiRotation;
    38.           } else if (hdmiPlugged && dockMode == Intent.EXTRA_DOCK_STATE_UNDOCKED
    39.                   && mUndockedHdmiRotation >= 0) {
    40.               preferredRotation = mUndockedHdmiRotation;
    41.           } else if (mDemoRotationLock) {
    42.               preferredRotation = mDemoRotation;
    43.           } else if (mDisplayPolicy.isPersistentVrModeEnabled()) {
    44.               preferredRotation = mPortraitRotation;
    45.           } else if (orientation == ActivityInfo.SCREEN_ORIENTATION_LOCKED) {
    46.               preferredRotation = lastRotation;
    47.           } else if (!mSupportAutoRotation) {
    48.               preferredRotation = -1;
    49.           } else if ((mUserRotationMode == WindowManagerPolicy.USER_ROTATION_FREE
    50.                           && (orientation == ActivityInfo.SCREEN_ORIENTATION_USER
    51.                                   || orientation == ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED
    52.                                   || orientation == ActivityInfo.SCREEN_ORIENTATION_USER_LANDSCAPE
    53.                                   || orientation == ActivityInfo.SCREEN_ORIENTATION_USER_PORTRAIT
    54.                                   || orientation == ActivityInfo.SCREEN_ORIENTATION_FULL_USER))
    55.                   || orientation == ActivityInfo.SCREEN_ORIENTATION_SENSOR
    56.                   || orientation == ActivityInfo.SCREEN_ORIENTATION_FULL_SENSOR
    57.                   || orientation == ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE
    58.                   || orientation == ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT) {
    59.               if (mAllowAllRotations == ALLOW_ALL_ROTATIONS_UNDEFINED) {
    60.                   mAllowAllRotations = mContext.getResources().getBoolean(
    61.                           R.bool.config_allowAllRotations)
    62.                                   ? ALLOW_ALL_ROTATIONS_ENABLED
    63.                                   : ALLOW_ALL_ROTATIONS_DISABLED;
    64.               }
    65.               if (sensorRotation != Surface.ROTATION_180
    66.                       || mAllowAllRotations == ALLOW_ALL_ROTATIONS_ENABLED
    67.                       || orientation == ActivityInfo.SCREEN_ORIENTATION_FULL_SENSOR
    68.                       || orientation == ActivityInfo.SCREEN_ORIENTATION_FULL_USER) {
    69.                   preferredRotation = sensorRotation;
    70.               } else {
    71.                   preferredRotation = lastRotation;
    72.               }
    73.           } else if (mUserRotationMode == WindowManagerPolicy.USER_ROTATION_LOCKED
    74.                   && orientation != ActivityInfo.SCREEN_ORIENTATION_NOSENSOR
    75.                   && orientation != ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE
    76.                   && orientation != ActivityInfo.SCREEN_ORIENTATION_PORTRAIT
    77.                   && orientation != ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE
    78.                   && orientation != ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT) {
    79.               preferredRotation = mUserRotation;
    80.           } else {
    81.               // No overriding preference.
    82.               // We will do exactly what the application asked us to do.
    83.               preferredRotation = -1;
    84.           }
    85.   
    86.           switch (orientation) {
    87.               case ActivityInfo.SCREEN_ORIENTATION_PORTRAIT:
    88.                   // Return portrait unless overridden.
    89.                   if (isAnyPortrait(preferredRotation)) {
    90.                       return preferredRotation;
    91.                   }
    92.                   return mPortraitRotation;
    93.   
    94.               case ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE:
    95.                   // Return landscape unless overridden.
    96.                   if (isLandscapeOrSeascape(preferredRotation)) {
    97.                       return preferredRotation;
    98.                   }
    99.                   return mLandscapeRotation;
    100.   
    101.               case ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT:
    102.                   // Return reverse portrait unless overridden.
    103.                   if (isAnyPortrait(preferredRotation)) {
    104.                       return preferredRotation;
    105.                   }
    106.                   return mUpsideDownRotation;
    107.   
    108.               case ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE:
    109.                   // Return seascape unless overridden.
    110.                   if (isLandscapeOrSeascape(preferredRotation)) {
    111.                       return preferredRotation;
    112.                   }
    113.                   return mSeascapeRotation;
    114.   
    115.               case ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE:
    116.               case ActivityInfo.SCREEN_ORIENTATION_USER_LANDSCAPE:
    117.                   // Return either landscape rotation.
    118.                   if (isLandscapeOrSeascape(preferredRotation)) {
    119.                       return preferredRotation;
    120.                   }
    121.                   if (isLandscapeOrSeascape(lastRotation)) {
    122.                       return lastRotation;
    123.                   }
    124.                   return mLandscapeRotation;
    125.   
    126.               case ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT:
    127.               case ActivityInfo.SCREEN_ORIENTATION_USER_PORTRAIT:
    128.                   // Return either portrait rotation.
    129.                   if (isAnyPortrait(preferredRotation)) {
    130.                       return preferredRotation;
    131.                   }
    132.                   if (isAnyPortrait(lastRotation)) {
    133.                       return lastRotation;
    134.                   }
    135.                   return mPortraitRotation;
    136.   
    137.               default:
    138.                   if (preferredRotation >= 0) {
    139.                       return preferredRotation;
    140.                   }
    141.                   return Surface.ROTATION_0;
    142.           }
    143.       }

    在上述的DisplayRotation.java的相关源码中分析得知，系统在开机过程中，首选在wms中先调用rotationForOrientation函数来获取rotation，来获取当前屏幕的旋转方向，获取当前的屏幕方向后，在根据当前屏幕方向来进行具体的系统方向旋转，最终会调用到
    rotationForOrientation(int orientation, int lastRotation) 来获取屏幕的方向值，在具体负责处理app具体的方向旋转当app进入
    到activity后由rotationForOrientation()来判断屏幕需要显示的方向，最后处理屏幕的具体旋转方向
    具体是在

    1.             switch (orientation) {
    2.                   case ActivityInfo.SCREEN_ORIENTATION_PORTRAIT:
    3.                       // Return portrait unless overridden.
    4.                       if (isAnyPortrait(preferredRotation)) {
    5.                           return preferredRotation;
    6.                       }
    7.                  -     return mPortraitRotation;
    8.                  +     return Surface.ROTATION_90;
    9.       
    10.                   case ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE:
    11.                       // Return landscape unless overridden.
    12.                       if (isLandscapeOrSeascape(preferredRotation)) {
    13.                           return preferredRotation;
    14.                       }
    15.                       return mLandscapeRotation;
    16.       
    17.                   case ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT:
    18.                       // Return reverse portrait unless overridden.
    19.                       if (isAnyPortrait(preferredRotation)) {
    20.                           return preferredRotation;
    21.                       }
    22.                       return mUpsideDownRotation;
    23.       
    24.                   case ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE:
    25.                       // Return seascape unless overridden.
    26.                       if (isLandscapeOrSeascape(preferredRotation)) {
    27.                           return preferredRotation;
    28.                       }
    29.                       return mSeascapeRotation;

    在上述的DisplayRotation.java的相关源码中分析得知，系统判定屏幕旋转方向具体是在rotationForOrientation(int orientation, int lastRotation) 中
    当处理屏幕旋转方向时，根据当前屏幕旋转的方向，需要处理是根据
    case ActivityInfo.SCREEN_ORIENTATION_PORTRAIT的时候，判断当前需要旋转到什么方向，
    这时候系统在进入app的时候当设置屏幕方向的时候，如果需要横屏显示这时候就需要设置方向旋转90度，所以在上面判断如果当前是竖屏，在这里设置旋转90的屏幕方向就可以了从而实现功能

  • 相关阅读:
    Docker 安装 Nginx 容器 (完整详细版)
    使用 Docker Compose V2 快速搭建日志分析平台 ELK (Elasticsearch、Logstash 和 Kibana)
    Mybatis - Spring整合后一级缓存失效了
    AGV小车、机械臂协同作业实战06-任务分配算法（图解蚁群算法）代码示例java
    Linux命令基础
    云原生消息流系统 Apache RocketMQ 在腾讯云的大规模生产实践
    [激光原理与应用-21]：《激光原理与技术》-7- 激光技术大汇总与总体概述
    【SpringBoot3.x教程03】SpringBoot自动配置详解
    FPGA----ZCU106基于axi-hp通道的pl与ps数据交互（全网唯一最详）
    【无标Spring Boot (十五)： Spring Boot + Jpa + Thymeleaf 增删改查示例题】
  • 原文地址：https://blog.csdn.net/baidu_41666295/article/details/136390017