import time
import signal
import os
import utils
import runtime, uiconfig, config
import phonesetting
from basemodel import Stage, NotifyStage, EntryStage, RichTextStage, ListStage
from baseui import LargeWindowUI, SmallWindowUI, NotifyUI, RichTextUI
from setting import setting
from profile import lan_profile
import profile, status
from runtime import mmiDebug as MD
from menu import DirectCallTeststage, DevMisc

####common
test_color = ((255,0,0,255),(0,255,0,255),(0,0,255,255),(0,0,0,255),(255,255,255,255))
test_image = ['TP01.PNG', 'TP02.PNG', 'TP03.PNG', 'TP04.PNG','TP05.PNG', 'TP06.PNG', 'TP07.PNG', 'TP08.PNG', 'TP09.PNG', 'TP10.PNG']
testplay_pid = None


def play_test(file):
	global testplay_pid
	if testplay_pid:
		stop_test()
	testplay_pid = os.fork()
	if testplay_pid == 0:
		try:
			if file.endswith(".mid"):
				midiplay_command = "midiplay -1 10"
				print midiplay_command
				file = (file,)
				command = ('midiplay',) + tuple(midiplay_command.split()) + file
				os.execlp(*command)
			else:
				os.execlp("playulaw", "playulaw", file)
		except:
			print "elpis midi play error"
			os._exit(1)

def stop_test():
	try:
		global testplay_pid
		if not testplay_pid:
			return
		print 'pid=',testplay_pid
		os.kill(testplay_pid, signal.SIGKILL)
		os.waitpid(testplay_pid, 0)
	except:
		pass
	testplay_pid = None

class TestUI(SmallWindowUI):
	def __init__(self, message, menu1, menu2, title):

		SmallWindowUI.__init__(self,menu1,menu2,title)
		self.testmsg=runtime.evas.text(font=uiconfig.date_edit_font)
		self.testmsg.color = uiconfig.date_edit_entry_color
		self.testmsg.pos = (30+60),100
		self.testmsg.text = ''
		self.add(self.testmsg)
	def update_msg(self):
		self.testmsg.text=self.text

class TestLargeUI(LargeWindowUI):
	def __init__(self, message, menu1, menu2, title):
		LargeWindowUI.__init__(self,menu1,menu2,title)
		self.testmsg=runtime.evas.text(font=uiconfig.date_edit_font)
		self.testmsg.color = uiconfig.date_edit_entry_color
		self.testmsg.pos = (30+60),100
		self.testmsg.text = ''
		self.add(self.testmsg)
	def update_msg(self):
		self.testmsg.text=self.text
####0
class version_test_stage(Stage):

	def __init__(self):
		os.system('rm /usr/etc/testmode*')
		self.tmpkey = runtime.evas.handle_key
		runtime.evas.handle_key = self.handle_key

		self.name = "version_test_stage"

		self.ui = TestLargeUI('','','','SHOW VERSION & MAC')

		t = runtime.evas.text()
		t.font = uiconfig.swver_details_font
		t.color = uiconfig.swver_details_color
		t.text = "Software version:"
		t.text = "Serial Number:"

		self.align_center(t, uiconfig.swver_details_swver_label_pos)
		self.ui.add(t)

		t = runtime.evas.text()
		t.font = uiconfig.swver_details_font
		t.color = uiconfig.swver_details_color
                try:
                        os.system('serialno > /tmp/serial.txt')
                        fp = open('/tmp/serial.txt')
#                       fp = os.popen("serialno","r")
                        serialnumber = fp.readline().strip()
                        fp.close()

                except IOError:

                        serialnumber=""
                t.text = serialnumber

                self.align_center(t, uiconfig.swver_details_swver_pos)
                self.ui.add(t)

                t = runtime.evas.text()
                t.font = uiconfig.swver_details_font
                t.color = uiconfig.swver_details_color
                t.text = 'MAC Address:'
                self.align_center(t, uiconfig.swver_details_hwver_label_pos)
                self.ui.add(t)

                t = runtime.evas.text()
                t.font = uiconfig.swver_details_font
                t.color = uiconfig.swver_details_color
                try:
                        os.system('serialno mac > /tmp/mac.txt')
#                       f = os.popen("show_mac", "r")
                        f = open('/tmp/mac.txt')
                        macaddress = f.read()
                        #macaddress = macaddress[14:32]
                        macaddress = macaddress.strip()
                        f.close()
		except:
			macaddress = "Not Available"
		t.text = macaddress
		self.align_center(t, uiconfig.swver_details_hwver_pos)
		self.ui.add(t)
		os.system('rm /usr/etc/testmode*')
		os.system('sync')

		self.timer = utils.Timer(5000, self.reset)
		
		t = runtime.evas.text()
		t.font = uiconfig.swver_details_font
		t.color = uiconfig.swver_details_color
		t.test = 'Software Version:'
		self.align_center(t,uiconfig.swver_details_hwver_label_pos)
		self.ui.add(t)



	def reset(self):
		utils.system_reset(reboot=False)

		stage = MessageStage2(_('Serial/MAC Check'),_('Initializing...'))
		runtime.manager.change_stage(stage)
	
		'''
		setting.reset()
		from phonedb import phonedb
		phonedb.reset()
		import calldb
		calldb.delete_db('all')
		utils.remove_dir(utils.get_image_dir('taken'))
		utils.remove_dir(utils.get_image_dir('wallpaper'))
		utils.remove_dir(utils.get_image_dir('picture'))
		utils.remove_dir(config.image_snapshot_dir)
		utils.remove_dir(utils.get_audio_dir('recorded'))
		utils.remove_dir(utils.get_audio_dir('poly'))
		utils.remove_dir(utils.get_audio_dir('other'))
		## remove video
		utils.remove_dir(config.video_recorded_dir)
		utils.remove_dir(config.video_received_dir)
		utils.remove_dir(config.video_recorded_thumnail_dir)
		utils.remove_dir(config.video_received_thumnail_dir)
# eicho add 06.11.23 same as BT, remove amr2wav directory
		utils.remove_dir(config.audio_amr2wav_recorded_dir)
		utils.remove_dir(config.audio_amr2wav_polyphonic_dir)
		utils.remove_dir(config.audio_amr2wav_other_dir)
# end
		## remove SMS
#ka...3800 2007.05.02
#	remove_messages()

		## remove T9 added word
		utils.remove_t9_word_list()

		utils.remove_dir(utils.get_email_dir('emailetc'))

		status.DECT_RESET_TEST = True
		print 'status.DECT_RESET_TEST :::: TRUE'

		runtime.dectCallManager.sendFactoryReset()

		stage = MessageStage2(_('Serial/MAC Check'),_('Initializing...'))
		runtime.manager.change_stage(stage)
		'''



	def oninit(self):
		pass

	def align_center(self, l, pos):
		x, y = pos
		width,height = l.size
		l.move(x - width/2, y)

	def get_name(self):
		return "testversion"

	def handle_key(self, down, key):
		if not down:
			return True
		if key == '*':
			runtime.manager.back_stage()

	def destroy(self):
		runtime.evas.handle_key = self.tmpkey
		self.ui.destroy()




	

###1
class final_auto_test_stage(Stage):
	def __init__(self):
		self.ui = TestUI( 'ASSY AUTO TEST',' ',' ','ASSY AUTO TEST' )
		self.keymsg = 'SOFT1','SOFT2','SOFT3','SOFT4','Video call','BANKING','KT Information','Audio Mute','Message','OK','Alarm',\
					'Media Player','Flash','Call list','Transfer',\
					'Connect','Delete','Disconnect','1','2','3','4','5','6','7','8','9','*','0','#'
		'''
		self.testkey = config.Menu1, config.Menu2, config.Menu3, config.Menu4, config.Video, 'Up',\
					config.VideoPrivacy , config.Snapshot, 'Left', 'OK', 'Right', config.VideoSize, 'DOWNTOWN' ,'Down', 'INFORMATION',\
					config.Green, 'CLR', config.Red,'1','2','3','4','5','6','7','8','9','*','0','#'
		'''
		self.testkey = config.Menu1, config.Menu2, config.Menu3, config.Menu4, 'F7', 'Up', 'F8', \
				'F9' , 'Left', 'OK', 'Right', 'F10', 'DOWNTOWN' ,'Down', 'INFORMATION',\
				config.Green, 'CLR', config.Red,'1','2','3','4','5','6','7','8','9','*','0','#'

		
		self.testsize = 30

		self.testidx=0
		self.tmpkey = runtime.evas.handle_key
		runtime.evas.handle_key = self.handle_key
		self.ui.testmsg.text = 'KEYPAD TEST:'+self.keymsg[self.testidx]
		self.lastkey = self.testkey[self.testidx]
		self.testidx = self.testidx+1
		self.timer = 0
		#runtime.dspg.set_state(runtime.dspg.ST_V_SPK_OFFHK_LPLAY)
		self.count = 0
		#runtime.dspg.set_volume(3)
		self.keytest = 0
		self.player_pid = None
		self.viewfinder = None

	def init_lcd_test(self):
		self.keytest = 1
		self.timer = 0
		self.ui.clip = runtime.evas.rectangle()
		self.ui.clip.pos = 0,0
		self.ui.clip.size = 480, 272
		self.idx = 0
		self.ui.clip.color = test_color[self.idx]
		self.ui.add(self.ui.clip)
		self.ui.show()
		self.timer = utils.Timer(300, self.testcolor)
		#self.init_camera_test()
	def testcolor(self):

		self.idx += 1
		if self.idx < 5:
			print 'idx=',self.idx
			self.ui.clip.color = test_color[self.idx]
			self.ui.add(self.ui.clip)
			time.sleep(1)
			self.timer = utils.Timer(100, self.testcolor)
		else:
			self.ui.clip.hide()
			self.init_vol_test()
			#self.init_camera_test()

########################		
	def  init_vol_test (self):
		self.mode = 1
		self.timer = 0
		self.ui.testmsg.text = _('PLAY SOUND')
		file = '/usr/local/lgvp/audios/transfer/transferMOH.wav'
		#runtime.SP_context.SP_stereoPlayback()
		self.pid = os.fork()
		if self.pid == 0:
			try:
				file = (file, '1')
				command = ('playulaw','playulaw') + file
				os.execlp(*command)
			except:
				os._exit(1)
		self.timer = utils.Timer(5000, self.stop_vol_test)
		
	def stop_vol_test(self):
		if not self.pid:
			return 
		try:
			import signal
			os.kill(self.pid, signal.SIGKILL)
			if config.utils_debug:
				print 'now call waitpid', self.pid
			os.waitpid(self.pid, 0)
		except:
			if config.utils_debug:
				print 'fail to kill!!!'

		self.pid = None
				
		runtime.SP_context.SP_stereoStopPlayback()	

		self.init_camera_test()





#######################
	'''	
 	def init_vol_test(self):
		self.mode = 1
		self.timer = 0
		self.ui.testmsg.text = 'PLAY SOUND MAX'
		self.cnt = 0
                #runtime.dspg.set_state(runtime.dspg.ST_RINGER)
		setting.external_ring = config.def_melody
 		melody = config.def_melody
 		print '########',melody

		#setting.stereo_volume = 5
 		self.player_pid = utils.player.play(melody, case = 2)
 		print '#####',self.player_pid
		#runtime.dspg.set_volume(5)
		#play_test("/usr/local/lgvp/audios/ring/walk.mid")
		self.timer = utils.Timer(5000, self.stop_vol_test)
#ka...		self.init_cam_test()

	def stop_vol_test(self):
 		#stop_test()
 		utils.player.stop(self.player_pid)
		self.init_camera_test()
		
		#runtime.manager.back_stage()    #ka..	
	'''
#	def init_vol_test(self):
#		self.timer = 0
#		self.ui.testmsg.text = 'PLAY SOUND MIDDLE'
#		self.cnt = 0
#		runtime.dspg.set_state(runtime.dspg.ST_MIDI)
#		runtime.dspg.set_volume(3)
#		play_test("/usr/local/lgvp/audios/ring/Logo Song.mid")
#		self.timer = utils.Timer(400, self.setvolume)

#	def setvolume(self):
#		if self.cnt == 0:
#			runtime.dspg.set_volume(5)
#			self.ui.testmsg.text = 'PLAY SOUND HIGH'
#			self.cnt =1
#			self.timer = utils.Timer(500, self.setvolume)
#		elif self.cnt == 1:
#			runtime.dspg.set_volume(3)
#			self.ui.testmsg.text = 'PLAY SOUND MIDDLE'
#			self.cnt =2
#			self.timer = utils.Timer(500, self.setvolume)
#		elif self.cnt == 2:
#			runtime.dspg.set_volume(1)
#			self.ui.testmsg.text = 'PLAY SOUND LOW'
#			self.cnt =3
#			self.timer = utils.Timer(500, self.setvolume)
#		elif self.cnt == 3:
#			runtime.dspg.set_volume(3)
#			self.cnt =0
#			stop_test()
#			runtime.manager.back_stage()


#ka...	def init_cam_test(self):
#		utils.run_camera()
	def init_camera_test(self):
		self.ui.clip.show()
		self.mode = 3
		self.timer = 0
		'''
		os.system('fb0top 0')
#		utils.player.preview_start()
#		self.timer = utils.Timer(3000, self.end_camera_test)
#ka...		self.po = os.popen("/usr/local/diag/TUP/TestApp -f /usr/local/diag/TUP/cmd.txt /usr/local/diag/TUP/GEDR_VH264.cfg", "w")
		os.system('vc-vc02-loop-diag')
		'''

		self.viewfinder = runtime.evas.rectangle()
		self.viewfinder.geometry = (0,0,480,272)
		self.viewfinder.layer = 1
		self.viewfinder.color = (255, 255, 254, 255)

		runtime.evas.use_transparency(True)
		self.viewfinder.show()
		
		os.system('vc-vc02-loop-diag')

		

	def end_camera_test(self):
		os.system('fb0top 1')
		utils.player.preview_stop()

		os.system("sync")
		time.sleep(3)
		
		#self.timer = utils.Timer(3000,self.init_vol_test)
		#self.init_vol_test
#		self.init_camera_mmx_test()

#	def init_camera_mmx_test(self):
#		self.mode = 4
#		os.system('fb0top 0')
#		self.po = os.popen("/usr/local/bin/TUP/TestApp /usr/local/bin/TUP/conftest/_local/GEDR_VH264.cfg", "w")
#		self.timer = 0
#		self.timer = utils.Timer(6000, self.end_camera_mmx_test)

#	def end_camera_mmx_test(self):
#		os.system('fb0top 1')
#		self.po.write("E\n")
#		self.po.close()
#		self.mode = 5
#		os.system('rm /usr/etc/testmode*')
#		os.system('touch /usr/etc/testmode2')
#		runtime.manager.back_stage()

#	def init_vol_test(self):
#		self.mode = 1
#		self.timer = 0
#		self.ui.testmsg.text = 'PLAY SOUND MAX'
#		self.cnt = 0
#		runtime.dspg.set_state(runtime.dspg.ST_MIDI)
#		runtime.dspg.set_volume(5)
#		play_test("/usr/local/lgvp/audios/ring/Logo Song.mid")
#		self.timer = utils.Timer(5000, self.stop_vol_test)

#	def stop_vol_test(self):
#		stop_test()
#		self.timer = utils.Timer(3000, self.init_lcd_test)		




	def handle_key(self, down, key):
		if not down:
			return True

		#if key in '0123456789':
		#	runtime.dspg.send_dtmf(key, False)
		if key == '*':
			if self.keytest == 0:
				self.count = self.count + 1
				print "elpis key:", self.keymsg[self.testidx]
				if (self.count == 2):
					runtime.manager.back_stage()
				else:
					if key == self.keymsg[self.testidx-1]:
						print "elpis : correct"
						self.ui.testmsg.text = 'KEYPAD TEST:'+self.keymsg[self.testidx]
						self.lastkey = self.testkey[self.testidx]
						self.testidx = self.testidx+1
						self.count = 0
					#else:
						#runtime.dspg.set_volume(3)
						#play_test("test1.wav")
						#print '!!! 1:Invalid Key', key
			else :
				os.system('vc-stop-loop')
				runtime.manager.back_stage()
		else:
			if key != self.lastkey:
				#runtime.dspg.set_volume(3)
				#play_test("test1.wav")
				#print '!!! 2:Invalid Key', key
				self.count = 0
			else:
				if self.testidx == self.testsize:
					self.timer = utils.Timer(10, self.init_lcd_test)
					self.init_lcd_test()
				elif self.testidx < self.testsize:
					self.ui.testmsg.text='KEYPAD TEST:'+self.keymsg[self.testidx]
					self.lastkey = self.testkey[self.testidx]
					self.testidx = self.testidx+1

	def destroy(self):
		#runtime.dspg.set_state(runtime.dspg.ST_IDLE)
		self.player_pid = None
		runtime.evas.handle_key = self.tmpkey
		Stage.destroy(self)
		if self.viewfinder:
			self.viewfinder.free()
		runtime.evas.use_transparency(False)
		
###2
class keypad_test_stage(Stage):
	def __init__(self):
		self.ui = TestUI( 'KEYPAD TEST',' ',' ','KEYPAD TEST' )

		self.keymsg = 'SOFT1','SOFT2','SOFT3','SOFT4','Video call','BANKING','KT Information','Audio Mute','Message','OK','Alarm',\
					'Media Player','Flash','Call list','Transfer',\
					'Connect','Delete','Disconnect','1','2','3','4','5','6','7','8','9','*','0','#'
		'''
		self.testkey = config.Menu1, config.Menu2, config.Menu3, config.Menu4, config.Video, 'Up',\
					config.VideoPrivacy , config.Snapshot, 'Left', 'OK', 'Right', config.VideoSize, 'DOWNTOWN' ,'Down', 'INFORMATION',\
					config.Green, 'CLR', config.Red,'1','2','3','4','5','6','7','8','9','*','0','#'
		'''
		self.testkey = config.Menu1, config.Menu2, config.Menu3, config.Menu4, 'F7', 'Up', 'F8', \
				'F9' , 'Left', 'OK', 'Right', 'F10', 'DOWNTOWN' ,'Down', 'INFORMATION',\
				config.Green, 'CLR', config.Red,'1','2','3','4','5','6','7','8','9','*','0','#'

		self.testsize = 30
		self.testidx=0
		self.tmpkey = runtime.evas.handle_key
		runtime.evas.handle_key = self.handle_key
		self.ui.testmsg.text = 'KEYPAD TEST:'+self.keymsg[self.testidx]
		self.lastkey = self.testkey[self.testidx]
		self.testidx = self.testidx+1
		self.count = 0
		self.keytest = 0
	def handle_key(self, down, key):
		if not down:
			return True

		if key == '*':
			if self.keytest == 0:
				self.count = self.count + 1
				print "elpis key:", self.keymsg[self.testidx]
				if (self.count == 2):
					runtime.manager.back_stage()
			 
				else:
					print 'ka...key=', key, 'self.testidx=', self.testidx
					print 'ka...msg=', self.keymsg[self.testidx-1]
					if key == self.keymsg[self.testidx-1]:
						print "elpis : correct"
						self.ui.testmsg.text = 'KEYPAD TEST:'+self.keymsg[self.testidx]
						self.lastkey = self.testkey[self.testidx]
						self.testidx = self.testidx+1
						self.count = 0
			else:
				self.count = 0
				

		elif key == config.key_link_up or key == config.key_link_down:
			pass

		else:
			
			if key != self.lastkey:
			
				self.count = 0
			else:

				if self.testidx == self.testsize:
					runtime.manager.back_stage()

				else:
					self.ui.testmsg.text = 'KEYPAD TEST:'+self.keymsg[self.testidx]
					self.lastkey = self.testkey[self.testidx]
					self.testidx = self.testidx+1

			self.count = 0

	def destroy(self):
		runtime.evas.handle_key = self.tmpkey
		Stage.destroy(self)


###3
	'''
class modem_dtmf_test_stage(Stage):
	def __init__(self):
		self.tmpkey = runtime.evas.handle_key
		runtime.evas.handle_key = self.handle_key
		self.ui = TestUI('DTMF(MODEM) TEST MODE', ' ', 'EXIT', 'DTMF(MODEM) TEST MODE')
		if profile.ip_mode == 0:
			self.ui.testmsg.text = 'SEND DTMF 1590'
		else :
			self.ui.testmsg.text = 'CHANGE PSTN MODE!!'

	def show(self):
		Stage.show(self)
		runtime.evas.render_now()

		if profile.ip_mode != 0:
			time.sleep(2)
			runtime.manager.back_stage()

		runtime.dspg.set_state(runtime.dspg.ST_IDLE)
		try:
			runtime.modem.write_command('ATDT 1590\r')
		except:
			pass

	def handle_key(self, down, key):
		if not down:
			return True
		if key == config.Menu2:
			runtime.manager.back_stage()
		elif key == '*':
			runtime.manager.back_stage()

	def destroy(self):
		if profile.ip_mode == 0:
			runtime.modem.hangup()

		runtime.evas.handle_key = self.tmpkey
		Stage.destroy(self)
	'''
###3
class ping_ethernet_test_stage(Stage):
	def __init__(self):
		self.tmpkey = runtime.evas.handle_key
		runtime.evas.handle_key = self.handle_key
		self.ui = TestUI('PING ETHERNET TEST MODE', ' ','EXIT','PING ETHERNET TEST MODE')
		os.system('ifconfig eth0 192.168.1.2')
		self.ui.testmsg.text = 'PING 192.168.1.1'
		self.timer = utils.Timer(3000, self.start_ping)

	def start_ping(self):
		self.res = -1

		print 'Ping start!'

		try:
			while self.res == -1:
				self.f = os.popen("ping -c 1 192.168.1.1", "r")
				self.res = self.f.read()
				print 'ping result:', self.res
				self.f.close()
				if self.res.find('ttl') != -1:
					runtime.manager.back_stage()
					stage = MessageStage('PING ETHERNET TEST MODE','Ping Test Complete!')
					runtime.manager.stack_stage(stage)
					break
				else:
					runtime.manager.back_stage()
					stage = MessageStage('PING ETHERNET TEST MODE','Ping Test Fail!')
					runtime.manager.stack_stage(stage)
# ka... BackÇÏÁö ¾Êµµ·Ï ¼öÁ¤ ERROR	
		except:
			pass



	def handle_key(self, down, key):
		if not down:
			return True
		if key == config.Menu2:
			runtime.manager.back_stage()
		elif key == '*':
			runtime.manager.back_stage()

	def destroy(self):
		runtime.evas.handle_key = self.tmpkey
		Stage.destroy(self)


###12
class wave_test_stage(Stage):
	def __init__(self):
		self.ui = TestUI( '',' ',' ','' )
		self.ui.testmsg.text = _('Wave left')
		self.tmpkey = runtime.evas.handle_key
		runtime.evas.handle_key = self.handle_key
		from mmiSoundPath import SP_State
		self.pid = None
		self.timer = None
		self.path = 0
		self.change_path()

	def change_path(self):
		self.path += 1
		self.path = self.path % 2
		self.stop_audio()
		self.play_audio()
		
		self.timer = utils.Timer(1000, self.change_path)
		
	def  play_audio (self):
		if self.path == 0:
			path = '4'
			self.ui.testmsg.text = _('Wave left')
			file = '/usr/local/lgvp/Left.wav'
		else:
			path = '5'
			self.ui.testmsg.text = _('Wave right')
			file = '/usr/local/lgvp/Right.wav'
		runtime.SP_context.SP_stereoPlayback()
		self.pid = os.fork()
		if self.pid == 0:
			try:
				#file = ('--loop', file, path)
				file = (file, path)
				command = ('playulaw_factory','playulaw_factory') + file
				os.execlp(*command)
			except:
				os._exit(1)

		return self.pid	
		
	def stop_audio(self):
		if not self.pid:
			return 
		try:
			import signal
			os.kill(self.pid, signal.SIGKILL)
			if config.utils_debug:
				print 'now call waitpid', self.pid
			os.waitpid(self.pid, 0)
		except:
			if config.utils_debug:
				print 'fail to kill!!!'

		self.pid = None
				
		runtime.SP_context.SP_stereoStopPlayback()	
	
	def handle_key(self, down, key):
		if not down:
			return True
		if key == '*':
			runtime.manager.back_stage()
		elif key == config.key_link_up or key == config.key_link_down:
			pass
			
	def destroy(self):
		Stage.destroy(self)
		self.timer = None
		runtime.evas.handle_key = self.tmpkey
		if self.pid:
			self.stop_audio()


###4
class ping_wifi_test_stage(Stage):
	def __init__(self):
		self.tmpkey = runtime.evas.handle_key
		runtime.evas.handle_key = self.handle_key
		self.ui = TestUI('PING WIFI TEST MODE', ' ','EXIT','PING WIFI TEST MODE')
		os.system('../bin/wltest')
		self.ui.testmsg.text = 'PING 192.168.100.100'
		self.timer = utils.Timer(3000, self.start_ping)

	def start_ping(self):
		self.res = -1

		print 'Ping start!'

		try:
			while self.res == -1:
				self.f = os.popen("ping -c 1 192.168.100.100", "r")
				self.res = self.f.read()
				print 'ping result:',res
				self.f.close()
				if self.res.find('ttl') != -1:
					runtime.manager.back_stage()
					stage = MessageStage('PING WIFI TEST MODE','Ping Test Complete!')
					runtime.manager.stack_stage(stage)
					break
		
				os.system('/usr/local/bin/dhcpcd -k')

#			runtime.manager.back_stage()

		except:
			pass



	def handle_key(self, down, key):
		if not down:
			return True
		if key == config.Menu2:
			runtime.manager.back_stage()
		elif key == '*':
			runtime.manager.back_stage()

	def destroy(self):
		runtime.evas.handle_key = self.tmpkey
		Stage.destroy(self)


###13
from mmiSoundPath import SP_State
class DectPathTest(Stage):
	REGISTER_TIMEOUT = 30 * 1000
	
	def __init__(self):
		import ui
		self.ui = ui.dectPathTestUI()

		status.DECT_PATH_TEST = True
		import runtime
		from dectHandler import DectCallManager
		runtime.dectCallManager.sendRegistrationResultReport(DectCallManager.REG_SUCCESS)
		
		self.registeringTimer = utils.Timer(self.REGISTER_TIMEOUT, self.registeringFailed)

		self.isOffHook = False

	def ringing(self):
		message = '2. Ringing'
		self.ui.changeMessage(message)
		self.ui.show()

		import runtime
		runtime.dectCallManager.startIncomingCall('1000', '1000')		

	def connect(self):
		self.registeringTimer = None
		message = '3. Connected'
		self.ui.changeMessage(message)
		
		ts1OffHook = runtime.SP_context.TS1_OffHook()
		if ts1OffHook.next():
			ts1OffHook.next()

		spkOffHook = runtime.SP_context.SPK_OffHook()
		if spkOffHook.next():
			spkOffHook.next()

		runtime.SP_context.combineTwoPath(SP_State.DEVICE_SPK, SP_State.DEVICE_HSS1_TS1)		

	def close(self):
		status.DECT_PATH_TEST = False

		if self.isOffHook:
			runtime.SP_context.devideTwoPath(SP_State.DEVICE_HS, SP_State.DEVICE_HSS1_TS1)
		else:
			runtime.SP_context.devideTwoPath(SP_State.DEVICE_SPK, SP_State.DEVICE_HSS1_TS1)

		runtime.SP_context.goIdleState()
		runtime.manager.back_stage()
		
	def handle_key(self, key):
		if key in (config.Menu2, config.Red, config.CANCEL) :
			MD.mmiTrace('DectPagingStage : Menu2 / Red / CANCEL')

			callIndex = runtime.dectCallManager.makeCallIndex()
			runtime.dectHandler.B2H_DROP_CALL_NOTIFY(1, callIndex)

			self.close()
						
		elif key == config.OffHook:
			MD.mmiTrace('DectPagingStage : offHook')
			self.isOffHook = True
			
			runtime.SP_context.devideTwoPath(SP_State.DEVICE_SPK, SP_State.DEVICE_HSS1_TS1)
			runtime.SP_context.goIdleState()
			
			hsOffHook = runtime.SP_context.HS_OffHook()
			if hsOffHook.next():
				hsOffHook.next()

			ts1OffHook = runtime.SP_context.TS1_OffHook()
			if ts1OffHook.next():
				ts1OffHook.next()

			runtime.SP_context.combineTwoPath(SP_State.DEVICE_HS, SP_State.DEVICE_HSS1_TS1)		
			
		elif key == config.Green:
			MD.mmiTrace('DectPagingStage : Green')

			if self.isOffHook:
				self.isOffHook = False
				
				runtime.SP_context.devideTwoPath(SP_State.DEVICE_HS, SP_State.DEVICE_HSS1_TS1)
				runtime.SP_context.goIdleState()
				
				spkOffHook = runtime.SP_context.SPK_OffHook()
				if spkOffHook.next():
					spkOffHook.next()

				ts1OffHook = runtime.SP_context.TS1_OffHook()
				if ts1OffHook.next():
					ts1OffHook.next()

				runtime.SP_context.combineTwoPath(SP_State.DEVICE_SPK, SP_State.DEVICE_HSS1_TS1)		
		
		return True

	def registeringFailed(self):
		MD.mmiTrace('DectPathTest : registeringFailed')

		status.DECT_PATH_TEST = False
		
		self.registeringTimer = None
		message = _('Registering failed')
		from phonesetting import DectNotifyStage
		stage = DectNotifyStage(message)
		runtime.manager.change_stage(stage)
	
	def destroy(self):
		self.registeringTimer = None
		Stage.destroy(self)
		status.supervision_not_allowed = 0

class dect_paging_test_stage(Stage):
	def __init__(self):
		self.ui = TestUI( '',' ',' ','' )
		self.ui.testmsg.text = _('Please wait for a moment.')
		self.tmpkey = runtime.evas.handle_key
		runtime.evas.handle_key = self.handle_key
		status.supervision_not_allowed = 1
		runtime.dectCallManager.readyToPaging()
		import dectConfig
		self.pagingTag = utils.Timer(dectConfig.PAGING_TIMEOUT, self.pagingFailed)
	def handle_key(self, down, key):
		if not down:
			return True
		if key == '*':
			from dectHandler import DectCallManager
			runtime.dectCallManager.cancelPaging()
			self.pagingTag = None
			runtime.manager.back_stage()
		elif key == config.key_link_up or key == config.key_link_down:
			pass	
		elif key == config.SUCCEED:
			self.pagingTag = None
			self.ui.testmsg.text = _('Paging Succeed')
			return True
		elif key == config.FAIL:
			self.pagingTag = None
			self.ui.testmsg.text = _('Paging Failed')
			return True
	def pagingFailed(self):
		self.pagingTag = None
		self.ui.testmsg.text = _('Paging Failed')
	def destroy(self):
		self.pagingTag = None
		Stage.destroy(self)
		status.supervision_not_allowed = 0
		runtime.evas.handle_key = self.tmpkey


###6
class usb_test_stage(Stage):
	def __init__(self):
		self.ui = TestUI( '',' ',' ','' )
		self.ui.testmsg.text = _('USB check')
		self.tmpkey = runtime.evas.handle_key
		runtime.evas.handle_key = self.handle_key
		self.timer = utils.Timer(3000, self.usb_check)
		
	def usb_check(self):
		ret = os.system("USB")
		if ret == 0:
			self.ui.testmsg.text = _('USB check succeed')
		else:
			self.ui.testmsg.text = _('USB check fail')

	def handle_key (self, down, key):
		if not down:
			return True
		if key == '*':
			runtime.manager.back_stage()
	def destroy(self):
		Stage.destroy(self)
		runtime.evas.handle_key = self.tmpkey

###5
class dialtone_test_stage(Stage):
	def __init__(self):
		self.tmpkey = runtime.evas.handle_key
		runtime.evas.handle_key = self.handle_key
		self.ui = TestUI( 'DIAL TONE TEST',' ',' ','DIAL TONE TEST')
		self.ui.testmsg.text = 'Playing dial tone'
		self.play_tone()

	def play_tone(self):
		runtime.dspg.set_state(runtime.dspg.ST_RINGER)
		runtime.dspg.set_volume(5)
		runtime.vdci_play_tone(config.PLAY_DIAL_TONE)
#		play_test("/usr/local/lgvp/audios/ring/love.wav")


	def handle_key(self, down, key):
		if not down:
			return True
		if key == "*":
#			stop_test()
			runtime.vdci_stop_tone()
#			status.set_modem_audio_state(status.IDLE)
#			runtime.dspg.set_state(runtime.dspg.ST_IDLE)
			runtime.manager.back_stage()

	def destroy(self):
		runtime.evas.handle_key = self.tmpkey
		Stage.destroy(self)

'''
class bluetooth_test_stage(Stage):


	def __init__(self):
		self.retry = 0
		self.index = 0
		self.tempkey = runtime.evas.handle_key
		runtime.evas.handle_key = self.handle_key
		self.ui = TestUI( 'BLUETOOTH TEST',' ',' ','BLUETOOTH TEST')
		self.ui.testmsg.text = 'Searching Bluetooth...'
		self.searchbt()

	def start_search(self):
		self.get_listt = 0
		self.bluetooths = []
		self.bt_restart = utils.Timer(15000, self.restart_bt)
		self.get_list()

	def restart_bt(self):
		print 'Before Test'
		phonesetting.Restart_btapp()
		print 'After Test'
		runtime.btapp.send_message('20|i')

	def get_search_device(self):

		import re
		print runtime.btapp.bt_list[0]
		return re.search("Addr=([0-9a-zA-z:]+)",runtime.btapp.bt_list[0]).group(1)

	def get_list(self):

		if runtime.btapp.dEnd == 'done':

			choice = runtime.btapp.bt_list

			if len(choice) == 0:

				if self.retry > 1:
					self.ui.testmsg.text = 'Bluetooth Not Found!'
				else:
					self.retry = self.retry +1
					print 'Retry Bluetooth Test!!'
					self.searchbt()
			else:

				self.ui.testmsg.text = self.get_search_device()+ " Found"
		else:
			self.get_listt = utils.Timer(1000, self.get_list)

	def no_cb(self):
		self.bt_restart = 0
		self.get_listt = 0
		runtime.btapp.send_message('20|D')
		runtime.btapp.send_message('20|v')
		runtime.btapp.set_default()

	def searchbt(self):

		runtime.btapp.set_default()

		if self.index == 0:
			runtime.btapp.send_message('20|i')
			self.start_search()

		else:
			try:
				fp = open('bluetooth.txt')
				showlist = []
				for line in fp.readlines():
					showlist.append(line)
				fp.close()

				if len(showlist) != 0:
					return
			except:
				print 'file error'

	def handle_key(self, down, key):
		if not down:
			return True
		if key == "*":
			runtime.manager.back_stage()

	def destroy(self):
		self.no_cb()
		runtime.evas.handle_key = self.tempkey
		Stage.destroy(self)
'''
###6
class mbu_auto_test_stage(Stage):
	def __init__(self):
		self.ui = TestUI( 'MBU AUTO TEST',' ',' ','ASSY AUTO TEST' )
		self.keymsg = 'OK','Alarm','Media Player','1','5','9','0'
		'''
		self.testkey= config.Menu1,config.Menu2, 'Up',config.Snapshot, 'Left', 'OK','Right','1','5','9','0'
		'''
		self.testkey= 'OK','Right','F10','1','5','9','0'
		
		self.testsize = 7
		self.testidx=0
		self.tmpkey = runtime.evas.handle_key
		runtime.evas.handle_key = self.handle_key
		self.ui.testmsg.text = 'KEYPAD TEST:'+self.keymsg[self.testidx]
		self.lastkey = self.testkey[self.testidx]
		self.testidx = self.testidx+1
		self.timer = 0
		#runtime.dspg.set_state(runtime.dspg.ST_V_SPK_OFFHK_LPLAY)
		self.count = 0
		#runtime.dspg.set_volume(3)
		self.keytest = 0
		self.player_pid = None
		self.viewfinder = None
		
	def init_lcd_test(self):
		self.keytest = 1
		self.timer = 0
		self.ui.clip = runtime.evas.rectangle()
		self.ui.clip.pos = 0,0
		self.ui.clip.size = 480, 272
		self.idx = 0
		self.ui.clip.color = test_color[self.idx]
		self.ui.add(self.ui.clip)
		self.ui.show()
		self.timer = utils.Timer(300, self.testcolor)
		os.system('sync')      
		

	def testcolor(self):

		self.idx += 1
		if self.idx < 5:
			print 'idx=',self.idx
			self.ui.clip.color = test_color[self.idx]
			self.ui.add(self.ui.clip)
			time.sleep(1)
			self.timer = utils.Timer(100, self.testcolor)
		else:
			self.ui.clip.hide()
			self.init_vol_test()
			import os
			if os.path.exists('/usr/etc/testmode1') or os.path.exists('/usr/etc/testmode2'):
				os.system('rm /usr/etc/testmode*')
				os.system('touch /usr/etc/testmode2')
				os.system('sync')      
			#self.init_camera_test()
			
####################
	def  init_vol_test (self):
		self.mode = 1
		self.timer = 0
		self.ui.testmsg.text = _('PLAY SOUND')
		file = '/usr/local/lgvp/audios/transfer/transferMOH.wav'
		#runtime.SP_context.SP_stereoPlayback()
		self.pid = os.fork()
		if self.pid == 0:
			try:
				file = (file, '1')
				command = ('playulaw','playulaw') + file
				os.execlp(*command)
			except:
				os._exit(1)
		self.timer = utils.Timer(5000, self.stop_vol_test)
		
	def stop_vol_test(self):
		if not self.pid:
			return 
		try:
			import signal
			os.kill(self.pid, signal.SIGKILL)
			if config.utils_debug:
				print 'now call waitpid', self.pid
			os.waitpid(self.pid, 0)
		except:
			if config.utils_debug:
				print 'fail to kill!!!'

		self.pid = None
				
		runtime.SP_context.SP_stereoStopPlayback()	

		self.init_camera_test()

####################
	'''
        def init_vol_test(self):
		self.mode = 1
		self.timer = 0
		self.ui.testmsg.text = 'PLAY SOUND MAX'
		self.cnt = 0
                
                #runtime.dspg.set_state(setting.handset_volume)
                #runtime.dspg.set_volume(5)
                #play_test("/usr/local/lgvp/audios/ring/walk.mid")
		
     
		setting.external_ring = config.def_melody
 		melody = config.def_melody
 		print '########',melody
		#setting.stereo_volume = 5
 		self.player_pid = utils.player.play(melody, case = 2)
		#runtime.dspg.set_volume(5)
		#play_test("/usr/local/lgvp/audios/ring/walk.mid")
		self.timer = utils.Timer(5000, self.stop_vol_test)

        def stop_vol_test(self):
                #stop_test()
                # TEST testmode1 -> testmode2
		os.system('rm /usr/etc/testmode*')
		os.system('touch /usr/etc/testmode2')
		os.system('sync')   
		utils.player.stop(self.player_pid)
		self.init_camera_test()
	'''
	
	def init_camera_test(self):		
		self.ui.clip.show()
		self.mode = 3
		self.timer = 0
		'''
		os.system('fb0top 0')
#		utils.player.preview_start()
#		self.timer = utils.Timer(3000, self.end_camera_test)
#ka...		self.po = os.popen("/usr/local/diag/TUP/TestApp -f /usr/local/diag/TUP/cmd.txt /usr/local/diag/TUP/GEDR_VH264.cfg", "w")
		os.system('vc-vc02-loop-diag')
		'''

		self.viewfinder = runtime.evas.rectangle()
		self.viewfinder.geometry = (0,0,480,272)
		self.viewfinder.layer = 1
		self.viewfinder.color = (255, 255, 254, 255)

		runtime.evas.use_transparency(True)
		self.viewfinder.show()
		
		os.system('vc-vc02-loop-diag')
		

	def handle_key(self, down, key):
		if not down:
			return True

		#if key in '0123456789':
		#	runtime.dspg.send_dtmf(key, False)
		if key == '*':
			if self.keytest == 0:
				self.count = self.count + 1
				print "elpis key:", self.keymsg[self.testidx]
				if (self.count == 2):
					runtime.manager.back_stage()
				else:
					if key == self.keymsg[self.testidx-1]:
						print "elpis : correct"
						self.ui.testmsg.text = 'KEYPAD TEST:'+self.keymsg[self.testidx]
						self.lastkey = self.testkey[self.testidx]
						self.testidx = self.testidx+1
						self.count = 0
					#else:
					#	runtime.dspg.set_volume(3)
					#	play_test("test1.wav")
					#	print '!!! 1:Invalid Key', key
			else :
				os.system('vc-stop-loop')
				runtime.manager.back_stage()
		else:
			if key != self.lastkey:
				#runtime.dspg.set_volume(3)
				#play_test("test1.wav")
				#print '!!! 2:Invalid Key', key
				self.count = 0
			else:
				if self.testidx == self.testsize:
					self.timer = utils.Timer(10, self.init_lcd_test)
					self.init_lcd_test()
				elif self.testidx < self.testsize:
					self.ui.testmsg.text='KEYPAD TEST:'+self.keymsg[self.testidx]
					self.lastkey = self.testkey[self.testidx]
					self.testidx = self.testidx+1

	def destroy(self):
		#runtime.dspg.set_state(runtime.dspg.ST_IDLE)
		self.player_pid = None
		runtime.evas.handle_key = self.tmpkey
		Stage.destroy(self)
		runtime.evas.use_transparency(False)
		if self.viewfinder:
			self.viewfinder.free()




		
'''
class mbu_auto_test_stage(Stage):

	def __init__(self):
		self.mode = 0
		self.ui = TestUI( 'MBU AUTO TEST',' ',' ','MBU AUTO TEST' )
		self.keymsg = 'SOFTKEY2', 'SMSKEY','LEFT', 'RED','1','5','9','0'
		self.testkey= config.Menu2,config.key_mms,'Left',config.Red,'1','5','9','0'
		self.testsize = 8

		self.testidx=0
		self.tmpkey = runtime.evas.handle_key
		runtime.evas.handle_key = self.handle_key
		self.ui.testmsg.text = 'KEYPAD TEST:'+self.keymsg[self.testidx]
		self.lastkey = self.testkey[self.testidx]
		self.testidx = self.testidx+1
		self.timer = 0
		runtime.dspg.set_state(runtime.dspg.ST_V_SPK_OFFHK_LPLAY)
		runtime.dspg.set_volume(3)

	def init_bluetooth_test(self):
		self.retry = 0
		self.mode = 3
		self.timer = 0
		self.index = 0
		self.tempkey = runtime.evas.handle_key
		self.ui.testmsg.text = 'Searching Bluetooth...'
		self.searchbt()

	def start_search(self):
		self.get_listt = 0
		self.bluetooths = []
		self.bt_restart = utils.Timer(5000, self.restart_bt)
		self.get_list()

	def restart_bt(self):
		phonesetting.Restart_btapp()
		runtime.btapp.send_message('20|i')


	def get_search_device(self):

		import re
		print runtime.btapp.bt_list[0]
		return re.search("Addr=([0-9a-zA-z:]+)",runtime.btapp.bt_list[0]).group(1)

	def get_list(self):

		if runtime.btapp.dEnd == 'done':

			choice = runtime.btapp.bt_list

			if len(choice) == 0:
				self.mode = 4

				if self.retry > 1:
                                        self.ui.testmsg.text = 'Bluetooth Not Found!'
                                else:
                                        self.retry = self.retry +1
                                        print 'Retry Bluetooth Test!!'
                                        self.searchbt()

			else:
				self.mode = 4
				self.ui.testmsg.text = self.get_search_device()+ " Found"
		else:
			self.get_listt = utils.Timer(1000, self.get_list)

	def no_cb(self):
		self.bt_restart = 0
		self.get_listt = 0
		runtime.btapp.send_message('20|D')
		runtime.btapp.send_message('20|v')
		runtime.btapp.set_default()

	def searchbt(self):

		runtime.btapp.set_default()

		if self.index == 0:
			runtime.btapp.send_message('20|i')
			self.start_search()

		else:
			try:
				fp = open('bluetooth.txt')
				showlist = []
				for line in fp.readlines():
					showlist.append(line)
				fp.close()

				if len(showlist) != 0:
					return
			except:
				print 'file error'


#	def init_vol_test(self):
#		self.mode = 1
#		self.timer = 0
#		self.ui.testmsg.text = 'PLAY SOUND HIGH'
#		self.cnt = 0
#		runtime.dspg.set_state(runtime.dspg.ST_MIDI)
#		runtime.dspg.set_volume(5)
#		play_test("/usr/local/lgvp/audios/ring/Logo Song.mid")
#		self.timer = utils.Timer(5000, self.stop_vol_test)

#	def stop_vol_test(self):
#		stop_test()
#		self.timer = utils.Timer(3000, self.init_bluetooth_test)

	def handle_key(self, down, key):
		if not down:
			return True

		if self.mode == 0:
			if key in '0123456789':
				runtime.dspg.send_dtmf(key, False)
			if key == '*':
				runtime.manager.back_stage()
			else:
				if key != self.lastkey:
					runtime.dspg.set_volume(3)
					play_test("test1.wav")
					print '!!! 2:Invalid Key', key
				else:
					if self.testidx == self.testsize:
#						self.timer = utils.Timer(100, self.init_vol_test)
						#self.timer = utils.Timer(100, self.init_bluetooth_test)
						pass
					elif self.testidx < self.testsize:
						self.ui.testmsg.text='KEYPAD TEST:'+self.keymsg[self.testidx]
						self.lastkey = self.testkey[self.testidx]
						self.testidx = self.testidx+1
		else :
			if key == '*':
				runtime.manager.back_stage()

	def destroy(self):

		runtime.dspg.set_state(runtime.dspg.ST_IDLE)

		if self.mode == 3:
			self.no_cb()

		stop_test()
		runtime.evas.handle_key = self.tmpkey
		Stage.destroy(self)
'''
###7
class record_test_stage(Stage):
	def __init__(self):
		from mmiSoundPath import SP_State, SP_Context #Device
		self.tmpkey = runtime.evas.handle_key
		runtime.evas.handle_key = self.handle_key
		self.filename = ''
		self.recordstage_timer = None
		self.audiopid = None
		self.ui = TestUI(_('Record test'),' ',_('Exit'),_('Record Test Mode'))
		self.ui.testmsg.text = _('Wait.')
		self.ui_timer = utils.Timer(2*1000, self.change_ui)
		self.rec_status = 0 # 0:not ready, 1:recording, 2:playing
		self.green_count = 0
		self.audioPath = 2 # 1: HS 2:SPK
		
	def change_ui(self):
		self.ui_timer = None
		self.ui.destroy()
		import ui
		self.ui = ui.AudioRecordUI('', '', _('RECORD TEST'),'')
		self.ui.set_max_duration(config.audio_record_duration)
		# subtitle
		subtitle = _('Recording')
		self.subtitle = runtime.evas.text(text=subtitle,font=uiconfig.pb_entry_font)
		self.subtitle.color = uiconfig.color_dark_gray
		self.subtitle.pos = 20, 60
		self.ui.add(self.subtitle)
		self.ui.show()
		
# KA: [20070730] video È­¸éÀ» °¡¸®±â À§ÇØ 
		os.system('fb0top 1')

		runtime.evas.render()
		utils.remove('/usr/local/lgvp/arec.amr')
		self.audiopid = utils.player.amr_record_ready(testmode=True)
		self.recordstage_timer = utils.Timer(200, self.recording_start)


	def update_duration_display(self):
		self.ui.duration.text = _('Duration: ') + '%02d:%02d' % divmod(self.duration, 60)
		self.ui.set_value(self.duration)
		
	def recording_start(self):
		self.rec_status = 1
		self.timer = utils.Timer(1000, self.update_time)
		self.duration = 0
		self.max_duration = config.audio_record_duration
		self.ui.set_max_duration(self.max_duration)
		self.update_duration_display()
		if self.audioPath == 1: # HS
			utils.player.amr_record_start(use_hs_mic=True)
		else:
			utils.player.amr_record_start(use_hs_mic=False)

	def update_time(self):
		if not self.timer:
			return False
		self.duration += 1
		self.update_duration_display()
		runtime.evas.render_now()
		if self.duration >= self.max_duration:
			utils.player.stop(self.audiopid)
			self.audiopid = None
			self.pid = 0
			self.recording_done()
			setting.reset_screen_saver_timer()
			status.screensaver_activated = False
			return False
		return True

	def recording_done(self):
		self.timer = 0
		self.ui.duration.text = _('Duration: ') + ('%02d:%02d' % divmod(self.duration, 60))
		self.ui.set_max_duration(config.audio_record_duration)
		self.ui.set_value(self.duration)
		self.subtitle.text_set(_('Playing'))
		self.recordstage_timer = utils.Timer(200, self.play_audio)


	def play_audio(self):
		self.rec_status = 2
		if status.phone_status != status.Disconnected:
			return

		runtime.mmedia.unload()
		runtime.SP_context.SP_stereoStopPlayback()
		if self.audioPath == 1: # HS
			from mmiSoundPath import SP_State
			runtime.soundpath.set_state(SP_State.DEVICE_HS, SP_State.STATE_CONNECT)
			runtime.SP_context.setBandwidthMode(SP_State.DEVICE_HS)
			runtime.SP_context.setDeviceVolume(SP_State.DEVICE_HS, 5)

			self.filename = '/usr/local/lgvp/arec.amr'
			runtime.mmedia.audio_stop()
			runtime.mmedia.audio_play(self.filename, config.ring_volume[setting.ringer_volume-1], True)
		elif self.audioPath == 2: # SPK
			from mmiSoundPath import SP_State
			runtime.soundpath.set_state(SP_State.DEVICE_SPK, SP_State.STATE_CONNECT)
			runtime.SP_context.setBandwidthMode(SP_State.DEVICE_SPK)
			runtime.SP_context.setDeviceVolume(SP_State.DEVICE_SPK, 5)
			
			self.filename = '/usr/local/lgvp/arec.amr'
			runtime.mmedia.audio_stop()
			runtime.mmedia.audio_play(self.filename, config.ring_volume[setting.ringer_volume-1], True)
			#self.audiopid = utils.player.play_ring(self.filename)
		
	def stop_audio(self):
		if status.phone_status != status.Disconnected:
			return
		if self.audioPath == 1: # HS		
			from mmiSoundPath import SP_State
			runtime.soundpath.set_state(SP_State.DEVICE_HS, SP_State.STATE_IDLE)
		elif self.audioPath == 2: # SPK
			from mmiSoundPath import SP_State
			runtime.soundpath.set_state(SP_State.DEVICE_SPK, SP_State.STATE_IDLE)
		runtime.mmedia.audio_stop()
		
		#utils.player.stop_ring()
	
	def handle_key(self, down, key):
		if not down:
			return True
		if key == config.Menu1:
			self.play_audio()
			
		elif key == config.Green:
			if self.green_count == 0:
				#utils.player.stop(self.audiopid)
				self.stop_audio()
				self.audiopid = None
				self.recording_done()
				self.green_count += 1
			else:
				self.stop_audio()
				runtime.manager.back_stage()
				
		elif key == config.OffHook:
			if self.rec_status == 0: # 0:not ready, 1:recording, 2:playing
				self.audioPath = 1
				runtime.mmedia.unload()
				runtime.SP_context.SP_stereoStopPlayback()

				from mmiSoundPath import SP_State
				runtime.soundpath.set_state(SP_State.DEVICE_HS, SP_State.STATE_CONNECT)
				runtime.SP_context.setBandwidthMode(SP_State.DEVICE_HS)
				runtime.SP_context.setDeviceVolume(SP_State.DEVICE_HS, 5)
					
		elif key == config.OnHook:
			if self.rec_status == 0:
				runtime.SP_context.goIdleState()
	
	def destroy(self):
		self.timer = 0
		self.stop_audio()
		runtime.evas.handle_key = self.tmpkey
		Stage.destroy(self)
		runtime.SP_context.goIdleState()
		


class cbu_auto_test_stage(Stage):

	def __init__(self):
		self.mode = 0
		self.ui = TestUI( 'CBU AUTO TEST',' ',' ','CBU AUTO TEST' )
		self.keymsg = 'SOFTKEY2', 'SMSKEY','LEFT', 'RED','1','5','9','0'
		self.testkey= config.Menu2,config.key_mms,'Left',config.Red,'1','5','9','0'
		self.testsize = 8

		self.testidx=0
		self.tmpkey = runtime.evas.handle_key
		runtime.evas.handle_key = self.handle_key
		self.ui.testmsg.text = 'KEYPAD TEST:'+self.keymsg[self.testidx]
		self.lastkey = self.testkey[self.testidx]
		self.testidx = self.testidx+1
		self.timer = 0
		runtime.dspg.set_state(runtime.dspg.ST_SPK_OFFHK_BPLAY)
		runtime.dspg.set_volume(3)

	def init_lcd_test(self):
		self.mode = 2
		self.timer = 0
		self.ui.clip = runtime.evas.rectangle()
		self.ui.clip.pos = 0,0
		self.ui.clip.size = 480, 272
		self.idx = 0
		self.ui.clip.color = test_color[self.idx]
		self.ui.add(self.ui.clip)
		self.ui.show()
		self.timer = utils.Timer(300, self.testcolor)

	def testcolor(self):

		self.idx += 1
		if self.idx < 5:
			print 'idx=',self.idx
			self.ui.clip.color = test_color[self.idx]
			self.ui.add(self.ui.clip)
			self.Timer = 0
			time.sleep(1)
			self.timer = utils.Timer(100, self.testcolor)
		else:
			self.ui.clip.hide()
			self.timer = 0
	                os.system('rm /usr/etc/testmode*')
	                os.system('touch /usr/etc/testmode2')
			self.timer = utils.Timer(500, self.init_camera_test)

	def init_camera_test(self):
		self.ui.clip.show()
		self.mode = 3
		self.timer = 0
		os.system('fb0top 0')
#		utils.player.preview_start()
#		self.timer = utils.Timer(3000, self.end_camera_test)
		self.po = os.popen("/usr/local/diag/TUP/TestApp -f /usr/local/diag/TUP/cmd.txt /usr/local/diag/TUP/GEDR_VH264.cfg", "w")

#	def end_camera_test(self):
#		os.system('fb0top 1')
#		utils.player.preview_stop()

#		os.system("sync")
#		os.system("sync")
#		time.sleep(3)
#		self.init_camera_mmx_test()

#	def init_camera_mmx_test(self):
#		self.mode = 4
#		os.system('fb0top 0')
#		self.po = os.popen("/usr/local/bin/TUP/TestApp /usr/local/bin/TUP/conftest/_local/GEDR_VH264.cfg", "w")
#		self.timer = 0
#		self.timer = utils.Timer(6000, self.end_camera_mmx_test)

#	def end_camera_mmx_test(self):
#		os.system('fb0top 1')
#		self.po.write("E\n")
#		self.po.close()
#		self.mode = 5
#		os.system('rm /usr/etc/testmode*')
#		os.system('touch /usr/etc/testmode2')
#		runtime.manager.back_stage()

#	def init_vol_test(self):
#		self.mode = 1
#		self.timer = 0
#		self.ui.testmsg.text = 'PLAY SOUND MAX'
#		self.cnt = 0
#		runtime.dspg.set_state(runtime.dspg.ST_MIDI)
#		runtime.dspg.set_volume(5)
#		play_test("/usr/local/lgvp/audios/ring/Logo Song.mid")
#		self.timer = utils.Timer(5000, self.stop_vol_test)

#	def stop_vol_test(self):
#		stop_test()
#		self.timer = utils.Timer(3000, self.init_lcd_test)

	def handle_key(self, down, key):
		if not down:
			return True

		if self.mode == 0:
			if key in '0123456789':
				runtime.dspg.send_dtmf(key, False)
			if key == '*':
				runtime.manager.back_stage()
			else:
				if key != self.lastkey:
					runtime.dspg.set_volume(3)
					play_test("test1.wav")
					print '!!! 2:Invalid Key', key
				else:
					if self.testidx == self.testsize:
#						self.timer = utils.Timer(100, self.init_vol_test)
						self.timer = utils.Timer(500, self.init_lcd_test)
					elif self.testidx < self.testsize:
						self.ui.testmsg.text='KEYPAD TEST:'+self.keymsg[self.testidx]
						self.lastkey = self.testkey[self.testidx]
						self.testidx = self.testidx+1

		else :
			if key == '*':
				runtime.manager.back_stage()

	def destroy(self):

		runtime.dspg.set_state(runtime.dspg.ST_IDLE)

		if self.mode == 3:
			self.po.write("E\n")
			self.po.close()
			os.system('fb0top 1')

		stop_test()
		runtime.evas.handle_key = self.tmpkey
		Stage.destroy(self)


###8
class camera_test_stage(Stage):
	name = 'video preview'
	def __init__(self):
		import ui
		self.ui = ui.VideoPreviewUI('', '', _('VIDEO RECORDER'), _('Stand by'))
		self.go_recordstage = False

		if setting.screen_saver_enabled:
			status.not_screen_saver = True

	def handle_key(self, key):
		if key== '*' or key == config.Menu2:
			runtime.manager.back_stage()
		return True
	
	def show(self):
		self.ui.set_left('')
		self.ui.set_right(_('BACK'))
		Stage.show(self)
		runtime.evas.render()
		os.system('fb0top 0')
		utils.remove_cmd('/usr/local/lgvp/*.3gp')
		utils.remove_cmd('/usr/local/lgvp/*.png')
		utils.remove_cmd('/usr/local/lgvp/*.yuv420')
		campos = (56, 24, 200, 206)
		utils.player.video_record_ready(campos)


	def destroy(self):
		os.system('fb0top 1')
		utils.player.video_end(False)
		utils.remove_cmd('/tmp/*.3gp')
		utils.remove_cmd('/tmp/*.png')
		utils.remove_cmd('/tmp/*.yuv420')
		Stage.destroy(self)

class video_call_test_stage(Stage):
	def __init__(self):
		import ui
		self.ui = ui.NormalDigitEditUI('', 'Direct IP call', 'IP address', 15)
		#self.ui.set_left('VIDEO CALL')
		self.change_profile()

	def change_profile(self):
		if profile.ip_mode == 0:
			self.profile = 1
			self.old_profile_name = _('PSTN')

			profile.profile.set_profile(self.profile)

			if self.profile == 1: # change LAN profile..

				if self.old_profile_name == _('PSTN'): # PSTN -> LAN

					if runtime.modem:
						runtime.modem.close()

					lan_profile.set_dhcp(False)
					runtime.modem = None
					if runtime.vdciapp == None:
						import vdciapp
						runtime.vdciapp = vdciapp.VDCIApp()
					runtime.vdciapp.run_vdciapp()
					runtime.vdci_send_mesg(code1=config.MESG_STARTUP, \
											mesg1=status.videocall_dimension, \
											mesg2=(3,6,9,12,15)[setting.video_fluency-1], \
											mesg3=0)

				os.system('ifconfig eth0 192.168.10.1 netmask 255.255.255.0')
				time.sleep(1)
				os.system('ping -c 1 192.168.10.100')
				time.sleep(2)

	def handle_key(self, key):
		dest = self.ui.get_text()
		if key == config.Green or key == config.Menu1:
			import status
			if not dest:
				dest = '192.168.10.100'

			spkOffHook = runtime.SP_context.SPK_OffHook()
			if spkOffHook.next():
				spkOffHook.next()
		
			status.dial_number = dest
			#runtime.manager.start_ip_call(dest, direct=True)
			runtime.manager.start_ip_call(number=status.dial_number, video_call=False, direct=True)
			return True
		elif key == config.Video:# or key == config.Menu1:
			import status
			if not dest:
				dest = '192.168.10.100'

			spkOffHook = runtime.SP_context.SPK_OffHook()
			if spkOffHook.next():
				spkOffHook.next()
			
			status.dial_number = dest
			# KA: [20080503] added
			from mmiSoundPath import SP_Context
			runtime.SP_context.setBaseCallStatus(SP_Context.OUTGOING_VIDEO)
			#runtime.mmiDebug.mmiTrace('video call start')
			runtime.SP_context.stopTonePlay()
			status.videocall_byuser = True
			runtime.manager.start_ip_call(number=status.dial_number, video_call=True, direct=True)
			#runtime.manager.start_ip_call(dest, video_call=True, direct=True, tstmode=True)
			# KA: [20080503] added ==
			return True
		else:
			return self.ui.handle_key(key)

	def destroy(self):

		Stage.destroy(self)

###9
_TM_functions = ['mode_disable', 'mode_pcb', 'mode_assy']



def get_func(index):
	return _TM_functions[index]


beforekey2 = 0
class change_test_mode_stage(ListStage):
	global beforekey2
	title = 'TEST MODE'
	choice = ('0. Disable','1. PCB','2. ASSY')

	beforekey2 = 0
	mode_text = ''

	def __init__(self):
		ListStage.__init__(self)

	def destroy(self):

		ListStage.destroy(self)

	def activate(self, index):
		global beforekey2

		if get_func(index) == 'mode_disable':
			print 'mode_disable'
			mode_text = 'DISABLE.'
			os.system('rm /usr/etc/testmode*')

		elif get_func(index) == 'mode_pcb':
			print 'mode_pcb'
			mode_text = 'TEST MODE 1.PCB'
			os.system('rm /usr/etc/testmode*')
			os.system('touch /usr/etc/testmode1')

		elif get_func(index) == 'mode_assy':
			print 'mode_assy'
			mode_text = 'TEST MODE 2.ASSY'
			os.system('rm /usr/etc/testmode*')
			os.system('touch /usr/etc/testmode2')

# ÁöÇý¾¾! ÀÌºÎºÐ »èÁ¦µÈ°Ô ¸Â´ÂÁö È®ÀÎÇØÁÖ¼¼¿ä~
		#setting.set_volume(setting.audio_volume)
		stage = MessageStage('TEST MODE',mode_text)
		runtime.manager.stack_stage(stage)
		runtime.manager.back_stage()



	def handle_key(self, key):
		global beforekey
		if key in "012":
			index = ord(key)-ord('0')
			print 'index = ' + key

			if get_func(index) == 'mode_disable':
				print 'mode_disable'
				mode_text = 'DISABLE.'
				os.system('rm /usr/etc/testmode*')


			elif get_func(index) == 'mode_pcb':
				print 'mode_pcb'
				mode_text = 'TEST MODE 1.PCB'
				os.system('rm /usr/etc/testmode*')
				os.system('touch /usr/etc/testmode1')


			elif get_func(index) == 'mode_assy':
				print 'mode_assy'
				mode_text = 'TEST MODE 2.ASSY'
				os.system('rm /usr/etc/testmode*')
				os.system('touch /usr/etc/testmode2')


			stage = MessageStage('TEST MODE',mode_text)
			runtime.manager.stack_stage(stage)
			runtime.manager.back_stage()


		elif key == '*':
				runtime.manager.back_stage()
		else:
			return ListStage.handle_key(self,key)
		beforekey2 = key

class LCD_defect_test(Stage):
	def __init__(self):
		self.mode = 0
		self.ui = TestUI( 'LCD DEFECT TEST',' ',' ','LCD DEFECT TEST' )
		self.idx = 0
		self.timer = None
		self.init_lcd_test()

	def init_lcd_test(self):
		self.image = utils.put_image(test_image[self.idx], (0, 0))
		self.ui.add(self.image)
		
	def changeColor(self):
		self.timer = None
		self.idx += 1
		if self.idx > 9:
			self.idx = 0
			
		print 'idx=',self.idx
		name = uiconfig.image_dir + test_image[self.idx]
		self.image.file = name	

	def changeColorAuto(self):
		self.idx += 1
		if self.idx > 9:
			self.idx = 0
			
		print 'idx=',self.idx
		name = uiconfig.image_dir + test_image[self.idx]
		self.image.file = name	
		self.timer = utils.Timer(1000, self.changeColorAuto)
		
		'''	
	def init_lcd_test(self):
		self.ui.clip = runtime.evas.rectangle()
		self.ui.clip.pos = 0,0
		self.ui.clip.size = 480, 272
		self.ui.clip.color = test_color[self.idx]
		self.ui.add(self.ui.clip)
		self.ui.show()

	def changeColor(self):
		self.idx += 1
		if self.idx > 4:
			self.idx = 0
			
		print 'idx=',self.idx
		self.ui.clip.color = test_color[self.idx]
		self.ui.add(self.ui.clip)
		'''
		
	def handle_key(self, key):
		if key in ('*', 'CLR', config.Red):
			self.timer = None
			runtime.manager.back_stage()
		elif key == '0':
			self.changeColorAuto()
		else:
			self.changeColor()


class wifi_test_stage(Stage):
	def __init__(self):
		self.ui = TestUI( '',' ',' ','' )
		self.ui.testmsg.text = _('WIFI check')
		self.tmpkey = runtime.evas.handle_key
		runtime.evas.handle_key = self.handle_key
		self.timer = utils.Timer(3000, self.usb_check)
		
	def usb_check(self):
		ret = os.system("wltest2")
		if ret == 0:
			self.ui.testmsg.text = _('WIFI check succeed')
		else:
			self.ui.testmsg.text = _('WIFI check fail')

	def handle_key (self, down, key):
		if not down:
			return True
		if key == '*':
			runtime.manager.back_stage()
	def destroy(self):
		Stage.destroy(self)
		runtime.evas.handle_key = self.tmpkey



class sd_mmc_test_stage(Stage):
	def __init__(self):
		self.ui = TestUI( '',' ',' ','' )
		self.ui.testmsg.text = _('SD/MMC check')
		self.tmpkey = runtime.evas.handle_key
		runtime.evas.handle_key = self.handle_key
		self.timer = utils.Timer(3000, self.usb_check)
		
	def usb_check(self):

		#ret = os.system("wltest")

		try:
			ret = os.stat("/mfs/sd")
		except:
			ret = 0
 
		if ret:
			self.ui.testmsg.text = 'SD/MMC check succeed'
		else:
			self.ui.testmsg.text = 'SD/MMC check fail'

	def handle_key (self, down, key):
		if not down:
			return True
		if key == '*':
			runtime.manager.back_stage()
	def destroy(self):
		Stage.destroy(self)
		runtime.evas.handle_key = self.tmpkey



###10
def swdown_start(index):
	pid = os.fork()
	if pid == 0:
		if index == 0:
			os.execlp('swdown','swdown', 'dhcpd')
		elif index == 1:
			os.execlp('swdown','swdown', 'inetd')
		elif index == 2:
			# ÀÏ´ÜÀº SD Update°æ¿ì¿¡¸¸
			if os.path.exists('/mfs/sd'):		
				utils.vega_reset_together()		
				os.execlp('swdown','swdown', 'sdmmc')
			else:
				stage = NotifyStage(_('Insert SD/MMC Card.'))
				runtime.manager.change_stage(stage)			
		elif index == 3:
			os.execlp('swdown','swdown', 'server')
	else:
		os.waitpid(pid, 0)
#		runtime.manager.back_stage()

#class DiagNotifyStage(NotifyStage):
#	def __init__(self, message):
#		NotifyStage.__init__(self, message, None, cb=None, duration=100*1000)

class swdown_stage(ListStage):
	global beforekey
	title = 'S/W DOWNLOAD'
	choice = ('0. DHCP Mode','1. Enable INETD','2. From SD/MMC','3. From 192.168.1.10')

	def activate(self, index):
		ipstr = ''
		if index == 0:
			ipstr = 'DHCP Mode'
		elif index == 1:
			ipstr = 'Enable INETD'
		elif index == 2:
			ipstr = 'UPDATE from SD/MMC'
		elif index == 3:
			ipstr = 'From 192.168.1.10'
#		stage = DiagNotifyStage(ipstr)
#		runtime.manager.change_stage(stage)
		stage = MessageStage('S/W DOWNLOAD',ipstr)
		runtime.manager.stack_stage(stage)
		swdown_start(index)

	def handle_key(self, key):
		if key in '0123':
			index = ord(key)-ord('0')
			self.activate(index)
		else:
			return ListStage.handle_key(self,key)

###11

_MISC_functions = ['packet_on', 'packet_off']



def get_misc_func(index):
	return _MISC_functions[index]


beforekey3 = 0
class packet_menu_onoff(ListStage):
	global beforekey3
	title = 'PACKET MENU ON/OFF'
	choice = ('0. PACKET Menu ON','1. PACKET Menu OFF')

	beforekey3 = 0
	mode_text = ''

	def __init__(self):
		ListStage.__init__(self)

	def destroy(self):

		ListStage.destroy(self)

	def activate(self, index):
		global beforekey3

		if get_misc_func(index) == 'packet_on':
			print 'packet_menu_on'
			os.system('rm /usr/etc/packet*')
			os.system('touch /usr/etc/packet_on')
			mode_text = "PACKET MENU VISIBLE!"

		elif get_misc_func(index) == 'packet_off':
			print 'packet_menu_off'
			os.system('rm /usr/etc/packet*')
			mode_text = "PACKET MENU HIDE!"

		stage = MessageStage('PACKET MENU VISIBLE/HIDE',mode_text)
		runtime.manager.stack_stage(stage)
		runtime.manager.back_stage()



	def handle_key(self, key):
		global beforekey3
		if key in "01":
			index = ord(key)-ord('0')
			print 'index = ' + key

			if get_misc_func(index) == 'packet_on':
				print 'packet_menu_on'
				os.system('rm /usr/etc/packet*')
				os.system('touch /usr/etc/packet_on')
				mode_text = "PACKET MENU VISIBLE!"

			elif get_misc_func(index) == 'packet_off':
				print 'packet_menu_off'
				os.system('rm /usr/etc/packet*')
				mode_text = "PACKET MENU HIDE!"




		elif key == '*':
				runtime.manager.back_stage()

		else:
			return ListStage.handle_key(self,key)
		beforekey3 = key

###12
class debug_menu_stage(ListStage):
	title = 'DEBUG MENU'

	def __init__(self):
		if status.debug_mode:
			self.choice = 'Disable',
		else:
			self.choice = 'Enable',
		ListStage.__init__(self, choice=self.choice)

	def activate(self, index):
		if status.debug_mode:
			print 'debug_menu disable..'
			status.debug_mode = False
			mode_text = 'DEBUG MENU DISABLE!'
		else:
			print 'debug_menu enable..'
			status.debug_mode = True
			mode_text = 'DEBUG MENU ENABLE!'

		stage = MessageStage('DEBUG MENU', mode_text)
		runtime.manager.stack_stage(stage)
		runtime.manager.back_stage()

#MMW added	// 2005.12.18 to change bug flag
class provision_debug_stage(ListStage):
	title = 'PROVISION_DEBUG'

	def __init__(self):
		if config.provision_debug:
			self.choice = 'Disable',
		else:
			self.choice = 'Enable',
		ListStage.__init__(self, choice=self.choice)

	def activate(self, index):
		if config.provision_debug:
			print 'provision_debug disable..'
			config.provision_debug = False
			mode_text = 'PROVISION_DEBUG DISABLE!'
		else:
			print 'provision_debug enable..'
			config.provision_debug = True
			mode_text = 'PROVISION_DEBUG ENABLE!'

		stage = MessageStage('PROVISION_DEBUG', mode_text)
		runtime.manager.stack_stage(stage)
		runtime.manager.back_stage()
		
class stage_debug_stage(ListStage):
	title = 'STAGE_DEBUG'

	def __init__(self):
		if config.stage_debug:
			self.choice = 'Disable',
		else:
			self.choice = 'Enable',
		ListStage.__init__(self, choice=self.choice)

	def activate(self, index):
		if config.stage_debug:
			print 'stage_debug disable..'
			config.stage_debug = False
			mode_text = 'STAGE_DEBUG DISABLE!'
		else:
			print 'stage_debug enable..'
			config.stage_debug = True
			mode_text = 'STAGE_DEBUG ENABLE!'

		stage = MessageStage('STAGE_DEBUG', mode_text)
		runtime.manager.stack_stage(stage)
		runtime.manager.back_stage()

class myann_service_stage(ListStage):
	title = 'My ANN Service'
	choice = ('Debug print', 'Registration flag', 'Home URL', 'BG download URL', 'Bell download URL', 'Traffic Host', 'Traffic Port')

	def __init__(self):
		ListStage.__init__(self)

	def activate(self, index):
		stage = (myann_debug_stage, myann_test_debug_stage, myann_home_url_stage, myann_bg_url_stage, myann_bell_url_stage, myann_traffic_host_stage, myann_traffic_port_stage)[index]
		runtime.manager.stack_stage(stage)

class myann_debug_stage(ListStage):
	title = 'MYANN_DEBUG'

	def __init__(self):
		if config.myann_debug:
			self.choice = 'Disable',
		else:
			self.choice = 'Enable',
		ListStage.__init__(self, choice=self.choice)

	def activate(self, index):
		if config.myann_debug:
			print 'myann_debug disable..'
			config.myann_debug = False
			mode_text = 'MYANN_DEBUG DISABLE!'
		else:
			print 'myann_debug enable..'
			config.myann_debug = True
			mode_text = 'MYANN_DEBUG ENABLE!'

		stage = MessageStage('MYANN_DEBUG', mode_text)
		runtime.manager.stack_stage(stage)
		runtime.manager.back_stage()

class myann_test_debug_stage(ListStage):
	title = 'MYANN_TEST_FLAG'

	def __init__(self):
		if config.myann_test_flag:
			self.choice = 'Disable',
		else:
			self.choice = 'Enable',
		ListStage.__init__(self, choice=self.choice)

	def activate(self, index):
		if config.myann_test_flag:
			print 'myann_test_flag disable..'
			config.myann_test_flag = False
			mode_text = 'MYANN_TEST_FLAG DISABLE!'
		else:
			print 'myann_test_flag enable..'
			config.myann_test_flag = True
			mode_text = 'MYANN_TEST_FLAG ENABLE!'

		stage = MessageStage('MYANN_TEST_FLAG', mode_text)
		runtime.manager.stack_stage(stage)
		runtime.manager.back_stage()

class myann_home_url_stage(EntryStage):
	def __init__(self):
		EntryStage.__init__(self, 'MYANN_HOME_URL', 'MYANN_HOME_URL')
		self.ui.set_text(config.MY_SERVICE_HOME_URL)
		self.ui.entry.cursor_start()

	def activate_menu1(self):
		config.MY_SERVICE_HOME_URL = self.ui.get_text()
		stage = MessageStage('MYANN_HOME_URL', 'MYANN_HOME_URL is changed')
		runtime.manager.stack_stage(stage)
		runtime.manager.back_stage()

class myann_bg_url_stage(EntryStage):
	def __init__(self):
		EntryStage.__init__(self, 'MYANN_BG_URL', 'MYANN_BG_URL')
		self.ui.set_text(config.BACKGROUND_DOWNLOAD_URL)
		self.ui.entry.cursor_start()

	def activate_menu1(self):
		config.BACKGROUND_DOWNLOAD_URL = self.ui.get_text()
		stage = MessageStage('MYANN_BG_URL', 'MYANN_BG_URL is changed')
		runtime.manager.stack_stage(stage)
		runtime.manager.back_stage()

class myann_bell_url_stage(EntryStage):
	def __init__(self):
		EntryStage.__init__(self, 'MYANN_BELL_URL', 'MYANN_BELL_URL')
		self.ui.set_text(config.BELL_DOWNLOAD_URL)
		self.ui.entry.cursor_start()

	def activate_menu1(self):
		config.BELL_DOWNLOAD_URL = self.ui.get_text()
		stage = MessageStage('MYANN_BELL_URL', 'MYANN_BELL_URL is changed')
		runtime.manager.stack_stage(stage)
		runtime.manager.back_stage()

class myann_traffic_host_stage(EntryStage):
	def __init__(self):
		EntryStage.__init__(self, 'MYANN_TRAFFIC_HOST', 'MYANN_TRAFFIC_HOST')
		self.ui.set_text(config.TRAFFICHOST)		

	def activate_menu1(self):
		config.TRAFFICHOST = self.ui.get_text()
		stage = MessageStage('MYANN_TRAFFIC_HOST', 'MYANN_TRAFFIC_HOST is changed')
		runtime.manager.stack_stage(stage)
		runtime.manager.back_stage()

class myann_traffic_port_stage(EntryStage):
	def __init__(self):
		EntryStage.__init__(self, 'MYANN_TRAFFIC_PORT', 'MYANN_TRAFFIC_PORT')
		self.ui.set_text(config.TRAFFICPORT)	

	def activate_menu1(self):
		config.TRAFFICPORT = self.ui.get_text()
		stage = MessageStage('MYANN_TRAFFIC_PORT', 'MYANN_TRAFFIC_PORT is changed')
		runtime.manager.stack_stage(stage)
		runtime.manager.back_stage()

#KA: [20080509]
class local_debug_stage(ListStage):
	title = 'local_debug'

	def __init__(self):
		if setting.urlPolicy == 0:
			self.choice = 'Disable',
		else:
			self.choice = 'Enable',
		ListStage.__init__(self, choice=self.choice)

	def activate(self, index):
		if setting.urlPolicy == 0:
			config.local_test_flag = False
			mode_text = 'LOCAL_DEBUG DISABLE!'
			setting.set_urlPolicy(1)
		else:
			config.local_test_flag = True
			mode_text = 'LOCAL_DEBUG ENABLE!'
			setting.set_urlPolicy(0)

		stage = MessageStage('LOCAL_DEBUG', mode_text)
		runtime.manager.stack_stage(stage)
		runtime.manager.back_stage()
#KA: [20080509] ==		

# hcryoo : [20070430_1]
class AEC_debug_stage(ListStage):
	title = 'AEC_DEBUG'

	def __init__(self):
		if config.AEC_debug:
			self.choice = 'Disable',
		else:
			self.choice = 'Enable',
		ListStage.__init__(self, choice=self.choice)

	def activate(self, index):
		if config.AEC_debug:
			print 'AEC_debug disable..'
			config.AEC_debug = False
			mode_text = 'AEC_DEBUG DISABLE!'
		else:
			print 'AEC_debug enable..'
			config.AEC_debug = True
			mode_text = 'AEC_DEBUG ENABLE!'

		stage = MessageStage('AEC_DEBUG', mode_text)
		runtime.manager.stack_stage(stage)
		runtime.manager.back_stage()
# hcryoo : [20070430_1]==

class audio_debug_stage(ListStage):
	title = 'AUDIO_DEBUG'

	def __init__(self):
		if config.audio_debug:
			self.choice = 'Disable',
		else:
			self.choice = 'Enable',
		ListStage.__init__(self, choice=self.choice)

	def activate(self, index):
		if config.audio_debug:
			print 'audio_debug disable..'
			config.audio_debug = False
			mode_text = 'AUDIO_DEBUG DISABLE!'
		else:
			print 'audio_debug enable..'
			config.audio_debug = True
			mode_text = 'AUDIO_DEBUG ENABLE!'

		stage = MessageStage('AUDIO_DEBUG', mode_text)
		runtime.manager.stack_stage(stage)
		runtime.manager.back_stage()

class dtmf_debug_stage(ListStage):
	title = 'DTMF_DEBUG'

	def __init__(self):
		if config.dtmf_debug:
			self.choice = 'Disable',
		else:
			self.choice = 'Enable',
		ListStage.__init__(self, choice=self.choice)

	def activate(self, index):
		if config.dtmf_debug:
			print 'dtmf_debug disable..'
			config.dtmf_debug = False
			mode_text = 'DTMF_DEBUG DISABLE!'
		else:
			print 'dtmf_debug enable..'
			config.dtmf_debug = True
			mode_text = 'DTMF_DEBUG ENABLE!'

		stage = MessageStage('DTMF_DEBUG', mode_text)
		runtime.manager.stack_stage(stage)
		runtime.manager.back_stage()


class sms_debug_stage(ListStage):
	title = 'SMS_DEBUG'
	def __init__(self):
		if config.sms_debug:
			self.choice = 'Disable',
		else:
			self.choice = 'Enable',
		ListStage.__init__(self, choice=self.choice)

	def activate(self, index):
		if config.sms_debug:
			print 'sms_debug disable..'
			config.sms_debug = False
			mode_text = 'SMS_DEBUG DISABLE!'
		else:
			print 'sms_debug enable..'
			config.sms_debug = True
			mode_text = 'SMS_DEBUG ENABLE!'

		stage = MessageStage('SMS_DEBUG', mode_text)
		runtime.manager.stack_stage(stage)
		runtime.manager.back_stage()

class utils_debug_stage(ListStage):
	title = 'UTILS_DEBUG'

	def __init__(self):
		if config.utils_debug:
			self.choice = 'Disable',
		else:
			self.choice = 'Enable',
		ListStage.__init__(self, choice=self.choice)

	def activate(self, index):
		if config.utils_debug:
			print 'utils_debug disable..'
			config.utils_debug = False
			mode_text = 'UTILS_DEBUG DISABLE!'
		else:
			print 'utils_debug enable..'
			config.utils_debug = True
			mode_text = 'UTILS_DEBUG ENABLE!'

		stage = MessageStage('UTILS_DEBUG', mode_text)
		runtime.manager.stack_stage(stage)
		runtime.manager.back_stage()

class sim_debug_stage(ListStage):
	title = 'SIM_DEBUG'

	def __init__(self):
		if config.sim_debug:
			self.choice = 'Disable',
		else:
			self.choice = 'Enable',
		ListStage.__init__(self, choice=self.choice)

	def activate(self, index):
		if config.sim_debug:
			print 'sim_debug disable..'
			config.sim_debug = False
			mode_text = 'SIM_DEBUG DISABLE!'
		else:
			print 'sim_debug enable..'
			config.sim_debug = True
			mode_text = 'SIM_DEBUG ENABLE!'

		stage = MessageStage('SIM_DEBUG', mode_text)
		runtime.manager.stack_stage(stage)
		runtime.manager.back_stage()



class sac3_debug_debug_stage(ListStage):
	title = 'SAC3_DEBUG'

	def __init__(self):
		if config.sac3_debug:
			self.choice = 'Disable',
		else:
			self.choice = 'Enable',
		ListStage.__init__(self, choice=self.choice)

	def activate(self, index):
		if config.sac3_debug:
			print 'sac3_debug disable..'
			config.sac3_debug = False
			mode_text = 'SAC3_DEBUG DISABLE!'
		else:
			print 'sac3_debug enable..'
			config.sac3_debug = True
			mode_text = 'SAC3_DEBUG ENABLE!'

		stage = MessageStage('SAC3_DEBUG', mode_text)
		runtime.manager.stack_stage(stage)
		runtime.manager.back_stage()


class modem_debug_stage(ListStage):
	title = 'MODEM_DEBUG'

	def __init__(self):
		if config.modem_debug:
			self.choice = 'Disable',
		else:
			self.choice = 'Enable',
		ListStage.__init__(self, choice=self.choice)

	def activate(self, index):
		if config.modem_debug:
			print 'modem_debug disable..'
			config.modem_debug = False
			mode_text = 'MODEM_DEBUG DISABLE!'
		else:
			print 'modem_debug enable..'
			config.modem_debug = True
			mode_text = 'MODEM_DEBUG ENABLE!'

		# eicho modify 06.03.17
		if runtime.modem != None:
			runtime.modem.set_debug(config.modem_debug)
		stage = MessageStage('MODEM_DEBUG', mode_text)
		runtime.manager.stack_stage(stage)
		runtime.manager.back_stage()

class mm_debug_stage(ListStage):
	title = 'MM_DEBUG'

	def __init__(self):
		if config.mm_debug:
			self.choice = 'Disable',
		else:
			self.choice = 'Enable',
		ListStage.__init__(self, choice=self.choice)

	def activate(self, index):
		if config.mm_debug:
			print 'mm_debug disable..'
			config.mm_debug = False
			mode_text = 'MM_DEBUG DISABLE!'
		else:
			print 'mm_debug enable..'
			config.mm_debug = True
			mode_text = 'MM_DEBUG ENABLE!'

		stage = MessageStage('MM_DEBUG', mode_text)
		runtime.manager.stack_stage(stage)
		runtime.manager.back_stage()

class videocall_debug_stage(ListStage):
	title = 'VIDEOCALL_DEBUG'

	def __init__(self):
		if config.videocall_debug:
			self.choice = 'Disable',
		else:
			self.choice = 'Enable',
		ListStage.__init__(self, choice=self.choice)

	def activate(self, index):
		if config.videocall_debug:
			print 'videocall_debug disable..'
			config.videocall_debug = False
			mode_text = 'VIDEOCALL_DEBUG DISABLE!'
		else:
			print 'videocall_debug enable..'
			config.videocall_debug = True
			mode_text = 'VIDEOCALL_DEBUG ENABLE!'

		stage = MessageStage('VIDEOCALL_DEBUG', mode_text)
		runtime.manager.stack_stage(stage)
		runtime.manager.back_stage()

class roxia_debug_stage(ListStage):
	title = 'ROXIA_DEBUG'

	def __init__(self):
		if config.roxia_debug:
			self.choice = 'Disable',
		else:
			self.choice = 'Enable',
		ListStage.__init__(self, choice=self.choice)

	def activate(self, index):
		if config.roxia_debug:
			print 'roxia_debug disable..'
			config.roxia_debug = False
			mode_text = 'ROXIA_DEBUG DISABLE!'
		else:
			print 'roxia_debug enable..'
			config.roxia_debug = True
			mode_text = 'ROXIA_DEBUG ENABLE!'

		stage = MessageStage('ROXIA_DEBUG', mode_text)
		runtime.manager.stack_stage(stage)
		runtime.manager.back_stage()

class roxia_event_stage(ListStage):
	title = 'ROXIA_EVENT'

	def __init__(self):
		if config.roxia_event:
			self.choice = 'Disable',
		else:
			self.choice = 'Enable',
		ListStage.__init__(self, choice=self.choice)

	def activate(self, index):
		if config.roxia_event:
			print 'roxia_event disable..'
			config.roxia_event = False
			mode_text = 'ROXIA_EVENT DISABLE!'
		else:
			print 'roxia_event enable..'
			config.roxia_event = True
			mode_text = 'ROXIA_EVENT ENABLE!'

		stage = MessageStage('ROXIA_EVENT', mode_text)
		runtime.manager.stack_stage(stage)
		runtime.manager.back_stage()

class update_debug_stage(ListStage):
	title = 'UPDATE_DEBUG'

	def __init__(self):
		if config.update_debug:
			self.choice = 'Disable',
		else:
			self.choice = 'Enable',
		ListStage.__init__(self, choice=self.choice)

	def activate(self, index):
		if config.update_debug:
			print 'update_debug disable..'
			config.update_debug = False
			mode_text = 'UPDATE_DEBUG DISABLE!'
		else:
			print 'update_debug enable..'
			config.update_debug = True
			mode_text = 'UPDATE_DEBUG ENABLE!'

		stage = MessageStage('UPDATE_DEBUG', mode_text)
		runtime.manager.stack_stage(stage)
		runtime.manager.back_stage()

class ipemail_debug_stage(ListStage):
	title = 'IPEMAIL_DEBUG'

	def __init__(self):
		if config.ipemail_debug:
			self.choice = 'Disable',
		else:
			self.choice = 'Enable',
		ListStage.__init__(self, choice=self.choice)

	def activate(self, index):
		if config.ipemail_debug:
			print 'ipemail_debug disable..'
			config.ipemail_debug = False
			mode_text = 'IPEMAIL_DEBUG DISABLE!'
		else:
			print 'ipemail_debug enable..'
			config.ipemail_debug = True
			mode_text = 'IPEMAIL_DEBUG ENABLE!'

		stage = MessageStage('IPEMAIL_DEBUG', mode_text)
		runtime.manager.stack_stage(stage)
		runtime.manager.back_stage()

class alldebug_flag_stage(ListStage):
	global all_debug_flag
	title = 'ALL_DEBUG_FLAG'
	all_debug_flag = False
	def __init__(self):
		if all_debug_flag == True:
			self.choice = 'Disable',
		else:
			self.choice = 'Enable',
		ListStage.__init__(self, choice=self.choice)

	def activate(self, index):
		global all_debug_flag
		if all_debug_flag == True:
			print 'all_debug_flag disable..'
			all_debug_flag = False
			key_debug = False
			config.stage_debug = False
			config.ring_debug = False
			config.audio_debug = False
			config.dtmf_debug = False
			config.sms_debug = False
			config.utils_debug = False
			config.sim_debug = False
			config.sim_reader_debug = False
			config.sac3_debug = False
			config.modem_debug = False
			config.mm_debug = False
			config.videocall_debug = False
			config.roxia_debug = False
			config.roxia_event = False
			config.update_debug = False
			config.ipemail_debug = False
			config.netc_debug = False
			config.netn_debug = False
			
			mode_text = 'ALL_DEBUG_FLAG DISABLE!'
		else:
			print 'all_debug_flag enable..'
			all_debug_flag = True
			key_debug = True
			config.stage_debug = True
			config.ring_debug = True
			config.audio_debug = True
			config.dtmf_debug = True
			config.sms_debug = True
			config.utils_debug = True
			config.sim_debug = True
			config.sim_reader_debug = True
			config.sac3_debug = True
			config.modem_debug = True
			config.mm_debug = True
			config.videocall_debug = True
			config.roxia_debug = True
			config.roxia_event = True
			config.update_debug = True
			config.ipemail_debug = True
			config.netc_debug = True
			config.netn_debug = True
			
			mode_text = 'ALL_DEBUG_FLAG ENABLE!'

		# eicho modify 06.03.17
		if runtime.modem != None:
			runtime.modem.set_debug(config.modem_debug)
		stage = MessageStage('ALL_DEBUG_FLAG', mode_text)
		runtime.manager.stack_stage(stage)
		runtime.manager.back_stage()

class VDCI_debug_stage(ListStage):
	title = 'VDCI_DEBUG'

	def __init__(self):
		if config.VDCI_debug:
			self.choice = 'Disable',
		else:
			self.choice = 'Enable',
		ListStage.__init__(self, choice=self.choice)

	def activate(self, index):
		if config.VDCI_debug:
			print 'VDCI_debug disable..'
			config.VDCI_debug = False
			runtime.vdciapp.send_mesg(code1='cd', code2='d', mesg1='d')	
			mode_text = 'VDCI_DEBUG DISABLE!'
		else:
			print 'VDCI_debug enable..'
			config.VDCI_debug = True
			runtime.vdciapp.send_mesg(code1='cd', code2='d', mesg1='a')	
			mode_text = 'VDCI_DEBUG ENABLE!'

		stage = MessageStage('VDCI_DEBUG', mode_text)
		runtime.manager.stack_stage(stage)
		runtime.manager.back_stage()
		
class all_KT_debug_stage(ListStage):
	global all_KT_debug_flag
	title = 'ALL_KT_DEBUG_FLAG'
	all_KT_debug_flag = False
	def __init__(self):
		if all_KT_debug_flag == True:
			self.choice = 'Disable',
		else:
			self.choice = 'Enable',
		ListStage.__init__(self, choice=self.choice)

	def activate(self, index):
		global all_KT_debug_flag
		if all_KT_debug_flag == True:
			print 'all_KT_debug_flag disable..'
			all_KT_debug_flag = False
			key_debug = False
			config.stage_debug = False
			config.mmi_debug = False
			config.videocall_debug = False
			config.roxia_debug = False
			config.roxia_event = False
			mode_text = 'ALL_KT_DEBUG_FLAG DISABLE!'
		else:
			print 'all_KT_debug_flag enable..'
			all_KT_debug_flag = True
			key_debug = True
			config.stage_debug = True
			config.mmi_debug = True
			config.videocall_debug = True
			config.roxia_debug = True
			config.roxia_event = True
			mode_text = 'ALL_KT_DEBUG_FLAG ENABLE!'

		stage = MessageStage('ALL_KT_DEBUG_FLAG', mode_text)
		runtime.manager.stack_stage(stage)
		runtime.manager.back_stage()


_chariot_functions = ['start_endpoint']
def get_chariot_func(index):
	return _chariot_functions[index]


beforekey4 = 0
class start_endpoint(ListStage):
	global beforekey4
	title = 'START ENDPOINT'
	choice = '0. Start EndPoint',

	beforekey4 = 0
	mode_text = ''

	def __init__(self):
		ListStage.__init__(self)

	def destroy(self):

		ListStage.destroy(self)

	def activate(self, index):
		global beforekey4

		if get_chariot_func(index) == 'start_endpoint':
			print 'start_endpoint!!'
			os.system('/usr/local/bin/start_endpoint &')
			mode_text = "STARTED ENDPOINT!"

			stage = MessageStage('START ENDPOINT',mode_text)
			runtime.manager.stack_stage(stage)
			runtime.manager.back_stage()



	def handle_key(self, key):
		global beforekey4
		if key in "0":
			index = ord(key)-ord('0')
			print 'index = ' + key

			if get_chariot_func(index) == 'start_endpoint':
				print 'start_endpoint!!'
				os.system('/usr/local/bin/start_endpoint &')
				mode_text = "STARTED ENDPOINT!"

		elif key == '*':
				runtime.manager.back_stage()

		else:
			return ListStage.handle_key(self,key)
		beforekey4 = key

class To_debug_stage(ListStage):
	name = 'test_debug_flag'
	title = 'To Debug'
	choice = ('stage_debug',
		'audio_debug',
		'dtmf_debug',
 		'sms_debug',
		'utils_debug',
		'sim_debug',
		'sac3_debug',
		'modem_debug',
		'mm_debug',
		'videocall_debug',
		'roxia_debug',
		'roxia_event',
		'update_debug',
		'ipemail_debug',
		'alldebug_flag',
		'Packet Menu Visible/Hide',
		'Debug menu',
		'Start EndPoint',
		'AEC',
		'My ANN Service', 
		'KT_debug', 
		'local_debug',
		'VDCI_debug',
		'LANG_SELECT',
		'DEV_MISC',
		'provision_debug'
		)


	def __init__(self):
		ListStage.__init__(self)

	def activate(self, index):
		stage = get_stage1(index)
		runtime.manager.stack_stage(stage)

_stages1 = 	\
			stage_debug_stage, \
			audio_debug_stage, \
			dtmf_debug_stage, \
			sms_debug_stage, \
			utils_debug_stage, \
			sim_debug_stage, \
			sac3_debug_debug_stage, \
			modem_debug_stage, \
			mm_debug_stage, \
			videocall_debug_stage, \
			roxia_debug_stage, \
			roxia_event_stage, \
			update_debug_stage, \
			ipemail_debug_stage,\
			alldebug_flag_stage, \
			packet_menu_onoff, \
			debug_menu_stage, \
			start_endpoint, \
			AEC_debug_stage, \
			myann_service_stage, \
			all_KT_debug_stage,\
			local_debug_stage, \
			VDCI_debug_stage, \
			phonesetting.LanguageTestStage, \
			DevMisc, \
			provision_debug_stage

def get_stage1(index):
	return _stages1[index]


class Modem_HW_reset_debug_stage(ListStage):
	title = 'MODEM_HW_RESET'

	def __init__(self):
		self.choice = 'Reset',
		ListStage.__init__(self, choice=self.choice)

	def activate(self, index):

		import sms

		if not runtime.modem:
			runtime.manager.modem_init()

		else :
			if runtime.modem:
				runtime.modem.close()
			runtime.modem = None

			runtime.dspg.modem_reset()
#			time.sleep(1)

			time.sleep(1)
			runtime.manager.modem_init()
			'''
			try:
				runtime.dspg.modem_reset()
				time.sleep(1)
			except IOError:
				print 'MODEM HW reset fail'
				time.sleep(5)
				self.write_command('ATZ\r')
				pass

			if setting.pcm_upstream == 0: #on
				modem_patch = config.modem_patch_upstream_on
			else:
				modem_patch = config.modem_patch_upstream_off

			for file in modem_patch:
				runtime.modem.load_patch(file)
			runtime.modem.reset()
			'''

		print 'MODEM HW reset'
		mode_text = 'MODEM HW RESET!!'

		stage = MessageStage('MODEM_HW_RESET', mode_text)
		runtime.manager.stack_stage(stage)



class Modem_SW_reset_debug_stage(ListStage):
	title = 'MODEM_SW_RESET'

	def __init__(self):
		self.choice = 'Reset',
		ListStage.__init__(self, choice=self.choice)

	def activate(self, index):
		import sms

		if not runtime.modem:
			runtime.manager.modem_init()


		else :
			try:
				runtime.modem.write_command('ATZ\r')
			except IOError:
				print 'MODEM SW reset fail'
				time.sleep(5)
				runtime.modem.write_command('ATZ\r')
				pass

			if setting.pcm_upstream == 0: #on
				modem_patch = config.modem_patch_upstream_on
			else:
				modem_patch = config.modem_patch_upstream_off

			for file in modem_patch:
				runtime.modem.load_patch(file)
			runtime.modem.reset()

		print 'MODEM SW reset'
		config.ipemail_debug = False
		mode_text = 'MODEM SW RESET!!'

		stage = MessageStage('MODEM_SW_RESET', mode_text)
		runtime.manager.stack_stage(stage)





class Modem_PCM_UP_Stream_stage(ListStage):
	global pcm_up
	title = 'MODEM_PCM_TEST'
	pcm_up = 0
	def __init__(self):
		runtime.modem.write_command('AT+PIG=1\r')
		if pcm_up == 1:
			self.choice = 'Disable',
		else:
			self.choice = 'Enable',
		ListStage.__init__(self, choice=self.choice)

	def activate(self, index):
		global pcm_up
		import sms
		if pcm_up == 1:
			print 'PCM_UP_disabled'
			runtime.modem.write_command('AT+PIG=1\r')
			mode_text = 'PCM_UP_DISABLED!'
			pcm_up = 0
		else:
			print 'PCM_UP_enabled'
			runtime.modem.write_command('AT+PIG=0\r')
			mode_text = 'PCM_UP_ENABLED!'
			pcm_up = 1


		stage = MessageStage('PCM_UP_STREAM', mode_text)
		runtime.manager.stack_stage(stage)
		runtime.manager.back_stage()



class Modem_debug_stage(ListStage):
	name = 'Modem_debug_flag'
	title = 'Modem Debug'
	choice = ('Modem_HW_reset_test',
		'Modem_SW_reset_test',
		'Modem_PCM_UP_test',
			)


	def __init__(self):
		ListStage.__init__(self)

	def activate(self, index):
		stage = get_stage2(index)
		runtime.manager.stack_stage(stage)

_stages2 = 	\
			Modem_HW_reset_debug_stage,\
			Modem_SW_reset_debug_stage,\
			Modem_PCM_UP_Stream_stage

def get_stage2(index):
	return _stages2[index]



#MMW
class RX_Result_stage(ListStage):
	title = 'Rx_Result'

	def __init__(self):
		self.choice = 'RF RX test result',
		fp = open('/tmp/rx_result')
		for tline in fp: #readlines:
			if tline.find('Receive: good packet') >= 0:
				if tline.find('good packet'):
					ti = tline.find('good packet')
					rx_result = (tline[ti+12:tline.find(', bad packet')])
					self.rx_result = int(rx_result)
					print 'first result =', self.rx_result
					break;

		ListStage.__init__(self, choice=self.choice)

	def activate(self, index):
		print 'wifi RF test result show!!'
		os.system('wl pktcnt > /tmp/rx_result')
		time.sleep(2)

		fp = open('/tmp/rx_result')
		for tline in fp: #readlines:
			if tline.find('Receive: good packet') >= 0:
				if tline.find('good packet'):
					ti = tline.find('good packet')
					rx_active_result = (tline[ti+12:tline.find(', bad packet')])
					after_result = int(rx_active_result)
					print 'after result = ', after_result
					break;
		before_result = self.rx_result			
		print 'before result =', before_result
		self.rx_result = after_result			
		rx_test_result = after_result - before_result
		print 'rx test result =', rx_test_result

		
		mode_text = 'Rx resut = '+str(rx_test_result)

		stage = MessageStage('WIFI RF RX TEST', mode_text)
		runtime.manager.stack_stage(stage)

		
class Driver_Loading_stage(ListStage):
	title = 'RF_Test_Driver_loading'

	def __init__(self):
		self.choice = 'RF Test driver loading',
		ListStage.__init__(self, choice=self.choice)

	def activate(self, index):
		os.system('wifi_RF_test')
		print 'wifi driver loading'
		mode_text = 'DRIVER LOADED!!'

		stage = MessageStage('WIFI RF TEST', mode_text)
		runtime.manager.stack_stage(stage)


class Wifi_RF_TX_TEST(ListStage):
	title = 'RF_TX_TEST'

	def __init__(self):
		self.choice = ('11b channel 1',
		'11b channel 5',
		'11b channel 9',
		'11b channel 13',
		'11g channel 1',
		'11g channel 5',
		'11g channel 9',
		'11g channel 13',
		)
		ListStage.__init__(self, choice=self.choice)

	def activate(self, index):
		if index == 0 :
#			channel_num = chr(index + 49) 
#			print 'channel'+channel_num
			os.system('b_test 1')
			print 'b-mode tx test channel 1'
			mode_text = '11b channel 1 tx test!!'
			stage = MessageStage('WIFI RF TX TEST', mode_text)

		elif index == 1 :
			os.system('b_test 5')
			print 'b-mode tx test channel 5'
			mode_text = '11b channel 5 tx test!!'
			stage = MessageStage('WIFI RF TX TEST', mode_text)

		elif index == 2 :
			os.system('b_test 9')
			print 'b-mode tx test channel 9'
			mode_text = '11b channel 9 tx test!!'
			stage = MessageStage('WIFI RF TX TEST', mode_text)

		elif index == 3 :
			os.system('b_test 13')
			print 'b-mode tx test channel 13'
			mode_text = '11b channel 13 tx test!!'
			stage = MessageStage('WIFI RF TX TEST', mode_text)

		elif index == 4 :
			os.system('g_test 1')
			print 'g-mode tx test channel 1'
			mode_text = '11g channel 1 tx test!!'
			stage = MessageStage('WIFI RF TX TEST', mode_text)

		elif index == 5 :
			os.system('g_test 5')
			print 'g-mode tx test channel 5'
			mode_text = '11g channel 5 tx test!!'
			stage = MessageStage('WIFI RF TX TEST', mode_text)
		elif index == 6 :
			os.system('g_test 9')
			print 'g-mode tx test channel 9'
			mode_text = '11g channel 9 tx test!!'
			stage = MessageStage('WIFI RF TX TEST', mode_text)
		elif index == 7 :
			os.system('g_test 13')
			print 'g-mode tx test channel 13'
			mode_text = '11g channel 13 tx test!!'
			stage = MessageStage('WIFI RF TX TEST', mode_text)

		runtime.manager.stack_stage(stage)

class Wifi_RF_RX_TEST(ListStage):
	title = 'RF_RX_TEST'

	def __init__(self):
		self.choice = ('11b channel 1',
		'11b channel 5',
		'11b channel 9',
		'11b channel 13',
		'11g channel 1',
		'11g channel 5',
		'11g channel 9',
		'11g channel 13',
		)
		ListStage.__init__(self, choice=self.choice)
		os.system('wl pktcnt > /tmp/rx_result')

	def activate(self, index):
		if index == 0 :
#			channel_num = chr(index + 49) 
#			print 'channel'+channel_num
			os.system('rx_test 1')
			print 'b-mode rx test channel 1'
#			mode_text = '11b channel 1 rx test!!'
			time.sleep(1)
			os.system('wl pktcnt > /tmp/rx_result')
			time.sleep(2)
			
		elif index == 1 :
			os.system('rx_test 5')
			print 'b-mode rx test channel 5'
#			mode_text = '11b channel 5 rx test!!'
			time.sleep(1)
			os.system('wl pktcnt > /tmp/rx_result')
			time.sleep(2)

		elif index == 2 :
			os.system('rx_test 9')
			print 'b-mode rx test channel 9'
#			mode_text = '11b channel 9 rx test!!'
			time.sleep(1)
			os.system('wl pktcnt > /tmp/rx_result')
			time.sleep(2)

		elif index == 3 :
			os.system('rx_test 13')
			print 'b-mode rx test channel 13'
#			mode_text = '11b channel 13 rx test!!'
			time.sleep(1)
			os.system('wl pktcnt > /tmp/rx_result')
			time.sleep(2)

		elif index == 4 :
			os.system('rx_test 1')
			print 'g-mode rx test channel 1'
#			mode_text = '11g channel 1 rx test!!'
			time.sleep(1)
			os.system('wl pktcnt > /tmp/rx_result')
			time.sleep(2)

		elif index == 5 :
			os.system('rx_test 5')
			print 'g-mode rx test channel 5'
#			mode_text = '11g channel 5 rx test!!'
			time.sleep(1)
			os.system('wl pktcnt > /tmp/rx_result')
			time.sleep(2)

		elif index == 6 :
			os.system('rx_test 9')
			print 'g-mode rx test channel 9'
#			mode_text = '11g channel 9 rx test!!'
			time.sleep(1)
			os.system('wl pktcnt > /tmp/rx_result')
			time.sleep(2)

		elif index == 7 :
			os.system('rx_test 13')
			print 'g-mode rx test channel 13'
#			mode_text = '11g channel 13 rx test!!'
			time.sleep(1)
			os.system('wl pktcnt > /tmp/rx_result')
			time.sleep(1)


		stage = RX_Result_stage
		runtime.manager.stack_stage(stage)




class Wifi_RF_test_stage(ListStage):
	name = 'WIFI_RF_TEST'
	title = 'Wifi RF test'
	choice = ('DRIVER LOADING',
		'TX test',
		'RX test',
		)


	def __init__(self):
		ListStage.__init__(self, menu4=_('REBOOT'))

	def activate(self, index):
		stage = get_stage3(index)
		runtime.manager.stack_stage(stage)

	def handle_key(self, key):
		if key in (config.Red, config.Menu4):
#MMW 2008.06.25 when reboot is called, reset vega and DCP related GPIO pin				
			utils.vega_reset_together()
#end of MMW		
#MMW	2008.07.07	when reboot send disassoc to AP and then unload the driver
			os.system('wlstop')
#end of MMW
			os.system('reboot')
			return True
		return ListStage.handle_key(self, key)

_stages3 = 	\
			Driver_Loading_stage,\
			Wifi_RF_TX_TEST,\
			Wifi_RF_RX_TEST

def get_stage3(index):
	return _stages3[index]


#end of MMW



class ModifyFirmwareVersion(EntryStage):
	def __init__(self):
		EntryStage.__init__(self, 'version modify', 'FIRMWARE VERSION')
		self.read_config_cfg()
		self.ui.set_automata('123', False)
	def read_config_cfg(self):
		g = self.__dict__
		for line in file('/usr/local/lgvp/config.cfg'):
			line = line.strip()
			key, value = line.split('=', 1)
			g[key] = value
			if key == 'firmware_version':
				self.ui.set_text(value)


	def write_config_cfg(self):
		fp = open('/usr/local/lgvp/config.cfg', 'w')
		for key, value in self.__dict__.items():
			if key == 'ui':
				continue
			if key == 'firmware_version':
				fp.write("%s=%s\n" % (key, self.ui.get_text()))
			else:
				fp.write("%s=%s\n" % (key, value))
		fp.close()

	def handle_key(self, key):
		if key == config.Menu1:
			self.write_config_cfg()
			runtime.manager.back_stage()
		else:
			EntryStage.handle_key(self,key)

###13
#_chariot_functions = ['start_endpoint']

#MMW 2008.07.08 to add wifi mac show
class WifiMacShowUI(LargeWindowUI):
	def __init__(self, mac):
		LargeWindowUI.__init__(self, menu4=_('BACK'), small_title=_('WIFI MAC Address'))
		self.mac = mac
		self.show_list()

	def show_list(self):
		t = runtime.evas.text()
		t.font=uiconfig.details_font
		t.color=uiconfig.swver_details_color	
		t.text= self.mac
		t.pos = uiconfig.networkdetail_text_pos[2]
		self.add(t)


class WifiMacShowStage(Stage):

	def __init__(self):
		msg_na = _('not available')

		if os.access('/usr/etc/wmac', os.R_OK) :
			try:
				os.system('cat /usr/etc/wmac > /tmp/wifi_temp_mac')
				fp = open('/tmp/wifi_temp_mac')
				msg_mac = fp.readline().strip()
				fp.close()
			except :
				msg_mac = msg_na
				print 'wifi mac file read fail!!!'
#			print 'mac 1!!!!!', msg_mac
		else :
			if profile.profile.get_profile() == 1 :
				os.system('wifi_driver_loading')

			network_info = utils.get_address('wlan')
			if network_info:
				msg_mac = network_info[0][0]
				try:
					fp = open('/usr/etc/wmac', 'w')
					fp.write(msg_mac + '\n')
					fp.close()
				except :
					print '/usr/etc/wmac file write error!!!'				
			else:
				msg_mac = msg_na
#			print 'mac 2!!!!!', msg_mac

		self.ui = WifiMacShowUI(mac=msg_mac)


	def handle_key(self, key):
		if key == config.Menu4 or key == config.CLEAR: # config.Red:
			runtime.manager.back_stage()
			return True
		else:
			return False
#end of MMW







###MAIN

_stages = 	\
			final_auto_test_stage, \
			keypad_test_stage, \
			ping_ethernet_test_stage, \
			wave_test_stage,\
			mbu_auto_test_stage, \
			usb_test_stage, \
			record_test_stage, \
			camera_test_stage, \
			change_test_mode_stage, \
			version_test_stage, \
			LCD_defect_test, \
			wifi_test_stage, \
			sd_mmc_test_stage, \
		  	swdown_stage, \
		  	DirectCallTeststage, \
		  	DectPathTest,	\
		  	WifiMacShowStage
			
# video_call_test_stage, \

#ModifyFirmwareVersion, \	# added by amigo. 05.10.21# added by hclee. 05.10.31

def get_stage(index):
	return _stages[index]


beforekey = 0
class TestStage(ListStage):
	name = 'test'
	global beforekey
	title = 'TEST'
	choice = ('1. Final assy test',
		'2. Keypad(all) test',
		'3. LAN(ping) test',
		'4. WAVE test',
 		'5. MBU auto test',
		'6. USB test',
		'7. Voice Tx/Rx test',
		'8. Camera test',
		'9. test mode change',
		'0. Serial/MAC check',
		'11. LCD defect test',
		'    WIFI check',
		'    SD/MMC check',
		'    S/W download', 
		'    Call test', 
		'    DECT path test',
		'    Wifi MAC check')


	beforekey = 0

	def __init__(self):
		ListStage.__init__(self)
		#if setting.screen_saver_enabled:
		#	print '>>> disable screen saver'
		#	setting._screen_saver_timer = 0
		#	def reset_screensaver():
		#		setting._screen_saver_timer = None
		#		return True
		#	self.reset_timer = utils.Timer(1000, reset_screensaver)


	def destroy(self):
		#self.reset_timer = None
		ListStage.destroy(self)
		#if setting.screen_saver_enabled:
		#	print '>>> enable screen saver'
		#	setting.reset_screen_saver_timer()
		#	status.screensaver_activated = False

	def activate(self, index):
		global beforekey
		stage = get_stage(index)
		runtime.manager.stack_stage(stage)

	def handle_key(self, key):
		global beforekey
		if key in "1234567890":
			index = ord(key)-ord('1')
			if key == "0":
				index = 9
			stage = get_stage(index)
			runtime.manager.stack_stage(stage)
		elif key == '#':
			if beforekey == '#':
				stage = video_server_stage()
				runtime.manager.stack_stage(stage)
		elif key in (config.Green, config.OffHook):
			return True
		else:
			return ListStage.handle_key(self,key)
		beforekey = key
###ETC
def check_error_report():

	try:
		if os.access("/usr/etc/testmode1", os.F_OK) or os.access("/usr/etc/testmode2", os.F_OK):
			runtime.manager.stack_stage(ViewErrorStage)
		else:
			pass
	except IOError:
		pass


class ViewErrorStage(Stage):
	def __init__(self):
		#self.ui = baseui.LargeWindowUI(left='EXIT')
		msg = ''
		try:
			fp = open("/tmp/hwcheckfail", 'r')
			for  strline in fp.readlines():
				#if strline in ['\n', '\r', '\r\n']:
				sharp = strline.rfind('\x0a') 
				if sharp == -1: 
					strline = strline 
				else: 
					strline = strline[:sharp]
				msg = msg + strline + '\n'
			print '-----------------> ', len(msg)
			if len(msg) == 0:
				msg = 'TEST OK'
		except IOError:
			msg = 'TEST OK'
			
		self.ui = RichTextUI(left='EXIT')
		self.ui.set_text(msg)
		
		#t = runtime.evas.text()
		#t.font=uiconfig.details_font
		#t.color=uiconfig.swver_details_color
		#t.text= msg
		#t.pos = uiconfig.networkdetail_text_pos[1]
		#self.ui.add(t)

	def activate_menu1(self):
		runtime.manager.change_stage(IdleStage, True)

	def activate_menu2(self):
		runtime.manager.change_stage(IdleStage, True)

	def destroy(self):
		Stage.destroy(self)

	def handle_key(self, key):
		if key in (config.Green, config.OffHook):
			return True
		elif key == config.Menu1:
			runtime.manager.back_stage()
			return True
		else:
			return False

'''
class ViewErrorStage(RichTextStage):
	def __init__(self):
		RichTextStage.__init__(self, 'ERROR REPORT', left='EXIT', right='EXIT')

		msg = ''
		try:
			fp = open("/tmp/hwcheckfail", 'r')
			for  strline in fp.readlines():
				msg = msg + strline
		except IOError:
			msg = 'TEST OK'
		
		self.set_text(msg)

	def activate_menu1(self):
		#runtime.manager.back_stage()
		runtime.manager.change_stage(IdleStage, True)
	def activate_menu2(self):
		#runtime.manager.back_stage()
		runtime.manager.change_stage(IdleStage, True)
	def destroy(self):
		Stage.destroy(self)

	def handle_key(self, key):
		if key in (config.Green, config.OffHook):
			return True
		elif key in (config.Menu1, config.Menu2):
			runtime.manager.back_stage()
			return True
		else:
			return False	
'''

class MessageStage(Stage):
	domonitor_forbidden = True
	def __init__(self,title,message):
		self.ui = TestUI( title,' ',' ',title )
		self.ui.testmsg.text = message

	def show(self):
		Stage.show(self)
		runtime.evas.render_now()
		time.sleep(3)
		runtime.manager.back_stage()

	def destroy(self):
		Stage.destroy(self)

class MessageStage2(Stage):
	def __init__(self,title,message):
		self.ui = TestUI( title,' ',' ',title )
		self.ui.testmsg.text = message

		def resetTimer_CB():
			self.resetTimer = None
			runtime.manager.change_stage(MessageStage(_('Serial/MAC Check'),_('Initial Failed')))
			
		self.resetTimer = utils.Timer(10*1000, resetTimer_CB)
		
	def show(self):
		Stage.show(self)

	def changeMessage(self):
		status.DECT_RESET_TEST = False
		self.resetTimer = None

		try:
			import time
			dectVegaResetFile = open('/proc/sys/lvp3870/dect_reset', 'w')
			dectVegaResetFile.write('0')
			dectVegaResetFile.close()

			time.sleep(1)

			dectVegaResetFile = open('/proc/sys/lvp3870/dect_reset', 'w')
			dectVegaResetFile.write('1')
			dectVegaResetFile.close()

			time.sleep(1)

			runtime.manager.change_stage(MessageStage(_('Serial/MAC Check'),_('Initial Complete')))
		except:
			runtime.manager.change_stage(MessageStage(_('Serial/MAC Check'),_('Initial Failed')))
			
	def destroy(self):
		self.resetTimer = None
		Stage.destroy(self)

