static void
account_manager_ready_cb (GObject *source_object,
GAsyncResult *result,
gpointer user_data)
{
TpAccountManager *manager = TP_ACCOUNT_MANAGER (source_object);
GError *error = NULL;
EmpathyIdle *idle;
EmpathyConnectivity *connectivity;
gboolean autoconnect = TRUE;
if (!tp_account_manager_prepare_finish (manager, result, &error))
{
DEBUG ("Failed to prepare account manager: %s", error->message);
g_error_free (error);
return;
}
/* Autoconnect */
idle = empathy_idle_dup_singleton ();
connectivity = empathy_connectivity_dup_singleton ();
empathy_conf_get_bool (empathy_conf_get (),
EMPATHY_PREFS_AUTOCONNECT, &autoconnect);
if (autoconnect && !no_connect &&
tp_connection_presence_type_cmp_availability
(empathy_idle_get_state (idle), TP_CONNECTION_PRESENCE_TYPE_OFFLINE)
<= 0)
/* if current state is Offline, then put it online */
empathy_idle_set_state (idle, TP_CONNECTION_PRESENCE_TYPE_AVAILABLE);
if (should_create_salut_account (manager)
|| !empathy_import_mc4_has_imported ())
{
EmpathyConnectionManagers *managers;
managers = empathy_connection_managers_dup_singleton ();
if (!check_connection_managers_ready (managers))
{
g_signal_connect (managers, "notify::ready",
G_CALLBACK (connection_managers_ready_cb), NULL);
}
}
else if (!start_hidden)
{
maybe_show_account_assistant ();
}
g_object_unref (idle);
g_object_unref (connectivity);
}
static void
empathy_presence_manager_init (EmpathyPresenceManager *self)
{
TpDBusDaemon *dbus;
self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
EMPATHY_TYPE_PRESENCE_MANAGER, EmpathyPresenceManagerPrivate);
self->priv->is_idle = FALSE;
self->priv->manager = tp_account_manager_dup ();
tp_account_manager_prepare_async (self->priv->manager, NULL,
account_manager_ready_cb, self);
tp_g_signal_connect_object (self->priv->manager,
"most-available-presence-changed",
G_CALLBACK (most_available_presence_changed), self, 0);
dbus = tp_dbus_daemon_dup (NULL);
self->priv->gs_proxy = dbus_g_proxy_new_for_name (
tp_proxy_get_dbus_connection (dbus),
"org.gnome.SessionManager",
"/org/gnome/SessionManager/Presence",
"org.gnome.SessionManager.Presence");
if (self->priv->gs_proxy)
{
dbus_g_proxy_add_signal (self->priv->gs_proxy, "StatusChanged",
G_TYPE_UINT, G_TYPE_INVALID);
dbus_g_proxy_connect_signal (self->priv->gs_proxy, "StatusChanged",
G_CALLBACK (session_status_changed_cb),
self, NULL);
}
else
{
DEBUG ("Failed to get gs proxy");
}
g_object_unref (dbus);
self->priv->connectivity = empathy_connectivity_dup_singleton ();
tp_g_signal_connect_object (self->priv->connectivity,
"state-change", G_CALLBACK (state_change_cb), self, 0);
self->priv->connect_times = g_hash_table_new (g_direct_hash, g_direct_equal);
}
static void
empathy_idle_init (EmpathyIdle *idle)
{
EmpathyIdlePriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (idle,
EMPATHY_TYPE_IDLE, EmpathyIdlePriv);
TpDBusDaemon *dbus;
idle->priv = priv;
priv->is_idle = FALSE;
priv->manager = tp_account_manager_dup ();
tp_account_manager_prepare_async (priv->manager, NULL,
account_manager_ready_cb, idle);
priv->idle_presence_changed_id = g_signal_connect (priv->manager,
"most-available-presence-changed",
G_CALLBACK (idle_presence_changed_cb), idle);
dbus = tp_dbus_daemon_dup (NULL);
priv->gs_proxy = dbus_g_proxy_new_for_name (
tp_proxy_get_dbus_connection (dbus),
"org.gnome.SessionManager",
"/org/gnome/SessionManager/Presence",
"org.gnome.SessionManager.Presence");
if (priv->gs_proxy) {
dbus_g_proxy_add_signal (priv->gs_proxy, "StatusChanged",
G_TYPE_UINT, G_TYPE_INVALID);
dbus_g_proxy_connect_signal (priv->gs_proxy, "StatusChanged",
G_CALLBACK (idle_session_status_changed_cb),
idle, NULL);
} else {
DEBUG ("Failed to get gs proxy");
}
g_object_unref (dbus);
priv->connectivity = empathy_connectivity_dup_singleton ();
priv->state_change_signal_id = g_signal_connect (priv->connectivity,
"state-change", G_CALLBACK (idle_state_change_cb), idle);
priv->connect_times = g_hash_table_new (g_direct_hash, g_direct_equal);
}
static void
empathy_idle_init (EmpathyIdle *idle)
{
EmpathyIdlePriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (idle,
EMPATHY_TYPE_IDLE, EmpathyIdlePriv);
idle->priv = priv;
priv->is_idle = FALSE;
priv->manager = empathy_account_manager_dup_singleton ();
if (empathy_account_manager_is_ready (priv->manager)) {
priv->state = empathy_account_manager_get_global_presence (priv->manager,
NULL, &priv->status);
} else {
g_signal_connect (priv->manager, "notify::ready",
G_CALLBACK (account_manager_ready_cb), idle);
}
g_signal_connect (priv->manager, "global-presence-changed",
G_CALLBACK (idle_presence_changed_cb), idle);
priv->gs_proxy = dbus_g_proxy_new_for_name (tp_get_bus (),
"org.gnome.SessionManager",
"/org/gnome/SessionManager/Presence",
"org.gnome.SessionManager.Presence");
if (priv->gs_proxy) {
dbus_g_proxy_add_signal (priv->gs_proxy, "StatusChanged",
G_TYPE_UINT, G_TYPE_INVALID);
dbus_g_proxy_connect_signal (priv->gs_proxy, "StatusChanged",
G_CALLBACK (idle_session_status_changed_cb),
idle, NULL);
} else {
DEBUG ("Failed to get gs proxy");
}
priv->connectivity = empathy_connectivity_dup_singleton ();
priv->state_change_signal_id = g_signal_connect (priv->connectivity,
"state-change", G_CALLBACK (idle_state_change_cb), idle);
}
int
main (int argc, char *argv[])
{
#if HAVE_GEOCLUE
EmpathyLocationManager *location_manager = NULL;
#endif
EmpathyStatusIcon *icon;
EmpathyDispatcher *dispatcher;
TpAccountManager *account_manager;
EmpathyLogManager *log_manager;
EmpathyChatroomManager *chatroom_manager;
EmpathyCallFactory *call_factory;
EmpathyFTFactory *ft_factory;
GtkWidget *window;
EmpathyIdle *idle;
EmpathyConnectivity *connectivity;
GError *error = NULL;
TpDBusDaemon *dbus_daemon;
UniqueApp *unique_app;
gboolean chatroom_manager_ready;
GOptionContext *optcontext;
GOptionEntry options[] = {
{ "no-connect", 'n',
0, G_OPTION_ARG_NONE, &no_connect,
N_("Don't connect on startup"),
NULL },
{ "start-hidden", 'h',
0, G_OPTION_ARG_NONE, &start_hidden,
N_("Don't display the contact list or any other dialogs on startup"),
NULL },
{ "accounts", 'a',
0, G_OPTION_ARG_NONE, &account_dialog_only,
N_("Show the accounts dialog"),
NULL },
{ "version", 'v',
G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, show_version_cb,
NULL, NULL },
{ NULL }
};
/* Init */
g_thread_init (NULL);
empathy_init ();
optcontext = g_option_context_new (N_("- Empathy IM Client"));
g_option_context_add_group (optcontext, gst_init_get_option_group ());
g_option_context_add_group (optcontext, gtk_get_option_group (TRUE));
g_option_context_add_main_entries (optcontext, options, GETTEXT_PACKAGE);
if (!g_option_context_parse (optcontext, &argc, &argv, &error)) {
g_print ("%s\nRun '%s --help' to see a full list of available command line options.\n",
error->message, argv[0]);
g_warning ("Error in empathy init: %s", error->message);
return EXIT_FAILURE;
}
g_option_context_free (optcontext);
empathy_gtk_init ();
g_set_application_name (_(PACKAGE_NAME));
g_setenv ("PULSE_PROP_media.role", "phone", TRUE);
#if HAVE_LIBCHAMPLAIN
gtk_clutter_init (&argc, &argv);
#endif
gtk_window_set_default_icon_name ("empathy");
textdomain (GETTEXT_PACKAGE);
#ifdef ENABLE_DEBUG
/* Set up debugger */
g_log_set_default_handler (default_log_handler, NULL);
#endif
unique_app = unique_app_new_with_commands ("org.gnome.Empathy",
NULL, "accounts_dialog", COMMAND_ACCOUNTS_DIALOG, NULL);
if (unique_app_is_running (unique_app))
{
unique_app_send_message (unique_app, account_dialog_only ?
COMMAND_ACCOUNTS_DIALOG : UNIQUE_ACTIVATE, NULL);
g_object_unref (unique_app);
return EXIT_SUCCESS;
}
/* Take well-known name */
dbus_daemon = tp_dbus_daemon_dup (&error);
if (error == NULL)
{
if (!tp_dbus_daemon_request_name (dbus_daemon,
"org.gnome.Empathy", TRUE, &error))
{
DEBUG ("Failed to request well-known name: %s",
error ? error->message : "no message");
g_clear_error (&error);
}
g_object_unref (dbus_daemon);
}
else
{
DEBUG ("Failed to dup dbus daemon: %s",
error ? error->message : "no message");
g_clear_error (&error);
}
if (account_dialog_only)
{
account_manager = tp_account_manager_dup ();
show_accounts_ui (NULL, TRUE);
gtk_main ();
g_object_unref (account_manager);
return 0;
}
notify_init (_(PACKAGE_NAME));
/* Setting up Idle */
idle = empathy_idle_dup_singleton ();
empathy_idle_set_auto_away (idle, TRUE);
/* Setting up Connectivity */
connectivity = empathy_connectivity_dup_singleton ();
use_conn_notify_cb (empathy_conf_get (), EMPATHY_PREFS_USE_CONN,
connectivity);
empathy_conf_notify_add (empathy_conf_get (), EMPATHY_PREFS_USE_CONN,
use_conn_notify_cb, connectivity);
/* account management */
account_manager = tp_account_manager_dup ();
tp_account_manager_prepare_async (account_manager, NULL,
account_manager_ready_cb, NULL);
/* Handle channels */
dispatcher = setup_dispatcher ();
g_signal_connect (dispatcher, "dispatch", G_CALLBACK (dispatch_cb), NULL);
migrate_config_to_xdg_dir ();
/* Setting up UI */
window = empathy_main_window_show ();
icon = empathy_status_icon_new (GTK_WINDOW (window), start_hidden);
g_signal_connect (unique_app, "message-received",
G_CALLBACK (unique_app_message_cb), window);
/* Logging */
log_manager = empathy_log_manager_dup_singleton ();
empathy_log_manager_observe (log_manager, dispatcher);
chatroom_manager = empathy_chatroom_manager_dup_singleton (NULL);
empathy_chatroom_manager_observe (chatroom_manager, dispatcher);
g_object_get (chatroom_manager, "ready", &chatroom_manager_ready, NULL);
if (!chatroom_manager_ready)
{
g_signal_connect (G_OBJECT (chatroom_manager), "notify::ready",
G_CALLBACK (chatroom_manager_ready_cb), account_manager);
}
else
{
chatroom_manager_ready_cb (chatroom_manager, NULL, account_manager);
}
/* Create the call factory */
call_factory = empathy_call_factory_initialise ();
g_signal_connect (G_OBJECT (call_factory), "new-call-handler",
G_CALLBACK (new_call_handler_cb), NULL);
/* Create the FT factory */
ft_factory = empathy_ft_factory_dup_singleton ();
g_signal_connect (ft_factory, "new-ft-handler",
G_CALLBACK (new_ft_handler_cb), NULL);
g_signal_connect (ft_factory, "new-incoming-transfer",
G_CALLBACK (new_incoming_transfer_cb), NULL);
/* Location mananger */
#if HAVE_GEOCLUE
location_manager = empathy_location_manager_dup_singleton ();
#endif
gtk_main ();
empathy_idle_set_state (idle, TP_CONNECTION_PRESENCE_TYPE_OFFLINE);
g_object_unref (idle);
g_object_unref (connectivity);
g_object_unref (icon);
g_object_unref (account_manager);
g_object_unref (log_manager);
g_object_unref (dispatcher);
g_object_unref (chatroom_manager);
#if HAVE_GEOCLUE
g_object_unref (location_manager);
#endif
g_object_unref (ft_factory);
g_object_unref (unique_app);
notify_uninit ();
return EXIT_SUCCESS;
}
