HarmonyOS API：@ohos.rpc (RPC通信)

joytrian

发布于 2023-4-7 15:59

浏览

0收藏

版本：v3.1 Beta

@ohos.rpc (RPC通信)

writeFloatArray

writeFloatArray(floatArray: number[]): boolean

将浮点数组写入MessageParcel实例。

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

参数：

参数名	类型	必填	说明
floatArray	number[]	是	要写入的浮点数组。由于系统内部对float类型的数据是按照double处理的，使用时对于数组所占的总字节数应按照double类型来计算。

返回值：

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

示例：

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

readFloatArray

readFloatArray(dataIn: number[]): void

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

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

参数：

参数名	类型	必填	说明
dataIn	number[]	是	要读取的浮点数组。由于系统内部对float类型的数据是按照double处理的，使用时对于数组所占的总字节数应按照double类型来计算。

示例：

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);

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);

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);

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);

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);

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);

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);

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);

writeCharArray

writeCharArray(charArray: number[]): boolean

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

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

参数：

参数名	类型	必填	说明
charArray	number[]	是	要写入的单个字符数组。

返回值：

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

示例：

let data = rpc.MessageParcel.create();
let result = data.writeCharArray([97, 98, 88]);
console.log("RpcClient: writeCharArray is " + result);

readCharArray

readCharArray(dataIn: number[]): void

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

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

参数：

参数名	类型	必填	说明
dataIn	number[]	是	要读取的单个字符数组。

示例：

let data = rpc.MessageParcel.create();
let result = data.writeCharArray([97, 98, 99]);
console.log("RpcClient: writeCharArray is " + result);
let array = new Array(3);
data.readCharArray(array);

readCharArray

readCharArray(): number[]

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

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

返回值：

类型	说明
number[]	返回单个字符数组。

示例：

let data = rpc.MessageParcel.create();
let result = data.writeCharArray([97, 98, 99]);
console.log("RpcClient: writeCharArray is " + result);
let array = data.readCharArray();
console.log("RpcClient: readCharArray is " + array);

writeStringArray

writeStringArray(stringArray: string[]): boolean

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

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

参数：

参数名	类型	必填	说明
stringArray	string[]	是	要写入的字符串数组，数组单个元素的长度应小于40960字节。

返回值：

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

示例：

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

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);

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);

writeNoException⁸⁺

writeNoException(): void

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

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

示例：

class MyDeathRecipient {
    onRemoteDied() {
        console.log("server died");
    }
}
class TestRemoteObject extends rpc.RemoteObject {
    constructor(descriptor) {
        super(descriptor);
    }
    addDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean {
        return true;
    }
    removeDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean {
        return true;
    }
    isObjectDead(): boolean {
        return false;
    }
    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;
        }
    }
}

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.sendMessageRequest(1, data, reply, option)
    .then(function(errCode) {
        if (errCode === 0) {
            console.log("sendMessageRequest got result");
            reply.readException();
            let msg = reply.readString();
            console.log("RPCTest: reply msg: " + msg);
        } else {
            console.log("RPCTest: sendMessageRequest failed, errCode: " + errCode);
        }
    }).catch(function(e) {
        console.log("RPCTest: sendMessageRequest got exception: " + e.message);
    }).finally (() => {
        console.log("RPCTest: sendMessageRequest ends, reclaim parcel");
        data.reclaim();
        reply.reclaim();
    });

writeSequenceableArray

writeSequenceableArray(sequenceableArray: Sequenceable[]): boolean

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

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

参数：

参数名	类型	必填	说明
sequenceableArray	Sequenceable[]	是	要写入的可序列化对象数组。

返回值：

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

示例：

class MySequenceable {
    num: number;
    str: string;
    constructor(num, str) {
        this.num = num;
        this.str = str;
    }
    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);

readSequenceableArray⁸⁺

readSequenceableArray(sequenceableArray: Sequenceable[]): void

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

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

参数：

参数名	类型	必填	说明
sequenceableArray	Sequenceable[]	是	要读取的可序列化对象数组。

示例：

class MySequenceable {
    num: number;
    str: string;
    constructor(num, str) {
        this.num = num;
        this.str = str;
    }
    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);

writeRemoteObjectArray⁸⁺

writeRemoteObjectArray(objectArray: IRemoteObject[]): boolean

将IRemoteObject对象数组写入MessageParcel。

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

参数：

参数名	类型	必填	说明
objectArray	IRemoteObject[]	是	要写入MessageParcel的IRemoteObject对象数组。

返回值：

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

示例：

class MyDeathRecipient {
    onRemoteDied() {
        console.log("server died");
    }
}
class TestRemoteObject extends rpc.RemoteObject {
    constructor(descriptor) {
        super(descriptor);
        this.attachLocalInterface(this, descriptor);
    }
    addDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean {
        return true;
    }
    removeDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean {
        return true;
    }
    isObjectDead(): boolean {
        return false;
    }
    asObject(): rpc.IRemoteObject {
        return this;
    }
}
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);

readRemoteObjectArray⁸⁺

readRemoteObjectArray(objects: IRemoteObject[]): void

从MessageParcel读取IRemoteObject对象数组。

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

参数：

参数名	类型	必填	说明
objects	IRemoteObject[]	是	从MessageParcel读取的IRemoteObject对象数组。

示例：

class MyDeathRecipient {
    onRemoteDied() {
        console.log("server died");
    }
}
class TestRemoteObject extends rpc.RemoteObject {
    constructor(descriptor) {
        super(descriptor);
        this.attachLocalInterface(this, descriptor);
    }
    addDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean {
        return true;
    }
    removeDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean {
        return true;
    }
    isObjectDead(): boolean {
       return false;
    }
    asObject(): rpc.IRemoteObject {
        return this;
    }
}
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);

readRemoteObjectArray⁸⁺

readRemoteObjectArray(): IRemoteObject[]

从MessageParcel读取IRemoteObject对象数组。

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

返回值：

类型	说明
IRemoteObject[]	返回IRemoteObject对象数组。

示例：

class MyDeathRecipient {
    onRemoteDied() {
        console.log("server died");
    }
}
class TestRemoteObject extends rpc.RemoteObject {
    constructor(descriptor) {
        super(descriptor);
        this.attachLocalInterface(this, descriptor);
    }
    addDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean {
        return true;
    }
    removeDeathRecipient(recipient: MyDeathRecipient, flags: number): boolean {
        return true;
    }
    isObjectDead(): boolean {
        return false;
    }
    asObject(): rpc.IRemoteObject {
        return this;
    }
}
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);

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);

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);

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);

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);

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);

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);

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);

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);

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 = [1, 2, 3, 4, 5];
let isWriteSuccess = parcel.writeRawData(arr, arr.length);
console.log("RpcTest: parcel write raw data result is : " + isWriteSuccess);

readRawData⁸⁺

readRawData(size: number): number[]

从MessageParcel读取原始数据。

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

参数：

参数名	类型	必填	说明
size	number	是	要读取的原始数据的大小。

返回值：

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

示例：

let parcel = new rpc.MessageParcel();
let arr = [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);

Parcelable⁹⁺

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

marshalling

marshalling(dataOut: MessageSequence): boolean

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

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

参数：

参数名	类型	必填	说明
dataOut	MessageSequence	是	可序列对象将被封送到的MessageSequence对象。

返回值：

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

示例：

class MyParcelable {
    num: number;
    str: string;
    constructor(num, str) {
        this.num = num;
        this.str = str;
    }
    marshalling(messageSequence) {
        messageSequence.writeInt(this.num);
        messageSequence.writeString(this.str);
        return true;
    }
    unmarshalling(messageSequence) {
        this.num = messageSequence.readInt();
        this.str = messageSequence.readString();
        return true;
    }
}
let parcelable = new MyParcelable(1, "aaa");
let data = rpc.MessageSequence.create();
let result = data.writeParcelable(parcelable);
console.log("RpcClient: writeParcelable is " + result);
let ret = new MyParcelable(0, "");
let result2 = data.readParcelable(ret);
console.log("RpcClient: readParcelable is " + result2);

unmarshalling

unmarshalling(dataIn: MessageSequence): boolean

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

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

参数：

参数名	类型	必填	说明
dataIn	MessageSequence	是	已将可序列对象封送到其中的MessageSequence对象。

返回值：

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

示例：

class MyParcelable {
    num: number;
    str: string;
    constructor(num, str) {
        this.num = num;
        this.str = str;
    }
    marshalling(messageSequence) {
        messageSequence.writeInt(this.num);
        messageSequence.writeString(this.str);
        return true;
    }
    unmarshalling(messageSequence) {
        this.num = messageSequence.readInt();
        this.str = messageSequence.readString();
        return true;
    }
}
let parcelable = new MyParcelable(1, "aaa");
let data = rpc.MessageSequence.create();
let result = data.writeParcelable(parcelable);
console.log("RpcClient: writeParcelable is " + result);
let ret = new MyParcelable(0, "");
let result2 = data.readParcelable(ret);
console.log("RpcClient: readParcelable is " + result2);

Sequenceable^(deprecated)

从API version 9 开始不再维护，建议使用Parcelable类替代。

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

marshalling

marshalling(dataOut: MessageParcel): boolean

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

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

参数：

参数名	类型	必填	说明
dataOut	MessageParcel	是	可序列对象将被封送到的MessageParcel对象。

返回值：

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

示例：

class MySequenceable {
    num: number;
    str: string;
    constructor(num, str) {
        this.num = num;
        this.str = str;
    }
    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);

unmarshalling

unmarshalling(dataIn: MessageParcel): boolean

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

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

参数：

参数名	类型	必填	说明
dataIn	MessageParcel	是	已将可序列对象封送到其中的MessageParcel对象。

返回值：

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

示例：

class MySequenceable {
    num: number;
    str: string;
    constructor(num, str) {
        this.num = num;
        this.str = str;
    }
    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);

IRemoteBroker

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

asObject

asObject(): IRemoteObject

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

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

返回值：

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

示例：

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

示例：

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

DeathRecipient

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

onRemoteDied

onRemoteDied(): void

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

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

示例：

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

RequestResult⁹⁺

发送请求的响应结果。

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

名称	类型	可读	可写	说明
errCode	number	是	否	错误码。
code	number	是	否	消息代码。
data	MessageSequence	是	否	发送给对端进程的MessageSequence对象。
reply	MessageSequence	是	否	对端进程返回的MessageSequence对象。

SendRequestResult^{8+(deprecated)}

从API version 9 开始不再维护，建议使用RequestResult类替代。

发送请求的响应结果。

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

名称	类型	可读	可写	说明
errCode	number	是	否	错误码。
code	number	是	否	消息代码。
data	MessageParcel	是	否	发送给对端进程的MessageParcel对象。
reply	MessageParcel	是	否	对端进程返回的MessageParcel对象。

IRemoteObject

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

getLocalInterface⁹⁺

getLocalInterface(descriptor: string): IRemoteBroker

查询接口。

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

参数：

参数名	类型	必填	说明
descriptor	string	是	接口描述符的字符串。

返回值：

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

queryLocalInterface^(deprecated)

从API version 9 开始不再维护，建议使用getLocalInterface类替代。

queryLocalInterface(descriptor: string): IRemoteBroker

查询接口。

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

参数：

参数名	类型	必填	说明
descriptor	string	是	接口描述符的字符串。

返回值：

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

sendRequest^(deprecated)

从API version 9 开始不再维护，建议使用sendMessageRequest类替代。

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

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

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

参数：

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

返回值：

类型	说明
boolean	返回一个布尔值，true表示成功，false表示失败。

sendRequest^{8+(deprecated)}

从API version 9 开始不再维护，建议使用sendMessageRequest类替代。

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<SendRequestResult>	返回一个期约，兑现值是sendRequestResult实例。

sendMessageRequest⁹⁺

sendMessageRequest(code: number, data: MessageSequence, reply: MessageSequence, options: MessageOption): Promise<RequestResult>

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

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

参数：

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

返回值：

类型	说明
Promise<RequestResult>	返回一个期约，兑现值是requestResult实例。

sendMessageRequest⁹⁺

sendMessageRequest(code: number, data: MessageSequence, reply: MessageSequence, options: MessageOption, callback: AsyncCallback<RequestResult>): void

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

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

参数：

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

sendRequest^{8+(deprecated)}

从API version 9 开始不再维护，建议使用sendMessageRequest类替代。

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>	是	接收发送结果的回调。

registerDeathRecipient⁹⁺

registerDeathRecipient(recipient: DeathRecipient, flags: number): void

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

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

参数：

参数名	类型	必填	说明
recipient	DeathRecipient	是	要注册的回调。
flags	number	是	死亡通知标志。

错误码：

以下错误码的详细介绍请参见ohos.rpc错误码

错误码ID	错误信息
1900008	proxy or remote object is invalid

addDeathrecipient^(deprecated)

从API version 9 开始不再维护，建议使用registerDeathRecipient类替代。

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

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

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

参数：

参数名	类型	必填	说明
recipient	DeathRecipient	是	要注册的回调。
flags	number	是	死亡通知标志。

返回值：

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

unregisterDeathRecipient⁹⁺

unregisterDeathRecipient(recipient: DeathRecipient, flags: number): void

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

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

参数：

参数名	类型	必填	说明
recipient	DeathRecipient	是	要注销的回调。
flags	number	是	死亡通知标志。

错误码：

以下错误码的详细介绍请参见ohos.rpc错误码

错误码ID	错误信息
1900008	proxy or remote object is invalid

removeDeathRecipient^(deprecated)

从API version 9 开始不再维护，建议使用unregisterDeathRecipient类替代。

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

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

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

参数：

参数名	类型	必填	说明
recipient	DeathRecipient	是	要注销的回调。
flags	number	是	死亡通知标志。

返回值：

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

getDescriptor⁹⁺

getDescriptor(): string

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

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

返回值：

类型	说明
string	返回接口描述符。

错误码：

以下错误码的详细介绍请参见ohos.rpc错误码

错误码ID	错误信息
1900008	proxy or remote object is invalid

getInterfaceDescriptor^(deprecated)

从API version 9 开始不再维护，建议使用getDescriptor类替代。

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^(deprecated)

从API version 9 开始不再维护，建议使用sendMessageRequest类替代。

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

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

参数：

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

返回值：

类型	说明
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);
let option = new rpc.MessageOption();
let data = rpc.MessageParcel.create();
let reply = rpc.MessageParcel.create();
data.writeInt(1);
data.writeString("hello");
let ret: boolean = proxy.sendRequest(1, data, reply, option);
if (ret) {
    console.log("sendRequest got result");
    let msg = reply.readString();
    console.log("RPCTest: reply msg: " + msg);
} else {
    console.log("RPCTest: sendRequest failed");
}
console.log("RPCTest: sendRequest ends, reclaim parcel");
data.reclaim();
reply.reclaim();

sendMessageRequest⁹⁺

sendMessageRequest(code: number, data: MessageSequence, reply: MessageSequence, options: MessageOption): Promise<RequestResult>

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

参数：

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

返回值：

类型	说明
Promise<RequestResult>	返回一个期约，兑现值是requestResult实例。

示例：

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.MessageSequence.create();
let reply = rpc.MessageSequence.create();
data.writeInt(1);
data.writeString("hello");
proxy.sendMessageRequest(1, data, reply, option)
    .then(function(result) {
        if (result.errCode === 0) {
            console.log("sendMessageRequest got result");
            result.reply.readException();
            let msg = result.reply.readString();
            console.log("RPCTest: reply msg: " + msg);
        } else {
            console.log("RPCTest: sendMessageRequest failed, errCode: " + result.errCode);
        }
    }).catch(function(e) {
        console.log("RPCTest: sendMessageRequest got exception: " + e.message);
    }).finally (() => {
        console.log("RPCTest: sendMessageRequest ends, reclaim parcel");
        data.reclaim();
        reply.reclaim();
    });

sendRequest^{8+(deprecated)}

从API version 9 开始不再维护，建议使用sendMessageRequest类替代。

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<SendRequestResult>	返回一个期约，兑现值是sendRequestResult实例。

sendMessageRequest⁹⁺

sendMessageRequest(code: number, data: MessageSequence, reply: MessageSequence, options: MessageOption, callback: AsyncCallback<RequestResult>): void

以同步或异步方式向对端进程发送MessageSequence消息。如果为选项设置了异步模式，则立即收到回调，reply报文里没有内容。如果为选项设置了同步模式，则将在sendMessageRequest返回后的某个时机执行回调，回复内容在RequestResult的reply报文里。

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

参数：

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

示例：

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.MessageSequence.create();
let reply = rpc.MessageSequence.create();
data.writeInt(1);
data.writeString("hello");
try {
    proxy.sendRequest(1, data, reply, option, sendRequestCallback);
} catch(error) {
    console.info("rpc send sequence request fail, errorCode " + error.code);
    console.info("rpc send sequence request fail, errorMessage " + error.message);
}

sendRequest^{8+(deprecated)}

从API version 9 开始不再维护，建议使用sendMessageRequest类替代。

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);

getLocalInterface⁹⁺

getLocalInterface(interface: string): IRemoteBroker

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

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

参数：

参数名	类型	必填	说明
interface	string	是	需要查询的接口描述符。

返回值：

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

错误码：

以下错误码的详细介绍请参见ohos.rpc错误码

错误码ID	错误信息
1900006	only remote object permitted

示例：

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);
try {
    let broker = proxy.getLocalInterface("testObject");
    console.log("RpcClient: getLocalInterface is " + broker);
} catch(error) {
    console.info("rpc get local interface fail, errorCode " + error.code);
    console.info("rpc get local interface fail, errorMessage " + error.message);
}

queryLocalInterface^(deprecated)

从API version 9 开始不再维护，建议使用getLocalInterface类替代。

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);

registerDeathRecipient⁹⁺

registerDeathRecipient(recipient: DeathRecipient, flags: number): void

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

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

参数：

参数名	类型	必填	说明
recipient	DeathRecipient	是	要注册的回调。
flags	number	是	死亡通知标志。

错误码：

以下错误码的详细介绍请参见ohos.rpc错误码

错误码ID	错误信息
1900008	proxy or remote object is invalid

示例：

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 died");
    }
}
let deathRecipient = new MyDeathRecipient();
try {
    proxy.registerDeathRecippient(deathRecipient, 0);
} catch(error) {
    console.info("proxy register deathRecipient fail, errorCode " + error.code);
    console.info("proxy register deathRecipient fail, errorMessage " + error.message);
}

addDeathRecippient^(deprecated)

从API version 9 开始不再维护，建议使用registerDeathRecipient类替代。

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 died");
    }
}
let deathRecipient = new MyDeathRecipient();
proxy.addDeathRecippient(deathRecipient, 0);

unregisterDeathRecipient⁹⁺

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

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

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

参数：

参数名	类型	必填	说明
recipient	DeathRecipient	是	要注销的回调。
flags	number	是	死亡通知标志。

错误码：

以下错误码的详细介绍请参见ohos.rpc错误码

错误码ID	错误信息
1900008	proxy or remote object is invalid

示例：

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 died");
    }
}
let deathRecipient = new MyDeathRecipient();
try {
    proxy.registerDeathRecippient(deathRecipient, 0);
    proxy.unregisterDeathRecippient(deathRecipient, 0);
} catch(error) {
    console.info("proxy register deathRecipient fail, errorCode " + error.code);
    console.info("proxy register deathRecipient fail, errorMessage " + error.message);
}

文章转载自：https://developer.harmonyos.com/cn/docs/documentation/doc-references-V3/js-apis-rpc-0000001427902704-V3?catalogVersion=V3#ZH-CN_TOPIC_0000001427902704__writelongarray-1

分类

卡片开发

IDE

标签

HarmonyOS API

已于2023-4-7 15:59:25修改

51CTO

51CTO博客

51CTO学堂

HarmonyOS API：@ohos.rpc (RPC通信)

@ohos.rpc (RPC通信)

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+

readAshmem8+

getRawDataCapacity8+

writeRawData8+

readRawData8+

Parcelable9+

marshalling

unmarshalling

Sequenceable(deprecated)

marshalling

unmarshalling

IRemoteBroker

asObject

DeathRecipient

onRemoteDied

RequestResult9+

SendRequestResult8+(deprecated)

IRemoteObject

getLocalInterface9+

queryLocalInterface(deprecated)

sendRequest(deprecated)

sendRequest8+(deprecated)

sendMessageRequest9+

sendMessageRequest9+

sendRequest8+(deprecated)

registerDeathRecipient9+

addDeathrecipient(deprecated)

unregisterDeathRecipient9+

removeDeathRecipient(deprecated)

getDescriptor9+

getInterfaceDescriptor(deprecated)

isObjectDead

RemoteProxy

sendRequest(deprecated)

sendMessageRequest9+

sendRequest8+(deprecated)

sendMessageRequest9+

sendRequest8+(deprecated)

getLocalInterface9+

queryLocalInterface(deprecated)

registerDeathRecipient9+

addDeathRecippient(deprecated)

unregisterDeathRecipient9+

目录

订阅鸿蒙技术特刊，精选内容抢先看

writeNoException⁸⁺

readException⁸⁺

readSequenceableArray⁸⁺

writeRemoteObjectArray⁸⁺

readRemoteObjectArray⁸⁺

readRemoteObjectArray⁸⁺

closeFileDescriptor⁸⁺

dupFileDescriptor⁸⁺

containFileDescriptors⁸⁺

writeFileDescriptor⁸⁺

readFileDescriptor⁸⁺

writeAshmem⁸⁺

readAshmem⁸⁺

getRawDataCapacity⁸⁺

writeRawData⁸⁺

readRawData⁸⁺

Parcelable⁹⁺

Sequenceable^(deprecated)

RequestResult⁹⁺

SendRequestResult^{8+(deprecated)}

getLocalInterface⁹⁺

queryLocalInterface^(deprecated)

sendRequest^(deprecated)

sendRequest^{8+(deprecated)}

sendMessageRequest⁹⁺

sendMessageRequest⁹⁺

sendRequest^{8+(deprecated)}

registerDeathRecipient⁹⁺

addDeathrecipient^(deprecated)

unregisterDeathRecipient⁹⁺

removeDeathRecipient^(deprecated)

getDescriptor⁹⁺

getInterfaceDescriptor^(deprecated)

sendRequest^(deprecated)

sendMessageRequest⁹⁺

sendRequest^{8+(deprecated)}

sendMessageRequest⁹⁺

sendRequest^{8+(deprecated)}

getLocalInterface⁹⁺

queryLocalInterface^(deprecated)

registerDeathRecipient⁹⁺

addDeathRecippient^(deprecated)

unregisterDeathRecipient⁹⁺