关于android2.3调试g-sensor

转载 2012年03月22日 19:28:02

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

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

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

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

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/reference/android/hardware/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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
public void onSensorChanged(SensorEvent event) {
            // the vector given in the SensorEvent points straight up (towards the sky) under ideal
            // conditions (the phone is not accelerating).  i'll call this upVector elsewhere.
            floatx = event.values[_DATA_X];
            floaty = event.values[_DATA_Y];
            floatz = event.values[_DATA_Z];
            floatmagnitude = vectorMagnitude(x, y, z);
            floatdeviation = Math.abs(magnitude - SensorManager.STANDARD_GRAVITY);
  
            handleAccelerationDistrust(deviation);
  
            // only filter tilt when we're accelerating
            floatalpha = 1;
            if(mAccelerationDistrust > 0) {
                alpha = ACCELERATING_LOWPASS_ALPHA;
            }
            floatnewTiltAngle = tiltAngle(z, magnitude);
            mTiltAngle = lowpassFilter(newTiltAngle, mTiltAngle, alpha);
  
            floatabsoluteTilt = Math.abs(mTiltAngle);
            checkFullyTilted(absoluteTilt);
            if(mTiltDistrust > 0) {
                return;// when fully tilted, ignore orientation entirely
            }
//下面通过x,y计算得到新的OrientationAngle,计算方法如下
//        private float computeNewOrientation(float x, float y) {
//           float orientationAngle = (float) -Math.atan2(-x, y) * RADIANS_TO_DEGREES;
            // atan2 returns [-180, 180]; normalize to [0, 360]
//            if (orientationAngle < 0) {
//               orientationAngle += 360;
//            }
//            return orientationAngle;
//        }
            floatnewOrientationAngle = computeNewOrientation(x, y);
//通过下面函数计算出Orientation的值。
            filterOrientation(absoluteTilt, newOrientationAngle);
            calculateNewRotation(mOrientationAngle, absoluteTilt);
        }

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
private static final int[][][] THRESHOLDS = newint[][][] {
                {{60,180}, {180,300}},
                {{0,30}, {195,315}, {315,360}},
                {{0,45}, {45,165}, {330,360}},
  
                // Handle situation where we are currently doing 180 rotation
                // but that is no longer allowed.
                {{0,45}, {45,135}, {135,225}, {225,315}, {315,360}},
        };
        // See THRESHOLDS
        privatestatic final int[][] ROTATE_TO = newint[][] {
                {ROTATION_90, ROTATION_270},
                {ROTATION_0, ROTATION_270, ROTATION_0},
                {ROTATION_0, ROTATION_90, ROTATION_0},
                {ROTATION_0, ROTATION_90, ROTATION_0, ROTATION_270, ROTATION_0},
        };
  
 privatestatic final int[][][] THRESHOLDS_WITH_180 = newint[][][] {
            {{60,165}, {165,195}, {195,300}},
            {{0,30}, {165,195}, {195,315}, {315,360}},
            {{0,45}, {45,165}, {165,195}, {330,360}},
            {{0,45}, {45,135}, {225,315}, {315,360}},
        };
 privatestatic final int[][] ROTATE_TO_WITH_180 = newint[][] {
        {ROTATION_90, ROTATION_180, ROTATION_270},
            {ROTATION_0, ROTATION_180, ROTATION_90, ROTATION_0},
            {ROTATION_0, ROTATION_270, ROTATION_180, ROTATION_0},
            {ROTATION_0, ROTATION_90, ROTATION_270, ROTATION_0},
        };
//当设备平放,屏幕朝正上方。以下四个常量分别代表:
privatestatic final int ROTATION_0 = 0;//初始情况。横/竖屏与一开始设置有关
privatestatic final int ROTATION_90 = 1;//右侧翻起侧立时,屏幕会旋转到这个方向。
privatestatic final int ROTATION_270 = 2;//左侧翻起度侧立时,屏幕会旋转到这个方向。
privatestatic final int ROTATION_180 = 3;//屏幕底部侧立时,屏幕会旋转到这个方向
  
//如上则
// {ROTATION_90, ROTATION_180, ROTATION_270}
//对应落在的范围为 {{60, 165}, {165, 195}, {195, 300}}
//{ROTATION_0, ROTATION_180, ROTATION_90, ROTATION_0}
//对应落在的范围为 {{0, 30}, {165, 195}, {195, 315}, {315, 360}}
//{ROTATION_0, ROTATION_270, ROTATION_180, ROTATION_0}
//对应落在的范围为 {{0, 45}, {45, 165}, {165, 195}, {330, 360}}
//{ROTATION_0, ROTATION_90, ROTATION_270, ROTATION_0}
//对应落在的范围为{{0, 45}, {45, 135}, {225, 315}, {315, 360}}
//所以如果需要微调的话只要修改对应的范围既可
  
//当前屏幕旋转方向为ROTATION_0时,取int[][] threshold=THRESHOLDS_WITH_180[0];
//此时的范围为:{{60, 165}, {165, 195}, {195, 300}}
//当前屏幕旋转方向为ROTATION_90时,取int[][] threshold=THRESHOLDS_WITH_180[1];
//此时的范围为:{{0, 30}, {165, 195}, {195, 315}, {315, 360}}
//当前屏幕旋转方向为ROTATION_270时,取int[][] threshold=THRESHOLDS_WITH_180[2];
//此时的范围为:{{0, 45}, {45, 165}, {165, 195}, {330, 360}}
//当前屏幕旋转方向为ROTATION_180时,取int[][] threshold=THRESHOLDS_WITH_180[3];
//此时的范围为:{{0, 45}, {45, 135}, {225, 315}, {315, 360}}
  
//例如当前我们的位置为ROTATION_90那么此时我们的THRESHOLDS_WITH_180就
//为{{0, 30}, {165, 195}, {195, 315}, {315, 360}}
//,然后通过filterOrientation计算出的orientation值落在了第2个元素围内,则到ROTATE_TO_WITH_180找到对应的值,
//这里为ROTATION_180,则此时把方向选装到ROTATION_180

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
private void calculateNewRotation(floatorientation, floattiltAngle) {
//这里的orientation,tiltAngle,mRotation为gsensor获取到的最新的数据
            if(localLOGV) Log.i(TAG, orientation + ", "+ tiltAngle + ", "+ mRotation);
//是否允许180度旋转,这里定义的其实就是变成了360度旋转了,
//如果mAllow180Rotation为false时,上面的变量中使用的为THRESHOLDS以及ROTATE_TO
//如果为ture则为THRESHOLDS_WITH_180与ROTATE_TO_WITH_180
            finalboolean allow180Rotation = mAllow180Rotation;
            intthresholdRanges[][] = allow180Rotation
                    ? THRESHOLDS_WITH_180[mRotation] : THRESHOLDS[mRotation];
            introw = -1;
            for(int i = 0; i < thresholdRanges.length; i++) {
                if(orientation >= thresholdRanges[i][0] && orientation < thresholdRanges[i][1]) {
                    row = i;
                    break;
                }
            }
            if(row == -1)return// no matching transition
  
            introtation = allow180Rotation
                    ? ROTATE_TO_WITH_180[mRotation][row] : ROTATE_TO[mRotation][row];
            if(tiltAngle > MAX_TRANSITION_TILT[rotation]) {
                // tilted too far flat to go to this rotation
                return;
            }
  
            if(localLOGV) Log.i(TAG, "orientation "+ orientation + " gives new rotation = "
                    + rotation);
            mRotation = rotation;
//这里通过WindowOrientationListener监听调用onOrientationChanged中的setRotation从而旋转界面
            mOrientationListener.onOrientationChanged(INTERNAL_TO_SURFACE_ROTATION[mRotation]);
        }

onOrientationChanged()的实现在PhoneWindowManager.java 中,如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class MyOrientationListener extends WindowOrientationListener {
       MyOrientationListener(Context context) {
           super(context);
       }
 
       @Override
       publicvoid onOrientationChanged(introtation) {
           // Send updates based on orientation value
           if(localLOGV) Log.v(TAG, "onOrientationChanged, rotation changed to "+rotation);
           try{
               mWindowManager.setRotation(rotation,false,
                       mFancyRotationAnimation);
       SystemProperties.set("service.screen.rotation",""+rotation);
           }catch (RemoteException e) {
               // Ignore
 
           }
       }
   }

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

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

相关文章推荐

关于android2.3调试g-sensor

关于android2.3调试g-sensor 由于工作上的需要,特地写了这么一份关于调试g-sensor的内容. 1.首先确定你要调试的设备的屏幕的横竖屏如何设置。 在代码中我们主要的流程如下:...

android2.3 G-sensor实现框架分析

本文主要描述了在android2.3平台G-sensor相关软硬件的体系架构和实现原理,按照Applications、Framework、HAL、Driver和Hardware五大层次分别介绍。 ...

Android中G-Sensor相关流程

  • 2012年11月23日 23:25
  • 73KB
  • 下载

MTK Android G-Sensor auto detect源码分析

环境:MTK Android4.4  硬件:MT8127 MMA8653 日期:2015年6月19日 在MTK的Gsensor构架中有一个auto detect的功能,只...

Android中G-Sensor相关流程 转

1.使G-sensor正常工作需要做的事:G-sensor driver文件包括:driver/i2c/chips/lis331dl.cdriver/i2c/chips/sensorioctl.hin...

Android基于G-Sensor的计步算法

一、写在分享之前 写在前面,最近项目需求研究计步功能,借鉴了一下别人的算法写了一个小例子,本文最后有源码地址。算法的准确度大概可以达到95.7%,综合起来觉得是比春雨略好,但是赢不了乐动力(可以达到...

简单说说Android G-sensor 的优化

原文地址:http://blog.csdn.net/yiyaaixuexi/article/details/6333803 近期在2.2中解决某个G-sensor的Bug的时候,意外的发现2.3其实...

<4>Android4.2 G-Sensor工作流程

转载来自:http://blog.csdn.net/myarrow/article/details/9044689 1. 简介     在了解Sensor工作流程以前,一直...

Android_基于G-Sensor的计步算法

一、写在分享之前 学习android也有将近一年的时间了,一直在看大牛们分享的知识,今天也想分享自己之前的一点研究,关于计步器算法的。 目前在计步领域比较领先的有乐动力以及春雨计步器,在做算法的参数调...
  • finnfu
  • finnfu
  • 2015年04月25日 19:39
  • 14837

android上层应用apk到G-sensor driver的大致流程

android上层应用apk到G-sensor driver的大致流程:Android HAL层,即硬件抽象层,是Google响应厂家“希望不公开源码”的要求推出的新概念1,源代码和目标位置源代码: ...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:关于android2.3调试g-sensor
举报原因:
原因补充:

(最多只允许输入30个字)