1 /*
2 * Copyright (c) 2023-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 #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(clientPid_, 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 #ifdef HAS_FEATURE_INNERCAPTURER
263 if (mode_ == AUDIO_MODE_RECORD && capturerInServer_ != nullptr) {
264 return capturerInServer_->UpdatePlaybackCaptureConfig(config);
265 }
266 AUDIO_ERR_LOG("Failed, invalid mode: %{public}d", static_cast<int32_t>(mode_));
267 return ERR_OPERATION_FAILED;
268 #else
269 return ERROR;
270 #endif
271 }
272
GetAudioTime(uint64_t & framePos,uint64_t & timestamp)273 int32_t IpcStreamInServer::GetAudioTime(uint64_t &framePos, uint64_t ×tamp)
274 {
275 if (mode_ == AUDIO_MODE_PLAYBACK && rendererInServer_ != nullptr) {
276 return rendererInServer_->GetAudioTime(framePos, timestamp);
277 }
278 if (mode_ == AUDIO_MODE_RECORD && capturerInServer_!= nullptr) {
279 return capturerInServer_->GetAudioTime(framePos, timestamp);
280 }
281 AUDIO_ERR_LOG("GetAudioTime failed, invalid mode: %{public}d", static_cast<int32_t>(mode_));
282 return ERR_OPERATION_FAILED;
283 }
284
GetAudioPosition(uint64_t & framePos,uint64_t & timestamp,uint64_t & latency)285 int32_t IpcStreamInServer::GetAudioPosition(uint64_t &framePos, uint64_t ×tamp, uint64_t &latency)
286 {
287 if (mode_ != AUDIO_MODE_PLAYBACK || rendererInServer_ == nullptr) {
288 AUDIO_ERR_LOG("unsupported mode: %{public}d or renderer obj is nullptr", static_cast<int32_t>(mode_));
289 return ERR_OPERATION_FAILED;
290 }
291 return rendererInServer_->GetAudioPosition(framePos, timestamp, latency);
292 }
293
GetLatency(uint64_t & latency)294 int32_t IpcStreamInServer::GetLatency(uint64_t &latency)
295 {
296 if (mode_ == AUDIO_MODE_PLAYBACK && rendererInServer_ != nullptr) {
297 return rendererInServer_->GetLatency(latency);
298 }
299 if (mode_ == AUDIO_MODE_RECORD && capturerInServer_!= nullptr) {
300 return capturerInServer_->GetLatency(latency);
301 }
302 AUDIO_ERR_LOG("GetAudioSessionID failed, invalid mode: %{public}d", static_cast<int32_t>(mode_));
303 return ERR_OPERATION_FAILED;
304 }
305
SetRate(int32_t rate)306 int32_t IpcStreamInServer::SetRate(int32_t rate)
307 {
308 if (mode_ == AUDIO_MODE_PLAYBACK && rendererInServer_ != nullptr) {
309 return rendererInServer_->SetRate(rate);
310 }
311 AUDIO_ERR_LOG("SetRate failed, invalid mode: %{public}d", static_cast<int32_t>(mode_));
312 return ERR_OPERATION_FAILED;
313 }
314
GetRate(int32_t & rate)315 int32_t IpcStreamInServer::GetRate(int32_t &rate)
316 {
317 // In plan
318 return ERR_OPERATION_FAILED;
319 }
320
SetLowPowerVolume(float volume)321 int32_t IpcStreamInServer::SetLowPowerVolume(float volume)
322 {
323 if (mode_ == AUDIO_MODE_PLAYBACK && rendererInServer_ != nullptr) {
324 return rendererInServer_->SetLowPowerVolume(volume);
325 }
326 AUDIO_ERR_LOG("SetLowPowerVolume failed, invalid mode: %{public}d", static_cast<int32_t>(mode_));
327 return ERR_OPERATION_FAILED;
328 }
329
GetLowPowerVolume(float & volume)330 int32_t IpcStreamInServer::GetLowPowerVolume(float &volume)
331 {
332 if (mode_ == AUDIO_MODE_PLAYBACK && rendererInServer_ != nullptr) {
333 return rendererInServer_->GetLowPowerVolume(volume);
334 }
335 AUDIO_ERR_LOG("GetLowPowerVolume failed, invalid mode: %{public}d", static_cast<int32_t>(mode_));
336 return ERR_OPERATION_FAILED;
337 }
338
SetAudioEffectMode(int32_t effectMode)339 int32_t IpcStreamInServer::SetAudioEffectMode(int32_t effectMode)
340 {
341 if (mode_ == AUDIO_MODE_PLAYBACK && rendererInServer_ != nullptr) {
342 return rendererInServer_->SetAudioEffectMode(effectMode);
343 }
344 AUDIO_ERR_LOG("SetAudioEffectMode failed, invalid mode: %{public}d", static_cast<int32_t>(mode_));
345 return ERR_OPERATION_FAILED;
346 }
347
GetAudioEffectMode(int32_t & effectMode)348 int32_t IpcStreamInServer::GetAudioEffectMode(int32_t &effectMode)
349 {
350 if (mode_ == AUDIO_MODE_PLAYBACK && rendererInServer_ != nullptr) {
351 return rendererInServer_->GetAudioEffectMode(effectMode);
352 }
353 AUDIO_ERR_LOG("GetAudioEffectMode failed, invalid mode: %{public}d", static_cast<int32_t>(mode_));
354 return ERR_OPERATION_FAILED;
355 }
356
SetPrivacyType(int32_t privacyType)357 int32_t IpcStreamInServer::SetPrivacyType(int32_t privacyType)
358 {
359 if (mode_ == AUDIO_MODE_PLAYBACK && rendererInServer_ != nullptr) {
360 return rendererInServer_->SetPrivacyType(privacyType);
361 }
362 AUDIO_ERR_LOG("SetPrivacyType failed, invalid mode: %{public}d", static_cast<int32_t>(mode_));
363 return ERR_OPERATION_FAILED;
364 }
365
GetPrivacyType(int32_t & privacyType)366 int32_t IpcStreamInServer::GetPrivacyType(int32_t &privacyType)
367 {
368 if (mode_ == AUDIO_MODE_PLAYBACK && rendererInServer_ != nullptr) {
369 return rendererInServer_->GetPrivacyType(privacyType);
370 }
371 AUDIO_ERR_LOG("GetPrivacyType failed, invalid mode: %{public}d", static_cast<int32_t>(mode_));
372 return ERR_OPERATION_FAILED;
373 }
374
SetOffloadMode(int32_t state,bool isAppBack)375 int32_t IpcStreamInServer::SetOffloadMode(int32_t state, bool isAppBack)
376 {
377 if (mode_ != AUDIO_MODE_PLAYBACK || rendererInServer_ == nullptr) {
378 AUDIO_ERR_LOG("failed, invalid mode: %{public}d, or rendererInServer_ is null: %{public}d,",
379 static_cast<int32_t>(mode_), rendererInServer_ == nullptr);
380 return ERR_OPERATION_FAILED;
381 }
382 return rendererInServer_->SetOffloadMode(state, isAppBack);
383 }
384
UnsetOffloadMode()385 int32_t IpcStreamInServer::UnsetOffloadMode()
386 {
387 if (mode_ != AUDIO_MODE_PLAYBACK || rendererInServer_ == nullptr) {
388 AUDIO_ERR_LOG("failed, invalid mode: %{public}d, or rendererInServer_ is null: %{public}d,",
389 static_cast<int32_t>(mode_), rendererInServer_ == nullptr);
390 return ERR_OPERATION_FAILED;
391 }
392 return rendererInServer_->UnsetOffloadMode();
393 }
394
GetOffloadApproximatelyCacheTime(uint64_t & timestamp,uint64_t & paWriteIndex,uint64_t & cacheTimeDsp,uint64_t & cacheTimePa)395 int32_t IpcStreamInServer::GetOffloadApproximatelyCacheTime(uint64_t ×tamp, uint64_t &paWriteIndex,
396 uint64_t &cacheTimeDsp, uint64_t &cacheTimePa)
397 {
398 if (mode_ != AUDIO_MODE_PLAYBACK || rendererInServer_ == nullptr) {
399 AUDIO_ERR_LOG("failed, invalid mode: %{public}d, or rendererInServer_ is null: %{public}d,",
400 static_cast<int32_t>(mode_), rendererInServer_ == nullptr);
401 return ERR_OPERATION_FAILED;
402 }
403 return rendererInServer_->GetOffloadApproximatelyCacheTime(timestamp, paWriteIndex, cacheTimeDsp, cacheTimePa);
404 }
405
UpdateSpatializationState(bool spatializationEnabled,bool headTrackingEnabled)406 int32_t IpcStreamInServer::UpdateSpatializationState(bool spatializationEnabled, bool headTrackingEnabled)
407 {
408 if (mode_ != AUDIO_MODE_PLAYBACK || rendererInServer_ == nullptr) {
409 AUDIO_ERR_LOG("failed, invalid mode: %{public}d, or rendererInServer_ is null: %{public}d,",
410 static_cast<int32_t>(mode_), rendererInServer_ == nullptr);
411 return ERR_OPERATION_FAILED;
412 }
413 return rendererInServer_->UpdateSpatializationState(spatializationEnabled, headTrackingEnabled);
414 }
415
GetStreamManagerType()416 int32_t IpcStreamInServer::GetStreamManagerType()
417 {
418 if (mode_ == AUDIO_MODE_PLAYBACK && rendererInServer_ != nullptr) {
419 return rendererInServer_->GetStreamManagerType();
420 }
421 AUDIO_ERR_LOG("mode is not playback or renderer is null");
422 return ERR_OPERATION_FAILED;
423 }
424
SetSilentModeAndMixWithOthers(bool on)425 int32_t IpcStreamInServer::SetSilentModeAndMixWithOthers(bool on)
426 {
427 if (mode_ != AUDIO_MODE_PLAYBACK || rendererInServer_ == nullptr) {
428 AUDIO_ERR_LOG("failed, invalid mode: %{public}d, or rendererInServer_ is null: %{public}d,",
429 static_cast<int32_t>(mode_), rendererInServer_ == nullptr);
430 return ERR_OPERATION_FAILED;
431 }
432 return rendererInServer_->SetSilentModeAndMixWithOthers(on);
433 }
434
SetClientVolume()435 int32_t IpcStreamInServer::SetClientVolume()
436 {
437 if (mode_ == AUDIO_MODE_PLAYBACK && rendererInServer_ != nullptr) {
438 return rendererInServer_->SetClientVolume();
439 }
440 AUDIO_ERR_LOG("mode is not playback or renderer is null");
441 return ERR_OPERATION_FAILED;
442 }
443
SetMute(bool isMute)444 int32_t IpcStreamInServer::SetMute(bool isMute)
445 {
446 if (mode_ == AUDIO_MODE_PLAYBACK && rendererInServer_ != nullptr) {
447 return rendererInServer_->SetMute(isMute);
448 }
449 AUDIO_ERR_LOG("mode is not playback or renderer is null");
450 return ERR_OPERATION_FAILED;
451 }
452
SetDuckFactor(float duckFactor)453 int32_t IpcStreamInServer::SetDuckFactor(float duckFactor)
454 {
455 if (mode_ == AUDIO_MODE_PLAYBACK && rendererInServer_ != nullptr) {
456 return rendererInServer_->SetDuckFactor(duckFactor);
457 }
458 AUDIO_ERR_LOG("mode is not playback or renderer is null");
459 return ERR_OPERATION_FAILED;
460 }
461
RegisterThreadPriority(uint32_t tid,const std::string & bundleName)462 int32_t IpcStreamInServer::RegisterThreadPriority(uint32_t tid, const std::string &bundleName)
463 {
464 if (!clientThreadPriorityRequested_) {
465 clientPid_ = IPCSkeleton::GetCallingPid();
466 clientTid_ = tid;
467 clientBundleName_ = bundleName;
468 ScheduleReportData(clientPid_, tid, bundleName.c_str());
469 return SUCCESS;
470 } else {
471 AUDIO_ERR_LOG("client thread priority requested");
472 return ERR_OPERATION_FAILED;
473 }
474 }
475
SetDefaultOutputDevice(const DeviceType defaultOutputDevice)476 int32_t IpcStreamInServer::SetDefaultOutputDevice(const DeviceType defaultOutputDevice)
477 {
478 if ((mode_ != AUDIO_MODE_PLAYBACK) || (rendererInServer_ == nullptr)) {
479 AUDIO_ERR_LOG("mode is not playback or renderer is null");
480 return ERR_OPERATION_FAILED;
481 }
482 return rendererInServer_->SetDefaultOutputDevice(defaultOutputDevice);
483 }
484
SetSourceDuration(int64_t duration)485 int32_t IpcStreamInServer::SetSourceDuration(int64_t duration)
486 {
487 if ((mode_ != AUDIO_MODE_PLAYBACK) || (rendererInServer_ == nullptr)) {
488 AUDIO_ERR_LOG("mode is not playback or renderer is null");
489 return ERR_OPERATION_FAILED;
490 }
491 return rendererInServer_->SetSourceDuration(duration);
492 }
493 } // namespace AudioStandard
494 } // namespace OHOS
495