1# @ohos.rpc (RPC通信) 2 3本模块提供进程间通信能力，包括设备内的进程间通信（IPC）和设备间的进程间通信（RPC），前者基于Binder驱动，后者基于软总线驱动。 4 5> **说明：** 6> 7> - 本模块首批接口从API version 7开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。 8> 9> - 本模块从API version 9开始支持异常返回功能。 10 11## 导入模块 12 13``` 14import rpc from '@ohos.rpc'; 15``` 16 17## ErrorCode<sup>9+</sup> 18 19从API version 9起，IPC支持异常返回功能。错误码对应数值及含义如下。 20 21**系统能力**：SystemCapability.Communication.IPC.Core 22 23 | 名称 | 值 | 说明 | 24 | ------------------------------------- | ------- | --------------------------------------------- | 25 | CHECK_PARAM_ERROR | 401 | 检查参数失败。 | 26 | OS_MMAP_ERROR | 1900001 | 执行系统调用mmap失败。 | 27 | OS_IOCTL_ERROR | 1900002 | 在共享内存文件描述符上执行系统调用ioctl失败。 | 28 | WRITE_TO_ASHMEM_ERROR | 1900003 | 向共享内存写数据失败。 | 29 | READ_FROM_ASHMEM_ERROR | 1900004 | 从共享内存读数据失败。 | 30 | ONLY_PROXY_OBJECT_PERMITTED_ERROR | 1900005 | 只有proxy对象允许该操作。 | 31 | ONLY_REMOTE_OBJECT_PERMITTED_ERROR | 1900006 | 只有remote对象允许该操作。 | 32 | COMMUNICATION_ERROR | 1900007 | 和远端对象进行进程间通信失败。 | 33 | PROXY_OR_REMOTE_OBJECT_INVALID_ERROR | 1900008 | 非法的代理对象或者远端对象。 | 34 | WRITE_DATA_TO_MESSAGE_SEQUENCE_ERROR | 1900009 | 向MessageSequence写数据失败。 | 35 | READ_DATA_FROM_MESSAGE_SEQUENCE_ERROR | 1900010 | 读取MessageSequence数据失败。 | 36 | PARCEL_MEMORY_ALLOC_ERROR | 1900011 | 序列化过程中内存分配失败。 | 37 | CALL_JS_METHOD_ERROR | 1900012 | 执行JS回调方法失败。 | 38 | OS_DUP_ERROR | 1900013 | 执行系统调用dup失败。 | 39 40 41## MessageSequence<sup>9+</sup> 42 43 在RPC或IPC过程中，发送方可以使用MessageSequence提供的写方法，将待发送的数据以特定格式写入该对象。接收方可以使用MessageSequence提供的读方法从该对象中读取特定格式的数据。数据格式包括：基础类型及数组、IPC对象、接口描述符和自定义序列化对象。 44 45### create 46 47 static create(): MessageSequence 48 49 静态方法，创建MessageSequence对象。 50 51**系统能力**：SystemCapability.Communication.IPC.Core 52 53**返回值：** 54 55 | 类型 | 说明 | 56 | --------------- | ------------------------------- | 57 | MessageSequence | 返回创建的MessageSequence对象。 | 58 59**示例：** 60 61 ```ts 62 let data = rpc.MessageSequence.create(); 63 console.log("RpcClient: data is " + data); 64 ``` 65 66### reclaim 67 68reclaim(): void 69 70释放不再使用的MessageSequence对象。 71 72**系统能力**：SystemCapability.Communication.IPC.Core 73 74**示例：** 75 76 ```ts 77 let reply = rpc.MessageSequence.create(); 78 reply.reclaim(); 79 ``` 80 81### writeRemoteObject 82 83writeRemoteObject(object: [IRemoteObject](#iremoteobject)): void 84 85序列化远程对象并将其写入MessageSequence对象。 86 87**系统能力**：SystemCapability.Communication.IPC.Core 88 89**参数：** 90 91 | 参数名 | 类型 | 必填 | 说明 | 92 | ------ | ------------------------------- | ---- | ----------------------------------------- | 93 | object | [IRemoteObject](#iremoteobject) | 是 | 要序列化并写入MessageSequence的远程对象。 | 94 95**错误码：** 96 97以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 98 99 | 错误码ID | 错误信息 | 100 | -------- | ------- | 101 | 1900008 | proxy or remote object is invalid | 102 | 1900009 | write data to message sequence failed | 103 104**示例：** 105 106 ```ts 107 class TestRemoteObject extends rpc.RemoteObject { 108 constructor(descriptor) { 109 super(descriptor); 110 } 111 } 112 let data = rpc.MessageSequence.create(); 113 let testRemoteObject = new TestRemoteObject("testObject"); 114 try { 115 data.writeRemoteObject(testRemoteObject); 116 } catch(error) { 117 console.info("Rpc write remote object fail, errorCode " + error.code); 118 console.info("Rpc write remote object fail, errorMessage " + error.message); 119 } 120 ``` 121 122### readRemoteObject 123 124readRemoteObject(): IRemoteObject 125 126从MessageSequence读取远程对象。此方法用于反序列化MessageSequence对象以生成IRemoteObject。远程对象按写入MessageSequence的顺序读取。 127 128**系统能力**：SystemCapability.Communication.IPC.Core 129 130**返回值：** 131 132 | 类型 | 说明 | 133 | ------------------------------- | ------------------ | 134 | [IRemoteObject](#iremoteobject) | 读取到的远程对象。 | 135 136**错误码：** 137 138以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 139 140 | 错误码ID | 错误信息 | 141 | ------- | -------- | 142 | 1900008 | proxy or remote object is invalid | 143 | 1900010 | read data from message sequence failed | 144 145**示例：** 146 147 ```ts 148 class TestRemoteObject extends rpc.RemoteObject { 149 constructor(descriptor) { 150 super(descriptor); 151 } 152 } 153 let data = rpc.MessageSequence.create(); 154 let testRemoteObject = new TestRemoteObject("testObject"); 155 try { 156 data.writeRemoteObject(testRemoteObject); 157 let proxy = data.readRemoteObject(); 158 } catch(error) { 159 console.info("Rpc write remote object fail, errorCode " + error.code); 160 console.info("Rpc write remote object fail, errorMessage " + error.message); 161 } 162 ``` 163 164### writeInterfaceToken 165 166writeInterfaceToken(token: string): void 167 168将接口描述符写入MessageSequence对象，远端对象可使用该信息校验本次通信。 169 170**系统能力**：SystemCapability.Communication.IPC.Core 171 172**参数：** 173 174 | 参数名 | 类型 | 必填 | 说明 | 175 | ------ | ------ | ---- | ------------------ | 176 | token | string | 是 | 字符串类型描述符。 | 177 178**错误码：** 179 180以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 181 182 | 错误码ID | 错误信息 | 183 | ------- | -------- | 184 | 1900009 | write data to message sequence failed | 185 186**示例：** 187 188 ```ts 189 let data = rpc.MessageSequence.create(); 190 try { 191 data.writeInterfaceToken("aaa"); 192 } catch(error) { 193 console.info("rpc write interface fail, errorCode " + error.code); 194 console.info("rpc write interface fail, errorMessage " + error.message); 195 } 196 ``` 197 198### readInterfaceToken 199 200readInterfaceToken(): string 201 202从MessageSequence对象中读取接口描述符，接口描述符按写入MessageSequence的顺序读取，本地对象可使用该信息检验本次通信。 203 204**系统能力**：SystemCapability.Communication.IPC.Core 205 206**返回值：** 207 208 | 类型 | 说明 | 209 | ------ | ------------------------ | 210 | string | 返回读取到的接口描述符。 | 211 212**错误码：** 213 214以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 215 216 | 错误码ID | 错误信息 | 217 | ------- | ----- | 218 | 1900010 | read data from message sequence failed | 219 220**示例：** 221 222```ts 223class Stub extends rpc.RemoteObject { 224 onRemoteRequest(code, data, reply, option) { 225 try { 226 let interfaceToken = data.readInterfaceToken(); 227 console.log("RpcServer: interfaceToken is " + interfaceToken); 228 } catch(error) { 229 console.info("RpcServer: read interfaceToken failed, errorCode " + error.code); 230 console.info("RpcServer: read interfaceToken failed, errorMessage " + error.message); 231 } 232 return true; 233 } 234} 235 ``` 236 237### getSize 238 239getSize(): number 240 241获取当前创建的MessageSequence对象的数据大小。 242 243**系统能力**：SystemCapability.Communication.IPC.Core 244 245**返回值：** 246 247 | 类型 | 说明 | 248 | ------ | ----------------------------------------------- | 249 | number | 获取的MessageSequence实例的数据大小。以字节为单位。 | 250 251**示例：** 252 253 ```ts 254 let data = rpc.MessageSequence.create(); 255 let size = data.getSize(); 256 console.log("RpcClient: size is " + size); 257 ``` 258 259### getCapacity 260 261getCapacity(): number 262 263获取当前MessageSequence对象的容量大小。 264 265**系统能力**：SystemCapability.Communication.IPC.Core 266 267**返回值：** 268 269 | 类型 | 说明 | 270 | ------ | ----- | 271 | number | 获取的MessageSequence实例的容量大小。以字节为单位。 | 272 273**示例：** 274 275 ```ts 276 let data = rpc.MessageSequence.create(); 277 let result = data.getCapacity(); 278 console.log("RpcClient: capacity is " + result); 279 ``` 280 281### setSize 282 283setSize(size: number): void 284 285设置MessageSequence对象中包含的数据大小。 286 287**系统能力**：SystemCapability.Communication.IPC.Core 288 289**参数：** 290 291 | 参数名 | 类型 | 必填 | 说明 | 292 | ------ | ------ | ---- | ------ | 293 | size | number | 是 | MessageSequence实例的数据大小。以字节为单位。 | 294 295**示例：** 296 297 ```ts 298 let data = rpc.MessageSequence.create(); 299 try { 300 data.setSize(16); 301 console.log("RpcClient: setSize is " + data.getSize()); 302 } catch(error) { 303 console.info("rpc set size of MessageSequence fail, errorCode " + error.code); 304 console.info("rpc set size of MessageSequence fail, errorMessage " + error.message); 305 } 306 ``` 307 308### setCapacity 309 310setCapacity(size: number): void 311 312设置MessageSequence对象的存储容量。 313 314**系统能力**：SystemCapability.Communication.IPC.Core 315 316**参数：** 317 318 | 参数名 | 类型 | 必填 | 说明 | 319 | ------ | ------ | ---- | --------------------------------------------- | 320 | size | number | 是 | MessageSequence实例的存储容量。以字节为单位。 | 321 322**错误码：** 323 324以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 325 326 | 错误码ID | 错误信息 | 327 | -------- | ------ | 328 | 1900011 | parcel memory alloc failed | 329 330**示例：** 331 332 ```ts 333 let data = rpc.MessageSequence.create(); 334 try { 335 data.setCapacity(100); 336 console.log("RpcClient: setCapacity is " + data.getCapacity()); 337 } catch(error) { 338 console.info("rpc memory alloc fail, errorCode " + error.code); 339 console.info("rpc memory alloc fail, errorMessage " + error.message); 340 } 341 ``` 342 343### getWritableBytes 344 345getWritableBytes(): number 346 347获取MessageSequence的可写字节空间大小。 348 349**系统能力**：SystemCapability.Communication.IPC.Core 350 351**返回值：** 352 353 | 类型 | 说明 | 354 | ------ | ------ | 355 | number | 获取到的MessageSequence实例的可写字节空间。以字节为单位。 | 356 357**示例：** 358 359```ts 360class Stub extends rpc.RemoteObject { 361 onRemoteRequest(code, data, reply, option) { 362 let getWritableBytes = data.getWritableBytes(); 363 console.log("RpcServer: getWritableBytes is " + getWritableBytes); 364 return true; 365 } 366} 367 ``` 368 369### getReadableBytes 370 371getReadableBytes(): number 372 373获取MessageSequence的可读字节空间。 374 375**系统能力**：SystemCapability.Communication.IPC.Core 376 377**返回值：** 378 379 | 类型 | 说明 | 380 | ------ | ------- | 381 | number | 获取到的MessageSequence实例的可读字节空间。以字节为单位。 | 382 383**示例：** 384 385 ```ts 386class Stub extends rpc.RemoteObject { 387 onRemoteRequest(code, data, reply, option) { 388 let result = data.getReadableBytes(); 389 console.log("RpcServer: getReadableBytes is " + result); 390 return true; 391 } 392} 393 ``` 394 395### getReadPosition 396 397getReadPosition(): number 398 399获取MessageSequence的读位置。 400 401**系统能力**：SystemCapability.Communication.IPC.Core 402 403**返回值：** 404 405 | 类型 | 说明 | 406 | ------ | ------ | 407 | number | 返回MessageSequence实例中的当前读取位置。 | 408 409**示例：** 410 411 ```ts 412 let data = rpc.MessageSequence.create(); 413 let readPos = data.getReadPosition(); 414 console.log("RpcClient: readPos is " + readPos); 415 ``` 416 417### getWritePosition 418 419getWritePosition(): number 420 421获取MessageSequence的写位置。 422 423**系统能力**：SystemCapability.Communication.IPC.Core 424 425**返回值：** 426 427 | 类型 | 说明 | 428 | ------ | ----- | 429 | number | 返回MessageSequence实例中的当前写入位置。 | 430 431**示例：** 432 433 ```ts 434 let data = rpc.MessageSequence.create(); 435 data.writeInt(10); 436 let bwPos = data.getWritePosition(); 437 console.log("RpcClient: bwPos is " + bwPos); 438 ``` 439 440### rewindRead 441 442rewindRead(pos: number): void 443 444重新偏移读取位置到指定的位置。 445 446**系统能力**：SystemCapability.Communication.IPC.Core 447 448**参数：** 449 450 | 参数名 | 类型 | 必填 | 说明 | 451 | ------ | ------ | ---- | ------- | 452 | pos | number | 是 | 开始读取数据的目标位置。 | 453 454**示例：** 455 456 ```ts 457 let data = rpc.MessageSequence.create(); 458 data.writeInt(12); 459 data.writeString("sequence"); 460 let number = data.readInt(); 461 console.log("RpcClient: number is " + number); 462 try { 463 data.rewindRead(0); 464 } catch(error) { 465 console.info("rpc rewind read data fail, errorCode " + error.code); 466 console.info("rpc rewind read data fail, errorMessage " + error.message); 467 } 468 let number2 = data.readInt(); 469 console.log("RpcClient: rewindRead is " + number2); 470 ``` 471 472### rewindWrite 473 474rewindWrite(pos: number): void 475 476重新偏移写位置到指定的位置。 477 478**系统能力**：SystemCapability.Communication.IPC.Core 479 480**参数：** 481 482 | 参数名 | 类型 | 必填 | 说明 | 483 | ------ | ------ | ---- | ----- | 484 | pos | number | 是 | 开始写入数据的目标位置。 | 485 486**示例：** 487 488 ```ts 489 let data = rpc.MessageSequence.create(); 490 data.writeInt(4); 491 try { 492 data.rewindWrite(0); 493 } catch(error) { 494 console.info("rpc rewind read data fail, errorCode " + error.code); 495 console.info("rpc rewind read data fail, errorMessage " + error.message); 496 } 497 data.writeInt(5); 498 let number = data.readInt(); 499 console.log("RpcClient: rewindWrite is: " + number); 500 ``` 501 502### writeByte 503 504writeByte(val: number): void 505 506将字节值写入MessageSequence实例。 507 508**系统能力**：SystemCapability.Communication.IPC.Core 509 510**参数：** 511 512 | 参数名 | 类型 | 必填 | 说明 | 513 | ----- | ------ | ---- | ----- | 514 | val | number | 是 | 要写入的字节值。 | 515 516**错误码：** 517 518以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 519 520 | 错误码ID | 错误信息 | 521 | -------- | ------- | 522 | 1900009 | write data to message sequence failed | 523 524**示例：** 525 526 ```ts 527 let data = rpc.MessageSequence.create(); 528 try { 529 data.writeByte(2); 530 } catch(error) { 531 console.info("rpc write byte fail, errorCode " + error.code); 532 console.info("rpc write byte fail, errorMessage" + error.message); 533 } 534 ``` 535 536### readByte 537 538readByte(): number 539 540从MessageSequence实例读取字节值。 541 542**系统能力**：SystemCapability.Communication.IPC.Core 543 544**返回值：** 545 546 | 类型 | 说明 | 547 | ------ | ----- | 548 | number | 返回字节值。 | 549 550**错误码：** 551 552以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 553 554 | 错误码ID | 错误信息 | 555 | ------- | -------- | 556 | 1900010 | read data from message sequence failed | 557 558**示例：** 559 560 ```ts 561 let data = rpc.MessageSequence.create(); 562 try { 563 data.writeByte(2); 564 } catch(error) { 565 console.info("rpc write byte fail, errorCode " + error.code); 566 console.info("rpc write byte fail, errorMessage" + error.message); 567 } 568 try { 569 let ret = data.readByte(); 570 console.log("RpcClient: readByte is: " + ret); 571 } catch(error) { 572 console.info("rpc write byte fail, errorCode " + error.code); 573 console.info("rpc write byte fail, errorMessage" + error.message); 574 } 575 ``` 576 577### writeShort 578 579writeShort(val: number): void 580 581将短整数值写入MessageSequence实例。 582 583**系统能力**：SystemCapability.Communication.IPC.Core 584 585**参数：** 586 587 | 参数名 | 类型 | 必填 | 说明 | 588 | ------ | ------ | --- | --- | 589 | val | number | 是 | 要写入的短整数值。 | 590 591**错误码：** 592 593以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 594 595 | 错误码ID | 错误信息 | 596 | ------- | ------ | 597 | 1900009 | write data to message sequence failed | 598 599**示例：** 600 601 ```ts 602 let data = rpc.MessageSequence.create(); 603 try { 604 data.writeShort(8); 605 } catch(error) { 606 console.info("rpc write short fail, errorCode " + error.code); 607 console.info("rpc write short fail, errorMessage" + error.message); 608 } 609 ``` 610 611### readShort 612 613readShort(): number 614 615从MessageSequence实例读取短整数值。 616 617**系统能力**：SystemCapability.Communication.IPC.Core 618 619**返回值：** 620 621 | 类型 | 说明 | 622 | ------ | -------------- | 623 | number | 返回短整数值。 | 624 625**错误码：** 626 627以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 628 629 | 错误码ID | 错误信息 | 630 | ------- | -------- | 631 | 1900010 | read data from message sequence failed | 632 633**示例：** 634 635 ```ts 636 let data = rpc.MessageSequence.create(); 637 try { 638 data.writeShort(8); 639 } catch(error) { 640 console.info("rpc write short fail, errorCode " + error.code); 641 console.info("rpc write short fail, errorMessage" + error.message); 642 } 643 try { 644 let ret = data.readShort(); 645 console.log("RpcClient: readByte is: " + ret); 646 } catch(error) { 647 console.info("rpc read short fail, errorCode " + error.code); 648 console.info("rpc read short fail, errorMessage" + error.message); 649 } 650 ``` 651 652### writeInt 653 654writeInt(val: number): void 655 656将整数值写入MessageSequence实例。 657 658**系统能力**：SystemCapability.Communication.IPC.Core 659 660**参数：** 661 662 | 参数名 | 类型 | 必填 | 说明 | 663 | ------ | ------ | ---- | ---------------- | 664 | val | number | 是 | 要写入的整数值。 | 665 666**错误码：** 667 668以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 669 670 | 错误码ID | 错误信息 | 671 | -------- | ------- | 672 | 1900009 | write data to message sequence failed | 673 674**示例：** 675 676 ```ts 677 let data = rpc.MessageSequence.create(); 678 try { 679 data.writeInt(10); 680 } catch(error) { 681 console.info("rpc write int fail, errorCode " + error.code); 682 console.info("rpc write int fail, errorMessage" + error.message); 683 } 684 ``` 685 686### readInt 687 688readInt(): number 689 690从MessageSequence实例读取整数值。 691 692**系统能力**：SystemCapability.Communication.IPC.Core 693 694**返回值：** 695 696 | 类型 | 说明 | 697 | ------ | ------------ | 698 | number | 返回整数值。 | 699 700**错误码：** 701 702以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 703 704 | 错误码ID | 错误信息 | 705 | ------- | ------- | 706 | 1900010 | read data from message sequence failed | 707 708**示例：** 709 710 ```ts 711 let data = rpc.MessageSequence.create(); 712 try { 713 data.writeInt(10); 714 } catch(error) { 715 console.info("rpc write int fail, errorCode " + error.code); 716 console.info("rpc write int fail, errorMessage" + error.message); 717 } 718 try { 719 let ret = data.readInt(); 720 console.log("RpcClient: readInt is " + ret); 721 } catch(error) { 722 console.info("rpc read int fail, errorCode " + error.code); 723 console.info("rpc read int fail, errorMessage" + error.message); 724 } 725 ``` 726 727### writeLong 728 729writeLong(val: number): void 730 731将长整数值写入MessageSequence实例。 732 733**系统能力**：SystemCapability.Communication.IPC.Core 734 735**参数：** 736 737 | 参数名 | 类型 | 必填 | 说明 | 738 | ------ | ------ | ---- | ---------------- | 739 | val | number | 是 | 要写入的长整数值 | 740 741**错误码：** 742 743以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 744 745 | 错误码ID | 错误信息 | 746 | ------- | ------- | 747 | 1900009 | write data to message sequence failed | 748 749**示例：** 750 751 ```ts 752 let data = rpc.MessageSequence.create(); 753 try { 754 data.writeLong(10000); 755 } catch(error) { 756 console.info("rpc write long fail, errorCode " + error.code); 757 console.info("rpc write long fail, errorMessage" + error.message); 758 } 759 ``` 760 761### readLong 762 763readLong(): number 764 765从MessageSequence实例中读取长整数值。 766 767**系统能力**：SystemCapability.Communication.IPC.Core 768 769**返回值：** 770 771 | 类型 | 说明 | 772 | ------ | -------------- | 773 | number | 返回长整数值。 | 774 775**错误码：** 776 777以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 778 779 | 错误码ID | 错误信息 | 780 | ------- | -------- | 781 | 1900010 | read data from message sequence failed | 782 783**示例：** 784 785 ```ts 786 let data = rpc.MessageSequence.create(); 787 try { 788 data.writeLong(10000); 789 } catch(error) { 790 console.info("rpc write long fail, errorCode " + error.code); 791 console.info("rpc write long fail, errorMessage" + error.message); 792 } 793 try { 794 let ret = data.readLong(); 795 console.log("RpcClient: readLong is " + ret); 796 } catch(error) { 797 console.info("rpc read long fail, errorCode " + error.code); 798 console.info("rpc read long fail, errorMessage" + error.message); 799 } 800 ``` 801 802### writeFloat 803 804writeFloat(val: number): void 805 806将浮点值写入MessageSequence实例。 807 808**系统能力**：SystemCapability.Communication.IPC.Core 809 810**参数：** 811 812 | 参数名 | 类型 | 必填 | 说明 | 813 | ----- | ---- | ---- | ----- | 814 | val | number | 是 | 要写入的浮点值。 | 815 816**错误码：** 817 818以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 819 820 | 错误码ID | 错误信息 | 821 | ------- | ------- | 822 | 1900009 | write data to message sequence failed | 823 824**示例：** 825 826 ```ts 827 let data = rpc.MessageSequence.create(); 828 try { 829 data.writeFloat(1.2); 830 } catch(error) { 831 console.info("rpc write float fail, errorCode " + error.code); 832 console.info("rpc write float fail, errorMessage" + error.message); 833 } 834 ``` 835 836### readFloat 837 838readFloat(): number 839 840从MessageSequence实例中读取浮点值。 841 842**系统能力**：SystemCapability.Communication.IPC.Core 843 844**返回值：** 845 846 | 类型 | 说明 | 847 | ------ | ------------ | 848 | number | 返回浮点值。 | 849 850**错误码：** 851 852以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 853 854 | 错误码ID | 错误信息 | 855 | ------- | -------- | 856 | 1900010 | read data from message sequence failed | 857 858**示例：** 859 860 ```ts 861 let data = rpc.MessageSequence.create(); 862 try { 863 data.writeFloat(1.2); 864 } catch(error) { 865 console.info("rpc write float fail, errorCode " + error.code); 866 console.info("rpc write float fail, errorMessage" + error.message); 867 } 868 try { 869 let ret = data.readFloat(); 870 console.log("RpcClient: readFloat is " + ret); 871 } catch(error) { 872 console.info("rpc read float fail, errorCode " + error.code); 873 console.info("rpc read float fail, errorMessage" + error.message); 874 } 875 ``` 876 877### writeDouble 878 879writeDouble(val: number): void 880 881将双精度浮点值写入MessageSequence实例。 882 883**系统能力**：SystemCapability.Communication.IPC.Core 884 885**参数：** 886 887 | 参数名 | 类型 | 必填 | 说明 | 888 | ------ | ------ | ---- | ---------------------- | 889 | val | number | 是 | 要写入的双精度浮点值。 | 890 891**错误码：** 892 893以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 894 895 | 错误码ID | 错误信息 | 896 | ------- | -------- | 897 | 1900009 | write data to message sequence failed | 898 899**示例：** 900 901 ```ts 902 let data = rpc.MessageSequence.create(); 903 try { 904 data.writeDouble(10.2); 905 } catch(error) { 906 console.info("rpc read float fail, errorCode " + error.code); 907 console.info("rpc read float fail, errorMessage" + error.message); 908 } 909 ``` 910 911### readDouble 912 913readDouble(): number 914 915从MessageSequence实例读取双精度浮点值。 916 917**系统能力**：SystemCapability.Communication.IPC.Core 918 919**返回值：** 920 921 | 类型 | 说明 | 922 | ------ | ------------------ | 923 | number | 返回双精度浮点值。 | 924 925**错误码：** 926 927以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 928 929 | 错误码ID | 错误信息 | 930 | ------- | -------- | 931 | 1900010 | read data from message sequence failed | 932 933**示例：** 934 935 ```ts 936 let data = rpc.MessageSequence.create(); 937 try { 938 data.writeDouble(10.2); 939 } catch(error) { 940 console.info("rpc write double fail, errorCode " + error.code); 941 console.info("rpc write double fail, errorMessage" + error.message); 942 } 943 try { 944 let ret = data.readDouble(); 945 console.log("RpcClient: readDouble is " + ret); 946 } catch(error) { 947 console.info("rpc read double fail, errorCode " + error.code); 948 console.info("rpc read double fail, errorMessage" + error.message); 949 } 950 ``` 951 952### writeBoolean 953 954writeBoolean(val: boolean): void 955 956将布尔值写入MessageSequence实例。 957 958**系统能力**：SystemCapability.Communication.IPC.Core 959 960**参数：** 961 962 | 参数名 | 类型 | 必填 | 说明 | 963 | ------ | ------- | ---- | ---------------- | 964 | val | boolean | 是 | 要写入的布尔值。 | 965 966**错误码：** 967 968以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 969 970 | 错误码ID | 错误信息 | 971 | ------- | ------- | 972 | 1900009 | write data to message sequence failed | 973 974**示例：** 975 976 ```ts 977 let data = rpc.MessageSequence.create(); 978 try { 979 data.writeBoolean(false); 980 } catch(error) { 981 console.info("rpc write boolean fail, errorCode " + error.code); 982 console.info("rpc write boolean fail, errorMessage" + error.message); 983 } 984 ``` 985 986### readBoolean 987 988readBoolean(): boolean 989 990从MessageSequence实例读取布尔值。 991 992**系统能力**：SystemCapability.Communication.IPC.Core 993 994**返回值：** 995 996 | 类型 | 说明 | 997 | ------- | -------------------- | 998 | boolean | 返回读取到的布尔值。 | 999 1000**错误码：** 1001 1002以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 1003 1004 | 错误码ID | 错误信息 | 1005 | -------- | ------- | 1006 | 1900010 | read data from message sequence failed | 1007 1008**示例：** 1009 1010 ```ts 1011 let data = rpc.MessageSequence.create(); 1012 try { 1013 data.writeBoolean(false); 1014 } catch(error) { 1015 console.info("rpc write boolean fail, errorCode " + error.code); 1016 console.info("rpc write boolean fail, errorMessage" + error.message); 1017 } 1018 try { 1019 let ret = data.readBoolean(); 1020 console.log("RpcClient: readBoolean is " + ret); 1021 } catch(error) { 1022 console.info("rpc read boolean fail, errorCode " + error.code); 1023 console.info("rpc read boolean fail, errorMessage" + error.message); 1024 } 1025 ``` 1026 1027### writeChar 1028 1029writeChar(val: number): void 1030 1031将单个字符值写入MessageSequence实例。 1032 1033**系统能力**：SystemCapability.Communication.IPC.Core 1034 1035**参数：** 1036 1037 | 参数名 | 类型 | 必填 | 说明 | 1038 | ------ | ------ | ---- | -------------------- | 1039 | val | number | 是 | 要写入的单个字符值。 | 1040 1041**错误码：** 1042 1043以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 1044 1045 | 错误码ID | 错误信息 | 1046 | ------- | -------- | 1047 | 1900009 | write data to message sequence failed | 1048 1049**示例：** 1050 1051 ```ts 1052 let data = rpc.MessageSequence.create(); 1053 try { 1054 data.writeChar(97); 1055 } catch(error) { 1056 console.info("rpc write char fail, errorCode " + error.code); 1057 console.info("rpc write char fail, errorMessage" + error.message); 1058 } 1059 ``` 1060 1061### readChar 1062 1063readChar(): number 1064 1065从MessageSequence实例中读取单个字符值。 1066 1067**系统能力**：SystemCapability.Communication.IPC.Core 1068 1069**返回值：** 1070 1071 | 类型 | 说明 | 1072 | ------ | ---- | 1073 | number | 返回单个字符值。 | 1074 1075**错误码：** 1076 1077以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 1078 1079 | 错误码ID | 错误信息 | 1080 | ------ | --------- | 1081 | 1900010 | read data from message sequence failed | 1082 1083**示例：** 1084 1085 ```ts 1086 let data = rpc.MessageSequence.create(); 1087 try { 1088 data.writeChar(97); 1089 } catch(error) { 1090 console.info("rpc write char fail, errorCode " + error.code); 1091 console.info("rpc write char fail, errorMessage" + error.message); 1092 } 1093 try { 1094 let ret = data.readChar(); 1095 console.log("RpcClient: readChar is " + ret); 1096 } catch(error) { 1097 console.info("rpc read char fail, errorCode " + error.code); 1098 console.info("rpc read char fail, errorMessage" + error.message); 1099 } 1100 ``` 1101 1102### writeString 1103 1104writeString(val: string): void 1105 1106将字符串值写入MessageSequence实例。 1107 1108**系统能力**：SystemCapability.Communication.IPC.Core 1109 1110**参数：** 1111 1112 | 参数名 | 类型 | 必填 | 说明 | 1113 | ------ | ------ | ---- | ----------------------------------------- | 1114 | val | string | 是 | 要写入的字符串值，其长度应小于40960字节。 | 1115 1116**错误码：** 1117 1118以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 1119 1120 | 错误码ID | 错误信息 | 1121 | ------- | -------- | 1122 | 1900009 | write data to message sequence failed | 1123 1124**示例：** 1125 1126 ```ts 1127 let data = rpc.MessageSequence.create(); 1128 try { 1129 data.writeString('abc'); 1130 } catch(error) { 1131 console.info("rpc write string fail, errorCode " + error.code); 1132 console.info("rpc write string fail, errorMessage" + error.message); 1133 } 1134 ``` 1135 1136### readString 1137 1138readString(): string 1139 1140从MessageSequence实例读取字符串值。 1141 1142**系统能力**：SystemCapability.Communication.IPC.Core 1143 1144**返回值：** 1145 1146 | 类型 | 说明 | 1147 | ------ | -------------- | 1148 | string | 返回字符串值。 | 1149 1150**错误码：** 1151 1152以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 1153 1154 | 错误码ID | 错误信息 | 1155 | ------- | -------- | 1156 | 1900010 | read data from message sequence failed | 1157 1158**示例：** 1159 1160 ```ts 1161 let data = rpc.MessageSequence.create(); 1162 try { 1163 data.writeString('abc'); 1164 } catch(error) { 1165 console.info("rpc write string fail, errorCode " + error.code); 1166 console.info("rpc write string fail, errorMessage" + error.message); 1167 } 1168 try { 1169 let ret = data.readString(); 1170 console.log("RpcClient: readString is " + ret); 1171 } catch(error) { 1172 console.info("rpc read string fail, errorCode " + error.code); 1173 console.info("rpc read string fail, errorMessage" + error.message); 1174 } 1175 ``` 1176 1177### writeParcelable 1178 1179writeParcelable(val: Parcelable): void 1180 1181将自定义序列化对象写入MessageSequence实例。 1182 1183**系统能力**：SystemCapability.Communication.IPC.Core 1184 1185**参数：** 1186 1187 | 参数名 | 类型 | 必填 | 说明 | 1188 | ------ | --------- | ---- | ------ | 1189 | val | Parcelable | 是 | 要写入的可序列对象。 | 1190 1191**错误码：** 1192 1193以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 1194 1195 | 错误码ID | 错误信息 | 1196 | ------- | -------- | 1197 | 1900009 | write data to message sequence failed | 1198 1199**示例：** 1200 1201 ```ts 1202 class MySequenceable { 1203 num: number; 1204 str: string; 1205 constructor(num, str) { 1206 this.num = num; 1207 this.str = str; 1208 } 1209 marshalling(messageSequence) { 1210 messageSequence.writeInt(this.num); 1211 messageSequence.writeString(this.str); 1212 return true; 1213 } 1214 unmarshalling(messageSequence) { 1215 this.num = messageSequence.readInt(); 1216 this.str = messageSequence.readString(); 1217 return true; 1218 } 1219 } 1220 let parcelable = new MySequenceable(1, "aaa"); 1221 let data = rpc.MessageSequence.create(); 1222 try { 1223 data.writeParcelable(parcelable); 1224 } catch(error) { 1225 console.info("rpc write parcelable fail, errorCode " + error.code); 1226 console.info("rpc write parcelable fail, errorMessage" + error.message); 1227 } 1228 ``` 1229 1230### readParcelable 1231 1232readParcelable(dataIn: Parcelable): void 1233 1234从MessageSequence实例中读取成员变量到指定的对象（dataIn）。 1235 1236**系统能力**：SystemCapability.Communication.IPC.Core 1237 1238**参数：** 1239 1240 | 参数名 | 类型 | 必填 | 说明 | 1241 | ------ | ------------------------- | ---- | ----------------------------------------- | 1242 | dataIn | Parcelable | 是 | 需要从MessageSequence读取成员变量的对象。 | 1243 1244**错误码：** 1245 1246以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 1247 1248 | 错误码ID | 错误信息 | 1249 | -------- | ------- | 1250 | 1900010 | read data from message sequence failed | 1251 | 1900012 | call js callback function failed | 1252 1253**示例：** 1254 1255 ```ts 1256 class MySequenceable { 1257 num: number; 1258 str: string; 1259 constructor(num, str) { 1260 this.num = num; 1261 this.str = str; 1262 } 1263 marshalling(messageSequence) { 1264 messageSequence.writeInt(this.num); 1265 messageSequence.writeString(this.str); 1266 return true; 1267 } 1268 unmarshalling(messageSequence) { 1269 this.num = messageSequence.readInt(); 1270 this.str = messageSequence.readString(); 1271 return true; 1272 } 1273 } 1274 let parcelable = new MySequenceable(1, "aaa"); 1275 let data = rpc.MessageSequence.create(); 1276 data.writeParcelable(parcelable); 1277 let ret = new MySequenceable(0, ""); 1278 try { 1279 data.readParcelable(ret); 1280 }catch(error) { 1281 console.info("rpc read parcelable fail, errorCode " + error.code); 1282 console.info("rpc read parcelable fail, errorMessage" + error.message); 1283 } 1284 ``` 1285 1286### writeByteArray 1287 1288writeByteArray(byteArray: number[]): void 1289 1290将字节数组写入MessageSequence实例。 1291 1292**系统能力**：SystemCapability.Communication.IPC.Core 1293 1294**参数：** 1295 1296 | 参数名 | 类型 | 必填 | 说明 | 1297 | --------- | -------- | ---- | ------------------ | 1298 | byteArray | number[] | 是 | 要写入的字节数组。 | 1299 1300**错误码：** 1301 1302以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 1303 1304 | 错误码ID | 错误信息 | 1305 | ------- | -------- | 1306 | 1900009 | write data to message sequence failed | 1307 1308**示例：** 1309 1310 ```ts 1311 let data = rpc.MessageSequence.create(); 1312 let ByteArrayVar = [1, 2, 3, 4, 5]; 1313 try { 1314 data.writeByteArray(ByteArrayVar); 1315 } catch(error) { 1316 console.info("rpc write byteArray fail, errorCode " + error.code); 1317 console.info("rpc write byteArray fail, errorMessage" + error.message); 1318 } 1319 ``` 1320 1321### readByteArray 1322 1323readByteArray(dataIn: number[]): void 1324 1325从MessageSequence实例读取字节数组。 1326 1327**系统能力**：SystemCapability.Communication.IPC.Core 1328 1329**参数：** 1330 1331 | 参数名 | 类型 | 必填 | 说明 | 1332 | ------ | -------- | ---- | ------------------ | 1333 | dataIn | number[] | 是 | 要读取的字节数组。 | 1334 1335**错误码：** 1336 1337以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 1338 1339 | 错误码ID | 错误信息 | 1340 | ------- | -------- | 1341 | 1900010 | read data from message sequence failed | 1342 1343**示例：** 1344 1345 ```ts 1346 let data = rpc.MessageSequence.create(); 1347 let ByteArrayVar = [1, 2, 3, 4, 5]; 1348 try { 1349 data.writeByteArray(ByteArrayVar); 1350 } catch(error) { 1351 console.info("rpc write byteArray fail, errorCode " + error.code); 1352 console.info("rpc write byteArray fail, errorMessage" + error.message); 1353 } 1354 try { 1355 let array = new Array(5); 1356 data.readByteArray(array); 1357 } catch(error) { 1358 console.info("rpc write byteArray fail, errorCode " + error.code); 1359 console.info("rpc write byteArray fail, errorMessage" + error.message); 1360 } 1361 ``` 1362 1363### readByteArray 1364 1365readByteArray(): number[] 1366 1367从MessageSequence实例中读取字节数组。 1368 1369**系统能力**：SystemCapability.Communication.IPC.Core 1370 1371**返回值：** 1372 1373 | 类型 | 说明 | 1374 | -------- | -------------- | 1375 | number[] | 返回字节数组。 | 1376 1377**错误码：** 1378 1379以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 1380 1381 | 错误码ID | 错误信息 | 1382 | -------- | ------- | 1383 | 1900010 | read data from message sequence failed | 1384 1385**示例：** 1386 1387 ```ts 1388 let data = rpc.MessageSequence.create(); 1389 let byteArrayVar = [1, 2, 3, 4, 5]; 1390 try { 1391 data.writeByteArray(byteArrayVar); 1392 } catch(error) { 1393 console.info("rpc write byteArray fail, errorCode " + error.code); 1394 console.info("rpc write byteArray fail, errorMessage" + error.message); 1395 } 1396 try { 1397 let array = data.readByteArray(); 1398 console.log("RpcClient: readByteArray is " + array); 1399 } catch(error) { 1400 console.info("rpc read byteArray fail, errorCode " + error.code); 1401 console.info("rpc read byteArray fail, errorMessage" + error.message); 1402 } 1403 ``` 1404 1405### writeShortArray 1406 1407writeShortArray(shortArray: number[]): void 1408 1409将短整数数组写入MessageSequence实例。 1410 1411**系统能力**：SystemCapability.Communication.IPC.Core 1412 1413**参数：** 1414 1415 | 参数名 | 类型 | 必填 | 说明 | 1416 | ---------- | -------- | ---- | -------------------- | 1417 | shortArray | number[] | 是 | 要写入的短整数数组。 | 1418 1419**错误码：** 1420 1421以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 1422 1423 | 错误码ID | 错误信息 | 1424 | ----- | ----- | 1425 | 1900009 | write data to message sequence failed | 1426 1427**示例：** 1428 1429 ```ts 1430 let data = rpc.MessageSequence.create(); 1431 try { 1432 data.writeShortArray([11, 12, 13]); 1433 } catch(error) { 1434 console.info("rpc read byteArray fail, errorCode " + error.code); 1435 console.info("rpc read byteArray fail, errorMessage" + error.message); 1436 } 1437 ``` 1438 1439### readShortArray 1440 1441readShortArray(dataIn: number[]): void 1442 1443从MessageSequence实例中读取短整数数组。 1444 1445**系统能力**：SystemCapability.Communication.IPC.Core 1446 1447**参数：** 1448 1449 | 参数名 | 类型 | 必填 | 说明 | 1450 | ------ | -------- | ---- | -------------------- | 1451 | dataIn | number[] | 是 | 要读取的短整数数组。 | 1452 1453**错误码：** 1454 1455以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 1456 1457 | 错误码ID | 错误信息 | 1458 | ------ | ------- | 1459 | 1900010 | read data from message sequence failed | 1460 1461**示例：** 1462 1463 ```ts 1464 let data = rpc.MessageSequence.create(); 1465 try { 1466 data.writeShortArray([11, 12, 13]); 1467 } catch(error) { 1468 console.info("rpc write shortArray fail, errorCode " + error.code); 1469 console.info("rpc write shortArray fail, errorMessage" + error.message); 1470 } 1471 try { 1472 let array = new Array(3); 1473 data.readShortArray(array); 1474 } catch(error) { 1475 console.info("rpc read shortArray fail, errorCode " + error.code); 1476 console.info("rpc read shortArray fail, errorMessage" + error.message); 1477 } 1478 ``` 1479 1480### readShortArray 1481 1482readShortArray(): number[] 1483 1484从MessageSequence实例中读取短整数数组。 1485 1486**系统能力**：SystemCapability.Communication.IPC.Core 1487 1488**返回值：** 1489 1490 | 类型 | 说明 | 1491 | -------- | ---------------- | 1492 | number[] | 返回短整数数组。 | 1493 1494**错误码：** 1495 1496以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 1497 1498 | 错误码ID | 错误信息 | 1499 | -------- | ------- | 1500 | 1900010 | read data from message sequence failed | 1501 1502**示例：** 1503 1504 ```ts 1505 let data = rpc.MessageSequence.create(); 1506 try { 1507 data.writeShortArray([11, 12, 13]); 1508 } catch(error) { 1509 console.info("rpc write shortArray fail, errorCode " + error.code); 1510 console.info("rpc write shortArray fail, errorMessage" + error.message); 1511 } 1512 try { 1513 let array = data.readShortArray(); 1514 console.log("RpcClient: readShortArray is " + array); 1515 } catch(error) { 1516 console.info("rpc read shortArray fail, errorCode " + error.code); 1517 console.info("rpc read shortArray fail, errorMessage" + error.message); 1518 } 1519 ``` 1520 1521### writeIntArray 1522 1523writeIntArray(intArray: number[]): void 1524 1525将整数数组写入MessageSequence实例。 1526 1527**系统能力**：SystemCapability.Communication.IPC.Core 1528 1529**参数：** 1530 1531 | 参数名 | 类型 | 必填 | 说明 | 1532 | -------- | -------- | ---- | ------------------ | 1533 | intArray | number[] | 是 | 要写入的整数数组。 | 1534 1535**错误码：** 1536 1537以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 1538 1539 | 错误码ID | 错误信息 | 1540 | ----- | --------- | 1541 | 1900009 | write data to message sequence failed | 1542 1543**示例：** 1544 1545 ```ts 1546 let data = rpc.MessageSequence.create(); 1547 try { 1548 data.writeIntArray([100, 111, 112]); 1549 } catch(error) { 1550 console.info("rpc write intArray fail, errorCode " + error.code); 1551 console.info("rpc write intArray fail, errorMessage" + error.message); 1552 } 1553 ``` 1554 1555### readIntArray 1556 1557readIntArray(dataIn: number[]): void 1558 1559从MessageSequence实例中读取整数数组。 1560 1561**系统能力**：SystemCapability.Communication.IPC.Core 1562 1563**参数：** 1564 1565 | 参数名 | 类型 | 必填 | 说明 | 1566 | ------ | -------- | ---- | ------------------ | 1567 | dataIn | number[] | 是 | 要读取的整数数组。 | 1568 1569**错误码：** 1570 1571以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 1572 1573 | 错误码ID | 错误信息 | 1574 | ------- | -------- | 1575 | 1900010 | read data from message sequence failed | 1576 1577**示例：** 1578 1579 ```ts 1580 let data = rpc.MessageSequence.create(); 1581 try { 1582 data.writeIntArray([100, 111, 112]); 1583 } catch(error) { 1584 console.info("rpc write intArray fail, errorCode " + error.code); 1585 console.info("rpc write intArray fail, errorMessage" + error.message); 1586 } 1587 let array = new Array(3); 1588 try { 1589 data.readIntArray(array); 1590 } catch(error) { 1591 console.info("rpc read intArray fail, errorCode " + error.code); 1592 console.info("rpc read intArray fail, errorMessage" + error.message); 1593 } 1594 ``` 1595 1596### readIntArray 1597 1598readIntArray(): number[] 1599 1600从MessageSequence实例中读取整数数组。 1601 1602**系统能力**：SystemCapability.Communication.IPC.Core 1603 1604**返回值：** 1605 1606 | 类型 | 说明 | 1607 | -------- | -------------- | 1608 | number[] | 返回整数数组。 | 1609 1610**错误码：** 1611 1612以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 1613 1614 | 错误码ID | 错误信息 | 1615 | ----- | ------- | 1616 | 1900010 | read data from message sequence failed | 1617 1618**示例：** 1619 1620 ```ts 1621 let data = rpc.MessageSequence.create(); 1622 try { 1623 data.writeIntArray([100, 111, 112]); 1624 } catch(error) { 1625 console.info("rpc write intArray fail, errorCode " + error.code); 1626 console.info("rpc write intArray fail, errorMessage" + error.message); 1627 } 1628 try { 1629 let array = data.readIntArray(); 1630 console.log("RpcClient: readIntArray is " + array); 1631 } catch(error) { 1632 console.info("rpc read intArray fail, errorCode " + error.code); 1633 console.info("rpc read intArray fail, errorMessage" + error.message); 1634 } 1635 ``` 1636 1637### writeLongArray 1638 1639writeLongArray(longArray: number[]): void 1640 1641将长整数数组写入MessageSequence实例。 1642 1643**系统能力**：SystemCapability.Communication.IPC.Core 1644 1645**参数：** 1646 1647 | 参数名 | 类型 | 必填 | 说明 | 1648 | --------- | -------- | ---- | -------------------- | 1649 | longArray | number[] | 是 | 要写入的长整数数组。 | 1650 1651**错误码：** 1652 1653以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 1654 1655 | 错误码ID | 错误信息 | 1656 | ------- | ----- | 1657 | 1900009 | write data to message sequence failed | 1658 1659**示例：** 1660 1661 ```ts 1662 let data = rpc.MessageSequence.create(); 1663 try { 1664 data.writeLongArray([1111, 1112, 1113]); 1665 }catch(error){ 1666 console.info("rpc write longArray fail, errorCode " + error.code); 1667 console.info("rpc write longArray fail, errorMessage" + error.message); 1668 } 1669 ``` 1670 1671### readLongArray 1672 1673readLongArray(dataIn: number[]): void 1674 1675从MessageSequence实例读取的长整数数组。 1676 1677**系统能力**：SystemCapability.Communication.IPC.Core 1678 1679**参数：** 1680 1681 | 参数名 | 类型 | 必填 | 说明 | 1682 | ------ | -------- | ---- | -------------------- | 1683 | dataIn | number[] | 是 | 要读取的长整数数组。 | 1684 1685**错误码：** 1686 1687以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 1688 1689 | 错误码ID | 错误信息 | 1690 | ------- | ------ | 1691 | 1900010 | read data from message sequence failed | 1692 1693**示例：** 1694 1695 ```ts 1696 let data = rpc.MessageSequence.create(); 1697 try { 1698 data.writeLongArray([1111, 1112, 1113]); 1699 } catch(error) { 1700 console.info("rpc write longArray fail, errorCode " + error.code); 1701 console.info("rpc write longArray fail, errorMessage" + error.message); 1702 } 1703 let array = new Array(3); 1704 try { 1705 data.readLongArray(array); 1706 } catch(error) { 1707 console.info("rpc read longArray fail, errorCode " + error.code); 1708 console.info("rpc read longArray fail, errorMessage" + error.message); 1709 } 1710 ``` 1711 1712### readLongArray 1713 1714readLongArray(): number[] 1715 1716从MessageSequence实例中读取所有的长整数数组。 1717 1718**系统能力**：SystemCapability.Communication.IPC.Core 1719 1720**返回值：** 1721 1722 | 类型 | 说明 | 1723 | -------- | ---------------- | 1724 | number[] | 返回长整数数组。 | 1725 1726**错误码：** 1727 1728以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 1729 1730 | 错误码ID | 错误信息 | 1731 | ------- | -------- | 1732 | 1900010 | read data from message sequence failed | 1733 1734**示例：** 1735 1736 ```ts 1737 let data = rpc.MessageSequence.create(); 1738 try { 1739 data.writeLongArray([1111, 1112, 1113]); 1740 } catch(error) { 1741 console.info("rpc write longArray fail, errorCode " + error.code); 1742 console.info("rpc write longArray fail, errorMessage" + error.message); 1743 } 1744 try { 1745 let array = data.readLongArray(); 1746 console.log("RpcClient: readLongArray is " + array); 1747 } catch(error) { 1748 console.info("rpc read longArray fail, errorCode " + error.code); 1749 console.info("rpc read longArray fail, errorMessage" + error.message); 1750 } 1751 ``` 1752 1753### writeFloatArray 1754 1755writeFloatArray(floatArray: number[]): void 1756 1757将浮点数组写入MessageSequence实例。 1758 1759**系统能力**：SystemCapability.Communication.IPC.Core 1760 1761**参数：** 1762 1763 | 参数名 | 类型 | 必填 | 说明 | 1764 | ---------- | -------- | ---- | ----------------------------------------------------------------------------------------------------------------------- | 1765 | floatArray | number[] | 是 | 要写入的浮点数组。由于系统内部对float类型的数据是按照double处理的，使用时对于数组所占的总字节数应按照double类型来计算。 | 1766 1767**错误码：** 1768 1769以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 1770 1771 | 错误码ID | 错误信息 | 1772 | ------- | -------- | 1773 | 1900009 | write data to message sequence failed | 1774 1775**示例：** 1776 1777 ```ts 1778 let data = rpc.MessageSequence.create(); 1779 try { 1780 data.writeFloatArray([1.2, 1.3, 1.4]); 1781 } catch(error) { 1782 console.info("rpc write floatArray fail, errorCode " + error.code); 1783 console.info("rpc write floatArray fail, errorMessage" + error.message); 1784 } 1785 ``` 1786 1787### readFloatArray 1788 1789readFloatArray(dataIn: number[]): void 1790 1791从MessageSequence实例中读取浮点数组。 1792 1793**系统能力**：SystemCapability.Communication.IPC.Core 1794 1795**参数：** 1796 1797 | 参数名 | 类型 | 必填 | 说明 | 1798 | ------ | -------- | ---- | ----------------------------------------------------------------------------------------------------------------------- | 1799 | dataIn | number[] | 是 | 要读取的浮点数组。由于系统内部对float类型的数据是按照double处理的，使用时对于数组所占的总字节数应按照double类型来计算。 | 1800 1801**错误码：** 1802 1803以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 1804 1805 | 错误码ID | 错误信息 | 1806 | ------- | -------- | 1807 | 1900010 | read data from message sequence failed | 1808 1809**示例：** 1810 1811 ```ts 1812 let data = rpc.MessageSequence.create(); 1813 try { 1814 data.writeFloatArray([1.2, 1.3, 1.4]); 1815 }catch(error){ 1816 console.info("rpc write floatArray fail, errorCode " + error.code); 1817 console.info("rpc write floatArray fail, errorMessage" + error.message); 1818 } 1819 let array = new Array(3); 1820 try { 1821 data.readFloatArray(array); 1822 } catch(error) { 1823 console.info("rpc read floatArray fail, errorCode " + error.code); 1824 console.info("rpc read floatArray fail, errorMessage" + error.message); 1825 } 1826 ``` 1827 1828### readFloatArray 1829 1830readFloatArray(): number[] 1831 1832从MessageSequence实例中读取浮点数组。 1833 1834**系统能力**：SystemCapability.Communication.IPC.Core 1835 1836**返回值：** 1837 1838 | 类型 | 说明 | 1839 | -------- | -------------- | 1840 | number[] | 返回浮点数组。 | 1841 1842**错误码：** 1843 1844以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 1845 1846 | 错误码ID | 错误信息 | 1847 | ------- | -------- | 1848 | 1900010 | read data from message sequence failed | 1849 1850**示例：** 1851 1852 ```ts 1853 let data = rpc.MessageSequence.create(); 1854 try { 1855 data.writeFloatArray([1.2, 1.3, 1.4]); 1856 } catch(error) { 1857 console.info("rpc write floatArray fail, errorCode " + error.code); 1858 console.info("rpc write floatArray fail, errorMessage" + error.message); 1859 } 1860 try { 1861 let array = data.readFloatArray(); 1862 console.log("RpcClient: readFloatArray is " + array); 1863 } catch(error) { 1864 console.info("rpc read floatArray fail, errorCode " + error.code); 1865 console.info("rpc read floatArray fail, errorMessage" + error.message); 1866 } 1867 ``` 1868 1869### writeDoubleArray 1870 1871writeDoubleArray(doubleArray: number[]): void 1872 1873将双精度浮点数组写入MessageSequence实例。 1874 1875**系统能力**：SystemCapability.Communication.IPC.Core 1876 1877**参数：** 1878 1879 | 参数名 | 类型 | 必填 | 说明 | 1880 | ----------- | -------- | ---- | ------------------------ | 1881 | doubleArray | number[] | 是 | 要写入的双精度浮点数组。 | 1882 1883**错误码：** 1884 1885以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 1886 1887 | 错误码ID | 错误信息 | 1888 | ------- | -------- | 1889 | 1900009 | write data to message sequence failed | 1890 1891**示例：** 1892 1893 ```ts 1894 let data = rpc.MessageSequence.create(); 1895 try { 1896 data.writeDoubleArray([11.1, 12.2, 13.3]); 1897 } catch(error) { 1898 console.info("rpc write doubleArray fail, errorCode " + error.code); 1899 console.info("rpc write doubleArray fail, errorMessage" + error.message); 1900 } 1901 ``` 1902 1903### readDoubleArray 1904 1905readDoubleArray(dataIn: number[]): void 1906 1907从MessageSequence实例中读取双精度浮点数组。 1908 1909**系统能力**：SystemCapability.Communication.IPC.Core 1910 1911**参数：** 1912 1913 | 参数名 | 类型 | 必填 | 说明 | 1914 | ------ | -------- | ---- | ------------------------ | 1915 | dataIn | number[] | 是 | 要读取的双精度浮点数组。 | 1916 1917**错误码：** 1918 1919以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 1920 1921 | 错误码ID | 错误信息 | 1922 | ------- | -------- | 1923 | 1900010 | read data from message sequence failed | 1924 1925**示例：** 1926 1927 ```ts 1928 let data = rpc.MessageSequence.create(); 1929 try { 1930 data.writeDoubleArray([11.1, 12.2, 13.3]); 1931 } catch(error) { 1932 console.info("rpc write doubleArray fail, errorCode " + error.code); 1933 console.info("rpc write doubleArray fail, errorMessage" + error.message); 1934 } 1935 let array = new Array(3); 1936 try { 1937 data.readDoubleArray(array); 1938 } catch(error) { 1939 console.info("rpc read doubleArray fail, errorCode " + error.code); 1940 console.info("rpc read doubleArray fail, errorMessage" + error.message); 1941 } 1942 ``` 1943 1944### readDoubleArray 1945 1946readDoubleArray(): number[] 1947 1948从MessageSequence实例读取所有双精度浮点数组。 1949 1950**系统能力**：SystemCapability.Communication.IPC.Core 1951 1952**返回值：** 1953 1954 | 类型 | 说明 | 1955 | -------- | -------------------- | 1956 | number[] | 返回双精度浮点数组。 | 1957 1958**错误码：** 1959 1960以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 1961 1962 | 错误码ID | 错误信息 | 1963 | ------- | -------- | 1964 | 1900010 | read data from message sequence failed | 1965 1966**示例：** 1967 1968 ```ts 1969 let data = rpc.MessageSequence.create(); 1970 try { 1971 data.writeDoubleArray([11.1, 12.2, 13.3]); 1972 } catch(error) { 1973 console.info("rpc write doubleArray fail, errorCode " + error.code); 1974 console.info("rpc write doubleArray fail, errorMessage" + error.message); 1975 } 1976 try { 1977 let array = data.readDoubleArray(); 1978 console.log("RpcClient: readDoubleArray is " + array); 1979 } catch(error) { 1980 console.info("rpc read doubleArray fail, errorCode " + error.code); 1981 console.info("rpc read doubleArray fail, errorMessage" + error.message); 1982 } 1983 ``` 1984 1985### writeBooleanArray 1986 1987writeBooleanArray(booleanArray: boolean[]): void 1988 1989将布尔数组写入MessageSequence实例。 1990 1991**系统能力**：SystemCapability.Communication.IPC.Core 1992 1993**参数：** 1994 1995 | 参数名 | 类型 | 必填 | 说明 | 1996 | ------------ | --------- | ---- | ------------------ | 1997 | booleanArray | boolean[] | 是 | 要写入的布尔数组。 | 1998 1999**错误码：** 2000 2001以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 2002 2003 | 错误码ID | 错误信息 | 2004 | ------- | -------- | 2005 | 1900009 | write data to message sequence failed | 2006 2007**示例：** 2008 2009 ```ts 2010 let data = rpc.MessageSequence.create(); 2011 try { 2012 data.writeBooleanArray([false, true, false]); 2013 } catch(error) { 2014 console.info("rpc write booleanArray fail, errorCode " + error.code); 2015 console.info("rpc write booleanArray fail, errorMessage" + error.message); 2016 } 2017 ``` 2018 2019### readBooleanArray 2020 2021readBooleanArray(dataIn: boolean[]): void 2022 2023从MessageSequence实例中读取布尔数组。 2024 2025**系统能力**：SystemCapability.Communication.IPC.Core 2026 2027**参数：** 2028 2029 | 参数名 | 类型 | 必填 | 说明 | 2030 | ------ | --------- | ---- | ------------------ | 2031 | dataIn | boolean[] | 是 | 要读取的布尔数组。 | 2032 2033**错误码：** 2034 2035以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 2036 2037 | 错误码ID | 错误信息 | 2038 | ------- | -------- | 2039 | 1900010 | read data from message sequence failed | 2040 2041**示例：** 2042 2043 ```ts 2044 let data = rpc.MessageSequence.create(); 2045 try { 2046 data.writeBooleanArray([false, true, false]); 2047 } catch(error) { 2048 console.info("rpc write booleanArray fail, errorCode " + error.code); 2049 console.info("rpc write booleanArray fail, errorMessage" + error.message); 2050 } 2051 let array = new Array(3); 2052 try { 2053 data.readBooleanArray(array); 2054 } catch(error) { 2055 console.info("rpc read booleanArray fail, errorCode " + error.code); 2056 console.info("rpc read booleanArray fail, errorMessage" + error.message); 2057 } 2058 ``` 2059 2060### readBooleanArray 2061 2062readBooleanArray(): boolean[] 2063 2064从MessageSequence实例中读取所有布尔数组。 2065 2066**系统能力**：SystemCapability.Communication.IPC.Core 2067 2068**返回值：** 2069 2070 | 类型 | 说明 | 2071 | --------- | -------------- | 2072 | boolean[] | 返回布尔数组。 | 2073 2074**错误码：** 2075 2076以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 2077 2078 | 错误码ID | 错误信息 | 2079 | ------- | -------- | 2080 | 1900010 | read data from message sequence failed | 2081 2082**示例：** 2083 2084 ```ts 2085 let data = rpc.MessageSequence.create(); 2086 try { 2087 data.writeBooleanArray([false, true, false]); 2088 } catch(error) { 2089 console.info("rpc write booleanArray fail, errorCode " + error.code); 2090 console.info("rpc write booleanArray fail, errorMessage" + error.message); 2091 } 2092 try { 2093 let array = data.readBooleanArray(); 2094 console.log("RpcClient: readBooleanArray is " + array); 2095 } catch(error) { 2096 console.info("rpc read booleanArray fail, errorCode " + error.code); 2097 console.info("rpc read booleanArray fail, errorMessage" + error.message); 2098 } 2099 ``` 2100 2101### writeCharArray 2102 2103writeCharArray(charArray: number[]): void 2104 2105将单个字符数组写入MessageSequence实例。 2106 2107**系统能力**：SystemCapability.Communication.IPC.Core 2108 2109**参数：** 2110 2111 | 参数名 | 类型 | 必填 | 说明 | 2112 | --------- | -------- | ---- | ---------------------- | 2113 | charArray | number[] | 是 | 要写入的单个字符数组。 | 2114 2115**错误码：** 2116 2117以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 2118 2119 | 错误码ID | 错误信息 | 2120 | -------- | ------ | 2121 | 1900009 | write data to message sequence failed | 2122 2123**示例：** 2124 2125 ```ts 2126 let data = rpc.MessageSequence.create(); 2127 try { 2128 data.writeCharArray([97, 98, 88]); 2129 } catch(error) { 2130 console.info("rpc write charArray fail, errorCode " + error.code); 2131 console.info("rpc write charArray fail, errorMessage" + error.message); 2132 } 2133 ``` 2134 2135### readCharArray 2136 2137readCharArray(dataIn: number[]): void 2138 2139从MessageSequence实例中读取单个字符数组。 2140 2141**系统能力**：SystemCapability.Communication.IPC.Core 2142 2143**参数：** 2144 2145 | 参数名 | 类型 | 必填 | 说明 | 2146 | ------ | -------- | ---- | ---------------------- | 2147 | dataIn | number[] | 是 | 要读取的单个字符数组。 | 2148 2149**错误码：** 2150 2151以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 2152 2153 | 错误码ID | 错误信息 | 2154 | ------- | -------- | 2155 | 1900010 | read data from message sequence failed | 2156 2157**示例：** 2158 2159 ```ts 2160 let data = rpc.MessageSequence.create(); 2161 try { 2162 data.writeCharArray([97, 98, 88]); 2163 } catch(error) { 2164 console.info("rpc write charArray fail, errorCode " + error.code); 2165 console.info("rpc write charArray fail, errorMessage" + error.message); 2166 } 2167 let array = new Array(3); 2168 try { 2169 data.readCharArray(array); 2170 } catch(error) { 2171 console.info("rpc read charArray fail, errorCode " + error.code); 2172 console.info("rpc read charArray fail, errorMessage" + error.message); 2173 } 2174 ``` 2175 2176### readCharArray 2177 2178readCharArray(): number[] 2179 2180从MessageSequence实例读取单个字符数组。 2181 2182**系统能力**：SystemCapability.Communication.IPC.Core 2183 2184**返回值：** 2185 2186 | 类型 | 说明 | 2187 | -------- | ------------------ | 2188 | number[] | 返回单个字符数组。 | 2189 2190**错误码：** 2191 2192以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 2193 2194 | 错误码ID | 错误信息 | 2195 | ------- | -------- | 2196 | 1900010 | read data from message sequence failed | 2197 2198**示例：** 2199 2200 ```ts 2201 let data = rpc.MessageSequence.create(); 2202 try { 2203 data.writeCharArray([97, 98, 88]); 2204 } catch(error) { 2205 console.info("rpc write charArray fail, errorCode " + error.code); 2206 console.info("rpc write charArray fail, errorMessage" + error.message); 2207 } 2208 let array = new Array(3); 2209 try { 2210 let array = data.readCharArray(); 2211 console.log("RpcClient: readCharArray is " + array); 2212 } catch(error) { 2213 console.info("rpc read charArray fail, errorCode " + error.code); 2214 console.info("rpc read charArray fail, errorMessage" + error.message); 2215 } 2216 ``` 2217 2218### writeStringArray 2219 2220writeStringArray(stringArray: string[]): void 2221 2222将字符串数组写入MessageSequence实例。 2223 2224**系统能力**：SystemCapability.Communication.IPC.Core 2225 2226**参数：** 2227 2228 | 参数名 | 类型 | 必填 | 说明 | 2229 | ----------- | -------- | ---- | ------------------------------------------------------- | 2230 | stringArray | string[] | 是 | 要写入的字符串数组，数组单个元素的长度应小于40960字节。 | 2231 2232**错误码：** 2233 2234以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 2235 2236 | 错误码ID | 错误信息 | 2237 | ------- | -------- | 2238 | 1900009 | write data to message sequence failed | 2239 2240**示例：** 2241 2242 ```ts 2243 let data = rpc.MessageSequence.create(); 2244 try { 2245 data.writeStringArray(["abc", "def"]); 2246 } catch(error) { 2247 console.info("rpc write stringArray fail, errorCode " + error.code); 2248 console.info("rpc write stringArray fail, errorMessage" + error.message); 2249 } 2250 ``` 2251 2252### readStringArray 2253 2254readStringArray(dataIn: string[]): void 2255 2256从MessageSequence实例读取字符串数组。 2257 2258**系统能力**：SystemCapability.Communication.IPC.Core 2259 2260**参数：** 2261 2262 | 参数名 | 类型 | 必填 | 说明 | 2263 | ------ | -------- | ---- | -------------------- | 2264 | dataIn | string[] | 是 | 要读取的字符串数组。 | 2265 2266**错误码：** 2267 2268以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 2269 2270 | 错误码ID | 错误信息 | 2271 | ------- | -------- | 2272 | 1900010 | read data from message sequence failed | 2273 2274**示例：** 2275 2276 ```ts 2277 let data = rpc.MessageSequence.create(); 2278 try { 2279 data.writeStringArray(["abc", "def"]); 2280 } catch(error) { 2281 console.info("rpc write stringArray fail, errorCode " + error.code); 2282 console.info("rpc write stringArray fail, errorMessage" + error.message); 2283 } 2284 let array = new Array(2); 2285 try { 2286 data.readStringArray(array); 2287 } catch(error) { 2288 console.info("rpc read stringArray fail, errorCode " + error.code); 2289 console.info("rpc read stringArray fail, errorMessage" + error.message); 2290 } 2291 ``` 2292 2293### readStringArray 2294 2295readStringArray(): string[] 2296 2297从MessageSequence实例读取字符串数组。 2298 2299**系统能力**：SystemCapability.Communication.IPC.Core 2300 2301**返回值：** 2302 2303 | 类型 | 说明 | 2304 | -------- | ---------------- | 2305 | string[] | 返回字符串数组。 | 2306 2307**错误码：** 2308 2309以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 2310 2311 | 错误码ID | 错误信息 | 2312 | ------- | -------- | 2313 | 1900010 | read data from message sequence failed | 2314 2315**示例：** 2316 2317 ```ts 2318 let data = rpc.MessageSequence.create(); 2319 try { 2320 data.writeStringArray(["abc", "def"]); 2321 } catch(error) { 2322 console.info("rpc write stringArray fail, errorCode " + error.code); 2323 console.info("rpc write stringArray fail, errorMessage" + error.message); 2324 } 2325 try { 2326 let array = data.readStringArray(); 2327 console.log("RpcClient: readStringArray is " + array); 2328 } catch(error) { 2329 console.info("rpc read stringArray fail, errorCode " + error.code); 2330 console.info("rpc read stringArray fail, errorMessage" + error.message); 2331 } 2332 ``` 2333 2334### writeNoException 2335 2336writeNoException(): void 2337 2338向MessageSequence写入“指示未发生异常”的信息。 2339 2340**系统能力**：SystemCapability.Communication.IPC.Core 2341 2342**错误码：** 2343 2344以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 2345 2346 | 错误码ID | 错误信息 | 2347 | ------- | -------- | 2348 | 1900009 | write data to message sequence failed | 2349 2350**示例：** 2351 2352 ```ts 2353 class TestRemoteObject extends rpc.RemoteObject { 2354 constructor(descriptor) { 2355 super(descriptor); 2356 } 2357 2358 onRemoteRequest(code, data, reply, option) { 2359 if (code === 1) { 2360 console.log("RpcServer: onRemoteRequest called"); 2361 try { 2362 reply.writeNoException(); 2363 } catch(error) { 2364 console.info("rpc write no exception fail, errorCode " + error.code); 2365 console.info("rpc write no exception fail, errorMessage" + error.message); 2366 } 2367 return true; 2368 } else { 2369 console.log("RpcServer: unknown code: " + code); 2370 return false; 2371 } 2372 } 2373 } 2374 ``` 2375 2376### readException 2377 2378readException(): void 2379 2380从MessageSequence中读取异常。 2381 2382**系统能力**：SystemCapability.Communication.IPC.Core 2383 2384**错误码：** 2385 2386以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 2387 2388 | 错误码ID | 错误信息 | 2389 | ------- | -------- | 2390 | 1900010 | read data from message sequence failed | 2391 2392**示例：** 2393 2394 获取服务 2395 2396 ```ts 2397 import FA from "@ohos.ability.featureAbility"; 2398 let proxy; 2399 let connect = { 2400 onConnect: function(elementName, remoteProxy) { 2401 console.log("RpcClient: js onConnect called."); 2402 proxy = remoteProxy; 2403 }, 2404 onDisconnect: function(elementName) { 2405 console.log("RpcClient: onDisconnect"); 2406 }, 2407 onFailed: function() { 2408 console.log("RpcClient: onFailed"); 2409 } 2410 }; 2411 let want = { 2412 "bundleName": "com.ohos.server", 2413 "abilityName": "com.ohos.server.MainAbility", 2414 }; 2415 FA.connectAbility(want, connect); 2416 ``` 2417 2418 上述onConnect回调函数中的proxy对象需要等ability异步连接成功后才会被赋值，然后才可调用proxy对象的sendMessageRequest接口方法发送消息 2419 2420 ```ts 2421 let option = new rpc.MessageOption(); 2422 let data = rpc.MessageSequence.create(); 2423 let reply = rpc.MessageSequence.create(); 2424 data.writeInt(1); 2425 data.writeString("hello"); 2426 proxy.sendMessageRequest(1, data, reply, option) 2427 .then(function(errCode) { 2428 if (errCode === 0) { 2429 console.log("sendMessageRequest got result"); 2430 try { 2431 reply.readException(); 2432 } catch(error) { 2433 console.info("rpc read exception fail, errorCode " + error.code); 2434 console.info("rpc read no exception fail, errorMessage" + error.message); 2435 } 2436 let msg = reply.readString(); 2437 console.log("RPCTest: reply msg: " + msg); 2438 } else { 2439 console.log("RPCTest: sendMessageRequest failed, errCode: " + errCode); 2440 } 2441 }).catch(function(e) { 2442 console.log("RPCTest: sendMessageRequest got exception: " + e.message); 2443 }).finally (() => { 2444 console.log("RPCTest: sendMessageRequest ends, reclaim parcel"); 2445 data.reclaim(); 2446 reply.reclaim(); 2447 }); 2448 ``` 2449 2450### writeParcelableArray 2451 2452writeParcelableArray(parcelableArray: Parcelable[]): void 2453 2454将可序列化对象数组写入MessageSequence实例。 2455 2456**系统能力**：SystemCapability.Communication.IPC.Core 2457 2458**参数：** 2459 2460 | 参数名 | 类型 | 必填 | 说明 | 2461 | --------------- | ------------ | ---- | -------------------------- | 2462 | parcelableArray | Parcelable[] | 是 | 要写入的可序列化对象数组。 | 2463 2464**错误码：** 2465 2466以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 2467 2468 | 错误码ID | 错误信息 | 2469 | ------- | -------- | 2470 | 1900009 | write data to message sequence failed | 2471 2472**示例：** 2473 2474 ```ts 2475 class MyParcelable { 2476 num: number; 2477 str: string; 2478 constructor(num, str) { 2479 this.num = num; 2480 this.str = str; 2481 } 2482 marshalling(messageSequence) { 2483 messageSequence.writeInt(this.num); 2484 messageSequence.writeString(this.str); 2485 return true; 2486 } 2487 unmarshalling(messageSequence) { 2488 this.num = messageSequence.readInt(); 2489 this.str = messageSequence.readString(); 2490 return true; 2491 } 2492 } 2493 let parcelable = new MyParcelable(1, "aaa"); 2494 let parcelable2 = new MyParcelable(2, "bbb"); 2495 let parcelable3 = new MyParcelable(3, "ccc"); 2496 let a = [parcelable, parcelable2, parcelable3]; 2497 let data = rpc.MessageSequence.create(); 2498 try { 2499 data.writeParcelableArray(a); 2500 } catch(error) { 2501 console.info("rpc write parcelable array fail, errorCode " + error.code); 2502 console.info("rpc write parcelable array fail, errorMessage" + error.message); 2503 } 2504 ``` 2505 2506### readParcelableArray 2507 2508readParcelableArray(parcelableArray: Parcelable[]): void 2509 2510从MessageSequence实例读取可序列化对象数组。 2511 2512**系统能力**：SystemCapability.Communication.IPC.Core 2513 2514**参数：** 2515 2516 | 参数名 | 类型 | 必填 | 说明 | 2517 | --------------- | ------------ | ---- | -------------------------- | 2518 | parcelableArray | Parcelable[] | 是 | 要读取的可序列化对象数组。 | 2519 2520**错误码：** 2521 2522以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 2523 2524 | 错误码ID | 错误信息 | 2525 | ------- | -------- | 2526 | 1900010 | read data from message sequence failed | 2527 | 1900012 | call js callback function failed | 2528 2529**示例：** 2530 2531 ```ts 2532 class MyParcelable { 2533 num: number; 2534 str: string; 2535 constructor(num, str) { 2536 this.num = num; 2537 this.str = str; 2538 } 2539 marshalling(messageSequence) { 2540 messageSequence.writeInt(this.num); 2541 messageSequence.writeString(this.str); 2542 return true; 2543 } 2544 unmarshalling(messageSequence) { 2545 this.num = messageSequence.readInt(); 2546 this.str = messageSequence.readString(); 2547 return true; 2548 } 2549 } 2550 let parcelable = new MyParcelable(1, "aaa"); 2551 let parcelable2 = new MyParcelable(2, "bbb"); 2552 let parcelable3 = new MyParcelable(3, "ccc"); 2553 let a = [parcelable, parcelable2, parcelable3]; 2554 let data = rpc.MessageSequence.create(); 2555 let result = data.writeParcelableArray(a); 2556 console.log("RpcClient: writeParcelableArray is " + result); 2557 let b = [new MyParcelable(0, ""), new MyParcelable(0, ""), new MyParcelable(0, "")]; 2558 try { 2559 data.readParcelableArray(b); 2560 } catch(error) { 2561 console.info("rpc read parcelable array fail, errorCode " + error.code); 2562 console.info("rpc read parcelable array fail, errorMessage" + error.message); 2563 } 2564 data.readParcelableArray(b); 2565 ``` 2566 2567### writeRemoteObjectArray 2568 2569writeRemoteObjectArray(objectArray: IRemoteObject[]): void 2570 2571将IRemoteObject对象数组写入MessageSequence。 2572 2573**系统能力**：SystemCapability.Communication.IPC.Core 2574 2575**参数：** 2576 2577 | 参数名 | 类型 | 必填 | 说明 | 2578 | ----------- | --------------- | ---- | ---------------------------------------------- | 2579 | objectArray | IRemoteObject[] | 是 | 要写入MessageSequence的IRemoteObject对象数组。 | 2580 2581**错误码：** 2582 2583以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 2584 2585 | 错误码ID | 错误信息 | 2586 | ------- | ------- | 2587 | 1900009 | write data to message sequence failed | 2588 2589**示例：** 2590 2591 ```ts 2592 class TestRemoteObject extends rpc.RemoteObject { 2593 constructor(descriptor) { 2594 super(descriptor); 2595 this.modifyLocalInterface(this, descriptor); 2596 } 2597 2598 asObject(): rpc.IRemoteObject { 2599 return this; 2600 } 2601 } 2602 let a = [new TestRemoteObject("testObject1"), new TestRemoteObject("testObject2"), new TestRemoteObject("testObject3")]; 2603 let data = rpc.MessageSequence.create(); 2604 let result = data.writeRemoteObjectArray(a); 2605 try { 2606 data.writeRemoteObjectArray(a); 2607 } catch(error) { 2608 console.info("rpc write remote object array fail, errorCode " + error.code); 2609 console.info("rpc write remote object array fail, errorMessage" + error.message); 2610 } 2611 console.log("RpcClient: writeRemoteObjectArray is " + result); 2612 ``` 2613 2614### readRemoteObjectArray 2615 2616readRemoteObjectArray(objects: IRemoteObject[]): void 2617 2618从MessageSequence读取IRemoteObject对象数组。 2619 2620**系统能力**：SystemCapability.Communication.IPC.Core 2621 2622**参数：** 2623 2624 | 参数名 | 类型 | 必填 | 说明 | 2625 | ------- | --------------- | ---- | ---------------------------------------------- | 2626 | objects | IRemoteObject[] | 是 | 从MessageSequence读取的IRemoteObject对象数组。 | 2627 2628**错误码：** 2629 2630以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 2631 2632 | 错误码ID | 错误信息 | 2633 | ------- | -------- | 2634 | 1900010 | read data from message sequence failed | 2635 2636**示例：** 2637 2638 ```ts 2639 class MyDeathRecipient { 2640 onRemoteDied() { 2641 console.log("server died"); 2642 } 2643 } 2644 class TestRemoteObject extends rpc.RemoteObject { 2645 constructor(descriptor) { 2646 super(descriptor); 2647 this.modifyLocalInterface(this, descriptor); 2648 } 2649 2650 asObject(): rpc.IRemoteObject { 2651 return this; 2652 } 2653 } 2654 let a = [new TestRemoteObject("testObject1"), new TestRemoteObject("testObject2"), new TestRemoteObject("testObject3")]; 2655 let data = rpc.MessageSequence.create(); 2656 data.writeRemoteObjectArray(a); 2657 let b = new Array(3); 2658 try { 2659 data.readRemoteObjectArray(b); 2660 } catch(error) { 2661 console.info("rpc read remote object array fail, errorCode " + error.code); 2662 console.info("rpc read remote object array fail, errorMessage" + error.message); 2663 } 2664 data.readRemoteObjectArray(b); 2665 ``` 2666 2667### readRemoteObjectArray 2668 2669readRemoteObjectArray(): IRemoteObject[] 2670 2671从MessageSequence读取IRemoteObject对象数组。 2672 2673**系统能力**：SystemCapability.Communication.IPC.Core 2674 2675**返回值：** 2676 2677 | 类型 | 说明 | 2678 | --------------- | --------------------------- | 2679 | IRemoteObject[] | 返回IRemoteObject对象数组。 | 2680 2681**错误码：** 2682 2683以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 2684 2685 | 错误码ID | 错误信息 | 2686 | ------- | -------- | 2687 | 1900010 | read data from message sequence failed | 2688 2689**示例：** 2690 2691 ```ts 2692 class TestRemoteObject extends rpc.RemoteObject { 2693 constructor(descriptor) { 2694 super(descriptor); 2695 this.modifyLocalInterface(this, descriptor); 2696 } 2697 2698 asObject(): rpc.IRemoteObject { 2699 return this; 2700 } 2701 } 2702 let a = [new TestRemoteObject("testObject1"), new TestRemoteObject("testObject2"), new TestRemoteObject("testObject3")]; 2703 let data = rpc.MessageSequence.create(); 2704 data.writeRemoteObjectArray(a); 2705 try { 2706 let b = data.readRemoteObjectArray(); 2707 console.log("RpcClient: readRemoteObjectArray is " + b); 2708 } catch(error) { 2709 console.info("rpc read remote object array fail, errorCode " + error.code); 2710 console.info("rpc read remote object array fail, errorMessage" + error.message); 2711 } 2712 ``` 2713 2714 2715### closeFileDescriptor<sup>9+</sup> 2716 2717static closeFileDescriptor(fd: number): void 2718 2719静态方法，关闭给定的文件描述符。 2720 2721**系统能力**：SystemCapability.Communication.IPC.Core 2722 2723**参数：** 2724 2725 | 参数名 | 类型 | 必填 | 说明 | 2726 | ------ | ------ | ---- | -------------------- | 2727 | fd | number | 是 | 要关闭的文件描述符。 | 2728 2729**示例：** 2730 2731 ```ts 2732 import fileio from '@ohos.fileio'; 2733 let filePath = "path/to/file"; 2734 let fd = fileio.openSync(filePath, 0o2| 0o100, 0o666); 2735 try { 2736 rpc.MessageSequence.closeFileDescriptor(fd); 2737 } catch(error) { 2738 console.info("rpc close file descriptor fail, errorCode " + error.code); 2739 console.info("rpc close file descriptor fail, errorMessage" + error.message); 2740 } 2741 ``` 2742 2743### dupFileDescriptor 2744 2745static dupFileDescriptor(fd: number) :number 2746 2747静态方法，复制给定的文件描述符。 2748 2749**系统能力**：SystemCapability.Communication.IPC.Core 2750 2751**参数：** 2752 2753 | 参数名 | 类型 | 必填 | 说明 | 2754 | ------ | ------ | ---- | ------------------------ | 2755 | fd | number | 是 | 表示已存在的文件描述符。 | 2756 2757**返回值：** 2758 2759 | 类型 | 说明 | 2760 | ------ | -------------------- | 2761 | number | 返回新的文件描述符。 | 2762 2763**错误码：** 2764 2765以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 2766 2767 | 错误码ID | 错误信息 | 2768 | ------- | ------- | 2769 | 1900013 | call os dup function failed | 2770 2771**示例：** 2772 2773 ```ts 2774 import fileio from '@ohos.fileio'; 2775 let filePath = "path/to/file"; 2776 let fd = fileio.openSync(filePath, 0o2| 0o100, 0o666); 2777 try { 2778 let newFd = rpc.MessageSequence.dupFileDescriptor(fd); 2779 } catch(error) { 2780 console.info("rpc dup file descriptor fail, errorCode " + error.code); 2781 console.info("rpc dup file descriptor fail, errorMessage" + error.message); 2782 } 2783 ``` 2784 2785### containFileDescriptors 2786 2787containFileDescriptors(): boolean 2788 2789检查此MessageSequence对象是否包含文件描述符。 2790 2791**系统能力**：SystemCapability.Communication.IPC.Core 2792 2793**返回值：** 2794 2795 | 类型 | 说明 | 2796 | ------- | -------------------------------------------------------------------- | 2797 | boolean | true：包含文件描述符，false：不包含文件描述符。| 2798 2799**示例：** 2800 2801 2802 ```ts 2803 import fileio from '@ohos.fileio'; 2804 let sequence = new rpc.MessageSequence(); 2805 let filePath = "path/to/file"; 2806 let r1 = sequence.containFileDescriptors(); 2807 let fd = fileio.openSync(filePath, 0o2| 0o100, 0o666); 2808 try { 2809 sequence.writeFileDescriptor(fd); 2810 } catch(error) { 2811 console.info("rpc write file descriptor fail, errorCode " + error.code); 2812 console.info("rpc write file descriptor fail, errorMessage" + error.message); 2813 } 2814 try { 2815 let containFD = sequence.containFileDescriptors(); 2816 console.log("RpcTest: sequence after write fd containFd result is : " + containFD); 2817 } catch(error) { 2818 console.info("rpc contain file descriptor fail, errorCode " + error.code); 2819 console.info("rpc contain file descriptor fail, errorMessage" + error.message); 2820 } 2821 ``` 2822 2823### writeFileDescriptor 2824 2825writeFileDescriptor(fd: number): void 2826 2827写入文件描述符到MessageSequence。 2828 2829**系统能力**：SystemCapability.Communication.IPC.Core 2830 2831**参数：** 2832 2833 | 参数名 | 类型 | 必填 | 说明 | 2834 | ------ | ------ | ---- | ------------ | 2835 | fd | number | 是 | 文件描述符。 | 2836 2837**错误码：** 2838 2839以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 2840 2841 | 错误码ID | 错误信息 | 2842 | -------- | ------ | 2843 | 1900009 | write data to message sequence failed | 2844 2845**示例：** 2846 2847 ```ts 2848 import fileio from '@ohos.fileio'; 2849 let sequence = new rpc.MessageSequence(); 2850 let filePath = "path/to/file"; 2851 let fd = fileio.openSync(filePath, 0o2| 0o100, 0o666); 2852 try { 2853 sequence.writeFileDescriptor(fd); 2854 } catch(error) { 2855 console.info("rpc write file descriptor fail, errorCode " + error.code); 2856 console.info("rpc write file descriptor fail, errorMessage" + error.message); 2857 } 2858 ``` 2859 2860### readFileDescriptor 2861 2862readFileDescriptor(): number 2863 2864从MessageSequence中读取文件描述符。 2865 2866**系统能力**：SystemCapability.Communication.IPC.Core 2867 2868**返回值：** 2869 2870 | 类型 | 说明 | 2871 | ------ | ---------------- | 2872 | number | 返回文件描述符。 | 2873 2874**错误码：** 2875 2876以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 2877 2878 | 错误码ID | 错误信息 | 2879 | ------- | -------- | 2880 | 1900010 | read data from message sequence failed | 2881 2882**示例：** 2883 2884 ```ts 2885 import fileio from '@ohos.fileio'; 2886 let sequence = new rpc.MessageSequence(); 2887 let filePath = "path/to/file"; 2888 let fd = fileio.openSync(filePath, 0o2| 0o100, 0o666); 2889 try { 2890 sequence.writeFileDescriptor(fd); 2891 } catch(error) { 2892 console.info("rpc write file descriptor fail, errorCode " + error.code); 2893 console.info("rpc write file descriptor fail, errorMessage" + error.message); 2894 } 2895 try { 2896 let readFD = sequence.readFileDescriptor(); 2897 } catch(error) { 2898 console.info("rpc read file descriptor fail, errorCode " + error.code); 2899 console.info("rpc read file descriptor fail, errorMessage" + error.message); 2900 } 2901 ``` 2902 2903### writeAshmem 2904 2905writeAshmem(ashmem: Ashmem): void 2906 2907将指定的匿名共享对象写入此MessageSequence。 2908 2909**系统能力**：SystemCapability.Communication.IPC.Core 2910 2911**参数：** 2912 2913 | 参数名 | 类型 | 必填 | 说明 | 2914 | ------ | ------ | ---- | ------------------------------------- | 2915 | ashmem | Ashmem | 是 | 要写入MessageSequence的匿名共享对象。 | 2916 2917**错误码：** 2918 2919以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 2920 2921 | 错误码ID | 错误信息 | 2922 | ------- | ------- | 2923 | 1900003 | write to ashmem failed | 2924 2925**示例：** 2926 2927 ```ts 2928 let sequence = new rpc.MessageSequence(); 2929 let ashmem; 2930 try { 2931 ashmem = rpc.Ashmem.create("ashmem", 1024); 2932 } catch(error) { 2933 console.info("rpc create ashmem fail, errorCode " + error.code); 2934 console.info("rpc creat ashmem fail, errorMessage" + error.message); 2935 } 2936 try { 2937 sequence.writeAshmem(ashmem); 2938 } catch(error) { 2939 console.info("rpc write ashmem fail, errorCode " + error.code); 2940 console.info("rpc write ashmem fail, errorMessage" + error.message); 2941 } 2942 ``` 2943 2944 2945### readAshmem 2946 2947readAshmem(): Ashmem 2948 2949从MessageSequence读取匿名共享对象。 2950 2951**系统能力**：SystemCapability.Communication.IPC.Core 2952 2953**返回值：** 2954 2955 | 类型 | 说明 | 2956 | ------ | ------------------ | 2957 | Ashmem | 返回匿名共享对象。 | 2958 2959**错误码：** 2960 2961以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 2962 2963 | 错误码ID | 错误信息 | 2964 | ------- | -------- | 2965 | 1900004 | read from ashmem failed | 2966 2967**示例：** 2968 2969 ```ts 2970 let sequence = new rpc.MessageSequence(); 2971 let ashmem; 2972 try { 2973 ashmem = rpc.Ashmem.create("ashmem", 1024); 2974 } catch(error) { 2975 console.info("rpc create ashmem fail, errorCode " + error.code); 2976 console.info("rpc creat ashmem fail, errorMessage" + error.message); 2977 } 2978 try { 2979 sequence.writeAshmem(ashmem); 2980 } catch(error) { 2981 console.info("rpc write ashmem fail, errorCode " + error.code); 2982 console.info("rpc write ashmem fail, errorMessage" + error.message); 2983 } 2984 try { 2985 let readAshmem = sequence.readAshmem(); 2986 console.log("RpcTest: read ashmem to result is : " + readAshmem); 2987 } catch(error) { 2988 console.info("rpc read ashmem fail, errorCode " + error.code); 2989 console.info("rpc read ashmem fail, errorMessage" + error.message); 2990 } 2991 ``` 2992 2993### getRawDataCapacity 2994 2995getRawDataCapacity(): number 2996 2997获取MessageSequence可以容纳的最大原始数据量。 2998 2999**系统能力**：SystemCapability.Communication.IPC.Core 3000 3001**返回值：** 3002 3003 | 类型 | 说明 | 3004 | ------ | ------------------------------------------------------------ | 3005 | number | 返回MessageSequence可以容纳的最大原始数据量，即128 Mb。 | 3006 3007**示例：** 3008 3009 ```ts 3010 let sequence = new rpc.MessageSequence(); 3011 let result = sequence.getRawDataCapacity(); 3012 console.log("RpcTest: sequence get RawDataCapacity result is : " + result); 3013 ``` 3014 3015### writeRawData 3016 3017writeRawData(rawData: number[], size: number): void 3018 3019将原始数据写入MessageSequence对象。 3020 3021**系统能力**：SystemCapability.Communication.IPC.Core 3022 3023**参数：** 3024 3025 | 参数名 | 类型 | 必填 | 说明 | 3026 | ------- | -------- | ---- | ---------------------------------- | 3027 | rawData | number[] | 是 | 要写入的原始数据。 | 3028 | size | number | 是 | 发送的原始数据大小，以字节为单位。 | 3029 3030**错误码：** 3031 3032以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 3033 3034 | 错误码ID | 错误信息 | 3035 | ------- | ------ | 3036 | 1900009 | write data to message sequence failed | 3037 3038**示例：** 3039 3040 ```ts 3041 let sequence = new rpc.MessageSequence(); 3042 let arr = [1, 2, 3, 4, 5]; 3043 try { 3044 sequence.writeRawData(arr, arr.length); 3045 } catch(error) { 3046 console.info("rpc write rawdata fail, errorCode " + error.code); 3047 console.info("rpc write rawdata fail, errorMessage" + error.message); 3048 } 3049 ``` 3050 3051### readRawData 3052 3053readRawData(size: number): number[] 3054 3055从MessageSequence读取原始数据。 3056 3057**系统能力**：SystemCapability.Communication.IPC.Core 3058 3059**参数：** 3060 3061 | 参数名 | 类型 | 必填 | 说明 | 3062 | ------ | ------ | ---- | ------------------------ | 3063 | size | number | 是 | 要读取的原始数据的大小。 | 3064 3065**返回值：** 3066 3067 | 类型 | 说明 | 3068 | -------- | ------------------------------ | 3069 | number[] | 返回原始数据（以字节为单位）。 | 3070 3071**错误码：** 3072 3073以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 3074 3075 | 错误码ID | 错误信息 | 3076 | ------- | -------- | 3077 | 1900010 | read data from message sequence failed | 3078 3079**示例：** 3080 3081 ```ts 3082 let sequence = new rpc.MessageSequence(); 3083 let arr = [1, 2, 3, 4, 5]; 3084 try { 3085 sequence.writeRawData(arr, arr.length); 3086 } catch(error) { 3087 console.info("rpc write rawdata fail, errorCode " + error.code); 3088 console.info("rpc write rawdata fail, errorMessage" + error.message); 3089 } 3090 try { 3091 let result = sequence.readRawData(5); 3092 console.log("RpcTest: sequence read raw data result is : " + result); 3093 } catch(error) { 3094 console.info("rpc read rawdata fail, errorCode " + error.code); 3095 console.info("rpc read rawdata fail, errorMessage" + error.message); 3096 } 3097 ``` 3098 3099## MessageParcel<sup>(deprecated)</sup> 3100 3101>从API version 9 开始不再维护，建议使用[MessageSequence](#messagesequence9)类替代。 3102 3103在RPC过程中，发送方可以使用MessageParcel提供的写方法，将待发送的数据以特定格式写入该对象。接收方可以使用MessageParcel提供的读方法从该对象中读取特定格式的数据。数据格式包括：基础类型及数组、IPC对象、接口描述符和自定义序列化对象。 3104 3105### create 3106 3107static create(): MessageParcel 3108 3109静态方法，创建MessageParcel对象。 3110 3111**系统能力**：SystemCapability.Communication.IPC.Core 3112 3113**返回值：** 3114 3115 | 类型 | 说明 | 3116 | ------------- | ----------------------------- | 3117 | MessageParcel | 返回创建的MessageParcel对象。 | 3118 3119**示例：** 3120 3121 ```ts 3122 let data = rpc.MessageParcel.create(); 3123 console.log("RpcClient: data is " + data); 3124 ``` 3125 3126### reclaim 3127 3128reclaim(): void 3129 3130释放不再使用的MessageParcel对象。 3131 3132**系统能力**：SystemCapability.Communication.IPC.Core 3133 3134**示例：** 3135 3136 ```ts 3137 let reply = rpc.MessageParcel.create(); 3138 reply.reclaim(); 3139 ``` 3140 3141### writeRemoteObject 3142 3143writeRemoteObject(object: [IRemoteObject](#iremoteobject)): boolean 3144 3145序列化远程对象并将其写入MessageParcel对象。 3146 3147**系统能力**：SystemCapability.Communication.IPC.Core 3148 3149**参数：** 3150 3151 | 参数名 | 类型 | 必填 | 说明 | 3152 | ------ | ------------------------------- | ---- | --------------------------------------- | 3153 | object | [IRemoteObject](#iremoteobject) | 是 | 要序列化并写入MessageParcel的远程对象。 | 3154 3155**返回值：** 3156 3157 | 类型 | 说明 | 3158 | ------- | ----------------------------------------- | 3159 | boolean | true：操作成功，false：操作失败。| 3160 3161**示例：** 3162 3163 ```ts 3164 class MyDeathRecipient { 3165 onRemoteDied() { 3166 console.log("server died"); 3167 } 3168 } 3169 class TestRemoteObject extends rpc.RemoteObject { 3170 constructor(descriptor) { 3171 super(descriptor); 3172 } 3173 addDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 3174 return true; 3175 } 3176 removeDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 3177 return true; 3178 } 3179 isObjectDead(): boolean { 3180 return false; 3181 } 3182 } 3183 let data = rpc.MessageParcel.create(); 3184 let testRemoteObject = new TestRemoteObject("testObject"); 3185 data.writeRemoteObject(testRemoteObject); 3186 ``` 3187 3188### readRemoteObject 3189 3190readRemoteObject(): IRemoteObject 3191 3192从MessageParcel读取远程对象。此方法用于反序列化MessageParcel对象以生成IRemoteObject。远程对象按写入MessageParcel的顺序读取。 3193 3194**系统能力**：SystemCapability.Communication.IPC.Core 3195 3196**返回值：** 3197 3198 | 类型 | 说明 | 3199 | ------------------------------- | ------------------ | 3200 | [IRemoteObject](#iremoteobject) | 读取到的远程对象。 | 3201 3202**示例：** 3203 3204 ```ts 3205 class MyDeathRecipient { 3206 onRemoteDied() { 3207 console.log("server died"); 3208 } 3209 } 3210 class TestRemoteObject extends rpc.RemoteObject { 3211 constructor(descriptor) { 3212 super(descriptor); 3213 } 3214 addDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 3215 return true; 3216 } 3217 removeDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 3218 return true; 3219 } 3220 isObjectDead(): boolean { 3221 return false; 3222 } 3223 } 3224 let data = rpc.MessageParcel.create(); 3225 let testRemoteObject = new TestRemoteObject("testObject"); 3226 data.writeRemoteObject(testRemoteObject); 3227 let proxy = data.readRemoteObject(); 3228 ``` 3229 3230### writeInterfaceToken 3231 3232writeInterfaceToken(token: string): boolean 3233 3234将接口描述符写入MessageParcel对象，远端对象可使用该信息校验本次通信。 3235 3236**系统能力**：SystemCapability.Communication.IPC.Core 3237 3238**参数：** 3239 3240 | 参数名 | 类型 | 必填 | 说明 | 3241 | ------ | ------ | ---- | ------------------ | 3242 | token | string | 是 | 字符串类型描述符。 | 3243 3244**返回值：** 3245 3246 | 类型 | 说明 | 3247 | ------- | ----------------------------------------- | 3248 | boolean | true：操作成功，false：操作失败。| 3249 3250**示例：** 3251 3252 ```ts 3253 let data = rpc.MessageParcel.create(); 3254 let result = data.writeInterfaceToken("aaa"); 3255 console.log("RpcServer: writeInterfaceToken is " + result); 3256 ``` 3257 3258 3259### readInterfaceToken 3260 3261readInterfaceToken(): string 3262 3263从MessageParcel中读取接口描述符，接口描述符按写入MessageParcel的顺序读取，本地对象可使用该信息检验本次通信。 3264 3265**系统能力**：SystemCapability.Communication.IPC.Core 3266 3267**返回值：** 3268 3269 | 类型 | 说明 | 3270 | ------ | ------------------------ | 3271 | string | 返回读取到的接口描述符。 | 3272 3273**示例：** 3274 3275 ```ts 3276 class Stub extends rpc.RemoteObject { 3277 onRemoteMessageRequest(code, data, reply, option) { 3278 let interfaceToken = data.readInterfaceToken(); 3279 console.log("RpcServer: interfaceToken is " + interfaceToken); 3280 return true; 3281 } 3282 } 3283 ``` 3284 3285### getSize 3286 3287getSize(): number 3288 3289获取当前MessageParcel的数据大小。 3290 3291**系统能力**：SystemCapability.Communication.IPC.Core 3292 3293**返回值：** 3294 3295 | 类型 | 说明 | 3296 | ------ | --------------------------------------------- | 3297 | number | 获取的MessageParcel的数据大小。以字节为单位。 | 3298 3299**示例：** 3300 3301 ```ts 3302 let data = rpc.MessageParcel.create(); 3303 let size = data.getSize(); 3304 console.log("RpcClient: size is " + size); 3305 ``` 3306 3307### getCapacity 3308 3309getCapacity(): number 3310 3311获取当前MessageParcel的容量。 3312 3313**系统能力**：SystemCapability.Communication.IPC.Core 3314 3315**返回值：** 3316 3317 | 类型 | 说明 | 3318 | ------ | --------------------------------------------- | 3319 | number | 获取的MessageParcel的容量大小。以字节为单位。 | 3320 3321**示例：** 3322 3323 ```ts 3324 let data = rpc.MessageParcel.create(); 3325 let result = data.getCapacity(); 3326 console.log("RpcClient: capacity is " + result); 3327 ``` 3328 3329### setSize 3330 3331setSize(size: number): boolean 3332 3333设置MessageParcel实例中包含的数据大小。 3334 3335**系统能力**：SystemCapability.Communication.IPC.Core 3336 3337**参数：** 3338 3339 | 参数名 | 类型 | 必填 | 说明 | 3340 | ------ | ------ | ---- | ------------------------------------------- | 3341 | size | number | 是 | MessageParcel实例的数据大小。以字节为单位。 | 3342 3343**返回值：** 3344 3345 | 类型 | 说明 | 3346 | ------- | --------------------------------- | 3347 | boolean | true：设置成功，false：设置失败。| 3348 3349**示例：** 3350 3351 ```ts 3352 let data = rpc.MessageParcel.create(); 3353 let setSize = data.setSize(16); 3354 console.log("RpcClient: setSize is " + setSize); 3355 ``` 3356 3357### setCapacity 3358 3359setCapacity(size: number): boolean 3360 3361设置MessageParcel实例的存储容量。 3362 3363**系统能力**：SystemCapability.Communication.IPC.Core 3364 3365**参数：** 3366 3367 | 参数名 | 类型 | 必填 | 说明 | 3368 | ------ | ------ | ---- | ------------------------------------------- | 3369 | size | number | 是 | MessageParcel实例的存储容量。以字节为单位。 | 3370 3371**返回值：** 3372 3373 | 类型 | 说明 | 3374 | ------- | --------------------------------- | 3375 | boolean | true：设置成功，false：设置失败。| 3376 3377**示例：** 3378 3379 ```ts 3380 let data = rpc.MessageParcel.create(); 3381 let result = data.setCapacity(100); 3382 console.log("RpcClient: setCapacity is " + result); 3383 ``` 3384 3385### getWritableBytes 3386 3387getWritableBytes(): number 3388 3389获取MessageParcel的可写字节空间。 3390 3391**系统能力**：SystemCapability.Communication.IPC.Core 3392 3393**返回值：** 3394 3395 | 类型 | 说明 | 3396 | ------ | --------------------------------------------------- | 3397 | number | 获取到的MessageParcel的可写字节空间。以字节为单位。 | 3398 3399**示例：** 3400 3401 ```ts 3402 class Stub extends rpc.RemoteObject { 3403 onRemoteMessageRequest(code, data, reply, option) { 3404 let getWritableBytes = data.getWritableBytes(); 3405 console.log("RpcServer: getWritableBytes is " + getWritableBytes); 3406 return true; 3407 } 3408 } 3409 ``` 3410 3411### getReadableBytes 3412 3413getReadableBytes(): number 3414 3415获取MessageParcel的可读字节空间。 3416 3417**系统能力**：SystemCapability.Communication.IPC.Core 3418 3419**返回值：** 3420 3421 | 类型 | 说明 | 3422 | ------ | --------------------------------------------------- | 3423 | number | 获取到的MessageParcel的可读字节空间。以字节为单位。 | 3424 3425**示例：** 3426 3427 ```ts 3428 class Stub extends rpc.RemoteObject { 3429 onRemoteRequest(code, data, reply, option) { 3430 let result = data.getReadableBytes(); 3431 console.log("RpcServer: getReadableBytes is " + result); 3432 return true; 3433 } 3434 } 3435 ``` 3436 3437### getReadPosition 3438 3439getReadPosition(): number 3440 3441获取MessageParcel的读位置。 3442 3443**系统能力**：SystemCapability.Communication.IPC.Core 3444 3445**返回值：** 3446 3447 | 类型 | 说明 | 3448 | ------ | --------------------------------------- | 3449 | number | 返回MessageParcel实例中的当前读取位置。 | 3450 3451**示例：** 3452 3453 ```ts 3454 let data = rpc.MessageParcel.create(); 3455 let readPos = data.getReadPosition(); 3456 console.log("RpcClient: readPos is " + readPos); 3457 ``` 3458 3459### getWritePosition 3460 3461getWritePosition(): number 3462 3463获取MessageParcel的写位置。 3464 3465**系统能力**：SystemCapability.Communication.IPC.Core 3466 3467**返回值：** 3468 3469 | 类型 | 说明 | 3470 | ------ | --------------------------------------- | 3471 | number | 返回MessageParcel实例中的当前写入位置。 | 3472 3473**示例：** 3474 3475 ```ts 3476 let data = rpc.MessageParcel.create(); 3477 data.writeInt(10); 3478 let bwPos = data.getWritePosition(); 3479 console.log("RpcClient: bwPos is " + bwPos); 3480 ``` 3481 3482### rewindRead 3483 3484rewindRead(pos: number): boolean 3485 3486重新偏移读取位置到指定的位置。 3487 3488**系统能力**：SystemCapability.Communication.IPC.Core 3489 3490**参数：** 3491 3492 | 参数名 | 类型 | 必填 | 说明 | 3493 | ------ | ------ | ---- | ------------------------ | 3494 | pos | number | 是 | 开始读取数据的目标位置。 | 3495 3496**返回值：** 3497 3498 | 类型 | 说明 | 3499 | ------- | ------------------------------------------------- | 3500 | boolean | true：读取位置发生更改，false：读取位置未发生更改。| 3501 3502**示例：** 3503 3504 ```ts 3505 let data = rpc.MessageParcel.create(); 3506 data.writeInt(12); 3507 data.writeString("parcel"); 3508 let number = data.readInt(); 3509 console.log("RpcClient: number is " + number); 3510 data.rewindRead(0); 3511 let number2 = data.readInt(); 3512 console.log("RpcClient: rewindRead is " + number2); 3513 ``` 3514 3515### rewindWrite 3516 3517rewindWrite(pos: number): boolean 3518 3519重新偏移写位置到指定的位置。 3520 3521**系统能力**：SystemCapability.Communication.IPC.Core 3522 3523**参数：** 3524 3525 | 参数名 | 类型 | 必填 | 说明 | 3526 | ------ | ------ | ---- | ------------------------ | 3527 | pos | number | 是 | 开始写入数据的目标位置。 | 3528 3529**返回值：** 3530 3531 | 类型 | 说明 | 3532 | ------- | --------------------------------------------- | 3533 | boolean | true：写入位置发生更改，false：写入位置未发生更改。| 3534 3535**示例：** 3536 3537 ```ts 3538 let data = rpc.MessageParcel.create(); 3539 data.writeInt(4); 3540 data.rewindWrite(0); 3541 data.writeInt(5); 3542 let number = data.readInt(); 3543 console.log("RpcClient: rewindWrite is: " + number); 3544 ``` 3545 3546### writeByte 3547 3548writeByte(val: number): boolean 3549 3550将字节值写入MessageParcel实例。 3551 3552**系统能力**：SystemCapability.Communication.IPC.Core 3553 3554**参数：** 3555 3556 | 参数名 | 类型 | 必填 | 说明 | 3557 | ------ | ------ | ---- | ---------------- | 3558 | val | number | 是 | 要写入的字节值。 | 3559 3560**返回值：** 3561 3562 | 类型 | 说明 | 3563 | ------- | ----------------------------- | 3564 | boolean | 写入返回成功，否则返回false。 | 3565 3566**示例：** 3567 3568 ```ts 3569 let data = rpc.MessageParcel.create(); 3570 let result = data.writeByte(2); 3571 console.log("RpcClient: writeByte is: " + result); 3572 ``` 3573 3574### readByte 3575 3576readByte(): number 3577 3578从MessageParcel实例读取字节值。 3579 3580**系统能力**：SystemCapability.Communication.IPC.Core 3581 3582**返回值：** 3583 3584 | 类型 | 说明 | 3585 | ------ | ------------ | 3586 | number | 返回字节值。 | 3587 3588**示例：** 3589 3590 ```ts 3591 let data = rpc.MessageParcel.create(); 3592 let result = data.writeByte(2); 3593 console.log("RpcClient: writeByte is: " + result); 3594 let ret = data.readByte(); 3595 console.log("RpcClient: readByte is: " + ret); 3596 ``` 3597 3598### writeShort 3599 3600writeShort(val: number): boolean 3601 3602将短整数值写入MessageParcel实例。 3603 3604**系统能力**：SystemCapability.Communication.IPC.Core 3605 3606**参数：** 3607 3608 | 参数名 | 类型 | 必填 | 说明 | 3609 | ------ | ------ | ---- | ------------------ | 3610 | val | number | 是 | 要写入的短整数值。 | 3611 3612**返回值：** 3613 3614 | 类型 | 说明 | 3615 | ------- | ----------------------------- | 3616 | boolean | true：写入成功，false：写入失败。| 3617 3618**示例：** 3619 3620 ```ts 3621 let data = rpc.MessageParcel.create(); 3622 let result = data.writeShort(8); 3623 console.log("RpcClient: writeShort is: " + result); 3624 ``` 3625 3626### readShort 3627 3628readShort(): number 3629 3630从MessageParcel实例读取短整数值。 3631 3632**系统能力**：SystemCapability.Communication.IPC.Core 3633 3634**返回值：** 3635 3636 | 类型 | 说明 | 3637 | ------ | -------------- | 3638 | number | 返回短整数值。 | 3639 3640**示例：** 3641 3642 ```ts 3643 let data = rpc.MessageParcel.create(); 3644 let result = data.writeShort(8); 3645 console.log("RpcClient: writeShort is: " + result); 3646 let ret = data.readShort(); 3647 console.log("RpcClient: readShort is: " + ret); 3648 ``` 3649 3650### writeInt 3651 3652writeInt(val: number): boolean 3653 3654将整数值写入MessageParcel实例。 3655 3656**系统能力**：SystemCapability.Communication.IPC.Core 3657 3658**参数：** 3659 3660 | 参数名 | 类型 | 必填 | 说明 | 3661 | ------ | ------ | ---- | ---------------- | 3662 | val | number | 是 | 要写入的整数值。 | 3663 3664**返回值：** 3665 3666 | 类型 | 说明 | 3667 | ------- | ----------------------------- | 3668 | boolean | 写入返回成功，否则返回false。 | 3669 3670**示例：** 3671 3672 ```ts 3673 let data = rpc.MessageParcel.create(); 3674 let result = data.writeInt(10); 3675 console.log("RpcClient: writeInt is " + result); 3676 ``` 3677 3678### readInt 3679 3680readInt(): number 3681 3682从MessageParcel实例读取整数值。 3683 3684**系统能力**：SystemCapability.Communication.IPC.Core 3685 3686**返回值：** 3687 3688 | 类型 | 说明 | 3689 | ------ | ------------ | 3690 | number | 返回整数值。 | 3691 3692**示例：** 3693 3694 ```ts 3695 let data = rpc.MessageParcel.create(); 3696 let result = data.writeInt(10); 3697 console.log("RpcClient: writeInt is " + result); 3698 let ret = data.readInt(); 3699 console.log("RpcClient: readInt is " + ret); 3700 ``` 3701 3702### writeLong 3703 3704writeLong(val: number): boolean 3705 3706将长整数值写入MessageParcel实例。 3707 3708**系统能力**：SystemCapability.Communication.IPC.Core 3709 3710**参数：** 3711 3712 | 参数名 | 类型 | 必填 | 说明 | 3713 | ------ | ------ | ---- | ---------------- | 3714 | val | number | 是 | 要写入的长整数值 | 3715 3716**返回值：** 3717 3718 | 类型 | 说明 | 3719 | ------- | --------------------------------- | 3720 | boolean | true：写入成功，false：写入失败。| 3721 3722**示例：** 3723 3724 ```ts 3725 let data = rpc.MessageParcel.create(); 3726 let result = data.writeLong(10000); 3727 console.log("RpcClient: writeLong is " + result); 3728 ``` 3729 3730### readLong 3731 3732readLong(): number 3733 3734从MessageParcel实例中读取长整数值。 3735 3736**系统能力**：SystemCapability.Communication.IPC.Core 3737 3738**返回值：** 3739 3740 | 类型 | 说明 | 3741 | ------ | -------------- | 3742 | number | 返回长整数值。 | 3743 3744**示例：** 3745 3746 ```ts 3747 let data = rpc.MessageParcel.create(); 3748 let result = data.writeLong(10000); 3749 console.log("RpcClient: writeLong is " + result); 3750 let ret = data.readLong(); 3751 console.log("RpcClient: readLong is " + ret); 3752 ``` 3753 3754### writeFloat 3755 3756writeFloat(val: number): boolean 3757 3758将浮点值写入MessageParcel实例。 3759 3760**系统能力**：SystemCapability.Communication.IPC.Core 3761 3762**参数：** 3763 3764 | 参数名 | 类型 | 必填 | 说明 | 3765 | ------ | ------ | ---- | ---------------- | 3766 | val | number | 是 | 要写入的浮点值。 | 3767 3768**返回值：** 3769 3770 | 类型 | 说明 | 3771 | ------- | --------------------------------- | 3772 | boolean | true：写入成功，false：写入失败。| 3773 3774**示例：** 3775 3776 ```ts 3777 let data = rpc.MessageParcel.create(); 3778 let result = data.writeFloat(1.2); 3779 console.log("RpcClient: writeFloat is " + result); 3780 ``` 3781 3782### readFloat 3783 3784readFloat(): number 3785 3786从MessageParcel实例中读取浮点值。 3787 3788**系统能力**：SystemCapability.Communication.IPC.Core 3789 3790**返回值：** 3791 3792 | 类型 | 说明 | 3793 | ------ | ------------ | 3794 | number | 返回浮点值。 | 3795 3796**示例：** 3797 3798 ```ts 3799 let data = rpc.MessageParcel.create(); 3800 let result = data.writeFloat(1.2); 3801 console.log("RpcClient: writeFloat is " + result); 3802 let ret = data.readFloat(); 3803 console.log("RpcClient: readFloat is " + ret); 3804 ``` 3805 3806### writeDouble 3807 3808writeDouble(val: number): boolean 3809 3810将双精度浮点值写入MessageParcel实例。 3811 3812**系统能力**：SystemCapability.Communication.IPC.Core 3813 3814**参数：** 3815 3816 | 参数名 | 类型 | 必填 | 说明 | 3817 | ------ | ------ | ---- | ---------------------- | 3818 | val | number | 是 | 要写入的双精度浮点值。 | 3819 3820**返回值：** 3821 3822 | 类型 | 说明 | 3823 | ------- | --------------------------------- | 3824 | boolean | true：写入成功，false：写入失败。| 3825 3826**示例：** 3827 3828 ```ts 3829 let data = rpc.MessageParcel.create(); 3830 let result = data.writeDouble(10.2); 3831 console.log("RpcClient: writeDouble is " + result); 3832 ``` 3833 3834### readDouble 3835 3836readDouble(): number 3837 3838从MessageParcel实例读取双精度浮点值。 3839 3840**系统能力**：SystemCapability.Communication.IPC.Core 3841 3842**返回值：** 3843 3844 | 类型 | 说明 | 3845 | ------ | ------------------ | 3846 | number | 返回双精度浮点值。 | 3847 3848**示例：** 3849 3850 ```ts 3851 let data = rpc.MessageParcel.create(); 3852 let result = data.writeDouble(10.2); 3853 console.log("RpcClient: writeDouble is " + result); 3854 let ret = data.readDouble(); 3855 console.log("RpcClient: readDouble is " + ret); 3856 ``` 3857 3858### writeBoolean 3859 3860writeBoolean(val: boolean): boolean 3861 3862将布尔值写入MessageParcel实例。 3863 3864**系统能力**：SystemCapability.Communication.IPC.Core 3865 3866**参数：** 3867 3868 | 参数名 | 类型 | 必填 | 说明 | 3869 | ------ | ------- | ---- | ---------------- | 3870 | val | boolean | 是 | 要写入的布尔值。 | 3871 3872**返回值：** 3873 3874 | 类型 | 说明 | 3875 | ------- | --------------------------------- | 3876 | boolean | true：写入成功，false：写入失败。| 3877 3878**示例：** 3879 3880 ```ts 3881 let data = rpc.MessageParcel.create(); 3882 let result = data.writeBoolean(false); 3883 console.log("RpcClient: writeBoolean is " + result); 3884 ``` 3885 3886### readBoolean 3887 3888readBoolean(): boolean 3889 3890从MessageParcel实例读取布尔值。 3891 3892**系统能力**：SystemCapability.Communication.IPC.Core 3893 3894**返回值：** 3895 3896 | 类型 | 说明 | 3897 | ------- | -------------------- | 3898 | boolean | 返回读取到的布尔值。 | 3899 3900**示例：** 3901 3902 ```ts 3903 let data = rpc.MessageParcel.create(); 3904 let result = data.writeBoolean(false); 3905 console.log("RpcClient: writeBoolean is " + result); 3906 let ret = data.readBoolean(); 3907 console.log("RpcClient: readBoolean is " + ret); 3908 ``` 3909 3910### writeChar 3911 3912writeChar(val: number): boolean 3913 3914将单个字符值写入MessageParcel实例。 3915 3916**系统能力**：SystemCapability.Communication.IPC.Core 3917 3918**参数：** 3919 3920 | 参数名 | 类型 | 必填 | 说明 | 3921 | ------ | ------ | ---- | -------------------- | 3922 | val | number | 是 | 要写入的单个字符值。 | 3923 3924**返回值：** 3925 3926 | 类型 | 说明 | 3927 | ------- | ----------------------------- | 3928 | boolean | true：写入成功，false：写入失败。| 3929 3930**示例：** 3931 3932 ```ts 3933 let data = rpc.MessageParcel.create(); 3934 let result = data.writeChar(97); 3935 console.log("RpcClient: writeChar is " + result); 3936 ``` 3937 3938### readChar 3939 3940readChar(): number 3941 3942从MessageParcel实例中读取单个字符值。 3943 3944**系统能力**：SystemCapability.Communication.IPC.Core 3945 3946**返回值：** 3947 3948 | 类型 | 说明 | 3949 | ------ | ---------------- | 3950 | number | 返回单个字符值。 | 3951 3952**示例：** 3953 3954 ```ts 3955 let data = rpc.MessageParcel.create(); 3956 let result = data.writeChar(97); 3957 console.log("RpcClient: writeChar is " + result); 3958 let ret = data.readChar(); 3959 console.log("RpcClient: readChar is " + ret); 3960 ``` 3961 3962### writeString 3963 3964writeString(val: string): boolean 3965 3966将字符串值写入MessageParcel实例。 3967 3968**系统能力**：SystemCapability.Communication.IPC.Core 3969 3970**参数：** 3971 3972 | 参数名 | 类型 | 必填 | 说明 | 3973 | ------ | ------ | ---- | ----------------------------------------- | 3974 | val | string | 是 | 要写入的字符串值，其长度应小于40960字节。 | 3975 3976**返回值：** 3977 3978 | 类型 | 说明 | 3979 | ------- | --------------------------------- | 3980 | boolean | true：写入成功，false：写入失败。| 3981 3982**示例：** 3983 3984 ```ts 3985 let data = rpc.MessageParcel.create(); 3986 let result = data.writeString('abc'); 3987 console.log("RpcClient: writeString is " + result); 3988 ``` 3989 3990### readString 3991 3992readString(): string 3993 3994从MessageParcel实例读取字符串值。 3995 3996**系统能力**：SystemCapability.Communication.IPC.Core 3997 3998**返回值：** 3999 4000 | 类型 | 说明 | 4001 | ------ | -------------- | 4002 | string | 返回字符串值。 | 4003 4004**示例：** 4005 4006 ```ts 4007 let data = rpc.MessageParcel.create(); 4008 let result = data.writeString('abc'); 4009 console.log("RpcClient: writeString is " + result); 4010 let ret = data.readString(); 4011 console.log("RpcClient: readString is " + ret); 4012 ``` 4013 4014### writeSequenceable 4015 4016writeSequenceable(val: Sequenceable): boolean 4017 4018将自定义序列化对象写入MessageParcel实例。 4019 4020**系统能力**：SystemCapability.Communication.IPC.Core 4021 4022**参数：** 4023 4024 | 参数名 | 类型 | 必填 | 说明 | 4025 | ------ | ----------------------------- | ---- | -------------------- | 4026 | val | [Sequenceable](#sequenceable) | 是 | 要写入的可序列对象。 | 4027 4028**返回值：** 4029 4030 | 类型 | 说明 | 4031 | ------- | --------------------------------- | 4032 | boolean | true：写入成功，false：写入失败。| 4033 4034**示例：** 4035 4036 ```ts 4037 class MySequenceable { 4038 num: number; 4039 str: string; 4040 constructor(num, str) { 4041 this.num = num; 4042 this.str = str; 4043 } 4044 marshalling(messageParcel) { 4045 messageParcel.writeInt(this.num); 4046 messageParcel.writeString(this.str); 4047 return true; 4048 } 4049 unmarshalling(messageParcel) { 4050 this.num = messageParcel.readInt(); 4051 this.str = messageParcel.readString(); 4052 return true; 4053 } 4054 } 4055 let sequenceable = new MySequenceable(1, "aaa"); 4056 let data = rpc.MessageParcel.create(); 4057 let result = data.writeSequenceable(sequenceable); 4058 console.log("RpcClient: writeSequenceable is " + result); 4059 ``` 4060 4061### readSequenceable 4062 4063readSequenceable(dataIn: Sequenceable): boolean 4064 4065从MessageParcel实例中读取成员变量到指定的对象（dataIn）。 4066 4067**系统能力**：SystemCapability.Communication.IPC.Core 4068 4069**参数：** 4070 4071 | 参数名 | 类型 | 必填 | 说明 | 4072 | ------ | ----------------------------- | ---- | --------------------------------------- | 4073 | dataIn | [Sequenceable](#sequenceabledeprecated) | 是 | 需要从MessageParcel读取成员变量的对象。 | 4074 4075**返回值：** 4076 4077 | 类型 | 说明 | 4078 | ------- | ------------------------------------------- | 4079 | boolean | true：反序列化成功，false：反序列化失败。| 4080 4081**示例：** 4082 4083 ```ts 4084 class MySequenceable { 4085 num: number; 4086 str: string; 4087 constructor(num, str) { 4088 this.num = num; 4089 this.str = str; 4090 } 4091 marshalling(messageParcel) { 4092 messageParcel.writeInt(this.num); 4093 messageParcel.writeString(this.str); 4094 return true; 4095 } 4096 unmarshalling(messageParcel) { 4097 this.num = messageParcel.readInt(); 4098 this.str = messageParcel.readString(); 4099 return true; 4100 } 4101 } 4102 let sequenceable = new MySequenceable(1, "aaa"); 4103 let data = rpc.MessageParcel.create(); 4104 let result = data.writeSequenceable(sequenceable); 4105 console.log("RpcClient: writeSequenceable is " + result); 4106 let ret = new MySequenceable(0, ""); 4107 let result2 = data.readSequenceable(ret); 4108 console.log("RpcClient: writeSequenceable is " + result2); 4109 ``` 4110 4111### writeByteArray 4112 4113writeByteArray(byteArray: number[]): boolean 4114 4115将字节数组写入MessageParcel实例。 4116 4117**系统能力**：SystemCapability.Communication.IPC.Core 4118 4119**参数：** 4120 4121 | 参数名 | 类型 | 必填 | 说明 | 4122 | --------- | -------- | ---- | ------------------ | 4123 | byteArray | number[] | 是 | 要写入的字节数组。 | 4124 4125**返回值：** 4126 4127 | 类型 | 说明 | 4128 | ------- | --------------------------------- | 4129 | boolean | true：写入成功，false：写入失败。| 4130 4131**示例：** 4132 4133 ```ts 4134 let data = rpc.MessageParcel.create(); 4135 let ByteArrayVar = [1, 2, 3, 4, 5]; 4136 let result = data.writeByteArray(ByteArrayVar); 4137 console.log("RpcClient: writeByteArray is " + result); 4138 ``` 4139 4140### readByteArray 4141 4142readByteArray(dataIn: number[]): void 4143 4144从MessageParcel实例读取字节数组。 4145 4146**系统能力**：SystemCapability.Communication.IPC.Core 4147 4148**参数：** 4149 4150 | 参数名 | 类型 | 必填 | 说明 | 4151 | ------ | -------- | ---- | ------------------ | 4152 | dataIn | number[] | 是 | 要读取的字节数组。 | 4153 4154**示例：** 4155 4156 ```ts 4157 let data = rpc.MessageParcel.create(); 4158 let ByteArrayVar = [1, 2, 3, 4, 5]; 4159 let result = data.writeByteArray(ByteArrayVar); 4160 console.log("RpcClient: writeByteArray is " + result); 4161 let array = new Array(5); 4162 data.readByteArray(array); 4163 ``` 4164 4165### readByteArray 4166 4167readByteArray(): number[] 4168 4169从MessageParcel实例中读取字节数组。 4170 4171**系统能力**：SystemCapability.Communication.IPC.Core 4172 4173**返回值：** 4174 4175 | 类型 | 说明 | 4176 | -------- | -------------- | 4177 | number[] | 返回字节数组。 | 4178 4179**示例：** 4180 4181 ```ts 4182 let data = rpc.MessageParcel.create(); 4183 let ByteArrayVar = [1, 2, 3, 4, 5]; 4184 let result = data.writeByteArray(ByteArrayVar); 4185 console.log("RpcClient: writeByteArray is " + result); 4186 let array = data.readByteArray(); 4187 console.log("RpcClient: readByteArray is " + array); 4188 ``` 4189 4190### writeShortArray 4191 4192writeShortArray(shortArray: number[]): boolean 4193 4194将短整数数组写入MessageParcel实例。 4195 4196**系统能力**：SystemCapability.Communication.IPC.Core 4197 4198**参数：** 4199 4200 | 参数名 | 类型 | 必填 | 说明 | 4201 | ---------- | -------- | ---- | -------------------- | 4202 | shortArray | number[] | 是 | 要写入的短整数数组。 | 4203 4204**返回值：** 4205 4206 | 类型 | 说明 | 4207 | ------- | ----------------------------- | 4208 | boolean | true：写入成功，false：写入失败。| 4209 4210**示例：** 4211 4212 ```ts 4213 let data = rpc.MessageParcel.create(); 4214 let result = data.writeShortArray([11, 12, 13]); 4215 console.log("RpcClient: writeShortArray is " + result); 4216 ``` 4217 4218### readShortArray 4219 4220readShortArray(dataIn: number[]): void 4221 4222从MessageParcel实例中读取短整数数组。 4223 4224**系统能力**：SystemCapability.Communication.IPC.Core 4225 4226**参数：** 4227 4228 | 参数名 | 类型 | 必填 | 说明 | 4229 | ------ | -------- | ---- | -------------------- | 4230 | dataIn | number[] | 是 | 要读取的短整数数组。 | 4231 4232**示例：** 4233 4234 ```ts 4235 let data = rpc.MessageParcel.create(); 4236 let result = data.writeShortArray([11, 12, 13]); 4237 console.log("RpcClient: writeShortArray is " + result); 4238 let array = new Array(3); 4239 data.readShortArray(array); 4240 ``` 4241 4242### readShortArray 4243 4244readShortArray(): number[] 4245 4246从MessageParcel实例中读取短整数数组。 4247 4248**系统能力**：SystemCapability.Communication.IPC.Core 4249 4250**返回值：** 4251 4252 | 类型 | 说明 | 4253 | -------- | ---------------- | 4254 | number[] | 返回短整数数组。 | 4255 4256**示例：** 4257 4258 ```ts 4259 let data = rpc.MessageParcel.create(); 4260 let result = data.writeShortArray([11, 12, 13]); 4261 console.log("RpcClient: writeShortArray is " + result); 4262 let array = data.readShortArray(); 4263 console.log("RpcClient: readShortArray is " + array); 4264 ``` 4265 4266### writeIntArray 4267 4268writeIntArray(intArray: number[]): boolean 4269 4270将整数数组写入MessageParcel实例。 4271 4272**系统能力**：SystemCapability.Communication.IPC.Core 4273 4274**参数：** 4275 4276 | 参数名 | 类型 | 必填 | 说明 | 4277 | -------- | -------- | ---- | ------------------ | 4278 | intArray | number[] | 是 | 要写入的整数数组。 | 4279 4280**返回值：** 4281 4282 | 类型 | 说明 | 4283 | ------- | ----------------------------- | 4284 | boolean | true：写入成功，false：写入失败。| 4285 4286**示例：** 4287 4288 ```ts 4289 let data = rpc.MessageParcel.create(); 4290 let result = data.writeIntArray([100, 111, 112]); 4291 console.log("RpcClient: writeIntArray is " + result); 4292 ``` 4293 4294### readIntArray 4295 4296readIntArray(dataIn: number[]): void 4297 4298从MessageParcel实例中读取整数数组。 4299 4300**系统能力**：SystemCapability.Communication.IPC.Core 4301 4302**参数：** 4303 4304 | 参数名 | 类型 | 必填 | 说明 | 4305 | ------ | -------- | ---- | ------------------ | 4306 | dataIn | number[] | 是 | 要读取的整数数组。 | 4307 4308**示例：** 4309 4310 ```ts 4311 let data = rpc.MessageParcel.create(); 4312 let result = data.writeIntArray([100, 111, 112]); 4313 console.log("RpcClient: writeIntArray is " + result); 4314 let array = new Array(3); 4315 data.readIntArray(array); 4316 ``` 4317 4318### readIntArray 4319 4320readIntArray(): number[] 4321 4322从MessageParcel实例中读取整数数组。 4323 4324**系统能力**：SystemCapability.Communication.IPC.Core 4325 4326**返回值：** 4327 4328 | 类型 | 说明 | 4329 | -------- | -------------- | 4330 | number[] | 返回整数数组。 | 4331 4332**示例：** 4333 4334 ```ts 4335 let data = rpc.MessageParcel.create(); 4336 let result = data.writeIntArray([100, 111, 112]); 4337 console.log("RpcClient: writeIntArray is " + result); 4338 let array = data.readIntArray(); 4339 console.log("RpcClient: readIntArray is " + array); 4340 ``` 4341 4342### writeLongArray 4343 4344writeLongArray(longArray: number[]): boolean 4345 4346将长整数数组写入MessageParcel实例。 4347 4348**系统能力**：SystemCapability.Communication.IPC.Core 4349 4350**参数：** 4351 4352 | 参数名 | 类型 | 必填 | 说明 | 4353 | --------- | -------- | ---- | -------------------- | 4354 | longArray | number[] | 是 | 要写入的长整数数组。 | 4355 4356**返回值：** 4357 4358 | 类型 | 说明 | 4359 | ------- | ----------------------------- | 4360 | boolean | true：写入成功，false：写入失败。| 4361 4362**示例：** 4363 4364 ```ts 4365 let data = rpc.MessageParcel.create(); 4366 let result = data.writeLongArray([1111, 1112, 1113]); 4367 console.log("RpcClient: writeLongArray is " + result); 4368 ``` 4369 4370### readLongArray 4371 4372readLongArray(dataIn: number[]): void 4373 4374从MessageParcel实例读取长整数数组。 4375 4376**系统能力**：SystemCapability.Communication.IPC.Core 4377 4378**参数：** 4379 4380 | 参数名 | 类型 | 必填 | 说明 | 4381 | ------ | -------- | ---- | -------------------- | 4382 | dataIn | number[] | 是 | 要读取的长整数数组。 | 4383 4384**示例：** 4385 4386 ```ts 4387 let data = rpc.MessageParcel.create(); 4388 let result = data.writeLongArray([1111, 1112, 1113]); 4389 console.log("RpcClient: writeLongArray is " + result); 4390 let array = new Array(3); 4391 data.readLongArray(array); 4392 ``` 4393 4394### readLongArray 4395 4396readLongArray(): number[] 4397 4398从MessageParcel实例中读取长整数数组。 4399 4400**系统能力**：SystemCapability.Communication.IPC.Core 4401 4402**返回值：** 4403 4404 | 类型 | 说明 | 4405 | -------- | ---------------- | 4406 | number[] | 返回长整数数组。 | 4407 4408**示例：** 4409 4410 ```ts 4411 let data = rpc.MessageParcel.create(); 4412 let result = data.writeLongArray([1111, 1112, 1113]); 4413 console.log("RpcClient: writeLongArray is " + result); 4414 let array = data.readLongArray(); 4415 console.log("RpcClient: readLongArray is " + array); 4416 ``` 4417 4418### writeFloatArray 4419 4420writeFloatArray(floatArray: number[]): boolean 4421 4422将浮点数组写入MessageParcel实例。 4423 4424**系统能力**：SystemCapability.Communication.IPC.Core 4425 4426**参数：** 4427 4428 | 参数名 | 类型 | 必填 | 说明 | 4429 | ---------- | -------- | ---- | --- | 4430 | floatArray | number[] | 是 | 要写入的浮点数组。由于系统内部对float类型的数据是按照double处理的，使用时对于数组所占的总字节数应按照double类型来计算。 | 4431 4432**返回值：** 4433 4434 | 类型 | 说明 | 4435 | ------- | ----------------------------- | 4436 | boolean | true：写入成功，false：写入失败。| 4437 4438**示例：** 4439 4440 ```ts 4441 let data = rpc.MessageParcel.create(); 4442 let result = data.writeFloatArray([1.2, 1.3, 1.4]); 4443 console.log("RpcClient: writeFloatArray is " + result); 4444 ``` 4445 4446### readFloatArray 4447 4448readFloatArray(dataIn: number[]): void 4449 4450从MessageParcel实例中读取浮点数组。 4451 4452**系统能力**：SystemCapability.Communication.IPC.Core 4453 4454**参数：** 4455 4456 | 参数名 | 类型 | 必填 | 说明 | 4457 | ------ | -------- | ---- | ------ | 4458 | dataIn | number[] | 是 | 要读取的浮点数组。由于系统内部对float类型的数据是按照double处理的，使用时对于数组所占的总字节数应按照double类型来计算。 | 4459 4460**示例：** 4461 4462 ```ts 4463 let data = rpc.MessageParcel.create(); 4464 let result = data.writeFloatArray([1.2, 1.3, 1.4]); 4465 console.log("RpcClient: writeFloatArray is " + result); 4466 let array = new Array(3); 4467 data.readFloatArray(array); 4468 ``` 4469 4470### readFloatArray 4471 4472readFloatArray(): number[] 4473 4474从MessageParcel实例中读取浮点数组。 4475 4476**系统能力**：SystemCapability.Communication.IPC.Core 4477 4478**返回值：** 4479 4480 | 类型 | 说明 | 4481 | -------- | -------------- | 4482 | number[] | 返回浮点数组。 | 4483 4484**示例：** 4485 4486 ```ts 4487 let data = rpc.MessageParcel.create(); 4488 let result = data.writeFloatArray([1.2, 1.3, 1.4]); 4489 console.log("RpcClient: writeFloatArray is " + result); 4490 let array = data.readFloatArray(); 4491 console.log("RpcClient: readFloatArray is " + array); 4492 ``` 4493 4494### writeDoubleArray 4495 4496writeDoubleArray(doubleArray: number[]): boolean 4497 4498将双精度浮点数组写入MessageParcel实例。 4499 4500**系统能力**：SystemCapability.Communication.IPC.Core 4501 4502**参数：** 4503 4504 | 参数名 | 类型 | 必填 | 说明 | 4505 | ----------- | -------- | ---- | ------------------------ | 4506 | doubleArray | number[] | 是 | 要写入的双精度浮点数组。 | 4507 4508**返回值：** 4509 4510 | 类型 | 说明 | 4511 | ------- | ----------------------------- | 4512 | boolean | true：写入成功，false：写入失败。| 4513 4514**示例：** 4515 4516 ```ts 4517 let data = rpc.MessageParcel.create(); 4518 let result = data.writeDoubleArray([11.1, 12.2, 13.3]); 4519 console.log("RpcClient: writeDoubleArray is " + result); 4520 ``` 4521 4522### readDoubleArray 4523 4524readDoubleArray(dataIn: number[]): void 4525 4526从MessageParcel实例中读取双精度浮点数组。 4527 4528**系统能力**：SystemCapability.Communication.IPC.Core 4529 4530**参数：** 4531 4532 | 参数名 | 类型 | 必填 | 说明 | 4533 | ------ | -------- | ---- | ------------------------ | 4534 | dataIn | number[] | 是 | 要读取的双精度浮点数组。 | 4535 4536**示例：** 4537 4538 ```ts 4539 let data = rpc.MessageParcel.create(); 4540 let result = data.writeDoubleArray([11.1, 12.2, 13.3]); 4541 console.log("RpcClient: writeDoubleArray is " + result); 4542 let array = new Array(3); 4543 data.readDoubleArray(array); 4544 ``` 4545 4546### readDoubleArray 4547 4548readDoubleArray(): number[] 4549 4550从MessageParcel实例读取双精度浮点数组。 4551 4552**系统能力**：SystemCapability.Communication.IPC.Core 4553 4554**返回值：** 4555 4556 | 类型 | 说明 | 4557 | -------- | -------------------- | 4558 | number[] | 返回双精度浮点数组。 | 4559 4560**示例：** 4561 4562 ```ts 4563 let data = rpc.MessageParcel.create(); 4564 let result = data.writeDoubleArray([11.1, 12.2, 13.3]); 4565 console.log("RpcClient: writeDoubleArray is " + result); 4566 let array = data.readDoubleArray(); 4567 console.log("RpcClient: readDoubleArray is " + array); 4568 ``` 4569 4570### writeBooleanArray 4571 4572writeBooleanArray(booleanArray: boolean[]): boolean 4573 4574将布尔数组写入MessageParcel实例。 4575 4576**系统能力**：SystemCapability.Communication.IPC.Core 4577 4578**参数：** 4579 4580 | 参数名 | 类型 | 必填 | 说明 | 4581 | ------------ | --------- | ---- | ------------------ | 4582 | booleanArray | boolean[] | 是 | 要写入的布尔数组。 | 4583 4584**返回值：** 4585 4586 | 类型 | 说明 | 4587 | ------- | --------------------------------- | 4588 | boolean | true：写入成功，false：写入失败。| 4589 4590**示例：** 4591 4592 ```ts 4593 let data = rpc.MessageParcel.create(); 4594 let result = data.writeBooleanArray([false, true, false]); 4595 console.log("RpcClient: writeBooleanArray is " + result); 4596 ``` 4597 4598### readBooleanArray 4599 4600readBooleanArray(dataIn: boolean[]): void 4601 4602从MessageParcel实例中读取布尔数组。 4603 4604**系统能力**：SystemCapability.Communication.IPC.Core 4605 4606**参数：** 4607 4608 | 参数名 | 类型 | 必填 | 说明 | 4609 | ------ | --------- | ---- | ------------------ | 4610 | dataIn | boolean[] | 是 | 要读取的布尔数组。 | 4611 4612**示例：** 4613 4614 ```ts 4615 let data = rpc.MessageParcel.create(); 4616 let result = data.writeBooleanArray([false, true, false]); 4617 console.log("RpcClient: writeBooleanArray is " + result); 4618 let array = new Array(3); 4619 data.readBooleanArray(array); 4620 ``` 4621 4622### readBooleanArray 4623 4624readBooleanArray(): boolean[] 4625 4626从MessageParcel实例中读取布尔数组。 4627 4628**系统能力**：SystemCapability.Communication.IPC.Core 4629 4630**返回值：** 4631 4632 | 类型 | 说明 | 4633 | --------- | -------------- | 4634 | boolean[] | 返回布尔数组。 | 4635 4636**示例：** 4637 4638 ```ts 4639 let data = rpc.MessageParcel.create(); 4640 let result = data.writeBooleanArray([false, true, false]); 4641 console.log("RpcClient: writeBooleanArray is " + result); 4642 let array = data.readBooleanArray(); 4643 console.log("RpcClient: readBooleanArray is " + array); 4644 ``` 4645 4646### writeCharArray 4647 4648writeCharArray(charArray: number[]): boolean 4649 4650将单个字符数组写入MessageParcel实例。 4651 4652**系统能力**：SystemCapability.Communication.IPC.Core 4653 4654**参数：** 4655 4656 | 参数名 | 类型 | 必填 | 说明 | 4657 | --------- | -------- | ---- | ---------------------- | 4658 | charArray | number[] | 是 | 要写入的单个字符数组。 | 4659 4660**返回值：** 4661 4662 | 类型 | 说明 | 4663 | ------- | --------------------------------- | 4664 | boolean | true：写入成功，false：写入失败。| 4665 4666**示例：** 4667 4668 ```ts 4669 let data = rpc.MessageParcel.create(); 4670 let result = data.writeCharArray([97, 98, 88]); 4671 console.log("RpcClient: writeCharArray is " + result); 4672 ``` 4673 4674### readCharArray 4675 4676readCharArray(dataIn: number[]): void 4677 4678从MessageParcel实例中读取单个字符数组。 4679 4680**系统能力**：SystemCapability.Communication.IPC.Core 4681 4682**参数：** 4683 4684 | 参数名 | 类型 | 必填 | 说明 | 4685 | ------ | -------- | ---- | ---------------------- | 4686 | dataIn | number[] | 是 | 要读取的单个字符数组。 | 4687 4688**示例：** 4689 4690 ```ts 4691 let data = rpc.MessageParcel.create(); 4692 let result = data.writeCharArray([97, 98, 99]); 4693 console.log("RpcClient: writeCharArray is " + result); 4694 let array = new Array(3); 4695 data.readCharArray(array); 4696 ``` 4697 4698### readCharArray 4699 4700readCharArray(): number[] 4701 4702从MessageParcel实例读取单个字符数组。 4703 4704**系统能力**：SystemCapability.Communication.IPC.Core 4705 4706**返回值：** 4707 4708 | 类型 | 说明 | 4709 | -------- | ------------------ | 4710 | number[] | 返回单个字符数组。 | 4711 4712**示例：** 4713 4714 ```ts 4715 let data = rpc.MessageParcel.create(); 4716 let result = data.writeCharArray([97, 98, 99]); 4717 console.log("RpcClient: writeCharArray is " + result); 4718 let array = data.readCharArray(); 4719 console.log("RpcClient: readCharArray is " + array); 4720 ``` 4721 4722### writeStringArray 4723 4724writeStringArray(stringArray: string[]): boolean 4725 4726将字符串数组写入MessageParcel实例。 4727 4728**系统能力**：SystemCapability.Communication.IPC.Core 4729 4730**参数：** 4731 4732 | 参数名 | 类型 | 必填 | 说明 | 4733 | ----------- | -------- | ---- | ---------------- | 4734 | stringArray | string[] | 是 | 要写入的字符串数组，数组单个元素的长度应小于40960字节。 | 4735 4736**返回值：** 4737 4738 | 类型 | 说明 | 4739 | ------- | --------------------------------- | 4740 | boolean | true：写入成功，false：写入失败。| 4741 4742**示例：** 4743 4744 ```ts 4745 let data = rpc.MessageParcel.create(); 4746 let result = data.writeStringArray(["abc", "def"]); 4747 console.log("RpcClient: writeStringArray is " + result); 4748 ``` 4749 4750### readStringArray 4751 4752readStringArray(dataIn: string[]): void 4753 4754从MessageParcel实例读取字符串数组。 4755 4756**系统能力**：SystemCapability.Communication.IPC.Core 4757 4758**参数：** 4759 4760 | 参数名 | 类型 | 必填 | 说明 | 4761 | ------ | -------- | ---- | -------------------- | 4762 | dataIn | string[] | 是 | 要读取的字符串数组。 | 4763 4764**示例：** 4765 4766 ```ts 4767 let data = rpc.MessageParcel.create(); 4768 let result = data.writeStringArray(["abc", "def"]); 4769 console.log("RpcClient: writeStringArray is " + result); 4770 let array = new Array(2); 4771 data.readStringArray(array); 4772 ``` 4773 4774### readStringArray 4775 4776readStringArray(): string[] 4777 4778从MessageParcel实例读取字符串数组。 4779 4780**系统能力**：SystemCapability.Communication.IPC.Core 4781 4782**返回值：** 4783 4784 | 类型 | 说明 | 4785 | -------- | ---------------- | 4786 | string[] | 返回字符串数组。 | 4787 4788**示例：** 4789 4790 ```ts 4791 let data = rpc.MessageParcel.create(); 4792 let result = data.writeStringArray(["abc", "def"]); 4793 console.log("RpcClient: writeStringArray is " + result); 4794 let array = data.readStringArray(); 4795 console.log("RpcClient: readStringArray is " + array); 4796 ``` 4797 4798### writeNoException<sup>8+</sup> 4799 4800writeNoException(): void 4801 4802向MessageParcel写入“指示未发生异常”的信息。 4803 4804**系统能力**：SystemCapability.Communication.IPC.Core 4805 4806**示例：** 4807 4808 ```ts 4809 class MyDeathRecipient { 4810 onRemoteDied() { 4811 console.log("server died"); 4812 } 4813 } 4814 class TestRemoteObject extends rpc.RemoteObject { 4815 constructor(descriptor) { 4816 super(descriptor); 4817 } 4818 addDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 4819 return true; 4820 } 4821 removeDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 4822 return true; 4823 } 4824 isObjectDead(): boolean { 4825 return false; 4826 } 4827 onRemoteRequest(code, data, reply, option) { 4828 if (code === 1) { 4829 console.log("RpcServer: onRemoteRequest called"); 4830 reply.writeNoException(); 4831 return true; 4832 } else { 4833 console.log("RpcServer: unknown code: " + code); 4834 return false; 4835 } 4836 } 4837 } 4838 ``` 4839 4840### readException<sup>8+</sup> 4841 4842readException(): void 4843 4844从MessageParcel中读取异常。 4845 4846**系统能力**：SystemCapability.Communication.IPC.Core 4847 4848**示例：** 4849 4850 获取服务 4851 4852 ```ts 4853 import FA from "@ohos.ability.featureAbility"; 4854 let proxy; 4855 let connect = { 4856 onConnect: function(elementName, remoteProxy) { 4857 console.log("RpcClient: js onConnect called."); 4858 proxy = remoteProxy; 4859 }, 4860 onDisconnect: function(elementName) { 4861 console.log("RpcClient: onDisconnect"); 4862 }, 4863 onFailed: function() { 4864 console.log("RpcClient: onFailed"); 4865 } 4866 }; 4867 let want = { 4868 "bundleName": "com.ohos.server", 4869 "abilityName": "com.ohos.server.MainAbility", 4870 }; 4871 FA.connectAbility(want, connect); 4872 ``` 4873 4874 上述onConnect回调函数中的proxy对象需要等ability异步连接成功后才会被赋值，然后才可调用proxy对象的sendMessageRequest接口方法发送消息 4875 4876 ```ts 4877 let option = new rpc.MessageOption(); 4878 let data = rpc.MessageParcel.create(); 4879 let reply = rpc.MessageParcel.create(); 4880 data.writeInt(1); 4881 data.writeString("hello"); 4882 proxy.sendMessageRequest(1, data, reply, option) 4883 .then(function(errCode) { 4884 if (errCode === 0) { 4885 console.log("sendMessageRequest got result"); 4886 reply.readException(); 4887 let msg = reply.readString(); 4888 console.log("RPCTest: reply msg: " + msg); 4889 } else { 4890 console.log("RPCTest: sendMessageRequest failed, errCode: " + errCode); 4891 } 4892 }).catch(function(e) { 4893 console.log("RPCTest: sendMessageRequest got exception: " + e.message); 4894 }).finally (() => { 4895 console.log("RPCTest: sendMessageRequest ends, reclaim parcel"); 4896 data.reclaim(); 4897 reply.reclaim(); 4898 }); 4899 ``` 4900 4901### writeSequenceableArray 4902 4903writeSequenceableArray(sequenceableArray: Sequenceable[]): boolean 4904 4905将可序列化对象数组写入MessageParcel实例。 4906 4907**系统能力**：SystemCapability.Communication.IPC.Core 4908 4909**参数：** 4910 4911 | 参数名 | 类型 | 必填 | 说明 | 4912 | ----------------- | -------------- | ---- | -------------------------- | 4913 | sequenceableArray | Sequenceable[] | 是 | 要写入的可序列化对象数组。 | 4914 4915**返回值：** 4916 4917 | 类型 | 说明 | 4918 | ------- | --------------------------------- | 4919 | boolean | true：写入成功，false：写入失败。| 4920 4921**示例：** 4922 4923 ```ts 4924 class MySequenceable { 4925 num: number; 4926 str: string; 4927 constructor(num, str) { 4928 this.num = num; 4929 this.str = str; 4930 } 4931 marshalling(messageParcel) { 4932 messageParcel.writeInt(this.num); 4933 messageParcel.writeString(this.str); 4934 return true; 4935 } 4936 unmarshalling(messageParcel) { 4937 this.num = messageParcel.readInt(); 4938 this.str = messageParcel.readString(); 4939 return true; 4940 } 4941 } 4942 let sequenceable = new MySequenceable(1, "aaa"); 4943 let sequenceable2 = new MySequenceable(2, "bbb"); 4944 let sequenceable3 = new MySequenceable(3, "ccc"); 4945 let a = [sequenceable, sequenceable2, sequenceable3]; 4946 let data = rpc.MessageParcel.create(); 4947 let result = data.writeSequenceableArray(a); 4948 console.log("RpcClient: writeSequenceableArray is " + result); 4949 ``` 4950 4951### readSequenceableArray<sup>8+</sup> 4952 4953readSequenceableArray(sequenceableArray: Sequenceable[]): void 4954 4955从MessageParcel实例读取可序列化对象数组。 4956 4957**系统能力**：SystemCapability.Communication.IPC.Core 4958 4959**参数：** 4960 4961 | 参数名 | 类型 | 必填 | 说明 | 4962 | ----------------- | -------------- | ---- | -------------------------- | 4963 | sequenceableArray | Sequenceable[] | 是 | 要读取的可序列化对象数组。 | 4964 4965**示例：** 4966 4967 ```ts 4968 class MySequenceable { 4969 num: number; 4970 str: string; 4971 constructor(num, str) { 4972 this.num = num; 4973 this.str = str; 4974 } 4975 marshalling(messageParcel) { 4976 messageParcel.writeInt(this.num); 4977 messageParcel.writeString(this.str); 4978 return true; 4979 } 4980 unmarshalling(messageParcel) { 4981 this.num = messageParcel.readInt(); 4982 this.str = messageParcel.readString(); 4983 return true; 4984 } 4985 } 4986 let sequenceable = new MySequenceable(1, "aaa"); 4987 let sequenceable2 = new MySequenceable(2, "bbb"); 4988 let sequenceable3 = new MySequenceable(3, "ccc"); 4989 let a = [sequenceable, sequenceable2, sequenceable3]; 4990 let data = rpc.MessageParcel.create(); 4991 let result = data.writeSequenceableArray(a); 4992 console.log("RpcClient: writeSequenceableArray is " + result); 4993 let b = [new MySequenceable(0, ""), new MySequenceable(0, ""), new MySequenceable(0, "")]; 4994 data.readSequenceableArray(b); 4995 ``` 4996 4997### writeRemoteObjectArray<sup>8+</sup> 4998 4999writeRemoteObjectArray(objectArray: IRemoteObject[]): boolean 5000 5001将IRemoteObject对象数组写入MessageParcel。 5002 5003**系统能力**：SystemCapability.Communication.IPC.Core 5004 5005**参数：** 5006 5007 | 参数名 | 类型 | 必填 | 说明 | 5008 | ----------- | --------------- | ---- | ----- | 5009 | objectArray | IRemoteObject[] | 是 | 要写入MessageParcel的IRemoteObject对象数组。 | 5010 5011**返回值：** 5012 5013 | 类型 | 说明 | 5014 | ------- | -------------------------------------------------------------------------------------------------------------------- | 5015 | boolean | true：写入成功，false：写入失败。| 5016 5017**示例：** 5018 5019 ```ts 5020 class MyDeathRecipient { 5021 onRemoteDied() { 5022 console.log("server died"); 5023 } 5024 } 5025 class TestRemoteObject extends rpc.RemoteObject { 5026 constructor(descriptor) { 5027 super(descriptor); 5028 this.attachLocalInterface(this, descriptor); 5029 } 5030 addDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 5031 return true; 5032 } 5033 removeDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 5034 return true; 5035 } 5036 isObjectDead(): boolean { 5037 return false; 5038 } 5039 asObject(): rpc.IRemoteObject { 5040 return this; 5041 } 5042 } 5043 let a = [new TestRemoteObject("testObject1"), new TestRemoteObject("testObject2"), new TestRemoteObject("testObject3")]; 5044 let data = rpc.MessageParcel.create(); 5045 let result = data.writeRemoteObjectArray(a); 5046 console.log("RpcClient: writeRemoteObjectArray is " + result); 5047 ``` 5048 5049### readRemoteObjectArray<sup>8+</sup> 5050 5051readRemoteObjectArray(objects: IRemoteObject[]): void 5052 5053从MessageParcel读取IRemoteObject对象数组。 5054 5055**系统能力**：SystemCapability.Communication.IPC.Core 5056 5057**参数：** 5058 5059 | 参数名 | 类型 | 必填 | 说明 | 5060 | ------- | --------------- | ---- | --------- | 5061 | objects | IRemoteObject[] | 是 | 从MessageParcel读取的IRemoteObject对象数组。 | 5062 5063**示例：** 5064 5065 ```ts 5066 class MyDeathRecipient { 5067 onRemoteDied() { 5068 console.log("server died"); 5069 } 5070 } 5071 class TestRemoteObject extends rpc.RemoteObject { 5072 constructor(descriptor) { 5073 super(descriptor); 5074 this.attachLocalInterface(this, descriptor); 5075 } 5076 addDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 5077 return true; 5078 } 5079 removeDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 5080 return true; 5081 } 5082 isObjectDead(): boolean { 5083 return false; 5084 } 5085 asObject(): rpc.IRemoteObject { 5086 return this; 5087 } 5088 } 5089 let a = [new TestRemoteObject("testObject1"), new TestRemoteObject("testObject2"), new TestRemoteObject("testObject3")]; 5090 let data = rpc.MessageParcel.create(); 5091 let result = data.writeRemoteObjectArray(a); 5092 let b = new Array(3); 5093 data.readRemoteObjectArray(b); 5094 ``` 5095 5096### readRemoteObjectArray<sup>8+</sup> 5097 5098readRemoteObjectArray(): IRemoteObject[] 5099 5100从MessageParcel读取IRemoteObject对象数组。 5101 5102**系统能力**：SystemCapability.Communication.IPC.Core 5103 5104**返回值：** 5105 5106 | 类型 | 说明 | 5107 | --------------- | -------- | 5108 | IRemoteObject[] | 返回IRemoteObject对象数组。 | 5109 5110**示例：** 5111 5112 ```ts 5113 class MyDeathRecipient { 5114 onRemoteDied() { 5115 console.log("server died"); 5116 } 5117 } 5118 class TestRemoteObject extends rpc.RemoteObject { 5119 constructor(descriptor) { 5120 super(descriptor); 5121 this.attachLocalInterface(this, descriptor); 5122 } 5123 addDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 5124 return true; 5125 } 5126 removeDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 5127 return true; 5128 } 5129 isObjectDead(): boolean { 5130 return false; 5131 } 5132 asObject(): rpc.IRemoteObject { 5133 return this; 5134 } 5135 } 5136 let a = [new TestRemoteObject("testObject1"), new TestRemoteObject("testObject2"), new TestRemoteObject("testObject3")]; 5137 let data = rpc.MessageParcel.create(); 5138 let result = data.writeRemoteObjectArray(a); 5139 console.log("RpcClient: readRemoteObjectArray is " + result); 5140 let b = data.readRemoteObjectArray(); 5141 console.log("RpcClient: readRemoteObjectArray is " + b); 5142 ``` 5143 5144### closeFileDescriptor<sup>8+</sup> 5145 5146static closeFileDescriptor(fd: number): void 5147 5148静态方法，关闭给定的文件描述符。 5149 5150**系统能力**：SystemCapability.Communication.IPC.Core 5151 5152**参数：** 5153 5154 | 参数名 | 类型 | 必填 | 说明 | 5155 | ------ | ------ | ---- | -------------------- | 5156 | fd | number | 是 | 要关闭的文件描述符。 | 5157 5158**示例：** 5159 5160 ```ts 5161 import fileio from '@ohos.fileio'; 5162 let filePath = "path/to/file"; 5163 let fd = fileio.openSync(filePath, 0o2| 0o100, 0o666); 5164 rpc.MessageParcel.closeFileDescriptor(fd); 5165 ``` 5166 5167### dupFileDescriptor<sup>8+</sup> 5168 5169static dupFileDescriptor(fd: number) :number 5170 5171静态方法，复制给定的文件描述符。 5172 5173**系统能力**：SystemCapability.Communication.IPC.Core 5174 5175**参数：** 5176 5177 | 参数名 | 类型 | 必填 | 说明 | 5178 | ------ | ------ | ---- | ------------------------ | 5179 | fd | number | 是 | 表示已存在的文件描述符。 | 5180 5181**返回值：** 5182 5183 | 类型 | 说明 | 5184 | ------ | -------------------- | 5185 | number | 返回新的文件描述符。 | 5186 5187**示例：** 5188 5189 ```ts 5190 import fileio from '@ohos.fileio'; 5191 let filePath = "path/to/file"; 5192 let fd = fileio.openSync(filePath, 0o2| 0o100, 0o666); 5193 let newFd = rpc.MessageParcel.dupFileDescriptor(fd); 5194 ``` 5195 5196### containFileDescriptors<sup>8+</sup> 5197 5198containFileDescriptors(): boolean 5199 5200检查此MessageParcel对象是否包含文件描述符。 5201 5202**系统能力**：SystemCapability.Communication.IPC.Core 5203 5204**返回值：** 5205 5206 | 类型 | 说明 | 5207 | ------- | ------------------------------------------------------------------ | 5208 | boolean |true：包含文件描述符，false：未包含文件描述符。| 5209 5210**示例：** 5211 5212 ```ts 5213 import fileio from '@ohos.fileio'; 5214 let parcel = new rpc.MessageParcel(); 5215 let filePath = "path/to/file"; 5216 let r1 = parcel.containFileDescriptors(); 5217 let fd = fileio.openSync(filePath, 0o2| 0o100, 0o666); 5218 let writeResult = parcel.writeFileDescriptor(fd); 5219 console.log("RpcTest: parcel writeFd result is : " + writeResult); 5220 let containFD = parcel.containFileDescriptors(); 5221 console.log("RpcTest: parcel after write fd containFd result is : " + containFD); 5222 ``` 5223 5224### writeFileDescriptor<sup>8+</sup> 5225 5226writeFileDescriptor(fd: number): boolean 5227 5228写入文件描述符到MessageParcel。 5229 5230**系统能力**：SystemCapability.Communication.IPC.Core 5231 5232**参数：** 5233 5234 | 参数名 | 类型 | 必填 | 说明 | 5235 | ------ | ------ | ---- | ------------ | 5236 | fd | number | 是 | 文件描述符。 | 5237 5238**返回值：** 5239 5240 | 类型 | 说明 | 5241 | ------- | ----------------------------------------- | 5242 | boolean | true：操作成功，false：操作失败。| 5243 5244**示例：** 5245 5246 ```ts 5247 import fileio from '@ohos.fileio'; 5248 let parcel = new rpc.MessageParcel(); 5249 let filePath = "path/to/file"; 5250 let fd = fileio.openSync(filePath, 0o2| 0o100, 0o666); 5251 let writeResult = parcel.writeFileDescriptor(fd); 5252 console.log("RpcTest: parcel writeFd result is : " + writeResult); 5253 ``` 5254 5255### readFileDescriptor<sup>8+</sup> 5256 5257readFileDescriptor(): number 5258 5259从MessageParcel中读取文件描述符。 5260 5261**系统能力**：SystemCapability.Communication.IPC.Core 5262 5263**返回值：** 5264 5265 | 类型 | 说明 | 5266 | ------ | ---------------- | 5267 | number | 返回文件描述符。 | 5268 5269**示例：** 5270 5271 ```ts 5272 import fileio from '@ohos.fileio'; 5273 let parcel = new rpc.MessageParcel(); 5274 let filePath = "path/to/file"; 5275 let fd = fileio.openSync(filePath, 0o2| 0o100, 0o666); 5276 let writeResult = parcel.writeFileDescriptor(fd); 5277 let readFD = parcel.readFileDescriptor(); 5278 console.log("RpcTest: parcel read fd is : " + readFD); 5279 ``` 5280 5281### writeAshmem<sup>8+</sup> 5282 5283writeAshmem(ashmem: Ashmem): boolean 5284 5285将指定的匿名共享对象写入此MessageParcel。 5286 5287**系统能力**：SystemCapability.Communication.IPC.Core 5288 5289**参数：** 5290 5291 | 参数名 | 类型 | 必填 | 说明 | 5292 | ------ | ------ | ---- | ----------------------------------- | 5293 | ashmem | Ashmem | 是 | 要写入MessageParcel的匿名共享对象。 | 5294 5295**返回值：** 5296 5297 | 类型 | 说明 | 5298 | ------- | -------------------------------------------------------------------- | 5299 | boolean | true：写入成功，false：写入失败。| 5300 5301**示例：** 5302 5303 ```ts 5304 let parcel = new rpc.MessageParcel(); 5305 let ashmem = rpc.Ashmem.createAshmem("ashmem", 1024); 5306 let isWriteSuccess = parcel.writeAshmem(ashmem); 5307 console.log("RpcTest: write ashmem to result is : " + isWriteSuccess); 5308 ``` 5309 5310### readAshmem<sup>8+</sup> 5311 5312readAshmem(): Ashmem 5313 5314从MessageParcel读取匿名共享对象。 5315 5316**系统能力**：SystemCapability.Communication.IPC.Core 5317 5318**返回值：** 5319 5320 | 类型 | 说明 | 5321 | ------ | ------------------ | 5322 | Ashmem | 返回匿名共享对象。 | 5323 5324**示例：** 5325 5326 ```ts 5327 let parcel = new rpc.MessageParcel(); 5328 let ashmem = rpc.Ashmem.createAshmem("ashmem", 1024); 5329 let isWriteSuccess = parcel.writeAshmem(ashmem); 5330 console.log("RpcTest: write ashmem to result is : " + isWriteSuccess); 5331 let readAshmem = parcel.readAshmem(); 5332 console.log("RpcTest: read ashmem to result is : " + readAshmem); 5333 ``` 5334 5335### getRawDataCapacity<sup>8+</sup> 5336 5337getRawDataCapacity(): number 5338 5339获取MessageParcel可以容纳的最大原始数据量。 5340 5341**系统能力**：SystemCapability.Communication.IPC.Core 5342 5343**返回值：** 5344 5345 | 类型 | 说明 | 5346 | ------ | ---------------------------------------------------------- | 5347 | number | 返回MessageParcel可以容纳的最大原始数据量，即128 Mb。 | 5348 5349**示例：** 5350 5351 ```ts 5352 let parcel = new rpc.MessageParcel(); 5353 let result = parcel.getRawDataCapacity(); 5354 console.log("RpcTest: parcel get RawDataCapacity result is : " + result); 5355 ``` 5356 5357### writeRawData<sup>8+</sup> 5358 5359writeRawData(rawData: number[], size: number): boolean 5360 5361将原始数据写入MessageParcel对象。 5362 5363**系统能力**：SystemCapability.Communication.IPC.Core 5364 5365**参数：** 5366 5367 | 参数名 | 类型 | 必填 | 说明 | 5368 | ------- | -------- | ---- | ---------------------------------- | 5369 | rawData | number[] | 是 | 要写入的原始数据。 | 5370 | size | number | 是 | 发送的原始数据大小，以字节为单位。 | 5371 5372**返回值：** 5373 5374 | 类型 | 说明 | 5375 | ------- | ----------------------------------------- | 5376 | boolean | true：写入成功，false：写入失败。| 5377 5378**示例：** 5379 5380 ```ts 5381 let parcel = new rpc.MessageParcel(); 5382 let arr = [1, 2, 3, 4, 5]; 5383 let isWriteSuccess = parcel.writeRawData(arr, arr.length); 5384 console.log("RpcTest: parcel write raw data result is : " + isWriteSuccess); 5385 ``` 5386 5387### readRawData<sup>8+</sup> 5388 5389readRawData(size: number): number[] 5390 5391从MessageParcel读取原始数据。 5392 5393**系统能力**：SystemCapability.Communication.IPC.Core 5394 5395**参数：** 5396 5397 | 参数名 | 类型 | 必填 | 说明 | 5398 | ------ | ------ | ---- | ------------------------ | 5399 | size | number | 是 | 要读取的原始数据的大小。 | 5400 5401**返回值：** 5402 5403 | 类型 | 说明 | 5404 | -------- | ------------------------------ | 5405 | number[] | 返回原始数据（以字节为单位）。 | 5406 5407**示例：** 5408 5409 ```ts 5410 let parcel = new rpc.MessageParcel(); 5411 let arr = [1, 2, 3, 4, 5]; 5412 let isWriteSuccess = parcel.writeRawData(arr, arr.length); 5413 console.log("RpcTest: parcel write raw data result is : " + isWriteSuccess); 5414 let result = parcel.readRawData(5); 5415 console.log("RpcTest: parcel read raw data result is : " + result); 5416 ``` 5417 5418## Parcelable<sup>9+</sup> 5419 5420在进程间通信（IPC）期间，将类的对象写入MessageSequence并从MessageSequence中恢复它们。 5421 5422### marshalling 5423 5424marshalling(dataOut: MessageSequence): boolean 5425 5426将此可序列对象封送到MessageSequence中。 5427 5428**系统能力**：SystemCapability.Communication.IPC.Core 5429 5430**参数：** 5431 5432 | 参数名 | 类型 | 必填 | 说明 | 5433 | ------- | --------------- | ---- | ------------------------------------------- | 5434 | dataOut | MessageSequence | 是 | 可序列对象将被封送到的MessageSequence对象。 | 5435 5436**返回值：** 5437 5438 | 类型 | 说明 | 5439 | ------- | ----------------------------------------- | 5440 | boolean | true：封送成功，false：封送失败。 5441**示例：** 5442 5443 ```ts 5444 class MyParcelable { 5445 num: number; 5446 str: string; 5447 constructor(num, str) { 5448 this.num = num; 5449 this.str = str; 5450 } 5451 marshalling(messageSequence) { 5452 messageSequence.writeInt(this.num); 5453 messageSequence.writeString(this.str); 5454 return true; 5455 } 5456 unmarshalling(messageSequence) { 5457 this.num = messageSequence.readInt(); 5458 this.str = messageSequence.readString(); 5459 return true; 5460 } 5461 } 5462 let parcelable = new MyParcelable(1, "aaa"); 5463 let data = rpc.MessageSequence.create(); 5464 let result = data.writeParcelable(parcelable); 5465 console.log("RpcClient: writeParcelable is " + result); 5466 let ret = new MyParcelable(0, ""); 5467 let result2 = data.readParcelable(ret); 5468 console.log("RpcClient: readParcelable is " + result2); 5469 ``` 5470 5471### unmarshalling 5472 5473unmarshalling(dataIn: MessageSequence): boolean 5474 5475从MessageSequence中解封此可序列对象。 5476 5477**系统能力**：SystemCapability.Communication.IPC.Core 5478 5479**参数：** 5480 5481 | 参数名 | 类型 | 必填 | 说明 | 5482 | ------ | --------------- | ---- | ----------------------------------------------- | 5483 | dataIn | MessageSequence | 是 | 已将可序列对象封送到其中的MessageSequence对象。 | 5484 5485**返回值：** 5486 5487 | 类型 | 说明 | 5488 | ------- | --------------------------------------------- | 5489 | boolean | true：反序列化成功，false：反序列化失败。| 5490 5491**示例：** 5492 5493 ```ts 5494 class MyParcelable { 5495 num: number; 5496 str: string; 5497 constructor(num, str) { 5498 this.num = num; 5499 this.str = str; 5500 } 5501 marshalling(messageSequence) { 5502 messageSequence.writeInt(this.num); 5503 messageSequence.writeString(this.str); 5504 return true; 5505 } 5506 unmarshalling(messageSequence) { 5507 this.num = messageSequence.readInt(); 5508 this.str = messageSequence.readString(); 5509 return true; 5510 } 5511 } 5512 let parcelable = new MyParcelable(1, "aaa"); 5513 let data = rpc.MessageSequence.create(); 5514 let result = data.writeParcelable(parcelable); 5515 console.log("RpcClient: writeParcelable is " + result); 5516 let ret = new MyParcelable(0, ""); 5517 let result2 = data.readParcelable(ret); 5518 console.log("RpcClient: readParcelable is " + result2); 5519 ``` 5520 5521## Sequenceable<sup>(deprecated)</sup> 5522 5523>从API version 9 开始不再维护，建议使用[Parcelable](#parcelable9)类替代。 5524 5525在进程间通信（IPC）期间，将类的对象写入MessageParcel并从MessageParcel中恢复它们。 5526 5527### marshalling 5528 5529marshalling(dataOut: MessageParcel): boolean 5530 5531将此可序列对象封送到MessageParcel中。 5532 5533**系统能力**：SystemCapability.Communication.IPC.Core 5534 5535**参数：** 5536 5537 | 参数名 | 类型 | 必填 | 说明 | 5538 | ------- | ------------------------------- | ---- | ----------------------------------------- | 5539 | dataOut | [MessageParcel](#messageparceldeprecated) | 是 | 可序列对象将被封送到的MessageParcel对象。 | 5540 5541**返回值：** 5542 5543 | 类型 | 说明 | 5544 | ------- | ----------------------------------------- | 5545 | boolean | true：封送成功，false：封送失败。 5546**示例：** 5547 5548 ```ts 5549 class MySequenceable { 5550 num: number; 5551 str: string; 5552 constructor(num, str) { 5553 this.num = num; 5554 this.str = str; 5555 } 5556 marshalling(messageParcel) { 5557 messageParcel.writeInt(this.num); 5558 messageParcel.writeString(this.str); 5559 return true; 5560 } 5561 unmarshalling(messageParcel) { 5562 this.num = messageParcel.readInt(); 5563 this.str = messageParcel.readString(); 5564 return true; 5565 } 5566 } 5567 let sequenceable = new MySequenceable(1, "aaa"); 5568 let data = rpc.MessageParcel.create(); 5569 let result = data.writeSequenceable(sequenceable); 5570 console.log("RpcClient: writeSequenceable is " + result); 5571 let ret = new MySequenceable(0, ""); 5572 let result2 = data.readSequenceable(ret); 5573 console.log("RpcClient: readSequenceable is " + result2); 5574 ``` 5575 5576### unmarshalling 5577 5578unmarshalling(dataIn: MessageParcel): boolean 5579 5580从MessageParcel中解封此可序列对象。 5581 5582**系统能力**：SystemCapability.Communication.IPC.Core 5583 5584**参数：** 5585 5586 | 参数名 | 类型 | 必填 | 说明 | 5587 | ------ | ------------------------------- | ---- | --------------------------------------------- | 5588 | dataIn | [MessageParcel](#messageparceldeprecated) | 是 | 已将可序列对象封送到其中的MessageParcel对象。 | 5589 5590**返回值：** 5591 5592 | 类型 | 说明 | 5593 | ------- | --------------------------------------------- | 5594 | boolean | true：反序列化成功，false：反序列化失败。| 5595 5596**示例：** 5597 5598 ```ts 5599 class MySequenceable { 5600 num: number; 5601 str: string; 5602 constructor(num, str) { 5603 this.num = num; 5604 this.str = str; 5605 } 5606 marshalling(messageParcel) { 5607 messageParcel.writeInt(this.num); 5608 messageParcel.writeString(this.str); 5609 return true; 5610 } 5611 unmarshalling(messageParcel) { 5612 this.num = messageParcel.readInt(); 5613 this.str = messageParcel.readString(); 5614 return true; 5615 } 5616 } 5617 let sequenceable = new MySequenceable(1, "aaa"); 5618 let data = rpc.MessageParcel.create(); 5619 let result = data.writeSequenceable(sequenceable); 5620 console.log("RpcClient: writeSequenceable is " + result); 5621 let ret = new MySequenceable(0, ""); 5622 let result2 = data.readSequenceable(ret); 5623 console.log("RpcClient: readSequenceable is " + result2); 5624 ``` 5625 5626## IRemoteBroker 5627 5628远端对象的代理持有者。用于获取代理对象。 5629 5630### asObject 5631 5632asObject(): IRemoteObject 5633 5634需派生类实现，获取代理或远端对象。 5635 5636**系统能力**：SystemCapability.Communication.IPC.Core 5637 5638**返回值：** 5639 5640 | 类型 | 说明 | 5641 | ---- | ----- | 5642 | [IRemoteObject](#iremoteobject) | 如果调用者是RemoteObject对象，则直接返回本身；如果调用者是[RemoteProxy](#remoteproxy)对象，则返回它的持有者[IRemoteObject](#iremoteobject)。 | 5643 5644**示例：** 5645 5646 ```ts 5647 class TestAbility extends rpc.RemoteObject { 5648 asObject() { 5649 return this; 5650 } 5651 } 5652 let remoteObject = new TestAbility("testObject").asObject(); 5653 ``` 5654 5655**示例：** 5656 5657 获取服务 5658 5659 ```ts 5660 import FA from "@ohos.ability.featureAbility"; 5661 let proxy; 5662 let connect = { 5663 onConnect: function (elementName, remoteProxy) { 5664 console.log("RpcClient: js onConnect called."); 5665 proxy = remoteProxy; 5666 }, 5667 onDisconnect: function (elementName) { 5668 console.log("RpcClient: onDisconnect"); 5669 }, 5670 onFailed: function () { 5671 console.log("RpcClient: onFailed"); 5672 } 5673 }; 5674 let want = { 5675 "bundleName": "com.ohos.server", 5676 "abilityName": "com.ohos.server.MainAbility", 5677 }; 5678 FA.connectAbility(want, connect); 5679 ``` 5680 5681 上述onConnect回调函数中的proxy对象需要等ability异步连接成功后才会被赋值，然后才可调用proxy对象的asObject接口方法获取代理或远端对象 5682 5683 ```ts 5684 class TestProxy { 5685 remote: rpc.RemoteObject; 5686 constructor(remote) { 5687 this.remote = remote; 5688 } 5689 asObject() { 5690 return this.remote; 5691 } 5692 } 5693 let iRemoteObject = new TestProxy(proxy).asObject(); 5694 5695 ``` 5696 5697## DeathRecipient 5698 5699用于订阅远端对象的死亡通知。当被订阅该通知的远端对象死亡时，本端可收到消息，调用[onRemoteDied](#onremotedied)接口。远端对象死亡可以为远端对象所在进程死亡，远端对象所在设备关机或重启，当远端对象与本端对象属于不同设备时，也可为远端对象离开组网时。 5700 5701### onRemoteDied 5702 5703onRemoteDied(): void 5704 5705在成功添加死亡通知订阅后，当远端对象死亡时，将自动调用本方法。 5706 5707**系统能力**：SystemCapability.Communication.IPC.Core 5708 5709**示例：** 5710 5711 ```ts 5712 class MyDeathRecipient { 5713 onRemoteDied() { 5714 console.log("server died"); 5715 } 5716 } 5717 ``` 5718 5719## RequestResult<sup>9+</sup> 5720 5721发送请求的响应结果。 5722 5723**系统能力**：以下各项对应的系统能力均为SystemCapability.Communication.IPC.Core。 5724 5725 | 名称 | 类型 | 可读 | 可写 | 说明 | 5726 | ------- | --------------- | ---- | ---- |-------------------------------------- | 5727 | errCode | number | 是 | 否 | 错误码。 | 5728 | code | number | 是 | 否 | 消息代码。 | 5729 | data | MessageSequence | 是 | 否 | 发送给对端进程的MessageSequence对象。 | 5730 | reply | MessageSequence | 是 | 否 | 对端进程返回的MessageSequence对象。 | 5731 5732## SendRequestResult<sup>8+(deprecated)</sup> 5733 5734>从API version 9 开始不再维护，建议使用[RequestResult](#requestresult9)类替代。 5735 5736发送请求的响应结果。 5737 5738**系统能力**：以下各项对应的系统能力均为SystemCapability.Communication.IPC.Core。 5739 5740 | 名称 | 类型 | 可读 | 可写 | 说明 | 5741 | ------- | ------------- | ---- | ---- | ----------------------------------- | 5742 | errCode | number | 是 | 否 | 错误码。 | 5743 | code | number | 是 | 否 | 消息代码。 | 5744 | data | MessageParcel | 是 | 否 | 发送给对端进程的MessageParcel对象。 | 5745 | reply | MessageParcel | 是 | 否 | 对端进程返回的MessageParcel对象。 | 5746 5747## IRemoteObject 5748 5749该接口可用于查询或获取接口描述符、添加或删除死亡通知、转储对象状态到特定文件、发送消息。 5750 5751### getLocalInterface<sup>9+</sup> 5752 5753getLocalInterface(descriptor: string): IRemoteBroker 5754 5755查询接口描述符的字符串。 5756 5757**系统能力**：SystemCapability.Communication.IPC.Core 5758 5759**参数：** 5760 5761 | 参数名 | 类型 | 必填 | 说明 | 5762 | ---------- | ------ | ---- | -------------------- | 5763 | descriptor | string | 是 | 接口描述符的字符串。 | 5764 5765**返回值：** 5766 5767 | 类型 | 说明 | 5768 | ------------- | --------------------------------------------- | 5769 | IRemoteBroker | 返回绑定到指定接口描述符的IRemoteBroker对象。 | 5770 5771### queryLocalInterface<sup>(deprecated)</sup> 5772 5773>从API version 9 开始不再维护，建议使用[getLocalInterface](#getlocalinterface9)类替代。 5774 5775queryLocalInterface(descriptor: string): IRemoteBroker 5776 5777查询接口描述符的字符串。 5778 5779**系统能力**：SystemCapability.Communication.IPC.Core 5780 5781**参数：** 5782 5783 | 参数名 | 类型 | 必填 | 说明 | 5784 | ---------- | ------ | ---- | -------------------- | 5785 | descriptor | string | 是 | 接口描述符的字符串。 | 5786 5787**返回值：** 5788 5789 | 类型 | 说明 | 5790 | ------------- | --------------------------------------------- | 5791 | IRemoteBroker | 返回绑定到指定接口描述符的IRemoteBroker对象。 | 5792 5793### sendRequest<sup>(deprecated)</sup> 5794 5795>从API version 9 开始不再维护，建议使用[sendMessageRequest](#sendmessagerequest9)类替代。 5796 5797sendRequest(code: number, data: MessageParcel, reply: MessageParcel, options: MessageOption): boolean 5798 5799以同步或异步方式向对端进程发送MessageParcel消息。如果为选项设置了异步模式，则期约立即兑现，reply报文里没有内容。如果为选项设置了同步模式，则期约将在sendRequest返回时兑现，回复内容在reply报文里。 5800 5801**系统能力**：SystemCapability.Communication.IPC.Core 5802 5803**参数：** 5804 5805 | 参数名 | 类型 | 必填 | 说明 | 5806 | ------- | ------------------------------- | ---- | ---- | 5807 | code | number | 是 | 本次请求调用的消息码，由通信双方确定。如果接口由IDL工具生成，则消息代码由IDL自动生成。 | 5808 | data | [MessageParcel](#messageparceldeprecated) | 是 | 保存待发送数据的 MessageParcel对象。 | 5809 | reply | [MessageParcel](#messageparceldeprecated) | 是 | 接收应答数据的MessageParcel对象。 | 5810 | options | [MessageOption](#messageoption) | 是 | 本次请求的同异步模式，默认同步调用。 | 5811 5812**返回值：** 5813 5814 | 类型 | 说明 | 5815 | ------- | --------------------------------------------- | 5816 | boolean | true：发送成功，false：发送失败。| 5817 5818 5819### sendRequest<sup>8+(deprecated)</sup> 5820 5821>从API version 9 开始不再维护，建议使用[sendMessageRequest](#sendmessagerequest9)类替代。 5822 5823sendRequest(code: number, data: MessageParcel, reply: MessageParcel, options: MessageOption): Promise<SendRequestResult> 5824 5825以同步或异步方式向对端进程发送MessageParcel消息。如果为选项设置了异步模式，则期约立即兑现，reply报文里没有内容，具体回复需要在业务侧的回调中获取。如果为选项设置了同步模式，则期约将在sendRequest返回时兑现，回复内容在reply报文里。 5826 5827**系统能力**：SystemCapability.Communication.IPC.Core 5828 5829**参数：** 5830 5831 | 参数名 | 类型 | 必填 | 说明 | 5832 | ------- | ------------------------------- | ---- | -------------------------------------------------------------------------------------- | 5833 | code | number | 是 | 本次请求调用的消息码，由通信双方确定。如果接口由IDL工具生成，则消息代码由IDL自动生成。 | 5834 | data | [MessageParcel](#messageparceldeprecated) | 是 | 保存待发送数据的 MessageParcel对象。 | 5835 | reply | [MessageParcel](#messageparceldeprecated) | 是 | 接收应答数据的MessageParcel对象。 | 5836 | options | [MessageOption](#messageoption) | 是 | 本次请求的同异步模式，默认同步调用。 | 5837 5838**返回值：** 5839 5840 | 类型 | 说明 | 5841 | -------------------------------- | --------------------------------------------- | 5842 | Promise<SendRequestResult> | 返回一个期约，兑现值是sendRequestResult实例。 | 5843 5844 5845### sendMessageRequest<sup>9+</sup> 5846 5847sendMessageRequest(code: number, data: MessageSequence, reply: MessageSequence, options: MessageOption): Promise<RequestResult> 5848 5849以同步或异步方式向对端进程发送MessageSequence消息。如果为选项设置了异步模式，则期约立即兑现，reply报文里没有内容，具体回复需要在业务侧的回调中获取。如果为选项设置了同步模式，则期约将在sendMessageRequest返回时兑现，回复内容在reply报文里。 5850 5851**系统能力**：SystemCapability.Communication.IPC.Core 5852 5853**参数：** 5854 5855 | 参数名 | 类型 | 必填 | 说明 | 5856 | ------- | ------------------------------- | ---- | -------------------------------------------------------------------------------------- | 5857 | code | number | 是 | 本次请求调用的消息码，由通信双方确定。如果接口由IDL工具生成，则消息代码由IDL自动生成。 | 5858 | data | [MessageSequence](#messagesequence9) | 是 | 保存待发送数据的 MessageSequence对象。 | 5859 | reply | [MessageSequence](#messagesequence9) | 是 | 接收应答数据的MessageSequence对象。 | 5860 | options | [MessageOption](#messageoption) | 是 | 本次请求的同异步模式，默认同步调用。 | 5861 5862**返回值：** 5863 5864 | 类型 | 说明 | 5865 | ---------------------------- | ----------------------------------------- | 5866 | Promise<RequestResult> | 返回一个期约，兑现值是requestResult实例。 | 5867 5868 5869### sendMessageRequest<sup>9+</sup> 5870 5871sendMessageRequest(code: number, data: MessageSequence, reply: MessageSequence, options: MessageOption, callback: AsyncCallback<RequestResult>): void 5872 5873以同步或异步方式向对端进程发送MessageSequence消息。如果为选项设置了异步模式，则立即收到回调，reply报文里没有内容，具体回复需要在业务侧的回调中获取。如果为选项设置了同步模式，则将在sendRequest返回时收到回调，回复内容在reply报文里。 5874 5875**系统能力**：SystemCapability.Communication.IPC.Core 5876 5877**参数：** 5878 5879 | 参数名 | 类型 | 必填 | 说明 | 5880 | -------- | ---------------------------------- | ---- | -------------------------------------------------------------------------------------- | 5881 | code | number | 是 | 本次请求调用的消息码，由通信双方确定。如果接口由IDL工具生成，则消息代码由IDL自动生成。 | 5882 | data | [MessageSequence](#messagesequence9) | 是 | 保存待发送数据的 MessageSequence对象。 | 5883 | reply | [MessageSequence](#messagesequence9) | 是 | 接收应答数据的MessageSequence对象。 | 5884 | options | [MessageOption](#messageoption) | 是 | 本次请求的同异步模式，默认同步调用。 | 5885 | callback | AsyncCallback<RequestResult> | 是 | 接收发送结果的回调。 | 5886 5887### sendRequest<sup>8+(deprecated)</sup> 5888 5889>从API version 9 开始不再维护，建议使用[sendMessageRequest](#sendmessagerequest9)类替代。 5890 5891sendRequest(code: number, data: MessageParcel, reply: MessageParcel, options: MessageOption, callback: AsyncCallback<SendRequestResult>): void 5892 5893以同步或异步方式向对端进程发送MessageParcel消息。如果为选项设置了异步模式，则立即收到回调，reply报文里没有内容，具体回复需要在业务侧的回调中获取。如果为选项设置了同步模式，则将在sendRequest返回时收到回调，回复内容在reply报文里。 5894 5895**系统能力**：SystemCapability.Communication.IPC.Core 5896 5897**参数：** 5898 5899 | 参数名 | 类型 | 必填 | 说明 | 5900 | -------- | -------------------------------------- | ---- | -------------------------------------------------------------------------------------- | 5901 | code | number | 是 | 本次请求调用的消息码，由通信双方确定。如果接口由IDL工具生成，则消息代码由IDL自动生成。 | 5902 | data | [MessageParcel](#messageparceldeprecated) | 是 | 保存待发送数据的 MessageParcel对象。 | 5903 | reply | [MessageParcel](#messageparceldeprecated) | 是 | 接收应答数据的MessageParcel对象。 | 5904 | options | [MessageOption](#messageoption) | 是 | 本次请求的同异步模式，默认同步调用。 | 5905 | callback | AsyncCallback<SendRequestResult> | 是 | 接收发送结果的回调。 | 5906 5907### registerDeathRecipient<sup>9+</sup> 5908 5909registerDeathRecipient(recipient: DeathRecipient, flags: number): void 5910 5911注册用于接收远程对象死亡通知的回调。如果与RemoteProxy对象匹配的远程对象进程死亡，则调用此方法。 5912 5913**系统能力**：SystemCapability.Communication.IPC.Core 5914 5915**参数：** 5916 5917 | 参数名 | 类型 | 必填 | 说明 | 5918 | --------- | --------------------------------- | ---- | -------------- | 5919 | recipient | [DeathRecipient](#deathrecipient) | 是 | 要注册的回调。 | 5920 | flags | number | 是 | 死亡通知标志。 | 5921 5922**错误码：** 5923 5924以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 5925 5926 | 错误码ID | 错误信息 | 5927 | ------- | -------- | 5928 | 1900008 | proxy or remote object is invalid | 5929 5930### addDeathrecipient<sup>(deprecated)</sup> 5931 5932>从API version 9 开始不再维护，建议使用[registerDeathRecipient](#registerdeathrecipient9)类替代。 5933 5934addDeathRecipient(recipient: DeathRecipient, flags: number): boolean 5935 5936注册用于接收远程对象死亡通知的回调。如果与RemoteProxy对象匹配的远程对象进程死亡，则调用此方法。 5937 5938**系统能力**：SystemCapability.Communication.IPC.Core 5939 5940**参数：** 5941 5942 | 参数名 | 类型 | 必填 | 说明 | 5943 | --------- | --------------------------------- | ---- | -------------- | 5944 | recipient | [DeathRecipient](#deathrecipient) | 是 | 要注册的回调。 | 5945 | flags | number | 是 | 死亡通知标志。 | 5946 5947**返回值：** 5948 5949 | 类型 | 说明 | 5950 | ------- | --------------------------------------------- | 5951 | boolean | true：回调注册成功，false：回调注册失败。| 5952 5953 5954### unregisterDeathRecipient<sup>9+</sup> 5955 5956unregisterDeathRecipient(recipient: DeathRecipient, flags: number): void 5957 5958注销用于接收远程对象死亡通知的回调。 5959 5960**系统能力**：SystemCapability.Communication.IPC.Core 5961 5962**参数：** 5963 5964 | 参数名 | 类型 | 必填 | 说明 | 5965 | --------- | --------------------------------- | ---- | -------------- | 5966 | recipient | [DeathRecipient](#deathrecipient) | 是 | 要注销的回调。 | 5967 | flags | number | 是 | 死亡通知标志。 | 5968 5969**错误码：** 5970 5971以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 5972 5973 | 错误码ID | 错误信息 | 5974 | ------- | -------- | 5975 | 1900008 | proxy or remote object is invalid | 5976 5977### removeDeathRecipient<sup>(deprecated)</sup> 5978 5979>从API version 9 开始不再维护，建议使用[unregisterDeathRecipient](#unregisterdeathrecipient9)类替代。 5980 5981removeDeathRecipient(recipient: DeathRecipient, flags: number): boolean 5982 5983注销用于接收远程对象死亡通知的回调。 5984 5985**系统能力**：SystemCapability.Communication.IPC.Core 5986 5987**参数：** 5988 5989 | 参数名 | 类型 | 必填 | 说明 | 5990 | --------- | --------------------------------- | ---- | -------------- | 5991 | recipient | [DeathRecipient](#deathrecipient) | 是 | 要注销的回调。 | 5992 | flags | number | 是 | 死亡通知标志。 | 5993 5994**返回值：** 5995 5996 | 类型 | 说明 | 5997 | ------- | --------------------------------------------- | 5998 | boolean | true：回调注销成功，false：回调注销失败。| 5999 6000### getDescriptor<sup>9+</sup> 6001 6002getDescriptor(): string 6003 6004获取对象的接口描述符，接口描述符为字符串。 6005 6006**系统能力**：SystemCapability.Communication.IPC.Core 6007 6008**返回值：** 6009 6010 | 类型 | 说明 | 6011 | ------ | ---------------- | 6012 | string | 返回接口描述符。 | 6013 6014**错误码：** 6015 6016以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 6017 6018 | 错误码ID | 错误信息 | 6019 | ------- | -------- | 6020 | 1900008 | proxy or remote object is invalid | 6021 6022 6023### getInterfaceDescriptor<sup>(deprecated)</sup> 6024 6025>从API version 9 开始不再维护，建议使用[getDescriptor](#getdescriptor9)类替代。 6026 6027getInterfaceDescriptor(): string 6028 6029获取对象的接口描述符，接口描述符为字符串。 6030 6031**系统能力**：SystemCapability.Communication.IPC.Core 6032 6033**返回值：** 6034 6035 | 类型 | 说明 | 6036 | ------ | ---------------- | 6037 | string | 返回接口描述符。 | 6038 6039 6040### isObjectDead 6041 6042isObjectDead(): boolean 6043 6044检查当前对象是否死亡。 6045 6046**系统能力**：SystemCapability.Communication.IPC.Core 6047 6048**返回值：** 6049 6050 | 类型 | 说明 | 6051 | ------- | ------------------------------------------- | 6052 | boolean | true：对象死亡，false：对象未死亡。| 6053 6054 6055## RemoteProxy 6056 6057实现IRemoteObject代理对象。 6058 6059**系统能力**：以下各项对应的系统能力均为SystemCapability.Communication.IPC.Core。 6060 6061| 名称 | 值 | 说明 | 6062| --------------------- | ----------------------- | --------------------------------- | 6063| PING_TRANSACTION | 1599098439 (0x5f504e47) | 内部指令码，用于测试IPC服务正常。 | 6064| DUMP_TRANSACTION | 1598311760 (0x5f444d50) | 内部指令码，获取Binder内部状态。 | 6065| INTERFACE_TRANSACTION | 1598968902 (0x5f4e5446) | 内部指令码，获取对端接口描述符。 | 6066| MIN_TRANSACTION_ID | 1 (0x00000001) | 最小有效指令码。 | 6067| MAX_TRANSACTION_ID | 16777215 (0x00FFFFFF) | 最大有效指令码。 | 6068 6069### sendRequest<sup>(deprecated)</sup> 6070 6071>从API version 9 开始不再维护，建议使用[sendMessageRequest](#sendmessagerequest9)类替代。 6072 6073sendRequest(code: number, data: MessageParcel, reply: MessageParcel, options: MessageOption): boolean 6074 6075以同步或异步方式向对端进程发送MessageParcel消息。如果为选项设置了异步模式，则期约立即兑现，reply报文里没有内容，具体回复需要在业务侧的回调中获取。如果为选项设置了同步模式，则期约将在sendRequest返回时兑现，回复内容在reply报文里。 6076 6077**系统能力**：SystemCapability.Communication.IPC.Core 6078 6079**参数：** 6080 6081 | 参数名 | 类型 | 必填 | 说明 | 6082 | ------- | ------------------------------- | ---- | -------------------------------------------------------------------------------------- | 6083 | code | number | 是 | 本次请求调用的消息码，由通信双方确定。如果接口由IDL工具生成，则消息代码由IDL自动生成。 | 6084 | data | [MessageParcel](#messageparceldeprecated) | 是 | 保存待发送数据的 MessageParcel对象。 | 6085 | reply | [MessageParcel](#messageparceldeprecated) | 是 | 接收应答数据的MessageParcel对象。 | 6086 | options | [MessageOption](#messageoption) | 是 | 本次请求的同异步模式，默认同步调用。 | 6087 6088**返回值：** 6089 6090 | 类型 | 说明 | 6091 | ------- | --------------------------------------------- | 6092 | boolean | true：发送成功，false：发送失败。| 6093 6094**示例：** 6095 6096 获取服务 6097 6098 ```ts 6099 import FA from "@ohos.ability.featureAbility"; 6100 let proxy; 6101 let connect = { 6102 onConnect: function(elementName, remoteProxy) { 6103 console.log("RpcClient: js onConnect called."); 6104 proxy = remoteProxy; 6105 }, 6106 onDisconnect: function(elementName) { 6107 console.log("RpcClient: onDisconnect"); 6108 }, 6109 onFailed: function() { 6110 console.log("RpcClient: onFailed"); 6111 } 6112 }; 6113 let want = { 6114 "bundleName": "com.ohos.server", 6115 "abilityName": "com.ohos.server.MainAbility", 6116 }; 6117 FA.connectAbility(want, connect); 6118 ``` 6119 6120 上述onConnect回调函数中的proxy对象需要等ability异步连接成功后才会被赋值，然后才可调用proxy对象的sendRequest接口方法发送消息 6121 6122 ```ts 6123 let option = new rpc.MessageOption(); 6124 let data = rpc.MessageParcel.create(); 6125 let reply = rpc.MessageParcel.create(); 6126 data.writeInt(1); 6127 data.writeString("hello"); 6128 let ret: boolean = proxy.sendRequest(1, data, reply, option); 6129 if (ret) { 6130 console.log("sendRequest got result"); 6131 let msg = reply.readString(); 6132 console.log("RPCTest: reply msg: " + msg); 6133 } else { 6134 console.log("RPCTest: sendRequest failed"); 6135 } 6136 console.log("RPCTest: sendRequest ends, reclaim parcel"); 6137 data.reclaim(); 6138 reply.reclaim(); 6139 ``` 6140 6141### sendMessageRequest<sup>9+</sup> 6142 6143sendMessageRequest(code: number, data: MessageSequence, reply: MessageSequence, options: MessageOption): Promise<RequestResult> 6144 6145以同步或异步方式向对端进程发送MessageSequence消息。如果为选项设置了异步模式，则期约立即兑现，reply报文里没有内容，具体回复需要在业务侧的回调中获取。如果为选项设置了同步模式，则期约将在sendMessageRequest返回时兑现，回复内容在reply报文里。 6146 6147**系统能力**：SystemCapability.Communication.IPC.Core 6148 6149**参数：** 6150 6151 | 参数名 | 类型 | 必填 | 说明 | 6152 | ------- | ------------------------------- | ---- | -------------------------------------------------------------------------------------- | 6153 | code | number | 是 | 本次请求调用的消息码，由通信双方确定。如果接口由IDL工具生成，则消息代码由IDL自动生成。 | 6154 | data | [MessageSequence](#messagesequence9) | 是 | 保存待发送数据的 MessageSequence对象。 | 6155 | reply | [MessageSequence](#messagesequence9) | 是 | 接收应答数据的MessageSequence对象。 | 6156 | options | [MessageOption](#messageoption) | 是 | 本次请求的同异步模式，默认同步调用。 | 6157 6158**返回值：** 6159 6160 | 类型 | 说明 | 6161 | ---------------------------- | ----------------------------------------- | 6162 | Promise<RequestResult> | 返回一个期约，兑现值是requestResult实例。 | 6163 6164**示例：** 6165 6166 获取服务 6167 6168 ```ts 6169 import FA from "@ohos.ability.featureAbility"; 6170 let proxy; 6171 let connect = { 6172 onConnect: function(elementName, remoteProxy) { 6173 console.log("RpcClient: js onConnect called."); 6174 proxy = remoteProxy; 6175 }, 6176 onDisconnect: function(elementName) { 6177 console.log("RpcClient: onDisconnect"); 6178 }, 6179 onFailed: function() { 6180 console.log("RpcClient: onFailed"); 6181 } 6182 }; 6183 let want = { 6184 "bundleName": "com.ohos.server", 6185 "abilityName": "com.ohos.server.MainAbility", 6186 }; 6187 FA.connectAbility(want, connect); 6188 ``` 6189 6190 上述onConnect回调函数中的proxy对象需要等ability异步连接成功后才会被赋值，然后才可调用proxy对象的sendMessageRequest接口方法发送消息 6191 6192 ```ts 6193 let option = new rpc.MessageOption(); 6194 let data = rpc.MessageSequence.create(); 6195 let reply = rpc.MessageSequence.create(); 6196 data.writeInt(1); 6197 data.writeString("hello"); 6198 proxy.sendMessageRequest(1, data, reply, option) 6199 .then(function(result) { 6200 if (result.errCode === 0) { 6201 console.log("sendMessageRequest got result"); 6202 result.reply.readException(); 6203 let msg = result.reply.readString(); 6204 console.log("RPCTest: reply msg: " + msg); 6205 } else { 6206 console.log("RPCTest: sendMessageRequest failed, errCode: " + result.errCode); 6207 } 6208 }).catch(function(e) { 6209 console.log("RPCTest: sendMessageRequest got exception: " + e.message); 6210 }).finally (() => { 6211 console.log("RPCTest: sendMessageRequest ends, reclaim parcel"); 6212 data.reclaim(); 6213 reply.reclaim(); 6214 }); 6215 ``` 6216 6217### sendRequest<sup>8+(deprecated)</sup> 6218 6219>从API version 9 开始不再维护，建议使用[sendMessageRequest](#sendmessagerequest9)类替代。 6220 6221sendRequest(code: number, data: MessageParcel, reply: MessageParcel, options: MessageOption): Promise<SendRequestResult> 6222 6223以同步或异步方式向对端进程发送MessageParcel消息。如果为选项设置了异步模式，则期约立即兑现，reply报文里没有内容，具体回复需要在业务侧的回调中获取。如果为选项设置了同步模式，则期约将在sendRequest返回时兑现，回复内容在reply报文里。 6224 6225**系统能力**：SystemCapability.Communication.IPC.Core 6226 6227**参数：** 6228 6229 | 参数名 | 类型 | 必填 | 说明 | 6230 | ------- | ------------------------------- | ---- | -------------------------------------------------------------------------------------- | 6231 | code | number | 是 | 本次请求调用的消息码，由通信双方确定。如果接口由IDL工具生成，则消息代码由IDL自动生成。 | 6232 | data | [MessageParcel](#messageparceldeprecated) | 是 | 保存待发送数据的 MessageParcel对象。 | 6233 | reply | [MessageParcel](#messageparceldeprecated) | 是 | 接收应答数据的MessageParcel对象。 | 6234 | options | [MessageOption](#messageoption) | 是 | 本次请求的同异步模式，默认同步调用。 | 6235 6236**返回值：** 6237 6238 | 类型 | 说明 | 6239 | -------------------------------- | --------------------------------------------- | 6240 | Promise<SendRequestResult> | 返回一个期约，兑现值是sendRequestResult实例。 | 6241 6242**示例：** 6243 6244 获取服务 6245 6246 ```ts 6247 import FA from "@ohos.ability.featureAbility"; 6248 let proxy; 6249 let connect = { 6250 onConnect: function(elementName, remoteProxy) { 6251 console.log("RpcClient: js onConnect called."); 6252 proxy = remoteProxy; 6253 }, 6254 onDisconnect: function(elementName) { 6255 console.log("RpcClient: onDisconnect"); 6256 }, 6257 onFailed: function() { 6258 console.log("RpcClient: onFailed"); 6259 } 6260 }; 6261 let want = { 6262 "bundleName": "com.ohos.server", 6263 "abilityName": "com.ohos.server.MainAbility", 6264 }; 6265 FA.connectAbility(want, connect); 6266 ``` 6267 6268 上述onConnect回调函数中的proxy对象需要等ability异步连接成功后才会被赋值，然后才可调用proxy对象的sendRequest接口方法发送消息 6269 6270 ```ts 6271 let option = new rpc.MessageOption(); 6272 let data = rpc.MessageParcel.create(); 6273 let reply = rpc.MessageParcel.create(); 6274 data.writeInt(1); 6275 data.writeString("hello"); 6276 proxy.sendRequest(1, data, reply, option) 6277 .then(function(result) { 6278 if (result.errCode === 0) { 6279 console.log("sendRequest got result"); 6280 result.reply.readException(); 6281 let msg = result.reply.readString(); 6282 console.log("RPCTest: reply msg: " + msg); 6283 } else { 6284 console.log("RPCTest: sendRequest failed, errCode: " + result.errCode); 6285 } 6286 }).catch(function(e) { 6287 console.log("RPCTest: sendRequest got exception: " + e.message); 6288 }).finally (() => { 6289 console.log("RPCTest: sendRequest ends, reclaim parcel"); 6290 data.reclaim(); 6291 reply.reclaim(); 6292 }); 6293 ``` 6294 6295### sendMessageRequest<sup>9+</sup> 6296 6297sendMessageRequest(code: number, data: MessageSequence, reply: MessageSequence, options: MessageOption, callback: AsyncCallback<RequestResult>): void 6298 6299以同步或异步方式向对端进程发送MessageSequence消息。如果为选项设置了异步模式，则立即收到回调，reply报文里没有内容，具体回复需要在业务侧的回调中获取。如果为选项设置了同步模式，则将在sendMessageRequest返回后的某个时机执行回调，回复内容在RequestResult的reply报文里。 6300 6301**系统能力**：SystemCapability.Communication.IPC.Core 6302 6303**参数：** 6304 6305 | 参数名 | 类型 | 必填 | 说明 | 6306 | -------- | ---------------------------------- | ---- | -------------------------------------------------------------------------------------- | 6307 | code | number | 是 | 本次请求调用的消息码，由通信双方确定。如果接口由IDL工具生成，则消息代码由IDL自动生成。 | 6308 | data | [MessageSequence](#messagesequence9) | 是 | 保存待发送数据的 MessageSequence对象。 | 6309 | reply | [MessageSequence](#messagesequence9) | 是 | 接收应答数据的MessageSequence对象。 | 6310 | options | [MessageOption](#messageoption) | 是 | 本次请求的同异步模式，默认同步调用。 | 6311 | callback | AsyncCallback<RequestResult> | 是 | 接收发送结果的回调。 | 6312 6313**示例：** 6314 6315 获取服务 6316 6317 ```ts 6318 import FA from "@ohos.ability.featureAbility"; 6319 let proxy; 6320 let connect = { 6321 onConnect: function(elementName, remoteProxy) { 6322 console.log("RpcClient: js onConnect called."); 6323 proxy = remoteProxy; 6324 }, 6325 onDisconnect: function(elementName) { 6326 console.log("RpcClient: onDisconnect"); 6327 }, 6328 onFailed: function() { 6329 console.log("RpcClient: onFailed"); 6330 } 6331 }; 6332 let want = { 6333 "bundleName": "com.ohos.server", 6334 "abilityName": "com.ohos.server.MainAbility", 6335 }; 6336 function sendRequestCallback(result) { 6337 if (result.errCode === 0) { 6338 console.log("sendRequest got result"); 6339 result.reply.readException(); 6340 let msg = result.reply.readString(); 6341 console.log("RPCTest: reply msg: " + msg); 6342 } else { 6343 console.log("RPCTest: sendRequest failed, errCode: " + result.errCode); 6344 } 6345 console.log("RPCTest: sendRequest ends, reclaim parcel"); 6346 result.data.reclaim(); 6347 result.reply.reclaim(); 6348 } 6349 FA.connectAbility(want, connect); 6350 ``` 6351 6352 上述onConnect回调函数中的proxy对象需要等ability异步连接成功后才会被赋值，然后才可调用proxy对象的sendMessageRequest接口方法发送消息 6353 6354 ```ts 6355 let option = new rpc.MessageOption(); 6356 let data = rpc.MessageSequence.create(); 6357 let reply = rpc.MessageSequence.create(); 6358 data.writeInt(1); 6359 data.writeString("hello"); 6360 try { 6361 proxy.sendRequest(1, data, reply, option, sendRequestCallback); 6362 } catch(error) { 6363 console.info("rpc send sequence request fail, errorCode " + error.code); 6364 console.info("rpc send sequence request fail, errorMessage " + error.message); 6365 } 6366 ``` 6367 6368### sendRequest<sup>8+(deprecated)</sup> 6369 6370>从API version 9 开始不再维护，建议使用[sendMessageRequest](#sendmessagerequest9)类替代。 6371 6372sendRequest(code: number, data: MessageParcel, reply: MessageParcel, options: MessageOption, callback: AsyncCallback<SendRequestResult>): void 6373 6374以同步或异步方式向对端进程发送MessageParcel消息。如果为选项设置了异步模式，则立即收到回调，reply报文里没有内容，具体回复需要在业务侧的回调中获取。如果为选项设置了同步模式，则将在sendRequest返回时收到回调，回复内容在reply报文里。 6375 6376**系统能力**：SystemCapability.Communication.IPC.Core 6377 6378**参数：** 6379 6380 | 参数名 | 类型 | 必填 | 说明 | 6381 | -------- | -------------------------------------- | ---- | -------------------------------------------------------------------------------------- | 6382 | code | number | 是 | 本次请求调用的消息码，由通信双方确定。如果接口由IDL工具生成，则消息代码由IDL自动生成。 | 6383 | data | [MessageParcel](#messageparceldeprecated) | 是 | 保存待发送数据的 MessageParcel对象。 | 6384 | reply | [MessageParcel](#messageparceldeprecated) | 是 | 接收应答数据的MessageParcel对象。 | 6385 | options | [MessageOption](#messageoption) | 是 | 本次请求的同异步模式，默认同步调用。 | 6386 | callback | AsyncCallback<SendRequestResult> | 是 | 接收发送结果的回调。 | 6387 6388**示例：** 6389 6390 获取服务 6391 6392 ```ts 6393 import FA from "@ohos.ability.featureAbility"; 6394 let proxy; 6395 let connect = { 6396 onConnect: function(elementName, remoteProxy) { 6397 console.log("RpcClient: js onConnect called."); 6398 proxy = remoteProxy; 6399 }, 6400 onDisconnect: function(elementName) { 6401 console.log("RpcClient: onDisconnect"); 6402 }, 6403 onFailed: function() { 6404 console.log("RpcClient: onFailed"); 6405 } 6406 }; 6407 let want = { 6408 "bundleName": "com.ohos.server", 6409 "abilityName": "com.ohos.server.MainAbility", 6410 }; 6411 function sendRequestCallback(result) { 6412 if (result.errCode === 0) { 6413 console.log("sendRequest got result"); 6414 result.reply.readException(); 6415 let msg = result.reply.readString(); 6416 console.log("RPCTest: reply msg: " + msg); 6417 } else { 6418 console.log("RPCTest: sendRequest failed, errCode: " + result.errCode); 6419 } 6420 console.log("RPCTest: sendRequest ends, reclaim parcel"); 6421 result.data.reclaim(); 6422 result.reply.reclaim(); 6423 } 6424 FA.connectAbility(want, connect); 6425 ``` 6426 6427 上述onConnect回调函数中的proxy对象需要等ability异步连接成功后才会被赋值，然后才可调用proxy对象的sendRequest接口方法发送消息 6428 6429 ```ts 6430 let option = new rpc.MessageOption(); 6431 let data = rpc.MessageParcel.create(); 6432 let reply = rpc.MessageParcel.create(); 6433 data.writeInt(1); 6434 data.writeString("hello"); 6435 proxy.sendRequest(1, data, reply, option, sendRequestCallback); 6436 ``` 6437 6438### getLocalInterface<sup>9+</sup> 6439 6440getLocalInterface(interface: string): IRemoteBroker 6441 6442查询并获取当前接口描述符对应的本地接口对象。 6443 6444**系统能力**：SystemCapability.Communication.IPC.Core 6445 6446**参数：** 6447 6448 | 参数名 | 类型 | 必填 | 说明 | 6449 | --------- | ------ | ---- | ---------------------- | 6450 | interface | string | 是 | 需要查询的接口描述符。 | 6451 6452**返回值：** 6453 6454 | 类型 | 说明 | 6455 | ------------- | ------------------------------------------ | 6456 | IRemoteBroker | 默认返回Null，标识该接口是一个代理侧接口。 | 6457 6458**错误码：** 6459 6460以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 6461 6462 | 错误码ID | 错误信息 | 6463 | ------- | -------- | 6464 | 1900006 | only remote object permitted | 6465 6466**示例：** 6467 6468 获取服务 6469 6470 ```ts 6471 import FA from "@ohos.ability.featureAbility"; 6472 let proxy; 6473 let connect = { 6474 onConnect: function(elementName, remoteProxy) { 6475 console.log("RpcClient: js onConnect called."); 6476 proxy = remoteProxy; 6477 }, 6478 onDisconnect: function (elementName) { 6479 console.log("RpcClient: onDisconnect"); 6480 }, 6481 onFailed: function() { 6482 console.log("RpcClient: onFailed"); 6483 } 6484 }; 6485 let want = { 6486 "bundleName":"com.ohos.server", 6487 "abilityName":"com.ohos.server.MainAbility", 6488 }; 6489 FA.connectAbility(want, connect); 6490 ``` 6491 6492 上述onConnect回调函数中的proxy对象需要等ability异步连接成功后才会被赋值，然后才可调用proxy对象的getLocalInterface接口方法查询接口对象 6493 6494 ```ts 6495 try { 6496 let broker = proxy.getLocalInterface("testObject"); 6497 console.log("RpcClient: getLocalInterface is " + broker); 6498 } catch(error) { 6499 console.info("rpc get local interface fail, errorCode " + error.code); 6500 console.info("rpc get local interface fail, errorMessage " + error.message); 6501 } 6502 ``` 6503 6504### queryLocalInterface<sup>(deprecated)</sup> 6505 6506>从API version 9 开始不再维护，建议使用[getLocalInterface](#getlocalinterface9)类替代。 6507 6508queryLocalInterface(interface: string): IRemoteBroker 6509 6510查询并获取当前接口描述符对应的本地接口对象。 6511 6512**系统能力**：SystemCapability.Communication.IPC.Core 6513 6514**参数：** 6515 6516 | 参数名 | 类型 | 必填 | 说明 | 6517 | --------- | ------ | ---- | ---------------------- | 6518 | interface | string | 是 | 需要查询的接口描述符。 | 6519 6520**返回值：** 6521 6522 | 类型 | 说明 | 6523 | ------------- | ------------------------------------------ | 6524 | IRemoteBroker | 默认返回Null，标识该接口是一个代理侧接口。 | 6525 6526**示例：** 6527 6528 获取服务 6529 6530 ```ts 6531 import FA from "@ohos.ability.featureAbility"; 6532 let proxy; 6533 let connect = { 6534 onConnect: function(elementName, remoteProxy) { 6535 console.log("RpcClient: js onConnect called."); 6536 proxy = remoteProxy; 6537 }, 6538 onDisconnect: function (elementName) { 6539 console.log("RpcClient: onDisconnect"); 6540 }, 6541 onFailed: function() { 6542 console.log("RpcClient: onFailed"); 6543 } 6544 }; 6545 let want = { 6546 "bundleName":"com.ohos.server", 6547 "abilityName":"com.ohos.server.MainAbility", 6548 }; 6549 FA.connectAbility(want, connect); 6550 ``` 6551 6552 上述onConnect回调函数中的proxy对象需要等ability异步连接成功后才会被赋值，然后才可调用proxy对象的queryLocalInterface接口获取接口对象 6553 6554 ```ts 6555 let broker = proxy.queryLocalInterface("testObject"); 6556 console.log("RpcClient: queryLocalInterface is " + broker); 6557 ``` 6558 6559### registerDeathRecipient<sup>9+</sup> 6560 6561registerDeathRecipient(recipient: DeathRecipient, flags: number): void 6562 6563注册用于接收远程对象死亡通知的回调。如果与RemoteProxy对象匹配的远程对象进程死亡，则调用此方法。 6564 6565**系统能力**：SystemCapability.Communication.IPC.Core 6566 6567**参数：** 6568 6569 | 参数名 | 类型 | 必填 | 说明 | 6570 | --------- | --------------------------------- | ---- | -------------- | 6571 | recipient | [DeathRecipient](#deathrecipient) | 是 | 要注册的回调。 | 6572 | flags | number | 是 | 死亡通知标志。 | 6573 6574**错误码：** 6575 6576以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 6577 6578 | 错误码ID | 错误信息 | 6579 | ------- | -------- | 6580 | 1900008 | proxy or remote object is invalid | 6581 6582**示例：** 6583 6584 获取服务 6585 6586 ```ts 6587 import FA from "@ohos.ability.featureAbility"; 6588 let proxy; 6589 let connect = { 6590 onConnect: function(elementName, remoteProxy) { 6591 console.log("RpcClient: js onConnect called."); 6592 proxy = remoteProxy; 6593 }, 6594 onDisconnect: function(elementName) { 6595 console.log("RpcClient: onDisconnect"); 6596 }, 6597 onFailed: function() { 6598 console.log("RpcClient: onFailed"); 6599 } 6600 }; 6601 let want = { 6602 "bundleName": "com.ohos.server", 6603 "abilityName": "com.ohos.server.MainAbility", 6604 }; 6605 FA.connectAbility(want, connect); 6606 ``` 6607 6608 上述onConnect回调函数中的proxy对象需要等ability异步连接成功后才会被赋值，然后才可调用proxy对象的registerDeathRecipient接口注册死亡回调 6609 6610 ```ts 6611 class MyDeathRecipient { 6612 onRemoteDied() { 6613 console.log("server died"); 6614 } 6615 } 6616 let deathRecipient = new MyDeathRecipient(); 6617 try { 6618 proxy.registerDeathRecipient(deathRecipient, 0); 6619 } catch(error) { 6620 console.info("proxy register deathRecipient fail, errorCode " + error.code); 6621 console.info("proxy register deathRecipient fail, errorMessage " + error.message); 6622 } 6623 ``` 6624 6625### addDeathRecippient<sup>(deprecated)</sup> 6626 6627>从API version 9 开始不再维护，建议使用[registerDeathRecipient](#registerdeathrecipient9)类替代。 6628 6629addDeathRecipient(recipient: DeathRecipient, flags: number): boolean 6630 6631注册用于接收远程对象死亡通知的回调，增加proxy对象上的死亡通知。 6632 6633**系统能力**：SystemCapability.Communication.IPC.Core 6634 6635**参数：** 6636 6637 | 参数名 | 类型 | 必填 | 说明 | 6638 | --------- | --------------------------------- | ---- | --------------------------------- | 6639 | recipient | [DeathRecipient](#deathrecipient) | 是 | 收件人表示要注册的回调。 | 6640 | flags | number | 是 | 死亡通知标志。保留参数。设置为0。 | 6641 6642**返回值：** 6643 6644 | 类型 | 说明 | 6645 | ------- | --------------------------------------------- | 6646 | boolean | true：回调注册成功，false：回调注册失败。| 6647 6648**示例：** 6649 6650 获取服务 6651 6652 ```ts 6653 import FA from "@ohos.ability.featureAbility"; 6654 let proxy; 6655 let connect = { 6656 onConnect: function(elementName, remoteProxy) { 6657 console.log("RpcClient: js onConnect called."); 6658 proxy = remoteProxy; 6659 }, 6660 onDisconnect: function(elementName) { 6661 console.log("RpcClient: onDisconnect"); 6662 }, 6663 onFailed: function() { 6664 console.log("RpcClient: onFailed"); 6665 } 6666 }; 6667 let want = { 6668 "bundleName": "com.ohos.server", 6669 "abilityName": "com.ohos.server.MainAbility", 6670 }; 6671 FA.connectAbility(want, connect); 6672 ``` 6673 6674 上述onConnect回调函数中的proxy对象需要等ability异步连接成功后才会被赋值，然后才可调用proxy对象的addDeathRecippient接口方法新增死亡回调 6675 6676 ```ts 6677 class MyDeathRecipient { 6678 onRemoteDied() { 6679 console.log("server died"); 6680 } 6681 } 6682 let deathRecipient = new MyDeathRecipient(); 6683 proxy.addDeathRecipient(deathRecipient, 0); 6684 ``` 6685 6686### unregisterDeathRecipient<sup>9+</sup> 6687 6688unregisterDeathRecipient(recipient: DeathRecipient, flags: number): void 6689 6690注销用于接收远程对象死亡通知的回调。 6691 6692**系统能力**：SystemCapability.Communication.IPC.Core 6693 6694**参数：** 6695 6696 | 参数名 | 类型 | 必填 | 说明 | 6697 | --------- | --------------------------------- | ---- | -------------- | 6698 | recipient | [DeathRecipient](#deathrecipient) | 是 | 要注销的回调。 | 6699 | flags | number | 是 | 死亡通知标志。 | 6700 6701**错误码：** 6702 6703以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 6704 6705 | 错误码ID | 错误信息 | 6706 | ------- | -------- | 6707 | 1900008 | proxy or remote object is invalid | 6708 6709**示例：** 6710 6711 获取服务 6712 6713 ```ts 6714 import FA from "@ohos.ability.featureAbility"; 6715 let proxy; 6716 let connect = { 6717 onConnect: function(elementName, remoteProxy) { 6718 console.log("RpcClient: js onConnect called."); 6719 proxy = remoteProxy; 6720 }, 6721 onDisconnect: function(elementName) { 6722 console.log("RpcClient: onDisconnect"); 6723 }, 6724 onFailed: function() { 6725 console.log("RpcClient: onFailed"); 6726 } 6727 }; 6728 let want = { 6729 "bundleName": "com.ohos.server", 6730 "abilityName": "com.ohos.server.MainAbility", 6731 }; 6732 FA.connectAbility(want, connect); 6733 ``` 6734 6735 上述onConnect回调函数中的proxy对象需要等ability异步连接成功后才会被赋值，然后才可调用proxy对象的unregisterDeathRecipient接口方法注销死亡回调 6736 6737 ```ts 6738 class MyDeathRecipient { 6739 onRemoteDied() { 6740 console.log("server died"); 6741 } 6742 } 6743 let deathRecipient = new MyDeathRecipient(); 6744 try { 6745 proxy.registerDeathRecippient(deathRecipient, 0); 6746 proxy.unregisterDeathRecippient(deathRecipient, 0); 6747 } catch(error) { 6748 console.info("proxy register deathRecipient fail, errorCode " + error.code); 6749 console.info("proxy register deathRecipient fail, errorMessage " + error.message); 6750 } 6751 ``` 6752 6753### removeDeathRecipient<sup>(deprecated)</sup> 6754 6755>从API version 9 开始不再维护，建议使用[unregisterDeathRecipient](#unregisterdeathrecipient9)类替代。 6756 6757removeDeathRecipient(recipient: DeathRecipient, flags: number): boolean 6758 6759注销用于接收远程对象死亡通知的回调。 6760 6761**系统能力**：SystemCapability.Communication.IPC.Core 6762 6763**参数：** 6764 6765 | 参数名 | 类型 | 必填 | 说明 | 6766 | --------- | --------------------------------- | ---- | --------------------------------- | 6767 | recipient | [DeathRecipient](#deathrecipient) | 是 | 要注销的死亡回调。 | 6768 | flags | number | 是 | 死亡通知标志。保留参数。设置为0。 | 6769 6770**返回值：** 6771 6772 | 类型 | 说明 | 6773 | ------- | --------------------------------------------- | 6774 | boolean | true：回调注销成功，false：回调注销失败。| 6775 6776**示例：** 6777 6778 获取服务 6779 6780 ```ts 6781 import FA from "@ohos.ability.featureAbility"; 6782 let proxy; 6783 let connect = { 6784 onConnect: function(elementName, remoteProxy) { 6785 console.log("RpcClient: js onConnect called."); 6786 proxy = remoteProxy; 6787 }, 6788 onDisconnect: function(elementName) { 6789 console.log("RpcClient: onDisconnect"); 6790 }, 6791 onFailed: function() { 6792 console.log("RpcClient: onFailed"); 6793 } 6794 }; 6795 let want = { 6796 "bundleName": "com.ohos.server", 6797 "abilityName": "com.ohos.server.MainAbility", 6798 }; 6799 FA.connectAbility(want, connect); 6800 ``` 6801 6802 上述onConnect回调函数中的proxy对象需要等ability异步连接成功后才会被赋值，然后才可调用proxy对象的removeDeathRecipient接口方法去注册死亡回调 6803 6804 ```ts 6805 class MyDeathRecipient { 6806 onRemoteDied() { 6807 console.log("server died"); 6808 } 6809 } 6810 let deathRecipient = new MyDeathRecipient(); 6811 proxy.addDeathRecippient(deathRecipient, 0); 6812 proxy.removeDeathRecipient(deathRecipient, 0); 6813 ``` 6814 6815### getDescriptor<sup>9+</sup> 6816 6817getDescriptor(): string 6818 6819获取对象的接口描述符，接口描述符为字符串。 6820 6821**系统能力**：SystemCapability.Communication.IPC.Core 6822 6823**返回值：** 6824 6825 | 类型 | 说明 | 6826 | ------ | ---------------- | 6827 | string | 返回接口描述符。 | 6828 6829**错误码：** 6830 6831以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 6832 6833 | 错误码ID | 错误信息 | 6834 | -------- | ------- | 6835 | 1900008 | proxy or remote object is invalid | 6836 | 1900007 | communication failed | 6837 6838**示例：** 6839 6840 获取服务 6841 6842 ```ts 6843 import FA from "@ohos.ability.featureAbility"; 6844 let proxy; 6845 let connect = { 6846 onConnect: function(elementName, remoteProxy) { 6847 console.log("RpcClient: js onConnect called."); 6848 proxy = remoteProxy; 6849 }, 6850 onDisconnect: function(elementName) { 6851 console.log("RpcClient: onDisconnect"); 6852 }, 6853 onFailed: function() { 6854 console.log("RpcClient: onFailed"); 6855 } 6856 }; 6857 let want = { 6858 "bundleName": "com.ohos.server", 6859 "abilityName": "com.ohos.server.MainAbility", 6860 }; 6861 FA.connectAbility(want, connect); 6862 ``` 6863 上述onConnect回调函数中的proxy对象需要等ability异步连接成功后才会被赋值，然后才可调用proxy对象的getDescriptor接口方法获取对象的接口描述符 6864 6865 ```ts 6866 try { 6867 let descriptor = proxy.getDescriptor(); 6868 console.log("RpcClient: descriptor is " + descriptor); 6869 } catch(error) { 6870 console.info("rpc get interface descriptor fail, errorCode " + error.code); 6871 console.info("rpc get interface descriptor fail, errorMessage " + error.message); 6872 } 6873 ``` 6874 6875### getInterfaceDescriptor<sup>(deprecated)</sup> 6876 6877>从API version 9 开始不再维护，建议使用[getDescriptor](#getdescriptor9)类替代。 6878 6879getInterfaceDescriptor(): string 6880 6881查询当前代理对象接口的描述符。 6882 6883**系统能力**：SystemCapability.Communication.IPC.Core 6884 6885**返回值：** 6886 6887 | 类型 | 说明 | 6888 | ------ | ------------------ | 6889 | string | 当前的接口描述符。 | 6890 6891**示例：** 6892 6893 获取服务 6894 6895 ```ts 6896 import FA from "@ohos.ability.featureAbility"; 6897 let proxy; 6898 let connect = { 6899 onConnect: function(elementName, remoteProxy) { 6900 console.log("RpcClient: js onConnect called."); 6901 proxy = remoteProxy; 6902 }, 6903 onDisconnect: function(elementName) { 6904 console.log("RpcClient: onDisconnect"); 6905 }, 6906 onFailed: function() { 6907 console.log("RpcClient: onFailed"); 6908 } 6909 }; 6910 let want = { 6911 "bundleName": "com.ohos.server", 6912 "abilityName": "com.ohos.server.MainAbility", 6913 }; 6914 FA.connectAbility(want, connect); 6915 ``` 6916 6917 上述onConnect回调函数中的proxy对象需要等ability异步连接成功后才会被赋值，然后才可调用proxy对象的isObjectDead接口方法判断当前对象是否已经死亡 6918 6919 ```ts 6920 let descriptor = proxy.getInterfaceDescriptor(); 6921 console.log("RpcClient: descriptor is " + descriptor); 6922 ``` 6923 6924### isObjectDead 6925 6926isObjectDead(): boolean 6927 6928指示对应的RemoteObject是否死亡。 6929 6930**系统能力**：SystemCapability.Communication.IPC.Core 6931 6932**返回值：** 6933 6934 | 类型 | 说明 | 6935 | ------- | --------------------------------------------------------- | 6936 | boolean | true：对应的对象已经死亡，false：对应的对象未死亡| 6937 6938**示例：** 6939 6940 获取服务 6941 6942 ```ts 6943 import FA from "@ohos.ability.featureAbility"; 6944 let proxy; 6945 let connect = { 6946 onConnect: function(elementName, remoteProxy) { 6947 console.log("RpcClient: js onConnect called."); 6948 proxy = remoteProxy; 6949 }, 6950 onDisconnect: function(elementName) { 6951 console.log("RpcClient: onDisconnect"); 6952 }, 6953 onFailed: function() { 6954 console.log("RpcClient: onFailed"); 6955 } 6956 }; 6957 let want = { 6958 "bundleName": "com.ohos.server", 6959 "abilityName": "com.ohos.server.MainAbility", 6960 }; 6961 FA.connectAbility(want, connect); 6962 ``` 6963 6964 上述onConnect回调函数中的proxy对象需要等ability异步连接成功后才会被赋值，然后才可调用proxy对象的isObjectDead接口方法判断当前对象是否已经死亡 6965 6966 ```ts 6967 let isDead = proxy.isObjectDead(); 6968 console.log("RpcClient: isObjectDead is " + isDead); 6969 ``` 6970 6971## MessageOption 6972 6973公共消息选项（int标志，int等待时间），使用标志中指定的标志构造指定的MessageOption对象。 6974 6975**系统能力**：以下各项对应的系统能力均为SystemCapability.Communication.IPC.Core。 6976 6977 | 名称 | 值 | 说明 | 6978 | ------------- | ---- | ----------------------------------------------------------- | 6979 | TF_SYNC | 0 | 同步调用标识。 | 6980 | TF_ASYNC | 1 | 异步调用标识。 | 6981 | TF_ACCEPT_FDS | 0x10 | 指示sendMessageRequest<sup>9+</sup>接口可以返回文件描述符。 | 6982 | TF_WAIT_TIME | 8 | 默认等待时间(单位/秒)。 | 6983 6984 6985### constructor<sup>9+</sup> 6986 6987constructor(async?: boolean); 6988 6989MessageOption构造函数。 6990 6991**系统能力**：SystemCapability.Communication.IPC.Core 6992 6993**参数：** 6994 6995 | 参数名 | 类型 | 必填 | 说明 | 6996 | --------- | ------ | ---- | -------------------------------------- | 6997 | syncFlags | number | 否 | 同步调用或异步调用标志。默认同步调用。 | 6998 6999 7000**示例：** 7001 7002 ```ts 7003 class TestRemoteObject extends rpc.MessageOption { 7004 constructor(async) { 7005 super(async); 7006 } 7007 } 7008 ``` 7009 7010### constructor 7011 7012constructor(syncFlags?: number, waitTime?: number) 7013 7014MessageOption构造函数。 7015 7016**系统能力**：SystemCapability.Communication.IPC.Core 7017 7018**参数：** 7019 7020 | 参数名 | 类型 | 必填 | 说明 | 7021 | --------- | ------ | ---- | --------------------------------------------- | 7022 | syncFlags | number | 否 | 同步调用或异步调用标志。默认同步调用。 | 7023 | waitTime | number | 否 | 调用rpc最长等待时间。默认 TF_WAIT_TIME。 | 7024 7025**示例：** 7026 7027 ```ts 7028 class TestRemoteObject extends rpc.MessageOption { 7029 constructor(syncFlags,waitTime) { 7030 super(syncFlags,waitTime); 7031 } 7032 } 7033 ``` 7034### isAsync<sup>9+</sup> 7035 7036isAsync(): boolean; 7037 7038获取SendMessageRequest调用中确定同步或是异步的标志。 7039 7040**系统能力**：SystemCapability.Communication.IPC.Core 7041 7042**返回值：** 7043 7044 | 类型 | 说明 | 7045 | ------- | ------------------------------------ | 7046 | boolean | true：同步调用成功，false：异步调用成功。 | 7047 7048**示例：** 7049 7050 ```ts 7051 let option = new rpc.MessageOption(); 7052 let isAsync = option.isAsync(); 7053 ``` 7054 7055### setAsync<sup>9+</sup> 7056 7057setAsync(async: boolean): void; 7058 7059设置SendMessageRequest调用中确定同步或是异步的标志。 7060 7061**系统能力**：SystemCapability.Communication.IPC.Core 7062 7063**示例：** 7064 7065 ```ts 7066 let option = new rpc.MessageOption(); 7067 let setAsync = option.setAsync(true); 7068 console.log("Set synchronization flag"); 7069 ``` 7070 7071### getFlags 7072 7073getFlags(): number 7074 7075获取同步调用或异步调用标志。 7076 7077**系统能力**：SystemCapability.Communication.IPC.Core 7078 7079**返回值：** 7080 7081 | 类型 | 说明 | 7082 | ------ | ------------------------------------ | 7083 | number | 调用成功返回同步调用或异步调用标志。 | 7084 7085**示例：** 7086 7087 ```ts 7088 try { 7089 let option = new rpc.MessageOption(); 7090 console.info("create object successfully."); 7091 let flog = option.getFlags(); 7092 console.info("run getFlags success, flog is " + flog); 7093 option.setFlags(1) 7094 console.info("run setFlags success"); 7095 let flog2 = option.getFlags(); 7096 console.info("run getFlags success, flog2 is " + flog2); 7097 } catch (error) { 7098 console.info("error " + error); 7099 } 7100 ``` 7101 7102### setFlags 7103 7104setFlags(flags: number): void 7105 7106设置同步调用或异步调用标志。 7107 7108**系统能力**：SystemCapability.Communication.IPC.Core 7109 7110**参数：** 7111 7112 | 参数名 | 类型 | 必填 | 说明 | 7113 | ------ | ------ | ---- | ------------------------ | 7114 | flags | number | 是 | 同步调用或异步调用标志。 | 7115 7116**示例：** 7117 7118 ```ts 7119 try { 7120 let option = new rpc.MessageOption(); 7121 option.setFlags(1) 7122 console.info("run setFlags success"); 7123 let flog = option.getFlags(); 7124 console.info("run getFlags success, flog is " + flog); 7125 } catch (error) { 7126 console.info("error " + error); 7127 } 7128 ``` 7129 7130### getWaitTime 7131 7132getWaitTime(): number 7133 7134获取rpc调用的最长等待时间。 7135 7136**系统能力**：SystemCapability.Communication.IPC.Core 7137 7138**返回值：** 7139 7140 | 类型 | 说明 | 7141 | ------ | ----------------- | 7142 | number | rpc最长等待时间。 | 7143 7144**示例：** 7145 7146 ```ts 7147 try { 7148 let option = new rpc.MessageOption(); 7149 let time = option.getWaitTime(); 7150 console.info("run getWaitTime success"); 7151 option.setWaitTime(16); 7152 let time2 = option.getWaitTime(); 7153 console.info("run getWaitTime success, time is " + time); 7154 } catch (error) { 7155 console.info("error " + error); 7156 } 7157 ``` 7158 7159### setWaitTime 7160 7161setWaitTime(waitTime: number): void 7162 7163设置rpc调用最长等待时间。 7164 7165**系统能力**：SystemCapability.Communication.IPC.Core 7166 7167**参数：** 7168 7169 | 参数名 | 类型 | 必填 | 说明 | 7170 | -------- | ------ | ---- | --------------------- | 7171 | waitTime | number | 是 | rpc调用最长等待时间。 | 7172 7173**示例：** 7174 7175 ```ts 7176 try { 7177 let option = new rpc.MessageOption(); 7178 option.setWaitTime(16); 7179 let time = option.getWaitTime(); 7180 console.info("run getWaitTime success, time is " + time); 7181 } catch (error) { 7182 console.info("error " + error); 7183 } 7184 ``` 7185 7186## IPCSkeleton 7187 7188用于获取IPC上下文信息，包括获取UID和PID、获取本端和对端设备ID、检查接口调用是否在同一设备上。 7189 7190### getContextObject 7191 7192static getContextObject(): IRemoteObject 7193 7194静态方法，获取系统能力的管理者。 7195 7196**系统能力**：SystemCapability.Communication.IPC.Core 7197 7198**返回值：** 7199 7200 | 类型 | 说明 | 7201 | ------------------------------- | -------------------- | 7202 | [IRemoteObject](#iremoteobject) | 返回系统能力管理者。 | 7203 7204**示例：** 7205 7206 ```ts 7207 let samgr = rpc.IPCSkeleton.getContextObject(); 7208 console.log("RpcServer: getContextObject result: " + samgr); 7209 ``` 7210 7211### getCallingPid 7212 7213static getCallingPid(): number 7214 7215静态方法，获取调用者的PID。此方法由RemoteObject对象在onRemoteRequest方法中调用，不在IPC上下文环境（onRemoteRequest）中调用则返回本进程的PID。 7216 7217**系统能力**：SystemCapability.Communication.IPC.Core 7218 7219**返回值：** 7220 7221 | 类型 | 说明 | 7222 | ------ | ----------------- | 7223 | number | 返回调用者的PID。 | 7224 7225**示例：** 7226 7227 ```ts 7228 class Stub extends rpc.RemoteObject { 7229 onRemoteMessageRequest(code, data, reply, option) { 7230 let callerPid = rpc.IPCSkeleton.getCallingPid(); 7231 console.log("RpcServer: getCallingPid result: " + callerPid); 7232 return true; 7233 } 7234 } 7235 ``` 7236 7237### getCallingUid 7238 7239static getCallingUid(): number 7240 7241静态方法，获取调用者的UID。此方法由RemoteObject对象在onRemoteRequest方法中调用，不在IPC上下文环境（onRemoteRequest）中调用则返回本进程的UID。 7242 7243**系统能力**：SystemCapability.Communication.IPC.Core 7244 7245**返回值：** 7246 7247 | 类型 | 说明 | 7248 | ------ | ----------------- | 7249 | number | 返回调用者的UID。 | 7250 7251**示例：** 7252 7253 ```ts 7254 class Stub extends rpc.RemoteObject { 7255 onRemoteMessageRequest(code, data, reply, option) { 7256 let callerUid = rpc.IPCSkeleton.getCallingUid(); 7257 console.log("RpcServer: getCallingUid result: " + callerUid); 7258 return true; 7259 } 7260 } 7261 ``` 7262 7263### getCallingTokenId<sup>8+</sup> 7264 7265static getCallingTokenId(): number; 7266 7267静态方法，获取调用者的TokenId，用于被调用方对调用方的身份校验。 7268 7269**系统能力**：SystemCapability.Communication.IPC.Core 7270 7271**返回值：** 7272 7273 | 类型 | 说明 | 7274 | ------ | --------------------- | 7275 | number | 返回调用者的TokenId。 | 7276 7277**示例：** 7278 7279 ```ts 7280 class Stub extends rpc.RemoteObject { 7281 onRemoteMessageRequest(code, data, reply, option) { 7282 let callerTokenId = rpc.IPCSkeleton.getCallingTokenId(); 7283 console.log("RpcServer: getCallingTokenId result: " + callerTokenId); 7284 return true; 7285 } 7286 } 7287 ``` 7288 7289 7290### getCallingDeviceID 7291 7292static getCallingDeviceID(): string 7293 7294静态方法，获取调用者进程所在的设备ID。 7295 7296**系统能力**：SystemCapability.Communication.IPC.Core 7297 7298**返回值：** 7299 7300 | 类型 | 说明 | 7301 | ------ | ---------------------------- | 7302 | string | 返回调用者进程所在的设备ID。 | 7303 7304**示例：** 7305 7306 ```ts 7307 class Stub extends rpc.RemoteObject { 7308 onRemoteMessageRequest(code, data, reply, option) { 7309 let callerDeviceID = rpc.IPCSkeleton.getCallingDeviceID(); 7310 console.log("RpcServer: callerDeviceID is: " + callerDeviceID); 7311 return true; 7312 } 7313 } 7314 ``` 7315 7316### getLocalDeviceID 7317 7318static getLocalDeviceID(): string 7319 7320静态方法，获取本端设备ID。 7321 7322**系统能力**：SystemCapability.Communication.IPC.Core 7323 7324**返回值：** 7325 7326 | 类型 | 说明 | 7327 | ------ | ------------------ | 7328 | string | 返回本地设备的ID。 | 7329 7330**示例：** 7331 7332 ```ts 7333 class Stub extends rpc.RemoteObject { 7334 onRemoteMessageRequest(code, data, reply, option) { 7335 let localDeviceID = rpc.IPCSkeleton.getLocalDeviceID(); 7336 console.log("RpcServer: localDeviceID is: " + localDeviceID); 7337 return true; 7338 } 7339 } 7340 ``` 7341 7342### isLocalCalling 7343 7344static isLocalCalling(): boolean 7345 7346静态方法，检查当前通信对端是否是本设备的进程。 7347 7348**系统能力**：SystemCapability.Communication.IPC.Core 7349 7350**返回值：** 7351 7352 | 类型 | 说明 | 7353 | ------- | --------------------------------------------------------- | 7354 | boolean | true：调用在同一台设备，false：调用未在同一台设备。| 7355 7356**示例：** 7357 7358 ```ts 7359 class Stub extends rpc.RemoteObject { 7360 onRemoteMessageRequest(code, data, reply, option) { 7361 let isLocalCalling = rpc.IPCSkeleton.isLocalCalling(); 7362 console.log("RpcServer: isLocalCalling is: " + isLocalCalling); 7363 return true; 7364 } 7365 } 7366 ``` 7367 7368### flushCmdBuffer<sup>9+</sup> 7369 7370static flushCmdBuffer(object: IRemoteObject): void 7371 7372静态方法，将所有挂起的命令从指定的RemoteProxy刷新到相应的RemoteObject。建议在执行任何时间敏感操作之前调用此方法。 7373 7374**系统能力**：SystemCapability.Communication.IPC.Core 7375 7376**参数：** 7377 7378 | 参数名 | 类型 | 必填 | 说明 | 7379 | ------ | ------------------------------- | ---- | ------------------- | 7380 | object | [IRemoteObject](#iremoteobject) | 是 | 指定的RemoteProxy。 | 7381 7382 7383**示例：** 7384 7385 ```ts 7386 class TestRemoteObject extends rpc.RemoteObject { 7387 constructor(descriptor) { 7388 super(descriptor); 7389 } 7390 } 7391 let remoteObject = new TestRemoteObject("aaa"); 7392 try { 7393 rpc.IPCSkeleton.flushCmdBuffer(remoteObject); 7394 } catch(error) { 7395 console.info("proxy set calling identity fail, errorCode " + error.code); 7396 console.info("proxy set calling identity fail, errorMessage " + error.message); 7397 } 7398 ``` 7399 7400### flushCommands<sup>(deprecated)</sup> 7401 7402>从API version 9 开始不再维护，建议使用[flushCmdBuffer](#flushcmdbuffer9)类替代。 7403 7404static flushCommands(object: IRemoteObject): number 7405 7406静态方法，将所有挂起的命令从指定的RemoteProxy刷新到相应的RemoteObject。建议在执行任何时间敏感操作之前调用此方法。 7407 7408**系统能力**：SystemCapability.Communication.IPC.Core 7409 7410**参数：** 7411 7412 | 参数名 | 类型 | 必填 | 说明 | 7413 | ------ | ------------------------------- | ---- | ------------------- | 7414 | object | [IRemoteObject](#iremoteobject) | 是 | 指定的RemoteProxy。 | 7415 7416**返回值：** 7417 7418 | 类型 | 说明 | 7419 | ------ | --------------------------------------------------------------------------------- | 7420 | number | 如果操作成功，返回0；如果输入对象为空或RemoteObject，或者操作失败，返回错误代码。 | 7421 7422**示例：** 7423 7424 ```ts 7425 class MyDeathRecipient { 7426 onRemoteDied() { 7427 console.log("server died"); 7428 } 7429 } 7430 class TestRemoteObject extends rpc.RemoteObject { 7431 constructor(descriptor) { 7432 super(descriptor); 7433 } 7434 addDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 7435 return true; 7436 } 7437 removeDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 7438 return true; 7439 } 7440 isObjectDead(): boolean { 7441 return false; 7442 } 7443 } 7444 let remoteObject = new TestRemoteObject("aaa"); 7445 let ret = rpc.IPCSkeleton.flushCommands(remoteObject); 7446 console.log("RpcServer: flushCommands result: " + ret); 7447 ``` 7448 7449### resetCallingIdentity 7450 7451static resetCallingIdentity(): string 7452 7453静态方法，将远程用户的UID和PID替换为本地用户的UID和PID。它可以用于身份验证等场景。 7454 7455**系统能力**：SystemCapability.Communication.IPC.Core 7456 7457**返回值：** 7458 7459 | 类型 | 说明 | 7460 | ------ | ------------------------------------ | 7461 | string | 返回包含远程用户的UID和PID的字符串。 | 7462 7463**示例：** 7464 7465 ```ts 7466 class Stub extends rpc.RemoteObject { 7467 onRemoteMessageRequest(code, data, reply, option) { 7468 let callingIdentity = rpc.IPCSkeleton.resetCallingIdentity(); 7469 console.log("RpcServer: callingIdentity is: " + callingIdentity); 7470 return true; 7471 } 7472 } 7473 ``` 7474 7475 7476### restoreCallingIdentity<sup>9+</sup> 7477 7478static restoreCallingIdentity(identity: string): void 7479 7480静态方法，将远程用户的UID和PID替换为本地用户的UID和PID。它可以用于身份验证等场景。 7481 7482**系统能力**：SystemCapability.Communication.IPC.Core 7483 7484**参数：** 7485 7486 | 参数名 | 类型 | 必填 | 说明 | 7487 | -------- | ------ | ---- | ------------------------------------------------------------------ | 7488 | identity | string | 是 | 标识表示包含远程用户UID和PID的字符串。由resetCallingIdentity返回。 | 7489 7490**示例：** 7491 7492 ```ts 7493 class Stub extends rpc.RemoteObject { 7494 onRemoteMessageRequest(code, data, reply, option) { 7495 let callingIdentity = null; 7496 try { 7497 callingIdentity = rpc.IPCSkeleton.resetCallingIdentity(); 7498 console.log("RpcServer: callingIdentity is: " + callingIdentity); 7499 } finally { 7500 rpc.IPCSkeleton.restoreCallingIdentity("callingIdentity "); 7501 } 7502 return true; 7503 } 7504 } 7505 ``` 7506 7507### setCallingIdentity<sup>(deprecated)</sup> 7508 7509>从API version 9 开始不再维护，建议使用[restoreCallingIdentity](#restorecallingidentity9)类替代。 7510 7511static setCallingIdentity(identity: string): boolean 7512 7513静态方法，将UID和PID恢复为远程用户的UID和PID。它通常在使用resetCallingIdentity后调用，需要resetCallingIdentity返回的远程用户的UID和PID。 7514 7515**系统能力**：SystemCapability.Communication.IPC.Core 7516 7517**参数：** 7518 7519 | 参数名 | 类型 | 必填 | 说明 | 7520 | -------- | ------ | ---- | ------------------------------------------------------------------ | 7521 | identity | string | 是 | 标识表示包含远程用户UID和PID的字符串。由resetCallingIdentity返回。 | 7522 7523**返回值：** 7524 7525 | 类型 | 说明 | 7526 | ------- | ----------------------------------------- | 7527 | boolean | true：设置成功，false：设置失败。| 7528 7529**示例：** 7530 7531 ```ts 7532 class Stub extends rpc.RemoteObject { 7533 onRemoteMessageRequest(code, data, reply, option) { 7534 let callingIdentity = null; 7535 try { 7536 callingIdentity = rpc.IPCSkeleton.resetCallingIdentity(); 7537 console.log("RpcServer: callingIdentity is: " + callingIdentity); 7538 } finally { 7539 let ret = rpc.IPCSkeleton.setCallingIdentity("callingIdentity "); 7540 console.log("RpcServer: setCallingIdentity is: " + ret); 7541 } 7542 return true; 7543 } 7544 } 7545 ``` 7546 7547## RemoteObject 7548 7549实现远程对象。服务提供者必须继承此类。 7550 7551### constructor 7552 7553constructor(descriptor: string) 7554 7555RemoteObject构造函数。 7556 7557**系统能力**：SystemCapability.Communication.IPC.Core 7558 7559**参数：** 7560 7561 | 参数名 | 类型 | 必填 | 说明 | 7562 | ---------- | ------ | ---- | ------------ | 7563 | descriptor | string | 是 | 接口描述符。 | 7564 7565 7566### sendRequest<sup>(deprecated)</sup> 7567 7568>从API version 9 开始不再维护，建议使用[sendMessageRequest](#sendmessagerequest9)类替代。 7569 7570sendRequest(code: number, data: MessageParcel, reply: MessageParcel, options: MessageOption): boolean 7571 7572以同步或异步方式向对端进程发送MessageParcel消息。如果为选项设置了异步模式，则期约立即兑现，reply报文里没有内容，具体回复需要在业务侧的回调中获取。如果为选项设置了同步模式，则期约将在sendRequest返回时兑现，回复内容在reply报文里。 7573 7574**系统能力**：SystemCapability.Communication.IPC.Core 7575 7576**参数：** 7577 7578 | 参数名 | 类型 | 必填 | 说明 | 7579 | ------- | ------------------------------- | ---- | -------------------------------------------------------------------------------------- | 7580 | code | number | 是 | 本次请求调用的消息码，由通信双方确定。如果接口由IDL工具生成，则消息代码由IDL自动生成。 | 7581 | data | [MessageParcel](#messageparceldeprecated) | 是 | 保存待发送数据的 MessageParcel对象。 | 7582 | reply | [MessageParcel](#messageparceldeprecated) | 是 | 接收应答数据的MessageParcel对象。 | 7583 | options | [MessageOption](#messageoption) | 是 | 本次请求的同异步模式，默认同步调用。 | 7584 7585**返回值：** 7586 7587 | 类型 | 说明 | 7588 | ------- | --------------------------------------------- | 7589 | boolean | true：发送成功，false：发送失败。| 7590 7591**示例：** 7592 7593 ```ts 7594 class MyDeathRecipient { 7595 onRemoteDied() { 7596 console.log("server died"); 7597 } 7598 } 7599 class TestRemoteObject extends rpc.RemoteObject { 7600 constructor(descriptor) { 7601 super(descriptor); 7602 } 7603 addDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 7604 return true; 7605 } 7606 removeDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 7607 return true; 7608 } 7609 isObjectDead(): boolean { 7610 return false; 7611 } 7612 } 7613 let testRemoteObject = new TestRemoteObject("testObject"); 7614 let option = new rpc.MessageOption(); 7615 let data = rpc.MessageParcel.create(); 7616 let reply = rpc.MessageParcel.create(); 7617 data.writeInt(1); 7618 data.writeString("hello"); 7619 let ret: boolean = testRemoteObject.sendRequest(1, data, reply, option); 7620 if (ret) { 7621 console.log("sendRequest got result"); 7622 let msg = reply.readString(); 7623 console.log("RPCTest: reply msg: " + msg); 7624 } else { 7625 console.log("RPCTest: sendRequest failed"); 7626 } 7627 console.log("RPCTest: sendRequest ends, reclaim parcel"); 7628 data.reclaim(); 7629 reply.reclaim(); 7630 ``` 7631 7632### sendRequest<sup>8+(deprecated)</sup> 7633 7634>从API version 9 开始不再维护，建议使用[sendMessageRequest](#sendmessagerequest9)类替代。 7635 7636sendRequest(code: number, data: MessageParcel, reply: MessageParcel, options: MessageOption): Promise<SendRequestResult> 7637 7638以同步或异步方式向对端进程发送MessageParcel消息。如果为选项设置了异步模式，则期约立即兑现，reply报文里没有内容，具体回复需要在业务侧的回调中获取。如果为选项设置了同步模式，则期约将在sendRequest返回时兑现，回复内容在reply报文里。 7639 7640**系统能力**：SystemCapability.Communication.IPC.Core 7641 7642**参数：** 7643 7644 | 参数名 | 类型 | 必填 | 说明 | 7645 | ------- | ------------------------------- | ---- | -------------------------------------------------------------------------------------- | 7646 | code | number | 是 | 本次请求调用的消息码，由通信双方确定。如果接口由IDL工具生成，则消息代码由IDL自动生成。 | 7647 | data | [MessageParcel](#messageparceldeprecated) | 是 | 保存待发送数据的 MessageParcel对象。 | 7648 | reply | [MessageParcel](#messageparceldeprecated) | 是 | 接收应答数据的MessageParcel对象。 | 7649 | options | [MessageOption](#messageoption) | 是 | 本次请求的同异步模式，默认同步调用。 | 7650 7651**返回值：** 7652 7653 | 类型 | 说明 | 7654 | -------------------------------- | --------------------------------------------- | 7655 | Promise<SendRequestResult> | 返回一个期约，兑现值是sendRequestResult实例。 | 7656 7657**示例：** 7658 7659 ```ts 7660 class MyDeathRecipient { 7661 onRemoteDied() { 7662 console.log("server died"); 7663 } 7664 } 7665 class TestRemoteObject extends rpc.RemoteObject { 7666 constructor(descriptor) { 7667 super(descriptor); 7668 } 7669 addDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 7670 return true; 7671 } 7672 removeDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 7673 return true; 7674 } 7675 isObjectDead(): boolean { 7676 return false; 7677 } 7678 } 7679 let testRemoteObject = new TestRemoteObject("testObject"); 7680 let option = new rpc.MessageOption(); 7681 let data = rpc.MessageParcel.create(); 7682 let reply = rpc.MessageParcel.create(); 7683 data.writeInt(1); 7684 data.writeString("hello"); 7685 testRemoteObject.sendRequest(1, data, reply, option) 7686 .then(function(result) { 7687 if (result.errCode === 0) { 7688 console.log("sendRequest got result"); 7689 result.reply.readException(); 7690 let msg = result.reply.readString(); 7691 console.log("RPCTest: reply msg: " + msg); 7692 } else { 7693 console.log("RPCTest: sendRequest failed, errCode: " + result.errCode); 7694 } 7695 }).catch(function(e) { 7696 console.log("RPCTest: sendRequest got exception: " + e.message); 7697 }).finally (() => { 7698 console.log("RPCTest: sendRequest ends, reclaim parcel"); 7699 data.reclaim(); 7700 reply.reclaim(); 7701 }); 7702 ``` 7703 7704### sendMessageRequest<sup>9+</sup> 7705 7706sendMessageRequest(code: number, data: MessageSequence, reply: MessageSequence, options: MessageOption): Promise<RequestResult> 7707 7708以同步或异步方式向对端进程发送MessageSequence消息。如果为选项设置了异步模式，则期约立即兑现，reply报文里没有内容，具体回复需要在业务侧的回调中获取。如果为选项设置了同步模式，则期约将在sendMessageRequest返回时兑现，回复内容在reply报文里。 7709 7710**系统能力**：SystemCapability.Communication.IPC.Core 7711 7712**参数：** 7713 7714 | 参数名 | 类型 | 必填 | 说明 | 7715 | ------- | ------------------------------- | ---- | -------------------------------------------------------------------------------------- | 7716 | code | number | 是 | 本次请求调用的消息码，由通信双方确定。如果接口由IDL工具生成，则消息代码由IDL自动生成。 | 7717 | data | [MessageSequence](#messagesequence9) | 是 | 保存待发送数据的 MessageSequence对象。 | 7718 | reply | [MessageSequence](#messagesequence9) | 是 | 接收应答数据的MessageSequence对象。 | 7719 | options | [MessageOption](#messageoption) | 是 | 本次请求的同异步模式，默认同步调用。 | 7720 7721**返回值：** 7722 7723 | 类型 | 说明 | 7724 | ---------------------------- | --------------------------------------------- | 7725 | Promise<RequestResult> | 返回一个期约，兑现值是sendRequestResult实例。 | 7726 7727**示例：** 7728 7729 ```ts 7730 class TestRemoteObject extends rpc.RemoteObject { 7731 constructor(descriptor) { 7732 super(descriptor); 7733 } 7734 } 7735 let testRemoteObject = new TestRemoteObject("testObject"); 7736 let option = new rpc.MessageOption(); 7737 let data = rpc.MessageSequence.create(); 7738 let reply = rpc.MessageSequence.create(); 7739 data.writeInt(1); 7740 data.writeString("hello"); 7741 testRemoteObject.sendMessageRequest(1, data, reply, option) 7742 .then(function(result) { 7743 if (result.errCode === 0) { 7744 console.log("sendMessageRequest got result"); 7745 result.reply.readException(); 7746 let msg = result.reply.readString(); 7747 console.log("RPCTest: reply msg: " + msg); 7748 } else { 7749 console.log("RPCTest: sendMessageRequest failed, errCode: " + result.errCode); 7750 } 7751 }).catch(function(e) { 7752 console.log("RPCTest: sendMessageRequest got exception: " + e.message); 7753 }).finally (() => { 7754 console.log("RPCTest: sendMessageRequest ends, reclaim parcel"); 7755 data.reclaim(); 7756 reply.reclaim(); 7757 }); 7758 ``` 7759 7760### sendMessageRequest<sup>9+</sup> 7761 7762sendMessageRequest(code: number, data: MessageSequence, reply: MessageSequence, options: MessageOption, callback: AsyncCallback<RequestResult>): void 7763 7764以同步或异步方式向对端进程发送MessageSequence消息。如果为选项设置了异步模式，则立即收到回调，reply报文里没有内容，具体回复需要在业务侧的回调中获取。如果为选项设置了同步模式，则将在sendMessageRequest返回时收到回调，回复内容在reply报文里。 7765 7766**系统能力**：SystemCapability.Communication.IPC.Core 7767 7768**参数：** 7769 7770 | 参数名 | 类型 | 必填 | 说明 | 7771 | ------------- | ---------------------------------- | ---- | -------------------------------------------------------------------------------------- | 7772 | code | number | 是 | 本次请求调用的消息码，由通信双方确定。如果接口由IDL工具生成，则消息代码由IDL自动生成。 | 7773 | data | [MessageSequence](#messagesequence9) | 是 | 保存待发送数据的 MessageSequence对象。 | 7774 | reply | [MessageSequence](#messagesequence9) | 是 | 接收应答数据的MessageSequence对象。 | 7775 | options | [MessageOption](#messageoption) | 是 | 本次请求的同异步模式，默认同步调用。 | 7776 | AsyncCallback | AsyncCallback<RequestResult> | 是 | 接收发送结果的回调。 | 7777 7778**示例：** 7779 7780 ```ts 7781 class TestRemoteObject extends rpc.RemoteObject { 7782 constructor(descriptor) { 7783 super(descriptor); 7784 } 7785 } 7786 function sendRequestCallback(result) { 7787 if (result.errCode === 0) { 7788 console.log("sendRequest got result"); 7789 result.reply.readException(); 7790 let msg = result.reply.readString(); 7791 console.log("RPCTest: reply msg: " + msg); 7792 } else { 7793 console.log("RPCTest: sendRequest failed, errCode: " + result.errCode); 7794 } 7795 console.log("RPCTest: sendRequest ends, reclaim parcel"); 7796 result.data.reclaim(); 7797 result.reply.reclaim(); 7798 } 7799 let testRemoteObject = new TestRemoteObject("testObject"); 7800 let option = new rpc.MessageOption(); 7801 let data = rpc.MessageSequence.create(); 7802 let reply = rpc.MessageSequence.create(); 7803 data.writeInt(1); 7804 data.writeString("hello"); 7805 testRemoteObject.sendMessageRequest(1, data, reply, option, sendRequestCallback); 7806 ``` 7807 7808### sendRequest<sup>8+(deprecated)</sup> 7809 7810>从API version 9 开始不再维护，建议使用[sendMessageRequest](#sendmessagerequest9)类替代。 7811 7812sendRequest(code: number, data: MessageParcel, reply: MessageParcel, options: MessageOption, callback: AsyncCallback<SendRequestResult>): void 7813 7814以同步或异步方式向对端进程发送MessageParcel消息。如果为选项设置了异步模式，则立即收到回调，reply报文里没有内容，具体回复需要在业务侧的回调中获取。如果为选项设置了同步模式，则将在sendRequest返回时收到回调，回复内容在reply报文里。 7815 7816**系统能力**：SystemCapability.Communication.IPC.Core 7817 7818**参数：** 7819 7820 | 参数名 | 类型 | 必填 | 说明 | 7821 | ------------- | -------------------------------------- | ---- | -------------------------------------------------------------------------------------- | 7822 | code | number | 是 | 本次请求调用的消息码，由通信双方确定。如果接口由IDL工具生成，则消息代码由IDL自动生成。 | 7823 | data | [MessageParcel](#messageparceldeprecated) | 是 | 保存待发送数据的 MessageParcel对象。 | 7824 | reply | [MessageParcel](#messageparceldeprecated) | 是 | 接收应答数据的MessageParcel对象。 | 7825 | options | [MessageOption](#messageoption) | 是 | 本次请求的同异步模式，默认同步调用。 | 7826 | AsyncCallback | AsyncCallback<SendRequestResult> | 是 | 接收发送结果的回调。 | 7827 7828**示例：** 7829 7830 ```ts 7831 class MyDeathRecipient { 7832 onRemoteDied() { 7833 console.log("server died"); 7834 } 7835 } 7836 class TestRemoteObject extends rpc.RemoteObject { 7837 constructor(descriptor) { 7838 super(descriptor); 7839 } 7840 addDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 7841 return true; 7842 } 7843 removeDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 7844 return true; 7845 } 7846 isObjectDead(): boolean { 7847 return false; 7848 } 7849 } 7850 function sendRequestCallback(result) { 7851 if (result.errCode === 0) { 7852 console.log("sendRequest got result"); 7853 result.reply.readException(); 7854 let msg = result.reply.readString(); 7855 console.log("RPCTest: reply msg: " + msg); 7856 } else { 7857 console.log("RPCTest: sendRequest failed, errCode: " + result.errCode); 7858 } 7859 console.log("RPCTest: sendRequest ends, reclaim parcel"); 7860 result.data.reclaim(); 7861 result.reply.reclaim(); 7862 } 7863 let testRemoteObject = new TestRemoteObject("testObject"); 7864 let option = new rpc.MessageOption(); 7865 let data = rpc.MessageParcel.create(); 7866 let reply = rpc.MessageParcel.create(); 7867 data.writeInt(1); 7868 data.writeString("hello"); 7869 testRemoteObject.sendRequest(1, data, reply, option, sendRequestCallback); 7870 ``` 7871 7872### onRemoteRequest<sup>8+(deprecated)</sup> 7873 7874>从API version 9 开始不再维护，建议使用[onRemoteMessageRequest](#onremotemessagerequest9)类替代。 7875 7876onRemoteRequest(code: number, data: MessageParcel, reply: MessageParcel, options: MessageOption): boolean 7877 7878sendMessageRequest请求的响应处理函数，服务端在该函数里处理请求，回复结果。 7879 7880**系统能力**：SystemCapability.Communication.IPC.Core 7881 7882**参数：** 7883 7884 | 参数名 | 类型 | 必填 | 说明 | 7885 | ------ | ------------------------------- | ---- | --------------------------------------- | 7886 | code | number | 是 | 对端发送的服务请求码。 | 7887 | data | [MessageParcel](#messageparceldeprecated) | 是 | 携带客户端调用参数的MessageParcel对象。 | 7888 | reply | [MessageParcel](#messageparceldeprecated) | 是 | 写入结果的MessageParcel对象。 | 7889 | option | [MessageOption](#messageoption) | 是 | 指示操作是同步还是异步。 | 7890 7891**返回值：** 7892 7893 | 类型 | 说明 | 7894 | ------- | ----------------------------------------- | 7895 | boolean | true：操作成功，false：操作失败。| 7896 7897**示例：** 7898 7899 ```ts 7900 class MyDeathRecipient { 7901 onRemoteDied() { 7902 console.log("server died"); 7903 } 7904 } 7905 class TestRemoteObject extends rpc.RemoteObject { 7906 constructor(descriptor) { 7907 super(descriptor); 7908 } 7909 addDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 7910 return true; 7911 } 7912 removeDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 7913 return true; 7914 } 7915 isObjectDead(): boolean { 7916 return false; 7917 } 7918 onRemoteRequest(code, data, reply, option) { 7919 if (code === 1) { 7920 console.log("RpcServer: onRemoteRequest called"); 7921 return true; 7922 } else { 7923 console.log("RpcServer: unknown code: " + code); 7924 return false; 7925 } 7926 } 7927 } 7928 ``` 7929 7930### onRemoteMessageRequest<sup>9+</sup> 7931 7932onRemoteMessageRequest(code: number, data: MessageSequence, reply: MessageSequence, options: MessageOption): boolean | Promise\<boolean> 7933 7934> **说明：** 7935> 7936>* 开发者应优先选择重载onRemoteMessageRequest方法，其中可以自由实现同步和异步的消息处理。 7937>* 开发者同时重载onRemoteRequest和onRemoteMessageRequest方法时，仅onRemoteMessageRequest方法生效。 7938 7939sendMessageRequest请求的响应处理函数，服务端在该函数里同步或异步地处理请求，回复结果。 7940 7941**系统能力**：SystemCapability.Communication.IPC.Core 7942 7943**参数：** 7944 7945 | 参数名 | 类型 | 必填 | 说明 | 7946 | ------ | ------------------------------- | ---- | ----------------------------------------- | 7947 | code | number | 是 | 对端发送的服务请求码。 | 7948 | data | [MessageSequence](#messagesequence9) | 是 | 携带客户端调用参数的MessageSequence对象。 | 7949 | reply | [MessageSequence](#messagesequence9) | 是 | 写入结果的MessageSequence对象。 | 7950 | option | [MessageOption](#messageoption) | 是 | 指示操作是同步还是异步。 | 7951 7952**返回值：** 7953 7954 | 类型 | 说明 | 7955 | ----------------- | ---------------------------------------------------------------------------------------------- | 7956 | boolean | 若在onRemoteMessageRequest中同步地处理请求，则返回一个布尔值：true：操作成功，false：操作失败。 | 7957 | Promise\<boolean> | 若在onRemoteMessageRequest中异步地处理请求，则返回一个Promise对象。 | 7958 7959**重载onRemoteMessageRequest方法同步处理请求示例：** 7960 7961 ```ts 7962 class TestRemoteObject extends rpc.RemoteObject { 7963 constructor(descriptor) { 7964 super(descriptor); 7965 } 7966 7967 onRemoteMessageRequest(code, data, reply, option) { 7968 if (code === 1) { 7969 console.log("RpcServer: sync onRemoteMessageRequest is called"); 7970 return true; 7971 } else { 7972 console.log("RpcServer: unknown code: " + code); 7973 return false; 7974 } 7975 } 7976 } 7977 ``` 7978 7979 **重载onRemoteMessageRequest方法异步处理请求示例：** 7980 7981 ```ts 7982 class TestRemoteObject extends rpc.RemoteObject { 7983 constructor(descriptor) { 7984 super(descriptor); 7985 } 7986 7987 async onRemoteMessageRequest(code, data, reply, option) { 7988 if (code === 1) { 7989 console.log("RpcServer: async onRemoteMessageRequest is called"); 7990 } else { 7991 console.log("RpcServer: unknown code: " + code); 7992 return false; 7993 } 7994 await new Promise((resolve) => { 7995 setTimeout(resolve, 100); 7996 }) 7997 return true; 7998 } 7999 } 8000 ``` 8001 8002**同时重载onRemoteMessageRequest和onRemoteRequest方法同步处理请求示例：** 8003 8004 ```ts 8005 class TestRemoteObject extends rpc.RemoteObject { 8006 constructor(descriptor) { 8007 super(descriptor); 8008 } 8009 8010 onRemoteRequest(code, data, reply, option) { 8011 if (code === 1) { 8012 console.log("RpcServer: sync onRemoteMessageRequest is called"); 8013 return true; 8014 } else { 8015 console.log("RpcServer: unknown code: " + code); 8016 return false; 8017 } 8018 } 8019 // 同时调用仅会执行onRemoteMessageRequest 8020 onRemoteMessageRequest(code, data, reply, option) { 8021 if (code === 1) { 8022 console.log("RpcServer: async onRemoteMessageRequest is called"); 8023 } else { 8024 console.log("RpcServer: unknown code: " + code); 8025 return false; 8026 } 8027 8028 return true; 8029 } 8030 } 8031 ``` 8032 8033 **同时重载onRemoteMessageRequest和onRemoteRequest方法异步处理请求示例：** 8034 8035 ```ts 8036 class TestRemoteObject extends rpc.RemoteObject { 8037 constructor(descriptor) { 8038 super(descriptor); 8039 } 8040 8041 onRemoteRequest(code, data, reply, option) { 8042 if (code === 1) { 8043 console.log("RpcServer: sync onRemoteRequest is called"); 8044 return true; 8045 } else { 8046 console.log("RpcServer: unknown code: " + code); 8047 return false; 8048 } 8049 } 8050 // 同时调用仅会执行onRemoteMessageRequest 8051 async onRemoteMessageRequest(code, data, reply, option) { 8052 if (code === 1) { 8053 console.log("RpcServer: async onRemoteMessageRequest is called"); 8054 } else { 8055 console.log("RpcServer: unknown code: " + code); 8056 return false; 8057 } 8058 await new Promise((resolve) => { 8059 setTimeout(resolve, 100); 8060 }) 8061 return true; 8062 } 8063 } 8064 ``` 8065 8066### getCallingUid 8067 8068getCallingUid(): number 8069 8070获取通信对端的进程Uid。 8071 8072**系统能力**：SystemCapability.Communication.IPC.Core 8073 8074**返回值：** 8075 | 类型 | 说明 | 8076 | ------ | ----------------------- | 8077 | number | 返回通信对端的进程Uid。 | 8078 8079**示例：** 8080 8081 ```ts 8082 class TestRemoteObject extends rpc.RemoteObject { 8083 constructor(descriptor) { 8084 super(descriptor); 8085 } 8086 } 8087 let testRemoteObject = new TestRemoteObject("testObject"); 8088 console.log("RpcServer: getCallingUid: " + testRemoteObject.getCallingUid()); 8089 ``` 8090 8091### getCallingPid 8092 8093getCallingPid(): number 8094 8095获取通信对端的进程Pid。 8096 8097**系统能力**：SystemCapability.Communication.IPC.Core 8098 8099**返回值：** 8100 8101 | 类型 | 说明 | 8102 | ------ | ----------------------- | 8103 | number | 返回通信对端的进程Pid。 | 8104 8105**示例：** 8106 8107 ```ts 8108 class TestRemoteObject extends rpc.RemoteObject { 8109 constructor(descriptor) { 8110 super(descriptor); 8111 } 8112 } 8113 let testRemoteObject = new TestRemoteObject("testObject"); 8114 console.log("RpcServer: getCallingPid: " + testRemoteObject.getCallingPid()); 8115 ``` 8116 8117### getLocalInterface<sup>9+</sup> 8118 8119getLocalInterface(descriptor: string): IRemoteBroker 8120 8121查询接口描述符的字符串。 8122 8123**系统能力**：SystemCapability.Communication.IPC.Core 8124 8125**参数：** 8126 8127 | 参数名 | 类型 | 必填 | 说明 | 8128 | ---------- | ------ | ---- | -------------------- | 8129 | descriptor | string | 是 | 接口描述符的字符串。 | 8130 8131**返回值：** 8132 8133 | 类型 | 说明 | 8134 | ------------- | --------------------------------------------- | 8135 | IRemoteBroker | 返回绑定到指定接口描述符的IRemoteBroker对象。 | 8136 8137 8138**示例：** 8139 8140 ```ts 8141 class MyDeathRecipient { 8142 onRemoteDied() { 8143 console.log("server died"); 8144 } 8145 } 8146 class TestRemoteObject extends rpc.RemoteObject { 8147 constructor(descriptor) { 8148 super(descriptor); 8149 } 8150 registerDeathRecipient(recipient: MyDeathRecipient, flags: number) { 8151 // 方法逻辑需开发者根据业务需要实现 8152 } 8153 unregisterDeathRecipient(recipient: MyDeathRecipient, flags: number) { 8154 // 方法逻辑需开发者根据业务需要实现 8155 } 8156 isObjectDead(): boolean { 8157 return false; 8158 } 8159 } 8160 let testRemoteObject = new TestRemoteObject("testObject"); 8161 try { 8162 let broker = testRemoteObject.getLocalInterface("testObject"); 8163 } catch(error) { 8164 console.info("rpc get local interface fail, errorCode " + error.code); 8165 console.info("rpc get local interface fail, errorMessage " + error.message); 8166 } 8167 ``` 8168 8169### queryLocalInterface<sup>(deprecated)</sup> 8170 8171>从API version 9 开始不再维护，建议使用[getLocalInterface](#getlocalinterface9)类替代。 8172 8173queryLocalInterface(descriptor: string): IRemoteBroker 8174 8175查询并获取当前接口描述符对应的远端对象是否已经存在。 8176 8177**系统能力**：SystemCapability.Communication.IPC.Core 8178 8179**参数：** 8180 8181 | 参数名 | 类型 | 必填 | 说明 | 8182 | ---------- | ------ | ---- | ---------------------- | 8183 | descriptor | string | 是 | 需要查询的接口描述符。 | 8184 8185**返回值：** 8186 8187 | 类型 | 说明 | 8188 | ------------- | ------------------------------------------------------------------ | 8189 | IRemoteBroker | 如果接口描述符对应的远端对象存在，则返回该远端对象，否则返回Null。 | 8190 8191**示例：** 8192 8193 ```ts 8194 class MyDeathRecipient { 8195 onRemoteDied() { 8196 console.log("server died"); 8197 } 8198 } 8199 class TestRemoteObject extends rpc.RemoteObject { 8200 constructor(descriptor) { 8201 super(descriptor); 8202 } 8203 addDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 8204 return true; 8205 } 8206 removeDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 8207 return true; 8208 } 8209 isObjectDead(): boolean { 8210 return false; 8211 } 8212 } 8213 let testRemoteObject = new TestRemoteObject("testObject"); 8214 let broker = testRemoteObject.queryLocalInterface("testObject"); 8215 ``` 8216 8217### getDescriptor<sup>9+</sup> 8218 8219getDescriptor(): string 8220 8221获取对象的接口描述符。接口描述符为字符串。 8222 8223**系统能力**：SystemCapability.Communication.IPC.Core 8224 8225**返回值：** 8226 8227 | 类型 | 说明 | 8228 | ------ | ---------------- | 8229 | string | 返回接口描述符。 | 8230 8231**错误码：** 8232 8233以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 8234 8235 | 错误码ID | 错误信息 | 8236 | ------- | -------- | 8237 | 1900008 | proxy or remote object is invalid | 8238 8239**示例：** 8240 8241 ```ts 8242 class MyDeathRecipient { 8243 onRemoteDied() { 8244 console.log("server died"); 8245 } 8246 } 8247 class TestRemoteObject extends rpc.RemoteObject { 8248 constructor(descriptor) { 8249 super(descriptor); 8250 } 8251 registerDeathRecipient(recipient: MyDeathRecipient, flags: number) { 8252 // 方法逻辑需开发者根据业务需要实现 8253 } 8254 unregisterDeathRecipient(recipient: MyDeathRecipient, flags: number) { 8255 // 方法逻辑需开发者根据业务需要实现 8256 } 8257 isObjectDead(): boolean { 8258 return false; 8259 } 8260 } 8261 let testRemoteObject = new TestRemoteObject("testObject"); 8262 console.log("RpcServer: descriptor is: " + descriptor); 8263 try { 8264 let descriptor = testRemoteObject.getDescriptor(); 8265 } catch(error) { 8266 console.info("rpc get local interface fail, errorCode " + error.code); 8267 console.info("rpc get local interface fail, errorMessage " + error.message); 8268 } 8269 ``` 8270 8271### getInterfaceDescriptor<sup>(deprecated)</sup> 8272 8273>从API version 9 开始不再维护，建议使用[getDescriptor](#getdescriptor9)类替代。 8274 8275getInterfaceDescriptor(): string 8276 8277查询接口描述符。 8278 8279**系统能力**：SystemCapability.Communication.IPC.Core 8280 8281**返回值：** 8282 8283 | 类型 | 说明 | 8284 | ------ | ---------------- | 8285 | string | 返回接口描述符。 | 8286 8287**示例：** 8288 8289 ```ts 8290 class MyDeathRecipient { 8291 onRemoteDied() { 8292 console.log("server died"); 8293 } 8294 } 8295 class TestRemoteObject extends rpc.RemoteObject { 8296 constructor(descriptor) { 8297 super(descriptor); 8298 } 8299 addDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 8300 return true; 8301 } 8302 removeDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 8303 return true; 8304 } 8305 isObjectDead(): boolean { 8306 return false; 8307 } 8308 } 8309 let testRemoteObject = new TestRemoteObject("testObject"); 8310 let descriptor = testRemoteObject.getInterfaceDescriptor(); 8311 console.log("RpcServer: descriptor is: " + descriptor); 8312 ``` 8313 8314### modifyLocalInterface<sup>9+</sup> 8315 8316modifyLocalInterface(localInterface: IRemoteBroker, descriptor: string): void 8317 8318此接口用于把接口描述符和IRemoteBroker对象绑定。 8319 8320**系统能力**：SystemCapability.Communication.IPC.Core 8321 8322**参数：** 8323 8324 | 参数名 | 类型 | 必填 | 说明 | 8325 | -------------- | ------------- | ---- | ------------------------------------- | 8326 | localInterface | IRemoteBroker | 是 | 将与描述符绑定的IRemoteBroker对象。 | 8327 | descriptor | string | 是 | 用于与IRemoteBroker对象绑定的描述符。 | 8328 8329**示例：** 8330 8331 ```ts 8332 class MyDeathRecipient { 8333 onRemoteDied() { 8334 console.log("server died"); 8335 } 8336 } 8337 class TestRemoteObject extends rpc.RemoteObject { 8338 constructor(descriptor) { 8339 super(descriptor); 8340 try { 8341 this.modifyLocalInterface(this, descriptor); 8342 } catch(error) { 8343 console.info(" rpc attach local interface fail, errorCode " + error.code); 8344 console.info(" rpc attach local interface fail, errorMessage " + error.message); 8345 } 8346 } 8347 registerDeathRecipient(recipient: MyDeathRecipient, flags: number) { 8348 // 方法逻辑需开发者根据业务需要实现 8349 } 8350 unregisterDeathRecipient(recipient: MyDeathRecipient, flags: number) { 8351 // 方法逻辑需开发者根据业务需要实现 8352 } 8353 isObjectDead(): boolean { 8354 return false; 8355 } 8356 asObject(): rpc.IRemoteObject { 8357 return this; 8358 } 8359 } 8360 let testRemoteObject = new TestRemoteObject("testObject"); 8361 ``` 8362 8363### attachLocalInterface<sup>(deprecated)</sup> 8364 8365>从API version 9 开始不再维护，建议使用[modifyLocalInterface](#modifylocalinterface9)类替代。 8366 8367attachLocalInterface(localInterface: IRemoteBroker, descriptor: string): void 8368 8369此接口用于把接口描述符和IRemoteBroker对象绑定。 8370 8371**系统能力**：SystemCapability.Communication.IPC.Core 8372 8373**参数：** 8374 8375 | 参数名 | 类型 | 必填 | 说明 | 8376 | -------------- | ------------- | ---- | ------------------------------------- | 8377 | localInterface | IRemoteBroker | 是 | 将与描述符绑定的IRemoteBroker对象。 | 8378 | descriptor | string | 是 | 用于与IRemoteBroker对象绑定的描述符。 | 8379 8380**示例：** 8381 8382 ```ts 8383 class MyDeathRecipient { 8384 onRemoteDied() { 8385 console.log("server died"); 8386 } 8387 } 8388 class TestRemoteObject extends rpc.RemoteObject { 8389 constructor(descriptor) { 8390 super(descriptor); 8391 this.attachLocalInterface(this, descriptor); 8392 } 8393 addDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 8394 return true; 8395 } 8396 removeDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 8397 return true; 8398 } 8399 isObjectDead(): boolean { 8400 return false; 8401 } 8402 asObject(): rpc.IRemoteObject { 8403 return this; 8404 } 8405 } 8406 let testRemoteObject = new TestRemoteObject("testObject"); 8407 ``` 8408 8409## Ashmem<sup>8+</sup> 8410 8411提供与匿名共享内存对象相关的方法，包括创建、关闭、映射和取消映射Ashmem、从Ashmem读取数据和写入数据、获取Ashmem大小、设置Ashmem保护。 8412 8413**系统能力**：以下各项对应的系统能力均为SystemCapability.Communication.IPC.Core。 8414 8415映射内存保护类型： 8416 8417 | 名称 | 值 | 说明 | 8418 | ---------- | --- | ------------------ | 8419 | PROT_EXEC | 4 | 映射的内存可执行 | 8420 | PROT_NONE | 0 | 映射的内存不可访问 | 8421 | PROT_READ | 1 | 映射的内存可读 | 8422 | PROT_WRITE | 2 | 映射的内存可写 | 8423 8424### create<sup>9+</sup> 8425 8426static create(name: string, size: number): Ashmem 8427 8428静态方法，根据指定的名称和大小创建Ashmem对象。 8429 8430**系统能力**：SystemCapability.Communication.IPC.Core 8431 8432**参数：** 8433 8434 | 参数名 | 类型 | 必填 | 说明 | 8435 | ------ | ------ | ---- | ---------------------------- | 8436 | name | string | 是 | 名称，用于查询Ashmem信息。 | 8437 | size | number | 是 | Ashmem的大小，以字节为单位。 | 8438 8439**返回值：** 8440 8441 | 类型 | 说明 | 8442 | ------ | ---------------------------------------------- | 8443 | Ashmem | 返回创建的Ashmem对象；如果创建失败，返回null。 | 8444 8445**示例：** 8446 8447 ```ts 8448 let ashmem; 8449 try { 8450 ashmem = rpc.Ashmem.create("ashmem", 1024*1024); 8451 } catch(error) { 8452 console.info("Rpc creat ashmem fail, errorCode " + error.code); 8453 console.info("Rpc creat ashmem fail, errorMessage " + error.message); 8454 } 8455 let size = ashmem.getAshmemSize(); 8456 console.log("RpcTest: get ashemm by create : " + ashmem + " size is : " + size); 8457 ``` 8458 8459### createAshmem<sup>8+(deprecated)</sup> 8460 8461>从API version 9 开始不再维护，建议使用[create](#create9)类替代。 8462 8463static createAshmem(name: string, size: number): Ashmem 8464 8465静态方法，根据指定的名称和大小创建Ashmem对象。 8466 8467**系统能力**：SystemCapability.Communication.IPC.Core 8468 8469**参数：** 8470 8471 | 参数名 | 类型 | 必填 | 说明 | 8472 | ------ | ------ | ---- | ---------------------------- | 8473 | name | string | 是 | 名称，用于查询Ashmem信息。 | 8474 | size | number | 是 | Ashmem的大小，以字节为单位。 | 8475 8476**返回值：** 8477 8478 | 类型 | 说明 | 8479 | ------ | ---------------------------------------------- | 8480 | Ashmem | 返回创建的Ashmem对象；如果创建失败，返回null。 | 8481 8482**示例：** 8483 8484 ```ts 8485 let ashmem = rpc.Ashmem.createAshmem("ashmem", 1024*1024); 8486 let size = ashmem.getAshmemSize(); 8487 console.log("RpcTest: get ashemm by createAshmem : " + ashmem + " size is : " + size); 8488 ``` 8489 8490### create<sup>9+</sup> 8491 8492static create(ashmem: Ashmem): Ashmem 8493 8494静态方法，通过复制现有Ashmem对象的文件描述符(fd)来创建Ashmem对象。两个Ashmem对象指向同一个共享内存区域。 8495 8496**系统能力**：SystemCapability.Communication.IPC.Core 8497 8498**参数：** 8499 8500 | 参数名 | 类型 | 必填 | 说明 | 8501 | ------ | ------ | ---- | -------------------- | 8502 | ashmem | Ashmem | 是 | 已存在的Ashmem对象。 | 8503 8504**返回值：** 8505 8506 | 类型 | 说明 | 8507 | ------ | ---------------------- | 8508 | Ashmem | 返回创建的Ashmem对象。 | 8509 8510 8511**示例：** 8512 8513 ```ts 8514 let ashmem2; 8515 try { 8516 let ashmem = rpc.Ashmem.create("ashmem", 1024*1024); 8517 let ashmem2 = rpc.Ashmem.create(ashmem); 8518 } catch(error) { 8519 console.info("Rpc creat ashmem from existing fail, errorCode " + error.code); 8520 console.info("Rpc creat ashmem from existing fail, errorMessage " + error.message); 8521 } 8522 let size = ashmem2.getAshmemSize(); 8523 console.log("RpcTest: get ashemm by create : " + ashmem2 + " size is : " + size); 8524 ``` 8525 8526### createAshmemFromExisting<sup>8+(deprecated)</sup> 8527 8528>从API version 9 开始不再维护，建议使用[create](#create9)类替代。 8529 8530static createAshmemFromExisting(ashmem: Ashmem): Ashmem 8531 8532静态方法，通过复制现有Ashmem对象的文件描述符(fd)来创建Ashmem对象。两个Ashmem对象指向同一个共享内存区域。 8533 8534**系统能力**：SystemCapability.Communication.IPC.Core 8535 8536**参数：** 8537 8538 | 参数名 | 类型 | 必填 | 说明 | 8539 | ------ | ------ | ---- | -------------------- | 8540 | ashmem | Ashmem | 是 | 已存在的Ashmem对象。 | 8541 8542**返回值：** 8543 8544 | 类型 | 说明 | 8545 | ------ | ---------------------- | 8546 | Ashmem | 返回创建的Ashmem对象。 | 8547 8548**示例：** 8549 8550 ```ts 8551 let ashmem = rpc.Ashmem.createAshmem("ashmem", 1024*1024); 8552 let ashmem2 = rpc.Ashmem.createAshmemFromExisting(ashmem); 8553 let size = ashmem2.getAshmemSize(); 8554 console.log("RpcTest: get ashemm by createAshmemFromExisting : " + ashmem2 + " size is : " + size); 8555 ``` 8556 8557### closeAshmem<sup>8+</sup> 8558 8559closeAshmem(): void 8560 8561关闭这个Ashmem。 8562 8563**系统能力**：SystemCapability.Communication.IPC.Core 8564 8565**示例：** 8566 8567 ```ts 8568 let ashmem = rpc.Ashmem.create("ashmem", 1024*1024); 8569 ashmem.closeAshmem(); 8570 ``` 8571 8572### unmapAshmem<sup>8+</sup> 8573 8574unmapAshmem(): void 8575 8576删除该Ashmem对象的地址映射。 8577 8578**系统能力**：SystemCapability.Communication.IPC.Core 8579 8580**示例：** 8581 8582 ```ts 8583 let ashmem = rpc.Ashmem.create("ashmem", 1024*1024); 8584 ashmem.unmapAshmem(); 8585 ``` 8586 8587### getAshmemSize<sup>8+</sup> 8588 8589getAshmemSize(): number 8590 8591获取Ashmem对象的内存大小。 8592 8593**系统能力**：SystemCapability.Communication.IPC.Core 8594 8595**返回值：** 8596 8597 | 类型 | 说明 | 8598 | ------ | -------------------------- | 8599 | number | 返回Ashmem对象的内存大小。 | 8600 8601**示例：** 8602 8603 ```ts 8604 let ashmem = rpc.Ashmem.createAshmem("ashmem", 1024*1024); 8605 let size = ashmem.getAshmemSize(); 8606 console.log("RpcTest: get ashmem is " + ashmem + " size is : " + size); 8607 ``` 8608 8609### mapTypedAshmem<sup>9+</sup> 8610 8611mapTypedAshmem(mapType: number): void 8612 8613在此进程的虚拟地址空间上创建共享文件映射，映射区域大小由此Ashmem对象指定。 8614 8615**系统能力**：SystemCapability.Communication.IPC.Core 8616 8617**参数：** 8618 8619 | 参数名 | 类型 | 必填 | 说明 | 8620 | ------- | ------ | ---- | ------------------------------ | 8621 | mapType | number | 是 | 指定映射的内存区域的保护等级。 | 8622 8623**错误码：** 8624 8625以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 8626 8627 | 错误码ID | 错误信息 | 8628 | ------- | ------ | 8629 | 1900001 | call mmap function failed | 8630 8631**示例：** 8632 8633 ```ts 8634 let ashmem = rpc.Ashmem.create("ashmem", 1024*1024); 8635 try { 8636 ashmem.mapTypedAshmem(ashmem.PROT_READ | ashmem.PROT_WRITE); 8637 } catch(error) { 8638 console.info("Rpc map ashmem fail, errorCode " + error.code); 8639 console.info("Rpc map ashmem fail, errorMessage " + error.message); 8640 } 8641 ``` 8642 8643### mapAshmem<sup>8+(deprecated)</sup> 8644 8645>从API version 9 开始不再维护，建议使用[mapTypedAshmem](#maptypedashmem9)类替代。 8646 8647mapAshmem(mapType: number): boolean 8648 8649在此进程的虚拟地址空间上创建共享文件映射，映射区域大小由此Ashmem对象指定。 8650 8651**系统能力**：SystemCapability.Communication.IPC.Core 8652 8653**参数：** 8654 8655 | 参数名 | 类型 | 必填 | 说明 | 8656 | ------- | ------ | ---- | ------------------------------ | 8657 | mapType | number | 是 | 指定映射的内存区域的保护等级。 | 8658 8659**返回值：** 8660 8661 | 类型 | 说明 | 8662 | ------- | ----------------------------------------- | 8663 | boolean | true：映射成功，false：映射失败。| 8664 8665**示例：** 8666 8667 ```ts 8668 let ashmem = rpc.Ashmem.createAshmem("ashmem", 1024*1024); 8669 let mapReadAndWrite = ashmem.mapAshmem(ashmem.PROT_READ | ashmem.PROT_WRITE); 8670 console.log("RpcTest: map ashmem result is : " + mapReadAndWrite); 8671 ``` 8672 8673### mapReadWriteAshmem<sup>9+</sup> 8674 8675mapReadWriteAshmem(): void 8676 8677在此进程虚拟地址空间上创建可读写的共享文件映射。 8678 8679**系统能力**：SystemCapability.Communication.IPC.Core 8680 8681**错误码：** 8682 8683以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 8684 8685 | 错误码ID | 错误信息 | 8686 | ------- | -------- | 8687 | 1900001 | call mmap function failed | 8688 8689**示例：** 8690 8691 ```ts 8692 let ashmem = rpc.Ashmem.create("ashmem", 1024*1024); 8693 try { 8694 ashmem.mapReadWriteAshmem(); 8695 } catch(error) { 8696 console.info("Rpc map read and write ashmem fail, errorCode " + error.code); 8697 console.info("Rpc map read and write ashmem fail, errorMessage " + error.message); 8698 } 8699 ``` 8700 8701### mapReadAndWriteAshmem<sup>8+(deprecated)</sup> 8702 8703>从API version 9 开始不再维护，建议使用[mapReadWriteAshmem](#mapreadwriteashmem9)类替代。 8704 8705mapReadAndWriteAshmem(): boolean 8706 8707在此进程虚拟地址空间上创建可读写的共享文件映射。 8708 8709**系统能力**：SystemCapability.Communication.IPC.Core 8710 8711**返回值：** 8712 8713 | 类型 | 说明 | 8714 | ------- | ----------------------------------------- | 8715 | boolean | true：映射成功，false：映射失败。| 8716 8717**示例：** 8718 8719 ```ts 8720 let ashmem = rpc.Ashmem.createAshmem("ashmem", 1024*1024); 8721 let mapResult = ashmem.mapReadAndWriteAshmem(); 8722 console.log("RpcTest: map ashmem result is : " + mapResult); 8723 ``` 8724 8725### mapReadonlyAshmem<sup>9+</sup> 8726 8727mapReadonlyAshmem(): void 8728 8729在此进程虚拟地址空间上创建只读的共享文件映射。 8730 8731**系统能力**：SystemCapability.Communication.IPC.Core 8732 8733**错误码：** 8734 8735以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 8736 8737 | 错误码ID | 错误信息 | 8738 | ------- | -------- | 8739 | 1900001 | call mmap function failed | 8740 8741**示例：** 8742 8743 ```ts 8744 let ashmem = rpc.Ashmem.create("ashmem", 1024*1024); 8745 try { 8746 ashmem.mapReadonlyAshmem(); 8747 } catch(error) { 8748 console.info("Rpc map read and write ashmem fail, errorCode " + error.code); 8749 console.info("Rpc map read and write ashmem fail, errorMessage " + error.message); 8750 } 8751 ``` 8752 8753### mapReadOnlyAshmem<sup>8+(deprecated)</sup> 8754 8755>从API version 9 开始不再维护，建议使用[mapReadonlyAshmem](#mapreadonlyashmem9)类替代。 8756 8757mapReadOnlyAshmem(): boolean 8758 8759在此进程虚拟地址空间上创建只读的共享文件映射。 8760 8761**系统能力**：SystemCapability.Communication.IPC.Core 8762 8763**返回值：** 8764 8765 | 类型 | 说明 | 8766 | ------- | ----------------------------------------- | 8767 | boolean | true：映射成功，false：映射失败。| 8768 8769**示例：** 8770 8771 ```ts 8772 let ashmem = rpc.Ashmem.createAshmem("ashmem", 1024*1024); 8773 let mapResult = ashmem.mapReadOnlyAshmem(); 8774 console.log("RpcTest: Ashmem mapReadOnlyAshmem result is : " + mapResult); 8775 ``` 8776 8777### setProtectionType<sup>9+</sup> 8778 8779setProtectionType(protectionType: number): void 8780 8781设置映射内存区域的保护等级。 8782 8783**系统能力**：SystemCapability.Communication.IPC.Core 8784 8785**参数：** 8786 8787 | 参数名 | 类型 | 必填 | 说明 | 8788 | -------------- | ------ | ---- | ------------------ | 8789 | protectionType | number | 是 | 要设置的保护类型。 | 8790 8791**错误码：** 8792 8793以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 8794 8795 | 错误码ID | 错误信息 | 8796 | -------- | ------- | 8797 | 1900002 | call os ioctl function failed | 8798 8799**示例：** 8800 8801 ```ts 8802 let ashmem = rpc.Ashmem.create("ashmem", 1024*1024); 8803 try { 8804 ashmem.setProtection(ashmem.PROT_READ); 8805 } catch(error) { 8806 console.info("Rpc set protection type fail, errorCode " + error.code); 8807 console.info("Rpc set protection type fail, errorMessage " + error.message); 8808 } 8809 ``` 8810 8811### setProtection<sup>8+(deprecated)</sup> 8812 8813>从API version 9 开始不再维护，建议使用[setProtectionType](#setprotectiontype9)类替代。 8814 8815setProtection(protectionType: number): boolean 8816 8817设置映射内存区域的保护等级。 8818 8819**系统能力**：SystemCapability.Communication.IPC.Core 8820 8821**参数：** 8822 8823 | 参数名 | 类型 | 必填 | 说明 | 8824 | -------------- | ------ | ---- | ------------------ | 8825 | protectionType | number | 是 | 要设置的保护类型。 | 8826 8827**返回值：** 8828 8829 | 类型 | 说明 | 8830 | ------- | ----------------------------------------- | 8831 | boolean | true：设置成功，false：设置失败。| 8832 8833**示例：** 8834 8835 ```ts 8836 let ashmem = rpc.Ashmem.createAshmem("ashmem", 1024*1024); 8837 let result = ashmem.setProtection(ashmem.PROT_READ); 8838 console.log("RpcTest: Ashmem setProtection result is : " + result); 8839 ``` 8840 8841### writeAshmem<sup>9+</sup> 8842 8843writeAshmem(buf: number[], size: number, offset: number): void 8844 8845将数据写入此Ashmem对象关联的共享文件。 8846 8847**系统能力**：SystemCapability.Communication.IPC.Core 8848 8849**参数：** 8850 8851 | 参数名 | 类型 | 必填 | 说明 | 8852 | ------ | -------- | ---- | -------------------------------------------------- | 8853 | buf | number[] | 是 | 写入Ashmem对象的数据。 | 8854 | size | number | 是 | 要写入的数据大小。 | 8855 | offset | number | 是 | 要写入的数据在此Ashmem对象关联的内存区间的起始位置 | 8856 8857**错误码：** 8858 8859以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 8860 8861 | 错误码ID | 错误信息 | 8862 | ------- | -------- | 8863 | 1900003 | write to ashmem failed | 8864 8865**示例：** 8866 8867 ```ts 8868 let ashmem = rpc.Ashmem.create("ashmem", 1024*1024); 8869 ashmem.mapReadWriteAshmem(); 8870 var ByteArrayVar = [1, 2, 3, 4, 5]; 8871 try { 8872 ashmem.writeAshmem(ByteArrayVar, 5, 0); 8873 } catch(error) { 8874 console.info("Rpc write to ashmem fail, errorCode " + error.code); 8875 console.info("Rpc write to ashmem fail, errorMessage " + error.message); 8876 } 8877 ``` 8878 8879### writeToAshmem<sup>8+(deprecated)</sup> 8880 8881>从API version 9 开始不再维护，建议使用[writeAshmem](#writeashmem9)类替代。 8882 8883writeToAshmem(buf: number[], size: number, offset: number): boolean 8884 8885将数据写入此Ashmem对象关联的共享文件。 8886 8887**系统能力**：SystemCapability.Communication.IPC.Core 8888 8889**参数：** 8890 8891 | 参数名 | 类型 | 必填 | 说明 | 8892 | ------ | -------- | ---- | -------------------------------------------------- | 8893 | buf | number[] | 是 | 写入Ashmem对象的数据。 | 8894 | size | number | 是 | 要写入的数据大小。 | 8895 | offset | number | 是 | 要写入的数据在此Ashmem对象关联的内存区间的起始位置 | 8896 8897**返回值：** 8898 8899 | 类型 | 说明 | 8900 | ------- | ----------------------------------------------------------------------------------------- | 8901 | boolean | true：如果数据写入成功，false：在其他情况下，如数据写入越界或未获得写入权限。。 | 8902 8903**示例：** 8904 8905 ```ts 8906 let ashmem = rpc.Ashmem.createAshmem("ashmem", 1024*1024); 8907 let mapResult = ashmem.mapReadAndWriteAshmem(); 8908 console.info("RpcTest map ashmem result is " + mapResult); 8909 var ByteArrayVar = [1, 2, 3, 4, 5]; 8910 let writeResult = ashmem.writeToAshmem(ByteArrayVar, 5, 0); 8911 console.log("RpcTest: write to Ashmem result is : " + writeResult); 8912 ``` 8913 8914### readAshmem<sup>9+</sup> 8915 8916readAshmem(size: number, offset: number): number[] 8917 8918从此Ashmem对象关联的共享文件中读取数据。 8919 8920**系统能力**：SystemCapability.Communication.IPC.Core 8921 8922**参数：** 8923 8924 | 参数名 | 类型 | 必填 | 说明 | 8925 | ------ | ------ | ---- | -------------------------------------------------- | 8926 | size | number | 是 | 要读取的数据的大小。 | 8927 | offset | number | 是 | 要读取的数据在此Ashmem对象关联的内存区间的起始位置 | 8928 8929**返回值：** 8930 8931 | 类型 | 说明 | 8932 | -------- | ---------------- | 8933 | number[] | 返回读取的数据。 | 8934 8935**错误码：** 8936 8937以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 8938 8939 | 错误码ID | 错误信息 | 8940 | -------- | -------- | 8941 | 1900004 | read from ashmem failed | 8942 8943**示例：** 8944 8945 ```ts 8946 let ashmem = rpc.Ashmem.create("ashmem", 1024*1024); 8947 ashmem.mapReadWriteAshmem(); 8948 var ByteArrayVar = [1, 2, 3, 4, 5]; 8949 ashmem.writeAshmem(ByteArrayVar, 5, 0); 8950 try { 8951 let readResult = ashmem.readAshmem(5, 0); 8952 console.log("RpcTest: read from Ashmem result is : " + readResult); 8953 } catch(error) { 8954 console.info("Rpc read from ashmem fail, errorCode " + error.code); 8955 console.info("Rpc read from ashmem fail, errorMessage " + error.message); 8956 } 8957 ``` 8958 8959### readFromAshmem<sup>8+(deprecated)</sup> 8960 8961>从API version 9 开始不再维护，建议使用[readAshmem](#readashmem9)类替代。 8962 8963readFromAshmem(size: number, offset: number): number[] 8964 8965从此Ashmem对象关联的共享文件中读取数据。 8966 8967**系统能力**：SystemCapability.Communication.IPC.Core 8968 8969**参数：** 8970 8971 | 参数名 | 类型 | 必填 | 说明 | 8972 | ------ | ------ | ---- | -------------------------------------------------- | 8973 | size | number | 是 | 要读取的数据的大小。 | 8974 | offset | number | 是 | 要读取的数据在此Ashmem对象关联的内存区间的起始位置 | 8975 8976**返回值：** 8977 8978 | 类型 | 说明 | 8979 | -------- | ---------------- | 8980 | number[] | 返回读取的数据。 | 8981 8982**示例：** 8983 8984 ```ts 8985 let ashmem = rpc.Ashmem.createAshmem("ashmem", 1024*1024); 8986 let mapResult = ashmem.mapReadAndWriteAshmem(); 8987 console.info("RpcTest map ashmem result is " + mapResult); 8988 var ByteArrayVar = [1, 2, 3, 4, 5]; 8989 let writeResult = ashmem.writeToAshmem(ByteArrayVar, 5, 0); 8990 console.log("RpcTest: write to Ashmem result is : " + writeResult); 8991 let readResult = ashmem.readFromAshmem(5, 0); 8992 console.log("RpcTest: read to Ashmem result is : " + readResult); 8993 ```