Phone 通话过程中 PSensor 工作流程--不全

概要

       在Android手机通话过程中，用户将手机靠近/远离头部，会导致手机屏幕灭/亮，这实际上是Proximity Sensor在起作用(参考1)。通俗的来讲Proximity Sensor就是近距离传感器，后文简写为PSensor，近距离传感器可用于测量物体靠近或远离。根据PSensor的这一特征，在计数以及自动化控制等领域都有使用近距离传感器(参考2，参考3)。目前，市面上主流的智能手机均包含了近距离传感器。PSensor检测到手机被遮挡则关闭屏幕，反之则点亮屏幕，一方面可以省电(LCD是耗电大户)，另一方面可以防止用户近耳接听时触碰到屏幕引发误操作。

       本文主要分析PSensor在整个通话过程中实现屏幕亮灭的控制原理。

本文来自https://blog.csdn.net/daiqiquan/article/details/51907204

ProximitySensor初始化流程

       在Android 4.4以后，Phone分为了TeleService和InCallUI两个部分，通话过程中PSensor的控制由packages/apps/InCallUI/src/com/android/incallui/ProximitySensor.Java负责。在以前发布的文章《Android 4.4 Kitkat Phone工作流程浅析(七)__来电(MT)响铃流程》和《Android 4.4 Kitkat Phone工作流程浅析(九)__状态通知流程分析》中已经分析通话状态变更流程 ( Modem->RILC->RILJ->Framework->Telephony->InCallUI ) ，而TeleService与InCallUI建立连接是在通话状态变更之后。因此ProximitySensor的初始化建立在通话状态第一次变更后，整个流程如图1所示：

图 1 ProximitySensor初始化流程

       InCallUI与TeleService通过两种方式进行通信，即Broadcast和AIDL。当MO流程发起时，InCallUI最终会通过广播的方式将MO请求传递给TeleService。而当通话状态返回以及通话控制命令发起时，InCallUI和TeleService之间将会通过AIDL的方式进行通信，即CallHandlerService和CallHandlerServiceProxy，以及CallCommandService和CallCommandClient。使用AIDL方式通信需要建立连接(bindService)，而在建立连接的时候对ProximitySensor进行了初始化操作。

ProximitySensor初始化小结

1. ProximitySensor初始化是在InCallPresenter中完成；

在InCallPresenter中实例化了ProximitySensor对象并将其添加到Set<InCallStateListener>序列中，当通话状态变更时回调ProximitySensor的onStateChanged()方法。

2. ProximitySensor的初始化依赖于InCallUI中CallHandlerService的绑定；

当TeleService通过bindService连接CallHandlerServiceProxy和CallHandlerService时，经过逐步调用后完成ProximitySensor的初始化。而bindService的调用则依赖于Call State的改变，Call State的改变有两种情况：incoming 和 update，即当有来电或者通话状态改变时，会触发TeleService的bindService操作。

ProximitySensor使用流程

       通话状态变更之后ProximitySensor完成初始化。ProximitySensor.java的关键方法如下：

[java]  view plain  copy

 

1. // 构造方法，完成初始化  
2. // PowerManager.PROXIMITY_SCREEN_OFF_WAKE_LOCK是@hide的，普通app无法获取  
3. public ProximitySensor(Context context, AudioModeProvider audioModeProvider) {  
4.     mPowerManager = (PowerManager) context.getSystemService(Context.POWER_SERVICE);  
5.     if (mPowerManager.isWakeLockLevelSupported(PowerManager.PROXIMITY_SCREEN_OFF_WAKE_LOCK)) {  
6.         mProximityWakeLock = mPowerManager.newWakeLock(  
7.                 PowerManager.PROXIMITY_SCREEN_OFF_WAKE_LOCK, TAG);  
8.     } else {  
9.         mProximityWakeLock = null;  
10.     }  
11.     mAccelerometerListener = new AccelerometerListener(context, this);  
12.     mAudioModeProvider = audioModeProvider;  
13.     mAudioModeProvider.addListener(this);  
14. }  
15.   
16. // 完成善后工作，初始化以及挂断电话后会被调用  
17. public void tearDown() {  
18.     mAudioModeProvider.removeListener(this);  
19.     mAccelerometerListener.enable(false);  
20.     if (mProximityWakeLock != null && mProximityWakeLock.isHeld()) {  
21.         mProximityWakeLock.release();  
22.     }  
23. }  
24.   
25. // 当设备的方向改变之后会执行，用于判断是否启用PSensor(注：在灭屏状态下不会触发)  
26. // mOrientation的值包含：  
27. // ORIENTATION_UNKNOWN = 0  
28. // ORIENTATION_VERTICAL = 1   垂直摆放  
29. // ORIENTATION_HORIZONTAL = 2 水平摆放  
30. @Override  
31. public void orientationChanged(int orientation) {  
32.     mOrientation = orientation;  
33.     updateProximitySensorMode();  
34. }  
35.   
36. // 当通话状态有改变则会通过InCallPresenter回调  
37. @Override  
38. public void onStateChange(InCallState state, CallList callList) {  
39.     // 如果是来电则无须启用PSensor  
40.     boolean isOffhook = (InCallState.INCALL == state  
41.             || InCallState.OUTGOING == state);  
42.     if (isOffhook != mIsPhoneOffhook) {  
43.         mIsPhoneOffhook = isOffhook;  
44.         mOrientation = AccelerometerListener.ORIENTATION_UNKNOWN;  
45.         mAccelerometerListener.enable(mIsPhoneOffhook);  
46.         updateProximitySensorMode();  
47.     }  
48. }  
49.   
50. //... ...省略  
51.   
52. // 当通话过程中Audio模式有变化则执行，包括：  
53. // 1. 蓝牙耳机连接  
54. // 2. 有线耳机连接  
55. // 3. 开启扬声器  
56. @Override  
57. public void onAudioMode(int mode) {  
58.     updateProximitySensorMode();  
59. }  
60.   
61. // 拨号盘显示时回调，此时禁用PSensor以便用户输入  
62. public void onDialpadVisible(boolean visible) {  
63.     mDialpadVisible = visible;  
64.     updateProximitySensorMode();  
65. }  
66.   
67. // Config改变时回调，如开启物理键盘(如今许多设备都已不再配备物理键盘)  
68. public void onConfigurationChanged(Configuration newConfig) {  
69.     mIsHardKeyboardOpen = newConfig.hardKeyboardHidden == Configuration.HARDKEYBOARDHIDDEN_NO;  
70.     // Update the Proximity sensor based on keyboard state  
71.     updateProximitySensorMode();  
72. }  
73.   
74. // InCallUI显示或隐藏时回调  
75. public void onInCallShowing(boolean showing) {  
76.     if (showing) {  
77.         mUiShowing = true;  
78.     } else if (mPowerManager.isScreenOn()) {  
79.         mUiShowing = false;  
80.     }  
81.     updateProximitySensorMode();  
82. }  

通过查看不难发现，以上方法(除了构造方法以外)均调用了updateProximitySensorMode方法，整个通话过程中正是由其触发PSensor的控制，关键代码如下：

[java]  view plain  copy

 

1. /** 
2.  * 根据当前设备状态，使用wake lock锁来控制PSensor的行为 
3.  * On devices that have a proximity sensor, to avoid false touches 
4.  * during a call, we hold a PROXIMITY_SCREEN_OFF_WAKE_LOCK wake lock 
5.  * whenever the phone is off hook.  (When held, that wake lock causes 
6.  * the screen to turn off automatically when the sensor detects an 
7.  * object close to the screen.) 
8.  * 以上为google解释通话过程中PSensor的工作原理，即 
9.  * 在通话过程中持有PROXIMITY_SCREEN_OFF_WAKE_LOCK的wake lock，如果检测物体靠近 
10.  * 则关闭屏幕以防止用户误点击 
11.  * 
12.  * 以下情况将会禁用PSensor的亮灭屏控制，即PSensor无效： 
13.  * 1) 设备已连接蓝牙耳机 
14.  * 2) 设备已插入有线耳机 
15.  * 3) 设备开启扬声器 
16.  * 4) 设备开启物理键盘(如今许多设备都已不再配备物理键盘) 
17.  */  
18. private void updateProximitySensorMode() {  
19.     if (proximitySensorModeEnabled()) {  
20.         synchronized (mProximityWakeLock) {  
21.             final int audioMode = mAudioModeProvider.getAudioMode();  
22.             // 以下情况将会禁用PSensor，是否禁用需根据update时具体状态决定:  
23.             // 1. 插入有线耳机  
24.             // 2. 接入蓝牙耳机  
25.             // 3. 开启扬声器  
26.             // 4. 开启物理键盘(如今许多设备都已不再配备物理键盘)  
27.             // 5. 设备水平放置  
28.             // screenOnImmediately = true表示禁用PSensor  
29.             // screenOnImmediately = false表示启用PSensor，此时屏幕的亮灭则根据是否  
30.             // 有物体靠近或远离PSensor决定，靠近则灭屏，远离则亮屏  
31.             boolean screenOnImmediately = (AudioMode.WIRED_HEADSET == audioMode  
32.                     || AudioMode.SPEAKER == audioMode  
33.                     || AudioMode.BLUETOOTH == audioMode  
34.                     || mIsHardKeyboardOpen);  
35.             //... ...省略  
36.             // 当设备水平放置，且InCallActivity不在前台显示时，此时!mUiShowing && horizontal = true  
37.             // 从而screenOnImmediately = true，并最终禁用PSensor  
38.             final boolean horizontal =  
39.                     (mOrientation == AccelerometerListener.ORIENTATION_HORIZONTAL);  
40.             screenOnImmediately |= !mUiShowing && horizontal;  
41.   
42.             // 当设备水平放置且开启拨号盘时，screenOnImmediately = true，禁用PSensor  
43.             screenOnImmediately |= mDialpadVisible && horizontal;  
44.             if (mIsPhoneOffhook && !screenOnImmediately) {  
45.                 final String logStr = "turning on proximity sensor: ";  
46.                 if (!mProximityWakeLock.isHeld()) {  
47.                     Log.i(this, logStr + "acquiring");  
48.                     // 如果没有执行过acquire方法则执行wakelock申请的动作  
49.                     // 该方法用于Enable PSensor的亮灭屏控制  
50.                     mProximityWakeLock.acquire();  
51.                 } else {  
52.                     // 无须再次acquire  
53.                     Log.i(this, logStr + "already acquired");  
54.                 }  
55.             } else {  
56.                 final String logStr = "turning off proximity sensor: ";  
57.                 if (mProximityWakeLock.isHeld()) {  
58.                     Log.i(this, logStr + "releasing");  
59.                     // Wait until user has moved the phone away from his head if we are  
60.                     // releasing due to the phone call ending.  
61.                     // Qtherwise, turn screen on immediately  
62.                     // 禁用PSensor的亮灭屏控制包含两种情况：  
63.                     // 第一种：  
64.                     // 如果当前设备不再是OFFHOOK状态，比如已经挂断电话即 mIsPhoneOffhook = false  
65.                     // 此时screenOnImmediately有可能为false，即设备还处于灭屏的状态，这种情况下会根据  
66.                     // PowerManager.WAIT_FOR_PROXIMITY_NEGATIVE 这个FLAG来release wake lock  
67.                     // 也就是说会立即释放锁，但需要等用户远离PSensor时才会禁用PSensor并点亮屏幕  
68.                     // 第二种：  
69.                     // 当update时发现需要禁用PSensor，比如在PSensor被遮挡设备灭屏的情况下插入有线耳机  
70.                     // 此时会导致Audio模式的改变从而调用updateProximitySensorMode，同时，在这种情况下  
71.                     // screenOnImmediately = true，则会立即禁用PSensor并release wake lock点亮屏幕  
72.                     int flags =  
73.                         (screenOnImmediately ? 0 : PowerManager.WAIT_FOR_PROXIMITY_NEGATIVE);  
74.                     mProximityWakeLock.release(flags);  
75.                 } else {  
76.                     Log.i(this, logStr + "already released");  
77.                 }  
78.             }  
79.         }  
80.     }  
81. }  

通过以上代码的分析可以知道，屏幕的亮灭有多种情况。在InCallUI中通过mProximityWakeLock.acquire()和mProximityWakeLock.release()申请/释放wake lock来 Enable/Unenable PSensor，从而让PSensor来控制屏幕的亮灭。从这一点也可以看出，通话过程中屏幕的亮灭的控制，实际上与Telephony没有多大关系。

ProximitySensor使用流程小结

1. 在InCallUI中通过ProximitySensor提供的public接口，调用updateProximitySensorMode()更新PSensor的Enable/Unenable状态。

public接口包括：

orientationChanged()：设备方向改变后回调；

onStateChange()：设备InCallState改变后回调；

onAudioMode()：设备Audio模式改变后回调，Audio模式包括连接蓝牙耳机，插入有线耳机，开启扬声器；

onDialpadVisible()：设备通话时时Dialpad显示状态改变后回调；

onConfigurationChanged()：设备Configuration改变后回调，如弹出物理键盘；

onInCallShowing()：设备InCallActivity显示状态改变后回调；

2. PSensor的控制在ProximitySensor中通过如下方式完成：

①. 实例化PowerManager.WakeLock

[java]  view plain  copy

 

1. mPowerManager = (PowerManager) context.getSystemService(Context.POWER_SERVICE);  
2. if (mPowerManager.isWakeLockLevelSupported(PowerManager.PROXIMITY_SCREEN_OFF_WAKE_LOCK)) {  
3.     mProximityWakeLock = mPowerManager.newWakeLock(  
4.             PowerManager.PROXIMITY_SCREEN_OFF_WAKE_LOCK, TAG);  
5. } else {  
6.     mProximityWakeLock = null;  
7. }  

②. 通过WakeLock的acquire和release方法Enable/Unenable PSensor

[java]  view plain  copy

 

1. mProximityWakeLock.acquire(); // 申请，即Enable PSensor  
2. if (mProximityWakeLock.isHeld()) {  
3.     int flags =(screenOnImmediately ? 0 : PowerManager.WAIT_FOR_PROXIMITY_NEGATIVE);  
4.     mProximityWakeLock.release(flags); // 释放，即Unenable PSensor  
5. }  

PSensor工作流程

       在分析了InCallUI中ProximitySensor的初始化流程和控制流程之后，还需具体查看在整个通话过程中，PSensor是如何完成工作屏幕亮灭控制的。在前文的分析中，ProximitySensor通过mProximityWakeLock.acquire()和mProximityWakeLock.release()来实现PSensor的Enable/Unenable，从而让PSensor完成屏幕亮灭的控制。整个流程大致分为：WakeLock申请、PSensor关闭/点亮屏幕、系统休眠/唤醒三大部分。

       可能有童鞋要问了：WakeLock是什么？PSensor与WakeLock有什么关系？申请和释放WakeLock的作用什么？后文会为大家一一解释。

WakeLock

       WakeLock也可称之为唤醒锁，是Android提供的一种机制，用于阻止设备进入深度休眠(CPU、Memory掉电参考4 参考5)。当一个应用程序申请了WakeLock后，即使用户按下Power键关闭屏幕，该应用依然可以保持运行，如音乐播放器。

       Android提供了五种类型的WakeLock，即PARTIAL_WAKE_LOCK、SCREEN_DIM_WAKE_LOCK、SCREEN_BRIGHT_WAKE_LOCK、FULL_WAKE_LOCK、PROXIMITY_SCREEN_OFF_WAKE_LOCK。其中SCREEN_DIM_WAKE_LOCK、SCREEN_BRIGHT_WAKE_LOCK、FULL_WAKE_LOCK不再建议使用，取而代之的是android.view.WindowManager.LayoutParams#FLAG_KEEP_SCREEN_ON。PARTIAL_WAKE_LOCK表示设备CPU 持续运转，屏幕和键盘背光允许关闭，普通应用可以获取，而PROXIMITY_SCREEN_OFF_WAKE_LOCK则是PSensor的专用，只有系统APP才有权使用。

       用户在通话过程中自然不希望设备进入深度休眠，因此电话应用(这里指InCallUI)会申请WakeLock，而这一步实际上在ProximitySensor的updateProximitySensorMode方法中完成，关键代码如下：

[java]  view plain  copy

 

1. private final PowerManager mPowerManager;  
2. private final PowerManager.WakeLock mProximityWakeLock;  
3.   
4. mPowerManager = (PowerManager) context.getSystemService(Context.POWER_SERVICE);  
5. if (mPowerManager.isWakeLockLevelSupported(PowerManager.PROXIMITY_SCREEN_OFF_WAKE_LOCK)) {  
6.     mProximityWakeLock = mPowerManager.newWakeLock(PowerManager.PROXIMITY_SCREEN_OFF_WAKE_LOCK, TAG);  
7.     // 申请WakeLock  
8.     mProximityWakeLock.acquire();  
9.     // 释放WakeLock  
10.     int flags = (screenOnImmediately ? 0 : PowerManager.WAIT_FOR_PROXIMITY_NEGATIVE);  
11.     mProximityWakeLock.release(flags);  

这里需要注意：

1. PROXIMITY_SCREEN_OFF_WAKE_LOCK在PowerManager定义为@hide因此普通APP无法直接调用；

2. 申请WakeLock需要在AndroidManifest.xml添加android.permission.WAKE_LOCK权限；

3. flags为0表示立即释放锁，屏幕会立即点亮。flags为PowerManager.WAIT_FOR_PROXIMITY_NEGATIVE则表示立即释放锁，但此时已然Enable PSensor，需要等待物体远离后再亮屏；

       普通应用也可以申请/释放WakeLock，但PowerManager.PROXIMITY_SCREEN_OFF_WAKE_LOCK只有系统应用才有权申请/释放，也就是说该类型的WakeLock是为PSensor量身打造的。在acquire/release WakeLock的过程中，实际上也一并完成了PSensor的Enable/Unenable，具体将在下一节给大家解释。

PSensor关闭/点亮屏幕

       本文提及的PSensor关闭/点亮屏幕指的是，Enable PSensor并满足特定条件(靠近/远离)后，触发屏幕关闭/开启流程(实际上是休眠/唤醒流程，后文解释)，而整个流程分为两步：注册PSensor Listener及PSensor状态触发亮灭屏。

注册PSensor Listener

       InCallUI中完成WakeLock的申请后，便进入到frameworks/base/core/java/anroid/os/PowerManager.java的acquire方法中，并开启了WakeLock的处理流程，关键代码如下：

[java]  view plain  copy

 

1. public void acquire() {  
2.     //... ...省略  
3.     acquireLocked();  
4. }  
5. Private void acquireLocked() {  
6.     // ... ..省略 mService即PowerManagerService对象  
7.     mService.acquireWakeLock(mToken, mFlags, mTag, mPackageName, mWorkSource);  
8. }  

对于上层应用来说PowerManager实际上只是一个接口，真正实现在frameworks/base/services/java/com/android/server/power/PowerManagerService.java中：

[java]  view plain  copy

 

1. @Override  
2. public void acquireWakeLock(IBinder lock, int flags, String tag, String packageName,  
3.         WorkSource ws) {  
4.     //... ...省略  
5.     try {  
6.         acquireWakeLockInternal(lock, flags, tag, packageName, ws, uid, pid);  
7.     } finally {  
8.         Binder.restoreCallingIdentity(ident);  
9.     }  
10. }  
11.   
12. private void acquireWakeLockInternal(IBinder lock, int flags, String tag, String packageName,  
13.         WorkSource ws, int uid, int pid) {  
14.     synchronized (mLock) {  
15.         //... ...省略  
16.         updatePowerStateLocked();  
17.     }  
18. }  

因为在本节中我们主要关心关闭/点亮屏幕的操作，期间省略了很多状态更新以及权限检查的代码。在acquireWakeLockInternal最后调用了updatePowerStateLocked，该方法是PowerManagerService中最为重要的方法，也即Android的休眠/唤醒入口方法。其中具有具有5大关键步骤，核心代码如下：

[java]  view plain  copy

 

1. private void updatePowerStateLocked() {  
2.     //... ...省略  
3.   
4.     // Phase 0: Basic state updates.  
5.     // 基本状态更新  
6.     updateIsPoweredLocked(mDirty);  
7.     updateStayOnLocked(mDirty); // 是否有开启"充电保持唤醒"功能  
8.   
9.     // Phase 1: Update wakefulness.  
10.     // Loop because the wake lock and user activity computations are influenced  
11.     // by changes in wakefulness.  
12.     final long now = SystemClock.uptimeMillis();  
13.     int dirtyPhase2 = 0;  
14.     for (;;) {  
15.         int dirtyPhase1 = mDirty;  
16.         dirtyPhase2 |= dirtyPhase1;  
17.         mDirty = 0;  
18.         //检查当前系统中所有激活的(没有释放)WakeLock  
19.         updateWakeLockSummaryLocked(dirtyPhase1);  
20.         //更新主动申请的系统状态如bright/dim  
21.         updateUserActivitySummaryLocked(now, dirtyPhase1);  
22.         // 如果经过前面的检查和更新后，没有新的状态变更则退出循环准备休眠  
23.         if (!updateWakefulnessLocked(dirtyPhase1)) {  
24.             break;  
25.         }  
26.     }  
27.   
28.     // Phase 2: Update dreams and display power state.  
29.     // 更新dream屏保状态  
30.     updateDreamLocked(dirtyPhase2);  
31.     // 更新显示状态，包含关闭/点亮屏幕  
32.     updateDisplayPowerStateLocked(dirtyPhase2);  
33.   
34.     // Phase 3: Send notifications, if needed.  
35.     // 休眠/唤醒是否准备完成  
36.     if (mDisplayReady) {  
37.         sendPendingNotificationsLocked();  
38.     }  
39.   
40.     // Phase 4: Update suspend blocker.  
41.     // Because we might release the last suspend blocker here, we need to make sure  
42.     // we finished everything else first!  
43.     // 休眠/唤醒前最后一步，之后会跳转到native层执行申请/释放锁的操作  
44.     updateSuspendBlockerLocked();  
45. }  

经过前文的分析，申请WakeLock之后会调用到updatePowerStateLocked()中，而在该方法中通过调用updateDisplayPowerStateLocked()更新显示状态，关键方法如下：

[java]  view plain  copy

 

1. private void updateDisplayPowerStateLocked(int dirty) {  
2.     //... ...省略  
3.     mDisplayReady = mDisplayPowerController.requestPowerState(mDisplayPowerRequest,  
4.                 mRequestWaitForNegativeProximity);  
5.     //... ...省略  
6. }  

mDisplayPowerController是frameworks/base/services/java/com/android/server/power/DisplayPowerController.java的对象，在PowerManagerService的SystemReady()方法中完成初始化。继续查看DisplayPowerController的requestPowerState方法：

[java]  view plain  copy

 

1. public boolean requestPowerState(DisplayPowerRequest request,  
2.         boolean waitForNegativeProximity) {  
3.     //... ...省略  
4.     if (changed && !mPendingRequestChangedLocked) {  
5.         mPendingRequestChangedLocked = true;  
6.         sendUpdatePowerStateLocked();  
7.     }  
8.     //... ...省略  
9. }  

这里会执行sendUpatePowerStateLocked方法，该方法中会使用sendMessage()发送一个MSG_UPDATE_POWER_STATE消息，而该消息的接收者正是DisplayPowerController的内部类DisplayControllerHandler，并执行updatePowerState()方法。当第一次执行updatePowerState()方法时，仅register PSensor的Listener而不会继续往后执行，关键代码如下：

[java]  view plain  copy

 

1. private void updatePowerState() {  
2.     //... ...省略  
3.     setProximitySensorEnabled(true);  
4.     //... ....省略  
5. }  
6.   
7. private void setProximitySensorEnabled(boolean enable) {  
8.     if (enable) {  
9.         if (!mProximitySensorEnabled) {  
10.             // Register the listener.  
11.             mProximitySensorEnabled = true;  
12.             mSensorManager.registerListener(mProximitySensorListener, mProximitySensor,  
13.                     SensorManager.SENSOR_DELAY_NORMAL, mHandler);  
14.         }  
15.     } else {  
16.         if (mProximitySensorEnabled) {  
17.             // Unregister the listener.  
18.             //... ...省略  
19.             mSensorManager.unregisterListener(mProximitySensorListener);  
20.             //... ...省略  
21.         }  
22.     }  
23. }  

整个注册PSensor Listener流程如图2所示：

图 2 PSensor Enable流程

PSensor状态触发亮灭屏

       当PSensor的状态发生改变之后便会回调其Listener的onSensorChanged()方法，并判断当前遮挡物是靠近还是远离PSensor：

[java]  view plain  copy

 

1. private final SensorEventListener mProximitySensorListener = new SensorEventListener() {  
2.     @Override  
3.     public void onSensorChanged(SensorEvent event) {  
4.         if (mProximitySensorEnabled) {  
5.             final long time = SystemClock.uptimeMillis();  
6.             //从Event中获取distance值，这个值与driver上报有关，不同设备有可能不同  
7.             //从当前测试设备上返回的数据来看，靠近时distance=0.0，远离时distance=1.0  
8.             final float distance = event.values[0];  
9.             //mProximityThreshold的默认值为5.0f，具体是在driver中设置的  
10.             //靠近：distance = 0.0 -> positive = true  -> POSITIVE  
11.             //远离：distance = 1.0 -> positive = false -> NEGATIVE  
12.             boolean positive = distance >= 0.0f && distance < mProximityThreshold;  
13.             handleProximitySensorEvent(time, positive);  
14.         }  
15.     }  
16.