llcallingcard.h

Go to the documentation of this file.

#ifndef LL_LLCALLINGCARD_H
#define LL_LLCALLINGCARD_H

#include <map>
#include <set>
#include <string>
#include <vector>
#include "lluserrelations.h"
#include "lluuid.h"
#include "v3dmath.h"

//class LLInventoryModel;
//class LLInventoryObserver;
class LLMessageSystem;
class LLTrackingData;
class LLFriendObserver
{
public:
        // This enumeration is a way to refer to what changed in a more
        // human readable format. You can mask the value provided by
        // chaged() to see if the observer is interested in the change.
        enum 
        {
                NONE = 0,
                ADD = 1,
                REMOVE = 2,
                ONLINE = 4,
                POWERS = 8,
                ALL = 0xffffffff
        };
        virtual ~LLFriendObserver() {}
        virtual void changed(U32 mask) = 0;
};

/*
struct LLBuddyInfo
{
        bool mIsOnline;
        bool mIsEmpowered;
        LLBuddyInfo() : mIsOnline(false), mIsEmpowered(false) {}
};
*/

// This is used as a base class for doing operations on all buddies.
class LLRelationshipFunctor
{
public:
        virtual ~LLRelationshipFunctor() {}
        virtual bool operator()(const LLUUID& buddy_id, LLRelationship* buddy) = 0;
};
        

class LLAvatarTracker
{
public:
        static LLAvatarTracker& instance() { return sInstance; }
        
        void track(const LLUUID& avatar_id, const std::string& name);
        void untrack(const LLUUID& avatar_id);
        bool isTrackedAgentValid() { return mTrackedAgentValid; }
        void setTrackedAgentValid(bool valid) { mTrackedAgentValid = valid; }
        void findAgent();

        // coarse update information
        void setTrackedCoarseLocation(const LLVector3d& global_pos);

        // dealing with the tracked agent location
        bool haveTrackingInfo();
        void getDegreesAndDist(F32& rot, F64& horiz_dist, F64& vert_dist);
        LLVector3d getGlobalPos();

        // Get the name passed in, returns null string if uninitialized.
        const LLString& getName();

        // Get the avatar being tracked, returns LLUUID::null if uninitialized
        const LLUUID& getAvatarID();

        // Deal with inventory
        //void observe(LLInventoryModel* model);
        //void inventoryChanged();

        // add or remove agents from buddy list. Each method takes a set
        // of buddies and returns how many were actually added or removed.
        typedef std::map<LLUUID, LLRelationship*> buddy_map_t;

        S32 addBuddyList(const buddy_map_t& buddies);
        //S32 removeBuddyList(const buddy_list_t& exes);
        void copyBuddyList(buddy_map_t& buddies) const;

        // deal with termination of friendhsip
        void terminateBuddy(const LLUUID& id);

        // get full info
        const LLRelationship* getBuddyInfo(const LLUUID& id) const;

        // online status
        void setBuddyOnline(const LLUUID& id, bool is_online);
        bool isBuddyOnline(const LLUUID& id) const;

        // simple empowered status
        void setBuddyEmpowered(const LLUUID& id, bool is_empowered);
        bool isBuddyEmpowered(const LLUUID& id) const;

        // set the empower bit & message the server.
        void empowerList(const buddy_map_t& list, bool grant);
        void empower(const LLUUID& id, bool grant); // wrapper for above

        // register callbacks
        void registerCallbacks(LLMessageSystem* msg);

        // Add/remove an observer. If the observer is destroyed, be sure
        // to remove it. On destruction of the tracker, it will delete any
        // observers left behind.
        void addObserver(LLFriendObserver* observer);
        void removeObserver(LLFriendObserver* observer);
        void notifyObservers();

        // Apply the functor to every buddy. Do not actually modify the
        // buddy list in the functor or bad things will happen.
        void applyFunctor(LLRelationshipFunctor& f);

        static void formFriendship(const LLUUID& friend_id);

protected:
        void deleteTrackingData();
        void agentFound(const LLUUID& prey,
                                        const LLVector3d& estimated_global_pos);

        // Message system functionality
        static void processAgentFound(LLMessageSystem* msg, void**);
        static void processOnlineNotification(LLMessageSystem* msg, void**);
        static void processOfflineNotification(LLMessageSystem* msg, void**);
        //static void processGrantedProxies(LLMessageSystem* msg, void**);
        static void processTerminateFriendship(LLMessageSystem* msg, void**);
        static void processChangeUserRights(LLMessageSystem* msg, void**);

        void processNotify(LLMessageSystem* msg, bool online);
        void processChange(LLMessageSystem* msg);

protected:
        static LLAvatarTracker sInstance;
        LLTrackingData* mTrackingData;
        bool mTrackedAgentValid;
        U32 mModifyMask;
        //LLInventoryModel* mInventory;
        //LLInventoryObserver* mInventoryObserver;

        buddy_map_t mBuddyInfo;

        typedef std::vector<LLFriendObserver*> observer_list_t;
        observer_list_t mObservers;

private:
        // do not implement
        LLAvatarTracker(const LLAvatarTracker&);
        bool operator==(const LLAvatarTracker&);

public:
        // don't you dare create or delete this object
        LLAvatarTracker();
        ~LLAvatarTracker();
};

// collect set of LLUUIDs we're a proxy for
class LLCollectProxyBuddies : public LLRelationshipFunctor
{
public:
        LLCollectProxyBuddies() {}
        virtual ~LLCollectProxyBuddies() {}
        virtual bool operator()(const LLUUID& buddy_id, LLRelationship* buddy);
        typedef std::set<LLUUID> buddy_list_t;
        buddy_list_t mProxy;
};

// collect dictionary sorted map of name -> agent_id for every online buddy
class LLCollectMappableBuddies : public LLRelationshipFunctor
{
public:
        LLCollectMappableBuddies() {}
        virtual ~LLCollectMappableBuddies() {}
        virtual bool operator()(const LLUUID& buddy_id, LLRelationship* buddy);
        typedef std::map<std::string, LLUUID, LLDictionaryLess> buddy_map_t;
        buddy_map_t mMappable;
        char mFirst[DB_FIRST_NAME_BUF_SIZE];    /* Flawfinder: ignore */
        char mLast[DB_LAST_NAME_BUF_SIZE];      /* Flawfinder: ignore */
};

// collect dictionary sorted map of name -> agent_id for every online buddy
class LLCollectOnlineBuddies : public LLRelationshipFunctor
{
public:
        LLCollectOnlineBuddies() {}
        virtual ~LLCollectOnlineBuddies() {}
        virtual bool operator()(const LLUUID& buddy_id, LLRelationship* buddy);
        typedef std::map<std::string, LLUUID, LLDictionaryLess> buddy_map_t;
        buddy_map_t mOnline;
        char mFirst[DB_FIRST_NAME_BUF_SIZE];            /*Flawfinder: ignore*/
        char mLast[DB_LAST_NAME_BUF_SIZE];              /*Flawfinder: ignore*/  
};

// collect dictionary sorted map of name -> agent_id for every buddy,
// one map is offline and the other map is online.
class LLCollectAllBuddies : public LLRelationshipFunctor
{
public:
        LLCollectAllBuddies() {}
        virtual ~LLCollectAllBuddies() {}
        virtual bool operator()(const LLUUID& buddy_id, LLRelationship* buddy);
        typedef std::map<std::string, LLUUID, LLDictionaryLess> buddy_map_t;
        buddy_map_t mOnline;
        buddy_map_t mOffline;
        char mFirst[DB_FIRST_NAME_BUF_SIZE];    /*Flawfinder: ignore*/  
        char mLast[DB_LAST_NAME_BUF_SIZE];              /*Flawfinder: ignore*/
};

#endif // LL_LLCALLINGCARD_H

---