static void tp_base_call_stream_get_property ( GObject *object, guint property_id, GValue *value, GParamSpec *pspec) { TpBaseCallStream *self = TP_BASE_CALL_STREAM (object); TpBaseCallStreamClass *klass = TP_BASE_CALL_STREAM_GET_CLASS (self); switch (property_id) { case PROP_CONNECTION: g_value_set_object (value, self->priv->conn); break; case PROP_OBJECT_PATH: g_value_set_string (value, self->priv->object_path); break; case PROP_CONTENT: g_value_set_object (value, self->priv->content); break; case PROP_CHANNEL: g_value_set_object (value, self->priv->channel); break; case PROP_REMOTE_MEMBERS: g_value_set_boxed (value, self->priv->remote_members); break; case PROP_REMOTE_MEMBER_IDENTIFIERS: { GHashTable *identifiers; identifiers = _tp_base_call_dup_member_identifiers (self->priv->conn, self->priv->remote_members); g_value_set_boxed (value, identifiers); g_hash_table_unref (identifiers); break; } case PROP_LOCAL_SENDING_STATE: g_value_set_uint (value, self->priv->local_sending_state); break; case PROP_CAN_REQUEST_RECEIVING: { g_value_set_boolean (value, klass->request_receiving != NULL); break; } case PROP_INTERFACES: { GPtrArray *interfaces = klass->get_interfaces (self); g_ptr_array_add (interfaces, NULL); g_value_set_boxed (value, interfaces->pdata); g_ptr_array_unref (interfaces); break; } default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } }
static void tp_base_call_stream_set_property ( GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { TpBaseCallStream *self = TP_BASE_CALL_STREAM (object); switch (property_id) { case PROP_CONNECTION: self->priv->conn = g_value_dup_object (value); g_assert (self->priv->conn != NULL); break; case PROP_CONTENT: { TpBaseCallContent *content = g_value_get_object (value); if (content) _tp_base_call_stream_set_content (self, content); } break; case PROP_OBJECT_PATH: g_free (self->priv->object_path); self->priv->object_path = g_value_dup_string (value); break; case PROP_LOCAL_SENDING_STATE: self->priv->local_sending_state = g_value_get_uint (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } }
static void call_content_setup_jingle (GabbleCallContent *self, GabbleCallMemberContent *mcontent) { TpBaseCallContent *base = TP_BASE_CALL_CONTENT (self); GabbleJingleContent *jingle; GabbleCallStream *stream; gchar *path; JingleTransportType transport; JingleMediaDescription *md; GHashTable *tp_md; TpHandle contact; jingle = gabble_call_member_content_get_jingle_content (mcontent); if (jingle == NULL) return; transport = gabble_jingle_content_get_transport_type (jingle); path = g_strdup_printf ("%s/Stream%p", tp_base_call_content_get_object_path (base), jingle); stream = g_object_new (GABBLE_TYPE_CALL_STREAM, "object-path", path, "connection", tp_base_call_content_get_connection (base), "jingle-content", jingle, "transport", _jingle_to_tp_transport (transport), NULL); g_free (path); md = jingle_media_description_new (); /* FIXME: correct??? */ contact = gabble_call_member_get_handle ( gabble_call_member_content_get_member (mcontent)); tp_md = tp_base_media_call_content_get_local_media_description ( TP_BASE_MEDIA_CALL_CONTENT (self), contact); if (tp_md != NULL) { md->codecs = codec_array_to_list (tp_asv_get_boxed (tp_md, TP_PROP_CALL_CONTENT_MEDIA_DESCRIPTION_CODECS, TP_ARRAY_TYPE_CODEC_LIST)); } if (md->codecs != NULL) jingle_media_rtp_set_local_media_description ( GABBLE_JINGLE_MEDIA_RTP (jingle), md, TRUE, NULL); else jingle_media_description_free (md); tp_base_call_content_add_stream (base, TP_BASE_CALL_STREAM (stream)); gabble_call_stream_update_member_states (stream); g_object_unref (stream); }
static void tp_base_call_stream_finalize (GObject *object) { TpBaseCallStream *self = TP_BASE_CALL_STREAM (object); /* free any data held directly by the object here */ g_free (self->priv->object_path); g_hash_table_unref (self->priv->remote_members); if (G_OBJECT_CLASS (tp_base_call_stream_parent_class)->finalize != NULL) G_OBJECT_CLASS (tp_base_call_stream_parent_class)->finalize (object); }
/** * tp_base_media_call_stream_update_receiving_state: * @self: a #TpBaseMediaCallStream * * Update the receiving state. * * Since: 0.17.5 */ void tp_base_media_call_stream_update_receiving_state (TpBaseMediaCallStream *self) { TpBaseCallStream *bcs = TP_BASE_CALL_STREAM (self); GHashTable *remote_members = _tp_base_call_stream_get_remote_members (bcs); GHashTableIter iter; gpointer key, value; gboolean remote_sending = FALSE; TpBaseCallChannel *channel = _tp_base_call_stream_get_channel (bcs); if (channel == NULL || !_tp_base_call_channel_is_locally_accepted (channel)) goto done; if (self->priv->receiving_failure) goto done; if (TP_IS_BASE_MEDIA_CALL_CHANNEL (channel)) { TpBaseMediaCallChannel *mediachan = TP_BASE_MEDIA_CALL_CHANNEL (channel); if (_tp_base_media_channel_is_held (mediachan)) goto done; } g_hash_table_iter_init (&iter, remote_members); while (g_hash_table_iter_next (&iter, &key, &value)) { TpSendingState state = GPOINTER_TO_UINT (value); switch (state) { case TP_SENDING_STATE_SENDING: case TP_SENDING_STATE_PENDING_SEND: remote_sending = TRUE; break; case TP_SENDING_STATE_PENDING_STOP_SENDING: case TP_SENDING_STATE_NONE: break; default: g_assert_not_reached (); } if (remote_sending) break; } done: if (remote_sending) set_receiving_state (self, TP_STREAM_FLOW_STATE_PENDING_START); else set_receiving_state (self, TP_STREAM_FLOW_STATE_PENDING_STOP); }
static void tp_base_call_stream_set_sending_dbus (TpSvcCallStream *iface, gboolean sending, DBusGMethodInvocation *context) { TpBaseCallStream *self = TP_BASE_CALL_STREAM (iface); GError *error = NULL; if (_tp_base_call_stream_set_sending (TP_BASE_CALL_STREAM (iface), sending, tp_base_channel_get_self_handle ((TpBaseChannel *) self->priv->channel), TP_CALL_STATE_CHANGE_REASON_USER_REQUESTED, "", "User changed the sending state", &error)) { tp_svc_call_stream_return_from_set_sending (context); } else { dbus_g_method_return_error (context, error); } g_clear_error (&error); }
static void tp_base_call_stream_dispose (GObject *object) { TpBaseCallStream *self = TP_BASE_CALL_STREAM (object); TpDBusDaemon *bus = tp_base_connection_get_dbus_daemon ( (TpBaseConnection *) self->priv->conn); tp_dbus_daemon_unregister_object (bus, G_OBJECT (self)); tp_clear_object (&self->priv->conn); if (G_OBJECT_CLASS (tp_base_call_stream_parent_class)->dispose != NULL) G_OBJECT_CLASS (tp_base_call_stream_parent_class)->dispose (object); }
static void tp_base_call_stream_constructed (GObject *obj) { TpBaseCallStream *self = TP_BASE_CALL_STREAM (obj); TpDBusDaemon *bus = tp_base_connection_get_dbus_daemon ( (TpBaseConnection *) self->priv->conn); if (G_OBJECT_CLASS (tp_base_call_stream_parent_class)->constructed != NULL) G_OBJECT_CLASS (tp_base_call_stream_parent_class)->constructed (obj); /* register object on the bus */ DEBUG ("Registering %s", self->priv->object_path); tp_dbus_daemon_register_object (bus, self->priv->object_path, obj); }
void rakia_call_content_add_stream (RakiaCallContent *self) { RakiaCallContentPrivate *priv = self->priv; TpBaseCallContent *bcc = TP_BASE_CALL_CONTENT (self); gchar *object_path; object_path = g_strdup_printf ("%s/Stream", tp_base_call_content_get_object_path (bcc)); priv->stream = rakia_call_stream_new (self, priv->media, object_path, TP_STREAM_TRANSPORT_TYPE_RAW_UDP, tp_base_call_content_get_connection (bcc)); g_free (object_path); tp_base_call_content_add_stream (bcc, TP_BASE_CALL_STREAM (priv->stream)); }
static void tp_base_media_call_stream_report_sending_failure ( TpSvcCallStreamInterfaceMedia *iface, TpCallStateChangeReason reason, const gchar *dbus_reason, const gchar *message, DBusGMethodInvocation *context) { TpBaseMediaCallStream *self = TP_BASE_MEDIA_CALL_STREAM (iface); TpBaseMediaCallStreamClass *klass = TP_BASE_MEDIA_CALL_STREAM_GET_CLASS (self); TpStreamFlowState old_state = self->priv->sending_state; TpBaseCallChannel *channel = _tp_base_call_stream_get_channel ( TP_BASE_CALL_STREAM (self)); gboolean was_held = FALSE; if (self->priv->sending_state == TP_STREAM_FLOW_STATE_STOPPED) goto done; self->priv->sending_failure = TRUE; self->priv->sending_stop_requested = FALSE; self->priv->sending_state = TP_STREAM_FLOW_STATE_STOPPED; if (channel != NULL && TP_IS_BASE_MEDIA_CALL_CHANNEL (channel)) { was_held = _tp_base_media_call_channel_streams_sending_state_changed ( TP_BASE_MEDIA_CALL_CHANNEL (channel), FALSE); } if (!was_held) { self->priv->local_sending = FALSE; if (klass->report_sending_failure != NULL) klass->report_sending_failure (self, old_state, reason, dbus_reason, message); } g_object_notify (G_OBJECT (self), "sending-state"); tp_svc_call_stream_interface_media_emit_sending_state_changed (self, self->priv->sending_state); self->priv->sending_failure = FALSE; done: tp_svc_call_stream_interface_media_return_from_report_sending_failure ( context); }
static void set_receiving_state (TpBaseMediaCallStream *self, TpStreamFlowState state) { if (ignore_state_change (self->priv->receiving_state, state)) return; DEBUG ("%s => %s (path: %s)", stream_flow_state_to_string (self->priv->receiving_state), stream_flow_state_to_string (state), tp_base_call_stream_get_object_path (TP_BASE_CALL_STREAM (self))); self->priv->receiving_state = state; g_object_notify (G_OBJECT (self), "receiving-state"); tp_svc_call_stream_interface_media_emit_receiving_state_changed (self, state); }
static void tp_base_media_call_stream_complete_receiving_state_change ( TpSvcCallStreamInterfaceMedia *iface, TpStreamFlowState state, DBusGMethodInvocation *context) { TpBaseMediaCallStream *self = TP_BASE_MEDIA_CALL_STREAM (iface); TpBaseMediaCallStreamClass *klass = TP_BASE_MEDIA_CALL_STREAM_GET_CLASS (self); TpBaseCallChannel *channel = _tp_base_call_stream_get_channel ( TP_BASE_CALL_STREAM (self)); if (!correct_state_transition (self->priv->receiving_state, state)) { GError e = { TP_ERROR, TP_ERROR_INVALID_ARGUMENT, "Invalid receiving state transition" }; dbus_g_method_return_error (context, &e); return; } self->priv->receiving_state = state; g_object_notify (G_OBJECT (self), "receiving-state"); if (channel != NULL && TP_IS_BASE_MEDIA_CALL_CHANNEL (channel)) _tp_base_media_call_channel_streams_receiving_state_changed ( TP_BASE_MEDIA_CALL_CHANNEL (channel), TRUE); if (state == TP_STREAM_FLOW_STATE_STARTED) { TpIntsetFastIter iter; TpHandle contact; tp_intset_fast_iter_init (&iter, self->priv->receiving_requests); while (tp_intset_fast_iter_next (&iter, &contact)) { if (klass->request_receiving != NULL) klass->request_receiving (self, contact, TRUE); } tp_intset_clear (self->priv->receiving_requests); } tp_svc_call_stream_interface_media_emit_receiving_state_changed (self, state); tp_svc_call_stream_interface_media_return_from_complete_receiving_state_change (context); }
static void tp_base_media_call_stream_complete_sending_state_change ( TpSvcCallStreamInterfaceMedia *iface, TpStreamFlowState state, DBusGMethodInvocation *context) { TpBaseMediaCallStream *self = TP_BASE_MEDIA_CALL_STREAM (iface); TpBaseMediaCallStreamClass *klass = TP_BASE_MEDIA_CALL_STREAM_GET_CLASS (self); TpBaseCallChannel *channel = _tp_base_call_stream_get_channel ( TP_BASE_CALL_STREAM (self)); if (!correct_state_transition (self->priv->sending_state, state)) { GError e = { TP_ERROR, TP_ERROR_INVALID_ARGUMENT, "Invalid sending state transition" }; dbus_g_method_return_error (context, &e); return; } self->priv->sending_state = state; if (channel != NULL && TP_IS_BASE_MEDIA_CALL_CHANNEL (channel)) _tp_base_media_call_channel_streams_sending_state_changed ( TP_BASE_MEDIA_CALL_CHANNEL (channel), TRUE); if (state == TP_STREAM_FLOW_STATE_STOPPED && klass->set_sending != NULL && self->priv->sending_stop_requested) klass->set_sending (self, FALSE, NULL); self->priv->sending_stop_requested = FALSE; tp_svc_call_stream_interface_media_emit_sending_state_changed (self, state); tp_svc_call_stream_interface_media_return_from_complete_sending_state_change (context); }
/** * tp_base_media_call_stream_update_sending_state: * @self: a #TpBaseMediaCallStream * * Update the sending state. * * Since: 0.17.5 */ void tp_base_media_call_stream_update_sending_state (TpBaseMediaCallStream *self) { TpBaseCallChannel *channel = _tp_base_call_stream_get_channel ( TP_BASE_CALL_STREAM (self)); gboolean sending = FALSE; if (channel == NULL) goto done; if (TP_IS_BASE_MEDIA_CALL_CHANNEL (channel)) { TpBaseMediaCallChannel *mediachan = TP_BASE_MEDIA_CALL_CHANNEL (channel); if (_tp_base_media_channel_is_held (mediachan)) goto done; } if (!tp_base_call_channel_is_accepted (TP_BASE_CALL_CHANNEL (channel))) goto done; if (self->priv->remotely_held) goto done; if (self->priv->sending_failure) goto done; sending = self->priv->local_sending; done: if (sending) set_sending_state (self, TP_STREAM_FLOW_STATE_PENDING_START); else set_sending_state (self, TP_STREAM_FLOW_STATE_PENDING_STOP); }
static void tp_base_media_call_stream_fail (TpSvcCallStreamInterfaceMedia *iface, const GValueArray *reason_array, DBusGMethodInvocation *context) { TpBaseMediaCallStream *self = TP_BASE_MEDIA_CALL_STREAM (iface); TpBaseCallStream *base = TP_BASE_CALL_STREAM (self); TpBaseCallChannel *channel; TpBaseCallContent *content; channel = _tp_base_call_stream_get_channel (base); content = _tp_base_call_stream_get_content (base); _tp_base_call_content_remove_stream_internal (content, base, reason_array); /* If it was the last stream, remove the content */ if (tp_base_call_content_get_streams (content) == NULL) { _tp_base_call_channel_remove_content_internal (channel, content, reason_array); } tp_svc_call_stream_interface_media_return_from_fail (context); }
static void tp_base_call_stream_request_receiving (TpSvcCallStream *iface, TpHandle contact, gboolean receiving, DBusGMethodInvocation *context) { TpBaseCallStream *self = TP_BASE_CALL_STREAM (iface); TpBaseCallStreamClass *klass = TP_BASE_CALL_STREAM_GET_CLASS (self); GError *error = NULL; TpSendingState remote_sending_state; gboolean can_request_receiving; g_object_get (self, "can-request-receiving", &can_request_receiving, NULL); if (!can_request_receiving) { g_set_error (&error, TP_ERROR, TP_ERROR_NOT_CAPABLE, "The contact does not support requesting to receive"); goto error; } if (!g_hash_table_lookup_extended (self->priv->remote_members, GUINT_TO_POINTER (contact), NULL, (gpointer *) &remote_sending_state)) { g_set_error (&error, TP_ERROR, TP_ERROR_INVALID_ARGUMENT, "Contact %u is not member of this stream", contact); goto error; } if (klass->request_receiving == NULL) { g_set_error_literal (&error, TP_ERROR, TP_ERROR_NOT_IMPLEMENTED, "This CM does not implement request_receiving"); goto error; } /* Determine if there is a state change for our receiving side * aka remote sending */ switch (remote_sending_state) { case TP_SENDING_STATE_NONE: case TP_SENDING_STATE_PENDING_STOP_SENDING: if (!receiving) goto out; break; case TP_SENDING_STATE_SENDING: case TP_SENDING_STATE_PENDING_SEND: if (receiving) goto out; break; default: g_assert_not_reached (); } if (!klass->request_receiving (self, contact, receiving, &error)) goto error; out: tp_svc_call_stream_return_from_request_receiving (context); return; error: dbus_g_method_return_error (context, error); g_clear_error (&error); }