MMManager

## 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.