squawk/core/account.cpp

418 lines
14 KiB
C++
Raw Normal View History

2019-03-29 14:54:34 +00:00
#include "account.h"
2019-04-03 21:23:51 +00:00
#include <qxmpp/QXmppRosterManager.h>
2019-04-09 15:04:08 +00:00
#include <qxmpp/QXmppMessage.h>
2019-04-07 14:02:41 +00:00
#include <QDateTime>
2019-03-29 14:54:34 +00:00
using namespace Core;
2019-03-30 20:13:13 +00:00
Account::Account(const QString& p_login, const QString& p_server, const QString& p_password, const QString& p_name, QObject* parent):
2019-03-29 14:54:34 +00:00
QObject(parent),
2019-03-30 20:13:13 +00:00
name(p_name),
client(),
config(),
presence(),
2019-04-03 21:23:51 +00:00
state(Shared::disconnected),
groups()
2019-03-29 14:54:34 +00:00
{
config.setUser(p_login);
config.setDomain(p_server);
config.setPassword(p_password);
QObject::connect(&client, SIGNAL(connected()), this, SLOT(onClientConnected()));
QObject::connect(&client, SIGNAL(disconnected()), this, SLOT(onClientDisconnected()));
2019-04-07 14:02:41 +00:00
QObject::connect(&client, SIGNAL(presenceReceived(const QXmppPresence&)), this, SLOT(onPresenceReceived(const QXmppPresence&)));
2019-04-09 15:04:08 +00:00
QObject::connect(&client, SIGNAL(messageReceived(const QXmppMessage&)), this, SLOT(onMessageReceived(const QXmppMessage&)));
2019-04-03 21:23:51 +00:00
QXmppRosterManager& rm = client.rosterManager();
2019-04-06 10:14:32 +00:00
2019-04-03 21:23:51 +00:00
QObject::connect(&rm, SIGNAL(rosterReceived()), this, SLOT(onRosterReceived()));
2019-04-06 10:14:32 +00:00
QObject::connect(&rm, SIGNAL(itemAdded(const QString&)), this, SLOT(onRosterItemAdded(const QString&)));
QObject::connect(&rm, SIGNAL(itemRemoved(const QString&)), this, SLOT(onRosterItemRemoved(const QString&)));
QObject::connect(&rm, SIGNAL(itemChanged(const QString&)), this, SLOT(onRosterItemChanged(const QString&)));
2019-04-07 14:02:41 +00:00
//QObject::connect(&rm, SIGNAL(presenceChanged(const QString&, const QString&)), this, SLOT(onRosterPresenceChanged(const QString&, const QString&)));
2019-03-29 14:54:34 +00:00
}
Account::~Account()
{
}
2019-03-29 14:54:34 +00:00
Shared::ConnectionState Core::Account::getState() const
{
return state;
2019-03-29 14:54:34 +00:00
}
void Core::Account::connect()
{
if (state == Shared::disconnected) {
client.connectToServer(config, presence);
state = Shared::connecting;
emit connectionStateChanged(state);
} else {
qDebug("An attempt to connect an account which is already connected, skipping");
}
}
void Core::Account::disconnect()
{
if (state != Shared::disconnected) {
client.disconnectFromServer();
state = Shared::disconnected;
emit connectionStateChanged(state);
}
}
void Core::Account::onClientConnected()
{
if (state == Shared::connecting) {
state = Shared::connected;
emit connectionStateChanged(state);
} else {
qDebug("Something weird had happened - xmpp client reported about successful connection but account wasn't in connecting state");
}
}
2019-04-02 15:46:18 +00:00
void Core::Account::onClientDisconnected()
{
if (state != Shared::disconnected) {
state = Shared::disconnected;
emit connectionStateChanged(state);
} else {
2019-04-03 18:15:36 +00:00
//qDebug("Something weird had happened - xmpp client reported about being disconnection but account was already in disconnected state");
}
}
QString Core::Account::getName() const
{
return name;
}
QString Core::Account::getLogin() const
{
return config.user();
}
QString Core::Account::getPassword() const
{
return config.password();
}
QString Core::Account::getServer() const
{
return config.domain();
}
2019-04-03 21:23:51 +00:00
void Core::Account::onRosterReceived()
{
QXmppRosterManager& rm = client.rosterManager();
QStringList bj = rm.getRosterBareJids();
for (int i = 0; i < bj.size(); ++i) {
const QString& jid = bj[i];
2019-04-06 10:14:32 +00:00
addedAccount(jid);
}
}
void Core::Account::onRosterItemAdded(const QString& bareJid)
{
addedAccount(bareJid);
}
void Core::Account::onRosterItemChanged(const QString& bareJid)
{
QXmppRosterManager& rm = client.rosterManager();
QXmppRosterIq::Item re = rm.getRosterEntry(bareJid);
QSet<QString> newGroups = re.groups();
QSet<QString> oldGroups;
2019-04-07 14:02:41 +00:00
QStringList res = rm.getResources(bareJid);
unsigned int state = re.subscriptionType();
if (state == QXmppRosterIq::Item::NotSet) {
state = Shared::unknown;
}
QMap<QString, QVariant> cData({
{"name", re.name()},
{"state", state}
});
2019-04-07 14:02:41 +00:00
emit changeContact(bareJid, cData);
2019-04-06 10:14:32 +00:00
for (std::map<QString, std::set<QString>>::iterator itr = groups.begin(), end = groups.end(); itr != end; ++itr) {
std::set<QString>& contacts = itr->second;
std::set<QString>::const_iterator cItr = contacts.find(bareJid);
if (cItr != contacts.end()) {
oldGroups.insert(itr->first);
}
}
QSet<QString> toRemove = oldGroups - newGroups;
QSet<QString> toAdd = newGroups - oldGroups;
QSet<QString> removeGroups;
for (QSet<QString>::iterator itr = toRemove.begin(), end = toRemove.end(); itr != end; ++itr) {
const QString& groupName = *itr;
std::set<QString>& contacts = groups.find(groupName)->second;
contacts.erase(bareJid);
emit removeContact(bareJid, groupName);
if (contacts.size() == 0) {
removeGroups.insert(groupName);
}
}
for (QSet<QString>::iterator itr = toAdd.begin(), end = toAdd.end(); itr != end; ++itr) {
const QString& groupName = *itr;
std::map<QString, std::set<QString>>::iterator cItr = groups.find(groupName);
if (cItr == groups.end()) {
cItr = groups.insert(std::make_pair(groupName, std::set<QString>())).first;
emit addGroup(groupName);
}
cItr->second.insert(bareJid);
emit addContact(bareJid, groupName, cData);
2019-04-06 10:14:32 +00:00
}
for (QSet<QString>::iterator itr = removeGroups.begin(), end = removeGroups.end(); itr != end; ++itr) {
const QString& groupName = *itr;
emit removeGroup(groupName);
groups.erase(groupName);
}
}
void Core::Account::onRosterItemRemoved(const QString& bareJid)
{
emit removeContact(bareJid);
QSet<QString> toRemove;
for (std::map<QString, std::set<QString>>::iterator itr = groups.begin(), end = groups.end(); itr != end; ++itr) {
std::set<QString> contacts = itr->second;
std::set<QString>::const_iterator cItr = contacts.find(bareJid);
if (cItr != contacts.end()) {
contacts.erase(cItr);
if (contacts.size() == 0) {
toRemove.insert(itr->first);
2019-04-03 21:23:51 +00:00
}
}
2019-04-06 10:14:32 +00:00
}
for (QSet<QString>::iterator itr = toRemove.begin(), end = toRemove.end(); itr != end; ++itr) {
const QString& groupName = *itr;
emit removeGroup(groupName);
groups.erase(groupName);
}
}
void Core::Account::addedAccount(const QString& jid)
{
QXmppRosterManager& rm = client.rosterManager();
QXmppRosterIq::Item re = rm.getRosterEntry(jid);
QSet<QString> gr = re.groups();
unsigned int state = re.subscriptionType();
if (state == QXmppRosterIq::Item::NotSet) {
state = Shared::unknown;
}
QMap<QString, QVariant> cData({
{"name", re.name()},
{"state", state}
});
2019-04-06 10:14:32 +00:00
int grCount = 0;
for (QSet<QString>::const_iterator itr = gr.begin(), end = gr.end(); itr != end; ++itr) {
const QString& groupName = *itr;
std::map<QString, std::set<QString>>::iterator gItr = groups.find(groupName);
if (gItr == groups.end()) {
gItr = groups.insert(std::make_pair(groupName, std::set<QString>())).first;
emit addGroup(groupName);
2019-04-03 21:23:51 +00:00
}
2019-04-06 10:14:32 +00:00
gItr->second.insert(jid);
emit addContact(jid, groupName, cData);
2019-04-06 10:14:32 +00:00
grCount++;
}
if (grCount == 0) {
emit addContact(jid, "", cData);
2019-04-03 21:23:51 +00:00
}
}
2019-04-07 14:02:41 +00:00
void Core::Account::onPresenceReceived(const QXmppPresence& presence)
{
QString id = presence.from();
QStringList comps = id.split("/");
QString jid = comps.front();
QString resource = comps.back();
QString myJid = getLogin() + "@" + getServer();
if (jid == myJid) {
if (resource == getResource()) {
emit availabilityChanged(presence.availableStatusType());
} else {
qDebug() << "Received a presence for another resource of my " << name << " account, skipping";
}
}
2019-04-07 14:02:41 +00:00
switch (presence.type()) {
case QXmppPresence::Error:
qDebug() << "An error reported by presence from " << id;
break;
case QXmppPresence::Available:{
QDateTime lastInteraction = presence.lastUserInteraction();
if (!lastInteraction.isValid()) {
lastInteraction = QDateTime::currentDateTime();
}
emit addPresence(jid, resource, {
{"lastActivity", lastInteraction},
{"availability", presence.availableStatusType()}, //TODO check and handle invisible
{"status", presence.statusText()}
});
}
break;
case QXmppPresence::Unavailable:
emit removePresence(jid, resource);
break;
case QXmppPresence::Subscribe:
qDebug("xmpp presence \"subscribe\" received, do not yet know what to do, skipping");
case QXmppPresence::Subscribed:
qDebug("xmpp presence \"subscribed\" received, do not yet know what to do, skipping");
case QXmppPresence::Unsubscribe:
qDebug("xmpp presence \"unsubscribe\" received, do not yet know what to do, skipping");
case QXmppPresence::Unsubscribed:
qDebug("xmpp presence \"unsubscribed\" received, do not yet know what to do, skipping");
case QXmppPresence::Probe:
qDebug("xmpp presence \"probe\" received, do not yet know what to do, skipping");
break;
}
}
void Core::Account::onRosterPresenceChanged(const QString& bareJid, const QString& resource)
{
//not used for now;
qDebug() << "presence changed for " << bareJid << " resource " << resource;
const QXmppPresence& presence = client.rosterManager().getPresence(bareJid, resource);
}
void Core::Account::setLogin(const QString& p_login)
{
config.setUser(p_login);
}
void Core::Account::setName(const QString& p_name)
{
name = p_name;
}
void Core::Account::setPassword(const QString& p_password)
{
config.setPassword(p_password);
}
void Core::Account::setServer(const QString& p_server)
{
config.setDomain(p_server);
}
Shared::Availability Core::Account::getAvailability() const
{
QXmppPresence::AvailableStatusType pres = presence.availableStatusType();
return static_cast<Shared::Availability>(pres); //TODO that's a shame! gotta do something about it
}
void Core::Account::setAvailability(Shared::Availability avail)
{
QXmppPresence::AvailableStatusType pres = static_cast<QXmppPresence::AvailableStatusType>(avail);
presence.setAvailableStatusType(pres);
if (state != Shared::disconnected) { //TODO not sure how to do here - changing state may cause connection or disconnection
client.setClientPresence(presence);
}
}
QString Core::Account::getResource() const
{
return config.resource();
}
void Core::Account::setResource(const QString& p_resource)
{
config.setResource(p_resource);
}
2019-04-09 15:04:08 +00:00
2019-04-09 22:01:25 +00:00
void Core::Account::onMessageReceived(const QXmppMessage& msg)
2019-04-09 15:04:08 +00:00
{
2019-04-09 22:01:25 +00:00
QString from = msg.from();
QStringList fcomps = from.split("/");
QString fjid = fcomps.front();
QString fresource = fcomps.back();
QString to = msg.to();
QStringList tcomps = to.split("/");
QString tjid = tcomps.front();
QString tresource = tcomps.back();
bool handled = false;
switch (msg.type()) {
case QXmppMessage::Normal:
qDebug() << "received a message with type \"Normal\", not sure what to do with it now, skipping";
break;
case QXmppMessage::Chat:{
QString body(msg.body());
if (body.size() != 0) {
QString id(msg.id());
emit message({
{"body", body},
{"from", fjid},
{"to", tjid},
{"fromResource", fresource},
{"toResource", tresource},
{"id", id}
});
if (msg.isReceiptRequested() && id.size() > 0) {
QXmppMessage receipt(getFullJid(), from, "");
receipt.setReceiptId(id);
client.sendPacket(receipt);
handled = true;
}
}
}
break;
case QXmppMessage::GroupChat:
qDebug() << "received a message with type \"GroupChat\", not sure what to do with it now, skipping";
break;
case QXmppMessage::Error:
qDebug() << "received a message with type \"Error\", not sure what to do with it now, skipping";
break;
case QXmppMessage::Headline:
qDebug() << "received a message with type \"Headline\", not sure what to do with it now, skipping";
break;
}
if (!handled) {
qDebug() << "Message wasn't handled: ";
qDebug() << "- from: " << msg.from();
qDebug() << "- to: " << msg.to();
qDebug() << "- body: " << msg.body();
qDebug() << "- type: " << msg.type();
qDebug() << "- state: " << msg.state();
qDebug() << "- stamp: " << msg.stamp();
qDebug() << "- id: " << msg.id();
qDebug() << "- isAttentionRequested: " << msg.isAttentionRequested();
qDebug() << "- isReceiptRequested: " << msg.isReceiptRequested();
qDebug() << "- receiptId: " << msg.receiptId();
qDebug() << "- subject: " << msg.subject();
qDebug() << "- thread: " << msg.thread();
qDebug() << "- isMarkable: " << msg.isMarkable();
qDebug() << "==============================";
}
2019-04-09 15:04:08 +00:00
}
2019-04-09 22:01:25 +00:00
QString Core::Account::getFullJid() const
{
return getLogin() + "@" + getServer() + "/" + getResource();
}
2019-04-10 20:53:42 +00:00
void Core::Account::sendMessage(const QMap<QString, QString>& data)
{
if (state == Shared::connected) {
client.sendMessage(data.value("to"), data.value("body"));
} else {
qDebug() << "An attempt to send message with not connected account " << name << ", skipping";
}
}