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 &timestamp)
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 &timestamp, 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 &timestamp, 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 
UpdateSpatializationState(bool spatializationEnabled,bool headTrackingEnabled)441 int32_t IpcStreamProxy::UpdateSpatializationState(bool spatializationEnabled, bool headTrackingEnabled)
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.WriteBool(spatializationEnabled);
450     data.WriteBool(headTrackingEnabled);
451     int ret = Remote()->SendRequest(IpcStreamMsg::ON_UPDATE_SPATIALIZATION_STATE, data, reply, option);
452     CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ret, "failed, ipc error: %{public}d", ret);
453     ret = reply.ReadInt32();
454     CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "failed, error: %{public}d", ret);
455     return ret;
456 }
457 
GetStreamManagerType()458 int32_t IpcStreamProxy::GetStreamManagerType()
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     int ret = Remote()->SendRequest(IpcStreamMsg::ON_GET_STREAM_MANAGER_TYPE, data, reply, option);
466     CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ret, "failed, ipc error: %{public}d", ret);
467     return reply.ReadInt32();
468 }
469 
SetSilentModeAndMixWithOthers(bool on)470 int32_t IpcStreamProxy::SetSilentModeAndMixWithOthers(bool on)
471 {
472     MessageParcel data;
473     MessageParcel reply;
474     MessageOption option;
475 
476     CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
477 
478     data.WriteBool(on);
479     int ret = Remote()->SendRequest(IpcStreamMsg::ON_SET_SILENT_MODE_AND_MIX_WITH_OTHERS, data, reply, option);
480     CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ret, "failed, ipc error: %{public}d", ret);
481     ret = reply.ReadInt32();
482     CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "failed, error: %{public}d", ret);
483     return ret;
484 }
485 
SetClientVolume()486 int32_t IpcStreamProxy::SetClientVolume()
487 {
488     MessageParcel data;
489     MessageParcel reply;
490     MessageOption option;
491 
492     CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
493 
494     int ret = Remote()->SendRequest(IpcStreamMsg::ON_SET_CLIENT_VOLUME, data, reply, option);
495     CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ret, "set client volume failed, ipc error: %{public}d", ret);
496     return reply.ReadInt32();
497 }
498 
SetMute(bool isMute)499 int32_t IpcStreamProxy::SetMute(bool isMute)
500 {
501     MessageParcel data;
502     MessageParcel reply;
503     MessageOption option;
504 
505     CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
506 
507     data.WriteBool(isMute);
508     int ret = Remote()->SendRequest(IpcStreamMsg::ON_SET_MUTE, data, reply, option);
509     CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ret, "set mute failed, ipc error: %{public}d", ret);
510     return reply.ReadInt32();
511 }
512 
SetDuckFactor(float duckFactor)513 int32_t IpcStreamProxy::SetDuckFactor(float duckFactor)
514 {
515     MessageParcel data;
516     MessageParcel reply;
517     MessageOption option;
518 
519     CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
520 
521     data.WriteFloat(duckFactor);
522     int ret = Remote()->SendRequest(IpcStreamMsg::ON_SET_DUCK_FACTOR, data, reply, option);
523     CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ret, "set duck failed, ipc error: %{public}d", ret);
524     return reply.ReadInt32();
525 }
526 
RegisterThreadPriority(uint32_t tid,const std::string & bundleName)527 int32_t IpcStreamProxy::RegisterThreadPriority(uint32_t tid, const std::string &bundleName)
528 {
529     MessageParcel data;
530     MessageParcel reply;
531     MessageOption option;
532 
533     CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
534     data.WriteUint32(tid);
535     data.WriteString(bundleName);
536     int ret = Remote()->SendRequest(IpcStreamMsg::ON_REGISTER_THREAD_PRIORITY, data, reply, option);
537     CHECK_AND_RETURN_RET(ret == AUDIO_OK, ret, "failed, ipc error: %{public}d", ret);
538     ret = reply.ReadInt32();
539     CHECK_AND_RETURN_RET(ret == SUCCESS, ret, "failed, error: %{public}d", ret);
540     return ret;
541 }
542 } // namespace AudioStandard
543 } // namespace OHOS
544