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

api,introspection: merge 'AllowedModes' and 'SupportedMode' into 'CurrentModes'

Browse Source 
We now have a single 'CurrentModes' property which contains both values in a
tuple with signature "(uu)".

Also, rename 'SetAllowedModes()' to 'SetCurrentModes()', and update the list of
arguments expected to have a single "(uu)" tuple.
This commit is contained in:
Aleksander Morgado
2013-05-29 13:42:14 +02:00
parent 45ceba7692
commit 1c67d050cb
24 changed files with 482 additions and 447 deletions
Download Patch File Download Diff File Expand all files Collapse all files

102
src/mm-broadband-modem-qmi.c
View File

@@ -2468,7 +2468,7 @@ modem_factory_reset (MMIfaceModem *self,
}
/*****************************************************************************/
/* Load allowed modes (Modem interface) */
/* Load current modes (Modem interface) */
typedef struct {
MMBroadbandModemQmi *self;
@@ -2476,15 +2476,15 @@ typedef struct {
GSimpleAsyncResult *result;
gboolean run_get_system_selection_preference;
gboolean run_get_technology_preference;
} LoadAllowedModesContext;
} LoadCurrentModesContext;
typedef struct {
MMModemMode allowed;
MMModemMode preferred;
} LoadAllowedModesResult;
} LoadCurrentModesResult;
static void
load_allowed_modes_context_complete_and_free (LoadAllowedModesContext *ctx)
load_current_modes_context_complete_and_free (LoadCurrentModesContext *ctx)
{
g_simple_async_result_complete_in_idle (ctx->result);
g_object_unref (ctx->result);
@@ -2494,13 +2494,13 @@ load_allowed_modes_context_complete_and_free (LoadAllowedModesContext *ctx)
}
static gboolean
load_allowed_modes_finish (MMIfaceModem *self,
load_current_modes_finish (MMIfaceModem *self,
GAsyncResult *res,
MMModemMode *allowed,
MMModemMode *preferred,
GError **error)
{
LoadAllowedModesResult *result;
LoadCurrentModesResult *result;
if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (res), error))
return FALSE;
@@ -2511,14 +2511,14 @@ load_allowed_modes_finish (MMIfaceModem *self,
return TRUE;
}
static void load_allowed_modes_context_step (LoadAllowedModesContext *ctx);
static void load_current_modes_context_step (LoadCurrentModesContext *ctx);
static void
get_technology_preference_ready (QmiClientNas *client,
GAsyncResult *res,
LoadAllowedModesContext *ctx)
LoadCurrentModesContext *ctx)
{
LoadAllowedModesResult *result = NULL;
LoadCurrentModesResult *result = NULL;
QmiMessageNasGetTechnologyPreferenceOutput *output = NULL;
GError *error = NULL;
@@ -2547,7 +2547,7 @@ get_technology_preference_ready (QmiClientNas *client,
g_free (str);
} else {
/* We got a valid value from here */
result = g_new (LoadAllowedModesResult, 1);
result = g_new (LoadCurrentModesResult, 1);
result->allowed = allowed;
result->preferred = MM_MODEM_MODE_NONE;
}
@@ -2558,7 +2558,7 @@ get_technology_preference_ready (QmiClientNas *client,
if (!result) {
ctx->run_get_technology_preference = FALSE;
load_allowed_modes_context_step (ctx);
load_current_modes_context_step (ctx);
return;
}
@@ -2566,15 +2566,15 @@ get_technology_preference_ready (QmiClientNas *client,
ctx->result,
result,
(GDestroyNotify)g_free);
load_allowed_modes_context_complete_and_free (ctx);
load_current_modes_context_complete_and_free (ctx);
}
static void
allowed_modes_get_system_selection_preference_ready (QmiClientNas *client,
current_modes_get_system_selection_preference_ready (QmiClientNas *client,
GAsyncResult *res,
LoadAllowedModesContext *ctx)
LoadCurrentModesContext *ctx)
{
LoadAllowedModesResult *result = NULL;
LoadCurrentModesResult *result = NULL;
QmiMessageNasGetSystemSelectionPreferenceOutput *output = NULL;
GError *error = NULL;
QmiNasRatModePreference mode_preference_mask = 0;
@@ -2605,7 +2605,7 @@ allowed_modes_get_system_selection_preference_ready (QmiClientNas *client,
QmiNasGsmWcdmaAcquisitionOrderPreference gsm_or_wcdma;
/* We got a valid value from here */
result = g_new (LoadAllowedModesResult, 1);
result = g_new (LoadCurrentModesResult, 1);
result->allowed = allowed;
result->preferred = MM_MODEM_MODE_NONE;
@@ -2626,7 +2626,7 @@ allowed_modes_get_system_selection_preference_ready (QmiClientNas *client,
if (!result) {
/* Try with the deprecated command */
ctx->run_get_system_selection_preference = FALSE;
load_allowed_modes_context_step (ctx);
load_current_modes_context_step (ctx);
return;
}
@@ -2634,11 +2634,11 @@ allowed_modes_get_system_selection_preference_ready (QmiClientNas *client,
ctx->result,
result,
(GDestroyNotify)g_free);
load_allowed_modes_context_complete_and_free (ctx);
load_current_modes_context_complete_and_free (ctx);
}
static void
load_allowed_modes_context_step (LoadAllowedModesContext *ctx)
load_current_modes_context_step (LoadCurrentModesContext *ctx)
{
if (ctx->run_get_system_selection_preference) {
qmi_client_nas_get_system_selection_preference (
@@ -2646,7 +2646,7 @@ load_allowed_modes_context_step (LoadAllowedModesContext *ctx)
NULL, /* no input */
5,
NULL, /* cancellable */
(GAsyncReadyCallback)allowed_modes_get_system_selection_preference_ready,
(GAsyncReadyCallback)current_modes_get_system_selection_preference_ready,
ctx);
return;
}
@@ -2666,16 +2666,16 @@ load_allowed_modes_context_step (LoadAllowedModesContext *ctx)
ctx->result,
MM_CORE_ERROR,
MM_CORE_ERROR_UNSUPPORTED,
"Loading allowed modes is not supported by this device");
load_allowed_modes_context_complete_and_free (ctx);
"Loading current modes is not supported by this device");
load_current_modes_context_complete_and_free (ctx);
}
static void
load_allowed_modes (MMIfaceModem *self,
load_current_modes (MMIfaceModem *self,
GAsyncReadyCallback callback,
gpointer user_data)
{
LoadAllowedModesContext *ctx;
LoadCurrentModesContext *ctx;
QmiClient *client = NULL;
if (!ensure_qmi_client (MM_BROADBAND_MODEM_QMI (self),
@@ -2683,13 +2683,13 @@ load_allowed_modes (MMIfaceModem *self,
callback, user_data))
return;
ctx = g_new0 (LoadAllowedModesContext, 1);
ctx = g_new0 (LoadCurrentModesContext, 1);
ctx->self = g_object_ref (self);
ctx->client = g_object_ref (client);
ctx->result = g_simple_async_result_new (G_OBJECT (self),
callback,
user_data,
load_allowed_modes);
load_current_modes);
/* System selection preference introduced in NAS 1.1 */
ctx->run_get_system_selection_preference = qmi_client_check_version (client, 1, 1);
@@ -2697,7 +2697,7 @@ load_allowed_modes (MMIfaceModem *self,
/* Technology preference introduced in NAS 1.0, so always available */
ctx->run_get_technology_preference = TRUE;
load_allowed_modes_context_step (ctx);
load_current_modes_context_step (ctx);
}
/*****************************************************************************/
@@ -2711,10 +2711,10 @@ typedef struct {
MMModemMode preferred;
gboolean run_set_system_selection_preference;
gboolean run_set_technology_preference;
} SetAllowedModesContext;
} SetCurrentModesContext;
static void
set_allowed_modes_context_complete_and_free (SetAllowedModesContext *ctx)
set_current_modes_context_complete_and_free (SetCurrentModesContext *ctx)
{
g_simple_async_result_complete_in_idle (ctx->result);
g_object_unref (ctx->result);
@@ -2724,19 +2724,19 @@ set_allowed_modes_context_complete_and_free (SetAllowedModesContext *ctx)
}
static gboolean
set_allowed_modes_finish (MMIfaceModem *self,
set_current_modes_finish (MMIfaceModem *self,
GAsyncResult *res,
GError **error)
{
return !g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (res), error);
}
static void set_allowed_modes_context_step (SetAllowedModesContext *ctx);
static void set_current_modes_context_step (SetCurrentModesContext *ctx);
static void
set_technology_preference_ready (QmiClientNas *client,
GAsyncResult *res,
SetAllowedModesContext *ctx)
SetCurrentModesContext *ctx)
{
QmiMessageNasSetTechnologyPreferenceOutput *output = NULL;
GError *error = NULL;
@@ -2756,19 +2756,19 @@ set_technology_preference_ready (QmiClientNas *client,
if (error)
g_error_free (error);
g_simple_async_result_set_op_res_gboolean (ctx->result, TRUE);
set_allowed_modes_context_complete_and_free (ctx);
set_current_modes_context_complete_and_free (ctx);
qmi_message_nas_set_technology_preference_output_unref (output);
return;
}
ctx->run_set_technology_preference = FALSE;
set_allowed_modes_context_step (ctx);
set_current_modes_context_step (ctx);
}
static void
allowed_modes_set_system_selection_preference_ready (QmiClientNas *client,
GAsyncResult *res,
SetAllowedModesContext *ctx)
SetCurrentModesContext *ctx)
{
QmiMessageNasSetSystemSelectionPreferenceOutput *output = NULL;
GError *error = NULL;
@@ -2784,18 +2784,18 @@ allowed_modes_set_system_selection_preference_ready (QmiClientNas *client,
} else {
/* Good! TODO: do we really need to wait for the indication? */
g_simple_async_result_set_op_res_gboolean (ctx->result, TRUE);
set_allowed_modes_context_complete_and_free (ctx);
set_current_modes_context_complete_and_free (ctx);
qmi_message_nas_set_system_selection_preference_output_unref (output);
return;
}
/* Try with the deprecated command */
ctx->run_set_system_selection_preference = FALSE;
set_allowed_modes_context_step (ctx);
set_current_modes_context_step (ctx);
}
static void
set_allowed_modes_context_step (SetAllowedModesContext *ctx)
set_current_modes_context_step (SetCurrentModesContext *ctx)
{
if (ctx->run_set_system_selection_preference) {
QmiMessageNasSetSystemSelectionPreferenceInput *input;
@@ -2814,7 +2814,7 @@ set_allowed_modes_context_step (SetAllowedModesContext *ctx)
"Unhandled allowed mode setting: '%s'",
str);
g_free (str);
set_allowed_modes_context_complete_and_free (ctx);
set_current_modes_context_complete_and_free (ctx);
return;
}
@@ -2853,7 +2853,7 @@ set_allowed_modes_context_step (SetAllowedModesContext *ctx)
MM_CORE_ERROR,
MM_CORE_ERROR_FAILED,
"Cannot set specific preferred mode");
set_allowed_modes_context_complete_and_free (ctx);
set_current_modes_context_complete_and_free (ctx);
return;
}
@@ -2869,7 +2869,7 @@ set_allowed_modes_context_step (SetAllowedModesContext *ctx)
"Unhandled allowed mode setting: '%s'",
str);
g_free (str);
set_allowed_modes_context_complete_and_free (ctx);
set_current_modes_context_complete_and_free (ctx);
return;
}
@@ -2892,17 +2892,17 @@ set_allowed_modes_context_step (SetAllowedModesContext *ctx)
MM_CORE_ERROR,
MM_CORE_ERROR_UNSUPPORTED,
"Setting allowed modes is not supported by this device");
set_allowed_modes_context_complete_and_free (ctx);
set_current_modes_context_complete_and_free (ctx);
}
static void
set_allowed_modes (MMIfaceModem *self,
set_current_modes (MMIfaceModem *self,
MMModemMode allowed,
MMModemMode preferred,
GAsyncReadyCallback callback,
gpointer user_data)
{
SetAllowedModesContext *ctx;
SetCurrentModesContext *ctx;
QmiClient *client = NULL;
if (!ensure_qmi_client (MM_BROADBAND_MODEM_QMI (self),
@@ -2910,13 +2910,13 @@ set_allowed_modes (MMIfaceModem *self,
callback, user_data))
return;
ctx = g_new0 (SetAllowedModesContext, 1);
ctx = g_new0 (SetCurrentModesContext, 1);
ctx->self = g_object_ref (self);
ctx->client = g_object_ref (client);
ctx->result = g_simple_async_result_new (G_OBJECT (self),
callback,
user_data,
set_allowed_modes);
set_current_modes);
if (allowed == MM_MODEM_MODE_ANY && ctx->preferred == MM_MODEM_MODE_NONE) {
ctx->allowed = (MM_MODEM_MODE_2G | MM_MODEM_MODE_3G);
@@ -2934,7 +2934,7 @@ set_allowed_modes (MMIfaceModem *self,
/* Technology preference introduced in NAS 1.0, so always available */
ctx->run_set_technology_preference = TRUE;
set_allowed_modes_context_step (ctx);
set_current_modes_context_step (ctx);
}
/*****************************************************************************/
@@ -8222,10 +8222,10 @@ iface_modem_init (MMIfaceModem *iface)
iface->load_supported_charsets_finish = NULL;
iface->setup_charset = NULL;
iface->setup_charset_finish = NULL;
iface->load_allowed_modes = load_allowed_modes;
iface->load_allowed_modes_finish = load_allowed_modes_finish;
iface->set_allowed_modes = set_allowed_modes;
iface->set_allowed_modes_finish = set_allowed_modes_finish;
iface->load_current_modes = load_current_modes;
iface->load_current_modes_finish = load_current_modes_finish;
iface->set_current_modes = set_current_modes;
iface->set_current_modes_finish = set_current_modes_finish;
iface->load_signal_quality = load_signal_quality;
iface->load_signal_quality_finish = load_signal_quality_finish;
iface->load_current_bands = modem_load_current_bands;

22
src/mm-iface-modem-simple.c
View File

@@ -174,7 +174,7 @@ typedef enum {
CONNECTION_STEP_WAIT_FOR_INITIALIZED,
CONNECTION_STEP_ENABLE,
CONNECTION_STEP_WAIT_FOR_ENABLED,
CONNECTION_STEP_ALLOWED_MODES,
CONNECTION_STEP_CURRENT_MODES,
CONNECTION_STEP_CURRENT_BANDS,
CONNECTION_STEP_REGISTER,
CONNECTION_STEP_BEARER,
@@ -275,7 +275,7 @@ register_in_3gpp_or_cdma_network_ready (MMIfaceModemSimple *self,
}
static gboolean
after_set_allowed_modes_timeout_cb (ConnectionContext *ctx)
after_set_current_modes_timeout_cb (ConnectionContext *ctx)
{
/* Allowed modes set... almost there! */
ctx->step++;
@@ -284,13 +284,13 @@ after_set_allowed_modes_timeout_cb (ConnectionContext *ctx)
}
static void
set_allowed_modes_ready (MMBaseModem *self,
set_current_modes_ready (MMBaseModem *self,
GAsyncResult *res,
ConnectionContext *ctx)
{
GError *error = NULL;
if (!mm_iface_modem_set_allowed_modes_finish (MM_IFACE_MODEM (self), res, &error)) {
if (!mm_iface_modem_set_current_modes_finish (MM_IFACE_MODEM (self), res, &error)) {
if (g_error_matches (error,
MM_CORE_ERROR,
MM_CORE_ERROR_UNSUPPORTED)) {
@@ -309,7 +309,7 @@ set_allowed_modes_ready (MMBaseModem *self,
* a couple of seconds to settle down. This sleep time just makes sure that
* the modem has enough time to report being unregistered. */
mm_dbg ("Will wait to settle down after updating allowed modes");
g_timeout_add_seconds (2, (GSourceFunc)after_set_allowed_modes_timeout_cb, ctx);
g_timeout_add_seconds (2, (GSourceFunc)after_set_current_modes_timeout_cb, ctx);
}
static gboolean
@@ -556,21 +556,21 @@ connection_step (ConnectionContext *ctx)
ctx);
return;
case CONNECTION_STEP_ALLOWED_MODES: {
case CONNECTION_STEP_CURRENT_MODES: {
MMModemMode allowed_modes = MM_MODEM_MODE_ANY;
MMModemMode preferred_mode = MM_MODEM_MODE_NONE;
mm_info ("Simple connect state (%d/%d): Allowed mode",
mm_info ("Simple connect state (%d/%d): Current modes",
ctx->step, CONNECTION_STEP_LAST);
/* Don't set modes unless explicitly requested to do so */
if (mm_simple_connect_properties_get_allowed_modes (ctx->properties,
if (mm_simple_connect_properties_get_current_modes (ctx->properties,
&allowed_modes,
&preferred_mode)) {
mm_iface_modem_set_allowed_modes (MM_IFACE_MODEM (ctx->self),
mm_iface_modem_set_current_modes (MM_IFACE_MODEM (ctx->self),
allowed_modes,
preferred_mode,
(GAsyncReadyCallback)set_allowed_modes_ready,
(GAsyncReadyCallback)set_current_modes_ready,
ctx);
return;
}
@@ -790,7 +790,7 @@ connect_auth_ready (MMBaseModem *self,
mm_dbg (" PIN: %s", VALIDATE_UNSPECIFIED (mm_simple_connect_properties_get_pin (ctx->properties)));
if (mm_simple_connect_properties_get_allowed_modes (ctx->properties, &allowed, &preferred)) {
if (mm_simple_connect_properties_get_current_modes (ctx->properties, &allowed, &preferred)) {
str = mm_modem_mode_build_string_from_mask (allowed);
mm_dbg (" Allowed mode: %s", str);
g_free (str);

200
src/mm-iface-modem.c
View File

@@ -2124,7 +2124,7 @@ handle_set_current_bands (MmGdbusModem *skeleton,
}
/*****************************************************************************/
/* ALLOWED MODES */
/* Set current modes */
typedef struct {
MMIfaceModem *self;
@@ -2132,10 +2132,10 @@ typedef struct {
GSimpleAsyncResult *result;
MMModemMode allowed;
MMModemMode preferred;
} SetAllowedModesContext;
} SetCurrentModesContext;
static void
set_allowed_modes_context_complete_and_free (SetAllowedModesContext *ctx)
set_current_modes_context_complete_and_free (SetCurrentModesContext *ctx)
{
g_simple_async_result_complete_in_idle (ctx->result);
g_object_unref (ctx->result);
@@ -2146,7 +2146,7 @@ set_allowed_modes_context_complete_and_free (SetAllowedModesContext *ctx)
}
gboolean
mm_iface_modem_set_allowed_modes_finish (MMIfaceModem *self,
mm_iface_modem_set_current_modes_finish (MMIfaceModem *self,
GAsyncResult *res,
GError **error)
{
@@ -2154,39 +2154,87 @@ mm_iface_modem_set_allowed_modes_finish (MMIfaceModem *self,
}
static void
set_allowed_modes_ready (MMIfaceModem *self,
GAsyncResult *res,
SetAllowedModesContext *ctx)
after_set_load_current_modes_ready (MMIfaceModem *self,
GAsyncResult *res,
SetCurrentModesContext *ctx)
{
MMModemMode allowed = MM_MODEM_MODE_NONE;
MMModemMode preferred = MM_MODEM_MODE_NONE;
GError *error = NULL;
if (!MM_IFACE_MODEM_GET_INTERFACE (self)->set_allowed_modes_finish (self, res, &error))
if (!MM_IFACE_MODEM_GET_INTERFACE (self)->load_current_modes_finish (self,
res,
&allowed,
&preferred,
&error)) {
/* Errors when getting allowed/preferred won't be critical */
mm_warn ("couldn't load current allowed/preferred modes: '%s'", error->message);
g_error_free (error);
/* If errors getting allowed modes, default to the ones we asked for */
mm_gdbus_modem_set_current_modes (ctx->skeleton, g_variant_new ("(uu)", ctx->allowed, ctx->preferred));
} else
mm_gdbus_modem_set_current_modes (ctx->skeleton, g_variant_new ("(uu)", allowed, preferred));
/* Done */
set_current_modes_context_complete_and_free (ctx);
}
static void
set_current_modes_ready (MMIfaceModem *self,
GAsyncResult *res,
SetCurrentModesContext *ctx)
{
MMModemState modem_state;
GError *error = NULL;
if (!MM_IFACE_MODEM_GET_INTERFACE (self)->set_current_modes_finish (self, res, &error)) {
g_simple_async_result_take_error (ctx->result, error);
else {
mm_gdbus_modem_set_allowed_modes (ctx->skeleton, ctx->allowed);
mm_gdbus_modem_set_preferred_mode (ctx->skeleton, ctx->preferred);
g_simple_async_result_set_op_res_gboolean (ctx->result, TRUE);
set_current_modes_context_complete_and_free (ctx);
return;
}
set_allowed_modes_context_complete_and_free (ctx);
/* If modem is not enabled, avoid updating the current modes */
modem_state = MM_MODEM_STATE_UNKNOWN;
g_object_get (ctx->self,
MM_IFACE_MODEM_STATE, &modem_state,
NULL);
if (modem_state >= MM_MODEM_STATE_ENABLING) {
if (MM_IFACE_MODEM_GET_INTERFACE (ctx->self)->load_current_modes &&
MM_IFACE_MODEM_GET_INTERFACE (ctx->self)->load_current_modes_finish) {
MM_IFACE_MODEM_GET_INTERFACE (ctx->self)->load_current_modes (
ctx->self,
(GAsyncReadyCallback)after_set_load_current_modes_ready,
ctx);
return;
}
mm_gdbus_modem_set_current_modes (ctx->skeleton,
g_variant_new ("(uu)",
ctx->allowed,
ctx->preferred));
}
g_simple_async_result_set_op_res_gboolean (ctx->result, TRUE);
set_current_modes_context_complete_and_free (ctx);
}
void
mm_iface_modem_set_allowed_modes (MMIfaceModem *self,
mm_iface_modem_set_current_modes (MMIfaceModem *self,
MMModemMode allowed,
MMModemMode preferred,
GAsyncReadyCallback callback,
gpointer user_data)
{
GArray *supported;
SetAllowedModesContext *ctx;
MMModemMode current_allowed;
MMModemMode current_preferred;
SetCurrentModesContext *ctx;
MMModemMode current_allowed = MM_MODEM_MODE_ANY;
MMModemMode current_preferred = MM_MODEM_MODE_NONE;
guint i;
/* If setting allowed modes is not implemented, report an error */
if (!MM_IFACE_MODEM_GET_INTERFACE (self)->set_allowed_modes ||
!MM_IFACE_MODEM_GET_INTERFACE (self)->set_allowed_modes_finish) {
if (!MM_IFACE_MODEM_GET_INTERFACE (self)->set_current_modes ||
!MM_IFACE_MODEM_GET_INTERFACE (self)->set_current_modes_finish) {
g_simple_async_report_error_in_idle (G_OBJECT (self),
callback,
user_data,
@@ -2197,12 +2245,12 @@ mm_iface_modem_set_allowed_modes (MMIfaceModem *self,
}
/* Setup context */
ctx = g_new0 (SetAllowedModesContext, 1);
ctx = g_new0 (SetCurrentModesContext, 1);
ctx->self = g_object_ref (self);
ctx->result = g_simple_async_result_new (G_OBJECT (self),
callback,
user_data,
mm_iface_modem_set_allowed_modes);
mm_iface_modem_set_current_modes);
ctx->allowed = allowed;
ctx->preferred = preferred;
g_object_get (self,
@@ -2213,7 +2261,7 @@ mm_iface_modem_set_allowed_modes (MMIfaceModem *self,
MM_CORE_ERROR,
MM_CORE_ERROR_FAILED,
"Couldn't get interface skeleton");
set_allowed_modes_context_complete_and_free (ctx);
set_current_modes_context_complete_and_free (ctx);
return;
}
@@ -2228,7 +2276,7 @@ mm_iface_modem_set_allowed_modes (MMIfaceModem *self,
MM_CORE_ERROR_UNSUPPORTED,
"Cannot change modes: only one combination supported");
g_array_unref (supported);
set_allowed_modes_context_complete_and_free (ctx);
set_current_modes_context_complete_and_free (ctx);
return;
}
@@ -2257,7 +2305,7 @@ mm_iface_modem_set_allowed_modes (MMIfaceModem *self,
MM_CORE_ERROR_UNSUPPORTED,
"The given combination of allowed and preferred modes is not supported");
g_array_unref (supported);
set_allowed_modes_context_complete_and_free (ctx);
set_current_modes_context_complete_and_free (ctx);
return;
}
}
@@ -2265,12 +2313,14 @@ mm_iface_modem_set_allowed_modes (MMIfaceModem *self,
g_array_unref (supported);
/* Check if we already are in the requested setup */
current_allowed = mm_gdbus_modem_get_allowed_modes (ctx->skeleton);
current_preferred = mm_gdbus_modem_get_preferred_mode (ctx->skeleton);
g_variant_get (mm_gdbus_modem_get_current_modes (ctx->skeleton),
"(uu)",
&current_allowed,
&current_preferred);
if (current_allowed == allowed &&
current_preferred == preferred) {
g_simple_async_result_set_op_res_gboolean (ctx->result, TRUE);
set_allowed_modes_context_complete_and_free (ctx);
set_current_modes_context_complete_and_free (ctx);
return;
}
@@ -2290,16 +2340,16 @@ mm_iface_modem_set_allowed_modes (MMIfaceModem *self,
g_free (preferred_str);
g_free (allowed_str);
set_allowed_modes_context_complete_and_free (ctx);
set_current_modes_context_complete_and_free (ctx);
return;
}
ctx->allowed = allowed;
ctx->preferred = preferred;
MM_IFACE_MODEM_GET_INTERFACE (self)->set_allowed_modes (self,
MM_IFACE_MODEM_GET_INTERFACE (self)->set_current_modes (self,
allowed,
preferred,
(GAsyncReadyCallback)set_allowed_modes_ready,
(GAsyncReadyCallback)set_current_modes_ready,
ctx);
}
@@ -2309,10 +2359,10 @@ typedef struct {
MMIfaceModem *self;
MMModemMode allowed;
MMModemMode preferred;
} HandleSetAllowedModesContext;
} HandleSetCurrentModesContext;
static void
handle_set_allowed_modes_context_free (HandleSetAllowedModesContext *ctx)
handle_set_current_modes_context_free (HandleSetCurrentModesContext *ctx)
{
g_object_unref (ctx->skeleton);
g_object_unref (ctx->invocation);
@@ -2321,31 +2371,31 @@ handle_set_allowed_modes_context_free (HandleSetAllowedModesContext *ctx)
}
static void
handle_set_allowed_modes_ready (MMIfaceModem *self,
handle_set_current_modes_ready (MMIfaceModem *self,
GAsyncResult *res,
HandleSetAllowedModesContext *ctx)
HandleSetCurrentModesContext *ctx)
{
GError *error = NULL;
if (!mm_iface_modem_set_allowed_modes_finish (self, res, &error))
if (!mm_iface_modem_set_current_modes_finish (self, res, &error))
g_dbus_method_invocation_take_error (ctx->invocation, error);
else
mm_gdbus_modem_complete_set_allowed_modes (ctx->skeleton, ctx->invocation);
mm_gdbus_modem_complete_set_current_modes (ctx->skeleton, ctx->invocation);
handle_set_allowed_modes_context_free (ctx);
handle_set_current_modes_context_free (ctx);
}
static void
handle_set_allowed_modes_auth_ready (MMBaseModem *self,
handle_set_current_modes_auth_ready (MMBaseModem *self,
GAsyncResult *res,
HandleSetAllowedModesContext *ctx)
HandleSetCurrentModesContext *ctx)
{
MMModemState modem_state;
GError *error = NULL;
if (!mm_base_modem_authorize_finish (self, res, &error)) {
g_dbus_method_invocation_take_error (ctx->invocation, error);
handle_set_allowed_modes_context_free (ctx);
handle_set_current_modes_context_free (ctx);
return;
}
@@ -2360,37 +2410,39 @@ handle_set_allowed_modes_auth_ready (MMBaseModem *self,
MM_CORE_ERROR_WRONG_STATE,
"Cannot set allowed modes: "
"not initialized/unlocked yet");
handle_set_allowed_modes_context_free (ctx);
handle_set_current_modes_context_free (ctx);
return;
}
mm_iface_modem_set_allowed_modes (MM_IFACE_MODEM (self),
mm_iface_modem_set_current_modes (MM_IFACE_MODEM (self),
ctx->allowed,
ctx->preferred,
(GAsyncReadyCallback)handle_set_allowed_modes_ready,
(GAsyncReadyCallback)handle_set_current_modes_ready,
ctx);
}
static gboolean
handle_set_allowed_modes (MmGdbusModem *skeleton,
handle_set_current_modes (MmGdbusModem *skeleton,
GDBusMethodInvocation *invocation,
guint allowed,
guint preferred,
GVariant *variant,
MMIfaceModem *self)
{
HandleSetAllowedModesContext *ctx;
HandleSetCurrentModesContext *ctx;
ctx = g_new (HandleSetAllowedModesContext, 1);
ctx = g_new (HandleSetCurrentModesContext, 1);
ctx->skeleton = g_object_ref (skeleton);
ctx->invocation = g_object_ref (invocation);
ctx->self = g_object_ref (self);
ctx->allowed = allowed;
ctx->preferred = preferred;
g_variant_get (variant,
"(uu)",
&ctx->allowed,
&ctx->preferred);
mm_base_modem_authorize (MM_BASE_MODEM (self),
invocation,
MM_AUTHORIZATION_DEVICE_CONTROL,
(GAsyncReadyCallback)handle_set_allowed_modes_auth_ready,
(GAsyncReadyCallback)handle_set_current_modes_auth_ready,
ctx);
return TRUE;
}
@@ -2982,7 +3034,7 @@ static void interface_disabling_step (DisablingContext *ctx);
typedef enum {
DISABLING_STEP_FIRST,
DISABLING_STEP_CURRENT_BANDS,
DISABLING_STEP_ALLOWED_MODES,
DISABLING_STEP_CURRENT_MODES,
DISABLING_STEP_LAST
} DisablingStep;
@@ -3027,10 +3079,9 @@ interface_disabling_step (DisablingContext *ctx)
/* Fall down to next step */
ctx->step++;
case DISABLING_STEP_ALLOWED_MODES:
case DISABLING_STEP_CURRENT_MODES:
/* Clear allowed/preferred modes */
mm_gdbus_modem_set_allowed_modes (ctx->skeleton, MM_MODEM_MODE_NONE);
mm_gdbus_modem_set_preferred_mode (ctx->skeleton, MM_MODEM_MODE_NONE);
mm_gdbus_modem_set_current_modes (ctx->skeleton, g_variant_new ("(uu)", MM_MODEM_MODE_NONE, MM_MODEM_MODE_NONE));
/* Fall down to next step */
ctx->step++;
@@ -3086,7 +3137,7 @@ typedef enum {
ENABLING_STEP_FLOW_CONTROL,
ENABLING_STEP_SUPPORTED_CHARSETS,
ENABLING_STEP_CHARSET,
ENABLING_STEP_ALLOWED_MODES,
ENABLING_STEP_CURRENT_MODES,
ENABLING_STEP_CURRENT_BANDS,
ENABLING_STEP_LAST
} EnablingStep;
@@ -3213,7 +3264,7 @@ setup_charset_ready (MMIfaceModem *self,
}
static void
load_allowed_modes_ready (MMIfaceModem *self,
load_current_modes_ready (MMIfaceModem *self,
GAsyncResult *res,
EnablingContext *ctx)
{
@@ -3221,7 +3272,7 @@ load_allowed_modes_ready (MMIfaceModem *self,
MMModemMode preferred = MM_MODEM_MODE_NONE;
GError *error = NULL;
if (!MM_IFACE_MODEM_GET_INTERFACE (self)->load_allowed_modes_finish (self,
if (!MM_IFACE_MODEM_GET_INTERFACE (self)->load_current_modes_finish (self,
res,
&allowed,
&preferred,
@@ -3231,12 +3282,9 @@ load_allowed_modes_ready (MMIfaceModem *self,
g_error_free (error);
/* If errors getting allowed modes, assume ANY/NONE */
allowed = MM_MODEM_MODE_ANY;
preferred = MM_MODEM_MODE_NONE;
}
mm_gdbus_modem_set_allowed_modes (ctx->skeleton, allowed);
mm_gdbus_modem_set_preferred_mode (ctx->skeleton, preferred);
mm_gdbus_modem_set_current_modes (ctx->skeleton, g_variant_new ("(uu)", MM_MODEM_MODE_ANY, MM_MODEM_MODE_NONE));
} else
mm_gdbus_modem_set_current_modes (ctx->skeleton, g_variant_new ("(uu)", allowed, preferred));
/* Done, Go on to next step */
ctx->step++;
@@ -3374,20 +3422,19 @@ interface_enabling_step (EnablingContext *ctx)
/* Fall down to next step */
ctx->step++;
case ENABLING_STEP_ALLOWED_MODES:
if (MM_IFACE_MODEM_GET_INTERFACE (ctx->self)->load_allowed_modes &&
MM_IFACE_MODEM_GET_INTERFACE (ctx->self)->load_allowed_modes_finish) {
MM_IFACE_MODEM_GET_INTERFACE (ctx->self)->load_allowed_modes (
case ENABLING_STEP_CURRENT_MODES:
if (MM_IFACE_MODEM_GET_INTERFACE (ctx->self)->load_current_modes &&
MM_IFACE_MODEM_GET_INTERFACE (ctx->self)->load_current_modes_finish) {
MM_IFACE_MODEM_GET_INTERFACE (ctx->self)->load_current_modes (
ctx->self,
(GAsyncReadyCallback)load_allowed_modes_ready,
(GAsyncReadyCallback)load_current_modes_ready,
ctx);
return;
}
/* If no way to get allowed modes, assume allowed=any,
* and none preferred */
mm_gdbus_modem_set_allowed_modes (ctx->skeleton, MM_MODEM_MODE_ANY);
mm_gdbus_modem_set_preferred_mode (ctx->skeleton, MM_MODEM_MODE_NONE);
/* If no way to get modes, assume ANY/NONE */
mm_gdbus_modem_set_current_modes (ctx->skeleton, g_variant_new ("(uu)", MM_MODEM_MODE_ANY, MM_MODEM_MODE_NONE));
/* Fall down to next step */
ctx->step++;
@@ -4227,8 +4274,8 @@ interface_initialization_step (InitializationContext *ctx)
G_CALLBACK (handle_set_current_bands),
ctx->self);
g_signal_connect (ctx->skeleton,
"handle-set-allowed-modes",
G_CALLBACK (handle_set_allowed_modes),
"handle-set-current-modes",
G_CALLBACK (handle_set_current_modes),
ctx->self);
g_simple_async_result_set_op_res_gboolean (ctx->result, TRUE);
}
@@ -4289,8 +4336,7 @@ mm_iface_modem_initialize (MMIfaceModem *self,
mm_gdbus_modem_set_access_technologies (skeleton, MM_MODEM_ACCESS_TECHNOLOGY_UNKNOWN);
mm_gdbus_modem_set_signal_quality (skeleton, g_variant_new ("(ub)", 0, FALSE));
mm_gdbus_modem_set_supported_modes (skeleton, mm_common_build_mode_combinations_default ());
mm_gdbus_modem_set_allowed_modes (skeleton, MM_MODEM_MODE_NONE);
mm_gdbus_modem_set_preferred_mode (skeleton, MM_MODEM_MODE_NONE);
mm_gdbus_modem_set_current_modes (skeleton,g_variant_new ("(uu)", MM_MODEM_MODE_NONE, MM_MODEM_MODE_NONE));
mm_gdbus_modem_set_supported_bands (skeleton, mm_common_build_bands_unknown ());
mm_gdbus_modem_set_current_bands (skeleton, mm_common_build_bands_unknown ());
mm_gdbus_modem_set_supported_ip_families (skeleton, MM_BEARER_IP_FAMILY_NONE);

16
src/mm-iface-modem.h
View File

@@ -130,11 +130,11 @@ struct _MMIfaceModem {
GAsyncResult *res,
GError **error);
/* Loading of the AllowedModes and PreferredMode properties */
void (*load_allowed_modes) (MMIfaceModem *self,
/* Loading of the Modes property */
void (*load_current_modes) (MMIfaceModem *self,
GAsyncReadyCallback callback,
gpointer user_data);
gboolean (*load_allowed_modes_finish) (MMIfaceModem *self,
gboolean (*load_current_modes_finish) (MMIfaceModem *self,
GAsyncResult *res,
MMModemMode *allowed,
MMModemMode *preferred,
@@ -226,13 +226,13 @@ struct _MMIfaceModem {
GAsyncResult *res,
GError **error);
/* Asynchronous allowed mode setting operation */
void (*set_allowed_modes) (MMIfaceModem *self,
/* Asynchronous current mode setting operation */
void (*set_current_modes) (MMIfaceModem *self,
MMModemMode modes,
MMModemMode preferred,
GAsyncReadyCallback callback,
gpointer user_data);
gboolean (*set_allowed_modes_finish) (MMIfaceModem *self,
gboolean (*set_current_modes_finish) (MMIfaceModem *self,
GAsyncResult *res,
GError **error);
@@ -417,12 +417,12 @@ void mm_iface_modem_update_signal_quality (MMIfaceModem *self,
guint signal_quality);
/* Allow setting allowed modes */
void mm_iface_modem_set_allowed_modes (MMIfaceModem *self,
void mm_iface_modem_set_current_modes (MMIfaceModem *self,
MMModemMode allowed,
MMModemMode preferred,
GAsyncReadyCallback callback,
gpointer user_data);
gboolean mm_iface_modem_set_allowed_modes_finish (MMIfaceModem *self,
gboolean mm_iface_modem_set_current_modes_finish (MMIfaceModem *self,
GAsyncResult *res,
GError **error);