RPC通信

说明： 本模块首批接口从API version 7开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。

导入模块

import rpc from '@ohos.rpc';

MessageParcel

该类提供读写基础类型及数组、IPC对象、接口描述符和自定义序列化对象的方法。

create

create(): MessageParcel

静态方法，创建MessageParcel对象。

系统能力：SystemCapability.Communication.IPC.Core

返回值

类型说明

MessageParcel 返回创建的MessageParcel对象。

类型	说明
MessageParcel	返回创建的MessageParcel对象。

示例

let data = rpc.MessageParcel.create();
console.log("RpcClient: data is " + data);

1
2

reclaim

reclaim(): void

释放不再使用的MessageParcel对象。

系统能力：SystemCapability.Communication.IPC.Core

示例

let reply = rpc.MessageParcel.create();
reply.reclaim();

1
2

writeRemoteObject

writeRemoteObject(object: IRemoteObject): boolean

序列化远程对象并将其写入MessageParcel对象。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名类型必填说明

object IRemoteObject 是要序列化并写入MessageParcel的远程对象。
返回值

类型说明

boolean 如果操作成功，则返回true；否则返回false。

参数名	类型	必填	说明
object	IRemoteObject	是	要序列化并写入MessageParcel的远程对象。

类型	说明
boolean	如果操作成功，则返回true；否则返回false。

示例

class TestRemoteObject extends rpc.RemoteObject {
    constructor(descriptor) {
        super(descriptor);
    }
}
let data = rpc.MessageParcel.create();
let testRemoteObject = new TestRemoteObject("testObject");
data.writeRemoteObject(testRemoteObject);

1
2
3
4
5
6
7
8

readRemoteObject

readRemoteObject(): IRemoteObject

从MessageParcel读取远程对象。此方法用于反序列化MessageParcel对象以生成IRemoteObject。远程对象按写入MessageParcel的顺序读取。

系统能力：SystemCapability.Communication.IPC.Core

返回值

类型说明

IRemoteObject 读取到的远程对象。

类型	说明
IRemoteObject	读取到的远程对象。

示例

class TestRemoteObject extends rpc.RemoteObject {
    constructor(descriptor) {
        super(descriptor);
    }
}
let data = rpc.MessageParcel.create();
let testRemoteObject = new TestRemoteObject("testObject");
data.writeRemoteObject(testRemoteObject);
let proxy = data.readRemoteObject();

1
2
3
4
5
6
7
8
9

writeInterfaceToken

writeInterfaceToken(token: string): boolean

将接口描述符写入MessageParcel对象。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名类型必填说明

token string 是字符串类型描述符。
返回值

类型说明

boolean 如果操作成功，则返回true；否则返回false。

参数名	类型	必填	说明
token	string	是	字符串类型描述符。

类型	说明
boolean	如果操作成功，则返回true；否则返回false。

示例

let data = rpc.MessageParcel.create();
let result = data.writeInterfaceToken("aaa");
console.log("RpcServer: writeInterfaceToken is " + result);

1
2
3

readInterfaceToken

readInterfaceToken(): string

从MessageParcel中读取接口描述符。接口描述符按写入MessageParcel的顺序读取。

系统能力：SystemCapability.Communication.IPC.Core

返回值

类型说明

string 返回读取到的接口描述符。

类型	说明
string	返回读取到的接口描述符。

示例

class Stub extends rpc.RemoteObject {
    onRemoteRequest(code, data, reply, option) {
        let interfaceToken = data.readInterfaceToken();
        console.log("RpcServer: interfaceToken is " + interfaceToken);
        return true;
    }
}

1
2
3
4
5
6
7

getSize

getSize(): number

获取当前MessageParcel的数据大小。

系统能力：SystemCapability.Communication.IPC.Core

返回值

类型说明

number 获取的MessageParcel的数据大小。以字节为单位。

类型	说明
number	获取的MessageParcel的数据大小。以字节为单位。

示例

let data = rpc.MessageParcel.create();
let size = data.getSize();
console.log("RpcClient: size is " + size);

1
2
3

getCapacity

getCapacity(): number

获取当前MessageParcel的容量。

系统能力：SystemCapability.Communication.IPC.Core

返回值

类型说明

number 获取的MessageParcel的容量大小。以字节为单位。

类型	说明
number	获取的MessageParcel的容量大小。以字节为单位。

示例

let data = rpc.MessageParcel.create();
let result = data.getCapacity();
console.log("RpcClient: capacity is " + result);

1
2
3

setSize

setSize(size: number): boolean

设置MessageParcel实例中包含的数据大小。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名类型必填说明

size number 是 MessageParcel实例的数据大小。以字节为单位。
返回值

类型说明

boolean 设置成功返回true，否则返回false。

参数名	类型	必填	说明
size	number	是	MessageParcel实例的数据大小。以字节为单位。

类型	说明
boolean	设置成功返回true，否则返回false。

示例

let data = rpc.MessageParcel.create();
let setSize = data.setSize(16);
console.log("RpcClient: setSize is " + setSize);

1
2
3

setCapacity

setCapacity(size: number): boolean

设置MessageParcel实例的存储容量。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名类型必填说明

size number 是 MessageParcel实例的存储容量。以字节为单位。
返回值

类型说明

boolean 设置成功返回true，否则返回false。

参数名	类型	必填	说明
size	number	是	MessageParcel实例的存储容量。以字节为单位。

类型	说明
boolean	设置成功返回true，否则返回false。

示例

let data = rpc.MessageParcel.create();
let result = data.setCapacity(100);
console.log("RpcClient: setCapacity is " + result);

1
2
3

getWritableBytes

getWritableBytes(): number

获取MessageParcel的可写字节空间。

系统能力：SystemCapability.Communication.IPC.Core

返回值

类型说明

number 获取到的MessageParcel的可写字节空间。以字节为单位。

类型	说明
number	获取到的MessageParcel的可写字节空间。以字节为单位。

示例

class Stub extends rpc.RemoteObject {
    onRemoteRequest(code, data, reply, option) {
        let getWritableBytes = data.getWritableBytes();
        console.log("RpcServer: getWritableBytes is " + getWritableBytes);
        return true;
    }
}

1
2
3
4
5
6
7

getReadableBytes

getReadableBytes(): number

获取MessageParcel的可读字节空间。

系统能力：SystemCapability.Communication.IPC.Core

返回值

类型说明

number 获取到的MessageParcel的可读字节空间。以字节为单位。

类型	说明
number	获取到的MessageParcel的可读字节空间。以字节为单位。

示例

class Stub extends rpc.RemoteObject {
    onRemoteRequest(code, data, reply, option) {
        let result = data.getReadableBytes();
        console.log("RpcServer: getReadableBytes is " + result);
        return true;
    }
}

1
2
3
4
5
6
7

getReadPosition

getReadPosition(): number

获取MessageParcel的读位置。

系统能力：SystemCapability.Communication.IPC.Core

返回值

类型说明

number 返回MessageParcel实例中的当前读取位置。

类型	说明
number	返回MessageParcel实例中的当前读取位置。

示例

let data = rpc.MessageParcel.create();
let readPos = data.getReadPosition();
console.log("RpcClient: readPos is " + readPos);

1
2
3

getWritePosition

getWritePosition(): number

获取MessageParcel的写位置。

系统能力：SystemCapability.Communication.IPC.Core

返回值

类型说明

number 返回MessageParcel实例中的当前写入位置。

类型	说明
number	返回MessageParcel实例中的当前写入位置。

示例

let data = rpc.MessageParcel.create();
data.writeInt(10);
let bwPos = data.getWritePosition();
console.log("RpcClient: bwPos is " + bwPos);

1
2
3
4

rewindRead

rewindRead(pos: number): boolean

重新偏移读取位置到指定的位置。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名类型必填说明

pos number 是开始读取数据的目标位置。
返回值

类型说明

boolean 如果读取位置发生更改，则返回true；否则返回false。

参数名	类型	必填	说明
pos	number	是	开始读取数据的目标位置。

类型	说明
boolean	如果读取位置发生更改，则返回true；否则返回false。

示例

let data = rpc.MessageParcel.create();
data.writeInt(12);
data.writeString("parcel");
let number = data.readInt();
console.log("RpcClient: number is " + number);
data.rewindRead(0);
let number2 = data.readInt();
console.log("RpcClient: rewindRead is " + number2);

1
2
3
4
5
6
7
8

rewindWrite

rewindWrite(pos: number): boolean

重新偏移写位置到指定的位置。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名类型必填说明

pos number 是开始写入数据的目标位置。
返回值

类型说明

boolean 如果写入位置更改，则返回true；否则返回false。

参数名	类型	必填	说明
pos	number	是	开始写入数据的目标位置。

类型	说明
boolean	如果写入位置更改，则返回true；否则返回false。

示例

let data = rpc.MessageParcel.create();
data.writeInt(4);
data.rewindWrite(0);
data.writeInt(5);
let number = data.readInt();
console.log("RpcClient: rewindWrite is: " + number);

1
2
3
4
5
6

writeByte

writeByte(val: number): boolean

将字节值写入MessageParcel实例。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名类型必填说明

val number 是要写入的字节值。
返回值

类型说明

boolean 写入返回成功，否则返回false。

参数名	类型	必填	说明
val	number	是	要写入的字节值。

类型	说明
boolean	写入返回成功，否则返回false。

示例

let data = rpc.MessageParcel.create();
let result = data.writeByte(2);
console.log("RpcClient: writeByte is: " + result);

1
2
3

readByte

readByte(): number

从MessageParcel实例读取字节值。

系统能力：SystemCapability.Communication.IPC.Core

返回值

类型说明

number 返回字节值。

类型	说明
number	返回字节值。

示例

let data = rpc.MessageParcel.create();
let result = data.writeByte(2);
console.log("RpcClient: writeByte is: " + result);
let ret = data.readByte();
console.log("RpcClient: readByte is: " + ret);

1
2
3
4
5

writeShort

writeShort(val: number): boolean

将短整数值写入MessageParcel实例。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名类型必填说明

val number 是要写入的短整数值。
返回值

类型说明

boolean 写入返回true，否则返回false。

参数名	类型	必填	说明
val	number	是	要写入的短整数值。

类型	说明
boolean	写入返回true，否则返回false。

示例

let data = rpc.MessageParcel.create();
let result = data.writeShort(8);
console.log("RpcClient: writeShort is: " + result);

1
2
3

readShort

readShort(): number

从MessageParcel实例读取短整数值。

系统能力：SystemCapability.Communication.IPC.Core

返回值

类型说明

number 返回短整数值。

类型	说明
number	返回短整数值。

示例

let data = rpc.MessageParcel.create();
let result = data.writeShort(8);
console.log("RpcClient: writeShort is: " + result);
let ret = data.readShort();
console.log("RpcClient: readShort is: " + ret);

1
2
3
4
5

writeInt

writeInt(val: number): boolean

将整数值写入MessageParcel实例。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名类型必填说明

val number 是要写入的整数值。
返回值

类型说明

boolean 写入返回成功，否则返回false。

参数名	类型	必填	说明
val	number	是	要写入的整数值。

类型	说明
boolean	写入返回成功，否则返回false。

示例

let data = rpc.MessageParcel.create();
let result = data.writeInt(10);
console.log("RpcClient: writeInt is " + result);

1
2
3

readInt

readInt(): number

从MessageParcel实例读取整数值。

系统能力：SystemCapability.Communication.IPC.Core

返回值

类型说明

number 返回整数值。

类型	说明
number	返回整数值。

示例

let data = rpc.MessageParcel.create();
let result = data.writeInt(10);
console.log("RpcClient: writeInt is " + result);
let ret = data.readInt();
console.log("RpcClient: readInt is " + ret);

1
2
3
4
5

writeLong

writeLong(val: number): boolean

将长整数值写入MessageParcel实例。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名类型必填说明

val number 是要写入的长整数值
返回值

类型说明

boolean 写入成功返回true，否则返回false。

参数名	类型	必填	说明
val	number	是	要写入的长整数值

类型	说明
boolean	写入成功返回true，否则返回false。

示例

let data = rpc.MessageParcel.create();
let result = data.writeLong(10000);
console.log("RpcClient: writeLong is " + result);

1
2
3

readLong

readLong(): number

从MessageParcel实例中读取长整数值。

系统能力：SystemCapability.Communication.IPC.Core

返回值

类型说明

number 返回长整数值。

类型	说明
number	返回长整数值。

示例

let data = rpc.MessageParcel.create();
let result = data.writeLong(10000);
console.log("RpcClient: writeLong is " + result);
let ret = data.readlong();
console.log("RpcClient: readLong is " + ret);

1
2
3
4
5

writeFloat

writeFloat(val: number): boolean

将浮点值写入MessageParcel实例。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名类型必填说明

val number 是要写入的浮点值。
返回值

类型说明

boolean 写入成功返回true，否则返回false。

参数名	类型	必填	说明
val	number	是	要写入的浮点值。

类型	说明
boolean	写入成功返回true，否则返回false。

示例

let data = rpc.MessageParcel.create();
let result = data.writeFloat(1.2);
console.log("RpcClient: writeFloat is " + result);

1
2
3

readFloat

readFloat(): number

从MessageParcel实例中读取浮点值。

系统能力：SystemCapability.Communication.IPC.Core

返回值

类型说明

number 返回浮点值。

类型	说明
number	返回浮点值。

示例

let data = rpc.MessageParcel.create();
let result = data.writeFloat(1.2);
console.log("RpcClient: writeFloat is " + result);
let ret = data.readFloat();
console.log("RpcClient: readFloat is " + ret);

1
2
3
4
5

writeDouble

writeDouble(val: number): boolean

将双精度浮点值写入MessageParcel实例。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名类型必填说明

val number 是要写入的双精度浮点值。
返回值

类型说明

boolean 写入成功返回true，否则返回false。

参数名	类型	必填	说明
val	number	是	要写入的双精度浮点值。

类型	说明
boolean	写入成功返回true，否则返回false。

示例

let data = rpc.MessageParcel.create();
let result = data.writeDouble(10.2);
console.log("RpcClient: writeDouble is " + result);

1
2
3

readDouble

readDouble(): number

从MessageParcel实例读取双精度浮点值。

系统能力：SystemCapability.Communication.IPC.Core

返回值

类型说明

number 返回双精度浮点值。

类型	说明
number	返回双精度浮点值。

示例

let data = rpc.MessageParcel.create();
let result = data.writeDouble(10.2);
console.log("RpcClient: writeDouble is " + result);
let ret = data.readDouble();
console.log("RpcClient: readDouble is " + ret);

1
2
3
4
5

writeBoolean

writeBoolean(val: boolean): boolean

将布尔值写入MessageParcel实例。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名类型必填说明

val boolean 是要写入的布尔值。
返回值

类型说明

boolean 写入成功返回true，否则返回false。

参数名	类型	必填	说明
val	boolean	是	要写入的布尔值。

类型	说明
boolean	写入成功返回true，否则返回false。

示例

let data = rpc.MessageParcel.create();
let result = data.writeBoolean(false);
console.log("RpcClient: writeBoolean is " + result);

1
2
3

readBoolean

readBoolean(): boolean

从MessageParcel实例读取布尔值。

系统能力：SystemCapability.Communication.IPC.Core

返回值

类型说明

boolean 返回读取到的布尔值。

类型	说明
boolean	返回读取到的布尔值。

示例

let data = rpc.MessageParcel.create();
let result = data.writeBoolean(false);
console.log("RpcClient: writeBoolean is " + result);
let ret = data.readBoolean();
console.log("RpcClient: readBoolean is " + ret);

1
2
3
4
5

writeChar

writeChar(val: number): boolean

将单个字符值写入MessageParcel实例。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名类型必填说明

val number 是要写入的单个字符值。
返回值

类型说明

boolean 写入返回true，否则返回false。

参数名	类型	必填	说明
val	number	是	要写入的单个字符值。

类型	说明
boolean	写入返回true，否则返回false。

示例

let data = rpc.MessageParcel.create();
let result = data.writeChar('a');
console.log("RpcClient: writeChar is " + result);

1
2
3

readChar

readChar(): number

从MessageParcel实例中读取单个字符值。

系统能力：SystemCapability.Communication.IPC.Core

返回值

类型说明

number 返回单个字符值。

类型	说明
number	返回单个字符值。

示例

let data = rpc.MessageParcel.create();
let result = data.writeChar('a');
console.log("RpcClient: writeChar is " + result);
let ret = data.readChar();
console.log("RpcClient: readChar is " + ret);

1
2
3
4
5

writeString

writeString(val: string): boolean

将字符串值写入MessageParcel实例。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名类型必填说明

val string 是要写入的字符串值。
返回值

类型说明

boolean 写入成功返回true，否则返回false。

参数名	类型	必填	说明
val	string	是	要写入的字符串值。

类型	说明
boolean	写入成功返回true，否则返回false。

示例

let data = rpc.MessageParcel.create();
let result = data.writeString('abc');
console.log("RpcClient: writeString  is " + result);

1
2
3

readString

readString(): string

从MessageParcel实例读取字符串值。

系统能力：SystemCapability.Communication.IPC.Core

返回值

类型说明

string 返回字符串值。

类型	说明
string	返回字符串值。

示例

let data = rpc.MessageParcel.create();
let result = data.writeString('abc');
console.log("RpcClient: writeString  is " + result);
let ret = data.readString();
console.log("RpcClient: readString is " + ret);

1
2
3
4
5

writeSequenceable

writeSequenceable(val: Sequenceable): boolean

将自定义序列化对象写入MessageParcel实例。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名类型必填说明

val Sequenceable 是要写入的可序列对象。
返回值

类型说明

boolean 写入成功返回true，否则返回false。

参数名	类型	必填	说明
val	Sequenceable	是	要写入的可序列对象。

类型	说明
boolean	写入成功返回true，否则返回false。

示例

class MySequenceable {
    constructor(num, string) {
        this.num = num;
        this.str = string;
    }
    marshalling(messageParcel) {
        messageParcel.writeInt(this.num);
        messageParcel.writeString(this.str);
        return true;
    }
    unmarshalling(messageParcel) {
        this.num = messageParcel.readInt();
        this.str = messageParcel.readString();
        return true;
    }
}
let sequenceable = new MySequenceable(1, "aaa");
let data = rpc.MessageParcel.create();
let result = data.writeSequenceable(sequenceable);
console.log("RpcClient: writeSequenceable is " + result);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

readSequenceable

readSequenceable(dataIn: Sequenceable) : boolean

从MessageParcel实例中读取成员变量到指定的对象（dataIn）。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名类型必填说明

dataIn Sequenceable 是需要从MessageParcel读取成员变量的对象。
返回值

类型说明

boolean 如果反序列成功，则返回true；否则返回false。

示例

class MySequenceable {
    constructor(num, string) {
        this.num = num;
        this.str = string;
    }
    marshalling(messageParcel) {
        messageParcel.writeInt(this.num);
        messageParcel.writeString(this.str);
        return true;
    }
    unmarshalling(messageParcel) {
        this.num = messageParcel.readInt();
        this.str = messageParcel.readString();
        return true;
    }
}
let sequenceable = new MySequenceable(1, "aaa");
let data = rpc.MessageParcel.create();
let result = data.writeSequenceable(sequenceable);
console.log("RpcClient: writeSequenceable is " + result);
let ret = new MySequenceable(0, "");
let result2 = data.readSequenceable(ret);
console.log("RpcClient: writeSequenceable is " + result2);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

writeByteArray

writeByteArray(byteArray: number[]): boolean

将字节数组写入MessageParcel实例。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名类型必填说明

byteArray number[] 是要写入的字节数组。
返回值

类型说明

boolean 写入成功返回true，否则返回false。

示例

let data = rpc.MessageParcel.create();
let ByteArrayVar = new Int8Array([1, 2, 3, 4, 5]);
let result = data.writeByteArray(ByteArrayVar);
console.log("RpcClient: writeByteArray is " + result);

1
2
3
4

readByteArray

readByteArray(dataIn: number[]) : void

从MessageParcel实例读取字节数组。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名类型必填说明

dataIn number[] 是要读取的字节数组。

示例

let data = rpc.MessageParcel.create();
let ByteArrayVar = new Int8Array([1, 2, 3, 4, 5]);
let result = data.writeByteArray(ByteArrayVar);
console.log("RpcClient: writeByteArray is " + result);
let array = new Array(5);
data.readByteArray(array);

1
2
3
4
5
6

readByteArray

readByteArray(): number[]

从MessageParcel实例中读取字节数组。

系统能力：SystemCapability.Communication.IPC.Core

返回值

类型说明

number[] 返回字节数组。

示例

let data = rpc.MessageParcel.create();
let ByteArrayVar = new Int8Array([1, 2, 3, 4, 5]);
let result = data.writeByteArray(ByteArrayVar);
console.log("RpcClient: writeByteArray is " + result);
let array = data.readByteArray();
console.log("RpcClient: readByteArray is " + array);

1
2
3
4
5
6

writeShortArray

writeShortArray(shortArray: number[]): boolean

将短整数数组写入MessageParcel实例。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名类型必填说明

shortArray number[] 是要写入的短整数数组。
返回值

类型说明

boolean 写入返回true，否则返回false。

示例

let data = rpc.MessageParcel.create();
let result = data.writeShortArray([11, 12, 13]);
console.log("RpcClient: writeShortArray is " + result);

1
2
3

readShortArray

readShortArray(dataIn: number[]) : void

从MessageParcel实例中读取短整数数组。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名类型必填说明

dataIn number[] 是要读取的短整数数组。

示例

let data = rpc.MessageParcel.create();
let result = data.writeShortArray([11, 12, 13]);
console.log("RpcClient: writeShortArray is " + result);
let array = new Array(3);
data.readShortArray(array);

1
2
3
4
5

readShortArray

readShortArray(): number[]

从MessageParcel实例中读取短整数数组。

系统能力：SystemCapability.Communication.IPC.Core

返回值

类型说明

number[] 返回短整数数组。

示例

let data = rpc.MessageParcel.create();
let result = data.writeShortArray([11, 12, 13]);
console.log("RpcClient: writeShortArray is " + result);
let array = data.readShortArray();
console.log("RpcClient: readShortArray is " + array);

1
2
3
4
5

writeIntArray

writeIntArray(intArray: number[]): boolean

将整数数组写入MessageParcel实例。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名类型必填说明

intArray number[] 是要写入的整数数组。
返回值

类型说明

boolean 写入返回true，否则返回false。

示例

let data = rpc.MessageParcel.create();
let result = data.writeIntArray([100, 111, 112]);
console.log("RpcClient: writeIntArray is " + result);

1
2
3

readIntArray

readIntArray(dataIn: number[]) : void

从MessageParcel实例中读取整数数组。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名类型必填说明

dataIn number[] 是要读取的整数数组。

示例

let data = rpc.MessageParcel.create();
let result = data.writeIntArray([100, 111, 112]);
console.log("RpcClient: writeIntArray is " + result);
let array = new Array(3);
data.readIntArray(array);

1
2
3
4
5

readIntArray

readIntArray(): number[]

从MessageParcel实例中读取整数数组。

系统能力：SystemCapability.Communication.IPC.Core

返回值

类型说明

number[] 返回整数数组。

示例

let data = rpc.MessageParcel.create();
let result = data.writeIntArray([100, 111, 112]);
console.log("RpcClient: writeIntArray is " + result);
let array = data.readIntArray();
console.log("RpcClient: readIntArray is " + array);

1
2
3
4
5

writeLongArray

writeLongArray(longArray: number[]): boolean

将长整数数组写入MessageParcel实例。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名类型必填说明

longArray number[] 是要写入的长整数数组。
返回值

类型说明

boolean 写入返回true，否则返回false。

示例

let data = rpc.MessageParcel.create();
let result = data.writeLongArray([1111, 1112, 1113]);
console.log("RpcClient: writeLongArray is " + result);

1
2
3

readLongArray

readLongArray(dataIn: number[]) : void

从MessageParcel实例读取长整数数组。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名类型必填说明

dataIn number[] 是要读取的长整数数组。

示例

let data = rpc.MessageParcel.create();
let result = data.writeLongArray([1111, 1112, 1113]);
console.log("RpcClient: writeLongArray is " + result);
let array = new Array(3);
data.readLongArray(array);

1
2
3
4
5

readLongArray

readLongArray(): number[]

从MessageParcel实例中读取长整数数组。

系统能力：SystemCapability.Communication.IPC.Core

返回值

类型说明

number[] 返回长整数数组。

示例

let data = rpc.MessageParcel.create();
let result = data.writeLongArray([1111, 1112, 1113]);
console.log("RpcClient: writeLongArray is " + result);
let array = data.readLongArray();
console.log("RpcClient: readLongArray is " + array);

1
2
3
4
5

writeFloatArray

writeFloatArray(floatArray: number[]): boolean

将浮点数组写入MessageParcel实例。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名类型必填说明

floatArray number[] 是要写入的浮点数组。
返回值

类型说明

boolean 写入返回true，否则返回false。

示例

let data = rpc.MessageParcel.create();
let result = data.writeFloatArray([1.2, 1.3, 1.4]);
console.log("RpcClient: writeFloatArray is " + result);

1
2
3

readFloatArray

readFloatArray(dataIn: number[]) : void

从MessageParcel实例中读取浮点数组。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名类型必填说明

dataIn number[] 是要读取的浮点数组。

示例

let data = rpc.MessageParcel.create();
let result = data.writeFloatArray([1.2, 1.3, 1.4]);
console.log("RpcClient: writeFloatArray is " + result);
let array = new Array(3);
data.readFloatArray(array);

1
2
3
4
5

readFloatArray

readFloatArray(): number[]

从MessageParcel实例中读取浮点数组。

系统能力：SystemCapability.Communication.IPC.Core

返回值

类型说明

number[] 返回浮点数组。

示例

let data = rpc.MessageParcel.create();
let result = data.writeFloatArray([1.2, 1.3, 1.4]);
console.log("RpcClient: writeFloatArray is " + result);
let array = data.readFloatArray();
console.log("RpcClient: readFloatArray is " + array);

1
2
3
4
5

writeDoubleArray

writeDoubleArray(doubleArray: number[]): boolean

将双精度浮点数组写入MessageParcel实例。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名类型必填说明

doubleArray number[] 是要写入的双精度浮点数组。
返回值

类型说明

boolean 写入返回true，否则返回false。

示例

let data = rpc.MessageParcel.create();
let result = data.writeDoubleArray([11.1, 12.2, 13.3]);
console.log("RpcClient: writeDoubleArray is " + result);

1
2
3

readDoubleArray

readDoubleArray(dataIn: number[]) : void

从MessageParcel实例中读取双精度浮点数组。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名类型必填说明

dataIn number[] 是要读取的双精度浮点数组。

示例

let data = rpc.MessageParcel.create();
let result = data.writeDoubleArray([11.1, 12.2, 13.3]);
console.log("RpcClient: writeDoubleArray is " + result);
let array = new Array(3);
data.readDoubleArray(array);

1
2
3
4
5

readDoubleArray

readDoubleArray(): number[]

从MessageParcel实例读取双精度浮点数组。

系统能力：SystemCapability.Communication.IPC.Core

返回值

类型说明

number[] 返回双精度浮点数组。

示例

let data = rpc.MessageParcel.create();
let result = data.writeDoubleArray([11.1, 12.2, 13.3]);
console.log("RpcClient: writeDoubleArray is " + result);
let array = data.readDoubleArray();
console.log("RpcClient: readDoubleArray is " + array);

1
2
3
4
5

writeBooleanArray

writeBooleanArray(booleanArray: boolean[]): boolean

将布尔数组写入MessageParcel实例。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名类型必填说明

booleanArray boolean[] 是要写入的布尔数组。
返回值

类型说明

boolean 写入成功返回true，否则返回false。

示例

let data = rpc.MessageParcel.create();
let result = data.writeBooleanArray([false, true, false]);
console.log("RpcClient: writeBooleanArray is " + result);

1
2
3

readBooleanArray

readBooleanArray(dataIn: boolean[]) : void

从MessageParcel实例中读取布尔数组。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名类型必填说明

dataIn boolean[] 是要读取的布尔数组。

示例

let data = rpc.MessageParcel.create();
let result = data.writeBooleanArray([false, true, false]);
console.log("RpcClient: writeBooleanArray is " + result);
let array = new Array(3);
data.readBooleanArray(array);

1
2
3
4
5

readBooleanArray

readBooleanArray(): boolean[]

从MessageParcel实例中读取布尔数组。

系统能力：SystemCapability.Communication.IPC.Core

返回值

类型	说明
boolean[]	返回布尔数组。

let data = rpc.MessageParcel.create();
let result = data.writeBooleanArray([false, true, false]);
console.log("RpcClient: writeBooleanArray is " + result);
let array = data.readBooleanArray();
console.log("RpcClient: readBooleanArray is " + array);

1
2
3
4
5

writeCharArray

writeCharArray(charArray: number[]): boolean

将单个字符数组写入MessageParcel实例。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名类型必填说明

charArray number[] 是要写入的单个字符数组。
返回值

类型说明

boolean 写入成功返回true，否则返回false。

示例

let data = rpc.MessageParcel.create();
let result = data.writeCharArray(['a', 'b', 'c']);
console.log("RpcClient: writeCharArray is " + result);

1
2
3

readCharArray

readCharArray(dataIn: number[]) : void

从MessageParcel实例中读取单个字符数组。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名类型必填说明

dataIn number[] 是要读取的单个字符数组。

示例

let data = rpc.MessageParcel.create();
let result = data.writeCharArray(['a', 'b', 'c']);
console.log("RpcClient: writeCharArray is " + result);
let array = new Array(3);
data.readCharArray(array);

1
2
3
4
5

readCharArray

readCharArray(): number[]

从MessageParcel实例读取单个字符数组。

系统能力：SystemCapability.Communication.IPC.Core

返回值

类型说明

number[] 返回单个字符数组。

示例

let data = rpc.MessageParcel.create();
let result = data.writeCharArray(['a', 'b', 'c']);
console.log("RpcClient: writeCharArray is " + result);
let array = data.readCharArray();
console.log("RpcClient: readCharArray is " + array);

1
2
3
4
5

writeStringArray

writeStringArray(stringArray: string[]): boolean

将字符串数组写入MessageParcel实例。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名类型必填说明

stringArray string[] 是要写入的字符串数组。
返回值

类型说明

boolean 写入成功返回true，否则返回false。

示例

let data = rpc.MessageParcel.create();
let result = data.writeStringArray(["abc", "def"]);
console.log("RpcClient: writeStringArray is " + result);

1
2
3

readStringArray

readStringArray(dataIn: string[]) : void

从MessageParcel实例读取字符串数组。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名类型必填说明

dataIn string[] 是要读取的字符串数组。

示例

let data = rpc.MessageParcel.create();
let result = data.writeStringArray(["abc", "def"]);
console.log("RpcClient: writeStringArray is " + result);
let array = new Array(2);
data.readStringArray(array);

1
2
3
4
5

readStringArray

readStringArray(): string[]

从MessageParcel实例读取字符串数组。

系统能力：SystemCapability.Communication.IPC.Core

返回值

类型说明

string[] 返回字符串数组。

示例

let data = rpc.MessageParcel.create();
let result = data.writeStringArray(["abc", "def"]);
console.log("RpcClient: writeStringArray is " + result);
let array = data.readStringArray();
console.log("RpcClient: readStringArray is " + array);

1
2
3
4
5

writeNoException⁸⁺

writeNoException(): void

向MessageParcel写入“指示未发生异常”的信息。

系统能力：SystemCapability.Communication.IPC.Core

示例

class TestRemoteObject extends rpc.RemoteObject {
    constructor(descriptor) {
        super(descriptor);
    }
    onRemoteRequest(code, data, reply, option) {
        if (code === 1) {
            console.log("RpcServer: onRemoteRequest called");
            reply.writeNoException();
            return true;
        } else {
            console.log("RpcServer: unknown code: " + code);
            return false;
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

readException⁸⁺

readException(): void

从MessageParcel中读取异常。

系统能力：SystemCapability.Communication.IPC.Core

示例

import FA from "@ohos.ability.featureAbility";
let proxy;
let connect = {
    onConnect: function(elementName, remoteProxy) {
        console.log("RpcClient: js onConnect called.");
        proxy = remoteProxy;
    },
    onDisconnect: function(elementName) {
        console.log("RpcClient: onDisconnect");
    },
    onFailed: function() {
        console.log("RpcClient: onFailed");
    }
};
let want = {
    "bundleName": "com.ohos.server",
    "abilityName": "com.ohos.server.MainAbility",
};
FA.connectAbility(want, connect);
let option = new rpc.MessageOption();
let data = rpc.MessageParcel.create();
let reply = rpc.MessageParcel.create();
data.writeInt(1);
data.writeString("hello");
proxy.sendRequest(1, data, reply, option)
    .then(function(errCode) {
        if (errCode === 0) {
            console.log("sendRequest got result");
            reply.readException();
            let msg = reply.readString();
            console.log("RPCTest: reply msg: " + msg);
        } else {
            console.log("RPCTest: sendRequest failed, errCode: " + errCode);
        }
    }).catch(function(e) {
        console.log("RPCTest: sendRequest got exception: " + e.message);
    }).finally (() => {
        console.log("RPCTest: sendRequest ends, reclaim parcel");
        data.reclaim();
        reply.reclaim();
    });

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

writeSequenceableArray

writeSequenceableArray(sequenceableArray: Sequenceable[]): boolean

将可序列化对象数组写入MessageParcel实例。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名类型必填说明

sequenceableArray Sequenceable[] 是要写入的可序列化对象数组。
返回值

类型说明

boolean 写入成功返回true，否则返回false。

示例

class MySequenceable {
    constructor(num, string) {
        this.num = num;
        this.str = string;
    }
    marshalling(messageParcel) {
        messageParcel.writeInt(this.num);
        messageParcel.writeString(this.str);
        return true;
    }
    unmarshalling(messageParcel) {
        this.num = messageParcel.readInt();
        this.str = messageParcel.readString();
        return true;
    }
}
let sequenceable = new MySequenceable(1, "aaa");
let sequenceable2 = new MySequenceable(2, "bbb");
let sequenceable3 = new MySequenceable(3, "ccc");
let a = [sequenceable, sequenceable2, sequenceable3];
let data = rpc.MessageParcel.create();
let result = data.writeSequenceableArray(a);
console.log("RpcClient: writeSequenceableArray is " + result);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

readSequenceableArray⁸⁺

readSequenceableArray(sequenceableArray: Sequenceable[]): void

从MessageParcel实例读取可序列化对象数组。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名类型必填说明

sequenceableArray Sequenceable[] 是要读取的可序列化对象数组。

示例

class MySequenceable {
    constructor(num, string) {
        this.num = num;
        this.str = string;
    }
    marshalling(messageParcel) {
        messageParcel.writeInt(this.num);
        messageParcel.writeString(this.str);
        return true;
    }
    unmarshalling(messageParcel) {
        this.num = messageParcel.readInt();
        this.str = messageParcel.readString();
        return true;
    }
}
let sequenceable = new MySequenceable(1, "aaa");
let sequenceable2 = new MySequenceable(2, "bbb");
let sequenceable3 = new MySequenceable(3, "ccc");
let a = [sequenceable, sequenceable2, sequenceable3];
let data = rpc.MessageParcel.create();
let result = data.writeSequenceableArray(a);
console.log("RpcClient: writeSequenceableArray is " + result);
let b = [new MySequenceable(0, ""), new MySequenceable(0, ""), new MySequenceable(0, "")];
data.readSequenceableArray(b);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

writeRemoteObjectArray⁸⁺

writeRemoteObjectArray(objectArray: IRemoteObject[]): boolean

将IRemoteObject对象数组写入MessageParcel。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名类型必填说明

objectArray IRemoteObject[] 是要写入MessageParcel的IRemoteObject对象数组。
返回值

类型说明

boolean 如果IRemoteObject对象数组成功写入MessageParcel，则返回true；如果对象为null或数组写入MessageParcel失败，则返回false。

示例

class TestRemoteObject extends rpc.RemoteObject {
    constructor(descriptor) {
        super(descriptor);
        this.attachLocalInterface(this, descriptor);
    }
}
let a = [new TestRemoteObject("testObject1"), new TestRemoteObject("testObject2"), new TestRemoteObject("testObject3")];
let data = rpc.MessageParcel.create();
let result = data.writeRemoteObjectArray(a);
console.log("RpcClient: writeRemoteObjectArray is " + result);

1
2
3
4
5
6
7
8
9
10

readRemoteObjectArray⁸⁺

readRemoteObjectArray(objects: IRemoteObject[]): void

从MessageParcel读取IRemoteObject对象数组。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名类型必填说明

objects IRemoteObject[] 是从MessageParcel读取的IRemoteObject对象数组。

示例

class TestRemoteObject extends rpc.RemoteObject {
    constructor(descriptor) {
        super(descriptor);
        this.attachLocalInterface(this, descriptor);
    }
}
let a = [new TestRemoteObject("testObject1"), new TestRemoteObject("testObject2"), new TestRemoteObject("testObject3")];
let data = rpc.MessageParcel.create();
let result = data.writeRemoteObjectArray(a);
let b = new Array(3);
data.readRemoteObjectArray(b);

1
2
3
4
5
6
7
8
9
10
11

readRemoteObjectArray⁸⁺

readRemoteObjectArray(): IRemoteObject[]

从MessageParcel读取IRemoteObject对象数组。

系统能力：SystemCapability.Communication.IPC.Core

返回值

类型说明

IRemoteObject[] 返回IRemoteObject对象数组。

示例

class TestRemoteObject extends rpc.RemoteObject {
    constructor(descriptor) {
        super(descriptor);
        this.attachLocalInterface(this, descriptor);
    }
}
let a = [new TestRemoteObject("testObject1"), new TestRemoteObject("testObject2"), new TestRemoteObject("testObject3")];
let data = rpc.MessageParcel.create();
let result = data.writeRemoteObjectArray(a);
console.log("RpcClient: readRemoteObjectArray is " + result);
let b = data.readRemoteObjectArray();
console.log("RpcClient: readRemoteObjectArray is " + b);

1
2
3
4
5
6
7
8
9
10
11
12

closeFileDescriptor⁸⁺

static closeFileDescriptor(fd: number): void

关闭给定的文件描述符。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名类型必填说明

fd number 是要关闭的文件描述符。

示例

import fileio from '@ohos.fileio';
let filePath = "path/to/file";
let fd = fileio.openSync(filePath, 0o2| 0o100, 0o666);
rpc.MessageParcel.closeFileDescriptor(fd);

1
2
3
4

dupFileDescriptor⁸⁺

static dupFileDescriptor(fd: number) :number

复制给定的文件描述符。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名类型必填说明

fd number 是表示已存在的文件描述符。
返回值

类型说明

number 返回新的文件描述符。

示例

import fileio from '@ohos.fileio';
let filePath = "path/to/file";
let fd = fileio.openSync(filePath, 0o2| 0o100, 0o666);
let newFd = rpc.MessageParcel.dupFileDescriptor(fd);

1
2
3
4

containFileDescriptors⁸⁺

containFileDescriptors(): boolean

检查此MessageParcel对象是否包含文件描述符。

系统能力：SystemCapability.Communication.IPC.Core

返回值

类型说明

boolean 如果此MessageParcel对象包含文件描述符，则返回true；否则返回false。

示例

import fileio from '@ohos.fileio';
let parcel = new rpc.MessageParcel();
let filePath = "path/to/file";
let r1 = parcel.containFileDescriptors();
let fd = fileio.openSync(filePath, 0o2| 0o100, 0o666);
let writeResult = parcel.writeFileDescriptor(fd);
console.log("RpcTest: parcel writeFd result is : " + writeResult);
let containFD = parcel.containFileDescriptors();
console.log("RpcTest: parcel after write fd containFd result is : " + containFD);

1
2
3
4
5
6
7
8
9

writeFileDescriptor⁸⁺

writeFileDescriptor(fd: number): boolean

写入文件描述符到MessageParcel。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名类型必填说明

fd number 是文件描述符。
返回值

类型说明

boolean 如果操作成功，则返回true；否则返回false。

示例

import fileio from '@ohos.fileio';
let parcel = new rpc.MessageParcel();
let filePath = "path/to/file";
let fd = fileio.openSync(filePath, 0o2| 0o100, 0o666);
let writeResult = parcel.writeFileDescriptor(fd);
console.log("RpcTest: parcel writeFd result is : " + writeResult);

1
2
3
4
5
6

readFileDescriptor⁸⁺

readFileDescriptor(): number

从MessageParcel中读取文件描述符。

系统能力：SystemCapability.Communication.IPC.Core

返回值

类型说明

number 返回文件描述符。

示例

import fileio from '@ohos.fileio';
let parcel = new rpc.MessageParcel();
let filePath = "path/to/file";
let fd = fileio.openSync(filePath, 0o2| 0o100, 0o666);
let writeResult = parcel.writeFileDescriptor(fd);
let readFD = parcel.readFileDescriptor();
console.log("RpcTest: parcel read fd is : " + readFD);

1
2
3
4
5
6
7

writeAshmem⁸⁺

writeAshmem(ashmem: Ashmem): boolean

将指定的匿名共享对象写入此MessageParcel。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名类型必填说明

ashmem Ashmem 是要写入MessageParcel的匿名共享对象。
返回值

类型说明

boolean 如果匿名共享对象成功写入此MessageParcel，则返回true；否则返回false。

示例

let parcel = new rpc.MessageParcel();
let ashmem = rpc.Ashmem.createAshmem("ashmem", 1024);
let isWriteSuccess = parcel.writeAshmem(ashmem);
console.log("RpcTest: write ashmem to result is : " + isWriteSuccess);

1
2
3
4

readAshmem⁸⁺

readAshmem(): Ashmem

从MessageParcel读取匿名共享对象。

系统能力：SystemCapability.Communication.IPC.Core

返回值

类型说明

Ashmem 返回匿名共享对象。

示例

let parcel = new rpc.MessageParcel();
let ashmem = rpc.Ashmem.createAshmem("ashmem", 1024);
let isWriteSuccess = parcel.writeAshmem(ashmem);
console.log("RpcTest: write ashmem to result is : " + isWriteSuccess);
let readAshmem = parcel.readAshmem();
console.log("RpcTest: read ashmem to result is : " + readAshmem);

1
2
3
4
5
6

getRawDataCapacity⁸⁺

getRawDataCapacity(): number

获取MessageParcel可以容纳的最大原始数据量。

系统能力：SystemCapability.Communication.IPC.Core

返回值

类型说明

number 返回MessageParcel可以容纳的最大原始数据量，即128 Mb。

示例

let parcel = new rpc.MessageParcel();
let result = parcel.getRawDataCapacity();
console.log("RpcTest: parcel get RawDataCapacity result is : " + result);

1
2
3

writeRawData⁸⁺

writeRawData(rawData: number[], size: number): boolean

将原始数据写入MessageParcel对象。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名类型必填说明

rawData number[] 是要写入的原始数据。

size number 是发送的原始数据大小，以字节为单位。
返回值

类型说明

boolean 如果操作成功，则返回true；否则返回false。

示例

let parcel = new rpc.MessageParcel();
let arr = new Int8Array([1, 2, 3, 4, 5]);
let isWriteSuccess = parcel.writeRawData(arr, arr.length);
console.log("RpcTest: parcel write raw data result is : " + isWriteSuccess);

1
2
3
4

readRawData⁸⁺

readRawData(size: number): number[]

从MessageParcel读取原始数据。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名类型必填说明

size number 是要读取的原始数据的大小。
返回值

类型说明

number[] 返回原始数据（以字节为单位）。

示例

let parcel = new rpc.MessageParcel();
let arr = new Int8Array([1, 2, 3, 4, 5]);
let isWriteSuccess = parcel.writeRawData(arr, arr.length);
console.log("RpcTest: parcel write raw data result is : " + isWriteSuccess);
let result = parcel.readRawData(5);
console.log("RpcTest: parcel read raw data result is : " + result);

1
2
3
4
5
6

Sequenceable

在进程间通信（IPC）期间，将类的对象写入MessageParcel并从MessageParcel中恢复它们。

marshalling

marshalling(dataOut: MessageParcel): boolean

将此可序列对象封送到MessageParcel中。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名类型必填说明

dataOut MessageParcel 是可序列对象将被封送到的MessageParcel对象。
返回值

类型说明

boolean 如果封送成功，则返回true；否则返回false。

示例

class MySequenceable {
    constructor(num, string) {
        this.num = num;
        this.str = string;
    }
    marshalling(messageParcel) {
        messageParcel.writeInt(this.num);
        messageParcel.writeString(this.str);
        return true;
    }
    unmarshalling(messageParcel) {
        this.num = messageParcel.readInt();
        this.str = messageParcel.readString();
        return true;
    }
}
let sequenceable = new MySequenceable(1, "aaa");
let data = rpc.MessageParcel.create();
let result = data.writeSequenceable(sequenceable);
console.log("RpcClient: writeSequenceable is " + result);
let ret = new MySequenceable(0, "");
let result2 = data.readSequenceable(ret);
console.log("RpcClient: readSequenceable is " + result2);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

unmarshalling

unmarshalling(dataIn: MessageParcel) : boolean

从MessageParcel中解封此可序列对象。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名类型必填说明

dataIn MessageParcel 是已将可序列对象封送到其中的MessageParcel对象。
返回值

类型说明

boolean 如果可序列化成功，则返回true；否则返回false。

示例

class MySequenceable {
    constructor(num, string) {
        this.num = num;
        this.str = string;
    }
    marshalling(messageParcel) {
        messageParcel.writeInt(this.num);
        messageParcel.writeString(this.str);
        return true;
    }
    unmarshalling(messageParcel) {
        this.num = messageParcel.readInt();
        this.str = messageParcel.readString();
        return true;
    }
}
let sequenceable = new MySequenceable(1, "aaa");
let data = rpc.MessageParcel.create();
let result = data.writeSequenceable(sequenceable);
console.log("RpcClient: writeSequenceable is " + result);
let ret = new MySequenceable(0, "");
let result2 = data.readSequenceable(ret);
console.log("RpcClient: readSequenceable is " + result2);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

IRemoteBroker

远端对象的代理持有者。用于获取代理对象。

asObject

asObject(): IRemoteObject

需派生类实现，获取代理或远端对象。

系统能力：SystemCapability.Communication.IPC.Core

返回值

类型说明

IRemoteObject 如果调用者是RemoteObject对象，则直接返回本身；如果调用者是RemoteProxy对象，则返回它的持有者IRemoteObject。

示例

class TestAbility extends rpc.RemoteObject {
    asObject() {
        return this;
    }
}

1
2
3
4
5

示例

class TestProxy {
    constructor(remote) {
        this.remote = remote;
    }
    asObject() {
        return this.remote;
    }
}

1
2
3
4
5
6
7
8

DeathRecipient

用于订阅远端对象的死亡通知。当被订阅该通知的远端对象死亡时，本端可收到消息，调用onRemoteDied接口。远端对象死亡可以为远端对象所在进程死亡，远端对象所在设备关机或重启，当远端对象与本端对象属于不同设备时，也可为远端对象离开组网时。

onRemoteDied

onRemoteDied(): void

在成功添加死亡通知订阅后，当远端对象死亡时，将自动调用本方法。

系统能力：SystemCapability.Communication.IPC.Core

示例

class MyDeathRecipient {
    onRemoteDied() {
        console.log("server is died");
    }
}

1
2
3
4
5

SendRequestResult⁸⁺

发送请求的响应结果。

系统能力：以下各项对应的系统能力均为SystemCapability.Communication.IPC.Core。

参数	值	说明
errCode	number	错误码。
code	number	消息代码。
data	MessageParcel	发送给对端进程的MessageParcel对象。
reply	MessageParcel	对端进程返回的MessageParcel对象。

IRemoteObject

该接口可用于查询或获取接口描述符、添加或删除死亡通知、转储对象状态到特定文件、发送消息。

queryLocalInterface

queryLocalInterface(descriptor: string): IRemoteBroker

查询接口。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名类型必填说明

descriptor string 是接口描述符的字符串。
返回值

类型说明

IRemoteBroker 返回绑定到指定接口描述符的IRemoteBroker对象。

sendRequest

sendRequest(code : number, data : MessageParcel, reply : MessageParcel, options : MessageOption): boolean;⁷

sendRequest(code : number, data : MessageParcel, reply : MessageParcel, options : MessageOption): Promise<SendRequestResult>⁸⁺

以同步或异步方式向对端进程发送MessageParcel消息。如果为选项设置了异步模式，则期约立即兑现，reply报文里没有内容。如果为选项设置了同步模式，则期约将在sendRequest返回时兑现，回复内容在reply报文里。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名	类型	必填	说明
code	number	是	本次请求调用的消息码，由通信双方确定。如果接口由IDL工具生成，则消息代码由IDL自动生成。
data	MessageParcel	是	保存待发送数据的 MessageParcel对象。
reply	MessageParcel	是	接收应答数据的MessageParcel对象。
options	MessageOption	是	本次请求的同异步模式，默认同步调用。

返回值

类型	说明
Promise<number>⁷ Promise<SendRequestResult>⁸⁺	返回一个期约，兑现值是sendRequest错误码。0表示成功，其他情况表示失败。⁷ 返回一个期约，兑现值是sendRequestResult实例。⁸⁺

sendRequest⁸⁺

sendRequest(code: number, data: MessageParcel, reply: MessageParcel, options: MessageOption, callback: AsyncCallback<SendRequestResult>): void

以同步或异步方式向对端进程发送MessageParcel消息。如果为选项设置了异步模式，则立即收到回调，reply报文里没有内容。如果为选项设置了同步模式，则将在sendRequest返回时收到回调，回复内容在reply报文里。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名	类型	必填	说明
code	number	是	本次请求调用的消息码，由通信双方确定。如果接口由IDL工具生成，则消息代码由IDL自动生成。
data	MessageParcel	是	保存待发送数据的 MessageParcel对象。
reply	MessageParcel	是	接收应答数据的MessageParcel对象。
options	MessageOption	是	本次请求的同异步模式，默认同步调用。
callback	AsyncCallback<SendRequestResult>	是	接收发送结果的回调。

addDeathrecipient

addDeathRecipient(recipient: DeathRecipient, flags: number): boolean

注册用于接收远程对象死亡通知的回调。如果与RemoteProxy对象匹配的远程对象进程死亡，则调用此方法。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名类型必填说明

recipient DeathRecipient 是要注册的回调。

flags number 是死亡通知标志。
返回值

类型说明

boolean 如果回调注册成功，则返回true；否则返回false。

removeDeathRecipient

removeDeathRecipient(recipient: DeathRecipient, flags: number): boolean

注销用于接收远程对象死亡通知的回调。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名类型必填说明

recipient DeathRecipient 是要注销的回调。

flags number 是死亡通知标志。
返回值

类型说明

boolean 如果回调成功注销，则返回true；否则返回false。

getInterfaceDescriptor

getInterfaceDescriptor(): string

获取对象的接口描述符。接口描述符为字符串。

系统能力：SystemCapability.Communication.IPC.Core

返回值
类型说明

string 返回接口描述符。

isObjectDead

isObjectDead(): boolean

检查当前对象是否死亡。

系统能力：SystemCapability.Communication.IPC.Core

返回值
类型说明

boolean 如果对象已死亡，则返回true；否则返回false。

RemoteProxy

实现IRemoteObject代理对象。

系统能力：以下各项对应的系统能力均为SystemCapability.Communication.IPC.Core。

参数	值	说明
PING_TRANSACTION	1599098439 (0x5f504e47)	内部指令码，用于测试IPC服务正常。
DUMP_TRANSACTION	1598311760 (0x5f444d50)	内部指令码，获取Binder内部状态。
INTERFACE_TRANSACTION	1598968902 (0x5f4e5446)	内部指令码，获取对端接口描述符。
MIN_TRANSACTION_ID	1 (0x00000001)	最小有效指令码。
MAX_TRANSACTION_ID	16777215 (0x00FFFFFF)	最大有效指令码。

sendRequest

sendRequest(code : number, data : MessageParcel, reply : MessageParcel, options : MessageOption): boolean;⁷

sendRequest(code : number, data : MessageParcel, reply : MessageParcel, options : MessageOption): Promise<SendRequestResult>⁸⁺

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名	类型	必填	说明
code	number	是	本次请求调用的消息码，由通信双方确定。如果接口由IDL工具生成，则消息代码由IDL自动生成。
data	MessageParcel	是	保存待发送数据的 MessageParcel对象。
reply	MessageParcel	是	接收应答数据的MessageParcel对象。
options	MessageOption	是	本次请求的同异步模式，默认同步调用。

返回值

类型	说明
Promise<number>⁷ Promise<SendRequestResult>⁸⁺	返回一个期约，兑现值是sendRequest错误码。0表示成功，其他情况表示失败。⁷ 返回一个期约，兑现值是sendRequestResult实例。⁸⁺

示例⁷

import FA from "@ohos.ability.featureAbility";
let proxy;
let connect = {
    onConnect: function(elementName, remoteProxy) {
        console.log("RpcClient: js onConnect called.");
        proxy = remoteProxy;
    },
    onDisconnect: function(elementName) {
        console.log("RpcClient: onDisconnect");
    },
    onFailed: function() {
        console.log("RpcClient: onFailed");
    }
};
let want = {
    "bundleName": "com.ohos.server",
    "abilityName": "com.ohos.server.MainAbility",
};
FA.connectAbility(want, connect);
let option = new rpc.MessageOption();
let data = rpc.MessageParcel.create();
let reply = rpc.MessageParcel.create();
data.writeInt(1);
data.writeString("hello");
proxy.sendRequest(1, data, reply, option)
    .then(function(errCode) {
        if (errCode === 0) {
            console.log("sendRequest got result");
            let msg = reply.readString();
            console.log("RPCTest: reply msg: " + msg);
        } else {
            console.log("RPCTest: sendRequest failed, errCode: " + errCode);
        }
    }).catch(function(e) {
        console.log("RPCTest: sendRequest got exception: " + e.message);
    }).finally (() => {
        console.log("RPCTest: sendRequest ends, reclaim parcel");
        data.reclaim();
        reply.reclaim();
    });

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

示例⁸⁺

import FA from "@ohos.ability.featureAbility";
let proxy;
let connect = {
    onConnect: function(elementName, remoteProxy) {
        console.log("RpcClient: js onConnect called.");
        proxy = remoteProxy;
    },
    onDisconnect: function(elementName) {
        console.log("RpcClient: onDisconnect");
    },
    onFailed: function() {
        console.log("RpcClient: onFailed");
    }
};
let want = {
    "bundleName": "com.ohos.server",
    "abilityName": "com.ohos.server.MainAbility",
};
FA.connectAbility(want, connect);
let option = new rpc.MessageOption();
let data = rpc.MessageParcel.create();
let reply = rpc.MessageParcel.create();
data.writeInt(1);
data.writeString("hello");
proxy.sendRequest(1, data, reply, option)
    .then(function(result) {
        if (result.errCode === 0) {
            console.log("sendRequest got result");
            result.reply.readException();
            let msg = result.reply.readString();
            console.log("RPCTest: reply msg: " + msg);
        } else {
            console.log("RPCTest: sendRequest failed, errCode: " + result.errCode);
        }
    }).catch(function(e) {
        console.log("RPCTest: sendRequest got exception: " + e.message);
    }).finally (() => {
        console.log("RPCTest: sendRequest ends, reclaim parcel");
        data.reclaim();
        reply.reclaim();
    });

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

sendRequest⁸⁺

sendRequest(code: number, data: MessageParcel, reply: MessageParcel, options: MessageOption, callback: AsyncCallback<SendRequestResult>): void

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名	类型	必填	说明
code	number	是	本次请求调用的消息码，由通信双方确定。如果接口由IDL工具生成，则消息代码由IDL自动生成。
data	MessageParcel	是	保存待发送数据的 MessageParcel对象。
reply	MessageParcel	是	接收应答数据的MessageParcel对象。
options	MessageOption	是	本次请求的同异步模式，默认同步调用。
callback	AsyncCallback<SendRequestResult>	是	接收发送结果的回调。

示例

import FA from "@ohos.ability.featureAbility";
let proxy;
let connect = {
    onConnect: function(elementName, remoteProxy) {
        console.log("RpcClient: js onConnect called.");
        proxy = remoteProxy;
    },
    onDisconnect: function(elementName) {
        console.log("RpcClient: onDisconnect");
    },
    onFailed: function() {
        console.log("RpcClient: onFailed");
    }
};
let want = {
    "bundleName": "com.ohos.server",
    "abilityName": "com.ohos.server.MainAbility",
};
function sendRequestCallback(result) {
    if (result.errCode === 0) {
        console.log("sendRequest got result");
        result.reply.readException();
        let msg = result.reply.readString();
        console.log("RPCTest: reply msg: " + msg);
    } else {
        console.log("RPCTest: sendRequest failed, errCode: " + result.errCode);
    }
    console.log("RPCTest: sendRequest ends, reclaim parcel");
    result.data.reclaim();
    result.reply.reclaim();
}
FA.connectAbility(want, connect);
let option = new rpc.MessageOption();
let data = rpc.MessageParcel.create();
let reply = rpc.MessageParcel.create();
data.writeInt(1);
data.writeString("hello");
proxy.sendRequest(1, data, reply, option, sendRequestCallback);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

queryLocalInterface

queryLocalInterface(interface: string): IRemoteBroker

查询并获取当前接口描述符对应的本地接口对象。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名类型必填说明

interface string 是需要查询的接口描述符。
返回值

类型说明

IRemoteBroker 默认返回Null，标识该接口是一个代理侧接口。

示例

import FA from "@ohos.ability.featureAbility";
let proxy;
let connect = {
    onConnect: function(elementName, remoteProxy) {
        console.log("RpcClient: js onConnect called.");
        proxy = remoteProxy;
    },
    onDisconnect: function (elementName) {
        console.log("RpcClient: onDisconnect");
    },
    onFailed: function() {
        console.log("RpcClient: onFailed");
    }
};
let want = {
    "bundleName":"com.ohos.server",
    "abilityName":"com.ohos.server.MainAbility",
};
FA.connectAbility(want, connect);
let broker = proxy.queryLocalInterface("testObject");
console.log("RpcClient: queryLocalInterface is " + broker);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

addDeathRecippient

addDeathRecipient(recipient : DeathRecipient, flags : number): boolean

注册用于接收远程对象死亡通知的回调，增加proxy对象上的死亡通知。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名类型必填说明

recipient DeathRecipient 是收件人表示要注册的回调。

flags number 是死亡通知标志。保留参数。设置为0。
返回值

类型说明

boolean 如果回调注册成功，则返回true；否则返回false。

示例

import FA from "@ohos.ability.featureAbility";
let proxy;
let connect = {
    onConnect: function(elementName, remoteProxy) {
        console.log("RpcClient: js onConnect called.");
        proxy = remoteProxy;
    },
    onDisconnect: function(elementName) {
        console.log("RpcClient: onDisconnect");
    },
    onFailed: function() {
        console.log("RpcClient: onFailed");
    }
};
let want = {
    "bundleName": "com.ohos.server",
    "abilityName": "com.ohos.server.MainAbility",
};
FA.connectAbility(want, connect);
class MyDeathRecipient {
    onRemoteDied() {
        console.log("server is died");
    }
}
let deathRecipient = new MyDeathRecipient();
proxy.addDeathRecippient(deathRecipient, 0);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

removeDeathRecipient

removeDeathRecipient(recipient : DeathRecipient, flags : number): boolean

注销用于接收远程对象死亡通知的回调。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名类型必填说明

recipient DeathRecipient 是要注销的死亡回调。

flags number 是死亡通知标志。保留参数。设置为0。
返回值

类型说明

boolean 如果回调成功注销，则返回true；否则返回false。

示例

import FA from "@ohos.ability.featureAbility";
let proxy;
let connect = {
    onConnect: function(elementName, remoteProxy) {
        console.log("RpcClient: js onConnect called.");
        proxy = remoteProxy;
    },
    onDisconnect: function(elementName) {
        console.log("RpcClient: onDisconnect");
    },
    onFailed: function() {
        console.log("RpcClient: onFailed");
    }
};
let want = {
    "bundleName": "com.ohos.server",
    "abilityName": "com.ohos.server.MainAbility",
};
FA.connectAbility(want, connect);
class MyDeathRecipient {
    onRemoteDied() {
        console.log("server is died");
    }
}
let deathRecipient = new MyDeathRecipient();
proxy.addDeathRecippient(deathRecipient, 0);
proxy.removeDeathRecipient(deathRecipient, 0);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

getInterfaceDescriptor

getInterfaceDescriptor(): string

查询当前代理对象接口的描述符。

系统能力：SystemCapability.Communication.IPC.Core

返回值

类型说明

string 当前的接口描述符。

示例

import FA from "@ohos.ability.featureAbility";
let proxy;
let connect = {
    onConnect: function(elementName, remoteProxy) {
        console.log("RpcClient: js onConnect called.");
        proxy = remoteProxy;
    },
    onDisconnect: function(elementName) {
        console.log("RpcClient: onDisconnect");
    },
    onFailed: function() {
        console.log("RpcClient: onFailed");
    }
};
let want = {
    "bundleName": "com.ohos.server",
    "abilityName": "com.ohos.server.MainAbility",
};
FA.connectAbility(want, connect);
let descriptor = proxy.getInterfaceDescriptor();
console.log("RpcClient: descriptor is " + descriptor);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

isObjectDead

isObjectDead(): boolean

指示对应的RemoteObject是否死亡。

系统能力：SystemCapability.Communication.IPC.Core

返回值

类型说明

boolean 如果对应的RemoteObject已经死亡，返回true，否则返回false。

示例

import FA from "@ohos.ability.featureAbility";
let proxy;
let connect = {
    onConnect: function(elementName, remoteProxy) {
        console.log("RpcClient: js onConnect called.");
        proxy = remoteProxy;
    },
    onDisconnect: function(elementName) {
        console.log("RpcClient: onDisconnect");
    },
    onFailed: function() {
        console.log("RpcClient: onFailed");
    }
};
let want = {
    "bundleName": "com.ohos.server",
    "abilityName": "com.ohos.server.MainAbility",
};
FA.connectAbility(want, connect);
let isDead = proxy.isObjectDead();
console.log("RpcClient: isObjectDead is " + isDead);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

MessageOption

公共消息选项（int标志，int等待时间），使用标志中指定的标志构造指定的MessageOption对象。

系统能力：以下各项对应的系统能力均为SystemCapability.Communication.IPC.Core。

参数	值	说明
TF_SYNC	0	同步调用。
TF_ASYNC	1	异步调用。
TF_ACCEPT_FDS	0x10	指示sendRequest接口可以返回文件描述符。
TF_WAIT_TIME	8	等待时间。单位秒。

constructor

constructor(syncFlags?: number, waitTime = TF_WAIT_TIME)

MessageOption构造函数。

系统能力：SystemCapability.Communication.IPC.Core

参数
参数名类型必填说明

syncFlags number 否同步调用或异步调用标志。默认同步调用。

waitTime number 否调用rpc最长等待时间。默认 TF_WAIT_TIME。

getFlags

getFlags(): number

获取同步调用或异步调用标志。

系统能力：SystemCapability.Communication.IPC.Core

返回值
类型说明

number 调用成功返回同步调用或异步调用标志。

setFlags

setFlags(flags: number): void

设置同步调用或异步调用标志。

系统能力：SystemCapability.Communication.IPC.Core

参数
参数名类型必填说明

flags number 是同步调用或异步调用标志。

getWaitTime

getWaitTime(): number

获取rpc调用的最长等待时间。

系统能力：SystemCapability.Communication.IPC.Core

返回值
类型说明

number rpc最长等待时间。

setWaitTime

setWaitTime(waitTime: number): void

设置rpc调用最长等待时间。

系统能力：SystemCapability.Communication.IPC.Core

参数
参数名类型必填说明

waitTime number 是 rpc调用最长等待时间。

IPCSkeleton

用于获取IPC上下文信息，包括获取UID和PID、获取本端和对端设备ID、检查接口调用是否在同一设备上。

getContextObject

static getContextObject(): IRemoteObject

获取系统能力的管理者。

系统能力：SystemCapability.Communication.IPC.Core

返回值

类型说明

IRemoteObject 返回系统能力管理者。

示例

let samgr = rpc.IPCSkeleton.getContextObject();
console.log("RpcServer: getContextObject result: " + samgr);

1
2

getCallingPid

static getCallingPid(): number

获取调用者的PID。此方法由RemoteObject对象在onRemoteRequest方法中调用，不在IPC上下文环境（onRemoteRequest）中调用则返回本进程的PID。

系统能力：SystemCapability.Communication.IPC.Core

返回值

类型说明

number 返回调用者的PID。

示例

class Stub extends rpc.RemoteObject {
    onRemoteRequest(code, data, reply, option) {
        let callerPid = rpc.IPCSkeleton.getCallingPid();
        console.log("RpcServer: getCallingPid result: " + callerPid);
        return true;
    }
}

1
2
3
4
5
6
7

getCallingUid

static getCallingUid(): number

获取调用者的UID。此方法由RemoteObject对象在onRemoteRequest方法中调用，不在IPC上下文环境（onRemoteRequest）中调用则返回本进程的UID。

系统能力：SystemCapability.Communication.IPC.Core

返回值

类型说明

number 返回调用者的UID。

示例

class Stub extends rpc.RemoteObject {
    onRemoteRequest(code, data, reply, option) {
        let callerUid = rpc.IPCSkeleton.getCallingUid();
        console.log("RpcServer: getCallingUid result: " + callerUid);
        return true;
    }
}

1
2
3
4
5
6
7

getCallingTokenId

static getCallingTokenId(): number;

获取调用者的TokenId，用于被调用方对调用方的身份校验。

系统能力：SystemCapability.Communication.IPC.Core

返回值

类型说明

number 返回调用者的TokenId。

示例

class Stub extends rpc.RemoteObject {
    onRemoteRequest(code, data, reply, option) {
        let callerTokenId = rpc.IPCSkeleton.getCallingTokenId();
        console.log("RpcServer: getCallingTokenId result: " + callerTokenId);
        return true;
    }
}

1
2
3
4
5
6
7

getCalligDeviceID

static getCallingDeviceID(): string

获取调用者进程所在的设备ID。

系统能力：SystemCapability.Communication.IPC.Core

返回值

类型说明

string 返回调用者进程所在的设备ID。

示例

class Stub extends rpc.RemoteObject {
    onRemoteRequest(code, data, reply, option) {
        let callerDeviceID = rpc.IPCSkeleton.getCalligDeviceID();
        console.log("RpcServer: callerDeviceID is: " + callerDeviceID);
        return true;
    }
}

1
2
3
4
5
6
7

getLocalDeviceID

static getLocalDeviceID(): string

获取本端设备ID。

系统能力：SystemCapability.Communication.IPC.Core

返回值

类型说明

string 返回本地设备的ID。

示例

class Stub extends rpc.RemoteObject {
    onRemoteRequest(code, data, reply, option) {
        let localDeviceID = rpc.IPCSkeleton.getLocalDeviceID();
        console.log("RpcServer: localDeviceID is: " + localDeviceID);
        return true;
    }
}

1
2
3
4
5
6
7

isLocalCalling

static isLocalCalling(): boolean

检查当前通信对端是否是本设备的进程。

系统能力：SystemCapability.Communication.IPC.Core

返回值

类型说明

boolean 如果调用是在同一设备上进行的，则返回true，否则返回false。

示例

class Stub extends rpc.RemoteObject {
    onRemoteRequest(code, data, reply, option) {
        let isLocalCalling = rpc.IPCSkeleton.isLocalCalling();
        console.log("RpcServer: isLocalCalling is: " + isLocalCalling);
        return true;
    }
}

1
2
3
4
5
6
7

flushCommands

static flushCommands(object : IRemoteObject): number

将所有挂起的命令从指定的RemoteProxy刷新到相应的RemoteObject。建议在执行任何时间敏感操作之前调用此方法。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名类型必填说明

object IRemoteObject 是指定的RemoteProxy。
返回值

类型说明

number 如果操作成功，返回0；如果输入对象为空或RemoteObject，或者操作失败，返回错误代码。

示例

let remoteObject = new rpc.RemoteObject("aaa", 3);
let ret = rpc.IPCSkeleton.flushCommands(remoteObject);
console.log("RpcServer: flushCommands result: " + ret);

1
2
3

resetCallingIdentity

static resetCallingIdentity(): string

将远程用户的UID和PID替换为本地用户的UID和PID。它可以用于身份验证等场景。

系统能力：SystemCapability.Communication.IPC.Core

返回值

类型说明

string 返回包含远程用户的UID和PID的字符串。

示例

class Stub extends rpc.RemoteObject {
    onRemoteRequest(code, data, reply, option) {
        let callingIdentity = rpc.IPCSkeleton.resetCallingIdentity();
        console.log("RpcServer: callingIdentity is: " + callingIdentity);
        return true;
    }
}

1
2
3
4
5
6
7

setCallingIdentity

static setCallingIdentity(identity : string): boolean

将UID和PID恢复为远程用户的UID和PID。它通常在使用resetCallingIdentity后调用，需要resetCallingIdentity返回的远程用户的UID和PID。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名类型必填说明

identity string 是标识表示包含远程用户UID和PID的字符串。由resetCallingIdentity返回。
返回值

类型说明

boolean 如果操作成功，则返回true；否则返回false。

示例

class Stub extends rpc.RemoteObject {
    onRemoteRequest(code, data, reply, option) {
        let callingIdentity = null;
        try {
            callingIdentity = rpc.IPCSkeleton.resetCallingIdentity();
            console.log("RpcServer: callingIdentity is: " + callingIdentity);
        } finally {
            let ret = rpc.IPCSkeleton.setCallingIdentity("callingIdentity ");
            console.log("RpcServer: setCallingIdentity is: " + ret);
        }
        return true;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13

RemoteObject

实现远程对象。服务提供者必须继承此类。

constructor

constructor(descriptor: string)

RemoteObject构造函数。

系统能力：SystemCapability.Communication.IPC.Core

参数
参数名类型必填说明

descriptor string 是接口描述符。

sendRequest

sendRequest(code : number, data : MessageParcel, reply : MessageParcel, options : MessageOption): boolean;⁷

sendRequest(code : number, data : MessageParcel, reply : MessageParcel, options : MessageOption): Promise<SendRequestResult>⁸⁺

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名	类型	必填	说明
code	number	是	本次请求调用的消息码，由通信双方确定。如果接口由IDL工具生成，则消息代码由IDL自动生成。
data	MessageParcel	是	保存待发送数据的 MessageParcel对象。
reply	MessageParcel	是	接收应答数据的MessageParcel对象。
options	MessageOption	是	本次请求的同异步模式，默认同步调用。

返回值

类型	说明
Promise<number>⁷ Promise<SendRequestResult>⁸⁺	返回一个期约，兑现值是sendRequest错误码。0表示成功，其他情况表示失败。⁷ 返回一个期约，兑现值是sendRequestResult实例。⁸⁺

示例⁷

class TestRemoteObject extends rpc.RemoteObject {
    constructor(descriptor) {
        super(descriptor);
    }
}
let testRemoteObject = new TestRemoteObject("testObject");
let option = new rpc.MessageOption();
let data = rpc.MessageParcel.create();
let reply = rpc.MessageParcel.create();
data.writeInt(1);
data.writeString("hello");
testRemoteObject.sendRequest(1, data, reply, option)
    .then(function(errCode) {
        if (errCode === 0) {
            console.log("sendRequest got result");
            let msg = reply.readString();
            console.log("RPCTest: reply msg: " + msg);
        } else {
            console.log("RPCTest: sendRequest failed, errCode: " + errCode);
        }
    }).catch(function(e) {
        console.log("RPCTest: sendRequest got exception: " + e.message);
    }).finally (() => {
        console.log("RPCTest: sendRequest ends, reclaim parcel");
        data.reclaim();
        reply.reclaim();
    });

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

示例⁸⁺

class TestRemoteObject extends rpc.RemoteObject {
    constructor(descriptor) {
        super(descriptor);
    }
}
let testRemoteObject = new TestRemoteObject("testObject");
let option = new rpc.MessageOption();
let data = rpc.MessageParcel.create();
let reply = rpc.MessageParcel.create();
data.writeInt(1);
data.writeString("hello");
testRemoteObject.sendRequest(1, data, reply, option)
    .then(function(result) {
        if (result.errCode === 0) {
            console.log("sendRequest got result");
            result.reply.readException();
            let msg = result.reply.readString();
            console.log("RPCTest: reply msg: " + msg);
        } else {
            console.log("RPCTest: sendRequest failed, errCode: " + result.errCode);
        }
    }).catch(function(e) {
        console.log("RPCTest: sendRequest got exception: " + e.message);
    }).finally (() => {
        console.log("RPCTest: sendRequest ends, reclaim parcel");
        data.reclaim();
        reply.reclaim();
    });

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

sendRequest⁸⁺

sendRequest(code: number, data: MessageParcel, reply: MessageParcel, options: MessageOption, callback: AsyncCallback<SendRequestResult>): void

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名	类型	必填	说明
code	number	是	本次请求调用的消息码，由通信双方确定。如果接口由IDL工具生成，则消息代码由IDL自动生成。
data	MessageParcel	是	保存待发送数据的 MessageParcel对象。
reply	MessageParcel	是	接收应答数据的MessageParcel对象。
options	MessageOption	是	本次请求的同异步模式，默认同步调用。
AsyncCallback	AsyncCallback<SendRequestResult>	是	接收发送结果的回调。

示例

class TestRemoteObject extends rpc.RemoteObject {
    constructor(descriptor) {
        super(descriptor);
    }
}
function sendRequestCallback(result) {
    if (result.errCode === 0) {
        console.log("sendRequest got result");
        result.reply.readException();
        let msg = result.reply.readString();
        console.log("RPCTest: reply msg: " + msg);
    } else {
        console.log("RPCTest: sendRequest failed, errCode: " + result.errCode);
    }
    console.log("RPCTest: sendRequest ends, reclaim parcel");
    result.data.reclaim();
    result.reply.reclaim();
}
let testRemoteObject = new TestRemoteObject("testObject");
let option = new rpc.MessageOption();
let data = rpc.MessageParcel.create();
let reply = rpc.MessageParcel.create();
data.writeInt(1);
data.writeString("hello");
testRemoteObject.sendRequest(1, data, reply, option, sendRequestCallback);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

onRemoteRequest

onRemoteRequest(code : number, data : MessageParcel, reply: MessageParcel, options : MessageOption): boolean

sendRequest请求的响应处理函数，服务端在该函数里处理请求，回复结果。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名	类型	必填	说明
code	number	是	对端发送的服务请求码。
data	MessageParcel	是	携带客户端调用参数的MessageParcel对象。
reply	MessageParcel	是	写入结果的MessageParcel对象。
option	MessageOption	是	指示操作是同步还是异步。

返回值

类型说明

boolean 如果操作成功，则返回true；否则返回false。

示例

class TestRemoteObject extends rpc.RemoteObject {
    constructor(descriptor) {
        super(descriptor);
    }

    onRemoteRequest(code, data, reply, option) {
        if (code === 1) {
            console.log("RpcServer: onRemoteRequest called");
            return true;
        } else {
            console.log("RpcServer: unknown code: " + code);
            return false;
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

getCallingUid

getCallingUid(): number

获取通信对端的进程Uid。

系统能力：SystemCapability.Communication.IPC.Core

返回值

类型说明

number 返回通信对端的进程Uid。

示例

class TestRemoteObject extends rpc.RemoteObject {
    constructor(descriptor) {
        super(descriptor);
    }
}
let testRemoteObject = new TestRemoteObject("testObject");
console.log("RpcServer: getCallingUid: " + testRemoteObject.getCallingUid());

1
2
3
4
5
6
7

getCallingPid

getCallingPid(): number

获取通信对端的进程Pid。

系统能力：SystemCapability.Communication.IPC.Core

返回值

类型说明

number 返回通信对端的进程Pid。

示例

class TestRemoteObject extends rpc.RemoteObject {
    constructor(descriptor) {
        super(descriptor);
    }
}
let testRemoteObject = new TestRemoteObject("testObject");
console.log("RpcServer: getCallingPid: " + testRemoteObject.getCallingPid());

1
2
3
4
5
6
7

queryLocalInterface

queryLocalInterface(descriptor: string): IRemoteBroker

查询并获取当前接口描述符对应的远端对象是否已经存在。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名类型必填说明

descriptor string 是需要查询的接口描述符。
返回值

类型说明

IRemoteBroker 如果接口描述符对应的远端对象存在，则返回该远端对象，否则返回Null。

示例

class TestRemoteObject extends rpc.RemoteObject {
    constructor(descriptor) {
        super(descriptor);
    }
}
let testRemoteObject = new TestRemoteObject("testObject");
let broker = testRemoteObject.queryLocalInterface("testObject");

1
2
3
4
5
6
7

getInterfaceDescriptor

getInterfaceDescriptor(): string

查询接口描述符。

系统能力：SystemCapability.Communication.IPC.Core

返回值

类型说明

string 返回接口描述符。

示例

class TestRemoteObject extends rpc.RemoteObject {
    constructor(descriptor) {
        super(descriptor);
    }
}
let testRemoteObject = new TestRemoteObject("testObject");
let descriptor = testRemoteObject.getInterfaceDescriptor();
console.log("RpcServer: descriptor is: " + descriptor);

1
2
3
4
5
6
7
8

attachLocalInterface

attachLocalInterface(localInterface: IRemoteBroker, descriptor: string): void

此接口用于把接口描述符和IRemoteBroker对象绑定。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名类型必填说明

localInterface IRemoteBroker 是将与描述符绑定的IRemoteBroker对象。

descriptor string 是用于与IRemoteBroker对象绑定的描述符。

示例

class TestRemoteObject extends rpc.RemoteObject {
    constructor(descriptor) {
        super(descriptor);
        this.attachLocalInterface(this, descriptor);
    }
}
let testRemoteObject = new TestRemoteObject("testObject");

1
2
3
4
5
6
7

Ashmem⁸⁺

提供与匿名共享内存对象相关的方法，包括创建、关闭、映射和取消映射Ashmem、从Ashmem读取数据和写入数据、获取Ashmem大小、设置Ashmem保护。

映射内存保护类型：

系统能力：以下各项对应的系统能力均为SystemCapability.Communication.IPC.Core。

参数名	值	说明
PROT_EXEC	4	映射的内存可执行
PROT_NONE	0	映射的内存不可访问
PROT_READ	1	映射的内存可读
PROT_WRITE	2	映射的内存可写

createAshmem⁸⁺

static createAshmem(name: string, size: number): Ashmem

根据指定的名称和大小创建Ashmem对象。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名类型必填说明

name string 是名称，用于查询Ashmem信息。

size number 是 Ashmem的大小，以字节为单位。
返回值

类型说明

Ashmem 返回创建的Ashmem对象；如果创建失败，返回null。

示例

let ashmem = rpc.Ashmem.createAshmem("ashmem", 1024*1024);
let size = ashmem.getAshmemSize();
console.log("RpcTest: get ashemm by createAshmem : " + ashmem + " size is : " + size);

1
2
3

createAshmemFromExisting⁸⁺

static createAshmemFromExisting(ashmem: Ashmem): Ashmem

通过复制现有Ashmem对象的文件描述符(fd)来创建Ashmem对象。两个Ashmem对象指向同一个共享内存区域。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名类型必填说明

ashmem Ashmem 是已存在的Ashmem对象。
返回值

类型说明

Ashmem 返回创建的Ashmem对象。

示例

let ashmem = rpc.Ashmem.createAshmem("ashmem", 1024*1024);
let ashmem2 = rpc.Ashmem.createAshmemFromExisting(ashmem);
let size = ashmem2.getAshmemSize();
console.log("RpcTest: get ashemm by createAshmemFromExisting : " + ashmem2 + " size is : " + size);

1
2
3
4

closeAshmem⁸⁺

closeAshmem(): void

关闭这个Ashmem。

系统能力：SystemCapability.Communication.IPC.Core

示例

let ashmem = rpc.Ashmem.createAshmem("ashmem", 1024*1024);
ashmem.closeAshmem();

1
2

unmapAshmem⁸⁺

unmapAshmem(): void

删除该Ashmem对象的地址映射。

系统能力：SystemCapability.Communication.IPC.Core

示例

let ashmem = rpc.Ashmem.createAshmem("ashmem", 1024*1024);
ashmem.unmapAshmem();

1
2

getAshmemSize⁸⁺

getAshmemSize(): number

获取Ashmem对象的内存大小。

系统能力：SystemCapability.Communication.IPC.Core

返回值

类型说明

number 返回Ashmem对象的内存大小。

示例

let ashmem = rpc.Ashmem.createAshmem("ashmem", 1024*1024);
let size = ashmem.getAshmemSize();
console.log("RpcTest: get ashmem is " + ashmem + " size is : " + size);

1
2
3

mapAshmem⁸⁺

mapAshmem(mapType: number): boolean

在此进程的虚拟地址空间上创建共享文件映射，映射区域大小由此Ashmem对象指定。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名类型必填说明

mapType number 是指定映射的内存区域的保护等级。
返回值

类型说明

boolean 如果映射成功，则返回true；否则返回false。

示例

let ashmem = rpc.Ashmem.createAshmem("ashmem", 1024*1024);
let mapReadAndWrite = ashmem.mapAshmem(rpc.Ashmem.PROT_READ | rpc.Ashmem.PROT_WRITE);
console.log("RpcTest: map ashmem result is  : " + mapReadAndWrite);

1
2
3

mapReadAndWriteAshmem⁸⁺

mapReadAndWriteAshmem(): boolean

在此进程虚拟地址空间上创建可读写的共享文件映射。

系统能力：SystemCapability.Communication.IPC.Core

返回值

类型说明

boolean 如果映射成功，则返回true；否则返回false。

示例

let ashmem = rpc.Ashmem.createAshmem("ashmem", 1024*1024);
let mapResult = ashmem.mapReadAndWriteAshmem();
console.log("RpcTest: map ashmem result is  : " + mapResult);

1
2
3

mapReadOnlyAshmem⁸⁺

mapReadOnlyAshmem(): boolean

在此进程虚拟地址空间上创建只读的共享文件映射。

系统能力：SystemCapability.Communication.IPC.Core

返回值

类型说明

boolean 如果映射成功，则返回true；否则返回false。

示例

let ashmem = rpc.Ashmem.createAshmem("ashmem", 1024*1024);
let mapResult = ashmem.mapReadOnlyAshmem();
console.log("RpcTest: Ashmem mapReadOnlyAshmem result is : " + mapResult);

1
2
3

setProtection⁸⁺

setProtection(protectionType: number): boolean

设置映射内存区域的保护等级。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名类型必填说明

protectionType number 是要设置的保护类型。
返回值

类型说明

boolean 如果设置成功，则返回true；否则返回false。

示例

let ashmem = rpc.Ashmem.createAshmem("ashmem", 1024*1024);
let result = ashmem.setProtection(rpc.Ashmem.PROT_READ);
console.log("RpcTest: Ashmem setProtection result is : " + result);

1
2
3

writeToAshmem⁸⁺

writeToAshmem(buf: number[], size: number, offset: number): boolean

将数据写入此Ashmem对象关联的共享文件。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名	类型	必填	说明
buf	number[]	是	写入Ashmem对象的数据。
size	number	是	要写入的数据大小。
offset	number	是	要写入的数据在此Ashmem对象关联的内存区间的起始位置

返回值

类型说明

boolean 如果数据写入成功，则返回true；在其他情况下，如数据写入越界或未获得写入权限，则返回false。

示例

let ashmem = rpc.Ashmem.createAshmem("ashmem", 1024*1024);
var ByteArrayVar = new Int8Array([1, 2, 3, 4, 5]);
let writeResult = ashmem.writeToAshmem(ByteArrayVar, 5, 0);
console.log("RpcTest: write to Ashmem result is  : " + writeResult);

1
2
3
4

readFromAshmem⁸⁺

readFromAshmem(size: number, offset: number): number[]

从此Ashmem对象关联的共享文件中读取数据。

系统能力：SystemCapability.Communication.IPC.Core

参数

参数名类型必填说明

size number 是要读取的数据的大小。

offset number 是要读取的数据在此Ashmem对象关联的内存区间的起始位置
返回值

类型说明

number[] 返回读取的数据。

示例

let ashmem = rpc.Ashmem.createAshmem("ashmem", 1024*1024);
var ByteArrayVar = new Int8Array([1, 2, 3, 4, 5]);
let writeResult = ashmem.writeToAshmem(ByteArrayVar, 5, 0);
console.log("RpcTest: write to Ashmem result is  : " + writeResult);
let readResult = ashmem.readFromAshmem(5, 0);
console.log("RpcTest: read to Ashmem result is  : " + readResult);

1
2
3
4
5
6

RPC通信

RPC通信

导入模块

MessageParcel

create

reclaim

writeRemoteObject

readRemoteObject

writeInterfaceToken

readInterfaceToken

getSize

getCapacity

setSize

setCapacity

getWritableBytes

getReadableBytes

getReadPosition

getWritePosition

rewindRead

rewindWrite

writeByte

readByte

writeShort

readShort

writeInt

readInt

writeLong

readLong

writeFloat

readFloat

writeDouble

readDouble

writeBoolean

readBoolean

writeChar

readChar

writeString

readString

writeSequenceable

readSequenceable

writeByteArray

readByteArray

readByteArray

writeShortArray

readShortArray

readShortArray

writeIntArray

readIntArray

readIntArray

writeLongArray

readLongArray

readLongArray

writeFloatArray

readFloatArray

readFloatArray

writeDoubleArray

readDoubleArray

readDoubleArray

writeBooleanArray

readBooleanArray

readBooleanArray

writeCharArray

readCharArray

readCharArray

writeStringArray

readStringArray

readStringArray

writeNoException8+

readException8+

writeSequenceableArray

readSequenceableArray8+

writeRemoteObjectArray8+

readRemoteObjectArray8+

readRemoteObjectArray8+

closeFileDescriptor8+

dupFileDescriptor8+

containFileDescriptors8+

writeFileDescriptor8+

readFileDescriptor8+

writeAshmem8+

writeNoException⁸⁺

readException⁸⁺

readSequenceableArray⁸⁺

writeRemoteObjectArray⁸⁺

readRemoteObjectArray⁸⁺

readRemoteObjectArray⁸⁺

closeFileDescriptor⁸⁺

dupFileDescriptor⁸⁺

containFileDescriptors⁸⁺

writeFileDescriptor⁸⁺

readFileDescriptor⁸⁺

writeAshmem⁸⁺

readAshmem⁸⁺

getRawDataCapacity⁸⁺

writeRawData⁸⁺

readRawData⁸⁺

SendRequestResult⁸⁺

sendRequest⁸⁺

sendRequest⁸⁺

sendRequest⁸⁺

Ashmem⁸⁺

createAshmem⁸⁺

createAshmemFromExisting⁸⁺

closeAshmem⁸⁺

unmapAshmem⁸⁺

getAshmemSize⁸⁺

mapAshmem⁸⁺

mapReadAndWriteAshmem⁸⁺

mapReadOnlyAshmem⁸⁺

setProtection⁸⁺

writeToAshmem⁸⁺