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 "PolicyProviderProxy"
17 #endif
18
19 #include "policy_provider_proxy.h"
20 #include "audio_service_log.h"
21 #include "audio_errors.h"
22
23 namespace OHOS {
24 namespace AudioStandard {
PolicyProviderProxy(const sptr<IRemoteObject> & impl)25 PolicyProviderProxy::PolicyProviderProxy(const sptr<IRemoteObject> &impl) : IRemoteProxy<IPolicyProviderIpc>(impl)
26 {
27 }
28
~PolicyProviderProxy()29 PolicyProviderProxy::~PolicyProviderProxy()
30 {
31 }
32
GetProcessDeviceInfo(const AudioProcessConfig & config,bool lockFlag,AudioDeviceDescriptor & deviceInfo)33 int32_t PolicyProviderProxy::GetProcessDeviceInfo(const AudioProcessConfig &config, bool lockFlag,
34 AudioDeviceDescriptor &deviceInfo)
35 {
36 MessageParcel data;
37 MessageParcel reply;
38 MessageOption option;
39
40 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
41
42 ProcessConfig::WriteConfigToParcel(config, data);
43 data.WriteBool(lockFlag);
44 int ret = Remote()->SendRequest(IPolicyProviderMsg::GET_DEVICE_INFO, data, reply, option);
45 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ERR_OPERATION_FAILED, "GetProcessDeviceInfo failed, error: %{public}d",
46 ret);
47 deviceInfo.Unmarshalling(reply);
48 return SUCCESS;
49 }
50
InitSharedVolume(std::shared_ptr<AudioSharedMemory> & buffer)51 int32_t PolicyProviderProxy::InitSharedVolume(std::shared_ptr<AudioSharedMemory> &buffer)
52 {
53 MessageParcel data;
54 MessageParcel reply;
55 MessageOption option;
56
57 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
58
59 int ret = Remote()->SendRequest(IPolicyProviderMsg::INIT_VOLUME_MAP, data, reply, option);
60 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ERR_OPERATION_FAILED, "InitSharedVolume failed, error: %{public}d", ret);
61 buffer = AudioSharedMemory::ReadFromParcel(reply);
62 CHECK_AND_RETURN_RET_LOG(buffer != nullptr, ERR_OPERATION_FAILED, "ReadFromParcel failed");
63 return SUCCESS;
64 }
65
SetWakeUpAudioCapturerFromAudioServer(const AudioProcessConfig & config)66 int32_t PolicyProviderProxy::SetWakeUpAudioCapturerFromAudioServer(const AudioProcessConfig &config)
67 {
68 MessageParcel data;
69 MessageParcel reply;
70 MessageOption option;
71
72 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
73
74 ProcessConfig::WriteConfigToParcel(config, data);
75 int ret = Remote()->SendRequest(IPolicyProviderMsg::SET_WAKEUP_ADUIO_CAPTURER, data, reply, option);
76 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ERR_OPERATION_FAILED, "failed, error: %{public}d", ret);
77
78 return reply.ReadInt32();
79 }
80
NotifyCapturerAdded(AudioCapturerInfo capturerInfo,AudioStreamInfo streamInfo,uint32_t sessionId)81 int32_t PolicyProviderProxy::NotifyCapturerAdded(AudioCapturerInfo capturerInfo, AudioStreamInfo streamInfo,
82 uint32_t sessionId)
83 {
84 MessageParcel data;
85 MessageParcel reply;
86 MessageOption option;
87
88 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
89 capturerInfo.Marshalling(data);
90 streamInfo.Marshalling(data);
91 data.WriteUint32(sessionId);
92
93 int ret = Remote()->SendRequest(IPolicyProviderMsg::SET_AUDIO_CAPTURER, data, reply, option);
94 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ERR_OPERATION_FAILED, "failed, error: %{public}d", ret);
95
96 return reply.ReadInt32();
97 }
98
NotifyWakeUpCapturerRemoved()99 int32_t PolicyProviderProxy::NotifyWakeUpCapturerRemoved()
100 {
101 MessageParcel data;
102 MessageParcel reply;
103 MessageOption option;
104
105 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
106
107 int ret = Remote()->SendRequest(IPolicyProviderMsg::REMOVE_WAKEUP_CAPUTER, data, reply, option);
108 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ERR_OPERATION_FAILED, "failed, error: %{public}d", ret);
109
110 return reply.ReadInt32();
111 }
112
IsAbsVolumeSupported()113 bool PolicyProviderProxy::IsAbsVolumeSupported()
114 {
115 MessageParcel data;
116 MessageParcel reply;
117 MessageOption option;
118
119 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
120
121 int ret = Remote()->SendRequest(IPolicyProviderMsg::IS_ABS_VOLUME_SUPPORTED, data, reply, option);
122 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ERR_OPERATION_FAILED, "failed, error: %{public}d", ret);
123
124 return reply.ReadBool();
125 }
126
OffloadGetRenderPosition(uint32_t & delayValue,uint64_t & sendDataSize,uint32_t & timeStamp)127 int32_t PolicyProviderProxy::OffloadGetRenderPosition(uint32_t &delayValue, uint64_t &sendDataSize, uint32_t &timeStamp)
128 {
129 MessageParcel data;
130 MessageParcel reply;
131 MessageOption option;
132
133 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
134
135 int ret = Remote()->SendRequest(IPolicyProviderMsg::OFFLOAD_GET_RENDER_POSITION, data, reply, option);
136 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ERR_OPERATION_FAILED, "failed, error: %{public}d", ret);
137 ret = reply.ReadInt32();
138 delayValue = reply.ReadUint32();
139 sendDataSize = reply.ReadUint64();
140 timeStamp = reply.ReadUint32();
141 return ret;
142 }
143
GetAndSaveClientType(uint32_t uid,const std::string & bundleName)144 int32_t PolicyProviderProxy::GetAndSaveClientType(uint32_t uid, const std::string &bundleName)
145 {
146 MessageParcel data;
147 MessageParcel reply;
148 MessageOption option;
149
150 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
151
152 data.WriteUint32(uid);
153 data.WriteString(bundleName);
154 int ret = Remote()->SendRequest(IPolicyProviderMsg::GET_AND_SAVE_CLIENT_TYPE, data, reply, option);
155 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ERR_OPERATION_FAILED, "failed, error: %{public}d", ret);
156 ret = reply.ReadInt32();
157 return ret;
158 }
159
GetMaxRendererInstances()160 int32_t PolicyProviderProxy::GetMaxRendererInstances()
161 {
162 MessageParcel data;
163 MessageParcel reply;
164 MessageOption option;
165
166 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
167
168 int ret = Remote()->SendRequest(IPolicyProviderMsg::GET_MAX_RENDERER_INSTANCES, data, reply, option);
169 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ERR_OPERATION_FAILED, "failed, error: %{public}d", ret);
170
171 return reply.ReadInt32();
172 }
173
ActivateConcurrencyFromServer(AudioPipeType incomingPipe)174 int32_t PolicyProviderProxy::ActivateConcurrencyFromServer(AudioPipeType incomingPipe)
175 {
176 MessageParcel data;
177 MessageParcel reply;
178 MessageOption option;
179
180 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
181
182 data.WriteInt32(incomingPipe);
183 int ret = Remote()->SendRequest(IPolicyProviderMsg::ACTIVATE_CONCURRENCY_FROM_SERVER, data, reply, option);
184 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ERR_OPERATION_FAILED,
185 "failed, error: %{public}d", ret);
186 return reply.ReadInt32();
187 }
188
NotifyCapturerRemoved(uint64_t sessionId)189 int32_t PolicyProviderProxy::NotifyCapturerRemoved(uint64_t sessionId)
190 {
191 MessageParcel data;
192 MessageParcel reply;
193 MessageOption option;
194 data.WriteUint64(sessionId);
195
196 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
197
198 int ret = Remote()->SendRequest(IPolicyProviderMsg::REMOVE_AUDIO_CAPTURER, data, reply, option);
199 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ERR_OPERATION_FAILED, "failed, error: %{public}d", ret);
200
201 return reply.ReadInt32();
202 }
203
SetDefaultOutputDevice(const DeviceType defaultOutputDevice,const uint32_t sessionID,const StreamUsage streamUsage,bool isRunning)204 int32_t PolicyProviderProxy::SetDefaultOutputDevice(const DeviceType defaultOutputDevice, const uint32_t sessionID,
205 const StreamUsage streamUsage, bool isRunning)
206 {
207 MessageParcel data;
208 MessageParcel reply;
209 MessageOption option;
210
211 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
212 data.WriteInt32(defaultOutputDevice);
213 data.WriteUint32(sessionID);
214 data.WriteInt32(streamUsage);
215 data.WriteBool(isRunning);
216 int ret = Remote()->SendRequest(IPolicyProviderMsg::SET_DEFAULT_OUTPUT_DEVICE, data, reply, option);
217 CHECK_AND_RETURN_RET(ret == AUDIO_OK, ret, "set default output device failed, ipc error: %{public}d", ret);
218 return reply.ReadInt32();
219 }
220
221 #ifdef HAS_FEATURE_INNERCAPTURER
LoadModernInnerCapSink(int32_t innerCapId)222 int32_t PolicyProviderProxy::LoadModernInnerCapSink(int32_t innerCapId)
223 {
224 MessageParcel data;
225 MessageParcel reply;
226 MessageOption option;
227
228 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
229 data.WriteInt32(innerCapId);
230 int ret = Remote()->SendRequest(IPolicyProviderMsg::LOAD_MODERN_INNER_CAPTURE_SINK, data, reply, option);
231 CHECK_AND_RETURN_RET(ret == AUDIO_OK, ret, "LoadModernInnerCapSink failed, ipc error: %{public}d", ret);
232 return reply.ReadInt32();
233 }
234
UnloadModernInnerCapSink(int32_t innerCapId)235 int32_t PolicyProviderProxy::UnloadModernInnerCapSink(int32_t innerCapId)
236 {
237 MessageParcel data;
238 MessageParcel reply;
239 MessageOption option;
240
241 CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!");
242 data.WriteInt32(innerCapId);
243 int ret = Remote()->SendRequest(IPolicyProviderMsg::UNLOAD_MODERN_INNER_CAPTURE_SINK, data, reply, option);
244 CHECK_AND_RETURN_RET(ret == AUDIO_OK, ret, "UnloadModernInnerCapSink failed, ipc error: %{public}d", ret);
245 return reply.ReadInt32();
246 }
247 #endif
248 } // namespace AudioStandard
249 } // namespace OHOS
250