/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
* libmm -- Access modem status & information from glib applications
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301 USA.
*
* Copyright (C) 2011 - 2012 Google, Inc.
* Copyright (C) 2011 - 2018 Aleksander Morgado <aleksander@aleksander.es>
*/
#include <ModemManager.h>
#include "mm-helpers.h"
#include "mm-errors-types.h"
#include "mm-gdbus-manager.h"
#include "mm-manager.h"
#include "mm-object.h"
/**
* SECTION: mm-manager
* @title: MMManager
* @short_description: The Manager object
*
* The #MMManager is the object allowing access to the Manager interface.
*
* This object is also a #GDBusObjectManagerClient, and therefore it allows to
* use the standard ObjectManager interface to list and handle the managed
* modem objects.
*/
G_DEFINE_TYPE (MMManager, mm_manager, MM_GDBUS_TYPE_OBJECT_MANAGER_CLIENT)
struct _MMManagerPrivate {
/* The proxy for the Manager interface */
MmGdbusOrgFreedesktopModemManager1 *manager_iface_proxy;
};
/*****************************************************************************/
static GType
get_proxy_type (GDBusObjectManagerClient *manager,
const gchar *object_path,
const gchar *interface_name,
gpointer user_data)
{
static gsize once_init_value = 0;
static GHashTable *lookup_hash;
GType ret;
if (interface_name == NULL)
return MM_TYPE_OBJECT;
if (g_once_init_enter (&once_init_value)) {
lookup_hash = g_hash_table_new (g_str_hash, g_str_equal);
g_hash_table_insert (lookup_hash, "org.freedesktop.ModemManager1.Modem", GSIZE_TO_POINTER (MM_TYPE_MODEM));
g_hash_table_insert (lookup_hash, "org.freedesktop.ModemManager1.Modem.Messaging", GSIZE_TO_POINTER (MM_TYPE_MODEM_MESSAGING));
g_hash_table_insert (lookup_hash, "org.freedesktop.ModemManager1.Modem.Voice", GSIZE_TO_POINTER (MM_TYPE_MODEM_VOICE));
g_hash_table_insert (lookup_hash, "org.freedesktop.ModemManager1.Modem.Location", GSIZE_TO_POINTER (MM_TYPE_MODEM_LOCATION));
g_hash_table_insert (lookup_hash, "org.freedesktop.ModemManager1.Modem.Time", GSIZE_TO_POINTER (MM_TYPE_MODEM_TIME));
g_hash_table_insert (lookup_hash, "org.freedesktop.ModemManager1.Modem.Signal", GSIZE_TO_POINTER (MM_TYPE_MODEM_SIGNAL));
g_hash_table_insert (lookup_hash, "org.freedesktop.ModemManager1.Modem.Firmware", GSIZE_TO_POINTER (MM_TYPE_MODEM_FIRMWARE));
g_hash_table_insert (lookup_hash, "org.freedesktop.ModemManager1.Modem.Oma", GSIZE_TO_POINTER (MM_TYPE_MODEM_OMA));
g_hash_table_insert (lookup_hash, "org.freedesktop.ModemManager1.Modem.ModemCdma", GSIZE_TO_POINTER (MM_TYPE_MODEM_CDMA));
g_hash_table_insert (lookup_hash, "org.freedesktop.ModemManager1.Modem.Modem3gpp", GSIZE_TO_POINTER (MM_TYPE_MODEM_3GPP));
g_hash_table_insert (lookup_hash, "org.freedesktop.ModemManager1.Modem.Modem3gpp.Ussd", GSIZE_TO_POINTER (MM_TYPE_MODEM_3GPP_USSD));
g_hash_table_insert (lookup_hash, "org.freedesktop.ModemManager1.Modem.Simple", GSIZE_TO_POINTER (MM_TYPE_MODEM_SIMPLE));
/* g_hash_table_insert (lookup_hash, "org.freedesktop.ModemManager1.Modem.Contacts", GSIZE_TO_POINTER (MM_GDBUS_TYPE_MODEM_CONTACTS_PROXY)); */
g_once_init_leave (&once_init_value, 1);
}
ret = (GType) GPOINTER_TO_SIZE (g_hash_table_lookup (lookup_hash, interface_name));
if (ret == (GType) 0)
ret = G_TYPE_DBUS_PROXY;
return ret;
}
/*****************************************************************************/
static void
cleanup_modem_manager1_proxy (MMManager *self)
{
if (self->priv->manager_iface_proxy) {
g_signal_handlers_disconnect_by_func (self, cleanup_modem_manager1_proxy, NULL);
g_clear_object (&self->priv->manager_iface_proxy);
}
}
static gboolean
ensure_modem_manager1_proxy (MMManager *self,
GError **error)
{
gchar *name = NULL;
gchar *object_path = NULL;
GDBusObjectManagerClientFlags obj_manager_flags = G_DBUS_OBJECT_MANAGER_CLIENT_FLAGS_NONE;
GDBusProxyFlags proxy_flags = G_DBUS_PROXY_FLAGS_NONE;
GDBusConnection *connection = NULL;
if (self->priv->manager_iface_proxy)
return TRUE;
/* Get the Manager proxy created synchronously now */
g_object_get (self,
"name", &name,
"object-path", &object_path,
"flags", &obj_manager_flags,
"connection", &connection,
NULL);
if (obj_manager_flags & G_DBUS_OBJECT_MANAGER_CLIENT_FLAGS_DO_NOT_AUTO_START)
proxy_flags |= G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START;
self->priv->manager_iface_proxy =
mm_gdbus_org_freedesktop_modem_manager1_proxy_new_sync (connection,
proxy_flags,
name,
object_path,
NULL,
error);
g_object_unref (connection);
g_free (object_path);
g_free (name);
if (self->priv->manager_iface_proxy)
g_signal_connect (self,
"notify::name-owner",
G_CALLBACK (cleanup_modem_manager1_proxy),
NULL);
return !!self->priv->manager_iface_proxy;
}
/*****************************************************************************/
/**
* mm_manager_new_finish:
* @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_manager_new().
* @error: Return location for error or %NULL
*
* Finishes an operation started with mm_manager_new().
*
* Returns: (transfer full) (type MMManager): The constructed object manager client or %NULL if @error is set.
*/
MMManager *
mm_manager_new_finish (GAsyncResult *res,
GError **error)
{
GObject *ret;
GObject *source_object;
source_object = g_async_result_get_source_object (res);
ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
g_object_unref (source_object);
return MM_MANAGER (ret);
}
/**
* mm_manager_new:
* @connection: A #GDBusConnection.
* @flags: Flags from the #GDBusObjectManagerClientFlags enumeration.
* @cancellable: (allow-none): A #GCancellable or %NULL.
* @callback: A #GAsyncReadyCallback to call when the request is satisfied.
* @user_data: User data to pass to @callback.
*
* Asynchronously creates a #MMManager.
*
* When the operation is finished, @callback will be invoked in the
* <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
* of the thread you are calling this method from.
*
* You can then call mm_manager_new_finish() to get the result of the operation.
*
* See mm_manager_new_sync() for the synchronous, blocking version of this constructor.
*/
void
mm_manager_new (GDBusConnection *connection,
GDBusObjectManagerClientFlags flags,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
g_async_initable_new_async (MM_TYPE_MANAGER,
G_PRIORITY_DEFAULT,
cancellable,
callback,
user_data,
"name", MM_DBUS_SERVICE,
"object-path", MM_DBUS_PATH,
"flags", flags,
"connection", connection,
"get-proxy-type-func", get_proxy_type,
NULL);
}
/**
* mm_manager_new_sync:
* @connection: A #GDBusConnection.
* @flags: Flags from the #GDBusObjectManagerClientFlags enumeration.
* @cancellable: (allow-none): A #GCancellable or %NULL.
* @error: Return location for error or %NULL
*
* Synchronously creates a #MMManager.
*
* The calling thread is blocked until a reply is received.
*
* See mm_manager_new() for the asynchronous version of this constructor.
*
* Returns: (transfer full) (type MMManager): The constructed object manager client or %NULL if @error is set.
*/
MMManager *
mm_manager_new_sync (GDBusConnection *connection,
GDBusObjectManagerClientFlags flags,
GCancellable *cancellable,
GError **error)
{
return MM_MANAGER (g_initable_new (MM_TYPE_MANAGER,
cancellable,
error,
"name", MM_DBUS_SERVICE,
"object-path", MM_DBUS_PATH,
"flags", flags,
"connection", connection,
"get-proxy-type-func", get_proxy_type,
NULL));
}
/*****************************************************************************/
/**
* mm_manager_peek_proxy:
* @manager: A #MMManager.
*
* Gets the #GDBusProxy interface of the @manager.
*
* Returns: (transfer none): The #GDBusProxy interface of @manager, or #NULL if none. Do not free the returned object, it is owned by @manager.
*/
GDBusProxy *
mm_manager_peek_proxy (MMManager *manager)
{
g_return_val_if_fail (MM_IS_MANAGER (manager), NULL);
if (!ensure_modem_manager1_proxy (manager, NULL))
return NULL;
return G_DBUS_PROXY (manager->priv->manager_iface_proxy);
}
/**
* mm_manager_get_proxy:
* @manager: A #MMManager.
*
* Gets the #GDBusProxy interface of the @manager.
*
* Returns: (transfer full): The #GDBusProxy interface of @manager, or #NULL if none. The returned object must be freed with g_object_unref().
*/
GDBusProxy *
mm_manager_get_proxy (MMManager *manager)
{
g_return_val_if_fail (MM_IS_MANAGER (manager), NULL);
if (!ensure_modem_manager1_proxy (manager, NULL))
return NULL;
return G_DBUS_PROXY (g_object_ref (manager->priv->manager_iface_proxy));
}
/*****************************************************************************/
/**
* mm_manager_get_version:
* @manager: A #MMManager.
*
* Gets the ModemManager version, as reported by the daemon.
*
* It is safe to assume this value never changes during runtime.
*
* Returns: (transfer none): The version, or %NULL if none available. Do not free the returned value, it belongs to @self.
*/
const gchar *
mm_manager_get_version (MMManager *manager)
{
g_return_val_if_fail (MM_IS_MANAGER (manager), NULL);
if (!ensure_modem_manager1_proxy (manager, NULL))
return NULL;
RETURN_NON_EMPTY_CONSTANT_STRING (
mm_gdbus_org_freedesktop_modem_manager1_get_version (manager->priv->manager_iface_proxy));
}
/*****************************************************************************/
/**
* mm_manager_set_logging_finish:
* @manager: A #MMManager.
* @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_manager_set_logging().
* @error: Return location for error or %NULL.
*
* Finishes an operation started with mm_manager_set_logging().
*
* Returns: %TRUE if the call succeeded, %FALSE if @error is set.
*/
gboolean
mm_manager_set_logging_finish (MMManager *manager,
GAsyncResult *res,
GError **error)
{
return g_task_propagate_boolean (G_TASK (res), error);
}
static void
set_logging_ready (MmGdbusOrgFreedesktopModemManager1 *manager_iface_proxy,
GAsyncResult *res,
GTask *task)
{
GError *error = NULL;
if (!mm_gdbus_org_freedesktop_modem_manager1_call_set_logging_finish (
manager_iface_proxy,
res,
&error))
g_task_return_error (task, error);
else
g_task_return_boolean (task, TRUE);
g_object_unref (task);
}
/**
* mm_manager_set_logging:
* @manager: A #MMManager.
* @level: the login level to set.
* @cancellable: (allow-none): A #GCancellable or %NULL.
* @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
* @user_data: User data to pass to @callback.
*
* Asynchronously requests to set the specified logging level in the daemon.
*
* When the operation is finished, @callback will be invoked in the
* <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
* of the thread you are calling this method from. You can then call
* mm_manager_set_logging_finish() to get the result of the operation.
*
* See mm_manager_set_logging_sync() for the synchronous, blocking version of this method.
*/
void
mm_manager_set_logging (MMManager *manager,
const gchar *level,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GTask *task;
GError *inner_error = NULL;
g_return_if_fail (MM_IS_MANAGER (manager));
task = g_task_new (manager, cancellable, callback, user_data);
if (!ensure_modem_manager1_proxy (manager, &inner_error)) {
g_task_return_error (task, inner_error);
g_object_unref (task);
return;
}
mm_gdbus_org_freedesktop_modem_manager1_call_set_logging (
manager->priv->manager_iface_proxy,
level,
cancellable,
(GAsyncReadyCallback)set_logging_ready,
task);
}
/**
* mm_manager_set_logging_sync:
* @manager: A #MMManager.
* @level: the login level to set.
* @cancellable: (allow-none): A #GCancellable or %NULL.
* @error: Return location for error or %NULL.
*
* Synchronously requests to set the specified logging level in the daemon..
*
* The calling thread is blocked until a reply is received.
*
* See mm_manager_set_logging() for the asynchronous version of this method.
*
* Returns: %TRUE if the call succeeded, %FALSE if @error is set.
*/
gboolean
mm_manager_set_logging_sync (MMManager *manager,
const gchar *level,
GCancellable *cancellable,
GError **error)
{
g_return_val_if_fail (MM_IS_MANAGER (manager), FALSE);
if (!ensure_modem_manager1_proxy (manager, error))
return FALSE;
return (mm_gdbus_org_freedesktop_modem_manager1_call_set_logging_sync (
manager->priv->manager_iface_proxy,
level,
cancellable,
error));
}
/*****************************************************************************/
/**
* mm_manager_scan_devices_finish:
* @manager: A #MMManager.
* @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_manager_scan_devices().
* @error: Return location for error or %NULL.
*
* Finishes an operation started with mm_manager_scan_devices().
*
* Returns: %TRUE if the call succeeded, %FALSE if @error is set.
*/
gboolean
mm_manager_scan_devices_finish (MMManager *manager,
GAsyncResult *res,
GError **error)
{
return g_task_propagate_boolean (G_TASK (res), error);
}
static void
scan_devices_ready (MmGdbusOrgFreedesktopModemManager1 *manager_iface_proxy,
GAsyncResult *res,
GTask *task)
{
GError *error = NULL;
if (!mm_gdbus_org_freedesktop_modem_manager1_call_scan_devices_finish (
manager_iface_proxy,
res,
&error))
g_task_return_error (task, error);
else
g_task_return_boolean (task, TRUE);
g_object_unref (task);
}
/**
* mm_manager_scan_devices:
* @manager: A #MMManager.
* @cancellable: (allow-none): A #GCancellable or %NULL.
* @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
* @user_data: User data to pass to @callback.
*
* Asynchronously requests to scan looking for devices.
*
* When the operation is finished, @callback will be invoked in the
* <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
* of the thread you are calling this method from. You can then call
* mm_manager_scan_devices_finish() to get the result of the operation.
*
* See mm_manager_scan_devices_sync() for the synchronous, blocking version of this method.
*/
void
mm_manager_scan_devices (MMManager *manager,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GTask *task;
GError *inner_error = NULL;
g_return_if_fail (MM_IS_MANAGER (manager));
task = g_task_new (manager, cancellable, callback, user_data);
if (!ensure_modem_manager1_proxy (manager, &inner_error)) {
g_task_return_error (task, inner_error);
g_object_unref (task);
return;
}
mm_gdbus_org_freedesktop_modem_manager1_call_scan_devices (
manager->priv->manager_iface_proxy,
cancellable,
(GAsyncReadyCallback)scan_devices_ready,
task);
}
/**
* mm_manager_scan_devices_sync:
* @manager: A #MMManager.
* @cancellable: (allow-none): A #GCancellable or %NULL.
* @error: Return location for error or %NULL.
*
* Synchronously requests to scan looking for devices.
*
* The calling thread is blocked until a reply is received.
*
* See mm_manager_scan_devices() for the asynchronous version of this method.
*
* Returns: %TRUE if the call succeeded, %FALSE if @error is set.
*/
gboolean
mm_manager_scan_devices_sync (MMManager *manager,
GCancellable *cancellable,
GError **error)
{
g_return_val_if_fail (MM_IS_MANAGER (manager), FALSE);
if (!ensure_modem_manager1_proxy (manager, error))
return FALSE;
return (mm_gdbus_org_freedesktop_modem_manager1_call_scan_devices_sync (
manager->priv->manager_iface_proxy,
cancellable,
error));
}
/*****************************************************************************/
/**
* mm_manager_report_kernel_event_finish:
* @manager: A #MMManager.
* @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_manager_report_kernel_event().
* @error: Return location for error or %NULL.
*
* Finishes an operation started with mm_manager_report_kernel_event().
*
* Returns: %TRUE if the operation succeeded, %FALSE if @error is set.
*/
gboolean
mm_manager_report_kernel_event_finish (MMManager *manager,
GAsyncResult *res,
GError **error)
{
return g_task_propagate_boolean (G_TASK (res), error);
}
static void
report_kernel_event_ready (MmGdbusOrgFreedesktopModemManager1 *manager_iface_proxy,
GAsyncResult *res,
GTask *task)
{
GError *error = NULL;
if (!mm_gdbus_org_freedesktop_modem_manager1_call_report_kernel_event_finish (
manager_iface_proxy,
res,
&error))
g_task_return_error (task, error);
else
g_task_return_boolean (task, TRUE);
g_object_unref (task);
}
/**
* mm_manager_report_kernel_event:
* @manager: A #MMManager.
* @properties: the properties of the kernel event.
* @cancellable: (allow-none): A #GCancellable or %NULL.
* @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
* @user_data: User data to pass to @callback.
*
* Asynchronously report kernel event.
*
* When the operation is finished, @callback will be invoked in the
* <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
* of the thread you are calling this method from. You can then call
* mm_manager_report_kernel_event_finish() to get the result of the operation.
*
* See mm_manager_report_kernel_event_sync() for the synchronous, blocking version of this method.
*/
void
mm_manager_report_kernel_event (MMManager *manager,
MMKernelEventProperties *properties,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GTask *task;
GError *inner_error = NULL;
GVariant *dictionary;
g_return_if_fail (MM_IS_MANAGER (manager));
task = g_task_new (manager, cancellable, callback, user_data);
if (!ensure_modem_manager1_proxy (manager, &inner_error)) {
g_task_return_error (task, inner_error);
g_object_unref (task);
return;
}
dictionary = mm_kernel_event_properties_get_dictionary (properties);
mm_gdbus_org_freedesktop_modem_manager1_call_report_kernel_event (
manager->priv->manager_iface_proxy,
dictionary,
cancellable,
(GAsyncReadyCallback)report_kernel_event_ready,
task);
g_variant_unref (dictionary);
}
/**
* mm_manager_report_kernel_event_sync:
* @manager: A #MMManager.
* @properties: the properties of the kernel event.
* @cancellable: (allow-none): A #GCancellable or %NULL.
* @error: Return location for error or %NULL.
*
* Synchronously report kernel event.
*
* The calling thread is blocked until a reply is received.
*
* See mm_manager_report_kernel_event() for the asynchronous version of this method.
*
* Returns: %TRUE if the operation succeeded, %FALSE if @error is set.
*/
gboolean
mm_manager_report_kernel_event_sync (MMManager *manager,
MMKernelEventProperties *properties,
GCancellable *cancellable,
GError **error)
{
GVariant *dictionary;
gboolean result;
g_return_val_if_fail (MM_IS_MANAGER (manager), FALSE);
if (!ensure_modem_manager1_proxy (manager, error))
return FALSE;
dictionary = mm_kernel_event_properties_get_dictionary (properties);
result = (mm_gdbus_org_freedesktop_modem_manager1_call_report_kernel_event_sync (
manager->priv->manager_iface_proxy,
dictionary,
cancellable,
error));
g_variant_unref (dictionary);
return result;
}
/*****************************************************************************/
static gboolean
common_inhibit_device_finish (MMManager *manager,
GAsyncResult *res,
GError **error)
{
return g_task_propagate_boolean (G_TASK (res), error);
}
static void
inhibit_ready (MmGdbusOrgFreedesktopModemManager1 *manager_iface_proxy,
GAsyncResult *res,
GTask *task)
{
GError *error = NULL;
if (!mm_gdbus_org_freedesktop_modem_manager1_call_inhibit_device_finish (manager_iface_proxy, res, &error))
g_task_return_error (task, error);
else
g_task_return_boolean (task, TRUE);
g_object_unref (task);
}
static void
common_inhibit_device (MMManager *manager,
const gchar *uid,
gboolean inhibit,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GTask *task;
GError *inner_error = NULL;
task = g_task_new (manager, cancellable, callback, user_data);
if (!ensure_modem_manager1_proxy (manager, &inner_error)) {
g_task_return_error (task, inner_error);
g_object_unref (task);
return;
}
mm_gdbus_org_freedesktop_modem_manager1_call_inhibit_device (
manager->priv->manager_iface_proxy,
uid,
inhibit,
cancellable,
(GAsyncReadyCallback)inhibit_ready,
task);
}
static gboolean
common_inhibit_device_sync (MMManager *manager,
const gchar *uid,
gboolean inhibit,
GCancellable *cancellable,
GError **error)
{
if (!ensure_modem_manager1_proxy (manager, error))
return FALSE;
return (mm_gdbus_org_freedesktop_modem_manager1_call_inhibit_device_sync (
manager->priv->manager_iface_proxy,
uid,
inhibit,
cancellable,
error));
}
/**
* mm_manager_inhibit_device_finish:
* @manager: A #MMManager.
* @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_manager_inhibit_device().
* @error: Return location for error or %NULL.
*
* Finishes an operation started with mm_manager_inhibit_device().
*
* Returns: %TRUE if the call succeeded, %FALSE if @error is set.
*/
gboolean
mm_manager_inhibit_device_finish (MMManager *manager,
GAsyncResult *res,
GError **error)
{
g_return_val_if_fail (MM_IS_MANAGER (manager), FALSE);
return common_inhibit_device_finish (manager, res, error);
}
/**
* mm_manager_inhibit_device:
* @manager: A #MMManager.
* @uid: the unique ID of the physical device.
* @cancellable: (allow-none): A #GCancellable or %NULL.
* @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
* @user_data: User data to pass to @callback.
*
* Asynchronously requests to add an inhibition on the device identified by @uid.
*
* The @uid must be the unique ID retrieved from an existing #MMModem using
* mm_modem_get_device(). The caller should keep track of this @uid and use it
* in the mm_manager_uninhibit_device() call when the inhibition is no longer required.
*
* The inhibition added with this method may also be automatically removed when
* the caller program disappears from the bus (e.g. if the program ends before
* having called mm_manager_uninhibit_device() explicitly).
*
* When the operation is finished, @callback will be invoked in the
* <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
* of the thread you are calling this method from. You can then call
* mm_manager_inhibit_device_finish() to get the result of the operation.
*
* See mm_manager_inhibit_device_sync() for the synchronous, blocking version of this method.
*/
void
mm_manager_inhibit_device (MMManager *manager,
const gchar *uid,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
g_return_if_fail (MM_IS_MANAGER (manager));
common_inhibit_device (manager, uid, TRUE, cancellable, callback, user_data);
}
/**
* mm_manager_inhibit_device_sync:
* @manager: A #MMManager.
* @uid: the unique ID of the physical device.
* @cancellable: (allow-none): A #GCancellable or %NULL.
* @error: Return location for error or %NULL.
*
* Synchronously requests to add an inhibition on the device identified by @uid.
*
* The @uid must be the unique ID retrieved from an existing #MMModem using
* mm_modem_get_device(). The caller should keep track of this @uid and use it
* in the mm_manager_uninhibit_device_sync() call when the inhibition is no longer required.
*
* The inhibition added with this method may also be automatically removed when
* the caller program disappears from the bus (e.g. if the program ends before
* having called mm_manager_uninhibit_device_sync() explicitly).
*
* See mm_manager_inhibit_device() for the asynchronous version of this method.
*
* Returns: %TRUE if the call succeeded, %FALSE if @error is set.
*/
gboolean
mm_manager_inhibit_device_sync (MMManager *manager,
const gchar *uid,
GCancellable *cancellable,
GError **error)
{
g_return_val_if_fail (MM_IS_MANAGER (manager), FALSE);
return common_inhibit_device_sync (manager, uid, TRUE, cancellable, error);
}
/**
* mm_manager_uninhibit_device_finish:
* @manager: A #MMManager.
* @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_manager_uninhibit_device().
* @error: Return location for error or %NULL.
*
* Finishes an operation started with mm_manager_uninhibit_device().
*
* Returns: %TRUE if the call succeeded, %FALSE if @error is set.
*/
gboolean
mm_manager_uninhibit_device_finish (MMManager *manager,
GAsyncResult *res,
GError **error)
{
g_return_val_if_fail (MM_IS_MANAGER (manager), FALSE);
return common_inhibit_device_finish (manager, res, error);
}
/**
* mm_manager_uninhibit_device:
* @manager: A #MMManager.
* @uid: the unique ID of the physical device.
* @cancellable: (allow-none): A #GCancellable or %NULL.
* @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
* @user_data: User data to pass to @callback.
*
* Asynchronously requests to remove an inhibition on the device identified by @uid.
*
* The @uid must be the same unique ID that was sent in the inhibition request.
*
* Only the same program that placed an inhibition on a given device is able to remove
* the inhibition.
*
* When the operation is finished, @callback will be invoked in the
* <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
* of the thread you are calling this method from. You can then call
* mm_manager_uninhibit_device_finish() to get the result of the operation.
*
* See mm_manager_uninhibit_device_sync() for the synchronous, blocking version of this method.
*/
void
mm_manager_uninhibit_device (MMManager *manager,
const gchar *uid,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
g_return_if_fail (MM_IS_MANAGER (manager));
common_inhibit_device (manager, uid, FALSE, cancellable, callback, user_data);
}
/**
* mm_manager_uninhibit_device_sync:
* @manager: A #MMManager.
* @uid: the unique ID of the physical device.
* @cancellable: (allow-none): A #GCancellable or %NULL.
* @error: Return location for error or %NULL.
*
* Synchronously requests to remove an inhibition on the device identified by @uid.
*
* The @uid must be the same unique ID that was sent in the inhibition request.
*
* Only the same program that placed an inhibition on a given device is able to remove
* the inhibition.
*
* See mm_manager_uninhibit_device() for the asynchronous version of this method.
*
* Returns: %TRUE if the call succeeded, %FALSE if @error is set.
*/
gboolean
mm_manager_uninhibit_device_sync (MMManager *manager,
const gchar *uid,
GCancellable *cancellable,
GError **error)
{
g_return_val_if_fail (MM_IS_MANAGER (manager), FALSE);
return common_inhibit_device_sync (manager, uid, FALSE, cancellable, error);
}
/*****************************************************************************/
static void
register_dbus_errors (void)
{
static volatile guint32 aux = 0;
if (aux)
return;
/* Register all known own errors */
aux |= MM_CORE_ERROR;
aux |= MM_MOBILE_EQUIPMENT_ERROR;
aux |= MM_CONNECTION_ERROR;
aux |= MM_SERIAL_ERROR;
aux |= MM_MESSAGE_ERROR;
aux |= MM_CDMA_ACTIVATION_ERROR;
}
static void
mm_manager_init (MMManager *manager)
{
register_dbus_errors ();
/* Setup private data */
manager->priv = G_TYPE_INSTANCE_GET_PRIVATE ((manager),
MM_TYPE_MANAGER,
MMManagerPrivate);
}
static void
dispose (GObject *object)
{
MMManager *self = MM_MANAGER (object);
g_clear_object (&self->priv->manager_iface_proxy);
G_OBJECT_CLASS (mm_manager_parent_class)->dispose (object);
}
static void
mm_manager_class_init (MMManagerClass *manager_class)
{
GObjectClass *object_class = G_OBJECT_CLASS (manager_class);
g_type_class_add_private (object_class, sizeof (MMManagerPrivate));
/* Virtual methods */
object_class->dispose = dispose;
}