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