1. /*各种传感器实例
   
2. */
   
3. public class Sensors extends Activity {
   
4.     private SensorManager mSensorManager;
   
5.     private GraphView mGraphView;
   
6. /*View的子类实现SensorEventListener接口*/
   
7.     private class GraphView extends View implements SensorEventListener
   
8.     {
   
9. /*画笔，画布，路径，矩形，颜色，接收传感器数据的数组变量*/
   
10.         private Bitmap  mBitmap;
    
11.         private Paint   mPaint = new Paint();
    
12.         private Canvas  mCanvas = new Canvas();
    
13.         private Path    mPath = new Path();
    
14.         private RectF   mRect = new RectF();
    
15.         private float   mLastValues[] = new float[3*2];
    
16.         private float   mOrientationValues[] = new float[3];
    
17.         private int     mColors[] = new int[3*2];
    
18.         private float   mLastX;
    
19.         private float   mScale[] = new float[2];
    
20.         private float   mYOffset;
    
21.         private float   mMaxX;
    
22.         private float   mSpeed = 1.0f;
    
23.         private float   mWidth;
    
24.         private float   mHeight;
    
25.         
    
26.         public GraphView(Context context) {
    
27.             super(context);
    
28.             mColors[0] = Color.argb(192, 255, 64, 64);
    
29.             mColors[1] = Color.argb(192, 64, 128, 64);
    
30.             mColors[2] = Color.argb(192, 64, 64, 255);
    
31.             mColors[3] = Color.argb(192, 64, 255, 255);
    
32.             mColors[4] = Color.argb(192, 128, 64, 128);
    
33.             mColors[5] = Color.argb(192, 255, 255, 64);
    
34. 
    
35.             mPaint.setFlags(Paint.ANTI_ALIAS_FLAG);
    
36.             mRect.set(-0.5f, -0.5f, 0.5f, 0.5f);
    
37.             mPath.arcTo(mRect, 0, 180);
    
38.         }
    
39. //view尺寸改变后的响应      
    
40.         @Override
    
41.         protected void onSizeChanged(int w, int h, int oldw, int oldh) {
    
42.             mBitmap = Bitmap.createBitmap(w, h, Bitmap.Config.RGB_565);
    
43.             mCanvas.setBitmap(mBitmap);
    
44.             mCanvas.drawColor(0xFFFFFFFF);
    
45.             mYOffset = h * 0.5f;
    
46.             mScale[0] = - (h * 0.5f * (1.0f / (SensorManager.STANDARD_GRAVITY * 2)));
    
47.             mScale[1] = - (h * 0.5f * (1.0f / (SensorManager.MAGNETIC_FIELD_EARTH_MAX)));
    
48.             mWidth = w;
    
49.             mHeight = h;
    
50.             if (mWidth < mHeight) {
    
51.                 mMaxX = w;
    
52.             } else {
    
53.                 mMaxX = w-50;
    
54.             }
    
55.             mLastX = mMaxX;
    
56.             super.onSizeChanged(w, h, oldw, oldh);
    
57.         }
    
58. //自动重绘函数
    
59.         @Override
    
60.         protected void onDraw(Canvas canvas) {
    
61.             synchronized (this) {
    
62.                 if (mBitmap != null) {
    
63.                     final Paint paint = mPaint;
    
64.                     final Path path = mPath;
    
65.                     final int outer = 0xFFC0C0C0;
    
66.                     final int inner = 0xFFff7010;
    
67. 
    
68.                     if (mLastX >= mMaxX) {
    
69.                         mLastX = 0;
    
70.                         final Canvas cavas = mCanvas;
    
71.                         final float yoffset = mYOffset;
    
72.                         final float maxx = mMaxX;
    
73.                         final float oneG = SensorManager.STANDARD_GRAVITY * mScale[0];
    
74.                         paint.setColor(0xFFAAAAAA);
    
75.                         cavas.drawColor(0xFFFFFFFF);
    
76.                         cavas.drawLine(0, yoffset,      maxx, yoffset,      paint);
    
77.                         cavas.drawLine(0, yoffset+oneG, maxx, yoffset+oneG, paint);
    
78.                         cavas.drawLine(0, yoffset-oneG, maxx, yoffset-oneG, paint);
    
79.                     }
    
80.                     canvas.drawBitmap(mBitmap, 0, 0, null);
    
81. 
    
82.                     float[] values = mOrientationValues;
    
83.                     if (mWidth < mHeight) {
    
84.                         float w0 = mWidth * 0.333333f;
    
85.                         float w  = w0 - 32;
    
86.                         float x = w0*0.5f;
    
87.                         for (int i=0 ; i<3 ; i++) {
    
88.                             canvas.save(Canvas.MATRIX_SAVE_FLAG);
    
89.                             canvas.translate(x, w*0.5f + 4.0f);
    
90.                             canvas.save(Canvas.MATRIX_SAVE_FLAG);
    
91.                             paint.setColor(outer);
    
92.                             canvas.scale(w, w);
    
93.                             canvas.drawOval(mRect, paint);
    
94.                             canvas.restore();
    
95.                             canvas.scale(w-5, w-5);
    
96.                             paint.setColor(inner);
    
97.                             canvas.rotate(-values[i]);
    
98.                             canvas.drawPath(path, paint);
    
99.                             canvas.restore();
    
100.                             x += w0;
     
101.                         }
     
102.                     } else {
     
103.                         float h0 = mHeight * 0.333333f;
     
104.                         float h  = h0 - 32;
     
105.                         float y = h0*0.5f;
     
106.                         for (int i=0 ; i<3 ; i++) {
     
107.                             canvas.save(Canvas.MATRIX_SAVE_FLAG);
     
108.                             canvas.translate(mWidth - (h*0.5f + 4.0f), y);
     
109.                             canvas.save(Canvas.MATRIX_SAVE_FLAG);
     
110.                             paint.setColor(outer);
     
111.                             canvas.scale(h, h);
     
112.                             canvas.drawOval(mRect, paint);
     
113.                             canvas.restore();
     
114.                             canvas.scale(h-5, h-5);
     
115.                             paint.setColor(inner);
     
116.                             canvas.rotate(-values[i]);
     
117.                             canvas.drawPath(path, paint);
     
118.                             canvas.restore();
     
119.                             y += h0;
     
120.                         }
     
121.                     }
     
122. 
     
123.                 }
     
124.             }
     
125.         }
     
126. /*传感器数据变化时的响应函数*/
     
127.         public void onSensorChanged(SensorEvent event) {
     
128.             //Log.d(TAG, "sensor: " + sensor + ", x: " + values[0] + ", y: " + values[1] + ", z: " + values[2]);
     
129.             synchronized (this) {
     
130.                 if (mBitmap != null) {
     
131.                     final Canvas canvas = mCanvas;
     
132.                     final Paint paint = mPaint;
     
133. //手机屏幕方向传感
     
134.                     if (event.sensor.getType() == Sensor.TYPE_ORIENTATION) {
     
135.                         for (int i=0 ; i<3 ; i++) {
     
136.                             mOrientationValues[i] = event.values[i];
     
137.                         }
     
138.                     } else {
     
139.                         float deltaX = mSpeed;
     
140.                         float newX = mLastX + deltaX;
     
141. 
     
142.                         int j = (event.sensor.getType() == Sensor.TYPE_MAGNETIC_FIELD) ? 1 : 0;
     
143.                         for (int i=0 ; i<3 ; i++) {
     
144.                             int k = i+j*3;
     
145.                             final float v = mYOffset + event.values[i] * mScale[j];
     
146.                             paint.setColor(mColors[k]);
     
147.                             canvas.drawLine(mLastX, mLastValues[k], newX, v, paint);
     
148.                             mLastValues[k] = v;
     
149.                         }
     
150. //地磁场方向传感
     
151.                         if (event.sensor.getType() == Sensor.TYPE_MAGNETIC_FIELD)
     
152.                             mLastX += mSpeed;
     
153.                     }
     
154.                     invalidate();
     
155.                 }
     
156.             }
     
157.         }
     
158. 
     
159.         public void onAccuracyChanged(Sensor sensor, int accuracy) {
     
160.         }
     
161.     }
     
162.    
     
163.     /**
     
164.      *初始化程序
     
165.      */
     
166.     @Override
     
167.     protected void onCreate(Bundle savedInstanceState) {
     
168.         // Be sure to call the super class.
     
169.         super.onCreate(savedInstanceState);
     
170. 
     
171.         mSensorManager = (SensorManager) getSystemService(SENSOR_SERVICE);
     
172.         mGraphView = new GraphView(this);
     
173.         setContentView(mGraphView);
     
174.     }
     
175. 
     
176.     @Override
     
177.     protected void onResume() {
     
178.         super.onResume();
     
179. //注册加速度传感器
     
180.         mSensorManager.registerListener(mGraphView,
     
181.                 mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER),
     
182.                 SensorManager.SENSOR_DELAY_FASTEST);
     
183. //注册地磁场传感器
     
184.         mSensorManager.registerListener(mGraphView,
     
185.                 mSensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD),
     
186.                 SensorManager.SENSOR_DELAY_FASTEST);
     
187. //注册屏幕方向传感器
     
188.         mSensorManager.registerListener(mGraphView,
     
189.                 mSensorManager.getDefaultSensor(Sensor.TYPE_ORIENTATION),
     
190.                 SensorManager.SENSOR_DELAY_FASTEST);
     
191.     }
     
192.    
     
193.     @Override
     
194.     protected void onStop() {
     
195.         mSensorManager.unregisterListener(mGraphView);
     
196.         super.onStop();
     
197.     }
     
198. }
     

复制代码

值得学习ing!