横屏 竖屏 代码流程

最新推荐文章于 2023-04-27 16:31:36 发布
最新推荐文章于 2023-04-27 16:31:36 发布
阅读量1.4k 收藏 1
点赞数

[Android移植] 关于android2.3调试g-sensor (2012-02-21 16:11:17)

转载▼
标签：

it

android
本帖最后由 Code007 于 2011-12-6 10:13 编辑

由于工作上的需要，特地写了这么一份关于调试g-sensor的内容.
1.首先确定你要调试的设备的屏幕的横竖屏如何设置。
在代码中我们主要的流程如下：
os 启动后 ：
WindowManagerService.java中ENABLE_SCREEN
–>performEnableScreen（）
–>mPolicy.enableScreenAfterBoot()/setRotation()
–>setRotationUnchecked()
–>PhoneWindowManager.java中的rotationForOrientationLw（）
–>Surface.setOrientation()
基本上流程就是如上，只要稍微跟踪一下就可以了。
下面大概对上面主要code进行注释说明：


  1. //下面的方法主要用于判断屏幕是否需要进行一个新的旋转
  2. public boolean setRotationUncheckedLocked(int rotation, int animFlags) {
  3.         boolean changed;
  4. //rotation从外面传入当前的rotation以及animFlags 最后的标签
  5. //如果rotation等于系统第一次启动则rotation赋值为mRequestedRotation此时为0
  6.         if (rotation == WindowManagerPolicy.USE_LAST_ROTATION) {
  7.             rotation = mRequestedRotation;
  8.         } else {
  9.             mRequestedRotation = rotation;
  10.             mLastRotationFlags = animFlags;
  11.         }
  12.         if (DEBUG_ORIENTATION) Slog.v(TAG, "Overwriting rotation value from " + rotation);
  13. //此时的rotation为老的rotation，下面通过mPolicy.rotationForOrientationLw（）进行获取新的rotation
  14.         rotation = mPolicy.rotationForOrientationLw(mForcedAppOrientation,
  15.                 mRotation, mDisplayEnabled);
  16.         if (DEBUG_ORIENTATION) Slog.v(TAG, "new rotation is set to " + rotation);
  17.         changed = mDisplayEnabled && mRotation != rotation;
  18. //如果获取新的rotation与旧的rotation一样则不做改变
  19. //否则进入下面函数进行调整
  20.         if (changed) {
  21.             if (DEBUG_ORIENTATION) Slog.v(TAG,
  22.                     "Rotation changed to " + rotation
  23.                     + " from " + mRotation
  24.                     + " (forceApp=" + mForcedAppOrientation
  25.                     + ", req=" + mRequestedRotation + ")");
  26.             mRotation = rotation;
  27.             mWindowsFreezingScreen = true;
  28.             mH.removeMessages(H.WINDOW_FREEZE_TIMEOUT);
  29.             mH.sendMessageDelayed(mH.obtainMessage(H.WINDOW_FREEZE_TIMEOUT),
  30.                     2000);
  31.             mWaitingForConfig = true;
  32.             mLayoutNeeded = true;
  33.             startFreezingDisplayLocked();
  34.             Slog.i(TAG, "Setting rotation to " + rotation + ", animFlags=" + animFlags);
  35.             mInputManager.setDisplayOrientation(0, rotation);
  36.             if (mDisplayEnabled) {
  37. //Surface.setOrientation(）这里将进行调整Orientation
  38.                 Surface.setOrientation(0, rotation, animFlags);
  39.             }
  40.             for (int i=mWindows.size()-1; i>=0; i--) {
  41.                 WindowState w = mWindows.get(i);
  42.                 if (w.mSurface != null) {
  43.                     w.mOrientationChanging = true;
  44.                 }
  45.             }
  46.             for (int i=mRotationWatchers.size()-1; i>=0; i--) {
  47.                 try {
  48.                     mRotationWatchers.get(i).onRotationChanged(rotation);
  49.                 } catch (RemoteException e) {
  50.                 }
  51.             }
  52.         } //end if changed

  54.         return changed;
  55.     }
复制代码


下面在对rotationForOrientationLw（）进行解析一下：
在setRotationUncheckedLocked（）中的 mPolicy.rotationForOrientationLw()如是：


  1. otationForOrientationLw(int orientation, int lastRotation,
  2.             boolean displayEnabled) {

  4.         if (mPortraitRotation < 0) {
  5.             // Initialize the rotation angles for each orientation once.
  6.             Display d = ((WindowManager)mContext.getSystemService(Context.WINDOW_SERVICE))
  7.                     .getDefaultDisplay();
  8. //这里的d.getWidth() 和 d.getHeight()得到的是物理屏幕的宽高。
  9. //平板跟手机不一样。平板的宽比高大
  10. //（0度时位于//landscape模式，右转90度进入porit模式），
  11. //而手机是高比宽大（0度是位于porit模式，右转90度进入landscape模式）。
  12. //所以下面我做的是对平板的修改
  13.             if (d.getWidth() > d.getHeight()) {
  14.                 //mPortraitRotation = Surface.ROTATION_90;
  15.                 mPortraitRotation = Surface.ROTATION_270;
  16.                 mLandscapeRotation = Surface.ROTATION_0;
  17.                 //mUpsideDownRotation = Surface.ROTATION_270;
  18.                 mUpsideDownRotation = Surface.ROTATION_90;
  19.                 mSeascapeRotation = Surface.ROTATION_180;
  20.             } else {
  21.                 mPortraitRotation = Surface.ROTATION_0;
  22.                 //mLandscapeRotation = Surface.ROTATION_90;
  23.                 mLandscapeRotation = Surface.ROTATION_270;
  24.                 mUpsideDownRotation = Surface.ROTATION_180;
  25.                 //mSeascapeRotation = Surface.ROTATION_270;
  26.                 mSeascapeRotation = Surface.ROTATION_90;
  27.             }
  28.         }
  29. ......
  30. }
复制代码


2.如果g-sensor在旋转上有不旋转的方向或者方向不是很灵敏，则我们从下面进行分析：

主要流程如下：
–>WindowOrientationListener.java中的onSensorChanged（）
–>computeNewOrientation()
–>filterOrientation()
–>calculateNewRotation()
calculateNewRotation()
–>mOrientationListener.onOrientationChanged()
PhoneWindowManager.java 中的onOrientationChanged()
–>mWindowManager.setRotation()

首先在android中的x，y，z定义如下摘自http://developer.android.com/ref ... re/SensorEvent.html ：
Class Overview

This class represents a Sensor event and holds informations such as the sensor’s type, the time-stamp, accuracy and of course the sensor’s data.

Definition of the coordinate system used by the SensorEvent API.

The coordinate-system is defined relative to the screen of the phone in its default orientation. The axes are not swapped when the device’s screen orientation changes.

The X axis is horizontal and points to the right, the Y axis is vertical and points up and the Z axis points towards the outside of the front face of the screen. In this system, coordinates behind the screen have negative Z values.

Sensors coordinate-system diagram.

Note: This coordinate system is different from the one used in the Android 2D APIs where the origin is in the top-left corner.

frameworks/base/core/java/android/view/WindowOrientationListener.java
WindowOrientationListener.java 是一个abstract class，它主要是把从gsensor获取到的数据转化为orientation.
每次sensor有进行改变时都会调用到以下函数进行计算Orientation。



  1. public void onSensorChanged(SensorEvent event) {
  2.             // the vector given in the SensorEvent points straight up (towards the sky) under ideal
  3.             // conditions (the phone is not accelerating).  i'll call this upVector elsewhere.
  4.             float x = event.values[_DATA_X];
  5.             float y = event.values[_DATA_Y];
  6.             float z = event.values[_DATA_Z];
  7.             float magnitude = vectorMagnitude(x, y, z);
  8.             float deviation = Math.abs(magnitude - SensorManager.STANDARD_GRAVITY);

  10.             handleAccelerationDistrust(deviation);

  12.             // only filter tilt when we're accelerating
  13.             float alpha = 1;
  14.             if (mAccelerationDistrust > 0) {
  15.                 alpha = ACCELERATING_LOWPASS_ALPHA;
  16.             }
  17.             float newTiltAngle = tiltAngle(z, magnitude);
  18.             mTiltAngle = lowpassFilter(newTiltAngle, mTiltAngle, alpha);

  20.             float absoluteTilt = Math.abs(mTiltAngle);
  21.             checkFullyTilted(absoluteTilt);
  22.             if (mTiltDistrust > 0) {
  23.                 return; // when fully tilted, ignore orientation entirely
  24.             }
  25. //下面通过x,y计算得到新的OrientationAngle，计算方法如下
  26. //        private float computeNewOrientation(float x, float y) {
  27. //           float orientationAngle = (float) -Math.atan2(-x, y) * RADIANS_TO_DEGREES;
  28.             // atan2 returns [-180, 180]; normalize to [0, 360]
  29. //            if (orientationAngle < 0) {
  30. //               orientationAngle += 360;
  31. //            }
  32. //            return orientationAngle;
  33. //        }
  34.             float newOrientationAngle = computeNewOrientation(x, y);
  35. //通过下面函数计算出Orientation的值。
  36.             filterOrientation(absoluteTilt, newOrientationAngle);
  37.             calculateNewRotation(mOrientationAngle, absoluteTilt);
  38.         }
复制代码


这里对calculateNewRotation进行分析前必须先对SensorEventListenerImpl类中的一些变量先进行解释：


  1. private static final int[][][] THRESHOLDS = new int[][][] {
  2. {{60, 180}, {180, 300}},
  3. {{0, 30}, {195, 315}, {315, 360}},
  4. {{0, 45}, {45, 165}, {330, 360}},

  6. // Handle situation where we are currently doing 180 rotation
  7. // but that is no longer allowed.
  8. {{0, 45}, {45, 135}, {135, 225}, {225, 315}, {315, 360}},
  9. };
  10. // See THRESHOLDS
  11. private static final int[][] ROTATE_TO = new int[][] {
  12. {ROTATION_90, ROTATION_270},
  13. {ROTATION_0, ROTATION_270, ROTATION_0},
  14. {ROTATION_0, ROTATION_90, ROTATION_0},
  15. {ROTATION_0, ROTATION_90, ROTATION_0, ROTATION_270, ROTATION_0},
  16. };

  18. private static final int[][][] THRESHOLDS_WITH_180 = new int[][][] {
  19. {{60, 165}, {165, 195}, {195, 300}},
  20. {{0, 30}, {165, 195}, {195, 315}, {315, 360}},
  21. {{0, 45}, {45, 165}, {165, 195}, {330, 360}},
  22. {{0, 45}, {45, 135}, {225, 315}, {315, 360}},
  23. };
  24. private static final int[][] ROTATE_TO_WITH_180 = new int[][] {
  25. {ROTATION_90, ROTATION_180, ROTATION_270},
  26. {ROTATION_0, ROTATION_180, ROTATION_90, ROTATION_0},
  27. {ROTATION_0, ROTATION_270, ROTATION_180, ROTATION_0},
  28. {ROTATION_0, ROTATION_90, ROTATION_270, ROTATION_0},
  29. };
  30. //当设备平放，屏幕朝正上方。以下四个常量分别代表：
  31. private static final int ROTATION_0 = 0;//初始情况。横/竖屏与一开始设置有关
  32. private static final int ROTATION_90 = 1;//右侧翻起侧立时，屏幕会旋转到这个方向。
  33. private static final int ROTATION_270 = 2;//左侧翻起度侧立时，屏幕会旋转到这个方向。
  34. private static final int ROTATION_180 = 3;//屏幕底部侧立时，屏幕会旋转到这个方向

  36. //如上则
  37. // {ROTATION_90, ROTATION_180, ROTATION_270}
  38. //对应落在的范围为 {{60, 165}, {165, 195}, {195, 300}}
  39. //{ROTATION_0, ROTATION_180, ROTATION_90, ROTATION_0}
  40. //对应落在的范围为 {{0, 30}, {165, 195}, {195, 315}, {315, 360}}
  41. //{ROTATION_0, ROTATION_270, ROTATION_180, ROTATION_0}
  42. //对应落在的范围为 {{0, 45}, {45, 165}, {165, 195}, {330, 360}}
  43. //{ROTATION_0, ROTATION_90, ROTATION_270, ROTATION_0}
  44. //对应落在的范围为{{0, 45}, {45, 135}, {225, 315}, {315, 360}}
  45. //所以如果需要微调的话只要修改对应的范围既可

  47. //当前屏幕旋转方向为ROTATION_0时，取int[][] threshold=THRESHOLDS_WITH_180[0];
  48. //此时的范围为：{{60, 165}, {165, 195}, {195, 300}}
  49. //当前屏幕旋转方向为ROTATION_90时，取int[][] threshold=THRESHOLDS_WITH_180[1];
  50. //此时的范围为：{{0, 30}, {165, 195}, {195, 315}, {315, 360}}
  51. //当前屏幕旋转方向为ROTATION_270时，取int[][] threshold=THRESHOLDS_WITH_180[2];
  52. //此时的范围为：{{0, 45}, {45, 165}, {165, 195}, {330, 360}}
  53. //当前屏幕旋转方向为ROTATION_180时，取int[][] threshold=THRESHOLDS_WITH_180[3];
  54. //此时的范围为：{{0, 45}, {45, 135}, {225, 315}, {315, 360}}

  56. //例如当前我们的位置为ROTATION_90那么此时我们的THRESHOLDS_WITH_180就
  57. //为{{0, 30}, {165, 195}, {195, 315}, {315, 360}}
  58. //，然后通过filterOrientation计算出的orientation值落在了第2个元素围内，则到ROTATE_TO_WITH_180找到对应的值，
  59. //这里为ROTATION_180，则此时把方向选装到ROTATION_180
复制代码



对上面的变量稍微了解后对下面的分析就很简单了。


  1. private void calculateNewRotation(float orientation, float tiltAngle) {
  2. //这里的orientation，tiltAngle，mRotation为gsensor获取到的最新的数据
  3.             if (localLOGV) Log.i(TAG, orientation + ", " + tiltAngle + ", " + mRotation);
  4. //是否允许180度旋转，这里定义的其实就是变成了360度旋转了，
  5. //如果mAllow180Rotation为false时，上面的变量中使用的为THRESHOLDS以及ROTATE_TO
  6. //如果为ture则为THRESHOLDS_WITH_180与ROTATE_TO_WITH_180
  7.             final boolean allow180Rotation = mAllow180Rotation;
  8.             int thresholdRanges[][] = allow180Rotation
  9.                     ? THRESHOLDS_WITH_180[mRotation] : THRESHOLDS[mRotation];
  10.             int row = -1;
  11.             for (int i = 0; i < thresholdRanges.length; i++) {
  12.                 if (orientation >= thresholdRanges[i][0] && orientation < thresholdRanges[i][1]) {
  13.                     row = i;
  14.                     break;
  15.                 }
  16.             }
  17.             if (row == -1) return; // no matching transition

  19.             int rotation = allow180Rotation
  20.                     ? ROTATE_TO_WITH_180[mRotation][row] : ROTATE_TO[mRotation][row];
  21.             if (tiltAngle > MAX_TRANSITION_TILT[rotation]) {
  22.                 // tilted too far flat to go to this rotation
  23.                 return;
  24.             }

  26.             if (localLOGV) Log.i(TAG, "orientation " + orientation + " gives new rotation = "
  27.                     + rotation);
  28.             mRotation = rotation;
  29. //这里通过WindowOrientationListener监听调用onOrientationChanged中的setRotation从而旋转界面
  30.             mOrientationListener.onOrientationChanged(INTERNAL_TO_SURFACE_ROTATION[mRotation]);
  31.         }
复制代码


onOrientationChanged（）的实现在PhoneWindowManager.java 中，如下：


  1. class MyOrientationListener extends WindowOrientationListener {
  2.        MyOrientationListener(Context context) {
  3.            super(context);
  4.        }

  6.        @Override
  7.        public void onOrientationChanged(int rotation) {
  8.            // Send updates based on orientation value
  9.            if (localLOGV) Log.v(TAG, "onOrientationChanged, rotation changed to " +rotation);
  10.            try {
  11.                mWindowManager.setRotation(rotation, false,
  12.                        mFancyRotationAnimation);
  13.        SystemProperties.set("service.screen.rotation", ""+rotation);
  14.            } catch (RemoteException e) {
  15.                // Ignore

  17.            }
  18.        }
  19.    }
复制代码


基本上整个流程到此结束。

转载时请注明出处和作者
文章出处：http://www.code007.org/
作者：Code007

禾刀个老鼠
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
关于android2.3调试g-sensor
lqf785435771的专栏
02-16 1199
关于android2.3调试g-sensor 由于工作上的需要，特地写了这么一份关于调试g-sensor的内容. 1.首先确定你要调试的设备的屏幕的横竖屏如何设置。 在代码中我们主要的流程如下： os 启动后 ： WindowManagerService.java中ENABLE_SCREEN –>performEnableScreen（） –>mPolicy.enableScreen
Android系统 添加动态控制屏幕方向、强制APP横竖屏方向
最新发布
一歲抬頭的博客
08-30 3109
本文介绍了如何在Android系统中Settings添加屏幕旋转和强制App应用旋转的功能，以便客户可以根据项目需求调整屏幕方向。
Android 10.0强制所有app竖屏显示 (修改framwork)
pbx6666的博客
03-29 5701
路径:frameworks\base\services\core\java\com\android\server\wm\DisplayContent.java final int oldRotation = mRotation; final int lastOrientation = mLastOrientation; int rotation = mDisplayRotation.rotationForOrientation(lastOrientation, oldRotation); //ad
20230427----Android 10.0-----framework 修改屏幕旋转角度
qq_854189624的博客
04-27 613
该类里边的 rotationForOrientation 方法可以设置显示角度。
Android6.0 旋转屏幕（二）旋转设备
kc58236582的博客
12-16 7598
上篇博客中我们一直提到updateRotationUnchecked函数，这篇博客我们就来分析下这个函数，这个函数可以说是旋转屏幕的一个核心函数，我们主要看下updateRotationUncheckedLocked和sendNewConfiguration函数，当updateRotationUncheckedLocked返回true代表设备已经旋转，这个时候要调用sendNewConfigura
uniapp中设置横屏竖屏
07-06
uniapp中设置横屏竖屏,或者如何进行横竖屏切换
JS检测移动端横竖屏的代码
10-22
主要介绍了JS检测移动端横竖屏的代码,非常不错具有参考借鉴价值，需要的朋友可以参考下
Android studio通过切换不同layout实现横竖屏适配
12-28
Android studio通过切换不同layout实现横竖屏适配
IOS强制横竖屏代码
08-04
这个是一个经典的 跨界面 任意界面自由旋转demo。
基于jQuery的判断iPad、iPhone、Android是横屏还是竖屏的代码
10-25
在ipad、iphone网页开发中，我们很可能需要判断是横屏或者竖屏。下面就来介绍如何用 jQuery 判断iPad、iPhone、Android是横屏还是竖屏的方法
安卓系统强制旋转屏幕实现横竖屏切换
Leak LocK的博客
06-04 4316
我们要实现开机强制系统横屏或者竖屏，并且可以再系统中实时切换横竖屏，首先分析代码找到 WindowManagerService.java @Override public int getRotation() { return mRotation; } 查看WindowManagerService.java代码发现我们获取当前屏幕参数时返回的是mRotation参数，继续查看mRotation初始化调用 /** All DisplayContents
android系统默认横屏
上海一九四三
08-25 1850
实际开发中,有时项目需要设备默认开机横屏,这里我们默认第一帧第二帧依旧采用竖屏资源(Android7.0)。 frameworks/base/cmds/bootanimation/BootAnimation.cpp frameworks/base/core/res/res/values/config.xml frameworks/base/services/core/java/com/android/server/wm/WindowManagerService...
android 10 系统源码 framework 默认所有强制竖屏应用（SCREEN_ORIENTATION_PORTRAIT）横屏显示
WHO_HRF的博客
04-22 2305
frameworks/base/core/java/android/content/pm/PackageParser.java @@ -169,6 +169,8 @@ public class PackageParser { private static final boolean MULTI_PACKAGE_APK_ENABLED = Build.IS_DEBUGGABLE && SystemProperties.getBoolean(PROPERTY_
Android重力感应开发
热门推荐
其实并不难,是你太悲观
03-09 8万+
一、手机中常用的传感器 在Android2.3 gingerbread系统中，google提供了11种传感器供应用层使用，具体如下：（Sensor类） #define SENSOR_TYPE_ACCELEROMETER 1 //加速度 #define SENSOR_TYPE_MAGNETIC_FIELD 2 //磁力 #define SENSOR_TYPE_ORIENTATION 3 //
android传感器
移动开发
12-28 1185
在Android2.3 gingerbread系统中，google提供了11种传感器供应用层使用。    #define SENSOR_TYPE_ACCELEROMETER       1 //加速度 #define SENSOR_TYPE_MAGNETIC_FIELD      2 //磁力 #define SENSOR_TYPE_ORIENTATION         3 //
android gsensor 坐标,获取Android设备的方向，Sensor和SensorManager实现手机旋转角度
weixin_42371234的博客
05-25 1565
带有g-sensor的Android设备上可通过API获取到设备的运动加速度，应用程序通过一些假设和运算，可以从加速度计算出设备的方向获取设备运动加速度的基本代码是：SensorManager sm = (SensorManager) context.getSystemService(Context.SENSOR_SERVICE);sm.registerListener(new SensorEve...
Android 获取屏幕实时sensor角度
qq_27494201的博客
12-15 1095
这种获取方式要比直接获取屏幕横竖屏状态稳定得多，因为如果手机之前是竖屏关闭自动旋转，横屏时，获取屏幕状态还是竖屏。但sensor是实时获取重力感应传感器的值。
android 屏幕旋转
08-10 1万+
基本思路：在输入事件分发线程中(代码在WindowManagerService.java中)，当事件为按键事件而且按键码与自定义功能键的码值一样时，向一个特定的Service（如com.android.settings.ButtonService）来请求服务。示例代码为 If
android如何改变系统默认横竖屏方向
07-19 1809
http://blog.csdn.net/abc19842008/article/details/7543559 如何改变android默认的横竖屏，修改源码一个地方就可以了。 [java]view plaincopy publicintrotationForOr...
uniapp横屏竖屏
08-20
Uni-app 是一个跨平台的应用开发框架，支持多种平台，包括iOS、Android、H5等。在 Uni-app 中实现横屏和竖屏的切换可以通过以下步骤进行： 1. 修改 manifest.json 文件，找到 "app-plus" -> "orientation" 字段，设置为 "auto"，表示自动根据设备方向进行切换。 ```json "app-plus": { "orientation": "auto" } ``` 2. 如果希望应用一直保持横屏或竖屏状态，可以将 "auto" 修改为具体的方向，如 "portrait" 表示竖屏，"landscape" 表示横屏。 ```json "app-plus": { "orientation": "landscape" } ``` 3. 如果希望应用在特定页面或特定情况下切换横屏和竖屏，可以使用 uni-app 提供的 API 进行动态设置。 ```javascript // 设置为横屏 uni.setScreenOrientation('landscape'); // 设置为竖屏 uni.setScreenOrientation('portrait'); ``` 需要注意的是，uni.setScreenOrientation() 只能在真机上生效，无法在开发工具内预览效果。另外，不同平台的横屏和竖屏切换方式可能有所差异，具体可参考对应平台的文档或开发者社区。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值