| /* |
| * Copyright 2020 HIMSA II K/S - www.himsa.com. Represented by EHIMA |
| * - www.ehima.com |
| * |
| * 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. |
| */ |
| |
| #pragma once |
| |
| #include <map> |
| #include <memory> |
| #include <optional> |
| #include <tuple> |
| #include <vector> |
| |
| #include "bt_types.h" |
| #include "bta_groups.h" |
| #include "btm_iso_api_types.h" |
| #include "client_audio.h" |
| #include "gatt_api.h" |
| #include "le_audio_types.h" |
| #include "osi/include/alarm.h" |
| #include "raw_address.h" |
| |
| namespace le_audio { |
| /* Class definitions */ |
| |
| /* LeAudioDevice class represents GATT server device with ASCS, PAC services as |
| * mandatory. Device may contain multiple ASEs, PACs, audio locations. ASEs from |
| * multiple devices may be formed in group. |
| * |
| * Device is created after connection or after storage restoration. |
| * |
| * Active device means that device has at least one ASE which will participate |
| * in any state transition of state machine. ASEs and devices will be activated |
| * according to requested by upper context type. |
| */ |
| class LeAudioDevice { |
| public: |
| RawAddress address_; |
| |
| bool known_service_handles_; |
| bool notify_connected_after_read_; |
| bool removing_device_; |
| |
| /* we are making active attempt to connect to this device, 'direct connect'. |
| * This is true only during initial phase of first connection. */ |
| bool first_connection_; |
| bool connecting_actively_; |
| uint16_t conn_id_; |
| bool encrypted_; |
| int group_id_; |
| bool csis_member_; |
| |
| uint8_t audio_directions_; |
| types::AudioLocations snk_audio_locations_; |
| types::AudioLocations src_audio_locations_; |
| |
| types::PublishedAudioCapabilities snk_pacs_; |
| types::PublishedAudioCapabilities src_pacs_; |
| |
| struct types::hdl_pair snk_audio_locations_hdls_; |
| struct types::hdl_pair src_audio_locations_hdls_; |
| struct types::hdl_pair audio_avail_hdls_; |
| struct types::hdl_pair audio_supp_cont_hdls_; |
| std::vector<struct types::ase> ases_; |
| struct types::hdl_pair ctp_hdls_; |
| |
| alarm_t* link_quality_timer; |
| uint16_t link_quality_timer_data; |
| |
| LeAudioDevice(const RawAddress& address_, bool first_connection, |
| int group_id = bluetooth::groups::kGroupUnknown) |
| : address_(address_), |
| known_service_handles_(false), |
| notify_connected_after_read_(false), |
| removing_device_(false), |
| first_connection_(first_connection), |
| connecting_actively_(first_connection), |
| conn_id_(GATT_INVALID_CONN_ID), |
| encrypted_(false), |
| group_id_(group_id), |
| csis_member_(false), |
| audio_directions_(0), |
| link_quality_timer(nullptr) {} |
| ~LeAudioDevice(void); |
| |
| void ClearPACs(void); |
| void RegisterPACs(std::vector<struct types::acs_ac_record>* apr_db, |
| std::vector<struct types::acs_ac_record>* apr); |
| struct types::ase* GetAseByValHandle(uint16_t val_hdl); |
| struct types::ase* GetFirstActiveAse(void); |
| struct types::ase* GetFirstActiveAseByDirection(uint8_t direction); |
| struct types::ase* GetNextActiveAseWithSameDirection( |
| struct types::ase* base_ase); |
| struct types::ase* GetFirstActiveAseByDataPathState( |
| types::AudioStreamDataPathState state); |
| struct types::ase* GetFirstInactiveAse(uint8_t direction, |
| bool reconnect = false); |
| struct types::ase* GetFirstInactiveAseWithState(uint8_t direction, |
| types::AseState state); |
| struct types::ase* GetNextActiveAse(struct types::ase* ase); |
| struct types::ase* GetAseToMatchBidirectionCis(struct types::ase* ase); |
| types::BidirectAsesPair GetAsesByCisConnHdl(uint16_t conn_hdl); |
| types::BidirectAsesPair GetAsesByCisId(uint8_t cis_id); |
| bool HaveActiveAse(void); |
| bool HaveAllActiveAsesSameState(types::AseState state); |
| bool HaveAnyUnconfiguredAses(void); |
| bool IsReadyToCreateStream(void); |
| bool IsReadyToSuspendStream(void); |
| bool HaveAllActiveAsesCisEst(void); |
| bool HaveAllAsesCisDisc(void); |
| bool HasCisId(uint8_t id); |
| uint8_t GetMatchingBidirectionCisId(const struct types::ase* base_ase); |
| bool IsCodecConfigurationSupported( |
| uint8_t direction, const set_configurations::CodecCapabilitySetting& |
| codec_capability_setting); |
| uint8_t GetLc3SupportedChannelCount(uint8_t direction); |
| uint8_t GetPhyBitmask(void); |
| bool ConfigureAses(const le_audio::set_configurations::SetConfiguration& ent, |
| types::LeAudioContextType context_type, |
| uint8_t* number_of_already_active_group_ase, |
| types::AudioLocations& group_snk_audio_locations, |
| types::AudioLocations& group_src_audio_locations, |
| bool reconnect = false); |
| void SetSupportedContexts(types::AudioContexts snk_contexts, |
| types::AudioContexts src_contexts); |
| types::AudioContexts GetAvailableContexts(void); |
| types::AudioContexts SetAvailableContexts(types::AudioContexts snk_cont_val, |
| types::AudioContexts src_cont_val); |
| void DeactivateAllAses(void); |
| void Dump(int fd); |
| std::vector<uint8_t> GetMetadata(types::LeAudioContextType context_type); |
| bool IsMetadataChanged(types::LeAudioContextType context_type); |
| |
| private: |
| types::AudioContexts avail_snk_contexts_; |
| types::AudioContexts avail_src_contexts_; |
| types::AudioContexts supp_snk_context_; |
| types::AudioContexts supp_src_context_; |
| }; |
| |
| /* LeAudioDevices class represents a wraper helper over all devices in le audio |
| * implementation. It allows to operate on device from a list (vector container) |
| * using determinants like address, connection id etc. |
| */ |
| class LeAudioDevices { |
| public: |
| void Add(const RawAddress& address, bool first_connection, |
| int group_id = bluetooth::groups::kGroupUnknown); |
| void Remove(const RawAddress& address); |
| LeAudioDevice* FindByAddress(const RawAddress& address); |
| std::shared_ptr<LeAudioDevice> GetByAddress(const RawAddress& address); |
| LeAudioDevice* FindByConnId(uint16_t conn_id); |
| LeAudioDevice* FindByCisConnHdl(const uint16_t conn_hdl); |
| size_t Size(void); |
| void Dump(int fd, int group_id); |
| void Cleanup(void); |
| |
| private: |
| std::vector<std::shared_ptr<LeAudioDevice>> leAudioDevices_; |
| }; |
| |
| /* LeAudioDeviceGroup class represents group of LeAudioDevices and allows to |
| * perform operations on them. Group states are ASE states due to nature of |
| * group which operates finally of ASEs. |
| * |
| * Group is created after adding a node to new group id (which is not on list). |
| */ |
| |
| class LeAudioDeviceGroup { |
| public: |
| const int group_id_; |
| bool cig_created_; |
| |
| struct stream_configuration stream_conf; |
| |
| uint8_t audio_directions_; |
| types::AudioLocations snk_audio_locations_; |
| types::AudioLocations src_audio_locations_; |
| |
| explicit LeAudioDeviceGroup(const int group_id) |
| : group_id_(group_id), |
| cig_created_(false), |
| audio_directions_(0), |
| transport_latency_mtos_(0), |
| transport_latency_stom_(0), |
| active_context_type_(types::LeAudioContextType::UNINITIALIZED), |
| target_state_(types::AseState::BTA_LE_AUDIO_ASE_STATE_IDLE), |
| current_state_(types::AseState::BTA_LE_AUDIO_ASE_STATE_IDLE), |
| context_type_(types::LeAudioContextType::UNINITIALIZED) { |
| stream_conf.valid = false; |
| stream_conf.conf = nullptr; |
| stream_conf.sink_num_of_devices = 0; |
| stream_conf.source_num_of_devices = 0; |
| } |
| ~LeAudioDeviceGroup(void); |
| |
| void AddNode(const std::shared_ptr<LeAudioDevice>& leAudioDevice); |
| void RemoveNode(const std::shared_ptr<LeAudioDevice>& leAudioDevice); |
| bool IsEmpty(void); |
| bool IsAnyDeviceConnected(void); |
| int Size(void); |
| int NumOfConnected( |
| types::LeAudioContextType context_type = types::LeAudioContextType::RFU); |
| void Deactivate(void); |
| void Cleanup(void); |
| LeAudioDevice* GetFirstDevice(void); |
| LeAudioDevice* GetFirstDeviceWithActiveContext( |
| types::LeAudioContextType context_type); |
| LeAudioDevice* GetNextDevice(LeAudioDevice* leAudioDevice); |
| LeAudioDevice* GetNextDeviceWithActiveContext( |
| LeAudioDevice* leAudioDevice, types::LeAudioContextType context_type); |
| LeAudioDevice* GetFirstActiveDevice(void); |
| LeAudioDevice* GetNextActiveDevice(LeAudioDevice* leAudioDevice); |
| bool IsDeviceInTheGroup(LeAudioDevice* leAudioDevice); |
| bool HaveAllActiveDevicesAsesTheSameState(types::AseState state); |
| bool IsGroupStreamReady(void); |
| bool HaveAllActiveDevicesCisDisc(void); |
| uint8_t GetFirstFreeCisId(void); |
| bool Configure(types::LeAudioContextType context_type); |
| bool SetContextType(types::LeAudioContextType context_type); |
| types::LeAudioContextType GetContextType(void); |
| uint32_t GetSduInterval(uint8_t direction); |
| uint8_t GetSCA(void); |
| uint8_t GetPacking(void); |
| uint8_t GetFraming(void); |
| uint8_t GetTargetLatency(void); |
| uint16_t GetMaxTransportLatencyStom(void); |
| uint16_t GetMaxTransportLatencyMtos(void); |
| void SetTransportLatency(uint8_t direction, uint16_t transport_latency); |
| uint8_t GetPhyBitmask(uint8_t direction); |
| uint8_t GetTargetPhy(uint8_t direction); |
| bool GetPresentationDelay(uint32_t* delay, uint8_t direction); |
| uint16_t GetRemoteDelay(uint8_t direction); |
| std::optional<types::AudioContexts> UpdateActiveContextsMap( |
| types::AudioContexts contexts); |
| std::optional<types::AudioContexts> UpdateActiveContextsMap(void); |
| bool ReloadAudioLocations(void); |
| const set_configurations::AudioSetConfiguration* GetActiveConfiguration(void); |
| types::LeAudioContextType GetCurrentContextType(void); |
| types::AudioContexts GetActiveContexts(void); |
| std::optional<LeAudioCodecConfiguration> GetCodecConfigurationByDirection( |
| types::LeAudioContextType group_context_type, uint8_t direction); |
| bool IsMetadataChanged(types::LeAudioContextType group_context_type); |
| |
| inline types::AseState GetState(void) const { return current_state_; } |
| void SetState(types::AseState state) { |
| LOG(INFO) << __func__ << " current state: " << current_state_ |
| << " new state: " << state; |
| current_state_ = state; |
| } |
| |
| inline types::AseState GetTargetState(void) const { return target_state_; } |
| void SetTargetState(types::AseState state) { |
| LOG(INFO) << __func__ << " target state: " << target_state_ |
| << " new target state: " << state; |
| target_state_ = state; |
| } |
| |
| bool IsInTransition(void); |
| bool IsReleasing(void); |
| void Dump(int fd); |
| |
| private: |
| uint16_t transport_latency_mtos_; |
| uint16_t transport_latency_stom_; |
| |
| const set_configurations::AudioSetConfiguration* |
| FindFirstSupportedConfiguration(types::LeAudioContextType context_type); |
| bool ConfigureAses( |
| const set_configurations::AudioSetConfiguration* audio_set_conf, |
| types::LeAudioContextType context_type); |
| bool IsConfigurationSupported( |
| const set_configurations::AudioSetConfiguration* audio_set_configuration, |
| types::LeAudioContextType context_type); |
| uint16_t GetTransportLatency(uint8_t direction); |
| |
| /* Mask and table of currently supported contexts */ |
| types::LeAudioContextType active_context_type_; |
| types::AudioContexts active_contexts_mask_; |
| std::map<types::LeAudioContextType, |
| const set_configurations::AudioSetConfiguration*> |
| active_context_to_configuration_map; |
| |
| types::AseState target_state_; |
| types::AseState current_state_; |
| types::LeAudioContextType context_type_; |
| std::vector<std::weak_ptr<LeAudioDevice>> leAudioDevices_; |
| }; |
| |
| /* LeAudioDeviceGroup class represents a wraper helper over all device groups in |
| * le audio implementation. It allows to operate on device group from a list |
| * (vector container) using determinants like id. |
| */ |
| class LeAudioDeviceGroups { |
| public: |
| LeAudioDeviceGroup* Add(int group_id); |
| void Remove(const int group_id); |
| LeAudioDeviceGroup* FindById(int group_id); |
| std::vector<int> GetGroupsIds(void); |
| size_t Size(); |
| bool IsAnyInTransition(); |
| void Cleanup(void); |
| void Dump(int fd); |
| |
| private: |
| std::vector<std::unique_ptr<LeAudioDeviceGroup>> groups_; |
| }; |
| } // namespace le_audio |