开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 游戏引擎 > 查看源码
llvoiceclient.h
资源名称：snowglobe-src-viewer-2.0.0-r0.tar.gz　[点击查看]
上传用户：king477883
上传日期：2021-03-01
资源大小：9553k
文件大小：29k
源码类别：

游戏引擎

开发平台：

C++ Builder

llvoiceclient.h：源码内容
  1. /** 
  2.  * @file llvoiceclient.h
  3.  * @brief Declaration of LLVoiceClient class which is the interface to the voice client process.
  4.  *
  5.  * $LicenseInfo:firstyear=2001&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2001-2010, Linden Research, Inc.
  8.  * 
  9.  * Second Life Viewer Source Code
  10.  * The source code in this file ("Source Code") is provided by Linden Lab
  11.  * to you under the terms of the GNU General Public License, version 2.0
  12.  * ("GPL"), unless you have obtained a separate licensing agreement
  13.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  14.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  15.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  16.  * 
  17.  * There are special exceptions to the terms and conditions of the GPL as
  18.  * it is applied to this Source Code. View the full text of the exception
  19.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  20.  * online at
  21.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  22.  * 
  23.  * By copying, modifying or distributing this software, you acknowledge
  24.  * that you have read and understood your obligations described above,
  25.  * and agree to abide by those obligations.
  26.  * 
  27.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  28.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  29.  * COMPLETENESS OR PERFORMANCE.
  30.  * $/LicenseInfo$
  31.  */
  32. #ifndef LL_VOICE_CLIENT_H
  33. #define LL_VOICE_CLIENT_H
  35. class LLVOAvatar;
  36. class LLVivoxProtocolParser;
  38. #include "lliopipe.h"
  39. #include "llpumpio.h"
  40. #include "llchainio.h"
  41. #include "lliosocket.h"
  42. #include "v3math.h"
  43. #include "llframetimer.h"
  44. #include "llviewerregion.h"
  45. #include "m3math.h" // LLMatrix3
  47. class LLFriendObserver;
  48. class LLVoiceClientParticipantObserver
  49. {
  50. public:
  51. virtual ~LLVoiceClientParticipantObserver() { }
  52. virtual void onChange() = 0;
  53. };
  55. class LLVoiceClientStatusObserver
  56. {
  57. public:
  58. typedef enum e_voice_status_type
  59. {
  60. // NOTE: when updating this enum, please also update the switch in
  61. //  LLVoiceClientStatusObserver::status2string().
  62. STATUS_LOGIN_RETRY,
  63. STATUS_LOGGED_IN,
  64. STATUS_JOINING,
  65. STATUS_JOINED,
  66. STATUS_LEFT_CHANNEL,
  67. STATUS_VOICE_DISABLED,
  69. // Adding STATUS_VOICE_ENABLED as pair status for STATUS_VOICE_DISABLED
  70. // See LLVoiceClient::setVoiceEnabled()
  71. STATUS_VOICE_ENABLED,
  73. BEGIN_ERROR_STATUS,
  74. ERROR_CHANNEL_FULL,
  75. ERROR_CHANNEL_LOCKED,
  76. ERROR_NOT_AVAILABLE,
  77. ERROR_UNKNOWN
  78. } EStatusType;
  80. virtual ~LLVoiceClientStatusObserver() { }
  81. virtual void onChange(EStatusType status, const std::string &channelURI, bool proximal) = 0;
  83. static std::string status2string(EStatusType inStatus);
  84. };
  86. class LLVoiceClient: public LLSingleton<LLVoiceClient>
  87. {
  88. LOG_CLASS(LLVoiceClient);
  89. public:
  90. LLVoiceClient();
  91. ~LLVoiceClient();
  93. public:
  94. static void init(LLPumpIO *pump); // Call this once at application startup (creates connector)
  95. static void terminate(); // Call this to clean up during shutdown
  97. protected:
  98. bool writeString(const std::string &str);
  100. public:
  102. static F32 OVERDRIVEN_POWER_LEVEL;
  104. void updateSettings(); // call after loading settings and whenever they change
  106. void getCaptureDevicesSendMessage();
  107. void getRenderDevicesSendMessage();
  109. void clearCaptureDevices();
  110. void addCaptureDevice(const std::string& name);
  111. void setCaptureDevice(const std::string& name);
  113. void clearRenderDevices();
  114. void addRenderDevice(const std::string& name);
  115. void setRenderDevice(const std::string& name);
  117. void tuningStart();
  118. void tuningStop();
  119. bool inTuningMode();
  120. bool inTuningStates();
  122. void tuningRenderStartSendMessage(const std::string& name, bool loop);
  123. void tuningRenderStopSendMessage();
  125. void tuningCaptureStartSendMessage(int duration);
  126. void tuningCaptureStopSendMessage();
  128. void tuningSetMicVolume(float volume);
  129. void tuningSetSpeakerVolume(float volume);
  130. float tuningGetEnergy(void);
  132. // This returns true when it's safe to bring up the "device settings" dialog in the prefs.
  133. // i.e. when the daemon is running and connected, and the device lists are populated.
  134. bool deviceSettingsAvailable();
  136. // Requery the vivox daemon for the current list of input/output devices.
  137. // If you pass true for clearCurrentList, deviceSettingsAvailable() will be false until the query has completed
  138. // (use this if you want to know when it's done).
  139. // 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.
  140. void refreshDeviceLists(bool clearCurrentList = true);
  142. // Call this if the connection to the daemon terminates unexpectedly.  It will attempt to reset everything and relaunch.
  143. void daemonDied();
  145. // Call this if we're just giving up on voice (can't provision an account, etc.).  It will clean up and go away.
  146. void giveUp();
  148. /////////////////////////////
  149. // Response/Event handlers
  150. void connectorCreateResponse(int statusCode, std::string &statusString, std::string &connectorHandle, std::string &versionID);
  151. void loginResponse(int statusCode, std::string &statusString, std::string &accountHandle, int numberOfAliases);
  152. void sessionCreateResponse(std::string &requestId, int statusCode, std::string &statusString, std::string &sessionHandle);
  153. void sessionGroupAddSessionResponse(std::string &requestId, int statusCode, std::string &statusString, std::string &sessionHandle);
  154. void sessionConnectResponse(std::string &requestId, int statusCode, std::string &statusString);
  155. void logoutResponse(int statusCode, std::string &statusString);
  156. void connectorShutdownResponse(int statusCode, std::string &statusString);
  158. void accountLoginStateChangeEvent(std::string &accountHandle, int statusCode, std::string &statusString, int state);
  159. void mediaStreamUpdatedEvent(std::string &sessionHandle, std::string &sessionGroupHandle, int statusCode, std::string &statusString, int state, bool incoming);
  160. void textStreamUpdatedEvent(std::string &sessionHandle, std::string &sessionGroupHandle, bool enabled, int state, bool incoming);
  161. void sessionAddedEvent(std::string &uriString, std::string &alias, std::string &sessionHandle, std::string &sessionGroupHandle, bool isChannel, bool incoming, std::string &nameString, std::string &applicationString);
  162. void sessionGroupAddedEvent(std::string &sessionGroupHandle);
  163. void sessionRemovedEvent(std::string &sessionHandle, std::string &sessionGroupHandle);
  164. void participantAddedEvent(std::string &sessionHandle, std::string &sessionGroupHandle, std::string &uriString, std::string &alias, std::string &nameString, std::string &displayNameString, int participantType);
  165. void participantRemovedEvent(std::string &sessionHandle, std::string &sessionGroupHandle, std::string &uriString, std::string &alias, std::string &nameString);
  166. void participantUpdatedEvent(std::string &sessionHandle, std::string &sessionGroupHandle, std::string &uriString, std::string &alias, bool isModeratorMuted, bool isSpeaking, int volume, F32 energy);
  167. void auxAudioPropertiesEvent(F32 energy);
  168. void buddyPresenceEvent(std::string &uriString, std::string &alias, std::string &statusString, std::string &applicationString);
  169. void messageEvent(std::string &sessionHandle, std::string &uriString, std::string &alias, std::string &messageHeader, std::string &messageBody, std::string &applicationString);
  170. void sessionNotificationEvent(std::string &sessionHandle, std::string &uriString, std::string &notificationType);
  171. void subscriptionEvent(std::string &buddyURI, std::string &subscriptionHandle, std::string &alias, std::string &displayName, std::string &applicationString, std::string &subscriptionType);
  173. void buddyListChanged();
  174. void muteListChanged();
  175. void updateFriends(U32 mask);
  177. /////////////////////////////
  178. // Sending updates of current state
  179. static void updatePosition(void);
  180. void setCameraPosition(const LLVector3d &position, const LLVector3 &velocity, const LLMatrix3 &rot);
  181. void setAvatarPosition(const LLVector3d &position, const LLVector3 &velocity, const LLMatrix3 &rot);
  182. bool channelFromRegion(LLViewerRegion *region, std::string &name);
  183. void leaveChannel(void); // call this on logout or teleport begin
  186. void setMuteMic(bool muted); // Use this to mute the local mic (for when the client is minimized, etc), ignoring user PTT state.
  187. bool getMuteMic() const;
  188. void setUserPTTState(bool ptt);
  189. bool getUserPTTState();
  190. void toggleUserPTTState(void);
  191. void inputUserControlState(bool down); // interpret any sort of up-down mic-open control input according to ptt-toggle prefs
  192. void setVoiceEnabled(bool enabled);
  193. static bool voiceEnabled();
  194. // Checks is voice working judging from mState
  195. // Returns true if vivox has successfully logged in and is not in error state
  196. bool voiceWorking();
  197. void setUsePTT(bool usePTT);
  198. void setPTTIsToggle(bool PTTIsToggle);
  199. bool getPTTIsToggle();
  200. void setPTTKey(std::string &key);
  201. void setEarLocation(S32 loc);
  202. void setVoiceVolume(F32 volume);
  203. void setMicGain(F32 volume);
  204. void setUserVolume(const LLUUID& id, F32 volume); // sets volume for specified agent, from 0-1 (where .5 is nominal)
  205. void setLipSyncEnabled(BOOL enabled);
  206. BOOL lipSyncEnabled();
  208. // PTT key triggering
  209. void keyDown(KEY key, MASK mask);
  210. void keyUp(KEY key, MASK mask);
  211. void middleMouseState(bool down);
  213. // Return the version of the Vivox library
  214. std::string getAPIVersion() const { return mAPIVersion; }
  216. /////////////////////////////
  217. // Accessors for data related to nearby speakers
  218. BOOL getVoiceEnabled(const LLUUID& id); // true if we've received data for this avatar
  219. BOOL getIsSpeaking(const LLUUID& id);
  220. BOOL getIsModeratorMuted(const LLUUID& id);
  221. F32 getCurrentPower(const LLUUID& id); // "power" is related to "amplitude" in a defined way.  I'm just not sure what the formula is...
  222. BOOL getOnMuteList(const LLUUID& id);
  223. F32 getUserVolume(const LLUUID& id);
  224. std::string getDisplayName(const LLUUID& id);
  226. // MBW -- XXX -- Not sure how to get this data out of the TVC
  227. BOOL getUsingPTT(const LLUUID& id);
  228. std::string getGroupID(const LLUUID& id); // group ID if the user is in group chat (empty string if not applicable)
  230. /////////////////////////////
  231. BOOL getAreaVoiceDisabled(); // returns true if the area the avatar is in is speech-disabled.
  232. // Use this to determine whether to show a "no speech" icon in the menu bar.
  234. /////////////////////////////
  235. // Recording controls
  236. void recordingLoopStart(int seconds = 3600, int deltaFramesPerControlFrame = 200);
  237. void recordingLoopSave(const std::string& filename);
  238. void recordingStop();
  240. // Playback controls
  241. void filePlaybackStart(const std::string& filename);
  242. void filePlaybackStop();
  243. void filePlaybackSetPaused(bool paused);
  244. void filePlaybackSetMode(bool vox = false, float speed = 1.0f);
  247. // This is used by the string-keyed maps below, to avoid storing the string twice.
  248. // The 'const std::string *' in the key points to a string actually stored in the object referenced by the map.
  249. // The add and delete operations for each map allocate and delete in the right order to avoid dangling references.
  250. // The default compare operation would just compare pointers, which is incorrect, so they must use this comparitor instead.
  251. struct stringMapComparitor
  252. {
  253. bool operator()(const std::string* a, const std::string * b) const
  254. {
  255. return a->compare(*b) < 0;
  256. }
  257. };
  259. struct uuidMapComparitor
  260. {
  261. bool operator()(const LLUUID* a, const LLUUID * b) const
  262. {
  263. return *a < *b;
  264. }
  265. };
  267. struct participantState
  268. {
  269. public:
  270. participantState(const std::string &uri);
  272. bool updateMuteState();
  273. bool isAvatar();
  275. std::string mURI;
  276. LLUUID mAvatarID;
  277. std::string mAccountName;
  278. std::string mDisplayName;
  279. LLFrameTimer mSpeakingTimeout;
  280. F32 mLastSpokeTimestamp;
  281. F32 mPower;
  282. int mVolume;
  283. std::string mGroupID;
  284. int mUserVolume;
  285. bool mPTT;
  286. bool mIsSpeaking;
  287. bool mIsModeratorMuted;
  288. bool mOnMuteList; // true if this avatar is on the user's mute list (and should be muted)
  289. bool mVolumeDirty; // true if this participant needs a volume command sent (either mOnMuteList or mUserVolume has changed)
  290. bool mAvatarIDValid;
  291. bool mIsSelf;
  292. };
  293. typedef std::map<const std::string *, participantState*, stringMapComparitor> participantMap;
  295. typedef std::map<const LLUUID *, participantState*, uuidMapComparitor> participantUUIDMap;
  297. enum streamState
  298. {
  299. streamStateUnknown = 0,
  300. streamStateIdle = 1,
  301. streamStateConnected = 2,
  302. streamStateRinging = 3,
  303. };
  305. struct sessionState
  306. {
  307. public:
  308. sessionState();
  309. ~sessionState();
  311. participantState *addParticipant(const std::string &uri);
  312. // Note: after removeParticipant returns, the participant* that was passed to it will have been deleted.
  313. // Take care not to use the pointer again after that.
  314. void removeParticipant(participantState *participant);
  315. void removeAllParticipants();
  317. participantState *findParticipant(const std::string &uri);
  318. participantState *findParticipantByID(const LLUUID& id);
  320. bool isCallBackPossible();
  321. bool isTextIMPossible();
  323. std::string mHandle;
  324. std::string mGroupHandle;
  325. std::string mSIPURI;
  326. std::string mAlias;
  327. std::string mName;
  328. std::string mAlternateSIPURI;
  329. std::string mHash; // Channel password
  330. std::string mErrorStatusString;
  331. std::queue<std::string> mTextMsgQueue;
  333. LLUUID mIMSessionID;
  334. LLUUID mCallerID;
  335. int mErrorStatusCode;
  336. int mMediaStreamState;
  337. int mTextStreamState;
  338. bool mCreateInProgress; // True if a Session.Create has been sent for this session and no response has been received yet.
  339. bool mMediaConnectInProgress; // True if a Session.MediaConnect has been sent for this session and no response has been received yet.
  340. bool mVoiceInvitePending; // True if a voice invite is pending for this session (usually waiting on a name lookup)
  341. bool mTextInvitePending; // True if a text invite is pending for this session (usually waiting on a name lookup)
  342. bool mSynthesizedCallerID; // True if the caller ID is a hash of the SIP URI -- this means we shouldn't do a name lookup.
  343. bool mIsChannel; // True for both group and spatial channels (false for p2p, PSTN)
  344. bool mIsSpatial; // True for spatial channels
  345. bool mIsP2P;
  346. bool mIncoming;
  347. bool mVoiceEnabled;
  348. bool mReconnect; // Whether we should try to reconnect to this session if it's dropped
  349. // Set to true when the mute state of someone in the participant list changes.
  350. // The code will have to walk the list to find the changed participant(s).
  351. bool mVolumeDirty;
  353. bool mParticipantsChanged;
  354. participantMap mParticipantsByURI;
  355. participantUUIDMap mParticipantsByUUID;
  356. };
  358. participantState *findParticipantByID(const LLUUID& id);
  359. participantMap *getParticipantList(void);
  360. void getParticipantsUUIDSet(std::set<LLUUID>& participant_uuids);
  362. typedef std::map<const std::string*, sessionState*, stringMapComparitor> sessionMap;
  363. typedef std::set<sessionState*> sessionSet;
  365. typedef sessionSet::iterator sessionIterator;
  366. sessionIterator sessionsBegin(void);
  367. sessionIterator sessionsEnd(void);
  369. sessionState *findSession(const std::string &handle);
  370. sessionState *findSessionBeingCreatedByURI(const std::string &uri);
  371. sessionState *findSession(const LLUUID &participant_id);
  372. sessionState *findSessionByCreateID(const std::string &create_id);
  374. sessionState *addSession(const std::string &uri, const std::string &handle = LLStringUtil::null);
  375. void setSessionHandle(sessionState *session, const std::string &handle = LLStringUtil::null);
  376. void setSessionURI(sessionState *session, const std::string &uri);
  377. void deleteSession(sessionState *session);
  378. void deleteAllSessions(void);
  380. void verifySessionState(void);
  382. void joinedAudioSession(sessionState *session);
  383. void leftAudioSession(sessionState *session);
  385. // This is called in several places where the session _may_ need to be deleted.
  386. // It contains logic for whether to delete the session or keep it around.
  387. void reapSession(sessionState *session);
  389. // Returns true if the session seems to indicate we've moved to a region on a different voice server
  390. bool sessionNeedsRelog(sessionState *session);
  392. struct buddyListEntry
  393. {
  394. buddyListEntry(const std::string &uri);
  395. std::string mURI;
  396. std::string mDisplayName;
  397. LLUUID mUUID;
  398. bool mOnlineSL;
  399. bool mOnlineSLim;
  400. bool mCanSeeMeOnline;
  401. bool mHasBlockListEntry;
  402. bool mHasAutoAcceptListEntry;
  403. bool mNameResolved;
  404. bool mInSLFriends;
  405. bool mInVivoxBuddies;
  406. bool mNeedsNameUpdate;
  407. };
  409. typedef std::map<const std::string*, buddyListEntry*, stringMapComparitor> buddyListMap;
  411. // This should be called when parsing a buddy list entry sent by SLVoice.
  412. void processBuddyListEntry(const std::string &uri, const std::string &displayName);
  414. buddyListEntry *addBuddy(const std::string &uri);
  415. buddyListEntry *addBuddy(const std::string &uri, const std::string &displayName);
  416. buddyListEntry *findBuddy(const std::string &uri);
  417. buddyListEntry *findBuddy(const LLUUID &id);
  418. buddyListEntry *findBuddyByDisplayName(const std::string &name);
  419. void deleteBuddy(const std::string &uri);
  420. void deleteAllBuddies(void);
  422. void deleteAllBlockRules(void);
  423. void addBlockRule(const std::string &blockMask, const std::string &presenceOnly);
  424. void deleteAllAutoAcceptRules(void);
  425. void addAutoAcceptRule(const std::string &autoAcceptMask, const std::string &autoAddAsBuddy);
  426. void accountListBlockRulesResponse(int statusCode, const std::string &statusString);
  427. void accountListAutoAcceptRulesResponse(int statusCode, const std::string &statusString);
  429. /////////////////////////////
  430. // session control messages
  431. void connectorCreate();
  432. void connectorShutdown();
  434. void requestVoiceAccountProvision(S32 retries = 3);
  435. void userAuthorized(
  436. const std::string& firstName,
  437. const std::string& lastName,
  438. const LLUUID &agentID);
  439. void login(
  440. const std::string& account_name,
  441. const std::string& password,
  442. const std::string& voice_sip_uri_hostname,
  443. const std::string& voice_account_server_uri);
  444. void loginSendMessage();
  445. void logout();
  446. void logoutSendMessage();
  448. void accountListBlockRulesSendMessage();
  449. void accountListAutoAcceptRulesSendMessage();
  451. void sessionGroupCreateSendMessage();
  452. void sessionCreateSendMessage(sessionState *session, bool startAudio = true, bool startText = false);
  453. void sessionGroupAddSessionSendMessage(sessionState *session, bool startAudio = true, bool startText = false);
  454. void sessionMediaConnectSendMessage(sessionState *session); // just joins the audio session
  455. void sessionTextConnectSendMessage(sessionState *session); // just joins the text session
  456. void sessionTerminateSendMessage(sessionState *session);
  457. void sessionGroupTerminateSendMessage(sessionState *session);
  458. void sessionMediaDisconnectSendMessage(sessionState *session);
  459. void sessionTextDisconnectSendMessage(sessionState *session);
  461. // Pokes the state machine to leave the audio session next time around.
  462. void sessionTerminate();
  464. // Pokes the state machine to shut down the connector and restart it.
  465. void requestRelog();
  467. // Does the actual work to get out of the audio session
  468. void leaveAudioSession();
  470. void addObserver(LLVoiceClientParticipantObserver* observer);
  471. void removeObserver(LLVoiceClientParticipantObserver* observer);
  473. void addObserver(LLVoiceClientStatusObserver* observer);
  474. void removeObserver(LLVoiceClientStatusObserver* observer);
  476. void addObserver(LLFriendObserver* observer);
  477. void removeObserver(LLFriendObserver* observer);
  479. void lookupName(const LLUUID &id);
  480. static void onAvatarNameLookup(const LLUUID& id, const std::string& first, const std::string& last, BOOL is_group);
  481. void avatarNameResolved(const LLUUID &id, const std::string &name);
  483. typedef std::vector<std::string> deviceList;
  485. deviceList *getCaptureDevices();
  486. deviceList *getRenderDevices();
  488. void setNonSpatialChannel(
  489. const std::string &uri,
  490. const std::string &credentials);
  491. void setSpatialChannel(
  492. const std::string &uri,
  493. const std::string &credentials);
  494. // start a voice session with the specified user
  495. void callUser(const LLUUID &uuid);
  497. // Send a text message to the specified user, initiating the session if necessary.
  498. bool sendTextMessage(const LLUUID& participant_id, const std::string& message);
  500. // close any existing text IM session with the specified user
  501. void endUserIMSession(const LLUUID &uuid);
  503. bool answerInvite(std::string &sessionHandle);
  504. void declineInvite(std::string &sessionHandle);
  505. void leaveNonSpatialChannel();
  507. // Returns the URI of the current channel, or an empty string if not currently in a channel.
  508. // NOTE that it will return an empty string if it's in the process of joining a channel.
  509. std::string getCurrentChannel();
  511. // returns true iff the user is currently in a proximal (local spatial) channel.
  512. // Note that gestures should only fire if this returns true.
  513. bool inProximalChannel();
  515. std::string sipURIFromID(const LLUUID &id);
  517. // Returns true if the indicated user is online via SIP presence according to SLVoice.
  518. // Note that we only get SIP presence data for other users that are in our vivox buddy list.
  519. bool isOnlineSIP(const LLUUID &id);
  521. // Returns true if the indicated participant is really an SL avatar.
  522. // This should be used to control the state of the "profile" button.
  523. // Currently this will be false only for PSTN callers into group chats, and PSTN p2p calls.
  524. bool isParticipantAvatar(const LLUUID &id);
  526. // Returns true if calling back the session URI after the session has closed is possible.
  527. // Currently this will be false only for PSTN P2P calls.
  528. // NOTE: this will return true if the session can't be found. 
  529. bool isSessionCallBackPossible(const LLUUID &session_id);
  531. // Returns true if the session can accepte text IM's.
  532. // Currently this will be false only for PSTN P2P calls.
  533. // NOTE: this will return true if the session can't be found. 
  534. bool isSessionTextIMPossible(const LLUUID &session_id);
  536. private:
  538. // internal state for a simple state machine.  This is used to deal with the asynchronous nature of some of the messages.
  539. // Note: if you change this list, please make corresponding changes to LLVoiceClient::state2string().
  540. enum state
  541. {
  542. stateDisableCleanup,
  543. stateDisabled, // Voice is turned off.
  544. stateStart, // Class is initialized, socket is created
  545. stateDaemonLaunched, // Daemon has been launched
  546. stateConnecting, // connect() call has been issued
  547. stateConnected, // connection to the daemon has been made, send some initial setup commands.
  548. stateIdle, // socket is connected, ready for messaging
  549. stateMicTuningStart,
  550. stateMicTuningRunning,
  551. stateMicTuningStop,
  552. stateConnectorStart, // connector needs to be started
  553. stateConnectorStarting, // waiting for connector handle
  554. stateConnectorStarted, // connector handle received
  555. stateLoginRetry, // need to retry login (failed due to changing password)
  556. stateLoginRetryWait, // waiting for retry timer
  557. stateNeedsLogin, // send login request
  558. stateLoggingIn, // waiting for account handle
  559. stateLoggedIn, // account handle received
  560. stateCreatingSessionGroup, // Creating the main session group
  561. stateNoChannel, // 
  562. stateJoiningSession, // waiting for session handle
  563. stateSessionJoined, // session handle received
  564. stateRunning, // in session, steady state
  565. stateLeavingSession, // waiting for terminate session response
  566. stateSessionTerminated, // waiting for terminate session response
  568. stateLoggingOut, // waiting for logout response
  569. stateLoggedOut, // logout response received
  570. stateConnectorStopping, // waiting for connector stop
  571. stateConnectorStopped, // connector stop received
  573. // We go to this state if the login fails because the account needs to be provisioned.
  575. // error states.  No way to recover from these yet.
  576. stateConnectorFailed,
  577. stateConnectorFailedWaiting,
  578. stateLoginFailed,
  579. stateLoginFailedWaiting,
  580. stateJoinSessionFailed,
  581. stateJoinSessionFailedWaiting,
  583. stateJail // Go here when all else has failed.  Nothing will be retried, we're done.
  584. };
  586. state mState;
  587. bool mSessionTerminateRequested;
  588. bool mRelogRequested;
  590. void setState(state inState);
  591. state getState(void)  { return mState; };
  592. static std::string state2string(state inState);
  594. void stateMachine();
  595. static void idle(void *user_data);
  597. LLHost mDaemonHost;
  598. LLSocket::ptr_t mSocket;
  599. bool mConnected;
  601. void closeSocket(void);
  603. LLPumpIO *mPump;
  604. friend class LLVivoxProtocolParser;
  606. std::string mAccountName;
  607. std::string mAccountPassword;
  608. std::string mAccountDisplayName;
  609. std::string mAccountFirstName;
  610. std::string mAccountLastName;
  612. bool mTuningMode;
  613. float mTuningEnergy;
  614. std::string mTuningAudioFile;
  615. int mTuningMicVolume;
  616. bool mTuningMicVolumeDirty;
  617. int mTuningSpeakerVolume;
  618. bool mTuningSpeakerVolumeDirty;
  619. state mTuningExitState; // state to return to when we leave tuning mode.
  621. std::string mSpatialSessionURI;
  622. std::string mSpatialSessionCredentials;
  624. std::string mMainSessionGroupHandle; // handle of the "main" session group.
  626. std::string mChannelName; // Name of the channel to be looked up 
  627. bool mAreaVoiceDisabled;
  628. sessionState *mAudioSession; // Session state for the current audio session
  629. bool mAudioSessionChanged; // set to true when the above pointer gets changed, so observers can be notified.
  631. sessionState *mNextAudioSession; // Session state for the audio session we're trying to join
  633. // std::string mSessionURI; // URI of the session we're in.
  634. // std::string mSessionHandle; // returned by ?
  636. S32 mCurrentParcelLocalID; // Used to detect parcel boundary crossings
  637. std::string mCurrentRegionName; // Used to detect parcel boundary crossings
  639. std::string mConnectorHandle; // returned by "Create Connector" message
  640. std::string mAccountHandle; // returned by login message
  641. int  mNumberOfAliases;
  642. U32 mCommandCookie;
  644. std::string mVoiceAccountServerURI;
  645. std::string mVoiceSIPURIHostName;
  647. int mLoginRetryCount;
  649. sessionMap mSessionsByHandle; // Active sessions, indexed by session handle.  Sessions which are being initiated may not be in this map.
  650. sessionSet mSessions; // All sessions, not indexed.  This is the canonical session list.
  652. bool mBuddyListMapPopulated;
  653. bool mBlockRulesListReceived;
  654. bool mAutoAcceptRulesListReceived;
  655. buddyListMap mBuddyListMap;
  657. deviceList mCaptureDevices;
  658. deviceList mRenderDevices;
  660. std::string mCaptureDevice;
  661. std::string mRenderDevice;
  662. bool mCaptureDeviceDirty;
  663. bool mRenderDeviceDirty;
  665. // This should be called when the code detects we have changed parcels.
  666. // It initiates the call to the server that gets the parcel channel.
  667. void parcelChanged();
  669. void switchChannel(std::string uri = std::string(), bool spatial = true, bool no_reconnect = false, bool is_p2p = false, std::string hash = "");
  670. void joinSession(sessionState *session);
  672. static  std::string nameFromAvatar(LLVOAvatar *avatar);
  673. static std::string nameFromID(const LLUUID &id);
  674. static bool IDFromName(const std::string name, LLUUID &uuid);
  675. static std::string displayNameFromAvatar(LLVOAvatar *avatar);
  676. std::string sipURIFromAvatar(LLVOAvatar *avatar);
  677. std::string sipURIFromName(std::string &name);
  679. // Returns the name portion of the SIP URI if the string looks vaguely like a SIP URI, or an empty string if not.
  680. static std::string nameFromsipURI(const std::string &uri);
  682. bool inSpatialChannel(void);
  683. std::string getAudioSessionURI();
  684. std::string getAudioSessionHandle();
  686. void sendPositionalUpdate(void);
  688. void buildSetCaptureDevice(std::ostringstream &stream);
  689. void buildSetRenderDevice(std::ostringstream &stream);
  690. void buildLocalAudioUpdates(std::ostringstream &stream);
  692. void clearAllLists();
  693. void checkFriend(const LLUUID& id);
  694. void sendFriendsListUpdates();
  696. // start a text IM session with the specified user
  697. // This will be asynchronous, the session may be established at a future time.
  698. sessionState* startUserIMSession(const LLUUID& uuid);
  699. void sendQueuedTextMessages(sessionState *session);
  701. void enforceTether(void);
  703. bool mSpatialCoordsDirty;
  705. LLVector3d mCameraPosition;
  706. LLVector3d mCameraRequestedPosition;
  707. LLVector3 mCameraVelocity;
  708. LLMatrix3 mCameraRot;
  710. LLVector3d mAvatarPosition;
  711. LLVector3 mAvatarVelocity;
  712. LLMatrix3 mAvatarRot;
  714. bool mPTTDirty;
  715. bool mPTT;
  717. bool mUsePTT;
  718. bool mPTTIsMiddleMouse;
  719. KEY mPTTKey;
  720. bool mPTTIsToggle;
  721. bool mUserPTTState;
  722. bool mMuteMic;
  724. // Set to true when the friends list is known to have changed.
  725. bool mFriendsListDirty;
  727. enum
  728. {
  729. earLocCamera = 0, // ear at camera
  730. earLocAvatar, // ear at avatar
  731. earLocMixed // ear at avatar location/camera direction
  732. };
  734. S32 mEarLocation;  
  736. bool mSpeakerVolumeDirty;
  737. bool mSpeakerMuteDirty;
  738. int mSpeakerVolume;
  740. int mMicVolume;
  741. bool mMicVolumeDirty;
  743. bool mVoiceEnabled;
  744. bool mWriteInProgress;
  745. std::string mWriteString;
  747. LLTimer mUpdateTimer;
  749. BOOL mLipSyncEnabled;
  751. std::string mAPIVersion;
  753. typedef std::set<LLVoiceClientParticipantObserver*> observer_set_t;
  754. observer_set_t mParticipantObservers;
  756. void notifyParticipantObservers();
  758. typedef std::set<LLVoiceClientStatusObserver*> status_observer_set_t;
  759. status_observer_set_t mStatusObservers;
  761. void notifyStatusObservers(LLVoiceClientStatusObserver::EStatusType status);
  763. typedef std::set<LLFriendObserver*> friend_observer_set_t;
  764. friend_observer_set_t mFriendObservers;
  765. void notifyFriendObservers();
  766. };
  768. extern LLVoiceClient *gVoiceClient;
  770. #endif //LL_VOICE_CLIENT_H