Merge "SoundTrigger DeviceState" into udc-dev am: 8e471cfef6 (c985091a) · Commits · e / os / android_frameworks_base

services/tests/voiceinteractiontests/src/com/android/server/soundtrigger/DeviceStateHandlerTest.java

0 → 100644

+261 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2023 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.server.soundtrigger;

		import static android.os.PowerManager.SOUND_TRIGGER_MODE_ALL_DISABLED;
		import static android.os.PowerManager.SOUND_TRIGGER_MODE_ALL_ENABLED;
		import static android.os.PowerManager.SOUND_TRIGGER_MODE_CRITICAL_ONLY;

		import static com.android.server.soundtrigger.DeviceStateHandler.SoundTriggerDeviceState;
		import static com.android.server.soundtrigger.DeviceStateHandler.SoundTriggerDeviceState.*;

		import static com.google.common.truth.Truth.assertThat;

		import android.os.SystemClock;

		import androidx.test.filters.FlakyTest;
		import androidx.test.runner.AndroidJUnit4;

		import com.android.internal.annotations.GuardedBy;
		import com.android.server.utils.EventLogger;

		import org.junit.Before;
		import org.junit.Test;
		import org.junit.runner.RunWith;

		import java.util.concurrent.CountDownLatch;
		import java.util.concurrent.TimeUnit;

		@RunWith(AndroidJUnit4.class)
		public final class DeviceStateHandlerTest {
		private final long CONFIRM_NO_EVENT_WAIT_MS = 1000;
		// A wait substantially less than the duration we delay phone notifications by
		private final long PHONE_DELAY_BRIEF_WAIT_MS =
		DeviceStateHandler.CALL_INACTIVE_MSG_DELAY_MS / 4;

		private DeviceStateHandler mHandler;
		private DeviceStateHandler.DeviceStateListener mDeviceStateCallback;

		private final Object mLock = new Object();

		@GuardedBy("mLock")
		private SoundTriggerDeviceState mState;

		@GuardedBy("mLock")
		private CountDownLatch mLatch;

		private EventLogger mEventLogger;

		@Before
		public void setup() {
		// Reset the state prior to each test
		mEventLogger = new EventLogger(256, "test logger");
		synchronized (mLock) {
		mLatch = new CountDownLatch(1);
		}
		mDeviceStateCallback =
		(SoundTriggerDeviceState state) -> {
		synchronized (mLock) {
		mState = state;
		mLatch.countDown();
		}
		};
		mHandler = new DeviceStateHandler(Runnable::run, mEventLogger);
		mHandler.onPhoneCallStateChanged(false);
		mHandler.onPowerModeChanged(SOUND_TRIGGER_MODE_ALL_ENABLED);
		mHandler.registerListener(mDeviceStateCallback);
		try {
		waitAndAssertState(ENABLE);
		} catch (InterruptedException e) {
		throw new RuntimeException(e);
		}
		}

		private void waitAndAssertState(SoundTriggerDeviceState state) throws InterruptedException {
		CountDownLatch latch;
		synchronized (mLock) {
		latch = mLatch;
		}
		latch.await();
		synchronized (mLock) {
		assertThat(mState).isEqualTo(state);
		mLatch = new CountDownLatch(1);
		}
		}

		private void waitToConfirmNoEventReceived() throws InterruptedException {
		CountDownLatch latch;
		synchronized (mLock) {
		latch = mLatch;
		}
		// Check that we time out
		assertThat(latch.await(CONFIRM_NO_EVENT_WAIT_MS, TimeUnit.MILLISECONDS)).isFalse();
		}

		@Test
		public void onPowerModeChangedCritical_receiveStateChange() throws Exception {
		mHandler.onPowerModeChanged(SOUND_TRIGGER_MODE_CRITICAL_ONLY);
		waitAndAssertState(CRITICAL);
		mHandler.onPowerModeChanged(SOUND_TRIGGER_MODE_ALL_ENABLED);
		waitAndAssertState(ENABLE);
		}

		@Test
		public void onPowerModeChangedDisabled_receiveStateChange() throws Exception {
		mHandler.onPowerModeChanged(SOUND_TRIGGER_MODE_ALL_DISABLED);
		waitAndAssertState(DISABLE);
		mHandler.onPowerModeChanged(SOUND_TRIGGER_MODE_ALL_ENABLED);
		waitAndAssertState(ENABLE);
		}

		@Test
		public void onPowerModeChangedMultiple_receiveStateChange() throws Exception {
		mHandler.onPowerModeChanged(SOUND_TRIGGER_MODE_ALL_DISABLED);
		waitAndAssertState(DISABLE);
		mHandler.onPowerModeChanged(SOUND_TRIGGER_MODE_CRITICAL_ONLY);
		waitAndAssertState(CRITICAL);
		mHandler.onPowerModeChanged(SOUND_TRIGGER_MODE_ALL_DISABLED);
		waitAndAssertState(DISABLE);
		}

		@Test
		public void onPowerModeSameState_noStateChange() throws Exception {
		mHandler.onPowerModeChanged(SOUND_TRIGGER_MODE_ALL_DISABLED);
		waitAndAssertState(DISABLE);
		mHandler.onPowerModeChanged(SOUND_TRIGGER_MODE_ALL_DISABLED);
		waitToConfirmNoEventReceived();
		mHandler.onPowerModeChanged(SOUND_TRIGGER_MODE_CRITICAL_ONLY);
		waitAndAssertState(CRITICAL);
		mHandler.onPowerModeChanged(SOUND_TRIGGER_MODE_CRITICAL_ONLY);
		waitToConfirmNoEventReceived();
		mHandler.onPowerModeChanged(SOUND_TRIGGER_MODE_ALL_ENABLED);
		waitAndAssertState(ENABLE);
		mHandler.onPowerModeChanged(SOUND_TRIGGER_MODE_ALL_ENABLED);
		waitToConfirmNoEventReceived();
		}

		@Test
		public void onPhoneCall_receiveStateChange() throws Exception {
		mHandler.onPhoneCallStateChanged(true);
		waitAndAssertState(DISABLE);
		mHandler.onPhoneCallStateChanged(false);
		waitAndAssertState(ENABLE);
		}

		@Test
		public void onPhoneCall_receiveStateChangeIsDelayed() throws Exception {
		mHandler.onPhoneCallStateChanged(true);
		waitAndAssertState(DISABLE);
		long beforeTime = SystemClock.uptimeMillis();
		mHandler.onPhoneCallStateChanged(false);
		waitAndAssertState(ENABLE);
		long afterTime = SystemClock.uptimeMillis();
		assertThat(afterTime - beforeTime).isAtLeast(DeviceStateHandler.CALL_INACTIVE_MSG_DELAY_MS);
		}

		@Test
		public void onPhoneCallEnterExitEnter_receiveNoStateChange() throws Exception {
		mHandler.onPhoneCallStateChanged(true);
		waitAndAssertState(DISABLE);
		mHandler.onPhoneCallStateChanged(false);
		SystemClock.sleep(PHONE_DELAY_BRIEF_WAIT_MS);
		mHandler.onPhoneCallStateChanged(true);
		waitToConfirmNoEventReceived();
		}

		@Test
		public void onBatteryCallbackDuringPhoneWait_receiveStateChangeDelayed() throws Exception {
		mHandler.onPhoneCallStateChanged(true);
		waitAndAssertState(DISABLE);
		mHandler.onPhoneCallStateChanged(false);
		SystemClock.sleep(PHONE_DELAY_BRIEF_WAIT_MS);
		mHandler.onPowerModeChanged(SOUND_TRIGGER_MODE_CRITICAL_ONLY);
		waitAndAssertState(CRITICAL);
		// Ensure we don't get an ENABLE event after
		waitToConfirmNoEventReceived();
		}

		@Test
		public void onBatteryChangeWhenInPhoneCall_receiveNoStateChange() throws Exception {
		mHandler.onPhoneCallStateChanged(true);
		waitAndAssertState(DISABLE);
		mHandler.onPowerModeChanged(SOUND_TRIGGER_MODE_ALL_ENABLED);
		waitToConfirmNoEventReceived();
		mHandler.onPowerModeChanged(SOUND_TRIGGER_MODE_CRITICAL_ONLY);
		waitToConfirmNoEventReceived();
		}

		@Test
		public void whenBatteryCriticalChangeDuringCallAfterPhoneCall_receiveCriticalStateChange()
		throws Exception {
		mHandler.onPhoneCallStateChanged(true);
		waitAndAssertState(DISABLE);
		mHandler.onPowerModeChanged(SOUND_TRIGGER_MODE_CRITICAL_ONLY);
		waitToConfirmNoEventReceived();
		mHandler.onPhoneCallStateChanged(false);
		waitAndAssertState(CRITICAL);
		}

		@Test
		public void whenBatteryDisableDuringCallAfterPhoneCallBatteryEnable_receiveStateChange()
		throws Exception {
		mHandler.onPhoneCallStateChanged(true);
		waitAndAssertState(DISABLE);
		mHandler.onPowerModeChanged(SOUND_TRIGGER_MODE_ALL_DISABLED);
		waitToConfirmNoEventReceived();
		mHandler.onPhoneCallStateChanged(false);
		waitToConfirmNoEventReceived();
		mHandler.onPowerModeChanged(SOUND_TRIGGER_MODE_CRITICAL_ONLY);
		waitAndAssertState(CRITICAL);
		}

		@Test
		public void whenPhoneCallDuringBatteryDisable_receiveNoStateChange() throws Exception {
		mHandler.onPowerModeChanged(SOUND_TRIGGER_MODE_ALL_DISABLED);
		waitAndAssertState(DISABLE);
		mHandler.onPhoneCallStateChanged(true);
		waitToConfirmNoEventReceived();
		mHandler.onPhoneCallStateChanged(false);
		waitToConfirmNoEventReceived();
		}

		@Test
		public void whenPhoneCallDuringBatteryCritical_receiveStateChange() throws Exception {
		mHandler.onPowerModeChanged(SOUND_TRIGGER_MODE_CRITICAL_ONLY);
		waitAndAssertState(CRITICAL);
		mHandler.onPhoneCallStateChanged(true);
		waitAndAssertState(DISABLE);
		mHandler.onPhoneCallStateChanged(false);
		waitAndAssertState(CRITICAL);
		}

		// This test could be flaky, but we want to verify that we only delay notification if
		// we are exiting a call, NOT if we are entering a call.
		@FlakyTest
		@Test
		public void whenPhoneCallReceived_receiveStateChangeFast() throws Exception {
		mHandler.onPhoneCallStateChanged(true);
		CountDownLatch latch;
		synchronized (mLock) {
		latch = mLatch;
		}
		assertThat(latch.await(PHONE_DELAY_BRIEF_WAIT_MS, TimeUnit.MILLISECONDS)).isTrue();
		synchronized (mLock) {
		assertThat(mState).isEqualTo(DISABLE);
		}
		}
		}

services/voiceinteraction/java/com/android/server/soundtrigger/DeviceStateHandler.java

0 → 100644

+279 −0

Original line number	Diff line number	Diff line
		/**
		* Copyright (C) 2023 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.server.soundtrigger;

		import static android.os.PowerManager.SOUND_TRIGGER_MODE_ALL_DISABLED;
		import static android.os.PowerManager.SOUND_TRIGGER_MODE_ALL_ENABLED;
		import static android.os.PowerManager.SOUND_TRIGGER_MODE_CRITICAL_ONLY;

		import com.android.internal.annotations.GuardedBy;
		import com.android.server.utils.EventLogger;

		import java.io.PrintWriter;
		import java.util.HashSet;
		import java.util.Objects;
		import java.util.Set;
		import java.util.concurrent.ConcurrentHashMap;
		import java.util.concurrent.CountDownLatch;
		import java.util.concurrent.Executor;
		import java.util.concurrent.Executors;
		import java.util.concurrent.TimeUnit;

		/**
		* Manages device state events which require pausing SoundTrigger recognition
		*
		* @hide
		*/
		public class DeviceStateHandler implements PhoneCallStateHandler.Callback {

		public static final long CALL_INACTIVE_MSG_DELAY_MS = 1000;

		public interface DeviceStateListener {
		void onSoundTriggerDeviceStateUpdate(SoundTriggerDeviceState state);
		}

		public enum SoundTriggerDeviceState {
		DISABLE, // The device state requires all SoundTrigger sessions are disabled
		CRITICAL, // The device state requires all non-critical SoundTrigger sessions are disabled
		ENABLE // The device state permits all SoundTrigger sessions
		}

		private final Object mLock = new Object();

		private final EventLogger mEventLogger;

		@GuardedBy("mLock")
		SoundTriggerDeviceState mSoundTriggerDeviceState = SoundTriggerDeviceState.ENABLE;

		// Individual components of the SoundTriggerDeviceState
		@GuardedBy("mLock")
		private int mSoundTriggerPowerSaveMode = SOUND_TRIGGER_MODE_ALL_ENABLED;

		@GuardedBy("mLock")
		private boolean mIsPhoneCallOngoing = false;

		// There can only be one pending notify at any given time.
		// If any phone state change comes in between, we will cancel the previous pending
		// task.
		@GuardedBy("mLock")
		private NotificationTask mPhoneStateChangePendingNotify = null;

		private Set<DeviceStateListener> mCallbackSet = ConcurrentHashMap.newKeySet(4);

		private final Executor mDelayedNotificationExecutor = Executors.newSingleThreadExecutor();

		private final Executor mCallbackExecutor;

		public void onPowerModeChanged(int soundTriggerPowerSaveMode) {
		mEventLogger.enqueue(new SoundTriggerPowerEvent(soundTriggerPowerSaveMode));
		synchronized (mLock) {
		if (soundTriggerPowerSaveMode == mSoundTriggerPowerSaveMode) {
		// No state change, nothing to do
		return;
		}
		mSoundTriggerPowerSaveMode = soundTriggerPowerSaveMode;
		evaluateStateChange();
		}
		}

		@Override
		public void onPhoneCallStateChanged(boolean isInPhoneCall) {
		mEventLogger.enqueue(new PhoneCallEvent(isInPhoneCall));
		synchronized (mLock) {
		if (mIsPhoneCallOngoing == isInPhoneCall) {
		// no change, nothing to do
		return;
		}
		// Clear any pending notification
		if (mPhoneStateChangePendingNotify != null) {
		mPhoneStateChangePendingNotify.cancel();
		mPhoneStateChangePendingNotify = null;
		}
		mIsPhoneCallOngoing = isInPhoneCall;
		if (!mIsPhoneCallOngoing) {
		// State has changed from call to no call, delay notification
		mPhoneStateChangePendingNotify = new NotificationTask(
		new Runnable() {
		@Override
		public void run() {
		synchronized (mLock) {
		if (mPhoneStateChangePendingNotify != null &&
		mPhoneStateChangePendingNotify.runnableEquals(this)) {

		mPhoneStateChangePendingNotify = null;
		evaluateStateChange();
		}
		}
		}
		},
		CALL_INACTIVE_MSG_DELAY_MS);
		mDelayedNotificationExecutor.execute(mPhoneStateChangePendingNotify);
		} else {
		evaluateStateChange();
		}
		}
		}

		/** Note, we expect initial callbacks immediately following construction */
		public DeviceStateHandler(Executor callbackExecutor, EventLogger eventLogger) {
		mCallbackExecutor = Objects.requireNonNull(callbackExecutor);
		mEventLogger = Objects.requireNonNull(eventLogger);
		}

		public SoundTriggerDeviceState getDeviceState() {
		synchronized (mLock) {
		return mSoundTriggerDeviceState;
		}
		}

		public void registerListener(DeviceStateListener callback) {
		final var state = getDeviceState();
		mCallbackExecutor.execute(
		() -> callback.onSoundTriggerDeviceStateUpdate(state));
		mCallbackSet.add(callback);
		}

		public void unregisterListener(DeviceStateListener callback) {
		mCallbackSet.remove(callback);
		}

		void dump(PrintWriter pw) {
		synchronized (mLock) {
		pw.println("DeviceState: " + mSoundTriggerDeviceState.name());
		pw.println("PhoneState: " + mIsPhoneCallOngoing);
		pw.println("PowerSaveMode: " + mSoundTriggerPowerSaveMode);
		}
		}

		@GuardedBy("mLock")
		private void evaluateStateChange() {
		// We should wait until any pending delays are complete to update.
		// We will eventually get called by the notification task, or something which
		// cancels it.
		// Additionally, if there isn't a state change, there is nothing to update.
		SoundTriggerDeviceState newState = computeState();
		if (mPhoneStateChangePendingNotify != null \|\| mSoundTriggerDeviceState == newState) {
		return;
		}

		mSoundTriggerDeviceState = newState;
		mEventLogger.enqueue(new DeviceStateEvent(mSoundTriggerDeviceState));
		final var state = mSoundTriggerDeviceState;
		for (var callback : mCallbackSet) {
		mCallbackExecutor.execute(
		() -> callback.onSoundTriggerDeviceStateUpdate(state));
		}
		}

		@GuardedBy("mLock")
		private SoundTriggerDeviceState computeState() {
		if (mIsPhoneCallOngoing) {
		return SoundTriggerDeviceState.DISABLE;
		}
		return switch (mSoundTriggerPowerSaveMode) {
		case SOUND_TRIGGER_MODE_ALL_ENABLED -> SoundTriggerDeviceState.ENABLE;
		case SOUND_TRIGGER_MODE_CRITICAL_ONLY -> SoundTriggerDeviceState.CRITICAL;
		case SOUND_TRIGGER_MODE_ALL_DISABLED -> SoundTriggerDeviceState.DISABLE;
		default -> throw new IllegalStateException(
		"Received unexpected power state code" + mSoundTriggerPowerSaveMode);
		};
		}

		/**
		* One-shot, cancellable task which runs after a delay. Run must only be called once, from a
		* single thread. Cancel can be called from any other thread.
		*/
		private static class NotificationTask implements Runnable {
		private final Runnable mRunnable;
		private final long mWaitInMillis;

		private final CountDownLatch mCancelLatch = new CountDownLatch(1);

		NotificationTask(Runnable r, long waitInMillis) {
		mRunnable = r;
		mWaitInMillis = waitInMillis;
		}

		void cancel() {
		mCancelLatch.countDown();
		}

		// Used for determining task equality.
		boolean runnableEquals(Runnable runnable) {
		return mRunnable == runnable;
		}

		public void run() {
		try {
		if (!mCancelLatch.await(mWaitInMillis, TimeUnit.MILLISECONDS)) {
		mRunnable.run();
		}
		} catch (InterruptedException e) {
		Thread.currentThread().interrupt();
		throw new AssertionError("Unexpected InterruptedException", e);
		}
		}
		}

		private static class PhoneCallEvent extends EventLogger.Event {
		final boolean mIsInPhoneCall;

		PhoneCallEvent(boolean isInPhoneCall) {
		mIsInPhoneCall = isInPhoneCall;
		}

		@Override
		public String eventToString() {
		return "PhoneCallChange - inPhoneCall: " + mIsInPhoneCall;
		}
		}

		private static class SoundTriggerPowerEvent extends EventLogger.Event {
		final int mSoundTriggerPowerState;

		SoundTriggerPowerEvent(int soundTriggerPowerState) {
		mSoundTriggerPowerState = soundTriggerPowerState;
		}

		@Override
		public String eventToString() {
		return "SoundTriggerPowerChange: " + stateToString();
		}

		private String stateToString() {
		return switch (mSoundTriggerPowerState) {
		case SOUND_TRIGGER_MODE_ALL_ENABLED -> "All enabled";
		case SOUND_TRIGGER_MODE_CRITICAL_ONLY -> "Critical only";
		case SOUND_TRIGGER_MODE_ALL_DISABLED -> "All disabled";
		default -> "Unknown power state: " + mSoundTriggerPowerState;
		};
		}
		}

		private static class DeviceStateEvent extends EventLogger.Event {
		final SoundTriggerDeviceState mSoundTriggerDeviceState;

		DeviceStateEvent(SoundTriggerDeviceState soundTriggerDeviceState) {
		mSoundTriggerDeviceState = soundTriggerDeviceState;
		}

		@Override
		public String eventToString() {
		return "DeviceStateChange: " + mSoundTriggerDeviceState.name();
		}
		}
		}

services/voiceinteraction/java/com/android/server/soundtrigger/PhoneCallStateHandler.java

0 → 100644

+158 −0

File added.

Preview size limit exceeded, changes collapsed.

services/voiceinteraction/java/com/android/server/soundtrigger/SoundTriggerHelper.java

+24 −187

File changed.

Preview size limit exceeded, changes collapsed.

services/voiceinteraction/java/com/android/server/soundtrigger/SoundTriggerService.java

+55 −4

File changed.

Preview size limit exceeded, changes collapsed.