diff --git a/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/CodecInfo.aidl b/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/CodecInfo.aidl index 2ca9d9648b..2727d6e840 100644 --- a/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/CodecInfo.aidl +++ b/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/CodecInfo.aidl @@ -49,7 +49,15 @@ parcelable CodecInfo { int outputDataPath = 1; boolean useControllerCodec = true; } + parcelable LeAudio { + android.hardware.bluetooth.audio.ChannelMode[] channelMode; + int[] samplingFrequencyHz; + int[] frameDurationUs; + int[] bitdepth; + @nullable android.hardware.bluetooth.audio.ConfigurationFlags flags; + } union Transport { + android.hardware.bluetooth.audio.CodecInfo.LeAudio leAudio; android.hardware.bluetooth.audio.CodecInfo.A2dp a2dp; android.hardware.bluetooth.audio.CodecInfo.Hfp hfp; } diff --git a/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/CodecSpecificCapabilitiesLtv.aidl b/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/CodecSpecificCapabilitiesLtv.aidl new file mode 100644 index 0000000000..1049d983fb --- /dev/null +++ b/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/CodecSpecificCapabilitiesLtv.aidl @@ -0,0 +1,83 @@ +/* + * Copyright 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. + */ +/////////////////////////////////////////////////////////////////////////////// +// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // +/////////////////////////////////////////////////////////////////////////////// + +// This file is a snapshot of an AIDL file. Do not edit it manually. There are +// two cases: +// 1). this is a frozen version file - do not edit this in any case. +// 2). this is a 'current' file. If you make a backwards compatible change to +// the interface (from the latest frozen version), the build system will +// prompt you to update this file with `m -update-api`. +// +// You must not make a backward incompatible change to any AIDL file built +// with the aidl_interface module type with versions property set. The module +// type is used to build AIDL files in a way that they can be used across +// independently updatable components of the system. If a device is shipped +// with such a backward incompatible change, it has a high risk of breaking +// later when a module using the interface is updated, e.g., Mainline modules. + +package android.hardware.bluetooth.audio; +@VintfStability +union CodecSpecificCapabilitiesLtv { + android.hardware.bluetooth.audio.CodecSpecificCapabilitiesLtv.SupportedSamplingFrequencies supportedSamplingFrequencies; + android.hardware.bluetooth.audio.CodecSpecificCapabilitiesLtv.SupportedFrameDurations supportedFrameDurations; + android.hardware.bluetooth.audio.CodecSpecificCapabilitiesLtv.SupportedAudioChannelCounts supportedAudioChannelCounts; + android.hardware.bluetooth.audio.CodecSpecificCapabilitiesLtv.SupportedOctetsPerCodecFrame supportedOctetsPerCodecFrame; + android.hardware.bluetooth.audio.CodecSpecificCapabilitiesLtv.SupportedMaxCodecFramesPerSDU supportedMaxCodecFramesPerSDU; + parcelable SupportedSamplingFrequencies { + int bitmask; + const int HZ8000 = 0x0001; + const int HZ11025 = 0x0002; + const int HZ16000 = 0x0004; + const int HZ22050 = 0x0008; + const int HZ24000 = 0x0010; + const int HZ32000 = 0x0020; + const int HZ44100 = 0x0040; + const int HZ48000 = 0x0080; + const int HZ88200 = 0x0100; + const int HZ96000 = 0x0200; + const int HZ176400 = 0x0400; + const int HZ192000 = 0x0800; + const int HZ384000 = 0x1000; + } + parcelable SupportedFrameDurations { + int bitmask; + const int US7500 = 0x01; + const int US10000 = 0x02; + const int US7500PREFERRED = 0x10; + const int US10000PREFERRED = 0x20; + } + parcelable SupportedAudioChannelCounts { + int bitmask; + const int ONE = 0x01; + const int TWO = 0x02; + const int THREE = 0x04; + const int FOUR = 0x08; + const int FIVE = 0x10; + const int SIX = 0x20; + const int SEVEN = 0x40; + const int EIGHT = 0x80; + } + parcelable SupportedOctetsPerCodecFrame { + int minimum; + int maximum; + } + parcelable SupportedMaxCodecFramesPerSDU { + int value; + } +} diff --git a/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/CodecSpecificConfigurationLtv.aidl b/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/CodecSpecificConfigurationLtv.aidl new file mode 100644 index 0000000000..943d396aec --- /dev/null +++ b/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/CodecSpecificConfigurationLtv.aidl @@ -0,0 +1,101 @@ +/* + * Copyright 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. + */ +/////////////////////////////////////////////////////////////////////////////// +// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // +/////////////////////////////////////////////////////////////////////////////// + +// This file is a snapshot of an AIDL file. Do not edit it manually. There are +// two cases: +// 1). this is a frozen version file - do not edit this in any case. +// 2). this is a 'current' file. If you make a backwards compatible change to +// the interface (from the latest frozen version), the build system will +// prompt you to update this file with `m -update-api`. +// +// You must not make a backward incompatible change to any AIDL file built +// with the aidl_interface module type with versions property set. The module +// type is used to build AIDL files in a way that they can be used across +// independently updatable components of the system. If a device is shipped +// with such a backward incompatible change, it has a high risk of breaking +// later when a module using the interface is updated, e.g., Mainline modules. + +package android.hardware.bluetooth.audio; +@VintfStability +union CodecSpecificConfigurationLtv { + android.hardware.bluetooth.audio.CodecSpecificConfigurationLtv.CodecFrameBlocksPerSDU codecFrameBlocksPerSDU; + android.hardware.bluetooth.audio.CodecSpecificConfigurationLtv.SamplingFrequency samplingFrequency; + android.hardware.bluetooth.audio.CodecSpecificConfigurationLtv.FrameDuration frameDuration; + android.hardware.bluetooth.audio.CodecSpecificConfigurationLtv.AudioChannelAllocation audioChannelAllocation; + android.hardware.bluetooth.audio.CodecSpecificConfigurationLtv.OctetsPerCodecFrame octetsPerCodecFrame; + @Backing(type="byte") + enum SamplingFrequency { + HZ8000 = 0x01, + HZ11025 = 0x02, + HZ16000 = 0x03, + HZ22050 = 0x04, + HZ24000 = 0x05, + HZ32000 = 0x06, + HZ44100 = 0x07, + HZ48000 = 0x08, + HZ88200 = 0x09, + HZ96000 = 0x0A, + HZ176400 = 0x0B, + HZ192000 = 0x0C, + HZ384000 = 0x0D, + } + @Backing(type="byte") + enum FrameDuration { + US7500 = 0x00, + US10000 = 0x01, + } + parcelable AudioChannelAllocation { + int bitmask; + const int NOT_ALLOWED = 0x00000000; + const int FRONT_LEFT = 0x00000001; + const int FRONT_RIGHT = 0x00000002; + const int FRONT_CENTER = 0x00000004; + const int LOW_FREQUENCY_EFFECTS_1 = 0x00000008; + const int BACK_LEFT = 0x00000010; + const int BACK_RIGHT = 0x00000020; + const int FRONT_LEFT_OF_CENTER = 0x00000040; + const int FRONT_RIGHT_OF_CENTER = 0x00000080; + const int BACK_CENTER = 0x00000100; + const int LOW_FREQUENCY_EFFECTS_2 = 0x00000200; + const int SIDE_LEFT = 0x00000400; + const int SIDE_RIGHT = 0x00000800; + const int TOP_FRONT_LEFT = 0x00001000; + const int TOP_FRONT_RIGHT = 0x00002000; + const int TOP_FRONT_CENTER = 0x00004000; + const int TOP_CENTER = 0x00008000; + const int TOP_BACK_LEFT = 0x00010000; + const int TOP_BACK_RIGHT = 0x00020000; + const int TOP_SIDE_LEFT = 0x00040000; + const int TOP_SIDE_RIGHT = 0x00080000; + const int TOP_BACK_CENTER = 0x00100000; + const int BOTTOM_FRONT_CENTER = 0x00200000; + const int BOTTOM_FRONT_LEFT = 0x00400000; + const int BOTTOM_FRONT_RIGHT = 0x00800000; + const int FRONT_LEFT_WIDE = 0x01000000; + const int FRONT_RIGHT_WIDE = 0x02000000; + const int LEFT_SURROUND = 0x04000000; + const int RIGHT_SURROUND = 0x08000000; + } + parcelable OctetsPerCodecFrame { + int value; + } + parcelable CodecFrameBlocksPerSDU { + int value; + } +} diff --git a/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/ConfigurationFlags.aidl b/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/ConfigurationFlags.aidl new file mode 100644 index 0000000000..baf0a4e9f6 --- /dev/null +++ b/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/ConfigurationFlags.aidl @@ -0,0 +1,45 @@ +/* + * Copyright 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. + */ +/////////////////////////////////////////////////////////////////////////////// +// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // +/////////////////////////////////////////////////////////////////////////////// + +// This file is a snapshot of an AIDL file. Do not edit it manually. There are +// two cases: +// 1). this is a frozen version file - do not edit this in any case. +// 2). this is a 'current' file. If you make a backwards compatible change to +// the interface (from the latest frozen version), the build system will +// prompt you to update this file with `m -update-api`. +// +// You must not make a backward incompatible change to any AIDL file built +// with the aidl_interface module type with versions property set. The module +// type is used to build AIDL files in a way that they can be used across +// independently updatable components of the system. If a device is shipped +// with such a backward incompatible change, it has a high risk of breaking +// later when a module using the interface is updated, e.g., Mainline modules. + +package android.hardware.bluetooth.audio; +@VintfStability +parcelable ConfigurationFlags { + int bitmask; + const int NONE = 0x0000; + const int LOSSLESS = 0x0001; + const int LOW_LATENCY = 0x0002; + const int ALLOW_ASYMMETRIC_CONFIGURATIONS = 0x0003; + const int SPATIAL_AUDIO = 0x0004; + const int PROVIDE_ASE_METADATA = 0x0005; + const int MONO_MIC_CONFIGURATION = 0x0006; +} diff --git a/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/IBluetoothAudioProvider.aidl b/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/IBluetoothAudioProvider.aidl index ccf5524bf1..788e38f0e9 100644 --- a/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/IBluetoothAudioProvider.aidl +++ b/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/IBluetoothAudioProvider.aidl @@ -42,4 +42,112 @@ interface IBluetoothAudioProvider { void setLowLatencyModeAllowed(in boolean allowed); android.hardware.bluetooth.audio.A2dpStatus parseA2dpConfiguration(in android.hardware.bluetooth.audio.CodecId codecId, in byte[] configuration, out android.hardware.bluetooth.audio.CodecParameters codecParameters); @nullable android.hardware.bluetooth.audio.A2dpConfiguration getA2dpConfiguration(in List remoteA2dpCapabilities, in android.hardware.bluetooth.audio.A2dpConfigurationHint hint); + void setCodecPriority(in android.hardware.bluetooth.audio.CodecId codecId, int priority); + List getLeAudioAseConfiguration(in @nullable List remoteSinkAudioCapabilities, in @nullable List remoteSourceAudioCapabilities, in List requirements); + android.hardware.bluetooth.audio.IBluetoothAudioProvider.LeAudioAseQosConfigurationPair getLeAudioAseQosConfiguration(in android.hardware.bluetooth.audio.IBluetoothAudioProvider.LeAudioAseQosConfigurationRequirement qosRequirement); + android.hardware.bluetooth.audio.IBluetoothAudioProvider.LeAudioDataPathConfigurationPair getLeAudioAseDatapathConfiguration(in android.hardware.bluetooth.audio.AudioContext context, in android.hardware.bluetooth.audio.LeAudioConfiguration.StreamMap[] streamMap); + void onSinkAseMetadataChanged(in android.hardware.bluetooth.audio.IBluetoothAudioProvider.AseState state, int cigId, int cisId, in @nullable android.hardware.bluetooth.audio.MetadataLtv[] metadata); + void onSourceAseMetadataChanged(in android.hardware.bluetooth.audio.IBluetoothAudioProvider.AseState state, int cigId, int cisId, in @nullable android.hardware.bluetooth.audio.MetadataLtv[] metadata); + @VintfStability + parcelable LeAudioDeviceCapabilities { + android.hardware.bluetooth.audio.CodecId codecId; + android.hardware.bluetooth.audio.CodecSpecificCapabilitiesLtv[] codecSpecificCapabilities; + @nullable byte[] vendorCodecSpecificCapabilities; + @nullable android.hardware.bluetooth.audio.MetadataLtv[] metadata; + } + @VintfStability + parcelable LeAudioDataPathConfiguration { + int dataPathId; + android.hardware.bluetooth.audio.IBluetoothAudioProvider.LeAudioDataPathConfiguration.DataPathConfiguration dataPathConfiguration; + android.hardware.bluetooth.audio.IBluetoothAudioProvider.LeAudioDataPathConfiguration.IsoDataPathConfiguration isoDataPathConfiguration; + @VintfStability + parcelable IsoDataPathConfiguration { + android.hardware.bluetooth.audio.CodecId codecId; + boolean isTransparent; + int controllerDelayUs; + @nullable byte[] configuration; + } + @VintfStability + parcelable DataPathConfiguration { + @nullable byte[] configuration; + } + } + @VintfStability + parcelable LeAudioAseQosConfiguration { + int sduIntervalUs; + android.hardware.bluetooth.audio.IBluetoothAudioProvider.Framing framing; + android.hardware.bluetooth.audio.Phy[] phy; + int maxTransportLatencyMs; + int maxSdu; + int retransmissionNum; + } + @Backing(type="byte") @VintfStability + enum Packing { + SEQUENTIAL = 0x00, + INTERLEAVED = 0x01, + } + @Backing(type="byte") @VintfStability + enum Framing { + UNFRAMED = 0x00, + FRAMED = 0x01, + } + @VintfStability + parcelable LeAudioAseConfigurationSetting { + android.hardware.bluetooth.audio.AudioContext audioContext; + android.hardware.bluetooth.audio.IBluetoothAudioProvider.Packing packing; + @nullable List sinkAseConfiguration; + @nullable List sourceAseConfiguration; + @nullable android.hardware.bluetooth.audio.ConfigurationFlags flags; + @VintfStability + parcelable AseDirectionConfiguration { + android.hardware.bluetooth.audio.LeAudioAseConfiguration aseConfiguration; + @nullable android.hardware.bluetooth.audio.IBluetoothAudioProvider.LeAudioAseQosConfiguration qosConfiguration; + @nullable android.hardware.bluetooth.audio.IBluetoothAudioProvider.LeAudioDataPathConfiguration dataPathConfiguration; + } + } + @VintfStability + parcelable LeAudioConfigurationRequirement { + android.hardware.bluetooth.audio.AudioContext audioContext; + @nullable List sinkAseRequirement; + @nullable List sourceAseRequirement; + @nullable android.hardware.bluetooth.audio.ConfigurationFlags flags; + @VintfStability + parcelable AseDirectionRequirement { + android.hardware.bluetooth.audio.LeAudioAseConfiguration aseConfiguration; + } + } + @VintfStability + parcelable LeAudioAseQosConfigurationRequirement { + android.hardware.bluetooth.audio.AudioContext contextType; + @nullable android.hardware.bluetooth.audio.IBluetoothAudioProvider.LeAudioAseQosConfigurationRequirement.AseQosDirectionRequirement sinkAseQosRequirement; + @nullable android.hardware.bluetooth.audio.IBluetoothAudioProvider.LeAudioAseQosConfigurationRequirement.AseQosDirectionRequirement sourceAseQosRequirement; + @nullable android.hardware.bluetooth.audio.ConfigurationFlags[] flags; + @VintfStability + parcelable AseQosDirectionRequirement { + android.hardware.bluetooth.audio.IBluetoothAudioProvider.Framing framing; + android.hardware.bluetooth.audio.Phy[] preferredPhy; + int preferredRetransmissionNum; + int maxTransportLatencyMs; + int presentationDelayMinUs; + int presentationDelayMaxUs; + int preferredPresentationDelayMinUs; + int preferredPresentationDelayMaxUs; + android.hardware.bluetooth.audio.LeAudioAseConfiguration aseConfiguration; + } + } + @VintfStability + parcelable LeAudioAseQosConfigurationPair { + @nullable android.hardware.bluetooth.audio.IBluetoothAudioProvider.LeAudioAseQosConfiguration sinkQosConfiguration; + @nullable android.hardware.bluetooth.audio.IBluetoothAudioProvider.LeAudioAseQosConfiguration sourceQosConfiguration; + } + parcelable LeAudioDataPathConfigurationPair { + @nullable android.hardware.bluetooth.audio.IBluetoothAudioProvider.LeAudioDataPathConfiguration inputConfig; + @nullable android.hardware.bluetooth.audio.IBluetoothAudioProvider.LeAudioDataPathConfiguration outputConfig; + } + @Backing(type="byte") @VintfStability + enum AseState { + ENABLING = 0x00, + STREAMING = 0x01, + DISABLING = 0x02, + } } diff --git a/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/IBluetoothAudioProviderFactory.aidl b/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/IBluetoothAudioProviderFactory.aidl index c806b0a001..edb79a3da0 100644 --- a/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/IBluetoothAudioProviderFactory.aidl +++ b/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/IBluetoothAudioProviderFactory.aidl @@ -41,5 +41,6 @@ interface IBluetoothAudioProviderFactory { parcelable ProviderInfo { String name; android.hardware.bluetooth.audio.CodecInfo[] codecInfos; + boolean supportsMultidirectionalCapabilities; } } diff --git a/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/LeAudioAseConfiguration.aidl b/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/LeAudioAseConfiguration.aidl new file mode 100644 index 0000000000..bffc88b352 --- /dev/null +++ b/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/LeAudioAseConfiguration.aidl @@ -0,0 +1,50 @@ +/* + * Copyright 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. + */ +/////////////////////////////////////////////////////////////////////////////// +// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // +/////////////////////////////////////////////////////////////////////////////// + +// This file is a snapshot of an AIDL file. Do not edit it manually. There are +// two cases: +// 1). this is a frozen version file - do not edit this in any case. +// 2). this is a 'current' file. If you make a backwards compatible change to +// the interface (from the latest frozen version), the build system will +// prompt you to update this file with `m -update-api`. +// +// You must not make a backward incompatible change to any AIDL file built +// with the aidl_interface module type with versions property set. The module +// type is used to build AIDL files in a way that they can be used across +// independently updatable components of the system. If a device is shipped +// with such a backward incompatible change, it has a high risk of breaking +// later when a module using the interface is updated, e.g., Mainline modules. + +package android.hardware.bluetooth.audio; +@VintfStability +parcelable LeAudioAseConfiguration { + android.hardware.bluetooth.audio.LeAudioAseConfiguration.TargetLatency targetLatency; + android.hardware.bluetooth.audio.Phy targetPhy; + @nullable android.hardware.bluetooth.audio.CodecId codecId; + android.hardware.bluetooth.audio.CodecSpecificConfigurationLtv[] codecConfiguration; + @nullable byte[] vendorCodecConfiguration; + @nullable android.hardware.bluetooth.audio.MetadataLtv[] metadata; + @Backing(type="byte") @VintfStability + enum TargetLatency { + UNDEFINED = 0x00, + LOWER = 0x01, + BALANCED_LATENCY_RELIABILITY = 0x02, + HIGHER_RELIABILITY = 0x03, + } +} diff --git a/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/LeAudioConfiguration.aidl b/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/LeAudioConfiguration.aidl index 2d9ebae9f4..25a9797daf 100644 --- a/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/LeAudioConfiguration.aidl +++ b/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/LeAudioConfiguration.aidl @@ -44,5 +44,16 @@ parcelable LeAudioConfiguration { char streamHandle; int audioChannelAllocation; boolean isStreamActive; + @nullable android.hardware.bluetooth.audio.LeAudioAseConfiguration aseConfiguration; + @nullable android.hardware.bluetooth.audio.ConfigurationFlags flags; + @nullable android.hardware.bluetooth.audio.LeAudioConfiguration.StreamMap.BluetoothDeviceAddress bluetoothDeviceAddress; + parcelable BluetoothDeviceAddress { + byte[6] deviceAddress; + android.hardware.bluetooth.audio.LeAudioConfiguration.StreamMap.BluetoothDeviceAddress.DeviceAddressType deviceAddressType; + enum DeviceAddressType { + BLE_ADDRESS_PUBLIC = 0x00, + BLE_ADDRESS_RANDOM = 0x01, + } + } } } diff --git a/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/MetadataLtv.aidl b/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/MetadataLtv.aidl new file mode 100644 index 0000000000..5e8a2ae25d --- /dev/null +++ b/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/MetadataLtv.aidl @@ -0,0 +1,50 @@ +/* + * Copyright 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. + */ +/////////////////////////////////////////////////////////////////////////////// +// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // +/////////////////////////////////////////////////////////////////////////////// + +// This file is a snapshot of an AIDL file. Do not edit it manually. There are +// two cases: +// 1). this is a frozen version file - do not edit this in any case. +// 2). this is a 'current' file. If you make a backwards compatible change to +// the interface (from the latest frozen version), the build system will +// prompt you to update this file with `m -update-api`. +// +// You must not make a backward incompatible change to any AIDL file built +// with the aidl_interface module type with versions property set. The module +// type is used to build AIDL files in a way that they can be used across +// independently updatable components of the system. If a device is shipped +// with such a backward incompatible change, it has a high risk of breaking +// later when a module using the interface is updated, e.g., Mainline modules. + +package android.hardware.bluetooth.audio; +@VintfStability +union MetadataLtv { + android.hardware.bluetooth.audio.MetadataLtv.PreferredAudioContexts preferredAudioContexts; + android.hardware.bluetooth.audio.MetadataLtv.StreamingAudioContexts streamingAudioContexts; + android.hardware.bluetooth.audio.MetadataLtv.VendorSpecific vendorSpecific; + parcelable PreferredAudioContexts { + android.hardware.bluetooth.audio.AudioContext values; + } + parcelable StreamingAudioContexts { + android.hardware.bluetooth.audio.AudioContext values; + } + parcelable VendorSpecific { + int companyId; + byte[] opaqueValue; + } +} diff --git a/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/Phy.aidl b/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/Phy.aidl new file mode 100644 index 0000000000..bfeabcd5a5 --- /dev/null +++ b/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/Phy.aidl @@ -0,0 +1,41 @@ +/* + * Copyright 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. + */ +/////////////////////////////////////////////////////////////////////////////// +// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // +/////////////////////////////////////////////////////////////////////////////// + +// This file is a snapshot of an AIDL file. Do not edit it manually. There are +// two cases: +// 1). this is a frozen version file - do not edit this in any case. +// 2). this is a 'current' file. If you make a backwards compatible change to +// the interface (from the latest frozen version), the build system will +// prompt you to update this file with `m -update-api`. +// +// You must not make a backward incompatible change to any AIDL file built +// with the aidl_interface module type with versions property set. The module +// type is used to build AIDL files in a way that they can be used across +// independently updatable components of the system. If a device is shipped +// with such a backward incompatible change, it has a high risk of breaking +// later when a module using the interface is updated, e.g., Mainline modules. + +package android.hardware.bluetooth.audio; +@Backing(type="byte") @VintfStability +enum Phy { + UNDEFINED = 0x00, + ONE_M = 0x01, + TWO_M = 0x02, + CODED = 0x03, +} diff --git a/bluetooth/audio/aidl/android/hardware/bluetooth/audio/CodecInfo.aidl b/bluetooth/audio/aidl/android/hardware/bluetooth/audio/CodecInfo.aidl index 127cd7c93a..33f0c04307 100644 --- a/bluetooth/audio/aidl/android/hardware/bluetooth/audio/CodecInfo.aidl +++ b/bluetooth/audio/aidl/android/hardware/bluetooth/audio/CodecInfo.aidl @@ -18,6 +18,7 @@ package android.hardware.bluetooth.audio; import android.hardware.bluetooth.audio.ChannelMode; import android.hardware.bluetooth.audio.CodecId; +import android.hardware.bluetooth.audio.ConfigurationFlags; /** * General information about a Codec @@ -86,11 +87,47 @@ parcelable CodecInfo { boolean useControllerCodec = true; } + /** + * LE Audio Context + */ + parcelable LeAudio { + /** + * Channel configuration: Mono, Dual-Mono or Stereo + */ + ChannelMode[] channelMode; + + /** + * Supported sampling frequencies, in Hz. + */ + int[] samplingFrequencyHz; + + /* + * FrameDuration in microseconds. + */ + int[] frameDurationUs; + + /** + * - Fixed point resolution, basically 16, 24 or 32 bits by samples. + * The value 32 should be used for floating point representation. + * + * When the bitdepth is not an encoding/decoding parameter (don't take + * part in the interoperability), the `bitdepth` list shall have a + * single element indicating the bitdepth selected for the platform. + */ + int[] bitdepth; + + /** + * Additional configuration flags + */ + @nullable ConfigurationFlags flags; + } + /** * Specific informations, * depending on transport. */ union Transport { + LeAudio leAudio; A2dp a2dp; Hfp hfp; } diff --git a/bluetooth/audio/aidl/android/hardware/bluetooth/audio/CodecSpecificCapabilitiesLtv.aidl b/bluetooth/audio/aidl/android/hardware/bluetooth/audio/CodecSpecificCapabilitiesLtv.aidl new file mode 100644 index 0000000000..ceb90baf51 --- /dev/null +++ b/bluetooth/audio/aidl/android/hardware/bluetooth/audio/CodecSpecificCapabilitiesLtv.aidl @@ -0,0 +1,80 @@ +/* + * Copyright 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 android.hardware.bluetooth.audio; + +/** + * Used to exchange generic remote device codec specific capabilities between + * the stack and the provider. As defined in Bluetooth Assigned Numbers, + * Sec. 6.12.4. + */ +@VintfStability +union CodecSpecificCapabilitiesLtv { + parcelable SupportedSamplingFrequencies { + const int HZ8000 = 0x0001; + const int HZ11025 = 0x0002; + const int HZ16000 = 0x0004; + const int HZ22050 = 0x0008; + const int HZ24000 = 0x0010; + const int HZ32000 = 0x0020; + const int HZ44100 = 0x0040; + const int HZ48000 = 0x0080; + const int HZ88200 = 0x0100; + const int HZ96000 = 0x0200; + const int HZ176400 = 0x0400; + const int HZ192000 = 0x0800; + const int HZ384000 = 0x1000; + + /* 16 bits wide bit mask */ + int bitmask; + } + parcelable SupportedFrameDurations { + const int US7500 = 0x01; + const int US10000 = 0x02; + // Bits 2-3 are RFU + const int US7500PREFERRED = 0x10; + const int US10000PREFERRED = 0x20; + + /* 8 bit wide bit mask */ + int bitmask; + } + parcelable SupportedAudioChannelCounts { + const int ONE = 0x01; + const int TWO = 0x02; + const int THREE = 0x04; + const int FOUR = 0x08; + const int FIVE = 0x10; + const int SIX = 0x20; + const int SEVEN = 0x40; + const int EIGHT = 0x80; + + /* 8 bit wide bit mask */ + int bitmask; + } + parcelable SupportedOctetsPerCodecFrame { + int minimum; + int maximum; + } + parcelable SupportedMaxCodecFramesPerSDU { + int value; + } + + SupportedSamplingFrequencies supportedSamplingFrequencies; + SupportedFrameDurations supportedFrameDurations; + SupportedAudioChannelCounts supportedAudioChannelCounts; + SupportedOctetsPerCodecFrame supportedOctetsPerCodecFrame; + SupportedMaxCodecFramesPerSDU supportedMaxCodecFramesPerSDU; +} diff --git a/bluetooth/audio/aidl/android/hardware/bluetooth/audio/CodecSpecificConfigurationLtv.aidl b/bluetooth/audio/aidl/android/hardware/bluetooth/audio/CodecSpecificConfigurationLtv.aidl new file mode 100644 index 0000000000..c099ebe108 --- /dev/null +++ b/bluetooth/audio/aidl/android/hardware/bluetooth/audio/CodecSpecificConfigurationLtv.aidl @@ -0,0 +1,96 @@ +/* + * Copyright 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 android.hardware.bluetooth.audio; + +/** + * Used to exchange generic remote device configuration between the stack and + * the provider. As defined in Bluetooth Assigned Numbers, Sec. 6.12.5. + */ +@VintfStability +union CodecSpecificConfigurationLtv { + @Backing(type="byte") + enum SamplingFrequency { + HZ8000 = 0x01, + HZ11025 = 0x02, + HZ16000 = 0x03, + HZ22050 = 0x04, + HZ24000 = 0x05, + HZ32000 = 0x06, + HZ44100 = 0x07, + HZ48000 = 0x08, + HZ88200 = 0x09, + HZ96000 = 0x0A, + HZ176400 = 0x0B, + HZ192000 = 0x0C, + HZ384000 = 0x0D, + } + + @Backing(type="byte") + enum FrameDuration { + US7500 = 0x00, + US10000 = 0x01, + } + + parcelable AudioChannelAllocation { + const int NOT_ALLOWED = 0x00000000; + const int FRONT_LEFT = 0x00000001; + const int FRONT_RIGHT = 0x00000002; + const int FRONT_CENTER = 0x00000004; + const int LOW_FREQUENCY_EFFECTS_1 = 0x00000008; + const int BACK_LEFT = 0x00000010; + const int BACK_RIGHT = 0x00000020; + const int FRONT_LEFT_OF_CENTER = 0x00000040; + const int FRONT_RIGHT_OF_CENTER = 0x00000080; + const int BACK_CENTER = 0x00000100; + const int LOW_FREQUENCY_EFFECTS_2 = 0x00000200; + const int SIDE_LEFT = 0x00000400; + const int SIDE_RIGHT = 0x00000800; + const int TOP_FRONT_LEFT = 0x00001000; + const int TOP_FRONT_RIGHT = 0x00002000; + const int TOP_FRONT_CENTER = 0x00004000; + const int TOP_CENTER = 0x00008000; + const int TOP_BACK_LEFT = 0x00010000; + const int TOP_BACK_RIGHT = 0x00020000; + const int TOP_SIDE_LEFT = 0x00040000; + const int TOP_SIDE_RIGHT = 0x00080000; + const int TOP_BACK_CENTER = 0x00100000; + const int BOTTOM_FRONT_CENTER = 0x00200000; + const int BOTTOM_FRONT_LEFT = 0x00400000; + const int BOTTOM_FRONT_RIGHT = 0x00800000; + const int FRONT_LEFT_WIDE = 0x01000000; + const int FRONT_RIGHT_WIDE = 0x02000000; + const int LEFT_SURROUND = 0x04000000; + const int RIGHT_SURROUND = 0x08000000; + + // Bit mask of Audio Locations + int bitmask; + } + + parcelable OctetsPerCodecFrame { + int value; + } + + parcelable CodecFrameBlocksPerSDU { + int value; + } + + CodecFrameBlocksPerSDU codecFrameBlocksPerSDU; + SamplingFrequency samplingFrequency; + FrameDuration frameDuration; + AudioChannelAllocation audioChannelAllocation; + OctetsPerCodecFrame octetsPerCodecFrame; +} diff --git a/bluetooth/audio/aidl/android/hardware/bluetooth/audio/ConfigurationFlags.aidl b/bluetooth/audio/aidl/android/hardware/bluetooth/audio/ConfigurationFlags.aidl new file mode 100644 index 0000000000..57c8be5b00 --- /dev/null +++ b/bluetooth/audio/aidl/android/hardware/bluetooth/audio/ConfigurationFlags.aidl @@ -0,0 +1,54 @@ +/* + * Copyright 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 android.hardware.bluetooth.audio; + +/** + * Coding fetures + */ +@VintfStability +parcelable ConfigurationFlags { + const int NONE = 0x0000; + /* + * Set for the lossless configurations + */ + const int LOSSLESS = 0x0001; + /* + * Set for the low latency configurations + */ + const int LOW_LATENCY = 0x0002; + /* + * When set, asymmetric configuration for SINK and SOURCE can be used. + * e.g. in GAMING mode stream for 32kHz and back channel for 16 kHz + */ + const int ALLOW_ASYMMETRIC_CONFIGURATIONS = 0x0003; + /* + * Set for the spatial audio configurations + */ + const int SPATIAL_AUDIO = 0x0004; + /* + * When set, BluetoothAudioProvider requests to receive ASE metadata. + * In such case onSinkAseMetadataChanged() and onSourceAseMetadataChanged + * will be called. + */ + const int PROVIDE_ASE_METADATA = 0x0005; + /* + * Set for mono microphone configurations + */ + const int MONO_MIC_CONFIGURATION = 0x0006; + + int bitmask; +} diff --git a/bluetooth/audio/aidl/android/hardware/bluetooth/audio/IBluetoothAudioProvider.aidl b/bluetooth/audio/aidl/android/hardware/bluetooth/audio/IBluetoothAudioProvider.aidl index b5c8a31ce5..f5650181ab 100644 --- a/bluetooth/audio/aidl/android/hardware/bluetooth/audio/IBluetoothAudioProvider.aidl +++ b/bluetooth/audio/aidl/android/hardware/bluetooth/audio/IBluetoothAudioProvider.aidl @@ -21,11 +21,18 @@ import android.hardware.bluetooth.audio.A2dpConfigurationHint; import android.hardware.bluetooth.audio.A2dpRemoteCapabilities; import android.hardware.bluetooth.audio.A2dpStatus; import android.hardware.bluetooth.audio.AudioConfiguration; +import android.hardware.bluetooth.audio.AudioContext; import android.hardware.bluetooth.audio.BluetoothAudioStatus; import android.hardware.bluetooth.audio.CodecId; import android.hardware.bluetooth.audio.CodecParameters; +import android.hardware.bluetooth.audio.CodecSpecificCapabilitiesLtv; +import android.hardware.bluetooth.audio.ConfigurationFlags; import android.hardware.bluetooth.audio.IBluetoothAudioPort; import android.hardware.bluetooth.audio.LatencyMode; +import android.hardware.bluetooth.audio.LeAudioAseConfiguration; +import android.hardware.bluetooth.audio.LeAudioConfiguration.StreamMap; +import android.hardware.bluetooth.audio.MetadataLtv; +import android.hardware.bluetooth.audio.Phy; import android.hardware.common.fmq.MQDescriptor; import android.hardware.common.fmq.SynchronizedReadWrite; @@ -124,4 +131,421 @@ interface IBluetoothAudioProvider { */ @nullable A2dpConfiguration getA2dpConfiguration( in List remoteA2dpCapabilities, in A2dpConfigurationHint hint); + + /** + * Set specific codec priority + * + * It should be assumed that the external module will start with all its + * integrated codecs priority 0 by default. + * + * @param codecId: codecId + * @param priority: 0 for no priority, -1 for codec disabled, + * from 1 to N, where 1 is highest. + */ + void setCodecPriority(in CodecId codecId, int priority); + + /** + * LE Audio device Capabilities - as defined in Bluetooth Published Audio + * Capabilities Service specification, v1.0.1, Sec. 3.1: "Sink PAC", and + * Sec. 3.3: "Source PAC". + */ + @VintfStability + parcelable LeAudioDeviceCapabilities { + /** + * Codec Identifier + */ + CodecId codecId; + /** + * Codec capabilities, packed as LTV. + */ + CodecSpecificCapabilitiesLtv[] codecSpecificCapabilities; + /** + * Vendor codec specific capabilities. + * + * This will not be parsed by the BT stack, but passed to the vendor + * module who can interpret this and based on that select the proper + * vendor specific codec configuration. + */ + @nullable byte[] vendorCodecSpecificCapabilities; + /** + * Audio capabilities metadata, packed as LTV. + */ + @nullable MetadataLtv[] metadata; + } + + @VintfStability + parcelable LeAudioDataPathConfiguration { + /** + * Vendor specific data path identifier + */ + int dataPathId; + + /** + * Used in the HCI_LE_Setup_ISO_Data_Path (0x006E). + * As defined in Bluetooth Core Specification Version + * 5.3, Vol 4, Part E, Sec. 7.8.109: "LE Setup ISO Data Path command". + */ + @VintfStability + parcelable IsoDataPathConfiguration { + /** + * Codec ID - Valid Codec Identifier matching the selected codec + */ + CodecId codecId; + /** + * Whether the transparent air mode should be set as a coding format + * in the HCI_LE_Setup_ISO_Data_Path command, indicating that the + * codec is not in the controller. + * + * If set to true, 0x03 (transparent air mode) will be used as a + * Codec_ID coding format and the `byte[] configuration` field shall + * remain empty. Otherwise the Codec_ID field will be set to + * according to BT specification (0xFF coding format, company ID, + * codec ID for vendor codecs, or according to Codec_ID identifiers + * defined in the Assigned Numbers for the non-vendor codecs). + */ + boolean isTransparent; + /** + * Controller delay (in microseconds) + */ + int controllerDelayUs; + /** + * Codec specific LE Audio ISO data path configuration + * must be null when codec ID is 0x03 transparent + */ + @nullable byte[] configuration; + } + + /** + * Used in HCI_Configure_Data_Path (0x0083) + * As defined in Bluetooth Core Specification Version + * 5.3, Vol 4, Part E, Sec. 7.3.101: "Configure Data Path command". + */ + @VintfStability + parcelable DataPathConfiguration { + /** + * Vendor specific data path configuration + */ + @nullable byte[] configuration; + } + /** + * Data path configuration + */ + DataPathConfiguration dataPathConfiguration; + /** + * ISO data path configuration + */ + IsoDataPathConfiguration isoDataPathConfiguration; + } + + /* All the LeAudioAseQosConfiguration parameters are defined by the + * Bluetooth Audio Stream Control Service specification v.1.0, Sec. 5: "ASE + * Control Operations". + */ + @VintfStability + parcelable LeAudioAseQosConfiguration { + /** + * SDU Interval (in microseconds) used in Set CIG Parameters command and + * Configure QoS. + */ + int sduIntervalUs; + /** + * Framing used in Set CIG Parameters command and Configure QoS + */ + Framing framing; + /** + * Phy used in Set CIG Parameters command and Configure QoS + */ + Phy[] phy; + /** + * Max transport latency (in milliseconds) used in Set CIG Parameters + * command and Configure QoS. + */ + int maxTransportLatencyMs; + /** + * Max SDU used in Set CIG Parameters command and Configure QoS + */ + int maxSdu; + /** + * Retransmission number used in Set CIG Parameters command and + * Configure QoS + */ + int retransmissionNum; + } + + /** + * Connected Isochronous Channel arrangement within the Connected + * Isochronous Group. As defined in Bluetooth Core Specification Version + * 5.3, Vol 4, Part E, Sec. 7.8.97. + */ + @VintfStability + @Backing(type="byte") + enum Packing { + SEQUENTIAL = 0x00, + INTERLEAVED = 0x01, + } + + /** + * Isochronous Data PDU framing parameter. As defined in Bluetooth Core + * Specification Version 5.3, Vol 4, Part E, Sec. 7.8.97. + */ + @VintfStability + @Backing(type="byte") + enum Framing { + UNFRAMED = 0x00, + FRAMED = 0x01, + } + + @VintfStability + parcelable LeAudioAseConfigurationSetting { + /** + * Audio Context that this configuration apply to + */ + AudioContext audioContext; + /** + * Sequential or interleave packing used in Set CIG Parameters command + */ + Packing packing; + + @VintfStability + parcelable AseDirectionConfiguration { + /** + * ASE configuration + */ + LeAudioAseConfiguration aseConfiguration; + /** + * QoS Configuration + */ + @nullable LeAudioAseQosConfiguration qosConfiguration; + /** + * Data path configuration + * If not provided, getLeAudioAseDatapathConfiguration() will be + * called during the configuration, increasing the stream + * establishment time (not recommended). + */ + @nullable LeAudioDataPathConfiguration dataPathConfiguration; + } + /** + * Sink ASEs configuration + */ + @nullable List sinkAseConfiguration; + /** + * Source ASEs configuration + */ + @nullable List sourceAseConfiguration; + /** + * Additional flags, used for configurations with special features + */ + @nullable ConfigurationFlags flags; + } + + /** + * ASE configuration requirements set by the BT stack. + */ + @VintfStability + parcelable LeAudioConfigurationRequirement { + /** + * Audio Contect that this requirements apply to + */ + AudioContext audioContext; + + @VintfStability + parcelable AseDirectionRequirement { + /** + * Optional ASE configurations requirements + * + * Note that the Host can set as many or as little parameters in + * the `aseConfiguration.codecConfiguration` field as needed, to + * closely or loosely specify the requirements. If any parameter + * is not specified, the offloader can choose it freely. The + * offloader should put all the specified parameters into the + * `aseConfiguration.codecConfiguration` field of the returned + * configuration to let the BT stack verify if the requirements + * were met. The mandatory requirement set by the BT stack will be + * the Audio Location. + */ + LeAudioAseConfiguration aseConfiguration; + } + /** + * Sink ASEs configuration setting + */ + @nullable List sinkAseRequirement; + /** + * Source ASEs configuration setting + */ + @nullable List sourceAseRequirement; + /** + * Additional flags, used to request configurations with special + * features + */ + @nullable ConfigurationFlags flags; + } + + /** + * Method that returns a proposed ASE configuration settings for each + * requested audio context type + * + * Note: _ENCODING session provides SINK ASE configuration + * and _DECODING session provides SOURCE ASE configuration unless + * BluetoothAudioProvider sets supportsMultidirectionalCapabilities to + * true in ProviderInfo. + * If supportsMultidirectionalCapabilities is set to true then the + * BluetoothStack expects to get configuration list for SINK and SOURCE + * on either _ENCODING or _DECODING session. + * + * @param remoteSinkAudioCapabilities List of remote sink capabilities + * supported by an active group devices. + * @param remoteSourceAudioCapabilities List of remote source capabilities + * supported by an active group devices. + * @param requirements ASE configuration requirements + * + * @return List + */ + List getLeAudioAseConfiguration( + in @nullable List remoteSinkAudioCapabilities, + in @nullable List remoteSourceAudioCapabilities, + in List requirements); + + @VintfStability + parcelable LeAudioAseQosConfigurationRequirement { + /** + * Audio Contect Type that this requirements apply to + */ + AudioContext contextType; + + /** + * QoS preferences received in Codec Configured ASE state. As defined in + * bluetooth service specification: Audio Stream Control Service" V1.0, + * Sec. 4.1 Audio Stream Endpoints, Table 4.3:"Additional_ASE_Parameters + * format when ASE_State = 0x01 (Codec Configured)". + */ + @VintfStability + parcelable AseQosDirectionRequirement { + /** + * Support for unframed Isochronous Adaptation Layer PDUs. + * When set to FRAMED, the unframed PDUs are not supported. + */ + Framing framing; + /** + * Preferred value for the PHY parameter to be written by the client + * for this ASE in the Config QoS operation + */ + Phy[] preferredPhy; + /** + * Preferred value for the Retransmission Number parameter to be + * written by the client for this ASE in the Config QoS operation. + */ + int preferredRetransmissionNum; + /** + * Preferred value for the Max Transport Latency parameter to be + * written by the client for this ASE in the Config QoS operation. + */ + int maxTransportLatencyMs; + /** + * Minimum server supported Presentation Delay (in microseconds) for + * an ASE. + */ + int presentationDelayMinUs; + /** + * Maximum server supported Presentation Delay (in microseconds) for + * an ASE. + */ + int presentationDelayMaxUs; + /** + * Preferred minimum Presentation Delay (in microseconds) for an + * ASE. + */ + int preferredPresentationDelayMinUs; + /** + * Preferred maximum Presentation Delay (in microseconds) for an + * ASE. + */ + int preferredPresentationDelayMaxUs; + + /** + * ASE configuration + */ + LeAudioAseConfiguration aseConfiguration; + } + /** + * Sink ASEs configuration setting + */ + @nullable AseQosDirectionRequirement sinkAseQosRequirement; + /** + * Source ASEs configuration setting + */ + @nullable AseQosDirectionRequirement sourceAseQosRequirement; + /** + * Additional configuration flags requirements + */ + @nullable ConfigurationFlags[] flags; + } + + /** + * A directional pair for QoS configuration. Either one or both directions + * can be set, depending on the audio context and the requirements provided + * to getLeAudioAseQosConfiguration(). + */ + @VintfStability + parcelable LeAudioAseQosConfigurationPair { + @nullable LeAudioAseQosConfiguration sinkQosConfiguration; + @nullable LeAudioAseQosConfiguration sourceQosConfiguration; + } + + /** + * Method that returns an ASE QoS configuration settings for the given ASE + * configuration,taking an ASE preferenced QoS parameters. It should be used + * to negotiaite the QoS parameters, when the initialy received QoS + * parameters are not within the boundaries received from the remote device + * after configuring the ASEs. + * + * @param qosRequirement ASE QoS configurations requirements + * + * @return LeAudioAseQosConfigurationPair + */ + LeAudioAseQosConfigurationPair getLeAudioAseQosConfiguration( + in LeAudioAseQosConfigurationRequirement qosRequirement); + + /** + * Audio data path configuration. + */ + parcelable LeAudioDataPathConfigurationPair { + /* Host to Controller data path */ + @nullable LeAudioDataPathConfiguration inputConfig; + /* Controller to Host data path */ + @nullable LeAudioDataPathConfiguration outputConfig; + } + + /** + * Used to get a data path configuration which dynamically depends on CIS + * connection handles in StreamMap. This is used if non-dynamic data path + * was not provided in LeAudioAseConfigurationSetting. Calling this during + * the unicast audio stream establishment might slightly delay the stream + * start. + */ + LeAudioDataPathConfigurationPair getLeAudioAseDatapathConfiguration( + in AudioContext context, in StreamMap[] streamMap); + + /* + * Audio Stream Endpoint state used to report Metadata changes on the remote + * device audio endpoints. + */ + @VintfStability + @Backing(type="byte") + enum AseState { + ENABLING = 0x00, + STREAMING = 0x01, + DISABLING = 0x02, + } + + /** + * Used to report metadata changes to the provider. This allows for a + * pseudo communication channel between the remote device and the provider, + * using the vendor specific metadata of the changing ASE state. + * It is used only when ASE is using configurations marked with the + * `PROVIDE_ASE_METADATA` flag. + */ + void onSinkAseMetadataChanged( + in AseState state, int cigId, int cisId, in @nullable MetadataLtv[] metadata); + void onSourceAseMetadataChanged( + in AseState state, int cigId, int cisId, in @nullable MetadataLtv[] metadata); } diff --git a/bluetooth/audio/aidl/android/hardware/bluetooth/audio/IBluetoothAudioProviderFactory.aidl b/bluetooth/audio/aidl/android/hardware/bluetooth/audio/IBluetoothAudioProviderFactory.aidl index b9cec2d38d..ea9c4e1709 100644 --- a/bluetooth/audio/aidl/android/hardware/bluetooth/audio/IBluetoothAudioProviderFactory.aidl +++ b/bluetooth/audio/aidl/android/hardware/bluetooth/audio/IBluetoothAudioProviderFactory.aidl @@ -69,19 +69,33 @@ interface IBluetoothAudioProviderFactory { * General information relative to a provider * - An optional name * - A list of codec information + * - supportsMultidirectionalCapabilities if is set to false it means each + * session i.e. _ENCODING and _DECODING is responsible to provide + * configuration for a single direction: + * _ENCODING for SINK ASE + * _DECODING for SOURCE ASE + * + * If supportsMultidirectionalCapabilities is set to true, then either + * _ENCODING or _DECODING session can provide the configurations for either + * direction. */ @VintfStability parcelable ProviderInfo { String name; CodecInfo[] codecInfos; + boolean supportsMultidirectionalCapabilities; } /** * Get general information relative to a provider. * + * This can be called at any time, or just once during the BT stack + * initialization. + * * @param sessionType Hardware Offload provider (*_HARDWARE_OFFLOAD_*) * @return General information relative to the provider. - * The `null` value can be returned when the provider is not available + * The `null` value can be returned when the provider is not + * available */ @nullable ProviderInfo getProviderInfo(in SessionType sessionType); } diff --git a/bluetooth/audio/aidl/android/hardware/bluetooth/audio/LeAudioAseConfiguration.aidl b/bluetooth/audio/aidl/android/hardware/bluetooth/audio/LeAudioAseConfiguration.aidl new file mode 100644 index 0000000000..9fb2ecf99d --- /dev/null +++ b/bluetooth/audio/aidl/android/hardware/bluetooth/audio/LeAudioAseConfiguration.aidl @@ -0,0 +1,87 @@ +/* + * Copyright 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 android.hardware.bluetooth.audio; + +import android.hardware.bluetooth.audio.CodecId; +import android.hardware.bluetooth.audio.CodecSpecificConfigurationLtv; +import android.hardware.bluetooth.audio.MetadataLtv; +import android.hardware.bluetooth.audio.Phy; + +/** + * All the LeAudioAseConfiguration parameters are defined by the Bluetooth Audio + * Stream Control Service specification v.1.0, Sec. 5: "ASE Control Operations". + */ +@VintfStability +parcelable LeAudioAseConfiguration { + @VintfStability + @Backing(type="byte") + enum TargetLatency { + UNDEFINED = 0x00, + LOWER = 0x01, + BALANCED_LATENCY_RELIABILITY = 0x02, + HIGHER_RELIABILITY = 0x03, + } + + /** + * Target latency used in Configure Codec command - Can be UNDEFINED when + * used inside the AseDirectionRequirement, but shall not be UNDEFINED when + * used inside LeAudioAseConfigurationSetting. + */ + TargetLatency targetLatency; + + /** + * Target PHY used in Configure Codec command - Can be UNDEFINED when used + * inside the AseDirectionRequirement, but shall not be UNDEFINED when used + * inside LeAudioAseConfigurationSetting. + */ + Phy targetPhy; + + /** + * Codec ID - Can be Null when used inside the AseDirectionRequirement, but + * shall not be Null when used inside LeAudioAseConfigurationSetting. + */ + @nullable CodecId codecId; + + /** + * Codec configuration for ASE represented in the LTV types defined by + * Bluetooth SIG. Regardless of vendor specific configuration being used or + * not, this shall contain Bluetooth LTV types describing the common stream + * parameters, at least CodecSpecificConfigurationLtv.SamplingFrequency and + * CodecSpecificConfigurationLtv.AudioChannelAllocation. In addition, it + * should match aseConfiguration provided in LeAudioConfigurationRequirement + * as this will also be used to verify the requirements on the known LTV + * types. + */ + CodecSpecificConfigurationLtv[] codecConfiguration; + + /** + * Vendor specific codec configuration for ASE. + * + * This will not be parsed by the BT stack but will be written to the remote + * device as the codec specific configuration as part of the codec configure + * control point operation. If this is populated, only the + * `vendorCodecConfiguration` will be used for the ASE configuration, + * otherwise `codecConfiguration` will be used. The BT stack will not merge + * it with the codecConfiguration for any purpose. + */ + @nullable byte[] vendorCodecConfiguration; + + /** + * Metadata, packed as LTV - used to enable ASE. This is optional + */ + @nullable MetadataLtv[] metadata; +} diff --git a/bluetooth/audio/aidl/android/hardware/bluetooth/audio/LeAudioConfiguration.aidl b/bluetooth/audio/aidl/android/hardware/bluetooth/audio/LeAudioConfiguration.aidl index 7302aea255..db753ada96 100644 --- a/bluetooth/audio/aidl/android/hardware/bluetooth/audio/LeAudioConfiguration.aidl +++ b/bluetooth/audio/aidl/android/hardware/bluetooth/audio/LeAudioConfiguration.aidl @@ -17,6 +17,8 @@ package android.hardware.bluetooth.audio; import android.hardware.bluetooth.audio.CodecType; +import android.hardware.bluetooth.audio.ConfigurationFlags; +import android.hardware.bluetooth.audio.LeAudioAseConfiguration; import android.hardware.bluetooth.audio.LeAudioCodecConfiguration; @VintfStability @@ -29,16 +31,40 @@ parcelable LeAudioConfiguration { */ char streamHandle; /* - * Audio channel allocation is a bit field, each enabled bit means that given audio - * direction, i.e. "left", or "right" is used. Ordering of audio channels comes from the - * least significant bit to the most significant bit. The valus follows the Bluetooth SIG - * Audio Location assigned number. + * Audio channel allocation is a bit field, each enabled bit means that + * given audio direction, i.e. "left", or "right" is used. Ordering of + * audio channels comes from the least significant bit to the most + * significant bit. The valus follows the Bluetooth SIG Audio Location + * assigned number. */ int audioChannelAllocation; /* * The stream handle status */ boolean isStreamActive; + /* + * LE Audio device ASE configuration + */ + @nullable LeAudioAseConfiguration aseConfiguration; + /* + * Additional flags, used for configurations with special features + */ + @nullable ConfigurationFlags flags; + parcelable BluetoothDeviceAddress { + enum DeviceAddressType { + BLE_ADDRESS_PUBLIC = 0x00, + BLE_ADDRESS_RANDOM = 0x01, + } + /** + * Peer device address. It should be non zero when isStreamActive is true + */ + byte[6] deviceAddress; + /** + * Peer device address type. + */ + DeviceAddressType deviceAddressType; + } + @nullable BluetoothDeviceAddress bluetoothDeviceAddress; } CodecType codecType; StreamMap[] streamMap; diff --git a/bluetooth/audio/aidl/android/hardware/bluetooth/audio/MetadataLtv.aidl b/bluetooth/audio/aidl/android/hardware/bluetooth/audio/MetadataLtv.aidl new file mode 100644 index 0000000000..b0befc15b9 --- /dev/null +++ b/bluetooth/audio/aidl/android/hardware/bluetooth/audio/MetadataLtv.aidl @@ -0,0 +1,44 @@ +/* + * Copyright 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 android.hardware.bluetooth.audio; + +import android.hardware.bluetooth.audio.AudioContext; + +/** + * Used to exchange generic metadata between the stack and the provider. + * As defined in Bluetooth Assigned Numbers, Sec. 6.12.6. + */ +@VintfStability +union MetadataLtv { + parcelable PreferredAudioContexts { + AudioContext values; + } + parcelable StreamingAudioContexts { + AudioContext values; + } + /* This is an opaque container for passing metadata between the provider and + * the remote device. It must not be interpreted by the BT stack. + */ + parcelable VendorSpecific { + int companyId; + byte[] opaqueValue; + } + + PreferredAudioContexts preferredAudioContexts; + StreamingAudioContexts streamingAudioContexts; + VendorSpecific vendorSpecific; +} diff --git a/bluetooth/audio/aidl/android/hardware/bluetooth/audio/Phy.aidl b/bluetooth/audio/aidl/android/hardware/bluetooth/audio/Phy.aidl new file mode 100644 index 0000000000..cbffdd5207 --- /dev/null +++ b/bluetooth/audio/aidl/android/hardware/bluetooth/audio/Phy.aidl @@ -0,0 +1,29 @@ +/* + * Copyright 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 android.hardware.bluetooth.audio; + +/** + * Used to exchange generic Phy parameter between the stack and the provider. + */ +@VintfStability +@Backing(type="byte") +enum Phy { + UNDEFINED = 0x00, + ONE_M = 0x01, + TWO_M = 0x02, + CODED = 0x03, +}