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 "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 MessageParcel data;
189 MessageParcel reply;
190 MessageOption option;
191
192 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
193
194 int32_t ret = ProcessConfig::WriteInnerCapConfigToParcel(config, data);
195 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "Write config failed");
196
197 ret = Remote()->SendRequest(IpcStreamMsg::ON_UPDATA_PLAYBACK_CAPTURER_CONFIG, data, reply, option);
198 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ret, "Failed, ipc error: %{public}d", ret);
199 return reply.ReadInt32();
200 }
201
GetAudioTime(uint64_t & framePos,uint64_t & timestamp)202 int32_t IpcStreamProxy::GetAudioTime(uint64_t &framePos, uint64_t ×tamp)
203 {
204 MessageParcel data;
205 MessageParcel reply;
206 MessageOption option;
207
208 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
209
210 int ret = Remote()->SendRequest(IpcStreamMsg::OH_GET_AUDIO_TIME, data, reply, option);
211 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ret, "GetAudioTime failed, ipc error: %{public}d", ret);
212 ret = reply.ReadInt32();
213 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "GetAudioTime failed, error: %{public}d", ret);
214 framePos = reply.ReadUint64();
215 timestamp = reply.ReadUint64();
216 return ret;
217 }
218
GetAudioPosition(uint64_t & framePos,uint64_t & timestamp,uint64_t & latency)219 int32_t IpcStreamProxy::GetAudioPosition(uint64_t &framePos, uint64_t ×tamp, uint64_t &latency)
220 {
221 MessageParcel data;
222 MessageParcel reply;
223 MessageOption option;
224
225 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
226
227 int ret = Remote()->SendRequest(IpcStreamMsg::OH_GET_AUDIO_POSITION, data, reply, option);
228 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ret, "ipc error: %{public}d", ret);
229 ret = reply.ReadInt32();
230 CHECK_AND_RETURN_RET_PRELOG(ret == SUCCESS, ret, "error: %{public}d", ret);
231 framePos = reply.ReadUint64();
232 timestamp = reply.ReadUint64();
233 latency = reply.ReadUint64();
234 return ret;
235 }
236
GetLatency(uint64_t & latency)237 int32_t IpcStreamProxy::GetLatency(uint64_t &latency)
238 {
239 MessageParcel data;
240 MessageParcel reply;
241 MessageOption option;
242
243 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
244
245 int ret = Remote()->SendRequest(IpcStreamMsg::ON_GET_LATENCY, data, reply, option);
246 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ret, "GetLatency failed, ipc error: %{public}d", ret);
247 ret = reply.ReadInt32();
248 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "GetLatency failed, error: %{public}d", ret);
249 latency = reply.ReadUint64();
250
251 return ret;
252 }
253
SetRate(int32_t rate)254 int32_t IpcStreamProxy::SetRate(int32_t rate)
255 {
256 MessageParcel data;
257 MessageParcel reply;
258 MessageOption option;
259
260 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
261 data.WriteInt32(rate);
262 int ret = Remote()->SendRequest(IpcStreamMsg::ON_SET_RATE, data, reply, option);
263 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ERR_OPERATION_FAILED, "SetRate failed, ipc error: %{public}d", ret);
264
265 return reply.ReadInt32();
266 }
267
GetRate(int32_t & rate)268 int32_t IpcStreamProxy::GetRate(int32_t &rate)
269 {
270 MessageParcel data;
271 MessageParcel reply;
272 MessageOption option;
273
274 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
275
276 int ret = Remote()->SendRequest(IpcStreamMsg::ON_GET_RATE, data, reply, option);
277 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ret, "GetRate failed, ipc error: %{public}d", ret);
278 ret = reply.ReadInt32();
279 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "GetRate failed, error: %{public}d", ret);
280 rate = reply.ReadInt32();
281
282 return ret;
283 }
284
SetLowPowerVolume(float volume)285 int32_t IpcStreamProxy::SetLowPowerVolume(float volume)
286 {
287 MessageParcel data;
288 MessageParcel reply;
289 MessageOption option;
290
291 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
292
293 data.WriteFloat(volume);
294 int ret = Remote()->SendRequest(IpcStreamMsg::ON_SET_LOWPOWER_VOLUME, data, reply, option);
295 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ERR_OPERATION_FAILED, "SetLowPowerVolume failed, error:%{public}d", ret);
296
297 return reply.ReadInt32();
298 }
299
GetLowPowerVolume(float & volume)300 int32_t IpcStreamProxy::GetLowPowerVolume(float &volume)
301 {
302 MessageParcel data;
303 MessageParcel reply;
304 MessageOption option;
305
306 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
307
308 int ret = Remote()->SendRequest(IpcStreamMsg::ON_GET_LOWPOWER_VOLUME, data, reply, option);
309 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ret, "GetLowPowerVolume failed, ipc error: %{public}d", ret);
310 ret = reply.ReadInt32();
311 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "GetLowPowerVolume failed, error: %{public}d", ret);
312 volume = reply.ReadFloat();
313
314 return ret;
315 }
316
SetAudioEffectMode(int32_t effectMode)317 int32_t IpcStreamProxy::SetAudioEffectMode(int32_t effectMode)
318 {
319 MessageParcel data;
320 MessageParcel reply;
321 MessageOption option;
322
323 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
324
325 data.WriteInt32(effectMode);
326 int ret = Remote()->SendRequest(IpcStreamMsg::ON_SET_EFFECT_MODE, data, reply, option);
327 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ERR_OPERATION_FAILED, "SetAudioEffectMode failed, ipc error: %{public}d",
328 ret);
329
330 return reply.ReadInt32();
331 }
332
GetAudioEffectMode(int32_t & effectMode)333 int32_t IpcStreamProxy::GetAudioEffectMode(int32_t &effectMode)
334 {
335 MessageParcel data;
336 MessageParcel reply;
337 MessageOption option;
338
339 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
340
341 int ret = Remote()->SendRequest(IpcStreamMsg::ON_GET_EFFECT_MODE, data, reply, option);
342 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ret, "GetAudioEffectMode failed, ipc error: %{public}d", ret);
343 ret = reply.ReadInt32();
344 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "GetAudioEffectMode failed, error: %{public}d", ret);
345 effectMode = reply.ReadInt32();
346
347 return ret;
348 }
349
SetPrivacyType(int32_t privacyType)350 int32_t IpcStreamProxy::SetPrivacyType(int32_t privacyType)
351 {
352 MessageParcel data;
353 MessageParcel reply;
354 MessageOption option;
355
356 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
357
358 int ret = Remote()->SendRequest(IpcStreamMsg::ON_SET_PRIVACY_TYPE, data, reply, option);
359 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ERR_OPERATION_FAILED, "SetPrivacyType failed, error: %{public}d", ret);
360
361 return reply.ReadInt32();
362 }
363
GetPrivacyType(int32_t & privacyType)364 int32_t IpcStreamProxy::GetPrivacyType(int32_t &privacyType)
365 {
366 MessageParcel data;
367 MessageParcel reply;
368 MessageOption option;
369
370 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
371
372 int ret = Remote()->SendRequest(IpcStreamMsg::ON_GET_PRIVACY_TYPE, data, reply, option);
373 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ret, "GetPrivacyType failed, ipc error: %{public}d", ret);
374 ret = reply.ReadInt32();
375 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "GetPrivacyType failed, error: %{public}d", ret);
376 privacyType = reply.ReadInt32();
377
378 return ret;
379 }
380
SetOffloadMode(int32_t state,bool isAppBack)381 int32_t IpcStreamProxy::SetOffloadMode(int32_t state, bool isAppBack)
382 {
383 MessageParcel data;
384 MessageParcel reply;
385 MessageOption option;
386
387 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
388
389 data.WriteInt32(state);
390 data.WriteBool(isAppBack);
391 int ret = Remote()->SendRequest(IpcStreamMsg::ON_SET_OFFLOAD_MODE, data, reply, option);
392 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ret, "failed, ipc error: %{public}d", ret);
393 ret = reply.ReadInt32();
394 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "failed, error: %{public}d", ret);
395
396 return ret;
397 }
398
UnsetOffloadMode()399 int32_t IpcStreamProxy::UnsetOffloadMode()
400 {
401 MessageParcel data;
402 MessageParcel reply;
403 MessageOption option;
404
405 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
406
407 int ret = Remote()->SendRequest(IpcStreamMsg::ON_UNSET_OFFLOAD_MODE, data, reply, option);
408 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ret, "failed, ipc error: %{public}d", ret);
409 ret = reply.ReadInt32();
410 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "failed, error: %{public}d", ret);
411
412 return ret;
413 }
414
GetOffloadApproximatelyCacheTime(uint64_t & timestamp,uint64_t & paWriteIndex,uint64_t & cacheTimeDsp,uint64_t & cacheTimePa)415 int32_t IpcStreamProxy::GetOffloadApproximatelyCacheTime(uint64_t ×tamp, uint64_t &paWriteIndex,
416 uint64_t &cacheTimeDsp, uint64_t &cacheTimePa)
417 {
418 MessageParcel data;
419 MessageParcel reply;
420 MessageOption option;
421
422 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
423
424 data.WriteUint64(timestamp);
425 data.WriteUint64(paWriteIndex);
426 data.WriteUint64(cacheTimeDsp);
427 data.WriteUint64(cacheTimePa);
428 int ret = Remote()->SendRequest(IpcStreamMsg::ON_GET_OFFLOAD_APPROXIMATELY_CACHE_TIME, data, reply, option);
429 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ret, "failed, ipc error: %{public}d",
430 ret);
431 ret = reply.ReadInt32();
432 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "failed, error: %{public}d", ret);
433 timestamp = reply.ReadUint64();
434 paWriteIndex = reply.ReadUint64();
435 cacheTimeDsp = reply.ReadUint64();
436 cacheTimePa = reply.ReadUint64();
437
438 return ret;
439 }
440
OffloadSetVolume(float volume)441 int32_t IpcStreamProxy::OffloadSetVolume(float volume)
442 {
443 MessageParcel data;
444 MessageParcel reply;
445 MessageOption option;
446
447 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
448
449 data.WriteFloat(volume);
450 int ret = Remote()->SendRequest(IpcStreamMsg::ON_SET_OFFLOAD_VOLUME, data, reply, option);
451 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ret, "failed, ipc error: %{public}d", ret);
452 ret = reply.ReadInt32();
453 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "failed, error: %{public}d", ret);
454
455 return ret;
456 }
457
UpdateSpatializationState(bool spatializationEnabled,bool headTrackingEnabled)458 int32_t IpcStreamProxy::UpdateSpatializationState(bool spatializationEnabled, bool headTrackingEnabled)
459 {
460 MessageParcel data;
461 MessageParcel reply;
462 MessageOption option;
463
464 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
465
466 data.WriteBool(spatializationEnabled);
467 data.WriteBool(headTrackingEnabled);
468 int ret = Remote()->SendRequest(IpcStreamMsg::ON_UPDATE_SPATIALIZATION_STATE, data, reply, option);
469 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ret, "failed, ipc error: %{public}d", ret);
470 ret = reply.ReadInt32();
471 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "failed, error: %{public}d", ret);
472 return ret;
473 }
474
GetStreamManagerType()475 int32_t IpcStreamProxy::GetStreamManagerType()
476 {
477 MessageParcel data;
478 MessageParcel reply;
479 MessageOption option;
480
481 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
482 int ret = Remote()->SendRequest(IpcStreamMsg::ON_GET_STREAM_MANAGER_TYPE, data, reply, option);
483 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ret, "failed, ipc error: %{public}d", ret);
484 return reply.ReadInt32();
485 }
486
SetSilentModeAndMixWithOthers(bool on)487 int32_t IpcStreamProxy::SetSilentModeAndMixWithOthers(bool on)
488 {
489 MessageParcel data;
490 MessageParcel reply;
491 MessageOption option;
492
493 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
494
495 data.WriteBool(on);
496 int ret = Remote()->SendRequest(IpcStreamMsg::ON_SET_SILENT_MODE_AND_MIX_WITH_OTHERS, data, reply, option);
497 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ret, "failed, ipc error: %{public}d", ret);
498 ret = reply.ReadInt32();
499 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "failed, error: %{public}d", ret);
500 return ret;
501 }
502
SetClientVolume()503 int32_t IpcStreamProxy::SetClientVolume()
504 {
505 MessageParcel data;
506 MessageParcel reply;
507 MessageOption option;
508
509 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
510
511 int ret = Remote()->SendRequest(IpcStreamMsg::ON_SET_CLIENT_VOLUME, data, reply, option);
512 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ret, "set client volume failed, ipc error: %{public}d", ret);
513 return reply.ReadInt32();
514 }
515
SetMute(bool isMute)516 int32_t IpcStreamProxy::SetMute(bool isMute)
517 {
518 MessageParcel data;
519 MessageParcel reply;
520 MessageOption option;
521
522 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
523
524 data.WriteBool(isMute);
525 int ret = Remote()->SendRequest(IpcStreamMsg::ON_SET_MUTE, data, reply, option);
526 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ret, "set mute failed, ipc error: %{public}d", ret);
527 return reply.ReadInt32();
528 }
529
RegisterThreadPriority(uint32_t tid,const std::string & bundleName)530 int32_t IpcStreamProxy::RegisterThreadPriority(uint32_t tid, const std::string &bundleName)
531 {
532 MessageParcel data;
533 MessageParcel reply;
534 MessageOption option;
535
536 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
537 data.WriteUint32(tid);
538 data.WriteString(bundleName);
539 int ret = Remote()->SendRequest(IpcStreamMsg::ON_REGISTER_THREAD_PRIORITY, data, reply, option);
540 CHECK_AND_RETURN_RET(ret == AUDIO_OK, ret, "failed, ipc error: %{public}d", ret);
541 ret = reply.ReadInt32();
542 CHECK_AND_RETURN_RET(ret == SUCCESS, ret, "failed, error: %{public}d", ret);
543 return ret;
544 }
545 } // namespace AudioStandard
546 } // namespace OHOS
547