static void
account_manager_prepared_cb (GObject *source_object,
GAsyncResult *result,
gpointer user_data)
{
GList *accounts, *l;
TpAccountManager *manager = TP_ACCOUNT_MANAGER (source_object);
EmpathyAccountChooser *chooser = user_data;
EmpathyAccountChooserPriv *priv = GET_PRIV (chooser);
GError *error = NULL;
if (!tp_account_manager_prepare_finish (manager, result, &error)) {
DEBUG ("Failed to prepare account manager: %s", error->message);
g_error_free (error);
return;
}
accounts = tp_account_manager_get_valid_accounts (manager);
for (l = accounts; l != NULL; l = l->next) {
TpAccount *account = l->data;
account_chooser_account_add_foreach (account, chooser);
tp_g_signal_connect_object (account, "status-changed",
G_CALLBACK (account_chooser_status_changed_cb),
chooser, 0);
}
g_list_free (accounts);
priv->ready = TRUE;
g_signal_emit (chooser, signals[READY], 0);
}
static void
account_manager_prepared_cb (GObject *source_object,
GAsyncResult *result,
gpointer user_data)
{
TpAccountManager *account_manager = TP_ACCOUNT_MANAGER (source_object);
EmpathyLogWindow *window = user_data;
guint account_num;
GList *accounts;
GError *error = NULL;
if (log_window == NULL)
return;
if (!tp_account_manager_prepare_finish (account_manager, result, &error)) {
DEBUG ("Failed to prepare account manager: %s", error->message);
g_error_free (error);
return;
}
accounts = tp_account_manager_get_valid_accounts (account_manager);
account_num = g_list_length (accounts);
g_list_free (accounts);
if (account_num > 1) {
gtk_widget_show (window->vbox_chats);
gtk_widget_show (window->account_chooser_chats);
} else {
gtk_widget_hide (window->vbox_chats);
gtk_widget_hide (window->account_chooser_chats);
}
}
static void
am_prepare_cb (GObject *source,
GAsyncResult *result,
gpointer user_data)
{
EmpathyConnectionAggregator *self = EMPATHY_CONNECTION_AGGREGATOR (user_data);
GError *error = NULL;
GList *accounts, *l;
if (!tp_proxy_prepare_finish (source, result, &error))
{
DEBUG ("Failed to prepare account manager: %s", error->message);
g_error_free (error);
goto out;
}
accounts = tp_account_manager_get_valid_accounts (self->priv->mgr);
for (l = accounts; l != NULL; l = g_list_next (l))
{
TpAccount *account = l->data;
add_account (self, account);
}
tp_g_signal_connect_object (self->priv->mgr, "account-validity-changed",
G_CALLBACK (account_validity_changed_cb), self, 0);
g_list_free (accounts);
out:
g_object_unref (self);
}
static void
contact_blocking_dialog_am_prepared (GObject *am,
GAsyncResult *result,
gpointer user_data)
{
EmpathyContactBlockingDialog *self = user_data;
GList *accounts, *ptr;
GError *error = NULL;
if (!tp_proxy_prepare_finish (am, result, &error))
{
g_critical ("Could not prepare Account Manager: %s", error->message);
g_error_free (error);
return;
}
accounts = tp_account_manager_get_valid_accounts (TP_ACCOUNT_MANAGER (am));
for (ptr = accounts; ptr != NULL; ptr = ptr->next)
{
TpAccount *account = ptr->data;
tp_g_signal_connect_object (account, "status-changed",
G_CALLBACK (contact_blocking_dialog_connection_status_changed),
self, 0);
contact_blocking_dialog_refilter_account_chooser (self);
}
g_list_free (accounts);
}
static void
account_manager_prepared_cb (GObject *source_object,
GAsyncResult *result,
gpointer user_data)
{
GList *list, *l;
TpAccountManager *account_manager = TP_ACCOUNT_MANAGER (source_object);
EmpathyStatusIcon *icon = user_data;
GError *error = NULL;
if (!tp_account_manager_prepare_finish (account_manager, result, &error)) {
DEBUG ("Failed to prepare account manager: %s", error->message);
g_error_free (error);
return;
}
list = tp_account_manager_get_valid_accounts (account_manager);
for (l = list; l != NULL; l = l->next) {
tp_g_signal_connect_object (l->data, "status-changed",
G_CALLBACK (status_icon_status_changed_cb),
icon, 0);
}
g_list_free (list);
status_icon_presence_changed_cb (icon);
}
static void
account_manager_prepared_cb (GObject *source_object,
GAsyncResult *result,
gpointer user_data)
{
TpAccountManager *manager = TP_ACCOUNT_MANAGER (source_object);
EmpathyImportWidget *self = user_data;
GtkTreeModel *model;
GtkTreeIter iter;
GList *l;
EmpathyImportWidgetPriv *priv = GET_PRIV (self);
GError *error = NULL;
if (!tp_proxy_prepare_finish (manager, result, &error))
{
DEBUG ("Failed to prepare account manager: %s", error->message);
g_error_free (error);
return;
}
model = gtk_tree_view_get_model (GTK_TREE_VIEW (priv->treeview));
for (l = priv->accounts; l; l = l->next)
{
GValue *value;
EmpathyImportAccountData *data = l->data;
gboolean import;
GList *accounts;
TpConnectionManager *cm = NULL;
if (!empathy_import_protocol_is_supported (data->protocol, &cm))
continue;
data->connection_manager = g_strdup (
tp_connection_manager_get_name (cm));
value = g_hash_table_lookup (data->settings, "account");
accounts = tp_account_manager_get_valid_accounts (manager);
/* Only set the "Import" cell to be active if there isn't already an
* account set up with the same account id. */
import = !import_widget_account_id_in_list (accounts,
g_value_get_string (value));
g_list_free (accounts);
gtk_list_store_append (GTK_LIST_STORE (model), &iter);
gtk_list_store_set (GTK_LIST_STORE (model), &iter,
COL_IMPORT, import,
COL_PROTOCOL, data->protocol,
COL_NAME, g_value_get_string (value),
COL_SOURCE, data->source,
COL_ACCOUNT_DATA, data,
-1);
}
}
static EmpathyLogSearchHit *
log_store_empathy_search_hit_new (EmpathyLogStore *self,
const gchar *filename)
{
EmpathyLogStoreEmpathyPriv *priv = GET_PRIV (self);
EmpathyLogSearchHit *hit;
gchar *account_name;
const gchar *end;
gchar **strv;
guint len;
GList *accounts, *l;
if (!g_str_has_suffix (filename, LOG_FILENAME_SUFFIX))
return NULL;
strv = g_strsplit (filename, G_DIR_SEPARATOR_S, -1);
len = g_strv_length (strv);
hit = g_slice_new0 (EmpathyLogSearchHit);
end = strstr (strv[len-1], LOG_FILENAME_SUFFIX);
hit->date = g_strndup (strv[len-1], end - strv[len-1]);
hit->chat_id = g_strdup (strv[len-2]);
hit->is_chatroom = (strcmp (strv[len-3], LOG_DIR_CHATROOMS) == 0);
if (hit->is_chatroom)
account_name = strv[len-4];
else
account_name = strv[len-3];
/* FIXME: This assumes the account manager is prepared, but the
* synchronous API forces this. See bug #599189. */
accounts = tp_account_manager_get_valid_accounts (priv->account_manager);
for (l = accounts; l != NULL; l = g_list_next (l))
{
TpAccount *account = TP_ACCOUNT (l->data);
gchar *name;
name = log_store_account_to_dirname (account);
if (!tp_strdiff (name, account_name))
{
g_assert (hit->account == NULL);
hit->account = account;
g_object_ref (account);
}
g_object_unref (account);
g_free (name);
}
g_list_free (accounts);
hit->filename = g_strdup (filename);
g_strfreev (strv);
return hit;
}
static void
account_manager_chatroom_ready_cb (GObject *source_object,
GAsyncResult *result,
gpointer user_data)
{
TpAccountManager *account_manager = TP_ACCOUNT_MANAGER (source_object);
EmpathyChatroomManager *chatroom_manager = user_data;
GList *accounts, *l;
GError *error = NULL;
if (!tp_account_manager_prepare_finish (account_manager, result, &error))
{
DEBUG ("Failed to prepare account manager: %s", error->message);
g_error_free (error);
return;
}
accounts = tp_account_manager_get_valid_accounts (account_manager);
for (l = accounts; l != NULL; l = g_list_next (l))
{
TpAccount *account = TP_ACCOUNT (l->data);
TpConnection *conn;
GList *chatrooms, *p;
conn = tp_account_get_connection (account);
chatrooms = empathy_chatroom_manager_get_chatrooms (
chatroom_manager, account);
for (p = chatrooms; p != NULL; p = p->next)
{
EmpathyChatroom *room = EMPATHY_CHATROOM (p->data);
if (!empathy_chatroom_get_auto_connect (room))
continue;
if (conn == NULL)
{
g_signal_connect (G_OBJECT (account), "status-changed",
G_CALLBACK (account_status_changed_cb), room);
}
else
{
empathy_dispatcher_join_muc (conn,
empathy_chatroom_get_room (room), NULL, NULL);
}
}
g_list_free (chatrooms);
}
g_list_free (accounts);
}
static void
migration_account_manager_prepared_cb (GObject *source_object,
GAsyncResult *result,
gpointer user_data)
{
TpAccountManager *am = TP_ACCOUNT_MANAGER (source_object);
GError *error = NULL;
GList *accounts, *l;
GSettings *gsettings;
if (!tp_proxy_prepare_finish (am, result, &error))
{
DEBUG ("Failed to prepare the account manager: %s", error->message);
g_error_free (error);
return;
}
accounts = tp_account_manager_get_valid_accounts (am);
for (l = accounts; l != NULL; l = l->next)
{
TpAccount *account = TP_ACCOUNT (l->data);
gchar *dir, *cm;
tp_account_parse_object_path (tp_proxy_get_object_path (account),
&cm, NULL, NULL, NULL);
if (tp_strdiff (cm, "butterfly"))
{
g_free (cm);
continue;
}
dir = get_log_dir_for_account (account);
DEBUG ("Migrating all logs from dir: %s", dir);
migrate_log_files_in_dir (dir);
g_free (cm);
g_free (dir);
}
DEBUG ("Finished all migrating");
gsettings = g_settings_new (EMPATHY_PREFS_SCHEMA);
g_settings_set_boolean (gsettings, EMPATHY_PREFS_BUTTERFLY_LOGS_MIGRATED,
TRUE);
g_object_unref (gsettings);
g_list_free (accounts);
}
static void
main_window_account_removed_cb (TpAccountManager *manager,
TpAccount *account,
EmpathyMainWindow *window)
{
GList *a;
a = tp_account_manager_get_valid_accounts (manager);
gtk_action_set_sensitive (window->view_history,
g_list_length (a) > 0);
g_list_free (a);
/* remove errors if any */
main_window_remove_error (window, account);
}
static void
account_manager_ready_cb (GObject *source_object,
GAsyncResult *result,
gpointer user_data)
{
EmpathyIdle *idle = user_data;
TpAccountManager *account_manager = TP_ACCOUNT_MANAGER (source_object);
EmpathyIdlePriv *priv;
TpConnectionPresenceType state;
gchar *status, *status_message;
GList *accounts, *l;
GError *error = NULL;
/* In case we've been finalized before reading this callback */
if (idle_singleton == NULL)
return;
priv = GET_PRIV (idle);
priv->ready = TRUE;
if (!tp_account_manager_prepare_finish (account_manager, result, &error)) {
DEBUG ("Failed to prepare account manager: %s", error->message);
g_error_free (error);
return;
}
state = tp_account_manager_get_most_available_presence (priv->manager,
&status, &status_message);
idle_presence_changed_cb (account_manager, state, status,
status_message, idle);
accounts = tp_account_manager_get_valid_accounts (priv->manager);
for (l = accounts; l != NULL; l = l->next) {
empathy_signal_connect_weak (l->data, "status-changed",
G_CALLBACK (account_status_changed_cb),
G_OBJECT (idle));
}
g_list_free (accounts);
g_free (status);
g_free (status_message);
}
/* Salut account creation. The TpAccountManager first argument
* must already be prepared when calling this function. */
static gboolean
should_create_salut_account (TpAccountManager *manager)
{
gboolean salut_created = FALSE;
GList *accounts, *l;
/* Check if we already created a salut account */
empathy_conf_get_bool (empathy_conf_get (),
EMPATHY_PREFS_SALUT_ACCOUNT_CREATED,
&salut_created);
if (salut_created)
{
DEBUG ("Gconf says we already created a salut account once");
return FALSE;
}
accounts = tp_account_manager_get_valid_accounts (manager);
for (l = accounts; l != NULL; l = g_list_next (l))
{
TpAccount *account = TP_ACCOUNT (l->data);
if (!tp_strdiff (tp_account_get_protocol (account), "local-xmpp"))
{
salut_created = TRUE;
break;
}
}
g_list_free (accounts);
if (salut_created)
{
DEBUG ("Existing salut account already exists, flagging so in gconf");
empathy_conf_set_bool (empathy_conf_get (),
EMPATHY_PREFS_SALUT_ACCOUNT_CREATED,
TRUE);
}
return !salut_created;
}
static gboolean
has_non_salut_accounts (TpAccountManager *manager)
{
gboolean ret = FALSE;
GList *accounts, *l;
accounts = tp_account_manager_get_valid_accounts (manager);
for (l = accounts ; l != NULL; l = g_list_next (l))
{
if (tp_strdiff (tp_account_get_protocol (l->data), "local-xmpp"))
{
ret = TRUE;
break;
}
}
g_list_free (accounts);
return ret;
}
static void
account_manager_prepared_cb (GObject *source_object,
GAsyncResult *result,
gpointer user_data)
{
GList *accounts, *j;
TpAccountManager *manager = TP_ACCOUNT_MANAGER (source_object);
EmpathyMainWindow *window = user_data;
GError *error = NULL;
if (!tp_account_manager_prepare_finish (manager, result, &error)) {
DEBUG ("Failed to prepare account manager: %s", error->message);
g_error_free (error);
return;
}
accounts = tp_account_manager_get_valid_accounts (window->account_manager);
for (j = accounts; j != NULL; j = j->next) {
TpAccount *account = TP_ACCOUNT (j->data);
gulong handler_id;
handler_id = g_signal_connect (account, "status-changed",
G_CALLBACK (main_window_connection_changed_cb),
window);
g_hash_table_insert (window->status_changed_handlers,
account, GUINT_TO_POINTER (handler_id));
}
g_signal_connect (manager, "account-validity-changed",
G_CALLBACK (main_window_account_validity_changed_cb),
window);
main_window_update_status (window);
/* Disable the "Previous Conversations" menu entry if there is no account */
gtk_action_set_sensitive (window->view_history,
g_list_length (accounts) > 0);
g_list_free (accounts);
}
static void
_update_presence_chooser_state (MnbPeoplePanel *panel)
{
MnbPeoplePanelPrivate *priv = GET_PRIVATE (panel);
GList *accounts;
accounts = tp_account_manager_get_valid_accounts (priv->am);
if (accounts == NULL)
{
clutter_actor_hide (priv->presence_chooser);
} else {
if (sw_is_online ())
{
clutter_actor_show (priv->presence_chooser);
} else {
clutter_actor_hide (priv->presence_chooser);
}
}
g_list_free (accounts);
}
static void
am_prepared_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
MnbPeoplePanel *self= user_data;
MnbPeoplePanelPrivate *priv = GET_PRIVATE (self);
GList *accounts;
GError *error = NULL;
if (!tp_proxy_prepare_finish (object, result, &error))
{
g_warning ("Error preparing the TpAccountManager: %s", error->message);
g_clear_error (&error);
return;
}
g_signal_connect (priv->am,
"account-validity-changed",
(GCallback)_account_validity_changed_cb,
self);
g_signal_connect_swapped (priv->am,
"most-available-presence-changed",
(GCallback)_update_presence_message,
self);
accounts = tp_account_manager_get_valid_accounts (priv->am);
while (accounts != NULL)
{
tp_g_signal_connect_object (accounts->data, "status-changed",
G_CALLBACK (_account_status_changed_cb),
self, 0);
accounts = g_list_delete_link (accounts, accounts);
}
_update_placeholder_state (self);
_update_presence_chooser_state (self);
_update_presence_message (self);
}
gboolean
empathy_account_manager_get_accounts_connected (gboolean *connecting)
{
TpAccountManager *manager;
GList *accounts, *l;
gboolean out_connecting = FALSE;
gboolean out_connected = FALSE;
manager = tp_account_manager_dup ();
if (G_UNLIKELY (!tp_account_manager_is_prepared (manager,
TP_ACCOUNT_MANAGER_FEATURE_CORE)))
g_critical (G_STRLOC ": %s called before AccountManager ready", G_STRFUNC);
accounts = tp_account_manager_get_valid_accounts (manager);
for (l = accounts; l != NULL; l = l->next)
{
TpConnectionStatus s = tp_account_get_connection_status (
TP_ACCOUNT (l->data), NULL);
if (s == TP_CONNECTION_STATUS_CONNECTING)
out_connecting = TRUE;
else if (s == TP_CONNECTION_STATUS_CONNECTED)
out_connected = TRUE;
if (out_connecting && out_connected)
break;
}
g_list_free (accounts);
g_object_unref (manager);
if (connecting != NULL)
*connecting = out_connecting;
return out_connected;
}
static void
account_manager_prepared_cb (GObject *source_object,
GAsyncResult *result,
gpointer user_data)
{
GList *accounts, *l;
EmpathyContactManager *manager = user_data;
TpAccountManager *account_manager = TP_ACCOUNT_MANAGER (source_object);
GError *error = NULL;
if (!tp_account_manager_prepare_finish (account_manager, result, &error)) {
DEBUG ("Failed to prepare account manager: %s", error->message);
g_error_free (error);
return;
}
accounts = tp_account_manager_get_valid_accounts (account_manager);
for (l = accounts; l != NULL; l = l->next) {
TpAccount *account = l->data;
TpConnection *conn = tp_account_get_connection (account);
if (conn != NULL) {
contact_manager_status_changed_cb (account, 0, 0, 0,
NULL, NULL, manager);
}
tp_g_signal_connect_object (account, "status-changed",
G_CALLBACK (contact_manager_status_changed_cb),
manager, 0);
}
g_list_free (accounts);
tp_g_signal_connect_object (account_manager, "account-validity-changed",
G_CALLBACK (contact_manager_validity_changed_cb),
manager, 0);
}
bool TelepathyAccountHandler::startSession(PD_Document* pDoc, const std::vector<std::string>& vAcl, AbiCollab** pSession)
{
UT_DEBUGMSG(("TelepathyAccountHandler::startSession()\n"));
UT_return_val_if_fail(pDoc, false);
AbiCollabSessionManager* pManager = AbiCollabSessionManager::getManager();
UT_return_val_if_fail(pManager, false);
// generate a unique session id to use
UT_UTF8String sSessionId;
UT_UUID* pUUID = XAP_App::getApp()->getUUIDGenerator()->createUUID();
pUUID->toString(sSessionId);
DELETEP(pUUID);
// start the session already, while we'll continue to setup a
// MUC asynchronously below
// TODO: we should fill in the in the master buddy descriptor so we can do
// proper author coloring and session takeover; we can't do that however, since
// the following bugs needs to be fixed first:
//
// https://bugs.freedesktop.org/show_bug.cgi?id=37631
*pSession = pManager->startSession(pDoc, sSessionId, this, true, NULL, "");
// create a chatroom to hold the session information
TelepathyChatroomPtr pChatroom = boost::shared_ptr<TelepathyChatroom>(new TelepathyChatroom(this, NULL, pDoc, sSessionId));
m_chatrooms.push_back(pChatroom);
// add the buddies in the acl list to the room invitee list
/*
std::vector<TelepathyBuddyPtr> buddies = _getBuddies(vAcl);
gchar** invitee_ids = reinterpret_cast<gchar**>(malloc(sizeof(gchar*) * vAcl.size()+1));
int i = 0;
for (std::vector<TelepathyBuddyPtr>::iterator it = buddies.begin(); it != buddies.end(); it++)
{
UT_continue_if_fail(*it);
invitee_ids[i] = strdup(tp_contact_get_identifier((*it)->getContact()));
UT_DEBUGMSG(("Added %s to the invite list\n", invitee_ids[i]));
}
invitee_ids[vAcl.size()] = NULL;
*/
_inviteBuddies(pChatroom, vAcl); // use the above code when TP_PROP_CHANNEL_INTERFACE_CONFERENCE_INITIAL_INVITEE_IDS is usable
// a quick hack to determine the account to offer the request on
TpAccountManager* manager = tp_account_manager_dup();
UT_return_val_if_fail(manager, false);
GList* accounts = tp_account_manager_get_valid_accounts(manager);
UT_return_val_if_fail(accounts, false);
// TODO: make sure the accounts are ready
TpAccount* selected_account = NULL;
for (GList* account = accounts; account; account = account->next)
{
selected_account = TP_ACCOUNT(account->data);
break;
}
UT_return_val_if_fail(selected_account, false);
g_list_free(accounts);
// determine the room target id
std::string target_id = sSessionId.utf8_str();
std::string conference_server = getProperty("conference_server");
if (conference_server != "")
target_id += "@" + conference_server;
UT_DEBUGMSG(("Using room target ID: %s\n", target_id.c_str()));
// create a anonymous MUC channel request
GHashTable* props = tp_asv_new (
TP_PROP_CHANNEL_CHANNEL_TYPE, G_TYPE_STRING, TP_IFACE_CHANNEL_TYPE_DBUS_TUBE,
TP_PROP_CHANNEL_TARGET_HANDLE_TYPE, TP_TYPE_HANDLE, TP_HANDLE_TYPE_ROOM,
TP_PROP_CHANNEL_TARGET_ID, G_TYPE_STRING, target_id.c_str(),
TP_PROP_CHANNEL_TYPE_DBUS_TUBE_SERVICE_NAME, G_TYPE_STRING, INTERFACE,
/*
* Enable TP_PROP_CHANNEL_INTERFACE_CONFERENCE_INITIAL_INVITEE_IDS if you want to use
* anonymous MUCs. We can't use it right now, anonymous DBUS_TUBE MUCs are not implemented yet.
* Remove the HANDLE_TYPE and TARGET_ID when you enable this.
*
* See https://bugs.freedesktop.org/show_bug.cgi?id=37630 for details.
*
* TP_PROP_CHANNEL_INTERFACE_CONFERENCE_INITIAL_INVITEE_IDS, G_TYPE_STRV, invitee_ids,
*/
NULL);
TpAccountChannelRequest * channel_request = tp_account_channel_request_new(selected_account, props, TP_USER_ACTION_TIME_NOT_USER_ACTION);
UT_return_val_if_fail(channel_request, false);
g_hash_table_destroy (props);
// TODO: free invitee_ids
tp_account_channel_request_create_and_handle_channel_async(channel_request, NULL, muc_channel_ready_cb, pChatroom.get());
return true;
}
static void
_update_placeholder_state (MnbPeoplePanel *self)
{
MnbPeoplePanelPrivate *priv = GET_PRIVATE (self);
gint accounts_available = 0;
gint accounts_online = 0;
GList *accounts;
for (accounts = tp_account_manager_get_valid_accounts (priv->am);
accounts != NULL;
accounts = g_list_delete_link (accounts, accounts))
{
TpAccount *account = accounts->data;
if (!tp_account_is_enabled (account))
continue;
accounts_available++;
if (tp_account_get_connection_status (account, NULL) ==
TP_CONNECTION_STATUS_CONNECTED)
accounts_online++;
}
/* There is something in the model, hide all placeholders */
if (clutter_model_get_first_iter (CLUTTER_MODEL (priv->model)))
{
clutter_actor_hide (priv->no_people_tile);
clutter_actor_hide (priv->everybody_offline_tile);
/* Ensure content stuff is visible */
clutter_actor_show (priv->main_scroll_view);
if (accounts_available > 0 && accounts_online == 0)
{
clutter_actor_show (priv->offline_banner);
} else {
clutter_actor_hide (priv->offline_banner);
}
} else {
/* Hide real content stuff */
clutter_actor_hide (priv->main_scroll_view);
if (accounts_online == 0)
{
if (accounts_available == 0)
{
clutter_actor_show (priv->no_people_tile);
clutter_actor_hide (priv->everybody_offline_tile);
clutter_actor_hide (priv->offline_banner);
} else {
clutter_actor_show (priv->offline_banner);
clutter_actor_hide (priv->no_people_tile);
clutter_actor_hide (priv->everybody_offline_tile);
}
} else {
clutter_actor_show (priv->everybody_offline_tile);
clutter_actor_hide (priv->no_people_tile);
clutter_actor_hide (priv->offline_banner);
}
}
}
