Android传感器API之：加速度Accelerometer功能源码

加速度传感器，主要是感应手机的运动。捕获三个参数，分别表示空间坐标系中X、Y、Z轴方向上的加速度减去重力加速度在相应轴上的分量，其单位均为m/s2。和之前几篇传感器功能介绍中的一样，这几个方向就不再多说了~~

Rexsee的源码如下，有兴趣的朋友可以再去找找，社区公开的源码里有包括加速度在内的，重力、磁场、温度、距离和方向等传感器功能。 http://www.rexsee.com/CN/helpReference.php

1. 
   
2. /*
   
3. * Copyright (C) 2011 The Rexsee Open Source Project
   
4. *
   
5. * Licensed under the Rexsee License, Version 1.0 (the "License");
   
6. * you may not use this file except in compliance with the License.
   
7. * You may obtain a copy of the License at
   
8. *
   
9. *      http://www.rexsee.com/CN/legal/license.html
   
10. *
    
11. * Unless required by applicable law or agreed to in writing, software
    
12. * distributed under the License is distributed on an "AS IS" BASIS,
    
13. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    
14. * See the License for the specific language governing permissions and
    
15. * limitations under the License.
    
16. */
    
17. 
    
18. package rexsee.sensor; 
    
19. 
    
20. import rexsee.core.browser.JavascriptInterface; 
    
21. import rexsee.core.browser.RexseeBrowser; 
    
22. import android.content.Context; 
    
23. import android.hardware.Sensor; 
    
24. import android.hardware.SensorEvent; 
    
25. import android.hardware.SensorEventListener; 
    
26. import android.hardware.SensorManager; 
    
27. 
    
28. public class RexseeSensorAccelerometer implements JavascriptInterface { 
    
29. 
    
30.        private static final String INTERFACE_NAME = "Accelerometer"; 
    
31.        @Override 
    
32.        public String getInterfaceName() { 
    
33.                return mBrowser.application.resources.prefix + INTERFACE_NAME; 
    
34.        } 
    
35.        @Override 
    
36.        public JavascriptInterface getInheritInterface(RexseeBrowser childBrowser) { 
    
37.                return this; 
    
38.        } 
    
39.        @Override 
    
40.        public JavascriptInterface getNewInterface(RexseeBrowser childBrowser) { 
    
41.                return new RexseeSensorAccelerometer(childBrowser); 
    
42.        } 
    
43. 
    
44.        public static final String EVENT_ONACCELERATE = "onAccelerometerChanged"; 
    
45. 
    
46.        private final Context mContext; 
    
47.        private final RexseeBrowser mBrowser; 
    
48.        private final SensorManager mSensorManager; 
    
49.        private final SensorEventListener mSensorListener; 
    
50.        private final Sensor mSensor; 
    
51. 
    
52.        private int mRate = SensorManager.SENSOR_DELAY_NORMAL; 
    
53.        private int mCycle = 100; 
    
54.        private int mEventCycle = 100; 
    
55. 
    
56.        private float mAccuracyX = 0; 
    
57.        private float mAccuracyY = 0; 
    
58.        private float mAccuracyZ = 0; 
    
59. 
    
60.        private long lastUpdate = -1; 
    
61.        private long lastEvent = -1; 
    
62. 
    
63.        private float x = -999, y = -999, z = -999; 
    
64. 
    
65.        public RexseeSensorAccelerometer(RexseeBrowser browser) { 
    
66. 
    
67.                mContext = browser.getContext(); 
    
68.                mBrowser = browser; 
    
69.                browser.eventList.add(EVENT_ONACCELERATE); 
    
70. 
    
71.                mSensorManager = (SensorManager) mContext.getSystemService(Context.SENSOR_SERVICE); 
    
72. 
    
73.                mSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER); 
    
74. 
    
75.                mSensorListener = new SensorEventListener() { 
    
76.                        @Override 
    
77.                        public void onAccuracyChanged(Sensor sensor, int accuracy) { 
    
78.                        } 
    
79.                        @Override 
    
80.                        public void onSensorChanged(SensorEvent event) { 
    
81.                                if (event.sensor.getType() != Sensor.TYPE_ACCELEROMETER) return; 
    
82.                                long curTime = System.currentTimeMillis(); 
    
83.                                if (lastUpdate == -1 || (curTime - lastUpdate) > mCycle) { 
    
84.                                        lastUpdate = curTime; 
    
85.                                        float lastX = x; 
    
86.                                        float lastY = y; 
    
87.                                        float lastZ = z; 
    
88.                                        x = event.values[SensorManager.DATA_X]; 
    
89.                                        y = event.values[SensorManager.DATA_Y]; 
    
90.                                        z = event.values[SensorManager.DATA_Z]; 
    
91.                                        if (lastEvent == -1 || (curTime - lastEvent) > mEventCycle) { 
    
92.                                                if ( 
    
93.                                                                (mAccuracyX >= 0 && Math.abs(x - lastX) > mAccuracyX) 
    
94.                                                                                || (mAccuracyY >= 0 && Math.abs(y - lastY) > mAccuracyY) 
    
95.                                                                                || (mAccuracyZ >= 0 && Math.abs(z - lastZ) > mAccuracyZ) 
    
96.                                                        ) { 
    
97.                                                                lastEvent = curTime; 
    
98.                                                                mBrowser.eventList.run(EVENT_ONACCELERATE); 
    
99.                                                        } 
    
100.                                                } 
     
101.                                        } 
     
102.                                } 
     
103.                }; 
     
104. 
     
105.        } 
     
106. 
     
107.        public String getLastKnownX() { 
     
108.                return (x == -999) ? "null" : String.valueOf(x); 
     
109.        } 
     
110.        public String getLastKnownY() { 
     
111.                return (y == -999) ? "null" : String.valueOf(y); 
     
112.        } 
     
113.        public String getLastKnownZ() { 
     
114.                return (z == -999) ? "null" : String.valueOf(z); 
     
115.        } 
     
116. 
     
117.        public void setRate(String rate) { 
     
118.                mRate = SensorRate.getInt(rate); 
     
119.        } 
     
120.        public String getRate() { 
     
121.                return SensorRate.getString(mRate); 
     
122.        } 
     
123.        public void setCycle(int milliseconds) { 
     
124.                mCycle = milliseconds; 
     
125.        } 
     
126.        public int getCycle() { 
     
127.                return mCycle; 
     
128.        } 
     
129.        public void setEventCycle(int milliseconds) { 
     
130.                mEventCycle = milliseconds; 
     
131.        } 
     
132.        public int getEventCycle() { 
     
133.                return mEventCycle; 
     
134.        } 
     
135.        public void setAccuracy(float x, float y, float z) { 
     
136.                mAccuracyX = x; 
     
137.                mAccuracyY = y; 
     
138.                mAccuracyZ = z; 
     
139.        } 
     
140.        public float getAccuracyX() { 
     
141.                return mAccuracyX; 
     
142.        } 
     
143.        public float getAccuracyY() { 
     
144.                return mAccuracyY; 
     
145.        } 
     
146.        public float getAccuracyZ() { 
     
147.                return mAccuracyZ; 
     
148.        } 
     
149. 
     
150.        public boolean isReady() { 
     
151.                return (mSensor == null) ? false : true; 
     
152.        } 
     
153.        public void start() { 
     
154.                if (isReady()) { 
     
155.                        mSensorManager.registerListener(mSensorListener, mSensor, mRate); 
     
156.                } else { 
     
157.                        mBrowser.exception(getInterfaceName(), "Accelerometer is not found."); 
     
158.                } 
     
159.        } 
     
160.        public void stop() { 
     
161.                if (isReady()) { 
     
162.                        mSensorManager.unregisterListener(mSensorListener); 
     
163.                } 
     
164.        } 
     
165. 
     
166. }