Sensor Test : Sensor « Hardware « Android






Sensor Test

   
/*
 * 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 app.test;

import android.app.Activity;
import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Path;
import android.graphics.Picture;
import android.graphics.Rect;
import android.graphics.drawable.Drawable;
import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.hardware.SensorManager;
import android.os.Bundle;
import android.util.AttributeSet;
import android.util.Config;
import android.util.Log;
import android.view.View;
import android.view.ViewGroup;
import android.view.ViewParent;
import android.widget.LinearLayout.LayoutParams;

public class SensorTest extends GraphicsActivity {
  private final String TAG = "SensorTest";

  private SensorManager mSensorManager;
  private Sensor mSensor;
  private SampleView mView;
  private float[] mValues;

  private static class RunAve {
    private final float[] mWeights;
    private final float mWeightScale;
    private final float[] mSamples;
    private final int mDepth;
    private int mCurr;

    public RunAve(float[] weights) {
      mWeights = weights;

      float sum = 0;
      for (int i = 0; i < weights.length; i++) {
        sum += weights[i];
      }
      mWeightScale = 1 / sum;

      mDepth = weights.length;
      mSamples = new float[mDepth];
      mCurr = 0;
    }

    public void addSample(float value) {
      mSamples[mCurr] = value;
      mCurr = (mCurr + 1) % mDepth;
    }

    public float computeAve() {
      final int depth = mDepth;
      int index = mCurr;
      float sum = 0;
      for (int i = 0; i < depth; i++) {
        sum += mWeights[i] * mSamples[index];
        index -= 1;
        if (index < 0) {
          index = depth - 1;
        }
      }
      return sum * mWeightScale;
    }
  };

  private final SensorEventListener mListener = new SensorEventListener() {

    private final float[] mScale = new float[] { 2, 2.5f, 0.5f }; // accel
    private float[] mPrev = new float[3];
    private long mLastGestureTime;

    public void onSensorChanged(SensorEvent event) {
      boolean show = false;
      float[] diff = new float[3];

      for (int i = 0; i < 3; i++) {
        diff[i] = Math.round(mScale[i] * (event.values[i] - mPrev[i])
            * 0.45f);
        if (Math.abs(diff[i]) > 0) {
          show = true;
        }
        mPrev[i] = event.values[i];
      }

      if (show) {
        // only shows if we think the delta is big enough, in an attempt
        // to detect "serious" moves left/right or up/down
        Log.e(TAG, "sensorChanged " + event.sensor.getName() + " ("
            + event.values[0] + ", " + event.values[1] + ", "
            + event.values[2] + ")" + " diff(" + diff[0] + " "
            + diff[1] + " " + diff[2] + ")");
      }

      long now = android.os.SystemClock.uptimeMillis();
      if (now - mLastGestureTime > 1000) {
        mLastGestureTime = 0;

        float x = diff[0];
        float y = diff[1];
        boolean gestX = Math.abs(x) > 3;
        boolean gestY = Math.abs(y) > 3;

        if ((gestX || gestY) && !(gestX && gestY)) {
          if (gestX) {
            if (x < 0) {
              Log.e("test", "<<<<<<<< LEFT <<<<<<<<<<<<");
            } else {
              Log.e("test", ">>>>>>>>> RITE >>>>>>>>>>>");
            }
          } else {
            if (y < -2) {
              Log.e("test", "<<<<<<<< UP <<<<<<<<<<<<");
            } else {
              Log.e("test", ">>>>>>>>> DOWN >>>>>>>>>>>");
            }
          }
          mLastGestureTime = now;
        }
      }
    }

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

  @Override
  protected void onCreate(Bundle icicle) {
    super.onCreate(icicle);
    mSensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
    mSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
    mView = new SampleView(this);
    setContentView(mView);
    if (Config.DEBUG)
      Log.d(TAG, "create " + mSensorManager);
  }

  @Override
  protected void onResume() {
    super.onResume();
    mSensorManager.registerListener(mListener, mSensor,
        SensorManager.SENSOR_DELAY_FASTEST);
    if (Config.DEBUG)
      Log.d(TAG, "resume " + mSensorManager);
  }

  @Override
  protected void onStop() {
    mSensorManager.unregisterListener(mListener);
    super.onStop();
    if (Config.DEBUG)
      Log.d(TAG, "stop " + mSensorManager);
  }

  private class SampleView extends View {
    private Paint mPaint = new Paint();
    private Path mPath = new Path();
    private boolean mAnimate;

    public SampleView(Context context) {
      super(context);

      // Construct a wedge-shaped path
      mPath.moveTo(0, -50);
      mPath.lineTo(-20, 60);
      mPath.lineTo(0, 50);
      mPath.lineTo(20, 60);
      mPath.close();
    }

    @Override
    protected void onDraw(Canvas canvas) {
      Paint paint = mPaint;

      canvas.drawColor(Color.WHITE);

      paint.setAntiAlias(true);
      paint.setColor(Color.BLACK);
      paint.setStyle(Paint.Style.FILL);

      int w = canvas.getWidth();
      int h = canvas.getHeight();
      int cx = w / 2;
      int cy = h / 2;

      canvas.translate(cx, cy);
      if (mValues != null) {
        canvas.rotate(-mValues[0]);
      }
      canvas.drawPath(mPath, mPaint);
    }

    @Override
    protected void onAttachedToWindow() {
      mAnimate = true;
      if (Config.DEBUG)
        Log.d(TAG, "onAttachedToWindow. mAnimate=" + mAnimate);
      super.onAttachedToWindow();
    }

    @Override
    protected void onDetachedFromWindow() {
      mAnimate = false;
      if (Config.DEBUG)
        Log.d(TAG, "onAttachedToWindow. mAnimate=" + mAnimate);
      super.onDetachedFromWindow();
    }
  }
}

class GraphicsActivity extends Activity {
  // set to true to test Picture
  private static final boolean TEST_PICTURE = false;

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
  }

  @Override
  public void setContentView(View view) {
    if (TEST_PICTURE) {
      ViewGroup vg = new PictureLayout(this);
      vg.addView(view);
      view = vg;
    }

    super.setContentView(view);
  }
}

class PictureLayout extends ViewGroup {
  private final Picture mPicture = new Picture();

  public PictureLayout(Context context) {
    super(context);
  }

  public PictureLayout(Context context, AttributeSet attrs) {
    super(context, attrs);
  }

  @Override
  public void addView(View child) {
    if (getChildCount() > 1) {
      throw new IllegalStateException(
          "PictureLayout can host only one direct child");
    }

    super.addView(child);
  }

  @Override
  public void addView(View child, int index) {
    if (getChildCount() > 1) {
      throw new IllegalStateException(
          "PictureLayout can host only one direct child");
    }

    super.addView(child, index);
  }

  @Override
  public void addView(View child, LayoutParams params) {
    if (getChildCount() > 1) {
      throw new IllegalStateException(
          "PictureLayout can host only one direct child");
    }

    super.addView(child, params);
  }

  @Override
  public void addView(View child, int index, LayoutParams params) {
    if (getChildCount() > 1) {
      throw new IllegalStateException(
          "PictureLayout can host only one direct child");
    }

    super.addView(child, index, params);
  }

  @Override
  protected LayoutParams generateDefaultLayoutParams() {
    return new LayoutParams(LayoutParams.MATCH_PARENT,
        LayoutParams.MATCH_PARENT);
  }

  @Override
  protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    final int count = getChildCount();

    int maxHeight = 0;
    int maxWidth = 0;

    for (int i = 0; i < count; i++) {
      final View child = getChildAt(i);
      if (child.getVisibility() != GONE) {
        measureChild(child, widthMeasureSpec, heightMeasureSpec);
      }
    }

    maxWidth += getPaddingLeft() + getPaddingRight();
    maxHeight += getPaddingTop() + getPaddingBottom();

    Drawable drawable = getBackground();
    if (drawable != null) {
      maxHeight = Math.max(maxHeight, drawable.getMinimumHeight());
      maxWidth = Math.max(maxWidth, drawable.getMinimumWidth());
    }

    setMeasuredDimension(resolveSize(maxWidth, widthMeasureSpec),
        resolveSize(maxHeight, heightMeasureSpec));
  }

  private void drawPict(Canvas canvas, int x, int y, int w, int h, float sx,
      float sy) {
    canvas.save();
    canvas.translate(x, y);
    canvas.clipRect(0, 0, w, h);
    canvas.scale(0.5f, 0.5f);
    canvas.scale(sx, sy, w, h);
    canvas.drawPicture(mPicture);
    canvas.restore();
  }

  @Override
  protected void dispatchDraw(Canvas canvas) {
    super.dispatchDraw(mPicture.beginRecording(getWidth(), getHeight()));
    mPicture.endRecording();

    int x = getWidth() / 2;
    int y = getHeight() / 2;

    if (false) {
      canvas.drawPicture(mPicture);
    } else {
      drawPict(canvas, 0, 0, x, y, 1, 1);
      drawPict(canvas, x, 0, x, y, -1, 1);
      drawPict(canvas, 0, y, x, y, 1, -1);
      drawPict(canvas, x, y, x, y, -1, -1);
    }
  }

  @Override
  public ViewParent invalidateChildInParent(int[] location, Rect dirty) {
    location[0] = getLeft();
    location[1] = getTop();
    dirty.set(0, 0, getWidth(), getHeight());
    return getParent();
  }

  @Override
  protected void onLayout(boolean changed, int l, int t, int r, int b) {
    final int count = super.getChildCount();

    for (int i = 0; i < count; i++) {
      final View child = getChildAt(i);
      if (child.getVisibility() != GONE) {
        final int childLeft = getPaddingLeft();
        final int childTop = getPaddingTop();
        child.layout(childLeft, childTop,
            childLeft + child.getMeasuredWidth(),
            childTop + child.getMeasuredHeight());

      }
    }
  }
}

   
    
    
  








Related examples in the same category

1.Using Sensor
2.Accelero meter Sensor
3.Compass sensor
4.Gravity sensor
5.Sensor.TYPE_GYROSCOPE
6.Light Sensor
7.PROXIMITY Sensor
8.Sensor List
9.Temperature Sensor
10.Sensor Changed event and information
11.Sensor Event Listener
12.Speed sensor
13.Displays the values of the acceleration sensor graphically
14.Compass Activity
15.Accelerometer API
16.Using the accelerometer to integrate the device's acceleration to a position using the Verlet method.