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

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.

4 files changed, 192 insertions, 146 deletions

diff --git a/src/mm-broadband-modem-qmi.c b/src/mm-broadband-modem-qmi.c
index 853d940f..3e4ced73 100644
--- a/src/mm-broadband-modem-qmi.c
+++ b/src/mm-broadband-modem-qmi.c
@@ -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;
diff --git a/src/mm-iface-modem-simple.c b/src/mm-iface-modem-simple.c
index 0ab46567..5d1e1b21 100644
--- a/src/mm-iface-modem-simple.c
+++ b/src/mm-iface-modem-simple.c
@@ -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);
diff --git a/src/mm-iface-modem.c b/src/mm-iface-modem.c
index 135f18f0..59be9e67 100644
--- a/src/mm-iface-modem.c
+++ b/src/mm-iface-modem.c
@@ -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,
+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)->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,
-                         SetAllowedModesContext *ctx)
+                         SetCurrentModesContext *ctx)
 {
+    MMModemState modem_state;
     GError *error = NULL;
 
-    if (!MM_IFACE_MODEM_GET_INTERFACE (self)->set_allowed_modes_finish (self, res, &error))
+    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);
diff --git a/src/mm-iface-modem.h b/src/mm-iface-modem.h
index 65b0243f..8ba1da66 100644
--- a/src/mm-iface-modem.h
+++ b/src/mm-iface-modem.h
@@ -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);