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_guard.h"
26
27 namespace OHOS {
28 namespace AudioStandard {
RegisterStreamListener(sptr<IIpcStreamListener> listener)29 int32_t StreamListenerHolder::RegisterStreamListener(sptr<IIpcStreamListener> listener)
30 {
31 std::lock_guard<std::mutex> lock(listenerMutex_);
32 // should only be set once
33 if (streamListener_ != nullptr) {
34 return ERR_INVALID_OPERATION;
35 }
36 streamListener_ = listener;
37 return SUCCESS;
38 }
39
OnOperationHandled(Operation operation,int64_t result)40 int32_t StreamListenerHolder::OnOperationHandled(Operation operation, int64_t result)
41 {
42 std::lock_guard<std::mutex> lock(listenerMutex_);
43 CHECK_AND_RETURN_RET_LOG(streamListener_ != nullptr, ERR_OPERATION_FAILED, "stream listrener not set");
44 if (IsWakeUpLaterNeeded(operation)) {
45 return streamListener_->OnOperationHandledLazy(operation, result);
46 } else {
47 return streamListener_->OnOperationHandled(operation, result);
48 }
49 }
50
IsWakeUpLaterNeeded(Operation operation)51 bool StreamListenerHolder::IsWakeUpLaterNeeded(Operation operation)
52 {
53 return (operation == SET_OFFLOAD_ENABLE) ||
54 (operation == DATA_LINK_CONNECTING) ||
55 (operation == DATA_LINK_CONNECTED);
56 }
57
Create(const AudioProcessConfig & config,int32_t & ret)58 sptr<IpcStreamInServer> IpcStreamInServer::Create(const AudioProcessConfig &config, int32_t &ret)
59 {
60 AudioMode mode = config.audioMode;
61 sptr<IpcStreamInServer> streamInServer = sptr<IpcStreamInServer>::MakeSptr(config, mode);
62 ret = streamInServer->Config();
63 if (ret != SUCCESS) {
64 AUDIO_ERR_LOG("IpcStreamInServer Config failed: %{public}d, uid: %{public}d",
65 ret, config.appInfo.appUid); // waiting for review: add uid.
66 streamInServer = nullptr;
67 }
68 return streamInServer;
69 }
70
IpcStreamInServer(const AudioProcessConfig & config,AudioMode mode)71 IpcStreamInServer::IpcStreamInServer(const AudioProcessConfig &config, AudioMode mode) : config_(config), mode_(mode)
72 {
73 AUDIO_INFO_LOG("IpcStreamInServer(), uid: %{public}d", config.appInfo.appUid); // waiting for review: add uid.
74 }
75
~IpcStreamInServer()76 IpcStreamInServer::~IpcStreamInServer()
77 {
78 AUDIO_INFO_LOG("~IpcStreamInServer(), uid: %{public}d", config_.appInfo.appUid); // waiting for review: add uid.
79 // avoid unexpected release in proRenderStreamImpl working thread
80 if (rendererInServer_ && (rendererInServer_->GetActualStreamManagerType() == DIRECT_PLAYBACK ||
81 rendererInServer_->GetActualStreamManagerType() == VOIP_PLAYBACK)) {
82 rendererInServer_->Release();
83 }
84 }
85
Config()86 int32_t IpcStreamInServer::Config()
87 {
88 streamListenerHolder_ = std::make_shared<StreamListenerHolder>();
89
90 if (mode_ == AUDIO_MODE_PLAYBACK) {
91 return ConfigRenderer();
92 }
93 if (mode_ == AUDIO_MODE_RECORD) {
94 return ConfigCapturer();
95 }
96 AUDIO_ERR_LOG("Config failed, mode is %{public}d", static_cast<int32_t>(mode_));
97 return ERR_OPERATION_FAILED;
98 }
99
GetRenderer()100 std::shared_ptr<RendererInServer> IpcStreamInServer::GetRenderer()
101 {
102 if (mode_ != AUDIO_MODE_PLAYBACK || rendererInServer_ == nullptr) {
103 AUDIO_ERR_LOG("GetRenderer failed, mode is %{public}s", (mode_ != AUDIO_MODE_PLAYBACK ? " not playback" :
104 "playback, but renderer is null!"));
105 return nullptr;
106 }
107 return rendererInServer_;
108 }
109
GetCapturer()110 std::shared_ptr<CapturerInServer> IpcStreamInServer::GetCapturer()
111 {
112 if (mode_ != AUDIO_MODE_RECORD || capturerInServer_ == nullptr) {
113 AUDIO_ERR_LOG("GetCapturer failed, mode is %{public}s", (mode_ != AUDIO_MODE_RECORD ? " not record" :
114 "record, but capturer is null!"));
115 return nullptr;
116 }
117 return capturerInServer_;
118 }
119
ConfigRenderer()120 int32_t IpcStreamInServer::ConfigRenderer()
121 {
122 rendererInServer_ = std::make_shared<RendererInServer>(config_, streamListenerHolder_);
123 CHECK_AND_RETURN_RET_LOG(rendererInServer_ != nullptr, ERR_OPERATION_FAILED, "Create RendererInServer failed");
124 int32_t ret = rendererInServer_->Init();
125 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERR_OPERATION_FAILED, "Init RendererInServer failed!");
126 return SUCCESS;
127 }
128
ConfigCapturer()129 int32_t IpcStreamInServer::ConfigCapturer()
130 {
131 capturerInServer_ = std::make_shared<CapturerInServer>(config_, streamListenerHolder_);
132 CHECK_AND_RETURN_RET_LOG(capturerInServer_ != nullptr, ERR_OPERATION_FAILED, "create CapturerInServer failed!");
133 int32_t ret = capturerInServer_->Init();
134 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERR_OPERATION_FAILED, "Init CapturerInServer failed");
135 return SUCCESS;
136 }
137
RegisterStreamListener(const sptr<IRemoteObject> & object)138 int32_t IpcStreamInServer::RegisterStreamListener(const sptr<IRemoteObject>& object)
139 {
140 CHECK_AND_RETURN_RET_LOG(streamListenerHolder_ != nullptr, ERR_OPERATION_FAILED, "RegisterStreamListener failed!");
141 sptr<IIpcStreamListener> listener = iface_cast<IIpcStreamListener>(object);
142 CHECK_AND_RETURN_RET_LOG(listener != nullptr, ERR_INVALID_PARAM, "RegisterStreamListener obj cast failed!");
143 streamListenerHolder_->RegisterStreamListener(listener);
144
145 // in plan: get session id, use it as key to find IpcStreamInServer
146 // in plan: listener->AddDeathRecipient( server ) // when client died, do release and clear works
147
148 return SUCCESS;
149 }
150
ResolveBuffer(std::shared_ptr<OHAudioBuffer> & buffer)151 int32_t IpcStreamInServer::ResolveBuffer(std::shared_ptr<OHAudioBuffer> &buffer)
152 {
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 if (mode_ == AUDIO_MODE_PLAYBACK && rendererInServer_ != nullptr) {
190 return rendererInServer_->Start();
191 }
192 if (mode_ == AUDIO_MODE_RECORD && capturerInServer_!= nullptr) {
193 return capturerInServer_->Start();
194 }
195 AUDIO_ERR_LOG("Start failed, invalid mode: %{public}d", static_cast<int32_t>(mode_));
196 return ERR_OPERATION_FAILED;
197 }
198
Pause()199 int32_t IpcStreamInServer::Pause()
200 {
201 {
202 std::lock_guard lock(scheduleGuardsMutex_);
203 scheduleGuards_[METHOD_START] = nullptr;
204 }
205
206 if (mode_ == AUDIO_MODE_PLAYBACK && rendererInServer_ != nullptr) {
207 return rendererInServer_->Pause();
208 }
209 if (mode_ == AUDIO_MODE_RECORD && capturerInServer_!= nullptr) {
210 return capturerInServer_->Pause();
211 }
212 AUDIO_ERR_LOG("Pause failed, invalid mode: %{public}d", static_cast<int32_t>(mode_));
213 return ERR_OPERATION_FAILED;
214 }
215
Stop()216 int32_t IpcStreamInServer::Stop()
217 {
218 {
219 std::lock_guard lock(scheduleGuardsMutex_);
220 scheduleGuards_[METHOD_START] = nullptr;
221 }
222
223 if (mode_ == AUDIO_MODE_PLAYBACK && rendererInServer_ != nullptr) {
224 return rendererInServer_->Stop();
225 }
226 if (mode_ == AUDIO_MODE_RECORD && capturerInServer_!= nullptr) {
227 return capturerInServer_->Stop();
228 }
229 AUDIO_ERR_LOG("Stop failed, invalid mode: %{public}d", static_cast<int32_t>(mode_));
230 return ERR_OPERATION_FAILED;
231 }
232
Release(bool isSwitchStream)233 int32_t IpcStreamInServer::Release(bool isSwitchStream)
234 {
235 {
236 std::lock_guard lock(scheduleGuardsMutex_);
237 scheduleGuards_[METHOD_WRITE_OR_READ] = nullptr;
238 scheduleGuards_[METHOD_START] = nullptr;
239 }
240
241 if (mode_ == AUDIO_MODE_PLAYBACK && rendererInServer_ != nullptr) {
242 return rendererInServer_->Release(isSwitchStream);
243 }
244 if (mode_ == AUDIO_MODE_RECORD && capturerInServer_!= nullptr) {
245 return capturerInServer_->Release(isSwitchStream);
246 }
247 AUDIO_ERR_LOG("Release failed, invalid mode: %{public}d", static_cast<int32_t>(mode_));
248 return ERR_OPERATION_FAILED;
249 }
250
Flush()251 int32_t IpcStreamInServer::Flush()
252 {
253 if (mode_ == AUDIO_MODE_PLAYBACK && rendererInServer_ != nullptr) {
254 return rendererInServer_->Flush();
255 }
256 if (mode_ == AUDIO_MODE_RECORD && capturerInServer_!= nullptr) {
257 return capturerInServer_->Flush();
258 }
259 AUDIO_ERR_LOG("Flush failed, invalid mode: %{public}d", static_cast<int32_t>(mode_));
260 return ERR_OPERATION_FAILED;
261 }
262
Drain(bool stopFlag)263 int32_t IpcStreamInServer::Drain(bool stopFlag)
264 {
265 if (mode_ == AUDIO_MODE_PLAYBACK && rendererInServer_ != nullptr) {
266 return rendererInServer_->Drain(stopFlag);
267 }
268 AUDIO_ERR_LOG("Drain failed, invalid mode: %{public}d", static_cast<int32_t>(mode_));
269 return ERR_OPERATION_FAILED;
270 }
271
UpdatePlaybackCaptureConfig(const AudioPlaybackCaptureConfig & config)272 int32_t IpcStreamInServer::UpdatePlaybackCaptureConfig(const AudioPlaybackCaptureConfig &config)
273 {
274 #ifdef HAS_FEATURE_INNERCAPTURER
275 if (mode_ == AUDIO_MODE_RECORD && capturerInServer_ != nullptr) {
276 return capturerInServer_->UpdatePlaybackCaptureConfig(config);
277 }
278 AUDIO_ERR_LOG("Failed, invalid mode: %{public}d", static_cast<int32_t>(mode_));
279 return ERR_OPERATION_FAILED;
280 #else
281 return ERROR;
282 #endif
283 }
284
GetAudioTime(uint64_t & framePos,uint64_t & timestamp)285 int32_t IpcStreamInServer::GetAudioTime(uint64_t &framePos, uint64_t ×tamp)
286 {
287 if (mode_ == AUDIO_MODE_PLAYBACK && rendererInServer_ != nullptr) {
288 return rendererInServer_->GetAudioTime(framePos, timestamp);
289 }
290 if (mode_ == AUDIO_MODE_RECORD && capturerInServer_!= nullptr) {
291 return capturerInServer_->GetAudioTime(framePos, timestamp);
292 }
293 AUDIO_ERR_LOG("GetAudioTime failed, invalid mode: %{public}d", static_cast<int32_t>(mode_));
294 return ERR_OPERATION_FAILED;
295 }
296
GetAudioPosition(uint64_t & framePos,uint64_t & timestamp,uint64_t & latency,int32_t base)297 int32_t IpcStreamInServer::GetAudioPosition(uint64_t &framePos, uint64_t ×tamp, uint64_t &latency, int32_t base)
298 {
299 if (mode_ != AUDIO_MODE_PLAYBACK || rendererInServer_ == nullptr) {
300 AUDIO_ERR_LOG("unsupported mode: %{public}d or renderer obj is nullptr", static_cast<int32_t>(mode_));
301 return ERR_OPERATION_FAILED;
302 }
303 return rendererInServer_->GetAudioPosition(framePos, timestamp, latency, base);
304 }
305
GetSpeedPosition(uint64_t & framePos,uint64_t & timestamp,uint64_t & latency,int32_t base)306 int32_t IpcStreamInServer::GetSpeedPosition(uint64_t &framePos, uint64_t ×tamp, uint64_t &latency, int32_t base)
307 {
308 CHECK_AND_RETURN_RET_LOG(rendererInServer_ != nullptr && mode_ == AUDIO_MODE_PLAYBACK, ERR_OPERATION_FAILED,
309 "unsupported mode: %{public}d or renderer obj is nullptr", static_cast<int32_t>(mode_));
310 return rendererInServer_->GetSpeedPosition(framePos, timestamp, latency, base);
311 }
312
GetLatency(uint64_t & latency)313 int32_t IpcStreamInServer::GetLatency(uint64_t &latency)
314 {
315 if (mode_ == AUDIO_MODE_PLAYBACK && rendererInServer_ != nullptr) {
316 return rendererInServer_->GetLatency(latency);
317 }
318 if (mode_ == AUDIO_MODE_RECORD && capturerInServer_!= nullptr) {
319 return capturerInServer_->GetLatency(latency);
320 }
321 AUDIO_ERR_LOG("GetAudioSessionID failed, invalid mode: %{public}d", static_cast<int32_t>(mode_));
322 return ERR_OPERATION_FAILED;
323 }
324
SetRate(int32_t rate)325 int32_t IpcStreamInServer::SetRate(int32_t rate)
326 {
327 if (mode_ == AUDIO_MODE_PLAYBACK && rendererInServer_ != nullptr) {
328 return rendererInServer_->SetRate(rate);
329 }
330 AUDIO_ERR_LOG("SetRate failed, invalid mode: %{public}d", static_cast<int32_t>(mode_));
331 return ERR_OPERATION_FAILED;
332 }
333
GetRate(int32_t & rate)334 int32_t IpcStreamInServer::GetRate(int32_t &rate)
335 {
336 // In plan
337 return ERR_OPERATION_FAILED;
338 }
339
SetLowPowerVolume(float volume)340 int32_t IpcStreamInServer::SetLowPowerVolume(float volume)
341 {
342 if (mode_ == AUDIO_MODE_PLAYBACK && rendererInServer_ != nullptr) {
343 return rendererInServer_->SetLowPowerVolume(volume);
344 }
345 AUDIO_ERR_LOG("SetLowPowerVolume failed, invalid mode: %{public}d", static_cast<int32_t>(mode_));
346 return ERR_OPERATION_FAILED;
347 }
348
GetLowPowerVolume(float & volume)349 int32_t IpcStreamInServer::GetLowPowerVolume(float &volume)
350 {
351 if (mode_ == AUDIO_MODE_PLAYBACK && rendererInServer_ != nullptr) {
352 return rendererInServer_->GetLowPowerVolume(volume);
353 }
354 AUDIO_ERR_LOG("GetLowPowerVolume failed, invalid mode: %{public}d", static_cast<int32_t>(mode_));
355 return ERR_OPERATION_FAILED;
356 }
357
SetAudioEffectMode(int32_t effectMode)358 int32_t IpcStreamInServer::SetAudioEffectMode(int32_t effectMode)
359 {
360 if (mode_ == AUDIO_MODE_PLAYBACK && rendererInServer_ != nullptr) {
361 return rendererInServer_->SetAudioEffectMode(effectMode);
362 }
363 AUDIO_ERR_LOG("SetAudioEffectMode failed, invalid mode: %{public}d", static_cast<int32_t>(mode_));
364 return ERR_OPERATION_FAILED;
365 }
366
GetAudioEffectMode(int32_t & effectMode)367 int32_t IpcStreamInServer::GetAudioEffectMode(int32_t &effectMode)
368 {
369 if (mode_ == AUDIO_MODE_PLAYBACK && rendererInServer_ != nullptr) {
370 return rendererInServer_->GetAudioEffectMode(effectMode);
371 }
372 AUDIO_ERR_LOG("GetAudioEffectMode failed, invalid mode: %{public}d", static_cast<int32_t>(mode_));
373 return ERR_OPERATION_FAILED;
374 }
375
SetPrivacyType(int32_t privacyType)376 int32_t IpcStreamInServer::SetPrivacyType(int32_t privacyType)
377 {
378 if (mode_ == AUDIO_MODE_PLAYBACK && rendererInServer_ != nullptr) {
379 return rendererInServer_->SetPrivacyType(privacyType);
380 }
381 AUDIO_ERR_LOG("SetPrivacyType failed, invalid mode: %{public}d", static_cast<int32_t>(mode_));
382 return ERR_OPERATION_FAILED;
383 }
384
GetPrivacyType(int32_t & privacyType)385 int32_t IpcStreamInServer::GetPrivacyType(int32_t &privacyType)
386 {
387 if (mode_ == AUDIO_MODE_PLAYBACK && rendererInServer_ != nullptr) {
388 return rendererInServer_->GetPrivacyType(privacyType);
389 }
390 AUDIO_ERR_LOG("GetPrivacyType failed, invalid mode: %{public}d", static_cast<int32_t>(mode_));
391 return ERR_OPERATION_FAILED;
392 }
393
SetOffloadMode(int32_t state,bool isAppBack)394 int32_t IpcStreamInServer::SetOffloadMode(int32_t state, bool isAppBack)
395 {
396 if (mode_ != AUDIO_MODE_PLAYBACK || rendererInServer_ == nullptr) {
397 AUDIO_ERR_LOG("failed, invalid mode: %{public}d, or rendererInServer_ is null: %{public}d,",
398 static_cast<int32_t>(mode_), rendererInServer_ == nullptr);
399 return ERR_OPERATION_FAILED;
400 }
401 return rendererInServer_->SetOffloadMode(state, isAppBack);
402 }
403
UnsetOffloadMode()404 int32_t IpcStreamInServer::UnsetOffloadMode()
405 {
406 if (mode_ != AUDIO_MODE_PLAYBACK || rendererInServer_ == nullptr) {
407 AUDIO_ERR_LOG("failed, invalid mode: %{public}d, or rendererInServer_ is null: %{public}d,",
408 static_cast<int32_t>(mode_), rendererInServer_ == nullptr);
409 return ERR_OPERATION_FAILED;
410 }
411 return rendererInServer_->UnsetOffloadMode();
412 }
413
GetOffloadApproximatelyCacheTime(uint64_t & timestamp,uint64_t & paWriteIndex,uint64_t & cacheTimeDsp,uint64_t & cacheTimePa)414 int32_t IpcStreamInServer::GetOffloadApproximatelyCacheTime(uint64_t ×tamp, uint64_t &paWriteIndex,
415 uint64_t &cacheTimeDsp, uint64_t &cacheTimePa)
416 {
417 if (mode_ != AUDIO_MODE_PLAYBACK || rendererInServer_ == nullptr) {
418 AUDIO_ERR_LOG("failed, invalid mode: %{public}d, or rendererInServer_ is null: %{public}d,",
419 static_cast<int32_t>(mode_), rendererInServer_ == nullptr);
420 return ERR_OPERATION_FAILED;
421 }
422 return rendererInServer_->GetOffloadApproximatelyCacheTime(timestamp, paWriteIndex, cacheTimeDsp, cacheTimePa);
423 }
424
UpdateSpatializationState(bool spatializationEnabled,bool headTrackingEnabled)425 int32_t IpcStreamInServer::UpdateSpatializationState(bool spatializationEnabled, bool headTrackingEnabled)
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_->UpdateSpatializationState(spatializationEnabled, headTrackingEnabled);
433 }
434
GetStreamManagerType()435 int32_t IpcStreamInServer::GetStreamManagerType()
436 {
437 if (mode_ == AUDIO_MODE_PLAYBACK && rendererInServer_ != nullptr) {
438 return rendererInServer_->GetStreamManagerType();
439 }
440 AUDIO_ERR_LOG("mode is not playback or renderer is null");
441 return ERR_OPERATION_FAILED;
442 }
443
SetSilentModeAndMixWithOthers(bool on)444 int32_t IpcStreamInServer::SetSilentModeAndMixWithOthers(bool on)
445 {
446 if (mode_ != AUDIO_MODE_PLAYBACK || rendererInServer_ == nullptr) {
447 AUDIO_ERR_LOG("failed, invalid mode: %{public}d, or rendererInServer_ is null: %{public}d,",
448 static_cast<int32_t>(mode_), rendererInServer_ == nullptr);
449 return ERR_OPERATION_FAILED;
450 }
451 return rendererInServer_->SetSilentModeAndMixWithOthers(on);
452 }
453
SetClientVolume()454 int32_t IpcStreamInServer::SetClientVolume()
455 {
456 if (mode_ == AUDIO_MODE_PLAYBACK && rendererInServer_ != nullptr) {
457 return rendererInServer_->SetClientVolume();
458 }
459 AUDIO_ERR_LOG("mode is not playback or renderer is null");
460 return ERR_OPERATION_FAILED;
461 }
462
SetLoudnessGain(float loudnessGain)463 int32_t IpcStreamInServer::SetLoudnessGain(float loudnessGain)
464 {
465 if (mode_ == AUDIO_MODE_PLAYBACK && rendererInServer_ != nullptr) {
466 return rendererInServer_->SetLoudnessGain(loudnessGain);
467 }
468 AUDIO_ERR_LOG("mode is not playback or renderer is null");
469 return ERR_OPERATION_FAILED;
470 }
471
SetMute(bool isMute)472 int32_t IpcStreamInServer::SetMute(bool isMute)
473 {
474 if (mode_ == AUDIO_MODE_PLAYBACK && rendererInServer_ != nullptr) {
475 return rendererInServer_->SetMute(isMute);
476 }
477 AUDIO_ERR_LOG("mode is not playback or renderer is null");
478 return ERR_OPERATION_FAILED;
479 }
480
SetDuckFactor(float duckFactor)481 int32_t IpcStreamInServer::SetDuckFactor(float duckFactor)
482 {
483 if (mode_ == AUDIO_MODE_PLAYBACK && rendererInServer_ != nullptr) {
484 return rendererInServer_->SetDuckFactor(duckFactor);
485 }
486 AUDIO_ERR_LOG("mode is not playback or renderer is null");
487 return ERR_OPERATION_FAILED;
488 }
489
RegisterThreadPriority(int32_t tid,const std::string & bundleName,uint32_t method)490 int32_t IpcStreamInServer::RegisterThreadPriority(int32_t tid, const std::string &bundleName, uint32_t method)
491 {
492 pid_t pid = IPCSkeleton::GetCallingPid();
493 CHECK_AND_RETURN_RET_LOG(method < METHOD_MAX, ERR_INVALID_PARAM, "err param %{public}u", method);
494 auto sharedGuard = SharedAudioScheduleGuard::Create(pid, static_cast<pid_t>(tid), bundleName);
495 std::lock_guard lock(scheduleGuardsMutex_);
496 scheduleGuards_[method].swap(sharedGuard);
497 return SUCCESS;
498 }
499
SetDefaultOutputDevice(int32_t defaultOutputDevice,bool skipForce)500 int32_t IpcStreamInServer::SetDefaultOutputDevice(int32_t defaultOutputDevice, bool skipForce)
501 {
502 if ((mode_ != AUDIO_MODE_PLAYBACK) || (rendererInServer_ == nullptr)) {
503 AUDIO_ERR_LOG("mode is not playback or renderer is null");
504 return ERR_OPERATION_FAILED;
505 }
506 return rendererInServer_->SetDefaultOutputDevice(static_cast<DeviceType>(defaultOutputDevice), skipForce);
507 }
508
SetSourceDuration(int64_t duration)509 int32_t IpcStreamInServer::SetSourceDuration(int64_t duration)
510 {
511 if ((mode_ != AUDIO_MODE_PLAYBACK) || (rendererInServer_ == nullptr)) {
512 AUDIO_ERR_LOG("mode is not playback or renderer is null");
513 return ERR_OPERATION_FAILED;
514 }
515 return rendererInServer_->SetSourceDuration(duration);
516 }
517
SetSpeed(float speed)518 int32_t IpcStreamInServer::SetSpeed(float speed)
519 {
520 CHECK_AND_RETURN_RET_LOG(mode_ == AUDIO_MODE_PLAYBACK && rendererInServer_ != nullptr, ERR_OPERATION_FAILED,
521 "mode is not playback or renderer is null");
522 return rendererInServer_->SetSpeed(speed);
523 }
524
SetOffloadDataCallbackState(int32_t state)525 int32_t IpcStreamInServer::SetOffloadDataCallbackState(int32_t state)
526 {
527 if ((mode_ != AUDIO_MODE_PLAYBACK) || (rendererInServer_ == nullptr)) {
528 AUDIO_ERR_LOG("mode is not playback or renderer is null");
529 return ERR_OPERATION_FAILED;
530 }
531 return rendererInServer_->SetOffloadDataCallbackState(state);
532 }
533
ResolveBufferBaseAndGetServerSpanSize(std::shared_ptr<OHAudioBufferBase> & buffer,uint32_t & spanSizeInFrame,uint64_t & engineTotalSizeInFrame)534 int32_t IpcStreamInServer::ResolveBufferBaseAndGetServerSpanSize(std::shared_ptr<OHAudioBufferBase> &buffer,
535 uint32_t &spanSizeInFrame, uint64_t &engineTotalSizeInFrame)
536 {
537 AUDIO_INFO_LOG("Resolve bufferbase, mode: %{public}d", mode_);
538 if (mode_ == AUDIO_MODE_PLAYBACK && rendererInServer_ != nullptr) {
539 return rendererInServer_->ResolveBufferBaseAndGetServerSpanSize(buffer, spanSizeInFrame,
540 engineTotalSizeInFrame);
541 }
542 if (mode_ == AUDIO_MODE_RECORD && capturerInServer_!= nullptr) {
543 return capturerInServer_->ResolveBufferBaseAndGetServerSpanSize(buffer, spanSizeInFrame,
544 engineTotalSizeInFrame);
545 }
546 AUDIO_ERR_LOG("GetAudioSessionID failed, invalid mode: %{public}d", static_cast<int32_t>(mode_));
547 return ERR_OPERATION_FAILED;
548 }
549
SetAudioHapticsSyncId(int32_t audioHapticsSyncId)550 int32_t IpcStreamInServer::SetAudioHapticsSyncId(int32_t audioHapticsSyncId)
551 {
552 if (mode_ != AUDIO_MODE_PLAYBACK || rendererInServer_ == nullptr) {
553 AUDIO_ERR_LOG("failed, invalid mode: %{public}d, or rendererInServer_ is null: %{public}d,",
554 static_cast<int32_t>(mode_), rendererInServer_ == nullptr);
555 return ERR_OPERATION_FAILED;
556 }
557 return rendererInServer_->SetAudioHapticsSyncId(audioHapticsSyncId);
558 }
559 } // namespace AudioStandard
560 } // namespace OHOS
561