summaryrefslogtreecommitdiff
path: root/indra/newview/llvoiceclient.h
blob: cfc336b27db9ed5dd013dae7b09b1ffbbcbe774d (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
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
/** 
 * @file llvoiceclient.h
 * @brief Declaration of LLVoiceClient class which is the interface to the voice client process.
 *
 * $LicenseInfo:firstyear=2001&license=viewergpl$
 * 
 * Copyright (c) 2001-2009, Linden Research, Inc.
 * 
 * Second Life Viewer Source Code
 * The source code in this file ("Source Code") is provided by Linden Lab
 * to you under the terms of the GNU General Public License, version 2.0
 * ("GPL"), unless you have obtained a separate licensing agreement
 * ("Other License"), formally executed by you and Linden Lab.  Terms of
 * the GPL can be found in doc/GPL-license.txt in this distribution, or
 * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
 * 
 * There are special exceptions to the terms and conditions of the GPL as
 * it is applied to this Source Code. View the full text of the exception
 * in the file doc/FLOSS-exception.txt in this software distribution, or
 * online at
 * http://secondlifegrid.net/programs/open_source/licensing/flossexception
 * 
 * By copying, modifying or distributing this software, you acknowledge
 * that you have read and understood your obligations described above,
 * and agree to abide by those obligations.
 * 
 * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
 * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
 * COMPLETENESS OR PERFORMANCE.
 * $/LicenseInfo$
 */
#ifndef LL_VOICE_CLIENT_H
#define LL_VOICE_CLIENT_H

class LLVOAvatar;
class LLVivoxProtocolParser;

#include "lliopipe.h"
#include "llpumpio.h"
#include "llchainio.h"
#include "lliosocket.h"
#include "v3math.h"
#include "llframetimer.h"
#include "llviewerregion.h"
#include "llcallingcard.h"   // for LLFriendObserver

class LLVoiceClientParticipantObserver
{
public:
	virtual ~LLVoiceClientParticipantObserver() { }
	virtual void onChange() = 0;
};

class LLVoiceClientStatusObserver
{
public:
	typedef enum e_voice_status_type
	{
		// NOTE: when updating this enum, please also update the switch in
		//  LLVoiceClientStatusObserver::status2string().
		STATUS_LOGIN_RETRY,
		STATUS_LOGGED_IN,
		STATUS_JOINING,
		STATUS_JOINED,
		STATUS_LEFT_CHANNEL,
		STATUS_VOICE_DISABLED,
		BEGIN_ERROR_STATUS,
		ERROR_CHANNEL_FULL,
		ERROR_CHANNEL_LOCKED,
		ERROR_NOT_AVAILABLE,
		ERROR_UNKNOWN
	} EStatusType;

	virtual ~LLVoiceClientStatusObserver() { }
	virtual void onChange(EStatusType status, const std::string &channelURI, bool proximal) = 0;

	static std::string status2string(EStatusType inStatus);
};

class LLVoiceClient: public LLSingleton<LLVoiceClient>
{
	LOG_CLASS(LLVoiceClient);
	public:
		LLVoiceClient();	
		~LLVoiceClient();
		
	public:
		static void init(LLPumpIO *pump);	// Call this once at application startup (creates connector)
		static void terminate();	// Call this to clean up during shutdown
						
	protected:
		bool writeString(const std::string &str);

	public:
		
		static F32 OVERDRIVEN_POWER_LEVEL;

		void updateSettings(); // call after loading settings and whenever they change
	
		void getCaptureDevicesSendMessage();
		void getRenderDevicesSendMessage();
		
		void clearCaptureDevices();
		void addCaptureDevice(const std::string& name);
		void setCaptureDevice(const std::string& name);
		
		void clearRenderDevices();
		void addRenderDevice(const std::string& name);
		void setRenderDevice(const std::string& name);

		void tuningStart();
		void tuningStop();
		bool inTuningMode();
		bool inTuningStates();
		
		void tuningRenderStartSendMessage(const std::string& name, bool loop);
		void tuningRenderStopSendMessage();

		void tuningCaptureStartSendMessage(int duration);
		void tuningCaptureStopSendMessage();
		
		void tuningSetMicVolume(float volume);
		void tuningSetSpeakerVolume(float volume);
		float tuningGetEnergy(void);
				
		// This returns true when it's safe to bring up the "device settings" dialog in the prefs.
		// i.e. when the daemon is running and connected, and the device lists are populated.
		bool deviceSettingsAvailable();
		
		// Requery the vivox daemon for the current list of input/output devices.
		// If you pass true for clearCurrentList, deviceSettingsAvailable() will be false until the query has completed
		// (use this if you want to know when it's done).
		// If you pass false, you'll have no way to know when the query finishes, but the device lists will not appear empty in the interim.
		void refreshDeviceLists(bool clearCurrentList = true);
		
		// Call this if the connection to the daemon terminates unexpectedly.  It will attempt to reset everything and relaunch.
		void daemonDied();

		// Call this if we're just giving up on voice (can't provision an account, etc.).  It will clean up and go away.
		void giveUp();
		
		/////////////////////////////
		// Response/Event handlers
		void connectorCreateResponse(int statusCode, std::string &statusString, std::string &connectorHandle, std::string &versionID);
		void loginResponse(int statusCode, std::string &statusString, std::string &accountHandle, int numberOfAliases);
		void sessionCreateResponse(std::string &requestId, int statusCode, std::string &statusString, std::string &sessionHandle);
		void sessionGroupAddSessionResponse(std::string &requestId, int statusCode, std::string &statusString, std::string &sessionHandle);
		void sessionConnectResponse(std::string &requestId, int statusCode, std::string &statusString);
		void logoutResponse(int statusCode, std::string &statusString);
		void connectorShutdownResponse(int statusCode, std::string &statusString);

		void accountLoginStateChangeEvent(std::string &accountHandle, int statusCode, std::string &statusString, int state);
		void mediaStreamUpdatedEvent(std::string &sessionHandle, std::string &sessionGroupHandle, int statusCode, std::string &statusString, int state, bool incoming);
		void textStreamUpdatedEvent(std::string &sessionHandle, std::string &sessionGroupHandle, bool enabled, int state, bool incoming);
		void sessionAddedEvent(std::string &uriString, std::string &alias, std::string &sessionHandle, std::string &sessionGroupHandle, bool isChannel, bool incoming, std::string &nameString, std::string &applicationString);
		void sessionGroupAddedEvent(std::string &sessionGroupHandle);
		void sessionRemovedEvent(std::string &sessionHandle, std::string &sessionGroupHandle);
		void participantAddedEvent(std::string &sessionHandle, std::string &sessionGroupHandle, std::string &uriString, std::string &alias, std::string &nameString, std::string &displayNameString, int participantType);
		void participantRemovedEvent(std::string &sessionHandle, std::string &sessionGroupHandle, std::string &uriString, std::string &alias, std::string &nameString);
		void participantUpdatedEvent(std::string &sessionHandle, std::string &sessionGroupHandle, std::string &uriString, std::string &alias, bool isModeratorMuted, bool isSpeaking, int volume, F32 energy);
		void auxAudioPropertiesEvent(F32 energy);
		void buddyPresenceEvent(std::string &uriString, std::string &alias, std::string &statusString, std::string &applicationString);
		void messageEvent(std::string &sessionHandle, std::string &uriString, std::string &alias, std::string &messageHeader, std::string &messageBody, std::string &applicationString);
		void sessionNotificationEvent(std::string &sessionHandle, std::string &uriString, std::string &notificationType);
		void subscriptionEvent(std::string &buddyURI, std::string &subscriptionHandle, std::string &alias, std::string &displayName, std::string &applicationString, std::string &subscriptionType);
		
		void buddyListChanged();
		void muteListChanged();
		void updateFriends(U32 mask);
		
		/////////////////////////////
		// Sending updates of current state
static	void updatePosition(void);
		void setCameraPosition(const LLVector3d &position, const LLVector3 &velocity, const LLMatrix3 &rot);
		void setAvatarPosition(const LLVector3d &position, const LLVector3 &velocity, const LLMatrix3 &rot);
		bool channelFromRegion(LLViewerRegion *region, std::string &name);
		void leaveChannel(void);		// call this on logout or teleport begin

		
		void setMuteMic(bool muted);		// Use this to mute the local mic (for when the client is minimized, etc), ignoring user PTT state.
		void setUserPTTState(bool ptt);
		bool getUserPTTState();
		void toggleUserPTTState(void);
		void setVoiceEnabled(bool enabled);
		static bool voiceEnabled();
		void setUsePTT(bool usePTT);
		void setPTTIsToggle(bool PTTIsToggle);
		void setPTTKey(std::string &key);
		void setEarLocation(S32 loc);
		void setVoiceVolume(F32 volume);
		void setMicGain(F32 volume);
		void setUserVolume(const LLUUID& id, F32 volume); // set's volume for specified agent, from 0-1 (where .5 is nominal)
		void setLipSyncEnabled(BOOL enabled);
		BOOL lipSyncEnabled();

		// PTT key triggering
		void keyDown(KEY key, MASK mask);
		void keyUp(KEY key, MASK mask);
		void middleMouseState(bool down);
		
		/////////////////////////////
		// Accessors for data related to nearby speakers
		BOOL getVoiceEnabled(const LLUUID& id);		// true if we've received data for this avatar
		BOOL getIsSpeaking(const LLUUID& id);
		BOOL getIsModeratorMuted(const LLUUID& id);
		F32 getCurrentPower(const LLUUID& id);		// "power" is related to "amplitude" in a defined way.  I'm just not sure what the formula is...
		BOOL getOnMuteList(const LLUUID& id);
		F32 getUserVolume(const LLUUID& id);
		std::string getDisplayName(const LLUUID& id);
		
		// MBW -- XXX -- Not sure how to get this data out of the TVC
		BOOL getUsingPTT(const LLUUID& id);
		std::string getGroupID(const LLUUID& id);		// group ID if the user is in group chat (empty string if not applicable)

		/////////////////////////////
		BOOL getAreaVoiceDisabled();		// returns true if the area the avatar is in is speech-disabled.
											// Use this to determine whether to show a "no speech" icon in the menu bar.
		
		/////////////////////////////
		// Recording controls
		void recordingLoopStart(int seconds = 3600, int deltaFramesPerControlFrame = 200);
		void recordingLoopSave(const std::string& filename);
		void recordingStop();
		
		// Playback controls
		void filePlaybackStart(const std::string& filename);
		void filePlaybackStop();
		void filePlaybackSetPaused(bool paused);
		void filePlaybackSetMode(bool vox = false, float speed = 1.0f);
		
		
		// This is used by the string-keyed maps below, to avoid storing the string twice.
		// The 'const std::string *' in the key points to a string actually stored in the object referenced by the map.
		// The add and delete operations for each map allocate and delete in the right order to avoid dangling references.
		// The default compare operation would just compare pointers, which is incorrect, so they must use this comparitor instead.
		struct stringMapComparitor
		{
			bool operator()(const std::string* a, const std::string * b) const
			{
				return a->compare(*b) < 0;
			}
		};

		struct uuidMapComparitor
		{
			bool operator()(const LLUUID* a, const LLUUID * b) const
			{
				return *a < *b;
			}
		};
		
		struct participantState
		{
		public:
			participantState(const std::string &uri);

			bool updateMuteState();
			bool isAvatar();

			std::string mURI;
			LLUUID mAvatarID;
			std::string mAccountName;
			std::string mDisplayName;
			LLFrameTimer mSpeakingTimeout;
			F32	mLastSpokeTimestamp;
			F32 mPower;
			int mVolume;
			std::string mGroupID;
			int mUserVolume;
			bool mPTT;
			bool mIsSpeaking;
			bool mIsModeratorMuted;
			bool mOnMuteList;		// true if this avatar is on the user's mute list (and should be muted)
			bool mVolumeDirty;		// true if this participant needs a volume command sent (either mOnMuteList or mUserVolume has changed)
			bool mAvatarIDValid;
			bool mIsSelf;
		};
		typedef std::map<const std::string *, participantState*, stringMapComparitor> participantMap;

		typedef std::map<const LLUUID *, participantState*, uuidMapComparitor> participantUUIDMap;
	
		enum streamState
		{
			streamStateUnknown = 0,
			streamStateIdle = 1,
			streamStateConnected = 2,
			streamStateRinging = 3,
		};
		
		struct sessionState
		{
		public:
			sessionState();
			~sessionState();

			participantState *addParticipant(const std::string &uri);
			// Note: after removeParticipant returns, the participant* that was passed to it will have been deleted.
			// Take care not to use the pointer again after that.
			void removeParticipant(participantState *participant);
			void removeAllParticipants();

			participantState *findParticipant(const std::string &uri);
			participantState *findParticipantByID(const LLUUID& id);

			bool isCallBackPossible();
			bool isTextIMPossible();

			std::string mHandle;
			std::string mGroupHandle;
			std::string mSIPURI;
			std::string mAlias;
			std::string mName;
			std::string mAlternateSIPURI;
			std::string mHash;			// Channel password
			std::string mErrorStatusString;
			std::queue<std::string> mTextMsgQueue;
			
			LLUUID		mIMSessionID;
			LLUUID		mCallerID;
			int			mErrorStatusCode;
			int			mMediaStreamState;
			int			mTextStreamState;
			bool		mCreateInProgress;	// True if a Session.Create has been sent for this session and no response has been received yet.
			bool		mMediaConnectInProgress;	// True if a Session.MediaConnect has been sent for this session and no response has been received yet.
			bool		mVoiceInvitePending;	// True if a voice invite is pending for this session (usually waiting on a name lookup)
			bool		mTextInvitePending;		// True if a text invite is pending for this session (usually waiting on a name lookup)
			bool		mSynthesizedCallerID;	// True if the caller ID is a hash of the SIP URI -- this means we shouldn't do a name lookup.
			bool		mIsChannel;	// True for both group and spatial channels (false for p2p, PSTN)
			bool		mIsSpatial;	// True for spatial channels
			bool		mIsP2P;
			bool		mIncoming;
			bool		mVoiceEnabled;
			bool		mReconnect;	// Whether we should try to reconnect to this session if it's dropped
			// Set to true when the mute state of someone in the participant list changes.
			// The code will have to walk the list to find the changed participant(s).
			bool		mVolumeDirty;

			bool		mParticipantsChanged;
			participantMap mParticipantsByURI;
			participantUUIDMap mParticipantsByUUID;
		};

		participantState *findParticipantByID(const LLUUID& id);
		participantMap *getParticipantList(void);
		
		typedef std::map<const std::string*, sessionState*, stringMapComparitor> sessionMap;
		typedef std::set<sessionState*> sessionSet;
				
		typedef sessionSet::iterator sessionIterator;
		sessionIterator sessionsBegin(void);
		sessionIterator sessionsEnd(void);

		sessionState *findSession(const std::string &handle);
		sessionState *findSessionBeingCreatedByURI(const std::string &uri);
		sessionState *findSession(const LLUUID &participant_id);
		sessionState *findSessionByCreateID(const std::string &create_id);
		
		sessionState *addSession(const std::string &uri, const std::string &handle = LLStringUtil::null);
		void setSessionHandle(sessionState *session, const std::string &handle = LLStringUtil::null);
		void setSessionURI(sessionState *session, const std::string &uri);
		void deleteSession(sessionState *session);
		void deleteAllSessions(void);

		void verifySessionState(void);

		void joinedAudioSession(sessionState *session);
		void leftAudioSession(sessionState *session);

		// This is called in several places where the session _may_ need to be deleted.
		// It contains logic for whether to delete the session or keep it around.
		void reapSession(sessionState *session);
		
		// Returns true if the session seems to indicate we've moved to a region on a different voice server
		bool sessionNeedsRelog(sessionState *session);
		
		struct buddyListEntry
		{
			buddyListEntry(const std::string &uri);
			std::string mURI;
			std::string mDisplayName;
			LLUUID	mUUID;
			bool mOnlineSL;
			bool mOnlineSLim;
			bool mCanSeeMeOnline;
			bool mHasBlockListEntry;
			bool mHasAutoAcceptListEntry;
			bool mNameResolved;
			bool mInSLFriends;
			bool mInVivoxBuddies;
			bool mNeedsNameUpdate;
		};

		typedef std::map<const std::string*, buddyListEntry*, stringMapComparitor> buddyListMap;
		
		// This should be called when parsing a buddy list entry sent by SLVoice.		
		void processBuddyListEntry(const std::string &uri, const std::string &displayName);

		buddyListEntry *addBuddy(const std::string &uri);
		buddyListEntry *addBuddy(const std::string &uri, const std::string &displayName);
		buddyListEntry *findBuddy(const std::string &uri);
		buddyListEntry *findBuddy(const LLUUID &id);
		buddyListEntry *findBuddyByDisplayName(const std::string &name);
		void deleteBuddy(const std::string &uri);
		void deleteAllBuddies(void);

		void deleteAllBlockRules(void);
		void addBlockRule(const std::string &blockMask, const std::string &presenceOnly);
		void deleteAllAutoAcceptRules(void);
		void addAutoAcceptRule(const std::string &autoAcceptMask, const std::string &autoAddAsBuddy);
		void accountListBlockRulesResponse(int statusCode, const std::string &statusString);						
		void accountListAutoAcceptRulesResponse(int statusCode, const std::string &statusString);						
		
		/////////////////////////////
		// session control messages
		void connectorCreate();
		void connectorShutdown();

		void requestVoiceAccountProvision(S32 retries = 3);
		void userAuthorized(
			const std::string& firstName,
			const std::string& lastName,
			const LLUUID &agentID);
		void login(
			const std::string& account_name,
			const std::string& password,
			const std::string& voice_sip_uri_hostname,
			const std::string& voice_account_server_uri);
		void loginSendMessage();
		void logout();
		void logoutSendMessage();

		void accountListBlockRulesSendMessage();
		void accountListAutoAcceptRulesSendMessage();
		
		void sessionGroupCreateSendMessage();
		void sessionCreateSendMessage(sessionState *session, bool startAudio = true, bool startText = false);
		void sessionGroupAddSessionSendMessage(sessionState *session, bool startAudio = true, bool startText = false);
		void sessionMediaConnectSendMessage(sessionState *session);		// just joins the audio session
		void sessionTextConnectSendMessage(sessionState *session);		// just joins the text session
		void sessionTerminateSendMessage(sessionState *session);
		void sessionGroupTerminateSendMessage(sessionState *session);
		void sessionMediaDisconnectSendMessage(sessionState *session);
		void sessionTextDisconnectSendMessage(sessionState *session);

		// Pokes the state machine to leave the audio session next time around.
		void sessionTerminate();	
		
		// Pokes the state machine to shut down the connector and restart it.
		void requestRelog();
		
		// Does the actual work to get out of the audio session
		void leaveAudioSession();
		
		void addObserver(LLVoiceClientParticipantObserver* observer);
		void removeObserver(LLVoiceClientParticipantObserver* observer);

		void addObserver(LLVoiceClientStatusObserver* observer);
		void removeObserver(LLVoiceClientStatusObserver* observer);

		void addObserver(LLFriendObserver* observer);
		void removeObserver(LLFriendObserver* observer);
		
		void lookupName(const LLUUID &id);
		static void onAvatarNameLookup(const LLUUID& id, const std::string& first, const std::string& last, BOOL is_group, void* user_data);
		void avatarNameResolved(const LLUUID &id, const std::string &name);
		
		typedef std::vector<std::string> deviceList;

		deviceList *getCaptureDevices();
		deviceList *getRenderDevices();
		
		void setNonSpatialChannel(
			const std::string &uri,
			const std::string &credentials);
		void setSpatialChannel(
			const std::string &uri,
			const std::string &credentials);
		// start a voice session with the specified user
		void callUser(const LLUUID &uuid);
		
		// Send a text message to the specified user, initiating the session if necessary.
		bool sendTextMessage(const LLUUID& participant_id, const std::string& message);
		
		// close any existing text IM session with the specified user
		void endUserIMSession(const LLUUID &uuid);
		
		bool answerInvite(std::string &sessionHandle);
		void declineInvite(std::string &sessionHandle);
		void leaveNonSpatialChannel();

		// Returns the URI of the current channel, or an empty string if not currently in a channel.
		// NOTE that it will return an empty string if it's in the process of joining a channel.
		std::string getCurrentChannel();
		
		// returns true iff the user is currently in a proximal (local spatial) channel.
		// Note that gestures should only fire if this returns true.
		bool inProximalChannel();

		std::string sipURIFromID(const LLUUID &id);
				
		// Returns true if the indicated user is online via SIP presence according to SLVoice.
		// Note that we only get SIP presence data for other users that are in our vivox buddy list.
		bool isOnlineSIP(const LLUUID &id);

		// Returns true if the indicated participant is really an SL avatar.
		// This should be used to control the state of the "profile" button.
		// Currently this will be false only for PSTN callers into group chats, and PSTN p2p calls.
		bool isParticipantAvatar(const LLUUID &id);
		
		// Returns true if calling back the session URI after the session has closed is possible.
		// Currently this will be false only for PSTN P2P calls.		
		// NOTE: this will return true if the session can't be found. 
		bool isSessionCallBackPossible(const LLUUID &session_id);
		
		// Returns true if the session can accepte text IM's.
		// Currently this will be false only for PSTN P2P calls.
		// NOTE: this will return true if the session can't be found. 
		bool isSessionTextIMPossible(const LLUUID &session_id);
		
	private:

		// internal state for a simple state machine.  This is used to deal with the asynchronous nature of some of the messages.
		// Note: if you change this list, please make corresponding changes to LLVoiceClient::state2string().
		enum state
		{
			stateDisableCleanup,
			stateDisabled,				// Voice is turned off.
			stateStart,					// Class is initialized, socket is created
			stateDaemonLaunched,		// Daemon has been launched
			stateConnecting,			// connect() call has been issued
			stateConnected,				// connection to the daemon has been made, send some initial setup commands.
			stateIdle,					// socket is connected, ready for messaging
			stateMicTuningStart,
			stateMicTuningRunning,		
			stateMicTuningStop,
			stateConnectorStart,		// connector needs to be started
			stateConnectorStarting,		// waiting for connector handle
			stateConnectorStarted,		// connector handle received
			stateLoginRetry,			// need to retry login (failed due to changing password)
			stateLoginRetryWait,		// waiting for retry timer
			stateNeedsLogin,			// send login request
			stateLoggingIn,				// waiting for account handle
			stateLoggedIn,				// account handle received
			stateCreatingSessionGroup,	// Creating the main session group
			stateNoChannel,				// 
			stateJoiningSession,		// waiting for session handle
			stateSessionJoined,			// session handle received
			stateRunning,				// in session, steady state
			stateLeavingSession,		// waiting for terminate session response
			stateSessionTerminated,		// waiting for terminate session response

			stateLoggingOut,			// waiting for logout response
			stateLoggedOut,				// logout response received
			stateConnectorStopping,		// waiting for connector stop
			stateConnectorStopped,		// connector stop received
			
			// We go to this state if the login fails because the account needs to be provisioned.
			
			// error states.  No way to recover from these yet.
			stateConnectorFailed,
			stateConnectorFailedWaiting,
			stateLoginFailed,
			stateLoginFailedWaiting,
			stateJoinSessionFailed,
			stateJoinSessionFailedWaiting,

			stateJail					// Go here when all else has failed.  Nothing will be retried, we're done.
		};
		
		state mState;
		bool mSessionTerminateRequested;
		bool mRelogRequested;
		
		void setState(state inState);
		state getState(void)  { return mState; };
		static std::string state2string(state inState);
		
		void stateMachine();
		static void idle(void *user_data);
		
		LLHost mDaemonHost;
		LLSocket::ptr_t mSocket;
		bool mConnected;
		
		void closeSocket(void);
		
		LLPumpIO *mPump;
		friend class LLVivoxProtocolParser;
		
		std::string mAccountName;
		std::string mAccountPassword;
		std::string mAccountDisplayName;
		std::string mAccountFirstName;
		std::string mAccountLastName;
				
		bool mTuningMode;
		float mTuningEnergy;
		std::string mTuningAudioFile;
		int mTuningMicVolume;
		bool mTuningMicVolumeDirty;
		int mTuningSpeakerVolume;
		bool mTuningSpeakerVolumeDirty;
		state mTuningExitState;					// state to return to when we leave tuning mode.
		
		std::string mSpatialSessionURI;
		std::string mSpatialSessionCredentials;

		std::string mMainSessionGroupHandle; // handle of the "main" session group.
		
		std::string mChannelName;			// Name of the channel to be looked up 
		bool mAreaVoiceDisabled;
		sessionState *mAudioSession;		// Session state for the current audio session
		bool mAudioSessionChanged;			// set to true when the above pointer gets changed, so observers can be notified.

		sessionState *mNextAudioSession;	// Session state for the audio session we're trying to join

//		std::string mSessionURI;			// URI of the session we're in.
//		std::string mSessionHandle;		// returned by ?
		
		S32 mCurrentParcelLocalID;			// Used to detect parcel boundary crossings
		std::string mCurrentRegionName;		// Used to detect parcel boundary crossings
		
		std::string mConnectorHandle;	// returned by "Create Connector" message
		std::string mAccountHandle;		// returned by login message		
		int 		mNumberOfAliases;
		U32 mCommandCookie;
	
		std::string mVoiceAccountServerURI;
		std::string mVoiceSIPURIHostName;
		
		int mLoginRetryCount;
		
		sessionMap mSessionsByHandle;				// Active sessions, indexed by session handle.  Sessions which are being initiated may not be in this map.
		sessionSet mSessions;						// All sessions, not indexed.  This is the canonical session list.
		
		bool mBuddyListMapPopulated;
		bool mBlockRulesListReceived;
		bool mAutoAcceptRulesListReceived;
		buddyListMap mBuddyListMap;
		
		deviceList mCaptureDevices;
		deviceList mRenderDevices;

		std::string mCaptureDevice;
		std::string mRenderDevice;
		bool mCaptureDeviceDirty;
		bool mRenderDeviceDirty;
		
		// This should be called when the code detects we have changed parcels.
		// It initiates the call to the server that gets the parcel channel.
		void parcelChanged();
		
	void switchChannel(std::string uri = std::string(), bool spatial = true, bool no_reconnect = false, bool is_p2p = false, std::string hash = "");
		void joinSession(sessionState *session);
		
static 	std::string nameFromAvatar(LLVOAvatar *avatar);
static	std::string nameFromID(const LLUUID &id);
static	bool IDFromName(const std::string name, LLUUID &uuid);
static	std::string displayNameFromAvatar(LLVOAvatar *avatar);
		std::string sipURIFromAvatar(LLVOAvatar *avatar);
		std::string sipURIFromName(std::string &name);
		
		// Returns the name portion of the SIP URI if the string looks vaguely like a SIP URI, or an empty string if not.
static	std::string nameFromsipURI(const std::string &uri);		

		bool inSpatialChannel(void);
		std::string getAudioSessionURI();
		std::string getAudioSessionHandle();
				
		void sendPositionalUpdate(void);
		
		void buildSetCaptureDevice(std::ostringstream &stream);
		void buildSetRenderDevice(std::ostringstream &stream);
		void buildLocalAudioUpdates(std::ostringstream &stream);
		
		void clearAllLists();
		void checkFriend(const LLUUID& id);
		void sendFriendsListUpdates();

		// start a text IM session with the specified user
		// This will be asynchronous, the session may be established at a future time.
		sessionState* startUserIMSession(const LLUUID& uuid);
		void sendQueuedTextMessages(sessionState *session);
		
		void enforceTether(void);
		
		bool		mSpatialCoordsDirty;
		
		LLVector3d	mCameraPosition;
		LLVector3d	mCameraRequestedPosition;
		LLVector3	mCameraVelocity;
		LLMatrix3	mCameraRot;

		LLVector3d	mAvatarPosition;
		LLVector3	mAvatarVelocity;
		LLMatrix3	mAvatarRot;
		
		bool		mPTTDirty;
		bool		mPTT;
		
		bool		mUsePTT;
		bool		mPTTIsMiddleMouse;
		KEY			mPTTKey;
		bool		mPTTIsToggle;
		bool		mUserPTTState;
		bool		mMuteMic;
				
		// Set to true when the friends list is known to have changed.
		bool		mFriendsListDirty;
		
		enum
		{
			earLocCamera = 0,		// ear at camera
			earLocAvatar,			// ear at avatar
			earLocMixed				// ear at avatar location/camera direction
		};
		
		S32			mEarLocation;  
		
		bool		mSpeakerVolumeDirty;
		bool		mSpeakerMuteDirty;
		int			mSpeakerVolume;

		int			mMicVolume;
		bool		mMicVolumeDirty;
		
		bool		mVoiceEnabled;
		bool		mWriteInProgress;
		std::string mWriteString;
		size_t		mWriteOffset;
		
		LLTimer		mUpdateTimer;
		
		BOOL		mLipSyncEnabled;

		typedef std::set<LLVoiceClientParticipantObserver*> observer_set_t;
		observer_set_t mParticipantObservers;

		void notifyParticipantObservers();

		typedef std::set<LLVoiceClientStatusObserver*> status_observer_set_t;
		status_observer_set_t mStatusObservers;
		
		void notifyStatusObservers(LLVoiceClientStatusObserver::EStatusType status);

		typedef std::set<LLFriendObserver*> friend_observer_set_t;
		friend_observer_set_t mFriendObservers;
		void notifyFriendObservers();
};

extern LLVoiceClient *gVoiceClient;

#endif //LL_VOICE_CLIENT_H