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