Chat-O-Matic/protocols/xmpp/JabberHandler.h
Jaidyn Ann 0326cee687 Move roster into its own generic window
The roster list is now split from MainWindow into RosterWindow, which
can be used arbitrarily for selecting something from contacts. The
im_what, title, and target can be specified.

Right now it's in use under the Chat menu, "New chat…". Chats can only
have two members (DM/PM), so "New chat…" directly leads to the roster
list.

In the future, roster list might be extended to allow specification of
non-contact users based on their identifiers, or filtering based on
protocol/account― this could help it with "invites" to future rooms,
etc.

IM_CREATE_CHAT and IM_CHAT_CREATED were also added to the protocol API,
allowing a new chat to be explicitly created from Caya or the protocol.
2021-05-26 07:48:25 -05:00

150 lines
5.0 KiB
C++

/*
* Copyright 2010, Pier Luigi Fiorini. All rights reserved.
* Distributed under the terms of the GPL v2 License.
*/
#ifndef _JABBER_HANDLER_H
#define _JABBER_HANDLER_H
#include <Notification.h>
#include <Path.h>
#include <String.h>
#include <gloox/client.h>
#include <gloox/chatstatehandler.h>
#include <gloox/connectionlistener.h>
#include <gloox/connectiontcpclient.h>
#include <gloox/discohandler.h>
#include <gloox/disco.h>
#include <gloox/rostermanager.h>
#include <gloox/loghandler.h>
#include <gloox/logsink.h>
#include <gloox/messagehandler.h>
#include <gloox/messagesession.h>
#include <gloox/messagesessionhandler.h>
#include <gloox/messageeventhandler.h>
#include <gloox/message.h>
#include <gloox/presence.h>
#include <gloox/vcardhandler.h>
#include <gloox/vcardmanager.h>
#include <CayaProtocol.h>
#include <CayaConstants.h>
class BList;
class JabberHandler : public CayaProtocol, gloox::RosterListener, gloox::ConnectionListener,
gloox::LogHandler, gloox::MessageSessionHandler,
gloox::MessageHandler, gloox::MessageEventHandler,
gloox::ChatStateHandler, gloox::VCardHandler {
public:
JabberHandler();
virtual ~JabberHandler();
// CayaProtocol inheritance
virtual status_t Init(CayaProtocolMessengerInterface*);
virtual status_t Process(BMessage* msg);
virtual status_t Shutdown();
virtual const char* Signature() const = 0;
virtual const char* FriendlySignature() const = 0;
virtual void SetPath(BPath path);
virtual BPath Path();
virtual status_t UpdateSettings(BMessage* msg);
virtual uint32 GetEncoding();
virtual bool SaveLogs() const { return true; }
virtual CayaProtocolMessengerInterface*
MessengerInterface() const;
// Functions for gloox
gloox::Client* Client() const;
void HandleError(gloox::ConnectionError& e);
// Callbacks for protocols
virtual void OverrideSettings() = 0;
virtual BString ComposeJID() const = 0;
protected:
BString fUsername;
BString fPassword;
BString fServer;
BString fResource;
uint16 fPort;
BPath fPath;
BMessage _SettingsTemplate(const char* username, bool serverOption);
private:
CayaProtocolMessengerInterface*
fServerMessenger;
gloox::Client* fClient;
gloox::ConnectionTCPClient*
fConnection;
gloox::VCardManager* fVCardManager;
gloox::MessageSession* fSession;
gloox::JID fJid;
thread_id fRecvThread;
BPath fCachePath;
BPath fAvatarCachePath;
BMessage fAvatarCache;
BList* fAvatars;
void _SendMessage(BMessage* msg);
void _MessageSent(const char* id, const char* subject,
const char* body);
void _ChatCreated(const char* id);
void _Notify(notification_type type, const char* title, const char* message);
void _NotifyProgress(const char* title, const char* message, float progress);
status_t _SetupAvatarCache();
status_t _SaveAvatarCache();
void _CacheAvatar(const char* id, const char* binval, size_t length);
void _AvatarChanged(const char*id, const char* filename);
CayaStatus _GlooxStatusToCaya(gloox::Presence::PresenceType type);
virtual void onConnect();
virtual void onDisconnect(gloox::ConnectionError);
virtual bool onTLSConnect(const gloox::CertInfo&);
virtual void onResourceBindError(const gloox::Error*);
virtual void handleRoster(const gloox::Roster&);
virtual void handleMessageSession(gloox::MessageSession* session);
virtual void handleMessage(const gloox::Message& m, gloox::MessageSession*);
virtual void handleMessageEvent(const gloox::JID& from, gloox::MessageEventType event);
virtual void handleChatState(const gloox::JID& from, gloox::ChatStateType state);
virtual void handleItemAdded(const gloox::JID&);
virtual void handleItemSubscribed(const gloox::JID&);
virtual void handleItemUnsubscribed(const gloox::JID&);
virtual void handleItemRemoved(const gloox::JID&);
virtual void handleItemUpdated(const gloox::JID&);
virtual void handleRosterPresence(const gloox::RosterItem&,
const std::string&, gloox::Presence::PresenceType,
const std::string&);
virtual void handleSelfPresence(const gloox::RosterItem&, const std::string&,
gloox::Presence::PresenceType, const std::string&);
virtual bool handleSubscriptionRequest(const gloox::JID&, const std::string&);
virtual bool handleUnsubscriptionRequest(const gloox::JID&, const std::string&);
virtual void handleNonrosterPresence(const gloox::Presence&);
virtual void handleRosterError(const gloox::IQ&);
virtual void handleLog(gloox::LogLevel, gloox::LogArea, const std::string&);
virtual void handleVCard(const gloox::JID&, const gloox::VCard*);
virtual void handleVCardResult(gloox::VCardHandler::VCardContext,
const gloox::JID&,
gloox::StanzaError);
};
#endif // _JABBER_HANDLER_H