John Spurlock | bf37099 | 2014-06-17 13:58:31 -0400 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2014 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 | |
Adrian Roos | 7294c11 | 2016-09-20 14:03:21 -0700 | [diff] [blame] | 19 | import android.app.ActivityManager; |
John Spurlock | 870f153 | 2014-09-25 20:34:31 -0400 | [diff] [blame] | 20 | import android.app.UiModeManager; |
John Spurlock | bf37099 | 2014-06-17 13:58:31 -0400 | [diff] [blame] | 21 | import android.content.BroadcastReceiver; |
| 22 | import android.content.Context; |
| 23 | import android.content.Intent; |
| 24 | import android.content.IntentFilter; |
John Spurlock | 870f153 | 2014-09-25 20:34:31 -0400 | [diff] [blame] | 25 | import android.content.res.Configuration; |
Adrian Roos | 7294c11 | 2016-09-20 14:03:21 -0700 | [diff] [blame] | 26 | import android.database.ContentObserver; |
John Spurlock | bf37099 | 2014-06-17 13:58:31 -0400 | [diff] [blame] | 27 | import android.hardware.Sensor; |
John Spurlock | 92b8d41 | 2014-10-03 17:12:40 -0400 | [diff] [blame] | 28 | import android.hardware.SensorEvent; |
| 29 | import android.hardware.SensorEventListener; |
John Spurlock | bf37099 | 2014-06-17 13:58:31 -0400 | [diff] [blame] | 30 | import android.hardware.SensorManager; |
| 31 | import android.hardware.TriggerEvent; |
| 32 | import android.hardware.TriggerEventListener; |
John Spurlock | 559d959 | 2014-08-09 12:04:36 -0400 | [diff] [blame] | 33 | import android.media.AudioAttributes; |
Adrian Roos | 7294c11 | 2016-09-20 14:03:21 -0700 | [diff] [blame] | 34 | import android.net.Uri; |
John Spurlock | 92b8d41 | 2014-10-03 17:12:40 -0400 | [diff] [blame] | 35 | import android.os.Handler; |
John Spurlock | bf37099 | 2014-06-17 13:58:31 -0400 | [diff] [blame] | 36 | import android.os.PowerManager; |
John Spurlock | 92b8d41 | 2014-10-03 17:12:40 -0400 | [diff] [blame] | 37 | import android.os.SystemClock; |
Adrian Roos | 7294c11 | 2016-09-20 14:03:21 -0700 | [diff] [blame] | 38 | import android.os.UserHandle; |
John Spurlock | bf37099 | 2014-06-17 13:58:31 -0400 | [diff] [blame] | 39 | import android.os.Vibrator; |
Adrian Roos | 7294c11 | 2016-09-20 14:03:21 -0700 | [diff] [blame] | 40 | import android.provider.Settings; |
John Spurlock | bf37099 | 2014-06-17 13:58:31 -0400 | [diff] [blame] | 41 | import android.service.dreams.DreamService; |
Adrian Roos | 7294c11 | 2016-09-20 14:03:21 -0700 | [diff] [blame] | 42 | import android.text.TextUtils; |
John Spurlock | bf37099 | 2014-06-17 13:58:31 -0400 | [diff] [blame] | 43 | import android.util.Log; |
John Spurlock | ed69bd6 | 2014-07-23 11:09:02 -0400 | [diff] [blame] | 44 | import android.view.Display; |
John Spurlock | bf37099 | 2014-06-17 13:58:31 -0400 | [diff] [blame] | 45 | |
Adrian Roos | b7e4e10 | 2016-10-14 13:03:45 -0700 | [diff] [blame] | 46 | import com.android.internal.hardware.AmbientDisplayConfiguration; |
Bhavik Singh | 3451da4 | 2016-06-01 18:25:59 -0700 | [diff] [blame] | 47 | import com.android.internal.logging.MetricsLogger; |
Tamas Berghammer | cbd3f0c | 2016-06-22 15:21:38 +0100 | [diff] [blame^] | 48 | import com.android.internal.logging.nano.MetricsProto.MetricsEvent; |
John Spurlock | bf37099 | 2014-06-17 13:58:31 -0400 | [diff] [blame] | 49 | import com.android.systemui.SystemUIApplication; |
John Spurlock | d06aa57 | 2014-09-10 10:40:49 -0400 | [diff] [blame] | 50 | import com.android.systemui.statusbar.phone.DozeParameters; |
John Spurlock | bf37099 | 2014-06-17 13:58:31 -0400 | [diff] [blame] | 51 | |
John Spurlock | 6612727 | 2014-06-28 11:27:17 -0400 | [diff] [blame] | 52 | import java.io.FileDescriptor; |
| 53 | import java.io.PrintWriter; |
John Spurlock | cb566aa | 2014-08-03 22:58:28 -0400 | [diff] [blame] | 54 | import java.util.Date; |
Adrian Roos | 7294c11 | 2016-09-20 14:03:21 -0700 | [diff] [blame] | 55 | import java.util.List; |
John Spurlock | 6612727 | 2014-06-28 11:27:17 -0400 | [diff] [blame] | 56 | |
John Spurlock | bf37099 | 2014-06-17 13:58:31 -0400 | [diff] [blame] | 57 | public class DozeService extends DreamService { |
John Spurlock | ed69bd6 | 2014-07-23 11:09:02 -0400 | [diff] [blame] | 58 | private static final String TAG = "DozeService"; |
| 59 | private static final boolean DEBUG = Log.isLoggable(TAG, Log.DEBUG); |
John Spurlock | bf37099 | 2014-06-17 13:58:31 -0400 | [diff] [blame] | 60 | |
John Spurlock | cb566aa | 2014-08-03 22:58:28 -0400 | [diff] [blame] | 61 | private static final String ACTION_BASE = "com.android.systemui.doze"; |
| 62 | private static final String PULSE_ACTION = ACTION_BASE + ".pulse"; |
Christoph Studer | 1f32c65 | 2014-11-26 15:32:20 +0100 | [diff] [blame] | 63 | |
Adrian Roos | 0288dcc | 2016-10-04 16:35:10 -0400 | [diff] [blame] | 64 | /** |
| 65 | * If true, reregisters all trigger sensors when the screen turns off. |
| 66 | */ |
| 67 | private static final boolean REREGISTER_ALL_SENSORS_ON_SCREEN_OFF = true; |
| 68 | |
John Spurlock | ed69bd6 | 2014-07-23 11:09:02 -0400 | [diff] [blame] | 69 | private final String mTag = String.format(TAG + ".%08x", hashCode()); |
John Spurlock | bf37099 | 2014-06-17 13:58:31 -0400 | [diff] [blame] | 70 | private final Context mContext = this; |
John Spurlock | d06aa57 | 2014-09-10 10:40:49 -0400 | [diff] [blame] | 71 | private final DozeParameters mDozeParameters = new DozeParameters(mContext); |
John Spurlock | 92b8d41 | 2014-10-03 17:12:40 -0400 | [diff] [blame] | 72 | private final Handler mHandler = new Handler(); |
John Spurlock | bf37099 | 2014-06-17 13:58:31 -0400 | [diff] [blame] | 73 | |
Jeff Brown | 4d69e22 | 2014-09-18 15:27:50 -0700 | [diff] [blame] | 74 | private DozeHost mHost; |
Adrian Roos | 7294c11 | 2016-09-20 14:03:21 -0700 | [diff] [blame] | 75 | private SensorManager mSensorManager; |
| 76 | private TriggerSensor[] mSensors; |
John Spurlock | 559d959 | 2014-08-09 12:04:36 -0400 | [diff] [blame] | 77 | private TriggerSensor mPickupSensor; |
John Spurlock | bf37099 | 2014-06-17 13:58:31 -0400 | [diff] [blame] | 78 | private PowerManager mPowerManager; |
| 79 | private PowerManager.WakeLock mWakeLock; |
John Spurlock | 870f153 | 2014-09-25 20:34:31 -0400 | [diff] [blame] | 80 | private UiModeManager mUiModeManager; |
John Spurlock | bf37099 | 2014-06-17 13:58:31 -0400 | [diff] [blame] | 81 | private boolean mDreaming; |
Jeff Brown | 4d69e22 | 2014-09-18 15:27:50 -0700 | [diff] [blame] | 82 | private boolean mPulsing; |
John Spurlock | cb566aa | 2014-08-03 22:58:28 -0400 | [diff] [blame] | 83 | private boolean mBroadcastReceiverRegistered; |
John Spurlock | ed69bd6 | 2014-07-23 11:09:02 -0400 | [diff] [blame] | 84 | private boolean mDisplayStateSupported; |
John Spurlock | d96179e | 2014-08-21 16:43:45 -0400 | [diff] [blame] | 85 | private boolean mPowerSaveActive; |
John Spurlock | 870f153 | 2014-09-25 20:34:31 -0400 | [diff] [blame] | 86 | private boolean mCarMode; |
John Spurlock | d06aa57 | 2014-09-10 10:40:49 -0400 | [diff] [blame] | 87 | private long mNotificationPulseTime; |
John Spurlock | bf37099 | 2014-06-17 13:58:31 -0400 | [diff] [blame] | 88 | |
Adrian Roos | b7e4e10 | 2016-10-14 13:03:45 -0700 | [diff] [blame] | 89 | private AmbientDisplayConfiguration mConfig; |
| 90 | |
John Spurlock | bf37099 | 2014-06-17 13:58:31 -0400 | [diff] [blame] | 91 | public DozeService() { |
| 92 | if (DEBUG) Log.d(mTag, "new DozeService()"); |
| 93 | setDebug(DEBUG); |
| 94 | } |
| 95 | |
| 96 | @Override |
John Spurlock | 6612727 | 2014-06-28 11:27:17 -0400 | [diff] [blame] | 97 | protected void dumpOnHandler(FileDescriptor fd, PrintWriter pw, String[] args) { |
| 98 | super.dumpOnHandler(fd, pw, args); |
| 99 | pw.print(" mDreaming: "); pw.println(mDreaming); |
Jeff Brown | 4d69e22 | 2014-09-18 15:27:50 -0700 | [diff] [blame] | 100 | pw.print(" mPulsing: "); pw.println(mPulsing); |
| 101 | pw.print(" mWakeLock: held="); pw.println(mWakeLock.isHeld()); |
John Spurlock | c6eed84 | 2014-08-25 12:19:41 -0400 | [diff] [blame] | 102 | pw.print(" mHost: "); pw.println(mHost); |
John Spurlock | cb566aa | 2014-08-03 22:58:28 -0400 | [diff] [blame] | 103 | pw.print(" mBroadcastReceiverRegistered: "); pw.println(mBroadcastReceiverRegistered); |
Adrian Roos | 7294c11 | 2016-09-20 14:03:21 -0700 | [diff] [blame] | 104 | for (TriggerSensor s : mSensors) { |
| 105 | pw.print(" sensor: "); |
| 106 | pw.println(s); |
| 107 | } |
John Spurlock | ed69bd6 | 2014-07-23 11:09:02 -0400 | [diff] [blame] | 108 | pw.print(" mDisplayStateSupported: "); pw.println(mDisplayStateSupported); |
John Spurlock | d96179e | 2014-08-21 16:43:45 -0400 | [diff] [blame] | 109 | pw.print(" mPowerSaveActive: "); pw.println(mPowerSaveActive); |
John Spurlock | 870f153 | 2014-09-25 20:34:31 -0400 | [diff] [blame] | 110 | pw.print(" mCarMode: "); pw.println(mCarMode); |
Adrian Roos | d13602f | 2016-08-22 15:31:38 +0200 | [diff] [blame] | 111 | pw.print(" mNotificationPulseTime: "); pw.println( |
| 112 | DozeLog.FORMAT.format(new Date(mNotificationPulseTime |
| 113 | - SystemClock.elapsedRealtime() + System.currentTimeMillis()))); |
John Spurlock | d06aa57 | 2014-09-10 10:40:49 -0400 | [diff] [blame] | 114 | mDozeParameters.dump(pw); |
John Spurlock | 6612727 | 2014-06-28 11:27:17 -0400 | [diff] [blame] | 115 | } |
| 116 | |
| 117 | @Override |
John Spurlock | bf37099 | 2014-06-17 13:58:31 -0400 | [diff] [blame] | 118 | public void onCreate() { |
| 119 | if (DEBUG) Log.d(mTag, "onCreate"); |
| 120 | super.onCreate(); |
| 121 | |
| 122 | if (getApplication() instanceof SystemUIApplication) { |
| 123 | final SystemUIApplication app = (SystemUIApplication) getApplication(); |
Jeff Brown | 4d69e22 | 2014-09-18 15:27:50 -0700 | [diff] [blame] | 124 | mHost = app.getComponent(DozeHost.class); |
John Spurlock | bf37099 | 2014-06-17 13:58:31 -0400 | [diff] [blame] | 125 | } |
John Spurlock | c6eed84 | 2014-08-25 12:19:41 -0400 | [diff] [blame] | 126 | if (mHost == null) Log.w(TAG, "No doze service host found."); |
John Spurlock | bf37099 | 2014-06-17 13:58:31 -0400 | [diff] [blame] | 127 | |
| 128 | setWindowless(true); |
| 129 | |
Adrian Roos | 7294c11 | 2016-09-20 14:03:21 -0700 | [diff] [blame] | 130 | mSensorManager = (SensorManager) mContext.getSystemService(Context.SENSOR_SERVICE); |
Adrian Roos | b7e4e10 | 2016-10-14 13:03:45 -0700 | [diff] [blame] | 131 | mConfig = new AmbientDisplayConfiguration(mContext); |
Adrian Roos | 7294c11 | 2016-09-20 14:03:21 -0700 | [diff] [blame] | 132 | mSensors = new TriggerSensor[] { |
| 133 | new TriggerSensor( |
| 134 | mSensorManager.getDefaultSensor(Sensor.TYPE_SIGNIFICANT_MOTION), |
| 135 | null /* setting */, |
| 136 | mDozeParameters.getPulseOnSigMotion(), |
| 137 | mDozeParameters.getVibrateOnSigMotion(), |
| 138 | DozeLog.PULSE_REASON_SENSOR_SIGMOTION), |
| 139 | mPickupSensor = new TriggerSensor( |
| 140 | mSensorManager.getDefaultSensor(Sensor.TYPE_PICK_UP_GESTURE), |
| 141 | Settings.Secure.DOZE_PULSE_ON_PICK_UP, |
Adrian Roos | b7e4e10 | 2016-10-14 13:03:45 -0700 | [diff] [blame] | 142 | mConfig.pulseOnPickupAvailable(), mDozeParameters.getVibrateOnPickup(), |
Adrian Roos | 7294c11 | 2016-09-20 14:03:21 -0700 | [diff] [blame] | 143 | DozeLog.PULSE_REASON_SENSOR_PICKUP), |
| 144 | new TriggerSensor( |
Adrian Roos | b7e4e10 | 2016-10-14 13:03:45 -0700 | [diff] [blame] | 145 | findSensorWithType(mConfig.doubleTapSensorType()), |
| 146 | Settings.Secure.DOZE_PULSE_ON_DOUBLE_TAP, true, |
| 147 | mDozeParameters.getVibrateOnPickup(), |
Adrian Roos | 7294c11 | 2016-09-20 14:03:21 -0700 | [diff] [blame] | 148 | DozeLog.PULSE_REASON_SENSOR_DOUBLE_TAP) |
| 149 | }; |
John Spurlock | bf37099 | 2014-06-17 13:58:31 -0400 | [diff] [blame] | 150 | mPowerManager = (PowerManager) mContext.getSystemService(Context.POWER_SERVICE); |
Dianne Hackborn | 3f8bd3f | 2015-07-10 17:05:52 -0700 | [diff] [blame] | 151 | mWakeLock = mPowerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, TAG); |
Jeff Brown | 4d69e22 | 2014-09-18 15:27:50 -0700 | [diff] [blame] | 152 | mWakeLock.setReferenceCounted(true); |
John Spurlock | 190d026 | 2014-09-14 15:39:13 -0400 | [diff] [blame] | 153 | mDisplayStateSupported = mDozeParameters.getDisplayStateSupported(); |
John Spurlock | 870f153 | 2014-09-25 20:34:31 -0400 | [diff] [blame] | 154 | mUiModeManager = (UiModeManager) mContext.getSystemService(Context.UI_MODE_SERVICE); |
Jeff Brown | 4d69e22 | 2014-09-18 15:27:50 -0700 | [diff] [blame] | 155 | turnDisplayOff(); |
John Spurlock | bf37099 | 2014-06-17 13:58:31 -0400 | [diff] [blame] | 156 | } |
| 157 | |
| 158 | @Override |
| 159 | public void onAttachedToWindow() { |
| 160 | if (DEBUG) Log.d(mTag, "onAttachedToWindow"); |
| 161 | super.onAttachedToWindow(); |
| 162 | } |
| 163 | |
| 164 | @Override |
| 165 | public void onDreamingStarted() { |
| 166 | super.onDreamingStarted(); |
Jeff Brown | 4d69e22 | 2014-09-18 15:27:50 -0700 | [diff] [blame] | 167 | |
| 168 | if (mHost == null) { |
| 169 | finish(); |
| 170 | return; |
| 171 | } |
| 172 | |
| 173 | mPowerSaveActive = mHost.isPowerSaveActive(); |
John Spurlock | 870f153 | 2014-09-25 20:34:31 -0400 | [diff] [blame] | 174 | mCarMode = mUiModeManager.getCurrentModeType() == Configuration.UI_MODE_TYPE_CAR; |
John Spurlock | d96179e | 2014-08-21 16:43:45 -0400 | [diff] [blame] | 175 | if (DEBUG) Log.d(mTag, "onDreamingStarted canDoze=" + canDoze() + " mPowerSaveActive=" |
John Spurlock | 870f153 | 2014-09-25 20:34:31 -0400 | [diff] [blame] | 176 | + mPowerSaveActive + " mCarMode=" + mCarMode); |
John Spurlock | d96179e | 2014-08-21 16:43:45 -0400 | [diff] [blame] | 177 | if (mPowerSaveActive) { |
| 178 | finishToSavePower(); |
| 179 | return; |
| 180 | } |
John Spurlock | 870f153 | 2014-09-25 20:34:31 -0400 | [diff] [blame] | 181 | if (mCarMode) { |
| 182 | finishForCarMode(); |
| 183 | return; |
| 184 | } |
Jeff Brown | 4d69e22 | 2014-09-18 15:27:50 -0700 | [diff] [blame] | 185 | |
John Spurlock | bf37099 | 2014-06-17 13:58:31 -0400 | [diff] [blame] | 186 | mDreaming = true; |
Christoph Studer | 1f32c65 | 2014-11-26 15:32:20 +0100 | [diff] [blame] | 187 | listenForPulseSignals(true); |
John Spurlock | bf37099 | 2014-06-17 13:58:31 -0400 | [diff] [blame] | 188 | |
Jeff Brown | 4d69e22 | 2014-09-18 15:27:50 -0700 | [diff] [blame] | 189 | // Ask the host to get things ready to start dozing. |
| 190 | // Once ready, we call startDozing() at which point the CPU may suspend |
| 191 | // and we will need to acquire a wakelock to do work. |
Adrian Roos | 9ede1d2 | 2016-09-23 14:08:09 -0700 | [diff] [blame] | 192 | mHost.startDozing(mWakeLock.wrap(() -> { |
| 193 | if (mDreaming) { |
| 194 | startDozing(); |
John Spurlock | bf37099 | 2014-06-17 13:58:31 -0400 | [diff] [blame] | 195 | |
Adrian Roos | 9ede1d2 | 2016-09-23 14:08:09 -0700 | [diff] [blame] | 196 | // From this point until onDreamingStopped we will need to hold a |
| 197 | // wakelock whenever we are doing work. Note that we never call |
| 198 | // stopDozing because can we just keep dozing until the bitter end. |
Jeff Brown | 4d69e22 | 2014-09-18 15:27:50 -0700 | [diff] [blame] | 199 | } |
Adrian Roos | 9ede1d2 | 2016-09-23 14:08:09 -0700 | [diff] [blame] | 200 | })); |
John Spurlock | ed69bd6 | 2014-07-23 11:09:02 -0400 | [diff] [blame] | 201 | } |
| 202 | |
John Spurlock | bf37099 | 2014-06-17 13:58:31 -0400 | [diff] [blame] | 203 | @Override |
| 204 | public void onDreamingStopped() { |
| 205 | if (DEBUG) Log.d(mTag, "onDreamingStopped isDozing=" + isDozing()); |
| 206 | super.onDreamingStopped(); |
| 207 | |
Jeff Brown | 4d69e22 | 2014-09-18 15:27:50 -0700 | [diff] [blame] | 208 | if (mHost == null) { |
| 209 | return; |
| 210 | } |
| 211 | |
John Spurlock | bf37099 | 2014-06-17 13:58:31 -0400 | [diff] [blame] | 212 | mDreaming = false; |
John Spurlock | cb566aa | 2014-08-03 22:58:28 -0400 | [diff] [blame] | 213 | listenForPulseSignals(false); |
John Spurlock | bf37099 | 2014-06-17 13:58:31 -0400 | [diff] [blame] | 214 | |
Jeff Brown | 4d69e22 | 2014-09-18 15:27:50 -0700 | [diff] [blame] | 215 | // Tell the host that it's over. |
| 216 | mHost.stopDozing(); |
John Spurlock | bf37099 | 2014-06-17 13:58:31 -0400 | [diff] [blame] | 217 | } |
| 218 | |
John Spurlock | eab28e6 | 2014-11-29 11:33:49 -0500 | [diff] [blame] | 219 | private void requestPulse(final int reason) { |
Adrian Roos | 5753f05 | 2016-07-13 10:30:37 -0700 | [diff] [blame] | 220 | requestPulse(reason, false /* performedProxCheck */); |
| 221 | } |
| 222 | |
| 223 | private void requestPulse(final int reason, boolean performedProxCheck) { |
Jeff Brown | 4d69e22 | 2014-09-18 15:27:50 -0700 | [diff] [blame] | 224 | if (mHost != null && mDreaming && !mPulsing) { |
| 225 | // Let the host know we want to pulse. Wait for it to be ready, then |
| 226 | // turn the screen on. When finished, turn the screen off again. |
| 227 | // Here we need a wakelock to stay awake until the pulse is finished. |
| 228 | mWakeLock.acquire(); |
| 229 | mPulsing = true; |
John Spurlock | 621afac8 | 2014-12-03 16:00:44 -0500 | [diff] [blame] | 230 | if (!mDozeParameters.getProxCheckBeforePulse()) { |
John Spurlock | 686e4d5 | 2014-11-20 21:48:09 -0500 | [diff] [blame] | 231 | // skip proximity check |
John Spurlock | eab28e6 | 2014-11-29 11:33:49 -0500 | [diff] [blame] | 232 | continuePulsing(reason); |
John Spurlock | 686e4d5 | 2014-11-20 21:48:09 -0500 | [diff] [blame] | 233 | return; |
| 234 | } |
John Spurlock | 92b8d41 | 2014-10-03 17:12:40 -0400 | [diff] [blame] | 235 | final long start = SystemClock.uptimeMillis(); |
Adrian Roos | 5753f05 | 2016-07-13 10:30:37 -0700 | [diff] [blame] | 236 | if (performedProxCheck) { |
| 237 | // the caller already performed a successful proximity check; we'll only do one to |
| 238 | // capture statistics, continue pulsing immediately. |
John Spurlock | 621afac8 | 2014-12-03 16:00:44 -0500 | [diff] [blame] | 239 | continuePulsing(reason); |
| 240 | } |
| 241 | // perform a proximity check |
John Spurlock | 92b8d41 | 2014-10-03 17:12:40 -0400 | [diff] [blame] | 242 | new ProximityCheck() { |
Jeff Brown | 4d69e22 | 2014-09-18 15:27:50 -0700 | [diff] [blame] | 243 | @Override |
John Spurlock | 92b8d41 | 2014-10-03 17:12:40 -0400 | [diff] [blame] | 244 | public void onProximityResult(int result) { |
John Spurlock | 92b8d41 | 2014-10-03 17:12:40 -0400 | [diff] [blame] | 245 | final boolean isNear = result == RESULT_NEAR; |
John Spurlock | eab28e6 | 2014-11-29 11:33:49 -0500 | [diff] [blame] | 246 | final long end = SystemClock.uptimeMillis(); |
Jorim Jaggi | 8396970 | 2015-06-05 14:59:24 -0700 | [diff] [blame] | 247 | DozeLog.traceProximityResult(mContext, isNear, end - start, reason); |
Adrian Roos | 5753f05 | 2016-07-13 10:30:37 -0700 | [diff] [blame] | 248 | if (performedProxCheck) { |
John Spurlock | 621afac8 | 2014-12-03 16:00:44 -0500 | [diff] [blame] | 249 | // we already continued |
| 250 | return; |
| 251 | } |
| 252 | // avoid pulsing in pockets |
John Spurlock | 92b8d41 | 2014-10-03 17:12:40 -0400 | [diff] [blame] | 253 | if (isNear) { |
Jeff Brown | 4d69e22 | 2014-09-18 15:27:50 -0700 | [diff] [blame] | 254 | mPulsing = false; |
John Spurlock | 92b8d41 | 2014-10-03 17:12:40 -0400 | [diff] [blame] | 255 | mWakeLock.release(); |
| 256 | return; |
Jeff Brown | 4d69e22 | 2014-09-18 15:27:50 -0700 | [diff] [blame] | 257 | } |
John Spurlock | 92b8d41 | 2014-10-03 17:12:40 -0400 | [diff] [blame] | 258 | |
| 259 | // not in-pocket, continue pulsing |
John Spurlock | eab28e6 | 2014-11-29 11:33:49 -0500 | [diff] [blame] | 260 | continuePulsing(reason); |
Jeff Brown | 4d69e22 | 2014-09-18 15:27:50 -0700 | [diff] [blame] | 261 | } |
John Spurlock | 92b8d41 | 2014-10-03 17:12:40 -0400 | [diff] [blame] | 262 | }.check(); |
John Spurlock | bf37099 | 2014-06-17 13:58:31 -0400 | [diff] [blame] | 263 | } |
| 264 | } |
| 265 | |
John Spurlock | eab28e6 | 2014-11-29 11:33:49 -0500 | [diff] [blame] | 266 | private void continuePulsing(int reason) { |
Jorim Jaggi | 007f0e8 | 2015-08-14 13:56:01 -0700 | [diff] [blame] | 267 | if (mHost.isPulsingBlocked()) { |
Jorim Jaggi | 5fb4b98 | 2015-08-19 13:01:19 -0700 | [diff] [blame] | 268 | mPulsing = false; |
| 269 | mWakeLock.release(); |
Jorim Jaggi | 007f0e8 | 2015-08-14 13:56:01 -0700 | [diff] [blame] | 270 | return; |
| 271 | } |
John Spurlock | 686e4d5 | 2014-11-20 21:48:09 -0500 | [diff] [blame] | 272 | mHost.pulseWhileDozing(new DozeHost.PulseCallback() { |
| 273 | @Override |
| 274 | public void onPulseStarted() { |
| 275 | if (mPulsing && mDreaming) { |
| 276 | turnDisplayOn(); |
| 277 | } |
| 278 | } |
| 279 | |
| 280 | @Override |
| 281 | public void onPulseFinished() { |
| 282 | if (mPulsing && mDreaming) { |
| 283 | mPulsing = false; |
Adrian Roos | 0288dcc | 2016-10-04 16:35:10 -0400 | [diff] [blame] | 284 | if (REREGISTER_ALL_SENSORS_ON_SCREEN_OFF) { |
| 285 | reregisterAllSensors(); |
| 286 | } |
John Spurlock | 686e4d5 | 2014-11-20 21:48:09 -0500 | [diff] [blame] | 287 | turnDisplayOff(); |
| 288 | } |
| 289 | mWakeLock.release(); // needs to be unconditional to balance acquire |
| 290 | } |
John Spurlock | eab28e6 | 2014-11-29 11:33:49 -0500 | [diff] [blame] | 291 | }, reason); |
John Spurlock | 686e4d5 | 2014-11-20 21:48:09 -0500 | [diff] [blame] | 292 | } |
| 293 | |
Jeff Brown | 4d69e22 | 2014-09-18 15:27:50 -0700 | [diff] [blame] | 294 | private void turnDisplayOff() { |
John Spurlock | 92b8d41 | 2014-10-03 17:12:40 -0400 | [diff] [blame] | 295 | if (DEBUG) Log.d(mTag, "Display off"); |
Jeff Brown | 4d69e22 | 2014-09-18 15:27:50 -0700 | [diff] [blame] | 296 | setDozeScreenState(Display.STATE_OFF); |
| 297 | } |
| 298 | |
| 299 | private void turnDisplayOn() { |
John Spurlock | 92b8d41 | 2014-10-03 17:12:40 -0400 | [diff] [blame] | 300 | if (DEBUG) Log.d(mTag, "Display on"); |
Jeff Brown | 4d69e22 | 2014-09-18 15:27:50 -0700 | [diff] [blame] | 301 | setDozeScreenState(mDisplayStateSupported ? Display.STATE_DOZE : Display.STATE_ON); |
John Spurlock | bf37099 | 2014-06-17 13:58:31 -0400 | [diff] [blame] | 302 | } |
| 303 | |
John Spurlock | d96179e | 2014-08-21 16:43:45 -0400 | [diff] [blame] | 304 | private void finishToSavePower() { |
| 305 | Log.w(mTag, "Exiting ambient mode due to low power battery saver"); |
| 306 | finish(); |
| 307 | } |
| 308 | |
John Spurlock | 870f153 | 2014-09-25 20:34:31 -0400 | [diff] [blame] | 309 | private void finishForCarMode() { |
| 310 | Log.w(mTag, "Exiting ambient mode, not allowed in car mode"); |
| 311 | finish(); |
| 312 | } |
| 313 | |
John Spurlock | cb566aa | 2014-08-03 22:58:28 -0400 | [diff] [blame] | 314 | private void listenForPulseSignals(boolean listen) { |
| 315 | if (DEBUG) Log.d(mTag, "listenForPulseSignals: " + listen); |
Adrian Roos | 7294c11 | 2016-09-20 14:03:21 -0700 | [diff] [blame] | 316 | for (TriggerSensor s : mSensors) { |
| 317 | s.setListening(listen); |
| 318 | } |
John Spurlock | cb566aa | 2014-08-03 22:58:28 -0400 | [diff] [blame] | 319 | listenForBroadcasts(listen); |
John Spurlock | 6612727 | 2014-06-28 11:27:17 -0400 | [diff] [blame] | 320 | listenForNotifications(listen); |
| 321 | } |
| 322 | |
Adrian Roos | 0288dcc | 2016-10-04 16:35:10 -0400 | [diff] [blame] | 323 | private void reregisterAllSensors() { |
| 324 | for (TriggerSensor s : mSensors) { |
| 325 | s.setListening(false); |
| 326 | } |
| 327 | for (TriggerSensor s : mSensors) { |
| 328 | s.setListening(true); |
| 329 | } |
| 330 | } |
| 331 | |
John Spurlock | cb566aa | 2014-08-03 22:58:28 -0400 | [diff] [blame] | 332 | private void listenForBroadcasts(boolean listen) { |
John Spurlock | bf37099 | 2014-06-17 13:58:31 -0400 | [diff] [blame] | 333 | if (listen) { |
John Spurlock | cb566aa | 2014-08-03 22:58:28 -0400 | [diff] [blame] | 334 | final IntentFilter filter = new IntentFilter(PULSE_ACTION); |
John Spurlock | 870f153 | 2014-09-25 20:34:31 -0400 | [diff] [blame] | 335 | filter.addAction(UiModeManager.ACTION_ENTER_CAR_MODE); |
Adrian Roos | 7294c11 | 2016-09-20 14:03:21 -0700 | [diff] [blame] | 336 | filter.addAction(Intent.ACTION_USER_SWITCHED); |
John Spurlock | cb566aa | 2014-08-03 22:58:28 -0400 | [diff] [blame] | 337 | mContext.registerReceiver(mBroadcastReceiver, filter); |
Adrian Roos | 7294c11 | 2016-09-20 14:03:21 -0700 | [diff] [blame] | 338 | |
| 339 | for (TriggerSensor s : mSensors) { |
| 340 | if (s.mConfigured && !TextUtils.isEmpty(s.mSetting)) { |
| 341 | mContext.getContentResolver().registerContentObserver( |
| 342 | Settings.Secure.getUriFor(s.mSetting), false /* descendants */, |
| 343 | mSettingsObserver, UserHandle.USER_ALL); |
| 344 | } |
| 345 | } |
John Spurlock | cb566aa | 2014-08-03 22:58:28 -0400 | [diff] [blame] | 346 | mBroadcastReceiverRegistered = true; |
John Spurlock | bf37099 | 2014-06-17 13:58:31 -0400 | [diff] [blame] | 347 | } else { |
John Spurlock | cb566aa | 2014-08-03 22:58:28 -0400 | [diff] [blame] | 348 | if (mBroadcastReceiverRegistered) { |
| 349 | mContext.unregisterReceiver(mBroadcastReceiver); |
Adrian Roos | 7294c11 | 2016-09-20 14:03:21 -0700 | [diff] [blame] | 350 | mContext.getContentResolver().unregisterContentObserver(mSettingsObserver); |
John Spurlock | bf37099 | 2014-06-17 13:58:31 -0400 | [diff] [blame] | 351 | } |
John Spurlock | cb566aa | 2014-08-03 22:58:28 -0400 | [diff] [blame] | 352 | mBroadcastReceiverRegistered = false; |
John Spurlock | bf37099 | 2014-06-17 13:58:31 -0400 | [diff] [blame] | 353 | } |
| 354 | } |
| 355 | |
John Spurlock | 6612727 | 2014-06-28 11:27:17 -0400 | [diff] [blame] | 356 | private void listenForNotifications(boolean listen) { |
John Spurlock | bf37099 | 2014-06-17 13:58:31 -0400 | [diff] [blame] | 357 | if (listen) { |
John Spurlock | 6612727 | 2014-06-28 11:27:17 -0400 | [diff] [blame] | 358 | mHost.addCallback(mHostCallback); |
John Spurlock | bf37099 | 2014-06-17 13:58:31 -0400 | [diff] [blame] | 359 | } else { |
John Spurlock | 6612727 | 2014-06-28 11:27:17 -0400 | [diff] [blame] | 360 | mHost.removeCallback(mHostCallback); |
John Spurlock | bf37099 | 2014-06-17 13:58:31 -0400 | [diff] [blame] | 361 | } |
| 362 | } |
| 363 | |
Adrian Roos | d13602f | 2016-08-22 15:31:38 +0200 | [diff] [blame] | 364 | private void requestNotificationPulse() { |
| 365 | if (DEBUG) Log.d(mTag, "requestNotificationPulse"); |
Adrian Roos | b7e4e10 | 2016-10-14 13:03:45 -0700 | [diff] [blame] | 366 | if (!mConfig.pulseOnNotificationEnabled(UserHandle.USER_CURRENT)) return; |
Adrian Roos | d13602f | 2016-08-22 15:31:38 +0200 | [diff] [blame] | 367 | mNotificationPulseTime = SystemClock.elapsedRealtime(); |
| 368 | requestPulse(DozeLog.PULSE_REASON_NOTIFICATION); |
John Spurlock | cb566aa | 2014-08-03 22:58:28 -0400 | [diff] [blame] | 369 | } |
| 370 | |
John Spurlock | bf37099 | 2014-06-17 13:58:31 -0400 | [diff] [blame] | 371 | private static String triggerEventToString(TriggerEvent event) { |
| 372 | if (event == null) return null; |
| 373 | final StringBuilder sb = new StringBuilder("TriggerEvent[") |
| 374 | .append(event.timestamp).append(',') |
| 375 | .append(event.sensor.getName()); |
| 376 | if (event.values != null) { |
| 377 | for (int i = 0; i < event.values.length; i++) { |
| 378 | sb.append(',').append(event.values[i]); |
| 379 | } |
| 380 | } |
| 381 | return sb.append(']').toString(); |
| 382 | } |
| 383 | |
John Spurlock | cb566aa | 2014-08-03 22:58:28 -0400 | [diff] [blame] | 384 | private final BroadcastReceiver mBroadcastReceiver = new BroadcastReceiver() { |
John Spurlock | bf37099 | 2014-06-17 13:58:31 -0400 | [diff] [blame] | 385 | @Override |
| 386 | public void onReceive(Context context, Intent intent) { |
John Spurlock | cb566aa | 2014-08-03 22:58:28 -0400 | [diff] [blame] | 387 | if (PULSE_ACTION.equals(intent.getAction())) { |
| 388 | if (DEBUG) Log.d(mTag, "Received pulse intent"); |
John Spurlock | eab28e6 | 2014-11-29 11:33:49 -0500 | [diff] [blame] | 389 | requestPulse(DozeLog.PULSE_REASON_INTENT); |
John Spurlock | cb566aa | 2014-08-03 22:58:28 -0400 | [diff] [blame] | 390 | } |
John Spurlock | 870f153 | 2014-09-25 20:34:31 -0400 | [diff] [blame] | 391 | if (UiModeManager.ACTION_ENTER_CAR_MODE.equals(intent.getAction())) { |
| 392 | mCarMode = true; |
| 393 | if (mCarMode && mDreaming) { |
| 394 | finishForCarMode(); |
| 395 | } |
| 396 | } |
Adrian Roos | 7294c11 | 2016-09-20 14:03:21 -0700 | [diff] [blame] | 397 | if (Intent.ACTION_USER_SWITCHED.equals(intent.getAction())) { |
| 398 | for (TriggerSensor s : mSensors) { |
| 399 | s.updateListener(); |
| 400 | } |
| 401 | } |
| 402 | } |
| 403 | }; |
| 404 | |
| 405 | private final ContentObserver mSettingsObserver = new ContentObserver(mHandler) { |
| 406 | @Override |
| 407 | public void onChange(boolean selfChange, Uri uri, int userId) { |
| 408 | if (userId != ActivityManager.getCurrentUser()) { |
| 409 | return; |
| 410 | } |
| 411 | for (TriggerSensor s : mSensors) { |
| 412 | s.updateListener(); |
| 413 | } |
John Spurlock | bf37099 | 2014-06-17 13:58:31 -0400 | [diff] [blame] | 414 | } |
| 415 | }; |
| 416 | |
Jeff Brown | 4d69e22 | 2014-09-18 15:27:50 -0700 | [diff] [blame] | 417 | private final DozeHost.Callback mHostCallback = new DozeHost.Callback() { |
John Spurlock | bf37099 | 2014-06-17 13:58:31 -0400 | [diff] [blame] | 418 | @Override |
| 419 | public void onNewNotifications() { |
Christoph Studer | 1f32c65 | 2014-11-26 15:32:20 +0100 | [diff] [blame] | 420 | if (DEBUG) Log.d(mTag, "onNewNotifications (noop)"); |
John Spurlock | cad5768 | 2014-07-26 17:09:56 -0400 | [diff] [blame] | 421 | // noop for now |
| 422 | } |
John Spurlock | cb566aa | 2014-08-03 22:58:28 -0400 | [diff] [blame] | 423 | |
John Spurlock | cad5768 | 2014-07-26 17:09:56 -0400 | [diff] [blame] | 424 | @Override |
| 425 | public void onBuzzBeepBlinked() { |
| 426 | if (DEBUG) Log.d(mTag, "onBuzzBeepBlinked"); |
Adrian Roos | d13602f | 2016-08-22 15:31:38 +0200 | [diff] [blame] | 427 | requestNotificationPulse(); |
John Spurlock | cb566aa | 2014-08-03 22:58:28 -0400 | [diff] [blame] | 428 | } |
| 429 | |
| 430 | @Override |
| 431 | public void onNotificationLight(boolean on) { |
Adrian Roos | d13602f | 2016-08-22 15:31:38 +0200 | [diff] [blame] | 432 | if (DEBUG) Log.d(mTag, "onNotificationLight (noop) on=" + on); |
| 433 | // noop for now |
John Spurlock | bf37099 | 2014-06-17 13:58:31 -0400 | [diff] [blame] | 434 | } |
John Spurlock | d96179e | 2014-08-21 16:43:45 -0400 | [diff] [blame] | 435 | |
| 436 | @Override |
| 437 | public void onPowerSaveChanged(boolean active) { |
| 438 | mPowerSaveActive = active; |
| 439 | if (mPowerSaveActive && mDreaming) { |
| 440 | finishToSavePower(); |
| 441 | } |
| 442 | } |
John Spurlock | bf37099 | 2014-06-17 13:58:31 -0400 | [diff] [blame] | 443 | }; |
| 444 | |
Adrian Roos | 7294c11 | 2016-09-20 14:03:21 -0700 | [diff] [blame] | 445 | private Sensor findSensorWithType(String type) { |
| 446 | if (TextUtils.isEmpty(type)) { |
| 447 | return null; |
| 448 | } |
| 449 | List<Sensor> sensorList = mSensorManager.getSensorList(Sensor.TYPE_ALL); |
| 450 | for (Sensor s : sensorList) { |
| 451 | if (type.equals(s.getStringType())) { |
| 452 | return s; |
| 453 | } |
| 454 | } |
| 455 | return null; |
| 456 | } |
| 457 | |
John Spurlock | 559d959 | 2014-08-09 12:04:36 -0400 | [diff] [blame] | 458 | private class TriggerSensor extends TriggerEventListener { |
Adrian Roos | 7294c11 | 2016-09-20 14:03:21 -0700 | [diff] [blame] | 459 | final Sensor mSensor; |
| 460 | final boolean mConfigured; |
| 461 | final boolean mDebugVibrate; |
| 462 | final int mPulseReason; |
| 463 | final String mSetting; |
John Spurlock | 559d959 | 2014-08-09 12:04:36 -0400 | [diff] [blame] | 464 | |
John Spurlock | 92b8d41 | 2014-10-03 17:12:40 -0400 | [diff] [blame] | 465 | private boolean mRequested; |
| 466 | private boolean mRegistered; |
| 467 | private boolean mDisabled; |
John Spurlock | 559d959 | 2014-08-09 12:04:36 -0400 | [diff] [blame] | 468 | |
Adrian Roos | 7294c11 | 2016-09-20 14:03:21 -0700 | [diff] [blame] | 469 | public TriggerSensor(Sensor sensor, String setting, boolean configured, |
| 470 | boolean debugVibrate, int pulseReason) { |
| 471 | mSensor = sensor; |
| 472 | mSetting = setting; |
John Spurlock | 190d026 | 2014-09-14 15:39:13 -0400 | [diff] [blame] | 473 | mConfigured = configured; |
| 474 | mDebugVibrate = debugVibrate; |
John Spurlock | eab28e6 | 2014-11-29 11:33:49 -0500 | [diff] [blame] | 475 | mPulseReason = pulseReason; |
John Spurlock | 559d959 | 2014-08-09 12:04:36 -0400 | [diff] [blame] | 476 | } |
| 477 | |
| 478 | public void setListening(boolean listen) { |
John Spurlock | 92b8d41 | 2014-10-03 17:12:40 -0400 | [diff] [blame] | 479 | if (mRequested == listen) return; |
| 480 | mRequested = listen; |
| 481 | updateListener(); |
| 482 | } |
| 483 | |
| 484 | public void setDisabled(boolean disabled) { |
| 485 | if (mDisabled == disabled) return; |
| 486 | mDisabled = disabled; |
| 487 | updateListener(); |
| 488 | } |
| 489 | |
Adrian Roos | 7294c11 | 2016-09-20 14:03:21 -0700 | [diff] [blame] | 490 | public void updateListener() { |
John Spurlock | 559d959 | 2014-08-09 12:04:36 -0400 | [diff] [blame] | 491 | if (!mConfigured || mSensor == null) return; |
Adrian Roos | 7294c11 | 2016-09-20 14:03:21 -0700 | [diff] [blame] | 492 | if (mRequested && !mDisabled && enabledBySetting() && !mRegistered) { |
| 493 | mRegistered = mSensorManager.requestTriggerSensor(this, mSensor); |
John Spurlock | 7850373 | 2014-11-10 09:41:41 -0500 | [diff] [blame] | 494 | if (DEBUG) Log.d(mTag, "requestTriggerSensor " + mRegistered); |
John Spurlock | 92b8d41 | 2014-10-03 17:12:40 -0400 | [diff] [blame] | 495 | } else if (mRegistered) { |
Adrian Roos | 7294c11 | 2016-09-20 14:03:21 -0700 | [diff] [blame] | 496 | final boolean rt = mSensorManager.cancelTriggerSensor(this, mSensor); |
John Spurlock | 7850373 | 2014-11-10 09:41:41 -0500 | [diff] [blame] | 497 | if (DEBUG) Log.d(mTag, "cancelTriggerSensor " + rt); |
John Spurlock | 92b8d41 | 2014-10-03 17:12:40 -0400 | [diff] [blame] | 498 | mRegistered = false; |
John Spurlock | 559d959 | 2014-08-09 12:04:36 -0400 | [diff] [blame] | 499 | } |
| 500 | } |
| 501 | |
Adrian Roos | 7294c11 | 2016-09-20 14:03:21 -0700 | [diff] [blame] | 502 | private boolean enabledBySetting() { |
| 503 | if (TextUtils.isEmpty(mSetting)) { |
| 504 | return true; |
| 505 | } |
| 506 | return Settings.Secure.getIntForUser(mContext.getContentResolver(), mSetting, 1, |
| 507 | UserHandle.USER_CURRENT) != 0; |
| 508 | } |
| 509 | |
John Spurlock | 559d959 | 2014-08-09 12:04:36 -0400 | [diff] [blame] | 510 | @Override |
| 511 | public String toString() { |
John Spurlock | 92b8d41 | 2014-10-03 17:12:40 -0400 | [diff] [blame] | 512 | return new StringBuilder("{mRegistered=").append(mRegistered) |
| 513 | .append(", mRequested=").append(mRequested) |
| 514 | .append(", mDisabled=").append(mDisabled) |
| 515 | .append(", mConfigured=").append(mConfigured) |
| 516 | .append(", mDebugVibrate=").append(mDebugVibrate) |
John Spurlock | 190d026 | 2014-09-14 15:39:13 -0400 | [diff] [blame] | 517 | .append(", mSensor=").append(mSensor).append("}").toString(); |
John Spurlock | 559d959 | 2014-08-09 12:04:36 -0400 | [diff] [blame] | 518 | } |
| 519 | |
| 520 | @Override |
| 521 | public void onTrigger(TriggerEvent event) { |
Jeff Brown | 4d69e22 | 2014-09-18 15:27:50 -0700 | [diff] [blame] | 522 | mWakeLock.acquire(); |
| 523 | try { |
| 524 | if (DEBUG) Log.d(mTag, "onTrigger: " + triggerEventToString(event)); |
Adrian Roos | 5753f05 | 2016-07-13 10:30:37 -0700 | [diff] [blame] | 525 | boolean sensorPerformsProxCheck = false; |
Bhavik Singh | 3451da4 | 2016-06-01 18:25:59 -0700 | [diff] [blame] | 526 | if (mSensor.getType() == Sensor.TYPE_PICK_UP_GESTURE) { |
| 527 | int subType = (int) event.values[0]; |
| 528 | MetricsLogger.action(mContext, MetricsEvent.ACTION_AMBIENT_GESTURE, subType); |
Adrian Roos | 5753f05 | 2016-07-13 10:30:37 -0700 | [diff] [blame] | 529 | sensorPerformsProxCheck = mDozeParameters.getPickupSubtypePerformsProxCheck( |
| 530 | subType); |
Bhavik Singh | 3451da4 | 2016-06-01 18:25:59 -0700 | [diff] [blame] | 531 | } |
Jeff Brown | 4d69e22 | 2014-09-18 15:27:50 -0700 | [diff] [blame] | 532 | if (mDebugVibrate) { |
| 533 | final Vibrator v = (Vibrator) mContext.getSystemService( |
| 534 | Context.VIBRATOR_SERVICE); |
| 535 | if (v != null) { |
| 536 | v.vibrate(1000, new AudioAttributes.Builder() |
| 537 | .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION) |
| 538 | .setUsage(AudioAttributes.USAGE_ASSISTANCE_SONIFICATION).build()); |
| 539 | } |
John Spurlock | 559d959 | 2014-08-09 12:04:36 -0400 | [diff] [blame] | 540 | } |
John Spurlock | 50a8ea6 | 2014-09-16 09:12:03 -0400 | [diff] [blame] | 541 | |
John Spurlock | 7850373 | 2014-11-10 09:41:41 -0500 | [diff] [blame] | 542 | mRegistered = false; |
Adrian Roos | 5753f05 | 2016-07-13 10:30:37 -0700 | [diff] [blame] | 543 | requestPulse(mPulseReason, sensorPerformsProxCheck); |
John Spurlock | 7850373 | 2014-11-10 09:41:41 -0500 | [diff] [blame] | 544 | updateListener(); // reregister, this sensor only fires once |
Jeff Brown | 4d69e22 | 2014-09-18 15:27:50 -0700 | [diff] [blame] | 545 | |
Adrian Roos | d13602f | 2016-08-22 15:31:38 +0200 | [diff] [blame] | 546 | // record pickup gesture, also keep track of whether we might have been triggered |
| 547 | // by recent vibration. |
| 548 | final long timeSinceNotification = SystemClock.elapsedRealtime() |
John Spurlock | 92b8d41 | 2014-10-03 17:12:40 -0400 | [diff] [blame] | 549 | - mNotificationPulseTime; |
Jeff Brown | 4d69e22 | 2014-09-18 15:27:50 -0700 | [diff] [blame] | 550 | final boolean withinVibrationThreshold = |
| 551 | timeSinceNotification < mDozeParameters.getPickupVibrationThreshold(); |
Jeff Brown | 4d69e22 | 2014-09-18 15:27:50 -0700 | [diff] [blame] | 552 | if (mSensor.getType() == Sensor.TYPE_PICK_UP_GESTURE) { |
Adrian Roos | 23c14fc | 2016-07-28 12:32:41 -0700 | [diff] [blame] | 553 | DozeLog.tracePickupPulse(mContext, withinVibrationThreshold); |
Jeff Brown | 4d69e22 | 2014-09-18 15:27:50 -0700 | [diff] [blame] | 554 | } |
| 555 | } finally { |
| 556 | mWakeLock.release(); |
John Spurlock | 813552c | 2014-09-19 08:30:21 -0400 | [diff] [blame] | 557 | } |
John Spurlock | 559d959 | 2014-08-09 12:04:36 -0400 | [diff] [blame] | 558 | } |
| 559 | } |
John Spurlock | 92b8d41 | 2014-10-03 17:12:40 -0400 | [diff] [blame] | 560 | |
| 561 | private abstract class ProximityCheck implements SensorEventListener, Runnable { |
| 562 | private static final int TIMEOUT_DELAY_MS = 500; |
| 563 | |
| 564 | protected static final int RESULT_UNKNOWN = 0; |
| 565 | protected static final int RESULT_NEAR = 1; |
| 566 | protected static final int RESULT_FAR = 2; |
| 567 | |
| 568 | private final String mTag = DozeService.this.mTag + ".ProximityCheck"; |
| 569 | |
| 570 | private boolean mRegistered; |
| 571 | private boolean mFinished; |
| 572 | private float mMaxRange; |
| 573 | |
| 574 | abstract public void onProximityResult(int result); |
| 575 | |
| 576 | public void check() { |
| 577 | if (mFinished || mRegistered) return; |
Adrian Roos | 7294c11 | 2016-09-20 14:03:21 -0700 | [diff] [blame] | 578 | final Sensor sensor = mSensorManager.getDefaultSensor(Sensor.TYPE_PROXIMITY); |
John Spurlock | 92b8d41 | 2014-10-03 17:12:40 -0400 | [diff] [blame] | 579 | if (sensor == null) { |
| 580 | if (DEBUG) Log.d(mTag, "No sensor found"); |
| 581 | finishWithResult(RESULT_UNKNOWN); |
| 582 | return; |
| 583 | } |
| 584 | // the pickup sensor interferes with the prox event, disable it until we have a result |
| 585 | mPickupSensor.setDisabled(true); |
| 586 | |
| 587 | mMaxRange = sensor.getMaximumRange(); |
Adrian Roos | 7294c11 | 2016-09-20 14:03:21 -0700 | [diff] [blame] | 588 | mSensorManager.registerListener(this, sensor, SensorManager.SENSOR_DELAY_NORMAL, 0, |
| 589 | mHandler); |
John Spurlock | 92b8d41 | 2014-10-03 17:12:40 -0400 | [diff] [blame] | 590 | mHandler.postDelayed(this, TIMEOUT_DELAY_MS); |
| 591 | mRegistered = true; |
| 592 | } |
| 593 | |
| 594 | @Override |
| 595 | public void onSensorChanged(SensorEvent event) { |
| 596 | if (event.values.length == 0) { |
| 597 | if (DEBUG) Log.d(mTag, "Event has no values!"); |
| 598 | finishWithResult(RESULT_UNKNOWN); |
| 599 | } else { |
| 600 | if (DEBUG) Log.d(mTag, "Event: value=" + event.values[0] + " max=" + mMaxRange); |
| 601 | final boolean isNear = event.values[0] < mMaxRange; |
| 602 | finishWithResult(isNear ? RESULT_NEAR : RESULT_FAR); |
| 603 | } |
| 604 | } |
| 605 | |
| 606 | @Override |
| 607 | public void run() { |
| 608 | if (DEBUG) Log.d(mTag, "No event received before timeout"); |
| 609 | finishWithResult(RESULT_UNKNOWN); |
| 610 | } |
| 611 | |
| 612 | private void finishWithResult(int result) { |
| 613 | if (mFinished) return; |
| 614 | if (mRegistered) { |
| 615 | mHandler.removeCallbacks(this); |
Adrian Roos | 7294c11 | 2016-09-20 14:03:21 -0700 | [diff] [blame] | 616 | mSensorManager.unregisterListener(this); |
John Spurlock | 92b8d41 | 2014-10-03 17:12:40 -0400 | [diff] [blame] | 617 | // we're done - reenable the pickup sensor |
| 618 | mPickupSensor.setDisabled(false); |
| 619 | mRegistered = false; |
| 620 | } |
| 621 | onProximityResult(result); |
| 622 | mFinished = true; |
| 623 | } |
| 624 | |
| 625 | @Override |
| 626 | public void onAccuracyChanged(Sensor sensor, int accuracy) { |
| 627 | // noop |
| 628 | } |
| 629 | } |
John Spurlock | bf37099 | 2014-06-17 13:58:31 -0400 | [diff] [blame] | 630 | } |