| /****************************************************************************** |
| * |
| * Copyright 2021 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. |
| * |
| ******************************************************************************/ |
| |
| |
| #include "bta_bap_uclient_api.h" |
| #include "ucast_client_int.h" |
| #include "bt_trace.h" |
| |
| namespace bluetooth { |
| namespace bap { |
| namespace ucast { |
| |
| using namespace std; |
| using bluetooth::bap::ucast::UstreamManagers; |
| using bluetooth::bap::ucast::UstreamManager; |
| |
| std::map<StreamState, int> state_map = { |
| {StreamState::DISCONNECTED, StreamTracker::kStateIdle} , |
| {StreamState::CONNECTING, StreamTracker::kStateConnecting}, |
| {StreamState::CONNECTED, StreamTracker::kStateConnected}, |
| {StreamState::STARTING, StreamTracker::kStateStarting}, |
| {StreamState::STREAMING, StreamTracker::kStateStreaming}, |
| {StreamState::STOPPING, StreamTracker::kStateStopping}, |
| {StreamState::DISCONNECTING, StreamTracker::kStateDisconnecting}, |
| {StreamState::RECONFIGURING, StreamTracker::kStateReconfiguring} |
| }; |
| |
| StreamContext *StreamContexts::FindByType(StreamType stream_type) { |
| auto iter = std::find_if(strm_contexts.begin(), strm_contexts.end(), |
| [&stream_type](StreamContext *context) { |
| return ((context->stream_type.type == stream_type.type) |
| && (context->stream_type.direction == |
| stream_type.direction)); |
| }); |
| |
| if (iter == strm_contexts.end()) { |
| return nullptr; |
| } else { |
| return (*iter); |
| } |
| } |
| |
| std::vector<StreamContext *> StreamContexts::FindByAseAttachedState( |
| uint16_t ase_id, StreamAttachedState state) { |
| std::vector<StreamContext *> contexts_list; |
| for(auto i = strm_contexts.begin(); i != strm_contexts.end();i++) { |
| if(static_cast<uint8_t>((*i)->attached_state) & |
| static_cast<uint8_t>(state)) { |
| for(auto j = (*i)->stream_ids.begin(); j != (*i)->stream_ids.end();j++) { |
| if(j->ase_id == ase_id) { |
| contexts_list.push_back(*i); |
| break; |
| } |
| } |
| } |
| } |
| return contexts_list; |
| } |
| |
| StreamContext *StreamContexts::FindOrAddByType(StreamType stream_type) { |
| auto iter = std::find_if(strm_contexts.begin(), strm_contexts.end(), |
| [&stream_type](StreamContext *context) { |
| return ((context->stream_type.type == |
| stream_type.type) && |
| (context->stream_type.direction == |
| stream_type.direction)); |
| }); |
| |
| if (iter == strm_contexts.end()) { |
| StreamContext *context = new StreamContext(stream_type); |
| strm_contexts.push_back(context); |
| return context; |
| } else { |
| return (*iter); |
| } |
| } |
| |
| void StreamContexts::Remove(StreamType stream_type) { |
| for (auto it = strm_contexts.begin(); it != strm_contexts.end();) { |
| if (((*it)->stream_type.type = stream_type.type) && |
| ((*it)->stream_type.direction = stream_type.direction)) { |
| delete(*it); |
| it = strm_contexts.erase(it); |
| } else { |
| it++; |
| } |
| } |
| } |
| |
| bool StreamContexts::IsAseAttached(StreamType stream_type) { |
| return false; |
| |
| } |
| |
| StreamContext* StreamContexts::FindByAseId(uint16_t ase_id) { |
| auto iter = std::find_if(strm_contexts.begin(), strm_contexts.end(), |
| [&ase_id](StreamContext *context) { |
| auto it = std::find_if(context->stream_ids.begin(), |
| context->stream_ids.end(), |
| [&ase_id](StreamIdType id) { |
| return (id.ase_id == ase_id); |
| }); |
| if (it != context->stream_ids.end()) { |
| return true; |
| } else return false; |
| |
| }); |
| |
| if (iter == strm_contexts.end()) { |
| return nullptr; |
| } else { |
| return (*iter); |
| } |
| } |
| |
| StreamTracker* StreamTrackers::FindOrAddByType(int init_state_id, |
| UstreamManager *strm_mgr, |
| std::vector<StreamConnect> *connect_streams, |
| std::vector<StreamReconfig> *reconfig_streams, |
| std::vector<StreamType> *streams, |
| StreamControlType ops_type) { |
| bool found = false; |
| auto iter = stream_trackers.begin(); |
| while (iter != stream_trackers.end() && !found) { |
| if((*iter)->GetControlType() == ops_type) { |
| if(ops_type == StreamControlType::Connect) { |
| // compare connection streams |
| std::vector<StreamConnect> *conn_strms = (*iter)->GetConnStreams(); |
| if(conn_strms->size() == connect_streams->size()) { |
| uint8_t len = connect_streams->size(); |
| for (uint8_t i = 0; i < len ; i++) { |
| StreamConnect src = conn_strms->at(i); |
| StreamConnect dst = connect_streams->at(i); |
| if((src.stream_type.type == dst.stream_type.type) && |
| (src.stream_type.direction == dst.stream_type.direction)) { |
| LOG(WARNING) << __func__ << " StreamConnect found"; |
| found = true; |
| break; |
| } |
| } |
| } |
| } else if(ops_type == StreamControlType::Reconfig) { |
| // compare connection streams |
| std::vector<StreamReconfig> *reconf_strms = (*iter)->GetReconfStreams(); |
| if(reconf_strms->size() == reconfig_streams->size()) { |
| uint8_t len = reconfig_streams->size(); |
| for (uint8_t i = 0; i < len ; i++) { |
| StreamReconfig src = reconf_strms->at(i); |
| StreamReconfig dst = reconfig_streams->at(i); |
| if((src.stream_type.type == dst.stream_type.type) && |
| (src.stream_type.direction == dst.stream_type.direction)) { |
| LOG(WARNING) << __func__ << " StreamReconfig found"; |
| found = true; |
| break; |
| } |
| } |
| } |
| } else if(ops_type != StreamControlType::None && |
| ops_type != StreamControlType::UpdateStream) { |
| // compare connection streams |
| std::vector<StreamType> *strms = (*iter)->GetStreams(); |
| if(strms->size() == streams->size()) { |
| uint8_t len = streams->size(); |
| for (uint8_t i = 0; i < len ; i++) { |
| StreamType src = strms->at(i); |
| StreamType dst = streams->at(i); |
| if((src.type == dst.type) && |
| (src.direction == dst.direction)) { |
| LOG(WARNING) << __func__ << " StreamType found"; |
| found = true; |
| break; |
| } |
| } |
| } |
| } |
| } |
| iter++; |
| } |
| |
| if (iter == stream_trackers.end()) { |
| StreamTracker *tracker = new StreamTracker(init_state_id, strm_mgr, |
| connect_streams, reconfig_streams, |
| streams, ops_type); |
| stream_trackers.push_back(tracker); |
| return tracker; |
| } else { |
| return (*iter); |
| } |
| } |
| |
| bool StreamTrackers::Remove(std::vector<StreamType> streams, |
| StreamControlType ops_type) { |
| return true; |
| } |
| |
| std::vector<StreamTracker *> StreamTrackers::GetTrackersByStates( |
| std::vector<int> *state_ids) { |
| vector<StreamTracker *> trackers; |
| for (auto i = stream_trackers.begin(); |
| i != stream_trackers.end();i++) { |
| for (auto j = state_ids->begin(); j != state_ids->end();j++) { |
| if((*i)->StateId() == *j) { |
| LOG(WARNING) << __func__ << " tracker found"; |
| trackers.push_back(*i); |
| } |
| } |
| } |
| return trackers; |
| } |
| |
| void StreamTrackers::RemoveByStates(std::vector<int> state_ids) { |
| for (auto i = stream_trackers.begin(); |
| i != stream_trackers.end();) { |
| bool found = false; |
| for (auto j = state_ids.begin(); j != state_ids.end();j++) { |
| if((*i)->StateId() == *j) { |
| LOG(WARNING) << __func__ << " tracker found"; |
| found = true; |
| break; |
| } |
| } |
| if(found) { |
| delete(*i); |
| i = stream_trackers.erase(i); |
| } else { |
| i++; |
| } |
| } |
| } |
| |
| |
| std::map<StreamTracker * , std::vector<StreamType> > |
| StreamTrackers::GetTrackersByType( |
| std::vector<StreamType> *streams) { |
| std::vector<StreamType> req_types = *streams; |
| std::vector<StreamType> all_types; |
| std::map<StreamTracker * , std::vector<StreamType> > tracker_and_type_map; |
| for (auto iter = stream_trackers.begin(); iter != stream_trackers.end(); |
| iter++) { |
| all_types.clear(); |
| if((*iter)->GetControlType() == StreamControlType::Connect) { |
| // compare connection streams |
| std::vector<StreamConnect> *conn_strms = (*iter)->GetConnStreams(); |
| uint8_t len = conn_strms->size(); |
| for (uint8_t i = 0; i < len ; i++) { |
| StreamConnect src = conn_strms->at(i); |
| all_types.push_back(src.stream_type); |
| } |
| } else if((*iter)->GetControlType() == StreamControlType::Reconfig) { |
| // compare connection streams |
| std::vector<StreamReconfig> *reconf_strms = (*iter)->GetReconfStreams(); |
| uint8_t len = reconf_strms->size(); |
| for (uint8_t i = 0; i < len ; i++) { |
| StreamReconfig src = reconf_strms->at(i); |
| all_types.push_back(src.stream_type); |
| } |
| } else if((*iter)->GetControlType() == StreamControlType::UpdateStream) { |
| // compare connection streams |
| std::vector<StreamUpdate> *update_streams = (*iter)->GetMetaUpdateStreams(); |
| uint8_t len = update_streams->size(); |
| for (uint8_t i = 0; i < len ; i++) { |
| StreamUpdate src = update_streams->at(i); |
| all_types.push_back(src.stream_type); |
| } |
| } else if((*iter)->GetControlType() != StreamControlType::None) { |
| // compare connection streams |
| std::vector<StreamType> *strms = (*iter)->GetStreams(); |
| uint8_t len = strms->size(); |
| for (uint8_t i = 0; i < len ; i++) { |
| StreamType src = strms->at(i); |
| all_types.push_back(src); |
| } |
| } |
| uint8_t count = 0; |
| std::vector<StreamType> filtered_types; |
| if(all_types.size() <= req_types.size()) { |
| filtered_types.clear(); |
| for (auto it = all_types.begin(); it != all_types.end(); it++) { |
| for (auto it_2 = req_types.begin(); it_2 != req_types.end();) { |
| if (((it_2)->type == it->type) && |
| ((it_2)->direction == it->direction)) { |
| filtered_types.push_back(*it_2); |
| tracker_and_type_map[*iter] = filtered_types; |
| it_2 = req_types.erase(it_2); |
| count++; |
| } else { |
| it_2++; |
| } |
| } |
| } |
| if(all_types.size() != count) { |
| LOG(ERROR) << __func__ << " invalid request"; |
| } |
| } else { |
| LOG(ERROR) << __func__ << " invalid request"; |
| } |
| } |
| if(req_types.size()) { |
| tracker_and_type_map[nullptr] = req_types; |
| } |
| return tracker_and_type_map; |
| } |
| |
| |
| StreamTracker *StreamTrackers::FindByStreamsType( |
| std::vector<StreamType> *streams) { |
| bool found = false; |
| auto iter = stream_trackers.begin(); |
| while (iter != stream_trackers.end()) { |
| if((*iter)->GetControlType() == StreamControlType::Connect) { |
| // compare connection streams |
| std::vector<StreamConnect> *conn_strms = (*iter)->GetConnStreams(); |
| if(conn_strms->size() == streams->size()) { |
| uint8_t len = streams->size(); |
| for (uint8_t i = 0; i < len ; i++) { |
| StreamConnect src = conn_strms->at(i); |
| StreamType dst = streams->at(i); |
| if((src.stream_type.type == dst.type) && |
| (src.stream_type.direction == dst.direction)) { |
| LOG(WARNING) << __func__ << " StreamConnect found"; |
| found = true; |
| break; |
| } |
| } |
| } |
| } else if((*iter)->GetControlType() == StreamControlType::Reconfig) { |
| // compare connection streams |
| std::vector<StreamReconfig> *reconf_strms = (*iter)->GetReconfStreams(); |
| if(reconf_strms->size() == streams->size()) { |
| uint8_t len = streams->size(); |
| for (uint8_t i = 0; i < len ; i++) { |
| StreamReconfig src = reconf_strms->at(i); |
| StreamType dst = streams->at(i); |
| if((src.stream_type.type == dst.type) && |
| (src.stream_type.direction == dst.direction)) { |
| LOG(WARNING) << __func__ << " StreamReconfig found"; |
| found = true; |
| break; |
| } |
| } |
| } |
| } else if((*iter)->GetControlType() == StreamControlType::UpdateStream) { |
| // compare connection streams |
| std::vector<StreamUpdate> *update_strms = (*iter)->GetMetaUpdateStreams(); |
| if(update_strms->size() == streams->size()) { |
| uint8_t len = streams->size(); |
| for (uint8_t i = 0; i < len ; i++) { |
| StreamUpdate src = update_strms->at(i); |
| StreamType dst = streams->at(i); |
| if((src.stream_type.type == dst.type) && |
| (src.stream_type.direction == dst.direction)) { |
| LOG(WARNING) << __func__ << " StreamUpdate found"; |
| found = true; |
| break; |
| } |
| } |
| } |
| } else if((*iter)->GetControlType() != StreamControlType::None) { |
| // compare connection streams |
| std::vector<StreamType> *strms = (*iter)->GetStreams(); |
| if(strms->size() == streams->size()) { |
| uint8_t len = streams->size(); |
| for (uint8_t i = 0; i < len ; i++) { |
| StreamType src = strms->at(i); |
| StreamType dst = streams->at(i); |
| if((src.type == dst.type) && |
| (src.direction == dst.direction)) { |
| LOG(WARNING) << __func__ << " StreamType found"; |
| found = true; |
| break; |
| } |
| } |
| } |
| } |
| if(found) break; |
| iter++; |
| } |
| |
| if (iter == stream_trackers.end()) { |
| return nullptr; |
| } else { |
| return (*iter); |
| } |
| } |
| |
| bool StreamTrackers::ChangeOpType( StreamType stream_type, |
| StreamControlType new_ops_type) { |
| return true; |
| } |
| |
| bool StreamTrackers::IsStreamTrackerValid(StreamTracker* tracker, |
| std::vector<int> *state_ids) { |
| vector<StreamTracker *> trackers_ = GetTrackersByStates(state_ids); |
| LOG(WARNING) << __func__; |
| if(trackers_.empty()) return false; |
| |
| for (auto it = trackers_.begin(); it != trackers_.end(); it++) { |
| if ((*it) == tracker) { |
| LOG(WARNING) << __func__ <<": Cached Tracker is valid"; |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| bool UstreamManager::PushEventToTracker(uint32_t event, void *p_data, |
| std::vector<int> *state_ids) { |
| vector<StreamTracker *> trackers = stream_trackers.GetTrackersByStates( |
| state_ids); |
| if(trackers.empty()) return false; |
| |
| for (auto it = trackers.begin(); it != trackers.end(); it++) { |
| (*it)->ProcessEvent(event, p_data); |
| } |
| return true; |
| } |
| |
| |
| std::map<int , std::vector<StreamType> > UstreamManager::SplitContextOnState( |
| std::vector<StreamType> *streams) { |
| StreamContexts *contexts = GetStreamContexts(); |
| std::vector<StreamType> req_types = *streams; |
| std::map<int , std::vector<StreamType> > state_and_type_map; |
| |
| for (auto it = req_types.begin(); it != req_types.end();) { |
| StreamContext *context = contexts->FindOrAddByType(*it); |
| if (context) { |
| int state = state_map[context->stream_state]; |
| state_and_type_map[state].push_back(*it); |
| it = req_types.erase(it); |
| } else { |
| it++; |
| } |
| } |
| return state_and_type_map; |
| } |
| |
| void UstreamManager::ProcessEvent(uint32_t event, void *p_data) { |
| LOG(WARNING) << __func__ <<": Event: " << GetEventName(event) |
| <<", bt_addr: " << GetAddress(); |
| |
| std::vector<int> stable_state_ids = { |
| StreamTracker::kStateConnected, |
| StreamTracker::kStateStreaming, |
| StreamTracker::kStateIdle |
| }; |
| |
| std::vector<int> transient_state_ids = { |
| StreamTracker::kStateConnecting, |
| StreamTracker::kStateReconfiguring, |
| StreamTracker::kStateDisconnecting, |
| StreamTracker::kStateStarting, |
| StreamTracker::kStateStopping, |
| StreamTracker::kStateUpdating, |
| }; |
| StreamContexts *contexts = GetStreamContexts(); |
| |
| switch (event) { |
| |
| case BAP_CONNECT_REQ_EVT: { |
| BapConnect *evt_data = (BapConnect *) p_data; |
| std::vector<StreamConnect> conn_streams = evt_data->streams; |
| LOG(WARNING) << __func__ << ": size: " << conn_streams.size(); |
| |
| for (auto it = conn_streams.begin(); it != conn_streams.end();) { |
| StreamContext *context = contexts->FindOrAddByType(it->stream_type); |
| if(context && context->stream_state != StreamState::DISCONNECTED) { |
| LOG(WARNING) << __func__ << ": Stream is not in disconnected state"; |
| it = conn_streams.erase(it); |
| } else { |
| it++; |
| } |
| } |
| |
| if(!conn_streams.size()) { |
| LOG(ERROR) << __func__ << ": All streams are not in disconnected state"; |
| break; |
| } |
| |
| // validate the combinations media Tx or voice TX|RX |
| StreamTracker *tracker = stream_trackers.FindOrAddByType( |
| StreamTracker::kStateIdle, |
| this, &conn_streams, nullptr, nullptr, |
| StreamControlType::Connect); |
| |
| if(tracker) { |
| tracker->Start(); |
| tracker->ProcessEvent(event, p_data); |
| } |
| } break; |
| |
| case BAP_DISCONNECT_REQ_EVT: { |
| BapDisconnect *evt_data = (BapDisconnect *) p_data; |
| std::vector<StreamType> disc_streams = evt_data->streams; |
| BapDisconnect int_evt_data; |
| |
| for (auto it = disc_streams.begin(); it != disc_streams.end();) { |
| StreamContext *context = contexts->FindOrAddByType(*it); |
| if(!context || context->stream_state == StreamState::DISCONNECTED) { |
| LOG(WARNING) << __func__ << " Stream is already disconnected"; |
| it = disc_streams.erase(it); |
| } else { |
| it++; |
| } |
| } |
| |
| if(!disc_streams.size()) { |
| LOG(ERROR) << __func__ << " All streams are already disconnected"; |
| break; |
| } |
| |
| LOG(WARNING) << __func__ << " disc streams size " << disc_streams.size(); |
| |
| // validate the combinations media Tx or voice TX|RX |
| std::map<StreamTracker * , std::vector<StreamType> > |
| tracker_and_type_list = |
| stream_trackers.GetTrackersByType(&disc_streams); |
| |
| |
| // check if all streams disconnection or subset of streams |
| // create the new tracker |
| for (auto itr = tracker_and_type_list.begin(); |
| itr != tracker_and_type_list.end(); itr++) { |
| if(itr->first == nullptr) { |
| std::map<int , std::vector<StreamType> > |
| list = SplitContextOnState(&itr->second); |
| for (auto itr_2 = list.begin(); itr_2 != list.end(); itr_2++) { |
| StreamTracker *tracker = stream_trackers.FindOrAddByType( |
| itr_2->first, |
| this, nullptr, nullptr, &itr_2->second, |
| StreamControlType::Disconnect); |
| LOG(ERROR) << __func__ << " new tracker start "; |
| tracker->Start(); |
| int_evt_data.streams = itr_2->second; |
| tracker->ProcessEvent(event, &int_evt_data); |
| } |
| } else { |
| LOG(ERROR) << __func__ << " existing tracker start "; |
| StreamTracker *tracker = itr->first; |
| int_evt_data.streams = itr->second; |
| tracker->ProcessEvent(event, &int_evt_data); |
| } |
| } |
| } break; |
| |
| case BAP_START_REQ_EVT: { |
| BapStart *evt_data = (BapStart *) p_data; |
| std::vector<StreamType> start_streams = evt_data->streams; |
| LOG(WARNING) << __func__ << " start streams size " << start_streams.size(); |
| |
| for (auto it = start_streams.begin(); it != start_streams.end();) { |
| StreamContext *context = contexts->FindOrAddByType(*it); |
| if(!context || context->stream_state != StreamState::CONNECTED) { |
| LOG(WARNING) << __func__ << " Stream is not in connected state"; |
| it = start_streams.erase(it); |
| } else { |
| it++; |
| } |
| } |
| |
| if(!start_streams.size()) { |
| LOG(WARNING) << __func__ << " Not eligible for stream start"; |
| break; |
| } |
| |
| // validate the combinations media Tx or voice TX|RX |
| StreamTracker *tracker = stream_trackers.FindByStreamsType( |
| &start_streams); |
| // create new tracker |
| if(tracker == nullptr) { |
| StreamTracker *tracker = stream_trackers.FindOrAddByType( |
| StreamTracker::kStateConnected, |
| this, nullptr, nullptr, &start_streams, |
| StreamControlType::Start); |
| tracker->Start(); |
| tracker->ProcessEvent(event, p_data); |
| } else { |
| tracker->ProcessEvent(event, p_data); |
| } |
| } break; |
| |
| case BAP_STOP_REQ_EVT: { |
| BapStop *evt_data = (BapStop *) p_data; |
| std::vector<StreamType> stop_streams = evt_data->streams; |
| LOG(WARNING) << __func__ << " stop streams size " << stop_streams.size(); |
| |
| for (auto it = stop_streams.begin(); it != stop_streams.end();) { |
| StreamContext *context = contexts->FindOrAddByType(*it); |
| if(!context || (context->stream_state != StreamState::STREAMING && |
| context->stream_state != StreamState::STARTING)) { |
| LOG(WARNING) << __func__ << " Stream is not in streaming state"; |
| it = stop_streams.erase(it); |
| } else { |
| it++; |
| } |
| } |
| |
| if(!stop_streams.size()) { |
| LOG(WARNING) << __func__ << " Not eligible for stream stop"; |
| break; |
| } |
| |
| StreamTracker *tracker = stream_trackers.FindByStreamsType( |
| &stop_streams); |
| // create the new tracker |
| if(tracker == nullptr) { |
| // validate the combinations media Tx or voice TX|RX |
| StreamTracker *tracker = stream_trackers.FindOrAddByType( |
| StreamTracker::kStateStreaming, |
| this, nullptr, nullptr, &stop_streams, |
| StreamControlType::Stop); |
| tracker->Start(); |
| tracker->ProcessEvent(event, p_data); |
| } else { |
| tracker->ProcessEvent(event, p_data); |
| } |
| } break; |
| |
| case BAP_STREAM_UPDATE_REQ_EVT: { |
| BapStreamUpdate *evt_data = (BapStreamUpdate *) p_data; |
| std::vector<StreamUpdate> update_streams = evt_data->update_streams; |
| std::vector<StreamType> streams; |
| |
| for (auto it = update_streams.begin(); it != update_streams.end();) { |
| StreamContext *context = contexts->FindOrAddByType(it->stream_type); |
| if(!context || (context->stream_state != StreamState::STREAMING && |
| context->stream_state != StreamState::STARTING)) { |
| LOG(WARNING) << __func__ << " Stream is not in proper state"; |
| it = update_streams.erase(it); |
| } else { |
| it++; |
| } |
| } |
| |
| if(!update_streams.size()) { |
| LOG(WARNING) << __func__ << " All streams are not in proper state"; |
| break; |
| } |
| |
| for (auto it = update_streams.begin(); |
| it != update_streams.end(); it++) { |
| StreamType type = it->stream_type; |
| streams.push_back(type); |
| } |
| |
| LOG(WARNING) << __func__ << " update streams size " << streams.size(); |
| |
| StreamTracker *tracker = stream_trackers.FindByStreamsType( |
| &streams); |
| // create the new tracker |
| if(tracker == nullptr) { |
| // validate the combinations media Tx or voice TX|RX |
| StreamTracker *tracker = stream_trackers.FindOrAddByType( |
| StreamTracker::kStateStreaming, |
| this, nullptr, nullptr, nullptr, |
| StreamControlType::UpdateStream); |
| tracker->Start(); |
| tracker->ProcessEvent(event, p_data); |
| } else { |
| tracker->ProcessEvent(event, p_data); |
| } |
| } break; |
| |
| case BAP_RECONFIG_REQ_EVT: { |
| BapReconfig *evt_data = (BapReconfig *) p_data; |
| std::vector<StreamReconfig> reconf_streams = evt_data->streams; |
| std::vector<StreamType> streams; |
| |
| for (auto it = reconf_streams.begin(); it != reconf_streams.end();) { |
| StreamContext *context = contexts->FindOrAddByType(it->stream_type); |
| if(!context || context->stream_state != StreamState::CONNECTED) { |
| LOG(WARNING) << __func__ << " Stream is not in Connected state"; |
| it = reconf_streams.erase(it); |
| } else { |
| it++; |
| } |
| } |
| |
| if(!reconf_streams.size()) { |
| LOG(WARNING) << __func__ << " All streams are not connected"; |
| break; |
| } |
| |
| for (auto it = reconf_streams.begin(); |
| it != reconf_streams.end(); it++) { |
| StreamType type = it->stream_type; |
| streams.push_back(type); |
| } |
| |
| LOG(WARNING) << __func__ << " reconf streams size " << streams.size(); |
| |
| StreamTracker *tracker = stream_trackers.FindByStreamsType( |
| &streams); |
| // create the new tracker |
| if(tracker == nullptr) { |
| // validate the combinations media Tx or voice TX|RX |
| StreamTracker *tracker = stream_trackers.FindOrAddByType( |
| StreamTracker::kStateConnected, |
| this, nullptr, &reconf_streams, nullptr, |
| StreamControlType::Reconfig); |
| tracker->Start(); |
| tracker->ProcessEvent(event, p_data); |
| } else { |
| tracker->ProcessEvent(event, p_data); |
| } |
| } break; |
| |
| case PACS_CONNECTION_STATE_EVT: { |
| PacsConnectionState *pacs_state = (PacsConnectionState *) p_data; |
| UpdatePacsState(pacs_state->state); |
| int state = StreamTracker::kStateIdle; |
| if (pacs_state->state != ConnectionState::DISCONNECTED) { |
| if(PushEventToTracker(event, p_data, &transient_state_ids)) { |
| break; |
| } else { |
| |
| std::vector<StreamContext *> *context_list = contexts->GetAllContexts(); |
| std::vector<StreamType> streams; |
| |
| for (auto it = context_list->begin(); it != context_list->end(); it++) { |
| if((*it)->stream_state != StreamState::DISCONNECTED) { |
| streams.push_back((*it)->stream_type); |
| state = state_map[(*it)->stream_state]; |
| } |
| } |
| |
| StreamTracker *tracker = stream_trackers.FindByStreamsType( |
| &streams); |
| // create the new tracker |
| if(tracker == nullptr) { |
| // validate the combinations media Tx or voice TX|RX |
| StreamTracker *tracker = stream_trackers.FindOrAddByType( |
| state, |
| this, nullptr, nullptr, &streams, |
| StreamControlType::Disconnect); |
| tracker->Start(); |
| tracker->ProcessEvent(event, p_data); |
| } else { |
| tracker->ProcessEvent(event, p_data); |
| } |
| } |
| } else { |
| |
| std::vector<StreamContext *> *context_list = contexts->GetAllContexts(); |
| std::vector<StreamType> disc_streams; |
| |
| for (auto it = context_list->begin(); it != context_list->end(); it++) { |
| if((*it)->stream_state != StreamState::DISCONNECTED) { |
| disc_streams.push_back((*it)->stream_type); |
| } |
| } |
| |
| LOG(WARNING) << __func__ << ": size: " << disc_streams.size(); |
| |
| // validate the combinations media Tx or voice TX|RX |
| std::map<StreamTracker * , std::vector<StreamType> > |
| tracker_and_type_list = |
| stream_trackers.GetTrackersByType(&disc_streams); |
| |
| // check if all streams disconnection or subset of streams |
| // create the new tracker |
| for (auto itr = tracker_and_type_list.begin(); |
| itr != tracker_and_type_list.end(); itr++) { |
| if(itr->first == nullptr) { |
| std::map<int , std::vector<StreamType> > |
| list = SplitContextOnState(&itr->second); |
| for (auto itr_2 = list.begin(); itr_2 != list.end(); itr_2++) { |
| StreamTracker *tracker = stream_trackers.FindOrAddByType( |
| itr_2->first, |
| this, nullptr, nullptr, &itr_2->second, |
| StreamControlType::Disconnect); |
| LOG(ERROR) << __func__ << " new tracker start "; |
| tracker->Start(); |
| tracker->ProcessEvent(event, p_data); |
| } |
| } else { |
| LOG(ERROR) << __func__ << " existing tracker start "; |
| StreamTracker *tracker = itr->first; |
| tracker->ProcessEvent(event, p_data); |
| } |
| } |
| } |
| } break; |
| |
| case PACS_AUDIO_CONTEXT_RES_EVT: { |
| // update the same event to upper layers also |
| PacsAvailableContexts *contexts = (PacsAvailableContexts *) p_data; |
| ucl_callbacks->OnStreamAvailable( |
| address, |
| (contexts->available_contexts >> 16), |
| (contexts->available_contexts & 0xFFFF)); |
| std::vector<int> state_ids = { StreamTracker::kStateStarting, |
| StreamTracker::kStateUpdating}; |
| PushEventToTracker(event, p_data, &state_ids); |
| } break; |
| |
| case PACS_DISCOVERY_RES_EVT: |
| case ASCS_DISCOVERY_RES_EVT: { |
| // validate the combinations media Tx or voice TX|RX |
| std::vector<int> state_ids = { StreamTracker::kStateConnecting, |
| StreamTracker::kStateReconfiguring }; |
| PushEventToTracker(event, p_data, &state_ids); |
| } break; |
| |
| case ASCS_CONNECTION_STATE_EVT: { |
| AscsConnectionState *ascs_state = (AscsConnectionState *) p_data; |
| UpdateAscsState(ascs_state->state); |
| PushEventToTracker(event, p_data, &transient_state_ids); |
| } break; |
| |
| case ASCS_ASE_OP_FAILED_EVT: { |
| if(PushEventToTracker(event, p_data, &transient_state_ids)) { |
| break; |
| } |
| } break; |
| |
| case ASCS_ASE_STATE_EVT: { |
| if(PushEventToTracker(event, p_data, &transient_state_ids)) { |
| break; |
| } |
| // create strm trackers based on ase ID and push it to |
| // newly created tracker. |
| // TODO Handle Releasing , disabling, codec configured states |
| // initiated from remote device |
| |
| AscsState *ascs = ((AscsState *) p_data); |
| UcastAudioStream *audio_stream = nullptr; |
| // find out the stream for the given ase id |
| uint8_t ase_id = ascs->ase_params.ase_id; |
| std::vector<StreamType> streams; |
| int state = StreamTracker::kStateIdle; |
| |
| UcastAudioStreams *audio_strms = GetAudioStreams(); |
| audio_stream = audio_strms->FindByAseId(ase_id); |
| if(audio_stream) { |
| StreamType type = { |
| .type = audio_stream->audio_context, |
| .direction = audio_stream->direction |
| }; |
| streams.push_back(type); |
| state = audio_stream->overall_state; |
| } |
| |
| LOG(WARNING) << __func__ << " size " << streams.size(); |
| |
| if (ascs->ase_params.ase_state == ascs::ASE_STATE_RELEASING) { |
| |
| StreamTracker *tracker = stream_trackers.FindOrAddByType( |
| state, |
| this, nullptr, nullptr, &streams, |
| StreamControlType::Disconnect); |
| tracker->Start(); |
| tracker->ProcessEvent(event, p_data); |
| } else if (ascs->ase_params.ase_state == ascs::ASE_STATE_DISABLING) { |
| |
| StreamTracker *tracker = stream_trackers.FindOrAddByType( |
| state, |
| this, nullptr, nullptr, &streams, |
| StreamControlType::Stop); |
| tracker->Start(); |
| tracker->ProcessEvent(event, p_data); |
| } else if (ascs->ase_params.ase_state == |
| ascs::ASE_STATE_CODEC_CONFIGURED) { |
| // TODO reconfig from remote device |
| } else if (ascs->ase_params.ase_state == |
| ascs::ASE_STATE_QOS_CONFIGURED) { |
| // this can happen when CIS is lost and detected on remote side |
| // first so it will immediately transition to QOS configured. |
| StreamTracker *tracker = stream_trackers.FindOrAddByType( |
| state, |
| this, nullptr, nullptr, &streams, |
| StreamControlType::Stop); |
| tracker->Start(); |
| tracker->ProcessEvent(event, p_data); |
| } |
| } break; |
| |
| case CIS_GROUP_STATE_EVT: { |
| // validate the combinations media Tx or voice TX|RX |
| std::vector<int> state_ids = { StreamTracker::kStateStarting, |
| StreamTracker::kStateStopping, |
| StreamTracker::kStateDisconnecting }; |
| PushEventToTracker(event, p_data, &state_ids); |
| } break; |
| |
| case CIS_STATE_EVT: { |
| CisStreamState *data = (CisStreamState *) p_data; |
| |
| if(PushEventToTracker(event, p_data, &transient_state_ids)) { |
| break; |
| } |
| |
| // find out the stream for the given ase id |
| int state = StreamTracker::kStateIdle; |
| std::vector<StreamType> streams; |
| |
| UcastAudioStreams *audio_strms = GetAudioStreams(); |
| std::vector<UcastAudioStream *> cis_streams = audio_strms->FindByCisId( |
| data->cig_id, data->cis_id); |
| |
| |
| if(cis_streams.empty()) break; |
| |
| for (auto it = cis_streams.begin(); it != cis_streams.end(); it++) { |
| StreamType type = { |
| .type = (*it)->audio_context, |
| .direction = (*it)->direction |
| }; |
| streams.push_back(type); |
| state = (*it)->overall_state; |
| } |
| |
| LOG(WARNING) << __func__ << " size " << streams.size(); |
| |
| // create strm trackers based on CIS ID and push it to |
| // newly created tracker. |
| // CIS disconnected |
| if(data->state == CisState::READY) { |
| StreamTracker *tracker = stream_trackers.FindOrAddByType( |
| state, |
| this, nullptr, nullptr, &streams, |
| StreamControlType::Stop); |
| tracker->Start(); |
| tracker->ProcessEvent(event, p_data); |
| } |
| } break; |
| |
| case BAP_TIME_OUT_EVT: { |
| BapTimeout* evt_data = (BapTimeout*) p_data; |
| |
| //Get Cached tracker and check if it is valid |
| if (stream_trackers.IsStreamTrackerValid(evt_data->tracker, |
| &transient_state_ids)) { |
| PushEventToTracker(event, p_data, &transient_state_ids); |
| } else { |
| LOG(WARNING) << __func__ << ": Tracker is not valid "; |
| } |
| } break; |
| |
| default: |
| break; |
| } |
| |
| // look for all stream trackers which are moved to stable states |
| // like connected, streaming, idle, and destroy those trackers here |
| stream_trackers.RemoveByStates(stable_state_ids); |
| } |
| |
| // TODO to introduce a queue for serializing the Audio stream establishment |
| UstreamManager* UstreamManagers::FindByAddress(const RawAddress& address) { |
| auto iter = std::find_if(strm_mgrs.begin(), strm_mgrs.end(), |
| [&address](UstreamManager *strm_mgr) { |
| return strm_mgr->GetAddress() == address; |
| }); |
| |
| return (iter == strm_mgrs.end()) ? nullptr : (*iter); |
| } |
| |
| UstreamManager* UstreamManagers::FindorAddByAddress(const RawAddress& address, |
| PacsClient *pacs_client, uint16_t pacs_client_id, |
| AscsClient *ascs_client, CisInterface *cis_intf, |
| UcastClientCallbacks* ucl_callbacks, |
| BapAlarm *bap_alarm) { |
| auto iter = std::find_if(strm_mgrs.begin(), strm_mgrs.end(), |
| [&address](UstreamManager *strm_mgr) { |
| return strm_mgr->GetAddress() == address; |
| }); |
| |
| if (iter == strm_mgrs.end()) { |
| UstreamManager *strm_mgr = new UstreamManager(address, pacs_client, |
| pacs_client_id, ascs_client, cis_intf, |
| ucl_callbacks, bap_alarm); |
| strm_mgrs.push_back(strm_mgr); |
| return strm_mgr; |
| } else { |
| return (*iter); |
| } |
| } |
| |
| std::vector<UstreamManager *> *UstreamManagers::GetAllManagers() { |
| return &strm_mgrs; |
| |
| } |
| |
| void UstreamManagers::Remove(const RawAddress& address) { |
| for (auto it = strm_mgrs.begin(); it != strm_mgrs.end();) { |
| if ((*it)->GetAddress() == address) { |
| delete(*it); |
| it = strm_mgrs.erase(it); |
| } else { |
| it++; |
| } |
| } |
| } |
| |
| } // namespace ucast |
| } // namespace bap |
| } // namespace bluetooth |
