1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16
17 #include "audio_stream_event_dispatcher.h"
18 #include "i_standard_capturer_state_change_listener.h"
19 #include "i_standard_renderer_state_change_listener.h"
20
21 namespace OHOS {
22 namespace AudioStandard {
AudioStreamEventDispatcher()23 AudioStreamEventDispatcher::AudioStreamEventDispatcher()
24 {
25 AUDIO_DEBUG_LOG("AudioStreamEventDispatcher::AudioStreamEventDispatcher()");
26 }
27
~AudioStreamEventDispatcher()28 AudioStreamEventDispatcher::~AudioStreamEventDispatcher()
29 {
30 AUDIO_DEBUG_LOG("AudioStreamEventDispatcher::~AudioStreamEventDispatcher()");
31 }
32
addRendererListener(int32_t clientPid,const std::shared_ptr<AudioRendererStateChangeCallback> & callback)33 void AudioStreamEventDispatcher::addRendererListener(int32_t clientPid,
34 const std::shared_ptr<AudioRendererStateChangeCallback> &callback)
35 {
36 std::lock_guard<std::mutex> lock(rendererStateChangeListnerMutex_);
37 rendererCBMap_[clientPid] = callback;
38 AUDIO_DEBUG_LOG("AudioStreamEventDispatcher::addRendererListener:client %{public}d added", clientPid);
39 }
40
removeRendererListener(int32_t clientPid)41 void AudioStreamEventDispatcher::removeRendererListener(int32_t clientPid)
42 {
43 std::lock_guard<std::mutex> lock(rendererStateChangeListnerMutex_);
44 if (rendererCBMap_.erase(clientPid)) {
45 AUDIO_INFO_LOG("AudioStreamEventDispatcher::removeRendererListener:client %{public}d done", clientPid);
46 return;
47 }
48 AUDIO_DEBUG_LOG("AudioStreamEventDispatcher::removeRendererListener:client %{public}d not present", clientPid);
49 }
50
addCapturerListener(int32_t clientPid,const std::shared_ptr<AudioCapturerStateChangeCallback> & callback)51 void AudioStreamEventDispatcher::addCapturerListener(int32_t clientPid,
52 const std::shared_ptr<AudioCapturerStateChangeCallback> &callback)
53 {
54 std::lock_guard<std::mutex> lock(capturerStateChangeListnerMutex_);
55 capturerCBMap_[clientPid] = callback;
56 AUDIO_DEBUG_LOG("AudioStreamEventDispatcher::addCapturerListener:client %{public}d added", clientPid);
57 }
58
removeCapturerListener(int32_t clientPid)59 void AudioStreamEventDispatcher::removeCapturerListener(int32_t clientPid)
60 {
61 std::lock_guard<std::mutex> lock(capturerStateChangeListnerMutex_);
62 if (capturerCBMap_.erase(clientPid)) {
63 AUDIO_INFO_LOG("AudioStreamEventDispatcher::removeCapturerListener:client %{public}d done", clientPid);
64 return;
65 }
66 AUDIO_DEBUG_LOG("AudioStreamEventDispatcher::removeCapturerListener:client %{public}d not present", clientPid);
67 }
68
SendRendererInfoEventToDispatcher(AudioMode mode,std::vector<std::unique_ptr<AudioRendererChangeInfo>> & audioRendererChangeInfos)69 void AudioStreamEventDispatcher::SendRendererInfoEventToDispatcher(AudioMode mode,
70 std::vector<std::unique_ptr<AudioRendererChangeInfo>> &audioRendererChangeInfos)
71 {
72 AUDIO_DEBUG_LOG("AudioStreamEventDispatcher::SendRendererInfoEventToDispatcher:mode %{public}d ", mode);
73
74 std::lock_guard<std::mutex> lock(streamStateChangeQueueMutex_);
75
76 std::vector<std::unique_ptr<AudioRendererChangeInfo>> rendererChangeInfos;
77 for (const auto &changeInfo : audioRendererChangeInfos) {
78 rendererChangeInfos.push_back(std::make_unique<AudioRendererChangeInfo>(*changeInfo));
79 }
80
81 unique_ptr<StreamStateChangeRequest> streamStateChangeRequest = make_unique<StreamStateChangeRequest>();
82 if (!streamStateChangeRequest) {
83 AUDIO_ERR_LOG("AudioStreamEventDispatcher::SendRendererInfoEventToDispatcher:Memory alloc failed!!");
84 return;
85 }
86 streamStateChangeRequest->mode = mode;
87 streamStateChangeRequest->audioRendererChangeInfos = move(rendererChangeInfos);
88 streamStateChangeQueue_.push(move(streamStateChangeRequest));
89 DispatcherEvent();
90 }
91
SendCapturerInfoEventToDispatcher(AudioMode mode,std::vector<std::unique_ptr<AudioCapturerChangeInfo>> & audioCapturerChangeInfos)92 void AudioStreamEventDispatcher::SendCapturerInfoEventToDispatcher(AudioMode mode,
93 std::vector<std::unique_ptr<AudioCapturerChangeInfo>> &audioCapturerChangeInfos)
94 {
95 AUDIO_DEBUG_LOG("AudioStreamEventDispatcher::SendCapturerInfoEventToDispatcher:mode %{public}d ", mode);
96
97 std::lock_guard<std::mutex> lock(streamStateChangeQueueMutex_);
98
99 std::vector<std::unique_ptr<AudioCapturerChangeInfo>> capturerChangeInfos;
100 for (const auto &changeInfo : audioCapturerChangeInfos) {
101 capturerChangeInfos.push_back(std::make_unique<AudioCapturerChangeInfo>(*changeInfo));
102 }
103
104 unique_ptr<StreamStateChangeRequest> streamStateChangeRequest = make_unique<StreamStateChangeRequest>();
105 if (!streamStateChangeRequest) {
106 AUDIO_ERR_LOG("AudioStreamEventDispatcher::Memory alloc failed!!");
107 return;
108 }
109 streamStateChangeRequest->mode = mode;
110 streamStateChangeRequest->audioCapturerChangeInfos = move(capturerChangeInfos);
111 streamStateChangeQueue_.push(move(streamStateChangeRequest));
112 DispatcherEvent();
113 }
114
HandleRendererStreamStateChange(const unique_ptr<StreamStateChangeRequest> & streamStateChangeRequest)115 void AudioStreamEventDispatcher::HandleRendererStreamStateChange(
116 const unique_ptr<StreamStateChangeRequest> &streamStateChangeRequest)
117 {
118 std::lock_guard<std::mutex> lock(rendererStateChangeListnerMutex_);
119 for (auto it = rendererCBMap_.begin(); it != rendererCBMap_.end(); ++it) {
120 std::shared_ptr<AudioRendererStateChangeCallback> rendererStateChangeCb = it->second;
121 if (rendererStateChangeCb == nullptr) {
122 AUDIO_ERR_LOG("rendererStateChangeCb : nullptr for client : %{public}d", it->first);
123 it = rendererCBMap_.erase(it);
124 continue;
125 }
126 rendererStateChangeCb->OnRendererStateChange(streamStateChangeRequest->audioRendererChangeInfos);
127 }
128 }
129
HandleCapturerStreamStateChange(const unique_ptr<StreamStateChangeRequest> & streamStateChangeRequest)130 void AudioStreamEventDispatcher::HandleCapturerStreamStateChange(
131 const unique_ptr<StreamStateChangeRequest> &streamStateChangeRequest)
132 {
133 std::lock_guard<std::mutex> lock(capturerStateChangeListnerMutex_);
134 for (auto it = capturerCBMap_.begin(); it != capturerCBMap_.end(); ++it) {
135 std::shared_ptr<AudioCapturerStateChangeCallback> capturerStateChangeCb = it->second;
136 if (capturerStateChangeCb == nullptr) {
137 AUDIO_ERR_LOG("capturerStateChangeCb : nullptr for client : %{public}d", it->first);
138 it = capturerCBMap_.erase(it);
139 continue;
140 }
141 capturerStateChangeCb->OnCapturerStateChange(streamStateChangeRequest->audioCapturerChangeInfos);
142 }
143 }
144
DispatcherEvent()145 void AudioStreamEventDispatcher::DispatcherEvent()
146 {
147 AUDIO_DEBUG_LOG("DispatcherEvent entered");
148 while (!streamStateChangeQueue_.empty()) {
149 std::unique_ptr<StreamStateChangeRequest> streamStateChangeRequest =
150 std::move(streamStateChangeQueue_.front());
151 if (streamStateChangeRequest != nullptr) {
152 if (streamStateChangeRequest->mode == AUDIO_MODE_PLAYBACK) {
153 HandleRendererStreamStateChange(streamStateChangeRequest);
154 } else {
155 HandleCapturerStreamStateChange(streamStateChangeRequest);
156 }
157 }
158 streamStateChangeQueue_.pop();
159 }
160 }
161 } // namespace AudioStandard
162 } // namespace OHOS
163