游戏引擎

开发平台：

C++ Builder

llvoiceclient.cpp：源码内容

/**
* @file llvoiceclient.cpp
* @brief Implementation of LLVoiceClient class which is the interface to the voice client process.
*
* $LicenseInfo:firstyear=2001&license=viewergpl$
*
*
* 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$
*/
#include "llviewerprecompiledheaders.h"
#include "llvoiceclient.h"
#include <boost/tokenizer.hpp>
// library includes
#include "llnotificationsutil.h"
#include "llsdserialize.h"
#include "llsdutil.h"
// project includes
#include "llvoavatar.h"
#include "llbufferstream.h"
#include "llfile.h"
#ifdef LL_STANDALONE
# include "expat.h"
#else
# include "expat/expat.h"
#endif
#include "llcallbacklist.h"
#include "llcallingcard.h" // for LLFriendObserver
#include "llviewerregion.h"
#include "llviewernetwork.h" // for gGridChoice
#include "llbase64.h"
#include "llviewercontrol.h"
#include "llkeyboard.h"
#include "llappviewer.h" // for gDisconnected, gDisableVoice
#include "llmutelist.h" // to check for muted avatars
#include "llagent.h"
#include "llcachename.h"
#include "llimview.h" // for LLIMMgr
#include "llparcel.h"
#include "llviewerparcelmgr.h"
//#include "llfirstuse.h"
#include "llspeakers.h"
#include "lltrans.h"
#include "llviewerwindow.h"
#include "llviewercamera.h"
#include "llvoavatarself.h"
#include "llvoicechannel.h"
// for base64 decoding
#include "apr_base64.h"
// for SHA1 hash
#include "apr_sha1.h"
// for MD5 hash
#include "llmd5.h"
#define USE_SESSION_GROUPS 0
static bool sConnectingToAgni = false;
F32 LLVoiceClient::OVERDRIVEN_POWER_LEVEL = 0.7f;
const F32 SPEAKING_TIMEOUT = 1.f;
const int VOICE_MAJOR_VERSION = 1;
const int VOICE_MINOR_VERSION = 0;
LLVoiceClient *gVoiceClient = NULL;
// Don't retry connecting to the daemon more frequently than this:
const F32 CONNECT_THROTTLE_SECONDS = 1.0f;
// Don't send positional updates more frequently than this:
const F32 UPDATE_THROTTLE_SECONDS = 0.1f;
const F32 LOGIN_RETRY_SECONDS = 10.0f;
const int MAX_LOGIN_RETRIES = 12;
static void setUUIDFromStringHash(LLUUID &uuid, const std::string &str)
{
LLMD5 md5_uuid;
md5_uuid.update((const unsigned char*)str.data(), str.size());
md5_uuid.finalize();
md5_uuid.raw_digest(uuid.mData);
}
static int scale_mic_volume(float volume)
{
// incoming volume has the range [0.0 ... 2.0], with 1.0 as the default.
// Map it to Vivox levels as follows: 0.0 -> 30, 1.0 -> 50, 2.0 -> 70
return 30 + (int)(volume * 20.0f);
}
static int scale_speaker_volume(float volume)
{
// incoming volume has the range [0.0 ... 1.0], with 0.5 as the default.
// Map it to Vivox levels as follows: 0.0 -> 30, 0.5 -> 50, 1.0 -> 70
return 30 + (int)(volume * 40.0f);
}
class LLViewerVoiceAccountProvisionResponder :
public LLHTTPClient::Responder
{
public:
LLViewerVoiceAccountProvisionResponder(int retries)
{
mRetries = retries;
}
virtual void error(U32 status, const std::string& reason)
{
if ( mRetries > 0 )
{
LL_WARNS("Voice") << "ProvisionVoiceAccountRequest returned an error, retrying. status = " << status << ", reason = "" << reason << """ << LL_ENDL;
if ( gVoiceClient ) gVoiceClient->requestVoiceAccountProvision(
mRetries - 1);
}
else
{
LL_WARNS("Voice") << "ProvisionVoiceAccountRequest returned an error, too many retries (giving up). status = " << status << ", reason = "" << reason << """ << LL_ENDL;
if ( gVoiceClient ) gVoiceClient->giveUp();
}
}
virtual void result(const LLSD& content)
{
if ( gVoiceClient )
{
std::string voice_sip_uri_hostname;
std::string voice_account_server_uri;
LL_DEBUGS("Voice") << "ProvisionVoiceAccountRequest response:" << ll_pretty_print_sd(content) << LL_ENDL;
if(content.has("voice_sip_uri_hostname"))
voice_sip_uri_hostname = content["voice_sip_uri_hostname"].asString();
// this key is actually misnamed -- it will be an entire URI, not just a hostname.
if(content.has("voice_account_server_name"))
voice_account_server_uri = content["voice_account_server_name"].asString();
gVoiceClient->login(
content["username"].asString(),
content["password"].asString(),
voice_sip_uri_hostname,
voice_account_server_uri);
}
}
private:
int mRetries;
};
/**
* @class LLVivoxProtocolParser
* @brief This class helps construct new LLIOPipe specializations
* @see LLIOPipe
*
* THOROUGH_DESCRIPTION
*/
class LLVivoxProtocolParser : public LLIOPipe
{
LOG_CLASS(LLVivoxProtocolParser);
public:
LLVivoxProtocolParser();
virtual ~LLVivoxProtocolParser();
protected:
/* @name LLIOPipe virtual implementations
*/
//@{
/**
* @brief Process the data in buffer
*/
virtual EStatus process_impl(
const LLChannelDescriptors& channels,
buffer_ptr_t& buffer,
bool& eos,
LLSD& context,
LLPumpIO* pump);
//@}
std::string mInput;
// Expat control members
XML_Parser parser;
int responseDepth;
bool ignoringTags;
bool isEvent;
int ignoreDepth;
// Members for processing responses. The values are transient and only valid within a call to processResponse().
bool squelchDebugOutput;
int returnCode;
int statusCode;
std::string statusString;
std::string requestId;
std::string actionString;
std::string connectorHandle;
std::string versionID;
std::string accountHandle;
std::string sessionHandle;
std::string sessionGroupHandle;
std::string alias;
std::string applicationString;
// Members for processing events. The values are transient and only valid within a call to processResponse().
std::string eventTypeString;
int state;
std::string uriString;
bool isChannel;
bool incoming;
bool enabled;
std::string nameString;
std::string audioMediaString;
std::string displayNameString;
std::string deviceString;
int participantType;
bool isLocallyMuted;
bool isModeratorMuted;
bool isSpeaking;
int volume;
F32 energy;
std::string messageHeader;
std::string messageBody;
std::string notificationType;
bool hasText;
bool hasAudio;
bool hasVideo;
bool terminated;
std::string blockMask;
std::string presenceOnly;
std::string autoAcceptMask;
std::string autoAddAsBuddy;
int numberOfAliases;
std::string subscriptionHandle;
std::string subscriptionType;
// Members for processing text between tags
std::string textBuffer;
bool accumulateText;
void reset();
void processResponse(std::string tag);
static void XMLCALL ExpatStartTag(void *data, const char *el, const char **attr);
static void XMLCALL ExpatEndTag(void *data, const char *el);
static void XMLCALL ExpatCharHandler(void *data, const XML_Char *s, int len);
void StartTag(const char *tag, const char **attr);
void EndTag(const char *tag);
void CharData(const char *buffer, int length);
};
LLVivoxProtocolParser::LLVivoxProtocolParser()
{
parser = NULL;
parser = XML_ParserCreate(NULL);
reset();
}
void LLVivoxProtocolParser::reset()
{
responseDepth = 0;
ignoringTags = false;
accumulateText = false;
energy = 0.f;
hasText = false;
hasAudio = false;
hasVideo = false;
terminated = false;
ignoreDepth = 0;
isChannel = false;
incoming = false;
enabled = false;
isEvent = false;
isLocallyMuted = false;
isModeratorMuted = false;
isSpeaking = false;
participantType = 0;
squelchDebugOutput = false;
returnCode = -1;
state = 0;
statusCode = 0;
volume = 0;
textBuffer.clear();
alias.clear();
numberOfAliases = 0;
applicationString.clear();
}
//virtual
LLVivoxProtocolParser::~LLVivoxProtocolParser()
{
if (parser)
XML_ParserFree(parser);
}
// virtual
LLIOPipe::EStatus LLVivoxProtocolParser::process_impl(
const LLChannelDescriptors& channels,
buffer_ptr_t& buffer,
bool& eos,
LLSD& context,
LLPumpIO* pump)
{
LLBufferStream istr(channels, buffer.get());
std::ostringstream ostr;
while (istr.good())
{
char buf[1024];
istr.read(buf, sizeof(buf));
mInput.append(buf, istr.gcount());
}
// Look for input delimiter(s) in the input buffer. If one is found, send the message to the xml parser.
int start = 0;
int delim;
while((delim = mInput.find("nnn", start)) != std::string::npos)
{
// Reset internal state of the LLVivoxProtocolParser (no effect on the expat parser)
reset();
XML_ParserReset(parser, NULL);
XML_SetElementHandler(parser, ExpatStartTag, ExpatEndTag);
XML_SetCharacterDataHandler(parser, ExpatCharHandler);
XML_SetUserData(parser, this);
XML_Parse(parser, mInput.data() + start, delim - start, false);
// If this message isn't set to be squelched, output the raw XML received.
if(!squelchDebugOutput)
{
LL_DEBUGS("Voice") << "parsing: " << mInput.substr(start, delim - start) << LL_ENDL;
}
start = delim + 3;
}
if(start != 0)
mInput = mInput.substr(start);
LL_DEBUGS("VivoxProtocolParser") << "at end, mInput is: " << mInput << LL_ENDL;
if(!gVoiceClient->mConnected)
{
// If voice has been disabled, we just want to close the socket. This does so.
LL_INFOS("Voice") << "returning STATUS_STOP" << LL_ENDL;
return STATUS_STOP;
}
return STATUS_OK;
}
void XMLCALL LLVivoxProtocolParser::ExpatStartTag(void *data, const char *el, const char **attr)
{
if (data)
{
LLVivoxProtocolParser *object = (LLVivoxProtocolParser*)data;
object->StartTag(el, attr);
}
}
// --------------------------------------------------------------------------------
void XMLCALL LLVivoxProtocolParser::ExpatEndTag(void *data, const char *el)
{
if (data)
{
LLVivoxProtocolParser *object = (LLVivoxProtocolParser*)data;
object->EndTag(el);
}
}
// --------------------------------------------------------------------------------
void XMLCALL LLVivoxProtocolParser::ExpatCharHandler(void *data, const XML_Char *s, int len)
{
if (data)
{
LLVivoxProtocolParser *object = (LLVivoxProtocolParser*)data;
object->CharData(s, len);
}
}
// --------------------------------------------------------------------------------
void LLVivoxProtocolParser::StartTag(const char *tag, const char **attr)
{
// Reset the text accumulator. We shouldn't have strings that are inturrupted by new tags
textBuffer.clear();
// only accumulate text if we're not ignoring tags.
accumulateText = !ignoringTags;
if (responseDepth == 0)
{
isEvent = !stricmp("Event", tag);
if (!stricmp("Response", tag) || isEvent)
{
// Grab the attributes
while (*attr)
{
const char *key = *attr++;
const char *value = *attr++;
if (!stricmp("requestId", key))
{
requestId = value;
}
else if (!stricmp("action", key))
{
actionString = value;
}
else if (!stricmp("type", key))
{
eventTypeString = value;
}
}
}
LL_DEBUGS("VivoxProtocolParser") << tag << " (" << responseDepth << ")" << LL_ENDL;
}
else
{
if (ignoringTags)
{
LL_DEBUGS("VivoxProtocolParser") << "ignoring tag " << tag << " (depth = " << responseDepth << ")" << LL_ENDL;
}
else
{
LL_DEBUGS("VivoxProtocolParser") << tag << " (" << responseDepth << ")" << LL_ENDL;
// Ignore the InputXml stuff so we don't get confused
if (!stricmp("InputXml", tag))
{
ignoringTags = true;
ignoreDepth = responseDepth;
accumulateText = false;
LL_DEBUGS("VivoxProtocolParser") << "starting ignore, ignoreDepth is " << ignoreDepth << LL_ENDL;
}
else if (!stricmp("CaptureDevices", tag))
{
gVoiceClient->clearCaptureDevices();
}
else if (!stricmp("RenderDevices", tag))
{
gVoiceClient->clearRenderDevices();
}
else if (!stricmp("CaptureDevice", tag))
{
deviceString.clear();
}
else if (!stricmp("RenderDevice", tag))
{
deviceString.clear();
}
else if (!stricmp("Buddies", tag))
{
gVoiceClient->deleteAllBuddies();
}
else if (!stricmp("BlockRules", tag))
{
gVoiceClient->deleteAllBlockRules();
}
else if (!stricmp("AutoAcceptRules", tag))
{
gVoiceClient->deleteAllAutoAcceptRules();
}
}
}
responseDepth++;
}
// --------------------------------------------------------------------------------
void LLVivoxProtocolParser::EndTag(const char *tag)
{
const std::string& string = textBuffer;
responseDepth--;
if (ignoringTags)
{
if (ignoreDepth == responseDepth)
{
LL_DEBUGS("VivoxProtocolParser") << "end of ignore" << LL_ENDL;
ignoringTags = false;
}
else
{
LL_DEBUGS("VivoxProtocolParser") << "ignoring tag " << tag << " (depth = " << responseDepth << ")" << LL_ENDL;
}
}
if (!ignoringTags)
{
LL_DEBUGS("VivoxProtocolParser") << "processing tag " << tag << " (depth = " << responseDepth << ")" << LL_ENDL;
// Closing a tag. Finalize the text we've accumulated and reset
if (!stricmp("ReturnCode", tag))
returnCode = strtol(string.c_str(), NULL, 10);
else if (!stricmp("SessionHandle", tag))
sessionHandle = string;
else if (!stricmp("SessionGroupHandle", tag))
sessionGroupHandle = string;
else if (!stricmp("StatusCode", tag))
statusCode = strtol(string.c_str(), NULL, 10);
else if (!stricmp("StatusString", tag))
statusString = string;
else if (!stricmp("ParticipantURI", tag))
uriString = string;
else if (!stricmp("Volume", tag))
volume = strtol(string.c_str(), NULL, 10);
else if (!stricmp("Energy", tag))
energy = (F32)strtod(string.c_str(), NULL);
else if (!stricmp("IsModeratorMuted", tag))
isModeratorMuted = !stricmp(string.c_str(), "true");
else if (!stricmp("IsSpeaking", tag))
isSpeaking = !stricmp(string.c_str(), "true");
else if (!stricmp("Alias", tag))
alias = string;
else if (!stricmp("NumberOfAliases", tag))
numberOfAliases = strtol(string.c_str(), NULL, 10);
else if (!stricmp("Application", tag))
applicationString = string;
else if (!stricmp("ConnectorHandle", tag))
connectorHandle = string;
else if (!stricmp("VersionID", tag))
versionID = string;
else if (!stricmp("AccountHandle", tag))
accountHandle = string;
else if (!stricmp("State", tag))
state = strtol(string.c_str(), NULL, 10);
else if (!stricmp("URI", tag))
uriString = string;
else if (!stricmp("IsChannel", tag))
isChannel = !stricmp(string.c_str(), "true");
else if (!stricmp("Incoming", tag))
incoming = !stricmp(string.c_str(), "true");
else if (!stricmp("Enabled", tag))
enabled = !stricmp(string.c_str(), "true");
else if (!stricmp("Name", tag))
nameString = string;
else if (!stricmp("AudioMedia", tag))
audioMediaString = string;
else if (!stricmp("ChannelName", tag))
nameString = string;
else if (!stricmp("DisplayName", tag))
displayNameString = string;
else if (!stricmp("Device", tag))
deviceString = string;
else if (!stricmp("AccountName", tag))
nameString = string;
else if (!stricmp("ParticipantType", tag))
participantType = strtol(string.c_str(), NULL, 10);
else if (!stricmp("IsLocallyMuted", tag))
isLocallyMuted = !stricmp(string.c_str(), "true");
else if (!stricmp("MicEnergy", tag))
energy = (F32)strtod(string.c_str(), NULL);
else if (!stricmp("ChannelName", tag))
nameString = string;
else if (!stricmp("ChannelURI", tag))
uriString = string;
else if (!stricmp("BuddyURI", tag))
uriString = string;
else if (!stricmp("Presence", tag))
statusString = string;
else if (!stricmp("CaptureDevice", tag))
{
gVoiceClient->addCaptureDevice(deviceString);
}
else if (!stricmp("RenderDevice", tag))
{
gVoiceClient->addRenderDevice(deviceString);
}
else if (!stricmp("Buddy", tag))
{
gVoiceClient->processBuddyListEntry(uriString, displayNameString);
}
else if (!stricmp("BlockRule", tag))
{
gVoiceClient->addBlockRule(blockMask, presenceOnly);
}
else if (!stricmp("BlockMask", tag))
blockMask = string;
else if (!stricmp("PresenceOnly", tag))
presenceOnly = string;
else if (!stricmp("AutoAcceptRule", tag))
{
gVoiceClient->addAutoAcceptRule(autoAcceptMask, autoAddAsBuddy);
}
else if (!stricmp("AutoAcceptMask", tag))
autoAcceptMask = string;
else if (!stricmp("AutoAddAsBuddy", tag))
autoAddAsBuddy = string;
else if (!stricmp("MessageHeader", tag))
messageHeader = string;
else if (!stricmp("MessageBody", tag))
messageBody = string;
else if (!stricmp("NotificationType", tag))
notificationType = string;
else if (!stricmp("HasText", tag))
hasText = !stricmp(string.c_str(), "true");
else if (!stricmp("HasAudio", tag))
hasAudio = !stricmp(string.c_str(), "true");
else if (!stricmp("HasVideo", tag))
hasVideo = !stricmp(string.c_str(), "true");
else if (!stricmp("Terminated", tag))
terminated = !stricmp(string.c_str(), "true");
else if (!stricmp("SubscriptionHandle", tag))
subscriptionHandle = string;
else if (!stricmp("SubscriptionType", tag))
subscriptionType = string;
textBuffer.clear();
accumulateText= false;
if (responseDepth == 0)
{
// We finished all of the XML, process the data
processResponse(tag);
}
}
}
// --------------------------------------------------------------------------------
void LLVivoxProtocolParser::CharData(const char *buffer, int length)
{
/*
This method is called for anything that isn't a tag, which can be text you
want that lies between tags, and a lot of stuff you don't want like file formatting
(tabs, spaces, CR/LF, etc).
Only copy text if we are in accumulate mode...
*/
if (accumulateText)
textBuffer.append(buffer, length);
}
// --------------------------------------------------------------------------------
void LLVivoxProtocolParser::processResponse(std::string tag)
{
LL_DEBUGS("VivoxProtocolParser") << tag << LL_ENDL;
// SLIM SDK: the SDK now returns a statusCode of "200" (OK) for success. This is a change vs. previous SDKs.
// According to Mike S., "The actual API convention is that responses with return codes of 0 are successful, regardless of the status code returned",
// so I believe this will give correct behavior.
if(returnCode == 0)
statusCode = 0;
if (isEvent)
{
const char *eventTypeCstr = eventTypeString.c_str();
if (!stricmp(eventTypeCstr, "AccountLoginStateChangeEvent"))
{
gVoiceClient->accountLoginStateChangeEvent(accountHandle, statusCode, statusString, state);
}
else if (!stricmp(eventTypeCstr, "SessionAddedEvent"))
{
/*
<Event type="SessionAddedEvent">
<SessionGroupHandle>c1_m1000xFnPP04IpREWNkuw1cOXlhw==_sg0</SessionGroupHandle>
<SessionHandle>c1_m1000xFnPP04IpREWNkuw1cOXlhw==0</SessionHandle>
<Uri>sip:confctl-1408789@bhr.vivox.com</Uri>
<IsChannel>true</IsChannel>
<Incoming>false</Incoming>
<ChannelName />
</Event>
*/
gVoiceClient->sessionAddedEvent(uriString, alias, sessionHandle, sessionGroupHandle, isChannel, incoming, nameString, applicationString);
}
else if (!stricmp(eventTypeCstr, "SessionRemovedEvent"))
{
gVoiceClient->sessionRemovedEvent(sessionHandle, sessionGroupHandle);
}
else if (!stricmp(eventTypeCstr, "SessionGroupAddedEvent"))
{
gVoiceClient->sessionGroupAddedEvent(sessionGroupHandle);
}
else if (!stricmp(eventTypeCstr, "MediaStreamUpdatedEvent"))
{
/*
<Event type="MediaStreamUpdatedEvent">
<SessionGroupHandle>c1_m1000xFnPP04IpREWNkuw1cOXlhw==_sg0</SessionGroupHandle>
<SessionHandle>c1_m1000xFnPP04IpREWNkuw1cOXlhw==0</SessionHandle>
<StatusCode>200</StatusCode>
<StatusString>OK</StatusString>
<State>2</State>
<Incoming>false</Incoming>
</Event>
*/
gVoiceClient->mediaStreamUpdatedEvent(sessionHandle, sessionGroupHandle, statusCode, statusString, state, incoming);
}
else if (!stricmp(eventTypeCstr, "TextStreamUpdatedEvent"))
{
/*
<Event type="TextStreamUpdatedEvent">
<SessionGroupHandle>c1_m1000xFnPP04IpREWNkuw1cOXlhw==_sg1</SessionGroupHandle>
<SessionHandle>c1_m1000xFnPP04IpREWNkuw1cOXlhw==1</SessionHandle>
<Enabled>true</Enabled>
<State>1</State>
<Incoming>true</Incoming>
</Event>
*/
gVoiceClient->textStreamUpdatedEvent(sessionHandle, sessionGroupHandle, enabled, state, incoming);
}
else if (!stricmp(eventTypeCstr, "ParticipantAddedEvent"))
{
/*
<Event type="ParticipantAddedEvent">
<SessionGroupHandle>c1_m1000xFnPP04IpREWNkuw1cOXlhw==_sg4</SessionGroupHandle>
<SessionHandle>c1_m1000xFnPP04IpREWNkuw1cOXlhw==4</SessionHandle>
<ParticipantUri>sip:xI5auBZ60SJWIk606-1JGRQ==@bhr.vivox.com</ParticipantUri>
<AccountName>xI5auBZ60SJWIk606-1JGRQ==</AccountName>
<DisplayName />
<ParticipantType>0</ParticipantType>
</Event>
*/
gVoiceClient->participantAddedEvent(sessionHandle, sessionGroupHandle, uriString, alias, nameString, displayNameString, participantType);
}
else if (!stricmp(eventTypeCstr, "ParticipantRemovedEvent"))
{
/*
<Event type="ParticipantRemovedEvent">
<SessionGroupHandle>c1_m1000xFnPP04IpREWNkuw1cOXlhw==_sg4</SessionGroupHandle>
<SessionHandle>c1_m1000xFnPP04IpREWNkuw1cOXlhw==4</SessionHandle>
<ParticipantUri>sip:xtx7YNV-3SGiG7rA1fo5Ndw==@bhr.vivox.com</ParticipantUri>
<AccountName>xtx7YNV-3SGiG7rA1fo5Ndw==</AccountName>
</Event>
*/
gVoiceClient->participantRemovedEvent(sessionHandle, sessionGroupHandle, uriString, alias, nameString);
}
else if (!stricmp(eventTypeCstr, "ParticipantUpdatedEvent"))
{
/*
<Event type="ParticipantUpdatedEvent">
<SessionGroupHandle>c1_m1000xFnPP04IpREWNkuw1cOXlhw==_sg0</SessionGroupHandle>
<SessionHandle>c1_m1000xFnPP04IpREWNkuw1cOXlhw==0</SessionHandle>
<ParticipantUri>sip:xFnPP04IpREWNkuw1cOXlhw==@bhr.vivox.com</ParticipantUri>
<IsModeratorMuted>false</IsModeratorMuted>
<IsSpeaking>true</IsSpeaking>
<Volume>44</Volume>
<Energy>0.0879437</Energy>
</Event>
*/
// These happen so often that logging them is pretty useless.
squelchDebugOutput = true;
gVoiceClient->participantUpdatedEvent(sessionHandle, sessionGroupHandle, uriString, alias, isModeratorMuted, isSpeaking, volume, energy);
}
else if (!stricmp(eventTypeCstr, "AuxAudioPropertiesEvent"))
{
gVoiceClient->auxAudioPropertiesEvent(energy);
}
else if (!stricmp(eventTypeCstr, "BuddyPresenceEvent"))
{
gVoiceClient->buddyPresenceEvent(uriString, alias, statusString, applicationString);
}
else if (!stricmp(eventTypeCstr, "BuddyAndGroupListChangedEvent"))
{
// The buddy list was updated during parsing.
// Need to recheck against the friends list.
gVoiceClient->buddyListChanged();
}
else if (!stricmp(eventTypeCstr, "BuddyChangedEvent"))
{
/*
<Event type="BuddyChangedEvent">
<AccountHandle>c1_m1000xFnPP04IpREWNkuw1cOXlhw==</AccountHandle>
<BuddyURI>sip:x9fFHFZjOTN6OESF1DUPrZQ==@bhr.vivox.com</BuddyURI>
<DisplayName>Monroe Tester</DisplayName>
<BuddyData />
<GroupID>0</GroupID>
<ChangeType>Set</ChangeType>
</Event>
*/
// TODO: Question: Do we need to process this at all?
}
else if (!stricmp(eventTypeCstr, "MessageEvent"))
{
gVoiceClient->messageEvent(sessionHandle, uriString, alias, messageHeader, messageBody, applicationString);
}
else if (!stricmp(eventTypeCstr, "SessionNotificationEvent"))
{
gVoiceClient->sessionNotificationEvent(sessionHandle, uriString, notificationType);
}
else if (!stricmp(eventTypeCstr, "SubscriptionEvent"))
{
gVoiceClient->subscriptionEvent(uriString, subscriptionHandle, alias, displayNameString, applicationString, subscriptionType);
}
else if (!stricmp(eventTypeCstr, "SessionUpdatedEvent"))
{
/*
<Event type="SessionUpdatedEvent">
<SessionGroupHandle>c1_m1000xFnPP04IpREWNkuw1cOXlhw==_sg0</SessionGroupHandle>
<SessionHandle>c1_m1000xFnPP04IpREWNkuw1cOXlhw==0</SessionHandle>
<Uri>sip:confctl-9@bhd.vivox.com</Uri>
<IsMuted>0</IsMuted>
<Volume>50</Volume>
<TransmitEnabled>1</TransmitEnabled>
<IsFocused>0</IsFocused>
<SpeakerPosition><Position><X>0</X><Y>0</Y><Z>0</Z></Position></SpeakerPosition>
<SessionFontID>0</SessionFontID>
</Event>
*/
// We don't need to process this, but we also shouldn't warn on it, since that confuses people.
}
else if (!stricmp(eventTypeCstr, "SessionGroupRemovedEvent"))
{
/*
<Event type="SessionGroupRemovedEvent">
<SessionGroupHandle>c1_m1000xFnPP04IpREWNkuw1cOXlhw==_sg0</SessionGroupHandle>
</Event>
*/
// We don't need to process this, but we also shouldn't warn on it, since that confuses people.
}
else
{
LL_WARNS("VivoxProtocolParser") << "Unknown event type " << eventTypeString << LL_ENDL;
}
}
else
{
const char *actionCstr = actionString.c_str();
if (!stricmp(actionCstr, "Connector.Create.1"))
{
gVoiceClient->connectorCreateResponse(statusCode, statusString, connectorHandle, versionID);
}
else if (!stricmp(actionCstr, "Account.Login.1"))
{
gVoiceClient->loginResponse(statusCode, statusString, accountHandle, numberOfAliases);
}
else if (!stricmp(actionCstr, "Session.Create.1"))
{
gVoiceClient->sessionCreateResponse(requestId, statusCode, statusString, sessionHandle);
}
else if (!stricmp(actionCstr, "SessionGroup.AddSession.1"))
{
gVoiceClient->sessionGroupAddSessionResponse(requestId, statusCode, statusString, sessionHandle);
}
else if (!stricmp(actionCstr, "Session.Connect.1"))
{
gVoiceClient->sessionConnectResponse(requestId, statusCode, statusString);
}
else if (!stricmp(actionCstr, "Account.Logout.1"))
{
gVoiceClient->logoutResponse(statusCode, statusString);
}
else if (!stricmp(actionCstr, "Connector.InitiateShutdown.1"))
{
gVoiceClient->connectorShutdownResponse(statusCode, statusString);
}
else if (!stricmp(actionCstr, "Account.ListBlockRules.1"))
{
gVoiceClient->accountListBlockRulesResponse(statusCode, statusString);
}
else if (!stricmp(actionCstr, "Account.ListAutoAcceptRules.1"))
{
gVoiceClient->accountListAutoAcceptRulesResponse(statusCode, statusString);
}
else if (!stricmp(actionCstr, "Session.Set3DPosition.1"))
{
// We don't need to process these, but they're so spammy we don't want to log them.
squelchDebugOutput = true;
}
/*
else if (!stricmp(actionCstr, "Account.ChannelGetList.1"))
{
gVoiceClient->channelGetListResponse(statusCode, statusString);
}
else if (!stricmp(actionCstr, "Connector.AccountCreate.1"))
{
}
else if (!stricmp(actionCstr, "Connector.MuteLocalMic.1"))
{
}
else if (!stricmp(actionCstr, "Connector.MuteLocalSpeaker.1"))
{
}
else if (!stricmp(actionCstr, "Connector.SetLocalMicVolume.1"))
{
}
else if (!stricmp(actionCstr, "Connector.SetLocalSpeakerVolume.1"))
{
}
else if (!stricmp(actionCstr, "Session.ListenerSetPosition.1"))
{
}
else if (!stricmp(actionCstr, "Session.SpeakerSetPosition.1"))
{
}
else if (!stricmp(actionCstr, "Session.AudioSourceSetPosition.1"))
{
}
else if (!stricmp(actionCstr, "Session.GetChannelParticipants.1"))
{
}
else if (!stricmp(actionCstr, "Account.ChannelCreate.1"))
{
}
else if (!stricmp(actionCstr, "Account.ChannelUpdate.1"))
{
}
else if (!stricmp(actionCstr, "Account.ChannelDelete.1"))
{
}
else if (!stricmp(actionCstr, "Account.ChannelCreateAndInvite.1"))
{
}
else if (!stricmp(actionCstr, "Account.ChannelFolderCreate.1"))
{
}
else if (!stricmp(actionCstr, "Account.ChannelFolderUpdate.1"))
{
}
else if (!stricmp(actionCstr, "Account.ChannelFolderDelete.1"))
{
}
else if (!stricmp(actionCstr, "Account.ChannelAddModerator.1"))
{
}
else if (!stricmp(actionCstr, "Account.ChannelDeleteModerator.1"))
{
}
*/
}
}
///////////////////////////////////////////////////////////////////////////////////////////////
class LLVoiceClientMuteListObserver : public LLMuteListObserver
{
/* virtual */ void onChange() { gVoiceClient->muteListChanged();}
};
class LLVoiceClientFriendsObserver : public LLFriendObserver
{
public:
/* virtual */ void changed(U32 mask) { gVoiceClient->updateFriends(mask);}
};
static LLVoiceClientMuteListObserver mutelist_listener;
static bool sMuteListListener_listening = false;
static LLVoiceClientFriendsObserver *friendslist_listener = NULL;
///////////////////////////////////////////////////////////////////////////////////////////////
class LLVoiceClientCapResponder : public LLHTTPClient::Responder
{
public:
LLVoiceClientCapResponder(void){};
virtual void error(U32 status, const std::string& reason); // called with bad status codes
virtual void result(const LLSD& content);
private:
};
void LLVoiceClientCapResponder::error(U32 status, const std::string& reason)
{
LL_WARNS("Voice") << "LLVoiceClientCapResponder::error("
<< status << ": " << reason << ")"
<< LL_ENDL;
}
void LLVoiceClientCapResponder::result(const LLSD& content)
{
LLSD::map_const_iterator iter;
LL_DEBUGS("Voice") << "ParcelVoiceInfoRequest response:" << ll_pretty_print_sd(content) << LL_ENDL;
if ( content.has("voice_credentials") )
{
LLSD voice_credentials = content["voice_credentials"];
std::string uri;
std::string credentials;
if ( voice_credentials.has("channel_uri") )
{
uri = voice_credentials["channel_uri"].asString();
}
if ( voice_credentials.has("channel_credentials") )
{
credentials =
voice_credentials["channel_credentials"].asString();
}
gVoiceClient->setSpatialChannel(uri, credentials);
}
}
#if LL_WINDOWS
static HANDLE sGatewayHandle = 0;
static bool isGatewayRunning()
{
bool result = false;
if(sGatewayHandle != 0)
{
DWORD waitresult = WaitForSingleObject(sGatewayHandle, 0);
if(waitresult != WAIT_OBJECT_0)
{
result = true;
}
}
return result;
}
static void killGateway()
{
if(sGatewayHandle != 0)
{
TerminateProcess(sGatewayHandle,0);
}
}
#else // Mac and linux
static pid_t sGatewayPID = 0;
static bool isGatewayRunning()
{
bool result = false;
if(sGatewayPID != 0)
{
// A kill with signal number 0 has no effect, just does error checking. It should return an error if the process no longer exists.
if(kill(sGatewayPID, 0) == 0)
{
result = true;
}
}
return result;
}
static void killGateway()
{
if(sGatewayPID != 0)
{
kill(sGatewayPID, SIGTERM);
}
}
#endif
class LLSpeakerVolumeStorage : public LLSingleton<LLSpeakerVolumeStorage>
{
LOG_CLASS(LLSpeakerVolumeStorage);
public:
/**
* Sets internal voluem level for specified user.
*
* @param[in] speaker_id - LLUUID of user to store volume level for
* @param[in] volume - external (vivox) volume level to be stored for user.
*/
void storeSpeakerVolume(const LLUUID& speaker_id, F32 volume);
/**
* Gets stored external (vivox) volume level for specified speaker and
* transforms it into internal (viewer) level.
*
* If specified user is not found -1 will be returned.
* Internal level is calculated as: internal = 400 * external^2
* Maps 0.0 to 1.0 to internal values 0-400
*
* @param[in] speaker_id - LLUUID of user to get his volume level
*/
S32 getSpeakerVolume(const LLUUID& speaker_id);
private:
friend class LLSingleton<LLSpeakerVolumeStorage>;
LLSpeakerVolumeStorage();
~LLSpeakerVolumeStorage();
const static std::string SETTINGS_FILE_NAME;
void load();
void save();
typedef std::map<LLUUID, F32> speaker_data_map_t;
speaker_data_map_t mSpeakersData;
};
const std::string LLSpeakerVolumeStorage::SETTINGS_FILE_NAME = "volume_settings.xml";
LLSpeakerVolumeStorage::LLSpeakerVolumeStorage()
{
load();
}
LLSpeakerVolumeStorage::~LLSpeakerVolumeStorage()
{
save();
}
void LLSpeakerVolumeStorage::storeSpeakerVolume(const LLUUID& speaker_id, F32 volume)
{
mSpeakersData[speaker_id] = volume;
}
S32 LLSpeakerVolumeStorage::getSpeakerVolume(const LLUUID& speaker_id)
{
// Return value of -1 indicates no level is stored for this speaker
S32 ret_val = -1;
speaker_data_map_t::const_iterator it = mSpeakersData.find(speaker_id);
if (it != mSpeakersData.end())
{
F32 f_val = it->second;
// volume can amplify by as much as 4x!
S32 ivol = (S32)(400.f * f_val * f_val);
ret_val = llclamp(ivol, 0, 400);
}
return ret_val;
}
void LLSpeakerVolumeStorage::load()
{
// load per-resident voice volume information
std::string filename = gDirUtilp->getExpandedFilename(LL_PATH_PER_SL_ACCOUNT, SETTINGS_FILE_NAME);
LLSD settings_llsd;
llifstream file;
file.open(filename);
if (file.is_open())
{
LLSDSerialize::fromXML(settings_llsd, file);
}
for (LLSD::map_const_iterator iter = settings_llsd.beginMap();
iter != settings_llsd.endMap(); ++iter)
{
mSpeakersData.insert(std::make_pair(LLUUID(iter->first), (F32)iter->second.asReal()));
}
}
void LLSpeakerVolumeStorage::save()
{
// If we quit from the login screen we will not have an SL account
// name. Don't try to save, otherwise we'll dump a file in
// C:Program FilesSecondLife or similar. JC
std::string user_dir = gDirUtilp->getLindenUserDir();
if (!user_dir.empty())
{
std::string filename = gDirUtilp->getExpandedFilename(LL_PATH_PER_SL_ACCOUNT, SETTINGS_FILE_NAME);
LLSD settings_llsd;
for(speaker_data_map_t::const_iterator iter = mSpeakersData.begin(); iter != mSpeakersData.end(); ++iter)
{
settings_llsd[iter->first.asString()] = iter->second;
}
llofstream file;
file.open(filename);
LLSDSerialize::toPrettyXML(settings_llsd, file);
}
}
///////////////////////////////////////////////////////////////////////////////////////////////
LLVoiceClient::LLVoiceClient() :
mState(stateDisabled),
mSessionTerminateRequested(false),
mRelogRequested(false),
mConnected(false),
mPump(NULL),
mTuningMode(false),
mTuningEnergy(0.0f),
mTuningMicVolume(0),
mTuningMicVolumeDirty(true),
mTuningSpeakerVolume(0),
mTuningSpeakerVolumeDirty(true),
mTuningExitState(stateDisabled),
mAreaVoiceDisabled(false),
mAudioSession(NULL),
mAudioSessionChanged(false),
mNextAudioSession(NULL),
mCurrentParcelLocalID(0),
mNumberOfAliases(0),
mCommandCookie(0),
mLoginRetryCount(0),
mBuddyListMapPopulated(false),
mBlockRulesListReceived(false),
mAutoAcceptRulesListReceived(false),
mCaptureDeviceDirty(false),
mRenderDeviceDirty(false),
mSpatialCoordsDirty(false),
mPTTDirty(true),
mPTT(true),
mUsePTT(true),
mPTTIsMiddleMouse(false),
mPTTKey(0),
mPTTIsToggle(false),
mUserPTTState(false),
mMuteMic(false),
mFriendsListDirty(true),
mEarLocation(0),
mSpeakerVolumeDirty(true),
mSpeakerMuteDirty(true),
mMicVolume(0),
mMicVolumeDirty(true),
mVoiceEnabled(false),
mWriteInProgress(false),
mLipSyncEnabled(false)
{
gVoiceClient = this;
mAPIVersion = LLTrans::getString("NotConnected");
mSpeakerVolume = scale_speaker_volume(0);
#if LL_DARWIN || LL_LINUX || LL_SOLARIS
// HACK: THIS DOES NOT BELONG HERE
// When the vivox daemon dies, the next write attempt on our socket generates a SIGPIPE, which kills us.
// This should cause us to ignore SIGPIPE and handle the error through proper channels.
// This should really be set up elsewhere. Where should it go?
signal(SIGPIPE, SIG_IGN);
// Since we're now launching the gateway with fork/exec instead of system(), we need to deal with zombie processes.
// Ignoring SIGCHLD should prevent zombies from being created. Alternately, we could use wait(), but I'd rather not do that.
signal(SIGCHLD, SIG_IGN);
#endif
// set up state machine
setState(stateDisabled);
gIdleCallbacks.addFunction(idle, this);
}
//---------------------------------------------------
LLVoiceClient::~LLVoiceClient()
{
}
//----------------------------------------------
void LLVoiceClient::init(LLPumpIO *pump)
{
// constructor will set up gVoiceClient
LLVoiceClient::getInstance()->mPump = pump;
LLVoiceClient::getInstance()->updateSettings();
}
void LLVoiceClient::terminate()
{
if(gVoiceClient)
{
// gVoiceClient->leaveAudioSession();
gVoiceClient->logout();
// As of SDK version 4885, this should no longer be necessary. It will linger after the socket close if it needs to.
// ms_sleep(2000);
gVoiceClient->connectorShutdown();
gVoiceClient->closeSocket(); // Need to do this now -- bad things happen if the destructor does it later.
// This will do unpleasant things on windows.
// killGateway();
// Don't do this anymore -- LLSingleton will take care of deleting the object.
// delete gVoiceClient;
// Hint to other code not to access the voice client anymore.
gVoiceClient = NULL;
}
}
//---------------------------------------------------
void LLVoiceClient::updateSettings()
{
setVoiceEnabled(gSavedSettings.getBOOL("EnableVoiceChat"));
setUsePTT(gSavedSettings.getBOOL("PTTCurrentlyEnabled"));
std::string keyString = gSavedSettings.getString("PushToTalkButton");
setPTTKey(keyString);
setPTTIsToggle(gSavedSettings.getBOOL("PushToTalkToggle"));
setEarLocation(gSavedSettings.getS32("VoiceEarLocation"));
std::string inputDevice = gSavedSettings.getString("VoiceInputAudioDevice");
setCaptureDevice(inputDevice);
std::string outputDevice = gSavedSettings.getString("VoiceOutputAudioDevice");
setRenderDevice(outputDevice);
F32 mic_level = gSavedSettings.getF32("AudioLevelMic");
setMicGain(mic_level);
setLipSyncEnabled(gSavedSettings.getBOOL("LipSyncEnabled"));
}
/////////////////////////////
// utility functions
bool LLVoiceClient::writeString(const std::string &str)
{
bool result = false;
if(mConnected)
{
apr_status_t err;
apr_size_t size = (apr_size_t)str.size();
apr_size_t written = size;
//MARK: Turn this on to log outgoing XML
// LL_DEBUGS("Voice") << "sending: " << str << LL_ENDL;
// check return code - sockets will fail (broken, etc.)
err = apr_socket_send(
mSocket->getSocket(),
(const char*)str.data(),
&written);
if(err == 0)
{
// Success.
result = true;
}
// TODO: handle partial writes (written is number of bytes written)
// Need to set socket to non-blocking before this will work.
// else if(APR_STATUS_IS_EAGAIN(err))
// {
// //
// }
else
{
// Assume any socket error means something bad. For now, just close the socket.
char buf[MAX_STRING];
LL_WARNS("Voice") << "apr error " << err << " ("<< apr_strerror(err, buf, MAX_STRING) << ") sending data to vivox daemon." << LL_ENDL;
daemonDied();
}
}
return result;
}
/////////////////////////////
// session control messages
void LLVoiceClient::connectorCreate()
{
std::ostringstream stream;
std::string logpath = gDirUtilp->getExpandedFilename(LL_PATH_LOGS, "");
std::string loglevel = "0";
// Transition to stateConnectorStarted when the connector handle comes back.
setState(stateConnectorStarting);
std::string savedLogLevel = gSavedSettings.getString("VivoxDebugLevel");
if(savedLogLevel != "-1")
{
LL_DEBUGS("Voice") << "creating connector with logging enabled" << LL_ENDL;
loglevel = "10";
}
stream
<< "<Request requestId="" << mCommandCookie++ << "" action="Connector.Create.1">"
<< "<ClientName>V2 SDK</ClientName>"
<< "<AccountManagementServer>" << mVoiceAccountServerURI << "</AccountManagementServer>"
<< "<Mode>Normal</Mode>"
<< "<Logging>"
<< "<Folder>" << logpath << "</Folder>"
<< "<FileNamePrefix>Connector</FileNamePrefix>"
<< "<FileNameSuffix>.log</FileNameSuffix>"
<< "<LogLevel>" << loglevel << "</LogLevel>"
<< "</Logging>"
<< "<Application>SecondLifeViewer.1</Application>"
<< "</Request>nnn";
writeString(stream.str());
}
void LLVoiceClient::connectorShutdown()
{
setState(stateConnectorStopping);
if(!mConnectorHandle.empty())
{
std::ostringstream stream;
stream
<< "<Request requestId="" << mCommandCookie++ << "" action="Connector.InitiateShutdown.1">"
<< "<ConnectorHandle>" << mConnectorHandle << "</ConnectorHandle>"
<< "</Request>"
<< "nnn";
mConnectorHandle.clear();
writeString(stream.str());
}
}
void LLVoiceClient::userAuthorized(const std::string& firstName, const std::string& lastName, const LLUUID &agentID)
{
mAccountFirstName = firstName;
mAccountLastName = lastName;
mAccountDisplayName = firstName;
mAccountDisplayName += " ";
mAccountDisplayName += lastName;
LL_INFOS("Voice") << "name "" << mAccountDisplayName << "" , ID " << agentID << LL_ENDL;
sConnectingToAgni = LLViewerLogin::getInstance()->isInProductionGrid();
mAccountName = nameFromID(agentID);
}
void LLVoiceClient::requestVoiceAccountProvision(S32 retries)
{
if ( gAgent.getRegion() && mVoiceEnabled )
{
std::string url =
gAgent.getRegion()->getCapability(
"ProvisionVoiceAccountRequest");
if ( url == "" ) return;
LLHTTPClient::post(
url,
LLSD(),
new LLViewerVoiceAccountProvisionResponder(retries));
}
}
void LLVoiceClient::login(
const std::string& account_name,
const std::string& password,
const std::string& voice_sip_uri_hostname,
const std::string& voice_account_server_uri)
{
mVoiceSIPURIHostName = voice_sip_uri_hostname;
mVoiceAccountServerURI = voice_account_server_uri;
if(!mAccountHandle.empty())
{
// Already logged in.
LL_WARNS("Voice") << "Called while already logged in." << LL_ENDL;
// Don't process another login.
return;
}
else if ( account_name != mAccountName )
{
//TODO: error?
LL_WARNS("Voice") << "Wrong account name! " << account_name
<< " instead of " << mAccountName << LL_ENDL;
}
else
{
mAccountPassword = password;
}
std::string debugSIPURIHostName = gSavedSettings.getString("VivoxDebugSIPURIHostName");
if( !debugSIPURIHostName.empty() )
{
mVoiceSIPURIHostName = debugSIPURIHostName;
}
if( mVoiceSIPURIHostName.empty() )
{
// we have an empty account server name
// so we fall back to hardcoded defaults
if(sConnectingToAgni)
{
// Use the release account server
mVoiceSIPURIHostName = "bhr.vivox.com";
}
else
{
// Use the development account server
mVoiceSIPURIHostName = "bhd.vivox.com";
}
}
std::string debugAccountServerURI = gSavedSettings.getString("VivoxDebugVoiceAccountServerURI");
if( !debugAccountServerURI.empty() )
{
mVoiceAccountServerURI = debugAccountServerURI;
}
if( mVoiceAccountServerURI.empty() )
{
// If the account server URI isn't specified, construct it from the SIP URI hostname
mVoiceAccountServerURI = "https://www." + mVoiceSIPURIHostName + "/api2/";
}
}
void LLVoiceClient::idle(void* user_data)
{
LLVoiceClient* self = (LLVoiceClient*)user_data;
self->stateMachine();
}
std::string LLVoiceClient::state2string(LLVoiceClient::state inState)
{
std::string result = "UNKNOWN";
// Prevent copy-paste errors when updating this list...
#define CASE(x) case x: result = #x; break
switch(inState)
{
CASE(stateDisableCleanup);
CASE(stateDisabled);
CASE(stateStart);
CASE(stateDaemonLaunched);
CASE(stateConnecting);
CASE(stateConnected);
CASE(stateIdle);
CASE(stateMicTuningStart);
CASE(stateMicTuningRunning);
CASE(stateMicTuningStop);
CASE(stateConnectorStart);
CASE(stateConnectorStarting);
CASE(stateConnectorStarted);
CASE(stateLoginRetry);
CASE(stateLoginRetryWait);
CASE(stateNeedsLogin);
CASE(stateLoggingIn);
CASE(stateLoggedIn);
CASE(stateCreatingSessionGroup);
CASE(stateNoChannel);
CASE(stateJoiningSession);
CASE(stateSessionJoined);
CASE(stateRunning);
CASE(stateLeavingSession);
CASE(stateSessionTerminated);
CASE(stateLoggingOut);
CASE(stateLoggedOut);
CASE(stateConnectorStopping);
CASE(stateConnectorStopped);
CASE(stateConnectorFailed);
CASE(stateConnectorFailedWaiting);
CASE(stateLoginFailed);
CASE(stateLoginFailedWaiting);
CASE(stateJoinSessionFailed);
CASE(stateJoinSessionFailedWaiting);
CASE(stateJail);
}
#undef CASE
return result;
}
std::string LLVoiceClientStatusObserver::status2string(LLVoiceClientStatusObserver::EStatusType inStatus)
{
std::string result = "UNKNOWN";
// Prevent copy-paste errors when updating this list...
#define CASE(x) case x: result = #x; break
switch(inStatus)
{
CASE(STATUS_LOGIN_RETRY);
CASE(STATUS_LOGGED_IN);
CASE(STATUS_JOINING);
CASE(STATUS_JOINED);
CASE(STATUS_LEFT_CHANNEL);
CASE(STATUS_VOICE_DISABLED);
CASE(STATUS_VOICE_ENABLED);
CASE(BEGIN_ERROR_STATUS);
CASE(ERROR_CHANNEL_FULL);
CASE(ERROR_CHANNEL_LOCKED);
CASE(ERROR_NOT_AVAILABLE);
CASE(ERROR_UNKNOWN);
default:
break;
}
#undef CASE
return result;
}
void LLVoiceClient::setState(state inState)
{
LL_DEBUGS("Voice") << "entering state " << state2string(inState) << LL_ENDL;
mState = inState;
}
void LLVoiceClient::stateMachine()
{
if(gDisconnected)
{
// The viewer has been disconnected from the sim. Disable voice.
setVoiceEnabled(false);
}
if(mVoiceEnabled)
{
updatePosition();
}
else if(mTuningMode)
{
// Tuning mode is special -- it needs to launch SLVoice even if voice is disabled.
}
else
{
if((getState() != stateDisabled) && (getState() != stateDisableCleanup))
{
// User turned off voice support. Send the cleanup messages, close the socket, and reset.
if(!mConnected)
{
// if voice was turned off after the daemon was launched but before we could connect to it, we may need to issue a kill.
LL_INFOS("Voice") << "Disabling voice before connection to daemon, terminating." << LL_ENDL;
killGateway();
}
logout();
connectorShutdown();
setState(stateDisableCleanup);
}
}
// Check for parcel boundary crossing
{
LLViewerRegion *region = gAgent.getRegion();
LLParcel *parcel = LLViewerParcelMgr::getInstance()->getAgentParcel();
if(region && parcel)
{
S32 parcelLocalID = parcel->getLocalID();
std::string regionName = region->getName();
std::string capURI = region->getCapability("ParcelVoiceInfoRequest");
// LL_DEBUGS("Voice") << "Region name = "" << regionName << "", parcel local ID = " << parcelLocalID << ", cap URI = "" << capURI << """ << LL_ENDL;
// The region name starts out empty and gets filled in later.
// Also, the cap gets filled in a short time after the region cross, but a little too late for our purposes.
// If either is empty, wait for the next time around.
if(!regionName.empty())
{
if(!capURI.empty())
{
if((parcelLocalID != mCurrentParcelLocalID) || (regionName != mCurrentRegionName))
{
// We have changed parcels. Initiate a parcel channel lookup.
mCurrentParcelLocalID = parcelLocalID;
mCurrentRegionName = regionName;
parcelChanged();
}
}
else
{
LL_WARNS_ONCE("Voice") << "region doesn't have ParcelVoiceInfoRequest capability. This is normal for a short time after teleporting, but bad if it persists for very long." << LL_ENDL;
}
}
}
}
switch(getState())
{
//MARK: stateDisableCleanup
case stateDisableCleanup:
// Clean up and reset everything.
closeSocket();
deleteAllSessions();
deleteAllBuddies();
mConnectorHandle.clear();
mAccountHandle.clear();
mAccountPassword.clear();
mVoiceAccountServerURI.clear();
setState(stateDisabled);
break;
//MARK: stateDisabled
case stateDisabled:
if(mTuningMode || (mVoiceEnabled && !mAccountName.empty()))
{
setState(stateStart);
}
break;
//MARK: stateStart
case stateStart:
if(gSavedSettings.getBOOL("CmdLineDisableVoice"))
{
// Voice is locked out, we must not launch the vivox daemon.
setState(stateJail);
}
else if(!isGatewayRunning())
{
if(true)
{
// Launch the voice daemon
// *FIX:Mani - Using the executable dir instead
// of mAppRODataDir, the working directory from which the app
// is launched.
//std::string exe_path = gDirUtilp->getAppRODataDir();
std::string exe_path = gDirUtilp->getExecutableDir();
exe_path += gDirUtilp->getDirDelimiter();
#if LL_WINDOWS
exe_path += "SLVoice.exe";
#elif LL_DARWIN
exe_path += "../Resources/SLVoice";
#else
exe_path += "SLVoice";
#endif
// See if the vivox executable exists
llstat s;
if(!LLFile::stat(exe_path, &s))
{
// vivox executable exists. Build the command line and launch the daemon.
// SLIM SDK: these arguments are no longer necessary.
// std::string args = " -p tcp -h -c";
std::string args;
std::string loglevel = gSavedSettings.getString("VivoxDebugLevel");
if(loglevel.empty())
{
loglevel = "-1"; // turn logging off completely
}
args += " -ll ";
args += loglevel;
LL_DEBUGS("Voice") << "Args for SLVoice: " << args << LL_ENDL;
#if LL_WINDOWS
PROCESS_INFORMATION pinfo;
STARTUPINFOW sinfo;
memset(&sinfo, 0, sizeof(sinfo));
std::string exe_dir = gDirUtilp->getExecutableDir();
llutf16string exe_path16 = utf8str_to_utf16str(exe_path);
llutf16string exe_dir16 = utf8str_to_utf16str(exe_dir);
llutf16string args16 = utf8str_to_utf16str(args);
// Create a writeable copy to keep Windows happy.
U16 *argscpy_16 = new U16[args16.size() + 1];
wcscpy_s(argscpy_16,args16.size()+1,args16.c_str());
if(!CreateProcessW(exe_path16.c_str(), argscpy_16, NULL, NULL, FALSE, 0, NULL, exe_dir16.c_str(), &sinfo, &pinfo))
{
// DWORD dwErr = GetLastError();
}
else
{
// foo = pinfo.dwProcessId; // get your pid here if you want to use it later on
// CloseHandle(pinfo.hProcess); // stops leaks - nothing else
sGatewayHandle = pinfo.hProcess;
CloseHandle(pinfo.hThread); // stops leaks - nothing else
}
delete[] argscpy_16;
#else // LL_WINDOWS
// This should be the same for mac and linux
{
std::vector<std::string> arglist;
arglist.push_back(exe_path);
// Split the argument string into separate strings for each argument
typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
boost::char_separator<char> sep(" ");
tokenizer tokens(args, sep);
tokenizer::iterator token_iter;
for(token_iter = tokens.begin(); token_iter != tokens.end(); ++token_iter)
{
arglist.push_back(*token_iter);
}
// create an argv vector for the child process
char **fakeargv = new char*[arglist.size() + 1];
int i;
for(i=0; i < arglist.size(); i++)
fakeargv[i] = const_cast<char*>(arglist[i].c_str());
fakeargv[i] = NULL;
fflush(NULL); // flush all buffers before the child inherits them
pid_t id = vfork();
if(id == 0)
{
// child
execv(exe_path.c_str(), fakeargv);
// If we reach this point, the exec failed.
// Use _exit() instead of exit() per the vfork man page.
_exit(0);
}
// parent
delete[] fakeargv;
sGatewayPID = id;
}
#endif // LL_WINDOWS
mDaemonHost = LLHost(gSavedSettings.getString("VoiceHost").c_str(), gSavedSettings.getU32("VoicePort"));
}
else
{
LL_INFOS("Voice") << exe_path << " not found." << LL_ENDL;
}
}
else
{
// SLIM SDK: port changed from 44124 to 44125.
// We can connect to a client gateway running on another host. This is useful for testing.
// To do this, launch the gateway on a nearby host like this:
// vivox-gw.exe -p tcp -i 0.0.0.0:44125
// and put that host's IP address here.
mDaemonHost = LLHost(gSavedSettings.getString("VoiceHost"), gSavedSettings.getU32("VoicePort"));
}
mUpdateTimer.start();
mUpdateTimer.setTimerExpirySec(CONNECT_THROTTLE_SECONDS);
setState(stateDaemonLaunched);
// Dirty the states we'll need to sync with the daemon when it comes up.
mPTTDirty = true;
mMicVolumeDirty = true;
mSpeakerVolumeDirty = true;
mSpeakerMuteDirty = true;
// These only need to be set if they're not default (i.e. empty string).
mCaptureDeviceDirty = !mCaptureDevice.empty();
mRenderDeviceDirty = !mRenderDevice.empty();
mMainSessionGroupHandle.clear();
}
break;
//MARK: stateDaemonLaunched
case stateDaemonLaunched:
if(mUpdateTimer.hasExpired())
{
LL_DEBUGS("Voice") << "Connecting to vivox daemon" << LL_ENDL;
mUpdateTimer.setTimerExpirySec(CONNECT_THROTTLE_SECONDS);
if(!mSocket)
{
mSocket = LLSocket::create(gAPRPoolp, LLSocket::STREAM_TCP);
}
mConnected = mSocket->blockingConnect(mDaemonHost);
if(mConnected)
{
setState(stateConnecting);
}
else
{
// If the connect failed, the socket may have been put into a bad state. Delete it.
closeSocket();
}
}
break;
//MARK: stateConnecting
case stateConnecting:
// Can't do this until we have the pump available.
if(mPump)
{
// MBW -- Note to self: pumps and pipes examples in
// indra/test/io.cpp
// indra/test/llpipeutil.{cpp|h}
// Attach the pumps and pipes
LLPumpIO::chain_t readChain;
readChain.push_back(LLIOPipe::ptr_t(new LLIOSocketReader(mSocket)));
readChain.push_back(LLIOPipe::ptr_t(new LLVivoxProtocolParser()));
mPump->addChain(readChain, NEVER_CHAIN_EXPIRY_SECS);
setState(stateConnected);
}
break;
//MARK: stateConnected
case stateConnected:
// Initial devices query
getCaptureDevicesSendMessage();
getRenderDevicesSendMessage();
mLoginRetryCount = 0;
setState(stateIdle);
break;
//MARK: stateIdle
case stateIdle:
// This is the idle state where we're connected to the daemon but haven't set up a connector yet.
if(mTuningMode)
{
mTuningExitState = stateIdle;
setState(stateMicTuningStart);
}
else if(!mVoiceEnabled)
{
// We never started up the connector. This will shut down the daemon.
setState(stateConnectorStopped);
}
else if(!mAccountName.empty())
{
LLViewerRegion *region = gAgent.getRegion();
if(region)
{
if ( region->getCapability("ProvisionVoiceAccountRequest") != "" )
{
if ( mAccountPassword.empty() )
{
requestVoiceAccountProvision();
}
setState(stateConnectorStart);
}
else
{
LL_WARNS_ONCE("Voice") << "region doesn't have ProvisionVoiceAccountRequest capability!" << LL_ENDL;
}
}
}
break;
//MARK: stateMicTuningStart
case stateMicTuningStart:
if(mUpdateTimer.hasExpired())
{
if(mCaptureDeviceDirty || mRenderDeviceDirty)
{
// These can't be changed while in tuning mode. Set them before starting.
std::ostringstream stream;
buildSetCaptureDevice(stream);
buildSetRenderDevice(stream);
if(!stream.str().empty())
{
writeString(stream.str());
}
// This will come around again in the same state and start the capture, after the timer expires.
mUpdateTimer.start();
mUpdateTimer.setTimerExpirySec(UPDATE_THROTTLE_SECONDS);
}
else
{
// duration parameter is currently unused, per Mike S.
tuningCaptureStartSendMessage(10000);
setState(stateMicTuningRunning);
}
}
break;
//MARK: stateMicTuningRunning
case stateMicTuningRunning:
if(!mTuningMode || mCaptureDeviceDirty || mRenderDeviceDirty)
{
// All of these conditions make us leave tuning mode.
setState(stateMicTuningStop);
}
else
{
// process mic/speaker volume changes
if(mTuningMicVolumeDirty || mTuningSpeakerVolumeDirty)
{
std::ostringstream stream;
if(mTuningMicVolumeDirty)
{
LL_INFOS("Voice") << "setting tuning mic level to " << mTuningMicVolume << LL_ENDL;
stream
<< "<Request requestId="" << mCommandCookie++ << "" action="Aux.SetMicLevel.1">"
<< "<Level>" << mTuningMicVolume << "</Level>"
<< "</Request>nnn";
}
if(mTuningSpeakerVolumeDirty)
{
stream
<< "<Request requestId="" << mCommandCookie++ << "" action="Aux.SetSpeakerLevel.1">"
<< "<Level>" << mTuningSpeakerVolume << "</Level>"
<< "</Request>nnn";
}
mTuningMicVolumeDirty = false;
mTuningSpeakerVolumeDirty = false;
if(!stream.str().empty())
{
writeString(stream.str());
}
}
}
break;
//MARK: stateMicTuningStop
case stateMicTuningStop:
{
// transition out of mic tuning
tuningCaptureStopSendMessage();
setState(mTuningExitState);
// if we exited just to change devices, this will keep us from re-entering too fast.
mUpdateTimer.start();
mUpdateTimer.setTimerExpirySec(UPDATE_THROTTLE_SECONDS);
}
break;
//MARK: stateConnectorStart
case stateConnectorStart:
if(!mVoiceEnabled)
{
// We were never logged in. This will shut down the connector.
setState(stateLoggedOut);
}
else if(!mVoiceAccountServerURI.empty())
{
connectorCreate();
}
break;
//MARK: stateConnectorStarting
case stateConnectorStarting: // waiting for connector handle
// connectorCreateResponse() will transition from here to stateConnectorStarted.
break;
//MARK: stateConnectorStarted
case stateConnectorStarted: // connector handle received
if(!mVoiceEnabled)
{
// We were never logged in. This will shut down the connector.
setState(stateLoggedOut);
}
else
{
// The connector is started. Send a login message.
setState(stateNeedsLogin);
}
break;
//MARK: stateLoginRetry
case stateLoginRetry:
if(mLoginRetryCount == 0)
{
// First retry -- display a message to the user
notifyStatusObservers(LLVoiceClientStatusObserver::STATUS_LOGIN_RETRY);
}
mLoginRetryCount++;
if(mLoginRetryCount > MAX_LOGIN_RETRIES)
{
LL_WARNS("Voice") << "too many login retries, giving up." << LL_ENDL;
setState(stateLoginFailed);
}
else
{
LL_INFOS("Voice") << "will retry login in " << LOGIN_RETRY_SECONDS << " seconds." << LL_ENDL;
mUpdateTimer.start();
mUpdateTimer.setTimerExpirySec(LOGIN_RETRY_SECONDS);
setState(stateLoginRetryWait);
}
break;
//MARK: stateLoginRetryWait
case stateLoginRetryWait:
if(mUpdateTimer.hasExpired())
{
setState(stateNeedsLogin);
}
break;
//MARK: stateNeedsLogin
case stateNeedsLogin:
if(!mAccountPassword.empty())
{
setState(stateLoggingIn);
loginSendMessage();
}
break;
//MARK: stateLoggingIn
case stateLoggingIn: // waiting for account handle
// loginResponse() will transition from here to stateLoggedIn.
break;
//MARK: stateLoggedIn
case stateLoggedIn: // account handle received
notifyStatusObservers(LLVoiceClientStatusObserver::STATUS_LOGGED_IN);
// request the current set of block rules (we'll need them when updating the friends list)
accountListBlockRulesSendMessage();
// request the current set of auto-accept rules
accountListAutoAcceptRulesSendMessage();
// Set up the mute list observer if it hasn't been set up already.
if((!sMuteListListener_listening))
{
LLMuteList::getInstance()->addObserver(&mutelist_listener);
sMuteListListener_listening = true;
}
// Set up the friends list observer if it hasn't been set up already.
if(friendslist_listener == NULL)
{
friendslist_listener = new LLVoiceClientFriendsObserver;
LLAvatarTracker::instance().addObserver(friendslist_listener);
}
// Set the initial state of mic mute, local speaker volume, etc.
{
std::ostringstream stream;
buildLocalAudioUpdates(stream);
if(!stream.str().empty())
{
writeString(stream.str());
}
}
#if USE_SESSION_GROUPS
// create the main session group
sessionGroupCreateSendMessage();
setState(stateCreatingSessionGroup);
#else
// Not using session groups -- skip the stateCreatingSessionGroup state.
setState(stateNoChannel);
// Initial kick-off of channel lookup logic
parcelChanged();
#endif
break;
//MARK: stateCreatingSessionGroup
case stateCreatingSessionGroup:
if(mSessionTerminateRequested || !mVoiceEnabled)
{
// TODO: Question: is this the right way out of this state
setState(stateSessionTerminated);
}
else if(!mMainSessionGroupHandle.empty())
{
setState(stateNoChannel);
// Start looped recording (needed for "panic button" anti-griefing tool)
recordingLoopStart();
// Initial kick-off of channel lookup logic
parcelChanged();
}
break;
//MARK: stateNoChannel
case stateNoChannel:
// Do this here as well as inside sendPositionalUpdate().
// Otherwise, if you log in but don't join a proximal channel (such as when your login location has voice disabled), your friends list won't sync.
sendFriendsListUpdates();
if(mSessionTerminateRequested || !mVoiceEnabled)
{
// TODO: Question: Is this the right way out of this state?
setState(stateSessionTerminated);
}
else if(mTuningMode)
{
mTuningExitState = stateNoChannel;
setState(stateMicTuningStart);
}
else if(sessionNeedsRelog(mNextAudioSession))
{
requestRelog();
setState(stateSessionTerminated);
}
else if(mNextAudioSession)
{
sessionState *oldSession = mAudioSession;
mAudioSession = mNextAudioSession;
if(!mAudioSession->mReconnect)
{
mNextAudioSession = NULL;
}
// The old session may now need to be deleted.
reapSession(oldSession);
if(!mAudioSession->mHandle.empty())
{
// Connect to a session by session handle
sessionMediaConnectSendMessage(mAudioSession);
}
else
{
// Connect to a session by URI
sessionCreateSendMessage(mAudioSession, true, false);
}
notifyStatusObservers(LLVoiceClientStatusObserver::STATUS_JOINING);
setState(stateJoiningSession);
}
else if(!mSpatialSessionURI.empty())
{
// If we're not headed elsewhere and have a spatial URI, return to spatial.
switchChannel(mSpatialSessionURI, true, false, false, mSpatialSessionCredentials);
}
break;
//MARK: stateJoiningSession
case stateJoiningSession: // waiting for session handle
// joinedAudioSession() will transition from here to stateSessionJoined.
if(!mVoiceEnabled)
{
// User bailed out during connect -- jump straight to teardown.
setState(stateSessionTerminated);
}
else if(mSessionTerminateRequested)
{
if(mAudioSession && !mAudioSession->mHandle.empty())
{
// Only allow direct exits from this state in p2p calls (for cancelling an invite).
// Terminating a half-connected session on other types of calls seems to break something in the vivox gateway.
if(mAudioSession->mIsP2P)
{
sessionMediaDisconnectSendMessage(mAudioSession);
setState(stateSessionTerminated);
}
}
}
break;
//MARK: stateSessionJoined
case stateSessionJoined: // session handle received
// It appears that I need to wait for BOTH the SessionGroup.AddSession response and the SessionStateChangeEvent with state 4
// before continuing from this state. They can happen in either order, and if I don't wait for both, things can get stuck.
// For now, the SessionGroup.AddSession response handler sets mSessionHandle and the SessionStateChangeEvent handler transitions to stateSessionJoined.
// This is a cheap way to make sure both have happened before proceeding.
if(mAudioSession && mAudioSession->mVoiceEnabled)
{
// Dirty state that may need to be sync'ed with the daemon.
mPTTDirty = true;
mSpeakerVolumeDirty = true;
mSpatialCoordsDirty = true;
setState(stateRunning);
// Start the throttle timer
mUpdateTimer.start();
mUpdateTimer.setTimerExpirySec(UPDATE_THROTTLE_SECONDS);
// Events that need to happen when a session is joined could go here.
// Maybe send initial spatial data?
notifyStatusObservers(LLVoiceClientStatusObserver::STATUS_JOINED);
}
else if(!mVoiceEnabled)
{
// User bailed out during connect -- jump straight to teardown.
setState(stateSessionTerminated);
}
else if(mSessionTerminateRequested)
{
// Only allow direct exits from this state in p2p calls (for cancelling an invite).
// Terminating a half-connected session on other types of calls seems to break something in the vivox gateway.
if(mAudioSession && mAudioSession->mIsP2P)
{
sessionMediaDisconnectSendMessage(mAudioSession);
setState(stateSessionTerminated);
}
}
break;
//MARK: stateRunning
case stateRunning: // steady state
// Disabling voice or disconnect requested.
if(!mVoiceEnabled || mSessionTerminateRequested)
{
leaveAudioSession();
}
else
{
// Figure out whether the PTT state needs to change
{
bool newPTT;
if(mUsePTT)
{
// If configured to use PTT, track the user state.
newPTT = mUserPTTState;
}
else
{
// If not configured to use PTT, it should always be true (otherwise the user will be unable to speak).
newPTT = true;
}
if(mMuteMic)
{
// This always overrides any other PTT setting.
newPTT = false;
}
// Dirty if state changed.
if(newPTT != mPTT)
{
mPTT = newPTT;
mPTTDirty = true;
}
}
if(!inSpatialChannel())
{
// When in a non-spatial channel, never send positional updates.
mSpatialCoordsDirty = false;
}
else
{
// Do the calculation that enforces the listener<->speaker tether (and also updates the real camera position)
enforceTether();
}
// Send an update if the ptt state has changed (which shouldn't be able to happen that often -- the user can only click so fast)
// or every 10hz, whichever is sooner.
if((mAudioSession && mAudioSession->mVolumeDirty) || mPTTDirty || mSpeakerVolumeDirty || mUpdateTimer.hasExpired())
{
mUpdateTimer.setTimerExpirySec(UPDATE_THROTTLE_SECONDS);
sendPositionalUpdate();
}
}
break;
//MARK: stateLeavingSession
case stateLeavingSession: // waiting for terminate session response
// The handler for the Session.Terminate response will transition from here to stateSessionTerminated.
break;
//MARK: stateSessionTerminated
case stateSessionTerminated:
// Must do this first, since it uses mAudioSession.
notifyStatusObservers(LLVoiceClientStatusObserver::STATUS_LEFT_CHANNEL);
if(mAudioSession)
{
sessionState *oldSession = mAudioSession;
mAudioSession = NULL;
// We just notified status observers about this change. Don't do it again.
mAudioSessionChanged = false;
// The old session may now need to be deleted.
reapSession(oldSession);
}
else
{
LL_WARNS("Voice") << "stateSessionTerminated with NULL mAudioSession" << LL_ENDL;
}
// Always reset the terminate request flag when we get here.
mSessionTerminateRequested = false;
if(mVoiceEnabled && !mRelogRequested)
{
// Just leaving a channel, go back to stateNoChannel (the "logged in but have no channel" state).
setState(stateNoChannel);
}
else
{
// Shutting down voice, continue with disconnecting.
logout();
// The state machine will take it from here
mRelogRequested = false;
}
break;
//MARK: stateLoggingOut
case stateLoggingOut: // waiting for logout response
// The handler for the AccountLoginStateChangeEvent will transition from here to stateLoggedOut.
break;
//MARK: stateLoggedOut
case stateLoggedOut: // logout response received
// Once we're logged out, all these things are invalid.
mAccountHandle.clear();
deleteAllSessions();
deleteAllBuddies();
if(mVoiceEnabled && !mRelogRequested)
{
// User was logged out, but wants to be logged in. Send a new login request.
setState(stateNeedsLogin);
}
else
{
// shut down the connector
connectorShutdown();
}
break;
//MARK: stateConnectorStopping
case stateConnectorStopping: // waiting for connector stop
// The handler for the Connector.InitiateShutdown response will transition from here to stateConnectorStopped.
break;
//MARK: stateConnectorStopped
case stateConnectorStopped: // connector stop received
setState(stateDisableCleanup);
break;
//MARK: stateConnectorFailed
case stateConnectorFailed:
setState(stateConnectorFailedWaiting);
break;
//MARK: stateConnectorFailedWaiting
case stateConnectorFailedWaiting:
if(!mVoiceEnabled)
{
setState(stateDisableCleanup);
}
break;
//MARK: stateLoginFailed
case stateLoginFailed:
setState(stateLoginFailedWaiting);
break;
//MARK: stateLoginFailedWaiting
case stateLoginFailedWaiting:
if(!mVoiceEnabled)
{
setState(stateDisableCleanup);
}
break;
//MARK: stateJoinSessionFailed
case stateJoinSessionFailed:
// Transition to error state. Send out any notifications here.
if(mAudioSession)
{
LL_WARNS("Voice") << "stateJoinSessionFailed: (" << mAudioSession->mErrorStatusCode << "): " << mAudioSession->mErrorStatusString << LL_ENDL;
}
else
{
LL_WARNS("Voice") << "stateJoinSessionFailed with no current session" << LL_ENDL;
}
notifyStatusObservers(LLVoiceClientStatusObserver::ERROR_UNKNOWN);
setState(stateJoinSessionFailedWaiting);
break;
//MARK: stateJoinSessionFailedWaiting
case stateJoinSessionFailedWaiting:
// Joining a channel failed, either due to a failed channel name -> sip url lookup or an error from the join message.
// Region crossings may leave this state and try the join again.
if(mSessionTerminateRequested)
{
setState(stateSessionTerminated);
}
break;
//MARK: stateJail
case stateJail:
// We have given up. Do nothing.
break;
}
if(mAudioSession && mAudioSession->mParticipantsChanged)
{
mAudioSession->mParticipantsChanged = false;
mAudioSessionChanged = true;
}
if(mAudioSessionChanged)
{
mAudioSessionChanged = false;
notifyParticipantObservers();
}
}
void LLVoiceClient::closeSocket(void)
{
mSocket.reset();
mConnected = false;
}
void LLVoiceClient::loginSendMessage()
{
std::ostringstream stream;
bool autoPostCrashDumps = gSavedSettings.getBOOL("VivoxAutoPostCrashDumps");
stream
<< "<Request requestId="" << mCommandCookie++ << "" action="Account.Login.1">"
<< "<ConnectorHandle>" << mConnectorHandle << "</ConnectorHandle>"
<< "<AccountName>" << mAccountName << "</AccountName>"
<< "<AccountPassword>" << mAccountPassword << "</AccountPassword>"
<< "<AudioSessionAnswerMode>VerifyAnswer</AudioSessionAnswerMode>"
<< "<EnableBuddiesAndPresence>true</EnableBuddiesAndPresence>"
<< "<BuddyManagementMode>Application</BuddyManagementMode>"
<< "<ParticipantPropertyFrequency>5</ParticipantPropertyFrequency>"
<< (autoPostCrashDumps?"<AutopostCrashDumps>true</AutopostCrashDumps>":"")
<< "</Request>nnn";
writeString(stream.str());
}
void LLVoiceClient::logout()
{
// Ensure that we'll re-request provisioning before logging in again
mAccountPassword.clear();
mVoiceAccountServerURI.clear();
setState(stateLoggingOut);
logoutSendMessage();
}
void LLVoiceClient::logoutSendMessage()
{
if(!mAccountHandle.empty())
{
std::ostringstream stream;
stream
<< "<Request requestId="" << mCommandCookie++ << "" action="Account.Logout.1">"
<< "<AccountHandle>" << mAccountHandle << "</AccountHandle>"
<< "</Request>"
<< "nnn";
mAccountHandle.clear();
writeString(stream.str());
}
}
void LLVoiceClient::accountListBlockRulesSendMessage()
{
if(!mAccountHandle.empty())
{
std::ostringstream stream;
LL_DEBUGS("Voice") << "requesting block rules" << LL_ENDL;
stream
<< "<Request requestId="" << mCommandCookie++ << "" action="Account.ListBlockRules.1">"
<< "<AccountHandle>" << mAccountHandle << "</AccountHandle>"
<< "</Request>"
<< "nnn";
writeString(stream.str());
}
}
void LLVoiceClient::accountListAutoAcceptRulesSendMessage()
{
if(!mAccountHandle.empty())
{
std::ostringstream stream;
LL_DEBUGS("Voice") << "requesting auto-accept rules" << LL_ENDL;
stream
<< "<Request requestId="" << mCommandCookie++ << "" action="Account.ListAutoAcceptRules.1">"
<< "<AccountHandle>" << mAccountHandle << "</AccountHandle>"
<< "</Request>"
<< "nnn";
writeString(stream.str());
}
}
void LLVoiceClient::sessionGroupCreateSendMessage()
{
if(!mAccountHandle.empty())
{
std::ostringstream stream;
LL_DEBUGS("Voice") << "creating session group" << LL_ENDL;
stream
<< "<Request requestId="" << mCommandCookie++ << "" action="SessionGroup.Create.1">"
<< "<AccountHandle>" << mAccountHandle << "</AccountHandle>"
<< "<Type>Normal</Type>"
<< "</Request>"
<< "nnn";
writeString(stream.str());
}
}
void LLVoiceClient::sessionCreateSendMessage(sessionState *session, bool startAudio, bool startText)
{
LL_DEBUGS("Voice") << "requesting create: " << session->mSIPURI << LL_ENDL;
session->mCreateInProgress = true;
if(startAudio)
{
session->mMediaConnectInProgress = true;
}
std::ostringstream stream;
stream
<< "<Request requestId="" << session->mSIPURI << "" action="Session.Create.1">"
<< "<AccountHandle>" << mAccountHandle << "</AccountHandle>"
<< "<URI>" << session->mSIPURI << "</URI>";
static const std::string allowed_chars =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
"0123456789"
"-._~";
if(!session->mHash.empty())
{
stream
<< "<Password>" << LLURI::escape(session->mHash, allowed_chars) << "</Password>"
<< "<PasswordHashAlgorithm>SHA1UserName</PasswordHashAlgorithm>";
}
stream
<< "<ConnectAudio>" << (startAudio?"true":"false") << "</ConnectAudio>"
<< "<ConnectText>" << (startText?"true":"false") << "</ConnectText>"
<< "<Name>" << mChannelName << "</Name>"
<< "</Request>nnn";
writeString(stream.str());
}
void LLVoiceClient::sessionGroupAddSessionSendMessage(sessionState *session, bool startAudio, bool startText)
{
LL_DEBUGS("Voice") << "requesting create: " << session->mSIPURI << LL_ENDL;
session->mCreateInProgress = true;
if(startAudio)
{
session->mMediaConnectInProgress = true;
}
std::string password;
if(!session->mHash.empty())
{
static const std::string allowed_chars =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
"0123456789"
"-._~"
;
password = LLURI::escape(session->mHash, allowed_chars);
}
std::ostringstream stream;
stream
<< "<Request requestId="" << session->mSIPURI << "" action="SessionGroup.AddSession.1">"
<< "<SessionGroupHandle>" << session->mGroupHandle << "</SessionGroupHandle>"
<< "<URI>" << session->mSIPURI << "</URI>"
<< "<Name>" << mChannelName << "</Name>"
<< "<ConnectAudio>" << (startAudio?"true":"false") << "</ConnectAudio>"
<< "<ConnectText>" << (startText?"true":"false") << "</ConnectText>"
<< "<Password>" << password << "</Password>"
<< "<PasswordHashAlgorithm>SHA1UserName</PasswordHashAlgorithm>"
<< "</Request>nnn"
;
writeString(stream.str());
}
void LLVoiceClient::sessionMediaConnectSendMessage(sessionState *session)
{
LL_DEBUGS("Voice") << "connecting audio to session handle: " << session->mHandle << LL_ENDL;
session->mMediaConnectInProgress = true;
std::ostringstream stream;
stream
<< "<Request requestId="" << session->mHandle << "" action="Session.MediaConnect.1">"
<< "<SessionGroupHandle>" << session->mGroupHandle << "</SessionGroupHandle>"
<< "<SessionHandle>" << session->mHandle << "</SessionHandle>"
<< "<Media>Audio</Media>"
<< "</Request>nnn";
writeString(stream.str());
}
void LLVoiceClient::sessionTextConnectSendMessage(sessionState *session)
{
LL_DEBUGS("Voice") << "connecting text to session handle: " << session->mHandle << LL_ENDL;
std::ostringstream stream;
stream
<< "<Request requestId="" << session->mHandle << "" action="Session.TextConnect.1">"
<< "<SessionGroupHandle>" << session->mGroupHandle << "</SessionGroupHandle>"
<< "<SessionHandle>" << session->mHandle << "</SessionHandle>"
<< "</Request>nnn";
writeString(stream.str());
}
void LLVoiceClient::sessionTerminate()
{
mSessionTerminateRequested = true;
}
void LLVoiceClient::requestRelog()
{
mSessionTerminateRequested = true;
mRelogRequested = true;
}
void LLVoiceClient::leaveAudioSession()
{
if(mAudioSession)
{
LL_DEBUGS("Voice") << "leaving session: " << mAudioSession->mSIPURI << LL_ENDL;
switch(getState())
{
case stateNoChannel:
// In this case, we want to pretend the join failed so our state machine doesn't get stuck.
// Skip the join failed transition state so we don't send out error notifications.
setState(stateJoinSessionFailedWaiting);
break;
case stateJoiningSession:
case stateSessionJoined:
case stateRunning:
if(!mAudioSession->mHandle.empty())
{
#if RECORD_EVERYTHING
// HACK: for testing only
// Save looped recording
std::string savepath("/tmp/vivoxrecording");
{
time_t now = time(NULL);
const size_t BUF_SIZE = 64;
char time_str[BUF_SIZE]; /* Flawfinder: ignore */
strftime(time_str, BUF_SIZE, "%Y-%m-%dT%H:%M:%SZ", gmtime(&now));
savepath += time_str;
}
recordingLoopSave(savepath);
#endif
sessionMediaDisconnectSendMessage(mAudioSession);
setState(stateLeavingSession);
}
else
{
LL_WARNS("Voice") << "called with no session handle" << LL_ENDL;
setState(stateSessionTerminated);
}
break;
case stateJoinSessionFailed:
case stateJoinSessionFailedWaiting:
setState(stateSessionTerminated);
break;
default:
LL_WARNS("Voice") << "called from unknown state" << LL_ENDL;
break;
}
}
else
{
LL_WARNS("Voice") << "called with no active session" << LL_ENDL;
setState(stateSessionTerminated);
}
}
void LLVoiceClient::sessionTerminateSendMessage(sessionState *session)
{
std::ostringstream stream;
LL_DEBUGS("Voice") << "Sending Session.Terminate with handle " << session->mHandle << LL_ENDL;
stream
<< "<Request requestId="" << mCommandCookie++ << "" action="Session.Terminate.1">"
<< "<SessionHandle>" << session->mHandle << "</SessionHandle>"
<< "</Request>nnn";
writeString(stream.str());
}
void LLVoiceClient::sessionGroupTerminateSendMessage(sessionState *session)
{
std::ostringstream stream;
LL_DEBUGS("Voice") << "Sending SessionGroup.Terminate with handle " << session->mGroupHandle << LL_ENDL;
stream
<< "<Request requestId="" << mCommandCookie++ << "" action="SessionGroup.Terminate.1">"
<< "<SessionGroupHandle>" << session->mGroupHandle << "</SessionGroupHandle>"
<< "</Request>nnn";
writeString(stream.str());
}
void LLVoiceClient::sessionMediaDisconnectSendMessage(sessionState *session)
{
std::ostringstream stream;
LL_DEBUGS("Voice") << "Sending Session.MediaDisconnect with handle " << session->mHandle << LL_ENDL;
stream
<< "<Request requestId="" << mCommandCookie++ << "" action="Session.MediaDisconnect.1">"
<< "<SessionGroupHandle>" << session->mGroupHandle << "</SessionGroupHandle>"
<< "<SessionHandle>" << session->mHandle << "</SessionHandle>"
<< "<Media>Audio</Media>"
<< "</Request>nnn";
writeString(stream.str());
}
void LLVoiceClient::sessionTextDisconnectSendMessage(sessionState *session)
{
std::ostringstream stream;
LL_DEBUGS("Voice") << "Sending Session.TextDisconnect with handle " << session->mHandle << LL_ENDL;
stream
<< "<Request requestId="" << mCommandCookie++ << "" action="Session.TextDisconnect.1">"
<< "<SessionGroupHandle>" << session->mGroupHandle << "</SessionGroupHandle>"
<< "<SessionHandle>" << session->mHandle << "</SessionHandle>"
<< "</Request>nnn";
writeString(stream.str());
}
void LLVoiceClient::getCaptureDevicesSendMessage()
{
std::ostringstream stream;
stream
<< "<Request requestId="" << mCommandCookie++ << "" action="Aux.GetCaptureDevices.1">"
<< "</Request>nnn";
writeString(stream.str());
}
void LLVoiceClient::getRenderDevicesSendMessage()
{
std::ostringstream stream;
stream
<< "<Request requestId="" << mCommandCookie++ << "" action="Aux.GetRenderDevices.1">"
<< "</Request>nnn";
writeString(stream.str());
}
void LLVoiceClient::clearCaptureDevices()
{
LL_DEBUGS("Voice") << "called" << LL_ENDL;
mCaptureDevices.clear();
}
void LLVoiceClient::addCaptureDevice(const std::string& name)
{
LL_DEBUGS("Voice") << name << LL_ENDL;
mCaptureDevices.push_back(name);
}
LLVoiceClient::deviceList *LLVoiceClient::getCaptureDevices()
{
return &mCaptureDevices;
}
void LLVoiceClient::setCaptureDevice(const std::string& name)
{
if(name == "Default")
{
if(!mCaptureDevice.empty())
{
mCaptureDevice.clear();
mCaptureDeviceDirty = true;
}
}
else
{
if(mCaptureDevice != name)
{
mCaptureDevice = name;
mCaptureDeviceDirty = true;
}
}
}
void LLVoiceClient::clearRenderDevices()
{
LL_DEBUGS("Voice") << "called" << LL_ENDL;
mRenderDevices.clear();
}
void LLVoiceClient::addRenderDevice(const std::string& name)
{
LL_DEBUGS("Voice") << name << LL_ENDL;
mRenderDevices.push_back(name);
}
LLVoiceClient::deviceList *LLVoiceClient::getRenderDevices()
{
return &mRenderDevices;
}
void LLVoiceClient::setRenderDevice(const std::string& name)
{
if(name == "Default")
{
if(!mRenderDevice.empty())
{
mRenderDevice.clear();
mRenderDeviceDirty = true;
}
}
else
{
if(mRenderDevice != name)
{
mRenderDevice = name;
mRenderDeviceDirty = true;
}
}
}
void LLVoiceClient::tuningStart()
{
mTuningMode = true;
if(getState() >= stateNoChannel)
{
sessionTerminate();
}
}
void LLVoiceClient::tuningStop()
{
mTuningMode = false;
}
bool LLVoiceClient::inTuningMode()
{
bool result = false;
switch(getState())
{
case stateMicTuningRunning:
result = true;
break;
default:
break;
}
return result;
}
void LLVoiceClient::tuningRenderStartSendMessage(const std::string& name, bool loop)
{
mTuningAudioFile = name;
std::ostringstream stream;
stream
<< "<Request requestId="" << mCommandCookie++ << "" action="Aux.RenderAudioStart.1">"
<< "<SoundFilePath>" << mTuningAudioFile << "</SoundFilePath>"
<< "<Loop>" << (loop?"1":"0") << "</Loop>"
<< "</Request>nnn";
writeString(stream.str());
}
void LLVoiceClient::tuningRenderStopSendMessage()
{
std::ostringstream stream;
stream
<< "<Request requestId="" << mCommandCookie++ << "" action="Aux.RenderAudioStop.1">"
<< "<SoundFilePath>" << mTuningAudioFile << "</SoundFilePath>"
<< "</Request>nnn";
writeString(stream.str());
}
void LLVoiceClient::tuningCaptureStartSendMessage(int duration)
{
LL_DEBUGS("Voice") << "sending CaptureAudioStart" << LL_ENDL;
std::ostringstream stream;
stream
<< "<Request requestId="" << mCommandCookie++ << "" action="Aux.CaptureAudioStart.1">"
<< "<Duration>" << duration << "</Duration>"
<< "</Request>nnn";
writeString(stream.str());
}
void LLVoiceClient::tuningCaptureStopSendMessage()
{
LL_DEBUGS("Voice") << "sending CaptureAudioStop" << LL_ENDL;
std::ostringstream stream;
stream
<< "<Request requestId="" << mCommandCookie++ << "" action="Aux.CaptureAudioStop.1">"
<< "</Request>nnn";
writeString(stream.str());
mTuningEnergy = 0.0f;
}
void LLVoiceClient::tuningSetMicVolume(float volume)
{
int scaled_volume = scale_mic_volume(volume);
if(scaled_volume != mTuningMicVolume)
{
mTuningMicVolume = scaled_volume;
mTuningMicVolumeDirty = true;
}
}
void LLVoiceClient::tuningSetSpeakerVolume(float volume)
{
int scaled_volume = scale_speaker_volume(volume);
if(scaled_volume != mTuningSpeakerVolume)
{
mTuningSpeakerVolume = scaled_volume;
mTuningSpeakerVolumeDirty = true;
}
}
float LLVoiceClient::tuningGetEnergy(void)
{
return mTuningEnergy;
}
bool LLVoiceClient::deviceSettingsAvailable()
{
bool result = true;
if(!mConnected)
result = false;
if(mRenderDevices.empty())
result = false;
return result;
}
void LLVoiceClient::refreshDeviceLists(bool clearCurrentList)
{
if(clearCurrentList)
{
clearCaptureDevices();
clearRenderDevices();
}
getCaptureDevicesSendMessage();
getRenderDevicesSendMessage();
}
void LLVoiceClient::daemonDied()
{
// The daemon died, so the connection is gone. Reset everything and start over.
LL_WARNS("Voice") << "Connection to vivox daemon lost. Resetting state."<< LL_ENDL;
// Try to relaunch the daemon
setState(stateDisableCleanup);
}
void LLVoiceClient::giveUp()
{
// All has failed. Clean up and stop trying.
closeSocket();
deleteAllSessions();
deleteAllBuddies();
setState(stateJail);
}
static void oldSDKTransform (LLVector3 &left, LLVector3 &up, LLVector3 &at, LLVector3d &pos, LLVector3 &vel)
{
F32 nat[3], nup[3], nl[3], nvel[3]; // the new at, up, left vectors and the new position and velocity
F64 npos[3];
// The original XML command was sent like this:
/*
<< "<Position>"
<< "<X>" << pos[VX] << "</X>"
<< "<Y>" << pos[VZ] << "</Y>"
<< "<Z>" << pos[VY] << "</Z>"
<< "</Position>"
<< "<Velocity>"
<< "<X>" << mAvatarVelocity[VX] << "</X>"
<< "<Y>" << mAvatarVelocity[VZ] << "</Y>"
<< "<Z>" << mAvatarVelocity[VY] << "</Z>"
<< "</Velocity>"
<< "<AtOrientation>"
<< "<X>" << l.mV[VX] << "</X>"
<< "<Y>" << u.mV[VX] << "</Y>"
<< "<Z>" << a.mV[VX] << "</Z>"
<< "</AtOrientation>"
<< "<UpOrientation>"
<< "<X>" << l.mV[VZ] << "</X>"
<< "<Y>" << u.mV[VY] << "</Y>"
<< "<Z>" << a.mV[VZ] << "</Z>"
<< "</UpOrientation>"
<< "<LeftOrientation>"
<< "<X>" << l.mV [VY] << "</X>"
<< "<Y>" << u.mV [VZ] << "</Y>"
<< "<Z>" << a.mV [VY] << "</Z>"
<< "</LeftOrientation>";
*/
#if 1
// This was the original transform done when building the XML command
nat[0] = left.mV[VX];
nat[1] = up.mV[VX];
nat[2] = at.mV[VX];
nup[0] = left.mV[VZ];
nup[1] = up.mV[VY];
nup[2] = at.mV[VZ];
nl[0] = left.mV[VY];
nl[1] = up.mV[VZ];
nl[2] = at.mV[VY];
npos[0] = pos.mdV[VX];
npos[1] = pos.mdV[VZ];
npos[2] = pos.mdV[VY];
nvel[0] = vel.mV[VX];
nvel[1] = vel.mV[VZ];
nvel[2] = vel.mV[VY];
for(int i=0;i<3;++i) {
at.mV[i] = nat[i];
up.mV[i] = nup[i];
left.mV[i] = nl[i];
pos.mdV[i] = npos[i];
}
// This was the original transform done in the SDK
nat[0] = at.mV[2];
nat[1] = 0; // y component of at vector is always 0, this was up[2]
nat[2] = -1 * left.mV[2];
// We override whatever the application gives us
nup[0] = 0; // x component of up vector is always 0
nup[1] = 1; // y component of up vector is always 1
nup[2] = 0; // z component of up vector is always 0
nl[0] = at.mV[0];
nl[1] = 0; // y component of left vector is always zero, this was up[0]
nl[2] = -1 * left.mV[0];
npos[2] = pos.mdV[2] * -1.0;
npos[1] = pos.mdV[1];
npos[0] = pos.mdV[0];
for(int i=0;i<3;++i) {
at.mV[i] = nat[i];
up.mV[i] = nup[i];
left.mV[i] = nl[i];
pos.mdV[i] = npos[i];
}
#else
// This is the compose of the two transforms (at least, that's what I'm trying for)
nat[0] = at.mV[VX];
nat[1] = 0; // y component of at vector is always 0, this was up[2]
nat[2] = -1 * up.mV[VZ];
// We override whatever the application gives us
nup[0] = 0; // x component of up vector is always 0
nup[1] = 1; // y component of up vector is always 1
nup[2] = 0; // z component of up vector is always 0
nl[0] = left.mV[VX];
nl[1] = 0; // y component of left vector is always zero, this was up[0]
nl[2] = -1 * left.mV[VY];
npos[0] = pos.mdV[VX];
npos[1] = pos.mdV[VZ];
npos[2] = pos.mdV[VY] * -1.0;
nvel[0] = vel.mV[VX];
nvel[1] = vel.mV[VZ];
nvel[2] = vel.mV[VY];
for(int i=0;i<3;++i) {
at.mV[i] = nat[i];
up.mV[i] = nup[i];
left.mV[i] = nl[i];
pos.mdV[i] = npos[i];
}
#endif
}
void LLVoiceClient::sendPositionalUpdate(void)
{
std::ostringstream stream;
if(mSpatialCoordsDirty)
{
LLVector3 l, u, a, vel;
LLVector3d pos;
mSpatialCoordsDirty = false;
// Always send both speaker and listener positions together.
stream << "<Request requestId="" << mCommandCookie++ << "" action="Session.Set3DPosition.1">"
<< "<SessionHandle>" << getAudioSessionHandle() << "</SessionHandle>";
stream << "<SpeakerPosition>";
// LL_DEBUGS("Voice") << "Sending speaker position " << mAvatarPosition << LL_ENDL;
l = mAvatarRot.getLeftRow();
u = mAvatarRot.getUpRow();
a = mAvatarRot.getFwdRow();
pos = mAvatarPosition;
vel = mAvatarVelocity;
// SLIM SDK: the old SDK was doing a transform on the passed coordinates that the new one doesn't do anymore.
// The old transform is replicated by this function.
oldSDKTransform(l, u, a, pos, vel);
stream
<< "<Position>"
<< "<X>" << pos.mdV[VX] << "</X>"
<< "<Y>" << pos.mdV[VY] << "</Y>"
<< "<Z>" << pos.mdV[VZ] << "</Z>"
<< "</Position>"
<< "<Velocity>"
<< "<X>" << vel.mV[VX] << "</X>"
<< "<Y>" << vel.mV[VY] << "</Y>"
<< "<Z>" << vel.mV[VZ] << "</Z>"
<< "</Velocity>"
<< "<AtOrientation>"
<< "<X>" << a.mV[VX] << "</X>"
<< "<Y>" << a.mV[VY] << "</Y>"
<< "<Z>" << a.mV[VZ] << "</Z>"
<< "</AtOrientation>"
<< "<UpOrientation>"
<< "<X>" << u.mV[VX] << "</X>"
<< "<Y>" << u.mV[VY] << "</Y>"
<< "<Z>" << u.mV[VZ] << "</Z>"
<< "</UpOrientation>"
<< "<LeftOrientation>"
<< "<X>" << l.mV [VX] << "</X>"
<< "<Y>" << l.mV [VY] << "</Y>"
<< "<Z>" << l.mV [VZ] << "</Z>"
<< "</LeftOrientation>";
stream << "</SpeakerPosition>";
stream << "<ListenerPosition>";
LLVector3d earPosition;
LLVector3 earVelocity;
LLMatrix3 earRot;
switch(mEarLocation)
{
case earLocCamera:
default:
earPosition = mCameraPosition;
earVelocity = mCameraVelocity;
earRot = mCameraRot;
break;
case earLocAvatar:
earPosition = mAvatarPosition;
earVelocity = mAvatarVelocity;
earRot = mAvatarRot;
break;
case earLocMixed:
earPosition = mAvatarPosition;
earVelocity = mAvatarVelocity;
earRot = mCameraRot;
break;
}
l = earRot.getLeftRow();
u = earRot.getUpRow();
a = earRot.getFwdRow();
pos = earPosition;
vel = earVelocity;
// LL_DEBUGS("Voice") << "Sending listener position " << earPosition << LL_ENDL;
oldSDKTransform(l, u, a, pos, vel);
stream
<< "<Position>"
<< "<X>" << pos.mdV[VX] << "</X>"
<< "<Y>" << pos.mdV[VY] << "</Y>"
<< "<Z>" << pos.mdV[VZ] << "</Z>"
<< "</Position>"
<< "<Velocity>"
<< "<X>" << vel.mV[VX] << "</X>"
<< "<Y>" << vel.mV[VY] << "</Y>"
<< "<Z>" << vel.mV[VZ] << "</Z>"
<< "</Velocity>"
<< "<AtOrientation>"
<< "<X>" << a.mV[VX] << "</X>"
<< "<Y>" << a.mV[VY] << "</Y>"
<< "<Z>" << a.mV[VZ] << "</Z>"
<< "</AtOrientation>"
<< "<UpOrientation>"
<< "<X>" << u.mV[VX] << "</X>"
<< "<Y>" << u.mV[VY] << "</Y>"
<< "<Z>" << u.mV[VZ] << "</Z>"
<< "</UpOrientation>"
<< "<LeftOrientation>"
<< "<X>" << l.mV [VX] << "</X>"
<< "<Y>" << l.mV [VY] << "</Y>"
<< "<Z>" << l.mV [VZ] << "</Z>"
<< "</LeftOrientation>";
stream << "</ListenerPosition>";
stream << "</Request>nnn";
}
if(mAudioSession && mAudioSession->mVolumeDirty)
{
participantMap::iterator iter = mAudioSession->mParticipantsByURI.begin();
mAudioSession->mVolumeDirty = false;
for(; iter != mAudioSession->mParticipantsByURI.end(); iter++)
{
participantState *p = iter->second;
if(p->mVolumeDirty)
{
// Can't set volume/mute for yourself
if(!p->mIsSelf)
{
int volume = 56; // nominal default value
bool mute = p->mOnMuteList;
if(p->mUserVolume != -1)
{
// scale from user volume in the range 0-400 (with 100 as "normal") to vivox volume in the range 0-100 (with 56 as "normal")
if(p->mUserVolume < 100)
volume = (p->mUserVolume * 56) / 100;
else
volume = (((p->mUserVolume - 100) * (100 - 56)) / 300) + 56;
}
else if(p->mVolume != -1)
{
// Use the previously reported internal volume (comes in with a ParticipantUpdatedEvent)
volume = p->mVolume;
}
if(mute)
{
// SetParticipantMuteForMe doesn't work in p2p sessions.
// If we want the user to be muted, set their volume to 0 as well.
// This isn't perfect, but it will at least reduce their volume to a minimum.
volume = 0;
}
if(volume == 0)
mute = true;
LL_DEBUGS("Voice") << "Setting volume/mute for avatar " << p->mAvatarID << " to " << volume << (mute?"/true":"/false") << LL_ENDL;
// SLIM SDK: Send both volume and mute commands.
// Send a "volume for me" command for the user.
stream << "<Request requestId="" << mCommandCookie++ << "" action="Session.SetParticipantVolumeForMe.1">"
<< "<SessionHandle>" << getAudioSessionHandle() << "</SessionHandle>"
<< "<ParticipantURI>" << p->mURI << "</ParticipantURI>"
<< "<Volume>" << volume << "</Volume>"
<< "</Request>nnn";
if(!mAudioSession->mIsP2P)
{
// Send a "mute for me" command for the user
// Doesn't work in P2P sessions
stream << "<Request requestId="" << mCommandCookie++ << "" action="Session.SetParticipantMuteForMe.1">"
<< "<SessionHandle>" << getAudioSessionHandle() << "</SessionHandle>"
<< "<ParticipantURI>" << p->mURI << "</ParticipantURI>"
<< "<Mute>" << (mute?"1":"0") << "</Mute>"
<< "<Scope>Audio</Scope>"
<< "</Request>nnn";
}
}
p->mVolumeDirty = false;
}
}
}
buildLocalAudioUpdates(stream);
if(!stream.str().empty())
{
writeString(stream.str());
}
// Friends list updates can be huge, especially on the first voice login of an account with lots of friends.
// Batching them all together can choke SLVoice, so send them in separate writes.
sendFriendsListUpdates();
}
void LLVoiceClient::buildSetCaptureDevice(std::ostringstream &stream)
{
if(mCaptureDeviceDirty)
{
LL_DEBUGS("Voice") << "Setting input device = "" << mCaptureDevice << """ << LL_ENDL;
stream
<< "<Request requestId="" << mCommandCookie++ << "" action="Aux.SetCaptureDevice.1">"
<< "<CaptureDeviceSpecifier>" << mCaptureDevice << "</CaptureDeviceSpecifier>"
<< "</Request>"
<< "nnn";
mCaptureDeviceDirty = false;
}
}
void LLVoiceClient::buildSetRenderDevice(std::ostringstream &stream)
{
if(mRenderDeviceDirty)
{
LL_DEBUGS("Voice") << "Setting output device = "" << mRenderDevice << """ << LL_ENDL;
stream
<< "<Request requestId="" << mCommandCookie++ << "" action="Aux.SetRenderDevice.1">"
<< "<RenderDeviceSpecifier>" << mRenderDevice << "</RenderDeviceSpecifier>"
<< "</Request>"
<< "nnn";
mRenderDeviceDirty = false;
}
}
void LLVoiceClient::buildLocalAudioUpdates(std::ostringstream &stream)
{
buildSetCaptureDevice(stream);
buildSetRenderDevice(stream);
if(mPTTDirty)
{
mPTTDirty = false;
// Send a local mute command.
// NOTE that the state of "PTT" is the inverse of "local mute".
// (i.e. when PTT is true, we send a mute command with "false", and vice versa)
LL_DEBUGS("Voice") << "Sending MuteLocalMic command with parameter " << (mPTT?"false":"true") << LL_ENDL;
stream << "<Request requestId="" << mCommandCookie++ << "" action="Connector.MuteLocalMic.1">"
<< "<ConnectorHandle>" << mConnectorHandle << "</ConnectorHandle>"
<< "<Value>" << (mPTT?"false":"true") << "</Value>"
<< "</Request>nnn";
}
if(mSpeakerMuteDirty)
{
const char *muteval = ((mSpeakerVolume <= scale_speaker_volume(0))?"true":"false");
mSpeakerMuteDirty = false;
LL_INFOS("Voice") << "Setting speaker mute to " << muteval << LL_ENDL;
stream << "<Request requestId="" << mCommandCookie++ << "" action="Connector.MuteLocalSpeaker.1">"
<< "<ConnectorHandle>" << mConnectorHandle << "</ConnectorHandle>"
<< "<Value>" << muteval << "</Value>"
<< "</Request>nnn";
}
if(mSpeakerVolumeDirty)
{
mSpeakerVolumeDirty = false;
LL_INFOS("Voice") << "Setting speaker volume to " << mSpeakerVolume << LL_ENDL;
stream << "<Request requestId="" << mCommandCookie++ << "" action="Connector.SetLocalSpeakerVolume.1">"
<< "<ConnectorHandle>" << mConnectorHandle << "</ConnectorHandle>"
<< "<Value>" << mSpeakerVolume << "</Value>"
<< "</Request>nnn";
}
if(mMicVolumeDirty)
{
mMicVolumeDirty = false;
LL_INFOS("Voice") << "Setting mic volume to " << mMicVolume << LL_ENDL;
stream << "<Request requestId="" << mCommandCookie++ << "" action="Connector.SetLocalMicVolume.1">"
<< "<ConnectorHandle>" << mConnectorHandle << "</ConnectorHandle>"
<< "<Value>" << mMicVolume << "</Value>"
<< "</Request>nnn";
}
}
void LLVoiceClient::checkFriend(const LLUUID& id)
{
std::string name;
buddyListEntry *buddy = findBuddy(id);
// Make sure we don't add a name before it's been looked up.
if(gCacheName->getFullName(id, name))
{
const LLRelationship* relationInfo = LLAvatarTracker::instance().getBuddyInfo(id);
bool canSeeMeOnline = false;
if(relationInfo && relationInfo->isRightGrantedTo(LLRelationship::GRANT_ONLINE_STATUS))
canSeeMeOnline = true;
// When we get here, mNeedsSend is true and mInSLFriends is false. Change them as necessary.
if(buddy)
{
// This buddy is already in both lists.
if(name != buddy->mDisplayName)
{
// The buddy is in the list with the wrong name. Update it with the correct name.
LL_WARNS("Voice") << "Buddy " << id << " has wrong name ("" << buddy->mDisplayName << "" should be "" << name << ""), updating."<< LL_ENDL;
buddy->mDisplayName = name;
buddy->mNeedsNameUpdate = true; // This will cause the buddy to be resent.
}
}
else
{
// This buddy was not in the vivox list, needs to be added.
buddy = addBuddy(sipURIFromID(id), name);
buddy->mUUID = id;
}
// In all the above cases, the buddy is in the SL friends list (which is how we got here).
buddy->mInSLFriends = true;
buddy->mCanSeeMeOnline = canSeeMeOnline;
buddy->mNameResolved = true;
}
else
{
// This name hasn't been looked up yet. Don't do anything with this buddy list entry until it has.
if(buddy)
{
buddy->mNameResolved = false;
}
// Initiate a lookup.
// The "lookup completed" callback will ensure that the friends list is rechecked after it completes.
lookupName(id);