libmm-glib,sms: `MMSms' is now a real object

Not just a typedef of the gdbus-codegen generated `MmGdbusSms'.

3 files changed, 375 insertions, 245 deletions

diff --git a/libmm-glib/mm-modem-messaging.c b/libmm-glib/mm-modem-messaging.c
index ccc6947e..62b180d6 100644
--- a/libmm-glib/mm-modem-messaging.c
+++ b/libmm-glib/mm-modem-messaging.c
@@ -275,15 +275,21 @@ mm_modem_messaging_list_finish (MMModemMessaging *self,
     return g_list_copy (list);
 }
 
+static void create_next_sms (ListSmsContext *ctx);
+
 static void
 list_build_object_ready (GDBusConnection *connection,
                          GAsyncResult *res,
                          ListSmsContext *ctx)
 {
-    MMSms *sms;
     GError *error = NULL;
+    GObject *sms;
+    GObject *source_object;
+
+    source_object = g_async_result_get_source_object (res);
+    sms = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, &error);
+    g_object_unref (source_object);
 
-    sms = mm_sms_new_finish (res, &error);
     if (error) {
         g_simple_async_result_take_error (ctx->result, error);
         list_sms_context_complete_and_free (ctx);
@@ -304,12 +310,23 @@ list_build_object_ready (GDBusConnection *connection,
     }
 
     /* Keep on creating next object */
-    mm_sms_new (g_dbus_proxy_get_connection (
-                    G_DBUS_PROXY (ctx->self)),
-                ctx->sms_paths[ctx->i],
-                ctx->cancellable,
-                (GAsyncReadyCallback)list_build_object_ready,
-                ctx);
+    create_next_sms (ctx);
+}
+
+static void
+create_next_sms (ListSmsContext *ctx)
+{
+    g_async_initable_new_async (MM_TYPE_SMS,
+                                G_PRIORITY_DEFAULT,
+                                ctx->cancellable,
+                                (GAsyncReadyCallback)list_build_object_ready,
+                                ctx,
+                                "g-flags",          G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START,
+                                "g-name",           MM_DBUS_SERVICE,
+                                "g-connection",     g_dbus_proxy_get_connection (G_DBUS_PROXY (ctx->self)),
+                                "g-object-path",    ctx->sms_paths[ctx->i],
+                                "g-interface-name", "org.freedesktop.ModemManager1.Sms",
+                                NULL);
 }
 
 static void
@@ -335,12 +352,7 @@ list_ready (MMModemMessaging *self,
 
     /* Got list of paths. If at least one found, start creating objects for each */
     ctx->i = 0;
-    mm_sms_new (g_dbus_proxy_get_connection (
-                    G_DBUS_PROXY (self)),
-                ctx->sms_paths[ctx->i],
-                ctx->cancellable,
-                (GAsyncReadyCallback)list_build_object_ready,
-                ctx);
+    create_next_sms (ctx);
 }
 
 /**
@@ -417,14 +429,17 @@ mm_modem_messaging_list_sync (MMModemMessaging *self,
         return NULL;
 
     for (i = 0; sms_paths[i]; i++) {
-        MMSms *sms;
-
-        sms = mm_sms_new_sync (g_dbus_proxy_get_connection (
-                                   G_DBUS_PROXY (self)),
-                               sms_paths[i],
-                               cancellable,
-                               error);
-
+        GObject *sms;
+
+        sms = g_initable_new (MM_TYPE_SMS,
+                                 cancellable,
+                                 error,
+                                 "g-flags",          G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START,
+                                 "g-name",           MM_DBUS_SERVICE,
+                                 "g-connection",     g_dbus_proxy_get_connection (G_DBUS_PROXY (self)),
+                                 "g-object-path",    sms_paths[i],
+                                 "g-interface-name", "org.freedesktop.ModemManager1.Sms",
+                              NULL);
         if (!sms) {
             sms_object_list_free (sms_objects);
             g_strfreev (sms_paths);
@@ -485,9 +500,13 @@ new_sms_object_ready (GDBusConnection *connection,
                       CreateSmsContext *ctx)
 {
     GError *error = NULL;
-    MMSms *sms;
+    GObject *sms;
+    GObject *source_object;
+
+    source_object = g_async_result_get_source_object (res);
+    sms = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, &error);
+    g_object_unref (source_object);
 
-    sms = mm_sms_new_finish (res, &error);
     if (error)
         g_simple_async_result_take_error (ctx->result, error);
     else
@@ -516,12 +535,17 @@ create_sms_ready (MMModemMessaging *self,
         return;
     }
 
-    mm_sms_new (g_dbus_proxy_get_connection (
-                    G_DBUS_PROXY (self)),
-                sms_path,
-                ctx->cancellable,
-                (GAsyncReadyCallback)new_sms_object_ready,
-                ctx);
+    g_async_initable_new_async (MM_TYPE_SMS,
+                                G_PRIORITY_DEFAULT,
+                                ctx->cancellable,
+                                (GAsyncReadyCallback)new_sms_object_ready,
+                                ctx,
+                                "g-flags",          G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START,
+                                "g-name",           MM_DBUS_SERVICE,
+                                "g-connection",     g_dbus_proxy_get_connection (G_DBUS_PROXY (self)),
+                                "g-object-path",    sms_path,
+                                "g-interface-name", "org.freedesktop.ModemManager1.Sms",
+                                NULL);
     g_free (sms_path);
 }
 
@@ -604,17 +628,21 @@ mm_modem_messaging_create_sync (MMModemMessaging *self,
                                                cancellable,
                                                error);
     if (sms_path) {
-        sms = mm_sms_new_sync (g_dbus_proxy_get_connection (
-                                   G_DBUS_PROXY (self)),
-                               sms_path,
-                               cancellable,
-                               error);
+        sms = g_initable_new (MM_TYPE_SMS,
+                              cancellable,
+                              error,
+                              "g-flags",          G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START,
+                              "g-name",           MM_DBUS_SERVICE,
+                              "g-connection",     g_dbus_proxy_get_connection (G_DBUS_PROXY (self)),
+                              "g-object-path",    sms_path,
+                              "g-interface-name", "org.freedesktop.ModemManager1.Sms",
+                              NULL);
         g_free (sms_path);
     }
 
     g_variant_unref (dictionary);
 
-    return sms;
+    return (sms ? MM_SMS (sms) : NULL);
 }
 
 /*****************************************************************************/
diff --git a/libmm-glib/mm-sms.c b/libmm-glib/mm-sms.c
index af8e4350..3a0bd5f5 100644
--- a/libmm-glib/mm-sms.c
+++ b/libmm-glib/mm-sms.c
@@ -27,6 +27,22 @@
 #include "mm-modem.h"
 
 /**
+ * SECTION: mm-sms
+ * @title: MMSms
+ * @short_description: The SMS interface
+ *
+ * The #MMSms is an object providing access to the methods, signals and
+ * properties of the SMS interface.
+ *
+ * When the SMS is exposed and available in the bus, it is ensured that at
+ * least this interface is also available.
+ */
+
+G_DEFINE_TYPE (MMSms, mm_sms, MM_GDBUS_TYPE_SMS_PROXY)
+
+/*****************************************************************************/
+
+/**
  * mm_sms_get_path:
  * @self: A #MMSms.
  *
@@ -37,7 +53,7 @@
 const gchar *
 mm_sms_get_path (MMSms *self)
 {
-    g_return_val_if_fail (G_IS_DBUS_PROXY (self), NULL);
+    g_return_val_if_fail (MM_IS_SMS (self), NULL);
 
     RETURN_NON_EMPTY_CONSTANT_STRING (
         g_dbus_proxy_get_object_path (G_DBUS_PROXY (self)));
@@ -56,7 +72,7 @@ mm_sms_dup_path (MMSms *self)
 {
     gchar *value;
 
-    g_return_val_if_fail (G_IS_DBUS_PROXY (self), NULL);
+    g_return_val_if_fail (MM_IS_SMS (self), NULL);
 
     g_object_get (G_OBJECT (self),
                   "g-object-path", &value,
@@ -65,50 +81,57 @@ mm_sms_dup_path (MMSms *self)
     RETURN_NON_EMPTY_STRING (value);
 }
 
+/*****************************************************************************/
+
 /**
  * mm_sms_get_text:
  * @self: A #MMSms.
  *
- * TODO
+ * Gets the message text, in UTF-8.
  *
- * <warning>It is only safe to use this function on the thread where @self was constructed. Use mm_sms_dup_text() if on another thread.</warning>
+ * <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_sms_dup_text() if on another
+ * thread.</warning>
  *
- * Returns: (transfer none): The name of the text, or %NULL if it couldn't be retrieved.
+ * Returns: (transfer none): The message text, or %NULL if it doesn't contain any (e.g. contains data instead).
  */
 const gchar *
 mm_sms_get_text (MMSms *self)
 {
-    g_return_val_if_fail (MM_GDBUS_IS_SMS (self), NULL);
+    g_return_val_if_fail (MM_IS_SMS (self), NULL);
 
     RETURN_NON_EMPTY_CONSTANT_STRING (
-        mm_gdbus_sms_get_text (self));
+        mm_gdbus_sms_get_text (MM_GDBUS_SMS (self)));
 }
 
 /**
  * mm_sms_dup_text:
  * @self: A #MMSms.
  *
- * TODO
+ * Gets the message text, in UTF-8.
  *
- * Returns: (transfer full): The name of the text, or %NULL if it couldn't be retrieved. The returned value should be freed with g_free().
+ * Returns: (transfer full): The message text, or %NULL if it doesn't contain any (e.g. contains data instead). The returned value should be freed with g_free().
  */
 gchar *
 mm_sms_dup_text (MMSms *self)
 {
-    g_return_val_if_fail (MM_GDBUS_IS_SMS (self), NULL);
+    g_return_val_if_fail (MM_IS_SMS (self), NULL);
 
     RETURN_NON_EMPTY_STRING (
-        mm_gdbus_sms_dup_text (self));
+        mm_gdbus_sms_dup_text (MM_GDBUS_SMS (self)));
 }
 
+/*****************************************************************************/
+
 /**
  * mm_sms_get_data:
  * @self: A #MMSms.
- * @data_len: (out) Size of the output data, if any given.
+ * @data_len: (out): Size of the output data, if any given.
  *
- * TODO
+ * Gets the message data.
  *
- * Returns: (transfer none): The data, or %NULL if it couldn't be retrieved. The returned value should be freed with g_free().
+ * Returns: (transfer none): The message data, or %NULL if it doesn't contain any (e.g. contains text instead).
  */
 const guint8 *
 mm_sms_get_data (MMSms *self,
@@ -116,7 +139,8 @@ mm_sms_get_data (MMSms *self,
 {
     GVariant *data;
 
-    g_return_val_if_fail (MM_GDBUS_IS_SMS (self), NULL);
+    g_return_val_if_fail (MM_IS_SMS (self), NULL);
+    g_return_val_if_fail (data_len != NULL, NULL);
 
     data = mm_gdbus_sms_get_data (MM_GDBUS_SMS (self));
     return (data ?
@@ -132,9 +156,9 @@ mm_sms_get_data (MMSms *self,
  * @self: A #MMSms.
  * @data_len: (out) Size of the output data, if any given.
  *
- * TODO
+ * Gets the message data.
  *
- * Returns: (transfer full): The data, or %NULL if it couldn't be retrieved. The returned value should be freed with g_free().
+ * Returns: (transfer full): The message data, or %NULL if it doesn't contain any (e.g. contains text instead). The returned value should be freed with g_free().
  */
 guint8 *
 mm_sms_dup_data (MMSms *self,
@@ -145,7 +169,7 @@ mm_sms_dup_data (MMSms *self,
     const guint8 *orig_data;
     gsize orig_data_len = 0;
 
-    g_return_val_if_fail (MM_GDBUS_IS_SMS (self), NULL);
+    g_return_val_if_fail (MM_IS_SMS (self), NULL);
 
     /* Get a ref to ensure the variant is valid as long as we use it */
     data_variant = mm_gdbus_sms_dup_data (MM_GDBUS_SMS (self));
@@ -166,268 +190,357 @@ mm_sms_dup_data (MMSms *self,
     return out;
 }
 
+/*****************************************************************************/
+
 /**
  * mm_sms_get_number:
  * @self: A #MMSms.
  *
- * TODO
+ * Gets the number to which the message is addressed.
  *
- * <warning>It is only safe to use this function on the thread where @self was constructed. Use mm_sms_dup_number() if on another thread.</warning>
+ * <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_sms_dup_number() if on another
+ * thread.</warning>
  *
- * Returns: (transfer none): The name of the number, or %NULL if it couldn't be retrieved.
+ * Returns: (transfer none): The number, or %NULL if it couldn't be retrieved.
  */
 const gchar *
 mm_sms_get_number (MMSms *self)
 {
-    g_return_val_if_fail (MM_GDBUS_IS_SMS (self), NULL);
+    g_return_val_if_fail (MM_IS_SMS (self), NULL);
 
     RETURN_NON_EMPTY_CONSTANT_STRING (
-        mm_gdbus_sms_get_number (self));
+        mm_gdbus_sms_get_number (MM_GDBUS_SMS (self)));
 }
 
 /**
  * mm_sms_dup_number:
  * @self: A #MMSms.
  *
- * TODO
+ * Gets the number to which the message is addressed.
  *
- * Returns: (transfer full): The name of the number, or %NULL if it couldn't be retrieved. The returned value should be freed with g_free().
+ * Returns: (transfer full): The number, or %NULL if it couldn't be retrieved. The returned value should be freed with g_free().
  */
 gchar *
 mm_sms_dup_number (MMSms *self)
 {
-    g_return_val_if_fail (MM_GDBUS_IS_SMS (self), NULL);
+    g_return_val_if_fail (MM_IS_SMS (self), NULL);
 
     RETURN_NON_EMPTY_STRING (
-        mm_gdbus_sms_dup_number (self));
+        mm_gdbus_sms_dup_number (MM_GDBUS_SMS (self)));
 }
 
+/*****************************************************************************/
+
 /**
  * mm_sms_get_smsc:
  * @self: A #MMSms.
  *
- * TODO
+ * Gets the SMS service center number.
  *
- * <warning>It is only safe to use this function on the thread where @self was constructed. Use mm_sms_dup_smsc() if on another thread.</warning>
+ * <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_sms_dup_smsc() if on another
+ * thread.</warning>
  *
- * Returns: (transfer none): The name of the smsc, or %NULL if it couldn't be retrieved.
+ * Returns: (transfer none): The number of the SMSC, or %NULL if it couldn't be retrieved.
  */
 const gchar *
 mm_sms_get_smsc (MMSms *self)
 {
-    g_return_val_if_fail (MM_GDBUS_IS_SMS (self), NULL);
+    g_return_val_if_fail (MM_IS_SMS (self), NULL);
 
     RETURN_NON_EMPTY_CONSTANT_STRING (
-        mm_gdbus_sms_get_smsc (self));
+        mm_gdbus_sms_get_smsc (MM_GDBUS_SMS (self)));
 }
 
 /**
  * mm_sms_dup_smsc:
  * @self: A #MMSms.
  *
- * TODO
+ * Gets the SMS service center number.
  *
- * Returns: (transfer full): The name of the smsc, or %NULL if it couldn't be retrieved. The returned value should be freed with g_free().
+ * Returns: (transfer full): The number of the SMSC, or %NULL if it couldn't be retrieved. The returned value should be freed with g_free().
  */
 gchar *
 mm_sms_dup_smsc (MMSms *self)
 {
-    g_return_val_if_fail (MM_GDBUS_IS_SMS (self), NULL);
+    g_return_val_if_fail (MM_IS_SMS (self), NULL);
 
     RETURN_NON_EMPTY_STRING (
-        mm_gdbus_sms_dup_smsc (self));
+        mm_gdbus_sms_dup_smsc (MM_GDBUS_SMS (self)));
 }
 
+/*****************************************************************************/
+
 /**
  * mm_sms_get_timestamp:
  * @self: A #MMSms.
  *
- * TODO
+ * Gets the time when the first PDU of the SMS message arrived the SMSC, in
+ * <ulink url="http://en.wikipedia.org/wiki/ISO_8601">ISO8601</ulink>
+ * format.
+ *
+ * This field is only applicable if the PDU type is %MM_SMS_PDU_TYPE_DELIVER or
+ * %MM_SMS_PDU_TYPE_STATUS_REPORT.
  *
- * <warning>It is only safe to use this function on the thread where @self was constructed. Use mm_sms_dup_timestamp() if on another thread.</warning>
+ * <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_sms_dup_timestamp() if on another
+ * thread.</warning>
  *
- * Returns: (transfer none): The name of the timestamp, or %NULL if it couldn't be retrieved.
+ * Returns: (transfer none): The timestamp, or %NULL if it couldn't be retrieved.
  */
 const gchar *
 mm_sms_get_timestamp (MMSms *self)
 {
-    g_return_val_if_fail (MM_GDBUS_IS_SMS (self), NULL);
+    g_return_val_if_fail (MM_IS_SMS (self), NULL);
 
     RETURN_NON_EMPTY_CONSTANT_STRING (
-        mm_gdbus_sms_get_timestamp (self));
+        mm_gdbus_sms_get_timestamp (MM_GDBUS_SMS (self)));
 }
 
 /**
  * mm_sms_dup_timestamp:
  * @self: A #MMSms.
  *
- * TODO
+ * Gets the time when the first PDU of the SMS message arrived the SMSC, in
+ * <ulink url="http://en.wikipedia.org/wiki/ISO_8601">ISO8601</ulink>
+ * format.
  *
- * Returns: (transfer full): The name of the timestamp, or %NULL if it couldn't be retrieved. The returned value should be freed with g_free().
+ * This field is only applicable if the PDU type is %MM_SMS_PDU_TYPE_DELIVER or
+ * %MM_SMS_PDU_TYPE_STATUS_REPORT.
+ *
+ * Returns: (transfer full): The timestamp, or %NULL if it couldn't be retrieved. The returned value should be freed with g_free().
  */
 gchar *
 mm_sms_dup_timestamp (MMSms *self)
 {
-    g_return_val_if_fail (MM_GDBUS_IS_SMS (self), NULL);
+    g_return_val_if_fail (MM_IS_SMS (self), NULL);
 
     RETURN_NON_EMPTY_STRING (
-        mm_gdbus_sms_dup_timestamp (self));
+        mm_gdbus_sms_dup_timestamp (MM_GDBUS_SMS (self)));
 }
 
+/*****************************************************************************/
+
 /**
  * mm_sms_get_discharge_timestamp:
  * @self: A #MMSms.
  *
- * TODO
+ * Gets the time when the first PDU of the SMS message left the SMSC, in
+ * <ulink url="http://en.wikipedia.org/wiki/ISO_8601">ISO8601</ulink>
+ * format.
  *
- * <warning>It is only safe to use this function on the thread where @self was constructed. Use mm_sms_dup_timestamp() if on another thread.</warning>
+ * This field is only applicable if the PDU type is %MM_SMS_PDU_TYPE_STATUS_REPORT.
  *
- * Returns: (transfer none): The name of the timestamp, or %NULL if it couldn't be retrieved.
+ * <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_sms_dup_discharge_timestamp() if on another
+ * thread.</warning>
+ *
+ * Returns: (transfer none): The timestamp, or %NULL if it couldn't be retrieved.
  */
 const gchar *
 mm_sms_get_discharge_timestamp (MMSms *self)
 {
-    g_return_val_if_fail (MM_GDBUS_IS_SMS (self), NULL);
+    g_return_val_if_fail (MM_IS_SMS (self), NULL);
 
     RETURN_NON_EMPTY_CONSTANT_STRING (
-        mm_gdbus_sms_get_discharge_timestamp (self));
+        mm_gdbus_sms_get_discharge_timestamp (MM_GDBUS_SMS (self)));
 }
 
 /**
  * mm_sms_dup_discharge_timestamp:
  * @self: A #MMSms.
  *
- * TODO
+ * Gets the time when the first PDU of the SMS message left the SMSC, in
+ * <ulink url="http://en.wikipedia.org/wiki/ISO_8601">ISO8601</ulink>
+ * format.
+ *
+ * This field is only applicable if the PDU type is %MM_SMS_PDU_TYPE_STATUS_REPORT.
  *
- * Returns: (transfer full): The name of the timestamp, or %NULL if it couldn't be retrieved. The returned value should be freed with g_free().
+ * Returns: (transfer full): The timestamp, or %NULL if it couldn't be retrieved. The returned value should be freed with g_free().
  */
 gchar *
 mm_sms_dup_discharge_timestamp (MMSms *self)
 {
-    g_return_val_if_fail (MM_GDBUS_IS_SMS (self), NULL);
+    g_return_val_if_fail (MM_IS_SMS (self), NULL);
 
     RETURN_NON_EMPTY_STRING (
-        mm_gdbus_sms_dup_discharge_timestamp (self));
+        mm_gdbus_sms_dup_discharge_timestamp (MM_GDBUS_SMS (self)));
 }
 
+/*****************************************************************************/
+
 /**
  * mm_sms_get_validity:
  * @self: A #MMSms.
  *
- * TODO
+ * Gets the validity time of the SMS.
  *
- * Returns: TODO
+ * Returns: the validity time or 0 if unknown.
  */
 guint
 mm_sms_get_validity (MMSms *self)
 {
-    g_return_val_if_fail (MM_GDBUS_IS_SMS (self), 0);
+    g_return_val_if_fail (MM_IS_SMS (self), 0);
 
-    return mm_gdbus_sms_get_validity (self);
+    return mm_gdbus_sms_get_validity (MM_GDBUS_SMS (self));
 }
 
+/*****************************************************************************/
+
 /**
  * mm_sms_get_class:
  * @self: A #MMSms.
  *
- * TODO
+ * Gets the 3GPP message class of the SMS.
  *
- * Returns: TODO
+ * Returns: the message class.
  */
 guint
 mm_sms_get_class (MMSms *self)
 {
-    g_return_val_if_fail (MM_GDBUS_IS_SMS (self), 0);
+    g_return_val_if_fail (MM_IS_SMS (self), 0);
 
-    return mm_gdbus_sms_get_class (self);
+    return mm_gdbus_sms_get_class (MM_GDBUS_SMS (self));
 }
 
+/*****************************************************************************/
+
 /**
  * mm_sms_get_message_reference:
  * @self: A #MMSms.
  *
- * TODO
+ * Gets the message reference of the last PDU sent/received within this SMS.
  *
- * Returns: TODO
+ * If the PDU type is %MM_SMS_PDU_TYPE_STATUS_REPORT, this field identifies the
+ * message reference of the PDU associated to the status report.
+ *
+ * Returns: The message reference.
  */
 guint
 mm_sms_get_message_reference (MMSms *self)
 {
-    g_return_val_if_fail (MM_GDBUS_IS_SMS (self), 0);
+    g_return_val_if_fail (MM_IS_SMS (self), 0);
 
-    return mm_gdbus_sms_get_message_reference (self);
+    return mm_gdbus_sms_get_message_reference (MM_GDBUS_SMS (self));
 }
 
+/*****************************************************************************/
+
+/**
+ * mm_sms_get_delivery_report_request:
+ * @self: A #MMSms.
+ *
+ * Checks whether delivery report is requested for this SMS.
+ *
+ * Returns: %TRUE if delivery report is requested, %FALSE otherwise.
+ */
 gboolean
 mm_sms_get_delivery_report_request (MMSms *self)
 {
-    g_return_val_if_fail (MM_GDBUS_IS_SMS (self), FALSE);
+    g_return_val_if_fail (MM_IS_SMS (self), FALSE);
 
-    return mm_gdbus_sms_get_delivery_report_request (self);
+    return mm_gdbus_sms_get_delivery_report_request (MM_GDBUS_SMS (self));
 }
 
+/*****************************************************************************/
+
 /**
  * mm_sms_get_delivery_state:
  * @self: A #MMSms.
  *
- * TODO
+ * Gets the delivery state of this SMS.
+ *
+ * This field is only applicable if the PDU type is %MM_SMS_PDU_TYPE_STATUS_REPORT.
  *
- * Returns: TODO
+ * Returns: A #MMSmsDeliveryState specifying the delivery state.
  */
 guint
 mm_sms_get_delivery_state (MMSms *self)
 {
-    g_return_val_if_fail (MM_GDBUS_IS_SMS (self), MM_SMS_DELIVERY_STATE_UNKNOWN);
+    g_return_val_if_fail (MM_IS_SMS (self), MM_SMS_DELIVERY_STATE_UNKNOWN);
 
-    return mm_gdbus_sms_get_delivery_state (self);
+    return mm_gdbus_sms_get_delivery_state (MM_GDBUS_SMS (self));
 }
 
+/*****************************************************************************/
+
 /**
  * mm_sms_get_state:
  * @self: A #MMSms.
  *
- * TODO
+ * Gets the state of this SMS.
  *
- * Returns: TODO
+ * Returns: A #MMSmsState specifying the state.
  */
 MMSmsState
 mm_sms_get_state (MMSms *self)
 {
-    g_return_val_if_fail (MM_GDBUS_IS_SMS (self), MM_SMS_STATE_UNKNOWN);
+    g_return_val_if_fail (MM_IS_SMS (self), MM_SMS_STATE_UNKNOWN);
 
-    return mm_gdbus_sms_get_state (self);
+    return (MMSmsState)mm_gdbus_sms_get_state (MM_GDBUS_SMS (self));
 }
 
+/*****************************************************************************/
+
 /**
  * mm_sms_get_storage:
  * @self: A #MMSms.
  *
- * TODO
+ * Gets the storage in which this SMS is kept.
  *
- * Returns: TODO
+ * Returns: A #MMSmsStorage specifying the storage.
  */
 MMSmsStorage
 mm_sms_get_storage (MMSms *self)
 {
-    g_return_val_if_fail (MM_GDBUS_IS_SMS (self), MM_SMS_STORAGE_UNKNOWN);
+    g_return_val_if_fail (MM_IS_SMS (self), MM_SMS_STORAGE_UNKNOWN);
 
-    return mm_gdbus_sms_get_storage (self);
+    return (MMSmsStorage)mm_gdbus_sms_get_storage (MM_GDBUS_SMS (self));
 }
 
+/*****************************************************************************/
+
 /**
  * mm_sms_get_pdu_type:
  * @self: A #MMSms.
  *
- * TODO
+ * Gets the PDU type on which this SMS is based.
  *
- * Returns: TODO
+ * Returns: A #MMSmsPduType specifying the PDU type.
  */
 MMSmsPduType
 mm_sms_get_pdu_type (MMSms *self)
 {
-    g_return_val_if_fail (MM_GDBUS_IS_SMS (self), MM_SMS_PDU_TYPE_UNKNOWN);
+    g_return_val_if_fail (MM_IS_SMS (self), MM_SMS_PDU_TYPE_UNKNOWN);
+
+    return (MMSmsPduType)mm_gdbus_sms_get_pdu_type (MM_GDBUS_SMS (self));
+}
+
+/*****************************************************************************/
+
+/**
+ * mm_sms_send_finish:
+ * @self: A #MMSms.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_sms_send().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with mm_sms_send().
+ *
+ * Returns:  %TRUE if the operation succeded, %FALSE if @error is set.
+ */
+gboolean
+mm_sms_send_finish (MMSms *self,
+                    GAsyncResult *res,
+                    GError **error)
+{
+    g_return_val_if_fail (MM_IS_SMS (self), FALSE);
 
-    return (MMSmsPduType)mm_gdbus_sms_get_pdu_type (self);
+    return mm_gdbus_sms_call_send_finish (MM_GDBUS_SMS (self), res, error);
 }
 
 /**
@@ -437,7 +550,9 @@ mm_sms_get_pdu_type (MMSms *self)
  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
  * @user_data: User data to pass to @callback.
  *
- * TODO
+ * Asynchronously requests to queue the message for delivery.
+ *
+ * SMS objects can only be sent once.
  *
  * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
  * You can then call mm_sms_send_finish() to get the result of the operation.
@@ -450,57 +565,61 @@ mm_sms_send (MMSms *self,
              GAsyncReadyCallback callback,
              gpointer user_data)
 {
-    g_return_if_fail (MM_GDBUS_IS_SMS (self));
+    g_return_if_fail (MM_IS_SMS (self));
 
-    mm_gdbus_sms_call_send (self,
+    mm_gdbus_sms_call_send (MM_GDBUS_SMS (self),
                             cancellable,
                             callback,
                             user_data);
 }
 
 /**
- * mm_sms_send_finish:
+ * mm_sms_send_sync:
  * @self: A #MMSms.
- * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_sms_send().
+ * @cancellable: (allow-none): A #GCancellable or %NULL.
  * @error: Return location for error or %NULL.
  *
- * Finishes an operation started with mm_sms_send().
+ * Synchronously requests to queue the message for delivery.
+ *
+ * SMS objects can only be sent once.
  *
- * Returns: (skip): %TRUE if the operation succeded, %FALSE if @error is set.
+ * The calling thread is blocked until a reply is received.
+ * See mm_sms_send() for the asynchronous version of this method.
+ *
+ * Returns: %TRUE if the operation succeded, %FALSE if @error is set.
  */
 gboolean
-mm_sms_send_finish (MMSms *self,
-                    GAsyncResult *res,
-                    GError **error)
+mm_sms_send_sync (MMSms *self,
+                  GCancellable *cancellable,
+                  GError **error)
 {
-    g_return_val_if_fail (MM_GDBUS_IS_SMS (self), FALSE);
+    g_return_val_if_fail (MM_IS_SMS (self), FALSE);
 
-    return mm_gdbus_sms_call_send_finish (self, res, error);
+    return mm_gdbus_sms_call_send_sync (MM_GDBUS_SMS (self),
+                                        cancellable,
+                                        error);
 }
 
+/*****************************************************************************/
+
 /**
- * mm_sms_send_sync:
+ * mm_sms_store_finish:
  * @self: A #MMSms.
- * @cancellable: (allow-none): A #GCancellable or %NULL.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_sms_store().
  * @error: Return location for error or %NULL.
  *
- * TODO
- *
- * The calling thread is blocked until a reply is received.
- * See mm_sms_send() for the asynchronous version of this method.
+ * Finishes an operation started with mm_sms_store().
  *
- * Returns: (skip): %TRUE if the operation succeded, %FALSE if @error is set.
+ * Returns: %TRUE if the operation succeded, %FALSE if @error is set.
  */
 gboolean
-mm_sms_send_sync (MMSms *self,
-                  GCancellable *cancellable,
-                  GError **error)
+mm_sms_store_finish (MMSms *self,
+                     GAsyncResult *res,
+                     GError **error)
 {
-    g_return_val_if_fail (MM_GDBUS_IS_SMS (self), FALSE);
+    g_return_val_if_fail (MM_IS_SMS (self), FALSE);
 
-    return mm_gdbus_sms_call_send_sync (self,
-                                        cancellable,
-                                        error);
+    return mm_gdbus_sms_call_store_finish (MM_GDBUS_SMS (self), res, error);
 }
 
 /**
@@ -511,7 +630,9 @@ mm_sms_send_sync (MMSms *self,
  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
  * @user_data: User data to pass to @callback.
  *
- * TODO
+ * Asynchronoulsy requests to store the message in the device if not already done.
+ *
+ * SMS objects can only be stored once.
  *
  * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
  * You can then call mm_sms_store_finish() to get the result of the operation.
@@ -525,9 +646,9 @@ mm_sms_store (MMSms *self,
               GAsyncReadyCallback callback,
               gpointer user_data)
 {
-    g_return_if_fail (MM_GDBUS_IS_SMS (self));
+    g_return_if_fail (MM_IS_SMS (self));
 
-    mm_gdbus_sms_call_store (self,
+    mm_gdbus_sms_call_store (MM_GDBUS_SMS (self),
                              storage,
                              cancellable,
                              callback,
@@ -535,38 +656,20 @@ mm_sms_store (MMSms *self,
 }
 
 /**
- * mm_sms_store_finish:
- * @self: A #MMSms.
- * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_sms_store().
- * @error: Return location for error or %NULL.
- *
- * Finishes an operation started with mm_sms_store().
- *
- * Returns: (skip): %TRUE if the operation succeded, %FALSE if @error is set.
- */
-gboolean
-mm_sms_store_finish (MMSms *self,
-                     GAsyncResult *res,
-                     GError **error)
-{
-    g_return_val_if_fail (MM_GDBUS_IS_SMS (self), FALSE);
-
-    return mm_gdbus_sms_call_store_finish (self, res, error);
-}
-
-/**
  * mm_sms_store_sync:
  * @self: A #MMSms.
  * @storage: A #MMSmsStorage specifying where to store the SMS, or #MM_SMS_STORAGE_UNKNOWN to use the default.
  * @cancellable: (allow-none): A #GCancellable or %NULL.
  * @error: Return location for error or %NULL.
  *
- * TODO
+ * Synchronoulsy requests to store the message in the device if not already done.
+ *
+ * SMS objects can only be stored once.
  *
  * The calling thread is blocked until a reply is received.
  * See mm_sms_store() for the asynchronous version of this method.
  *
- * Returns: (skip): %TRUE if the operation succeded, %FALSE if @error is set.
+ * Returns: %TRUE if the operation succeded, %FALSE if @error is set.
  */
 gboolean
 mm_sms_store_sync (MMSms *self,
@@ -574,47 +677,22 @@ mm_sms_store_sync (MMSms *self,
                    GCancellable *cancellable,
                    GError **error)
 {
-    g_return_val_if_fail (MM_GDBUS_IS_SMS (self), FALSE);
+    g_return_val_if_fail (MM_IS_SMS (self), FALSE);
 
-    return mm_gdbus_sms_call_store_sync (self,
+    return mm_gdbus_sms_call_store_sync (MM_GDBUS_SMS (self),
                                          storage,
                                          cancellable,
                                          error);
 }
 
-void
-mm_sms_new (GDBusConnection *connection,
-            const gchar *path,
-            GCancellable *cancellable,
-            GAsyncReadyCallback callback,
-            gpointer user_data)
-{
-    return mm_gdbus_sms_proxy_new (connection,
-                                   G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START,
-                                   MM_DBUS_SERVICE,
-                                   path,
-                                   cancellable,
-                                   callback,
-                                   user_data);
-}
+/*****************************************************************************/
 
-MMSms *
-mm_sms_new_finish (GAsyncResult *res,
-                   GError **error)
+static void
+mm_sms_init (MMSms *self)
 {
-    return mm_gdbus_sms_proxy_new_finish (res, error);
 }
 
-MMSms *
-mm_sms_new_sync (GDBusConnection *connection,
-                 const gchar *path,
-                 GCancellable *cancellable,
-                 GError **error)
+static void
+mm_sms_class_init (MMSmsClass *sms_class)
 {
-    return mm_gdbus_sms_proxy_new_sync (connection,
-                                        G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START,
-                                        MM_DBUS_SERVICE,
-                                        path,
-                                        cancellable,
-                                        error);
 }
diff --git a/libmm-glib/mm-sms.h b/libmm-glib/mm-sms.h
index bb73ce0b..6a252a94 100644
--- a/libmm-glib/mm-sms.h
+++ b/libmm-glib/mm-sms.h
@@ -28,74 +28,98 @@
 
 G_BEGIN_DECLS
 
-typedef MmGdbusSms     MMSms;
-#define MM_TYPE_SMS(o) MM_GDBUS_TYPE_SMS (o)
-#define MM_SMS(o)      MM_GDBUS_SMS(o)
-#define MM_IS_SMS(o)   MM_GDBUS_IS_SMS(o)
-
-const gchar *mm_sms_get_path (MMSms *self);
-gchar       *mm_sms_dup_path (MMSms *self);
-
-void mm_sms_new (GDBusConnection     *connection,
-                 const gchar         *object_path,
-                 GCancellable        *cancellable,
-                 GAsyncReadyCallback  callback,
-                 gpointer             user_data);
-MMSms *mm_sms_new_finish (GAsyncResult  *res,
-                          GError       **error);
-
-MMSms *mm_sms_new_sync (GDBusConnection     *connection,
-                        const gchar         *object_path,
-                        GCancellable        *cancellable,
-                        GError             **error);
+#define MM_TYPE_SMS            (mm_sms_get_type ())
+#define MM_SMS(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), MM_TYPE_SMS, MMSms))
+#define MM_SMS_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), MM_TYPE_SMS, MMSmsClass))
+#define MM_IS_SMS(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MM_TYPE_SMS))
+#define MM_IS_SMS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), MM_TYPE_SMS))
+#define MM_SMS_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), MM_TYPE_SMS, MMSmsClass))
 
-void     mm_sms_send        (MMSms *self,
-                             GCancellable *cancellable,
-                             GAsyncReadyCallback callback,
-                             gpointer user_data);
-gboolean mm_sms_send_finish (MMSms *self,
-                             GAsyncResult *res,
-                             GError **error);
-gboolean mm_sms_send_sync   (MMSms *self,
-                             GCancellable *cancellable,
-                             GError **error);
+typedef struct _MMSms MMSms;
+typedef struct _MMSmsClass MMSmsClass;
 
-void     mm_sms_store        (MMSms *self,
-                              MMSmsStorage storage,
-                              GCancellable *cancellable,
-                              GAsyncReadyCallback callback,
-                              gpointer user_data);
-gboolean mm_sms_store_finish (MMSms *self,
-                              GAsyncResult *res,
-                              GError **error);
-gboolean mm_sms_store_sync   (MMSms *self,
-                              MMSmsStorage storage,
-                              GCancellable *cancellable,
-                              GError **error);
+/**
+ * MMSms:
+ *
+ * The #MMSms structure contains private data and should only be accessed
+ * using the provided API.
+ */
+struct _MMSms {
+    /*< private >*/
+    MmGdbusSmsProxy parent;
+    gpointer unused;
+};
+
+struct _MMSmsClass {
+    /*< private >*/
+    MmGdbusSmsProxyClass parent;
+};
+
+GType mm_sms_get_type (void);
+
+const gchar *mm_sms_get_path                     (MMSms *self);
+gchar       *mm_sms_dup_path                     (MMSms *self);
 
 const gchar  *mm_sms_get_text                    (MMSms *self);
 gchar        *mm_sms_dup_text                    (MMSms *self);
+
 const guint8 *mm_sms_get_data                    (MMSms *self,
                                                   gsize *data_len);
 guint8       *mm_sms_dup_data                    (MMSms *self,
                                                   gsize *data_len);
+
 const gchar  *mm_sms_get_number                  (MMSms *self);
 gchar        *mm_sms_dup_number                  (MMSms *self);
+
 const gchar  *mm_sms_get_smsc                    (MMSms *self);
 gchar        *mm_sms_dup_smsc                    (MMSms *self);
+
 const gchar  *mm_sms_get_timestamp               (MMSms *self);
 gchar        *mm_sms_dup_timestamp               (MMSms *self);
+
 const gchar  *mm_sms_get_discharge_timestamp     (MMSms *self);
 gchar        *mm_sms_dup_discharge_timestamp     (MMSms *self);
+
 guint         mm_sms_get_validity                (MMSms *self);
+
 guint         mm_sms_get_class                   (MMSms *self);
+
 guint         mm_sms_get_message_reference       (MMSms *self);
+
 gboolean      mm_sms_get_delivery_report_request (MMSms *self);
+
 guint         mm_sms_get_delivery_state          (MMSms *self);
+
 MMSmsState    mm_sms_get_state                   (MMSms *self);
+
 MMSmsStorage  mm_sms_get_storage                 (MMSms *self);
+
 MMSmsPduType  mm_sms_get_pdu_type                (MMSms *self);
 
+void     mm_sms_send        (MMSms *self,
+                             GCancellable *cancellable,
+                             GAsyncReadyCallback callback,
+                             gpointer user_data);
+gboolean mm_sms_send_finish (MMSms *self,
+                             GAsyncResult *res,
+                             GError **error);
+gboolean mm_sms_send_sync   (MMSms *self,
+                             GCancellable *cancellable,
+                             GError **error);
+
+void     mm_sms_store        (MMSms *self,
+                              MMSmsStorage storage,
+                              GCancellable *cancellable,
+                              GAsyncReadyCallback callback,
+                              gpointer user_data);
+gboolean mm_sms_store_finish (MMSms *self,
+                              GAsyncResult *res,
+                              GError **error);
+gboolean mm_sms_store_sync   (MMSms *self,
+                              MMSmsStorage storage,
+                              GCancellable *cancellable,
+                              GError **error);
+
 G_END_DECLS
 
 #endif /* _MM_SMS_H_ */