static EmpathyContact *
contact_manager_lookup_contact (EmpathyContactManager *manager,
const gchar *account_name,
const gchar *contact_id)
{
EmpathyContact *retval = NULL;
GList *members, *l;
/* XXX: any more efficient way to do this (other than having to build
* and maintain a hash)? */
members = empathy_contact_list_get_members (
EMPATHY_CONTACT_LIST (manager));
for (l = members; l; l = l->next) {
EmpathyContact *contact = l->data;
TpAccount *account = empathy_contact_get_account (contact);
const gchar *id_cur;
const gchar *name_cur;
id_cur = empathy_contact_get_id (contact);
name_cur = tp_proxy_get_object_path (TP_PROXY (account));
if (!tp_strdiff (contact_id, id_cur) &&
!tp_strdiff (account_name, name_cur)) {
retval = contact;
}
g_object_unref (contact);
}
g_list_free (members);
return retval;
}
static gboolean
contact_manager_is_favourite (EmpathyContactList *manager,
EmpathyContact *contact)
{
EmpathyContactManagerPriv *priv;
TpAccount *account;
const gchar *account_name;
GHashTable *contact_hash;
g_return_val_if_fail (EMPATHY_IS_CONTACT_MANAGER (manager), FALSE);
g_return_val_if_fail (EMPATHY_IS_CONTACT (contact), FALSE);
priv = GET_PRIV (manager);
account = empathy_contact_get_account (contact);
account_name = tp_proxy_get_object_path (TP_PROXY (account));
contact_hash = g_hash_table_lookup (priv->favourites, account_name);
if (contact_hash != NULL) {
const gchar *contact_id = empathy_contact_get_id (contact);
if (g_hash_table_lookup (contact_hash, contact_id) != NULL)
return TRUE;
}
return FALSE;
}
static void
anerley_presence_chooser_init (AnerleyPresenceChooser *self)
{
MxComboBox *combo = MX_COMBO_BOX (self);
AnerleyPresenceChooserPrivate *priv = GET_PRIVATE (self);
priv->am = tp_account_manager_dup ();
g_signal_connect (priv->am,
"most-available-presence-changed",
G_CALLBACK (_account_manager_presence_changed),
self);
priv->combo_entries = g_array_sized_new (FALSE, TRUE, sizeof (ComboEntry), 7);
/* add some entries */
_append_presence (combo, TP_CONNECTION_PRESENCE_TYPE_AVAILABLE);
_append_presence (combo, TP_CONNECTION_PRESENCE_TYPE_BUSY);
_append_presence (combo, TP_CONNECTION_PRESENCE_TYPE_AWAY);
_append_presence (combo, TP_CONNECTION_PRESENCE_TYPE_OFFLINE);
/* FIXME: Hidden ? */
g_signal_connect (self,
"notify::index",
G_CALLBACK (_combo_index_changed),
NULL);
tp_proxy_prepare_async (TP_PROXY (priv->am),
NULL,
(GAsyncReadyCallback)_account_manager_ready,
self);
}
void
empathy_tls_certificate_reject_async (EmpathyTLSCertificate *self,
EmpTLSCertificateRejectReason reason,
GHashTable *details,
GAsyncReadyCallback callback,
gpointer user_data)
{
GPtrArray *rejections;
GSimpleAsyncResult *reject_result;
g_assert (EMPATHY_IS_TLS_CERTIFICATE (self));
DEBUG ("Rejecting TLS certificate with reason %u", reason);
rejections = build_rejections_array (reason, details);
reject_result = g_simple_async_result_new (G_OBJECT (self),
callback, user_data, empathy_tls_certificate_reject_async);
emp_cli_authentication_tls_certificate_call_reject (TP_PROXY (self),
-1, rejections, cert_proxy_reject_cb,
reject_result, g_object_unref, G_OBJECT (self));
tp_clear_boxed (EMP_ARRAY_TYPE_TLS_CERTIFICATE_REJECTION_LIST,
&rejections);
}
static void
_mcd_master_get_property (GObject * obj, guint prop_id,
GValue * val, GParamSpec * pspec)
{
McdMasterPrivate *priv = MCD_MASTER_PRIV (obj);
switch (prop_id)
{
case PROP_DISPATCHER:
g_value_set_object (val, priv->dispatcher);
break;
case PROP_DBUS_DAEMON:
g_value_set_object (val, priv->dbus_daemon);
break;
case PROP_DBUS_CONNECTION:
g_value_set_pointer (val,
TP_PROXY (priv->dbus_daemon)->dbus_connection);
break;
case PROP_ACCOUNT_MANAGER:
g_value_set_object (val, priv->account_manager);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, prop_id, pspec);
break;
}
}
static void
contact_manager_new_connection_cb (EmpathyAccountManager *account_manager,
TpConnection *connection,
EmpathyContactManager *self)
{
EmpathyContactManagerPriv *priv = GET_PRIV (self);
EmpathyTpContactList *list;
if (g_hash_table_lookup (priv->lists, connection)) {
return;
}
DEBUG ("Adding new connection: %s",
tp_proxy_get_object_path (TP_PROXY (connection)));
list = empathy_tp_contact_list_new (connection);
g_hash_table_insert (priv->lists, g_object_ref (connection), list);
g_signal_connect (connection, "invalidated",
G_CALLBACK (contact_manager_invalidated_cb),
self);
/* Connect signals */
g_signal_connect (list, "members-changed",
G_CALLBACK (contact_manager_members_changed_cb),
self);
g_signal_connect (list, "pendings-changed",
G_CALLBACK (contact_manager_pendings_changed_cb),
self);
g_signal_connect (list, "groups-changed",
G_CALLBACK (contact_manager_groups_changed_cb),
self);
}
void
empathy_account_request_presence (EmpathyAccount *account,
TpConnectionPresenceType type,
const gchar *status,
const gchar *message)
{
EmpathyAccountPriv *priv = GET_PRIV (account);
GValue value = {0, };
GValueArray *arr;
g_value_init (&value, TP_STRUCT_TYPE_SIMPLE_PRESENCE);
g_value_take_boxed (&value, dbus_g_type_specialized_construct
(TP_STRUCT_TYPE_SIMPLE_PRESENCE));
arr = (GValueArray *) g_value_get_boxed (&value);
g_value_set_uint (arr->values, type);
g_value_set_static_string (arr->values + 1, status);
g_value_set_static_string (arr->values + 2, message);
tp_cli_dbus_properties_call_set (TP_PROXY (priv->account),
-1,
TP_IFACE_ACCOUNT,
"RequestedPresence",
&value,
empathy_account_requested_presence_cb,
NULL,
NULL,
G_OBJECT (account));
g_value_unset (&value);
}
const gchar *
mcd_channel_get_object_path (McdChannel *channel)
{
McdChannelPrivate *priv = MCD_CHANNEL_PRIV (channel);
return priv->tp_chan ? TP_PROXY (priv->tp_chan)->object_path : NULL;
}
static gboolean
check_goa_object_match (AddAccountData *data,
GoaObject *goa_object)
{
GoaTelepathyProviderPrivate *priv = data->provider->priv;
GoaAccount *goa_account = NULL;
const gchar *provider_type = NULL;
const gchar *goa_id = NULL;
const gchar *tp_id = NULL;
if (data->tp_account == NULL)
{
/* Still waiting for the creation of the TpAccount */
return FALSE;
}
goa_account = goa_object_peek_account (goa_object);
provider_type = goa_account_get_provider_type (goa_account);
if (g_strcmp0 (provider_type, priv->provider_type) != 0)
return FALSE;
/* The backend-specific identity is set to the object path of the
* corresponding Telepathy account object. */
goa_id = goa_account_get_identity (goa_account);
tp_id = tp_proxy_get_object_path (TP_PROXY (data->tp_account));
if (g_strcmp0 (goa_id, tp_id) == 0)
{
/* Found it! */
data->ret = g_object_ref (goa_object);
g_main_loop_quit (data->loop);
return TRUE;
}
return FALSE;
}
static void
polari_room_set_channel (PolariRoom *room,
TpChannel *channel)
{
PolariRoomPrivate *priv;
g_return_if_fail (POLARI_IS_ROOM (room));
g_return_if_fail (channel == NULL || TP_IS_TEXT_CHANNEL (channel));
priv = room->priv;
if (priv->channel == channel)
return;
if (priv->channel)
{
g_signal_handler_disconnect (priv->channel, priv->identifier_notify_id);
g_signal_handler_disconnect (priv->channel, priv->group_contacts_changed_id);
tp_proxy_signal_connection_disconnect (priv->properties_changed_id);
g_clear_object (&priv->channel);
}
if (channel)
{
priv->channel = g_object_ref (channel);
if (priv->id == NULL)
priv->id = g_strdup (tp_proxy_get_object_path (TP_PROXY (channel)));
tp_cli_dbus_properties_call_get_all (channel, -1,
TP_IFACE_CHANNEL_INTERFACE_SUBJECT,
(tp_properties_get_all_cb)subject_get_all,
room, NULL, NULL);
priv->identifier_notify_id =
g_signal_connect (channel, "notify::identifier",
G_CALLBACK (on_identifier_notify), room);
priv->group_contacts_changed_id =
g_signal_connect (channel, "group-contacts-changed",
G_CALLBACK (on_group_contacts_changed), room);
priv->properties_changed_id =
tp_cli_dbus_properties_connect_to_properties_changed (
channel,
(tp_properties_changed_cb) properties_changed,
room, NULL, NULL, NULL);
}
g_object_freeze_notify (G_OBJECT (room));
update_identifier (room);
update_icon (room);
g_object_notify_by_pspec (G_OBJECT (room), props[PROP_CHANNEL]);
g_object_thaw_notify (G_OBJECT (room));
}
gboolean
empathy_proxy_equal (gconstpointer a,
gconstpointer b)
{
TpProxy *proxy_a = TP_PROXY (a);
TpProxy *proxy_b = TP_PROXY (b);
TpProxyClass *proxy_a_class = TP_PROXY_GET_CLASS (a);
TpProxyClass *proxy_b_class = TP_PROXY_GET_CLASS (b);
g_return_val_if_fail (TP_IS_PROXY (proxy_a), FALSE);
g_return_val_if_fail (TP_IS_PROXY (proxy_b), FALSE);
g_return_val_if_fail (proxy_a_class->must_have_unique_name, 0);
g_return_val_if_fail (proxy_b_class->must_have_unique_name, 0);
return g_str_equal (proxy_a->object_path, proxy_b->object_path) &&
g_str_equal (proxy_a->bus_name, proxy_b->bus_name);
}
guint
empathy_proxy_hash (gconstpointer key)
{
TpProxy *proxy = TP_PROXY (key);
TpProxyClass *proxy_class = TP_PROXY_GET_CLASS (key);
g_return_val_if_fail (TP_IS_PROXY (proxy), 0);
g_return_val_if_fail (proxy_class->must_have_unique_name, 0);
return g_str_hash (proxy->object_path) ^ g_str_hash (proxy->bus_name);
}
static void
changed_accounts (TpConnectionPresenceType type)
{
TpAccountManager *am;
am = tp_account_manager_dup ();
tp_proxy_prepare_async (TP_PROXY (am),
NULL,
(GAsyncReadyCallback)_account_manager_ready_cb,
GINT_TO_POINTER (type));
g_object_unref (am);
}
void
empathy_tp_contact_factory_set_avatar (EmpathyTpContactFactory *tp_factory,
const gchar *data,
gsize size,
const gchar *mime_type)
{
EmpathyTpContactFactoryPriv *priv = GET_PRIV (tp_factory);
g_return_if_fail (EMPATHY_IS_TP_CONTACT_FACTORY (tp_factory));
if (data && size > 0 && size < G_MAXUINT) {
GArray avatar;
avatar.data = (gchar *) data;
avatar.len = size;
DEBUG ("Setting avatar on connection %s",
tp_proxy_get_object_path (TP_PROXY (priv->connection)));
tp_cli_connection_interface_avatars_call_set_avatar (priv->connection,
-1,
&avatar,
mime_type,
tp_contact_factory_set_avatar_cb,
NULL, NULL,
G_OBJECT (tp_factory));
} else {
DEBUG ("Clearing avatar on connection %s",
tp_proxy_get_object_path (TP_PROXY (priv->connection)));
tp_cli_connection_interface_avatars_call_clear_avatar (priv->connection,
-1,
tp_contact_factory_clear_avatar_cb,
NULL, NULL,
G_OBJECT (tp_factory));
}
}
/**
* mcd_channel_get_error:
* @channel: the #McdChannel.
*
* Returns: the #GError, or %NULL if no error is set.
*/
const GError *
mcd_channel_get_error (McdChannel *channel)
{
McdChannelPrivate *priv;
g_return_val_if_fail (MCD_IS_CHANNEL (channel), NULL);
priv = channel->priv;
if (priv->error)
return priv->error;
if (priv->tp_chan)
return TP_PROXY (priv->tp_chan)->invalidated;
return NULL;
}
void hev_impathy_tls_certificate_accept_async(HevImpathyTLSCertificate *self,
GAsyncReadyCallback callback, gpointer user_data)
{
GSimpleAsyncResult *accept_result = NULL;
g_debug("%s:%d[%s]", __FILE__, __LINE__, __FUNCTION__);
g_return_if_fail(HEV_IS_IMPATHY_TLS_CERTIFICATE(self));
accept_result = g_simple_async_result_new(G_OBJECT(self),
callback, user_data,
hev_impathy_tls_certificate_accept_async);
hev_cli_authentication_tls_certificate_call_accept(TP_PROXY(self),
-1, cert_proxy_accept_handler, accept_result,
g_object_unref, G_OBJECT(self));
}
void
empathy_account_set_enabled_async (EmpathyAccount *account,
gboolean enabled,
GAsyncReadyCallback callback,
gpointer user_data)
{
EmpathyAccountPriv *priv = GET_PRIV (account);
EmpathyAccountManager *acc_manager;
GValue value = {0, };
GSimpleAsyncResult *result = g_simple_async_result_new (G_OBJECT (account),
callback, user_data, empathy_account_set_enabled_finish);
char *status = NULL;
char *status_message = NULL;
TpConnectionPresenceType presence;
if (priv->enabled == enabled)
{
g_simple_async_result_complete_in_idle (result);
return;
}
if (enabled)
{
acc_manager = empathy_account_manager_dup_singleton ();
presence = empathy_account_manager_get_requested_global_presence
(acc_manager, &status, &status_message);
if (presence != TP_CONNECTION_PRESENCE_TYPE_UNSET)
empathy_account_request_presence (account, presence, status,
status_message);
g_object_unref (acc_manager);
g_free (status);
g_free (status_message);
}
g_value_init (&value, G_TYPE_BOOLEAN);
g_value_set_boolean (&value, enabled);
tp_cli_dbus_properties_call_set (TP_PROXY (priv->account),
-1, TP_IFACE_ACCOUNT, "Enabled", &value,
account_enabled_set_cb, result, NULL, G_OBJECT (account));
}
void
empathy_tls_certificate_accept_async (EmpathyTLSCertificate *self,
GAsyncReadyCallback callback,
gpointer user_data)
{
GSimpleAsyncResult *accept_result;
g_assert (EMPATHY_IS_TLS_CERTIFICATE (self));
DEBUG ("Accepting TLS certificate");
accept_result = g_simple_async_result_new (G_OBJECT (self),
callback, user_data, empathy_tls_certificate_accept_async);
emp_cli_authentication_tls_certificate_call_accept (TP_PROXY (self),
-1, cert_proxy_accept_cb,
accept_result, g_object_unref,
G_OBJECT (self));
}
static void
contact_manager_status_changed_cb (TpAccount *account,
guint old_status,
guint new_status,
guint reason,
gchar *dbus_error_name,
GHashTable *details,
EmpathyContactManager *self)
{
EmpathyContactManagerPriv *priv = GET_PRIV (self);
EmpathyTpContactList *list;
TpConnection *connection;
if (new_status == TP_CONNECTION_STATUS_DISCONNECTED)
/* No point to start tracking a connection which is about to die */
return;
connection = tp_account_get_connection (account);
if (connection == NULL || g_hash_table_lookup (priv->lists, connection)) {
return;
}
DEBUG ("Adding new connection: %s",
tp_proxy_get_object_path (TP_PROXY (connection)));
list = empathy_tp_contact_list_new (connection);
g_hash_table_insert (priv->lists, g_object_ref (connection), list);
g_signal_connect (connection, "invalidated",
G_CALLBACK (contact_manager_invalidated_cb),
self);
/* Connect signals */
g_signal_connect (list, "members-changed",
G_CALLBACK (contact_manager_members_changed_cb),
self);
g_signal_connect (list, "pendings-changed",
G_CALLBACK (contact_manager_pendings_changed_cb),
self);
g_signal_connect (list, "groups-changed",
G_CALLBACK (contact_manager_groups_changed_cb),
self);
}
static void
contact_manager_invalidated_cb (TpProxy *connection,
guint domain,
gint code,
gchar *message,
EmpathyContactManager *manager)
{
EmpathyContactManagerPriv *priv = GET_PRIV (manager);
EmpathyTpContactList *list;
DEBUG ("Removing connection: %s (%s)",
tp_proxy_get_object_path (TP_PROXY (connection)),
message);
list = g_hash_table_lookup (priv->lists, connection);
if (list) {
empathy_tp_contact_list_remove_all (list);
g_hash_table_remove (priv->lists, connection);
}
}
static void
_account_manager_ready_cb (TpAccountManager *am,
GAsyncResult *res,
gpointer userdata)
{
TpConnectionPresenceType type = (TpConnectionPresenceType)GPOINTER_TO_INT (userdata);
GError *error = NULL;
if (!tp_proxy_prepare_finish (TP_PROXY (am), res, &error))
{
g_warning (G_STRLOC ": Error preparing account manager: %s",
error->message);
g_error_free (error);
return;
}
tp_account_manager_set_all_requested_presences (am,
type,
NULL,
NULL);
}
static GObject *
tp_tube_constructor (GType type,
guint n_props,
GObjectConstructParam *props)
{
GObject *self;
EmpathyTpTubePriv *priv;
self = G_OBJECT_CLASS (empathy_tp_tube_parent_class)->constructor (
type, n_props, props);
priv = GET_PRIV (self);
g_signal_connect (priv->channel, "invalidated",
G_CALLBACK (tp_tube_invalidated_cb), self);
emp_cli_channel_interface_tube_connect_to_tube_channel_state_changed (
TP_PROXY (priv->channel), tp_tube_state_changed_cb, NULL, NULL,
self, NULL);
return self;
}
static void
update_icon (PolariRoom *room)
{
PolariRoomPrivate *priv = room->priv;
g_clear_object (&priv->icon);
if (priv->channel)
{
const char *icon_name;
gboolean is_private;
is_private = !tp_proxy_has_interface_by_id (TP_PROXY (priv->channel),
TP_IFACE_QUARK_CHANNEL_INTERFACE_GROUP);
icon_name = is_private ? "avatar-default-symbolic"
: "user-available-symbolic";
priv->icon = g_themed_icon_new (icon_name);
}
g_object_notify_by_pspec (G_OBJECT (room), props[PROP_ICON]);
}
static void
contact_manager_remove_favourite (EmpathyContactList *manager,
EmpathyContact *contact)
{
EmpathyContactManagerPriv *priv;
TpAccount *account;
const gchar *account_name;
g_return_if_fail (EMPATHY_IS_CONTACT_MANAGER (manager));
g_return_if_fail (EMPATHY_IS_CONTACT (contact));
priv = GET_PRIV (manager);
account = empathy_contact_get_account (contact);
account_name = tp_proxy_get_object_path (TP_PROXY (account));
emp_cli_logger_call_remove_favourite_contact (priv->logger, -1,
account_name,
empathy_contact_get_id (contact),
remove_favourite_contact_cb, NULL, NULL, G_OBJECT (manager));
}
static GObject *
mcd_master_constructor (GType type, guint n_params,
GObjectConstructParam *params)
{
GObjectClass *object_class = (GObjectClass *)mcd_master_parent_class;
McdMaster *master;
McdMasterPrivate *priv;
master = MCD_MASTER (object_class->constructor (type, n_params, params));
priv = MCD_MASTER_PRIV (master);
g_return_val_if_fail (master != NULL, NULL);
#ifdef HAVE_UMASK
/* mask out group and other rwx bits when creating files */
umask (0077);
#endif
if (!priv->account_manager)
priv->account_manager = mcd_account_manager_new (priv->dbus_daemon);
priv->dispatcher = mcd_dispatcher_new (priv->dbus_daemon, master);
g_assert (MCD_IS_DISPATCHER (priv->dispatcher));
_mcd_account_manager_setup (priv->account_manager);
dbus_connection_set_exit_on_disconnect (
dbus_g_connection_get_connection (
TP_PROXY (priv->dbus_daemon)->dbus_connection),
TRUE);
mcd_kludge_transport_install (master);
/* we assume that at this point all transport plugins have been registered.
* We get the active transports and check whether some accounts should be
* automatically connected */
mcd_master_connect_automatic_accounts (master);
return (GObject *) master;
}
static void
_account_manager_ready (TpAccountManager *am,
GAsyncResult *res,
gpointer user_data)
{
AnerleyPresenceChooser *self = user_data;
AnerleyPresenceChooserPrivate *priv = GET_PRIVATE (self);
GError *error = NULL;
if (!tp_proxy_prepare_finish (TP_PROXY (am), res, &error))
{
g_warning (G_STRLOC ": Error preparing account manager: %s",
error->message);
g_error_free (error);
return;
}
priv->presence = tp_account_manager_get_most_available_presence (priv->am,
NULL,
NULL);
update_combox_index (self);
}
void
polari_room_remove_member (PolariRoom *room,
TpContact *member)
{
TpChannel *channel;
g_return_if_fail (POLARI_IS_ROOM (room));
channel = room->priv->channel;
if (!tp_proxy_has_interface_by_id (TP_PROXY (channel),
TP_IFACE_QUARK_CHANNEL_INTERFACE_GROUP))
return;
{
TpHandle handle = tp_contact_get_handle (member);
GArray handles = { (char *)&handle, 1 };
tp_cli_channel_interface_group_call_remove_members (channel,
-1, &handles, NULL, NULL, NULL, NULL, NULL);
}
}
void hev_impathy_tls_certificate_reject_async(HevImpathyTLSCertificate *self,
TpTLSCertificateRejectReason reason, GHashTable *details,
GAsyncReadyCallback callback, gpointer user_data)
{
GPtrArray *rejections = NULL;
GSimpleAsyncResult *reject_result = NULL;
g_debug("%s:%d[%s]", __FILE__, __LINE__, __FUNCTION__);
g_return_if_fail(HEV_IS_IMPATHY_TLS_CERTIFICATE(self));
rejections = build_rejections_array(reason, details);
reject_result = g_simple_async_result_new(G_OBJECT(self),
callback, user_data,
hev_impathy_tls_certificate_reject_async);
hev_cli_authentication_tls_certificate_call_reject(TP_PROXY(self),
-1, rejections, cert_proxy_reject_handler,
reject_result, g_object_unref, G_OBJECT(self));
tp_clear_boxed(TP_ARRAY_TYPE_TLS_CERTIFICATE_REJECTION_LIST,
&rejections);
}
void
empathy_tp_tube_accept_stream_tube (EmpathyTpTube *tube,
TpSocketAddressType type, EmpatyTpTubeAcceptStreamTubeCb *callback,
gpointer user_data)
{
EmpathyTpTubePriv *priv = GET_PRIV (tube);
GValue *control_param;
EmpathyTpTubeAcceptData *data;
g_return_if_fail (EMPATHY_IS_TP_TUBE (tube));
DEBUG ("Accepting stream tube");
/* FIXME allow other acls */
control_param = tp_g_value_slice_new (G_TYPE_STRING);
data = new_empathy_tp_tube_accept_data (type, callback, user_data);
emp_cli_channel_type_stream_tube_call_accept_stream_tube (
TP_PROXY (priv->channel), -1, type, TP_SOCKET_ACCESS_CONTROL_LOCALHOST,
control_param, tp_tube_accept_stream_cb, data,
free_empathy_tp_tube_accept_data, G_OBJECT (tube));
tp_g_value_slice_free (control_param);
}
void
empathy_chat_manager_call_undo_closed_chat (void)
{
TpDBusDaemon *dbus_daemon = tp_dbus_daemon_dup (NULL);
TpProxy *proxy;
if (dbus_daemon == NULL)
return;
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);
tp_proxy_add_interface_by_id (proxy, EMP_IFACE_QUARK_CHAT_MANAGER);
emp_cli_chat_manager_call_undo_closed_chat (proxy, -1, empathy_get_current_action_time (),
NULL, NULL, NULL, NULL);
g_object_unref (proxy);
g_object_unref (dbus_daemon);
}
