/*
* 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 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;
}
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);
}
TpHandle
gabble_ensure_handle_from_uri (TpHandleRepoIface *repo,
const gchar *uri,
GError **error)
{
TpHandle handle;
gchar *jid = gabble_uri_to_jid (uri, error);
if (jid == NULL)
return 0;
handle = tp_handle_ensure (repo, jid, NULL, error);
g_free (jid);
return handle;
}
TpHandle
gabble_ensure_handle_from_vcard_address (TpHandleRepoIface *repo,
const gchar *vcard_field,
const gchar *vcard_address,
GError **error)
{
gchar *normalized_jid;
TpHandle handle;
normalized_jid = gabble_vcard_address_to_jid (vcard_field, vcard_address, error);
if (normalized_jid == NULL)
return 0;
handle = tp_handle_ensure (repo, normalized_jid, NULL, error);
g_free (normalized_jid);
return handle;
}
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 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 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 _parse_atom(IdleParser *parser, GValueArray *arr, char atom, const gchar *token, TpHandleSet *contact_reffed, TpHandleSet *room_reffed) {
IdleParserPrivate *priv = IDLE_PARSER_GET_PRIVATE(parser);
TpHandle handle;
GValue val = {0};
TpHandleRepoIface *contact_repo = tp_base_connection_get_handles(TP_BASE_CONNECTION(priv->conn), TP_HANDLE_TYPE_CONTACT);
TpHandleRepoIface *room_repo = tp_base_connection_get_handles(TP_BASE_CONNECTION(priv->conn), TP_HANDLE_TYPE_ROOM);
if (token[0] == ':')
token++;
IDLE_DEBUG("parsing atom \"%s\" as %c", token, atom);
switch (atom) {
case 'I':
IDLE_DEBUG("ignored token");
return TRUE;
break;
case 'c':
case 'r':
case 'C': {
gchar *id, *bang = NULL;
gchar modechar = '\0';
if (idle_muc_channel_is_modechar(token[0])) {
modechar = token[0];
token++;
}
id = g_strdup(token);
if (atom != 'r') {
bang = strchr(id, '!');
if (bang)
*bang = '\0';
}
if (atom == 'r') {
if ((handle = tp_handle_ensure(room_repo, id, NULL, NULL))) {
tp_handle_set_add(room_reffed, handle);
}
} else {
if ((handle = tp_handle_ensure(contact_repo, id, NULL, NULL))) {
tp_handle_set_add(contact_reffed, handle);
idle_connection_canon_nick_receive(priv->conn, handle, id);
}
}
g_free(id);
if (!handle)
return FALSE;
g_value_init(&val, G_TYPE_UINT);
g_value_set_uint(&val, handle);
g_value_array_append(arr, &val);
g_value_unset(&val);
IDLE_DEBUG("set handle %u", handle);
if (atom == 'C') {
g_value_init(&val, G_TYPE_CHAR);
g_value_set_schar(&val, modechar);
g_value_array_append(arr, &val);
g_value_unset(&val);
IDLE_DEBUG("set modechar %c", modechar);
}
return TRUE;
}
break;
case 'd': {
guint dval;
if (sscanf(token, "%d", &dval)) {
g_value_init(&val, G_TYPE_UINT);
g_value_set_uint(&val, dval);
g_value_array_append(arr, &val);
g_value_unset(&val);
IDLE_DEBUG("set int %d", dval);
return TRUE;
} else {
return FALSE;
}
}
break;
case 's':
g_value_init(&val, G_TYPE_STRING);
g_value_set_string(&val, token);
g_value_array_append(arr, &val);
g_value_unset(&val);
IDLE_DEBUG("set string \"%s\"", token);
return TRUE;
break;
default:
IDLE_DEBUG("unknown atom %c", atom);
return FALSE;
break;
}
}
