Android R CarAudio行为变更
本文主要梳理CarAudio模块，从Q升到R的行为变更，如有错误或者理解偏差，欢迎指正
文章目录
一、CarAudioManager行为变更
1.1 成员变量
INVALID_AUDIO_ZONE用于CarOccupantService的初始化和判定，INVALID_VOLUME_GROUP_ID用于usage找groupId时，找不到对应groupId的情况，之前返回的-1。
/**
* Zone id of the invalid audio zone.
* @hide
*/
@SystemApi
public static final int INVALID_AUDIO_ZONE = 0xffffffff;
/**
* Volume Group ID when volume group not found.
* @hide
*/
public static final int INVALID_VOLUME_GROUP_ID = -1;
1.2 新增API
getOutputDeviceForUsage
通过usage拿到对应的device address 如BUS media，然后通过audiomanger拿到所有的outputdevice后进行address匹配，匹配成功返回AudioDeviceInfo
/**
* Gets the output device for a given {@link AudioAttributes} usage in zoneId.
*
* <p><b>Note:</b> To be used for routing to a specific device. Most applications should
* use the regular routing mechanism, which is to set audio attribute usage to
* an audio track.
*
* @param zoneId zone id to query for device
* @param usage usage where audio is routed
* @return Audio device info, returns {@code null} if audio device usage fails to map to
* an active audio device. This is different from the using an invalid value for
* {@link AudioAttributes} usage. In the latter case the query will fail with a
* RuntimeException indicating the issue.
*
* @hide
*/
@SystemApi
@Nullable
@RequiresPermission(Car.PERMISSION_CAR_CONTROL_AUDIO_SETTINGS)
public AudioDeviceInfo getOutputDeviceForUsage(int zoneId,
@AudioAttributes.AttributeUsage int usage) {
try {
String deviceAddress = mService.getOutputDeviceAddressForUsage(zoneId, usage);
if (deviceAddress == null) {
return null;
}
AudioDeviceInfo[] outputDevices =
mAudioManager.getDevices(AudioManager.GET_DEVICES_OUTPUTS);
for (AudioDeviceInfo info : outputDevices) {
if (info.getAddress().equals(deviceAddress)) {
return info;
}
}
return null;
} catch (RemoteException e) {
return handleRemoteExceptionFromCarService(e, null);
}
}
getInputDevicesForZoneId
先通过CarAudioService拿到对应zoneId的所有的inputDevices，然后通过audioManger拿到所有的InputDevice然后匹配对应的address，成功加入到list后一起返回
/**
* Gets the input devices for an audio zone
*
* @return list of input devices
* @hide
*/
@SystemApi
@RequiresPermission(Car.PERMISSION_CAR_CONTROL_AUDIO_SETTINGS)
public @NonNull List<AudioDeviceInfo> getInputDevicesForZoneId(int zoneId) {
try {
return convertInputDevicesToDeviceInfos(
mService.getInputDevicesForZoneId(zoneId),
AudioManager.GET_DEVICES_INPUTS);
} catch (RemoteException e) {
return handleRemoteExceptionFromCarService(e, new ArrayList<>());
}
}
private List<AudioDeviceInfo> convertInputDevicesToDeviceInfos(
List<AudioDeviceAttributes> devices, @AudioDeviceRole int flag) {
int addressesSize = devices.size();
Set<String> deviceAddressMap = new HashSet<>(addressesSize);
for (int i = 0; i < addressesSize; ++i) {
AudioDeviceAttributes device = devices.get(i);
deviceAddressMap.add(device.getAddress());
}
List<AudioDeviceInfo> deviceInfoList = new ArrayList<>(devices.size());
AudioDeviceInfo[] inputDevices = mAudioManager.getDevices(flag);
for (int i = 0; i < inputDevices.length; ++i) {
AudioDeviceInfo info = inputDevices[i];
if (info.isSource() && deviceAddressMap.contains(info.getAddress())) {
deviceInfoList.add(info);
}
}
return deviceInfoList;
}
1.3 移除API
getZoneIdForDisplay
getZoneIdForDisplayPortId
两个关于displayId和zoneId来回转换的API被移除了，通样的car_audio_configuration.xml里zones里绑定的display也被去掉了。
移除原因：carService里新增了CarOccupantZoneManger和service用来管理display和users，
/**
* API to get information on displays and users in the car.
*/
该api移除后，需要进行适配到getAudioZoneIdForOccupant和getOccupantForAudioZoneId API上
/**
* Get the zone id for the display
*
* @param display display to query
* @return zone id for display or
* CarAudioManager.PRIMARY_AUDIO_ZONE if no match is found.
* @hide
*/
@RequiresPermission(Car.PERMISSION_CAR_CONTROL_AUDIO_SETTINGS)
public int getZoneIdForDisplay(Display display) {}
/**
* Get the zone id for the display port id passed in
*
* @param displayPortId display port id to query
* @return zone id for display port id or
* CarAudioManager.PRIMARY_AUDIO_ZONE if no match is found.
* @hide
*/
@RequiresPermission(Car.PERMISSION_CAR_CONTROL_AUDIO_SETTINGS)
public int getZoneIdForDisplayPortId(byte displayPortId) {}
//======================================================================>
/**
* Gets the audio zone id for the occupant, or returns
* {@code CarAudioManager.INVALID_AUDIO_ZONE} if no audio zone matches the requirements.
* throws InvalidArgumentException if occupantZone does not exist.
*
* @hide
*/
@SystemApi
@RequiresPermission(Car.PERMISSION_CAR_CONTROL_AUDIO_SETTINGS)
public int getAudioZoneIdForOccupant(@NonNull OccupantZoneInfo occupantZone) {
assertNonNullOccupant(occupantZone);
try {
return mService.getAudioZoneIdForOccupant(occupantZone.zoneId);
} catch (RemoteException e) {
return handleRemoteExceptionFromCarService(e, null);
}
}
/**
* Gets occupant for the audio zone id, or returns {@code null}
* if no audio zone matches the requirements.
*
* @hide
*/
@Nullable
@SystemApi
@RequiresPermission(Car.PERMISSION_CAR_CONTROL_AUDIO_SETTINGS)
public OccupantZoneInfo getOccupantForAudioZoneId(int audioZoneId) {
try {
return mService.getOccupantForAudioZoneId(audioZoneId);
} catch (RemoteException e) {
return handleRemoteExceptionFromCarService(e, null);
}
}
二、CarAudioService的行为变更
Q的目录结构
src\com\android\car\audio\CarAudioDeviceInfo.java
src\com\android\car\audio\CarAudioDynamicRouting.java
src\com\android\car\audio\CarAudioFocus.java
src\com\android\car\audio\CarAudioService.java
src\com\android\car\audio\CarAudioZone.java
src\com\android\car\audio\CarAudioZonesHelper.java
src\com\android\car\audio\CarAudioZonesHelperLegacy.java
src\com\android\car\audio\CarVolumeGroup.java
src\com\android\car\audio\CarZonesAudioFocus.java
R的目录结构
src\com\android\car\audio\hal\AudioControlFactory.java
src\com\android\car\audio\hal\AudioControlWrapper.java
src\com\android\car\audio\hal\AudioControlWrapperV1.java
src\com\android\car\audio\hal\AudioControlWrapperV2.java
src\com\android\car\audio\hal\HalAudioFocus.java
src\com\android\car\audio\CarAudioContext.java
src\com\android\car\audio\CarAudioDeviceInfo.java
src\com\android\car\audio\CarAudioDynamicRouting.java
src\com\android\car\audio\CarAudioFocus.java
src\com\android\car\audio\CarAudioService.java
src\com\android\car\audio\CarAudioSettings.java
src\com\android\car\audio\CarAudioZone.java
src\com\android\car\audio\CarAudioZonesHelper.java
src\com\android\car\audio\CarAudioZonesHelperLegacy.java
src\com\android\car\audio\CarAudioZonesValidator.java
src\com\android\car\audio\CarVolume.java
src\com\android\car\audio\CarVolumeCallbackHandler.java
src\com\android\car\audio\CarVolumeGroup.java
src\com\android\car\audio\CarZonesAudioFocus.java
src\com\android\car\audio\FocusEntry.java
src\com\android\car\audio\FocusInteraction.java
src\com\android\car\audio\OWNERS
对比之后多了好多小模块，好多模块也做了优化
2.1 CarAudioZonesHelper解析car_audio_configuration 2.0
car_audio_configuration新增字段，新增字段后version也变成了2，如果使用了audioZoneId occupantZoneId inputDevices字段但是version没有生成2，会在解析阶段报异常。
<?xml version="1.0" encoding="utf-8"?>
<carAudioConfiguration version="2">
<zones>
<zone name="primary zone" isPrimary="true" audioZoneId="0" occupantZoneId="1">
<volumeGroups>
<group>
<device address="bus0_media_out">
<context context="music"/>
</device>
<device address="bus3_call_ring_out">
<context context="call_ring"/>
</device>
</group>
<group>
<device address="bus1_navigation_out">
<context context="navigation"/>
<context context="emergency"/>
<context context="safety"/>
<context context="vehicle_status"/>
<context context="announcement"/>
</device>
</group>
</volumeGroups>
<inputDevices>
<inputDevice address="fm_tuner"/>
<inputDevice address="Built-In Mic"/>
</inputDevices>
</zone>
<zone name="rear seat zone" audioZoneId="2">
<volumeGroups>
<group>
<device address="bus100_rear_seat">
<context context="music"/>
<context context="navigation"/>
<context context="voice_command"/>
<context context="call_ring"/>
<context context="call"/>
<context context="alarm"/>
<context context="system_sound"/>
<context context="notification"/>
<context context="emergency"/>
<context context="safety"/>
<context context="vehicle_status"/>
<context context="announcement"/>
</device>
</group>
</volumeGroups>
<inputDevices>
<inputDevice address="bus_1000_input"/>
<inputDevice address="Built-In Back Mic"/>
</inputDevices>
</zone>
</zones>
</carAudioConfiguration>
inputDevices
为了支持getInputDeviceForZoneId，CarAudioZones初始化时也会去读取xml里的inputDevice，如官方示例中
<inputDevices>
<inputDevice address="bus_1000_input"/>
<inputDevice address="Built-In Back Mic"/>
</inputDevices>
在解析过程中会放到对应的
class CarAudioZone {
private final int mId;
private final String mName;
private final List<CarVolumeGroup> mVolumeGroups;
//AudioDeviceAttributes也是R上 framework新增的类
private List<AudioDeviceAttributes> mInputAudioDevice;
void addInputAudioDevice(AudioDeviceAttributes device) {
mInputAudioDevice.add(device);
}
List<AudioDeviceAttributes> getInputAudioDevices() {
return mInputAudioDevice;
}
AudioDeviceAttributes是R上新增的设备构建类，可用于R上AudioManager的setDeviceVolumeBehavior和getDeviceVolumeBehavior，之前是使用的deviceType和deviceAddress，现在用AudioDeviceAttributes替代
@SystemApi
public AudioDeviceAttributes(@NonNull AudioDeviceInfo deviceInfo) {
Objects.requireNonNull(deviceInfo);
mRole = deviceInfo.isSink() ? ROLE_OUTPUT : ROLE_INPUT;
mType = deviceInfo.getType();
mAddress = deviceInfo.getAddress();
}
//AudioManager
@IntDef({
DEVICE_VOLUME_BEHAVIOR_UNSET,
DEVICE_VOLUME_BEHAVIOR_VARIABLE,
DEVICE_VOLUME_BEHAVIOR_FULL,
DEVICE_VOLUME_BEHAVIOR_FIXED,
DEVICE_VOLUME_BEHAVIOR_ABSOLUTE,
DEVICE_VOLUME_BEHAVIOR_ABSOLUTE_MULTI_MODE,
})
@Retention(RetentionPolicy.SOURCE)
public @interface DeviceVolumeBehaviorState {}
/**
* @hide
* Sets the volume behavior for an audio output device.
* @param device the device to be affected. Currently only supports devices of type
* {@link AudioDeviceInfo#TYPE_HDMI}, {@link AudioDeviceInfo#TYPE_HDMI_ARC},
* {@link AudioDeviceInfo#TYPE_LINE_DIGITAL} and {@link AudioDeviceInfo#TYPE_AUX_LINE}
* @param deviceVolumeBehavior one of the device behaviors
*/
@RequiresPermission(android.Manifest.permission.MODIFY_AUDIO_ROUTING)
public void setDeviceVolumeBehavior(@NonNull AudioDeviceAttributes device,
@DeviceVolumeBehavior int deviceVolumeBehavior) {
}
/**
* @hide
* Returns the volume device behavior for the given audio device
* @param device the audio device
* @return the volume behavior for the device
*/
@RequiresPermission(android.Manifest.permission.MODIFY_AUDIO_ROUTING)
public @DeviceVolumeBehaviorState int getDeviceVolumeBehavior(
@NonNull AudioDeviceAttributes device) {
}
audioZoneId
version 2 支持自定义zoneId的值了，当然和isPrimary有所关联，Primary只能设置为0，或者audioZoneId字段省略。而非primary的zone，audioZoneId不能设置为0，且不能缺省。
Objects.requireNonNull(audioZoneIdString, () ->
"Requires " + ATTR_ZONE_ID + " for all audio zones.");
if (isPrimary) {
Preconditions.checkArgument(zoneId == CarAudioManager.PRIMARY_AUDIO_ZONE,
"Primary zone %s must be %d or it can be left empty.",
ATTR_ZONE_ID, CarAudioManager.PRIMARY_AUDIO_ZONE);
} else {
Preconditions.checkArgument(zoneId != CarAudioManager.PRIMARY_AUDIO_ZONE,
"%s can only be %d for primary zone.",
ATTR_ZONE_ID, CarAudioManager.PRIMARY_AUDIO_ZONE);
}
occupantZoneId
occupantZoneId在xml中定义，最后和zoneId形成map关系，提供给CarService使用，逻辑详见2.5
int occupantZoneId = parsePositiveIntAttribute(ATTR_OCCUPANT_ZONE_ID, occupantZoneIdString);
validateOccupantZoneIdIsUnique(occupantZoneId);
mZoneIdToOccupantZoneIdMapping.put(audioZoneId, occupantZoneId);
2.2 CarAudioSetting
carAudioSetting是为了应对多个user的不同设置的存储模块
在CarAudioService构造的时候，创建
public CarAudioService(Context context) {
mCarAudioSettings = new CarAudioSettings(mContext.getContentResolver());
}
里面封装里一些静音和音量的接口
int getStoredVolumeGainIndexForUser(int userId, int zoneId, int id) {
return Settings.System.getIntForUser(mContentResolver,
getVolumeSettingsKeyForGroup(zoneId, id), -1, userId);
}
void storeVolumeGainIndexForUser(int userId, int zoneId, int id, int gainIndex) {
Settings.System.putIntForUser(mContentResolver,
getVolumeSettingsKeyForGroup(zoneId, id),
gainIndex, userId);
}
void storeMasterMute(Boolean masterMuteValue) {
Settings.Global.putInt(mContentResolver,
VOLUME_SETTINGS_KEY_MASTER_MUTE,
masterMuteValue ? 1 : 0);
}
boolean getMasterMute() {
return Settings.Global.getInt(mContentResolver,
VOLUME_SETTINGS_KEY_MASTER_MUTE, 0) != 0;
}
还有一个新增的设置就是是否允许导航出声在通话过程中，由此R上的仲裁矩阵有了动态更新的逻辑，详见2.4 矩阵动态更新
public boolean isRejectNavigationOnCallEnabledInSettings(@UserIdInt int userId) {
return Settings.Secure.getIntForUser(mContentResolver,
CarSettings.Secure.KEY_AUDIO_FOCUS_NAVIGATION_REJECTED_DURING_CALL,
/*disabled by default*/ 0, userId) == 1;
}
2.3 SystemUsages
R上新增了5中systemUsage，用于 来电语音播报，警报提示音，安全带音，车辆状态音，车辆通知音。
/**
* @hide
* Usage value to use for assistant voice interaction with remote caller on Cell and VoIP calls.
*/
@SystemApi
@RequiresPermission(allOf = {
android.Manifest.permission.MODIFY_PHONE_STATE,
android.Manifest.permission.MODIFY_AUDIO_ROUTING
})
public static final int USAGE_CALL_ASSISTANT = 17;
private static final int SYSTEM_USAGE_OFFSET = 1000;
/**
* @hide
* Usage value to use when the usage is an emergency.
*/
@SystemApi
@RequiresPermission(android.Manifest.permission.MODIFY_AUDIO_ROUTING)
public static final int USAGE_EMERGENCY = SYSTEM_USAGE_OFFSET;
/**
* @hide
* Usage value to use when the usage is a safety sound.
*/
@SystemApi
@RequiresPermission(android.Manifest.permission.MODIFY_AUDIO_ROUTING)
public static final int USAGE_SAFETY = SYSTEM_USAGE_OFFSET + 1;
/**
* @hide
* Usage value to use when the usage is a vehicle status.
*/
@SystemApi
@RequiresPermission(android.Manifest.permission.MODIFY_AUDIO_ROUTING)
public static final int USAGE_VEHICLE_STATUS = SYSTEM_USAGE_OFFSET + 2;
/**
* @hide
* Usage value to use when the usage is an announcement.
*/
@SystemApi
@RequiresPermission(android.Manifest.permission.MODIFY_AUDIO_ROUTING)
public static final int USAGE_ANNOUNCEMENT = SYSTEM_USAGE_OFFSET + 3;
但这些usage没有对三方app开放，属于系统usage。即在builder里setUsage这些系统usage不能使用，只能在setSystemUsage中使用，但是在build构建AudioAttribute时mSystemUsage和mUsage（不允许同时赋值）都会赋值给AudioAttribute的mUsage。
@SystemApi
@RequiresPermission(android.Manifest.permission.MODIFY_AUDIO_ROUTING)
public @NonNull Builder setSystemUsage(@AttributeSystemUsage int systemUsage) {
if (isSystemUsage(systemUsage)) {
mSystemUsage = systemUsage;
} else {
throw new IllegalArgumentException("Invalid system usage " + systemUsage);
}
return this;
}
@SystemApi
public static boolean isSystemUsage(@AttributeSystemUsage int usage) {
return (usage == USAGE_CALL_ASSISTANT
|| usage == USAGE_EMERGENCY
|| usage == USAGE_SAFETY
|| usage == USAGE_VEHICLE_STATUS
|| usage == USAGE_ANNOUNCEMENT);
}
public AudioAttributes build() {
AudioAttributes aa = new AudioAttributes();
aa.mContentType = mContentType;
if (mUsage == USAGE_INVALID) {
if (mSystemUsage == USAGE_INVALID) {
aa.mUsage = USAGE_UNKNOWN;
} else {
aa.mUsage = mSystemUsage;
}
} else {
if (mSystemUsage == USAGE_INVALID) {
aa.mUsage = mUsage;
} else {
throw new IllegalArgumentException(
"Cannot set both usage and system usage on same builder");
}
}
}
CarAudioService在init时会setSupportSystemUsage，这样其他模块就可以通过getSupportSystemUsages获取当前可用系统usage，如果没有CarAudioService 设置这个系统级的usages，默认framework只会支持USAGE_CALL_ASSISTANT
//CarAudioService
private static final @AttributeSystemUsage int[] SYSTEM_USAGES = new int[] {
AudioAttributes.USAGE_CALL_ASSISTANT,
AudioAttributes.USAGE_EMERGENCY,
AudioAttributes.USAGE_SAFETY,
AudioAttributes.USAGE_VEHICLE_STATUS,
AudioAttributes.USAGE_ANNOUNCEMENT
};
@Override
public void init() {
mAudioManager.setSupportedSystemUsages(SYSTEM_USAGES);
}
//AudioService
private @AttributeSystemUsage int[] mSupportedSystemUsages =
new int[]{AudioAttributes.USAGE_CALL_ASSISTANT};
public void setSupportedSystemUsages(@NonNull @AttributeSystemUsage int[] systemUsages) {
enforceModifyAudioRoutingPermission();
verifySystemUsages(systemUsages);
synchronized (mSupportedSystemUsagesLock) {
AudioSystem.setSupportedSystemUsages(systemUsages);
mSupportedSystemUsages = systemUsages;
}
}
/**
* @see AudioManager#getSupportedSystemUsages()
*/
public @NonNull @AttributeSystemUsage int[] getSupportedSystemUsages() {
enforceModifyAudioRoutingPermission();
synchronized (mSupportedSystemUsagesLock) {
return Arrays.copyOf(mSupportedSystemUsages, mSupportedSystemUsages.length);
}
}
当然设置的systemUsage也会通过AudioSystem设置到AudioPolicy里
//AudioPolicyInterfaceImpl.cpp
const std::vector<audio_usage_t>& SYSTEM_USAGES = {
AUDIO_USAGE_CALL_ASSISTANT,
AUDIO_USAGE_EMERGENCY,
AUDIO_USAGE_SAFETY,
AUDIO_USAGE_VEHICLE_STATUS,
AUDIO_USAGE_ANNOUNCEMENT
};
bool isSystemUsage(audio_usage_t usage) {
return std::find(std::begin(SYSTEM_USAGES), std::end(SYSTEM_USAGES), usage)
!= std::end(SYSTEM_USAGES);
}
bool AudioPolicyService::isSupportedSystemUsage(audio_usage_t usage) {
return std::find(std::begin(mSupportedSystemUsages), std::end(mSupportedSystemUsages), usage)
!= std::end(mSupportedSystemUsages);
}
status_t AudioPolicyService::setSupportedSystemUsages(const std::vector<audio_usage_t>& systemUsages) {
Mutex::Autolock _l(mLock);
if(!modifyAudioRoutingAllowed()) {
return PERMISSION_DENIED;
}
bool areAllSystemUsages = std::all_of(begin(systemUsages), end(systemUsages),
[](audio_usage_t usage) { return isSystemUsage(usage); });
if (!areAllSystemUsages) {
return BAD_VALUE;
}
mSupportedSystemUsages = systemUsages;
return NO_ERROR;
}
2.4 CarAudioFocus 之 FocusInteraction
新增仲裁
R上新增了一个CarAudioContext用于管理usage和context之间关系，包括新增的4中car的systemUsage，但是USAGE_CALL_ASSISTANT并没有放到这个connext map里，不知道是落下了，还是故意这么设计。安装当前的逻辑（android11-release last in carService 2020 07 19）来说USAGE_CALL_ASSISTANT会归到无效的connext里，实际使用时建议新增一个CallTts的connext来区别普通的tts，如果有该项需求的话。
static {
CONTEXT_TO_USAGES.put(MUSIC,
new int[]{
AudioAttributes.USAGE_UNKNOWN,
AudioAttributes.USAGE_GAME,
AudioAttributes.USAGE_MEDIA
});
CONTEXT_TO_USAGES.put(NAVIGATION,
new int[]{
AudioAttributes.USAGE_ASSISTANCE_NAVIGATION_GUIDANCE
});
CONTEXT_TO_USAGES.put(VOICE_COMMAND,
new int[]{
AudioAttributes.USAGE_ASSISTANCE_ACCESSIBILITY,
AudioAttributes.USAGE_ASSISTANT
});
CONTEXT_TO_USAGES.put(CALL_RING,
new int[]{
AudioAttributes.USAGE_NOTIFICATION_RINGTONE
});
CONTEXT_TO_USAGES.put(CALL,
new int[]{
AudioAttributes.USAGE_VOICE_COMMUNICATION,
AudioAttributes.USAGE_VOICE_COMMUNICATION_SIGNALLING
});
CONTEXT_TO_USAGES.put(ALARM,
new int[]{
AudioAttributes.USAGE_ALARM
});
CONTEXT_TO_USAGES.put(NOTIFICATION,
new int[]{
AudioAttributes.USAGE_NOTIFICATION,
AudioAttributes.USAGE_NOTIFICATION_COMMUNICATION_REQUEST,
AudioAttributes.USAGE_NOTIFICATION_COMMUNICATION_INSTANT,
AudioAttributes.USAGE_NOTIFICATION_COMMUNICATION_DELAYED,
AudioAttributes.USAGE_NOTIFICATION_EVENT
});
CONTEXT_TO_USAGES.put(SYSTEM_SOUND,
new int[]{
AudioAttributes.USAGE_ASSISTANCE_SONIFICATION
});
CONTEXT_TO_USAGES.put(EMERGENCY,
new int[]{
AudioAttributes.USAGE_EMERGENCY
});
CONTEXT_TO_USAGES.put(SAFETY,
new int[]{
AudioAttributes.USAGE_SAFETY
});
CONTEXT_TO_USAGES.put(VEHICLE_STATUS,
new int[]{
AudioAttributes.USAGE_VEHICLE_STATUS
});
CONTEXT_TO_USAGES.put(ANNOUNCEMENT,
new int[]{
AudioAttributes.USAGE_ANNOUNCEMENT
});
CONTEXT_TO_USAGES.put(INVALID,
new int[]{
AudioAttributes.USAGE_VIRTUAL_SOURCE
});
}
矩阵优化
之前在R之前，焦点矩阵是个二维数组，在添加和修改时需要很耐心的一点点的数对应关系，对于修改和扩展都很麻烦，在R上矩阵被单独放在一个小模块里了，便于修改和扩展。
矩阵结果还是之前的三种
// Values for the internal interaction matrix we use to make focus decisions
@VisibleForTesting
static final int INTERACTION_REJECT = 0; // Focus not granted
@VisibleForTesting
static final int INTERACTION_EXCLUSIVE = 1; // Focus granted, others loose focus
@VisibleForTesting
static final int INTERACTION_CONCURRENT = 2; // Focus granted, others keep focus
二维数组更新初始化结构，数组还是二维数组只是便于修改和观察了。
private static final int[][] sInteractionMatrix = {
// Each Row represents CarAudioContext of current focus holder
// Each Column represents CarAudioContext of incoming request (labels along the right)
// Cell value is one of INTERACTION_REJECT, INTERACTION_EXCLUSIVE,
// or INTERACTION_CONCURRENT
// Focus holder: INVALID
{
INTERACTION_REJECT, // INVALID
INTERACTION_REJECT, // MUSIC
INTERACTION_REJECT, // NAVIGATION
INTERACTION_REJECT, // VOICE_COMMAND
INTERACTION_REJECT, // CALL_RING
INTERACTION_REJECT, // CALL
INTERACTION_REJECT, // ALARM
INTERACTION_REJECT, // NOTIFICATION
INTERACTION_REJECT, // SYSTEM_SOUND,
INTERACTION_EXCLUSIVE, // EMERGENCY
INTERACTION_EXCLUSIVE, // SAFETY
INTERACTION_REJECT, // VEHICLE_STATUS
INTERACTION_REJECT, // ANNOUNCEMENT
},
// Focus holder: MUSIC
{
INTERACTION_REJECT, // INVALID
INTERACTION_EXCLUSIVE, // MUSIC
INTERACTION_CONCURRENT, // NAVIGATION
INTERACTION_EXCLUSIVE, // VOICE_COMMAND
INTERACTION_EXCLUSIVE, // CALL_RING
INTERACTION_EXCLUSIVE, // CALL
INTERACTION_EXCLUSIVE, // ALARM
INTERACTION_CONCURRENT, // NOTIFICATION
INTERACTION_CONCURRENT, // SYSTEM_SOUND
INTERACTION_EXCLUSIVE, // EMERGENCY
INTERACTION_CONCURRENT, // SAFETY
INTERACTION_CONCURRENT, // VEHICLE_STATUS
INTERACTION_EXCLUSIVE, // ANNOUNCEMENT
},
// Focus holder: NAVIGATION
{
INTERACTION_REJECT, // INVALID
INTERACTION_CONCURRENT, // MUSIC
INTERACTION_CONCURRENT, // NAVIGATION
INTERACTION_EXCLUSIVE, // VOICE_COMMAND
INTERACTION_CONCURRENT, // CALL_RING
INTERACTION_EXCLUSIVE, // CALL
INTERACTION_CONCURRENT, // ALARM
INTERACTION_CONCURRENT, // NOTIFICATION
INTERACTION_CONCURRENT, // SYSTEM_SOUND
INTERACTION_EXCLUSIVE, // EMERGENCY
INTERACTION_CONCURRENT, // SAFETY
INTERACTION_CONCURRENT, // VEHICLE_STATUS
INTERACTION_CONCURRENT, // ANNOUNCEMENT
},
// Focus holder: VOICE_COMMAND
{
INTERACTION_REJECT, // INVALID
INTERACTION_CONCURRENT, // MUSIC
INTERACTION_REJECT, // NAVIGATION
INTERACTION_CONCURRENT, // VOICE_COMMAND
INTERACTION_EXCLUSIVE, // CALL_RING
INTERACTION_EXCLUSIVE, // CALL
INTERACTION_REJECT, // ALARM
INTERACTION_REJECT, // NOTIFICATION
INTERACTION_REJECT, // SYSTEM_SOUND
INTERACTION_EXCLUSIVE, // EMERGENCY
INTERACTION_CONCURRENT, // SAFETY
INTERACTION_CONCURRENT, // VEHICLE_STATUS
INTERACTION_REJECT, // ANNOUNCEMENT
},
// Focus holder: CALL_RING
{
INTERACTION_REJECT, // INVALID
INTERACTION_REJECT, // MUSIC
INTERACTION_CONCURRENT, // NAVIGATION
INTERACTION_CONCURRENT, // VOICE_COMMAND
INTERACTION_CONCURRENT, // CALL_RING
INTERACTION_CONCURRENT, // CALL
INTERACTION_REJECT, // ALARM
INTERACTION_REJECT, // NOTIFICATION
INTERACTION_CONCURRENT, // SYSTEM_SOUND
INTERACTION_EXCLUSIVE, // EMERGENCY
INTERACTION_CONCURRENT, // SAFETY
INTERACTION_CONCURRENT, // VEHICLE_STATUS
INTERACTION_REJECT, // ANNOUNCEMENT
},
// Focus holder: CALL
{
INTERACTION_REJECT, // INVALID
INTERACTION_REJECT, // MUSIC
INTERACTION_CONCURRENT, // NAVIGATION
INTERACTION_REJECT, // VOICE_COMMAND
INTERACTION_CONCURRENT, // CALL_RING
INTERACTION_CONCURRENT, // CALL
INTERACTION_CONCURRENT, // ALARM
INTERACTION_CONCURRENT, // NOTIFICATION
INTERACTION_REJECT, // SYSTEM_SOUND
INTERACTION_CONCURRENT, // EMERGENCY
INTERACTION_CONCURRENT, // SAFETY
INTERACTION_CONCURRENT, // VEHICLE_STATUS
INTERACTION_REJECT, // ANNOUNCEMENT
},
// Focus holder: ALARM
{
INTERACTION_REJECT, // INVALID
INTERACTION_CONCURRENT, // MUSIC
INTERACTION_CONCURRENT, // NAVIGATION
INTERACTION_EXCLUSIVE, // VOICE_COMMAND
INTERACTION_EXCLUSIVE, // CALL_RING
INTERACTION_EXCLUSIVE, // CALL
INTERACTION_CONCURRENT, // ALARM
INTERACTION_CONCURRENT, // NOTIFICATION
INTERACTION_CONCURRENT, // SYSTEM_SOUND
INTERACTION_EXCLUSIVE, // EMERGENCY
INTERACTION_CONCURRENT, // SAFETY
INTERACTION_CONCURRENT, // VEHICLE_STATUS
INTERACTION_REJECT, // ANNOUNCEMENT
},
// Focus holder: NOTIFICATION
{
INTERACTION_REJECT, // INVALID
INTERACTION_CONCURRENT, // MUSIC
INTERACTION_CONCURRENT, // NAVIGATION
INTERACTION_EXCLUSIVE, // VOICE_COMMAND
INTERACTION_EXCLUSIVE, // CALL_RING
INTERACTION_EXCLUSIVE, // CALL
INTERACTION_CONCURRENT, // ALARM
INTERACTION_CONCURRENT, // NOTIFICATION
INTERACTION_CONCURRENT, // SYSTEM_SOUND
INTERACTION_EXCLUSIVE, // EMERGENCY
INTERACTION_CONCURRENT, // SAFETY
INTERACTION_CONCURRENT, // VEHICLE_STATUS
INTERACTION_CONCURRENT, // ANNOUNCEMENT
},
// Focus holder: SYSTEM_SOUND
{
INTERACTION_REJECT, // INVALID
INTERACTION_CONCURRENT, // MUSIC
INTERACTION_CONCURRENT, // NAVIGATION
INTERACTION_EXCLUSIVE, // VOICE_COMMAND
INTERACTION_EXCLUSIVE, // CALL_RING
INTERACTION_EXCLUSIVE, // CALL
INTERACTION_CONCURRENT, // ALARM
INTERACTION_CONCURRENT, // NOTIFICATION
INTERACTION_CONCURRENT, // SYSTEM_SOUND
INTERACTION_EXCLUSIVE, // EMERGENCY
INTERACTION_CONCURRENT, // SAFETY
INTERACTION_CONCURRENT, // VEHICLE_STATUS
INTERACTION_CONCURRENT, // ANNOUNCEMENT
},
// Focus holder: EMERGENCY
{
INTERACTION_REJECT, // INVALID
INTERACTION_REJECT, // MUSIC
INTERACTION_REJECT, // NAVIGATION
INTERACTION_REJECT, // VOICE_COMMAND
INTERACTION_REJECT, // CALL_RING
INTERACTION_CONCURRENT, // CALL
INTERACTION_REJECT, // ALARM
INTERACTION_REJECT, // NOTIFICATION
INTERACTION_REJECT, // SYSTEM_SOUND
INTERACTION_CONCURRENT, // EMERGENCY
INTERACTION_CONCURRENT, // SAFETY
INTERACTION_REJECT, // VEHICLE_STATUS
INTERACTION_REJECT, // ANNOUNCEMENT
},
// Focus holder: SAFETY
{
INTERACTION_REJECT, // INVALID
INTERACTION_CONCURRENT, // MUSIC
INTERACTION_CONCURRENT, // NAVIGATION
INTERACTION_CONCURRENT, // VOICE_COMMAND
INTERACTION_CONCURRENT, // CALL_RING
INTERACTION_CONCURRENT, // CALL
INTERACTION_CONCURRENT, // ALARM
INTERACTION_CONCURRENT, // NOTIFICATION
INTERACTION_CONCURRENT, // SYSTEM_SOUND
INTERACTION_CONCURRENT, // EMERGENCY
INTERACTION_CONCURRENT, // SAFETY
INTERACTION_CONCURRENT, // VEHICLE_STATUS
INTERACTION_CONCURRENT, // ANNOUNCEMENT
},
// Focus holder: VEHICLE_STATUS
{
INTERACTION_REJECT, // INVALID
INTERACTION_CONCURRENT, // MUSIC
INTERACTION_CONCURRENT, // NAVIGATION
INTERACTION_CONCURRENT, // VOICE_COMMAND
INTERACTION_CONCURRENT, // CALL_RING
INTERACTION_CONCURRENT, // CALL
INTERACTION_CONCURRENT, // ALARM
INTERACTION_CONCURRENT, // NOTIFICATION
INTERACTION_CONCURRENT, // SYSTEM_SOUND
INTERACTION_EXCLUSIVE, // EMERGENCY
INTERACTION_CONCURRENT, // SAFETY
INTERACTION_CONCURRENT, // VEHICLE_STATUS
INTERACTION_CONCURRENT, // ANNOUNCEMENT
},
// Focus holder: ANNOUNCEMENT
{
INTERACTION_REJECT, // INVALID
INTERACTION_EXCLUSIVE, // MUSIC
INTERACTION_CONCURRENT, // NAVIGATION
INTERACTION_EXCLUSIVE, // VOICE_COMMAND
INTERACTION_EXCLUSIVE, // CALL_RING
INTERACTION_EXCLUSIVE, // CALL
INTERACTION_EXCLUSIVE, // ALARM
INTERACTION_CONCURRENT, // NOTIFICATION
INTERACTION_CONCURRENT, // SYSTEM_SOUND
INTERACTION_EXCLUSIVE, // EMERGENCY
INTERACTION_CONCURRENT, // SAFETY
INTERACTION_CONCURRENT, // VEHICLE_STATUS
INTERACTION_EXCLUSIVE, // ANNOUNCEMENT
},
};
矩阵动态更新
在FocusInteraction里通过setRejectNavigationOnCallLocked方法里，可以动态修改二维数组中Call时request NAV的结果，这里建议在适配时顺手也把Nav时request Call时的结果改了，即nav 不会被call打断在开关打开时。
public void setRejectNavigationOnCallLocked(boolean navigationRejectedWithCall) {
mInteractionMatrix[CarAudioContext.CALL][CarAudioContext.NAVIGATION] =
navigationRejectedWithCall ? INTERACTION_REJECT :
sInteractionMatrix[CarAudioContext.CALL][CarAudioContext.NAVIGATION];
}
setRejectNavigationOnCallLocked会在user发生变化或SettingProvider里的字段发生变化时调用
KEY_AUDIO_FOCUS_NAVIGATION_REJECTED_DURING_CALL =
"android.car.KEY_AUDIO_FOCUS_NAVIGATION_REJECTED_DURING_CALL"
void setUserIdForSettings(@UserIdInt int userId) {
synchronized (mLock) {
mUserId = userId;
if (mContentObserver != null) {
mCarAudioFocusSettings.getContentResolver()
.unregisterContentObserver(mContentObserver);
mContentObserver = null;
}
if (mUserId == UserHandle.USER_NULL) {
setRejectNavigationOnCallLocked(false);
return;
}
mContentObserver = new ContentObserver(new Handler(Looper.getMainLooper())) {
@Override
public void onChange(boolean selfChange, Uri uri) {
if (uri.equals(AUDIO_FOCUS_NAVIGATION_REJECTED_DURING_CALL_URI)) {
navigationOnCallSettingChanged();
}
}
};
mCarAudioFocusSettings.getContentResolver()
.registerContentObserver(AUDIO_FOCUS_NAVIGATION_REJECTED_DURING_CALL_URI,
false, mContentObserver, userId);
setRejectNavigationOnCallLocked(isRejectNavigationOnCallEnabledInSettings(mUserId));
}
}
通过这个逻辑可以扩展nav是压低media还是打断media的开关等等一些其他需要动态修改矩阵的需求
2.5 HalAudioFocus
新增的4中car的system usage实际使用者是AudioControl 2.0，之前的chime音、转向音等非android侧声音都是在hal层或hal以下进行仲裁，现在2.0可以拿到CarAudioService里来一起仲裁了。
AudioControlFactory
使用工厂模式里管理AudioControl 1.0和2.0，优先2.0
public static AudioControlWrapper newAudioControl() {
android.hardware.automotive.audiocontrol.V2_0.IAudioControl audioControlV2 =
AudioControlWrapperV2.getService();
if (audioControlV2 != null) {
return new AudioControlWrapperV2(audioControlV2);
}
Log.i(TAG, "IAudioControl@V2.0 not in the manifest");
android.hardware.automotive.audiocontrol.V1_0.IAudioControl audioControlV1 =
AudioControlWrapperV1.getService();
if (audioControlV1 != null) {
Log.w(TAG, "IAudioControl V1.0 is deprecated. Consider upgrading to V2.0");
return new AudioControlWrapperV1(audioControlV1);
}
throw new IllegalStateException("No version of AudioControl HAL in the manifest");
}
2.0和1.0的区别就是2.0增加焦点模块，1.0不支持。
HalAudioFocus机制
在CarAudioService init时会setupAudioFocusListenerLocked
@Override
public void init() {
setupHalAudioFocusListenerLocked();
}
private void setupHalAudioFocusListenerLocked() {
AudioControlWrapper audioControlWrapper = getAudioControlWrapperLocked();
//目前只有2.0支持
if (!audioControlWrapper.supportsHalAudioFocus()) {
Log.d(CarLog.TAG_AUDIO, "HalAudioFocus is not supported on this device");
return;
}
mHalAudioFocus = new HalAudioFocus(mAudioManager, mAudioControlWrapper, getAudioZoneIds());
mHalAudioFocus.registerFocusListener();
}
HalAudioFocus是IFocusListener的远端实现端
public final class HalAudioFocus extends IFocusListener.Stub {
@Override
public void requestAudioFocus(@AttributeUsage int usage, int zoneId, int focusGain) {}
@Override
public void abandonAudioFocus(int usage, int zoneId) throws RemoteException {}
}
而客户端是AudioControl2.0，IFocusListener.hal定义hidl的接口。
package android.hardware.automotive.audiocontrol@2.0;
import android.hardware.audio.common@6.0::AudioUsage;
/**
* Callback interface for audio focus listener.
*
* For typical configuration, the listener the car audio service.
*/
interface IFocusListener {
oneway requestAudioFocus(bitfield<AudioUsage> usage, int32_t zoneId,
bitfield<AudioFocusChange> focusGain);
oneway abandonAudioFocus(bitfield<AudioUsage> usage, int32_t zoneId);
};
在HalAudioFocus创建之后会紧接着registerFocusListener，在CarAudioService release时会unregisterFocusListener。r然后通过AudioControlWrapperV2到达AudioControl2.0里。
//HalAudioFocus.java
public void registerFocusListener() {
mAudioControlWrapper.registerFocusListener(this);
}
/**
* Unregisters {@code IFocusListener} from {@code AudioControlWrapper}.
*/
public void unregisterFocusListener() {
mAudioControlWrapper.unregisterFocusListener();
}
//AudioControlWrapperV2
@Override
public void registerFocusListener(IFocusListener focusListener) {
Log.d(TAG, "Registering focus listener on AudioControl HAL");
try {
mCloseHandle = mAudioControlV2.registerFocusListener(focusListener);
} catch (RemoteException e) {
Log.e(TAG, "Failed to register focus listener");
throw new IllegalStateException("IAudioControl#registerFocusListener failed", e);
}
}
@Override
public void unregisterFocusListener() {
if (mCloseHandle != null) {
try {
mCloseHandle.close();
} catch (RemoteException e) {
Log.e(TAG, "Failed to close focus listener", e);
} finally {
mCloseHandle = null;
}
}
}
在AudioControl.cpp里有对IAudioControl.hal里registerFocusListener的实现，讲传递过来的mFocusListener暂存，并创建一个CloseHandle返回到HalAudioControl里，用于在unregisterFocusListener时调用CloseHandle的close方法
Return<sp<ICloseHandle>> AudioControl::registerFocusListener(const sp<IFocusListener>& listener) {
LOG(DEBUG) << "registering focus listener";
sp<ICloseHandle> closeHandle(nullptr);
if (listener) {
mFocusListener = listener;
closeHandle = new CloseHandle([this, listener]() {
if (mFocusListener == listener) {
mFocusListener = nullptr;
}
});
} else {
LOG(ERROR) << "Unexpected nullptr for listener resulting in no-op.";
}
return closeHandle;
}
CloseHandle.cpp里有对ICloseHandle.hal的close的实现
CloseHandle::CloseHandle(Callback callback) : mCallback(callback) {}
CloseHandle::~CloseHandle() {
close();
}
Return<void> CloseHandle::close() {
const auto wasClosed = mIsClosed.exchange(true);
if (wasClosed) return {};
if (mCallback) mCallback();
return {};
}
AudioControl.cpp里对于焦点申请给出了示例，cmdRequestFocus通过mFocusListener->requestAudioFocus来申请焦点
void AudioControl::cmdRequestFocus(int fd, const hidl_vec<hidl_string>& options) {
if (!checkCallerHasWritePermissions(fd) || !checkArgumentsSize(fd, options, 3)) return;
hidl_bitfield<AudioUsage> usage;
if (!safelyParseInt(options[1], &usage)) {
dprintf(fd, "Non-integer usage provided with request: %s\n", options[1].c_str());
return;
}
int zoneId;
if (!safelyParseInt(options[2], &zoneId)) {
dprintf(fd, "Non-integer zoneId provided with request: %s\n", options[2].c_str());
return;
}
hidl_bitfield<AudioFocusChange> focusGain;
if (!safelyParseInt(options[3], &focusGain)) {
dprintf(fd, "Non-integer focusGain provided with request: %s\n", options[3].c_str());
return;
}
if (mFocusListener == nullptr) {
dprintf(fd, "Unable to request focus - no focus listener registered\n");
return;
}
//通过hidl 到达HalAudioFocus里进行处理
mFocusListener->requestAudioFocus(usage, zoneId, focusGain);
dprintf(fd, "Requested focus for usage %d, zoneId %d, and focusGain %d\n", usage, zoneId,
focusGain);
}
在收到焦点处理结果，（request和abando都是异步的在这收到结果）
Return<void> AudioControl::onAudioFocusChange(hidl_bitfield<AudioUsage> usage, int zoneId,
hidl_bitfield<AudioFocusChange> focusChange) {
LOG(INFO) << "Focus changed: " << static_cast<int>(focusChange) << " for usage "
<< static_cast<int>(usage) << " in zone " << zoneId;
return Void();
}
放弃焦点
void AudioControl::cmdAbandonFocus(int fd, const hidl_vec<hidl_string>& options) {
if (!checkCallerHasWritePermissions(fd) || !checkArgumentsSize(fd, options, 2)) return;
hidl_bitfield<AudioUsage> usage;
if (!safelyParseInt(options[1], &usage)) {
dprintf(fd, "Non-integer usage provided with abandon: %s\n", options[1].c_str());
return;
}
int zoneId;
if (!safelyParseInt(options[2], &zoneId)) {
dprintf(fd, "Non-integer zoneId provided with abandon: %s\n", options[2].c_str());
return;
}
if (mFocusListener == nullptr) {
dprintf(fd, "Unable to abandon focus - no focus listener registered\n");
return;
}
mFocusListener->abandonAudioFocus(usage, zoneId);
dprintf(fd, "Abandoned focus for usage %d and zoneId %d\n", usage, zoneId);
}
hal AudioFocus处理逻辑
requsetAudioFocus
当AudioControl申请焦点时，通过
mFocusListener->requestAudioFocus(usage, zoneId, focusGain);
申请焦点，HalAudioFocus收到回调requestAudioFocus的回调，会先去mHalFocusRequestsByZoneAndUsage找一下有没有存过仲裁结果（目前逻辑只存可以混音的usage仲裁结果），如果有的话直接通过onAudioFocusChange将mFocusStatus通知到AudioControl里。
@Override
public void requestAudioFocus(@AttributeUsage int usage, int zoneId, int focusGain) {
Preconditions.checkArgument(mHalFocusRequestsByZoneAndUsage.contains(zoneId),
"Invalid zoneId %d provided in requestAudioFocus", zoneId);
if (Log.isLoggable(TAG, Log.DEBUG)) {
Log.d(TAG, "Requesting focus gain " + focusGain + " with usage "
+ AudioAttributes.usageToString(usage) + " and zoneId " + zoneId);
}
synchronized (mLock) {
//获取保存过的处理结果
HalAudioFocusRequest currentRequest = mHalFocusRequestsByZoneAndUsage.get(zoneId).get(
usage);
if (currentRequest != null) {
if (Log.isLoggable(TAG, Log.DEBUG)) {
Log.d(TAG, "A request already exists for zoneId " + zoneId + " and usage "
+ usage);
}
mAudioControlWrapper.onAudioFocusChange(usage, zoneId, currentRequest.mFocusStatus);
} else {
makeAudioFocusRequestLocked(usage, zoneId, focusGain);
}
}
}
如果没有存过话就去重新申请通过makeAudioFocusRequestLocked方法，hal层第一次申请的usage肯定是要创建一个的。
private void makeAudioFocusRequestLocked(@AttributeUsage int usage, int zoneId, int focusGain) {
AudioFocusRequest audioFocusRequest = generateFocusRequestLocked(usage, zoneId, focusGain);
在generateFocusRequestLocked中将hal层传过来的usage zoneId 和请求焦点的类型focusGain，做成一个AudioFocusRequest，并setOnAudioFocusChangeListener回调onAudioFocusChange，即监听该usage被别的usage打断的情况。
private AudioFocusRequest generateFocusRequestLocked(int usage, int zoneId, int focusGain) {
AudioAttributes attributes = generateAudioAttributes(usage, zoneId);
return new AudioFocusRequest.Builder(focusGain)
.setAudioAttributes(attributes)
.setOnAudioFocusChangeListener((int focusChange) -> {
//焦点变化监听 放入AudioFocusRequest中
onAudioFocusChange(usage, zoneId, focusChange);
})
.build();
}
然后通过AudioManger申请焦点，根据外置焦点处理策略，会通过CarAudioFocus进行仲裁处理，默认优先级见2.4 新增仲裁。最后拿到requestResult，如果是成功获取AUDIOFOCUS_REQUEST_GRANTED，就创建一个HalAudioFocusRequest暂存在mHalFocusRequestsByZoneAndUsage里。
其他的结果AUDIOFOCUS_REQUEST_FAILED和AUDIOFOCUS_REQUEST_DELAYED(不支持hal层延时获取)都不存，直接通知hal层AUDIOFOCUS_LOSS。
即mHalFocusRequestsByZoneAndUsage会暂存当前获取到焦点的usage和其audioFocusRequester以及focusGain焦点取得情况
int requestResult = mAudioManager.requestAudioFocus(audioFocusRequest);
int resultingFocusGain = focusGain;
if (requestResult == AUDIOFOCUS_REQUEST_GRANTED) {
HalAudioFocusRequest halAudioFocusRequest = new HalAudioFocusRequest(audioFocusRequest,
focusGain);
mHalFocusRequestsByZoneAndUsage.get(zoneId).append(usage, halAudioFocusRequest);
} else if (requestResult == AUDIOFOCUS_REQUEST_FAILED) {
resultingFocusGain = AUDIOFOCUS_LOSS;
} else if (requestResult == AUDIOFOCUS_REQUEST_DELAYED) {
Log.w(TAG, "Delayed result for request with usage "
+ AudioAttributes.usageToString(usage) + ", zoneId " + zoneId
+ ", and focusGain " + focusGain);
resultingFocusGain = AUDIOFOCUS_LOSS;
}
//通过mAudioControlWrapper 直接将结果通知到hal层
mAudioControlWrapper.onAudioFocusChange(usage, zoneId, resultingFocusGain);
}
onAudioFocusChange
在看一下FocuschangeListener，就是在申请焦点时的焦点变化通知，只会处理焦点还处于暂存状态的usage，已经丢失或者申请不成功的不会处理。
会先取暂存状态如果是AUDIOFOCUS_LOSS，就将暂存的状态移除。最后调用mAudioControlWrapper.onAudioFocusChange通知到Hal层。
private void onAudioFocusChange(int usage, int zoneId, int focusChange) {
synchronized (mLock) {
HalAudioFocusRequest currentRequest = mHalFocusRequestsByZoneAndUsage.get(zoneId).get(
usage);
if (currentRequest != null) {
if (focusChange == AUDIOFOCUS_LOSS) {
mHalFocusRequestsByZoneAndUsage.get(zoneId).remove(usage);
} else {
currentRequest.mFocusStatus = focusChange;
}
mAudioControlWrapper.onAudioFocusChange(usage, zoneId, focusChange);
}
}
}
abandonAudioFocus
放弃焦点逻辑就简单些了，先去暂存的SparseArray里找一下，如果为空（没有找到），说明之前也没有成功不用处理。
如果存在，通过mAudioManager.abandonAudioFocusRequest（存下AudioFocusRequester），走一下abandon流程，最后将结果通知到hal层。
private void abandonAudioFocusLocked(int usage, int zoneId) {
HalAudioFocusRequest currentRequest = mHalFocusRequestsByZoneAndUsage.get(zoneId)
.removeReturnOld(usage);
if (currentRequest == null) {
if (Log.isLoggable(TAG, Log.DEBUG)) {
Log.d(TAG, "No focus to abandon for usage " + AudioAttributes.usageToString(usage)
+ " and zoneId " + zoneId);
}
return;
}
int result = mAudioManager.abandonAudioFocusRequest(currentRequest.mAudioFocusRequest);
if (result == AUDIOFOCUS_REQUEST_GRANTED) {
if (Log.isLoggable(TAG, Log.DEBUG)) {
Log.d(TAG, "Abandoned focus for usage " + AudioAttributes.usageToString(usage)
+ "and zoneId " + zoneId);
}
mAudioControlWrapper.onAudioFocusChange(usage, zoneId, AUDIOFOCUS_LOSS);
} else {
Log.w(TAG,
"Failed to abandon focus for usage " + AudioAttributes.usageToString(usage)
+ " and zoneId " + zoneId);
}
}
2.6 CarVolume getSuggestedAudioContext
R上还有一个针对getSuggestedAudioContext小改动，之前策略都是通话状态优先，之后是获取最后一个活跃的playback。显然这个和复杂的需求对不上，方控调节音量或者mute音量也应该有自己的优先级的。R上就增加了这个逻辑。
首先定义出优先级来
private static final int[] AUDIO_CONTEXT_VOLUME_PRIORITY = {
CarAudioContext.NAVIGATION,
CarAudioContext.CALL,
CarAudioContext.MUSIC,
CarAudioContext.ANNOUNCEMENT,
CarAudioContext.VOICE_COMMAND,
CarAudioContext.CALL_RING,
CarAudioContext.SYSTEM_SOUND,
CarAudioContext.SAFETY,
CarAudioContext.ALARM,
CarAudioContext.NOTIFICATION,
CarAudioContext.VEHICLE_STATUS,
CarAudioContext.EMERGENCY,
// CarAudioContext.INVALID is intentionally not prioritized as it is not routed by
// CarAudioService and is not expected to be used.
};
之后通过遍历查找当前获取的playback，并根据优先最后拿到一个suggest的context。
static @AudioContext int getSuggestedAudioContext(
List<AudioPlaybackConfiguration> configurations, @CallState int callState) {
int currentContext = DEFAULT_AUDIO_CONTEXT;
int currentPriority = AUDIO_CONTEXT_VOLUME_PRIORITY.length;
//还是通话状态优先。
if (callState == TelephonyManager.CALL_STATE_RINGING) {
currentContext = CarAudioContext.CALL_RING;
currentPriority = VOLUME_PRIORITY_BY_AUDIO_CONTEXT.get(CarAudioContext.CALL_RING);
} else if (callState == TelephonyManager.CALL_STATE_OFFHOOK) {
currentContext = CarAudioContext.CALL;
currentPriority = VOLUME_PRIORITY_BY_AUDIO_CONTEXT.get(CarAudioContext.CALL);
}
//遍历活跃playback
for (AudioPlaybackConfiguration configuration : configurations) {
if (!configuration.isActive()) {
continue;
}
@AttributeUsage int usage = configuration.getAudioAttributes().getSystemUsage();
@AudioContext int context = CarAudioContext.getContextForUsage(usage);
int priority = VOLUME_PRIORITY_BY_AUDIO_CONTEXT.get(context, CONTEXT_NOT_PRIORITIZED);
if (priority == CONTEXT_NOT_PRIORITIZED) {
Log.w(TAG, "Usage " + AudioAttributes.usageToString(usage) + " mapped to context "
+ CarAudioContext.toString(context) + " which is not prioritized");
continue;
}
if (priority < currentPriority) {
currentContext = context;
currentPriority = priority;
}
}
return currentContext;
}
2.7 CarOccupant模块联动
getzoneIdForDisplay API的取消，就是因为R上新增了这个模块。CarOccupant是用于管理Display和user的模块。
occupantZone占用着Zone类似视图Zone，具体如何使用还待后续调查分析，这里不做深入。
通过CarOccupantZoneServiceTest中可以看到zone的分区（occupantZone），occupantZoneId，occupantType等成员变量的示例，猜测是用于管理仪表屏，中控，后排的模块。
private static final String[] DEFAULT_OCCUPANT_ZONES = {
"occupantZoneId=0,occupantType=DRIVER,seatRow=1,seatSide=driver",
"occupantZoneId=1,occupantType=FRONT_PASSENGER,seatRow=1,seatSide=oppositeDriver",
"occupantZoneId=2,occupantType=REAR_PASSENGER,seatRow=2,seatSide=left",
"occupantZoneId=3,occupantType=REAR_PASSENGER,seatRow=2,seatSide=right"
};
然后也有displayPort和displayType occupantZoneId的map关系，比较复杂，就不细看了。
private static final String[] DEFAULT_OCCUPANT_DISPLAY_MAPPING = {
"displayPort=10,displayType=MAIN,occupantZoneId=0",
"displayPort=11,displayType=INSTRUMENT_CLUSTER,occupantZoneId=0",
"displayPort=12,displayType=MAIN,occupantZoneId=1",
"displayPort=13,displayType=MAIN,occupantZoneId=2",
"displayPort=14,displayType=MAIN,occupantZoneId=3"
};
只看看和CarAudio的联动，CarAudioService在设置动态路由的时候，也setup了OccupantZoneInfo。
private OccupantZoneConfigChangeListener
mOccupantZoneConfigChangeListener = new CarAudioOccupantConfigChangeListener();
/*
mZoneIdToOccupantZoneIdMapping是在解析xml时，获取的audioZoneId和occupantZoneId的关系
mZoneIdToOccupantZoneIdMapping.put(audioZoneId, occupantZoneId);
//CarLocalService 可以更方便的获取本地Car的其他服务模块了
mOccupantZoneService = CarLocalServices.getService(CarOccupantZoneService.class);
Car car = new Car(mContext, (service=) null, (handler= ) null);
mOccupantZoneManager = new CarOccupantZoneManager(car, mOccupantZoneService);
*/
private void setupOccupantZoneInfo() {
CarOccupantZoneService occupantZoneService;
CarOccupantZoneManager occupantZoneManager;
SparseIntArray audioZoneIdToOccupantZoneMapping;
OccupantZoneConfigChangeListener listener;
synchronized (mImplLock) {
audioZoneIdToOccupantZoneMapping = mAudioZoneIdToOccupantZoneIdMapping;
occupantZoneService = mOccupantZoneService;
occupantZoneManager = mOccupantZoneManager;
listener = mOccupantZoneConfigChangeListener;
}
occupantZoneService.setAudioZoneIdsForOccupantZoneIds(audioZoneIdToOccupantZoneMapping);
occupantZoneManager.registerOccupantZoneConfigChangeListener(listener);
}
看下CarAudioOccupantConfigChangeListener，CarOccupant模块联动CarAudio的入口。
private class CarAudioOccupantConfigChangeListener implements OccupantZoneConfigChangeListener {
@Override
public void onOccupantZoneConfigChanged(int flags) {
if (Log.isLoggable(CarLog.TAG_AUDIO, Log.DEBUG)) {
Log.d(CarLog.TAG_AUDIO,
"onOccupantZoneConfigChanged(" + flags + ")");
}
//当用户user或者display发生变化时，对OccupantZone的变化进行处理
if (((flags & CarOccupantZoneManager.ZONE_CONFIG_CHANGE_FLAG_USER)
== CarOccupantZoneManager.ZONE_CONFIG_CHANGE_FLAG_USER)
|| ((flags & CarOccupantZoneManager.ZONE_CONFIG_CHANGE_FLAG_DISPLAY)
== CarOccupantZoneManager.ZONE_CONFIG_CHANGE_FLAG_DISPLAY)) {
handleOccupantZoneUserChanged();
}
}
}
handleOccupantZoneUserChanged
处理OccupantZoneUserChanged
private boolean isOccupantZoneMappingAvailable() {
return mAudioZoneIdToOccupantZoneIdMapping.size() > 0;
}
private void handleOccupantZoneUserChanged() {
int driverUserId = mOccupantZoneService.getDriverUserId();
synchronized (mImplLock) {
//如果audioZone和OccupantZoneId没有关联，只重新设置下user的setting
if (!isOccupantZoneMappingAvailable()) {
//No occupant zone to audio zone mapping, re-adjust to settings driver.
for (int index = 0; index < mCarAudioZones.length; index++) {
CarAudioZone zone = mCarAudioZones[index];
zone.updateVolumeGroupsForUser(driverUserId);
//根据user的设置 动态更新矩阵 详见 2.4矩阵动态更新
mFocusHandler.updateUserForZoneId(zone.getId(), driverUserId);
}
return;
}
如果AudioZone和OccupantZone有关联，逻辑就比较复杂了，先要getOccupantZoneIdForDriver
//Method handleOccupantZoneUserChanged 2
int occupantZoneForDriver = getOccupantZoneIdForDriver();
/*
通过CarOccupantZoneManager遍历所有的ZoneId，拿到OCCUPANT_TYPE_DRIVER驾驶员的occupantZone
*/
private int getOccupantZoneIdForDriver() {
List<CarOccupantZoneManager.OccupantZoneInfo> occupantZoneInfos =
mOccupantZoneManager.getAllOccupantZones();
for (CarOccupantZoneManager.OccupantZoneInfo info: occupantZoneInfos) {
if (info.occupantType == CarOccupantZoneManager.OCCUPANT_TYPE_DRIVER) {
return info.zoneId;
}
}
return CarOccupantZoneManager.OccupantZoneInfo.INVALID_ZONE_ID;
}
然后遍历mAudioZoneIdToOccupantZoneIdMapping，update一下audioZoneId，occupantZoneId，driverUserId，occupantZoneForDriver四者的关系。
//Method handleOccupantZoneUserChanged 3
for (int index = 0; index < mAudioZoneIdToOccupantZoneIdMapping.size(); index++) {
int audioZoneId = mAudioZoneIdToOccupantZoneIdMapping.keyAt(index);
int occupantZoneId = mAudioZoneIdToOccupantZoneIdMapping.get(audioZoneId);
updateUserForOccupantZoneLocked(occupantZoneId, audioZoneId, driverUserId,
occupantZoneForDriver);
}
}
}
updateUserForOccupantZoneLocked
主要更新三点
1.如果userId发生了变化，先移除AudioPolicyMixer里的关于 userId的match。然后如果新的userId和driverId不相等（且新的不为空），设置该zone里的AudioDevice和userId绑定，在AudioPolicyManager里getOutput通过RULE_MATCH_USERID match。
（猜测：由于在设置动态路由的时候，audioMixer的Rule设置的是RULE_MATCH_ATTRIBUTE_USAGE，且CarService里没有RULE_MATCH_USERID 和RULE_EXCLUDE_USERID使用的地方。所以目前没有太大的作用，可能是用于录音设备的match，给出的car_audio_configuration 示例中有些zone里没有对应的InputDevice，以后用到了再看）
//method setupAudioDynamicRoutingForGroup
for (int usage : usages) {
AudioAttributes attributes = buildAttributesWithUsage(usage);
mixingRuleBuilder.addRule(attributes,
AudioMixingRule.RULE_MATCH_ATTRIBUTE_USAGE);
}
2.如果新的user为空，resetZoneToDefaultUser重新设置动态路由设置和zone的音量设置到默认用户设置
3.如果新的user不为空，会跟新到新的user的动态路由设置和zone的音量设置
private void updateUserForOccupantZoneLocked(int occupantZoneId, int audioZoneId,
@UserIdInt int driverUserId, int occupantZoneForDriver) {
CarAudioZone zone = getAudioZoneForZoneIdLocked(audioZoneId);
int userId = mOccupantZoneService.getUserForOccupant(occupantZoneId);
int prevUserId = getUserIdForZoneLocked(audioZoneId);
Objects.requireNonNull(zone, () ->
"setUserIdDeviceAffinity for userId " + userId
+ " in zone " + audioZoneId + " Failed, invalid zone.");
// user in occupant zone has not changed
if (userId == prevUserId) {
return;
}
// If the user has changed, be sure to remove from current routing
// This would be true even if the new user is UserHandle.USER_NULL,
// as that indicates the user has logged out.
removeUserIdDeviceAffinitiesLocked(prevUserId);
if (userId == UserHandle.USER_NULL) {
// Reset zone back to driver user id
resetZoneToDefaultUser(zone, driverUserId);
return;
}
// Only set user id device affinities for driver when it is the driver's occupant zone
if (userId != driverUserId || occupantZoneId == occupantZoneForDriver) {
setUserIdDeviceAffinitiesLocked(zone, userId, audioZoneId);
mAudioZoneIdToUserIdMapping.put(audioZoneId, userId);
}
zone.updateVolumeGroupsForUser(userId);
mFocusHandler.updateUserForZoneId(audioZoneId, userId);
}
版权声明：本文为sinat_18179367原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。