1# RPC通信 2 3本模块提供进程间通信能力，包括设备内的进程间通信（IPC）和设备间的进程间通信（RPC），前者基于Binder驱动，后者基于软总线驱动。 4 5>  **说明：** 6> 本模块首批接口从API version 7开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。 7 8 9## 导入模块 10 11 12``` 13import rpc from '@ohos.rpc'; 14``` 15 16 17## MessageParcel 18 19该类提供读写基础类型及数组、IPC对象、接口描述符和自定义序列化对象的方法。 20 21 22### create 23 24create(): MessageParcel 25 26静态方法，创建MessageParcel对象。 27 28**系统能力**：SystemCapability.Communication.IPC.Core 29 30**返回值：** 31 | 类型 | 说明 | 32 | -------- | -------- | 33 | MessageParcel | 返回创建的MessageParcel对象。 | 34 35**示例：** 36 37 ``` 38 let data = rpc.MessageParcel.create(); 39 console.log("RpcClient: data is " + data); 40 ``` 41 42 43### reclaim 44 45reclaim(): void 46 47释放不再使用的MessageParcel对象。 48 49**系统能力**：SystemCapability.Communication.IPC.Core 50 51**示例：** 52 53 ``` 54 let reply = rpc.MessageParcel.create(); 55 reply.reclaim(); 56 ``` 57 58 59### writeRemoteObject 60 61writeRemoteObject(object: [IRemoteObject](#iremoteobject)): boolean 62 63 序列化远程对象并将其写入MessageParcel对象。 64 65**系统能力**：SystemCapability.Communication.IPC.Core 66 67**参数：** 68 | 参数名 | 类型 | 必填 | 说明 | 69 | -------- | -------- | -------- | -------- | 70 | object | [IRemoteObject](#iremoteobject) | 是 | 要序列化并写入MessageParcel的远程对象。 | 71 72**返回值：** 73 | 类型 | 说明 | 74 | -------- | -------- | 75 | boolean | 如果操作成功，则返回true；否则返回false。 | 76 77**示例：** 78 79 ``` 80 class MyDeathRecipient { 81 onRemoteDied() { 82 console.log("server died"); 83 } 84 } 85 class TestRemoteObject extends rpc.RemoteObject { 86 constructor(descriptor) { 87 super(descriptor); 88 } 89 addDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 90 return true; 91 } 92 removeDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 93 return true; 94 } 95 isObjectDead(): boolean { 96 return false; 97 } 98 } 99 let data = rpc.MessageParcel.create(); 100 let testRemoteObject = new TestRemoteObject("testObject"); 101 data.writeRemoteObject(testRemoteObject); 102 ``` 103 104 105### readRemoteObject 106 107readRemoteObject(): IRemoteObject 108 109从MessageParcel读取远程对象。此方法用于反序列化MessageParcel对象以生成IRemoteObject。远程对象按写入MessageParcel的顺序读取。 110 111**系统能力**：SystemCapability.Communication.IPC.Core 112 113**返回值：** 114 | 类型 | 说明 | 115 | -------- | -------- | 116 | [IRemoteObject](#iremoteobject) | 读取到的远程对象。 | 117 118**示例：** 119 120 ``` 121 class MyDeathRecipient { 122 onRemoteDied() { 123 console.log("server died"); 124 } 125 } 126 class TestRemoteObject extends rpc.RemoteObject { 127 constructor(descriptor) { 128 super(descriptor); 129 } 130 addDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 131 return true; 132 } 133 removeDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 134 return true; 135 } 136 isObjectDead(): boolean { 137 return false; 138 } 139 } 140 let data = rpc.MessageParcel.create(); 141 let testRemoteObject = new TestRemoteObject("testObject"); 142 data.writeRemoteObject(testRemoteObject); 143 let proxy = data.readRemoteObject(); 144 ``` 145 146 147### writeInterfaceToken 148 149writeInterfaceToken(token: string): boolean 150 151将接口描述符写入MessageParcel对象。 152 153**系统能力**：SystemCapability.Communication.IPC.Core 154 155**参数：** 156 | 参数名 | 类型 | 必填 | 说明 | 157 | -------- | -------- | -------- | -------- | 158 | token | string | 是 | 字符串类型描述符。 | 159 160**返回值：** 161 | 类型 | 说明 | 162 | -------- | -------- | 163 | boolean | 如果操作成功，则返回true；否则返回false。 | 164 165**示例：** 166 167 ``` 168 let data = rpc.MessageParcel.create(); 169 let result = data.writeInterfaceToken("aaa"); 170 console.log("RpcServer: writeInterfaceToken is " + result); 171 ``` 172 173 174### readInterfaceToken 175 176readInterfaceToken(): string 177 178从MessageParcel中读取接口描述符。接口描述符按写入MessageParcel的顺序读取。 179 180**系统能力**：SystemCapability.Communication.IPC.Core 181 182**返回值：** 183 | 类型 | 说明 | 184 | -------- | -------- | 185 | string | 返回读取到的接口描述符。 | 186 187**示例：** 188 189 ``` 190 class Stub extends rpc.RemoteObject { 191 onRemoteRequest(code, data, reply, option) { 192 let interfaceToken = data.readInterfaceToken(); 193 console.log("RpcServer: interfaceToken is " + interfaceToken); 194 return true; 195 } 196 } 197 ``` 198 199 200### getSize 201 202getSize(): number 203 204获取当前MessageParcel的数据大小。 205 206**系统能力**：SystemCapability.Communication.IPC.Core 207 208**返回值：** 209 | 类型 | 说明 | 210 | -------- | -------- | 211 | number | 获取的MessageParcel的数据大小。以字节为单位。 | 212 213**示例：** 214 215 ``` 216 let data = rpc.MessageParcel.create(); 217 let size = data.getSize(); 218 console.log("RpcClient: size is " + size); 219 ``` 220 221 222### getCapacity 223 224getCapacity(): number 225 226获取当前MessageParcel的容量。 227 228**系统能力**：SystemCapability.Communication.IPC.Core 229 230**返回值：** 231 | 类型 | 说明 | 232 | -------- | -------- | 233 | number | 获取的MessageParcel的容量大小。以字节为单位。 | 234 235**示例：** 236 237 ``` 238 let data = rpc.MessageParcel.create(); 239 let result = data.getCapacity(); 240 console.log("RpcClient: capacity is " + result); 241 ``` 242 243 244### setSize 245 246setSize(size: number): boolean 247 248设置MessageParcel实例中包含的数据大小。 249 250**系统能力**：SystemCapability.Communication.IPC.Core 251 252**参数：** 253 | 参数名 | 类型 | 必填 | 说明 | 254 | -------- | -------- | -------- | -------- | 255 | size | number | 是 | MessageParcel实例的数据大小。以字节为单位。 | 256 257**返回值：** 258 | 类型 | 说明 | 259 | -------- | -------- | 260 | boolean | 设置成功返回true，否则返回false。 | 261 262**示例：** 263 264 ``` 265 let data = rpc.MessageParcel.create(); 266 let setSize = data.setSize(16); 267 console.log("RpcClient: setSize is " + setSize); 268 ``` 269 270 271### setCapacity 272 273setCapacity(size: number): boolean 274 275设置MessageParcel实例的存储容量。 276 277**系统能力**：SystemCapability.Communication.IPC.Core 278 279**参数：** 280 | 参数名 | 类型 | 必填 | 说明 | 281 | -------- | -------- | -------- | -------- | 282 | size | number | 是 | MessageParcel实例的存储容量。以字节为单位。 | 283 284**返回值：** 285 | 类型 | 说明 | 286 | -------- | -------- | 287 | boolean | 设置成功返回true，否则返回false。 | 288 289**示例：** 290 291 ``` 292 let data = rpc.MessageParcel.create(); 293 let result = data.setCapacity(100); 294 console.log("RpcClient: setCapacity is " + result); 295 ``` 296 297 298### getWritableBytes 299 300getWritableBytes(): number 301 302获取MessageParcel的可写字节空间。 303 304**系统能力**：SystemCapability.Communication.IPC.Core 305 306**返回值：** 307 | 类型 | 说明 | 308 | -------- | -------- | 309 | number | 获取到的MessageParcel的可写字节空间。以字节为单位。 | 310 311**示例：** 312 313 ``` 314 class Stub extends rpc.RemoteObject { 315 onRemoteRequest(code, data, reply, option) { 316 let getWritableBytes = data.getWritableBytes(); 317 console.log("RpcServer: getWritableBytes is " + getWritableBytes); 318 return true; 319 } 320 } 321 ``` 322 323 324### getReadableBytes 325 326getReadableBytes(): number 327 328获取MessageParcel的可读字节空间。 329 330**系统能力**：SystemCapability.Communication.IPC.Core 331 332**返回值：** 333 | 类型 | 说明 | 334 | -------- | -------- | 335 | number | 获取到的MessageParcel的可读字节空间。以字节为单位。 | 336 337**示例：** 338 339 ``` 340 class Stub extends rpc.RemoteObject { 341 onRemoteRequest(code, data, reply, option) { 342 let result = data.getReadableBytes(); 343 console.log("RpcServer: getReadableBytes is " + result); 344 return true; 345 } 346 } 347 ``` 348 349 350### getReadPosition 351 352getReadPosition(): number 353 354获取MessageParcel的读位置。 355 356**系统能力**：SystemCapability.Communication.IPC.Core 357 358**返回值：** 359 | 类型 | 说明 | 360 | -------- | -------- | 361 | number | 返回MessageParcel实例中的当前读取位置。 | 362 363**示例：** 364 365 ``` 366 let data = rpc.MessageParcel.create(); 367 let readPos = data.getReadPosition(); 368 console.log("RpcClient: readPos is " + readPos); 369 ``` 370 371 372### getWritePosition 373 374getWritePosition(): number 375 376获取MessageParcel的写位置。 377 378**系统能力**：SystemCapability.Communication.IPC.Core 379 380**返回值：** 381 | 类型 | 说明 | 382 | -------- | -------- | 383 | number | 返回MessageParcel实例中的当前写入位置。 | 384 385**示例：** 386 387 ``` 388 let data = rpc.MessageParcel.create(); 389 data.writeInt(10); 390 let bwPos = data.getWritePosition(); 391 console.log("RpcClient: bwPos is " + bwPos); 392 ``` 393 394 395### rewindRead 396 397rewindRead(pos: number): boolean 398 399重新偏移读取位置到指定的位置。 400 401**系统能力**：SystemCapability.Communication.IPC.Core 402 403**参数：** 404 | 参数名 | 类型 | 必填 | 说明 | 405 | -------- | -------- | -------- | -------- | 406 | pos | number | 是 | 开始读取数据的目标位置。 | 407 408**返回值：** 409 | 类型 | 说明 | 410 | -------- | -------- | 411 | boolean | 如果读取位置发生更改，则返回true；否则返回false。 | 412 413**示例：** 414 415 ``` 416 let data = rpc.MessageParcel.create(); 417 data.writeInt(12); 418 data.writeString("parcel"); 419 let number = data.readInt(); 420 console.log("RpcClient: number is " + number); 421 data.rewindRead(0); 422 let number2 = data.readInt(); 423 console.log("RpcClient: rewindRead is " + number2); 424 ``` 425 426 427### rewindWrite 428 429rewindWrite(pos: number): boolean 430 431重新偏移写位置到指定的位置。 432 433**系统能力**：SystemCapability.Communication.IPC.Core 434 435**参数：** 436 | 参数名 | 类型 | 必填 | 说明 | 437 | -------- | -------- | -------- | -------- | 438 | pos | number | 是 | 开始写入数据的目标位置。 | 439 440**返回值：** 441 | 类型 | 说明 | 442 | -------- | -------- | 443 | boolean | 如果写入位置更改，则返回true；否则返回false。 | 444 445**示例：** 446 447 ``` 448 let data = rpc.MessageParcel.create(); 449 data.writeInt(4); 450 data.rewindWrite(0); 451 data.writeInt(5); 452 let number = data.readInt(); 453 console.log("RpcClient: rewindWrite is: " + number); 454 ``` 455 456 457### writeByte 458 459writeByte(val: number): boolean 460 461将字节值写入MessageParcel实例。 462 463**系统能力**：SystemCapability.Communication.IPC.Core 464 465**参数：** 466 | 参数名 | 类型 | 必填 | 说明 | 467 | -------- | -------- | -------- | -------- | 468 | val | number | 是 | 要写入的字节值。 | 469 470**返回值：** 471 | 类型 | 说明 | 472 | -------- | -------- | 473 | boolean | 写入返回成功，否则返回false。 | 474 475**示例：** 476 477 ``` 478 let data = rpc.MessageParcel.create(); 479 let result = data.writeByte(2); 480 console.log("RpcClient: writeByte is: " + result); 481 ``` 482 483 484### readByte 485 486readByte(): number 487 488从MessageParcel实例读取字节值。 489 490**系统能力**：SystemCapability.Communication.IPC.Core 491 492**返回值：** 493 | 类型 | 说明 | 494 | -------- | -------- | 495 | number | 返回字节值。 | 496 497**示例：** 498 499 ``` 500 let data = rpc.MessageParcel.create(); 501 let result = data.writeByte(2); 502 console.log("RpcClient: writeByte is: " + result); 503 let ret = data.readByte(); 504 console.log("RpcClient: readByte is: " + ret); 505 ``` 506 507 508### writeShort 509 510writeShort(val: number): boolean 511 512将短整数值写入MessageParcel实例。 513 514**系统能力**：SystemCapability.Communication.IPC.Core 515 516**参数：** 517 | 参数名 | 类型 | 必填 | 说明 | 518 | -------- | -------- | -------- | -------- | 519 | val | number | 是 | 要写入的短整数值。 | 520 521**返回值：** 522 | 类型 | 说明 | 523 | -------- | -------- | 524 | boolean | 写入返回true，否则返回false。 | 525 526**示例：** 527 528 ``` 529 let data = rpc.MessageParcel.create(); 530 let result = data.writeShort(8); 531 console.log("RpcClient: writeShort is: " + result); 532 ``` 533 534 535### readShort 536 537readShort(): number 538 539从MessageParcel实例读取短整数值。 540 541**系统能力**：SystemCapability.Communication.IPC.Core 542 543**返回值：** 544 | 类型 | 说明 | 545 | -------- | -------- | 546 | number | 返回短整数值。 | 547 548**示例：** 549 550 ``` 551 let data = rpc.MessageParcel.create(); 552 let result = data.writeShort(8); 553 console.log("RpcClient: writeShort is: " + result); 554 let ret = data.readShort(); 555 console.log("RpcClient: readShort is: " + ret); 556 ``` 557 558 559### writeInt 560 561writeInt(val: number): boolean 562 563将整数值写入MessageParcel实例。 564 565**系统能力**：SystemCapability.Communication.IPC.Core 566 567**参数：** 568 | 参数名 | 类型 | 必填 | 说明 | 569 | -------- | -------- | -------- | -------- | 570 | val | number | 是 | 要写入的整数值。 | 571 572**返回值：** 573 | 类型 | 说明 | 574 | -------- | -------- | 575 | boolean | 写入返回成功，否则返回false。 | 576 577**示例：** 578 579 ``` 580 let data = rpc.MessageParcel.create(); 581 let result = data.writeInt(10); 582 console.log("RpcClient: writeInt is " + result); 583 ``` 584 585 586### readInt 587 588readInt(): number 589 590从MessageParcel实例读取整数值。 591 592**系统能力**：SystemCapability.Communication.IPC.Core 593 594**返回值：** 595 | 类型 | 说明 | 596 | -------- | -------- | 597 | number | 返回整数值。 | 598 599**示例：** 600 601 ``` 602 let data = rpc.MessageParcel.create(); 603 let result = data.writeInt(10); 604 console.log("RpcClient: writeInt is " + result); 605 let ret = data.readInt(); 606 console.log("RpcClient: readInt is " + ret); 607 ``` 608 609 610### writeLong 611 612writeLong(val: number): boolean 613 614将长整数值写入MessageParcel实例。 615 616**系统能力**：SystemCapability.Communication.IPC.Core 617 618**参数：** 619 | 参数名 | 类型 | 必填 | 说明 | 620 | -------- | -------- | -------- | -------- | 621 | val | number | 是 | 要写入的长整数值 | 622 623**返回值：** 624 | 类型 | 说明 | 625 | -------- | -------- | 626 | boolean | 写入成功返回true，否则返回false。 | 627 628**示例：** 629 630 ``` 631 let data = rpc.MessageParcel.create(); 632 let result = data.writeLong(10000); 633 console.log("RpcClient: writeLong is " + result); 634 ``` 635 636 637### readLong 638 639readLong(): number 640 641从MessageParcel实例中读取长整数值。 642 643**系统能力**：SystemCapability.Communication.IPC.Core 644 645**返回值：** 646 | 类型 | 说明 | 647 | -------- | -------- | 648 | number | 返回长整数值。 | 649 650**示例：** 651 652 ``` 653 let data = rpc.MessageParcel.create(); 654 let result = data.writeLong(10000); 655 console.log("RpcClient: writeLong is " + result); 656 let ret = data.readLong(); 657 console.log("RpcClient: readLong is " + ret); 658 ``` 659 660 661### writeFloat 662 663writeFloat(val: number): boolean 664 665将浮点值写入MessageParcel实例。 666 667**系统能力**：SystemCapability.Communication.IPC.Core 668 669**参数：** 670 | 参数名 | 类型 | 必填 | 说明 | 671 | -------- | -------- | -------- | -------- | 672 | val | number | 是 | 要写入的浮点值。 | 673 674**返回值：** 675 | 类型 | 说明 | 676 | -------- | -------- | 677 | boolean | 写入成功返回true，否则返回false。 | 678 679**示例：** 680 681 ``` 682 let data = rpc.MessageParcel.create(); 683 let result = data.writeFloat(1.2); 684 console.log("RpcClient: writeFloat is " + result); 685 ``` 686 687 688### readFloat 689 690readFloat(): number 691 692从MessageParcel实例中读取浮点值。 693 694**系统能力**：SystemCapability.Communication.IPC.Core 695 696**返回值：** 697 | 类型 | 说明 | 698 | -------- | -------- | 699 | number | 返回浮点值。 | 700 701**示例：** 702 703 ``` 704 let data = rpc.MessageParcel.create(); 705 let result = data.writeFloat(1.2); 706 console.log("RpcClient: writeFloat is " + result); 707 let ret = data.readFloat(); 708 console.log("RpcClient: readFloat is " + ret); 709 ``` 710 711 712### writeDouble 713 714writeDouble(val: number): boolean 715 716将双精度浮点值写入MessageParcel实例。 717 718**系统能力**：SystemCapability.Communication.IPC.Core 719 720**参数：** 721 | 参数名 | 类型 | 必填 | 说明 | 722 | -------- | -------- | -------- | -------- | 723 | val | number | 是 | 要写入的双精度浮点值。 | 724 725**返回值：** 726 | 类型 | 说明 | 727 | -------- | -------- | 728 | boolean | 写入成功返回true，否则返回false。 | 729 730**示例：** 731 732 ``` 733 let data = rpc.MessageParcel.create(); 734 let result = data.writeDouble(10.2); 735 console.log("RpcClient: writeDouble is " + result); 736 ``` 737 738 739### readDouble 740 741readDouble(): number 742 743从MessageParcel实例读取双精度浮点值。 744 745**系统能力**：SystemCapability.Communication.IPC.Core 746 747**返回值：** 748 | 类型 | 说明 | 749 | -------- | -------- | 750 | number | 返回双精度浮点值。 | 751 752**示例：** 753 754 ``` 755 let data = rpc.MessageParcel.create(); 756 let result = data.writeDouble(10.2); 757 console.log("RpcClient: writeDouble is " + result); 758 let ret = data.readDouble(); 759 console.log("RpcClient: readDouble is " + ret); 760 ``` 761 762 763### writeBoolean 764 765writeBoolean(val: boolean): boolean 766 767将布尔值写入MessageParcel实例。 768 769**系统能力**：SystemCapability.Communication.IPC.Core 770 771**参数：** 772 | 参数名 | 类型 | 必填 | 说明 | 773 | -------- | -------- | -------- | -------- | 774 | val | boolean | 是 | 要写入的布尔值。 | 775 776**返回值：** 777 | 类型 | 说明 | 778 | -------- | -------- | 779 | boolean | 写入成功返回true，否则返回false。 | 780 781**示例：** 782 783 ``` 784 let data = rpc.MessageParcel.create(); 785 let result = data.writeBoolean(false); 786 console.log("RpcClient: writeBoolean is " + result); 787 ``` 788 789 790### readBoolean 791 792readBoolean(): boolean 793 794从MessageParcel实例读取布尔值。 795 796**系统能力**：SystemCapability.Communication.IPC.Core 797 798**返回值：** 799 | 类型 | 说明 | 800 | -------- | -------- | 801 | boolean | 返回读取到的布尔值。 | 802 803**示例：** 804 805 ``` 806 let data = rpc.MessageParcel.create(); 807 let result = data.writeBoolean(false); 808 console.log("RpcClient: writeBoolean is " + result); 809 let ret = data.readBoolean(); 810 console.log("RpcClient: readBoolean is " + ret); 811 ``` 812 813 814### writeChar 815 816writeChar(val: number): boolean 817 818将单个字符值写入MessageParcel实例。 819 820**系统能力**：SystemCapability.Communication.IPC.Core 821 822**参数：** 823 | 参数名 | 类型 | 必填 | 说明 | 824 | -------- | -------- | -------- | -------- | 825 | val | number | 是 | 要写入的单个字符值。 | 826 827**返回值：** 828 | 类型 | 说明 | 829 | -------- | -------- | 830 | boolean | 写入返回true，否则返回false。 | 831 832**示例：** 833 834 ``` 835 let data = rpc.MessageParcel.create(); 836 let result = data.writeChar(97); 837 console.log("RpcClient: writeChar is " + result); 838 ``` 839 840 841### readChar 842 843readChar(): number 844 845从MessageParcel实例中读取单个字符值。 846 847**系统能力**：SystemCapability.Communication.IPC.Core 848 849**返回值：** 850 | 类型 | 说明 | 851 | -------- | -------- | 852 | number | 返回单个字符值。 | 853 854**示例：** 855 856 ``` 857 let data = rpc.MessageParcel.create(); 858 let result = data.writeChar(97); 859 console.log("RpcClient: writeChar is " + result); 860 let ret = data.readChar(); 861 console.log("RpcClient: readChar is " + ret); 862 ``` 863 864 865### writeString 866 867writeString(val: string): boolean 868 869将字符串值写入MessageParcel实例。 870 871**系统能力**：SystemCapability.Communication.IPC.Core 872 873**参数：** 874 | 参数名 | 类型 | 必填 | 说明 | 875 | -------- | -------- | -------- | -------- | 876 | val | string | 是 | 要写入的字符串值，其长度应小于40960字节。 | 877 878**返回值：** 879 | 类型 | 说明 | 880 | -------- | -------- | 881 | boolean | 写入成功返回true，否则返回false。 | 882 883**示例：** 884 885 ``` 886 let data = rpc.MessageParcel.create(); 887 let result = data.writeString('abc'); 888 console.log("RpcClient: writeString is " + result); 889 ``` 890 891 892### readString 893 894readString(): string 895 896从MessageParcel实例读取字符串值。 897 898**系统能力**：SystemCapability.Communication.IPC.Core 899 900**返回值：** 901 | 类型 | 说明 | 902 | -------- | -------- | 903 | string | 返回字符串值。 | 904 905**示例：** 906 907 ``` 908 let data = rpc.MessageParcel.create(); 909 let result = data.writeString('abc'); 910 console.log("RpcClient: writeString is " + result); 911 let ret = data.readString(); 912 console.log("RpcClient: readString is " + ret); 913 ``` 914 915 916### writeSequenceable 917 918writeSequenceable(val: Sequenceable): boolean 919 920将自定义序列化对象写入MessageParcel实例。 921 922**系统能力**：SystemCapability.Communication.IPC.Core 923 924**参数：** 925 | 参数名 | 类型 | 必填 | 说明 | 926 | -------- | -------- | -------- | -------- | 927 | val | [Sequenceable](#sequenceable) | 是 | 要写入的可序列对象。 | 928 929**返回值：** 930 | 类型 | 说明 | 931 | -------- | -------- | 932 | boolean | 写入成功返回true，否则返回false。 | 933 934**示例：** 935 936 ``` 937 class MySequenceable { 938 num: number; 939 str: string; 940 constructor(num, str) { 941 this.num = num; 942 this.str = str; 943 } 944 marshalling(messageParcel) { 945 messageParcel.writeInt(this.num); 946 messageParcel.writeString(this.str); 947 return true; 948 } 949 unmarshalling(messageParcel) { 950 this.num = messageParcel.readInt(); 951 this.str = messageParcel.readString(); 952 return true; 953 } 954 } 955 let sequenceable = new MySequenceable(1, "aaa"); 956 let data = rpc.MessageParcel.create(); 957 let result = data.writeSequenceable(sequenceable); 958 console.log("RpcClient: writeSequenceable is " + result); 959 ``` 960 961 962### readSequenceable 963 964readSequenceable(dataIn: Sequenceable) : boolean 965 966从MessageParcel实例中读取成员变量到指定的对象（dataIn）。 967 968**系统能力**：SystemCapability.Communication.IPC.Core 969 970**参数：** 971 | 参数名 | 类型 | 必填 | 说明 | 972 | -------- | -------- | -------- | -------- | 973 | dataIn | [Sequenceable](#sequenceable) | 是 | 需要从MessageParcel读取成员变量的对象。 | 974 975**返回值：** 976 | 类型 | 说明 | 977 | -------- | -------- | 978 | boolean | 如果反序列成功，则返回true；否则返回false。 | 979 980**示例：** 981 982 ``` 983 class MySequenceable { 984 num: number; 985 str: string; 986 constructor(num, str) { 987 this.num = num; 988 this.str = str; 989 } 990 marshalling(messageParcel) { 991 messageParcel.writeInt(this.num); 992 messageParcel.writeString(this.str); 993 return true; 994 } 995 unmarshalling(messageParcel) { 996 this.num = messageParcel.readInt(); 997 this.str = messageParcel.readString(); 998 return true; 999 } 1000 } 1001 let sequenceable = new MySequenceable(1, "aaa"); 1002 let data = rpc.MessageParcel.create(); 1003 let result = data.writeSequenceable(sequenceable); 1004 console.log("RpcClient: writeSequenceable is " + result); 1005 let ret = new MySequenceable(0, ""); 1006 let result2 = data.readSequenceable(ret); 1007 console.log("RpcClient: writeSequenceable is " + result2); 1008 ``` 1009 1010 1011### writeByteArray 1012 1013writeByteArray(byteArray: number[]): boolean 1014 1015将字节数组写入MessageParcel实例。 1016 1017**系统能力**：SystemCapability.Communication.IPC.Core 1018 1019**参数：** 1020 | 参数名 | 类型 | 必填 | 说明 | 1021 | -------- | -------- | -------- | -------- | 1022 | byteArray | number[] | 是 | 要写入的字节数组。 | 1023 1024**返回值：** 1025 | 类型 | 说明 | 1026 | -------- | -------- | 1027 | boolean | 写入成功返回true，否则返回false。 | 1028 1029**示例：** 1030 1031 ``` 1032 let data = rpc.MessageParcel.create(); 1033 let ByteArrayVar = [1, 2, 3, 4, 5]; 1034 let result = data.writeByteArray(ByteArrayVar); 1035 console.log("RpcClient: writeByteArray is " + result); 1036 ``` 1037 1038 1039### readByteArray 1040 1041readByteArray(dataIn: number[]) : void 1042 1043从MessageParcel实例读取字节数组。 1044 1045**系统能力**：SystemCapability.Communication.IPC.Core 1046 1047**参数：** 1048 | 参数名 | 类型 | 必填 | 说明 | 1049 | -------- | -------- | -------- | -------- | 1050 | dataIn | number[] | 是 | 要读取的字节数组。 | 1051 1052**示例：** 1053 1054 ``` 1055 let data = rpc.MessageParcel.create(); 1056 let ByteArrayVar = [1, 2, 3, 4, 5]; 1057 let result = data.writeByteArray(ByteArrayVar); 1058 console.log("RpcClient: writeByteArray is " + result); 1059 let array = new Array(5); 1060 data.readByteArray(array); 1061 ``` 1062 1063 1064### readByteArray 1065 1066readByteArray(): number[] 1067 1068从MessageParcel实例中读取字节数组。 1069 1070**系统能力**：SystemCapability.Communication.IPC.Core 1071 1072**返回值：** 1073 | 类型 | 说明 | 1074 | -------- | -------- | 1075 | number[] | 返回字节数组。 | 1076 1077**示例：** 1078 1079 ``` 1080 let data = rpc.MessageParcel.create(); 1081 let ByteArrayVar = [1, 2, 3, 4, 5]; 1082 let result = data.writeByteArray(ByteArrayVar); 1083 console.log("RpcClient: writeByteArray is " + result); 1084 let array = data.readByteArray(); 1085 console.log("RpcClient: readByteArray is " + array); 1086 ``` 1087 1088 1089### writeShortArray 1090 1091writeShortArray(shortArray: number[]): boolean 1092 1093将短整数数组写入MessageParcel实例。 1094 1095**系统能力**：SystemCapability.Communication.IPC.Core 1096 1097**参数：** 1098 | 参数名 | 类型 | 必填 | 说明 | 1099 | -------- | -------- | -------- | -------- | 1100 | shortArray | number[] | 是 | 要写入的短整数数组。 | 1101 1102**返回值：** 1103 | 类型 | 说明 | 1104 | -------- | -------- | 1105 | boolean | 写入返回true，否则返回false。 | 1106 1107**示例：** 1108 1109 ``` 1110 let data = rpc.MessageParcel.create(); 1111 let result = data.writeShortArray([11, 12, 13]); 1112 console.log("RpcClient: writeShortArray is " + result); 1113 ``` 1114 1115 1116### readShortArray 1117 1118readShortArray(dataIn: number[]) : void 1119 1120从MessageParcel实例中读取短整数数组。 1121 1122**系统能力**：SystemCapability.Communication.IPC.Core 1123 1124**参数：** 1125 | 参数名 | 类型 | 必填 | 说明 | 1126 | -------- | -------- | -------- | -------- | 1127 | dataIn | number[] | 是 | 要读取的短整数数组。 | 1128 1129**示例：** 1130 1131 ``` 1132 let data = rpc.MessageParcel.create(); 1133 let result = data.writeShortArray([11, 12, 13]); 1134 console.log("RpcClient: writeShortArray is " + result); 1135 let array = new Array(3); 1136 data.readShortArray(array); 1137 ``` 1138 1139 1140### readShortArray 1141 1142readShortArray(): number[] 1143 1144从MessageParcel实例中读取短整数数组。 1145 1146**系统能力**：SystemCapability.Communication.IPC.Core 1147 1148**返回值：** 1149 | 类型 | 说明 | 1150 | -------- | -------- | 1151 | number[] | 返回短整数数组。 | 1152 1153**示例：** 1154 1155 ``` 1156 let data = rpc.MessageParcel.create(); 1157 let result = data.writeShortArray([11, 12, 13]); 1158 console.log("RpcClient: writeShortArray is " + result); 1159 let array = data.readShortArray(); 1160 console.log("RpcClient: readShortArray is " + array); 1161 ``` 1162 1163 1164### writeIntArray 1165 1166writeIntArray(intArray: number[]): boolean 1167 1168将整数数组写入MessageParcel实例。 1169 1170**系统能力**：SystemCapability.Communication.IPC.Core 1171 1172**参数：** 1173 | 参数名 | 类型 | 必填 | 说明 | 1174 | -------- | -------- | -------- | -------- | 1175 | intArray | number[] | 是 | 要写入的整数数组。 | 1176 1177**返回值：** 1178 | 类型 | 说明 | 1179 | -------- | -------- | 1180 | boolean | 写入返回true，否则返回false。 | 1181 1182**示例：** 1183 1184 ``` 1185 let data = rpc.MessageParcel.create(); 1186 let result = data.writeIntArray([100, 111, 112]); 1187 console.log("RpcClient: writeIntArray is " + result); 1188 ``` 1189 1190 1191### readIntArray 1192 1193readIntArray(dataIn: number[]) : void 1194 1195从MessageParcel实例中读取整数数组。 1196 1197**系统能力**：SystemCapability.Communication.IPC.Core 1198 1199**参数：** 1200 | 参数名 | 类型 | 必填 | 说明 | 1201 | -------- | -------- | -------- | -------- | 1202 | dataIn | number[] | 是 | 要读取的整数数组。 | 1203 1204**示例：** 1205 1206 ``` 1207 let data = rpc.MessageParcel.create(); 1208 let result = data.writeIntArray([100, 111, 112]); 1209 console.log("RpcClient: writeIntArray is " + result); 1210 let array = new Array(3); 1211 data.readIntArray(array); 1212 ``` 1213 1214 1215### readIntArray 1216 1217readIntArray(): number[] 1218 1219从MessageParcel实例中读取整数数组。 1220 1221**系统能力**：SystemCapability.Communication.IPC.Core 1222 1223**返回值：** 1224 | 类型 | 说明 | 1225 | -------- | -------- | 1226 | number[] | 返回整数数组。 | 1227 1228**示例：** 1229 1230 ``` 1231 let data = rpc.MessageParcel.create(); 1232 let result = data.writeIntArray([100, 111, 112]); 1233 console.log("RpcClient: writeIntArray is " + result); 1234 let array = data.readIntArray(); 1235 console.log("RpcClient: readIntArray is " + array); 1236 ``` 1237 1238 1239### writeLongArray 1240 1241writeLongArray(longArray: number[]): boolean 1242 1243将长整数数组写入MessageParcel实例。 1244 1245**系统能力**：SystemCapability.Communication.IPC.Core 1246 1247**参数：** 1248 | 参数名 | 类型 | 必填 | 说明 | 1249 | -------- | -------- | -------- | -------- | 1250 | longArray | number[] | 是 | 要写入的长整数数组。 | 1251 1252**返回值：** 1253 | 类型 | 说明 | 1254 | -------- | -------- | 1255 | boolean | 写入返回true，否则返回false。 | 1256 1257**示例：** 1258 1259 ``` 1260 let data = rpc.MessageParcel.create(); 1261 let result = data.writeLongArray([1111, 1112, 1113]); 1262 console.log("RpcClient: writeLongArray is " + result); 1263 ``` 1264 1265 1266### readLongArray 1267 1268readLongArray(dataIn: number[]) : void 1269 1270从MessageParcel实例读取长整数数组。 1271 1272**系统能力**：SystemCapability.Communication.IPC.Core 1273 1274**参数：** 1275 | 参数名 | 类型 | 必填 | 说明 | 1276 | -------- | -------- | -------- | -------- | 1277 | dataIn | number[] | 是 | 要读取的长整数数组。 | 1278 1279**示例：** 1280 1281 ``` 1282 let data = rpc.MessageParcel.create(); 1283 let result = data.writeLongArray([1111, 1112, 1113]); 1284 console.log("RpcClient: writeLongArray is " + result); 1285 let array = new Array(3); 1286 data.readLongArray(array); 1287 ``` 1288 1289 1290### readLongArray 1291 1292readLongArray(): number[] 1293 1294从MessageParcel实例中读取长整数数组。 1295 1296**系统能力**：SystemCapability.Communication.IPC.Core 1297 1298**返回值：** 1299 | 类型 | 说明 | 1300 | -------- | -------- | 1301 | number[] | 返回长整数数组。 | 1302 1303**示例：** 1304 1305 ``` 1306 let data = rpc.MessageParcel.create(); 1307 let result = data.writeLongArray([1111, 1112, 1113]); 1308 console.log("RpcClient: writeLongArray is " + result); 1309 let array = data.readLongArray(); 1310 console.log("RpcClient: readLongArray is " + array); 1311 ``` 1312 1313 1314### writeFloatArray 1315 1316writeFloatArray(floatArray: number[]): boolean 1317 1318将浮点数组写入MessageParcel实例。 1319 1320**系统能力**：SystemCapability.Communication.IPC.Core 1321 1322**参数：** 1323 | 参数名 | 类型 | 必填 | 说明 | 1324 | -------- | -------- | -------- | -------- | 1325 | floatArray | number[] | 是 | 要写入的浮点数组。 | 1326 1327**返回值：** 1328 | 类型 | 说明 | 1329 | -------- | -------- | 1330 | boolean | 写入返回true，否则返回false。 | 1331 1332**示例：** 1333 1334 ``` 1335 let data = rpc.MessageParcel.create(); 1336 let result = data.writeFloatArray([1.2, 1.3, 1.4]); 1337 console.log("RpcClient: writeFloatArray is " + result); 1338 ``` 1339 1340 1341### readFloatArray 1342 1343readFloatArray(dataIn: number[]) : void 1344 1345从MessageParcel实例中读取浮点数组。 1346 1347**系统能力**：SystemCapability.Communication.IPC.Core 1348 1349**参数：** 1350 | 参数名 | 类型 | 必填 | 说明 | 1351 | -------- | -------- | -------- | -------- | 1352 | dataIn | number[] | 是 | 要读取的浮点数组。 | 1353 1354 1355**示例：** 1356 1357 ``` 1358 let data = rpc.MessageParcel.create(); 1359 let result = data.writeFloatArray([1.2, 1.3, 1.4]); 1360 console.log("RpcClient: writeFloatArray is " + result); 1361 let array = new Array(3); 1362 data.readFloatArray(array); 1363 ``` 1364 1365 1366### readFloatArray 1367 1368readFloatArray(): number[] 1369 1370从MessageParcel实例中读取浮点数组。 1371 1372**系统能力**：SystemCapability.Communication.IPC.Core 1373 1374**返回值：** 1375 | 类型 | 说明 | 1376 | -------- | -------- | 1377 | number[] | 返回浮点数组。 | 1378 1379**示例：** 1380 1381 ``` 1382 let data = rpc.MessageParcel.create(); 1383 let result = data.writeFloatArray([1.2, 1.3, 1.4]); 1384 console.log("RpcClient: writeFloatArray is " + result); 1385 let array = data.readFloatArray(); 1386 console.log("RpcClient: readFloatArray is " + array); 1387 ``` 1388 1389 1390### writeDoubleArray 1391 1392writeDoubleArray(doubleArray: number[]): boolean 1393 1394将双精度浮点数组写入MessageParcel实例。 1395 1396**系统能力**：SystemCapability.Communication.IPC.Core 1397 1398**参数：** 1399 | 参数名 | 类型 | 必填 | 说明 | 1400 | -------- | -------- | -------- | -------- | 1401 | doubleArray | number[] | 是 | 要写入的双精度浮点数组。 | 1402 1403**返回值：** 1404 | 类型 | 说明 | 1405 | -------- | -------- | 1406 | boolean | 写入返回true，否则返回false。 | 1407 1408**示例：** 1409 1410 ``` 1411 let data = rpc.MessageParcel.create(); 1412 let result = data.writeDoubleArray([11.1, 12.2, 13.3]); 1413 console.log("RpcClient: writeDoubleArray is " + result); 1414 ``` 1415 1416 1417### readDoubleArray 1418 1419readDoubleArray(dataIn: number[]) : void 1420 1421从MessageParcel实例中读取双精度浮点数组。 1422 1423**系统能力**：SystemCapability.Communication.IPC.Core 1424 1425**参数：** 1426 | 参数名 | 类型 | 必填 | 说明 | 1427 | -------- | -------- | -------- | -------- | 1428 | dataIn | number[] | 是 | 要读取的双精度浮点数组。 | 1429 1430**示例：** 1431 1432 ``` 1433 let data = rpc.MessageParcel.create(); 1434 let result = data.writeDoubleArray([11.1, 12.2, 13.3]); 1435 console.log("RpcClient: writeDoubleArray is " + result); 1436 let array = new Array(3); 1437 data.readDoubleArray(array); 1438 ``` 1439 1440 1441### readDoubleArray 1442 1443readDoubleArray(): number[] 1444 1445从MessageParcel实例读取双精度浮点数组。 1446 1447**系统能力**：SystemCapability.Communication.IPC.Core 1448 1449**返回值：** 1450 | 类型 | 说明 | 1451 | -------- | -------- | 1452 | number[] | 返回双精度浮点数组。 | 1453 1454**示例：** 1455 1456 ``` 1457 let data = rpc.MessageParcel.create(); 1458 let result = data.writeDoubleArray([11.1, 12.2, 13.3]); 1459 console.log("RpcClient: writeDoubleArray is " + result); 1460 let array = data.readDoubleArray(); 1461 console.log("RpcClient: readDoubleArray is " + array); 1462 ``` 1463 1464 1465### writeBooleanArray 1466 1467writeBooleanArray(booleanArray: boolean[]): boolean 1468 1469将布尔数组写入MessageParcel实例。 1470 1471**系统能力**：SystemCapability.Communication.IPC.Core 1472 1473**参数：** 1474 | 参数名 | 类型 | 必填 | 说明 | 1475 | -------- | -------- | -------- | -------- | 1476 | booleanArray | boolean[] | 是 | 要写入的布尔数组。 | 1477 1478**返回值：** 1479 | 类型 | 说明 | 1480 | -------- | -------- | 1481 | boolean | 写入成功返回true，否则返回false。 | 1482 1483**示例：** 1484 1485 ``` 1486 let data = rpc.MessageParcel.create(); 1487 let result = data.writeBooleanArray([false, true, false]); 1488 console.log("RpcClient: writeBooleanArray is " + result); 1489 ``` 1490 1491 1492### readBooleanArray 1493 1494readBooleanArray(dataIn: boolean[]) : void 1495 1496从MessageParcel实例中读取布尔数组。 1497 1498**系统能力**：SystemCapability.Communication.IPC.Core 1499 1500**参数：** 1501 | 参数名 | 类型 | 必填 | 说明 | 1502 | -------- | -------- | -------- | -------- | 1503 | dataIn | boolean[] | 是 | 要读取的布尔数组。 | 1504 1505**示例：** 1506 1507 ``` 1508 let data = rpc.MessageParcel.create(); 1509 let result = data.writeBooleanArray([false, true, false]); 1510 console.log("RpcClient: writeBooleanArray is " + result); 1511 let array = new Array(3); 1512 data.readBooleanArray(array); 1513 ``` 1514 1515 1516### readBooleanArray 1517 1518readBooleanArray(): boolean[] 1519 1520从MessageParcel实例中读取布尔数组。 1521 1522**系统能力**：SystemCapability.Communication.IPC.Core 1523 1524**返回值：** 1525 | 类型 | 说明 | 1526 | -------- | -------- | 1527 | boolean[] | 返回布尔数组。 | 1528 1529 1530 ``` 1531 let data = rpc.MessageParcel.create(); 1532 let result = data.writeBooleanArray([false, true, false]); 1533 console.log("RpcClient: writeBooleanArray is " + result); 1534 let array = data.readBooleanArray(); 1535 console.log("RpcClient: readBooleanArray is " + array); 1536 ``` 1537 1538 1539### writeCharArray 1540 1541writeCharArray(charArray: number[]): boolean 1542 1543将单个字符数组写入MessageParcel实例。 1544 1545**系统能力**：SystemCapability.Communication.IPC.Core 1546 1547**参数：** 1548 | 参数名 | 类型 | 必填 | 说明 | 1549 | -------- | -------- | -------- | -------- | 1550 | charArray | number[] | 是 | 要写入的单个字符数组。 | 1551 1552**返回值：** 1553 | 类型 | 说明 | 1554 | -------- | -------- | 1555 | boolean | 写入成功返回true，否则返回false。 | 1556 1557**示例：** 1558 1559 ``` 1560 let data = rpc.MessageParcel.create(); 1561 let result = data.writeCharArray([97, 98, 88]); 1562 console.log("RpcClient: writeCharArray is " + result); 1563 ``` 1564 1565 1566### readCharArray 1567 1568readCharArray(dataIn: number[]) : void 1569 1570从MessageParcel实例中读取单个字符数组。 1571 1572**系统能力**：SystemCapability.Communication.IPC.Core 1573 1574**参数：** 1575 | 参数名 | 类型 | 必填 | 说明 | 1576 | -------- | -------- | -------- | -------- | 1577 | dataIn | number[] | 是 | 要读取的单个字符数组。 | 1578 1579**示例：** 1580 1581 ``` 1582 let data = rpc.MessageParcel.create(); 1583 let result = data.writeCharArray([97, 98, 99]); 1584 console.log("RpcClient: writeCharArray is " + result); 1585 let array = new Array(3); 1586 data.readCharArray(array); 1587 ``` 1588 1589 1590### readCharArray 1591 1592readCharArray(): number[] 1593 1594从MessageParcel实例读取单个字符数组。 1595 1596**系统能力**：SystemCapability.Communication.IPC.Core 1597 1598**返回值：** 1599 | 类型 | 说明 | 1600 | -------- | -------- | 1601 | number[] | 返回单个字符数组。 | 1602 1603**示例：** 1604 1605 ``` 1606 let data = rpc.MessageParcel.create(); 1607 let result = data.writeCharArray([97, 98, 99]); 1608 console.log("RpcClient: writeCharArray is " + result); 1609 let array = data.readCharArray(); 1610 console.log("RpcClient: readCharArray is " + array); 1611 ``` 1612 1613 1614### writeStringArray 1615 1616writeStringArray(stringArray: string[]): boolean 1617 1618将字符串数组写入MessageParcel实例。 1619 1620**系统能力**：SystemCapability.Communication.IPC.Core 1621 1622**参数：** 1623 | 参数名 | 类型 | 必填 | 说明 | 1624 | -------- | -------- | -------- | -------- | 1625 | stringArray | string[] | 是 | 要写入的字符串数组，数组单个元素的长度应小于40960字节。 | 1626 1627**返回值：** 1628 | 类型 | 说明 | 1629 | -------- | -------- | 1630 | boolean | 写入成功返回true，否则返回false。 | 1631 1632**示例：** 1633 1634 ``` 1635 let data = rpc.MessageParcel.create(); 1636 let result = data.writeStringArray(["abc", "def"]); 1637 console.log("RpcClient: writeStringArray is " + result); 1638 ``` 1639 1640 1641### readStringArray 1642 1643readStringArray(dataIn: string[]) : void 1644 1645从MessageParcel实例读取字符串数组。 1646 1647**系统能力**：SystemCapability.Communication.IPC.Core 1648 1649**参数：** 1650 | 参数名 | 类型 | 必填 | 说明 | 1651 | -------- | -------- | -------- | -------- | 1652 | dataIn | string[] | 是 | 要读取的字符串数组。 | 1653 1654**示例：** 1655 1656 ``` 1657 let data = rpc.MessageParcel.create(); 1658 let result = data.writeStringArray(["abc", "def"]); 1659 console.log("RpcClient: writeStringArray is " + result); 1660 let array = new Array(2); 1661 data.readStringArray(array); 1662 ``` 1663 1664 1665### readStringArray 1666 1667readStringArray(): string[] 1668 1669从MessageParcel实例读取字符串数组。 1670 1671**系统能力**：SystemCapability.Communication.IPC.Core 1672 1673**返回值：** 1674 | 类型 | 说明 | 1675 | -------- | -------- | 1676 | string[] | 返回字符串数组。 | 1677 1678**示例：** 1679 1680 ``` 1681 let data = rpc.MessageParcel.create(); 1682 let result = data.writeStringArray(["abc", "def"]); 1683 console.log("RpcClient: writeStringArray is " + result); 1684 let array = data.readStringArray(); 1685 console.log("RpcClient: readStringArray is " + array); 1686 ``` 1687 1688 1689### writeNoException<sup>8+</sup> 1690 1691writeNoException(): void 1692 1693向MessageParcel写入“指示未发生异常”的信息。 1694 1695**系统能力**：SystemCapability.Communication.IPC.Core 1696 1697**示例：** 1698 1699 ``` 1700 class MyDeathRecipient { 1701 onRemoteDied() { 1702 console.log("server died"); 1703 } 1704 } 1705 class TestRemoteObject extends rpc.RemoteObject { 1706 constructor(descriptor) { 1707 super(descriptor); 1708 } 1709 addDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 1710 return true; 1711 } 1712 removeDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 1713 return true; 1714 } 1715 isObjectDead(): boolean { 1716 return false; 1717 } 1718 onRemoteRequest(code, data, reply, option) { 1719 if (code === 1) { 1720 console.log("RpcServer: onRemoteRequest called"); 1721 reply.writeNoException(); 1722 return true; 1723 } else { 1724 console.log("RpcServer: unknown code: " + code); 1725 return false; 1726 } 1727 } 1728 } 1729 ``` 1730 1731 1732### readException<sup>8+</sup> 1733 1734readException(): void 1735 1736从MessageParcel中读取异常。 1737 1738**系统能力**：SystemCapability.Communication.IPC.Core 1739 1740**示例：** 1741 1742 ``` 1743 import FA from "@ohos.ability.featureAbility"; 1744 let proxy; 1745 let connect = { 1746 onConnect: function(elementName, remoteProxy) { 1747 console.log("RpcClient: js onConnect called."); 1748 proxy = remoteProxy; 1749 }, 1750 onDisconnect: function(elementName) { 1751 console.log("RpcClient: onDisconnect"); 1752 }, 1753 onFailed: function() { 1754 console.log("RpcClient: onFailed"); 1755 } 1756 }; 1757 let want = { 1758 "bundleName": "com.ohos.server", 1759 "abilityName": "com.ohos.server.MainAbility", 1760 }; 1761 FA.connectAbility(want, connect); 1762 let option = new rpc.MessageOption(); 1763 let data = rpc.MessageParcel.create(); 1764 let reply = rpc.MessageParcel.create(); 1765 data.writeInt(1); 1766 data.writeString("hello"); 1767 proxy.sendRequest(1, data, reply, option) 1768 .then(function(errCode) { 1769 if (errCode === 0) { 1770 console.log("sendRequest got result"); 1771 reply.readException(); 1772 let msg = reply.readString(); 1773 console.log("RPCTest: reply msg: " + msg); 1774 } else { 1775 console.log("RPCTest: sendRequest failed, errCode: " + errCode); 1776 } 1777 }).catch(function(e) { 1778 console.log("RPCTest: sendRequest got exception: " + e.message); 1779 }).finally (() => { 1780 console.log("RPCTest: sendRequest ends, reclaim parcel"); 1781 data.reclaim(); 1782 reply.reclaim(); 1783 }); 1784 ``` 1785 1786 1787### writeSequenceableArray 1788 1789writeSequenceableArray(sequenceableArray: Sequenceable[]): boolean 1790 1791将可序列化对象数组写入MessageParcel实例。 1792 1793**系统能力**：SystemCapability.Communication.IPC.Core 1794 1795**参数：** 1796 | 参数名 | 类型 | 必填 | 说明 | 1797 | -------- | -------- | -------- | -------- | 1798 | sequenceableArray | Sequenceable[] | 是 | 要写入的可序列化对象数组。 | 1799 1800**返回值：** 1801 | 类型 | 说明 | 1802 | -------- | -------- | 1803 | boolean | 写入成功返回true，否则返回false。 | 1804 1805**示例：** 1806 1807 ``` 1808 class MySequenceable { 1809 num: number; 1810 str: string; 1811 constructor(num, str) { 1812 this.num = num; 1813 this.str = str; 1814 } 1815 marshalling(messageParcel) { 1816 messageParcel.writeInt(this.num); 1817 messageParcel.writeString(this.str); 1818 return true; 1819 } 1820 unmarshalling(messageParcel) { 1821 this.num = messageParcel.readInt(); 1822 this.str = messageParcel.readString(); 1823 return true; 1824 } 1825 } 1826 let sequenceable = new MySequenceable(1, "aaa"); 1827 let sequenceable2 = new MySequenceable(2, "bbb"); 1828 let sequenceable3 = new MySequenceable(3, "ccc"); 1829 let a = [sequenceable, sequenceable2, sequenceable3]; 1830 let data = rpc.MessageParcel.create(); 1831 let result = data.writeSequenceableArray(a); 1832 console.log("RpcClient: writeSequenceableArray is " + result); 1833 ``` 1834 1835 1836### readSequenceableArray<sup>8+</sup> 1837 1838readSequenceableArray(sequenceableArray: Sequenceable[]): void 1839 1840从MessageParcel实例读取可序列化对象数组。 1841 1842**系统能力**：SystemCapability.Communication.IPC.Core 1843 1844**参数：** 1845 | 参数名 | 类型 | 必填 | 说明 | 1846 | -------- | -------- | -------- | -------- | 1847 | sequenceableArray | Sequenceable[] | 是 | 要读取的可序列化对象数组。 | 1848 1849**示例：** 1850 1851 ``` 1852 class MySequenceable { 1853 num: number; 1854 str: string; 1855 constructor(num, str) { 1856 this.num = num; 1857 this.str = str; 1858 } 1859 marshalling(messageParcel) { 1860 messageParcel.writeInt(this.num); 1861 messageParcel.writeString(this.str); 1862 return true; 1863 } 1864 unmarshalling(messageParcel) { 1865 this.num = messageParcel.readInt(); 1866 this.str = messageParcel.readString(); 1867 return true; 1868 } 1869 } 1870 let sequenceable = new MySequenceable(1, "aaa"); 1871 let sequenceable2 = new MySequenceable(2, "bbb"); 1872 let sequenceable3 = new MySequenceable(3, "ccc"); 1873 let a = [sequenceable, sequenceable2, sequenceable3]; 1874 let data = rpc.MessageParcel.create(); 1875 let result = data.writeSequenceableArray(a); 1876 console.log("RpcClient: writeSequenceableArray is " + result); 1877 let b = [new MySequenceable(0, ""), new MySequenceable(0, ""), new MySequenceable(0, "")]; 1878 data.readSequenceableArray(b); 1879 ``` 1880 1881 1882### writeRemoteObjectArray<sup>8+</sup> 1883 1884writeRemoteObjectArray(objectArray: IRemoteObject[]): boolean 1885 1886将IRemoteObject对象数组写入MessageParcel。 1887 1888**系统能力**：SystemCapability.Communication.IPC.Core 1889 1890**参数：** 1891 | 参数名 | 类型 | 必填 | 说明 | 1892 | -------- | -------- | -------- | -------- | 1893 | objectArray | IRemoteObject[] | 是 | 要写入MessageParcel的IRemoteObject对象数组。 | 1894 1895**返回值：** 1896 | 类型 | 说明 | 1897 | -------- | -------- | 1898 | boolean | 如果IRemoteObject对象数组成功写入MessageParcel，则返回true；如果对象为null或数组写入MessageParcel失败，则返回false。 | 1899 1900**示例：** 1901 1902 ``` 1903 class MyDeathRecipient { 1904 onRemoteDied() { 1905 console.log("server died"); 1906 } 1907 } 1908 class TestRemoteObject extends rpc.RemoteObject { 1909 constructor(descriptor) { 1910 super(descriptor); 1911 this.attachLocalInterface(this, descriptor); 1912 } 1913 addDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 1914 return true; 1915 } 1916 removeDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 1917 return true; 1918 } 1919 isObjectDead(): boolean { 1920 return false; 1921 } 1922 asObject(): rpc.IRemoteObject { 1923 return this; 1924 } 1925 } 1926 let a = [new TestRemoteObject("testObject1"), new TestRemoteObject("testObject2"), new TestRemoteObject("testObject3")]; 1927 let data = rpc.MessageParcel.create(); 1928 let result = data.writeRemoteObjectArray(a); 1929 console.log("RpcClient: writeRemoteObjectArray is " + result); 1930 ``` 1931 1932 1933### readRemoteObjectArray<sup>8+</sup> 1934 1935readRemoteObjectArray(objects: IRemoteObject[]): void 1936 1937从MessageParcel读取IRemoteObject对象数组。 1938 1939**系统能力**：SystemCapability.Communication.IPC.Core 1940 1941**参数：** 1942 | 参数名 | 类型 | 必填 | 说明 | 1943 | -------- | -------- | -------- | -------- | 1944 | objects | IRemoteObject[] | 是 | 从MessageParcel读取的IRemoteObject对象数组。 | 1945 1946**示例：** 1947 1948 ``` 1949 class MyDeathRecipient { 1950 onRemoteDied() { 1951 console.log("server died"); 1952 } 1953 } 1954 class TestRemoteObject extends rpc.RemoteObject { 1955 constructor(descriptor) { 1956 super(descriptor); 1957 this.attachLocalInterface(this, descriptor); 1958 } 1959 addDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 1960 return true; 1961 } 1962 removeDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 1963 return true; 1964 } 1965 isObjectDead(): boolean { 1966 return false; 1967 } 1968 asObject(): rpc.IRemoteObject { 1969 return this; 1970 } 1971 } 1972 let a = [new TestRemoteObject("testObject1"), new TestRemoteObject("testObject2"), new TestRemoteObject("testObject3")]; 1973 let data = rpc.MessageParcel.create(); 1974 let result = data.writeRemoteObjectArray(a); 1975 let b = new Array(3); 1976 data.readRemoteObjectArray(b); 1977 ``` 1978 1979 1980### readRemoteObjectArray<sup>8+</sup> 1981 1982readRemoteObjectArray(): IRemoteObject[] 1983 1984从MessageParcel读取IRemoteObject对象数组。 1985 1986**系统能力**：SystemCapability.Communication.IPC.Core 1987 1988**返回值：** 1989 | 类型 | 说明 | 1990 | -------- | -------- | 1991 | IRemoteObject[] | 返回IRemoteObject对象数组。 | 1992 1993**示例：** 1994 1995 ``` 1996 class MyDeathRecipient { 1997 onRemoteDied() { 1998 console.log("server died"); 1999 } 2000 } 2001 class TestRemoteObject extends rpc.RemoteObject { 2002 constructor(descriptor) { 2003 super(descriptor); 2004 this.attachLocalInterface(this, descriptor); 2005 } 2006 addDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 2007 return true; 2008 } 2009 removeDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 2010 return true; 2011 } 2012 isObjectDead(): boolean { 2013 return false; 2014 } 2015 asObject(): rpc.IRemoteObject { 2016 return this; 2017 } 2018 } 2019 let a = [new TestRemoteObject("testObject1"), new TestRemoteObject("testObject2"), new TestRemoteObject("testObject3")]; 2020 let data = rpc.MessageParcel.create(); 2021 let result = data.writeRemoteObjectArray(a); 2022 console.log("RpcClient: readRemoteObjectArray is " + result); 2023 let b = data.readRemoteObjectArray(); 2024 console.log("RpcClient: readRemoteObjectArray is " + b); 2025 ``` 2026 2027 2028### closeFileDescriptor<sup>8+</sup> 2029 2030static closeFileDescriptor(fd: number): void 2031 2032关闭给定的文件描述符。 2033 2034**系统能力**：SystemCapability.Communication.IPC.Core 2035 2036**参数：** 2037 | 参数名 | 类型 | 必填 | 说明 | 2038 | -------- | -------- | -------- | -------- | 2039 | fd | number | 是 | 要关闭的文件描述符。 | 2040 2041**示例：** 2042 2043 ``` 2044 import fileio from '@ohos.fileio'; 2045 let filePath = "path/to/file"; 2046 let fd = fileio.openSync(filePath, 0o2| 0o100, 0o666); 2047 rpc.MessageParcel.closeFileDescriptor(fd); 2048 ``` 2049 2050 2051### dupFileDescriptor<sup>8+</sup> 2052 2053static dupFileDescriptor(fd: number) :number 2054 2055复制给定的文件描述符。 2056 2057**系统能力**：SystemCapability.Communication.IPC.Core 2058 2059**参数：** 2060 | 参数名 | 类型 | 必填 | 说明 | 2061 | -------- | -------- | -------- | -------- | 2062 | fd | number | 是 | 表示已存在的文件描述符。 | 2063 2064**返回值：** 2065 | 类型 | 说明 | 2066 | -------- | -------- | 2067 | number | 返回新的文件描述符。 | 2068 2069**示例：** 2070 2071 ``` 2072 import fileio from '@ohos.fileio'; 2073 let filePath = "path/to/file"; 2074 let fd = fileio.openSync(filePath, 0o2| 0o100, 0o666); 2075 let newFd = rpc.MessageParcel.dupFileDescriptor(fd); 2076 ``` 2077 2078 2079### containFileDescriptors<sup>8+</sup> 2080 2081containFileDescriptors(): boolean 2082 2083检查此MessageParcel对象是否包含文件描述符。 2084 2085**系统能力**：SystemCapability.Communication.IPC.Core 2086 2087**返回值：** 2088 | 类型 | 说明 | 2089 | -------- | -------- | 2090 | boolean | 如果此MessageParcel对象包含文件描述符，则返回true；否则返回false。 | 2091 2092**示例：** 2093 2094 ``` 2095 import fileio from '@ohos.fileio'; 2096 let parcel = new rpc.MessageParcel(); 2097 let filePath = "path/to/file"; 2098 let r1 = parcel.containFileDescriptors(); 2099 let fd = fileio.openSync(filePath, 0o2| 0o100, 0o666); 2100 let writeResult = parcel.writeFileDescriptor(fd); 2101 console.log("RpcTest: parcel writeFd result is : " + writeResult); 2102 let containFD = parcel.containFileDescriptors(); 2103 console.log("RpcTest: parcel after write fd containFd result is : " + containFD); 2104 ``` 2105 2106 2107### writeFileDescriptor<sup>8+</sup> 2108 2109writeFileDescriptor(fd: number): boolean 2110 2111写入文件描述符到MessageParcel。 2112 2113**系统能力**：SystemCapability.Communication.IPC.Core 2114 2115**参数：** 2116 | 参数名 | 类型 | 必填 | 说明 | 2117 | -------- | -------- | -------- | -------- | 2118 | fd | number | 是 | 文件描述符。 | 2119 2120**返回值：** 2121 | 类型 | 说明 | 2122 | -------- | -------- | 2123 | boolean | 如果操作成功，则返回true；否则返回false。 | 2124 2125**示例：** 2126 2127 ``` 2128 import fileio from '@ohos.fileio'; 2129 let parcel = new rpc.MessageParcel(); 2130 let filePath = "path/to/file"; 2131 let fd = fileio.openSync(filePath, 0o2| 0o100, 0o666); 2132 let writeResult = parcel.writeFileDescriptor(fd); 2133 console.log("RpcTest: parcel writeFd result is : " + writeResult); 2134 ``` 2135 2136 2137### readFileDescriptor<sup>8+</sup> 2138 2139readFileDescriptor(): number 2140 2141从MessageParcel中读取文件描述符。 2142 2143**系统能力**：SystemCapability.Communication.IPC.Core 2144 2145**返回值：** 2146 | 类型 | 说明 | 2147 | -------- | -------- | 2148 | number | 返回文件描述符。 | 2149 2150**示例：** 2151 2152 ``` 2153 import fileio from '@ohos.fileio'; 2154 let parcel = new rpc.MessageParcel(); 2155 let filePath = "path/to/file"; 2156 let fd = fileio.openSync(filePath, 0o2| 0o100, 0o666); 2157 let writeResult = parcel.writeFileDescriptor(fd); 2158 let readFD = parcel.readFileDescriptor(); 2159 console.log("RpcTest: parcel read fd is : " + readFD); 2160 ``` 2161 2162 2163### writeAshmem<sup>8+</sup> 2164 2165writeAshmem(ashmem: Ashmem): boolean 2166 2167将指定的匿名共享对象写入此MessageParcel。 2168 2169**系统能力**：SystemCapability.Communication.IPC.Core 2170 2171**参数：** 2172 | 参数名 | 类型 | 必填 | 说明 | 2173 | -------- | -------- | -------- | -------- | 2174 | ashmem | Ashmem | 是 | 要写入MessageParcel的匿名共享对象。 | 2175 2176**返回值：** 2177 | 类型 | 说明 | 2178 | -------- | -------- | 2179 | boolean | 如果匿名共享对象成功写入此MessageParcel，则返回true；否则返回false。 | 2180 2181**示例：** 2182 2183 ``` 2184 let parcel = new rpc.MessageParcel(); 2185 let ashmem = rpc.Ashmem.createAshmem("ashmem", 1024); 2186 let isWriteSuccess = parcel.writeAshmem(ashmem); 2187 console.log("RpcTest: write ashmem to result is : " + isWriteSuccess); 2188 ``` 2189 2190 2191### readAshmem<sup>8+</sup> 2192 2193readAshmem(): Ashmem 2194 2195从MessageParcel读取匿名共享对象。 2196 2197**系统能力**：SystemCapability.Communication.IPC.Core 2198 2199**返回值：** 2200 | 类型 | 说明 | 2201 | -------- | -------- | 2202 | Ashmem | 返回匿名共享对象。 | 2203 2204**示例：** 2205 2206 ``` 2207 let parcel = new rpc.MessageParcel(); 2208 let ashmem = rpc.Ashmem.createAshmem("ashmem", 1024); 2209 let isWriteSuccess = parcel.writeAshmem(ashmem); 2210 console.log("RpcTest: write ashmem to result is : " + isWriteSuccess); 2211 let readAshmem = parcel.readAshmem(); 2212 console.log("RpcTest: read ashmem to result is : " + readAshmem); 2213 ``` 2214 2215 2216### getRawDataCapacity<sup>8+</sup> 2217 2218getRawDataCapacity(): number 2219 2220获取MessageParcel可以容纳的最大原始数据量。 2221 2222**系统能力**：SystemCapability.Communication.IPC.Core 2223 2224**返回值：** 2225 | 类型 | 说明 | 2226 | -------- | -------- | 2227 | number | 返回MessageParcel可以容纳的最大原始数据量，即128 Mb。 | 2228 2229**示例：** 2230 2231 ``` 2232 let parcel = new rpc.MessageParcel(); 2233 let result = parcel.getRawDataCapacity(); 2234 console.log("RpcTest: parcel get RawDataCapacity result is : " + result); 2235 ``` 2236 2237 2238### writeRawData<sup>8+</sup> 2239 2240writeRawData(rawData: number[], size: number): boolean 2241 2242将原始数据写入MessageParcel对象。 2243 2244**系统能力**：SystemCapability.Communication.IPC.Core 2245 2246**参数：** 2247 | 参数名 | 类型 | 必填 | 说明 | 2248 | -------- | -------- | -------- | -------- | 2249 | rawData | number[] | 是 | 要写入的原始数据。 | 2250 | size | number | 是 | 发送的原始数据大小，以字节为单位。 | 2251 2252**返回值：** 2253 | 类型 | 说明 | 2254 | -------- | -------- | 2255 | boolean | 如果操作成功，则返回true；否则返回false。 | 2256 2257**示例：** 2258 2259 ``` 2260 let parcel = new rpc.MessageParcel(); 2261 let arr = [1, 2, 3, 4, 5]; 2262 let isWriteSuccess = parcel.writeRawData(arr, arr.length); 2263 console.log("RpcTest: parcel write raw data result is : " + isWriteSuccess); 2264 ``` 2265 2266 2267### readRawData<sup>8+</sup> 2268 2269readRawData(size: number): number[] 2270 2271从MessageParcel读取原始数据。 2272 2273**系统能力**：SystemCapability.Communication.IPC.Core 2274 2275**参数：** 2276 | 参数名 | 类型 | 必填 | 说明 | 2277 | -------- | -------- | -------- | -------- | 2278 | size | number | 是 | 要读取的原始数据的大小。 | 2279 2280**返回值：** 2281 | 类型 | 说明 | 2282 | -------- | -------- | 2283 | number[] | 返回原始数据（以字节为单位）。 | 2284 2285**示例：** 2286 2287 ``` 2288 let parcel = new rpc.MessageParcel(); 2289 let arr = [1, 2, 3, 4, 5]; 2290 let isWriteSuccess = parcel.writeRawData(arr, arr.length); 2291 console.log("RpcTest: parcel write raw data result is : " + isWriteSuccess); 2292 let result = parcel.readRawData(5); 2293 console.log("RpcTest: parcel read raw data result is : " + result); 2294 ``` 2295 2296## Sequenceable 2297 2298在进程间通信（IPC）期间，将类的对象写入MessageParcel并从MessageParcel中恢复它们。 2299 2300 2301### marshalling 2302 2303marshalling(dataOut: MessageParcel): boolean 2304 2305将此可序列对象封送到MessageParcel中。 2306 2307**系统能力**：SystemCapability.Communication.IPC.Core 2308 2309**参数：** 2310 | 参数名 | 类型 | 必填 | 说明 | 2311 | -------- | -------- | -------- | -------- | 2312 | dataOut | [MessageParcel](#messageparcel) | 是 | 可序列对象将被封送到的MessageParcel对象。 | 2313 2314**返回值：** 2315 | 类型 | 说明 | 2316 | -------- | -------- | 2317 | boolean | 如果封送成功，则返回true；否则返回false。 | 2318 2319**示例：** 2320 2321 ``` 2322 class MySequenceable { 2323 num: number; 2324 str: string; 2325 constructor(num, str) { 2326 this.num = num; 2327 this.str = str; 2328 } 2329 marshalling(messageParcel) { 2330 messageParcel.writeInt(this.num); 2331 messageParcel.writeString(this.str); 2332 return true; 2333 } 2334 unmarshalling(messageParcel) { 2335 this.num = messageParcel.readInt(); 2336 this.str = messageParcel.readString(); 2337 return true; 2338 } 2339 } 2340 let sequenceable = new MySequenceable(1, "aaa"); 2341 let data = rpc.MessageParcel.create(); 2342 let result = data.writeSequenceable(sequenceable); 2343 console.log("RpcClient: writeSequenceable is " + result); 2344 let ret = new MySequenceable(0, ""); 2345 let result2 = data.readSequenceable(ret); 2346 console.log("RpcClient: readSequenceable is " + result2); 2347 ``` 2348 2349 2350### unmarshalling 2351 2352unmarshalling(dataIn: MessageParcel) : boolean 2353 2354从MessageParcel中解封此可序列对象。 2355 2356**系统能力**：SystemCapability.Communication.IPC.Core 2357 2358**参数：** 2359 | 参数名 | 类型 | 必填 | 说明 | 2360 | -------- | -------- | -------- | -------- | 2361 | dataIn | [MessageParcel](#messageparcel) | 是 | 已将可序列对象封送到其中的MessageParcel对象。 | 2362 2363**返回值：** 2364 | 类型 | 说明 | 2365 | -------- | -------- | 2366 | boolean | 如果可序列化成功，则返回true；否则返回false。 | 2367 2368**示例：** 2369 2370 ``` 2371 class MySequenceable { 2372 num: number; 2373 str: string; 2374 constructor(num, str) { 2375 this.num = num; 2376 this.str = str; 2377 } 2378 marshalling(messageParcel) { 2379 messageParcel.writeInt(this.num); 2380 messageParcel.writeString(this.str); 2381 return true; 2382 } 2383 unmarshalling(messageParcel) { 2384 this.num = messageParcel.readInt(); 2385 this.str = messageParcel.readString(); 2386 return true; 2387 } 2388 } 2389 let sequenceable = new MySequenceable(1, "aaa"); 2390 let data = rpc.MessageParcel.create(); 2391 let result = data.writeSequenceable(sequenceable); 2392 console.log("RpcClient: writeSequenceable is " + result); 2393 let ret = new MySequenceable(0, ""); 2394 let result2 = data.readSequenceable(ret); 2395 console.log("RpcClient: readSequenceable is " + result2); 2396 ``` 2397 2398 2399## IRemoteBroker 2400 2401远端对象的代理持有者。用于获取代理对象。 2402 2403 2404### asObject 2405 2406asObject(): IRemoteObject 2407 2408需派生类实现，获取代理或远端对象。 2409 2410**系统能力**：SystemCapability.Communication.IPC.Core 2411 2412**返回值：** 2413 | 类型 | 说明 | 2414 | -------- | -------- | 2415 | [IRemoteObject](#iremoteobject) | 如果调用者是[RemoteObject](#ashmem8)对象，则直接返回本身；如果调用者是[RemoteProxy](#remoteproxy)对象，则返回它的持有者[IRemoteObject](#iremoteobject)。 | 2416 2417**示例：** 2418 2419 ``` 2420 class TestAbility extends rpc.RemoteObject { 2421 asObject() { 2422 return this; 2423 } 2424 } 2425 ``` 2426 2427**示例：** 2428 2429 ``` 2430 class TestProxy { 2431 remote: rpc.RemoteObject; 2432 constructor(remote) { 2433 this.remote = remote; 2434 } 2435 asObject() { 2436 return this.remote; 2437 } 2438 } 2439 ``` 2440 2441 2442## DeathRecipient 2443 2444用于订阅远端对象的死亡通知。当被订阅该通知的远端对象死亡时，本端可收到消息，调用[onRemoteDied](#onremotedied)接口。远端对象死亡可以为远端对象所在进程死亡，远端对象所在设备关机或重启，当远端对象与本端对象属于不同设备时，也可为远端对象离开组网时。 2445 2446 2447### onRemoteDied 2448 2449onRemoteDied(): void 2450 2451在成功添加死亡通知订阅后，当远端对象死亡时，将自动调用本方法。 2452 2453**系统能力**：SystemCapability.Communication.IPC.Core 2454 2455**示例：** 2456 2457 ``` 2458 class MyDeathRecipient { 2459 onRemoteDied() { 2460 console.log("server died"); 2461 } 2462 } 2463 ``` 2464 2465 2466## SendRequestResult<sup>8+</sup> 2467 2468发送请求的响应结果。 2469 2470**系统能力**：以下各项对应的系统能力均为SystemCapability.Communication.IPC.Core。 2471 2472 | 参数 | 值 | 说明 | 2473| -------- | -------- | -------- | 2474| errCode | number | 错误码。 | 2475| code | number | 消息代码。 | 2476| data | MessageParcel | 发送给对端进程的MessageParcel对象。 | 2477| reply | MessageParcel | 对端进程返回的MessageParcel对象。 | 2478 2479 2480## IRemoteObject 2481 2482该接口可用于查询或获取接口描述符、添加或删除死亡通知、转储对象状态到特定文件、发送消息。 2483 2484 2485### queryLocalInterface 2486 2487queryLocalInterface(descriptor: string): IRemoteBroker 2488 2489查询接口。 2490 2491**系统能力**：SystemCapability.Communication.IPC.Core 2492 2493**参数：** 2494 | 参数名 | 类型 | 必填 | 说明 | 2495 | -------- | -------- | -------- | -------- | 2496 | descriptor | string | 是 | 接口描述符的字符串。 | 2497 2498**返回值：** 2499 | 类型 | 说明 | 2500 | -------- | -------- | 2501 | IRemoteBroker | 返回绑定到指定接口描述符的IRemoteBroker对象。 | 2502 2503 2504### sendRequest<sup>(deprecated)</sup> 2505 2506> **说明：** 2507> 从 API Version 8 开始废弃，建议使用[sendRequest<sup>8+</sup>](#sendrequest8)替代。 2508 2509sendRequest(code : number, data : MessageParcel, reply : MessageParcel, options : MessageOption): boolean 2510 2511以同步或异步方式向对端进程发送MessageParcel消息。如果为选项设置了异步模式，则期约立即兑现，reply报文里没有内容。如果为选项设置了同步模式，则期约将在sendRequest返回时兑现，回复内容在reply报文里。 2512 2513**系统能力**：SystemCapability.Communication.IPC.Core 2514 2515**参数：** 2516 | 参数名 | 类型 | 必填 | 说明 | 2517 | -------- | -------- | -------- | -------- | 2518 | code | number | 是 | 本次请求调用的消息码，由通信双方确定。如果接口由IDL工具生成，则消息代码由IDL自动生成。 | 2519 | data | [MessageParcel](#messageparcel) | 是 | 保存待发送数据的 MessageParcel对象。 | 2520 | reply | [MessageParcel](#messageparcel) | 是 | 接收应答数据的MessageParcel对象。 | 2521 | options | [MessageOption](#messageoption) | 是 | 本次请求的同异步模式，默认同步调用。 | 2522 2523**返回值：** 2524 | 类型 | 说明 | 2525 | -------- | -------- | 2526 | boolean | 返回一个布尔值，true表示成功，false表示失败。| 2527 2528 2529### sendRequest<sup>8+</sup> 2530 2531sendRequest(code : number, data : MessageParcel, reply : MessageParcel, options : MessageOption): Promise<SendRequestResult> 2532 2533以同步或异步方式向对端进程发送MessageParcel消息。如果为选项设置了异步模式，则期约立即兑现，reply报文里没有内容。如果为选项设置了同步模式，则期约将在sendRequest返回时兑现，回复内容在reply报文里。 2534 2535**系统能力**：SystemCapability.Communication.IPC.Core 2536 2537**参数：** 2538 | 参数名 | 类型 | 必填 | 说明 | 2539 | -------- | -------- | -------- | -------- | 2540 | code | number | 是 | 本次请求调用的消息码，由通信双方确定。如果接口由IDL工具生成，则消息代码由IDL自动生成。 | 2541 | data | [MessageParcel](#messageparcel) | 是 | 保存待发送数据的 MessageParcel对象。 | 2542 | reply | [MessageParcel](#messageparcel) | 是 | 接收应答数据的MessageParcel对象。 | 2543 | options | [MessageOption](#messageoption) | 是 | 本次请求的同异步模式，默认同步调用。 | 2544 2545**返回值：** 2546 | 类型 | 说明 | 2547 | -------- | -------- | 2548 | Promise<SendRequestResult> | 返回一个期约，兑现值是sendRequestResult实例。| 2549 2550### sendRequest<sup>8+</sup> 2551 2552sendRequest(code: number, data: MessageParcel, reply: MessageParcel, options: MessageOption, callback: AsyncCallback<SendRequestResult>): void 2553 2554以同步或异步方式向对端进程发送MessageParcel消息。如果为选项设置了异步模式，则立即收到回调，reply报文里没有内容。如果为选项设置了同步模式，则将在sendRequest返回时收到回调，回复内容在reply报文里。 2555 2556**系统能力**：SystemCapability.Communication.IPC.Core 2557 2558**参数：** 2559 | 参数名 | 类型 | 必填 | 说明 | 2560 | -------- | -------- | -------- | -------- | 2561 | code | number | 是 | 本次请求调用的消息码，由通信双方确定。如果接口由IDL工具生成，则消息代码由IDL自动生成。 | 2562 | data | [MessageParcel](#messageparcel) | 是 | 保存待发送数据的 MessageParcel对象。 | 2563 | reply | [MessageParcel](#messageparcel) | 是 | 接收应答数据的MessageParcel对象。 | 2564 | options | [MessageOption](#messageoption) | 是 | 本次请求的同异步模式，默认同步调用。 | 2565 | callback | AsyncCallback<SendRequestResult> | 是 | 接收发送结果的回调。 | 2566 2567 2568### addDeathrecipient 2569 2570addDeathRecipient(recipient: DeathRecipient, flags: number): boolean 2571 2572注册用于接收远程对象死亡通知的回调。如果与RemoteProxy对象匹配的远程对象进程死亡，则调用此方法。 2573 2574**系统能力**：SystemCapability.Communication.IPC.Core 2575 2576**参数：** 2577 | 参数名 | 类型 | 必填 | 说明 | 2578 | -------- | -------- | -------- | -------- | 2579 | recipient | [DeathRecipient](#deathrecipient) | 是 | 要注册的回调。 | 2580 | flags | number | 是 | 死亡通知标志。 | 2581 2582**返回值：** 2583 | 类型 | 说明 | 2584 | -------- | -------- | 2585 | boolean | 如果回调注册成功，则返回true；否则返回false。 | 2586 2587 2588### removeDeathRecipient 2589 2590removeDeathRecipient(recipient: DeathRecipient, flags: number): boolean 2591 2592注销用于接收远程对象死亡通知的回调。 2593 2594**系统能力**：SystemCapability.Communication.IPC.Core 2595 2596**参数：** 2597 | 参数名 | 类型 | 必填 | 说明 | 2598 | -------- | -------- | -------- | -------- | 2599 | recipient | [DeathRecipient](#deathrecipient) | 是 | 要注销的回调。 | 2600 | flags | number | 是 | 死亡通知标志。 | 2601 2602**返回值：** 2603 | 类型 | 说明 | 2604 | -------- | -------- | 2605 | boolean | 如果回调成功注销，则返回true；否则返回false。 | 2606 2607 2608### getInterfaceDescriptor 2609 2610getInterfaceDescriptor(): string 2611 2612获取对象的接口描述符。接口描述符为字符串。 2613 2614**系统能力**：SystemCapability.Communication.IPC.Core 2615 2616**返回值：** 2617 | 类型 | 说明 | 2618 | -------- | -------- | 2619 | string | 返回接口描述符。 | 2620 2621 2622### isObjectDead 2623 2624isObjectDead(): boolean 2625 2626检查当前对象是否死亡。 2627 2628**系统能力**：SystemCapability.Communication.IPC.Core 2629 2630**返回值：** 2631 | 类型 | 说明 | 2632 | -------- | -------- | 2633 | boolean | 如果对象已死亡，则返回true；否则返回false。 | 2634 2635 2636## RemoteProxy 2637 2638实现IRemoteObject代理对象。 2639 2640**系统能力**：以下各项对应的系统能力均为SystemCapability.Communication.IPC.Core。 2641 2642| 参数 | 值 | 说明 | 2643| --------------------- | ----------------------- | --------------------------------- | 2644| PING_TRANSACTION | 1599098439 (0x5f504e47) | 内部指令码，用于测试IPC服务正常。 | 2645| DUMP_TRANSACTION | 1598311760 (0x5f444d50) | 内部指令码，获取Binder内部状态。 | 2646| INTERFACE_TRANSACTION | 1598968902 (0x5f4e5446) | 内部指令码，获取对端接口描述符。 | 2647| MIN_TRANSACTION_ID | 1 (0x00000001) | 最小有效指令码。 | 2648| MAX_TRANSACTION_ID | 16777215 (0x00FFFFFF) | 最大有效指令码。 | 2649 2650 2651 2652 2653### sendRequest<sup>(deprecated)</sup> 2654 2655> **说明：** 2656> 从 API Version 8 开始废弃，建议使用[sendRequest<sup>8+</sup>](#sendrequest8-2)替代。 2657 2658sendRequest(code : number, data : MessageParcel, reply : MessageParcel, options : MessageOption): boolean 2659 2660以同步或异步方式向对端进程发送MessageParcel消息。如果为选项设置了异步模式，则期约立即兑现，reply报文里没有内容。如果为选项设置了同步模式，则期约将在sendRequest返回时兑现，回复内容在reply报文里。 2661 2662**系统能力**：SystemCapability.Communication.IPC.Core 2663 2664**参数：** 2665 | 参数名 | 类型 | 必填 | 说明 | 2666 | -------- | -------- | -------- | -------- | 2667 | code | number | 是 | 本次请求调用的消息码，由通信双方确定。如果接口由IDL工具生成，则消息代码由IDL自动生成。 | 2668 | data | [MessageParcel](#messageparcel) | 是 | 保存待发送数据的 MessageParcel对象。 | 2669 | reply | [MessageParcel](#messageparcel) | 是 | 接收应答数据的MessageParcel对象。 | 2670 | options | [MessageOption](#messageoption) | 是 | 本次请求的同异步模式，默认同步调用。 | 2671 2672**返回值：** 2673 | 类型 | 说明 | 2674 | -------- | -------- | 2675 | boolean | 返回一个布尔值，true表示成功，false表示失败。| 2676 2677 2678**示例：** 2679 2680 ``` 2681 import FA from "@ohos.ability.featureAbility"; 2682 let proxy; 2683 let connect = { 2684 onConnect: function(elementName, remoteProxy) { 2685 console.log("RpcClient: js onConnect called."); 2686 proxy = remoteProxy; 2687 }, 2688 onDisconnect: function(elementName) { 2689 console.log("RpcClient: onDisconnect"); 2690 }, 2691 onFailed: function() { 2692 console.log("RpcClient: onFailed"); 2693 } 2694 }; 2695 let want = { 2696 "bundleName": "com.ohos.server", 2697 "abilityName": "com.ohos.server.MainAbility", 2698 }; 2699 FA.connectAbility(want, connect); 2700 let option = new rpc.MessageOption(); 2701 let data = rpc.MessageParcel.create(); 2702 let reply = rpc.MessageParcel.create(); 2703 data.writeInt(1); 2704 data.writeString("hello"); 2705 let ret: boolean = proxy.sendRequest(1, data, reply, option); 2706 if (ret) { 2707 console.log("sendRequest got result"); 2708 let msg = reply.readString(); 2709 console.log("RPCTest: reply msg: " + msg); 2710 } else { 2711 console.log("RPCTest: sendRequest failed"); 2712 } 2713 console.log("RPCTest: sendRequest ends, reclaim parcel"); 2714 data.reclaim(); 2715 reply.reclaim(); 2716 ``` 2717 2718### sendRequest<sup>8+</sup> 2719 2720sendRequest(code : number, data : MessageParcel, reply : MessageParcel, options : MessageOption): Promise<SendRequestResult> 2721 2722以同步或异步方式向对端进程发送MessageParcel消息。如果为选项设置了异步模式，则期约立即兑现，reply报文里没有内容。如果为选项设置了同步模式，则期约将在sendRequest返回时兑现，回复内容在reply报文里。 2723 2724**系统能力**：SystemCapability.Communication.IPC.Core 2725 2726**参数：** 2727 | 参数名 | 类型 | 必填 | 说明 | 2728 | -------- | -------- | -------- | -------- | 2729 | code | number | 是 | 本次请求调用的消息码，由通信双方确定。如果接口由IDL工具生成，则消息代码由IDL自动生成。 | 2730 | data | [MessageParcel](#messageparcel) | 是 | 保存待发送数据的 MessageParcel对象。 | 2731 | reply | [MessageParcel](#messageparcel) | 是 | 接收应答数据的MessageParcel对象。 | 2732 | options | [MessageOption](#messageoption) | 是 | 本次请求的同异步模式，默认同步调用。 | 2733 2734**返回值：** 2735 | 类型 | 说明 | 2736 | -------- | -------- | 2737 | Promise<SendRequestResult> | 返回一个期约，兑现值是sendRequestResult实例。| 2738 2739**示例：** 2740 2741 ``` 2742 import FA from "@ohos.ability.featureAbility"; 2743 let proxy; 2744 let connect = { 2745 onConnect: function(elementName, remoteProxy) { 2746 console.log("RpcClient: js onConnect called."); 2747 proxy = remoteProxy; 2748 }, 2749 onDisconnect: function(elementName) { 2750 console.log("RpcClient: onDisconnect"); 2751 }, 2752 onFailed: function() { 2753 console.log("RpcClient: onFailed"); 2754 } 2755 }; 2756 let want = { 2757 "bundleName": "com.ohos.server", 2758 "abilityName": "com.ohos.server.MainAbility", 2759 }; 2760 FA.connectAbility(want, connect); 2761 let option = new rpc.MessageOption(); 2762 let data = rpc.MessageParcel.create(); 2763 let reply = rpc.MessageParcel.create(); 2764 data.writeInt(1); 2765 data.writeString("hello"); 2766 proxy.sendRequest(1, data, reply, option) 2767 .then(function(result) { 2768 if (result.errCode === 0) { 2769 console.log("sendRequest got result"); 2770 result.reply.readException(); 2771 let msg = result.reply.readString(); 2772 console.log("RPCTest: reply msg: " + msg); 2773 } else { 2774 console.log("RPCTest: sendRequest failed, errCode: " + result.errCode); 2775 } 2776 }).catch(function(e) { 2777 console.log("RPCTest: sendRequest got exception: " + e.message); 2778 }).finally (() => { 2779 console.log("RPCTest: sendRequest ends, reclaim parcel"); 2780 data.reclaim(); 2781 reply.reclaim(); 2782 }); 2783 ``` 2784 2785 2786### sendRequest<sup>8+</sup> 2787 2788sendRequest(code: number, data: MessageParcel, reply: MessageParcel, options: MessageOption, callback: AsyncCallback<SendRequestResult>): void 2789 2790以同步或异步方式向对端进程发送MessageParcel消息。如果为选项设置了异步模式，则立即收到回调，reply报文里没有内容。如果为选项设置了同步模式，则将在sendRequest返回时收到回调，回复内容在reply报文里。 2791 2792**系统能力**：SystemCapability.Communication.IPC.Core 2793 2794**参数：** 2795 | 参数名 | 类型 | 必填 | 说明 | 2796 | -------- | -------- | -------- | -------- | 2797 | code | number | 是 | 本次请求调用的消息码，由通信双方确定。如果接口由IDL工具生成，则消息代码由IDL自动生成。 | 2798 | data | [MessageParcel](#messageparcel) | 是 | 保存待发送数据的 MessageParcel对象。 | 2799 | reply | [MessageParcel](#messageparcel) | 是 | 接收应答数据的MessageParcel对象。 | 2800 | options | [MessageOption](#messageoption) | 是 | 本次请求的同异步模式，默认同步调用。 | 2801 | callback | AsyncCallback<SendRequestResult> | 是 | 接收发送结果的回调。 | 2802 2803**示例：** 2804 2805 ``` 2806 import FA from "@ohos.ability.featureAbility"; 2807 let proxy; 2808 let connect = { 2809 onConnect: function(elementName, remoteProxy) { 2810 console.log("RpcClient: js onConnect called."); 2811 proxy = remoteProxy; 2812 }, 2813 onDisconnect: function(elementName) { 2814 console.log("RpcClient: onDisconnect"); 2815 }, 2816 onFailed: function() { 2817 console.log("RpcClient: onFailed"); 2818 } 2819 }; 2820 let want = { 2821 "bundleName": "com.ohos.server", 2822 "abilityName": "com.ohos.server.MainAbility", 2823 }; 2824 function sendRequestCallback(result) { 2825 if (result.errCode === 0) { 2826 console.log("sendRequest got result"); 2827 result.reply.readException(); 2828 let msg = result.reply.readString(); 2829 console.log("RPCTest: reply msg: " + msg); 2830 } else { 2831 console.log("RPCTest: sendRequest failed, errCode: " + result.errCode); 2832 } 2833 console.log("RPCTest: sendRequest ends, reclaim parcel"); 2834 result.data.reclaim(); 2835 result.reply.reclaim(); 2836 } 2837 FA.connectAbility(want, connect); 2838 let option = new rpc.MessageOption(); 2839 let data = rpc.MessageParcel.create(); 2840 let reply = rpc.MessageParcel.create(); 2841 data.writeInt(1); 2842 data.writeString("hello"); 2843 proxy.sendRequest(1, data, reply, option, sendRequestCallback); 2844 ``` 2845 2846 2847### queryLocalInterface 2848 2849queryLocalInterface(interface: string): IRemoteBroker 2850 2851查询并获取当前接口描述符对应的本地接口对象。 2852 2853**系统能力**：SystemCapability.Communication.IPC.Core 2854 2855**参数：** 2856 | 参数名 | 类型 | 必填 | 说明 | 2857 | -------- | -------- | -------- | -------- | 2858 | interface | string | 是 | 需要查询的接口描述符。 | 2859 2860**返回值：** 2861 | 类型 | 说明 | 2862 | -------- | -------- | 2863 | IRemoteBroker | 默认返回Null，标识该接口是一个代理侧接口。 | 2864 2865**示例：** 2866 2867 ``` 2868 import FA from "@ohos.ability.featureAbility"; 2869 let proxy; 2870 let connect = { 2871 onConnect: function(elementName, remoteProxy) { 2872 console.log("RpcClient: js onConnect called."); 2873 proxy = remoteProxy; 2874 }, 2875 onDisconnect: function (elementName) { 2876 console.log("RpcClient: onDisconnect"); 2877 }, 2878 onFailed: function() { 2879 console.log("RpcClient: onFailed"); 2880 } 2881 }; 2882 let want = { 2883 "bundleName":"com.ohos.server", 2884 "abilityName":"com.ohos.server.MainAbility", 2885 }; 2886 FA.connectAbility(want, connect); 2887 let broker = proxy.queryLocalInterface("testObject"); 2888 console.log("RpcClient: queryLocalInterface is " + broker); 2889 ``` 2890 2891 2892### addDeathRecippient 2893 2894addDeathRecipient(recipient : DeathRecipient, flags : number): boolean 2895 2896注册用于接收远程对象死亡通知的回调，增加proxy对象上的死亡通知。 2897 2898**系统能力**：SystemCapability.Communication.IPC.Core 2899 2900**参数：** 2901 | 参数名 | 类型 | 必填 | 说明 | 2902 | -------- | -------- | -------- | -------- | 2903 | recipient | [DeathRecipient](#deathrecipient) | 是 | 收件人表示要注册的回调。 | 2904 | flags | number | 是 | 死亡通知标志。保留参数。设置为0。 | 2905 2906**返回值：** 2907 | 类型 | 说明 | 2908 | -------- | -------- | 2909 | boolean | 如果回调注册成功，则返回true；否则返回false。 | 2910 2911**示例：** 2912 2913 ``` 2914 import FA from "@ohos.ability.featureAbility"; 2915 let proxy; 2916 let connect = { 2917 onConnect: function(elementName, remoteProxy) { 2918 console.log("RpcClient: js onConnect called."); 2919 proxy = remoteProxy; 2920 }, 2921 onDisconnect: function(elementName) { 2922 console.log("RpcClient: onDisconnect"); 2923 }, 2924 onFailed: function() { 2925 console.log("RpcClient: onFailed"); 2926 } 2927 }; 2928 let want = { 2929 "bundleName": "com.ohos.server", 2930 "abilityName": "com.ohos.server.MainAbility", 2931 }; 2932 FA.connectAbility(want, connect); 2933 class MyDeathRecipient { 2934 onRemoteDied() { 2935 console.log("server died"); 2936 } 2937 } 2938 let deathRecipient = new MyDeathRecipient(); 2939 proxy.addDeathRecippient(deathRecipient, 0); 2940 ``` 2941 2942 2943### removeDeathRecipient 2944 2945removeDeathRecipient(recipient : DeathRecipient, flags : number): boolean 2946 2947注销用于接收远程对象死亡通知的回调。 2948 2949**系统能力**：SystemCapability.Communication.IPC.Core 2950 2951**参数：** 2952 | 参数名 | 类型 | 必填 | 说明 | 2953 | -------- | -------- | -------- | -------- | 2954 | recipient | [DeathRecipient](#deathrecipient) | 是 | 要注销的死亡回调。 | 2955 | flags | number | 是 | 死亡通知标志。保留参数。设置为0。 | 2956 2957**返回值：** 2958 | 类型 | 说明 | 2959 | -------- | -------- | 2960 | boolean | 如果回调成功注销，则返回true；否则返回false。 | 2961 2962**示例：** 2963 2964 ``` 2965 import FA from "@ohos.ability.featureAbility"; 2966 let proxy; 2967 let connect = { 2968 onConnect: function(elementName, remoteProxy) { 2969 console.log("RpcClient: js onConnect called."); 2970 proxy = remoteProxy; 2971 }, 2972 onDisconnect: function(elementName) { 2973 console.log("RpcClient: onDisconnect"); 2974 }, 2975 onFailed: function() { 2976 console.log("RpcClient: onFailed"); 2977 } 2978 }; 2979 let want = { 2980 "bundleName": "com.ohos.server", 2981 "abilityName": "com.ohos.server.MainAbility", 2982 }; 2983 FA.connectAbility(want, connect); 2984 class MyDeathRecipient { 2985 onRemoteDied() { 2986 console.log("server died"); 2987 } 2988 } 2989 let deathRecipient = new MyDeathRecipient(); 2990 proxy.addDeathRecippient(deathRecipient, 0); 2991 proxy.removeDeathRecipient(deathRecipient, 0); 2992 ``` 2993 2994 2995### getInterfaceDescriptor 2996 2997getInterfaceDescriptor(): string 2998 2999查询当前代理对象接口的描述符。 3000 3001**系统能力**：SystemCapability.Communication.IPC.Core 3002 3003**返回值：** 3004 | 类型 | 说明 | 3005 | -------- | -------- | 3006 | string | 当前的接口描述符。 | 3007 3008**示例：** 3009 3010 ``` 3011 import FA from "@ohos.ability.featureAbility"; 3012 let proxy; 3013 let connect = { 3014 onConnect: function(elementName, remoteProxy) { 3015 console.log("RpcClient: js onConnect called."); 3016 proxy = remoteProxy; 3017 }, 3018 onDisconnect: function(elementName) { 3019 console.log("RpcClient: onDisconnect"); 3020 }, 3021 onFailed: function() { 3022 console.log("RpcClient: onFailed"); 3023 } 3024 }; 3025 let want = { 3026 "bundleName": "com.ohos.server", 3027 "abilityName": "com.ohos.server.MainAbility", 3028 }; 3029 FA.connectAbility(want, connect); 3030 let descriptor = proxy.getInterfaceDescriptor(); 3031 console.log("RpcClient: descriptor is " + descriptor); 3032 ``` 3033 3034 3035### isObjectDead 3036 3037isObjectDead(): boolean 3038 3039指示对应的RemoteObject是否死亡。 3040 3041**系统能力**：SystemCapability.Communication.IPC.Core 3042 3043**返回值：** 3044 | 类型 | 说明 | 3045 | -------- | -------- | 3046 | boolean | 如果对应的RemoteObject已经死亡，返回true，否则返回false。 | 3047 3048**示例：** 3049 3050 ``` 3051 import FA from "@ohos.ability.featureAbility"; 3052 let proxy; 3053 let connect = { 3054 onConnect: function(elementName, remoteProxy) { 3055 console.log("RpcClient: js onConnect called."); 3056 proxy = remoteProxy; 3057 }, 3058 onDisconnect: function(elementName) { 3059 console.log("RpcClient: onDisconnect"); 3060 }, 3061 onFailed: function() { 3062 console.log("RpcClient: onFailed"); 3063 } 3064 }; 3065 let want = { 3066 "bundleName": "com.ohos.server", 3067 "abilityName": "com.ohos.server.MainAbility", 3068 }; 3069 FA.connectAbility(want, connect); 3070 let isDead = proxy.isObjectDead(); 3071 console.log("RpcClient: isObjectDead is " + isDead); 3072 ``` 3073 3074 3075## MessageOption 3076 3077公共消息选项（int标志，int等待时间），使用标志中指定的标志构造指定的MessageOption对象。 3078 3079**系统能力**：以下各项对应的系统能力均为SystemCapability.Communication.IPC.Core。 3080 3081 | 参数 | 值 | 说明 | 3082| -------- | -------- | -------- | 3083| TF_SYNC | 0 | 同步调用。 | 3084| TF_ASYNC | 1 | 异步调用。 | 3085| TF_ACCEPT_FDS | 0x10 | 指示[sendRequest](#sendrequest8)接口可以返回文件描述符。 | 3086| TF_WAIT_TIME | 8 | 等待时间。单位秒。 | 3087 3088 3089### constructor 3090 3091constructor(syncFlags?: number, waitTime = TF_WAIT_TIME) 3092 3093MessageOption构造函数。 3094 3095**系统能力**：SystemCapability.Communication.IPC.Core 3096 3097**参数：** 3098 | 参数名 | 类型 | 必填 | 说明 | 3099 | -------- | -------- | -------- | -------- | 3100 | syncFlags | number | 否 | 同步调用或异步调用标志。默认同步调用。 | 3101 | waitTime | number | 否 | 调用rpc最长等待时间。默认 TF_WAIT_TIME。 | 3102 3103 3104### getFlags 3105 3106getFlags(): number 3107 3108获取同步调用或异步调用标志。 3109 3110**系统能力**：SystemCapability.Communication.IPC.Core 3111 3112**返回值：** 3113 | 类型 | 说明 | 3114 | -------- | -------- | 3115 | number | 调用成功返回同步调用或异步调用标志。 | 3116 3117 3118### setFlags 3119 3120setFlags(flags: number): void 3121 3122设置同步调用或异步调用标志。 3123 3124**系统能力**：SystemCapability.Communication.IPC.Core 3125 3126**参数：** 3127 | 参数名 | 类型 | 必填 | 说明 | 3128 | -------- | -------- | -------- | -------- | 3129 | flags | number | 是 | 同步调用或异步调用标志。 | 3130 3131 3132### getWaitTime 3133 3134getWaitTime(): number 3135 3136获取rpc调用的最长等待时间。 3137 3138**系统能力**：SystemCapability.Communication.IPC.Core 3139 3140**返回值：** 3141 | 类型 | 说明 | 3142 | -------- | -------- | 3143 | number | rpc最长等待时间。 | 3144 3145 3146### setWaitTime 3147 3148setWaitTime(waitTime: number): void 3149 3150设置rpc调用最长等待时间。 3151 3152**系统能力**：SystemCapability.Communication.IPC.Core 3153 3154**参数：** 3155 | 参数名 | 类型 | 必填 | 说明 | 3156 | -------- | -------- | -------- | -------- | 3157 | waitTime | number | 是 | rpc调用最长等待时间。 | 3158 3159 3160## IPCSkeleton 3161 3162用于获取IPC上下文信息，包括获取UID和PID、获取本端和对端设备ID、检查接口调用是否在同一设备上。 3163 3164 3165### getContextObject 3166 3167static getContextObject(): IRemoteObject 3168 3169获取系统能力的管理者。 3170 3171**系统能力**：SystemCapability.Communication.IPC.Core 3172 3173**返回值：** 3174 | 类型 | 说明 | 3175 | -------- | -------- | 3176 | [IRemoteObject](#iremoteobject) | 返回系统能力管理者。 | 3177 3178**示例：** 3179 3180 ``` 3181 let samgr = rpc.IPCSkeleton.getContextObject(); 3182 console.log("RpcServer: getContextObject result: " + samgr); 3183 ``` 3184 3185 3186### getCallingPid 3187 3188static getCallingPid(): number 3189 3190获取调用者的PID。此方法由RemoteObject对象在onRemoteRequest方法中调用，不在IPC上下文环境（onRemoteRequest）中调用则返回本进程的PID。 3191 3192**系统能力**：SystemCapability.Communication.IPC.Core 3193 3194**返回值：** 3195 | 类型 | 说明 | 3196 | -------- | -------- | 3197 | number | 返回调用者的PID。 | 3198 3199**示例：** 3200 3201 ``` 3202 class Stub extends rpc.RemoteObject { 3203 onRemoteRequest(code, data, reply, option) { 3204 let callerPid = rpc.IPCSkeleton.getCallingPid(); 3205 console.log("RpcServer: getCallingPid result: " + callerPid); 3206 return true; 3207 } 3208 } 3209 ``` 3210 3211 3212### getCallingUid 3213 3214static getCallingUid(): number 3215 3216获取调用者的UID。此方法由RemoteObject对象在onRemoteRequest方法中调用，不在IPC上下文环境（onRemoteRequest）中调用则返回本进程的UID。 3217 3218**系统能力**：SystemCapability.Communication.IPC.Core 3219 3220**返回值：** 3221 | 类型 | 说明 | 3222 | -------- | -------- | 3223 | number | 返回调用者的UID。 | 3224 3225**示例：** 3226 3227 ``` 3228 class Stub extends rpc.RemoteObject { 3229 onRemoteRequest(code, data, reply, option) { 3230 let callerUid = rpc.IPCSkeleton.getCallingUid(); 3231 console.log("RpcServer: getCallingUid result: " + callerUid); 3232 return true; 3233 } 3234 } 3235 ``` 3236 3237### getCallingTokenId<sup>8+</sup> 3238 3239static getCallingTokenId(): number; 3240 3241获取调用者的TokenId，用于被调用方对调用方的身份校验。 3242 3243**系统能力**：SystemCapability.Communication.IPC.Core 3244 3245* 返回值 3246 3247 | 类型 | 说明 | 3248 | ------ | --------------------- | 3249 | number | 返回调用者的TokenId。 | 3250 3251* 示例 3252 3253 ``` 3254 class Stub extends rpc.RemoteObject { 3255 onRemoteRequest(code, data, reply, option) { 3256 let callerTokenId = rpc.IPCSkeleton.getCallingTokenId(); 3257 console.log("RpcServer: getCallingTokenId result: " + callerTokenId); 3258 return true; 3259 } 3260 } 3261 ``` 3262 3263 3264### getCallingDeviceID 3265 3266static getCallingDeviceID(): string 3267 3268获取调用者进程所在的设备ID。 3269 3270**系统能力**：SystemCapability.Communication.IPC.Core 3271 3272**返回值：** 3273 | 类型 | 说明 | 3274 | -------- | -------- | 3275 | string | 返回调用者进程所在的设备ID。 | 3276 3277**示例：** 3278 3279 ``` 3280 class Stub extends rpc.RemoteObject { 3281 onRemoteRequest(code, data, reply, option) { 3282 let callerDeviceID = rpc.IPCSkeleton.getCallingDeviceID(); 3283 console.log("RpcServer: callerDeviceID is: " + callerDeviceID); 3284 return true; 3285 } 3286 } 3287 ``` 3288 3289 3290### getLocalDeviceID 3291 3292static getLocalDeviceID(): string 3293 3294获取本端设备ID。 3295 3296**系统能力**：SystemCapability.Communication.IPC.Core 3297 3298**返回值：** 3299 | 类型 | 说明 | 3300 | -------- | -------- | 3301 | string | 返回本地设备的ID。 | 3302 3303**示例：** 3304 3305 ``` 3306 class Stub extends rpc.RemoteObject { 3307 onRemoteRequest(code, data, reply, option) { 3308 let localDeviceID = rpc.IPCSkeleton.getLocalDeviceID(); 3309 console.log("RpcServer: localDeviceID is: " + localDeviceID); 3310 return true; 3311 } 3312 } 3313 ``` 3314 3315 3316### isLocalCalling 3317 3318static isLocalCalling(): boolean 3319 3320检查当前通信对端是否是本设备的进程。 3321 3322**系统能力**：SystemCapability.Communication.IPC.Core 3323 3324**返回值：** 3325 | 类型 | 说明 | 3326 | -------- | -------- | 3327 | boolean | 如果调用是在同一设备上进行的，则返回true，否则返回false。 | 3328 3329**示例：** 3330 3331 ``` 3332 class Stub extends rpc.RemoteObject { 3333 onRemoteRequest(code, data, reply, option) { 3334 let isLocalCalling = rpc.IPCSkeleton.isLocalCalling(); 3335 console.log("RpcServer: isLocalCalling is: " + isLocalCalling); 3336 return true; 3337 } 3338 } 3339 ``` 3340 3341 3342### flushCommands 3343 3344static flushCommands(object : IRemoteObject): number 3345 3346将所有挂起的命令从指定的RemoteProxy刷新到相应的RemoteObject。建议在执行任何时间敏感操作之前调用此方法。 3347 3348**系统能力**：SystemCapability.Communication.IPC.Core 3349 3350**参数：** 3351 | 参数名 | 类型 | 必填 | 说明 | 3352 | -------- | -------- | -------- | -------- | 3353 | object | [IRemoteObject](#iremoteobject) | 是 | 指定的RemoteProxy。 | 3354 3355 3356**返回值：** 3357 | 类型 | 说明 | 3358 | -------- | -------- | 3359 | number | 如果操作成功，返回0；如果输入对象为空或RemoteObject，或者操作失败，返回错误代码。 | 3360 3361**示例：** 3362 3363 ``` 3364 class MyDeathRecipient { 3365 onRemoteDied() { 3366 console.log("server died"); 3367 } 3368 } 3369 class TestRemoteObject extends rpc.RemoteObject { 3370 constructor(descriptor) { 3371 super(descriptor); 3372 } 3373 addDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 3374 return true; 3375 } 3376 removeDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 3377 return true; 3378 } 3379 isObjectDead(): boolean { 3380 return false; 3381 } 3382 } 3383 let remoteObject = new TestRemoteObject("aaa"); 3384 let ret = rpc.IPCSkeleton.flushCommands(remoteObject); 3385 console.log("RpcServer: flushCommands result: " + ret); 3386 ``` 3387 3388 3389### resetCallingIdentity 3390 3391static resetCallingIdentity(): string 3392 3393将远程用户的UID和PID替换为本地用户的UID和PID。它可以用于身份验证等场景。 3394 3395**系统能力**：SystemCapability.Communication.IPC.Core 3396 3397**返回值：** 3398 | 类型 | 说明 | 3399 | -------- | -------- | 3400 | string | 返回包含远程用户的UID和PID的字符串。 | 3401 3402**示例：** 3403 3404 ``` 3405 class Stub extends rpc.RemoteObject { 3406 onRemoteRequest(code, data, reply, option) { 3407 let callingIdentity = rpc.IPCSkeleton.resetCallingIdentity(); 3408 console.log("RpcServer: callingIdentity is: " + callingIdentity); 3409 return true; 3410 } 3411 } 3412 ``` 3413 3414 3415### setCallingIdentity 3416 3417static setCallingIdentity(identity : string): boolean 3418 3419将UID和PID恢复为远程用户的UID和PID。它通常在使用resetCallingIdentity后调用，需要resetCallingIdentity返回的远程用户的UID和PID。 3420 3421**系统能力**：SystemCapability.Communication.IPC.Core 3422 3423**参数：** 3424 | 参数名 | 类型 | 必填 | 说明 | 3425 | -------- | -------- | -------- | -------- | 3426 | identity | string | 是 | 标识表示包含远程用户UID和PID的字符串。由resetCallingIdentity返回。 | 3427 3428**返回值：** 3429 | 类型 | 说明 | 3430 | -------- | -------- | 3431 | boolean | 如果操作成功，则返回true；否则返回false。 | 3432 3433**示例：** 3434 3435 ``` 3436 class Stub extends rpc.RemoteObject { 3437 onRemoteRequest(code, data, reply, option) { 3438 let callingIdentity = null; 3439 try { 3440 callingIdentity = rpc.IPCSkeleton.resetCallingIdentity(); 3441 console.log("RpcServer: callingIdentity is: " + callingIdentity); 3442 } finally { 3443 let ret = rpc.IPCSkeleton.setCallingIdentity("callingIdentity "); 3444 console.log("RpcServer: setCallingIdentity is: " + ret); 3445 } 3446 return true; 3447 } 3448 } 3449 ``` 3450 3451 3452## RemoteObject 3453 3454实现远程对象。服务提供者必须继承此类。 3455 3456 3457### constructor 3458 3459constructor(descriptor: string) 3460 3461RemoteObject构造函数。 3462 3463**系统能力**：SystemCapability.Communication.IPC.Core 3464 3465**参数：** 3466 | 参数名 | 类型 | 必填 | 说明 | 3467 | -------- | -------- | -------- | -------- | 3468 | descriptor | string | 是 | 接口描述符。 | 3469 3470 3471### sendRequest<sup>(deprecated)</sup> 3472 3473> **说明：** 3474> 从 API Version 8 开始废弃，建议使用[sendRequest<sup>8+</sup>](#sendrequest8-4)替代。 3475 3476sendRequest(code : number, data : MessageParcel, reply : MessageParcel, options : MessageOption): boolean 3477 3478以同步或异步方式向对端进程发送MessageParcel消息。如果为选项设置了异步模式，则期约立即兑现，reply报文里没有内容。如果为选项设置了同步模式，则期约将在sendRequest返回时兑现，回复内容在reply报文里。 3479 3480**系统能力**：SystemCapability.Communication.IPC.Core 3481 3482**参数：** 3483 | 参数名 | 类型 | 必填 | 说明 | 3484 | -------- | -------- | -------- | -------- | 3485 | code | number | 是 | 本次请求调用的消息码，由通信双方确定。如果接口由IDL工具生成，则消息代码由IDL自动生成。 | 3486 | data | [MessageParcel](#messageparcel) | 是 | 保存待发送数据的 MessageParcel对象。 | 3487 | reply | [MessageParcel](#messageparcel) | 是 | 接收应答数据的MessageParcel对象。 | 3488 | options | [MessageOption](#messageoption) | 是 | 本次请求的同异步模式，默认同步调用。 | 3489 3490**返回值：** 3491 | 类型 | 说明 | 3492 | -------- | -------- | 3493 | boolean | 返回一个布尔值，true表示成功，false表示失败。| 3494 3495 3496**示例：** 3497 3498 ``` 3499 class MyDeathRecipient { 3500 onRemoteDied() { 3501 console.log("server died"); 3502 } 3503 } 3504 class TestRemoteObject extends rpc.RemoteObject { 3505 constructor(descriptor) { 3506 super(descriptor); 3507 } 3508 addDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 3509 return true; 3510 } 3511 removeDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 3512 return true; 3513 } 3514 isObjectDead(): boolean { 3515 return false; 3516 } 3517 } 3518 let testRemoteObject = new TestRemoteObject("testObject"); 3519 let option = new rpc.MessageOption(); 3520 let data = rpc.MessageParcel.create(); 3521 let reply = rpc.MessageParcel.create(); 3522 data.writeInt(1); 3523 data.writeString("hello"); 3524 let ret: boolean = testRemoteObject.sendRequest(1, data, reply, option); 3525 if (ret) { 3526 console.log("sendRequest got result"); 3527 let msg = reply.readString(); 3528 console.log("RPCTest: reply msg: " + msg); 3529 } else { 3530 console.log("RPCTest: sendRequest failed"); 3531 } 3532 console.log("RPCTest: sendRequest ends, reclaim parcel"); 3533 data.reclaim(); 3534 reply.reclaim(); 3535 ``` 3536 3537 3538### sendRequest<sup>8+</sup> 3539 3540sendRequest(code : number, data : MessageParcel, reply : MessageParcel, options : MessageOption): Promise<SendRequestResult> 3541 3542以同步或异步方式向对端进程发送MessageParcel消息。如果为选项设置了异步模式，则期约立即兑现，reply报文里没有内容。如果为选项设置了同步模式，则期约将在sendRequest返回时兑现，回复内容在reply报文里。 3543 3544**系统能力**：SystemCapability.Communication.IPC.Core 3545 3546**参数：** 3547 | 参数名 | 类型 | 必填 | 说明 | 3548 | -------- | -------- | -------- | -------- | 3549 | code | number | 是 | 本次请求调用的消息码，由通信双方确定。如果接口由IDL工具生成，则消息代码由IDL自动生成。 | 3550 | data | [MessageParcel](#messageparcel) | 是 | 保存待发送数据的 MessageParcel对象。 | 3551 | reply | [MessageParcel](#messageparcel) | 是 | 接收应答数据的MessageParcel对象。 | 3552 | options | [MessageOption](#messageoption) | 是 | 本次请求的同异步模式，默认同步调用。 | 3553 3554**返回值：** 3555 | 类型 | 说明 | 3556 | -------- | -------- | 3557 | Promise<SendRequestResult> | 返回一个期约，兑现值是sendRequestResult实例。| 3558 3559 3560**示例：** 3561 3562 ``` 3563 class MyDeathRecipient { 3564 onRemoteDied() { 3565 console.log("server died"); 3566 } 3567 } 3568 class TestRemoteObject extends rpc.RemoteObject { 3569 constructor(descriptor) { 3570 super(descriptor); 3571 } 3572 addDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 3573 return true; 3574 } 3575 removeDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 3576 return true; 3577 } 3578 isObjectDead(): boolean { 3579 return false; 3580 } 3581 } 3582 let testRemoteObject = new TestRemoteObject("testObject"); 3583 let option = new rpc.MessageOption(); 3584 let data = rpc.MessageParcel.create(); 3585 let reply = rpc.MessageParcel.create(); 3586 data.writeInt(1); 3587 data.writeString("hello"); 3588 testRemoteObject.sendRequest(1, data, reply, option) 3589 .then(function(result) { 3590 if (result.errCode === 0) { 3591 console.log("sendRequest got result"); 3592 result.reply.readException(); 3593 let msg = result.reply.readString(); 3594 console.log("RPCTest: reply msg: " + msg); 3595 } else { 3596 console.log("RPCTest: sendRequest failed, errCode: " + result.errCode); 3597 } 3598 }).catch(function(e) { 3599 console.log("RPCTest: sendRequest got exception: " + e.message); 3600 }).finally (() => { 3601 console.log("RPCTest: sendRequest ends, reclaim parcel"); 3602 data.reclaim(); 3603 reply.reclaim(); 3604 }); 3605 ``` 3606 3607 3608### sendRequest<sup>8+</sup> 3609 3610sendRequest(code: number, data: MessageParcel, reply: MessageParcel, options: MessageOption, callback: AsyncCallback<SendRequestResult>): void 3611 3612以同步或异步方式向对端进程发送MessageParcel消息。如果为选项设置了异步模式，则立即收到回调，reply报文里没有内容。如果为选项设置了同步模式，则将在sendRequest返回时收到回调，回复内容在reply报文里。 3613 3614**系统能力**：SystemCapability.Communication.IPC.Core 3615 3616**参数：** 3617 | 参数名 | 类型 | 必填 | 说明 | 3618 | -------- | -------- | -------- | -------- | 3619 | code | number | 是 | 本次请求调用的消息码，由通信双方确定。如果接口由IDL工具生成，则消息代码由IDL自动生成。 | 3620 | data | [MessageParcel](#messageparcel) | 是 | 保存待发送数据的 MessageParcel对象。 | 3621 | reply | [MessageParcel](#messageparcel) | 是 | 接收应答数据的MessageParcel对象。 | 3622 | options | [MessageOption](#messageoption) | 是 | 本次请求的同异步模式，默认同步调用。 | 3623 | AsyncCallback | AsyncCallback<SendRequestResult> | 是 | 接收发送结果的回调。 | 3624 3625 3626**示例：** 3627 3628 ``` 3629 class MyDeathRecipient { 3630 onRemoteDied() { 3631 console.log("server died"); 3632 } 3633 } 3634 class TestRemoteObject extends rpc.RemoteObject { 3635 constructor(descriptor) { 3636 super(descriptor); 3637 } 3638 addDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 3639 return true; 3640 } 3641 removeDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 3642 return true; 3643 } 3644 isObjectDead(): boolean { 3645 return false; 3646 } 3647 } 3648 function sendRequestCallback(result) { 3649 if (result.errCode === 0) { 3650 console.log("sendRequest got result"); 3651 result.reply.readException(); 3652 let msg = result.reply.readString(); 3653 console.log("RPCTest: reply msg: " + msg); 3654 } else { 3655 console.log("RPCTest: sendRequest failed, errCode: " + result.errCode); 3656 } 3657 console.log("RPCTest: sendRequest ends, reclaim parcel"); 3658 result.data.reclaim(); 3659 result.reply.reclaim(); 3660 } 3661 let testRemoteObject = new TestRemoteObject("testObject"); 3662 let option = new rpc.MessageOption(); 3663 let data = rpc.MessageParcel.create(); 3664 let reply = rpc.MessageParcel.create(); 3665 data.writeInt(1); 3666 data.writeString("hello"); 3667 testRemoteObject.sendRequest(1, data, reply, option, sendRequestCallback); 3668 ``` 3669 3670 3671### onRemoteRequest 3672 3673onRemoteRequest(code : number, data : MessageParcel, reply: MessageParcel, options : MessageOption): boolean 3674 3675sendRequest请求的响应处理函数，服务端在该函数里处理请求，回复结果。 3676 3677**系统能力**：SystemCapability.Communication.IPC.Core 3678 3679**参数：** 3680 | 参数名 | 类型 | 必填 | 说明 | 3681 | -------- | -------- | -------- | -------- | 3682 | code | number | 是 | 对端发送的服务请求码。 | 3683 | data | [MessageParcel](#messageparcel) | 是 | 携带客户端调用参数的MessageParcel对象。 | 3684 | reply | [MessageParcel](#messageparcel) | 是 | 写入结果的MessageParcel对象。 | 3685 | option | [MessageOption](#messageoption) | 是 | 指示操作是同步还是异步。 | 3686 3687**返回值：** 3688 | 类型 | 说明 | 3689 | -------- | -------- | 3690 | boolean | 如果操作成功，则返回true；否则返回false。 | 3691 3692 3693**示例：** 3694 3695 ``` 3696 class MyDeathRecipient { 3697 onRemoteDied() { 3698 console.log("server died"); 3699 } 3700 } 3701 class TestRemoteObject extends rpc.RemoteObject { 3702 constructor(descriptor) { 3703 super(descriptor); 3704 } 3705 addDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 3706 return true; 3707 } 3708 removeDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 3709 return true; 3710 } 3711 isObjectDead(): boolean { 3712 return false; 3713 } 3714 3715 onRemoteRequest(code, data, reply, option) { 3716 if (code === 1) { 3717 console.log("RpcServer: onRemoteRequest called"); 3718 return true; 3719 } else { 3720 console.log("RpcServer: unknown code: " + code); 3721 return false; 3722 } 3723 } 3724 } 3725 ``` 3726 3727 3728### getCallingUid 3729 3730getCallingUid(): number 3731 3732获取通信对端的进程Uid。 3733 3734**系统能力**：SystemCapability.Communication.IPC.Core 3735 3736**返回值：** 3737 | 类型 | 说明 | 3738 | -------- | -------- | 3739 | number | 返回通信对端的进程Uid。 | 3740 3741 3742**示例：** 3743 3744 ``` 3745 class MyDeathRecipient { 3746 onRemoteDied() { 3747 console.log("server died"); 3748 } 3749 } 3750 class TestRemoteObject extends rpc.RemoteObject { 3751 constructor(descriptor) { 3752 super(descriptor); 3753 } 3754 addDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 3755 return true; 3756 } 3757 removeDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 3758 return true; 3759 } 3760 isObjectDead(): boolean { 3761 return false; 3762 } 3763 } 3764 let testRemoteObject = new TestRemoteObject("testObject"); 3765 console.log("RpcServer: getCallingUid: " + testRemoteObject.getCallingUid()); 3766 ``` 3767 3768 3769### getCallingPid 3770 3771getCallingPid(): number 3772 3773获取通信对端的进程Pid。 3774 3775**系统能力**：SystemCapability.Communication.IPC.Core 3776 3777**返回值：** 3778 | 类型 | 说明 | 3779 | -------- | -------- | 3780 | number | 返回通信对端的进程Pid。 | 3781 3782 3783**示例：** 3784 3785 ``` 3786 class MyDeathRecipient { 3787 onRemoteDied() { 3788 console.log("server died"); 3789 } 3790 } 3791 class TestRemoteObject extends rpc.RemoteObject { 3792 constructor(descriptor) { 3793 super(descriptor); 3794 } 3795 addDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 3796 return true; 3797 } 3798 removeDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 3799 return true; 3800 } 3801 isObjectDead(): boolean { 3802 return false; 3803 } 3804 } 3805 let testRemoteObject = new TestRemoteObject("testObject"); 3806 console.log("RpcServer: getCallingPid: " + testRemoteObject.getCallingPid()); 3807 ``` 3808 3809 3810### queryLocalInterface 3811 3812queryLocalInterface(descriptor: string): IRemoteBroker 3813 3814查询并获取当前接口描述符对应的远端对象是否已经存在。 3815 3816**系统能力**：SystemCapability.Communication.IPC.Core 3817 3818**参数：** 3819 | 参数名 | 类型 | 必填 | 说明 | 3820 | -------- | -------- | -------- | -------- | 3821 | descriptor | string | 是 | 需要查询的接口描述符。 | 3822 3823**返回值：** 3824 | 类型 | 说明 | 3825 | -------- | -------- | 3826 | IRemoteBroker | 如果接口描述符对应的远端对象存在，则返回该远端对象，否则返回Null。 | 3827 3828 3829**示例：** 3830 3831 ``` 3832 class MyDeathRecipient { 3833 onRemoteDied() { 3834 console.log("server died"); 3835 } 3836 } 3837 class TestRemoteObject extends rpc.RemoteObject { 3838 constructor(descriptor) { 3839 super(descriptor); 3840 } 3841 addDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 3842 return true; 3843 } 3844 removeDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 3845 return true; 3846 } 3847 isObjectDead(): boolean { 3848 return false; 3849 } 3850 } 3851 let testRemoteObject = new TestRemoteObject("testObject"); 3852 let broker = testRemoteObject.queryLocalInterface("testObject"); 3853 ``` 3854 3855 3856### getInterfaceDescriptor 3857 3858getInterfaceDescriptor(): string 3859 3860查询接口描述符。 3861 3862**系统能力**：SystemCapability.Communication.IPC.Core 3863 3864**返回值：** 3865 | 类型 | 说明 | 3866 | -------- | -------- | 3867 | string | 返回接口描述符。 | 3868 3869 3870**示例：** 3871 3872 ``` 3873 class MyDeathRecipient { 3874 onRemoteDied() { 3875 console.log("server died"); 3876 } 3877 } 3878 class TestRemoteObject extends rpc.RemoteObject { 3879 constructor(descriptor) { 3880 super(descriptor); 3881 } 3882 addDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 3883 return true; 3884 } 3885 removeDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 3886 return true; 3887 } 3888 isObjectDead(): boolean { 3889 return false; 3890 } 3891 } 3892 let testRemoteObject = new TestRemoteObject("testObject"); 3893 let descriptor = testRemoteObject.getInterfaceDescriptor(); 3894 console.log("RpcServer: descriptor is: " + descriptor); 3895 ``` 3896 3897 3898### attachLocalInterface 3899 3900attachLocalInterface(localInterface: IRemoteBroker, descriptor: string): void 3901 3902此接口用于把接口描述符和IRemoteBroker对象绑定。 3903 3904**系统能力**：SystemCapability.Communication.IPC.Core 3905 3906**参数：** 3907 | 参数名 | 类型 | 必填 | 说明 | 3908 | -------- | -------- | -------- | -------- | 3909 | localInterface | IRemoteBroker | 是 | 将与描述符绑定的IRemoteBroker对象。 | 3910 | descriptor | string | 是 | 用于与IRemoteBroker对象绑定的描述符。 | 3911 3912 3913**示例：** 3914 3915 ``` 3916 class MyDeathRecipient { 3917 onRemoteDied() { 3918 console.log("server died"); 3919 } 3920 } 3921 class TestRemoteObject extends rpc.RemoteObject { 3922 constructor(descriptor) { 3923 super(descriptor); 3924 this.attachLocalInterface(this, descriptor); 3925 } 3926 addDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 3927 return true; 3928 } 3929 removeDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 3930 return true; 3931 } 3932 isObjectDead(): boolean { 3933 return false; 3934 } 3935 asObject(): rpc.IRemoteObject { 3936 return this; 3937 } 3938 } 3939 let testRemoteObject = new TestRemoteObject("testObject"); 3940 ``` 3941 3942 3943## Ashmem<sup>8+</sup> 3944 3945提供与匿名共享内存对象相关的方法，包括创建、关闭、映射和取消映射Ashmem、从Ashmem读取数据和写入数据、获取Ashmem大小、设置Ashmem保护。 3946 3947映射内存保护类型： 3948 3949**系统能力**：以下各项对应的系统能力均为SystemCapability.Communication.IPC.Core。 3950 3951 | 参数名 | 值 | 说明 | 3952| -------- | -------- | -------- | 3953| PROT_EXEC | 4 | 映射的内存可执行 | 3954| PROT_NONE | 0 | 映射的内存不可访问 | 3955| PROT_READ | 1 | 映射的内存可读 | 3956| PROT_WRITE | 2 | 映射的内存可写 | 3957 3958 3959### createAshmem<sup>8+</sup> 3960 3961static createAshmem(name: string, size: number): Ashmem 3962 3963根据指定的名称和大小创建Ashmem对象。 3964 3965**系统能力**：SystemCapability.Communication.IPC.Core 3966 3967**参数：** 3968 | 参数名 | 类型 | 必填 | 说明 | 3969 | -------- | -------- | -------- | -------- | 3970 | name | string | 是 | 名称，用于查询Ashmem信息。 | 3971 | size | number | 是 | Ashmem的大小，以字节为单位。 | 3972 3973**返回值：** 3974 | 类型 | 说明 | 3975 | -------- | -------- | 3976 | Ashmem | 返回创建的Ashmem对象；如果创建失败，返回null。 | 3977 3978 3979**示例：** 3980 3981 ``` 3982 let ashmem = rpc.Ashmem.createAshmem("ashmem", 1024*1024); 3983 let size = ashmem.getAshmemSize(); 3984 console.log("RpcTest: get ashemm by createAshmem : " + ashmem + " size is : " + size); 3985 ``` 3986 3987 3988### createAshmemFromExisting<sup>8+</sup> 3989 3990static createAshmemFromExisting(ashmem: Ashmem): Ashmem 3991 3992通过复制现有Ashmem对象的文件描述符(fd)来创建Ashmem对象。两个Ashmem对象指向同一个共享内存区域。 3993 3994**系统能力**：SystemCapability.Communication.IPC.Core 3995 3996**参数：** 3997 | 参数名 | 类型 | 必填 | 说明 | 3998 | -------- | -------- | -------- | -------- | 3999 | ashmem | Ashmem | 是 | 已存在的Ashmem对象。 | 4000 4001**返回值：** 4002 | 类型 | 说明 | 4003 | -------- | -------- | 4004 | Ashmem | 返回创建的Ashmem对象。 | 4005 4006 4007**示例：** 4008 4009 ``` 4010 let ashmem = rpc.Ashmem.createAshmem("ashmem", 1024*1024); 4011 let ashmem2 = rpc.Ashmem.createAshmemFromExisting(ashmem); 4012 let size = ashmem2.getAshmemSize(); 4013 console.log("RpcTest: get ashemm by createAshmemFromExisting : " + ashmem2 + " size is : " + size); 4014 ``` 4015 4016 4017### closeAshmem<sup>8+</sup> 4018 4019closeAshmem(): void 4020 4021关闭这个Ashmem。 4022 4023**系统能力**：SystemCapability.Communication.IPC.Core 4024 4025**示例：** 4026 4027 ``` 4028 let ashmem = rpc.Ashmem.createAshmem("ashmem", 1024*1024); 4029 ashmem.closeAshmem(); 4030 ``` 4031 4032 4033### unmapAshmem<sup>8+</sup> 4034 4035unmapAshmem(): void 4036 4037删除该Ashmem对象的地址映射。 4038 4039**系统能力**：SystemCapability.Communication.IPC.Core 4040 4041**示例：** 4042 4043 ``` 4044 let ashmem = rpc.Ashmem.createAshmem("ashmem", 1024*1024); 4045 ashmem.unmapAshmem(); 4046 ``` 4047 4048 4049### getAshmemSize<sup>8+</sup> 4050 4051getAshmemSize(): number 4052 4053获取Ashmem对象的内存大小。 4054 4055**系统能力**：SystemCapability.Communication.IPC.Core 4056 4057**返回值：** 4058 | 类型 | 说明 | 4059 | -------- | -------- | 4060 | number | 返回Ashmem对象的内存大小。 | 4061 4062**示例：** 4063 4064 ``` 4065 let ashmem = rpc.Ashmem.createAshmem("ashmem", 1024*1024); 4066 let size = ashmem.getAshmemSize(); 4067 console.log("RpcTest: get ashmem is " + ashmem + " size is : " + size); 4068 ``` 4069 4070 4071### mapAshmem<sup>8+</sup> 4072 4073mapAshmem(mapType: number): boolean 4074 4075在此进程的虚拟地址空间上创建共享文件映射，映射区域大小由此Ashmem对象指定。 4076 4077**系统能力**：SystemCapability.Communication.IPC.Core 4078 4079**参数：** 4080 | 参数名 | 类型 | 必填 | 说明 | 4081 | -------- | -------- | -------- | -------- | 4082 | mapType | number | 是 | 指定映射的内存区域的保护等级。 | 4083 4084**返回值：** 4085 | 类型 | 说明 | 4086 | -------- | -------- | 4087 | boolean | 如果映射成功，则返回true；否则返回false。 | 4088 4089**示例：** 4090 4091 ``` 4092 let ashmem = rpc.Ashmem.createAshmem("ashmem", 1024*1024); 4093 let mapReadAndWrite = ashmem.mapAshmem(ashmem.PROT_READ | ashmem.PROT_WRITE); 4094 console.log("RpcTest: map ashmem result is : " + mapReadAndWrite); 4095 ``` 4096 4097 4098### mapReadAndWriteAshmem<sup>8+</sup> 4099 4100mapReadAndWriteAshmem(): boolean 4101 4102在此进程虚拟地址空间上创建可读写的共享文件映射。 4103 4104**系统能力**：SystemCapability.Communication.IPC.Core 4105 4106**返回值：** 4107 | 类型 | 说明 | 4108 | -------- | -------- | 4109 | boolean | 如果映射成功，则返回true；否则返回false。 | 4110 4111**示例：** 4112 4113 ``` 4114 let ashmem = rpc.Ashmem.createAshmem("ashmem", 1024*1024); 4115 let mapResult = ashmem.mapReadAndWriteAshmem(); 4116 console.log("RpcTest: map ashmem result is : " + mapResult); 4117 ``` 4118 4119 4120### mapReadOnlyAshmem<sup>8+</sup> 4121 4122mapReadOnlyAshmem(): boolean 4123 4124在此进程虚拟地址空间上创建只读的共享文件映射。 4125 4126**系统能力**：SystemCapability.Communication.IPC.Core 4127 4128**返回值：** 4129 | 类型 | 说明 | 4130 | -------- | -------- | 4131 | boolean | 如果映射成功，则返回true；否则返回false。 | 4132 4133**示例：** 4134 4135 ``` 4136 let ashmem = rpc.Ashmem.createAshmem("ashmem", 1024*1024); 4137 let mapResult = ashmem.mapReadOnlyAshmem(); 4138 console.log("RpcTest: Ashmem mapReadOnlyAshmem result is : " + mapResult); 4139 ``` 4140 4141 4142### setProtection<sup>8+</sup> 4143 4144setProtection(protectionType: number): boolean 4145 4146设置映射内存区域的保护等级。 4147 4148**系统能力**：SystemCapability.Communication.IPC.Core 4149 4150**参数：** 4151 | 参数名 | 类型 | 必填 | 说明 | 4152 | -------- | -------- | -------- | -------- | 4153 | protectionType | number | 是 | 要设置的保护类型。 | 4154 4155**返回值：** 4156 | 类型 | 说明 | 4157 | -------- | -------- | 4158 | boolean | 如果设置成功，则返回true；否则返回false。 | 4159 4160**示例：** 4161 4162 ``` 4163 let ashmem = rpc.Ashmem.createAshmem("ashmem", 1024*1024); 4164 let result = ashmem.setProtection(ashmem.PROT_READ); 4165 console.log("RpcTest: Ashmem setProtection result is : " + result); 4166 ``` 4167 4168 4169### writeToAshmem<sup>8+</sup> 4170 4171writeToAshmem(buf: number[], size: number, offset: number): boolean 4172 4173将数据写入此Ashmem对象关联的共享文件。 4174 4175**系统能力**：SystemCapability.Communication.IPC.Core 4176 4177**参数：** 4178 | 参数名 | 类型 | 必填 | 说明 | 4179 | -------- | -------- | -------- | -------- | 4180 | buf | number[] | 是 | 写入Ashmem对象的数据。 | 4181 | size | number | 是 | 要写入的数据大小。 | 4182 | offset | number | 是 | 要写入的数据在此Ashmem对象关联的内存区间的起始位置 | 4183 4184**返回值：** 4185 | 类型 | 说明 | 4186 | -------- | -------- | 4187 | boolean | 如果数据写入成功，则返回true；在其他情况下，如数据写入越界或未获得写入权限，则返回false。 | 4188 4189**示例：** 4190 4191 ``` 4192 let ashmem = rpc.Ashmem.createAshmem("ashmem", 1024*1024); 4193 let mapResult = ashmem.mapReadAndWriteAshmem(); 4194 console.info("RpcTest map ashmem result is " + mapResult); 4195 var ByteArrayVar = [1, 2, 3, 4, 5]; 4196 let writeResult = ashmem.writeToAshmem(ByteArrayVar, 5, 0); 4197 console.log("RpcTest: write to Ashmem result is : " + writeResult); 4198 ``` 4199 4200 4201### readFromAshmem<sup>8+</sup> 4202 4203readFromAshmem(size: number, offset: number): number[] 4204 4205从此Ashmem对象关联的共享文件中读取数据。 4206 4207**系统能力**：SystemCapability.Communication.IPC.Core 4208 4209**参数：** 4210 | 参数名 | 类型 | 必填 | 说明 | 4211 | -------- | -------- | -------- | -------- | 4212 | size | number | 是 | 要读取的数据的大小。 | 4213 | offset | number | 是 | 要读取的数据在此Ashmem对象关联的内存区间的起始位置 | 4214 4215**返回值：** 4216 | 类型 | 说明 | 4217 | -------- | -------- | 4218 | number[] | 返回读取的数据。 | 4219 4220 4221**示例：** 4222 4223 ``` 4224 let ashmem = rpc.Ashmem.createAshmem("ashmem", 1024*1024); 4225 let mapResult = ashmem.mapReadAndWriteAshmem(); 4226 console.info("RpcTest map ashmem result is " + mapResult); 4227 var ByteArrayVar = [1, 2, 3, 4, 5]; 4228 let writeResult = ashmem.writeToAshmem(ByteArrayVar, 5, 0); 4229 console.log("RpcTest: write to Ashmem result is : " + writeResult); 4230 let readResult = ashmem.readFromAshmem(5, 0); 4231 console.log("RpcTest: read to Ashmem result is : " + readResult); 4232 ``` 4233
