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### closeFileDescriptor<sup>9+</sup> 2721 2722static closeFileDescriptor(fd: number): void 2723 2724静态方法，关闭给定的文件描述符。 2725 2726**系统能力**：SystemCapability.Communication.IPC.Core 2727 2728**参数：** 2729 2730 | 参数名 | 类型 | 必填 | 说明 | 2731 | ------ | ------ | ---- | -------------------- | 2732 | fd | number | 是 | 要关闭的文件描述符。 | 2733 2734**示例：** 2735 2736 ```ts 2737 import fs from '@ohos.file.fs'; 2738 let filePath = "path/to/file"; 2739 let file = fs.openSync(filePath, fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE); 2740 try { 2741 rpc.MessageSequence.closeFileDescriptor(file.fd); 2742 } catch(error) { 2743 console.info("rpc close file descriptor fail, errorCode " + error.code); 2744 console.info("rpc close file descriptor fail, errorMessage" + error.message); 2745 } 2746 ``` 2747 2748### dupFileDescriptor 2749 2750static dupFileDescriptor(fd: number) :number 2751 2752静态方法，复制给定的文件描述符。 2753 2754**系统能力**：SystemCapability.Communication.IPC.Core 2755 2756**参数：** 2757 2758 | 参数名 | 类型 | 必填 | 说明 | 2759 | ------ | ------ | ---- | ------------------------ | 2760 | fd | number | 是 | 表示已存在的文件描述符。 | 2761 2762**返回值：** 2763 2764 | 类型 | 说明 | 2765 | ------ | -------------------- | 2766 | number | 返回新的文件描述符。 | 2767 2768**错误码：** 2769 2770以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 2771 2772 | 错误码ID | 错误信息 | 2773 | -------- | -------- | 2774 | 1900013 | call os dup function failed | 2775 2776**示例：** 2777 2778 ```ts 2779 import fs from '@ohos.file.fs'; 2780 let filePath = "path/to/file"; 2781 let file = fs.openSync(filePath, fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE); 2782 try { 2783 let newFd = rpc.MessageSequence.dupFileDescriptor(file.fd); 2784 } catch(error) { 2785 console.info("rpc dup file descriptor fail, errorCode " + error.code); 2786 console.info("rpc dup file descriptor fail, errorMessage" + error.message); 2787 } 2788 ``` 2789 2790### containFileDescriptors 2791 2792containFileDescriptors(): boolean 2793 2794检查此MessageSequence对象是否包含文件描述符。 2795 2796**系统能力**：SystemCapability.Communication.IPC.Core 2797 2798**返回值：** 2799 2800 | 类型 | 说明 | 2801 | ------- | -------------------------------------------------------------------- | 2802 | boolean | true：包含文件描述符，false：不包含文件描述符。| 2803 2804**示例：** 2805 2806 ```ts 2807 import fs from '@ohos.file.fs'; 2808 let sequence = new rpc.MessageSequence(); 2809 let filePath = "path/to/file"; 2810 let r1 = sequence.containFileDescriptors(); 2811 let file = fs.openSync(filePath, fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE); 2812 try { 2813 sequence.writeFileDescriptor(file.fd); 2814 } catch(error) { 2815 console.info("rpc write file descriptor fail, errorCode " + error.code); 2816 console.info("rpc write file descriptor fail, errorMessage" + error.message); 2817 } 2818 try { 2819 let containFD = sequence.containFileDescriptors(); 2820 console.log("RpcTest: sequence after write fd containFd result is : " + containFD); 2821 } catch(error) { 2822 console.info("rpc contain file descriptor fail, errorCode " + error.code); 2823 console.info("rpc contain file descriptor fail, errorMessage" + error.message); 2824 } 2825 ``` 2826 2827### writeFileDescriptor 2828 2829writeFileDescriptor(fd: number): void 2830 2831写入文件描述符到MessageSequence。 2832 2833**系统能力**：SystemCapability.Communication.IPC.Core 2834 2835**参数：** 2836 2837 | 参数名 | 类型 | 必填 | 说明 | 2838 | ------ | ------ | ---- | ------------ | 2839 | fd | number | 是 | 文件描述符。 | 2840 2841**错误码：** 2842 2843以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 2844 2845 | 错误码ID | 错误信息 | 2846 | -------- | -------- | 2847 | 1900009 | write data to message sequence failed | 2848 2849**示例：** 2850 2851 ```ts 2852 import fs from '@ohos.file.fs'; 2853 let sequence = new rpc.MessageSequence(); 2854 let filePath = "path/to/file"; 2855 let file = fs.openSync(filePath, fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE); 2856 try { 2857 sequence.writeFileDescriptor(file.fd); 2858 } catch(error) { 2859 console.info("rpc write file descriptor fail, errorCode " + error.code); 2860 console.info("rpc write file descriptor fail, errorMessage" + error.message); 2861 } 2862 ``` 2863 2864### readFileDescriptor 2865 2866readFileDescriptor(): number 2867 2868从MessageSequence中读取文件描述符。 2869 2870**系统能力**：SystemCapability.Communication.IPC.Core 2871 2872**返回值：** 2873 2874 | 类型 | 说明 | 2875 | ------ | ---------------- | 2876 | number | 返回文件描述符。 | 2877 2878**错误码：** 2879 2880以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 2881 2882 | 错误码ID | 错误信息 | 2883 | -------- | -------- | 2884 | 1900010 | read data from message sequence failed | 2885 2886**示例：** 2887 2888 ```ts 2889 import fs from '@ohos.file.fs'; 2890 let sequence = new rpc.MessageSequence(); 2891 let filePath = "path/to/file"; 2892 let file = fs.openSync(filePath, fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE); 2893 try { 2894 sequence.writeFileDescriptor(file.fd); 2895 } catch(error) { 2896 console.info("rpc write file descriptor fail, errorCode " + error.code); 2897 console.info("rpc write file descriptor fail, errorMessage" + error.message); 2898 } 2899 try { 2900 let readFD = sequence.readFileDescriptor(); 2901 } catch(error) { 2902 console.info("rpc read file descriptor fail, errorCode " + error.code); 2903 console.info("rpc read file descriptor fail, errorMessage" + error.message); 2904 } 2905 ``` 2906 2907### writeAshmem 2908 2909writeAshmem(ashmem: Ashmem): void 2910 2911将指定的匿名共享对象写入此MessageSequence。 2912 2913**系统能力**：SystemCapability.Communication.IPC.Core 2914 2915**参数：** 2916 2917 | 参数名 | 类型 | 必填 | 说明 | 2918 | ------ | ------ | ---- | ------------------------------------- | 2919 | ashmem | Ashmem | 是 | 要写入MessageSequence的匿名共享对象。 | 2920 2921**错误码：** 2922 2923以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 2924 2925 | 错误码ID | 错误信息 | 2926 | -------- | ------- | 2927 | 1900003 | write to ashmem failed | 2928 2929**示例：** 2930 2931 ```ts 2932 let sequence = new rpc.MessageSequence(); 2933 let ashmem; 2934 try { 2935 ashmem = rpc.Ashmem.create("ashmem", 1024); 2936 } catch(error) { 2937 console.info("rpc create ashmem fail, errorCode " + error.code); 2938 console.info("rpc creat ashmem fail, errorMessage" + error.message); 2939 } 2940 try { 2941 sequence.writeAshmem(ashmem); 2942 } catch(error) { 2943 console.info("rpc write ashmem fail, errorCode " + error.code); 2944 console.info("rpc write ashmem fail, errorMessage" + error.message); 2945 } 2946 ``` 2947 2948### readAshmem 2949 2950readAshmem(): Ashmem 2951 2952从MessageSequence读取匿名共享对象。 2953 2954**系统能力**：SystemCapability.Communication.IPC.Core 2955 2956**返回值：** 2957 2958 | 类型 | 说明 | 2959 | ------ | ------------------ | 2960 | Ashmem | 返回匿名共享对象。 | 2961 2962**错误码：** 2963 2964以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 2965 2966 | 错误码ID | 错误信息 | 2967 | -------- | -------- | 2968 | 1900004 | read from ashmem failed | 2969 2970**示例：** 2971 2972 ```ts 2973 let sequence = new rpc.MessageSequence(); 2974 let ashmem; 2975 try { 2976 ashmem = rpc.Ashmem.create("ashmem", 1024); 2977 } catch(error) { 2978 console.info("rpc create ashmem fail, errorCode " + error.code); 2979 console.info("rpc creat ashmem fail, errorMessage" + error.message); 2980 } 2981 try { 2982 sequence.writeAshmem(ashmem); 2983 } catch(error) { 2984 console.info("rpc write ashmem fail, errorCode " + error.code); 2985 console.info("rpc write ashmem fail, errorMessage" + error.message); 2986 } 2987 try { 2988 let readAshmem = sequence.readAshmem(); 2989 console.log("RpcTest: read ashmem to result is : " + readAshmem); 2990 } catch(error) { 2991 console.info("rpc read ashmem fail, errorCode " + error.code); 2992 console.info("rpc read ashmem fail, errorMessage" + error.message); 2993 } 2994 ``` 2995 2996### getRawDataCapacity 2997 2998getRawDataCapacity(): number 2999 3000获取MessageSequence可以容纳的最大原始数据量。 3001 3002**系统能力**：SystemCapability.Communication.IPC.Core 3003 3004**返回值：** 3005 3006 | 类型 | 说明 | 3007 | ------ | ------------------------------------------------------------ | 3008 | number | 返回MessageSequence可以容纳的最大原始数据量，即128 Mb。 | 3009 3010**示例：** 3011 3012 ```ts 3013 let sequence = new rpc.MessageSequence(); 3014 let result = sequence.getRawDataCapacity(); 3015 console.log("RpcTest: sequence get RawDataCapacity result is : " + result); 3016 ``` 3017 3018### writeRawData 3019 3020writeRawData(rawData: number[], size: number): void 3021 3022将原始数据写入MessageSequence对象。 3023 3024**系统能力**：SystemCapability.Communication.IPC.Core 3025 3026**参数：** 3027 3028 | 参数名 | 类型 | 必填 | 说明 | 3029 | ------- | -------- | ---- | ---------------------------------- | 3030 | rawData | number[] | 是 | 要写入的原始数据。 | 3031 | size | number | 是 | 发送的原始数据大小，以字节为单位。 | 3032 3033**错误码：** 3034 3035以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 3036 3037 | 错误码ID | 错误信息 | 3038 | -------- | -------- | 3039 | 1900009 | write data to message sequence failed | 3040 3041**示例：** 3042 3043 ```ts 3044 let sequence = new rpc.MessageSequence(); 3045 let arr = [1, 2, 3, 4, 5]; 3046 try { 3047 sequence.writeRawData(arr, arr.length); 3048 } catch(error) { 3049 console.info("rpc write rawdata fail, errorCode " + error.code); 3050 console.info("rpc write rawdata fail, errorMessage" + error.message); 3051 } 3052 ``` 3053 3054### readRawData 3055 3056readRawData(size: number): number[] 3057 3058从MessageSequence读取原始数据。 3059 3060**系统能力**：SystemCapability.Communication.IPC.Core 3061 3062**参数：** 3063 3064 | 参数名 | 类型 | 必填 | 说明 | 3065 | ------ | ------ | ---- | ------------------------ | 3066 | size | number | 是 | 要读取的原始数据的大小。 | 3067 3068**返回值：** 3069 3070 | 类型 | 说明 | 3071 | -------- | ------------------------------ | 3072 | number[] | 返回原始数据（以字节为单位）。 | 3073 3074**错误码：** 3075 3076以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 3077 3078 | 错误码ID | 错误信息 | 3079 | -------- | -------- | 3080 | 1900010 | read data from message sequence failed | 3081 3082**示例：** 3083 3084 ```ts 3085 let sequence = new rpc.MessageSequence(); 3086 let arr = [1, 2, 3, 4, 5]; 3087 try { 3088 sequence.writeRawData(arr, arr.length); 3089 } catch(error) { 3090 console.info("rpc write rawdata fail, errorCode " + error.code); 3091 console.info("rpc write rawdata fail, errorMessage" + error.message); 3092 } 3093 try { 3094 let result = sequence.readRawData(5); 3095 console.log("RpcTest: sequence read raw data result is : " + result); 3096 } catch(error) { 3097 console.info("rpc read rawdata fail, errorCode " + error.code); 3098 console.info("rpc read rawdata fail, errorMessage" + error.message); 3099 } 3100 ``` 3101 3102## MessageParcel<sup>(deprecated)</sup> 3103 3104>从API version 9 开始不再维护，建议使用[MessageSequence](#messagesequence9)类替代。 3105 3106在RPC过程中，发送方可以使用MessageParcel提供的写方法，将待发送的数据以特定格式写入该对象。接收方可以使用MessageParcel提供的读方法从该对象中读取特定格式的数据。数据格式包括：基础类型及数组、IPC对象、接口描述符和自定义序列化对象。 3107 3108### create 3109 3110static create(): MessageParcel 3111 3112静态方法，创建MessageParcel对象。 3113 3114**系统能力**：SystemCapability.Communication.IPC.Core 3115 3116**返回值：** 3117 3118 | 类型 | 说明 | 3119 | ------------- | ----------------------------- | 3120 | MessageParcel | 返回创建的MessageParcel对象。 | 3121 3122**示例：** 3123 3124 ```ts 3125 let data = rpc.MessageParcel.create(); 3126 console.log("RpcClient: data is " + data); 3127 ``` 3128 3129### reclaim 3130 3131reclaim(): void 3132 3133释放不再使用的MessageParcel对象。 3134 3135**系统能力**：SystemCapability.Communication.IPC.Core 3136 3137**示例：** 3138 3139 ```ts 3140 let reply = rpc.MessageParcel.create(); 3141 reply.reclaim(); 3142 ``` 3143 3144### writeRemoteObject 3145 3146writeRemoteObject(object: [IRemoteObject](#iremoteobject)): boolean 3147 3148序列化远程对象并将其写入MessageParcel对象。 3149 3150**系统能力**：SystemCapability.Communication.IPC.Core 3151 3152**参数：** 3153 3154 | 参数名 | 类型 | 必填 | 说明 | 3155 | ------ | ------------------------------- | ---- | --------------------------------------- | 3156 | object | [IRemoteObject](#iremoteobject) | 是 | 要序列化并写入MessageParcel的远程对象。 | 3157 3158**返回值：** 3159 3160 | 类型 | 说明 | 3161 | ------- | ----------------------------------------- | 3162 | boolean | true：操作成功，false：操作失败。| 3163 3164**示例：** 3165 3166 ```ts 3167 class MyDeathRecipient { 3168 onRemoteDied() { 3169 console.log("server died"); 3170 } 3171 } 3172 class TestRemoteObject extends rpc.RemoteObject { 3173 constructor(descriptor) { 3174 super(descriptor); 3175 } 3176 addDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 3177 return true; 3178 } 3179 removeDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 3180 return true; 3181 } 3182 isObjectDead(): boolean { 3183 return false; 3184 } 3185 } 3186 let data = rpc.MessageParcel.create(); 3187 let testRemoteObject = new TestRemoteObject("testObject"); 3188 data.writeRemoteObject(testRemoteObject); 3189 ``` 3190 3191### readRemoteObject 3192 3193readRemoteObject(): IRemoteObject 3194 3195从MessageParcel读取远程对象。此方法用于反序列化MessageParcel对象以生成IRemoteObject。远程对象按写入MessageParcel的顺序读取。 3196 3197**系统能力**：SystemCapability.Communication.IPC.Core 3198 3199**返回值：** 3200 3201 | 类型 | 说明 | 3202 | ------------------------------- | ------------------ | 3203 | [IRemoteObject](#iremoteobject) | 读取到的远程对象。 | 3204 3205**示例：** 3206 3207 ```ts 3208 class MyDeathRecipient { 3209 onRemoteDied() { 3210 console.log("server died"); 3211 } 3212 } 3213 class TestRemoteObject extends rpc.RemoteObject { 3214 constructor(descriptor) { 3215 super(descriptor); 3216 } 3217 addDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 3218 return true; 3219 } 3220 removeDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 3221 return true; 3222 } 3223 isObjectDead(): boolean { 3224 return false; 3225 } 3226 } 3227 let data = rpc.MessageParcel.create(); 3228 let testRemoteObject = new TestRemoteObject("testObject"); 3229 data.writeRemoteObject(testRemoteObject); 3230 let proxy = data.readRemoteObject(); 3231 ``` 3232 3233### writeInterfaceToken 3234 3235writeInterfaceToken(token: string): boolean 3236 3237将接口描述符写入MessageParcel对象，远端对象可使用该信息校验本次通信。 3238 3239**系统能力**：SystemCapability.Communication.IPC.Core 3240 3241**参数：** 3242 3243 | 参数名 | 类型 | 必填 | 说明 | 3244 | ------ | ------ | ---- | ------------------ | 3245 | token | string | 是 | 字符串类型描述符。 | 3246 3247**返回值：** 3248 3249 | 类型 | 说明 | 3250 | ------- | ----------------------------------------- | 3251 | boolean | true：操作成功，false：操作失败。| 3252 3253**示例：** 3254 3255 ```ts 3256 let data = rpc.MessageParcel.create(); 3257 let result = data.writeInterfaceToken("aaa"); 3258 console.log("RpcServer: writeInterfaceToken is " + result); 3259 ``` 3260 3261### readInterfaceToken 3262 3263readInterfaceToken(): string 3264 3265从MessageParcel中读取接口描述符，接口描述符按写入MessageParcel的顺序读取，本地对象可使用该信息检验本次通信。 3266 3267**系统能力**：SystemCapability.Communication.IPC.Core 3268 3269**返回值：** 3270 3271 | 类型 | 说明 | 3272 | ------ | ------------------------ | 3273 | string | 返回读取到的接口描述符。 | 3274 3275**示例：** 3276 3277 ```ts 3278 class Stub extends rpc.RemoteObject { 3279 onRemoteMessageRequest(code, data, reply, option) { 3280 let interfaceToken = data.readInterfaceToken(); 3281 console.log("RpcServer: interfaceToken is " + interfaceToken); 3282 return true; 3283 } 3284 } 3285 ``` 3286 3287### getSize 3288 3289getSize(): number 3290 3291获取当前MessageParcel的数据大小。 3292 3293**系统能力**：SystemCapability.Communication.IPC.Core 3294 3295**返回值：** 3296 3297 | 类型 | 说明 | 3298 | ------ | --------------------------------------------- | 3299 | number | 获取的MessageParcel的数据大小。以字节为单位。 | 3300 3301**示例：** 3302 3303 ```ts 3304 let data = rpc.MessageParcel.create(); 3305 let size = data.getSize(); 3306 console.log("RpcClient: size is " + size); 3307 ``` 3308 3309### getCapacity 3310 3311getCapacity(): number 3312 3313获取当前MessageParcel的容量。 3314 3315**系统能力**：SystemCapability.Communication.IPC.Core 3316 3317**返回值：** 3318 3319 | 类型 | 说明 | 3320 | ------ | --------------------------------------------- | 3321 | number | 获取的MessageParcel的容量大小。以字节为单位。 | 3322 3323**示例：** 3324 3325 ```ts 3326 let data = rpc.MessageParcel.create(); 3327 let result = data.getCapacity(); 3328 console.log("RpcClient: capacity is " + result); 3329 ``` 3330 3331### setSize 3332 3333setSize(size: number): boolean 3334 3335设置MessageParcel实例中包含的数据大小。 3336 3337**系统能力**：SystemCapability.Communication.IPC.Core 3338 3339**参数：** 3340 3341 | 参数名 | 类型 | 必填 | 说明 | 3342 | ------ | ------ | ---- | ------------------------------------------- | 3343 | size | number | 是 | MessageParcel实例的数据大小。以字节为单位。 | 3344 3345**返回值：** 3346 3347 | 类型 | 说明 | 3348 | ------- | --------------------------------- | 3349 | boolean | true：设置成功，false：设置失败。| 3350 3351**示例：** 3352 3353 ```ts 3354 let data = rpc.MessageParcel.create(); 3355 let setSize = data.setSize(16); 3356 console.log("RpcClient: setSize is " + setSize); 3357 ``` 3358 3359### setCapacity 3360 3361setCapacity(size: number): boolean 3362 3363设置MessageParcel实例的存储容量。 3364 3365**系统能力**：SystemCapability.Communication.IPC.Core 3366 3367**参数：** 3368 3369 | 参数名 | 类型 | 必填 | 说明 | 3370 | ------ | ------ | ---- | ------------------------------------------- | 3371 | size | number | 是 | MessageParcel实例的存储容量。以字节为单位。 | 3372 3373**返回值：** 3374 3375 | 类型 | 说明 | 3376 | ------- | --------------------------------- | 3377 | boolean | true：设置成功，false：设置失败。| 3378 3379**示例：** 3380 3381 ```ts 3382 let data = rpc.MessageParcel.create(); 3383 let result = data.setCapacity(100); 3384 console.log("RpcClient: setCapacity is " + result); 3385 ``` 3386 3387### getWritableBytes 3388 3389getWritableBytes(): number 3390 3391获取MessageParcel的可写字节空间。 3392 3393**系统能力**：SystemCapability.Communication.IPC.Core 3394 3395**返回值：** 3396 3397 | 类型 | 说明 | 3398 | ------ | --------------------------------------------------- | 3399 | number | 获取到的MessageParcel的可写字节空间。以字节为单位。 | 3400 3401**示例：** 3402 3403 ```ts 3404 class Stub extends rpc.RemoteObject { 3405 onRemoteMessageRequest(code, data, reply, option) { 3406 let getWritableBytes = data.getWritableBytes(); 3407 console.log("RpcServer: getWritableBytes is " + getWritableBytes); 3408 return true; 3409 } 3410 } 3411 ``` 3412 3413### getReadableBytes 3414 3415getReadableBytes(): number 3416 3417获取MessageParcel的可读字节空间。 3418 3419**系统能力**：SystemCapability.Communication.IPC.Core 3420 3421**返回值：** 3422 3423 | 类型 | 说明 | 3424 | ------ | --------------------------------------------------- | 3425 | number | 获取到的MessageParcel的可读字节空间。以字节为单位。 | 3426 3427**示例：** 3428 3429 ```ts 3430 class Stub extends rpc.RemoteObject { 3431 onRemoteRequest(code, data, reply, option) { 3432 let result = data.getReadableBytes(); 3433 console.log("RpcServer: getReadableBytes is " + result); 3434 return true; 3435 } 3436 } 3437 ``` 3438 3439### getReadPosition 3440 3441getReadPosition(): number 3442 3443获取MessageParcel的读位置。 3444 3445**系统能力**：SystemCapability.Communication.IPC.Core 3446 3447**返回值：** 3448 3449 | 类型 | 说明 | 3450 | ------ | --------------------------------------- | 3451 | number | 返回MessageParcel实例中的当前读取位置。 | 3452 3453**示例：** 3454 3455 ```ts 3456 let data = rpc.MessageParcel.create(); 3457 let readPos = data.getReadPosition(); 3458 console.log("RpcClient: readPos is " + readPos); 3459 ``` 3460 3461### getWritePosition 3462 3463getWritePosition(): number 3464 3465获取MessageParcel的写位置。 3466 3467**系统能力**：SystemCapability.Communication.IPC.Core 3468 3469**返回值：** 3470 3471 | 类型 | 说明 | 3472 | ------ | --------------------------------------- | 3473 | number | 返回MessageParcel实例中的当前写入位置。 | 3474 3475**示例：** 3476 3477 ```ts 3478 let data = rpc.MessageParcel.create(); 3479 data.writeInt(10); 3480 let bwPos = data.getWritePosition(); 3481 console.log("RpcClient: bwPos is " + bwPos); 3482 ``` 3483 3484### rewindRead 3485 3486rewindRead(pos: number): boolean 3487 3488重新偏移读取位置到指定的位置。 3489 3490**系统能力**：SystemCapability.Communication.IPC.Core 3491 3492**参数：** 3493 3494 | 参数名 | 类型 | 必填 | 说明 | 3495 | ------ | ------ | ---- | ------------------------ | 3496 | pos | number | 是 | 开始读取数据的目标位置。 | 3497 3498**返回值：** 3499 3500 | 类型 | 说明 | 3501 | ------- | ------------------------------------------------- | 3502 | boolean | true：读取位置发生更改，false：读取位置未发生更改。| 3503 3504**示例：** 3505 3506 ```ts 3507 let data = rpc.MessageParcel.create(); 3508 data.writeInt(12); 3509 data.writeString("parcel"); 3510 let number = data.readInt(); 3511 console.log("RpcClient: number is " + number); 3512 data.rewindRead(0); 3513 let number2 = data.readInt(); 3514 console.log("RpcClient: rewindRead is " + number2); 3515 ``` 3516 3517### rewindWrite 3518 3519rewindWrite(pos: number): boolean 3520 3521重新偏移写位置到指定的位置。 3522 3523**系统能力**：SystemCapability.Communication.IPC.Core 3524 3525**参数：** 3526 3527 | 参数名 | 类型 | 必填 | 说明 | 3528 | ------ | ------ | ---- | ------------------------ | 3529 | pos | number | 是 | 开始写入数据的目标位置。 | 3530 3531**返回值：** 3532 3533 | 类型 | 说明 | 3534 | ------- | --------------------------------------------- | 3535 | boolean | true：写入位置发生更改，false：写入位置未发生更改。| 3536 3537**示例：** 3538 3539 ```ts 3540 let data = rpc.MessageParcel.create(); 3541 data.writeInt(4); 3542 data.rewindWrite(0); 3543 data.writeInt(5); 3544 let number = data.readInt(); 3545 console.log("RpcClient: rewindWrite is: " + number); 3546 ``` 3547 3548### writeByte 3549 3550writeByte(val: number): boolean 3551 3552将字节值写入MessageParcel实例。 3553 3554**系统能力**：SystemCapability.Communication.IPC.Core 3555 3556**参数：** 3557 3558 | 参数名 | 类型 | 必填 | 说明 | 3559 | ------ | ------ | ---- | ---------------- | 3560 | val | number | 是 | 要写入的字节值。 | 3561 3562**返回值：** 3563 3564 | 类型 | 说明 | 3565 | ------- | ----------------------------- | 3566 | boolean | true：写入成功，false：写入失败。 | 3567 3568**示例：** 3569 3570 ```ts 3571 let data = rpc.MessageParcel.create(); 3572 let result = data.writeByte(2); 3573 console.log("RpcClient: writeByte is: " + result); 3574 ``` 3575 3576### readByte 3577 3578readByte(): number 3579 3580从MessageParcel实例读取字节值。 3581 3582**系统能力**：SystemCapability.Communication.IPC.Core 3583 3584**返回值：** 3585 3586 | 类型 | 说明 | 3587 | ------ | ------------ | 3588 | number | 返回字节值。 | 3589 3590**示例：** 3591 3592 ```ts 3593 let data = rpc.MessageParcel.create(); 3594 let result = data.writeByte(2); 3595 console.log("RpcClient: writeByte is: " + result); 3596 let ret = data.readByte(); 3597 console.log("RpcClient: readByte is: " + ret); 3598 ``` 3599 3600### writeShort 3601 3602writeShort(val: number): boolean 3603 3604将短整数值写入MessageParcel实例。 3605 3606**系统能力**：SystemCapability.Communication.IPC.Core 3607 3608**参数：** 3609 3610 | 参数名 | 类型 | 必填 | 说明 | 3611 | ------ | ------ | ---- | ------------------ | 3612 | val | number | 是 | 要写入的短整数值。 | 3613 3614**返回值：** 3615 3616 | 类型 | 说明 | 3617 | ------- | ----------------------------- | 3618 | boolean | true：写入成功，false：写入失败。| 3619 3620**示例：** 3621 3622 ```ts 3623 let data = rpc.MessageParcel.create(); 3624 let result = data.writeShort(8); 3625 console.log("RpcClient: writeShort is: " + result); 3626 ``` 3627 3628### readShort 3629 3630readShort(): number 3631 3632从MessageParcel实例读取短整数值。 3633 3634**系统能力**：SystemCapability.Communication.IPC.Core 3635 3636**返回值：** 3637 3638 | 类型 | 说明 | 3639 | ------ | -------------- | 3640 | number | 返回短整数值。 | 3641 3642**示例：** 3643 3644 ```ts 3645 let data = rpc.MessageParcel.create(); 3646 let result = data.writeShort(8); 3647 console.log("RpcClient: writeShort is: " + result); 3648 let ret = data.readShort(); 3649 console.log("RpcClient: readShort is: " + ret); 3650 ``` 3651 3652### writeInt 3653 3654writeInt(val: number): boolean 3655 3656将整数值写入MessageParcel实例。 3657 3658**系统能力**：SystemCapability.Communication.IPC.Core 3659 3660**参数：** 3661 3662 | 参数名 | 类型 | 必填 | 说明 | 3663 | ------ | ------ | ---- | ---------------- | 3664 | val | number | 是 | 要写入的整数值。 | 3665 3666**返回值：** 3667 3668 | 类型 | 说明 | 3669 | ------- | ----------------------------- | 3670 | boolean | true：写入成功，false：写入失败。 | 3671 3672**示例：** 3673 3674 ```ts 3675 let data = rpc.MessageParcel.create(); 3676 let result = data.writeInt(10); 3677 console.log("RpcClient: writeInt is " + result); 3678 ``` 3679 3680### readInt 3681 3682readInt(): number 3683 3684从MessageParcel实例读取整数值。 3685 3686**系统能力**：SystemCapability.Communication.IPC.Core 3687 3688**返回值：** 3689 3690 | 类型 | 说明 | 3691 | ------ | ------------ | 3692 | number | 返回整数值。 | 3693 3694**示例：** 3695 3696 ```ts 3697 let data = rpc.MessageParcel.create(); 3698 let result = data.writeInt(10); 3699 console.log("RpcClient: writeInt is " + result); 3700 let ret = data.readInt(); 3701 console.log("RpcClient: readInt is " + ret); 3702 ``` 3703 3704### writeLong 3705 3706writeLong(val: number): boolean 3707 3708将长整数值写入MessageParcel实例。 3709 3710**系统能力**：SystemCapability.Communication.IPC.Core 3711 3712**参数：** 3713 3714 | 参数名 | 类型 | 必填 | 说明 | 3715 | ------ | ------ | ---- | ---------------- | 3716 | val | number | 是 | 要写入的长整数值 | 3717 3718**返回值：** 3719 3720 | 类型 | 说明 | 3721 | ------- | --------------------------------- | 3722 | boolean | true：写入成功，false：写入失败。| 3723 3724**示例：** 3725 3726 ```ts 3727 let data = rpc.MessageParcel.create(); 3728 let result = data.writeLong(10000); 3729 console.log("RpcClient: writeLong is " + result); 3730 ``` 3731 3732### readLong 3733 3734readLong(): number 3735 3736从MessageParcel实例中读取长整数值。 3737 3738**系统能力**：SystemCapability.Communication.IPC.Core 3739 3740**返回值：** 3741 3742 | 类型 | 说明 | 3743 | ------ | -------------- | 3744 | number | 返回长整数值。 | 3745 3746**示例：** 3747 3748 ```ts 3749 let data = rpc.MessageParcel.create(); 3750 let result = data.writeLong(10000); 3751 console.log("RpcClient: writeLong is " + result); 3752 let ret = data.readLong(); 3753 console.log("RpcClient: readLong is " + ret); 3754 ``` 3755 3756### writeFloat 3757 3758writeFloat(val: number): boolean 3759 3760将浮点值写入MessageParcel实例。 3761 3762**系统能力**：SystemCapability.Communication.IPC.Core 3763 3764**参数：** 3765 3766 | 参数名 | 类型 | 必填 | 说明 | 3767 | ------ | ------ | ---- | ---------------- | 3768 | val | number | 是 | 要写入的浮点值。 | 3769 3770**返回值：** 3771 3772 | 类型 | 说明 | 3773 | ------- | --------------------------------- | 3774 | boolean | true：写入成功，false：写入失败。| 3775 3776**示例：** 3777 3778 ```ts 3779 let data = rpc.MessageParcel.create(); 3780 let result = data.writeFloat(1.2); 3781 console.log("RpcClient: writeFloat is " + result); 3782 ``` 3783 3784### readFloat 3785 3786readFloat(): number 3787 3788从MessageParcel实例中读取浮点值。 3789 3790**系统能力**：SystemCapability.Communication.IPC.Core 3791 3792**返回值：** 3793 3794 | 类型 | 说明 | 3795 | ------ | ------------ | 3796 | number | 返回浮点值。 | 3797 3798**示例：** 3799 3800 ```ts 3801 let data = rpc.MessageParcel.create(); 3802 let result = data.writeFloat(1.2); 3803 console.log("RpcClient: writeFloat is " + result); 3804 let ret = data.readFloat(); 3805 console.log("RpcClient: readFloat is " + ret); 3806 ``` 3807 3808### writeDouble 3809 3810writeDouble(val: number): boolean 3811 3812将双精度浮点值写入MessageParcel实例。 3813 3814**系统能力**：SystemCapability.Communication.IPC.Core 3815 3816**参数：** 3817 3818 | 参数名 | 类型 | 必填 | 说明 | 3819 | ------ | ------ | ---- | ---------------------- | 3820 | val | number | 是 | 要写入的双精度浮点值。 | 3821 3822**返回值：** 3823 3824 | 类型 | 说明 | 3825 | ------- | --------------------------------- | 3826 | boolean | true：写入成功，false：写入失败。| 3827 3828**示例：** 3829 3830 ```ts 3831 let data = rpc.MessageParcel.create(); 3832 let result = data.writeDouble(10.2); 3833 console.log("RpcClient: writeDouble is " + result); 3834 ``` 3835 3836### readDouble 3837 3838readDouble(): number 3839 3840从MessageParcel实例读取双精度浮点值。 3841 3842**系统能力**：SystemCapability.Communication.IPC.Core 3843 3844**返回值：** 3845 3846 | 类型 | 说明 | 3847 | ------ | ------------------ | 3848 | number | 返回双精度浮点值。 | 3849 3850**示例：** 3851 3852 ```ts 3853 let data = rpc.MessageParcel.create(); 3854 let result = data.writeDouble(10.2); 3855 console.log("RpcClient: writeDouble is " + result); 3856 let ret = data.readDouble(); 3857 console.log("RpcClient: readDouble is " + ret); 3858 ``` 3859 3860### writeBoolean 3861 3862writeBoolean(val: boolean): boolean 3863 3864将布尔值写入MessageParcel实例。 3865 3866**系统能力**：SystemCapability.Communication.IPC.Core 3867 3868**参数：** 3869 3870 | 参数名 | 类型 | 必填 | 说明 | 3871 | ------ | ------- | ---- | ---------------- | 3872 | val | boolean | 是 | 要写入的布尔值。 | 3873 3874**返回值：** 3875 3876 | 类型 | 说明 | 3877 | ------- | --------------------------------- | 3878 | boolean | true：写入成功，false：写入失败。| 3879 3880**示例：** 3881 3882 ```ts 3883 let data = rpc.MessageParcel.create(); 3884 let result = data.writeBoolean(false); 3885 console.log("RpcClient: writeBoolean is " + result); 3886 ``` 3887 3888### readBoolean 3889 3890readBoolean(): boolean 3891 3892从MessageParcel实例读取布尔值。 3893 3894**系统能力**：SystemCapability.Communication.IPC.Core 3895 3896**返回值：** 3897 3898 | 类型 | 说明 | 3899 | ------- | -------------------- | 3900 | boolean | 返回读取到的布尔值。 | 3901 3902**示例：** 3903 3904 ```ts 3905 let data = rpc.MessageParcel.create(); 3906 let result = data.writeBoolean(false); 3907 console.log("RpcClient: writeBoolean is " + result); 3908 let ret = data.readBoolean(); 3909 console.log("RpcClient: readBoolean is " + ret); 3910 ``` 3911 3912### writeChar 3913 3914writeChar(val: number): boolean 3915 3916将单个字符值写入MessageParcel实例。 3917 3918**系统能力**：SystemCapability.Communication.IPC.Core 3919 3920**参数：** 3921 3922 | 参数名 | 类型 | 必填 | 说明 | 3923 | ------ | ------ | ---- | -------------------- | 3924 | val | number | 是 | 要写入的单个字符值。 | 3925 3926**返回值：** 3927 3928 | 类型 | 说明 | 3929 | ------- | ----------------------------- | 3930 | boolean | true：写入成功，false：写入失败。| 3931 3932**示例：** 3933 3934 ```ts 3935 let data = rpc.MessageParcel.create(); 3936 let result = data.writeChar(97); 3937 console.log("RpcClient: writeChar is " + result); 3938 ``` 3939 3940### readChar 3941 3942readChar(): number 3943 3944从MessageParcel实例中读取单个字符值。 3945 3946**系统能力**：SystemCapability.Communication.IPC.Core 3947 3948**返回值：** 3949 3950 | 类型 | 说明 | 3951 | ------ | ---------------- | 3952 | number | 返回单个字符值。 | 3953 3954**示例：** 3955 3956 ```ts 3957 let data = rpc.MessageParcel.create(); 3958 let result = data.writeChar(97); 3959 console.log("RpcClient: writeChar is " + result); 3960 let ret = data.readChar(); 3961 console.log("RpcClient: readChar is " + ret); 3962 ``` 3963 3964### writeString 3965 3966writeString(val: string): boolean 3967 3968将字符串值写入MessageParcel实例。 3969 3970**系统能力**：SystemCapability.Communication.IPC.Core 3971 3972**参数：** 3973 3974 | 参数名 | 类型 | 必填 | 说明 | 3975 | ------ | ------ | ---- | ----------------------------------------- | 3976 | val | string | 是 | 要写入的字符串值，其长度应小于40960字节。 | 3977 3978**返回值：** 3979 3980 | 类型 | 说明 | 3981 | ------- | --------------------------------- | 3982 | boolean | true：写入成功，false：写入失败。| 3983 3984**示例：** 3985 3986 ```ts 3987 let data = rpc.MessageParcel.create(); 3988 let result = data.writeString('abc'); 3989 console.log("RpcClient: writeString is " + result); 3990 ``` 3991 3992### readString 3993 3994readString(): string 3995 3996从MessageParcel实例读取字符串值。 3997 3998**系统能力**：SystemCapability.Communication.IPC.Core 3999 4000**返回值：** 4001 4002 | 类型 | 说明 | 4003 | ------ | -------------- | 4004 | string | 返回字符串值。 | 4005 4006**示例：** 4007 4008 ```ts 4009 let data = rpc.MessageParcel.create(); 4010 let result = data.writeString('abc'); 4011 console.log("RpcClient: writeString is " + result); 4012 let ret = data.readString(); 4013 console.log("RpcClient: readString is " + ret); 4014 ``` 4015 4016### writeSequenceable 4017 4018writeSequenceable(val: Sequenceable): boolean 4019 4020将自定义序列化对象写入MessageParcel实例。 4021 4022**系统能力**：SystemCapability.Communication.IPC.Core 4023 4024**参数：** 4025 4026 | 参数名 | 类型 | 必填 | 说明 | 4027 | ------ | ----------------------------- | ---- | -------------------- | 4028 | val | [Sequenceable](#sequenceable) | 是 | 要写入的可序列对象。 | 4029 4030**返回值：** 4031 4032 | 类型 | 说明 | 4033 | ------- | -------------------------------- | 4034 | boolean | true：写入成功，false：写入失败。| 4035 4036**示例：** 4037 4038 ```ts 4039 class MySequenceable { 4040 num: number; 4041 str: string; 4042 constructor(num, str) { 4043 this.num = num; 4044 this.str = str; 4045 } 4046 marshalling(messageParcel) { 4047 messageParcel.writeInt(this.num); 4048 messageParcel.writeString(this.str); 4049 return true; 4050 } 4051 unmarshalling(messageParcel) { 4052 this.num = messageParcel.readInt(); 4053 this.str = messageParcel.readString(); 4054 return true; 4055 } 4056 } 4057 let sequenceable = new MySequenceable(1, "aaa"); 4058 let data = rpc.MessageParcel.create(); 4059 let result = data.writeSequenceable(sequenceable); 4060 console.log("RpcClient: writeSequenceable is " + result); 4061 ``` 4062 4063### readSequenceable 4064 4065readSequenceable(dataIn: Sequenceable): boolean 4066 4067从MessageParcel实例中读取成员变量到指定的对象（dataIn）。 4068 4069**系统能力**：SystemCapability.Communication.IPC.Core 4070 4071**参数：** 4072 4073 | 参数名 | 类型 | 必填 | 说明 | 4074 | ------ | ----------------------------- | ------- | ---------------------------------------------- | 4075 | dataIn | [Sequenceable](#sequenceabledeprecated) | 是 | 需要从MessageParcel读取成员变量的对象。 | 4076 4077**返回值：** 4078 4079 | 类型 | 说明 | 4080 | ------- | ---------------------------------------- | 4081 | boolean | true：反序列化成功，false：反序列化失败。| 4082 4083**示例：** 4084 4085 ```ts 4086 class MySequenceable { 4087 num: number; 4088 str: string; 4089 constructor(num, str) { 4090 this.num = num; 4091 this.str = str; 4092 } 4093 marshalling(messageParcel) { 4094 messageParcel.writeInt(this.num); 4095 messageParcel.writeString(this.str); 4096 return true; 4097 } 4098 unmarshalling(messageParcel) { 4099 this.num = messageParcel.readInt(); 4100 this.str = messageParcel.readString(); 4101 return true; 4102 } 4103 } 4104 let sequenceable = new MySequenceable(1, "aaa"); 4105 let data = rpc.MessageParcel.create(); 4106 let result = data.writeSequenceable(sequenceable); 4107 console.log("RpcClient: writeSequenceable is " + result); 4108 let ret = new MySequenceable(0, ""); 4109 let result2 = data.readSequenceable(ret); 4110 console.log("RpcClient: writeSequenceable is " + result2); 4111 ``` 4112 4113### writeByteArray 4114 4115writeByteArray(byteArray: number[]): boolean 4116 4117将字节数组写入MessageParcel实例。 4118 4119**系统能力**：SystemCapability.Communication.IPC.Core 4120 4121**参数：** 4122 4123 | 参数名 | 类型 | 必填 | 说明 | 4124 | --------- | -------- | ---- | ------------------ | 4125 | byteArray | number[] | 是 | 要写入的字节数组。 | 4126 4127**返回值：** 4128 4129 | 类型 | 说明 | 4130 | ------- | -------------------------------- | 4131 | boolean | true：写入成功，false：写入失败。| 4132 4133**示例：** 4134 4135 ```ts 4136 let data = rpc.MessageParcel.create(); 4137 let ByteArrayVar = [1, 2, 3, 4, 5]; 4138 let result = data.writeByteArray(ByteArrayVar); 4139 console.log("RpcClient: writeByteArray is " + result); 4140 ``` 4141 4142### readByteArray 4143 4144readByteArray(dataIn: number[]): void 4145 4146从MessageParcel实例读取字节数组。 4147 4148**系统能力**：SystemCapability.Communication.IPC.Core 4149 4150**参数：** 4151 4152 | 参数名 | 类型 | 必填 | 说明 | 4153 | ------ | -------- | ---- | ------------------ | 4154 | dataIn | number[] | 是 | 要读取的字节数组。 | 4155 4156**示例：** 4157 4158 ```ts 4159 let data = rpc.MessageParcel.create(); 4160 let ByteArrayVar = [1, 2, 3, 4, 5]; 4161 let result = data.writeByteArray(ByteArrayVar); 4162 console.log("RpcClient: writeByteArray is " + result); 4163 let array = new Array(5); 4164 data.readByteArray(array); 4165 ``` 4166 4167### readByteArray 4168 4169readByteArray(): number[] 4170 4171从MessageParcel实例中读取字节数组。 4172 4173**系统能力**：SystemCapability.Communication.IPC.Core 4174 4175**返回值：** 4176 4177 | 类型 | 说明 | 4178 | -------- | -------------- | 4179 | number[] | 返回字节数组。 | 4180 4181**示例：** 4182 4183 ```ts 4184 let data = rpc.MessageParcel.create(); 4185 let ByteArrayVar = [1, 2, 3, 4, 5]; 4186 let result = data.writeByteArray(ByteArrayVar); 4187 console.log("RpcClient: writeByteArray is " + result); 4188 let array = data.readByteArray(); 4189 console.log("RpcClient: readByteArray is " + array); 4190 ``` 4191 4192### writeShortArray 4193 4194writeShortArray(shortArray: number[]): boolean 4195 4196将短整数数组写入MessageParcel实例。 4197 4198**系统能力**：SystemCapability.Communication.IPC.Core 4199 4200**参数：** 4201 4202 | 参数名 | 类型 | 必填 | 说明 | 4203 | ---------- | -------- | ---- | -------------------- | 4204 | shortArray | number[] | 是 | 要写入的短整数数组。 | 4205 4206**返回值：** 4207 4208 | 类型 | 说明 | 4209 | ------- | -------------------------------- | 4210 | boolean | true：写入成功，false：写入失败。| 4211 4212**示例：** 4213 4214 ```ts 4215 let data = rpc.MessageParcel.create(); 4216 let result = data.writeShortArray([11, 12, 13]); 4217 console.log("RpcClient: writeShortArray is " + result); 4218 ``` 4219 4220### readShortArray 4221 4222readShortArray(dataIn: number[]): void 4223 4224从MessageParcel实例中读取短整数数组。 4225 4226**系统能力**：SystemCapability.Communication.IPC.Core 4227 4228**参数：** 4229 4230 | 参数名 | 类型 | 必填 | 说明 | 4231 | ------ | -------- | ---- | -------------------- | 4232 | dataIn | number[] | 是 | 要读取的短整数数组。 | 4233 4234**示例：** 4235 4236 ```ts 4237 let data = rpc.MessageParcel.create(); 4238 let result = data.writeShortArray([11, 12, 13]); 4239 console.log("RpcClient: writeShortArray is " + result); 4240 let array = new Array(3); 4241 data.readShortArray(array); 4242 ``` 4243 4244### readShortArray 4245 4246readShortArray(): number[] 4247 4248从MessageParcel实例中读取短整数数组。 4249 4250**系统能力**：SystemCapability.Communication.IPC.Core 4251 4252**返回值：** 4253 4254 | 类型 | 说明 | 4255 | -------- | ---------------- | 4256 | number[] | 返回短整数数组。 | 4257 4258**示例：** 4259 4260 ```ts 4261 let data = rpc.MessageParcel.create(); 4262 let result = data.writeShortArray([11, 12, 13]); 4263 console.log("RpcClient: writeShortArray is " + result); 4264 let array = data.readShortArray(); 4265 console.log("RpcClient: readShortArray is " + array); 4266 ``` 4267 4268### writeIntArray 4269 4270writeIntArray(intArray: number[]): boolean 4271 4272将整数数组写入MessageParcel实例。 4273 4274**系统能力**：SystemCapability.Communication.IPC.Core 4275 4276**参数：** 4277 4278 | 参数名 | 类型 | 必填 | 说明 | 4279 | -------- | -------- | ---- | ------------------ | 4280 | intArray | number[] | 是 | 要写入的整数数组。 | 4281 4282**返回值：** 4283 4284 | 类型 | 说明 | 4285 | ------- | -------------------------------- | 4286 | boolean | true：写入成功，false：写入失败。| 4287 4288**示例：** 4289 4290 ```ts 4291 let data = rpc.MessageParcel.create(); 4292 let result = data.writeIntArray([100, 111, 112]); 4293 console.log("RpcClient: writeIntArray is " + result); 4294 ``` 4295 4296### readIntArray 4297 4298readIntArray(dataIn: number[]): void 4299 4300从MessageParcel实例中读取整数数组。 4301 4302**系统能力**：SystemCapability.Communication.IPC.Core 4303 4304**参数：** 4305 4306 | 参数名 | 类型 | 必填 | 说明 | 4307 | ------ | -------- | ---- | ------------------ | 4308 | dataIn | number[] | 是 | 要读取的整数数组。 | 4309 4310**示例：** 4311 4312 ```ts 4313 let data = rpc.MessageParcel.create(); 4314 let result = data.writeIntArray([100, 111, 112]); 4315 console.log("RpcClient: writeIntArray is " + result); 4316 let array = new Array(3); 4317 data.readIntArray(array); 4318 ``` 4319 4320### readIntArray 4321 4322readIntArray(): number[] 4323 4324从MessageParcel实例中读取整数数组。 4325 4326**系统能力**：SystemCapability.Communication.IPC.Core 4327 4328**返回值：** 4329 4330 | 类型 | 说明 | 4331 | -------- | -------------- | 4332 | number[] | 返回整数数组。 | 4333 4334**示例：** 4335 4336 ```ts 4337 let data = rpc.MessageParcel.create(); 4338 let result = data.writeIntArray([100, 111, 112]); 4339 console.log("RpcClient: writeIntArray is " + result); 4340 let array = data.readIntArray(); 4341 console.log("RpcClient: readIntArray is " + array); 4342 ``` 4343 4344### writeLongArray 4345 4346writeLongArray(longArray: number[]): boolean 4347 4348将长整数数组写入MessageParcel实例。 4349 4350**系统能力**：SystemCapability.Communication.IPC.Core 4351 4352**参数：** 4353 4354 | 参数名 | 类型 | 必填 | 说明 | 4355 | --------- | -------- | ---- | -------------------- | 4356 | longArray | number[] | 是 | 要写入的长整数数组。 | 4357 4358**返回值：** 4359 4360 | 类型 | 说明 | 4361 | ------- | ----------------------------- | 4362 | boolean | true：写入成功，false：写入失败。| 4363 4364**示例：** 4365 4366 ```ts 4367 let data = rpc.MessageParcel.create(); 4368 let result = data.writeLongArray([1111, 1112, 1113]); 4369 console.log("RpcClient: writeLongArray is " + result); 4370 ``` 4371 4372### readLongArray 4373 4374readLongArray(dataIn: number[]): void 4375 4376从MessageParcel实例读取长整数数组。 4377 4378**系统能力**：SystemCapability.Communication.IPC.Core 4379 4380**参数：** 4381 4382 | 参数名 | 类型 | 必填 | 说明 | 4383 | ------ | -------- | ---- | -------------------- | 4384 | dataIn | number[] | 是 | 要读取的长整数数组。 | 4385 4386**示例：** 4387 4388 ```ts 4389 let data = rpc.MessageParcel.create(); 4390 let result = data.writeLongArray([1111, 1112, 1113]); 4391 console.log("RpcClient: writeLongArray is " + result); 4392 let array = new Array(3); 4393 data.readLongArray(array); 4394 ``` 4395 4396### readLongArray 4397 4398readLongArray(): number[] 4399 4400从MessageParcel实例中读取长整数数组。 4401 4402**系统能力**：SystemCapability.Communication.IPC.Core 4403 4404**返回值：** 4405 4406 | 类型 | 说明 | 4407 | -------- | ---------------- | 4408 | number[] | 返回长整数数组。 | 4409 4410**示例：** 4411 4412 ```ts 4413 let data = rpc.MessageParcel.create(); 4414 let result = data.writeLongArray([1111, 1112, 1113]); 4415 console.log("RpcClient: writeLongArray is " + result); 4416 let array = data.readLongArray(); 4417 console.log("RpcClient: readLongArray is " + array); 4418 ``` 4419 4420### writeFloatArray 4421 4422writeFloatArray(floatArray: number[]): boolean 4423 4424将浮点数组写入MessageParcel实例。 4425 4426**系统能力**：SystemCapability.Communication.IPC.Core 4427 4428**参数：** 4429 4430 | 参数名 | 类型 | 必填 | 说明 | 4431 | ---------- | -------- | ---- | --- | 4432 | floatArray | number[] | 是 | 要写入的浮点数组。由于系统内部对float类型的数据是按照double处理的，使用时对于数组所占的总字节数应按照double类型来计算。 | 4433 4434**返回值：** 4435 4436 | 类型 | 说明 | 4437 | ------- | -------------------------------- | 4438 | boolean | true：写入成功，false：写入失败。| 4439 4440**示例：** 4441 4442 ```ts 4443 let data = rpc.MessageParcel.create(); 4444 let result = data.writeFloatArray([1.2, 1.3, 1.4]); 4445 console.log("RpcClient: writeFloatArray is " + result); 4446 ``` 4447 4448### readFloatArray 4449 4450readFloatArray(dataIn: number[]): void 4451 4452从MessageParcel实例中读取浮点数组。 4453 4454**系统能力**：SystemCapability.Communication.IPC.Core 4455 4456**参数：** 4457 4458 | 参数名 | 类型 | 必填 | 说明 | 4459 | ------ | -------- | ---- | ------ | 4460 | dataIn | number[] | 是 | 要读取的浮点数组。由于系统内部对float类型的数据是按照double处理的，使用时对于数组所占的总字节数应按照double类型来计算。 | 4461 4462**示例：** 4463 4464 ```ts 4465 let data = rpc.MessageParcel.create(); 4466 let result = data.writeFloatArray([1.2, 1.3, 1.4]); 4467 console.log("RpcClient: writeFloatArray is " + result); 4468 let array = new Array(3); 4469 data.readFloatArray(array); 4470 ``` 4471 4472### readFloatArray 4473 4474readFloatArray(): number[] 4475 4476从MessageParcel实例中读取浮点数组。 4477 4478**系统能力**：SystemCapability.Communication.IPC.Core 4479 4480**返回值：** 4481 4482 | 类型 | 说明 | 4483 | -------- | -------------- | 4484 | number[] | 返回浮点数组。 | 4485 4486**示例：** 4487 4488 ```ts 4489 let data = rpc.MessageParcel.create(); 4490 let result = data.writeFloatArray([1.2, 1.3, 1.4]); 4491 console.log("RpcClient: writeFloatArray is " + result); 4492 let array = data.readFloatArray(); 4493 console.log("RpcClient: readFloatArray is " + array); 4494 ``` 4495 4496### writeDoubleArray 4497 4498writeDoubleArray(doubleArray: number[]): boolean 4499 4500将双精度浮点数组写入MessageParcel实例。 4501 4502**系统能力**：SystemCapability.Communication.IPC.Core 4503 4504**参数：** 4505 4506 | 参数名 | 类型 | 必填 | 说明 | 4507 | ----------- | -------- | ---- | ------------------------ | 4508 | doubleArray | number[] | 是 | 要写入的双精度浮点数组。 | 4509 4510**返回值：** 4511 4512 | 类型 | 说明 | 4513 | ------- | -------------------------------- | 4514 | boolean | true：写入成功，false：写入失败。| 4515 4516**示例：** 4517 4518 ```ts 4519 let data = rpc.MessageParcel.create(); 4520 let result = data.writeDoubleArray([11.1, 12.2, 13.3]); 4521 console.log("RpcClient: writeDoubleArray is " + result); 4522 ``` 4523 4524### readDoubleArray 4525 4526readDoubleArray(dataIn: number[]): void 4527 4528从MessageParcel实例中读取双精度浮点数组。 4529 4530**系统能力**：SystemCapability.Communication.IPC.Core 4531 4532**参数：** 4533 4534 | 参数名 | 类型 | 必填 | 说明 | 4535 | ------ | -------- | ---- | ------------------------ | 4536 | dataIn | number[] | 是 | 要读取的双精度浮点数组。 | 4537 4538**示例：** 4539 4540 ```ts 4541 let data = rpc.MessageParcel.create(); 4542 let result = data.writeDoubleArray([11.1, 12.2, 13.3]); 4543 console.log("RpcClient: writeDoubleArray is " + result); 4544 let array = new Array(3); 4545 data.readDoubleArray(array); 4546 ``` 4547 4548### readDoubleArray 4549 4550readDoubleArray(): number[] 4551 4552从MessageParcel实例读取双精度浮点数组。 4553 4554**系统能力**：SystemCapability.Communication.IPC.Core 4555 4556**返回值：** 4557 4558 | 类型 | 说明 | 4559 | -------- | -------------------- | 4560 | number[] | 返回双精度浮点数组。 | 4561 4562**示例：** 4563 4564 ```ts 4565 let data = rpc.MessageParcel.create(); 4566 let result = data.writeDoubleArray([11.1, 12.2, 13.3]); 4567 console.log("RpcClient: writeDoubleArray is " + result); 4568 let array = data.readDoubleArray(); 4569 console.log("RpcClient: readDoubleArray is " + array); 4570 ``` 4571 4572### writeBooleanArray 4573 4574writeBooleanArray(booleanArray: boolean[]): boolean 4575 4576将布尔数组写入MessageParcel实例。 4577 4578**系统能力**：SystemCapability.Communication.IPC.Core 4579 4580**参数：** 4581 4582 | 参数名 | 类型 | 必填 | 说明 | 4583 | ------------ | --------- | ---- | ------------------ | 4584 | booleanArray | boolean[] | 是 | 要写入的布尔数组。 | 4585 4586**返回值：** 4587 4588 | 类型 | 说明 | 4589 | ------- | -------------------------------- | 4590 | boolean | true：写入成功，false：写入失败。| 4591 4592**示例：** 4593 4594 ```ts 4595 let data = rpc.MessageParcel.create(); 4596 let result = data.writeBooleanArray([false, true, false]); 4597 console.log("RpcClient: writeBooleanArray is " + result); 4598 ``` 4599 4600### readBooleanArray 4601 4602readBooleanArray(dataIn: boolean[]): void 4603 4604从MessageParcel实例中读取布尔数组。 4605 4606**系统能力**：SystemCapability.Communication.IPC.Core 4607 4608**参数：** 4609 4610 | 参数名 | 类型 | 必填 | 说明 | 4611 | ------ | --------- | ---- | ------------------ | 4612 | dataIn | boolean[] | 是 | 要读取的布尔数组。 | 4613 4614**示例：** 4615 4616 ```ts 4617 let data = rpc.MessageParcel.create(); 4618 let result = data.writeBooleanArray([false, true, false]); 4619 console.log("RpcClient: writeBooleanArray is " + result); 4620 let array = new Array(3); 4621 data.readBooleanArray(array); 4622 ``` 4623 4624### readBooleanArray 4625 4626readBooleanArray(): boolean[] 4627 4628从MessageParcel实例中读取布尔数组。 4629 4630**系统能力**：SystemCapability.Communication.IPC.Core 4631 4632**返回值：** 4633 4634 | 类型 | 说明 | 4635 | --------- | -------------- | 4636 | boolean[] | 返回布尔数组。 | 4637 4638**示例：** 4639 4640 ```ts 4641 let data = rpc.MessageParcel.create(); 4642 let result = data.writeBooleanArray([false, true, false]); 4643 console.log("RpcClient: writeBooleanArray is " + result); 4644 let array = data.readBooleanArray(); 4645 console.log("RpcClient: readBooleanArray is " + array); 4646 ``` 4647 4648### writeCharArray 4649 4650writeCharArray(charArray: number[]): boolean 4651 4652将单个字符数组写入MessageParcel实例。 4653 4654**系统能力**：SystemCapability.Communication.IPC.Core 4655 4656**参数：** 4657 4658 | 参数名 | 类型 | 必填 | 说明 | 4659 | --------- | -------- | ---- | ---------------------- | 4660 | charArray | number[] | 是 | 要写入的单个字符数组。 | 4661 4662**返回值：** 4663 4664 | 类型 | 说明 | 4665 | ------- | -------------------------------- | 4666 | boolean | true：写入成功，false：写入失败。| 4667 4668**示例：** 4669 4670 ```ts 4671 let data = rpc.MessageParcel.create(); 4672 let result = data.writeCharArray([97, 98, 88]); 4673 console.log("RpcClient: writeCharArray is " + result); 4674 ``` 4675 4676### readCharArray 4677 4678readCharArray(dataIn: number[]): void 4679 4680从MessageParcel实例中读取单个字符数组。 4681 4682**系统能力**：SystemCapability.Communication.IPC.Core 4683 4684**参数：** 4685 4686 | 参数名 | 类型 | 必填 | 说明 | 4687 | ------ | -------- | ---- | ---------------------- | 4688 | dataIn | number[] | 是 | 要读取的单个字符数组。 | 4689 4690**示例：** 4691 4692 ```ts 4693 let data = rpc.MessageParcel.create(); 4694 let result = data.writeCharArray([97, 98, 99]); 4695 console.log("RpcClient: writeCharArray is " + result); 4696 let array = new Array(3); 4697 data.readCharArray(array); 4698 ``` 4699 4700### readCharArray 4701 4702readCharArray(): number[] 4703 4704从MessageParcel实例读取单个字符数组。 4705 4706**系统能力**：SystemCapability.Communication.IPC.Core 4707 4708**返回值：** 4709 4710 | 类型 | 说明 | 4711 | -------- | ------------------ | 4712 | number[] | 返回单个字符数组。 | 4713 4714**示例：** 4715 4716 ```ts 4717 let data = rpc.MessageParcel.create(); 4718 let result = data.writeCharArray([97, 98, 99]); 4719 console.log("RpcClient: writeCharArray is " + result); 4720 let array = data.readCharArray(); 4721 console.log("RpcClient: readCharArray is " + array); 4722 ``` 4723 4724### writeStringArray 4725 4726writeStringArray(stringArray: string[]): boolean 4727 4728将字符串数组写入MessageParcel实例。 4729 4730**系统能力**：SystemCapability.Communication.IPC.Core 4731 4732**参数：** 4733 4734 | 参数名 | 类型 | 必填 | 说明 | 4735 | ----------- | -------- | ---- | ---------------- | 4736 | stringArray | string[] | 是 | 要写入的字符串数组，数组单个元素的长度应小于40960字节。 | 4737 4738**返回值：** 4739 4740 | 类型 | 说明 | 4741 | ------- | -------------------------------- | 4742 | boolean | true：写入成功，false：写入失败。| 4743 4744**示例：** 4745 4746 ```ts 4747 let data = rpc.MessageParcel.create(); 4748 let result = data.writeStringArray(["abc", "def"]); 4749 console.log("RpcClient: writeStringArray is " + result); 4750 ``` 4751 4752### readStringArray 4753 4754readStringArray(dataIn: string[]): void 4755 4756从MessageParcel实例读取字符串数组。 4757 4758**系统能力**：SystemCapability.Communication.IPC.Core 4759 4760**参数：** 4761 4762 | 参数名 | 类型 | 必填 | 说明 | 4763 | ------ | -------- | ---- | -------------------- | 4764 | dataIn | string[] | 是 | 要读取的字符串数组。 | 4765 4766**示例：** 4767 4768 ```ts 4769 let data = rpc.MessageParcel.create(); 4770 let result = data.writeStringArray(["abc", "def"]); 4771 console.log("RpcClient: writeStringArray is " + result); 4772 let array = new Array(2); 4773 data.readStringArray(array); 4774 ``` 4775 4776### readStringArray 4777 4778readStringArray(): string[] 4779 4780从MessageParcel实例读取字符串数组。 4781 4782**系统能力**：SystemCapability.Communication.IPC.Core 4783 4784**返回值：** 4785 4786 | 类型 | 说明 | 4787 | -------- | ---------------- | 4788 | string[] | 返回字符串数组。 | 4789 4790**示例：** 4791 4792 ```ts 4793 let data = rpc.MessageParcel.create(); 4794 let result = data.writeStringArray(["abc", "def"]); 4795 console.log("RpcClient: writeStringArray is " + result); 4796 let array = data.readStringArray(); 4797 console.log("RpcClient: readStringArray is " + array); 4798 ``` 4799 4800### writeNoException<sup>8+</sup> 4801 4802writeNoException(): void 4803 4804向MessageParcel写入“指示未发生异常”的信息。 4805 4806**系统能力**：SystemCapability.Communication.IPC.Core 4807 4808**示例：** 4809 4810 ```ts 4811 class MyDeathRecipient { 4812 onRemoteDied() { 4813 console.log("server died"); 4814 } 4815 } 4816 class TestRemoteObject extends rpc.RemoteObject { 4817 constructor(descriptor) { 4818 super(descriptor); 4819 } 4820 addDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 4821 return true; 4822 } 4823 removeDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 4824 return true; 4825 } 4826 isObjectDead(): boolean { 4827 return false; 4828 } 4829 onRemoteRequest(code, data, reply, option) { 4830 if (code === 1) { 4831 console.log("RpcServer: onRemoteRequest called"); 4832 reply.writeNoException(); 4833 return true; 4834 } else { 4835 console.log("RpcServer: unknown code: " + code); 4836 return false; 4837 } 4838 } 4839 } 4840 ``` 4841 4842### readException<sup>8+</sup> 4843 4844readException(): void 4845 4846从MessageParcel中读取异常。 4847 4848**系统能力**：SystemCapability.Communication.IPC.Core 4849 4850**示例：** 4851 4852 Stage模型的应用在获取服务前需要先获取context，具体方法可参考[获取context](#获取context) 4853 4854 ```ts 4855 // 仅FA模型需要导入@ohos.ability.featureAbility 4856 // import FA from "@ohos.ability.featureAbility"; 4857 4858 let proxy; 4859 let connect = { 4860 onConnect: function(elementName, remoteProxy) { 4861 console.log("RpcClient: js onConnect called."); 4862 proxy = remoteProxy; 4863 }, 4864 onDisconnect: function(elementName) { 4865 console.log("RpcClient: onDisconnect"); 4866 }, 4867 onFailed: function() { 4868 console.log("RpcClient: onFailed"); 4869 } 4870 }; 4871 let want = { 4872 "bundleName": "com.ohos.server", 4873 "abilityName": "com.ohos.server.EntryAbility", 4874 }; 4875 4876 // FA模型使用此方法连接服务 4877 // FA.connectAbility(want,connect); 4878 4879 globalThis.context.connectServiceExtensionAbility(want, connect); 4880 ``` 4881 4882 上述onConnect回调函数中的proxy对象需要等ability异步连接成功后才会被赋值，然后才可调用proxy对象的sendMessageRequest接口方法发送消息 4883 4884 ```ts 4885 let option = new rpc.MessageOption(); 4886 let data = rpc.MessageParcel.create(); 4887 let reply = rpc.MessageParcel.create(); 4888 data.writeInt(1); 4889 data.writeString("hello"); 4890 proxy.sendMessageRequest(1, data, reply, option) 4891 .then(function(errCode) { 4892 if (errCode === 0) { 4893 console.log("sendMessageRequest got result"); 4894 reply.readException(); 4895 let msg = reply.readString(); 4896 console.log("RPCTest: reply msg: " + msg); 4897 } else { 4898 console.log("RPCTest: sendMessageRequest failed, errCode: " + errCode); 4899 } 4900 }).catch(function(e) { 4901 console.log("RPCTest: sendMessageRequest got exception: " + e.message); 4902 }).finally (() => { 4903 console.log("RPCTest: sendMessageRequest ends, reclaim parcel"); 4904 data.reclaim(); 4905 reply.reclaim(); 4906 }); 4907 ``` 4908 4909### writeSequenceableArray 4910 4911writeSequenceableArray(sequenceableArray: Sequenceable[]): boolean 4912 4913将可序列化对象数组写入MessageParcel实例。 4914 4915**系统能力**：SystemCapability.Communication.IPC.Core 4916 4917**参数：** 4918 4919 | 参数名 | 类型 | 必填 | 说明 | 4920 | ----------------- | -------------- | ---- | -------------------------- | 4921 | sequenceableArray | Sequenceable[] | 是 | 要写入的可序列化对象数组。 | 4922 4923**返回值：** 4924 4925 | 类型 | 说明 | 4926 | ------- | -------------------------------- | 4927 | boolean | true：写入成功，false：写入失败。| 4928 4929**示例：** 4930 4931 ```ts 4932 class MySequenceable { 4933 num: number; 4934 str: string; 4935 constructor(num, str) { 4936 this.num = num; 4937 this.str = str; 4938 } 4939 marshalling(messageParcel) { 4940 messageParcel.writeInt(this.num); 4941 messageParcel.writeString(this.str); 4942 return true; 4943 } 4944 unmarshalling(messageParcel) { 4945 this.num = messageParcel.readInt(); 4946 this.str = messageParcel.readString(); 4947 return true; 4948 } 4949 } 4950 let sequenceable = new MySequenceable(1, "aaa"); 4951 let sequenceable2 = new MySequenceable(2, "bbb"); 4952 let sequenceable3 = new MySequenceable(3, "ccc"); 4953 let a = [sequenceable, sequenceable2, sequenceable3]; 4954 let data = rpc.MessageParcel.create(); 4955 let result = data.writeSequenceableArray(a); 4956 console.log("RpcClient: writeSequenceableArray is " + result); 4957 ``` 4958 4959### readSequenceableArray<sup>8+</sup> 4960 4961readSequenceableArray(sequenceableArray: Sequenceable[]): void 4962 4963从MessageParcel实例读取可序列化对象数组。 4964 4965**系统能力**：SystemCapability.Communication.IPC.Core 4966 4967**参数：** 4968 4969 | 参数名 | 类型 | 必填 | 说明 | 4970 | ----------------- | -------------- | ---- | -------------------------- | 4971 | sequenceableArray | Sequenceable[] | 是 | 要读取的可序列化对象数组。 | 4972 4973**示例：** 4974 4975 ```ts 4976 class MySequenceable { 4977 num: number; 4978 str: string; 4979 constructor(num, str) { 4980 this.num = num; 4981 this.str = str; 4982 } 4983 marshalling(messageParcel) { 4984 messageParcel.writeInt(this.num); 4985 messageParcel.writeString(this.str); 4986 return true; 4987 } 4988 unmarshalling(messageParcel) { 4989 this.num = messageParcel.readInt(); 4990 this.str = messageParcel.readString(); 4991 return true; 4992 } 4993 } 4994 let sequenceable = new MySequenceable(1, "aaa"); 4995 let sequenceable2 = new MySequenceable(2, "bbb"); 4996 let sequenceable3 = new MySequenceable(3, "ccc"); 4997 let a = [sequenceable, sequenceable2, sequenceable3]; 4998 let data = rpc.MessageParcel.create(); 4999 let result = data.writeSequenceableArray(a); 5000 console.log("RpcClient: writeSequenceableArray is " + result); 5001 let b = [new MySequenceable(0, ""), new MySequenceable(0, ""), new MySequenceable(0, "")]; 5002 data.readSequenceableArray(b); 5003 ``` 5004 5005### writeRemoteObjectArray<sup>8+</sup> 5006 5007writeRemoteObjectArray(objectArray: IRemoteObject[]): boolean 5008 5009将IRemoteObject对象数组写入MessageParcel。 5010 5011**系统能力**：SystemCapability.Communication.IPC.Core 5012 5013**参数：** 5014 5015 | 参数名 | 类型 | 必填 | 说明 | 5016 | ----------- | --------------- | ---- | ----- | 5017 | objectArray | IRemoteObject[] | 是 | 要写入MessageParcel的IRemoteObject对象数组。 | 5018 5019**返回值：** 5020 5021 | 类型 | 说明 | 5022 | ------- | -------------------------------- | 5023 | boolean | true：写入成功，false：写入失败。| 5024 5025**示例：** 5026 5027 ```ts 5028 class MyDeathRecipient { 5029 onRemoteDied() { 5030 console.log("server died"); 5031 } 5032 } 5033 class TestRemoteObject extends rpc.RemoteObject { 5034 constructor(descriptor) { 5035 super(descriptor); 5036 this.attachLocalInterface(this, descriptor); 5037 } 5038 addDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 5039 return true; 5040 } 5041 removeDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 5042 return true; 5043 } 5044 isObjectDead(): boolean { 5045 return false; 5046 } 5047 asObject(): rpc.IRemoteObject { 5048 return this; 5049 } 5050 } 5051 let a = [new TestRemoteObject("testObject1"), new TestRemoteObject("testObject2"), new TestRemoteObject("testObject3")]; 5052 let data = rpc.MessageParcel.create(); 5053 let result = data.writeRemoteObjectArray(a); 5054 console.log("RpcClient: writeRemoteObjectArray is " + result); 5055 ``` 5056 5057### readRemoteObjectArray<sup>8+</sup> 5058 5059readRemoteObjectArray(objects: IRemoteObject[]): void 5060 5061从MessageParcel读取IRemoteObject对象数组。 5062 5063**系统能力**：SystemCapability.Communication.IPC.Core 5064 5065**参数：** 5066 5067 | 参数名 | 类型 | 必填 | 说明 | 5068 | ------- | --------------- | ---- | --------- | 5069 | objects | IRemoteObject[] | 是 | 从MessageParcel读取的IRemoteObject对象数组。 | 5070 5071**示例：** 5072 5073 ```ts 5074 class MyDeathRecipient { 5075 onRemoteDied() { 5076 console.log("server died"); 5077 } 5078 } 5079 class TestRemoteObject extends rpc.RemoteObject { 5080 constructor(descriptor) { 5081 super(descriptor); 5082 this.attachLocalInterface(this, descriptor); 5083 } 5084 addDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 5085 return true; 5086 } 5087 removeDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 5088 return true; 5089 } 5090 isObjectDead(): boolean { 5091 return false; 5092 } 5093 asObject(): rpc.IRemoteObject { 5094 return this; 5095 } 5096 } 5097 let a = [new TestRemoteObject("testObject1"), new TestRemoteObject("testObject2"), new TestRemoteObject("testObject3")]; 5098 let data = rpc.MessageParcel.create(); 5099 let result = data.writeRemoteObjectArray(a); 5100 let b = new Array(3); 5101 data.readRemoteObjectArray(b); 5102 ``` 5103 5104### readRemoteObjectArray<sup>8+</sup> 5105 5106readRemoteObjectArray(): IRemoteObject[] 5107 5108从MessageParcel读取IRemoteObject对象数组。 5109 5110**系统能力**：SystemCapability.Communication.IPC.Core 5111 5112**返回值：** 5113 5114 | 类型 | 说明 | 5115 | --------------- | --------------------------- | 5116 | IRemoteObject[] | 返回IRemoteObject对象数组。 | 5117 5118**示例：** 5119 5120 ```ts 5121 class MyDeathRecipient { 5122 onRemoteDied() { 5123 console.log("server died"); 5124 } 5125 } 5126 class TestRemoteObject extends rpc.RemoteObject { 5127 constructor(descriptor) { 5128 super(descriptor); 5129 this.attachLocalInterface(this, descriptor); 5130 } 5131 addDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 5132 return true; 5133 } 5134 removeDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 5135 return true; 5136 } 5137 isObjectDead(): boolean { 5138 return false; 5139 } 5140 asObject(): rpc.IRemoteObject { 5141 return this; 5142 } 5143 } 5144 let a = [new TestRemoteObject("testObject1"), new TestRemoteObject("testObject2"), new TestRemoteObject("testObject3")]; 5145 let data = rpc.MessageParcel.create(); 5146 let result = data.writeRemoteObjectArray(a); 5147 console.log("RpcClient: readRemoteObjectArray is " + result); 5148 let b = data.readRemoteObjectArray(); 5149 console.log("RpcClient: readRemoteObjectArray is " + b); 5150 ``` 5151 5152### closeFileDescriptor<sup>8+</sup> 5153 5154static closeFileDescriptor(fd: number): void 5155 5156静态方法，关闭给定的文件描述符。 5157 5158**系统能力**：SystemCapability.Communication.IPC.Core 5159 5160**参数：** 5161 5162 | 参数名 | 类型 | 必填 | 说明 | 5163 | ------ | ------ | ---- | -------------------- | 5164 | fd | number | 是 | 要关闭的文件描述符。 | 5165 5166**示例：** 5167 5168 ```ts 5169 import fs from '@ohos.file.fs'; 5170 let filePath = "path/to/file"; 5171 let file = fs.openSync(filePath, fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE); 5172 rpc.MessageParcel.closeFileDescriptor(file.fd); 5173 ``` 5174 5175### dupFileDescriptor<sup>8+</sup> 5176 5177static dupFileDescriptor(fd: number) :number 5178 5179静态方法，复制给定的文件描述符。 5180 5181**系统能力**：SystemCapability.Communication.IPC.Core 5182 5183**参数：** 5184 5185 | 参数名 | 类型 | 必填 | 说明 | 5186 | ------ | ------ | ---- | ------------------------ | 5187 | fd | number | 是 | 表示已存在的文件描述符。 | 5188 5189**返回值：** 5190 5191 | 类型 | 说明 | 5192 | ------ | -------------------- | 5193 | number | 返回新的文件描述符。 | 5194 5195**示例：** 5196 5197 ```ts 5198 import fs from '@ohos.file.fs'; 5199 let filePath = "path/to/file"; 5200 let file = fs.openSync(filePath, fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE); 5201 let newFd = rpc.MessageParcel.dupFileDescriptor(file.fd); 5202 ``` 5203 5204### containFileDescriptors<sup>8+</sup> 5205 5206containFileDescriptors(): boolean 5207 5208检查此MessageParcel对象是否包含文件描述符。 5209 5210**系统能力**：SystemCapability.Communication.IPC.Core 5211 5212**返回值：** 5213 5214 | 类型 | 说明 | 5215 | ------- | --------------------------------------------- | 5216 | boolean |true：包含文件描述符，false：未包含文件描述符。| 5217 5218**示例：** 5219 5220 ```ts 5221 import fs from '@ohos.file.fs'; 5222 let parcel = new rpc.MessageParcel(); 5223 let filePath = "path/to/file"; 5224 let r1 = parcel.containFileDescriptors(); 5225 let file = fs.openSync(filePath, fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE); 5226 let writeResult = parcel.writeFileDescriptor(file.fd); 5227 console.log("RpcTest: parcel writeFd result is : " + writeResult); 5228 let containFD = parcel.containFileDescriptors(); 5229 console.log("RpcTest: parcel after write fd containFd result is : " + containFD); 5230 ``` 5231 5232### writeFileDescriptor<sup>8+</sup> 5233 5234writeFileDescriptor(fd: number): boolean 5235 5236写入文件描述符到MessageParcel。 5237 5238**系统能力**：SystemCapability.Communication.IPC.Core 5239 5240**参数：** 5241 5242 | 参数名 | 类型 | 必填 | 说明 | 5243 | ------ | ------ | ---- | ------------ | 5244 | fd | number | 是 | 文件描述符。 | 5245 5246**返回值：** 5247 5248 | 类型 | 说明 | 5249 | ------- | -------------------------------- | 5250 | boolean | true：操作成功，false：操作失败。| 5251 5252**示例：** 5253 5254 ```ts 5255 import fs from '@ohos.file.fs'; 5256 let parcel = new rpc.MessageParcel(); 5257 let filePath = "path/to/file"; 5258 let file = fs.openSync(filePath, fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE); 5259 let writeResult = parcel.writeFileDescriptor(file.fd); 5260 console.log("RpcTest: parcel writeFd result is : " + writeResult); 5261 ``` 5262 5263### readFileDescriptor<sup>8+</sup> 5264 5265readFileDescriptor(): number 5266 5267从MessageParcel中读取文件描述符。 5268 5269**系统能力**：SystemCapability.Communication.IPC.Core 5270 5271**返回值：** 5272 5273 | 类型 | 说明 | 5274 | ------ | ---------------- | 5275 | number | 返回文件描述符。 | 5276 5277**示例：** 5278 5279 ```ts 5280 import fs from '@ohos.file.fs'; 5281 let parcel = new rpc.MessageParcel(); 5282 let filePath = "path/to/file"; 5283 let file = fs.openSync(filePath, fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE); 5284 let writeResult = parcel.writeFileDescriptor(file.fd); 5285 let readFD = parcel.readFileDescriptor(); 5286 console.log("RpcTest: parcel read fd is : " + readFD); 5287 ``` 5288 5289### writeAshmem<sup>8+</sup> 5290 5291writeAshmem(ashmem: Ashmem): boolean 5292 5293将指定的匿名共享对象写入此MessageParcel。 5294 5295**系统能力**：SystemCapability.Communication.IPC.Core 5296 5297**参数：** 5298 5299 | 参数名 | 类型 | 必填 | 说明 | 5300 | ------ | ------ | ---- | ----------------------------------- | 5301 | ashmem | Ashmem | 是 | 要写入MessageParcel的匿名共享对象。 | 5302 5303**返回值：** 5304 5305 | 类型 | 说明 | 5306 | ------- | -------------------------------- | 5307 | boolean | true：写入成功，false：写入失败。| 5308 5309**示例：** 5310 5311 ```ts 5312 let parcel = new rpc.MessageParcel(); 5313 let ashmem = rpc.Ashmem.createAshmem("ashmem", 1024); 5314 let isWriteSuccess = parcel.writeAshmem(ashmem); 5315 console.log("RpcTest: write ashmem to result is : " + isWriteSuccess); 5316 ``` 5317 5318### readAshmem<sup>8+</sup> 5319 5320readAshmem(): Ashmem 5321 5322从MessageParcel读取匿名共享对象。 5323 5324**系统能力**：SystemCapability.Communication.IPC.Core 5325 5326**返回值：** 5327 5328 | 类型 | 说明 | 5329 | ------ | ------------------ | 5330 | Ashmem | 返回匿名共享对象。 | 5331 5332**示例：** 5333 5334 ```ts 5335 let parcel = new rpc.MessageParcel(); 5336 let ashmem = rpc.Ashmem.createAshmem("ashmem", 1024); 5337 let isWriteSuccess = parcel.writeAshmem(ashmem); 5338 console.log("RpcTest: write ashmem to result is : " + isWriteSuccess); 5339 let readAshmem = parcel.readAshmem(); 5340 console.log("RpcTest: read ashmem to result is : " + readAshmem); 5341 ``` 5342 5343### getRawDataCapacity<sup>8+</sup> 5344 5345getRawDataCapacity(): number 5346 5347获取MessageParcel可以容纳的最大原始数据量。 5348 5349**系统能力**：SystemCapability.Communication.IPC.Core 5350 5351**返回值：** 5352 5353 | 类型 | 说明 | 5354 | ------ | ---------------------------------------------------------- | 5355 | number | 返回MessageParcel可以容纳的最大原始数据量，即128 Mb。 | 5356 5357**示例：** 5358 5359 ```ts 5360 let parcel = new rpc.MessageParcel(); 5361 let result = parcel.getRawDataCapacity(); 5362 console.log("RpcTest: parcel get RawDataCapacity result is : " + result); 5363 ``` 5364 5365### writeRawData<sup>8+</sup> 5366 5367writeRawData(rawData: number[], size: number): boolean 5368 5369将原始数据写入MessageParcel对象。 5370 5371**系统能力**：SystemCapability.Communication.IPC.Core 5372 5373**参数：** 5374 5375 | 参数名 | 类型 | 必填 | 说明 | 5376 | ------- | -------- | ---- | ---------------------------------- | 5377 | rawData | number[] | 是 | 要写入的原始数据。 | 5378 | size | number | 是 | 发送的原始数据大小，以字节为单位。 | 5379 5380**返回值：** 5381 5382 | 类型 | 说明 | 5383 | ------- | -------------------------------- | 5384 | boolean | true：写入成功，false：写入失败。| 5385 5386**示例：** 5387 5388 ```ts 5389 let parcel = new rpc.MessageParcel(); 5390 let arr = [1, 2, 3, 4, 5]; 5391 let isWriteSuccess = parcel.writeRawData(arr, arr.length); 5392 console.log("RpcTest: parcel write raw data result is : " + isWriteSuccess); 5393 ``` 5394 5395### readRawData<sup>8+</sup> 5396 5397readRawData(size: number): number[] 5398 5399从MessageParcel读取原始数据。 5400 5401**系统能力**：SystemCapability.Communication.IPC.Core 5402 5403**参数：** 5404 5405 | 参数名 | 类型 | 必填 | 说明 | 5406 | ------ | ------ | ---- | ------------------------ | 5407 | size | number | 是 | 要读取的原始数据的大小。 | 5408 5409**返回值：** 5410 5411 | 类型 | 说明 | 5412 | -------- | ------------------------------ | 5413 | number[] | 返回原始数据（以字节为单位）。 | 5414 5415**示例：** 5416 5417 ```ts 5418 let parcel = new rpc.MessageParcel(); 5419 let arr = [1, 2, 3, 4, 5]; 5420 let isWriteSuccess = parcel.writeRawData(arr, arr.length); 5421 console.log("RpcTest: parcel write raw data result is : " + isWriteSuccess); 5422 let result = parcel.readRawData(5); 5423 console.log("RpcTest: parcel read raw data result is : " + result); 5424 ``` 5425 5426## Parcelable<sup>9+</sup> 5427 5428在进程间通信（IPC）期间，将类的对象写入MessageSequence并从MessageSequence中恢复它们。 5429 5430### marshalling 5431 5432marshalling(dataOut: MessageSequence): boolean 5433 5434将此可序列对象封送到MessageSequence中。 5435 5436**系统能力**：SystemCapability.Communication.IPC.Core 5437 5438**参数：** 5439 5440 | 参数名 | 类型 | 必填 | 说明 | 5441 | ------- | --------------- | ---- | ------------------------------------------- | 5442 | dataOut | MessageSequence | 是 | 可序列对象将被封送到的MessageSequence对象。 | 5443 5444**返回值：** 5445 5446 | 类型 | 说明 | 5447 | ------- | -------------------------------- | 5448 | boolean | true：封送成功，false：封送失败。| 5449 5450**示例：** 5451 5452 ```ts 5453 class MyParcelable { 5454 num: number; 5455 str: string; 5456 constructor(num, str) { 5457 this.num = num; 5458 this.str = str; 5459 } 5460 marshalling(messageSequence) { 5461 messageSequence.writeInt(this.num); 5462 messageSequence.writeString(this.str); 5463 return true; 5464 } 5465 unmarshalling(messageSequence) { 5466 this.num = messageSequence.readInt(); 5467 this.str = messageSequence.readString(); 5468 return true; 5469 } 5470 } 5471 let parcelable = new MyParcelable(1, "aaa"); 5472 let data = rpc.MessageSequence.create(); 5473 let result = data.writeParcelable(parcelable); 5474 console.log("RpcClient: writeParcelable is " + result); 5475 let ret = new MyParcelable(0, ""); 5476 let result2 = data.readParcelable(ret); 5477 console.log("RpcClient: readParcelable is " + result2); 5478 ``` 5479 5480### unmarshalling 5481 5482unmarshalling(dataIn: MessageSequence): boolean 5483 5484从MessageSequence中解封此可序列对象。 5485 5486**系统能力**：SystemCapability.Communication.IPC.Core 5487 5488**参数：** 5489 5490 | 参数名 | 类型 | 必填 | 说明 | 5491 | ------ | --------------- | ---- | ----------------------------------------------- | 5492 | dataIn | MessageSequence | 是 | 已将可序列对象封送到其中的MessageSequence对象。 | 5493 5494**返回值：** 5495 5496 | 类型 | 说明 | 5497 | ------- | ---------------------------------------- | 5498 | boolean | true：反序列化成功，false：反序列化失败。| 5499 5500**示例：** 5501 5502 ```ts 5503 class MyParcelable { 5504 num: number; 5505 str: string; 5506 constructor(num, str) { 5507 this.num = num; 5508 this.str = str; 5509 } 5510 marshalling(messageSequence) { 5511 messageSequence.writeInt(this.num); 5512 messageSequence.writeString(this.str); 5513 return true; 5514 } 5515 unmarshalling(messageSequence) { 5516 this.num = messageSequence.readInt(); 5517 this.str = messageSequence.readString(); 5518 return true; 5519 } 5520 } 5521 let parcelable = new MyParcelable(1, "aaa"); 5522 let data = rpc.MessageSequence.create(); 5523 let result = data.writeParcelable(parcelable); 5524 console.log("RpcClient: writeParcelable is " + result); 5525 let ret = new MyParcelable(0, ""); 5526 let result2 = data.readParcelable(ret); 5527 console.log("RpcClient: readParcelable is " + result2); 5528 ``` 5529 5530## Sequenceable<sup>(deprecated)</sup> 5531 5532>从API version 9 开始不再维护，建议使用[Parcelable](#parcelable9)类替代。 5533 5534在进程间通信（IPC）期间，将类的对象写入MessageParcel并从MessageParcel中恢复它们。 5535 5536### marshalling 5537 5538marshalling(dataOut: MessageParcel): boolean 5539 5540将此可序列对象封送到MessageParcel中。 5541 5542**系统能力**：SystemCapability.Communication.IPC.Core 5543 5544**参数：** 5545 5546 | 参数名 | 类型 | 必填 | 说明 | 5547 | ------- | ----------------------------------------- | ---- | ----------------------------------------- | 5548 | dataOut | [MessageParcel](#messageparceldeprecated) | 是 | 可序列对象将被封送到的MessageParcel对象。 | 5549 5550**返回值：** 5551 5552 | 类型 | 说明 | 5553 | ------- | -------------------------------- | 5554 | boolean | true：封送成功，false：封送失败。 | 5555 5556**示例：** 5557 5558 ```ts 5559 class MySequenceable { 5560 num: number; 5561 str: string; 5562 constructor(num, str) { 5563 this.num = num; 5564 this.str = str; 5565 } 5566 marshalling(messageParcel) { 5567 messageParcel.writeInt(this.num); 5568 messageParcel.writeString(this.str); 5569 return true; 5570 } 5571 unmarshalling(messageParcel) { 5572 this.num = messageParcel.readInt(); 5573 this.str = messageParcel.readString(); 5574 return true; 5575 } 5576 } 5577 let sequenceable = new MySequenceable(1, "aaa"); 5578 let data = rpc.MessageParcel.create(); 5579 let result = data.writeSequenceable(sequenceable); 5580 console.log("RpcClient: writeSequenceable is " + result); 5581 let ret = new MySequenceable(0, ""); 5582 let result2 = data.readSequenceable(ret); 5583 console.log("RpcClient: readSequenceable is " + result2); 5584 ``` 5585 5586### unmarshalling 5587 5588unmarshalling(dataIn: MessageParcel): boolean 5589 5590从MessageParcel中解封此可序列对象。 5591 5592**系统能力**：SystemCapability.Communication.IPC.Core 5593 5594**参数：** 5595 5596 | 参数名 | 类型 | 必填 | 说明 | 5597 | ------ | ----------------------------------------- | ---- | --------------------------------------------- | 5598 | dataIn | [MessageParcel](#messageparceldeprecated) | 是 | 已将可序列对象封送到其中的MessageParcel对象。 | 5599 5600**返回值：** 5601 5602 | 类型 | 说明 | 5603 | ------- | ---------------------------------------- | 5604 | boolean | true：反序列化成功，false：反序列化失败。| 5605 5606**示例：** 5607 5608 ```ts 5609 class MySequenceable { 5610 num: number; 5611 str: string; 5612 constructor(num, str) { 5613 this.num = num; 5614 this.str = str; 5615 } 5616 marshalling(messageParcel) { 5617 messageParcel.writeInt(this.num); 5618 messageParcel.writeString(this.str); 5619 return true; 5620 } 5621 unmarshalling(messageParcel) { 5622 this.num = messageParcel.readInt(); 5623 this.str = messageParcel.readString(); 5624 return true; 5625 } 5626 } 5627 let sequenceable = new MySequenceable(1, "aaa"); 5628 let data = rpc.MessageParcel.create(); 5629 let result = data.writeSequenceable(sequenceable); 5630 console.log("RpcClient: writeSequenceable is " + result); 5631 let ret = new MySequenceable(0, ""); 5632 let result2 = data.readSequenceable(ret); 5633 console.log("RpcClient: readSequenceable is " + result2); 5634 ``` 5635 5636## IRemoteBroker 5637 5638远端对象的代理持有者。用于获取代理对象。 5639 5640### asObject 5641 5642asObject(): IRemoteObject 5643 5644需派生类实现，获取代理或远端对象。 5645 5646**系统能力**：SystemCapability.Communication.IPC.Core 5647 5648**返回值：** 5649 5650 | 类型 | 说明 | 5651 | ----- | ----- | 5652 | [IRemoteObject](#iremoteobject) | 如果调用者是RemoteObject对象，则直接返回本身；如果调用者是[RemoteProxy](#remoteproxy)对象，则返回它的持有者[IRemoteObject](#iremoteobject)。 | 5653 5654**示例：** 5655 5656 ```ts 5657 class TestAbility extends rpc.RemoteObject { 5658 asObject() { 5659 return this; 5660 } 5661 } 5662 let remoteObject = new TestAbility("testObject").asObject(); 5663 ``` 5664 5665**示例：** 5666 5667 Stage模型的应用在获取服务前需要先获取context，具体方法可参考[获取context](#获取context) 5668 5669 ```ts 5670 // 仅FA模型需要导入@ohos.ability.featureAbility 5671 // import FA from "@ohos.ability.featureAbility"; 5672 5673 let proxy; 5674 let connect = { 5675 onConnect: function(elementName, remoteProxy) { 5676 console.log("RpcClient: js onConnect called."); 5677 proxy = remoteProxy; 5678 }, 5679 onDisconnect: function(elementName) { 5680 console.log("RpcClient: onDisconnect"); 5681 }, 5682 onFailed: function() { 5683 console.log("RpcClient: onFailed"); 5684 } 5685 }; 5686 let want = { 5687 "bundleName": "com.ohos.server", 5688 "abilityName": "com.ohos.server.EntryAbility", 5689 }; 5690 5691 // FA模型使用此方法连接服务 5692 // FA.connectAbility(want,connect); 5693 5694 globalThis.context.connectServiceExtensionAbility(want, connect); 5695 ``` 5696 5697 上述onConnect回调函数中的proxy对象需要等ability异步连接成功后才会被赋值，然后才可调用proxy对象的asObject接口方法获取代理或远端对象 5698 5699 ```ts 5700 class TestProxy { 5701 remote: rpc.RemoteObject; 5702 constructor(remote) { 5703 this.remote = remote; 5704 } 5705 asObject() { 5706 return this.remote; 5707 } 5708 } 5709 let iRemoteObject = new TestProxy(proxy).asObject(); 5710 ``` 5711 5712## DeathRecipient 5713 5714用于订阅远端对象的死亡通知。当被订阅该通知的远端对象死亡时，本端可收到消息，调用[onRemoteDied](#onremotedied)接口。远端对象死亡可以为远端对象所在进程死亡，远端对象所在设备关机或重启，当远端对象与本端对象属于不同设备时，也可为远端对象离开组网时。 5715 5716### onRemoteDied 5717 5718onRemoteDied(): void 5719 5720在成功添加死亡通知订阅后，当远端对象死亡时，将自动调用本方法。 5721 5722**系统能力**：SystemCapability.Communication.IPC.Core 5723 5724**示例：** 5725 5726 ```ts 5727 class MyDeathRecipient { 5728 onRemoteDied() { 5729 console.log("server died"); 5730 } 5731 } 5732 ``` 5733 5734## RequestResult<sup>9+</sup> 5735 5736发送请求的响应结果。 5737 5738**系统能力**：以下各项对应的系统能力均为SystemCapability.Communication.IPC.Core。 5739 5740 | 名称 | 类型 | 可读 | 可写 | 说明 | 5741 | ------- | --------------- | ---- | ---- |-------------------------------------- | 5742 | errCode | number | 是 | 否 | 错误码。 | 5743 | code | number | 是 | 否 | 消息代码。 | 5744 | data | MessageSequence | 是 | 否 | 发送给对端进程的MessageSequence对象。 | 5745 | reply | MessageSequence | 是 | 否 | 对端进程返回的MessageSequence对象。 | 5746 5747## SendRequestResult<sup>8+(deprecated)</sup> 5748 5749>从API version 9 开始不再维护，建议使用[RequestResult](#requestresult9)类替代。 5750 5751发送请求的响应结果。 5752 5753**系统能力**：以下各项对应的系统能力均为SystemCapability.Communication.IPC.Core。 5754 5755 | 名称 | 类型 | 可读 | 可写 | 说明 | 5756 | ------- | ------------- | ---- | ---- | ----------------------------------- | 5757 | errCode | number | 是 | 否 | 错误码。 | 5758 | code | number | 是 | 否 | 消息代码。 | 5759 | data | MessageParcel | 是 | 否 | 发送给对端进程的MessageParcel对象。 | 5760 | reply | MessageParcel | 是 | 否 | 对端进程返回的MessageParcel对象。 | 5761 5762## IRemoteObject 5763 5764该接口可用于查询或获取接口描述符、添加或删除死亡通知、转储对象状态到特定文件、发送消息。 5765 5766### getLocalInterface<sup>9+</sup> 5767 5768getLocalInterface(descriptor: string): IRemoteBroker 5769 5770查询接口描述符的字符串。 5771 5772**系统能力**：SystemCapability.Communication.IPC.Core 5773 5774**参数：** 5775 5776 | 参数名 | 类型 | 必填 | 说明 | 5777 | ---------- | ------ | ---- | -------------------- | 5778 | descriptor | string | 是 | 接口描述符的字符串。 | 5779 5780**返回值：** 5781 5782 | 类型 | 说明 | 5783 | ------------- | --------------------------------------------- | 5784 | IRemoteBroker | 返回绑定到指定接口描述符的IRemoteBroker对象。 | 5785 5786### queryLocalInterface<sup>(deprecated)</sup> 5787 5788>从API version 9 开始不再维护，建议使用[getLocalInterface](#getlocalinterface9)类替代。 5789 5790queryLocalInterface(descriptor: string): IRemoteBroker 5791 5792查询接口描述符的字符串。 5793 5794**系统能力**：SystemCapability.Communication.IPC.Core 5795 5796**参数：** 5797 5798 | 参数名 | 类型 | 必填 | 说明 | 5799 | ---------- | ------ | ---- | -------------------- | 5800 | descriptor | string | 是 | 接口描述符的字符串。 | 5801 5802**返回值：** 5803 5804 | 类型 | 说明 | 5805 | ------------- | --------------------------------------------- | 5806 | IRemoteBroker | 返回绑定到指定接口描述符的IRemoteBroker对象。 | 5807 5808### sendRequest<sup>(deprecated)</sup> 5809 5810>从API version 9 开始不再维护，建议使用[sendMessageRequest](#sendmessagerequest9)类替代。 5811 5812sendRequest(code: number, data: MessageParcel, reply: MessageParcel, options: MessageOption): boolean 5813 5814以同步或异步方式向对端进程发送MessageParcel消息。如果为选项设置了异步模式，则期约立即兑现，reply报文里没有内容。如果为选项设置了同步模式，则期约将在sendRequest返回时兑现，回复内容在reply报文里。 5815 5816**系统能力**：SystemCapability.Communication.IPC.Core 5817 5818**参数：** 5819 5820 | 参数名 | 类型 | 必填 | 说明 | 5821 | ------- | ----------------------------------------- | ---- | -------------------------------------------------------------------------------------- | 5822 | code | number | 是 | 本次请求调用的消息码（1-16777215），由通信双方确定。如果接口由IDL工具生成，则消息代码由IDL自动生成。 | 5823 | data | [MessageParcel](#messageparceldeprecated) | 是 | 保存待发送数据的 MessageParcel对象。 | 5824 | reply | [MessageParcel](#messageparceldeprecated) | 是 | 接收应答数据的MessageParcel对象。 | 5825 | options | [MessageOption](#messageoption) | 是 | 本次请求的同异步模式，默认同步调用。 | 5826 5827**返回值：** 5828 5829 | 类型 | 说明 | 5830 | ------- | -------------------------------- | 5831 | boolean | true：发送成功，false：发送失败。| 5832 5833### sendRequest<sup>8+(deprecated)</sup> 5834 5835>从API version 9 开始不再维护，建议使用[sendMessageRequest](#sendmessagerequest9)类替代。 5836 5837sendRequest(code: number, data: MessageParcel, reply: MessageParcel, options: MessageOption): Promise<SendRequestResult> 5838 5839以同步或异步方式向对端进程发送MessageParcel消息。如果为选项设置了异步模式，则期约立即兑现，reply报文里没有内容，具体回复需要在业务侧的回调中获取。如果为选项设置了同步模式，则期约将在sendRequest返回时兑现，回复内容在reply报文里。 5840 5841**系统能力**：SystemCapability.Communication.IPC.Core 5842 5843**参数：** 5844 5845 | 参数名 | 类型 | 必填 | 说明 | 5846 | ------- | ---------------------------------------- | ---- | -------------------------------------------------------------------------------------- | 5847 | code | number | 是 | 本次请求调用的消息码（1-16777215），由通信双方确定。如果接口由IDL工具生成，则消息代码由IDL自动生成。 | 5848 | data | [MessageParcel](#messageparceldeprecated) | 是 | 保存待发送数据的 MessageParcel对象。 | 5849 | reply | [MessageParcel](#messageparceldeprecated) | 是 | 接收应答数据的MessageParcel对象。 | 5850 | options | [MessageOption](#messageoption) | 是 | 本次请求的同异步模式，默认同步调用。 | 5851 5852**返回值：** 5853 5854 | 类型 | 说明 | 5855 | -------------------------------- | --------------------------------------------- | 5856 | Promise<SendRequestResult> | 返回一个期约，兑现值是sendRequestResult实例。 | 5857 5858### sendMessageRequest<sup>9+</sup> 5859 5860sendMessageRequest(code: number, data: MessageSequence, reply: MessageSequence, options: MessageOption): Promise<RequestResult> 5861 5862以同步或异步方式向对端进程发送MessageSequence消息。如果为选项设置了异步模式，则期约立即兑现，reply报文里没有内容，具体回复需要在业务侧的回调中获取。如果为选项设置了同步模式，则期约将在sendMessageRequest返回时兑现，回复内容在reply报文里。 5863 5864**系统能力**：SystemCapability.Communication.IPC.Core 5865 5866**参数：** 5867 5868 | 参数名 | 类型 | 必填 | 说明 | 5869 | ------- | ------------------------------------ | ---- | -------------------------------------------------------------------------------------- | 5870 | code | number | 是 | 本次请求调用的消息码（1-16777215），由通信双方确定。如果接口由IDL工具生成，则消息代码由IDL自动生成。 | 5871 | data | [MessageSequence](#messagesequence9) | 是 | 保存待发送数据的 MessageSequence对象。 | 5872 | reply | [MessageSequence](#messagesequence9) | 是 | 接收应答数据的MessageSequence对象。 | 5873 | options | [MessageOption](#messageoption) | 是 | 本次请求的同异步模式，默认同步调用。 | 5874 5875**返回值：** 5876 5877 | 类型 | 说明 | 5878 | ---------------------------- | ----------------------------------------- | 5879 | Promise<RequestResult> | 返回一个期约，兑现值是requestResult实例。 | 5880 5881### sendMessageRequest<sup>9+</sup> 5882 5883sendMessageRequest(code: number, data: MessageSequence, reply: MessageSequence, options: MessageOption, callback: AsyncCallback<RequestResult>): void 5884 5885以同步或异步方式向对端进程发送MessageSequence消息。如果为选项设置了异步模式，则立即收到回调，reply报文里没有内容，具体回复需要在业务侧的回调中获取。如果为选项设置了同步模式，则将在sendRequest返回时收到回调，回复内容在reply报文里。 5886 5887**系统能力**：SystemCapability.Communication.IPC.Core 5888 5889**参数：** 5890 5891 | 参数名 | 类型 | 必填 | 说明 | 5892 | -------- | ------------------------------------ | ---- | -------------------------------------------------------------------------------------- | 5893 | code | number | 是 | 本次请求调用的消息码（1-16777215），由通信双方确定。如果接口由IDL工具生成，则消息代码由IDL自动生成。 | 5894 | data | [MessageSequence](#messagesequence9) | 是 | 保存待发送数据的 MessageSequence对象。 | 5895 | reply | [MessageSequence](#messagesequence9) | 是 | 接收应答数据的MessageSequence对象。 | 5896 | options | [MessageOption](#messageoption) | 是 | 本次请求的同异步模式，默认同步调用。 | 5897 | callback | AsyncCallback<RequestResult> | 是 | 接收发送结果的回调。 | 5898 5899### sendRequest<sup>8+(deprecated)</sup> 5900 5901>从API version 9 开始不再维护，建议使用[sendMessageRequest](#sendmessagerequest9)类替代。 5902 5903sendRequest(code: number, data: MessageParcel, reply: MessageParcel, options: MessageOption, callback: AsyncCallback<SendRequestResult>): void 5904 5905以同步或异步方式向对端进程发送MessageParcel消息。如果为选项设置了异步模式，则立即收到回调，reply报文里没有内容，具体回复需要在业务侧的回调中获取。如果为选项设置了同步模式，则将在sendRequest返回时收到回调，回复内容在reply报文里。 5906 5907**系统能力**：SystemCapability.Communication.IPC.Core 5908 5909**参数：** 5910 5911 | 参数名 | 类型 | 必填 | 说明 | 5912 | -------- | ----------------------------------------- | ---- | -------------------------------------------------------------------------------------- | 5913 | code | number | 是 | 本次请求调用的消息码（1-16777215），由通信双方确定。如果接口由IDL工具生成，则消息代码由IDL自动生成。 | 5914 | data | [MessageParcel](#messageparceldeprecated) | 是 | 保存待发送数据的 MessageParcel对象。 | 5915 | reply | [MessageParcel](#messageparceldeprecated) | 是 | 接收应答数据的MessageParcel对象。 | 5916 | options | [MessageOption](#messageoption) | 是 | 本次请求的同异步模式，默认同步调用。 | 5917 | callback | AsyncCallback<SendRequestResult> | 是 | 接收发送结果的回调。 | 5918 5919### registerDeathRecipient<sup>9+</sup> 5920 5921registerDeathRecipient(recipient: DeathRecipient, flags: number): void 5922 5923注册用于接收远程对象死亡通知的回调。如果与RemoteProxy对象匹配的远程对象进程死亡，则调用此方法。 5924 5925**系统能力**：SystemCapability.Communication.IPC.Core 5926 5927**参数：** 5928 5929 | 参数名 | 类型 | 必填 | 说明 | 5930 | --------- | --------------------------------- | ---- | -------------- | 5931 | recipient | [DeathRecipient](#deathrecipient) | 是 | 要注册的回调。 | 5932 | flags | number | 是 | 死亡通知标志。 | 5933 5934**错误码：** 5935 5936以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 5937 5938 | 错误码ID | 错误信息 | 5939 | -------- | -------- | 5940 | 1900008 | proxy or remote object is invalid | 5941 5942### addDeathrecipient<sup>(deprecated)</sup> 5943 5944>从API version 9 开始不再维护，建议使用[registerDeathRecipient](#registerdeathrecipient9)类替代。 5945 5946addDeathRecipient(recipient: DeathRecipient, flags: number): boolean 5947 5948注册用于接收远程对象死亡通知的回调。如果与RemoteProxy对象匹配的远程对象进程死亡，则调用此方法。 5949 5950**系统能力**：SystemCapability.Communication.IPC.Core 5951 5952**参数：** 5953 5954 | 参数名 | 类型 | 必填 | 说明 | 5955 | --------- | --------------------------------- | ---- | -------------- | 5956 | recipient | [DeathRecipient](#deathrecipient) | 是 | 要注册的回调。 | 5957 | flags | number | 是 | 死亡通知标志。 | 5958 5959**返回值：** 5960 5961 | 类型 | 说明 | 5962 | ------- | ---------------------------------------- | 5963 | boolean | true：回调注册成功，false：回调注册失败。| 5964 5965### unregisterDeathRecipient<sup>9+</sup> 5966 5967unregisterDeathRecipient(recipient: DeathRecipient, flags: number): void 5968 5969注销用于接收远程对象死亡通知的回调。 5970 5971**系统能力**：SystemCapability.Communication.IPC.Core 5972 5973**参数：** 5974 5975 | 参数名 | 类型 | 必填 | 说明 | 5976 | --------- | --------------------------------- | ---- | -------------- | 5977 | recipient | [DeathRecipient](#deathrecipient) | 是 | 要注销的回调。 | 5978 | flags | number | 是 | 死亡通知标志。 | 5979 5980**错误码：** 5981 5982以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 5983 5984 | 错误码ID | 错误信息 | 5985 | -------- | -------- | 5986 | 1900008 | proxy or remote object is invalid | 5987 5988### removeDeathRecipient<sup>(deprecated)</sup> 5989 5990>从API version 9 开始不再维护，建议使用[unregisterDeathRecipient](#unregisterdeathrecipient9)类替代。 5991 5992removeDeathRecipient(recipient: DeathRecipient, flags: number): boolean 5993 5994注销用于接收远程对象死亡通知的回调。 5995 5996**系统能力**：SystemCapability.Communication.IPC.Core 5997 5998**参数：** 5999 6000 | 参数名 | 类型 | 必填 | 说明 | 6001 | --------- | --------------------------------- | ---- | -------------- | 6002 | recipient | [DeathRecipient](#deathrecipient) | 是 | 要注销的回调。 | 6003 | flags | number | 是 | 死亡通知标志。 | 6004 6005**返回值：** 6006 6007 | 类型 | 说明 | 6008 | ------- | -----------------------------------------| 6009 | boolean | true：回调注销成功，false：回调注销失败。| 6010 6011### getDescriptor<sup>9+</sup> 6012 6013getDescriptor(): string 6014 6015获取对象的接口描述符，接口描述符为字符串。 6016 6017**系统能力**：SystemCapability.Communication.IPC.Core 6018 6019**返回值：** 6020 6021 | 类型 | 说明 | 6022 | ------ | ---------------- | 6023 | string | 返回接口描述符。 | 6024 6025**错误码：** 6026 6027以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 6028 6029 | 错误码ID | 错误信息 | 6030 | -------- | -------- | 6031 | 1900008 | proxy or remote object is invalid | 6032 6033### getInterfaceDescriptor<sup>(deprecated)</sup> 6034 6035>从API version 9 开始不再维护，建议使用[getDescriptor](#getdescriptor9)类替代。 6036 6037getInterfaceDescriptor(): string 6038 6039获取对象的接口描述符，接口描述符为字符串。 6040 6041**系统能力**：SystemCapability.Communication.IPC.Core 6042 6043**返回值：** 6044 6045 | 类型 | 说明 | 6046 | ------ | ---------------- | 6047 | string | 返回接口描述符。 | 6048 6049### isObjectDead 6050 6051isObjectDead(): boolean 6052 6053检查当前对象是否死亡。 6054 6055**系统能力**：SystemCapability.Communication.IPC.Core 6056 6057**返回值：** 6058 6059 | 类型 | 说明 | 6060 | ------- | ---------------------------------- | 6061 | boolean | true：对象死亡，false：对象未死亡。| 6062 6063## RemoteProxy 6064 6065实现IRemoteObject代理对象。 6066 6067**系统能力**：以下各项对应的系统能力均为SystemCapability.Communication.IPC.Core。 6068 6069| 名称 | 值 | 说明 | 6070| --------------------- | ----------------------- | --------------------------------- | 6071| PING_TRANSACTION | 1599098439 (0x5f504e47) | 内部指令码，用于测试IPC服务正常。 | 6072| DUMP_TRANSACTION | 1598311760 (0x5f444d50) | 内部指令码，获取Binder内部状态。 | 6073| INTERFACE_TRANSACTION | 1598968902 (0x5f4e5446) | 内部指令码，获取对端接口描述符。 | 6074| MIN_TRANSACTION_ID | 1 (0x00000001) | 最小有效指令码。 | 6075| MAX_TRANSACTION_ID | 16777215 (0x00FFFFFF) | 最大有效指令码。 | 6076 6077### sendRequest<sup>(deprecated)</sup> 6078 6079>从API version 9 开始不再维护，建议使用[sendMessageRequest](#sendmessagerequest9)类替代。 6080 6081sendRequest(code: number, data: MessageParcel, reply: MessageParcel, options: MessageOption): boolean 6082 6083以同步或异步方式向对端进程发送MessageParcel消息。如果为选项设置了异步模式，则期约立即兑现，reply报文里没有内容，具体回复需要在业务侧的回调中获取。如果为选项设置了同步模式，则期约将在sendRequest返回时兑现，回复内容在reply报文里。 6084 6085**系统能力**：SystemCapability.Communication.IPC.Core 6086 6087**参数：** 6088 6089 | 参数名 | 类型 | 必填 | 说明 | 6090 | ------- | ----------------------------------------- | ---- | -------------------------------------------------------------------------------------- | 6091 | code | number | 是 | 本次请求调用的消息码（1-16777215），由通信双方确定。如果接口由IDL工具生成，则消息代码由IDL自动生成。 | 6092 | data | [MessageParcel](#messageparceldeprecated) | 是 | 保存待发送数据的 MessageParcel对象。 | 6093 | reply | [MessageParcel](#messageparceldeprecated) | 是 | 接收应答数据的MessageParcel对象。 | 6094 | options | [MessageOption](#messageoption) | 是 | 本次请求的同异步模式，默认同步调用。 | 6095 6096**返回值：** 6097 6098 | 类型 | 说明 | 6099 | ------- | ---------------------------------| 6100 | boolean | true：发送成功，false：发送失败。| 6101 6102**示例：** 6103 6104 Stage模型的应用在获取服务前需要先获取context，具体方法可参考[获取context](#获取context) 6105 6106 ```ts 6107 // 仅FA模型需要导入@ohos.ability.featureAbility 6108 // import FA from "@ohos.ability.featureAbility"; 6109 6110 let proxy; 6111 let connect = { 6112 onConnect: function(elementName, remoteProxy) { 6113 console.log("RpcClient: js onConnect called."); 6114 proxy = remoteProxy; 6115 }, 6116 onDisconnect: function(elementName) { 6117 console.log("RpcClient: onDisconnect"); 6118 }, 6119 onFailed: function() { 6120 console.log("RpcClient: onFailed"); 6121 } 6122 }; 6123 let want = { 6124 "bundleName": "com.ohos.server", 6125 "abilityName": "com.ohos.server.EntryAbility", 6126 }; 6127 6128 // FA模型使用此方法连接服务 6129 // FA.connectAbility(want,connect); 6130 6131 globalThis.context.connectServiceExtensionAbility(want, connect); 6132 ``` 6133 6134 上述onConnect回调函数中的proxy对象需要等ability异步连接成功后才会被赋值，然后才可调用proxy对象的sendRequest接口方法发送消息 6135 6136 ```ts 6137 let option = new rpc.MessageOption(); 6138 let data = rpc.MessageParcel.create(); 6139 let reply = rpc.MessageParcel.create(); 6140 data.writeInt(1); 6141 data.writeString("hello"); 6142 let ret: boolean = proxy.sendRequest(1, data, reply, option); 6143 if (ret) { 6144 console.log("sendRequest got result"); 6145 let msg = reply.readString(); 6146 console.log("RPCTest: reply msg: " + msg); 6147 } else { 6148 console.log("RPCTest: sendRequest failed"); 6149 } 6150 console.log("RPCTest: sendRequest ends, reclaim parcel"); 6151 data.reclaim(); 6152 reply.reclaim(); 6153 ``` 6154 6155### sendMessageRequest<sup>9+</sup> 6156 6157sendMessageRequest(code: number, data: MessageSequence, reply: MessageSequence, options: MessageOption): Promise<RequestResult> 6158 6159以同步或异步方式向对端进程发送MessageSequence消息。如果为选项设置了异步模式，则期约立即兑现，reply报文里没有内容，具体回复需要在业务侧的回调中获取。如果为选项设置了同步模式，则期约将在sendMessageRequest返回时兑现，回复内容在reply报文里。 6160 6161**系统能力**：SystemCapability.Communication.IPC.Core 6162 6163**参数：** 6164 6165 | 参数名 | 类型 | 必填 | 说明 | 6166 | ------- | ------------------------------------ | ---- | -------------------------------------------------------------------------------------- | 6167 | code | number | 是 | 本次请求调用的消息码（1-16777215），由通信双方确定。如果接口由IDL工具生成，则消息代码由IDL自动生成。 | 6168 | data | [MessageSequence](#messagesequence9) | 是 | 保存待发送数据的 MessageSequence对象。 | 6169 | reply | [MessageSequence](#messagesequence9) | 是 | 接收应答数据的MessageSequence对象。 | 6170 | options | [MessageOption](#messageoption) | 是 | 本次请求的同异步模式，默认同步调用。 | 6171 6172**返回值：** 6173 6174 | 类型 | 说明 | 6175 | ---------------------------- | ----------------------------------------- | 6176 | Promise<RequestResult> | 返回一个期约，兑现值是requestResult实例。 | 6177 6178**示例：** 6179 6180 Stage模型的应用在获取服务前需要先获取context，具体方法可参考[获取context](#获取context) 6181 6182 ```ts 6183 // 仅FA模型需要导入@ohos.ability.featureAbility 6184 // import FA from "@ohos.ability.featureAbility"; 6185 6186 let proxy; 6187 let connect = { 6188 onConnect: function(elementName, remoteProxy) { 6189 console.log("RpcClient: js onConnect called."); 6190 proxy = remoteProxy; 6191 }, 6192 onDisconnect: function(elementName) { 6193 console.log("RpcClient: onDisconnect"); 6194 }, 6195 onFailed: function() { 6196 console.log("RpcClient: onFailed"); 6197 } 6198 }; 6199 let want = { 6200 "bundleName": "com.ohos.server", 6201 "abilityName": "com.ohos.server.EntryAbility", 6202 }; 6203 6204 // FA模型使用此方法连接服务 6205 // FA.connectAbility(want,connect); 6206 6207 globalThis.context.connectServiceExtensionAbility(want, connect); 6208 ``` 6209 6210 上述onConnect回调函数中的proxy对象需要等ability异步连接成功后才会被赋值，然后才可调用proxy对象的sendMessageRequest接口方法发送消息 6211 6212 ```ts 6213 let option = new rpc.MessageOption(); 6214 let data = rpc.MessageSequence.create(); 6215 let reply = rpc.MessageSequence.create(); 6216 data.writeInt(1); 6217 data.writeString("hello"); 6218 proxy.sendMessageRequest(1, data, reply, option) 6219 .then(function(result) { 6220 if (result.errCode === 0) { 6221 console.log("sendMessageRequest got result"); 6222 result.reply.readException(); 6223 let msg = result.reply.readString(); 6224 console.log("RPCTest: reply msg: " + msg); 6225 } else { 6226 console.log("RPCTest: sendMessageRequest failed, errCode: " + result.errCode); 6227 } 6228 }).catch(function(e) { 6229 console.log("RPCTest: sendMessageRequest got exception: " + e.message); 6230 }).finally (() => { 6231 console.log("RPCTest: sendMessageRequest ends, reclaim parcel"); 6232 data.reclaim(); 6233 reply.reclaim(); 6234 }); 6235 ``` 6236 6237### sendRequest<sup>8+(deprecated)</sup> 6238 6239>从API version 9 开始不再维护，建议使用[sendMessageRequest](#sendmessagerequest9)类替代。 6240 6241sendRequest(code: number, data: MessageParcel, reply: MessageParcel, options: MessageOption): Promise<SendRequestResult> 6242 6243以同步或异步方式向对端进程发送MessageParcel消息。如果为选项设置了异步模式，则期约立即兑现，reply报文里没有内容，具体回复需要在业务侧的回调中获取。如果为选项设置了同步模式，则期约将在sendRequest返回时兑现，回复内容在reply报文里。 6244 6245**系统能力**：SystemCapability.Communication.IPC.Core 6246 6247**参数：** 6248 6249 | 参数名 | 类型 | 必填 | 说明 | 6250 | ------- | ----------------------------------------- | ---- | -------------------------------------------------------------------------------------- | 6251 | code | number | 是 | 本次请求调用的消息码（1-16777215），由通信双方确定。如果接口由IDL工具生成，则消息代码由IDL自动生成。 | 6252 | data | [MessageParcel](#messageparceldeprecated) | 是 | 保存待发送数据的 MessageParcel对象。 | 6253 | reply | [MessageParcel](#messageparceldeprecated) | 是 | 接收应答数据的MessageParcel对象。 | 6254 | options | [MessageOption](#messageoption) | 是 | 本次请求的同异步模式，默认同步调用。 | 6255 6256**返回值：** 6257 6258 | 类型 | 说明 | 6259 | -------------------------------- | --------------------------------------------- | 6260 | Promise<SendRequestResult> | 返回一个期约，兑现值是sendRequestResult实例。 | 6261 6262**示例：** 6263 6264 Stage模型的应用在获取服务前需要先获取context，具体方法可参考[获取context](#获取context) 6265 6266 ```ts 6267 // 仅FA模型需要导入@ohos.ability.featureAbility 6268 // import FA from "@ohos.ability.featureAbility"; 6269 6270 let proxy; 6271 let connect = { 6272 onConnect: function(elementName, remoteProxy) { 6273 console.log("RpcClient: js onConnect called."); 6274 proxy = remoteProxy; 6275 }, 6276 onDisconnect: function(elementName) { 6277 console.log("RpcClient: onDisconnect"); 6278 }, 6279 onFailed: function() { 6280 console.log("RpcClient: onFailed"); 6281 } 6282 }; 6283 let want = { 6284 "bundleName": "com.ohos.server", 6285 "abilityName": "com.ohos.server.EntryAbility", 6286 }; 6287 6288 // FA模型使用此方法连接服务 6289 // FA.connectAbility(want,connect); 6290 6291 globalThis.context.connectServiceExtensionAbility(want, connect); 6292 ``` 6293 6294 上述onConnect回调函数中的proxy对象需要等ability异步连接成功后才会被赋值，然后才可调用proxy对象的sendRequest接口方法发送消息 6295 6296 ```ts 6297 let option = new rpc.MessageOption(); 6298 let data = rpc.MessageParcel.create(); 6299 let reply = rpc.MessageParcel.create(); 6300 data.writeInt(1); 6301 data.writeString("hello"); 6302 proxy.sendRequest(1, data, reply, option) 6303 .then(function(result) { 6304 if (result.errCode === 0) { 6305 console.log("sendRequest got result"); 6306 result.reply.readException(); 6307 let msg = result.reply.readString(); 6308 console.log("RPCTest: reply msg: " + msg); 6309 } else { 6310 console.log("RPCTest: sendRequest failed, errCode: " + result.errCode); 6311 } 6312 }).catch(function(e) { 6313 console.log("RPCTest: sendRequest got exception: " + e.message); 6314 }).finally (() => { 6315 console.log("RPCTest: sendRequest ends, reclaim parcel"); 6316 data.reclaim(); 6317 reply.reclaim(); 6318 }); 6319 ``` 6320 6321### sendMessageRequest<sup>9+</sup> 6322 6323sendMessageRequest(code: number, data: MessageSequence, reply: MessageSequence, options: MessageOption, callback: AsyncCallback<RequestResult>): void 6324 6325以同步或异步方式向对端进程发送MessageSequence消息。如果为选项设置了异步模式，则立即收到回调，reply报文里没有内容，具体回复需要在业务侧的回调中获取。如果为选项设置了同步模式，则将在sendMessageRequest返回后的某个时机执行回调，回复内容在RequestResult的reply报文里。 6326 6327**系统能力**：SystemCapability.Communication.IPC.Core 6328 6329**参数：** 6330 6331 | 参数名 | 类型 | 必填 | 说明 | 6332 | -------- | ------------------------------------ | ---- | -------------------------------------------------------------------------------------- | 6333 | code | number | 是 | 本次请求调用的消息码（1-16777215），由通信双方确定。如果接口由IDL工具生成，则消息代码由IDL自动生成。 | 6334 | data | [MessageSequence](#messagesequence9) | 是 | 保存待发送数据的 MessageSequence对象。 | 6335 | reply | [MessageSequence](#messagesequence9) | 是 | 接收应答数据的MessageSequence对象。 | 6336 | options | [MessageOption](#messageoption) | 是 | 本次请求的同异步模式，默认同步调用。 | 6337 | callback | AsyncCallback<RequestResult> | 是 | 接收发送结果的回调。 | 6338 6339**示例：** 6340 6341 Stage模型的应用在获取服务前需要先获取context，具体方法可参考[获取context](#获取context) 6342 6343 ```ts 6344 // 仅FA模型需要导入@ohos.ability.featureAbility 6345 // import FA from "@ohos.ability.featureAbility"; 6346 6347 let proxy; 6348 let connect = { 6349 onConnect: function(elementName, remoteProxy) { 6350 console.log("RpcClient: js onConnect called."); 6351 proxy = remoteProxy; 6352 }, 6353 onDisconnect: function(elementName) { 6354 console.log("RpcClient: onDisconnect"); 6355 }, 6356 onFailed: function() { 6357 console.log("RpcClient: onFailed"); 6358 } 6359 }; 6360 let want = { 6361 "bundleName": "com.ohos.server", 6362 "abilityName": "com.ohos.server.EntryAbility", 6363 }; 6364 function sendRequestCallback(result) { 6365 if (result.errCode === 0) { 6366 console.log("sendRequest got result"); 6367 result.reply.readException(); 6368 let msg = result.reply.readString(); 6369 console.log("RPCTest: reply msg: " + msg); 6370 } else { 6371 console.log("RPCTest: sendRequest failed, errCode: " + result.errCode); 6372 } 6373 console.log("RPCTest: sendRequest ends, reclaim parcel"); 6374 result.data.reclaim(); 6375 result.reply.reclaim(); 6376 } 6377 6378 // FA模型使用此方法连接服务 6379 // FA.connectAbility(want,connect); 6380 6381 globalThis.context.connectServiceExtensionAbility(want, connect); 6382 ``` 6383 6384 上述onConnect回调函数中的proxy对象需要等ability异步连接成功后才会被赋值，然后才可调用proxy对象的sendMessageRequest接口方法发送消息 6385 6386 ```ts 6387 let option = new rpc.MessageOption(); 6388 let data = rpc.MessageSequence.create(); 6389 let reply = rpc.MessageSequence.create(); 6390 data.writeInt(1); 6391 data.writeString("hello"); 6392 try { 6393 proxy.sendMessageRequest(1, data, reply, option, sendRequestCallback); 6394 } catch(error) { 6395 console.info("rpc send sequence request fail, errorCode " + error.code); 6396 console.info("rpc send sequence request fail, errorMessage " + error.message); 6397 } 6398 ``` 6399 6400### sendRequest<sup>8+(deprecated)</sup> 6401 6402>从API version 9 开始不再维护，建议使用[sendMessageRequest](#sendmessagerequest9)类替代。 6403 6404sendRequest(code: number, data: MessageParcel, reply: MessageParcel, options: MessageOption, callback: AsyncCallback<SendRequestResult>): void 6405 6406以同步或异步方式向对端进程发送MessageParcel消息。如果为选项设置了异步模式，则立即收到回调，reply报文里没有内容，具体回复需要在业务侧的回调中获取。如果为选项设置了同步模式，则将在sendRequest返回时收到回调，回复内容在reply报文里。 6407 6408**系统能力**：SystemCapability.Communication.IPC.Core 6409 6410**参数：** 6411 6412 | 参数名 | 类型 | 必填 | 说明 | 6413 | -------- | ----------------------------------------- | ---- | -------------------------------------------------------------------------------------- | 6414 | code | number | 是 | 本次请求调用的消息码（1-16777215），由通信双方确定。如果接口由IDL工具生成，则消息代码由IDL自动生成。 | 6415 | data | [MessageParcel](#messageparceldeprecated) | 是 | 保存待发送数据的 MessageParcel对象。 | 6416 | reply | [MessageParcel](#messageparceldeprecated) | 是 | 接收应答数据的MessageParcel对象。 | 6417 | options | [MessageOption](#messageoption) | 是 | 本次请求的同异步模式，默认同步调用。 | 6418 | callback | AsyncCallback<SendRequestResult> | 是 | 接收发送结果的回调。 | 6419 6420**示例：** 6421 6422 Stage模型的应用在获取服务前需要先获取context，具体方法可参考[获取context](#获取context) 6423 6424 ```ts 6425 // 仅FA模型需要导入@ohos.ability.featureAbility 6426 // import FA from "@ohos.ability.featureAbility"; 6427 6428 let proxy; 6429 let connect = { 6430 onConnect: function(elementName, remoteProxy) { 6431 console.log("RpcClient: js onConnect called."); 6432 proxy = remoteProxy; 6433 }, 6434 onDisconnect: function(elementName) { 6435 console.log("RpcClient: onDisconnect"); 6436 }, 6437 onFailed: function() { 6438 console.log("RpcClient: onFailed"); 6439 } 6440 }; 6441 let want = { 6442 "bundleName": "com.ohos.server", 6443 "abilityName": "com.ohos.server.EntryAbility", 6444 }; 6445 function sendRequestCallback(result) { 6446 if (result.errCode === 0) { 6447 console.log("sendRequest got result"); 6448 result.reply.readException(); 6449 let msg = result.reply.readString(); 6450 console.log("RPCTest: reply msg: " + msg); 6451 } else { 6452 console.log("RPCTest: sendRequest failed, errCode: " + result.errCode); 6453 } 6454 console.log("RPCTest: sendRequest ends, reclaim parcel"); 6455 result.data.reclaim(); 6456 result.reply.reclaim(); 6457 } 6458 6459 // FA模型使用此方法连接服务 6460 // FA.connectAbility(want,connect); 6461 6462 globalThis.context.connectServiceExtensionAbility(want, connect); 6463 ``` 6464 6465 上述onConnect回调函数中的proxy对象需要等ability异步连接成功后才会被赋值，然后才可调用proxy对象的sendRequest接口方法发送消息 6466 6467 ```ts 6468 let option = new rpc.MessageOption(); 6469 let data = rpc.MessageParcel.create(); 6470 let reply = rpc.MessageParcel.create(); 6471 data.writeInt(1); 6472 data.writeString("hello"); 6473 proxy.sendRequest(1, data, reply, option, sendRequestCallback); 6474 ``` 6475 6476### getLocalInterface<sup>9+</sup> 6477 6478getLocalInterface(interface: string): IRemoteBroker 6479 6480查询并获取当前接口描述符对应的本地接口对象。 6481 6482**系统能力**：SystemCapability.Communication.IPC.Core 6483 6484**参数：** 6485 6486 | 参数名 | 类型 | 必填 | 说明 | 6487 | --------- | ------ | ---- | ---------------------- | 6488 | interface | string | 是 | 需要查询的接口描述符。 | 6489 6490**返回值：** 6491 6492 | 类型 | 说明 | 6493 | ------------- | ------------------------------------------ | 6494 | IRemoteBroker | 默认返回Null，标识该接口是一个代理侧接口。 | 6495 6496**错误码：** 6497 6498以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 6499 6500 | 错误码ID | 错误信息 | 6501 | -------- | -------- | 6502 | 1900006 | only remote object permitted | 6503 6504**示例：** 6505 6506 Stage模型的应用在获取服务前需要先获取context，具体方法可参考[获取context](#获取context) 6507 6508 ```ts 6509 // 仅FA模型需要导入@ohos.ability.featureAbility 6510 // import FA from "@ohos.ability.featureAbility"; 6511 6512 let proxy; 6513 let connect = { 6514 onConnect: function(elementName, remoteProxy) { 6515 console.log("RpcClient: js onConnect called."); 6516 proxy = remoteProxy; 6517 }, 6518 onDisconnect: function(elementName) { 6519 console.log("RpcClient: onDisconnect"); 6520 }, 6521 onFailed: function() { 6522 console.log("RpcClient: onFailed"); 6523 } 6524 }; 6525 let want = { 6526 "bundleName": "com.ohos.server", 6527 "abilityName": "com.ohos.server.EntryAbility", 6528 }; 6529 6530 // FA模型使用此方法连接服务 6531 // FA.connectAbility(want,connect); 6532 6533 globalThis.context.connectServiceExtensionAbility(want, connect); 6534 ``` 6535 6536 上述onConnect回调函数中的proxy对象需要等ability异步连接成功后才会被赋值，然后才可调用proxy对象的getLocalInterface接口方法查询接口对象 6537 6538 ```ts 6539 try { 6540 let broker = proxy.getLocalInterface("testObject"); 6541 console.log("RpcClient: getLocalInterface is " + broker); 6542 } catch(error) { 6543 console.info("rpc get local interface fail, errorCode " + error.code); 6544 console.info("rpc get local interface fail, errorMessage " + error.message); 6545 } 6546 ``` 6547 6548### queryLocalInterface<sup>(deprecated)</sup> 6549 6550>从API version 9 开始不再维护，建议使用[getLocalInterface](#getlocalinterface9)类替代。 6551 6552queryLocalInterface(interface: string): IRemoteBroker 6553 6554查询并获取当前接口描述符对应的本地接口对象。 6555 6556**系统能力**：SystemCapability.Communication.IPC.Core 6557 6558**参数：** 6559 6560 | 参数名 | 类型 | 必填 | 说明 | 6561 | --------- | ------ | ---- | ---------------------- | 6562 | interface | string | 是 | 需要查询的接口描述符。 | 6563 6564**返回值：** 6565 6566 | 类型 | 说明 | 6567 | ------------- | ------------------------------------------ | 6568 | IRemoteBroker | 默认返回Null，标识该接口是一个代理侧接口。 | 6569 6570**示例：** 6571 6572 Stage模型的应用在获取服务前需要先获取context，具体方法可参考[获取context](#获取context) 6573 6574 ```ts 6575 // 仅FA模型需要导入@ohos.ability.featureAbility 6576 // import FA from "@ohos.ability.featureAbility"; 6577 6578 let proxy; 6579 let connect = { 6580 onConnect: function(elementName, remoteProxy) { 6581 console.log("RpcClient: js onConnect called."); 6582 proxy = remoteProxy; 6583 }, 6584 onDisconnect: function(elementName) { 6585 console.log("RpcClient: onDisconnect"); 6586 }, 6587 onFailed: function() { 6588 console.log("RpcClient: onFailed"); 6589 } 6590 }; 6591 let want = { 6592 "bundleName": "com.ohos.server", 6593 "abilityName": "com.ohos.server.EntryAbility", 6594 }; 6595 6596 // FA模型使用此方法连接服务 6597 // FA.connectAbility(want,connect); 6598 6599 globalThis.context.connectServiceExtensionAbility(want, connect); 6600 ``` 6601 6602 上述onConnect回调函数中的proxy对象需要等ability异步连接成功后才会被赋值，然后才可调用proxy对象的queryLocalInterface接口获取接口对象 6603 6604 ```ts 6605 let broker = proxy.queryLocalInterface("testObject"); 6606 console.log("RpcClient: queryLocalInterface is " + broker); 6607 ``` 6608 6609### registerDeathRecipient<sup>9+</sup> 6610 6611registerDeathRecipient(recipient: DeathRecipient, flags: number): void 6612 6613注册用于接收远程对象死亡通知的回调。如果与RemoteProxy对象匹配的远程对象进程死亡，则调用此方法。 6614 6615**系统能力**：SystemCapability.Communication.IPC.Core 6616 6617**参数：** 6618 6619 | 参数名 | 类型 | 必填 | 说明 | 6620 | --------- | --------------------------------- | ---- | -------------- | 6621 | recipient | [DeathRecipient](#deathrecipient) | 是 | 要注册的回调。 | 6622 | flags | number | 是 | 死亡通知标志。 | 6623 6624**错误码：** 6625 6626以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 6627 6628 | 错误码ID | 错误信息 | 6629 | -------- | -------- | 6630 | 1900008 | proxy or remote object is invalid | 6631 6632**示例：** 6633 6634 Stage模型的应用在获取服务前需要先获取context，具体方法可参考[获取context](#获取context) 6635 6636 ```ts 6637 // 仅FA模型需要导入@ohos.ability.featureAbility 6638 // import FA from "@ohos.ability.featureAbility"; 6639 6640 let proxy; 6641 let connect = { 6642 onConnect: function(elementName, remoteProxy) { 6643 console.log("RpcClient: js onConnect called."); 6644 proxy = remoteProxy; 6645 }, 6646 onDisconnect: function(elementName) { 6647 console.log("RpcClient: onDisconnect"); 6648 }, 6649 onFailed: function() { 6650 console.log("RpcClient: onFailed"); 6651 } 6652 }; 6653 let want = { 6654 "bundleName": "com.ohos.server", 6655 "abilityName": "com.ohos.server.EntryAbility", 6656 }; 6657 6658 // FA模型使用此方法连接服务 6659 // FA.connectAbility(want,connect); 6660 6661 globalThis.context.connectServiceExtensionAbility(want, connect); 6662 ``` 6663 6664 上述onConnect回调函数中的proxy对象需要等ability异步连接成功后才会被赋值，然后才可调用proxy对象的registerDeathRecipient接口注册死亡回调 6665 6666 ```ts 6667 class MyDeathRecipient { 6668 onRemoteDied() { 6669 console.log("server died"); 6670 } 6671 } 6672 let deathRecipient = new MyDeathRecipient(); 6673 try { 6674 proxy.registerDeathRecipient(deathRecipient, 0); 6675 } catch(error) { 6676 console.info("proxy register deathRecipient fail, errorCode " + error.code); 6677 console.info("proxy register deathRecipient fail, errorMessage " + error.message); 6678 } 6679 ``` 6680 6681### addDeathRecipient<sup>(deprecated)</sup> 6682 6683>从API version 9 开始不再维护，建议使用[registerDeathRecipient](#registerdeathrecipient9)类替代。 6684 6685addDeathRecipient(recipient: DeathRecipient, flags: number): boolean 6686 6687注册用于接收远程对象死亡通知的回调，增加proxy对象上的死亡通知。 6688 6689**系统能力**：SystemCapability.Communication.IPC.Core 6690 6691**参数：** 6692 6693 | 参数名 | 类型 | 必填 | 说明 | 6694 | --------- | --------------------------------- | ---- | --------------------------------- | 6695 | recipient | [DeathRecipient](#deathrecipient) | 是 | 收件人表示要注册的回调。 | 6696 | flags | number | 是 | 死亡通知标志。保留参数。设置为0。 | 6697 6698**返回值：** 6699 6700 | 类型 | 说明 | 6701 | ------- | ---------------------------------------- | 6702 | boolean | true：回调注册成功，false：回调注册失败。| 6703 6704**示例：** 6705 6706 Stage模型的应用在获取服务前需要先获取context，具体方法可参考[获取context](#获取context) 6707 6708 ```ts 6709 // 仅FA模型需要导入@ohos.ability.featureAbility 6710 // import FA from "@ohos.ability.featureAbility"; 6711 6712 let proxy; 6713 let connect = { 6714 onConnect: function(elementName, remoteProxy) { 6715 console.log("RpcClient: js onConnect called."); 6716 proxy = remoteProxy; 6717 }, 6718 onDisconnect: function(elementName) { 6719 console.log("RpcClient: onDisconnect"); 6720 }, 6721 onFailed: function() { 6722 console.log("RpcClient: onFailed"); 6723 } 6724 }; 6725 let want = { 6726 "bundleName": "com.ohos.server", 6727 "abilityName": "com.ohos.server.EntryAbility", 6728 }; 6729 6730 // FA模型使用此方法连接服务 6731 // FA.connectAbility(want,connect); 6732 6733 globalThis.context.connectServiceExtensionAbility(want, connect); 6734 ``` 6735 6736 上述onConnect回调函数中的proxy对象需要等ability异步连接成功后才会被赋值，然后才可调用proxy对象的addDeathRecipient接口方法新增死亡回调 6737 6738 ```ts 6739 class MyDeathRecipient { 6740 onRemoteDied() { 6741 console.log("server died"); 6742 } 6743 } 6744 let deathRecipient = new MyDeathRecipient(); 6745 proxy.addDeathRecipient(deathRecipient, 0); 6746 ``` 6747 6748### unregisterDeathRecipient<sup>9+</sup> 6749 6750unregisterDeathRecipient(recipient: DeathRecipient, flags: number): void 6751 6752注销用于接收远程对象死亡通知的回调。 6753 6754**系统能力**：SystemCapability.Communication.IPC.Core 6755 6756**参数：** 6757 6758 | 参数名 | 类型 | 必填 | 说明 | 6759 | --------- | --------------------------------- | ---- | -------------- | 6760 | recipient | [DeathRecipient](#deathrecipient) | 是 | 要注销的回调。 | 6761 | flags | number | 是 | 死亡通知标志。 | 6762 6763**错误码：** 6764 6765以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 6766 6767 | 错误码ID | 错误信息 | 6768 | -------- | -------- | 6769 | 1900008 | proxy or remote object is invalid | 6770 6771**示例：** 6772 6773 Stage模型的应用在获取服务前需要先获取context，具体方法可参考[获取context](#获取context) 6774 6775 ```ts 6776 // 仅FA模型需要导入@ohos.ability.featureAbility 6777 // import FA from "@ohos.ability.featureAbility"; 6778 6779 let proxy; 6780 let connect = { 6781 onConnect: function(elementName, remoteProxy) { 6782 console.log("RpcClient: js onConnect called."); 6783 proxy = remoteProxy; 6784 }, 6785 onDisconnect: function(elementName) { 6786 console.log("RpcClient: onDisconnect"); 6787 }, 6788 onFailed: function() { 6789 console.log("RpcClient: onFailed"); 6790 } 6791 }; 6792 let want = { 6793 "bundleName": "com.ohos.server", 6794 "abilityName": "com.ohos.server.EntryAbility", 6795 }; 6796 6797 // FA模型使用此方法连接服务 6798 // FA.connectAbility(want,connect); 6799 6800 globalThis.context.connectServiceExtensionAbility(want, connect); 6801 ``` 6802 6803 上述onConnect回调函数中的proxy对象需要等ability异步连接成功后才会被赋值，然后才可调用proxy对象的unregisterDeathRecipient接口方法注销死亡回调 6804 6805 ```ts 6806 class MyDeathRecipient { 6807 onRemoteDied() { 6808 console.log("server died"); 6809 } 6810 } 6811 let deathRecipient = new MyDeathRecipient(); 6812 try { 6813 proxy.registerDeathRecipient(deathRecipient, 0); 6814 proxy.unregisterDeathRecipient(deathRecipient, 0); 6815 } catch(error) { 6816 console.info("proxy register deathRecipient fail, errorCode " + error.code); 6817 console.info("proxy register deathRecipient fail, errorMessage " + error.message); 6818 } 6819 ``` 6820 6821### removeDeathRecipient<sup>(deprecated)</sup> 6822 6823>从API version 9 开始不再维护，建议使用[unregisterDeathRecipient](#unregisterdeathrecipient9)类替代。 6824 6825removeDeathRecipient(recipient: DeathRecipient, flags: number): boolean 6826 6827注销用于接收远程对象死亡通知的回调。 6828 6829**系统能力**：SystemCapability.Communication.IPC.Core 6830 6831**参数：** 6832 6833 | 参数名 | 类型 | 必填 | 说明 | 6834 | --------- | --------------------------------- | ---- | --------------------------------- | 6835 | recipient | [DeathRecipient](#deathrecipient) | 是 | 要注销的死亡回调。 | 6836 | flags | number | 是 | 死亡通知标志。保留参数。设置为0。 | 6837 6838**返回值：** 6839 6840 | 类型 | 说明 | 6841 | ------- | ---------------------------------------- | 6842 | boolean | true：回调注销成功，false：回调注销失败。| 6843 6844**示例：** 6845 6846 Stage模型的应用在获取服务前需要先获取context，具体方法可参考[获取context](#获取context) 6847 6848 ```ts 6849 // 仅FA模型需要导入@ohos.ability.featureAbility 6850 // import FA from "@ohos.ability.featureAbility"; 6851 6852 let proxy; 6853 let connect = { 6854 onConnect: function(elementName, remoteProxy) { 6855 console.log("RpcClient: js onConnect called."); 6856 proxy = remoteProxy; 6857 }, 6858 onDisconnect: function(elementName) { 6859 console.log("RpcClient: onDisconnect"); 6860 }, 6861 onFailed: function() { 6862 console.log("RpcClient: onFailed"); 6863 } 6864 }; 6865 let want = { 6866 "bundleName": "com.ohos.server", 6867 "abilityName": "com.ohos.server.EntryAbility", 6868 }; 6869 6870 // FA模型使用此方法连接服务 6871 // FA.connectAbility(want,connect); 6872 6873 globalThis.context.connectServiceExtensionAbility(want, connect); 6874 ``` 6875 6876 上述onConnect回调函数中的proxy对象需要等ability异步连接成功后才会被赋值，然后才可调用proxy对象的removeDeathRecipient接口方法去注册死亡回调 6877 6878 ```ts 6879 class MyDeathRecipient { 6880 onRemoteDied() { 6881 console.log("server died"); 6882 } 6883 } 6884 let deathRecipient = new MyDeathRecipient(); 6885 proxy.addDeathRecipient(deathRecipient, 0); 6886 proxy.removeDeathRecipient(deathRecipient, 0); 6887 ``` 6888 6889### getDescriptor<sup>9+</sup> 6890 6891getDescriptor(): string 6892 6893获取对象的接口描述符，接口描述符为字符串。 6894 6895**系统能力**：SystemCapability.Communication.IPC.Core 6896 6897**返回值：** 6898 6899 | 类型 | 说明 | 6900 | ------ | ---------------- | 6901 | string | 返回接口描述符。 | 6902 6903**错误码：** 6904 6905以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 6906 6907 | 错误码ID | 错误信息 | 6908 | -------- | -------- | 6909 | 1900008 | proxy or remote object is invalid | 6910 | 1900007 | communication failed | 6911 6912**示例：** 6913 6914 Stage模型的应用在获取服务前需要先获取context，具体方法可参考[获取context](#获取context) 6915 6916 ```ts 6917 // 仅FA模型需要导入@ohos.ability.featureAbility 6918 // import FA from "@ohos.ability.featureAbility"; 6919 6920 let proxy; 6921 let connect = { 6922 onConnect: function(elementName, remoteProxy) { 6923 console.log("RpcClient: js onConnect called."); 6924 proxy = remoteProxy; 6925 }, 6926 onDisconnect: function(elementName) { 6927 console.log("RpcClient: onDisconnect"); 6928 }, 6929 onFailed: function() { 6930 console.log("RpcClient: onFailed"); 6931 } 6932 }; 6933 let want = { 6934 "bundleName": "com.ohos.server", 6935 "abilityName": "com.ohos.server.EntryAbility", 6936 }; 6937 6938 // FA模型使用此方法连接服务 6939 // FA.connectAbility(want,connect); 6940 6941 globalThis.context.connectServiceExtensionAbility(want, connect); 6942 ``` 6943 上述onConnect回调函数中的proxy对象需要等ability异步连接成功后才会被赋值，然后才可调用proxy对象的getDescriptor接口方法获取对象的接口描述符 6944 6945 ```ts 6946 try { 6947 let descriptor = proxy.getDescriptor(); 6948 console.log("RpcClient: descriptor is " + descriptor); 6949 } catch(error) { 6950 console.info("rpc get interface descriptor fail, errorCode " + error.code); 6951 console.info("rpc get interface descriptor fail, errorMessage " + error.message); 6952 } 6953 ``` 6954 6955### getInterfaceDescriptor<sup>(deprecated)</sup> 6956 6957>从API version 9 开始不再维护，建议使用[getDescriptor](#getdescriptor9)类替代。 6958 6959getInterfaceDescriptor(): string 6960 6961查询当前代理对象接口的描述符。 6962 6963**系统能力**：SystemCapability.Communication.IPC.Core 6964 6965**返回值：** 6966 6967 | 类型 | 说明 | 6968 | ------ | ------------------ | 6969 | string | 当前的接口描述符。 | 6970 6971**示例：** 6972 6973 Stage模型的应用在获取服务前需要先获取context，具体方法可参考[获取context](#获取context) 6974 6975 ```ts 6976 // 仅FA模型需要导入@ohos.ability.featureAbility 6977 // import FA from "@ohos.ability.featureAbility"; 6978 6979 let proxy; 6980 let connect = { 6981 onConnect: function(elementName, remoteProxy) { 6982 console.log("RpcClient: js onConnect called."); 6983 proxy = remoteProxy; 6984 }, 6985 onDisconnect: function(elementName) { 6986 console.log("RpcClient: onDisconnect"); 6987 }, 6988 onFailed: function() { 6989 console.log("RpcClient: onFailed"); 6990 } 6991 }; 6992 let want = { 6993 "bundleName": "com.ohos.server", 6994 "abilityName": "com.ohos.server.EntryAbility", 6995 }; 6996 6997 // FA模型使用此方法连接服务 6998 // FA.connectAbility(want,connect); 6999 7000 globalThis.context.connectServiceExtensionAbility(want, connect); 7001 ``` 7002 7003 上述onConnect回调函数中的proxy对象需要等ability异步连接成功后才会被赋值，然后才可调用proxy对象的getInterfaceDescriptor接口方法查询当前代理对象接口的描述符 7004 7005 ```ts 7006 let descriptor = proxy.getInterfaceDescriptor(); 7007 console.log("RpcClient: descriptor is " + descriptor); 7008 ``` 7009 7010### isObjectDead 7011 7012isObjectDead(): boolean 7013 7014指示对应的RemoteObject是否死亡。 7015 7016**系统能力**：SystemCapability.Communication.IPC.Core 7017 7018**返回值：** 7019 7020 | 类型 | 说明 | 7021 | ------- | ------------------------------------------------- | 7022 | boolean | true：对应的对象已经死亡，false：对应的对象未死亡 | 7023 7024**示例：** 7025 7026 Stage模型的应用在获取服务前需要先获取context，具体方法可参考[获取context](#获取context) 7027 7028 ```ts 7029 // 仅FA模型需要导入@ohos.ability.featureAbility 7030 // import FA from "@ohos.ability.featureAbility"; 7031 7032 let proxy; 7033 let connect = { 7034 onConnect: function(elementName, remoteProxy) { 7035 console.log("RpcClient: js onConnect called."); 7036 proxy = remoteProxy; 7037 }, 7038 onDisconnect: function(elementName) { 7039 console.log("RpcClient: onDisconnect"); 7040 }, 7041 onFailed: function() { 7042 console.log("RpcClient: onFailed"); 7043 } 7044 }; 7045 let want = { 7046 "bundleName": "com.ohos.server", 7047 "abilityName": "com.ohos.server.EntryAbility", 7048 }; 7049 7050 // FA模型使用此方法连接服务 7051 // FA.connectAbility(want,connect); 7052 7053 globalThis.context.connectServiceExtensionAbility(want, connect); 7054 ``` 7055 7056 上述onConnect回调函数中的proxy对象需要等ability异步连接成功后才会被赋值，然后才可调用proxy对象的isObjectDead接口方法判断当前对象是否已经死亡 7057 7058 ```ts 7059 let isDead = proxy.isObjectDead(); 7060 console.log("RpcClient: isObjectDead is " + isDead); 7061 ``` 7062 7063## MessageOption 7064 7065公共消息选项（int标志，int等待时间），使用标志中指定的标志构造指定的MessageOption对象。 7066 7067**系统能力**：以下各项对应的系统能力均为SystemCapability.Communication.IPC.Core。 7068 7069 | 名称 | 值 | 说明 | 7070 | ------------- | --------- | ----------------------------------------------------------- | 7071 | TF_SYNC | 0 (0x00) | 同步调用标识。 | 7072 | TF_ASYNC | 1 (0x01) | 异步调用标识。 | 7073 | TF_ACCEPT_FDS | 16 (0x10) | 指示sendMessageRequest<sup>9+</sup>接口可以返回文件描述符。 | 7074 | TF_WAIT_TIME | 4 (0x4) | 默认等待时间(单位/秒)。 | 7075 7076### constructor<sup>9+</sup> 7077 7078constructor(async?: boolean); 7079 7080MessageOption构造函数。 7081 7082**系统能力**：SystemCapability.Communication.IPC.Core 7083 7084**参数：** 7085 7086| 参数名 | 类型 | 必填 | 说明 | 7087| ------ | ------- | ---- | -------------------------------------- | 7088| async | boolean | 否 | 同步调用或异步调用标志。默认同步调用。 | 7089 7090**示例：** 7091 7092 ```ts 7093 class TestRemoteObject extends rpc.MessageOption { 7094 constructor(async) { 7095 super(async); 7096 } 7097 } 7098 ``` 7099 7100### constructor 7101 7102constructor(syncFlags?: number, waitTime?: number) 7103 7104MessageOption构造函数。 7105 7106**系统能力**：SystemCapability.Communication.IPC.Core 7107 7108**参数：** 7109 7110 | 参数名 | 类型 | 必填 | 说明 | 7111 | --------- | ------ | ---- | --------------------------------------------- | 7112 | syncFlags | number | 否 | 同步调用或异步调用标志。默认同步调用。 | 7113 | waitTime | number | 否 | 调用rpc最长等待时间。默认 TF_WAIT_TIME。 | 7114 7115**示例：** 7116 7117 ```ts 7118 class TestRemoteObject extends rpc.MessageOption { 7119 constructor(syncFlags,waitTime) { 7120 super(syncFlags,waitTime); 7121 } 7122 } 7123 ``` 7124### isAsync<sup>9+</sup> 7125 7126isAsync(): boolean; 7127 7128获取SendMessageRequest调用中确定同步或是异步的标志。 7129 7130**系统能力**：SystemCapability.Communication.IPC.Core 7131 7132**返回值：** 7133 7134 | 类型 | 说明 | 7135 | ------- | ---------------------------------------- | 7136 | boolean | true：异步调用成功，false：同步调用成功。| 7137 7138**示例：** 7139 7140 ```ts 7141 let option = new rpc.MessageOption(); 7142 let isAsync = option.isAsync(); 7143 ``` 7144 7145### setAsync<sup>9+</sup> 7146 7147setAsync(async: boolean): void; 7148 7149设置SendMessageRequest调用中确定同步或是异步的标志。 7150 7151**系统能力**：SystemCapability.Communication.IPC.Core 7152 7153**示例：** 7154 7155 ```ts 7156 let option = new rpc.MessageOption(); 7157 let setAsync = option.setAsync(true); 7158 console.log("Set synchronization flag"); 7159 ``` 7160 7161### getFlags 7162 7163getFlags(): number 7164 7165获取同步调用或异步调用标志。 7166 7167**系统能力**：SystemCapability.Communication.IPC.Core 7168 7169**返回值：** 7170 7171 | 类型 | 说明 | 7172 | ------ | ------------------------------------ | 7173 | number | 调用成功返回同步调用或异步调用标志。 | 7174 7175**示例：** 7176 7177 ```ts 7178 try { 7179 let option = new rpc.MessageOption(); 7180 console.info("create object successfully."); 7181 let flog = option.getFlags(); 7182 console.info("run getFlags success, flog is " + flog); 7183 option.setFlags(1) 7184 console.info("run setFlags success"); 7185 let flog2 = option.getFlags(); 7186 console.info("run getFlags success, flog2 is " + flog2); 7187 } catch (error) { 7188 console.info("error " + error); 7189 } 7190 ``` 7191 7192### setFlags 7193 7194setFlags(flags: number): void 7195 7196设置同步调用或异步调用标志。 7197 7198**系统能力**：SystemCapability.Communication.IPC.Core 7199 7200**参数：** 7201 7202 | 参数名 | 类型 | 必填 | 说明 | 7203 | ------ | ------ | ---- | ------------------------ | 7204 | flags | number | 是 | 同步调用或异步调用标志。 | 7205 7206**示例：** 7207 7208 ```ts 7209 try { 7210 let option = new rpc.MessageOption(); 7211 option.setFlags(1) 7212 console.info("run setFlags success"); 7213 let flog = option.getFlags(); 7214 console.info("run getFlags success, flog is " + flog); 7215 } catch (error) { 7216 console.info("error " + error); 7217 } 7218 ``` 7219 7220### getWaitTime 7221 7222getWaitTime(): number 7223 7224获取rpc调用的最长等待时间。 7225 7226**系统能力**：SystemCapability.Communication.IPC.Core 7227 7228**返回值：** 7229 7230 | 类型 | 说明 | 7231 | ------ | ----------------- | 7232 | number | rpc最长等待时间。 | 7233 7234**示例：** 7235 7236 ```ts 7237 try { 7238 let option = new rpc.MessageOption(); 7239 let time = option.getWaitTime(); 7240 console.info("run getWaitTime success"); 7241 option.setWaitTime(16); 7242 let time2 = option.getWaitTime(); 7243 console.info("run getWaitTime success, time is " + time); 7244 } catch (error) { 7245 console.info("error " + error); 7246 } 7247 ``` 7248 7249### setWaitTime 7250 7251setWaitTime(waitTime: number): void 7252 7253设置rpc调用最长等待时间。 7254 7255**系统能力**：SystemCapability.Communication.IPC.Core 7256 7257**参数：** 7258 7259 | 参数名 | 类型 | 必填 | 说明 | 7260 | -------- | ------ | ---- | --------------------- | 7261 | waitTime | number | 是 | rpc调用最长等待时间。 | 7262 7263**示例：** 7264 7265 ```ts 7266 try { 7267 let option = new rpc.MessageOption(); 7268 option.setWaitTime(16); 7269 let time = option.getWaitTime(); 7270 console.info("run getWaitTime success, time is " + time); 7271 } catch (error) { 7272 console.info("error " + error); 7273 } 7274 ``` 7275 7276## IPCSkeleton 7277 7278用于获取IPC上下文信息，包括获取UID和PID、获取本端和对端设备ID、检查接口调用是否在同一设备上。 7279 7280### getContextObject 7281 7282static getContextObject(): IRemoteObject 7283 7284静态方法，获取系统能力的管理者。 7285 7286**系统能力**：SystemCapability.Communication.IPC.Core 7287 7288**返回值：** 7289 7290 | 类型 | 说明 | 7291 | ------------------------------- | -------------------- | 7292 | [IRemoteObject](#iremoteobject) | 返回系统能力管理者。 | 7293 7294**示例：** 7295 7296 ```ts 7297 let samgr = rpc.IPCSkeleton.getContextObject(); 7298 console.log("RpcServer: getContextObject result: " + samgr); 7299 ``` 7300 7301### getCallingPid 7302 7303static getCallingPid(): number 7304 7305静态方法，获取调用者的PID。此方法由RemoteObject对象在onRemoteRequest方法中调用，不在IPC上下文环境（onRemoteRequest）中调用则返回本进程的PID。 7306 7307**系统能力**：SystemCapability.Communication.IPC.Core 7308 7309**返回值：** 7310 7311 | 类型 | 说明 | 7312 | ------ | ----------------- | 7313 | number | 返回调用者的PID。 | 7314 7315**示例：** 7316 7317 ```ts 7318 class Stub extends rpc.RemoteObject { 7319 onRemoteMessageRequest(code, data, reply, option) { 7320 let callerPid = rpc.IPCSkeleton.getCallingPid(); 7321 console.log("RpcServer: getCallingPid result: " + callerPid); 7322 return true; 7323 } 7324 } 7325 ``` 7326 7327### getCallingUid 7328 7329static getCallingUid(): number 7330 7331静态方法，获取调用者的UID。此方法由RemoteObject对象在onRemoteRequest方法中调用，不在IPC上下文环境（onRemoteRequest）中调用则返回本进程的UID。 7332 7333**系统能力**：SystemCapability.Communication.IPC.Core 7334 7335**返回值：** 7336 7337 | 类型 | 说明 | 7338 | ------ | ----------------- | 7339 | number | 返回调用者的UID。 | 7340 7341**示例：** 7342 7343 ```ts 7344 class Stub extends rpc.RemoteObject { 7345 onRemoteMessageRequest(code, data, reply, option) { 7346 let callerUid = rpc.IPCSkeleton.getCallingUid(); 7347 console.log("RpcServer: getCallingUid result: " + callerUid); 7348 return true; 7349 } 7350 } 7351 ``` 7352 7353### getCallingTokenId<sup>8+</sup> 7354 7355static getCallingTokenId(): number; 7356 7357静态方法，获取调用者的TokenId，用于被调用方对调用方的身份校验。 7358 7359**系统能力**：SystemCapability.Communication.IPC.Core 7360 7361**返回值：** 7362 7363 | 类型 | 说明 | 7364 | ------ | --------------------- | 7365 | number | 返回调用者的TokenId。 | 7366 7367**示例：** 7368 7369 ```ts 7370 class Stub extends rpc.RemoteObject { 7371 onRemoteMessageRequest(code, data, reply, option) { 7372 let callerTokenId = rpc.IPCSkeleton.getCallingTokenId(); 7373 console.log("RpcServer: getCallingTokenId result: " + callerTokenId); 7374 return true; 7375 } 7376 } 7377 ``` 7378 7379### getCallingDeviceID 7380 7381static getCallingDeviceID(): string 7382 7383静态方法，获取调用者进程所在的设备ID。 7384 7385**系统能力**：SystemCapability.Communication.IPC.Core 7386 7387**返回值：** 7388 7389 | 类型 | 说明 | 7390 | ------ | ---------------------------- | 7391 | string | 返回调用者进程所在的设备ID。 | 7392 7393**示例：** 7394 7395 ```ts 7396 class Stub extends rpc.RemoteObject { 7397 onRemoteMessageRequest(code, data, reply, option) { 7398 let callerDeviceID = rpc.IPCSkeleton.getCallingDeviceID(); 7399 console.log("RpcServer: callerDeviceID is: " + callerDeviceID); 7400 return true; 7401 } 7402 } 7403 ``` 7404 7405### getLocalDeviceID 7406 7407static getLocalDeviceID(): string 7408 7409静态方法，获取本端设备ID。 7410 7411**系统能力**：SystemCapability.Communication.IPC.Core 7412 7413**返回值：** 7414 7415 | 类型 | 说明 | 7416 | ------ | ------------------ | 7417 | string | 返回本地设备的ID。 | 7418 7419**示例：** 7420 7421 ```ts 7422 class Stub extends rpc.RemoteObject { 7423 onRemoteMessageRequest(code, data, reply, option) { 7424 let localDeviceID = rpc.IPCSkeleton.getLocalDeviceID(); 7425 console.log("RpcServer: localDeviceID is: " + localDeviceID); 7426 return true; 7427 } 7428 } 7429 ``` 7430 7431### isLocalCalling 7432 7433static isLocalCalling(): boolean 7434 7435静态方法，检查当前通信对端是否是本设备的进程。 7436 7437**系统能力**：SystemCapability.Communication.IPC.Core 7438 7439**返回值：** 7440 7441 | 类型 | 说明 | 7442 | ------- | -------------------------------------------------- | 7443 | boolean | true：调用在同一台设备，false：调用未在同一台设备。| 7444 7445**示例：** 7446 7447 ```ts 7448 class Stub extends rpc.RemoteObject { 7449 onRemoteMessageRequest(code, data, reply, option) { 7450 let isLocalCalling = rpc.IPCSkeleton.isLocalCalling(); 7451 console.log("RpcServer: isLocalCalling is: " + isLocalCalling); 7452 return true; 7453 } 7454 } 7455 ``` 7456 7457### flushCmdBuffer<sup>9+</sup> 7458 7459static flushCmdBuffer(object: IRemoteObject): void 7460 7461静态方法，将所有挂起的命令从指定的RemoteProxy刷新到相应的RemoteObject。建议在执行任何时间敏感操作之前调用此方法。 7462 7463**系统能力**：SystemCapability.Communication.IPC.Core 7464 7465**参数：** 7466 7467 | 参数名 | 类型 | 必填 | 说明 | 7468 | ------ | ------------------------------- | ---- | ------------------- | 7469 | object | [IRemoteObject](#iremoteobject) | 是 | 指定的RemoteProxy。 | 7470 7471**示例：** 7472 7473 ```ts 7474 class TestRemoteObject extends rpc.RemoteObject { 7475 constructor(descriptor) { 7476 super(descriptor); 7477 } 7478 } 7479 let remoteObject = new TestRemoteObject("aaa"); 7480 try { 7481 rpc.IPCSkeleton.flushCmdBuffer(remoteObject); 7482 } catch(error) { 7483 console.info("proxy set calling identity fail, errorCode " + error.code); 7484 console.info("proxy set calling identity fail, errorMessage " + error.message); 7485 } 7486 ``` 7487 7488### flushCommands<sup>(deprecated)</sup> 7489 7490>从API version 9 开始不再维护，建议使用[flushCmdBuffer](#flushcmdbuffer9)类替代。 7491 7492static flushCommands(object: IRemoteObject): number 7493 7494静态方法，将所有挂起的命令从指定的RemoteProxy刷新到相应的RemoteObject。建议在执行任何时间敏感操作之前调用此方法。 7495 7496**系统能力**：SystemCapability.Communication.IPC.Core 7497 7498**参数：** 7499 7500 | 参数名 | 类型 | 必填 | 说明 | 7501 | ------ | ------------------------------- | ---- | ------------------- | 7502 | object | [IRemoteObject](#iremoteobject) | 是 | 指定的RemoteProxy。 | 7503 7504**返回值：** 7505 7506 | 类型 | 说明 | 7507 | ------ | --------------------------------------------------------------------------------- | 7508 | number | 如果操作成功，返回0；如果输入对象为空或RemoteObject，或者操作失败，返回错误代码。 | 7509 7510**示例：** 7511 7512 ```ts 7513 class MyDeathRecipient { 7514 onRemoteDied() { 7515 console.log("server died"); 7516 } 7517 } 7518 class TestRemoteObject extends rpc.RemoteObject { 7519 constructor(descriptor) { 7520 super(descriptor); 7521 } 7522 addDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 7523 return true; 7524 } 7525 removeDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 7526 return true; 7527 } 7528 isObjectDead(): boolean { 7529 return false; 7530 } 7531 } 7532 let remoteObject = new TestRemoteObject("aaa"); 7533 let ret = rpc.IPCSkeleton.flushCommands(remoteObject); 7534 console.log("RpcServer: flushCommands result: " + ret); 7535 ``` 7536 7537### resetCallingIdentity 7538 7539static resetCallingIdentity(): string 7540 7541静态方法，将远程用户的UID和PID替换为本地用户的UID和PID。它可以用于身份验证等场景。 7542 7543**系统能力**：SystemCapability.Communication.IPC.Core 7544 7545**返回值：** 7546 7547 | 类型 | 说明 | 7548 | ------ | ------------------------------------ | 7549 | string | 返回包含远程用户的UID和PID的字符串。 | 7550 7551**示例：** 7552 7553 ```ts 7554 class Stub extends rpc.RemoteObject { 7555 onRemoteMessageRequest(code, data, reply, option) { 7556 let callingIdentity = rpc.IPCSkeleton.resetCallingIdentity(); 7557 console.log("RpcServer: callingIdentity is: " + callingIdentity); 7558 return true; 7559 } 7560 } 7561 ``` 7562 7563### restoreCallingIdentity<sup>9+</sup> 7564 7565static restoreCallingIdentity(identity: string): void 7566 7567静态方法，将远程用户的UID和PID替换为本地用户的UID和PID。它可以用于身份验证等场景。 7568 7569**系统能力**：SystemCapability.Communication.IPC.Core 7570 7571**参数：** 7572 7573 | 参数名 | 类型 | 必填 | 说明 | 7574 | -------- | ------ | ---- | ------------------------------------------------------------------ | 7575 | identity | string | 是 | 标识表示包含远程用户UID和PID的字符串。由resetCallingIdentity返回。 | 7576 7577**示例：** 7578 7579 ```ts 7580 class Stub extends rpc.RemoteObject { 7581 onRemoteMessageRequest(code, data, reply, option) { 7582 let callingIdentity = null; 7583 try { 7584 callingIdentity = rpc.IPCSkeleton.resetCallingIdentity(); 7585 console.log("RpcServer: callingIdentity is: " + callingIdentity); 7586 } finally { 7587 rpc.IPCSkeleton.restoreCallingIdentity("callingIdentity "); 7588 } 7589 return true; 7590 } 7591 } 7592 ``` 7593 7594### setCallingIdentity<sup>(deprecated)</sup> 7595 7596>从API version 9 开始不再维护，建议使用[restoreCallingIdentity](#restorecallingidentity9)类替代。 7597 7598static setCallingIdentity(identity: string): boolean 7599 7600静态方法，将UID和PID恢复为远程用户的UID和PID。它通常在使用resetCallingIdentity后调用，需要resetCallingIdentity返回的远程用户的UID和PID。 7601 7602**系统能力**：SystemCapability.Communication.IPC.Core 7603 7604**参数：** 7605 7606 | 参数名 | 类型 | 必填 | 说明 | 7607 | -------- | ------ | ---- | ------------------------------------------------------------------ | 7608 | identity | string | 是 | 标识表示包含远程用户UID和PID的字符串。由resetCallingIdentity返回。 | 7609 7610**返回值：** 7611 7612 | 类型 | 说明 | 7613 | ------- | ---------------------------------| 7614 | boolean | true：设置成功，false：设置失败。| 7615 7616**示例：** 7617 7618 ```ts 7619 class Stub extends rpc.RemoteObject { 7620 onRemoteMessageRequest(code, data, reply, option) { 7621 let callingIdentity = null; 7622 try { 7623 callingIdentity = rpc.IPCSkeleton.resetCallingIdentity(); 7624 console.log("RpcServer: callingIdentity is: " + callingIdentity); 7625 } finally { 7626 let ret = rpc.IPCSkeleton.setCallingIdentity("callingIdentity "); 7627 console.log("RpcServer: setCallingIdentity is: " + ret); 7628 } 7629 return true; 7630 } 7631 } 7632 ``` 7633 7634## RemoteObject 7635 7636实现远程对象。服务提供者必须继承此类。 7637 7638### constructor 7639 7640constructor(descriptor: string) 7641 7642RemoteObject构造函数。 7643 7644**系统能力**：SystemCapability.Communication.IPC.Core 7645 7646**参数：** 7647 7648 | 参数名 | 类型 | 必填 | 说明 | 7649 | ---------- | ------ | ---- | ------------ | 7650 | descriptor | string | 是 | 接口描述符。 | 7651 7652### sendRequest<sup>(deprecated)</sup> 7653 7654>从API version 9 开始不再维护，建议使用[sendMessageRequest](#sendmessagerequest9)类替代。 7655 7656sendRequest(code: number, data: MessageParcel, reply: MessageParcel, options: MessageOption): boolean 7657 7658以同步或异步方式向对端进程发送MessageParcel消息。如果为选项设置了异步模式，则期约立即兑现，reply报文里没有内容，具体回复需要在业务侧的回调中获取。如果为选项设置了同步模式，则期约将在sendRequest返回时兑现，回复内容在reply报文里。 7659 7660**系统能力**：SystemCapability.Communication.IPC.Core 7661 7662**参数：** 7663 7664 | 参数名 | 类型 | 必填 | 说明 | 7665 | ------- | ----------------------------------------- | ---- | -------------------------------------------------------------------------------------- | 7666 | code | number | 是 | 本次请求调用的消息码（1-16777215），由通信双方确定。如果接口由IDL工具生成，则消息代码由IDL自动生成。 | 7667 | data | [MessageParcel](#messageparceldeprecated) | 是 | 保存待发送数据的 MessageParcel对象。 | 7668 | reply | [MessageParcel](#messageparceldeprecated) | 是 | 接收应答数据的MessageParcel对象。 | 7669 | options | [MessageOption](#messageoption) | 是 | 本次请求的同异步模式，默认同步调用。 | 7670 7671**返回值：** 7672 7673 | 类型 | 说明 | 7674 | ------- | -------------------------------- | 7675 | boolean | true：发送成功，false：发送失败。| 7676 7677**示例：** 7678 7679 ```ts 7680 class MyDeathRecipient { 7681 onRemoteDied() { 7682 console.log("server died"); 7683 } 7684 } 7685 class TestRemoteObject extends rpc.RemoteObject { 7686 constructor(descriptor) { 7687 super(descriptor); 7688 } 7689 addDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 7690 return true; 7691 } 7692 removeDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 7693 return true; 7694 } 7695 isObjectDead(): boolean { 7696 return false; 7697 } 7698 } 7699 let testRemoteObject = new TestRemoteObject("testObject"); 7700 let option = new rpc.MessageOption(); 7701 let data = rpc.MessageParcel.create(); 7702 let reply = rpc.MessageParcel.create(); 7703 data.writeInt(1); 7704 data.writeString("hello"); 7705 let ret: boolean = testRemoteObject.sendRequest(1, data, reply, option); 7706 if (ret) { 7707 console.log("sendRequest got result"); 7708 let msg = reply.readString(); 7709 console.log("RPCTest: reply msg: " + msg); 7710 } else { 7711 console.log("RPCTest: sendRequest failed"); 7712 } 7713 console.log("RPCTest: sendRequest ends, reclaim parcel"); 7714 data.reclaim(); 7715 reply.reclaim(); 7716 ``` 7717 7718### sendRequest<sup>8+(deprecated)</sup> 7719 7720>从API version 9 开始不再维护，建议使用[sendMessageRequest](#sendmessagerequest9)类替代。 7721 7722sendRequest(code: number, data: MessageParcel, reply: MessageParcel, options: MessageOption): Promise<SendRequestResult> 7723 7724以同步或异步方式向对端进程发送MessageParcel消息。如果为选项设置了异步模式，则期约立即兑现，reply报文里没有内容，具体回复需要在业务侧的回调中获取。如果为选项设置了同步模式，则期约将在sendRequest返回时兑现，回复内容在reply报文里。 7725 7726**系统能力**：SystemCapability.Communication.IPC.Core 7727 7728**参数：** 7729 7730 | 参数名 | 类型 | 必填 | 说明 | 7731 | ------- | ----------------------------------------- | ---- | -------------------------------------------------------------------------------------- | 7732 | code | number | 是 | 本次请求调用的消息码（1-16777215），由通信双方确定。如果接口由IDL工具生成，则消息代码由IDL自动生成。 | 7733 | data | [MessageParcel](#messageparceldeprecated) | 是 | 保存待发送数据的 MessageParcel对象。 | 7734 | reply | [MessageParcel](#messageparceldeprecated) | 是 | 接收应答数据的MessageParcel对象。 | 7735 | options | [MessageOption](#messageoption) | 是 | 本次请求的同异步模式，默认同步调用。 | 7736 7737**返回值：** 7738 7739 | 类型 | 说明 | 7740 | -------------------------------- | --------------------------------------------- | 7741 | Promise<SendRequestResult> | 返回一个期约，兑现值是sendRequestResult实例。 | 7742 7743**示例：** 7744 7745 ```ts 7746 class MyDeathRecipient { 7747 onRemoteDied() { 7748 console.log("server died"); 7749 } 7750 } 7751 class TestRemoteObject extends rpc.RemoteObject { 7752 constructor(descriptor) { 7753 super(descriptor); 7754 } 7755 addDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 7756 return true; 7757 } 7758 removeDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 7759 return true; 7760 } 7761 isObjectDead(): boolean { 7762 return false; 7763 } 7764 } 7765 let testRemoteObject = new TestRemoteObject("testObject"); 7766 let option = new rpc.MessageOption(); 7767 let data = rpc.MessageParcel.create(); 7768 let reply = rpc.MessageParcel.create(); 7769 data.writeInt(1); 7770 data.writeString("hello"); 7771 testRemoteObject.sendRequest(1, data, reply, option) 7772 .then(function(result) { 7773 if (result.errCode === 0) { 7774 console.log("sendRequest got result"); 7775 result.reply.readException(); 7776 let msg = result.reply.readString(); 7777 console.log("RPCTest: reply msg: " + msg); 7778 } else { 7779 console.log("RPCTest: sendRequest failed, errCode: " + result.errCode); 7780 } 7781 }).catch(function(e) { 7782 console.log("RPCTest: sendRequest got exception: " + e.message); 7783 }).finally (() => { 7784 console.log("RPCTest: sendRequest ends, reclaim parcel"); 7785 data.reclaim(); 7786 reply.reclaim(); 7787 }); 7788 ``` 7789 7790### sendMessageRequest<sup>9+</sup> 7791 7792sendMessageRequest(code: number, data: MessageSequence, reply: MessageSequence, options: MessageOption): Promise<RequestResult> 7793 7794以同步或异步方式向对端进程发送MessageSequence消息。如果为选项设置了异步模式，则期约立即兑现，reply报文里没有内容，具体回复需要在业务侧的回调中获取。如果为选项设置了同步模式，则期约将在sendMessageRequest返回时兑现，回复内容在reply报文里。 7795 7796**系统能力**：SystemCapability.Communication.IPC.Core 7797 7798**参数：** 7799 7800 | 参数名 | 类型 | 必填 | 说明 | 7801 | ------- | ------------------------------------ | ---- | -------------------------------------------------------------------------------------- | 7802 | code | number | 是 | 本次请求调用的消息码（1-16777215），由通信双方确定。如果接口由IDL工具生成，则消息代码由IDL自动生成。 | 7803 | data | [MessageSequence](#messagesequence9) | 是 | 保存待发送数据的 MessageSequence对象。 | 7804 | reply | [MessageSequence](#messagesequence9) | 是 | 接收应答数据的MessageSequence对象。 | 7805 | options | [MessageOption](#messageoption) | 是 | 本次请求的同异步模式，默认同步调用。 | 7806 7807**返回值：** 7808 7809 | 类型 | 说明 | 7810 | ---------------------------- | --------------------------------------------- | 7811 | Promise<RequestResult> | 返回一个期约，兑现值是RequestResult实例。 | 7812 7813**示例：** 7814 7815 ```ts 7816 class TestRemoteObject extends rpc.RemoteObject { 7817 constructor(descriptor) { 7818 super(descriptor); 7819 } 7820 } 7821 let testRemoteObject = new TestRemoteObject("testObject"); 7822 let option = new rpc.MessageOption(); 7823 let data = rpc.MessageSequence.create(); 7824 let reply = rpc.MessageSequence.create(); 7825 data.writeInt(1); 7826 data.writeString("hello"); 7827 testRemoteObject.sendMessageRequest(1, data, reply, option) 7828 .then(function(result) { 7829 if (result.errCode === 0) { 7830 console.log("sendMessageRequest got result"); 7831 result.reply.readException(); 7832 let msg = result.reply.readString(); 7833 console.log("RPCTest: reply msg: " + msg); 7834 } else { 7835 console.log("RPCTest: sendMessageRequest failed, errCode: " + result.errCode); 7836 } 7837 }).catch(function(e) { 7838 console.log("RPCTest: sendMessageRequest got exception: " + e.message); 7839 }).finally (() => { 7840 console.log("RPCTest: sendMessageRequest ends, reclaim parcel"); 7841 data.reclaim(); 7842 reply.reclaim(); 7843 }); 7844 ``` 7845 7846### sendMessageRequest<sup>9+</sup> 7847 7848sendMessageRequest(code: number, data: MessageSequence, reply: MessageSequence, options: MessageOption, callback: AsyncCallback<RequestResult>): void 7849 7850以同步或异步方式向对端进程发送MessageSequence消息。如果为选项设置了异步模式，则立即收到回调，reply报文里没有内容，具体回复需要在业务侧的回调中获取。如果为选项设置了同步模式，则将在sendMessageRequest返回时收到回调，回复内容在reply报文里。 7851 7852**系统能力**：SystemCapability.Communication.IPC.Core 7853 7854**参数：** 7855 7856 | 参数名 | 类型 | 必填 | 说明 | 7857 | ------------- | ------------------------------------ | ---- | -------------------------------------------------------------------------------------- | 7858 | code | number | 是 | 本次请求调用的消息码（1-16777215），由通信双方确定。如果接口由IDL工具生成，则消息代码由IDL自动生成。 | 7859 | data | [MessageSequence](#messagesequence9) | 是 | 保存待发送数据的 MessageSequence对象。 | 7860 | reply | [MessageSequence](#messagesequence9) | 是 | 接收应答数据的MessageSequence对象。 | 7861 | options | [MessageOption](#messageoption) | 是 | 本次请求的同异步模式，默认同步调用。 | 7862 | AsyncCallback | AsyncCallback<RequestResult> | 是 | 接收发送结果的回调。 | 7863 7864**示例：** 7865 7866 ```ts 7867 class TestRemoteObject extends rpc.RemoteObject { 7868 constructor(descriptor) { 7869 super(descriptor); 7870 } 7871 } 7872 function sendRequestCallback(result) { 7873 if (result.errCode === 0) { 7874 console.log("sendRequest got result"); 7875 result.reply.readException(); 7876 let msg = result.reply.readString(); 7877 console.log("RPCTest: reply msg: " + msg); 7878 } else { 7879 console.log("RPCTest: sendRequest failed, errCode: " + result.errCode); 7880 } 7881 console.log("RPCTest: sendRequest ends, reclaim parcel"); 7882 result.data.reclaim(); 7883 result.reply.reclaim(); 7884 } 7885 let testRemoteObject = new TestRemoteObject("testObject"); 7886 let option = new rpc.MessageOption(); 7887 let data = rpc.MessageSequence.create(); 7888 let reply = rpc.MessageSequence.create(); 7889 data.writeInt(1); 7890 data.writeString("hello"); 7891 testRemoteObject.sendMessageRequest(1, data, reply, option, sendRequestCallback); 7892 ``` 7893 7894### sendRequest<sup>8+(deprecated)</sup> 7895 7896>从API version 9 开始不再维护，建议使用[sendMessageRequest](#sendmessagerequest9)类替代。 7897 7898sendRequest(code: number, data: MessageParcel, reply: MessageParcel, options: MessageOption, callback: AsyncCallback<SendRequestResult>): void 7899 7900以同步或异步方式向对端进程发送MessageParcel消息。如果为选项设置了异步模式，则立即收到回调，reply报文里没有内容，具体回复需要在业务侧的回调中获取。如果为选项设置了同步模式，则将在sendRequest返回时收到回调，回复内容在reply报文里。 7901 7902**系统能力**：SystemCapability.Communication.IPC.Core 7903 7904**参数：** 7905 7906 | 参数名 | 类型 | 必填 | 说明 | 7907 | ------------- | ----------------------------------------- | ---- | -------------------------------------------------------------------------------------- | 7908 | code | number | 是 | 本次请求调用的消息码（1-16777215），由通信双方确定。如果接口由IDL工具生成，则消息代码由IDL自动生成。 | 7909 | data | [MessageParcel](#messageparceldeprecated) | 是 | 保存待发送数据的 MessageParcel对象。 | 7910 | reply | [MessageParcel](#messageparceldeprecated) | 是 | 接收应答数据的MessageParcel对象。 | 7911 | options | [MessageOption](#messageoption) | 是 | 本次请求的同异步模式，默认同步调用。 | 7912 | AsyncCallback | AsyncCallback<SendRequestResult> | 是 | 接收发送结果的回调。 | 7913 7914**示例：** 7915 7916 ```ts 7917 class MyDeathRecipient { 7918 onRemoteDied() { 7919 console.log("server died"); 7920 } 7921 } 7922 class TestRemoteObject extends rpc.RemoteObject { 7923 constructor(descriptor) { 7924 super(descriptor); 7925 } 7926 addDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 7927 return true; 7928 } 7929 removeDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 7930 return true; 7931 } 7932 isObjectDead(): boolean { 7933 return false; 7934 } 7935 } 7936 function sendRequestCallback(result) { 7937 if (result.errCode === 0) { 7938 console.log("sendRequest got result"); 7939 result.reply.readException(); 7940 let msg = result.reply.readString(); 7941 console.log("RPCTest: reply msg: " + msg); 7942 } else { 7943 console.log("RPCTest: sendRequest failed, errCode: " + result.errCode); 7944 } 7945 console.log("RPCTest: sendRequest ends, reclaim parcel"); 7946 result.data.reclaim(); 7947 result.reply.reclaim(); 7948 } 7949 let testRemoteObject = new TestRemoteObject("testObject"); 7950 let option = new rpc.MessageOption(); 7951 let data = rpc.MessageParcel.create(); 7952 let reply = rpc.MessageParcel.create(); 7953 data.writeInt(1); 7954 data.writeString("hello"); 7955 testRemoteObject.sendRequest(1, data, reply, option, sendRequestCallback); 7956 ``` 7957 7958### onRemoteRequest<sup>8+(deprecated)</sup> 7959 7960>从API version 9 开始不再维护，建议使用[onRemoteMessageRequest](#onremotemessagerequest9)类替代。 7961 7962onRemoteRequest(code: number, data: MessageParcel, reply: MessageParcel, options: MessageOption): boolean 7963 7964sendMessageRequest请求的响应处理函数，服务端在该函数里处理请求，回复结果。 7965 7966**系统能力**：SystemCapability.Communication.IPC.Core 7967 7968**参数：** 7969 7970 | 参数名 | 类型 | 必填 | 说明 | 7971 | ------ | ----------------------------------------- | ---- | --------------------------------------- | 7972 | code | number | 是 | 对端发送的服务请求码。 | 7973 | data | [MessageParcel](#messageparceldeprecated) | 是 | 携带客户端调用参数的MessageParcel对象。 | 7974 | reply | [MessageParcel](#messageparceldeprecated) | 是 | 写入结果的MessageParcel对象。 | 7975 | option | [MessageOption](#messageoption) | 是 | 指示操作是同步还是异步。 | 7976 7977**返回值：** 7978 7979 | 类型 | 说明 | 7980 | ------- | -------------------------------- | 7981 | boolean | true：操作成功，false：操作失败。| 7982 7983**示例：** 7984 7985 ```ts 7986 class MyDeathRecipient { 7987 onRemoteDied() { 7988 console.log("server died"); 7989 } 7990 } 7991 class TestRemoteObject extends rpc.RemoteObject { 7992 constructor(descriptor) { 7993 super(descriptor); 7994 } 7995 addDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 7996 return true; 7997 } 7998 removeDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 7999 return true; 8000 } 8001 isObjectDead(): boolean { 8002 return false; 8003 } 8004 onRemoteRequest(code, data, reply, option) { 8005 if (code === 1) { 8006 console.log("RpcServer: onRemoteRequest called"); 8007 return true; 8008 } else { 8009 console.log("RpcServer: unknown code: " + code); 8010 return false; 8011 } 8012 } 8013 } 8014 ``` 8015 8016### onRemoteMessageRequest<sup>9+</sup> 8017 8018onRemoteMessageRequest(code: number, data: MessageSequence, reply: MessageSequence, options: MessageOption): boolean | Promise\<boolean> 8019 8020> **说明：** 8021> 8022>* 开发者应优先选择重载onRemoteMessageRequest方法，其中可以自由实现同步和异步的消息处理。 8023>* 开发者同时重载onRemoteRequest和onRemoteMessageRequest方法时，仅onRemoteMessageRequest方法生效。 8024 8025sendMessageRequest请求的响应处理函数，服务端在该函数里同步或异步地处理请求，回复结果。 8026 8027**系统能力**：SystemCapability.Communication.IPC.Core 8028 8029**参数：** 8030 8031 | 参数名 | 类型 | 必填 | 说明 | 8032 | ------ | ------------------------------------ | ---- | ----------------------------------------- | 8033 | code | number | 是 | 对端发送的服务请求码。 | 8034 | data | [MessageSequence](#messagesequence9) | 是 | 携带客户端调用参数的MessageSequence对象。 | 8035 | reply | [MessageSequence](#messagesequence9) | 是 | 写入结果的MessageSequence对象。 | 8036 | option | [MessageOption](#messageoption) | 是 | 指示操作是同步还是异步。 | 8037 8038**返回值：** 8039 8040 | 类型 | 说明 | 8041 | ----------------- | ----------------------------------------------------------------------------------------------- | 8042 | boolean | 若在onRemoteMessageRequest中同步地处理请求，则返回一个布尔值：true：操作成功，false：操作失败。 | 8043 | Promise\<boolean> | 若在onRemoteMessageRequest中异步地处理请求，则返回一个Promise对象。 | 8044 8045**重载onRemoteMessageRequest方法同步处理请求示例：** 8046 8047 ```ts 8048 class TestRemoteObject extends rpc.RemoteObject { 8049 constructor(descriptor) { 8050 super(descriptor); 8051 } 8052 8053 onRemoteMessageRequest(code, data, reply, option) { 8054 if (code === 1) { 8055 console.log("RpcServer: sync onRemoteMessageRequest is called"); 8056 return true; 8057 } else { 8058 console.log("RpcServer: unknown code: " + code); 8059 return false; 8060 } 8061 } 8062 } 8063 ``` 8064 8065 **重载onRemoteMessageRequest方法异步处理请求示例：** 8066 8067 ```ts 8068 class TestRemoteObject extends rpc.RemoteObject { 8069 constructor(descriptor) { 8070 super(descriptor); 8071 } 8072 8073 async onRemoteMessageRequest(code, data, reply, option) { 8074 if (code === 1) { 8075 console.log("RpcServer: async onRemoteMessageRequest is called"); 8076 } else { 8077 console.log("RpcServer: unknown code: " + code); 8078 return false; 8079 } 8080 await new Promise((resolve) => { 8081 setTimeout(resolve, 100); 8082 }) 8083 return true; 8084 } 8085 } 8086 ``` 8087 8088**同时重载onRemoteMessageRequest和onRemoteRequest方法同步处理请求示例：** 8089 8090 ```ts 8091 class TestRemoteObject extends rpc.RemoteObject { 8092 constructor(descriptor) { 8093 super(descriptor); 8094 } 8095 8096 onRemoteRequest(code, data, reply, option) { 8097 if (code === 1) { 8098 console.log("RpcServer: sync onRemoteMessageRequest is called"); 8099 return true; 8100 } else { 8101 console.log("RpcServer: unknown code: " + code); 8102 return false; 8103 } 8104 } 8105 // 同时调用仅会执行onRemoteMessageRequest 8106 onRemoteMessageRequest(code, data, reply, option) { 8107 if (code === 1) { 8108 console.log("RpcServer: async onRemoteMessageRequest is called"); 8109 } else { 8110 console.log("RpcServer: unknown code: " + code); 8111 return false; 8112 } 8113 8114 return true; 8115 } 8116 } 8117 ``` 8118 8119 **同时重载onRemoteMessageRequest和onRemoteRequest方法异步处理请求示例：** 8120 8121 ```ts 8122 class TestRemoteObject extends rpc.RemoteObject { 8123 constructor(descriptor) { 8124 super(descriptor); 8125 } 8126 8127 onRemoteRequest(code, data, reply, option) { 8128 if (code === 1) { 8129 console.log("RpcServer: sync onRemoteRequest is called"); 8130 return true; 8131 } else { 8132 console.log("RpcServer: unknown code: " + code); 8133 return false; 8134 } 8135 } 8136 // 同时调用仅会执行onRemoteMessageRequest 8137 async onRemoteMessageRequest(code, data, reply, option) { 8138 if (code === 1) { 8139 console.log("RpcServer: async onRemoteMessageRequest is called"); 8140 } else { 8141 console.log("RpcServer: unknown code: " + code); 8142 return false; 8143 } 8144 await new Promise((resolve) => { 8145 setTimeout(resolve, 100); 8146 }) 8147 return true; 8148 } 8149 } 8150 ``` 8151 8152### getCallingUid 8153 8154getCallingUid(): number 8155 8156获取通信对端的进程Uid。 8157 8158**系统能力**：SystemCapability.Communication.IPC.Core 8159 8160**返回值：** 8161 | 类型 | 说明 | 8162 | ------ | ----------------------- | 8163 | number | 返回通信对端的进程Uid。 | 8164 8165**示例：** 8166 8167 ```ts 8168 class TestRemoteObject extends rpc.RemoteObject { 8169 constructor(descriptor) { 8170 super(descriptor); 8171 } 8172 } 8173 let testRemoteObject = new TestRemoteObject("testObject"); 8174 console.log("RpcServer: getCallingUid: " + testRemoteObject.getCallingUid()); 8175 ``` 8176 8177### getCallingPid 8178 8179getCallingPid(): number 8180 8181获取通信对端的进程Pid。 8182 8183**系统能力**：SystemCapability.Communication.IPC.Core 8184 8185**返回值：** 8186 8187 | 类型 | 说明 | 8188 | ------ | ----------------------- | 8189 | number | 返回通信对端的进程Pid。 | 8190 8191**示例：** 8192 8193 ```ts 8194 class TestRemoteObject extends rpc.RemoteObject { 8195 constructor(descriptor) { 8196 super(descriptor); 8197 } 8198 } 8199 let testRemoteObject = new TestRemoteObject("testObject"); 8200 console.log("RpcServer: getCallingPid: " + testRemoteObject.getCallingPid()); 8201 ``` 8202 8203### getLocalInterface<sup>9+</sup> 8204 8205getLocalInterface(descriptor: string): IRemoteBroker 8206 8207查询接口描述符的字符串。 8208 8209**系统能力**：SystemCapability.Communication.IPC.Core 8210 8211**参数：** 8212 8213 | 参数名 | 类型 | 必填 | 说明 | 8214 | ---------- | ------ | ---- | -------------------- | 8215 | descriptor | string | 是 | 接口描述符的字符串。 | 8216 8217**返回值：** 8218 8219 | 类型 | 说明 | 8220 | ------------- | --------------------------------------------- | 8221 | IRemoteBroker | 返回绑定到指定接口描述符的IRemoteBroker对象。 | 8222 8223**示例：** 8224 8225 ```ts 8226 class MyDeathRecipient { 8227 onRemoteDied() { 8228 console.log("server died"); 8229 } 8230 } 8231 class TestRemoteObject extends rpc.RemoteObject { 8232 constructor(descriptor) { 8233 super(descriptor); 8234 } 8235 registerDeathRecipient(recipient: MyDeathRecipient, flags: number) { 8236 // 方法逻辑需开发者根据业务需要实现 8237 } 8238 unregisterDeathRecipient(recipient: MyDeathRecipient, flags: number) { 8239 // 方法逻辑需开发者根据业务需要实现 8240 } 8241 isObjectDead(): boolean { 8242 return false; 8243 } 8244 } 8245 let testRemoteObject = new TestRemoteObject("testObject"); 8246 try { 8247 let broker = testRemoteObject.getLocalInterface("testObject"); 8248 } catch(error) { 8249 console.info("rpc get local interface fail, errorCode " + error.code); 8250 console.info("rpc get local interface fail, errorMessage " + error.message); 8251 } 8252 ``` 8253 8254### queryLocalInterface<sup>(deprecated)</sup> 8255 8256>从API version 9 开始不再维护，建议使用[getLocalInterface](#getlocalinterface9)类替代。 8257 8258queryLocalInterface(descriptor: string): IRemoteBroker 8259 8260查询并获取当前接口描述符对应的远端对象是否已经存在。 8261 8262**系统能力**：SystemCapability.Communication.IPC.Core 8263 8264**参数：** 8265 8266 | 参数名 | 类型 | 必填 | 说明 | 8267 | ---------- | ------ | ---- | ---------------------- | 8268 | descriptor | string | 是 | 需要查询的接口描述符。 | 8269 8270**返回值：** 8271 8272 | 类型 | 说明 | 8273 | ------------- | ------------------------------------------------------------------ | 8274 | IRemoteBroker | 如果接口描述符对应的远端对象存在，则返回该远端对象，否则返回Null。 | 8275 8276**示例：** 8277 8278 ```ts 8279 class MyDeathRecipient { 8280 onRemoteDied() { 8281 console.log("server died"); 8282 } 8283 } 8284 class TestRemoteObject extends rpc.RemoteObject { 8285 constructor(descriptor) { 8286 super(descriptor); 8287 } 8288 addDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 8289 return true; 8290 } 8291 removeDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 8292 return true; 8293 } 8294 isObjectDead(): boolean { 8295 return false; 8296 } 8297 } 8298 let testRemoteObject = new TestRemoteObject("testObject"); 8299 let broker = testRemoteObject.queryLocalInterface("testObject"); 8300 ``` 8301 8302### getDescriptor<sup>9+</sup> 8303 8304getDescriptor(): string 8305 8306获取对象的接口描述符。接口描述符为字符串。 8307 8308**系统能力**：SystemCapability.Communication.IPC.Core 8309 8310**返回值：** 8311 8312 | 类型 | 说明 | 8313 | ------ | ---------------- | 8314 | string | 返回接口描述符。 | 8315 8316**错误码：** 8317 8318以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 8319 8320 | 错误码ID | 错误信息 | 8321 | -------- | -------- | 8322 | 1900008 | proxy or remote object is invalid | 8323 8324**示例：** 8325 8326 ```ts 8327 class MyDeathRecipient { 8328 onRemoteDied() { 8329 console.log("server died"); 8330 } 8331 } 8332 class TestRemoteObject extends rpc.RemoteObject { 8333 constructor(descriptor) { 8334 super(descriptor); 8335 } 8336 registerDeathRecipient(recipient: MyDeathRecipient, flags: number) { 8337 // 方法逻辑需开发者根据业务需要实现 8338 } 8339 unregisterDeathRecipient(recipient: MyDeathRecipient, flags: number) { 8340 // 方法逻辑需开发者根据业务需要实现 8341 } 8342 isObjectDead(): boolean { 8343 return false; 8344 } 8345 } 8346 let testRemoteObject = new TestRemoteObject("testObject"); 8347 console.log("RpcServer: descriptor is: " + descriptor); 8348 try { 8349 let descriptor = testRemoteObject.getDescriptor(); 8350 } catch(error) { 8351 console.info("rpc get local interface fail, errorCode " + error.code); 8352 console.info("rpc get local interface fail, errorMessage " + error.message); 8353 } 8354 ``` 8355 8356### getInterfaceDescriptor<sup>(deprecated)</sup> 8357 8358>从API version 9 开始不再维护，建议使用[getDescriptor](#getdescriptor9)类替代。 8359 8360getInterfaceDescriptor(): string 8361 8362查询接口描述符。 8363 8364**系统能力**：SystemCapability.Communication.IPC.Core 8365 8366**返回值：** 8367 8368 | 类型 | 说明 | 8369 | ------ | ---------------- | 8370 | string | 返回接口描述符。 | 8371 8372**示例：** 8373 8374 ```ts 8375 class MyDeathRecipient { 8376 onRemoteDied() { 8377 console.log("server died"); 8378 } 8379 } 8380 class TestRemoteObject extends rpc.RemoteObject { 8381 constructor(descriptor) { 8382 super(descriptor); 8383 } 8384 addDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 8385 return true; 8386 } 8387 removeDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 8388 return true; 8389 } 8390 isObjectDead(): boolean { 8391 return false; 8392 } 8393 } 8394 let testRemoteObject = new TestRemoteObject("testObject"); 8395 let descriptor = testRemoteObject.getInterfaceDescriptor(); 8396 console.log("RpcServer: descriptor is: " + descriptor); 8397 ``` 8398 8399### modifyLocalInterface<sup>9+</sup> 8400 8401modifyLocalInterface(localInterface: IRemoteBroker, descriptor: string): void 8402 8403此接口用于把接口描述符和IRemoteBroker对象绑定。 8404 8405**系统能力**：SystemCapability.Communication.IPC.Core 8406 8407**参数：** 8408 8409 | 参数名 | 类型 | 必填 | 说明 | 8410 | -------------- | ------------- | ---- | ------------------------------------- | 8411 | localInterface | IRemoteBroker | 是 | 将与描述符绑定的IRemoteBroker对象。 | 8412 | descriptor | string | 是 | 用于与IRemoteBroker对象绑定的描述符。 | 8413 8414**示例：** 8415 8416 ```ts 8417 class MyDeathRecipient { 8418 onRemoteDied() { 8419 console.log("server died"); 8420 } 8421 } 8422 class TestRemoteObject extends rpc.RemoteObject { 8423 constructor(descriptor) { 8424 super(descriptor); 8425 try { 8426 this.modifyLocalInterface(this, descriptor); 8427 } catch(error) { 8428 console.info(" rpc attach local interface fail, errorCode " + error.code); 8429 console.info(" rpc attach local interface fail, errorMessage " + error.message); 8430 } 8431 } 8432 registerDeathRecipient(recipient: MyDeathRecipient, flags: number) { 8433 // 方法逻辑需开发者根据业务需要实现 8434 } 8435 unregisterDeathRecipient(recipient: MyDeathRecipient, flags: number) { 8436 // 方法逻辑需开发者根据业务需要实现 8437 } 8438 isObjectDead(): boolean { 8439 return false; 8440 } 8441 asObject(): rpc.IRemoteObject { 8442 return this; 8443 } 8444 } 8445 let testRemoteObject = new TestRemoteObject("testObject"); 8446 ``` 8447 8448### attachLocalInterface<sup>(deprecated)</sup> 8449 8450>从API version 9 开始不再维护，建议使用[modifyLocalInterface](#modifylocalinterface9)类替代。 8451 8452attachLocalInterface(localInterface: IRemoteBroker, descriptor: string): void 8453 8454此接口用于把接口描述符和IRemoteBroker对象绑定。 8455 8456**系统能力**：SystemCapability.Communication.IPC.Core 8457 8458**参数：** 8459 8460 | 参数名 | 类型 | 必填 | 说明 | 8461 | -------------- | ------------- | ---- | ------------------------------------- | 8462 | localInterface | IRemoteBroker | 是 | 将与描述符绑定的IRemoteBroker对象。 | 8463 | descriptor | string | 是 | 用于与IRemoteBroker对象绑定的描述符。 | 8464 8465**示例：** 8466 8467 ```ts 8468 class MyDeathRecipient { 8469 onRemoteDied() { 8470 console.log("server died"); 8471 } 8472 } 8473 class TestRemoteObject extends rpc.RemoteObject { 8474 constructor(descriptor) { 8475 super(descriptor); 8476 this.attachLocalInterface(this, descriptor); 8477 } 8478 addDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 8479 return true; 8480 } 8481 removeDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean { 8482 return true; 8483 } 8484 isObjectDead(): boolean { 8485 return false; 8486 } 8487 asObject(): rpc.IRemoteObject { 8488 return this; 8489 } 8490 } 8491 let testRemoteObject = new TestRemoteObject("testObject"); 8492 ``` 8493 8494## Ashmem<sup>8+</sup> 8495 8496提供与匿名共享内存对象相关的方法，包括创建、关闭、映射和取消映射Ashmem、从Ashmem读取数据和写入数据、获取Ashmem大小、设置Ashmem保护。 8497 8498**系统能力**：以下各项对应的系统能力均为SystemCapability.Communication.IPC.Core。 8499 8500映射内存保护类型： 8501 8502 | 名称 | 值 | 说明 | 8503 | ---------- | --- | ------------------ | 8504 | PROT_EXEC | 4 | 映射的内存可执行 | 8505 | PROT_NONE | 0 | 映射的内存不可访问 | 8506 | PROT_READ | 1 | 映射的内存可读 | 8507 | PROT_WRITE | 2 | 映射的内存可写 | 8508 8509### create<sup>9+</sup> 8510 8511static create(name: string, size: number): Ashmem 8512 8513静态方法，根据指定的名称和大小创建Ashmem对象。 8514 8515**系统能力**：SystemCapability.Communication.IPC.Core 8516 8517**参数：** 8518 8519 | 参数名 | 类型 | 必填 | 说明 | 8520 | ------ | ------ | ---- | ---------------------------- | 8521 | name | string | 是 | 名称，用于查询Ashmem信息。 | 8522 | size | number | 是 | Ashmem的大小，以字节为单位。 | 8523 8524**返回值：** 8525 8526 | 类型 | 说明 | 8527 | ------ | ---------------------------------------------- | 8528 | Ashmem | 返回创建的Ashmem对象；如果创建失败，返回null。 | 8529 8530**示例：** 8531 8532 ```ts 8533 let ashmem; 8534 try { 8535 ashmem = rpc.Ashmem.create("ashmem", 1024*1024); 8536 } catch(error) { 8537 console.info("Rpc creat ashmem fail, errorCode " + error.code); 8538 console.info("Rpc creat ashmem fail, errorMessage " + error.message); 8539 } 8540 let size = ashmem.getAshmemSize(); 8541 console.log("RpcTest: get ashemm by create : " + ashmem + " size is : " + size); 8542 ``` 8543 8544### createAshmem<sup>8+(deprecated)</sup> 8545 8546>从API version 9 开始不再维护，建议使用[create](#create9)类替代。 8547 8548static createAshmem(name: string, size: number): Ashmem 8549 8550静态方法，根据指定的名称和大小创建Ashmem对象。 8551 8552**系统能力**：SystemCapability.Communication.IPC.Core 8553 8554**参数：** 8555 8556 | 参数名 | 类型 | 必填 | 说明 | 8557 | ------ | ------ | ---- | ---------------------------- | 8558 | name | string | 是 | 名称，用于查询Ashmem信息。 | 8559 | size | number | 是 | Ashmem的大小，以字节为单位。 | 8560 8561**返回值：** 8562 8563 | 类型 | 说明 | 8564 | ------ | ---------------------------------------------- | 8565 | Ashmem | 返回创建的Ashmem对象；如果创建失败，返回null。 | 8566 8567**示例：** 8568 8569 ```ts 8570 let ashmem = rpc.Ashmem.createAshmem("ashmem", 1024*1024); 8571 let size = ashmem.getAshmemSize(); 8572 console.log("RpcTest: get ashemm by createAshmem : " + ashmem + " size is : " + size); 8573 ``` 8574 8575### create<sup>9+</sup> 8576 8577static create(ashmem: Ashmem): Ashmem 8578 8579静态方法，通过复制现有Ashmem对象的文件描述符(fd)来创建Ashmem对象。两个Ashmem对象指向同一个共享内存区域。 8580 8581**系统能力**：SystemCapability.Communication.IPC.Core 8582 8583**参数：** 8584 8585 | 参数名 | 类型 | 必填 | 说明 | 8586 | ------ | ------ | ---- | -------------------- | 8587 | ashmem | Ashmem | 是 | 已存在的Ashmem对象。 | 8588 8589**返回值：** 8590 8591 | 类型 | 说明 | 8592 | ------ | ---------------------- | 8593 | Ashmem | 返回创建的Ashmem对象。 | 8594 8595**示例：** 8596 8597 ```ts 8598 let ashmem2; 8599 try { 8600 let ashmem = rpc.Ashmem.create("ashmem", 1024*1024); 8601 let ashmem2 = rpc.Ashmem.create(ashmem); 8602 } catch(error) { 8603 console.info("Rpc creat ashmem from existing fail, errorCode " + error.code); 8604 console.info("Rpc creat ashmem from existing fail, errorMessage " + error.message); 8605 } 8606 let size = ashmem2.getAshmemSize(); 8607 console.log("RpcTest: get ashemm by create : " + ashmem2 + " size is : " + size); 8608 ``` 8609 8610### createAshmemFromExisting<sup>8+(deprecated)</sup> 8611 8612>从API version 9 开始不再维护，建议使用[create](#create9)类替代。 8613 8614static createAshmemFromExisting(ashmem: Ashmem): Ashmem 8615 8616静态方法，通过复制现有Ashmem对象的文件描述符(fd)来创建Ashmem对象。两个Ashmem对象指向同一个共享内存区域。 8617 8618**系统能力**：SystemCapability.Communication.IPC.Core 8619 8620**参数：** 8621 8622 | 参数名 | 类型 | 必填 | 说明 | 8623 | ------ | ------ | ---- | -------------------- | 8624 | ashmem | Ashmem | 是 | 已存在的Ashmem对象。 | 8625 8626**返回值：** 8627 8628 | 类型 | 说明 | 8629 | ------ | ---------------------- | 8630 | Ashmem | 返回创建的Ashmem对象。 | 8631 8632**示例：** 8633 8634 ```ts 8635 let ashmem = rpc.Ashmem.createAshmem("ashmem", 1024*1024); 8636 let ashmem2 = rpc.Ashmem.createAshmemFromExisting(ashmem); 8637 let size = ashmem2.getAshmemSize(); 8638 console.log("RpcTest: get ashemm by createAshmemFromExisting : " + ashmem2 + " size is : " + size); 8639 ``` 8640 8641### closeAshmem<sup>8+</sup> 8642 8643closeAshmem(): void 8644 8645关闭这个Ashmem。 8646 8647**系统能力**：SystemCapability.Communication.IPC.Core 8648 8649**示例：** 8650 8651 ```ts 8652 let ashmem = rpc.Ashmem.create("ashmem", 1024*1024); 8653 ashmem.closeAshmem(); 8654 ``` 8655 8656### unmapAshmem<sup>8+</sup> 8657 8658unmapAshmem(): void 8659 8660删除该Ashmem对象的地址映射。 8661 8662**系统能力**：SystemCapability.Communication.IPC.Core 8663 8664**示例：** 8665 8666 ```ts 8667 let ashmem = rpc.Ashmem.create("ashmem", 1024*1024); 8668 ashmem.unmapAshmem(); 8669 ``` 8670 8671### getAshmemSize<sup>8+</sup> 8672 8673getAshmemSize(): number 8674 8675获取Ashmem对象的内存大小。 8676 8677**系统能力**：SystemCapability.Communication.IPC.Core 8678 8679**返回值：** 8680 8681 | 类型 | 说明 | 8682 | ------ | -------------------------- | 8683 | number | 返回Ashmem对象的内存大小。 | 8684 8685**示例：** 8686 8687 ```ts 8688 let ashmem = rpc.Ashmem.createAshmem("ashmem", 1024*1024); 8689 let size = ashmem.getAshmemSize(); 8690 console.log("RpcTest: get ashmem is " + ashmem + " size is : " + size); 8691 ``` 8692 8693### mapTypedAshmem<sup>9+</sup> 8694 8695mapTypedAshmem(mapType: number): void 8696 8697在此进程的虚拟地址空间上创建共享文件映射，映射区域大小由此Ashmem对象指定。 8698 8699**系统能力**：SystemCapability.Communication.IPC.Core 8700 8701**参数：** 8702 8703 | 参数名 | 类型 | 必填 | 说明 | 8704 | ------- | ------ | ---- | ------------------------------ | 8705 | mapType | number | 是 | 指定映射的内存区域的保护等级。 | 8706 8707**错误码：** 8708 8709以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 8710 8711 | 错误码ID | 错误信息 | 8712 | -------- | -------- | 8713 | 1900001 | call mmap function failed | 8714 8715**示例：** 8716 8717 ```ts 8718 let ashmem = rpc.Ashmem.create("ashmem", 1024*1024); 8719 try { 8720 ashmem.mapTypedAshmem(ashmem.PROT_READ | ashmem.PROT_WRITE); 8721 } catch(error) { 8722 console.info("Rpc map ashmem fail, errorCode " + error.code); 8723 console.info("Rpc map ashmem fail, errorMessage " + error.message); 8724 } 8725 ``` 8726 8727### mapAshmem<sup>8+(deprecated)</sup> 8728 8729>从API version 9 开始不再维护，建议使用[mapTypedAshmem](#maptypedashmem9)类替代。 8730 8731mapAshmem(mapType: number): boolean 8732 8733在此进程的虚拟地址空间上创建共享文件映射，映射区域大小由此Ashmem对象指定。 8734 8735**系统能力**：SystemCapability.Communication.IPC.Core 8736 8737**参数：** 8738 8739 | 参数名 | 类型 | 必填 | 说明 | 8740 | ------- | ------ | ---- | ------------------------------ | 8741 | mapType | number | 是 | 指定映射的内存区域的保护等级。 | 8742 8743**返回值：** 8744 8745 | 类型 | 说明 | 8746 | ------- | -------------------------------- | 8747 | boolean | true：映射成功，false：映射失败。| 8748 8749**示例：** 8750 8751 ```ts 8752 let ashmem = rpc.Ashmem.createAshmem("ashmem", 1024*1024); 8753 let mapReadAndWrite = ashmem.mapAshmem(ashmem.PROT_READ | ashmem.PROT_WRITE); 8754 console.log("RpcTest: map ashmem result is : " + mapReadAndWrite); 8755 ``` 8756 8757### mapReadWriteAshmem<sup>9+</sup> 8758 8759mapReadWriteAshmem(): void 8760 8761在此进程虚拟地址空间上创建可读写的共享文件映射。 8762 8763**系统能力**：SystemCapability.Communication.IPC.Core 8764 8765**错误码：** 8766 8767以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 8768 8769 | 错误码ID | 错误信息 | 8770 | -------- | -------- | 8771 | 1900001 | call mmap function failed | 8772 8773**示例：** 8774 8775 ```ts 8776 let ashmem = rpc.Ashmem.create("ashmem", 1024*1024); 8777 try { 8778 ashmem.mapReadWriteAshmem(); 8779 } catch(error) { 8780 console.info("Rpc map read and write ashmem fail, errorCode " + error.code); 8781 console.info("Rpc map read and write ashmem fail, errorMessage " + error.message); 8782 } 8783 ``` 8784 8785### mapReadAndWriteAshmem<sup>8+(deprecated)</sup> 8786 8787>从API version 9 开始不再维护，建议使用[mapReadWriteAshmem](#mapreadwriteashmem9)类替代。 8788 8789mapReadAndWriteAshmem(): boolean 8790 8791在此进程虚拟地址空间上创建可读写的共享文件映射。 8792 8793**系统能力**：SystemCapability.Communication.IPC.Core 8794 8795**返回值：** 8796 8797 | 类型 | 说明 | 8798 | ------- | -------------------------------- | 8799 | boolean | true：映射成功，false：映射失败。| 8800 8801**示例：** 8802 8803 ```ts 8804 let ashmem = rpc.Ashmem.createAshmem("ashmem", 1024*1024); 8805 let mapResult = ashmem.mapReadAndWriteAshmem(); 8806 console.log("RpcTest: map ashmem result is : " + mapResult); 8807 ``` 8808 8809### mapReadonlyAshmem<sup>9+</sup> 8810 8811mapReadonlyAshmem(): void 8812 8813在此进程虚拟地址空间上创建只读的共享文件映射。 8814 8815**系统能力**：SystemCapability.Communication.IPC.Core 8816 8817**错误码：** 8818 8819以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 8820 8821 | 错误码ID | 错误信息 | 8822 | -------- | -------- | 8823 | 1900001 | call mmap function failed | 8824 8825**示例：** 8826 8827 ```ts 8828 let ashmem = rpc.Ashmem.create("ashmem", 1024*1024); 8829 try { 8830 ashmem.mapReadonlyAshmem(); 8831 } catch(error) { 8832 console.info("Rpc map read and write ashmem fail, errorCode " + error.code); 8833 console.info("Rpc map read and write ashmem fail, errorMessage " + error.message); 8834 } 8835 ``` 8836 8837### mapReadOnlyAshmem<sup>8+(deprecated)</sup> 8838 8839>从API version 9 开始不再维护，建议使用[mapReadonlyAshmem](#mapreadonlyashmem9)类替代。 8840 8841mapReadOnlyAshmem(): boolean 8842 8843在此进程虚拟地址空间上创建只读的共享文件映射。 8844 8845**系统能力**：SystemCapability.Communication.IPC.Core 8846 8847**返回值：** 8848 8849 | 类型 | 说明 | 8850 | ------- | -------------------------------- | 8851 | boolean | true：映射成功，false：映射失败。| 8852 8853**示例：** 8854 8855 ```ts 8856 let ashmem = rpc.Ashmem.createAshmem("ashmem", 1024*1024); 8857 let mapResult = ashmem.mapReadOnlyAshmem(); 8858 console.log("RpcTest: Ashmem mapReadOnlyAshmem result is : " + mapResult); 8859 ``` 8860 8861### setProtectionType<sup>9+</sup> 8862 8863setProtectionType(protectionType: number): void 8864 8865设置映射内存区域的保护等级。 8866 8867**系统能力**：SystemCapability.Communication.IPC.Core 8868 8869**参数：** 8870 8871 | 参数名 | 类型 | 必填 | 说明 | 8872 | -------------- | ------ | ---- | ------------------ | 8873 | protectionType | number | 是 | 要设置的保护类型。 | 8874 8875**错误码：** 8876 8877以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 8878 8879 | 错误码ID | 错误信息 | 8880 | -------- | -------- | 8881 | 1900002 | call os ioctl function failed | 8882 8883**示例：** 8884 8885 ```ts 8886 let ashmem = rpc.Ashmem.create("ashmem", 1024*1024); 8887 try { 8888 ashmem.setProtection(ashmem.PROT_READ); 8889 } catch(error) { 8890 console.info("Rpc set protection type fail, errorCode " + error.code); 8891 console.info("Rpc set protection type fail, errorMessage " + error.message); 8892 } 8893 ``` 8894 8895### setProtection<sup>8+(deprecated)</sup> 8896 8897>从API version 9 开始不再维护，建议使用[setProtectionType](#setprotectiontype9)类替代。 8898 8899setProtection(protectionType: number): boolean 8900 8901设置映射内存区域的保护等级。 8902 8903**系统能力**：SystemCapability.Communication.IPC.Core 8904 8905**参数：** 8906 8907 | 参数名 | 类型 | 必填 | 说明 | 8908 | -------------- | ------ | ---- | ------------------ | 8909 | protectionType | number | 是 | 要设置的保护类型。 | 8910 8911**返回值：** 8912 8913 | 类型 | 说明 | 8914 | ------- | -------------------------------- | 8915 | boolean | true：设置成功，false：设置失败。| 8916 8917**示例：** 8918 8919 ```ts 8920 let ashmem = rpc.Ashmem.createAshmem("ashmem", 1024*1024); 8921 let result = ashmem.setProtection(ashmem.PROT_READ); 8922 console.log("RpcTest: Ashmem setProtection result is : " + result); 8923 ``` 8924 8925### writeAshmem<sup>9+</sup> 8926 8927writeAshmem(buf: number[], size: number, offset: number): void 8928 8929将数据写入此Ashmem对象关联的共享文件。 8930 8931**系统能力**：SystemCapability.Communication.IPC.Core 8932 8933**参数：** 8934 8935 | 参数名 | 类型 | 必填 | 说明 | 8936 | ------ | -------- | ---- | -------------------------------------------------- | 8937 | buf | number[] | 是 | 写入Ashmem对象的数据。 | 8938 | size | number | 是 | 要写入的数据大小。 | 8939 | offset | number | 是 | 要写入的数据在此Ashmem对象关联的内存区间的起始位置 | 8940 8941**错误码：** 8942 8943以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 8944 8945 | 错误码ID | 错误信息 | 8946 | -------- | -------- | 8947 | 1900003 | write to ashmem failed | 8948 8949**示例：** 8950 8951 ```ts 8952 let ashmem = rpc.Ashmem.create("ashmem", 1024*1024); 8953 ashmem.mapReadWriteAshmem(); 8954 var ByteArrayVar = [1, 2, 3, 4, 5]; 8955 try { 8956 ashmem.writeAshmem(ByteArrayVar, 5, 0); 8957 } catch(error) { 8958 console.info("Rpc write to ashmem fail, errorCode " + error.code); 8959 console.info("Rpc write to ashmem fail, errorMessage " + error.message); 8960 } 8961 ``` 8962 8963### writeToAshmem<sup>8+(deprecated)</sup> 8964 8965>从API version 9 开始不再维护，建议使用[writeAshmem](#writeashmem9)类替代。 8966 8967writeToAshmem(buf: number[], size: number, offset: number): boolean 8968 8969将数据写入此Ashmem对象关联的共享文件。 8970 8971**系统能力**：SystemCapability.Communication.IPC.Core 8972 8973**参数：** 8974 8975 | 参数名 | 类型 | 必填 | 说明 | 8976 | ------ | -------- | ---- | -------------------------------------------------- | 8977 | buf | number[] | 是 | 写入Ashmem对象的数据。 | 8978 | size | number | 是 | 要写入的数据大小。 | 8979 | offset | number | 是 | 要写入的数据在此Ashmem对象关联的内存区间的起始位置 | 8980 8981**返回值：** 8982 8983 | 类型 | 说明 | 8984 | ------- | ----------------------------------------------------------------------------- | 8985 | boolean | true：如果数据写入成功，false：在其他情况下，如数据写入越界或未获得写入权限。 | 8986 8987**示例：** 8988 8989 ```ts 8990 let ashmem = rpc.Ashmem.createAshmem("ashmem", 1024*1024); 8991 let mapResult = ashmem.mapReadAndWriteAshmem(); 8992 console.info("RpcTest map ashmem result is " + mapResult); 8993 var ByteArrayVar = [1, 2, 3, 4, 5]; 8994 let writeResult = ashmem.writeToAshmem(ByteArrayVar, 5, 0); 8995 console.log("RpcTest: write to Ashmem result is : " + writeResult); 8996 ``` 8997 8998### readAshmem<sup>9+</sup> 8999 9000readAshmem(size: number, offset: number): number[] 9001 9002从此Ashmem对象关联的共享文件中读取数据。 9003 9004**系统能力**：SystemCapability.Communication.IPC.Core 9005 9006**参数：** 9007 9008 | 参数名 | 类型 | 必填 | 说明 | 9009 | ------ | ------ | ---- | -------------------------------------------------- | 9010 | size | number | 是 | 要读取的数据的大小。 | 9011 | offset | number | 是 | 要读取的数据在此Ashmem对象关联的内存区间的起始位置 | 9012 9013**返回值：** 9014 9015 | 类型 | 说明 | 9016 | -------- | ---------------- | 9017 | number[] | 返回读取的数据。 | 9018 9019**错误码：** 9020 9021以下错误码的详细介绍请参见[ohos.rpc错误码](../errorcodes/errorcode-rpc.md) 9022 9023 | 错误码ID | 错误信息 | 9024 | -------- | -------- | 9025 | 1900004 | read from ashmem failed | 9026 9027**示例：** 9028 9029 ```ts 9030 let ashmem = rpc.Ashmem.create("ashmem", 1024*1024); 9031 ashmem.mapReadWriteAshmem(); 9032 var ByteArrayVar = [1, 2, 3, 4, 5]; 9033 ashmem.writeAshmem(ByteArrayVar, 5, 0); 9034 try { 9035 let readResult = ashmem.readAshmem(5, 0); 9036 console.log("RpcTest: read from Ashmem result is : " + readResult); 9037 } catch(error) { 9038 console.info("Rpc read from ashmem fail, errorCode " + error.code); 9039 console.info("Rpc read from ashmem fail, errorMessage " + error.message); 9040 } 9041 ``` 9042 9043### readFromAshmem<sup>8+(deprecated)</sup> 9044 9045>从API version 9 开始不再维护，建议使用[readAshmem](#readashmem9)类替代。 9046 9047readFromAshmem(size: number, offset: number): number[] 9048 9049从此Ashmem对象关联的共享文件中读取数据。 9050 9051**系统能力**：SystemCapability.Communication.IPC.Core 9052 9053**参数：** 9054 9055 | 参数名 | 类型 | 必填 | 说明 | 9056 | ------ | ------ | ---- | -------------------------------------------------- | 9057 | size | number | 是 | 要读取的数据的大小。 | 9058 | offset | number | 是 | 要读取的数据在此Ashmem对象关联的内存区间的起始位置 | 9059 9060**返回值：** 9061 9062 | 类型 | 说明 | 9063 | -------- | ---------------- | 9064 | number[] | 返回读取的数据。 | 9065 9066**示例：** 9067 9068 ``` ts 9069 let ashmem = rpc.Ashmem.createAshmem("ashmem", 1024*1024); 9070 let mapResult = ashmem.mapReadAndWriteAshmem(); 9071 console.info("RpcTest map ashmem result is " + mapResult); 9072 var ByteArrayVar = [1, 2, 3, 4, 5]; 9073 let writeResult = ashmem.writeToAshmem(ByteArrayVar, 5, 0); 9074 console.log("RpcTest: write to Ashmem result is : " + writeResult); 9075 let readResult = ashmem.readFromAshmem(5, 0); 9076 console.log("RpcTest: read to Ashmem result is : " + readResult); 9077 ``` 9078 9079## 获取context 9080 9081**示例：** 9082 9083 ```ts 9084 import Ability from '@ohos.app.ability.UIAbility'; 9085 9086 export default class MainAbility extends Ability { 9087 onCreate(want, launchParam) { 9088 console.log("[Demo] MainAbility onCreate"); 9089 globalThis.context = this.context; 9090 } 9091 onDestroy() { 9092 console.log("[Demo] MainAbility onDestroy"); 9093 } 9094 onWindowStageCreate(windowStage) { 9095 // Main window is created, set main page for this ability 9096 console.log("[Demo] MainAbility onWindowStageCreate"); 9097 } 9098 onWindowStageDestroy() { 9099 // Main window is destroyed, release UI related resources 9100 console.log("[Demo] MainAbility onWindowStageDestroy"); 9101 } 9102 onForeground() { 9103 // Ability has brought to foreground 9104 console.log("[Demo] MainAbility onForeground"); 9105 } 9106 onBackground() { 9107 // Ability has back to background 9108 console.log("[Demo] MainAbility onBackground"); 9109 } 9110 }; 9111 ``` 9112 9113