Unref the EmpathyTpContactFactory

Use gchar* instead of char* for allocated retvals

Use != NULL for pointer checks.

Use g_slice_* instead of g_malloc

Use tp_g_value_slice_new_* where possible

Unref the EmpathyTpContactFactory

Adapt the code to the tp style.

Plug a string leak

Don't destroy an hashtable owned by DBus

Update Python bindings

Wait for channel close before closing the socket

So that we can better handle cancellations of the transfer.

Add schema for the new preference

Don't leak GErrors.

Handle construction errors

Handle errors that may arise when constructing the handler from the
factory.

Set the right initial value in the UI

Set an initial value for the UI string in case we're not using hash.

Add some debug messages

Properly handle checksumming in the receiver UI

Remove the singleton logic from the manager

Don't use a singleton logic for the FT Manager, but let the manager
itself hold the references according to the state of the toplevel
window.

Adjust clear button sensitivity

Set the clear button sensitivity according to the number of
completed/cancelled handlers in the manager.

Adapt the manager code

Adapt the manager code to react to the new possible hashing.

Add empathy_ft_handler_get_use_hash

This is needed, as the GConf property might change during the transfer.

Fix a stupid mistake

W.I.P. for hash on receiver side.

Add use_hash params for incoming transfers

Add use_hash params for incoming transfers to the FT Factory and
Handler, so that we will use them to check hash for received files.

Clarify UI string

Checksum is not always possible.

Add a new preference in the UI

Add the USE_HASH property in class_init

Update the EmpathyFTFactory API

Update the factory API to make hashing request optional.

Make checksum optional when sending

Cleanup after rebase v2

First cleanup after rebase

Simplify the hashing code

Simplify the hashing code with the aid of GIOScheduler. This has the
nice side effect that checksum updating is now done in the I/O thread.

Ensure the callbacks are only run once

Also ensure that we get no progress callbacks after the transfer has
been cancelled.

Add back speed and remaining time

Close the handler when rejecting a transfer

React to Tp remote errors

Push Tp state change errors to the handler/UI.

Remove hashing progress debug message

Properly ref/unref the request table

Destroy the request table early, and keep a reference when passing it to
the dispatcher.
Also, don't cancel the nonexistant EmpathyTpFile when stopping hashing.

Don't set the status to cancelled when closing

If we are only closing a channel, don't set the EmpathyTpFile status to
cancelled.

Handle errors coming from the EmpathyFTFactory

Set the overwrite confermation when receiving

Unref the EmpathyFTHandlers

Unref EmpathyFTHandler objects after adding them to the manager.

Properly emit the TRANSFER_STARTED signal

Emit the TRANSFER_STARTED signal when actually starting the transfer
(after the DBus invocation callback).

Don't notify progress for zero bytes

Also, remove useless state property.

First implementation of error handling

Implement the callback in EmpathyFTManager.
Erase a redundant is_cancelled property in EmpathyFTHandler and rely on
the GCancellable, which is shared by EmpathyTpFile and EmpathyFTHandler.

Total FileTransfer draft spec exorcism

Rework the logic of cancelling transfers

Rework the logic of cancelling transfers so that the GCancellable object
is not used from an UI frontend, as that would require to duplicate
storage for each EmpathyFTHandler in the manager.

Use proper DEBUG() messages

Use values from TpFileTransferState

Use values from the TpFileTransferState and
TpFileTransferStateChangeReason enums instead of the Empathy draft
interfaces.

Only close the FT operation after the state change

Close the FT operation only after the "completed" state change has been
emitted, so that we can guarantee there will be no other progress
signals emitted after TRANSFER_DONE.
Also, add some other debug calls.

Format messages for hashing

Format messages when hashing.
Also, add some debug spew to see when the callbacks are called.

Emit the TRANSFER_STARTED signal

Emit the TRANSFER_STARTED signal also when offering.

Set the "incoming" property at construct

Set the "incoming" property of EmpathyTpFile when we construct it from
EmpathyDispatchOperation.

Sync with changes in master

Sync with the changes in master and port to the stable TP FileTransfer
spec.

Add is_completed and is_cancelled API

Add some API to get the state of the handler.

Use the proper TP interface instead of emp_cli

Update to use the stable TP interface for FT.

Make the whole thing compile

The branch now compiles. Still have to debug and implement error
handling.

Remove some of the EmpFileTransferState crack

The basic idea is to completely hide the state in EmpathyFTHandler, and
let the clients interact with the signal interface instead of switching
cases for the state.

Add empathy_ft_handler_get_total_bytes API

s/ft_manager/manager/ where appropriate

W.I.P. code for EmpathyFTManager v2

Use GET_PRIV everywhere
Stubs of implementations of the transfer state machine

Add empathy_ft_handler_get_transferred_bytes API

First batch of W.I.P. rework of EmpathyFTManager

Add to the EmpathyFTManager the new handlers.

Add some useful APIs to EmpathyFTHandler

Add some APIs to EmpathyFTHandler useful to get transfer properties.
Also, implement an error signal.

Fix indentation of function prototype

Remove useless include of empathy-tp-file.h

Remove dead code in EmpathyDispatcher

Rethink a bit the logic for an incoming transfer.

Now, a client should have to do the following, in order to receive a file transfer:
- let the EmpathyFTFactory claim the EmpathyDispatchOperation
- the factory will emit "new-incoming-transfer" when the handler is filled with
  the relevant properties
- now you can choose a destination file, and then you should call _set_destination
  on EmpathyFTFactory passing the handler.
- the factory will emit "new-ft-handler" as you're now ready to start the actual
  transfer.

Use the new API to send a file with the file chooser.

Emit the transfer_started signal as soon as we start an incoming transfer.

Free memory in _finalize inside EmpathyFTHandler.

We don't need dispose, finalize and private fields in EmpathyFTFactory (yet?).

Cleanup in EmpathyTpFile style.

Make libempathy compile with the new changes.

Modify EmpathyFTHandler to adapt to the changes in EmpathyTpFile API.

Remove the RequestData struct.

W.I.P. for heavy lifting on EmpathyTpFile.

Don't schedule the next read two times when we're finished reading the stream.

Add debug spew.

Add some error handling and keep on adding progress signals.

Fix the build.

Start implementing signals inside EmpathyFTHandler.

Implement empathy_ft_factory_claim_channel and make naming uniform.

Fix the build.

Set more meaningful names for EmpathyFTHandler public methods.

Call the dispatcher to create the Channel after we have built the request.

Implement hashing of the file. Make it compile.

Little cleanup.

Initial commit for EmpathyFTFactory and EmpathyFTHandler.

Only remove the address fields and position fields instead of all

Remove unused var

Get rid of McAccount everywhere

Shouldn't have to care about accounts, just connections.

Get rid of Mission Control as EmpathyAccountManager does all that too

Fix inconsistency in preferences and code

Don't set priv on a separate line

Use tp_g_value_slice_new_double

tp_asv_* cannot be used as tp_asv does not copy the keys

Reorder functions to get rid of the function declarations

Reimplement the singleton in the constructor

Fix errors found by make check