1 /*
2  * Copyright (c) 2023 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 "IpcStreamInServer"
17 #endif
18 
19 #include <memory>
20 #include <cinttypes>
21 
22 #include "ipc_stream_in_server.h"
23 #include "audio_service_log.h"
24 #include "audio_errors.h"
25 #include "audio_schedule.h"
26 
27 namespace OHOS {
28 namespace AudioStandard {
StreamListenerHolder()29 StreamListenerHolder::StreamListenerHolder()
30 {
31     AUDIO_INFO_LOG("StreamListenerHolder()");
32 }
33 
~StreamListenerHolder()34 StreamListenerHolder::~StreamListenerHolder()
35 {
36     AUDIO_INFO_LOG("~StreamListenerHolder()");
37 }
38 
RegisterStreamListener(sptr<IpcStreamListener> listener)39 int32_t StreamListenerHolder::RegisterStreamListener(sptr<IpcStreamListener> listener)
40 {
41     std::lock_guard<std::mutex> lock(listenerMutex_);
42     // should only be set once
43     if (streamListener_ != nullptr) {
44         return ERR_INVALID_OPERATION;
45     }
46     streamListener_ = listener;
47     return SUCCESS;
48 }
49 
OnOperationHandled(Operation operation,int64_t result)50 int32_t StreamListenerHolder::OnOperationHandled(Operation operation, int64_t result)
51 {
52     std::lock_guard<std::mutex> lock(listenerMutex_);
53     CHECK_AND_RETURN_RET_LOG(streamListener_ != nullptr, ERR_OPERATION_FAILED, "stream listrener not set");
54     return streamListener_->OnOperationHandled(operation, result);
55 }
56 
Create(const AudioProcessConfig & config,int32_t & ret)57 sptr<IpcStreamInServer> IpcStreamInServer::Create(const AudioProcessConfig &config, int32_t &ret)
58 {
59     AudioMode mode = config.audioMode;
60     sptr<IpcStreamInServer> streamInServer = sptr<IpcStreamInServer>::MakeSptr(config, mode);
61     ret = streamInServer->Config();
62     if (ret != SUCCESS) {
63         AUDIO_ERR_LOG("IpcStreamInServer Config failed: %{public}d, uid: %{public}d",
64             ret, config.appInfo.appUid); // waiting for review: add uid.
65         streamInServer = nullptr;
66     }
67     return streamInServer;
68 }
69 
IpcStreamInServer(const AudioProcessConfig & config,AudioMode mode)70 IpcStreamInServer::IpcStreamInServer(const AudioProcessConfig &config, AudioMode mode) : config_(config), mode_(mode)
71 {
72     AUDIO_INFO_LOG("IpcStreamInServer(), uid: %{public}d", config.appInfo.appUid); // waiting for review: add uid.
73 }
74 
~IpcStreamInServer()75 IpcStreamInServer::~IpcStreamInServer()
76 {
77     AUDIO_INFO_LOG("~IpcStreamInServer(), uid: %{public}d", config_.appInfo.appUid); // waiting for review: add uid.
78     // avoid unexpected release in proRenderStreamImpl working thread
79     if (rendererInServer_ && (rendererInServer_->GetActualStreamManagerType() == DIRECT_PLAYBACK ||
80         rendererInServer_->GetActualStreamManagerType() == VOIP_PLAYBACK)) {
81         rendererInServer_->Release();
82     }
83 }
84 
Config()85 int32_t IpcStreamInServer::Config()
86 {
87     streamListenerHolder_ = std::make_shared<StreamListenerHolder>();
88 
89     if (mode_ == AUDIO_MODE_PLAYBACK) {
90         return ConfigRenderer();
91     }
92     if (mode_ == AUDIO_MODE_RECORD) {
93         return ConfigCapturer();
94     }
95     AUDIO_ERR_LOG("Config failed, mode is %{public}d", static_cast<int32_t>(mode_));
96     return ERR_OPERATION_FAILED;
97 }
98 
GetRenderer()99 std::shared_ptr<RendererInServer> IpcStreamInServer::GetRenderer()
100 {
101     if (mode_ != AUDIO_MODE_PLAYBACK || rendererInServer_ == nullptr) {
102         AUDIO_ERR_LOG("GetRenderer failed, mode is %{public}s", (mode_ != AUDIO_MODE_PLAYBACK ? " not playback" :
103             "playback, but renderer is null!"));
104         return nullptr;
105     }
106     return rendererInServer_;
107 }
108 
GetCapturer()109 std::shared_ptr<CapturerInServer> IpcStreamInServer::GetCapturer()
110 {
111     if (mode_ != AUDIO_MODE_RECORD || capturerInServer_ == nullptr) {
112         AUDIO_ERR_LOG("GetCapturer failed, mode is %{public}s", (mode_ != AUDIO_MODE_RECORD ? " not record" :
113             "record, but capturer is null!"));
114         return nullptr;
115     }
116     return capturerInServer_;
117 }
118 
ConfigRenderer()119 int32_t IpcStreamInServer::ConfigRenderer()
120 {
121     rendererInServer_ = std::make_shared<RendererInServer>(config_, streamListenerHolder_);
122     CHECK_AND_RETURN_RET_LOG(rendererInServer_ != nullptr, ERR_OPERATION_FAILED, "Create RendererInServer failed");
123     int32_t ret = rendererInServer_->Init();
124     CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERR_OPERATION_FAILED, "Init RendererInServer failed");
125     return SUCCESS;
126 }
127 
ConfigCapturer()128 int32_t IpcStreamInServer::ConfigCapturer()
129 {
130     capturerInServer_ = std::make_shared<CapturerInServer>(config_, streamListenerHolder_);
131     CHECK_AND_RETURN_RET_LOG(capturerInServer_ != nullptr, ERR_OPERATION_FAILED, "create CapturerInServer failed");
132     int32_t ret = capturerInServer_->Init();
133     CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERR_OPERATION_FAILED, "Init CapturerInServer failed");
134     return SUCCESS;
135 }
136 
RegisterStreamListener(sptr<IRemoteObject> object)137 int32_t IpcStreamInServer::RegisterStreamListener(sptr<IRemoteObject> object)
138 {
139     CHECK_AND_RETURN_RET_LOG(streamListenerHolder_ != nullptr, ERR_OPERATION_FAILED, "RegisterStreamListener failed");
140     sptr<IpcStreamListener> listener = iface_cast<IpcStreamListener>(object);
141     CHECK_AND_RETURN_RET_LOG(listener != nullptr, ERR_INVALID_PARAM, "RegisterStreamListener obj cast failed");
142     streamListenerHolder_->RegisterStreamListener(listener);
143 
144     // in plan: get session id, use it as key to find IpcStreamInServer
145     // in plan: listener->AddDeathRecipient( server ) // when client died, do release and clear works
146 
147     return SUCCESS;
148 }
149 
ResolveBuffer(std::shared_ptr<OHAudioBuffer> & buffer)150 int32_t IpcStreamInServer::ResolveBuffer(std::shared_ptr<OHAudioBuffer> &buffer)
151 {
152     AUDIO_INFO_LOG("Resolve buffer, mode: %{public}d", mode_);
153     if (mode_ == AUDIO_MODE_PLAYBACK && rendererInServer_ != nullptr) {
154         return rendererInServer_->ResolveBuffer(buffer);
155     }
156     if (mode_ == AUDIO_MODE_RECORD && capturerInServer_!= nullptr) {
157         return capturerInServer_->ResolveBuffer(buffer);
158     }
159     AUDIO_ERR_LOG("GetAudioSessionID failed, invalid mode: %{public}d", static_cast<int32_t>(mode_));
160     return ERR_OPERATION_FAILED;
161 }
162 
UpdatePosition()163 int32_t IpcStreamInServer::UpdatePosition()
164 {
165     if (mode_ == AUDIO_MODE_PLAYBACK && rendererInServer_ != nullptr) {
166         return rendererInServer_->UpdateWriteIndex();
167     }
168     if (mode_ == AUDIO_MODE_RECORD && capturerInServer_!= nullptr) {
169         return capturerInServer_->UpdateReadIndex();
170     }
171     AUDIO_ERR_LOG("UpdatePosition failed, invalid mode: %{public}d", static_cast<int32_t>(mode_));
172     return ERR_OPERATION_FAILED;
173 }
174 
GetAudioSessionID(uint32_t & sessionId)175 int32_t IpcStreamInServer::GetAudioSessionID(uint32_t &sessionId)
176 {
177     if (mode_ == AUDIO_MODE_PLAYBACK && rendererInServer_ != nullptr) {
178         return rendererInServer_->GetSessionId(sessionId);
179     }
180     if (mode_ == AUDIO_MODE_RECORD && capturerInServer_!= nullptr) {
181         return capturerInServer_->GetSessionId(sessionId);
182     }
183     AUDIO_ERR_LOG("GetAudioSessionID failed, invalid mode: %{public}d", static_cast<int32_t>(mode_));
184     return ERR_OPERATION_FAILED;
185 }
186 
Start()187 int32_t IpcStreamInServer::Start()
188 {
189     AUDIO_INFO_LOG("IpcStreamInServer::Start()");
190 
191     if (mode_ == AUDIO_MODE_PLAYBACK && rendererInServer_ != nullptr) {
192         return rendererInServer_->Start();
193     }
194     if (mode_ == AUDIO_MODE_RECORD && capturerInServer_!= nullptr) {
195         return capturerInServer_->Start();
196     }
197     AUDIO_ERR_LOG("Start failed, invalid mode: %{public}d", static_cast<int32_t>(mode_));
198     return ERR_OPERATION_FAILED;
199 }
200 
Pause()201 int32_t IpcStreamInServer::Pause()
202 {
203     if (mode_ == AUDIO_MODE_PLAYBACK && rendererInServer_ != nullptr) {
204         return rendererInServer_->Pause();
205     }
206     if (mode_ == AUDIO_MODE_RECORD && capturerInServer_!= nullptr) {
207         return capturerInServer_->Pause();
208     }
209     AUDIO_ERR_LOG("Pause failed, invalid mode: %{public}d", static_cast<int32_t>(mode_));
210     return ERR_OPERATION_FAILED;
211 }
212 
Stop()213 int32_t IpcStreamInServer::Stop()
214 {
215     if (mode_ == AUDIO_MODE_PLAYBACK && rendererInServer_ != nullptr) {
216         return rendererInServer_->Stop();
217     }
218     if (mode_ == AUDIO_MODE_RECORD && capturerInServer_!= nullptr) {
219         return capturerInServer_->Stop();
220     }
221     AUDIO_ERR_LOG("Stop failed, invalid mode: %{public}d", static_cast<int32_t>(mode_));
222     return ERR_OPERATION_FAILED;
223 }
224 
Release()225 int32_t IpcStreamInServer::Release()
226 {
227     UnscheduleReportData(config_.appInfo.appPid, clientTid_, clientBundleName_.c_str());
228     clientThreadPriorityRequested_ = false;
229     if (mode_ == AUDIO_MODE_PLAYBACK && rendererInServer_ != nullptr) {
230         return rendererInServer_->Release();
231     }
232     if (mode_ == AUDIO_MODE_RECORD && capturerInServer_!= nullptr) {
233         return capturerInServer_->Release();
234     }
235     AUDIO_ERR_LOG("Release failed, invalid mode: %{public}d", static_cast<int32_t>(mode_));
236     return ERR_OPERATION_FAILED;
237 }
238 
Flush()239 int32_t IpcStreamInServer::Flush()
240 {
241     if (mode_ == AUDIO_MODE_PLAYBACK && rendererInServer_ != nullptr) {
242         return rendererInServer_->Flush();
243     }
244     if (mode_ == AUDIO_MODE_RECORD && capturerInServer_!= nullptr) {
245         return capturerInServer_->Flush();
246     }
247     AUDIO_ERR_LOG("Flush failed, invalid mode: %{public}d", static_cast<int32_t>(mode_));
248     return ERR_OPERATION_FAILED;
249 }
250 
Drain(bool stopFlag)251 int32_t IpcStreamInServer::Drain(bool stopFlag)
252 {
253     if (mode_ == AUDIO_MODE_PLAYBACK && rendererInServer_ != nullptr) {
254         return rendererInServer_->Drain(stopFlag);
255     }
256     AUDIO_ERR_LOG("Drain failed, invalid mode: %{public}d", static_cast<int32_t>(mode_));
257     return ERR_OPERATION_FAILED;
258 }
259 
UpdatePlaybackCaptureConfig(const AudioPlaybackCaptureConfig & config)260 int32_t IpcStreamInServer::UpdatePlaybackCaptureConfig(const AudioPlaybackCaptureConfig &config)
261 {
262     if (mode_ == AUDIO_MODE_RECORD && capturerInServer_ != nullptr) {
263         return capturerInServer_->UpdatePlaybackCaptureConfig(config);
264     }
265     AUDIO_ERR_LOG("Failed, invalid mode: %{public}d", static_cast<int32_t>(mode_));
266     return ERR_OPERATION_FAILED;
267 }
268 
GetAudioTime(uint64_t & framePos,uint64_t & timestamp)269 int32_t IpcStreamInServer::GetAudioTime(uint64_t &framePos, uint64_t &timestamp)
270 {
271     if (mode_ == AUDIO_MODE_PLAYBACK && rendererInServer_ != nullptr) {
272         return rendererInServer_->GetAudioTime(framePos, timestamp);
273     }
274     if (mode_ == AUDIO_MODE_RECORD && capturerInServer_!= nullptr) {
275         return capturerInServer_->GetAudioTime(framePos, timestamp);
276     }
277     AUDIO_ERR_LOG("GetAudioTime failed, invalid mode: %{public}d", static_cast<int32_t>(mode_));
278     return ERR_OPERATION_FAILED;
279 }
280 
GetAudioPosition(uint64_t & framePos,uint64_t & timestamp,uint64_t & latency)281 int32_t IpcStreamInServer::GetAudioPosition(uint64_t &framePos, uint64_t &timestamp, uint64_t &latency)
282 {
283     if (mode_ != AUDIO_MODE_PLAYBACK || rendererInServer_ == nullptr) {
284         AUDIO_ERR_LOG("unsupported mode: %{public}d or renderer obj is nullptr", static_cast<int32_t>(mode_));
285         return ERR_OPERATION_FAILED;
286     }
287     return rendererInServer_->GetAudioPosition(framePos, timestamp, latency);
288 }
289 
GetLatency(uint64_t & latency)290 int32_t IpcStreamInServer::GetLatency(uint64_t &latency)
291 {
292     if (mode_ == AUDIO_MODE_PLAYBACK && rendererInServer_ != nullptr) {
293         return rendererInServer_->GetLatency(latency);
294     }
295     if (mode_ == AUDIO_MODE_RECORD && capturerInServer_!= nullptr) {
296         return capturerInServer_->GetLatency(latency);
297     }
298     AUDIO_ERR_LOG("GetAudioSessionID failed, invalid mode: %{public}d", static_cast<int32_t>(mode_));
299     return ERR_OPERATION_FAILED;
300 }
301 
SetRate(int32_t rate)302 int32_t IpcStreamInServer::SetRate(int32_t rate)
303 {
304     if (mode_ == AUDIO_MODE_PLAYBACK && rendererInServer_ != nullptr) {
305         return rendererInServer_->SetRate(rate);
306     }
307     AUDIO_ERR_LOG("SetRate failed, invalid mode: %{public}d", static_cast<int32_t>(mode_));
308     return ERR_OPERATION_FAILED;
309 }
310 
GetRate(int32_t & rate)311 int32_t IpcStreamInServer::GetRate(int32_t &rate)
312 {
313     // In plan
314     return ERR_OPERATION_FAILED;
315 }
316 
SetLowPowerVolume(float volume)317 int32_t IpcStreamInServer::SetLowPowerVolume(float volume)
318 {
319     if (mode_ == AUDIO_MODE_PLAYBACK && rendererInServer_ != nullptr) {
320         return rendererInServer_->SetLowPowerVolume(volume);
321     }
322     AUDIO_ERR_LOG("SetLowPowerVolume failed, invalid mode: %{public}d", static_cast<int32_t>(mode_));
323     return ERR_OPERATION_FAILED;
324 }
325 
GetLowPowerVolume(float & volume)326 int32_t IpcStreamInServer::GetLowPowerVolume(float &volume)
327 {
328     if (mode_ == AUDIO_MODE_PLAYBACK && rendererInServer_ != nullptr) {
329         return rendererInServer_->GetLowPowerVolume(volume);
330     }
331     AUDIO_ERR_LOG("GetLowPowerVolume failed, invalid mode: %{public}d", static_cast<int32_t>(mode_));
332     return ERR_OPERATION_FAILED;
333 }
334 
SetAudioEffectMode(int32_t effectMode)335 int32_t IpcStreamInServer::SetAudioEffectMode(int32_t effectMode)
336 {
337     if (mode_ == AUDIO_MODE_PLAYBACK && rendererInServer_ != nullptr) {
338         return rendererInServer_->SetAudioEffectMode(effectMode);
339     }
340     AUDIO_ERR_LOG("SetAudioEffectMode failed, invalid mode: %{public}d", static_cast<int32_t>(mode_));
341     return ERR_OPERATION_FAILED;
342 }
343 
GetAudioEffectMode(int32_t & effectMode)344 int32_t IpcStreamInServer::GetAudioEffectMode(int32_t &effectMode)
345 {
346     if (mode_ == AUDIO_MODE_PLAYBACK && rendererInServer_ != nullptr) {
347         return rendererInServer_->GetAudioEffectMode(effectMode);
348     }
349     AUDIO_ERR_LOG("GetAudioEffectMode failed, invalid mode: %{public}d", static_cast<int32_t>(mode_));
350     return ERR_OPERATION_FAILED;
351 }
352 
SetPrivacyType(int32_t privacyType)353 int32_t IpcStreamInServer::SetPrivacyType(int32_t privacyType)
354 {
355     if (mode_ == AUDIO_MODE_PLAYBACK && rendererInServer_ != nullptr) {
356         return rendererInServer_->SetPrivacyType(privacyType);
357     }
358     AUDIO_ERR_LOG("SetPrivacyType failed, invalid mode: %{public}d", static_cast<int32_t>(mode_));
359     return ERR_OPERATION_FAILED;
360 }
361 
GetPrivacyType(int32_t & privacyType)362 int32_t IpcStreamInServer::GetPrivacyType(int32_t &privacyType)
363 {
364     if (mode_ == AUDIO_MODE_PLAYBACK && rendererInServer_ != nullptr) {
365         return rendererInServer_->GetPrivacyType(privacyType);
366     }
367     AUDIO_ERR_LOG("GetPrivacyType failed, invalid mode: %{public}d", static_cast<int32_t>(mode_));
368     return ERR_OPERATION_FAILED;
369 }
370 
SetOffloadMode(int32_t state,bool isAppBack)371 int32_t IpcStreamInServer::SetOffloadMode(int32_t state, bool isAppBack)
372 {
373     if (mode_ != AUDIO_MODE_PLAYBACK || rendererInServer_ == nullptr) {
374         AUDIO_ERR_LOG("failed, invalid mode: %{public}d, or rendererInServer_ is null: %{public}d,",
375             static_cast<int32_t>(mode_), rendererInServer_ == nullptr);
376         return ERR_OPERATION_FAILED;
377     }
378     return rendererInServer_->SetOffloadMode(state, isAppBack);
379 }
380 
UnsetOffloadMode()381 int32_t IpcStreamInServer::UnsetOffloadMode()
382 {
383     if (mode_ != AUDIO_MODE_PLAYBACK || rendererInServer_ == nullptr) {
384         AUDIO_ERR_LOG("failed, invalid mode: %{public}d, or rendererInServer_ is null: %{public}d,",
385             static_cast<int32_t>(mode_), rendererInServer_ == nullptr);
386         return ERR_OPERATION_FAILED;
387     }
388     return rendererInServer_->UnsetOffloadMode();
389 }
390 
GetOffloadApproximatelyCacheTime(uint64_t & timestamp,uint64_t & paWriteIndex,uint64_t & cacheTimeDsp,uint64_t & cacheTimePa)391 int32_t IpcStreamInServer::GetOffloadApproximatelyCacheTime(uint64_t &timestamp, uint64_t &paWriteIndex,
392     uint64_t &cacheTimeDsp, uint64_t &cacheTimePa)
393 {
394     if (mode_ != AUDIO_MODE_PLAYBACK || rendererInServer_ == nullptr) {
395         AUDIO_ERR_LOG("failed, invalid mode: %{public}d, or rendererInServer_ is null: %{public}d,",
396             static_cast<int32_t>(mode_), rendererInServer_ == nullptr);
397         return ERR_OPERATION_FAILED;
398     }
399     return rendererInServer_->GetOffloadApproximatelyCacheTime(timestamp, paWriteIndex, cacheTimeDsp, cacheTimePa);
400 }
401 
UpdateSpatializationState(bool spatializationEnabled,bool headTrackingEnabled)402 int32_t IpcStreamInServer::UpdateSpatializationState(bool spatializationEnabled, bool headTrackingEnabled)
403 {
404     if (mode_ != AUDIO_MODE_PLAYBACK || rendererInServer_ == nullptr) {
405         AUDIO_ERR_LOG("failed, invalid mode: %{public}d, or rendererInServer_ is null: %{public}d,",
406             static_cast<int32_t>(mode_), rendererInServer_ == nullptr);
407         return ERR_OPERATION_FAILED;
408     }
409     return rendererInServer_->UpdateSpatializationState(spatializationEnabled, headTrackingEnabled);
410 }
411 
GetStreamManagerType()412 int32_t IpcStreamInServer::GetStreamManagerType()
413 {
414     if (mode_ == AUDIO_MODE_PLAYBACK && rendererInServer_ != nullptr) {
415         return rendererInServer_->GetStreamManagerType();
416     }
417     AUDIO_ERR_LOG("mode is not playback or renderer is null");
418     return ERR_OPERATION_FAILED;
419 }
420 
SetSilentModeAndMixWithOthers(bool on)421 int32_t IpcStreamInServer::SetSilentModeAndMixWithOthers(bool on)
422 {
423     if (mode_ != AUDIO_MODE_PLAYBACK || rendererInServer_ == nullptr) {
424         AUDIO_ERR_LOG("failed, invalid mode: %{public}d, or rendererInServer_ is null: %{public}d,",
425             static_cast<int32_t>(mode_), rendererInServer_ == nullptr);
426         return ERR_OPERATION_FAILED;
427     }
428     return rendererInServer_->SetSilentModeAndMixWithOthers(on);
429 }
430 
SetClientVolume()431 int32_t IpcStreamInServer::SetClientVolume()
432 {
433     if (mode_ == AUDIO_MODE_PLAYBACK && rendererInServer_ != nullptr) {
434         return rendererInServer_->SetClientVolume();
435     }
436     AUDIO_ERR_LOG("mode is not playback or renderer is null");
437     return ERR_OPERATION_FAILED;
438 }
439 
SetMute(bool isMute)440 int32_t IpcStreamInServer::SetMute(bool isMute)
441 {
442     if (mode_ == AUDIO_MODE_PLAYBACK && rendererInServer_ != nullptr) {
443         return rendererInServer_->SetMute(isMute);
444     }
445     AUDIO_ERR_LOG("mode is not playback or renderer is null");
446     return ERR_OPERATION_FAILED;
447 }
448 
SetDuckFactor(float duckFactor)449 int32_t IpcStreamInServer::SetDuckFactor(float duckFactor)
450 {
451     if (mode_ == AUDIO_MODE_PLAYBACK && rendererInServer_ != nullptr) {
452         return rendererInServer_->SetDuckFactor(duckFactor);
453     }
454     AUDIO_ERR_LOG("mode is not playback or renderer is null");
455     return ERR_OPERATION_FAILED;
456 }
457 
RegisterThreadPriority(uint32_t tid,const std::string & bundleName)458 int32_t IpcStreamInServer::RegisterThreadPriority(uint32_t tid, const std::string &bundleName)
459 {
460     if (!clientThreadPriorityRequested_) {
461         clientTid_ = tid;
462         clientBundleName_ = bundleName;
463         ScheduleReportData(config_.appInfo.appPid, tid, bundleName.c_str());
464         return SUCCESS;
465     } else {
466         AUDIO_ERR_LOG("client thread priority requested");
467         return ERR_OPERATION_FAILED;
468     }
469 }
470 } // namespace AudioStandard
471 } // namespace OHOS
472