setting中打开自动旋转功能和接收sensor数据分析

在设置中，有个自动旋转屏幕的开关功能。

随系统选装的话，我们先要在手机设置中选择显示项，设备旋转时自动旋转。最终会调用RotationPolicy.setRotationLockForAccessibility函数，我们先来看下这个函数:

/**

* Enables or disables rotation lock from the system UI toggle.

*/

public static voidsetRotationLock(Context context, final boolean enabled) {

Settings.System.putIntForUser(context.getContentResolver(),

Settings.System.HIDE_ROTATION_LOCK_TOGGLE_FOR_ACCESSIBILITY, 0,

UserHandle.USER_CURRENT);

final int rotation = areAllRotationsAllowed(context) ? CURRENT_ROTATION : NATURAL_ROTATION;

setRotationLock(enabled, rotation);

}

private static voidsetRotationLock(final boolean enabled, final int rotation) {

AsyncTask.execute(new Runnable() {

@Override

public void run() {

try {

IWindowManager wm = WindowManagerGlobal.getWindowManagerService();

if (enabled) {

wm.freezeRotation(rotation);//关闭自动旋转

} else {

wm.thawRotation();//打开自动旋转

}

} catch (RemoteException exc) {

Log.w(TAG, "Unable to save auto-rotate setting");

}

}

});

}

接下来需要到WM中看下thawRotation的实现了：

/**

* Thaw rotation changes. (Disable "rotation lock".)

* Persists across reboots.

*/

@Override

public void thawRotation() {

if (!checkCallingPermission(android.Manifest.permission.SET_ORIENTATION,

"thawRotation()")) {

throw new SecurityException("Requires SET_ORIENTATION permission");

}

if (DEBUG_ORIENTATION) Slog.v(TAG, "thawRotation: mRotation=" + mRotation);

long origId = Binder.clearCallingIdentity();

try {

mPolicy.setUserRotationMode(WindowManagerPolicy.USER_ROTATION_FREE,

777); // rot not used

} finally {

Binder.restoreCallingIdentity(origId);

}

updateRotationUnchecked(false, false);

}

继续跟进setUserRotationMode函数，它的实现在phonwindowmanger中实现的：

public void setUserRotationMode(int mode, int rot) {

ContentResolver res = mContext.getContentResolver();

// mUserRotationMode and mUserRotation will be assigned by the content observer

if (mode == WindowManagerPolicy.USER_ROTATION_LOCKED) {

Settings.System.putIntForUser(res,

Settings.System.USER_ROTATION,

rot,

UserHandle.USER_CURRENT);

Settings.System.putIntForUser(res,

Settings.System.ACCELEROMETER_ROTATION,

0,

UserHandle.USER_CURRENT);

} else {

Settings.System.putIntForUser(res,

Settings.System.ACCELEROMETER_ROTATION,

1,

UserHandle.USER_CURRENT);

}

}

这里只是改变了setting中开关的值。当setting中监听到这个值有变化的时候：

class SettingsObserver extends ContentObserver {

SettingsObserver(Handler handler) {

super(handler);

}

void observe() {

// Observe all users' changes

ContentResolver resolver = mContext.getContentResolver();

resolver.registerContentObserver(Settings.System.getUriFor(

Settings.System.END_BUTTON_BEHAVIOR), false, this,

UserHandle.USER_ALL);

resolver.registerContentObserver(Settings.Secure.getUriFor(

Settings.Secure.INCALL_POWER_BUTTON_BEHAVIOR), false, this,

UserHandle.USER_ALL);

resolver.registerContentObserver(Settings.Secure.getUriFor(

Settings.Secure.WAKE_GESTURE_ENABLED), false, this,

UserHandle.USER_ALL);

resolver.registerContentObserver(Settings.System.getUriFor(

Settings.System.ACCELEROMETER_ROTATION), false, this,

UserHandle.USER_ALL);

resolver.registerContentObserver(Settings.System.getUriFor(

Settings.System.USER_ROTATION), false, this,

UserHandle.USER_ALL);

resolver.registerContentObserver(Settings.System.getUriFor(

Settings.System.SCREEN_OFF_TIMEOUT), false, this,

UserHandle.USER_ALL);

resolver.registerContentObserver(Settings.System.getUriFor(

Settings.System.POINTER_LOCATION), false, this,

UserHandle.USER_ALL);

resolver.registerContentObserver(Settings.Secure.getUriFor(

Settings.Secure.DEFAULT_INPUT_METHOD), false, this,

UserHandle.USER_ALL);

resolver.registerContentObserver(Settings.Secure.getUriFor(

Settings.Secure.IMMERSIVE_MODE_CONFIRMATIONS), false, this,

UserHandle.USER_ALL);

resolver.registerContentObserver(Settings.Global.getUriFor(

Settings.Global.POLICY_CONTROL), false, this,

UserHandle.USER_ALL);

updateSettings();

}

@Override public voidonChange(boolean selfChange) {

updateSettings();

updateRotation(false);

}

}

在updateSettings中：

// Configure rotation lock.

int userRotation = Settings.System.getIntForUser(resolver,

Settings.System.USER_ROTATION, Surface.ROTATION_0,

UserHandle.USER_CURRENT);

if (mUserRotation != userRotation) {

mUserRotation = userRotation;

updateRotation = true;

}

int userRotationMode = Settings.System.getIntForUser(resolver,

Settings.System.ACCELEROMETER_ROTATION, 0, UserHandle.USER_CURRENT) != 0 ?

WindowManagerPolicy.USER_ROTATION_FREE :

WindowManagerPolicy.USER_ROTATION_LOCKED;

if (mUserRotationMode != userRotationMode) {

mUserRotationMode = userRotationMode;

updateRotation = true;

updateOrientationListenerLp();

}

在看看updateOrientationListenerLp它的实现：

void updateOrientationListenerLp() {

if (!mOrientationListener.canDetectOrientation()) {

// If sensor is turned off or nonexistent for some reason

return;

}

//Could have been invoked due to screen turning on or off or

//change of the currently visible window's orientation

if (localLOGV) Slog.v(TAG, "mScreenOnEarly=" + mScreenOnEarly

+ ", mAwake=" + mAwake + ", mCurrentAppOrientation=" + mCurrentAppOrientation

+ ", mOrientationSensorEnabled=" + mOrientationSensorEnabled);

boolean disable = true;

if (mScreenOnFully && mAwake) {

if (needSensorRunningLp()) {

disable = false;

//enable listener if not already enabled

if (!mOrientationSensorEnabled) {

mOrientationListener.enable();//打开sensor

if(localLOGV) Slog.v(TAG, "Enabling listeners");

mOrientationSensorEnabled = true;

}

}

}

//check if sensors need to be disabled

if (disable && mOrientationSensorEnabled) {

mOrientationListener.disable();//关闭sensor

if(localLOGV) Slog.v(TAG, "Disabling listeners");

mOrientationSensorEnabled = false;

}

}

首先看下这个mOrientationListener是个啥东西呢？

在PhoneWindowManager中的init中：

mOrientationListener= new MyOrientationListener(mContext, mHandler);

继续看MyOrientationListener：

class MyOrientationListener extends WindowOrientationListener {

MyOrientationListener(Context context, Handler handler) {

super(context, handler);

}

所以需要到WindowOrientationListener中看它的enable和disable的实现：

public void enable() {

synchronized (mLock) {

if (mSensor == null) {

Log.w(TAG, "Cannot detect sensors. Not enabled");

return;

}

if (mEnabled == false) {

if (LOG) {

Log.d(TAG, "WindowOrientationListener enabled");

}

mSensorEventListener.resetLocked();

mSensorManager.registerListener(mSensorEventListener, mSensor, mRate, mHandler);

mEnabled = true;

}

}

}

/**

* Disables the WindowOrientationListener.

*/

public void disable() {

synchronized (mLock) {

if (mSensor == null) {

Log.w(TAG, "Cannot detect sensors. Invalid disable");

return;

}

if (mEnabled == true) {

if (LOG) {

Log.d(TAG, "WindowOrientationListener disabled");

}

mSensorManager.unregisterListener(mSensorEventListener);

mEnabled = false;

}

}

}

这里先看下enable的流程：

mSensorManager就是SensorManager，现在到SensorManager中看下registerListener：、

public boolean registerListener(SensorEventListener listener, Sensor sensor,

int samplingPeriodUs, Handler handler) {

int delay = getDelay(samplingPeriodUs);

return registerListenerImpl(listener, sensor, delay, handler, 0, 0);

}

需要继续跟进registerListenerImpl：

protected abstract boolean registerListenerImpl(SensorEventListener listener, Sensor sensor,

int delayUs, Handler handler, int maxReportLatencyUs, int reservedFlags);

空的，需要到它的子类中找答案了：

在SystemSensorManager中：

/** @hide */

@Override

protected boolean registerListenerImpl(SensorEventListener listener, Sensor sensor,

int delayUs, Handler handler, int maxBatchReportLatencyUs, int reservedFlags) {

if (listener == null || sensor == null) {

Log.e(TAG, "sensor or listener is null");

return false;

}

// Trigger Sensors should use the requestTriggerSensor call.

if (sensor.getReportingMode() == Sensor.REPORTING_MODE_ONE_SHOT) {

Log.e(TAG, "Trigger Sensors should use the requestTriggerSensor.");

return false;

}

if (maxBatchReportLatencyUs < 0 || delayUs < 0) {

Log.e(TAG, "maxBatchReportLatencyUs and delayUs should be non-negative");

return false;

}

// Invariants to preserve:

// - one Looper per SensorEventListener

// - one Looper per SensorEventQueue

// We map SensorEventListener to a SensorEventQueue, which holds the looper

synchronized (mSensorListeners) {

SensorEventQueue queue = mSensorListeners.get(listener);

if (queue == null) {

Looper looper = (handler != null) ? handler.getLooper() : mMainLooper;

queue = new SensorEventQueue(listener, looper, this);//第一次必须是null

if (!queue.addSensor(sensor, delayUs, maxBatchReportLatencyUs, reservedFlags)) {

queue.dispose();

return false;

}

mSensorListeners.put(listener, queue);

return true;

} else {

return queue.addSensor(sensor, delayUs, maxBatchReportLatencyUs, reservedFlags);

}

}

}

所以接下来需要分析下SensorEventQueue：作用就是创建一个底层到上层的数据传输通道：

public SensorEventQueue(SensorEventListener listener, Looper looper,

SystemSensorManager manager) {

super(looper, manager);

mListener = listener;

}

它的父类是：

BaseEventQueue(Looper looper, SystemSensorManager manager) {

nSensorEventQueue =nativeInitBaseEventQueue(this, looper.getQueue(), mScratch);

mCloseGuard.open("dispose");

mManager = manager;

}

所以需要到jni中分析了nativeInitBaseEventQueue：

static jlongnativeInitSensorEventQueue(JNIEnv *env, jclass clazz, jobject eventQ, jobject msgQ, jfloatArray scratch) {

//1:创建SensorEventQueue，首先拿到SensorManager

SensorManager& mgr(SensorManager::getInstance());

sp<SensorEventQueue>queue(mgr.createEventQueue());

//创建一个messageQueue

sp<MessageQueue>messageQueue =android_os_MessageQueue_getMessageQueue(env, msgQ);

if (messageQueue == NULL) {

jniThrowRuntimeException(env, "MessageQueue is not initialized.");

return 0;

}

//2：创建数据接收者

sp<Receiver>receiver = new Receiver(queue, messageQueue, eventQ, scratch);

//3：调用onfirstRef

receiver->incStrong((void*)nativeInitSensorEventQueue);

return jlong(receiver.get());

}

先看下第一步：只看createEventQueue的过程：

sp<SensorEventQueue> SensorManager::createEventQueue()

{

sp<SensorEventQueue> queue;

Mutex::Autolock _l(mLock);

while (assertStateLocked() == NO_ERROR) {

sp<ISensorEventConnection> connection =

mSensorServer->createSensorEventConnection();

if (connection == NULL) {

// SensorService just died.

ALOGE("createEventQueue: connection is NULL. SensorService died.");

continue;

}

queue = new SensorEventQueue(connection);

break;

}

return queue;

}

先看下createSensorEventConnection，这里是binder调用，直接到SensorService中看下实现：

sp<ISensorEventConnection> SensorService::createSensorEventConnection()

{

uid_t uid = IPCThreadState::self()->getCallingUid();

sp<SensorEventConnection> result(newSensorEventConnection(this, uid));

return result;

}

SensorService::SensorEventConnection::SensorEventConnection(

const sp<SensorService>& service, uid_t uid)

: mService(service), mUid(uid), mWakeLockRefCount(0), mHasLooperCallbacks(false),

mDead(false), mEventCache(NULL), mCacheSize(0), mMaxCacheSize(0) {

//最重要是创建了一个BitTube用于通信

mChannel = newBitTube(mService->mSocketBufferSize);

#if DEBUG_CONNECTIONS

mEventsReceived = mEventsSentFromCache = mEventsSent = 0;

mTotalAcksNeeded = mTotalAcksReceived = 0;

#endif

}

回到createEventQueue中，最下面是创建了一个SensorEventQueue：

SensorEventQueue::SensorEventQueue(const sp<ISensorEventConnection>& connection)

: mSensorEventConnection(connection), mRecBuffer(NULL), mAvailable(0), mConsumed(0),

mNumAcksToSend(0) {

mRecBuffer = new ASensorEvent[MAX_RECEIVE_BUFFER_EVENT_COUNT];

}

再看下第二步：

Receiver(const sp<SensorEventQueue>& sensorQueue,

const sp<MessageQueue>& messageQueue,

jobject receiverObject, jfloatArray scratch) {

JNIEnv* env = AndroidRuntime::getJNIEnv();

mSensorQueue = sensorQueue;

mMessageQueue = messageQueue;

mReceiverObject = env->NewGlobalRef(receiverObject);

mScratch = (jfloatArray)env->NewGlobalRef(scratch);

}

在看下它的一个onFirstRef：添加到looper中去的监听

virtual voidonFirstRef() {

LooperCallback::onFirstRef();

mMessageQueue->getLooper()->addFd(mSensorQueue->getFd(), 0,

ALOOPER_EVENT_INPUT, this, mSensorQueue.get());

}

既然有looper的addFd，必然有handleEvent：下面来看下它的实现：

virtual int handleEvent(int fd, int events, void* data) {

JNIEnv* env = AndroidRuntime::getJNIEnv();

sp<SensorEventQueue> q = reinterpret_cast<SensorEventQueue *>(data);

ssize_t n;

ASensorEvent buffer[16];

while ((n = q->read(buffer, 16)) > 0) {

for (int i=0 ; i<n ; i++) {

if (buffer[i].type ==SENSOR_TYPE_STEP_COUNTER) {

// step-counter returns a uint64, but the java API only deals with floats

float value = float(buffer[i].u64.step_counter);

env->SetFloatArrayRegion(mScratch, 0, 1, &value);

} else {

env->SetFloatArrayRegion(mScratch, 0, 16, buffer[i].data);

}

if (buffer[i].type ==SENSOR_TYPE_META_DATA) {

// This is a flush complete sensor event. Call dispatchFlushCompleteEvent

// method.

env->CallVoidMethod(mReceiverObject,

gBaseEventQueueClassInfo.dispatchFlushCompleteEvent,

buffer[i].meta_data.sensor);

} else {

int8_t status;

switch (buffer[i].type) {

case SENSOR_TYPE_ORIENTATION:

case SENSOR_TYPE_MAGNETIC_FIELD:

case SENSOR_TYPE_ACCELEROMETER:

case SENSOR_TYPE_GYROSCOPE:

status = buffer[i].vector.status;

break;

case SENSOR_TYPE_HEART_RATE:

status = buffer[i].heart_rate.status;

break;

default:

status = SENSOR_STATUS_ACCURACY_HIGH;

break;

}

//回调Java层BaseEventQueue的dispatchSensorEvent方法

env->CallVoidMethod(mReceiverObject,

gBaseEventQueueClassInfo.dispatchSensorEvent,

buffer[i].sensor,

mScratch,

status,

buffer[i].timestamp);

}

if (env->ExceptionCheck()) {

mSensorQueue->sendAck(buffer, n);

ALOGE("Exception dispatching input event.");

return 1;

}

}

mSensorQueue->sendAck(buffer, n);

}

if (n<0 && n != -EAGAIN) {

// FIXME: error receiving events, what to do in this case?

}

return 1;

}

接下来，需要到java层看下数据是怎么分发的：

protected voiddispatchSensorEvent(int handle, float[] values, int inAccuracy,

long timestamp) {

final Sensor sensor = sHandleToSensor.get(handle);

SensorEvent t = null;

synchronized (mSensorsEvents) {

t = mSensorsEvents.get(handle);

}

if (t == null) {

// This may happen if the client has unregistered and there are pending events in

// the queue waiting to be delivered. Ignore.

return;

}

// Copy from the values array.

System.arraycopy(values, 0, t.values, 0, t.values.length);

t.timestamp = timestamp;

t.accuracy = inAccuracy;

t.sensor = sensor;

// call onAccuracyChanged() only if the value changes

final int accuracy = mSensorAccuracies.get(handle);

if ((t.accuracy >= 0) && (accuracy != t.accuracy)) {

mSensorAccuracies.put(handle, t.accuracy);

mListener.onAccuracyChanged(t.sensor, t.accuracy);

}

mListener.onSensorChanged(t);//所以最终会调用onSensorChanged的方法；

}