samples/ApiDemos/src/com/example/android/apis/os/Sensors.java - platform/development - Git at Google

 /*
  * Copyright (C) 2007 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.example.android.apis.os;

 import android.app.Activity;
 import android.content.Context;
 import android.os.Bundle;
 import android.view.View;
 import android.hardware.Sensor;
 import android.hardware.SensorEvent;
 import android.hardware.SensorEventListener;
 import android.hardware.SensorManager;
 import android.graphics.Bitmap;
 import android.graphics.Canvas;
 import android.graphics.Color;
 import android.graphics.Paint;
 import android.graphics.Path;
 import android.graphics.RectF;

 /**
  * <h3>Application that displays the values of the acceleration sensor graphically.</h3>

 <p>This demonstrates the {@link android.hardware.SensorManager android.hardware.SensorManager} class.

 <h4>Demo</h4>
 OS / Sensors

 <h4>Source files</h4>
  * <table class="LinkTable">
  *         <tr>
  *             <td >src/com.example.android.apis/os/Sensors.java</td>
  *             <td >Sensors</td>
  *         </tr>
  * </table>
  */
 public class Sensors extends Activity {
     private SensorManager mSensorManager;
     private GraphView mGraphView;

     private class GraphView extends View implements SensorEventListener
     {
         private Bitmap  mBitmap;
         private Paint   mPaint = new Paint();
         private Canvas  mCanvas = new Canvas();
         private Path    mPath = new Path();
         private RectF   mRect = new RectF();
         private float   mLastValues[] = new float[3*2];
         private float   mOrientationValues[] = new float[3];
         private int     mColors[] = new int[3*2];
         private float   mLastX;
         private float   mScale[] = new float[2];
         private float   mYOffset;
         private float   mMaxX;
         private float   mSpeed = 1.0f;
         private float   mWidth;
         private float   mHeight;

         public GraphView(Context context) {
             super(context);
             mColors[0] = Color.argb(192, 255, 64, 64);
             mColors[1] = Color.argb(192, 64, 128, 64);
             mColors[2] = Color.argb(192, 64, 64, 255);
             mColors[3] = Color.argb(192, 64, 255, 255);
             mColors[4] = Color.argb(192, 128, 64, 128);
             mColors[5] = Color.argb(192, 255, 255, 64);

             mPaint.setFlags(Paint.ANTI_ALIAS_FLAG);
             mRect.set(-0.5f, -0.5f, 0.5f, 0.5f);
             mPath.arcTo(mRect, 0, 180);
         }

         @Override
         protected void onSizeChanged(int w, int h, int oldw, int oldh) {
             mBitmap = Bitmap.createBitmap(w, h, Bitmap.Config.RGB_565);
             mCanvas.setBitmap(mBitmap);
             mCanvas.drawColor(0xFFFFFFFF);
             mYOffset = h * 0.5f;
             mScale[0] = - (h * 0.5f * (1.0f / (SensorManager.STANDARD_GRAVITY * 2)));
             mScale[1] = - (h * 0.5f * (1.0f / (SensorManager.MAGNETIC_FIELD_EARTH_MAX)));
             mWidth = w;
             mHeight = h;
             if (mWidth < mHeight) {
                 mMaxX = w;
             } else {
                 mMaxX = w-50;
             }
             mLastX = mMaxX;
             super.onSizeChanged(w, h, oldw, oldh);
         }

         @Override
         protected void onDraw(Canvas canvas) {
             synchronized (this) {
                 if (mBitmap != null) {
                     final Paint paint = mPaint;
                     final Path path = mPath;
                     final int outer = 0xFFC0C0C0;
                     final int inner = 0xFFff7010;

                     if (mLastX >= mMaxX) {
                         mLastX = 0;
                         final Canvas cavas = mCanvas;
                         final float yoffset = mYOffset;
                         final float maxx = mMaxX;
                         final float oneG = SensorManager.STANDARD_GRAVITY * mScale[0];
                         paint.setColor(0xFFAAAAAA);
                         cavas.drawColor(0xFFFFFFFF);
                         cavas.drawLine(0, yoffset,      maxx, yoffset,      paint);
                         cavas.drawLine(0, yoffset+oneG, maxx, yoffset+oneG, paint);
                         cavas.drawLine(0, yoffset-oneG, maxx, yoffset-oneG, paint);
                     }
                     canvas.drawBitmap(mBitmap, 0, 0, null);

                     float[] values = mOrientationValues;
                     if (mWidth < mHeight) {
                         float w0 = mWidth * 0.333333f;
                         float w  = w0 - 32;
                         float x = w0*0.5f;
                         for (int i=0 ; i<3 ; i++) {
                             canvas.save(Canvas.MATRIX_SAVE_FLAG);
                             canvas.translate(x, w*0.5f + 4.0f);
                             canvas.save(Canvas.MATRIX_SAVE_FLAG);
                             paint.setColor(outer);
                             canvas.scale(w, w);
                             canvas.drawOval(mRect, paint);
                             canvas.restore();
                             canvas.scale(w-5, w-5);
                             paint.setColor(inner);
                             canvas.rotate(-values[i]);
                             canvas.drawPath(path, paint);
                             canvas.restore();
                             x += w0;
                         }
                     } else {
                         float h0 = mHeight * 0.333333f;
                         float h  = h0 - 32;
                         float y = h0*0.5f;
                         for (int i=0 ; i<3 ; i++) {
                             canvas.save(Canvas.MATRIX_SAVE_FLAG);
                             canvas.translate(mWidth - (h*0.5f + 4.0f), y);
                             canvas.save(Canvas.MATRIX_SAVE_FLAG);
                             paint.setColor(outer);
                             canvas.scale(h, h);
                             canvas.drawOval(mRect, paint);
                             canvas.restore();
                             canvas.scale(h-5, h-5);
                             paint.setColor(inner);
                             canvas.rotate(-values[i]);
                             canvas.drawPath(path, paint);
                             canvas.restore();
                             y += h0;
                         }
                     }

                 }
             }
         }

         public void onSensorChanged(SensorEvent event) {
             //Log.d(TAG, "sensor: " + sensor + ", x: " + values[0] + ", y: " + values[1] + ", z: " + values[2]);
             synchronized (this) {
                 if (mBitmap != null) {
                     final Canvas canvas = mCanvas;
                     final Paint paint = mPaint;
                     if (event.sensor.getType() == Sensor.TYPE_ORIENTATION) {
                         for (int i=0 ; i<3 ; i++) {
                             mOrientationValues[i] = event.values[i];
                         }
                     } else {
                         float deltaX = mSpeed;
                         float newX = mLastX + deltaX;

                         int j = (event.sensor.getType() == Sensor.TYPE_MAGNETIC_FIELD) ? 1 : 0;
                         for (int i=0 ; i<3 ; i++) {
                             int k = i+j*3;
                             final float v = mYOffset + event.values[i] * mScale[j];
                             paint.setColor(mColors[k]);
                             canvas.drawLine(mLastX, mLastValues[k], newX, v, paint);
                             mLastValues[k] = v;
                         }
                         if (event.sensor.getType() == Sensor.TYPE_MAGNETIC_FIELD)
                             mLastX += mSpeed;
                     }
                     invalidate();
                 }
             }
         }

         public void onAccuracyChanged(Sensor sensor, int accuracy) {
         }
     }

     /**
      * Initialization of the Activity after it is first created.  Must at least
      * call {@link android.app.Activity#setContentView setContentView()} to
      * describe what is to be displayed in the screen.
      */
     @Override
     protected void onCreate(Bundle savedInstanceState) {
         // Be sure to call the super class.
         super.onCreate(savedInstanceState);

         mSensorManager = (SensorManager) getSystemService(SENSOR_SERVICE);
         mGraphView = new GraphView(this);
         setContentView(mGraphView);
     }

     @Override
     protected void onResume() {
         super.onResume();
         mSensorManager.registerListener(mGraphView,
                 mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER),
                 SensorManager.SENSOR_DELAY_FASTEST);
         mSensorManager.registerListener(mGraphView,
                 mSensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD),
                 SensorManager.SENSOR_DELAY_FASTEST);
         mSensorManager.registerListener(mGraphView,
                 mSensorManager.getDefaultSensor(Sensor.TYPE_ORIENTATION),
                 SensorManager.SENSOR_DELAY_FASTEST);
     }

     @Override
     protected void onStop() {
         mSensorManager.unregisterListener(mGraphView);
         super.onStop();
     }
 }
	/*
	* Copyright (C) 2007 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.example.android.apis.os;

	import android.app.Activity;
	import android.content.Context;
	import android.os.Bundle;
	import android.view.View;
	import android.hardware.Sensor;
	import android.hardware.SensorEvent;
	import android.hardware.SensorEventListener;
	import android.hardware.SensorManager;
	import android.graphics.Bitmap;
	import android.graphics.Canvas;
	import android.graphics.Color;
	import android.graphics.Paint;
	import android.graphics.Path;
	import android.graphics.RectF;

	/**
	* <h3>Application that displays the values of the acceleration sensor graphically.</h3>

	<p>This demonstrates the {@link android.hardware.SensorManager android.hardware.SensorManager} class.

	<h4>Demo</h4>
	OS / Sensors

	<h4>Source files</h4>
	* <table class="LinkTable">
	* <tr>
	* <td >src/com.example.android.apis/os/Sensors.java</td>
	* <td >Sensors</td>
	* </tr>
	* </table>
	*/
	public class Sensors extends Activity {
	private SensorManager mSensorManager;
	private GraphView mGraphView;

	private class GraphView extends View implements SensorEventListener
	{
	private Bitmap mBitmap;
	private Paint mPaint = new Paint();
	private Canvas mCanvas = new Canvas();
	private Path mPath = new Path();
	private RectF mRect = new RectF();
	private float mLastValues[] = new float[3*2];
	private float mOrientationValues[] = new float[3];
	private int mColors[] = new int[3*2];
	private float mLastX;
	private float mScale[] = new float[2];
	private float mYOffset;
	private float mMaxX;
	private float mSpeed = 1.0f;
	private float mWidth;
	private float mHeight;

	public GraphView(Context context) {
	super(context);
	mColors[0] = Color.argb(192, 255, 64, 64);
	mColors[1] = Color.argb(192, 64, 128, 64);
	mColors[2] = Color.argb(192, 64, 64, 255);
	mColors[3] = Color.argb(192, 64, 255, 255);
	mColors[4] = Color.argb(192, 128, 64, 128);
	mColors[5] = Color.argb(192, 255, 255, 64);

	mPaint.setFlags(Paint.ANTI_ALIAS_FLAG);
	mRect.set(-0.5f, -0.5f, 0.5f, 0.5f);
	mPath.arcTo(mRect, 0, 180);
	}

	@Override
	protected void onSizeChanged(int w, int h, int oldw, int oldh) {
	mBitmap = Bitmap.createBitmap(w, h, Bitmap.Config.RGB_565);
	mCanvas.setBitmap(mBitmap);
	mCanvas.drawColor(0xFFFFFFFF);
	mYOffset = h * 0.5f;
	mScale[0] = - (h * 0.5f * (1.0f / (SensorManager.STANDARD_GRAVITY * 2)));
	mScale[1] = - (h * 0.5f * (1.0f / (SensorManager.MAGNETIC_FIELD_EARTH_MAX)));
	mWidth = w;
	mHeight = h;
	if (mWidth < mHeight) {
	mMaxX = w;
	} else {
	mMaxX = w-50;
	}
	mLastX = mMaxX;
	super.onSizeChanged(w, h, oldw, oldh);
	}

	@Override
	protected void onDraw(Canvas canvas) {
	synchronized (this) {
	if (mBitmap != null) {
	final Paint paint = mPaint;
	final Path path = mPath;
	final int outer = 0xFFC0C0C0;
	final int inner = 0xFFff7010;

	if (mLastX >= mMaxX) {
	mLastX = 0;
	final Canvas cavas = mCanvas;
	final float yoffset = mYOffset;
	final float maxx = mMaxX;
	final float oneG = SensorManager.STANDARD_GRAVITY * mScale[0];
	paint.setColor(0xFFAAAAAA);
	cavas.drawColor(0xFFFFFFFF);
	cavas.drawLine(0, yoffset, maxx, yoffset, paint);
	cavas.drawLine(0, yoffset+oneG, maxx, yoffset+oneG, paint);
	cavas.drawLine(0, yoffset-oneG, maxx, yoffset-oneG, paint);
	}
	canvas.drawBitmap(mBitmap, 0, 0, null);

	float[] values = mOrientationValues;
	if (mWidth < mHeight) {
	float w0 = mWidth * 0.333333f;
	float w = w0 - 32;
	float x = w0*0.5f;
	for (int i=0 ; i<3 ; i++) {
	canvas.save(Canvas.MATRIX_SAVE_FLAG);
	canvas.translate(x, w*0.5f + 4.0f);
	canvas.save(Canvas.MATRIX_SAVE_FLAG);
	paint.setColor(outer);
	canvas.scale(w, w);
	canvas.drawOval(mRect, paint);
	canvas.restore();
	canvas.scale(w-5, w-5);
	paint.setColor(inner);
	canvas.rotate(-values[i]);
	canvas.drawPath(path, paint);
	canvas.restore();
	x += w0;
	}
	} else {
	float h0 = mHeight * 0.333333f;
	float h = h0 - 32;
	float y = h0*0.5f;
	for (int i=0 ; i<3 ; i++) {
	canvas.save(Canvas.MATRIX_SAVE_FLAG);
	canvas.translate(mWidth - (h*0.5f + 4.0f), y);
	canvas.save(Canvas.MATRIX_SAVE_FLAG);
	paint.setColor(outer);
	canvas.scale(h, h);
	canvas.drawOval(mRect, paint);
	canvas.restore();
	canvas.scale(h-5, h-5);
	paint.setColor(inner);
	canvas.rotate(-values[i]);
	canvas.drawPath(path, paint);
	canvas.restore();
	y += h0;
	}
	}

	}
	}
	}

	public void onSensorChanged(SensorEvent event) {
	//Log.d(TAG, "sensor: " + sensor + ", x: " + values[0] + ", y: " + values[1] + ", z: " + values[2]);
	synchronized (this) {
	if (mBitmap != null) {
	final Canvas canvas = mCanvas;
	final Paint paint = mPaint;
	if (event.sensor.getType() == Sensor.TYPE_ORIENTATION) {
	for (int i=0 ; i<3 ; i++) {
	mOrientationValues[i] = event.values[i];
	}
	} else {
	float deltaX = mSpeed;
	float newX = mLastX + deltaX;

	int j = (event.sensor.getType() == Sensor.TYPE_MAGNETIC_FIELD) ? 1 : 0;
	for (int i=0 ; i<3 ; i++) {
	int k = i+j*3;
	final float v = mYOffset + event.values[i] * mScale[j];
	paint.setColor(mColors[k]);
	canvas.drawLine(mLastX, mLastValues[k], newX, v, paint);
	mLastValues[k] = v;
	}
	if (event.sensor.getType() == Sensor.TYPE_MAGNETIC_FIELD)
	mLastX += mSpeed;
	}
	invalidate();
	}
	}
	}

	public void onAccuracyChanged(Sensor sensor, int accuracy) {
	}
	}

	/**
	* Initialization of the Activity after it is first created. Must at least
	* call {@link android.app.Activity#setContentView setContentView()} to
	* describe what is to be displayed in the screen.
	*/
	@Override
	protected void onCreate(Bundle savedInstanceState) {
	// Be sure to call the super class.
	super.onCreate(savedInstanceState);

	mSensorManager = (SensorManager) getSystemService(SENSOR_SERVICE);
	mGraphView = new GraphView(this);
	setContentView(mGraphView);
	}

	@Override
	protected void onResume() {
	super.onResume();
	mSensorManager.registerListener(mGraphView,
	mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER),
	SensorManager.SENSOR_DELAY_FASTEST);
	mSensorManager.registerListener(mGraphView,
	mSensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD),
	SensorManager.SENSOR_DELAY_FASTEST);
	mSensorManager.registerListener(mGraphView,
	mSensorManager.getDefaultSensor(Sensor.TYPE_ORIENTATION),
	SensorManager.SENSOR_DELAY_FASTEST);
	}

	@Override
	protected void onStop() {
	mSensorManager.unregisterListener(mGraphView);
	super.onStop();
	}
	}