diff options
Diffstat (limited to 'kopete/protocols/meanwhile/meanwhilesession.h')
| -rw-r--r-- | kopete/protocols/meanwhile/meanwhilesession.h | 350 |
1 files changed, 350 insertions, 0 deletions
diff --git a/kopete/protocols/meanwhile/meanwhilesession.h b/kopete/protocols/meanwhile/meanwhilesession.h new file mode 100644 index 00000000..0e2a3558 --- /dev/null +++ b/kopete/protocols/meanwhile/meanwhilesession.h @@ -0,0 +1,350 @@ +/* + meanwhilesession.h - interface to the 'C' meanwhile session + + Copyright (c) 2005 by Jeremy Kerr <[email protected]> + + ************************************************************************* + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + ************************************************************************* +*/ +#ifndef MEANWHILESESSION_H +#define MEANWHILESESSION_H + +#include "meanwhileaccount.h" +#include "meanwhilecontact.h" +#include <kextendedsocket.h> + +#include <mw_session.h> +#include <mw_service.h> +#include <mw_srvc_aware.h> +#include <mw_srvc_im.h> +#include <mw_srvc_resolve.h> + +struct MeanwhileClientID { + int id; + const char *name; +}; + +/** + * A class to handle libmeanwhile session management. + */ +class MeanwhileSession : public QObject +{ + Q_OBJECT + +public: + /** + * Create a session. By default, the session is not connected - you will + * need to call login() to initiate the connection process. + * @param account The account that the connection is for + */ + MeanwhileSession(MeanwhileAccount *account); + + /** + * Destroy the session + */ + ~MeanwhileSession(); + + /** + * Connect to the server. This will open a socket and start login. Note that + * the connection process is ascychronous - a loginDone() signal will be + * emitted when sucessfully logged in. + */ + void connect(QString password); + + /** + * Disconnect from the server. + */ + void disconnect(); + + /** + * Set our (the local contact's) online status. The internalStatus of the + * state argument will be used to define the state message we send - it + * should be one of the Status enum fields (and not Offline) + * @param state the new state of the local user + * @param msg a custom message to use, if required + */ + void setStatus(Kopete::OnlineStatus status, + const QString msg = QString::null); + + /** + * Add a single contact to be registered for status updates + * @param contact The contact to register + */ + void addContact(const Kopete::Contact *contact); + + /** + * Add a list of contacts to be registered for status updates + * @param contact The list of contacts to register + */ + void addContacts(const QDict<Kopete::Contact>& contacts); + + /** + * Send a message (with recipient specified). + * @param message The message to send + * @return non-zero if the message could be sent + */ + int sendMessage(Kopete::Message &message); + + /** + * Send a typing notification to a contact + * @param contact The contact to notify + * @param isTyping If true, the typing notification is set + */ + void sendTyping(MeanwhileContact *contact, bool isTyping); + + /** + * Determine if the session is connected to the server + * @return true if the session is connected + */ + bool isConnected(); + + /** + * Determine if the session is in the process of connecting to the server + * @return true if the session is connecting + */ + bool isConnecting(); + + static const struct MeanwhileClientID *getClientIDs(); + + static void getDefaultClientIDParams(int *clientID, + int *verMajor, int *verMinor); +signals: + /** + * Emitted when the status of the connection changes + * @param status The new status of the session + */ + void sessionStateChange(Kopete::OnlineStatus status); + + /** + * Emitted when a notification is received from the server, or other + * out-of-band data (eg, the password is incorrect). + * @param mesgString A description of the notification + */ + void serverNotification(const QString &mesgString); + +private: + /** Main libmeanwhile session object */ + struct mwSession *session; + + /** Session handler */ + struct mwSessionHandler sessionHandler; + + /** Aware service */ + struct mwServiceAware *awareService; + + /** Aware handler */ + struct mwAwareHandler awareHandler; + + /** Aware List Handler */ + struct mwAwareListHandler awareListHandler; + + /** The aware list */ + struct mwAwareList *awareList; + + /** Aware service */ + struct mwServiceIm *imService; + + /** Aware handler */ + struct mwImHandler imHandler; + + /** Resolve service */ + struct mwServiceResolve *resolveService; + + /** Storage service, for contact list */ + struct mwServiceStorage *storageService; + + /** Last recorded meanwhile state */ + enum mwSessionState state; + + /** The kopete account that this library is for */ + MeanwhileAccount *account; + + /** socket to the server */ + KExtendedSocket *socket; + + /* These structures are stored in the libmeanwhile 'ClientData' fields */ + + /** Stored in the mwConversation struct */ + struct ConversationData { + MeanwhileContact *contact; + Kopete::ChatSession *chat; + QValueList<Kopete::Message> *queue; + }; + + /** (To be) stored in the mwConference struct */ + struct ConferenceData { + Kopete::ChatSession *chatsession; + }; + + /** + * Initialise the conversation data struct for a conversation, and store it + * in the meanwhile conversation object + * @param conv the meanwhile conversation object + * @param contact the contact that the conversation is with + * @param createQueue whether a message queue is required for this + * conversation + * @return The created conversation data struct + */ + struct ConversationData *createConversationData( + struct mwConversation *conv, MeanwhileContact *contact, + bool createQueue = false); + + /** + * Get the contact for a conversation + * @param conv the meanwhile conversation + * @return the contact that this conversation is held with + */ + MeanwhileContact *conversationContact(struct mwConversation *conv); + + /** + * Convert a libmeanwhile-type status into one of the MeanwhileProtocol + * statuses + * @param mstatus The internal status to convert + * @return The Meanwhile status + */ + Kopete::OnlineStatus convertStatus(int mstatus); + + /** + * Parse the nickname of a libmeanwhile contact. From what I've seen, + * usernames are in the format: + * <userid> - <name>/<domain>/<domain> + * @param name the extened username to parse + * @return just the name part of the username info + */ + QString getNickName(QString name); + + /** + * Convenience method to call the above from a mwLoginInfo struct. All is + * checked for null. + * @param logininfo the login info for a contact + * @return just the name part of the login info data + */ + QString getNickName(struct mwLoginInfo *logininfo); + + /** + * Resolve a contact to find (and set) the display name. This requires the + * session to be connected to use the meanwhile resolve service. + * @param contact The contact to resolve + */ + void resolveContactNickname(MeanwhileContact *contact); + +public: + void syncContactsToServer(); + void syncContactsFromServer(); + +private slots: + + /** Notify the library that data is available on the socket */ + void slotSocketDataAvailable(); + + /** + * Notify the library that the socket has been closed + * @param reason the reason for closing + */ + void slotSocketClosed(int reason); + +private: + /* ugly callbacks for libmeanwhile interface. These declare a static method + * to proxy the callback from libmeanwhile to a call to the MeanwhileSession + */ + +#define declare_session_handler_type(type, func, args, ...) \ + static type _handleSession ## func ( \ + struct mwSession *mwsession, __VA_ARGS__) { \ + MeanwhileSession *session = \ + (MeanwhileSession *)mwSession_getClientData(mwsession); \ + return session->handleSession ## func args; \ + }; \ + type handleSession ## func(__VA_ARGS__) +#define declare_session_handler(func, args, ...) \ + static void _handleSession ## func ( \ + struct mwSession *mwsession, ## __VA_ARGS__) { \ + MeanwhileSession *session = \ + (MeanwhileSession *)mwSession_getClientData(mwsession); \ + session->handleSession ## func args; \ + }; \ + void handleSession ## func(__VA_ARGS__) + + declare_session_handler_type(int, IOWrite, (buf, len), + const guchar *buf, gsize len); + declare_session_handler(IOClose,()); + declare_session_handler(Clear,()); + declare_session_handler(StateChange, (state, info), + enum mwSessionState state, gpointer info); + declare_session_handler(SetPrivacyInfo,()); + declare_session_handler(SetUserStatus,()); + declare_session_handler(Admin, (text), const char *text); + declare_session_handler(Announce, (from, may_reply, text), + struct mwLoginInfo *from, gboolean may_reply, const char *text); + +#define declare_aware_handler(func, args, ...) \ + static void _handleAware ## func ( \ + struct mwServiceAware *srvc, ## __VA_ARGS__) { \ + MeanwhileSession *session = (MeanwhileSession *) \ + mwService_getClientData((struct mwService *)srvc); \ + return session->handleAware ## func args; \ + }; \ + void handleAware ## func(__VA_ARGS__) + + declare_aware_handler(Attrib, (attrib), struct mwAwareAttribute *attrib); + declare_aware_handler(Clear,()); + +#define declare_aware_list_handler(func, args, ...) \ + static void _handleAwareList ## func ( \ + struct mwAwareList *list, ## __VA_ARGS__){ \ + MeanwhileSession *session = (MeanwhileSession *) \ + mwAwareList_getClientData(list); \ + return session->handleAwareList ## func args; \ + }; \ + void handleAwareList ## func(__VA_ARGS__) + + declare_aware_list_handler(Aware, (snapshot), + struct mwAwareSnapshot *snapshot); + declare_aware_list_handler(Attrib, (id, attrib), + struct mwAwareIdBlock *id, struct mwAwareAttribute *attrib); + declare_aware_list_handler(Clear,()); + +#define declare_im_handler(func, args, ...) \ + static void _handleIm ## func ( \ + struct mwConversation *conv, ## __VA_ARGS__) { \ + MeanwhileSession *session = (MeanwhileSession *) \ + mwService_getClientData( \ + (struct mwService *)mwConversation_getService(conv)); \ + return session->handleIm ## func args; \ + }; \ + void handleIm ## func (struct mwConversation *conv, ## __VA_ARGS__) + + declare_im_handler(ConvOpened, (conv)); + declare_im_handler(ConvClosed, (conv, err), guint32 err); + declare_im_handler(ConvReceived, (conv, type, msg), + enum mwImSendType type, gconstpointer msg); + + /* resolve service */ + static void _handleResolveLookupResults(struct mwServiceResolve *srvc, + guint32 id, guint32 code, GList *results, gpointer data) { + MeanwhileSession *session = (MeanwhileSession *) + mwService_getClientData(MW_SERVICE(srvc)); + session->handleResolveLookupResults(srvc, id, code, results, data); + }; + void handleResolveLookupResults(struct mwServiceResolve *srvc, guint32 id, + guint32 code, GList *results, gpointer data); + + /* storage service */ + static void _handleStorageLoad(struct mwServiceStorage *srvc, + guint32 result, struct mwStorageUnit *item, gpointer data) { + MeanwhileSession *session = (MeanwhileSession *) + mwService_getClientData(MW_SERVICE(srvc)); + session->handleStorageLoad(srvc, result, item, data); + }; + void handleStorageLoad(struct mwServiceStorage *srvc, + guint32 result, struct mwStorageUnit *item, gpointer data); +}; + +#endif + |