Merge changes Ifa407b84,Iff84c019 into oc-dr1-dev (cecb9d81) · Commits · e / os / android_frameworks_base

packages/SystemUI/src/com/android/systemui/doze/DozeFactory.java

+6 −5

Original line number	Diff line number	Diff line
		@@ -52,8 +52,9 @@ public class DozeFactory {
		config,
		wakeLock);
		machine.setParts(new DozeMachine.Part[]{
		createDozeTriggers(context, sensorManager, host, config, params, handler, wakeLock,
		machine),
		new DozePauser(handler, machine, alarmManager),
		createDozeTriggers(context, sensorManager, host, alarmManager, config, params,
		handler, wakeLock, machine),
		createDozeUi(context, host, wakeLock, machine, handler, alarmManager),
		});

		@@ -61,10 +62,10 @@ public class DozeFactory {
		}

		private DozeTriggers createDozeTriggers(Context context, SensorManager sensorManager,
		DozeHost host, AmbientDisplayConfiguration config, DozeParameters params,
		Handler handler, WakeLock wakeLock, DozeMachine machine) {
		DozeHost host, AlarmManager alarmManager, AmbientDisplayConfiguration config,
		DozeParameters params, Handler handler, WakeLock wakeLock, DozeMachine machine) {
		boolean allowPulseTriggers = true;
		return new DozeTriggers(context, machine, host, config, params,
		return new DozeTriggers(context, machine, host, alarmManager, config, params,
		sensorManager, handler, wakeLock, allowPulseTriggers);
		}

packages/SystemUI/src/com/android/systemui/doze/DozeMachine.java

+7 −2

Original line number	Diff line number	Diff line
		@@ -60,13 +60,16 @@ public class DozeMachine {
		/** Doze is done. DozeService is finished. */
		FINISH,
		/** AOD, but the display is temporarily off. */
		DOZE_AOD_PAUSED;
		DOZE_AOD_PAUSED,
		/** AOD, prox is near, transitions to DOZE_AOD_PAUSED after a timeout. */
		DOZE_AOD_PAUSING;

		boolean canPulse() {
		switch (this) {
		case DOZE:
		case DOZE_AOD:
		case DOZE_AOD_PAUSED:
		case DOZE_AOD_PAUSING:
		return true;
		default:
		return false;
		@@ -93,6 +96,7 @@ public class DozeMachine {
		case DOZE_PULSING:
		return Display.STATE_ON;
		case DOZE_AOD:
		case DOZE_AOD_PAUSING:
		return Display.STATE_DOZE_SUSPEND;
		default:
		return Display.STATE_UNKNOWN;
		@@ -284,7 +288,8 @@ public class DozeMachine {
		if (mState == State.FINISH) {
		return State.FINISH;
		}
		if ((mState == State.DOZE_AOD_PAUSED \|\| mState == State.DOZE_AOD \|\| mState == State.DOZE)
		if ((mState == State.DOZE_AOD_PAUSED \|\| mState == State.DOZE_AOD_PAUSING
		\|\| mState == State.DOZE_AOD \|\| mState == State.DOZE)
		&& requestedState == State.DOZE_PULSE_DONE) {
		Log.i(TAG, "Dropping pulse done because current state is already done: " + mState);
		return mState;

packages/SystemUI/src/com/android/systemui/doze/DozePauser.java

0 → 100644

+53 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2017 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License
		*/

		package com.android.systemui.doze;

		import android.app.AlarmManager;
		import android.os.Handler;

		import com.android.systemui.util.AlarmTimeout;

		/**
		* Moves the doze machine from the pausing to the paused state after a timeout.
		*/
		public class DozePauser implements DozeMachine.Part {
		public static final String TAG = DozePauser.class.getSimpleName();
		private static final long TIMEOUT = 10 * 1000;
		private final AlarmTimeout mPauseTimeout;
		private final DozeMachine mMachine;

		public DozePauser(Handler handler, DozeMachine machine, AlarmManager alarmManager) {
		mMachine = machine;
		mPauseTimeout = new AlarmTimeout(alarmManager, this::onTimeout, TAG, handler);
		}

		@Override
		public void transitionTo(DozeMachine.State oldState, DozeMachine.State newState) {
		switch (newState) {
		case DOZE_AOD_PAUSING:
		mPauseTimeout.schedule(TIMEOUT, AlarmTimeout.MODE_IGNORE_IF_SCHEDULED);
		break;
		default:
		mPauseTimeout.cancel();
		break;
		}
		}

		private void onTimeout() {
		mMachine.requestState(DozeMachine.State.DOZE_AOD_PAUSED);
		}
		}

packages/SystemUI/src/com/android/systemui/doze/DozeSensors.java

+45 −4

Original line number	Diff line number	Diff line
		@@ -18,6 +18,7 @@ package com.android.systemui.doze;

		import android.annotation.AnyThread;
		import android.app.ActivityManager;
		import android.app.AlarmManager;
		import android.content.ContentResolver;
		import android.content.Context;
		import android.database.ContentObserver;
		@@ -29,6 +30,7 @@ import android.hardware.TriggerEvent;
		import android.hardware.TriggerEventListener;
		import android.net.Uri;
		import android.os.Handler;
		import android.os.SystemClock;
		import android.os.UserHandle;
		import android.provider.Settings;
		import android.text.TextUtils;
		@@ -38,6 +40,7 @@ import com.android.internal.hardware.AmbientDisplayConfiguration;
		import com.android.internal.logging.MetricsLogger;
		import com.android.internal.logging.nano.MetricsProto;
		import com.android.systemui.statusbar.phone.DozeParameters;
		import com.android.systemui.util.AlarmTimeout;
		import com.android.systemui.util.wakelock.WakeLock;

		import java.io.PrintWriter;
		@@ -51,6 +54,7 @@ public class DozeSensors {
		private static final String TAG = "DozeSensors";

		private final Context mContext;
		private final AlarmManager mAlarmManager;
		private final SensorManager mSensorManager;
		private final TriggerSensor[] mSensors;
		private final ContentResolver mResolver;
		@@ -65,10 +69,12 @@ public class DozeSensors {
		private final ProxSensor mProxSensor;


		public DozeSensors(Context context, SensorManager sensorManager, DozeParameters dozeParameters,
		public DozeSensors(Context context, AlarmManager alarmManager, SensorManager sensorManager,
		DozeParameters dozeParameters,
		AmbientDisplayConfiguration config, WakeLock wakeLock, Callback callback,
		Consumer<Boolean> proxCallback) {
		mContext = context;
		mAlarmManager = alarmManager;
		mSensorManager = sensorManager;
		mDozeParameters = dozeParameters;
		mConfig = config;
		@@ -140,7 +146,7 @@ public class DozeSensors {
		}

		public void setProxListening(boolean listen) {
		mProxSensor.setRegistered(listen);
		mProxSensor.setRequested(listen);
		}

		private final ContentObserver mSettingsObserver = new ContentObserver(mHandler) {
		@@ -168,11 +174,23 @@ public class DozeSensors {

		private class ProxSensor implements SensorEventListener {

		static final long COOLDOWN_TRIGGER = 2 * 1000;
		static final long COOLDOWN_PERIOD = 5 * 1000;

		boolean mRequested;
		boolean mRegistered;
		Boolean mCurrentlyFar;
		long mLastNear;
		final AlarmTimeout mCooldownTimer;

		void setRegistered(boolean register) {
		if (mRegistered == register) {

		public ProxSensor() {
		mCooldownTimer = new AlarmTimeout(mAlarmManager, this::updateRegistered,
		"prox_cooldown", mHandler);
		}

		void setRequested(boolean requested) {
		if (mRequested == requested) {
		// Send an update even if we don't re-register.
		mHandler.post(() -> {
		if (mCurrentlyFar != null) {
		@@ -181,6 +199,18 @@ public class DozeSensors {
		});
		return;
		}
		mRequested = requested;
		updateRegistered();
		}

		private void updateRegistered() {
		setRegistered(mRequested && !mCooldownTimer.isScheduled());
		}

		private void setRegistered(boolean register) {
		if (mRegistered == register) {
		return;
		}
		if (register) {
		mRegistered = mSensorManager.registerListener(this,
		mSensorManager.getDefaultSensor(Sensor.TYPE_PROXIMITY),
		@@ -196,6 +226,17 @@ public class DozeSensors {
		public void onSensorChanged(SensorEvent event) {
		mCurrentlyFar = event.values[0] >= event.sensor.getMaximumRange();
		mProxCallback.accept(mCurrentlyFar);

		long now = SystemClock.elapsedRealtime();
		if (!mCurrentlyFar) {
		mLastNear = now;
		} else if (mCurrentlyFar && now - mLastNear < COOLDOWN_TRIGGER) {
		// If the last near was very recent, we might be using more power for prox
		// wakeups than we're saving from turning of the screen. Instead, turn it off
		// for a while.
		mCooldownTimer.schedule(COOLDOWN_PERIOD, AlarmTimeout.MODE_IGNORE_IF_SCHEDULED);
		updateRegistered();
		}
		}

		@Override

packages/SystemUI/src/com/android/systemui/doze/DozeTriggers.java

+13 −7

Original line number	Diff line number	Diff line
		@@ -16,6 +16,7 @@

		package com.android.systemui.doze;

		import android.app.AlarmManager;
		import android.app.UiModeManager;
		import android.content.BroadcastReceiver;
		import android.content.Context;
		@@ -70,7 +71,7 @@ public class DozeTriggers implements DozeMachine.Part {


		public DozeTriggers(Context context, DozeMachine machine, DozeHost dozeHost,
		AmbientDisplayConfiguration config,
		AlarmManager alarmManager, AmbientDisplayConfiguration config,
		DozeParameters dozeParameters, SensorManager sensorManager, Handler handler,
		WakeLock wakeLock, boolean allowPulseTriggers) {
		mContext = context;
		@@ -82,8 +83,8 @@ public class DozeTriggers implements DozeMachine.Part {
		mHandler = handler;
		mWakeLock = wakeLock;
		mAllowPulseTriggers = allowPulseTriggers;
		mDozeSensors = new DozeSensors(context, mSensorManager, dozeParameters, config,
		wakeLock, this::onSensor, this::onProximityFar);
		mDozeSensors = new DozeSensors(context, alarmManager, mSensorManager, dozeParameters,
		config, wakeLock, this::onSensor, this::onProximityFar);
		mUiModeManager = mContext.getSystemService(UiModeManager.class);
		}

		@@ -152,18 +153,22 @@ public class DozeTriggers implements DozeMachine.Part {

		private void onProximityFar(boolean far) {
		final boolean near = !far;
		DozeMachine.State state = mMachine.getState();
		final DozeMachine.State state = mMachine.getState();
		final boolean paused = (state == DozeMachine.State.DOZE_AOD_PAUSED);
		final boolean pausing = (state == DozeMachine.State.DOZE_AOD_PAUSING);
		final boolean aod = (state == DozeMachine.State.DOZE_AOD);

		if (near && state == DozeMachine.State.DOZE_PULSING) {
		if (DEBUG) Log.i(TAG, "Prox NEAR, ending pulse");
		DozeLog.tracePulseCanceledByProx(mContext);
		mMachine.requestState(DozeMachine.State.DOZE_PULSE_DONE);
		}
		if (far && state == DozeMachine.State.DOZE_AOD_PAUSED) {
		if (far && (paused \|\| pausing)) {
		if (DEBUG) Log.i(TAG, "Prox FAR, unpausing AOD");
		mMachine.requestState(DozeMachine.State.DOZE_AOD);
		} else if (near && state == DozeMachine.State.DOZE_AOD) {
		} else if (near && aod) {
		if (DEBUG) Log.i(TAG, "Prox NEAR, pausing AOD");
		mMachine.requestState(DozeMachine.State.DOZE_AOD_PAUSED);
		mMachine.requestState(DozeMachine.State.DOZE_AOD_PAUSING);
		}
		}

		@@ -192,6 +197,7 @@ public class DozeTriggers implements DozeMachine.Part {
		}
		break;
		case DOZE_AOD_PAUSED:
		case DOZE_AOD_PAUSING:
		mDozeSensors.setProxListening(true);
		mDozeSensors.setListening(false);
		break;