798 lines
20 KiB
C++
798 lines
20 KiB
C++
/**
|
|
* @file llcallingcard.cpp
|
|
* @brief Implementation of the LLPreviewCallingCard class
|
|
*
|
|
* Copyright (c) 2002-$CurrentYear$, Linden Research, Inc.
|
|
* $License$
|
|
*/
|
|
|
|
#include "llviewerprecompiledheaders.h"
|
|
|
|
#if LL_WINDOWS
|
|
#pragma warning( disable : 4800 ) // performance warning in <functional>
|
|
#endif
|
|
|
|
#include "llcallingcard.h"
|
|
|
|
#include <vector>
|
|
#include <algorithm>
|
|
//#include <iterator>
|
|
|
|
#include "indra_constants.h"
|
|
#include "llcachename.h"
|
|
#include "llstl.h"
|
|
#include "lltimer.h"
|
|
#include "lluuid.h"
|
|
#include "message.h"
|
|
|
|
#include "llagent.h"
|
|
#include "llbutton.h"
|
|
//#include "llinventory.h"
|
|
#include "llinventorymodel.h"
|
|
#include "llnotify.h"
|
|
#include "llresmgr.h"
|
|
#include "llimview.h"
|
|
#include "llviewercontrol.h"
|
|
#include "llviewernetwork.h"
|
|
#include "llviewerobjectlist.h"
|
|
#include "llviewerwindow.h"
|
|
#include "llvoavatar.h"
|
|
|
|
///----------------------------------------------------------------------------
|
|
/// Local function declarations, constants, enums, and typedefs
|
|
///----------------------------------------------------------------------------
|
|
|
|
class LLTrackingData
|
|
{
|
|
public:
|
|
LLTrackingData(const LLUUID& avatar_id, const std::string& name);
|
|
bool haveTrackingInfo();
|
|
void setTrackedCoarseLocation(const LLVector3d& global_pos);
|
|
void agentFound(const LLUUID& prey,
|
|
const LLVector3d& estimated_global_pos);
|
|
|
|
public:
|
|
LLUUID mAvatarID;
|
|
LLString mName;
|
|
LLVector3d mGlobalPositionEstimate;
|
|
bool mHaveInfo;
|
|
bool mHaveCoarseInfo;
|
|
LLTimer mCoarseLocationTimer;
|
|
LLTimer mUpdateTimer;
|
|
LLTimer mAgentGone;
|
|
};
|
|
|
|
const F32 COARSE_FREQUENCY = 2.2f;
|
|
const F32 FIND_FREQUENCY = 29.7f; // This results in a database query, so cut these back
|
|
const F32 OFFLINE_SECONDS = FIND_FREQUENCY + 8.0f;
|
|
|
|
// static
|
|
LLAvatarTracker LLAvatarTracker::sInstance;
|
|
|
|
/*
|
|
class LLAvatarTrackerInventoryObserver : public LLInventoryObserver
|
|
{
|
|
public:
|
|
LLAvatarTrackerInventoryObserver(LLAvatarTracker* at) :
|
|
mAT(at) {}
|
|
virtual ~LLAvatarTrackerInventoryObserver() {}
|
|
virtual void changed(U32 mask);
|
|
protected:
|
|
LLAvatarTracker* mAT;
|
|
};
|
|
*/
|
|
|
|
/*
|
|
void LLAvatarTrackerInventoryObserver::changed(U32 mask)
|
|
{
|
|
// if there's a calling card change, just do it.
|
|
if((mask & LLInventoryObserver::CALLING_CARD) != 0)
|
|
{
|
|
mAT->inventoryChanged();
|
|
}
|
|
}
|
|
*/
|
|
|
|
///----------------------------------------------------------------------------
|
|
/// Class LLAvatarTracker
|
|
///----------------------------------------------------------------------------
|
|
|
|
LLAvatarTracker::LLAvatarTracker() :
|
|
mTrackingData(NULL),
|
|
mTrackedAgentValid(false),
|
|
//mInventory(NULL),
|
|
//mInventoryObserver(NULL),
|
|
mModifyMask(0x0)
|
|
{
|
|
}
|
|
|
|
LLAvatarTracker::~LLAvatarTracker()
|
|
{
|
|
deleteTrackingData();
|
|
std::for_each(mObservers.begin(), mObservers.end(), DeletePointer());
|
|
}
|
|
|
|
void LLAvatarTracker::track(const LLUUID& avatar_id, const std::string& name)
|
|
{
|
|
deleteTrackingData();
|
|
mTrackedAgentValid = false;
|
|
mTrackingData = new LLTrackingData(avatar_id, name);
|
|
findAgent();
|
|
|
|
// We track here because findAgent() is called on a timer (for now).
|
|
if(avatar_id.notNull())
|
|
{
|
|
LLMessageSystem* msg = gMessageSystem;
|
|
msg->newMessageFast(_PREHASH_TrackAgent);
|
|
msg->nextBlockFast(_PREHASH_AgentData);
|
|
msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
|
|
msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
|
|
msg->nextBlockFast(_PREHASH_TargetData);
|
|
msg->addUUIDFast(_PREHASH_PreyID, avatar_id);
|
|
gAgent.sendReliableMessage();
|
|
}
|
|
}
|
|
|
|
void LLAvatarTracker::untrack(const LLUUID& avatar_id)
|
|
{
|
|
if (mTrackingData && mTrackingData->mAvatarID == avatar_id)
|
|
{
|
|
deleteTrackingData();
|
|
mTrackedAgentValid = false;
|
|
LLMessageSystem* msg = gMessageSystem;
|
|
msg->newMessageFast(_PREHASH_TrackAgent);
|
|
msg->nextBlockFast(_PREHASH_AgentData);
|
|
msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
|
|
msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
|
|
msg->nextBlockFast(_PREHASH_TargetData);
|
|
msg->addUUIDFast(_PREHASH_PreyID, LLUUID::null);
|
|
gAgent.sendReliableMessage();
|
|
}
|
|
}
|
|
|
|
void LLAvatarTracker::setTrackedCoarseLocation(const LLVector3d& global_pos)
|
|
{
|
|
if(mTrackingData)
|
|
{
|
|
mTrackingData->setTrackedCoarseLocation(global_pos);
|
|
}
|
|
}
|
|
|
|
bool LLAvatarTracker::haveTrackingInfo()
|
|
{
|
|
if(mTrackingData)
|
|
{
|
|
return mTrackingData->haveTrackingInfo();
|
|
}
|
|
return false;
|
|
}
|
|
|
|
LLVector3d LLAvatarTracker::getGlobalPos()
|
|
{
|
|
if(!mTrackedAgentValid) return LLVector3d();
|
|
LLVector3d global_pos;
|
|
|
|
LLViewerObject* object = gObjectList.findObject(mTrackingData->mAvatarID);
|
|
if(object && !object->isDead())
|
|
{
|
|
global_pos = object->getPositionGlobal();
|
|
// HACK - for making the tracker point above the avatar's head
|
|
// rather than its groin
|
|
global_pos.mdV[VZ] += 0.7f * ((LLVOAvatar *)object)->mBodySize.mV[VZ];
|
|
|
|
mTrackingData->mGlobalPositionEstimate = global_pos;
|
|
}
|
|
else
|
|
{
|
|
global_pos = mTrackingData->mGlobalPositionEstimate;
|
|
}
|
|
|
|
return global_pos;
|
|
}
|
|
|
|
void LLAvatarTracker::getDegreesAndDist(F32& rot,
|
|
F64& horiz_dist,
|
|
F64& vert_dist)
|
|
{
|
|
if(!mTrackingData) return;
|
|
|
|
LLVector3d global_pos;
|
|
|
|
LLViewerObject* object = gObjectList.findObject(mTrackingData->mAvatarID);
|
|
if(object && !object->isDead())
|
|
{
|
|
global_pos = object->getPositionGlobal();
|
|
mTrackingData->mGlobalPositionEstimate = global_pos;
|
|
}
|
|
else
|
|
{
|
|
global_pos = mTrackingData->mGlobalPositionEstimate;
|
|
}
|
|
LLVector3d to_vec = global_pos - gAgent.getPositionGlobal();
|
|
horiz_dist = sqrt(to_vec.mdV[VX] * to_vec.mdV[VX] + to_vec.mdV[VY] * to_vec.mdV[VY]);
|
|
vert_dist = to_vec.mdV[VZ];
|
|
rot = F32(RAD_TO_DEG * atan2(to_vec.mdV[VY], to_vec.mdV[VX]));
|
|
}
|
|
|
|
const LLString& LLAvatarTracker::getName()
|
|
{
|
|
if(mTrackingData)
|
|
{
|
|
return mTrackingData->mName;
|
|
}
|
|
else
|
|
{
|
|
return LLString::null;
|
|
}
|
|
}
|
|
|
|
const LLUUID& LLAvatarTracker::getAvatarID()
|
|
{
|
|
if(mTrackingData)
|
|
{
|
|
return mTrackingData->mAvatarID;
|
|
}
|
|
else
|
|
{
|
|
return LLUUID::null;
|
|
}
|
|
}
|
|
|
|
S32 LLAvatarTracker::addBuddyList(const LLAvatarTracker::buddy_map_t& buds)
|
|
{
|
|
using namespace std;
|
|
|
|
U32 new_buddy_count = 0;
|
|
char first[DB_FIRST_NAME_BUF_SIZE]; /*Flawfinder: ignore*/
|
|
char last[DB_LAST_NAME_BUF_SIZE]; /*Flawfinder: ignore*/
|
|
LLUUID agent_id;
|
|
for(buddy_map_t::const_iterator itr = buds.begin(); itr != buds.end(); ++itr)
|
|
{
|
|
agent_id = (*itr).first;
|
|
if(mBuddyInfo.find(agent_id) == mBuddyInfo.end())
|
|
{
|
|
++new_buddy_count;
|
|
mBuddyInfo[agent_id] = (*itr).second;
|
|
gCacheName->getName(agent_id, first, last);
|
|
mModifyMask |= LLFriendObserver::ADD;
|
|
}
|
|
}
|
|
|
|
return new_buddy_count;
|
|
}
|
|
|
|
|
|
void LLAvatarTracker::copyBuddyList(buddy_map_t& buddies) const
|
|
{
|
|
buddy_map_t::const_iterator it = mBuddyInfo.begin();
|
|
buddy_map_t::const_iterator end = mBuddyInfo.end();
|
|
for(; it != end; ++it)
|
|
{
|
|
buddies[(*it).first] = (*it).second;
|
|
}
|
|
}
|
|
|
|
void LLAvatarTracker::terminateBuddy(const LLUUID& id)
|
|
{
|
|
lldebugs << "LLAvatarTracker::terminateBuddy()" << llendl;
|
|
LLRelationship* buddy = get_ptr_in_map(mBuddyInfo, id);
|
|
if(!buddy) return;
|
|
mBuddyInfo.erase(id);
|
|
LLMessageSystem* msg = gMessageSystem;
|
|
msg->newMessage("TerminateFriendship");
|
|
msg->nextBlock("AgentData");
|
|
msg->addUUID("AgentID", gAgent.getID());
|
|
msg->addUUID("SessionID", gAgent.getSessionID());
|
|
msg->nextBlock("ExBlock");
|
|
msg->addUUID("OtherID", id);
|
|
gAgent.sendReliableMessage();
|
|
mModifyMask |= LLFriendObserver::REMOVE;
|
|
delete buddy;
|
|
}
|
|
|
|
// get all buddy info
|
|
const LLRelationship* LLAvatarTracker::getBuddyInfo(const LLUUID& id) const
|
|
{
|
|
if(id.isNull()) return NULL;
|
|
return get_ptr_in_map(mBuddyInfo, id);
|
|
}
|
|
|
|
// online status
|
|
void LLAvatarTracker::setBuddyOnline(const LLUUID& id, bool is_online)
|
|
{
|
|
LLRelationship* info = get_ptr_in_map(mBuddyInfo, id);
|
|
if(info)
|
|
{
|
|
info->online(is_online);
|
|
mModifyMask |= LLFriendObserver::ONLINE;
|
|
}
|
|
}
|
|
|
|
bool LLAvatarTracker::isBuddyOnline(const LLUUID& id) const
|
|
{
|
|
LLRelationship* info = get_ptr_in_map(mBuddyInfo, id);
|
|
if(info)
|
|
{
|
|
return info->isOnline();
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// empowered status
|
|
void LLAvatarTracker::setBuddyEmpowered(const LLUUID& id, bool is_empowered)
|
|
{
|
|
LLRelationship* info = get_ptr_in_map(mBuddyInfo, id);
|
|
if(info)
|
|
{
|
|
info->grantRights(LLRelationship::GRANT_MODIFY_OBJECTS, 0);
|
|
mModifyMask |= LLFriendObserver::POWERS;
|
|
}
|
|
}
|
|
|
|
bool LLAvatarTracker::isBuddyEmpowered(const LLUUID& id) const
|
|
{
|
|
LLRelationship* info = get_ptr_in_map(mBuddyInfo, id);
|
|
if(info)
|
|
{
|
|
return info->isRightGrantedTo(LLRelationship::GRANT_MODIFY_OBJECTS);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void LLAvatarTracker::empower(const LLUUID& id, bool grant)
|
|
{
|
|
// wrapper for ease of use in some situations.
|
|
buddy_map_t list;
|
|
/*
|
|
list.insert(id);
|
|
empowerList(list, grant);
|
|
*/
|
|
}
|
|
|
|
void LLAvatarTracker::empowerList(const buddy_map_t& list, bool grant)
|
|
{
|
|
llwarns << "LLAvatarTracker::empowerList() not implemented." << llendl;
|
|
/*
|
|
LLMessageSystem* msg = gMessageSystem;
|
|
const char* message_name;
|
|
const char* block_name;
|
|
const char* field_name;
|
|
if(grant)
|
|
{
|
|
message_name = _PREHASH_GrantModification;
|
|
block_name = _PREHASH_EmpoweredBlock;
|
|
field_name = _PREHASH_EmpoweredID;
|
|
}
|
|
else
|
|
{
|
|
message_name = _PREHASH_RevokeModification;
|
|
block_name = _PREHASH_RevokedBlock;
|
|
field_name = _PREHASH_RevokedID;
|
|
}
|
|
|
|
std::string name;
|
|
gAgent.buildFullnameAndTitle(name);
|
|
|
|
bool start_new_message = true;
|
|
buddy_list_t::const_iterator it = list.begin();
|
|
buddy_list_t::const_iterator end = list.end();
|
|
for(; it != end; ++it)
|
|
{
|
|
if(NULL == get_ptr_in_map(mBuddyInfo, (*it))) continue;
|
|
setBuddyEmpowered((*it), grant);
|
|
if(start_new_message)
|
|
{
|
|
start_new_message = false;
|
|
msg->newMessageFast(message_name);
|
|
msg->nextBlockFast(_PREHASH_AgentData);
|
|
msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
|
|
msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
|
|
msg->addStringFast(_PREHASH_GranterName, name);
|
|
}
|
|
msg->nextBlockFast(block_name);
|
|
msg->addUUIDFast(field_name, (*it));
|
|
if(msg->isSendFullFast(block_name))
|
|
{
|
|
start_new_message = true;
|
|
gAgent.sendReliableMessage();
|
|
}
|
|
}
|
|
if(!start_new_message)
|
|
{
|
|
gAgent.sendReliableMessage();
|
|
}
|
|
*/
|
|
}
|
|
|
|
void LLAvatarTracker::deleteTrackingData()
|
|
{
|
|
delete mTrackingData;
|
|
mTrackingData = NULL;
|
|
}
|
|
|
|
void LLAvatarTracker::findAgent()
|
|
{
|
|
if (!mTrackingData) return;
|
|
if (mTrackingData->mAvatarID.isNull()) return;
|
|
LLMessageSystem* msg = gMessageSystem;
|
|
msg->newMessageFast(_PREHASH_FindAgent); // Request
|
|
msg->nextBlockFast(_PREHASH_AgentBlock);
|
|
msg->addUUIDFast(_PREHASH_Hunter, gAgentID);
|
|
msg->addUUIDFast(_PREHASH_Prey, mTrackingData->mAvatarID);
|
|
msg->addU32Fast(_PREHASH_SpaceIP, 0); // will get filled in by userserver
|
|
msg->nextBlockFast(_PREHASH_LocationBlock);
|
|
const F64 NO_LOCATION = 0.0;
|
|
msg->addF64Fast(_PREHASH_GlobalX, NO_LOCATION);
|
|
msg->addF64Fast(_PREHASH_GlobalY, NO_LOCATION);
|
|
gAgent.sendReliableMessage();
|
|
}
|
|
|
|
void LLAvatarTracker::addObserver(LLFriendObserver* observer)
|
|
{
|
|
if(observer)
|
|
{
|
|
mObservers.push_back(observer);
|
|
}
|
|
}
|
|
|
|
void LLAvatarTracker::removeObserver(LLFriendObserver* observer)
|
|
{
|
|
mObservers.erase(
|
|
std::remove(mObservers.begin(), mObservers.end(), observer),
|
|
mObservers.end());
|
|
}
|
|
|
|
void LLAvatarTracker::notifyObservers()
|
|
{
|
|
observer_list_t observers(mObservers);
|
|
observer_list_t::iterator it = observers.begin();
|
|
observer_list_t::iterator end = observers.end();
|
|
for(; it != end; ++it)
|
|
{
|
|
(*it)->changed(mModifyMask);
|
|
}
|
|
mModifyMask = LLFriendObserver::NONE;
|
|
}
|
|
|
|
void LLAvatarTracker::applyFunctor(LLRelationshipFunctor& f)
|
|
{
|
|
buddy_map_t::iterator it = mBuddyInfo.begin();
|
|
buddy_map_t::iterator end = mBuddyInfo.end();
|
|
for(; it != end; ++it)
|
|
{
|
|
f((*it).first, (*it).second);
|
|
}
|
|
}
|
|
|
|
void LLAvatarTracker::registerCallbacks(LLMessageSystem* msg)
|
|
{
|
|
msg->setHandlerFuncFast(_PREHASH_FindAgent, processAgentFound);
|
|
msg->setHandlerFuncFast(_PREHASH_OnlineNotification,
|
|
processOnlineNotification);
|
|
msg->setHandlerFuncFast(_PREHASH_OfflineNotification,
|
|
processOfflineNotification);
|
|
//msg->setHandlerFuncFast(_PREHASH_GrantedProxies,
|
|
// processGrantedProxies);
|
|
msg->setHandlerFunc("TerminateFriendship", processTerminateFriendship);
|
|
msg->setHandlerFunc(_PREHASH_ChangeUserRights, processChangeUserRights);
|
|
}
|
|
|
|
// static
|
|
void LLAvatarTracker::processAgentFound(LLMessageSystem* msg, void**)
|
|
{
|
|
LLUUID id;
|
|
|
|
|
|
msg->getUUIDFast(_PREHASH_AgentBlock, _PREHASH_Hunter, id);
|
|
msg->getUUIDFast(_PREHASH_AgentBlock, _PREHASH_Prey, id);
|
|
// *FIX: should make sure prey id matches.
|
|
LLVector3d estimated_global_pos;
|
|
msg->getF64Fast(_PREHASH_LocationBlock, _PREHASH_GlobalX,
|
|
estimated_global_pos.mdV[VX]);
|
|
msg->getF64Fast(_PREHASH_LocationBlock, _PREHASH_GlobalY,
|
|
estimated_global_pos.mdV[VY]);
|
|
LLAvatarTracker::instance().agentFound(id, estimated_global_pos);
|
|
}
|
|
|
|
void LLAvatarTracker::agentFound(const LLUUID& prey,
|
|
const LLVector3d& estimated_global_pos)
|
|
{
|
|
if(!mTrackingData) return;
|
|
//if we get a valid reply from the server, that means the agent
|
|
//is our friend and mappable, so enable interest list based updates
|
|
LLAvatarTracker::instance().setTrackedAgentValid(true);
|
|
mTrackingData->agentFound(prey, estimated_global_pos);
|
|
}
|
|
|
|
// static
|
|
void LLAvatarTracker::processOnlineNotification(LLMessageSystem* msg, void**)
|
|
{
|
|
lldebugs << "LLAvatarTracker::processOnlineNotification()" << llendl;
|
|
instance().processNotify(msg, true);
|
|
}
|
|
|
|
// static
|
|
void LLAvatarTracker::processOfflineNotification(LLMessageSystem* msg, void**)
|
|
{
|
|
lldebugs << "LLAvatarTracker::processOfflineNotification()" << llendl;
|
|
instance().processNotify(msg, false);
|
|
}
|
|
|
|
void LLAvatarTracker::processChange(LLMessageSystem* msg)
|
|
{
|
|
S32 count = msg->getNumberOfBlocksFast(_PREHASH_Rights);
|
|
LLUUID agent_id, agent_related;
|
|
S32 new_rights;
|
|
msg->getUUIDFast(_PREHASH_AgentData, _PREHASH_AgentID, agent_id);
|
|
for(int i = 0; i < count; ++i)
|
|
{
|
|
msg->getUUIDFast(_PREHASH_Rights, _PREHASH_AgentRelated, agent_related, i);
|
|
msg->getS32Fast(_PREHASH_Rights,_PREHASH_RelatedRights, new_rights, i);
|
|
if(agent_id == gAgent.getID())
|
|
{
|
|
if(mBuddyInfo.find(agent_related) != mBuddyInfo.end())
|
|
{
|
|
(mBuddyInfo[agent_related])->setRightsTo(new_rights);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(mBuddyInfo.find(agent_id) != mBuddyInfo.end())
|
|
{
|
|
if((mBuddyInfo[agent_id]->getRightsGrantedFrom() ^ new_rights) & LLRelationship::GRANT_MODIFY_OBJECTS)
|
|
{
|
|
char first[DB_FIRST_NAME_BUF_SIZE]; /*Flawfinder: ignore*/
|
|
char last[DB_LAST_NAME_BUF_SIZE]; /*Flawfinder: ignore*/
|
|
LLStringBase<char>::format_map_t args;
|
|
if(gCacheName->getName(agent_id, first, last))
|
|
{
|
|
args["[FIRST_NAME]"] = first;
|
|
args["[LAST_NAME]"] = last;
|
|
}
|
|
if(LLRelationship::GRANT_MODIFY_OBJECTS & new_rights)
|
|
{
|
|
gViewerWindow->alertXml("GrantedModifyRights",args);
|
|
}
|
|
else
|
|
{
|
|
gViewerWindow->alertXml("RevokedModifyRights",args);
|
|
}
|
|
}
|
|
(mBuddyInfo[agent_id])->setRightsFrom(new_rights);
|
|
}
|
|
}
|
|
}
|
|
mModifyMask |= LLFriendObserver::POWERS;
|
|
|
|
notifyObservers();
|
|
}
|
|
|
|
void LLAvatarTracker::processChangeUserRights(LLMessageSystem* msg, void**)
|
|
{
|
|
lldebugs << "LLAvatarTracker::processChangeUserRights()" << llendl;
|
|
instance().processChange(msg);
|
|
}
|
|
|
|
void LLAvatarTracker::processNotify(LLMessageSystem* msg, bool online)
|
|
{
|
|
S32 count = msg->getNumberOfBlocksFast(_PREHASH_AgentBlock);
|
|
BOOL chat_notify = gSavedSettings.getBOOL("ChatOnlineNotification");
|
|
|
|
if(count > 0)
|
|
{
|
|
LLUUID agent_id;
|
|
const LLRelationship* info = NULL;
|
|
LLUUID tracking_id;
|
|
if(mTrackingData)
|
|
{
|
|
tracking_id = mTrackingData->mAvatarID;
|
|
}
|
|
BOOL notify = FALSE;
|
|
LLString::format_map_t args;
|
|
for(S32 i = 0; i < count; ++i)
|
|
{
|
|
msg->getUUIDFast(_PREHASH_AgentBlock, _PREHASH_AgentID, agent_id, i);
|
|
info = getBuddyInfo(agent_id);
|
|
if(info)
|
|
{
|
|
setBuddyOnline(agent_id,online);
|
|
if(chat_notify)
|
|
{
|
|
char first[DB_FIRST_NAME_BUF_SIZE]; /*Flawfinder: ignore*/
|
|
char last[DB_LAST_NAME_BUF_SIZE]; /*Flawfinder: ignore*/
|
|
if(gCacheName->getName(agent_id, first, last))
|
|
{
|
|
notify = TRUE;
|
|
args["[FIRST]"] = first;
|
|
args["[LAST]"] = last;
|
|
}
|
|
}
|
|
}
|
|
if(tracking_id == agent_id)
|
|
{
|
|
// we were tracking someone who went offline
|
|
deleteTrackingData();
|
|
}
|
|
// *TODO: get actual inventory id
|
|
gInventory.addChangedMask(LLInventoryObserver::CALLING_CARD, LLUUID::null);
|
|
}
|
|
if(notify)
|
|
{
|
|
LLNotifyBox::showXml(online ? "FriendOnline" : "FriendOffline", args);
|
|
}
|
|
|
|
mModifyMask |= LLFriendObserver::ONLINE;
|
|
instance().notifyObservers();
|
|
gInventory.notifyObservers();
|
|
}
|
|
}
|
|
|
|
// XUI:translate
|
|
void LLAvatarTracker::formFriendship(const LLUUID& id)
|
|
{
|
|
if(id.notNull())
|
|
{
|
|
LLRelationship* buddy_info = get_ptr_in_map(instance().mBuddyInfo, id);
|
|
if(!buddy_info)
|
|
{
|
|
LLAvatarTracker& at = LLAvatarTracker::instance();
|
|
//The default for relationship establishment is to have both parties
|
|
//visible online to each other.
|
|
buddy_info = new LLRelationship(LLRelationship::GRANT_ONLINE_STATUS,LLRelationship::GRANT_ONLINE_STATUS, false);
|
|
at.mBuddyInfo[id] = buddy_info;
|
|
at.mModifyMask |= LLFriendObserver::ADD;
|
|
at.notifyObservers();
|
|
}
|
|
}
|
|
}
|
|
|
|
void LLAvatarTracker::processTerminateFriendship(LLMessageSystem* msg, void**)
|
|
{
|
|
LLUUID id;
|
|
msg->getUUID("ExBlock", "OtherID", id);
|
|
if(id.notNull())
|
|
{
|
|
LLAvatarTracker& at = LLAvatarTracker::instance();
|
|
LLRelationship* buddy = get_ptr_in_map(at.mBuddyInfo, id);
|
|
if(!buddy) return;
|
|
at.mBuddyInfo.erase(id);
|
|
at.mModifyMask |= LLFriendObserver::REMOVE;
|
|
delete buddy;
|
|
at.notifyObservers();
|
|
}
|
|
}
|
|
|
|
///----------------------------------------------------------------------------
|
|
/// Tracking Data
|
|
///----------------------------------------------------------------------------
|
|
|
|
LLTrackingData::LLTrackingData(const LLUUID& avatar_id, const std::string& name)
|
|
: mAvatarID(avatar_id),
|
|
mHaveInfo(false),
|
|
mHaveCoarseInfo(false)
|
|
{
|
|
mCoarseLocationTimer.setTimerExpirySec(COARSE_FREQUENCY);
|
|
mUpdateTimer.setTimerExpirySec(FIND_FREQUENCY);
|
|
mAgentGone.setTimerExpirySec(OFFLINE_SECONDS);
|
|
if(!name.empty())
|
|
{
|
|
mName = name;
|
|
}
|
|
}
|
|
|
|
void LLTrackingData::agentFound(const LLUUID& prey,
|
|
const LLVector3d& estimated_global_pos)
|
|
{
|
|
if(prey != mAvatarID)
|
|
{
|
|
llwarns << "LLTrackingData::agentFound() - found " << prey
|
|
<< " but looking for " << mAvatarID << llendl;
|
|
}
|
|
mHaveInfo = true;
|
|
mAgentGone.setTimerExpirySec(OFFLINE_SECONDS);
|
|
mGlobalPositionEstimate = estimated_global_pos;
|
|
}
|
|
|
|
bool LLTrackingData::haveTrackingInfo()
|
|
{
|
|
LLViewerObject* object = gObjectList.findObject(mAvatarID);
|
|
if(object && !object->isDead())
|
|
{
|
|
mCoarseLocationTimer.checkExpirationAndReset(COARSE_FREQUENCY);
|
|
mUpdateTimer.setTimerExpirySec(FIND_FREQUENCY);
|
|
mAgentGone.setTimerExpirySec(OFFLINE_SECONDS);
|
|
mHaveInfo = true;
|
|
return true;
|
|
}
|
|
if(mHaveCoarseInfo &&
|
|
!mCoarseLocationTimer.checkExpirationAndReset(COARSE_FREQUENCY))
|
|
{
|
|
// if we reach here, then we have a 'recent' coarse update
|
|
mUpdateTimer.setTimerExpirySec(FIND_FREQUENCY);
|
|
mAgentGone.setTimerExpirySec(OFFLINE_SECONDS);
|
|
return true;
|
|
}
|
|
if(mUpdateTimer.checkExpirationAndReset(FIND_FREQUENCY))
|
|
{
|
|
LLAvatarTracker::instance().findAgent();
|
|
mHaveCoarseInfo = false;
|
|
}
|
|
if(mAgentGone.checkExpirationAndReset(OFFLINE_SECONDS))
|
|
{
|
|
mHaveInfo = false;
|
|
mHaveCoarseInfo = false;
|
|
}
|
|
return mHaveInfo;
|
|
}
|
|
|
|
void LLTrackingData::setTrackedCoarseLocation(const LLVector3d& global_pos)
|
|
{
|
|
mCoarseLocationTimer.setTimerExpirySec(COARSE_FREQUENCY);
|
|
mGlobalPositionEstimate = global_pos;
|
|
mHaveInfo = true;
|
|
mHaveCoarseInfo = true;
|
|
}
|
|
|
|
///----------------------------------------------------------------------------
|
|
// various buddy functors
|
|
///----------------------------------------------------------------------------
|
|
|
|
bool LLCollectProxyBuddies::operator()(const LLUUID& buddy_id, LLRelationship* buddy)
|
|
{
|
|
if(buddy->isRightGrantedFrom(LLRelationship::GRANT_MODIFY_OBJECTS))
|
|
{
|
|
mProxy.insert(buddy_id);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool LLCollectMappableBuddies::operator()(const LLUUID& buddy_id, LLRelationship* buddy)
|
|
{
|
|
mFirst[0] = '\0';
|
|
mLast[0] = '\0';
|
|
gCacheName->getName(buddy_id, mFirst, mLast);
|
|
std::ostringstream fullname;
|
|
fullname << mFirst << " " << mLast;
|
|
buddy_map_t::value_type value(fullname.str(), buddy_id);
|
|
if(buddy->isOnline() && buddy->isRightGrantedFrom(LLRelationship::GRANT_MAP_LOCATION))
|
|
{
|
|
mMappable.insert(value);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool LLCollectOnlineBuddies::operator()(const LLUUID& buddy_id, LLRelationship* buddy)
|
|
{
|
|
mFirst[0] = '\0';
|
|
mLast[0] = '\0';
|
|
gCacheName->getName(buddy_id, mFirst, mLast);
|
|
std::ostringstream fullname;
|
|
fullname << mFirst << " " << mLast;
|
|
buddy_map_t::value_type value(fullname.str(), buddy_id);
|
|
if(buddy->isOnline())
|
|
{
|
|
mOnline.insert(value);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool LLCollectAllBuddies::operator()(const LLUUID& buddy_id, LLRelationship* buddy)
|
|
{
|
|
mFirst[0] = '\0';
|
|
mLast[0] = '\0';
|
|
gCacheName->getName(buddy_id, mFirst, mLast);
|
|
std::ostringstream fullname;
|
|
fullname << mFirst << " " << mLast;
|
|
buddy_map_t::value_type value(fullname.str(), buddy_id);
|
|
if(buddy->isOnline())
|
|
{
|
|
mOnline.insert(value);
|
|
}
|
|
else
|
|
{
|
|
mOffline.insert(value);
|
|
}
|
|
return true;
|
|
}
|
|
|