高通平台学习二

发布时间：2024年01月23日

2、QMI api可分为五大类

2.1 回调函数原型

2.1.1qmi_client_notify_cb()

void *qmi_client_notify_cb
(
qmi_client_type user_handle,
qmi_idl_service_object_type service_obj,
qmi_client_notify_event_type service_event,
void *notify_cb_data
);
这段代码是一个回调函数，用于处理QMI（Qualcomm MSM Interface）Common Client Interface（QCCI）基础设施的服务事件通知。以下是对函数参数的解释：

user_handle（用户句柄）： 表示客户端的句柄，用于标识客户端。
service_obj（服务对象）： 表示服务对象的类型。这通常是一个由QMI IDL（Interface Definition Language）生成的服务对象。
service_event（服务事件）： 通知客户端服务数量是否发生变化的事件。可能的值有：
- QMI_CLIENT_SERVICE_COUNT_INC：表示服务数量增加。
- QMI_CLIENT_SERVICE_COUNT_DEC：表示服务数量减少。
notify_cb_data（通知回调数据）： 是在调用qmi_client_register_notify_cb时传递给该回调函数的用户数据。

该回调函数被设计用于处理当相关服务的数量发生变化时触发的事件。在函数体内，你可以根据service_event的值执行相应的操作，以适应服务数量的增加或减少。

2.1.2 qmi_client_recv_raw_msg_async_cb()

void *qmi_client_recv_raw_msg_async_cb
(
qmi_client_type user_handle,
unsigned int msg_id,
void *resp_buf,
unsigned int resp_buf_len,
void *resp_cb_data,
qmi_client_error_type transp_err
);
这段代码是用于处理在使用qmi_client_send_raw_msg_async()发送请求后，通过QCCI（QMI Common Client Interface）基础设施接收到响应时调用的回调函数。以下是对函数参数的解释：

user_handle（用户句柄）： 由基础设施使用的句柄，用于标识不同的客户端。
msg_id（消息ID）： 表示接收到的响应消息的ID。
resp_buf（响应缓冲区指针）： 指向编码的QMI消息的指针，需要由客户端使用qmi_client_message_decode函数进行解码。
resp_buf_len（响应缓冲区长度）： 表示响应消息的长度。
resp_cb_data（响应回调数据）： 是在发起异步请求时传递给qmi_client_send_raw_msg_async的用户数据。
transp_err（传输错误）： 表示传输过程中是否发生错误的错误代码。QMI_NO_ERR表示成功，其他值表示从服务接收消息时发生了问题。

该回调函数的目的是在接收到异步请求的响应时执行相应的操作。在函数体内，你可以根据transp_err的值判断传输是否成功，并进一步处理响应消息（例如解码）。

如果需要"qmi_client_message_decode"函数的中文解释或其他相关信息，请提供相关代码片段。

2.1.3 qmi_client_recv_msg_async_cb()

void *qmi_client_recv_msg_async_cb
(
qmi_client_type user_handle,
unsigned int msg_id,
void *resp_c_struct,
unsigned int resp_c_struct_len,
void *resp_cb_data,
qmi_client_error_type transp_err
);
这段代码是用于处理在使用qmi_client_send_msg_async()发送请求后，通过QCCI（QMI Common Client Interface）基础设施接收到响应时调用的回调函数。以下是对函数参数的解释：

user_handle（用户句柄）： 由基础设施使用的句柄，用于标识不同的客户端。
msg_id（消息ID）： 表示接收到的响应消息的ID。
resp_c_struct（响应结构体指针）： 指向包含响应数据的结构体指针。这是由QMI IDL生成的C结构体，用于存储解码后的响应信息。
resp_c_struct_len（响应结构体长度）： 表示响应结构体的长度。
resp_cb_data（响应回调数据）： 是在发起异步请求时传递给qmi_client_send_msg_async的用户数据。
transp_err（传输错误）： 表示传输过程中是否发生错误的错误代码。QMI_NO_ERR表示成功，其他值表示从服务接收或解码消息时发生了问题。

该回调函数的目的是在接收到异步请求的响应时执行相应的操作。在函数体内，你可以根据transp_err的值判断传输是否成功，并进一步处理响应消息（例如解码存储在resp_c_struct中的数据）。

需要注意的是，这里使用的是qmi_client_send_msg_async()而不是前一个例子中的qmi_client_send_raw_msg_async()，因此处理的是QMI消息的C结构体而不是原始编码的消息。

总的来说，qmi_client_recv_raw_msg_async_cb()更关注原始的QMI消息，需要客户端进行手动解码，而qmi_client_recv_msg_async_cb()提供了更高级的抽象，直接使用QMI IDL生成的结构体来表示响应数据，简化了客户端的操作。选择使用哪个函数取决于客户端对消息处理的需求和偏好。

2.1.4qmi_client_ind_cb()

void *qmi_client_recv_raw_msg_async_cb
(
qmi_client_type user_handle,
unsigned int msg_id,
void *ind_buf,
unsigned int ind_buf_len,
void *resp_cb_data
);
这段代码是用于处理在接收到QCCI（QMI Common Client Interface）基础设施发送的指示（Indication）时调用的回调函数。以下是对函数参数的解释：

user_handle（用户句柄）： 由基础设施使用的句柄，用于标识不同的客户端。
msg_id（消息ID）： 表示接收到的指示消息的ID。
ind_buf（指示缓冲区指针）： 指向编码的QMI消息的指针，需要由客户端使用qmi_client_message_decode函数进行解码。
ind_buf_len（指示缓冲区长度）： 表示指示消息的长度。
resp_cb_data（响应回调数据）： 是在注册回调函数时传递给QCCI的用户数据。

这个回调函数的目的是在接收到QMI指示时执行相应的操作。与前面提到的异步响应回调函数类似，客户端需要使用qmi_client_message_decode函数对ind_buf进行解码以获取指示的内容。

总体而言，该函数用于处理从服务端发来的指示消息，允许客户端在收到指示时执行特定的操作。

2.1.5qmi_client_error_cb()

void *qmi_client_error_cb
(
qmi_client_type user_handle,
qmi_client_error_type error,
void *err_cb_data
);
这段代码是用于处理在服务终止或取消注册时由QCCI（QMI Common Client Interface）基础设施调用的回调函数。该回调函数是通过qmi_client_register_error_cb函数注册的。当服务终止或取消注册时，客户端应该调用qmi_client_release()，因为其当前对服务的句柄已不再有效，客户端需要在服务重新启动时重新初始化。

以下是对函数参数的解释：

user_handle（用户句柄）： 由基础设施使用的句柄，用于标识不同的客户端。
error（错误值）： 表示服务终止或取消注册时的错误值。
err_cb_data（错误回调数据）： 是在注册回调函数时传递给QCCI的用户数据。

该回调函数的目的是在服务终止或取消注册时执行相应的操作。当收到此回调时，客户端可以根据错误值执行一些清理操作，然后调用qmi_client_release()释放当前的服务句柄。

总体而言，该函数用于处理服务终止或取消注册时的情况，以确保客户端在这种情况下能够进行适当的清理和处理。

2.1.6qmi_client_release_cb()

void *qmi_client_release_cb
(
void *release_cb_data
);
这段代码是用于处理在通过qmi_client_release_async()调用释放连接后，由QCCI（QMI Common Client Interface）基础设施调用的回调函数。以下是对函数参数的解释：

release_cb_data（释放回调数据）： 是在调用qmi_client_release_async()时提供的Cookie（标识符），在回调函数中用于识别并关联释放的连接。

该回调函数的目的是在连接完全释放后执行相应的操作。当客户端通过异步方式释放连接时，QCCI基础设施会调用此回调函数，以通知客户端连接已成功释放。

总的来说，该函数用于处理在异步释放连接后的清理工作，可以根据需要执行一些额外的操作。

2.2接入接口

2.2.1qmi_client_notifier_init()

extern qmi_client_error_type
qmi_client_notifier_init
(
qmi_idl_service_object_type service_obj,
qmi_client_os_params *os_params,
qmi_client_type *user_handle
);
这段代码是用于初始化带有服务对象的通知器的函数。当支持service_obj的服务进入或退出系统时，设置在os_params中指定的信号或事件对象。os_params 的内存必须在从函数返回的 user_handle 的生命周期内有效。如果 os_params 是在栈上声明的，那么在返回之前必须通过 qmi_client_release 函数释放 user_handle。

以下是对函数参数的解释：

service_obj（服务对象）： 表示服务的对象，通常是由QMI IDL生成的服务对象。
os_params（OS特定参数）： 包含与操作系统相关的参数，可以是指向事件对象的指针，或者是信号掩码和任务控制块（TCB）。
user_handle（用户句柄）： 由基础设施使用的句柄，用于标识不同的客户端。

该函数的目的是初始化具有服务对象的通知器，当支持service_obj的服务进入或退出系统时，将设置指定的信号或事件对象。这使得客户端能够感知系统中服务的变化，并采取相应的操作。

以下是一个简单的例子，演示如何使用qmi_client_notifier_init函数：

#include <qmi_idl_lib.h>

// 假设存在一个服务对象
extern const struct qmi_idl_service_object_type my_qmi_service_object;

// 初始化通知器
void initNotifier() {
    qmi_client_type user_handle;
    qmi_client_error_type result;

    // 初始化通知器
    result = qmi_client_notifier_init(my_qmi_service_object, os_params, &user_handle);

    if (result == QMI_NO_ERR) {
        // 成功初始化通知器
        // 可以使用 user_handle 进行相应的操作
    } else {
        // 处理通知器初始化失败的情况
    }
}

int main() {
    // 在主函数中调用初始化通知器的函数
    initNotifier();

    return 0;
}

在这个例子中，my_qmi_service_object 是由QMI IDL生成的服务对象。initNotifier 函数调用了 qmi_client_notifier_init 来初始化通知器，并返回一个用于标识客户端的句柄。您需要根据实际情况提供服务对象、OS特定参数等参数。

2.2.2qmi_client_init()

extern qmi_client_error_type
qmi_client_init
(
qmi_service_info *service_info,
qmi_idl_service_object_type service_obj,
qmi_client_ind_cb ind_cb,
void *ind_cb_data,
qmi_client_os_params *os_params,
qmi_client_type *user_handle
);
这段代码是用于初始化到服务的连接的函数。该函数返回一个有效的user_handle，允许客户端与服务进行通信。然而，在发送第一个请求消息之前，服务并不知道客户端的存在。os_params 的内存必须在从函数返回的 user_handle 的生命周期内有效。如果 os_params 是在栈上声明的，那么在返回之前必须通过 qmi_client_release 函数释放 user_handle。

以下是对函数参数的解释：

service_info（服务信息指针）： 指向由 qmi_client_get_service_list() 返回的 service_info 数组中的一个条目的指针。
service_obj（服务对象）： 表示服务的对象，通常是由QMI IDL生成的服务对象。
ind_cb（指示回调函数）： 指向指示回调函数的指针，用于处理接收到的指示消息。
ind_cb_data（指示回调用户数据）： 传递给指示回调函数的用户数据。
os_params（OS特定参数）： 包含与操作系统相关的参数，可以是指向事件对象的指针，或者是信号掩码和TCB。
user_handle（用户句柄）： 由基础设施使用的句柄，用于标识不同的客户端。

该函数的目的是初始化到服务的连接，并返回用于标识客户端的句柄。它为客户端提供了一个有效的user_handle，使其能够与服务进行通信。但请注意，服务直到发送第一个请求消息之前并不知道客户端的存在。

以下是一个简单的例子，演示如何使用qmi_client_init函数：

#include <qmi_idl_lib.h>

// 假设存在一个服务对象
extern const struct qmi_idl_service_object_type my_qmi_service_object;

// 初始化到服务的连接
void initServiceConnection() {
    qmi_client_type user_handle;
    qmi_service_info service_info;  // 假设是由 qmi_client_get_service_list 返回的一个服务信息

    // 初始化到服务的连接
    qmi_client_error_type result = qmi_client_init(
        &service_info, my_qmi_service_object, ind_cb, ind_cb_data, os_params, &user_handle);

    if (result == QMI_NO_ERR) {
        // 成功初始化连接
        // 可以使用 user_handle 进行相应的操作
    } else {
        // 处理连接初始化失败的情况
    }
}

int main() {
    // 在主函数中调用初始化连接的函数
    initServiceConnection();

    return 0;
}

在这个例子中，my_qmi_service_object 是由QMI IDL生成的服务对象。initServiceConnection 函数调用了 qmi_client_init 来初始化到服务的连接，并返回一个用于标识客户端的句柄。您需要根据实际情况提供服务信息、指示回调函数、OS特定参数等参数。

2.2.3qmi_client_init_instance()

extern qmi_client_error_type
qmi_client_init_instance
(
qmi_idl_service_object_type service_obj,
qmi_service_instance instance_id,
qmi_client_ind_cb ind_cb,
void *ind_cb_data,
qmi_client_os_params *os_params,
uint32_t timeout,
qmi_client_type *user_handle
);
这段代码是用于初始化到具有特定实例ID的服务的连接的阻塞辅助函数。该函数处理查找和连接初始化到具有特定实例ID的服务的操作。它在内部调用了qmi_client_get_service_list()和qmi_client_init()，并在服务尚未启动时可能创建一个通知客户端。如果未找到所需实例ID的服务，该函数在超时之前可能会阻塞，并返回QMI_TIMEOUT_ERR。

以下是对函数参数的解释：

service_obj（服务对象）： 表示服务的对象，通常是由QMI IDL生成的服务对象。
instance_id（服务实例ID）： 表示服务的特定实例ID，用于标识不同的服务实例。
ind_cb（指示回调函数）： 指向指示回调函数的指针，用于处理接收到的指示消息。
ind_cb_data（指示回调用户数据）： 传递给指示回调函数的用户数据。
os_params（OS特定参数）： 包含与操作系统相关的参数，可以是指向事件对象的指针，或者是信号掩码和TCB。
timeout（超时时间）： 超时时间，以毫秒为单位。如果设置为0，表示没有超时。
user_handle（用户句柄）： 由基础设施使用的句柄，用于标识不同的客户端。

该函数的目的是在给定的实例ID下初始化连接，并返回用于标识客户端的句柄。它处理了查找服务、初始化连接的过程，同时考虑到可能的超时情况。

以下是一个简单的例子，演示如何使用qmi_client_init_instance函数：

#include <qmi_idl_lib.h>

// 假设存在一个服务对象
extern const struct qmi_idl_service_object_type my_qmi_service_object;

// 初始化到具有特定实例ID的服务的连接
void initServiceConnection() {
    qmi_client_type user_handle;
    qmi_client_error_type result;

    // 初始化到具有特定实例ID的服务的连接
    result = qmi_client_init_instance(
        my_qmi_service_object, instance_id, ind_cb, ind_cb_data, os_params, timeout, &user_handle);

    if (result == QMI_NO_ERR) {
        // 成功初始化连接
        // 可以使用 user_handle 进行相应的操作
    } else {
        // 处理连接初始化失败的情况
    }
}

int main() {
    // 在主函数中调用初始化连接的函数
    initServiceConnection();

    return 0;
}

在这个例子中，my_qmi_service_object 是由QMI IDL生成的服务对象。initServiceConnection 函数调用了 qmi_client_init_instance 来初始化到具有特定实例ID的服务的连接，并返回一个用于标识客户端的句柄。您需要根据实际情况提供实例ID、指示回调函数、超时时间等参数。

2.2.4qmi_client_get_service_list()

qmi_client_error_type
qmi_client_get_service_list
(
qmi_idl_service_object_type service_obj,
qmi_service_info *service_info_array,
uint32_t *num_entries,
uint32_t *num_services
);
这段代码是用于根据提供的服务对象（service_obj）检索与之对应的服务列表的函数。以下是对函数参数的解释：

service_obj（服务对象）： 表示服务的对象，通常是由QMI IDL生成的服务对象。
service_info_array（服务信息数组指针）： 用于存储获取到的服务信息的数组指针。这个数组将被填充以包含相应的服务信息。
num_entries（数组条目数）： 作为输入，表示数组的大小（条目数）。作为输出，表示实际被填充的数组条目数。
num_services（已知服务数量指针）： 用于存储已知服务的数量。如果 num_services 大于 num_entries，那么需要一个更大的数组来存储服务信息。

该函数的目的是获取特定服务对象对应的服务列表，将服务信息存储在提供的数组中，并返回实际填充的服务条目数。

以下是一个简单的例子，演示如何使用 qmi_client_get_service_list 函数：

#include <qmi_idl_lib.h>

// 假设存在一个服务对象
extern const struct qmi_idl_service_object_type my_qmi_service_object;

// 获取服务列表
void getServiceList() {
    qmi_service_info service_info_array[10];  // 假设数组大小为10，根据实际情况调整
    uint32_t num_entries = 10;  // 数组的大小
    uint32_t num_services;

    // 获取服务对象对应的服务列表
    qmi_client_error_type result = qmi_client_get_service_list(
        my_qmi_service_object, service_info_array, &num_entries, &num_services);

    if (result == QMI_NO_ERR) {
        // 成功获取服务列表
        // 可以使用 service_info_array 和 num_entries 进行相应的操作
    } else {
        // 处理获取服务列表失败的情况
    }
}

int main() {
    // 在主函数中调用获取服务列表的函数
    getServiceList();

    return 0;
}

在这个例子中，my_qmi_service_object 是由QMI IDL生成的服务对象。getServiceList 函数调用了 qmi_client_get_service_list 来获取服务列表，将服务信息存储在数组中，并返回实际填充的服务条目数。您可以根据实际情况调整数组大小。

2.2.5 qmi_client_get_any_service()

qmi_client_error_type
qmi_client_get_any_service
(
qmi_idl_service_object_type service_obj,
qmi_service_info *service_info
);
这段代码是用于根据提供的服务对象（service_obj）检索对应的单个服务信息（service_info）。如果系统中存在多个服务，它将返回找到的第一个服务。以下是对函数参数的解释：

service_obj（服务对象）： 表示服务的对象，通常是由QMI IDL生成的服务对象。
service_info（服务信息指针）： 用于存储获取到的服务信息的指针。

该函数的目的是根据提供的服务对象检索相应的服务信息，并将其存储在用户提供的service_info指针指向的位置。如果系统中存在多个服务，该函数将返回找到的第一个服务的信息。

总的来说，通过使用qmi_client_get_any_service，客户端可以根据服务对象获取系统中的某个服务的信息，以便在与该服务进行交互时使用。

#include <qmi_idl_lib.h>

// 定义QMI服务对象
extern const struct qmi_idl_service_object my_qmi_service_object;

// 获取任意服务的信息
void getAnyServiceInfo() {
    qmi_service_info service_info;

    // 获取服务对象的任意服务信息
    qmi_client_error_type result = qmi_client_get_any_service(my_qmi_service_object, &service_info);

    if (result == QMI_NO_ERR) {
        // 成功获取服务信息
        // 这里可以使用 service_info 进行相应的操作，例如获取服务的ID、版本等
    } else {
        // 处理获取服务信息失败的情况
    }
}

int main() {
    // 在主函数中调用获取任意服务信息的函数
    getAnyServiceInfo();

    return 0;
}

2.2.6qmi_client_get_service_instance()

qmi_client_error_type
qmi_client_get_service_instance
(
qmi_idl_service_object_type service_obj,
qmi_service_instance instance_id,
qmi_service_info *service_info
);
这段代码是用于根据提供的服务对象（service_obj）和特定实例ID（instance_id）检索对应的单个服务信息（service_info）。以下是对函数参数的解释：

service_obj（服务对象）： 表示服务的对象，通常是由QMI IDL生成的服务对象。
instance_id（实例ID）： 表示服务实例的ID，用于唯一标识特定服务的一个实例。
service_info（服务信息指针）： 用于存储获取到的服务信息的指针。

该函数的目的是根据提供的服务对象和实例ID检索相应的服务信息，并将其存储在用户提供的service_info指针指向的位置。服务信息包含了有关服务的各种元数据。

总的来说，通过使用qmi_client_get_service_instance，客户端可以根据服务对象和实例ID获取特定服务的信息，以便在与该服务实例进行交互时使用。

2.2.7qmi_client_get_instance_id()

qmi_client_error_type
qmi_client_get_instance_id
(
qmi_service_info *service_info,
qmi_service_instance *instance_id
);
这段代码是用于获取特定服务信息（service_info）的实例ID（instance_id）。以下是对函数参数的解释：

service_info（服务信息指针）： 指向service_info数组中的一个条目的指针。
instance_id（实例ID指针）： 用于存储获取到的服务信息实例的指针。

该函数的目的是从给定的service_info中提取实例ID，并将其存储在用户提供的instance_id指针指向的位置。实例ID标识特定服务的实例。

总的来说，通过使用qmi_client_get_instance_id，客户端可以从服务信息中获取实例ID，以便在与特定服务实例交互时使用。

2.2.8qmi_client_register_error_cb()

qmi_client_error_type
qmi_client_register_error_cb
(
qmi_client_type user_handle,
qmi_client_error_cb err_cb,
void *err_cb_data
);
这段代码是用于注册一个回调函数，该回调函数在服务终止或取消注册时被调用。以下是对函数参数的解释：

user_handle（用户句柄）： 不透明句柄，用于标识不同的客户端。
err_cb（错误回调函数指针）： 指向回调函数的指针，即在服务终止或取消注册时将被调用的函数。
err_cb_data（错误回调数据）： 是在注册回调函数时传递给qmi_client_register_error_cb的用户数据。

该函数的目的是注册一个用于处理服务终止或取消注册的回调函数。当服务终止或取消注册时，QMI客户端基础设施会调用已注册的错误回调函数（err_cb），并将用户提供的数据传递给这个回调函数。

总的来说，通过使用qmi_client_register_error_cb，客户端可以注册一个回调函数，以便在服务终止或取消注册时执行特定的操作。这有助于客户端在服务状态发生变化时进行相应的处理。

2.2.9qmi_client_register_notify_cb()

qmi_client_error_type
qmi_client_register_notify_cb
(
qmi_client_type user_handle,
qmi_client_notify_cb notify_cb,
void *notify_cb_data
);
这段代码是用于注册一个回调函数，该回调函数在发生服务事件时被调用。更详细的信息可以在qmi_client_notify_cb部分找到。以下是对函数参数的解释：

user_handle（用户句柄）： 不透明句柄，用于标识不同的客户端。
notify_cb（通知回调函数指针）： 指向回调函数的指针，即在服务事件发生时将被调用的函数。
notify_cb_data（通知回调数据）： 是在注册回调函数时传递给qmi_client_register_notify_cb的用户数据。

该函数的目的是注册一个用于处理服务事件的回调函数。当发生服务事件时，QMI客户端基础设施会调用已注册的回调函数（notify_cb），并将用户提供的数据传递给这个回调函数。

总的来说，通过使用qmi_client_register_notify_cb，客户端可以注册一个回调函数，以便在发生服务事件时执行特定的操作。

2.3发送消息接口

2.3.1Asynchronous Messages

2.3.1.1qmi_client_send_raw_msg_async()

extern qmi_client_error_type
qmi_client_send_raw_msg_async
(
qmi_client_type user_handle,
unsigned int msg_id,
void *req_buf,
unsigned int req_buf_len,
void *resp_buf,
unsigned int resp_buf_len
qmi_client_async_rsp_cb *resp_cb,
void *resp_cb_data
qmi_txn_handle *txn_handle
);
这段代码是用于发送异步QMI服务消息的函数。调用者在通过此函数发送消息之前，需要对消息进行编码。以下是对函数参数的解释：

user_handle（用户句柄）： 基础设施用于标识不同客户端的句柄。
msg_id（消息ID）： 消息的ID，用于标识不同类型的QMI服务消息。
req_buf（请求缓冲区指针）： 指向已编码的请求消息的指针。
req_buf_len（请求缓冲区长度）： 请求消息的长度。
resp_buf（响应缓冲区指针）： 用于存储响应消息的指针。
resp_buf_len（响应缓冲区长度）： 响应缓冲区的长度。
resp_cb（响应回调函数）： 用于处理响应的回调函数。
resp_cb_data（响应回调用户数据）： 传递给响应回调函数的用户数据。
txn_handle（事务句柄）： 用于标识事务的句柄。

该函数的目的是发送异步的QMI服务消息，调用者需要在调用该函数之前对消息进行编码。函数将响应存储在提供的响应缓冲区中，并在处理完响应时调用提供的回调函数。同时，通过返回的 txn_handle 可以标识这个事务。

以下是一个简单的例子，演示如何使用qmi_client_send_raw_msg_async函数：

#include <qmi_idl_lib.h>

// 假设存在一个用户句柄 user_handle 和已编码的请求消息 req_buf
extern qmi_client_type user_handle;
extern void* req_buf;
extern unsigned int req_buf_len;

// 响应回调函数
void responseCallback(qmi_client_type user_handle, unsigned int msg_id, void* resp_buf,
                      unsigned int resp_buf_len, void* resp_cb_data, qmi_client_error_type transp_err) {
    // 处理响应
    // 根据实际需求进行相应的操作
}

// 发送异步QMI服务消息
void sendAsyncQmiMessage() {
    qmi_client_type user_handle;
    unsigned int msg_id = 123;  // 假设消息ID为123
    void* resp_buf;
    unsigned int resp_buf_len;
    qmi_txn_handle txn_handle;

    // 发送异步QMI服务消息
    qmi_client_error_type result = qmi_client_send_raw_msg_async(
        user_handle, msg_id, req_buf, req_buf_len, resp_buf, resp_buf_len,
        responseCallback, resp_cb_data, &txn_handle);

    if (result == QMI_NO_ERR) {
        // 成功发送异步QMI服务消息
        // 可以使用 txn_handle 进行相应的操作
    } else {
        // 处理发送消息失败的情况
    }
}

int main() {
    // 在主函数中调用发送异步QMI服务消息的函数
    sendAsyncQmiMessage();

    return 0;
}

在这个例子中，假设已经存在用户句柄 user_handle 和已编码的请求消息 req_buf。sendAsyncQmiMessage 函数调用了 qmi_client_send_raw_msg_async 来发送异步QMI服务消息，并在响应到达时调用指定的回调函数 responseCallback 进行处理。您需要根据实际情况提供消息ID、响应缓冲区、响应回调数据等参数。

2.3.1.2qmi_client_send_msg_async()

extern qmi_client_error_type
qmi_client_send_msg_async
(
qmi_client_type user_handle,
unsigned int msg_id,
void *req_c_struct,
unsigned int req_c_struct_len,
void *resp_c_struct,
unsigned int resp_c_struct_len
qmi_client_recv_msg_async_cb resp_cb,
void *resp_cb_data ，
qmi_txn_handle *txn_handle
);
这段代码是用于发送异步QMI服务消息的函数。该函数处理消息的编码和解码，以下是对函数参数的解释：

user_handle（用户句柄）： 用于标识用户的句柄。
msg_id（消息ID）： 消息的ID，用于标识不同类型的QMI服务消息。
req_c_struct（请求C结构指针）： 指向请求消息的C结构的指针。
req_c_struct_len（请求C结构长度）： 请求消息C结构的长度。
resp_c_struct（响应C结构指针）： 用于存储响应消息的C结构的指针。
resp_c_struct_len（响应C结构长度）： 响应C结构的长度。
resp_cb（响应回调函数）： 用于处理响应的回调函数。
resp_cb_data（响应回调用户数据）： 传递给响应回调函数的用户数据。
txn_handle（事务句柄）： 用于标识事务的句柄。

该函数的目的是发送异步的QMI服务消息，同时处理消息的编码和解码。函数将请求消息的C结构编码后发送，并在接收到响应时解码为C结构，并调用指定的回调函数进行处理。通过返回的 txn_handle 可以标识这个事务。

以下是一个简单的例子，演示如何使用qmi_client_send_msg_async函数：

#include <qmi_idl_lib.h>

// 假设存在一个用户句柄 user_handle 和请求C结构 req_c_struct
extern qmi_client_type user_handle;
extern void* req_c_struct;
extern unsigned int req_c_struct_len;

// 响应回调函数
void responseCallback(qmi_client_type user_handle, unsigned int msg_id, void* resp_c_struct,
                      unsigned int resp_c_struct_len, void* resp_cb_data,
                      qmi_client_error_type transp_err) {
    // 处理响应
    // 根据实际需求进行相应的操作
}

// 发送异步QMI服务消息
void sendAsyncQmiMessage() {
    qmi_client_type user_handle;
    unsigned int msg_id = 123;  // 假设消息ID为123
    void* resp_c_struct;
    unsigned int resp_c_struct_len;
    qmi_txn_handle txn_handle;

    // 发送异步QMI服务消息
    qmi_client_error_type result = qmi_client_send_msg_async(
        user_handle, msg_id, req_c_struct, req_c_struct_len,
        resp_c_struct, resp_c_struct_len, responseCallback, resp_cb_data, &txn_handle);

    if (result == QMI_NO_ERR) {
        // 成功发送异步QMI服务消息
        // 可以使用 txn_handle 进行相应的操作
    } else {
        // 处理发送消息失败的情况
    }
}

int main() {
    // 在主函数中调用发送异步QMI服务消息的函数
    sendAsyncQmiMessage();

    return 0;
}

在这个例子中，假设已经存在用户句柄 user_handle 和请求C结构 req_c_struct。sendAsyncQmiMessage 函数调用了 qmi_client_send_msg_async 来发送异步QMI服务消息，并在响应到达时调用指定的回调函数 responseCallback 进行处理。您需要根据实际情况提供消息ID、响应C结构、响应回调数据等参数。

2.3.1.3qmi_client_delete_async_txn()

extern qmi_client_error_type
qmi_client_delete_async_txn
(
qmi_client_type user_handle,
qmi_txn_handle async_txn_handle
);
这段代码是用于取消异步事务的函数。以下是对函数参数的解释：

user_handle（用户句柄）： 客户端的用户句柄，用于标识不同的客户端。
async_txn_handle（异步事务句柄）： 异步事务的句柄，用于标识要取消的特定事务。

该函数的目的是取消一个异步事务，通过提供的 async_txn_handle 可以指定要取消的特定事务。

以下是一个简单的例子，演示如何使用qmi_client_delete_async_txn函数：

#include <qmi_idl_lib.h>

// 假设存在一个用户句柄 user_handle 和异步事务句柄 async_txn_handle
extern qmi_client_type user_handle;
extern qmi_txn_handle async_txn_handle;

// 取消异步事务
void cancelAsyncTransaction() {
    // 取消异步事务
    qmi_client_error_type result = qmi_client_delete_async_txn(user_handle, async_txn_handle);

    if (result == QMI_NO_ERR) {
        // 成功取消异步事务
        // 根据实际需求进行相应的操作
    } else {
        // 处理取消异步事务失败的情况
    }
}

int main() {
    // 在主函数中调用取消异步事务的函数
    cancelAsyncTransaction();

    return 0;
}

在这个例子中，假设已经存在用户句柄 user_handle 和异步事务句柄 async_txn_handle。cancelAsyncTransaction 函数调用了 qmi_client_delete_async_txn 来取消异步事务。您需要根据实际情况提供用户句柄和异步事务句柄。

2.3.1.4qmi_client_get_async_txn_id()

extern qmi_client_error_type
qmi_client_get_async_txn_id
(
qmi_client_type user_handle,
qmi_txn_handle async_txn_handle,
uint32_t *txn_id
);

这段代码是用于获取事务ID（transaction ID）的函数，但已经被标记为不推荐使用（DEPRECATED）。以下是对函数参数的解释：

user_handle（用户句柄）： 客户端的用户句柄，用于标识不同的客户端。
async_txn_handle（异步事务句柄）： 异步事务的句柄，用于标识特定的异步事务。
txn_id（事务ID指针）： 用于存储获取到的事务ID的指针。

该函数的目的是从异步事务句柄中获取事务ID。事务ID是用于标识特定事务的唯一标识符。这个函数被添加是为了支持需要访问事务ID的传统QMI消息。

由于该函数已被标记为不推荐使用，建议使用更现代的API和方式来处理异步事务，如果可能的话，尽量避免使用这个被弃用的函数。

以下是一个简单的例子，演示如何使用qmi_client_get_async_txn_id函数：

#include <qmi_idl_lib.h>

// 假设存在一个用户句柄 user_handle 和异步事务句柄 async_txn_handle
extern qmi_client_type user_handle;
extern qmi_txn_handle async_txn_handle;

// 获取异步事务的事务ID
void getAsyncTransactionId() {
    uint32_t txn_id;

    // 获取异步事务的事务ID
    qmi_client_error_type result = qmi_client_get_async_txn_id(user_handle, async_txn_handle, &txn_id);

    if (result == QMI_NO_ERR) {
        // 成功获取异步事务的事务ID
        // 可以使用 txn_id 进行相应的操作
    } else {
        // 处理获取异步事务的事务ID失败的情况
    }
}

int main() {
    // 在主函数中调用获取异步事务的事务ID的函数
    getAsyncTransactionId();

    return 0;
}

在这个例子中，假设已经存在用户句柄 user_handle 和异步事务句柄 async_txn_handle。getAsyncTransactionId 函数调用了 qmi_client_get_async_txn_id 来获取异步事务的事务ID。您需要根据实际情况提供用户句柄、异步事务句柄和事务ID指针。

2.3.2synchronous Messages

2.3.2.1 qmi_client_send_raw_msg_sync()

extern qmi_client_error_type
qmi_client_send_raw_msg_sync
(
qmi_client_type user_handle,
unsigned int msg_id,
void *req_buf,
unsigned int req_buf_len,
void *resp_buf,
unsigned int resp_buf_len,
unsigned int resp_buf_recv_len,
unsigned int timeout_msecs
);
这段代码是用于发送同步QMI服务消息的函数。以下是对函数参数的解释：

user_handle（用户句柄）： 用于标识用户的句柄。
msg_id（消息ID）： 消息的ID，用于标识不同类型的QMI服务消息。
req_buf（请求缓冲区指针）： 指向已编码的请求消息的指针。
req_buf_len（请求缓冲区长度）： 请求消息的长度。
resp_buf（响应缓冲区指针）： 用于存储响应消息的指针。
resp_buf_len（响应缓冲区长度）： 响应缓冲区的长度。
resp_buf_recv_len（接收到的响应缓冲区长度）： 用于存储实际接收到的响应消息的长度。
timeout_msecs（超时时间，毫秒）： 发送同步消息时的超时时间，以毫秒为单位。

该函数的目的是发送同步的QMI服务消息，调用者需要在调用该函数之前对消息进行编码。函数将请求消息发送到服务端，等待服务端的响应，并将响应存储在提供的响应缓冲区中。

以下是一个简单的例子，演示如何使用qmi_client_send_raw_msg_sync函数：

#include <qmi_idl_lib.h>

// 假设存在一个用户句柄 user_handle、已编码的请求消息 req_buf 和相应的缓冲区 resp_buf
extern qmi_client_type user_handle;
extern void* req_buf;
extern unsigned int req_buf_len;
extern void* resp_buf;
extern unsigned int resp_buf_len;
extern unsigned int resp_buf_recv_len;
extern unsigned int timeout_msecs;

// 发送同步QMI服务消息
void sendSyncQmiMessage() {
    // 发送同步QMI服务消息
    qmi_client_error_type result = qmi_client_send_raw_msg_sync(
        user_handle, msg_id, req_buf, req_buf_len,
        resp_buf, resp_buf_len, &resp_buf_recv_len, timeout_msecs);

    if (result == QMI_NO_ERR) {
        // 成功发送同步QMI服务消息
        // 可以使用 resp_buf 和 resp_buf_recv_len 进行相应的操作
    } else {
        // 处理发送消息失败的情况
    }
}

int main() {
    // 在主函数中调用发送同步QMI服务消息的函数
    sendSyncQmiMessage();

    return 0;
}

在这个例子中，假设已经存在用户句柄 user_handle、已编码的请求消息 req_buf 和相应的缓冲区 resp_buf。sendSyncQmiMessage 函数调用了 qmi_client_send_raw_msg_sync 来发送同步QMI服务消息，并在响应到达时将响应存储在提供的响应缓冲区中。您需要根据实际情况提供消息ID、请求缓冲区、响应缓冲区、超时时间等参数。

2.3.2.2 qmi_client_send_msg_sync()

extern qmi_client_error_type
qmi_client_send_msg_sync
(
qmi_client_type user_handle,
unsigned int msg_id,
void *req_c_struct,
unsigned int req_c_struct_len,
void *resp_c_struct,
unsigned int resp_c_struct_len,
unsigned int resp_c_struct_recv_len,
unsigned int timeout_msecs
);
这段代码是用于发送同步QMI服务消息的函数，提供了编码/解码功能，用户在提供的响应结构中获取解码后的数据。以下是对函数参数的解释：

user_handle（用户句柄）： 用于标识用户的句柄。
msg_id（消息ID）： 消息的ID，用于标识不同类型的QMI服务消息。
req_c_struct（请求结构指针）： 指向已编码的请求消息的指针。
req_c_struct_len（请求结构长度）： 请求消息结构的长度。
resp_c_struct（响应结构指针）： 用于存储解码后的响应数据的指针。
resp_c_struct_len（响应结构长度）： 响应结构的长度。
resp_c_struct_recv_len（接收到的响应结构长度）： 用于存储实际接收到的解码后的响应数据的长度。
timeout_msecs（超时时间，毫秒）： 发送同步消息时的超时时间，以毫秒为单位。

该函数的目的是发送同步的QMI服务消息，调用者无需在调用函数之前对消息进行编码，函数会处理编码和解码的过程。函数将请求消息发送到服务端，等待服务端的响应，并将解码后的响应存储在提供的响应结构中。

以下是一个简单的例子，演示如何使用qmi_client_send_msg_sync函数：

#include <qmi_idl_lib.h>

// 假设存在一个用户句柄 user_handle、已编码的请求消息 req_c_struct 和相应的结构 resp_c_struct
extern qmi_client_type user_handle;
extern void* req_c_struct;
extern unsigned int req_c_struct_len;
extern void* resp_c_struct;
extern unsigned int resp_c_struct_len;
extern unsigned int resp_c_struct_recv_len;
extern unsigned int timeout_msecs;

// 发送同步QMI服务消息
void sendSyncQmiMessage() {
    // 发送同步QMI服务消息
    qmi_client_error_type result = qmi_client_send_msg_sync(
        user_handle, msg_id, req_c_struct, req_c_struct_len,
        resp_c_struct, resp_c_struct_len, &resp_c_struct_recv_len, timeout_msecs);

    if (result == QMI_NO_ERR) {
        // 成功发送同步QMI服务消息
        // 可以使用 resp_c_struct 和 resp_c_struct_recv_len 进行相应的操作
    } else {
        // 处理发送消息失败的情况
    }
}

int main() {
    // 在主函数中调用发送同步QMI服务消息的函数
    sendSyncQmiMessage();

    return 0;
}

在这个例子中，假设已经存在用户句柄 user_handle、已编码的请求消息 req_c_struct 和相应的结构 resp_c_struct。sendSyncQmiMessage 函数调用了 qmi_client_send_msg_sync 来发送同步QMI服务消息，并在响应到达时将解码后的响应存储在提供的响应结构中。您需要根据实际情况提供消息ID、请求结构、响应结构、超时时间等参数。

2.4释放接口API

extern qmi_client_error_type
qmi_client_release
(
qmi_client_type user_handle,
);

2.5对api进行编码和解码

2.5.1qmi_client_message_encode()

extern qmi_client_error_type
qmi_client_message_encode
(
qmi_client_type user_handle,
qmi_idl_type_of_message_type req_resp_ind,
unsigned int message_id,
const void *p_src,
unsigned int src_len,
void *p_dst,
unsigned int dst_len,
unsigned int *dst_encoded_len
);
这段代码是用于将QMI消息从C数据结构编码为传输格式的API。以下是对函数参数的解释：

user_handle（用户句柄）： 用于标识用户的句柄。这是在初始化QMI服务连接时返回的句柄。
req_resp_ind（消息类型）： 指定消息的类型，可以是请求、响应或者指示。
message_id（消息ID）： 消息的ID，用于标识不同类型的QMI消息。
p_src（源数据结构指针）： 指向包含消息数据的C结构的指针。
src_len（源数据结构长度）： C结构的长度，以字节为单位。
p_dst（目标缓冲区指针）： 指向消息中第一个TLV的指针。
dst_len（目标缓冲区长度）： p_dst缓冲区的长度，以字节为单位。
dst_encoded_len（编码后消息的长度指针）： 用于存储编码后消息的长度的指针。

该函数的目的是将QMI消息的主体从C数据结构编码为传输格式，以便发送到QMI服务。调用者需要提供包含消息数据的C结构、目标缓冲区等信息，函数将对消息进行编码，并将编码后消息的长度存储在提供的指针中。

以下是一个简单的例子，演示如何使用qmi_client_message_encode函数：

#include <qmi_idl_lib.h>

// 假设存在一个用户句柄 user_handle、消息类型 req_resp_ind、消息ID message_id
// 以及包含消息数据的C结构指针 p_src 和相应的长度 src_len
extern qmi_client_type user_handle;
extern qmi_idl_type_of_message_type req_resp_ind;
extern unsigned int message_id;
extern const void* p_src;
extern unsigned int src_len;
extern void* p_dst;
extern unsigned int dst_len;
extern unsigned int dst_encoded_len;

// 编码QMI消息
void encodeQmiMessage() {
    // 编码QMI消息
    qmi_client_error_type result = qmi_client_message_encode(
        user_handle, req_resp_ind, message_id, p_src, src_len,
        p_dst, dst_len, &dst_encoded_len);

    if (result == QMI_NO_ERR) {
        // 成功编码QMI消息
        // 可以使用 p_dst 和 dst_encoded_len 进行相应的操作
    } else {
        // 处理编码消息失败的情况
    }
}

int main() {
    // 在主函数中调用编码QMI消息的函数
    encodeQmiMessage();

    return 0;
}

在这个例子中，假设已经存在用户句柄 user_handle、消息类型 req_resp_ind、消息ID message_id，以及包含消息数据的C结构指针 p_src 和相应的长度 src_len。encodeQmiMessage 函数调用了 qmi_client_message_encode 来将QMI消息从C数据结构编码为传输格式。您需要根据实际情况提供消息类型、消息ID、源数据结构、目标缓冲区等参数。

2.5.2qmi_client_message_decode()

extern qmi_client_error_type
qmi_client_message_decode
(
qmi_client_type user_handle,
qmi_idl_type_of_message_type req_resp_ind,
unsigned int message_id,
const void *p_src,
unsigned int src_len,
void *p_dst,
unsigned int dst_len
);
这段代码是用于将QMI消息从传输格式解码为C数据结构的API。以下是对函数参数的解释：

user_handle（用户句柄）： 用于标识用户的句柄。这是在初始化QMI服务连接时返回的句柄。
req_resp_ind（消息类型）： 指定消息的类型，可以是请求、响应或者指示。
message_id（消息ID）： 消息的ID，用于标识不同类型的QMI消息。
p_src（源缓冲区指针）： 指向消息中第一个TLV的指针。
src_len（源缓冲区长度）： p_src缓冲区的长度，以字节为单位。
p_dst（目标数据结构指针）： 指向存储解码后数据的C结构的指针。
dst_len（目标数据结构长度）： C结构的长度，以字节为单位。

该函数的目的是将QMI消息的主体从传输格式解码为C数据结构，以便在客户端进行处理。调用者需要提供源缓冲区、目标数据结构等信息，函数将对消息进行解码，并将解码后的数据存储在提供的C结构中。

以下是一个简单的例子，演示如何使用qmi_client_message_decode函数：

#include <qmi_idl_lib.h>

// 假设存在一个用户句柄 user_handle、消息类型 req_resp_ind、消息ID message_id
// 以及源缓冲区指针 p_src、源缓冲区长度 src_len
extern qmi_client_type user_handle;
extern qmi_idl_type_of_message_type req_resp_ind;
extern unsigned int message_id;
extern const void* p_src;
extern unsigned int src_len;
extern void* p_dst;
extern unsigned int dst_len;

// 解码QMI消息
void decodeQmiMessage() {
    // 解码QMI消息
    qmi_client_error_type result = qmi_client_message_decode(
        user_handle, req_resp_ind, message_id, p_src, src_len,
        p_dst, dst_len);

    if (result == QMI_NO_ERR) {
        // 成功解码QMI消息
        // 可以使用 p_dst 进行相应的操作
    } else {
        // 处理解码消息失败的情况
    }
}

int main() {
    // 在主函数中调用解码QMI消息的函数
    decodeQmiMessage();

    return 0;
}

在这个例子中，假设已经存在用户句柄 user_handle、消息类型 req_resp_ind、消息ID message_id，以及源缓冲区指针 p_src 和相应的长度 src_len。decodeQmiMessage 函数调用了 qmi_client_message_decode 来将QMI消息从传输格式解码为C数据结构。您需要根据实际情况提供消息类型、消息ID、源缓冲区、目标数据结构等参数。

文章来源:https://blog.csdn.net/m0_51998128/article/details/135750544
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若内容造成侵权/违法违规/事实不符，请联系我的编程经验分享网邮箱：chenni525@qq.com进行投诉反馈，一经查实，立即删除！