summaryrefslogtreecommitdiff
path: root/Plugins/jingle/libjingle/talk/session/fileshare/fileshare.h
diff options
context:
space:
mode:
authorpescuma <pescuma@c086bb3d-8645-0410-b8da-73a8550f86e7>2011-10-10 01:39:18 +0000
committerpescuma <pescuma@c086bb3d-8645-0410-b8da-73a8550f86e7>2011-10-10 01:39:18 +0000
commite9bf8a6e2d782dc480fb97cb59928c8cfe1dd777 (patch)
tree12bb8ebaab13ef1476ce9343482796c901ee0130 /Plugins/jingle/libjingle/talk/session/fileshare/fileshare.h
parentf574681d9b6fee0d05319af1831620e48cc8492f (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.h250
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__