TfChannel

## TfChannel TfChannel — Handle the MediaSignalling or Call media interfaces on a Channel |

## Synopsis

                        TfChannel;
    void                tf_channel_new_async                (TpChannel *channel_proxy,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    TfChannel *         tf_channel_new_finish               (GObject *object,
                                                             GAsyncResult *result,
                                                             GError **error);
    gboolean            tf_channel_bus_message              (TfChannel *channel,
                                                             GstMessage *message);

## Object Hierarchy

      GObject
       +----TfChannel

## Implemented Interfaces

TfChannel implements GAsyncInitable.

## Properties

      "channel"                  TpChannel*            : Read / Write / Construct Only
      "fs-conferences"           GPtrArray*            : Read
      "object-path"              gchar*                : Read

## Signals

      "closed"                                         : Run Last
      "content-added"                                  : Run Last
      "content-removed"                                : Run Last
      "fs-conference-added"                            : Run Last
      "fs-conference-removed"                          : Run Last

## Description

This class handles the org.freedesktop.Telepathy.Channel.Interface.MediaSignalling on a channel using Farstream or the media part of the org.freedesktop.Telepathy.Channel.Type.Call that has HardwareStreaming=FALSE

## Details

### TfChannel

    typedef struct _TfChannel TfChannel;

All members of the object are private

### tf_channel_new_async ()

    void                tf_channel_new_async                (TpChannel *channel_proxy,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

Creates a new TfChannel from an existing channel proxy, the new TfChannel object will be return in the async callback.

The user must call `tf_channel_new_finish()` in the callback to get the finished object.

`channel_proxy` : | a TpChannel proxy
`callback` : | a GAsyncReadyCallback to call when the channel is ready
`user_data` : | the data to pass to callback function

### tf_channel_new_finish ()

    TfChannel *         tf_channel_new_finish               (GObject *object,
                                                             GAsyncResult *result,
                                                             GError **error);

Completes the construction of a TfChannel.

`object` : | The GObject
`result` : | a GAsyncResult
`error` : | the location of a GError or `NULL` to ignore it
Returns : | a TfChannel or `NULL` if there was an error

Since 0.2.2

### tf_channel_bus_message ()

    gboolean            tf_channel_bus_message              (TfChannel *channel,
                                                             GstMessage *message);

You must call this function on call messages received on the async bus. GstMessages are not modified.

`channel` : | A TfChannel
`message` : | A GstMessage received from the bus
Returns : | `TRUE` if the message has been handled, `FALSE` otherwise

## Property Details

### The `"channel"` property

      "channel"                  TpChannel*            : Read / Write / Construct Only

Telepathy channel object which this media channel should operate on.

### The `"fs-conferences"` property

      "fs-conferences"           GPtrArray*            : Read

GPtrArray of Farstream FsConferences for this channel.

### The `"object-path"` property

      "object-path"              gchar*                : Read

D-Bus object path of the Telepathy channel which this channel operates on.

Default value: NULL

## Signal Details

### The `"closed"` signal

    void                user_function                      (TfChannel *arg0,
                                                            gpointer   user_data)      : Run Last

This function is called after a channel is closed, either because it has been closed by the connection manager or because we had a locally generated error.

`user_data` : | user data set when the signal handler was connected.

### The `"content-added"` signal

    void                user_function                      (TfChannel *tfchannel,
                                                            TfContent *content,
                                                            gpointer   user_data)      : Run Last

Tells the application that a content has been added. In the callback for this signal, the application should set its preferred codecs, and hook up to any signal from TfContent it cares about. Special care should be made to connect "src-pad-added" as well as the "start-sending" and "stop-sending" signals.

`tfchannel` : | the TfChannel
`content` : | a TfContent
`user_data` : | user data set when the signal handler was connected.

### The `"content-removed"` signal

    void                user_function                      (TfChannel *tfchannel,
                                                            TfContent *content,
                                                            gpointer   user_data)      : Run Last

Tells the application that a content is being removed.

`tfchannel` : | the TfChannel
`content` : | a TfContent
`user_data` : | user data set when the signal handler was connected.

### The `"fs-conference-added"` signal

    void                user_function                      (TfChannel    *tfchannel,
                                                            FsConference *conf,
                                                            gpointer      user_data)      : Run Last

When this signal is emitted, the conference should be added to the application's pipeline.

`tfchannel` : | the TfChannel
`conf` : | a FsConference
`user_data` : | user data set when the signal handler was connected.

### The `"fs-conference-removed"` signal

    void                user_function                      (TfChannel    *tfchannel,
                                                            FsConference *conf,
                                                            gpointer      user_data)      : Run Last

When this signal is emitted, the conference should be remove from the application's pipeline.

`tfchannel` : | the TfChannel
`conf` : | a FsConference
`user_data` : | user data set when the signal handler was connected.