colin/ModemManager
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

telit: port mm-broadband-modem-telit to use GTask

Browse Source
This commit is contained in:
Daniele Palmas
2017-06-30 13:02:26 +02:00
committed by Aleksander Morgado
parent 347610a63d
commit acf1013356
1 changed files with 131 additions and 154 deletions
Download Patch File Download Diff File Expand all files Collapse all files

285
plugins/telit/mm-broadband-modem-telit.c
View File

@@ -62,14 +62,14 @@ modem_after_sim_unlock_finish (MMIfaceModem *self,
GAsyncResult *res, GAsyncResult *res,
GError **error) GError **error)
{ {
return TRUE; return g_task_propagate_boolean (G_TASK (res), error);
} }
static gboolean static gboolean
after_sim_unlock_ready (GSimpleAsyncResult *result) after_sim_unlock_ready (GTask *task)
{ {
g_simple_async_result_complete (result); g_task_return_boolean (task, TRUE);
g_object_unref (result); g_object_unref (task);
return G_SOURCE_REMOVE; return G_SOURCE_REMOVE;
} }
@@ -78,16 +78,13 @@ modem_after_sim_unlock (MMIfaceModem *self,
GAsyncReadyCallback callback, GAsyncReadyCallback callback,
gpointer user_data) gpointer user_data)
{ {
GSimpleAsyncResult *result; GTask *task;
result = g_simple_async_result_new (G_OBJECT (self), task = g_task_new (self, NULL, callback, user_data);
callback,
user_data,
modem_after_sim_unlock);
/* A short delay is necessary with some SIMs when /* A short delay is necessary with some SIMs when
they have just been unlocked. Using 1 second as secure margin. */ they have just been unlocked. Using 1 second as secure margin. */
g_timeout_add_seconds (1, (GSourceFunc) after_sim_unlock_ready, result); g_timeout_add_seconds (1, (GSourceFunc) after_sim_unlock_ready, task);
} }
/*****************************************************************************/ /*****************************************************************************/
@@ -324,25 +321,24 @@ modem_set_current_bands_finish (MMIfaceModem *self,
GAsyncResult *res, GAsyncResult *res,
GError **error) 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 static void
modem_set_current_bands_ready (MMIfaceModem *self, modem_set_current_bands_ready (MMIfaceModem *self,
GAsyncResult *res, GAsyncResult *res,
GSimpleAsyncResult *simple) GTask *task)
{ {
GError *error = NULL; GError *error = NULL;
mm_base_modem_at_command_finish (MM_BASE_MODEM (self), res, &error); mm_base_modem_at_command_finish (MM_BASE_MODEM (self), res, &error);
if (error) { if (error) {
g_simple_async_result_take_error (simple, error); g_task_return_error (task, error);
} else { } else {
g_simple_async_result_set_op_res_gboolean (simple, TRUE); g_task_return_boolean (task, TRUE);
} }
g_simple_async_result_complete (simple); g_object_unref (task);
g_object_unref (simple);
} }
static void static void
@@ -358,7 +354,7 @@ modem_set_current_bands (MMIfaceModem *self,
gboolean is_2g; gboolean is_2g;
gboolean is_3g; gboolean is_3g;
gboolean is_4g; gboolean is_4g;
GSimpleAsyncResult *res; GTask *task;
mm_telit_get_band_flag (bands_array, &flag2g, &flag3g, &flag4g); mm_telit_get_band_flag (bands_array, &flag2g, &flag3g, &flag4g);
@@ -418,16 +414,13 @@ modem_set_current_bands (MMIfaceModem *self,
"Unexpectd error: could not compose AT#BND command"); "Unexpectd error: could not compose AT#BND command");
return; return;
} }
res = g_simple_async_result_new (G_OBJECT (self), task = g_task_new (self, NULL, callback, user_data);
callback,
user_data,
modem_set_current_bands);
mm_base_modem_at_command (MM_BASE_MODEM (self), mm_base_modem_at_command (MM_BASE_MODEM (self),
cmd, cmd,
20, 20,
FALSE, FALSE,
(GAsyncReadyCallback)modem_set_current_bands_ready, (GAsyncReadyCallback)modem_set_current_bands_ready,
res); task);
g_free (cmd); g_free (cmd);
} }
@@ -435,8 +428,6 @@ modem_set_current_bands (MMIfaceModem *self,
/* Load current bands (Modem interface) */ /* Load current bands (Modem interface) */
typedef struct { typedef struct {
MMIfaceModem *self;
GSimpleAsyncResult *result;
gboolean mm_modem_is_2g; gboolean mm_modem_is_2g;
gboolean mm_modem_is_3g; gboolean mm_modem_is_3g;
gboolean mm_modem_is_4g; gboolean mm_modem_is_4g;
@@ -444,11 +435,8 @@ typedef struct {
} LoadBandsContext; } LoadBandsContext;
static void static void
load_bands_context_complete_and_free (LoadBandsContext *ctx) load_bands_context_free (LoadBandsContext *ctx)
{ {
g_simple_async_result_complete (ctx->result);
g_object_unref (ctx->result);
g_object_unref (ctx->self);
g_slice_free (LoadBandsContext, ctx); g_slice_free (LoadBandsContext, ctx);
} }
@@ -457,26 +445,24 @@ modem_load_bands_finish (MMIfaceModem *self,
GAsyncResult *res, GAsyncResult *res,
GError **error) GError **error)
{ {
if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (res), error)) return (GArray *) g_task_propagate_pointer (G_TASK (res), error);
return NULL;
return (GArray *) g_array_ref (g_simple_async_result_get_op_res_gpointer (
G_SIMPLE_ASYNC_RESULT (res)));
} }
static void static void
load_bands_ready (MMBaseModem *self, load_bands_ready (MMBaseModem *self,
GAsyncResult *res, GAsyncResult *res,
LoadBandsContext *ctx) GTask *task)
{ {
const gchar *response; const gchar *response;
GError *error = NULL; GError *error = NULL;
GArray *bands = NULL; GArray *bands = NULL;
LoadBandsContext *ctx;
ctx = g_task_get_task_data (task);
response = mm_base_modem_at_command_finish (MM_BASE_MODEM (self), res, &error); response = mm_base_modem_at_command_finish (MM_BASE_MODEM (self), res, &error);
if (!response) if (!response)
g_simple_async_result_take_error (ctx->result, error); g_task_return_error (task, error);
else if (!mm_telit_parse_bnd_response (response, else if (!mm_telit_parse_bnd_response (response,
ctx->mm_modem_is_2g, ctx->mm_modem_is_2g,
ctx->mm_modem_is_3g, ctx->mm_modem_is_3g,
@@ -484,11 +470,11 @@ load_bands_ready (MMBaseModem *self,
ctx->band_type, ctx->band_type,
&bands, &bands,
&error)) &error))
g_simple_async_result_take_error (ctx->result, error); g_task_return_error (task, error);
else else
g_simple_async_result_set_op_res_gpointer (ctx->result, bands, (GDestroyNotify)g_array_unref); g_task_return_pointer (task, bands, (GDestroyNotify)g_array_unref);
load_bands_context_complete_and_free (ctx); g_object_unref (task);
} }
static void static void
@@ -496,27 +482,25 @@ modem_load_current_bands (MMIfaceModem *self,
GAsyncReadyCallback callback, GAsyncReadyCallback callback,
gpointer user_data) gpointer user_data)
{ {
GTask *task;
LoadBandsContext *ctx; LoadBandsContext *ctx;
ctx = g_slice_new0 (LoadBandsContext); ctx = g_slice_new0 (LoadBandsContext);
ctx->self = g_object_ref (self); ctx->mm_modem_is_2g = mm_iface_modem_is_2g (self);
ctx->mm_modem_is_2g = mm_iface_modem_is_2g (ctx->self); ctx->mm_modem_is_3g = mm_iface_modem_is_3g (self);
ctx->mm_modem_is_3g = mm_iface_modem_is_3g (ctx->self); ctx->mm_modem_is_4g = mm_iface_modem_is_4g (self);
ctx->mm_modem_is_4g = mm_iface_modem_is_4g (ctx->self);
ctx->band_type = LOAD_CURRENT_BANDS; ctx->band_type = LOAD_CURRENT_BANDS;
ctx->result = g_simple_async_result_new (G_OBJECT (self), task = g_task_new (self, NULL, callback, user_data);
callback, g_task_set_task_data (task, ctx, (GDestroyNotify)load_bands_context_free);
user_data,
modem_load_current_bands);
mm_base_modem_at_command (MM_BASE_MODEM (self), mm_base_modem_at_command (MM_BASE_MODEM (self),
"#BND?", "#BND?",
3, 3,
FALSE, FALSE,
(GAsyncReadyCallback) load_bands_ready, (GAsyncReadyCallback) load_bands_ready,
ctx); task);
} }
/*****************************************************************************/ /*****************************************************************************/
@@ -527,27 +511,25 @@ modem_load_supported_bands (MMIfaceModem *self,
GAsyncReadyCallback callback, GAsyncReadyCallback callback,
gpointer user_data) gpointer user_data)
{ {
GTask *task;
LoadBandsContext *ctx; LoadBandsContext *ctx;
ctx = g_slice_new0 (LoadBandsContext); ctx = g_slice_new0 (LoadBandsContext);
ctx->self = g_object_ref (self); ctx->mm_modem_is_2g = mm_iface_modem_is_2g (self);
ctx->mm_modem_is_2g = mm_iface_modem_is_2g (ctx->self); ctx->mm_modem_is_3g = mm_iface_modem_is_3g (self);
ctx->mm_modem_is_3g = mm_iface_modem_is_3g (ctx->self); ctx->mm_modem_is_4g = mm_iface_modem_is_4g (self);
ctx->mm_modem_is_4g = mm_iface_modem_is_4g (ctx->self);
ctx->band_type = LOAD_SUPPORTED_BANDS; ctx->band_type = LOAD_SUPPORTED_BANDS;
ctx->result = g_simple_async_result_new (G_OBJECT (self), task = g_task_new (self, NULL, callback, user_data);
callback, g_task_set_task_data (task, ctx, (GDestroyNotify)load_bands_context_free);
user_data,
modem_load_supported_bands);
mm_base_modem_at_command (MM_BASE_MODEM (self), mm_base_modem_at_command (MM_BASE_MODEM (self),
"#BND=?", "#BND=?",
3, 3,
FALSE, FALSE,
(GAsyncReadyCallback) load_bands_ready, (GAsyncReadyCallback) load_bands_ready,
ctx); task);
} }
/*****************************************************************************/ /*****************************************************************************/
@@ -587,22 +569,17 @@ static const gchar *step_lock_names[LOAD_UNLOCK_RETRIES_STEP_LAST] = {
}; };
typedef struct { typedef struct {
MMBroadbandModemTelit *self;
GSimpleAsyncResult *result;
MMUnlockRetries *retries; MMUnlockRetries *retries;
LoadUnlockRetriesStep step; LoadUnlockRetriesStep step;
guint succeded_requests; guint succeded_requests;
} LoadUnlockRetriesContext; } LoadUnlockRetriesContext;
static void load_unlock_retries_step (LoadUnlockRetriesContext *ctx); static void load_unlock_retries_step (GTask *task);
static void static void
load_unlock_retries_context_complete_and_free (LoadUnlockRetriesContext *ctx) load_unlock_retries_context_free (LoadUnlockRetriesContext *ctx)
{ {
g_simple_async_result_complete (ctx->result);
g_object_unref (ctx->retries); g_object_unref (ctx->retries);
g_object_unref (ctx->result);
g_object_unref (ctx->self);
g_slice_free (LoadUnlockRetriesContext, ctx); g_slice_free (LoadUnlockRetriesContext, ctx);
} }
@@ -611,20 +588,21 @@ modem_load_unlock_retries_finish (MMIfaceModem *self,
GAsyncResult *res, GAsyncResult *res,
GError **error) GError **error)
{ {
if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (res), error)) return (MMUnlockRetries *) g_task_propagate_pointer (G_TASK (res), error);
return NULL;
return (MMUnlockRetries*) g_object_ref (g_simple_async_result_get_op_res_gpointer (
G_SIMPLE_ASYNC_RESULT (res)));
} }
static void static void
csim_unlock_ready (MMBaseModem *self, csim_unlock_ready (MMBaseModem *self,
GAsyncResult *res, GAsyncResult *res,
LoadUnlockRetriesContext *ctx) GTask *task)
{ {
const gchar *response; const gchar *response;
GError *error = NULL; GError *error = NULL;
MMBroadbandModemTelit *modem_telit;
LoadUnlockRetriesContext *ctx;
modem_telit = MM_BROADBAND_MODEM_TELIT (g_task_get_source_object (task));
ctx = g_task_get_task_data (task);
/* Ignore errors */ /* Ignore errors */
response = mm_base_modem_at_command_finish (self, res, &error); response = mm_base_modem_at_command_finish (self, res, &error);
@@ -632,28 +610,31 @@ csim_unlock_ready (MMBaseModem *self,
if (g_error_matches (error, if (g_error_matches (error,
MM_MOBILE_EQUIPMENT_ERROR, MM_MOBILE_EQUIPMENT_ERROR,
MM_MOBILE_EQUIPMENT_ERROR_NOT_SUPPORTED)) { MM_MOBILE_EQUIPMENT_ERROR_NOT_SUPPORTED)) {
ctx->self->priv->csim_lock_support = FEATURE_NOT_SUPPORTED; modem_telit->priv->csim_lock_support = FEATURE_NOT_SUPPORTED;
} }
mm_warn ("Couldn't unlock SIM card: %s", error->message); mm_warn ("Couldn't unlock SIM card: %s", error->message);
g_error_free (error); g_error_free (error);
} }
if (ctx->self->priv->csim_lock_support != FEATURE_NOT_SUPPORTED) { if (modem_telit->priv->csim_lock_support != FEATURE_NOT_SUPPORTED) {
ctx->self->priv->csim_lock_support = FEATURE_SUPPORTED; modem_telit->priv->csim_lock_support = FEATURE_SUPPORTED;
} }
ctx->step++; ctx->step++;
load_unlock_retries_step (ctx); load_unlock_retries_step (task);
} }
static void static void
csim_query_ready (MMBaseModem *self, csim_query_ready (MMBaseModem *self,
GAsyncResult *res, GAsyncResult *res,
LoadUnlockRetriesContext *ctx) GTask *task)
{ {
const gchar *response; const gchar *response;
gint unlock_retries; gint unlock_retries;
GError *error = NULL; GError *error = NULL;
LoadUnlockRetriesContext *ctx;
ctx = g_task_get_task_data (task);
response = mm_base_modem_at_command_finish (self, res, &error); response = mm_base_modem_at_command_finish (self, res, &error);
@@ -693,68 +674,79 @@ csim_query_ready (MMBaseModem *self,
next_step: next_step:
ctx->step++; ctx->step++;
load_unlock_retries_step (ctx); load_unlock_retries_step (task);
} }
static void static void
csim_lock_ready (MMBaseModem *self, csim_lock_ready (MMBaseModem *self,
GAsyncResult *res, GAsyncResult *res,
LoadUnlockRetriesContext *ctx) GTask *task)
{ {
const gchar *response; const gchar *response;
GError *error = NULL; GError *error = NULL;
MMBroadbandModemTelit *modem_telit;
LoadUnlockRetriesContext *ctx;
modem_telit = MM_BROADBAND_MODEM_TELIT (g_task_get_source_object (task));
ctx = g_task_get_task_data (task);
response = mm_base_modem_at_command_finish (self, res, &error); response = mm_base_modem_at_command_finish (self, res, &error);
if (!response) { if (!response) {
if (g_error_matches (error, if (g_error_matches (error,
MM_MOBILE_EQUIPMENT_ERROR, MM_MOBILE_EQUIPMENT_ERROR,
MM_MOBILE_EQUIPMENT_ERROR_NOT_SUPPORTED)) { MM_MOBILE_EQUIPMENT_ERROR_NOT_SUPPORTED)) {
ctx->self->priv->csim_lock_support = FEATURE_NOT_SUPPORTED; modem_telit->priv->csim_lock_support = FEATURE_NOT_SUPPORTED;
mm_warn ("Couldn't lock SIM card: %s. Continuing without CSIM lock.", error->message); mm_warn ("Couldn't lock SIM card: %s. Continuing without CSIM lock.", error->message);
g_error_free (error); g_error_free (error);
} else { } else {
g_prefix_error (&error, "Couldn't lock SIM card: "); g_prefix_error (&error, "Couldn't lock SIM card: ");
g_simple_async_result_take_error (ctx->result, error); g_task_return_error (task, error);
load_unlock_retries_context_complete_and_free (ctx); g_object_unref (task);
return; return;
} }
} }
if (ctx->self->priv->csim_lock_support != FEATURE_NOT_SUPPORTED) { if (modem_telit->priv->csim_lock_support != FEATURE_NOT_SUPPORTED) {
ctx->self->priv->csim_lock_support = FEATURE_SUPPORTED; modem_telit->priv->csim_lock_support = FEATURE_SUPPORTED;
} }
ctx->step++; ctx->step++;
load_unlock_retries_step (ctx); load_unlock_retries_step (task);
} }
static void static void
handle_csim_locking (LoadUnlockRetriesContext *ctx, gboolean is_lock) handle_csim_locking (GTask *task, gboolean is_lock)
{ {
switch (ctx->self->priv->csim_lock_support) { MMBroadbandModemTelit *modem_telit;
LoadUnlockRetriesContext *ctx;
modem_telit = MM_BROADBAND_MODEM_TELIT (g_task_get_source_object (task));
ctx = g_task_get_task_data (task);
switch (modem_telit->priv->csim_lock_support) {
case FEATURE_SUPPORT_UNKNOWN: case FEATURE_SUPPORT_UNKNOWN:
case FEATURE_SUPPORTED: case FEATURE_SUPPORTED:
if (is_lock) { if (is_lock) {
mm_base_modem_at_command (MM_BASE_MODEM (ctx->self), mm_base_modem_at_command (MM_BASE_MODEM (modem_telit),
CSIM_LOCK_STR, CSIM_LOCK_STR,
CSIM_QUERY_TIMEOUT, CSIM_QUERY_TIMEOUT,
FALSE, FALSE,
(GAsyncReadyCallback) csim_lock_ready, (GAsyncReadyCallback) csim_lock_ready,
ctx); task);
} else { } else {
mm_base_modem_at_command (MM_BASE_MODEM (ctx->self), mm_base_modem_at_command (MM_BASE_MODEM (modem_telit),
CSIM_UNLOCK_STR, CSIM_UNLOCK_STR,
CSIM_QUERY_TIMEOUT, CSIM_QUERY_TIMEOUT,
FALSE, FALSE,
(GAsyncReadyCallback) csim_unlock_ready, (GAsyncReadyCallback) csim_unlock_ready,
ctx); task);
} }
break; break;
case FEATURE_NOT_SUPPORTED: case FEATURE_NOT_SUPPORTED:
mm_dbg ("CSIM lock not supported by this modem. Skipping %s command", mm_dbg ("CSIM lock not supported by this modem. Skipping %s command",
is_lock ? "lock" : "unlock"); is_lock ? "lock" : "unlock");
ctx->step++; ctx->step++;
load_unlock_retries_step (ctx); load_unlock_retries_step (task);
break; break;
default: default:
g_assert_not_reached (); g_assert_not_reached ();
@@ -763,63 +755,64 @@ handle_csim_locking (LoadUnlockRetriesContext *ctx, gboolean is_lock)
} }
static void static void
load_unlock_retries_step (LoadUnlockRetriesContext *ctx) load_unlock_retries_step (GTask *task)
{ {
MMBroadbandModemTelit *modem_telit;
LoadUnlockRetriesContext *ctx;
modem_telit = MM_BROADBAND_MODEM_TELIT (g_task_get_source_object (task));
ctx = g_task_get_task_data (task);
switch (ctx->step) { switch (ctx->step) {
case LOAD_UNLOCK_RETRIES_STEP_FIRST: case LOAD_UNLOCK_RETRIES_STEP_FIRST:
/* Fall back on next step */ /* Fall back on next step */
ctx->step++; ctx->step++;
case LOAD_UNLOCK_RETRIES_STEP_LOCK: case LOAD_UNLOCK_RETRIES_STEP_LOCK:
handle_csim_locking (ctx, TRUE); handle_csim_locking (task, TRUE);
break; break;
case LOAD_UNLOCK_RETRIES_STEP_PIN: case LOAD_UNLOCK_RETRIES_STEP_PIN:
mm_base_modem_at_command (MM_BASE_MODEM (ctx->self), mm_base_modem_at_command (MM_BASE_MODEM (modem_telit),
CSIM_QUERY_PIN_RETRIES_STR, CSIM_QUERY_PIN_RETRIES_STR,
CSIM_QUERY_TIMEOUT, CSIM_QUERY_TIMEOUT,
FALSE, FALSE,
(GAsyncReadyCallback) csim_query_ready, (GAsyncReadyCallback) csim_query_ready,
ctx); task);
break; break;
case LOAD_UNLOCK_RETRIES_STEP_PUK: case LOAD_UNLOCK_RETRIES_STEP_PUK:
mm_base_modem_at_command (MM_BASE_MODEM (ctx->self), mm_base_modem_at_command (MM_BASE_MODEM (modem_telit),
CSIM_QUERY_PUK_RETRIES_STR, CSIM_QUERY_PUK_RETRIES_STR,
CSIM_QUERY_TIMEOUT, CSIM_QUERY_TIMEOUT,
FALSE, FALSE,
(GAsyncReadyCallback) csim_query_ready, (GAsyncReadyCallback) csim_query_ready,
ctx); task);
break; break;
case LOAD_UNLOCK_RETRIES_STEP_PIN2: case LOAD_UNLOCK_RETRIES_STEP_PIN2:
mm_base_modem_at_command (MM_BASE_MODEM (ctx->self), mm_base_modem_at_command (MM_BASE_MODEM (modem_telit),
CSIM_QUERY_PIN2_RETRIES_STR, CSIM_QUERY_PIN2_RETRIES_STR,
CSIM_QUERY_TIMEOUT, CSIM_QUERY_TIMEOUT,
FALSE, FALSE,
(GAsyncReadyCallback) csim_query_ready, (GAsyncReadyCallback) csim_query_ready,
ctx); task);
break; break;
case LOAD_UNLOCK_RETRIES_STEP_PUK2: case LOAD_UNLOCK_RETRIES_STEP_PUK2:
mm_base_modem_at_command (MM_BASE_MODEM (ctx->self), mm_base_modem_at_command (MM_BASE_MODEM (modem_telit),
CSIM_QUERY_PUK2_RETRIES_STR, CSIM_QUERY_PUK2_RETRIES_STR,
CSIM_QUERY_TIMEOUT, CSIM_QUERY_TIMEOUT,
FALSE, FALSE,
(GAsyncReadyCallback) csim_query_ready, (GAsyncReadyCallback) csim_query_ready,
ctx); task);
break; break;
case LOAD_UNLOCK_RETRIES_STEP_UNLOCK: case LOAD_UNLOCK_RETRIES_STEP_UNLOCK:
handle_csim_locking (ctx, FALSE); handle_csim_locking (task, FALSE);
break; break;
case LOAD_UNLOCK_RETRIES_STEP_LAST: case LOAD_UNLOCK_RETRIES_STEP_LAST:
if (ctx->succeded_requests == 0) { if (ctx->succeded_requests == 0) {
g_simple_async_result_set_error (ctx->result, g_task_return_new_error (task, MM_CORE_ERROR, MM_CORE_ERROR_FAILED,
MM_CORE_ERROR, "Could not get any of the SIM unlock retries values");
MM_CORE_ERROR_FAILED,
"Could not get any of the SIM unlock retries values");
} else { } else {
g_simple_async_result_set_op_res_gpointer (ctx->result, g_task_return_pointer (task, g_object_ref (ctx->retries), g_object_unref);
g_object_ref (ctx->retries),
g_object_unref);
} }
load_unlock_retries_context_complete_and_free (ctx); g_object_unref (task);
break; break;
default: default:
break; break;
@@ -831,20 +824,18 @@ modem_load_unlock_retries (MMIfaceModem *self,
GAsyncReadyCallback callback, GAsyncReadyCallback callback,
gpointer user_data) gpointer user_data)
{ {
GTask *task;
LoadUnlockRetriesContext *ctx; LoadUnlockRetriesContext *ctx;
ctx = g_slice_new0 (LoadUnlockRetriesContext); ctx = g_slice_new0 (LoadUnlockRetriesContext);
ctx->self = g_object_ref (self);
ctx->result = g_simple_async_result_new (G_OBJECT (self),
callback,
user_data,
modem_load_unlock_retries);
ctx->retries = mm_unlock_retries_new (); ctx->retries = mm_unlock_retries_new ();
ctx->step = LOAD_UNLOCK_RETRIES_STEP_FIRST; ctx->step = LOAD_UNLOCK_RETRIES_STEP_FIRST;
ctx->succeded_requests = 0; ctx->succeded_requests = 0;
load_unlock_retries_step (ctx); task = g_task_new (self, NULL, callback, user_data);
g_task_set_task_data (task, ctx, (GDestroyNotify)load_unlock_retries_context_free);
load_unlock_retries_step (task);
} }
/*****************************************************************************/ /*****************************************************************************/
@@ -1131,24 +1122,23 @@ set_current_modes_finish (MMIfaceModem *self,
GAsyncResult *res, GAsyncResult *res,
GError **error) 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 static void
ws46_set_ready (MMIfaceModem *self, ws46_set_ready (MMIfaceModem *self,
GAsyncResult *res, GAsyncResult *res,
GSimpleAsyncResult *operation_result) GTask *task)
{ {
GError *error = NULL; GError *error = NULL;
mm_base_modem_at_command_finish (MM_BASE_MODEM (self), res, &error); mm_base_modem_at_command_finish (MM_BASE_MODEM (self), res, &error);
if (error) if (error)
/* Let the error be critical. */ /* Let the error be critical. */
g_simple_async_result_take_error (operation_result, error); g_task_return_error (task, error);
else else
g_simple_async_result_set_op_res_gboolean (operation_result, TRUE); g_task_return_boolean (task, TRUE);
g_simple_async_result_complete (operation_result); g_object_unref (task);
g_object_unref (operation_result);
} }
static void static void
@@ -1158,14 +1148,11 @@ set_current_modes (MMIfaceModem *self,
GAsyncReadyCallback callback, GAsyncReadyCallback callback,
gpointer user_data) gpointer user_data)
{ {
GSimpleAsyncResult *result; GTask *task;
gchar *command; gchar *command;
gint ws46_mode = -1; gint ws46_mode = -1;
result = g_simple_async_result_new (G_OBJECT (self), task = g_task_new (self, NULL, callback, user_data);
callback,
user_data,
set_current_modes);
if (allowed == MM_MODEM_MODE_2G) if (allowed == MM_MODEM_MODE_2G)
ws46_mode = 12; ws46_mode = 12;
@@ -1193,18 +1180,17 @@ set_current_modes (MMIfaceModem *self,
allowed_str = mm_modem_mode_build_string_from_mask (allowed); allowed_str = mm_modem_mode_build_string_from_mask (allowed);
preferred_str = mm_modem_mode_build_string_from_mask (preferred); preferred_str = mm_modem_mode_build_string_from_mask (preferred);
g_simple_async_result_set_error (result, g_task_return_new_error (task,
MM_CORE_ERROR, MM_CORE_ERROR,
MM_CORE_ERROR_FAILED, MM_CORE_ERROR_FAILED,
"Requested mode (allowed: '%s', preferred: '%s') not " "Requested mode (allowed: '%s', preferred: '%s') not "
"supported by the modem.", "supported by the modem.",
allowed_str, allowed_str,
preferred_str); preferred_str);
g_free (allowed_str); g_free (allowed_str);
g_free (preferred_str); g_free (preferred_str);
g_simple_async_result_complete_in_idle (result); g_object_unref (task);
g_object_unref (result);
return; return;
} }
@@ -1215,7 +1201,7 @@ set_current_modes (MMIfaceModem *self,
10, 10,
FALSE, FALSE,
(GAsyncReadyCallback)ws46_set_ready, (GAsyncReadyCallback)ws46_set_ready,
result); task);
g_free (command); g_free (command);
} }
@@ -1227,16 +1213,13 @@ load_supported_modes_finish (MMIfaceModem *self,
GAsyncResult *res, GAsyncResult *res,
GError **error) GError **error)
{ {
if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (res), error)) return (GArray *) g_task_propagate_pointer (G_TASK (res), error);
return NULL;
return g_array_ref (g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (res)));
} }
static void static void
parent_load_supported_modes_ready (MMIfaceModem *self, parent_load_supported_modes_ready (MMIfaceModem *self,
GAsyncResult *res, GAsyncResult *res,
GSimpleAsyncResult *simple) GTask *task)
{ {
GError *error = NULL; GError *error = NULL;
GArray *all; GArray *all;
@@ -1246,17 +1229,15 @@ parent_load_supported_modes_ready (MMIfaceModem *self,
all = iface_modem_parent->load_supported_modes_finish (self, res, &error); all = iface_modem_parent->load_supported_modes_finish (self, res, &error);
if (!all) { if (!all) {
g_simple_async_result_take_error (simple, error); g_task_return_error (task, error);
g_simple_async_result_complete (simple); g_object_unref (task);
g_object_unref (simple);
return; return;
} }
/* CDMA-only modems don't support changing modes, default to parent's */ /* CDMA-only modems don't support changing modes, default to parent's */
if (!mm_iface_modem_is_3gpp (self)) { if (!mm_iface_modem_is_3gpp (self)) {
g_simple_async_result_set_op_res_gpointer (simple, all, (GDestroyNotify) g_array_unref); g_task_return_pointer (task, all, (GDestroyNotify) g_array_unref);
g_simple_async_result_complete_in_idle (simple); g_object_unref (task);
g_object_unref (simple);
return; return;
} }
@@ -1297,9 +1278,8 @@ parent_load_supported_modes_ready (MMIfaceModem *self,
g_array_unref (all); g_array_unref (all);
g_array_unref (combinations); g_array_unref (combinations);
g_simple_async_result_set_op_res_gpointer (simple, filtered, (GDestroyNotify) g_array_unref); g_task_return_pointer (task, filtered, (GDestroyNotify) g_array_unref);
g_simple_async_result_complete (simple); g_object_unref (task);
g_object_unref (simple);
} }
static void static void
@@ -1311,10 +1291,7 @@ load_supported_modes (MMIfaceModem *self,
iface_modem_parent->load_supported_modes ( iface_modem_parent->load_supported_modes (
MM_IFACE_MODEM (self), MM_IFACE_MODEM (self),
(GAsyncReadyCallback)parent_load_supported_modes_ready, (GAsyncReadyCallback)parent_load_supported_modes_ready,
g_simple_async_result_new (G_OBJECT (self), g_task_new (self, NULL, callback, user_data));
callback,
user_data,
load_supported_modes));
} }
/*****************************************************************************/ /*****************************************************************************/