626 lines
21 KiB
C++
626 lines
21 KiB
C++
/**
|
|
* @file llvoiceclient.h
|
|
* @brief Declaration of LLVoiceClient class which is the interface to the voice client process.
|
|
*
|
|
* $LicenseInfo:firstyear=2001&license=viewerlgpl$
|
|
* Second Life Viewer Source Code
|
|
* Copyright (C) 2010, Linden Research, Inc.
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation;
|
|
* version 2.1 of the License only.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*
|
|
* Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA
|
|
* $/LicenseInfo$
|
|
*/
|
|
#ifndef LL_VOICE_CLIENT_H
|
|
#define LL_VOICE_CLIENT_H
|
|
|
|
class LLVOAvatar;
|
|
|
|
#include "lliopipe.h"
|
|
#include "llpumpio.h"
|
|
#include "llchainio.h"
|
|
#include "lliosocket.h"
|
|
#include "v3math.h"
|
|
#include "llframetimer.h"
|
|
#include "llsingleton.h"
|
|
#include "llcallingcard.h" // for LLFriendObserver
|
|
#include "llsecapi.h"
|
|
#include "llcontrol.h"
|
|
|
|
// devices
|
|
|
|
class LLVoiceDevice
|
|
{
|
|
public:
|
|
std::string display_name; // friendly value for the user
|
|
std::string full_name; // internal value for selection
|
|
|
|
LLVoiceDevice(const std::string& display_name, const std::string& full_name)
|
|
:display_name(display_name)
|
|
,full_name(full_name)
|
|
{
|
|
};
|
|
};
|
|
typedef std::vector<LLVoiceDevice> LLVoiceDeviceList;
|
|
|
|
// <FS:Ansariel> Add callback for user volume change
|
|
typedef boost::signals2::signal<void(const LLUUID&)> user_voice_volume_change_callback_t;
|
|
|
|
class LLVoiceClientParticipantObserver
|
|
{
|
|
public:
|
|
virtual ~LLVoiceClientParticipantObserver() { }
|
|
virtual void onParticipantsChanged() = 0;
|
|
};
|
|
|
|
|
|
///////////////////////////////////
|
|
/// @class LLVoiceClientStatusObserver
|
|
class LLVoiceClientStatusObserver
|
|
{
|
|
public:
|
|
typedef enum e_voice_status_type
|
|
{
|
|
// NOTE: when updating this enum, please also update the switch in
|
|
// LLVoiceClientStatusObserver::status2string().
|
|
STATUS_LOGIN_RETRY,
|
|
STATUS_LOGGED_IN,
|
|
STATUS_JOINING,
|
|
STATUS_JOINED,
|
|
STATUS_LEFT_CHANNEL,
|
|
STATUS_VOICE_DISABLED,
|
|
STATUS_VOICE_ENABLED,
|
|
BEGIN_ERROR_STATUS,
|
|
ERROR_CHANNEL_FULL,
|
|
ERROR_CHANNEL_LOCKED,
|
|
ERROR_NOT_AVAILABLE,
|
|
ERROR_UNKNOWN
|
|
} EStatusType;
|
|
|
|
virtual ~LLVoiceClientStatusObserver() { }
|
|
virtual void onChange(EStatusType status, const LLSD& channelInfo, bool proximal) = 0;
|
|
|
|
static std::string status2string(EStatusType inStatus);
|
|
};
|
|
|
|
struct LLVoiceVersionInfo
|
|
{
|
|
std::string voiceServerType;
|
|
std::string internalVoiceServerType;
|
|
int majorVersion;
|
|
int minorVersion;
|
|
std::string serverVersion;
|
|
std::string mBuildVersion;
|
|
};
|
|
|
|
//////////////////////////////////
|
|
/// @class LLVoiceP2POutgoingCallInterface
|
|
/// @brief Outgoing call interface
|
|
///
|
|
/// For providers that support P2P signaling (vivox)
|
|
/////////////////////////////////
|
|
|
|
class LLVoiceP2POutgoingCallInterface
|
|
{
|
|
public:
|
|
// initiate an outgoing call to a user
|
|
virtual void callUser(const LLUUID &agentID) = 0;
|
|
virtual void hangup() = 0;
|
|
};
|
|
|
|
//////////////////////////////////
|
|
/// @class LLVoiceP2PIncomingCallInterface
|
|
/// @brief Incoming call interface
|
|
///
|
|
/// For providers that support P2P signaling (vivox)
|
|
/////////////////////////////////
|
|
class LLVoiceP2PIncomingCallInterface
|
|
{
|
|
public:
|
|
virtual ~LLVoiceP2PIncomingCallInterface() {}
|
|
|
|
virtual bool answerInvite() = 0;
|
|
virtual void declineInvite() = 0;
|
|
};
|
|
|
|
typedef std::shared_ptr<LLVoiceP2PIncomingCallInterface> LLVoiceP2PIncomingCallInterfacePtr;
|
|
|
|
//////////////////////////////////
|
|
/// @class LLVoiceModuleInterface
|
|
/// @brief Voice module interface
|
|
///
|
|
/// Voice modules should provide an implementation for this interface.
|
|
/////////////////////////////////
|
|
|
|
class LLVoiceModuleInterface
|
|
{
|
|
public:
|
|
LLVoiceModuleInterface() {}
|
|
virtual ~LLVoiceModuleInterface() {}
|
|
|
|
virtual void init(LLPumpIO *pump)=0; // Call this once at application startup (creates connector)
|
|
virtual void terminate()=0; // Call this to clean up during shutdown
|
|
|
|
virtual void updateSettings()=0; // call after loading settings and whenever they change
|
|
|
|
virtual bool isVoiceWorking() const = 0; // connected to a voice server and voice channel
|
|
|
|
virtual void setHidden(bool hidden)=0; // Hides the user from voice.
|
|
|
|
virtual const LLVoiceVersionInfo& getVersion()=0;
|
|
|
|
|
|
|
|
/////////////////////
|
|
/// @name Tuning
|
|
//@{
|
|
virtual void tuningStart()=0;
|
|
virtual void tuningStop()=0;
|
|
virtual bool inTuningMode()=0;
|
|
|
|
virtual void tuningSetMicVolume(float volume)=0;
|
|
virtual void tuningSetSpeakerVolume(float volume)=0;
|
|
virtual float tuningGetEnergy(void)=0;
|
|
//@}
|
|
|
|
/////////////////////
|
|
/// @name Devices
|
|
//@{
|
|
// This returns true when it's safe to bring up the "device settings" dialog in the prefs.
|
|
// i.e. when the daemon is running and connected, and the device lists are populated.
|
|
virtual bool deviceSettingsAvailable()=0;
|
|
virtual bool deviceSettingsUpdated() = 0;
|
|
|
|
// Requery the vivox daemon for the current list of input/output devices.
|
|
// If you pass true for clearCurrentList, deviceSettingsAvailable() will be false until the query has completed
|
|
// (use this if you want to know when it's done).
|
|
// If you pass false, you'll have no way to know when the query finishes, but the device lists will not appear empty in the interim.
|
|
virtual void refreshDeviceLists(bool clearCurrentList = true)=0;
|
|
|
|
virtual void setCaptureDevice(const std::string& name)=0;
|
|
virtual void setRenderDevice(const std::string& name)=0;
|
|
|
|
virtual LLVoiceDeviceList& getCaptureDevices()=0;
|
|
virtual LLVoiceDeviceList& getRenderDevices()=0;
|
|
|
|
virtual void getParticipantList(std::set<LLUUID> &participants)=0;
|
|
virtual bool isParticipant(const LLUUID& speaker_id)=0;
|
|
//@}
|
|
|
|
////////////////////////////
|
|
/// @ name Channel stuff
|
|
//@{
|
|
// returns true iff the user is currently in a proximal (local spatial) channel.
|
|
// Note that gestures should only fire if this returns true.
|
|
virtual bool inProximalChannel()=0;
|
|
|
|
virtual void setNonSpatialChannel(const LLSD& channelInfo,
|
|
bool notify_on_first_join,
|
|
bool hangup_on_last_leave)=0;
|
|
|
|
virtual bool setSpatialChannel(const LLSD& channelInfo)=0;
|
|
|
|
virtual void leaveNonSpatialChannel() = 0;
|
|
virtual void processChannels(bool process) = 0;
|
|
|
|
virtual bool isCurrentChannel(const LLSD &channelInfo) = 0;
|
|
virtual bool compareChannels(const LLSD &channelInfo1, const LLSD &channelInfo2) = 0;
|
|
|
|
//@}
|
|
|
|
|
|
//////////////////////////
|
|
/// @name p2p
|
|
//@{
|
|
|
|
// initiate a call with a peer using the P2P interface, which only applies to some
|
|
// voice server types. Otherwise, a group call should be used for P2P
|
|
virtual LLVoiceP2POutgoingCallInterface* getOutgoingCallInterface() = 0;
|
|
|
|
// an incoming call was received, and the incoming call dialogue is asking for an interface to
|
|
// answer or decline.
|
|
virtual LLVoiceP2PIncomingCallInterfacePtr getIncomingCallInterface(const LLSD &voice_call_info) = 0;
|
|
//@}
|
|
|
|
/////////////////////////
|
|
/// @name Volume/gain
|
|
//@{
|
|
virtual void setVoiceVolume(F32 volume)=0;
|
|
virtual void setMicGain(F32 volume)=0;
|
|
//@}
|
|
|
|
/////////////////////////
|
|
/// @name enable disable voice and features
|
|
//@{
|
|
virtual void setVoiceEnabled(bool enabled)=0;
|
|
virtual void setMuteMic(bool muted)=0; // Set the mute state of the local mic.
|
|
//@}
|
|
|
|
//////////////////////////
|
|
/// @name nearby speaker accessors
|
|
//@{
|
|
virtual std::string getDisplayName(const LLUUID& id)=0;
|
|
virtual bool isParticipantAvatar(const LLUUID &id)=0;
|
|
virtual bool getIsSpeaking(const LLUUID& id)=0;
|
|
virtual bool getIsModeratorMuted(const LLUUID& id)=0;
|
|
virtual F32 getCurrentPower(const LLUUID& id)=0; // "power" is related to "amplitude" in a defined way. I'm just not sure what the formula is...
|
|
virtual F32 getUserVolume(const LLUUID& id)=0;
|
|
virtual void setUserVolume(const LLUUID& id, F32 volume)=0; // set's volume for specified agent, from 0-1 (where .5 is nominal)
|
|
//@}
|
|
|
|
//////////////////////////
|
|
/// @name text chat
|
|
//@{
|
|
virtual bool isSessionTextIMPossible(const LLUUID& id)=0;
|
|
virtual bool isSessionCallBackPossible(const LLUUID& id)=0;
|
|
//virtual bool sendTextMessage(const LLUUID& participant_id, const std::string& message)=0;
|
|
//@}
|
|
|
|
// authorize the user
|
|
virtual void userAuthorized(const std::string& user_id,
|
|
const LLUUID &agentID)=0;
|
|
|
|
//////////////////////////////
|
|
/// @name Status notification
|
|
//@{
|
|
virtual void addObserver(LLVoiceClientStatusObserver* observer)=0;
|
|
virtual void removeObserver(LLVoiceClientStatusObserver* observer)=0;
|
|
virtual void addObserver(LLFriendObserver* observer)=0;
|
|
virtual void removeObserver(LLFriendObserver* observer)=0;
|
|
virtual void addObserver(LLVoiceClientParticipantObserver* observer)=0;
|
|
virtual void removeObserver(LLVoiceClientParticipantObserver* observer)=0;
|
|
//@}
|
|
|
|
virtual std::string sipURIFromID(const LLUUID &id) const=0;
|
|
virtual LLSD getP2PChannelInfoTemplate(const LLUUID& id) const=0;
|
|
//@}
|
|
|
|
};
|
|
|
|
|
|
//////////////////////////////////
|
|
/// @class LLVoiceEffectObserver
|
|
class LLVoiceEffectObserver
|
|
{
|
|
public:
|
|
virtual ~LLVoiceEffectObserver() { }
|
|
virtual void onVoiceEffectChanged(bool effect_list_updated) = 0;
|
|
};
|
|
|
|
typedef std::multimap<const std::string, const LLUUID, LLDictionaryLess> voice_effect_list_t;
|
|
|
|
//////////////////////////////////
|
|
/// @class LLVoiceEffectInterface
|
|
/// @brief Voice effect module interface
|
|
///
|
|
/// Voice effect modules should provide an implementation for this interface.
|
|
/////////////////////////////////
|
|
|
|
class LLVoiceEffectInterface
|
|
{
|
|
public:
|
|
LLVoiceEffectInterface() {}
|
|
virtual ~LLVoiceEffectInterface() {}
|
|
|
|
//////////////////////////
|
|
/// @name Accessors
|
|
//@{
|
|
virtual bool setVoiceEffect(const LLUUID& id) = 0;
|
|
virtual const LLUUID getVoiceEffect() = 0;
|
|
virtual LLSD getVoiceEffectProperties(const LLUUID& id) = 0;
|
|
|
|
virtual void refreshVoiceEffectLists(bool clear_lists) = 0;
|
|
virtual const voice_effect_list_t &getVoiceEffectList() const = 0;
|
|
virtual const voice_effect_list_t &getVoiceEffectTemplateList() const = 0;
|
|
//@}
|
|
|
|
//////////////////////////////
|
|
/// @name Status notification
|
|
//@{
|
|
virtual void addObserver(LLVoiceEffectObserver* observer) = 0;
|
|
virtual void removeObserver(LLVoiceEffectObserver* observer) = 0;
|
|
//@}
|
|
|
|
//////////////////////////////
|
|
/// @name Preview buffer
|
|
//@{
|
|
virtual void enablePreviewBuffer(bool enable) = 0;
|
|
virtual void recordPreviewBuffer() = 0;
|
|
virtual void playPreviewBuffer(const LLUUID& effect_id = LLUUID::null) = 0;
|
|
virtual void stopPreviewBuffer() = 0;
|
|
|
|
virtual bool isPreviewRecording() = 0;
|
|
virtual bool isPreviewPlaying() = 0;
|
|
//@}
|
|
};
|
|
|
|
|
|
// <FS:Ansariel> Centralized voice power level
|
|
typedef enum e_voice_power_level
|
|
{
|
|
VPL_MUTED,
|
|
VPL_PTT_Off,
|
|
VPL_PTT_On,
|
|
VPL_Level1,
|
|
VPL_Level2,
|
|
VPL_Level3
|
|
} EVoicePowerLevel;
|
|
// </FS:Ansariel> Centralized voice power level
|
|
|
|
class LLVoiceClient: public LLParamSingleton<LLVoiceClient>
|
|
{
|
|
LLSINGLETON(LLVoiceClient, LLPumpIO *pump);
|
|
LOG_CLASS(LLVoiceClient);
|
|
~LLVoiceClient();
|
|
|
|
public:
|
|
typedef boost::signals2::signal<void(void)> micro_changed_signal_t;
|
|
micro_changed_signal_t mMicroChangedSignal;
|
|
|
|
void terminate(); // Call this to clean up during shutdown
|
|
|
|
const LLVoiceVersionInfo getVersion();
|
|
|
|
static const F32 OVERDRIVEN_POWER_LEVEL;
|
|
|
|
// <FS:Ansariel> Centralized voice power level
|
|
static const F32 POWER_LEVEL_0;
|
|
static const F32 POWER_LEVEL_1;
|
|
static const F32 POWER_LEVEL_2;
|
|
// </FS:Ansariel> Centralized voice power level
|
|
|
|
static const F32 VOLUME_MIN;
|
|
static const F32 VOLUME_DEFAULT;
|
|
static const F32 VOLUME_MAX;
|
|
|
|
void updateSettings(); // call after loading settings and whenever they change
|
|
|
|
bool isVoiceWorking() const; // connected to a voice server and voice channel
|
|
|
|
// tuning
|
|
void tuningStart();
|
|
void tuningStop();
|
|
bool inTuningMode();
|
|
|
|
void tuningSetMicVolume(float volume);
|
|
void tuningSetSpeakerVolume(float volume);
|
|
float tuningGetEnergy(void);
|
|
|
|
// devices
|
|
|
|
// This returns true when it's safe to bring up the "device settings" dialog in the prefs.
|
|
// i.e. when the daemon is running and connected, and the device lists are populated.
|
|
bool deviceSettingsAvailable();
|
|
bool deviceSettingsUpdated(); // returns true when the device list has been updated recently.
|
|
|
|
// Requery the vivox daemon for the current list of input/output devices.
|
|
// If you pass true for clearCurrentList, deviceSettingsAvailable() will be false until the query has completed
|
|
// (use this if you want to know when it's done).
|
|
// If you pass false, you'll have no way to know when the query finishes, but the device lists will not appear empty in the interim.
|
|
void refreshDeviceLists(bool clearCurrentList = true);
|
|
|
|
void setCaptureDevice(const std::string& name);
|
|
void setRenderDevice(const std::string& name);
|
|
void setHidden(bool hidden);
|
|
|
|
const LLVoiceDeviceList& getCaptureDevices();
|
|
const LLVoiceDeviceList& getRenderDevices();
|
|
|
|
////////////////////////////
|
|
// Channel stuff
|
|
//
|
|
|
|
// returns true iff the user is currently in a proximal (local spatial) channel.
|
|
// Note that gestures should only fire if this returns true.
|
|
bool inProximalChannel();
|
|
|
|
void setNonSpatialChannel(const LLSD& channelInfo,
|
|
bool notify_on_first_join,
|
|
bool hangup_on_last_leave);
|
|
|
|
void setSpatialChannel(const LLSD &channelInfo);
|
|
|
|
void activateSpatialChannel(bool activate);
|
|
|
|
void leaveNonSpatialChannel();
|
|
|
|
bool isCurrentChannel(const LLSD& channelInfo);
|
|
|
|
bool compareChannels(const LLSD& channelInfo1, const LLSD& channelInfo2);
|
|
|
|
// initiate a call with a peer using the P2P interface, which only applies to some
|
|
// voice server types. Otherwise, a group call should be used for P2P
|
|
LLVoiceP2POutgoingCallInterface* getOutgoingCallInterface(const LLSD& voiceChannelInfo = LLSD());
|
|
|
|
LLVoiceP2PIncomingCallInterfacePtr getIncomingCallInterface(const LLSD &voiceCallInfo);
|
|
|
|
/////////////////////////////
|
|
// Sending updates of current state
|
|
|
|
|
|
void setVoiceVolume(F32 volume);
|
|
void setMicGain(F32 volume);
|
|
void setUserVolume(const LLUUID& id, F32 volume); // set's volume for specified agent, from 0-1 (where .5 is nominal)
|
|
// <FS:Ansariel> Bypass LLCachedControls for voice status update
|
|
//bool voiceEnabled();
|
|
bool voiceEnabled(bool no_cache = false);
|
|
// </FS:Ansariel>
|
|
void setMuteMic(bool muted); // Use this to mute the local mic (for when the client is minimized, etc), ignoring user PTT state.
|
|
void setUserPTTState(bool ptt);
|
|
bool getUserPTTState();
|
|
void toggleUserPTTState(void);
|
|
void inputUserControlState(bool down); // interpret any sort of up-down mic-open control input according to ptt-toggle prefs
|
|
static void setVoiceEnabled(bool enabled);
|
|
|
|
void setUsePTT(bool usePTT);
|
|
void setPTTIsToggle(bool PTTIsToggle);
|
|
bool getPTTIsToggle();
|
|
|
|
void updateMicMuteLogic();
|
|
|
|
boost::signals2::connection MicroChangedCallback(const micro_changed_signal_t::slot_type& cb ) { return mMicroChangedSignal.connect(cb); }
|
|
|
|
// <FS:Ansariel> Add callback for user volume change
|
|
static boost::signals2::connection setUserVolumeUpdateCallback(const user_voice_volume_change_callback_t::slot_type& cb);
|
|
static user_voice_volume_change_callback_t sUserVolumeUpdateSignal;
|
|
|
|
/////////////////////////////
|
|
// Accessors for data related to nearby speakers
|
|
bool getVoiceEnabled(const LLUUID& id) const; // true if we've received data for this avatar
|
|
std::string getDisplayName(const LLUUID& id) const;
|
|
bool isOnlineSIP(const LLUUID &id);
|
|
bool isParticipantAvatar(const LLUUID &id);
|
|
bool getIsSpeaking(const LLUUID& id);
|
|
bool getIsModeratorMuted(const LLUUID& id);
|
|
F32 getCurrentPower(const LLUUID& id); // "power" is related to "amplitude" in a defined way. I'm just not sure what the formula is...
|
|
bool getOnMuteList(const LLUUID& id);
|
|
F32 getUserVolume(const LLUUID& id);
|
|
|
|
// <FS:Ansariel> Centralized voice power level
|
|
EVoicePowerLevel getPowerLevel(const LLUUID& id);
|
|
// </FS:Ansariel> Centralized voice power level
|
|
|
|
/////////////////////////////
|
|
void getParticipantList(std::set<LLUUID> &participants) const;
|
|
bool isParticipant(const LLUUID& speaker_id) const;
|
|
|
|
//////////////////////////
|
|
/// @name text chat
|
|
//@{
|
|
bool isSessionTextIMPossible(const LLUUID& id);
|
|
bool isSessionCallBackPossible(const LLUUID& id);
|
|
//bool sendTextMessage(const LLUUID& participant_id, const std::string& message) const {return true;} ;
|
|
//@}
|
|
|
|
void setSpatialVoiceModule(const std::string& voice_server_type);
|
|
void setNonSpatialVoiceModule(const std::string &voice_server_type);
|
|
|
|
void userAuthorized(const std::string& user_id,
|
|
const LLUUID &agentID);
|
|
|
|
void onRegionChanged();
|
|
|
|
static void addObserver(LLVoiceClientStatusObserver* observer);
|
|
static void removeObserver(LLVoiceClientStatusObserver* observer);
|
|
static void addObserver(LLFriendObserver* observer);
|
|
static void removeObserver(LLFriendObserver* observer);
|
|
static void addObserver(LLVoiceClientParticipantObserver* observer);
|
|
static void removeObserver(LLVoiceClientParticipantObserver* observer);
|
|
|
|
std::string sipURIFromID(const LLUUID &id) const;
|
|
LLSD getP2PChannelInfoTemplate(const LLUUID& id) const;
|
|
|
|
//////////////////////////
|
|
/// @name Voice effects
|
|
//@{
|
|
bool getVoiceEffectEnabled() const { return mVoiceEffectEnabled; };
|
|
LLUUID getVoiceEffectDefault() const { return LLUUID(mVoiceEffectDefault); };
|
|
|
|
// Returns NULL if voice effects are not supported, or not enabled.
|
|
LLVoiceEffectInterface* getVoiceEffectInterface() const;
|
|
//@}
|
|
|
|
void handleSimulatorFeaturesReceived(const LLSD &simulatorFeatures);
|
|
|
|
private:
|
|
|
|
void init(LLPumpIO *pump);
|
|
|
|
protected:
|
|
|
|
static bool onVoiceEffectsNotSupported(const LLSD ¬ification, const LLSD &response);
|
|
|
|
LLVoiceModuleInterface* mSpatialVoiceModule;
|
|
LLVoiceModuleInterface* mNonSpatialVoiceModule;
|
|
LLSD mSpatialCredentials; // used to store spatial credentials for vivox
|
|
// so they're available when the region voice
|
|
// server is retrieved.
|
|
LLPumpIO *m_servicePump;
|
|
|
|
boost::signals2::connection mSimulatorFeaturesReceivedSlot;
|
|
boost::signals2::connection mRegionChangedCallbackSlot;
|
|
|
|
LLCachedControl<bool> mVoiceEffectEnabled;
|
|
LLCachedControl<std::string> mVoiceEffectDefault;
|
|
bool mVoiceEffectSupportNotified;
|
|
|
|
bool mPTTDirty;
|
|
bool mPTT;
|
|
|
|
bool mUsePTT;
|
|
S32 mPTTMouseButton;
|
|
KEY mPTTKey;
|
|
bool mPTTIsToggle;
|
|
bool mUserPTTState;
|
|
bool mMuteMic;
|
|
bool mDisableMic;
|
|
};
|
|
|
|
/**
|
|
* Speaker volume storage helper class
|
|
**/
|
|
class LLSpeakerVolumeStorage : public LLSingleton<LLSpeakerVolumeStorage>
|
|
{
|
|
LLSINGLETON(LLSpeakerVolumeStorage);
|
|
~LLSpeakerVolumeStorage();
|
|
LOG_CLASS(LLSpeakerVolumeStorage);
|
|
|
|
protected:
|
|
virtual void cleanupSingleton() override;
|
|
|
|
public:
|
|
|
|
/**
|
|
* Stores volume level for specified user.
|
|
*
|
|
* @param[in] speaker_id - LLUUID of user to store volume level for.
|
|
* @param[in] volume - volume level to be stored for user.
|
|
*/
|
|
void storeSpeakerVolume(const LLUUID& speaker_id, F32 volume);
|
|
|
|
/**
|
|
* Gets stored volume level for specified speaker
|
|
*
|
|
* @param[in] speaker_id - LLUUID of user to retrieve volume level for.
|
|
* @param[out] volume - set to stored volume if found, otherwise unmodified.
|
|
* @return - true if a stored volume is found.
|
|
*/
|
|
bool getSpeakerVolume(const LLUUID& speaker_id, F32& volume);
|
|
|
|
/**
|
|
* Removes stored volume level for specified user.
|
|
*
|
|
* @param[in] speaker_id - LLUUID of user to remove.
|
|
*/
|
|
void removeSpeakerVolume(const LLUUID& speaker_id);
|
|
|
|
private:
|
|
const static std::string SETTINGS_FILE_NAME;
|
|
|
|
void load();
|
|
void save();
|
|
|
|
static F32 transformFromLegacyVolume(F32 volume_in);
|
|
static F32 transformToLegacyVolume(F32 volume_in);
|
|
|
|
typedef std::map<LLUUID, F32> speaker_data_map_t;
|
|
speaker_data_map_t mSpeakersData;
|
|
};
|
|
|
|
#endif //LL_VOICE_CLIENT_H
|
|
|
|
|
|
|