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 "IpcStreamProxy"
17 #endif
18
19 #include "ipc_stream_proxy.h"
20 #include "audio_service_log.h"
21 #include "audio_errors.h"
22 #include "audio_process_config.h"
23
24 namespace OHOS {
25 namespace AudioStandard {
IpcStreamProxy(const sptr<IRemoteObject> & impl)26 IpcStreamProxy::IpcStreamProxy(const sptr<IRemoteObject> &impl) : IRemoteProxy<IpcStream>(impl)
27 {
28 AUDIO_INFO_LOG("IpcStreamProxy()");
29 }
30
~IpcStreamProxy()31 IpcStreamProxy::~IpcStreamProxy()
32 {
33 AUDIO_INFO_LOG("~IpcStreamProxy()");
34 }
35
RegisterStreamListener(sptr<IRemoteObject> object)36 int32_t IpcStreamProxy::RegisterStreamListener(sptr<IRemoteObject> object)
37 {
38 MessageParcel data;
39 MessageParcel reply;
40 MessageOption option;
41
42 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
43
44 if (object == nullptr) {
45 AUDIO_ERR_LOG("RegisterStreamListener object is null");
46 return ERR_NULL_OBJECT;
47 }
48
49 data.WriteRemoteObject(object);
50
51 int ret = Remote()->SendRequest(IpcStreamMsg::ON_REGISTER_STREAM_LISTENER, data, reply, option);
52 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ERR_OPERATION_FAILED, "RegisterStreamListener failed,"
53 "error: %{public}d", ret);
54
55 return reply.ReadInt32();
56 }
57
ResolveBuffer(std::shared_ptr<OHAudioBuffer> & buffer)58 int32_t IpcStreamProxy::ResolveBuffer(std::shared_ptr<OHAudioBuffer> &buffer)
59 {
60 MessageParcel data;
61 MessageParcel reply;
62 MessageOption option;
63
64 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
65
66 int ret = Remote()->SendRequest(IpcStreamMsg::ON_RESOLVE_BUFFER, data, reply, option);
67 CHECK_AND_RETURN_RET_LOG((ret == AUDIO_OK && reply.ReadInt32() == AUDIO_OK), ERR_OPERATION_FAILED,
68 "ResolveBuffer failed, error: %{public}d", ret);
69 buffer = OHAudioBuffer::ReadFromParcel(reply);
70 CHECK_AND_RETURN_RET_LOG(buffer != nullptr, ERR_OPERATION_FAILED, "ReadFromParcel failed");
71 return SUCCESS;
72 }
73
UpdatePosition()74 int32_t IpcStreamProxy::UpdatePosition()
75 {
76 MessageParcel data;
77 MessageParcel reply;
78 MessageOption option;
79
80 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
81
82 int ret = Remote()->SendRequest(IpcStreamMsg::ON_UPDATE_POSITION, data, reply, option);
83 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ERR_OPERATION_FAILED, "UpdatePosition failed, error: %{public}d", ret);
84
85 return reply.ReadInt32();
86 }
87
GetAudioSessionID(uint32_t & sessionId)88 int32_t IpcStreamProxy::GetAudioSessionID(uint32_t &sessionId)
89 {
90 MessageParcel data;
91 MessageParcel reply;
92 MessageOption option;
93
94 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
95
96 int ret = Remote()->SendRequest(IpcStreamMsg::ON_GET_AUDIO_SESSIONID, data, reply, option);
97 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ERR_OPERATION_FAILED, "GetAudioSessionID failed, error: %{public}d", ret);
98 ret = reply.ReadInt32();
99 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "GetAudioSessionID failed, error: %{public}d", ret);
100 sessionId = reply.ReadUint32();
101 return ret;
102 }
103
Start()104 int32_t IpcStreamProxy::Start()
105 {
106 MessageParcel data;
107 MessageParcel reply;
108 MessageOption option;
109
110 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
111
112 int ret = Remote()->SendRequest(IpcStreamMsg::ON_START, data, reply, option);
113 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ERR_OPERATION_FAILED, "Start failed, error: %{public}d", ret);
114
115 return reply.ReadInt32();
116 }
117
Pause()118 int32_t IpcStreamProxy::Pause()
119 {
120 MessageParcel data;
121 MessageParcel reply;
122 MessageOption option;
123
124 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
125 int ret = Remote()->SendRequest(IpcStreamMsg::ON_PAUSE, data, reply, option);
126 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ERR_OPERATION_FAILED, "Pause failed, error: %{public}d", ret);
127
128 return reply.ReadInt32();
129 }
130
Stop()131 int32_t IpcStreamProxy::Stop()
132 {
133 MessageParcel data;
134 MessageParcel reply;
135 MessageOption option;
136
137 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
138
139 int ret = Remote()->SendRequest(IpcStreamMsg::ON_STOP, data, reply, option);
140 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ERR_OPERATION_FAILED, "Stop failed, error: %{public}d", ret);
141
142 return reply.ReadInt32();
143 }
144
Release()145 int32_t IpcStreamProxy::Release()
146 {
147 MessageParcel data;
148 MessageParcel reply;
149 MessageOption option;
150
151 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
152
153 int ret = Remote()->SendRequest(IpcStreamMsg::ON_RELEASE, data, reply, option);
154 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ERR_OPERATION_FAILED, "Release failed, error: %{public}d", ret);
155
156 return reply.ReadInt32();
157 }
158
Flush()159 int32_t IpcStreamProxy::Flush()
160 {
161 MessageParcel data;
162 MessageParcel reply;
163 MessageOption option;
164
165 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
166
167 int ret = Remote()->SendRequest(IpcStreamMsg::ON_FLUSH, data, reply, option);
168 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ERR_OPERATION_FAILED, "Flush failed, error: %{public}d", ret);
169
170 return reply.ReadInt32();
171 }
172
Drain(bool stopFlag)173 int32_t IpcStreamProxy::Drain(bool stopFlag)
174 {
175 MessageParcel data;
176 MessageParcel reply;
177 MessageOption option;
178
179 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
180 data.WriteBool(stopFlag);
181 int ret = Remote()->SendRequest(IpcStreamMsg::ON_DRAIN, data, reply, option);
182 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ret, "Drain failed, ipc error: %{public}d", ret);
183 return reply.ReadInt32();
184 }
185
UpdatePlaybackCaptureConfig(const AudioPlaybackCaptureConfig & config)186 int32_t IpcStreamProxy::UpdatePlaybackCaptureConfig(const AudioPlaybackCaptureConfig &config)
187 {
188 #ifdef HAS_FEATURE_INNERCAPTURER
189 MessageParcel data;
190 MessageParcel reply;
191 MessageOption option;
192
193 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
194
195 int32_t ret = ProcessConfig::WriteInnerCapConfigToParcel(config, data);
196 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "Write config failed");
197
198 ret = Remote()->SendRequest(IpcStreamMsg::ON_UPDATA_PLAYBACK_CAPTURER_CONFIG, data, reply, option);
199 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ret, "Failed, ipc error: %{public}d", ret);
200 return reply.ReadInt32();
201 #else
202 return ERROR;
203 #endif
204 }
205
GetAudioTime(uint64_t & framePos,uint64_t & timestamp)206 int32_t IpcStreamProxy::GetAudioTime(uint64_t &framePos, uint64_t ×tamp)
207 {
208 MessageParcel data;
209 MessageParcel reply;
210 MessageOption option;
211
212 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
213
214 int ret = Remote()->SendRequest(IpcStreamMsg::OH_GET_AUDIO_TIME, data, reply, option);
215 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ret, "GetAudioTime failed, ipc error: %{public}d", ret);
216 ret = reply.ReadInt32();
217 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "GetAudioTime failed, error: %{public}d", ret);
218 framePos = reply.ReadUint64();
219 timestamp = reply.ReadUint64();
220 return ret;
221 }
222
GetAudioPosition(uint64_t & framePos,uint64_t & timestamp,uint64_t & latency)223 int32_t IpcStreamProxy::GetAudioPosition(uint64_t &framePos, uint64_t ×tamp, uint64_t &latency)
224 {
225 MessageParcel data;
226 MessageParcel reply;
227 MessageOption option;
228
229 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
230
231 int ret = Remote()->SendRequest(IpcStreamMsg::OH_GET_AUDIO_POSITION, data, reply, option);
232 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ret, "ipc error: %{public}d", ret);
233 ret = reply.ReadInt32();
234 CHECK_AND_RETURN_RET_PRELOG(ret == SUCCESS, ret, "error: %{public}d", ret);
235 framePos = reply.ReadUint64();
236 timestamp = reply.ReadUint64();
237 latency = reply.ReadUint64();
238 return ret;
239 }
240
GetLatency(uint64_t & latency)241 int32_t IpcStreamProxy::GetLatency(uint64_t &latency)
242 {
243 MessageParcel data;
244 MessageParcel reply;
245 MessageOption option;
246
247 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
248
249 int ret = Remote()->SendRequest(IpcStreamMsg::ON_GET_LATENCY, data, reply, option);
250 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ret, "GetLatency failed, ipc error: %{public}d", ret);
251 ret = reply.ReadInt32();
252 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "GetLatency failed, error: %{public}d", ret);
253 latency = reply.ReadUint64();
254
255 return ret;
256 }
257
SetRate(int32_t rate)258 int32_t IpcStreamProxy::SetRate(int32_t rate)
259 {
260 MessageParcel data;
261 MessageParcel reply;
262 MessageOption option;
263
264 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
265 data.WriteInt32(rate);
266 int ret = Remote()->SendRequest(IpcStreamMsg::ON_SET_RATE, data, reply, option);
267 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ERR_OPERATION_FAILED, "SetRate failed, ipc error: %{public}d", ret);
268
269 return reply.ReadInt32();
270 }
271
GetRate(int32_t & rate)272 int32_t IpcStreamProxy::GetRate(int32_t &rate)
273 {
274 MessageParcel data;
275 MessageParcel reply;
276 MessageOption option;
277
278 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
279
280 int ret = Remote()->SendRequest(IpcStreamMsg::ON_GET_RATE, data, reply, option);
281 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ret, "GetRate failed, ipc error: %{public}d", ret);
282 ret = reply.ReadInt32();
283 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "GetRate failed, error: %{public}d", ret);
284 rate = reply.ReadInt32();
285
286 return ret;
287 }
288
SetLowPowerVolume(float volume)289 int32_t IpcStreamProxy::SetLowPowerVolume(float volume)
290 {
291 MessageParcel data;
292 MessageParcel reply;
293 MessageOption option;
294
295 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
296
297 data.WriteFloat(volume);
298 int ret = Remote()->SendRequest(IpcStreamMsg::ON_SET_LOWPOWER_VOLUME, data, reply, option);
299 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ERR_OPERATION_FAILED, "SetLowPowerVolume failed, error:%{public}d", ret);
300
301 return reply.ReadInt32();
302 }
303
GetLowPowerVolume(float & volume)304 int32_t IpcStreamProxy::GetLowPowerVolume(float &volume)
305 {
306 MessageParcel data;
307 MessageParcel reply;
308 MessageOption option;
309
310 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
311
312 int ret = Remote()->SendRequest(IpcStreamMsg::ON_GET_LOWPOWER_VOLUME, data, reply, option);
313 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ret, "GetLowPowerVolume failed, ipc error: %{public}d", ret);
314 ret = reply.ReadInt32();
315 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "GetLowPowerVolume failed, error: %{public}d", ret);
316 volume = reply.ReadFloat();
317
318 return ret;
319 }
320
SetAudioEffectMode(int32_t effectMode)321 int32_t IpcStreamProxy::SetAudioEffectMode(int32_t effectMode)
322 {
323 MessageParcel data;
324 MessageParcel reply;
325 MessageOption option;
326
327 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
328
329 data.WriteInt32(effectMode);
330 int ret = Remote()->SendRequest(IpcStreamMsg::ON_SET_EFFECT_MODE, data, reply, option);
331 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ERR_OPERATION_FAILED, "SetAudioEffectMode failed, ipc error: %{public}d",
332 ret);
333
334 return reply.ReadInt32();
335 }
336
GetAudioEffectMode(int32_t & effectMode)337 int32_t IpcStreamProxy::GetAudioEffectMode(int32_t &effectMode)
338 {
339 MessageParcel data;
340 MessageParcel reply;
341 MessageOption option;
342
343 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
344
345 int ret = Remote()->SendRequest(IpcStreamMsg::ON_GET_EFFECT_MODE, data, reply, option);
346 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ret, "GetAudioEffectMode failed, ipc error: %{public}d", ret);
347 ret = reply.ReadInt32();
348 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "GetAudioEffectMode failed, error: %{public}d", ret);
349 effectMode = reply.ReadInt32();
350
351 return ret;
352 }
353
SetPrivacyType(int32_t privacyType)354 int32_t IpcStreamProxy::SetPrivacyType(int32_t privacyType)
355 {
356 MessageParcel data;
357 MessageParcel reply;
358 MessageOption option;
359
360 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
361
362 int ret = Remote()->SendRequest(IpcStreamMsg::ON_SET_PRIVACY_TYPE, data, reply, option);
363 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ERR_OPERATION_FAILED, "SetPrivacyType failed, error: %{public}d", ret);
364
365 return reply.ReadInt32();
366 }
367
GetPrivacyType(int32_t & privacyType)368 int32_t IpcStreamProxy::GetPrivacyType(int32_t &privacyType)
369 {
370 MessageParcel data;
371 MessageParcel reply;
372 MessageOption option;
373
374 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
375
376 int ret = Remote()->SendRequest(IpcStreamMsg::ON_GET_PRIVACY_TYPE, data, reply, option);
377 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ret, "GetPrivacyType failed, ipc error: %{public}d", ret);
378 ret = reply.ReadInt32();
379 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "GetPrivacyType failed, error: %{public}d", ret);
380 privacyType = reply.ReadInt32();
381
382 return ret;
383 }
384
SetOffloadMode(int32_t state,bool isAppBack)385 int32_t IpcStreamProxy::SetOffloadMode(int32_t state, bool isAppBack)
386 {
387 MessageParcel data;
388 MessageParcel reply;
389 MessageOption option;
390
391 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
392
393 data.WriteInt32(state);
394 data.WriteBool(isAppBack);
395 int ret = Remote()->SendRequest(IpcStreamMsg::ON_SET_OFFLOAD_MODE, data, reply, option);
396 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ret, "failed, ipc error: %{public}d", ret);
397 ret = reply.ReadInt32();
398 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "failed, error: %{public}d", ret);
399
400 return ret;
401 }
402
UnsetOffloadMode()403 int32_t IpcStreamProxy::UnsetOffloadMode()
404 {
405 MessageParcel data;
406 MessageParcel reply;
407 MessageOption option;
408
409 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
410
411 int ret = Remote()->SendRequest(IpcStreamMsg::ON_UNSET_OFFLOAD_MODE, data, reply, option);
412 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ret, "failed, ipc error: %{public}d", ret);
413 ret = reply.ReadInt32();
414 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "failed, error: %{public}d", ret);
415
416 return ret;
417 }
418
GetOffloadApproximatelyCacheTime(uint64_t & timestamp,uint64_t & paWriteIndex,uint64_t & cacheTimeDsp,uint64_t & cacheTimePa)419 int32_t IpcStreamProxy::GetOffloadApproximatelyCacheTime(uint64_t ×tamp, uint64_t &paWriteIndex,
420 uint64_t &cacheTimeDsp, uint64_t &cacheTimePa)
421 {
422 MessageParcel data;
423 MessageParcel reply;
424 MessageOption option;
425
426 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
427
428 data.WriteUint64(timestamp);
429 data.WriteUint64(paWriteIndex);
430 data.WriteUint64(cacheTimeDsp);
431 data.WriteUint64(cacheTimePa);
432 int ret = Remote()->SendRequest(IpcStreamMsg::ON_GET_OFFLOAD_APPROXIMATELY_CACHE_TIME, data, reply, option);
433 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ret, "failed, ipc error: %{public}d",
434 ret);
435 ret = reply.ReadInt32();
436 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "failed, error: %{public}d", ret);
437 timestamp = reply.ReadUint64();
438 paWriteIndex = reply.ReadUint64();
439 cacheTimeDsp = reply.ReadUint64();
440 cacheTimePa = reply.ReadUint64();
441
442 return ret;
443 }
444
UpdateSpatializationState(bool spatializationEnabled,bool headTrackingEnabled)445 int32_t IpcStreamProxy::UpdateSpatializationState(bool spatializationEnabled, bool headTrackingEnabled)
446 {
447 MessageParcel data;
448 MessageParcel reply;
449 MessageOption option;
450
451 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
452
453 data.WriteBool(spatializationEnabled);
454 data.WriteBool(headTrackingEnabled);
455 int ret = Remote()->SendRequest(IpcStreamMsg::ON_UPDATE_SPATIALIZATION_STATE, data, reply, option);
456 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ret, "failed, ipc error: %{public}d", ret);
457 ret = reply.ReadInt32();
458 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "failed, error: %{public}d", ret);
459 return ret;
460 }
461
GetStreamManagerType()462 int32_t IpcStreamProxy::GetStreamManagerType()
463 {
464 MessageParcel data;
465 MessageParcel reply;
466 MessageOption option;
467
468 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
469 int ret = Remote()->SendRequest(IpcStreamMsg::ON_GET_STREAM_MANAGER_TYPE, data, reply, option);
470 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ret, "failed, ipc error: %{public}d", ret);
471 return reply.ReadInt32();
472 }
473
SetSilentModeAndMixWithOthers(bool on)474 int32_t IpcStreamProxy::SetSilentModeAndMixWithOthers(bool on)
475 {
476 MessageParcel data;
477 MessageParcel reply;
478 MessageOption option;
479
480 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
481
482 data.WriteBool(on);
483 int ret = Remote()->SendRequest(IpcStreamMsg::ON_SET_SILENT_MODE_AND_MIX_WITH_OTHERS, data, reply, option);
484 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ret, "failed, ipc error: %{public}d", ret);
485 ret = reply.ReadInt32();
486 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "failed, error: %{public}d", ret);
487
488 return ret;
489 }
490
SetClientVolume()491 int32_t IpcStreamProxy::SetClientVolume()
492 {
493 MessageParcel data;
494 MessageParcel reply;
495 MessageOption option;
496
497 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
498
499 int ret = Remote()->SendRequest(IpcStreamMsg::ON_SET_CLIENT_VOLUME, data, reply, option);
500 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ret, "set client volume failed, ipc error: %{public}d", ret);
501 return reply.ReadInt32();
502 }
503
SetMute(bool isMute)504 int32_t IpcStreamProxy::SetMute(bool isMute)
505 {
506 MessageParcel data;
507 MessageParcel reply;
508 MessageOption option;
509
510 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
511
512 data.WriteBool(isMute);
513 int ret = Remote()->SendRequest(IpcStreamMsg::ON_SET_MUTE, data, reply, option);
514 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ret, "set mute failed, ipc error: %{public}d", ret);
515 return reply.ReadInt32();
516 }
517
SetDuckFactor(float duckFactor)518 int32_t IpcStreamProxy::SetDuckFactor(float duckFactor)
519 {
520 MessageParcel data;
521 MessageParcel reply;
522 MessageOption option;
523
524 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
525
526 data.WriteFloat(duckFactor);
527 int ret = Remote()->SendRequest(IpcStreamMsg::ON_SET_DUCK_FACTOR, data, reply, option);
528 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ret, "set duck failed, ipc error: %{public}d", ret);
529 return reply.ReadInt32();
530 }
531
RegisterThreadPriority(uint32_t tid,const std::string & bundleName)532 int32_t IpcStreamProxy::RegisterThreadPriority(uint32_t tid, const std::string &bundleName)
533 {
534 MessageParcel data;
535 MessageParcel reply;
536 MessageOption option;
537
538 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
539 data.WriteUint32(tid);
540 data.WriteString(bundleName);
541 int ret = Remote()->SendRequest(IpcStreamMsg::ON_REGISTER_THREAD_PRIORITY, data, reply, option);
542 CHECK_AND_RETURN_RET(ret == AUDIO_OK, ret, "failed, ipc error: %{public}d", ret);
543 ret = reply.ReadInt32();
544 CHECK_AND_RETURN_RET(ret == SUCCESS, ret, "failed, error: %{public}d", ret);
545 return ret;
546 }
547
SetDefaultOutputDevice(const DeviceType defaultOutputDevice)548 int32_t IpcStreamProxy::SetDefaultOutputDevice(const DeviceType defaultOutputDevice)
549 {
550 MessageParcel data;
551 MessageParcel reply;
552 MessageOption option;
553
554 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
555 data.WriteInt32(defaultOutputDevice);
556 int ret = Remote()->SendRequest(IpcStreamMsg::ON_SET_DEFAULT_OUTPUT_DEVICE, data, reply, option);
557 CHECK_AND_RETURN_RET(ret == AUDIO_OK, ret, "set default output device failed, ipc error: %{public}d", ret);
558 return reply.ReadInt32();
559 }
560
SetSourceDuration(int64_t duration)561 int32_t IpcStreamProxy::SetSourceDuration(int64_t duration)
562 {
563 MessageParcel data;
564 MessageParcel reply;
565 MessageOption option;
566
567 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
568 data.WriteInt64(duration);
569 int ret = Remote()->SendRequest(IpcStreamMsg::ON_SET_SOURCE_DURATION, data, reply, option);
570 CHECK_AND_RETURN_RET(ret == AUDIO_OK, ret, "set source duration failed, ipc error: %{public}d", ret);
571 return reply.ReadInt32();
572 }
573 } // namespace AudioStandard
574 } // namespace OHOS
575