MMManager

MMManager — The Manager object

Synopsis

struct              MMManager;

GDBusProxy *        mm_manager_peek_proxy               (MMManager *manager);
GDBusProxy *        mm_manager_get_proxy                (MMManager *manager);

void                mm_manager_new                      (GDBusConnection *connection,
                                                         GDBusObjectManagerClientFlags flags,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
MMManager *         mm_manager_new_finish               (GAsyncResult *res,
                                                         GError **error);
MMManager *         mm_manager_new_sync                 (GDBusConnection *connection,
                                                         GDBusObjectManagerClientFlags flags,
                                                         GCancellable *cancellable,
                                                         GError **error);

void                mm_manager_scan_devices             (MMManager *manager,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            mm_manager_scan_devices_finish      (MMManager *manager,
                                                         GAsyncResult *res,
                                                         GError **error);
gboolean            mm_manager_scan_devices_sync        (MMManager *manager,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                mm_manager_set_logging              (MMManager *manager,
                                                         const gchar *level,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            mm_manager_set_logging_finish       (MMManager *manager,
                                                         GAsyncResult *res,
                                                         GError **error);
gboolean            mm_manager_set_logging_sync         (MMManager *manager,
                                                         const gchar *level,
                                                         GCancellable *cancellable,
                                                         GError **error);

Object Hierarchy

  GObject
   +----GDBusObjectManagerClient
         +----MmGdbusObjectManagerClient
               +----MMManager

Implemented Interfaces

MMManager implements GInitable, GAsyncInitable and GDBusObjectManager.

Description

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.

Details

struct MMManager

struct MMManager;

The MMManager structure contains private data and should only be accessed using the provided API.

mm_manager_peek_proxy ()

GDBusProxy *        mm_manager_peek_proxy               (MMManager *manager);

Gets the GDBusProxy interface of the manager.

`manager` :	A MMManager.
Returns :	The GDBusProxy interface of `manager`, or NULL if none. Do not free the returned object, it is owned by `manager`. [transfer none]

mm_manager_get_proxy ()

GDBusProxy *        mm_manager_get_proxy                (MMManager *manager);

Gets the GDBusProxy interface of the manager.

`manager` :	A MMManager.
Returns :	The GDBusProxy interface of `manager`, or NULL if none. The returned object must be freed with `g_object_unref()`. [transfer full]

mm_manager_new ()

void                mm_manager_new                      (GDBusConnection *connection,
                                                         GDBusObjectManagerClientFlags flags,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Asynchronously creates a MMManager.

When the operation is finished, callback will be invoked in the thread-default main loop 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.

`connection` :	A GDBusConnection.
`flags` :	Flags from the GDBusObjectManagerClientFlags enumeration.
`cancellable` :	A GCancellable or `NULL`. [allow-none]
`callback` :	A GAsyncReadyCallback to call when the request is satisfied.
`user_data` :	User data to pass to `callback`.

mm_manager_new_finish ()

MMManager *         mm_manager_new_finish               (GAsyncResult *res,
                                                         GError **error);

Finishes an operation started with mm_manager_new().

`res` :	The GAsyncResult obtained from the GAsyncReadyCallback passed to `mm_manager_new()`.
`error` :	Return location for error or `NULL`
Returns :	The constructed object manager client or `NULL` if `error` is set. [transfer full][type MMManager]

mm_manager_new_sync ()

MMManager *         mm_manager_new_sync                 (GDBusConnection *connection,
                                                         GDBusObjectManagerClientFlags flags,
                                                         GCancellable *cancellable,
                                                         GError **error);

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.

`connection` :	A GDBusConnection.
`flags` :	Flags from the GDBusObjectManagerClientFlags enumeration.
`cancellable` :	A GCancellable or `NULL`. [allow-none]
`error` :	Return location for error or `NULL`
Returns :	The constructed object manager client or `NULL` if `error` is set. [transfer full][type MMManager]

mm_manager_scan_devices ()

void                mm_manager_scan_devices             (MMManager *manager,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Asynchronously requests to scan looking for devices.

When the operation is finished, callback will be invoked in the thread-default main loop 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.

`manager` :	A MMManager.
`cancellable` :	A GCancellable or `NULL`. [allow-none]
`callback` :	A GAsyncReadyCallback to call when the request is satisfied or `NULL`.
`user_data` :	User data to pass to `callback`.

mm_manager_scan_devices_finish ()

gboolean            mm_manager_scan_devices_finish      (MMManager *manager,
                                                         GAsyncResult *res,
                                                         GError **error);

Finishes an operation started with mm_manager_scan_devices().

`manager` :	A MMManager.
`res` :	The GAsyncResult obtained from the GAsyncReadyCallback passed to `mm_manager_scan_devices()`.
`error` :	Return location for error or `NULL`.
Returns :	`TRUE` if the call succeded, `FALSE` if `error` is set.

mm_manager_scan_devices_sync ()

gboolean            mm_manager_scan_devices_sync        (MMManager *manager,
                                                         GCancellable *cancellable,
                                                         GError **error);

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.

`manager` :	A MMManager.
`cancellable` :	A GCancellable or `NULL`. [allow-none]
`error` :	Return location for error or `NULL`.
Returns :	`TRUE` if the call succeded, `FALSE` if `error` is set.

mm_manager_set_logging ()

void                mm_manager_set_logging              (MMManager *manager,
                                                         const gchar *level,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Asynchronously requests to set the specified logging level in the daemon.

When the operation is finished, callback will be invoked in the thread-default main loop 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.

`manager` :	A MMManager.
`level` :	the login level to set.
`cancellable` :	A GCancellable or `NULL`. [allow-none]
`callback` :	A GAsyncReadyCallback to call when the request is satisfied or `NULL`.
`user_data` :	User data to pass to `callback`.

mm_manager_set_logging_finish ()

gboolean            mm_manager_set_logging_finish       (MMManager *manager,
                                                         GAsyncResult *res,
                                                         GError **error);

Finishes an operation started with mm_manager_set_logging().

`manager` :	A MMManager.
`res` :	The GAsyncResult obtained from the GAsyncReadyCallback passed to `mm_manager_set_logging()`.
`error` :	Return location for error or `NULL`.
Returns :	`TRUE` if the call succeded, `FALSE` if `error` is set.

mm_manager_set_logging_sync ()

gboolean            mm_manager_set_logging_sync         (MMManager *manager,
                                                         const gchar *level,
                                                         GCancellable *cancellable,
                                                         GError **error);

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.

`manager` :	A MMManager.
`level` :	the login level to set.
`cancellable` :	A GCancellable or `NULL`. [allow-none]
`error` :	Return location for error or `NULL`.
Returns :	`TRUE` if the call succeded, `FALSE` if `error` is set.

			libmm-glib Reference Manual
Top \| Description \| Object Hierarchy \| Implemented Interfaces