summaryrefslogtreecommitdiff
path: root/indra/newview/llcallingcard.h
blob: 07de0ff3ce36d165d25c182d7c25fce69def14d7 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
/**
 * @file llcallingcard.h
 * @brief Definition of the LLPreviewCallingCard class
 *
 * $LicenseInfo:firstyear=2002&license=viewerlgpl$
 * Second Life Viewer Source Code
 * Copyright (C) 2010, Linden Research, Inc.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation;
 * version 2.1 of the License only.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
 * $/LicenseInfo$
 */

#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
    // changed() 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 std::string& 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;

    // Is this person a friend/buddy/calling card holder?
    bool isBuddy(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 idleNotifyObservers();
    void notifyObservers();

    // Observers interested in updates of a particular avatar.
    // On destruction these observers are NOT deleted.
    void addParticularFriendObserver(const LLUUID& buddy_id, LLFriendObserver* observer);
    void removeParticularFriendObserver(const LLUUID& buddy_id, LLFriendObserver* observer);
    void notifyParticularFriendObservers(const LLUUID& buddy_id);

    /**
     * Stores flag for change and id of object change applies to
     *
     * This allows outsiders to tell the AvatarTracker if something has
     * been changed 'under the hood',
     * and next notification will have exact avatar IDs have been changed.
     */
    void addChangedMask(U32 mask, const LLUUID& referent);

    const std::set<LLUUID>& getChangedIDs() { return mChangedBuddyIDs; }

    // 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::set<LLUUID> changed_buddy_t;
    changed_buddy_t mChangedBuddyIDs;

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

    typedef std::set<LLFriendObserver*> observer_set_t;
    typedef std::map<LLUUID, observer_set_t> observer_map_t;
    observer_map_t mParticularFriendObserverMap;

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

    BOOL mIsNotifyObservers;

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<LLUUID, std::string> buddy_map_t;
    buddy_map_t mMappable;
    std::string mFullName;
};

// 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<LLUUID, std::string> buddy_map_t;
    buddy_map_t mOnline;
    std::string mFullName;
};

// 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<LLUUID, std::string> buddy_map_t;
    buddy_map_t mOnline;
    buddy_map_t mOffline;
    std::string mFullName;
};

#endif // LL_LLCALLINGCARD_H