| /* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ |
| /* |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License as published by |
| * the Free Software Foundation; either version 2 of the License, or |
| * (at your option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details: |
| * |
| * Copyright (C) 2013 Aleksander Morgado <aleksander@gnu.org> |
| */ |
| |
| #include <ModemManager.h> |
| #define _LIBMM_INSIDE_MM |
| #include <libmm-glib.h> |
| |
| #include "mm-iface-modem.h" |
| #include "mm-iface-modem-signal.h" |
| #include "mm-log.h" |
| |
| #define SUPPORT_CHECKED_TAG "signal-support-checked-tag" |
| #define SUPPORTED_TAG "signal-supported-tag" |
| #define REFRESH_CONTEXT_TAG "signal-refresh-context-tag" |
| |
| static GQuark support_checked_quark; |
| static GQuark supported_quark; |
| static GQuark refresh_context_quark; |
| |
| /*****************************************************************************/ |
| |
| void |
| mm_iface_modem_signal_bind_simple_status (MMIfaceModemSignal *self, |
| MMSimpleStatus *status) |
| { |
| } |
| |
| /*****************************************************************************/ |
| |
| typedef struct { |
| guint rate; |
| guint timeout_source; |
| } RefreshContext; |
| |
| static void |
| refresh_context_free (RefreshContext *ctx) |
| { |
| if (ctx->timeout_source) |
| g_source_remove (ctx->timeout_source); |
| g_slice_free (RefreshContext, ctx); |
| } |
| |
| static void |
| clear_values (MMIfaceModemSignal *self) |
| { |
| MmGdbusModemSignal *skeleton; |
| |
| g_object_get (self, |
| MM_IFACE_MODEM_SIGNAL_DBUS_SKELETON, &skeleton, |
| NULL); |
| if (!skeleton) |
| return; |
| |
| mm_gdbus_modem_signal_set_cdma (skeleton, NULL); |
| mm_gdbus_modem_signal_set_evdo (skeleton, NULL); |
| mm_gdbus_modem_signal_set_gsm (skeleton, NULL); |
| mm_gdbus_modem_signal_set_umts (skeleton, NULL); |
| mm_gdbus_modem_signal_set_lte (skeleton, NULL); |
| g_object_unref (skeleton); |
| } |
| |
| static void |
| load_values_ready (MMIfaceModemSignal *self, |
| GAsyncResult *res) |
| { |
| GVariant *dictionary; |
| GError *error = NULL; |
| MMSignal *cdma = NULL; |
| MMSignal *evdo = NULL; |
| MMSignal *gsm = NULL; |
| MMSignal *umts = NULL; |
| MMSignal *lte = NULL; |
| MmGdbusModemSignal *skeleton; |
| |
| if (!MM_IFACE_MODEM_SIGNAL_GET_INTERFACE (self)->load_values_finish ( |
| self, |
| res, |
| &cdma, |
| &evdo, |
| &gsm, |
| &umts, |
| <e, |
| &error)) { |
| mm_warn ("Couldn't load extended signal information: %s", error->message); |
| g_error_free (error); |
| clear_values (self); |
| return; |
| } |
| |
| g_object_get (self, |
| MM_IFACE_MODEM_SIGNAL_DBUS_SKELETON, &skeleton, |
| NULL); |
| if (!skeleton) { |
| mm_warn ("Cannot update extended signal information: " |
| "Couldn't get interface skeleton"); |
| return; |
| } |
| |
| if (cdma) { |
| dictionary = mm_signal_get_dictionary (cdma); |
| mm_gdbus_modem_signal_set_cdma (skeleton, dictionary); |
| g_variant_unref (dictionary); |
| g_object_unref (cdma); |
| } else |
| mm_gdbus_modem_signal_set_cdma (skeleton, NULL); |
| |
| if (evdo) { |
| dictionary = mm_signal_get_dictionary (evdo); |
| mm_gdbus_modem_signal_set_evdo (skeleton, dictionary); |
| g_variant_unref (dictionary); |
| g_object_unref (evdo); |
| } else |
| mm_gdbus_modem_signal_set_evdo (skeleton, NULL); |
| |
| if (gsm) { |
| dictionary = mm_signal_get_dictionary (gsm); |
| mm_gdbus_modem_signal_set_gsm (skeleton, dictionary); |
| g_variant_unref (dictionary); |
| g_object_unref (gsm); |
| } else |
| mm_gdbus_modem_signal_set_gsm (skeleton, NULL); |
| |
| if (umts) { |
| dictionary = mm_signal_get_dictionary (umts); |
| mm_gdbus_modem_signal_set_umts (skeleton, dictionary); |
| g_variant_unref (dictionary); |
| g_object_unref (umts); |
| } else |
| mm_gdbus_modem_signal_set_umts (skeleton, NULL); |
| |
| if (lte) { |
| dictionary = mm_signal_get_dictionary (lte); |
| mm_gdbus_modem_signal_set_lte (skeleton, dictionary); |
| g_variant_unref (dictionary); |
| g_object_unref (lte); |
| } else |
| mm_gdbus_modem_signal_set_lte (skeleton, NULL); |
| |
| /* Flush right away */ |
| g_dbus_interface_skeleton_flush (G_DBUS_INTERFACE_SKELETON (skeleton)); |
| |
| g_object_unref (skeleton); |
| } |
| |
| static gboolean |
| refresh_context_cb (MMIfaceModemSignal *self) |
| { |
| MM_IFACE_MODEM_SIGNAL_GET_INTERFACE (self)->load_values ( |
| self, |
| NULL, |
| (GAsyncReadyCallback)load_values_ready, |
| NULL); |
| return G_SOURCE_CONTINUE; |
| } |
| |
| static void |
| teardown_refresh_context (MMIfaceModemSignal *self) |
| { |
| mm_dbg ("Extended signal information reporting disabled"); |
| clear_values (self); |
| if (G_UNLIKELY (!refresh_context_quark)) |
| refresh_context_quark = g_quark_from_static_string (REFRESH_CONTEXT_TAG); |
| g_object_set_qdata (G_OBJECT (self), refresh_context_quark, NULL); |
| } |
| |
| static gboolean |
| setup_refresh_context (MMIfaceModemSignal *self, |
| gboolean update_rate, |
| guint new_rate, |
| GError **error) |
| { |
| MmGdbusModemSignal *skeleton; |
| RefreshContext *ctx; |
| MMModemState modem_state; |
| |
| if (G_UNLIKELY (!refresh_context_quark)) |
| refresh_context_quark = g_quark_from_static_string (REFRESH_CONTEXT_TAG); |
| |
| g_object_get (self, |
| MM_IFACE_MODEM_SIGNAL_DBUS_SKELETON, &skeleton, |
| MM_IFACE_MODEM_STATE, &modem_state, |
| NULL); |
| if (!skeleton) { |
| g_set_error (error, |
| MM_CORE_ERROR, |
| MM_CORE_ERROR_FAILED, |
| "Couldn't get interface skeleton"); |
| return FALSE; |
| } |
| |
| if (update_rate) |
| mm_gdbus_modem_signal_set_rate (skeleton, new_rate); |
| else |
| new_rate = mm_gdbus_modem_signal_get_rate (skeleton); |
| g_object_unref (skeleton); |
| |
| /* User disabling? */ |
| if (new_rate == 0) { |
| mm_dbg ("Extended signal information reporting disabled (rate: 0 seconds)"); |
| clear_values (self); |
| g_object_set_qdata (G_OBJECT (self), refresh_context_quark, NULL); |
| return TRUE; |
| } |
| |
| if (modem_state < MM_MODEM_STATE_ENABLING) { |
| mm_dbg ("Extended signal information reporting disabled (modem not yet enabled)"); |
| return TRUE; |
| } |
| |
| /* Setup refresh context */ |
| ctx = g_object_get_qdata (G_OBJECT (self), refresh_context_quark); |
| if (!ctx) { |
| ctx = g_slice_new0 (RefreshContext); |
| g_object_set_qdata_full (G_OBJECT (self), |
| refresh_context_quark, |
| ctx, |
| (GDestroyNotify)refresh_context_free); |
| } |
| |
| /* We're enabling, compare to old rate */ |
| if (ctx->rate == new_rate) { |
| /* Already there */ |
| return TRUE; |
| } |
| |
| /* Update refresh context */ |
| mm_dbg ("Extended signal information reporting enabled (rate: %u seconds)", new_rate); |
| ctx->rate = new_rate; |
| if (ctx->timeout_source) |
| g_source_remove (ctx->timeout_source); |
| ctx->timeout_source = g_timeout_add_seconds (ctx->rate, (GSourceFunc) refresh_context_cb, self); |
| |
| /* Also launch right away */ |
| refresh_context_cb (self); |
| |
| return TRUE; |
| } |
| |
| /*****************************************************************************/ |
| |
| typedef struct { |
| GDBusMethodInvocation *invocation; |
| MmGdbusModemSignal *skeleton; |
| MMIfaceModemSignal *self; |
| guint rate; |
| } HandleSetupContext; |
| |
| static void |
| handle_setup_context_free (HandleSetupContext *ctx) |
| { |
| g_object_unref (ctx->invocation); |
| g_object_unref (ctx->skeleton); |
| g_object_unref (ctx->self); |
| g_slice_free (HandleSetupContext, ctx); |
| } |
| |
| static void |
| handle_setup_auth_ready (MMBaseModem *self, |
| GAsyncResult *res, |
| HandleSetupContext *ctx) |
| { |
| GError *error = NULL; |
| |
| if (!mm_base_modem_authorize_finish (self, res, &error)) |
| g_dbus_method_invocation_take_error (ctx->invocation, error); |
| else if (!setup_refresh_context (ctx->self, TRUE, ctx->rate, &error)) |
| g_dbus_method_invocation_take_error (ctx->invocation, error); |
| else |
| mm_gdbus_modem_signal_complete_setup (ctx->skeleton, ctx->invocation); |
| handle_setup_context_free (ctx); |
| } |
| |
| static gboolean |
| handle_setup (MmGdbusModemSignal *skeleton, |
| GDBusMethodInvocation *invocation, |
| guint rate, |
| MMIfaceModemSignal *self) |
| { |
| HandleSetupContext *ctx; |
| |
| ctx = g_slice_new (HandleSetupContext); |
| ctx->invocation = g_object_ref (invocation); |
| ctx->skeleton = g_object_ref (skeleton); |
| ctx->self = g_object_ref (self); |
| ctx->rate = rate; |
| |
| mm_base_modem_authorize (MM_BASE_MODEM (self), |
| invocation, |
| MM_AUTHORIZATION_DEVICE_CONTROL, |
| (GAsyncReadyCallback)handle_setup_auth_ready, |
| ctx); |
| return TRUE; |
| } |
| |
| /*****************************************************************************/ |
| |
| gboolean |
| mm_iface_modem_signal_disable_finish (MMIfaceModemSignal *self, |
| GAsyncResult *res, |
| GError **error) |
| { |
| return g_task_propagate_boolean (G_TASK (res), error); |
| } |
| |
| void |
| mm_iface_modem_signal_disable (MMIfaceModemSignal *self, |
| GAsyncReadyCallback callback, |
| gpointer user_data) |
| { |
| GTask *task; |
| |
| teardown_refresh_context (self); |
| |
| task = g_task_new (self, NULL, callback, user_data); |
| g_task_return_boolean (task, TRUE); |
| g_object_unref (task); |
| } |
| |
| /*****************************************************************************/ |
| |
| gboolean |
| mm_iface_modem_signal_enable_finish (MMIfaceModemSignal *self, |
| GAsyncResult *res, |
| GError **error) |
| { |
| return g_task_propagate_boolean (G_TASK (res), error); |
| } |
| |
| void |
| mm_iface_modem_signal_enable (MMIfaceModemSignal *self, |
| GCancellable *cancellable, |
| GAsyncReadyCallback callback, |
| gpointer user_data) |
| { |
| GTask *task; |
| GError *error = NULL; |
| |
| task = g_task_new (self, cancellable, callback, user_data); |
| |
| if (!setup_refresh_context (self, FALSE, 0, &error)) |
| g_task_return_error (task, error); |
| else |
| g_task_return_boolean (task, TRUE); |
| |
| g_object_unref (task); |
| } |
| |
| /*****************************************************************************/ |
| |
| typedef struct _InitializationContext InitializationContext; |
| static void interface_initialization_step (GTask *task); |
| |
| typedef enum { |
| INITIALIZATION_STEP_FIRST, |
| INITIALIZATION_STEP_CHECK_SUPPORT, |
| INITIALIZATION_STEP_FAIL_IF_UNSUPPORTED, |
| INITIALIZATION_STEP_LAST |
| } InitializationStep; |
| |
| struct _InitializationContext { |
| MmGdbusModemSignal *skeleton; |
| InitializationStep step; |
| }; |
| |
| static void |
| initialization_context_free (InitializationContext *ctx) |
| { |
| g_object_unref (ctx->skeleton); |
| g_slice_free (InitializationContext, ctx); |
| } |
| |
| gboolean |
| mm_iface_modem_signal_initialize_finish (MMIfaceModemSignal *self, |
| GAsyncResult *res, |
| GError **error) |
| { |
| return g_task_propagate_boolean (G_TASK (res), error); |
| } |
| |
| static void |
| check_support_ready (MMIfaceModemSignal *self, |
| GAsyncResult *res, |
| GTask *task) |
| { |
| InitializationContext *ctx; |
| GError *error = NULL; |
| |
| if (!MM_IFACE_MODEM_SIGNAL_GET_INTERFACE (self)->check_support_finish (self, res, &error)) { |
| if (error) { |
| /* This error shouldn't be treated as critical */ |
| mm_dbg ("Extended signal support check failed: '%s'", error->message); |
| g_error_free (error); |
| } |
| } else { |
| /* Signal is supported! */ |
| g_object_set_qdata (G_OBJECT (self), |
| supported_quark, |
| GUINT_TO_POINTER (TRUE)); |
| } |
| |
| /* Go on to next step */ |
| ctx = g_task_get_task_data (task); |
| ctx->step++; |
| interface_initialization_step (task); |
| } |
| |
| static void |
| interface_initialization_step (GTask *task) |
| { |
| MMIfaceModemSignal *self; |
| InitializationContext *ctx; |
| |
| /* Don't run new steps if we're cancelled */ |
| if (g_task_return_error_if_cancelled (task)) { |
| g_object_unref (task); |
| return; |
| } |
| |
| self = g_task_get_source_object (task); |
| ctx = g_task_get_task_data (task); |
| |
| switch (ctx->step) { |
| case INITIALIZATION_STEP_FIRST: |
| /* Setup quarks if we didn't do it before */ |
| if (G_UNLIKELY (!support_checked_quark)) |
| support_checked_quark = (g_quark_from_static_string ( |
| SUPPORT_CHECKED_TAG)); |
| if (G_UNLIKELY (!supported_quark)) |
| supported_quark = (g_quark_from_static_string ( |
| SUPPORTED_TAG)); |
| |
| /* Fall down to next step */ |
| ctx->step++; |
| |
| case INITIALIZATION_STEP_CHECK_SUPPORT: |
| if (!GPOINTER_TO_UINT (g_object_get_qdata (G_OBJECT (self), |
| support_checked_quark))) { |
| /* Set the checked flag so that we don't run it again */ |
| g_object_set_qdata (G_OBJECT (self), |
| support_checked_quark, |
| GUINT_TO_POINTER (TRUE)); |
| /* Initially, assume we don't support it */ |
| g_object_set_qdata (G_OBJECT (self), |
| supported_quark, |
| GUINT_TO_POINTER (FALSE)); |
| |
| if (MM_IFACE_MODEM_SIGNAL_GET_INTERFACE (self)->check_support && |
| MM_IFACE_MODEM_SIGNAL_GET_INTERFACE (self)->check_support_finish) { |
| MM_IFACE_MODEM_SIGNAL_GET_INTERFACE (self)->check_support ( |
| self, |
| (GAsyncReadyCallback)check_support_ready, |
| task); |
| return; |
| } |
| |
| /* If there is no implementation to check support, assume we DON'T |
| * support it. */ |
| } |
| /* Fall down to next step */ |
| ctx->step++; |
| |
| case INITIALIZATION_STEP_FAIL_IF_UNSUPPORTED: |
| if (!GPOINTER_TO_UINT (g_object_get_qdata (G_OBJECT (self), |
| supported_quark))) { |
| g_task_return_new_error (task, |
| MM_CORE_ERROR, |
| MM_CORE_ERROR_UNSUPPORTED, |
| "Extended Signal information not supported"); |
| g_object_unref (task); |
| return; |
| } |
| /* Fall down to next step */ |
| ctx->step++; |
| |
| case INITIALIZATION_STEP_LAST: |
| /* We are done without errors! */ |
| |
| /* Handle method invocations */ |
| g_signal_connect (ctx->skeleton, |
| "handle-setup", |
| G_CALLBACK (handle_setup), |
| self); |
| /* Finally, export the new interface */ |
| mm_gdbus_object_skeleton_set_modem_signal (MM_GDBUS_OBJECT_SKELETON (self), |
| MM_GDBUS_MODEM_SIGNAL (ctx->skeleton)); |
| |
| g_task_return_boolean (task, TRUE); |
| g_object_unref (task); |
| return; |
| } |
| |
| g_assert_not_reached (); |
| } |
| |
| void |
| mm_iface_modem_signal_initialize (MMIfaceModemSignal *self, |
| GCancellable *cancellable, |
| GAsyncReadyCallback callback, |
| gpointer user_data) |
| { |
| InitializationContext *ctx; |
| MmGdbusModemSignal *skeleton = NULL; |
| GTask *task; |
| |
| /* Did we already create it? */ |
| g_object_get (self, |
| MM_IFACE_MODEM_SIGNAL_DBUS_SKELETON, &skeleton, |
| NULL); |
| if (!skeleton) { |
| skeleton = mm_gdbus_modem_signal_skeleton_new (); |
| clear_values (self); |
| g_object_set (self, |
| MM_IFACE_MODEM_SIGNAL_DBUS_SKELETON, skeleton, |
| NULL); |
| } |
| |
| /* Perform async initialization here */ |
| |
| ctx = g_slice_new0 (InitializationContext); |
| ctx->step = INITIALIZATION_STEP_FIRST; |
| ctx->skeleton = skeleton; |
| |
| task = g_task_new (self, cancellable, callback, user_data); |
| g_task_set_task_data (task, ctx, (GDestroyNotify)initialization_context_free); |
| |
| interface_initialization_step (task); |
| } |
| |
| void |
| mm_iface_modem_signal_shutdown (MMIfaceModemSignal *self) |
| { |
| /* Teardown refresh context */ |
| teardown_refresh_context (self); |
| |
| /* Unexport DBus interface and remove the skeleton */ |
| mm_gdbus_object_skeleton_set_modem_signal (MM_GDBUS_OBJECT_SKELETON (self), NULL); |
| g_object_set (self, |
| MM_IFACE_MODEM_SIGNAL_DBUS_SKELETON, NULL, |
| NULL); |
| } |
| |
| /*****************************************************************************/ |
| |
| static void |
| iface_modem_signal_init (gpointer g_iface) |
| { |
| static gboolean initialized = FALSE; |
| |
| if (initialized) |
| return; |
| |
| /* Properties */ |
| g_object_interface_install_property |
| (g_iface, |
| g_param_spec_object (MM_IFACE_MODEM_SIGNAL_DBUS_SKELETON, |
| "Signal DBus skeleton", |
| "DBus skeleton for the Signal interface", |
| MM_GDBUS_TYPE_MODEM_SIGNAL_SKELETON, |
| G_PARAM_READWRITE)); |
| |
| initialized = TRUE; |
| } |
| |
| GType |
| mm_iface_modem_signal_get_type (void) |
| { |
| static GType iface_modem_signal_type = 0; |
| |
| if (!G_UNLIKELY (iface_modem_signal_type)) { |
| static const GTypeInfo info = { |
| sizeof (MMIfaceModemSignal), /* class_size */ |
| iface_modem_signal_init, /* base_init */ |
| NULL, /* base_finalize */ |
| }; |
| |
| iface_modem_signal_type = g_type_register_static (G_TYPE_INTERFACE, |
| "MMIfaceModemSignal", |
| &info, |
| 0); |
| |
| g_type_interface_add_prerequisite (iface_modem_signal_type, MM_TYPE_IFACE_MODEM); |
| } |
| |
| return iface_modem_signal_type; |
| } |