# -*- coding: euc-kr -*-

#-------------------------------------------------------------------------------
# Name:		 mmiSoundPath.py
# Purpose:	 MMI상의 soundpath를 관리하는 모듈 
#
# Author:	  류호창
#
# Created:	 02-01-2008
# Copyright:   (c) LG-Nortel 2008
# Licence:	 <Ryoo Ho Chang GGU!>
#-------------------------------------------------------------------------------
import runtime
import soundpath
import config
import os
from telephoneNumberPolicy import *
from setting import setting
from runtime import mmiDebug as MD

class Device:
	IDLE = 0
	OUTGOING_AUDIO = 0
	OUTGOING_VIDEO = 1
	INCOMING_AUDIO = 2
	INCOMING_VIDEO = 3

	ON_HOOK = 0
	OFF_HOOK = 1
	
	def __init__(self):
		self.workingChannel = None
		self.tone = None
		self.tonePlaying = False
		self.volume = None
		self.status = self.ON_HOOK
		
	def getWorkingChannel(self):
		return self.workingChannel

	def setWorkingChannel(self, workingChannel):
		self.workingChannel = workingChannel

	def getTone(self):
		return self.tone

	def setTone(self, tone):
		self.tone = tone

	def clearTone(self):
		self.tonePlaying = False
		self.tone = None
		
	def isTonePlaying(self):
		return self.tonePlaying

	def setTonePlaying(self, tonePlaying):
		self.tonePlaying = tonePlaying
		
	def getVolume(self):
		return self.volume

	def setVolume(self, volume):
		self.volume = volume

	def getStatus(self):
		return self.status

	def setStatus(self, status):
		self.status = status

	def clearStatus(self):
		self.workingChannel = None
		self.tone = None
		self.tonePlaying = False
		self.volume = None
		self.status = self.ON_HOOK

class Handset(Device):
	def __init__(self):
		Device.__init__(self)
		
class Speaker(Device):
	def __init__(self):
		Device.__init__(self)

class DECT1(Device):
	def __init__(self):
		Device.__init__(self)

class SP_State:
	DEVICE_HS = 0x00
	DEVICE_SPK = 0x01
	DEVICE_HDS1 = 0x02
	DEVICE_MIDI = 0x03
	DEVICE_HSS1_TS1 = 0x04
	DEVICE_HSS1_TS2 = 0x05
	DEVICE_BT = 0x06
	DEVICE_STEREO_SPK = 0x07
	DEVICE_NUM = 0x08

	STATE_IDLE = 0x00
	STATE_CONNECT = 0x01
	STATE_PLAYBACK = 0x02
	STATE_RECORD = 0x03

	def __init__(self):
		#self.stereoPlaybackFlag = False	
		self.playbackFlag = False
		self.recordFlag = False

	def getName(self):
		return self.name

	'''
	def getStereoPlaybackFlag(self):
		return self.stereoPlaybackFlag

	def setStereoPlaybackFlag(self, stereoPlaybackFlag):
		self.stereoPlaybackFlag = stereoPlaybackFlag
	'''
	
	def getPlaybackFlag(self):
		return self.playbackFlag

	def setPlaybackFlag(self, playbackFlag):
		self.playbackFlag = playbackFlag

	def getRecordFlag(self):
		return recordFlag

	def setRecordFlag(self, recordFlag):
		self.recordFlag = recordFlag
		
	def HS_OffHook(self):
		yield False

	def HS_OnHook(self):
		yield False

	def SPK_OffHook(self, dialNumber=False):
		yield False

	# 최종적으로 END_Pressed(self):로 변경되어야 함.
	def SPK_OnHook(self):
		yield False

	def HDS1_OffHook(self):
		yield False

	def HDS1_OnHook(self):
		yield False

	def TS1_OffHook(self):
		yield False

	def TS1_OnHook(self):
		yield False

	def TS2_OffHook(self):
		yield False

	def TS2_OnHook(self):
		yield False

	def BT_OffHook(self):
		yield False

	def BT_OnHook(self):
		yield False

	def B2TS1_Transfer(self):
		yield False

	def B2TS2_Transfer(self):
		yield False

	def RED_Pressed(self):
		# original device 중 삭제될 device만 선별하여 return
		yield False
		
	def isMessageForDect(self):
		yield False

	def SP_stereoPlayback(self):
		'''
		if runtime.SP_context.getStereoPlaybackFlag():
			return False
		else:
			runtime.SP_context.setStereoPlaybackFlag(True)
			runtime.soundpath.set_state(self.DEVICE_STEREO_SPK, self.STATE_CONNECT)
			runtime.SP_context.setDeviceVolume(self.DEVICE_STEREO_SPK, setting.stereo_volume)
			runtime.soundpath.set_state(self.DEVICE_STEREO_SPK, self.STATE_PLAYBACK)
			return True
		'''
		runtime.SP_context.setStereoPlaybackFlag(True)
		runtime.soundpath.set_state(self.DEVICE_STEREO_SPK, self.STATE_CONNECT)
		runtime.SP_context.setDeviceVolume(self.DEVICE_STEREO_SPK, setting.stereo_volume)
		runtime.soundpath.set_state(self.DEVICE_STEREO_SPK, self.STATE_PLAYBACK)
		return True

	def SP_stereoStopPlayback(self):
		'''
		if runtime.SP_context.getStereoPlaybackFlag():
			runtime.SP_context.setStereoPlaybackFlag(False)
			runtime.soundpath.set_state(self.DEVICE_STEREO_SPK, self.STATE_IDLE)
			return True
		else:
			return False
		'''
		runtime.soundpath.set_state(self.DEVICE_STEREO_SPK, self.STATE_IDLE)
		
	def SP_startPlayback(self):
		if self.playbackFlag:
			return False
		else:
			self.playbackFlag = True
			devices = runtime.SP_context.getCurrentDevice()
			for device in devices:
				runtime.soundpath.set_state(device, self.STATE_PLAYBACK)
				runtime.soundpath.set_volume(device, setting.ringer_volume)
			return True

	def SP_stopPlayback(self):
		if self.playbackFlag:
			self.playbackFlag = False
			devices = runtime.SP_context.getCurrentDevice()
			for device in devices:
				runtime.soundpath.set_state(device, self.STATE_CONNECT)
			return True
		else:
			return False
		
	def SP_startRecord(self):
		if self.recordFlag:
			return False
		else:
			self.recordFlag = True
			devices = runtime.SP_context.getCurrentDevice()
			for device in devices:				
				runtime.soundpath.set_state(device, self.STATE_RECORD)

			return True

	def SP_stopRecord(self):
		if self.recordFlag:
			self.recordFlag = False
			devices = runtime.SP_context.getCurrentDevice()
			for device in devices:
				runtime.soundpath.set_state(device, self.STATE_CONNECT)

			return True
		else:
			return False

	def SP_setMicDisableAll(self):
		devices = [self.DEVICE_HS, self.DEVICE_SPK, self.DEVICE_HSS1_TS1]
		for device in devices:
			MD.mmiTrace('SP_setMicDisable', device)
			runtime.soundpath.set_mute(device, 1) # 0:un-mute 1: mute

	def SP_setMicEnableAll(self):
		devices = [self.DEVICE_HS, self.DEVICE_SPK, self.DEVICE_HSS1_TS1]
		for device in devices:
			MD.mmiTrace('SP_setMicEnable', device)
			runtime.soundpath.set_mute(device, 0) # 0:un-mute 1: mute		

	def SP_setMicDisable(self):
		devices = runtime.SP_context.getCurrentDevice()
		for device in devices:
			runtime.soundpath.set_mute(device, 1) # 0:un-mute 1: mute
			MD.mmiTrace('SP_setMicDisable')

	def SP_setMicEnable(self):
		devices = runtime.SP_context.getCurrentDevice()
		for device in devices:
			MD.mmiTrace('SP_setMicEnable')
			runtime.soundpath.set_mute(device, 0) # 0:un-mute 1: mute		

	def SP_playWav(self, device, filename, loop=True):
		if loop:
			runtime.soundpath.start_play(device, filename, 1)
		else:
			runtime.soundpath.start_play(device, filename, 0)

	def SP_stopWav(self):
		runtime.soundpath.stop_play()
		
class SP_Idle(SP_State):
	name = 'SP_Idle'

	def __init__(self):
		SP_State.__init__(self)

		'''		
		if runtime.SP_context.handset.getStatus() == Device.OFF_HOOK:
			print '***__________________________________***'
			self.HS_OffHook()
			return
		'''	
		runtime.SP_context.setCurrentDevice([])

		#runtime.mmedia.unload()
		#runtime.soundpath.set_state(self.DEVICE_STEREO_SPK, self.STATE_IDLE)
		
	def HS_OffHook(self):
		yield True

		runtime.soundpath.set_state(self.DEVICE_STEREO_SPK, self.STATE_IDLE)
		
		runtime.soundpath.set_state(self.DEVICE_HS, self.STATE_CONNECT)
		runtime.SP_context.setBandwidthMode(self.DEVICE_HS)
		runtime.SP_context.setDeviceVolume(self.DEVICE_HS, setting.handset_volume)
		'''
		runtime.SP_context.handset.setStatus(Device.OFF_HOOK)
		if runtime.SP_context.getBaseStatus() == SP_Context.IDLE:
			if runtime.SP_context.getBaseCallStatus() in [SP_Context.OUTGOING_AUDIO, SP_Context.OUTGOING_VIDEO]:
				runtime.SP_context.setBaseStatus(SP_Context.DIALING)
				runtime.SP_context.handset.setTone(config.PLAY_DIAL_TONE)
		elif runtime.SP_context.getBaseStatus() == SP_Context.RINGING:
			runtime.SP_context.setBaseStatus(SP_Context.CONNECTED)
		'''
		runtime.SP_context.setCurrentState(SP_HS_OffHook())
		
		yield []

	def SPK_OffHook(self, dialNumber=False):
		yield True

		runtime.soundpath.set_state(self.DEVICE_SPK, self.STATE_CONNECT)
		runtime.SP_context.setBandwidthMode(self.DEVICE_SPK)
		runtime.SP_context.setDeviceVolume(self.DEVICE_SPK, setting.speaker_volume)

		'''
		runtime.SP_context.speaker.setStatus(Device.OFF_HOOK)
		if runtime.SP_context.getBaseStatus() == SP_Context.IDLE:
			if runtime.SP_context.getBaseCallStatus() in [SP_Context.OUTGOING_AUDIO, SP_Context.OUTGOING_VIDEO]:
				runtime.SP_context.setBaseStatus(SP_Context.DIALING)
				runtime.SP_context.speaker.setTone(config.PLAY_DIAL_TONE)
		elif runtime.SP_context.getBaseStatus() == SP_Context.RINGING:
			runtime.SP_context.setBaseStatus(SP_Context.CONNECTED)
		'''
		runtime.SP_context.setCurrentState(SP_SPK_OffHook())
		
		yield True

		
	def TS1_OffHook(self):
		yield True

		# 상태 검사
		stereoState = runtime.SP_context.getDeviceState(self.DEVICE_STEREO_SPK)
		if stereoState:
			runtime.SP_context.SP_stereoStopPlayback()
		runtime.mmedia.HAL_mixer_pause()
		runtime.soundpath.set_state(self.DEVICE_HSS1_TS1, self.STATE_CONNECT)
		# re-open
		baseStatus = runtime.SP_context.getBaseStatus()
		if stereoState and baseStatus != SP_Context.TRANSFER_RINGING:
			runtime.SP_context.SP_stereoPlayback()
		runtime.mmedia.HAL_mixer_resume()
		runtime.SP_context.setBandwidthMode(self.DEVICE_HSS1_TS1)
		runtime.SP_context.setDeviceVolume(self.DEVICE_HSS1_TS1)

		'''
		dectStatus = runtime.dectCallManager.getDectStatus()
		print 'dectStatus = ', dectStatus
		from dectHandler import DectCallManager
		if dectStatus == DectCallManager.IDLE:
			runtime.SP_context.dect1.setStatus(Device.OFF_HOOK)
			runtime.SP_context.dect1.setTone(config.PLAY_DIAL_TONE)
			runtime.dectCallManager.setDectStatus(DectCallManager.DIALING)
		'''
		runtime.SP_context.setCurrentState(SP_TS1_OffHook())
		
		yield True

	def TS2_OffHook(self):
		yield True

		runtime.soundpath.set_state(self.DEVICE_HSS1_TS2, self.STATE_CONNECT)
		runtime.SP_context.setBandwidthMode(self.DEVICE_HSS1_TS2)
		runtime.SP_context.setDeviceVolume(self.DEVICE_HSS1_TS2)

		runtime.SP_context.speaker.setStatus(Device.OFF_HOOK)
		runtime.SP_context.speaker.setTone(config.PLAY_DIAL_TONE)
		
		runtime.SP_context.setCurrentState(SP_TS2_OffHook())
		
		yield True

	'''
	def BT_OffHook(self):
		yield True

		runtime.soundpath.set_state(self.DEVICE_BT, self.STATE_CONNECT)
		runtime.SP_context.setCurrentState(SP_BT_OffHook())
		
		yield True
	'''
	
class SP_HS_OffHook(SP_State):
	name = 'SP_HS_OffHook'

	def __init__(self):
		SP_State.__init__(self)
		runtime.SP_context.setCurrentDevice([self.DEVICE_HS])	
		
		if runtime.SP_context.isInSession():
			runtime.SP_context.setPhysicalDevice()

		#runtime.mmedia.unload()
		#runtime.soundpath.set_state(self.DEVICE_STEREO_SPK, self.STATE_IDLE)

	def HS_OnHook(self):
		yield True
		'''
		if not runtime.SP_context.isInSession():
			runtime.SP_context.handset.setStatus(Device.ON_HOOK)
			runtime.SP_context.handset.clearTone()
			runtime.SP_context.stopTonePlay(self.DEVICE_HS)
		'''
		runtime.soundpath.set_state(self.DEVICE_HS, self.STATE_IDLE)

		#yield False

		runtime.SP_context.setCurrentState(SP_Idle())

		yield None		

	def SPK_OffHook(self, dialNumber=False):
		yield True

		if dialNumber:
			yield True
		else:
			yield False

		yield False
		
		runtime.soundpath.set_state(self.DEVICE_SPK, self.STATE_CONNECT)
		runtime.SP_context.setBandwidthMode(self.DEVICE_SPK)
		runtime.SP_context.setDeviceVolume(self.DEVICE_SPK, setting.speaker_volume)

		'''
		if not runtime.SP_context.isInSession():
			runtime.SP_context.speaker.setStatus(Device.OFF_HOOK)
			runtime.SP_context.speaker.setTone(config.PLAY_DIAL_TONE)
		'''
		runtime.SP_context.setCurrentState(SP_HS_OffHook_SPK_OffHook())


		yield True
	
	def TS1_OffHook(self):
		'''
		if TNP.TS1_isFeasible():
			yield True
		else:
			yield False
		'''
		yield True
		
		# 상태 검사
		stereoState = runtime.SP_context.getDeviceState(self.DEVICE_STEREO_SPK)
		if stereoState:
			runtime.SP_context.SP_stereoStopPlayback()
		runtime.mmedia.HAL_mixer_pause()
		runtime.soundpath.set_state(self.DEVICE_HSS1_TS1, self.STATE_CONNECT)
		# re-open
		baseStatus = runtime.SP_context.getBaseStatus()
		if stereoState and baseStatus != SP_Context.TRANSFER_RINGING:
			runtime.SP_context.SP_stereoPlayback()
		runtime.mmedia.HAL_mixer_resume()
		runtime.SP_context.setBandwidthMode(self.DEVICE_HSS1_TS1)
		runtime.SP_context.setDeviceVolume(self.DEVICE_HSS1_TS1)

		'''
		runtime.SP_context.dect1.setStatus(Device.OFF_HOOK)
		runtime.SP_context.dect1.setTone(config.PLAY_BUSY_TONE)
		'''
		runtime.SP_context.setCurrentState(SP_HS_OffHook_TS1_OffHook())
		
		yield True

	def TS2_OffHook(self):
		if TNP.TS2_isFeasible():
			yield True
		else:
			yield False

		runtime.soundpath.set_state(self.DEVICE_HSS1_TS2, self.STATE_CONNECT)
		runtime.SP_context.setBandwidthMode(self.DEVICE_HSS1_TS2)
		runtime.SP_context.setDeviceVolume(self.DEVICE_HSS1_TS2)
		
		runtime.SP_context.setCurrentState(SP_HS_OffHook_TS2_OffHook())
		
		yield True

	def RED_Pressed(self):
		yield True
		runtime.soundpath.set_state(self.DEVICE_HS, self.STATE_IDLE)
		runtime.SP_context.setCurrentState(SP_Idle())

		yield [self.DEVICE_HS]		

	def B2TS1_Transfer(self):
		yield True

		runtime.soundpath.set_state(self.DEVICE_HS, self.STATE_IDLE)
		runtime.soundpath.set_state(self.DEVICE_HSS1_TS1, self.STATE_CONNECT)
		runtime.SP_context.setCurrentState(SP_TS1_OffHook())
		
		yield True

	def B2TS2_Transfer(self):
		yield True

		runtime.soundpath.set_state(self.DEVICE_HS, self.STATE_IDLE)
		runtime.soundpath.set_state(self.DEVICE_HSS1_TS2, self.STATE_CONNECT)
		runtime.SP_context.setCurrentState(SP_TS2_OffHook())
		
		yield True
	
class SP_SPK_OffHook(SP_State):
	name = 'SP_SPK_OffHook'

	def __init__(self):
		SP_State.__init__(self)
		runtime.SP_context.setCurrentDevice([self.DEVICE_SPK])
		if runtime.SP_context.isInSession():
			runtime.SP_context.setPhysicalDevice()
			#runtime.SP_context.setDevice(SP_Context.DICT_SP_TO_EPT.get(self.DEVICE_SPK))
		'''
			runtime.SP_context.startTonePlay()
		else:
			runtime.SP_context.startTonePlay()
		'''

		#runtime.mmedia.unload()
		#runtime.soundpath.set_state(self.DEVICE_STEREO_SPK, self.STATE_IDLE)
		
	def HS_OffHook(self):
		yield True

		runtime.soundpath.set_state(self.DEVICE_SPK, self.STATE_IDLE)
		'''
		if not runtime.SP_context.isInSession():
			runtime.SP_context.handset.setStatus(Device.ON_HOOK)
			runtime.SP_context.handset.clearTone()
			runtime.SP_context.stopTonePlay(self.DEVICE_HS)
		'''
		runtime.soundpath.set_state(self.DEVICE_HS, self.STATE_CONNECT)
		runtime.SP_context.setBandwidthMode(self.DEVICE_HS)
		runtime.SP_context.setDeviceVolume(self.DEVICE_HS, setting.handset_volume)
		'''
		if not runtime.SP_context.isInSession():
			runtime.SP_context.handset.setStatus(Device.OFF_HOOK)
			runtime.SP_context.handset.setTone(config.PLAY_DIAL_TONE)
		'''
		runtime.SP_context.setCurrentState(SP_HS_OffHook())
		
		yield [self.DEVICE_SPK]

	# soundpath 구성의 이상 경우이며,  SPK를 두번 누를 경우 발생
	def SPK_OffHook(self, dialNumber=False):
		yield True

		if dialNumber:
			yield True
		else:
			yield False
		'''
		runtime.soundpath.set_state(self.DEVICE_SPK, self.STATE_IDLE)
		runtime.SP_context.setCurrentState(SP_Idle())
		'''
		yield True
		
	def SPK_OnHook(self):
		yield True

		runtime.soundpath.set_state(self.DEVICE_SPK, self.STATE_IDLE)

		'''
		if not runtime.SP_context.isInSession():
			runtime.SP_context.speaker.setStatus(Device.ON_HOOK)
			runtime.SP_context.speaker.clearTone()
			runtime.SP_context.stopTonePlay(self.DEVICE_SPK)
		'''
		yield False
		
		runtime.SP_context.setCurrentState(SP_Idle())

		yield True

	def TS1_OffHook(self):
		yield True

		# 상태 검사
		stereoState = runtime.SP_context.getDeviceState(self.DEVICE_STEREO_SPK)
		if stereoState:
			runtime.SP_context.SP_stereoStopPlayback()
		runtime.mmedia.HAL_mixer_pause()
		runtime.soundpath.set_state(self.DEVICE_HSS1_TS1, self.STATE_CONNECT)
		# re-open
		baseStatus = runtime.SP_context.getBaseStatus()
		if stereoState and baseStatus != SP_Context.TRANSFER_RINGING:
			runtime.SP_context.SP_stereoPlayback()
		runtime.mmedia.HAL_mixer_resume()
		runtime.SP_context.setBandwidthMode(self.DEVICE_HSS1_TS1)
		runtime.SP_context.setDeviceVolume(self.DEVICE_HSS1_TS1)

		'''
		runtime.SP_context.dect1.setStatus(Device.OFF_HOOK)
		runtime.SP_context.dect1.setTone(config.PLAY_BUSY_TONE)
		'''
		runtime.SP_context.setCurrentState(SP_SPK_OffHook_TS1_OffHook())
		
		yield True

	def TS2_OffHook(self):
		yield True

		runtime.soundpath.set_state(self.DEVICE_HSS1_TS2, self.STATE_CONNECT)
		runtime.SP_context.setBandwidthMode(self.DEVICE_HSS1_TS2)
		runtime.SP_context.setDeviceVolume(self.DEVICE_HSS1_TS2)
	
		runtime.SP_context.setCurrentState(SP_SPK_OffHook_TS2_OffHook())
		
		yield True

	def RED_Pressed(self):
		yield True
		runtime.soundpath.set_state(self.DEVICE_SPK, self.STATE_IDLE)
		runtime.SP_context.setCurrentState(SP_Idle())

		yield [self.DEVICE_SPK]		

	def B2TS1_Transfer(self):
		yield True

		runtime.soundpath.set_state(self.DEVICE_HS, self.STATE_IDLE)
		runtime.soundpath.set_state(self.DEVICE_HSS1_TS1, self.STATE_CONNECT)
		runtime.SP_context.setCurrentState(SP_TS1_OffHook())
		
		yield True

	def B2TS2_Transfer(self):
		yield True

		runtime.soundpath.set_state(self.DEVICE_HS, self.STATE_IDLE)
		runtime.soundpath.set_state(self.DEVICE_HSS1_TS2, self.STATE_CONNECT)
		runtime.SP_context.setCurrentState(SP_TS2_OffHook())
		
		yield True

class SP_HDS1_OffHook(SP_State):
	name = 'SP_HDS1_OffHook'

	def __init__(self):
		SP_State.__init__(self)
		runtime.SP_context.setCurrentDevice([self.DEVICE_HDS1])
		if runtime.SP_context.isInSession():
			runtime.SP_context.setDevice(SP_Context.DICT_SP_TO_EPT.get(self.DEVICE_HDS1))

class SP_TS1_OffHook(SP_State):
	name = 'SP_TS1_OffHook'

	def __init__(self):
		SP_State.__init__(self)
		runtime.SP_context.setCurrentDevice([self.DEVICE_HSS1_TS1])
		if runtime.SP_context.isInSession():
			runtime.SP_context.setPhysicalDevice()

		#runtime.mmedia.unload()
		#runtime.soundpath.set_state(self.DEVICE_STEREO_SPK, self.STATE_IDLE)
	
	def HS_OffHook(self):
		yield True

		runtime.soundpath.set_state(self.DEVICE_HS, self.STATE_CONNECT)
		runtime.SP_context.setBandwidthMode(self.DEVICE_HS)
		runtime.SP_context.setDeviceVolume(self.DEVICE_HS, setting.handset_volume)
		'''
		runtime.SP_context.handset.setStatus(Device.OFF_HOOK)
		runtime.SP_context.handset.setTone(config.PLAY_BUSY_TONE)
		'''
		runtime.SP_context.setCurrentState(SP_TS1_OffHook_HS_OffHook())
		
		yield [self.DEVICE_HSS1_TS1]

	def SPK_OffHook(self, dialNumber=False):
		yield True

		runtime.soundpath.set_state(self.DEVICE_SPK, self.STATE_CONNECT)
		runtime.SP_context.setBandwidthMode(self.DEVICE_SPK)
		runtime.SP_context.setDeviceVolume(self.DEVICE_SPK, setting.speaker_volume)

		'''
		runtime.SP_context.speaker.setStatus(Device.OFF_HOOK)
		runtime.SP_context.speaker.setTone(config.PLAY_BUSY_TONE)
		'''
		runtime.SP_context.setCurrentState(SP_TS1_OffHook_SPK_OffHook())
		
		yield True

	def TS1_OnHook(self):
		yield True

		'''
		if not runtime.SP_context.isInSession():
			runtime.SP_context.dect1.setStatus(Device.ON_HOOK)
			runtime.SP_context.dect1.clearTone()
			runtime.SP_context.stopTonePlay(self.DEVICE_HSS1_TS1)
		'''
		# 상태 검사
		stereoState = runtime.SP_context.getDeviceState(self.DEVICE_STEREO_SPK)
		if stereoState:
			runtime.SP_context.SP_stereoStopPlayback()
		runtime.mmedia.HAL_mixer_pause()
		runtime.soundpath.set_state(self.DEVICE_HSS1_TS1, self.STATE_IDLE)
		# re-open
		baseStatus = runtime.SP_context.getBaseStatus()
		if stereoState and baseStatus != SP_Context.TRANSFER_RINGING:
			runtime.SP_context.SP_stereoPlayback()
		runtime.mmedia.HAL_mixer_resume()
		runtime.SP_context.setCurrentState(SP_Idle())
		
		yield True

	def TS2_OffHook(self):
		yield True

		runtime.soundpath.set_state(self.DEVICE_HSS1_TS2, self.STATE_CONNECT)
		runtime.SP_context.setDeviceVolume(self.DEVICE_HSS1_TS2)
		runtime.SP_context.setCurrentState(SP_TS1_OffHook_TS2_OffHook())
		
		yield True

	def RED_Pressed(self):
		yield True
		runtime.soundpath.set_state(self.DEVICE_HSS1_TS1, self.STATE_IDLE)
		runtime.SP_context.setCurrentState(SP_Idle())

		yield [self.DEVICE_HSS1_TS1]		

	def isMessageForDect(self):
		yield True
	
class SP_TS2_OffHook(SP_State):
	name = 'SP_TS2_OffHook'

	def __init__(self):
		SP_State.__init__(self)
		runtime.SP_context.setCurrentDevice([self.DEVICE_HSS1_TS2])
		if runtime.SP_context.isInSession():
			runtime.SP_context.setDevice(SP_Context.DICT_SP_TO_EPT.get(self.DEVICE_HSS1_TS2))

	def HS_OffHook(self):
		yield True

		runtime.soundpath.set_state(self.DEVICE_HS, self.STATE_CONNECT)
		runtime.SP_context.setCurrentState(SP_TS2_OffHook_HS_OffHook())
		
		yield True

	def SPK_OffHook(self, dialNumber=False):
		yield True

		runtime.soundpath.set_state(self.DEVICE_SPK, self.STATE_CONNECT)
		runtime.SP_context.setCurrentState(SP_TS2_OffHook_SPK_OffHook())
		
		yield True

	def TS1_OffHook(self):
		yield True

		# 상태 검사
		stereoState = runtime.SP_context.getDeviceState(self.DEVICE_STEREO_SPK)
		if stereoState:
			runtime.SP_context.SP_stereoStopPlayback()
		runtime.mmedia.HAL_mixer_pause()
		runtime.soundpath.set_state(self.DEVICE_HSS1_TS1, self.STATE_CONNECT)
		# re-open
		baseStatus = runtime.SP_context.getBaseStatus()
		if stereoState and baseStatus != SP_Context.TRANSFER_RINGING:
			runtime.SP_context.SP_stereoPlayback()
		runtime.mmedia.HAL_mixer_resume()
		runtime.SP_context.setDeviceVolume(self.DEVICE_HSS1_TS1)
		runtime.SP_context.setCurrentState(SP_TS2_OffHook_TS1_OffHook())
		
		yield True

	def TS2_OnHook(self):
		yield True

		runtime.soundpath.set_state(self.DEVICE_HSS1_TS2, self.STATE_IDLE)
		runtime.SP_context.setCurrentState(SP_Idle())
		
		yield True

class SP_BT_OffHook(SP_State):
	name = 'SP_BT_OffHook'

	def __init__(self):
		SP_State.__init__(self)
		runtime.SP_context.setCurrentDevice([self.DEVICE_BT])
		if runtime.SP_context.isInSession():
			runtime.SP_context.setDevice(SP_Context.DICT_SP_TO_EPT.get(self.DEVICE_BT))

class SP_HS_OffHook_SPK_OffHook(SP_State):
	name = 'SP_HS_OffHook_SPK_OffHook'

	def __init__(self):
		SP_State.__init__(self)
		runtime.SP_context.setCurrentDevice([self.DEVICE_HS, self.DEVICE_SPK])
		if runtime.SP_context.isInSession():
			runtime.SP_context.setPhysicalDevice()

		#runtime.mmedia.unload()
		#runtime.soundpath.set_state(self.DEVICE_STEREO_SPK, self.STATE_IDLE)
			
	def HS_OnHook(self):
		yield True
		'''	
		if runtime.SP_context.isInSession():
			runtime.SP_context.setDevice(self.DEVICE_SPK)
		else:
			runtime.SP_context.handset.setStatus(Device.ON_HOOK)
			runtime.SP_context.handset.clearTone()
			runtime.SP_context.stopTonePlay(self.DEVICE_HS)
		'''
		runtime.soundpath.set_state(self.DEVICE_HS, self.STATE_IDLE)

		# [20080908_1] : hcryoo : 그룹 콜에서 전환 후 HS off hook 하고 바로 전환 취소 시 mute 발생하는 오류 수정
		if runtime.SP_context.isInSession():
			runtime.SP_context.setDeviceWithSoundpath(self.DEVICE_HS)
		# [20080908_1] : hcryoo : 그룹 콜에서 전환 후 HS off hook 하고 바로 전환 취소 시 mute 발생하는 오류 수정==
		runtime.SP_context.setCurrentState(SP_SPK_OffHook())
		
		yield [self.DEVICE_SPK]

	# soundpath 구성의 이상 경우이며,  SPK를 두번 누를 경우 발생
	def SPK_OffHook(self, dialNumber=False):
		yield True

		if dialNumber:
			yield True
		else:
			yield False

		yield False
		
		runtime.soundpath.set_state(self.DEVICE_SPK, self.STATE_IDLE)
		runtime.SP_context.setCurrentState(SP_HS_OffHook())
		
		yield True

	def SPK_OnHook(self):
		yield True
		'''
		if runtime.SP_context.isInSession():
			runtime.SP_context.setDevice(self.DEVICE_HS)
		runtime.soundpath.set_state(self.DEVICE_SPK, self.STATE_IDLE)

		if not runtime.SP_context.isInSession():
			runtime.SP_context.speaker.setStatus(Device.ON_HOOK)
			runtime.SP_context.speaker.clearTone()
			runtime.SP_context.stopTonePlay(self.DEVICE_SPK)
		'''
		runtime.soundpath.set_state(self.DEVICE_SPK, self.STATE_IDLE)
		runtime.SP_context.setCurrentState(SP_HS_OffHook())
		
		yield True

	def TS1_OffHook(self):
		yield True

		# 상태 검사
		stereoState = runtime.SP_context.getDeviceState(self.DEVICE_STEREO_SPK)
		if stereoState:
			runtime.SP_context.SP_stereoStopPlayback()
		runtime.mmedia.HAL_mixer_pause()
		runtime.soundpath.set_state(self.DEVICE_HSS1_TS1, self.STATE_CONNECT)
		# re-open
		baseStatus = runtime.SP_context.getBaseStatus()
		if stereoState and baseStatus != SP_Context.TRANSFER_RINGING:
			runtime.SP_context.SP_stereoPlayback()
		runtime.mmedia.HAL_mixer_resume()
		runtime.SP_context.setBandwidthMode(self.DEVICE_HSS1_TS1)
		runtime.SP_context.setDeviceVolume(self.DEVICE_HSS1_TS1)
		'''
		runtime.SP_context.dect1.setStatus(Device.OFF_HOOK)
		runtime.SP_context.dect1.setTone(config.PLAY_BUSY_TONE)
		'''
		runtime.SP_context.setCurrentState(SP_HS_OffHook_SPK_OffHook_TS1_OffHook())
		
		yield True

	def TS2_OffHook(self):
		yield True

		runtime.soundpath.set_state(self.DEVICE_HSS1_TS2, self.STATE_CONNECT)
		runtime.SP_context.setBandwidthMode(self.DEVICE_HSS1_TS2)
		runtime.SP_context.setDeviceVolume(self.DEVICE_HSS1_TS2)
		
		runtime.SP_context.setCurrentState(SP_HS_OffHook_SPK_OffHook_TS2_OffHook())
		
		yield True

	def B2TS1_Transfer(self):
		yield True

		runtime.soundpath.set_state(self.DEVICE_HS, self.STATE_IDLE)
		runtime.soundpath.set_state(self.DEVICE_SPK, self.STATE_IDLE)
		runtime.soundpath.set_state(self.DEVICE_HSS1_TS1, self.STATE_CONNECT)
		runtime.SP_context.setCurrentState(SP_TS1_OffHook())
		
		yield True

	def B2TS2_Transfer(self):
		yield True

		runtime.soundpath.set_state(self.DEVICE_HS, self.STATE_IDLE)
		runtime.soundpath.set_state(self.DEVICE_SPK, self.STATE_IDLE)
		runtime.soundpath.set_state(self.DEVICE_HSS1_TS2, self.STATE_CONNECT)
		runtime.SP_context.setCurrentState(SP_TS2_OffHook())
		
		yield True

	def RED_Pressed(self):
		yield True
		runtime.soundpath.set_state(self.DEVICE_HS, self.STATE_IDLE)
		runtime.soundpath.set_state(self.DEVICE_SPK, self.STATE_IDLE)
		runtime.SP_context.setCurrentState(SP_Idle())

		yield [self.DEVICE_HS, self.DEVICE_SPK]		

'''
class SP_HS_OffHook_HDS1_OffHook(SP_State):
	name = 'SP_HS_OffHook_HDS1_OffHook'

	def __init__(self):
		runtime.SP_context.setCurrentDevice([self.DEVICE_HS, self.DEVICE_HDS1])

'''

class SP_HS_OffHook_TS1_OffHook(SP_State):
	name = 'SP_HS_OffHook_TS1_OffHook'

	def __init__(self):
		SP_State.__init__(self)
		runtime.SP_context.setCurrentDevice([self.DEVICE_HS, self.DEVICE_HSS1_TS1])
		if runtime.SP_context.isInSession():
			runtime.SP_context.setPhysicalDevice()
		'''
			#runtime.SP_context.setDevice(SP_Context.DICT_SP_TO_EPT.get(self.DEVICE_HS) | SP_Context.DICT_SP_TO_EPT.get(self.DEVICE_HSS1_TS1))
			runtime.SP_context.startTonePlay()
		else:
			runtime.SP_context.startTonePlay()	
		'''

		#runtime.mmedia.unload()
		#runtime.soundpath.set_state(self.DEVICE_STEREO_SPK, self.STATE_IDLE)
		
	def HS_OnHook(self):
		yield True

		'''
		if runtime.SP_context.isInSession():
			runtime.SP_context.setDevice(self.DEVICE_HSS1_TS1)
		else:
			runtime.SP_context.handset.setStatus(Device.ON_HOOK)
			runtime.SP_context.handset.clearTone()
			runtime.SP_context.stopTonePlay(self.DEVICE_HS)
		'''
		runtime.soundpath.set_state(self.DEVICE_HS, self.STATE_IDLE)		
		runtime.SP_context.setCurrentState(SP_TS1_OffHook())
		
		yield [self.DEVICE_HSS1_TS1]

	def SPK_OffHook(self, dialNumber=False):
		yield True

		runtime.soundpath.set_state(self.DEVICE_SPK, self.STATE_CONNECT)
		runtime.SP_context.setBandwidthMode(self.DEVICE_SPK)
		runtime.SP_context.setDeviceVolume(self.DEVICE_SPK, setting.speaker_volume)

		'''
		if not runtime.SP_context.isInSession():
			runtime.SP_context.speaker.setStatus(Device.OFF_HOOK)
			runtime.SP_context.speaker.setTone(config.PLAY_DIAL_TONE)
		'''
		runtime.SP_context.setCurrentState(SP_HS_OffHook_TS1_OffHook_SPK_OffHook())
		
		yield True

	def TS1_OnHook(self):
		yield True

		'''
		if runtime.SP_context.isInSession():
			runtime.SP_context.setDevice(self.DEVICE_HS)
		else:
			runtime.SP_context.dect1.setStatus(Device.ON_HOOK)
			runtime.SP_context.dect1.clearTone()
			runtime.SP_context.stopTonePlay(SP_State.DEVICE_HSS1_TS1)
		'''
		# 상태 검사
		stereoState = runtime.SP_context.getDeviceState(self.DEVICE_STEREO_SPK)
		if stereoState:
			runtime.SP_context.SP_stereoStopPlayback()
		runtime.mmedia.HAL_mixer_pause()
		runtime.soundpath.set_state(self.DEVICE_HSS1_TS1, self.STATE_IDLE)
		# re-open
		baseStatus = runtime.SP_context.getBaseStatus()
		if stereoState and baseStatus != SP_Context.TRANSFER_RINGING:
			runtime.SP_context.SP_stereoPlayback()
		runtime.mmedia.HAL_mixer_resume()
		runtime.SP_context.setCurrentState(SP_HS_OffHook())
		
		yield True

	def RED_Pressed(self):
		yield True

		runtime.soundpath.set_state(self.DEVICE_HS, self.STATE_IDLE)		
		runtime.SP_context.setCurrentState(SP_TS1_OffHook())
		
		yield [self.DEVICE_HS]

	def B2TS2_Transfer(self):
		yield True

		runtime.soundpath.set_state(self.DEVICE_HS, self.STATE_IDLE)
		runtime.soundpath.set_state(self.DEVICE_HSS1_TS2, self.STATE_CONNECT)
		runtime.SP_context.setCurrentState(SP_TS1_OffHook_TS2_OffHook())
		
		yield True

class SP_HS_OffHook_TS2_OffHook(SP_State):
	name = 'SP_HS_OffHook_TS2_OffHook'

	def __init__(self):
		SP_State.__init__(self)
		runtime.SP_context.setCurrentDevice([self.DEVICE_HS, self.DEVICE_HSS1_TS2])
		if runtime.SP_context.isInSession():
			runtime.SP_context.setDevice(SP_Context.DICT_SP_TO_EPT.get(self.DEVICE_HS) | SP_Context.DICT_SP_TO_EPT.get(self.DEVICE_HSS1_TS2))

	def HS_OnHook(self):
		yield True

		'''
		if runtime.SP_context.isInSession():
			runtime.SP_context.setDevice(self.DEVICE_HSS1_TS2)
		'''
		runtime.soundpath.set_state(self.DEVICE_HS, self.STATE_IDLE)
		runtime.SP_context.setCurrentState(SP_TS2_OffHook())
		
		yield True

	def SPK_OffHook(self, dialNumber=False):
		yield True

		runtime.soundpath.set_state(self.DEVICE_SPK, self.STATE_CONNECT)
		runtime.SP_context.setBandwidthMode(self.DEVICE_SPK)
		runtime.SP_context.setDeviceVolume(self.DEVICE_SPK, setting.speaker_volume)
		runtime.SP_context.setCurrentState(SP_HS_OffHook_TS2_OffHook_SPK_OffHook())
		
		yield True

	def TS2_OnHook(self):
		yield True

		runtime.soundpath.set_state(self.DEVICE_HSS1_TS2, self.STATE_IDLE)
		runtime.SP_context.setCurrentState(SP_HS_OffHook())
		
		yield True

	def B2TS1_Transfer(self):
		yield True

		runtime.soundpath.set_state(self.DEVICE_HS, self.STATE_IDLE)
		runtime.soundpath.set_state(self.DEVICE_HSS1_TS1, self.STATE_CONNECT)
		runtime.SP_context.setCurrentState(SP_TS2_OffHook_TS1_OffHook())
		
		yield True

'''
class SP_HS_OffHook_BT_OffHook(SP_State):
	name = 'SP_HS_OffHook_BT_OffHook'

	def __init__(self):
		runtime.SP_context.setCurrentDevice([self.DEVICE_HS, self.DEVICE_BT])

'''

class SP_SPK_OffHook_TS1_OffHook(SP_State):
	name = 'SP_SPK_OffHook_TS1_OffHook'

	def __init__(self):
		SP_State.__init__(self)
		runtime.SP_context.setCurrentDevice([self.DEVICE_SPK, self.DEVICE_HSS1_TS1])
		if runtime.SP_context.isInSession():
			runtime.SP_context.setPhysicalDevice()
		'''
			#runtime.SP_context.setDevice(SP_Context.DICT_SP_TO_EPT.get(self.DEVICE_SPK) | SP_Context.DICT_SP_TO_EPT.get(self.DEVICE_HSS1_TS1))
			runtime.SP_context.startTonePlay()
		else:
			runtime.SP_context.startTonePlay()
		'''

		#runtime.mmedia.unload()
		#runtime.soundpath.set_state(self.DEVICE_STEREO_SPK, self.STATE_IDLE)

	def HS_OffHook(self):
		yield True

		'''
		if runtime.SP_context.isInSession():
			runtime.SP_context.setDevice(self.DEVICE_HS)
		else:
			runtime.SP_context.speaker.setStatus(Device.ON_HOOK)
			runtime.SP_context.speaker.clearTone()
			runtime.SP_context.stopTonePlay(SP_State.DEVICE_SPK)
		'''
		runtime.soundpath.set_state(self.DEVICE_SPK, self.STATE_IDLE)

		runtime.soundpath.set_state(self.DEVICE_HS, self.STATE_CONNECT)
		runtime.SP_context.setBandwidthMode(self.DEVICE_HS)
		runtime.SP_context.setDeviceVolume(self.DEVICE_HS, setting.handset_volume)
			
		runtime.SP_context.setCurrentState(SP_TS1_OffHook_HS_OffHook())
		
		yield [self.DEVICE_SPK, self.DEVICE_HSS1_TS1]

	def SPK_OnHook(self):
		yield True

		'''
		if runtime.SP_context.isInSession():
			runtime.SP_context.setDevice(self.DEVICE_HSS1_TS1)
		else:
			runtime.SP_context.speaker.setStatus(Device.ON_HOOK)
			runtime.SP_context.speaker.clearTone()
			runtime.SP_context.stopTonePlay(SP_State.DEVICE_SPK)
		'''
		runtime.soundpath.set_state(self.DEVICE_SPK, self.STATE_IDLE)
		runtime.SP_context.setCurrentState(SP_TS1_OffHook())

		yield False

		yield True

	def TS1_OnHook(self):
		yield True

		'''
		if runtime.SP_context.isInSession():
			runtime.SP_context.setDevice(self.DEVICE_SPK)
		else:
			runtime.SP_context.dect1.setStatus(Device.ON_HOOK)
			runtime.SP_context.dect1.clearTone()
			runtime.SP_context.stopTonePlay(SP_State.DEVICE_HSS1_TS1)
		'''
		# 상태 검사
		stereoState = runtime.SP_context.getDeviceState(self.DEVICE_STEREO_SPK)
		if stereoState:
			runtime.SP_context.SP_stereoStopPlayback()
		runtime.mmedia.HAL_mixer_pause()
		runtime.soundpath.set_state(self.DEVICE_HSS1_TS1, self.STATE_IDLE)		
		# re-open
		baseStatus = runtime.SP_context.getBaseStatus()
		if stereoState and baseStatus != SP_Context.TRANSFER_RINGING:
			runtime.SP_context.SP_stereoPlayback()
		runtime.mmedia.HAL_mixer_resume()
		runtime.SP_context.setCurrentState(SP_SPK_OffHook())
		
		yield True

	def TS2_OffHook(self):
		yield True

		runtime.soundpath.set_state(self.DEVICE_HSS1_TS2, self.STATE_CONNECT)
		runtime.SP_context.setCurrentState(SP_SPK_OffHook_TS1_OffHook_TS2_OffHook())
		
		yield True

	def RED_Pressed(self):
		yield True

		runtime.soundpath.set_state(self.DEVICE_SPK, self.STATE_IDLE)
		runtime.SP_context.setCurrentState(SP_TS1_OffHook())
		
		yield [self.DEVICE_SPK]

	def B2TS2_Transfer(self):
		yield True

		runtime.soundpath.set_state(self.DEVICE_SPK, self.STATE_IDLE)
		runtime.soundpath.set_state(self.DEVICE_HSS1_TS2, self.STATE_CONNECT)
		runtime.SP_context.setCurrentState(SP_TS1_OffHook_TS2_OffHook())
		
		yield True

	def isMessageForDect(self):
		yield True

class SP_SPK_OffHook_TS2_OffHook(SP_State):
	name = 'SP_SPK_OffHook_TS2_OffHook'
	
	def __init__(self):
		SP_State.__init__(self)
		runtime.SP_context.setCurrentDevice([self.DEVICE_SPK, self.DEVICE_HSS1_TS2])
		if runtime.SP_context.isInSession():
			runtime.SP_context.setDevice(SP_Context.DICT_SP_TO_EPT.get(self.DEVICE_SPK) | SP_Context.DICT_SP_TO_EPT.get(self.DEVICE_HSS1_TS2))
	
	def HS_OffHook(self):
		yield True

		runtime.soundpath.set_state(self.DEVICE_HS, self.STATE_CONNECT)
		runtime.SP_context.setBandwidthMode(self.DEVICE_HS)
		runtime.SP_context.setDeviceVolume(self.DEVICE_HS, setting.handset_volume)
		runtime.soundpath.set_state(self.DEVICE_HS, self.STATE_CONNECT)
		
		runtime.SP_context.setCurrentState(SP_SPK_OffHook_TS2_OffHook_HS_OffHook())
		
		yield True

	def SPK_OnHook(self):
		yield True

		if runtime.SP_context.isInSession():
			runtime.SP_context.setDevice(self.DEVICE_HSS1_TS1)
		runtime.soundpath.set_state(self.DEVICE_SPK, self.STATE_IDLE)
		runtime.SP_context.setCurrentState(SP_TS2_OffHook())
		
		yield True

	def TS1_OffHook(self):
		yield True

		# 상태 검사
		stereoState = runtime.SP_context.getDeviceState(self.DEVICE_STEREO_SPK)
		if stereoState:
			runtime.SP_context.SP_stereoStopPlayback()
		runtime.mmedia.HAL_mixer_pause()
		runtime.soundpath.set_state(self.DEVICE_HSS1_TS1, self.STATE_CONNECT)
		# re-open
		baseStatus = runtime.SP_context.getBaseStatus()
		if stereoState and baseStatus != SP_Context.TRANSFER_RINGING:
			runtime.SP_context.SP_stereoPlayback()
		runtime.mmedia.HAL_mixer_resume()
		runtime.SP_context.setCurrentState(SP_SPK_OffHook_TS2_OffHook_TS1_OffHook())
		
		yield True

	def TS2_OnHook(self):
		yield True

		if runtime.SP_context.isInSession():
			runtime.SP_context.setDevice(self.DEVICE_SPK)
		runtime.soundpath.set_state(self.DEVICE_HSS1_TS2, self.STATE_IDLE)
		runtime.SP_context.setCurrentState(SP_SPK_OffHook())
		
		yield True

	def B2TS1_Transfer(self):
		yield True

		runtime.soundpath.set_state(self.DEVICE_SPK, self.STATE_IDLE)
		runtime.soundpath.set_state(self.DEVICE_HSS1_TS1, self.STATE_CONNECT)
		runtime.SP_context.setCurrentState(SP_TS2_OffHook_TS1_OffHook())
		
		yield True

class SP_TS1_OffHook_HS_OffHook(SP_HS_OffHook_TS1_OffHook):
	name = 'SP_TS1_OffHook_HS_OffHook'

	def __init__(self):
		SP_HS_OffHook_TS1_OffHook.__init__(self)
	
class SP_TS1_OffHook_SPK_OffHook(SP_SPK_OffHook_TS1_OffHook):
	name = 'SP_TS1_OffHook_SPK_OffHook'

	def __init__(self):
		SP_SPK_OffHook_TS1_OffHook.__init__(self)
	
class SP_TS1_OffHook_TS2_OffHook(SP_State):
	name = 'SP_TS1_OffHook_TS2_OffHook'

	def __init__(self):
		SP_State.__init__(self)
		runtime.SP_context.setCurrentDevice([self.DEVICE_HSS1_TS1, self.DEVICE_HSS1_TS2])
		if runtime.SP_context.isInSession():
			runtime.SP_context.setDevice(SP_Context.DICT_SP_TO_EPT.get(self.DEVICE_HSS1_TS1) | SP_Context.DICT_SP_TO_EPT.get(self.DEVICE_HSS1_TS2))
	
	def TS1_OnHook(self):
		yield True

		if runtime.SP_context.isInSession():
			runtime.SP_context.setDevice(self.DEVICE_HSS1_TS2)
		# 상태 검사
		stereoState = runtime.SP_context.getDeviceState(self.DEVICE_STEREO_SPK)
		if stereoState:
			runtime.SP_context.SP_stereoStopPlayback()
		runtime.mmedia.HAL_mixer_pause()
		runtime.soundpath.set_state(self.DEVICE_HSS1_TS1, self.STATE_IDLE)
		# re-open
		baseStatus = runtime.SP_context.getBaseStatus()
		if stereoState and baseStatus != SP_Context.TRANSFER_RINGING:
			runtime.SP_context.SP_stereoPlayback()
		runtime.mmedia.HAL_mixer_resume()
		runtime.SP_context.setCurrentState(SP_TS2_OffHook())
		
		yield True

	def TS2_OnHook(self):
		yield True

		if runtime.SP_context.isInSession():
			runtime.SP_context.setDevice(self.DEVICE_HSS1_TS1)
		runtime.soundpath.set_state(self.DEVICE_HSS1_TS2, self.STATE_IDLE)
		runtime.SP_context.setCurrentState(SP_TS1_OffHook())
		
		yield True

class SP_TS2_OffHook_HS_OffHook(SP_HS_OffHook_TS2_OffHook):
	name = 'SP_TS2_OffHook_HS_OffHook'

	def __init__(self):
		SP_HS_OffHook_TS2_OffHook.__init__(self)

class SP_TS2_OffHook_SPK_OffHook(SP_SPK_OffHook_TS2_OffHook):
	name = 'SP_TS2_OffHook_SPK_OffHook'

	def __init__(self):
		SP_SPK_OffHook_TS2_OffHook.__init__(self)

class SP_TS2_OffHook_TS1_OffHook(SP_TS1_OffHook_TS2_OffHook):
	name = 'SP_TS2_OffHook_TS1_OffHook'

	def __init__(self):
		SP_TS1_OffHook_TS2_OffHook.__init__(self)

class SP_HS_OffHook_SPK_OffHook_TS1_OffHook(SP_State):
	name = 'SP_HS_OffHook_SPK_OffHook_TS1_OffHook'

	def __init__(self):
		SP_State.__init__(self)
		runtime.SP_context.setCurrentDevice([self.DEVICE_HS, self.DEVICE_SPK, self.DEVICE_HSS1_TS1])
		if runtime.SP_context.isInSession():
			runtime.SP_context.setPhysicalDevice()
		'''
			#runtime.SP_context.setDevice(SP_Context.DICT_SP_TO_EPT.get(self.DEVICE_HS) | \
			#	SP_Context.DICT_SP_TO_EPT.get(self.DEVICE_SPK) | \
			#	SP_Context.DICT_SP_TO_EPT.get(self.DEVICE_HSS1_TS1))
			runtime.SP_context.startTonePlay()
		else:
			runtime.SP_context.startTonePlay()	
		'''

		#runtime.mmedia.unload()
		#runtime.soundpath.set_state(self.DEVICE_STEREO_SPK, self.STATE_IDLE)
		
	def HS_OnHook(self):
		yield True

		'''
		if not runtime.SP_context.isInSession():
			runtime.SP_context.handset.setStatus(Device.ON_HOOK)
			runtime.SP_context.handset.clearTone()
			runtime.SP_context.stopTonePlay(SP_State.DEVICE_HS)
		'''
		runtime.soundpath.set_state(self.DEVICE_HS, self.STATE_IDLE)
		runtime.SP_context.setCurrentState(SP_SPK_OffHook_TS1_OffHook())
		
		yield [self.DEVICE_SPK, self.DEVICE_HSS1_TS1]

	def SPK_OnHook(self):
		yield True

		'''
		if not runtime.SP_context.isInSession():
			runtime.SP_context.speaker.setStatus(Device.ON_HOOK)
			runtime.SP_context.speaker.clearTone()
			runtime.SP_context.stopTonePlay(SP_State.DEVICE_SPK)
		'''
		
		runtime.soundpath.set_state(self.DEVICE_SPK, self.STATE_IDLE)
		runtime.SP_context.setCurrentState(SP_HS_OffHook_TS1_OffHook())
		
		yield True

	def TS1_OnHook(self):
		yield True

		'''
		if not runtime.SP_context.isInSession():
			runtime.SP_context.dect1.setStatus(Device.ON_HOOK)
			runtime.SP_context.dect1.clearTone()
			runtime.SP_context.stopTonePlay(SP_State.DEVICE_HSS1_TS1)
		'''
		
		# 상태 검사
		stereoState = runtime.SP_context.getDeviceState(self.DEVICE_STEREO_SPK)
		if stereoState:
			runtime.SP_context.SP_stereoStopPlayback()
		runtime.mmedia.HAL_mixer_pause()
		runtime.soundpath.set_state(self.DEVICE_HSS1_TS1, self.STATE_IDLE)
		# re-open
		baseStatus = runtime.SP_context.getBaseStatus()
		if stereoState and baseStatus != SP_Context.TRANSFER_RINGING:
			runtime.SP_context.SP_stereoPlayback()
		runtime.mmedia.HAL_mixer_resume()
		runtime.SP_context.setCurrentState(SP_HS_OffHook_SPK_OffHook())
		
		yield True

	def RED_Pressed(self):
		yield True

		runtime.soundpath.set_state(self.DEVICE_HS, self.STATE_IDLE)
		runtime.soundpath.set_state(self.DEVICE_SPK, self.STATE_IDLE)
		runtime.SP_context.setCurrentState(SP_TS1_OffHook())
		
		yield [self.DEVICE_HS, self.DEVICE_SPK]

	def B2TS2_Transfer(self):
		yield True

		runtime.soundpath.set_state(self.DEVICE_HS, self.STATE_IDLE)
		runtime.soundpath.set_state(self.DEVICE_SPK, self.STATE_IDLE)
		runtime.soundpath.set_state(self.DEVICE_HSS1_TS2, self.STATE_CONNECT)
		runtime.SP_context.setCurrentState(SP_TS1_OffHook_TS2_OffHook())

		yield True

class SP_HS_OffHook_SPK_OffHook_TS2_OffHook(SP_State):
	name = 'SP_HS_OffHook_SPK_OffHook_TS2_OffHook'

	def __init__(self):
		SP_State.__init__(self)
		runtime.SP_context.setCurrentDevice([self.DEVICE_HS, self.DEVICE_SPK, self.DEVICE_HSS1_TS2])
		if runtime.SP_context.isInSession():
			runtime.SP_context.setDevice(SP_Context.DICT_SP_TO_EPT.get(self.DEVICE_HS) | \
				SP_Context.DICT_SP_TO_EPT.get(self.DEVICE_SPK) | \
				SP_Context.DICT_SP_TO_EPT.get(self.DEVICE_HSS1_TS2))
	
	def HS_OnHook(self):
		yield True

		if runtime.SP_context.isInSession():
			# 현재 지원되지 않으므로 단순히 SPK로만 함.
			runtime.SP_context.setDevice(self.DEVICE_SPK)
		runtime.soundpath.set_state(self.DEVICE_HS, self.STATE_IDLE)
		runtime.SP_context.setCurrentState(SP_SPK_OffHook_TS2_OffHook())
		
		yield True

	def SPK_OnHook(self):
		yield True

		if runtime.SP_context.isInSession():
			# 현재 지원되지 않으므로 단순히 HS로만 함.
			runtime.SP_context.setDevice(self.DEVICE_HS)
		runtime.soundpath.set_state(self.DEVICE_SPK, self.STATE_IDLE)
		runtime.SP_context.setCurrentState(SP_HS_OffHook_TS2_OffHook())
		
		yield True

	def TS2_OnHook(self):
		yield True

		if runtime.SP_context.isInSession():
			# 현재 지원되지 않으므로 단순히 HS로만 함.
			runtime.SP_context.setDevice(self.DEVICE_HS)
		runtime.soundpath.set_state(self.DEVICE_HSS1_TS2, self.STATE_IDLE)
		runtime.SP_context.setCurrentState(SP_HS_OffHook_SPK_OffHook())
		
		yield True

	def B2TS1_Transfer(self):
		yield True

		runtime.soundpath.set_state(self.DEVICE_HS, self.STATE_IDLE)
		runtime.soundpath.set_state(self.DEVICE_SPK, self.STATE_IDLE)
		runtime.soundpath.set_state(self.DEVICE_HSS1_TS1, self.STATE_CONNECT)
		runtime.SP_context.setCurrentState(SP_TS2_OffHook_TS1_OffHook())

		yield True

class SP_HS_OffHook_TS1_OffHook_SPK_OffHook(SP_HS_OffHook_SPK_OffHook_TS1_OffHook):
	name = 'SP_HS_OffHook_TS1_OffHook_SPK_OffHook'

	def __init__(self):
		SP_HS_OffHook_SPK_OffHook_TS1_OffHook.__init__(self)

class SP_HS_OffHook_TS2_OffHook_SPK_OffHook(SP_HS_OffHook_SPK_OffHook_TS2_OffHook):
	name = 'SP_HS_OffHook_TS2_OffHook_SPK_OffHook'

	def __init__(self):
		SP_HS_OffHook_SPK_OffHook_TS2_OffHook.__init__(self)

class SP_SPK_OffHook_TS1_OffHook_HS_OffHook(SP_HS_OffHook_SPK_OffHook_TS1_OffHook):
	name = 'SP_SPK_OffHook_TS1_OffHook_HS_OffHook'

	def __init__(self):
		SP_HS_OffHook_SPK_OffHook_TS1_OffHook.__init__(self)

class SP_SPK_OffHook_TS2_OffHook_HS_OffHook(SP_HS_OffHook_SPK_OffHook_TS2_OffHook):
	name = 'SP_SPK_OffHook_TS2_OffHook_HS_OffHook'

	def __init__(self):
		SP_HS_OffHook_SPK_OffHook_TS2_OffHook.__init__(self)

class SP_SPK_OffHook_TS1_OffHook_TS2_OffHook(SP_State):
	name = 'SP_SPK_OffHook_TS1_OffHook_TS2_OffHook'

	def __init__(self):
		SP_State.__init__(self)
		runtime.SP_context.setCurrentDevice([self.DEVICE_SPK, self.DEVICE_HSS1_TS1, self.DEVICE_HSS1_TS2])
		if runtime.SP_context.isInSession():
			runtime.SP_context.setDevice(SP_Context.DICT_SP_TO_EPT.get(self.DEVICE_SPK) | \
				SP_Context.DICT_SP_TO_EPT.get(self.DEVICE_HSS1_TS1) | \
				SP_Context.DICT_SP_TO_EPT.get(self.DEVICE_HSS1_TS2))

	def SPK_OnHook(self):
		yield True

		if runtime.SP_context.isInSession():
			# 현재 지원되지 않으므로 단순히 DEVICE_HSS1_TS1로만 함.
			runtime.SP_context.setDevice(self.DEVICE_HSS1_TS1)
		runtime.soundpath.set_state(self.DEVICE_SPK, self.STATE_IDLE)
		runtime.SP_context.setCurrentState(SP_TS1_OffHook_TS2_OffHook())
		
		yield True
	
	def TS1_OnHook(self):
		yield True

		if runtime.SP_context.isInSession():
			# 현재 지원되지 않으므로 단순히 DEVICE_SPK로만 함.
			runtime.SP_context.setDevice(self.DEVICE_SPK)
		# 상태 검사
		stereoState = runtime.SP_context.getDeviceState(self.DEVICE_STEREO_SPK)
		if stereoState:
			runtime.SP_context.SP_stereoStopPlayback()
		runtime.mmedia.HAL_mixer_pause()
		runtime.soundpath.set_state(self.DEVICE_HSS1_TS1, self.STATE_IDLE)
		# re-open
		baseStatus = runtime.SP_context.getBaseStatus()
		if stereoState and baseStatus != SP_Context.TRANSFER_RINGING:
			runtime.SP_context.SP_stereoPlayback()
		runtime.mmedia.HAL_mixer_resume()
		runtime.SP_context.setCurrentState(SP_TS2_OffHook())
		
		yield True

	def TS2_OnHook(self):
		yield True

		if runtime.SP_context.isInSession():
			# 현재 지원되지 않으므로 단순히 DEVICE_SPK로만 함.
			runtime.SP_context.setDevice(self.DEVICE_SPK)
		runtime.soundpath.set_state(self.DEVICE_HSS1_TS2, self.STATE_IDLE)
		runtime.SP_context.setCurrentState(SP_TS1_OffHook())
		
		yield True

class SP_SPK_OffHook_TS2_OffHook_TS1_OffHook(SP_State):
	name = 'SP_SPK_OffHook_TS2_OffHook_TS1_OffHook'

	def __init__(self):
		SP_SPK_OffHook_TS1_OffHook_TS2_OffHook.__init__(self)

class SP_Context:
	# from tupbr.h
	DICT_SP_TO_EPT = {SP_State.DEVICE_HS:0x01, SP_State.DEVICE_SPK:0x02, SP_State.DEVICE_HSS1_TS1:0x04, SP_State.DEVICE_HSS1_TS2:0x08}

	IDLE = 0
	RINGING = 1
	DIALING = 2
	RINGBACK = 3
	CONNECTED = 4
	BUSY = 5

	TRANSFER_RINGING = 6
	
	#IDLE = 0
	OUTGOING_AUDIO = 1
	OUTGOING_VIDEO = 2
	INCOMING_AUDIO = 3
	INCOMING_VIDEO = 4

	def __init__(self):
		#self.currentState = SP_Idle()
		#self.currentDevice = []

		self.currentState = None
		self.currentDevice = None
		self.widebandCodecFlag = False
		
		runtime.soundpath = soundpath.SoundPath()
		#runtime.TNP = TelephoneNumberPolicy()

		self.inSession = False
		self.baseStatus = self.IDLE
		self.baseCallStatus = self.IDLE
		self.toneInPlaying = None

		self.handset = Handset()
		self.speaker = Speaker()
		self.dect1 = DECT1()

		self.stereoPlaybackFlag = False

		self.keyTonePlaying = False

	def isKeyTonePlaying(self):
		runtime.mmiDebug.mmiTrace('KEY TONE STATUS = ', self.keyTonePlaying)
		return self.keyTonePlaying

	def setKeyTonePlaying(self, keyTonePlaying):
		self.keyTonePlaying = keyTonePlaying
		runtime.mmiDebug.mmiTrace('SET KEY TONE STATUS = ', self.keyTonePlaying)
		
	def getStereoPlaybackFlag(self):
		return self.stereoPlaybackFlag

	def setStereoPlaybackFlag(self, stereoPlaybackFlag):
		self.stereoPlaybackFlag = stereoPlaybackFlag
		
	def getBaseCallStatus(self):
		return self.baseCallStatus

	def setBaseCallStatus(self, baseCallStatus):
		self.baseCallStatus = baseCallStatus
		
	def getBaseStatus(self):
		return self.baseStatus

	def setBaseStatus(self, baseStatus):
		runtime.mmiDebug.mmiTrace('setBaseStatus = ', baseStatus)
		self.baseStatus = baseStatus
		
	def isInSession(self):
		return self.inSession

	def setInSession(self, inSession):
		self.inSession = inSession	

	def getCurrentStateName(self):
		return self.currentState.getName()

	def getWidebandCodecFlag(self):
		return self.widebandCodecFlag

	def clearWidebandCodecFlag(self):
		self.widebandCodecFlag = False
		
	def setWidebandCodecFlag(self, widebandCodec):
		if widebandCodec == '9' or widebandCodec == '96':
			self.widebandCodecFlag = True
		else:
			self.widebandCodecFlag = False
		
	def getCurrentState(self):
		return self.currentState

	def setCurrentState(self, currentState):
		runtime.mmiDebug.mmiTrace('SET currnent SP State ==> ', currentState.getName())
		
		self.currentState = currentState

	def getCurrentDevice(self):
		runtime.mmiDebug.mmiTrace('Current Devices = ', self.currentDevice)
		return self.currentDevice
		
	def setCurrentDevice(self, currentDevice):
		self.currentDevice = currentDevice

	## 각 state에 가해지는 Action들
	def HS_OffHook(self):
		return self.currentState.HS_OffHook()
		
	def HS_OnHook(self):
		return self.currentState.HS_OnHook()

	def SPK_OffHook(self, dialNumber=False):
		return self.currentState.SPK_OffHook(dialNumber)

	def SPK_OnHook(self):
		return self.currentState.SPK_OnHook()

	def HDS1_OffHook(self):
		return self.currentState.HDS1_OffHook()

	def HDS1_OnHook(self):
		return self.currentState.HDS1_OnHook()

	def TS1_OffHook(self):
		return self.currentState.TS1_OffHook() 

	def TS1_OnHook(self):
		return self.currentState.TS1_OnHook() 

	def TS2_OffHook(self):
		return self.currentState.TS2_OffHook()

	def TS2_OnHook(self):
		return self.currentState.TS2_OnHook()

	def BT_OffHook(self):
		return self.currentState.BT_OffHook()

	def BT_OnHook(self):
		return self.currentState.BT_OnHook()

	def RED_Pressed(self):
		return self.currentState.RED_Pressed()

	def B2TS1_Transfer(self):
		return self.currentState.B2TS1_Transfer()

	def B2TS2_Transfer(self):
		return self.currentState.B2TS2_Transfer()

	def SP_stereoPlayback(self):
		return self.currentState.SP_stereoPlayback()

	def SP_stereoStopPlayback(self):
		return self.currentState.SP_stereoStopPlayback()

	def SP_startPlayback(self):
		return self.currentState.SP_startPlayback()

	def SP_stopPlayback(self):
		return self.currentState.SP_stopPlayback()
		
	def SP_startRecord(self):
		return self.currentState.SP_startRecord()

	def SP_stopRecord(self):
		return self.currentState.SP_stopRecord()

	def SP_setMicDisableAll(self):
		self.currentState.SP_setMicDisableAll()

	def SP_setMicEnableAll(self):
		self.currentState.SP_setMicEnableAll()

	def SP_setMicDisable(self):
		self.currentState.SP_setMicDisable()

	def SP_setMicEnable(self):
		self.currentState.SP_setMicEnable()

	def SP_playWav(self, device, filename, loop=True):
		self.currentState.SP_playWav(device, filename, loop)

	def SP_stopWav(self):
		self.currentState.SP_stopWav()

	def isMessageForDect(self):
		return self.currentState.isMessageForDect()
		
	## HAL driver Upload/Download
	def HAL_open(self):
		runtime.soundpath.hal_open()

	def HAL_close(self):
		runtime.soundpath.hal_close()

	def getDeviceState(self, device):
		# 0 : IDLE / 1 : 그외 상태
		return runtime.soundpath.get_state(device)

	def goIdleState(self, includingDect=True):
		runtime.mmiDebug.mmiTrace('go to IDLE stage')
		remainingDect = False
		for device in self.currentDevice:
			if device == SP_State.DEVICE_HSS1_TS1 and includingDect == False:
				remainingDect = True
				continue
			runtime.soundpath.set_state(device, SP_State.STATE_IDLE)

		if remainingDect:
			self.currentState = SP_TS1_OffHook()
		else:
			self.currentState = SP_Idle()

	def setStereoVolume(self, volume = 4):
		runtime.mmiDebug.mmiTrace('set stereo volume:', volume)
		runtime.soundpath.set_volume(SP_State.DEVICE_STEREO_SPK, volume)

	def setRingVolume(self, volume = 4 ):
		runtime.mmiDebug.mmiTrace('set ring volume:', volume)
		runtime.soundpath.set_volume(SP_State.DEVICE_SPK, volume)

	def setKeytoneVolume(self, volume = 4):
		runtime.mmiDebug.mmiTrace('set keytone volume:', volume)

		for device in self.currentDevice:
			if device == SP_State.DEVICE_HS:
				self.setDeviceVolume(SP_State.DEVICE_HS, volume)
			elif device == SP_State.DEVICE_SPK:
				self.setDeviceVolume(SP_State.DEVICE_SPK, volume)
		
	def setDeviceVolume(self, device, volume=4):
		runtime.mmiDebug.mmiTrace('set device volume in ', device, ' : ', volume)
		runtime.soundpath.set_volume(device, volume)

		if self.isInSession():
			runtime.vdci_send_mesg(code1=config.MESG_SET_PARAMS, code2=config.MESG_SW_VOLUME, \
				mesg1=self.DICT_SP_TO_EPT.get(device), mesg2=volume, mesg3='1')

	def getPhysicalDevice(self, device):
		return self.DICT_SP_TO_EPT.get(device)	

	def getDeviceVolume(self, device):
		if device == SP_State.DEVICE_HS:
			return setting.handset_volume
		elif device == SP_State.DEVICE_SPK:
			return setting.speaker_volume
		elif device == SP_State.DEVICE_HSS1_TS1:
			return setting.speaker_volume

	def setSoundpathVolume(self):
		for device in self.currentDevice:
			volume = self.getDeviceVolume(device)
			runtime.soundpath.set_volume(device, volume)
	
	def setPhysicalDevice(self):
		runtime.mmiDebug.mmiTrace('SET DEVICE')
		targetDevices = []

		import status
		from dectHandler import DectCallManager
		baseCallStatus, baseStatus, dectCallStatus, dectStatus = status.getCurrentCallStatus()
		if SP_State.DEVICE_HSS1_TS1 in self.currentDevice:
			if dectStatus in [DectCallManager.CONNECTED, DectCallManager.CONNECTING, DectCallManager.RINGBACK, DectCallManager.DIALING]:
				targetDevices.append(SP_State.DEVICE_HSS1_TS1)
			else:
				if len(self.currentDevice) > 1:
					 targetDevices = self.currentDevice.remove(SP_State.DEVICE_HSS1_TS1)
		else:
			targetDevices = self.currentDevice
			
		oringDevice = 0
		for device in targetDevices:
			physicalDevice = self.DICT_SP_TO_EPT.get(device)
			volume = self.getDeviceVolume(device)
			runtime.vdci_send_mesg(code1=config.MESG_SET_PARAMS, code2=config.MESG_SW_VOLUME, \
				mesg1=self.DICT_SP_TO_EPT.get(device), mesg2=volume, mesg3='1')
			oringDevice = oringDevice | physicalDevice
		self.setDevice(oringDevice)

	def setDeviceWithSoundpath(self, device):
		runtime.mmiDebug.mmiTrace('SET DEVICE With Soundpath')
		physicalDevice = self.DICT_SP_TO_EPT.get(device)
		runtime.vdci_send_mesg(code1=config.MESG_SET_PARAMS, code2=config.MESG_EPT_DEVICE, \
			mesg1=config.EPT_SET_DEVICE, mesg2=str(physicalDevice))

	def setDevice(self, physicalDevice):
		runtime.mmiDebug.mmiTrace('SET DEVICE')
		runtime.vdci_send_mesg(code1=config.MESG_SET_PARAMS, code2=config.MESG_EPT_DEVICE, \
			mesg1=config.EPT_SET_DEVICE, mesg2=str(physicalDevice))
				
	def setDevice_old(self):
		runtime.mmiDebug.mmiTrace('SET DEVICE')
		firstDevice = True
		for device in self.currentDevice:
			if firstDevice:
				runtime.vdci_send_mesg(code1=config.MESG_SET_PARAMS, code2=config.MESG_EPT_DEVICE, \
					mesg1=config.EPT_SET_DEVICE, mesg2=str(self.DICT_SP_TO_EPT.get(device)))
				firstDevice = False
			else:
				self.addDevice(device)

	def addDevice(self, device):
		runtime.mmiDebug.mmiTrace('ADD DEVICE')
		runtime.vdci_send_mesg(code1=config.MESG_SET_PARAMS, code2=config.MESG_EPT_DEVICE, \
			mesg1=config.EPT_ADD_DEVICE, mesg2=str(self.DICT_SP_TO_EPT.get(device)))

	def setEqualizer(self):
		for device in self.currentDevice:
			self.setBandwidthMode(device)
			
	def setBandwidthMode(self, device):
		runtime.mmiDebug.mmiTrace('set Bandwidth Mode in ', device)

		if device == SP_State.DEVICE_HS:
			if self.widebandCodecFlag == True:
				runtime.mmiDebug.mmiTrace('EXECUTE Wideband equset in HS')
				runtime.soundpath.equset(1, 1, "/usr/etc/wb_hs_coeff.txt")
				#os.system('equset 1 1 /usr/etc/wb_hs_coeff.txt')
				runtime.soundpath.set_wideband(SP_State.DEVICE_HS, config.WIDEBAND)
			else:
				runtime.mmiDebug.mmiTrace('EXECUTE Narrowband equalizer in HS')
				runtime.soundpath.equset(1, 1, "/usr/etc/nb_hs_coeff.txt")
				#os.system('equset 1 1 /usr/etc/nb_hs_coeff.txt')
				runtime.soundpath.set_wideband(SP_State.DEVICE_HS, config.NARROWBAND)
		elif device == SP_State.DEVICE_SPK:
			if self.widebandCodecFlag == True:
				runtime.mmiDebug.mmiTrace('EXECUTE Wideband equalizer in SPK')
				runtime.soundpath.equset(0, 1, "/usr/etc/wb_hf_coeff.txt")
				#os.system('equset 0 1 /usr/etc/wb_hf_coeff.txt')
				runtime.soundpath.set_wideband(SP_State.DEVICE_SPK, config.WIDEBAND)
			else:
				runtime.mmiDebug.mmiTrace('EXECUTE Narrowband equalizer in SPK')
				runtime.soundpath.equset(0, 1, "/usr/etc/nb_hf_coeff.txt")
				#os.system('equset 0 1 /usr/etc/nb_hf_coeff.txt')
				runtime.soundpath.set_wideband(SP_State.DEVICE_SPK, config.NARROWBAND)
		elif device == SP_State.DEVICE_HSS1_TS1:
			if self.widebandCodecFlag == True:
				runtime.mmiDebug.mmiTrace('EXECUTE Wideband equalizer in TS1')
				runtime.soundpath.set_wideband(SP_State.DEVICE_HSS1_TS1, config.WIDEBAND)
			else:
				runtime.mmiDebug.mmiTrace('EXECUTE Narrowband equalizer in TS1')
				runtime.soundpath.set_wideband(SP_State.DEVICE_HSS1_TS1, config.NARROWBAND)

	def clearToneStatus(self, device):
		if device == SP_State.DEVICE_HS:
			self.handset.clearStatus()
		elif device == SP_State.DEVICE_SPK:
			self.speaker.clearStatus()
		elif device == SP_State.DEVICE_HSS1_TS1:
			self.dect1.clearStatus()

	def setTonePlaying(self, device):
		if device == SP_State.DEVICE_HS:
			if self.handset.isTonePlaying():
				return False
			else:
				self.handset.setTonePlaying(True)
		elif device == SP_State.DEVICE_SPK:
			if self.speaker.isTonePlaying():
				return False
			else:
				self.speaker.setTonePlaying(True)
		elif device == SP_State.DEVICE_HSS1_TS1:
			if self.dect1.isTonePlaying():
				return False
			else:
				self.dect1.setTonePlaying(True)
		return True
	
	def setTonePlaying_old(self, device):
		if device == SP_State.DEVICE_HS:
			if self.handset.isTonePlaying():
				return False
			else:
				self.handset.setTonePlaying(True)
		elif device == SP_State.DEVICE_SPK:
			if self.speaker.isTonePlaying():
				return False
			else:
				self.speaker.setTonePlaying(True)
		elif device == SP_State.DEVICE_HSS1_TS1:
			if self.dect1.isTonePlaying():
				return False
			else:
				self.dect1.setTonePlaying(True)
		return True
		
	def clearTonePlaying(self, device):
		if device == SP_State.DEVICE_HS:
			self.handset.setTonePlaying(False)
		elif device == SP_State.DEVICE_SPK:
			self.speaker.setTonePlaying(False)
		elif device == SP_State.DEVICE_HSS1_TS1:
			self.dect1.setTonePlaying(False)
	
	def getTone(self, device):
		if device == SP_State.DEVICE_HS:
			return self.handset.getTone()
		elif device == SP_State.DEVICE_SPK:
			return self.speaker.getTone()
		elif device == SP_State.DEVICE_HSS1_TS1:
			return self.dect1.getTone()

	def setErrorTone(self, tone):
		from dectHandler import DectCallManager
		from mmiSoundPath import SP_Context

		currentDevices = runtime.SP_context.getCurrentDevice()
		for currentDevice in currentDevices:
			runtime.SP_context.startTonePlay(currentDevice, tone)
			if currentDevice == SP_State.DEVICE_HS:
				runtime.SP_context.handset.setTone(tone)	
			elif currentDevice == SP_State.DEVICE_SPK:
				runtime.SP_context.speaker.setTone(tone)
		
		'''
		from dectHandler import DectCallManager
		from mmiSoundPath import SP_Context
		dectStatus = runtime.dectCallManager.getDectStatus()
		baseStatus = runtime.SP_context.getBaseStatus()
		if dectStatus == DectCallManager.DIALING or dectStatus == DectCallManager.CONNECTING:
			runtime.dectCallManager.setDectStatus(DectCallManager.BUSY)		
			runtime.SP_context.dect1.setTone(tone)
			runtime.SP_context.startTonePlay(SP_State.DEVICE_HSS1_TS1)
		elif baseStatus == SP_Context.DIALING:
			runtime.SP_context.setBaseStatus(SP_Context.BUSY)
			currentDevices = runtime.SP_context.getCurrentDevice()
			if SP_State.DEVICE_SPK in currentDevices:
				runtime.SP_context.speaker.setTone(tone)
				runtime.SP_context.startTonePlay(SP_State.DEVICE_SPK)
			if SP_State.DEVICE_HS in currentDevices:
				runtime.SP_context.handset.setTone(tone)
				runtime.SP_context.startTonePlay(SP_State.DEVICE_HS)
		'''
	def startTonePlay(self, device=None, commonTone=None):
		runtime.mmiDebug.mmiTrace('startTonePlay : ', device, commonTone)
		if device == None:
			for device in self.currentDevice:
				if commonTone:
					tone = commonTone
				else:
					tone = self.getTone(device)
				#if tone and self.setTonePlaying(device):
				if tone:
					physicalDevice = runtime.SP_context.getPhysicalDevice(device)
					if tone == config.PLAY_DIAL_TONE:
						runtime.vdci_send_mesg(code1=config.MESG_PLAY_TONE, code2=config.MESG_PLAY_TONE_ACTIVE, \
							mesg1=config.PLAY_DIAL_TONE, mesg2=0, mesg3=physicalDevice)
					elif tone == config.PLAY_RINGBACK_TONE:
						runtime.vdci_send_mesg(code1=config.MESG_PLAY_TONE, code2=config.MESG_PLAY_TONE_ACTIVE, \
							mesg1=config.PLAY_RINGBACK_TONE, mesg2=0, mesg3=physicalDevice)
					elif tone == config.PLAY_BUSY_TONE:
						runtime.vdci_send_mesg(code1=config.MESG_PLAY_TONE, code2=config.MESG_PLAY_TONE_ACTIVE, \
							mesg1=config.PLAY_BUSY_TONE, mesg2=0, mesg3=physicalDevice)
					elif tone == config.PLAY_CG_TONE:
						runtime.vdci_send_mesg(code1=config.MESG_PLAY_TONE, code2=config.MESG_PLAY_TONE_ACTIVE, \
							mesg1=config.PLAY_CG_TONE, mesg2=0, mesg3=physicalDevice)
					else: # DTMF
						from vdcisetting import vdci_setting
						runtime.vdci_send_mesg(code1=config.MESG_PLAY_TONE, code2=config.MESG_PLAY_TONE_ACTIVE, \
							mesg1=tone, mesg2=vdci_setting.dtmf_duration, mesg3=physicalDevice)
		else:
			if commonTone:
				tone = commonTone
			else:
				tone = self.getTone(device)
			if tone and self.setTonePlaying(device):
				physicalDevice = self.getPhysicalDevice(device)
				if tone == config.PLAY_DIAL_TONE:
					runtime.vdci_send_mesg(code1=config.MESG_PLAY_TONE, code2=config.MESG_PLAY_TONE_ACTIVE, \
						mesg1=config.PLAY_DIAL_TONE, mesg2=0, mesg3=physicalDevice)
				elif tone == config.PLAY_RINGBACK_TONE:
					runtime.vdci_send_mesg(code1=config.MESG_PLAY_TONE, code2=config.MESG_PLAY_TONE_ACTIVE, \
						mesg1=config.PLAY_RINGBACK_TONE, mesg2=0, mesg3=physicalDevice)
				elif tone == config.PLAY_BUSY_TONE:
					runtime.vdci_send_mesg(code1=config.MESG_PLAY_TONE, code2=config.MESG_PLAY_TONE_ACTIVE, \
						mesg1=config.PLAY_BUSY_TONE, mesg2=0, mesg3=physicalDevice)
				elif tone == config.PLAY_CG_TONE:
					runtime.vdci_send_mesg(code1=config.MESG_PLAY_TONE, code2=config.MESG_PLAY_TONE_ACTIVE, \
						mesg1=config.PLAY_CG_TONE, mesg2=0, mesg3=physicalDevice)
				else: # DTMF
					from vdcisetting import vdci_setting
					runtime.vdci_send_mesg(code1=config.MESG_PLAY_TONE, code2=config.MESG_PLAY_TONE_ACTIVE, \
						mesg1=tone, mesg2=vdci_setting.dtmf_duration, mesg3=physicalDevice)

	def stopTonePlay(self, device=None):
		if device != None:
			runtime.SP_context.clearToneStatus(device)
			physicalDevice = runtime.SP_context.getPhysicalDevice(device)
			runtime.vdci_send_mesg(code1=config.MESG_PLAY_TONE, code2=config.MESG_PLAY_TONE_DEACTIVE, mesg3=physicalDevice)
		else:
			for device in self.currentDevice:
				runtime.SP_context.clearToneStatus(device)
				physicalDevice = runtime.SP_context.getPhysicalDevice(device)
				runtime.vdci_send_mesg(code1=config.MESG_PLAY_TONE, code2=config.MESG_PLAY_TONE_DEACTIVE, mesg3=physicalDevice)
			
			self.toneInPlaying = None

	def startKeyTonePlay(self, device=None, key=None, duration=None):
		runtime.mmiDebug.mmiTrace('startKeyTonePlay : ', device, key, duration)
		from vdcisetting import vdci_setting
		if not duration:
			duration = vdci_setting.dtmf_duration
			
		physicalDevice = runtime.SP_context.getPhysicalDevice(device)
		runtime.vdci_send_mesg(code1=config.MESG_PLAY_TONE, code2=config.MESG_PLAY_TONE_ACTIVE, \
			mesg1=key, mesg2=duration, mesg3=physicalDevice)
							
	def stopKeyTonePlay(self, device=None):
		if device != None:
			runtime.SP_context.clearToneStatus(device)
			physicalDevice = runtime.SP_context.getPhysicalDevice(device)
			runtime.vdci_send_mesg(code1=config.MESG_PLAY_TONE, code2=config.MESG_PLAY_TONE_DEACTIVE, mesg3=physicalDevice)
		else:
			for device in self.currentDevice:
				runtime.SP_context.clearToneStatus(device)
				physicalDevice = runtime.SP_context.getPhysicalDevice(device)
				runtime.vdci_send_mesg(code1=config.MESG_PLAY_TONE, code2=config.MESG_PLAY_TONE_DEACTIVE, mesg3=physicalDevice)
			
			self.toneInPlaying = None

	def combineTwoPath(self, path1, path2):
		runtime.soundpath.connect(path1, path2)

	def devideTwoPath(self, path1, path2):
		runtime.soundpath.disconnect(path1, path2)

if runtime.mmedia == None:
	from mmedia import Mmedia
	runtime.mmedia = Mmedia()
		
runtime.SP_context = SP_Context()
runtime.SP_context.setCurrentState(SP_Idle())
runtime.SP_context.setCurrentDevice([])