www.pudn.com > fanccMSNr.src.rar > ChatterModel.hpp

#pragma once 
#include  
#include  
#include  
#include  
#include  
using namespace std; 
 
#include "MessageDispatcher.hpp" 
#include "ChatterListener.hpp" 
#include "User.hpp" 
#include "FileTransferModel.hpp" 
#include "InvitationMessage.hpp" 
 
namespace poral { 
	class MessengerModel; 
 
	/** 
	* Manages connection with switchboard server. 
	* Handles only one-to-one chatting for now. 
	*/ 
	class ChatterModel:  
		public MessageListener			// interface 
	{ 
		// Type and property definitions  ///////////////////// 
	public: 
		typedef enum { 
			/** Not yet connected with switchboard server. */ 
			NOT_CONNECTED, 
			/** Companion has leaved from the chatting room. */ 
			CONNECTED_ALONE, 
			/** Attempting to connect to accept the invitation from the companion. */ 
			ACCEPTING_THE_INVITATION, 
			/** Attempting to connect to invite the companion. */ 
			ATTEMPTING_TO_CONNECT, 
			/** Invited the companion, but not yet participated. */ 
			WAITING_FOR_COMPANION, 
			/** A companion participated. */ 
			ONE_TO_ONE_CHAT, 
			/** NOT YET IMPLEMENTED. The companions more than two participated. */ 
			MANY_TO_MANY_CHAT, 
		} Status; 
		/** Supports only single transfer with a companion. */ 
		FileTransferModel fileTransferModel; 
 
	protected: 
		Status status; 
		/** Should refrenced by getTransactionID() */ 
		int transactionID; 
 
		MessengerModel *messengerModel; 
		MessageDispatcher *messageDispatcher; 
		list listeners; 
		/** 
		* A companion to talk to. 
		* Valid only id and screenName fields. 
		*/ 
		User companion; 
 
		// These values needed for accept invitation 
		string initHash; 
		string initSessionID; 
		string screenName; 
 
		/**  
		* Indicates whether view has been requested.  
		* Used when invited to switchboard. 
		*/ 
		bool viewRequested; 
 
		/** Message buffer to send.	*/ 
		queue > messageBuffer; 
 
		string serverIP; 
 
		/**  
		* filename to store incoming data.  
		*/ 
		string filename; 
 
	public: 
		// Constructors and destructors ///////////////////// 
		ChatterModel(); 
		virtual ~ChatterModel(void); 
 
		// Getter and setters ///////////////////// 
		Status getStatus() const { 
			return status; 
		} 
		int getTransactionID() { 
			return transactionID++; 
		} 
		const User &getCompanion() const { 
			return companion; 
		} 
		MessengerModel &getMessengerModel() { 
			return *messengerModel; 
		} 
		void addChatterListener(ChatterListener &listener); 
		void removeChatterListener(const ChatterListener &listener); 
 
		// Operators ///////////////////// 
		/** 
		* Connect to switchboard server to accept invitation. 
		* 
		* @param RNGMessage Invitaiton message from notification server. 
		*/ 
		void connect(MessengerModel &messengerModel, const Message &RNGMessage); 
		/** 
		* Connect to switchboard server to invite the companion. 
		*/ 
		void connect(MessengerModel &messengerModel, const Message &XFRMessage, const string &companionId); 
 
		void sendMessage(const string &message); 
		 
		// file transfer related methods 
		void acceptFileTransfer(const string &cookie, const string &filename); 
		void rejectFileTransfer(const string &cookie); 
		void inviteFileTransfer(const string &filename); 
 
		/** 
		* Compare by refrence-equality. 
		* Implemented for find() algorithm with list in MessengerModel 
		*/ 
		bool operator==(const ChatterModel &model) { 
			if(this==&model) { 
				return true; 
			} 
			return false; 
		} 
 
		// Implementation of MessageListener. ///////////////////// 
		// Shoud not call these mehtods. 
		virtual void connected(); 
		virtual void messageArrived(const Message &message); 
		virtual void failed(); 
 
	protected: 
		/** Reconnect to switchboard. */ 
		void reconnect(); 
		void callCompanion(const string &companionID); 
		/** Fires MessengerModel::fireChatterViewRequested if it has not yet requested */ 
		void fireChatterViewRequested(); 
		// these methods fire ChatterListener. 
		void fireFileTransferInvited(const string &filename, size_t size, const string &cookie); 
		void fireFileTransferRejected(const string &cookie); 
		void fireTyping(const string &user); 
		void fireChatterUpdate(ChatterListener::Event event); 
		void fireMessageArrived(const ChatMessage &inMessage); 
 
		/** Sends a message not via messageBuffer */ 
		void sendMessageNow(const string &message); 
		/** Sends all messages in messageBuffer */ 
		void sendBufferedMessages(); 
 
		void setStatus(Status status); 
		/**  
		* Change model status to disconnected.  
		* 
		* @param closed Indicates messageDispatcher has been closed. 
		*               disconnect() does not call messageDispatcher->close(); 
		*				when this variable set to true. 
		*/ 
		void disconnect(ChatterListener::Event event, bool closed=false); 
 
		void sendInvitationMessage(const InvitationMessage &invMessage); 
 
	private: 
		/** Used privately in messageArrived() */ 
		void MIMEMessageArrived(const MIMEMessage &message); 
 
		friend class FileTransferModel; 
	}; 
}