def initialize(self, domain):
LOG_VOIP_INT('VOIPManager.Initialize')
assert self.__initialized is False
self.__voipDomain = domain
self.__testDomain = 'sip:confctl-2@' + self.__voipDomain.partition(
'www.')[2]
LOG_VOIP_INT("voip_domain: '%s'" % self.__voipDomain)
LOG_VOIP_INT("test_domain: '%s'" % self.__testDomain)
self.__fsm.update(self)
logLevel = 0
section = Settings.g_instance.userPrefs
if section.has_key('development'):
section = section['development']
if section.has_key('vivoxLogLevel'):
logLevel = section['vivoxLogLevel'].asInt
vinit = {
KEY_SERVER: 'http://%s/api2' % self.__voipDomain,
KEY_MIN_PORT: '0',
KEY_MAX_PORT: '0',
KEY_LOG_PREFIX: 'voip',
KEY_LOG_SUFFIX: '.txt',
KEY_LOG_FOLDER: '.',
KEY_LOG_LEVEL: str(logLevel)
}
BigWorld.VOIP.initialise(vinit)
def onNetworkTest(self, data):
returnCode = int(data[KEY_RETURN_CODE])
if returnCode == CODE_ERROR:
LOG_VOIP_INT('---------------------------')
LOG_VOIP_INT("ERROR: '%d' - '%s'" % (int(data[KEY_STATUS_CODE]), data[KEY_STATUS_STRING]))
LOG_VOIP_INT('---------------------------')
self.onFailedToConnect()
self.__clearDesiredChannel()
self.__clearUser()
def onVoipInited(self, data):
returnCode = int(data[KEY_RETURN_CODE])
if returnCode == CODE_SUCCESS:
self.__initialized = True
self.__fsm.update(self)
self.onInitialized(data)
else:
self.__initialized = False
self.__fsm.reset()
LOG_VOIP_INT('---------------------------')
LOG_VOIP_INT("ERROR: '%d' - '%s'" % (int(data[KEY_STATUS_CODE]), data[KEY_STATUS_STRING]))
LOG_VOIP_INT('---------------------------')
def __call__(self, message, data={}):
if message is not MSG_PARTICIPANT_UPDATED:
LOG_VOIP_INT('Message: %d [%s], Data: %s' %
(message, MESSAGE_IDS[message], data))
if message == MSG_VOIP_INITED:
self.onVoipInited(data)
elif message == MSG_VOIP_DESTROYED:
self.onVoipDestroyed(data)
elif message == MSG_CAPTURE_DEVICES:
self.onCaptureDevicesArrived(data)
elif message == MSG_SET_CAPTURE_DEVICE:
self.onSetCaptureDevice(data)
elif message == MSG_SET_LOCAL_SPEAKER_VOLUME:
self.onSetLocalSpeakerVolume(data)
elif message == MSG_SET_LOCAL_MIC_VOLUME:
self.onSetLocalMicVolume(data)
elif message == MSG_MUTE_LOCAL_MIC:
self.onMuteLocalMic(data)
elif message == MSG_LOGIN_STATE_CHANGE:
self.onLoginStateChange(data)
elif message == MSG_SESSION_ADDED:
self.onSessionAdded(data)
elif message == MSG_SESSION_REMOVED:
self.onSessionRemoved(data)
elif message == MSG_NETWORK_TEST:
self.onNetworkTest(data)
elif message == MSG_PARTICIPANT_ADDED:
self.onParticipantAdded(data)
elif message == MSG_PARTICIPANT_REMOVED:
self.onParticipantRemoved(data)
elif message == MSG_PARTICIPANT_UPDATED:
self.onParticipantUpdated(data)
def __init__(self):
LOG_VOIP_INT('VOIPManager.Create')
super(VOIPManager, self).__init__()
self.__initialized = False
self.__enabled = False
self.__voipDomain = ''
self.__testDomain = ''
self.__user = ['', '']
self.__channel = ['', '']
self.__currentChannel = ''
self.__inTesting = False
self.__loggedIn = False
self.__needLogginAfterInit = False
self.__loginAttemptsRemained = 2
self.__fsm = VOIPFsm()
self.__activateMicByVoice = False
self.__captureDevices = []
self.__currentCaptureDevice = ''
self.__channelUsers = {}
self.onCaptureDevicesUpdated = Event.Event()
self.onPlayerSpeaking = Event.Event()
self.onInitialized = Event.Event()
self.onStateToggled = Event.Event()
self.onFailedToConnect = Event.Event()
self.onJoinedChannel = Event.Event()
self.onLeftChannel = Event.Event()
self.__fsm.onStateChanged += self.__onStateChanged
def update(self, voip):
if self.__state == _STATE.NONE:
self.__setState(_STATE.INITIALIZING)
elif self.__state == _STATE.INITIALIZING and voip.isInitialized():
self.__setState(_STATE.INITIALIZED)
elif self.__state == _STATE.INITIALIZED and voip.getUser() != '':
self.__setState(_STATE.LOGGING_IN)
elif self.__state == _STATE.LOGGING_IN and voip.isLoggedIn():
self.__setState(_STATE.LOGGED_IN)
elif self.__state == _STATE.LOGGING_IN and not voip.isLoggedIn():
self.__setState(_STATE.INITIALIZED)
elif self.__state == _STATE.LOGGED_IN and voip.hasDesiredChannel(
) and voip.isEnabled():
self.__setState(_STATE.JOINING_CHANNEL)
elif self.__state == _STATE.LOGGED_IN and voip.getUser() == '':
self.__setState(_STATE.LOGGING_OUT)
elif self.__state == _STATE.LOGGING_OUT and not voip.isLoggedIn():
self.__setState(_STATE.INITIALIZED)
elif self.__state == _STATE.JOINING_CHANNEL and voip.getCurrentChannel(
):
self.__setState(_STATE.JOINED_CHANNEL)
elif self.__state == _STATE.JOINING_CHANNEL and not voip.hasDesiredChannel(
):
self.__setState(_STATE.LEAVING_CHANNEL)
elif self.__state == _STATE.JOINED_CHANNEL and (
not voip.isInDesiredChannel() or not voip.isEnabled()
or not voip.getCurrentChannel()):
self.__setState(_STATE.LEAVING_CHANNEL)
elif self.__state == _STATE.LEAVING_CHANNEL and not voip.getCurrentChannel(
):
self.__setState(_STATE.LOGGED_IN)
else:
LOG_VOIP_INT('%s not changed' % _STATE_NAMES[self.__state])
def __enterChannel(self, channel, password):
if not self.__initialized and self.__fsm.inNoneState():
self.initialize(self.__voipDomain)
if not self.__user[0] and self.isEnabled():
self.__requestCredentials()
LOG_VOIP_INT("VOIPManager.EnterChannel: '%s' '%s'" % (channel, password))
self.__channel = [channel, password]
self.__fsm.update(self)
def __setState(self, newState):
if newState == self.__state:
return
LOG_VOIP_INT('%s -> %s' %
(_STATE_NAMES[self.__state], _STATE_NAMES[newState]))
oldState = self.__state
self.__state = newState
self.onStateChanged(oldState, newState)
def onDisconnected(self):
LOG_VOIP_INT('VOIPManager.Unsubscribe')
voipEvents = g_messengerEvents.voip
voipEvents.onChannelEntered -= self.__me_onChannelEntered
voipEvents.onChannelLeft -= self.__me_onChannelLeft
voipEvents.onCredentialReceived -= self.__me_onCredentialReceived
usersEvents = g_messengerEvents.users
usersEvents.onUsersListReceived -= self.__me_onUsersListReceived
usersEvents.onUserActionReceived -= self.__me_onUserActionReceived
def leaveTestChannel(self):
if not self.__inTesting:
return
LOG_VOIP_INT('VOIPManager.LeaveTestChannel')
self.__inTesting = False
params = self.bwProto.voipProvider.getChannelParams()
if params[0]:
self.__enterChannel(*params)
else:
self.__leaveChannel()
def __muteParticipantForMe(self, dbid, mute):
LOG_VOIP_INT('VOIPManager.MuteParticipantForMe: %d, %s' % (dbid, str(mute)))
raise dbid in self.__channelUsers or AssertionError
self.__channelUsers[dbid]['muted'] = mute
uri = self.__channelUsers[dbid]['uri']
cmd = {KEY_COMMAND: CMD_SET_PARTICIPANT_MUTE,
KEY_PARTICIPANT_URI: uri,
KEY_STATE: str(mute)}
BigWorld.VOIP.command(cmd)
return True
def onConnected(self):
LOG_VOIP_INT('VOIPManager.Subscribe')
self.__loginAttemptsRemained = 2
voipEvents = g_messengerEvents.voip
voipEvents.onChannelEntered += self.__me_onChannelEntered
voipEvents.onChannelLeft += self.__me_onChannelLeft
voipEvents.onCredentialReceived += self.__me_onCredentialReceived
usersEvents = g_messengerEvents.users
usersEvents.onUsersListReceived += self.__me_onUsersListReceived
usersEvents.onUserActionReceived += self.__me_onUserActionReceived
def onLoginStateChange(self, data):
returnCode = int(data[KEY_RETURN_CODE])
if returnCode == CODE_SUCCESS:
state = int(data[KEY_STATE])
if state == STATE_LOGGED_IN:
if self.getAPI() == VOIP_SUPPORTED_API.VIVOX:
self.bwProto.voipProvider.logVivoxLogin()
self.__loggedIn = True
self.__fsm.update(self)
elif state == STATE_LOGGED_OUT:
self.__loggedIn = False
self.__fsm.update(self)
else:
LOG_VOIP_INT('---------------------------')
LOG_VOIP_INT("ERROR: '%d' - '%s'" % (int(data[KEY_STATUS_CODE]), data[KEY_STATUS_STRING]))
LOG_VOIP_INT('---------------------------')
code = int(data[KEY_STATUS_CODE])
if (code == STATUS_WRONG_CREDENTIALS or code == STATUS_UNKNOWN_ACCOUNT) and self.__loginAttemptsRemained > 0:
self.__reloginUser()
else:
self.onFailedToConnect()
def initialize(self, domain, server):
LOG_VOIP_INT('VOIPManager.Initialize')
if not self.__initialized is False:
raise AssertionError
self.__voipServer = server
self.__voipDomain = domain
self.__testDomain = 'sip:confctl-2@' + self.__voipDomain
LOG_VOIP_INT("voip_server: '%s'" % self.__voipServer)
LOG_VOIP_INT("voip_domain: '%s'" % self.__voipDomain)
LOG_VOIP_INT("test_domain: '%s'" % self.__testDomain)
self.__fsm.update(self)
logLevel = 0
section = Settings.g_instance.userPrefs
if section.has_key('development'):
section = section['development']
logLevel = section.has_key('vivoxLogLevel') and section['vivoxLogLevel'].asInt
vinit = {VOIPCommon.KEY_SERVER: 'http://%s/api2' % self.__voipServer,
VOIPCommon.KEY_MIN_PORT: '0',
VOIPCommon.KEY_MAX_PORT: '0',
VOIPCommon.KEY_LOG_PREFIX: 'voip',
VOIPCommon.KEY_LOG_SUFFIX: '.txt',
VOIPCommon.KEY_LOG_FOLDER: '.',
VOIPCommon.KEY_LOG_LEVEL: str(logLevel)}
BigWorld.VOIP.initialise(vinit)
def __onStateChanged(self, _, newState):
if newState == STATE.INITIALIZED:
self.__resetToInitializedState()
elif newState == STATE.LOGGING_IN:
self.__loginUser(self.__user[0], self.__user[1])
elif newState == STATE.LOGGED_IN:
self.__fsm.update(self)
elif newState == STATE.JOINING_CHANNEL:
muteMic = self.__channel[0] != self.__testDomain and not self.__activateMicByVoice
self.setMicMute(muteMic)
self.__joinChannel(self.__channel[0], self.__channel[1])
elif newState == STATE.JOINED_CHANNEL:
LOG_VOIP_INT("Joined to channel: '%s'" % self.__currentChannel)
self.__fsm.update(self)
elif newState == STATE.LEAVING_CHANNEL:
self.__sendLeaveChannelCommand(self.getCurrentChannel())
elif newState == STATE.LOGGING_OUT:
BigWorld.VOIP.logout()
def __me_onCredentialReceived(self, name, pwd):
"""
Listener of event g_messengerEvents.voip.onCredentialReceived.
"""
LOG_VOIP_INT("VOIPManager.OnUserCredentials: '%s' '%s'" % (name, pwd))
self.__login(name, pwd)
def logout(self):
LOG_VOIP_INT('VOIPManager.Logout')
self.__clearUser()
self.__clearDesiredChannel()
self.__fsm.update(self)
def __joinChannel(self, channel, password):
LOG_VOIP_INT("Joining channel '%s'" % channel)
BigWorld.VOIP.joinChannel(channel, password)
def __leaveChannel(self):
if not self.__initialized:
return
LOG_VOIP_INT('VOIPManager.LeaveChannel')
self.__clearDesiredChannel()
self.__fsm.update(self)
def enterTestChannel(self):
if self.__inTesting:
return
LOG_VOIP_INT("VOIPManager.EnterTestChannel: '%s'" % self.__testDomain)
self.__inTesting = True
self.__enterChannel(self.__testDomain, '')
def __sendLeaveChannelCommand(self, channel):
LOG_VOIP_INT("Leaving channel '%s'" % channel)
if channel:
BigWorld.VOIP.leaveChannel(channel)
self.__fsm.update(self)
def __onChatActionMute(self, dbid, muted):
LOG_VOIP_INT('VOIPManager.OnChatActionMute', dbid, muted)
if dbid in self.__channelUsers and self.__channelUsers[dbid]['muted'] != muted:
self.__muteParticipantForMe(dbid, muted)
def __reloginUser(self):
self.__loginAttemptsRemained -= 1
LOG_VOIP_INT('VOIPHandler.ReloginUser. Attempts remained: %d' % self.__loginAttemptsRemained)
if self.__enabled:
self.__requestCredentials(1)
def setVoiceActivation(self, enabled):
LOG_VOIP_INT('VOIPManager.SetVoiceActivation: %s' % str(enabled))
self.__activateMicByVoice = enabled
self.setMicMute(not enabled)
def destroy(self):
self.__fsm.onStateChanged -= self.__onStateChanged
BigWorld.VOIP.finalise()
LOG_VOIP_INT('VOIPManager.Destroy')
closeLog()
def __setMicMute(self, muted):
LOG_VOIP_INT('VOIPManager.SetMicMute: %s' % str(muted))
if muted:
BigWorld.VOIP.disableMicrophone()
else:
BigWorld.VOIP.enableMicrophone()
def setCaptureDevice(self, deviceName):
LOG_VOIP_INT("VOIPManager.SetCaptureDevice: '%s'" % deviceName)
BigWorld.VOIP.setCaptureDevice(deviceName)
def __requestCredentials(self, reset = 0):
LOG_VOIP_INT('VOIPManager.RequestUserCredentials')
self.bwProto.voipProvider.requestCredentials(reset)
def requestCaptureDevices(self):
LOG_VOIP_INT('VOIPManager.RequestCaptureDevices')
BigWorld.VOIP.getCaptureDevices()
def __loginUser(self, username, password):
LOG_VOIP_INT("Login Request: '%s', '%s'" % (username, password))
cmd = {KEY_PARTICIPANT_PROPERTY_FREQUENCY: '100'}
BigWorld.VOIP.login(username, password, cmd)
