* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
-#include <telepathy-glib/telepathy-glib.h>
-#include <telepathy-glib/proxy-subclass.h>
-
-#include <libempathy/empathy-chatroom-manager.h>
-#include <libempathy/empathy-request-util.h>
-#include <libempathy/empathy-utils.h>
+#include "config.h"
+#include "empathy-chat-manager.h"
-#include <libempathy-gtk/empathy-ui-utils.h>
+#include <telepathy-glib/proxy-subclass.h>
+#include <telepathy-glib/telepathy-glib-dbus.h>
+#include "empathy-bus-names.h"
+#include "empathy-chatroom-manager.h"
#include "empathy-chat-window.h"
+#include "empathy-request-util.h"
+#include "empathy-ui-utils.h"
#define DEBUG_FLAG EMPATHY_DEBUG_OTHER
-#include <libempathy/empathy-debug.h>
+#include "empathy-debug.h"
-#include "empathy-chat-manager.h"
-
-#include <extensions/extensions.h>
+#define CHAT_MANAGER_PATH "/org/gnome/Empathy/ChatManager"
enum {
CLOSED_CHATS_CHANGED,
static guint signals[LAST_SIGNAL];
-static void svc_iface_init (gpointer, gpointer);
+static void chat_manager_iface_init (gpointer, gpointer);
G_DEFINE_TYPE_WITH_CODE (EmpathyChatManager, empathy_chat_manager,
- G_TYPE_OBJECT,
- G_IMPLEMENT_INTERFACE (EMP_TYPE_SVC_CHAT_MANAGER,
- svc_iface_init)
+ EMPATHY_GEN_TYPE_CHAT_MANAGER_SKELETON,
+ G_IMPLEMENT_INTERFACE (EMPATHY_GEN_TYPE_CHAT_MANAGER ,
+ chat_manager_iface_init)
)
/* private structure */
GHashTable *messages;
TpBaseClient *handler;
+
+ /* Cached to keep Folks in memory while empathy-chat is running; we don't
+ * want to reload it each time the last chat window is closed
+ * and re-opened. */
+ EmpathyIndividualManager *individual_mgr;
};
#define GET_PRIV(o) \
priv->num_displayed_chat);
}
+static void
+join_cb (GObject *source,
+ GAsyncResult *result,
+ gpointer user_data)
+{
+ TpChannel *channel = TP_CHANNEL (source);
+ GError *error = NULL;
+
+ if (!tp_channel_join_finish (channel, result, &error))
+ {
+ DEBUG ("Failed to join chat (%s): %s",
+ tp_channel_get_identifier (channel), error->message);
+ g_error_free (error);
+ }
+}
+
+static void
+individual_mgr_cb (EmpathyChatWindow *window,
+ GParamSpec *spec,
+ EmpathyChatManager *self)
+{
+ EmpathyChatManagerPriv *priv = GET_PRIV (self);
+
+ if (priv->individual_mgr != NULL)
+ return;
+
+ priv->individual_mgr = empathy_chat_window_get_individual_manager (window);
+ g_object_ref (priv->individual_mgr);
+}
+
static void
process_tp_chat (EmpathyChatManager *self,
EmpathyTpChat *tp_chat,
EmpathyChatManagerPriv *priv = GET_PRIV (self);
EmpathyChat *chat = NULL;
const gchar *id;
+ EmpathyChatWindow *window;
id = empathy_tp_chat_get_id (tp_chat);
if (!tp_str_empty (id))
g_object_weak_ref ((GObject *) chat, chat_destroyed_cb, self);
}
- empathy_chat_window_present_chat (chat, user_action_time);
+
+ window = empathy_chat_window_present_chat (chat, user_action_time);
+
+ if (priv->individual_mgr == NULL)
+ {
+ /* We want to cache it as soon it's created */
+ tp_g_signal_connect_object (window, "notify::individual-manager",
+ G_CALLBACK (individual_mgr_cb), self, 0);
+ }
if (empathy_tp_chat_is_invited (tp_chat, NULL))
{
/* We have been invited to the room. Add ourself as member as this
* channel has been approved. */
- empathy_tp_chat_join (tp_chat);
+ tp_channel_join_async (TP_CHANNEL (tp_chat), "", join_cb, self);
}
}
/* Text channels handler */
priv->handler = tp_simple_handler_new_with_am (am, FALSE, FALSE,
- EMPATHY_CHAT_BUS_NAME_SUFFIX, FALSE, handle_channels, self, NULL);
+ EMPATHY_CHAT_TP_BUS_NAME_SUFFIX, FALSE, handle_channels, self, NULL);
g_object_unref (am);
tp_clear_object (&priv->handler);
tp_clear_object (&priv->chatroom_mgr);
+ tp_clear_object (&priv->individual_mgr);
G_OBJECT_CLASS (empathy_chat_manager_parent_class)->finalize (object);
}
static void
empathy_chat_manager_constructed (GObject *obj)
{
- TpDBusDaemon *dbus_daemon;
-
- dbus_daemon = tp_dbus_daemon_dup (NULL);
+ GDBusConnection *conn;
+ GError *error = NULL;
- if (dbus_daemon != NULL)
+ conn = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error);
+ if (conn == NULL)
{
- tp_dbus_daemon_register_object (dbus_daemon,
- "/org/gnome/Empathy/ChatManager", obj);
+ DEBUG ("Failed to get bus: %s", error->message);
+ g_error_free (error);
+ return;
+ }
- g_object_unref (dbus_daemon);
+ if (!g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (obj), conn,
+ CHAT_MANAGER_PATH, &error))
+ {
+ DEBUG ("Failed to export chat manager: %s\n", error->message);
+ g_error_free (error);
}
+
+ g_object_unref (conn);
}
static void
if (data->room)
empathy_join_muc (data->account, data->id, timestamp);
else if (data->sms)
- empathy_sms_contact_id (data->account, data->id, timestamp);
+ empathy_sms_contact_id (data->account, data->id, timestamp,
+ NULL, NULL);
else
- empathy_chat_with_contact_id (data->account, data->id, timestamp);
+ empathy_chat_with_contact_id (data->account, data->id, timestamp,
+ NULL, NULL);
g_signal_emit (self, signals[CLOSED_CHATS_CHANGED], 0,
g_queue_get_length (priv->closed_queue));
return g_queue_get_length (priv->closed_queue);
}
-static void
-empathy_chat_manager_dbus_undo_closed_chat (EmpSvcChatManager *manager,
- gint64 timestamp,
- DBusGMethodInvocation *context)
+static gboolean
+empathy_chat_manager_dbus_undo_closed_chat (EmpathyGenChatManager *manager,
+ GDBusMethodInvocation *invocation,
+ gint64 timestamp)
{
empathy_chat_manager_undo_closed_chat ((EmpathyChatManager *) manager,
timestamp);
- emp_svc_chat_manager_return_from_undo_closed_chat (context);
+ empathy_gen_chat_manager_complete_undo_closed_chat (manager, invocation);
+ return TRUE;
}
static void
-svc_iface_init (gpointer g_iface,
+chat_manager_iface_init (gpointer g_iface,
gpointer iface_data)
{
- EmpSvcChatManagerClass *klass = (EmpSvcChatManagerClass *) g_iface;
+ EmpathyGenChatManagerIface *iface = (EmpathyGenChatManagerIface *) g_iface;
-#define IMPLEMENT(x) emp_svc_chat_manager_implement_##x (\
- klass, empathy_chat_manager_dbus_##x)
- IMPLEMENT(undo_closed_chat);
-#undef IMPLEMENT
+ iface->handle_undo_closed_chat = empathy_chat_manager_dbus_undo_closed_chat;
}
-void
-empathy_chat_manager_call_undo_closed_chat (void)
+static void
+undo_closed_cb (GObject *source,
+ GAsyncResult *result,
+ gpointer user_data)
{
- TpDBusDaemon *dbus_daemon = tp_dbus_daemon_dup (NULL);
- TpProxy *proxy;
+ GError *error = NULL;
- if (dbus_daemon == NULL)
- return;
+ if (!empathy_gen_chat_manager_call_undo_closed_chat_finish (
+ EMPATHY_GEN_CHAT_MANAGER (source), result,
+ &error))
+ {
+ DEBUG ("UndoClosedChat failed: %s", error->message);
+ g_error_free (error);
+ }
+}
- proxy = g_object_new (TP_TYPE_PROXY,
- "dbus-daemon", dbus_daemon,
- "dbus-connection", tp_proxy_get_dbus_connection (TP_PROXY (dbus_daemon)),
- "bus-name", EMPATHY_CHAT_BUS_NAME,
- "object-path", "/org/gnome/Empathy/ChatManager",
- NULL);
+static void
+chat_mgr_proxy_cb (GObject *source,
+ GAsyncResult *result,
+ gpointer user_data)
+{
+ EmpathyGenChatManager *proxy;
+ GError *error = NULL;
+ GVariant *action_time = user_data;
- tp_proxy_add_interface_by_id (proxy, EMP_IFACE_QUARK_CHAT_MANAGER);
+ proxy = empathy_gen_chat_manager_proxy_new_for_bus_finish (result, &error);
+ if (proxy == NULL)
+ {
+ DEBUG ("Failed to create ChatManager proxy: %s", error->message);
+ g_error_free (error);
+ goto finally;
+ }
- emp_cli_chat_manager_call_undo_closed_chat (proxy, -1, empathy_get_current_action_time (),
- NULL, NULL, NULL, NULL);
+ empathy_gen_chat_manager_call_undo_closed_chat (proxy,
+ g_variant_get_int64 (action_time), NULL, undo_closed_cb, NULL);
g_object_unref (proxy);
- g_object_unref (dbus_daemon);
+
+finally:
+ g_variant_unref (action_time);
+}
+
+void
+empathy_chat_manager_call_undo_closed_chat (void)
+{
+ gint64 action_time;
+
+ action_time = empathy_get_current_action_time ();
+
+ empathy_gen_chat_manager_proxy_new_for_bus (G_BUS_TYPE_SESSION,
+ G_DBUS_PROXY_FLAGS_NONE, EMPATHY_CHAT_BUS_NAME, CHAT_MANAGER_PATH,
+ NULL, chat_mgr_proxy_cb,
+ /* We can't use GINT_TO_POINTER as we won't be able to store a 64 bits
+ * integer on a 32 bits plateform. Use a GVariant for its convenient
+ * API. */
+ g_variant_new_int64 (action_time));
}
projects / empathy.git / blobdiff