/* tp-conn.c

 *

 * Copyright (C) 2005 Collabora Ltd.

 * 

 *

 * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

 *

 */

#include <string.h>

#include "tp-conn.h"

#include "tp-helpers.h"

#include "tp-connmgr.h"

#include "tp-props-iface.h"

#ifdef EMULATOR

#include "libtelepathy_wsd_solution.h"

#endif

#ifdef EMULATOR

	GET_STATIC_VAR_FROM_TLS(parent_class,tp_conn,GObjectClass *)

	#define parent_class (*GET_WSD_VAR_NAME(parent_class,tp_conn,s)())

	GET_STATIC_VAR_FROM_TLS(type1,tp_conn,GType)

	#define type1 (*GET_WSD_VAR_NAME(type1,tp_conn,s)())

	GET_STATIC_VAR_FROM_TLS(ret1,tp_conn,GQuark)

	#define ret1 (*GET_WSD_VAR_NAME(ret1,tp_conn,s)())

	GET_STATIC_VAR_FROM_TLS(ret2,tp_conn,GQuark)

	#define ret2 (*GET_WSD_VAR_NAME(ret2,tp_conn,s)())

	GET_STATIC_VAR_FROM_TLS(ret3,tp_conn,GQuark)

	#define ret3 (*GET_WSD_VAR_NAME(ret3,tp_conn,s)())

	GET_STATIC_VAR_FROM_TLS(ret4,tp_conn,GQuark)

	#define ret4 (*GET_WSD_VAR_NAME(ret4,tp_conn,s)())

	GET_STATIC_VAR_FROM_TLS(ret5,tp_conn,GQuark)

	#define ret5 (*GET_WSD_VAR_NAME(ret5,tp_conn,s)())

	GET_STATIC_VAR_FROM_TLS(ret6,tp_conn,GQuark)

	#define ret6 (*GET_WSD_VAR_NAME(ret6,tp_conn,s)())

	GET_STATIC_VAR_FROM_TLS(ret7,tp_conn,GQuark)

	#define ret7 (*GET_WSD_VAR_NAME(ret7,tp_conn,s)())

	GET_STATIC_VAR_FROM_TLS(ret8,tp_conn,GQuark)

	#define ret8 (*GET_WSD_VAR_NAME(ret8,tp_conn,s)())

	GET_STATIC_VAR_FROM_TLS(ret9,tp_conn,GQuark)

    #define ret9 (*GET_WSD_VAR_NAME(ret9,tp_conn,s)())

#else

	static GObjectClass *parent_class = NULL;

#endif

static gboolean tp_conn_status_change_handler(DBusGProxy *proxy, 

 					      guint status, guint reason, 

 					      gpointer user_data); 

static void _tp_conn_connect_req_handler(DBusGProxy *proxy,

                                        GError *error, gpointer user_data);

static void _tp_conn_register_signal_marshallers()

{

  /* Register marshaller for NewChannel signal */

  dbus_g_object_register_marshaller(tp_conn_signals_marshal_VOID__OBJECT_STRING_UINT_UINT_BOOLEAN, G_TYPE_NONE, DBUS_TYPE_G_OBJECT_PATH, G_TYPE_STRING, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_BOOLEAN, G_TYPE_INVALID);

  /* Register marshaller for StatusChanged signal */

  dbus_g_object_register_marshaller(tp_conn_signals_marshal_VOID__UINT_UINT, G_TYPE_NONE, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_INVALID);

}

static void _tp_conn_register_interface_signal_marshallers()

{

  /* Register marshaller for Aliasing interface signal AliasUpdate and

     ContactInfo interface signal GotContactInfo*/

  dbus_g_object_register_marshaller(tp_ifaces_signals_marshal_VOID__UINT_STRING, G_TYPE_NONE, G_TYPE_UINT, G_TYPE_STRING, G_TYPE_INVALID);

  /* Register marshaller for Forwarding interface signal ForwardingChanged */

  dbus_g_object_register_marshaller(tp_ifaces_signals_marshal_VOID__UINT, G_TYPE_NONE, G_TYPE_UINT, G_TYPE_INVALID);

  /* Register marshaller for Presence interface signal PresenceUpdate */

  dbus_g_object_register_marshaller(tp_ifaces_signals_marshal_VOID__BOXED, G_TYPE_NONE, G_TYPE_BOXED, G_TYPE_INVALID);

  /* Register marshaller for Privacy interface signal PrivacyModeChanged */

  dbus_g_object_register_marshaller(tp_ifaces_signals_marshal_VOID__STRING, G_TYPE_NONE, G_TYPE_STRING, G_TYPE_INVALID);

  /* Register marshaller for Renaming interface signal Renamed */

  dbus_g_object_register_marshaller(tp_ifaces_signals_marshal_VOID__UINT_UINT, G_TYPE_NONE, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_INVALID);

}

/* We initialize the list of signatures here, so that we can use

 * it to add them for new interface instances later.

 */

/* FIXME: This should be replaced by a more automatic way of doing

 * this. The reason for using a set of function pointers is that there is no

 * apparent cleaner way of doing this, unless DBusGProxy gains a non-varargs

 * version of dbus_g_proxy_add_signal...

 */

static void _tp_conn_init_interface_signal_signatures(GData **signal_sigs)

{

  g_datalist_init(signal_sigs);

  /* Create and store aliasing iface signal signatures */

  g_datalist_id_set_data(signal_sigs, TELEPATHY_CONN_IFACE_ALIASING_QUARK,

			 (gpointer)&tp_conn_set_aliasing_signatures);

  /* Create and store capabilities iface signal signatures */

  g_datalist_id_set_data(signal_sigs, TELEPATHY_CONN_IFACE_CAPABILITIES_QUARK,

			 (gpointer)&tp_conn_set_capabilities_signatures);

  /* Create and store contactinfo iface signal signatures */

  g_datalist_id_set_data(signal_sigs, TELEPATHY_CONN_IFACE_CONTACTINFO_QUARK,

			 (gpointer)&tp_conn_set_contactinfo_signatures);

  /* Create and store forwarding iface signal signatures */

  g_datalist_id_set_data(signal_sigs, TELEPATHY_CONN_IFACE_FORWARDING_QUARK,

			 (gpointer)&tp_conn_set_forwarding_signatures);

  /* Create and store presence iface signal signatures */

  g_datalist_id_set_data(signal_sigs, TELEPATHY_CONN_IFACE_PRESENCE_QUARK,

			 (gpointer)&tp_conn_set_presence_signatures);

  /* Create and store privacy iface signal signatures */

  g_datalist_id_set_data(signal_sigs, TELEPATHY_CONN_IFACE_PRIVACY_QUARK,

			 (gpointer)&tp_conn_set_privacy_signatures);

  /* Create and store renaming iface signal signatures */

  g_datalist_id_set_data(signal_sigs, TELEPATHY_CONN_IFACE_RENAMING_QUARK,

			 (gpointer)&tp_conn_set_renaming_signatures);

  g_datalist_id_set_data(signal_sigs, TELEPATHY_CONN_IFACE_AVATAR_QUARK,

               (gpointer)&tp_conn_set_avatar_signatures);

}

static void synthesize_status_changed(TpConn *conn);

static void tp_conn_init(GTypeInstance *instance, gpointer g_class)

{

  TpConn *self = TELEPATHY_CONN(instance);

  self->first_run = TRUE;

}

static void tp_conn_dispose(GObject *obj)

{

  TpConn *self = TELEPATHY_CONN(obj);

  if (self->first_run == TRUE)

  {

    self->first_run = FALSE;

    synthesize_status_changed(self);

    g_datalist_clear(&(self->interface_list));

  }

  /* Call parent class dispose method */

  if (G_OBJECT_CLASS(parent_class)->dispose)

  {

    G_OBJECT_CLASS(parent_class)->dispose(obj);

  }

}

static void tp_conn_finalize(GObject *obj)

{

  if (G_OBJECT_CLASS(parent_class)->finalize)

    {

      G_OBJECT_CLASS(parent_class)->finalize(obj);

    }

}

static void tp_conn_class_init(TpConnClass *klass)

{

  GObjectClass *obj = G_OBJECT_CLASS(klass);

  parent_class = g_type_class_peek_parent(klass);

  obj->set_property = parent_class->set_property;

  obj->get_property = parent_class->get_property;

  obj->dispose = tp_conn_dispose;

  obj->finalize = tp_conn_finalize;

  _tp_conn_register_signal_marshallers();

  _tp_conn_register_interface_signal_marshallers();

  _tp_conn_init_interface_signal_signatures(&(klass->iface_signal_sigs));

}

#ifdef SYMBIAN

EXPORT_C

#endif

GType tp_conn_get_type(void)

{

#ifndef EMULATOR

  static GType type1 = 0;

#endif

  if (type1 == 0)

    {

      static const GTypeInfo info = 

	{

	  sizeof(TpConnClass),

	  NULL,

	  NULL,

	  (GClassInitFunc)tp_conn_class_init,

	  NULL,

	  NULL,

	  sizeof(TpConn),

	  0,

	  (GInstanceInitFunc)tp_conn_init

	};

      type1 = g_type_register_static(DBUS_TYPE_G_PROXY,

				    "TpConn", &info, 0);

    }

  return type1;

}

/* The interface name getters */

GQuark tp_get_conn_interface()

{

#ifndef EMULATOR

  static GQuark ret1 = 0;

#endif

  if (ret1 == 0)

  {

    /* FIXME: The naming conventions should be unified */

    ret1 = g_quark_from_static_string(TP_IFACE_CONN_INTERFACE);

  }

  return ret1;

}

GQuark tp_get_conn_aliasing_interface()

{

#ifndef EMULATOR

  static GQuark ret2 = 0;

#endif

  if (ret2 == 0)

  {

    ret2 = g_quark_from_static_string(TP_IFACE_CONN_INTERFACE_ALIASING);

  }

  return ret2;

}

GQuark tp_get_conn_capabilities_interface()

{

#ifndef EMULATOR

  static GQuark ret3 = 0;

#endif

  if (ret3 == 0)

  {

    ret3 = g_quark_from_static_string(TP_IFACE_CONN_INTERFACE_CAPABILITIES);

  }

  return ret3;

}

GQuark tp_get_conn_contactinfo_interface()

{

#ifndef EMULATOR

  static GQuark ret4 = 0;

#endif

  if (ret4 == 0)

  {

    ret4 = g_quark_from_static_string(TP_IFACE_CONN_INTERFACE_CONTACT_INFO);

  }

  return ret4;

}

GQuark tp_get_conn_forwarding_interface()

{

#ifndef EMULATOR

  static GQuark ret5 = 0;

#endif

  if (ret5 == 0)

  {

    ret5 = g_quark_from_static_string(TP_IFACE_CONN_INTERFACE_FORWARDING);

  }

  return ret5;

}

#ifdef SYMBIAN

EXPORT_C

#endif

GQuark tp_get_conn_presence_interface()

{

#ifndef EMULATOR

  static GQuark ret6 = 0;

#endif

  if (ret6 == 0)

  {

    ret6 = g_quark_from_static_string(TP_IFACE_CONN_INTERFACE_PRESENCE);

  }

  return ret6;

}

GQuark tp_get_conn_privacy_interface()

{

#ifndef EMULATOR

  static GQuark ret7 = 0;

#endif

  if (ret7 == 0)

  {

    ret7 = g_quark_from_static_string(TP_IFACE_CONN_INTERFACE_PRIVACY);

  }

  return ret7;

}

GQuark tp_get_conn_renaming_interface()

{

#ifndef EMULATOR

  static GQuark ret8 = 0;

#endif

  if (ret8 == 0)

  {

    ret8 = g_quark_from_static_string(TP_IFACE_CONN_INTERFACE_RENAMING);

  }

  return ret8;

}

#ifdef SYMBIAN

EXPORT_C 

#endif

GQuark tp_get_conn_avatar_interface(void)

    {

#ifndef EMULATOR

  static GQuark ret9 = 0;

#endif

  if (ret9 == 0)

  {

    ret9 = g_quark_from_static_string(TP_IFACE_CONN_INTERFACE_AVATAR);

  }

  return ret9;    

    }

TpConn *

tp_conn_new_without_connect (DBusGConnection *connection,

                             const gchar *bus_name,

                             const gchar *object_path,

                             guint *status,

                             GError **error)

{

  gchar *unique_name;

  gchar **interfaces;

  guint conn_status = TP_CONN_STATUS_DISCONNECTED;

  TpConn *obj;

  GError *err = NULL;

  g_return_val_if_fail (connection != NULL, NULL);

  g_return_val_if_fail (bus_name != NULL, NULL);

  g_return_val_if_fail (object_path, NULL);

  /* Create the proxy object for this connection. It will be used to

     perform the actual method calls over D-BUS. */

  if (!dbus_g_proxy_call (tp_get_bus_proxy (), "GetNameOwner", error,

        G_TYPE_STRING, bus_name, G_TYPE_INVALID,

        G_TYPE_STRING, &unique_name, G_TYPE_INVALID))

    {

      return NULL;

    }

  obj = g_object_new (TELEPATHY_CONN_TYPE,

      "name", unique_name,

      "path", object_path,

      "interface", TP_IFACE_CONN_INTERFACE,//TP_IFACE_CONNECTION,

      "connection", connection,

      NULL);

  g_free (unique_name);

  g_datalist_init (&(obj->interface_list));

  //ADD_SIGNALS_FOR_CONNECTION (DBUS_G_PROXY (obj)); //commenting this bcoz header file not found 

  //equivalent of above stmt

  dbus_g_proxy_add_signal (DBUS_G_PROXY (obj), "NewChannel",\

    DBUS_TYPE_G_OBJECT_PATH,\

    G_TYPE_STRING,\

    G_TYPE_UINT,\

    G_TYPE_UINT,\

    G_TYPE_BOOLEAN,\

    G_TYPE_INVALID);\

  dbus_g_proxy_add_signal (DBUS_G_PROXY (obj), "StatusChanged",\

    G_TYPE_UINT,\

    G_TYPE_UINT,\

    G_TYPE_INVALID);

  /* Check if the connection is already connected. If so, we can

   * already perform GetInterfaces(). */

  if (!tp_conn_get_status (DBUS_G_PROXY (obj), &conn_status, &err))

    {

      if (err != NULL)

        g_propagate_error (error, err);

      g_object_unref (obj);

      return NULL;

    }

  if (conn_status == TP_CONN_STATUS_CONNECTED)

    {

      if (!tp_conn_get_interfaces (DBUS_G_PROXY (obj), &interfaces, &err))

        {

          if (err != NULL)

            g_propagate_error (error, err);

          g_object_unref (obj);

          return NULL;

        }

      /* Initialize the interface objects for this TpConn object */

      tp_conn_local_set_interfaces (obj, interfaces);

      g_strfreev (interfaces);

    }

  else

    {

      /* Not connected yet, so this is really a new connection. Thus, we

         have to hook up to StatusChanged signal to perform the

         GetInterfaces when it goes Connected */

      dbus_g_proxy_connect_signal (DBUS_G_PROXY (obj), "StatusChanged",

          G_CALLBACK (tp_conn_status_change_handler), NULL, NULL);

    }

  if (status != NULL)

    *status = conn_status;

  return obj;

}

TpConn *

tp_conn_new (DBusGConnection *connection,

             const gchar *bus_name,

             const gchar *object_path)

{

  GError *error = NULL;

  guint status;

  TpConn *obj;

  g_return_val_if_fail (connection != NULL, NULL);

  g_return_val_if_fail (bus_name != NULL, NULL);

  g_return_val_if_fail (object_path, NULL);

  obj = tp_conn_new_without_connect (connection, bus_name, object_path,

      &status, &error);

  if (obj == NULL)

    {

      /* either GetNameOwner, GetStatus or GetInterfaces failed */

      if (error != NULL)

        {

          g_warning ("Failed to create connection for %s %s: %s", bus_name,

              object_path, error->message);

          g_error_free (error);

        }

      else

        {

          g_warning ("Failed to create connection for %s %s: error is NULL",

              bus_name, object_path);

        }

      return NULL;

    }

  if (status != TP_CONN_STATUS_CONNECTED)

    {

      tp_conn_connect_async (DBUS_G_PROXY (obj), _tp_conn_connect_req_handler,

          NULL);

    }

  return obj;

}

#ifdef SYMBIAN

EXPORT_C

#endif

TpChan *tp_conn_new_channel(DBusGConnection *connection,

			    TpConn *tp_conn, const gchar *bus_name,

			    gchar *type, guint handle_type,

			    guint handle, gboolean supress_handler)

{

  GError *error = NULL;

  gchar *chan_object_path = NULL;

  TpChan *new_chan = NULL;

  g_return_val_if_fail(connection, NULL);

  g_return_val_if_fail(TELEPATHY_IS_CONN(tp_conn), NULL);

  g_return_val_if_fail(bus_name, NULL);

  g_return_val_if_fail(type, NULL);

  /* Request a new channel to be created by using the proxy object.

     We also retrieve the object path for it here. */

  if (!tp_conn_request_channel(DBUS_G_PROXY(tp_conn),

                               type, handle_type, handle, supress_handler,

                               &chan_object_path, &error))

  {