void MetaEntry::handleRealVariantsChanged (QStringList variants, QObject *passedObj)
{
QObject *obj = passedObj ? passedObj : sender ();
Q_FOREACH (const QString& var, Variant2RealVariant_.keys ())
{
const QPair<QObject*, QString>& pair = Variant2RealVariant_ [var];
if (pair.first == obj)
Variant2RealVariant_.remove (var);
}
ICLEntry *entry = qobject_cast<ICLEntry*> (obj);
if (!variants.contains (QString ()))
variants.prepend (QString ());
Q_FOREACH (const QString& var, variants)
Variant2RealVariant_ [entry->GetEntryName () + '/' + var] =
qMakePair (obj, var);
emit availableVariantsChanged (Variants ());
Q_FOREACH (const QString& var, variants)
{
const QString& str = entry->GetEntryName () + '/' + var;
emit statusChanged (GetStatus (str), str);
}
}
void MetaEntry::PerformRemoval (QObject *entryObj)
{
for (auto i = Messages_.begin (); i != Messages_.end (); )
{
const auto metaMsg = dynamic_cast<MetaMessage*> (*i);
const auto origMsg = metaMsg->GetOriginalMessage ();
if (origMsg->OtherPart () == entryObj)
i = Messages_.erase (i);
else
++i;
}
for (auto i = Variant2RealVariant_.begin (); i != Variant2RealVariant_.end (); )
{
const auto& var = i.key ();
const auto& pair = i.value ();
if (pair.first == entryObj)
{
emit statusChanged ({ SOffline, QString () }, var);
i = Variant2RealVariant_.erase (i);
}
else
++i;
}
emit availableVariantsChanged (Variants ());
}
void MetaEntry::SetNewEntryList (const QList<QObject*>& newList, bool readdRemoved)
{
if (newList == AvailableRealEntries_)
return;
QList<QObject*> removedContacts;
Q_FOREACH (QObject *obj, AvailableRealEntries_)
if (!newList.contains (obj))
removedContacts << obj;
AvailableRealEntries_ = newList;
Q_FOREACH (QObject *entryObj, removedContacts)
PerformRemoval (entryObj);
Core::Instance ().HandleEntriesRemoved (removedContacts, readdRemoved);
if (AvailableRealEntries_.isEmpty () &&
UnavailableRealEntries_.isEmpty ())
{
emit shouldRemoveThis ();
return;
}
emit availableVariantsChanged (Variants ());
emit statusChanged (GetStatus (QString ()), QString ());
}
QStringList MetaEntry::Variants () const
{
QStringList result;
for (const auto entryObj : AvailableRealEntries_)
{
const auto entry = qobject_cast<ICLEntry*> (entryObj);
const auto& name = entry->GetEntryName ();
auto variants = entry->Variants ();
if (!variants.contains (QString ()))
variants.prepend (QString ());
for (const auto& var : variants)
{
const auto& full = name + '/' + var;
if (!Variant2RealVariant_.contains (full))
{
qWarning () << Q_FUNC_INFO
<< "skipping out-of-sync with variant map:"
<< name
<< var
<< Variant2RealVariant_;
continue;
}
result << full;
}
}
return result;
}
/** empty internal buffer */
void VariantAlleleNormalizer::flush()
{
_impl->buffered_variants = std::priority_queue<Variants, std::vector<Variants>, VariantCompare >();
_impl->vs = Variants();
_impl->maxpos_chr = "";
_impl->current_maxpos.resize(0);
}
void EntryBase::UpdateEntityTime ()
{
const auto& now = QDateTime::currentDateTime ();
if (LastEntityTimeRequest_.isValid () &&
LastEntityTimeRequest_.secsTo (now) < 60)
return;
connect (Account_->GetClientConnection ()->GetEntityTimeManager (),
SIGNAL (timeReceived (QXmppEntityTimeIq)),
this,
SLOT (handleTimeReceived (QXmppEntityTimeIq)),
Qt::UniqueConnection);
LastEntityTimeRequest_ = now;
auto jid = GetJID ();
auto timeMgr = Account_->GetClientConnection ()->GetEntityTimeManager ();
if (jid.contains ('/'))
{
timeMgr->requestTime (jid);
return;
}
for (const auto& variant : Variants ())
if (!variant.isEmpty ())
timeMgr->requestTime (jid + '/' + variant);
}
void ToxContact::SetStatus (const EntryStatus& status)
{
if (status == Status_)
return;
Status_ = status;
emit statusChanged (Status_, Variants ().front ());
}
DcOptions::Variants DcOptions::lookup(DcId dcId, DcType type) const {
auto isMediaDownload = (type == DcType::MediaDownload);
int shifts[2][2][4] = {
{ // IPv4
{ // TCP IPv4
isMediaDownload ? (MTPDdcOption::Flag::f_media_only | MTPDdcOption::Flag::f_tcpo_only) : -1,
qFlags(MTPDdcOption::Flag::f_tcpo_only),
isMediaDownload ? qFlags(MTPDdcOption::Flag::f_media_only) : -1,
0
}, { // HTTP IPv4
-1,
-1,
isMediaDownload ? qFlags(MTPDdcOption::Flag::f_media_only) : -1,
0
},
}, { // IPv6
{ // TCP IPv6
isMediaDownload ? (MTPDdcOption::Flag::f_media_only | MTPDdcOption::Flag::f_tcpo_only | MTPDdcOption::Flag::f_ipv6) : -1,
MTPDdcOption::Flag::f_tcpo_only | MTPDdcOption::Flag::f_ipv6,
isMediaDownload ? (MTPDdcOption::Flag::f_media_only | MTPDdcOption::Flag::f_ipv6) : -1,
qFlags(MTPDdcOption::Flag::f_ipv6)
}, { // HTTP IPv6
-1,
-1,
isMediaDownload ? (MTPDdcOption::Flag::f_media_only | MTPDdcOption::Flag::f_ipv6) : -1,
qFlags(MTPDdcOption::Flag::f_ipv6)
},
},
};
auto result = Variants();
{
QReadLocker lock(&_mutex);
for (auto address = 0; address != Variants::AddressTypeCount; ++address) {
for (auto protocol = 0; protocol != Variants::ProtocolCount; ++protocol) {
for (auto variant = 0; variant != base::array_size(shifts[address][protocol]); ++variant) {
auto shift = shifts[address][protocol][variant];
if (shift < 0) continue;
auto it = _data.find(shiftDcId(dcId, shift));
if (it != _data.cend()) {
result.data[address][protocol].ip = it->second.ip;
result.data[address][protocol].flags = it->second.flags;
result.data[address][protocol].port = it->second.port;
break;
}
}
}
}
}
return result;
}
void MRIMBuddy::UpdateInfo (const Proto::ContactInfo& info)
{
CmpXchg (Info_, info,
GetMem<QString> (&Proto::ContactInfo::Alias_),
[this] (QString name) { emit nameChanged (name); });
CmpXchg (Info_, info,
GetMem<QString> (&Proto::ContactInfo::UA_),
[this] (QString)
{
UpdateClientVersion ();
emit entryGenerallyChanged ();
});
bool stChanged = false;
const int oldVars = Variants ().size ();
CmpXchg (Info_, info,
GetMem<quint32> (&Proto::ContactInfo::StatusID_),
[&stChanged] (quint32) { stChanged = true; });
CmpXchg (Info_, info,
GetMem<QString> (&Proto::ContactInfo::StatusTitle_),
[&stChanged] (QString) { stChanged = true; });
CmpXchg (Info_, info,
GetMem<QString> (&Proto::ContactInfo::StatusDesc_),
[&stChanged] (QString) { stChanged = true; });
if (stChanged)
{
Status_.State_ = VaderUtil::StatusID2State (Info_.StatusID_);
Status_.StatusString_ = Info_.StatusTitle_;
if (oldVars != Variants ().size ())
emit availableVariantsChanged (Variants ());
emit statusChanged (GetStatus (QString ()), QString ());
}
Info_.GroupNumber_ = info.GroupNumber_;
}
void NotificationsManager::AddCLEntry (QObject *entryObj)
{
connect (entryObj,
SIGNAL (statusChanged (EntryStatus, QString)),
this,
SLOT (handleStatusChanged (EntryStatus, QString)));
if (qobject_cast<IAdvancedCLEntry*> (entryObj))
{
connect (entryObj,
SIGNAL (attentionDrawn (const QString&, const QString&)),
this,
SLOT (handleAttentionDrawn (const QString&, const QString&)));
connect (entryObj,
SIGNAL (locationChanged (QString)),
this,
SLOT (handleLocationChanged (QString)));
}
if (qobject_cast<IHaveContactTune*> (entryObj))
connect (entryObj,
SIGNAL (tuneChanged (QString)),
this,
SLOT (handleTuneChanged (QString)));
if (qobject_cast<IHaveContactMood*> (entryObj))
connect (entryObj,
SIGNAL (moodChanged (QString)),
this,
SLOT (handleMoodChanged (QString)));
if (qobject_cast<IHaveContactActivity*> (entryObj))
connect (entryObj,
SIGNAL (activityChanged (QString)),
this,
SLOT (handleActivityChanged (QString)));
const auto entry = qobject_cast<ICLEntry*> (entryObj);
const auto status = entry->GetStatus ();
if (status.State_ != SOffline)
HandleStatusChanged (entry, status, entry->Variants ().value (0));
}
void EntryBase::HandlePEPEvent (QString variant, PEPEventBase *event)
{
const auto& vars = Variants ();
if (!vars.isEmpty () &&
(!vars.contains (variant) || variant.isEmpty ()))
variant = vars.first ();
if (const auto activity = dynamic_cast<UserActivity*> (event))
return HandleUserActivity (activity, variant);
if (const auto mood = dynamic_cast<UserMood*> (event))
return HandleUserMood (mood, variant);
if (const auto tune = dynamic_cast<UserTune*> (event))
return HandleUserTune (tune, variant);
if (const auto location = dynamic_cast<UserLocation*> (event))
{
if (Location_ [variant] == location->GetInfo ())
return;
Location_ [variant] = location->GetInfo ();
emit locationChanged (variant, this);
emit locationChanged (variant);
return;
}
if (PEPMicroblog *microblog = dynamic_cast<PEPMicroblog*> (event))
{
emit gotNewPost (*microblog);
return;
}
if (dynamic_cast<UserAvatarData*> (event) || dynamic_cast<UserAvatarMetadata*> (event))
return;
qWarning () << Q_FUNC_INFO
<< "unhandled PEP event from"
<< GetJID ();
}
void SelfContact::UpdateJID (const QString& fullJid)
{
ClientConnection::Split (fullJid, &BareJID_, &Resource_);
emit availableVariantsChanged (Variants ());
}
void SelfContact::UpdatePriority (const QString& resource, int prio)
{
Status2Prio_.remove (resource);
Status2Prio_ [resource] = prio;
emit availableVariantsChanged (Variants ());
}
void EntryBase::SetStatus (const EntryStatus& status, const QString& variant, const QXmppPresence& presence)
{
const bool existed = CurrentStatus_.contains (variant);
const bool wasOffline = existed ?
CurrentStatus_ [variant].State_ == SOffline :
false;
if (existed &&
status == CurrentStatus_ [variant] &&
presence.priority () == Variant2ClientInfo_.value (variant).value ("priority"))
return;
CurrentStatus_ [variant] = status;
const QStringList& vars = Variants ();
if ((!existed || wasOffline) && !vars.isEmpty ())
{
const QString& highest = vars.first ();
if (Location_.contains ({}))
Location_ [highest] = Location_.take ({});
if (Variant2Audio_.contains ({}))
Variant2Audio_ [highest] = Variant2Audio_.take ({});
if (Variant2Mood_.contains ({}))
Variant2Mood_ [highest] = Variant2Mood_.take ({});
if (Variant2Activity_.contains ({}))
Variant2Activity_ [highest] = Variant2Activity_.take ({});
}
if ((!existed || wasOffline) &&
status.State_ != SOffline)
{
auto conn = Account_->GetClientConnection ();
if (conn->GetInfoReqPolicyManager ()->IsRequestAllowed (InfoRequest::Version, this))
{
if (!variant.isEmpty ())
conn->FetchVersion (GetJID () + '/' + variant);
else
conn->FetchVersion (GetJID ());
}
}
if (status.State_ != SOffline)
{
if (const int p = presence.priority ())
Variant2ClientInfo_ [variant] ["priority"] = p;
}
else
{
Variant2Version_.remove (variant);
Variant2ClientInfo_.remove (variant);
Variant2VerString_.remove (variant);
Variant2Identities_.remove (variant);
Variant2Audio_.remove (variant);
Variant2Mood_.remove (variant);
Variant2Activity_.remove (variant);
Variant2SecsDiff_.remove (variant);
}
emit statusChanged (status, variant);
if (!existed ||
status.State_ == SOffline ||
wasOffline)
emit availableVariantsChanged (vars);
GlooxMessage *message = 0;
if (GetEntryType () == EntryType::PrivateChat)
message = new GlooxMessage (IMessage::Type::StatusMessage,
IMessage::Direction::In,
qobject_cast<RoomCLEntry*> (GetParentCLEntryObject ())->
GetRoomHandler ()->GetRoomJID (),
GetEntryName (),
Account_->GetClientConnection ().get ());
else
message = new GlooxMessage (IMessage::Type::StatusMessage,
IMessage::Direction::In,
GetJID (),
variant,
Account_->GetClientConnection ().get ());
message->SetMessageSubType (IMessage::SubType::ParticipantStatusChange);
const auto proxy = Account_->GetParentProtocol ()->GetProxyObject ();
const auto& state = proxy->StateToString (status.State_);
const auto& nick = GetEntryName () + '/' + variant;
message->setProperty ("Azoth/Nick", nick);
message->setProperty ("Azoth/TargetState", state);
message->setProperty ("Azoth/StatusText", status.StatusString_);
const auto& msg = tr ("%1 is now %2 (%3)")
.arg (nick)
.arg (state)
.arg (status.StatusString_);
message->SetBody (msg);
HandleMessage (message);
}
void SelfContact::RemoveVariant (const QString& resource)
{
Prio2Status_.remove (Prio2Status_.key (resource));
CurrentStatus_.remove (resource);
emit availableVariantsChanged (Variants ());
}
void SelfContact::UpdatePriority (const QString& resource, int prio)
{
Prio2Status_ [prio] = resource;
emit availableVariantsChanged (Variants ());
}
void EntryBase::SetStatus (const EntryStatus& status, const QString& variant, const QXmppPresence& presence)
{
const bool existed = CurrentStatus_.contains (variant);
const bool wasOffline = existed ?
CurrentStatus_ [variant].State_ == SOffline :
false;
if (existed &&
status == CurrentStatus_ [variant] &&
presence.priority () == Variant2ClientInfo_.value (variant).value ("priority"))
return;
CurrentStatus_ [variant] = status;
const QStringList& vars = Variants ();
if ((!existed || wasOffline) && !vars.isEmpty ())
{
const QString& highest = vars.first ();
if (Location_.contains (QString ()))
Location_ [highest] = Location_.take (QString ());
if (Variant2ClientInfo_.contains (QString ()))
{
const auto& info = Variant2ClientInfo_ [QString ()];
QStringList toCopy;
toCopy << "user_tune" << "user_mood" << "user_activity";
Q_FOREACH (const QString& key, toCopy)
if (info.contains (key))
Variant2ClientInfo_ [highest] [key] = info [key];
}
}
if ((!existed || wasOffline) &&
status.State_ != SOffline)
{
auto conn = Account_->GetClientConnection ();
if (conn->GetInfoReqPolicyManager ()->IsRequestAllowed (InfoRequest::Version, this) &&
!variant.isEmpty ())
conn->FetchVersion (GetJID () + '/' + variant);
}
if (status.State_ != SOffline)
{
if (const int p = presence.priority ())
Variant2ClientInfo_ [variant] ["priority"] = p;
}
else
{
Variant2Version_.remove (variant);
Variant2ClientInfo_.remove (variant);
}
emit statusChanged (status, variant);
if (!existed ||
(existed && status.State_ == SOffline) ||
wasOffline)
emit availableVariantsChanged (vars);
GlooxMessage *message = 0;
if (GetEntryType () == ETPrivateChat)
message = new GlooxMessage (IMessage::MTStatusMessage,
IMessage::DIn,
qobject_cast<RoomCLEntry*> (GetParentCLEntry ())->
GetRoomHandler ()->GetRoomJID (),
GetEntryName (),
Account_->GetClientConnection ().get ());
else
message = new GlooxMessage (IMessage::MTStatusMessage,
IMessage::DIn,
GetJID (),
variant,
Account_->GetClientConnection ().get ());
message->SetMessageSubType (IMessage::MSTParticipantStatusChange);
GlooxProtocol *proto = qobject_cast<GlooxProtocol*> (Account_->GetParentProtocol ());
IProxyObject *proxy = qobject_cast<IProxyObject*> (proto->GetProxyObject ());
const QString& state = proxy->StateToString (status.State_);
const QString& nick = GetEntryName () + '/' + variant;
message->setProperty ("Azoth/Nick", nick);
message->setProperty ("Azoth/TargetState", state);
message->setProperty ("Azoth/StatusText", status.StatusString_);
QString msg = tr ("%1 is now %2 (%3)")
.arg (nick)
.arg (state)
.arg (status.StatusString_);
message->SetBody (msg);
HandleMessage (message);
}
void EntryBase::HandlePEPEvent (QString variant, PEPEventBase *event)
{
const QStringList& vars = Variants ();
if (!vars.isEmpty () &&
(!vars.contains (variant) || variant.isEmpty ()))
variant = vars.first ();
if (UserActivity *activity = dynamic_cast<UserActivity*> (event))
{
if (activity->GetGeneral () == UserActivity::GeneralEmpty)
Variant2ClientInfo_ [variant].remove ("user_activity");
else
{
QMap<QString, QVariant> activityMap;
activityMap ["general"] = activity->GetGeneralStr ();
activityMap ["specific"] = activity->GetSpecificStr ();
activityMap ["text"] = activity->GetText ();
Variant2ClientInfo_ [variant] ["user_activity"] = activityMap;
}
emit activityChanged (variant);
return;
}
if (UserMood *mood = dynamic_cast<UserMood*> (event))
{
if (mood->GetMood () == UserMood::MoodEmpty)
Variant2ClientInfo_ [variant].remove ("user_mood");
else
{
QMap<QString, QVariant> moodMap;
moodMap ["mood"] = mood->GetMoodStr ();
moodMap ["text"] = mood->GetText ();
Variant2ClientInfo_ [variant] ["user_mood"] = moodMap;
}
emit moodChanged (variant);
return;
}
if (UserTune *tune = dynamic_cast<UserTune*> (event))
{
if (tune->IsNull ())
Variant2ClientInfo_ [variant].remove ("user_tune");
else
{
QMap<QString, QVariant> tuneMap;
tuneMap ["artist"] = tune->GetArtist ();
tuneMap ["source"] = tune->GetSource ();
tuneMap ["title"] = tune->GetTitle ();
tuneMap ["track"] = tune->GetTrack ();
tuneMap ["URI"] = tune->GetURI ();
tuneMap ["length"] = tune->GetLength ();
tuneMap ["rating"] = tune->GetRating ();
Variant2ClientInfo_ [variant] ["user_tune"] = tuneMap;
}
emit tuneChanged (variant);
return;
}
if (UserLocation *location = dynamic_cast<UserLocation*> (event))
{
Location_ [variant] = location->GetInfo ();
emit locationChanged (variant, this);
emit locationChanged (variant);
return;
}
if (PEPMicroblog *microblog = dynamic_cast<PEPMicroblog*> (event))
{
emit gotNewPost (*microblog);
return;
}
if (dynamic_cast<UserAvatarData*> (event) || dynamic_cast<UserAvatarMetadata*> (event))
return;
qWarning () << Q_FUNC_INFO
<< "unhandled PEP event from"
<< GetJID ()
<< "resource"
<< variant;
}
/** empty internal buffer */
void VariantPrimitiveSplitter::flush()
{
_impl->buffered_variants.clear();
_impl->output_variants = ns_variantprimitivesplitter::VariantQueue();
_impl->vs = Variants();
}
/** empty internal buffer */
void VariantCallsOnly::flush()
{
_impl->buffered_variants.clear();
_impl->vs = Variants();
_impl->homref_ivs.advance(-1);
}
