1 /* 2 * Copyright (C) 2016 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.systemui.doze; 18 19 import android.app.AlarmManager; 20 import android.app.UiModeManager; 21 import android.content.BroadcastReceiver; 22 import android.content.Context; 23 import android.content.Intent; 24 import android.content.IntentFilter; 25 import android.content.res.Configuration; 26 import android.hardware.Sensor; 27 import android.hardware.SensorEvent; 28 import android.hardware.SensorEventListener; 29 import android.hardware.SensorManager; 30 import android.os.Handler; 31 import android.os.SystemClock; 32 import android.os.UserHandle; 33 import android.text.format.Formatter; 34 import android.util.Log; 35 36 import com.android.internal.hardware.AmbientDisplayConfiguration; 37 import com.android.internal.util.Preconditions; 38 import com.android.systemui.statusbar.phone.DozeParameters; 39 import com.android.systemui.util.Assert; 40 import com.android.systemui.util.wakelock.WakeLock; 41 42 import java.io.PrintWriter; 43 import java.util.function.IntConsumer; 44 45 /** 46 * Handles triggers for ambient state changes. 47 */ 48 public class DozeTriggers implements DozeMachine.Part { 49 50 private static final String TAG = "DozeTriggers"; 51 private static final boolean DEBUG = DozeService.DEBUG; 52 53 /** adb shell am broadcast -a com.android.systemui.doze.pulse com.android.systemui */ 54 private static final String PULSE_ACTION = "com.android.systemui.doze.pulse"; 55 56 private final Context mContext; 57 private final DozeMachine mMachine; 58 private final DozeSensors mDozeSensors; 59 private final DozeHost mDozeHost; 60 private final AmbientDisplayConfiguration mConfig; 61 private final DozeParameters mDozeParameters; 62 private final SensorManager mSensorManager; 63 private final Handler mHandler; 64 private final WakeLock mWakeLock; 65 private final boolean mAllowPulseTriggers; 66 private final UiModeManager mUiModeManager; 67 private final TriggerReceiver mBroadcastReceiver = new TriggerReceiver(); 68 69 private long mNotificationPulseTime; 70 private boolean mPulsePending; 71 72 73 public DozeTriggers(Context context, DozeMachine machine, DozeHost dozeHost, 74 AlarmManager alarmManager, AmbientDisplayConfiguration config, 75 DozeParameters dozeParameters, SensorManager sensorManager, Handler handler, 76 WakeLock wakeLock, boolean allowPulseTriggers) { 77 mContext = context; 78 mMachine = machine; 79 mDozeHost = dozeHost; 80 mConfig = config; 81 mDozeParameters = dozeParameters; 82 mSensorManager = sensorManager; 83 mHandler = handler; 84 mWakeLock = wakeLock; 85 mAllowPulseTriggers = allowPulseTriggers; 86 mDozeSensors = new DozeSensors(context, alarmManager, mSensorManager, dozeParameters, 87 config, wakeLock, this::onSensor, this::onProximityFar, 88 new AlwaysOnDisplayPolicy(context)); 89 mUiModeManager = mContext.getSystemService(UiModeManager.class); 90 } 91 92 private void onNotification() { 93 if (DozeMachine.DEBUG) Log.d(TAG, "requestNotificationPulse"); 94 mNotificationPulseTime = SystemClock.elapsedRealtime(); 95 if (!mConfig.pulseOnNotificationEnabled(UserHandle.USER_CURRENT)) return; 96 requestPulse(DozeLog.PULSE_REASON_NOTIFICATION, false /* performedProxCheck */); 97 DozeLog.traceNotificationPulse(mContext); 98 } 99 100 private void onWhisper() { 101 requestPulse(DozeLog.PULSE_REASON_NOTIFICATION, false /* performedProxCheck */); 102 } 103 104 private void proximityCheckThenCall(IntConsumer callback, 105 boolean alreadyPerformedProxCheck, 106 int pulseReason) { 107 Boolean cachedProxFar = mDozeSensors.isProximityCurrentlyFar(); 108 if (alreadyPerformedProxCheck) { 109 callback.accept(ProximityCheck.RESULT_NOT_CHECKED); 110 } else if (cachedProxFar != null) { 111 callback.accept(cachedProxFar ? ProximityCheck.RESULT_FAR : ProximityCheck.RESULT_NEAR); 112 } else { 113 final long start = SystemClock.uptimeMillis(); 114 new ProximityCheck() { 115 @Override 116 public void onProximityResult(int result) { 117 final long end = SystemClock.uptimeMillis(); 118 DozeLog.traceProximityResult(mContext, result == RESULT_NEAR, 119 end - start, pulseReason); 120 callback.accept(result); 121 } 122 }.check(); 123 } 124 } 125 126 private void onSensor(int pulseReason, boolean sensorPerformedProxCheck, 127 float screenX, float screenY) { 128 boolean isDoubleTap = pulseReason == DozeLog.PULSE_REASON_SENSOR_DOUBLE_TAP; 129 boolean isPickup = pulseReason == DozeLog.PULSE_REASON_SENSOR_PICKUP; 130 boolean isLongPress = pulseReason == DozeLog.PULSE_REASON_SENSOR_LONG_PRESS; 131 132 if (mConfig.alwaysOnEnabled(UserHandle.USER_CURRENT) && !isLongPress) { 133 proximityCheckThenCall((result) -> { 134 if (result == ProximityCheck.RESULT_NEAR) { 135 // In pocket, drop event. 136 return; 137 } 138 if (isDoubleTap) { 139 mDozeHost.onDoubleTap(screenX, screenY); 140 mMachine.wakeUp(); 141 } else { 142 mDozeHost.extendPulse(); 143 } 144 }, sensorPerformedProxCheck, pulseReason); 145 return; 146 } else { 147 requestPulse(pulseReason, sensorPerformedProxCheck); 148 } 149 150 if (isPickup) { 151 final long timeSinceNotification = 152 SystemClock.elapsedRealtime() - mNotificationPulseTime; 153 final boolean withinVibrationThreshold = 154 timeSinceNotification < mDozeParameters.getPickupVibrationThreshold(); 155 DozeLog.tracePickupPulse(mContext, withinVibrationThreshold); 156 } 157 } 158 159 private void onProximityFar(boolean far) { 160 final boolean near = !far; 161 final DozeMachine.State state = mMachine.getState(); 162 final boolean paused = (state == DozeMachine.State.DOZE_AOD_PAUSED); 163 final boolean pausing = (state == DozeMachine.State.DOZE_AOD_PAUSING); 164 final boolean aod = (state == DozeMachine.State.DOZE_AOD); 165 166 if (state == DozeMachine.State.DOZE_PULSING) { 167 boolean ignoreTouch = near; 168 if (DEBUG) Log.i(TAG, "Prox changed, ignore touch = " + ignoreTouch); 169 mDozeHost.onIgnoreTouchWhilePulsing(ignoreTouch); 170 } 171 if (far && (paused || pausing)) { 172 if (DEBUG) Log.i(TAG, "Prox FAR, unpausing AOD"); 173 mMachine.requestState(DozeMachine.State.DOZE_AOD); 174 } else if (near && aod) { 175 if (DEBUG) Log.i(TAG, "Prox NEAR, pausing AOD"); 176 mMachine.requestState(DozeMachine.State.DOZE_AOD_PAUSING); 177 } 178 } 179 180 @Override 181 public void transitionTo(DozeMachine.State oldState, DozeMachine.State newState) { 182 switch (newState) { 183 case INITIALIZED: 184 mBroadcastReceiver.register(mContext); 185 mDozeHost.addCallback(mHostCallback); 186 checkTriggersAtInit(); 187 break; 188 case DOZE: 189 case DOZE_AOD: 190 mDozeSensors.setProxListening(newState != DozeMachine.State.DOZE); 191 if (oldState != DozeMachine.State.INITIALIZED) { 192 mDozeSensors.reregisterAllSensors(); 193 } 194 mDozeSensors.setListening(true); 195 break; 196 case DOZE_AOD_PAUSED: 197 case DOZE_AOD_PAUSING: 198 mDozeSensors.setProxListening(true); 199 mDozeSensors.setListening(false); 200 break; 201 case DOZE_PULSING: 202 mDozeSensors.setTouchscreenSensorsListening(false); 203 mDozeSensors.setProxListening(true); 204 break; 205 case FINISH: 206 mBroadcastReceiver.unregister(mContext); 207 mDozeHost.removeCallback(mHostCallback); 208 mDozeSensors.setListening(false); 209 mDozeSensors.setProxListening(false); 210 break; 211 default: 212 } 213 } 214 215 private void checkTriggersAtInit() { 216 if (mUiModeManager.getCurrentModeType() == Configuration.UI_MODE_TYPE_CAR 217 || mDozeHost.isPowerSaveActive() 218 || mDozeHost.isBlockingDoze() 219 || !mDozeHost.isProvisioned()) { 220 mMachine.requestState(DozeMachine.State.FINISH); 221 } 222 } 223 224 private void requestPulse(final int reason, boolean performedProxCheck) { 225 Assert.isMainThread(); 226 mDozeHost.extendPulse(); 227 if (mPulsePending || !mAllowPulseTriggers || !canPulse()) { 228 if (mAllowPulseTriggers) { 229 DozeLog.tracePulseDropped(mContext, mPulsePending, mMachine.getState(), 230 mDozeHost.isPulsingBlocked()); 231 } 232 return; 233 } 234 235 mPulsePending = true; 236 proximityCheckThenCall((result) -> { 237 if (result == ProximityCheck.RESULT_NEAR) { 238 // in pocket, abort pulse 239 mPulsePending = false; 240 } else { 241 // not in pocket, continue pulsing 242 continuePulseRequest(reason); 243 } 244 }, !mDozeParameters.getProxCheckBeforePulse() || performedProxCheck, reason); 245 } 246 247 private boolean canPulse() { 248 return mMachine.getState() == DozeMachine.State.DOZE 249 || mMachine.getState() == DozeMachine.State.DOZE_AOD; 250 } 251 252 private void continuePulseRequest(int reason) { 253 mPulsePending = false; 254 if (mDozeHost.isPulsingBlocked() || !canPulse()) { 255 DozeLog.tracePulseDropped(mContext, mPulsePending, mMachine.getState(), 256 mDozeHost.isPulsingBlocked()); 257 return; 258 } 259 mMachine.requestPulse(reason); 260 } 261 262 @Override 263 public void dump(PrintWriter pw) { 264 pw.print(" notificationPulseTime="); 265 pw.println(Formatter.formatShortElapsedTime(mContext, mNotificationPulseTime)); 266 267 pw.print(" pulsePending="); pw.println(mPulsePending); 268 pw.println("DozeSensors:"); 269 mDozeSensors.dump(pw); 270 } 271 272 private abstract class ProximityCheck implements SensorEventListener, Runnable { 273 private static final int TIMEOUT_DELAY_MS = 500; 274 275 protected static final int RESULT_UNKNOWN = 0; 276 protected static final int RESULT_NEAR = 1; 277 protected static final int RESULT_FAR = 2; 278 protected static final int RESULT_NOT_CHECKED = 3; 279 280 private boolean mRegistered; 281 private boolean mFinished; 282 private float mMaxRange; 283 284 protected abstract void onProximityResult(int result); 285 286 public void check() { 287 Preconditions.checkState(!mFinished && !mRegistered); 288 final Sensor sensor = mSensorManager.getDefaultSensor(Sensor.TYPE_PROXIMITY); 289 if (sensor == null) { 290 if (DozeMachine.DEBUG) Log.d(TAG, "ProxCheck: No sensor found"); 291 finishWithResult(RESULT_UNKNOWN); 292 return; 293 } 294 mDozeSensors.setDisableSensorsInterferingWithProximity(true); 295 296 mMaxRange = sensor.getMaximumRange(); 297 mSensorManager.registerListener(this, sensor, SensorManager.SENSOR_DELAY_NORMAL, 0, 298 mHandler); 299 mHandler.postDelayed(this, TIMEOUT_DELAY_MS); 300 mWakeLock.acquire(); 301 mRegistered = true; 302 } 303 304 @Override 305 public void onSensorChanged(SensorEvent event) { 306 if (event.values.length == 0) { 307 if (DozeMachine.DEBUG) Log.d(TAG, "ProxCheck: Event has no values!"); 308 finishWithResult(RESULT_UNKNOWN); 309 } else { 310 if (DozeMachine.DEBUG) { 311 Log.d(TAG, "ProxCheck: Event: value=" + event.values[0] + " max=" + mMaxRange); 312 } 313 final boolean isNear = event.values[0] < mMaxRange; 314 finishWithResult(isNear ? RESULT_NEAR : RESULT_FAR); 315 } 316 } 317 318 @Override 319 public void run() { 320 if (DozeMachine.DEBUG) Log.d(TAG, "ProxCheck: No event received before timeout"); 321 finishWithResult(RESULT_UNKNOWN); 322 } 323 324 private void finishWithResult(int result) { 325 if (mFinished) return; 326 boolean wasRegistered = mRegistered; 327 if (mRegistered) { 328 mHandler.removeCallbacks(this); 329 mSensorManager.unregisterListener(this); 330 mDozeSensors.setDisableSensorsInterferingWithProximity(false); 331 mRegistered = false; 332 } 333 onProximityResult(result); 334 if (wasRegistered) { 335 mWakeLock.release(); 336 } 337 mFinished = true; 338 } 339 340 @Override 341 public void onAccuracyChanged(Sensor sensor, int accuracy) { 342 // noop 343 } 344 } 345 346 private class TriggerReceiver extends BroadcastReceiver { 347 private boolean mRegistered; 348 349 @Override 350 public void onReceive(Context context, Intent intent) { 351 if (PULSE_ACTION.equals(intent.getAction())) { 352 if (DozeMachine.DEBUG) Log.d(TAG, "Received pulse intent"); 353 requestPulse(DozeLog.PULSE_REASON_INTENT, false /* performedProxCheck */); 354 } 355 if (UiModeManager.ACTION_ENTER_CAR_MODE.equals(intent.getAction())) { 356 mMachine.requestState(DozeMachine.State.FINISH); 357 } 358 if (Intent.ACTION_USER_SWITCHED.equals(intent.getAction())) { 359 mDozeSensors.onUserSwitched(); 360 } 361 } 362 363 public void register(Context context) { 364 if (mRegistered) { 365 return; 366 } 367 IntentFilter filter = new IntentFilter(PULSE_ACTION); 368 filter.addAction(UiModeManager.ACTION_ENTER_CAR_MODE); 369 filter.addAction(Intent.ACTION_USER_SWITCHED); 370 context.registerReceiver(this, filter); 371 mRegistered = true; 372 } 373 374 public void unregister(Context context) { 375 if (!mRegistered) { 376 return; 377 } 378 context.unregisterReceiver(this); 379 mRegistered = false; 380 } 381 } 382 383 private DozeHost.Callback mHostCallback = new DozeHost.Callback() { 384 @Override 385 public void onNotificationHeadsUp() { 386 onNotification(); 387 } 388 389 @Override 390 public void onPowerSaveChanged(boolean active) { 391 if (active) { 392 mMachine.requestState(DozeMachine.State.FINISH); 393 } 394 } 395 }; 396 } 397
