openharmony/communication_ipc
1
0
Fork 0
mirror of https://gitee.com/openharmony/communication_ipc synced 2024-12-02 13:16:50 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge branch 'master' of gitee.com:openharmony/communication_ipc into master

Browse Source 
Signed-off-by: yanghang <yanghang86@huawei.com>
This commit is contained in:
yanghang 2024-05-16 06:35:39 +00:00 committed by Gitee
commit 3f17d50615
11 changed files with 788 additions and 623 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

412
interfaces/innerkits/c_api/include/ipc_cparcel.h
View File

@ -20,7 +20,7 @@
* @addtogroup OHIPCParcel
* @{
*
* @brief 提供IPC序列化/反序列化C接口.
* @brief Defines C interfaces for IPC serialization and deserialization.
*
* @syscap SystemCapability.Communication.IPC.Core
* @since 12
@ -29,9 +29,10 @@
/**
* @file ipc_cparcel.h
*
* @brief 提供IPC序列化/反序列化C接口.
* @brief Defines C interfaces for IPC serialization and deserialization.
*
* @library libipc_capi.so
* @syscap SystemCapability.Communication.IPC.Core
* @since 12
*/
@ -41,426 +42,482 @@
extern "C" {
#endif
/**
* @brief Defines an IPC serialized object.
*
* @syscap SystemCapability.Communication.IPC.Core
* @since 12
*/
struct OHIPCParcel;
/**
* @brief Typedef an IPC serialized object.
*
* @syscap SystemCapability.Communication.IPC.Core
* @since 12
*/
typedef struct OHIPCParcel OHIPCParcel;
/**
* @brief Defines an IPC remote proxy object.
*
* @syscap SystemCapability.Communication.IPC.Core
* @since 12
*/
struct OHIPCRemoteProxy;
/**
* @brief Typedef an IPC remote proxy object.
*
* @syscap SystemCapability.Communication.IPC.Core
* @since 12
*/
typedef struct OHIPCRemoteProxy OHIPCRemoteProxy;
/**
* @brief Defines an IPC remote service object.
*
* @syscap SystemCapability.Communication.IPC.Core
* @since 12
*/
struct OHIPCRemoteStub;
/**
* @brief 内存分配函数类型.
* @brief Typedef an IPC remote service object.
*
* @syscap SystemCapability.Communication.IPC.Core
* @since 12
*/
typedef struct OHIPCRemoteStub OHIPCRemoteStub;
/**
* @brief Allocates memory.
*
* @syscap SystemCapability.Communication.IPC.Core
* @param len 分配内存长度.
* @return 成功返回分配的内存地址；失败返回NULL.
* @param len Length of the memory to allocate.
* @return Returns the address of the memory allocated if the operation is successful; returns NULL otherwise.
* @since 12
*/
typedef void* (*OH_IPC_MemAllocator)(int32_t len);
/**
* @brief 创建OHIPCParcel对象，对象可序列化大小不能超过204800字节.
* @brief Creates an <b>OHIPCParcel</b> object, which cannot exceed 204,800 bytes.
*
* @syscap SystemCapability.Communication.IPC.Core
* @return 成功返回OHIPCParcel对象指针；失败返回NULL.
* @return Returns the pointer to the <b>OHIPCParcel</b> object created if the operation is successful;
* returns NULL otherwise.
* @since 12
*/
OHIPCParcel* OH_IPCParcel_Create(void);
/**
* @brief 销毁OHIPCParcel对象.
* @brief Destroys an <b>OHIPCParcel</b> object.
*
* @syscap SystemCapability.Communication.IPC.Core
* @param parcel 需要销毁OHIPCParcel对象的指针.
* @param parcel Pointer to the <b>OHIPCParcel</b> object to destroy.
* @since 12
*/
void OH_IPCParcel_Destroy(OHIPCParcel *parcel);
/**
* @brief 获取OHIPCParcel对象包含的数据的大小.
* @brief Obtains the size of the data contained in an <b>OHIPCParcel</b> object.
*
* @syscap SystemCapability.Communication.IPC.Core
* @param parcel OHIPCParcel对象的指针，不能为空.
* @return 返回数据大小，参数不合法时返回-1.
* @param parcel Pointer to the target <b>OHIPCParcel</b> object. It cannot be NULL.
* @return Returns the data size obtained if the operation is successful.\n
* Returns <b>-1</b> if invalid parameters are found.
* @since 12
*/
int OH_IPCParcel_GetDataSize(const OHIPCParcel *parcel);
/**
* @brief 获取OHIPCParcel对象可以写入的字节数.
* @brief Obtains the number of bytes that can be written to an <b>OHIPCParcel</b> object.
*
* @syscap SystemCapability.Communication.IPC.Core
* @param parcel OHIPCParcel对象的指针，不能为空.
* @return 返回可写字节数大小，参数不合法时返回-1.
* @param parcel Pointer to the target <b>OHIPCParcel</b> object. It cannot be NULL.
* @return Returns the number of bytes that can be written to the <b>OHIPCParcel</b> object. \n
* Returns <b>-1</b> if invalid parameters are found.
* @since 12
*/
int OH_IPCParcel_GetWritableBytes(const OHIPCParcel *parcel);
/**
* @brief 获取OHIPCParcel对象还可以读取的字节数.
* @brief Obtains the number of bytes that can be read from an <b>OHIPCParcel</b> object.
*
* @syscap SystemCapability.Communication.IPC.Core
* @param parcel OHIPCParcel对象的指针，不能为空.
* @return 返回可读字节数大小，参数不合法时返回-1.
* @param parcel Pointer to the target <b>OHIPCParcel</b> object. It cannot be NULL.
* @return Returns the number of bytes that can be read from the <b>OHIPCParcel</b> object. \n
* Returns <b>-1</b> if invalid parameters are found.
* @since 12
*/
int OH_IPCParcel_GetReadableBytes(const OHIPCParcel *parcel);
/**
* @brief 获取OHIPCParcel对象当前读取位置.
* @brief Obtains the position where data is read in an <b>OHIPCParcel</b> object.
*
* @syscap SystemCapability.Communication.IPC.Core
* @param parcel OHIPCParcel对象的指针，不能为空.
* @return 返回当前读位置，参数不合法时返回-1
* @param parcel Pointer to the target <b>OHIPCParcel</b> object. It cannot be NULL.
* @return Returns the position obtained if the operation is successful. \n
* Returns <b>-1</b> if invalid parameters are found.
* @since 12
*/
int OH_IPCParcel_GetReadPosition(const OHIPCParcel *parcel);
/**
* @brief 获取OHIPCParcel对象当前写入位置.
* @brief Obtains the position where data is written in an <b>OHIPCParcel</b> object.
*
* @syscap SystemCapability.Communication.IPC.Core
* @param parcel OHIPCParcel对象的指针，不能为空.
* @return 返回当前写入位置，参数不合法时返回-1.
* @param parcel Pointer to the target <b>OHIPCParcel</b> object. It cannot be NULL.
* @return Returns the position obtained if the operation is successful. \n
* Returns <b>-1</b> if invalid parameters are found.
* @since 12
*/
int OH_IPCParcel_GetWritePosition(const OHIPCParcel *parcel);
/**
* @brief 重置OHIPCParcel对象读取位置.
* @brief Resets the position to read data in an IPC parcel.
*
* @syscap SystemCapability.Communication.IPC.Core
* @param parcel OHIPCParcel对象的指针，不能为空.
* @param newReadPos 新的读取位置，范围:[0, 当前数据大小].
* @return 成功返回{@link OH_IPC_ErrorCode#OH_IPC_SUCCESS}. \n
* 参数不合法时返回{@link OH_IPC_ErrorCode#OH_IPC_CHECK_PARAM_ERROR}.
* @param parcel Pointer to the target <b>OHIPCParcel</b> object. It cannot be NULL.
* @param newReadPos New position to read data. The value ranges from <b>0</b> to the current data size.
* @return Returns {@link OH_IPC_ErrorCode#OH_IPC_SUCCESS} if the operation is successful. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_CHECK_PARAM_ERROR} if invalid parameters are found.
* @since 12
*/
int OH_IPCParcel_RewindReadPosition(OHIPCParcel *parcel, uint32_t newReadPos);
/**
* @brief 重置OHIPCParcel对象写入位置.
* @brief Resets the position to write data in an <b>OHIPCParcel</b> object.
*
* @syscap SystemCapability.Communication.IPC.Core
* @param parcel OHIPCParcel对象的指针，不能为空.
* @param newWritePos 新的写入位置，范围:[0, 当前数据大小].
* @return 成功返回{@link OH_IPC_ErrorCode#OH_IPC_SUCCESS}. \n
* 参数不合法时返回{@link OH_IPC_ErrorCode#OH_IPC_CHECK_PARAM_ERROR}.
* @param parcel Pointer to the target <b>OHIPCParcel</b> object. It cannot be NULL.
* @param newWritePos New position to write data. The value ranges from <b>0</b> to the current data size.
* @return Returns {@link OH_IPC_ErrorCode#OH_IPC_SUCCESS} if the operation is successful. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_CHECK_PARAM_ERROR} if invalid parameters are found.
* @since 12
*/
int OH_IPCParcel_RewindWritePosition(OHIPCParcel *parcel, uint32_t newWritePos);
/**
* @brief 向OHIPCParcel对象写入int8_t值.
* @brief Writes an int8_t value to an <b>OHIPCParcel</b> object.
*
* @syscap SystemCapability.Communication.IPC.Core
* @param parcel OHIPCParcel对象的指针，不能为空.
* @param value 要写入的值.
* @return 成功返回{@link OH_IPC_ErrorCode#OH_IPC_SUCCESS}. \n
* 参数不合法时返回{@link OH_IPC_ErrorCode#OH_IPC_CHECK_PARAM_ERROR}. \n
* 写入失败返回{@link OH_IPC_ErrorCode#OH_IPC_PARCEL_WRITE_ERROR}.
* @param parcel Pointer to the target <b>OHIPCParcel</b> object. It cannot be NULL.
* @param value Value to write.
* @return Returns {@link OH_IPC_ErrorCode#OH_IPC_SUCCESS} if the operation is successful. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_CHECK_PARAM_ERROR} if invalid parameters are found. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_PARCEL_WRITE_ERROR} if the data write operation fails.
* @since 12
*/
int OH_IPCParcel_WriteInt8(OHIPCParcel *parcel, int8_t value);
/**
* @brief 从OHIPCParcel对象读取int8_t值.
* @brief Reads an int8_t value from an <b>OHIPCParcel</b> object.
*
* @syscap SystemCapability.Communication.IPC.Core
* @param parcel OHIPCParcel对象的指针，不能为空.
* @param value 存储读取数据的指针，不能为空.
* @return 成功返回{@link OH_IPC_ErrorCode#OH_IPC_SUCCESS}. \n
* 参数不合法时返回{@link OH_IPC_ErrorCode#OH_IPC_CHECK_PARAM_ERROR}. \n
* 读取失败返回{@link OH_IPC_ErrorCode#OH_IPC_PARCEL_READ_ERROR}.
* @param parcel Pointer to the target <b>OHIPCParcel</b> object. It cannot be NULL.
* @param value Pointer to the data to read. It cannot be NULL.
* @return Returns {@link OH_IPC_ErrorCode#OH_IPC_SUCCESS} if the operation is successful. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_CHECK_PARAM_ERROR} if invalid parameters are found. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_PARCEL_READ_ERROR} if the read operation fails.
* @since 12
*/
int OH_IPCParcel_ReadInt8(const OHIPCParcel *parcel, int8_t *value);
/**
* @brief 向OHIPCParcel对象写入int16_t值.
* @brief Writes an int16_t value to an <b>OHIPCParcel</b> object.
*
* @syscap SystemCapability.Communication.IPC.Core
* @param parcel OHIPCParcel对象的指针，不能为空.
* @param value 要写入的值.
* @return 成功返回{@link OH_IPC_ErrorCode#OH_IPC_SUCCESS}. \n
* 参数不合法时返回{@link OH_IPC_ErrorCode#OH_IPC_CHECK_PARAM_ERROR}. \n
* 写入失败返回{@link OH_IPC_ErrorCode#OH_IPC_PARCEL_WRITE_ERROR}.
* @param parcel Pointer to the target <b>OHIPCParcel</b> object. It cannot be NULL.
* @param value Value to write.
* @return Returns {@link OH_IPC_ErrorCode#OH_IPC_SUCCESS} if the operation is successful. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_CHECK_PARAM_ERROR} if invalid parameters are found. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_PARCEL_WRITE_ERROR} if the data write operation fails.
* @since 12
*/
int OH_IPCParcel_WriteInt16(OHIPCParcel *parcel, int16_t value);
/**
* @brief 从OHIPCParcel对象读取int16_t值.
* @brief Reads an int16_t value from an <b>OHIPCParcel</b> object.
*
* @syscap SystemCapability.Communication.IPC.Core
* @param parcel OHIPCParcel对象的指针，不能为空.
* @param value 存储读取数据的指针，不能为空.
* @return 成功返回{@link OH_IPC_ErrorCode#OH_IPC_SUCCESS}. \n
* 参数不合法时返回{@link OH_IPC_ErrorCode#OH_IPC_CHECK_PARAM_ERROR}. \n
* 读取失败返回{@link OH_IPC_ErrorCode#OH_IPC_PARCEL_READ_ERROR}.
* @param parcel Pointer to the target <b>OHIPCParcel</b> object. It cannot be NULL.
* @param value Pointer to the data to read. It cannot be NULL.
* @return Returns {@link OH_IPC_ErrorCode#OH_IPC_SUCCESS} if the operation is successful. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_CHECK_PARAM_ERROR} if invalid parameters are found. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_PARCEL_READ_ERROR} if the read operation fails.
* @since 12
*/
int OH_IPCParcel_ReadInt16(const OHIPCParcel *parcel, int16_t *value);
/**
* @brief 向OHIPCParcel对象写入int32_t值.
* @brief Writes an int32_t value to an <b>OHIPCParcel</b> object.
*
* @syscap SystemCapability.Communication.IPC.Core
* @param parcel OHIPCParcel对象的指针，不能为空.
* @param value 要写入的值.
* @return 成功返回{@link OH_IPC_ErrorCode#OH_IPC_SUCCESS}. \n
* 参数不合法时返回{@link OH_IPC_ErrorCode#OH_IPC_CHECK_PARAM_ERROR}. \n
* 写入失败返回{@link OH_IPC_ErrorCode#OH_IPC_PARCEL_WRITE_ERROR}.
* @param parcel Pointer to the target <b>OHIPCParcel</b> object. It cannot be NULL.
* @param value Value to write.
* @return Returns {@link OH_IPC_ErrorCode#OH_IPC_SUCCESS} if the operation is successful. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_CHECK_PARAM_ERROR} if invalid parameters are found. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_PARCEL_WRITE_ERROR} if the data write operation fails.
* @since 12
*/
int OH_IPCParcel_WriteInt32(OHIPCParcel *parcel, int32_t value);
/**
* @brief 从OHIPCParcel对象读取int32_t值.
* @brief Reads an int32_t value from an <b>OHIPCParcel</b> object.
*
* @syscap SystemCapability.Communication.IPC.Core
* @param parcel OHIPCParcel对象的指针，不能为空.
* @param value 存储读取数据的指针，不能为空.
* @return 成功返回{@link OH_IPC_ErrorCode#OH_IPC_SUCCESS}. \n
* 参数不合法时返回{@link OH_IPC_ErrorCode#OH_IPC_CHECK_PARAM_ERROR}. \n
* 读取失败返回{@link OH_IPC_ErrorCode#OH_IPC_PARCEL_READ_ERROR}.
* @param parcel Pointer to the target <b>OHIPCParcel</b> object. It cannot be NULL.
* @param value Pointer to the data to read. It cannot be NULL.
* @return Returns {@link OH_IPC_ErrorCode#OH_IPC_SUCCESS} if the operation is successful. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_CHECK_PARAM_ERROR} if invalid parameters are found. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_PARCEL_READ_ERROR} if the read operation fails.
* @since 12
*/
int OH_IPCParcel_ReadInt32(const OHIPCParcel *parcel, int32_t *value);
/**
* @brief 向OHIPCParcel对象写入int64_t值.
* @brief Writes an int64_t value to an <b>OHIPCParcel</b> object.
*
* @syscap SystemCapability.Communication.IPC.Core
* @param parcel OHIPCParcel对象的指针，不能为空.
* @param value 要写入的值.
* @return 成功返回{@link OH_IPC_ErrorCode#OH_IPC_SUCCESS}. \n
* 参数不合法时返回{@link OH_IPC_ErrorCode#OH_IPC_CHECK_PARAM_ERROR}. \n
* 写入失败返回{@link OH_IPC_ErrorCode#OH_IPC_PARCEL_WRITE_ERROR}.
* @param parcel Pointer to the target <b>OHIPCParcel</b> object. It cannot be NULL.
* @param value Value to write.
* @return Returns {@link OH_IPC_ErrorCode#OH_IPC_SUCCESS} if the operation is successful. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_CHECK_PARAM_ERROR} if invalid parameters are found. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_PARCEL_WRITE_ERROR} if the data write operation fails.
* @since 12
*/
int OH_IPCParcel_WriteInt64(OHIPCParcel *parcel, int64_t value);
/**
* @brief 从OHIPCParcel对象读取int64_t值.
* @brief Reads an int64_t value from an <b>OHIPCParcel</b> object.
*
* @syscap SystemCapability.Communication.IPC.Core
* @param parcel OHIPCParcel对象的指针，不能为空.
* @param value 存储读取数据的指针，不能为空.
* @return 成功返回{@link OH_IPC_ErrorCode#OH_IPC_SUCCESS}. \n
* 参数不合法时返回{@link OH_IPC_ErrorCode#OH_IPC_CHECK_PARAM_ERROR}. \n
* 读取失败返回{@link OH_IPC_ErrorCode#OH_IPC_PARCEL_READ_ERROR}.
* @param parcel Pointer to the target <b>OHIPCParcel</b> object. It cannot be NULL.
* @param value Pointer to the data to read. It cannot be NULL.
* @return Returns {@link OH_IPC_ErrorCode#OH_IPC_SUCCESS} if the operation is successful. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_CHECK_PARAM_ERROR} if invalid parameters are found. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_PARCEL_READ_ERROR} if the read operation fails.
* @since 12
*/
int OH_IPCParcel_ReadInt64(const OHIPCParcel *parcel, int64_t *value);
/**
* @brief 向OHIPCParcel对象写入float值.
* @brief Writes a float value to an <b>OHIPCParcel</b> object.
*
* @syscap SystemCapability.Communication.IPC.Core
* @param parcel OHIPCParcel对象的指针，不能为空.
* @param value 要写入的值.
* @return 成功返回{@link OH_IPC_ErrorCode#OH_IPC_SUCCESS}. \n
* 参数不合法时返回{@link OH_IPC_ErrorCode#OH_IPC_CHECK_PARAM_ERROR}. \n
* 写入失败返回{@link OH_IPC_ErrorCode#OH_IPC_PARCEL_WRITE_ERROR}.
* @param parcel Pointer to the target <b>OHIPCParcel</b> object. It cannot be NULL.
* @param value Value to write.
* @return Returns {@link OH_IPC_ErrorCode#OH_IPC_SUCCESS} if the operation is successful. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_CHECK_PARAM_ERROR} if invalid parameters are found. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_PARCEL_WRITE_ERROR} if the data write operation fails.
* @since 12
*/
int OH_IPCParcel_WriteFloat(OHIPCParcel *parcel, float value);
/**
* @brief 从OHIPCParcel对象读取float值.
* @brief Reads a float value from an <b>OHIPCParcel</b> object.
*
* @syscap SystemCapability.Communication.IPC.Core
* @param parcel OHIPCParcel对象的指针，不能为空.
* @param value 存储读取数据的指针，不能为空.
* @return 成功返回{@link OH_IPC_ErrorCode#OH_IPC_SUCCESS}. \n
* 参数不合法时返回{@link OH_IPC_ErrorCode#OH_IPC_CHECK_PARAM_ERROR}. \n
* 读取失败返回{@link OH_IPC_ErrorCode#OH_IPC_PARCEL_READ_ERROR}.
* @param parcel Pointer to the target <b>OHIPCParcel</b> object. It cannot be NULL.
* @param value Pointer to the data to read. It cannot be NULL.
* @return Returns {@link OH_IPC_ErrorCode#OH_IPC_SUCCESS} if the operation is successful. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_CHECK_PARAM_ERROR} if invalid parameters are found. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_PARCEL_READ_ERROR} if the read operation fails.
* @since 12
*/
int OH_IPCParcel_ReadFloat(const OHIPCParcel *parcel, float *value);
/**
* @brief 向OHIPCParcel对象写入double值.
* @brief Writes a double value to an <b>OHIPCParcel</b> object.
*
* @syscap SystemCapability.Communication.IPC.Core
* @param parcel OHIPCParcel对象的指针，不能为空.
* @param value 要写入的值.
* @return 成功返回{@link OH_IPC_ErrorCode#OH_IPC_SUCCESS}. \n
* 参数不合法时返回{@link OH_IPC_ErrorCode#OH_IPC_CHECK_PARAM_ERROR}. \n
* 写入失败返回{@link OH_IPC_ErrorCode#OH_IPC_PARCEL_WRITE_ERROR}.
* @param parcel Pointer to the target <b>OHIPCParcel</b> object. It cannot be NULL.
* @param value Value to write.
* @return Returns {@link OH_IPC_ErrorCode#OH_IPC_SUCCESS} if the operation is successful. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_CHECK_PARAM_ERROR} if invalid parameters are found. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_PARCEL_WRITE_ERROR} if the data write operation fails.
* @since 12
*/
int OH_IPCParcel_WriteDouble(OHIPCParcel *parcel, double value);
/**
* @brief 从OHIPCParcel对象读取double值.
* @brief Reads a double value from an <b>OHIPCParcel</b> object.
*
* @syscap SystemCapability.Communication.IPC.Core
* @param parcel OHIPCParcel对象的指针，不能为空.
* @param value 存储读取数据的指针，不能为空.
* @return 成功返回{@link OH_IPC_ErrorCode#OH_IPC_SUCCESS}. \n
* 参数不合法时返回{@link OH_IPC_ErrorCode#OH_IPC_CHECK_PARAM_ERROR}. \n
* 读取失败返回{@link OH_IPC_ErrorCode#OH_IPC_PARCEL_READ_ERROR}.
* @param parcel Pointer to the target <b>OHIPCParcel</b> object. It cannot be NULL.
* @param value Pointer to the data to read. It cannot be NULL.
* @return Returns {@link OH_IPC_ErrorCode#OH_IPC_SUCCESS} if the operation is successful. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_CHECK_PARAM_ERROR} if invalid parameters are found. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_PARCEL_READ_ERROR} if the read operation fails.
* @since 12
*/
int OH_IPCParcel_ReadDouble(const OHIPCParcel *parcel, double *value);
/**
* @brief 向OHIPCParcel对象写入字符串，包含字符串结束符.
* @brief Writes a string including a string terminator to an <b>OHIPCParcel</b> object.
*
* @syscap SystemCapability.Communication.IPC.Core
* @param parcel OHIPCParcel对象的指针，不能为空.
* @param str 写入字符串，不能为空.
* @return 成功返回{@link OH_IPC_ErrorCode#OH_IPC_SUCCESS}. \n
* 参数不合法时返回{@link OH_IPC_ErrorCode#OH_IPC_CHECK_PARAM_ERROR}. \n
* 写入失败返回{@link OH_IPC_ErrorCode#OH_IPC_PARCEL_WRITE_ERROR}.
* @param parcel Pointer to the target <b>OHIPCParcel</b> object. It cannot be NULL.
* @param str String to write, which cannot be NULL.
* @return Returns {@link OH_IPC_ErrorCode#OH_IPC_SUCCESS} if the operation is successful. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_CHECK_PARAM_ERROR} if invalid parameters are found. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_PARCEL_WRITE_ERROR} if the data write operation fails.
* @since 12
*/
int OH_IPCParcel_WriteString(OHIPCParcel *parcel, const char *str);
/**
* @brief 从OHIPCParcel对象读取字符串，用户可通过strlen获取字符串长度。
* @brief Reads a string from an <b>OHIPCParcel</b> object. You can obtain the length of the string from <b>strlen</b>.
*
* @syscap SystemCapability.Communication.IPC.Core
* @param parcel OHIPCParcel对象的指针，不能为空。
* @return 成功返回读取字符串地址；参数不合法或读取失败时返回NULL。
* @param parcel Pointer to the target <b>OHIPCParcel</b> object. It cannot be NULL.
* @return Returns the address of the string read if the operation is successful;
* returns NULL if the operation fails or invalid parameters are found.
* @since 12
*/
const char* OH_IPCParcel_ReadString(const OHIPCParcel *parcel);
/**
* @brief 向OHIPCParcel对象写入指定长度的内存信息.
* @brief Writes data of the specified length from the memory to an <b>OHIPCParcel</b> object.
*
* @syscap SystemCapability.Communication.IPC.Core
* @param parcel OHIPCParcel对象的指针，不能为空.
* @param buffer 写入内存信息地址.
* @param len 写入信息长度.
* @return 成功返回{@link OH_IPC_ErrorCode#OH_IPC_SUCCESS}. \n
* 参数不合法时返回{@link OH_IPC_ErrorCode#OH_IPC_CHECK_PARAM_ERROR}. \n
* 写入失败返回{@link OH_IPC_ErrorCode#OH_IPC_PARCEL_WRITE_ERROR}.
* @param parcel Pointer to the target <b>OHIPCParcel</b> object. It cannot be NULL.
* @param buffer Pointer to the address of the memory information to write.
* @param len Length of the data to write.
* @return Returns {@link OH_IPC_ErrorCode#OH_IPC_SUCCESS} if the operation is successful. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_CHECK_PARAM_ERROR} if invalid parameters are found. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_PARCEL_WRITE_ERROR} if the data write operation fails.
* @since 12
*/
int OH_IPCParcel_WriteBuffer(OHIPCParcel *parcel, const uint8_t *buffer, int32_t len);
/**
* @brief 从OHIPCParcel对象读取指定长度内存信息。
* @brief Reads memory information of the specified length from an <b>OHIPCParcel</b> object.
*
* @syscap SystemCapability.Communication.IPC.Core
* @param parcel OHIPCParcel对象的指针，不能为空。
* @param len 读取内存的长度。
* @return 成功返回读取到的内存地址；参数不合法或len超过parcel可读长度时返回NULL。
* @param parcel Pointer to the target <b>OHIPCParcel</b> object. It cannot be NULL.
* @param len Length of the memory to be read.
* @return Returns the memory address read if the operation is successful;
* returns NULL if invalid parameters are found or <b>len</b> exceeds the readable length of <b>parcel</b>.
* @since 12
*/
const uint8_t* OH_IPCParcel_ReadBuffer(const OHIPCParcel *parcel, int32_t len);
/**
* @brief 向OHIPCParcel对象写入OHIPCRemoteStub对象.
* @brief Writes an <b>OHIPCRemoteStub</b> object to an <b>OHIPCParcel</b> object.
*
* @syscap SystemCapability.Communication.IPC.Core
* @param parcel OHIPCParcel对象的指针，不能为空.
* @param stub 需要写入的OHIPCRemoteStub对象指针，不能为空.
* @return 成功返回{@link OH_IPC_ErrorCode#OH_IPC_SUCCESS}. \n
* 参数不合法时返回{@link OH_IPC_ErrorCode#OH_IPC_CHECK_PARAM_ERROR}. \n
* 写入失败返回{@link OH_IPC_ErrorCode#OH_IPC_PARCEL_WRITE_ERROR}.
* @param parcel Pointer to the target <b>OHIPCParcel</b> object. It cannot be NULL.
* @param stub Pointer to the <b>OHIPCRemoteStub</b> object to write. It cannot be NULL.
* @return Returns {@link OH_IPC_ErrorCode#OH_IPC_SUCCESS} if the operation is successful. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_CHECK_PARAM_ERROR} if invalid parameters are found. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_PARCEL_WRITE_ERROR} if the data write operation fails.
* @since 12
*/
int OH_IPCParcel_WriteRemoteStub(OHIPCParcel *parcel, const OHIPCRemoteStub *stub);
/**
* @brief 从OHIPCParcel对象读取OHIPCRemoteStub对象.
* @brief Reads the <b>OHIPCRemoteStub</b> object from an <b>OHIPCParcel</b> object.
*
* @syscap SystemCapability.Communication.IPC.Core
* @param parcel OHIPCParcel对象的指针，不能为空.
* @return 成功返回OHIPCRemoteStub对象指针；失败返回NULL.
* @param parcel Pointer to the target <b>OHIPCParcel</b> object. It cannot be NULL.
* @return Returns the pointer to the <b>OHIPCRemoteStub</b> object read if the operation is successful;
* returns NULL otherwise.
* @since 12
*/
OHIPCRemoteStub* OH_IPCParcel_ReadRemoteStub(const OHIPCParcel *parcel);
/**
* @brief 向OHIPCParcel对象写入OHIPCRemoteProxy对象.
* @brief Writes an <b>OHIPCRemoteProxy</b> object to an <b>OHIPCParcel</b> object.
*
* @syscap SystemCapability.Communication.IPC.Core
* @param parcel OHIPCParcel对象的指针，不能为空.
* @param proxy 需要写入的OHIPCRemoteProxy对象指针，不能为空.
* @return 成功返回{@link OH_IPC_ErrorCode#OH_IPC_SUCCESS}. \n
* 参数不合法时返回{@link OH_IPC_ErrorCode#OH_IPC_CHECK_PARAM_ERROR}. \n
* 写入失败返回{@link OH_IPC_ErrorCode#OH_IPC_PARCEL_WRITE_ERROR}.
* @param parcel Pointer to the target <b>OHIPCParcel</b> object. It cannot be NULL.
* @param proxy Pointer to the <b>OHIPCRemoteProxy</b> object to write. It cannot be NULL.
* @return Returns {@link OH_IPC_ErrorCode#OH_IPC_SUCCESS} if the operation is successful. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_CHECK_PARAM_ERROR} if invalid parameters are found. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_PARCEL_WRITE_ERROR} if the data write operation fails.
* @since 12
*/
int OH_IPCParcel_WriteRemoteProxy(OHIPCParcel *parcel, const OHIPCRemoteProxy *proxy);
/**
* @brief 从OHIPCParcel对象读取OHIPCRemoteProxy对象.
* @brief Reads the <b>OHIPCRemoteProxy</b> object from an <b>OHIPCParcel</b> object.
*
* @syscap SystemCapability.Communication.IPC.Core
* @param parcel OHIPCParcel对象的指针，不能为空.
* @return 成功返回OHIPCRemoteProxy对象指针；失败返回NULL.
* @param parcel Pointer to the target <b>OHIPCParcel</b> object. It cannot be NULL.
* @return Returns the pointer to the <b>OHIPCRemoteProxy</b> object read if the operation is successful;
* returns NULL otherwise.
* @since 12
*/
OHIPCRemoteProxy* OH_IPCParcel_ReadRemoteProxy(const OHIPCParcel *parcel);
/**
* @brief 向OHIPCParcel对象写入文件描述符
* @brief Writes a file descriptor to an <b>OHIPCParcel</b> object.
*
* @syscap SystemCapability.Communication.IPC.Core
* @param parcel OHIPCParcel对象的指针，不能为空.
* @param fd 要写入的文件描述符.
* @return 成功返回{@link OH_IPC_ErrorCode#OH_IPC_SUCCESS}. \n
* 参数不合法时返回{@link OH_IPC_ErrorCode#OH_IPC_CHECK_PARAM_ERROR}. \n
* 写入失败返回{@link OH_IPC_ErrorCode#OH_IPC_PARCEL_WRITE_ERROR}.
* @param parcel Pointer to the target <b>OHIPCParcel</b> object. It cannot be NULL.
* @param fd File descriptor to write.
* @return Returns {@link OH_IPC_ErrorCode#OH_IPC_SUCCESS} if the operation is successful. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_CHECK_PARAM_ERROR} if invalid parameters are found. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_PARCEL_WRITE_ERROR} if the data write operation fails.
* @since 12
*/
int OH_IPCParcel_WriteFileDescriptor(OHIPCParcel *parcel, int32_t fd);
/**
* @brief 从OHIPCParcel对象读取文件描述符.
* @brief Reads a file descriptor from an <b>OHIPCParcel</b> object.
*
* @syscap SystemCapability.Communication.IPC.Core
* @param parcel OHIPCParcel对象的指针，不能为空.
* @param fd 存储读取文件描述符的指针，不能为空.
* @return 成功返回{@link OH_IPC_ErrorCode#OH_IPC_SUCCESS}. \n
* 参数不合法时返回{@link OH_IPC_ErrorCode#OH_IPC_CHECK_PARAM_ERROR}. \n
* 读取失败返回{@link OH_IPC_ErrorCode#OH_IPC_PARCEL_READ_ERROR}.
* @param parcel Pointer to the target <b>OHIPCParcel</b> object. It cannot be NULL.
* @param fd Pointer to the file descriptor to read. It cannot be NULL.
* @return Returns {@link OH_IPC_ErrorCode#OH_IPC_SUCCESS} if the operation is successful. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_CHECK_PARAM_ERROR} if invalid parameters are found. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_PARCEL_READ_ERROR} if the read operation fails.
* @since 12
*/
int OH_IPCParcel_ReadFileDescriptor(const OHIPCParcel *parcel, int32_t *fd);
/**
* @brief OHIPCParcel对象数据拼接.
* @brief Appends data to an <b>OHIPCParcel</b> object.
*
* @syscap SystemCapability.Communication.IPC.Core
* @param parcel 拼接目标OHIPCParcel对象的指针，不能为空.
* @param data 源OHIPCParcel对象的指针，不能为空.
* @return 成功返回{@link OH_IPC_ErrorCode#OH_IPC_SUCCESS}. \n
* 参数不合法时返回{@link OH_IPC_ErrorCode#OH_IPC_CHECK_PARAM_ERROR}. \n
* 拼接失败返回{@link OH_IPC_ErrorCode#OH_IPC_PARCEL_WRITE_ERROR}.
* @param parcel Pointer to the target <b>OHIPCParcel</b> object. It cannot be NULL.
* @param data Pointer to the data to append. It cannot be NULL.
* @return Returns {@link OH_IPC_ErrorCode#OH_IPC_SUCCESS} if the operation is successful. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_CHECK_PARAM_ERROR} if invalid parameters are found. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_PARCEL_WRITE_ERROR} if the operation fails.
* @since 12
*/
int OH_IPCParcel_Append(OHIPCParcel *parcel, const OHIPCParcel *data);
/**
* @brief 向OHIPCParcel对象写入接口描述符，用于接口身份校验.
* @brief Writes an interface token to an <b>OHIPCParcel</b> object for interface identity verification.
*
* @syscap SystemCapability.Communication.IPC.Core
* @param parcel OHIPCParcel对象的指针，不能为空.
* @param token 需要写入的接口描述符信息，不能为空.
* @return 成功返回{@link OH_IPC_ErrorCode#OH_IPC_SUCCESS}. \n
* 参数不合法时返回{@link OH_IPC_ErrorCode#OH_IPC_CHECK_PARAM_ERROR}. \n
* 写入失败返回{@link OH_IPC_ErrorCode#OH_IPC_PARCEL_WRITE_ERROR}.
* @param parcel Pointer to the target <b>OHIPCParcel</b> object. It cannot be NULL.
* @param token Pointer to the interface token to write. It cannot be NULL.
* @return Returns {@link OH_IPC_ErrorCode#OH_IPC_SUCCESS} if the operation is successful. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_CHECK_PARAM_ERROR} if invalid parameters are found. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_PARCEL_WRITE_ERROR} if the data write operation fails.
* @since 12
*/
int OH_IPCParcel_WriteInterfaceToken(OHIPCParcel *parcel, const char *token);
/**
* @brief 从OHIPCParcel对象读取接口描述符信息，用于接口身份校验.
* @brief Reads an interface token from an <b>OHIPCParcel</b> object for interface identity verification.
*
* @syscap SystemCapability.Communication.IPC.Core
* @param parcel OHIPCParcel对象的指针，不能为空.
* @param token 用于存储接口描述符信息的内存地址，该内存由用户提供的分配器进行内存分配，用户使用完后需要主动释放，不能为空. \n
* 接口返回失败时，用户依然需要判断该内存是否为空，并主动释放，否则会造成内存泄漏.
* @param len 存储读取接口描述符的长度，包含结束符，不能为空.
* @param allocator 用户指定的用来分配token的内存分配器，不能为空.
* @return 成功返回{@link OH_IPC_ErrorCode#OH_IPC_SUCCESS}. \n
* 参数不合法时返回{@link OH_IPC_ErrorCode#OH_IPC_CHECK_PARAM_ERROR}. \n
* 读取失败返回{@link OH_IPC_ErrorCode#OH_IPC_PARCEL_READ_ERROR}.
* @param parcel Pointer to the target <b>OHIPCParcel</b> object. It cannot be NULL.
* @param token Pointer to the address of the memory for storing the interface token.
* The memory is allocated by the allocator provided by the user and needs to be released. This pointer cannot be NULL.
* If an error code is returned, you still need to check whether the memory is empty and release the memory.
* Otherwise, memory leaks may occur.
* @param len Pointer to the length of the interface token read, including the terminator. It cannot be NULL.
* @param allocator Memory allocator specified by the user for allocating memory for <b>token</b>. It cannot be NULL.
* @return Returns {@link OH_IPC_ErrorCode#OH_IPC_SUCCESS} if the operation is successful. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_CHECK_PARAM_ERROR} if invalid parameters are found. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_PARCEL_READ_ERROR} if the read operation fails.
* @since 12
*/
int OH_IPCParcel_ReadInterfaceToken(const OHIPCParcel *parcel, char **token, int32_t *len,
@ -470,4 +527,5 @@ int OH_IPCParcel_ReadInterfaceToken(const OHIPCParcel *parcel, char **token, int
}
#endif
/** @} */
#endif

207
interfaces/innerkits/c_api/include/ipc_cremote_object.h
View File

@ -20,7 +20,8 @@
* @addtogroup OHIPCRemoteObject
* @{
*
* @brief 提供远端对象创建、销毁、数据发送、远端对象死亡状态监听等功能C接口.
* @brief Provides C interfaces for creating and destroying a remote object, transferring data,
* and observing the dead status of a remote object.
*
* @syscap SystemCapability.Communication.IPC.Core
* @since 12
@ -29,9 +30,11 @@
/**
* @file ipc_cremote_object.h
*
* @brief 提供远端对象创建、销毁、数据发送、远端对象死亡状态监听等功能C接口.
* @brief Defines C interfaces for creating and destroying a remote object, transferring data,
* and observing the dead status of a remote object.
*
* @library libipc_capi.so
* @syscap SystemCapability.Communication.IPC.Core
* @since 12
*/
@ -43,214 +46,234 @@
extern "C" {
#endif
/**
* @brief Defines an <b>OHIPCDeathRecipient</b> object, which is used to receive a notification
* when the <b>OHIPCRemoteStub</b> object dies unexpectedly.
*
* @syscap SystemCapability.Communication.IPC.Core
* @since 12
*/
struct OHIPCDeathRecipient;
/**
* @brief Stub端用于处理远端数据请求的回调函数.
* @brief Typedef an <b>OHIPCDeathRecipient</b> object.
*
* @syscap SystemCapability.Communication.IPC.Core
* @since 12
*/
typedef struct OHIPCDeathRecipient OHIPCDeathRecipient;
/**
* @brief Called to process the remote data request at the stub.
*
* @syscap SystemCapability.Communication.IPC.Core
* @param code 用户自定义通讯命令字，范围:[0x01, 0x00ffffff].
* @param data 请求数据对象指针，不会为空，函数内不允许释放.
* @param reply 回应数据对象指针，不会为空，函数内不允许释放. \n
* 如果函数返回错误，该值不允许写入数据.
* @param userData 用户私有数据，可以为空.
* @return 成功返回{@link OH_IPC_ErrorCode#OH_IPC_SUCCESS}. \n
* 否则返回用户自定义错误码或系统错误码，自定义错误码范围:[1909001, 1909999]. \n
* 如果用户自定义错误码超出范围，将返回{@link OH_IPC_ErrorCode#OH_IPC_INVALID_USER_ERROR_CODE}.
* @param code Custom command word for communication, in the range [0x01, 0x00ffffff].
* @param data Pointer to the request data object. It cannot be NULL or released in the function.
* @param reply Pointer to the response data object. It cannot be NULL or released in the function.
* If this function returns an error, data cannot be written to this parameter.
* @param userData Pointer to the user data. It can be NULL.
* @return Returns {@link OH_IPC_ErrorCode#OH_IPC_SUCCESS} if the operation is successful. \n
* Returns a custom error code in the range [1909001, 1909999] or a system error code otherwise. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_INVALID_USER_ERROR_CODE} if the custom error code is out of the value range.
* @since 12
*/
typedef int (*OH_OnRemoteRequestCallback)(uint32_t code, const OHIPCParcel *data,
OHIPCParcel *reply, void *userData);
/**
* @brief Stub端用于监听对象销毁的回调函数.
* @brief Called when an observed object is destroyed.
*
* @syscap SystemCapability.Communication.IPC.Core
* @param userData 用户私有数据，可以为空.
* @param userData Pointer to the user data. It can be NULL.
* @since 12
*/
typedef void (*OH_OnRemoteDestroyCallback)(void *userData);
/**
* @brief 创建OHIPCRemoteStub对象.
* @brief Creates an <b>OHIPCRemoteStub</b> object.
*
* @syscap SystemCapability.Communication.IPC.Core
* @param descriptor OHIPCRemoteStub对象描述符，不能为空.
* @param requestCallback 数据请求处理函数，不能为空.
* @param destroyCallback 对象销毁回调函数，可以为空.
* @param userData 用户私有数据，可以为空.
* @return 成功返回OHIPCRemoteStub对象指针，否则返回NULL.
* @param descriptor Pointer to the descriptor of the <b>OHIPCRemoteStub</b> object to create. It cannot be NULL.
* @param requestCallback Callback used to process the data request. It cannot be NULL.
* @param destroyCallback Callback to be invoked when the object is destroyed. It can be NULL.
* @param userData Pointer to the user data. It can be NULL.
* @return Returns the pointer to the <b>OHIPCRemoteStub</b> object created if the operation is successful;
* returns NULL otherwise.
* @since 12
*/
OHIPCRemoteStub* OH_IPCRemoteStub_Create(const char *descriptor, OH_OnRemoteRequestCallback requestCallback,
OH_OnRemoteDestroyCallback destroyCallback, void *userData);
/**
* @brief 销毁OHIPCRemoteStub对象.
* @brief Destroys an <b>OHIPCRemoteStub</b> object.
*
* @syscap SystemCapability.Communication.IPC.Core
* @param stub 要销毁的OHIPCRemoteStub对象指针.
* @param stub Pointer to the <b>OHIPCRemoteStub</b> object to destroy.
* @since 12
*/
void OH_IPCRemoteStub_Destroy(OHIPCRemoteStub *stub);
/**
* @brief 销毁OHIPCRemoteProxy对象.
* @brief Destroys an <b>OHIPCRemoteProxy</b> object.
*
* @syscap SystemCapability.Communication.IPC.Core
* @param proxy 要销毁的OHIPCRemoteProxy对象指针.
* @param proxy Pointer to the <b>OHIPCRemoteProxy</b> object to destroy.
* @since 12
*/
void OH_IPCRemoteProxy_Destroy(OHIPCRemoteProxy *proxy);
/**
* @brief IPC请求模式定义
* @brief Enumerates the IPC request modes.
*
* @since 12
*/
enum OH_IPC_RequestMode {
/**
* 同步请求模式
*/
typedef enum {
/** Synchronous request. */
OH_IPC_REQUEST_MODE_SYNC = 0,
/**
* 异步请求模式
*/
/** Asynchronous request. */
OH_IPC_REQUEST_MODE_ASYNC = 1,
};
} OH_IPC_RequestMode;
/**
* @brief IPC消息选项定义.
* @brief Defines the IPC message options.
*
* @since 12
*/
#pragma pack(4)
struct OH_IPC_MessageOption {
/**
* 消息请求模式
*/
typedef struct {
/** Message request mode. */
OH_IPC_RequestMode mode;
/**
* RPC预留参数，该参数对IPC无效
*/
/** Parameter reserved for RPC, which is invalid for IPC. */
uint32_t timeout;
/**
* 保留参数，必须为空
*/
/** Reserved parameter, which must be NULL. */
void* reserved;
};
} OH_IPC_MessageOption;
#pragma pack()
/**
* @brief IPC消息发送函数.
* @brief Sends an IPC message.
*
* @syscap SystemCapability.Communication.IPC.Core
* @param proxy OHIPCRemoteProxy对象指针，不能为空.
* @param code 用户定义的IPC命令字，范围:[0x01,0x00ffffff].
* @param data 请求数据对象指针，不能为空.
* @param reply 回应数据对象指针，同步请求时，不能为空；异步请求时，可以为空.
* @param option 消息选项指针，可以为空，为空时按同步处理.
* @return 发送成功返回{@link OH_IPC_ErrorCode#OH_IPC_SUCCESS}. \n
* 参数不合法时返回{@link OH_IPC_ErrorCode#OH_IPC_CHECK_PARAM_ERROR}. \n
* 远端OHIPCRemoteStub对象死亡返回{@link OH_IPC_ErrorCode#OH_IPC_DEAD_REMOTE_OBJECT}. \n
* code超出范围返回{@link OH_IPC_ErrorCode#OH_IPC_CODE_OUT_OF_RANGE}. \n
* 其它返回{@link OH_IPC_ErrorCode#OH_IPC_INNER_ERROR}或用户自定义错误码.
* @param proxy Pointer to the <b>OHIPCRemoteProxy</b> object. It cannot be NULL.
* @param code Custom IPC command word, in the range [0x01, 0x00ffffff].
* @param data Pointer to the request data object. It cannot be NULL.
* @param reply Pointer to the response data object. It cannot be NULL in the case of a synchronous request,
* and can be NULL in the case of an asynchronous request.
* @param option Pointer to the message options. It can be NULL, which indicates a synchronous request.
* @return Returns {@link OH_IPC_ErrorCode#OH_IPC_SUCCESS} if the operation is successful. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_CHECK_PARAM_ERROR} if invalid parameters are found. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_DEAD_REMOTE_OBJECT} if the <b>OHIPCRemoteStub</b> object is dead. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_CODE_OUT_OF_RANGE} if the error code is out of the value range. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_INNER_ERROR} or a custom error code in other cases.
* @since 12
*/
int OH_IPCRemoteProxy_SendRequest(const OHIPCRemoteProxy *proxy, uint32_t code, const OHIPCParcel *data,
OHIPCParcel *reply, const OH_IPC_MessageOption *option);
/**
* @brief 从Stub端获取接口描述符.
* @brief Obtains the interface descriptor from the stub.
*
* @syscap SystemCapability.Communication.IPC.Core
* @param proxy OHIPCRemoteProxy对象指针，不能为空.
* @param descriptor 用于存储描述符的内存地址，该内存由用户提供的分配器进行内存分配，用户使用完后需要主动释放，不能为空. \n
* 接口返回失败时，用户依然需要判断该内存是否为空，并主动释放，否则会造成内存泄漏.
* @param len 写入descriptor的数据长度，包含结束符，不能为空.
* @param allocator 用户指定的用来分配descriptor的内存分配器，不能为空.
* @return 成功返回{@link OH_IPC_ErrorCode#OH_IPC_SUCCESS}. \n
* 参数错误返回{@link OH_IPC_ErrorCode#OH_IPC_CHECK_PARAM_ERROR}. \n
* 远端OHIPCRemoteStub对象死亡返回{@link OH_IPC_ErrorCode#OH_IPC_DEAD_REMOTE_OBJECT}. \n
* 内存分配失败返回{@link OH_IPC_ErrorCode#OH_IPC_MEM_ALLOCATOR_ERROR}. \n
* 序列化读失败返回{@link OH_IPC_ErrorCode#OH_IPC_PARCEL_READ_ERROR}.
* @param proxy Pointer to the <b>OHIPCRemoteProxy</b> object. It cannot be NULL.
* @param descriptor Double pointer to the address of the memory for holding the interface descriptor.
* The memory is allocated by the allocator provided by the user and needs to be released. This pointer cannot be NULL.
* If an error code is returned, you still need to check whether the memory is empty and release the memory.
* Otherwise, memory leaks may occur.
* @param len Pointer to the length of the data to be written to the descriptor, including the terminator.
* This parameter cannot be NULL.
* @param allocator Memory allocator specified by the user for allocating memory for <b>descriptor</b>.
* It cannot be NULL.
* @return Returns {@link OH_IPC_ErrorCode#OH_IPC_SUCCESS} if the operation is successful. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_CHECK_PARAM_ERROR} if incorrect parameters are found. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_DEAD_REMOTE_OBJECT} if the <b>OHIPCRemoteStub</b> object is dead. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_MEM_ALLOCATOR_ERROR} if memory allocation fails. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_PARCEL_READ_ERROR} if the data in the serialized object failed to be read.
* @since 12
*/
int OH_IPCRemoteProxy_GetInterfaceDescriptor(OHIPCRemoteProxy *proxy, char **descriptor, int32_t *len,
OH_IPC_MemAllocator allocator);
/**
* @brief 远端OHIPCRemoteStub对象死亡通知的回调函数类型.
* @brief Called when the <b>OHIPCRemoteStub</b> object dies unexpectedly.
*
* @syscap SystemCapability.Communication.IPC.Core
* @param userData 用户私有数据指针，可以为空.
* @param userData Pointer to the user data. It can be NULL.
* @since 12
*/
typedef void (*OH_OnDeathRecipientCallback)(void *userData);
/**
* @brief OHIPCDeathRecipient对象销毁回调函数类型.
* @brief Called when the <b>OHIPCDeathRecipient</b> object is destroyed.
*
* @syscap SystemCapability.Communication.IPC.Core
* @param userData 用户私有数据指针，可以为空.
* @param userData Pointer to the user data. It can be NULL.
* @since 12
*/
typedef void (*OH_OnDeathRecipientDestroyCallback)(void *userData);
/**
* @brief 创建远端OHIPCRemoteStub对象死亡通知对象OHIPCDeathRecipient.
* @brief Creates an <b>OHIPCDeathRecipient</b> object, which allows a notification to be received
* when the <b>OHIPCRemoteStub</b> object dies unexpectedly.
*
* @syscap SystemCapability.Communication.IPC.Core
* @param deathRecipientCallback 远端OHIPCRemoteStub对象死亡通知的回调处理函数，不能为空.
* @param destroyCallback 对象销毁回调处理函数，可以为空.
* @param userData 用户私有数据指针，可以为空.
* @return 成功返回OHIPCDeathRecipient对象指针;否则返回NULL.
* @param deathRecipientCallback Callback to be invoked when the <b>OHIPCRemoteStub</b> object is dead.
* It cannot be NULL.
* @param destroyCallback Callback to be invoked when the object is destroyed. It can be NULL.
* @param userData Pointer to the user data. It can be NULL.
* @return Returns the pointer to the <b>OHIPCDeathRecipient</b> object created if the operation is successful;
* returns NULL otherwise.
* @since 12
*/
OHIPCDeathRecipient* OH_IPCDeathRecipient_Create(OH_OnDeathRecipientCallback deathRecipientCallback,
OH_OnDeathRecipientDestroyCallback destroyCallback, void *userData);
/**
* @brief 销毁OHIPCDeathRecipient对象.
* @brief Destroys an <b>OHIPCDeathRecipient</b> object.
*
* @syscap SystemCapability.Communication.IPC.Core
* @param recipient 要销毁的OHIPCDeathRecipient对象指针.
* @param recipient Pointer to the <b>OHIPCDeathRecipient</b> object to destroy.
* @since 12
*/
void OH_IPCDeathRecipient_Destroy(OHIPCDeathRecipient *recipient);
/**
* @brief 向OHIPCRemoteProxy对象添加死亡监听，用于接收远端OHIPCRemoteStub对象死亡的回调通知.
* @brief Subscribes to the death of an <b>OHIPCRemoteStub</b> object for an <b>OHIPCRemoteProxy</b> object.
*
* @syscap SystemCapability.Communication.IPC.Core
* @param proxy 需要添加死亡通知的OHIPCRemoteProxy对象指针，不能为空.
* @param recipient 用于接收远程对象死亡通知的死亡对象指针，不能为空.
* @return 成功返回{@link OH_IPC_ErrorCode#OH_IPC_SUCCESS}. \n
* 参数错误返回{@link OH_IPC_ErrorCode#OH_IPC_CHECK_PARAM_ERROR}. \n
* 其它{@link OH_IPC_ErrorCode#OH_IPC_INNER_ERROR}.
* @param proxy Pointer to the <b>OHIPCRemoteProxy</b> object that subscribes to the death notification.
* It cannot be NULL.
* @param recipient Pointer to the object that receives the death notification of the <b>OHIPCRemoteStub</b> object.
* It cannot be NULL.
* @return Returns {@link OH_IPC_ErrorCode#OH_IPC_SUCCESS} if the operation is successful. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_CHECK_PARAM_ERROR} if incorrect parameters are found. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_INNER_ERROR} in other cases.
* @since 12
*/
int OH_IPCRemoteProxy_AddDeathRecipient(OHIPCRemoteProxy *proxy, OHIPCDeathRecipient *recipient);
/**
* @brief 移除向OHIPCRemoteProxy对象已经添加的死亡监听.
* @brief Unsubscribes from the death of the <b>OHIPCRemoteStub</b> object for an <b>OHIPCRemoteProxy</b> object.
*
* @syscap SystemCapability.Communication.IPC.Core
* @param proxy 需要移除死亡通知的OHIPCRemoteProxy对象指针，不能为空.
* @param recipient 用于接收远程对象死亡通知的死亡对象指针，不能为空.
* @return 成功返回{@link OH_IPC_ErrorCode#OH_IPC_SUCCESS}. \n
* 参数错误返回{@link OH_IPC_ErrorCode#OH_IPC_CHECK_PARAM_ERROR}. \n
* 其它{@link OH_IPC_ErrorCode#OH_IPC_INNER_ERROR}.
* @param proxy Pointer to the <b>OHIPCRemoteProxy</b> object that unsubscribes from the death notification.
* It cannot be NULL.
* @param recipient Pointer to the object that receives the death notification of the <b>OHIPCRemoteStub</b> object.
* It cannot be NULL.
* @return Returns {@link OH_IPC_ErrorCode#OH_IPC_SUCCESS} if the operation is successful. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_CHECK_PARAM_ERROR} if incorrect parameters are found. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_INNER_ERROR} in other cases.
* @since 12
*/
int OH_IPCRemoteProxy_RemoveDeathRecipient(OHIPCRemoteProxy *proxy, OHIPCDeathRecipient *recipient);
/**
* @brief 判断OHIPCRemoteProxy对象对应的远端OHIPCRemoteStub对象是否死亡.
* @brief Checks whether the <b>OHIPCRemoteStub</b> object corresponding to the <b>OHIPCRemoteProxy</b> object is dead.
*
* @syscap SystemCapability.Communication.IPC.Core
* @param proxy 需要判断远端是否死亡的OHIPCRemoteProxy对象指针，不能为空.
* @return 远端OHIPCRemoteStub对象死亡返回1; 否则，返回0. 参数非法时，说明其远端OHIPCRemoteStub对象不存在，返回1.
* @param proxy Pointer to the <b>OHIPCRemoteProxy</b> object to check. It cannot be NULL.
* @return Returns <b>1</b> if the <b>OHIPCRemoteStub</b> object is dead; returns <b>0</b> otherwise.
* If an invalid parameter is found, the <b>OHIPCRemoteStub</b> object does not exist.
* In this case, <b>1</b> is returned.
* @since 12
*/
int OH_IPCRemoteProxy_IsRemoteDead(const OHIPCRemoteProxy *proxy);

84
interfaces/innerkits/c_api/include/ipc_cskeleton.h
View File

@ -20,7 +20,8 @@
* @addtogroup OHIPCSkeleton
* @{
*
* @brief 提供IPC框架tokenId、凭据、PID/UID、线程池配置等功能C接口.
* @brief Provides C interfaces for managing the token IDs, credentials, process IDs (PIDs),
* user IDs (UIDs), and thread pool in the IPC framework.
*
* @syscap SystemCapability.Communication.IPC.Core
* @since 12
@ -29,9 +30,11 @@
/**
* @file ipc_cskeleton.h
*
* @brief 提供IPC框架tokenId、凭据、PID/UID、线程池配置等功能C接口.
* @brief Defines C interfaces for managing the token IDs, credentials, PIDs, UIDs, and thread
* pool in the IPC framework.
*
* @library libipc_capi.so
* @syscap SystemCapability.Communication.IPC.Core
* @since 12
*/
@ -44,7 +47,7 @@ extern "C" {
#endif
/**
* @brief 当前线程加入IPC工作线程池.
* @brief Joints this thread to the IPC worker thread pool.
*
* @syscap SystemCapability.Communication.IPC.Core
* @since 12
@ -52,7 +55,7 @@ extern "C" {
void OH_IPCSkeleton_JoinWorkThread(void);
/**
* @brief 当前线程退出IPC工作线程池.
* @brief Stops this thread.
*
* @syscap SystemCapability.Communication.IPC.Core
* @since 12
@ -60,104 +63,111 @@ void OH_IPCSkeleton_JoinWorkThread(void);
void OH_IPCSkeleton_StopWorkThread(void);
/**
* @brief 获取调用方TokenId.该接口需要在IPC上下文中调用，否则返回自身TokenId.
* @brief Obtains the token ID of the caller. This function must be called in the IPC context.
* Otherwise, the local token ID is returned.
*
* @syscap SystemCapability.Communication.IPC.Core
* @return 返回调用方TokenId.
* @return Returns the token ID of the caller.
* @since 12
*/
uint64_t OH_IPCSkeleton_GetCallingTokenId(void);
/**
* @brief 获取首调者TokenId.
* @brief Obtains the token ID of the first caller.
*
* @syscap SystemCapability.Communication.IPC.Core
* @return 返回首调者TokenId.
* @return Returns the token ID obtained.
* @since 12
*/
uint64_t OH_IPCSkeleton_GetFirstTokenId(void);
/**
* @brief 获取自身TokenId.
* @brief Obtains the local token ID.
*
* @syscap SystemCapability.Communication.IPC.Core
* @return 返回自身TokenId.
* @return Returns the token ID obtained.
* @since 12
*/
uint64_t OH_IPCSkeleton_GetSelfTokenId(void);
/**
* @brief 获取调用方进程ID.该接口需要在IPC上下文中调用，否则返当前进程ID.
* @brief Obtains the process ID of the caller. This function must be called in the IPC context.
* Otherwise, the current process ID is returned.
*
* @syscap SystemCapability.Communication.IPC.Core
* @return 返回调用方进程ID.
* @return Returns the process ID of the caller.
* @since 12
*/
uint64_t OH_IPCSkeleton_GetCallingPid(void);
/**
* @brief 获取调用方用户ID.该接口需要在IPC上下文中调用，否则返当前用户ID.
* @brief Obtains the UID of the caller. This function must be called in the IPC context.
* Otherwise, the current UID is returned.
*
* @syscap SystemCapability.Communication.IPC.Core
* @return 返回调用方用户ID.
* @return Returns the UID of the caller.
* @since 12
*/
uint64_t OH_IPCSkeleton_GetCallingUid(void);
/**
* @brief 判断是否正在进行本地调用.
* @brief Checks whether a local calling is being made.
*
* @syscap SystemCapability.Communication.IPC.Core
* @return 正在进行本地调用，返回1；否则，返回0.
* @return Returns <b>1</b> if a local calling is in progress; returns <b>0</b> otherwise.
* @since 12
*/
int OH_IPCSkeleton_IsLocalCalling(void);
/**
* @brief 设置最大工作线程数.
* @brief Sets the maximum number of worker threads.
*
* @syscap SystemCapability.Communication.IPC.Core
* @param maxThreadNum 最大工作线程数，默认16，范围[1, 32].
* @return 成功返回{@link OH_IPC_ErrorCode#OH_IPC_SUCCESS}. \n
* 参数错误返回{@link OH_IPC_ErrorCode#OH_IPC_CHECK_PARAM_ERROR}. \n
* 其它情况返回{@link OH_IPC_ErrorCode#OH_IPC_INNER_ERROR}.
* @param maxThreadNum Maximum number of worker threads to set. The default value is <b>16</b>.
* The value range is [1, 32].
* @return Returns {@link OH_IPC_ErrorCode#OH_IPC_SUCCESS} if the operation is successful. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_CHECK_PARAM_ERROR} if incorrect parameters are found. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_INNER_ERROR} in other cases.
* @since 12
*/
int OH_IPCSkeleton_SetMaxWorkThreadNum(const int maxThreadNum);
/**
* @brief 重置调用方身份凭证为自身进程的身份凭证（包括tokenid、UID和PID信息），并返回调用方的凭证信息.
* 该信息主要用于OH_IPCSkeleton_SetCallingIdentity接口调用.
* @brief Resets the caller identity credential (including the token ID, UID, and PID) to that of this process and
* returns the caller credential information.
* The identity information is used in <b>OH_IPCSkeleton_SetCallingIdentity</b>.
*
* @syscap SystemCapability.Communication.IPC.Core
* @param identity 用于存储调凭证的内存地址，该内存由用户提供的分配器进行内存分配，用户使用完后需要主动释放，不能为空.
* @param len 写入identity的数据长度，不能为空.
* @param allocator 用户指定的用来分配identity的内存分配器，不能为空.
* @return 成功返回{@link OH_IPC_ErrorCode#OH_IPC_SUCCESS}. \n
* 参数错误返回{@link OH_IPC_ErrorCode#OH_IPC_CHECK_PARAM_ERROR}. \n
* 内存分配失败返回{@link OH_IPC_ErrorCode#OH_IPC_MEM_ALLOCATOR_ERROR}. \n
* 其它情况返回{@link OH_IPC_ErrorCode#OH_IPC_INNER_ERROR}.
* @param identity Pointer to the address of the memory for holding the caller identity information.
* The memory is allocated by the allocator provided by the user and needs to be released. This pointer cannot be NULL.
* @param len Pointer to the length of the identity information. It cannot be NULL.
* @param allocator Memory allocator specified by the user for allocating memory for <b>identity</b>. It cannot be NULL.
* @return Returns {@link OH_IPC_ErrorCode#OH_IPC_SUCCESS} if the operation is successful. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_CHECK_PARAM_ERROR} if incorrect parameters are found. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_MEM_ALLOCATOR_ERROR} if memory allocation fails. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_INNER_ERROR} in other cases.
* @since 12
*/
int OH_IPCSkeleton_ResetCallingIdentity(char **identity, int32_t *len, OH_IPC_MemAllocator allocator);
/**
* @brief 恢复调用方凭证信息至IPC上下文中.
* @brief Sets the caller credential information to the IPC context.
*
* @syscap SystemCapability.Communication.IPC.Core
* @param identity 调用方凭证，不能为空.来源于OH_IPCSkeleton_ResetCallingIdentity的返回值.
* @return 成功返回{@link OH_IPC_ErrorCode#OH_IPC_SUCCESS}. \n
* 参数错误返回{@link OH_IPC_ErrorCode#OH_IPC_CHECK_PARAM_ERROR}. \n
* 其它情况返回{@link OH_IPC_ErrorCode#OH_IPC_INNER_ERROR}.
* @param identity Pointer to the caller identity, which cannot be NULL.
* The value is returned by <b>OH_IPCSkeleton_ResetCallingIdentity</b>.
* @return Returns {@link OH_IPC_ErrorCode#OH_IPC_SUCCESS} if the operation is successful. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_CHECK_PARAM_ERROR} if incorrect parameters are found. \n
* Returns {@link OH_IPC_ErrorCode#OH_IPC_INNER_ERROR} in other cases.
* @since 12
*/
int OH_IPCSkeleton_SetCallingIdentity(const char *identity);
/**
* @brief 是否正在处理IPC请求.
* @brief Checks whether an IPC request is being handled.
*
* @syscap SystemCapability.Communication.IPC.Core
* @return 正在处理IPC请求，返回1；否则，返回0.
* @return Returns <b>1</b> if an IPC request is being handled; returns <b>0</b> otherwise.
* @since 12
*/
int OH_IPCSkeleton_IsHandlingTransaction(void);

69
interfaces/innerkits/c_api/include/ipc_error_code.h
View File

@ -20,7 +20,7 @@
* @addtogroup OHIPCErrorCode
* @{
*
* @brief Provides IPC error code define.
* @brief Provides IPC error codes.
*
* @syscap SystemCapability.Communication.IPC.Core
* @since 12
@ -29,71 +29,46 @@
/**
* @file ipc_error_code.h
*
* @brief Provides IPC error code define.
* @brief Defines IPC error codes.
*
* @library libipc_capi.so
* @syscap SystemCapability.Communication.IPC.Core
* @since 12
*/
/**
* @brief IPC错误码定义. \n
*
* @since 12
*/
enum OH_IPC_ErrorCode {
/**
* 执行成功
*/
* @brief Enumerates IPC error codes.
*
* @since 12
*/
typedef enum {
/** @error Execution successful. */
OH_IPC_SUCCESS = 0,
/**
* 错误码区间起始值
*/
/** @error Start error code. */
OH_IPC_ERROR_CODE_BASE = 1901000,
/**
* 参数错误
*/
/** @error Invalid parameters. */
OH_IPC_CHECK_PARAM_ERROR = OH_IPC_ERROR_CODE_BASE,
/**
* 序列化对象写入数据失败
*/
/** @error Failed to write data to the serialized object. */
OH_IPC_PARCEL_WRITE_ERROR = OH_IPC_ERROR_CODE_BASE + 1,
/**
* 序列化对象读取数据失败
*/
/** @error Failed to read data from the serialized object. */
OH_IPC_PARCEL_READ_ERROR = OH_IPC_ERROR_CODE_BASE + 2,
/**
* 内存分配失败
*/
/** @error Failed to allocate memory. */
OH_IPC_MEM_ALLOCATOR_ERROR = OH_IPC_ERROR_CODE_BASE + 3,
/**
* 命令字超出定义范围[0x01,0x00ffffff]
*/
/** @error The command word is out of the value range [0x01,0x00ffffff]. */
OH_IPC_CODE_OUT_OF_RANGE = OH_IPC_ERROR_CODE_BASE + 4,
/**
* 远端对象死亡
*/
/** @error The remote object is dead. */
OH_IPC_DEAD_REMOTE_OBJECT = OH_IPC_ERROR_CODE_BASE + 5,
/**
* 用户自定义错误码超出范围[1900001, 1999999]
*/
/** @error The custom error code is out of range [1900001, 1999999]. */
OH_IPC_INVALID_USER_ERROR_CODE = OH_IPC_ERROR_CODE_BASE + 6,
/**
* IPC内部错误
*/
/** @error IPC internal error. */
OH_IPC_INNER_ERROR = OH_IPC_ERROR_CODE_BASE + 7,
/**
* 错误码区间最大值
*/
/** @error Maximum error code. */
OH_IPC_ERROR_CODE_MAX = OH_IPC_ERROR_CODE_BASE + 1000,
/**
* 用户自定义错误码最小值
*/
/** @error Minimum value for a custom error code. */
OH_IPC_USER_ERROR_CODE_MIN = 1909000,
/**
* 用户自定义错误码最大值
*/
/** @error Maximum value for a custom error code. */
OH_IPC_USER_ERROR_CODE_MAX = 1909999,
};
} OH_IPC_ErrorCode;
/** @} */
#endif

21
interfaces/innerkits/c_api/include/ipc_kit.h
View File

@ -16,9 +16,30 @@
#ifndef CAPI_INCLUDE_IPC_KIT_H
#define CAPI_INCLUDE_IPC_KIT_H
/**
* @addtogroup IPCKit
* @{
*
* @brief Provides an entry to the IPC header files for you to reference.
*
* @syscap SystemCapability.Communication.IPC.Core
* @since 12
*/
/**
* @file ipc_cparcel.h
*
* @brief Provides an entry to the IPC header files for you to reference.
*
* @library libipc_capi.so
* @syscap SystemCapability.Communication.IPC.Core
* @since 12
*/
#include "ipc_error_code.h"
#include "ipc_cparcel.h"
#include "ipc_cremote_object.h"
#include "ipc_cskeleton.h"
/** @} */
#endif

21
ipc/native/src/mock/include/binder_invoker.h
View File

@ -164,7 +164,11 @@ private:
void OnReleaseObject(uint32_t cmd);
void OnTransaction(const uint8_t *);
void Transaction(const uint8_t *buffer);
void OnTransaction(int32_t &error);
void OnSpawnThread();
int HandleCommands(uint32_t cmd);
@ -217,6 +221,21 @@ private:
int lastErrCnt_ = 0;
const std::unordered_set<int32_t> readHandleFromCommandsSet = {BC_ACQUIRE, BC_RELEASE,
BC_REQUEST_DEATH_NOTIFICATION, BC_REPLY, BC_CLEAR_DEATH_NOTIFICATION, BC_FREE_BUFFER, BC_TRANSACTION};
const std::map<int32_t, std::function<void(int32_t cmd, int32_t &error)>> commandMap_ = {
{ BR_ERROR, [&](int32_t cmd, int32_t &error) { error = input_.ReadInt32(); } },
{ BR_ACQUIRE, [&](int32_t cmd, int32_t &error) { OnAcquireObject(cmd); } },
{ BR_INCREFS, [&](int32_t cmd, int32_t &error) { OnAcquireObject(cmd); } },
{ BR_RELEASE, [&](int32_t cmd, int32_t &error) { OnReleaseObject(cmd); } },
{ BR_DECREFS, [&](int32_t cmd, int32_t &error) { OnReleaseObject(cmd); } },
{ BR_ATTEMPT_ACQUIRE, [&](int32_t cmd, int32_t &error) { OnAttemptAcquire(); } },
{ BR_TRANSACTION, [&](int32_t cmd, int32_t &error) { OnTransaction(error); } },
{ BR_SPAWN_LOOPER, [&](int32_t cmd, int32_t &error) { OnSpawnThread(); } },
{ BR_FINISHED, [&](int32_t cmd, int32_t &error) { error = -ERR_TIMED_OUT; } },
{ BR_DEAD_BINDER, [&](int32_t cmd, int32_t &error) { OnBinderDied(); } },
{ BR_OK, [&](int32_t cmd, int32_t &error) { } },
{ BR_NOOP, [&](int32_t cmd, int32_t &error) { } },
{ BR_CLEAR_DEATH_NOTIFICATION_DONE, [&](int32_t cmd, int32_t &error) { OnRemoveRecipientDone(); } },
};
#ifdef CONFIG_ACTV_BINDER
bool useActvBinder_ = false;
ActvHandlerInfo *actvHandlerInfo_ = nullptr;

72
ipc/native/src/mock/source/binder_invoker.cpp
View File

@ -558,7 +558,7 @@ void BinderInvoker::GetSenderInfo(uint64_t &callerTokenID, uint64_t &firstTokenI
realPid = static_cast<pid_t>(sender.sender_pid_nr);
}
void BinderInvoker::OnTransaction(const uint8_t *buffer)
void BinderInvoker::Transaction(const uint8_t *buffer)
{
const binder_transaction_data *tr = reinterpret_cast<const binder_transaction_data *>(buffer);
auto binderAllocator = new (std::nothrow) BinderAllocator();
@ -695,6 +695,24 @@ void BinderInvoker::OnRemoveRecipientDone()
}
}
void BinderInvoker::OnSpawnThread()
{
IPCProcessSkeleton *current = IPCProcessSkeleton::GetCurrent();
if (current != nullptr) {
current->SpawnThread();
}
}
void BinderInvoker::OnTransaction(int32_t &error)
{
const uint8_t *buffer = input_.ReadBuffer(sizeof(binder_transaction_data));
if (buffer == nullptr) {
error = IPC_INVOKER_INVALID_DATA_ERR;
return;
}
Transaction(buffer);
}
int BinderInvoker::HandleReply(MessageParcel *reply)
{
const size_t readSize = sizeof(binder_transaction_data);
@ -742,52 +760,12 @@ int BinderInvoker::HandleReply(MessageParcel *reply)
int BinderInvoker::HandleCommandsInner(uint32_t cmd)
{
int error = ERR_NONE;
switch (cmd) {
case BR_ERROR:
error = input_.ReadInt32();
break;
case BR_ACQUIRE:
case BR_INCREFS:
OnAcquireObject(cmd);
break;
case BR_RELEASE:
case BR_DECREFS:
OnReleaseObject(cmd);
break;
case BR_ATTEMPT_ACQUIRE:
OnAttemptAcquire();
break;
case BR_TRANSACTION: {
const uint8_t *buffer = input_.ReadBuffer(sizeof(binder_transaction_data));
if (buffer == nullptr) {
error = IPC_INVOKER_INVALID_DATA_ERR;
break;
}
OnTransaction(buffer);
break;
}
case BR_SPAWN_LOOPER: {
IPCProcessSkeleton *current = IPCProcessSkeleton::GetCurrent();
if (current != nullptr) {
current->SpawnThread();
}
break;
}
case BR_FINISHED:
error = -ERR_TIMED_OUT;
break;
case BR_DEAD_BINDER:
OnBinderDied();
break;
case BR_CLEAR_DEATH_NOTIFICATION_DONE:
OnRemoveRecipientDone();
break;
case BR_OK:
case BR_NOOP:
break;
default:
error = IPC_INVOKER_ON_TRANSACT_ERR;
break;
auto it = commandMap_.find(cmd);
if (it != commandMap_.end()) {
it->second(cmd, error);
} else {
error = IPC_INVOKER_ON_TRANSACT_ERR;
}
return error;

6
ipc/native/test/fuzztest/mock/binderinvoker_fuzzer/binderinvoker_fuzzer.cpp
View File

@ -26,7 +26,7 @@
namespace OHOS {
void OnTransactionTest(const uint8_t* data, size_t size)
void TransactionTest(const uint8_t* data, size_t size)
{
if (data == nullptr || size < sizeof(binder_transaction_data)) {
return;
@ -38,7 +38,7 @@ namespace OHOS {
trData.target.ptr = 0;
trData.offsets_size = 0;
trData.flags = 0;
invoker->OnTransaction(reinterpret_cast<const uint8_t*>(&trData));
invoker->Transaction(reinterpret_cast<const uint8_t*>(&trData));
delete invoker;
}
}
@ -47,6 +47,6 @@ namespace OHOS {
extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
{
/* Run your code on data */
OHOS::OnTransactionTest(data, size);
OHOS::TransactionTest(data, size);
return 0;
}

513
ipc/native/test/unittest/common/ipc_capi_parcel_unittest.cpp
View File

@ -48,6 +48,7 @@ static constexpr int MAX_MEMORY_SIZE = 204800;
static constexpr int MAX_INTERFACE_TOKEN_LEN = 100;
static constexpr int TEST_PARCEL_SIZE = MAX_MEMORY_SIZE - 10;
static constexpr int TEST_PERFORMANCE_OPERATOR_COUNT = 2000;
static constexpr int TEST_PERFORMANCE_OPERATOR_GROUP = 50;
struct PerformanceResult {
uint32_t min{ 100 };
@ -65,12 +66,20 @@ public:
void TearDown();
uint32_t CalcSpendTime(TimePoint &start, TimePoint &end);
void ReadWriteStringPerformance(PerformanceResult &writeResult, PerformanceResult &readResult);
void ReadWriteStringCppPerformance(PerformanceResult &writeResult, PerformanceResult &readResult);
void ReadWriteBufferPerformance(PerformanceResult &writeResult, PerformanceResult &readResult);
void ReadWriteBufferCppPerformance(PerformanceResult &writeResult, PerformanceResult &readResult);
void ReadWriteInterfaceTokenPerformance(PerformanceResult &writeResult, PerformanceResult &readResult);
void ReadWriteInterfaceTokenCppPerformance(PerformanceResult &writeResult, PerformanceResult &readResult);
void ReadWriteString(const char *str, uint32_t &writeDuration, uint32_t &readDuration);
void ReadWriteStringCpp(const char *str, uint32_t &writeDuration, uint32_t &readDuration);
void ReadWriteStringPerformance(PerformanceResult &writeResult, PerformanceResult &readResult,
PerformanceResult &writeCppResult, PerformanceResult &readCppResult);
void ReadWriteBuffer(const uint8_t *buf, int32_t bufLength, uint32_t &writeDuration, uint32_t &readDuration);
void ReadWriteBufferCpp(const uint8_t *buf, int32_t bufLength, uint32_t &writeDuration, uint32_t &readDuration);
void ReadWriteBufferPerformance(PerformanceResult &writeResult, PerformanceResult &readResult,
PerformanceResult &writeCppResult, PerformanceResult &readCppResult);
void ReadWriteInterfaceToken(const char *token, uint32_t &writeDuration, uint32_t &readDuration);
void ReadWriteInterfaceTokenCpp(const char *token, uint32_t &writeDuration, uint32_t &readDuration);
void ReadWriteInterfaceTokenPerformance(PerformanceResult &writeResult, PerformanceResult &readResult,
PerformanceResult &writeCppResult, PerformanceResult &readCppResult);
void PerformanceStatistic(uint32_t writeAvg, uint32_t readAvg, uint32_t writeCppAvg, uint32_t readCppAvg);
static constexpr HiLogLabel LABEL = { LOG_CORE, LOG_ID_TEST, "IpcCApiUnitTest" };
};
@ -119,206 +128,234 @@ uint32_t IpcCApiParcelUnitTest::CalcSpendTime(TimePoint& start, TimePoint& end)
return static_cast<uint32_t>(std::chrono::duration_cast<std::chrono::microseconds>(duration).count());
}
void IpcCApiParcelUnitTest::ReadWriteStringPerformance(PerformanceResult &writeResult,
PerformanceResult &readResult)
void IpcCApiParcelUnitTest::PerformanceStatistic(uint32_t writeAvg, uint32_t readAvg,
uint32_t writeCppAvg, uint32_t readCppAvg)
{
char buf[TEST_PARCEL_SIZE] = {0};
EXPECT_EQ(memset_s(buf, sizeof(buf) - 1, '1', sizeof(buf) - 1), EOK);
for (int i = 0; i < TEST_PERFORMANCE_OPERATOR_COUNT; ++i) {
auto dataCParcel = OH_IPCParcel_Create();
int ret = OH_IPC_SUCCESS;
auto startPoint = std::chrono::steady_clock::now();
ret = OH_IPCParcel_WriteString(dataCParcel, buf);
auto endPoint = std::chrono::steady_clock::now();
ASSERT_EQ(ret, OH_IPC_SUCCESS);
uint32_t duration = CalcSpendTime(startPoint, endPoint);
writeResult.min = (duration > writeResult.min) ? writeResult.min : duration;
writeResult.max = (duration < writeResult.max) ? writeResult.max : duration;
writeResult.average += duration;
startPoint = std::chrono::steady_clock::now();
const char *readStr = OH_IPCParcel_ReadString(dataCParcel);
endPoint = std::chrono::steady_clock::now();
ASSERT_NE(readStr, nullptr);
EXPECT_EQ(strlen(readStr), sizeof(buf) - 1);
duration = CalcSpendTime(startPoint, endPoint);
readResult.min = (duration > readResult.min) ? readResult.min : duration;
readResult.max = (duration < readResult.max) ? readResult.max : duration;
readResult.average += duration;
OH_IPCParcel_Destroy(dataCParcel);
static constexpr uint32_t PERCENT = 100;
static constexpr uint32_t PERCENT_RANGE = 105;
static constexpr uint32_t ERROR_VALUE = 5;
std::cout << "OHIPCParcel writeAvg:" << writeAvg << "us, readAvg:" << readAvg << "us" << std::endl;
std::cout << "MessageParcel writeAvg:" << writeCppAvg << "us, readAvg:" << readCppAvg << "us" << std::endl;
if (writeCppAvg >= ERROR_VALUE) {
ASSERT_LE(writeAvg * PERCENT, writeCppAvg * PERCENT_RANGE);
} else {
ASSERT_LE(writeAvg, writeCppAvg + ERROR_VALUE);
}
if (readCppAvg >= ERROR_VALUE) {
ASSERT_LE(readAvg * PERCENT, readCppAvg * PERCENT_RANGE);
} else {
ASSERT_LE(readAvg, readCppAvg + ERROR_VALUE);
}
writeResult.average /= TEST_PERFORMANCE_OPERATOR_COUNT;
readResult.average /= TEST_PERFORMANCE_OPERATOR_COUNT;
}
void IpcCApiParcelUnitTest::ReadWriteStringCppPerformance(PerformanceResult &writeResult,
PerformanceResult &readResult)
void IpcCApiParcelUnitTest::ReadWriteString(const char *str, uint32_t &writeDuration, uint32_t &readDuration)
{
char buf[TEST_PARCEL_SIZE] = {0};
EXPECT_EQ(memset_s(buf, sizeof(buf) - 1, '1', sizeof(buf) - 1), EOK);
auto dataCParcel = OH_IPCParcel_Create();
int ret = OH_IPC_SUCCESS;
auto startPoint = std::chrono::steady_clock::now();
ret = OH_IPCParcel_WriteString(dataCParcel, str);
auto endPoint = std::chrono::steady_clock::now();
ASSERT_EQ(ret, OH_IPC_SUCCESS);
writeDuration = CalcSpendTime(startPoint, endPoint);
startPoint = std::chrono::steady_clock::now();
const char *readStr = OH_IPCParcel_ReadString(dataCParcel);
endPoint = std::chrono::steady_clock::now();
ASSERT_NE(readStr, nullptr);
EXPECT_EQ(strlen(readStr), strlen(str));
OH_IPCParcel_Destroy(dataCParcel);
readDuration = CalcSpendTime(startPoint, endPoint);
}
void IpcCApiParcelUnitTest::ReadWriteStringCpp(const char *str, uint32_t &writeDuration, uint32_t &readDuration)
{
MessageParcel dataCpp;
auto startPoint = std::chrono::steady_clock::now();
dataCpp.WriteCString(str);
auto endPoint = std::chrono::steady_clock::now();
writeDuration = CalcSpendTime(startPoint, endPoint);
startPoint = std::chrono::steady_clock::now();
const char *readStr = dataCpp.ReadCString();
endPoint = std::chrono::steady_clock::now();
ASSERT_NE(readStr, nullptr);
EXPECT_EQ(strlen(readStr), strlen(str));
readDuration = CalcSpendTime(startPoint, endPoint);
}
void IpcCApiParcelUnitTest::ReadWriteStringPerformance(PerformanceResult &writeResult,
PerformanceResult &readResult, PerformanceResult &writeCppResult, PerformanceResult &readCppResult)
{
char str[TEST_PARCEL_SIZE] = {0};
ASSERT_EQ(memset_s(str, sizeof(str) - 1, '1', sizeof(str) - 1), EOK);
for (int i = 0; i < TEST_PERFORMANCE_OPERATOR_COUNT; ++i) {
MessageParcel dataCpp;
auto startPoint = std::chrono::steady_clock::now();
dataCpp.WriteCString(buf);
auto endPoint = std::chrono::steady_clock::now();
uint32_t writeDuration = 0;
uint32_t readDuration = 0;
ReadWriteString(str, writeDuration, readDuration);
writeResult.min = (writeDuration > writeResult.min) ? writeResult.min : writeDuration;
writeResult.max = (writeDuration < writeResult.max) ? writeResult.max : writeDuration;
writeResult.average += writeDuration;
readResult.min = (readDuration > readResult.min) ? readResult.min : readDuration;
readResult.max = (readDuration < readResult.max) ? readResult.max : readDuration;
readResult.average += readDuration;
uint32_t duration = CalcSpendTime(startPoint, endPoint);
writeResult.min = (duration > writeResult.min) ? writeResult.min : duration;
writeResult.max = (duration < writeResult.max) ? writeResult.max : duration;
writeResult.average += duration;
startPoint = std::chrono::steady_clock::now();
const char* readCString = dataCpp.ReadCString();
endPoint = std::chrono::steady_clock::now();
ASSERT_NE(readCString, nullptr);
EXPECT_EQ(strlen(readCString), sizeof(buf) - 1);
duration = CalcSpendTime(startPoint, endPoint);
readResult.min = (duration > readResult.min) ? readResult.min : duration;
readResult.max = (duration < readResult.max) ? readResult.max : duration;
readResult.average += duration;
uint32_t writeCppDuration = 0;
uint32_t readCppDuration = 0;
ReadWriteStringCpp(str, writeCppDuration, readCppDuration);
writeCppResult.min = (writeCppDuration > writeCppResult.min) ? writeCppResult.min : writeCppDuration;
writeCppResult.max = (writeCppDuration < writeCppResult.max) ? writeCppResult.max : writeCppDuration;
writeCppResult.average += writeCppDuration;
readCppResult.min = (readCppDuration > readCppResult.min) ? readCppResult.min : readCppDuration;
readCppResult.max = (readCppDuration < readCppResult.max) ? readCppResult.max : readCppDuration;
readCppResult.average += readCppDuration;
}
writeResult.average /= TEST_PERFORMANCE_OPERATOR_COUNT;
readResult.average /= TEST_PERFORMANCE_OPERATOR_COUNT;
writeCppResult.average /= TEST_PERFORMANCE_OPERATOR_COUNT;
readCppResult.average /= TEST_PERFORMANCE_OPERATOR_COUNT;
}
void IpcCApiParcelUnitTest::ReadWriteBuffer(const uint8_t *buf, int32_t bufLength,
uint32_t &writeDuration, uint32_t &readDuration)
{
auto dataCParcel = OH_IPCParcel_Create();
int ret = OH_IPC_SUCCESS;
auto startPoint = std::chrono::steady_clock::now();
ret = OH_IPCParcel_WriteBuffer(dataCParcel, buf, bufLength);
auto endPoint = std::chrono::steady_clock::now();
ASSERT_EQ(ret, OH_IPC_SUCCESS);
writeDuration = CalcSpendTime(startPoint, endPoint);
startPoint = std::chrono::steady_clock::now();
const uint8_t *readBuffer = OH_IPCParcel_ReadBuffer(dataCParcel, bufLength);
endPoint = std::chrono::steady_clock::now();
ASSERT_NE(readBuffer, nullptr);
EXPECT_EQ(memcmp(readBuffer, buf, bufLength), 0);
OH_IPCParcel_Destroy(dataCParcel);
readDuration = CalcSpendTime(startPoint, endPoint);
}
void IpcCApiParcelUnitTest::ReadWriteBufferCpp(const uint8_t *buf, int32_t bufLength,
uint32_t &writeDuration, uint32_t &readDuration)
{
MessageParcel dataCpp;
auto startPoint = std::chrono::steady_clock::now();
dataCpp.WriteBuffer(buf, TEST_PARCEL_SIZE);
auto endPoint = std::chrono::steady_clock::now();
writeDuration = CalcSpendTime(startPoint, endPoint);
startPoint = std::chrono::steady_clock::now();
const uint8_t *readBuf = dataCpp.ReadBuffer(TEST_PARCEL_SIZE);
endPoint = std::chrono::steady_clock::now();
ASSERT_NE(readBuf, nullptr);
EXPECT_EQ(memcmp(readBuf, buf, bufLength), 0);
readDuration = CalcSpendTime(startPoint, endPoint);
}
void IpcCApiParcelUnitTest::ReadWriteBufferPerformance(PerformanceResult &writeResult,
PerformanceResult &readResult)
PerformanceResult &readResult, PerformanceResult &writeCppResult, PerformanceResult &readCppResult)
{
uint8_t buf[TEST_PARCEL_SIZE] = {0};
EXPECT_EQ(memset_s(buf, sizeof(buf), '2', sizeof(buf)), EOK);
ASSERT_EQ(memset_s(buf, sizeof(buf), '2', sizeof(buf)), EOK);
for (int i = 0; i < TEST_PERFORMANCE_OPERATOR_COUNT; ++i) {
auto dataCParcel = OH_IPCParcel_Create();
int ret = OH_IPC_SUCCESS;
auto startPoint = std::chrono::steady_clock::now();
ret = OH_IPCParcel_WriteBuffer(dataCParcel, buf, TEST_PARCEL_SIZE);
auto endPoint = std::chrono::steady_clock::now();
ASSERT_EQ(ret, OH_IPC_SUCCESS);
uint32_t writeDuration = 0;
uint32_t readDuration = 0;
ReadWriteBuffer(buf, TEST_PARCEL_SIZE, writeDuration, readDuration);
writeResult.min = (writeDuration > writeResult.min) ? writeResult.min : writeDuration;
writeResult.max = (writeDuration < writeResult.max) ? writeResult.max : writeDuration;
writeResult.average += writeDuration;
readResult.min = (readDuration > readResult.min) ? readResult.min : readDuration;
readResult.max = (readDuration < readResult.max) ? readResult.max : readDuration;
readResult.average += readDuration;
uint32_t duration = CalcSpendTime(startPoint, endPoint);
writeResult.min = (duration > writeResult.min) ? writeResult.min : duration;
writeResult.max = (duration < writeResult.max) ? writeResult.max : duration;
writeResult.average += duration;
startPoint = std::chrono::steady_clock::now();
const uint8_t *readBuffer = OH_IPCParcel_ReadBuffer(dataCParcel, TEST_PARCEL_SIZE);
endPoint = std::chrono::steady_clock::now();
ASSERT_NE(readBuffer, nullptr);
EXPECT_EQ(memcmp(readBuffer, buf, TEST_PARCEL_SIZE), 0);
duration = CalcSpendTime(startPoint, endPoint);
readResult.min = (duration > readResult.min) ? readResult.min : duration;
readResult.max = (duration < readResult.max) ? readResult.max : duration;
readResult.average += duration;
OH_IPCParcel_Destroy(dataCParcel);
uint32_t writeCppDuration = 0;
uint32_t readCppDuration = 0;
ReadWriteBufferCpp(buf, TEST_PARCEL_SIZE, writeCppDuration, readCppDuration);
writeCppResult.min = (writeCppDuration > writeCppResult.min) ? writeCppResult.min : writeCppDuration;
writeCppResult.max = (writeCppDuration < writeCppResult.max) ? writeCppResult.max : writeCppDuration;
writeCppResult.average += writeCppDuration;
readCppResult.min = (readCppDuration > readCppResult.min) ? readCppResult.min : readCppDuration;
readCppResult.max = (readCppDuration < readCppResult.max) ? readCppResult.max : readCppDuration;
readCppResult.average += readCppDuration;
}
writeResult.average /= TEST_PERFORMANCE_OPERATOR_COUNT;
readResult.average /= TEST_PERFORMANCE_OPERATOR_COUNT;
writeCppResult.average /= TEST_PERFORMANCE_OPERATOR_COUNT;
readCppResult.average /= TEST_PERFORMANCE_OPERATOR_COUNT;
}
void IpcCApiParcelUnitTest::ReadWriteBufferCppPerformance(PerformanceResult &writeResult,
PerformanceResult &readResult)
void IpcCApiParcelUnitTest::ReadWriteInterfaceToken(const char *token,
uint32_t &writeDuration, uint32_t &readDuration)
{
uint8_t buf[TEST_PARCEL_SIZE] = {0};
EXPECT_EQ(memset_s(buf, sizeof(buf), '2', sizeof(buf)), EOK);
for (int i = 0; i < TEST_PERFORMANCE_OPERATOR_COUNT; ++i) {
MessageParcel dataCpp;
auto startPoint = std::chrono::steady_clock::now();
dataCpp.WriteBuffer(buf, TEST_PARCEL_SIZE);
auto endPoint = std::chrono::steady_clock::now();
auto dataCParcel = OH_IPCParcel_Create();
int ret = OH_IPC_SUCCESS;
auto startPoint = std::chrono::steady_clock::now();
ret = OH_IPCParcel_WriteInterfaceToken(dataCParcel, token);
auto endPoint = std::chrono::steady_clock::now();
ASSERT_EQ(ret, OH_IPC_SUCCESS);
writeDuration = CalcSpendTime(startPoint, endPoint);
uint32_t duration = CalcSpendTime(startPoint, endPoint);
writeResult.min = (duration > writeResult.min) ? writeResult.min : duration;
writeResult.max = (duration < writeResult.max) ? writeResult.max : duration;
writeResult.average += duration;
int readLen = 0;
char *readInterfaceToken = nullptr;
startPoint = std::chrono::steady_clock::now();
ret = OH_IPCParcel_ReadInterfaceToken(dataCParcel, &readInterfaceToken, &readLen, LocalMemAllocator);
endPoint = std::chrono::steady_clock::now();
EXPECT_EQ(strcmp(token, readInterfaceToken), 0);
EXPECT_EQ(readLen, strlen(token) + 1);
free(readInterfaceToken);
OH_IPCParcel_Destroy(dataCParcel);
readDuration = CalcSpendTime(startPoint, endPoint);
}
startPoint = std::chrono::steady_clock::now();
const uint8_t* readBuf = dataCpp.ReadBuffer(TEST_PARCEL_SIZE);
endPoint = std::chrono::steady_clock::now();
ASSERT_NE(readBuf, nullptr);
EXPECT_EQ(memcmp(readBuf, buf, TEST_PARCEL_SIZE), 0);
void IpcCApiParcelUnitTest::ReadWriteInterfaceTokenCpp(const char *token,
uint32_t &writeDuration, uint32_t &readDuration)
{
MessageParcel dataCpp;
auto startPoint = std::chrono::steady_clock::now();
auto u16Token = OHOS::Str8ToStr16(token);
dataCpp.WriteInterfaceToken(u16Token.c_str());
auto endPoint = std::chrono::steady_clock::now();
writeDuration = CalcSpendTime(startPoint, endPoint);
duration = CalcSpendTime(startPoint, endPoint);
readResult.min = (duration > readResult.min) ? readResult.min : duration;
readResult.max = (duration < readResult.max) ? readResult.max : duration;
readResult.average += duration;
}
writeResult.average /= TEST_PERFORMANCE_OPERATOR_COUNT;
readResult.average /= TEST_PERFORMANCE_OPERATOR_COUNT;
startPoint = std::chrono::steady_clock::now();
auto u16TokenRead = dataCpp.ReadInterfaceToken();
std::string strTokenRead = OHOS::Str16ToStr8(u16TokenRead);
endPoint = std::chrono::steady_clock::now();
EXPECT_EQ(strTokenRead.length(), strlen(token));
EXPECT_EQ(strTokenRead.compare(token), 0);
readDuration = CalcSpendTime(startPoint, endPoint);
}
void IpcCApiParcelUnitTest::ReadWriteInterfaceTokenPerformance(PerformanceResult &writeResult,
PerformanceResult &readResult)
PerformanceResult &readResult, PerformanceResult &writeCppResult, PerformanceResult &readCppResult)
{
char token[MAX_INTERFACE_TOKEN_LEN] = {0};
EXPECT_EQ(memset_s(token, sizeof(token) - 1, '1', sizeof(token) - 1), EOK);
ASSERT_EQ(memset_s(token, sizeof(token) - 1, '1', sizeof(token) - 1), EOK);
for (int i = 0; i < TEST_PERFORMANCE_OPERATOR_COUNT; ++i) {
auto dataCParcel = OH_IPCParcel_Create();
int ret = OH_IPC_SUCCESS;
auto startPoint = std::chrono::steady_clock::now();
ret = OH_IPCParcel_WriteInterfaceToken(dataCParcel, token);
auto endPoint = std::chrono::steady_clock::now();
ASSERT_EQ(ret, OH_IPC_SUCCESS);
uint32_t writeDuration = 0;
uint32_t readDuration = 0;
ReadWriteInterfaceToken(token, writeDuration, readDuration);
writeResult.min = (writeDuration > writeResult.min) ? writeResult.min : writeDuration;
writeResult.max = (writeDuration < writeResult.max) ? writeResult.max : writeDuration;
writeResult.average += writeDuration;
readResult.min = (readDuration > readResult.min) ? readResult.min : readDuration;
readResult.max = (readDuration < readResult.max) ? readResult.max : readDuration;
readResult.average += readDuration;
uint32_t duration = CalcSpendTime(startPoint, endPoint);
writeResult.min = (duration > writeResult.min) ? writeResult.min : duration;
writeResult.max = (duration < writeResult.max) ? writeResult.max : duration;
writeResult.average += duration;
int readLen = 0;
char *readInterfaceToken = nullptr;
startPoint = std::chrono::steady_clock::now();
ret = OH_IPCParcel_ReadInterfaceToken(dataCParcel, &readInterfaceToken, &readLen, LocalMemAllocator);
endPoint = std::chrono::steady_clock::now();
EXPECT_EQ(strcmp(token, readInterfaceToken), 0);
EXPECT_EQ(readLen, MAX_INTERFACE_TOKEN_LEN);
duration = CalcSpendTime(startPoint, endPoint);
readResult.min = (duration > readResult.min) ? readResult.min : duration;
readResult.max = (duration < readResult.max) ? readResult.max : duration;
readResult.average += duration;
OH_IPCParcel_Destroy(dataCParcel);
}
writeResult.average /= TEST_PERFORMANCE_OPERATOR_COUNT;
readResult.average /= TEST_PERFORMANCE_OPERATOR_COUNT;
}
void IpcCApiParcelUnitTest::ReadWriteInterfaceTokenCppPerformance(PerformanceResult &writeResult,
PerformanceResult &readResult)
{
char token[MAX_INTERFACE_TOKEN_LEN] = {0};
EXPECT_EQ(memset_s(token, sizeof(token) - 1, '1', sizeof(token) - 1), EOK);
for (int i = 0; i < TEST_PERFORMANCE_OPERATOR_COUNT; ++i) {
MessageParcel dataCpp;
auto startPoint = std::chrono::steady_clock::now();
auto u16Token = OHOS::Str8ToStr16(token);
dataCpp.WriteInterfaceToken(u16Token.c_str());
auto endPoint = std::chrono::steady_clock::now();
uint32_t duration = CalcSpendTime(startPoint, endPoint);
writeResult.min = (duration > writeResult.min) ? writeResult.min : duration;
writeResult.max = (duration < writeResult.max) ? writeResult.max : duration;
writeResult.average += duration;
startPoint = std::chrono::steady_clock::now();
auto u16TokenRead = dataCpp.ReadInterfaceToken();
std::string strTokenRead = OHOS::Str16ToStr8(u16TokenRead);
endPoint = std::chrono::steady_clock::now();
EXPECT_EQ(strTokenRead.length(), MAX_INTERFACE_TOKEN_LEN - 1);
EXPECT_EQ(strTokenRead.compare(token), 0);
duration = CalcSpendTime(startPoint, endPoint);
readResult.min = (duration > readResult.min) ? readResult.min : duration;
readResult.max = (duration < readResult.max) ? readResult.max : duration;
readResult.average += duration;
uint32_t writeCppDuration = 0;
uint32_t readCppDuration = 0;
ReadWriteInterfaceTokenCpp(token, writeCppDuration, readCppDuration);
writeCppResult.min = (writeCppDuration > writeCppResult.min) ? writeCppResult.min : writeCppDuration;
writeCppResult.max = (writeCppDuration < writeCppResult.max) ? writeCppResult.max : writeCppDuration;
writeCppResult.average += writeCppDuration;
readCppResult.min = (readCppDuration > readCppResult.min) ? readCppResult.min : readCppDuration;
readCppResult.max = (readCppDuration < readCppResult.max) ? readCppResult.max : readCppDuration;
readCppResult.average += readCppDuration;
}
writeResult.average /= TEST_PERFORMANCE_OPERATOR_COUNT;
readResult.average /= TEST_PERFORMANCE_OPERATOR_COUNT;
writeCppResult.average /= TEST_PERFORMANCE_OPERATOR_COUNT;
readCppResult.average /= TEST_PERFORMANCE_OPERATOR_COUNT;
}
HWTEST_F(IpcCApiParcelUnitTest, OH_IPCParcel_Create_001, TestSize.Level1)
@ -764,64 +801,108 @@ HWTEST_F(IpcCApiParcelUnitTest, OH_IPCParcel_TestReadWriteInterfaceToken_001, Te
HWTEST_F(IpcCApiParcelUnitTest, OH_IPCParcel_TestReadWriteStringPerformance_001, TestSize.Level1)
{
PerformanceResult writeResult;
PerformanceResult readResult;
ReadWriteStringPerformance(writeResult, readResult);
uint32_t writeAvg = 0;
uint32_t readAvg = 0;
uint32_t writeCppAvg = 0;
uint32_t readCppAvg = 0;
for (int i = 0; i < TEST_PERFORMANCE_OPERATOR_GROUP; ++i) {
PerformanceResult writeResult;
PerformanceResult readResult;
PerformanceResult writeCppResult;
PerformanceResult readCppResult;
ReadWriteStringPerformance(writeResult, readResult, writeCppResult, readCppResult);
PerformanceResult writeCppResult;
PerformanceResult readCppResult;
ReadWriteStringCppPerformance(writeCppResult, readCppResult);
writeAvg += writeResult.average;
readAvg += readResult.average;
writeCppAvg += writeCppResult.average;
readCppAvg += readCppResult.average;
std::cout << "Test String len:" << TEST_PARCEL_SIZE << ", count:" << TEST_PERFORMANCE_OPERATOR_COUNT << std::endl;
std::cout << "OHIPCParcel WriteCString spend:[min:" << writeResult.min << ", max:" << writeResult.max
<< ", avg:" << writeResult.average << "]us" << std::endl;
std::cout << "MessageParcel WriteCString spend:[min:" << writeCppResult.min << ", max:" << writeCppResult.max
<< ", avg:" << writeCppResult.average << "]us" << std::endl;
std::cout << "OHIPCParcel ReadCString spend:[min:" << readResult.min << ", max:" << readResult.max
<< ", avg:" << readResult.average << "]us" << std::endl;
std::cout << "MessageParcel ReadCString spend:[min:" << readCppResult.min << ", max:" << readCppResult.max
<< ", avg:" << readCppResult.average << "]us" << std::endl;
std::cout << "Test String len:" << TEST_PARCEL_SIZE << ", count:"
<< TEST_PERFORMANCE_OPERATOR_COUNT << std::endl;
std::cout << "OHIPCParcel WriteCString spend:[min:" << writeResult.min << ", max:" << writeResult.max
<< ", avg:" << writeResult.average << "]us" << std::endl;
std::cout << "MessageParcel WriteCString spend:[min:" << writeCppResult.min << ", max:" << writeCppResult.max
<< ", avg:" << writeCppResult.average << "]us" << std::endl;
std::cout << "OHIPCParcel ReadCString spend:[min:" << readResult.min << ", max:" << readResult.max
<< ", avg:" << readResult.average << "]us" << std::endl;
std::cout << "MessageParcel ReadCString spend:[min:" << readCppResult.min << ", max:" << readCppResult.max
<< ", avg:" << readCppResult.average << "]us" << std::endl;
}
writeAvg /= TEST_PERFORMANCE_OPERATOR_GROUP;
readAvg /= TEST_PERFORMANCE_OPERATOR_GROUP;
writeCppAvg /= TEST_PERFORMANCE_OPERATOR_GROUP;
readCppAvg /= TEST_PERFORMANCE_OPERATOR_GROUP;
PerformanceStatistic(writeAvg, readAvg, writeCppAvg, readCppAvg);
}
HWTEST_F(IpcCApiParcelUnitTest, OH_IPCParcel_TestReadWriteBufferPerformance_001, TestSize.Level1)
{
PerformanceResult writeResult;
PerformanceResult readResult;
ReadWriteBufferPerformance(writeResult, readResult);
uint32_t writeAvg = 0;
uint32_t readAvg = 0;
uint32_t writeCppAvg = 0;
uint32_t readCppAvg = 0;
for (int i = 0; i < TEST_PERFORMANCE_OPERATOR_GROUP; ++i) {
PerformanceResult writeResult;
PerformanceResult readResult;
PerformanceResult writeCppResult;
PerformanceResult readCppResult;
ReadWriteBufferPerformance(writeResult, readResult, writeCppResult, readCppResult);
PerformanceResult writeCppResult;
PerformanceResult readCppResult;
ReadWriteBufferCppPerformance(writeCppResult, readCppResult);
writeAvg += writeResult.average;
readAvg += readResult.average;
writeCppAvg += writeCppResult.average;
readCppAvg += readCppResult.average;
std::cout << "Test Buffer len:" << TEST_PARCEL_SIZE << ", count:" << TEST_PERFORMANCE_OPERATOR_COUNT << std::endl;
std::cout << "OHIPCParcel WriteBuffer spend:[min:" << writeResult.min << ", max:" << writeResult.max
<< ", avg:" << writeResult.average << "]us" << std::endl;
std::cout << "MessageParcel WriteBuffer spend:[min:" << writeCppResult.min << ", max:" << writeCppResult.max
<< ", avg:" << writeCppResult.average << "]us" << std::endl;
std::cout << "OHIPCParcel ReadBuffer spend:[min:" << readResult.min << ", max:" << readResult.max
<< ", avg:" << readResult.average << "]us" << std::endl;
std::cout << "MessageParcel ReadBuffer spend:[min:" << readCppResult.min << ", max:" << readCppResult.max
<< ", avg:" << readCppResult.average << "]us" << std::endl;
std::cout << "Test Buffer len:" << TEST_PARCEL_SIZE << ", count:"
<< TEST_PERFORMANCE_OPERATOR_COUNT << std::endl;
std::cout << "OHIPCParcel WriteBuffer spend:[min:" << writeResult.min << ", max:" << writeResult.max
<< ", avg:" << writeResult.average << "]us" << std::endl;
std::cout << "MessageParcel WriteBuffer spend:[min:" << writeCppResult.min << ", max:" << writeCppResult.max
<< ", avg:" << writeCppResult.average << "]us" << std::endl;
std::cout << "OHIPCParcel ReadBuffer spend:[min:" << readResult.min << ", max:" << readResult.max
<< ", avg:" << readResult.average << "]us" << std::endl;
std::cout << "MessageParcel ReadBuffer spend:[min:" << readCppResult.min << ", max:" << readCppResult.max
<< ", avg:" << readCppResult.average << "]us" << std::endl;
}
writeAvg /= TEST_PERFORMANCE_OPERATOR_GROUP;
readAvg /= TEST_PERFORMANCE_OPERATOR_GROUP;
writeCppAvg /= TEST_PERFORMANCE_OPERATOR_GROUP;
readCppAvg /= TEST_PERFORMANCE_OPERATOR_GROUP;
PerformanceStatistic(writeAvg, readAvg, writeCppAvg, readCppAvg);
}
HWTEST_F(IpcCApiParcelUnitTest, OH_IPCParcel_TestReadWriteInterfaceTokenPerformance_001, TestSize.Level1)
{
PerformanceResult writeResult;
PerformanceResult readResult;
ReadWriteInterfaceTokenPerformance(writeResult, readResult);
uint32_t writeAvg = 0;
uint32_t readAvg = 0;
uint32_t writeCppAvg = 0;
uint32_t readCppAvg = 0;
for (int i = 0; i < TEST_PERFORMANCE_OPERATOR_GROUP; ++i) {
PerformanceResult writeResult;
PerformanceResult readResult;
PerformanceResult writeCppResult;
PerformanceResult readCppResult;
ReadWriteInterfaceTokenPerformance(writeResult, readResult, writeCppResult, readCppResult);
PerformanceResult writeCppResult;
PerformanceResult readCppResult;
ReadWriteInterfaceTokenCppPerformance(writeCppResult, readCppResult);
writeAvg += writeResult.average;
readAvg += readResult.average;
writeCppAvg += writeCppResult.average;
readCppAvg += readCppResult.average;
std::cout << "Test token len:" << MAX_INTERFACE_TOKEN_LEN << ", count:"
<< TEST_PERFORMANCE_OPERATOR_COUNT << std::endl;
std::cout << "OHIPCParcel WriteInterfaceToken spend:[min:" << writeResult.min << ", max:"
<< writeResult.max << ", avg:" << writeResult.average << "]us" << std::endl;
std::cout << "MessageParcel WriteInterfaceToken spend:[min:" << writeCppResult.min
<< ", max:" << writeCppResult.max << ", avg:" << writeCppResult.average << "]us" << std::endl;
std::cout << "OHIPCParcel ReadInterfaceToken spend:[min:" << readResult.min << ", max:"
<< readResult.max << ", avg:" << readResult.average << "]us" << std::endl;
std::cout << "MessageParcel ReadInterfaceToken spend:[min:" << readCppResult.min << ", max:"
<< readCppResult.max << ", avg:" << readCppResult.average << "]us" << std::endl;
std::cout << "Test token len:" << MAX_INTERFACE_TOKEN_LEN << ", count:"
<< TEST_PERFORMANCE_OPERATOR_COUNT << std::endl;
std::cout << "OHIPCParcel WriteInterfaceToken spend:[min:" << writeResult.min << ", max:"
<< writeResult.max << ", avg:" << writeResult.average << "]us" << std::endl;
std::cout << "MessageParcel WriteInterfaceToken spend:[min:" << writeCppResult.min
<< ", max:" << writeCppResult.max << ", avg:" << writeCppResult.average << "]us" << std::endl;
std::cout << "OHIPCParcel ReadInterfaceToken spend:[min:" << readResult.min << ", max:"
<< readResult.max << ", avg:" << readResult.average << "]us" << std::endl;
std::cout << "MessageParcel ReadInterfaceToken spend:[min:" << readCppResult.min << ", max:"
<< readCppResult.max << ", avg:" << readCppResult.average << "]us" << std::endl;
}
writeAvg /= TEST_PERFORMANCE_OPERATOR_GROUP;
readAvg /= TEST_PERFORMANCE_OPERATOR_GROUP;
writeCppAvg /= TEST_PERFORMANCE_OPERATOR_GROUP;
readCppAvg /= TEST_PERFORMANCE_OPERATOR_GROUP;
PerformanceStatistic(writeAvg, readAvg, writeCppAvg, readCppAvg);
}

4
ipc/test/auxiliary/native/include/test_capi_skeleton.h
View File

@ -88,8 +88,8 @@ private:
std::random_device randomDevice_;
std::uniform_int_distribution<> randomDistribution_{ 1, 10000 };
OHIPCRemoteProxy* proxy_{ nullptr };
OHIPCRemoteStub* stubCallBack_{ nullptr };
OHIPCRemoteProxy *proxy_{ nullptr };
OHIPCRemoteStub *stubCallBack_{ nullptr };
};
class NativeRemoteStubTest : public NativeRemoteBase {

2
ipc/test/auxiliary/native/src/main_client.cpp
View File

@ -143,6 +143,6 @@ void SignalHandler(int signum)
}
if (signum == SIGINT) {
ZLOGD(LABEL, "SIGINT");
exit(1);
IPCSkeleton::StopWorkThread();
}
}