Convenience function to create a new #TpAccountChannelRequest object.
a #TpAccount
the requested properties of the channel (see #TpAccountChannelRequest:request)
the time of the user action that caused this request, or one of the special values %TP_USER_ACTION_TIME_NOT_USER_ACTION or %TP_USER_ACTION_TIME_CURRENT_TIME (see #TpAccountChannelRequest:user-action-time)
The #TpAccount used to request the channel. Read-only except during construction.
This property can't be %NULL.
The #TpChannelRequest used to request the channel, or %NULL if the channel has not be requested yet.
This can be useful for example to compare with the #TpChannelRequest objects received from the requests_satisfied argument of #TpSimpleHandlerHandleChannelsImpl to check if the client is asked to handle the channel it just requested.
Note that the #TpChannelRequest objects may be different while still representing the same ChannelRequest on D-Bus. You have to compare them using their object paths (tp_proxy_get_object_path()).
Since 0.13.13
The desired D-Bus properties for the channel.
When constructing a new object, one of #TpAccountChannelRequest:request or #TpAccountChannelRequest:request-vardict must be set to a non-%NULL value, and the other must remain unspecified.
The user action time that will be passed to the channel dispatcher when requesting the channel.
This may be the time at which user action occurred, or one of the special values %TP_USER_ACTION_TIME_NOT_USER_ACTION or %TP_USER_ACTION_TIME_CURRENT_TIME.
If %TP_USER_ACTION_TIME_NOT_USER_ACTION, the action doesn't involve any user action. Clients should avoid stealing focus when presenting the channel.
If %TP_USER_ACTION_TIME_CURRENT_TIME, clients SHOULD behave as though the user action happened at the current time, e.g. a client may request that its window gains focus.
On X11-based systems, GDK 2, GDK 3, Clutter 1.0 etc., tp_user_action_time_from_x11() can be used to convert an X11 timestamp to a Telepathy user action time.
If the channel request succeeds, this user action time will be passed on to the channel's handler. If the handler is a GUI, it may use tp_user_action_time_should_present() to decide whether to bring its window to the foreground.
Creates a binding between source_property on source and target_property
on target.
Whenever the source_property is changed the target_property is
updated using the same value. For instance:
g_object_bind_property (action, "active", widget, "sensitive", 0);
Will result in the "sensitive" property of the widget #GObject instance to be updated with the same value of the "active" property of the action #GObject instance.
If flags contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
if target_property on target changes then the source_property on source
will be updated as well.
The binding will automatically be removed when either the source or the
target instances are finalized. To remove the binding without affecting the
source and the target you can just call g_object_unref() on the returned
#GBinding instance.
Removing the binding by calling g_object_unref() on it must only be done if
the binding, source and target are only used from a single thread and it
is clear that both source and target outlive the binding. Especially it
is not safe to rely on this if the binding, source or target can be
finalized from different threads. Keep another reference to the binding and
use g_binding_unbind() instead to be on the safe side.
A #GObject can have multiple bindings.
the property on source to bind
the target #GObject
the property on target to bind
flags to pass to #GBinding
Creates a binding between source_property on source and target_property
on target, allowing you to set the transformation functions to be used by
the binding.
This function is the language bindings friendly version of g_object_bind_property_full(), using #GClosures instead of function pointers.
the property on source to bind
the target #GObject
the property on target to bind
flags to pass to #GBinding
a #GClosure wrapping the transformation function from the source to the target, or %NULL to use the default
a #GClosure wrapping the transformation function from the target to the source, or %NULL to use the default
Asynchronously calls CreateChannel on the ChannelDispatcher to create a
channel with the properties defined in #TpAccountChannelRequest:request
that you are going to handle yourself.
When the operation is finished, callback will be called. You can then call
tp_account_channel_request_create_and_handle_channel_finish() to get the
result of the operation.
(Behind the scenes, this works by creating a temporary #TpBaseClient, then
acting like tp_account_channel_request_create_channel_async() with the
temporary #TpBaseClient as the preferred_handler.)
The caller is responsible for closing the channel with tp_cli_channel_call_close() when it has finished handling it.
optional #GCancellable object, %NULL to ignore
a callback to call when the request is satisfied
Finishes an async channel creation started using tp_account_channel_request_create_and_handle_channel_async().
See tp_account_channel_request_ensure_and_handle_channel_finish()
for details of how context can be used.
The caller is responsible for closing the channel with tp_cli_channel_call_close() when it has finished handling it.
a #GAsyncResult
Asynchronously calls CreateChannel on the ChannelDispatcher to create a
channel with the properties defined in #TpAccountChannelRequest:request
and let the ChannelDispatcher dispatch it to an handler.
callback will be called when the channel has been created and dispatched,
or the request has failed.
You can then call tp_account_channel_request_create_channel_finish() to
get the result of the operation and a #TpChannel representing the channel
which has been created. Note that you are
Either the well-known bus name (starting with %TP_CLIENT_BUS_NAME_BASE) of the preferred handler for the channel, or %NULL to indicate that any handler would be acceptable.
optional #GCancellable object, %NULL to ignore
a callback to call when the request is satisfied
Finishes an async channel creation started using tp_account_channel_request_create_and_observe_channel_async().
a #GAsyncResult
Asynchronously calls CreateChannel on the ChannelDispatcher to create a
channel with the properties defined in #TpAccountChannelRequest:request
and let the ChannelDispatcher dispatch it to an handler.
callback will be called when the channel has been created and dispatched,
or the request has failed.
You can then call tp_account_channel_request_create_channel_finish() to
get the result of the operation.
Either the well-known bus name (starting with %TP_CLIENT_BUS_NAME_BASE) of the preferred handler for the channel, or %NULL to indicate that any handler would be acceptable.
optional #GCancellable object, %NULL to ignore
a callback to call when the request is satisfied
Finishes an async channel creation started using tp_account_channel_request_create_channel_async().
a #GAsyncResult
Asynchronously calls EnsureChannel on the ChannelDispatcher to create a
channel with the properties defined in #TpAccountChannelRequest:request
that you are going to handle yourself.
When the operation is finished, callback will be called. You can then call
tp_account_channel_request_ensure_and_handle_channel_finish() to get the
result of the operation.
If the channel already exists and is already being handled, or if a newly created channel is sent to a different handler, this operation will fail with the error %TP_ERROR_NOT_YOURS. The other handler will be notified that the channel was requested again (for instance with #TpAccountChannelRequest::re-handled, #TpBaseClientClassHandleChannelsImpl or #TpSimpleHandler:callback), and can move its window to the foreground, if applicable.
(Behind the scenes, this works by creating a temporary #TpBaseClient, then
acting like tp_account_channel_request_ensure_channel_async() with the
temporary #TpBaseClient as the preferred_handler.)
optional #GCancellable object, %NULL to ignore
a callback to call when the request is satisfied
Finishes an async channel creation started using tp_account_channel_request_ensure_and_handle_channel_async().
If the channel already exists and is already being handled, or if a newly created channel is sent to a different handler, this operation will fail with the error %TP_ERROR_NOT_YOURS.
context can be used to obtain extensible information about the channel
via tp_handle_channels_context_get_handler_info(), and any similar methods
that are added in future. It is not valid for the caller of this method
to call tp_handle_channels_context_accept(),
tp_handle_channels_context_delay() or tp_handle_channels_context_fail().
a #GAsyncResult
Asynchronously calls EnsureChannel on the ChannelDispatcher to create a
channel with the properties defined in #TpAccountChannelRequest:request
and let the ChannelDispatcher dispatch it to an handler.
callback will be called when the channel has been created and dispatched,
or the request has failed.
You can then call tp_account_channel_request_create_channel_finish() to
get the result of the operation and a #TpChannel representing the channel
which has been created. Note that you are
If a suitable channel already existed, its handler will be notified that the channel was requested again (for instance with #TpAccountChannelRequest::re-handled, #TpBaseClientClassHandleChannelsImpl or #TpSimpleHandler:callback, if it is implemented using Telepathy-GLib), so that it can re-present the window to the user, for example. Otherwise, a new channel will be created and dispatched to a handler.
Either the well-known bus name (starting with %TP_CLIENT_BUS_NAME_BASE) of the preferred handler for the channel, or %NULL to indicate that any handler would be acceptable.
optional #GCancellable object, %NULL to ignore
a callback to call when the request is satisfied
Finishes an async channel creation started using tp_account_channel_request_create_and_observe_channel_async().
a #GAsyncResult
Asynchronously calls EnsureChannel on the ChannelDispatcher to create a channel with the properties defined in #TpAccountChannelRequest:request and let the ChannelDispatcher dispatch it to an handler.
If a suitable channel already existed, its handler will be notified that the channel was requested again (for instance with #TpAccountChannelRequest::re-handled, #TpBaseClientClassHandleChannelsImpl or #TpSimpleHandler:callback, if it is implemented using Telepathy-GLib), so that it can re-present the window to the user, for example. Otherwise, a new channel will be created and dispatched to a handler.
callback will be called when an existing channel's handler has been
notified, a new channel has been created and dispatched, or the request
has failed.
You can then call tp_account_channel_request_ensure_channel_finish() to
get the result of the operation.
Either the well-known bus name (starting with %TP_CLIENT_BUS_NAME_BASE) of the preferred handler for the channel, or %NULL to indicate that any handler would be acceptable.
optional #GCancellable object, %NULL to ignore
a callback to call when the request is satisfied
Finishes an async channel creation started using tp_account_channel_request_ensure_channel_async().
a #GAsyncResult
This function is intended for #GObject implementations to re-enforce a [floating][floating-ref] object reference. Doing this is seldom required: all #GInitiallyUnowneds are created with a floating reference which usually just needs to be sunken by calling g_object_ref_sink().
Increases the freeze count on object. If the freeze count is
non-zero, the emission of "notify" signals on object is
stopped. The signals are queued until the freeze count is decreased
to zero. Duplicate notifications are squashed so that at most one
#GObject::notify signal is emitted for each property modified while the
object is frozen.
This is necessary for accessors that modify multiple properties to prevent premature notification while the object is still being modified.
Return the #TpAccountChannelRequest:account construct-only property
Return the #TpAccountChannelRequest:channel-request property
Gets a named field from the objects table of associations (see g_object_set_data()).
name of the key for that association
Gets a property of an object.
The value can be:
In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling g_value_unset().
Note that g_object_get_property() is really intended for language bindings, g_object_get() is much more convenient for C programming.
the name of the property to get
return location for the property value
This function gets back user data pointers stored via g_object_set_qdata().
A #GQuark, naming the user data pointer
Return the #TpAccountChannelRequest:request construct-only property
Return the #TpAccountChannelRequest:user-action-time construct-only property
Gets n_properties properties for an object.
Obtained properties will be set to values. All properties must be valid.
Warnings will be emitted and undefined behaviour may result if invalid
properties are passed in.
the names of each property to get
the values of each property to get
Checks whether object has a [floating][floating-ref] reference.
Emits a "notify" signal for the property property_name on object.
When possible, eg. when signaling a property change from within the class that registered the property, you should use g_object_notify_by_pspec() instead.
Note that emission of the notify signal may be blocked with g_object_freeze_notify(). In this case, the signal emissions are queued and will be emitted (in reverse order) when g_object_thaw_notify() is called.
the name of a property installed on the class of object.
Emits a "notify" signal for the property specified by pspec on object.
This function omits the property name lookup, hence it is faster than g_object_notify().
One way to avoid using g_object_notify() from within the class that registered the properties, and using g_object_notify_by_pspec() instead, is to store the GParamSpec used with g_object_class_install_property() inside a static array, e.g.:
enum
{
PROP_0,
PROP_FOO,
PROP_LAST
};
static GParamSpec *properties[PROP_LAST];
static void
my_object_class_init (MyObjectClass *klass)
{
properties[PROP_FOO] = g_param_spec_int ("foo", "Foo", "The foo",
0, 100,
50,
G_PARAM_READWRITE);
g_object_class_install_property (gobject_class,
PROP_FOO,
properties[PROP_FOO]);
}
and then notify a change on the "foo" property with:
g_object_notify_by_pspec (self, properties[PROP_FOO]);
the #GParamSpec of a property installed on the class of object.
Increase the reference count of object, and possibly remove the
[floating][floating-ref] reference, if object has a floating reference.
In other words, if the object is floating, then this call "assumes ownership" of the floating reference, converting it to a normal reference by clearing the floating flag while leaving the reference count unchanged. If the object is not floating, then this call adds a new normal reference increasing the reference count by one.
Since GLib 2.56, the type of object will be propagated to the return type
under the same conditions as for g_object_ref().
Releases all references to other objects. This can be used to break reference cycles.
This function should only be called from object system implementations.
Set factory as the #TpClientChannelFactory that will be used to
create the channel requested by self.
By default #TpAutomaticProxyFactory is used.
This function can't be called once self has been used to request a
channel.
a #TpClientChannelFactory
Indicate that the channel which is going to be requested using self
is an upgrade of the channels whose object paths is listed in channels.
This function can't be called once self has been used to request a
channel.
a #NULL-terminated array of channel paths
Each object carries around a table of associations from strings to pointers. This function lets you set an association.
If the object already had an association with that name, the old association will be destroyed.
Internally, the key is converted to a #GQuark using g_quark_from_string().
This means a copy of key is kept permanently (even after object has been
finalized) — so it is recommended to only use a small, bounded set of values
for key in your program, to avoid the #GQuark storage growing unbounded.
name of the key
data to associate with that key
If delegate is %TRUE, asks to the client currently handling the channels to
delegate them to the preferred handler (passed when calling
tp_account_channel_request_ensure_channel_async() for example).
This function can't be called once self has been used to request a
channel.
%TRUE to request to delegate channels
Turn on support for the org.freedesktop.Telepathy.ChannelRequest.DelegateToPreferredHandler hint.
When receiving a request containing this hint, self will automatically
delegate the channel to the preferred handler of the request and then call
callback to inform the client that it is no longer handling this channel.
callback may be called any time after (and only after) requesting and
handling the channel (i.e. you have called create_and_handle or
ensure_and_handle).
This function can't be called once self has been used to request a
channel.
See also: tp_base_client_set_delegated_channels_callback()
function called the channel requested using self is delegated, may not be %NULL
Configure this channel request to provide the recipient of the file with the given description.
If file descriptions are not supported by the protocol, or if this method is used on a request that is not actually a file transfer, the channel request will fail. Use tp_capabilities_supports_file_transfer_description() to determine whether outgoing file transfers can have a description.
This function can't be called once self has been used to request a
channel.
a description of the file
Configure this channel request to accompany the file transfer with the hash of the file.
This function can't be called once self has been used to request a
channel.
a type of hash
hash of the contents of the file transfer
Configure this channel request to inform the recipient of the file
that this channel will not send the first offset bytes of the file.
In some protocols, this can be used to resume an interrupted transfer.
If this method is not called, the default is to start from the
beginning of the file (equivalent to offset = 0).
If offsets greater than 0 are not supported by the protocol, or if this method is used on a request that is not actually a file transfer, the channel request will fail. Use tp_capabilities_supports_file_transfer_initial_offset() to determine whether offsets greater than 0 are available.
This function can't be called once self has been used to request a
channel.
the offset into the file at which the transfer will start
Configure this channel request to accompany the file transfer with the given modification timestamp for the file.
If file timestamps are not supported by the protocol, or if this method is used on a request that is not actually a file transfer, the channel request will fail. Use tp_capabilities_supports_file_transfer_date() to determine whether outgoing file transfers can have a timestamp.
This function can't be called once self has been used to request a
channel.
the modification timestamp of the file, in seconds since the Unix epoch (the beginning of 1970 in the UTC time zone), as returned by g_date_time_to_unix()
Configure this channel request to provide other local Telepathy components with the URI of the file being sent. Unlike most properties on a file transfer channel, this information is not sent to the recipient of the file; instead, it is signalled on D-Bus for use by other Telepathy components.
The URI should usually be a file URI as defined by
file:///path/to/file or
file://localhost/path/to/file). If a remote resource
is being transferred to a contact, it may have a different scheme,
such as http.
Even if this method is used, the connection manager will not read the file from disk: the handler for the channel is still responsible for streaming the file. However, providing the URI allows a local logger to log which file was transferred, for instance.
If this functionality is not supported by the connection manager, or if this method is used on a request that is not actually a file transfer, the channel request will fail. Use tp_capabilities_supports_file_transfer_uri() to determine whether outgoing file transfers can have a URI.
This function can't be called once self has been used to request a
channel.
the source URI for the file
Set additional information about the channel request, which will be used in the resulting request's #TpChannelRequest:hints property.
This function can't be called once self has been used to request a
channel.
Set additional information about the channel request, which will be used as the value for the resulting request's #TpChannelRequest:hints property.
This function can't be called once self has been used to request a
channel.
In high-level language bindings, use tp_account_channel_request_set_hint() instead.
a #TP_HASH_TYPE_STRING_VARIANT_MAP
Indicate that the contacts listed in ids have to be invited to the
conference represented by the channel which is going to be requested
using self.
This function can't be called once self has been used to request a
channel.
a #NULL-terminated array of contact ids
Indicate that the contacts listed in contacts have to be invited to the
conference represented by the channel which is going to be requested
using self.
This function can't be called once self has been used to request a
channel.
a #GPtrArray of #TpContact
Sets a property on an object.
the name of the property to set
the value
Configure this channel request to include the given property, as documented in the Telepathy D-Bus API Specification or an implementation-specific extension.
Using this method is not recommended, but it can be necessary for experimental or implementation-specific interfaces.
If the property is not supported by the protocol or channel type, the channel request will fail. Use #TpCapabilities and the Telepathy D-Bus API Specification to determine which properties are available.
If value is a floating reference, this method takes ownership of it
by using g_variant_ref_sink(). This allows convenient inline use of
#GVariant constructors:
|[ tp_account_channel_request_set_request_property (acr, "com.example.Int", g_variant_new_int32 (17)); tp_account_channel_request_set_request_property (acr, "com.example.String", g_variant_new_string ("ferret"));
It is an error to provide a `value` which contains types not supported by
D-Bus.
This function can't be called once `self` has been used to request a
channel.
@param name a D-Bus property name
@param value an arbitrary value for the property
If is_sms_channel is set to #TRUE, messages sent and received on the
requested channel will be transmitted via SMS.
This function can't be called once self has been used to request a
channel.
#TRUE if the channel should use SMS
Configure this request to create a peer-to-peer channel with contact as
the other peer.
This function can't be called once self has been used to request a
channel.
the contact to be contacted
Configure this request to create a channel with identifier,
an identifier of type handle_type.
This function can't be called once self has been used to request a
channel.
the type of identifier, typically %TP_HANDLE_TYPE_CONTACT or %TP_HANDLE_TYPE_ROOM
the unique identifier of the contact, room etc. to be contacted
Remove a specified datum from the object's data associations, without invoking the association's destroy handler.
name of the key
This function gets back user data pointers stored via
g_object_set_qdata() and removes the data from object
without invoking its destroy() function (if any was
set).
Usually, calling this function is only required to update
user data pointers with a destroy notifier, for example:
void
object_add_to_user_list (GObject *object,
const gchar *new_string)
{
// the quark, naming the object data
GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
// retrieve the old string list
GList *list = g_object_steal_qdata (object, quark_string_list);
// prepend new string
list = g_list_prepend (list, g_strdup (new_string));
// this changed 'list', so we need to set it again
g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
}
static void
free_string_list (gpointer data)
{
GList *node, *list = data;
for (node = list; node; node = node->next)
g_free (node->data);
g_list_free (list);
}
Using g_object_get_qdata() in the above example, instead of g_object_steal_qdata() would have left the destroy function set, and thus the partial string list would have been freed upon g_object_set_qdata_full().
A #GQuark, naming the user data pointer
Reverts the effect of a previous call to
g_object_freeze_notify(). The freeze count is decreased on object
and when it reaches zero, queued "notify" signals are emitted.
Duplicate notifications for each property are squashed so that at most one #GObject::notify signal is emitted for each property, in the reverse order in which they have been queued.
It is an error to call this function when the freeze count is zero.
Decreases the reference count of object. When its reference count
drops to 0, the object is finalized (i.e. its memory is freed).
If the pointer to the #GObject may be reused in future (for example, if it is an instance variable of another object), it is recommended to clear the pointer to %NULL rather than retain a dangling pointer to a potentially invalid #GObject instance. Use g_clear_object() for this.
Emits a "notify" signal for the property property_name on object.
When possible, eg. when signaling a property change from within the class that registered the property, you should use g_object_notify_by_pspec() instead.
Note that emission of the notify signal may be blocked with g_object_freeze_notify(). In this case, the signal emissions are queued and will be emitted (in reverse order) when g_object_thaw_notify() is called.
This function essentially limits the life time of the closure to
the life time of the object. That is, when the object is finalized,
the closure is invalidated by calling g_closure_invalidate() on
it, in order to prevent invocations of the closure with a finalized
(nonexisting) object. Also, g_object_ref() and g_object_unref() are
added as marshal guards to the closure, to ensure that an extra
reference count is held on object during invocation of the
closure. Usually, this function will be called on closures that
use this object as closure data.
#GClosure to watch
Find the #GParamSpec with the given name for an
interface. Generally, the interface vtable passed in as g_iface
will be the default vtable from g_type_default_interface_ref(), or,
if you know the interface has already been loaded,
g_type_default_interface_peek().
any interface vtable for the interface, or the default vtable for the interface
name of a property to look up.
Add a property to an interface; this is only useful for interfaces that are added to GObject-derived types. Adding a property to an interface forces all objects classes with that interface to have a compatible property. The compatible property could be a newly created #GParamSpec, but normally g_object_class_override_property() will be used so that the object class only needs to provide an implementation and inherits the property description, default value, bounds, and so forth from the interface property.
This function is meant to be called from the interface's default
vtable initialization function (the class_init member of
#GTypeInfo.) It must not be called after after class_init has
been called for any object types implementing this interface.
If pspec is a floating reference, it will be consumed.
any interface vtable for the interface, or the default vtable for the interface.
the #GParamSpec for the new property
Lists the properties of an interface.Generally, the interface
vtable passed in as g_iface will be the default vtable from
g_type_default_interface_ref(), or, if you know the interface has
already been loaded, g_type_default_interface_peek().
any interface vtable for the interface, or the default vtable for the interface
Convenience function to create a new #TpAccountChannelRequest object.
a #TpAccount
the requested properties of the channel (see #TpAccountChannelRequest:request)
the time of the user action that caused this request, or one of the special values %TP_USER_ACTION_TIME_NOT_USER_ACTION or %TP_USER_ACTION_TIME_CURRENT_TIME (see #TpAccountChannelRequest:user-action-time)
Convenience function to create a new #TpAccountChannelRequest object which will yield a Call channel, initially carrying audio only.
After creating the request, you will usually also need to set the "target" of the channel by calling one of the following functions:
To call a contact, either use
tp_account_channel_request_set_target_contact() or one of the generic
methods that takes a handle type argument. To check whether this
is possible, use tp_capabilities_supports_audio_call() with
handle_type set to %TP_HANDLE_TYPE_CONTACT.
In some protocols, it is possible to create a Call channel without
setting a target at all, which will result in a new, empty
conference call. To test whether this is possible, use
tp_capabilities_supports_audio_call() with handle_type set to
%TP_HANDLE_TYPE_NONE.
a #TpAccount
the time of the user action that caused this request, or one of the special values %TP_USER_ACTION_TIME_NOT_USER_ACTION or %TP_USER_ACTION_TIME_CURRENT_TIME (see #TpAccountChannelRequest:user-action-time)
Convenience function to create a new #TpAccountChannelRequest object which will yield a Call channel, initially carrying both audio and video.
This is the same as tp_account_channel_request_new_audio_call(), except that the channel will initially carry video as well as audio, and instead of using tp_capabilities_supports_audio_call() you should test capabilities with tp_capabilities_supports_audio_video_call().
See the documentation of tp_account_channel_request_new_audio_call() for details of how to set the target (contact, chatroom etc.) for the call.
a #TpAccount
the time of the user action that caused this request, or one of the special values %TP_USER_ACTION_TIME_NOT_USER_ACTION or %TP_USER_ACTION_TIME_CURRENT_TIME (see #TpAccountChannelRequest:user-action-time)
Convenience function to create a new #TpAccountChannelRequest object, which will yield a DBusTube channel.
After creating the request, you will also need to set the "target" of the channel by calling one of the following functions:
a #TpAccount
the service name that will be used over the tube. It should be
the time of the user action that caused this request, or one of the special values %TP_USER_ACTION_TIME_NOT_USER_ACTION or %TP_USER_ACTION_TIME_CURRENT_TIME (see #TpAccountChannelRequest:user-action-time)
Convenience function to create a new #TpAccountChannelRequest object, which will yield a FileTransfer channel to send a file to a contact.
After creating the request, you will also need to set the "target" of the channel by calling one of the following functions:
a #TpAccount
a suggested name for the file, which should not contain directories or directory separators (for example, if you are sending a file called /home/user/monkey.pdf, set this to monkey.pdf)
the MIME type (content-type) of the file; a %NULL value is allowed, and is treated as "application/octet-stream"
the file's size in bytes
the time of the user action that caused this request, or one of the special values %TP_USER_ACTION_TIME_NOT_USER_ACTION or %TP_USER_ACTION_TIME_CURRENT_TIME (see #TpAccountChannelRequest:user-action-time)
Convenience function to create a new #TpAccountChannelRequest object, which will yield a StreamTube channel.
After creating the request, you will also need to set the "target" of the channel by calling one of the following functions:
a #TpAccount
the service name that will be used over the tube. It should be a well-known TCP service name as defined by http://www.iana.org/assignments/port-numbers or http://www.dns-sd.org/ServiceTypes.html, for instance "rsync" or "daap".
the time of the user action that caused this request, or one of the special values %TP_USER_ACTION_TIME_NOT_USER_ACTION or %TP_USER_ACTION_TIME_CURRENT_TIME (see #TpAccountChannelRequest:user-action-time)
Convenience function to create a new #TpAccountChannelRequest object which will yield a Text channel.
After creating the request, you will also need to set the "target" of the channel by calling one of the following functions:
a #TpAccount
the time of the user action that caused this request, or one of the special values %TP_USER_ACTION_TIME_NOT_USER_ACTION or %TP_USER_ACTION_TIME_CURRENT_TIME (see #TpAccountChannelRequest:user-action-time)
Convenience function to create a new #TpAccountChannelRequest object.
If request is a floating reference, this function will
take ownership of it, much like g_variant_ref_sink(). See documentation of
that function for details.
a #TpAccount
the requested properties of the channel (see #TpAccountChannelRequest:request) as a %G_VARIANT_TYPE_VARDICT
the time of the user action that caused this request, or one of the special values %TP_USER_ACTION_TIME_NOT_USER_ACTION or %TP_USER_ACTION_TIME_CURRENT_TIME (see #TpAccountChannelRequest:user-action-time)
Creates a new instance of a #GObject subtype and sets its properties.
Construction parameters (see %G_PARAM_CONSTRUCT, %G_PARAM_CONSTRUCT_ONLY) which are not explicitly specified are set to their default values.
the type id of the #GObject subtype to instantiate
an array of #GParameter
Data structure representing a #TpAccountChannelRequest object.