1 /*
2 * Copyright (c) 2025 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 #ifndef LOG_TAG
17 #define LOG_TAG "AudioFocusInfoChangeCallbackImpl"
18 #endif
19
20 #include "audio_focus_info_change_callback_impl.h"
21
22 #include <mutex>
23 #include "audio_common_log.h"
24 #include "audio_errors.h"
25
26 namespace OHOS {
27 namespace AudioStandard {
AudioFocusInfoChangeCallbackImpl()28 AudioFocusInfoChangeCallbackImpl::AudioFocusInfoChangeCallbackImpl()
29 {
30 AUDIO_INFO_LOG("AudioFocusInfoChangeCallbackImpl constructor");
31 }
32
~AudioFocusInfoChangeCallbackImpl()33 AudioFocusInfoChangeCallbackImpl::~AudioFocusInfoChangeCallbackImpl()
34 {
35 AUDIO_INFO_LOG("AudioFocusInfoChangeCallbackImpl: destroy");
36 }
37
SaveCallback(const std::weak_ptr<AudioFocusInfoChangeCallback> & callback)38 void AudioFocusInfoChangeCallbackImpl::SaveCallback(const std::weak_ptr<AudioFocusInfoChangeCallback> &callback)
39 {
40 AUDIO_INFO_LOG("Entered %{public}s", __func__);
41 bool hasCallback = false;
42 std::lock_guard<std::mutex> cbListLock(cbListMutex_);
43 for (auto it = callbackList_.begin(); it != callbackList_.end(); ++it) {
44 if ((*it).lock() == callback.lock()) {
45 hasCallback = true;
46 }
47 }
48 if (!hasCallback) {
49 callbackList_.push_back(callback);
50 }
51 }
52
RemoveCallback(const std::weak_ptr<AudioFocusInfoChangeCallback> & callback)53 void AudioFocusInfoChangeCallbackImpl::RemoveCallback(const std::weak_ptr<AudioFocusInfoChangeCallback> &callback)
54 {
55 AUDIO_INFO_LOG("Entered %{public}s", __func__);
56 std::lock_guard<std::mutex> cbListLock(cbListMutex_);
57 callbackList_.remove_if([&callback](std::weak_ptr<AudioFocusInfoChangeCallback> &callback_) {
58 return callback_.lock() == callback.lock();
59 });
60 }
61
OnAudioFocusInfoChange(const std::list<std::pair<AudioInterrupt,AudioFocuState>> & focusInfoList)62 void AudioFocusInfoChangeCallbackImpl::OnAudioFocusInfoChange(
63 const std::list<std::pair<AudioInterrupt, AudioFocuState>> &focusInfoList)
64 {
65 AUDIO_DEBUG_LOG("on callback Entered AudioFocusInfoChangeCallbackImpl %{public}s", __func__);
66 std::vector<std::shared_ptr<AudioFocusInfoChangeCallback>> temp_;
67 std::unique_lock<std::mutex> cbListLock(cbListMutex_);
68 for (auto callback = callbackList_.begin(); callback != callbackList_.end(); ++callback) {
69 cb_ = (*callback).lock();
70 if (cb_ != nullptr) {
71 AUDIO_DEBUG_LOG("OnAudioFocusInfoChange : Notify event to app complete");
72 temp_.push_back(cb_);
73 } else {
74 AUDIO_ERR_LOG("OnAudioFocusInfoChange: callback is null");
75 }
76 }
77 cbListLock.unlock();
78 for (uint32_t i = 0; i < temp_.size(); i++) {
79 temp_[i]->OnAudioFocusInfoChange(focusInfoList);
80 }
81 return;
82 }
83
OnAudioFocusRequested(const AudioInterrupt & requestFocus)84 void AudioFocusInfoChangeCallbackImpl::OnAudioFocusRequested(const AudioInterrupt &requestFocus)
85 {
86 AUDIO_DEBUG_LOG("on callback Entered OnAudioFocusRequested %{public}s", __func__);
87
88 std::vector<std::shared_ptr<AudioFocusInfoChangeCallback>> temp_;
89 std::unique_lock<std::mutex> cbListLock(cbListMutex_);
90 for (auto callback = callbackList_.begin(); callback != callbackList_.end(); ++callback) {
91 cb_ = (*callback).lock();
92 if (cb_ != nullptr) {
93 AUDIO_DEBUG_LOG("OnAudioFocusRequested : Notify event to app complete");
94 temp_.push_back(cb_);
95 } else {
96 AUDIO_ERR_LOG("OnAudioFocusRequested: callback is null");
97 }
98 }
99 cbListLock.unlock();
100 for (uint32_t i = 0; i < temp_.size(); i++) {
101 temp_[i]->OnAudioFocusRequested(requestFocus);
102 }
103 return;
104 }
105
OnAudioFocusAbandoned(const AudioInterrupt & abandonFocus)106 void AudioFocusInfoChangeCallbackImpl::OnAudioFocusAbandoned(const AudioInterrupt &abandonFocus)
107 {
108 AUDIO_DEBUG_LOG("on callback Entered OnAudioFocusAbandoned %{public}s", __func__);
109 std::vector<std::shared_ptr<AudioFocusInfoChangeCallback>> temp_;
110 std::unique_lock<std::mutex> cbListLock(cbListMutex_);
111 for (auto callback = callbackList_.begin(); callback != callbackList_.end(); ++callback) {
112 cb_ = (*callback).lock();
113 if (cb_ != nullptr) {
114 AUDIO_DEBUG_LOG("OnAudioFocusAbandoned : Notify event to app complete");
115 temp_.push_back(cb_);
116 } else {
117 AUDIO_ERR_LOG("OnAudioFocusAbandoned: callback is null");
118 }
119 }
120 cbListLock.unlock();
121 for (uint32_t i = 0; i < temp_.size(); i++) {
122 temp_[i]->OnAudioFocusAbandoned(abandonFocus);
123 }
124 return;
125 }
126 }
127 }