MMModem

MMModem — The Modem interface

Synopsis

struct              MMModem;
                    MMModemModeCombination;
                    MMModemPortInfo;

const gchar *       mm_modem_get_path                   (MMModem *self);
gchar *             mm_modem_dup_path                   (MMModem *self);
MMModemState        mm_modem_get_state                  (MMModem *self);
MMModemStateFailedReason mm_modem_get_state_failed_reason
                                                        (MMModem *self);
MMModemPowerState   mm_modem_get_power_state            (MMModem *self);
gboolean            mm_modem_peek_supported_capabilities
                                                        (MMModem *self,
                                                         const MMModemCapability **capabilities,
                                                         guint *n_capabilities);
gboolean            mm_modem_get_supported_capabilities (MMModem *self,
                                                         MMModemCapability **capabilities,
                                                         guint *n_capabilities);
MMModemCapability   mm_modem_get_current_capabilities   (MMModem *self);
const gchar *       mm_modem_get_manufacturer           (MMModem *self);
gchar *             mm_modem_dup_manufacturer           (MMModem *self);
const gchar *       mm_modem_get_model                  (MMModem *self);
gchar *             mm_modem_dup_model                  (MMModem *self);
const gchar *       mm_modem_get_revision               (MMModem *self);
gchar *             mm_modem_dup_revision               (MMModem *self);
const gchar * const  * mm_modem_get_drivers             (MMModem *self);
gchar **            mm_modem_dup_drivers                (MMModem *self);
const gchar *       mm_modem_get_plugin                 (MMModem *self);
gchar *             mm_modem_dup_plugin                 (MMModem *self);
const gchar *       mm_modem_get_primary_port           (MMModem *self);
gchar *             mm_modem_dup_primary_port           (MMModem *self);
gboolean            mm_modem_peek_ports                 (MMModem *self,
                                                         const MMModemPortInfo **ports,
                                                         guint *n_ports);
gboolean            mm_modem_get_ports                  (MMModem *self,
                                                         MMModemPortInfo **ports,
                                                         guint *n_ports);
const gchar *       mm_modem_get_device                 (MMModem *self);
gchar *             mm_modem_dup_device                 (MMModem *self);
const gchar *       mm_modem_get_equipment_identifier   (MMModem *self);
gchar *             mm_modem_dup_equipment_identifier   (MMModem *self);
const gchar *       mm_modem_get_device_identifier      (MMModem *self);
gchar *             mm_modem_dup_device_identifier      (MMModem *self);
MMModemLock         mm_modem_get_unlock_required        (MMModem *self);
MMUnlockRetries *   mm_modem_peek_unlock_retries        (MMModem *self);
MMUnlockRetries *   mm_modem_get_unlock_retries         (MMModem *self);
guint               mm_modem_get_max_bearers            (MMModem *self);
guint               mm_modem_get_max_active_bearers     (MMModem *self);
const gchar *const  * mm_modem_get_own_numbers          (MMModem *self);
gchar **            mm_modem_dup_own_numbers            (MMModem *self);
gboolean            mm_modem_peek_supported_modes       (MMModem *self,
                                                         const MMModemModeCombination **modes,
                                                         guint *n_modes);
gboolean            mm_modem_get_supported_modes        (MMModem *self,
                                                         MMModemModeCombination **modes,
                                                         guint *n_modes);
gboolean            mm_modem_get_current_modes          (MMModem *self,
                                                         MMModemMode *allowed,
                                                         MMModemMode *preferred);
gboolean            mm_modem_peek_supported_bands       (MMModem *self,
                                                         const MMModemBand **bands,
                                                         guint *n_bands);
gboolean            mm_modem_get_supported_bands        (MMModem *self,
                                                         MMModemBand **bands,
                                                         guint *n_bands);
gboolean            mm_modem_peek_current_bands         (MMModem *self,
                                                         const MMModemBand **bands,
                                                         guint *n_bands);
gboolean            mm_modem_get_current_bands          (MMModem *self,
                                                         MMModemBand **bands,
                                                         guint *n_bands);
MMBearerIpFamily    mm_modem_get_supported_ip_families  (MMModem *self);
guint               mm_modem_get_signal_quality         (MMModem *self,
                                                         gboolean *recent);
MMModemAccessTechnology mm_modem_get_access_technologies
                                                        (MMModem *self);

const gchar *       mm_modem_get_sim_path               (MMModem *self);
gchar *             mm_modem_dup_sim_path               (MMModem *self);
void                mm_modem_get_sim                    (MMModem *self,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
MMSim *             mm_modem_get_sim_finish             (MMModem *self,
                                                         GAsyncResult *res,
                                                         GError **error);
MMSim *             mm_modem_get_sim_sync               (MMModem *self,
                                                         GCancellable *cancellable,
                                                         GError **error);

void                mm_modem_enable                     (MMModem *self,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            mm_modem_enable_finish              (MMModem *self,
                                                         GAsyncResult *res,
                                                         GError **error);
gboolean            mm_modem_enable_sync                (MMModem *self,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                mm_modem_disable                    (MMModem *self,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            mm_modem_disable_finish             (MMModem *self,
                                                         GAsyncResult *res,
                                                         GError **error);
gboolean            mm_modem_disable_sync               (MMModem *self,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                mm_modem_set_power_state            (MMModem *self,
                                                         MMModemPowerState state,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            mm_modem_set_power_state_finish     (MMModem *self,
                                                         GAsyncResult *res,
                                                         GError **error);
gboolean            mm_modem_set_power_state_sync       (MMModem *self,
                                                         MMModemPowerState state,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                mm_modem_set_current_modes          (MMModem *self,
                                                         MMModemMode modes,
                                                         MMModemMode preferred,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            mm_modem_set_current_modes_finish   (MMModem *self,
                                                         GAsyncResult *res,
                                                         GError **error);
gboolean            mm_modem_set_current_modes_sync     (MMModem *self,
                                                         MMModemMode modes,
                                                         MMModemMode preferred,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                mm_modem_set_current_bands          (MMModem *self,
                                                         const MMModemBand *bands,
                                                         guint n_bands,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            mm_modem_set_current_bands_finish   (MMModem *self,
                                                         GAsyncResult *res,
                                                         GError **error);
gboolean            mm_modem_set_current_bands_sync     (MMModem *self,
                                                         const MMModemBand *bands,
                                                         guint n_bands,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                mm_modem_set_current_capabilities   (MMModem *self,
                                                         MMModemCapability capabilities,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            mm_modem_set_current_capabilities_finish
                                                        (MMModem *self,
                                                         GAsyncResult *res,
                                                         GError **error);
gboolean            mm_modem_set_current_capabilities_sync
                                                        (MMModem *self,
                                                         MMModemCapability capabilities,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                mm_modem_reset                      (MMModem *self,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            mm_modem_reset_finish               (MMModem *self,
                                                         GAsyncResult *res,
                                                         GError **error);
gboolean            mm_modem_reset_sync                 (MMModem *self,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                mm_modem_factory_reset              (MMModem *self,
                                                         const gchar *code,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            mm_modem_factory_reset_finish       (MMModem *self,
                                                         GAsyncResult *res,
                                                         GError **error);
gboolean            mm_modem_factory_reset_sync         (MMModem *self,
                                                         const gchar *code,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                mm_modem_list_bearers               (MMModem *self,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
GList *             mm_modem_list_bearers_finish        (MMModem *self,
                                                         GAsyncResult *res,
                                                         GError **error);
GList *             mm_modem_list_bearers_sync          (MMModem *self,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                mm_modem_create_bearer              (MMModem *self,
                                                         MMBearerProperties *properties,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
MMBearer *          mm_modem_create_bearer_finish       (MMModem *self,
                                                         GAsyncResult *res,
                                                         GError **error);
MMBearer *          mm_modem_create_bearer_sync         (MMModem *self,
                                                         MMBearerProperties *properties,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                mm_modem_delete_bearer              (MMModem *self,
                                                         const gchar *bearer,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            mm_modem_delete_bearer_finish       (MMModem *self,
                                                         GAsyncResult *res,
                                                         GError **error);
gboolean            mm_modem_delete_bearer_sync         (MMModem *self,
                                                         const gchar *bearer,
                                                         GCancellable *cancellable,
                                                         GError **error);

void                mm_modem_command                    (MMModem *self,
                                                         const gchar *cmd,
                                                         guint timeout,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gchar *             mm_modem_command_finish             (MMModem *self,
                                                         GAsyncResult *res,
                                                         GError **error);
gchar *             mm_modem_command_sync               (MMModem *self,
                                                         const gchar *cmd,
                                                         guint timeout,
                                                         GCancellable *cancellable,
                                                         GError **error);

void                mm_modem_port_info_array_free       (MMModemPortInfo *array,
                                                         guint array_size);

Object Hierarchy

  GObject
   +----GDBusProxy
         +----MmGdbusModemProxy
               +----MMModem

Implemented Interfaces

MMModem implements GDBusInterface, GInitable, GAsyncInitable and MmGdbusModem.

Description

The MMModem is an object providing access to the methods, signals and properties of the Modem interface.

When the modem is exposed and available in the bus, it is ensured that at least this interface is also available.

Details

struct MMModem

struct MMModem;

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


MMModemModeCombination

typedef struct {
    MMModemMode allowed;
    MMModemMode preferred;
} MMModemModeCombination;

MMModemModeCombination is a simple struct holding a pair of MMModemMode values.

MMModemMode allowed;

Mask of MMModemMode values specifying allowed modes.

MMModemMode preferred;

A single MMModemMode value specifying the preferred mode.

MMModemPortInfo

typedef struct {
    gchar *name;
    MMModemPortType type;
} MMModemPortInfo;

Information of a given port.

gchar *name;

Name of the port.

MMModemPortType type;

A MMModemPortType value.

mm_modem_get_path ()

const gchar *       mm_modem_get_path                   (MMModem *self);

Gets the DBus path of the MMObject which implements this interface.

self :

A MMModem.

Returns :

The DBus path of the MMObject object. Do not free the returned value, it belongs to self. [transfer none]

mm_modem_dup_path ()

gchar *             mm_modem_dup_path                   (MMModem *self);

Gets a copy of the DBus path of the MMObject object which implements this interface.

self :

A MMModem.

Returns :

The DBus path of the MMObject. The returned value should be freed with g_free(). [transfer full]

mm_modem_get_state ()

MMModemState        mm_modem_get_state                  (MMModem *self);

Gets the overall state of the MMModem.

self :

A MMModem.

Returns :

A MMModemState value.

mm_modem_get_state_failed_reason ()

MMModemStateFailedReason mm_modem_get_state_failed_reason
                                                        (MMModem *self);

Gets the reason specifying why the modem is in MM_MODEM_STATE_FAILED state.

self :

A MMModem.

Returns :

A MMModemStateFailedReason value.

mm_modem_get_power_state ()

MMModemPowerState   mm_modem_get_power_state            (MMModem *self);

Gets the power state of the MMModem.

self :

A MMModem.

Returns :

A MMModemPowerState value.

mm_modem_peek_supported_capabilities ()

gboolean            mm_modem_peek_supported_capabilities
                                                        (MMModem *self,
                                                         const MMModemCapability **capabilities,
                                                         guint *n_capabilities);

Gets the list of combinations of generic families of access technologies supported by this MMModem.

self :

A MMModem.

capabilities :

Return location for the array of MMModemCapability values. Do not free the returned array, it is owned by self. [out][array length=n_capabilities]

n_capabilities :

Return location for the number of values in capabilities. [out]

Returns :

TRUE if capabilities and n_capabilities are set, FALSE otherwise.

mm_modem_get_supported_capabilities ()

gboolean            mm_modem_get_supported_capabilities (MMModem *self,
                                                         MMModemCapability **capabilities,
                                                         guint *n_capabilities);

Gets the list of combinations of generic families of access technologies supported by this MMModem.

self :

A MMModem.

capabilities :

Return location for the array of MMModemCapability values. The returned array should be freed with g_free() when no longer needed. [out][array length=n_capabilities]

n_capabilities :

Return location for the number of values in capabilities. [out]

Returns :

TRUE if capabilities and n_capabilities are set, FALSE otherwise.

mm_modem_get_current_capabilities ()

MMModemCapability   mm_modem_get_current_capabilities   (MMModem *self);

Gets the list of generic families of access technologies supported by this MMModem without a firmware reload or reinitialization.

self :

A MMModem.

Returns :

A bitmask of MMModemCapability flags.

mm_modem_get_manufacturer ()

const gchar *       mm_modem_get_manufacturer           (MMModem *self);

Gets the equipment manufacturer, as reported by this MMModem.

Warning

The returned value is only valid until the property changes so it is only safe to use this function on the thread where self was constructed. Use mm_modem_dup_manufacturer() if on another thread.

self :

A MMModem.

Returns :

The equipment manufacturer, or NULL if none available. Do not free the returned value, it belongs to self. [transfer none]

mm_modem_dup_manufacturer ()

gchar *             mm_modem_dup_manufacturer           (MMModem *self);

Gets a copy of the equipment manufacturer, as reported by this MMModem.

self :

A MMModem.

Returns :

The equipment manufacturer, or NULL if none available. The returned value should be freed with g_free(). [transfer full]

mm_modem_get_model ()

const gchar *       mm_modem_get_model                  (MMModem *self);

Gets the equipment model, as reported by this MMModem.

Warning

The returned value is only valid until the property changes so it is only safe to use this function on the thread where self was constructed. Use mm_modem_dup_model() if on another thread.

self :

A MMModem.

Returns :

The equipment model, or NULL if none available. Do not free the returned value, it belongs to self. [transfer none]

mm_modem_dup_model ()

gchar *             mm_modem_dup_model                  (MMModem *self);

Gets a copy of the equipment model, as reported by this MMModem.

self :

A MMModem.

Returns :

The equipment model, or NULL if none available. The returned value should be freed with g_free(). [transfer full]

mm_modem_get_revision ()

const gchar *       mm_modem_get_revision               (MMModem *self);

Gets the equipment revision, as reported by this MMModem.

Warning

The returned value is only valid until the property changes so it is only safe to use this function on the thread where self was constructed. Use mm_modem_dup_revision() if on another thread.

self :

A MMModem.

Returns :

The equipment revision, or NULL if none available. Do not free the returned value, it belongs to self. [transfer none]

mm_modem_dup_revision ()

gchar *             mm_modem_dup_revision               (MMModem *self);

Gets a copy of the equipment revision, as reported by this MMModem.

self :

A MMModem.

Returns :

The equipment revision, or NULL if none available. The returned value should be freed with g_free(). [transfer full]

mm_modem_get_drivers ()

const gchar * const  * mm_modem_get_drivers             (MMModem *self);

Gets the Operating System device drivers handling communication with the modem hardware.

Warning

The returned value is only valid until the property changes so it is only safe to use this function on the thread where self was constructed. Use mm_modem_dup_drivers() if on another thread.

self :

A MMModem.

Returns :

The drivers, or NULL if none available. Do not free the returned value, it belongs to self. [transfer none]

mm_modem_dup_drivers ()

gchar **            mm_modem_dup_drivers                (MMModem *self);

Gets a copy of the Operating System device driver handling communication with the modem hardware.

self :

A MMModem.

Returns :

The drivers, or NULL if none available. The returned value should be freed with g_strfreev(). [transfer full]

mm_modem_get_plugin ()

const gchar *       mm_modem_get_plugin                 (MMModem *self);

Gets the name of the plugin handling this MMModem.

Warning

The returned value is only valid until the property changes so it is only safe to use this function on the thread where self was constructed. Use mm_modem_dup_plugin() if on another thread.

self :

A MMModem.

Returns :

The name of the plugin, or NULL if none available. Do not free the returned value, it belongs to self. [transfer none]

mm_modem_dup_plugin ()

gchar *             mm_modem_dup_plugin                 (MMModem *self);

Gets a copy of the name of the plugin handling this MMModem.

self :

A MMModem.

Returns :

The name of the plugin, or NULL if none available. The returned value should be freed with g_free(). [transfer full]

mm_modem_get_primary_port ()

const gchar *       mm_modem_get_primary_port           (MMModem *self);

Gets the name of the primary port controlling this MMModem.

Warning

The returned value is only valid until the property changes so it is only safe to use this function on the thread where self was constructed. Use mm_modem_dup_primary_port() if on another thread.

self :

A MMModem.

Returns :

The name of the primary port. Do not free the returned value, it belongs to self. [transfer none]

mm_modem_dup_primary_port ()

gchar *             mm_modem_dup_primary_port           (MMModem *self);

Gets a copy of the name of the primary port controlling this MMModem.

self :

A MMModem.

Returns :

The name of the primary port. The returned value should be freed with g_free(). [transfer full]

mm_modem_peek_ports ()

gboolean            mm_modem_peek_ports                 (MMModem *self,
                                                         const MMModemPortInfo **ports,
                                                         guint *n_ports);


mm_modem_get_ports ()

gboolean            mm_modem_get_ports                  (MMModem *self,
                                                         MMModemPortInfo **ports,
                                                         guint *n_ports);

Gets the list of ports in the modem.

self :

A MMModem.

ports :

Return location for the array of MMModemPortInfo values. The returned array should be freed with mm_modem_port_info_array_free() when no longer needed. [out][array length=n_ports]

n_ports :

Return location for the number of values in ports. [out]

Returns :

TRUE if ports and n_ports are set, FALSE otherwise.

mm_modem_get_device ()

const gchar *       mm_modem_get_device                 (MMModem *self);

Gets the physical modem device reference (ie, USB, PCI, PCMCIA device), which may be dependent upon the operating system.

Warning

The returned value is only valid until the property changes so it is only safe to use this function on the thread where self was constructed. Use mm_modem_dup_device() if on another thread.

self :

A MMModem.

Returns :

The device, or NULL if none available. Do not free the returned value, it belongs to self. [transfer none]

mm_modem_dup_device ()

gchar *             mm_modem_dup_device                 (MMModem *self);

Gets a copy of the physical modem device reference (ie, USB, PCI, PCMCIA device), which may be dependent upon the operating system.

self :

A MMModem.

Returns :

The device, or NULL if none available. The returned value should be freed with g_free(). [transfer full]

mm_modem_get_equipment_identifier ()

const gchar *       mm_modem_get_equipment_identifier   (MMModem *self);

Gets the identity of the MMModem.

This will be the IMEI number for GSM devices and the hex-format ESN/MEID for CDMA devices.

Warning

The returned value is only valid until the property changes so it is only safe to use this function on the thread where self was constructed. Use mm_modem_dup_plugin() if on another thread.

self :

A MMModem.

Returns :

The equipment identifier, or NULL if none available. Do not free the returned value, it belongs to self. [transfer none]

mm_modem_dup_equipment_identifier ()

gchar *             mm_modem_dup_equipment_identifier   (MMModem *self);

Gets a copy of the identity of the MMModem.

This will be the IMEI number for GSM devices and the hex-format ESN/MEID for CDMA devices.

self :

A MMModem.

Returns :

The equipment identifier, or NULL if none available. The returned value should be freed with g_free(). [transfer full]

mm_modem_get_device_identifier ()

const gchar *       mm_modem_get_device_identifier      (MMModem *self);

Gets a best-effort device identifier based on various device information like model name, firmware revision, USB/PCI/PCMCIA IDs, and other properties.

This ID is not guaranteed to be unique and may be shared between identical devices with the same firmware, but is intended to be "unique enough" for use as a casual device identifier for various user experience operations.

This is not the device's IMEI or ESN since those may not be available before unlocking the device via a PIN.

Warning

The returned value is only valid until the property changes so it is only safe to use this function on the thread where self was constructed. Use mm_modem_dup_device_identifier() if on another thread.

self :

A MMModem.

Returns :

The device identifier, or NULL if none available. Do not free the returned value, it belongs to self. [transfer none]

mm_modem_dup_device_identifier ()

gchar *             mm_modem_dup_device_identifier      (MMModem *self);

Gets a copy of a best-effort device identifier based on various device information like model name, firmware revision, USB/PCI/PCMCIA IDs, and other properties.

This ID is not guaranteed to be unique and may be shared between identical devices with the same firmware, but is intended to be "unique enough" for use as a casual device identifier for various user experience operations.

This is not the device's IMEI or ESN since those may not be available before unlocking the device via a PIN.

self :

A MMModem.

Returns :

The device identifier, or NULL if none available. The returned value should be freed with g_free(). [transfer full]

mm_modem_get_unlock_required ()

MMModemLock         mm_modem_get_unlock_required        (MMModem *self);

Gets current lock state of the MMModem.

self :

A MMModem.

Returns :

A MMModemLock value, specifying the current lock state.

mm_modem_peek_unlock_retries ()

MMUnlockRetries *   mm_modem_peek_unlock_retries        (MMModem *self);

Gets a MMUnlockRetries object, which provides, for each MMModemLock handled by the modem, the number of PIN tries remaining before the code becomes blocked (requiring a PUK) or permanently blocked.

Warning

The returned value is only valid until the property changes so it is only safe to use this function on the thread where self was constructed. Use mm_modem_get_unlock_retries() if on another thread.

self :

A MMModem.

Returns :

(transfer none) A MMUnlockRetries. Do not free the returned value, it belongs to self.

mm_modem_get_unlock_retries ()

MMUnlockRetries *   mm_modem_get_unlock_retries         (MMModem *self);

Gets a MMUnlockRetries object, which provides, for each MMModemLock handled by the modem, the number of PIN tries remaining before the code becomes blocked (requiring a PUK) or permanently blocked.

Warning

The values reported by self are not updated when the values in the interface change. Instead, the client is expected to call mm_modem_get_unlock_retries() again to get a new MMUnlockRetries with the new values.

self :

A MMModem.

Returns :

(transfer full) A MMUnlockRetries that must be freed with g_object_unref() or NULL if unknown.

mm_modem_get_max_bearers ()

guint               mm_modem_get_max_bearers            (MMModem *self);

Gets the maximum number of defined packet data bearers this MMModem supports.

This is not the number of active/connected bearers the modem supports, but simply the number of bearers that may be defined at any given time. For example, POTS and CDMA2000-only devices support only one bearer, while GSM/UMTS devices typically support three or more, and any LTE-capable device (whether LTE-only, GSM/UMTS-capable, and/or CDMA2000-capable) also typically support three or more.

self :

a MMModem.

Returns :

the maximum number of defined packet data bearers.

mm_modem_get_max_active_bearers ()

guint               mm_modem_get_max_active_bearers     (MMModem *self);

Gets the maximum number of active packet data bearers this MMModem supports.

POTS and CDMA2000-only devices support one active bearer, while GSM/UMTS and LTE-capable devices (including LTE/CDMA devices) typically support at least two active bearers.

self :

a MMModem.

Returns :

the maximum number of defined packet data bearers.

mm_modem_get_own_numbers ()

const gchar *const  * mm_modem_get_own_numbers          (MMModem *self);

Gets the list of numbers (e.g. MSISDN in 3GPP) being currently handled by this modem.

Warning

The returned value is only valid until the property changes so it is only safe to use this function on the thread where self was constructed. Use mm_modem_dup_own_numbers() if on another thread.

self :

A MMModem.

Returns :

The list of own numbers or NULL if none available. Do not free the returned value, it belongs to self. [transfer none]

mm_modem_dup_own_numbers ()

gchar **            mm_modem_dup_own_numbers            (MMModem *self);

Gets a copy of the list of numbers (e.g. MSISDN in 3GPP) being currently handled by this modem.

self :

A MMModem.

Returns :

The list of own numbers or NULL if none is available. The returned value should be freed with g_strfreev(). [transfer full]

mm_modem_peek_supported_modes ()

gboolean            mm_modem_peek_supported_modes       (MMModem *self,
                                                         const MMModemModeCombination **modes,
                                                         guint *n_modes);

Gets the list of supported mode combinations.

self :

A MMModem.

modes :

Return location for the array of MMModemModeCombination values. Do not free the returned array, it is owned by self. [out][array length=n_modes]

n_modes :

Return location for the number of values in modes. [out]

Returns :

TRUE if modes and n_modes are set, FALSE otherwise.

mm_modem_get_supported_modes ()

gboolean            mm_modem_get_supported_modes        (MMModem *self,
                                                         MMModemModeCombination **modes,
                                                         guint *n_modes);

Gets the list of supported mode combinations.

self :

A MMModem.

modes :

Return location for the array of MMModemModeCombination structs. The returned array should be freed with g_free() when no longer needed. [out][array length=n_modes]

n_modes :

Return location for the number of values in modes. [out]

Returns :

TRUE if modes and n_modes are set, FALSE otherwise.

mm_modem_get_current_modes ()

gboolean            mm_modem_get_current_modes          (MMModem *self,
                                                         MMModemMode *allowed,
                                                         MMModemMode *preferred);

Gets the list of modes specifying the access technologies (eg 2G/3G/4G) the MMModem is currently allowed to use when connecting to a network, as well as the preferred one, if any.

self :

A MMModem.

allowed :

Return location for a bitmask of MMModemMode values. [out]

preferred :

Return location for a MMModemMode value. [out]

Returns :

TRUE if allowed and preferred are set, FALSE otherwise.

mm_modem_peek_supported_bands ()

gboolean            mm_modem_peek_supported_bands       (MMModem *self,
                                                         const MMModemBand **bands,
                                                         guint *n_bands);

Gets the list of radio frequency and technology bands supported by the MMModem.

For POTS devices, only MM_MODEM_BAND_ANY will be returned in bands.

self :

A MMModem.

bands :

Return location for the array of MMModemBand values. Do not free the returned array, it is owned by self. [out][array length=n_bands]

n_bands :

Return location for the number of values in bands. [out]

Returns :

TRUE if bands and n_bands are set, FALSE otherwise.

mm_modem_get_supported_bands ()

gboolean            mm_modem_get_supported_bands        (MMModem *self,
                                                         MMModemBand **bands,
                                                         guint *n_bands);

Gets the list of radio frequency and technology bands supported by the MMModem.

For POTS devices, only MM_MODEM_BAND_ANY will be returned in bands.

self :

A MMModem.

bands :

Return location for the array of MMModemBand values. The returned array should be freed with g_free() when no longer needed. [out][array length=n_bands]

n_bands :

Return location for the number of values in bands. [out]

Returns :

TRUE if bands and n_bands are set, FALSE otherwise.

mm_modem_peek_current_bands ()

gboolean            mm_modem_peek_current_bands         (MMModem *self,
                                                         const MMModemBand **bands,
                                                         guint *n_bands);

Gets the list of radio frequency and technology bands the MMModem is currently using when connecting to a network.

For POTS devices, only the MM_MODEM_BAND_ANY band is supported.

self :

A MMModem.

bands :

Return location for the array of MMModemBand values. Do not free the returned value, it is owned by self. [out][array length=n_storages]

n_bands :

Return location for the number of values in bands. [out]

Returns :

TRUE if bands and n_bands are set, FALSE otherwise.

mm_modem_get_current_bands ()

gboolean            mm_modem_get_current_bands          (MMModem *self,
                                                         MMModemBand **bands,
                                                         guint *n_bands);

Gets the list of radio frequency and technology bands the MMModem is currently using when connecting to a network.

For POTS devices, only the MM_MODEM_BAND_ANY band is supported.

self :

A MMModem.

bands :

Return location for the array of MMModemBand values. The returned array should be freed with g_free() when no longer needed. [out][array length=n_bands]

n_bands :

Return location for the number of values in bands. [out]

Returns :

TRUE if bands and n_bands are set, FALSE otherwise.

mm_modem_get_supported_ip_families ()

MMBearerIpFamily    mm_modem_get_supported_ip_families  (MMModem *self);

Gets the list of supported IP families.

self :

A MMModem.

Returns :

A bitmask of MMBearerIpFamily values.

mm_modem_get_signal_quality ()

guint               mm_modem_get_signal_quality         (MMModem *self,
                                                         gboolean *recent);

Gets the signal quality value in percent (0 - 100) of the dominant access technology the MMModem is using to communicate with the network.

Always 0 for POTS devices.

self :

A MMModem.

recent :

Return location for the flag specifying if the signal quality value was recent or not. [out]

Returns :

The signal quality.

mm_modem_get_access_technologies ()

MMModemAccessTechnology mm_modem_get_access_technologies
                                                        (MMModem *self);


mm_modem_get_sim_path ()

const gchar *       mm_modem_get_sim_path               (MMModem *self);

Gets the DBus path of the MMSim handled in this MMModem.

Warning

The returned value is only valid until the property changes so it is only safe to use this function on the thread where self was constructed. Use mm_modem_dup_sim_path() if on another thread.

self :

A MMModem.

Returns :

The DBus path of the MMSim handled in this MMModem, or NULL if none available. Do not free the returned value, it belongs to self. [transfer none]

mm_modem_dup_sim_path ()

gchar *             mm_modem_dup_sim_path               (MMModem *self);

Gets a copy of the DBus path of the MMSim handled in this MMModem.

self :

A MMModem.

Returns :

The DBus path of the MMSim handled in this MMModem, or NULL if none available. The returned value should be freed with g_free(). [transfer full]

mm_modem_get_sim ()

void                mm_modem_get_sim                    (MMModem *self,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Synchronously gets the MMSim object managed by this MMModem.

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_modem_get_sim_finish() to get the result of the operation.

See mm_modem_get_sim_sync() for the synchronous, blocking version of this method.

self :

A MMModem.

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_modem_get_sim_finish ()

MMSim *             mm_modem_get_sim_finish             (MMModem *self,
                                                         GAsyncResult *res,
                                                         GError **error);

Finishes an operation started with mm_modem_get_sim().

self :

A MMModem.

res :

The GAsyncResult obtained from the GAsyncReadyCallback passed to mm_modem_get_sim().

error :

Return location for error or NULL.

Returns :

a MMSim or NULL if none available. The returned value should be freed with g_object_unref().

mm_modem_get_sim_sync ()

MMSim *             mm_modem_get_sim_sync               (MMModem *self,
                                                         GCancellable *cancellable,
                                                         GError **error);

Synchronously gets the MMSim object managed by this MMModem.

The calling thread is blocked until a reply is received. See mm_modem_get_sim() for the asynchronous version of this method.

self :

A MMModem.

cancellable :

A GCancellable or NULL. [allow-none]

error :

Return location for error or NULL.

Returns :

a MMSim or NULL if none available. The returned value should be freed with g_object_unref().

mm_modem_enable ()

void                mm_modem_enable                     (MMModem *self,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Asynchronously tries to enable the MMModem. When enabled, the modem's radio is powered on and data sessions, voice calls, location services, and Short Message Service may be available.

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_modem_enable_finish() to get the result of the operation.

See mm_modem_enable_sync() for the synchronous, blocking version of this method.

self :

A MMModem.

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_modem_enable_finish ()

gboolean            mm_modem_enable_finish              (MMModem *self,
                                                         GAsyncResult *res,
                                                         GError **error);

Finishes an operation started with mm_modem_enable().

self :

A MMModem.

res :

The GAsyncResult obtained from the GAsyncReadyCallback passed to mm_modem_enable().

error :

Return location for error or NULL.

Returns :

TRUE if the modem was properly enabled, FALSE if error is set.

mm_modem_enable_sync ()

gboolean            mm_modem_enable_sync                (MMModem *self,
                                                         GCancellable *cancellable,
                                                         GError **error);

Synchronously tries to enable the MMModem. When enabled, the modem's radio is powered on and data sessions, voice calls, location services, and Short Message Service may be available.

The calling thread is blocked until a reply is received. See mm_modem_enable() for the asynchronous version of this method.

self :

A MMModem.

cancellable :

A GCancellable or NULL. [allow-none]

error :

Return location for error or NULL.

Returns :

TRUE if the modem was properly enabled, FALSE if error is set.

mm_modem_disable ()

void                mm_modem_disable                    (MMModem *self,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Asynchronously tries to disable the MMModem. When disabled, the modem enters low-power state and no network-related operations are available.

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_modem_disable_finish() to get the result of the operation.

See mm_modem_disable_sync() for the synchronous, blocking version of this method.

self :

A MMModem.

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_modem_disable_finish ()

gboolean            mm_modem_disable_finish             (MMModem *self,
                                                         GAsyncResult *res,
                                                         GError **error);

Finishes an operation started with mm_modem_disable().

self :

A MMModem.

res :

The GAsyncResult obtained from the GAsyncReadyCallback passed to mm_modem_disable().

error :

Return location for error or NULL.

Returns :

TRUE if the modem was properly disabled, FALSE if error is set.

mm_modem_disable_sync ()

gboolean            mm_modem_disable_sync               (MMModem *self,
                                                         GCancellable *cancellable,
                                                         GError **error);

Synchronously tries to disable the MMModem. When disabled, the modem enters low-power state and no network-related operations are available.

The calling thread is blocked until a reply is received. See mm_modem_disable() for the asynchronous version of this method.

self :

A MMModem.

cancellable :

A GCancellable or NULL. [allow-none]

error :

Return location for error or NULL.

Returns :

TRUE if the modem was properly disabled, FALSE if error is set.

mm_modem_set_power_state ()

void                mm_modem_set_power_state            (MMModem *self,
                                                         MMModemPowerState state,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Asynchronously sets the power state of the device. This method can only be used while the modem is in MM_MODEM_STATE_DISABLED state.

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_modem_set_power_state_finish() to get the result of the operation.

See mm_modem_set_power_state_sync() for the synchronous, blocking version of this method.

self :

A MMModem.

state :

Either MM_MODEM_POWER_STATE_LOW or MM_MODEM_POWER_STATE_ON. Every other MMModemPowerState value is not allowed.

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_modem_set_power_state_finish ()

gboolean            mm_modem_set_power_state_finish     (MMModem *self,
                                                         GAsyncResult *res,
                                                         GError **error);

Finishes an operation started with mm_modem_set_power_state().

self :

A MMModem.

res :

The GAsyncResult obtained from the GAsyncReadyCallback passed to mm_modem_set_power_state().

error :

Return location for error or NULL.

Returns :

TRUE if the power state was successfully set, FALSE if error is set.

mm_modem_set_power_state_sync ()

gboolean            mm_modem_set_power_state_sync       (MMModem *self,
                                                         MMModemPowerState state,
                                                         GCancellable *cancellable,
                                                         GError **error);

Synchronously sets the power state of the device. This method can only be used while the modem is in MM_MODEM_STATE_DISABLED state.

The calling thread is blocked until a reply is received. See mm_modem_set_power_state() for the asynchronous version of this method.

self :

A MMModem.

state :

Either MM_MODEM_POWER_STATE_LOW or MM_MODEM_POWER_STATE_ON. Every other MMModemPowerState value is not allowed.

cancellable :

A GCancellable or NULL. [allow-none]

error :

Return location for error or NULL.

Returns :

TRUE if the power state was successfully set, FALSE if error is set.

mm_modem_set_current_modes ()

void                mm_modem_set_current_modes          (MMModem *self,
                                                         MMModemMode modes,
                                                         MMModemMode preferred,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Asynchronously sets the access technologies (e.g. 2G/3G/4G preference) the device is currently allowed to use when connecting to a network.

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_modem_set_current_modes_finish() to get the result of the operation.

See mm_modem_set_current_modes_sync() for the synchronous, blocking version of this method.

self :

A MMModem.

modes :

Mask of MMModemMode values specifying which modes are allowed.

preferred :

A MMModemMode value specifying which of the modes given in modes is the preferred one, or MM_MODEM_MODE_NONE if none.

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_modem_set_current_modes_finish ()

gboolean            mm_modem_set_current_modes_finish   (MMModem *self,
                                                         GAsyncResult *res,
                                                         GError **error);

Finishes an operation started with mm_modem_set_current_modes().

self :

A MMModem.

res :

The GAsyncResult obtained from the GAsyncReadyCallback passed to mm_modem_set_current_modes().

error :

Return location for error or NULL.

Returns :

TRUE if the allowed modes were successfully set, FALSE if error is set.

mm_modem_set_current_modes_sync ()

gboolean            mm_modem_set_current_modes_sync     (MMModem *self,
                                                         MMModemMode modes,
                                                         MMModemMode preferred,
                                                         GCancellable *cancellable,
                                                         GError **error);

Synchronously sets the access technologies (e.g. 2G/3G/4G preference) the device is currently allowed to use when connecting to a network.

The calling thread is blocked until a reply is received. See mm_modem_set_current_modes() for the asynchronous version of this method.

self :

A MMModem.

modes :

Mask of MMModemMode values specifying which modes are allowed.

preferred :

A MMModemMode value specifying which of the modes given in modes is the preferred one, or MM_MODEM_MODE_NONE if none.

cancellable :

A GCancellable or NULL. [allow-none]

error :

Return location for error or NULL.

Returns :

TRUE if the allowed modes were successfully set, FALSE if error is set.

mm_modem_set_current_bands ()

void                mm_modem_set_current_bands          (MMModem *self,
                                                         const MMModemBand *bands,
                                                         guint n_bands,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Asynchronously sets the radio frequency and technology bands the device is currently allowed to use when connecting to a network.

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_modem_set_current_bands_finish() to get the result of the operation.

See mm_modem_set_current_bands_sync() for the synchronous, blocking version of this method.

self :

A MMModem.

bands :

An array of MMModemBand values specifying which bands are allowed.

n_bands :

Number of elements in bands.

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_modem_set_current_bands_finish ()

gboolean            mm_modem_set_current_bands_finish   (MMModem *self,
                                                         GAsyncResult *res,
                                                         GError **error);

Finishes an operation started with mm_modem_set_current_bands().

self :

A MMModem.

res :

The GAsyncResult obtained from the GAsyncReadyCallback passed to mm_modem_set_current_bands().

error :

Return location for error or NULL.

Returns :

TRUE if the bands were successfully set, FALSE if error is set.

mm_modem_set_current_bands_sync ()

gboolean            mm_modem_set_current_bands_sync     (MMModem *self,
                                                         const MMModemBand *bands,
                                                         guint n_bands,
                                                         GCancellable *cancellable,
                                                         GError **error);

Synchronously sets the radio frequency and technology bands the device is currently allowed to use when connecting to a network.

The calling thread is blocked until a reply is received. See mm_modem_set_current_bands() for the asynchronous version of this method.

self :

A MMModem.

bands :

An array of MMModemBand values specifying which bands are allowed.

n_bands :

Number of elements in bands.

cancellable :

A GCancellable or NULL. [allow-none]

error :

Return location for error or NULL.

Returns :

TRUE if the bands were successfully set, FALSE if error is set.

mm_modem_set_current_capabilities ()

void                mm_modem_set_current_capabilities   (MMModem *self,
                                                         MMModemCapability capabilities,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Asynchronously sets the capabilities of the device. A restart of the modem may be required.

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_modem_set_current_capabilities_finish() to get the result of the operation.

See mm_modem_set_current_capabilities_sync() for the synchronous, blocking version of this method.

self :

A MMModem.

capabilities :

A MMModemCapability mask.

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_modem_set_current_capabilities_finish ()

gboolean            mm_modem_set_current_capabilities_finish
                                                        (MMModem *self,
                                                         GAsyncResult *res,
                                                         GError **error);

Finishes an operation started with mm_modem_set_current_capabilities().

self :

A MMModem.

res :

The GAsyncResult obtained from the GAsyncReadyCallback passed to mm_modem_set_current_capabilities().

error :

Return location for error or NULL.

Returns :

TRUE if the capabilities were successfully set, FALSE if error is set.

mm_modem_set_current_capabilities_sync ()

gboolean            mm_modem_set_current_capabilities_sync
                                                        (MMModem *self,
                                                         MMModemCapability capabilities,
                                                         GCancellable *cancellable,
                                                         GError **error);

Synchronously sets the capabilities of the device. A restart of the modem may be required.

The calling thread is blocked until a reply is received. See mm_modem_set_current_capabilities() for the asynchronous version of this method.

self :

A MMModem.

capabilities :

A MMModemCapability mask.

cancellable :

A GCancellable or NULL. [allow-none]

error :

Return location for error or NULL.

Returns :

TRUE if the capabilities were successfully set, FALSE if error is set.

mm_modem_reset ()

void                mm_modem_reset                      (MMModem *self,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Asynchronously clears non-persistent configuration and state, and returns the device to a newly-powered-on state.

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_modem_reset_finish() to get the result of the operation.

See mm_modem_reset_sync() for the synchronous, blocking version of this method.

self :

A MMModem.

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_modem_reset_finish ()

gboolean            mm_modem_reset_finish               (MMModem *self,
                                                         GAsyncResult *res,
                                                         GError **error);

Finishes an operation started with mm_modem_reset().

self :

A MMModem.

res :

The GAsyncResult obtained from the GAsyncReadyCallback passed to mm_modem_reset().

error :

Return location for error or NULL.

Returns :

TRUE if the reset was successful, FALSE if error is set.

mm_modem_reset_sync ()

gboolean            mm_modem_reset_sync                 (MMModem *self,
                                                         GCancellable *cancellable,
                                                         GError **error);

Synchronously clears non-persistent configuration and state, and returns the device to a newly-powered-on state.

The calling thread is blocked until a reply is received. See mm_modem_reset() for the asynchronous version of this method.

self :

A MMModem.

cancellable :

A GCancellable or NULL. [allow-none]

error :

Return location for error or NULL.

Returns :

TRUE if the reset was successful, FALSE if error is set.

mm_modem_factory_reset ()

void                mm_modem_factory_reset              (MMModem *self,
                                                         const gchar *code,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Asynchronously clears the modem's configuration (including persistent configuration and state), and returns the device to a factory-default state.

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_modem_factory_reset_finish() to get the result of the operation.

See mm_modem_factory_reset_sync() for the synchronous, blocking version of this method.

self :

A MMModem.

code :

Carrier-supplied code required to reset the modem.

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_modem_factory_reset_finish ()

gboolean            mm_modem_factory_reset_finish       (MMModem *self,
                                                         GAsyncResult *res,
                                                         GError **error);

Finishes an operation started with mm_modem_factory_reset().

self :

A MMModem.

res :

The GAsyncResult obtained from the GAsyncReadyCallback passed to mm_modem_factory_reset().

error :

Return location for error or NULL.

Returns :

TRUE if the factory_reset was successful, FALSE if error is set.

mm_modem_factory_reset_sync ()

gboolean            mm_modem_factory_reset_sync         (MMModem *self,
                                                         const gchar *code,
                                                         GCancellable *cancellable,
                                                         GError **error);

Synchronously clears the modem's configuration (including persistent configuration and state), and returns the device to a factory-default state.

The calling thread is blocked until a reply is received. See mm_modem_factory_reset() for the asynchronous version of this method.

self :

A MMModem.

code :

Carrier-supplied code required to reset the modem.

cancellable :

A GCancellable or NULL. [allow-none]

error :

Return location for error or NULL.

Returns :

TRUE if the factory reset was successful, FALSE if error is set.

mm_modem_list_bearers ()

void                mm_modem_list_bearers               (MMModem *self,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Asynchronously lists the packet data bearers in the MMModem.

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_modem_list_bearers_finish() to get the result of the operation.

See mm_modem_list_bearers_sync() for the synchronous, blocking version of this method.

self :

A MMModem.

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_modem_list_bearers_finish ()

GList *             mm_modem_list_bearers_finish        (MMModem *self,
                                                         GAsyncResult *res,
                                                         GError **error);

Finishes an operation started with mm_modem_list_bearers().

self :

A MMModem.

res :

The GAsyncResult obtained from the GAsyncReadyCallback passed to mm_modem_list_bearers().

error :

Return location for error or NULL.

Returns :

The list of MMBearer objects, or NULL if either none found or if error is set. [transfer full]

mm_modem_list_bearers_sync ()

GList *             mm_modem_list_bearers_sync          (MMModem *self,
                                                         GCancellable *cancellable,
                                                         GError **error);

Synchronously lists the packet data bearers in the MMModem.

The calling thread is blocked until a reply is received. See mm_modem_list_bearers() for the asynchronous version of this method.

self :

A MMModem.

cancellable :

A GCancellable or NULL. [allow-none]

error :

Return location for error or NULL.

Returns :

The list of MMBearer objects, or NULL if either none found or if error is set. [transfer full]

mm_modem_create_bearer ()

void                mm_modem_create_bearer              (MMModem *self,
                                                         MMBearerProperties *properties,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Asynchronously creates a new packet data bearer in the MMModem.

This request may fail if the modem does not support additional bearers, if too many bearers are already defined, or if properties are invalid.

See CreateBearer to check which properties may be passed.

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_modem_create_bearer_finish() to get the result of the operation.

See mm_modem_create_bearer_sync() for the synchronous, blocking version of this method.

self :

A MMModem.

properties :

A MMBearerProperties object with the properties to use.

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_modem_create_bearer_finish ()

MMBearer *          mm_modem_create_bearer_finish       (MMModem *self,
                                                         GAsyncResult *res,
                                                         GError **error);

Finishes an operation started with mm_modem_create_bearer().

self :

A MMModem.

res :

The GAsyncResult obtained from the GAsyncReadyCallback passed to mm_modem_create_bearer().

error :

Return location for error or NULL.

Returns :

A newly created MMBearer, or NULL if error is set. [transfer full]

mm_modem_create_bearer_sync ()

MMBearer *          mm_modem_create_bearer_sync         (MMModem *self,
                                                         MMBearerProperties *properties,
                                                         GCancellable *cancellable,
                                                         GError **error);

Synchronously creates a new packet data bearer in the MMModem.

This request may fail if the modem does not support additional bearers, if too many bearers are already defined, or if properties are invalid.

See CreateBearer to check which properties may be passed.

The calling thread is blocked until a reply is received. See mm_modem_create_bearer() for the asynchronous version of this method.

self :

A MMModem.

properties :

A MMBearerProperties object with the properties to use.

cancellable :

A GCancellable or NULL. [allow-none]

error :

Return location for error or NULL.

Returns :

A newly created MMBearer, or NULL if error is set. [transfer full]

mm_modem_delete_bearer ()

void                mm_modem_delete_bearer              (MMModem *self,
                                                         const gchar *bearer,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Asynchronously deletes a given bearer from the MMModem.

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_modem_delete_bearer_finish() to get the result of the operation.

See mm_modem_delete_bearer_sync() for the synchronous, blocking version of this method.

self :

A MMModem.

bearer :

Path of the bearer to delete.

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_modem_delete_bearer_finish ()

gboolean            mm_modem_delete_bearer_finish       (MMModem *self,
                                                         GAsyncResult *res,
                                                         GError **error);

Finishes an operation started with mm_modem_delete_bearer().

self :

A MMModem.

res :

The GAsyncResult obtained from the GAsyncReadyCallback passed to mm_modem_delete_bearer().

error :

Return location for error or NULL.

Returns :

TRUE if the bearer was deleted, FALSE if error is set.

mm_modem_delete_bearer_sync ()

gboolean            mm_modem_delete_bearer_sync         (MMModem *self,
                                                         const gchar *bearer,
                                                         GCancellable *cancellable,
                                                         GError **error);

Synchronously deletes a given bearer from the MMModem.

The calling thread is blocked until a reply is received. See mm_modem_delete_bearer() for the asynchronous version of this method.

self :

A MMModem.

bearer :

Path of the bearer to delete.

cancellable :

A GCancellable or NULL. [allow-none]

error :

Return location for error or NULL.

Returns :

TRUE if the bearer was deleted, FALSE if error is set.

mm_modem_command ()

void                mm_modem_command                    (MMModem *self,
                                                         const gchar *cmd,
                                                         guint timeout,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Asynchronously runs an AT command in the modem.

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_modem_command_finish() to get the result of the operation.

See mm_modem_command_sync() for the synchronous, blocking version of this method.

self :

A MMModem.

cmd :

AT command to run.

timeout :

Maximum time to wait for the response, in seconds.

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_modem_command_finish ()

gchar *             mm_modem_command_finish             (MMModem *self,
                                                         GAsyncResult *res,
                                                         GError **error);

Finishes an operation started with mm_modem_command().

self :

A MMModem.

res :

The GAsyncResult obtained from the GAsyncReadyCallback passed to mm_modem_command().

error :

Return location for error or NULL.

Returns :

(transfer full) A newly allocated string with the reply to the command, or NULL if error is set. The returned value should be freed with g_free().

mm_modem_command_sync ()

gchar *             mm_modem_command_sync               (MMModem *self,
                                                         const gchar *cmd,
                                                         guint timeout,
                                                         GCancellable *cancellable,
                                                         GError **error);

Synchronously runs an AT command in the modem.

The calling thread is blocked until a reply is received. See mm_modem_command() for the asynchronous version of this method.

self :

A MMModem.

cmd :

AT command to run.

timeout :

Maximum time to wait for the response, in seconds.

cancellable :

A GCancellable or NULL. [allow-none]

error :

Return location for error or NULL.

Returns :

(transfer full) A newly allocated string with the reply to the command, or NULL if error is set. The returned value should be freed with g_free().

mm_modem_port_info_array_free ()

void                mm_modem_port_info_array_free       (MMModemPortInfo *array,
                                                         guint array_size);

Frees an array of MMModemPortInfo values.

array :

an array of MMModemPortInfo values.

array_size :

length of array.