static void
do_constructed (GObject *object)
{
EmpathyTpFile *self = (EmpathyTpFile *) object;
g_signal_connect (self->priv->channel, "invalidated",
G_CALLBACK (tp_file_invalidated_cb), self);
self->priv->incoming = !tp_channel_get_requested (self->priv->channel);
tp_cli_channel_type_file_transfer_connect_to_file_transfer_state_changed (
self->priv->channel, tp_file_state_changed_cb, NULL, NULL, object, NULL);
tp_cli_channel_type_file_transfer_connect_to_transferred_bytes_changed (
self->priv->channel, tp_file_transferred_bytes_changed_cb,
NULL, NULL, object, NULL);
tp_cli_dbus_properties_call_get (self->priv->channel,
-1, TP_IFACE_CHANNEL_TYPE_FILE_TRANSFER, "State", tp_file_get_state_cb,
NULL, NULL, object);
tp_cli_dbus_properties_call_get (self->priv->channel,
-1, TP_IFACE_CHANNEL_TYPE_FILE_TRANSFER, "AvailableSocketTypes",
tp_file_get_available_socket_types_cb, NULL, NULL, object);
self->priv->state_change_reason =
TP_FILE_TRANSFER_STATE_CHANGE_REASON_NONE;
}
static void
mex_telepathy_channel_on_contact_fetched (TpConnection *connection,
guint n_contacts,
TpContact *const *contacts,
guint n_failed,
const TpHandle *failed,
const GError *fetched_error,
gpointer user_data,
GObject *weak_object)
{
MexTelepathyChannel *self = MEX_TELEPATHY_CHANNEL (user_data);
int i = 0;
if (self->priv->channel)
{
for (i = 0; i < n_contacts; ++i)
{
gchar *text;
const gchar *alias;
TpContact *current;
GFile *file;
// Get the contacts.
current = contacts[i];
// Connect to alias change signal.
// Add the alias to the label.
alias = tp_contact_get_alias (current);
mx_label_set_text (MX_LABEL (self->priv->title_label),
alias);
if (tp_channel_get_requested(self->priv->channel))
text = g_strdup_printf ("Calling %s", alias);
else
text = g_strdup_printf ("Setting up call with %s", alias);
mx_label_set_text (MX_LABEL (self->priv->busy_label), text);
g_free (text);
file = tp_contact_get_avatar_file (current);
if (file)
{
gchar *filename = g_file_get_path (file);
GError *error = NULL;
MEX_DEBUG ("setting new avatar filename to %s", filename);
mx_image_set_from_file (MX_IMAGE(self->priv->avatar_image),
filename,
&error);
if (error)
{
MEX_ERROR ("ERROR %s loading avatar from file %s\n",
error->message, filename);
g_clear_error (&error);
}
if (filename)
g_free (filename);
}
}
}
}
/**
* empathy_ft_handler_is_incoming:
* @handler: an #EmpathyFTHandler
*
* Returns whether @handler is incoming or outgoing.
*
* Return value: %TRUE if the handler is incoming, %FALSE otherwise.
*/
gboolean
empathy_ft_handler_is_incoming (EmpathyFTHandler *handler)
{
EmpathyFTHandlerPriv *priv;
g_return_val_if_fail (EMPATHY_IS_FT_HANDLER (handler), FALSE);
priv = handler->priv;
if (priv->channel == NULL)
return FALSE;
return !tp_channel_get_requested ((TpChannel *) priv->channel);
}
void
empathy_call_handler_start_call (EmpathyCallHandler *handler,
gint64 timestamp)
{
EmpathyCallHandlerPriv *priv = GET_PRIV (handler);
TpAccountChannelRequest *req;
TpAccount *account;
GHashTable *request;
if (priv->call != NULL)
{
empathy_call_handler_start_tpfs (handler);
if (tp_channel_get_requested (TP_CHANNEL (priv->call)))
{
/* accept outgoing channels immediately */
tp_call_channel_accept_async (priv->call,
on_call_accepted_cb, NULL);
}
else
{
/* accepting incoming channels when they are INITIALISED */
if (tp_call_channel_get_state (priv->call, NULL, NULL, NULL) ==
TP_CALL_STATE_INITIALISED)
tp_call_channel_accept_async (priv->call,
on_call_accepted_cb, NULL);
else
priv->accept_when_initialised = TRUE;
}
return;
}
/* No TpCallChannel (we are redialing). Request a new call channel */
g_assert (priv->contact != NULL);
account = empathy_contact_get_account (priv->contact);
request = empathy_call_create_call_request (
empathy_contact_get_id (priv->contact),
priv->initial_audio, priv->initial_video);
req = tp_account_channel_request_new (account, request, timestamp);
tp_account_channel_request_create_and_handle_channel_async (req, NULL,
empathy_call_handler_request_cb, handler);
g_object_unref (req);
g_hash_table_unref (request);
}
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;
}
static void
tp_stream_tube_channel_constructed (GObject *obj)
{
TpStreamTubeChannel *self = (TpStreamTubeChannel *) obj;
void (*chain_up) (GObject *) =
((GObjectClass *) tp_stream_tube_channel_parent_class)->constructed;
TpChannel *chan = (TpChannel *) obj;
GHashTable *props;
GError *err = NULL;
if (chain_up != NULL)
chain_up (obj);
if (tp_channel_get_channel_type_id (chan) !=
TP_IFACE_QUARK_CHANNEL_TYPE_STREAM_TUBE)
{
GError error = { TP_DBUS_ERRORS, TP_DBUS_ERROR_INCONSISTENT,
"Channel is not a stream tube" };
DEBUG ("Channel is not a stream tube: %s", tp_channel_get_channel_type (
chan));
tp_proxy_invalidate (TP_PROXY (self), &error);
return;
}
props = _tp_channel_get_immutable_properties (TP_CHANNEL (self));
if (tp_asv_get_string (props, TP_PROP_CHANNEL_TYPE_STREAM_TUBE_SERVICE)
== NULL)
{
GError error = { TP_DBUS_ERRORS, TP_DBUS_ERROR_INCONSISTENT,
"Tube doesn't have StreamTube.Service property" };
DEBUG ("%s", error.message);
tp_proxy_invalidate (TP_PROXY (self), &error);
return;
}
/* Tube.Parameters is immutable for incoming tubes. For outgoing ones,
* it's defined when offering the tube. */
if (!tp_channel_get_requested (TP_CHANNEL (self)))
{
GHashTable *params;
params = tp_asv_get_boxed (props,
TP_PROP_CHANNEL_INTERFACE_TUBE_PARAMETERS,
TP_HASH_TYPE_STRING_VARIANT_MAP);
if (params == NULL)
{
DEBUG ("Incoming tube doesn't have Tube.Parameters property");
self->priv->parameters = tp_asv_new (NULL, NULL);
}
else
{
self->priv->parameters = g_boxed_copy (
TP_HASH_TYPE_STRING_VARIANT_MAP, params);
}
}
tp_cli_channel_type_stream_tube_connect_to_connection_closed (
TP_CHANNEL (self), connection_closed_cb, NULL, NULL,
G_OBJECT (self), &err);
if (err != NULL)
{
DEBUG ("Failed to connect to ConnectionClosed signal: %s",
err->message);
g_error_free (err);
}
}
/**
* tp_stream_tube_channel_offer_async:
* @self: an outgoing #TpStreamTubeChannel
* @params: (allow-none) (transfer none): parameters of the tube, or %NULL
* @callback: a callback to call when the tube has been offered
* @user_data: data to pass to @callback
*
* Offer an outgoing stream tube. When the tube has been offered, @callback
* will be called. You can then call tp_stream_tube_channel_offer_finish()
* to get the result of the operation.
*
* You have to connect to the #TpStreamTubeChannel::incoming signal to get a
* #TpStreamTubeConnection each time a contact establishes a connection to
* the tube.
*
* Since: 0.13.2
*/
void
tp_stream_tube_channel_offer_async (TpStreamTubeChannel *self,
GHashTable *params,
GAsyncReadyCallback callback,
gpointer user_data)
{
GHashTable *properties;
GHashTable *supported_sockets;
GError *error = NULL;
g_return_if_fail (TP_IS_STREAM_TUBE_CHANNEL (self));
g_return_if_fail (self->priv->result == NULL);
g_return_if_fail (tp_channel_get_requested (TP_CHANNEL (self)));
if (self->priv->service != NULL)
{
g_critical ("Can't reoffer Tube!");
return;
}
self->priv->result = g_simple_async_result_new (G_OBJECT (self), callback,
user_data, tp_stream_tube_channel_offer_async);
properties = _tp_channel_get_immutable_properties (TP_CHANNEL (self));
supported_sockets = tp_asv_get_boxed (properties,
TP_PROP_CHANNEL_TYPE_STREAM_TUBE_SUPPORTED_SOCKET_TYPES,
TP_HASH_TYPE_SUPPORTED_SOCKET_MAP);
if (!_tp_set_socket_address_type_and_access_control_type (supported_sockets,
&self->priv->socket_type, &self->priv->access_control, &error))
{
operation_failed (self, error);
g_clear_error (&error);
return;
}
DEBUG ("Using socket type %u with access control %u", self->priv->socket_type,
self->priv->access_control);
self->priv->service = g_socket_service_new ();
switch (self->priv->socket_type)
{
#ifdef HAVE_GIO_UNIX
case TP_SOCKET_ADDRESS_TYPE_UNIX:
{
self->priv->address = _tp_create_temp_unix_socket (
self->priv->service, &error);
/* check there wasn't an error on the final attempt */
if (self->priv->address == NULL)
{
operation_failed (self, error);
g_clear_error (&error);
return;
}
}
break;
#endif /* HAVE_GIO_UNIX */
case TP_SOCKET_ADDRESS_TYPE_IPV4:
case TP_SOCKET_ADDRESS_TYPE_IPV6:
{
GInetAddress *localhost;
GSocketAddress *in_address;
localhost = g_inet_address_new_loopback (
self->priv->socket_type == TP_SOCKET_ADDRESS_TYPE_IPV4 ?
G_SOCKET_FAMILY_IPV4 : G_SOCKET_FAMILY_IPV6);
in_address = g_inet_socket_address_new (localhost, 0);
g_socket_listener_add_address (
G_SOCKET_LISTENER (self->priv->service), in_address,
G_SOCKET_TYPE_STREAM, G_SOCKET_PROTOCOL_DEFAULT,
NULL, &self->priv->address, &error);
g_object_unref (localhost);
g_object_unref (in_address);
if (error != NULL)
{
operation_failed (self, error);
g_clear_error (&error);
return;
}
break;
}
default:
/* should have already errored */
g_assert_not_reached ();
break;
}
tp_g_signal_connect_object (self->priv->service, "incoming",
G_CALLBACK (service_incoming_cb), self, 0);
g_socket_service_start (self->priv->service);
_offer_with_address (self, params);
}
