static void
rakia_media_manager_type_foreach_channel_class (GType type,
TpChannelManagerTypeChannelClassFunc func,
gpointer user_data)
{
GHashTable *table = g_hash_table_new_full (g_str_hash, g_str_equal,
NULL, (GDestroyNotify) tp_g_value_slice_free);
GValue *value, *handle_type_value;
value = tp_g_value_slice_new (G_TYPE_STRING);
g_value_set_static_string (value, TP_IFACE_CHANNEL_TYPE_CALL);
g_hash_table_insert (table, TP_PROP_CHANNEL_CHANNEL_TYPE, value);
handle_type_value = tp_g_value_slice_new (G_TYPE_UINT);
/* no uint value yet - we'll change it for each channel class */
g_hash_table_insert (table, TP_PROP_CHANNEL_TARGET_HANDLE_TYPE,
handle_type_value);
g_value_set_uint (handle_type_value, TP_HANDLE_TYPE_CONTACT);
g_hash_table_insert (table, TP_PROP_CHANNEL_TYPE_CALL_INITIAL_AUDIO,
tp_g_value_slice_new_boolean (TRUE));
func (type, table, named_channel_allowed_properties, user_data);
g_hash_table_remove (table, TP_PROP_CHANNEL_TYPE_CALL_INITIAL_AUDIO);
g_hash_table_insert (table, TP_PROP_CHANNEL_TYPE_CALL_INITIAL_VIDEO,
tp_g_value_slice_new_boolean (TRUE));
func (type, table, named_channel_allowed_properties, user_data);
g_hash_table_unref (table);
}
static GHashTable *
ring_anon_channel_fixed_properties(void)
{
static GHashTable *hash;
if (hash)
return hash;
hash = g_hash_table_new(g_str_hash, g_str_equal);
char const *key;
GValue *value;
key = TP_IFACE_CHANNEL ".TargetHandleType";
value = tp_g_value_slice_new(G_TYPE_UINT);
g_value_set_uint(value, TP_HANDLE_TYPE_NONE);
g_hash_table_insert(hash, (gpointer)key, value);
key = TP_IFACE_CHANNEL ".ChannelType";
value = tp_g_value_slice_new(G_TYPE_STRING);
g_value_set_static_string(value, TP_IFACE_CHANNEL_TYPE_STREAMED_MEDIA);
g_hash_table_insert(hash, (gpointer)key, value);
return hash;
}
void
empathy_call_handler_start_call (EmpathyCallHandler *handler)
{
EmpathyCallHandlerPriv *priv = GET_PRIV (handler);
EmpathyDispatcher *dispatcher;
TpConnection *connection;
GList *classes;
GValue *value;
GHashTable *request;
if (priv->call != NULL)
{
empathy_call_handler_start_tpfs (handler);
empathy_tp_call_accept_incoming_call (priv->call);
return;
}
g_assert (priv->contact != NULL);
dispatcher = empathy_dispatcher_dup_singleton ();
connection = empathy_contact_get_connection (priv->contact);
classes = empathy_dispatcher_find_requestable_channel_classes
(dispatcher, connection, TP_IFACE_CHANNEL_TYPE_STREAMED_MEDIA,
TP_HANDLE_TYPE_CONTACT, NULL);
if (classes == NULL)
return;
g_list_free (classes);
request = g_hash_table_new_full (g_str_hash, g_str_equal, NULL,
(GDestroyNotify) tp_g_value_slice_free);
/* org.freedesktop.Telepathy.Channel.ChannelType */
value = tp_g_value_slice_new (G_TYPE_STRING);
g_value_set_string (value, TP_IFACE_CHANNEL_TYPE_STREAMED_MEDIA);
g_hash_table_insert (request, TP_IFACE_CHANNEL ".ChannelType", value);
/* org.freedesktop.Telepathy.Channel.TargetHandleType */
value = tp_g_value_slice_new (G_TYPE_UINT);
g_value_set_uint (value, TP_HANDLE_TYPE_CONTACT);
g_hash_table_insert (request, TP_IFACE_CHANNEL ".TargetHandleType", value);
/* org.freedesktop.Telepathy.Channel.TargetHandle*/
value = tp_g_value_slice_new (G_TYPE_UINT);
g_value_set_uint (value, empathy_contact_get_handle (priv->contact));
g_hash_table_insert (request, TP_IFACE_CHANNEL ".TargetHandle", value);
empathy_dispatcher_create_channel (dispatcher, connection,
request, empathy_call_handler_request_cb, handler);
g_object_unref (dispatcher);
}
static void
gabble_im_factory_get_contact_caps (GabbleCapsChannelManager *manager,
TpHandle handle,
const GabbleCapabilitySet *caps,
GPtrArray *arr)
{
/* We don't need to check this contact's capabilities, we assume every
* contact support text channels. */
/* NOTE: if any more contact caps are added here which are not
* assumed then be sure to change the implementation of
* gabble_connection_get_handle_contact_capabilities, as that uses
* this function to fill the contact caps hash for all contacts
* (even offline). */
GValue monster = {0, };
GHashTable *fixed_properties;
GValue *channel_type_value;
GValue *target_handle_type_value;
gchar *text_allowed_properties[] =
{
TP_IFACE_CHANNEL ".TargetHandle",
NULL
};
g_assert (handle != 0);
g_value_init (&monster, TP_STRUCT_TYPE_REQUESTABLE_CHANNEL_CLASS);
g_value_take_boxed (&monster,
dbus_g_type_specialized_construct (
TP_STRUCT_TYPE_REQUESTABLE_CHANNEL_CLASS));
fixed_properties = g_hash_table_new_full (g_str_hash, g_str_equal, NULL,
(GDestroyNotify) tp_g_value_slice_free);
channel_type_value = tp_g_value_slice_new (G_TYPE_STRING);
g_value_set_static_string (channel_type_value, TP_IFACE_CHANNEL_TYPE_TEXT);
g_hash_table_insert (fixed_properties, TP_IFACE_CHANNEL ".ChannelType",
channel_type_value);
target_handle_type_value = tp_g_value_slice_new (G_TYPE_UINT);
g_value_set_uint (target_handle_type_value, TP_HANDLE_TYPE_CONTACT);
g_hash_table_insert (fixed_properties, TP_IFACE_CHANNEL ".TargetHandleType",
target_handle_type_value);
dbus_g_type_struct_set (&monster,
0, fixed_properties,
1, text_allowed_properties,
G_MAXUINT);
g_hash_table_unref (fixed_properties);
g_ptr_array_add (arr, g_value_get_boxed (&monster));
}
void
conn_location_properties_getter (GObject *object,
GQuark interface,
GQuark name,
GValue *value,
gpointer getter_data)
{
GabbleConnection *conn = GABBLE_CONNECTION (object);
if (!tp_strdiff (g_quark_to_string (name), "LocationAccessControlTypes"))
{
guint access_control_type =
TP_RICH_PRESENCE_ACCESS_CONTROL_TYPE_PUBLISH_LIST;
GArray *access_control = g_array_sized_new (FALSE, FALSE,
sizeof (guint), 1);
g_array_append_val (access_control, access_control_type);
g_value_take_boxed (value, access_control);
}
else if (!tp_strdiff (g_quark_to_string (name), "LocationAccessControl"))
{
GValueArray *access_control = g_value_array_new (2);
GValue type = {0,};
GValue variant = {0,};
GValue *allocated_value;
/* G_TYPE_UINT is the D-Bus type of TpRichPresenceAccessControlType */
g_value_init (&type, G_TYPE_UINT);
g_value_set_uint (&type,
TP_RICH_PRESENCE_ACCESS_CONTROL_TYPE_PUBLISH_LIST);
g_value_array_append (access_control, &type);
g_value_unset (&type);
g_value_init (&variant, G_TYPE_VALUE);
/* For Publish_List, the variant isn't used, so we set a dummy value,
* (guint) 0 */
allocated_value = tp_g_value_slice_new (G_TYPE_UINT);
g_value_set_uint (allocated_value, 0);
g_value_set_boxed (&variant, allocated_value);
g_value_array_append (access_control, &variant);
g_value_unset (&variant);
tp_g_value_slice_free (allocated_value);
g_value_take_boxed (value, access_control);
}
else if (name == g_quark_from_static_string ("SupportedLocationFeatures"))
{
TpLocationFeatures flags = 0;
if (conn->features & GABBLE_CONNECTION_FEATURES_PEP)
flags |= TP_LOCATION_FEATURE_CAN_SET;
g_value_set_uint (value, flags);
}
else
{
g_assert_not_reached ();
}
}
/**
* tp_g_value_slice_new_uint:
* @n: an unsigned integer
*
* Slice-allocate and initialize a #GValue. This function is convenient to
* use when constructing hash tables from string to #GValue, for example.
*
* Returns: a #GValue of type %G_TYPE_UINT with value @n, to be freed with
* tp_g_value_slice_free() or g_slice_free()
*
* Since: 0.7.27
*/
GValue *
tp_g_value_slice_new_uint (guint n)
{
GValue *v = tp_g_value_slice_new (G_TYPE_UINT);
g_value_set_uint (v, n);
return v;
}
/**
* tp_g_value_slice_dup:
* @value: A GValue
*
* <!-- 'Returns' says it all -->
*
* Returns: a newly allocated copy of @value, to be freed with
* tp_g_value_slice_free() or g_slice_free().
* Since: 0.5.14
*/
GValue *
tp_g_value_slice_dup (const GValue *value)
{
GValue *ret = tp_g_value_slice_new (G_VALUE_TYPE (value));
g_value_copy (value, ret);
return ret;
}
/**
* tp_g_value_slice_new_take_string:
* @string: a string which will be freed with g_free() by the returned #GValue
* (the caller must own it before calling this function, but no longer owns
* it after this function returns)
*
* Slice-allocate and initialize a #GValue. This function is convenient to
* use when constructing hash tables from string to #GValue, for example.
*
* Returns: a #GValue of type %G_TYPE_STRING whose value is @string,
* to be freed with tp_g_value_slice_free() or g_slice_free()
*
* Since: 0.7.27
*/
GValue *
tp_g_value_slice_new_take_string (gchar *string)
{
GValue *v = tp_g_value_slice_new (G_TYPE_STRING);
g_value_take_string (v, string);
return v;
}
/**
* tp_g_value_slice_new_static_string:
* @string: a static string which must remain valid forever, to be pointed to
* by the value
*
* Slice-allocate and initialize a #GValue. This function is convenient to
* use when constructing hash tables from string to #GValue, for example.
*
* Returns: a #GValue of type %G_TYPE_STRING whose value is @string,
* to be freed with tp_g_value_slice_free() or g_slice_free()
*
* Since: 0.7.27
*/
GValue *
tp_g_value_slice_new_static_string (const gchar *string)
{
GValue *v = tp_g_value_slice_new (G_TYPE_STRING);
g_value_set_static_string (v, string);
return v;
}
/**
* tp_g_value_slice_new_double:
* @d: a number
*
* Slice-allocate and initialize a #GValue. This function is convenient to
* use when constructing hash tables from string to #GValue, for example.
*
* Returns: a #GValue of type %G_TYPE_DOUBLE with value @n, to be freed with
* tp_g_value_slice_free() or g_slice_free()
*
* Since: 0.7.27
*/
GValue *
tp_g_value_slice_new_double (double n)
{
GValue *v = tp_g_value_slice_new (G_TYPE_DOUBLE);
g_value_set_double (v, n);
return v;
}
/**
* tp_g_value_slice_new_uint64:
* @n: a 64-bit unsigned integer
*
* Slice-allocate and initialize a #GValue. This function is convenient to
* use when constructing hash tables from string to #GValue, for example.
*
* Returns: a #GValue of type %G_TYPE_UINT64 with value @n, to be freed with
* tp_g_value_slice_free() or g_slice_free()
*
* Since: 0.7.27
*/
GValue *
tp_g_value_slice_new_uint64 (guint64 n)
{
GValue *v = tp_g_value_slice_new (G_TYPE_UINT64);
g_value_set_uint64 (v, n);
return v;
}
/**
* tp_g_value_slice_new_boolean:
* @b: a boolean value
*
* Slice-allocate and initialize a #GValue. This function is convenient to
* use when constructing hash tables from string to #GValue, for example.
*
* Returns: a #GValue of type %G_TYPE_BOOLEAN with value @b, to be freed with
* tp_g_value_slice_free() or g_slice_free()
*
* Since: 0.7.27
*/
GValue *
tp_g_value_slice_new_boolean (gboolean b)
{
GValue *v = tp_g_value_slice_new (G_TYPE_BOOLEAN);
g_value_set_boolean (v, b);
return v;
}
static void kindling_roomlist_manager_type_foreach_channel_class (GType type,
TpChannelManagerTypeChannelClassFunc func,
gpointer user_data) {
g_printf("type_foreach_channel_class\n");
GHashTable *table = g_hash_table_new_full (g_str_hash, g_str_equal,
NULL, (GDestroyNotify) tp_g_value_slice_free);
GValue *value;
value = tp_g_value_slice_new (G_TYPE_STRING);
g_value_set_static_string (value, TP_IFACE_CHANNEL_TYPE_ROOM_LIST);
g_hash_table_insert (table, TP_IFACE_CHANNEL ".ChannelType", value);
value = tp_g_value_slice_new (G_TYPE_UINT);
g_value_set_uint (value, TP_HANDLE_TYPE_NONE);
g_hash_table_insert (table, TP_IFACE_CHANNEL ".TargetHandleType", value);
func (type, table, roomlist_channel_allowed_properties, user_data);
g_hash_table_unref (table);
}
/**
* tp_g_value_slice_new_take_boxed:
* @type: a boxed type
* @p: a pointer of type @type which will be freed with g_boxed_free() by the
* returned #GValue (the caller must own it before calling this function, but
* no longer owns it after this function returns)
*
* Slice-allocate and initialize a #GValue. This function is convenient to
* use when constructing hash tables from string to #GValue, for example.
*
* Returns: a #GValue of type @type whose value is @p,
* to be freed with tp_g_value_slice_free() or g_slice_free()
*
* Since: 0.7.27
*/
GValue *
tp_g_value_slice_new_take_boxed (GType type,
gpointer p)
{
GValue *v;
g_return_val_if_fail (G_TYPE_FUNDAMENTAL (type) == G_TYPE_BOXED, NULL);
v = tp_g_value_slice_new (type);
g_value_take_boxed (v, p);
return v;
}
static void _im_manager_type_foreach_class (GType type,
TpChannelManagerTypeChannelClassFunc func,
gpointer user_data)
{
GHashTable *table;
GValue *value;
table = g_hash_table_new_full (g_str_hash, g_str_equal,
NULL, (GDestroyNotify) tp_g_value_slice_free);
value = tp_g_value_slice_new (G_TYPE_STRING);
g_value_set_static_string (value, TP_IFACE_CHANNEL_TYPE_TEXT);
g_hash_table_insert (table, (gpointer) im_channel_fixed_properties[0], value);
value = tp_g_value_slice_new (G_TYPE_UINT);
g_value_set_uint (value, TP_HANDLE_TYPE_CONTACT);
g_hash_table_insert (table, (gpointer) im_channel_fixed_properties[1], value);
func (type, table, im_channel_allowed_properties, user_data);
g_hash_table_destroy (table);
}
/**
* tp_properties_mixin_change_value:
* @obj: An object with the properties mixin
* @prop_id: A property ID on which to act
* @new_value: Property value
* @props: either %NULL, or a pointer to a TpIntSet
*
* Change the value of the given property ID in response to a server state
* change.
*
* If the old and new values match, nothing happens; no signal is emitted and
* @props is ignored. Otherwise, the following applies:
*
* If @props is %NULL the PropertiesChanged signal is emitted for this one
* property.
*
* Otherwise, the property ID is added to the set; the caller is responsible
* for passing the set to tp_properties_mixin_emit_changed() once a batch of
* properties have been changed.
*/
void
tp_properties_mixin_change_value (GObject *obj,
guint prop_id,
const GValue *new_value,
TpIntSet *props)
{
TpPropertiesMixin *mixin = TP_PROPERTIES_MIXIN (obj);
TpPropertiesMixinClass *mixin_cls = TP_PROPERTIES_MIXIN_CLASS (
G_OBJECT_GET_CLASS (obj));
TpProperty *prop;
g_assert (prop_id < mixin_cls->num_props);
prop = &mixin->properties[prop_id];
if (prop->value)
{
if (values_are_equal (prop->value, new_value))
return;
}
else
{
prop->value = tp_g_value_slice_new (mixin_cls->signatures[prop_id].type);
}
g_value_copy (new_value, prop->value);
if (props)
{
tp_intset_add (props, prop_id);
}
else
{
TpIntSet *changed_props = tp_intset_sized_new (prop_id + 1);
tp_intset_add (changed_props, prop_id);
tp_properties_mixin_emit_changed (obj, changed_props);
tp_intset_destroy (changed_props);
}
}
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);
}
EmpathyTpTube *
empathy_tp_tube_new_stream_tube (EmpathyContact *contact,
TpSocketAddressType type,
const gchar *hostname,
guint port,
const gchar *service,
GHashTable *parameters)
{
MissionControl *mc;
McAccount *account;
TpConnection *connection;
TpChannel *channel;
gchar *object_path;
GHashTable *params;
GValue *address;
GValue *control_param;
EmpathyTpTube *tube = NULL;
GError *error = NULL;
GHashTable *request;
GHashTable *channel_properties;
GValue *value;
g_return_val_if_fail (EMPATHY_IS_CONTACT (contact), NULL);
g_return_val_if_fail (hostname != NULL, NULL);
g_return_val_if_fail (service != NULL, NULL);
mc = empathy_mission_control_dup_singleton ();
account = empathy_contact_get_account (contact);
connection = mission_control_get_tpconnection (mc, account, NULL);
g_object_unref (mc);
tp_connection_run_until_ready (connection, FALSE, NULL, NULL);
request = g_hash_table_new_full (g_str_hash, g_str_equal, NULL,
(GDestroyNotify) tp_g_value_slice_free);
/* org.freedesktop.Telepathy.Channel.ChannelType */
value = tp_g_value_slice_new (G_TYPE_STRING);
g_value_set_string (value, EMP_IFACE_CHANNEL_TYPE_STREAM_TUBE);
g_hash_table_insert (request, TP_IFACE_CHANNEL ".ChannelType", value);
/* org.freedesktop.Telepathy.Channel.TargetHandleType */
value = tp_g_value_slice_new (G_TYPE_UINT);
g_value_set_uint (value, TP_HANDLE_TYPE_CONTACT);
g_hash_table_insert (request, TP_IFACE_CHANNEL ".TargetHandleType", value);
/* org.freedesktop.Telepathy.Channel.TargetHandleType */
value = tp_g_value_slice_new (G_TYPE_UINT);
g_value_set_uint (value, empathy_contact_get_handle (contact));
g_hash_table_insert (request, TP_IFACE_CHANNEL ".TargetHandle", value);
/* org.freedesktop.Telepathy.Channel.Type.StreamTube.Service */
value = tp_g_value_slice_new (G_TYPE_STRING);
g_value_set_string (value, service);
g_hash_table_insert (request,
EMP_IFACE_CHANNEL_TYPE_STREAM_TUBE ".Service", value);
if (!tp_cli_connection_interface_requests_run_create_channel (connection, -1,
request, &object_path, &channel_properties, &error, NULL))
{
DEBUG ("Error requesting channel: %s", error->message);
g_clear_error (&error);
g_object_unref (connection);
return NULL;
}
DEBUG ("Offering a new stream tube");
channel = tp_channel_new_from_properties (connection, object_path,
channel_properties, NULL);
tp_channel_run_until_ready (channel, NULL, NULL);
#define ADDRESS_TYPE dbus_g_type_get_struct ("GValueArray",\
G_TYPE_STRING, G_TYPE_UINT, G_TYPE_INVALID)
params = g_hash_table_new (g_str_hash, g_str_equal);
address = tp_g_value_slice_new (ADDRESS_TYPE);
g_value_take_boxed (address, dbus_g_type_specialized_construct (ADDRESS_TYPE));
dbus_g_type_struct_set (address, 0, hostname, 1, port, G_MAXUINT);
control_param = tp_g_value_slice_new (G_TYPE_STRING);
if (!emp_cli_channel_type_stream_tube_run_offer_stream_tube (
TP_PROXY(channel), -1, type, address,
TP_SOCKET_ACCESS_CONTROL_LOCALHOST, control_param, parameters,
&error, NULL))
{
DEBUG ("Couldn't offer tube: %s", error->message);
g_clear_error (&error);
goto OUT;
}
DEBUG ("Stream tube offered");
tube = empathy_tp_tube_new (channel);
OUT:
g_object_unref (channel);
g_free (object_path);
g_hash_table_destroy (request);
g_hash_table_destroy (channel_properties);
tp_g_value_slice_free (address);
tp_g_value_slice_free (control_param);
g_object_unref (connection);
return tube;
}
