1 /* 2 * Copyright (C) 2009 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package com.android.phone; 18 19 import android.content.Context; 20 import android.hardware.Sensor; 21 import android.hardware.SensorEvent; 22 import android.hardware.SensorEventListener; 23 import android.hardware.SensorManager; 24 import android.os.Handler; 25 import android.os.Message; 26 import android.util.Log; 27 28 /** 29 * This class is used to listen to the accelerometer to monitor the 30 * orientation of the phone. The client of this class is notified when 31 * the orientation changes between horizontal and vertical. 32 */ 33 public final class AccelerometerListener { 34 private static final String TAG = "AccelerometerListener"; 35 private static final boolean DEBUG = true; 36 private static final boolean VDEBUG = false; 37 38 private SensorManager mSensorManager; 39 private Sensor mSensor; 40 41 // mOrientation is the orientation value most recently reported to the client. 42 private int mOrientation; 43 44 // mPendingOrientation is the latest orientation computed based on the sensor value. 45 // This is sent to the client after a rebounce delay, at which point it is copied to 46 // mOrientation. 47 private int mPendingOrientation; 48 49 private OrientationListener mListener; 50 51 // Device orientation 52 public static final int ORIENTATION_UNKNOWN = 0; 53 public static final int ORIENTATION_VERTICAL = 1; 54 public static final int ORIENTATION_HORIZONTAL = 2; 55 56 private static final int ORIENTATION_CHANGED = 1234; 57 58 private static final int VERTICAL_DEBOUNCE = 100; 59 private static final int HORIZONTAL_DEBOUNCE = 500; 60 private static final double VERTICAL_ANGLE = 50.0; 61 62 public interface OrientationListener { orientationChanged(int orientation)63 public void orientationChanged(int orientation); 64 } 65 AccelerometerListener(Context context, OrientationListener listener)66 public AccelerometerListener(Context context, OrientationListener listener) { 67 mListener = listener; 68 mSensorManager = (SensorManager)context.getSystemService(Context.SENSOR_SERVICE); 69 mSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER); 70 } 71 enable(boolean enable)72 public void enable(boolean enable) { 73 if (DEBUG) Log.d(TAG, "enable(" + enable + ")"); 74 synchronized (this) { 75 if (enable) { 76 mOrientation = ORIENTATION_UNKNOWN; 77 mPendingOrientation = ORIENTATION_UNKNOWN; 78 mSensorManager.registerListener(mSensorListener, mSensor, 79 SensorManager.SENSOR_DELAY_NORMAL); 80 } else { 81 mSensorManager.unregisterListener(mSensorListener); 82 mHandler.removeMessages(ORIENTATION_CHANGED); 83 } 84 } 85 } 86 setOrientation(int orientation)87 private void setOrientation(int orientation) { 88 synchronized (this) { 89 if (mPendingOrientation == orientation) { 90 // Pending orientation has not changed, so do nothing. 91 return; 92 } 93 94 // Cancel any pending messages. 95 // We will either start a new timer or cancel alltogether 96 // if the orientation has not changed. 97 mHandler.removeMessages(ORIENTATION_CHANGED); 98 99 if (mOrientation != orientation) { 100 // Set timer to send an event if the orientation has changed since its 101 // previously reported value. 102 mPendingOrientation = orientation; 103 Message m = mHandler.obtainMessage(ORIENTATION_CHANGED); 104 // set delay to our debounce timeout 105 int delay = (orientation == ORIENTATION_VERTICAL ? VERTICAL_DEBOUNCE 106 : HORIZONTAL_DEBOUNCE); 107 mHandler.sendMessageDelayed(m, delay); 108 } else { 109 // no message is pending 110 mPendingOrientation = ORIENTATION_UNKNOWN; 111 } 112 } 113 } 114 onSensorEvent(double x, double y, double z)115 private void onSensorEvent(double x, double y, double z) { 116 if (VDEBUG) Log.d(TAG, "onSensorEvent(" + x + ", " + y + ", " + z + ")"); 117 118 // If some values are exactly zero, then likely the sensor is not powered up yet. 119 // ignore these events to avoid false horizontal positives. 120 if (x == 0.0 || y == 0.0 || z == 0.0) return; 121 122 // magnitude of the acceleration vector projected onto XY plane 123 double xy = Math.sqrt(x*x + y*y); 124 // compute the vertical angle 125 double angle = Math.atan2(xy, z); 126 // convert to degrees 127 angle = angle * 180.0 / Math.PI; 128 int orientation = (angle > VERTICAL_ANGLE ? ORIENTATION_VERTICAL : ORIENTATION_HORIZONTAL); 129 if (VDEBUG) Log.d(TAG, "angle: " + angle + " orientation: " + orientation); 130 setOrientation(orientation); 131 } 132 133 SensorEventListener mSensorListener = new SensorEventListener() { 134 public void onSensorChanged(SensorEvent event) { 135 onSensorEvent(event.values[0], event.values[1], event.values[2]); 136 } 137 138 public void onAccuracyChanged(Sensor sensor, int accuracy) { 139 // ignore 140 } 141 }; 142 143 Handler mHandler = new Handler() { 144 public void handleMessage(Message msg) { 145 switch (msg.what) { 146 case ORIENTATION_CHANGED: 147 synchronized (this) { 148 mOrientation = mPendingOrientation; 149 if (DEBUG) { 150 Log.d(TAG, "orientation: " + 151 (mOrientation == ORIENTATION_HORIZONTAL ? "horizontal" 152 : (mOrientation == ORIENTATION_VERTICAL ? "vertical" 153 : "unknown"))); 154 } 155 mListener.orientationChanged(mOrientation); 156 } 157 break; 158 } 159 } 160 }; 161 } 162