Added EmpathyFile and EmpathyTpFile objects. (Jonny Lamb)

Signed-off-by: Jonny Lamb <jonny.lamb@collabora.co.uk>

svn path=/trunk/; revision=1736

1 files changed, 650 insertions, 0 deletions

diff --git a/libempathy/empathy-file.c b/libempathy/empathy-file.c
new file mode 100644
index 000000000..dd4079005
--- /dev/null
+++ b/libempathy/empathy-file.c
@@ -0,0 +1,650 @@
+/*
+ * Copyright (C) 2007 Marco Barisione <marco@barisione.org>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include "config.h"
+
+#include "empathy-file.h"
+#include "empathy-tp-file.h"
+#include "empathy-tp-file-priv.h"
+#include "empathy-utils.h"
+#include "empathy-enum-types.h"
+
+#define DEBUG_FLAG EMPATHY_DEBUG_FT
+#include "empathy-debug.h"
+
+/**
+ * SECTION:empathy-file
+ * @short_description: Transfer files with contacts
+ * @see_also: #EmpathyTpFile, #EmpathyContact
+ * @include: libempthy/empathy-file.h
+ *
+ * The #EmpathyFile object represents a single file transfer. Usually file
+ * transfers are not created directly, but using empathy_tp_file_offer_file()
+ * or an utility function such as empathy_send_file().
+ * For incoming file transfers you can get notified of their creation
+ * connecting to the "new-file-transfer" signal of #EmpathyTpFile.
+ */
+
+/**
+ * EMPATHY_FILE_UNKNOWN_SIZE:
+ *
+ * Value used for the "size" property when the size of the transferred
+ * file is unknown.
+ */
+
+/* Telepathy does not have file transfer objects, file transfers are identified
+ * just with an ID (valid only with the corresponding channel).
+ * So EmpathyFile is just a convenience class that contains only an EmpathyTpFile
+ * and an ID. Every actual function is delegated to the EmpathyTpFile. */
+
+#define GET_PRIV(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), EMPATHY_TYPE_FILE, EmpathyFilePriv))
+
+typedef struct _EmpathyFilePriv EmpathyFilePriv;
+
+struct _EmpathyFilePriv
+{
+  EmpathyTpFile *tp_file;
+  guint id;
+};
+
+static void empathy_file_class_init (EmpathyFileClass *klass);
+static void empathy_file_init (EmpathyFile *file);
+static void file_finalize (GObject *object);
+static void file_get_property (GObject *object, guint param_id, GValue *value,
+    GParamSpec *pspec);
+static void file_set_property (GObject *object, guint param_id,
+    const GValue *value, GParamSpec *pspec);
+static void file_set_tp_file (EmpathyFile *file, EmpathyTpFile *tp_file);
+
+enum
+{
+  PROP_0,
+  PROP_TP_FILE,
+  PROP_CONTACT,
+  PROP_INPUT_STREAM,
+  PROP_OUTPUT_STREAM,
+  PROP_FILENAME,
+  PROP_DIRECTION,
+  PROP_STATE,
+  PROP_SIZE,
+  PROP_TRANSFERRED_BYTES,
+  PROP_REMAINING_TIME,
+  PROP_STATE_CHANGE_REASON,
+};
+
+G_DEFINE_TYPE (EmpathyFile, empathy_file, G_TYPE_OBJECT);
+
+static void
+empathy_file_class_init (EmpathyFileClass *klass)
+  {
+    GObjectClass *object_class;
+
+    object_class = G_OBJECT_CLASS (klass);
+
+    object_class->finalize     = file_finalize;
+    object_class->get_property = file_get_property;
+    object_class->set_property = file_set_property;
+
+    g_object_class_install_property (object_class,
+        PROP_TP_FILE,
+        g_param_spec_object ("tp-file",
+            "EmpathyTpFile",
+            "The associated EmpathyTpFile",
+            EMPATHY_TYPE_TP_FILE,
+            G_PARAM_READWRITE |
+            G_PARAM_CONSTRUCT_ONLY));
+
+    g_object_class_install_property (object_class,
+        PROP_CONTACT,
+        g_param_spec_object ("contact",
+            "EmpathyContact",
+            "The contact with whom we are transferring the file",
+            EMPATHY_TYPE_CONTACT,
+            G_PARAM_READABLE));
+
+    g_object_class_install_property (object_class,
+        PROP_INPUT_STREAM,
+        g_param_spec_object ("input-stream",
+            "Input stream",
+            "The stream from which to read the data to send",
+            G_TYPE_INPUT_STREAM,
+            G_PARAM_READWRITE));
+
+    g_object_class_install_property (object_class,
+        PROP_OUTPUT_STREAM,
+        g_param_spec_object ("output-stream",
+            "Output stream",
+            "The stream to which to write the received file",
+            G_TYPE_OUTPUT_STREAM,
+            G_PARAM_READWRITE));
+
+    g_object_class_install_property (object_class,
+        PROP_FILENAME,
+        g_param_spec_string ("filename",
+            "File name",
+            "The file's name, for displaying",
+            NULL,
+            G_PARAM_READWRITE));
+
+    g_object_class_install_property (object_class,
+        PROP_DIRECTION,
+        g_param_spec_uint ("direction",
+            "Transfer direction",
+             "The direction of the file transfer",
+             0,
+             G_MAXUINT,
+             G_MAXUINT,
+             G_PARAM_READABLE));
+
+    g_object_class_install_property (object_class,
+       PROP_STATE,
+       g_param_spec_uint ("state",
+           "Transfer state",
+           "The file transfer state",
+           0,
+           G_MAXUINT,
+           G_MAXUINT,
+           G_PARAM_READABLE));
+
+    g_object_class_install_property (object_class,
+        PROP_SIZE,
+        g_param_spec_uint64 ("size",
+            "Size",
+            "The file size in bytes",
+            0,
+            G_MAXUINT64,
+            EMPATHY_FILE_UNKNOWN_SIZE,
+            G_PARAM_READABLE));
+
+    g_object_class_install_property (object_class,
+        PROP_TRANSFERRED_BYTES,
+        g_param_spec_uint64 ("transferred-bytes",
+            "Transferred bytes",
+            "The number of already transferred bytes",
+            0,
+            G_MAXUINT64,
+            0,
+            G_PARAM_READABLE));
+
+    g_object_class_install_property (object_class,
+        PROP_REMAINING_TIME,
+        g_param_spec_int ("remaining-time",
+            "Remaining time",
+            "The estimated number of remaining seconds before completing the transfer",
+            -1,
+            G_MAXINT,
+            -1,
+            G_PARAM_READABLE));
+
+    g_object_class_install_property (object_class,
+        PROP_STATE_CHANGE_REASON,
+        g_param_spec_uint ("state-change-reason",
+            "State change reason",
+            "The reason why the file transfer changed state",
+            0,
+            G_MAXUINT,
+            G_MAXUINT,
+            G_PARAM_READABLE));
+
+    g_type_class_add_private (object_class, sizeof (EmpathyFilePriv));
+}
+
+static void
+empathy_file_init (EmpathyFile *file)
+{
+}
+
+static void
+file_finalize (GObject *object)
+{
+  EmpathyFilePriv *priv;
+  EmpathyTpFile *tp_file;
+
+  priv = GET_PRIV (object);
+  tp_file = priv->tp_file;
+
+  DEBUG ("finalize: %p", object);
+
+  (G_OBJECT_CLASS (empathy_file_parent_class)->finalize) (object);
+
+  if (tp_file)
+    g_object_unref (tp_file);
+}
+
+static void
+file_get_property (GObject    *object,
+     guint       param_id,
+     GValue     *value,
+     GParamSpec *pspec)
+{
+  EmpathyFilePriv *priv;
+
+  priv = GET_PRIV (object);
+
+  switch (param_id)
+    {
+      case PROP_TP_FILE:
+        g_value_set_object (value,
+            empathy_file_get_tp_file (EMPATHY_FILE (object)));
+        break;
+      case PROP_CONTACT:
+        g_value_set_object (value,
+            empathy_file_get_contact (EMPATHY_FILE (object)));
+        break;
+      case PROP_INPUT_STREAM:
+        g_value_set_object (value,
+            empathy_file_get_input_stream (EMPATHY_FILE (object)));
+        break;
+      case PROP_OUTPUT_STREAM:
+        g_value_set_object (value,
+            empathy_file_get_output_stream (EMPATHY_FILE (object)));
+        break;
+      case PROP_FILENAME:
+        g_value_set_string (value,
+            empathy_file_get_filename (EMPATHY_FILE (object)));
+        break;
+      case PROP_DIRECTION:
+        g_value_set_uint (value,
+          empathy_file_get_direction (EMPATHY_FILE (object)));
+        break;
+      case PROP_STATE:
+        g_value_set_uint (value,
+          empathy_file_get_state (EMPATHY_FILE (object)));
+        break;
+      case PROP_SIZE:
+        g_value_set_uint64 (value,
+            empathy_file_get_size (EMPATHY_FILE (object)));
+        break;
+      case PROP_TRANSFERRED_BYTES:
+        g_value_set_uint64 (value,
+            empathy_file_get_transferred_bytes (EMPATHY_FILE (object)));
+        break;
+      case PROP_REMAINING_TIME:
+        g_value_set_int (value,
+         empathy_file_get_remaining_time (EMPATHY_FILE (object)));
+        break;
+      case PROP_STATE_CHANGE_REASON:
+        g_value_set_uint (value,
+          empathy_file_get_state_change_reason (EMPATHY_FILE (object)));
+        break;
+      default:
+        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
+        break;
+    }
+}
+
+static void
+file_set_property (GObject *object, guint param_id, const GValue *value,
+     GParamSpec   *pspec)
+{
+  EmpathyFilePriv *priv;
+
+  priv = GET_PRIV (object);
+
+  switch (param_id)
+    {
+      case PROP_TP_FILE:
+        file_set_tp_file (EMPATHY_FILE (object),
+            g_value_get_object (value));
+        break;
+      case PROP_INPUT_STREAM:
+        empathy_file_set_input_stream (EMPATHY_FILE (object),
+            g_value_get_object (value));
+        break;
+      case PROP_OUTPUT_STREAM:
+        empathy_file_set_output_stream (EMPATHY_FILE (object),
+            g_value_get_object (value));
+        break;
+      case PROP_FILENAME:
+        empathy_file_set_filename (EMPATHY_FILE (object),
+            g_value_get_string (value));
+        break;
+      default:
+        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
+        break;
+    };
+}
+
+/**
+ * empathy_file_new:
+ * @tp_file: an EmpathyTpFile
+ *
+ * Returns a new #EmpathyFile object associated with #EmpathyTpFile.
+ *
+ * Returns: the associated #EmpathyFile
+ */
+EmpathyFile *
+empathy_file_new (EmpathyTpFile *tp_file)
+{
+  return g_object_new (EMPATHY_TYPE_FILE,
+                       "tp_file", tp_file,
+                       NULL);
+}
+
+/**
+ * empathy_file_get_tp_file:
+ * @file: an #EmpathyFile
+ *
+ * Returns the #EmpathyTpFile associated to this file transfer.
+ *
+ * Returns: the associated #EmpathyTpFile
+ */
+EmpathyTpFile *
+empathy_file_get_tp_file (EmpathyFile *file)
+{
+  EmpathyFilePriv *priv;
+
+  g_return_val_if_fail (EMPATHY_IS_FILE (file), NULL);
+
+  priv = GET_PRIV (file);
+
+  return priv->tp_file;
+}
+
+/**
+ * empathy_file_get_contact:
+ * @file: an #EmpathyFile
+ *
+ * Returns the contact representing the other participant to the file
+ * transfer.
+ *
+ * Returns: the other contact participating to the file transfer
+ */
+EmpathyContact *
+empathy_file_get_contact (EmpathyFile *file)
+{
+  EmpathyFilePriv *priv;
+
+  g_return_val_if_fail (EMPATHY_IS_FILE (file), NULL);
+
+  priv = GET_PRIV (file);
+  return _empathy_tp_file_get_contact (priv->tp_file);
+}
+
+/**
+ * empathy_file_get_input_stream:
+ * @file: an #EmpathyFile
+ *
+ * Returns the #GInputStream from which to read the data to send.
+ *
+ * Returns: a #GInputStream
+ */
+GInputStream *
+empathy_file_get_input_stream (EmpathyFile *file)
+{
+  EmpathyFilePriv *priv;
+
+  g_return_val_if_fail (EMPATHY_IS_FILE (file), NULL);
+
+  priv = GET_PRIV (file);
+  return _empathy_tp_file_get_input_stream (priv->tp_file);
+}
+
+/**
+ * empathy_file_get_output_stream:
+ * @file: an #EmpathyFile
+ *
+ * Returns the #GOutputStream to which to write the received file.
+ *
+ * Returns: a #GOutputStream
+ */
+GOutputStream *
+empathy_file_get_output_stream (EmpathyFile *file)
+{
+  EmpathyFilePriv *priv;
+
+  g_return_val_if_fail (EMPATHY_IS_FILE (file), NULL);
+
+  priv = GET_PRIV (file);
+  return _empathy_tp_file_get_output_stream (priv->tp_file);
+}
+
+/**
+ * empathy_file_get_filename:
+ * @file: an #EmpathyFile
+ *
+ * Returns the UTF-8 encoded file's friendly name without path, for
+ * displaying it to the user.
+ *
+ * Returns: the file name
+ */
+const gchar *
+empathy_file_get_filename (EmpathyFile *file)
+{
+  EmpathyFilePriv *priv;
+
+  g_return_val_if_fail (EMPATHY_IS_FILE (file), NULL);
+
+  priv = GET_PRIV (file);
+  return _empathy_tp_file_get_filename (priv->tp_file);
+}
+
+/**
+ * empathy_file_get_direction:
+ * @file: an #EmpathyFile
+ *
+ * Returns the direction of the file transfer, i.e. whether the transfer is
+ * incoming or outgoing.
+ *
+ * Returns: the direction of the file transfer
+ */
+EmpFileTransferDirection
+empathy_file_get_direction (EmpathyFile *file)
+{
+  EmpathyFilePriv *priv;
+
+  g_return_val_if_fail (EMPATHY_IS_FILE (file), 0);
+
+  priv = GET_PRIV (file);
+  return _empathy_tp_file_get_direction (priv->tp_file);
+}
+
+/**
+ * empathy_file_get_state:
+ * @file: an #EmpathyFile
+ *
+ * Returns the file transfer current state.
+ *
+ * Returns: the file transfer state
+ */
+EmpFileTransferState
+empathy_file_get_state (EmpathyFile *file)
+{
+  EmpathyFilePriv *priv;
+
+  g_return_val_if_fail (EMPATHY_IS_FILE (file),
+            EMP_FILE_TRANSFER_STATE_CANCELED);
+
+  priv = GET_PRIV (file);
+  return _empathy_tp_file_get_state (priv->tp_file);
+}
+
+/**
+ * empathy_file_get_state_change_reason:
+ * @file: an #EmpathyFile
+ *
+ * Returns the reason of the last file transfer state change.
+ *
+ * Returns: why the file transfer changed state
+ */
+EmpFileTransferStateChangeReason
+empathy_file_get_state_change_reason (EmpathyFile *file)
+{
+  EmpathyFilePriv *priv;
+
+  g_return_val_if_fail (EMPATHY_IS_FILE (file),
+            EMP_FILE_TRANSFER_STATE_CHANGE_REASON_NONE);
+
+  priv = GET_PRIV (file);
+  return _empathy_tp_file_get_state_change_reason (priv->tp_file);
+}
+
+/**
+ * empathy_file_get_size:
+ * @file: an #EmpathyFile
+ *
+ * Returns the file size in bytes or #EMPATHY_FILE_UNKNOWN_SIZE if the size is
+ * not known.
+ *
+ * Returns: the file size in bytes or #EMPATHY_FILE_UNKNOWN_SIZE
+ */
+guint64
+empathy_file_get_size (EmpathyFile *file)
+{
+  EmpathyFilePriv *priv;
+
+  g_return_val_if_fail (EMPATHY_IS_FILE (file), EMPATHY_FILE_UNKNOWN_SIZE);
+
+  priv = GET_PRIV (file);
+  return _empathy_tp_file_get_size (priv->tp_file);
+}
+
+/**
+ * empathy_file_get_transferred_bytes:
+ * @file: an #EmpathyFile
+ *
+ * Returns the number of already transferred bytes.
+ *
+ * Returns: the number of transferred bytes
+ */
+guint64
+empathy_file_get_transferred_bytes (EmpathyFile *file)
+{
+  EmpathyFilePriv *priv;
+
+  g_return_val_if_fail (EMPATHY_IS_FILE (file), 0);
+
+  priv = GET_PRIV (file);
+  return _empathy_tp_file_get_transferred_bytes (priv->tp_file);
+}
+
+/**
+ * empathy_file_get_remaining_time:
+ * @file: an #EmpathyFile
+ *
+ * Returns the estimated number of remaining seconds before completing the
+ * file transfer, or -1 if it cannot be estimated.
+ *
+ * Returns: the estimated number of remaining seconds or -1
+ */
+gint
+empathy_file_get_remaining_time (EmpathyFile *file)
+{
+  EmpathyFilePriv *priv;
+
+  g_return_val_if_fail (EMPATHY_IS_FILE (file), -1);
+
+  priv = GET_PRIV (file);
+  return _empathy_tp_file_get_remaining_time (priv->tp_file);
+}
+
+static void
+file_set_tp_file (EmpathyFile   *file,
+        EmpathyTpFile *tp_file)
+{
+  EmpathyFilePriv *priv;
+
+  g_return_if_fail (EMPATHY_IS_FILE (file));
+  g_return_if_fail (EMPATHY_IS_TP_FILE (tp_file));
+
+  priv = GET_PRIV (file);
+
+  priv->tp_file = g_object_ref (tp_file);
+}
+
+/**
+ * empathy_file_set_input_stream:
+ * @file: an #EmpathyFile
+ * @in_stream: the #GInputStream
+ *
+ * Sets the #GInputStream from which to read the data to send.
+ */
+void
+empathy_file_set_input_stream (EmpathyFile    *file,
+           GInputStream *in_stream)
+{
+  EmpathyFilePriv *priv;
+
+  g_return_if_fail (EMPATHY_IS_FILE (file));
+
+  priv = GET_PRIV (file);
+
+  _empathy_tp_file_set_input_stream (priv->tp_file, in_stream);
+}
+
+/**
+ * empathy_file_set_output_stream:
+ * @file: an #EmpathyFile
+ * @out_stream: the #GOutputStream
+ *
+ * Sets the #GOutputStream to which to write the received file.
+ */
+void
+empathy_file_set_output_stream (EmpathyFile     *file,
+            GOutputStream *out_stream)
+{
+  EmpathyFilePriv *priv;
+
+  g_return_if_fail (EMPATHY_IS_FILE (file));
+
+  priv = GET_PRIV (file);
+
+  _empathy_tp_file_set_output_stream (priv->tp_file, out_stream);
+}
+
+/**
+ * empathy_file_set_filename:
+ * @file: an #EmpathyFile
+ * @filename: the file name
+ *
+ * Sets the UTF-8 encoded file's friendly name without path, for
+ * displaying it to the user.
+ */
+void
+empathy_file_set_filename (EmpathyFile   *file,
+       const gchar *filename)
+{
+  EmpathyFilePriv *priv;
+
+  g_return_if_fail (EMPATHY_IS_FILE (file));
+  g_return_if_fail (filename != NULL);
+
+  priv = GET_PRIV (file);
+
+  _empathy_tp_file_set_filename (priv->tp_file, filename);
+}
+
+/**
+ * empathy_file_accept:
+ * @file: an #EmpathyFile
+ *
+ * Accepts a file transfer that's in the "local pending" state (i.e.
+ * EMP_FILE_TRANSFER_STATE_LOCAL_PENDING).
+ */
+void
+empathy_file_accept (EmpathyFile *file)
+{
+  EmpathyFilePriv *priv;
+
+  g_return_if_fail (EMPATHY_IS_FILE (file));
+
+  priv = GET_PRIV (file);
+
+/*  _empathy_tp_file_accept (priv->tp_file);*/
+  if (priv) ;
+}