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 #ifndef LOG_TAG
16 #define LOG_TAG "AudioClientTrackerCallbackStub"
17 #endif
18
19 #include "audio_client_tracker_callback_stub.h"
20 #include "audio_policy_log.h"
21
22 namespace OHOS {
23 namespace AudioStandard {
AudioClientTrackerCallbackStub()24 AudioClientTrackerCallbackStub::AudioClientTrackerCallbackStub()
25 {
26 }
27
~AudioClientTrackerCallbackStub()28 AudioClientTrackerCallbackStub::~AudioClientTrackerCallbackStub()
29 {
30 }
31
SelectCodeCase(uint32_t code,StreamSetStateEventInternal & streamSetStateEventInternal)32 void AudioClientTrackerCallbackStub::SelectCodeCase(uint32_t code,
33 StreamSetStateEventInternal &streamSetStateEventInternal)
34 {
35 switch (code) {
36 case PAUSEDSTREAM:
37 return PausedStreamImpl(streamSetStateEventInternal);
38 case RESUMESTREAM:
39 return ResumeStreamImpl(streamSetStateEventInternal);
40 case MUTESTREAM:
41 return MuteStreamImpl(streamSetStateEventInternal);
42 case UNMUTESTREAM:
43 return UnmuteStreamImpl(streamSetStateEventInternal);
44 default:
45 AUDIO_ERR_LOG("default case, need check AudioListenerStub");
46 return;
47 }
48 return;
49 }
50
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)51 int AudioClientTrackerCallbackStub::OnRemoteRequest(
52 uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
53 {
54 CHECK_AND_RETURN_RET_LOG(data.ReadInterfaceToken() == GetDescriptor(), -1,
55 "AudioClientTrackerCallbackStub: ReadInterfaceToken failed");
56
57 switch (code) {
58 case PAUSEDSTREAM:
59 case RESUMESTREAM:
60 case MUTESTREAM:
61 case UNMUTESTREAM: {
62 StreamSetStateEventInternal sreamSetStateEventInternal = {};
63 sreamSetStateEventInternal.streamSetState= static_cast<StreamSetState>(data.ReadInt32());
64 sreamSetStateEventInternal.streamUsage = static_cast<StreamUsage>(data.ReadInt32());
65 SelectCodeCase(code, sreamSetStateEventInternal);
66 return AUDIO_OK;
67 }
68 case SETLOWPOWERVOL: {
69 float volume = data.ReadFloat();
70 SetLowPowerVolumeImpl(volume);
71 return AUDIO_OK;
72 }
73 case GETLOWPOWERVOL: {
74 float volume;
75 GetLowPowerVolumeImpl(volume);
76 reply.WriteFloat(volume);
77 return AUDIO_OK;
78 }
79 case GETSINGLESTREAMVOL: {
80 float volume;
81 GetSingleStreamVolumeImpl(volume);
82 reply.WriteFloat(volume);
83 return AUDIO_OK;
84 }
85 case SETOFFLOADMODE:
86 case UNSETOFFLOADMODE: {
87 return OffloadRemoteRequest(code, data, reply, option);
88 }
89 default: {
90 AUDIO_ERR_LOG("default case, need check AudioListenerStub");
91 return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
92 }
93 }
94
95 return 0;
96 }
97
OffloadRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)98 int AudioClientTrackerCallbackStub::OffloadRemoteRequest(
99 uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
100 {
101 if (code == SETOFFLOADMODE) {
102 int32_t state = data.ReadInt32();
103 bool isAppBack = data.ReadBool();
104 SetOffloadModeImpl(state, isAppBack);
105 return AUDIO_OK;
106 }
107
108 if (code == UNSETOFFLOADMODE) {
109 UnsetOffloadModeImpl();
110 return AUDIO_OK;
111 }
112 return 0;
113 }
114
SetClientTrackerCallback(const std::weak_ptr<AudioClientTracker> & callback)115 void AudioClientTrackerCallbackStub::SetClientTrackerCallback(
116 const std::weak_ptr<AudioClientTracker> &callback)
117 {
118 std::unique_lock<std::mutex> lock(clientTrackerMutex_);
119 callback_ = callback;
120 }
121
UnsetClientTrackerCallback()122 void AudioClientTrackerCallbackStub::UnsetClientTrackerCallback()
123 {
124 std::unique_lock<std::mutex> lock(clientTrackerMutex_);
125 callback_.reset();
126 }
127
MuteStreamImpl(const StreamSetStateEventInternal & streamSetStateEventInternal)128 void AudioClientTrackerCallbackStub::MuteStreamImpl(
129 const StreamSetStateEventInternal &streamSetStateEventInternal)
130 {
131 std::unique_lock<std::mutex> lock(clientTrackerMutex_);
132 std::shared_ptr<AudioClientTracker> cb = callback_.lock();
133 lock.unlock();
134 if (cb != nullptr) {
135 cb->MuteStreamImpl(streamSetStateEventInternal);
136 } else {
137 AUDIO_WARNING_LOG("AudioClientTrackerCallbackStub: MuteStreamImpl callback_ is nullptr");
138 }
139 }
140
UnmuteStreamImpl(const StreamSetStateEventInternal & streamSetStateEventInternal)141 void AudioClientTrackerCallbackStub::UnmuteStreamImpl(
142 const StreamSetStateEventInternal &streamSetStateEventInternal)
143 {
144 std::unique_lock<std::mutex> lock(clientTrackerMutex_);
145 std::shared_ptr<AudioClientTracker> cb = callback_.lock();
146 lock.unlock();
147 if (cb != nullptr) {
148 cb->UnmuteStreamImpl(streamSetStateEventInternal);
149 } else {
150 AUDIO_WARNING_LOG("AudioClientTrackerCallbackStub: UnmuteStreamImpl callback_ is nullptr");
151 }
152 }
153
PausedStreamImpl(const StreamSetStateEventInternal & streamSetStateEventInternal)154 void AudioClientTrackerCallbackStub::PausedStreamImpl(
155 const StreamSetStateEventInternal &streamSetStateEventInternal)
156 {
157 std::unique_lock<std::mutex> lock(clientTrackerMutex_);
158 std::shared_ptr<AudioClientTracker> cb = callback_.lock();
159 lock.unlock();
160 if (cb != nullptr) {
161 cb->PausedStreamImpl(streamSetStateEventInternal);
162 } else {
163 AUDIO_WARNING_LOG("AudioClientTrackerCallbackStub: PausedStreamImpl callback_ is nullptr");
164 }
165 }
166
SetLowPowerVolumeImpl(float volume)167 void AudioClientTrackerCallbackStub::SetLowPowerVolumeImpl(float volume)
168 {
169 std::unique_lock<std::mutex> lock(clientTrackerMutex_);
170 std::shared_ptr<AudioClientTracker> cb = callback_.lock();
171 lock.unlock();
172 if (cb != nullptr) {
173 cb->SetLowPowerVolumeImpl(volume);
174 } else {
175 AUDIO_WARNING_LOG("AudioClientTrackerCallbackStub: SetLowPowerVolumeImpl callback_ is nullptr");
176 }
177 }
178
ResumeStreamImpl(const StreamSetStateEventInternal & streamSetStateEventInternal)179 void AudioClientTrackerCallbackStub::ResumeStreamImpl(
180 const StreamSetStateEventInternal &streamSetStateEventInternal)
181 {
182 std::unique_lock<std::mutex> lock(clientTrackerMutex_);
183 std::shared_ptr<AudioClientTracker> cb = callback_.lock();
184 lock.unlock();
185 if (cb != nullptr) {
186 cb->ResumeStreamImpl(streamSetStateEventInternal);
187 } else {
188 AUDIO_WARNING_LOG("AudioClientTrackerCallbackStub: ResumeStreamImpl callback_ is nullptr");
189 }
190 }
191
SetOffloadModeImpl(int32_t state,bool isAppBack)192 void AudioClientTrackerCallbackStub::SetOffloadModeImpl(int32_t state, bool isAppBack)
193 {
194 std::unique_lock<std::mutex> lock(clientTrackerMutex_);
195 std::shared_ptr<AudioClientTracker> cb = callback_.lock();
196 lock.unlock();
197 if (cb != nullptr) {
198 cb->SetOffloadModeImpl(state, isAppBack);
199 } else {
200 AUDIO_WARNING_LOG("AudioClientTrackerCallbackStub: SetOffloadModeImpl callback_ is nullptr");
201 }
202 }
203
UnsetOffloadModeImpl()204 void AudioClientTrackerCallbackStub::UnsetOffloadModeImpl()
205 {
206 std::unique_lock<std::mutex> lock(clientTrackerMutex_);
207 std::shared_ptr<AudioClientTracker> cb = callback_.lock();
208 lock.unlock();
209 if (cb != nullptr) {
210 cb->UnsetOffloadModeImpl();
211 } else {
212 AUDIO_WARNING_LOG("AudioClientTrackerCallbackStub: UnsetOffloadModeImpl callback_ is nullptr");
213 }
214 }
215
GetLowPowerVolumeImpl(float & volume)216 void AudioClientTrackerCallbackStub::GetLowPowerVolumeImpl(float &volume)
217 {
218 std::unique_lock<std::mutex> lock(clientTrackerMutex_);
219 std::shared_ptr<AudioClientTracker> cb = callback_.lock();
220 lock.unlock();
221 if (cb != nullptr) {
222 cb->GetLowPowerVolumeImpl(volume);
223 } else {
224 AUDIO_WARNING_LOG("AudioClientTrackerCallbackStub: GetLowPowerVolumeImpl callback_ is nullptr");
225 }
226 }
227
GetSingleStreamVolumeImpl(float & volume)228 void AudioClientTrackerCallbackStub::GetSingleStreamVolumeImpl(float &volume)
229 {
230 std::unique_lock<std::mutex> lock(clientTrackerMutex_);
231 std::shared_ptr<AudioClientTracker> cb = callback_.lock();
232 lock.unlock();
233 if (cb != nullptr) {
234 cb->GetSingleStreamVolumeImpl(volume);
235 } else {
236 AUDIO_WARNING_LOG("AudioClientTrackerCallbackStub: GetSingleStreamVolumeImpl callback_ is nullptr");
237 }
238 }
239 } // namespace AudioStandard
240 } // namespace OHOS
241