static GObject *
constructor (GType type,
guint n_props,
GObjectConstructParam *props)
{
GObject *object =
G_OBJECT_CLASS (fetion_im_channel_parent_class)->constructor (type,
n_props, props);
FetionImChannel *self = FETION_IM_CHANNEL (object);
TpBaseChannel *base = TP_BASE_CHANNEL (self);
static TpChannelTextMessageType const types[] = {
TP_CHANNEL_TEXT_MESSAGE_TYPE_NORMAL,
TP_CHANNEL_TEXT_MESSAGE_TYPE_ACTION,
TP_CHANNEL_TEXT_MESSAGE_TYPE_NOTICE
};
static const char * const content_types[] = { "text/plain", NULL };
tp_base_channel_register (base);
tp_message_mixin_init (object, G_STRUCT_OFFSET (FetionImChannel, text),
tp_base_channel_get_connection (base));
tp_message_mixin_implement_sending (object, send_message,
G_N_ELEMENTS (types), types,0,
TP_DELIVERY_REPORTING_SUPPORT_FLAG_RECEIVE_FAILURES,
content_types);
return object;
}
static void
lwqq_channel_init (LwqqChannel *self)
{
LwqqChannelPrivate *priv;
priv = LWQQ_CHANNEL_GET_PRIVATE (self);
self->priv = priv;
TpBaseChannel* base = TP_BASE_CHANNEL(self);
GObject* obj = G_OBJECT(self);
static TpChannelTextMessageType const types[] = {
TP_CHANNEL_TEXT_MESSAGE_TYPE_NORMAL
};
static const char* const content_types[] = {"text/plain", NULL};
tp_base_channel_register(base);
tp_message_mixin_init(G_OBJECT(self), G_STRUCT_OFFSET(LwqqChannel, text),
tp_base_channel_get_connection(base));
tp_message_mixin_implement_sending(obj, send_message, G_N_ELEMENTS(types),
types, 0, TP_DELIVERY_REPORTING_SUPPORT_FLAG_RECEIVE_FAILURES,
content_types);
}
static void
tp_tests_room_list_chan_constructed (GObject *object)
{
TpTestsRoomListChan *self = TP_TESTS_ROOM_LIST_CHAN (object);
void (*chain_up) (GObject *) =
((GObjectClass *) tp_tests_room_list_chan_parent_class)->constructed;
if (chain_up != NULL)
chain_up (object);
tp_base_channel_register (TP_BASE_CHANNEL (self));
}
void
gabble_server_sasl_channel_start_auth_async (GabbleServerSaslChannel *self,
GAsyncReadyCallback callback,
gpointer user_data)
{
GabbleServerSaslChannelPrivate *priv = self->priv;
g_assert (priv->result == NULL);
g_assert (priv->sasl_status == TP_SASL_STATUS_NOT_STARTED);
DEBUG ("Starting authentication");
priv->result = g_simple_async_result_new (G_OBJECT (self), callback,
user_data, gabble_server_sasl_channel_start_auth_async);
tp_base_channel_register (TP_BASE_CHANNEL (self));
}
/*
* new_im_channel:
* @fac: the factory
* @handle: a contact handle, for whom a channel must not yet exist
* @request_token: if the channel is being created in response to a channel
* request, the associated request token; otherwise, NULL.
*
* Creates a new 1-1 text channel to a contact. Must only be called when no 1-1
* text channel is already open to that contact.
*
* Returns: (transfer none): a freshly-constructed channel
*/
static GabbleIMChannel *
new_im_channel (GabbleImFactory *fac,
TpHandle handle,
gpointer request_token)
{
GabbleImFactoryPrivate *priv = fac->priv;
TpBaseConnection *conn = (TpBaseConnection *) priv->conn;
GabbleIMChannel *chan;
GSList *request_tokens;
TpHandle initiator;
g_return_val_if_fail (handle != 0, NULL);
if (request_token != NULL)
initiator = tp_base_connection_get_self_handle (conn);
else
initiator = handle;
chan = g_object_new (GABBLE_TYPE_IM_CHANNEL,
"connection", priv->conn,
"handle", handle,
"initiator-handle", initiator,
"requested", (handle != initiator),
NULL);
tp_base_channel_register ((TpBaseChannel *) chan);
g_signal_connect (chan, "closed", (GCallback) im_channel_closed_cb, fac);
g_hash_table_insert (priv->channels, GUINT_TO_POINTER (handle), chan);
if (request_token != NULL)
request_tokens = g_slist_prepend (NULL, request_token);
else
request_tokens = NULL;
tp_channel_manager_emit_new_channel (fac,
(TpExportableChannel *) chan, request_tokens);
g_slist_free (request_tokens);
return chan;
}
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;
}
/**
* new_call_channel
*
* Creates a new empty RakiaCallChannel.
*/
static RakiaCallChannel *
new_call_channel (RakiaMediaManager *fac,
TpHandle initiator,
TpHandle maybe_peer,
GHashTable *request_properties,
RakiaSipSession *session)
{
RakiaMediaManagerPrivate *priv = RAKIA_MEDIA_MANAGER_GET_PRIVATE (fac);
RakiaCallChannel *chan = NULL;
gchar *object_path;
gboolean initial_audio = FALSE;
gboolean initial_video = FALSE;
gboolean immutable_streams = FALSE;
const gchar *dtmf_initial_tones = NULL;
const gchar *initial_audio_name = NULL;
const gchar *initial_video_name = NULL;
TpHandle self_handle = tp_base_connection_get_self_handle (priv->conn);
g_assert (initiator != 0);
object_path = g_strdup_printf ("%s/CallChannel%u",
tp_base_connection_get_object_path (priv->conn), priv->channel_index++);
DEBUG("channel object path %s", object_path);
if (request_properties != NULL)
{
initial_audio = tp_asv_get_boolean (request_properties,
TP_PROP_CHANNEL_TYPE_CALL_INITIAL_AUDIO, NULL);
initial_video = tp_asv_get_boolean (request_properties,
TP_PROP_CHANNEL_TYPE_CALL_INITIAL_VIDEO, NULL);
initial_audio_name = tp_asv_get_string (request_properties,
TP_PROP_CHANNEL_TYPE_CALL_INITIAL_AUDIO_NAME);
initial_video_name = tp_asv_get_string (request_properties,
TP_PROP_CHANNEL_TYPE_CALL_INITIAL_VIDEO_NAME);
dtmf_initial_tones = tp_asv_get_string (request_properties,
TP_PROP_CHANNEL_INTERFACE_DTMF_INITIAL_TONES);
}
g_object_get (priv->conn,
"immutable-streams", &immutable_streams,
NULL);
chan = g_object_new (RAKIA_TYPE_CALL_CHANNEL,
"connection", priv->conn,
"object-path", object_path,
"handle", maybe_peer,
"initiator-handle", initiator,
"initial-audio", initial_audio,
"initial-video", initial_video,
"initial-audio-name", initial_audio_name,
"initial-video-name", initial_video_name,
"initial-transport", TP_STREAM_TRANSPORT_TYPE_RAW_UDP,
"mutable-contents", !immutable_streams,
"initial-tones", dtmf_initial_tones,
"sip-session", session,
"stun-server", priv->stun_server ? priv->stun_server :
"",
"stun-port", priv->stun_port,
"requested", (initiator == self_handle),
NULL);
g_free (object_path);
g_signal_connect (chan, "closed", G_CALLBACK (call_channel_closed_cb), fac);
g_ptr_array_add (priv->channels, chan);
tp_base_channel_register (TP_BASE_CHANNEL (chan));
return chan;
}
