QMI_DEVICE_FILE

#define QMI_DEVICE_FILE "device-file"

QMI_DEVICE_SIGNAL_INDICATION

#define QMI_DEVICE_SIGNAL_INDICATION "indication"

struct QmiDevice

struct QmiDevice;

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

qmi_device_new ()

void                qmi_device_new                      (GFile *file,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Asynchronously creates a QmiDevice object to manage file. When the operation is finished, callback will be invoked. You can then call qmi_device_new_finish() to get the result of the operation.

qmi_device_new_finish ()

QmiDevice *         qmi_device_new_finish               (GAsyncResult *res,
                                                         GError **error);

Finishes an operation started with qmi_device_new().

qmi_device_get_file ()

GFile *             qmi_device_get_file                 (QmiDevice *self);

Get the GFile associated with this QmiDevice.

qmi_device_peek_file ()

GFile *             qmi_device_peek_file                (QmiDevice *self);

Get the GFile associated with this QmiDevice, without increasing the reference count on the returned object.

qmi_device_get_path ()

const gchar *       qmi_device_get_path                 (QmiDevice *self);

Get the system path of the underlying QMI device.

qmi_device_get_path_display ()

const gchar *       qmi_device_get_path_display         (QmiDevice *self);

Get the system path of the underlying QMI device in UTF-8.

qmi_device_is_open ()

gboolean            qmi_device_is_open                  (QmiDevice *self);

Checks whether the QmiDevice is open for I/O.

enum QmiDeviceOpenFlags

typedef enum {
    QMI_DEVICE_OPEN_FLAGS_NONE              = 0,
    QMI_DEVICE_OPEN_FLAGS_VERSION_INFO      = 1 << 0,
    QMI_DEVICE_OPEN_FLAGS_SYNC              = 1 << 1,
    QMI_DEVICE_OPEN_FLAGS_NET_802_3         = 1 << 2,
    QMI_DEVICE_OPEN_FLAGS_NET_RAW_IP        = 1 << 3,
    QMI_DEVICE_OPEN_FLAGS_NET_QOS_HEADER    = 1 << 4,
    QMI_DEVICE_OPEN_FLAGS_NET_NO_QOS_HEADER = 1 << 5,
    QMI_DEVICE_OPEN_FLAGS_PROXY             = 1 << 6
} QmiDeviceOpenFlags;

Flags to specify which actions to be performed when the device is open.

qmi_device_open ()

void                qmi_device_open                     (QmiDevice *self,
                                                         QmiDeviceOpenFlags flags,
                                                         guint timeout,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Asynchronously opens a QmiDevice for I/O.

When the operation is finished callback will be called. You can then call qmi_device_open_finish() to get the result of the operation.

qmi_device_open_finish ()

gboolean            qmi_device_open_finish              (QmiDevice *self,
                                                         GAsyncResult *res,
                                                         GError **error);

Finishes an asynchronous open operation started with qmi_device_open().

qmi_device_close ()

gboolean            qmi_device_close                    (QmiDevice *self,
                                                         GError **error);

Synchronously closes a QmiDevice, preventing any further I/O.

Closing a QmiDevice multiple times will not return an error.

qmi_device_allocate_client ()

void                qmi_device_allocate_client          (QmiDevice *self,
                                                         QmiService service,
                                                         guint8 cid,
                                                         guint timeout,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Asynchronously allocates a new QmiClient in self.

If QMI_CID_NONE is given in cid, a new client ID will be allocated; otherwise a client with the given cid will be generated.

When the operation is finished callback will be called. You can then call qmi_device_allocate_client_finish() to get the result of the operation.

Note: Clients for the QMI_SERVICE_CTL cannot be created with this method; instead get/peek the implicit one from self.

qmi_device_allocate_client_finish ()

QmiClient *         qmi_device_allocate_client_finish   (QmiDevice *self,
                                                         GAsyncResult *res,
                                                         GError **error);

Finishes an operation started with qmi_device_allocate_client().

enum QmiDeviceReleaseClientFlags

typedef enum {
    QMI_DEVICE_RELEASE_CLIENT_FLAGS_NONE        = 0,
    QMI_DEVICE_RELEASE_CLIENT_FLAGS_RELEASE_CID = 1 << 0
} QmiDeviceReleaseClientFlags;

Flags to specify which actions to be performed when releasing the client.

qmi_device_release_client ()

void                qmi_device_release_client           (QmiDevice *self,
                                                         QmiClient *client,
                                                         QmiDeviceReleaseClientFlags flags,
                                                         guint timeout,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Asynchronously releases the QmiClient from the QmiDevice.

Once the QmiClient has been released, it cannot be used any more to perform operations.

When the operation is finished callback will be called. You can then call qmi_device_release_client_finish() to get the result of the operation.

qmi_device_release_client_finish ()

gboolean            qmi_device_release_client_finish    (QmiDevice *self,
                                                         GAsyncResult *res,
                                                         GError **error);

Finishes an operation started with qmi_device_release_client().

Note that even if the release operation returns an error, the client should anyway be considered released, and shouldn't be used afterwards.

qmi_device_set_instance_id ()

void                qmi_device_set_instance_id          (QmiDevice *self,
                                                         guint8 instance_id,
                                                         guint timeout,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Sets the instance ID of the QmiDevice.

When the operation is finished callback will be called. You can then call qmi_device_set_instance_id_finish() to get the result of the operation.

qmi_device_set_instance_id_finish ()

gboolean            qmi_device_set_instance_id_finish   (QmiDevice *self,
                                                         GAsyncResult *res,
                                                         guint16 *link_id,
                                                         GError **error);

Finishes an operation started with qmi_device_set_instance_id().

qmi_device_command ()

void                qmi_device_command                  (QmiDevice *self,
                                                         QmiMessage *message,
                                                         guint timeout,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Asynchronously sends a QmiMessage to the device.

When the operation is finished callback will be called. You can then call qmi_device_command_finish() to get the result of the operation.

qmi_device_command_finish ()

QmiMessage *        qmi_device_command_finish           (QmiDevice *self,
                                                         GAsyncResult *res,
                                                         GError **error);

Finishes an operation started with qmi_device_command().

QmiDeviceServiceVersionInfo

typedef struct {
    QmiService service;
    guint16 major_version;
    guint16 minor_version;
} QmiDeviceServiceVersionInfo;

Version information for a service.

qmi_device_get_service_version_info ()

void                qmi_device_get_service_version_info (QmiDevice *self,
                                                         guint timeout,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Asynchronously requests the service version information of the device.

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

qmi_device_get_service_version_info_finish ()

GArray *            qmi_device_get_service_version_info_finish
                                                        (QmiDevice *self,
                                                         GAsyncResult *res,
                                                         GError **error);

Finishes an operation started with qmi_device_get_service_version_info().

The "device-file" property

  "device-file"              GFile*                : Read / Write / Construct Only

File to the underlying QMI device.

The "indication" signal

void                user_function                      (QmiDevice  *qmidevice,
                                                        GByteArray *arg1,
                                                        gpointer    user_data)      : Run Last