UTS6710/aps/application/s2tek/rda_atv/atv/atv_app.c

/********************************************************************
** File Name: atv_app.c
**
** File Description: This file implements dvb system application
**
** Copyright(c) 2009 Sunplus Technologies - All Rights Reserved
**
** History Information Description
** Date						Author					Modification
** 2009/03/12				James					Create
********************************************************************/

/********************************************************************
	Including Files
********************************************************************/
#define ATV_GUI_OBJECT_TABLE_DEFINE_HERE
#include <signal.h>
#include <sys/ioctl.h>
#include "sysapp_if.h"
#include "sysapp_table.h"
#include "ap_extern.h"
#include "al_fw.h"
#include "atv_app.h"
#include "main_app.h"
#include "app_event.h"
#include "app_atv_event.h"
#include "app_atv_playback.h"
#ifdef CONFIG_SUPPORT_TTX
#include "al_teletext.h"
#endif
#include "app_audio.h"
#include "app_data_setting.h"
#include "app_factory.h"
#include "app_global.h"
#include "app_gui.h"
#include "app_menumgr.h"
#include "app_prog_list.h"
#include "app_power_control.h"
#include "app_systime.h"
#include "app_video.h"
#include "app_audio.h"
#include "app_scart.h"
#include "app_scan_api.h"
#ifdef CONFIG_SUPPORT_USB_UPGRADE
#include "app_usb_upgrade.h"
#endif
#include "app_guiobj_adjust.h"
#include "app_guiobj_sound.h"
#include "app_guiobj_atv_pcsetup.h"
#include "app_guiobj_atv_playback.h"
#include "app_guiobj_banner.h"
#include "app_guiobj_sleeptimer.h"
#include "app_guiobj_channel.h"
#include "app_guiobj_mute.h"
#include "app_guiobj_fm_factory.h"
#include "app_guiobj_cul_fm_HotelSetting.h"
#include "app_guiobj_fm_factory.h"
#include "app_guiobj_fm_Hotel_Mode_Adj.h"
#include "app_guiobj_mainmenu.h"
#include "app_guiobj_mainmenupop.h"
#include "app_guiobj_source.h"
#include "atv_guiobj_table.h"
#ifdef SUPPORT_CEC_TV
#include "umf_cec.h"
#endif
#ifdef SUPPORT_FACTORY_AUTO_TEST
#include "al_aps_table_api.h"
#include "mid_atv_scan.h"
#endif
#include "app_sysset.h"
#include "app_guiobj_cul_fm_factorySetting_new.h"
#include "app_guiobj_hdmilink.h"
#include "cvd2_ioctl.h"
#include "adc_ioctl.h"
#include "hdmi_ioctl.h"
#include <drv_sif_interface.h>
#ifdef CONFIG_CC_SUPPORT
#include "al_cc.h"
#endif
#ifdef CONFIG_SUPPORT_SW_AFC
#include "mid_afc.h"
#endif
#include "tuner_demod_ioctl.h"

#if defined(CONFIG_SUPPORT_NES_GAME)|| defined(CONFIG_OSD_GAME_SUPPORT)
#include "app_guiobj_game_mainmenu.h"
#endif

#ifdef CONFIG_BLUETOOTH_SUPPORT
#include "al_bluetooth.h"
#include "al_bluetooth_ctrl.h"
#if defined(CONFIG_BT_RDA5856)
#include "app_bt.h"
#include "app_guiobj_bt_setting.h"
#endif
#endif
#include "app_factory_flash_access.h"
#ifdef CONFIG_SMART_MODULE_SUPPORT
//#include "mid_dtv_display.h"
#endif
#ifdef CONFIG_SUPPORT_NET_OTA
#include "net_ota.h"
#endif
#ifdef CONFIG_SUPPORT_WIFI
#include "netsetting_if.h"
#include "net_ip_setting.h"
#endif
#ifdef CONFIG_SUPPORT_HDMI_PLUGIN_CHANGE_SOURCE
#include "cecd_interface.h"
#endif
/********************************************************************
	Macros
********************************************************************/
#define ATV_DEBUG
#define atv_printf(fmt, arg...) ((void) 0)

#ifdef ATV_DEBUG
#undef atv_printf
#define atv_printf(fmt, arg...) UMFDBG(0,"[ATV App]" fmt, ##arg)
#endif
#define  ATV_10_MINUTES		(5400)//5400*100 ms (9 min)
#define  ATV_1_MINUTES		(300)//300*100MS
#define  NO_SIGNAL_BOUNCE_TIME		(20)//20*100 ms
#define  HDMI_NO_SIGNAL_BOUNCE_TIME		(60)//20*100 ms
#define ATV_NO_SIGNAL_BOUNCE_TIME	(30)

/********************************************************************
	Type definitions
********************************************************************/
//System Application private data structure.
typedef struct AtvPrivateData_t_
{
    //user define private data
    UINT32 dUserData;
} AtvPrivateData_t;

typedef void (*SysTimeFunc)(void);

extern void _APP_GUIOBJ_3DMenu_GetForce2DAnother(UINT32 *u32Force2D);
extern void _APP_GUIOBJ_3DMenu_SetForce2DAnother(UINT32 u32Force2D);
extern int APP_GUIOBJ_3DMenu_SetModeNoOutPutStructure(UINT32 u32Mode);

/*Function declare*/
static INT32 _ATVApp_OnCreate(void **ppPrivateData);
static INT32 _ATVApp_OnDestroy(void **ppPrivateData);
static INT32 _ATVApp_OnRun(void *pPrivateData, UINT32 dParam);
static INT32 _ATVApp_OnTerminate(void *pPrivateData, UINT32 dParam);
static INT32 _ATVApp_OnTimerUpdate(void *pPrivateData);
static INT32 _ATVApp_OnEvent(void *pPrivateData, UINT32 dMessage, UINT32 dParam);

extern void  APP_GUIOBJ_SleepTimer_Reset(void);
extern UINT8 AL_FLASH_GetColorLUTALL(ColorLUT_t* bColorLUTValue);
extern void _APP_GUIOBJ_Sound_SetMuteStatus();
static UINT32 PreHDMIMODE = APP_MODE_UNDEFINE;

/********************************************************************
	Global Variables
********************************************************************/
SysAppInstDef stAtvInst =
{
    SYS_APP_ATV,
    _ATVApp_OnCreate,
    _ATVApp_OnDestroy,
    _ATVApp_OnRun,
    _ATVApp_OnTerminate,
    _ATVApp_OnTimerUpdate,
    _ATVApp_OnEvent,

    SYSTEM_IDLE, //system state.
    Atv_GUI_Obj_List,    //GUI object table
    ATV_GUIOBJ_MAX,      //GUI object table size

    NULL,  //System Application Infrastructure (should not be modified)
    NULL   //System Application private data (created in OnInitialize function)
};

static UINT8 g_ADCAutoChnage = FALSE;
#ifdef CONFIG_SUPPORT_ESTICKER_INFILE
static UINT8 g_u32StoreModeOpenTimer = 0;
#endif
static PopmsgParam_t stPopupWaitingList[
    PLAYBACK_POPUP_MAX-PLAYBACK_POPUP_NONE];
static UINT32 g_u32OldPopup = PLAYBACK_POPUP_NONE;
static UINT32 g_u32PopupWaitingList = 0;
static UINT32 g_dCurPopup = PLAYBACK_POPUP_NONE;

static bool bSetUnMuteFlag = FALSE;
static bool bSetVIPFINISHFlag = FALSE;
static UINT32 g_u32NoSignalTimer = 0;
static UINT32 g_u32NoSignalSleepTimer = 0;
static UINT8 g_noSignaldebouncetime = NO_SIGNAL_BOUNCE_TIME;
static UINT8 g_u8NotAvailableTimer = 0;
static UINT8 g_u8SignalState = ATV_INVALID_STATUS;
static UINT8 g_ucComeFromAutoSearch = 0;
static UINT8 g_bATVDBInited = FALSE;
static UINT8 g_u8SourceTrastTimer = 0;
static UINT8 g_u8ZappingTimer = 0;
static UINT8 g_u8CheckMTSTimer = 0;
static UINT8 IsAlreadyFirstSetMTS = 0;
static UINT8 g_u8SIF_SCS_OK = 0;
static UINT32 u8CheckMTSCount = 0;
static TVFE_AudioSIFAvailableMode_e LasteAvaiMode = 0;
static UINT8 g_u8CallCMDState = FALSE;
static INT32 g_u32Mutekeydelaytime = 10;
static INT32 g_u32MuteIconHandle = 10;
static INT32 MUTE_KEY_INTERVAL = 10;
#ifdef CONFIG_HDMI_SPD
static INT32 g_SPD_Timer_count = 0;
static INT32 bSPDCheck = 0;
#endif
#ifdef CONFIG_CONFIRM_AUTO_UPGRADE
static int dLastFocusedIndex = 0;
#endif
extern Boolean gUSBUpgradeBinIsSupperBin;
extern UINT8 gIsFactoryResetting;
static bool bAutoScanPassword = FALSE;
#ifdef SUPPORT_AUTO_SOURCE_TEST
static UINT8 g_u8CurSourceIndex = 0;
static UINT32 g_u32TestSignalTimer = 0;
#endif

void SysApp_ATV_Reset_ADCAutoChnageFlag(void)
{
	g_ADCAutoChnage = FALSE;
}

#ifdef CONFIG_SUPPORT_TTX
static UINT8 TTXSubtitleExistFlag = FALSE;

UINT8 ATVApp_GetTTXSubtitleExistFlag(void)
{
	return TTXSubtitleExistFlag;
}
void ATVApp_SetTTXSubtitleExistFlag(UINT8 flag)
{
	TTXSubtitleExistFlag = flag;
}
#endif

#ifdef CONFIG_VCHIP_SUPPORT
static Boolean VchipLockFlag = FALSE;
static Boolean PreVchipLockFlag = FALSE;
static Boolean VchipNeedOpenFlag = FALSE;

Boolean ATVAPP_GetSignalLockStatus(void)
{
    Boolean Lock = FALSE;
    APP_Source_Type_t eSourType = APP_SOURCE_MAX;
    APP_GUIOBJ_Source_GetCurrSource(&eSourType);
    if((eSourType >= APP_SOURCE_SCART) && (eSourType <= APP_SOURCE_YPBPR2))
    {
        AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_SETUP, 0,
            sizeof(APP_SETTING_Setup_t), &(g_stSetupData));
        if((APP_GUIOBJ_ATV_Playback_GetAtvUnLock() == al_false)
            && (ATVAPP_GetVchipLockFlag() == TRUE)
            && (g_stSetupData.Vchip_Lock == 1)
            && (ATVApp_GetSignalState() == ATV_AVAILABLE_SIGNAL))
        {
            Lock = TRUE;
        }
    }
    return Lock;
}
Boolean ATVAPP_GetVchipLockFlag(void)
{
	return VchipLockFlag;
}
#endif
#ifdef CONFIG_HDMI_SUPPORT_MHL
Boolean CbusconnectedFlag = FALSE;

typedef struct _AutoCmdTable_t_
{
	UINT32 dEvent;
	UINT32 dCMD;
}MhlCmdTable_t;

static MhlCmdTable_t MappingTable[] =
{
	{UI_EVENT_ENTER, MHL_RCP_CMD_SELECT},
	{UI_EVENT_UP, MHL_RCP_CMD_UP},
	{UI_EVENT_DOWN, MHL_RCP_CMD_DOWN},
	{UI_EVENT_EXIT, MHL_RCP_CMD_EXIT},
	{UI_EVENT_MENU, MHL_RCP_CMD_ROOT_MENU},
	#if 0
	{UI_EVENT_LEFT, MHL_RCP_CMD_LEFT},
	{UI_EVENT_RIGHT, MHL_RCP_CMD_RIGHT},
	{UI_EVENT_NULL, MHL_RCP_CMD_RIGHT_UP},
	{UI_EVENT_NULL, MHL_RCP_CMD_RIGHT_DOWN},
	{UI_EVENT_NULL, MHL_RCP_CMD_LEFT_UP},
	{UI_EVENT_NULL, MHL_RCP_CMD_LEFT_DOWN},
	{UI_EVENT_NULL, MHL_RCP_CMD_ROOT_MENU},
	{UI_EVENT_NULL, MHL_RCP_CMD_SETUP_MENU},
	{UI_EVENT_NULL, MHL_RCP_CMD_CONTENTS_MENU},
	{UI_EVENT_FAV, MHL_RCP_CMD_FAVORITE_MENU},
	{UI_EVENT_EXIT, MHL_RCP_CMD_EXIT},


	{UI_EVENT_0, MHL_RCP_CMD_NUM_0},
	{UI_EVENT_1, MHL_RCP_CMD_NUM_1},
	{UI_EVENT_2, MHL_RCP_CMD_NUM_2},
	{UI_EVENT_3, MHL_RCP_CMD_NUM_3},
	{UI_EVENT_4, MHL_RCP_CMD_NUM_4},
	{UI_EVENT_5, MHL_RCP_CMD_NUM_5},
	{UI_EVENT_6, MHL_RCP_CMD_NUM_6},
	{UI_EVENT_7, MHL_RCP_CMD_NUM_7},
	{UI_EVENT_8, MHL_RCP_CMD_NUM_8},
	{UI_EVENT_0, MHL_RCP_CMD_NUM_9},
	{UI_EVENT_NULL, MHL_RCP_CMD_DOT},
	{UI_EVENT_ENTER, MHL_RCP_CMD_ENTER},
	{UI_EVENT_NULL, MHL_RCP_CMD_CLEAR},


	{UI_EVENT_CH_UP, MHL_RCP_CMD_CH_UP},
	{UI_EVENT_CH_DN, MHL_RCP_CMD_CH_DOWN},
	{UI_EVENT_RECALL, MHL_RCP_CMD_PRE_CH},
	{UI_EVENT_AUDIO, MHL_RCP_CMD_SOUND_SELECT},
	{UI_EVENT_SOURCE, MHL_RCP_CMD_INPUT_SELECT},
	{UI_EVENT_DISPLAY, MHL_RCP_CMD_SHOW_INFO},
	{UI_EVENT_NULL, MHL_RCP_CMD_HELP},
	{UI_EVENT_PAGE_UP, MHL_RCP_CMD_PAGE_UP},
	{UI_EVENT_PAGE_DN, MHL_RCP_CMD_PAGE_DOWN},


	{UI_EVENT_VOL_UP, MHL_RCP_CMD_VOL_UP},
	{UI_EVENT_VOL_DN, MHL_RCP_CMD_VOL_DOWN},
	{UI_EVENT_MUTE, MHL_RCP_CMD_MUTE},
	{UI_EVENT_PLAY, MHL_RCP_CMD_PLAY},
	{UI_EVENT_STOP, MHL_RCP_CMD_STOP},
	{UI_EVENT_PAUSE, MHL_RCP_CMD_PAUSE},
	{UI_EVENT_REC, MHL_RCP_CMD_RECORD},
	{UI_EVENT_NULL, MHL_RCP_CMD_REWIND},
	{UI_EVENT_NULL, MHL_RCP_CMD_FAST_FWD},
	{UI_EVENT_NULL, MHL_RCP_CMD_EJECT},
	{UI_EVENT_NULL, MHL_RCP_CMD_FWD},
	{UI_EVENT_NULL, MHL_RCP_CMD_BKWD},


	{UI_EVENT_NULL, MHL_RCP_CMD_ANGLE},
	{UI_EVENT_NULL, MHL_RCP_CMD_SUBPICTURE},
	{UI_EVENT_NULL, MHL_RCP_CMD_PLAY_FUNC},
	{UI_EVENT_NULL, MHL_RCP_CMD_PAUSE_PLAY_FUNC},
	{UI_EVENT_NULL, MHL_RCP_CMD_RECORD_FUNC},
	{UI_EVENT_NULL, MHL_RCP_CMD_PAUSE_REC_FUNC},
	{UI_EVENT_NULL, MHL_RCP_CMD_STOP_FUNC},
	{UI_EVENT_NULL, MHL_RCP_CMD_MUTE_FUNC},
	{UI_EVENT_NULL, MHL_RCP_CMD_RESTORE_VOLUME_FUNC},
	{UI_EVENT_NULL, MHL_RCP_CMD_TUNE_FUNC},
	{UI_EVENT_NULL, MHL_RCP_CMD_MEDIA_FUNC},


	{UI_EVENT_NULL, MHL_RCP_CMD_F1_BLUE},
	{UI_EVENT_NULL, MHL_RCP_CMD_F2_RED},
	{UI_EVENT_NULL, MHL_RCP_CMD_F3_GREEN},
	{UI_EVENT_NULL, MHL_RCP_CMD_F4_YELLOW},
	{UI_EVENT_NULL, MHL_RCP_CMD_F5},
	{UI_EVENT_NULL, MHL_RCP_CMD_VS},
	{UI_EVENT_NULL, MHL_RCP_CMD_RSVD},
	#endif
};

static int _ATVApp_GetKeyByCmd(UINT32 cmd, UINT32 *key)
{

	UINT32 i = 0;

	for (i = 0; i < sizeof(MappingTable)/sizeof(MhlCmdTable_t); i++)
	{
		if (cmd == MappingTable[i].dCMD)
		{
			break;
		}
	}

	if (i >= sizeof(MappingTable)/sizeof(MhlCmdTable_t))
	{
		*key = UI_EVENT_NULL;
		return -1;
	}
	else
	{
		*key = MappingTable[i].dEvent;
		g_u8CallCMDState =TRUE;
		return 0;
	}

	return -1;
}
#endif

void ATVApp_SetVIPFINISHFlag(UINT8 flag)
{
	bSetVIPFINISHFlag = flag;
}
UINT32 ATVApp_Get_MTS_AlreadyFlag(void)
{
    return IsAlreadyFirstSetMTS;

}
UINT32 _ATVApp_Get_TotalNumber(void)
{
	UINT32 dTotalNum = 0;
	AL_DB_EDBType_t eDBType = AL_DBTYPE_DVB_ATV;

	if (APP_ProgList_IsExist(eDBType, AL_RECTYPE_ATVSERVICE, ProgListType_Normal) == al_true)
	{
		dTotalNum = APP_ProgList_GetTotalNum(eDBType, AL_RECTYPE_ATVSERVICE, ProgListType_Normal);
	}
	else
	{
		APP_ProgList_Init(eDBType, AL_RECTYPE_ATVSERVICE, AL_DB_INVALIDHDL, ProgListType_Normal, &dTotalNum);
		APP_ProgList_Uninit(eDBType, AL_RECTYPE_ATVSERVICE, ProgListType_Normal);
	}

	return dTotalNum;
}

static void _ATVAPP_ShowPopup(ATV_AppPopMsgType_t ePopType)
{
    PopmsgParam_t stPopup;

    memset(&stPopup, 0x0, sizeof(PopmsgParam_t));

    switch (ePopType)
    {
        case ATV_APP_POP_MSG_INVALID_INPUT:
            stPopup.eType = POPMSG_TYPE_PROMPT;
            stPopup.u16Exitkeys =  POPMSG_EXIT_ANY_KEY;
            stPopup.u16ReturnType = GUI_OBJECT_POST_EVENT | GUI_OBJECT_EVENT_BYPASS;
            stPopup.extend.stPrompt.ePromptType = POPMSG_PROMPT_INVALID_INPUT;
            stPopup.extend.stPrompt.iTimeout = 2;
            break;
        case ATV_APP_POP_MSG_NOT_AVAILABLE:
            stPopup.eType = POPMSG_TYPE_PROMPT;
            stPopup.u16Exitkeys =  POPMSG_EXIT_KEY_NONE;
            stPopup.u16ReturnType = GUI_OBJECT_NO_POST_ACTION;
            stPopup.extend.stPrompt.ePromptType = POPMSG_PROMPT_NOT_AVAILABLE;
            stPopup.extend.stPrompt.iTimeout = 2;
            break;
        case ATV_APP_POP_MSG_NOT_SUPPORT_MODE:
            stPopup.eType = POPMSG_TYPE_PROMPT;
            stPopup.u16Exitkeys =  POPMSG_EXIT_KEY_NONE;
            stPopup.u16ReturnType = GUI_OBJECT_NO_POST_ACTION;
            stPopup.extend.stPrompt.ePromptType = PLAYBACK_POPUP_MSG_NOT_SUPPORT_MODE;
            break;
        case ATV_APP_POP_MSG_CHECKPWD:
            stPopup.eType = POPMSG_TYPE_PWD;
            stPopup.u16ReturnType = GUI_OBJECT_EVENT_BYPASS ;
            stPopup.extend.stPwd.ePwdType = PLAYBACK_POPUP_PWD_LOCKED;
            break;
        case ATV_APP_POP_MSG_NO_SIGNAL:
            stPopup.eType = POPMSG_TYPE_PROMPT;
            stPopup.u16Exitkeys =  POPMSG_EXIT_KEY_NONE;
            stPopup.u16ReturnType = GUI_OBJECT_EVENT_BYPASS;
            stPopup.extend.stPrompt.ePromptType = PLAYBACK_POPUP_MSG_NO_SIGNAL;
            break;
        case ATV_APP_POP_MSG_CHECK_ANTENNA_INPUT:
            stPopup.eType = POPMSG_TYPE_PROMPT;
            stPopup.u16Exitkeys =  POPMSG_EXIT_KEY_NONE;
            stPopup.u16ReturnType = GUI_OBJECT_EVENT_BYPASS;
            stPopup.extend.stPrompt.ePromptType = PLAYBACK_POPUP_MSG_CHECK_ANTENNA_INPUT;
            break;
        case ATV_APP_POP_MSG_DB_SAVE_IN_PROGRESS:
            stPopup.eType = POPMSG_TYPE_PROMPT;
            stPopup.u16Exitkeys = POPMSG_EXIT_CHN_UP_DOWN | POPMSG_EXIT_EPG | POPMSG_EXIT_MENU | POPMSG_EXIT_SOURCE;
            stPopup.u16ReturnType = GUI_OBJECT_POST_EVENT | GUI_OBJECT_EVENT_BYPASS;
            stPopup.extend.stPrompt.ePromptType = POPMSG_PROMPT_SAVING_DATA;
            stPopup.extend.stPrompt.iTimeout = 20;
            break;
        case ATV_APP_POP_MSG_CHANNEL_DELETED:
            stPopup.eType = POPMSG_TYPE_PROMPT;
            stPopup.u16Exitkeys =  POPMSG_EXIT_ANY_KEY;
            stPopup.u16ReturnType = GUI_OBJECT_POST_EVENT | GUI_OBJECT_EVENT_BYPASS;
            stPopup.extend.stPrompt.ePromptType = POPMSG_PROMPT_CHANNEL_DELETED;
            stPopup.extend.stPrompt.iTimeout = 2;
            break;
        case ATV_APP_POP_MSG_AUTO_ADJUST:
            stPopup.eType = POPMSG_TYPE_PROMPT;
            stPopup.u16Exitkeys =  POPMSG_EXIT_ANY_KEY;
            stPopup.u16ReturnType = GUI_OBJECT_POST_EVENT | GUI_OBJECT_EVENT_BYPASS;
            stPopup.extend.stPrompt.ePromptType = POPMSG_PROMPT_AUTO_ADJUST;
            stPopup.extend.stPrompt.iTimeout = 2;
            break;

        case ATV_APP_POP_MSG_DATABASE_EMPTY:
            stPopup.eType = POPMSG_TYPE_PROMPT;
            stPopup.u16Exitkeys =  POPMSG_EXIT_KEY_NONE;
            stPopup.u16ReturnType = GUI_OBJECT_EVENT_BYPASS;
            stPopup.extend.stPrompt.ePromptType = PLAYBACK_POPUP_MSG_DATABASE_EMPTY;
            break;
        case ATV_APP_POP_MSG_INVALID_CHANNEL_NUMBER:
            stPopup.eType = POPMSG_TYPE_PROMPT;
            stPopup.u16Exitkeys =  POPMSG_EXIT_ANY_KEY;
            stPopup.u16ReturnType = GUI_OBJECT_POST_EVENT | GUI_OBJECT_EVENT_BYPASS;
            stPopup.extend.stPrompt.ePromptType = POPMSG_PROMPT_INVALID_CHANNEL_NUMBER;
            stPopup.extend.stPrompt.iTimeout = 2;
            break;

#ifdef CONFIG_SUPPORT_TTX
        case ATV_APP_POP_MSG_NO_TTX:
            stPopup.eType = POPMSG_TYPE_PROMPT;
            stPopup.u16Exitkeys =  POPMSG_EXIT_KEY_NONE;
            stPopup.u16ReturnType = GUI_OBJECT_NO_POST_ACTION;
            stPopup.extend.stPrompt.ePromptType = POPMSG_PROMPT_NO_TTX;
            stPopup.extend.stPrompt.iTimeout = 2;
            break;
#endif
        case ATV_APP_POP_MSG_KEYLOCK:
            stPopup.eType = POPMSG_TYPE_PROMPT;
            stPopup.u16Exitkeys =  POPMSG_EXIT_EXIT;
            stPopup.u16ReturnType = GUI_OBJECT_POST_EVENT;
            stPopup.extend.stPrompt.ePromptType = POPMSG_PROMPT_KEYLOCK;
            stPopup.extend.stPrompt.iTimeout = 2;
            break;
        case ATV_APP_POP_MSG_OVERMAXVOLUME:
            stPopup.eType = POPMSG_TYPE_PROMPT;
            stPopup.u16Exitkeys =  POPMSG_EXIT_EXIT;
            stPopup.u16ReturnType = GUI_OBJECT_POST_EVENT;
            stPopup.extend.stPrompt.ePromptType = POPMSG_PROMPT_OVER_MAXVOLUME;
            stPopup.extend.stPrompt.iTimeout = 2;
            break;
		case ATV_APP_POP_MSG_HDCP_UPGRADE_SUCC:
			stPopup.eType = POPMSG_TYPE_PROMPT;
			stPopup.u16ReturnType = GUI_OBJECT_EVENT_BYPASS;
			stPopup.extend.stPrompt.ePromptType = POPMSG_PROMP_HDCP_UPGRADE_SUCC;
			stPopup.extend.stPrompt.iTimeout = 8;
			break;
		case ATV_APP_POP_MSG_HDCP_UPGRADE_FAILE:
			stPopup.eType = POPMSG_TYPE_PROMPT;
			stPopup.u16ReturnType = GUI_OBJECT_EVENT_BYPASS;
			stPopup.extend.stPrompt.ePromptType = POPMSG_PROMP_HDCP_UPGRADE_FAILED;
			stPopup.extend.stPrompt.iTimeout = 8;
			break;

		case ATV_APP_POP_MSG_CI_PASS_HDCP_PASS:
			stPopup.eType = POPMSG_TYPE_PROMPT;
			stPopup.u16ReturnType = GUI_OBJECT_EVENT_BYPASS;
			stPopup.extend.stPrompt.ePromptType = POPMSG_PROMP_CI_PASS_HDCP_PASS;
			stPopup.extend.stPrompt.iTimeout = 8;
			break;
		case ATV_APP_POP_MSG_CI_PASS_HDCP_FAIL:
			stPopup.eType = POPMSG_TYPE_PROMPT;
			stPopup.u16ReturnType = GUI_OBJECT_EVENT_BYPASS;
			stPopup.extend.stPrompt.ePromptType = POPMSG_PROMP_CI_PASS_HDCP_FAIL;
			stPopup.extend.stPrompt.iTimeout = 8;
			break;
		case ATV_APP_POP_MSG_CI_FAIL_HDCP_PASS:
			stPopup.eType = POPMSG_TYPE_PROMPT;
			stPopup.u16ReturnType = GUI_OBJECT_EVENT_BYPASS;
			stPopup.extend.stPrompt.ePromptType = POPMSG_PROMP_CI_FAIL_HDCP_PASS;
			stPopup.extend.stPrompt.iTimeout = 8;
			break;
		case ATV_APP_POP_MSG_CI_FAIL_HDCP_FAIL:
			stPopup.eType = POPMSG_TYPE_PROMPT;
			stPopup.u16ReturnType = GUI_OBJECT_EVENT_BYPASS;
			stPopup.extend.stPrompt.ePromptType = POPMSG_PROMP_CI_FAIL_HDCP_FAIL;
			stPopup.extend.stPrompt.iTimeout = 8;
			break;

        default:
            return;
    }

    if (stAtvInst.bAppState == SYSTEM_IDLE)
    {
        return;
    }
	#ifdef CONFIG_SMART_MODULE_SUPPORT
	APP_Source_Type_t eSourceType = APP_SOURCE_MAX;
	APP_GUIOBJ_Source_GetCurrSource(&eSourceType);
	if((APP_SOURCE_HDMI + CONFIG_HDMI_SMART_PORT) == eSourceType)
	#endif
    ATVApp_SchedulePopup(stPopup);
}

static INT32 _ATVApp_CheckPopupDisplay(void)
{
    UINT32 dCheckFlag;

    if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_POPMSG))
    {
        for (dCheckFlag = PLAYBACK_POPUP_MAX - 1;
             dCheckFlag > PLAYBACK_POPUP_NONE; dCheckFlag--)
        {
            if (g_u32PopupWaitingList & (1 << (dCheckFlag - PLAYBACK_POPUP_NONE)))
            {
                ATVApp_SchedulePopup(stPopupWaitingList[dCheckFlag-PLAYBACK_POPUP_NONE]);
                break;
            }
        }
    }
    return 0;
}

static INT32 _ATVApp_HidePopupDisplay(void)
{
    APP_MenuMgr_SetMsgPopup(FALSE);
    g_u32OldPopup = PLAYBACK_POPUP_NONE;

    if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_POPMSG))
    {
        SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_POPMSG);
    }

    g_dCurPopup = PLAYBACK_POPUP_NONE;

    if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_INPUTINFO))
    {
        SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_INPUTINFO);
    }

    return 0;
}

static INT32 _ATVApp_ResetPopup_Channel(void)
{
    ATVApp_ClosePopup(PLAYBACK_POPUP_MSG_NOT_SUPPORT_MODE, UI_EVENT_NULL);
    ATVApp_ClosePopup(PLAYBACK_POPUP_MSG_NO_SIGNAL, UI_EVENT_NULL);
    ATVApp_ClosePopup(PLAYBACK_POPUP_MSG_DATABASE_EMPTY, UI_EVENT_NULL);
    ATVApp_ClosePopup(PLAYBACK_POPUP_PWD_LOCKED, UI_EVENT_NULL);

    return SP_SUCCESS;
}
static INT32 _ATVApp_CloseAllMenu(void)
{
    UINT32 u32GuiObj = 0;

    _ATVApp_HidePopupDisplay();

    for (u32GuiObj = 0; u32GuiObj < ATV_GUIOBJ_MAX; u32GuiObj++)
    {
        if (u32GuiObj == APP_GUIOBJ_MUTE
#ifdef CONFIG_SUPPORT_ESTICKER_INFILE
            || u32GuiObj == APP_GUIOBJ_ESTICKER
#endif
#ifdef CONFIG_SUPPORT_ESTICKER_NEW
			|| u32GuiObj == APP_GUIOBJ_ESTICKER_NEW
#endif

            || u32GuiObj == ATV_GUIOBJ_FREEZE
            || u32GuiObj == ATV_GUIOBJ_POPMSG
#ifdef CONFIG_SUPPORT_SHOW_KEYPADMENU
			|| u32GuiObj == APP_GUIOBJ_KEYPADMENU
#endif
#if defined(CONFIG_SUPPORT_NES_GAME)|| defined(CONFIG_OSD_GAME_SUPPORT)
            || u32GuiObj == APP_GUIOBJ_GAMEMENU
#endif
#ifdef CONFIG_OSD_GAME_SUPPORT
            || u32GuiObj == APP_GUIOBJ_OSDGAME
#endif
#ifdef CONFIG_SUPPORT_NES_GAME
            || u32GuiObj == APP_GUIOBJ_NESGAME_RUNNING
#endif
#ifdef CONFIG_CC_SUPPORT
            || u32GuiObj == ATV_GUIOBJ_CC
#endif
			)
        {
            continue;
        }

        if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, u32GuiObj))
        {
            SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, u32GuiObj);
        }
    }

    return SP_SUCCESS;
}

/*****************************************************************************
** FUNCTION : _ATVApp_Exit_All_Menu
**
** DESCRIPTION :
**				exit all menu
**
** PARAMETERS :
**				i32Type		1:exit from atuo scan done 0:normal
**
** RETURN VALUES:
**				void
**
*****************************************************************************/
static void _ATVApp_Exit_All_Menu(INT32 i32Type)
{
    if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_POPMSG))
    {
        SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_POPMSG);
    }

    if (APP_MenuMgr_Exist_Main_Menu())
    {
        APP_MenuMgr_Exit_Main_Menu();
    }

    if (APP_MenuMgr_Exist_Factory_Menu())
    {
        APP_MenuMgr_Exit_Factory_Menu();
    }

    if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_SOURCE))
    {
        SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, APP_GUIOBJ_SOURCE);
    }

    if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_SOURCE_CEC))
    {
        SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, APP_GUIOBJ_SOURCE_CEC);
    }
#if defined(CONFIG_SUPPORT_NES_GAME) || defined(CONFIG_OSD_GAME_SUPPORT)
	if(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_GAMEMENU))
	{
        SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, APP_GUIOBJ_GAMEMENU);
	}
#endif
    if (g_u32OldPopup == PLAYBACK_POPUP_NONE)
    {
        _ATVApp_CloseAllMenu();
    }
    APP_Source_Type_t eSourType = APP_SOURCE_MAX;
    APP_GUIOBJ_Source_GetCurrSource(&eSourType);

    switch (eSourType)
    {
        default:
            /*have no signal*/
            if ((i32Type == 0)
			  &&(g_u8SignalState == ATV_NO_SIGNAL)
			  &&(g_u32NoSignalTimer >= NO_SIGNAL_BOUNCE_TIME))
            {
                if (!ATVApp_IsPopupExist(PLAYBACK_POPUP_MSG_NO_SIGNAL))
                {
                    SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_ATV,
                                  	APP_ATV_GLOBAL_EVENT_POPMSG_NO_SIGNAL, 0);
                }
            }
            break;
    }
}

#if 0
static bool _ATVAPP_CheckDatabaseEmpty(void)
{
    al_uint32 u32TotalNum = 0;

    AL_DB_GetRecordsTotalNum(AL_DBTYPE_DVB_ATV, AL_RECTYPE_ATVSERVICE, &u32TotalNum);

    /*
     * if current have some channel, but all of them are `skip'
     * is it empty?
     */
    if (u32TotalNum == 0)
    {
        return TRUE;
    }
    else
    {
        return FALSE;
    }
}
#endif

/*****************************************************************************
** FUNCTION : ATVApp_PCAutoTune
**
** DESCRIPTION :
**				Do PC AutoTune calibration
**
** PARAMETERS :
**				bShowPopMenuFlag	TRUE : ie. enter IR Hot-Key, so need do _ATVAPP_ShowPopup() & MID_TVFE_DoAutoTune()
**									FALSE : ie. PC timing change, so needn't  do _ATVAPP_ShowPopup() & MID_TVFE_DoAutoTune()
**
** RETURN VALUES:
**				0 : Success
**				1 : Fail
**
*****************************************************************************/
INT32 ATVApp_PCAutoTune(bool bShowPopMenuFlag)
{
	PLF_VideoID_t eResolution;
	PCSetup_Data_t PC_Tempvalue;

	if (MID_DTV_SUCCESS != MID_TVFE_GetCurrentVideoInfo(NULL, &eResolution))
	{
		return 1;
	}
	if (eResolution == PLF_VIDEO_TIMING_ID_NO_SIGNAL
		|| eResolution == PLF_VIDEO_TIMING_ID_UNKNOW_FORMAT)
	{
		return 1;
	}

	Boolean UserFlag;
	UINT16 wFIFOTblIdx;
	UINT32 u32AdjustIdx = 0;

	u32AdjustIdx = APP_GUIOBJ_Adjust_GetType();
	PCAutoTune_FIFOTable_Search(eResolution, &wFIFOTblIdx, &UserFlag);
	#if 0 //richie remark, Always save pc auto tune information in S2 chip, For CVT IR Hot-Key request need do AutoTune calibration
	if(UserFlag)
	{
		return 1;
	}
	#endif

	if(bShowPopMenuFlag && !APP_MenuMgr_Exist_Factory_Menu())
	{
		_ATVAPP_ShowPopup(ATV_APP_POP_MSG_AUTO_ADJUST);
	}

	if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV,APP_GUIOBJ_ADJUST)
		&& (u32AdjustIdx >= ADJUST_PC_HPOSITION)
		&& (u32AdjustIdx <= ADJUST_PC_PHASE))
	{
		SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV,APP_GUIOBJ_ADJUST);
	}

	if (bShowPopMenuFlag == TRUE) //For CVT IR Hot-Key request need do AutoTune calibration, but for PC timing change needn't do AutoTune calibration
	{
		MID_TVFE_DoAutoTune(1);
	}

	if (eResolution != 0)
	{
		if (wFIFOTblIdx<MAX_NUM_PC) //For New PC timing or Redo AutoTune calibartion, need update g_stSysInfoData structure to default value
		{
			/* save pc auto tune information */
			Cmd_AdcGetAdcPhase(&PC_Tempvalue.PCPhase);
			APP_GUIOBJ_ATV_PCSetup_ResetPCSetupData();
			PC_Tempvalue.PCHPosition = 0;
			PC_Tempvalue.PCVPosition = 0;
			PC_Tempvalue.PCPhase =
				APP_GUIOBJ_ATV_PCSetup_PhaseMappingtoOSDValue(PC_Tempvalue.PCPhase);
			PC_Tempvalue.PCClock = 0;

			g_stSysInfoData.stPC_AutoTune[wFIFOTblIdx].i8HpositionOffset = PC_Tempvalue.PCHPosition;
			g_stSysInfoData.stPC_AutoTune[wFIFOTblIdx].i8VpositionOffset = PC_Tempvalue.PCVPosition;
			g_stSysInfoData.stPC_AutoTune[wFIFOTblIdx].i8ClockOffset = PC_Tempvalue.PCClock;
			g_stSysInfoData.stPC_AutoTune[wFIFOTblIdx].Phase = PC_Tempvalue.PCPhase;
			//AutoTune OK
			AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_SYSINFO,
							 ITEM_OFFSET(APP_SETTING_SystemInfo_t, stPC_AutoTune[wFIFOTblIdx]),
							 sizeof(g_stSysInfoData.stPC_AutoTune[wFIFOTblIdx]),
							 &(g_stSysInfoData.stPC_AutoTune[wFIFOTblIdx]));

			PCAutoTune_FIFOTable_Update(eResolution, wFIFOTblIdx);
		}
	}

    return 0;
}


static INT32 _ATVApp_SetMuteProcess(UINT8 bMuteFlag)
{
    atv_printf("%s, %d bMuteFlag = %d\n", __FUNCTION__, __LINE__, bMuteFlag);
    //Boolean bFreezeFlag = FALSE;
    APP_Source_Type_t eSourType = APP_SOURCE_MAX;

    APP_GUIOBJ_Source_GetCurrSource(&eSourType);

    if (bMuteFlag)
    {
        //if (AL_CS_IsStop())
        {
            AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_SETUP, 0,
                            sizeof(APP_SETTING_Setup_t), &(g_stSetupData));

            if (ATVApp_GetSignalState() == ATV_AVAILABLE_SIGNAL)
            {
                APP_Audio_SetMute(TRUE, TRUE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
                APP_Video_SetMute(TRUE, TRUE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
            }
            else
            {
                if ((g_stSetupData.BlueScreen == APP_SWITCH_ON))//&&(eSourType!= APP_SOURCE_PC))
                {
                    if (ATVApp_CheckProgramType(FALSE) == SP_SUCCESS)
                    {
                        APP_Audio_SetMute(TRUE, TRUE, APP_MUTE_MODE_NO_SIGNALE, eSourType);
                        MID_DISP_DTVSetVideoMute(0,0,255);
                        APP_SCARTOUT_SetVideoMute(eSourType, FALSE, FALSE);
                    }
                }
                else
                {
                    APP_Audio_SetMute(TRUE, TRUE, APP_MUTE_MODE_NO_SIGNALE, eSourType);
                    APP_Video_SetMute(TRUE, TRUE, APP_MUTE_MODE_NO_SIGNALE, eSourType);
                }
            }

            if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_FREEZE))
            {
                SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_FREEZE);
            }
        }
    }
    else
    {
        /*close no signal popmessage*/
        g_u32NoSignalTimer = 0;
		g_u32NoSignalSleepTimer = 0;
        /*close not available popmessage*/
        g_u8NotAvailableTimer = 0;
        bSetUnMuteFlag = TRUE;
    }
    return 0;
}

static int _ATVApp_Zapping(AL_RecHandle_t hNextProgHdl, al_bool bForce)
{
    APP_Source_Type_t eSourType = APP_SOURCE_MAX;
    Boolean bFreezeFlag = FALSE;

#ifdef CONFIG_SUPPORT_TTX
    if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_TTXCLOCK))
    {
        SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_TTXCLOCK);
    }
#endif
    if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_FREEZE))
    {
        SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_FREEZE);
    }
    if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_POPMSG))
    {
        SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_POPMSG);
    }
    MID_DISP_DTVGetPause(&bFreezeFlag);
    if (bFreezeFlag)
    {
        MID_DISP_DTVSetPause(FALSE);
    }
    if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_ADJUST))
    {
        SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, APP_GUIOBJ_ADJUST);
    }
#ifdef SUPPORT_CEC_TV
    if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_AMPLIFIERVOLUME))
    {
        SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, APP_GUIOBJ_AMPLIFIERVOLUME);
    }
#endif
    if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_BANNER))
    {
        SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, APP_GUIOBJ_BANNER);
    }

    APP_GUIOBJ_Source_GetCurrSource(&eSourType);    

    _ATVApp_CheckPopupDisplay();

    return SP_SUCCESS;
}

#if (defined(SUPPORT_FACTORY_AUTO_TEST)||defined(SUPPORT_FACTORY_AUTO_TEST_MODE2)||defined(SUPPORT_FACTORY_AUTO_TEST_MODE2_EXTEND))
#ifndef CONFIG_SUPPORT_ATV_SCAN_NTSCM_PALM_N
static void _ATVApp_PrestoreProgram(void)
{
	al_uint8 ucGetChannelName[DB_ATV_MAX_CHNAME_LEN];
	AL_ServiceDetail_t 	stAtvInfo;
	AL_RecHandle_t stHdl;

	AL_FW_SwitchDBModule(AL_DBTYPE_DVB_ATV);
	AL_DB_Reset(AL_DBTYPE_DVB_ATV, al_true);

	stAtvInfo.stAnalogServ.colorSystem = APP_OSD_COLOR_SYSTEM_PAL;
	stAtvInfo.stAnalogServ.soundSystem = ANA_SCAN_AUDIO_STD_NICAMI;

	stAtvInfo.stAnalogServ.u32Freq = 48250000;
	stAtvInfo.stAnalogServ.skip = 0;
	stAtvInfo.stAnalogServ.del = 0;
	stAtvInfo.stAnalogServ.AFC = 1;
	stAtvInfo.stAnalogServ.inuse = 1;

	memset(ucGetChannelName, 0x0, DB_ATV_MAX_CHNAME_LEN);
	ucGetChannelName[0] = 'C';
	ucGetChannelName[1] = 'H';
	ucGetChannelName[2] = '1';
	memcpy(stAtvInfo.stAnalogServ.szChannelName,
		ucGetChannelName,
		sizeof(stAtvInfo.stAnalogServ.szChannelName));

	stAtvInfo.stAnalogServ.multiAudio = TVFE_AUDIO_SIF_MODE_ERR;
	AL_DB_AddRecord(AL_DBTYPE_DVB_ATV,
		AL_RECTYPE_ATVSERVICE, &stAtvInfo, CDBI_INVALID_HDL, &stHdl);

	stAtvInfo.stAnalogServ.colorSystem = APP_OSD_COLOR_SYSTEM_SECAM;
	stAtvInfo.stAnalogServ.soundSystem = ANA_SCAN_AUDIO_STD_NICAMBG;

	stAtvInfo.stAnalogServ.u32Freq = 487250000;
	stAtvInfo.stAnalogServ.skip = 0;
	stAtvInfo.stAnalogServ.del = 0;
	stAtvInfo.stAnalogServ.AFC = 1;
	stAtvInfo.stAnalogServ.inuse = 1;

	memset(ucGetChannelName, 0x0, DB_ATV_MAX_CHNAME_LEN);
	ucGetChannelName[0] = 'C';
	ucGetChannelName[1] = 'H';
	ucGetChannelName[2] = '2';
	memcpy(stAtvInfo.stAnalogServ.szChannelName,
		ucGetChannelName,
		sizeof(stAtvInfo.stAnalogServ.szChannelName));

	stAtvInfo.stAnalogServ.multiAudio = TVFE_AUDIO_SIF_MODE_ERR;
	AL_DB_AddRecord(AL_DBTYPE_DVB_ATV,
		AL_RECTYPE_ATVSERVICE, &stAtvInfo, CDBI_INVALID_HDL, &stHdl);
}
#else
static void _ATVApp_PrestoreProgram(void)
{
	al_uint8 ucGetChannelName[DB_ATV_MAX_CHNAME_LEN];
	AL_ServiceDetail_t 	stAtvInfo;
	AL_RecHandle_t stHdl;

	AL_FW_SwitchDBModule(AL_DBTYPE_DVB_ATV);
	AL_DB_Reset(AL_DBTYPE_DVB_ATV, al_true);

	stAtvInfo.stAnalogServ.colorSystem = APP_OSD_COLOR_SYSTEM_NTSC358;
	stAtvInfo.stAnalogServ.soundSystem = APP_OSD_SOUND_SYSTEM_M;

	stAtvInfo.stAnalogServ.u32Freq = 187250000;
	stAtvInfo.stAnalogServ.skip = 0;
	stAtvInfo.stAnalogServ.del = 0;
	stAtvInfo.stAnalogServ.AFC = 1;
	stAtvInfo.stAnalogServ.inuse = 1;
    if (APP_GUIOBJ_Source_GetCurATVType() == ATV_TYPE_AIR)
    {
        stAtvInfo.stAnalogServ.tvtype = 0;
    }
    else
    {
        stAtvInfo.stAnalogServ.tvtype = 1;
    }
    stAtvInfo.stAnalogServ.available = 1;

	memset(ucGetChannelName, 0x0, DB_ATV_MAX_CHNAME_LEN);
	ucGetChannelName[0] = 'C';
	ucGetChannelName[1] = 'H';
	ucGetChannelName[2] = '1';
	memcpy(stAtvInfo.stAnalogServ.szChannelName,
		ucGetChannelName,
		sizeof(stAtvInfo.stAnalogServ.szChannelName));

	stAtvInfo.stAnalogServ.multiAudio = TVFE_AUDIO_SIF_MODE_ERR;

    APP_Database_GetHandleByIndex(AL_DBTYPE_DVB_ATV, AL_RECTYPE_ATVSERVICE, 0, &stHdl);
	AL_DB_UpdateDetail(stHdl, &stAtvInfo.stAnalogServ);
}

#endif
#endif

static void _ATVApp_sw_init(void)
{
    AL_FW_Init(FW_ATV_INIT, NULL, NULL);
#ifdef CONFIG_ATV_SUPPORT
    if (ATVApp_GetDBInitState() == FALSE)
    {
        ATVApp_DBInit();
    }
#endif
    AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FACTUSER,0,
        sizeof(APP_SETTING_FactoryUser_t), &g_stFactoryUserData);
    Cmd_SetCVD2FactoryValue((CVD2VideoDecoderSetting_t *)&g_stFactoryUserData.FM_CVD2Setting);
#if (defined(SUPPORT_FACTORY_AUTO_TEST)||defined(SUPPORT_FACTORY_AUTO_TEST_MODE2)||defined(SUPPORT_FACTORY_AUTO_TEST_MODE2_EXTEND))
	if(APP_Factory_GetAutoTestOnOff() == TRUE)
	{
		_ATVApp_PrestoreProgram();
		AL_DB_Sync(AL_DBTYPE_DVB_ATV, al_true);
	}
	else
#endif
	{
		APP_Factory_HotelModePowerOnChan();
	#ifdef CONFIG_ATV_SUPPORT
	#ifdef NUMBER_KEY_WAKEUP_CHANNEL

	#ifdef CONFIG_SUPPORT_ATV_SCAN_NTSCM_PALM_N
        app_scan_table_info_st scan_info;
	#endif

	    AL_RecHandle_t hServHdl = AL_DB_INVALIDHDL;
		UINT32 bChannel = 0;
		extern UINT8 bNumberKeyPowerOn;
		extern UINT32 dPowerOnNumberKey;

		if (bNumberKeyPowerOn == TRUE)
		{
			bNumberKeyPowerOn = FALSE;
			if ((dPowerOnNumberKey <= UI_EVENT_0) || (UI_EVENT_9 < dPowerOnNumberKey))
			{
				bChannel = 0;
			}
			else
			{
				bChannel = dPowerOnNumberKey - UI_EVENT_0 - 1;
			}
		    #ifndef CONFIG_SUPPORT_ATV_SCAN_NTSCM_PALM_N
	        APP_Database_GetHandleByIndex(AL_DBTYPE_DVB_ATV, AL_RECTYPE_ATVSERVICE, bChannel, &hServHdl);
	       	if (hServHdl != AL_DB_INVALIDHDL)
			{
	            g_stVariationalData.ATV_TVHdl = hServHdl;
	            AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_VARIATIONAL,
	                             ITEM_OFFSET(APP_SETTING_Variational_t, ATV_TVHdl),
	                             sizeof(g_stVariationalData.ATV_TVHdl), &(g_stVariationalData.ATV_TVHdl));
	            AL_Setting_Store(APP_Data_UserSetting_Handle(), SYS_SET_ID_VARIATIONAL,
	                             ITEM_OFFSET(APP_SETTING_Variational_t, ATV_TVHdl),
	                             sizeof(g_stVariationalData.ATV_TVHdl));
	       	}
	       	#else
			atv_type_t atv_type = APP_GUIOBJ_Source_GetCurATVType();
            APP_Scan_API_GetTableInfo(atv_type, &scan_info);
	        APP_Scan_API_GetTableInfo(ATV_TYPE_AIR, &air_scan_info);
	        if ((bChannel > scan_info.u32MaxChNo) || (bChannel < scan_info.u32MinChNo))
	        {
				bChannel = scan_info.u32MinChNo;
	        }
	        if (atv_type == ATV_TYPE_AIR)
	        {
	            APP_Database_GetHandleByIndex(AL_DBTYPE_DVB_ATV, AL_RECTYPE_ATVSERVICE, bChannel - scan_info.u32MinChNo, &hServHdl);
	           	if (hServHdl != AL_DB_INVALIDHDL)
				{
	                g_stVariationalData.ATV_TVHdl = hServHdl;
	                AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_VARIATIONAL,
	                                 ITEM_OFFSET(APP_SETTING_Variational_t, ATV_TVHdl),
	                                 sizeof(g_stVariationalData.ATV_TVHdl), &(g_stVariationalData.ATV_TVHdl));
	                AL_Setting_Store(APP_Data_UserSetting_Handle(), SYS_SET_ID_VARIATIONAL,
	                                 ITEM_OFFSET(APP_SETTING_Variational_t, ATV_TVHdl),
	                                 sizeof(g_stVariationalData.ATV_TVHdl));
	           	}
	        }
	        else
	        {
	            APP_Database_GetHandleByIndex(AL_DBTYPE_DVB_ATV, AL_RECTYPE_ATVSERVICE, bChannel - scan_info.u32MinChNo+air_scan_info.u32ScanTableLen, &hServHdl);
	           	if (hServHdl != AL_DB_INVALIDHDL)
				{
	                g_stVariationalData.CATV_TVHdl = hServHdl;
	                AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_VARIATIONAL,
	                                 ITEM_OFFSET(APP_SETTING_Variational_t, CATV_TVHdl),
	                                 sizeof(g_stVariationalData.CATV_TVHdl), &(g_stVariationalData.CATV_TVHdl));
	                AL_Setting_Store(APP_Data_UserSetting_Handle(), SYS_SET_ID_VARIATIONAL,
	                                 ITEM_OFFSET(APP_SETTING_Variational_t, CATV_TVHdl),
	                                 sizeof(g_stVariationalData.CATV_TVHdl));
	           	}
	        }
	       	#endif
		}
	#endif
	#endif
	}
}

static void _ATVApp_main_program(void *data)
{
    _ATVApp_sw_init();
}

static INT32 _ATVApp_OnCreate(void **ppPrivateData)
{
    atv_printf(" %s is called.\n", __FUNCTION__);

    _ATVApp_main_program(NULL);
    AtvPrivateData_t *pAtvPrivateData =
        (AtvPrivateData_t *) GL_MemAlloc(sizeof(AtvPrivateData_t));
	
	if(pAtvPrivateData != NULL)
	{
		memset(pAtvPrivateData, 0x00, sizeof(AtvPrivateData_t));
		pAtvPrivateData->dUserData = 0;
	}
    (*ppPrivateData) = (void *)pAtvPrivateData;

    stAtvInst.bAppState = SYSTEM_IDLE;
    return 0;
}

static INT32 _ATVApp_OnDestroy(void **ppPrivateData)
{
    atv_printf(" %s is called.\n", __FUNCTION__);
    SYSAPP_GOBJ_FinalizeGUIObject(SYS_APP_ATV);
    GL_MemFree((*ppPrivateData));
    (*ppPrivateData) = NULL;
    return 0;
}

static INT32 _ATVApp_OnRun(void *pPrivateData, UINT32 dParam)
{
    atv_printf(" %s is called.\n", __FUNCTION__);
    AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_SYSINFO, 0,
                    sizeof(APP_SETTING_SystemInfo_t), &(g_stSysInfoData));
    AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_USERINFO, 0,
                    sizeof(APP_SETTING_UserInfo_t), &(g_stUserInfoData));
    stAtvInst.bAppState = SYSTEM_RUNNING;
    atv_printf(" ATV state is %d,dParam=%x.\n", stAtvInst.bAppState, dParam);

    if (dParam == AUTOSEARCH_FROM_ALLTUNE)
    {
        g_ucComeFromAutoSearch = 1;

    }

    APP_GUIOBJ_PopMs_SetCloseFun(ATVApp_ClosePopup);
    APP_GuiMgr_Set_Menu() ;
    APP_GuiMgr_SwitchShareMenu(SYS_APP_ATV);

    SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_ATV,
                   	APP_ATV_GLOBAL_EVENT_ATV_ONRUN | PASS_TO_SYSAPP, TRUE);
	APP_Video_Init();
    return 0;
}


static INT32 _ATVApp_OnTerminate(void *pPrivateData, UINT32 dParamter)
{
    atv_printf("[ATV] %s is called.\n", __FUNCTION__);
    if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_FREEZE))
    {
        SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_FREEZE);
    }

    if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_MUTE))
    {
        SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, APP_GUIOBJ_MUTE);
    }
	APP_Video_Uninit();
    SYSAPP_GOBJ_FinalizeGUIObject(SYS_APP_ATV);

    g_u32OldPopup = PLAYBACK_POPUP_NONE;

    APP_Video_app_UnInitDvbOSD2();
	#ifdef CONFIG_SCARTOUT_IN_AVC
	APP_Audio_SetMute(TRUE, FALSE, APP_MUTE_MODE_STATEMAX, APP_SOURCE_ATV);
	#else
	APP_Audio_SetMute(TRUE, TRUE, APP_MUTE_MODE_STATEMAX, APP_SOURCE_ATV);
	#endif
	APP_Video_SetMute(TRUE, FALSE, APP_MUTE_MODE_STATEMAX, APP_SOURCE_MAX);
    stAtvInst.bAppState = SYSTEM_IDLE;
    return 0;
}

static INT32 _ATVApp_OnTimerUpdate(void *pPrivateData)
{
    APP_Source_Type_t eSourType = APP_SOURCE_MAX;
    INT32 dFocusedIndex;
	/*Delay the mute key sending to AMP*/
	if((0 <= g_u32Mutekeydelaytime) && (g_u32Mutekeydelaytime < MUTE_KEY_INTERVAL))
	{
		g_u32Mutekeydelaytime++;
		g_u32MuteIconHandle++;
	}

    APP_GUIOBJ_Source_GetCurrSource(&eSourType);

#ifdef CONFIG_HDMI_SPD
		if(bSPDCheck == 1)
		{
			g_SPD_Timer_count++;
			if(g_SPD_Timer_count >= 30) //30*100ms
			{
				APP_Video_SetMute(FALSE, TRUE, APP_MUTE_MODE_NO_SIGNALE, eSourType);
				g_SPD_Timer_count = 0;
			}
		}
#endif

	/*Set timer to source translate state
	   avoid dvb app not received onrun message result in not clear the falg*/
	if (APP_GUIOBJ_Source_GetSourceTransState())
	{
		g_u8SourceTrastTimer++;
		if (g_u8SourceTrastTimer >= 3)//3*100ms
		{
			APP_GUIOBJ_Source_SetSourceTransState(FALSE);
			g_u8SourceTrastTimer = 0;
		}
	}
#ifdef CONFIG_SUPPORT_ESTICKER_INFILE
	UINT32  dIndex=SYS_APP_ATV;
		AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_SETUP, 0,
			sizeof(APP_SETTING_Setup_t), &(g_stSetupData));
	if(g_stSetupData.StoreMode == APP_SWITCH_ON)
	{
		{
#ifndef CONFIG_SUPPORT_ESTICKER_NEW
			if(!SYSAPP_GOBJ_GUIObjectExist(dIndex, APP_GUIOBJ_ESTICKER))
			{
				g_u32StoreModeOpenTimer++;
				if(g_u32StoreModeOpenTimer >= STOREMODE_TIMEGAP*10)
				{
					SYSAPP_GOBJ_CreateGUIObject_WithPara(dIndex, APP_GUIOBJ_ESTICKER, 0);
					g_u32StoreModeOpenTimer = 0;
				}
			}
#else
			if (g_u8SignalState != ATV_NO_SIGNAL && SYSAPP_GOBJ_GUIObjectExist(dIndex, APP_GUIOBJ_ESTICKER_NEW))
			{
				SYSAPP_GOBJ_DestroyGUIObject(dIndex, APP_GUIOBJ_ESTICKER_NEW);
			}
			if ((g_u8SignalState == ATV_NO_SIGNAL) && !SYSAPP_GOBJ_GUIObjectExist(dIndex, APP_GUIOBJ_ESTICKER_NEW) 
				&& !SYSAPP_GOBJ_GUIObjectExist(dIndex,APP_GUIOBJ_SOFTWARE_UPGRADE))
			{
				g_u32StoreModeOpenTimer++;
				if(g_u32StoreModeOpenTimer >= STOREMODE_TIMEGAP*10)
				{
					SYSAPP_GOBJ_CreateGUIObject_WithPara(dIndex, APP_GUIOBJ_ESTICKER_NEW, 0);
					g_u32StoreModeOpenTimer = 0;
				}
			}
#endif
			else
			{
				g_u32StoreModeOpenTimer = 0;
			}
		}
	}
	else
	{
#ifdef CONFIG_SUPPORT_ESTICKER_NEW
		if (SYSAPP_GOBJ_GUIObjectExist(dIndex, APP_GUIOBJ_ESTICKER_NEW))
		{
			SYSAPP_GOBJ_DestroyGUIObject(dIndex, APP_GUIOBJ_ESTICKER_NEW);
		}
#endif
		g_u32StoreModeOpenTimer = 0;
	}
#endif

#ifdef SUPPORT_FACTORY_AUTO_TEST_MODE2
	#ifndef SUPPORT_FACTORY_AUTO_TEST_MODE2_EXTEND
	if(APP_Factory_GetAutoTestOnOff() == TRUE)
	{
		if (SYSTEM_APP_NO_FOCUSED_GUIOBJ == SYSAPP_GOBJ_GetFocusedGUIObject(SYS_APP_ATV, &dFocusedIndex))
		{
			_ATVApp_ResetPopup_Channel();
			_ATVApp_CloseAllMenu();
			SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, APP_GUIOBJ_FAC_AUTOTEST, 1);
		}
	}
	#endif
#endif

    switch (g_u8SignalState)
    {
        case ATV_NO_SIGNAL:  //Show no signal
        {
#ifdef CONFIG_CC_SUPPORT
            if(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_CC))
            {
                SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_CC);
            }
#endif
            if ((!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_SLEEP_INFO)) &&
#ifdef CONFIG_SUPPORT_ESTICKER_NEW
				!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_ESTICKER_NEW) &&
#endif
                (!APP_MenuMgr_Exist_Factory_Menu()))
            {
                g_u32NoSignalTimer ++;
                g_u32NoSignalSleepTimer ++;
            }
            else
            {
                g_u32NoSignalTimer = 0;
            }
/*2.1.10 Input factory auto test mode close no signal standby function*/
#if (defined(SUPPORT_FACTORY_AUTO_TEST) ||  defined(SUPPORT_FACTORY_AUTO_TEST_MODE2))
	#ifndef SUPPORT_FACTORY_AUTO_TEST_MODE2_EXTEND
			if(APP_Factory_GetAutoTestOnOff() == TRUE)
			{
				g_u32NoSignalTimer = 0;
				g_u32NoSignalSleepTimer = 0;
			}
	#endif
#endif

            if (eSourType == APP_SOURCE_PC)
            {
                if (g_u32NoSignalSleepTimer == ATV_1_MINUTES)
                {
                    g_u32NoSignalSleepTimer = 0;
                    if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_SLEEP_INFO) && (APP_GUIOBJ_SleepTimer_GetStandbyPopConflict() == FALSE))
                    {
                        APP_GUIOBJ_SleepTimer_SetStandbyPopConflict(TRUE);
                    }

                    SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_ATV,
                                 (APP_GLOBAL_EVENT_SLEEP_TIMER_INFO | PASS_TO_SYSAPP), APP_POWERDOWN_SUSPEND);
                }
            }
            else if ((eSourType != APP_SOURCE_DVD) && (eSourType != APP_SOURCE_ANDRO))
            {
                if (g_u32NoSignalSleepTimer == ATV_10_MINUTES)
                {
                    g_u32NoSignalSleepTimer = 0;
                    if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_SLEEP_INFO) && (APP_GUIOBJ_SleepTimer_GetStandbyPopConflict() == FALSE))
                    {
                        APP_GUIOBJ_SleepTimer_SetStandbyPopConflict(TRUE);
                    }
                    SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_ATV,
                                	(APP_GLOBAL_EVENT_SLEEP_TIMER_INFO | PASS_TO_SYSAPP), APP_POWERDOWN_NO_SINGAL);
                }
            }
            if (g_u32NoSignalTimer >= g_noSignaldebouncetime)
            {
                if (SYSTEM_APP_NO_FOCUSED_GUIOBJ == SYSAPP_GOBJ_GetFocusedGUIObject(SYS_APP_ATV, &dFocusedIndex))
                {
                    if (!ATVApp_IsPopupExist(PLAYBACK_POPUP_MSG_NO_SIGNAL))
                    {
                    	g_u32NoSignalTimer = 0;
					#ifdef CONFIG_QSD
						// Chip test mode doesn't need to show no signal OSD
					#else
                        SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_ATV,APP_ATV_GLOBAL_EVENT_POPMSG_NO_SIGNAL, 0);
					#endif
                    }
                }
            }
        }
        break;

        case ATV_NOTAVAILABLE_SIGNAL: //Not avaiable case
        {
#ifdef CONFIG_CC_SUPPORT
            if(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_CC))
            {
                SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_CC);
            }
#endif
            g_u8NotAvailableTimer ++;

            if (g_u8NotAvailableTimer >= 25)//5*100ms
            {
                g_u8NotAvailableTimer = 0;
                if (!ATVApp_IsPopupExist(PLAYBACK_POPUP_MSG_NOT_SUPPORT_MODE))
                {
                    SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_ATV,
                    		APP_ATV_GLOBAL_EVENT_POPMSG_NOT_SUPPORT_MODE, 0);
                }
            }
        }
        break;
        case ATV_AVAILABLE_SIGNAL:
			
#ifdef CONFIG_CC_SUPPORT
            if((eSourType == APP_SOURCE_ATV)
               || ((eSourType >= APP_SOURCE_SCART)
               && (eSourType <= APP_SOURCE_YPBPR2)))
            {
                AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_SETUP, 0,
                    sizeof(APP_SETTING_Setup_t), &(g_stSetupData));
                if(g_stSetupData.ATVCCMode != APP_CC_MODE_OFF)
                {
                    /*cc ui can't coexist with menu ui.
                               when have availble signal, need display cc.*/
                    if(!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_CC)
                        && ((APP_MenuMgr_Exist_Main_Menu() == 0)
                        && !SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_OPTIONMENU)))
                    {
                         if(eSourType != APP_SOURCE_ATV)
                         {
                            SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, ATV_GUIOBJ_CC, 0);
                         }
                    }
                }
                else
                {
                    if(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_CC))
                    {
                        SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_CC);
                    }
                }
           }
#endif

        if (eSourType == APP_SOURCE_ATV)
        {
        #if 0
		    if (AL_CS_IsStopFinish())
			{
#ifdef SUPPORT_CLOSE_NICAM
				if(g_u8SIF_SCS_OK == TRUE)
				{
					AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_USERINFO, 0,
    						sizeof(APP_SETTING_UserInfo_t), &(g_stUserInfoData));
					APP_Audio_SetMute(g_stUserInfoData.Mute, TRUE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
					g_u8SIF_SCS_OK = FALSE;
				}
#else
 				if (g_u8SIF_SCS_OK == TRUE)
	    		{
	    		    //printf("g_u8CheckMTSTimer=%d\n",g_u8CheckMTSTimer);
	    		    if (g_u8CheckMTSTimer >= 3)
	                {

	    			APP_Audio_GetATVSIFAvailableMode(&mode);
	    			memset(&GET_SIFinfo,0,sizeof(TVFE_AudioFrontEndStatus_t));
	    			TVFE_Audio_GetSIFInfo(&GET_SIFinfo);
	                //printf("u8CheckMTSCount=%d\n",u8CheckMTSCount);

	                if(LasteAvaiMode == GET_SIFinfo.eAvaiMode)
	                {
	                    u8CheckMTSCount ++;
	                }
	                else

	                {
	                    u8CheckMTSCount = 0;
	                }
				    LasteAvaiMode = GET_SIFinfo.eAvaiMode;       
	                //printf("11111111111mode=%x,GET_SIFinfo.eAvaiMode=%x,u8CheckMTSCount=%d\n",mode,GET_SIFinfo.eAvaiMode,u8CheckMTSCount);
	    			if (u8CheckMTSCount == 2)
	    			{
	    			    u8CheckMTSCount = 0;
	                    if (mode != GET_SIFinfo.eAvaiMode)
	                    {
	        				if ( IsAlreadyFirstSetMTS == FALSE )
	                        {
	                            AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_USERINFO, 0,
	    						sizeof(APP_SETTING_UserInfo_t), &(g_stUserInfoData));

	                            APP_ATV_Playback_SetMTS(GET_SIFinfo.eAvaiMode,TRUE,TRUE);
	                            APP_Audio_SetMute(g_stUserInfoData.Mute, TRUE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
	                            g_u8CheckMTSTimer = 0;
	                            IsAlreadyFirstSetMTS = TRUE;
#ifdef SUPPORT_BURNINGMODE_OUTPUT_AUDIO
	                            AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FACTUSER, 0,
	                                sizeof(APP_SETTING_FactoryUser_t), &(g_stFactoryUserData));
	                            if (g_stFactoryUserData.n_FactSet_BurningMode == al_false)
	                            {
#endif
	                                if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_INPUTINFO))
	                        		{
	                        			INT32 dFocusedIndex;
	                        			if (SYSTEM_APP_NO_FOCUSED_GUIOBJ == SYSAPP_GOBJ_GetFocusedGUIObject(SYS_APP_ATV, &dFocusedIndex))
	                        			{
	                        				SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV,
	                        						ATV_GUIOBJ_INPUTINFO, 0);
	                        			}
	                        		}
	                        		else
	                        		{
	                        			SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_ATV, APP_ATV_GLOBAL_EVENT_INFO_UPDATE, 0);
	                        		}

#ifdef SUPPORT_BURNINGMODE_OUTPUT_AUDIO
	                            }
#endif
	                        }
	                        else if (IsAlreadyFirstSetMTS == TRUE)
	                        {
	                            AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_USERINFO, 0,
	    						sizeof(APP_SETTING_UserInfo_t), &(g_stUserInfoData));

	                        	APP_ATV_Playback_SetMTS(GET_SIFinfo.eAvaiMode,FALSE,TRUE);
	                        	APP_Audio_SetMute(g_stUserInfoData.Mute, TRUE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
	                        	g_u8CheckMTSTimer = 0;
#ifdef SUPPORT_BURNINGMODE_OUTPUT_AUDIO
	                            AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FACTUSER, 0,
	                                sizeof(APP_SETTING_FactoryUser_t), &(g_stFactoryUserData));
	                            if (g_stFactoryUserData.n_FactSet_BurningMode == al_false)
	                            {
#endif
	                        		if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_INPUTINFO))
	                        		{
	                        			INT32 dFocusedIndex;
	                        			if (SYSTEM_APP_NO_FOCUSED_GUIOBJ == SYSAPP_GOBJ_GetFocusedGUIObject(SYS_APP_ATV, &dFocusedIndex))
	                        			{
	                        				SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV,
	                        					ATV_GUIOBJ_INPUTINFO, 1);
	                        			}
	                        		}
	                        		else
	                        		{
	                        			SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_ATV, APP_ATV_GLOBAL_EVENT_INFO_UPDATE, 1);
	                        		}
#ifdef SUPPORT_BURNINGMODE_OUTPUT_AUDIO
	                         	    }
#endif
	                        }
	                    }
	    				g_u8CheckMTSTimer = 0;
	                    break;
	    			}
	    			g_u8CheckMTSTimer = 0;
	                break;
	    		}
			 	g_u8CheckMTSTimer++;
	            }		
#endif
			}
		#endif
        }
#ifdef CONFIG_VCHIP_SUPPORT
        else if((eSourType >= APP_SOURCE_SCART)
           && (eSourType <= APP_SOURCE_YPBPR2))
        {
            /*need reopen pwd message for vchip locked program.*/
            if(ATVAPP_GetSignalLockStatus() == TRUE)
            {
                if (SYSTEM_APP_NO_FOCUSED_GUIOBJ == SYSAPP_GOBJ_GetFocusedGUIObject(SYS_APP_ATV, &dFocusedIndex))
                {
                    _ATVAPP_ShowPopup(ATV_APP_POP_MSG_CHECKPWD);
                }
                break;
            }
        }
#endif
#ifdef SUPPORT_AUTO_SOURCE_TEST
			extern APP_Source_Type_t g_AutoSourceTable[APP_SOURCE_MAX];
			extern APP_Source_Type_t g_AutoSourceSize;
			g_u32TestSignalTimer++;
			if(TRUE == APP_Factory_GetAutoSourceTestOnOff() && g_u32TestSignalTimer == 30)//30*100ms
			{
				g_u32TestSignalTimer = 0;
				g_u8CurSourceIndex ++;
				if(g_u8CurSourceIndex < g_AutoSourceSize)
				{
					APP_GUIOBJ_Source_SetAppSource(g_AutoSourceTable[g_u8CurSourceIndex]);
				}
				else
				{
					g_u8CurSourceIndex = 0;
					APP_Factory_SetAutoSourceTestOnOff(FALSE);
				}
			}
#endif        
			break;
		default:
			break;
    }
#if defined (CONFIG_SUPPORT_TTX ) && defined(CONFIG_SUPPORT_TTX_DISP_FOR_AUS)
	{
		UINT8 ttxtimer = APP_GetTTXTimer();
		if(ttxtimer > 0)
		{
			ttxtimer--;
			APP_SetTTXTimer(ttxtimer);
			if(ttxtimer == 0)//time is 8s
			{
				AL_TTX_Reset();
				if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_TTX))
				{
					SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_TTX);
				}
			}
		}
	}
#endif

    return 0;
}

static INT32 _ATVApp_OnGlobalEvent(void *pPrivateData,
                                   UINT32 dMessage, UINT32 dParam)
{
    Boolean bFreezeFlag = FALSE;
   // PLF_VideoID_t eResolution;
	#ifndef CONFIG_SUPPORT_ATV_SCAN_NTSCM_PALM_N
	UINT8 bAutoInstall = FALSE;
	#endif
    APP_Source_Type_t eSourType = APP_SOURCE_MAX;
    al_uint8 u8HotelMode;
    al_uint8 u8MainUIEn;
    PopmsgParam_t stPopup;
	UINT32 dAppIndex = 0;
	DRV_Scart_SignalType_t eScartPin16Status = DRV_Scart_Signal_Unkonwn;
	UINT8 RegionIdx = 0;
	ColorLUT_t stColorLUTValue;
	#ifdef SUPPORT_CLOSE_NICAM
    TVFE_AudioFrontEndStatus_t GET_SIFinfo;
	TVFE_AudioSIFAvailableMode_e mode = 0;
	#endif
	#if defined(CONFIG_HEADPHONE_DETECT_BY_ISR) || defined(CONFIG_HPDET_BY_SWTIMER)
	MID_DISP_MUTE_ST eMuteSt = MID_DISP_MUTE;
	#endif
    AL_ServiceDetail_t stServInfo;

    memset(&stServInfo, 0, sizeof(stServInfo));
    
    dMessage = (dMessage&~PASS_TO_SYSAPP);
    atv_printf(" %s, %d dMessage = 0x%x(%d) event received.\n", __FUNCTION__, __LINE__, dMessage,(dMessage&0xfff));

    APP_GUIOBJ_Source_GetCurrSource(&eSourType);
    AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FACTUSER, 0,
        sizeof(APP_SETTING_FactoryUser_t), &(g_stFactoryUserData));
	AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_USERINFO, 0,
		sizeof(APP_SETTING_UserInfo_t), &(g_stUserInfoData));
	AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_SETUP,
		ITEM_OFFSET(APP_SETTING_Setup_t, SCARTOutput),
		sizeof(g_stSetupData.SCARTOutput),&(g_stSetupData.SCARTOutput));
#ifdef CONFIG_POWER_ON_TV_LOCK
	AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_SETUP, 
        ITEM_OFFSET(APP_SETTING_Setup_t, PowerOnTVLock),
		sizeof(g_stSetupData.PowerOnTVLock), &(g_stSetupData.PowerOnTVLock));
	if(g_stSetupData.PowerOnTVLock == APP_SWITCH_ON && APP_GUIOBJ_GET_PASSWORDRight_Flag() == FALSE)
    {
         _ATVAPP_ShowPopup(ATV_APP_POP_MSG_CHECKPWD);  
         return SP_SUCCESS;
    }   
#endif
    if (g_stFactoryUserData.n_FactSet_BurningMode == al_true)
    {
#ifdef SUPPORT_BURNINGMODE_OUTPUT_AUDIO
        if (dMessage == APP_ATV_GLOBAL_EVENT_ATV_ONRUN)
        {
            UINT32 Indexmm = TOTAL_SYS_APP_SIZE;
            while(MAINAPP_GetActiveSystemAppIndex(&Indexmm) !=MAIN_APP_SUCCESS)
            {
                GL_TaskSleep(1);
            }
            if (SP_SUCCESS != APP_GUIOBJ_Source_SetMidSource(NULL))
                //|| (APP_IsScan_Running()))
            {
            	APP_GUIOBJ_Source_SetSourceTransState(FALSE);
				g_u8SourceTrastTimer = 0;
                return SP_ERR_FAILURE;
            }
			APP_GUIOBJ_Source_SetSourceTransState(FALSE);
			g_u8SourceTrastTimer = 0;

        }
#endif
    	if ((eSourType == APP_SOURCE_SCART
			|| eSourType == APP_SOURCE_SCART1)
			&&(dMessage == APP_ATV_GLOBAL_EVENT_SIGNAL_PRESENT))
    	{
			atv_printf(" Scart is plugged during burning mode AND signal availale.\n");
			g_u8SignalState = ATV_AVAILABLE_SIGNAL;
	}

#ifdef SUPPORT_BURNINGMODE_OUTPUT_AUDIO
        if (dMessage == APP_ATV_GLOBAL_EVENT_NO_SIGNAL)
        {
            g_u8SignalState = ATV_NO_SIGNAL;
            TVFE_Audio_RFLineCTL(FALSE);
            IsAlreadyFirstSetMTS = FALSE;

            APP_Audio_SetMute(TRUE, TRUE, APP_MUTE_MODE_NO_SIGNALE, eSourType);
        }
        else if (dMessage == APP_ATV_GLOBAL_EVENT_SIGNAL_PRESENT)
        {
            g_u8SignalState = ATV_AVAILABLE_SIGNAL;
        }
        else if (dMessage == APP_ATV_GLOBAL_EVENT_VIP_STATUS)
        {
            if (g_u8SignalState == ATV_AVAILABLE_SIGNAL && eSourType != APP_SOURCE_ATV)
            {
                APP_Audio_SetMute(FALSE, TRUE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
            }
        }
        else if (dMessage == APP_ATV_GLOBAL_EVENT_HDMIACPTYPE_CHANGE)
        {
			if (dParam != APP_ACP_RESERVED)
			{
				APP_Audio_HDMITypeChange(APP_ACP_TYPE_CHG,dParam);
			}
        }
        else if(dMessage == APP_ATV_GLOBAL_EVENT_HDMIDVI_CHANGE)
        {
		   if (dParam != APP_MODE_UNDEFINE)
            {
            	APP_Audio_HDMITypeChange(APP_HDMI_MODE_CHG,dParam);
                /*Set SPDIF output when HDMI audio_src has been known*/
                if (eSourType >= APP_SOURCE_HDMI && eSourType <= APP_SOURCE_HDMI2)
                {
                        if (dParam != PreHDMIMODE)
                        {
				            UINT8 u8Value = g_stVariationalData.Volume;
				            APP_Audio_SetVolume(u8Value);

							UINT32 u32Spdif;
							APP_GUIOBJ_Sound_GetSPDIF(&u32Spdif);
							APP_GUIOBJ_Sound_SetSPDIF(u32Spdif);
                        }
                        PreHDMIMODE = dParam;
                }            
            }
        }
        else if (dMessage ==  APP_ATV_GLOBAL_EVENT_SIF_SAS_OK)
        {
            TVFE_Audio_RFLineCTL(TRUE);
            g_u8SIF_SCS_OK = FALSE;
        }
        else if (dMessage == APP_ATV_GLOBAL_EVENT_SIF_SCS_OK)
        {
	 	g_u8SIF_SCS_OK = TRUE;
        #ifdef SUPPORT_CLOSE_NICAM
        memset(&GET_SIFinfo,0,sizeof(TVFE_AudioFrontEndStatus_t));
    	TVFE_Audio_GetSIFInfo(&GET_SIFinfo);
        APP_ATV_Playback_SetMTS(GET_SIFinfo.eAvaiMode,FALSE,TRUE);
        APP_Audio_SetMute(g_stUserInfoData.Mute, TRUE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
        #endif
		printf("g_u8SIF_SCS_OK\n");
        }
#endif
        return SP_SUCCESS;
    }

    AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FACTHOTEL, 0,
                    sizeof(APP_SETTING_FactoryHotel_t), &(g_stFactoryHotelData));
    u8HotelMode = g_stFactoryHotelData.HotelModeOnOff;
    u8MainUIEn = g_stFactoryHotelData.MainUIOperation;

    if (u8HotelMode == 1)
    {
        if (u8MainUIEn == 1)
        {
            if (dMessage == UI_EVENT_MENU)
            {
                dMessage = UI_EVENT_NULL;
            }
        }
    }

    if ((g_stFactoryHotelData.HotelModeOnOff == 1) && (g_stFactoryHotelData.AspectRatioLock == 1))
    {
        if (dMessage == UI_EVENT_ASPECT)
        {
            dMessage = UI_EVENT_NULL;
        }
    }
	#ifdef CONFIG_HDMI_SUPPORT_MHL
	//MHL RCP Cmd
	APP_Source_Type_t eMhlSrc;
	UINT8 IsMHLSoure;
	APP_GOBJ_Source_CheckAndGetMHLSource(&IsMHLSoure,&eMhlSrc);
    if ((CbusconnectedFlag == TRUE) && (g_u8CallCMDState == FALSE) && (TRUE == IsMHLSoure))//MHL Port
    {
    	INT32 dFocusedIndex = 0;
		if(SYSTEM_APP_NO_FOCUSED_GUIOBJ == SYSAPP_GOBJ_GetFocusedGUIObject(SYS_APP_ATV, &dFocusedIndex) || ATVApp_IsPopupExist(PLAYBACK_POPUP_MSG_NO_SIGNAL))
		{
	    	printf("[APP_MHL] send RCP %d\n", dMessage);
	        switch (dMessage)
	        {
	            case UI_EVENT_0:
					Cmd_Hdmi_SendMHLRcpCmd(MHL_RCP_CMD_NUM_0);
					break;
	            case UI_EVENT_1:
					Cmd_Hdmi_SendMHLRcpCmd(MHL_RCP_CMD_NUM_1);
					break;
	            case UI_EVENT_2:
					Cmd_Hdmi_SendMHLRcpCmd(MHL_RCP_CMD_NUM_2);
					break;
	            case UI_EVENT_3:
					Cmd_Hdmi_SendMHLRcpCmd(MHL_RCP_CMD_NUM_3);
					break;
	            case UI_EVENT_4:
					Cmd_Hdmi_SendMHLRcpCmd(MHL_RCP_CMD_NUM_4);
					break;
	            case UI_EVENT_5:
					Cmd_Hdmi_SendMHLRcpCmd(MHL_RCP_CMD_NUM_5);
					break;
	            case UI_EVENT_6:
					Cmd_Hdmi_SendMHLRcpCmd(MHL_RCP_CMD_NUM_6);
					break;
	            case UI_EVENT_7:
					Cmd_Hdmi_SendMHLRcpCmd(MHL_RCP_CMD_NUM_7);
					break;
	            case UI_EVENT_8:
					Cmd_Hdmi_SendMHLRcpCmd(MHL_RCP_CMD_NUM_8);
					break;
	            case UI_EVENT_9:
					Cmd_Hdmi_SendMHLRcpCmd(MHL_RCP_CMD_NUM_9);
					break;
	            case UI_EVENT_UP:
					Cmd_Hdmi_SendMHLRcpCmd(MHL_RCP_CMD_UP);
					break;
	            case UI_EVENT_DOWN:
					Cmd_Hdmi_SendMHLRcpCmd(MHL_RCP_CMD_DOWN);
					break;
	            case UI_EVENT_LEFT:
					Cmd_Hdmi_SendMHLRcpCmd(MHL_RCP_CMD_LEFT);
					break;
	            case UI_EVENT_RIGHT:
					Cmd_Hdmi_SendMHLRcpCmd(MHL_RCP_CMD_RIGHT);
					break;
	            case UI_EVENT_ENTER:
					Cmd_Hdmi_SendMHLRcpCmd(MHL_RCP_CMD_SELECT);
					break;
	            case UI_EVENT_MUTE:
					Cmd_Hdmi_SendMHLRcpCmd(MHL_RCP_CMD_MUTE);
					break;
	            case UI_EVENT_VOL_UP:
					Cmd_Hdmi_SendMHLRcpCmd(MHL_RCP_CMD_VOL_UP);
					break;
	            case UI_EVENT_VOL_DN:
					Cmd_Hdmi_SendMHLRcpCmd(MHL_RCP_CMD_VOL_DOWN);
					break;
	            case UI_EVENT_MENU:
					Cmd_Hdmi_SendMHLRcpCmd(MHL_RCP_CMD_SETUP_MENU);
					break;
	            case UI_EVENT_STOP:
					Cmd_Hdmi_SendMHLRcpCmd(MHL_RCP_CMD_STOP);
					break;
	            case UI_EVENT_PLAY:
					Cmd_Hdmi_SendMHLRcpCmd(MHL_RCP_CMD_PLAY);
					break;
	            case UI_EVENT_PAUSE:
					Cmd_Hdmi_SendMHLRcpCmd(MHL_RCP_CMD_PAUSE);
					break;
	            case UI_EVENT_FF:
					Cmd_Hdmi_SendMHLRcpCmd(MHL_RCP_CMD_FAST_FWD);
					break;
	            case UI_EVENT_FR:
					Cmd_Hdmi_SendMHLRcpCmd(MHL_RCP_CMD_REWIND);
					break;
	           case UI_EVENT_NEXT:
					Cmd_Hdmi_SendMHLRcpCmd(MHL_RCP_CMD_FWD);
					break;
	           case UI_EVENT_PREV:
					Cmd_Hdmi_SendMHLRcpCmd(MHL_RCP_CMD_BKWD);
					break;
	           case UI_EVENT_RED:
					Cmd_Hdmi_SendMHLRcpCmd(MHL_RCP_CMD_F2_RED);
					break;
	           case UI_EVENT_GREEN:
					Cmd_Hdmi_SendMHLRcpCmd(MHL_RCP_CMD_F3_GREEN);
					break;
	           case UI_EVENT_YELLOW:
					Cmd_Hdmi_SendMHLRcpCmd(MHL_RCP_CMD_F4_YELLOW);
					break;
	           case UI_EVENT_BLUE:
					Cmd_Hdmi_SendMHLRcpCmd(MHL_RCP_CMD_F1_BLUE);
					break;
	           case UI_EVENT_RETURN:
					Cmd_Hdmi_SendMHLRcpCmd(MHL_RCP_CMD_PRE_CH);
					break;
	           case UI_EVENT_PLAY_PAUSE:
					Cmd_Hdmi_SendMHLRcpCmd(MHL_RCP_CMD_PLAY);
					break;
	           case UI_EVENT_CH_UP:
					Cmd_Hdmi_SendMHLRcpCmd(MHL_RCP_CMD_CH_UP);
					break;
	           case UI_EVENT_CH_DN:
					Cmd_Hdmi_SendMHLRcpCmd(MHL_RCP_CMD_CH_DOWN);
					break;
	           case UI_EVENT_EXIT:
					Cmd_Hdmi_SendMHLRcpCmd(MHL_RCP_CMD_EXIT);
					break;
	           case UI_EVENT_DOT:
					Cmd_Hdmi_SendMHLRcpCmd(MHL_RCP_CMD_DOT);
					break;
			}
		}
    }
	g_u8CallCMDState = FALSE;
	//MHL RCP TEST end
	#endif

#ifdef SUPPORT_CEC_TV
	if(dMessage == UI_EVENT_EXIT)
	{
		if (CECTV_GetCECEnable()==CECTV_ENABLE)
		{
			if((eSourType == APP_SOURCE_HDMI)||(eSourType == APP_SOURCE_HDMI1)||(eSourType == APP_SOURCE_HDMI2))
			{
				UINT32 u32GuiObj =0;
				UINT32 IsExitMenu =0;

				for (u32GuiObj =0; u32GuiObj < ATV_GUIOBJ_MAX; u32GuiObj++)
				{
					if (u32GuiObj == ATV_GUIOBJ_FREEZE
						|| u32GuiObj == ATV_GUIOBJ_POPMSG
						|| u32GuiObj == APP_GUIOBJ_MUTE)
					{
						continue;
					}

					if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, u32GuiObj))
					{
						IsExitMenu = TRUE;
						break;
					}
				}
				if(IsExitMenu == FALSE)
				{
					dMessage = DMN_EVENT_CECTV_EXIT;
				}
			}
		}
	}

	if (CECTV_GetCECEnable() == CECTV_ENABLE)
    {
        if ((eSourType == APP_SOURCE_HDMI) ||
            (eSourType == APP_SOURCE_HDMI1) ||
            (eSourType == APP_SOURCE_HDMI2))
        {
            switch (dMessage)
            {
                case UI_EVENT_STOP:
                    CECTV_SendCmd(CECTV_SINGLE_ACT_CMD_KEYPRESS, CECTV_KEY_STOP << 8); //UCP CECTV_KEY_STOP
                    atv_printf("========================UI_EVENT_STOP========================\n");
                    break;
				case UI_EVENT_TIMESHIFT:
					CECTV_SendCmd(CECTV_SINGLE_ACT_CMD_KEYPRESS, CECTV_KEY_EJECT << 8); //UCP UI_EVENT_TIMESHIFT
					atv_printf("========================UI_EVENT_TIMESHIFT========================\n");
					break;
				case UI_EVENT_PLAY_PAUSE:
					CECTV_SendCmd(CECTV_SINGLE_ACT_CMD_KEYPRESS, CECTV_KEY_PAUSE_PLAY_FUNC << 8); //UCP UI_EVENT_PLAY_PAUSE
					atv_printf("========================UI_EVENT_PLAY_PAUSE========================\n");
					break;
				case UI_EVENT_PLAY:
                    CECTV_SendCmd(CECTV_SINGLE_ACT_CMD_KEYPRESS, CECTV_KEY_PLAY << 8); //UCP CECTV_KEY_PLAY
                    atv_printf("========================UI_EVENT_PLAY========================\n");
                    break;
                case UI_EVENT_PAUSE:
                    CECTV_SendCmd(CECTV_SINGLE_ACT_CMD_KEYPRESS, CECTV_KEY_PAUSE << 8); //UCP CECTV_KEY_PAUSE
                    atv_printf("========================UI_EVENT_PAUSE========================\n");
                    break;
                case UI_EVENT_FF:
                    CECTV_SendCmd(CECTV_SINGLE_ACT_CMD_KEYPRESS, CECTV_KEY_FAST_FORWARD << 8); //UCP CECTV_KEY_FAST_FORWARD
                    atv_printf("========================UI_EVENT_FF========================\n");
                    break;
                case UI_EVENT_FR:
                    CECTV_SendCmd(CECTV_SINGLE_ACT_CMD_KEYPRESS, CECTV_KEY_REWIND << 8); //UCP CECTV_KEY_REWIND
                    atv_printf("========================UI_EVENT_FF========================\n");
                    break;
                case UI_EVENT_NEXT:
                    CECTV_SendCmd(CECTV_SINGLE_ACT_CMD_KEYPRESS, CECTV_KEY_FORWARD << 8); //UCP CECTV_KEY_FORWARD
                    atv_printf("========================UI_EVENT_NEXT========================\n");
                    break;
                case UI_EVENT_PREV:
                    CECTV_SendCmd(CECTV_SINGLE_ACT_CMD_KEYPRESS, CECTV_KEY_BACKWARD << 8); //UCP CECTV_KEY_BACKWARD
                    atv_printf("========================UI_EVENT_PREV========================\n");
                    break;
                case UI_EVENT_ENTER:
                    CECTV_SendCmd(CECTV_SINGLE_ACT_CMD_KEYPRESS, CECTV_KEY_SELECT << 8); //UCP CECTV_KEY_SELECT
                    atv_printf("========================UI_EVENT_ENTER========================\n");
                    break;
				case UI_EVENT_UP:
					//CECTV_SendCmd(CECTV_SINGLE_ACT_CMD_KEYPRESS, CECTV_KEY_UP << 8); //UCP CECTV_KEY_UP
					cec_RemoteControlPassThrough(CECTV_KEY_UP);
					atv_printf("========================UI_EVENT_UP========================\n");
					break;
				case UI_EVENT_DOWN:
					//CECTV_SendCmd(CECTV_SINGLE_ACT_CMD_KEYPRESS, CECTV_KEY_DOWN << 8); //UCP CECTV_KEY_DOWN
					cec_RemoteControlPassThrough(CECTV_KEY_DOWN);
					atv_printf("========================UI_EVENT_DOWN========================\n");
					break;
				case UI_EVENT_LEFT:
					//CECTV_SendCmd(CECTV_SINGLE_ACT_CMD_KEYPRESS, CECTV_KEY_LEFT << 8); //UCP CECTV_KEY_LEFT
					cec_RemoteControlPassThrough(CECTV_KEY_LEFT);
					atv_printf("========================CECTV_KEY_LEFT========================\n");
					break;
				case UI_EVENT_RIGHT:
					//CECTV_SendCmd(CECTV_SINGLE_ACT_CMD_KEYPRESS, CECTV_KEY_RIGHT << 8); //UCP CECTV_KEY_RIGHT
					cec_RemoteControlPassThrough(CECTV_KEY_RIGHT);
					atv_printf("========================UI_EVENT_RIGHT========================\n");
					break;


				case UI_EVENT_RED:
                    CECTV_SendCmd(CECTV_SINGLE_ACT_CMD_KEYPRESS, CECTV_KEY_F2_RED << 8); //UCP CECTV_KEY_F2_RED
                    atv_printf("========================UI_EVENT_RED========================\n");
                    break;
                case UI_EVENT_GREEN:
                    CECTV_SendCmd(CECTV_SINGLE_ACT_CMD_KEYPRESS, CECTV_KEY_F3_GREEN << 8); //UCP CECTV_KEY_F3_GREEN
                    atv_printf("========================UI_EVENT_GREEN========================\n");
                    break;
                case UI_EVENT_YELLOW:
                    CECTV_SendCmd(CECTV_SINGLE_ACT_CMD_KEYPRESS, CECTV_KEY_F4_YELLOW << 8); //UCP CECTV_KEY_F4_YELLOW
                    atv_printf("========================UI_EVENT_YELLOW========================\n");
                    break;
                case UI_EVENT_BLUE:
                    CECTV_SendCmd(CECTV_SINGLE_ACT_CMD_KEYPRESS, CECTV_KEY_F1_BLUE << 8); //UCP CECTV_KEY_F1_BLUE
                    atv_printf("========================UI_EVENT_BLUE========================\n");
                    break;

                case DMN_EVENT_CECTV_EXIT:
                    CECTV_SendCmd(CECTV_SINGLE_ACT_CMD_KEYPRESS, CECTV_KEY_EXIT << 8); //UCP CECTV_KEY_EXIT
                    atv_printf("========================DMN_EVENT_CECTV_EXIT========================\n");
                    break;
            }
        }
        //active source
        if (dMessage == UI_EVENT_TVRADIO)
        {
            atv_printf("========================UI_EVENT_TVRADIO========================\n");
            CECTV_SendCmd(CECTV_SINGLE_ACT_CMD_CHGSRC_OUT_HDMI, SRC_OTHERS);
        }
        if (dMessage == UI_EVENT_MUTE)
        {
            atv_printf("========================UI_EVENT_MUTE========================\n");
            //CECTV_SendCmd(CECTV_SINGLE_ACT_CMD_KEYPRESS, CECTV_KEY_MUTE << 8 | 0x05); //Mute Function
			if (CECTV_GetHDMISystemAudioMode()&& CECTV_GetSpeakerPreference())
            {
				if(g_u32Mutekeydelaytime >= MUTE_KEY_INTERVAL)
				{
					cec_RemoteControlPassThrough(CECTV_KEY_MUTE);
		            cec_RemoteControlPassThrough(CECTV_KEY_MUTE_RELEASE);
	                g_u32Mutekeydelaytime = 0;
				}
            }
        }
        if (dMessage == UI_EVENT_VOL_UP)
        {
            atv_printf("========================UI_EVENT_VOL_UP========================\n");
            //CECTV_SendCmd(CECTV_SINGLE_ACT_CMD_KEYPRESS, CECTV_KEY_VOLUME_UP << 8 | 0x05); //UCP VOL_DN Function
			if (CECTV_GetHDMISystemAudioMode() && APP_Check_CEC_DEVICE_Status()&& CECTV_GetSpeakerPreference())
            {
	            if (dParam & IR_EVENT_REPEAT_TYPE)
				{
					cec_RemoteControlPassThrough(CECTV_KEY_VOLUME_UP);
				}
				else if (dParam & IR_EVENT_REPEAT_END)
				{
					cec_RemoteControlPassThrough(CECTV_KEY_VOLUME_UP_RELEASE);
				}
				else
				{
					cec_RemoteControlPassThrough(CECTV_KEY_VOLUME_UP);
					cec_RemoteControlPassThrough(CECTV_KEY_VOLUME_UP_RELEASE);
				}
            }
        }
        if (dMessage == UI_EVENT_VOL_DN)
        {
            atv_printf("========================UI_EVENT_VOL_DN========================\n");
            //CECTV_SendCmd(CECTV_SINGLE_ACT_CMD_KEYPRESS, CECTV_KEY_VOLUME_DOWN << 8 | 0x05); //UCP VOL_DN Function
			if (CECTV_GetHDMISystemAudioMode() && APP_Check_CEC_DEVICE_Status()&& CECTV_GetSpeakerPreference())
			{
				if (dParam & IR_EVENT_REPEAT_TYPE)
				{
					cec_RemoteControlPassThrough(CECTV_KEY_VOLUME_DOWN);
				}
				else if (dParam & IR_EVENT_REPEAT_END)
				{
					cec_RemoteControlPassThrough(CECTV_KEY_VOLUME_DOWN_RELEASE);
				}
				else
				{
					cec_RemoteControlPassThrough(CECTV_KEY_VOLUME_DOWN);
					cec_RemoteControlPassThrough(CECTV_KEY_VOLUME_DOWN_RELEASE);
				}
			}
        }
    }
#if 0//Deck Control
    switch (dMessage)
    {
        case UI_EVENT_STOP:
            CECTV_SendCmd(CECTV_SINGLE_ACT_CMD_DECK_CONTROL, DECKCONTROL_STOP << 8 | 0x08); //UCP CECTV_KEY_STOP
            atv_printf("========================UI_EVENT_STOP========================");
            break;
        case UI_EVENT_PLAY:
            CECTV_SendCmd(CECTV_SINGLE_ACT_CMD_PLAY, PLAY_FORWARD << 8 | 0x08); //UCP CECTV_KEY_PLAY
            atv_printf("========================UI_EVENT_PLAY========================");
            break;
        case UI_EVENT_PAUSE:
            CECTV_SendCmd(CECTV_SINGLE_ACT_CMD_PLAY, PLAY_STILL << 8 | 0x08); //UCP CECTV_KEY_PAUSE
            atv_printf("========================UI_EVENT_PAUSE========================");
            break;
        case UI_EVENT_FF:
            CECTV_SendCmd(CECTV_SINGLE_ACT_CMD_PLAY, FAST_FWD_MED << 8 | 0x08); //UCP CECTV_KEY_FAST_FORWARD
            atv_printf("========================UI_EVENT_FF========================");
            break;
        case UI_EVENT_FR:
            CECTV_SendCmd(CECTV_SINGLE_ACT_CMD_PLAY, FAST_REV_MED << 8 | 0x08); //UCP CECTV_KEY_REWIND
            atv_printf("========================UI_EVENT_FF========================");
            break;
        case UI_EVENT_NEXT:
            CECTV_SendCmd(CECTV_SINGLE_ACT_CMD_DECK_CONTROL, DECKCONTROL_SKIP_FWD << 8 | 0x08); //UCP CECTV_KEY_FORWARD
            atv_printf("========================UI_EVENT_NEXT========================");
            break;
        case UI_EVENT_PREV:
            CECTV_SendCmd(CECTV_SINGLE_ACT_CMD_DECK_CONTROL, DECKCONTROL_SKIP_BACK << 8 | 0x08); //UCP CECTV_KEY_BACKWARD
            atv_printf("========================UI_EVENT_PREV========================");
            break;
    }
#endif
#endif
    switch (dMessage)
    {
#ifdef SUPPORT_POWERAGAIN_CONFIRM_POWEROFF
		case APP_GLOBAL_EVENT_CONFIRM_POWER:
			_ATVApp_CloseAllMenu();
			_ATVApp_ResetPopup_Channel();
			SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, APP_GUIOBJ_MAINMENUPOP, MAINPOPMSG_SHOW_CONFIRM_POWER);
			break;
#endif
#ifdef CONFIG_SUPPORT_AUDIO_CODEC_OVERLAY
		case FW_AUDIO_LOADCODEC_OK:
			printf("\n[%s:%d] Load audio codec ok \n\n",__FUNCTION__,__LINE__);
			break;
		case FW_AUDIO_LOADCODEC_ERROR:
			printf("\n[%s:%d] Load audio codec error \n\n",__FUNCTION__,__LINE__);
			break;
#endif
        case APP_ATV_GLOBAL_EVENT_ATV_ONRUN:
			{
            atv_printf("[%s: %d] APP_ATV_GLOBAL_EVENT_ATV_ONRUN event received\n", __FUNCTION__, __LINE__);
            UINT32 Indexmm = TOTAL_SYS_APP_SIZE;
            while(MAINAPP_GetActiveSystemAppIndex(&Indexmm) !=MAIN_APP_SUCCESS)
            {
                GL_TaskSleep(1);
            }
            if (SP_SUCCESS != APP_GUIOBJ_Source_SetMidSource(NULL)) 
                //|| (APP_IsScan_Running()))
            {
            	APP_GUIOBJ_Source_SetSourceTransState(FALSE);
				g_u8SourceTrastTimer = 0;
                return SP_ERR_FAILURE;
            }
			APP_GUIOBJ_Source_SetSourceTransState(FALSE);
			g_u8SourceTrastTimer = 0;

            if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_MUTE))
            {
                SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, APP_GUIOBJ_MUTE, 0);
            }

            AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_USERINFO, 0,
                            sizeof(APP_SETTING_UserInfo_t), &(g_stUserInfoData));
            if (g_stUserInfoData.Mute == TRUE)
            {
                SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_ATV, APP_GUIOBJ_MUTE,
                                                     APP_INTRA_EVENT_SHOW_MUTE, SHOW_MUTE_ON_TV);
            }
#ifdef CONFIG_ATV_SUPPORT
            APP_GUIOBJ_ATV_Playback_SetAtvUnLock(al_false);
#endif
#ifdef CONFIG_VCHIP_SUPPORT
            VchipLockFlag = FALSE;
            PreVchipLockFlag = FALSE;
#endif
            if (g_ucComeFromAutoSearch == 1)
            {
                //SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, ATV_GUIOBJ_AUTO_SEARCH, AUTOSEARCH_FROM_ALLTUNE);
                //SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_ATV, ATV_GUIOBJ_PLAYBACK, APP_ATV_INTRA_EVENT_START_PLAYBACK, TRUE);
                g_ucComeFromAutoSearch = 0;
                break;
            }

			g_stUserInfoData.AutoInstalled = FALSE;

			AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_USERINFO,
							 ITEM_OFFSET(APP_SETTING_UserInfo_t, AutoInstalled),
							 sizeof(g_stUserInfoData.AutoInstalled), &(g_stUserInfoData.AutoInstalled));
			AL_Setting_Store(APP_Data_UserSetting_Handle(), SYS_SET_ID_USERINFO,
							 ITEM_OFFSET(APP_SETTING_UserInfo_t, AutoInstalled), sizeof(g_stUserInfoData.AutoInstalled));
            bAutoInstall = g_stUserInfoData.AutoInstalled;
            if (bAutoInstall && (FALSE == gIsFactoryResetting))
            {
                g_u8SignalState = ATV_INVALID_STATUS;                
            }

#ifdef SUPPORT_FACTORY_AUTO_TEST
			if(APP_Factory_GetAutoTestOnOff() == TRUE)
			{
				extern void APP_SetPoweronEnterVersion(UINT8 value);
				extern UINT8 APP_GetPoweronEnterVersion(void);
				if(APP_GetPoweronEnterVersion() == 1)
				{
					APP_SetPoweronEnterVersion(0);
					if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_FM_FACTORYSETTING))
					{
						_ATVApp_ResetPopup_Channel();
						_ATVApp_CloseAllMenu();
						SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, APP_GUIOBJ_FM_FACTORYSETTING, 1);
						Factory_Ver_Debug();
					}
				}
			}
#endif
#ifdef SUPPORT_FACTORY_AUTO_TEST_MODE2
	#ifndef SUPPORT_FACTORY_AUTO_TEST_MODE2_EXTEND
			if(APP_Factory_GetAutoTestOnOff() == TRUE)
			{
				if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_FAC_AUTOTEST))
				{
					_ATVApp_ResetPopup_Channel();
					_ATVApp_CloseAllMenu();
					SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, APP_GUIOBJ_FAC_AUTOTEST, 1);
				}
			}
	#endif
#endif

			if ((!APP_Factory_CheckNeedReopenFm(SYS_APP_ATV))
#ifdef SUPPORT_HOTEL_MODE_INFOBANNER_SHOW_CONTROL
				&&((!g_stFactoryHotelData.HotelModeOnOff)||(g_stFactoryHotelData.ShowInfoBar))
#endif
#ifdef SUPPORT_FACTORY_AUTO_TEST_MODE2
				&&(APP_Factory_GetAutoTestOnOff() == FALSE)
#endif
				)
            {
                if ((!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_INPUTINFO))
                    && (!(APP_MenuMgr_Exist_Main_Menu()))
                   )
                {
                    _ATVApp_HidePopupDisplay();
					if(((APP_SOURCE_ATV == eSourType)
						|| (eSourType >= APP_SOURCE_SCART && eSourType <= APP_SOURCE_PC)
						||(APP_SOURCE_ANDRO== eSourType) ||(APP_SOURCE_DVD== eSourType))
#if defined(CONFIG_SUPPORT_NES_GAME) || defined(CONFIG_OSD_GAME_SUPPORT)
                      && (eSourType != APP_SOURCE_GAME)
#endif
#ifdef CONFIG_BLUETOOTH_SUPPORT
                      && (eSourType != APP_SOURCE_BLUETOOTH)
#endif
						)
					{
                    	SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV,
							ATV_GUIOBJ_INPUTINFO, 0);
					}
                }
            }

            AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_TVINFO, 0,
                            sizeof(APP_SETTING_TVInfo_t), &(g_stTVInfoData));
			AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_VARIATIONAL, 0,
							sizeof(APP_SETTING_Variational_t), &(g_stVariationalData));

            if (eSourType == APP_SOURCE_HDMI
				|| eSourType == APP_SOURCE_HDMI1
				|| eSourType == APP_SOURCE_HDMI2)
            {
                g_noSignaldebouncetime = HDMI_NO_SIGNAL_BOUNCE_TIME;
            }
			else if (eSourType == APP_SOURCE_ATV)
            {
                g_noSignaldebouncetime = ATV_NO_SIGNAL_BOUNCE_TIME;
            }
            else
            {
                g_noSignaldebouncetime = NO_SIGNAL_BOUNCE_TIME;
            }

#if defined(CONFIG_SUPPORT_NES_GAME)|| defined(CONFIG_OSD_GAME_SUPPORT)
            if (eSourType == APP_SOURCE_GAME)
            {
                if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_FM_FACTORYSETTING))
                {
                    SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, APP_GUIOBJ_GAMEMENU, GAME_TYPE_LAYER1);
                }
            }
#endif
#ifdef CONFIG_BLUETOOTH_SUPPORT
		if (eSourType == APP_SOURCE_BLUETOOTH)
		{
		      if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_FM_FACTORYSETTING))
		      {
		           SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, APP_GUIOBJ_BLUETOOTH, 0);
		      }
		      AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_USERINFO, 0,
		                  sizeof(APP_SETTING_UserInfo_t), &(g_stUserInfoData));
			  APP_Audio_SetMute(g_stUserInfoData.Mute, TRUE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
		}
#endif
		#ifdef CONFIG_SMART_MODULE_SUPPORT
			if((APP_SOURCE_HDMI + CONFIG_HDMI_SMART_PORT) == eSourType)
				MID_DISP_DTVSetHDMIScreenMode(2);
			else
				MID_DISP_DTVSetHDMIScreenMode(0);
		#endif
		   	}
            break;

        case APP_GLOBAL_EVENT_SET_UNMUTE:
            _ATVApp_SetMuteProcess(FALSE);
			if (bSetUnMuteFlag == TRUE)
			{
				bSetUnMuteFlag = FALSE;
				ATVApp_CheckProgramType(FALSE);
			}
            break;

        case APP_GLOBAL_EVENT_OBJECT_OPEN:
            if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, dParam & 0XFFFF))
            {
                SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, dParam & 0XFFFF, dParam >> 16);
            }
            break;

        case APP_GLOBAL_EVENT_OBJECT_CLOSE:
            if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, dParam))
            {
                SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, dParam);
            }
            break;

        case APP_GLOBAL_EVENT_OPEN_HOMEMODE:
#if defined(CELLO_cello) && defined(SUPPORT_HOMEMODE)
			AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_USERINFO, 0,
							sizeof(APP_SETTING_UserInfo_t), &(g_stUserInfoData));
			if ((!g_stUserInfoData.AutoInstalled)&&(g_stUserInfoData.AutoInstalledHomeMode))
			{
				if (1
					#ifdef CONFIG_SUPPORT_USB_UPGRADE
					&&(!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_SOFTWARE_UPGRADE))
					#endif
					)
				{
					//Close all menu before show Auto Installation menu
					_ATVApp_CloseAllMenu();
#ifdef SUPPORT_FACTORY_AUTO_TEST
					if(APP_Factory_GetAutoTestOnOff() == FALSE)
#endif
					{
					}
				}
			}
#endif
            break;
        case APP_GLOBAL_EVENT_OPEN_POPUP:
            _ATVAPP_ShowPopup(dParam);
            break;

        case APP_GLOBAL_EVENT_CLOSE_POPUP:
            ATVApp_ClosePopup(dParam, UI_EVENT_NULL);
            break;

        case APP_GLOBAL_EVENT_POPMSG_PWD:
		{
#ifdef CONFIG_POWER_ON_TV_LOCK

            if(g_stSetupData.PowerOnTVLock == APP_SWITCH_ON && APP_GUIOBJ_GET_PASSWORDRight_Flag() == TRUE)
            {
                SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_ATV,
                   	APP_ATV_GLOBAL_EVENT_ATV_ONRUN | PASS_TO_SYSAPP, TRUE);
                break;
            }
#endif
#ifdef CONFIG_VCHIP_SUPPORT
			if(VchipNeedOpenFlag)
			{
				VchipNeedOpenFlag = FALSE;
				if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_VCHIPSET))
	            {
	                _ATVApp_Exit_All_Menu(0);
	            }
	            else
	            {
	                _ATVApp_CloseAllMenu();
	                _ATVApp_ResetPopup_Channel();
	                SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, ATV_GUIOBJ_VCHIPSET, VCHIPSET_NON_FROM_SETUP);
	            }
				break;
			}
            if(VchipLockFlag == TRUE)
            {
                if(PreVchipLockFlag == TRUE)
                {
                    PreVchipLockFlag = FALSE;
                }
                _ATVApp_HidePopupDisplay();
                /* mute/unmute audio */
                AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_USERINFO, 0,
                    sizeof(APP_SETTING_UserInfo_t), &(g_stUserInfoData));
                APP_Audio_SetMute(g_stUserInfoData.Mute, TRUE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
                APP_Video_SetMute(TRUE, TRUE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
                APP_ATV_Playback_SetForcePlay();
            }
#endif
            break;
        }
		
#ifdef CONFIG_AUTO_DETECT_VALID_SOURCE
		case APP_GLOBAL_EVENT_SET_APP_SOURCE:
			{
				APP_GUIOBJ_Source_AutoDetectSourceDisable();
				_ATVApp_ResetPopup_Channel();
				_ATVApp_CloseAllMenu();
				APP_GUIOBJ_Source_SetAppSource(dParam);
				APP_GUIOBJ_Source_AutoDetectSourceEnable();
			}
			break;
#endif			
		case APP_ATV_GLOBAL_EVENT_SCARTINPUT_CHANGE:
			eScartPin16Status = App_SCARTIN_GetPin16Satus();
			if (eScartPin16Status != dParam)
			{
				App_SCARTIN_SetPin16Satus(dParam);
			}
			break;

		case APP_ATV_GLOBAL_EVENT_HDMIDVI_CHANGE:
			if (dParam != APP_MODE_UNDEFINE && (eSourType >= APP_SOURCE_HDMI && eSourType <= APP_SOURCE_HDMI2))
			{
				APP_Audio_HDMITypeChange(APP_HDMI_MODE_CHG,dParam);
                /*set current aspect ratio*/
               UINT8 u8AspectRatioIndex = 0;
               APP_Video_AspectRatioType_e u8AspectRatioType = APP_VIDEO_ASPECT_RATIO_MAX;
               APP_Video_AspectSystemSetRead(&u8AspectRatioIndex);
               u8AspectRatioType = APP_Video_AspectRatioIndexMappingToType(u8AspectRatioIndex);
               APP_Video_Set_AspectRatio(u8AspectRatioType);
               /*end*/
                #ifdef CONFIG_ENABLE_MIR
                MID_DISP_DTVSetMointerMode(FALSE, MID_DISP_ScartOutput_FORMAT_PAL, FALSE);
                #endif

                /*Set SPDIF output when HDMI audio_src has been known*/
                 if (eSourType >= APP_SOURCE_HDMI && eSourType <= APP_SOURCE_HDMI2)
                {
                        if (dParam != PreHDMIMODE)
                        {
				            UINT8 u8Value = g_stVariationalData.Volume;
				            APP_Audio_SetVolume(u8Value);

							UINT32 u32Spdif;
							APP_GUIOBJ_Sound_GetSPDIF(&u32Spdif);
							APP_GUIOBJ_Sound_SetSPDIF(u32Spdif);
                        }
                        PreHDMIMODE = dParam;
                }
#ifdef SUPPORT_FACTORY_AUTO_TEST_MODE2
				if(APP_Factory_GetAutoTestOnOff() == FALSE)
#endif
				{
    					if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_INPUTINFO))
    					{
                            INT32 dFocusedIndex;
                            if (SYSTEM_APP_NO_FOCUSED_GUIOBJ == SYSAPP_GOBJ_GetFocusedGUIObject(SYS_APP_ATV, &dFocusedIndex))
                            {
    						    SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV,
    						    		ATV_GUIOBJ_INPUTINFO, 0);
                            }
    					}
    					else
    					{
    						SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_ATV, APP_ATV_GLOBAL_EVENT_INFO_UPDATE, 0);
    					}
				}
				if (bSetUnMuteFlag == TRUE)
				{
					bSetUnMuteFlag = FALSE;
					APP_Video_SetMute(FALSE, TRUE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
				}
			}
			break;
		case APP_ATV_GLOBAL_EVENT_HDMIACPTYPE_CHANGE:
			if (dParam != APP_ACP_RESERVED&&(eSourType >= APP_SOURCE_HDMI && eSourType <= APP_SOURCE_HDMI2))
			{
				APP_Audio_HDMITypeChange(APP_ACP_TYPE_CHG,dParam);
			}
			break;
#ifdef SUPPORT_CEC_TV
		case APP_ATV_GLOBAL_EVENT_HDMIPORT_STATUS:
			CECTV_HDMIPortStatus(dParam);
			break;
#endif
#if defined(CONFIG_HEADPHONE_DETECT_BY_ISR) || defined(CONFIG_HPDET_BY_SWTIMER)
		case APP_GLOBAL_EVENT_HEADPHONE_PLUG_IN:
			printf("%s:%d ----- hp plug in\n",__FUNCTION__,__LINE__);
			APP_Audio_Set_HPStatus(APP_Audio_Headphone_PlugIn);
			APP_Audio_SetMuteSpeakerWithoutAMP(TRUE);
			APP_Audio_SetMuteAMP(TRUE);
			#ifdef CONFIG_HP_OUT_FROM_SPEAKER_PIN
			APP_Audio_SetMuteDACSpeak(FALSE);
			#elif defined(CONFIG_HP_OUT_FROM_LINEOUT_PIN)
			APP_Audio_SetMuteDACSpeak(TRUE);
			APP_Audio_SetMuteDACLineOut(FALSE);			
			#else
			APP_Audio_SetMuteDACSpeak(TRUE);
			APP_Audio_SetMuteDACHeadohone(FALSE);		
			#endif

			AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_USERINFO, 0,
							sizeof(APP_SETTING_UserInfo_t), &(g_stUserInfoData));
			MID_DISP_DTVGetVideoMute(&eMuteSt);
			AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FEATURE, 0,
			sizeof(APP_SETTING_Feature_t), &(g_stFeatureData));
			if ((g_stUserInfoData.Mute == FALSE) && (eMuteSt == MID_DISP_UNMUTE)&& ATVApp_GetSignalState() == ATV_AVAILABLE_SIGNAL && g_stFeatureData.SpeakerPreference == APP_HDMILINK_TVSPEAKER)

				APP_Audio_SetMuteSpeakerWithoutAMP(FALSE);
			AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_VARIATIONAL, 0,
				sizeof(APP_SETTING_Variational_t), &(g_stVariationalData));
			APP_Audio_SetVolume(g_stVariationalData.Volume);
			break;
		case APP_GLOBAL_EVENT_HEADPHONE_PLUG_OUT:
			printf("%s:%d ----- hp plug out\n",__FUNCTION__,__LINE__);
			APP_Audio_Set_HPStatus(APP_Audio_Headphone_PlugOut);
			APP_Audio_SetMuteDACHeadohone(TRUE);
			#if defined(CONFIG_HP_OUT_FROM_LINEOUT_PIN)
			APP_Audio_SetMuteDACLineOut(TRUE);	
			#endif		
			APP_Audio_SetMuteSpeakerWithoutAMP(TRUE);
			APP_Audio_SetMuteDACSpeak(FALSE);
			APP_Audio_SetMuteAMP(FALSE);
			AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_USERINFO, 0,
							sizeof(APP_SETTING_UserInfo_t), &(g_stUserInfoData));
			MID_DISP_DTVGetVideoMute(&eMuteSt);

			AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FEATURE, 0,
			sizeof(APP_SETTING_Feature_t), &(g_stFeatureData));
			if ((g_stUserInfoData.Mute == FALSE) && (eMuteSt == MID_DISP_UNMUTE)&& ATVApp_GetSignalState() == ATV_AVAILABLE_SIGNAL && g_stFeatureData.SpeakerPreference == APP_HDMILINK_TVSPEAKER)
			{
				APP_Audio_SetMuteSpeakerWithoutAMP(FALSE);
			}
			AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_VARIATIONAL, 0,
				sizeof(APP_SETTING_Variational_t), &(g_stVariationalData));
			APP_Audio_SetVolume(g_stVariationalData.Volume);
			break;
#endif

        case APP_GLOBAL_EVENT_ADC_TURNOFFSOUND:
            APP_Audio_SetMuteAll(TRUE);
            break;
#ifdef CONFIG_QSD
		case APP_GLOBAL_EVENT_QSD_MEDIA_PLAY:
			{
				void MM_MediaQsd_SetTestFlag(BOOLEAN bFlag, UINT32 dParam);
				MM_MediaQsd_SetTestFlag(TRUE, dParam);
				_ATVApp_CloseAllMenu();
				_ATVApp_ResetPopup_Channel();
#ifdef CONFIG_MULTIMEDIA1_SUPPORT
                {
                    MediaSourceNumber_e MediaType = 0;
                    UINT8 u8Port;
                    int i32Cnt = MID_PartitionList_GetMountedCount();
                    if (i32Cnt > 0)
                    {
                        u8Port = MID_PartitionList_GetMountPort(0);
                        extern MediaSourceNumber_e MM_HomePage_GetMediaSourceNumberbyPort(UINT8 u8Port);
                        MediaType = MM_HomePage_GetMediaSourceNumberbyPort(u8Port);
                        if (MediaType == MEDIA_ONE)
                        {
                            APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_MEDIA);
                        }
                        else if (MediaType == MEDIA_TWO)
                        {
                            APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_MEDIA1);
                        }
                    }
                }
#else
				APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_MEDIA);
#endif
        }
			break;

		case APP_GLOBAL_EVENT_QSD_SET_SOURCE:
			_ATVApp_CloseAllMenu();
			_ATVApp_ResetPopup_Channel();
			APP_GUIOBJ_Source_SetAppSource(dParam);
			break;
#endif

#ifdef CONFIG_SUPPORT_TTX
		case FW_TT_NO_DATA:
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_TTX))
            {
                SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_TTX);
            }
#ifdef CONFIG_DTV_SUPPORT
			/*add by xm.zeng on 2013/10/17 for mantis id:0013769*/
			if(DVBApp_IsPopupExist(PLAYBACK_POPUP_MSG_SCRAMBLED))
			{
				break;
			}
#endif
			AL_TTX_Reset();
			break;
#endif
		case UI_EVENT_PIP_MENU:
        case UI_EVENT_MENU:
			AutoUpgrade = FALSE;
            MID_DISP_DTVGetPause(&bFreezeFlag);
            if (APP_MenuMgr_Exist_Main_Menu()
                || APP_MenuMgr_Exist_Factory_Menu()
				)
            {
                if (bFreezeFlag)
                {
                    SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, ATV_GUIOBJ_FREEZE, 0);
                }
                _ATVApp_Exit_All_Menu(0);
#ifdef CONFIG_BLUETOOTH_SUPPORT
                if (eSourType == APP_SOURCE_BLUETOOTH)
                {
                    if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_BLUETOOTH))
                    {
                       //Al_Bluetooth_Set_Action(BT_CMD_SET_BT_MODE, NULL, 0);
                       extern INT32 APP_GUIOBJ_Bluetooth_GetFocusItem(void);
                       SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, APP_GUIOBJ_BLUETOOTH, (APP_GUIOBJ_Bluetooth_GetFocusItem() |KeepConnected));
                    }
                }
#endif
            }
            else
            {
                _ATVApp_CloseAllMenu();
                _ATVApp_ResetPopup_Channel();
                if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_FREEZE))
                {
                    SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_FREEZE);
                }
#ifdef CONFIG_CC_SUPPORT
                /*cc ui can't coexist with menu ui.*/
                if(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_CC))
                {
                    SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_CC);
                }
#endif
                if (bFreezeFlag)
                {
                    MID_DISP_DTVSetPause(FALSE);
                }
#ifdef CONFIG_BT_RDA5856
				if(UI_EVENT_PIP_MENU == dMessage)
				{
					SYSAPP_GOBJ_CreateGUIObject_WithPara(
						SYS_APP_ATV, APP_GUIOBJ_BT_SETTING, BT_FROM_OPTION);
				}
				else
#endif
				{
					SYSAPP_GOBJ_CreateGUIObject_WithPara(
						SYS_APP_ATV, APP_GUIOBJ_MAINMENU, FIRST_ENTER_MAINMENU);
				}
            }
            break;

        case UI_EVENT_SOURCE:
            if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_SOURCE))
            {
                _ATVApp_Exit_All_Menu(0);
#ifdef CONFIG_BLUETOOTH_SUPPORT
              if (eSourType == APP_SOURCE_BLUETOOTH)
              {
                  if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_BLUETOOTH))
                  {
                      //Al_Bluetooth_Set_Action(BT_CMD_SET_BT_MODE, NULL, 0);
                      extern INT32 APP_GUIOBJ_Bluetooth_GetFocusItem(void);
                      SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, APP_GUIOBJ_BLUETOOTH, (APP_GUIOBJ_Bluetooth_GetFocusItem() |KeepConnected));
                  }
              }
#endif
            }
            else
            {
                _ATVApp_CloseAllMenu();
                _ATVApp_ResetPopup_Channel();
                SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, APP_GUIOBJ_SOURCE, 0);
            }
            break;
        case UI_EVENT_TV_DVD:
            _ATVApp_CloseAllMenu();
            _ATVApp_ResetPopup_Channel();
            if (eSourType == APP_SOURCE_DVD)
            {
                APP_Source_Type_t eLastSourType = APP_SOURCE_MAX;
                APP_GUIOBJ_Source_GetLastSource(&eLastSourType);
                APP_GUIOBJ_Source_SetAppSource(eLastSourType);
            }
            else
            {
                APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_DVD);
            }
            break;

		case UI_EVENT_OPEN_FACTORY:
            if (APP_MenuMgr_Exist_Factory_Menu())
            {
                _ATVApp_Exit_All_Menu(0);
            }
            else
            {
                _ATVApp_CloseAllMenu();
                _ATVApp_ResetPopup_Channel();
                SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, APP_GUIOBJ_FM_FACTORYSETTING, FIRST_ENTER_FACTORY);
            }
            break;
        case UI_EVENT_FACTORY:
            if (APP_MenuMgr_Exist_Factory_Menu())
            {
                _ATVApp_Exit_All_Menu(0);
            }
            else
            {
                if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_MAINMENU))
		    	{
                    _ATVApp_CloseAllMenu();
                    _ATVApp_ResetPopup_Channel();
                    SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, APP_GUIOBJ_FM_FACTORYSETTING, FIRST_ENTER_FACTORY);
		    	}
            }
            break;
#if 1//ll.jing mark for fm
        case UI_EVENT_FAC_HOTEL:

            if (APP_MenuMgr_Exist_Factory_Menu())
            {
                _ATVApp_Exit_All_Menu(0);
            }
            else
            {
			    if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_MAINMENU))
		    	{
	                _ATVApp_CloseAllMenu();
	                _ATVApp_ResetPopup_Channel();
	                SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, APP_GUIOBJ_FM_HOTELSETTING, ENTER_HOTELSET_NOTFROM_FACTORYMENU);
		    	}
            }
            break;
#endif
#ifdef CONFIG_SUPPORT_USB_UPGRADE
		case UI_EVENT_CHECK_UPGRADE:
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_SOFTWARE_UPGRADE))
			{
				atv_printf("upgrade is running!");
				break;
			}
			else
			{
                if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_SOURCE))
                {
                    _ATVApp_CloseAllMenu();
                    _ATVApp_ResetPopup_Channel();
					SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, APP_GUIOBJ_SOFTWARE_UPGRADE, SOFTWARE_UPGRADE_FROM_PASSWORD);
                }
			}
			break;
#endif
        case UI_EVENT_POWER:
            MAINAPP_SendGlobalEvent(UI_EVENT_POWER, AL_POWER_STATE_OFF);
            break;
        case UI_EVENT_EPG:
            //_ATVAPP_ShowPopup(ATV_APP_POP_MSG_NOT_AVAILABLE);
            break;
        case UI_EVENT_MUTE:
#ifdef SUPPORT_CEC_TV
            AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FEATURE, 0,
                            sizeof(APP_SETTING_Feature_t), &(g_stFeatureData));
            if ((APP_SWITCH_ON == g_stFeatureData.Enable_HDMILink)
#ifdef SUPPORT_AMPLIFIER_CONTROL
                && (APP_SWITCH_ON == g_stFeatureData.AmplifierControl)
#endif
                && (APP_HDMILINK_AMPLIFIER == g_stFeatureData.SpeakerPreference) && APP_GUIOBJ_Source_GetAmplifierPort())
            {
                if (CECTV_GetCECEnable() == CECTV_ENABLE && CECTV_GetHDMISystemAudioMode() && g_u32MuteIconHandle >= MUTE_KEY_INTERVAL)
				{
					APP_Set_CECTV_Mute_Status(EVENT_CECTV_SET_MUTE_STATUS_MUTE);
					if (APP_Get_HDMICEC_AMP_Mute_Status() == FALSE)
						APP_Set_HDMICEC_AMP_Mute_Status(TRUE);
					else
						APP_Set_HDMICEC_AMP_Mute_Status(FALSE);
					APP_GUIOBJ_Mute_MuteKeyHandler();
					g_u32MuteIconHandle = 0;
					break;
				}
				else if(g_u32MuteIconHandle < MUTE_KEY_INTERVAL)//Don't handle mute icon
				{
					break;
				}

            }
#endif
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_SLEEP_INFO))
			{
				APP_GUIOBJ_SleepTimer_Reset();
				SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, APP_GUIOBJ_SLEEP_INFO);

#ifdef CONFIG_BLUETOOTH_SUPPORT
                if (eSourType == APP_SOURCE_BLUETOOTH)
                {
                    if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_BLUETOOTH))
                    {
                       SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, APP_GUIOBJ_BLUETOOTH, 0);
                    }
                }
#endif
			}
			APP_GUIOBJ_Mute_MuteKeyHandler();
            break;
#ifdef CONFIG_VCHIP_SUPPORT
        case UI_EVENT_VCHIP:
			if(APP_SOURCE_ATV == eSourType || APP_SOURCE_AV == eSourType)
			{
				VchipNeedOpenFlag = TRUE;
	        	_ATVAPP_ShowPopup(ATV_APP_POP_MSG_CHECKPWD);
			}
            break;
#endif
#ifdef SUPPORT_CEC_TV
		case DMN_EVENT_CECTV_SET_MUTE_STATUS:
			AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FEATURE, 0,
				sizeof(APP_SETTING_Feature_t), &(g_stFeatureData));
			if ((APP_SWITCH_ON == g_stFeatureData.Enable_HDMILink)
#ifdef SUPPORT_AMPLIFIER_CONTROL
				&& (APP_SWITCH_ON == g_stFeatureData.AmplifierControl)
#endif
				&& (APP_HDMILINK_AMPLIFIER == g_stFeatureData.SpeakerPreference) && APP_GUIOBJ_Source_GetAmplifierPort())
			{
				if (CECTV_GetCECEnable() == CECTV_ENABLE)
				{
					APP_Process_CECTV_Mute_Status(dParam);
					 if(g_stUserInfoData.Mute == TRUE && APP_Get_HDMICEC_AMP_Mute_Status() == FALSE)
					 {
					      APP_GUIOBJ_Mute_MuteKeyHandler();
					 }
					     else if(g_stUserInfoData.Mute == FALSE && APP_Get_HDMICEC_AMP_Mute_Status() == TRUE)
					 {
					      APP_GUIOBJ_Mute_MuteKeyHandler();
					 }
				}
			}
			break;

		case DMN_EVENT_CECTV_SET_SYSTEMAUDIO_STATUS:
			APP_Process_CECTV_Control_Status_From_Amp(dParam);
			break;

		case DMN_EVENT_CECTV_SET_DEVICE_OSDNAME:
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_INPUTINFO)
				||SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_SOURCE)
				||SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_SOURCE_CEC)
#ifdef SUPPORT_CEC_TV
				||SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_HDMI_LINK)
#endif
#ifdef CONFIG_BT_RDA5856
				|| (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_BT_SETTING))
				|| (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_BT_DEVICELIST))
#endif
				||SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_MAINMENU))
			{
				break;
			}
			_ATVApp_CloseAllMenu();
			_ATVApp_ResetPopup_Channel();
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_FREEZE))
			{
				SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_FREEZE);
			}
			MID_DISP_DTVGetPause(&bFreezeFlag);
			if (bFreezeFlag)
			{
				MID_DISP_DTVSetPause(FALSE);
			}

			//SYSAPP_GOBJ_CreateGUIObject_WithPara(
			//SYS_APP_ATV, APP_GUIOBJ_CEC_DEVICE_INSERT, dParam);
			break;
#endif

        case UI_EVENT_EXIT:
        case UI_EVENT_RETURN:
            AutoUpgrade = FALSE;
		    bAutoScanPassword = FALSE;
            _ATVApp_ResetPopup_Channel();
            _ATVApp_Exit_All_Menu(0);
#ifdef CONFIG_BLUETOOTH_SUPPORT
          if (eSourType == APP_SOURCE_BLUETOOTH)
          {
              if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_BLUETOOTH))
              {
                  //Al_Bluetooth_Set_Action(BT_CMD_SET_BT_MODE, NULL, 0);
                  extern INT32 APP_GUIOBJ_Bluetooth_GetFocusItem(void);
                  SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, APP_GUIOBJ_BLUETOOTH, (APP_GUIOBJ_Bluetooth_GetFocusItem() |KeepConnected));
              }
          }
#endif
#if defined(CONFIG_SUPPORT_NES_GAME)|| defined(CONFIG_OSD_GAME_SUPPORT)
            if (eSourType == APP_SOURCE_GAME)
            {
                if(!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_GAMEMENU))
                {
                    SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, APP_GUIOBJ_GAMEMENU,GAME_TYPE_LAYER1);
                }
            }
#endif
            break;

        case UI_EVENT_CH_UP:
        case UI_EVENT_CH_DN:
            break;

        case UI_EVENT_RECALL:
            break;

        case APP_ATV_INTRA_EVENT_ZAPPING:
            _ATVApp_Zapping(dParam, FALSE);
			break;

#ifdef CONFIG_SUPPORT_ATV_SCAN_NTSCM_PALM_N
        case UI_EVENT_AD:
            if (APP_GUIOBJ_Source_GetCurATVType() == ATV_TYPE_AIR)
            {
                APP_GUIOBJ_Source_StoreATVType(ATV_TYPE_CATV);
                _ATVApp_CloseAllMenu();
                _ATVApp_ResetPopup_Channel();
                APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_ATV);
            }
            else
            {
                APP_GUIOBJ_Source_StoreATVType(ATV_TYPE_AIR);
                _ATVApp_CloseAllMenu();
                _ATVApp_ResetPopup_Channel();
                APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_ATV);
            }
            break;
#endif
		case UI_EVENT_HDMI:
			if(eSourType != APP_SOURCE_HDMI)
			{
				_ATVApp_CloseAllMenu();
				_ATVApp_ResetPopup_Channel();
				APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_HDMI);
			}
			break;

		case UI_EVENT_PC:
			if(eSourType != APP_SOURCE_PC)
			{
				_ATVApp_CloseAllMenu();
				_ATVApp_ResetPopup_Channel();
				APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_PC);
			}
			break;
		case UI_EVENT_ATV:
			if(eSourType != APP_SOURCE_ATV)
			{
				_ATVApp_CloseAllMenu();
				_ATVApp_ResetPopup_Channel();
				APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_ATV);
			}
			break;
		case UI_EVENT_AV:
			if(eSourType != APP_SOURCE_AV)
			{
				_ATVApp_CloseAllMenu();
				_ATVApp_ResetPopup_Channel();
				APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_AV);
			}
			else
			{
				if(APP_GOBJ_Source_SourceCheck(APP_SOURCE_AV1) == SP_SUCCESS)
				{
					_ATVApp_CloseAllMenu();
					_ATVApp_ResetPopup_Channel();
					APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_AV1);
				}
			}
			break;
#ifdef CELLO_REMOTE_KEY
		case UI_EVENT_INITIAL:
		{
            _ATVApp_CloseAllMenu();
            _ATVApp_ResetPopup_Channel();
			//SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, APP_GUIOBJ_INITINSTALL, 0);
			break;
		}
		case UI_EVENT_DTV:
		{
			_ATVApp_CloseAllMenu();
			_ATVApp_ResetPopup_Channel();
			APP_GUIOBJ_Channel_SetRFType(FRONTEND_CONNECT_TYPE_DVB_T, AL_DB_INVALIDHDL);
			APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_DTV);
			break;
		}
		case UI_EVENT_SATELLITE:
		{
			_ATVApp_CloseAllMenu();
			_ATVApp_ResetPopup_Channel();
			APP_GUIOBJ_Channel_SetRFType(FRONTEND_CONNECT_TYPE_DVB_S, AL_DB_INVALIDHDL);
			APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_DTV);
			break;
		}
		case UI_EVENT_CABLE:
		{
			_ATVApp_CloseAllMenu();
			_ATVApp_ResetPopup_Channel();
			APP_GUIOBJ_Channel_SetRFType(FRONTEND_CONNECT_TYPE_DVB_C, AL_DB_INVALIDHDL);
			APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_DTV);
			break;
		}
		case UI_EVENT_HDMI:
			_ATVApp_CloseAllMenu();
			_ATVApp_ResetPopup_Channel();
			if(eSourType != APP_SOURCE_HDMI && eSourType != APP_SOURCE_HDMI1 &&
				eSourType != APP_SOURCE_HDMI2)
			{
				APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_HDMI);
			}
			else if(eSourType == APP_SOURCE_HDMI)
			{
				APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_HDMI1);
			}
			else if(eSourType == APP_SOURCE_HDMI1)
			{
				APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_HDMI2);
			}
			else if(eSourType == APP_SOURCE_HDMI2)
			{
				APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_HDMI);
			}
			break;

		case UI_EVENT_DVD:
			if(eSourType != APP_SOURCE_DVD)
			{
				_ATVApp_CloseAllMenu();
				_ATVApp_ResetPopup_Channel();
				APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_DVD);
			}
			else
			{
				// Show DVD MainMenu.
			}
			break;

#endif
		case UI_EVENT_ENTER:
        case UI_EVENT_CHLIST:
            if (eSourType == APP_SOURCE_ATV)
            {
            }
            else
            {
                //_ATVAPP_ShowPopup(ATV_APP_POP_MSG_NOT_AVAILABLE);
            }
            break;

#ifdef SUPPORT_SET_FAVPROGRAM_BY_HOTKEY
		case UI_EVENT_SETFAV:            
			break;
#endif
        case UI_EVENT_FAV:
			AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_CHANNEL, 0,
			        sizeof(APP_SETTING_Channel_t), &(g_stChannelData));
            if (eSourType == APP_SOURCE_ATV)
            {
            }
            else
            {
                //_ATVAPP_ShowPopup(ATV_APP_POP_MSG_NOT_AVAILABLE);
            }
            break;

        case UI_EVENT_FAV_UP:
        case UI_EVENT_FAV_DN:
            if (eSourType == APP_SOURCE_ATV)
        	{
        	}
            else
            {
                _ATVAPP_ShowPopup(ATV_APP_POP_MSG_NOT_AVAILABLE);
            }
            break;
        case UI_EVENT_DISPLAY:
#ifdef SUPPORT_HOTEL_MODE_INFOBANNER_SHOW_CONTROL
			if((g_stFactoryHotelData.HotelModeOnOff)&&(!g_stFactoryHotelData.ShowInfoBar))
				break;
#endif
            if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_INPUTINFO))
            {
                SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_INPUTINFO);
            }
            else
            {				
				#ifdef CONFIG_SUPPORT_TTX
                if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_TTXCLOCK))
                {
                    SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_TTXCLOCK);
                }
				#endif
				if (ATVApp_IsPopupExist(PLAYBACK_POPUP_MSG_NO_SIGNAL))
                {
                    ATVApp_ClosePopup(PLAYBACK_POPUP_MSG_NO_SIGNAL, UI_EVENT_NULL);
                }

                if (ATVApp_IsPopupExist(PLAYBACK_POPUP_PWD_LOCKED))
                {
                    SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, ATV_GUIOBJ_INPUTINFO, 0);
                }
                else
                {
                    if (!ATVApp_IsPopupExist(PLAYBACK_POPUP_MSG_NO_SIGNAL))
                    {
                        _ATVApp_CloseAllMenu();
                    }

					PLF_VideoID_t eRetResolution;

					MID_TVFE_GetCurrentVideoInfo(NULL, &eRetResolution);
					if (eRetResolution == PLF_VIDEO_TIMING_ID_UNKNOW_FORMAT
						//|| eRetResolution == PLF_VIDEO_TIMING_ID_NO_SIGNAL
						|| eRetResolution == PLF_VIDEO_TIMING_ID_NOT_STANDARD_FORMAT)
					{
						_ATVAPP_ShowPopup(ATV_APP_POP_MSG_NOT_SUPPORT_MODE);
					}
					else
					{
                		SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, ATV_GUIOBJ_INPUTINFO, 1);
					}
                }
            }
            break;

        case UI_EVENT_AUDIO:
            break;

        case UI_EVENT_TEXT:
			if ((eSourType == APP_SOURCE_ATV)
				||((eSourType >= APP_SOURCE_SCART)
				  &&(eSourType <= APP_SOURCE_SVIDEO2)))
            {
                if (ATVApp_IsPopupExist(PLAYBACK_POPUP_MSG_NO_SIGNAL))
                {
                    //_ATVAPP_ShowPopup(ATV_APP_POP_MSG_NOT_AVAILABLE);
                    break;
                }
#ifdef CONFIG_SUPPORT_TTX
				al_bool bTtSignalStatus = al_false;
#endif
				MID_InputInfo_t TimingInfo;
                MID_TVFE_GetCurrentVideoInfo(&TimingInfo, NULL);
                printf("TimingInfo.eCvd2ColorFormat==%d\n",TimingInfo.eCvd2ColorFormat);

				switch(TimingInfo.eCvd2ColorFormat)
				{
#ifdef CONFIG_CC_SUPPORT
					case MID_CVD2_STD_NTSC_M:
					case MID_CVD2_STD_PAL_M:
					case MID_CVD2_STD_NTSC_443:
	#ifdef CONFIG_PALN_SUPPORT_CC
					case MID_CVD2_STD_PAL_CN:
	#endif
						atv_printf("call create cc menu!\n");
						_ATVApp_CloseAllMenu();
						SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, ATV_GUIOBJ_CC_BANNER, 0);
						break;
#endif

#ifdef CONFIG_SUPPORT_TTX
					case MID_CVD2_STD_PAL:
					case MID_CVD2_STD_SECAM:
	#ifdef CONFIG_PALN_SUPPORT_TT
					case MID_CVD2_STD_PAL_CN:
	#endif
						AL_TTX_GetSignalStatus(&bTtSignalStatus);
						atv_printf("\n$$TTTT$$[%d] TTXStatus = %d\n", __LINE__,bTtSignalStatus);
						if (bTtSignalStatus == 1)
						{
							if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_TTX))
							{
								atv_printf("close atv ttx menu!\n");
								SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_TTX);
							}
							else
							{
								atv_printf("call create atv ttx menu!\n");
								_ATVApp_CloseAllMenu();
								if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_FREEZE))
								{
									SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_FREEZE);
									MID_DISP_DTVSetPause(FALSE);
								}
								SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, ATV_GUIOBJ_TTX, 0);
							}
						}
						else
						{
							_ATVAPP_ShowPopup(ATV_APP_POP_MSG_NO_TTX);
						}
						break;
#endif						
					default:
						_ATVAPP_ShowPopup(ATV_APP_POP_MSG_NOT_AVAILABLE);
						break;
				}
            }
            break;
#ifdef CONFIG_SUPPORT_TTX
#ifdef SUPPORT_CLOCKINFO_SHOW
        case UI_EVENT_DEVLIST:  //UI_EVENT_DEVLIST  clock key
            if ((eSourType == APP_SOURCE_ATV)
				||((eSourType >= APP_SOURCE_SCART)
				 &&(eSourType <= APP_SOURCE_SVIDEO2)))
            {
                if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_TTXCLOCK))
                {
                    atv_printf("Close TTX Clock menu.\n");
                    SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_TTXCLOCK);

                }
                else
                {
                	al_bool	bTtSignalStatus = al_false;
                	AL_TTX_GetSignalStatus(&bTtSignalStatus);
					if (bTtSignalStatus == al_true)
					{
						atv_printf("Create TTX Clock menu.\n");
						_ATVApp_CloseAllMenu();
						SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, ATV_GUIOBJ_TTXCLOCK, 0);
            		}
					else
					{
						atv_printf("No TTX Data.\n");
						//_ATVAPP_ShowPopup(ATV_APP_POP_MSG_NOT_AVAILABLE);
					}
                }
            }
            else
            {
                //_ATVAPP_ShowPopup(ATV_APP_POP_MSG_NOT_AVAILABLE);
            }
            break;
#endif
#endif
        case UI_EVENT_SUBTITLE:
			{
#ifdef CONFIG_SUPPORT_TTX
			al_bool bTtSignalStatus = al_false;
			AL_TTX_GetSignalStatus(&bTtSignalStatus);
			atv_printf("\n$$TTTT$$[%d]TTXSubStatus = %d\n", __LINE__,bTtSignalStatus);
			if (bTtSignalStatus == 1)
			{
				if(AL_TTX_SubtitleExistStatus() == AL_SUCCESS)
				{
					if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_TTX))
                    {
                        atv_printf("close  atv ttx menu!\n");
                        SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_TTX);
						TTXSubtitleExistFlag = FALSE;
                    }
					else
					{
                        atv_printf("create  atv ttx menu!\n");
					     _ATVApp_CloseAllMenu();
						if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_FREEZE))
						{
							SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_FREEZE);
							MID_DISP_DTVSetPause(FALSE);
						}
						TTXSubtitleExistFlag = TRUE;
						SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, ATV_GUIOBJ_TTX, 0);
					}
					break;
				}
			}
#endif
            //_ATVAPP_ShowPopup(ATV_APP_POP_MSG_NOT_AVAILABLE);
}
            break;

        case UI_EVENT_VOL_DN:
        case UI_EVENT_VOL_UP:
#ifdef SUPPORT_CEC_TV
            AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FEATURE, 0,
                            sizeof(APP_SETTING_Feature_t), &(g_stFeatureData));
            if ((APP_SWITCH_ON == g_stFeatureData.Enable_HDMILink)
#ifdef SUPPORT_AMPLIFIER_CONTROL
                && (APP_SWITCH_ON == g_stFeatureData.AmplifierControl)
#endif
                && (APP_HDMILINK_AMPLIFIER == g_stFeatureData.SpeakerPreference)
                && (APP_GUIOBJ_Source_GetAmplifierPort() != 0) && APP_Check_CEC_DEVICE_Status())
            {
                if (CECTV_GetCECEnable() == CECTV_ENABLE)
                {
                    if (dMessage == UI_EVENT_VOL_UP)
                    {
                        APP_Set_CECTV_Mute_Status(EVENT_CECTV_SET_MUTE_STATUS_VOLUME_UP);
                    }
                    else if (dMessage == UI_EVENT_VOL_DN)
                    {
                        APP_Set_CECTV_Mute_Status(EVENT_CECTV_SET_MUTE_STATUS_VOLUME_DOWN);
                    }
					ATVApp_VolumeKeyHandler(dMessage, TRUE);
                    break;
                }

            }
#endif
            ATVApp_VolumeKeyHandler(dMessage, FALSE);
            break;
		//case UI_EVENT_PIC_ASPECT:
        case UI_EVENT_PIC_MOD:
            AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FACTHOTEL, 0,
                sizeof(APP_SETTING_FactoryHotel_t), &(g_stFactoryHotelData));

            if (g_stFactoryHotelData.HotelModeOnOff == 1&&g_stFactoryHotelData.PictureLock == 1)
            {
                atv_printf("[%s] Picture Option has been Lock On!!\n",__FUNCTION__);
                break;
            }
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_FREEZE))
            {
                SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_FREEZE);
            }
            _ATVApp_CloseAllMenu();
            if (ATVApp_IsPopupExist(PLAYBACK_POPUP_MSG_NO_SIGNAL))
            {
                ATVApp_ClosePopup(PLAYBACK_POPUP_MSG_NO_SIGNAL, UI_EVENT_NULL);
            }
            SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, APP_GUIOBJ_BANNER, dMessage);
            break;

        case UI_EVENT_SND_MOD:
#ifdef CELLO_REMOTE_KEY
		case UI_EVENT_SOUND_MTS:
#endif
			//_APP_GUIOBJ_Sound_SetMuteStatus();
            AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FACTHOTEL, 0,
                sizeof(APP_SETTING_FactoryHotel_t), &(g_stFactoryHotelData));

            if (g_stFactoryHotelData.HotelModeOnOff == 1&&g_stFactoryHotelData.SoundLock== 1)
            {
                atv_printf("[%s] Sound Option has been Lock On!!\n",__FUNCTION__);
                break;
            }
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_FREEZE))
            {
                SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_FREEZE);
            }
            _ATVApp_CloseAllMenu();
            if (ATVApp_IsPopupExist(PLAYBACK_POPUP_MSG_NO_SIGNAL))
            {
                ATVApp_ClosePopup(PLAYBACK_POPUP_MSG_NO_SIGNAL, UI_EVENT_NULL);
            }
            SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, APP_GUIOBJ_BANNER, dMessage);
            break;


        case UI_EVENT_ASPECT:
            AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FACTHOTEL, 0,
                sizeof(APP_SETTING_FactoryHotel_t), &(g_stFactoryHotelData));

            if (g_stFactoryHotelData.HotelModeOnOff == 1&&g_stFactoryHotelData.PictureLock == 1)
            {

                atv_printf("[%s] Picture Option has been Lock On!!\n",__FUNCTION__);
                break;
            }

            if (g_u8SignalState != ATV_AVAILABLE_SIGNAL)
            {
                break;
            }
            if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_FREEZE))
            {
                SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_FREEZE);
            }

            MID_DISP_DTVGetPause(&bFreezeFlag);
            if (bFreezeFlag)
            {
                MID_DISP_DTVSetPause(FALSE);
            }
        case UI_EVENT_SLEEP:
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_FREEZE))
            {
                SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_FREEZE);
            }
            _ATVApp_CloseAllMenu();
            if (ATVApp_IsPopupExist(PLAYBACK_POPUP_MSG_NO_SIGNAL))
            {
                ATVApp_ClosePopup(PLAYBACK_POPUP_MSG_NO_SIGNAL, UI_EVENT_NULL);
            }
            SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, APP_GUIOBJ_BANNER, dMessage);
            break;

#ifdef SUPPORT_FACTORY_AUTO_TEST
		case UI_EVENT_KEYPAD_DOWN:
		case UI_EVENT_KEYPAD_UP:
		case UI_EVENT_KEYPAD_SOURCE:
		case UI_EVENT_KEYPAD_LEFT:
		case UI_EVENT_KEYPAD_RIGHT:
		case UI_EVENT_KEYPAD_POWER:
		case UI_EVENT_KEYPAD_MENU:
			{
				extern int APP_Factory_GetAutoTestOnOff(void);
				if(APP_Factory_GetAutoTestOnOff() == TRUE)
				{
					if(!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV,APP_GUIOBJ_BANNER))
					{
						SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, APP_GUIOBJ_BANNER, dMessage);
					}
				}
			}
			break;
#endif

        case UI_EVENT_0:
        case UI_EVENT_1:
        case UI_EVENT_2:
        case UI_EVENT_3:
        case UI_EVENT_4:
        case UI_EVENT_5:
        case UI_EVENT_6:
        case UI_EVENT_7:
        case UI_EVENT_8:
        case UI_EVENT_9:
        case UI_EVENT_10:
#ifdef SUPPORT_FACTORY_AUTO_TEST
			if(dMessage == UI_EVENT_10)
			{
				if(APP_Factory_GetAutoTestOnOff() == TRUE)
				{
					APP_Factory_SetAutoTestSourceChange(dMessage);
					break;
				}
			}
#endif            
            break;

        case UI_EVENT_FREEZE:
        {
            if (bSetUnMuteFlag == FALSE && bSetVIPFINISHFlag == TRUE)
            {
                Boolean PauseStatus = FALSE;
                MID_DISP_DTVGetPause(&PauseStatus);
                if (PauseStatus)
                {
                    SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_FREEZE);
                    MID_DISP_DTVSetPause(FALSE);
                }
                else
                {
                    if (ATVApp_GetSignalState() != ATV_AVAILABLE_SIGNAL)
                    {
                        break;
                    }
                    _ATVApp_HidePopupDisplay();
                    if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_BANNER))
                    {
                        SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, APP_GUIOBJ_BANNER);
                    }
                    SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, ATV_GUIOBJ_FREEZE, 0);
                    MID_DISP_DTVSetPause(TRUE);
                }
            }
        }
        break;
#ifdef SUPPORT_AUTO_SOURCE_TEST
		case UI_EVENT_AUTOSOURCE:
		{
			extern APP_Source_Type_t g_AutoSourceTable[APP_SOURCE_MAX];
			APP_Source_Type_t eSourType = APP_SOURCE_MAX;
			extern void APP_GOBJ_Source_Get_Support_AutoSource(void);
			g_u8CurSourceIndex = 0;
			if(TRUE == APP_Factory_GetAutoSourceTestOnOff())
			{
				APP_Factory_SetAutoSourceTestOnOff(FALSE);
			}
			else
			{
				APP_GOBJ_Source_Get_Support_AutoSource();
				APP_Factory_SetAutoSourceTestOnOff(TRUE);
				APP_GUIOBJ_Source_GetCurrSource(&eSourType);
				if(g_AutoSourceTable[g_u8CurSourceIndex] != eSourType)
				{
					APP_GUIOBJ_Source_SetAppSource(g_AutoSourceTable[g_u8CurSourceIndex]);
				}
			}
			break;
		}
#endif
        case UI_EVENT_TVRADIO:
#if 0
#ifdef CONFIG_DTV_SUPPORT
            if (eSourType == APP_SOURCE_ATV)
            {
                _ATVAPP_ShowPopup(ATV_APP_POP_MSG_NOT_AVAILABLE);
            }
            else
            {
                AL_DB_EDBType_t eDBType = APP_DVB_Playback_GetCurrentNetType();
                AL_DB_ERecordType_t eServiceType = APP_DVB_Playback_GetCurrServiceType(eDBType);
                if (eServiceType == AL_RECTYPE_DVBTV)
                {
                    _ATVApp_CloseAllMenu();
                    _ATVApp_ResetPopup_Channel();
                    APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_DTV);
                }
                else if (eServiceType == AL_RECTYPE_DVBRADIO)
                {
                    _ATVApp_CloseAllMenu();
                    _ATVApp_ResetPopup_Channel();
                    APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_RADIO);
                }
                else
                {
                    _ATVAPP_ShowPopup(ATV_APP_POP_MSG_NOT_AVAILABLE);
                }
            }
#else
            _ATVAPP_ShowPopup(ATV_APP_POP_MSG_NOT_AVAILABLE);
#endif
#else
            //_ATVAPP_ShowPopup(ATV_APP_POP_MSG_NOT_AVAILABLE);
#endif
            break;

        case UI_EVENT_ATVDTV:
#ifdef CONFIG_DTV_SUPPORT
            {
                _ATVApp_CloseAllMenu();
                _ATVApp_ResetPopup_Channel();
                APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_DTV);

            }
#else
            _ATVAPP_ShowPopup(ATV_APP_POP_MSG_NOT_AVAILABLE);
#endif
            break;
#ifdef CONFIG_SUPPORT_NET_OTA
		case APP_GLOBAL_EVENT_OTA_UPGRADE:
			if(dParam==1)//from fm OTA
			{
				SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_ATV, APP_GLOBAL_EVENT_ERASE_WHOLE_FLASH_OTA|PASS_TO_SYSAPP, 0);
			}
			break;
			
		case APP_GLOBAL_EVENT_ERASE_WHOLE_FLASH_OTA:
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_FM_FACTORYSETTING))
			{
				SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, APP_GUIOBJ_FM_FACTORYSETTING);
			}
			#ifdef CONFIG_SUPPORT_NET_SETTING
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_NETWORKINFORMATION))
			{
				SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, APP_GUIOBJ_NETWORKINFORMATION);
			}
			#ifdef CONFIG_SUPPORT_WIFI
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_ACCESS_POINT))
			{
				SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, APP_GUIOBJ_ACCESS_POINT);
			}
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_CONNECT_AP))
			{
				SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, APP_GUIOBJ_CONNECT_AP);
			}
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_AP_MANUAL_SETUP))
			{
				SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, APP_GUIOBJ_AP_MANUAL_SETUP);
			}
			#endif
			#endif
			memset(&stPopup, 0x0, sizeof(PopmsgParam_t));
			stPopup.eType = POPMSG_TYPE_CONFIRM;
			stPopup.u16Exitkeys = POPMSG_EXIT_EXIT | POPMSG_EXIT_RECALL;
			stPopup.u16ReturnType = GUI_OBJECT_POST_EVENT | GUI_OBJECT_EVENT_BYPASS;
			stPopup.extend.stConfirm.eConfirmType = POPMSG_CONFIRM_OTA;
			stPopup.extend.stConfirm.u8Default = POPMSG_NO;
			ATVApp_SchedulePopup(stPopup);
			break;
#endif            
        case APP_GLOBAL_EVENT_POPMSG_YES:
#ifdef CONFIG_CONFIRM_AUTO_UPGRADE
            if (dParam == POPMSG_CONFIRM_START_AUTO_UPGRADE)
            {
                if (!APP_MenuMgr_Exist_Main_Menu())
                {
                    _ATVApp_Exit_All_Menu(1);
                    SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, \
                                                         APP_GUIOBJ_SOFTWARE_UPGRADE, SOFTWARE_UPGRADE_FROM_AUTO_UPGRADE);
                }
                else if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_SOFTWARE_UPGRADE))
                {
                    SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, APP_GUIOBJ_SOFTWARE_UPGRADE, 0);
                }

                if (g_u32OldPopup == PLAYBACK_POPUP_MSG_NO_SIGNAL)
                {
                    g_u32OldPopup = PLAYBACK_POPUP_NONE;
                }
                if (g_dCurPopup  == PLAYBACK_POPUP_MSG_NO_SIGNAL)
                {
                    g_dCurPopup = PLAYBACK_POPUP_NONE;
                }
                g_u32PopupWaitingList &= ~(1 << (PLAYBACK_POPUP_MSG_NO_SIGNAL - PLAYBACK_POPUP_NONE));
            }
#endif
            if (POPMSG_CONFIRM_FLIP == dParam)
            {
				g_stFactoryUserData.Function.PanelSetting.n_FlipIndex = Factory_GetFlipIndex();
				AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_FACTUSER,
				   ITEM_OFFSET(APP_SETTING_FactoryUser_t, Function.PanelSetting.n_FlipIndex), sizeof(g_stFactoryUserData.Function.PanelSetting.n_FlipIndex),
					&(g_stFactoryUserData.Function.PanelSetting.n_FlipIndex));
				AL_Setting_Store(APP_Data_UserSetting_Handle(), SYS_SET_ID_FACTUSER,
				   ITEM_OFFSET(APP_SETTING_FactoryUser_t, Function.PanelSetting.n_FlipIndex), sizeof(g_stFactoryUserData.Function.PanelSetting.n_FlipIndex));

				MID_TVFE_SetPanelInverse((BOOL)(g_stFactoryUserData.Function.PanelSetting.n_FlipIndex));
				//MID_DISP_DTVSetFlip((MID_DISP_FlipType_t)(g_stFactoryUserData.Function.PanelSetting.n_FlipIndex) ); // added for VIP test
				GL_TaskSleep(2000);
				APP_Sysset_Reset_System();

            }
#ifdef CONFIG_SUPPORT_USB_UPGRADE
            if (POPMSG_CONFIRM_ERASE_WHOLE_FLASH == dParam)
            {
                if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_SOFTWARE_UPGRADE))
                {
                    SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, APP_GUIOBJ_SOFTWARE_UPGRADE, SOFTWARE_UPGRADE_FROM_FM);
                }
            }
#endif
#ifdef CONFIG_SUPPORT_NET_OTA
			if (POPMSG_CONFIRM_OTA == dParam)
			{		
				if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_SOFTWARE_UPGRADE))
				{
					_ATVAPP_ShowPopup(ATV_APP_POP_MSG_FTP_FILE_DOWNLOAD_WAITING);
					if(NET_OTA_DownloadUpdate() == NET_OTA_OK)
					{
						ATVApp_ClosePopup(POPMSG_FTP_FILE_DOWNLOAD_WAITING, UI_EVENT_NULL);
						#if defined(CONFIG_SUPPORT_NET_OTA_FROM_USB)
						APP_SetUpdateSource(UPGRADE_NETWORK_FROM_USB);
						#elif defined(CONFIG_SUPPORT_NET_OTA_FROM_MEM)
						APP_SetUpdateSource(UPGRADE_NETWORK_FROM_MEM);
						#else
						#error No storage for NET OTA is selected.
						#endif
						SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, APP_GUIOBJ_SOFTWARE_UPGRADE, SOFTWARE_UPGRADE_FROM_NET_OTA);
						return GUI_OBJECT_POST_EVENT;
					}
					ATVApp_ClosePopup(POPMSG_FTP_FILE_DOWNLOAD_WAITING, UI_EVENT_NULL);
				}
			}
#endif

            break;
        case APP_GLOBAL_EVENT_POPMSG_NO:
            if (dParam == POPMSG_CONFIRM_FLIP)
            {
                ATVApp_ClosePopup(POPMSG_CONFIRM_FLIP, UI_EVENT_NULL);
                SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_ATV,
                                                   (UI_EVENT_FACTORY | PASS_TO_SYSAPP), 1);
            }
#ifdef CONFIG_SUPPORT_USB_UPGRADE
            if (POPMSG_CONFIRM_ERASE_WHOLE_FLASH == dParam)
            {
                //if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_SOFTWARE_UPGRADE))
                //{
                //SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, APP_GUIOBJ_SOFTWARE_UPGRADE, SOFTWARE_UPGRADE_FROM_FM);
                //}
            }
#endif
#ifdef CONFIG_CONFIRM_AUTO_UPGRADE
			if (dParam == POPMSG_CONFIRM_START_AUTO_UPGRADE)
			{
				if (dLastFocusedIndex!=ATV_GUIOBJ_POPMSG)
				{
					SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, dLastFocusedIndex, 0);
				}
				AutoUpgrade = FALSE;
			}
#endif
            break;
        case APP_GLOBAL_EVENT_POPMSG_TIMEOUT:
            break;
        case APP_GLOBAL_EVENT_POPMSG_EXIT_KEY_MATCH:
			if(dParam == POPMSG_PWD_PINCODE)
			{
				bAutoScanPassword = FALSE;
			}
			if (dParam == PLAYBACK_POPUP_PWD_LOCKED)
			{
				#ifdef CONFIG_VCHIP_SUPPORT
				VchipNeedOpenFlag = FALSE;
				#endif
			}
            break;
        case APP_ATV_GLOBAL_EVENT_SIF_SAS_OK:
            g_u8SIF_SCS_OK = FALSE;
            break;
	    case APP_ATV_GLOBAL_EVENT_SIF_SCS_OK:
    	 	g_u8SIF_SCS_OK = TRUE;
            u8CheckMTSCount = 0;
            LasteAvaiMode = TVFE_AUDIO_SIF_AVAIL_ERROR;
    		printf("g_u8SIF_SCS_OK\n");
#ifdef SUPPORT_CLOSE_NICAM
			//if (!APP_IsScan_Running())
			{
				APP_Audio_GetATVSIFAvailableMode(&mode);
				if(mode == TVFE_AUDIO_SIF_AVAIL_ERROR)
				{
					memset(&GET_SIFinfo,0,sizeof(TVFE_AudioFrontEndStatus_t));
					TVFE_Audio_GetSIFInfo(&GET_SIFinfo);
					APP_ATV_Playback_SetMTS(GET_SIFinfo.eAvaiMode,FALSE,TRUE);
				}
			}
#endif
			break;
        case APP_ATV_GLOBAL_EVENT_SIGNAL_PRESENT:
		{
                atv_printf("APP_ATV_GLOBAL_EVENT_SIGNAL_PRESENT event is received.\n\n");
                g_u8ZappingTimer = 0;
                /*set signal state*/
                /*have available signal*/
                g_u8SignalState = ATV_AVAILABLE_SIGNAL;
                Boolean PauseStatus = FALSE;
                MID_DISP_DTVGetPause(&PauseStatus);
                if (PauseStatus)
                {
                    SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_FREEZE);
                    MID_DISP_DTVSetPause(FALSE);
                }
				#if 0//def SUPPORT_CLOSE_NICAM
				if ((eSourType == APP_SOURCE_ATV) && !APP_IsScan_Running())
				{
                	TVFE_Audio_RFLineCTL(TRUE);
				}
				#endif
#ifdef CONFIG_SUPPORT_TTX
#ifndef CONFIG_SUPPORT_TTX_DISP_FOR_AUS
				//AL_TTX_Reset();//move it here .Though it don't exist guiobj ttx ,it should also reset ttx.
				if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_TTX))
				{
				    SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_TTX);
				}
#else
				APP_SetTTXTimer(0);
#endif
#endif
#ifdef CONFIG_WSS_SUPPORT
				APP_Video_SetWssEn(FALSE);
#endif
    /*update pc setup menu*/
    			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_PCSETUP))
    			{

    				SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_ATV,
    													 ATV_GUIOBJ_PCSETUP, APP_ATV_GLOBAL_EVENT_SIGNAL_PRESENT, 0);
    			}

				/*close database empty popmessage*/
				if (ATVApp_IsPopupExist(PLAYBACK_POPUP_MSG_DATABASE_EMPTY))
				{
				    ATVApp_ClosePopup(PLAYBACK_POPUP_MSG_DATABASE_EMPTY, UI_EVENT_NULL);
				}

				/*close no signal popmessage*/
				g_u32NoSignalTimer = 0;
				g_u32NoSignalSleepTimer = 0;
				if (ATVApp_IsPopupExist(PLAYBACK_POPUP_MSG_NO_SIGNAL))
				{
				    ATVApp_ClosePopup(PLAYBACK_POPUP_MSG_NO_SIGNAL, UI_EVENT_NULL);
				}

				/*close not available popmessage*/
				g_u8NotAvailableTimer = 0;
				if (ATVApp_IsPopupExist(POPMSG_PROMPT_NOT_AVAILABLE))
				{
				    ATVApp_ClosePopup(POPMSG_PROMPT_NOT_AVAILABLE, UI_EVENT_NULL);
				}

				if (ATVApp_IsPopupExist(PLAYBACK_POPUP_MSG_NOT_SUPPORT_MODE))
				{
				    ATVApp_ClosePopup(PLAYBACK_POPUP_MSG_NOT_SUPPORT_MODE, UI_EVENT_NULL);
				}

				//if (!APP_IsScan_Running())
				{
					_ATVApp_SetMuteProcess(FALSE);
				}

				/*undate or open input info*/
				if ((eSourType == APP_SOURCE_HDMI)||(eSourType == APP_SOURCE_HDMI2)||(eSourType == APP_SOURCE_HDMI1))
				{
					
					APP_Video_SetMute(TRUE, FALSE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
					break;
				}
                //if (!APP_IsScan_Running())
                {
                    /*set current aspect ratio*/
    		        UINT8 u8AspectRatioIndex = 0;
    		        APP_Video_AspectRatioType_e u8AspectRatioType = APP_VIDEO_ASPECT_RATIO_MAX;
    		        APP_Video_AspectSystemSetRead(&u8AspectRatioIndex);
    		        u8AspectRatioType = APP_Video_AspectRatioIndexMappingToType(u8AspectRatioIndex);
    		        APP_Video_Set_AspectRatio(u8AspectRatioType);
                }
		        /*end*/
                if(1
#ifdef SUPPORT_HOTEL_MODE_INFOBANNER_SHOW_CONTROL
					&&((!g_stFactoryHotelData.HotelModeOnOff)||(g_stFactoryHotelData.ShowInfoBar))
#endif
#ifdef SUPPORT_FACTORY_AUTO_TEST_MODE2
					&&(APP_Factory_GetAutoTestOnOff() == FALSE)
#endif
				)
				{
					INT32 dFocusedIndex;
					/* No focused Guiobj exist */
					if (SYSTEM_APP_NO_FOCUSED_GUIOBJ == SYSAPP_GOBJ_GetFocusedGUIObject(SYS_APP_ATV, &dFocusedIndex))
					{
						#ifdef CONFIG_SUPPORT_TTX
						if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_TTXCLOCK))
						{
							SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_TTXCLOCK);
						}
						#endif
						SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, ATV_GUIOBJ_INPUTINFO, 0);
					}
				}

				if (bSetUnMuteFlag == TRUE)
				{
					bSetUnMuteFlag = FALSE;
#ifdef CONFIG_VCHIP_SUPPORT
                    if((g_stSetupData.Vchip_Lock == 1)\
                        &&(VchipLockFlag == TRUE)\
                        &&(APP_GUIOBJ_ATV_Playback_GetAtvUnLock() == FALSE))
                    {

                        return SP_ERR_FAILURE;
                    }
#endif					
			      	APP_Video_SetMute(FALSE, TRUE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
				}
			}
            break;
        case APP_ATV_GLOBAL_EVENT_VIP_FINISH:
		{
			atv_printf("APP_ATV_GLOBAL_EVENT_VIP_FINISH event is received.  g_u8SignalState ======= %d\n\n",g_u8SignalState);
			// Dynamic contrast
			DynamicContrast_t stDynamic;
			AL_FLASH_GetDynamicContrastALL(&stDynamic);
			int nLevel = stDynamic.n_PicMode_DynCon_DynamicContrastlevel;
			MID_TVFE_SetPictureDynamicContrastEnable( nLevel ? 1 : 0);
			MID_TVFE_SetPictureContrastLevel( stDynamic.n_PicMode_DynCon_ContrastLevel[nLevel] );
			MID_TVFE_SetPictureChromaLevel( stDynamic.n_PicMode_DynCon_ChromaLevel[nLevel] );
			MID_TVFE_SetPictureAlphaMode1( stDynamic.n_PicMode_DynCon_Alphamode1[nLevel] );
			MID_TVFE_SetPictureAlphaMode2( stDynamic.n_PicMode_DynCon_Alphamode2[nLevel] );
			MID_TVFE_SetPictureAlphaMode3( stDynamic.n_PicMode_DynCon_Alphamode3[nLevel] );
			MID_TVFE_SetPictureAlphaMode4( stDynamic.n_PicMode_DynCon_Alphamode4[nLevel] );
			MID_TVFE_SetPictureFleshToneLevel( stDynamic.n_PicMode_DynCon_FleshToneLevel );
			#if	defined(CONFIG_SUPPORT_ACTION_SHOW_BLUE_SCREEN_EXCEPT_MEDIA)
			if(g_stSetupData.BlueScreen == APP_SWITCH_ON)
			{
				MID_DISP_DTVSetMuteColor(0, 0, 255);
			}
			else
			{
				MID_DISP_DTVSetMuteColor(0, 0, 0);
			}
			#endif
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_MAINMENU))
			{
				SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_ATV, APP_GUIOBJ_MAINMENU, APP_ATV_GLOBAL_EVENT_VIP_FINISH, 0);
			}
			else if(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_PICTURE))
			{
				SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_ATV, APP_GUIOBJ_PICTURE, APP_ATV_GLOBAL_EVENT_VIP_FINISH, 0);
			}
			else if(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_FM_FACTORYSETTING))
			{
				SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_ATV, APP_GUIOBJ_FM_FACTORYSETTING, APP_ATV_GLOBAL_EVENT_VIP_FINISH, 0);
			}
			if (g_u8SignalState == ATV_AVAILABLE_SIGNAL)
			{
                bSetVIPFINISHFlag = TRUE;
                UINT8 u8Mute = 0;
				
                /* mute/unmute audio */
                AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_USERINFO, 0,
                        sizeof(APP_SETTING_UserInfo_t), &(g_stUserInfoData));
                u8Mute = g_stUserInfoData.Mute;
				if (eSourType != APP_SOURCE_ATV)
				{
					APP_Audio_SetMute(u8Mute, TRUE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
				}
                else
                {
                    APP_Source_Type_t eLSourceType = APP_SOURCE_MAX;
                    APP_GUIOBJ_Source_GetLastSource(&eLSourceType);
					
                    if((APP_SCARTOUT_GetScartOutputMode(eSourType) == SCARTOUT_ATV_SOURCE
            			&& APP_SCARTOUT_GetScartOutputMode(eLSourceType)== SCARTOUT_ATV_SOURCE)
            			|| (eSourType == APP_SOURCE_ATV && eLSourceType == APP_SOURCE_ATV))
                    {
                        APP_Audio_SetMute(u8Mute, TRUE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
                    }
                }
				if((((APP_POWERDOWN_NO_SINGAL == APP_GUIOBJ_SleepTimer_GetType()) && (APP_SOURCE_PC != eSourType)) 
						|| ((APP_POWERDOWN_SUSPEND == APP_GUIOBJ_SleepTimer_GetType()) && (APP_SOURCE_PC == eSourType))) 
					&& (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_SLEEP_INFO)))
				{
					APP_GUIOBJ_SleepTimer_Reset();
					SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, APP_GUIOBJ_SLEEP_INFO);
					//SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_ATV, (UI_EVENT_EXIT | PASS_TO_SYSAPP), 0);
				}
			}
        }
			break;
		case APP_ATV_GLOBAL_EVENT_VIP_STATUS:
			atv_printf("APP_ATV_GLOBAL_EVENT_VIP_STATUS event is received.  g_u8SignalState ======= %d\n\n",g_u8SignalState);
			if (g_u8SignalState == ATV_AVAILABLE_SIGNAL)
			{
				//APP_LED_HaveSignalStatus();//sea set Gled-on Rled-off
				/*set PQ param*/
				APP_StorageSource_Type_t eStorageSourType = APP_STORAGE_SOURCE_MAX;
				eStorageSourType = APP_Data_UserSetting_SourceTypeMappingToStorage(eSourType);
				AL_FLASH_GetColorLUTALL(&stColorLUTValue);

				for(RegionIdx = 0; RegionIdx<APP_ColorLUT_NUM; RegionIdx++)
				{
					MID_TVFE_SetColorLUT7Range(RegionIdx, APP_Video_GetColorLUTSetting(LUT_FUN_MAKE, RegionIdx),
                                             stColorLUTValue.n_PicMode_CoLUT_HueMin[RegionIdx],
                                             stColorLUTValue.n_PicMode_CoLUT_HueMax[RegionIdx],
                                             stColorLUTValue.n_PicMode_CoLUT_SatMin[RegionIdx],
                                             stColorLUTValue.n_PicMode_CoLUT_SatMax[RegionIdx],
                                             stColorLUTValue.n_PicMode_CoLUT_YMin[RegionIdx],
                                             stColorLUTValue.n_PicMode_CoLUT_YMax[RegionIdx],
                                             stColorLUTValue.n_PicMode_CoLUT_SmoothLevel[RegionIdx], FALSE);

					MID_TVFE_SetColorLUT7Axis(RegionIdx,
						stColorLUTValue.n_PicMode_CoLUT_Enable[RegionIdx],
						stColorLUTValue.n_PicMode_CoLUT_HueGain[RegionIdx],
						stColorLUTValue.n_PicMode_CoLUT_SatGain[RegionIdx],
						stColorLUTValue.n_PicMode_CoLUT_YGain[RegionIdx],
						RegionIdx==(APP_ColorLUT_NUM - 1)? TRUE : FALSE);
				}

				AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_PICTURE, 0,
				                sizeof(APP_SETTING_Picture_t), &(g_stPictureData));
                AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_PQSETTING, 0,
                    sizeof(APP_SETTING_PqSetting_t), &(g_stPqSettingData));
				APP_Video_SetPictureMode(
				    g_stPqSettingData.stPictureModeSourceTab[eStorageSourType].PictureModeIndex);
				APP_Video_OSD_PQSet(APP_VIDEO_OSD_ITEM_COLORTEMP, g_stPqSettingData.stPictureModeSourceTab[eStorageSourType].ColorTempIndex);
				APP_Video_OSD_PQSet(APP_VIDEO_OSD_ITEM_NR, g_stPqSettingData.NR);
				if ((eSourType == APP_SOURCE_HDMI)||(eSourType == APP_SOURCE_HDMI2)||(eSourType == APP_SOURCE_HDMI1))
				{
					MID_DISP_DTVSetHdmiRGBRange(g_stPqSettingData.FMPictureMode.VIP.n_PicMode_VIP_HDMI_RGB_Range);
					break;
				}
                if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_INPUTINFO))
				{
					INT32 dFocusedIndex;
					if (SYSTEM_APP_NO_FOCUSED_GUIOBJ == SYSAPP_GOBJ_GetFocusedGUIObject(SYS_APP_ATV, &dFocusedIndex))
					{
						SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV,
								ATV_GUIOBJ_INPUTINFO, 0);
					}
				}
				else
				{
					SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_ATV, APP_ATV_GLOBAL_EVENT_INFO_UPDATE, 0);
				}

				if (eSourType == APP_SOURCE_PC)
				{
#if(defined(SUPPORT_FACTORY_AUTO_TEST)||defined(SUPPORT_FACTORY_AUTO_TEST_MODE2))
					if(APP_Factory_GetAutoTestOnOff() == FALSE)
#endif
					{
						APP_GUIOBJ_ATV_PCSetup_ResetPCSetupData();
						ATVApp_PCAutoTune(FALSE); //Don't show "Adjusting , Please wait..." UI message, because AutoTune calibration has done before video unmute
					}
					/*update pc setup menu*/
					if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_PCSETUP))
					{

						SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_ATV,
															 ATV_GUIOBJ_PCSETUP, APP_ATV_GLOBAL_EVENT_VIP_STATUS, 0);
					}

				}
			}
			break;
        case APP_ATV_GLOBAL_EVENT_NO_SIGNAL:
			{
				//APP_LED_NoSignalStatus();//sea set Gled-off Rled-on
				if (g_u8SignalState == ATV_NO_SIGNAL)
				{
					break;
				}
				g_u8ZappingTimer = 0;
				UINT32 dActiveSysApp = TOTAL_SYS_APP_SIZE;
				if (MAINAPP_GetActiveSystemAppIndex(&dActiveSysApp) == MAIN_APP_SUCCESS)
                {
                    atv_printf(" ATV_GLOBAL_EVENT_NO_SIGNAL event received.\n\n");

                    /*set signal state*/
                    /*have no signal*/
                    g_u8SignalState = ATV_NO_SIGNAL;
                    bSetVIPFINISHFlag = FALSE;
#ifdef CONFIG_VCHIP_SUPPORT
                    VchipLockFlag = FALSE;
                    PreVchipLockFlag = FALSE;
#endif
                    if(APP_SCARTOUT_GetScartOutputMode(eSourType) == SCARTOUT_ATV_SOURCE)
			        {
                    	//Analog source Scart Mute or not is referred to ATV signal status.
            			if (g_stSetupData.SCARTOutput == APP_SCARTOUTPUT_TV)
            			{
            				DRV_RfFrontend_Status_t tStatus;
            				FrontendCmd_t  front;
            				front.cmd = FRONTEND_CMD_QUERY_STATUS_ANALOG;
            				front.param = &tStatus;
            				ioctl(kmfdev, KMF_IOC_FRONTENDCTRL , &front);
            				if(!tStatus.IsLock)
            				{
            					 TVFE_Audio_RFLineCTL(FALSE);
            				}
            			}
                        else
                        {
                            TVFE_Audio_RFLineCTL(FALSE);
                        }
                    }
                    IsAlreadyFirstSetMTS = FALSE;
#ifdef CONFIG_WSS_SUPPORT
                    APP_Video_SetWssEn(FALSE);
#endif
                    /*update pc setup menu*/
                    if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_PCSETUP))
                    {
                        SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_ATV, ATV_GUIOBJ_PCSETUP, APP_ATV_GLOBAL_EVENT_NO_SIGNAL, 0);
                    }
                    if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_FM_FACTORYSETTING))
                    {
                        SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_ATV, APP_GUIOBJ_FM_FACTORYSETTING, APP_ATV_GLOBAL_EVENT_NO_SIGNAL, 0);
                    }
        			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_MAINMENU))
        			{
        				SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_ATV, APP_GUIOBJ_MAINMENU, APP_ATV_GLOBAL_EVENT_NO_SIGNAL, 0);
        			}

                    /*close not available popmessage*/
                    g_u8NotAvailableTimer = 0;
                    if(ATVApp_IsPopupExist(PLAYBACK_POPUP_PWD_LOCKED))
                    {
                        ATVApp_ClosePopup(PLAYBACK_POPUP_PWD_LOCKED, UI_EVENT_NULL);
                    }
                    if (ATVApp_IsPopupExist(POPMSG_PROMPT_NOT_AVAILABLE))
                    {
                        ATVApp_ClosePopup(POPMSG_PROMPT_NOT_AVAILABLE, UI_EVENT_NULL);
                    }

                    if (ATVApp_IsPopupExist(PLAYBACK_POPUP_MSG_NOT_SUPPORT_MODE))
                    {
                        ATVApp_ClosePopup(PLAYBACK_POPUP_MSG_NOT_SUPPORT_MODE, UI_EVENT_NULL);
                    }
                    /* if TT Menu exist, first close it */
#ifdef CONFIG_SUPPORT_TTX
#ifndef CONFIG_SUPPORT_TTX_DISP_FOR_AUS
                    if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_TTX))
                    {
                        SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_TTX);
                    }
                    AL_TTX_Reset();
#else
                    APP_SetTTXTimer(80);
#endif
                    if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_TTXCLOCK))
                    {
                        SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_TTXCLOCK);
                    }
#endif
                    if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_FREEZE))
                    {
                     SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_FREEZE);
                    }

                    MID_DISP_DTVGetPause(&bFreezeFlag);
                    if (bFreezeFlag)
                    {
                     	MID_DISP_DTVSetPause(FALSE);
                    }
                    if (eSourType == APP_SOURCE_ATV)
                    {
                    }
                    else
                    {
	                     _ATVApp_SetMuteProcess(TRUE);
                    }
                    if (bSetUnMuteFlag == TRUE)
                    {
                        bSetUnMuteFlag = FALSE;
                        ATVApp_CheckProgramType(FALSE);
                    }
                }
        	}
            break;

        case APP_ATV_GLOBAL_EVENT_NOT_AVILABLE:
			{
				g_u8ZappingTimer = 0;
				atv_printf(" ATV_GLOBAL_EVENT_NOT_AVILABLE event received.\n\n");

				g_u8SignalState = ATV_NOTAVAILABLE_SIGNAL;

			    /*close Standby menu*/
			    if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_SLEEP_INFO))
			    {
			        if (APP_GUIOBJ_SleepTimer_GetOpenStandby() == al_true)
			        {
			            SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, APP_GUIOBJ_SLEEP_INFO);
			            if (APP_GUIOBJ_SleepTimer_GetSleepPopConflict() == TRUE)
			            {
			                APP_GUIOBJ_SleepTimer_SetSleepPopConflict(FALSE);
			                SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_ATV,
									(APP_GLOBAL_EVENT_SLEEP_TIMER_INFO | PASS_TO_SYSAPP), APP_POWERDOWN_SLEEP);
			            }
			        }
			    }
			    /*close database empty popmessage*/
			    if (ATVApp_IsPopupExist(PLAYBACK_POPUP_MSG_DATABASE_EMPTY))
			    {
			        ATVApp_ClosePopup(PLAYBACK_POPUP_MSG_DATABASE_EMPTY, UI_EVENT_NULL);
			    }

			    /*close no signal popmessage*/
			    g_u32NoSignalTimer = 0;
				g_u32NoSignalSleepTimer = 0;
			    if (ATVApp_IsPopupExist(PLAYBACK_POPUP_MSG_NO_SIGNAL))
			    {
			        ATVApp_ClosePopup(PLAYBACK_POPUP_MSG_NO_SIGNAL, UI_EVENT_NULL);
			    }

			    if (SYSAPP_GOBJ_GUIObjectExist(stAtvInst.dSystemApplicationIndex, ATV_GUIOBJ_INPUTINFO))
			    {
			        SYSAPP_GOBJ_DestroyGUIObject(stAtvInst.dSystemApplicationIndex, ATV_GUIOBJ_INPUTINFO);
			    }

			    /*set mute*/
			    _ATVApp_SetMuteProcess(TRUE);
			}
            break;

        case APP_ATV_GLOBAL_EVENT_POPMSG_NO_SIGNAL:
            {
				AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_SETUP, 0,
								sizeof(APP_SETTING_Setup_t), &(g_stSetupData));
				if (eSourType != APP_SOURCE_ATV && eSourType != APP_SOURCE_DTV
					&& eSourType != APP_SOURCE_MEDIA && eSourType != APP_SOURCE_MEDIA1 && g_stSetupData.BlueScreen == APP_SWITCH_ON)
				{
					MID_DISP_DTVSetVideoMute(0,0,255);
				}

				if (ATVApp_IsPopupExist(PLAYBACK_POPUP_MSG_NO_SIGNAL))
                {
                    break;
                }
				if(!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_INPUTINFO))
				{
					_ATVApp_CloseAllMenu();
				}
				#ifdef CONFIG_SMART_MODULE_SUPPORT
				if((APP_SOURCE_HDMI + CONFIG_HDMI_SMART_PORT) != eSourType)
				#endif
					_ATVAPP_ShowPopup(ATV_APP_POP_MSG_NO_SIGNAL);

            }
            break;

        case APP_ATV_GLOBAL_EVENT_POPMSG_NOT_AVILABLE:
            if (ATVApp_IsPopupExist(POPMSG_PROMPT_NOT_AVAILABLE))
            {
                break;
            }
            _ATVAPP_ShowPopup(ATV_APP_POP_MSG_NOT_AVAILABLE);
            break;
        case APP_ATV_GLOBAL_EVENT_POPMSG_NOT_SUPPORT_MODE:
            if (ATVApp_IsPopupExist(PLAYBACK_POPUP_MSG_NOT_SUPPORT_MODE))
            {
                break;
            }
            _ATVAPP_ShowPopup(ATV_APP_POP_MSG_NOT_SUPPORT_MODE);
            break;
		case APP_ATV_GLOBAL_EVENT_HDMI_PLUG_PROCESSING:
			{
				printf("APP_ATV_GLOBAL_EVENT_HDMI_PLUG_PROCESSING dParam=%d\n",dParam);
				if (dParam == 1)
				{
					g_u8SignalState = ATV_AVAILABLE_SIGNAL;
					if (ATVApp_IsPopupExist(PLAYBACK_POPUP_MSG_NO_SIGNAL))
					{
						ATVApp_ClosePopup(PLAYBACK_POPUP_MSG_NO_SIGNAL, UI_EVENT_NULL);
					}
					g_u32NoSignalTimer = 0;
					if ((!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_INPUTINFO))
	                && (!(APP_MenuMgr_Exist_Main_Menu()))
#ifdef SUPPORT_FACTORY_AUTO_TEST_MODE2
					&&(APP_Factory_GetAutoTestOnOff() == FALSE)
#endif
	                )
				   {
					   SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV,
								ATV_GUIOBJ_INPUTINFO, 0);
				   }
				}
				else
				{
					g_u8SignalState = ATV_NO_SIGNAL;
					MID_TVFE_ResetCurrentVideoInfo(SRCTYPE_HDMI);
					_ATVApp_SetMuteProcess(TRUE);
					if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_FM_FACTORYSETTING))
					{
						SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_ATV, APP_GUIOBJ_FM_FACTORYSETTING, APP_ATV_GLOBAL_EVENT_HDMI_PLUG_PROCESSING, 0);
					}
					if ((!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_INPUTINFO))
	                    && (!(APP_MenuMgr_Exist_Main_Menu()))
#ifdef SUPPORT_FACTORY_AUTO_TEST_MODE2
					&&(APP_Factory_GetAutoTestOnOff() == FALSE)
#endif
	                   )
				   {
					   SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV,
								ATV_GUIOBJ_INPUTINFO, 0);
				   }
				}
			}
			break;
        case DMN_EVENT_AUTODVD_CHANGE_SOURCE:
			/* Check Valid state +++*/
			#if 1
            AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FACTUSER, 0,
                            sizeof(APP_SETTING_FactoryUser_t), &(g_stFactoryUserData));
            if (g_stFactoryUserData.n_FactSet_BurningMode == al_true)
            {
                break;
            }

            if ((MAIN_APP_SUCCESS != MAINAPP_GetActiveSystemAppIndex(&dAppIndex)) ||
                (APP_MenuMgr_Exist_Scan_Menu()) ||
#ifdef CONFIG_SUPPORT_USB_UPGRADE
                (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_SOFTWARE_UPGRADE)) ||
#endif
                0)//(AL_CS_IsStop() != al_true))
            {
                 break;
            }
            /* Check Valid state ---*/
			#endif
            _ATVApp_CloseAllMenu();
            _ATVApp_ResetPopup_Channel();
            if (SP_SUCCESS != APP_GUIOBJ_Source_SetAppSource(dParam))
            {
                atv_printf("[AtvApp OnGlobalEvent] APP_GUIOBJ_Source_SetAppSource faild.\n");
            }
			break;

        case DMN_EVENT_AUTOSCART_CHANGE_SOURCE:
            /* Check Valid state +++*/
            AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FACTUSER, 0,
                            sizeof(APP_SETTING_FactoryUser_t), &(g_stFactoryUserData));
            if (g_stFactoryUserData.n_FactSet_BurningMode == al_true)
            {
                break;
            }

            if ((MAIN_APP_SUCCESS != MAINAPP_GetActiveSystemAppIndex(&dAppIndex)) ||
                (APP_MenuMgr_Exist_Scan_Menu()) ||
#ifdef CONFIG_SUPPORT_USB_UPGRADE
                (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_SOFTWARE_UPGRADE)) ||
#endif
                0)//(AL_CS_IsStop() != al_true))
            {
			#ifdef CONFIG_DVB_SYSTEM
                APP_SCARTIN_ResetAutoPlugInStatus(AUTO_PLUGIN_SCART0);
			#endif
                break;
            }
            /* Check Valid state ---*/

            _ATVApp_CloseAllMenu();
            _ATVApp_ResetPopup_Channel();
            if (SP_SUCCESS != APP_GUIOBJ_Source_SetAppSource(dParam))
            {
                atv_printf("[AtvApp OnGlobalEvent] APP_GUIOBJ_Source_SetAppSource faild.\n");
            }
            else
            {
			#ifdef CONFIG_DVB_SYSTEM
                if (dParam == APP_SOURCE_SCART)
                {
                    APP_SCARTIN_SetAutoPlugInStatus(AUTO_PLUGIN_SCART0);
                    APP_SCARTIN_SetPlugStatus(AUTO_PLUGIN_SCART0);
                }
			#endif
            }
            break;

        case APP_GLOBAL_EVENT_SLEEP_TIMER_INFO:
            if (0//APP_IsScan_Running()
#ifdef CONFIG_SUPPORT_USB_UPGRADE
              || (APP_Data_Get_USB_Upgrade_State() == TRUE)
#endif
               )
            {
                APP_GUIOBJ_SleepTimer_Reset();
            }
            else
            {
                if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_SLEEP_INFO))
                {
                    _ATVApp_CloseAllMenu();
                    _ATVApp_ResetPopup_Channel();
                    SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, APP_GUIOBJ_SLEEP_INFO, dParam);
                }
            }
            break;

#ifdef CONFIG_MEDIA_ENABLE
        case UI_EVENT_SRC_USB:
        {
            _ATVApp_CloseAllMenu();
#ifdef CONFIG_OSD_GAME_SUPPORT
            if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_OSDGAME))
            {
                SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, APP_GUIOBJ_OSDGAME);
            }
#endif
            _ATVApp_ResetPopup_Channel();
            if (SP_SUCCESS != APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_MEDIA))
            {
                atv_printf("APP_GUIOBJ_Source_SetAppSource Fail!!!!!!!!!\n");
            }
        }
        break;
#endif

#ifdef NET_SUPPORT
        case UI_EVENT_SRC_NET:
            if (SP_SUCCESS != APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_NET))
            {
                atv_printf("UI_EVENT_SRC_NET change Net Fail!!!!!!!!!\n");
            }
            break;
#endif

#ifdef CONFIG_HDMI_SUPPORT_MHL
		case DMN_EVENT_MHL_CHANGE_SOURCE:
		{
			/* Check invalid state ---*/
			APP_Source_Type_t eMhlSrc;
			UINT8 IsMHLSoure;
			APP_GOBJ_Source_CheckAndGetMHLSource(&IsMHLSoure,&eMhlSrc);
			if(FALSE == IsMHLSoure)
			{
			
	            _ATVApp_CloseAllMenu();
	            _ATVApp_ResetPopup_Channel();
				if (SP_SUCCESS != APP_GUIOBJ_Source_SetAppSource(eMhlSrc))
				{
					atv_printf("[AtvApp OnGlobalEvent] APP_GUIOBJ_Source_SetAppSource faild.\n");
				}
			}
			}
			break;
#endif

#ifdef CONFIG_SUPPORT_HDMI_PLUGIN_CHANGE_SOURCE
		case APP_GLOBAL_EVENT_HDMI_CHANGE_SOURCE:
			atv_printf("[AtvApp OnGlobalEvent] APP_GLOBAL_EVENT_HDMI_CHANGE_SOURCE.\n");	
			#if 0	
            /* Scan State */
            if (AL_CS_IsStop() != 1)
            {
                break;
            }
            /*
            ** Channel Tuning,
            ** Channel - Analogue Manual Search,
            ** Channel - Analogue Manual Search - Search/Fine Tune
            */
            if ((SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_ANALOG_MANUAL_SEARCH))
                || (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_AMS_SEARCH))
                || (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_AMS_FINE_TUNE))
                || (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_AUTO_SEARCH))
                || (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_SCAN_PROCESS))
                || (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_INITINSTALL)) )
            {
                break;
            }
			#endif
            /* Check Valid state ---*/
			UINT8 tmpSrc = (UINT8)((CONFIG_HDMI_PORT_MAP>>(dParam*4))&0xf);
			APP_Source_Type_t eSrc1;
			switch(tmpSrc)
			{
				case SRC_HDMI_1:
					eSrc1 = APP_SOURCE_HDMI;
					break;

				case SRC_HDMI_2:
					eSrc1 = APP_SOURCE_HDMI1;
					break;

				case SRC_HDMI_3:
					eSrc1 = APP_SOURCE_HDMI2;
					break;
				default:
					atv_printf(" [AtvApp OnGlobalEvent] not invalid source,need change backsource!");
					return 0;
			}
			_ATVApp_CloseAllMenu();
			_ATVApp_ResetPopup_Channel();
			atv_printf("[AtvApp OnGlobalEvent] APP_GLOBAL_EVENT_HDMI_CHANGE_SOURCE eSrc1:%d \n",eSrc1);
			if (SP_SUCCESS != APP_GUIOBJ_Source_SetAppSource(eSrc1))
			{
				atv_printf("[AtvApp OnGlobalEvent] APP_GUIOBJ_Source_SetAppSource faild.\n");
			}
			break;
#endif

#ifdef SUPPORT_CEC_TV
        case DMN_EVENT_CECTV_CHANGE_SOURCE:
            /* Check Valid state ---*/

            _ATVApp_CloseAllMenu();
            _ATVApp_ResetPopup_Channel();
            APP_Source_Type_t eSrc;
            APP_Video_GetCECPortMapping(dParam, &eSrc);
            if (SP_SUCCESS != APP_GUIOBJ_Source_SetAppSource(eSrc))
            {
                atv_printf("[AtvApp OnGlobalEvent] APP_GUIOBJ_Source_SetAppSource faild.\n");
            }
            break;
        case DMN_EVENT_CECTV_STANDBY:
            MAINAPP_SendGlobalEvent(UI_EVENT_POWER, 0);
            break;

#endif
#ifdef CONFIG_SUPPORT_USB_UPGRADE
        case APP_GLOBAL_EVENT_USB_UPGRADE:
			{
				UINT32 dActiveSysApp = TOTAL_SYS_APP_SIZE;
				if (MAINAPP_GetActiveSystemAppIndex(&dActiveSysApp) != MAIN_APP_SUCCESS)
				{
					break;
				}

				if (dActiveSysApp != SYS_APP_ATV)
				{
					break;
				}
#ifdef SUPPORT_FACTORY_AUTO_TEST_MODE2//when factory test,no upgrade when usb plugin
				if(APP_Factory_GetAutoTestOnOff() == TRUE)
				{
					break;
				}
#endif
#ifdef SUPPORT_FACTORY_AUTO_TEST
				if(APP_Factory_GetUpgradeandAutoTestFlag() == TRUE)
				{
					AutoUpgrade = TRUE;
					bSetUnMuteFlag = FALSE;
					_ATVApp_Exit_All_Menu(1);
					if(dParam==1)
					{
						SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_ATV, APP_GLOBAL_EVENT_ERASE_WHOLE_FLASH|PASS_TO_SYSAPP, 0);
					}
					else
					{
						SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, APP_GUIOBJ_SOFTWARE_UPGRADE, SOFTWARE_UPGRADE_FROM_AUTO_UPGRADE);
					}
					//add for 0159405 @20111114 +++
					if (g_u32OldPopup == PLAYBACK_POPUP_MSG_NO_SIGNAL)
					{
						g_u32OldPopup = PLAYBACK_POPUP_NONE;
					}
					if (g_dCurPopup == PLAYBACK_POPUP_MSG_NO_SIGNAL)
					{
						g_dCurPopup = PLAYBACK_POPUP_NONE;
					}
					g_u32PopupWaitingList &= ~(1 << (PLAYBACK_POPUP_MSG_NO_SIGNAL - PLAYBACK_POPUP_NONE));
					break;
				}
#endif
			}

			if(dParam==1)//from fm
			{
				SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_ATV, APP_GLOBAL_EVENT_ERASE_WHOLE_FLASH|PASS_TO_SYSAPP, 0);
			}

			if (!APP_MenuMgr_Exist_Main_Menu()
				&& !(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_FM_FACTORYSETTING)))
            {

                _ATVApp_Exit_All_Menu(1);
				{
					AutoUpgrade = TRUE;
					bSetUnMuteFlag = FALSE;
#ifdef CONFIG_CONFIRM_AUTO_UPGRADE
					if(FALSE == gUSBUpgradeBinIsSupperBin)
					{
						INT32 dFocusedIndex = 0;
						int ret = SYSAPP_GOBJ_GetFocusedGUIObject(SYS_APP_ATV, &dFocusedIndex);
						if (ret == SYSTEM_APP_SUCCESS)
						{
							dLastFocusedIndex = dFocusedIndex;
						}
						else if(ret == SYSTEM_APP_NO_FOCUSED_GUIOBJ)
						{
							dLastFocusedIndex = ATV_GUIOBJ_MAX;
						}
						memset(&stPopup, 0x0, sizeof(PopmsgParam_t));
						stPopup.eType = POPMSG_TYPE_CONFIRM;
						stPopup.u16Exitkeys = POPMSG_EXIT_EXIT | POPMSG_EXIT_RECALL;
						stPopup.u16ReturnType = GUI_OBJECT_POST_EVENT | GUI_OBJECT_EVENT_BYPASS;
						stPopup.extend.stConfirm.eConfirmType = POPMSG_CONFIRM_START_AUTO_UPGRADE;
						stPopup.extend.stConfirm.u8Default = POPMSG_NO;
						ATVApp_SchedulePopup(stPopup);
					}
					else
#endif
					{
    					SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, APP_GUIOBJ_SOFTWARE_UPGRADE, SOFTWARE_UPGRADE_FROM_AUTO_UPGRADE);
					}
				}
                //add for 0159405 @20111114 +++
                if (g_u32OldPopup == PLAYBACK_POPUP_MSG_NO_SIGNAL)
                {
                    g_u32OldPopup = PLAYBACK_POPUP_NONE;
                }
                if (g_dCurPopup	== PLAYBACK_POPUP_MSG_NO_SIGNAL)
                {
                    g_dCurPopup = PLAYBACK_POPUP_NONE;
                }
                g_u32PopupWaitingList &= ~(1 << (PLAYBACK_POPUP_MSG_NO_SIGNAL - PLAYBACK_POPUP_NONE));
            }
            break;
#endif
        case APP_GLOBAL_EVENT_FLIP:
            if (APP_MenuMgr_Exist_Factory_Menu())
            {
                APP_MenuMgr_Exit_Factory_Menu();
            }
            memset(&stPopup, 0x0, sizeof(PopmsgParam_t));
            stPopup.eType = POPMSG_TYPE_CONFIRM;
            stPopup.u16Exitkeys = POPMSG_EXIT_EXIT | POPMSG_EXIT_RECALL;
            stPopup.u16ReturnType = GUI_OBJECT_POST_EVENT | GUI_OBJECT_EVENT_BYPASS;
            stPopup.extend.stConfirm.eConfirmType = POPMSG_CONFIRM_FLIP;
            stPopup.extend.stConfirm.u8Default = POPMSG_YES;
            ATVApp_SchedulePopup(stPopup);
            break;
#ifdef CONFIG_SUPPORT_USB_UPGRADE
        case APP_GLOBAL_EVENT_ERASE_WHOLE_FLASH:
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_FM_FACTORYSETTING))
			{
				SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, APP_GUIOBJ_FM_FACTORYSETTING);
			}
            memset(&stPopup, 0x0, sizeof(PopmsgParam_t));
            stPopup.eType = POPMSG_TYPE_CONFIRM;
            stPopup.u16Exitkeys = POPMSG_EXIT_EXIT | POPMSG_EXIT_RECALL;
            stPopup.u16ReturnType = GUI_OBJECT_POST_EVENT | GUI_OBJECT_EVENT_BYPASS;
            stPopup.extend.stConfirm.eConfirmType = POPMSG_CONFIRM_ERASE_WHOLE_FLASH;
            stPopup.extend.stConfirm.u8Default = POPMSG_NO;
            ATVApp_SchedulePopup(stPopup);
            break;
#endif
        case APP_GLOBAL_EVENT_KEYLOCK:
			if (!APP_MenuMgr_Exist_Main_Menu() && !APP_MenuMgr_Exist_Factory_Menu())
			{
				_ATVAPP_ShowPopup(ATV_APP_POP_MSG_KEYLOCK);
			}
            break;

#ifdef CONFIG_SUPPORT_SHOW_KEYPADMENU
		case APP_GLOBAL_EVENT_KEYPADMENU_OPEN:
			SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, APP_GUIOBJ_KEYPADMENU, dParam);
			break;
		case APP_GLOBAL_EVENT_KEYPADMENU_CLOSE:
			SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, APP_GUIOBJ_KEYPADMENU);
			break;
#endif
        case APP_GLOBAL_EVENT_OVER_MAXVOLUME:
            _ATVAPP_ShowPopup(ATV_APP_POP_MSG_OVERMAXVOLUME);
            break;
		case UI_EVENT_MultiPanelIndex:
#ifdef SUPPORT_FACTORY_AUTO_TEST
			if(APP_Factory_GetAutoTestOnOff() == TRUE)
			{
				if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_FM_FACTORYSETTING))
				{
					_ATVApp_ResetPopup_Channel();
            		_ATVApp_CloseAllMenu();
					SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, APP_GUIOBJ_FM_FACTORYSETTING, 1);
					Factory_Ver_Debug();
				}
				else
				{
					SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, APP_GUIOBJ_FM_FACTORYSETTING);
				}
				break;
			}
			else
#endif
			{
				if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_SOURCE))
				{
					UINT8 u8PanelIdx = tv_GetPanelIndex();
					u8PanelIdx = (u8PanelIdx + 1) % CONFIG_PANEL_NUM;
					tv_SetPanelIndex(u8PanelIdx);
		            g_stFactoryUserData.Function.PanelSetting.n_MultiplePanelIndex = u8PanelIdx;
		            AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_FACTUSER,
		                             ITEM_OFFSET(APP_SETTING_FactoryUser_t, Function.PanelSetting.n_MultiplePanelIndex), sizeof(g_stFactoryUserData.Function.PanelSetting.n_MultiplePanelIndex),
		                             &(g_stFactoryUserData.Function.PanelSetting.n_MultiplePanelIndex));
		            AL_Setting_Store(APP_Data_UserSetting_Handle(), SYS_SET_ID_FACTUSER,
		                             ITEM_OFFSET(APP_SETTING_FactoryUser_t, Function.PanelSetting.n_MultiplePanelIndex), sizeof(g_stFactoryUserData.Function.PanelSetting.n_MultiplePanelIndex));

					tv_SetRebootAfterPowerOff();
					MAINAPP_SendGlobalEvent(UI_EVENT_POWER, 0);
		            printf("[%s], %d: Panel Index is %d\n", __FUNCTION__, __LINE__, u8PanelIdx);
				}
	            break;
			}

		case UI_EVENT_FAC_BURNINGMODE:
			{
				g_stFactoryUserData.n_FactSet_BurningMode= 1;
				AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_FACTUSER,
					ITEM_OFFSET(APP_SETTING_FactoryUser_t, n_FactSet_BurningMode),
					sizeof(g_stFactoryUserData.n_FactSet_BurningMode),&(g_stFactoryUserData.n_FactSet_BurningMode));
				AL_Setting_Store(APP_Data_UserSetting_Handle(), SYS_SET_ID_FACTUSER,
					ITEM_OFFSET(APP_SETTING_FactoryUser_t, n_FactSet_BurningMode),
					sizeof(g_stFactoryUserData.n_FactSet_BurningMode));
				_ATVApp_Exit_All_Menu(0);
				MID_TVFE_SetAutoPowerOn(TRUE);

				#ifdef SUPPORT_FACTORY_AUTO_TEST_MODE2
				AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_VARIATIONAL, 0,
					sizeof(APP_SETTING_Variational_t), &(g_stVariationalData));
				g_stVariationalData.Volume = 90;
				APP_Audio_SetVolume(g_stVariationalData.Volume);
				AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_VARIATIONAL,
					ITEM_OFFSET(APP_SETTING_Variational_t, Volume), sizeof(g_stVariationalData.Volume),
					&(g_stVariationalData.Volume));
				AL_Setting_Store(APP_Data_UserSetting_Handle(), SYS_SET_ID_VARIATIONAL,
					ITEM_OFFSET(APP_SETTING_Variational_t, Volume), sizeof(g_stVariationalData.Volume));
				#endif
				APP_Factory_SetBurnIn_LEDTwinkle(TRUE);
			}
			break;
#ifdef SUPPORT_HKC_FACTORY_REMOTE
		case UI_EVENT_HKC_ENTER_BURNINGMODE:
			if(g_stFactoryUserData.n_FactSet_FactoryRemote == 1)
			{
				_ATVApp_Exit_All_Menu(0);
				g_stFactoryUserData.n_FactSet_BurningMode = 1;
				AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_FACTUSER, 0,
					sizeof(APP_SETTING_FactoryUser_t), &(g_stFactoryUserData));
				AL_Setting_Store(APP_Data_UserSetting_Handle(), SYS_SET_ID_FACTUSER, 0,
							sizeof(g_stFactoryUserData));
				MID_TVFE_SetBurnIn(1, 0, 1);
				//APP_Cul_Fm_CheckAndStartBurningMode();
			}
			break;
		case UI_EVENT_HKC_DTV:
#ifdef CONFIG_DTV_SUPPORT
			if(g_stFactoryUserData.n_FactSet_FactoryRemote == 1)
			{
				APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_DTV);
			}
#endif
			break;
		case UI_EVENT_HKC_DVD:
			if(g_stFactoryUserData.n_FactSet_FactoryRemote == 1)
				APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_DVD);
				break;
		case UI_EVENT_HKC_FACTORYMENU:
			if(g_stFactoryUserData.n_FactSet_FactoryRemote == 1)
				SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_ATV, UI_EVENT_FACTORY, UI_EVENT_HKC_FACTORYMENU);
			break;
		case UI_EVENT_HKC_VERSION:
			if(g_stFactoryUserData.n_FactSet_FactoryRemote == 1)
			{
				if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_FM_FACTORYSETTING))
				{
					_ATVApp_ResetPopup_Channel();
            		_ATVApp_CloseAllMenu();
					SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, APP_GUIOBJ_FM_FACTORYSETTING, 1);
					Factory_Ver_Debug();

				}
			}
			break;
		case UI_EVENT_HKC_VOLUME80:
			if(g_stFactoryUserData.n_FactSet_FactoryRemote == 1)
			{
				APP_Audio_SetVolume(80);
				AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FACTHOTEL, 0,
						sizeof(APP_SETTING_FactoryHotel_t), &(g_stFactoryHotelData));
				g_stVariationalData.Volume = 80;
				AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_VARIATIONAL,
					ITEM_OFFSET(APP_SETTING_Variational_t, Volume),
					sizeof(g_stVariationalData.Volume),&(g_stVariationalData.Volume));
				AL_Setting_Store(APP_Data_UserSetting_Handle(), SYS_SET_ID_VARIATIONAL,
					ITEM_OFFSET(APP_SETTING_Variational_t, Volume), sizeof(g_stVariationalData.Volume));
				SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, APP_GUIOBJ_ADJUST, ADJUST_VOLUME);
			}
			break;
		case UI_EVENT_HKC_VOLUMEUP10:
		case UI_EVENT_HKC_VOLUMEDOWN10:
			if(g_stFactoryUserData.n_FactSet_FactoryRemote == 1)
			{
				AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FACTHOTEL, 0,
						sizeof(APP_SETTING_FactoryHotel_t), &(g_stFactoryHotelData));
				UINT8 u8VolumeIdx = g_stVariationalData.Volume;
	            if (dMessage == UI_EVENT_HKC_VOLUMEUP10)
				{
					u8VolumeIdx += 10;
					g_stVariationalData.Volume = u8VolumeIdx >= ADJUST_MAX_VALUE ? ADJUST_MAX_VALUE : u8VolumeIdx;
				}
				else if (dMessage == UI_EVENT_HKC_VOLUMEDOWN10)
				{
					g_stVariationalData.Volume = u8VolumeIdx <= 10 ? ADJUST_MIN_VALUE : u8VolumeIdx - 10;
				}
				APP_Audio_SetVolume((UINT32)g_stVariationalData.Volume);
				AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_VARIATIONAL,
								 ITEM_OFFSET(APP_SETTING_Variational_t, Volume),
								 sizeof(g_stVariationalData.Volume), &(g_stVariationalData.Volume));
				AL_Setting_Store(APP_Data_UserSetting_Handle(), SYS_SET_ID_VARIATIONAL,
								 ITEM_OFFSET(APP_SETTING_Variational_t, Volume), sizeof(g_stVariationalData.Volume));
				SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, APP_GUIOBJ_ADJUST, ADJUST_VOLUME);
			}
			break;
		case UI_EVENT_HKC_PCAUTO:
			if ((g_stFactoryUserData.n_FactSet_FactoryRemote == 1)&&(eSourType == APP_SOURCE_PC))
			{
				UINT16 usTimingTblIdx;
				PLF_VideoID_t eResolution;
				APP_SETTING_PC_AutoTune_t PC_Tempvalue;
				MID_INPUT_STATUS_t eInputStatus;
				Boolean UserFlag;
				eInputStatus = Cmd_VipGetCurrentInputSignalSatus();
				MID_TVFE_GetCurrentVideoInfo(NULL, &eResolution);
				if (eInputStatus == STATUS_NOSIGNAL
					|| eInputStatus == STATUS_UNKNOWN)
				{
					return 1;
				}
				if (MID_DTV_SUCCESS != MID_TVFE_GetCurrentVideoInfo(NULL, &eResolution))
				{
					return 1;
				}
				if (eResolution == PLF_VIDEO_TIMING_ID_NO_SIGNAL
					|| eResolution == PLF_VIDEO_TIMING_ID_UNKNOW_FORMAT)
				{
					return 1;
				}
				_ATVAPP_ShowPopup(ATV_APP_POP_MSG_AUTO_ADJUST);

				MID_TVFE_DoAutoTune(1);
				/* save pc auto tune information */
				if ((eResolution != PLF_VIDEO_TIMING_ID_NO_SIGNAL)
					&& (eResolution != PLF_VIDEO_TIMING_ID_UNKNOW_FORMAT))
				{
					Cmd_AdcGetAdcPhase(&PC_Tempvalue.Phase);
					PC_Tempvalue.i16HPosition = 0;
					PC_Tempvalue.i16VPosition = 0;
					PC_Tempvalue.Phase =
						APP_GUIOBJ_ATV_PCSetup_PhaseMappingtoOSDValue(PC_Tempvalue.Phase);
					PC_Tempvalue.i16Clock = 0;
					if ((eResolution == PLF_VIDEO_TIMING_ID_UNKNOW_FORMAT) || (eResolution == 0))
					{
						return 0;
					}
					PCAutoTune_FIFOTable_Search(eResolution, &usTimingTblIdx, &UserFlag);
					g_stSysInfoData.stPC_AutoTune[usTimingTblIdx].i8HpositionOffset = PC_Tempvalue.i16HPosition;
					g_stSysInfoData.stPC_AutoTune[usTimingTblIdx].i8VpositionOffset = PC_Tempvalue.i16VPosition;
					g_stSysInfoData.stPC_AutoTune[usTimingTblIdx].i8ClockOffset = PC_Tempvalue.i16Clock;
					g_stSysInfoData.stPC_AutoTune[usTimingTblIdx].Phase = PC_Tempvalue.Phase;
					//AutoTune OK
					PCAutoTune_FIFOTable_Update(eResolution, usTimingTblIdx);

					AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_SYSINFO,
									 ITEM_OFFSET(APP_SETTING_SystemInfo_t, stPC_AutoTune[usTimingTblIdx]),
									 sizeof(g_stSysInfoData.stPC_AutoTune[usTimingTblIdx]),
									 &(g_stSysInfoData.stPC_AutoTune[usTimingTblIdx]));
					MID_DISP_DTVSetCropWindowHStartOffset(0, (PC_Tempvalue.i16HPosition*(-1)));
					MID_DISP_DTVSetCropWindowVStartOffset(0, PC_Tempvalue.i16VPosition);
					AL_Setting_Store(APP_Data_UserSetting_Handle(), SYS_SET_ID_SYSINFO,
									 ITEM_OFFSET(APP_SETTING_SystemInfo_t, stPC_AutoTune[usTimingTblIdx]),
									 sizeof(g_stSysInfoData.stPC_AutoTune[0]));
				}
			}
			break;
		case UI_EVENT_HKC_ADCADJUST:
			if(g_stFactoryUserData.n_FactSet_FactoryRemote == 1)
			{
				//APP_GUIOBJ_FM_PCADCAutoColor();
				ADCCalibrate_OSDGainOffset_t pAdc;
				Cmd_AdcGetAutoColor(&pAdc);
				extern void Enable_Debug_Message(UINT32 DBGStatus);
				Enable_Debug_Message(1<<MODULEID_UMF);
				atv_printf("\n VGA Offset: {R_OFF,G_OFF,B_OFF}={%d,%d,%d,%d,%d,%d}\n",
					pAdc.scOSDROffsetValue,pAdc.scOSDGOffsetValue,pAdc.scOSDBOffsetValue,
					pAdc.scOSDRGainValue,pAdc.scOSDRGainValue,pAdc.scOSDBGainValue);
				Enable_Debug_Message(0);
			}
			break;
		case UI_EVENT_HKC_RESET:
			if(g_stFactoryUserData.n_FactSet_FactoryRemote == 1)
			{
				APP_Audio_SetMute(TRUE, FALSE, APP_MUTE_MODE_STATEMAX, eSourType);
				APP_Video_SetMute(TRUE, FALSE, APP_MUTE_MODE_STATEMAX, eSourType);
#ifdef CONFIG_ATV_SUPPORT
				SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_ATV, ATV_GUIOBJ_PLAYBACK,
					APP_ATV_INTRA_EVENT_STOP_PLAYBACK, 0);
				AL_DB_Reset(AL_DBTYPE_DVB_ATV, al_true);
				APP_ATV_Playback_ResetFirstService();
#endif
				App_Data_UserSetting_Restore();
				App_Data_UserSetting_FM_Hotel_Restore();
				App_Data_UserSetting_ResetLangContry_ByFMDefaultValue();
				APP_Video_ResetTVSetting();
				GL_TaskSleep(2000);
				MAINAPP_SendGlobalEvent(UI_EVENT_POWER, AL_POWER_STATE_OFF);
			}
			break;
		case UI_EVENT_HKC_RESET_DEFAULT_FAC:
			if(g_stFactoryUserData.n_FactSet_FactoryRemote == 1)
			{
				extern void _APP_GUIOBJ_FM_FactorySetting_Shipping(void);
				_APP_GUIOBJ_FM_FactorySetting_Shipping();
			}
			break;
		case UI_EVENT_HKC_TV:
			if(g_stFactoryUserData.n_FactSet_FactoryRemote == 1)
			{
				APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_ATV);
			}
			break;
		case UI_EVENT_HKC_AV:
			if(g_stFactoryUserData.n_FactSet_FactoryRemote == 1)
			{
			APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_AV);
			}
			break;
		case UI_EVENT_HKC_AV2:
			if(g_stFactoryUserData.n_FactSet_FactoryRemote == 1)
			{
				APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_AV1);
			}
			break;
		case UI_EVENT_HKC_PC:
			if(g_stFactoryUserData.n_FactSet_FactoryRemote == 1)
			{
				APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_PC);
			}
			break;
		case UI_EVENT_HKC_YPBPR:
			if(g_stFactoryUserData.n_FactSet_FactoryRemote == 1)
			{
				APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_YPBPR);
			}
			break;
		case UI_EVENT_HKC_YPBPR2:
			if(g_stFactoryUserData.n_FactSet_FactoryRemote == 1)
			{
				APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_YPBPR1);
			}
			break;
		case UI_EVENT_HKC_HDMI:
			if(g_stFactoryUserData.n_FactSet_FactoryRemote == 1)
			{
				APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_HDMI);
			}
			break;
		case UI_EVENT_HKC_HDMI2:
			if(g_stFactoryUserData.n_FactSet_FactoryRemote == 1)
			{
				APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_HDMI1);
			}
			break;
		case UI_EVENT_HKC_HDMI3:
			if(g_stFactoryUserData.n_FactSet_FactoryRemote == 1)
			{
				APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_HDMI2);
			}
			break;
		case UI_EVENT_HKC_SCART:
			if(g_stFactoryUserData.n_FactSet_FactoryRemote == 1)
			{
				APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_SCART);
			}
			break;
		case UI_EVENT_HKC_USB:
			if(g_stFactoryUserData.n_FactSet_FactoryRemote == 1)
			{
				APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_MEDIA);
			}
			break;
#endif
		case UI_EVENT_PCAUTOADJ:
			if (eSourType == APP_SOURCE_PC)
			{
				ATVApp_PCAutoTune(TRUE);
			}
			break;
#if (defined(SUPPORT_FACTORY_AUTO_TEST)||defined(SUPPORT_FACTORY_AUTO_TEST_MODE2))
		case UI_EVENT_ERASE_HDCP:
		case UI_EVENT_ERASE_CIKEY:
		case UI_EVENT_FAC_HDCP_CHECK:
		case UI_EVENT_FAC_CIPLUSKEY_CHECK:
		case UI_EVENT_FAC_HDCP_UPDATE:
		case UI_EVENT_FAC_CIPLUSKEY_UPDATE:
			APP_CIPLUS_HDCP_Key_Action_Function(dMessage);
			break;

		case UI_EVENT_AUTO_OUTPUTPCADJ:

//2.1.13 short key start atuo color function
			if(APP_Factory_GetAutoTestOnOff() == TRUE)
			{
	            //APP_GUIOBJ_FM_PCADCAutoColor();
				ADCCalibrate_OSDGainOffset_t pAdc;
				Cmd_AdcGetAutoColor(&pAdc);
				extern void Enable_Debug_Message(UINT32 DBGStatus);
				Enable_Debug_Message(1<<MODULEID_UMF);
				atv_printf("\n VGA Offset: {R_OFF,G_OFF,B_OFF}={%d,%d,%d,%d,%d,%d}\n",
					pAdc.scOSDROffsetValue,pAdc.scOSDGOffsetValue,pAdc.scOSDBOffsetValue,
					pAdc.scOSDRGainValue,pAdc.scOSDRGainValue,pAdc.scOSDBGainValue);
				Enable_Debug_Message(0);
			}
			break;
//#if 0
		case UI_EVENT_AUTO_OUTPUTCI:
			if(APP_Factory_GetAutoTestOnOff() == TRUE)
			{
				extern void Enable_Debug_Message(UINT32 DBGStatus);
				Enable_Debug_Message(1<<MODULEID_UMF);
				APP_Source_Type_t eSourceType;
				APP_GUIOBJ_Source_GetCurrSource(&eSourceType);
				if((eSourceType == APP_SOURCE_SCART)||(eSourceType == APP_SOURCE_SCART1))
				{
					switch (App_SCARTIN_GetPin16Satus())
					{
						case DRV_Scart_Signal_RGB:
							if(eSourceType == APP_SOURCE_SCART){
								atv_printf("\n***SCART RGB***\n");
							}
							else{
								atv_printf("\n***SCART1 RGB***\n");
							}
							break;
						case DRV_Scart_Signal_CVBS:
						case DRV_Scart_Signal_SVIDEO:
						default:
							if(eSourceType == APP_SOURCE_SCART){
								atv_printf("\n***SCART CVBS***\n");
							}
							else{
								atv_printf("\n***SCART1 CVBS***\n");
							}
							break;
					}
					if(APP_SCARTIN_GetAspectRatio() == APP_SCART_ASPECTRATIO_43)
					{
						atv_printf("\n***ASPECT 4:3***\n");
					}
					else if(APP_SCARTIN_GetAspectRatio() == APP_SCART_ASPECTRATIO_169)
					{
						atv_printf("\n***ASPECT 16:9***\n");
					}
				}
				Enable_Debug_Message(0);
			}
			break;
//#endif
		case UI_EVENT_AUTO_ATV:
		case UI_EVENT_AUTO_DTV:
		case UI_EVENT_AUTO_AV1:
		case UI_EVENT_AUTO_AV2:
		case UI_EVENT_AUTO_AV3:
		case UI_EVENT_AUTO_SVIDEO1:
		case UI_EVENT_AUTO_SVIDEO2:
		case UI_EVENT_AUTO_SCART1:
		case UI_EVENT_AUTO_SCART2:
		case UI_EVENT_AUTO_YPBPR1:
		case UI_EVENT_AUTO_YPBPR2:
		case UI_EVENT_AUTO_YPBPR3:
		case UI_EVENT_AUTO_HDMI1:
		case UI_EVENT_AUTO_HDMI2:
		case UI_EVENT_AUTO_HDMI3:
		case UI_EVENT_AUTO_HDMI4:
		case UI_EVENT_AUTO_PC:
		case UI_EVENT_AUTO_MEDIA:
		case UI_EVENT_AUTO_DVD:
			if(APP_Factory_GetAutoTestOnOff() == TRUE)
			{
				APP_Factory_SetAutoTestSourceChange(dMessage);
				if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_FAC_AUTOTEST))
				{
					 SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_ATV, APP_GUIOBJ_FAC_AUTOTEST, APP_ATV_GLOBAL_EVENT_INFO_UPDATE, 0);
				}
			}
			break;
		case UI_EVENT_FAC_F1:
		case UI_EVENT_FAC_RESET:
			//if(APP_Factory_GetAutoTestOnOff() == TRUE)
			{
				APP_Audio_SetMute(TRUE, FALSE, APP_MUTE_MODE_STATEMAX, eSourType);
				APP_Video_SetMute(TRUE, FALSE, APP_MUTE_MODE_STATEMAX, eSourType);
				ATVApp_ClearStatus();
				
#ifdef CONFIG_ATV_SUPPORT
				SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_ATV, ATV_GUIOBJ_PLAYBACK,
					APP_ATV_INTRA_EVENT_STOP_PLAYBACK, 0);
#endif
				//APP_Sysset_Reset(APP_SYSSET_RESET_ALL);
				Factory_FactSet_ResetAllEx();
			}
			break;
		case UI_EVENT_VOL_MAX:
			g_stVariationalData.Volume = 100;
			APP_Audio_SetVolume(g_stVariationalData.Volume);
			AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_VARIATIONAL,
				ITEM_OFFSET(APP_SETTING_Variational_t, Volume),
				sizeof(g_stVariationalData.Volume),&(g_stVariationalData.Volume));
			AL_Setting_Store(APP_Data_UserSetting_Handle(), SYS_SET_ID_VARIATIONAL,
				ITEM_OFFSET(APP_SETTING_Variational_t, Volume), sizeof(g_stVariationalData.Volume));
			break;
		case UI_EVENT_AUTO_OUTPUTSYSCONF:
#if defined(SUPPORT_FACTORY_AUTO_TEST)
			if(APP_Factory_GetAutoTestOnOff() == TRUE)
			{
				APP_Factory_Send_SysConf();
			}
#endif
			break;

#endif

		case UI_EVENT_AUTO_SCAN:
			if(eSourType == APP_SOURCE_ATV)
			{
			}
			break;
#ifdef CONFIG_VCHIP_SUPPORT
		case FW_VCHIP_LOCK:
            /*user has unlock video.*/
            if(APP_GUIOBJ_ATV_Playback_GetAtvUnLock() == al_true)
		    {
			    break;
			}
			AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_SETUP, 0,
				sizeof(APP_SETTING_Setup_t), &(g_stSetupData));
            if(g_stSetupData.Vchip_Lock == 1)
            {
                VchipLockFlag = TRUE;
    			if(VchipLockFlag != PreVchipLockFlag)
    			{
                    INT32 dFocusedIndex = 0;
                    PreVchipLockFlag = VchipLockFlag;
                    /*for samsung tv spec: when gotten rating level, need lock channel and don't open pop message
                                with existed ui.*/
                    if (SYSTEM_APP_NO_FOCUSED_GUIOBJ == SYSAPP_GOBJ_GetFocusedGUIObject(SYS_APP_ATV, &dFocusedIndex))
                    {
                        _ATVAPP_ShowPopup(ATV_APP_POP_MSG_CHECKPWD);
                    }
                    APP_Audio_SetMute(TRUE, FALSE, APP_MUTE_MODE_STATEMAX, eSourType);
                    APP_Video_SetMute(TRUE, FALSE, APP_MUTE_MODE_STATEMAX, eSourType);
					
#ifdef CONFIG_ATV_SUPPORT
                    SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_ATV, ATV_GUIOBJ_PLAYBACK,
                        APP_ATV_INTRA_EVENT_STOP_PLAYBACK, 0);
#endif
                 }
            }
            else
            {
                /*when Vchip_Lock is 0 and channel is locked, need unlock channel.*/
                if(VchipLockFlag == TRUE)
                {
                    VchipLockFlag = FALSE;
                    if(PreVchipLockFlag != VchipLockFlag)
                    {
                        PreVchipLockFlag = VchipLockFlag;
                        _ATVApp_HidePopupDisplay();
                        APP_Audio_SetMute(TRUE, TRUE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
                        APP_Video_SetMute(TRUE, TRUE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
						
#ifdef CONFIG_ATV_SUPPORT
                        SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_ATV, ATV_GUIOBJ_PLAYBACK,
                            APP_ATV_INTRA_EVENT_START_PLAYBACK, TRUE);
#endif
                    }
                }
            }
			break;
		case FW_VCHIP_UNLOCK:
		  VchipLockFlag = FALSE;
          if(PreVchipLockFlag != VchipLockFlag)
          {
              PreVchipLockFlag = VchipLockFlag;
              _ATVApp_HidePopupDisplay();
              /* mute/unmute audio */
              AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_USERINFO, 0,
                  sizeof(APP_SETTING_UserInfo_t), &(g_stUserInfoData));
              APP_Audio_SetMute(g_stUserInfoData.Mute, TRUE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
              APP_Video_SetMute(TRUE, TRUE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
			  
#ifdef CONFIG_ATV_SUPPORT
              SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_ATV, ATV_GUIOBJ_PLAYBACK,
                  APP_ATV_INTRA_EVENT_START_PLAYBACK, TRUE);
#endif
          }
		  break;
#endif
#ifdef CONFIG_SUPPORT_SW_AFC
		case APP_GLOBAL_EVENT_AFT_PROCESS:
			/*set MTS*/
			{
			}
			break;
#endif
		case APP_GLOBAL_EVENT_ADC_AUTO_CHANGE_SOURCE:
			#if 0
			if(dParam == TRUE)//plug in
			{	
				if(g_ADCAutoChnage == FALSE)
				{
					if (SP_SUCCESS != APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_PC))
		            {
		                atv_printf("APP_GUIOBJ_Source_SetAppSource Fail!!!!!!!!!\n");
		            }
					else
					{
						g_ADCAutoChnage = TRUE;
					}
				}
			}
			else // plutg out
			{
				g_ADCAutoChnage = FALSE;
				
				extern void SysApp_MM_Reset_ADCAutoChnageFlag(void);
				SysApp_MM_Reset_ADCAutoChnageFlag();
			}
			#endif
			break;

#if defined(CONFIG_SUPPORT_NES_GAME)|| defined(CONFIG_OSD_GAME_SUPPORT)
      case APP_ATV_INTRA_EVENT_GAME_SOURCE_CHANGE:

            atv_printf("\n Input (Source) Block !!!   %s  %d\n" ,__FUNCTION__,__LINE__);
            SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, APP_GUIOBJ_GAMEMENU, GAME_TYPE_LAYER1);
            break;
#endif
		case APP_GLOBAL_EVENT_CIHDCPKEY_RESULT:
		{
			 if (dParam == 0xffffffff)
			 	break;

			 UINT32 u32CIupgrade = dParam & 0xf;
			 UINT32 u32HDCPupgrade = (dParam & 0xf0)>>4;

			 if (u32CIupgrade && u32HDCPupgrade)
			 {
			 	// upgrade CI & HDCP
			 	if (u32CIupgrade == APP_DATA_KEYUPGRADE_SUCCESS)
				{
					if (u32HDCPupgrade == APP_DATA_KEYUPGRADE_SUCCESS)
					{
						// CI OK, HDCP OK
						_ATVAPP_ShowPopup(ATV_APP_POP_MSG_CI_PASS_HDCP_PASS);
					}
					else
					{
						// CI OK, HDCP fail
						_ATVAPP_ShowPopup(ATV_APP_POP_MSG_CI_PASS_HDCP_FAIL);
					}
				}
				else
				{
					if (u32HDCPupgrade == APP_DATA_KEYUPGRADE_SUCCESS)
					{
						// CI fail, HDCP OK
						_ATVAPP_ShowPopup(ATV_APP_POP_MSG_CI_FAIL_HDCP_PASS);
					}
					else
					{
						// CI fail, HDCP fail
						_ATVAPP_ShowPopup(ATV_APP_POP_MSG_CI_FAIL_HDCP_FAIL);
					}
				}
			 }
			 else if (u32CIupgrade != APP_DATA_KEYUPGRADE_NOT_UPGRADE)
			 {
				 _ATVApp_CloseAllMenu();
			 	// upgrade CI
			 	if (u32CIupgrade == APP_DATA_KEYUPGRADE_SUCCESS)
				{
				 	_ATVAPP_ShowPopup(ATV_APP_POP_MSG_CIPLUSE_UPGRADE_SUCC);
				}
				else
				{
					_ATVAPP_ShowPopup(ATV_APP_POP_MSG_CIPLUSE_UPGRADE_FAILE);
				}
			 }
			 else if (u32HDCPupgrade != APP_DATA_KEYUPGRADE_NOT_UPGRADE)
			 {
			 	// upgrade HDCP
			 	if (u32HDCPupgrade == APP_DATA_KEYUPGRADE_SUCCESS)
				{
					_ATVAPP_ShowPopup(ATV_APP_POP_MSG_HDCP_UPGRADE_SUCC);
				}
				else
				{
					_ATVAPP_ShowPopup(ATV_APP_POP_MSG_HDCP_UPGRADE_FAILE);
				}
			 }
		}
		break;
		#ifdef CONFIG_SUPPORT_WIFI
		case DMN_EVENT_WIFI_DONGLE_ATTACHED:
		{
			#if 1
			extern void Network_WifiDongle_Attached_Check(void);
			Network_WifiDongle_Attached_Check();
			#else
			UINT8 retry_count = 0;
			#ifdef CONFIG_SUPPORT_NET_SETTING
			Al_IP_t Get_IPaddress = {0};
			UINT32 dRetry = 0;
			UINT8 ifflag = E_MID_NWSI_IF_OFF;
			AL_Return_t ret = AL_FAILURE;
			#endif

			while((MID_NWSI_GetIFFlag(E_MID_NWSI_CONNECT_TYPE_WIRELESS) & E_MID_NWSI_IF_UP) != E_MID_NWSI_IF_UP && retry_count < 20)
			{
				usleep(200000);
				retry_count ++;
				printf("wait interface up\n");
			}
			retry_count = 0;
			#ifdef CONFIG_SUPPORT_NET_SETTING
			if(Al_Network_Ctrl_GetIP(&Get_IPaddress) != AL_SUCCESS)
			{
				if(MID_NWSI_WLAN_GetAPState() == E_MID_NWSI_WLAN_CONNECT_STATE_ON)
				{
					Al_APPW_t *pAPPW = NULL;
					pAPPW = &g_stSetupData.WiFiSetting.WiFiPassword.APPW[0];
					if(Al_Network_Ctrl_ConnectAP(g_stSetupData.WiFiSetting.ConnectAPData, pAPPW->PWlen, pAPPW->PassWord) == AL_SUCCESS)
					{
						Al_Network_Ctrl_SetDhcpStatic(e_AL_Network_Mode_Wireless, g_stSetupData.EthernetConnectMode, &g_stSetupData.IPSetting);
					}
					MID_NWSI_WLAN_WiFiEnable(TRUE);
					while(ret != AL_SUCCESS && dRetry < 30)
					{
						ret = Al_Network_Ctrl_GetIP(&Get_IPaddress);
						ifflag = MID_NWSI_GetIFFlag(e_AL_Network_Mode_Wireless);
						if(ret == AL_SUCCESS && (ifflag&E_MID_NWSI_IF_RUNNING))
						{						
							break;
						}
						dRetry ++;
					}
				}
			}
			#endif
			#endif
			break;
		}
		#endif
        default:
            atv_printf("[%s] Unknown message received.\n", __FUNCTION__);
            break;
    }
	g_u8CallCMDState = FALSE;
    return 0;
}

static INT32 _ATVApp_OnGUIFeedbackEvent(void *pPrivateData, UINT32 dMessage, UINT32 dParam)
{
    APP_Source_Type_t eSourType = APP_SOURCE_MAX;

    APP_GUIOBJ_Source_GetCurrSource(&eSourType);

    switch (dMessage)
    {
        case APP_GLOBAL_EVENT_SET_SOURCE:
            _ATVApp_ResetPopup_Channel();
            _ATVApp_CloseAllMenu();
            APP_GUIOBJ_Source_SetAppSource(dParam);
            break;

        case GUI_RESPOND_ZAPPING:
        {
            AL_RecHandle_t NextHdl = dParam;
            _ATVApp_CloseAllMenu();
            if (NextHdl != AL_DB_INVALIDHDL)
            {
                _ATVApp_Zapping(NextHdl, FALSE);
            }
        }
        break;

        case GUI_RESPOND_EXIT_ALL_MENU:
            if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_SLEEP_INFO))
            {
                if (APP_GUIOBJ_SleepTimer_GetOpenStandby() == al_true)
                {
                    _ATVApp_CloseAllMenu();
                    _ATVApp_ResetPopup_Channel();
                    if (APP_GUIOBJ_SleepTimer_GetSleepPopConflict() == TRUE)
                    {
                        APP_GUIOBJ_SleepTimer_SetSleepPopConflict(FALSE);
                        SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_ATV,
                                                           (APP_GLOBAL_EVENT_SLEEP_TIMER_INFO | PASS_TO_SYSAPP), APP_POWERDOWN_SLEEP);
                    }
                }
                else
                {
                    _ATVApp_CloseAllMenu();
                    _ATVApp_ResetPopup_Channel();
                    if ((g_u8SignalState == ATV_NO_SIGNAL) && (APP_GUIOBJ_SleepTimer_GetStandbyPopConflict() == TRUE))
                    {
                        APP_GUIOBJ_SleepTimer_SetStandbyPopConflict(FALSE);
                        if (eSourType == APP_SOURCE_PC)
                        {
                            SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_ATV,
                                                               (APP_GLOBAL_EVENT_SLEEP_TIMER_INFO | PASS_TO_SYSAPP), APP_POWERDOWN_SUSPEND);
                        }
                        else
                        {
                            SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_ATV,
                                                               (APP_GLOBAL_EVENT_SLEEP_TIMER_INFO | PASS_TO_SYSAPP), APP_POWERDOWN_NO_SINGAL);
                        }
                    }
                }
            }
            else
            {
                _ATVApp_ResetPopup_Channel();
                _ATVApp_Exit_All_Menu(0);
            }
            break;
        case GUI_RESPOND_INVALID_CHN_NUM:
            _ATVApp_Exit_All_Menu(0);
            _ATVAPP_ShowPopup(ATV_APP_POP_MSG_INVALID_INPUT);
            break;
        default:
            atv_printf("[%s] Unknown message received.\n", __FUNCTION__);
            break;
    }

    return 0;
}

static INT32 _ATVApp_OnEvent(void *pPrivateData, UINT32 dMessage, UINT32 dParam)
{
    switch (dMessage & GUIOBJ_MESSAGE_TYPE_MASK)
    {
        case SYSAPP_GLOBAL_EVENT_TYPE:
            _ATVApp_OnGlobalEvent(pPrivateData,
                                  (dMessage & GUIOBJ_MESSAGE_MASK), dParam);
            break;

        case GUIOBJ_FEEDBACK_EVENT_TYPE:
            _ATVApp_OnGUIFeedbackEvent(pPrivateData,
                                       (dMessage & GUIOBJ_MESSAGE_MASK), dParam);
            break;

        default:
            atv_printf("[%s] Unknown message received.\n", __FUNCTION__);
            break;
    }
    return 0;
}
/*****************************************************************************
** FUNCTION : ATVApp_GetDBInitState
**
** DESCRIPTION :
**				Get atv database inited state
**
** PARAMETERS :
**				None
**
** RETURN VALUES:
**				g_bATVDBInited  -  1:Inited, 0:Non inited
*****************************************************************************/
UINT8 ATVApp_GetDBInitState(void)
{
    return g_bATVDBInited;
}

/*****************************************************************************
** FUNCTION : ATVApp_SetDBInitState
**
** DESCRIPTION :
**				Set atv database inited state
**
** PARAMETERS :
**				None
**
** RETURN VALUES:
**				bInitState  -  1:Inited, 0:Non inited
*****************************************************************************/
void ATVApp_SetDBInitState(UINT8 bInitState)
{
    g_bATVDBInited = bInitState;
}

/*****************************************************************************
** FUNCTION : ATVApp_ClearStatus
**
** DESCRIPTION :
**				clear flag status when change source
**
** PARAMETERS :
**				None
**
** RETURN VALUES:
**				None
*****************************************************************************/
void ATVApp_ClearStatus(void)
{
    bSetUnMuteFlag = FALSE;
    g_u32NoSignalTimer = 0;
	g_u32NoSignalSleepTimer = 0;
    g_u8SignalState = ATV_INVALID_STATUS;
    g_u8NotAvailableTimer = 0;
    bAutoScanPassword = FALSE;
	IsAlreadyFirstSetMTS = FALSE;
	g_u8CheckMTSTimer = 0;
}

/*****************************************************************************
** FUNCTION : ATVAPP_NoSignal_TimerReset
**
** DESCRIPTION :
**
**
** PARAMETERS :
**
** RETURN VALUES:
**
*****************************************************************************/
void  ATVAPP_NoSignal_TimerReset(void)
{
	g_u32NoSignalTimer = 0;
}

void  ATVAPP_NoSignal_StandbyTimerReset(void)
{
	g_u32NoSignalSleepTimer = 0;
}

/*****************************************************************************
** FUNCTION : ATVApp_GetSignalState
**
** DESCRIPTION :
**				Get signal state
**
** PARAMETERS :
**				None
**
** RETURN VALUES:
**				signal state  -  0:no signal, 1:available signal, 2: not available signal
*****************************************************************************/
UINT8 ATVApp_GetSignalState(void)
{
    return g_u8SignalState;
}

/*****************************************************************************
** FUNCTION : ATVApp_SetSignalState
**
** DESCRIPTION :
**				Set signal state
**
** PARAMETERS :
**				SignalState  -  signal state (0:no signal, 1:available signal, 2: not available signal)
**
** RETURN VALUES:
**				None
*****************************************************************************/
INT32 ATVApp_SetSignalState(UINT8 SignalState)
{
    g_u8SignalState = SignalState;
    return 0;
}

/*****************************************************************************
** FUNCTION : ATVApp_CheckProgramType
**
** DESCRIPTION :
**				Check program lock or unlock
**
** PARAMETERS :
**				bInit   -  lock dispose
**
** RETURN VALUES:
**				SP_ERR_FAILURE  -  locked
**				SP_SUCCESS  -  unlock
*****************************************************************************/
INT32 ATVApp_CheckProgramType(Boolean bInit)
{
    APP_Source_Type_t eSourType = APP_SOURCE_MAX;

    APP_GUIOBJ_Source_GetCurrSource(&eSourType);
#ifdef CONFIG_VCHIP_SUPPORT
    int dFocusedIndex = ATV_GUIOBJ_MAX;
#endif
    /* if lock */
    /* unlock dispose */
    if ((ATVApp_GetSignalState() == ATV_AVAILABLE_SIGNAL)
		||((ATVApp_GetSignalState() == ATV_NO_SIGNAL) && (g_stSetupData.BlueScreen == APP_SWITCH_OFF)))
    {
        UINT8 u8Mute = 0;
        /* mute/unmute audio */
        u8Mute = g_stUserInfoData.Mute;
        if (ATVApp_GetSignalState())
        {
#ifdef CONFIG_VCHIP_SUPPORT
            /*if the vchip lock and don't open video*/
            if(ATVAPP_GetSignalLockStatus() == TRUE)
            {
                APP_Audio_SetMute(TRUE, FALSE, APP_MUTE_MODE_STATEMAX, eSourType);
                APP_Video_SetMute(TRUE, FALSE, APP_MUTE_MODE_STATEMAX, eSourType);
                /*when there is non focused guiobj, need pop pwd message
                            otherwise, atv on timer will check pop pwd message for available signal with non focused guiobj.*/
                if(SYSTEM_APP_NO_FOCUSED_GUIOBJ == SYSAPP_GOBJ_GetFocusedGUIObject(SYS_APP_ATV, &dFocusedIndex))
                {
                    _ATVAPP_ShowPopup(ATV_APP_POP_MSG_CHECKPWD);
                }
                return SP_SUCCESS;
            }
#endif
			APP_Audio_SetMute(u8Mute, TRUE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
            APP_Video_SetMute(FALSE, TRUE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
		}
        else
        {
            APP_Audio_SetMute(u8Mute, TRUE, APP_MUTE_MODE_NO_SIGNALE, eSourType);
            APP_Video_SetMute(FALSE, TRUE, APP_MUTE_MODE_NO_SIGNALE, eSourType);
        }
    }
	else if ((ATVApp_GetSignalState() == ATV_NO_SIGNAL) && (g_stSetupData.BlueScreen == APP_SWITCH_ON))
	{
		if(eSourType != APP_SOURCE_ATV && eSourType != APP_SOURCE_DTV && eSourType != APP_SOURCE_MEDIA && eSourType != APP_SOURCE_MEDIA1)
		{
			MID_DISP_DTVSetVideoMute(0,0,255);
		}
	}
    return SP_SUCCESS;
}
/*****************************************************************************
** FUNCTION : ATVApp_SchedulePopup
**
** DESCRIPTION :
**				Schedule atv popmsg
**
** PARAMETERS :
**				Popup  -  popmsg type
**
** RETURN VALUES:
**				None
*****************************************************************************/
INT32 ATVApp_SchedulePopup(PopmsgParam_t Popup)
{
    UINT32 u32CurPopup = PLAYBACK_POPUP_NONE;
    UINT8 bTimeoutFlag = 0;

    switch (Popup.eType)
    {
        case POPMSG_TYPE_CONFIRM:
            u32CurPopup = Popup.extend.stConfirm.eConfirmType;
            break;
        case POPMSG_TYPE_PWD:
            u32CurPopup = Popup.extend.stPwd.ePwdType;
            break;
        case POPMSG_TYPE_PROMPT:
            u32CurPopup = Popup.extend.stPrompt.ePromptType;
            if (Popup.extend.stPrompt.iTimeout > 0)
            {
                if (g_dCurPopup == u32CurPopup)
                {
                    SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_ATV,
                                   APP_GLOBAL_EVENT_POPMSG_RESET_TIMEOUT,
                                   Popup.extend.stPrompt.iTimeout);
                    return 0;
                }
                bTimeoutFlag = 1;
            }
            break;
        default:
            return 0;
    }

    if (u32CurPopup > PLAYBACK_POPUP_NONE)
    {
        if (bTimeoutFlag == 0)
        {
            g_u32PopupWaitingList |= 1 << (u32CurPopup - PLAYBACK_POPUP_NONE);
            stPopupWaitingList[u32CurPopup-PLAYBACK_POPUP_NONE] = Popup;
        }
        if (u32CurPopup > g_u32OldPopup)
        {
            g_u32OldPopup = u32CurPopup;
            if (APP_MenuMgr_Exist_Main_Menu()
                || SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_SOURCE)
				|| SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_SOURCE_CEC)
#ifdef CONFIG_SUPPORT_TTX
                || SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_TTX)
#endif
               )
            {
                g_u32OldPopup = PLAYBACK_POPUP_NONE;
                g_dCurPopup = u32CurPopup;
                return 0;
            }
            if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_POPMSG))
            {
                SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_POPMSG);
            }
            APP_MenuMgr_SetMsgPopup(TRUE);
            SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, ATV_GUIOBJ_POPMSG, (UINT32)&Popup);
        }
    }
    else
    {
        if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_POPMSG))
        {
            SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_POPMSG);
        }
        APP_MenuMgr_SetMsgPopup(TRUE);
        SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, ATV_GUIOBJ_POPMSG, (UINT32)&Popup);
    }
    g_dCurPopup = u32CurPopup;

    return 1;
}

/*****************************************************************************
** FUNCTION : ATVApp_ClosePopup
**
** DESCRIPTION :
**				Close atv popmsg
**
** PARAMETERS :
**				u32ClosePopup  -  popmsg type
**				dMessage  -  send message type when close popmsg
**
** RETURN VALUES:
**				None
*****************************************************************************/
INT32 ATVApp_ClosePopup(UINT32 u32ClosePopup, UINT32 dMessage)
{
    UINT32 dCheckFlag;

    APP_MenuMgr_SetMsgPopup(FALSE);
    if (u32ClosePopup > PLAYBACK_POPUP_NONE)
    {
        if (u32ClosePopup == g_u32OldPopup)
        {
            if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_POPMSG))
            {
                SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_POPMSG);
            }
        }

        if (dMessage != UI_EVENT_NULL)
        {
            SYSAPP_IF_SendCriticalGlobalEventWithIndex(SYS_APP_ATV, dMessage, g_dCurPopup);
        }

        g_u32PopupWaitingList &= ~(1 << (u32ClosePopup - PLAYBACK_POPUP_NONE));

        if (u32ClosePopup == g_u32OldPopup)
        {
            g_u32OldPopup = PLAYBACK_POPUP_NONE;
            g_dCurPopup = PLAYBACK_POPUP_NONE;
            for (dCheckFlag = PLAYBACK_POPUP_MAX - 1;
                 dCheckFlag > PLAYBACK_POPUP_NONE; dCheckFlag--)
            {
                if (g_u32PopupWaitingList & (1 << (dCheckFlag - PLAYBACK_POPUP_NONE)))
                {
                    ATVApp_SchedulePopup(stPopupWaitingList[
                             	dCheckFlag-PLAYBACK_POPUP_NONE]);
                    break;
                }
            }
        }
    }
    else
    {
        if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_POPMSG))
        {
            SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_POPMSG);
        }

        if (dMessage != UI_EVENT_NULL)
        {
            SYSAPP_IF_SendCriticalGlobalEventWithIndex(SYS_APP_ATV, dMessage, g_dCurPopup);
        }

        if (g_u32OldPopup != PLAYBACK_POPUP_NONE)
        {
            g_u32OldPopup = PLAYBACK_POPUP_NONE;
        }

        g_dCurPopup = PLAYBACK_POPUP_NONE;

        if (dMessage == UI_EVENT_EXIT) //use g_stPopMsgParam.stParam.dParam1 to indicate that no need to pop scheculed pop.
        {
            return 1;
        }

        for (dCheckFlag = PLAYBACK_POPUP_MAX - 1; dCheckFlag > PLAYBACK_POPUP_NONE; dCheckFlag--)
        {
            if (g_u32PopupWaitingList & (1 << (dCheckFlag - PLAYBACK_POPUP_NONE)))
            {
                ATVApp_SchedulePopup(stPopupWaitingList[
                                         dCheckFlag-PLAYBACK_POPUP_NONE]);
                break;
            }
        }
    }
    return 1;
}

/*****************************************************************************
** FUNCTION : ATVApp_IsPopupExist
**
** DESCRIPTION :
**				Judge popmsg is exist
**
** PARAMETERS :
**				u32TargetPopup  -  popmsg type
**
** RETURN VALUES:
**				TRUE  -  exist
**				FALSE  -  not exist
*****************************************************************************/
UINT8 ATVApp_IsPopupExist(UINT32 u32TargetPopup)
{
	if (u32TargetPopup == g_u32OldPopup)
	{
		return TRUE;
	}
	else
	{
		if((u32TargetPopup > PLAYBACK_POPUP_NONE)
			&& (g_u32PopupWaitingList & (1 << (u32TargetPopup - PLAYBACK_POPUP_NONE))))
		{
			return TRUE;
		}
		else
		{
			return FALSE;
		}
	}
}

/*****************************************************************************
** FUNCTION : ATVApp_fw_callback
**
** DESCRIPTION :
**
**
** PARAMETERS :
**				None
**
** RETURN VALUES:
**				None
*****************************************************************************/
INT32 ATVApp_fw_callback(AFW_event_t event, void *param)
{
	UINT32 message = 0xffffffff;
	UINT32 dParam = 0;
	UINT32 Index = TOTAL_SYS_APP_SIZE;

	if (MAIN_APP_SUCCESS != MAINAPP_GetActiveSystemAppIndex(&Index))
	{
		atv_printf("[%s: %d] get active system app fail\n", __FUNCTION__, __LINE__);
	}

	if (Index == SYS_APP_ATV)
	{
		atv_printf(" Received event: %d from AFW module callback.\n\n",event);

		switch (event)
		{
			case FW_DATASAVING_ATVDB_STORE_START_EVENT:
			case FW_DATASAVING_DVBDB_STORE_START_EVENT:
			case FW_DATASAVING_ATVDB_STORE_END_EVENT:
			case FW_DATASAVING_DVBDB_STORE_END_EVENT:
				message = event;
				break;
			case FW_VIP_FINISH:
#ifdef SUPPORT_FACTORY_AUTO_TEST
				if(APP_Factory_GetAutoTestOnOff() == TRUE)
				{
					APP_Source_Type_t eSourType;
					APP_GUIOBJ_Source_GetCurrSource(&eSourType);
					APP_GOBJ_Source_Set_SourceCheck(eSourType);
				}
#endif
				message = APP_ATV_GLOBAL_EVENT_VIP_FINISH|PASS_TO_SYSAPP;
				break;

			case FW_VIP_STATUS:
				message = APP_ATV_GLOBAL_EVENT_VIP_STATUS|PASS_TO_SYSAPP;
				MID_DISP_DTVSetHdmiRGBRange(g_stPqSettingData.FMPictureMode.VIP.n_PicMode_VIP_HDMI_RGB_Range);
				break;
			case FW_SIGNAL_PRESENT:
#ifdef SUPPORT_FACTORY_AUTO_TEST
				if(APP_Factory_GetAutoTestOnOff() == TRUE)
				{
					APP_Source_Type_t eSourType;
					APP_GUIOBJ_Source_GetCurrSource(&eSourType);
					APP_GOBJ_Source_Set_SourceCheck(eSourType);
				}
#endif
				message = APP_ATV_GLOBAL_EVENT_SIGNAL_PRESENT|PASS_TO_SYSAPP;
			#ifdef CONFIG_QSD
				// To echo message with ATV has signal for chip test using.
				con_dbg_echo('G', 'O');
				con_dbg_echo('O', 'D');
			#endif
				break;
			case FW_NO_SIGNAL:
				message = APP_ATV_GLOBAL_EVENT_NO_SIGNAL|PASS_TO_SYSAPP;
			#ifdef CONFIG_QSD
				// To echo message with ATV has no signal for chip test using.
				con_dbg_echo('G', 'O');
				con_dbg_echo('O', 'D');
			#endif
				break;
			case FW_NOT_SUPPORT:
				message = APP_ATV_GLOBAL_EVENT_NOT_AVILABLE|PASS_TO_SYSAPP;
				break;
#ifdef CONFIG_VCHIP_SUPPORT
            case FW_VCHIP_LOCK:
            case FW_VCHIP_UNLOCK:
                message = event|PASS_TO_SYSAPP;
                break;
#endif
#ifdef CONFIG_SUPPORT_TTX
			case FW_TT_NO_DATA:
				message = event|PASS_TO_SYSAPP;
				break;
#endif
			case FW_AUDIO_HEADPHONE_PLUG_IN:
				message = APP_GLOBAL_EVENT_HEADPHONE_PLUG_IN|PASS_TO_SYSAPP;
				break;
			case FW_AUDIO_HEADPHONE_PLUG_OUT:
				message = APP_GLOBAL_EVENT_HEADPHONE_PLUG_OUT|PASS_TO_SYSAPP;
				break;
            case FW_AUDIO_ADC_TURNOFFSOUND:
                message = APP_GLOBAL_EVENT_ADC_TURNOFFSOUND|PASS_TO_SYSAPP;
                break;

			case FW_SCART_INPUTSRC_CHANGE:
				dParam = *(UINT32 *)param;
				message = APP_ATV_GLOBAL_EVENT_SCARTINPUT_CHANGE|PASS_TO_SYSAPP;
				break;
			case FW_HDMI_CHANGE_SOURCE:
				dParam = *(UINT32 *)param;
				message = APP_GLOBAL_EVENT_HDMI_CHANGE_SOURCE|PASS_TO_SYSAPP;
				break;
			case FW_AUDIO_SIF_SAS_OK:
				//if (!APP_IsScan_Running())
				{
                	TVFE_Audio_RFLineCTL(TRUE);
				}
                message = APP_ATV_GLOBAL_EVENT_SIF_SAS_OK|PASS_TO_SYSAPP;
				break;
			case FW_AUDIO_SIF_SCS_OK:
				message = APP_ATV_GLOBAL_EVENT_SIF_SCS_OK|PASS_TO_SYSAPP;
				break;
#ifdef CONFIG_SUPPORT_AUDIO_CODEC_OVERLAY
			case FW_AUDIO_LOADCODEC_OK:
			case FW_AUDIO_LOADCODEC_ERROR:
				dParam = *(UINT32 *)param;
				message = event|PASS_TO_SYSAPP;
				break;
			case FW_AUDIO_LOADCODEC_TYPE:
				{
					UINT16 new_condec = *(UINT32 *)param;
					TVFE_Audio_LOAD_CODEC_t stConfig;
					memset(&stConfig, 0, sizeof(TVFE_Audio_LOAD_CODEC_t));
					stConfig.flag = TVFE_AUDIO_CODEC_FLAG_SET;
					stConfig.new_type = new_condec;
					TVFE_Audio_Load_Codec(&stConfig);
					printf("\n\n[%s:%d] new_condec =========== %d\n\n\n",__FUNCTION__,__LINE__,new_condec);
				}
				break;
#endif
#ifdef CONFIG_SCART_SUPPORT
			case FW_SCART_INPUTSTATUS_CHANGE:
				dParam = *(UINT32 *)param;
				APP_SCARTIN_Pin8Function(dParam);
				break;
#endif
			case FW_HDMI_HDMIDVI_CHANGE:
				dParam = *(UINT32 *)param;
				message = APP_ATV_GLOBAL_EVENT_HDMIDVI_CHANGE|PASS_TO_SYSAPP;
				break;
			case FW_HDMI_ACPTYPE_CHANGE:
				dParam = *(UINT32 *)param;
				message = APP_ATV_GLOBAL_EVENT_HDMIACPTYPE_CHANGE|PASS_TO_SYSAPP;
				break;
#ifdef SUPPORT_CEC_TV
			case FW_HDMI_PORTSTATUS:
				dParam = *(UINT32 *)param;
				message = APP_ATV_GLOBAL_EVENT_HDMIPORT_STATUS|PASS_TO_SYSAPP;
				break;
#endif
			case FW_HDMI_PROCESSING:
				dParam = *(UINT32 *)param;
				message = APP_ATV_GLOBAL_EVENT_HDMI_PLUG_PROCESSING|PASS_TO_SYSAPP;
				break;
#ifdef CONFIG_QSD
			case FW_QSD_ATV_SetCH:
				dParam = (UINT32)APP_Database_GetHdlByIdx(*(UINT32 *)param);
				message = APP_ATV_INTRA_EVENT_ZAPPING|PASS_TO_SYSAPP;
				break;

			case FW_QSD_Media_Play:
				dParam = *(UINT32 *)param;
				message = APP_GLOBAL_EVENT_QSD_MEDIA_PLAY|PASS_TO_SYSAPP;
				break;

			case FW_QSD_Source_Set:
				dParam = *(UINT32 *)param;
				message = APP_GLOBAL_EVENT_QSD_SET_SOURCE|PASS_TO_SYSAPP;
				break;
			#ifdef CONFIG_DTV_SUPPORT
			case FW_QSD_DTV_SetFreq:
				APP_GUIOBJ_FM_DtvChnSet_LoadSettingData();
				break;
			#endif
#endif
		#ifdef CONFIG_SUPPORT_SW_AFC
			case FW_AFT_PROCESS_DONE:
                printf("FW_AFT_PROCESS_DONE\n");
				AFT_ProcessIsDone();
                //if (!APP_IsScan_Running())
				{
                	TVFE_Audio_RFLineCTL(TRUE);
				}
				break;
			case FW_AFT_ADEMOD_PQSET:
				{
                    printf("FW_AFT_ADEMOD_PQSET\n");
                    TVFE_TvDecFormatType_e format;
                    UINT32 DemodFilter = 0;
                    APP_OsdColorSystem_t color = 0;
                    Cmd_GetATVColorSystem(&format);
                    switch(format)
                    {
                        case TVFE_TvDecFORMAT_NTSC:
                            color = APP_OSD_COLOR_SYSTEM_NTSC358;
                            break;
                        case TVFE_TvDecFORMAT_PAL_M:
                            color = APP_OSD_COLOR_SYSTEM_PALM;
                            break;
                        case TVFE_TvDecFORMAT_PAL_N:
                            color = APP_OSD_COLOR_SYSTEM_PALCN;
                            break;
                        case TVFE_TvDecFORMAT_SECAM:
                            color = APP_OSD_COLOR_SYSTEM_SECAM;
                            break;
                        default:
                            break;
                    }
                    DemodFilter = APP_ATV_GetDemodFilter(color);
    				Cmd_Tuner_Demod_Set_Ddmod_Filter(DemodFilter);
                }
				break;
		#endif
		#ifdef CONFIG_HDMI_SUPPORT_MHL
			case FW_HDMI_MHL_RCP_CMD:
				dParam = *(UINT32 *)param;
				atv_printf("[%s:%d] dParam ======================== 0x%x\n",__FUNCTION__,__LINE__,dParam);
				_ATVApp_GetKeyByCmd(dParam, &message);
				atv_printf("[%s:%d] message ======================== 0x%x\n",__FUNCTION__,__LINE__,message);
				message = message|APPLICATION_EXTERNAL_UI_MESSAGE_TYPE;
				MSG_FILTER_DispatchMessage((UINT32)message, 0);
				return SP_SUCCESS;
			case FW_HDMI_MHL_CONNECTED:
				dParam = *(UINT32 *)param;
				atv_printf("[%s:%d] dParam(CbusConnected) ======================== 0x%x\n",__FUNCTION__,__LINE__,dParam);
				if(dParam == 1)
				{
					CbusconnectedFlag = TRUE;
					message = DMN_EVENT_MHL_CHANGE_SOURCE|PASS_TO_SYSAPP;
				}
				else
				{
					CbusconnectedFlag = FALSE;
				}
				break;
#endif
#ifdef CONFIG_HDMI_SPD
			case FW_HDMI_SPD_INFOFRAME_UPDATE:
			{
				dParam = *(UINT32 *)param;
				atv_printf("[%s:%d] dParam ======================== 0x%x\n",__FUNCTION__,__LINE__,dParam);

				if(dParam == 0)
				{
					bSPDCheck = 1;
				}
				else
				{
					bSPDCheck = 0;
				}

				break;
			}
#endif
			#ifdef CONFIG_SUPPORT_WIFI
			case FW_USB_PLUGIN:		
				dParam = *(UINT32 *)param;
				if(dParam == 0)
				{
					if(MID_NWSI_WLAN_CheckWifiDongle() == WIFI_DONGLE)
					{
						message = DMN_EVENT_WIFI_DONGLE_ATTACHED;
					}
				}
			break;
			#endif
			case FW_ADC_AUTOCHANGE_SOURCE:
				dParam = *(UINT32 *)param;
				message = APP_GLOBAL_EVENT_ADC_AUTO_CHANGE_SOURCE|PASS_TO_SYSAPP;
			break;

			default:
				message = 0xffffffff;
				break;
		}
	}
	else
	{
		switch (event)
		{
			default:
				message = 0xffffffff;
				break;
		}
	}

	if (message != 0xffffffff)
	{
		SYSAPP_IF_SendCriticalGlobalEventWithIndex(Index, message, dParam);

		return SP_SUCCESS;
	}
	else
	{
		return SP_ERR_FAILURE;
	}
}

void ATVApp_VolumeKeyHandler(UINT32 dMessage, UINT8 IsCECKey)
{
    UINT8 u8Mute = 0;
    APP_Source_Type_t eSourType = APP_SOURCE_MAX;

	if(IsCECKey == TRUE)
	{
	#ifdef SUPPORT_CEC_TV
		AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FEATURE, 0,
			sizeof(APP_SETTING_Feature_t), &(g_stFeatureData));
		if (( APP_SWITCH_ON == g_stFeatureData.Enable_HDMILink)
#ifdef SUPPORT_AMPLIFIER_CONTROL
			&&(APP_SWITCH_ON == g_stFeatureData.AmplifierControl)
#endif
			&&(APP_HDMILINK_AMPLIFIER == g_stFeatureData.SpeakerPreference) && APP_GUIOBJ_Source_GetAmplifierPort())
		{
			if (CECTV_GetCECEnable()==CECTV_ENABLE && CECTV_GetHDMISystemAudioMode() && APP_Check_CEC_DEVICE_Status())
			{
				if(APP_Get_HDMICEC_AMP_Mute_Status() == TRUE)
				{
					APP_Set_HDMICEC_AMP_Mute_Status(FALSE);
					APP_GUIOBJ_Mute_MuteKeyHandler();
					//CECTV_SendCmd(CECTV_SINGLE_ACT_CMD_KEYPRESS, CECTV_KEY_MUTE<<8|0x05);//Mute Function
					//SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_ATV, APP_GUIOBJ_MUTE, APP_INTRA_EVENT_HIDE_MUTE, 0);
				}
			}
		}
	#endif
	}
	else
	{
		APP_GUIOBJ_Source_GetCurrSource(&eSourType);
		AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_USERINFO, 0,
						sizeof(APP_SETTING_UserInfo_t), &(g_stUserInfoData));

		u8Mute = g_stUserInfoData.Mute;

		if (u8Mute == TRUE)
		{
			if (dMessage == UI_EVENT_VOL_UP || IsCECKey == TRUE)
			{
				if (g_u8SignalState == ATV_NO_SIGNAL)
				{
					APP_Audio_SetMute(FALSE, TRUE, APP_MUTE_MODE_NO_SIGNALE, eSourType);
				}
				else if (g_u8SignalState != ATV_INVALID_STATUS)
				{
					APP_Audio_SetMute(FALSE, TRUE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
				}
				g_stUserInfoData.Mute = FALSE;

				AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_USERINFO,
								 ITEM_OFFSET(APP_SETTING_UserInfo_t, Mute),
								 sizeof(g_stUserInfoData.Mute), &(g_stUserInfoData.Mute));
				#ifdef SUPPORT_STORE_MUTE_FLAG
				AL_Setting_Store(APP_Data_UserSetting_Handle(), SYS_SET_ID_USERINFO,
								 ITEM_OFFSET(APP_SETTING_UserInfo_t, Mute),
								 sizeof(g_stUserInfoData.Mute));
				#endif

#ifdef CONFIG_BLUETOOTH_SUPPORT
				if(eSourType == APP_SOURCE_BLUETOOTH)
				{
					APP_Audio_SetMute(FALSE, TRUE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
				}
#endif
#ifdef CONFIG_OSD_GAME_SUPPORT
				if(eSourType == APP_SOURCE_GAME)
				{
					APP_Audio_SetMute(FALSE, TRUE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
				}
#endif
				SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_ATV, APP_GUIOBJ_MUTE, APP_INTRA_EVENT_HIDE_MUTE, 0);
			}
		}
	}

    if (ATVApp_IsPopupExist(PLAYBACK_POPUP_MSG_NO_SIGNAL))
    {
        ATVApp_ClosePopup(PLAYBACK_POPUP_MSG_NO_SIGNAL, UI_EVENT_NULL);
    }
    if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_BANNER))
    {
        SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, APP_GUIOBJ_BANNER);
    }
	if(IsCECKey == TRUE
#ifdef SUPPORT_CEC_TV
		&& CECTV_GetHDMISystemAudioMode() && APP_Check_CEC_DEVICE_Status()
#endif
	)
	{
		if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_ADJUST))
		{
			SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, APP_GUIOBJ_ADJUST);
		}

#ifdef SUPPORT_CEC_TV
		if(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_AMPLIFIERVOLUME))
		{
			SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, APP_GUIOBJ_AMPLIFIERVOLUME);
		}
		else
		{
			SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, APP_GUIOBJ_AMPLIFIERVOLUME, 0);
		}
#endif
	}
	else
	{
#ifdef SUPPORT_CEC_TV
		if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_AMPLIFIERVOLUME))
		{
			SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, APP_GUIOBJ_AMPLIFIERVOLUME);
		}
#endif

		if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_ADJUST))
		{
			SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, APP_GUIOBJ_ADJUST);
		}
		else
		{
			UINT8 u8VolumeIdx = g_stVariationalData.Volume;
            if (dMessage == UI_EVENT_VOL_UP)
			{
				g_stVariationalData.Volume = u8VolumeIdx >= ADJUST_MAX_VALUE ? ADJUST_MAX_VALUE : ++u8VolumeIdx;
			}
			else if (dMessage == UI_EVENT_VOL_DN)
			{
				g_stVariationalData.Volume = u8VolumeIdx <= ADJUST_MIN_VALUE ? ADJUST_MIN_VALUE : --u8VolumeIdx;
			}
			AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FACTHOTEL, 0,
					sizeof(APP_SETTING_FactoryHotel_t), &(g_stFactoryHotelData));
			if ((g_stFactoryHotelData.MaxVolume < g_stVariationalData.Volume)
				&&(g_stFactoryHotelData.HotelModeOnOff == 1))
			{
				g_stVariationalData.Volume = g_stFactoryHotelData.MaxVolume;
			}
			APP_Audio_SetVolume((UINT32)g_stVariationalData.Volume);
			AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_VARIATIONAL,
							 ITEM_OFFSET(APP_SETTING_Variational_t, Volume),
							 sizeof(g_stVariationalData.Volume), &(g_stVariationalData.Volume));
/*
			// store volume value when adjust guiobj exit
			AL_Setting_Store(APP_Data_UserSetting_Handle(), SYS_SET_ID_VARIATIONAL,
							 ITEM_OFFSET(APP_SETTING_Variational_t, Volume), sizeof(g_stVariationalData.Volume));
*/
			SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, APP_GUIOBJ_ADJUST, ADJUST_VOLUME);
		}
	}
}