diff options
author | pescuma <pescuma@c086bb3d-8645-0410-b8da-73a8550f86e7> | 2011-10-10 01:39:18 +0000 |
---|---|---|
committer | pescuma <pescuma@c086bb3d-8645-0410-b8da-73a8550f86e7> | 2011-10-10 01:39:18 +0000 |
commit | e9bf8a6e2d782dc480fb97cb59928c8cfe1dd777 (patch) | |
tree | 12bb8ebaab13ef1476ce9343482796c901ee0130 /Plugins/jingle/libjingle/talk/session/fileshare/fileshare.h | |
parent | f574681d9b6fee0d05319af1831620e48cc8492f (diff) |
Moved files from BerliOS
git-svn-id: http://pescuma.googlecode.com/svn/trunk/Miranda@229 c086bb3d-8645-0410-b8da-73a8550f86e7
Diffstat (limited to 'Plugins/jingle/libjingle/talk/session/fileshare/fileshare.h')
-rw-r--r-- | Plugins/jingle/libjingle/talk/session/fileshare/fileshare.h | 250 |
1 files changed, 250 insertions, 0 deletions
diff --git a/Plugins/jingle/libjingle/talk/session/fileshare/fileshare.h b/Plugins/jingle/libjingle/talk/session/fileshare/fileshare.h new file mode 100644 index 0000000..b0802b4 --- /dev/null +++ b/Plugins/jingle/libjingle/talk/session/fileshare/fileshare.h @@ -0,0 +1,250 @@ +#ifndef TALK_APP_WIN32_FILESHARE_H__ +#define TALK_APP_WIN32_FILESHARE_H__ +#include "talk/base/messagequeue.h" +#include "talk/base/socketpool.h" +#include "talk/base/stringutils.h" +#include "talk/base/sigslot.h" +#include "talk/p2p/base/session.h" +#include "talk/p2p/base/sessiondescription.h" +#include "talk/xmpp/jid.h" + +class StreamCounter; +class StreamRelay; + +namespace talk_base { + class HttpClient; + class HttpServer; + class HttpTransaction; +} + +extern const std::string NS_GOOGLE_SHARE; + + +namespace cricket { + +/////////////////////////////////////////////////////////////////////////////// +// FileShareManifest +/////////////////////////////////////////////////////////////////////////////// + +class FileShareManifest { +public: + enum Type { T_FILE, T_IMAGE, T_FOLDER }; + enum { SIZE_UNKNOWN = talk_base::SIZE_UNKNOWN }; + + struct Item { + Type type; + std::string name; + size_t size, width, height; + }; + typedef std::vector<Item> ItemList; + + inline bool empty() const { return items_.empty(); } + inline size_t size() const { return items_.size(); } + inline const Item& item(size_t index) const { return items_[index]; } + + void AddFile(const std::string& name, size_t size); + void AddImage(const std::string& name, size_t size, + size_t width, size_t height); + void AddFolder(const std::string& name, size_t size); + + size_t GetItemCount(Type t) const; + inline size_t GetFileCount() const { return GetItemCount(T_FILE); } + inline size_t GetImageCount() const { return GetItemCount(T_IMAGE); } + inline size_t GetFolderCount() const { return GetItemCount(T_FOLDER); } + +private: + ItemList items_; +}; + + +enum FileShareState { + FS_NONE, // Initialization + FS_OFFER, // Offer extended + FS_TRANSFER, // In progress + FS_COMPLETE, // Completed successfully + FS_LOCAL_CANCEL, // Local side cancelled + FS_REMOTE_CANCEL, // Remote side cancelled + FS_FAILURE // An error occurred during transfer +}; + + +class FileShareSession + : public talk_base::StreamPool, + public talk_base::MessageHandler, + public sigslot::has_slots<> { +public: + struct FileShareDescription : public cricket::SessionDescription { + FileShareManifest manifest; + bool supports_http; + std::string source_path; + std::string preview_path; + FileShareDescription() : supports_http(false) { } + }; + + FileShareSession(cricket::Session* session, const std::string &user_agent); + virtual ~FileShareSession(); + + bool IsComplete() const; + bool IsClosed() const; + FileShareState state() const; + sigslot::signal1<FileShareState> SignalState; + sigslot::signal1<FileShareSession*> SignalNextFile; + sigslot::signal1<FileShareSession*> SignalUpdateProgress; + sigslot::signal4<std::string, int, int, talk_base::HttpTransaction*> SignalResampleImage; + + void ResampleComplete(talk_base::StreamInterface *si, talk_base::HttpTransaction *trans, bool success); + + bool is_sender() const; + const buzz::Jid& jid() const; + const FileShareManifest* manifest() const; + const std::string& local_folder() const; + + void SetLocalFolder(const std::string& folder) { local_folder_ = folder; } + void Share(const buzz::Jid& jid, FileShareManifest* manifest); + + void Accept(); + void Decline(); + void Cancel(); + + bool GetItemUrl(size_t index, std::string* url); + bool GetImagePreviewUrl(size_t index, size_t width, size_t height, + std::string* url); + // Returns true if the transferring item size is known + bool GetProgress(size_t& bytes) const; + // Returns true if the total size is known + bool GetTotalSize(size_t& bytes) const; + // Returns true if currently transferring item name is known + bool GetCurrentItemName(std::string* name); + + // TODO: Eliminate this eventually? + cricket::Session* session() { return session_; } + + // StreamPool Interface + virtual talk_base::StreamInterface* + RequestConnectedStream(const talk_base::SocketAddress& remote, int* err); + virtual void ReturnConnectedStream(talk_base::StreamInterface* stream); + + // MessageHandler Interface + virtual void OnMessage(talk_base::Message* msg); + + void GetItemNetworkPath(size_t index, bool preview, std::string* path); + +private: + typedef std::list<StreamRelay*> ProxyList; + typedef std::list<talk_base::HttpTransaction*> TransactionList; + + // Session Signals + void OnSessionState(cricket::Session* session, cricket::Session::State state); + void OnSessionInfoMessage(cricket::Session* session, + const cricket::Session::XmlElements& els); + void OnSessionChannelGone(cricket::Session* session, + const std::string& name); + + // HttpClient Signals + void OnHttpClientComplete(talk_base::HttpClient* http, int err); + void OnHttpClientClosed(talk_base::HttpClient* http, int err); + + // HttpServer Signals + void OnHttpRequest(talk_base::HttpServer* server, + talk_base::HttpTransaction* transaction); + void OnHttpRequestComplete(talk_base::HttpServer* server, + talk_base::HttpTransaction* transaction, + int err); + void OnHttpConnectionClosed(talk_base::HttpServer* server, + int err, + talk_base::StreamInterface* stream); + + // TarStream Signals + void OnNextEntry(const std::string& name, size_t size); + + // Socket Signals + void OnProxyAccept(talk_base::AsyncSocket* socket); + void OnProxyClosed(StreamRelay* proxy, int error); + + // StreamCounterSignals + void OnUpdateBytes(size_t count); + + // Internal Helpers + void GenerateTemporaryPrefix(std::string* prefix); + bool GetItemBaseUrl(size_t index, bool preview, std::string* url); + bool GetProxyAddress(talk_base::SocketAddress& address, bool is_remote); + talk_base::StreamInterface* CreateChannel(const std::string& channel_name); + void SetState(FileShareState state, bool prevent_close); + void OnInitiate(); + void NextDownload(); + const FileShareDescription* description() const; + void DoClose(bool terminate); + + cricket::Session* session_; + FileShareState state_; + bool is_closed_; + bool is_sender_; + buzz::Jid jid_; + FileShareManifest* manifest_; + std::string source_path_; + std::string preview_path_; + std::string local_folder_; + + // The currently active p2p streams to our peer + talk_base::StreamCache pool_; + // The http client state (client only) + talk_base::HttpClient* http_client_; + // The http server state (server only) + talk_base::HttpServer* http_server_; + // The connection id of the currently transferring file (server) + int transfer_connection_id_; + // The counter for the currently transferring file + const StreamCounter* counter_; + // The number of manifest items that have successfully transferred + size_t item_transferring_; + // The byte count of successfully transferred items + size_t bytes_transferred_; + // Where the currently transferring item is being (temporarily) saved (client) + std::string transfer_path_; + // The name of the currently transferring item + std::string transfer_name_; + // Where the files are saved after transfer (client) + std::vector<std::string> stored_location_; + // Was it a local cancel? Or a remote cancel? + bool local_cancel_; + // Proxy socket for local IE http requests + talk_base::AsyncSocket* local_listener_; + // Proxy socket for remote IE http requests + talk_base::AsyncSocket* remote_listener_; + // Cached address of remote_listener_ + talk_base::SocketAddress remote_listener_address_; + // Uniqueness for channel names + size_t next_channel_id_; + // Proxy relays + ProxyList proxies_; + std::string user_agent_; + TransactionList transactions_; +}; + +class FileShareSessionClient : public SessionClient +{ + public: + FileShareSessionClient(SessionManager *sm, buzz::Jid jid, const std::string &user_agent) : sm_(sm), jid_(jid), + user_agent_(user_agent) {} + virtual void OnSessionCreate(cricket::Session* session, + bool received_initiate); + virtual void OnSessionDestroy(cricket::Session* session); + virtual const cricket::SessionDescription* CreateSessionDescription(const buzz::XmlElement* element); + virtual buzz::XmlElement* TranslateSessionDescription(const cricket::SessionDescription* description); + FileShareSession *CreateFileShareSession(); + + sigslot::signal1<FileShareSession*> SignalFileShareSessionCreate; + sigslot::signal1<FileShareSession*> SignalFileShareSessionDestroy; + + private: + SessionManager *sm_; + buzz::Jid jid_; + friend class FileShareSession; + typedef std::set<cricket::Session*> SessionSet; + SessionSet sessions_; + std::string user_agent_; +}; + +} // namespace cricket + +#endif // TALK_APP_WIN32_FILESHARE_H__ |