1 /*
2 * Copyright (c) 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
16 #include "ipc_ffi.h"
17
18 #include <string_ex.h>
19
20 #include "ipc_skeleton_imp.h"
21 #include "message_option.h"
22 #include "napi_remote_object_holder.h"
23 #include "napi_remote_proxy_holder.h"
24 #include "napi/native_common.h"
25 #include "remote_object_impl.h"
26 #include "remote_proxy_holder_impl.h"
27 #include "securec.h"
28
29 using namespace OHOS::FFI;
30
31 namespace OHOS {
32 static const size_t ARGV_LENGTH_1 = 1;
33 extern "C" {
FfiRpcMessageSequenceImplCreate()34 int64_t FfiRpcMessageSequenceImplCreate()
35 {
36 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplCreate start");
37 auto rpc = FFIData::Create<MessageSequenceImpl>(nullptr);
38 if (!rpc) {
39 ZLOGE(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplCreate failed");
40 return -1;
41 }
42 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplCreate end");
43 return rpc->GetID();
44 }
45
FfiRpcMessageSequenceImplWriteInterfaceToken(int64_t id,char * token,int32_t * errCode)46 void FfiRpcMessageSequenceImplWriteInterfaceToken(int64_t id, char* token, int32_t* errCode)
47 {
48 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplWriteInterfaceToken start");
49 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
50 if (!rpc) {
51 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
52 *errCode = errorDesc::WRITE_DATA_TO_MESSAGE_SEQUENCE_ERROR;
53 return;
54 }
55 std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> converter;
56 std::u16string str = converter.from_bytes(token);
57 if (str.length() >= MAX_BYTES_LENGTH) {
58 ZLOGE(LOG_LABEL, "[RPC] string length too large");
59 *errCode = errorDesc::CHECK_PARAM_ERROR;
60 return;
61 }
62 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplWriteInterfaceToken end");
63 *errCode = rpc->CJ_WriteInterfaceToken(str);
64 }
65
FfiRpcMessageSequenceImplReadInterfaceToken(int64_t id,int32_t * errCode)66 char* FfiRpcMessageSequenceImplReadInterfaceToken(int64_t id, int32_t* errCode)
67 {
68 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadInterfaceToken start");
69 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
70 if (!rpc) {
71 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
72 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
73 return nullptr;
74 }
75 std::u16string token = rpc->CJ_ReadInterfaceToken(errCode);
76 if (*errCode != 0) {
77 return nullptr;
78 }
79 std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> converter;
80 std::string str = converter.to_bytes(token);
81 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadInterfaceToken end");
82 return MallocCString(str);
83 }
84
FfiRpcMessageSequenceImplGetSize(int64_t id,int32_t * errCode)85 uint32_t FfiRpcMessageSequenceImplGetSize(int64_t id, int32_t* errCode)
86 {
87 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplGetSize start");
88 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
89 if (!rpc) {
90 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
91 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
92 return 0;
93 }
94 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplGetSize end");
95 return rpc->CJ_GetSize(errCode);
96 }
97
FfiRpcMessageSequenceImplGetCapacity(int64_t id,int32_t * errCode)98 uint32_t FfiRpcMessageSequenceImplGetCapacity(int64_t id, int32_t* errCode)
99 {
100 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplGetCapacity start");
101 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
102 if (!rpc) {
103 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
104 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
105 return 0;
106 }
107 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplGetCapacity end");
108 return rpc->CJ_GetCapacity(errCode);
109 }
110
FfiRpcMessageSequenceImplSetSize(int64_t id,uint32_t value,int32_t * errCode)111 void FfiRpcMessageSequenceImplSetSize(int64_t id, uint32_t value, int32_t* errCode)
112 {
113 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplSetSize start");
114 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
115 if (!rpc) {
116 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
117 *errCode = errorDesc::WRITE_DATA_TO_MESSAGE_SEQUENCE_ERROR;
118 return;
119 }
120 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplSetSize end");
121 *errCode = rpc->CJ_SetSize(value);
122 return;
123 }
124
FfiRpcMessageSequenceImplSetCapacity(int64_t id,uint32_t value,int32_t * errCode)125 void FfiRpcMessageSequenceImplSetCapacity(int64_t id, uint32_t value, int32_t* errCode)
126 {
127 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplSetCapacity start");
128 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
129 if (!rpc) {
130 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
131 *errCode = errorDesc::WRITE_DATA_TO_MESSAGE_SEQUENCE_ERROR;
132 return;
133 }
134 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplSetCapacity end");
135 *errCode = rpc->CJ_SetCapacity(value);
136 return;
137 }
138
FfiRpcMessageSequenceImplGetWritableBytes(int64_t id,int32_t * errCode)139 uint32_t FfiRpcMessageSequenceImplGetWritableBytes(int64_t id, int32_t* errCode)
140 {
141 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplGetWritableBytes start");
142 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
143 if (!rpc) {
144 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
145 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
146 return 0;
147 }
148 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplGetWritableBytes end");
149 return rpc->CJ_GetWritableBytes(errCode);
150 }
151
FfiRpcMessageSequenceImplGetReadableBytes(int64_t id,int32_t * errCode)152 uint32_t FfiRpcMessageSequenceImplGetReadableBytes(int64_t id, int32_t* errCode)
153 {
154 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplGetReadableBytes start");
155 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
156 if (!rpc) {
157 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
158 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
159 return 0;
160 }
161 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplGetReadableBytes end");
162 return rpc->CJ_GetReadableBytes(errCode);
163 }
164
FfiRpcMessageSequenceImplGetReadPosition(int64_t id,int32_t * errCode)165 uint32_t FfiRpcMessageSequenceImplGetReadPosition(int64_t id, int32_t* errCode)
166 {
167 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplGetReadPosition start");
168 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
169 if (!rpc) {
170 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
171 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
172 return 0;
173 }
174 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplGetReadPosition end");
175 return rpc->CJ_GetReadPosition(errCode);
176 }
177
FfiRpcMessageSequenceImplGetWritePosition(int64_t id,int32_t * errCode)178 uint32_t FfiRpcMessageSequenceImplGetWritePosition(int64_t id, int32_t* errCode)
179 {
180 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplGetWritePosition start");
181 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
182 if (!rpc) {
183 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
184 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
185 return 0;
186 }
187 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplGetWritePosition end");
188 return rpc->CJ_GetWritePosition(errCode);
189 }
190
FfiRpcMessageSequenceImplRewindWrite(int64_t id,uint32_t pos,int32_t * errCode)191 void FfiRpcMessageSequenceImplRewindWrite(int64_t id, uint32_t pos, int32_t* errCode)
192 {
193 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplRewindWrite start");
194 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
195 if (!rpc) {
196 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
197 *errCode = errorDesc::WRITE_DATA_TO_MESSAGE_SEQUENCE_ERROR;
198 return;
199 }
200 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplRewindWrite end");
201 *errCode = rpc->CJ_RewindWrite(pos);
202 }
203
FfiRpcMessageSequenceImplRewindRead(int64_t id,uint32_t pos,int32_t * errCode)204 void FfiRpcMessageSequenceImplRewindRead(int64_t id, uint32_t pos, int32_t* errCode)
205 {
206 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplRewindRead start");
207 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
208 if (!rpc) {
209 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
210 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
211 return;
212 }
213 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplRewindRead end");
214 *errCode = rpc->CJ_RewindRead(pos);
215 }
216
FfiRpcMessageSequenceImplWriteNoException(int64_t id,int32_t * errCode)217 void FfiRpcMessageSequenceImplWriteNoException(int64_t id, int32_t* errCode)
218 {
219 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplWriteNoException start");
220 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
221 if (!rpc) {
222 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
223 *errCode = errorDesc::WRITE_DATA_TO_MESSAGE_SEQUENCE_ERROR;
224 return;
225 }
226 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplWriteNoException end");
227 *errCode = rpc->CJ_WriteNoException();
228 }
229
FfiRpcMessageSequenceImplReadException(int64_t id,int32_t * errCode)230 char* FfiRpcMessageSequenceImplReadException(int64_t id, int32_t* errCode)
231 {
232 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadException start");
233 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
234 if (!rpc) {
235 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
236 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
237 return nullptr;
238 }
239 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadException end");
240 std::string res = rpc->CJ_ReadException(errCode);
241 if (*errCode != 0) {
242 return nullptr;
243 }
244 return MallocCString(res);
245 }
246
FfiRpcMessageSequenceImplWriteByte(int64_t id,int8_t value,int32_t * errCode)247 void FfiRpcMessageSequenceImplWriteByte(int64_t id, int8_t value, int32_t* errCode)
248 {
249 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplWriteByte start");
250 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
251 if (!rpc) {
252 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
253 *errCode = errorDesc::WRITE_DATA_TO_MESSAGE_SEQUENCE_ERROR;
254 return;
255 }
256 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplWriteByte end");
257 *errCode = rpc->CJ_WriteByte(value);
258 }
259
FfiRpcMessageSequenceImplWriteShort(int64_t id,int16_t value,int32_t * errCode)260 void FfiRpcMessageSequenceImplWriteShort(int64_t id, int16_t value, int32_t* errCode)
261 {
262 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplWriteShort start");
263 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
264 if (!rpc) {
265 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
266 *errCode = errorDesc::WRITE_DATA_TO_MESSAGE_SEQUENCE_ERROR;
267 return;
268 }
269 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplWriteShort end");
270 *errCode = rpc->CJ_WriteShort(value);
271 }
272
FfiRpcMessageSequenceImplWriteInt(int64_t id,int32_t value,int32_t * errCode)273 void FfiRpcMessageSequenceImplWriteInt(int64_t id, int32_t value, int32_t* errCode)
274 {
275 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplWriteInt start");
276 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
277 if (!rpc) {
278 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
279 *errCode = errorDesc::WRITE_DATA_TO_MESSAGE_SEQUENCE_ERROR;
280 return;
281 }
282 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplWriteInt end");
283 *errCode = rpc->CJ_WriteInt(value);
284 }
285
FfiRpcMessageSequenceImplWriteLong(int64_t id,int64_t value,int32_t * errCode)286 void FfiRpcMessageSequenceImplWriteLong(int64_t id, int64_t value, int32_t* errCode)
287 {
288 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplWriteLong start");
289 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
290 if (!rpc) {
291 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
292 *errCode = errorDesc::WRITE_DATA_TO_MESSAGE_SEQUENCE_ERROR;
293 return;
294 }
295 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplWriteLong end");
296 *errCode = rpc->CJ_WriteLong(value);
297 }
298
FfiRpcMessageSequenceImplWriteFloat(int64_t id,float value,int32_t * errCode)299 void FfiRpcMessageSequenceImplWriteFloat(int64_t id, float value, int32_t* errCode)
300 {
301 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplWriteFloat start");
302 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
303 if (!rpc) {
304 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
305 *errCode = errorDesc::WRITE_DATA_TO_MESSAGE_SEQUENCE_ERROR;
306 return;
307 }
308 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplWriteFloat end");
309 *errCode = rpc->CJ_WriteFloat(value);
310 }
311
FfiRpcMessageSequenceImplWriteDouble(int64_t id,double value,int32_t * errCode)312 void FfiRpcMessageSequenceImplWriteDouble(int64_t id, double value, int32_t* errCode)
313 {
314 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplWriteDouble start");
315 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
316 if (!rpc) {
317 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
318 *errCode = errorDesc::WRITE_DATA_TO_MESSAGE_SEQUENCE_ERROR;
319 return;
320 }
321 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplWriteDouble end");
322 *errCode = rpc->CJ_WriteDouble(value);
323 }
324
FfiRpcMessageSequenceImplWriteBoolean(int64_t id,int8_t value,int32_t * errCode)325 void FfiRpcMessageSequenceImplWriteBoolean(int64_t id, int8_t value, int32_t* errCode)
326 {
327 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplWriteBoolean start");
328 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
329 if (!rpc) {
330 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
331 *errCode = errorDesc::WRITE_DATA_TO_MESSAGE_SEQUENCE_ERROR;
332 return;
333 }
334 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplWriteBoolean end");
335 *errCode = rpc->CJ_WriteBoolean(value);
336 }
337
FfiRpcMessageSequenceImplWriteChar(int64_t id,uint8_t value,int32_t * errCode)338 void FfiRpcMessageSequenceImplWriteChar(int64_t id, uint8_t value, int32_t* errCode)
339 {
340 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplWriteChar start");
341 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
342 if (!rpc) {
343 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
344 *errCode = errorDesc::WRITE_DATA_TO_MESSAGE_SEQUENCE_ERROR;
345 return;
346 }
347 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplWriteChar end");
348 *errCode = rpc->CJ_WriteChar(value);
349 }
350
FfiRpcMessageSequenceImplWriteString(int64_t id,char * value,int32_t * errCode)351 void FfiRpcMessageSequenceImplWriteString(int64_t id, char* value, int32_t* errCode)
352 {
353 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplWriteString start");
354 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
355 if (!rpc) {
356 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
357 *errCode = errorDesc::WRITE_DATA_TO_MESSAGE_SEQUENCE_ERROR;
358 return;
359 }
360 std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> converter;
361 std::u16string str = converter.from_bytes(value);
362 if (str.length() >= MAX_BYTES_LENGTH) {
363 ZLOGE(LOG_LABEL, "string length too large");
364 *errCode = errorDesc::CHECK_PARAM_ERROR;
365 return;
366 }
367 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplWriteString end");
368 *errCode = rpc->CJ_WriteString(str);
369 }
370
FfiRpcMessageSequenceImplWriteByteArray(int64_t id,OHOS::CJByteArray value,int32_t * errCode)371 void FfiRpcMessageSequenceImplWriteByteArray(int64_t id, OHOS::CJByteArray value, int32_t* errCode)
372 {
373 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplWriteByteArray start");
374 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
375 if (!rpc) {
376 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
377 *errCode = errorDesc::WRITE_DATA_TO_MESSAGE_SEQUENCE_ERROR;
378 return;
379 }
380 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplWriteByteArray end");
381 *errCode = rpc->CJ_WriteByteArray(value);
382 }
383
FfiRpcMessageSequenceImplWriteShortArray(int64_t id,OHOS::CJShortArray value,int32_t * errCode)384 void FfiRpcMessageSequenceImplWriteShortArray(int64_t id, OHOS::CJShortArray value, int32_t* errCode)
385 {
386 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplWriteShortArray start");
387 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
388 if (!rpc) {
389 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
390 *errCode = errorDesc::WRITE_DATA_TO_MESSAGE_SEQUENCE_ERROR;
391 return;
392 }
393 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplWritShortArray end");
394 *errCode = rpc->CJ_WriteShortArray(value);
395 }
396
FfiRpcMessageSequenceImplWriteIntArray(int64_t id,OHOS::CJIntArray value,int32_t * errCode)397 void FfiRpcMessageSequenceImplWriteIntArray(int64_t id, OHOS::CJIntArray value, int32_t* errCode)
398 {
399 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplWriteIntArray start");
400 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
401 if (!rpc) {
402 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
403 *errCode = errorDesc::WRITE_DATA_TO_MESSAGE_SEQUENCE_ERROR;
404 return;
405 }
406 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplWriteIntArray end");
407 *errCode = rpc->CJ_WriteIntArray(value);
408 }
409
FfiRpcMessageSequenceImplWriteLongArray(int64_t id,OHOS::CJLongArray value,int32_t * errCode)410 void FfiRpcMessageSequenceImplWriteLongArray(int64_t id, OHOS::CJLongArray value, int32_t* errCode)
411 {
412 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplWriteLongArray start");
413 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
414 if (!rpc) {
415 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
416 *errCode = errorDesc::WRITE_DATA_TO_MESSAGE_SEQUENCE_ERROR;
417 return;
418 }
419 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplWriteLongArray end");
420 *errCode = rpc->CJ_WriteLongArray(value);
421 }
422
FfiRpcMessageSequenceImplWriteFloatArray(int64_t id,OHOS::CJFloatArray value,int32_t * errCode)423 void FfiRpcMessageSequenceImplWriteFloatArray(int64_t id, OHOS::CJFloatArray value, int32_t* errCode)
424 {
425 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplWriteFloatArray start");
426 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
427 if (!rpc) {
428 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
429 *errCode = errorDesc::WRITE_DATA_TO_MESSAGE_SEQUENCE_ERROR;
430 return;
431 }
432 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplWriteFloatArray end");
433 *errCode = rpc->CJ_WriteFloatArray(value);
434 }
435
FfiRpcMessageSequenceImplWriteDoubleArray(int64_t id,OHOS::CJDoubleArray value,int32_t * errCode)436 void FfiRpcMessageSequenceImplWriteDoubleArray(int64_t id, OHOS::CJDoubleArray value, int32_t* errCode)
437 {
438 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplWriteDoubleArray start");
439 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
440 if (!rpc) {
441 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
442 *errCode = errorDesc::WRITE_DATA_TO_MESSAGE_SEQUENCE_ERROR;
443 return;
444 }
445 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplWriteDoubleArray end");
446 *errCode = rpc->CJ_WriteDoubleArray(value);
447 }
448
FfiRpcMessageSequenceImplWriteBooleanArray(int64_t id,OHOS::CJByteArray value,int32_t * errCode)449 void FfiRpcMessageSequenceImplWriteBooleanArray(int64_t id, OHOS::CJByteArray value, int32_t* errCode)
450 {
451 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplWriteBooleanArray start");
452 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
453 if (!rpc) {
454 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
455 *errCode = errorDesc::WRITE_DATA_TO_MESSAGE_SEQUENCE_ERROR;
456 return;
457 }
458 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplWriteBooleanArray end");
459 *errCode = rpc->CJ_WriteBooleanArray(value);
460 }
461
FfiRpcMessageSequenceImplWriteCharArray(int64_t id,OHOS::CJCharArray value,int32_t * errCode)462 void FfiRpcMessageSequenceImplWriteCharArray(int64_t id, OHOS::CJCharArray value, int32_t* errCode)
463 {
464 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplWriteCharArray start");
465 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
466 if (!rpc) {
467 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
468 *errCode = errorDesc::WRITE_DATA_TO_MESSAGE_SEQUENCE_ERROR;
469 return;
470 }
471 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplWriteCharArray end");
472 *errCode = rpc->CJ_WriteCharArray(value);
473 }
474
FfiRpcMessageSequenceImplWriteStringArray(int64_t id,OHOS::CJStringArray value,int32_t * errCode)475 void FfiRpcMessageSequenceImplWriteStringArray(int64_t id, OHOS::CJStringArray value, int32_t* errCode)
476 {
477 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplWriteStringArray start");
478 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
479 if (!rpc) {
480 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
481 *errCode = errorDesc::WRITE_DATA_TO_MESSAGE_SEQUENCE_ERROR;
482 return;
483 }
484 std::u16string stringValue[value.len];
485 std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> converter;
486 for (uint32_t i = 0; i < value.len; i++) {
487 stringValue[i] = converter.from_bytes(value.data[i]);
488 if (stringValue[i].length() >= MAX_BYTES_LENGTH) {
489 ZLOGE(LOG_LABEL, "string length too large");
490 *errCode = errorDesc::CHECK_PARAM_ERROR;
491 return;
492 }
493 }
494 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplWriteStringArray end");
495 *errCode = rpc->CJ_WriteStringArray(stringValue, value.len);
496 }
497
FfiRpcMessageSequenceImplWriteArrayBuffer(int64_t id,int32_t typeCode,void * value,size_t byteLength,int32_t * errCode)498 void FfiRpcMessageSequenceImplWriteArrayBuffer(
499 int64_t id, int32_t typeCode, void* value, size_t byteLength, int32_t* errCode)
500 {
501 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplWriteArrayBuffer start");
502 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
503 if (!rpc) {
504 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
505 *errCode = errorDesc::WRITE_DATA_TO_MESSAGE_SEQUENCE_ERROR;
506 return;
507 }
508 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplWriteArrayBuffer end");
509 *errCode = rpc->CJ_WriteArrayBuffer(typeCode, value, byteLength);
510 }
511
FfiRpcMessageSequenceImplWriteUint32(int64_t id,uint32_t value)512 bool FfiRpcMessageSequenceImplWriteUint32(int64_t id, uint32_t value)
513 {
514 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplWriteUint32 start");
515 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
516 if (!rpc) {
517 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
518 return false;
519 }
520 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplWriteUint32 end");
521 return rpc->CJ_WriteUint32(value);
522 }
523
FfiRpcMessageSequenceImplWriteRawDataBuffer(int64_t id,uint8_t * data,int64_t size,int32_t * errCode)524 void FfiRpcMessageSequenceImplWriteRawDataBuffer(int64_t id, uint8_t* data, int64_t size, int32_t* errCode)
525 {
526 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplWriteRawDataBuffer start");
527 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
528 if (!rpc) {
529 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
530 *errCode = errorDesc::WRITE_DATA_TO_MESSAGE_SEQUENCE_ERROR;
531 return;
532 }
533 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplWriteRawDataBuffer end");
534 *errCode = rpc->CJ_WriteRawDataBuffer(data, size);
535 }
536
FfiRpcMessageSequenceImplWriteRemoteObject(int64_t id,int64_t object,int32_t * errCode)537 void FfiRpcMessageSequenceImplWriteRemoteObject(int64_t id, int64_t object, int32_t* errCode)
538 {
539 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplWriteRemoteObject start");
540 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
541 if (!rpc) {
542 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
543 *errCode = errorDesc::WRITE_DATA_TO_MESSAGE_SEQUENCE_ERROR;
544 return;
545 }
546 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplWriteRemoteObject end");
547 *errCode = rpc->CJ_WriteRemoteObject(object);
548 }
549
FfiRpcMessageSequenceImplWriteRemoteObjectArray(int64_t id,OHOS::CJLongArray value,int32_t * errCode)550 void FfiRpcMessageSequenceImplWriteRemoteObjectArray(int64_t id, OHOS::CJLongArray value, int32_t* errCode)
551 {
552 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplWriteRemoteObjectArray start");
553 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
554 if (!rpc) {
555 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
556 *errCode = errorDesc::WRITE_DATA_TO_MESSAGE_SEQUENCE_ERROR;
557 return;
558 }
559 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplWriteRemoteObjectArray end");
560 *errCode = rpc->CJ_WriteRemoteObjectArray(value);
561 }
562
FfiRpcMessageSequenceImplReadByte(int64_t id,int32_t * errCode)563 int8_t FfiRpcMessageSequenceImplReadByte(int64_t id, int32_t* errCode)
564 {
565 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadByte start");
566 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
567 if (!rpc) {
568 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
569 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
570 return 0;
571 }
572 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadByte end");
573 return rpc->CJ_ReadByte(errCode);
574 }
575
FfiRpcMessageSequenceImplReadShort(int64_t id,int32_t * errCode)576 int16_t FfiRpcMessageSequenceImplReadShort(int64_t id, int32_t* errCode)
577 {
578 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadShort start");
579 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
580 if (!rpc) {
581 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
582 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
583 return 0;
584 }
585 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadShort end");
586 return rpc->CJ_ReadShort(errCode);
587 }
588
FfiRpcMessageSequenceImplReadInt(int64_t id,int32_t * errCode)589 int32_t FfiRpcMessageSequenceImplReadInt(int64_t id, int32_t* errCode)
590 {
591 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadInt start");
592 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
593 if (!rpc) {
594 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
595 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
596 return 0;
597 }
598 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadInt end");
599 return rpc->CJ_ReadInt(errCode);
600 }
601
FfiRpcMessageSequenceImplReadLong(int64_t id,int32_t * errCode)602 int64_t FfiRpcMessageSequenceImplReadLong(int64_t id, int32_t* errCode)
603 {
604 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadLong start");
605 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
606 if (!rpc) {
607 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
608 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
609 return 0;
610 }
611 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadLong end");
612 return rpc->CJ_ReadLong(errCode);
613 }
614
FfiRpcMessageSequenceImplReadFloat(int64_t id,int32_t * errCode)615 float FfiRpcMessageSequenceImplReadFloat(int64_t id, int32_t* errCode)
616 {
617 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadFloat start");
618 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
619 if (!rpc) {
620 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
621 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
622 return 0;
623 }
624 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadFloat end");
625 return rpc->CJ_ReadFloat(errCode);
626 }
627
FfiRpcMessageSequenceImplReadDouble(int64_t id,int32_t * errCode)628 double FfiRpcMessageSequenceImplReadDouble(int64_t id, int32_t* errCode)
629 {
630 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadDouble start");
631 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
632 if (!rpc) {
633 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
634 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
635 return 0;
636 }
637 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadDouble end");
638 return rpc->CJ_ReadDouble(errCode);
639 }
640
FfiRpcMessageSequenceImplReadBoolean(int64_t id,int32_t * errCode)641 int8_t FfiRpcMessageSequenceImplReadBoolean(int64_t id, int32_t* errCode)
642 {
643 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadBoolean start");
644 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
645 if (!rpc) {
646 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
647 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
648 return 0;
649 }
650 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadBoolean end");
651 return rpc->CJ_ReadBoolean(errCode);
652 }
653
FfiRpcMessageSequenceImplReadChar(int64_t id,int32_t * errCode)654 uint8_t FfiRpcMessageSequenceImplReadChar(int64_t id, int32_t* errCode)
655 {
656 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadChar start");
657 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
658 if (!rpc) {
659 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
660 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
661 return 0;
662 }
663 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadChar end");
664 return rpc->CJ_ReadChar(errCode);
665 }
666
FfiRpcMessageSequenceImplReadString(int64_t id,int32_t * errCode)667 char* FfiRpcMessageSequenceImplReadString(int64_t id, int32_t* errCode)
668 {
669 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadString start");
670 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
671 if (!rpc) {
672 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
673 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
674 return nullptr;
675 }
676 std::u16string token = rpc->CJ_ReadString(errCode);
677 if (*errCode != 0) {
678 return nullptr;
679 }
680 std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> converter;
681 std::string str = converter.to_bytes(token);
682 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadString end");
683 return MallocCString(str);
684 }
685
FfiRpcMessageSequenceImplReadByteArray(int64_t id,int32_t * errCode)686 OHOS::CJByteArray FfiRpcMessageSequenceImplReadByteArray(int64_t id, int32_t* errCode)
687 {
688 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadByteArray start");
689 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
690 if (!rpc) {
691 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
692 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
693 return OHOS::CJByteArray { 0 };
694 }
695 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadByteArray end");
696 return rpc->CJ_ReadByteArray(errCode);
697 }
698
FfiRpcMessageSequenceImplReadShortArray(int64_t id,int32_t * errCode)699 OHOS::CJShortArray FfiRpcMessageSequenceImplReadShortArray(int64_t id, int32_t* errCode)
700 {
701 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadShortArray start");
702 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
703 if (!rpc) {
704 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
705 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
706 return OHOS::CJShortArray { 0 };
707 }
708 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadShortArray end");
709 return rpc->CJ_ReadShortArray(errCode);
710 }
711
FfiRpcMessageSequenceImplReadIntArray(int64_t id,int32_t * errCode)712 OHOS::CJIntArray FfiRpcMessageSequenceImplReadIntArray(int64_t id, int32_t* errCode)
713 {
714 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadIntArray start");
715 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
716 if (!rpc) {
717 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
718 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
719 return OHOS::CJIntArray { 0 };
720 }
721 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadIntArray end");
722 return rpc->CJ_ReadIntArray(errCode);
723 }
724
FfiRpcMessageSequenceImplReadLongArray(int64_t id,int32_t * errCode)725 OHOS::CJLongArray FfiRpcMessageSequenceImplReadLongArray(int64_t id, int32_t* errCode)
726 {
727 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadLongArray start");
728 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
729 if (!rpc) {
730 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
731 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
732 return OHOS::CJLongArray { 0 };
733 }
734 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadLongArray end");
735 return rpc->CJ_ReadLongArray(errCode);
736 }
737
FfiRpcMessageSequenceImplReadFloatArray(int64_t id,int32_t * errCode)738 OHOS::CJFloatArray FfiRpcMessageSequenceImplReadFloatArray(int64_t id, int32_t* errCode)
739 {
740 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadFloatArray start");
741 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
742 if (!rpc) {
743 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
744 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
745 return OHOS::CJFloatArray { 0 };
746 }
747 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadFloatArray end");
748 return rpc->CJ_ReadFloatArray(errCode);
749 }
750
FfiRpcMessageSequenceImplReadDoubleArray(int64_t id,int32_t * errCode)751 OHOS::CJDoubleArray FfiRpcMessageSequenceImplReadDoubleArray(int64_t id, int32_t* errCode)
752 {
753 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadDoubleArray start");
754 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
755 if (!rpc) {
756 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
757 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
758 return OHOS::CJDoubleArray { 0 };
759 }
760 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadDoubleArray end");
761 return rpc->CJ_ReadDoubleArray(errCode);
762 }
763
FfiRpcMessageSequenceImplReadBooleanArray(int64_t id,int32_t * errCode)764 OHOS::CJByteArray FfiRpcMessageSequenceImplReadBooleanArray(int64_t id, int32_t* errCode)
765 {
766 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadBooleanArray start");
767 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
768 if (!rpc) {
769 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
770 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
771 return OHOS::CJByteArray { 0 };
772 }
773 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadBooleanArray end");
774 return rpc->CJ_ReadBooleanArray(errCode);
775 }
776
FfiRpcMessageSequenceImplReadCharArray(int64_t id,int32_t * errCode)777 OHOS::CJCharArray FfiRpcMessageSequenceImplReadCharArray(int64_t id, int32_t* errCode)
778 {
779 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadCharArray start");
780 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
781 if (!rpc) {
782 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
783 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
784 return OHOS::CJCharArray { 0 };
785 }
786 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadCharArray end");
787 return rpc->CJ_ReadCharArray(errCode);
788 }
789
FfiRpcMessageSequenceImplReadStringArray(int64_t id,int32_t * errCode)790 OHOS::CJStringArray FfiRpcMessageSequenceImplReadStringArray(int64_t id, int32_t* errCode)
791 {
792 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadStringArray start");
793 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
794 if (!rpc) {
795 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
796 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
797 return OHOS::CJStringArray { 0 };
798 }
799 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadStringArray end");
800 return rpc->CJ_ReadStringArray(errCode);
801 }
802
FfiRpcMessageSequenceImplReadInt8ArrayBuffer(int64_t id,int32_t * errCode)803 OHOS::CJByteArray FfiRpcMessageSequenceImplReadInt8ArrayBuffer(int64_t id, int32_t* errCode)
804 {
805 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadInt8ArrayBuffer start");
806 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
807 if (!rpc) {
808 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
809 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
810 return OHOS::CJByteArray { 0 };
811 }
812 std::vector<int8_t> vector = rpc->CJ_ReadInt8ArrayBuffer(errCode);
813 if (*errCode != 0) {
814 return OHOS::CJByteArray { 0 };
815 }
816 size_t bufferSize = vector.size();
817 if (bufferSize <= 0) {
818 return OHOS::CJByteArray { 0 };
819 }
820 int8_t* arr = static_cast<int8_t*>(malloc(bufferSize));
821 if (arr == nullptr) {
822 ZLOGE(LOG_LABEL, "[RPC] create arrayBuffer failed.");
823 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
824 return OHOS::CJByteArray { 0 };
825 }
826 errno_t ret = memcpy_s(arr, bufferSize, vector.data(), bufferSize);
827 if (ret != EOK) {
828 free(arr);
829 ZLOGE(LOG_LABEL, "[RPC] memcpy_s is failed.");
830 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
831 return OHOS::CJByteArray { 0 };
832 }
833 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadInt8ArrayBuffer end");
834 return OHOS::CJByteArray { .data = arr, .len = static_cast<uint32_t>(bufferSize) };
835 }
836
FfiRpcMessageSequenceImplReadUInt8ArrayBuffer(int64_t id,int32_t * errCode)837 OHOS::CJCharArray FfiRpcMessageSequenceImplReadUInt8ArrayBuffer(int64_t id, int32_t* errCode)
838 {
839 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadUInt8ArrayBuffer start");
840 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
841 if (!rpc) {
842 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
843 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
844 return OHOS::CJCharArray { 0 };
845 }
846 std::vector<uint8_t> vector = rpc->CJ_ReadUInt8ArrayBuffer(errCode);
847 size_t bufferSize = vector.size();
848 if (bufferSize <= 0) {
849 return OHOS::CJCharArray { 0 };
850 }
851 uint8_t* arr = static_cast<uint8_t*>(malloc(bufferSize));
852 if (arr == nullptr) {
853 ZLOGE(LOG_LABEL, "[RPC] create arrayBuffer failed.");
854 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
855 return OHOS::CJCharArray { 0 };
856 }
857 errno_t ret = memcpy_s(arr, bufferSize, vector.data(), bufferSize);
858 if (ret != EOK) {
859 free(arr);
860 ZLOGE(LOG_LABEL, "[RPC] memcpy_s is failed.");
861 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
862 return OHOS::CJCharArray { 0 };
863 }
864 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadUInt8ArrayBuffer end");
865 return OHOS::CJCharArray { .data = arr, .len = static_cast<uint32_t>(bufferSize) };
866 }
867
FfiRpcMessageSequenceImplReadInt16ArrayBuffer(int64_t id,int32_t * errCode)868 OHOS::CJShortArray FfiRpcMessageSequenceImplReadInt16ArrayBuffer(int64_t id, int32_t* errCode)
869 {
870 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadInt16ArrayBuffer start");
871 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
872 if (!rpc) {
873 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
874 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
875 return OHOS::CJShortArray { 0 };
876 }
877 std::vector<int16_t> vector = rpc->CJ_ReadInt16ArrayBuffer(errCode);
878 size_t bufferSize = vector.size();
879 if (bufferSize <= 0) {
880 return OHOS::CJShortArray { 0 };
881 }
882 int16_t* arr = static_cast<int16_t*>(malloc(sizeof(int16_t) * bufferSize));
883 if (arr == nullptr) {
884 ZLOGE(LOG_LABEL, "[RPC] create arrayBuffer failed.");
885 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
886 return OHOS::CJShortArray { 0 };
887 }
888 errno_t ret = memcpy_s(arr, bufferSize * BYTE_SIZE_16, vector.data(), bufferSize * BYTE_SIZE_16);
889 if (ret != EOK) {
890 free(arr);
891 ZLOGE(LOG_LABEL, "[RPC] memcpy_s is failed.");
892 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
893 return OHOS::CJShortArray { 0 };
894 }
895 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadInt16ArrayBuffer end");
896 return OHOS::CJShortArray { .data = arr, .len = static_cast<uint32_t>(bufferSize) };
897 }
898
FfiRpcMessageSequenceImplReadUInt16ArrayBuffer(int64_t id,int32_t * errCode)899 OHOS::CJUInt16Array FfiRpcMessageSequenceImplReadUInt16ArrayBuffer(int64_t id, int32_t* errCode)
900 {
901 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadUInt16ArrayBuffer start");
902 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
903 if (!rpc) {
904 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
905 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
906 return OHOS::CJUInt16Array { 0 };
907 }
908 std::vector<uint16_t> vector = rpc->CJ_ReadUInt16ArrayBuffer(errCode);
909 size_t bufferSize = vector.size();
910 if (bufferSize <= 0) {
911 return OHOS::CJUInt16Array { 0 };
912 }
913 uint16_t* arr = static_cast<uint16_t*>(malloc(sizeof(uint16_t) * bufferSize));
914 if (arr == nullptr) {
915 ZLOGE(LOG_LABEL, "[RPC] create arrayBuffer failed.");
916 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
917 return OHOS::CJUInt16Array { 0 };
918 }
919 errno_t ret = memcpy_s(arr, bufferSize * BYTE_SIZE_16, vector.data(), bufferSize * BYTE_SIZE_16);
920 if (ret != EOK) {
921 free(arr);
922 ZLOGE(LOG_LABEL, "[RPC] memcpy_s is failed.");
923 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
924 return OHOS::CJUInt16Array { 0 };
925 }
926 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadUInt16ArrayBuffer end");
927 return OHOS::CJUInt16Array { .data = arr, .len = static_cast<uint32_t>(bufferSize) };
928 }
929
FfiRpcMessageSequenceImplReadInt32ArrayBuffer(int64_t id,int32_t * errCode)930 OHOS::CJIntArray FfiRpcMessageSequenceImplReadInt32ArrayBuffer(int64_t id, int32_t* errCode)
931 {
932 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadInt32ArrayBuffer start");
933 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
934 if (!rpc) {
935 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
936 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
937 return OHOS::CJIntArray { 0 };
938 }
939 std::vector<int32_t> vector = rpc->CJ_ReadInt32ArrayBuffer(errCode);
940 size_t bufferSize = vector.size();
941 if (bufferSize <= 0) {
942 return OHOS::CJIntArray { 0 };
943 }
944 int32_t* arr = static_cast<int32_t*>(malloc(sizeof(int32_t) * bufferSize));
945 if (arr == nullptr) {
946 ZLOGE(LOG_LABEL, "[RPC] create arrayBuffer failed.");
947 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
948 return OHOS::CJIntArray { 0 };
949 }
950 errno_t ret = memcpy_s(arr, bufferSize * BYTE_SIZE_32, vector.data(), bufferSize * BYTE_SIZE_32);
951 if (ret != EOK) {
952 free(arr);
953 ZLOGE(LOG_LABEL, "[RPC] memcpy_s is failed.");
954 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
955 return OHOS::CJIntArray { 0 };
956 }
957 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadInt32ArrayBuffer end");
958 return OHOS::CJIntArray { .data = arr, .len = static_cast<uint32_t>(bufferSize) };
959 }
960
FfiRpcMessageSequenceImplReadUInt32ArrayBuffer(int64_t id,int32_t * errCode)961 OHOS::CJUInt32Array FfiRpcMessageSequenceImplReadUInt32ArrayBuffer(int64_t id, int32_t* errCode)
962 {
963 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadUInt32ArrayBuffer start");
964 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
965 if (!rpc) {
966 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
967 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
968 return OHOS::CJUInt32Array { 0 };
969 }
970 std::vector<uint32_t> vector = rpc->CJ_ReadUInt32ArrayBuffer(errCode);
971 size_t bufferSize = vector.size();
972 if (bufferSize <= 0) {
973 return OHOS::CJUInt32Array { 0 };
974 }
975 uint32_t* arr = static_cast<uint32_t*>(malloc(sizeof(uint32_t) * bufferSize));
976 if (arr == nullptr) {
977 ZLOGE(LOG_LABEL, "[RPC] create arrayBuffer failed.");
978 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
979 return OHOS::CJUInt32Array { 0 };
980 }
981 errno_t ret = memcpy_s(arr, bufferSize * BYTE_SIZE_32, vector.data(), bufferSize * BYTE_SIZE_32);
982 if (ret != EOK) {
983 free(arr);
984 ZLOGE(LOG_LABEL, "[RPC] memcpy_s is failed.");
985 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
986 return OHOS::CJUInt32Array { 0 };
987 }
988 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadUInt32ArrayBuffer end");
989 return OHOS::CJUInt32Array { .data = arr, .len = static_cast<uint32_t>(bufferSize) };
990 }
991
FfiRpcMessageSequenceImplReadFloatArrayBuffer(int64_t id,int32_t * errCode)992 OHOS::CJFloatArray FfiRpcMessageSequenceImplReadFloatArrayBuffer(int64_t id, int32_t* errCode)
993 {
994 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadFloatArrayBuffer start");
995 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
996 if (!rpc) {
997 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
998 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
999 return OHOS::CJFloatArray { 0 };
1000 }
1001 std::vector<float> vector = rpc->CJ_ReadFloatArrayBuffer(errCode);
1002 size_t bufferSize = vector.size();
1003 if (bufferSize <= 0) {
1004 return OHOS::CJFloatArray { 0 };
1005 }
1006 float* arr = static_cast<float*>(malloc(sizeof(float) * bufferSize));
1007 if (arr == nullptr) {
1008 ZLOGE(LOG_LABEL, "[RPC] create arrayBuffer failed.");
1009 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
1010 return OHOS::CJFloatArray { 0 };
1011 }
1012 errno_t ret = memcpy_s(arr, bufferSize * BYTE_SIZE_32, vector.data(), bufferSize * BYTE_SIZE_32);
1013 if (ret != EOK) {
1014 free(arr);
1015 ZLOGE(LOG_LABEL, "[RPC] memcpy_s is failed.");
1016 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
1017 return OHOS::CJFloatArray { 0 };
1018 }
1019 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadFloatArrayBuffer end");
1020 return OHOS::CJFloatArray { .data = arr, .len = static_cast<uint32_t>(bufferSize) };
1021 }
1022
FfiRpcMessageSequenceImplReadDoubleArrayBuffer(int64_t id,int32_t * errCode)1023 OHOS::CJDoubleArray FfiRpcMessageSequenceImplReadDoubleArrayBuffer(int64_t id, int32_t* errCode)
1024 {
1025 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadDoubleArrayBuffer start");
1026 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
1027 if (!rpc) {
1028 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
1029 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
1030 return OHOS::CJDoubleArray { 0 };
1031 }
1032 std::vector<double> vector = rpc->CJ_ReadDoubleArrayBuffer(errCode);
1033 size_t bufferSize = vector.size();
1034 if (bufferSize <= 0) {
1035 return OHOS::CJDoubleArray { 0 };
1036 }
1037 double* arr = static_cast<double*>(malloc(sizeof(double) * bufferSize));
1038 if (arr == nullptr) {
1039 ZLOGE(LOG_LABEL, "[RPC] create arrayBuffer failed.");
1040 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
1041 return OHOS::CJDoubleArray { 0 };
1042 }
1043 errno_t ret = memcpy_s(arr, bufferSize * BYTE_SIZE_64, vector.data(), bufferSize * BYTE_SIZE_64);
1044 if (ret != EOK) {
1045 free(arr);
1046 ZLOGE(LOG_LABEL, "[RPC] memcpy_s is failed.");
1047 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
1048 return OHOS::CJDoubleArray { 0 };
1049 }
1050 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadDoubleArrayBuffer end");
1051 return OHOS::CJDoubleArray { .data = arr, .len = static_cast<uint32_t>(bufferSize) };
1052 }
FfiRpcMessageSequenceImplReadInt64ArrayBuffer(int64_t id,int32_t * errCode)1053 OHOS::CJLongArray FfiRpcMessageSequenceImplReadInt64ArrayBuffer(int64_t id, int32_t* errCode)
1054 {
1055 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadInt64ArrayBuffer start");
1056 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
1057 if (!rpc) {
1058 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
1059 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
1060 return OHOS::CJLongArray { 0 };
1061 }
1062 std::vector<int64_t> vector = rpc->CJ_ReadInt64ArrayBuffer(errCode);
1063 size_t bufferSize = vector.size();
1064 if (bufferSize <= 0) {
1065 return OHOS::CJLongArray { 0 };
1066 }
1067 int64_t* arr = static_cast<int64_t*>(malloc(sizeof(int64_t) * bufferSize));
1068 if (arr == nullptr) {
1069 ZLOGE(LOG_LABEL, "[RPC] create arrayBuffer failed.");
1070 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
1071 return OHOS::CJLongArray { 0 };
1072 }
1073 errno_t ret = memcpy_s(arr, bufferSize * BYTE_SIZE_64, vector.data(), bufferSize * BYTE_SIZE_64);
1074 if (ret != EOK) {
1075 free(arr);
1076 ZLOGE(LOG_LABEL, "[RPC] memcpy_s is failed.");
1077 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
1078 return OHOS::CJLongArray { 0 };
1079 }
1080 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadInt64ArrayBuffer end");
1081 return OHOS::CJLongArray { .data = arr, .len = static_cast<uint32_t>(bufferSize) };
1082 }
1083
FfiRpcMessageSequenceImplReadUInt64ArrayBuffer(int64_t id,int32_t * errCode)1084 OHOS::CJUInt64Array FfiRpcMessageSequenceImplReadUInt64ArrayBuffer(int64_t id, int32_t* errCode)
1085 {
1086 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadUInt64ArrayBuffer start");
1087 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
1088 if (!rpc) {
1089 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
1090 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
1091 return OHOS::CJUInt64Array { 0 };
1092 }
1093 std::vector<uint64_t> vector = rpc->CJ_ReadUInt64ArrayBuffer(errCode);
1094 size_t bufferSize = vector.size();
1095 if (bufferSize <= 0) {
1096 return OHOS::CJUInt64Array { 0 };
1097 }
1098 uint64_t* arr = static_cast<uint64_t*>(malloc(sizeof(uint64_t) * bufferSize));
1099 if (arr == nullptr) {
1100 ZLOGE(LOG_LABEL, "[RPC] create arrayBuffer failed.");
1101 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
1102 return OHOS::CJUInt64Array { 0 };
1103 }
1104 errno_t ret = memcpy_s(arr, bufferSize * BYTE_SIZE_64, vector.data(), bufferSize * BYTE_SIZE_64);
1105 if (ret != EOK) {
1106 free(arr);
1107 ZLOGE(LOG_LABEL, "[RPC] memcpy_s is failed.");
1108 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
1109 return OHOS::CJUInt64Array { 0 };
1110 }
1111 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadUInt64ArrayBuffer end");
1112 return OHOS::CJUInt64Array { .data = arr, .len = static_cast<uint32_t>(bufferSize) };
1113 }
1114
FfiRpcMessageSequenceImplReadRawDataBuffer(int64_t id,int64_t size,int32_t * errCode)1115 uint8_t* FfiRpcMessageSequenceImplReadRawDataBuffer(int64_t id, int64_t size, int32_t* errCode)
1116 {
1117 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadRawDataBuffer start");
1118 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
1119 if (!rpc) {
1120 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
1121 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
1122 return nullptr;
1123 }
1124 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadRawDataBuffer end");
1125 return rpc->CJ_ReadRawDataBuffer(size, errCode);
1126 }
1127
1128
FfiRpcMessageSequenceImplReadRemoteObject(int64_t id,int32_t * errCode)1129 RetDataI64 FfiRpcMessageSequenceImplReadRemoteObject(int64_t id, int32_t* errCode)
1130 {
1131 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadRemoteObject start");
1132 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
1133 if (!rpc) {
1134 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
1135 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
1136 return RetDataI64 { 0, 0 };
1137 }
1138 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadRemoteObject end");
1139 return rpc->CJ_ReadRemoteObject(errCode);
1140 }
1141
FfiRpcMessageSequenceImplReadRemoteObjectArray(int64_t id,int32_t * errCode)1142 OHOS::RemoteObjectArray FfiRpcMessageSequenceImplReadRemoteObjectArray(int64_t id, int32_t* errCode)
1143 {
1144 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadRemoteObjectArray start");
1145 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
1146 if (!rpc) {
1147 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
1148 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
1149 return OHOS::RemoteObjectArray { nullptr, nullptr, 0 };
1150 }
1151 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadRemoteObjectArray end");
1152 return rpc->CJ_ReadRemoteObjectArray(errCode);
1153 }
1154
FfiRpcMessageSequenceImplCloseFileDescriptor(int32_t fd)1155 void FfiRpcMessageSequenceImplCloseFileDescriptor(int32_t fd)
1156 {
1157 return MessageSequenceImpl::CJ_CloseFileDescriptor(fd);
1158 }
1159
FfiRpcMessageSequenceImplDupFileDescriptor(int32_t fd)1160 int32_t FfiRpcMessageSequenceImplDupFileDescriptor(int32_t fd)
1161 {
1162 return MessageSequenceImpl::CJ_DupFileDescriptor(fd);
1163 }
1164
FfiRpcMessageSequenceImplContainFileDescriptors(int64_t id,int32_t * errCode)1165 bool FfiRpcMessageSequenceImplContainFileDescriptors(int64_t id, int32_t* errCode)
1166 {
1167 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplContainFileDescriptors start");
1168 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
1169 if (!rpc) {
1170 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
1171 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
1172 return false;
1173 }
1174 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplContainFileDescriptors end");
1175 return rpc->CJ_ContainFileDescriptors(errCode);
1176 }
1177
FfiRpcMessageSequenceImplWriteFileDescriptor(int64_t id,int32_t fd,int32_t * errCode)1178 void FfiRpcMessageSequenceImplWriteFileDescriptor(int64_t id, int32_t fd, int32_t* errCode)
1179 {
1180 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplWriteFileDescriptor start");
1181 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
1182 if (!rpc) {
1183 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
1184 *errCode = errorDesc::WRITE_DATA_TO_MESSAGE_SEQUENCE_ERROR;
1185 return;
1186 }
1187 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplWriteFileDescriptor end");
1188 *errCode = rpc->CJ_WriteFileDescriptor(fd);
1189 }
1190
FfiRpcMessageSequenceImplReadFileDescriptor(int64_t id,int32_t * errCode)1191 int32_t FfiRpcMessageSequenceImplReadFileDescriptor(int64_t id, int32_t* errCode)
1192 {
1193 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadFileDescriptor start");
1194 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
1195 if (!rpc) {
1196 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
1197 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
1198 return 0;
1199 }
1200 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadFileDescriptor end");
1201 return rpc->CJ_ReadFileDescriptor(errCode);
1202 }
1203
FfiRpcMessageSequenceImplWriteAshmem(int64_t mid,int64_t aid,int32_t * errCode)1204 void FfiRpcMessageSequenceImplWriteAshmem(int64_t mid, int64_t aid, int32_t* errCode)
1205 {
1206 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplWriteAshmem start");
1207 auto rpc = FFIData::GetData<MessageSequenceImpl>(mid);
1208 if (!rpc) {
1209 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
1210 *errCode = errorDesc::WRITE_DATA_TO_MESSAGE_SEQUENCE_ERROR;
1211 return;
1212 }
1213 auto ashmem = FFIData::GetData<AshmemImpl>(aid);
1214 if (!ashmem || ashmem->GetAshmem() == nullptr) {
1215 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
1216 *errCode = errorDesc::WRITE_DATA_TO_MESSAGE_SEQUENCE_ERROR;
1217 return;
1218 }
1219 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplWriteAshmem end");
1220 *errCode = rpc->CJ_WriteAshmem(ashmem->GetAshmem());
1221 }
1222
FfiRpcMessageSequenceImplReadAshmem(int64_t id,int32_t * errCode)1223 int64_t FfiRpcMessageSequenceImplReadAshmem(int64_t id, int32_t* errCode)
1224 {
1225 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadAshmem start");
1226 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
1227 if (!rpc) {
1228 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
1229 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
1230 return -1;
1231 }
1232 sptr<Ashmem> nativeAshmem = rpc->CJ_ReadAshmem(errCode);
1233 if (*errCode != 0) {
1234 return -1;
1235 }
1236 auto ashmem = FFIData::Create<AshmemImpl>(nativeAshmem);
1237 if (!ashmem) {
1238 ZLOGE(LOG_LABEL, "[RPC] failed to construct cj Ashmem");
1239 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
1240 return -1;
1241 }
1242 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplReadAshmem end");
1243 return ashmem->GetID();
1244 }
1245
FfiRpcMessageSequenceImplGetRawDataCapacity(int64_t id,int32_t * errCode)1246 uint32_t FfiRpcMessageSequenceImplGetRawDataCapacity(int64_t id, int32_t* errCode)
1247 {
1248 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplGetRawDataCapacity start");
1249 auto rpc = FFIData::GetData<MessageSequenceImpl>(id);
1250 if (!rpc) {
1251 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
1252 *errCode = errorDesc::READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR;
1253 return 0;
1254 }
1255 ZLOGD(LOG_LABEL, "[RPC] FfiRpcMessageSequenceImplGetRawDataCapacity end");
1256 return rpc->CJ_GetRawDataCapacity(errCode);
1257 }
1258
FfiRpcAshmemImplCreate(char * ashmemName,int32_t ashmemSize)1259 int64_t FfiRpcAshmemImplCreate(char* ashmemName, int32_t ashmemSize)
1260 {
1261 ZLOGD(LOG_LABEL, "[RPC] FfiRpcAshmemImplCreate start");
1262 sptr<Ashmem> nativeAshmem = Ashmem::CreateAshmem(ashmemName, ashmemSize);
1263 if (nativeAshmem == nullptr) {
1264 ZLOGE(LOG_LABEL, "[RPC] instance not exist.");
1265 return -1;
1266 }
1267 auto ashmem = FFIData::Create<AshmemImpl>(nativeAshmem);
1268 if (!ashmem) {
1269 ZLOGE(LOG_LABEL, "[RPC] FfiRpcAshmemImplCreate failed");
1270 return -1;
1271 }
1272 ZLOGD(LOG_LABEL, "[RPC] FfiRpcAshmemImplCreate end");
1273 return ashmem->GetID();
1274 }
1275
FfiRpcAshmemImplCreateFromExisting(int64_t id,int32_t * errCode)1276 int64_t FfiRpcAshmemImplCreateFromExisting(int64_t id, int32_t* errCode)
1277 {
1278 ZLOGD(LOG_LABEL, "[RPC] FfiRpcAshmemImplCreateFromExisting start");
1279 auto nativeAshmem = FFIData::GetData<AshmemImpl>(id);
1280 if (!nativeAshmem) {
1281 ZLOGE(LOG_LABEL, "[RPC] FfiRpcAshmemImplCreateFromExisting failed");
1282 *errCode = errorDesc::CHECK_PARAM_ERROR;
1283 return -1;
1284 }
1285 int32_t fd = nativeAshmem->GetAshmem()->GetAshmemFd();
1286 int32_t size = nativeAshmem->GetAshmem()->GetAshmemSize();
1287 if (fd <= 0 || size <= 0) {
1288 ZLOGE(LOG_LABEL, "[RPC] fd <= 0 or size <= 0");
1289 *errCode = errorDesc::CHECK_PARAM_ERROR;
1290 return -1;
1291 }
1292 int dupFd = dup(fd);
1293 if (dupFd < 0) {
1294 ZLOGE(LOG_LABEL, "[RPC] failed to dup fd");
1295 *errCode = errorDesc::CHECK_PARAM_ERROR;
1296 return -1;
1297 }
1298 sptr<Ashmem> newAshmem(new Ashmem(dupFd, size));
1299 if (newAshmem == nullptr) {
1300 close(dupFd);
1301 ZLOGE(LOG_LABEL, "[RPC] failed to new Ashmem");
1302 *errCode = errorDesc::CHECK_PARAM_ERROR;
1303 return -1;
1304 }
1305 auto ashmem = FFIData::Create<AshmemImpl>(newAshmem);
1306 if (!ashmem) {
1307 ZLOGE(LOG_LABEL, "[RPC] FfiRpcAshmemImplCreateFromExisting failed");
1308 *errCode = errorDesc::CHECK_PARAM_ERROR;
1309 return -1;
1310 }
1311 ZLOGD(LOG_LABEL, "[RPC] FfiRpcAshmemImplCreateFromExisting end");
1312 return ashmem->GetID();
1313 }
1314
FfiRpcAshmemImplCloseAshmem(int64_t id)1315 void FfiRpcAshmemImplCloseAshmem(int64_t id)
1316 {
1317 ZLOGD(LOG_LABEL, "[RPC] FfiRpcAshmemImplCloseAshmem start");
1318 auto nativeAshmem = FFIData::GetData<AshmemImpl>(id);
1319 if (!nativeAshmem) {
1320 ZLOGE(LOG_LABEL, "[RPC] FfiRpcAshmemImplCloseAshmem failed");
1321 return;
1322 }
1323 nativeAshmem->CloseAshmem();
1324 ZLOGD(LOG_LABEL, "[RPC] FfiRpcAshmemImplCloseAshmem end");
1325 }
1326
FfiRpcAshmemImplUnmapAshmem(int64_t id)1327 void FfiRpcAshmemImplUnmapAshmem(int64_t id)
1328 {
1329 ZLOGD(LOG_LABEL, "[RPC] FfiRpcAshmemImplUnmapAshmem start");
1330 auto nativeAshmem = FFIData::GetData<AshmemImpl>(id);
1331 if (!nativeAshmem) {
1332 ZLOGE(LOG_LABEL, "[RPC] FfiRpcAshmemImplUnmapAshmem failed");
1333 return;
1334 }
1335 nativeAshmem->UnmapAshmem();
1336 ZLOGD(LOG_LABEL, "[RPC] FfiRpcAshmemImplUnmapAshmem end");
1337 }
1338
FfiRpcAshmemImplGetAshmemSize(int64_t id,int32_t * errCode)1339 int32_t FfiRpcAshmemImplGetAshmemSize(int64_t id, int32_t* errCode)
1340 {
1341 ZLOGD(LOG_LABEL, "[RPC] FfiRpcAshmemImplGetAshmemSize start");
1342 auto nativeAshmem = FFIData::GetData<AshmemImpl>(id);
1343 if (!nativeAshmem) {
1344 ZLOGE(LOG_LABEL, "[RPC] FfiRpcAshmemImplGetAshmemSize failed");
1345 *errCode = errorDesc::CHECK_PARAM_ERROR;
1346 return 0;
1347 }
1348 ZLOGD(LOG_LABEL, "[RPC] FfiRpcAshmemImplGetAshmemSize end");
1349 return nativeAshmem->GetAshmemSize(errCode);
1350 }
1351
FfiRpcAshmemImplMapTypedAshmem(int64_t id,uint32_t mapType,int32_t * errCode)1352 void FfiRpcAshmemImplMapTypedAshmem(int64_t id, uint32_t mapType, int32_t* errCode)
1353 {
1354 ZLOGD(LOG_LABEL, "[RPC] FfiRpcAshmemImplMapTypedAshmem start");
1355 auto nativeAshmem = FFIData::GetData<AshmemImpl>(id);
1356 if (!nativeAshmem) {
1357 ZLOGE(LOG_LABEL, "[RPC] FfiRpcAshmemImplMapTypedAshmem failed");
1358 *errCode = errorDesc::OS_MMAP_ERROR;
1359 return;
1360 }
1361 ZLOGD(LOG_LABEL, "[RPC] FfiRpcAshmemImplMapTypedAshmem end");
1362 *errCode = nativeAshmem->MapTypedAshmem(mapType);
1363 }
1364
FfiRpcAshmemImplMapReadWriteAshmem(int64_t id,int32_t * errCode)1365 void FfiRpcAshmemImplMapReadWriteAshmem(int64_t id, int32_t* errCode)
1366 {
1367 ZLOGD(LOG_LABEL, "[RPC] FfiRpcAshmemImplMapReadWriteAshmem start");
1368 auto nativeAshmem = FFIData::GetData<AshmemImpl>(id);
1369 if (!nativeAshmem) {
1370 ZLOGE(LOG_LABEL, "[RPC] FfiRpcAshmemImplMapReadWriteAshmem failed");
1371 *errCode = errorDesc::OS_MMAP_ERROR;
1372 return;
1373 }
1374 ZLOGD(LOG_LABEL, "[RPC] FfiRpcAshmemImplMapReadWriteAshmem end");
1375 *errCode = nativeAshmem->MapReadWriteAshmem();
1376 }
1377
FfiRpcAshmemImplMapReadonlyAshmem(int64_t id,int32_t * errCode)1378 void FfiRpcAshmemImplMapReadonlyAshmem(int64_t id, int32_t* errCode)
1379 {
1380 ZLOGD(LOG_LABEL, "[RPC] FfiRpcAshmemImplMapReadonlyAshmem start");
1381 auto nativeAshmem = FFIData::GetData<AshmemImpl>(id);
1382 if (!nativeAshmem) {
1383 ZLOGE(LOG_LABEL, "[RPC] FfiRpcAshmemImplMapReadonlyAshmem failed");
1384 *errCode = errorDesc::OS_MMAP_ERROR;
1385 return;
1386 }
1387 ZLOGD(LOG_LABEL, "[RPC] FfiRpcAshmemImplMapReadonlyAshmem end");
1388 *errCode = nativeAshmem->MapReadonlyAshmem();
1389 }
1390
FfiRpcAshmemImplSetProtectionType(int64_t id,uint32_t protectionType,int32_t * errCode)1391 void FfiRpcAshmemImplSetProtectionType(int64_t id, uint32_t protectionType, int32_t* errCode)
1392 {
1393 ZLOGD(LOG_LABEL, "[RPC] FfiRpcAshmemImplSetProtectionType start");
1394 auto nativeAshmem = FFIData::GetData<AshmemImpl>(id);
1395 if (!nativeAshmem) {
1396 ZLOGE(LOG_LABEL, "[RPC] FfiRpcAshmemImplSetProtectionType failed");
1397 *errCode = errorDesc::OS_IOCTL_ERROR;
1398 return;
1399 }
1400 ZLOGD(LOG_LABEL, "[RPC] FfiRpcAshmemImplSetProtectionType end");
1401 *errCode = nativeAshmem->SetProtectionType(protectionType);
1402 }
1403
FfiRpcAshmemImplWriteDataToAshmem(int64_t id,uint8_t * data,int64_t size,int64_t offset,int32_t * errCode)1404 void FfiRpcAshmemImplWriteDataToAshmem(int64_t id, uint8_t* data, int64_t size, int64_t offset, int32_t* errCode)
1405 {
1406 ZLOGD(LOG_LABEL, "[RPC] FfiRpcAshmemImplWriteDataToAshmem start");
1407 auto nativeAshmem = FFIData::GetData<AshmemImpl>(id);
1408 if (!nativeAshmem) {
1409 ZLOGE(LOG_LABEL, "[RPC] FfiRpcAshmemImplWriteDataToAshmem failed");
1410 *errCode = errorDesc::WRITE_TO_ASHMEM_ERROR;
1411 return;
1412 }
1413 ZLOGD(LOG_LABEL, "[RPC] FfiRpcAshmemImplWriteDataToAshmem end");
1414 *errCode = nativeAshmem->WriteDataToAshmem(data, size, offset);
1415 }
1416
FfiRpcAshmemImplReadDataFromAshmem(int64_t id,int64_t size,int64_t offset,int32_t * errCode)1417 uint8_t* FfiRpcAshmemImplReadDataFromAshmem(int64_t id, int64_t size, int64_t offset, int32_t* errCode)
1418 {
1419 ZLOGD(LOG_LABEL, "[RPC] FfiRpcAshmemImplReadDataFromAshmem start");
1420 auto nativeAshmem = FFIData::GetData<AshmemImpl>(id);
1421 if (!nativeAshmem) {
1422 ZLOGE(LOG_LABEL, "[RPC] FfiRpcAshmemImplReadDataFromAshmem failed");
1423 *errCode = errorDesc::READ_FROM_ASHMEM_ERROR;
1424 return nullptr;
1425 }
1426 ZLOGD(LOG_LABEL, "[RPC] FfiRpcAshmemImplReadDataFromAshmem end");
1427 return nativeAshmem->ReadDataFromAshmem(size, offset, errCode);
1428 }
1429
FfiRpcRemoteObjectConstructor(char * stringValue)1430 int64_t FfiRpcRemoteObjectConstructor(char* stringValue)
1431 {
1432 ZLOGD(LOG_LABEL, "[RPC] FfiRpcRemoteObjectConstructor start");
1433 if (strlen(stringValue) >= MAX_BYTES_LENGTH) {
1434 ZLOGE(LOG_LABEL, "string length too large");
1435 return -1;
1436 }
1437 std::string descriptor = stringValue;
1438 RemoteObjectHolderImpl* holder = new (std::nothrow) RemoteObjectHolderImpl(Str8ToStr16(descriptor));
1439 if (holder == nullptr) {
1440 ZLOGE(LOG_LABEL, "new RemoteObjectHolderImpl failed");
1441 return -1;
1442 }
1443 auto remoteObject = FFIData::Create<CjRemoteObjectImpl>(holder);
1444 if (!remoteObject) {
1445 delete holder;
1446 ZLOGE(LOG_LABEL, "[RPC] FfiRpcRemoteObjectConstructor failed");
1447 return -1;
1448 }
1449 ZLOGD(LOG_LABEL, "[RPC] FfiRpcRemoteObjectConstructor end");
1450 return remoteObject->GetID();
1451 }
1452
FfiRpcRemoteObjectSendMessageRequest(int64_t id,uint32_t code,int64_t dataId,int64_t replyId,MesOption opt,int64_t funcId)1453 int32_t FfiRpcRemoteObjectSendMessageRequest(
1454 int64_t id, uint32_t code, int64_t dataId, int64_t replyId, MesOption opt, int64_t funcId)
1455 {
1456 ZLOGD(LOG_LABEL, "[RPC] FfiRpcRemoteObjectSendMessageRequest start");
1457 auto remoteObject = FFIData::GetData<CjRemoteObjectImpl>(id);
1458 if (!remoteObject) {
1459 ZLOGE(LOG_LABEL, "[RPC] FfiRpcRemoteObjectSendMessageRequest failed");
1460 return errorDesc::PROXY_OR_REMOTE_OBJECT_INVALID_ERROR;
1461 }
1462 MessageOption option = MessageOption(opt.flags, opt.waitTime);
1463 ZLOGD(LOG_LABEL, "[RPC] FfiRpcRemoteObjectSendMessageRequest end");
1464 return remoteObject->SendMessageRequest(code, dataId, replyId, option, funcId);
1465 }
1466
FfiRpcRemoteObjectGetCallingPid()1467 int32_t FfiRpcRemoteObjectGetCallingPid()
1468 {
1469 return GetCallingPid();
1470 }
1471
FfiRpcRemoteObjectGetCallingUid()1472 int32_t FfiRpcRemoteObjectGetCallingUid()
1473 {
1474 return GetCallingUid();
1475 }
1476
FfiRpcRemoteObjectGetDescriptor(int64_t id,int32_t * errCode)1477 char* FfiRpcRemoteObjectGetDescriptor(int64_t id, int32_t* errCode)
1478 {
1479 ZLOGD(LOG_LABEL, "[RPC] FfiRpcRemoteObjectGetDescriptor start");
1480 auto remoteObject = FFIData::GetData<CjRemoteObjectImpl>(id);
1481 if (!remoteObject) {
1482 ZLOGE(LOG_LABEL, "[RPC] FfiRpcRemoteObjectGetDescriptor failed");
1483 *errCode = errorDesc::PROXY_OR_REMOTE_OBJECT_INVALID_ERROR;
1484 return nullptr;
1485 }
1486 ZLOGD(LOG_LABEL, "[RPC] FfiRpcRemoteObjectGetDescriptor end");
1487 return remoteObject->GetDescriptor(errCode);
1488 }
1489
FfiRpcRemoteObjectModifyLocalInterface(int64_t id,char * stringValue,int32_t * errCode)1490 void FfiRpcRemoteObjectModifyLocalInterface(int64_t id, char* stringValue, int32_t* errCode)
1491 {
1492 ZLOGD(LOG_LABEL, "[RPC] FfiRpcRemoteObjectModifyLocalInterface start");
1493 auto remoteObject = FFIData::GetData<CjRemoteObjectImpl>(id);
1494 if (!remoteObject) {
1495 ZLOGE(LOG_LABEL, "[RPC] FfiRpcRemoteObjectModifyLocalInterface failed");
1496 *errCode = errorDesc::PROXY_OR_REMOTE_OBJECT_INVALID_ERROR;
1497 return;
1498 }
1499 ZLOGD(LOG_LABEL, "[RPC] FfiRpcRemoteObjectModifyLocalInterface end");
1500 *errCode = remoteObject->ModifyLocalInterface(stringValue);
1501 }
1502
FfiRpcIPCSkeletonGetContextObject()1503 RetDataI64 FfiRpcIPCSkeletonGetContextObject()
1504 {
1505 return GetContextObject();
1506 }
1507
FfiRpcIPCSkeletonGetCallingPid()1508 int32_t FfiRpcIPCSkeletonGetCallingPid()
1509 {
1510 return GetCallingPid();
1511 }
1512
FfiRpcIPCSkeletonGetCallingUid()1513 int32_t FfiRpcIPCSkeletonGetCallingUid()
1514 {
1515 return GetCallingUid();
1516 }
1517
FfiRpcIPCSkeletonGetCallingTokenId()1518 uint32_t FfiRpcIPCSkeletonGetCallingTokenId()
1519 {
1520 return GetCallingTokenId();
1521 }
1522
FfiRpcIPCSkeletonGetCallingDeviceID()1523 char* FfiRpcIPCSkeletonGetCallingDeviceID()
1524 {
1525 return GetCallingDeviceID();
1526 }
1527
FfiRpcIPCSkeletonGetLocalDeviceID()1528 char* FfiRpcIPCSkeletonGetLocalDeviceID()
1529 {
1530 return GetLocalDeviceID();
1531 }
1532
FfiRpcIPCSkeletonIsLocalCalling()1533 bool FfiRpcIPCSkeletonIsLocalCalling()
1534 {
1535 return IsLocalCalling();
1536 }
1537
FfiRpcIPCSkeletonFlushCmdBuffer(int64_t object)1538 void FfiRpcIPCSkeletonFlushCmdBuffer(int64_t object)
1539 {
1540 FlushCmdBuffer(object);
1541 }
1542
FfiRpcRemoteProxySendMessageRequest(int64_t id,uint32_t code,int64_t dataId,int64_t replyId,MesOption opt,int64_t funcId)1543 int32_t FfiRpcRemoteProxySendMessageRequest(
1544 int64_t id, uint32_t code, int64_t dataId, int64_t replyId, MesOption opt, int64_t funcId)
1545 {
1546 ZLOGD(LOG_LABEL, "[RPC] FfiRpcRemoteProxySendMessageRequest start");
1547 auto remoteProxy = FFIData::GetData<RemoteProxyHolderImpl>(id);
1548 if (!remoteProxy) {
1549 ZLOGE(LOG_LABEL, "[RPC] FfiRpcRemoteProxySendMessageRequest failed");
1550 return errorDesc::PROXY_OR_REMOTE_OBJECT_INVALID_ERROR;
1551 }
1552 MessageOption option = MessageOption(opt.flags, opt.waitTime);
1553 ZLOGD(LOG_LABEL, "[RPC] FfiRpcRemoteProxySendMessageRequest end");
1554 return remoteProxy->SendMessageRequest(code, dataId, replyId, option, funcId);
1555 }
1556
FfiRpcRemoteProxyRegisterDeathRecipient(int64_t id,int64_t funcId,int32_t flag,int32_t * errCode)1557 void FfiRpcRemoteProxyRegisterDeathRecipient(int64_t id, int64_t funcId, int32_t flag, int32_t* errCode)
1558 {
1559 ZLOGD(LOG_LABEL, "[RPC] FfiRpcRemoteProxyRegisterDeathRecipient start");
1560 auto remoteProxy = FFIData::GetData<RemoteProxyHolderImpl>(id);
1561 if (!remoteProxy) {
1562 ZLOGE(LOG_LABEL, "[RPC] FfiRpcRemoteProxyRegisterDeathRecipient failed");
1563 *errCode = errorDesc::PROXY_OR_REMOTE_OBJECT_INVALID_ERROR;
1564 return;
1565 }
1566 ZLOGD(LOG_LABEL, "[RPC] FfiRpcRemoteProxyRegisterDeathRecipient end");
1567 *errCode = remoteProxy->RegisterDeathRecipient(funcId, flag);
1568 }
1569
FfiRpcRemoteProxyUnregisterDeathRecipient(int64_t id,int64_t funcId,int32_t flag,int32_t * errCode)1570 void FfiRpcRemoteProxyUnregisterDeathRecipient(int64_t id, int64_t funcId, int32_t flag, int32_t* errCode)
1571 {
1572 ZLOGD(LOG_LABEL, "[RPC] FfiRpcRemoteProxyUnregisterDeathRecipient start");
1573 auto remoteProxy = FFIData::GetData<RemoteProxyHolderImpl>(id);
1574 if (!remoteProxy) {
1575 ZLOGE(LOG_LABEL, "[RPC] FfiRpcRemoteProxyUnregisterDeathRecipient failed");
1576 *errCode = errorDesc::PROXY_OR_REMOTE_OBJECT_INVALID_ERROR;
1577 return;
1578 }
1579 ZLOGD(LOG_LABEL, "[RPC] FfiRpcRemoteProxyUnregisterDeathRecipient end");
1580 *errCode = remoteProxy->UnregisterDeathRecipient(funcId, flag);
1581 }
1582
FfiRpcRemoteProxyGetDescriptor(int64_t id,int32_t * errCode)1583 char* FfiRpcRemoteProxyGetDescriptor(int64_t id, int32_t* errCode)
1584 {
1585 ZLOGD(LOG_LABEL, "[RPC] FfiRpcRemoteProxyGetDescriptor start");
1586 auto remoteProxy = FFIData::GetData<RemoteProxyHolderImpl>(id);
1587 if (!remoteProxy) {
1588 ZLOGE(LOG_LABEL, "[RPC] FfiRpcRemoteProxyGetDescriptor failed");
1589 *errCode = errorDesc::PROXY_OR_REMOTE_OBJECT_INVALID_ERROR;
1590 return nullptr;
1591 }
1592 ZLOGD(LOG_LABEL, "[RPC] FfiRpcRemoteProxyGetDescriptor end");
1593 return remoteProxy->GetDescriptor(errCode);
1594 }
1595
FfiRpcRemoteProxyIsObjectDead(int64_t id)1596 bool FfiRpcRemoteProxyIsObjectDead(int64_t id)
1597 {
1598 ZLOGD(LOG_LABEL, "[RPC] FfiRpcRemoteProxyIsObjectDead start");
1599 auto remoteProxy = FFIData::GetData<RemoteProxyHolderImpl>(id);
1600 if (!remoteProxy) {
1601 ZLOGE(LOG_LABEL, "[RPC] FfiRpcRemoteProxyIsObjectDead failed");
1602 return false;
1603 }
1604 ZLOGD(LOG_LABEL, "[RPC] FfiRpcRemoteProxyIsObjectDead end");
1605 return remoteProxy->IsObjectDead();
1606 }
1607
FfiRpcGetRemoteType(int64_t id)1608 int32_t FfiRpcGetRemoteType(int64_t id)
1609 {
1610 auto remoteObject = FFIData::GetData<CjIRemoteObjectImpl>(id);
1611 if (!remoteObject) {
1612 ZLOGE(LOG_LABEL, "[RPC] get construct failed");
1613 return INVALID_REMOTE_TYPE;
1614 }
1615 return remoteObject->IsProxyObject() ? REMOTE_PROXY : REMOTE_OBJECT;
1616 }
1617
GetRemoteProxyHolder(napi_env env,napi_value jsRemoteProxy)1618 NAPIRemoteProxyHolder *GetRemoteProxyHolder(napi_env env, napi_value jsRemoteProxy)
1619 {
1620 NAPIRemoteProxyHolder *proxyHolder = nullptr;
1621 napi_unwrap(env, jsRemoteProxy, (void **)&proxyHolder);
1622 NAPI_ASSERT(env, proxyHolder != nullptr, "failed to get napi remote proxy holder");
1623 return proxyHolder;
1624 }
1625
FfiCreateRemoteObjectFromNapi(napi_env env,napi_value object)1626 int64_t FfiCreateRemoteObjectFromNapi(napi_env env, napi_value object)
1627 {
1628 if (env != nullptr || object != nullptr) {
1629 napi_value global = nullptr;
1630 napi_status status = napi_get_global(env, &global);
1631 if (status != napi_ok) {
1632 ZLOGE(LOG_LABEL, "get napi global failed");
1633 return 0;
1634 }
1635 napi_value stubConstructor = nullptr;
1636 status = napi_get_named_property(env, global, "IPCStubConstructor_", &stubConstructor);
1637 if (status != napi_ok) {
1638 ZLOGE(LOG_LABEL, "get stub constructor failed");
1639 return 0;
1640 }
1641 bool instanceOfStub = false;
1642 status = napi_instanceof(env, object, stubConstructor, &instanceOfStub);
1643 if (status != napi_ok) {
1644 ZLOGE(LOG_LABEL, "failed to check js object type");
1645 return 0;
1646 }
1647 if (instanceOfStub) {
1648 NAPIRemoteObjectHolder *holder = nullptr;
1649 napi_unwrap(env, object, (void **)&holder);
1650 if (holder == nullptr) {
1651 ZLOGE(LOG_LABEL, "failed to get napi remote object holder");
1652 return 0;
1653 }
1654 return CreateStubRemoteObject(holder->Get());
1655 }
1656
1657 napi_value proxyConstructor = nullptr;
1658 status = napi_get_named_property(env, global, "IPCProxyConstructor_", &proxyConstructor);
1659 if (status != napi_ok) {
1660 ZLOGE(LOG_LABEL, "get proxy constructor failed");
1661 return 0;
1662 }
1663 bool instanceOfProxy = false;
1664 status = napi_instanceof(env, object, proxyConstructor, &instanceOfProxy);
1665 if (status != napi_ok) {
1666 ZLOGE(LOG_LABEL, "failed to check js object type");
1667 return 0;
1668 }
1669 if (instanceOfProxy) {
1670 NAPIRemoteProxyHolder *proxyHolder = GetRemoteProxyHolder(env, object);
1671 if (proxyHolder != nullptr) {
1672 return CreateProxyRemoteObject(proxyHolder->object_);
1673 }
1674 }
1675 }
1676 return 0;
1677 }
1678
CreateJsProxyRemoteObject(napi_env env,const sptr<IRemoteObject> target)1679 napi_value CreateJsProxyRemoteObject(napi_env env, const sptr<IRemoteObject> target)
1680 {
1681 napi_value global = nullptr;
1682 napi_status status = napi_get_global(env, &global);
1683 NAPI_ASSERT(env, status == napi_ok, "get napi global failed");
1684 napi_value constructor = nullptr;
1685 status = napi_get_named_property(env, global, "IPCProxyConstructor_", &constructor);
1686 NAPI_ASSERT(env, status == napi_ok, "get proxy constructor failed");
1687 napi_value jsRemoteProxy;
1688 status = napi_new_instance(env, constructor, 0, nullptr, &jsRemoteProxy);
1689 NAPI_ASSERT(env, status == napi_ok, "failed to construct js RemoteProxy");
1690 NAPIRemoteProxyHolder *proxyHolder = NAPI_ohos_rpc_getRemoteProxyHolder(env, jsRemoteProxy);
1691 if (proxyHolder == nullptr) {
1692 ZLOGE(LOG_LABEL, "proxyHolder null");
1693 return nullptr;
1694 }
1695 proxyHolder->object_ = target;
1696 proxyHolder->list_ = new (std::nothrow) NAPIDeathRecipientList();
1697 NAPI_ASSERT(env, proxyHolder->list_ != nullptr, "new NAPIDeathRecipientList failed");
1698
1699 return jsRemoteProxy;
1700 }
1701
CreateJsStubRemoteObject(napi_env env,const sptr<IRemoteObject> target)1702 napi_value CreateJsStubRemoteObject(napi_env env, const sptr<IRemoteObject> target)
1703 {
1704 // retrieve js remote object constructor
1705 napi_value global = nullptr;
1706 napi_status status = napi_get_global(env, &global);
1707 NAPI_ASSERT(env, status == napi_ok, "get napi global failed");
1708 napi_value constructor = nullptr;
1709 status = napi_get_named_property(env, global, "IPCStubConstructor_", &constructor);
1710 NAPI_ASSERT(env, status == napi_ok, "set stub constructor failed");
1711 NAPI_ASSERT(env, constructor != nullptr, "failed to get js RemoteObject constructor");
1712 // retrieve descriptor and it's length
1713 std::u16string descriptor = target->GetObjectDescriptor();
1714 std::string desc = Str16ToStr8(descriptor);
1715 napi_value jsDesc = nullptr;
1716 napi_create_string_utf8(env, desc.c_str(), desc.length(), &jsDesc);
1717 // create a new js remote object
1718 size_t argc = 1;
1719 napi_value argv[ARGV_LENGTH_1] = { jsDesc };
1720 napi_value jsRemoteObject = nullptr;
1721 status = napi_new_instance(env, constructor, argc, argv, &jsRemoteObject);
1722 NAPI_ASSERT(env, status == napi_ok, "failed to construct js RemoteObject");
1723 // retrieve holder and set object
1724 NAPIRemoteObjectHolder *holder = nullptr;
1725 napi_unwrap(env, jsRemoteObject, (void **)&holder);
1726 NAPI_ASSERT(env, holder != nullptr, "failed to get napi remote object holder");
1727 holder->Set(target);
1728 return jsRemoteObject;
1729 }
1730
FfiConvertRemoteObject2Napi(napi_env env,int64_t object)1731 napi_value FfiConvertRemoteObject2Napi(napi_env env, int64_t object)
1732 {
1733 sptr<IRemoteObject> target = CJ_rpc_getNativeRemoteObject(object);
1734 if (target == nullptr) {
1735 return nullptr;
1736 }
1737 if (!target->IsProxyObject()) {
1738 IPCObjectStub *tmp = static_cast<IPCObjectStub *>(target.GetRefPtr());
1739 uint32_t objectType = static_cast<uint32_t>(tmp->GetObjectType());
1740 ZLOGD(LOG_LABEL, "create js object, type:%{public}d", objectType);
1741 if (objectType == IPCObjectStub::OBJECT_TYPE_JAVASCRIPT || objectType == IPCObjectStub::OBJECT_TYPE_NATIVE) {
1742 return CreateJsStubRemoteObject(env, target);
1743 }
1744 }
1745
1746 return CreateJsProxyRemoteObject(env, target);
1747 }
1748 }
1749 } // namespace OHOS