static void
constructed (GObject *object)
{
ExampleContactListBase *self = EXAMPLE_CONTACT_LIST_BASE (object);
void (*chain_up) (GObject *) =
((GObjectClass *) example_contact_list_base_parent_class)->constructed;
TpHandleRepoIface *contact_repo = tp_base_connection_get_handles
(self->priv->conn, TP_HANDLE_TYPE_CONTACT);
TpHandle self_handle = self->priv->conn->self_handle;
TpHandleRepoIface *handle_repo = tp_base_connection_get_handles
(self->priv->conn, self->priv->handle_type);
if (chain_up != NULL)
chain_up (object);
g_assert (TP_IS_BASE_CONNECTION (self->priv->conn));
g_assert (EXAMPLE_IS_CONTACT_LIST_MANAGER (self->priv->manager));
tp_dbus_daemon_register_object (
tp_base_connection_get_dbus_daemon (self->priv->conn),
self->priv->object_path, self);
tp_handle_ref (handle_repo, self->priv->handle);
tp_group_mixin_init (object, G_STRUCT_OFFSET (ExampleContactListBase, group),
contact_repo, self_handle);
/* Both the subclasses have full support for telepathy-spec 0.17.6. */
tp_group_mixin_change_flags (object,
TP_CHANNEL_GROUP_FLAG_PROPERTIES, 0);
}
static GObject *
gabble_bytestream_multiple_constructor (GType type,
guint n_props,
GObjectConstructParam *props)
{
GObject *obj;
GabbleBytestreamMultiplePrivate *priv;
TpHandleRepoIface *contact_repo;
const gchar *jid;
obj = G_OBJECT_CLASS (gabble_bytestream_multiple_parent_class)->
constructor (type, n_props, props);
priv = GABBLE_BYTESTREAM_MULTIPLE_GET_PRIVATE (
GABBLE_BYTESTREAM_MULTIPLE (obj));
g_assert (priv->conn != NULL);
g_assert (priv->peer_handle != 0);
g_assert (priv->stream_id != NULL);
contact_repo = tp_base_connection_get_handles (
(TpBaseConnection *) priv->conn, TP_HANDLE_TYPE_CONTACT);
jid = tp_handle_inspect (contact_repo, priv->peer_handle);
if (priv->peer_resource != NULL)
priv->peer_jid = g_strdup_printf ("%s/%s", jid, priv->peer_resource);
else
priv->peer_jid = g_strdup (jid);
g_assert (priv->self_full_jid != NULL);
return obj;
}
/*
* get_channel_for_incoming_message:
* @self: a factory
* @jid: a contact's JID
* @create_if_missing: if %TRUE, a new channel will be created if there is no
* existing channel to @jid
*
* Retrieves a 1-1 text channel to a particular contact. If no channel is open
* to @jid, it will be created only if @create_if_missing is %TRUE. If @jid is
* not of the form 'user@domain' (optionally with a resource), no channel will
* be opened.
*
* Returns: an IM channel to @jid, or %NULL
*/
static GabbleIMChannel *
get_channel_for_incoming_message (
GabbleImFactory *self,
const gchar *jid,
gboolean create_if_missing)
{
GabbleImFactoryPrivate *priv = self->priv;
TpBaseConnection *conn = (TpBaseConnection *) priv->conn;
TpHandleRepoIface *contact_repo = tp_base_connection_get_handles (conn,
TP_HANDLE_TYPE_CONTACT);
TpHandle handle;
GabbleIMChannel *chan;
g_return_val_if_fail (jid != NULL, NULL);
handle = tp_handle_ensure (contact_repo, jid, NULL, NULL);
if (handle == 0)
return NULL;
chan = g_hash_table_lookup (priv->channels, GUINT_TO_POINTER (handle));
if (chan != NULL)
return chan;
else if (create_if_missing)
return new_im_channel (self, handle, NULL);
else
return NULL;
}
static void
location_pep_node_changed (WockyPepService *pep,
WockyBareContact *contact,
WockyStanza *stanza,
GabbleConnection *conn)
{
TpHandleRepoIface *contact_repo = tp_base_connection_get_handles (
(TpBaseConnection *) conn, TP_HANDLE_TYPE_CONTACT);
TpBaseConnection *base = (TpBaseConnection *) conn;
TpHandle handle;
const gchar *jid;
jid = wocky_bare_contact_get_jid (contact);
handle = tp_handle_ensure (contact_repo, jid, NULL, NULL);
if (handle == 0)
{
DEBUG ("Invalid from: %s", jid);
return;
}
if (handle == base->self_handle)
/* Ignore echoed pubsub notifications */
goto out;
update_location_from_msg (conn, handle, stanza);
out:
tp_handle_unref (contact_repo, handle);
}
static GObject *
constructor (GType type,
guint n_props,
GObjectConstructParam *props)
{
GObject *object =
G_OBJECT_CLASS (example_echo_channel_parent_class)->constructor (type,
n_props, props);
ExampleEchoChannel *self = EXAMPLE_ECHO_CHANNEL (object);
TpHandleRepoIface *contact_repo = tp_base_connection_get_handles
(self->priv->conn, TP_HANDLE_TYPE_CONTACT);
tp_dbus_daemon_register_object (
tp_base_connection_get_dbus_daemon (self->priv->conn),
self->priv->object_path, self);
tp_text_mixin_init (object, G_STRUCT_OFFSET (ExampleEchoChannel, text),
contact_repo);
tp_text_mixin_set_message_types (object,
TP_CHANNEL_TEXT_MESSAGE_TYPE_NORMAL,
TP_CHANNEL_TEXT_MESSAGE_TYPE_ACTION,
TP_CHANNEL_TEXT_MESSAGE_TYPE_NOTICE,
G_MAXUINT);
return object;
}
static RingTextChannel *
get_text_channel(RingTextManager *self,
char const *address,
gboolean class0,
gboolean self_invoked)
{
TpHandleRepoIface *repo;
RingTextChannel *channel = NULL;
TpHandle handle, initiator;
GError *error = NULL;
g_return_val_if_fail (address != NULL, NULL);
repo = tp_base_connection_get_handles(
(TpBaseConnection *)self->priv->connection, TP_HANDLE_TYPE_CONTACT);
error = NULL;
handle = tp_handle_ensure(repo, address,
ring_network_normalization_context(), &error);
if (handle == 0) {
DEBUG("tp_handle_ensure: %s: %s (%d@%s)", address, GERROR_MSG_CODE(error));
g_clear_error(&error);
/* Xyzzy */
return NULL;
}
initiator = self_invoked ? self->priv->connection->parent.self_handle : handle;
channel = ring_text_manager_request(self, NULL, initiator, handle, 0, class0);
if (channel == NULL)
tp_handle_unref(repo, handle);
return channel;
}
static void
constructed (GObject *object)
{
ExampleCallStream *self = EXAMPLE_CALL_STREAM (object);
void (*chain_up) (GObject *) =
((GObjectClass *) example_call_stream_parent_class)->constructed;
if (chain_up != NULL)
chain_up (object);
tp_dbus_daemon_register_object (
tp_base_connection_get_dbus_daemon (self->priv->conn),
self->priv->object_path, self);
if (self->priv->locally_requested)
{
example_call_stream_change_direction (self, TRUE, TRUE);
}
else
{
example_call_stream_receive_direction_request (self, TRUE, TRUE);
}
if (self->priv->handle != 0)
{
TpHandleRepoIface *contact_repo = tp_base_connection_get_handles (
self->priv->conn, TP_HANDLE_TYPE_CONTACT);
tp_handle_ref (contact_repo, self->priv->handle);
}
}
static void
location_request_location (
TpSvcConnectionInterfaceLocation *iface,
TpHandle handle,
DBusGMethodInvocation *context)
{
GabbleConnection *self = GABBLE_CONNECTION (iface);
TpBaseConnection *base = (TpBaseConnection *) self;
TpHandleRepoIface *contact_handles = tp_base_connection_get_handles (base,
TP_HANDLE_TYPE_CONTACT);
const gchar *jid;
WockyBareContact *contact;
YetAnotherContextStruct *ctx;
GError *error = NULL;
if (!tp_handle_is_valid (contact_handles, handle, &error))
{
dbus_g_method_return_error (context, error);
g_error_free (error);
return;
}
/* Oh! for GDBus. */
ctx = g_slice_new (YetAnotherContextStruct);
ctx->self = g_object_ref (self);
ctx->handle = handle;
ctx->context = context;
jid = tp_handle_inspect (contact_handles, handle);
contact = ensure_bare_contact_from_jid (self, jid);
DEBUG ("fetching location for '%s'", jid);
wocky_pep_service_get_async (self->pep_location, contact, NULL,
request_location_reply_cb, ctx);
g_object_unref (contact);
}
static gboolean
add_member (GObject *object,
TpHandle member,
const gchar *message,
GError **error)
{
ExampleCallableMediaChannel *self = EXAMPLE_CALLABLE_MEDIA_CHANNEL (object);
TpHandleRepoIface *contact_repo = tp_base_connection_get_handles
(self->priv->conn, TP_HANDLE_TYPE_CONTACT);
/* In connection managers that supported the RequestChannel method for
* streamed media channels, it would be necessary to support adding the
* called contact to the members of an outgoing call. However, in this
* legacy-free example, we don't support that usage, so the only use for
* AddMembers is to accept an incoming call.
*/
if (member == self->group.self_handle &&
tp_handle_set_is_member (self->group.local_pending, member))
{
/* We're in local-pending, move to members to accept. */
TpIntSet *set = tp_intset_new_containing (member);
GHashTableIter iter;
gpointer v;
g_assert (self->priv->progress == PROGRESS_CALLING);
g_message ("SIGNALLING: send: Accepting incoming call from %s",
tp_handle_inspect (contact_repo, self->priv->handle));
self->priv->progress = PROGRESS_ACTIVE;
tp_group_mixin_change_members (object, "",
set /* added */,
NULL /* nobody removed */,
NULL /* nobody added to local pending */,
NULL /* nobody added to remote pending */,
member /* actor */, TP_CHANNEL_GROUP_CHANGE_REASON_NONE);
tp_intset_destroy (set);
g_hash_table_iter_init (&iter, self->priv->streams);
while (g_hash_table_iter_next (&iter, NULL, &v))
{
/* we accept the proposed stream direction... */
example_callable_media_stream_accept_proposed_direction (v);
/* ... and the stream tries to connect */
example_callable_media_stream_connect (v);
}
return TRUE;
}
/* Otherwise it's a meaningless request, so reject it. */
g_set_error (error, TP_ERRORS, TP_ERROR_NOT_AVAILABLE,
"Cannot add handle %u to channel", member);
return FALSE;
}
static void
get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
TpTestsTextChannelGroup *self = TP_TESTS_TEXT_CHANNEL_GROUP (object);
switch (property_id)
{
case PROP_OBJECT_PATH:
g_value_set_string (value, self->priv->object_path);
break;
case PROP_CHANNEL_TYPE:
g_value_set_static_string (value, TP_IFACE_CHANNEL_TYPE_TEXT);
break;
case PROP_HANDLE_TYPE:
g_value_set_uint (value, TP_HANDLE_TYPE_NONE);
break;
case PROP_HANDLE:
g_value_set_uint (value, 0);
break;
case PROP_TARGET_ID:
g_value_set_static_string (value, "");
break;
case PROP_REQUESTED:
g_value_set_boolean (value, TRUE);
break;
case PROP_INITIATOR_HANDLE:
g_value_set_uint (value, self->conn->self_handle);
break;
case PROP_INITIATOR_ID:
{
TpHandleRepoIface *contact_repo = tp_base_connection_get_handles (
self->conn, TP_HANDLE_TYPE_CONTACT);
g_value_set_string (value,
tp_handle_inspect (contact_repo, self->conn->self_handle));
}
break;
case PROP_INTERFACES:
g_value_set_boxed (value, text_channel_group_interfaces);
break;
case PROP_CONNECTION:
g_value_set_object (value, self->conn);
break;
case PROP_DETAILED:
g_value_set_boolean (value, self->priv->detailed);
break;
case PROP_PROPERTIES:
g_value_set_boolean (value, self->priv->properties);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
const gchar *
conn_util_get_bare_self_jid (GabbleConnection *conn)
{
TpBaseConnection *base = TP_BASE_CONNECTION (conn);
TpHandleRepoIface *contact_handles = tp_base_connection_get_handles (base,
TP_HANDLE_TYPE_CONTACT);
TpHandle self = tp_base_connection_get_self_handle (base);
return tp_handle_inspect (contact_handles, self);
}
static void
finalize (GObject *object)
{
ExampleContactListBase *self = EXAMPLE_CONTACT_LIST_BASE (object);
TpHandleRepoIface *handle_repo = tp_base_connection_get_handles
(self->priv->conn, self->priv->handle_type);
tp_handle_unref (handle_repo, self->priv->handle);
g_free (self->priv->object_path);
tp_group_mixin_finalize (object);
((GObjectClass *) example_contact_list_base_parent_class)->finalize (object);
}
gchar *
tp_tests_simple_connection_ensure_text_chan (TpTestsSimpleConnection *self,
const gchar *target_id,
GHashTable **props)
{
TpTestsTextChannelNull *chan;
gchar *chan_path;
TpHandleRepoIface *contact_repo;
TpHandle handle;
static guint count = 0;
TpBaseConnection *base_conn = (TpBaseConnection *) self;
/* Get contact handle */
contact_repo = tp_base_connection_get_handles (base_conn,
TP_HANDLE_TYPE_CONTACT);
g_assert (contact_repo != NULL);
handle = tp_handle_ensure (contact_repo, target_id, NULL, NULL);
chan = g_hash_table_lookup (self->priv->channels, GUINT_TO_POINTER (handle));
if (chan != NULL)
{
/* Channel already exist, reuse it */
g_object_get (chan, "object-path", &chan_path, NULL);
}
else
{
chan_path = g_strdup_printf ("%s/Channel%u", base_conn->object_path,
count++);
chan = TP_TESTS_TEXT_CHANNEL_NULL (
tp_tests_object_new_static_class (
TP_TESTS_TYPE_TEXT_CHANNEL_NULL,
"connection", self,
"object-path", chan_path,
"handle", handle,
NULL));
g_hash_table_insert (self->priv->channels, GUINT_TO_POINTER (handle),
chan);
}
tp_handle_unref (contact_repo, handle);
if (props != NULL)
*props = tp_tests_text_channel_get_props (chan);
return chan_path;
}
void
tp_tests_simple_connection_set_identifier (TpTestsSimpleConnection *self,
const gchar *identifier)
{
TpBaseConnection *conn = (TpBaseConnection *) self;
TpHandleRepoIface *contact_repo = tp_base_connection_get_handles (conn,
TP_HANDLE_TYPE_CONTACT);
TpHandle handle = tp_handle_ensure (contact_repo, identifier, NULL, NULL);
/* if this fails then the identifier was bad - caller error */
g_return_if_fail (handle != 0);
tp_base_connection_set_self_handle (conn, handle);
tp_handle_unref (contact_repo, handle);
}
static void
finalize (GObject *object)
{
ExampleCallableMediaChannel *self = EXAMPLE_CALLABLE_MEDIA_CHANNEL (object);
TpHandleRepoIface *contact_handles = tp_base_connection_get_handles
(self->priv->conn, TP_HANDLE_TYPE_CONTACT);
tp_handle_unref (contact_handles, self->priv->handle);
tp_handle_unref (contact_handles, self->priv->initiator);
g_free (self->priv->object_path);
tp_group_mixin_finalize (object);
((GObjectClass *) example_callable_media_channel_parent_class)->finalize (object);
}
static void
location_get_locations (TpSvcConnectionInterfaceLocation *iface,
const GArray *contacts,
DBusGMethodInvocation *context)
{
GabbleConnection *conn = GABBLE_CONNECTION (iface);
TpBaseConnection *base = (TpBaseConnection *) conn;
TpHandleRepoIface *contact_handles;
guint i;
GError *error = NULL;
GHashTable *return_locations = g_hash_table_new_full (g_direct_hash,
g_direct_equal, NULL, (GDestroyNotify) g_hash_table_unref);
DEBUG ("GetLocation for contacts:");
gabble_connection_ensure_capabilities (conn,
gabble_capabilities_get_geoloc_notify ());
/* Validate contacts */
contact_handles = tp_base_connection_get_handles (base,
TP_HANDLE_TYPE_CONTACT);
if (!tp_handles_are_valid (contact_handles, contacts, TRUE, &error))
{
dbus_g_method_return_error (context, error);
g_error_free (error);
g_hash_table_unref (return_locations);
return;
}
for (i = 0; i < contacts->len; i++)
{
TpHandle contact = g_array_index (contacts, TpHandle, i);
GHashTable *location = get_cached_location (conn, contact);
if (location != NULL)
g_hash_table_insert (return_locations, GUINT_TO_POINTER (contact),
location);
}
tp_svc_connection_interface_location_return_from_get_locations
(context, return_locations);
g_hash_table_unref (return_locations);
}
static gboolean
pretend_connected (gpointer data)
{
TpTestsSimpleConnection *self = TP_TESTS_SIMPLE_CONNECTION (data);
TpBaseConnection *conn = (TpBaseConnection *) self;
TpHandleRepoIface *contact_repo = tp_base_connection_get_handles (conn,
TP_HANDLE_TYPE_CONTACT);
conn->self_handle = tp_handle_ensure (contact_repo, self->priv->account,
NULL, NULL);
if (conn->status == TP_CONNECTION_STATUS_CONNECTING)
{
tp_base_connection_change_status (conn, TP_CONNECTION_STATUS_CONNECTED,
TP_CONNECTION_STATUS_REASON_REQUESTED);
}
self->priv->connect_source = 0;
return FALSE;
}
static IdleIMChannel *
_im_manager_new_channel (IdleIMManager *mgr,
TpHandle handle,
TpHandle initiator,
gpointer request)
{
IdleIMManagerPrivate *priv = IDLE_IM_MANAGER_GET_PRIVATE (mgr);
TpBaseConnection *base_connection = TP_BASE_CONNECTION (priv->conn);
TpHandleRepoIface *handle_repo =
tp_base_connection_get_handles (base_connection, TP_HANDLE_TYPE_CONTACT);
IdleIMChannel *chan;
const gchar *name;
GSList *requests = NULL;
g_assert (g_hash_table_lookup (priv->channels, GUINT_TO_POINTER (handle))
== NULL);
name = tp_handle_inspect (handle_repo, handle);
IDLE_DEBUG ("Requested channel for handle: %u (%s)", handle, name);
chan = g_object_new (IDLE_TYPE_IM_CHANNEL,
"connection", priv->conn,
"handle", handle,
"initiator-handle", initiator,
"requested", handle != initiator,
NULL);
tp_base_channel_register (TP_BASE_CHANNEL (chan));
g_hash_table_insert (priv->channels, GUINT_TO_POINTER (handle), chan);
if (request != NULL)
requests = g_slist_prepend (requests, request);
tp_channel_manager_emit_new_channel (mgr, TP_EXPORTABLE_CHANNEL (chan),
requests);
g_slist_free (requests);
g_signal_connect (chan, "closed", G_CALLBACK (_im_channel_closed_cb), mgr);
return chan;
}
static void
request_aliases (TpSvcConnectionInterfaceAliasing *aliasing,
const GArray *contacts,
DBusGMethodInvocation *context)
{
ExampleContactListConnection *self =
EXAMPLE_CONTACT_LIST_CONNECTION (aliasing);
TpBaseConnection *base = TP_BASE_CONNECTION (aliasing);
TpHandleRepoIface *contact_repo = tp_base_connection_get_handles (base,
TP_HANDLE_TYPE_CONTACT);
GPtrArray *result;
gchar **strings;
GError *error = NULL;
guint i;
TP_BASE_CONNECTION_ERROR_IF_NOT_CONNECTED (base, context);
if (!tp_handles_are_valid (contact_repo, contacts, FALSE, &error))
{
dbus_g_method_return_error (context, error);
g_error_free (error);
return;
}
result = g_ptr_array_sized_new (contacts->len + 1);
for (i = 0; i < contacts->len; i++)
{
TpHandle contact = g_array_index (contacts, TpHandle, i);
const gchar *alias = example_contact_list_manager_get_alias (
self->priv->list_manager, contact);
g_ptr_array_add (result, (gchar *) alias);
}
g_ptr_array_add (result, NULL);
strings = (gchar **) g_ptr_array_free (result, FALSE);
tp_svc_connection_interface_aliasing_return_from_request_aliases (context,
(const gchar **) strings);
g_free (strings);
}
/*
* get_cached_location:
* @conn: a connection
* @handle: a handle, which must have been pre-validated.
*
* Returns: a new ref to a GHashTable containing @handle's location, or %NULL
* if we have no cached location.
*/
static GHashTable *
get_cached_location (GabbleConnection *conn,
TpHandle handle)
{
TpBaseConnection *base = (TpBaseConnection *) conn;
GHashTable *location;
const gchar *jid;
TpHandleRepoIface *contact_repo;
contact_repo = tp_base_connection_get_handles (base, TP_HANDLE_TYPE_CONTACT);
jid = tp_handle_inspect (contact_repo, handle);
location = gabble_presence_cache_get_location (conn->presence_cache, handle);
if (location != NULL)
DEBUG (" - %s: cached", jid);
else
DEBUG (" - %s: unknown", jid);
return location;
}
static gboolean
simulate_incoming_call_cb (gpointer p)
{
ExampleCallManager *self = p;
TpHandleRepoIface *contact_repo;
TpHandle caller;
/* do nothing if we've been disconnected while waiting for the contact to
* call us */
if (self->priv->available_id == 0)
return FALSE;
/* We're called by someone whose ID on the IM service is "caller" */
contact_repo = tp_base_connection_get_handles (self->priv->conn,
TP_HANDLE_TYPE_CONTACT);
caller = tp_handle_ensure (contact_repo, "caller", NULL, NULL);
new_channel (self, caller, caller, NULL, TRUE, FALSE);
return FALSE;
}
static void
tp_contacts_mixin_get_contact_by_id_impl (
TpSvcConnectionInterfaceContacts *iface,
const gchar *id,
const gchar **interfaces,
DBusGMethodInvocation *context)
{
TpBaseConnection *conn = TP_BASE_CONNECTION (iface);
TpHandleRepoIface *contact_repo = tp_base_connection_get_handles (conn,
TP_HANDLE_TYPE_CONTACT);
GetContactByIdData *data;
TP_BASE_CONNECTION_ERROR_IF_NOT_CONNECTED (conn, context);
data = g_slice_new0 (GetContactByIdData);
data->conn = g_object_ref (conn);
data->interfaces = g_strdupv ((gchar **) interfaces);
data->context = context;
tp_handle_ensure_async (contact_repo, conn, id, NULL,
ensure_handle_cb, data);
}
static void
get_aliases (TpSvcConnectionInterfaceAliasing *aliasing,
const GArray *contacts,
DBusGMethodInvocation *context)
{
ExampleContactListConnection *self =
EXAMPLE_CONTACT_LIST_CONNECTION (aliasing);
TpBaseConnection *base = TP_BASE_CONNECTION (aliasing);
TpHandleRepoIface *contact_repo = tp_base_connection_get_handles (base,
TP_HANDLE_TYPE_CONTACT);
GHashTable *result;
GError *error = NULL;
guint i;
TP_BASE_CONNECTION_ERROR_IF_NOT_CONNECTED (base, context);
if (!tp_handles_are_valid (contact_repo, contacts, FALSE, &error))
{
dbus_g_method_return_error (context, error);
g_error_free (error);
return;
}
result = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL, NULL);
for (i = 0; i < contacts->len; i++)
{
TpHandle contact = g_array_index (contacts, TpHandle, i);
const gchar *alias = example_contact_list_manager_get_alias (
self->priv->list_manager, contact);
g_hash_table_insert (result, GUINT_TO_POINTER (contact),
(gchar *) alias);
}
tp_svc_connection_interface_aliasing_return_from_get_aliases (context,
result);
g_hash_table_destroy (result);
}
static GObject *
constructor (GType type,
guint n_props,
GObjectConstructParam *props)
{
GObject *object =
G_OBJECT_CLASS (tp_tests_text_channel_group_parent_class)->constructor (type,
n_props, props);
TpTestsTextChannelGroup *self = TP_TESTS_TEXT_CHANNEL_GROUP (object);
TpHandleRepoIface *contact_repo = tp_base_connection_get_handles
(self->conn, TP_HANDLE_TYPE_CONTACT);
TpChannelGroupFlags flags = 0;
tp_dbus_daemon_register_object (
tp_base_connection_get_dbus_daemon (self->conn),
self->priv->object_path, self);
tp_text_mixin_init (object, G_STRUCT_OFFSET (TpTestsTextChannelGroup, text),
contact_repo);
tp_text_mixin_set_message_types (object,
TP_CHANNEL_TEXT_MESSAGE_TYPE_NORMAL,
TP_CHANNEL_TEXT_MESSAGE_TYPE_ACTION,
TP_CHANNEL_TEXT_MESSAGE_TYPE_NOTICE,
G_MAXUINT);
if (self->priv->detailed)
flags |= TP_CHANNEL_GROUP_FLAG_MEMBERS_CHANGED_DETAILED;
if (self->priv->properties)
flags |= TP_CHANNEL_GROUP_FLAG_PROPERTIES;
tp_group_mixin_init (object, G_STRUCT_OFFSET (TpTestsTextChannelGroup, group),
contact_repo, self->conn->self_handle);
tp_group_mixin_change_flags (object, flags, 0);
return object;
}
static void
set_aliases (TpSvcConnectionInterfaceAliasing *aliasing,
GHashTable *aliases,
DBusGMethodInvocation *context)
{
ExampleContactListConnection *self =
EXAMPLE_CONTACT_LIST_CONNECTION (aliasing);
TpBaseConnection *base = TP_BASE_CONNECTION (aliasing);
TpHandleRepoIface *contact_repo = tp_base_connection_get_handles (base,
TP_HANDLE_TYPE_CONTACT);
GHashTableIter iter;
gpointer key, value;
g_hash_table_iter_init (&iter, aliases);
while (g_hash_table_iter_next (&iter, &key, &value))
{
GError *error = NULL;
if (!tp_handle_is_valid (contact_repo, GPOINTER_TO_UINT (key),
&error))
{
dbus_g_method_return_error (context, error);
g_error_free (error);
return;
}
}
g_hash_table_iter_init (&iter, aliases);
while (g_hash_table_iter_next (&iter, &key, &value))
{
example_contact_list_manager_set_alias (self->priv->list_manager,
GPOINTER_TO_UINT (key), value);
}
tp_svc_connection_interface_aliasing_return_from_set_aliases (context);
}
static void
dispose (GObject *object)
{
ExampleCallStream *self = EXAMPLE_CALL_STREAM (object);
TpHandleRepoIface *contact_repo = tp_base_connection_get_handles (
self->priv->conn, TP_HANDLE_TYPE_CONTACT);
example_call_stream_close (self);
if (self->priv->handle != 0)
{
tp_handle_unref (contact_repo, self->priv->handle);
self->priv->handle = 0;
}
if (self->priv->conn != NULL)
{
g_object_unref (self->priv->conn);
self->priv->conn = NULL;
}
((GObjectClass *) example_call_stream_parent_class)->dispose (object);
}
static gboolean
start_connecting (TpBaseConnection *conn,
GError **error)
{
ExampleContactListConnection *self = EXAMPLE_CONTACT_LIST_CONNECTION (conn);
TpHandleRepoIface *contact_repo = tp_base_connection_get_handles (conn,
TP_HANDLE_TYPE_CONTACT);
/* In a real connection manager we'd ask the underlying implementation to
* start connecting, then go to state CONNECTED when finished, but here
* we can do it immediately. */
conn->self_handle = tp_handle_ensure (contact_repo, self->priv->account,
NULL, error);
if (conn->self_handle == 0)
return FALSE;
tp_base_connection_change_status (conn, TP_CONNECTION_STATUS_CONNECTED,
TP_CONNECTION_STATUS_REASON_REQUESTED);
return TRUE;
}
static void
on_modem_call_incoming(ModemCallService *call_service,
ModemCall *modem_call,
char const *originator,
RingMediaManager *self)
{
RingMediaManagerPrivate *priv = self->priv;
TpHandleRepoIface *repo;
RingCallChannel *channel;
TpHandle handle;
GError *error = NULL;
if (!ring_media_manager_is_connected (self))
return;
channel = modem_call_get_handler(modem_call);
if (channel) {
modem_call_set_handler(modem_call, NULL);
ring_critical("Call instance %s already associated with channel.",
modem_call_get_name(modem_call));
ring_critical("Closing old channel %s.", RING_MEDIA_CHANNEL(channel)->nick);
ring_media_channel_close(RING_MEDIA_CHANNEL(channel));
}
repo = tp_base_connection_get_handles(
(TpBaseConnection *)(self->priv->connection), TP_HANDLE_TYPE_CONTACT);
error = NULL;
handle = tp_handle_ensure(repo, originator,
ring_network_normalization_context(), &error);
if (handle == 0) {
DEBUG("tp_handle_ensure:" GERROR_MSG_FMT, GERROR_MSG_CODE(error));
if (error) g_error_free(error);
/* Xyzzy - modem_call_request_release() ?? */
return;
}
/* Incoming call - pass call and handle ownership to new media channel */
char *object_path = ring_media_manager_new_object_path(self, "incoming");
channel = (RingCallChannel *)
g_object_new(RING_TYPE_CALL_CHANNEL,
"connection", priv->connection,
"tones", priv->tones,
"object-path", object_path,
"initiator-handle", handle,
"handle-type", TP_HANDLE_TYPE_CONTACT,
"handle", handle,
"peer", handle,
"requested", FALSE,
"initial-audio", TRUE,
"anon-modes", priv->anon_modes,
"call-instance", modem_call,
"terminating", TRUE,
NULL);
g_free(object_path);
ring_media_manager_emit_new_channel(self, NULL, channel, NULL);
ring_media_channel_set_state(RING_MEDIA_CHANNEL(channel),
MODEM_CALL_STATE_INCOMING, 0, 0);
}
static void
on_modem_call_created(ModemCallService *call_service,
ModemCall *modem_call,
char const *destination,
RingMediaManager *self)
{
RingMediaManagerPrivate *priv = self->priv;
TpHandleRepoIface *repo;
RingCallChannel *channel;
TpHandle handle;
char const *sos;
GError *error = NULL;
if (!ring_media_manager_is_connected (self))
return;
channel = modem_call_get_handler(modem_call);
if (channel)
return; /* Call created by ring, nothing to do */
/* This is a call created outside ring, create a channel for it */
DEBUG("Freshly created call instance %s not associated with channel.",
modem_call_get_name(modem_call));
repo = tp_base_connection_get_handles(
(TpBaseConnection *)(self->priv->connection), TP_HANDLE_TYPE_CONTACT);
error = NULL;
handle = tp_handle_ensure(repo, destination,
ring_network_normalization_context(), &error);
if (handle == 0) {
ring_warning("tp_handle_ensure:" GERROR_MSG_FMT, GERROR_MSG_CODE(error));
if (error) g_error_free(error);
/* Xyzzy - modem_call_request_release() ?? */
return;
}
sos = modem_call_get_emergency_service(priv->call_service, destination);
char *object_path = ring_media_manager_new_object_path(self, "created");
channel = (RingCallChannel *)
g_object_new(RING_TYPE_CALL_CHANNEL,
"connection", priv->connection,
"tones", priv->tones,
"object-path", object_path,
"initiator-handle", tp_base_connection_get_self_handle(
TP_BASE_CONNECTION(priv->connection)),
"handle-type", TP_HANDLE_TYPE_CONTACT,
"handle", handle,
"peer", handle,
"requested", TRUE,
"initial-remote", handle,
"initial-audio", TRUE,
"anon-modes", priv->anon_modes,
"call-instance", modem_call,
"originating", TRUE,
sos ? "initial-emergency-service" : NULL, sos,
NULL);
g_free(object_path);
ring_media_manager_emit_new_channel(self, NULL, channel, NULL);
ring_media_channel_set_state(RING_MEDIA_CHANNEL(channel),
MODEM_CALL_STATE_DIALING, 0, 0);
}
static gboolean
update_location_from_msg (GabbleConnection *conn,
TpHandle contact,
LmMessage *msg)
{
LmMessageNode *node;
GHashTable *location = g_hash_table_new_full (g_direct_hash, g_direct_equal,
g_free, (GDestroyNotify) tp_g_value_slice_free);
TpHandleRepoIface *contact_repo = tp_base_connection_get_handles (
(TpBaseConnection *) conn, TP_HANDLE_TYPE_CONTACT);
const gchar *from = tp_handle_inspect (contact_repo, contact);
NodeIter i;
const gchar *lang;
node = lm_message_node_find_child (wocky_stanza_get_top_node (msg),
"geoloc");
if (node == NULL)
return FALSE;
DEBUG ("LocationsUpdate for %s:", from);
lang = lm_message_node_get_attribute (node, "xml:lang");
if (lang != NULL)
{
g_hash_table_insert (location, g_strdup ("language"),
tp_g_value_slice_new_string (lang));
}
build_mapping_tables ();
for (i = node_iter (node); i; i = node_iter_next (i))
{
LmMessageNode *subloc_node = node_iter_data (i);
GValue *value = NULL;
gchar *xmpp_name;
const gchar *str;
LocationMapping *mapping;
xmpp_name = subloc_node->name;
str = lm_message_node_get_value (subloc_node);
if (str == NULL)
continue;
mapping = g_hash_table_lookup (xmpp_to_tp, xmpp_name);
if (mapping == NULL)
{
DEBUG ("Unknown location attribute: %s\n", xmpp_name);
continue;
}
if (mapping->type == G_TYPE_DOUBLE)
{
gdouble double_value;
gchar *end;
double_value = g_ascii_strtod (str, &end);
if (end == str)
continue;
value = tp_g_value_slice_new_double (double_value);
DEBUG ("\t - %s: %f", xmpp_name, double_value);
}
else if (strcmp (xmpp_name, "timestamp") == 0)
{
GTimeVal timeval;
if (g_time_val_from_iso8601 (str, &timeval))
{
value = tp_g_value_slice_new_int64 (timeval.tv_sec);
DEBUG ("\t - %s: %s", xmpp_name, str);
}
else
{
DEBUG ("\t - %s: %s: unknown date format", xmpp_name, str);
continue;
}
}
else if (mapping->type == G_TYPE_STRING)
{
value = tp_g_value_slice_new_string (str);
DEBUG ("\t - %s: %s", xmpp_name, str);
}
else
{
g_assert_not_reached ();
}
g_hash_table_insert (location, g_strdup (mapping->tp_name), value);
}
tp_svc_connection_interface_location_emit_location_updated (conn,
contact, location);
gabble_presence_cache_update_location (conn->presence_cache, contact,
location);
return TRUE;
}