[PATCH 7/8] libqmi-glib, device: port qmi_device_open to use GTask
Aleksander Morgado
aleksander at aleksander.es
Tue Apr 18 14:05:30 UTC 2017
On 12/04/17 22:15, Ben Chan wrote:
> ---
> src/libqmi-glib/qmi-device.c | 279 ++++++++++++++++++++++++-------------------
> 1 file changed, 155 insertions(+), 124 deletions(-)
>
Pushed to git master, thanks.
> diff --git a/src/libqmi-glib/qmi-device.c b/src/libqmi-glib/qmi-device.c
> index bc9480c..9f1c973 100644
> --- a/src/libqmi-glib/qmi-device.c
> +++ b/src/libqmi-glib/qmi-device.c
> @@ -1790,9 +1790,6 @@ typedef enum {
> } DeviceOpenContextStep;
>
> typedef struct {
> - QmiDevice *self;
> - GSimpleAsyncResult *result;
> - GCancellable *cancellable;
> DeviceOpenContextStep step;
> QmiDeviceOpenFlags flags;
> guint timeout;
> @@ -1801,14 +1798,9 @@ typedef struct {
> } DeviceOpenContext;
>
> static void
> -device_open_context_complete_and_free (DeviceOpenContext *ctx)
> +device_open_context_free (DeviceOpenContext *ctx)
> {
> - g_simple_async_result_complete_in_idle (ctx->result);
> - g_object_unref (ctx->result);
> g_free (ctx->driver);
> - if (ctx->cancellable)
> - g_object_unref (ctx->cancellable);
> - g_object_unref (ctx->self);
> g_slice_free (DeviceOpenContext, ctx);
> }
>
> @@ -1817,89 +1809,103 @@ qmi_device_open_finish (QmiDevice *self,
> GAsyncResult *res,
> GError **error)
> {
> - return !g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (res), error);
> + return g_task_propagate_boolean (G_TASK (res), error);
> }
>
> -static void device_open_context_step (DeviceOpenContext *ctx);
> +static void device_open_step (GTask *task);
>
> static void
> ctl_set_data_format_ready (QmiClientCtl *client,
> GAsyncResult *res,
> - DeviceOpenContext *ctx)
> + GTask *task)
> {
> + QmiDevice *self;
> + DeviceOpenContext *ctx;
> QmiMessageCtlSetDataFormatOutput *output = NULL;
> GError *error = NULL;
>
> output = qmi_client_ctl_set_data_format_finish (client, res, &error);
> /* Check result of the async operation */
> if (!output) {
> - g_simple_async_result_take_error (ctx->result, error);
> - device_open_context_complete_and_free (ctx);
> + g_task_return_error (task, error);
> + g_object_unref (task);
> return;
> }
>
> /* Check result of the QMI operation */
> if (!qmi_message_ctl_set_data_format_output_get_result (output, &error)) {
> - g_simple_async_result_take_error (ctx->result, error);
> - device_open_context_complete_and_free (ctx);
> + g_task_return_error (task, error);
> + g_object_unref (task);
> qmi_message_ctl_set_data_format_output_unref (output);
> return;
> }
>
> + self = g_task_get_source_object (task);
> +
> g_debug ("[%s] Network port data format operation finished",
> - ctx->self->priv->path_display);
> + self->priv->path_display);
>
> qmi_message_ctl_set_data_format_output_unref (output);
>
> /* Go on */
> + ctx = g_task_get_task_data (task);
> ctx->step++;
> - device_open_context_step (ctx);
> + device_open_step (task);
> }
>
> static void
> sync_ready (QmiClientCtl *client_ctl,
> GAsyncResult *res,
> - DeviceOpenContext *ctx)
> + GTask *task)
> {
> + QmiDevice *self;
> + DeviceOpenContext *ctx;
> GError *error = NULL;
> QmiMessageCtlSyncOutput *output;
>
> /* Check result of the async operation */
> output = qmi_client_ctl_sync_finish (client_ctl, res, &error);
> if(!output) {
> - g_simple_async_result_take_error (ctx->result, error);
> - device_open_context_complete_and_free (ctx);
> + g_task_return_error (task, error);
> + g_object_unref (task);
> return;
> }
>
> /* Check result of the QMI operation */
> if (!qmi_message_ctl_sync_output_get_result (output, &error)) {
> - g_simple_async_result_take_error (ctx->result, error);
> - device_open_context_complete_and_free (ctx);
> + g_task_return_error (task, error);
> + g_object_unref (task);
> qmi_message_ctl_sync_output_unref (output);
> return;
> }
>
> + self = g_task_get_source_object (task);
> g_debug ("[%s] Sync operation finished",
> - ctx->self->priv->path_display);
> + self->priv->path_display);
>
> qmi_message_ctl_sync_output_unref (output);
>
> /* Go on */
> + ctx = g_task_get_task_data (task);
> ctx->step++;
> - device_open_context_step (ctx);
> + device_open_step (task);
> }
>
> static void
> open_version_info_ready (QmiClientCtl *client_ctl,
> GAsyncResult *res,
> - DeviceOpenContext *ctx)
> + GTask *task)
> {
> + QmiDevice *self;
> + DeviceOpenContext *ctx;
> GArray *service_list;
> QmiMessageCtlGetVersionInfoOutput *output;
> GError *error = NULL;
> guint i;
>
> + self = g_task_get_source_object (task);
> + ctx = g_task_get_task_data (task);
> +
> /* Check result of the async operation */
> output = qmi_client_ctl_get_version_info_finish (client_ctl, res, &error);
> if (!output) {
> @@ -1909,27 +1915,27 @@ open_version_info_ready (QmiClientCtl *client_ctl,
> /* If retries left, retry */
> if (ctx->version_check_retries > 0) {
> g_error_free (error);
> - qmi_client_ctl_get_version_info (ctx->self->priv->client_ctl,
> + qmi_client_ctl_get_version_info (self->priv->client_ctl,
> NULL,
> 1,
> - ctx->cancellable,
> + g_task_get_cancellable (task),
> (GAsyncReadyCallback)open_version_info_ready,
> - ctx);
> + task);
> return;
> }
>
> /* Otherwise, propagate the error */
> }
>
> - g_simple_async_result_take_error (ctx->result, error);
> - device_open_context_complete_and_free (ctx);
> + g_task_return_error (task, error);
> + g_object_unref (task);
> return;
> }
>
> /* Check result of the QMI operation */
> if (!qmi_message_ctl_get_version_info_output_get_result (output, &error)) {
> - g_simple_async_result_take_error (ctx->result, error);
> - device_open_context_complete_and_free (ctx);
> + g_task_return_error (task, error);
> + g_object_unref (task);
> qmi_message_ctl_get_version_info_output_unref (output);
> return;
> }
> @@ -1939,28 +1945,28 @@ open_version_info_ready (QmiClientCtl *client_ctl,
> qmi_message_ctl_get_version_info_output_get_service_list (output,
> &service_list,
> NULL);
> - ctx->self->priv->supported_services = g_array_ref (service_list);
> + self->priv->supported_services = g_array_ref (service_list);
>
> g_debug ("[%s] QMI Device supports %u services:",
> - ctx->self->priv->path_display,
> - ctx->self->priv->supported_services->len);
> - for (i = 0; i < ctx->self->priv->supported_services->len; i++) {
> + self->priv->path_display,
> + self->priv->supported_services->len);
> + for (i = 0; i < self->priv->supported_services->len; i++) {
> QmiMessageCtlGetVersionInfoOutputServiceListService *info;
> const gchar *service_str;
>
> - info = &g_array_index (ctx->self->priv->supported_services,
> + info = &g_array_index (self->priv->supported_services,
> QmiMessageCtlGetVersionInfoOutputServiceListService,
> i);
> service_str = qmi_service_get_string (info->service);
> if (service_str)
> g_debug ("[%s] %s (%u.%u)",
> - ctx->self->priv->path_display,
> + self->priv->path_display,
> service_str,
> info->major_version,
> info->minor_version);
> else
> g_debug ("[%s] unknown [0x%02x] (%u.%u)",
> - ctx->self->priv->path_display,
> + self->priv->path_display,
> info->service,
> info->major_version,
> info->minor_version);
> @@ -1970,29 +1976,30 @@ open_version_info_ready (QmiClientCtl *client_ctl,
>
> /* Go on */
> ctx->step++;
> - device_open_context_step (ctx);
> + device_open_step (task);
> }
>
> static void
> internal_proxy_open_ready (QmiClientCtl *client_ctl,
> GAsyncResult *res,
> - DeviceOpenContext *ctx)
> + GTask *task)
> {
> + DeviceOpenContext *ctx;
> QmiMessageCtlInternalProxyOpenOutput *output;
> GError *error = NULL;
>
> /* Check result of the async operation */
> output = qmi_client_ctl_internal_proxy_open_finish (client_ctl, res, &error);
> if (!output) {
> - g_simple_async_result_take_error (ctx->result, error);
> - device_open_context_complete_and_free (ctx);
> + g_task_return_error (task, error);
> + g_object_unref (task);
> return;
> }
>
> /* Check result of the QMI operation */
> if (!qmi_message_ctl_internal_proxy_open_output_get_result (output, &error)) {
> - g_simple_async_result_take_error (ctx->result, error);
> - device_open_context_complete_and_free (ctx);
> + g_task_return_error (task, error);
> + g_object_unref (task);
> qmi_message_ctl_internal_proxy_open_output_unref (output);
> return;
> }
> @@ -2000,26 +2007,29 @@ internal_proxy_open_ready (QmiClientCtl *client_ctl,
> qmi_message_ctl_internal_proxy_open_output_unref (output);
>
> /* Go on */
> + ctx = g_task_get_task_data (task);
> ctx->step++;
> - device_open_context_step (ctx);
> + device_open_step (task);
> }
>
> static void
> create_iostream_ready (QmiDevice *self,
> GAsyncResult *res,
> - DeviceOpenContext *ctx)
> + GTask *task)
> {
> + DeviceOpenContext *ctx;
> GError *error = NULL;
>
> if (!create_iostream_finish (self, res, &error)) {
> - g_simple_async_result_take_error (ctx->result, error);
> - device_open_context_complete_and_free (ctx);
> + g_task_return_error (task, error);
> + g_object_unref (task);
> return;
> }
>
> /* Go on */
> + ctx = g_task_get_task_data (task);
> ctx->step++;
> - device_open_context_step (ctx);
> + device_open_step (task);
> }
>
> #if defined MBIM_QMUX_ENABLED
> @@ -2027,83 +2037,98 @@ create_iostream_ready (QmiDevice *self,
> static void
> mbim_device_open_ready (MbimDevice *dev,
> GAsyncResult *res,
> - DeviceOpenContext *ctx)
> + GTask *task)
> {
> + QmiDevice *self;
> + DeviceOpenContext *ctx;
> GError *error = NULL;
>
> if (!mbim_device_open_finish (dev, res, &error)) {
> - g_simple_async_result_take_error (ctx->result, error);
> - device_open_context_complete_and_free (ctx);
> + g_task_return_error (task, error);
> + g_object_unref (task);
> return;
> }
>
> - g_debug ("[%s] MBIM device open", ctx->self->priv->path_display);
> + self = g_task_get_source_object (task);
> + g_debug ("[%s] MBIM device open", self->priv->path_display);
>
> /* Go on */
> + ctx = g_task_get_task_data (task);
> ctx->step++;
> - device_open_context_step (ctx);
> + device_open_step (task);
> }
>
> static void
> -open_mbim_device (DeviceOpenContext *ctx)
> +open_mbim_device (GTask *task)
> {
> + QmiDevice *self;
> + DeviceOpenContext *ctx;
> MbimDeviceOpenFlags open_flags = MBIM_DEVICE_OPEN_FLAGS_NONE;
>
> + self = g_task_get_source_object (task);
> + ctx = g_task_get_task_data (task);
> +
> /* If QMI proxy was requested, use MBIM proxy instead */
> if (ctx->flags & QMI_DEVICE_OPEN_FLAGS_PROXY)
> open_flags |= MBIM_DEVICE_OPEN_FLAGS_PROXY;
>
> /* We pass the original timeout of the request to the open operation */
> - g_debug ("[%s] opening MBIM device...", ctx->self->priv->path_display);
> - mbim_device_open_full (ctx->self->priv->mbimdev,
> + g_debug ("[%s] opening MBIM device...", self->priv->path_display);
> + mbim_device_open_full (self->priv->mbimdev,
> open_flags,
> ctx->timeout,
> - ctx->cancellable,
> + g_task_get_cancellable (task),
> (GAsyncReadyCallback) mbim_device_open_ready,
> - ctx);
> + task);
> }
>
> static void
> mbim_device_new_ready (GObject *source,
> GAsyncResult *res,
> - DeviceOpenContext *ctx)
> + GTask *task)
> {
> + QmiDevice *self;
> + DeviceOpenContext *ctx;
> GError *error = NULL;
>
> - ctx->self->priv->mbimdev = mbim_device_new_finish (res, &error);
> - if (!ctx->self->priv->mbimdev) {
> - g_simple_async_result_take_error (ctx->result, error);
> - device_open_context_complete_and_free (ctx);
> + self = g_task_get_source_object (task);
> + self->priv->mbimdev = mbim_device_new_finish (res, &error);
> + if (!self->priv->mbimdev) {
> + g_task_return_error (task, error);
> + g_object_unref (task);
> return;
> }
>
> - g_debug ("[%s] MBIM device created", ctx->self->priv->path_display);
> + g_debug ("[%s] MBIM device created", self->priv->path_display);
>
> /* Go on */
> + ctx = g_task_get_task_data (task);
> ctx->step++;
> - device_open_context_step (ctx);
> + device_open_step (task);
> }
>
> static void
> -create_mbim_device (DeviceOpenContext *ctx)
> +create_mbim_device (GTask *task)
> {
> + QmiDevice *self;
> GFile *file;
>
> - if (ctx->self->priv->mbimdev) {
> - g_simple_async_result_set_error (ctx->result,
> - QMI_CORE_ERROR,
> - QMI_CORE_ERROR_WRONG_STATE,
> - "Already open");
> - device_open_context_complete_and_free (ctx);
> + self = g_task_get_source_object (task);
> + if (self->priv->mbimdev) {
> + g_task_return_new_error (task,
> + QMI_CORE_ERROR,
> + QMI_CORE_ERROR_WRONG_STATE,
> + "Already open");
> + g_object_unref (task);
> return;
> }
>
> - g_debug ("[%s] creating MBIM device...", ctx->self->priv->path_display);
> - file = g_file_new_for_path (ctx->self->priv->path);
> + g_debug ("[%s] creating MBIM device...", self->priv->path_display);
> + file = g_file_new_for_path (self->priv->path);
> mbim_device_new (file,
> - ctx->cancellable,
> + g_task_get_cancellable (task),
> (GAsyncReadyCallback) mbim_device_new_ready,
> - ctx);
> + task);
> g_object_unref (file);
> }
>
> @@ -2115,60 +2140,68 @@ create_mbim_device (DeviceOpenContext *ctx)
> QMI_DEVICE_OPEN_FLAGS_NET_NO_QOS_HEADER)
>
> static void
> -device_open_context_step (DeviceOpenContext *ctx)
> +device_open_step (GTask *task)
> {
> + QmiDevice *self;
> + DeviceOpenContext *ctx;
> +
> + self = g_task_get_source_object (task);
> + ctx = g_task_get_task_data (task);
> +
> switch (ctx->step) {
> case DEVICE_OPEN_CONTEXT_STEP_FIRST:
> ctx->step++;
> /* Fall down */
>
> case DEVICE_OPEN_CONTEXT_STEP_DRIVER:
> - ctx->driver = __qmi_utils_get_driver (ctx->self->priv->path);
> + ctx->driver = __qmi_utils_get_driver (self->priv->path);
> if (ctx->driver)
> - g_debug ("[%s] loaded driver of cdc-wdm port: %s", ctx->self->priv->path_display, ctx->driver);
> - else if (!ctx->self->priv->no_file_check)
> - g_warning ("[%s] couldn't load driver of cdc-wdm port", ctx->self->priv->path_display);
> + g_debug ("[%s] loaded driver of cdc-wdm port: %s", self->priv->path_display, ctx->driver);
> + else if (!self->priv->no_file_check)
> + g_warning ("[%s] couldn't load driver of cdc-wdm port", self->priv->path_display);
>
> #if defined MBIM_QMUX_ENABLED
>
> /* Auto mode requested? */
> if (ctx->flags & QMI_DEVICE_OPEN_FLAGS_AUTO) {
> if (!g_strcmp0 (ctx->driver, "cdc_mbim")) {
> - g_debug ("[%s] automatically selecting MBIM mode", ctx->self->priv->path_display);
> + g_debug ("[%s] automatically selecting MBIM mode", self->priv->path_display);
> ctx->flags |= QMI_DEVICE_OPEN_FLAGS_MBIM;
> goto next_step;
> }
> if (!g_strcmp0 (ctx->driver, "qmi_wwan")) {
> - g_debug ("[%s] automatically selecting QMI mode", ctx->self->priv->path_display);
> + g_debug ("[%s] automatically selecting QMI mode", self->priv->path_display);
> ctx->flags &= ~QMI_DEVICE_OPEN_FLAGS_MBIM;
> goto next_step;
> }
> - g_simple_async_result_set_error (ctx->result, QMI_CORE_ERROR, QMI_CORE_ERROR_FAILED,
> - "Cannot automatically select QMI/MBIM mode: driver %s",
> - ctx->driver ? ctx->driver : "unknown");
> - device_open_context_complete_and_free (ctx);
> + g_task_return_new_error (task,
> + QMI_CORE_ERROR,
> + QMI_CORE_ERROR_FAILED,
> + "Cannot automatically select QMI/MBIM mode: driver %s",
> + ctx->driver ? ctx->driver : "unknown");
> + g_object_unref (task);
> return;
> }
>
> /* MBIM mode requested? */
> if (ctx->flags & QMI_DEVICE_OPEN_FLAGS_MBIM) {
> - if (g_strcmp0 (ctx->driver, "cdc_mbim") && !ctx->self->priv->no_file_check)
> - g_warning ("[%s] requested MBIM mode but unexpected driver found: %s", ctx->self->priv->path_display, ctx->driver);
> + if (g_strcmp0 (ctx->driver, "cdc_mbim") && !self->priv->no_file_check)
> + g_warning ("[%s] requested MBIM mode but unexpected driver found: %s", self->priv->path_display, ctx->driver);
> goto next_step;
> }
>
> #else
> if (ctx->flags & QMI_DEVICE_OPEN_FLAGS_AUTO)
> - g_warning ("[%s] requested auto mode but no MBIM QMUX support available", ctx->self->priv->path_display);
> + g_warning ("[%s] requested auto mode but no MBIM QMUX support available", self->priv->path_display);
> if (ctx->flags & QMI_DEVICE_OPEN_FLAGS_MBIM)
> - g_warning ("[%s] requested MBIM mode but no MBIM QMUX support available", ctx->self->priv->path_display);
> + g_warning ("[%s] requested MBIM mode but no MBIM QMUX support available", self->priv->path_display);
>
> #endif /* MBIM_QMUX_ENABLED */
>
> /* QMI mode requested? */
> - if (g_strcmp0 (ctx->driver, "qmi_wwan") && !ctx->self->priv->no_file_check)
> + if (g_strcmp0 (ctx->driver, "qmi_wwan") && !self->priv->no_file_check)
> g_warning ("[%s] requested QMI mode but unexpected driver found: %s",
> - ctx->self->priv->path_display, ctx->driver ? ctx->driver : "unknown");
> + self->priv->path_display, ctx->driver ? ctx->driver : "unknown");
>
> #if defined MBIM_QMUX_ENABLED
> next_step:
> @@ -2179,7 +2212,7 @@ device_open_context_step (DeviceOpenContext *ctx)
> #if defined MBIM_QMUX_ENABLED
> case DEVICE_OPEN_CONTEXT_STEP_DEVICE_MBIM:
> if (ctx->flags & QMI_DEVICE_OPEN_FLAGS_MBIM) {
> - create_mbim_device (ctx);
> + create_mbim_device (task);
> return;
> }
> ctx->step++;
> @@ -2187,7 +2220,7 @@ device_open_context_step (DeviceOpenContext *ctx)
>
> case DEVICE_OPEN_CONTEXT_STEP_OPEN_DEVICE_MBIM:
> if (ctx->flags & QMI_DEVICE_OPEN_FLAGS_MBIM) {
> - open_mbim_device (ctx);
> + open_mbim_device (task);
> return;
> }
> ctx->step++;
> @@ -2196,10 +2229,10 @@ device_open_context_step (DeviceOpenContext *ctx)
>
> case DEVICE_OPEN_CONTEXT_STEP_CREATE_IOSTREAM:
> if (!(ctx->flags & QMI_DEVICE_OPEN_FLAGS_MBIM)) {
> - create_iostream (ctx->self,
> + create_iostream (self,
> !!(ctx->flags & QMI_DEVICE_OPEN_FLAGS_PROXY),
> (GAsyncReadyCallback)create_iostream_ready,
> - ctx);
> + task);
> return;
> }
> ctx->step++;
> @@ -2211,13 +2244,13 @@ device_open_context_step (DeviceOpenContext *ctx)
> QmiMessageCtlInternalProxyOpenInput *input;
>
> input = qmi_message_ctl_internal_proxy_open_input_new ();
> - qmi_message_ctl_internal_proxy_open_input_set_device_path (input, ctx->self->priv->path, NULL);
> - qmi_client_ctl_internal_proxy_open (ctx->self->priv->client_ctl,
> + qmi_message_ctl_internal_proxy_open_input_set_device_path (input, self->priv->path, NULL);
> + qmi_client_ctl_internal_proxy_open (self->priv->client_ctl,
> input,
> 5,
> - ctx->cancellable,
> + g_task_get_cancellable (task),
> (GAsyncReadyCallback)internal_proxy_open_ready,
> - ctx);
> + task);
> qmi_message_ctl_internal_proxy_open_input_unref (input);
> return;
> }
> @@ -2230,14 +2263,14 @@ device_open_context_step (DeviceOpenContext *ctx)
> /* Setup how many times to retry... We'll retry once per second */
> ctx->version_check_retries = ctx->timeout > 0 ? ctx->timeout : 1;
> g_debug ("[%s] Checking version info (%u retries)...",
> - ctx->self->priv->path_display,
> + self->priv->path_display,
> ctx->version_check_retries);
> - qmi_client_ctl_get_version_info (ctx->self->priv->client_ctl,
> + qmi_client_ctl_get_version_info (self->priv->client_ctl,
> NULL,
> 1,
> - ctx->cancellable,
> + g_task_get_cancellable (task),
> (GAsyncReadyCallback)open_version_info_ready,
> - ctx);
> + task);
> return;
> }
> ctx->step++;
> @@ -2247,13 +2280,13 @@ device_open_context_step (DeviceOpenContext *ctx)
> /* Sync? */
> if (ctx->flags & QMI_DEVICE_OPEN_FLAGS_SYNC) {
> g_debug ("[%s] Running sync...",
> - ctx->self->priv->path_display);
> - qmi_client_ctl_sync (ctx->self->priv->client_ctl,
> + self->priv->path_display);
> + qmi_client_ctl_sync (self->priv->client_ctl,
> NULL,
> ctx->timeout,
> - ctx->cancellable,
> + g_task_get_cancellable (task),
> (GAsyncReadyCallback)sync_ready,
> - ctx);
> + task);
> return;
> }
> ctx->step++;
> @@ -2267,7 +2300,7 @@ device_open_context_step (DeviceOpenContext *ctx)
> QmiCtlDataLinkProtocol link_protocol = QMI_CTL_DATA_LINK_PROTOCOL_802_3;
>
> g_debug ("[%s] Setting network port data format...",
> - ctx->self->priv->path_display);
> + self->priv->path_display);
>
> input = qmi_message_ctl_set_data_format_input_new ();
>
> @@ -2279,12 +2312,12 @@ device_open_context_step (DeviceOpenContext *ctx)
> link_protocol = QMI_CTL_DATA_LINK_PROTOCOL_RAW_IP;
> qmi_message_ctl_set_data_format_input_set_protocol (input, link_protocol, NULL);
>
> - qmi_client_ctl_set_data_format (ctx->self->priv->client_ctl,
> + qmi_client_ctl_set_data_format (self->priv->client_ctl,
> input,
> 5,
> NULL,
> (GAsyncReadyCallback)ctl_set_data_format_ready,
> - ctx);
> + task);
> qmi_message_ctl_set_data_format_input_unref (input);
> return;
> }
> @@ -2293,8 +2326,8 @@ device_open_context_step (DeviceOpenContext *ctx)
>
> case DEVICE_OPEN_CONTEXT_STEP_LAST:
> /* Nothing else to process, done we are */
> - g_simple_async_result_set_op_res_gboolean (ctx->result, TRUE);
> - device_open_context_complete_and_free (ctx);
> + g_task_return_boolean (task, TRUE);
> + g_object_unref (task);
> return;
>
> default:
> @@ -2314,6 +2347,7 @@ qmi_device_open (QmiDevice *self,
> {
> DeviceOpenContext *ctx;
> gchar *flags_str;
> + GTask *task;
>
> /* Raw IP and 802.3 are mutually exclusive */
> g_return_if_fail (!((flags & QMI_DEVICE_OPEN_FLAGS_NET_802_3) &&
> @@ -2336,18 +2370,15 @@ qmi_device_open (QmiDevice *self,
> g_free (flags_str);
>
> ctx = g_slice_new (DeviceOpenContext);
> - ctx->self = g_object_ref (self);
> - ctx->result = g_simple_async_result_new (G_OBJECT (self),
> - callback,
> - user_data,
> - qmi_device_open);
> ctx->step = DEVICE_OPEN_CONTEXT_STEP_FIRST;
> ctx->flags = flags;
> ctx->timeout = timeout;
> - ctx->cancellable = (cancellable ? g_object_ref (cancellable) : NULL);
> +
> + task = g_task_new (self, cancellable, callback, user_data);
> + g_task_set_task_data (task, ctx, (GDestroyNotify)device_open_context_free);
>
> /* Start processing */
> - device_open_context_step (ctx);
> + device_open_step (task);
> }
>
> /*****************************************************************************/
>
--
Aleksander
https://aleksander.es
More information about the libqmi-devel
mailing list