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; }