Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

AudioManager: listener for changes to preferred device for strategy

Browse Source 
Add a listener for being notified when the preferred audio device
for an audio strategy changes.

Bug: 148566862
Bug: 144440677
Test: atest AudioServiceHostTest#testPreferredDeviceRouting
Test: atest AudioServiceHostTest#testDevicesForAttributes
Change-Id: Iff47d6bc7f4bd18c3a8fe48557acf803a4059630
This commit is contained in:
Jean-Michel Trivi
2020-02-05 15:44:42 -08:00
parent 6666041589
commit 8d64ebb8b3
8 changed files with 298 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

174
media/java/android/media/AudioManager.java
View File

@@ -17,6 +17,7 @@
package android.media;
import android.annotation.CallbackExecutor;
import android.annotation.IntDef;
import android.annotation.IntRange;
import android.annotation.NonNull;
@@ -1649,6 +1650,179 @@ public class AudioManager {
}
}
/**
* @hide
* Interface to be notified of changes in the preferred audio device set for a given audio
* strategy.
* @see #setPreferredDeviceForStrategy(AudioProductStrategy, AudioDevice)
* @see #removePreferredDeviceForStrategy(AudioProductStrategy)
* @see #getPreferredDeviceForStrategy(AudioProductStrategy)
*/
@SystemApi
public interface OnPreferredDeviceForStrategyChangedListener {
/**
* Called on the listener to indicate that the preferred audio device for the given
* strategy has changed.
* @param strategy the {@link AudioProductStrategy} whose preferred device changed
* @param device <code>null</code> if the preferred device was removed, or the newly set
* preferred audio device
*/
void onPreferredDeviceForStrategyChanged(@NonNull AudioProductStrategy strategy,
@Nullable AudioDevice device);
}
/**
* @hide
* Adds a listener for being notified of changes to the strategy-preferred audio device.
* @param executor
* @param listener
* @throws SecurityException if the caller doesn't hold the required permission
*/
@SystemApi
@RequiresPermission(android.Manifest.permission.MODIFY_AUDIO_ROUTING)
public void addOnPreferredDeviceForStrategyChangedListener(
@NonNull @CallbackExecutor Executor executor,
@NonNull OnPreferredDeviceForStrategyChangedListener listener)
throws SecurityException {
Objects.requireNonNull(executor);
Objects.requireNonNull(listener);
synchronized (mPrefDevListenerLock) {
if (hasPrefDevListener(listener)) {
throw new IllegalArgumentException(
"attempt to call addOnPreferredDeviceForStrategyChangedListener() "
+ "on a previously registered listener");
}
// lazy initialization of the list of strategy-preferred device listener
if (mPrefDevListeners == null) {
mPrefDevListeners = new ArrayList<>();
}
final int oldCbCount = mPrefDevListeners.size();
mPrefDevListeners.add(new PrefDevListenerInfo(listener, executor));
if (oldCbCount == 0 && mPrefDevListeners.size() > 0) {
// register binder for callbacks
if (mPrefDevDispatcherStub == null) {
mPrefDevDispatcherStub = new StrategyPreferredDeviceDispatcherStub();
}
try {
getService().registerStrategyPreferredDeviceDispatcher(mPrefDevDispatcherStub);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
}
}
/**
* @hide
* Removes a previously added listener of changes to the strategy-preferred audio device.
* @param listener
*/
@SystemApi
@RequiresPermission(android.Manifest.permission.MODIFY_AUDIO_ROUTING)
public void removeOnPreferredDeviceForStrategyChangedListener(
@NonNull OnPreferredDeviceForStrategyChangedListener listener) {
Objects.requireNonNull(listener);
synchronized (mPrefDevListenerLock) {
if (!removePrefDevListener(listener)) {
throw new IllegalArgumentException(
"attempt to call removeOnPreferredDeviceForStrategyChangedListener() "
+ "on an unregistered listener");
}
if (mPrefDevListeners.size() == 0) {
// unregister binder for callbacks
try {
getService().unregisterStrategyPreferredDeviceDispatcher(
mPrefDevDispatcherStub);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
} finally {
mPrefDevDispatcherStub = null;
mPrefDevListeners = null;
}
}
}
}
private final Object mPrefDevListenerLock = new Object();
/**
* List of listeners for preferred device for strategy and their associated Executor.
* List is lazy-initialized on first registration
*/
@GuardedBy("mPrefDevListenerLock")
private @Nullable ArrayList<PrefDevListenerInfo> mPrefDevListeners;
private static class PrefDevListenerInfo {
final @NonNull OnPreferredDeviceForStrategyChangedListener mListener;
final @NonNull Executor mExecutor;
PrefDevListenerInfo(OnPreferredDeviceForStrategyChangedListener listener, Executor exe) {
mListener = listener;
mExecutor = exe;
}
}
@GuardedBy("mPrefDevListenerLock")
private StrategyPreferredDeviceDispatcherStub mPrefDevDispatcherStub;
private final class StrategyPreferredDeviceDispatcherStub
extends IStrategyPreferredDeviceDispatcher.Stub {
@Override
public void dispatchPrefDeviceChanged(int strategyId, @Nullable AudioDevice device) {
// make a shallow copy of listeners so callback is not executed under lock
final ArrayList<PrefDevListenerInfo> prefDevListeners;
synchronized (mPrefDevListenerLock) {
if (mPrefDevListeners == null || mPrefDevListeners.size() == 0) {
return;
}
prefDevListeners = (ArrayList<PrefDevListenerInfo>) mPrefDevListeners.clone();
}
final AudioProductStrategy strategy =
AudioProductStrategy.getAudioProductStrategyWithId(strategyId);
final long ident = Binder.clearCallingIdentity();
try {
for (PrefDevListenerInfo info : prefDevListeners) {
info.mExecutor.execute(() ->
info.mListener.onPreferredDeviceForStrategyChanged(strategy, device));
}
} finally {
Binder.restoreCallingIdentity(ident);
}
}
}
@GuardedBy("mPrefDevListenerLock")
private @Nullable PrefDevListenerInfo getPrefDevListenerInfo(
OnPreferredDeviceForStrategyChangedListener listener) {
if (mPrefDevListeners == null) {
return null;
}
for (PrefDevListenerInfo info : mPrefDevListeners) {
if (info.mListener == listener) {
return info;
}
}
return null;
}
@GuardedBy("mPrefDevListenerLock")
private boolean hasPrefDevListener(OnPreferredDeviceForStrategyChangedListener listener) {
return getPrefDevListenerInfo(listener) != null;
}
@GuardedBy("mPrefDevListenerLock")
/**
* @return true if the listener was removed from the list
*/
private boolean removePrefDevListener(OnPreferredDeviceForStrategyChangedListener listener) {
final PrefDevListenerInfo infoToRemove = getPrefDevListenerInfo(listener);
if (infoToRemove != null) {
mPrefDevListeners.remove(infoToRemove);
return true;
}
return false;
}
//====================================================================
// Offload query
/**

6
media/java/android/media/IAudioService.aidl
View File

@@ -29,6 +29,7 @@ import android.media.IAudioServerStateDispatcher;
import android.media.IPlaybackConfigDispatcher;
import android.media.IRecordingConfigDispatcher;
import android.media.IRingtonePlayer;
import android.media.IStrategyPreferredDeviceDispatcher;
import android.media.IVolumeController;
import android.media.IVolumeController;
import android.media.PlayerBase;
@@ -286,6 +287,11 @@ interface IAudioService {
int getAllowedCapturePolicy();
void registerStrategyPreferredDeviceDispatcher(IStrategyPreferredDeviceDispatcher dispatcher);
oneway void unregisterStrategyPreferredDeviceDispatcher(
IStrategyPreferredDeviceDispatcher dispatcher);
// WARNING: read warning at top of file, new methods that need to be used by native
// code via IAudioManager.h need to be added to the top section.
}

30
media/java/android/media/IStrategyPreferredDeviceDispatcher.aidl Normal file
View File

@@ -0,0 +1,30 @@
/*
* Copyright (C) 2020 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 android.media;
import android.media.AudioDevice;
/**
* AIDL for AudioService to signal audio strategy-preferred device updates.
*
* {@hide}
*/
oneway interface IStrategyPreferredDeviceDispatcher {
void dispatchPrefDeviceChanged(int strategyId, in AudioDevice device);
}

21
media/java/android/media/audiopolicy/AudioProductStrategy.java
View File

@@ -81,6 +81,27 @@ public final class AudioProductStrategy implements Parcelable {
return sAudioProductStrategies;
}
/**
* @hide
* Return the AudioProductStrategy object for the given strategy ID.
* @param id the ID of the strategy to find
* @return an AudioProductStrategy on which getId() would return id, null if no such strategy
* exists.
*/
public static @Nullable AudioProductStrategy getAudioProductStrategyWithId(int id) {
synchronized (sLock) {
if (sAudioProductStrategies == null) {
sAudioProductStrategies = initializeAudioProductStrategies();
}
for (AudioProductStrategy strategy : sAudioProductStrategies) {
if (strategy.getId() == id) {
return strategy;
}
}
}
return null;
}
/**
* @hide
* Create an invalid AudioProductStrategy instance for testing