broadband-modem-mbim: port remaining code to use GTask

This patch ports the following functions in MMBroadbandModemMbim to use GTask:
- common_enable_disable_unsolicited_events
- common_setup_cleanup_unsolicited_events
- load_initial_sms_parts
- modem_3gpp_load_enabled_facility_locks
- modem_3gpp_register_in_network
- modem_3gpp_run_registration_checks
- modem_3gpp_scan_networks
- modem_load_current_capabilities
- modem_load_own_numbers
- modem_load_power_state
- modem_load_unlock_required
- modem_load_unlock_retries
- modem_power_down
- modem_power_up

1 files changed, 311 insertions, 358 deletions

diff --git a/src/mm-broadband-modem-mbim.c b/src/mm-broadband-modem-mbim.c
index 613e2425..1b5682e9 100644
--- a/src/mm-broadband-modem-mbim.c
+++ b/src/mm-broadband-modem-mbim.c
@@ -102,12 +102,13 @@ peek_device (gpointer self,
 
     port = mm_base_modem_peek_port_mbim (MM_BASE_MODEM (self));
     if (!port) {
-        g_simple_async_report_error_in_idle (G_OBJECT (self),
-                                             callback,
-                                             user_data,
-                                             MM_CORE_ERROR,
-                                             MM_CORE_ERROR_FAILED,
-                                             "Couldn't peek MBIM port");
+        g_task_report_new_error (self,
+                                 callback,
+                                 user_data,
+                                 peek_device,
+                                 MM_CORE_ERROR,
+                                 MM_CORE_ERROR_FAILED,
+                                 "Couldn't peek MBIM port");
         return FALSE;
     }
 
@@ -118,88 +119,72 @@ peek_device (gpointer self,
 /*****************************************************************************/
 /* Current Capabilities loading (Modem interface) */
 
-typedef struct {
-    MMBroadbandModemMbim *self;
-    GSimpleAsyncResult *result;
-} LoadCapabilitiesContext;
-
-static void
-load_capabilities_context_complete_and_free (LoadCapabilitiesContext *ctx)
-{
-    g_simple_async_result_complete (ctx->result);
-    g_object_unref (ctx->result);
-    g_object_unref (ctx->self);
-    g_slice_free (LoadCapabilitiesContext, ctx);
-}
-
 static MMModemCapability
 modem_load_current_capabilities_finish (MMIfaceModem *self,
                                         GAsyncResult *res,
                                         GError **error)
 {
-    MMModemCapability caps;
-    gchar *caps_str;
+    GError *inner_error = NULL;
+    gssize value;
 
-    if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (res), error))
+    value = g_task_propagate_int (G_TASK (res), &inner_error);
+    if (inner_error) {
+        g_propagate_error (error, inner_error);
         return MM_MODEM_CAPABILITY_NONE;
-
-    caps = ((MMModemCapability) GPOINTER_TO_UINT (
-                g_simple_async_result_get_op_res_gpointer (
-                    G_SIMPLE_ASYNC_RESULT (res))));
-    caps_str = mm_modem_capability_build_string_from_mask (caps);
-    mm_dbg ("loaded modem capabilities: %s", caps_str);
-    g_free (caps_str);
-    return caps;
+    }
+    return (MMModemCapability)value;
 }
 
 static void
 device_caps_query_ready (MbimDevice *device,
                          GAsyncResult *res,
-                         LoadCapabilitiesContext *ctx)
+                         GTask *task)
 {
+    MMBroadbandModemMbim *self;
     MMModemCapability mask;
     MbimMessage *response;
     GError *error = NULL;
 
+    self = g_task_get_source_object (task);
+
     response = mbim_device_command_finish (device, res, &error);
     if (response &&
         mbim_message_response_get_result (response, MBIM_MESSAGE_TYPE_COMMAND_DONE, &error) &&
         mbim_message_device_caps_response_parse (
             response,
             NULL, /* device_type */
-            &ctx->self->priv->caps_cellular_class,
+            &self->priv->caps_cellular_class,
             NULL, /* voice_class */
             NULL, /* sim_class */
-            &ctx->self->priv->caps_data_class,
-            &ctx->self->priv->caps_sms,
+            &self->priv->caps_data_class,
+            &self->priv->caps_sms,
             NULL, /* ctrl_caps */
-            &ctx->self->priv->caps_max_sessions,
+            &self->priv->caps_max_sessions,
             NULL, /* custom_data_class */
-            &ctx->self->priv->caps_device_id,
-            &ctx->self->priv->caps_firmware_info,
+            &self->priv->caps_device_id,
+            &self->priv->caps_firmware_info,
             NULL, /* hardware_info */
             &error)) {
         /* Build mask of modem capabilities */
         mask = 0;
-        if (ctx->self->priv->caps_cellular_class & MBIM_CELLULAR_CLASS_GSM)
+        if (self->priv->caps_cellular_class & MBIM_CELLULAR_CLASS_GSM)
             mask |= MM_MODEM_CAPABILITY_GSM_UMTS;
 
 #if 0  /* Disable until we add MBIM CDMA support */
-        if (ctx->self->priv->caps_cellular_class & MBIM_CELLULAR_CLASS_CDMA)
+        if (self->priv->caps_cellular_class & MBIM_CELLULAR_CLASS_CDMA)
             mask |= MM_MODEM_CAPABILITY_CDMA_EVDO;
 #endif
 
-        if (ctx->self->priv->caps_data_class & MBIM_DATA_CLASS_LTE)
+        if (self->priv->caps_data_class & MBIM_DATA_CLASS_LTE)
             mask |= MM_MODEM_CAPABILITY_LTE;
-        g_simple_async_result_set_op_res_gpointer (ctx->result,
-                                                   GUINT_TO_POINTER (mask),
-                                                   NULL);
+        g_task_return_int (task, mask);
     } else
-        g_simple_async_result_take_error (ctx->result, error);
+        g_task_return_error (task, error);
+
+    g_object_unref (task);
 
     if (response)
         mbim_message_unref (response);
-    load_capabilities_context_complete_and_free (ctx);
 }
 
 static void
@@ -207,19 +192,14 @@ modem_load_current_capabilities (MMIfaceModem *self,
                                  GAsyncReadyCallback callback,
                                  gpointer user_data)
 {
-    LoadCapabilitiesContext *ctx;
     MbimDevice *device;
     MbimMessage *message;
+    GTask *task;
 
     if (!peek_device (self, &device, callback, user_data))
         return;
 
-    ctx = g_slice_new (LoadCapabilitiesContext);
-    ctx->self = g_object_ref (self);
-    ctx->result = g_simple_async_result_new (G_OBJECT (self),
-                                             callback,
-                                             user_data,
-                                             modem_load_current_capabilities);
+    task = g_task_new (self, NULL, callback, user_data);
 
     mm_dbg ("loading current capabilities...");
     message = mbim_message_device_caps_query_new (NULL);
@@ -228,7 +208,7 @@ modem_load_current_capabilities (MMIfaceModem *self,
                          10,
                          NULL,
                          (GAsyncReadyCallback)device_caps_query_ready,
-                         ctx);
+                         task);
     mbim_message_unref (message);
 }
 
@@ -485,19 +465,14 @@ modem_load_supported_ip_families (MMIfaceModem *self,
 /* Unlock required loading (Modem interface) */
 
 typedef struct {
-    MMBroadbandModemMbim *self;
-    GSimpleAsyncResult *result;
     guint n_ready_status_checks;
     MbimDevice *device;
 } LoadUnlockRequiredContext;
 
 static void
-load_unlock_required_context_complete_and_free (LoadUnlockRequiredContext *ctx)
+load_unlock_required_context_free (LoadUnlockRequiredContext *ctx)
 {
-    g_simple_async_result_complete (ctx->result);
-    g_object_unref (ctx->result);
     g_object_unref (ctx->device);
-    g_object_unref (ctx->self);
     g_slice_free (LoadUnlockRequiredContext, ctx);
 }
 
@@ -506,16 +481,21 @@ modem_load_unlock_required_finish (MMIfaceModem *self,
                                    GAsyncResult *res,
                                    GError **error)
 {
-    if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (res), error))
-        return MM_MODEM_LOCK_UNKNOWN;
+    GError *inner_error = NULL;
+    gssize value;
 
-    return (MMModemLock) GPOINTER_TO_UINT (g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (res)));
+    value = g_task_propagate_int (G_TASK (res), &inner_error);
+    if (inner_error) {
+        g_propagate_error (error, inner_error);
+        return MM_MODEM_LOCK_UNKNOWN;
+    }
+    return (MMModemLock)value;
 }
 
 static void
 pin_query_ready (MbimDevice *device,
                  GAsyncResult *res,
-                 LoadUnlockRequiredContext *ctx)
+                 GTask *task)
 {
     MbimMessage *response;
     GError *error = NULL;
@@ -537,36 +517,37 @@ pin_query_ready (MbimDevice *device,
             unlock_required = MM_MODEM_LOCK_NONE;
         else
             unlock_required = mm_modem_lock_from_mbim_pin_type (pin_type);
-        g_simple_async_result_set_op_res_gpointer (ctx->result,
-                                                   GUINT_TO_POINTER (unlock_required),
-                                                   NULL);
+
+        g_task_return_int (task, unlock_required);
     }
     /* VZ20M reports an error when SIM-PIN is required... */
     else if (g_error_matches (error, MBIM_STATUS_ERROR, MBIM_STATUS_ERROR_PIN_REQUIRED)) {
         g_error_free (error);
-        g_simple_async_result_set_op_res_gpointer (ctx->result,
-                                                   GUINT_TO_POINTER (MBIM_PIN_TYPE_PIN1),
-                                                   NULL);
+        g_task_return_int (task, MBIM_PIN_TYPE_PIN1);
     }
     else
-        g_simple_async_result_take_error (ctx->result, error);
+        g_task_return_error (task, error);
+
+    g_object_unref (task);
 
     if (response)
         mbim_message_unref (response);
-    load_unlock_required_context_complete_and_free (ctx);
 }
 
-static gboolean wait_for_sim_ready (LoadUnlockRequiredContext *ctx);
+static gboolean wait_for_sim_ready (GTask *task);
 
 static void
 unlock_required_subscriber_ready_state_ready (MbimDevice *device,
                                               GAsyncResult *res,
-                                              LoadUnlockRequiredContext *ctx)
+                                              GTask *task)
 {
+    LoadUnlockRequiredContext *ctx;
     MbimMessage *response;
     GError *error = NULL;
     MbimSubscriberReadyState ready_state = MBIM_SUBSCRIBER_READY_STATE_NOT_INITIALIZED;
 
+    ctx = g_task_get_task_data (task);
+
     response = mbim_device_command_finish (device, res, &error);
     if (response &&
         mbim_message_response_get_result (response, MBIM_MESSAGE_TYPE_COMMAND_DONE, &error) &&
@@ -602,8 +583,8 @@ unlock_required_subscriber_ready_state_ready (MbimDevice *device,
 
     /* Fatal errors are reported right away */
     if (error) {
-        g_simple_async_result_take_error (ctx->result, error);
-        load_unlock_required_context_complete_and_free (ctx);
+        g_task_return_error (task, error);
+        g_object_unref (task);
     }
     /* Need to retry? */
     else if (ready_state == MBIM_SUBSCRIBER_READY_STATE_NOT_INITIALIZED ||
@@ -611,18 +592,18 @@ unlock_required_subscriber_ready_state_ready (MbimDevice *device,
         if (--ctx->n_ready_status_checks == 0) {
             /* All retries consumed, issue error */
             if (ready_state == MBIM_SUBSCRIBER_READY_STATE_SIM_NOT_INSERTED)
-                g_simple_async_result_take_error (
-                    ctx->result,
+                g_task_return_error (
+                    task,
                     mm_mobile_equipment_error_for_code (MM_MOBILE_EQUIPMENT_ERROR_SIM_NOT_INSERTED));
             else
-                g_simple_async_result_set_error (ctx->result,
-                                                 MM_CORE_ERROR,
-                                                 MM_CORE_ERROR_FAILED,
-                                                 "Error waiting for SIM to get initialized");
-            load_unlock_required_context_complete_and_free (ctx);
+                g_task_return_new_error (task,
+                                         MM_CORE_ERROR,
+                                         MM_CORE_ERROR_FAILED,
+                                         "Error waiting for SIM to get initialized");
+            g_object_unref (task);
         } else {
             /* Retry */
-            g_timeout_add_seconds (1, (GSourceFunc)wait_for_sim_ready, ctx);
+            g_timeout_add_seconds (1, (GSourceFunc)wait_for_sim_ready, task);
         }
     }
     /* Initialized but locked? */
@@ -636,15 +617,13 @@ unlock_required_subscriber_ready_state_ready (MbimDevice *device,
                              10,
                              NULL,
                              (GAsyncReadyCallback)pin_query_ready,
-                             ctx);
+                             task);
         mbim_message_unref (message);
     }
     /* Initialized but locked? */
     else if (ready_state == MBIM_SUBSCRIBER_READY_STATE_INITIALIZED) {
-        g_simple_async_result_set_op_res_gpointer (ctx->result,
-                                                   GUINT_TO_POINTER (MM_MODEM_LOCK_NONE),
-                                                   NULL);
-        load_unlock_required_context_complete_and_free (ctx);
+        g_task_return_boolean (task, TRUE);
+        g_object_unref (task);
     } else
         g_assert_not_reached ();
 
@@ -653,17 +632,19 @@ unlock_required_subscriber_ready_state_ready (MbimDevice *device,
 }
 
 static gboolean
-wait_for_sim_ready (LoadUnlockRequiredContext *ctx)
+wait_for_sim_ready (GTask *task)
 {
+    LoadUnlockRequiredContext *ctx;
     MbimMessage *message;
 
+    ctx = g_task_get_task_data (task);
     message = mbim_message_subscriber_ready_status_query_new (NULL);
     mbim_device_command (ctx->device,
                          message,
                          10,
                          NULL,
                          (GAsyncReadyCallback)unlock_required_subscriber_ready_state_ready,
-                         ctx);
+                         task);
     mbim_message_unref (message);
     return G_SOURCE_REMOVE;
 }
@@ -675,20 +656,19 @@ modem_load_unlock_required (MMIfaceModem *self,
 {
     LoadUnlockRequiredContext *ctx;
     MbimDevice *device;
+    GTask *task;
 
     if (!peek_device (self, &device, callback, user_data))
         return;
 
     ctx = g_slice_new (LoadUnlockRequiredContext);
-    ctx->self = g_object_ref (self);
     ctx->device = g_object_ref (device);
-    ctx->result = g_simple_async_result_new (G_OBJECT (self),
-                                        callback,
-                                        user_data,
-                                        modem_load_unlock_required);
     ctx->n_ready_status_checks = 10;
 
-    wait_for_sim_ready (ctx);
+    task = g_task_new (self, NULL, callback, user_data);
+    g_task_set_task_data (task, ctx, (GDestroyNotify)load_unlock_required_context_free);
+
+    wait_for_sim_ready (task);
 }
 
 /*****************************************************************************/
@@ -699,16 +679,13 @@ modem_load_unlock_retries_finish (MMIfaceModem *self,
                                   GAsyncResult *res,
                                   GError **error)
 {
-    if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (res), error))
-        return NULL;
-
-    return MM_UNLOCK_RETRIES (g_object_ref (g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (res))));
+    return g_task_propagate_pointer (G_TASK (res), error);
 }
 
 static void
 pin_query_unlock_retries_ready (MbimDevice *device,
                                 GAsyncResult *res,
-                                GSimpleAsyncResult *simple)
+                                GTask *task)
 {
     MbimMessage *response;
     GError *error = NULL;
@@ -734,14 +711,14 @@ pin_query_unlock_retries_ready (MbimDevice *device,
                                    mm_modem_lock_from_mbim_pin_type (pin_type),
                                    remaining_attempts);
         }
-        g_simple_async_result_set_op_res_gpointer (simple, retries, g_object_unref);
+        g_task_return_pointer (task, retries, g_object_unref);
     } else
-        g_simple_async_result_take_error (simple, error);
+        g_task_return_error (task, error);
+
+    g_object_unref (task);
 
     if (response)
         mbim_message_unref (response);
-    g_simple_async_result_complete (simple);
-    g_object_unref (simple);
 }
 
 static void
@@ -749,17 +726,14 @@ modem_load_unlock_retries (MMIfaceModem *self,
                            GAsyncReadyCallback callback,
                            gpointer user_data)
 {
-    GSimpleAsyncResult *result;
     MbimDevice *device;
     MbimMessage *message;
+    GTask *task;
 
     if (!peek_device (self, &device, callback, user_data))
         return;
 
-    result = g_simple_async_result_new (G_OBJECT (self),
-                                        callback,
-                                        user_data,
-                                        modem_load_unlock_retries);
+    task = g_task_new (self, NULL, callback, user_data);
 
     message = mbim_message_pin_query_new (NULL);
     mbim_device_command (device,
@@ -767,7 +741,7 @@ modem_load_unlock_retries (MMIfaceModem *self,
                          10,
                          NULL,
                          (GAsyncReadyCallback)pin_query_unlock_retries_ready,
-                         result);
+                         task);
     mbim_message_unref (message);
 }
 
@@ -779,16 +753,13 @@ modem_load_own_numbers_finish (MMIfaceModem *self,
                                GAsyncResult *res,
                                GError **error)
 {
-    if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (res), error))
-        return NULL;
-
-    return g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (res));
+    return g_task_propagate_pointer (G_TASK (res), error);
 }
 
 static void
 own_numbers_subscriber_ready_state_ready (MbimDevice *device,
                                           GAsyncResult *res,
-                                          GSimpleAsyncResult *simple)
+                                          GTask *task)
 {
     MbimMessage *response;
     GError *error = NULL;
@@ -806,14 +777,14 @@ own_numbers_subscriber_ready_state_ready (MbimDevice *device,
             NULL, /* telephone_numbers_count */
             &telephone_numbers,
             &error)) {
-        g_simple_async_result_set_op_res_gpointer (simple, telephone_numbers, NULL);
+        g_task_return_pointer (task, telephone_numbers, (GDestroyNotify)g_strfreev);
     } else
-        g_simple_async_result_take_error (simple, error);
+        g_task_return_error (task, error);
+
+    g_object_unref (task);
 
     if (response)
         mbim_message_unref (response);
-    g_simple_async_result_complete (simple);
-    g_object_unref (simple);
 }
 
 static void
@@ -821,17 +792,14 @@ modem_load_own_numbers (MMIfaceModem *self,
                         GAsyncReadyCallback callback,
                         gpointer user_data)
 {
-    GSimpleAsyncResult *result;
     MbimDevice *device;
     MbimMessage *message;
+    GTask *task;
 
     if (!peek_device (self, &device, callback, user_data))
         return;
 
-    result = g_simple_async_result_new (G_OBJECT (self),
-                                        callback,
-                                        user_data,
-                                        modem_load_own_numbers);
+    task = g_task_new (self, NULL, callback, user_data);
 
     message = mbim_message_subscriber_ready_status_query_new (NULL);
     mbim_device_command (device,
@@ -839,7 +807,7 @@ modem_load_own_numbers (MMIfaceModem *self,
                          10,
                          NULL,
                          (GAsyncReadyCallback)own_numbers_subscriber_ready_state_ready,
-                         result);
+                         task);
     mbim_message_unref (message);
 }
 
@@ -851,16 +819,21 @@ modem_load_power_state_finish (MMIfaceModem *self,
                                GAsyncResult *res,
                                GError **error)
 {
-    if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (res), error))
-        return MM_MODEM_POWER_STATE_UNKNOWN;
+    GError *inner_error = NULL;
+    gssize value;
 
-    return (MMModemPowerState) GPOINTER_TO_UINT (g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (res)));
+    value = g_task_propagate_int (G_TASK (res), &inner_error);
+    if (inner_error) {
+        g_propagate_error (error, inner_error);
+        return MM_MODEM_POWER_STATE_UNKNOWN;
+    }
+    return (MMModemPowerState)value;
 }
 
 static void
 radio_state_query_ready (MbimDevice *device,
                          GAsyncResult *res,
-                         GSimpleAsyncResult *simple)
+                         GTask *task)
 {
     MbimMessage *response;
     GError *error = NULL;
@@ -882,16 +855,13 @@ radio_state_query_ready (MbimDevice *device,
             state = MM_MODEM_POWER_STATE_LOW;
         else
             state = MM_MODEM_POWER_STATE_ON;
-        g_simple_async_result_set_op_res_gpointer (simple,
-                                                   GUINT_TO_POINTER (state),
-                                                   NULL);
+        g_task_return_int (task, state);
     } else
-        g_simple_async_result_take_error (simple, error);
+        g_task_return_error (task, error);
+    g_object_unref (task);
 
     if (response)
         mbim_message_unref (response);
-    g_simple_async_result_complete (simple);
-    g_object_unref (simple);
 }
 
 static void
@@ -899,17 +869,14 @@ modem_load_power_state (MMIfaceModem *self,
                         GAsyncReadyCallback callback,
                         gpointer user_data)
 {
-    GSimpleAsyncResult *result;
     MbimDevice *device;
     MbimMessage *message;
+    GTask *task;
 
     if (!peek_device (self, &device, callback, user_data))
         return;
 
-    result = g_simple_async_result_new (G_OBJECT (self),
-                                        callback,
-                                        user_data,
-                                        modem_load_power_state);
+    task = g_task_new (self, NULL, callback, user_data);
 
     message = mbim_message_radio_state_query_new (NULL);
     mbim_device_command (device,
@@ -917,7 +884,7 @@ modem_load_power_state (MMIfaceModem *self,
                          10,
                          NULL,
                          (GAsyncReadyCallback)radio_state_query_ready,
-                         result);
+                         task);
     mbim_message_unref (message);
 }
 
@@ -938,9 +905,7 @@ typedef enum {
 } PowerUpContextStep;
 
 typedef struct {
-    MMBroadbandModemMbim *self;
     MbimDevice *device;
-    GSimpleAsyncResult *result;
     PowerUpContextStep step;
 #if defined WITH_QMI && QMI_MBIM_QMUX_SUPPORTED
     QmiDevice *qmi_device;
@@ -950,7 +915,7 @@ typedef struct {
 } PowerUpContext;
 
 static void
-power_up_context_complete_and_free (PowerUpContext *ctx)
+power_up_context_free (PowerUpContext *ctx)
 {
 #if defined WITH_QMI && QMI_MBIM_QMUX_SUPPORTED
     if (ctx->qmi_device) {
@@ -966,10 +931,7 @@ power_up_context_complete_and_free (PowerUpContext *ctx)
     if (ctx->saved_error)
         g_error_free (ctx->saved_error);
 #endif
-    g_simple_async_result_complete (ctx->result);
-    g_object_unref (ctx->result);
     g_object_unref (ctx->device);
-    g_object_unref (ctx->self);
     g_slice_free (PowerUpContext, ctx);
 }
 
@@ -978,20 +940,23 @@ power_up_finish (MMIfaceModem *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 power_up_context_step (PowerUpContext *ctx);
+static void power_up_context_step (GTask *task);
 
 #if defined WITH_QMI && QMI_MBIM_QMUX_SUPPORTED
 
 static void
-release_qmi_client_dms_ready (QmiDevice      *dev,
-                              GAsyncResult   *res,
-                              PowerUpContext *ctx)
+release_qmi_client_dms_ready (QmiDevice *dev,
+                              GAsyncResult *res,
+                              GTask *task)
 {
+    PowerUpContext *ctx;
     GError *error = NULL;
 
+    ctx = g_task_get_task_data (task);
+
     /* Non-fatal error */
     if (!qmi_device_release_client_finish (dev, res, &error)) {
         mm_dbg ("error: couldn't release client: %s", error->message);
@@ -999,42 +964,47 @@ release_qmi_client_dms_ready (QmiDevice      *dev,
     }
 
     ctx->step++;
-    power_up_context_step (ctx);
+    power_up_context_step (task);
 }
 
 static void
-set_radio_state_release_qmi_client_dms (PowerUpContext *ctx)
+set_radio_state_release_qmi_client_dms (GTask *task)
 {
+    PowerUpContext *ctx;
+
+    ctx = g_task_get_task_data (task);
     qmi_device_release_client (ctx->qmi_device,
                                ctx->qmi_client,
                                QMI_DEVICE_RELEASE_CLIENT_FLAGS_RELEASE_CID,
                                10,
                                NULL,
                                (GAsyncReadyCallback)release_qmi_client_dms_ready,
-                               ctx);
+                               task);
 }
 
 static void
-set_fcc_authentication_ready (QmiClientDms   *client,
-                              GAsyncResult   *res,
-                              PowerUpContext *ctx)
+set_fcc_authentication_ready (QmiClientDms *client,
+                              GAsyncResult *res,
+                              GTask *task)
 {
+    PowerUpContext *ctx;
     QmiMessageDmsSetFccAuthenticationOutput *output;
     GError *error = NULL;
 
+    ctx = g_task_get_task_data (task);
     output = qmi_client_dms_set_fcc_authentication_finish (client, res, &error);
     if (!output || !qmi_message_dms_set_fcc_authentication_output_get_result (output, &error)) {
         mm_dbg ("error: couldn't set FCC auth: %s", error->message);
         g_error_free (error);
         g_assert (ctx->saved_error);
-        g_simple_async_result_take_error (ctx->result, ctx->saved_error);
+        g_task_return_error (task, ctx->saved_error);
         ctx->saved_error = NULL;
-        power_up_context_complete_and_free (ctx);
+        g_object_unref (task);
         goto out;
     }
 
     ctx->step++;
-    power_up_context_step (ctx);
+    power_up_context_step (task);
 
 out:
     if (output)
@@ -1042,41 +1012,49 @@ out:
 }
 
 static void
-set_radio_state_fcc_auth (PowerUpContext *ctx)
+set_radio_state_fcc_auth (GTask *task)
 {
+    PowerUpContext *ctx;
+
+    ctx = g_task_get_task_data (task);
     qmi_client_dms_set_fcc_authentication (QMI_CLIENT_DMS (ctx->qmi_client),
                                            NULL,
                                            10,
                                            NULL, /* cancellable */
                                            (GAsyncReadyCallback)set_fcc_authentication_ready,
-                                           ctx);
+                                           task);
 }
 
 static void
-qmi_client_dms_ready (QmiDevice      *dev,
-                      GAsyncResult   *res,
-                      PowerUpContext *ctx)
+qmi_client_dms_ready (QmiDevice *dev,
+                      GAsyncResult *res,
+                      GTask *task)
 {
+    PowerUpContext *ctx;
     GError *error = NULL;
 
+    ctx = g_task_get_task_data (task);
     ctx->qmi_client = qmi_device_allocate_client_finish (dev, res, &error);
     if (!ctx->qmi_client) {
         mm_dbg ("error: couldn't create DMS client: %s", error->message);
         g_error_free (error);
         g_assert (ctx->saved_error);
-        g_simple_async_result_take_error (ctx->result, ctx->saved_error);
+        g_task_return_error (task, ctx->saved_error);
         ctx->saved_error = NULL;
-        power_up_context_complete_and_free (ctx);
+        g_object_unref (task);
         return;
     }
 
     ctx->step++;
-    power_up_context_step (ctx);
+    power_up_context_step (task);
 }
 
 static void
-set_radio_state_allocate_qmi_client_dms (PowerUpContext *ctx)
+set_radio_state_allocate_qmi_client_dms (GTask *task)
 {
+    PowerUpContext *ctx;
+
+    ctx = g_task_get_task_data (task);
     g_assert (ctx->qmi_device);
     qmi_device_allocate_client (ctx->qmi_device,
                                 QMI_SERVICE_DMS,
@@ -1084,90 +1062,101 @@ set_radio_state_allocate_qmi_client_dms (PowerUpContext *ctx)
                                 10,
                                 NULL, /* cancellable */
                                 (GAsyncReadyCallback) qmi_client_dms_ready,
-                                ctx);
+                                task);
 }
 
 static void
-device_open_ready (QmiDevice      *dev,
-                   GAsyncResult   *res,
-                   PowerUpContext *ctx)
+device_open_ready (QmiDevice *dev,
+                   GAsyncResult *res,
+                   GTask *task)
 {
+    PowerUpContext *ctx;
     GError *error = NULL;
 
+    ctx = g_task_get_task_data (task);
     if (!qmi_device_open_finish (dev, res, &error)) {
         mm_dbg ("error: couldn't open QmiDevice: %s", error->message);
         g_error_free (error);
         g_assert (ctx->saved_error);
-        g_simple_async_result_take_error (ctx->result, ctx->saved_error);
+        g_task_return_error (task, ctx->saved_error);
         ctx->saved_error = NULL;
-        power_up_context_complete_and_free (ctx);
+        g_object_unref (task);
         return;
     }
 
     ctx->step++;
-    power_up_context_step (ctx);
+    power_up_context_step (task);
 }
 
 static void
-set_radio_state_qmi_device_open (PowerUpContext *ctx)
+set_radio_state_qmi_device_open (GTask *task)
 {
+    PowerUpContext *ctx;
+
     /* Open the device */
+    ctx = g_task_get_task_data (task);
     g_assert (ctx->qmi_device);
     qmi_device_open (ctx->qmi_device,
                      (QMI_DEVICE_OPEN_FLAGS_PROXY | QMI_DEVICE_OPEN_FLAGS_MBIM),
                      15,
                      NULL, /* cancellable */
                      (GAsyncReadyCallback)device_open_ready,
-                     ctx);
+                     task);
 }
 
 static void
-qmi_device_new_ready (GObject        *unused,
-                      GAsyncResult   *res,
-                      PowerUpContext *ctx)
+qmi_device_new_ready (GObject *unused,
+                      GAsyncResult *res,
+                      GTask *task)
 {
+    PowerUpContext *ctx;
     GError *error = NULL;
 
+    ctx = g_task_get_task_data (task);
     ctx->qmi_device = qmi_device_new_finish (res, &error);
     if (!ctx->qmi_device) {
         mm_dbg ("error: couldn't create QmiDevice: %s", error->message);
         g_error_free (error);
         g_assert (ctx->saved_error);
-        g_simple_async_result_take_error (ctx->result, ctx->saved_error);
+        g_task_return_error (task, ctx->saved_error);
         ctx->saved_error = NULL;
-        power_up_context_complete_and_free (ctx);
+        g_object_unref (task);
         return;
     }
 
     ctx->step++;
-    power_up_context_step (ctx);
+    power_up_context_step (task);
 }
 
 static void
-set_radio_state_qmi_device_new (PowerUpContext *ctx)
+set_radio_state_qmi_device_new (GTask *task)
 {
+    PowerUpContext *ctx;
     GFile *file;
 
+    ctx = g_task_get_task_data (task);
     file = mbim_device_get_file (ctx->device);
     qmi_device_new (file,
                     NULL, /* cancellable */
                     (GAsyncReadyCallback) qmi_device_new_ready,
-                    ctx);
+                    task);
     g_object_unref (file);
 }
 
 #endif
 
 static void
-radio_state_set_up_ready (MbimDevice     *device,
-                          GAsyncResult   *res,
-                          PowerUpContext *ctx)
+radio_state_set_up_ready (MbimDevice *device,
+                          GAsyncResult *res,
+                          GTask *task)
 {
+    PowerUpContext *ctx;
     MbimMessage *response;
     GError *error = NULL;
     MbimRadioSwitchState hardware_radio_state;
     MbimRadioSwitchState software_radio_state;
 
+    ctx = g_task_get_task_data (task);
     response = mbim_device_command_finish (device, res, &error);
     if (response &&
         mbim_message_response_get_result (response, MBIM_MESSAGE_TYPE_COMMAND_DONE, &error) &&
@@ -1192,7 +1181,7 @@ radio_state_set_up_ready (MbimDevice     *device,
     /* Nice! we're done, quick exit */
     if (!error) {
         ctx->step = POWER_UP_CONTEXT_STEP_LAST;
-        power_up_context_step (ctx);
+        power_up_context_step (task);
         return;
     }
 
@@ -1204,71 +1193,77 @@ radio_state_set_up_ready (MbimDevice     *device,
         g_assert (!ctx->saved_error);
         ctx->saved_error = error;
         ctx->step++;
-        power_up_context_step (ctx);
+        power_up_context_step (task);
         return;
     }
 #endif
 
     /* Fatal */
-    g_simple_async_result_take_error (ctx->result, error);
-    power_up_context_complete_and_free (ctx);
+    g_task_return_error (task, error);
+    g_object_unref (task);
 }
 
 static void
-set_radio_state_up (PowerUpContext *ctx)
+set_radio_state_up (GTask *task)
 {
+    PowerUpContext *ctx;
     MbimMessage *message;
 
+    ctx = g_task_get_task_data (task);
     message = mbim_message_radio_state_set_new (MBIM_RADIO_SWITCH_STATE_ON, NULL);
     mbim_device_command (ctx->device,
                          message,
                          20,
                          NULL,
                          (GAsyncReadyCallback)radio_state_set_up_ready,
-                         ctx);
+                         task);
     mbim_message_unref (message);
 }
 
 static void
-power_up_context_step (PowerUpContext *ctx)
+power_up_context_step (GTask *task)
 {
+    PowerUpContext *ctx;
+
+    ctx = g_task_get_task_data (task);
+
     switch (ctx->step) {
     case POWER_UP_CONTEXT_STEP_FIRST:
-        set_radio_state_up (ctx);
+        set_radio_state_up (task);
         return;
 
 #if defined WITH_QMI && QMI_MBIM_QMUX_SUPPORTED
 
     case POWER_UP_CONTEXT_STEP_QMI_DEVICE_NEW:
-        set_radio_state_qmi_device_new (ctx);
+        set_radio_state_qmi_device_new (task);
         return;
 
     case POWER_UP_CONTEXT_STEP_QMI_DEVICE_OPEN:
-        set_radio_state_qmi_device_open (ctx);
+        set_radio_state_qmi_device_open (task);
         return;
 
     case POWER_UP_CONTEXT_STEP_ALLOCATE_QMI_CLIENT_DMS:
-        set_radio_state_allocate_qmi_client_dms (ctx);
+        set_radio_state_allocate_qmi_client_dms (task);
         return;
 
     case POWER_UP_CONTEXT_STEP_FCC_AUTH:
-        set_radio_state_fcc_auth (ctx);
+        set_radio_state_fcc_auth (task);
         return;
 
     case POWER_UP_CONTEXT_STEP_RELEASE_QMI_CLIENT_DMS:
-        set_radio_state_release_qmi_client_dms (ctx);
+        set_radio_state_release_qmi_client_dms (task);
         return;
 
     case POWER_UP_CONTEXT_STEP_RETRY:
-        set_radio_state_up (ctx);
+        set_radio_state_up (task);
         return;
 
 #endif
 
     case POWER_UP_CONTEXT_STEP_LAST:
         /* Good! */
-        g_simple_async_result_set_op_res_gboolean (ctx->result, TRUE);
-        power_up_context_complete_and_free (ctx);
+        g_task_return_boolean (task, TRUE);
+        g_object_unref (task);
         return;
 
     default:
@@ -1283,19 +1278,19 @@ modem_power_up (MMIfaceModem *self,
 {
     PowerUpContext *ctx;
     MbimDevice *device;
+    GTask *task;
 
     if (!peek_device (self, &device, callback, user_data))
         return;
 
     ctx = g_slice_new0 (PowerUpContext);
-    ctx->self = g_object_ref (self);
     ctx->device = g_object_ref (device);
     ctx->step = POWER_UP_CONTEXT_STEP_FIRST;
-    ctx->result = g_simple_async_result_new (G_OBJECT (self),
-                                             callback,
-                                             user_data,
-                                             modem_power_up);
-    power_up_context_step (ctx);
+
+    task = g_task_new (self, NULL, callback, user_data);
+    g_task_set_task_data (task, ctx, (GDestroyNotify)power_up_context_free);
+
+    power_up_context_step (task);
 }
 
 /*****************************************************************************/
@@ -1306,13 +1301,13 @@ power_down_finish (MMIfaceModem *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
-radio_state_set_down_ready (MbimDevice         *device,
-                            GAsyncResult       *res,
-                            GSimpleAsyncResult *simple)
+radio_state_set_down_ready (MbimDevice *device,
+                            GAsyncResult *res,
+                            GTask *task)
 {
     MbimMessage *response;
     GError *error = NULL;
@@ -1324,11 +1319,10 @@ radio_state_set_down_ready (MbimDevice         *device,
     }
 
     if (error)
-        g_simple_async_result_take_error (simple, error);
+        g_task_return_error (task, error);
     else
-        g_simple_async_result_set_op_res_gboolean (simple, TRUE);
-    g_simple_async_result_complete (simple);
-    g_object_unref (simple);
+        g_task_return_boolean (task, TRUE);
+    g_object_unref (task);
 }
 
 static void
@@ -1336,24 +1330,22 @@ modem_power_down (MMIfaceModem *self,
                   GAsyncReadyCallback callback,
                   gpointer user_data)
 {
-    GSimpleAsyncResult *simple;
     MbimDevice *device;
     MbimMessage *message;
+    GTask *task;
 
     if (!peek_device (self, &device, callback, user_data))
         return;
 
-    simple = g_simple_async_result_new (G_OBJECT (self),
-                                        callback,
-                                        user_data,
-                                        modem_power_down);
+    task = g_task_new (self, NULL, callback, user_data);
+
     message = mbim_message_radio_state_set_new (MBIM_RADIO_SWITCH_STATE_OFF, NULL);
     mbim_device_command (device,
                          message,
                          20,
                          NULL,
                          (GAsyncReadyCallback)radio_state_set_down_ready,
-                         simple);
+                         task);
     mbim_message_unref (message);
 }
 
@@ -1676,17 +1668,21 @@ modem_3gpp_load_enabled_facility_locks_finish (MMIfaceModem3gpp *self,
                                                GAsyncResult *res,
                                                GError **error)
 {
-    if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (res), error))
-        return MM_MODEM_3GPP_FACILITY_NONE;
+    GError *inner_error = NULL;
+    gssize value;
 
-    return ((MMModem3gppFacility) GPOINTER_TO_UINT (
-                g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (res))));
+    value = g_task_propagate_int (G_TASK (res), &inner_error);
+    if (inner_error) {
+        g_propagate_error (error, inner_error);
+        return MM_MODEM_3GPP_FACILITY_NONE;
+    }
+    return (MMModem3gppFacility)value;
 }
 
 static void
 pin_list_query_ready (MbimDevice *device,
                       GAsyncResult *res,
-                      GSimpleAsyncResult *simple)
+                      GTask *task)
 {
     MbimMessage *response;
     GError *error = NULL;
@@ -1749,16 +1745,14 @@ pin_list_query_ready (MbimDevice *device,
             mask |= MM_MODEM_3GPP_FACILITY_CORP_PERS;
         mbim_pin_desc_free (pin_desc_corporate_pin);
 
-        g_simple_async_result_set_op_res_gpointer (simple,
-                                                   GUINT_TO_POINTER (mask),
-                                                   NULL);
+        g_task_return_int (task, mask);
     } else
-        g_simple_async_result_take_error (simple, error);
+        g_task_return_error (task, error);
+
+    g_object_unref (task);
 
     if (response)
         mbim_message_unref (response);
-    g_simple_async_result_complete (simple);
-    g_object_unref (simple);
 }
 
 static void
@@ -1766,17 +1760,14 @@ modem_3gpp_load_enabled_facility_locks (MMIfaceModem3gpp *self,
                                         GAsyncReadyCallback callback,
                                         gpointer user_data)
 {
-    GSimpleAsyncResult *result;
     MbimDevice *device;
     MbimMessage *message;
+    GTask *task;
 
     if (!peek_device (self, &device, callback, user_data))
         return;
 
-    result = g_simple_async_result_new (G_OBJECT (self),
-                                        callback,
-                                        user_data,
-                                        modem_3gpp_load_enabled_facility_locks);
+    task = g_task_new (self, NULL, callback, user_data);
 
     message = mbim_message_pin_list_query_new (NULL);
     mbim_device_command (device,
@@ -1784,7 +1775,7 @@ modem_3gpp_load_enabled_facility_locks (MMIfaceModem3gpp *self,
                          10,
                          NULL,
                          (GAsyncReadyCallback)pin_list_query_ready,
-                         result);
+                         task);
     mbim_message_unref (message);
 }
 
@@ -2217,7 +2208,7 @@ common_setup_cleanup_unsolicited_events_finish (MMBroadbandModemMbim *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
@@ -2227,16 +2218,11 @@ common_setup_cleanup_unsolicited_events (MMBroadbandModemMbim *self,
                                          gpointer user_data)
 {
     MbimDevice *device;
-    GSimpleAsyncResult *result;
+    GTask *task;
 
     if (!peek_device (self, &device, callback, user_data))
         return;
 
-    result = g_simple_async_result_new (G_OBJECT (self),
-                                        callback,
-                                        user_data,
-                                        common_setup_cleanup_unsolicited_events);
-
     mm_dbg ("Supported notifications: signal (%s), registration (%s), sms (%s), connect (%s), subscriber (%s), packet (%s)",
             self->priv->setup_flags & PROCESS_NOTIFICATION_FLAG_SIGNAL_QUALITY ? "yes" : "no",
             self->priv->setup_flags & PROCESS_NOTIFICATION_FLAG_REGISTRATION_UPDATES ? "yes" : "no",
@@ -2263,8 +2249,9 @@ common_setup_cleanup_unsolicited_events (MMBroadbandModemMbim *self,
         }
     }
 
-    g_simple_async_result_complete_in_idle (result);
-    g_object_unref (result);
+    task = g_task_new (self, NULL, callback, user_data);
+    g_task_return_boolean (task, TRUE);
+    g_object_unref (task);
 }
 
 /*****************************************************************************/
@@ -2331,30 +2318,28 @@ common_enable_disable_unsolicited_events_finish (MMBroadbandModemMbim *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
 subscribe_list_set_ready_cb (MbimDevice *device,
                              GAsyncResult *res,
-                             GSimpleAsyncResult *simple)
+                             GTask *task)
 {
     MbimMessage *response;
     GError *error = NULL;
 
     response = mbim_device_command_finish (device, res, &error);
-    if (response)
+    if (response) {
         mbim_message_response_get_result (response, MBIM_MESSAGE_TYPE_COMMAND_DONE, &error);
+        mbim_message_unref (response);
+    }
 
     if (error)
-        g_simple_async_result_take_error (simple, error);
+        g_task_return_error (task, error);
     else
-        g_simple_async_result_set_op_res_gboolean (simple, TRUE);
-
-    if (response)
-        mbim_message_unref (response);
-    g_simple_async_result_complete (simple);
-    g_object_unref (simple);
+        g_task_return_boolean (task, TRUE);
+    g_object_unref (task);
 }
 
 static void
@@ -2364,18 +2349,13 @@ common_enable_disable_unsolicited_events (MMBroadbandModemMbim *self,
 {
     MbimMessage *request;
     MbimDevice *device;
-    GSimpleAsyncResult *result;
     MbimEventEntry **entries;
     guint n_entries = 0;
+    GTask *task;
 
     if (!peek_device (self, &device, callback, user_data))
         return;
 
-    result = g_simple_async_result_new (G_OBJECT (self),
-                                        callback,
-                                        user_data,
-                                        common_enable_disable_unsolicited_events);
-
     mm_dbg ("Enabled notifications: signal (%s), registration (%s), sms (%s), connect (%s), subscriber (%s), packet (%s)",
             self->priv->enable_flags & PROCESS_NOTIFICATION_FLAG_SIGNAL_QUALITY ? "yes" : "no",
             self->priv->enable_flags & PROCESS_NOTIFICATION_FLAG_REGISTRATION_UPDATES ? "yes" : "no",
@@ -2420,6 +2400,8 @@ common_enable_disable_unsolicited_events (MMBroadbandModemMbim *self,
         n_entries++;
     }
 
+    task = g_task_new (self, NULL, callback, user_data);
+
     request = (mbim_message_device_service_subscribe_list_set_new (
                    n_entries,
                    (const MbimEventEntry *const *)entries,
@@ -2429,7 +2411,7 @@ common_enable_disable_unsolicited_events (MMBroadbandModemMbim *self,
                          10,
                          NULL,
                          (GAsyncReadyCallback)subscribe_list_set_ready_cb,
-                         result);
+                         task);
     mbim_message_unref (request);
     mbim_event_entry_array_free (entries);
 }
@@ -2577,13 +2559,13 @@ modem_3gpp_run_registration_checks_finish (MMIfaceModem3gpp *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
 register_state_query_ready (MbimDevice *device,
                             GAsyncResult *res,
-                            GSimpleAsyncResult *simple)
+                            GTask *task)
 {
     MbimMessage *response;
     GError *error = NULL;
@@ -2609,22 +2591,21 @@ register_state_query_ready (MbimDevice *device,
             NULL)) {
         MMBroadbandModemMbim *self;
 
-        self = MM_BROADBAND_MODEM_MBIM (g_async_result_get_source_object (G_ASYNC_RESULT (simple)));
+        self = g_task_get_source_object (task);
         update_registration_info (self,
                                   register_state,
                                   available_data_classes,
                                   provider_id,
                                   provider_name);
-        g_object_unref (self);
 
-        g_simple_async_result_set_op_res_gboolean (simple, TRUE);
+        g_task_return_boolean (task, TRUE);
     } else
-        g_simple_async_result_take_error (simple, error);
+        g_task_return_error (task, error);
+
+    g_object_unref (task);
 
     if (response)
         mbim_message_unref (response);
-    g_simple_async_result_complete (simple);
-    g_object_unref (simple);
 }
 
 static void
@@ -2635,17 +2616,14 @@ modem_3gpp_run_registration_checks (MMIfaceModem3gpp *self,
                                     GAsyncReadyCallback callback,
                                     gpointer user_data)
 {
-    GSimpleAsyncResult *result;
     MbimDevice *device;
     MbimMessage *message;
+    GTask *task;
 
     if (!peek_device (self, &device, callback, user_data))
         return;
 
-    result = g_simple_async_result_new (G_OBJECT (self),
-                                        callback,
-                                        user_data,
-                                        modem_3gpp_run_registration_checks);
+    task = g_task_new (self, NULL, callback, user_data);
 
     message = mbim_message_register_state_query_new (NULL);
     mbim_device_command (device,
@@ -2653,7 +2631,7 @@ modem_3gpp_run_registration_checks (MMIfaceModem3gpp *self,
                          10,
                          NULL,
                          (GAsyncReadyCallback)register_state_query_ready,
-                         result);
+                         task);
     mbim_message_unref (message);
 }
 
@@ -2664,13 +2642,13 @@ modem_3gpp_register_in_network_finish (MMIfaceModem3gpp *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
 register_state_set_ready (MbimDevice *device,
                           GAsyncResult *res,
-                          GSimpleAsyncResult *simple)
+                          GTask *task)
 {
     MbimMessage *response;
     GError *error = NULL;
@@ -2695,15 +2673,14 @@ register_state_set_ready (MbimDevice *device,
             error = mm_mobile_equipment_error_from_mbim_nw_error (nw_error);
     }
 
-    if (error)
-        g_simple_async_result_take_error (simple, error);
-    else
-        g_simple_async_result_set_op_res_gboolean (simple, TRUE);
-
     if (response)
         mbim_message_unref (response);
-    g_simple_async_result_complete (simple);
-    g_object_unref (simple);
+
+    if (error)
+        g_task_return_error (task, error);
+    else
+        g_task_return_boolean (task, TRUE);
+    g_object_unref (task);
 }
 
 static void
@@ -2713,17 +2690,14 @@ modem_3gpp_register_in_network (MMIfaceModem3gpp *self,
                                 GAsyncReadyCallback callback,
                                 gpointer user_data)
 {
-    GSimpleAsyncResult *result;
     MbimDevice *device;
     MbimMessage *message;
+    GTask *task;
 
     if (!peek_device (self, &device, callback, user_data))
         return;
 
-    result = g_simple_async_result_new (G_OBJECT (self),
-                                        callback,
-                                        user_data,
-                                        modem_3gpp_register_in_network);
+    task = g_task_new (self, NULL, callback, user_data);
 
     if (operator_id && operator_id[0])
         message = (mbim_message_register_state_set_new (
@@ -2742,7 +2716,7 @@ modem_3gpp_register_in_network (MMIfaceModem3gpp *self,
                          60,
                          NULL,
                          (GAsyncReadyCallback)register_state_set_ready,
-                         result);
+                         task);
     mbim_message_unref (message);
 }
 
@@ -2754,43 +2728,40 @@ modem_3gpp_scan_networks_finish (MMIfaceModem3gpp *self,
                                  GAsyncResult *res,
                                  GError **error)
 {
+    return g_task_propagate_pointer (G_TASK (res), error);
+}
+
+static void
+visible_providers_query_ready (MbimDevice *device,
+                               GAsyncResult *res,
+                               GTask *task)
+{
     MbimMessage *response;
     MbimProvider **providers;
     guint n_providers;
-    GList *info_list = NULL;
-
-    if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (res), error))
-        return NULL;
+    GError *error = NULL;
 
-    response = (MbimMessage *)g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (res));
-    if (mbim_message_response_get_result (response, MBIM_MESSAGE_TYPE_COMMAND_DONE, error) &&
+    response = mbim_device_command_finish (device, res, &error);
+    if (response &&
+        mbim_message_response_get_result (response, MBIM_MESSAGE_TYPE_COMMAND_DONE, &error) &&
         mbim_message_visible_providers_response_parse (response,
                                                        &n_providers,
                                                        &providers,
-                                                       error)) {
+                                                       &error)) {
+        GList *info_list;
+
         info_list = mm_3gpp_network_info_list_from_mbim_providers ((const MbimProvider *const *)providers,
                                                                    n_providers);
         mbim_provider_array_free (providers);
-    }
-    return info_list;
-}
 
-static void
-visible_providers_query_ready (MbimDevice *device,
-                               GAsyncResult *res,
-                               GSimpleAsyncResult *simple)
-{
-    MbimMessage *response;
-    GError *error = NULL;
+        g_task_return_pointer (task, info_list, (GDestroyNotify)mm_3gpp_network_info_list_free);
+    } else
+        g_task_return_error (task, error);
 
-    response = mbim_device_command_finish (device, res, &error);
-    if (response)
-        g_simple_async_result_set_op_res_gpointer (simple, response, (GDestroyNotify)mbim_message_unref);
-    else
-        g_simple_async_result_take_error (simple, error);
+    g_object_unref (task);
 
-    g_simple_async_result_complete (simple);
-    g_object_unref (simple);
+    if (response)
+        mbim_message_unref (response);
 }
 
 static void
@@ -2798,17 +2769,14 @@ modem_3gpp_scan_networks (MMIfaceModem3gpp *self,
                           GAsyncReadyCallback callback,
                           gpointer user_data)
 {
-    GSimpleAsyncResult *result;
     MbimDevice *device;
     MbimMessage *message;
+    GTask *task;
 
     if (!peek_device (self, &device, callback, user_data))
         return;
 
-    result = g_simple_async_result_new (G_OBJECT (self),
-                                        callback,
-                                        user_data,
-                                        modem_3gpp_scan_networks);
+    task = g_task_new (self, NULL, callback, user_data);
 
     mm_dbg ("scanning networks...");
     message = mbim_message_visible_providers_query_new (MBIM_VISIBLE_PROVIDERS_ACTION_FULL_SCAN, NULL);
@@ -2817,7 +2785,7 @@ modem_3gpp_scan_networks (MMIfaceModem3gpp *self,
                          300,
                          NULL,
                          (GAsyncReadyCallback)visible_providers_query_ready,
-                         result);
+                         task);
     mbim_message_unref (message);
 }
 
@@ -2890,26 +2858,12 @@ messaging_load_supported_storages (MMIfaceModemMessaging *self,
 /*****************************************************************************/
 /* Load initial SMS parts */
 
-typedef struct {
-    MMBroadbandModemMbim *self;
-    GSimpleAsyncResult *result;
-} LoadInitialSmsPartsContext;
-
-static void
-load_initial_sms_parts_context_complete_and_free (LoadInitialSmsPartsContext *ctx)
-{
-    g_simple_async_result_complete (ctx->result);
-    g_object_unref (ctx->result);
-    g_object_unref (ctx->self);
-    g_slice_free (LoadInitialSmsPartsContext, ctx);
-}
-
 static gboolean
 load_initial_sms_parts_finish (MMIfaceModemMessaging *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
@@ -2941,13 +2895,16 @@ add_sms_part (MMBroadbandModemMbim *self,
 static void
 sms_read_query_ready (MbimDevice *device,
                       GAsyncResult *res,
-                      LoadInitialSmsPartsContext *ctx)
+                      GTask *task)
 {
+    MMBroadbandModemMbim *self;
     MbimMessage *response;
     GError *error = NULL;
     guint32 messages_count;
     MbimSmsPduReadRecord **pdu_messages;
 
+    self = g_task_get_source_object (task);
+
     response = mbim_device_command_finish (device, res, &error);
     if (response &&
         mbim_message_response_get_result (response, MBIM_MESSAGE_TYPE_COMMAND_DONE, &error) &&
@@ -2961,15 +2918,16 @@ sms_read_query_ready (MbimDevice *device,
         guint i;
 
         for (i = 0; i < messages_count; i++)
-            add_sms_part (ctx->self, pdu_messages[i]);
+            add_sms_part (self, pdu_messages[i]);
         mbim_sms_pdu_read_record_array_free (pdu_messages);
+        g_task_return_boolean (task, TRUE);
     } else
-        g_simple_async_result_take_error (ctx->result, error);
+        g_task_return_error (task, error);
+
+    g_object_unref (task);
 
     if (response)
         mbim_message_unref (response);
-
-    load_initial_sms_parts_context_complete_and_free (ctx);
 }
 
 static void
@@ -2978,21 +2936,16 @@ load_initial_sms_parts (MMIfaceModemMessaging *self,
                         GAsyncReadyCallback callback,
                         gpointer user_data)
 {
-    LoadInitialSmsPartsContext *ctx;
     MbimDevice *device;
     MbimMessage *message;
+    GTask *task;
 
     if (!peek_device (self, &device, callback, user_data))
         return;
 
     g_assert (storage == MM_SMS_STORAGE_MT);
 
-    ctx = g_slice_new0 (LoadInitialSmsPartsContext);
-    ctx->self = g_object_ref (self);
-    ctx->result = g_simple_async_result_new (G_OBJECT (self),
-                                             callback,
-                                             user_data,
-                                             load_initial_sms_parts);
+    task = g_task_new (self, NULL, callback, user_data);
 
     mm_dbg ("loading SMS parts...");
     message = mbim_message_sms_read_query_new (MBIM_SMS_FORMAT_PDU,
@@ -3004,7 +2957,7 @@ load_initial_sms_parts (MMIfaceModemMessaging *self,
                          10,
                          NULL,
                          (GAsyncReadyCallback)sms_read_query_ready,
-                         ctx);
+                         task);
     mbim_message_unref (message);
 }