/**
* empathy_ft_handler_start_transfer:
* @handler: an #EmpathyFTHandler
*
* Starts the transfer machinery. After this call, the transfer and hashing
* signals will be emitted by the handler.
*/
void
empathy_ft_handler_start_transfer (EmpathyFTHandler *handler)
{
EmpathyFTHandlerPriv *priv;
g_return_if_fail (EMPATHY_IS_FT_HANDLER (handler));
priv = handler->priv;
if (priv->channel == NULL)
{
ft_handler_complete_request (handler);
}
else
{
/* TODO: add support for resume. */
tp_file_transfer_channel_accept_file_async (priv->channel,
priv->gfile, 0, ft_transfer_accept_cb, handler);
tp_g_signal_connect_object (priv->channel, "notify::state",
G_CALLBACK (ft_transfer_state_cb), handler, 0);
tp_g_signal_connect_object (priv->channel, "notify::transferred-bytes",
G_CALLBACK (ft_transfer_transferred_bytes_cb), handler, 0);
}
}
/**
* empathy_ft_handler_get_contact:
* @handler: an #EmpathyFTHandler
*
* Returns the remote #EmpathyContact at the other side of the transfer.
*
* Return value: the remote #EmpathyContact for @handler
*/
EmpathyContact *
empathy_ft_handler_get_contact (EmpathyFTHandler *handler)
{
EmpathyFTHandlerPriv *priv;
g_return_val_if_fail (EMPATHY_IS_FT_HANDLER (handler), NULL);
priv = GET_PRIV (handler);
return priv->contact;
}
/**
* empathy_ft_handler_get_gfile:
* @handler: an #EmpathyFTHandler
*
* Returns the #GFile where the transfer is being read/saved.
*
* Return value: the #GFile where the transfer is being read/saved
*/
GFile *
empathy_ft_handler_get_gfile (EmpathyFTHandler *handler)
{
EmpathyFTHandlerPriv *priv;
g_return_val_if_fail (EMPATHY_IS_FT_HANDLER (handler), NULL);
priv = GET_PRIV (handler);
return priv->gfile;
}
/**
* empathy_ft_handler_get_total_bytes:
* @handler: an #EmpathyFTHandler
*
* Returns the total size of the file being transferred by the handler.
*
* Return value: a number of bytes indicating the total size of the file being
* transferred by the handler.
*/
guint64
empathy_ft_handler_get_total_bytes (EmpathyFTHandler *handler)
{
EmpathyFTHandlerPriv *priv;
g_return_val_if_fail (EMPATHY_IS_FT_HANDLER (handler), 0);
priv = GET_PRIV (handler);
return priv->total_bytes;
}
/**
* empathy_ft_handler_get_use_hash:
* @handler: an #EmpathyFTHandler
*
* Returns whether @handler has checksumming enabled. This can depend on
* the CM and the remote contact capabilities.
*
* Return value: %TRUE if the handler has checksumming enabled,
* %FALSE otherwise.
*/
gboolean
empathy_ft_handler_get_use_hash (EmpathyFTHandler *handler)
{
EmpathyFTHandlerPriv *priv;
g_return_val_if_fail (EMPATHY_IS_FT_HANDLER (handler), FALSE);
priv = GET_PRIV (handler);
return priv->use_hash;
}
const char *
empathy_ft_handler_get_description (EmpathyFTHandler *handler)
{
EmpathyFTHandlerPriv *priv;
g_return_val_if_fail (EMPATHY_IS_FT_HANDLER (handler), NULL);
priv = handler->priv;
return priv->description;
}
/**
* empathy_ft_handler_get_transferred_bytes:
* @handler: an #EmpathyFTHandler
*
* Returns the number of bytes already transferred by the handler.
*
* Return value: the number of bytes already transferred by the handler.
*/
guint64
empathy_ft_handler_get_transferred_bytes (EmpathyFTHandler *handler)
{
EmpathyFTHandlerPriv *priv;
g_return_val_if_fail (EMPATHY_IS_FT_HANDLER (handler), 0);
priv = handler->priv;
return priv->transferred_bytes;
}
/**
* empathy_ft_handler_get_filename:
* @handler: an #EmpathyFTHandler
*
* Returns the name of the file being transferred.
*
* Return value: the name of the file being transferred
*/
const char *
empathy_ft_handler_get_filename (EmpathyFTHandler *handler)
{
EmpathyFTHandlerPriv *priv;
g_return_val_if_fail (EMPATHY_IS_FT_HANDLER (handler), NULL);
priv = handler->priv;
return priv->filename;
}
/**
* empathy_ft_handler_is_completed:
* @handler: an #EmpathyFTHandler
*
* Returns whether the transfer for @handler has been completed succesfully.
*
* Return value: %TRUE if the handler has been transferred correctly, %FALSE
* otherwise
*/
gboolean
empathy_ft_handler_is_completed (EmpathyFTHandler *handler)
{
EmpathyFTHandlerPriv *priv;
g_return_val_if_fail (EMPATHY_IS_FT_HANDLER (handler), FALSE);
priv = GET_PRIV (handler);
return priv->is_completed;
}
/**
* empathy_ft_handler_get_content_type:
* @handler: an #EmpathyFTHandler
*
* Returns the content type of the file being transferred.
*
* Return value: the content type of the file being transferred
*/
const char *
empathy_ft_handler_get_content_type (EmpathyFTHandler *handler)
{
EmpathyFTHandlerPriv *priv;
g_return_val_if_fail (EMPATHY_IS_FT_HANDLER (handler), NULL);
priv = GET_PRIV (handler);
return priv->content_type;
}
/**
* empathy_ft_handler_is_cancelled:
* @handler: an #EmpathyFTHandler
*
* Returns whether the transfer for @handler has been cancelled or has stopped
* due to an error.
*
* Return value: %TRUE if the transfer for @handler has been cancelled
* or has stopped due to an error, %FALSE otherwise.
*/
gboolean
empathy_ft_handler_is_cancelled (EmpathyFTHandler *handler)
{
EmpathyFTHandlerPriv *priv;
g_return_val_if_fail (EMPATHY_IS_FT_HANDLER (handler), FALSE);
priv = GET_PRIV (handler);
return g_cancellable_is_cancelled (priv->cancellable);
}
/**
* empathy_ft_handler_is_incoming:
* @handler: an #EmpathyFTHandler
*
* Returns whether @handler is incoming or outgoing.
*
* Return value: %TRUE if the handler is incoming, %FALSE otherwise.
*/
gboolean
empathy_ft_handler_is_incoming (EmpathyFTHandler *handler)
{
EmpathyFTHandlerPriv *priv;
g_return_val_if_fail (EMPATHY_IS_FT_HANDLER (handler), FALSE);
priv = handler->priv;
if (priv->channel == NULL)
return FALSE;
return !tp_channel_get_requested ((TpChannel *) priv->channel);
}
/**
* empathy_ft_factory_set_destination_for_incoming_handler:
* @factory: an #EmpathyFTFactory
* @handler: the #EmpathyFTHandler to set the destination of
* @destination: the #GFile destination of the transfer
*
* Sets @destination as destination file for the transfer. After the call of
* this method, the ::new-ft-handler will be emitted for the incoming handler.
*/
void
empathy_ft_factory_set_destination_for_incoming_handler (
EmpathyFTFactory *factory,
EmpathyFTHandler *handler,
GFile *destination)
{
g_return_if_fail (EMPATHY_IS_FT_FACTORY (factory));
g_return_if_fail (EMPATHY_IS_FT_HANDLER (handler));
g_return_if_fail (G_IS_FILE (destination));
empathy_ft_handler_incoming_set_destination (handler, destination);
g_signal_emit (factory, signals[NEW_FT_HANDLER], 0, handler, NULL);
}
/**
* empathy_ft_handler_is_incoming:
* @handler: an #EmpathyFTHandler
*
* Returns whether @handler is incoming or outgoing.
*
* Return value: %TRUE if the handler is incoming, %FALSE otherwise.
*/
gboolean
empathy_ft_handler_is_incoming (EmpathyFTHandler *handler)
{
EmpathyFTHandlerPriv *priv;
g_return_val_if_fail (EMPATHY_IS_FT_HANDLER (handler), FALSE);
priv = GET_PRIV (handler);
if (priv->tpfile == NULL)
return FALSE;
return empathy_tp_file_is_incoming (priv->tpfile);
}
void
empathy_ft_manager_add_handler (EmpathyFTHandler *handler)
{
EmpathyFTManager *manager;
EmpathyFTManagerPriv *priv;
DEBUG ("Adding handler");
g_return_if_fail (EMPATHY_IS_FT_HANDLER (handler));
manager = g_object_new (EMPATHY_TYPE_FT_MANAGER, NULL);
priv = GET_PRIV (manager);
ft_manager_add_handler_to_list (manager, handler, NULL);
gtk_window_present (GTK_WINDOW (priv->window));
}
void
empathy_ft_manager_display_error (EmpathyFTHandler *handler,
const GError *error)
{
EmpathyFTManager *manager;
EmpathyFTManagerPriv *priv;
g_return_if_fail (EMPATHY_IS_FT_HANDLER (handler));
g_return_if_fail (error != NULL);
manager = g_object_new (EMPATHY_TYPE_FT_MANAGER, NULL);
priv = GET_PRIV (manager);
ft_manager_add_handler_to_list (manager, handler, error);
gtk_window_present (GTK_WINDOW (priv->window));
}
/**
* empathy_ft_handler_cancel_transfer:
* @handler: an #EmpathyFTHandler
*
* Cancels an ongoing handler operation. Note that this doesn't destroy
* the object, which will keep all the properties, altough it won't be able
* to do any more I/O.
*/
void
empathy_ft_handler_cancel_transfer (EmpathyFTHandler *handler)
{
EmpathyFTHandlerPriv *priv;
g_return_if_fail (EMPATHY_IS_FT_HANDLER (handler));
priv = GET_PRIV (handler);
/* if we don't have an EmpathyTpFile, we are hashing, so
* we can just cancel the GCancellable to stop it.
*/
if (priv->tpfile == NULL)
g_cancellable_cancel (priv->cancellable);
else
empathy_tp_file_cancel (priv->tpfile);
}
/**
* empathy_ft_handler_cancel_transfer:
* @handler: an #EmpathyFTHandler
*
* Cancels an ongoing handler operation. Note that this doesn't destroy
* the object, which will keep all the properties, altough it won't be able
* to do any more I/O.
*/
void
empathy_ft_handler_cancel_transfer (EmpathyFTHandler *handler)
{
EmpathyFTHandlerPriv *priv;
g_return_if_fail (EMPATHY_IS_FT_HANDLER (handler));
priv = handler->priv;
/* if we don't have a channel, we are hashing, so
* we can just cancel the GCancellable to stop it.
*/
if (priv->channel == NULL)
g_cancellable_cancel (priv->cancellable);
else
tp_channel_close_async (TP_CHANNEL (priv->channel), NULL, NULL);
}
/**
* empathy_ft_handler_start_transfer:
* @handler: an #EmpathyFTHandler
*
* Starts the transfer machinery. After this call, the transfer and hashing
* signals will be emitted by the handler.
*/
void
empathy_ft_handler_start_transfer (EmpathyFTHandler *handler)
{
EmpathyFTHandlerPriv *priv;
g_return_if_fail (EMPATHY_IS_FT_HANDLER (handler));
priv = GET_PRIV (handler);
if (priv->tpfile == NULL)
{
ft_handler_complete_request (handler);
}
else
{
/* TODO: add support for resume. */
empathy_tp_file_accept (priv->tpfile, 0, priv->gfile, priv->cancellable,
ft_transfer_progress_callback, handler,
ft_transfer_operation_callback, handler);
}
}
/**
* empathy_ft_handler_incoming_set_destination:
* @handler: an #EmpathyFTHandler
* @destination: the #GFile where the transfer should be saved
*
* Sets the destination of the incoming handler to be @destination.
* Note that calling this method is mandatory before starting the transfer
* for incoming handlers.
*/
void
empathy_ft_handler_incoming_set_destination (EmpathyFTHandler *handler,
GFile *destination)
{
EmpathyFTHandlerPriv *priv;
g_return_if_fail (EMPATHY_IS_FT_HANDLER (handler));
g_return_if_fail (G_IS_FILE (destination));
priv = GET_PRIV (handler);
g_object_set (handler, "gfile", destination, NULL);
/* check if hash is supported. if it isn't, set use_hash to FALSE
* anyway, so that clients won't be expecting us to checksum.
*/
if (EMP_STR_EMPTY (priv->content_hash) ||
priv->content_hash_type == TP_FILE_HASH_TYPE_NONE)
priv->use_hash = FALSE;
else
priv->use_hash = TRUE;
}
