/**
* empathy_ft_handler_start_transfer:
* @handler: an #EmpathyFTHandler
*
* Starts the transfer machinery. After this call, the transfer and hashing
* signals will be emitted by the handler.
*/
void
empathy_ft_handler_start_transfer (EmpathyFTHandler *handler)
{
EmpathyFTHandlerPriv *priv;
g_return_if_fail (EMPATHY_IS_FT_HANDLER (handler));
priv = handler->priv;
if (priv->channel == NULL)
{
ft_handler_complete_request (handler);
}
else
{
/* TODO: add support for resume. */
tp_file_transfer_channel_accept_file_async (priv->channel,
priv->gfile, 0, ft_transfer_accept_cb, handler);
tp_g_signal_connect_object (priv->channel, "notify::state",
G_CALLBACK (ft_transfer_state_cb), handler, 0);
tp_g_signal_connect_object (priv->channel, "notify::transferred-bytes",
G_CALLBACK (ft_transfer_transferred_bytes_cb), handler, 0);
}
}
static void
empathy_call_handler_set_property (GObject *object,
guint property_id, const GValue *value, GParamSpec *pspec)
{
EmpathyCallHandlerPriv *priv = GET_PRIV (object);
switch (property_id)
{
case PROP_CONTACT:
priv->contact = g_value_dup_object (value);
break;
case PROP_CALL_CHANNEL:
g_return_if_fail (priv->call == NULL);
priv->call = g_value_dup_object (value);
tp_g_signal_connect_object (priv->call, "state-changed",
G_CALLBACK (on_call_state_changed_cb), object, 0);
tp_g_signal_connect_object (priv->call, "invalidated",
G_CALLBACK (on_call_invalidated_cb), object, 0);
break;
case PROP_INITIAL_AUDIO:
priv->initial_audio = g_value_get_boolean (value);
break;
case PROP_INITIAL_VIDEO:
priv->initial_video = g_value_get_boolean (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}
}
static void
empathy_roster_view_constructed (GObject *object)
{
EmpathyRosterView *self = EMPATHY_ROSTER_VIEW (object);
void (*chain_up) (GObject *) =
((GObjectClass *) empathy_roster_view_parent_class)->constructed;
if (chain_up != NULL)
chain_up (object);
g_assert (EMPATHY_IS_ROSTER_MODEL (self->priv->model));
/* Get saved group states. */
empathy_contact_groups_get_all ();
populate_view (self);
tp_g_signal_connect_object (self->priv->model, "individual-added",
G_CALLBACK (individual_added_cb), self, 0);
tp_g_signal_connect_object (self->priv->model, "individual-removed",
G_CALLBACK (individual_removed_cb), self, 0);
tp_g_signal_connect_object (self->priv->model, "groups-changed",
G_CALLBACK (groups_changed_cb), self, 0);
gtk_list_box_set_sort_func (GTK_LIST_BOX (self),
roster_view_sort, self, NULL);
gtk_list_box_set_header_func (GTK_LIST_BOX (self), update_header, self, NULL);
gtk_list_box_set_filter_func (GTK_LIST_BOX (self), filter_list, self, NULL);
gtk_list_box_set_activate_on_single_click (GTK_LIST_BOX (self), FALSE);
}
static void
check_connection (EmpathyConnectionAggregator *self,
TpConnection *conn)
{
GPtrArray *contacts;
if (g_list_find (self->priv->conns, conn) != NULL)
return;
self->priv->conns = g_list_prepend (self->priv->conns,
g_object_ref (conn));
tp_g_signal_connect_object (conn, "contact-list-changed",
G_CALLBACK (contact_list_changed_cb), self, 0);
contacts = tp_connection_dup_contact_list (conn);
if (contacts != NULL)
{
GPtrArray *empty;
empty = g_ptr_array_new ();
contact_list_changed_cb (conn, contacts, empty, self);
g_ptr_array_unref (empty);
}
tp_g_signal_connect_object (conn, "invalidated",
G_CALLBACK (conn_invalidated_cb), self, 0);
}
static void
empathy_account_chooser_init (EmpathyAccountChooser *self)
{
TpSimpleClientFactory *factory;
self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
EMPATHY_TYPE_ACCOUNT_CHOOSER, EmpathyAccountChooserPriv);
self->priv->set_active_item = FALSE;
self->priv->account_manually_set = FALSE;
self->priv->filter = NULL;
self->priv->filter_data = NULL;
self->priv->manager = tp_account_manager_dup ();
tp_g_signal_connect_object (self->priv->manager, "account-validity-changed",
G_CALLBACK (account_chooser_account_validity_changed_cb), self, 0);
tp_g_signal_connect_object (self->priv->manager, "account-removed",
G_CALLBACK (account_chooser_account_removed_cb), self, 0);
/* Make sure we'll have the capabilities feature on TpAccount's connection */
factory = tp_proxy_get_factory (self->priv->manager);
tp_simple_client_factory_add_account_features_varargs (factory,
TP_ACCOUNT_FEATURE_CONNECTION, NULL);
tp_simple_client_factory_add_connection_features_varargs (factory,
TP_CONNECTION_FEATURE_CAPABILITIES, NULL);
}
static void
tf_call_channel_init_async (GAsyncInitable *initable,
int io_priority,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
TfCallChannel *self = TF_CALL_CHANNEL (initable);
GSimpleAsyncResult *res;
if (cancellable != NULL)
{
g_simple_async_report_error_in_idle (G_OBJECT (self), callback, user_data,
G_IO_ERROR, G_IO_ERROR_NOT_INITIALIZED,
"TfCallChannel initialisation does not support cancellation");
return;
}
res = g_simple_async_result_new (G_OBJECT (self), callback, user_data,
tf_call_channel_init_async);
tp_g_signal_connect_object (self->proxy, "content-added",
G_CALLBACK (content_added), self, 0);
tp_g_signal_connect_object (self->proxy, "content-removed",
G_CALLBACK (content_removed), self, 0);
tp_proxy_prepare_async (self->proxy, NULL, channel_prepared, res);
}
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 *self = user_data;
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;
}
accounts = tp_account_manager_dup_valid_accounts (manager);
for (l = accounts; l != NULL; l = l->next)
{
TpAccount *account = l->data;
account_chooser_account_add_foreach (account, self);
tp_g_signal_connect_object (account, "status-changed",
G_CALLBACK (account_chooser_status_changed_cb),
self, 0);
/* We generally use the TpConnection from the account to filter it so,
* just relying on the account status is not enough. In some case we the
* status change can be notified while the TpConnection is still
* preparing. */
tp_g_signal_connect_object (account, "notify::connection",
G_CALLBACK (account_connection_notify_cb),
self, 0);
}
g_list_free_full (accounts, g_object_unref);
if (self->priv->select_when_ready != NULL)
{
select_account (self, self->priv->select_when_ready);
g_clear_object (&self->priv->select_when_ready);
}
self->priv->ready = TRUE;
g_signal_emit (self, signals[READY], 0);
}
static void
empathy_mic_menu_constructed (GObject *obj)
{
EmpathyMicMenu *self = EMPATHY_MIC_MENU (obj);
EmpathyMicMenuPrivate *priv = self->priv;
GtkUIManager *ui_manager;
EmpathyGstAudioSrc *audio;
g_assert (EMPATHY_IS_CALL_WINDOW (priv->window));
ui_manager = empathy_call_window_get_ui_manager (priv->window);
audio = empathy_call_window_get_audio_src (priv->window);
g_assert (GTK_IS_UI_MANAGER (ui_manager));
g_assert (EMPATHY_IS_GST_AUDIO_SRC (audio));
/* Okay let's go go go. */
priv->mic_monitor = empathy_mic_monitor_new ();
priv->action_group = gtk_action_group_new ("EmpathyMicMenu");
gtk_ui_manager_insert_action_group (ui_manager, priv->action_group, -1);
/* the UI manager now owns this */
g_object_unref (priv->action_group);
priv->anchor_action = g_object_new (GTK_TYPE_RADIO_ACTION,
"name", "EmpathyMicMenuAnchorAction",
NULL);
gtk_action_group_add_action (priv->action_group, priv->anchor_action);
g_object_unref (priv->anchor_action);
priv->microphones = g_queue_new ();
/* Don't bother with any of this if we don't support changing
* microphone, so don't listen for microphone changes or enumerate
* the available microphones. */
if (!empathy_audio_src_supports_changing_mic (audio))
return;
tp_g_signal_connect_object (audio, "notify::microphone",
G_CALLBACK (empathy_mic_menu_notify_microphone_cb), self, 0);
tp_g_signal_connect_object (priv->mic_monitor, "microphone-added",
G_CALLBACK (empathy_mic_menu_microphone_added_cb), self, 0);
tp_g_signal_connect_object (priv->mic_monitor, "microphone-removed",
G_CALLBACK (empathy_mic_menu_microphone_removed_cb), self, 0);
empathy_mic_monitor_list_microphones_async (priv->mic_monitor,
empathy_mic_menu_list_microphones_cb, self);
}
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
observe_channels (TpSimpleObserver *observer,
TpAccount *account,
TpConnection *connection,
GList *channels,
TpChannelDispatchOperation *dispatch_operation,
GList *requests,
TpObserveChannelsContext *context,
gpointer user_data)
{
EmpathyCallObserver *self = EMPATHY_CALL_OBSERVER (user_data);
TpChannel *channel;
const GError *error;
channel = find_main_channel (channels);
if (channel == NULL)
{
GError err = { TP_ERRORS, TP_ERROR_INVALID_ARGUMENT,
"Unknown channel type" };
DEBUG ("Didn't find any Call or StreamedMedia channel; ignoring");
tp_observe_channels_context_fail (context, &err);
return;
}
/* Autoreject if there are other ongoing calls */
if (has_ongoing_calls (self))
{
AutoRejectCtx *ctx = auto_reject_ctx_new (self, context, channel);
DEBUG ("Autorejecting incoming call since there are others in "
"progress: %s", tp_proxy_get_object_path (channel));
tp_channel_dispatch_operation_leave_channels_async (dispatch_operation,
TP_CHANNEL_GROUP_CHANGE_REASON_BUSY, "Already in a call",
claim_and_leave_cb, ctx);
tp_observe_channels_context_accept (context);
return;
}
if ((error = tp_proxy_get_invalidated (channel)) != NULL)
{
DEBUG ("The channel has already been invalidated: %s",
error->message);
tp_observe_channels_context_fail (context, error);
return;
}
DEBUG ("Observing channel %s", tp_proxy_get_object_path (channel));
tp_g_signal_connect_object (channel, "invalidated",
G_CALLBACK (on_channel_closed), self, 0);
self->priv->channels = g_list_prepend (self->priv->channels,
g_object_ref (channel));
tp_observe_channels_context_accept (context);
}
/*
* _mcd_channel_new_request:
* @clients: the client registry
* @account: an account.
* @properties: a #GHashTable of desired channel properties.
* @user_time: user action time.
* @preferred_handler: well-known name of preferred handler.
* @hints: client hints from the request, or %NULL
* @use_existing: use EnsureChannel if %TRUE or CreateChannel if %FALSE
*
* Create a #McdChannel object holding the given properties. The object can
* then be used to intiate a channel request, by passing it to
* mcd_connection_request_channel() on a connection in connected state.
*
* Returns: a newly created #McdChannel.
*/
McdChannel *
_mcd_channel_new_request (McdRequest *request)
{
McdChannel *channel;
channel = g_object_new (MCD_TYPE_CHANNEL,
"outgoing", TRUE,
NULL);
/* TODO: this could be freed when the channel status becomes
* MCD_CHANNEL_STATUS_DISPATCHED or MCD_CHANNEL_STATUS_FAILED? */
channel->priv->request = request;
channel->priv->satisfied_requests = g_list_prepend (NULL,
g_object_ref (channel->priv->request));
channel->priv->latest_request_time =
_mcd_request_get_user_action_time (request);
_mcd_channel_set_status (channel, MCD_CHANNEL_STATUS_REQUEST);
/* for the moment McdChannel implements the later stages of cancelling */
tp_g_signal_connect_object (request, "cancelling",
G_CALLBACK (_mcd_channel_request_cancelling_cb), channel, 0);
return channel;
}
static gboolean
fake_network_monitor_initable_init (GInitable *initable,
GCancellable *cancellable,
GError **error)
{
FakeNetworkMonitor *self = FAKE_NETWORK_MONITOR (initable);
if (self->proxy != NULL)
return TRUE;
self->proxy = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SYSTEM,
G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES,
NULL, "net.connman", "/", "net.connman.Manager", cancellable, error);
if (self->proxy == NULL)
return FALSE;
tp_g_signal_connect_object (self->proxy,
"g-signal", G_CALLBACK (fake_network_monitor_dbus_signal_cb), self, 0);
g_dbus_proxy_call (self->proxy,
"GetProperties", NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL,
fake_network_monitor_get_properties_cb, tp_weak_ref_new (self, NULL, NULL));
return TRUE;
}
static void
on_account_notify_changing_presence (GObject *object,
GParamSpec *pspec,
gpointer user_data)
{
TpAccount *account = TP_ACCOUNT (object);
ChangingPresenceData *data = user_data;
TpConnection *connection;
if (tp_account_get_changing_presence (account))
{
g_source_remove (data->source_id);
g_signal_handler_disconnect (data->account, data->handler_id);
connection = tp_account_get_connection (account);
if (connection == NULL)
{
/* now just wait for the connection */
tp_g_signal_connect_object (account, "notify::connection",
G_CALLBACK (on_account_notify_connection), data->res, 0);
}
else
{
/* TODO: this should be given the cancellable when it's used. */
_tp_yts_connection_future_ensure_sidecar_async (connection,
TP_YTS_IFACE_STATUS, NULL,
on_connection_future_ensure_sidecar_returned, data->res);
}
g_slice_free (ChangingPresenceData, data);
}
}
static void
on_content_added_cb (TpProxy *proxy,
const gchar *content_path,
gpointer user_data,
GObject *weak_object)
{
TpyCallChannel *self = TPY_CALL_CHANNEL (proxy);
TpyCallContent *content;
DEBUG ("Content added: %s", content_path);
content = g_object_new (TPY_TYPE_CALL_CONTENT,
"bus-name", tp_proxy_get_bus_name (self),
"dbus-daemon", tp_proxy_get_dbus_daemon (self),
"dbus-connection", tp_proxy_get_dbus_connection (self),
"object-path", content_path,
NULL);
if (content == NULL)
{
g_warning ("Could not create a CallContent for path %s", content_path);
return;
}
g_ptr_array_add (self->priv->contents, content);
tp_g_signal_connect_object (content, "notify::ready",
G_CALLBACK (on_content_ready_cb), self, 0);
g_signal_emit (self, _signals[CONTENT_ADDED], 0, content);
}
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
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
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)
{
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
add_account (EmpathyConnectionAggregator *self,
TpAccount *account)
{
check_account (self, account);
tp_g_signal_connect_object (account, "notify::connection",
G_CALLBACK (account_conn_changed_cb), self, 0);
}
static void
contact_manager_validity_changed_cb (TpAccountManager *account_manager,
TpAccount *account,
gboolean valid,
EmpathyContactManager *manager)
{
if (valid) {
tp_g_signal_connect_object (account, "status-changed",
G_CALLBACK (contact_manager_status_changed_cb),
manager, 0);
}
}
static void
empathy_tls_dialog_constructed (GObject *object)
{
GtkWidget *content_area, *expander, *details, *checkbox;
gchar *text;
EmpathyTLSDialog *self = EMPATHY_TLS_DIALOG (object);
GtkMessageDialog *message_dialog = GTK_MESSAGE_DIALOG (self);
GtkDialog *dialog = GTK_DIALOG (self);
EmpathyTLSDialogPriv *priv = GET_PRIV (self);
gtk_dialog_add_buttons (dialog,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
_("C_ontinue"), GTK_RESPONSE_YES,
NULL);
text = reason_to_string (self);
g_object_set (message_dialog,
"title", _("Untrusted connection"),
"text", _("This connection is untrusted. Would you like to "
"continue anyway?"),
"secondary-text", text,
NULL);
g_free (text);
content_area = gtk_dialog_get_content_area (dialog);
checkbox = gtk_check_button_new_with_label (
_("Remember this choice for future connections"));
gtk_box_pack_end (GTK_BOX (content_area), checkbox, FALSE, FALSE, 0);
gtk_widget_show (checkbox);
g_signal_connect (checkbox, "toggled", G_CALLBACK (checkbox_toggled_cb),
self);
text = g_strdup_printf ("<b>%s</b>", _("Certificate Details"));
expander = gtk_expander_new (text);
gtk_expander_set_use_markup (GTK_EXPANDER (expander), TRUE);
gtk_box_pack_end (GTK_BOX (content_area), expander, TRUE, TRUE, 0);
gtk_widget_show (expander);
g_free (text);
details = build_gcr_widget (self);
gtk_container_add (GTK_CONTAINER (expander), details);
gtk_widget_show (details);
gtk_window_set_keep_above (GTK_WINDOW (self), TRUE);
tp_g_signal_connect_object (priv->certificate, "invalidated",
G_CALLBACK (certificate_invalidated_cb), self, 0);
}
static void
connection_notify_cb (TpawUserInfo *self)
{
TpConnection *connection = tp_account_get_connection (self->priv->account);
if (connection != NULL)
{
tp_g_signal_connect_object (connection, "notify::self-contact",
G_CALLBACK (reload_contact_info), self, G_CONNECT_SWAPPED);
}
reload_contact_info (self);
}
static void
ft_handler_create_channel_cb (GObject *source,
GAsyncResult *result,
gpointer user_data)
{
EmpathyFTHandler *handler = user_data;
EmpathyFTHandlerPriv *priv = handler->priv;
GError *error = NULL;
TpChannel *channel;
DEBUG ("Dispatcher create channel CB");
channel = tp_account_channel_request_create_and_handle_channel_finish (
TP_ACCOUNT_CHANNEL_REQUEST (source), result, NULL, &error);
if (channel == NULL)
DEBUG ("Failed to request FT channel: %s", error->message);
else
g_cancellable_set_error_if_cancelled (priv->cancellable, &error);
if (error != NULL)
{
emit_error_signal (handler, error);
g_clear_object (&channel);
g_error_free (error);
return;
}
priv->channel = TP_FILE_TRANSFER_CHANNEL (channel);
tp_g_signal_connect_object (priv->channel, "notify::state",
G_CALLBACK (ft_transfer_state_cb), handler, 0);
tp_g_signal_connect_object (priv->channel, "notify::transferred-bytes",
G_CALLBACK (ft_transfer_transferred_bytes_cb), handler, 0);
tp_file_transfer_channel_provide_file_async (priv->channel, priv->gfile,
ft_transfer_provide_cb, handler);
}
static void
gabble_im_factory_constructed (GObject *obj)
{
GabbleImFactory *self = GABBLE_IM_FACTORY (obj);
GObjectClass *parent_class = gabble_im_factory_parent_class;
if (parent_class->constructed != NULL)
parent_class->constructed (obj);
self->priv->status_changed_id = g_signal_connect (self->priv->conn,
"status-changed", (GCallback) connection_status_changed_cb, obj);
tp_g_signal_connect_object (self->priv->conn,
"porter-available", (GCallback) porter_available_cb, obj, 0);
}
static void
empathy_call_handler_request_cb (GObject *source,
GAsyncResult *result,
gpointer user_data)
{
EmpathyCallHandler *self = EMPATHY_CALL_HANDLER (user_data);
EmpathyCallHandlerPriv *priv = GET_PRIV (self);
TpChannel *channel;
GError *error = NULL;
TpAccountChannelRequest *req = TP_ACCOUNT_CHANNEL_REQUEST (source);
channel = tp_account_channel_request_create_and_handle_channel_finish (req,
result, NULL, &error);
if (channel == NULL)
{
DEBUG ("Failed to create the channel: %s", error->message);
g_error_free (error);
return;
}
if (!TP_IS_CALL_CHANNEL (channel))
{
DEBUG ("The channel is not a Call channel!");
return;
}
priv->call = TP_CALL_CHANNEL (channel);
tp_g_signal_connect_object (priv->call, "state-changed",
G_CALLBACK (on_call_state_changed_cb), self, 0);
tp_g_signal_connect_object (priv->call, "invalidated",
G_CALLBACK (on_call_invalidated_cb), self, 0);
g_object_notify (G_OBJECT (self), "call-channel");
empathy_call_handler_start_tpfs (self);
tp_call_channel_accept_async (priv->call, on_call_accepted_cb, NULL);
}
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);
}
static GObject *
tp_streamed_media_constructor (GType type,
guint n_construct_params,
GObjectConstructParam *construct_params)
{
GObject *object;
EmpathyTpStreamedMedia *call;
EmpathyTpStreamedMediaPriv *priv;
object = G_OBJECT_CLASS (empathy_tp_streamed_media_parent_class)->constructor (type,
n_construct_params, construct_params);
call = EMPATHY_TP_STREAMED_MEDIA (object);
priv = GET_PRIV (call);
/* Setup streamed media channel */
g_signal_connect (priv->channel, "invalidated",
G_CALLBACK (tp_streamed_media_channel_invalidated_cb), call);
tp_cli_channel_type_streamed_media_connect_to_stream_added (priv->channel,
tp_streamed_media_stream_added_cb, NULL, NULL, G_OBJECT (call), NULL);
tp_cli_channel_type_streamed_media_connect_to_stream_removed (priv->channel,
tp_streamed_media_stream_removed_cb, NULL, NULL, G_OBJECT (call), NULL);
tp_cli_channel_type_streamed_media_connect_to_stream_state_changed (priv->channel,
tp_streamed_media_stream_state_changed_cb, NULL, NULL, G_OBJECT (call), NULL);
tp_cli_channel_type_streamed_media_connect_to_stream_direction_changed (priv->channel,
tp_streamed_media_stream_direction_changed_cb, NULL, NULL, G_OBJECT (call), NULL);
tp_cli_channel_type_streamed_media_connect_to_stream_error (priv->channel,
tp_streamed_media_stream_error_cb, NULL, NULL, G_OBJECT (call), NULL);
tp_cli_channel_type_streamed_media_call_list_streams (priv->channel, -1,
tp_streamed_media_request_streams_cb, NULL, NULL, G_OBJECT (call));
/* Is the call incoming? */
priv->is_incoming = !tp_channel_get_requested (priv->channel);
/* Get the remote contact */
empathy_tp_contact_factory_get_from_handle (
tp_channel_borrow_connection (priv->channel),
tp_channel_get_handle (priv->channel, NULL), tp_streamed_media_got_contact_cb,
NULL, NULL, object);
/* Update status when members changes */
tp_streamed_media_update_status (call);
tp_g_signal_connect_object (priv->channel, "group-members-changed",
G_CALLBACK (tp_streamed_media_update_status), call, G_CONNECT_SWAPPED);
return object;
}
/**
* tp_yts_status_ensure_async:
* @account: The Ytstenut enabled account
* @cancellable: Not used
* @callback: A callback which should be called when the result is ready
* @user_data: Data to pass to the callback
*
* Create a #TpYtsStatus object for a Ytstenut enabled
* connection. @account must be either connected, or in the process of
* connecting. Calling tp_yts_account_manager_hold() before this
* function (even if haven't re-entered the mainloop yet) is
* acceptable for connecting the account.
*/
void
tp_yts_status_ensure_async (TpAccount *account,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GSimpleAsyncResult *res;
TpConnection *connection;
g_return_if_fail (TP_IS_ACCOUNT (account));
connection = tp_account_get_connection (account);
res = g_simple_async_result_new (G_OBJECT (account), callback, user_data,
tp_yts_status_ensure_async);
if (connection == NULL)
{
if (tp_account_get_changing_presence (account))
{
/* just wait for the connection */
tp_g_signal_connect_object (account, "notify::connection",
G_CALLBACK (on_account_notify_connection), res, 0);
}
else
{
/* wait to see if the connection appears */
ChangingPresenceData *data = g_slice_new0 (ChangingPresenceData);
data->res = res;
data->account = account;
data->source_id = g_timeout_add_seconds (1, on_account_timeout, data);
data->handler_id = g_signal_connect (account,
"notify::changing-presence",
G_CALLBACK (on_account_notify_changing_presence),
data);
}
}
else
{
_tp_yts_connection_future_ensure_sidecar_async (connection,
TP_YTS_IFACE_STATUS, cancellable,
on_connection_future_ensure_sidecar_returned, res);
}
}
static void
empathy_server_sasl_handler_constructed (GObject *object)
{
EmpathyServerSASLHandlerPriv *priv = EMPATHY_SERVER_SASL_HANDLER (object)->priv;
GError *error = NULL;
tp_cli_channel_interface_sasl_authentication_connect_to_sasl_status_changed (
priv->channel, sasl_status_changed_cb, NULL, NULL, object, &error);
if (error != NULL)
{
DEBUG ("Failed to connect to SASLStatusChanged: %s", error->message);
g_clear_error (&error);
}
tp_g_signal_connect_object (priv->channel, "invalidated",
G_CALLBACK (channel_invalidated_cb), object, 0);
}
static void
auth_factory_auth_passsword_failed (EmpathyAuthFactory *factory,
TpAccount *account,
const gchar *password,
gpointer user_data)
{
GtkWidget *dialog;
DEBUG ("Authentication on %s failed, popup password dialog",
tp_account_get_path_suffix (account));
dialog = empathy_bad_password_dialog_new (account, password);
tp_g_signal_connect_object (dialog, "retry",
G_CALLBACK (retry_account_cb), factory, 0);
gtk_widget_show (dialog);
}
