bool QXmppRosterManager::acceptSubscription(const QString &bareJid)
{
QXmppPresence presence;
presence.setTo(bareJid);
presence.setType(QXmppPresence::Subscribed);
return client()->sendPacket(presence);
}
bool QXmppRosterManager::unsubscribe(const QString &bareJid)
{
QXmppPresence packet;
packet.setTo(QXmppUtils::jidToBareJid(bareJid));
packet.setType(QXmppPresence::Unsubscribe);
return client()->sendPacket(packet);
}
Status JabberPresenceService::presenceToStatus(const QXmppPresence &presence)
{
auto status = Status{};
if (presence.type() == QXmppPresence::Available)
{
switch (presence.availableStatusType())
{
case QXmppPresence::AvailableStatusType::Online:
status.setType(StatusType::Online);
break;
case QXmppPresence::AvailableStatusType::Away:
status.setType(StatusType::Away);
break;
case QXmppPresence::AvailableStatusType::XA:
status.setType(StatusType::NotAvailable);
break;
case QXmppPresence::AvailableStatusType::DND:
status.setType(StatusType::DoNotDisturb);
break;
case QXmppPresence::AvailableStatusType::Chat:
status.setType(StatusType::FreeForChat);
break;
case QXmppPresence::AvailableStatusType::Invisible:
status.setType(StatusType::DoNotDisturb);
break;
}
}
else if (presence.type() == QXmppPresence::Unavailable)
status.setType(StatusType::Offline);
status.setDescription(presence.statusText());
return status;
}
void QFileTrans::slotPresenceReceived(const QXmppPresence &presence)
{
bool check;
Q_UNUSED(check);
// if we don't have a recipient, or if the presence is not from the recipient,
// do nothing
if (m_recipient.isEmpty() ||
QXmppUtils::jidToBareJid(presence.from()) != m_recipient ||
presence.type() != QXmppPresence::Available)
return;
// send the file and connect to the job's signals
QXmppTransferJob *job = transferManager->sendFile(presence.from(), ":/example_3_transferHandling.cpp", "example source code");
check = connect(job, SIGNAL(error(QXmppTransferJob::Error)),
this, SLOT(slotError(QXmppTransferJob::Error)));
Q_ASSERT(check);
check = connect(job, SIGNAL(finished()),
this, SLOT(slotFinished()));
Q_ASSERT(check);
check = connect(job, SIGNAL(progress(qint64,qint64)),
this, SLOT(slotProgress(qint64,qint64)));
Q_ASSERT(check);
}
void EntryBase::CheckVCardUpdate (const QXmppPresence& pres)
{
auto conn = Account_->GetClientConnection ();
if (!conn->GetInfoReqPolicyManager ()->IsRequestAllowed (InfoRequest::VCard, this))
return;
const auto& vcardUpdate = pres.vCardUpdateType ();
if (vcardUpdate == QXmppPresence::VCardUpdateNoPhoto)
{
if (!VCardPhotoHash_.isEmpty ())
{
VCardPhotoHash_.clear ();
WriteDownPhotoHash ();
emit avatarChanged (this);
}
}
else if (vcardUpdate == QXmppPresence::VCardUpdateValidPhoto)
{
if (pres.photoHash () != VCardPhotoHash_)
{
VCardPhotoHash_ = pres.photoHash ();
WriteDownPhotoHash ();
emit avatarChanged (this);
}
}
}
void EntryBase::CheckVCardUpdate (const QXmppPresence& pres)
{
auto conn = Account_->GetClientConnection ();
if (!conn->GetInfoReqPolicyManager ()->IsRequestAllowed (InfoRequest::VCard, this))
return;
auto fetchVCard = [this, conn] () -> void
{
QPointer<EntryBase> ptr (this);
conn->FetchVCard (GetJID (),
[ptr] (const QXmppVCardIq& iq) { if (ptr) ptr->SetVCard (iq); });
};
const auto& vcardUpdate = pres.vCardUpdateType ();
if (vcardUpdate == QXmppPresence::VCardUpdateNoPhoto)
{
if (!Avatar_.isNull ())
{
Avatar_ = QImage ();
emit avatarChanged (GetAvatar ());
}
}
else if (vcardUpdate == QXmppPresence::VCardUpdateValidPhoto)
{
if (pres.photoHash () != VCardPhotoHash_)
fetchVCard ();
}
else if (pres.type () == QXmppPresence::Available && !HasBlindlyRequestedVCard_)
{
fetchVCard ();
HasBlindlyRequestedVCard_ = true;
}
}
EntryStatus GlooxCLEntry::GetStatus (const QString& variant) const
{
if (ODS_)
return EntryStatus ();
if (AuthRequested_)
return EntryStatus (SOnline, QString ());
QXmppRosterManager& rm = Account_->
GetClientConnection ()->GetClient ()->rosterManager ();
if (!rm.isRosterReceived ())
return EntryBase::GetStatus (variant);
const QMap<QString, QXmppPresence>& press = rm.getAllPresencesForBareJid (GetJID ());
if (!press.size ())
return EntryBase::GetStatus (variant);
QXmppPresence max = press.begin ().value ();
Q_FOREACH (const QString& resource, press.keys ())
{
if (!variant.isEmpty () && variant == resource)
{
max = press [resource];
break;
}
const QXmppPresence& pres = press [resource];
if (pres.priority () > max.priority ())
max = pres;
}
return EntryStatus (static_cast<State> (max.availableStatusType () + 1),
max.statusText ());
}
void QXmppRosterManager::_q_presenceReceived(const QXmppPresence& presence)
{
const QString jid = presence.from();
const QString bareJid = QXmppUtils::jidToBareJid(jid);
const QString resource = QXmppUtils::jidToResource(jid);
if (bareJid.isEmpty())
return;
switch(presence.type())
{
case QXmppPresence::Available:
d->presences[bareJid][resource] = presence;
emit presenceChanged(bareJid, resource);
break;
case QXmppPresence::Unavailable:
d->presences[bareJid].remove(resource);
emit presenceChanged(bareJid, resource);
break;
case QXmppPresence::Subscribe:
if (client()->configuration().autoAcceptSubscriptions())
{
// accept subscription request
acceptSubscription(bareJid);
// ask for reciprocal subscription
subscribe(bareJid);
} else {
emit subscriptionReceived(bareJid);
}
break;
default:
break;
}
}
void xmppClient::slotPresenceReceived(const QXmppPresence &presence)
{
const QLatin1String recipient("*****@*****.**");
// if we are the recipient, or if the presence is not from the recipient,
// do nothing
if (jidToBareJid(configuration().jid()) == recipient ||
jidToBareJid(presence.from()) != recipient ||
presence.type() != QXmppPresence::Available)
return;
// send the file and connect to the job's signals
QXmppTransferJob *job = transferManager->sendFile(presence.from(), "xmppClient.cpp");
bool check = connect( job, SIGNAL(error(QXmppTransferJob::Error)),
this, SLOT(slotError(QXmppTransferJob::Error)) );
Q_ASSERT(check);
check = connect( job, SIGNAL(finished()),
this, SLOT(slotFinished()) );
Q_ASSERT(check);
check = connect( job, SIGNAL(progress(qint64,qint64)),
this, SLOT(slotProgress(qint64,qint64)) );
Q_ASSERT(check);
}
EntryStatus PresenceToStatus (const QXmppPresence& pres)
{
EntryStatus st (static_cast<State> (pres.availableStatusType () + 1), pres.statusText ());
if (pres.type () == QXmppPresence::Unavailable)
st.State_ = SOffline;
return st;
}
QString presenceToStatusText(const QXmppPresence& presence)
{
QString statusText = presence.statusText();
if(statusText.isEmpty())
{
if(presence.type() == QXmppPresence::Available)
{
switch(presence.availableStatusType())
{
case QXmppPresence::Invisible:
statusText = "Offline";
break;
case QXmppPresence::Online:
case QXmppPresence::Chat:
statusText = "Available";
break;
case QXmppPresence::Away:
case QXmppPresence::XA:
statusText = "Idle";
break;
case QXmppPresence::DND:
statusText = "Busy";
break;
}
}
else
statusText = "Offline";
}
return statusText;
}
void QXmppRosterManager::presenceReceived(const QXmppPresence& presence)
{
QString jid = presence.from();
QString bareJid = jidToBareJid(jid);
QString resource = jidToResource(jid);
if (bareJid.isEmpty())
return;
switch(presence.type())
{
case QXmppPresence::Available:
m_presences[bareJid][resource] = presence;
emit presenceChanged(bareJid, resource);
break;
case QXmppPresence::Unavailable:
m_presences[bareJid].remove(resource);
emit presenceChanged(bareJid, resource);
break;
case QXmppPresence::Subscribe:
if (m_stream->configuration().autoAcceptSubscriptions())
{
QXmppPresence presence;
presence.setTo(jid);
presence.setType(QXmppPresence::Subscribed);
m_stream->sendPacket(presence);
}
break;
default:
break;
}
}
void QXmppRosterManager::rosterIqReceived(const QXmppRosterIq& rosterIq)
{
bool isInitial = (m_rosterReqId == rosterIq.id());
switch(rosterIq.type())
{
case QXmppIq::Set:
{
// send result iq
QXmppIq returnIq(QXmppIq::Result);
returnIq.setId(rosterIq.id());
m_stream->sendPacket(returnIq);
// store updated entries and notify changes
const QList<QXmppRosterIq::Item> items = rosterIq.items();
for (int i = 0; i < items.count(); i++)
{
QString bareJid = items.at(i).bareJid();
m_entries[bareJid] = items.at(i);
emit rosterChanged(bareJid);
}
// when contact subscribes user...user sends 'subscribed' presence
// then after recieving following iq user requests contact for subscription
// check the "from" is newly added in the roster...and remove this ask thing...and do this for all items
QXmppRosterIq::Item item = items.at(0);
if (!item.bareJid().isEmpty() &&
item.subscriptionType() == QXmppRosterIq::Item::From &&
item.subscriptionStatus().isEmpty())
{
QXmppPresence presence;
presence.setTo(item.bareJid());
presence.setType(QXmppPresence::Subscribe);
m_stream->sendPacket(presence);
}
}
break;
case QXmppIq::Result:
{
QList<QXmppRosterIq::Item> items = rosterIq.items();
for(int i = 0; i < items.count(); ++i)
{
QString bareJid = items.at(i).bareJid();
m_entries[bareJid] = items.at(i);
if (!isInitial)
emit rosterChanged(bareJid);
}
if (isInitial)
{
m_isRosterReceived = true;
emit rosterReceived();
}
break;
}
default:
break;
}
}
bool QXmppRosterManager::subscribe(const QString &bareJid, const QString &reason)
{
QXmppPresence packet;
packet.setTo(QXmppUtils::jidToBareJid(bareJid));
packet.setType(QXmppPresence::Subscribe);
packet.setStatusText(reason);
return client()->sendPacket(packet);
}
bool QXmppRosterManager::refuseSubscription(const QString &bareJid, const QString &reason)
{
QXmppPresence presence;
presence.setTo(bareJid);
presence.setType(QXmppPresence::Unsubscribed);
presence.setStatusText(reason);
return client()->sendPacket(presence);
}
void QXmppClientPrivate::addProperCapability(QXmppPresence& presence)
{
QXmppDiscoveryManager* ext = q->findExtension<QXmppDiscoveryManager>();
if(ext) {
presence.setCapabilityHash("sha-1");
presence.setCapabilityNode(ext->clientCapabilitiesNode());
presence.setCapabilityVer(ext->capabilities().verificationString());
}
}
bool QXmppMucManager::leaveRoom(const QString &roomJid)
{
if (!m_nickNames.contains(roomJid))
return false;
QString nickName = m_nickNames.take(roomJid);
QXmppPresence packet;
packet.setTo(roomJid + "/" + nickName);
packet.setType(QXmppPresence::Unavailable);
return client()->sendPacket(packet);
}
void QXmppClient::setClientPresence(QXmppPresence::Status::Type statusType)
{
QXmppPresence newPresence = d->clientPresence;
if (statusType == QXmppPresence::Status::Offline)
newPresence.setType(QXmppPresence::Unavailable);
else
newPresence.setType(QXmppPresence::Available);
newPresence.status().setType(statusType);
setClientPresence(newPresence);
}
void GlooxCLEntry::SendGWPresence (QXmppPresence::Type type)
{
const auto& variant = sender ()->property ("Azoth/Xoox/Variant").toString ();
QString jid = GetJID ();
if (!variant.isEmpty ())
jid += '/' + variant;
QXmppPresence avail (type);
avail.setTo (jid);
Account_->GetClientConnection ()->GetClient ()->sendPacket (avail);
}
void MyXmppClient::setStatusText( const QString &__statusText )
{
if( __statusText != m_statusText ) {
m_statusText=__statusText;
QXmppPresence myPresence = xmppClient->clientPresence();
myPresence.setStatusText( __statusText );
xmppClient->setClientPresence( myPresence );
emit statusTextChanged();
}
}
QXmppPresence QXmppRosterManager::getPresence(const QString& bareJid,
const QString& resource) const
{
if(d->presences.contains(bareJid) && d->presences[bareJid].contains(resource))
return d->presences[bareJid][resource];
else
{
QXmppPresence presence;
presence.setType(QXmppPresence::Unavailable);
return presence;
}
}
void RoomHandler::HandleErrorPresence (const QXmppPresence& pres, const QString& nick)
{
const QString& errorText = pres.error ().text ();
QString hrText;
switch (pres.error ().condition ())
{
case QXmppStanza::Error::Conflict:
hrText = tr ("nickname already taken");
break;
case QXmppStanza::Error::Forbidden:
case QXmppStanza::Error::NotAllowed:
hrText = tr ("access forbidden");
break;
case QXmppStanza::Error::NotAuthorized:
hrText = tr ("password required");
break;
case QXmppStanza::Error::JidMalformed:
hrText = tr ("malformed JID");
break;
case QXmppStanza::Error::RegistrationRequired:
hrText = tr ("only registered users can enter this room");
break;
default:
hrText = tr ("unknown condition %1 (please report to developers)")
.arg (pres.error ().condition ());
break;
}
const QString& text = tr ("Error for %1: %2 (original message: %3)")
.arg (nick)
.arg (hrText)
.arg (errorText.isEmpty () ?
tr ("no message") :
errorText);
RoomPublicMessage *message = new RoomPublicMessage (text,
IMessage::DIn,
CLEntry_,
IMessage::MTEventMessage,
IMessage::MSTOther);
CLEntry_->HandleMessage (message);
switch (pres.error ().condition ())
{
case QXmppStanza::Error::Conflict:
HandleNickConflict ();
break;
case QXmppStanza::Error::NotAuthorized:
HandlePasswordRequired ();
break;
default:
break;
}
}
void xmppClient::slotPresenceReceived(const QXmppPresence &presence)
{
// if we don't have a recipient, or if the presence is not from the recipient,
// do nothing
if (m_recipient.isEmpty() ||
QXmppUtils::jidToBareJid(presence.from()) != m_recipient ||
presence.type() != QXmppPresence::Available)
return;
// start the call and connect to the its signals
m_recipientFullJid = presence.from();
startCall();
}
void TestPackets::testPresence()
{
const QByteArray xml(
"<presence to=\"[email protected]/QXmpp\" from=\"[email protected]/QXmpp\">"
"<x xmlns=\"vcard-temp:x:update\"/></presence>");
QXmppPresence presence;
parsePacket(presence, xml);
QCOMPARE(presence.to(), QString("[email protected]/QXmpp"));
QCOMPARE(presence.from(), QString("[email protected]/QXmpp"));
QCOMPARE(presence.photoHash(), QByteArray(""));
QCOMPARE(presence.vCardUpdateType(), QXmppPresence::VCardUpdateNotReady);
serializePacket(presence, xml);
}
QXmppPresence StatusToPresence (State state, const QString& text, int prio)
{
QXmppPresence::Type presType = state == SOffline ?
QXmppPresence::Unavailable :
QXmppPresence::Available;
QXmppPresence pres (presType);
if (state != SOffline)
pres.setAvailableStatusType (static_cast<QXmppPresence::AvailableStatusType> (state - 1));
pres.setStatusText (text);
pres.setPriority (prio);
return pres;
}
void ChatClient::setStatusType(const QString &statusType)
{
if (statusType != this->statusType()) {
QXmppPresence presence = clientPresence();
if (statusType == "offline") {
presence.setType(QXmppPresence::Unavailable);
} else {
presence.setType(QXmppPresence::Available);
presence.setAvailableStatusType(stringToStatus(statusType));
}
setClientPresence(presence);
emit statusTypeChanged(statusType);
}
}
void rpcClient::slotPresenceReceived(const QXmppPresence &presence)
{
const QLatin1String recipient("*****@*****.**");
// if we are the recipient, or if the presence is not from the recipient,
// do nothing
if (QXmppUtils::jidToBareJid(configuration().jid()) == recipient ||
QXmppUtils::jidToBareJid(presence.from()) != recipient ||
presence.type() != QXmppPresence::Available)
return;
// invoke the remote method in 1 second
m_remoteJid = presence.from();
QTimer::singleShot(1000, this, SLOT(slotInvokeRemoteMethod()));
}
QString MyXmppClient::getPicPresence( const QXmppPresence &presence ) const
{
QString picPresenceName;
QXmppPresence::Type status = presence.type();
if( status != QXmppPresence::Available ) picPresenceName = "qrc:/presence/offline";
else
{
QXmppPresence::AvailableStatusType availableStatus = presence.availableStatusType();
if( availableStatus == QXmppPresence::Online ) picPresenceName = "qrc:/presence/online";
else if ( availableStatus == QXmppPresence::Chat ) picPresenceName = "qrc:/presence/chatty";
else if ( availableStatus == QXmppPresence::Away ) picPresenceName = "qrc:/presence/away";
else if ( availableStatus == QXmppPresence::XA ) picPresenceName = "qrc:/presence/xa";
else if ( availableStatus == QXmppPresence::DND ) picPresenceName = "qrc:/presence/busy";
}
return picPresenceName;
}
void JabberContactAvatarService::presenceReceived(const QXmppPresence &presence)
{
auto jid = Jid::parse(presence.from());
auto contactId = ContactId{jid.bare().toUtf8()};
switch (presence.vCardUpdateType())
{
case QXmppPresence::VCardUpdateNoPhoto:
emit removed(contactId);
break;
case QXmppPresence::VCardUpdateValidPhoto:
emit available({contactId, presence.photoHash()});
break;
default:
break;
}
}
void MyXmppClient::initPresence(const QString& bareJid, const QString& resource)
{
int indxItem = -1;
RosterItemModel *item = (RosterItemModel*)cachedRoster->find( bareJid, indxItem );
if( item == 0 ) {
return;
}
QXmppPresence xmppPresence = rosterManager->getPresence( bareJid, resource );
QXmppPresence::Type statusJid = xmppPresence.type();
QStringList _listResources = this->getResourcesByJid( bareJid );
if( (_listResources.count() > 0) && (!_listResources.contains(resource)) )
{
qDebug() << bareJid << "/" << resource << " ****************[" <<_listResources<<"]" ;
if( statusJid == QXmppPresence::Unavailable ) {
return;
}
}
item->setResource( resource );
QString picStatus = this->getPicPresence( xmppPresence );
item->setPresence( picStatus );
QString txtStatus = this->getTextStatus( xmppPresence.statusText(), xmppPresence );
item->setStatusText( txtStatus );
RosterItemModel *itemExists = (RosterItemModel*)cachedRoster->find( bareJid, indxItem );
if( itemExists != 0 ) {
itemExists->copy( item );
QString picStatusPrev = itemExists->presence();
if( picStatusPrev != picStatus )
{
//emit presenceJidChanged( bareJid, txtStatus, picStatus );
emit rosterChanged();
}
}
item = 0; itemExists = 0;
delete item; delete itemExists;
emit contactStatusChanged(m_accountId,bareJid);
}
