UTS6710/aps/application/s2tek/formal/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 "ap_extern.h"
#include "al_fw.h"
#include "atv_app.h"
#include "main_app.h"
#include "app_event.h"
#include "app_atv_event.h"
#ifdef CONFIG_ATV_SUPPORT
#include "app_atv_playback.h"
#endif
#if defined(CONFIG_DVB_SYSTEM) || defined(CONFIG_AUS_DVB_SYSTEM) || defined(CONFIG_DTMB_SYSTEM)
#include "dvb_app.h"
#endif
#ifdef CONFIG_DTV_SUPPORT
#ifdef CONFIG_SUPPORT_PVR
#include "al_prog_reminder.h"
#endif
#ifdef CONFIG_ISDB_SYSTEM
#include "sbtvd_app.h"
#include "app_sbtvd_playback.h"
#include "app_guiobj_sbtvd_table.h"
#include "app_guiobj_sbtvd_playback.h"
#include "app_guiobj_sbtvd_chnlist.h"
#endif
#endif
#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"
#if defined(CONFIG_DTV_SUPPORT) || defined(CONFIG_ATV_SUPPORT)
#include "app_prog_list.h"
#include "app_scan_api.h"
#endif
#include "app_power_control.h"
#include "app_systime.h"
#include "app_video.h"
#include "app_audio.h"
#ifdef CONFIG_SCART_SUPPORT
#include "app_scart.h"
#endif
#include "app_usb_upgrade.h"
#ifndef CONFIG_SUPPORT_MONITOR
#include "app_guiobj_picture.h"
#include "app_guiobj_sound.h"
#include "app_guiobj_channel.h"
#endif
#include "app_guiobj_adjust.h"
#ifdef CONFIG_ATV_SUPPORT
#include "app_guiobj_atv_playback.h"
#include "app_guiobj_atv_prognum.h"
#include "app_guiobj_auto_search.h"
#include "app_guiobj_scan_process.h"
#include "app_guiobj_atv_pcsetup.h"
#endif
#ifdef CELLO_cello
#include "app_guiobj_auto_installation_cello.h"
#else
#include "app_guiobj_auto_installation.h"
#endif
#include "app_guiobj_banner.h"
#include "app_guiobj_sleeptimer.h"
#include "app_guiobj_mute.h"
#include "app_guiobj_fm_factory.h"
#include "app_guiobj_cul_fm_HotelSetting.h"
#include "app_guiobj_fm_Hotel_Mode_Adj.h"
#include "app_guiobj_mainmenu.h"
#include "app_guiobj_source.h"
#include "atv_guiobj_table.h"
#ifdef SUPPORT_CEC_TV
#include "umf_cec.h"
#include "app_guiobj_hdmilink.h"
#endif
#ifdef SUPPORT_FACTORY_AUTO_TEST
#include "al_aps_table_api.h"
#include "mid_atv_scan.h"
#endif
#if defined(CONFIG_DTV_SUPPORT) || defined(CONFIG_ATV_SUPPORT)
#include "tuner_demod_ioctl.h"
#endif
#include "app_sysset.h"
#include "app_guiobj_cul_fm_factorySetting_new.h"
#ifdef N32_GAME_SUPPORT
#include "app_clone_data.h"
#endif
#if defined(CONFIG_SCART_SUPPORT) || defined(CONFIG_ATV_SUPPORT) || defined(CONFIG_AV_SUPPORT) || defined(CONFIG_SV_SUPPORT)
#include "cvd2_ioctl.h"
#endif
#ifdef CONFIG_ATV_SUPPORT
#include <drv_sif_interface.h>
#endif
#include "adc_ioctl.h"
#include "hdmi_ioctl.h"
#include "nvm_ioctl.h"
#include "cust_nvm_cfg.h"
#ifdef CONFIG_SUPPORT_HDMI_PLUGIN_CHANGE_SOURCE
#include "cecd_interface.h"
#endif
#ifdef CONFIG_SUPPORT_DETECT_USBPLL


#endif
#ifdef CONFIG_CC_SUPPORT
#include "al_cc.h"
#endif
#ifdef CONFIG_SUPPORT_SW_AFC
#include "mid_afc.h"
#endif

#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_SUPPORT_INDONESIA_EWS
#include "app_guiobj_ews_areacodesetting.h"
#endif
#ifdef CONFIG_SUPPORT_MIRACAST
#include "umf_miracast.h"
#endif
#ifdef CONFIG_SMART_MODULE_SUPPORT
#include "app_smart.h"
#endif

#ifdef CONFIG_SUPPORT_KEY_BOARD
#include "umf_keyBoard.h"
#endif

#ifdef CONFIG_ENABLE_UMF_MODULES
#include "umf_mod.h"
#endif

#ifdef CONFIG_SUPPORT_NET_OTA
#include "net_ota.h"
#endif

#include "gl_task.h"
#include "app_usermenu.h"
#include <drv_pq_internal.h>
#include "app_guiobj_menutree.h"


/********************************************************************
	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		(30)//30*100 ms
#define  HDMI_NO_SIGNAL_BOUNCE_TIME		(30)//30*100 ms
#define ATV_NO_SIGNAL_BOUNCE_TIME	(30)
#define AV_NO_SIGNAL_BOUNCE_TIME	(600)
#ifdef CONFIG_SUPPORT_NOSIGNAL_AUTO_CHANGE_SOURCE
#define CHECK_SIGNAL_TIMES	(1)
#endif

/********************************************************************
	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();
#ifdef CONFIG_SUPPORT_HOTKEY_SOURCE_LOCK
extern void SourceLock_Set_Hotkey_Flag(bool g_SourceLock_flag);
#endif
#ifdef CONFIG_SUPPORT_NOSIGNAL_AUTO_CHANGE_SOURCE
void ATVApp_SwitchSourceToCheckSignal(void);
void ATVApp_Reset_SwitchSourceToCheckSignal_Flag(void);
#endif
#ifdef CONFIG_SUPPORT_3D_EN
extern UINT8 bSet3DMode;
#endif
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 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;
#ifdef CONFIG_ATV_SUPPORT
static UINT8 g_u8CheckMTSTimer = 0;
static UINT8 IsAlreadyFirstSetMTS = 0;
static UINT8 g_u8SIF_SCS_OK = 0;
static UINT8 g_u8SIF_SCS_OK_HasCheck = 0;
#endif
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_SUPPORT_PVR
extern AL_DB_ERecordType_t g_eRecType;
extern AL_SCH_sched_id_t g_dReminderId;
extern AL_PR_details_t g_stDetails;
Boolean g_bShowReminder = FALSE;//for mantis 180711, for fine tune issue
#endif
#ifdef CONFIG_CONFIRM_AUTO_UPGRADE
static int dLastFocusedIndex = 0;
#endif
extern Boolean gUSBUpgradeBinIsSupperBin;
extern UINT8 gIsFactoryResetting;

al_bool g_ATVbLastParentLock = al_false;

static UINT8 g_VCPPowerMode = 1; // panel on

static UINT8 g_ADCAutoChange = FALSE;
#ifdef CONFIG_SUPPORT_NOSIGNAL_AUTO_CHANGE_SOURCE
static UINT8 g_CheckSignal = FALSE;
static UINT8 g_CheckSignal_Times = 0xFF;
static APP_SourceConfig_t g_stSourceConfigTable_New[APP_SOURCE_MAX];
static UINT16 g_u16SourceConfigTable_Size_New;
#endif

#ifdef CONFIG_SUPPORT_TTX
static UINT8 TTXSubtitleExistFlag = FALSE;
#ifdef CONFIG_SUPPORT_HOTKEY_SOURCE_LOCK
static BOOL g_fmSourceLock_flag = FALSE;
#endif


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

#ifdef CONFIG_VCHIP_SUPPORT
static Boolean VchipLockFlag = FALSE;
static Boolean PreVchipLockFlag = 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_ATV)
    {
#ifdef CONFIG_ATV_SUPPORT
        Lock = APP_GUIOBJ_ATV_Playback_GetProgramState();
#endif
    }
    else if((eSourType >= APP_SOURCE_SCART) && (eSourType <= APP_SOURCE_YPBPR2))
    {
#ifndef CONFIG_SUPPORT_MONITOR
        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;
        }
#endif
    }
    return Lock;
}
Boolean ATVAPP_GetVchipLockFlag(void)
{
	return VchipLockFlag;
}
#endif
#ifdef CONFIG_CC_SUPPORT
/*cc ui can't coexist with other ui for mantis0036921.*/
static Boolean _ATVAPP_DisplayCCFlag(void)
{
    MID_InputInfo_t TimingInfo;
    MID_TVFE_GetCurrentVideoInfo(&TimingInfo, NULL);
   /*NTSC-M/PAL-M/PAL-N/NTSC-4 B/G need support cc,
     other color system need support ttx.*/
    if((TimingInfo.eCvd2ColorFormat == MID_CVD2_STD_NTSC_M)
        || (TimingInfo.eCvd2ColorFormat == MID_CVD2_STD_PAL_M)
        || (TimingInfo.eCvd2ColorFormat == MID_CVD2_STD_PAL_CN)
        || (TimingInfo.eCvd2ColorFormat == MID_CVD2_STD_NTSC_443))
    {
        int dFocusedIndex = ATV_GUIOBJ_MAX;
        if(SYSTEM_APP_NO_FOCUSED_GUIOBJ == SYSAPP_GOBJ_GetFocusedGUIObject(SYS_APP_ATV, &dFocusedIndex))
        {
            return TRUE;
        }
        else if((SYSTEM_APP_SUCCESS == SYSAPP_GOBJ_GetFocusedGUIObject(SYS_APP_ATV, &dFocusedIndex))
            && (dFocusedIndex == APP_GUIOBJ_MUTE))
        {
            return TRUE;
        }
    }
    return FALSE;
}
#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 SysApp_ATV_Reset_ADCAutoChnageFlag(void)
{
	g_ADCAutoChange = FALSE;
}


void ATVApp_SetVIPFINISHFlag(UINT8 flag)
{
	bSetVIPFINISHFlag = flag;
}
#ifdef CONFIG_ATV_SUPPORT
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;
}
#endif
static void _ATVAPP_ShowPopup(ATV_AppPopMsgType_t ePopType)
{
    PopmsgParam_t stPopup;
#ifdef CONFIG_ATV_SUPPORT
    if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_SCAN_PROCESS))
    {
        return;
    }
#endif
    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;
#ifndef CONFIG_SUPPORT_MONITOR
        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;
#endif
        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_KEY_NONE;
            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;
#ifdef CONFIG_SUPPORT_PVR
        case ATV_APP_POP_MSG_PVR_REMIDER:
            stPopup.eType = POPMSG_TYPE_CONFIRM;
            stPopup.u16Exitkeys =  POPMSG_EXIT_KEY_NONE;
            stPopup.u16ReturnType = GUI_OBJECT_NO_POST_ACTION;
            stPopup.extend.stConfirm.eConfirmType = POPMSG_CONFIRM_REC_REMIDER_TIME;
            stPopup.extend.stConfirm.u8Default = POPMSG_YES;
            stPopup.extend.stConfirm.iTimeout = DVBApp_GetReminderTime2Show()+1;
            break;
        case ATV_APP_POP_MSG_PVR_REMIDER_CONFIRM:
            stPopup.eType = POPMSG_TYPE_CONFIRM;
            stPopup.u16Exitkeys =  POPMSG_EXIT_KEY_NONE;
            stPopup.u16ReturnType = GUI_OBJECT_POST_EVENT | GUI_OBJECT_EVENT_BYPASS;
            stPopup.extend.stConfirm.eConfirmType = POPMSG_CONFIRM_REC_REMIDER_TIME_CONFIRM;
            stPopup.extend.stConfirm.u8Default = POPMSG_NO;
            break;
        case ATV_APP_POP_MSG_INSERT_USB:
            stPopup.eType = POPMSG_TYPE_PROMPT;
            stPopup.u16Exitkeys =  POPMSG_EXIT_KEY_NONE;
            stPopup.u16ReturnType = GUI_OBJECT_EVENT_BYPASS;
            stPopup.extend.stPrompt.ePromptType = POPMSG_PROMPT_INSERT_USB;
            stPopup.extend.stPrompt.iTimeout = 3;
            break;
        case ATV_APP_POP_MSG_INVALID_USB:
            stPopup.eType = POPMSG_TYPE_PROMPT;
            stPopup.u16Exitkeys =  POPMSG_EXIT_KEY_NONE;
            stPopup.u16ReturnType = GUI_OBJECT_EVENT_BYPASS;
            stPopup.extend.stPrompt.ePromptType = POPMSG_PROMPT_INVALID_USB;
            stPopup.extend.stPrompt.iTimeout = 3;
            break;
        case ATV_APP_POP_MSG_INSERT_USB_CONFIRM:
            stPopup.eType = POPMSG_TYPE_CONFIRM;
            stPopup.u16Exitkeys =  POPMSG_EXIT_EXIT | POPMSG_EXIT_RETURN;
            stPopup.u16ReturnType = GUI_OBJECT_POST_EVENT | GUI_OBJECT_EVENT_BYPASS;
            stPopup.extend.stConfirm.eConfirmType = POPMSG_CONFIRM_INSERT_USB;
            stPopup.extend.stConfirm.u8Default = POPMSG_NO;
            break;
        case ATV_APP_POP_MSG_INVALID_USB_CONFIRM:
            stPopup.eType = POPMSG_TYPE_CONFIRM;
            stPopup.u16Exitkeys =  POPMSG_EXIT_EXIT | POPMSG_EXIT_RETURN;
            stPopup.u16ReturnType = GUI_OBJECT_POST_EVENT | GUI_OBJECT_EVENT_BYPASS;
            stPopup.extend.stConfirm.eConfirmType = POPMSG_CONFIRM_INVALID_USB;
            stPopup.extend.stConfirm.u8Default = POPMSG_NO;
            break;
#endif
        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;
#ifdef N32_GAME_SUPPORT
		case ATV_APP_POP_MSG_IMPORTING_GAME:
            stPopup.eType = POPMSG_TYPE_PROMPT;
            stPopup.u16Exitkeys =  POPMSG_EXIT_KEY_NONE;
            stPopup.u16ReturnType = GUI_OBJECT_NO_POST_ACTION;
            stPopup.extend.stPrompt.ePromptType = POPMSG_N32GAME_IMPORTING_GAME;
            stPopup.extend.stPrompt.iTimeout = 2;
            break;
		case ATV_APP_POP_MSG_NO_SIZE_FOR_GAME:
			stPopup.eType = POPMSG_TYPE_PROMPT;
			stPopup.u16Exitkeys =  POPMSG_EXIT_KEY_NONE;
			stPopup.u16ReturnType = GUI_OBJECT_NO_POST_ACTION ;
			stPopup.extend.stPrompt.ePromptType = POPMSG_N32GAME_NO_SIZE_FOR_GAME;
			stPopup.extend.stPrompt.iTimeout = 2;
			break;
#endif
		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;
#ifdef CONFIG_SUPPORT_NET_OTA
		case ATV_APP_POP_MSG_FTP_FILE_DOWNLOAD_WAITING:
			stPopup.eType = POPMSG_TYPE_PROMPT;
			stPopup.u16ReturnType = GUI_OBJECT_NO_POST_ACTION ;
			stPopup.extend.stPrompt.iTimeout = 0;
			stPopup.extend.stPrompt.ePromptType = POPMSG_FTP_FILE_DOWNLOAD_WAITING;
			break;
#endif
		case ATV_APP_POP_MSG_OSDLOCK:
            stPopup.eType = POPMSG_TYPE_PROMPT;
            stPopup.u16Exitkeys =  POPMSG_EXIT_EXIT;
            stPopup.u16ReturnType = GUI_OBJECT_POST_EVENT;
            stPopup.extend.stPrompt.ePromptType = POPMSG_PROMPT_OSDLOCK;
            stPopup.extend.stPrompt.iTimeout = 2;
            break;

		case ATV_APP_POP_MSG_INPUT_INFO:
			stPopup.eType = POPMSG_TYPE_PROMPT;
			stPopup.u16Exitkeys =  POPMSG_EXIT_KEY_NONE;
			stPopup.u16ReturnType = GUI_OBJECT_POST_EVENT | GUI_OBJECT_EVENT_BYPASS;
			stPopup.extend.stPrompt.ePromptType = POPMSG_PROMPT_INPUT_INFO;
			stPopup.extend.stPrompt.iTimeout = 2;
			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);
}
#ifdef CONFIG_ATV_SUPPORT
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;
}
#endif
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;
#ifdef CONFIG_ATV_SUPPORT
    if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_SIF))
    {
        SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_SIF);
    }

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

    if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_PROGNUM))
    {
        SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_PROGNUM);
    }
#endif
    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 == ATV_GUIOBJ_PLAYBACK
#ifndef CONFIG_SUPPORT_MONITOR
            || u32GuiObj == ATV_GUIOBJ_FREEZE
            || u32GuiObj == APP_GUIOBJ_MUTE
#ifndef CONFIG_ISDB_SYSTEM
            || u32GuiObj == APP_GUIOBJ_KEYPADMENU
#endif 
#endif
            || u32GuiObj == ATV_GUIOBJ_POPMSG               
#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
#ifdef CONFIG_KEYPAD_SINGLE_REUSE
			|| (u32GuiObj == APP_GUIOBJ_SINGLEKEYPAD)
#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);
    }
#ifdef CONFIG_SUPPORT_CEC_TV
    if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_SOURCE_CEC))
    {
        SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, APP_GUIOBJ_SOURCE_CEC);
    }
#endif
#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
//#ifndef CONFIG_ISDB_SYSTEM
#ifndef CONFIG_SUPPORT_MONITOR
#ifndef CONFIG_SUPPORT_ATV_SCAN_NTSCM_PALM_N
    if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_INITINSTALL))
    {
        SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, APP_GUIOBJ_INITINSTALL);
    }
//#endif
#endif
#endif
    if (g_u32OldPopup == PLAYBACK_POPUP_NONE)
    {
        _ATVApp_CloseAllMenu();
    }

    APP_Source_Type_t eSourType = APP_SOURCE_MAX;
    APP_GUIOBJ_Source_GetCurrSource(&eSourType);

    switch (eSourType)
    {
#ifdef CONFIG_ATV_SUPPORT
        case APP_SOURCE_ATV:
            if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_INPUTINFO))
            {
                SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_INPUTINFO);
            }
            /*have available signal*/
            if (g_u8SignalState == ATV_AVAILABLE_SIGNAL)
            {
                if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_PLAYBACK))
                {
                    if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_PLAYBACK))
                    {
                        SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV,
                                                             ATV_GUIOBJ_PLAYBACK, 0);
                    }
                    SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_ATV, ATV_GUIOBJ_PLAYBACK,
                                                         APP_ATV_INTRA_EVENT_START_PLAYBACK, FALSE);
                }
            }

            _ATVApp_CheckPopupDisplay();

            /*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))
                {
#ifdef CONFIG_KEYPAD_SINGLE_REUSE
                	if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV,APP_GUIOBJ_SINGLEKEYPAD))
#endif
					{
	                    SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_ATV,
	                            	APP_ATV_GLOBAL_EVENT_POPMSG_NO_SIGNAL, 0);
					}
                }
            }

            break;
#endif
        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))
                {
#ifndef CONFIG_SUPPORT_MONITOR
#ifdef CONFIG_KEYPAD_SINGLE_REUSE
                	if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV,APP_GUIOBJ_KEYPADMENU))
#endif
#endif
					{
	                    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_CLOCK))
	{
		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)
		{
			/* save pc auto tune information */
			Cmd_AdcGetAdcPhase(&PC_Tempvalue.PCPhase);
#ifndef CONFIG_SUPPORT_MONITOR			
			APP_GUIOBJ_ATV_PCSetup_ResetPCSetupData();
#endif
			PC_Tempvalue.PCHPosition = APP_PC_HPOS_DEF;
			PC_Tempvalue.PCVPosition = APP_PC_VPOS_DEF;
#ifndef CONFIG_SUPPORT_MONITOR
			PC_Tempvalue.PCPhase =
				APP_GUIOBJ_ATV_PCSetup_PhaseMappingtoOSDValue(PC_Tempvalue.PCPhase);
#else
			PC_Tempvalue.PCPhase =
				APP_UserMenu_PCSetup_PhaseMappingtoOSDValue(PC_Tempvalue.PCPhase);
#endif
			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]));
#ifdef CONFIG_DDC_CI_SUPPORT
			Cmd_AdcAdjust(ADC_CMD_DDCCI_OSD_CLOCK, g_stSysInfoData.stPC_AutoTune[wFIFOTblIdx].i8ClockOffset);
			Cmd_AdcAdjust(ADC_CMD_DDCCI_OSD_PHASE, g_stSysInfoData.stPC_AutoTune[wFIFOTblIdx].Phase);
#endif
			PCAutoTune_FIFOTable_Update(eResolution, wFIFOTblIdx);
		}
	}

    return 0;
}

static INT32 _ATVApp_ResetAllSetting(void)
{
	App_Data_UserSetting_Restore();
	App_Data_UserSetting_FM_Restore();
	App_Data_UserSetting_ResetLangContry_ByFMDefaultValue();
	APP_Video_ResetTVSetting();
	GL_TaskSleep(200);


	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_FACTUSER,0, sizeof(APP_SETTING_FactoryUser_t), &g_stFactoryUserData);

	int value;

	// Gamma table
	int Mode = (INT32)AL_FLASH_GetWBMode();
	value = AL_FLASH_GetWBGammaTable(Mode);

	UINT8 nSwitchState = AL_FLASH_GetGammaType();
	if(nSwitchState)
	{
		MID_TVFE_SetColorTmpGammaTableIndex(value);
	}

	// Noise reduction
	value = AL_FLASH_GetPictureNR();
	MID_TVFE_SetPictureNR( value );
	MID_TVFE_SetPictureMPEGNR( value );

	// Color Matrix
	value = AL_FLASH_GetPictureColorMatrix();
	MID_TVFE_SetPictureColorMatrix( value );

	// Dithering level
	value = AL_FLASH_GetPictureDithering();
	MID_TVFE_SetPictureDithering( value );
    if(value == PQ_DITHER_METHOD_1)
    {
	    MID_TVFE_SetPictureDitheringLevel( AL_FLASH_GetPictureDitheringBit() );
    }
    else if(value == PQ_DITHER_METHOD_2)
    {
        MID_TVFE_SetPictureDitheringLevel( AL_FLASH_GetPictureDitheringBit_M2() );
    }

    if(value != PQ_DITHER_DISABLE)
    {
        MID_TVFE_SetPictureDitheringAlgorithm(AL_FLASH_GetPictureDitheringAlgorithm());
    }
	// 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 );

	//Dynamic BL
	Backlight_t BacklightSetting;
	BacklightSetting.Backlight_total_Stage = 100; // set total backlight stage = 100

	if(AL_FLASH_GetDynamicBackLight())
	{
		MID_TVFE_SetPictureDynamicBacklight(TRUE);
	}
	else
	{
		MID_TVFE_SetPictureDynamicBacklight(FALSE);
		BacklightSetting.OSD_backlight_index = AL_FLASH_GetBackLight();
		Cmd_SetLcdBackLight(BacklightSetting);
	}
	return 0;
}

static INT32 _ATVApp_ResetLumContrastSetting(void)
{
	APP_Source_Type_t eSourType = APP_SOURCE_MAX;
	APP_StorageSource_Type_t eStorageSourType = APP_STORAGE_SOURCE_MAX;
	APP_GUIOBJ_Source_GetCurrSource(&eSourType);
	eStorageSourType = APP_Data_UserSetting_SourceTypeMappingToStorage(eSourType);
	
	AL_Setting_ReadDefault(APP_Data_UserSetting_Handle(), SYS_SET_ID_PICTURE,
		(al_uint8*)&g_stSettingDefault_Picture);
	AL_Setting_Store(APP_Data_UserSetting_Handle(), SYS_SET_ID_PICTURE, 
		ITEM_OFFSET(APP_SETTING_Picture_t, stPictureModeSourceTab[eStorageSourType].PictureModeIndex), 
		sizeof(g_stPictureData.stPictureModeSourceTab[eStorageSourType].PictureModeIndex));
	AL_Setting_Store(APP_Data_UserSetting_Handle(), SYS_SET_ID_PICTURE, 
		ITEM_OFFSET(APP_SETTING_Picture_t, PictureMode[eSourType]), 
		sizeof(g_stPictureData.PictureMode[eSourType]));
	AL_Setting_Reload(APP_Data_UserSetting_Handle(), SYS_SET_ID_PICTURE);
	AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_PICTURE, 0,
		sizeof(APP_SETTING_Picture_t), &(g_stPictureData));
	APP_Video_SetPictureMode(g_stPictureData.stPictureModeSourceTab[eStorageSourType].PictureModeIndex);
	return 0;
}

INT32 ATVApp_ResetGeometrySetting(void)
{
	UINT16 usTimingTblIdx;
	PLF_VideoID_t eResolution;
	Boolean UserFlag;
	APP_SETTING_PC_AutoTune_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;
	}
	MID_TVFE_DoAutoTune(1);
	Cmd_AdcGetAdcPhase(&PC_Tempvalue.Phase);
	PC_Tempvalue.i8HpositionOffset = APP_PC_HPOS_DEF;
	PC_Tempvalue.i8VpositionOffset = APP_PC_VPOS_DEF;
	PC_Tempvalue.Phase = APP_UserMenu_PCSetup_PhaseMappingtoOSDValue(PC_Tempvalue.Phase);
	PC_Tempvalue.i8ClockOffset = 0;

	PCAutoTune_FIFOTable_Search(eResolution, &usTimingTblIdx, &UserFlag);
	g_stSysInfoData.stPC_AutoTune[usTimingTblIdx].i8HpositionOffset = PC_Tempvalue.i8HpositionOffset;
	g_stSysInfoData.stPC_AutoTune[usTimingTblIdx].i8VpositionOffset = PC_Tempvalue.i8VpositionOffset;
	g_stSysInfoData.stPC_AutoTune[usTimingTblIdx].i8ClockOffset = PC_Tempvalue.i8ClockOffset;
	g_stSysInfoData.stPC_AutoTune[usTimingTblIdx].Phase = PC_Tempvalue.Phase;

	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]));
#ifdef CONFIG_DDC_CI_SUPPORT
	Cmd_AdcAdjust(ADC_CMD_DDCCI_OSD_CLOCK, g_stSysInfoData.stPC_AutoTune[usTimingTblIdx].i8ClockOffset);
	Cmd_AdcAdjust(ADC_CMD_DDCCI_OSD_PHASE, g_stSysInfoData.stPC_AutoTune[usTimingTblIdx].Phase);
#endif
	return 0;
}

static INT32 _ATVApp_ResetColorSetting(void)
{
	APP_Source_Type_t eSourType = APP_SOURCE_MAX;
	APP_StorageSource_Type_t eStorageSourType = APP_STORAGE_SOURCE_MAX;
	APP_GUIOBJ_Source_GetCurrSource(&eSourType);
	eStorageSourType = APP_Data_UserSetting_SourceTypeMappingToStorage(eSourType);
	
	AL_Setting_ReadDefault(APP_Data_UserSetting_Handle(), SYS_SET_ID_PICTURE,
		(al_uint8*)&g_stSettingDefault_Picture);
	AL_Setting_ReadDefault(APP_Data_UserSetting_Handle(), SYS_SET_ID_FACTUSER,
		(al_uint8*)&g_stSettingDefault_FactoryUser);
	
	AL_Setting_Store(APP_Data_UserSetting_Handle(), SYS_SET_ID_PICTURE, 0, sizeof(APP_SETTING_Picture_t));
	AL_Setting_Reload(APP_Data_UserSetting_Handle(), SYS_SET_ID_PICTURE);

	AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FACTUSER,0,
			sizeof(APP_SETTING_FactoryUser_t), &g_stFactoryUserData);

	memcpy(&(g_stFactoryUserData.PictureMode.WBAdjust), &(g_stSettingDefault_FactoryUser.PictureMode.WBAdjust), sizeof(APP_PictureMode_ColorTempAdjust_t));
	AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_FACTUSER,
					ITEM_OFFSET(APP_SETTING_FactoryUser_t, PictureMode.WBAdjust),
					sizeof(g_stFactoryUserData.PictureMode.WBAdjust),
					&(g_stFactoryUserData.PictureMode.WBAdjust));

	AL_Setting_Store(APP_Data_UserSetting_Handle(), SYS_SET_ID_FACTUSER,
                     ITEM_OFFSET(APP_SETTING_FactoryUser_t, PictureMode.WBAdjust), sizeof(APP_PictureMode_ColorTempAdjust_t));

	AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_PICTURE, 0,
		sizeof(APP_SETTING_Picture_t), &(g_stPictureData));
	APP_Video_SetPictureMode(g_stPictureData.stPictureModeSourceTab[eStorageSourType].PictureModeIndex);
	APP_Video_OSD_PQSet(APP_VIDEO_OSD_ITEM_COLORTEMP, g_stPictureData.stPictureModeSourceTab[eStorageSourType].ColorTempIndex);
	APP_Video_OSD_PQSet(APP_VIDEO_OSD_ITEM_NR, g_stPictureData.NR);
	return 0;
}

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

    APP_GUIOBJ_Source_GetCurrSource(&eSourType);

    if (bMuteFlag)
    {
#ifdef CONFIG_ATV_SUPPORT
        if (AL_CS_IsStop())
#endif
        {
            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 (ATVApp_GetSignalState() == ATV_SIGNAL_IN_PROGRESS)
            {
                if ((g_stSetupData.BlueScreen == APP_SWITCH_ON))
                {
                    if (ATVApp_CheckProgramType(FALSE) == SP_SUCCESS)
                    {
                        APP_Audio_SetMute(TRUE, TRUE, APP_MUTE_MODE_NO_SIGNALE, eSourType);
                        MID_DISP_DTVSetVideoMute(0,0,0);
#ifdef CONFIG_SCART_SUPPORT						
                        APP_SCARTOUT_SetVideoMute(eSourType, FALSE, FALSE);
#endif
                    }
                }
                else
                {
                    APP_Audio_SetMute(TRUE, TRUE, APP_MUTE_MODE_NO_SIGNALE, eSourType);
                    APP_Video_SetMute(TRUE, TRUE, APP_MUTE_MODE_NO_SIGNALE, 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);
#ifdef CONFIG_SCART_SUPPORT
                        APP_SCARTOUT_SetVideoMute(eSourType, FALSE, FALSE);
#endif
                    }
                }
                else
                {
                    APP_Audio_SetMute(TRUE, TRUE, APP_MUTE_MODE_NO_SIGNALE, eSourType);
                    APP_Video_SetMute(TRUE, TRUE, APP_MUTE_MODE_NO_SIGNALE, eSourType);
                }
            }
#ifndef CONFIG_SUPPORT_MONITOR
            if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_FREEZE))
            {
                SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_FREEZE);
            }
#endif
#ifndef CONFIG_SUPPORT_MONITOR
            MID_DISP_DTVGetPause(&bFreezeFlag);
            if (bFreezeFlag)
            {
                MID_DISP_DTVSetPause(FALSE);
            }
#endif
        }
#ifdef CONFIG_ATV_SUPPORT
        else
        {
		#ifdef CONFIG_ISDB_SYSTEM
            AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_SETUP, 0,
                            sizeof(APP_SETTING_Setup_t), &(g_stSetupData));
            if ((g_stSetupData.BlueScreen == APP_SWITCH_ON))
            {
                MID_DISP_DTVSetVideoMute(0,0,255);
            }
            else
            {
                APP_Video_SetMute(TRUE, TRUE, APP_MUTE_MODE_NO_SIGNALE, eSourType);
            }
        #endif

        #ifdef CONFIG_SUPPORT_ATV_SCAN_NTSCM_PALM_N
            AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_SETUP, 0,
                            sizeof(APP_SETTING_Setup_t), &(g_stSetupData));
            if ((g_stSetupData.BlueScreen == APP_SWITCH_ON))
            {
                MID_DISP_DTVSetVideoMute(0,0,255);
            }
            else
            {
                APP_Video_SetMute(TRUE, TRUE, APP_MUTE_MODE_NO_SIGNALE, eSourType);
            }
		#endif
        }
#endif
    }
    else
    {
        /*close no signal popmessage*/
        g_u32NoSignalTimer = 0;
		g_u32NoSignalSleepTimer = 0;
        /*close not available popmessage*/
        g_u8NotAvailableTimer = 0;
        bSetUnMuteFlag = TRUE;

    }
    return 0;
}
#ifdef CONFIG_ATV_SUPPORT
static int _ATVApp_Zapping(AL_RecHandle_t hNextProgHdl, al_bool bForce)
{
    AL_RecHandle_t hCurProgHdl = AL_DB_INVALIDHDL;
    APP_Source_Type_t eSourType = APP_SOURCE_MAX;
    Boolean bFreezeFlag = FALSE;

    if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_PROGNUM))
    {
        SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_PROGNUM);
    }
    if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_TTXCLOCK))
    {
        SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_TTXCLOCK);
    }
    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);
    }
#ifndef CONFIG_SUPPORT_MONITOR
    MID_DISP_DTVGetPause(&bFreezeFlag);
    if (bFreezeFlag)
    {
        MID_DISP_DTVSetPause(FALSE);
    }
#endif
#ifdef CONFIG_ATV_SUPPORT
    if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_SIF))
    {
        SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_SIF);
    }
#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);
    }
#endif
#ifndef CONFIG_SUPPORT_MONITOR
    if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_BANNER))
    {
        SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, APP_GUIOBJ_BANNER);
    }
#endif
    APP_GUIOBJ_Source_GetCurrSource(&eSourType);

    hCurProgHdl = APP_ATV_Playback_GetCurProg();
    if ((eSourType == APP_SOURCE_ATV) && (hNextProgHdl == AL_DB_INVALIDHDL))
    {
        _ATVAPP_ShowPopup(ATV_APP_POP_MSG_INVALID_INPUT);
    }
    else if ((eSourType == APP_SOURCE_ATV) && ((hCurProgHdl != hNextProgHdl) || (bForce == TRUE)))
    {
#ifdef CONFIG_CC_SUPPORT
		AL_CC_Stop();
#endif
#ifdef CONFIG_SUPPORT_TTX
		AL_TTX_Stop();
		AL_TTX_Reset();
#endif
        APP_GUIOBJ_ATV_Playback_SetAtvUnLock(al_false);
        _ATVApp_ResetPopup_Channel();
        ATVApp_ClearStatus();
        APP_ATV_Playback_SetForcePlay();
#ifdef CONFIG_ATV_SUPPORT
		APP_Audio_SetATVSIFAvailableMode(TVFE_AUDIO_SIF_AVAIL_ERROR);
#endif
        SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_ATV,
                                             ATV_GUIOBJ_PLAYBACK, APP_ATV_INTRA_EVENT_ZAPPING_WITH_RETVAL, (UINT32)hNextProgHdl);
#ifndef CONFIG_ISDB_SYSTEM
		if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_INPUTINFO))
		{
			SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_INPUTINFO);
		}
		if(!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_CHNMGR))
		{
			SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, ATV_GUIOBJ_INPUTINFO, 0);
		}
#endif		
	}

    _ATVApp_CheckPopupDisplay();

    return SP_SUCCESS;
}
#endif
#ifdef CONFIG_ATV_SUPPORT
#if (defined(SUPPORT_FACTORY_AUTO_TEST)||defined(SUPPORT_FACTORY_AUTO_TEST_MODE2)||defined(SUPPORT_FACTORY_AUTO_TEST_MODE2_EXTEND))
#ifdef CONFIG_ISDB_SYSTEM
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_NTSC443;
	stAtvInfo.stAnalogServ.soundSystem = ANA_SCAN_AUDIO_STD_NICAMBG;

	stAtvInfo.stAnalogServ.u32Freq = 187250000;
	stAtvInfo.stAnalogServ.skip = 0;
	stAtvInfo.stAnalogServ.del = 0;
	stAtvInfo.stAnalogServ.AFC = 1;
	stAtvInfo.stAnalogServ.inuse = 1;
    if (APP_GUIOBJ_Source_GetRFPort() == RF_INPUT_PORT_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);
}
#else
#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 = 60000000;
	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
#endif
#endif
#ifdef CONFIG_SUPPORT_MONITOR_POWERSAVE
static void _ATVApp_Wakeup_Display(void)
{
	atv_printf("_ATVApp_Wakeup_Display.\n\n");
	APP_Source_Type_t eSourType = APP_SOURCE_MAX;
	UINT8 RegionIdx = 0;
	ColorLUT_t stColorLUTValue;
	APP_GUIOBJ_Source_GetCurrSource(&eSourType);

	/*APP_ATV_GLOBAL_EVENT_SIGNAL_PRESENT*/
	g_u8ZappingTimer = 0;
	/*set signal state*/
	/*have available signal*/
	g_u8SignalState = ATV_AVAILABLE_SIGNAL;
	#ifdef CONFIG_SUPPORT_NOSIGNAL_AUTO_CHANGE_SOURCE
	ATVApp_Reset_SwitchSourceToCheckSignal_Flag();
	#endif

	/*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);
	}

	{
		_ATVApp_SetMuteProcess(FALSE);
	}
	if ((eSourType == APP_SOURCE_HDMI)||(eSourType == APP_SOURCE_HDMI2)||(eSourType == APP_SOURCE_HDMI1))
	{
		APP_Video_SetMute(TRUE, FALSE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
	}
	else
	{
		/*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 (bSetUnMuteFlag == TRUE)
		{
			bSetUnMuteFlag = FALSE;
			APP_Video_SetMute(FALSE, TRUE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
		}
	}

	/*APP_ATV_GLOBAL_EVENT_VIP_STATUS*/
	if ((eSourType == APP_SOURCE_HDMI)||(eSourType == APP_SOURCE_HDMI2)||(eSourType == APP_SOURCE_HDMI1))
	{
		/*set PQ param*/
		// 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 );

		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));
		APP_Video_SetPictureMode(
				g_stPictureData.stPictureModeSourceTab[eStorageSourType].PictureModeIndex);
		//APP_Video_OSD_PQSet(APP_VIDEO_OSD_ITEM_BACKLIGHT, g_stPictureData.PictureMode[eSourType].stUserTab.Backlight);
		APP_Video_OSD_PQSet(APP_VIDEO_OSD_ITEM_COLORTEMP, g_stPictureData.stPictureModeSourceTab[eStorageSourType].ColorTempIndex);
		APP_Video_OSD_PQSet(APP_VIDEO_OSD_ITEM_NR, g_stPictureData.NR);
		if ((eSourType == APP_SOURCE_HDMI)||(eSourType == APP_SOURCE_HDMI2)||(eSourType == APP_SOURCE_HDMI1))
		{
			MID_DISP_DTVSetHdmiRGBRange(g_stFactoryUserData.PictureMode.VIP.n_PicMode_VIP_HDMI_RGB_Range);
		}
		else
		{
			if (eSourType == APP_SOURCE_PC)
			{
#if(defined(SUPPORT_FACTORY_AUTO_TEST)||defined(SUPPORT_FACTORY_AUTO_TEST_MODE2))
				if(APP_Factory_GetAutoTestOnOff() == FALSE)
#endif
				{
					ATVApp_PCAutoTune(FALSE); //Don't show "Adjusting , Please wait..." UI message, because AutoTune calibration has done before video unmute
				}
				/*update pc setup menu*/
			}
		}

		/*APP_ATV_GLOBAL_EVENT_HDMIDVI_CHANGE*/
		if (/*dParam != APP_MODE_UNDEFINE && */((eSourType == APP_SOURCE_HDMI)||(eSourType == APP_SOURCE_HDMI1)||(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*/
			/*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);
		  		}
				//PreHDMIMODE = dParam;
			}
			if (bSetUnMuteFlag == TRUE)
			{
				bSetUnMuteFlag = FALSE;
				APP_Video_SetMute(FALSE, TRUE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
			}
		}

		/*VIP FINISH*/
		bSetVIPFINISHFlag = TRUE;
		if (g_u8SignalState == ATV_AVAILABLE_SIGNAL)
		{
			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);
			}
		}
	}
}
#endif
static void _ATVApp_MCCS_MuteKeyHandler(UINT8 u8SetMute)
{
	UINT8 u8Mute = 0;
	APP_Source_Type_t eCurrSource = APP_SOURCE_MAX;
	static UINT32 u32CurrentSysappIndex = 0;

	APP_GUIOBJ_Source_GetCurrSource(&eCurrSource);
	AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_USERINFO, 0,
		sizeof(APP_SETTING_UserInfo_t), &(g_stUserInfoData));
	u8Mute = g_stUserInfoData.Mute;

	if(u8SetMute != u8Mute)
	{
		if(MAIN_APP_SUCCESS == MAINAPP_GetActiveSystemAppIndex(&u32CurrentSysappIndex))
		{         
			if ((ATVApp_GetSignalState() == ATV_AVAILABLE_SIGNAL))/*have signal*/
			{
				if (u8SetMute == TRUE)
				{
					APP_Audio_SetMute(u8SetMute, TRUE, APP_MUTE_MODE_SIGNAL_DETECT, eCurrSource);
				}
				else
				{
					u8SetMute = FALSE;
					APP_Audio_SetMute(u8SetMute, TRUE, APP_MUTE_MODE_SIGNAL_DETECT, eCurrSource);
				}
			}
			else/*no signal*/
			{
			if (u8SetMute == TRUE)
			{
				u8SetMute = TRUE;
				APP_Audio_SetMute(u8SetMute, TRUE, APP_MUTE_MODE_NO_SIGNALE, eCurrSource);
			}
			else
			{
				u8Mute = FALSE;
				APP_Audio_SetMute(u8SetMute, TRUE, APP_MUTE_MODE_NO_SIGNALE, eCurrSource);
			}
			}
		}
		g_stUserInfoData.Mute = u8SetMute;

		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
	}
}

static void _ATVApp_MCCS_StoreSetting(AFW_event_t event, UINT32 param)
{
	APP_Source_Type_t eSourType = APP_SOURCE_MAX;
	int Mode = MID_COLORTEMP_MAX;
	APP_SETTING_ColorTemp_t stColorTempValue;
	SRCTYPE_t pstSrc = SRCTYPE_RESERVED;
	APP_Video_PQ_Store_SourceType_t ePQStoreSrcType = APP_VIDEO_PQ_STORE_SOURCE_TYPE_MAX;
	DynamicContrast_t stDynamic;
	
	APP_GUIOBJ_Source_GetCurrSource(&eSourType);
	MID_DISP_DTVGetSource(&pstSrc);
	ePQStoreSrcType = APP_Video_SourceTypeMappingToPQStorage(pstSrc);
	switch(event)
	{
		case FW_MCCS_IMAGE_LUMINANCE:
			g_stPictureData.PictureMode[eSourType].stStandardTab.Backlight = param;
			AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_PICTURE,
				ITEM_OFFSET(APP_SETTING_Picture_t, PictureMode[eSourType].stStandardTab.Backlight),
				sizeof(g_stPictureData.PictureMode[eSourType].stStandardTab.Backlight),
				&(g_stPictureData.PictureMode[eSourType].stStandardTab.Backlight));
			break;
		case FW_MCCS_IMAGE_CONTRAST:
			g_stPictureData.PictureMode[eSourType].stStandardTab.Contrast = param;
			AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_PICTURE,
				ITEM_OFFSET(APP_SETTING_Picture_t, PictureMode[eSourType].stStandardTab.Contrast),
				sizeof(g_stPictureData.PictureMode[eSourType].stStandardTab.Contrast),
				&(g_stPictureData.PictureMode[eSourType].stStandardTab.Contrast));
			break;
		case FW_MCCS_IMAGE_SHARPNESS:
			g_stPictureData.PictureMode[eSourType].stStandardTab.Sharpness = param;
			AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_PICTURE,
				ITEM_OFFSET(APP_SETTING_Picture_t, PictureMode[eSourType].stStandardTab.Sharpness),
				sizeof(g_stPictureData.PictureMode[eSourType].stStandardTab.Sharpness),
				&(g_stPictureData.PictureMode[eSourType].stStandardTab.Sharpness));
			break;
		case FW_MCCS_IMAGE_SATURATION:
			g_stPictureData.PictureMode[eSourType].stStandardTab.Saturation = param;
			AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_PICTURE,
				ITEM_OFFSET(APP_SETTING_Picture_t, PictureMode[eSourType].stStandardTab.Saturation),
				sizeof(g_stPictureData.PictureMode[eSourType].stStandardTab.Saturation),
				&(g_stPictureData.PictureMode[eSourType].stStandardTab.Saturation));
			break;
		case FW_MCCS_IMAGE_RGAIN:
			Mode = (INT32)AL_FLASH_GetWBMode();
			AL_FLASH_GetWBTemperature(Mode,&stColorTempValue);
			stColorTempValue.u16RGain = (UINT16)param;
			AL_FLASH_SetWBTemperature(Mode,&stColorTempValue);
			break;
		case FW_MCCS_IMAGE_GGAIN:
			Mode = (INT32)AL_FLASH_GetWBMode();
			AL_FLASH_GetWBTemperature(Mode,&stColorTempValue);
			stColorTempValue.u16GGain = (UINT16)param;
			AL_FLASH_SetWBTemperature(Mode,&stColorTempValue);
			break;
		case FW_MCCS_IMAGE_BGAIN:
			Mode = (INT32)AL_FLASH_GetWBMode();
			AL_FLASH_GetWBTemperature(Mode,&stColorTempValue);
			stColorTempValue.u16BGain = (UINT16)param;
			AL_FLASH_SetWBTemperature(Mode,&stColorTempValue);
			break;
		case FW_MCCS_IMAGE_ROFFSET:
			Mode = (INT32)AL_FLASH_GetWBMode();
			AL_FLASH_GetWBTemperature(Mode,&stColorTempValue);
			stColorTempValue.u16ROffset = (UINT16)param;
			AL_FLASH_SetWBTemperature(Mode,&stColorTempValue);
			break;
		case FW_MCCS_IMAGE_GOFFSET:
			Mode = (INT32)AL_FLASH_GetWBMode();
			AL_FLASH_GetWBTemperature(Mode,&stColorTempValue);
			stColorTempValue.u16GOffset = (UINT16)param;
			AL_FLASH_SetWBTemperature(Mode,&stColorTempValue);
			break;
		case FW_MCCS_IMAGE_BOFFSET:
			Mode = (INT32)AL_FLASH_GetWBMode();
			AL_FLASH_GetWBTemperature(Mode,&stColorTempValue);
			stColorTempValue.u16BOffset = (UINT16)param;
			AL_FLASH_SetWBTemperature(Mode,&stColorTempValue);
			break;
		case FW_MCCS_IMAGE_COLORLUT_SATGAIN_R:
			g_stFactoryUserData.PictureMode.ColorLUT[ePQStoreSrcType].n_PicMode_CoLUT_SatGain[APP_ColorLUT_R] = (INT8)param;
			AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_FACTUSER,
					ITEM_OFFSET(APP_SETTING_FactoryUser_t,PictureMode.ColorLUT[ePQStoreSrcType].n_PicMode_CoLUT_SatGain[APP_ColorLUT_R]),
					sizeof(g_stFactoryUserData.PictureMode.ColorLUT[ePQStoreSrcType].n_PicMode_CoLUT_SatGain[APP_ColorLUT_R]),
					&(g_stFactoryUserData.PictureMode.ColorLUT[ePQStoreSrcType].n_PicMode_CoLUT_SatGain[APP_ColorLUT_R]));
			break;
		case FW_MCCS_IMAGE_COLORLUT_SATGAIN_Y:
			g_stFactoryUserData.PictureMode.ColorLUT[ePQStoreSrcType].n_PicMode_CoLUT_SatGain[APP_ColorLUT_Y] = (INT8)param;
			AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_FACTUSER,
					ITEM_OFFSET(APP_SETTING_FactoryUser_t,PictureMode.ColorLUT[ePQStoreSrcType].n_PicMode_CoLUT_SatGain[APP_ColorLUT_Y]),
					sizeof(g_stFactoryUserData.PictureMode.ColorLUT[ePQStoreSrcType].n_PicMode_CoLUT_SatGain[APP_ColorLUT_Y]),
					&(g_stFactoryUserData.PictureMode.ColorLUT[ePQStoreSrcType].n_PicMode_CoLUT_SatGain[APP_ColorLUT_Y]));
			break;
		case FW_MCCS_IMAGE_COLORLUT_SATGAIN_G:
			g_stFactoryUserData.PictureMode.ColorLUT[ePQStoreSrcType].n_PicMode_CoLUT_SatGain[APP_ColorLUT_G] = (INT8)param;
			AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_FACTUSER,
					ITEM_OFFSET(APP_SETTING_FactoryUser_t,PictureMode.ColorLUT[ePQStoreSrcType].n_PicMode_CoLUT_SatGain[APP_ColorLUT_G]),
					sizeof(g_stFactoryUserData.PictureMode.ColorLUT[ePQStoreSrcType].n_PicMode_CoLUT_SatGain[APP_ColorLUT_G]),
					&(g_stFactoryUserData.PictureMode.ColorLUT[ePQStoreSrcType].n_PicMode_CoLUT_SatGain[APP_ColorLUT_G]));
			break;
		case FW_MCCS_IMAGE_COLORLUT_SATGAIN_C:
			g_stFactoryUserData.PictureMode.ColorLUT[ePQStoreSrcType].n_PicMode_CoLUT_SatGain[APP_ColorLUT_C] = (INT8)param;
			AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_FACTUSER,
					ITEM_OFFSET(APP_SETTING_FactoryUser_t,PictureMode.ColorLUT[ePQStoreSrcType].n_PicMode_CoLUT_SatGain[APP_ColorLUT_C]),
					sizeof(g_stFactoryUserData.PictureMode.ColorLUT[ePQStoreSrcType].n_PicMode_CoLUT_SatGain[APP_ColorLUT_C]),
					&(g_stFactoryUserData.PictureMode.ColorLUT[ePQStoreSrcType].n_PicMode_CoLUT_SatGain[APP_ColorLUT_C]));
			break;
		case FW_MCCS_IMAGE_COLORLUT_SATGAIN_B:
			g_stFactoryUserData.PictureMode.ColorLUT[ePQStoreSrcType].n_PicMode_CoLUT_SatGain[APP_ColorLUT_B] = (INT8)param;
			AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_FACTUSER,
					ITEM_OFFSET(APP_SETTING_FactoryUser_t,PictureMode.ColorLUT[ePQStoreSrcType].n_PicMode_CoLUT_SatGain[APP_ColorLUT_B]),
					sizeof(g_stFactoryUserData.PictureMode.ColorLUT[ePQStoreSrcType].n_PicMode_CoLUT_SatGain[APP_ColorLUT_B]),
					&(g_stFactoryUserData.PictureMode.ColorLUT[ePQStoreSrcType].n_PicMode_CoLUT_SatGain[APP_ColorLUT_B]));
			break;
		case FW_MCCS_IMAGE_COLORLUT_SATGAIN_M:
			g_stFactoryUserData.PictureMode.ColorLUT[ePQStoreSrcType].n_PicMode_CoLUT_SatGain[APP_ColorLUT_M] = (INT8)param;
			AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_FACTUSER,
					ITEM_OFFSET(APP_SETTING_FactoryUser_t,PictureMode.ColorLUT[ePQStoreSrcType].n_PicMode_CoLUT_SatGain[APP_ColorLUT_M]),
					sizeof(g_stFactoryUserData.PictureMode.ColorLUT[ePQStoreSrcType].n_PicMode_CoLUT_SatGain[APP_ColorLUT_M]),
					&(g_stFactoryUserData.PictureMode.ColorLUT[ePQStoreSrcType].n_PicMode_CoLUT_SatGain[APP_ColorLUT_M]));
			break;
		case FW_MCCS_IMAGE_GAMMA_TABLE_INDEX:
			if(param == 0)
				Mode = MID_COLORTEMP_WARM;
			else if(param == 2)
				Mode = MID_COLORTEMP_COOL;
			else
				Mode = MID_COLORTEMP_STD;
			AL_FLASH_SetWBMode((UINT8)Mode);
			break;
		case FW_MCCS_IMAGE_CONTRAST_AUTO:
			AL_FLASH_GetDynamicContrastALL(&stDynamic);
			if(param == 0)
				stDynamic.n_PicMode_DynCon_DynamicContrastlevel = 0;
			else
				stDynamic.n_PicMode_DynCon_DynamicContrastlevel = 2;
			AL_FLASH_SetDynamicContrastALL(&stDynamic);
			break;
		case FW_MCCS_OSD_HPOSITION:
			g_stSetupData.stOSDSetup.OSDHPosition = (INT32)param;	
			AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_SETUP,		
				ITEM_OFFSET(APP_SETTING_Setup_t, stOSDSetup.OSDHPosition),	 	
				sizeof(g_stSetupData.stOSDSetup.OSDHPosition),		
				&(g_stSetupData.stOSDSetup.OSDHPosition));
			break;
		case FW_MCCS_OSD_VPOSITION:	
			g_stSetupData.stOSDSetup.OSDVPosition = (INT32)param;
			AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_SETUP,		
				ITEM_OFFSET(APP_SETTING_Setup_t, stOSDSetup.OSDVPosition),	 	
				sizeof(g_stSetupData.stOSDSetup.OSDVPosition),		
				&(g_stSetupData.stOSDSetup.OSDVPosition));
			break;
		case FW_MCCS_AUDIOVOLUME:
			g_stVariationalData.Volume = (UINT8)(param);
			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));
			break;
		case FW_MCCS_OSD_LANGUAGE:
			g_stFeatureData.OSDLang = APP_DCCCI_Language_SetOsdLanguage((INT32)param);
			APP_UserMenu_Language_SetOsdLanguage(g_stFeatureData.OSDLang);
			UINT32 StringId = APP_UserMenu_OSD_Language_MappingTo_StringID(g_stFeatureData.OSDLang);
			GUI_FUNC_CALL(GEL_SetGlobalLang(APP_GuiMgr_GetCurFontLangIndex((UINT32*)&StringId, OSD_TVPROJECT)));
			break;
		case FW_MCCS_AUDIOMUTE:
			_ATVApp_MCCS_MuteKeyHandler(param);
			break;	
		default:
			break;
	}
}
static void _ATVApp_MCCS_VGASetup(AFW_event_t event, UINT32 param)
{
	UINT16 usTimingTblIdx = 0;
	UINT8 u8Phase = 0;
	UINT32 u32HTotal = 0;
	UINT32 u32RegVal = 0;

	AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_SYSINFO, 0,
                    sizeof(APP_SETTING_SystemInfo_t), &(g_stSysInfoData));
	APP_UserMenu_Picture_GetPCAutoTuneIdx(&usTimingTblIdx);

	if(event == FW_MCCS_SET_VGASETTING_HPOSITION)
	{
		MID_DISP_DTVSetCropWindowHStartOffset(0, (param-APP_PC_HPOS_DEF));
		g_stSysInfoData.stPC_AutoTune[usTimingTblIdx].i8HpositionOffset = param;
		AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_SYSINFO,
                         ITEM_OFFSET(APP_SETTING_SystemInfo_t, stPC_AutoTune[usTimingTblIdx].i8HpositionOffset),
                         sizeof(g_stSysInfoData.stPC_AutoTune[usTimingTblIdx].i8HpositionOffset),
                         &(g_stSysInfoData.stPC_AutoTune[usTimingTblIdx].i8HpositionOffset));
	}
	else if(event == FW_MCCS_SET_VGASETTING_VPOSITION)
	{
		MID_DISP_DTVSetCropWindowVStartOffset(0, (param-APP_PC_VPOS_DEF));
		g_stSysInfoData.stPC_AutoTune[usTimingTblIdx].i8VpositionOffset = param;
		AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_SYSINFO,
                         ITEM_OFFSET(APP_SETTING_SystemInfo_t, stPC_AutoTune[usTimingTblIdx].i8VpositionOffset),
                         sizeof(g_stSysInfoData.stPC_AutoTune[usTimingTblIdx].i8VpositionOffset),
                         &(g_stSysInfoData.stPC_AutoTune[usTimingTblIdx].i8VpositionOffset));
	}
	else if(event == FW_MCCS_SET_VGASETTING_PHASE)
	{
		g_stSysInfoData.stPC_AutoTune[usTimingTblIdx].Phase = param;
		u8Phase = APP_UserMenu_ATV_PCSetup_OSDValueMappingtoPhase(g_stSysInfoData.stPC_AutoTune[usTimingTblIdx].Phase);
        	Cmd_AdcAdjust(ADC_CMD_PHASE, u8Phase);
		#ifdef CONFIG_DDC_CI_SUPPORT
		Cmd_AdcAdjust(ADC_CMD_DDCCI_OSD_PHASE, param);
		#endif	
        	AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_SYSINFO,
                         ITEM_OFFSET(APP_SETTING_SystemInfo_t, stPC_AutoTune[usTimingTblIdx].Phase),
                         sizeof(g_stSysInfoData.stPC_AutoTune[usTimingTblIdx].Phase),
                         &(g_stSysInfoData.stPC_AutoTune[usTimingTblIdx].Phase));
	}
	else if(event == FW_MCCS_SET_VGASETTING_CLOCK)
	{
		u32HTotal = Cmd_VipGetAdcHTotal();
		u32RegVal = param + u32HTotal;
		Cmd_VipAdjust(VIP_CLOCK, u32RegVal);
		#ifdef CONFIG_DDC_CI_SUPPORT
		Cmd_AdcAdjust(ADC_CMD_DDCCI_OSD_CLOCK, param);
		#endif
		g_stSysInfoData.stPC_AutoTune[usTimingTblIdx].i8ClockOffset = param;
		AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_SYSINFO,
	                  ITEM_OFFSET(APP_SETTING_SystemInfo_t, stPC_AutoTune[usTimingTblIdx].i8ClockOffset),
	                  sizeof(g_stSysInfoData.stPC_AutoTune[usTimingTblIdx].i8ClockOffset),
	                  &(g_stSysInfoData.stPC_AutoTune[usTimingTblIdx].i8ClockOffset));
	}
        
}

static void _ATVApp_MCCS_CLOSE_USERMENU(void)
{
	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_ADJUST))
	{
		SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, APP_GUIOBJ_ADJUST);
	}

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

static void _ATVApp_sw_init(void)
{
#ifdef CONFIG_ATV_SUPPORT
#if (defined(CONFIG_DRAMSIZE) && (CONFIG_DRAMSIZE == 64)) || (defined (CONFIG_SUPPORT_64M_DTV))
	bool bNeedSyncDatabase = FALSE;
#endif
#endif

    AL_FW_Init(FW_ATV_INIT, NULL, NULL);
#ifdef CONFIG_ATV_SUPPORT
    if (ATVApp_GetDBInitState() == FALSE)
    {
        ATVApp_DBInit();
#if (defined(CONFIG_DRAMSIZE) && (CONFIG_DRAMSIZE == 64)) || (defined (CONFIG_SUPPORT_64M_DTV))
		bNeedSyncDatabase = TRUE;
#endif
    }
#endif
#if defined(CONFIG_SCART_SUPPORT) || defined(CONFIG_ATV_SUPPORT) || defined(CONFIG_AV_SUPPORT) || defined(CONFIG_SV_SUPPORT)
    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);
#endif
#if (defined(SUPPORT_FACTORY_AUTO_TEST)||defined(SUPPORT_FACTORY_AUTO_TEST_MODE2)||defined(SUPPORT_FACTORY_AUTO_TEST_MODE2_EXTEND))
	if(APP_Factory_GetAutoTestOnOff() == TRUE)
	{
#ifdef CONFIG_ATV_SUPPORT
		_ATVApp_PrestoreProgram();
#if (defined(CONFIG_DRAMSIZE) && (CONFIG_DRAMSIZE == 64)) || (defined (CONFIG_SUPPORT_64M_DTV))
		bNeedSyncDatabase = TRUE;
#else
		AL_DB_Sync(AL_DBTYPE_DVB_ATV, al_true);
#endif
#endif
	}
	else
#endif
	{
		APP_Factory_HotelModePowerOnChan();
	#ifdef CONFIG_ATV_SUPPORT
	#ifdef NUMBER_KEY_WAKEUP_CHANNEL
	#ifdef CONFIG_ISDB_SYSTEM
	    app_scan_table_info_st scan_info;
	    app_scan_table_info_st air_scan_info;
	#endif

	#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;
			}
		#ifdef CONFIG_ISDB_SYSTEM
	        APP_Scan_API_GetTableInfo(APP_GUIOBJ_Source_GetRFPort(), &scan_info);
	        APP_Scan_API_GetTableInfo(RF_INPUT_PORT_AIR, &air_scan_info);
	        if ((bChannel > scan_info.u32MaxChNo) || (bChannel < scan_info.u32MinChNo))
	        {
				bChannel = scan_info.u32MinChNo;
	        }
	        if (APP_GUIOBJ_Source_GetRFPort() == RF_INPUT_PORT_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));
	           	}
	        }
		#else
		    #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
	#endif
	}
#ifdef CONFIG_ATV_SUPPORT
#if (defined(CONFIG_DRAMSIZE) && (CONFIG_DRAMSIZE == 64)) || (defined (CONFIG_SUPPORT_64M_DTV))
	if (bNeedSyncDatabase)
	{
		AL_DB_Sync(AL_DBTYPE_DVB_ATV, al_true);
	}
	APP_Source_Type_t eCurrSrc = APP_SOURCE_MAX;
	APP_GUIOBJ_Source_GetCurrSource(&eCurrSrc);
	if (eCurrSrc == APP_SOURCE_MAX || eCurrSrc == APP_SOURCE_MEDIA || eCurrSrc == APP_SOURCE_MEDIA1)
	{
		AL_FW_DeActiveDBModule(AL_DBTYPE_DVB_ATV);
	}
#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);

#ifdef CONFIG_ENABLE_UMF_MODULES
	if (umf_checkModuleLoaded(UMFMOD_MEDIA))
	{
		MAINAPP_SendGlobalEvent(APP_GLOBAL_EVENT_FINALIZE_SYSAPP, SYS_APP_FILE_PLAYER);
	}
#endif
    if (dParam == AUTOSEARCH_FROM_ALLTUNE)
    {
        g_ucComeFromAutoSearch = 1;

    }
#ifdef CONFIG_SUPPORT_NOSIGNAL_AUTO_CHANGE_SOURCE
    APP_GUIOBJ_Source_SourceMapping_Table(g_stSourceConfigTable_New,&g_u16SourceConfigTable_Size_New);
#endif

    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);
#ifdef CONFIG_SUPPORT_DETECT_USBPLL
	AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FACTUSER, 0,
	  sizeof(APP_SETTING_FactoryUser_t), &(g_stFactoryUserData));
	if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_MUTE))
	{
		SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, APP_GUIOBJ_MUTE, 0);
	}
	
	UINT8 u8USBPLL_Fail = 0;
	Cmd_NVMRead(ENVMPurposeIDUSBPLLFailFlag, FALSE, sizeof(UINT8), &u8USBPLL_Fail);
	if(u8USBPLL_Fail == TRUE)
	{
		SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_ATV, APP_GUIOBJ_MUTE,
										   APP_INTRA_EVENT_SHOW_CLK_ERROR, 0);
	}
#endif
	APP_Video_Init();
	

    return 0;
}


static INT32 _ATVApp_OnTerminate(void *pPrivateData, UINT32 dParamter)
{
#ifdef CONFIG_ATV_SUPPORT
    APP_EProgListType_t eListType = ProgListType_Normal;
#endif
    atv_printf("[ATV] %s is called.\n", __FUNCTION__);
#ifndef CONFIG_SUPPORT_MONITOR
    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);
    }
#endif
#ifdef CONFIG_ATV_SUPPORT
    /* Release ATV program list  if there's any */
    for (eListType = ProgListType_Fav1; eListType < ProgListType_Max; eListType++)
    {
        if (eListType == ProgListType_Scramb)
        {
            /* ATV has no such type of list */
            continue;
        }
        if (APP_ProgList_IsExist(AL_DBTYPE_DVB_ATV, AL_RECTYPE_ATVSERVICE, eListType) == al_true)
        {
            APP_ProgList_Uninit(AL_DBTYPE_DVB_ATV, AL_RECTYPE_ATVSERVICE, eListType);
        }
    }
#endif
	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_SOURCE_CHANGE, APP_SOURCE_MAX);
    stAtvInst.bAppState = SYSTEM_IDLE;
	
#ifdef CONFIG_ENABLE_UMF_MODULES
#ifdef CONFIG_MOD_PACK_ATV
	MAINAPP_SendGlobalEvent(APP_GLOBAL_EVENT_FINALIZE_SYSAPP, SYS_APP_ATV);
#endif
#endif
    return 0;
}

static INT32 _ATVApp_OnTimerUpdate(void *pPrivateData)
{
    APP_Source_Type_t eSourType = APP_SOURCE_MAX;
    INT32 dFocusedIndex;
#ifdef CONFIG_ATV_SUPPORT
#ifndef SUPPORT_CLOSE_NICAM
    TVFE_AudioFrontEndStatus_t GET_SIFinfo;
    TVFE_AudioSIFAvailableMode_e mode = 0;
#endif
#endif
	/*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 >= 6000) //6000*100ms=10 min
		{
			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_ATV_SUPPORT
	/*Set timer to clear zapping state
	   avoid dvb app not received tuner locke or tuner unlock message result in not clear the flag*/
	if (APP_GUIOBJ_ATV_Playback_GetZappingState())
	{
		g_u8ZappingTimer++;
		if (g_u8ZappingTimer >= 1)//3*100ms
		{
			APP_GUIOBJ_ATV_Playback_SetZappingState(FALSE);
			g_u8ZappingTimer = 0;
		}
	}
	#endif

#ifdef CONFIG_TESTAUTOREBOOT
	{
		FW_mode_t FW_Module = FW_NORMAL_VIEW_MODE;
		AL_FW_GetFWModule(&FW_Module);
		/*don't enable autoreboot while searching channel and update*/
		if (FW_Module == FW_CHAN_SRCH_MODE || FW_Module == FW_UPGRADE_MODE)
		{
			ir_autoreboot_disable();
		}
	}
#endif

#if defined(CELLO_cello) && defined(SUPPORT_HOMEMODE)
	/*Cello spec: Home Mode Open*/
	if(APP_GUIOBJ_AutoInstall_GetOpenHomeModeFlag())
	{
		AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_USERINFO, 0,
						sizeof(APP_SETTING_UserInfo_t), &(g_stUserInfoData));
		if((g_stUserInfoData.AutoInstalledHomeMode)
			&&(!g_stUserInfoData.AutoInstalled))
		{
		#ifdef CONFIG_SUPPORT_USB_UPGRADE
			if(!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_SOFTWARE_UPGRADE))
		#endif
			{
				SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_ATV, APP_GLOBAL_EVENT_OPEN_HOMEMODE|PASS_TO_SYSAPP, 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)) &&
                (!APP_MenuMgr_Exist_Factory_Menu())
               )
            {
                g_u32NoSignalTimer ++;
				#ifndef SUPPORT_NO_SIGNAL_NOTSTANDBY
                g_u32NoSignalSleepTimer ++;
				#endif
            }
            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(g_VCPPowerMode == 4) //VCP panel off
				break;
            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);
                    }
                  #ifdef  CONFIG_SUPPORT_NO_SIGNAL_STANDBY
                    SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_ATV,
                                	(APP_GLOBAL_EVENT_SLEEP_TIMER_INFO | PASS_TO_SYSAPP), APP_POWERDOWN_NO_SINGAL);
                  #endif
                }
            }

            if (g_u32NoSignalTimer >= g_noSignaldebouncetime)
            {
                if (SYSTEM_APP_NO_FOCUSED_GUIOBJ == SYSAPP_GOBJ_GetFocusedGUIObject(SYS_APP_ATV, &dFocusedIndex))
                {
#ifdef CONFIG_SUPPORT_NOSIGNAL_AUTO_CHANGE_SOURCE
                    if(g_stSetupData.MenuSourceType == APP_MENUSOURCETYPE_AUTO)
                    {
                        if(g_CheckSignal_Times < (CHECK_SIGNAL_TIMES*g_u16SourceConfigTable_Size_New))
                        {
                           g_u32NoSignalTimer = 0;
                           g_u32NoSignalSleepTimer = 0;
                           g_CheckSignal = TRUE;
                           ATVApp_SwitchSourceToCheckSignal();
                           break;
                        }
                        else
                        {
                           ATVApp_Reset_SwitchSourceToCheckSignal_Flag();
                        }
                    }
#endif
                    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
						#ifndef CONFIG_SUPPORT_MONITOR
						#ifdef CONFIG_KEYPAD_SINGLE_REUSE
                    	if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV,APP_GUIOBJ_KEYPADMENU))
						#endif
						#endif
						{
							SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_ATV,APP_ATV_GLOBAL_EVENT_POPMSG_NO_SIGNAL, 0);
						}
					#endif
                    }
                }
#ifdef CONFIG_SUPPORT_NOSIGNAL_AUTO_CHANGE_SOURCE
                else if(ATVApp_IsPopupExist(PLAYBACK_POPUP_MSG_NO_SIGNAL))
                {
                    if(g_stSetupData.MenuSourceType == APP_MENUSOURCETYPE_AUTO)
                    {
                        if(g_CheckSignal_Times < (CHECK_SIGNAL_TIMES*g_u16SourceConfigTable_Size_New))
                        {
                           g_u32NoSignalTimer = 0;
                           g_u32NoSignalSleepTimer = 0;
                           g_CheckSignal = TRUE;
                           ATVApp_SwitchSourceToCheckSignal();
                           break;
                        }
                        else
                        {
                    #ifdef SUPPORT_NO_SIGNAL_POWEROFF_WITHOUT_COUNTING
                            ATVApp_Reset_SwitchSourceToCheckSignal_Flag();
                            #ifdef SUPPORT_AV_NOSIGNAL_POWEROFF_60
                            if(eSourType == APP_SOURCE_AV && g_u32NoSignalTimer < AV_NO_SIGNAL_BOUNCE_TIME)
                                break;
                            #endif
                            MAINAPP_SendGlobalEvent(UI_EVENT_POWER, AL_POWER_STATE_SUSPEND);
							#else
                            ATVApp_Reset_SwitchSourceToCheckSignal_Flag();
                    #endif
                        }
                    }
                    else
                    {
                        if(g_CheckSignal_Times == 0xFF)
                        {
                    #ifdef SUPPORT_NO_SIGNAL_POWEROFF_WITHOUT_COUNTING
                            ATVApp_Reset_SwitchSourceToCheckSignal_Flag();
                            #ifdef SUPPORT_AV_NOSIGNAL_POWEROFF_60
                            if(eSourType == APP_SOURCE_AV && g_u32NoSignalTimer < AV_NO_SIGNAL_BOUNCE_TIME)
                                break;
                            #endif
                            MAINAPP_SendGlobalEvent(UI_EVENT_POWER, AL_POWER_STATE_SUSPEND);
							#else
                            ATVApp_Reset_SwitchSourceToCheckSignal_Flag();
                    #endif
                         }
                    }
                }
#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 (SYSTEM_APP_NO_FOCUSED_GUIOBJ == SYSAPP_GOBJ_GetFocusedGUIObject(SYS_APP_ATV, &dFocusedIndex))
                {
                    if (!ATVApp_IsPopupExist(PLAYBACK_POPUP_MSG_NOT_SUPPORT_MODE))
                    {
                        SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_ATV,
                        		APP_ATV_GLOBAL_EVENT_POPMSG_NOT_SUPPORT_MODE, 0);
                    }
                }
#ifdef SUPPORT_SIGNAL_UNSUPPOST_POWEROFF
                else if(ATVApp_IsPopupExist(PLAYBACK_POPUP_MSG_NOT_SUPPORT_MODE))
                {
                    MAINAPP_SendGlobalEvent(UI_EVENT_POWER, AL_POWER_STATE_SUSPEND);
                }
#endif
            }
        }
        break;
        case ATV_AVAILABLE_SIGNAL:
		{
#ifdef CONFIG_ATV_SUPPORT
            if (eSourType == APP_SOURCE_ATV )
            {
				if (SYSTEM_APP_NO_FOCUSED_GUIOBJ == SYSAPP_GOBJ_GetFocusedGUIObject(SYS_APP_ATV, &dFocusedIndex)
					|| (dFocusedIndex == ATV_GUIOBJ_INPUTINFO || dFocusedIndex == ATV_GUIOBJ_CHNMGR || dFocusedIndex == ATV_GUIOBJ_CHILD_LOCK))
                {
                    if((APP_GUIOBJ_ATV_Playback_GetProgramState() == TRUE)
						|| (g_ATVbLastParentLock == TRUE && APP_GUIOBJ_ATV_Playback_GetProgramState() == FALSE))
                    {
                    	g_ATVbLastParentLock = FALSE;
                        ATVApp_CheckProgramType(FALSE);
                        break;
                    }
                }
			}
#endif
#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 other ui for mantis0036921.*/
                    if(!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_CC)
                        && (_ATVAPP_DisplayCCFlag() == TRUE)
#ifdef CONFIG_VCHIP_SUPPORT
                        && (ATVAPP_GetSignalLockStatus() == FALSE)
#endif
                        )
                    {
                         SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, ATV_GUIOBJ_CC, 0);
                    }
                    else if(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_CC)
                        && (_ATVAPP_DisplayCCFlag() == FALSE))
                    {
                        SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_CC);
                    }	
#ifdef CONFIG_VCHIP_SUPPORT
					else if(ATVAPP_GetSignalLockStatus() == TRUE)
					{
						if (SYSTEM_APP_NO_FOCUSED_GUIOBJ == SYSAPP_GOBJ_GetFocusedGUIObject(SYS_APP_ATV, &dFocusedIndex))
						{
							_ATVAPP_ShowPopup(ATV_APP_POP_MSG_CHECKPWD);
						}
					}
#endif	
                }
                else
                {
                    if(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_CC))
                    {
                        SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_CC);
                    }			
#ifdef CONFIG_VCHIP_SUPPORT
					if(ATVAPP_GetSignalLockStatus() == TRUE)
	                {
	                    if (SYSTEM_APP_NO_FOCUSED_GUIOBJ == SYSAPP_GOBJ_GetFocusedGUIObject(SYS_APP_ATV, &dFocusedIndex))
	                    {
	                        _ATVAPP_ShowPopup(ATV_APP_POP_MSG_CHECKPWD);
	                    }
	                }
#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 CONFIG_ATV_SUPPORT
#ifndef SUPPORT_CLOSE_NICAM
	    if (eSourType == APP_SOURCE_ATV&& (!APP_IsScan_Running()))
	    {
		//printf("g_u8CheckMTSTimer=%d\n",g_u8CheckMTSTimer);
		if (g_u8SIF_SCS_OK == TRUE)
	    {
	    	if (g_u8CheckMTSTimer >= 2)
		    {
				APP_Audio_GetATVSIFAvailableMode(&mode);
				memset(&GET_SIFinfo,0,sizeof(TVFE_AudioFrontEndStatus_t));
				TVFE_Audio_GetSIFInfo(&GET_SIFinfo);
				//printf("mode=%x,GET_SIFinfo.eAvaiMode=%x\n",mode,GET_SIFinfo.eAvaiMode);
				if (mode != GET_SIFinfo.eAvaiMode)
				{
					if (
						#ifdef CONFIG_SUPPORT_SW_AFC
						Get_AFT_ProcessStatus() == 1 && MID_AFC_GetStatus() == MID_AFC_RUNNING  &&
						#endif
						IsAlreadyFirstSetMTS == FALSE )
					{
					
						g_u8CheckMTSTimer = 0;
						IsAlreadyFirstSetMTS = TRUE;
						APP_ATV_Playback_SetMTS(GET_SIFinfo.eAvaiMode,TRUE,TRUE);
						#ifdef CONFIG_ISDB_SYSTEM
						if(bSetVIPFINISHFlag == TRUE)
						#endif	
						{
							APP_Audio_SetMute(g_stUserInfoData.Mute, TRUE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
							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);
							}
						}
					}
					else if (IsAlreadyFirstSetMTS == TRUE)
					{
					    if(GET_SIFinfo.eAvaiMode!=TVFE_AUDIO_SIF_AVAIL_ERROR)
                        {               
    						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;
    						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);
    						}
                        }
                        g_u8CheckMTSTimer = 0;
                        break;
					}
					g_u8CheckMTSTimer = 0;
                    break;
				}
				g_u8CheckMTSTimer = 0;
                break;
			}
			g_u8CheckMTSTimer++;

		    }
	  	}
#endif
#endif
    }
     break;
		default:
#ifdef CONFIG_OSD_GAME_SUPPORT
            if (eSourType == APP_SOURCE_GAME)
            {
                if (SYSTEM_APP_NO_FOCUSED_GUIOBJ == SYSAPP_GOBJ_GetFocusedGUIObject(SYS_APP_ATV, &dFocusedIndex))
                {
                    //if (APP_GUIOBJ_Source_GetLockState() == TRUE)
                    {
                    #ifndef CONFIG_SUPPORT_MONITOR
                        SYSAPP_IF_SendGlobalEventWithIndex(
                                        SYS_APP_ATV, APP_GLOBAL_EVENT_OPEN_POPUP|PASS_TO_SYSAPP, ATV_APP_POP_MSG_CHECKPWD);
			#endif
                    }
                }
            }
#endif

			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)
{
#ifndef CONFIG_SUPPORT_MONITOR
    Boolean bFreezeFlag = FALSE;
#endif
#ifdef CONFIG_ATV_SUPPORT
    UINT32 u32BlueBackvalue = 0;
    PLF_VideoID_t eResolution;
#endif
#ifndef CONFIG_ISDB_SYSTEM
#ifndef CONFIG_SUPPORT_ATV_SCAN_NTSCM_PALM_N
#ifndef CONFIG_SUPPORT_MONITOR
	UINT8 bAutoInstall = FALSE;
#endif
#endif
#endif
    APP_Source_Type_t eSourType = APP_SOURCE_MAX;
    al_uint8 u8HotelMode;
    al_uint8 u8MainUIEn;
#ifdef CONFIG_ATV_SUPPORT
    AL_RecHandle_t hProgHdl = AL_DB_INVALIDHDL;
    AL_ServiceDetail_t stServInfo;
#endif
    PopmsgParam_t stPopup;
#ifdef SUPPORT_SOURCE_DVBTCS
	UINT32 RFtype = APP_RF_TYPE_DVB_MAX;
	UINT32 StringId = 0;
#endif
	UINT32 dAppIndex = 0;
#ifdef CONFIG_SCART_SUPPORT
	DRV_Scart_SignalType_t eScartPin16Status = DRV_Scart_Signal_Unkonwn;
#endif
	UINT8 RegionIdx = 0;
	ColorLUT_t stColorLUTValue;
#ifdef CONFIG_SUPPORT_3D_EN
	APP_Video_Image3DAction_t ePicture3DState = APP_VIDEO_IMAGE_3D_DISABLED;
#endif
#if defined(CONFIG_HEADPHONE_DETECT_BY_ISR) || defined(CONFIG_HPDET_BY_SWTIMER)
	MID_DISP_MUTE_ST eMuteSt = MID_DISP_MUTE;
#endif
#ifdef CONFIG_ATV_SUPPORT
#ifdef SUPPORT_CLOSE_NICAM
    TVFE_AudioFrontEndStatus_t GET_SIFinfo;
#endif
#endif
#ifdef CONFIG_HDMI_SUPPORT_MHL
	INT32 dFocusedIndex;
#endif
#ifdef CONFIG_ATV_SUPPORT
    memset(&stServInfo, 0, sizeof(stServInfo));
#endif
    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));
#ifdef CONFIG_SCART_SUPPORT
    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));
#endif
    if (g_stFactoryUserData.n_FactSet_BurningMode == al_true)
    {
    
#ifdef CONFIG_SUPPORT_DETECT_USBPLL
			if(dMessage  == APP_ATV_GLOBAL_EVENT_ATV_ONRUN)
			{
				UINT32 Index = TOTAL_SYS_APP_SIZE;
				while (MAINAPP_GetActiveSystemAppIndex(&Index) != MAIN_APP_SUCCESS)
				{
					GL_TaskSleep(1);
				}
				if (SP_SUCCESS != APP_GUIOBJ_Source_SetMidSource(NULL)
					#ifdef CONFIG_ATV_SUPPORT
					|| (APP_IsScan_Running())
					#endif
					)
				{
					 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);
				 }
				 
				 UINT8 u8USBPLL_Fail = 0;
				 Cmd_NVMRead(ENVMPurposeIDUSBPLLFailFlag, FALSE, sizeof(UINT8), &u8USBPLL_Fail);
				 if(u8USBPLL_Fail == TRUE)
				 {
					 SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_ATV, APP_GUIOBJ_MUTE,
														APP_INTRA_EVENT_SHOW_CLK_ERROR, 0);
				 }

			}
			if (dMessage  == APP_GLOBAL_EVENT_USBPLL_RESULT)
			{

				SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_ATV, APP_GUIOBJ_MUTE, APP_INTRA_EVENT_SHOW_MESSAGE, dParam);
			}
#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;
		}
        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;
            }
        }
    }


#ifdef CONFIG_SUPPORT_KEY_BOARD
#if 1
    if (dMessage == UI_EVENT_0)
    {
        KeyBoardParam_t param;
        memset(&param, 0, sizeof(KeyBoardParam_t));
        param.dataLength = 24;
        param.StartCode = -1;//default value is -1 or 0
        param.EndCode = -1;//default value is -1 or 0
        keyBoard_Start(&param);
        return 0;
    }

    if (dMessage == UI_EVENT_YELLOW)
    {
        INT32 ret = keyBoard_GetRcDataLength();
        INT32 i = 0;
        printf("[KeyBoard Test]1111ret:%d\n", ret);
        char *tmp = (char*)malloc(ret);
        ret = keyBoard_GetRcValue(tmp, ret);//key.code is in array tmp
        printf("[Jsong debug]2222ret:%d\n", ret);
        for (i = 0; i < ret; i++)
        {
            printf("[KeyBoard Test]tmp[%d]:%c\n", i, tmp[i]);
        }

        keyBoard_Cancel();
        free(tmp);
        tmp = NULL;
        return 0;
    }
#endif
#endif
    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 ((SYSTEM_APP_NO_FOCUSED_GUIOBJ == SYSAPP_GOBJ_GetFocusedGUIObject(SYS_APP_ATV, &dFocusedIndex) || ATVApp_IsPopupExist(PLAYBACK_POPUP_MSG_NO_SIGNAL))
		&& (CbusconnectedFlag == TRUE) && (g_u8CallCMDState == FALSE)
		&& (TRUE == IsMHLSoure))//MHL Port
    {
    	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_PLAYBACK
						#ifndef CONFIG_SUPPORT_MONITOR
						|| u32GuiObj == ATV_GUIOBJ_FREEZE
						#endif
						|| 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 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");
            // no need to notice cec change src
            //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()&& APP_Check_CEC_DEVICE_Status())
            {
				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())
            {
	            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())
			{
				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 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 0//def CONFIG_SUPPORT_MIRACAST
		//if( IsDonglePlugged() )
		{
			//DrawInfoWindow("Device plugged", DRAW_IT);
			MiracastInit();
		}
		//else{
			//DrawInfoWindow("NO Device!!", DRAW_IT);
		//}
#endif
#ifdef CONFIG_SUPPORT_INDONESIA_EWS
			if(!_APP_GUIOBJ_EWS_AreaCodeSetting_GetLeaveState())
			{
				_ATVApp_CloseAllMenu();
				SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, APP_GUIOBJ_EWS_AREACODE, 0);
			}
			else
#endif
			{
            if (SP_SUCCESS != APP_GUIOBJ_Source_SetMidSource(NULL) 
                #ifdef CONFIG_ATV_SUPPORT
                || (APP_IsScan_Running())
                #endif
                )
            {
            	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, ATV_GUIOBJ_PLAYBACK))
            {
                SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV,
                                                     ATV_GUIOBJ_PLAYBACK, 0);
            }
#ifndef CONFIG_SUPPORT_MONITOR
            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);
            }
#endif
#ifdef CONFIG_ATV_SUPPORT
            APP_GUIOBJ_ATV_Playback_SetAtvUnLock(al_false);
#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;
            }
#endif
#ifdef CONFIG_ISDB_SYSTEM
#ifdef CONFIG_ATV_SUPPORT
            if ((eSourType == APP_SOURCE_ATV) && (APP_GUIOBJ_Source_GetRFPort() == RF_INPUT_PORT_AIR))
            {
                APP_GUIOBJ_Source_SetAirSource(AIR_SOURCE_TYPE_ATV);
            }
#endif
#ifndef CONFIG_SUPPORT_ATV_SCAN_NTSCM_PALM_N
#ifdef SUPPORT_SBTVD_AUTOINSTALL
#ifndef CONFIG_SUPPORT_MONITOR
            if (g_stUserInfoData.AutoInstalled)
            {
                g_u8SignalState = ATV_INVALID_STATUS;
                if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_INITINSTALL))
                {
                    //Close all menu before show Auto Installation menu
                    _ATVApp_CloseAllMenu();
#ifdef SUPPORT_FACTORY_AUTO_TEST
					if(APP_Factory_GetAutoTestOnOff() == FALSE)
#endif
					{
						SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, APP_GUIOBJ_INITINSTALL, 0);
					}
                }
            }
#endif
#endif
#endif
#else
#ifndef CONFIG_SUPPORT_ATV_SCAN_NTSCM_PALM_N
#ifndef CONFIG_SUPPORT_MONITOR
            bAutoInstall = g_stUserInfoData.AutoInstalled;
            if (bAutoInstall && (FALSE == gIsFactoryResetting))
            {
                g_u8SignalState = ATV_INVALID_STATUS;
                if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_INITINSTALL))
                {
                    //Close all menu before show Auto Installation menu
                    _ATVApp_CloseAllMenu();
#ifdef SUPPORT_FACTORY_AUTO_TEST
					if(APP_Factory_GetAutoTestOnOff() == FALSE)
#endif
					{
						SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, APP_GUIOBJ_INITINSTALL, 0);
					}
                }
            }
#endif
#else
#endif
#endif

#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 CONFIG_ATV_SUPPORT
                if ((!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_INPUTINFO))
				//#ifndef CONFIG_ISDB_SYSTEM
#ifndef CONFIG_SUPPORT_ATV_SCAN_NTSCM_PALM_N
                && (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_INITINSTALL))
                //#endif
#endif
                    && (!(APP_MenuMgr_Exist_Main_Menu()))
#ifdef SUPPORT_FACTORY_AUTO_TEST_MODE2
					&&(APP_Factory_GetAutoTestOnOff() == FALSE)
#endif
                   )
                {
                    _ATVApp_HidePopupDisplay();
					if((
						#ifndef CONFIG_ISDB_SYSTEM
						(APP_SOURCE_ATV == eSourType) ||
						#endif
						 (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
					)
					{
					#ifdef CONFIG_ATV_SUPPORT
					    if(APP_GetAskPowerOffInSearching() == TRUE)
					#endif
                        {               
                    	SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV,
							ATV_GUIOBJ_INPUTINFO, 0);
                        }
					}
                }
		#endif
#ifdef CONFIG_SUPPORT_NOSIGNAL_AUTO_CHANGE_SOURCE
			if(!g_CheckSignal)
#endif
			{
				if (!ATVApp_IsPopupExist(POPMSG_PROMPT_INPUT_INFO) && (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_MAINMENU)))
			 		_ATVAPP_ShowPopup(ATV_APP_POP_MSG_INPUT_INFO);
#ifdef CONFIG_SUPPORT_MONITOR_POWERSAVE
				if(MID_DISP_DTV_Get_Wakeup_Status() != 0)
				{
					_ATVApp_Wakeup_Display();
					MID_DISP_DTV_Set_Wakeup_Status(0);
				}
#endif
			}
            }

            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));
#ifdef CONFIG_ATV_SUPPORT
            if (eSourType == APP_SOURCE_ATV)
            {
            
#ifndef CONFIG_SUPPORT_ATV_SCAN_NTSCM_PALM_N
				if (g_stUserInfoData.AutoInstalled != 1)
#endif					
				{
				#ifdef SUPPORT_CONSOLE_AUTO_TEST
	                UINT32 uChnNo = 0;
					if(TRUE == APP_Factory_CheckNeedSetChannelByNum(&uChnNo))
					{
						App_SetATVProg_ByChannelNum(uChnNo);
					}
					else
				#endif
					{
	                SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_ATV,
	              			ATV_GUIOBJ_PLAYBACK, APP_ATV_INTRA_EVENT_START_PLAYBACK, TRUE);
					}
				}
            }
#endif

            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;
            }

#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
#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_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_ATV_GLOBAL_EVENT_ATV_RESETTING:
            atv_printf("[%s: %d] APP_ATV_GLOBAL_EVENT_ATV_RESETTING event received\n", __FUNCTION__, __LINE__);
#ifdef CONFIG_ATV_SUPPORT
            if (APP_SOURCE_ATV == eSourType && ATV_AVAILABLE_SIGNAL == g_u8SignalState)
        	{
            	g_ATVbLastParentLock = FALSE;
                ATVApp_CheckProgramType(FALSE);
        	}
#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:
#ifndef CONFIG_SUPPORT_MONITOR
#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 ((!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_INITINSTALL))
					#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
					{
						APP_GUIOBJ_AutoInstall_SetOpenHomeModeFlag(FALSE);
						SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, APP_GUIOBJ_INITINSTALL, INSTALL_FROM_ONLYFORHOMEMODE);
					}
				}
			}
#endif
#endif
            break;
        case APP_GLOBAL_EVENT_OPEN_POPUP:
            #ifdef CONFIG_ATV_SUPPORT
            if ((ATV_APP_POP_MSG_CHECKPWD == dParam) && (APP_GUIOBJ_ATV_Playback_GetAtvUnLock() == TRUE))
            {
                break;
            }
            if ((ATV_APP_POP_MSG_CHECKPWD == dParam) && (APP_GUIOBJ_ATV_Playback_GetProgramState() == al_false))
            {
                break;
            }
            #endif
            _ATVAPP_ShowPopup(dParam);
            break;

        case APP_GLOBAL_EVENT_CLOSE_POPUP:
            ATVApp_ClosePopup(dParam, UI_EVENT_NULL);
            break;
#ifndef CONFIG_SUPPORT_MONITOR
        case APP_GLOBAL_EVENT_POPMSG_PWD:
#ifdef CONFIG_VCHIP_SUPPORT
            if(VchipLockFlag == TRUE)
            {
                UINT8 u8Mute = 0;
                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));
                u8Mute = g_stUserInfoData.Mute;
                APP_Audio_SetMute(u8Mute, TRUE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
                APP_Video_SetMute(TRUE, TRUE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
                APP_ATV_Playback_SetForcePlay();
            }
#endif
#ifdef CONFIG_ATV_SUPPORT
            APP_GUIOBJ_ATV_Playback_SetAtvUnLock(al_true);
            SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_ATV, ATV_GUIOBJ_PLAYBACK,  APP_ATV_INTRA_EVENT_START_PLAYBACK, FALSE);
#endif
#ifdef CONFIG_CC_SUPPORT
            if((eSourType >= APP_SOURCE_SCART) && (eSourType <= APP_SOURCE_SVIDEO2))
            {
				if(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_CC))
				{
					SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_ATV,
						ATV_GUIOBJ_CC, APP_GLOBAL_EVENT_CC_RESTART, 0);
				}
			}
#endif
            break;
#endif
		case APP_ATV_GLOBAL_EVENT_SCARTINPUT_CHANGE:
			#ifdef CONFIG_SCART_SUPPORT
			eScartPin16Status = App_SCARTIN_GetPin16Satus();
			if (eScartPin16Status != dParam)
			{
				if ((eSourType == APP_SOURCE_SCART) ||(eSourType == APP_SOURCE_SCART1))
				{
					AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_SETUP, 0,
						sizeof(APP_SETTING_Setup_t), &(g_stSetupData));
					if (g_stSetupData.SCARTInput == DRV_SCART_AUTO)
					{
						if (App_SCARTIN_IsScartPathNeedChange(eScartPin16Status, dParam))
						{
							InputSrc_t eSourcePort = INPUTSRC_DISABLE;
							DRV_ScartSrcType_t eScartIn = DRV_SCART_NONE;
							InputVideoConf_st eCurInputPin;
							APP_GUIOBJ_Source_GetMidSource(NULL, &eSourcePort);
							App_SCARTIN_SetPin16Satus(dParam);
							App_SCARTIN_GetScartInPath(dParam, &eScartIn);
							if (APP_GUIOBJ_Source_GetCurrentInputPin(&eCurInputPin) == SP_SUCCESS)
							{
								APP_Video_Set_DISP_DTVSetVideoMute_ByUserSetting();
								MID_DISP_DTVSetSourceEx(eSourcePort, eScartIn, eCurInputPin);
							}
						}
					}
				}
				App_SCARTIN_SetPin16Satus(dParam);
			}
			#endif
			break;

		case APP_ATV_GLOBAL_EVENT_HDMIDVI_CHANGE:
			if (dParam != APP_MODE_UNDEFINE && ((eSourType == APP_SOURCE_HDMI)||(eSourType == APP_SOURCE_HDMI1)||(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);
#ifndef CONFIG_SUPPORT_MONITOR
						UINT32 u32Spdif;
						APP_GUIOBJ_Sound_GetSPDIF(&u32Spdif);
						APP_GUIOBJ_Sound_SetSPDIF(u32Spdif);
#endif
	  				}
					PreHDMIMODE = dParam;
				}
				#ifdef CONFIG_ATV_SUPPORT
				if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_INPUTINFO))
				{
					SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_ATV, APP_ATV_GLOBAL_EVENT_INFO_UPDATE, 0);
				}
				#endif
				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_HDMI1)||(eSourType == APP_SOURCE_HDMI2)))
			{
				APP_Audio_HDMITypeChange(APP_ACP_TYPE_CHG,dParam);
			}
			break;

		case APP_ATV_GLOBAL_EVENT_HDMIPORT_STATUS:
#ifdef SUPPORT_CEC_TV
			CECTV_HDMIPortStatus(dParam);
#endif
			break;
#if defined(CONFIG_HEADPHONE_DETECT_BY_ISR) || defined(CONFIG_HPDET_BY_SWTIMER)
		case APP_GLOBAL_EVENT_HEADPHONE_PLUG_IN:
			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);
			#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_SWITCH_ON == g_stFeatureData.Enable_HDMILink)
            		&&(APP_HDMILINK_AMPLIFIER == g_stFeatureData.SpeakerPreference)
            		#ifdef CONFIG_SUPPORT_CEC_TV
                    &&((!CECTV_GetHDMISystemAudioMode())||(!APP_Check_CEC_DEVICE_Status())|| APP_GUIOBJ_Source_GetAmplifierPort()== 0)
                    #endif
					)))

				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:
			APP_Audio_Set_HPStatus(APP_Audio_Headphone_PlugOut);
			APP_Audio_SetMuteDACHeadohone(TRUE);
			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) && (g_stFeatureData.SpeakerPreference == APP_HDMILINK_TVSPEAKER 
              
                || (( APP_SWITCH_ON == g_stFeatureData.Enable_HDMILink)
            		&&(APP_HDMILINK_AMPLIFIER == g_stFeatureData.SpeakerPreference)
            		#ifdef CONFIG_SUPPORT_CEC_TV
                    &&((!CECTV_GetHDMISystemAudioMode())||(!APP_Check_CEC_DEVICE_Status())|| APP_GUIOBJ_Source_GetAmplifierPort()== 0)
                    #endif
					)))

			{
				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:
		{
			UINT32 dActiveSysApp = TOTAL_SYS_APP_SIZE;
			if (MAINAPP_GetActiveSystemAppIndex(&dActiveSysApp) == MAIN_APP_SUCCESS)
			{
				if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_MAINMENU) && ID_InputSelect != APP_MENU_GetCurrentNode())
				{
					SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, APP_GUIOBJ_MAINMENU);
				}
			}
			APP_Audio_SetMuteAll(TRUE);
			break;
		}
		
#ifdef CONFIG_QSD
		case APP_GLOBAL_EVENT_QSD_MEDIA_PLAY:
			{
				_ATVApp_CloseAllMenu();
				_ATVApp_ResetPopup_Channel();
				void MM_MediaQsd_SetTestFlag(BOOLEAN bFlag, UINT32 dParam);
				MM_MediaQsd_SetTestFlag(TRUE, dParam);
#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;
			#ifndef CONFIG_SUPPORT_MONITOR
			MID_DISP_DTVGetPause(&bFreezeFlag);
			#endif
            if (APP_MenuMgr_Exist_Main_Menu()
                || APP_MenuMgr_Exist_Factory_Menu()
			#if defined(CONFIG_DVB_SYSTEM) || defined(CONFIG_AUS_DVB_SYSTEM) || defined(CONFIG_DTMB_SYSTEM)
                || SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_CHNMGR)
                || SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_FAVMGR)
                || SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_CHNRENAME)
                || SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_CHNLIST)
				|| SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_FAVLIST)
			#endif
			#ifdef CONFIG_ISDB_SYSTEM
				|| SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_CHNRENAME)
				|| SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_CHNLIST)
			#endif
				)
            {
                #ifndef CONFIG_SUPPORT_MONITOR
                if (bFreezeFlag)
                {
                    SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, ATV_GUIOBJ_FREEZE, 0);
                }
                #endif
                #ifdef CONFIG_ATV_SUPPORT
                if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_AMS_SEARCH))
                {
                    _ATVApp_Exit_All_Menu(1);
                }
                else
                #endif
                {
                    _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();
		#ifndef CONFIG_SUPPORT_MONITOR
                if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_FREEZE))
                {
                    SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_FREEZE);
                }
		#endif
#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
#ifndef CONFIG_SUPPORT_MONITOR
                if (bFreezeFlag)
                {
                    MID_DISP_DTVSetPause(FALSE);
                }
#endif
#ifdef CONFIG_BANDWIDTH_LIMIT_WHEN_MENU_OPEN
				Cmd_VipAdjust(VIP_MENU_IS_OPEN,1);
#endif
#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
				{
					if(SYSAPP_GOBJ_Get_OSDLOCK() == TRUE)
					{
						_ATVAPP_ShowPopup(ATV_APP_POP_MSG_OSDLOCK);
					}	
					else
					{
						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();
				if(SYSAPP_GOBJ_Get_OSDLOCK() == TRUE)
				{
					SYSAPP_GOBJ_Set_OSDLOCK(FALSE);
					SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, APP_GUIOBJ_SOURCE, 0);
					SYSAPP_GOBJ_Set_OSDLOCK(TRUE);
				}
				else
	                SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, APP_GUIOBJ_SOURCE, 0);
            }
            break;
#ifdef CONFIG_DTV_SUPPORT
#ifdef CONFIG_SUPPORT_PVR
        case APP_GLOBAL_EVENT_PVRREC_CHANGESOURCE:
            DVBApp_SetPVRSwitchSRC(TRUE);
			/*
            if (g_eRecType == AL_RECTYPE_DVBRADIO)
            {
                APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_RADIO);
            }
            else
            */ //uniplatform has not radio source,radio&&dtv share DTV source
            {
                APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_DTV);
            }
            break;
        case APP_GLOBAL_EVENT_PVR_REMINDER:
        {
            AL_Return_t ret;
#ifdef CONFIG_ISDB_SYSTEM
			AL_DB_EDBType_t DBType_ret = AL_DBTYPE_DVB_SBTVD;
#else
			AL_DB_EDBType_t DBType_ret = AL_DBTYPE_DVB_T;
#endif
            AL_DB_ERecordType_t RecType = AL_RECTYPE_DVBTV;
            al_uint32 CurTimeInSec = 0;
            AL_Time_GetCurTimeInSecs(&CurTimeInSec);

            g_dReminderId = dParam;
            /*  get remider program index */
            memset(&g_stDetails, 0, sizeof(AL_PR_details_t));
            ret = AL_PR_GetById(g_dReminderId, &g_stDetails);
            if (ret != AL_SUCCESS)
            {
                atv_printf("AL_PR_GetById Error\n");
            }
			APP_WAKEUP_Recorder_SetTimeout();
            /*Only storage the current REC type for start prompted pop*/
            DVBApp_SetRemType(g_stDetails.rem_type);
            if (AL_PR_EVT_REM == g_stDetails.rem_type)
            {
                DVBApp_PVRDEMUX_SetTimerRECFLag(TRUE);
            }
            /*set reminder popup show time*/
            AL_DB_GetRecordType(g_stDetails.rem_details.handle, &DBType_ret, &RecType);
            if (RecType == AL_RECTYPE_DVBTV)
            {
                g_eRecType = AL_RECTYPE_DVBTV;
            }
            else if (RecType == AL_RECTYPE_DVBRADIO)
            {
                g_eRecType = AL_RECTYPE_DVBRADIO;
            }
            //popup reminder message
            g_bShowReminder = TRUE;
            _ATVApp_ResetPopup_Channel();
            _ATVApp_CloseAllMenu();
            _ATVAPP_ShowPopup(ATV_APP_POP_MSG_PVR_REMIDER);
            g_bShowReminder = FALSE;
        }
        break;
        case APP_GLOBAL_EVENT_PVR_REMINDER_CONFIRM:
            _ATVAPP_ShowPopup(ATV_APP_POP_MSG_PVR_REMIDER_CONFIRM);
            break;
        case APP_GLOBAL_EVENT_PVR_INSERT_USB_POP:
            _ATVAPP_ShowPopup(ATV_APP_POP_MSG_INSERT_USB);
            break;
        case APP_GLOBAL_EVENT_PVR_INVALID_USB_POP:
            _ATVAPP_ShowPopup(ATV_APP_POP_MSG_INVALID_USB);
            break;
        case APP_GLOBAL_EVENT_PVR_INSERT_USB_CONFIRM:
            _ATVAPP_ShowPopup(ATV_APP_POP_MSG_INSERT_USB_CONFIRM);
            break;
        case APP_GLOBAL_EVENT_PVR_INVALID_USB_CONFIRM:
            _ATVAPP_ShowPopup(ATV_APP_POP_MSG_INVALID_USB_CONFIRM);
            break;
#endif
#endif
#ifdef TEAC_BLUE_KEY_FUNCTION
		case UI_EVENT_BLUE:
            if (eSourType == APP_SOURCE_PC)
			{
				UINT16 usTimingTblIdx;
				PLF_VideoID_t eResolution;
				Boolean UserFlag;
				APP_SETTING_PC_AutoTune_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;
				}
				_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 = APP_PC_HPOS_DEF;
					PC_Tempvalue.i16VPosition = APP_PC_VPOS_DEF;
#ifndef CONFIG_SUPPORT_MONITOR
					PC_Tempvalue.Phase =
						APP_GUIOBJ_ATV_PCSetup_PhaseMappingtoOSDValue(PC_Tempvalue.Phase);
#else
					PC_Tempvalue.Phase =
						APP_UserMenu_PCSetup_PhaseMappingtoOSDValue(PC_Tempvalue.Phase);
#endif
					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 - APP_PC_HPOS_DEF));
					MID_DISP_DTVSetCropWindowVStartOffset(0, (PC_Tempvalue.i16VPosition - APP_PC_VPOS_DEF));
					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]));
				}
			}
            if((eSourType == APP_SOURCE_HDMI) || (eSourType == APP_SOURCE_HDMI1) || (eSourType == APP_SOURCE_HDMI2))
            {
				MID_InputInfo_t stTimingInfo;
				Boolean bIsHdmiNeedOverScan = TRUE;
				MID_DISP_DTVGetTimingInfo(&stTimingInfo);
				bIsHdmiNeedOverScan = stTimingInfo.bIsHdmiNeedOverScan;
				if(bIsHdmiNeedOverScan == FALSE )
					break;
				SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, APP_GUIOBJ_BANNER, dMessage);
			}
			break;
#endif
#ifdef CONFIG_SUPPORT_HELP_MENU
		case UI_EVENT_HELP:
            _ATVApp_CloseAllMenu();
            _ATVApp_ResetPopup_Channel();
			SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, APP_GUIOBJ_HELP_MENU, 0);
			break;
#endif
        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:
#ifndef CONFIG_SUPPORT_MONITOR
#ifdef CONFIG_SUPPORT_HOTKEY_SOURCE_LOCK
            g_fmSourceLock_flag = FALSE;
            SourceLock_Set_Hotkey_Flag(g_fmSourceLock_flag);
#endif
            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);
		    	}
            }
#endif
            break;
#endif
#ifdef CONFIG_SUPPORT_HOTKEY_SOURCE_LOCK
        case UI_EVENT_FAC_SOURCE_LOCK:
            g_fmSourceLock_flag = TRUE;
			SourceLock_Set_Hotkey_Flag(g_fmSourceLock_flag);
            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_SOURCELOCK, ENTER_HOTELSET_NOTFROM_FACTORYMENU);
                }
            }
            break;
#endif
#ifdef CONFIG_SUPPORT_USB_UPGRADE
		case UI_EVENT_CHECK_UPGRADE:
			#ifndef UNSUPPORT_MAINMENU_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);
                }
			}
			#endif
			break;
#endif
#ifdef SUPPORT_CLOSE_NOTTVSOURCE_BY_PINCODE
		case UI_EVENT_ALLSOURCE_ON:
            if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_SOURCE) && eSourType == APP_SOURCE_ATV)
            {
				//set all source support
				APP_GOBJ_Source_Set_ResetDefaultSourceSupport();
        		SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, APP_GUIOBJ_SOURCE);
            }
			break;
		case UI_EVENT_TVSOURCE_ON:
            if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_SOURCE) && eSourType == APP_SOURCE_ATV)
            {
				//set only tv source support
				APP_GOBJ_Source_Set_OnlyTVSourceSupport();
        		SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, APP_GUIOBJ_SOURCE);
            }
			break;
#endif
        case UI_EVENT_PCAUTOADJ:
            if (eSourType == APP_SOURCE_PC)
            {
                UINT16 usTimingTblIdx;
                PLF_VideoID_t eResolution;
                Boolean UserFlag;
                APP_SETTING_PC_AutoTune_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;
                }
                _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.i8HpositionOffset = APP_PC_HPOS_DEF;
                	PC_Tempvalue.i8VpositionOffset = APP_PC_VPOS_DEF;
#ifndef CONFIG_SUPPORT_MONITOR
                     PC_Tempvalue.Phase = APP_GUIOBJ_ATV_PCSetup_PhaseMappingtoOSDValue(PC_Tempvalue.Phase);
#else
                     PC_Tempvalue.Phase = APP_UserMenu_PCSetup_PhaseMappingtoOSDValue(PC_Tempvalue.Phase);
#endif
                     PC_Tempvalue.i8ClockOffset = 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.i8HpositionOffset;
                     g_stSysInfoData.stPC_AutoTune[usTimingTblIdx].i8VpositionOffset = PC_Tempvalue.i8VpositionOffset;
                     g_stSysInfoData.stPC_AutoTune[usTimingTblIdx].i8ClockOffset = PC_Tempvalue.i8ClockOffset;
                     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.i8HpositionOffset - APP_PC_HPOS_DEF));
                     MID_DISP_DTVSetCropWindowVStartOffset(0, (PC_Tempvalue.i8VpositionOffset - APP_PC_VPOS_DEF));
                     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_POWER:
            MAINAPP_SendGlobalEvent(UI_EVENT_POWER, AL_POWER_STATE_OFF);
            break;
        case UI_EVENT_EPG:
#ifndef CONFIG_SUPPORT_MONITOR        
            _ATVAPP_ShowPopup(ATV_APP_POP_MSG_NOT_AVAILABLE);
#endif            
            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()&& APP_Check_CEC_DEVICE_Status())
            {
                if (CECTV_GetCECEnable() == CECTV_ENABLE && CECTV_GetHDMISystemAudioMode() && g_u32MuteIconHandle >= MUTE_KEY_INTERVAL)
				{
					APP_Set_CECTV_Mute_Status(EVENT_CECTV_SET_MUTE_STATUS_MUTE);
					g_u32MuteIconHandle = 0;
					break;
				}
				else if(g_u32MuteIconHandle < MUTE_KEY_INTERVAL)//Don't handle mute icon
				{
					break;
				}

            }
			APP_Set_HDMICEC_TV_Mute_Status(!APP_Get_HDMICEC_TV_Mute_Status());
#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_OSD_GAME_SUPPORT
                if (eSourType == APP_SOURCE_GAME)
                {
                    if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_GAMEMENU)
                        && (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_OSDGAME)))
                    {
                        SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, APP_GUIOBJ_GAMEMENU, GAME_TYPE_LAYER2_OSDGAME);
                    }
                }
#endif
			}
			APP_UserMenu_MuteKeyHandler();
            break;

#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()&& APP_Check_CEC_DEVICE_Status())
			{
				if (CECTV_GetCECEnable() == CECTV_ENABLE)
                {
                    if( (dParam & 0x80) != 0) //reopen TV, the amp vol status must sinc.So if amp is mute state, tv need to set mute state.
                    {
                    	 APP_Set_CECTV_Mute_Status(EVENT_CECTV_SET_MUTE_STATUS_MUTE);
                    }

                    APP_Process_CECTV_Mute_Status(dParam);
                }
			}
			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();
			#ifndef CONFIG_SUPPORT_MONITOR
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_FREEZE))
			{
				SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_FREEZE);
			}
			#endif
			#ifndef CONFIG_SUPPORT_MONITOR
			MID_DISP_DTVGetPause(&bFreezeFlag);
			if (bFreezeFlag)
			{
				MID_DISP_DTVSetPause(FALSE);
			}
			#endif
			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;
            _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 (APP_GUIOBJ_Source_GetLockState() == FALSE)
                {
                    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:
#ifdef CONFIG_ATV_SUPPORT
            if (eSourType == APP_SOURCE_ATV)
            {
                if (dMessage == UI_EVENT_CH_DN)
                {
                    hProgHdl = APP_ATV_Playback_SearchNextProg(-1, APP_FAVORITE_NONE);
                }
                else if (dMessage == UI_EVENT_CH_UP)
                {
                    hProgHdl = APP_ATV_Playback_SearchNextProg(1, APP_FAVORITE_NONE);
                }

                if (AL_DB_INVALIDHDL != hProgHdl)
                {
                    AL_DB_EDBType_t db_type;
                    AL_DB_ERecordType_t record_type;
                    AL_DB_GetRecordType(hProgHdl, &db_type, &record_type);
                    if (db_type == AL_DBTYPE_DVB_ATV)
                    {
                        _ATVApp_Zapping(hProgHdl, FALSE);
                    }
					#ifdef CONFIG_ISDB_SYSTEM
                    else if(db_type == AL_DBTYPE_DVB_SBTVD)
                    {
                   		APP_DVB_Playback_SetCurrentProgHandle(db_type, record_type, hProgHdl);
                        APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_DTV);
                    }
					#endif
					else
					{
						_ATVApp_CloseAllMenu();
					}
                }
                else
                {
                    /* cj_marker, it's need? */
					#if 0
                    SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_ATV, ATV_GUIOBJ_PLAYBACK,
                                                         APP_ATV_INTRA_EVENT_START_PLAYBACK, FALSE);
					#endif
                }
            }
#ifdef SUPPORT_JUMP_TVSOURCE
            else
            {
                AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_CHANNEL, 0,
			        sizeof(APP_SETTING_Channel_t), &(g_stChannelData));
				#ifdef CONFIG_DVB_SYSTEM
                if (g_stChannelData.Country == AREA_FRANCE)//customer spec
                {
                    _ATVApp_CloseAllMenu();
                    _ATVApp_ResetPopup_Channel();
                    APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_DTV);
                }
				#endif
            }
#else
            else
            {
                _ATVAPP_ShowPopup(ATV_APP_POP_MSG_NOT_AVAILABLE);
            }
#endif
#endif
            break;

        case UI_EVENT_RECALL:
#ifdef CONFIG_ATV_SUPPORT
            if (eSourType == APP_SOURCE_ATV)
            {
                hProgHdl = APP_ATV_Playback_GetPrevProg();
                AL_DB_QueryDetail(hProgHdl, (al_void *)&stServInfo);
                if(stServInfo.stAnalogServ.skip == 1)
                {
                    break;
                }
                if ((AL_DB_INVALIDHDL != hProgHdl) && (hProgHdl != APP_ATV_Playback_GetCurProg()))
                {
                    _ATVApp_Zapping(hProgHdl, FALSE);
                }
                else
                {
                    _ATVAPP_ShowPopup(ATV_APP_POP_MSG_NOT_AVAILABLE);
                }
            }
            else
            {
	            #if 0
                _ATVApp_CloseAllMenu();
                _ATVApp_ResetPopup_Channel();
                AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_USERINFO, 0,
                                sizeof(APP_SETTING_UserInfo_t), &(g_stUserInfoData));
                APP_GUIOBJ_Source_SetAppSource(g_stUserInfoData.LastTVSource);
				#endif
            }
#endif
            break;

        case APP_ATV_INTRA_EVENT_ZAPPING:
		#ifdef CONFIG_ATV_SUPPORT
		_ATVApp_Zapping(dParam, FALSE);
		#endif
		break;

#ifdef CONFIG_ISDB_SYSTEM
        case UI_EVENT_AD:
            if (APP_GUIOBJ_Source_GetRFPort() == RF_INPUT_PORT_AIR)
            {
                APP_GUIOBJ_Source_SetAirSource(AIR_SOURCE_TYPE_DTV);
                _ATVApp_CloseAllMenu();
                _ATVApp_ResetPopup_Channel();

                /* switch dtv or radio */
                APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_DTV);
#ifdef SUPPORT_SFU_AUTO_TEST
				APP_Console_TO_SUF_Respond(CON_TO_SUF_ACK);
#if 0
				extern void Enable_Debug_Message(UINT32 DBGStatus);
				Enable_Debug_Message(1<<MODULEID_UMF);
				atv_printf("ACK\n");
				Enable_Debug_Message(0);
#endif

#endif
            }
            break;
#endif

#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

#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_CHLIST:
#ifdef CONFIG_ATV_SUPPORT
            if (eSourType == APP_SOURCE_ATV)
            {
                if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_CHNLIST))
                {
                    SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_CHNLIST);
                }
                else
                {
    				_ATVApp_CloseAllMenu();
#ifdef CONFIG_ISDB_SYSTEM
    				SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, ATV_GUIOBJ_CHNLIST, SBTVD_CHNLIST_TYPE_CHNLIST);
#else
    				SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, ATV_GUIOBJ_CHNLIST, 0);
#endif
                }
            }
            else
#endif
            {
                _ATVAPP_ShowPopup(ATV_APP_POP_MSG_NOT_AVAILABLE);
            }
            break;

        case UI_EVENT_FAV:
#ifndef CONFIG_SUPPORT_MONITOR			
#ifdef CONFIG_ATV_SUPPORT
			AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_CHANNEL, 0,
			        sizeof(APP_SETTING_Channel_t), &(g_stChannelData));
			#ifdef CONFIG_DVB_SYSTEM
			if (g_stChannelData.Country == AREA_NORWAY)
			{
				break;
			}
			#endif
            if (eSourType == APP_SOURCE_ATV)
            {
#ifdef CONFIG_ISDB_SYSTEM
                if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_CHNLIST))
                {
                    SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_CHNLIST);
                }
#endif
#if defined(CONFIG_DVB_SYSTEM) || defined(CONFIG_AUS_DVB_SYSTEM) || defined(CONFIG_ANALOGUE_ONLY_SYSTEM) ||defined(CONFIG_DTMB_SYSTEM)
                if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_FAVLIST))
                {
                    SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_FAVLIST);
                }
#endif
                else
                {
                    _ATVApp_CloseAllMenu();
#ifdef CONFIG_ISDB_SYSTEM
                    SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, ATV_GUIOBJ_CHNLIST, SBTVD_CHNLIST_TYPE_FAVLIST);
#endif
#if defined(CONFIG_DVB_SYSTEM) || defined(CONFIG_AUS_DVB_SYSTEM) || defined(CONFIG_ANALOGUE_ONLY_SYSTEM) ||defined(CONFIG_DTMB_SYSTEM)
                    SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, ATV_GUIOBJ_FAVLIST, 0);
#endif
                }
            }
            else
#endif
            {
                _ATVAPP_ShowPopup(ATV_APP_POP_MSG_NOT_AVAILABLE);
            }
#endif
            break;

        case UI_EVENT_FAV_UP:
        case UI_EVENT_FAV_DN:
#ifndef CONFIG_ISDB_SYSTEM
#ifdef CONFIG_ATV_SUPPORT
            if (eSourType == APP_SOURCE_ATV)
            {
                UINT32 TotalNum = 0;
                AL_RecHandle_t hCurServHdl = AL_DB_INVALIDHDL;
                APP_Favorite_t FavType=APP_FAVORITE_NONE;

                //FavType = APP_ATV_Playback_GetFavType();
                FavType = APP_GUIOBJ_ATV_Playback_GetFavType();
                APP_Database_InitChnList(APP_DB_CHNLISTTYPE_ATV, AL_DB_INVALIDHDL, APP_Database_ConvertFavType2List(FavType));
                TotalNum = APP_Database_GetChnListSize();
                APP_Database_UninitChnList();
                if (TotalNum == 0)
                {
                    /* search next fav list type */
                    int i = 0;
                    for (i=0; i<3; i++)
                    {
                        FavType++;
                        if (FavType == APP_FAVORITE_MAX)
                            FavType = APP_FAVORITE_1;
                        APP_Database_InitChnList(APP_DB_CHNLISTTYPE_ATV, AL_DB_INVALIDHDL, APP_Database_ConvertFavType2List(FavType));
                        TotalNum = APP_Database_GetChnListSize();
                        APP_Database_UninitChnList();
                        if (TotalNum > 0)
                        {
							APP_GUIOBJ_ATV_Playback_SetFavType(FavType);
                            break;
                        }
                    }

                    if (i == 3)
                    {
						APP_GUIOBJ_ATV_Playback_SetFavType(APP_FAVORITE_1);
                        _ATVAPP_ShowPopup(ATV_APP_POP_MSG_NOT_AVAILABLE);
                        break;
                    }
                }

                if (TotalNum < 2)
                {
                    _ATVAPP_ShowPopup(ATV_APP_POP_MSG_NOT_AVAILABLE);
                    break;
                }

                if (dMessage == UI_EVENT_FAV_UP)
                {
                    hCurServHdl = APP_ATV_Playback_SearchNextProg(1, FavType);
				}
				else if (dMessage == UI_EVENT_FAV_DN)
				{
					hCurServHdl = APP_ATV_Playback_SearchNextProg(-1, FavType);
				}
				if (hCurServHdl != AL_DB_INVALIDHDL)
				{
                    AL_DB_EDBType_t db_type;
                    AL_DB_ERecordType_t record_type;
                    AL_DB_GetRecordType(hCurServHdl, &db_type, &record_type);
                    if (db_type == AL_DBTYPE_DVB_ATV)
                    {
                        _ATVApp_Zapping(hCurServHdl, FALSE);
                    }
                    else
                    {
                        _ATVApp_CloseAllMenu();
                    }
				}
				else
				{
					SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_ATV, ATV_GUIOBJ_PLAYBACK,
						APP_ATV_INTRA_EVENT_START_PLAYBACK, FALSE);
				}
            }
            else
#endif
            {
                _ATVAPP_ShowPopup(ATV_APP_POP_MSG_NOT_AVAILABLE);
            }
            break;
#else
#ifdef CONFIG_ATV_SUPPORT
            if (eSourType == APP_SOURCE_ATV)
            {
                UINT32 TotalNum=0;
                AL_RecHandle_t hCurServHdl;
                AL_ServiceDetail_t stServInfo;
                APP_Favorite_t FavType=APP_FAVORITE_NONE;
                APP_EProgListType_t ListType=ProgListType_Normal;

                hCurServHdl = APP_ATV_Playback_GetCurProg();
                AL_DB_QueryDetail(hCurServHdl, (al_void *)&stServInfo);

                //FavType = APP_ATV_Playback_GetFavType();
                FavType = APP_GUIOBJ_ATV_Playback_GetFavType();
                if (FavType == APP_FAVORITE_NONE)
                {
                    if (stServInfo.stAnalogServ.fav1 == 1)
                    {
                        ListType = ProgListType_Fav1;
                        FavType = APP_FAVORITE_1;
                    }
                    else if (stServInfo.stAnalogServ.fav2 == 1)
                    {
                        ListType = ProgListType_Fav2;
                        FavType = APP_FAVORITE_2;
                    }
                    else if (stServInfo.stAnalogServ.fav3 == 1)
                    {
                        ListType = ProgListType_Fav3;
                        FavType = APP_FAVORITE_3;
                    }
                    else if (stServInfo.stAnalogServ.fav4 == 1)
                    {
                        ListType = ProgListType_Fav4;
                        FavType = APP_FAVORITE_4;
                    }
                    else
                    {
                        _ATVAPP_ShowPopup(ATV_APP_POP_MSG_NOT_AVAILABLE);
                        break;
                    }
                    APP_GUIOBJ_ATV_Playback_SetFavType(FavType);
                }
                else
                {
                    if (FavType == APP_FAVORITE_1)
                    {
                        ListType = ProgListType_Fav1;
                    }
                    else if (FavType == APP_FAVORITE_2)
                    {
                        ListType = ProgListType_Fav2;
                    }
                    else if (FavType == APP_FAVORITE_3)
                    {
                        ListType = ProgListType_Fav3;
                    }
                    else if (FavType == APP_FAVORITE_4)
                    {
                        ListType = ProgListType_Fav4;
                    }
                    else
                    {
                        /* never run here */
                        _ATVAPP_ShowPopup(ATV_APP_POP_MSG_NOT_AVAILABLE);
                        break;
                    }
                }

                if (APP_ProgList_IsExist(AL_DBTYPE_DVB_ATV, AL_RECTYPE_ATVSERVICE, ListType) == al_true)
                {
                    TotalNum = APP_ProgList_GetTotalNum(AL_DBTYPE_DVB_ATV, AL_RECTYPE_ATVSERVICE, ListType);
                }
                else
                {
                    APP_Database_SetCareIsValid(al_true);
                    APP_ProgList_Init(AL_DBTYPE_DVB_ATV, AL_RECTYPE_ATVSERVICE, AL_DB_INVALIDHDL, ListType, &TotalNum);
                    //APP_ProgList_Uninit(AL_DBTYPE_DVB_ATV, AL_RECTYPE_ATVSERVICE, ListType);
                }
                if (TotalNum < 2)
                {
                    _ATVAPP_ShowPopup(ATV_APP_POP_MSG_NOT_AVAILABLE);
                    break;
                }

                if (dMessage == UI_EVENT_FAV_UP)
				{
                    hCurServHdl = APP_ATV_Playback_SearchNextProg(1, FavType);
				}
				else if (dMessage == UI_EVENT_FAV_DN)
				{
					hCurServHdl = APP_ATV_Playback_SearchNextProg(-1, FavType);
				}
				if (hCurServHdl != AL_DB_INVALIDHDL)
				{
					_ATVApp_Zapping(hCurServHdl, FALSE);
				}
				else
				{
					SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_ATV, ATV_GUIOBJ_PLAYBACK,
						APP_ATV_INTRA_EVENT_START_PLAYBACK, FALSE);
				}
            }
            else
#endif
            {
                _ATVAPP_ShowPopup(ATV_APP_POP_MSG_NOT_AVAILABLE);
            }
            break;
#endif
        case UI_EVENT_DISPLAY:
#ifndef CONFIG_SUPPORT_MONITOR
#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
            {
                if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_PROGNUM))
                {
                    SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_PROGNUM);
                }
                if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_TTXCLOCK))
                {
                    SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_TTXCLOCK);
                }
				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);
					}
                }
            }
#endif
            break;

        case UI_EVENT_AUDIO:
#ifdef CONFIG_ATV_SUPPORT
            if (ATV_AVAILABLE_SIGNAL != g_u8SignalState
        #ifndef SUPPORT_CHANNEL_SWITCH
            || (eSourType != APP_SOURCE_ATV)
        #endif
            )
            {
#ifdef CELLO_REMOTE_KEY
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_BANNER))
			{
				break;
			}
#else
		    _ATVAPP_ShowPopup(ATV_APP_POP_MSG_NOT_AVAILABLE);
		    break;
#endif
            }

            if (APP_GUIOBJ_ATV_Playback_GetProgramState() && eSourType == APP_SOURCE_ATV)
            {
                break;
            }
			MID_TVFE_GetCurrentVideoInfo(NULL, &eResolution);

            if (eSourType != APP_SOURCE_ATV)
            {
                if ((eResolution == PLF_VIDEO_TIMING_ID_NO_SIGNAL) ||
                    (eResolution == PLF_VIDEO_TIMING_ID_SNOW525)   ||
                    (eResolution == PLF_VIDEO_TIMING_ID_UNKNOW_FORMAT))
                {
                    _ATVAPP_ShowPopup(ATV_APP_POP_MSG_NOT_AVAILABLE);
                    break;
                }
            }

            _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, ATV_GUIOBJ_SIF, 0);
#endif
            break;

        case UI_EVENT_TEXT:
#if defined(CONFIG_SCART_SUPPORT) || defined(CONFIG_ATV_SUPPORT) || defined(CONFIG_AV_SUPPORT) || defined(CONFIG_SV_SUPPORT)
		#ifdef CONFIG_ATV_SUPPORT
			if ((eSourType == APP_SOURCE_ATV) && (APP_GUIOBJ_ATV_Playback_GetProgramState()))
				break;
		#endif

            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);
#ifdef CONFIG_SCART_SUPPORT
                if ((eSourType == APP_SOURCE_SCART || eSourType == APP_SOURCE_SCART1)
                    && App_SCARTIN_GetPin16Satus() == DRV_Scart_Signal_RGB)
                {
#ifdef CONFIG_SUPPORT_TTX
                    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();
				#ifndef CONFIG_SUPPORT_MONITOR
                            if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_FREEZE))
                            {
                                SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_FREEZE);
                                MID_DISP_DTVSetPause(FALSE);
                            }
				#endif
                            SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, ATV_GUIOBJ_TTX, 0);
                        }
                    }
                    else
#endif
                    {
#ifdef CONFIG_CC_SUPPORT
                        atv_printf("call create cc menu!\n");
                        _ATVApp_CloseAllMenu();
                        SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, ATV_GUIOBJ_CC_BANNER, 0);
                        break;
#endif            
                        atv_printf("There is no TT Data!\n");
#ifdef CONFIG_SUPPORT_TTX
                        _ATVAPP_ShowPopup(ATV_APP_POP_MSG_NO_TTX);
#else
                        _ATVAPP_ShowPopup(ATV_APP_POP_MSG_NOT_AVAILABLE);
#endif
                    }

                }
				else
#endif
                {	
                    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;
                    }
                }
            }
#endif
            break;
#ifdef SUPPORT_CLOCKINFO_SHOW
        case UI_EVENT_DEVLIST:  //UI_EVENT_DEVLIST  clock key
			if ((eSourType == APP_SOURCE_ATV) && (APP_GUIOBJ_ATV_Playback_GetProgramState()))
				 break;
            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
        case UI_EVENT_SUBTITLE:
#ifndef CONFIG_SUPPORT_MONITOR			
			{
#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(eSourType == APP_SOURCE_ATV)
				{
					if(APP_GUIOBJ_ATV_Playback_GetProgramState())
					{
			            _ATVAPP_ShowPopup(ATV_APP_POP_MSG_NOT_AVAILABLE);
						break;
					}
				}
				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);
}
#endif		
            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:

#ifdef CONFIG_ATV_SUPPORT
            if (APP_GUIOBJ_ATV_Playback_GetProgramState() && eSourType == APP_SOURCE_ATV)
            {
                break;
            }
#endif
            if (g_u8SignalState != ATV_AVAILABLE_SIGNAL)
            {
                break;
            }
#ifndef CONFIG_SUPPORT_MONITOR
            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;
            }
#endif
            _ATVApp_CloseAllMenu();
            if (ATVApp_IsPopupExist(PLAYBACK_POPUP_MSG_NO_SIGNAL))
            {
                ATVApp_ClosePopup(PLAYBACK_POPUP_MSG_NO_SIGNAL, UI_EVENT_NULL);
            }
			if(SYSAPP_GOBJ_Get_OSDLOCK() == TRUE)
			{
				_ATVAPP_ShowPopup(ATV_APP_POP_MSG_OSDLOCK);
			}	
			else
			{
	            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
#ifndef CONFIG_SUPPORT_MONITOR
			#ifdef SUPPORT_SMODE_UNMUTE
			AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_USERINFO, 0,
			sizeof(APP_SETTING_UserInfo_t), &(g_stUserInfoData));
			if(g_stUserInfoData.Mute)
			{
			   if (CECTV_GetHDMISystemAudioMode()&& APP_Check_CEC_DEVICE_Status())
		            {
					cec_RemoteControlPassThrough(CECTV_KEY_MUTE);
				    	cec_RemoteControlPassThrough(CECTV_KEY_MUTE_RELEASE);
		            }
			}
			_APP_GUIOBJ_Sound_SetMuteStatus();
			#endif
#ifdef CONFIG_ATV_SUPPORT			
            if (APP_GUIOBJ_ATV_Playback_GetProgramState() && eSourType == APP_SOURCE_ATV)
            {
                break;
            }
#endif
            if (g_u8SignalState != ATV_AVAILABLE_SIGNAL)
            {
                break;
            }

            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;
            }
            _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);
#endif
            break;


        case UI_EVENT_ASPECT:
#ifdef CONFIG_ATV_SUPPORT
            if (APP_GUIOBJ_ATV_Playback_GetProgramState() && eSourType == APP_SOURCE_ATV)
            {
                break;
            }
#endif
            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)
            {
                _ATVAPP_ShowPopup(ATV_APP_POP_MSG_NOT_AVAILABLE);
                break;
            }
#ifndef CONFIG_SUPPORT_MONITOR
            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);
            }

#endif
        case UI_EVENT_SLEEP:
#ifndef CONFIG_SUPPORT_MONITOR
            _ATVApp_CloseAllMenu();
            if (ATVApp_IsPopupExist(PLAYBACK_POPUP_MSG_NO_SIGNAL))
            {
                ATVApp_ClosePopup(PLAYBACK_POPUP_MSG_NO_SIGNAL, UI_EVENT_NULL);
            }
            if (ATVApp_IsPopupExist(PLAYBACK_POPUP_MSG_NOT_SUPPORT_MODE))
			{
			    ATVApp_ClosePopup(PLAYBACK_POPUP_MSG_NOT_SUPPORT_MODE, UI_EVENT_NULL);
			}
            SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, APP_GUIOBJ_BANNER, dMessage);
#endif
            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:
				_ATVApp_CloseAllMenu();
				if(!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV,APP_GUIOBJ_MAINMENU))
				{
					printf("create APP_GUIOBJ_MONITOR_MAINMENU==========\n");
					SYSAPP_GOBJ_CreateGUIObject_WithPara(
								SYS_APP_ATV, APP_GUIOBJ_MAINMENU, 0);
				}	
				break;
        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:
#ifndef CONFIG_SUPPORT_MONITOR
#ifdef SUPPORT_FACTORY_AUTO_TEST
			if(dMessage == UI_EVENT_10)
			{
				if(APP_Factory_GetAutoTestOnOff() == TRUE)
				{
					APP_Factory_SetAutoTestSourceChange(dMessage);
					break;
				}
			}
#endif

#ifdef NOT_SUPPORT_NUMBER_KEY_CHANGESOURCETOTV
            if(eSourType != APP_SOURCE_ATV)
			{
				if (!APP_MenuMgr_Exist_Main_Menu() && !APP_MenuMgr_Exist_Factory_Menu())
                {
                   if (!ATVApp_IsPopupExist(ATV_APP_POP_MSG_NOT_AVAILABLE))
                    {
				        _ATVAPP_ShowPopup(ATV_APP_POP_MSG_NOT_AVAILABLE);
                    }
                }
				break;
			}
#endif

            if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_PROGNUM))
            {
                if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_INPUTINFO))
                {
                    SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_INPUTINFO);
                }
                if (ATVApp_IsPopupExist(PLAYBACK_POPUP_MSG_NO_SIGNAL))
                {
                    ATVApp_ClosePopup(PLAYBACK_POPUP_MSG_NO_SIGNAL, UI_EVENT_NULL);
                }
                if ((!ATVApp_IsPopupExist(PLAYBACK_POPUP_MSG_NO_SIGNAL)) &&
                    (!ATVApp_IsPopupExist(PLAYBACK_POPUP_PWD_LOCKED)))
                {
                    _ATVApp_CloseAllMenu();
                }
                SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, ATV_GUIOBJ_PROGNUM, (dMessage - UI_EVENT_0));
            }
#endif
            break;

        case UI_EVENT_FREEZE:
        {
#ifndef CONFIG_SUPPORT_MONITOR
#ifdef CONFIG_ATV_SUPPORT
            if (APP_GUIOBJ_ATV_Playback_GetProgramState() && eSourType == APP_SOURCE_ATV)
            {
                break;
            }
#endif
            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)
                    {
                        _ATVAPP_ShowPopup(ATV_APP_POP_MSG_NOT_AVAILABLE);
                        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);
                }
            }
#endif
        }
        break;

        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
#ifndef CONFIG_SUPPORT_MONITOR
            _ATVAPP_ShowPopup(ATV_APP_POP_MSG_NOT_AVAILABLE);
#endif
#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 SUPPORT_SOURCE_DVBTCS
		case UI_EVENT_DVBC:// For DVB-C shortcut key
		case UI_EVENT_RED:
			#ifdef CONFIG_DVB_SYSTEM_DVBC_SUPPORT
			_ATVApp_CloseAllMenu();
			_ATVApp_ResetPopup_Channel();
			APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_DTV);
			AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_CHANNEL, 0,
				sizeof(APP_SETTING_Channel_t), &(g_stChannelData));
			RFtype = g_stChannelData.TV_Connection;
			if(RFtype != APP_RF_TYPE_DVB_C)
			{
				APP_GUIOBJ_Source_GetCurrSource(&eSourType);
				if((eSourType == APP_SOURCE_DTV)||((eSourType == APP_SOURCE_RADIO)))
				{
					StringId = APP_GUIOBJ_Channel_GetStringIDByRFType(APP_RF_TYPE_DVB_C);
					APP_GUIOBJ_Channel_SetRFTypeByStringID(StringId);
				}
			}
			#else
            _ATVAPP_ShowPopup(ATV_APP_POP_MSG_NOT_AVAILABLE);
			#endif
			break;
		case UI_EVENT_DVBS:// For DVB-S shortcut key
		case UI_EVENT_GREEN:
			#ifdef CONFIG_DVB_SYSTEM_DVBS_SUPPORT
			_ATVApp_CloseAllMenu();
			_ATVApp_ResetPopup_Channel();
			APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_DTV);
			AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_CHANNEL, 0,
				sizeof(APP_SETTING_Channel_t), &(g_stChannelData));
			RFtype = g_stChannelData.TV_Connection;
			if(RFtype != APP_RF_TYPE_DVB_S)
			{
				APP_GUIOBJ_Source_GetCurrSource(&eSourType);
				if((eSourType == APP_SOURCE_DTV)||((eSourType == APP_SOURCE_RADIO)))
				{
					StringId = APP_GUIOBJ_Channel_GetStringIDByRFType(APP_RF_TYPE_DVB_S);
					APP_GUIOBJ_Channel_SetRFTypeByStringID(StringId);
				}
			}
			#else
            _ATVAPP_ShowPopup(ATV_APP_POP_MSG_NOT_AVAILABLE);
			#endif
			break;
#endif

        case APP_GLOBAL_EVENT_POPMSG_YES:
#ifndef CONFIG_SUPPORT_MONITOR
#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
#endif
#ifdef N32_GAME_SUPPORT
			if (dParam == POPMSG_CONFIRM_START_GAME_UPGRADE)
			{
				atv_printf("\n!!!start ugrade game\n");
				_ATVAPP_ShowPopup(ATV_APP_POP_MSG_IMPORTING_GAME);
				APP_Clone_Revert_BinFile_to_System(UPGRADE_GAME_BIN_ID);
			}
#endif
#ifdef CONFIG_SUPPORT_PVR
            if (POPMSG_CONFIRM_REC_REMIDER_TIME == dParam)
            {
				SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_ATV,
						(APP_GLOBAL_EVENT_PVRREC_CHANGESOURCE | PASS_TO_SYSAPP), 0);
            }
            if (POPMSG_CONFIRM_REC_REMIDER_TIME_CONFIRM == dParam)
            {
                APP_WAKEUP_Recorder_ResetTimeout();
                DVBApp_PVRRec_SetTimerCancle();
            }
            if (POPMSG_CONFIRM_INVALID_USB == dParam)
            {
				MAINAPP_SendGlobalEvent(UI_EVENT_POWER, AL_POWER_STATE_OFF);
            }
#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)
            {
            #ifndef CONFIG_SUPPORT_MONITOR
                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
            }
#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:
#ifdef CONFIG_SUPPORT_PVR
			if (dParam == POPMSG_CONFIRM_REC_REMIDER_TIME)
			{
				APP_WAKEUP_Recorder_ResetTimeout();
				DVBApp_PVRRec_SetTimerCancle();
				//SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_ATV,
						//(APP_GLOBAL_EVENT_PVR_REMINDER_CONFIRM | PASS_TO_SYSAPP), 0);
			}
            if (dParam == POPMSG_CONFIRM_REC_REMIDER_TIME_CONFIRM)
            {
                al_uint32 CurTimeInSec = 0;
                UINT32 RECStartTime = 0;
                AL_Time_GetCurTimeInSecs(&CurTimeInSec);
                RECStartTime = DVBApp_GetTimerRECStartTime();
                if (RECStartTime > CurTimeInSec)
                {
                    _ATVAPP_ShowPopup(ATV_APP_POP_MSG_PVR_REMIDER);
                }
            }
            if (POPMSG_CONFIRM_INSERT_USB == dParam)
            {
				MAINAPP_SendGlobalEvent(UI_EVENT_POWER, AL_POWER_STATE_OFF);
            }
#endif
            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:
#ifdef CONFIG_SUPPORT_PVR
			if (dParam == POPMSG_CONFIRM_REC_REMIDER_TIME)
			{
				APP_WAKEUP_Recorder_ResetTimeout();
				DVBApp_PVRRec_SetTimerCancle();
				//SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_ATV,
						//(APP_GLOBAL_EVENT_PVR_REMINDER_CONFIRM | PASS_TO_SYSAPP), 0);
			}
#endif
            break;
     case APP_ATV_GLOBAL_EVENT_SIF_SAS_OK:
		#ifdef CONFIG_ATV_SUPPORT
		g_u8SIF_SCS_OK = FALSE;
		#endif
		break;
	 case APP_ATV_GLOBAL_EVENT_SIF_SCS_OK:
	 	#ifdef CONFIG_ATV_SUPPORT
	 	g_u8SIF_SCS_OK = TRUE;
		g_u8SIF_SCS_OK_HasCheck = TRUE;
		#ifdef CONFIG_ISDB_SYSTEM
		if (!(g_stSetupData.BlueScreen == APP_SWITCH_ON && g_u8SignalState != ATV_AVAILABLE_SIGNAL))
		{
			APP_Video_SetMute(FALSE, TRUE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
		}
		#endif
#ifdef SUPPORT_CLOSE_NICAM
		if (!APP_IsScan_Running())
		{
			memset(&GET_SIFinfo,0,sizeof(TVFE_AudioFrontEndStatus_t));
			TVFE_Audio_GetSIFInfo(&GET_SIFinfo);
			APP_ATV_Playback_SetMTS(GET_SIFinfo.eAvaiMode,FALSE,TRUE);
		}
#endif
		printf("g_u8SIF_SCS_OK\n");
		#endif
	 	break;
        case APP_ATV_GLOBAL_EVENT_SIGNAL_PRESENT:
			{
				atv_printf("APP_ATV_GLOBAL_EVENT_SIGNAL_PRESENT event is received.\n\n");
				#ifdef CONFIG_ATV_SUPPORT
				APP_GUIOBJ_ATV_Playback_SetZappingState(FALSE);
				#endif
				g_u8ZappingTimer = 0;
				/*set signal state*/
				/*have available signal*/
				g_u8SignalState = ATV_AVAILABLE_SIGNAL;
				#ifdef CONFIG_SUPPORT_NOSIGNAL_AUTO_CHANGE_SOURCE
				ATVApp_Reset_SwitchSourceToCheckSignal_Flag();
				#endif
				#ifndef CONFIG_SUPPORT_MONITOR
				Boolean PauseStatus = FALSE;
               	MID_DISP_DTVGetPause(&PauseStatus);
				if (PauseStatus)
				{
				    SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_FREEZE);
				    MID_DISP_DTVSetPause(FALSE);
				}
				#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

#ifdef CONFIG_SUPPORT_3D_EN
			UINT32 value = TV_IDS_String_On;
			 _APP_GUIOBJ_3DMenu_GetForce2DAnother(&value);

			DISP_3D_ModeChange_Status_t e3DModeChangeSt = DISP_3D_STATUS_RESET;
			UINT32 u32Mode = 0;
			MID_DISP_DTVGet3DModeChangeSt(&e3DModeChangeSt);
			if (DISP_3D_STATUS_RESET == e3DModeChangeSt)
			{
				if(bSet3DMode == TRUE)
				{
					bSet3DMode = FALSE;
				}
				else
				if (bSet3DMode == FALSE)
				{
					APP_GUIOBJ_3DMenu_SetMode(TV_IDS_String_3DMODE_OFF);
				}
			}
			else if (DISP_3D_STATUS_ALWAYS_ON == e3DModeChangeSt)
			{
				APP_GUIOBJ_3DMenu_SetMode(TV_IDS_String_3DMODE_OFF);
			}
			else if (DISP_3D_STATUS_ALWAYS_ON == e3DModeChangeSt)
			{
				APP_GUIOBJ_3DMenu_GetMode(&u32Mode);
				if(value == TV_IDS_String_On)
				{
					APP_GUIOBJ_3DMenu_SetModeNoOutPutStructure(u32Mode);
					_APP_GUIOBJ_3DMenu_SetForce2DAnother(TV_IDS_String_On);
				}
				else
				{
					APP_GUIOBJ_3DMenu_SetMode(u32Mode);
				}
			}
			else if(DISP_3D_STATUS_ONLY_2D3D_ALWAYS_ON == e3DModeChangeSt)
			{
				APP_GUIOBJ_3DMenu_GetMode(&u32Mode);

				if(value == TV_IDS_String_On)
				{
					if(u32Mode == TV_IDS_String_3DMODE_2D23D)
					{
						//set 3D mode to Off
						APP_GUIOBJ_3DMenu_SetModeNoOutPutStructure(u32Mode);
						_APP_GUIOBJ_3DMenu_SetForce2DAnother(TV_IDS_String_On);
					}
					else
					{
						APP_GUIOBJ_3DMenu_SetMode(u32Mode);
					}
				}
				else if(DISP_3D_STATUS_ONLY_2D3D_ALWAYS_ON == e3DModeChangeSt)
				{
					APP_GUIOBJ_3DMenu_GetMode(&u32Mode);

					if(value == TV_IDS_String_On)
					{
						if(u32Mode == TV_IDS_String_3DMODE_2D23D)
						{
							APP_GUIOBJ_3DMenu_SetModeNoOutPutStructure(u32Mode);
							_APP_GUIOBJ_3DMenu_SetForce2DAnother(TV_IDS_String_On);
						}
						else
						{
							if(bSet3DMode == TRUE)
							{
								bSet3DMode = FALSE;
							}
							else
							{
								APP_GUIOBJ_3DMenu_SetMode(TV_IDS_String_3DMODE_OFF);
							}
						}
					}
					else if(u32Mode == TV_IDS_String_3DMODE_2D23D)//Force 2D is off
					{
						APP_GUIOBJ_3DMenu_SetMode(TV_IDS_String_3DMODE_2D23D);
					}
					else //if(u32Mode == TV_IDS_String_3DMODE_2D23D)
					{
						if(bSet3DMode == TRUE)
						{
							bSet3DMode = FALSE;
						}
						else
						{
							APP_GUIOBJ_3DMenu_SetMode(TV_IDS_String_3DMODE_OFF);
						}
					}
				}
		}
#endif
				/*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);
				}
				#ifdef CONFIG_ATV_SUPPORT
				if (!APP_IsScan_Running())
				#endif
				{
					_ATVApp_SetMuteProcess(FALSE);
				}
#ifdef CONFIG_ATV_SUPPORT
				/*undate or open input info*/
				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))
					{
						if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_TTXCLOCK))
						{
							SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_TTXCLOCK);
						}
						#ifdef CONFIG_ISDB_SYSTEM
						if(eSourType != APP_SOURCE_ATV)
						#endif
						{
						SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, ATV_GUIOBJ_INPUTINFO, 0);
						}
					}
				}
#endif
				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;
				}
			#ifdef CONFIG_ATV_SUPPORT
                if (!APP_IsScan_Running())
			#endif
                {
                    /*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 (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
					#ifdef CONFIG_ATV_SUPPORT
					if ((eSourType == APP_SOURCE_ATV) && (APP_GUIOBJ_ATV_Playback_GetProgramState()))
					{
						 APP_Audio_SetMute(TRUE, FALSE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
						if (g_stSetupData.BlueScreen == APP_SWITCH_ON)
						{
						    APP_SCARTOUT_SetVideoMute(APP_SOURCE_ATV, TRUE, TRUE);
						    MID_DISP_DTVSetVideoMute(0,0,255);
						}
						else
						{
						    APP_Video_SetMute(TRUE, FALSE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
						}
						APP_ATV_Playback_SetFirstPlay(TRUE);
						SYSAPP_IF_SendGlobalEventWithIndex(
							SYS_APP_ATV, APP_GLOBAL_EVENT_OPEN_POPUP, ATV_APP_POP_MSG_CHECKPWD);
						return 0;
					}
					#endif
					#ifdef CONFIG_ISDB_SYSTEM
					if (eSourType != APP_SOURCE_ATV || (eSourType == APP_SOURCE_ATV && g_u8SIF_SCS_OK_HasCheck == TRUE))
					#endif
			      	APP_Video_SetMute(FALSE, TRUE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);

				}
			}
            break;
        case APP_ATV_GLOBAL_EVENT_VIP_FINISH:
			bSetVIPFINISHFlag = TRUE;
			atv_printf("APP_ATV_GLOBAL_EVENT_VIP_FINISH event is received.  g_u8SignalState ======= %d\n\n",g_u8SignalState);

			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);
			}
			#ifndef CONFIG_SUPPORT_MONITOR
			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);
			}
			#endif
			if (g_u8SignalState == ATV_AVAILABLE_SIGNAL)
			{
				#ifdef CONFIG_ATV_SUPPORT
				if ((eSourType == APP_SOURCE_ATV) && (APP_GUIOBJ_ATV_Playback_GetProgramState()))
				{
					break;
				}
				#endif
				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);
				}
		#ifdef CONFIG_ATV_SUPPORT
                else
                {
                	if(eSourType == APP_SOURCE_ATV)
	                {
#if defined( CONFIG_ISDB_SYSTEM) || defined(SUPPORT_CLOSE_NICAM)
						#ifdef CONFIG_ISDB_SYSTEM
						if(IsAlreadyFirstSetMTS == TRUE)
						#endif	
						{
							APP_Audio_SetMute(g_stUserInfoData.Mute, TRUE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
							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);
							}
						}
#endif
					}
					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);
	                    }
					}
                }
		#endif
#ifdef CONFIG_CC_SUPPORT
				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)
				{
					if(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_CC))
					{
						SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_ATV,
							ATV_GUIOBJ_CC, APP_GLOBAL_EVENT_CC_RESTART, 0);
					}
					else
					{
						SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, ATV_GUIOBJ_CC, 0);
					}
				}
#endif
			}
			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)
			{
				/*set PQ param*/
				// 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 );

				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));
				APP_Video_SetPictureMode(
				    g_stPictureData.stPictureModeSourceTab[eStorageSourType].PictureModeIndex);
				//APP_Video_OSD_PQSet(APP_VIDEO_OSD_ITEM_BACKLIGHT, g_stPictureData.PictureMode[eSourType].stUserTab.Backlight);
				APP_Video_OSD_PQSet(APP_VIDEO_OSD_ITEM_COLORTEMP, g_stPictureData.stPictureModeSourceTab[eStorageSourType].ColorTempIndex);
				APP_Video_OSD_PQSet(APP_VIDEO_OSD_ITEM_NR, g_stPictureData.NR);
				if ((eSourType == APP_SOURCE_HDMI)||(eSourType == APP_SOURCE_HDMI2)||(eSourType == APP_SOURCE_HDMI1))
				{
					MID_DISP_DTVSetHdmiRGBRange(g_stFactoryUserData.PictureMode.VIP.n_PicMode_VIP_HDMI_RGB_Range);
					break;
				}
				#ifdef CONFIG_ATV_SUPPORT
				if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_INPUTINFO))
				{
					#ifdef CONFIG_ISDB_SYSTEM
					if (eSourType != APP_SOURCE_ATV)
					#else
					if(eSourType != APP_SOURCE_ATV
						#ifdef CONFIG_ATV_SUPPORT
						|| (eSourType == APP_SOURCE_ATV && APP_GUIOBJ_ATV_Playback_GetProgramState() != TRUE )
						#endif
						)
					#endif	
					{            
					    SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_ATV, APP_ATV_GLOBAL_EVENT_INFO_UPDATE, 0);
					}
				}
				
                		else
				{
					INT32 dFocusedIndex;
					/* No focused Guiobj exist */
					if (SYSTEM_APP_NO_FOCUSED_GUIOBJ == SYSAPP_GOBJ_GetFocusedGUIObject(SYS_APP_ATV, &dFocusedIndex))
					{
						if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_TTXCLOCK))
						{
							SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_TTXCLOCK);
						}
						#ifdef CONFIG_ISDB_SYSTEM
						if(eSourType != APP_SOURCE_ATV)
						#endif
						{
							SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, ATV_GUIOBJ_INPUTINFO, 0);
						}
					}
				}
				#endif
				if (eSourType == APP_SOURCE_PC)
				{
#if(defined(SUPPORT_FACTORY_AUTO_TEST)||defined(SUPPORT_FACTORY_AUTO_TEST_MODE2))
					if(APP_Factory_GetAutoTestOnOff() == FALSE)
#endif
					{
#ifndef CONFIG_SUPPORT_MONITOR
						APP_GUIOBJ_ATV_PCSetup_ResetPCSetupData();
#endif
						ATVApp_PCAutoTune(FALSE); //Don't show "Adjusting , Please wait..." UI message, because AutoTune calibration has done before video unmute
					}
					/*update pc setup menu*/
#ifdef CONFIG_ATV_SUPPORT
					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);
					}
#endif
				}
			}
			break;
        case APP_ATV_GLOBAL_EVENT_SIGNAL_IN_PROGRESS:
			{
				#ifdef CONFIG_ATV_SUPPORT
				APP_GUIOBJ_ATV_Playback_SetZappingState(FALSE);
				#endif
				g_u8ZappingTimer = 0;
				UINT32 dActiveSysApp = TOTAL_SYS_APP_SIZE;
				if (MAINAPP_GetActiveSystemAppIndex(&dActiveSysApp) == MAIN_APP_SUCCESS)
	            {
	                atv_printf(" APP_ATV_GLOBAL_EVENT_SIGNAL_IN_PROGRESS event received.\n\n");
                    /*reset vchip lock flag*/
#ifdef CONFIG_VCHIP_SUPPORT
                    VchipLockFlag = FALSE;
                    PreVchipLockFlag = FALSE;
#endif
	                /*set signal state*/
	                /*have no signal*/
	                g_u8SignalState = ATV_SIGNAL_IN_PROGRESS;
#ifdef CONFIG_SCART_SUPPORT
                    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);
                        }
                    }
#endif
#ifdef CONFIG_ATV_SUPPORT
			        IsAlreadyFirstSetMTS = FALSE;
		            APP_Audio_SetATVSIFAvailableMode(TVFE_AUDIO_SIF_AVAIL_ERROR);
#endif
#ifdef CONFIG_WSS_SUPPORT
					APP_Video_SetWssEn(FALSE);
#endif
#ifdef CONFIG_ATV_SUPPORT
	                /*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, ATV_GUIOBJ_SIF))
	                {
	                    SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_ATV, ATV_GUIOBJ_SIF, APP_ATV_GLOBAL_EVENT_NO_SIGNAL, 0);
	                }
#endif
	                /*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);
	                }
					#ifdef CONFIG_ISDB_SYSTEM		
					if (ATVApp_IsPopupExist(PLAYBACK_POPUP_PWD_LOCKED))
	                {
	                    ATVApp_ClosePopup(PLAYBACK_POPUP_PWD_LOCKED, UI_EVENT_NULL);
	                }
					#endif
	                /* 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);
	                }
#ifdef CONFIG_MOD_PACK_TT
                    if (umf_checkModuleLoaded(UMFMOD_TT) == 1)
                    {
					    AL_TTX_Reset();
                    }
#endif
#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

#ifdef CONFIG_SUPPORT_3D_EN
				APP_StorageSource_Type_t eStorageSourTypeT = APP_STORAGE_SOURCE_MAX;
				eStorageSourTypeT = APP_Data_UserSetting_SourceTypeMappingToStorage(eSourType);
				UINT32 value = TV_IDS_String_On;
				 _APP_GUIOBJ_3DMenu_GetForce2DAnother(&value);

				DISP_3D_ModeChange_Status_t e3DModeChangeSt = DISP_3D_STATUS_RESET;
				UINT32 u32Mode = 0;
				MID_DISP_DTVGet3DModeChangeSt(&e3DModeChangeSt);
				if (DISP_3D_STATUS_RESET == e3DModeChangeSt)
				{
					APP_GUIOBJ_3DMenu_GetMode(&u32Mode);

					if(bSet3DMode == TRUE)
					{
						bSet3DMode = FALSE;
					}
					else
					{
						switch(u32Mode)
						{
							case TV_IDS_String_3DMODE_OFF:
							case TV_IDS_String_3DMODE_AUTO:
							case TV_IDS_String_3DMODE_2D23D:
							case TV_IDS_String_3DMODE_SBS3D:
							case TV_IDS_String_3DMODE_SBSH3D:
							case TV_IDS_String_3DMODE_TAB3D:
							case TV_IDS_String_3DMODE_FP3D:
								u32Mode = SPAL_PQ_3DMODE_OFF;
								break;
							default:
								u32Mode = SPAL_PQ_3DMODE_OFF;
								break;
						}
						//APP_GUIOBJ_3DMenu_SetMode(u32Mode);
						AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_PICTURE, 0,
										sizeof(APP_SETTING_Picture_t), &(g_stPictureData));
						g_stPictureData.stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Mode3D = u32Mode;
						AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_PICTURE,
							ITEM_OFFSET(APP_SETTING_Picture_t, stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Mode3D),
							sizeof(g_stPictureData.stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Mode3D),
							&(g_stPictureData.stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Mode3D));

						AL_Setting_Store(APP_Data_UserSetting_Handle(), SYS_SET_ID_PICTURE,
							ITEM_OFFSET(APP_SETTING_Picture_t, stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Mode3D),
							sizeof(g_stPictureData.stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Mode3D));
						}
				}
				else if (DISP_3D_STATUS_ALWAYS_ON == e3DModeChangeSt)
				{
					APP_GUIOBJ_3DMenu_GetMode(&u32Mode);
					if(value == TV_IDS_String_On)
					{
						//set 3D mode to Off
						AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_PICTURE, 0,
										sizeof(APP_SETTING_Picture_t), &(g_stPictureData));
						g_stPictureData.stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Force2D= SPAL_PQ_3DForce2D_ON;
						AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_PICTURE,
							ITEM_OFFSET(APP_SETTING_Picture_t, stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Force2D),
							sizeof(g_stPictureData.stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Force2D),
							&(g_stPictureData.stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Force2D));

							AL_Setting_Store(APP_Data_UserSetting_Handle(), SYS_SET_ID_PICTURE,
								ITEM_OFFSET(APP_SETTING_Picture_t, stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Force2D),
								sizeof(g_stPictureData.stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Force2D));

					}
					else
					{
						switch(u32Mode)
						{
							case TV_IDS_String_3DMODE_OFF:
								u32Mode = SPAL_PQ_3DMODE_OFF;
								break;

							case TV_IDS_String_3DMODE_AUTO:
								u32Mode = SPAL_PQ_3DMODE_ATUO;
								break;

							case TV_IDS_String_3DMODE_2D23D:
								u32Mode = SPAL_PQ_3DMODE_2D3D;
								break;

							case TV_IDS_String_3DMODE_SBS3D:
								u32Mode = SPAL_PQ_3DMODE_SBS3D;
								break;

							case TV_IDS_String_3DMODE_TAB3D:
								u32Mode = SPAL_PQ_3DMODE_TAB3D;
								break;

							case TV_IDS_String_3DMODE_FP3D:
								u32Mode = SPAL_PQ_3DMODE_FP3D;
								break;
							default:
								u32Mode = SPAL_PQ_3DMODE_ATUO;
								break;
						}

						//APP_GUIOBJ_3DMenu_SetMode(u32Mode);
						AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_PICTURE, 0,
										sizeof(APP_SETTING_Picture_t), &(g_stPictureData));
						g_stPictureData.stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Mode3D = u32Mode;
						AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_PICTURE,
							ITEM_OFFSET(APP_SETTING_Picture_t, stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Mode3D),
							sizeof(g_stPictureData.stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Mode3D),
							&(g_stPictureData.stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Mode3D));

							AL_Setting_Store(APP_Data_UserSetting_Handle(), SYS_SET_ID_PICTURE,
								ITEM_OFFSET(APP_SETTING_Picture_t, stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Mode3D),
								sizeof(g_stPictureData.stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Mode3D));

					}
				}
				else if(DISP_3D_STATUS_ONLY_2D3D_ALWAYS_ON == e3DModeChangeSt)
				{
					APP_GUIOBJ_3DMenu_GetMode(&u32Mode);
					if(bSet3DMode == TRUE)
					{
						bSet3DMode = FALSE;
					}
					else if(value == TV_IDS_String_On)
					{
						//set 3D mode to Off
						//_APP_GUIOBJ_3DMenu_SetForce2DAnother(TV_IDS_String_On);
						AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_PICTURE, 0,
										sizeof(APP_SETTING_Picture_t), &(g_stPictureData));
						g_stPictureData.stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Force2D= SPAL_PQ_3DForce2D_ON;
						AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_PICTURE,
							ITEM_OFFSET(APP_SETTING_Picture_t, stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Force2D),
							sizeof(g_stPictureData.stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Force2D),
							&(g_stPictureData.stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Force2D));

							AL_Setting_Store(APP_Data_UserSetting_Handle(), SYS_SET_ID_PICTURE,
								ITEM_OFFSET(APP_SETTING_Picture_t, stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Force2D),
								sizeof(g_stPictureData.stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Force2D));
					}
					else if(u32Mode != TV_IDS_String_3DMODE_2D23D)
					{
						//APP_GUIOBJ_3DMenu_SetMode(TV_IDS_String_3DMODE_OFF);
						AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_PICTURE, 0,
										sizeof(APP_SETTING_Picture_t), &(g_stPictureData));
						g_stPictureData.stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Mode3D = SPAL_PQ_3DMODE_OFF;
						AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_PICTURE,
							ITEM_OFFSET(APP_SETTING_Picture_t, stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Mode3D),
							sizeof(g_stPictureData.stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Mode3D),
							&(g_stPictureData.stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Mode3D));

							AL_Setting_Store(APP_Data_UserSetting_Handle(), SYS_SET_ID_PICTURE,
								ITEM_OFFSET(APP_SETTING_Picture_t, stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Mode3D),
								sizeof(g_stPictureData.stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Mode3D));
					}
					else
					{
						AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_PICTURE, 0,
										sizeof(APP_SETTING_Picture_t), &(g_stPictureData));
						g_stPictureData.stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Mode3D = SPAL_PQ_3DMODE_2D3D;
						AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_PICTURE,
							ITEM_OFFSET(APP_SETTING_Picture_t, stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Mode3D),
							sizeof(g_stPictureData.stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Mode3D),
							&(g_stPictureData.stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Mode3D));

							AL_Setting_Store(APP_Data_UserSetting_Handle(), SYS_SET_ID_PICTURE,
								ITEM_OFFSET(APP_SETTING_Picture_t, stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Mode3D),
								sizeof(g_stPictureData.stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Mode3D));
					}
				}
#endif
#ifndef CONFIG_SUPPORT_MONITOR
				 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);
				 }
#endif
				 #ifdef CONFIG_ATV_SUPPORT
				 if (eSourType == APP_SOURCE_ATV)
				 {
					 if (!APP_IsScan_Running())
					 {
						 AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_SETUP, 0,
									 sizeof(APP_SETTING_Setup_t), &(g_stSetupData));
						 u32BlueBackvalue = g_stSetupData.BlueScreen;

						 if (u32BlueBackvalue == APP_SWITCH_ON)
						 {
							 if((!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_SCAN_PROCESS))
								 && (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_AMS_SEARCH))
								 && (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_AMS_FINE_TUNE))
								 )
							 {
							     MID_DISP_DTVSetDispAspect(DISP_ASPECT_RATIO_FULL, TRUE);
								 _ATVApp_SetMuteProcess(TRUE);
							 }
							 else
							 {
							     MID_DISP_DTVSetDispAspect(DISP_ASPECT_RATIO_FULL, TRUE);
								 _ATVApp_SetMuteProcess(FALSE);
							 }
						 }
						 else
						 {
						     MID_DISP_DTVSetDispAspect(DISP_ASPECT_RATIO_FULL, TRUE);
							 _ATVApp_SetMuteProcess(TRUE);
						 }
						 #ifdef CONFIG_ISDB_SYSTEM
						 INT32 dFocusedIndex;
						/* No focused Guiobj exist */
					    if (SYSTEM_APP_NO_FOCUSED_GUIOBJ == SYSAPP_GOBJ_GetFocusedGUIObject(SYS_APP_ATV, &dFocusedIndex))
					    {
							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);
							}
					    }
						#endif
					 }
				 }
				 else
				 #endif
				 {
					 _ATVApp_SetMuteProcess(TRUE);
				 }
				if (bSetUnMuteFlag == TRUE)
				{
					bSetUnMuteFlag = FALSE;
					ATVApp_CheckProgramType(FALSE);
				}
			 	}
        	}
            break;
        case APP_ATV_GLOBAL_EVENT_NO_SIGNAL:
			{
				#ifdef CONFIG_ATV_SUPPORT
				APP_GUIOBJ_ATV_Playback_SetZappingState(FALSE);
				#endif
				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");
                    /*reset vchip lock flag*/
#ifdef CONFIG_VCHIP_SUPPORT
                    VchipLockFlag = FALSE;
                    PreVchipLockFlag = FALSE;
#endif
	                /*set signal state*/
	                /*have no signal*/
#ifdef CONFIG_SUPPORT_NOSIGNAL_AUTO_CHANGE_SOURCE
                    if(g_stSetupData.MenuSourceType == APP_MENUSOURCETYPE_AUTO)
                    {
                        if(g_CheckSignal == FALSE && g_u8SignalState !=ATV_NO_SIGNAL)
                        {
                            g_CheckSignal_Times = 0;
                        }
                    }
#endif
	                g_u8SignalState = ATV_NO_SIGNAL;

#ifdef CONFIG_SCART_SUPPORT
                    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);
                        }
                    }
#endif
#ifdef CONFIG_ATV_SUPPORT
			        IsAlreadyFirstSetMTS = FALSE;
		            APP_Audio_SetATVSIFAvailableMode(TVFE_AUDIO_SIF_AVAIL_ERROR);
#endif
#ifdef CONFIG_WSS_SUPPORT
					APP_Video_SetWssEn(FALSE);
#endif
#ifdef CONFIG_ATV_SUPPORT
	                /*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, ATV_GUIOBJ_SIF))
	                {
	                    SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_ATV, ATV_GUIOBJ_SIF, APP_ATV_GLOBAL_EVENT_NO_SIGNAL, 0);
	                }
#endif
	                /*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);
	                }
					#ifdef CONFIG_ISDB_SYSTEM		
					if (ATVApp_IsPopupExist(PLAYBACK_POPUP_PWD_LOCKED))
	                {
	                    ATVApp_ClosePopup(PLAYBACK_POPUP_PWD_LOCKED, UI_EVENT_NULL);
	                }
					#endif
	                /* 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);
	                }
#ifdef CONFIG_MOD_PACK_TT
                    if (umf_checkModuleLoaded(UMFMOD_TT) == 1)
                    {
					    AL_TTX_Reset();
                    }
#endif
#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

#ifdef CONFIG_SUPPORT_3D_EN
				APP_StorageSource_Type_t eStorageSourTypeT = APP_STORAGE_SOURCE_MAX;
				eStorageSourTypeT = APP_Data_UserSetting_SourceTypeMappingToStorage(eSourType);
				UINT32 value = TV_IDS_String_On;
				 _APP_GUIOBJ_3DMenu_GetForce2DAnother(&value);

				DISP_3D_ModeChange_Status_t e3DModeChangeSt = DISP_3D_STATUS_RESET;
				UINT32 u32Mode = 0;
				MID_DISP_DTVGet3DModeChangeSt(&e3DModeChangeSt);
				if (DISP_3D_STATUS_RESET == e3DModeChangeSt)
				{
					APP_GUIOBJ_3DMenu_GetMode(&u32Mode);

					if(bSet3DMode == TRUE)
					{
						bSet3DMode = FALSE;
					}
					else
					{
						switch(u32Mode)
						{
							case TV_IDS_String_3DMODE_OFF:
							case TV_IDS_String_3DMODE_AUTO:
							case TV_IDS_String_3DMODE_2D23D:
							case TV_IDS_String_3DMODE_SBS3D:
							case TV_IDS_String_3DMODE_SBSH3D:
							case TV_IDS_String_3DMODE_TAB3D:
							case TV_IDS_String_3DMODE_FP3D:
								u32Mode = SPAL_PQ_3DMODE_OFF;
								break;
							default:
								u32Mode = SPAL_PQ_3DMODE_OFF;
								break;
						}
						//APP_GUIOBJ_3DMenu_SetMode(u32Mode);
						AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_PICTURE, 0,
										sizeof(APP_SETTING_Picture_t), &(g_stPictureData));
						g_stPictureData.stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Mode3D = u32Mode;
						AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_PICTURE,
							ITEM_OFFSET(APP_SETTING_Picture_t, stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Mode3D),
							sizeof(g_stPictureData.stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Mode3D),
							&(g_stPictureData.stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Mode3D));

						AL_Setting_Store(APP_Data_UserSetting_Handle(), SYS_SET_ID_PICTURE,
							ITEM_OFFSET(APP_SETTING_Picture_t, stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Mode3D),
							sizeof(g_stPictureData.stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Mode3D));
						}
				}
				else if (DISP_3D_STATUS_ALWAYS_ON == e3DModeChangeSt)
				{
					APP_GUIOBJ_3DMenu_GetMode(&u32Mode);
					if(value == TV_IDS_String_On)
					{
						//set 3D mode to Off
						AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_PICTURE, 0,
										sizeof(APP_SETTING_Picture_t), &(g_stPictureData));
						g_stPictureData.stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Force2D= SPAL_PQ_3DForce2D_ON;
						AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_PICTURE,
							ITEM_OFFSET(APP_SETTING_Picture_t, stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Force2D),
							sizeof(g_stPictureData.stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Force2D),
							&(g_stPictureData.stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Force2D));

							AL_Setting_Store(APP_Data_UserSetting_Handle(), SYS_SET_ID_PICTURE,
								ITEM_OFFSET(APP_SETTING_Picture_t, stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Force2D),
								sizeof(g_stPictureData.stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Force2D));

					}
					else
					{
						switch(u32Mode)
						{
							case TV_IDS_String_3DMODE_OFF:
								u32Mode = SPAL_PQ_3DMODE_OFF;
								break;

							case TV_IDS_String_3DMODE_AUTO:
								u32Mode = SPAL_PQ_3DMODE_ATUO;
								break;

							case TV_IDS_String_3DMODE_2D23D:
								u32Mode = SPAL_PQ_3DMODE_2D3D;
								break;

							case TV_IDS_String_3DMODE_SBS3D:
								u32Mode = SPAL_PQ_3DMODE_SBS3D;
								break;

							case TV_IDS_String_3DMODE_TAB3D:
								u32Mode = SPAL_PQ_3DMODE_TAB3D;
								break;

							case TV_IDS_String_3DMODE_FP3D:
								u32Mode = SPAL_PQ_3DMODE_FP3D;
								break;
							default:
								u32Mode = SPAL_PQ_3DMODE_ATUO;
								break;
						}

						//APP_GUIOBJ_3DMenu_SetMode(u32Mode);
						AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_PICTURE, 0,
										sizeof(APP_SETTING_Picture_t), &(g_stPictureData));
						g_stPictureData.stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Mode3D = u32Mode;
						AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_PICTURE,
							ITEM_OFFSET(APP_SETTING_Picture_t, stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Mode3D),
							sizeof(g_stPictureData.stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Mode3D),
							&(g_stPictureData.stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Mode3D));

							AL_Setting_Store(APP_Data_UserSetting_Handle(), SYS_SET_ID_PICTURE,
								ITEM_OFFSET(APP_SETTING_Picture_t, stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Mode3D),
								sizeof(g_stPictureData.stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Mode3D));

					}
				}
				else if(DISP_3D_STATUS_ONLY_2D3D_ALWAYS_ON == e3DModeChangeSt)
				{
					APP_GUIOBJ_3DMenu_GetMode(&u32Mode);
					if(bSet3DMode == TRUE)
					{
						bSet3DMode = FALSE;
					}
					else if(value == TV_IDS_String_On)
					{
						//set 3D mode to Off
						//_APP_GUIOBJ_3DMenu_SetForce2DAnother(TV_IDS_String_On);
						AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_PICTURE, 0,
										sizeof(APP_SETTING_Picture_t), &(g_stPictureData));
						g_stPictureData.stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Force2D= SPAL_PQ_3DForce2D_ON;
						AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_PICTURE,
							ITEM_OFFSET(APP_SETTING_Picture_t, stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Force2D),
							sizeof(g_stPictureData.stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Force2D),
							&(g_stPictureData.stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Force2D));

							AL_Setting_Store(APP_Data_UserSetting_Handle(), SYS_SET_ID_PICTURE,
								ITEM_OFFSET(APP_SETTING_Picture_t, stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Force2D),
								sizeof(g_stPictureData.stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Force2D));
					}
					else if(u32Mode != TV_IDS_String_3DMODE_2D23D)
					{
						//APP_GUIOBJ_3DMenu_SetMode(TV_IDS_String_3DMODE_OFF);
						AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_PICTURE, 0,
										sizeof(APP_SETTING_Picture_t), &(g_stPictureData));
						g_stPictureData.stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Mode3D = SPAL_PQ_3DMODE_OFF;
						AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_PICTURE,
							ITEM_OFFSET(APP_SETTING_Picture_t, stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Mode3D),
							sizeof(g_stPictureData.stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Mode3D),
							&(g_stPictureData.stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Mode3D));

							AL_Setting_Store(APP_Data_UserSetting_Handle(), SYS_SET_ID_PICTURE,
								ITEM_OFFSET(APP_SETTING_Picture_t, stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Mode3D),
								sizeof(g_stPictureData.stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Mode3D));
					}
					else
					{
						AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_PICTURE, 0,
										sizeof(APP_SETTING_Picture_t), &(g_stPictureData));
						g_stPictureData.stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Mode3D = SPAL_PQ_3DMODE_2D3D;
						AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_PICTURE,
							ITEM_OFFSET(APP_SETTING_Picture_t, stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Mode3D),
							sizeof(g_stPictureData.stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Mode3D),
							&(g_stPictureData.stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Mode3D));

							AL_Setting_Store(APP_Data_UserSetting_Handle(), SYS_SET_ID_PICTURE,
								ITEM_OFFSET(APP_SETTING_Picture_t, stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Mode3D),
								sizeof(g_stPictureData.stPictureModeSourceTab[eStorageSourTypeT].st3DMenu.Mode3D));
					}
				}
#endif
#ifndef CONFIG_SUPPORT_MONITOR
				 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);
				 }
#endif
				 #ifdef CONFIG_ATV_SUPPORT
				 if (eSourType == APP_SOURCE_ATV)
				 {
					 if (!APP_IsScan_Running())
					 {
						 AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_SETUP, 0,
									 sizeof(APP_SETTING_Setup_t), &(g_stSetupData));
						 u32BlueBackvalue = g_stSetupData.BlueScreen;

						 if (u32BlueBackvalue == APP_SWITCH_ON)
						 {
							 if((!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_SCAN_PROCESS))
								 && (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_AMS_SEARCH))
								 && (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_AMS_FINE_TUNE))
								 )
							 {
							     MID_DISP_DTVSetDispAspect(DISP_ASPECT_RATIO_FULL, TRUE);
								 _ATVApp_SetMuteProcess(TRUE);
							 }
							 else
							 {
							     MID_DISP_DTVSetDispAspect(DISP_ASPECT_RATIO_FULL, TRUE);
								 _ATVApp_SetMuteProcess(FALSE);
							 }
						 }
						 else
						 {
						     MID_DISP_DTVSetDispAspect(DISP_ASPECT_RATIO_FULL, TRUE);
							 _ATVApp_SetMuteProcess(TRUE);
						 }
						 #ifdef CONFIG_ISDB_SYSTEM
						 INT32 dFocusedIndex;
						/* No focused Guiobj exist */
					    if (SYSTEM_APP_NO_FOCUSED_GUIOBJ == SYSAPP_GOBJ_GetFocusedGUIObject(SYS_APP_ATV, &dFocusedIndex))
					    {
							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);
							}
					    }
						#endif
					 }
				 }
				 else
				 #endif
				 {
					 _ATVApp_SetMuteProcess(TRUE);
				 }
				if (bSetUnMuteFlag == TRUE)
				{
					bSetUnMuteFlag = FALSE;
					ATVApp_CheckProgramType(FALSE);
				}
			 	}
        	}
            break;

        case APP_ATV_GLOBAL_EVENT_NOT_AVILABLE:
			{
				#ifdef CONFIG_ATV_SUPPORT
				APP_GUIOBJ_ATV_Playback_SetZappingState(FALSE);
				#endif
				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);
			    }
#ifdef CONFIG_ATV_SUPPORT
			    if (SYSAPP_GOBJ_GUIObjectExist(stAtvInst.dSystemApplicationIndex, ATV_GUIOBJ_INPUTINFO))
			    {
			        SYSAPP_GOBJ_DestroyGUIObject(stAtvInst.dSystemApplicationIndex, ATV_GUIOBJ_INPUTINFO);
			    }
#endif
			    /*set mute*/
			    _ATVApp_SetMuteProcess(TRUE);
			}
            break;

        case APP_ATV_GLOBAL_EVENT_POPMSG_NO_SIGNAL:
		#ifdef CONFIG_ATV_SUPPORT
            if ((eSourType == APP_SOURCE_ATV)
                && (ATVApp_GetSignalState() == ATV_NO_SIGNAL)
                && (APP_GUIOBJ_ATV_Playback_GetProgramState()))
            {
                if (ATVApp_IsPopupExist(ATV_APP_POP_MSG_CHECKPWD))
                {
                    break;
                }
                _ATVAPP_ShowPopup(ATV_APP_POP_MSG_CHECKPWD);
            }
            else
		#endif
            {
				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(g_stSetupData.MenuSourceType == APP_MENUSOURCETYPE_AUTO && g_CheckSignal_Times != 0xFF)
					break;
#ifdef CONFIG_ATV_SUPPORT
				if(!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_INPUTINFO))
#endif
				{
					_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;
#ifdef CONFIG_ATV_SUPPORT
					if ((!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_INPUTINFO))
					//#ifndef CONFIG_ISDB_SYSTEM
#ifndef CONFIG_SUPPORT_ATV_SCAN_NTSCM_PALM_N
	                && (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_INITINSTALL))
	                //#endif
#endif
	                    && (!(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);
				   }
#endif
				}
				else
				{
#ifdef CONFIG_SUPPORT_NOSIGNAL_AUTO_CHANGE_SOURCE
					if(g_stSetupData.MenuSourceType == APP_MENUSOURCETYPE_AUTO)
					{
						if(g_CheckSignal == FALSE && g_u8SignalState !=ATV_NO_SIGNAL)
						{
							g_CheckSignal_Times = 0;
						}
					}
#endif
					g_u8SignalState = ATV_NO_SIGNAL;
					MID_TVFE_ResetCurrentVideoInfo(SRCTYPE_HDMI);
					_ATVApp_SetMuteProcess(TRUE);
#ifdef CONFIG_ATV_SUPPORT
					if ((!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_INPUTINFO))
					//#ifndef CONFIG_ISDB_SYSTEM
#ifndef CONFIG_SUPPORT_ATV_SCAN_NTSCM_PALM_N
	                && (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_INITINSTALL))
	                //#endif
#endif
	                    && (!(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);
				   }
#endif
				}
			}
			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()) 
#ifndef CONFIG_SUPPORT_MONITOR
#ifdef CONFIG_SUPPORT_USB_UPGRADE
                || (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_SOFTWARE_UPGRADE))
#endif
#endif
#ifdef CONFIG_ATV_SUPPORT
                || (AL_CS_IsStop() != al_true)
#endif
                )
            {
                 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()) 
#ifndef CONFIG_SUPPORT_MONITOR
#ifdef CONFIG_SUPPORT_USB_UPGRADE
                || (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_SOFTWARE_UPGRADE)) 
#endif
#endif
#ifdef CONFIG_ATV_SUPPORT
                || (AL_CS_IsStop() != al_true)
#endif
		)
            {
			#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_SCART_SUPPORT
                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 ((APP_MenuMgr_Exist_Scan_Menu())
#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_SUPPORT_3D_EN
        case UI_EVENT_3D:
            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;
            }
            atv_printf("[%s]==== UI_EVENT_3D \n\n", __FUNCTION__);

			APP_Video_Check3DState(&ePicture3DState);
			if(ePicture3DState == APP_VIDEO_IMAGE_3D_DISABLED)
			{
				if(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_3D_INFO))
				{
					SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, APP_GUIOBJ_3D_INFO);
				}
		        _ATVAPP_ShowPopup(ATV_APP_POP_MSG_NOT_AVAILABLE);
	            break;
			}

            if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_3D_INFO))
            {
                _ATVApp_CloseAllMenu();
				#ifndef CONFIG_SUPPORT_MONITOR
				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);
				}
				#endif
                SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, APP_GUIOBJ_3D_INFO, dMessage);
                atv_printf("%s %d\n\n", __FUNCTION__, dMessage);
            }
            else
            {
                SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, APP_GUIOBJ_3D_INFO);
            }
            break;
        case APP_GLOBAL_EVENT_3D_TIMER_INFO:
            AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_PICTURE, 0,
                            sizeof(APP_SETTING_Picture_t), &(g_stPictureData));
            APP_StorageSource_Type_t eStorageSourType = APP_STORAGE_SOURCE_MAX;
            eStorageSourType = APP_Data_UserSetting_SourceTypeMappingToStorage(eSourType);
            if ((!SYSAPP_GOBJ_GUIObjectExist(stAtvInst.dSystemApplicationIndex,
                                             APP_GUIOBJ_3D_INFO)) && (g_stPictureData.stPictureModeSourceTab[eStorageSourType].st3DMenu.Mode3D != SPAL_PQ_3DMODE_OFF))
            {
                _ATVApp_Exit_All_Menu(TRUE);
                SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, APP_GUIOBJ_3D_INFO, dParam);
            }
            break;
#endif

#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

#ifdef SUPPORT_CEC_TV
	if (CECTV_GetCECEnable()==CECTV_ENABLE)
	{
		CECTV_SendCmd(CECTV_SINGLE_ACT_CMD_CHGSRC_OUT_HDMI, SRC_OTHERS);
	}
#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:
			//#ifndef CONFIG_ISDB_SYSTEM
			if(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_INITINSTALL))
			{
				break;
			}
			//#endif
            #ifdef CONFIG_ATV_SUPPORT
            /* 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)))
            {
                break;
            }
            #endif
			/* 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:
			//#ifndef CONFIG_ISDB_SYSTEM
			#ifndef CONFIG_SUPPORT_MONITOR
			if(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_INITINSTALL))
			{
				break;
			}
			#endif
			//#endif
#ifdef CONFIG_ATV_SUPPORT
            /* 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)))
            {
                break;
            }
#endif
            /* 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_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;
#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
#ifdef CONFIG_ATV_SUPPORT
				if (AL_CS_IsStop() == FALSE)
				{
					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
					INT32 dFocusedIndex;
					if(FALSE == gUSBUpgradeBinIsSupperBin)
					{
						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
					{
					#ifndef CONFIG_SUPPORT_MONITOR
					SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, APP_GUIOBJ_SOFTWARE_UPGRADE, SOFTWARE_UPGRADE_FROM_AUTO_UPGRADE);
					#endif
					}
				}
                //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
#ifdef N32_GAME_SUPPORT
		case APP_GLOBAL_EVENT_GAME_UPGRADE:
		if (!APP_MenuMgr_Exist_Main_Menu()
			&& !(APP_MenuMgr_Exist_Factory_Menu())
			)
		{
			if(dParam == 0)
			{
				atv_printf("\n!!!open confirm for game upgrade\n");
				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_GAME_UPGRADE;
				stPopup.extend.stConfirm.u8Default = POPMSG_YES;
				ATVApp_SchedulePopup(stPopup);
			}
			else
			{
				atv_printf("\n!!!show popmsg not enough size to upgrade game\n");
				_ATVAPP_ShowPopup(ATV_APP_POP_MSG_NO_SIZE_FOR_GAME);
			}
		}
		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
#ifdef CONFIG_SUPPORT_NET_OTA
		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
			#ifdef CONFIG_SUPPORT_ETHERNET
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_ETHERNET_CONFIG))
			{
				SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, APP_GUIOBJ_ETHERNET_CONFIG);
			}
			#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_KEYLOCK:
            _ATVAPP_ShowPopup(ATV_APP_POP_MSG_KEYLOCK);
            break;
#ifndef CONFIG_SUPPORT_MONITOR			
#ifndef CONFIG_ISDB_SYSTEM
        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	
#endif
#ifdef CONFIG_KEYPAD_SINGLE_REUSE
		case APP_GLOBAL_EVENT_SINGLEKEYPAD_OPEN:
			SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, APP_GUIOBJ_SINGLEKEYPAD, 0);
			break;
		case APP_GLOBAL_EVENT_SINGLEKEYPAD_CLOSE:
			SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, APP_GUIOBJ_SINGLEKEYPAD);
			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
			{
				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));

	            printf("[%s], %d: Panel Index is %d\n", __FUNCTION__, __LINE__, u8PanelIdx);

	            break;
			}
		case UI_EVENT_FAC_BURNINGMODE:
			{
				_ATVApp_Exit_All_Menu(0);
				MID_TVFE_SetAutoPowerOn(AC_AUTO_POWERON_ON);
				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 = APP_PC_HPOS_DEF;
					PC_Tempvalue.i16VPosition = APP_PC_VPOS_DEF;
#ifndef CONFIG_SUPPORT_MONITOR
					PC_Tempvalue.Phase =
						APP_GUIOBJ_ATV_PCSetup_PhaseMappingtoOSDValue(PC_Tempvalue.Phase);
#else
					PC_Tempvalue.Phase =
						APP_UserMenu_PCSetup_PhaseMappingtoOSDValue(PC_Tempvalue.Phase);
#endif
					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 - APP_PC_HPOS_DEF));
					MID_DISP_DTVSetCropWindowVStartOffset(0, (PC_Tempvalue.i16VPosition - APP_PC_VPOS_DEF));
					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);

				SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_ATV, ATV_GUIOBJ_PLAYBACK,
					APP_ATV_INTRA_EVENT_STOP_PLAYBACK, 0);
#ifdef CONFIG_ATV_SUPPORT
#if (defined(CONFIG_DRAMSIZE) && (CONFIG_DRAMSIZE == 64)) || (defined (CONFIG_SUPPORT_64M_DTV))
				AL_FW_ActiveDBModule(AL_DBTYPE_DVB_ATV);
#endif
				AL_DB_Reset(AL_DBTYPE_DVB_ATV, al_true);
#endif
#if(defined CONFIG_DVB_SYSTEM_DVBT_SUPPORT)
				AL_FW_SwitchDBModule(AL_DBTYPE_DVB_T);
				AL_DB_Reset(AL_DBTYPE_DVB_T, al_true);
				AL_Event_UnLockChannels(AL_DBTYPE_DVB_T, RESERVED_ORIGINAL_NET_ID, RESERVED_TRANSPORT_ID, RESERVED_SERVICE_ID);
				AL_PR_DeleteAllSch(AL_DBTYPE_DVB_T,AL_PR_EVT_REM | AL_PR_SRV_REM);
#endif
#if(defined CONFIG_DVB_SYSTEM_DVBC_SUPPORT)
				AL_FW_SwitchDBModule(AL_DBTYPE_DVB_C);
				AL_DB_Reset(AL_DBTYPE_DVB_C, al_true);
				AL_Event_UnLockChannels(AL_DBTYPE_DVB_C, RESERVED_ORIGINAL_NET_ID, RESERVED_TRANSPORT_ID, RESERVED_SERVICE_ID);
				AL_PR_DeleteAllSch(AL_DBTYPE_DVB_C,AL_PR_EVT_REM | AL_PR_SRV_REM);
#endif
#if(defined CONFIG_DVB_SYSTEM_DVBS_SUPPORT)
				AL_FW_SwitchDBModule(AL_DBTYPE_DVB_S);
				AL_DB_Reset(AL_DBTYPE_DVB_S, al_true);
				AL_Event_UnLockChannels(AL_DBTYPE_DVB_S, RESERVED_ORIGINAL_NET_ID, RESERVED_TRANSPORT_ID, RESERVED_SERVICE_ID);
				AL_PR_DeleteAllSch(AL_DBTYPE_DVB_S,AL_PR_EVT_REM | AL_PR_SRV_REM);
				DVBApp_LoadCustomerDB(AL_DBTYPE_DVB_S);
				AL_DB_Sync(AL_DBTYPE_DVB_S, al_true);
#endif
#if (defined CONFIG_ISDB_SYSTEM)
				AL_FW_SwitchDBModule(AL_DBTYPE_DVB_SBTVD);
				AL_DB_Reset(AL_DBTYPE_DVB_SBTVD, al_true);
				AL_Event_UnLockChannels(AL_DBTYPE_DVB_SBTVD, RESERVED_ORIGINAL_NET_ID, RESERVED_TRANSPORT_ID, RESERVED_SERVICE_ID);
#ifdef CONFIG_SUPPORT_PVR
				AL_PR_DeleteAllSch(AL_DBTYPE_DVB_SBTVD,AL_PR_EVT_REM | AL_PR_SRV_REM);
#endif
				extern void APP_Sysset_Reset_list(AL_DB_EDBType_t eDBType);
				APP_Sysset_Reset_list(AL_DBTYPE_DVB_SBTVD);
#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
#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_TEST_ON:
		case UI_EVENT_AUTO_TEST_OFF:
			APP_Factory_Event_Action_Function(dMessage);
			break;

		case UI_EVENT_PCAUTOADJ:
		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:
			#ifdef CONFIG_SCART_SUPPORT
			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);
			}
			#endif
			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);
			}
			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();
				SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_ATV, ATV_GUIOBJ_PLAYBACK,
					APP_ATV_INTRA_EVENT_STOP_PLAYBACK, 0);
				//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;
#endif
#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);
                    SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_ATV, ATV_GUIOBJ_PLAYBACK,
                        APP_ATV_INTRA_EVENT_STOP_PLAYBACK, 0);
                 }
            }
            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);
                        SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_ATV, ATV_GUIOBJ_PLAYBACK,
                            APP_ATV_INTRA_EVENT_START_PLAYBACK, TRUE);
                    }
                }
            }
			break;
		case FW_VCHIP_UNLOCK:
		  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);
              SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_ATV, ATV_GUIOBJ_PLAYBACK,
                  APP_ATV_INTRA_EVENT_START_PLAYBACK, TRUE);
          }
		  break;
#endif
#ifdef CONFIG_SUPPORT_SW_AFC
		case APP_GLOBAL_EVENT_AFT_PROCESS:
			{
				AFT_ProcessIsDone();
                if (!APP_IsScan_Running())
				{
                	TVFE_Audio_RFLineCTL(TRUE);
                    g_u8SIF_SCS_OK = FALSE;
				}
			}
			break;
#endif

		case APP_GLOBAL_EVENT_ADC_AUTO_CHANGE_SOURCE:
#ifdef CONFIG_SUPPORT_NOSIGNAL_AUTO_CHANGE_SOURCE
			if (ATVApp_GetSignalState() == ATV_AVAILABLE_SIGNAL)
				break;
			if(g_stSetupData.MenuSourceType != APP_MENUSOURCETYPE_AUTO)
				break;
			g_CheckSignal_Times = 0;
			if(dParam == TRUE)//plug in
			{
				if(g_ADCAutoChange == FALSE)
				{
					printf("plug in\n");
					if (SP_SUCCESS != APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_PC))
		            {
		                atv_printf("APP_GUIOBJ_Source_SetAppSource Fail!!!!!!!!!\n");
		            }
					else
					{
						g_ADCAutoChange = TRUE;
					}
				}
			}
			else // plutg out
			{
				g_ADCAutoChange = FALSE;	
				printf("plug out\n");
			}
#endif
			break;
		case APP_GLOBAL_EVENT_ADC_AUTOADJUST:
			if(dParam == TRUE)//auto adjust start
			{
				_ATVAPP_ShowPopup(ATV_APP_POP_MSG_AUTO_ADJUST);
			}
			else //auto adjust finished
			{
				if (ATVApp_IsPopupExist(ATV_APP_POP_MSG_AUTO_ADJUST))
				{
					ATVApp_ClosePopup(ATV_APP_POP_MSG_AUTO_ADJUST, UI_EVENT_NULL);
				}
			}
			break;

#if defined(CONFIG_SUPPORT_NES_GAME)|| defined(CONFIG_OSD_GAME_SUPPORT)
      case APP_ATV_INTRA_EVENT_GAME_SOURCE_CHANGE:
            //if (APP_GUIOBJ_Source_GetLockState() == TRUE)
            {
                atv_printf("\n Input (Source) Block !!!   %s  %d\n" ,__FUNCTION__,__LINE__);
		#ifndef CONFIG_SUPPORT_MONITOR
                SYSAPP_IF_SendGlobalEventWithIndex(
                                    SYS_APP_ATV, APP_GLOBAL_EVENT_OPEN_POPUP|PASS_TO_SYSAPP, ATV_APP_POP_MSG_CHECKPWD);
		#endif
                break;
            }
            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;
			 {
				 UINT32 u32PQupgrade = (dParam & 0xf00)>>8;
				 if(u32PQupgrade != APP_DATA_KEYUPGRADE_NOT_UPGRADE)
				 {
					 _ATVAPP_ShowPopup(ATV_APP_POP_MSG_IMPORT_PQ_PASS);
					 printf("PQ import success full !");
				 }
			 }

			 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;
#if 0//def CONFIG_SUPPORT_MIRACAST
	case DMN_EVENT_MIRACAST_CONNECTING:
		atv_printf("DMN_EVENT_MIRACAST_CONNECTING.\n");
		if(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_INITINSTALL))
		{
			break;
		}
		//#endif
		/* 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)))
		{
		    break;
		}
		_ATVApp_CloseAllMenu();
		_ATVApp_ResetPopup_Channel();
		/* Check invalid state ---*/
		if (SP_SUCCESS != APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_NET))
		{
			atv_printf("[AtvApp OnGlobalEvent] APP_GUIOBJ_Source_SetAppSource faild.\n");
		}
		break;
	case DMN_EVENT_MIRACAST_EXIT_SUCCESS:
		atv_printf("DMN_EVENT_MIRACAST_EXIT_SUCCESS.\n");
		//if(IsDonglePlugged())
		{
			//DrawInfoWindow("Device Plugged", DRAW_IT);
			GL_TaskSleep(3000);
			MiracastInit();
		}
		//else{
			//DrawInfoWindow("NO Device", DRAW_IT);
		//}
		break;
#endif
#ifdef CONFIG_SMART_MODULE_SUPPORT
			case UI_EVENT_HDMI:
				_ATVApp_CloseAllMenu();
				_ATVApp_ResetPopup_Channel();
				APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_HDMI);
			break;

#endif
#ifdef SUPPORT_IR_HOTKEY
			case UI_EVENT_DTV:
				_ATVApp_CloseAllMenu();
				APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_DTV);
				break;
			case UI_EVENT_AV:
				{
				APP_Source_Type_t curSource = 0;
				_ATVApp_CloseAllMenu();
				APP_GUIOBJ_Source_GetCurrSource(&curSource);
				if(curSource != APP_SOURCE_AV)
				{
					curSource = APP_SOURCE_AV;
				}
				else if(curSource != APP_SOURCE_AV1)
				{
					curSource = APP_SOURCE_AV1;
				}
				else if(curSource != APP_SOURCE_AV2)
				{
					curSource = APP_SOURCE_AV2;
				}
				APP_GUIOBJ_Source_SetAppSource(curSource);
				}
				break;
			case UI_EVENT_YPP:
				{
				APP_Source_Type_t curSource = 0;				
				_ATVApp_CloseAllMenu();
				APP_GUIOBJ_Source_GetCurrSource(&curSource);
				if(curSource != APP_SOURCE_YPBPR)
				{
					curSource = APP_SOURCE_YPBPR;
				}
				else if(curSource != APP_SOURCE_YPBPR1)
				{
					curSource = APP_SOURCE_YPBPR;
				}
				else if(curSource != APP_SOURCE_YPBPR2)
				{
					curSource = APP_SOURCE_YPBPR2;
				}
				APP_GUIOBJ_Source_SetAppSource(curSource);
				}
				break;
			#ifndef CONFIG_SMART_MODULE_SUPPORT
			case UI_EVENT_HDMI:
			{
				APP_Source_Type_t curSource = 0;

				_ATVApp_CloseAllMenu();
				APP_GUIOBJ_Source_GetCurrSource(&curSource);
				switch(curSource)
				{
					case APP_SOURCE_PC:
						curSource = APP_SOURCE_HDMI;
						break;
					case APP_SOURCE_HDMI:
						curSource = APP_SOURCE_HDMI1;
						break;
					case APP_SOURCE_HDMI1:
						curSource = APP_SOURCE_HDMI2;
						break;
					case APP_SOURCE_HDMI2:
						curSource = APP_SOURCE_PC;
						break;
					default:
						curSource = APP_SOURCE_PC;
						break;
				}
				APP_GUIOBJ_Source_SetAppSource(curSource);
			}
			break;
			#endif
#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:
        {
            _ATVApp_CloseAllMenu();
            #ifdef CONFIG_ATV_SUPPORT
             AL_RecHandle_t NextHdl = dParam;
            if (NextHdl != AL_DB_INVALIDHDL)
            {
                _ATVApp_Zapping(NextHdl, FALSE);
            }
            #endif
        }
        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_DBInit
**
** DESCRIPTION :
**				Init ATV database
**
** PARAMETERS :
**				None
**
** RETURN VALUES:
**				None
*****************************************************************************/
#ifdef CONFIG_ATV_SUPPORT
void ATVApp_DBInit(void)
{
    APP_ATV_Playback_ResetFirstService();
}
#endif
/*****************************************************************************
** 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;
#ifdef CONFIG_ATV_SUPPORT
	IsAlreadyFirstSetMTS = FALSE;
	g_u8CheckMTSTimer = 0;
	g_u8SIF_SCS_OK_HasCheck = 0;
	APP_Audio_SetATVSIFAvailableMode(TVFE_AUDIO_SIF_AVAIL_ERROR);
#endif
}

/*****************************************************************************
** 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;
}
#ifdef CONFIG_SUPPORT_NOSIGNAL_AUTO_CHANGE_SOURCE
INT32 ATVApp_SetCheckSignalTimes(UINT8 CheckSignal_Times, UINT8 status)
{
    g_CheckSignal_Times = CheckSignal_Times;
    g_CheckSignal = status;
    return 0;
}
#endif
/*****************************************************************************
** 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;
#ifdef CONFIG_VCHIP_SUPPORT
    int dFocusedIndex = ATV_GUIOBJ_MAX;
#endif

    APP_GUIOBJ_Source_GetCurrSource(&eSourType);
    /* if lock */
#ifdef CONFIG_ATV_SUPPORT
    if ((eSourType == APP_SOURCE_ATV) && (APP_GUIOBJ_ATV_Playback_GetProgramState()))
    {
        if (bInit == FALSE)
        {
			g_ATVbLastParentLock = TRUE;
            AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_SETUP, 0,
                            sizeof(APP_SETTING_Setup_t), &(g_stSetupData));
            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(TRUE, FALSE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
                if (g_stSetupData.BlueScreen == APP_SWITCH_ON)
                {
                    APP_SCARTOUT_SetVideoMute(APP_SOURCE_ATV, TRUE, TRUE);
                    MID_DISP_DTVSetVideoMute(0,0,255);
                }
                else
                {
                    APP_Video_SetMute(TRUE, FALSE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
                }
            }
            else
            {
                APP_Audio_SetMute(TRUE, FALSE, APP_MUTE_MODE_NO_SIGNALE, eSourType);
                if (g_stSetupData.BlueScreen == APP_SWITCH_ON)
                {
                    APP_SCARTOUT_SetVideoMute(APP_SOURCE_ATV, TRUE, TRUE);
                    MID_DISP_DTVSetVideoMute(0,0,255);
                }
                else
                {
                    APP_Video_SetMute(TRUE, FALSE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
                }
            }
			APP_ATV_Playback_SetFirstPlay(TRUE);
            SYSAPP_IF_SendGlobalEventWithIndex(
                SYS_APP_ATV, APP_GLOBAL_EVENT_OPEN_POPUP, ATV_APP_POP_MSG_CHECKPWD);
        }
        return SP_ERR_FAILURE;
    }
#endif
    /* 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)
#ifdef CONFIG_SUPPORT_CEC_TV
				|| SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_SOURCE_CEC)
#endif
#ifdef CONFIG_ATV_SUPPORT
                || SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_CHNLIST)
#endif
#if defined(CONFIG_DVB_SYSTEM) || defined(CONFIG_AUS_DVB_SYSTEM) ||defined(CONFIG_DTMB_SYSTEM)
			    || SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_FAVLIST)
#endif
#ifdef CONFIG_SUPPORT_TTX
                || SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_TTX)
#endif
               )
            {
                g_u32OldPopup = PLAYBACK_POPUP_NONE;
                g_dCurPopup = u32CurPopup;
                return 0;
            }
#ifdef CONFIG_ATV_SUPPORT
            if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_POPMSG))
            {
                SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_POPMSG);
            }
#endif
            APP_MenuMgr_SetMsgPopup(TRUE);
			if(SYSAPP_GOBJ_Get_OSDLOCK() == TRUE)
			{
				SYSAPP_GOBJ_Set_OSDLOCK(FALSE);
	            SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, ATV_GUIOBJ_POPMSG, (UINT32)&Popup);
				SYSAPP_GOBJ_Set_OSDLOCK(TRUE);
			}
			else
				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);
#ifdef CONFIG_ATV_SUPPORT
        if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_PROGNUM))
        {
            SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_PROGNUM);
        }
#endif
		if(SYSAPP_GOBJ_Get_OSDLOCK() == TRUE)
		{
			SYSAPP_GOBJ_Set_OSDLOCK(FALSE);
			SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, ATV_GUIOBJ_POPMSG, (UINT32)&Popup);
			SYSAPP_GOBJ_Set_OSDLOCK(TRUE);
		}
		else
				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
			#if	defined(CONFIG_SUPPORT_ACTION_SHOW_BLUE_SCREEN_EXCEPT_MEDIA)
			//MID_DISP_DTVSetMuteColor(0, 0, 255);
			#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;
				break;
			case FW_SIGNAL_PRESENT:
#ifdef CONFIG_TESTAUTOREBOOT
				{
					FW_mode_t FW_Module = FW_NORMAL_VIEW_MODE;
					AL_FW_GetFWModule(&FW_Module);
					/*don't enable autoreboot while searching channel and update*/
					if (FW_Module != FW_CHAN_SRCH_MODE && FW_Module != FW_UPGRADE_MODE)
					{
#ifdef CONFIG_AUTOREBOOT_NO_SIGNAL
						ir_autoreboot_disable();
#else
						ir_autoreboot_enable();
#endif
					}
				}
#endif
#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_SIGNAL_IN_PROGRESS:
#ifdef CONFIG_TESTAUTOREBOOT
				{
					FW_mode_t FW_Module = FW_NORMAL_VIEW_MODE;
					AL_FW_GetFWModule(&FW_Module);
					/*don't enable autoreboot while searching channel and update*/
					if (FW_Module != FW_CHAN_SRCH_MODE && FW_Module != FW_UPGRADE_MODE)
					{
	#ifdef CONFIG_AUTOREBOOT_NO_SIGNAL
						ir_autoreboot_enable();
	#else
						ir_autoreboot_disable();
	#endif
					}
				}
#endif
				message = APP_ATV_GLOBAL_EVENT_SIGNAL_IN_PROGRESS |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_NO_SIGNAL:
#ifdef CONFIG_TESTAUTOREBOOT
				{
					FW_mode_t FW_Module = FW_NORMAL_VIEW_MODE;
					AL_FW_GetFWModule(&FW_Module);
					/*don't enable autoreboot while searching channel and update*/
					if (FW_Module != FW_CHAN_SRCH_MODE && FW_Module != FW_UPGRADE_MODE)
					{
	#ifdef CONFIG_AUTOREBOOT_NO_SIGNAL
						ir_autoreboot_enable();
	#else
						ir_autoreboot_disable();
	#endif
					}
				}
#endif
				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 VCHIP_SUPPORT
			case FM_CC_VCHIP_LOCK:
			case FM_CC_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
#ifdef CONFIG_VCHIP_SUPPORT
			case FW_VCHIP_LOCK:
			case FW_VCHIP_UNLOCK:
				message = event|PASS_TO_SYSAPP;
				break;
#endif
#ifdef CONFIG_SUPPORT_PVR
#if 0
			case FW_SCHEDULER_EVENT:
				atv_printf("event is coming\n");
				message = APP_DVB_GLOBAL_EVENT_PVRSCH;
				break;
#endif
			case FW_SCHEDULER_MSG:
				atv_printf("first warning: event will come in 10 sec\n");
				dParam = *(UINT32 *)param;
				message = APP_GLOBAL_EVENT_PVR_REMINDER | 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:
				#ifdef CONFIG_SCART_SUPPORT
				dParam = *(UINT32 *)param;
				message = APP_ATV_GLOBAL_EVENT_SCARTINPUT_CHANGE|PASS_TO_SYSAPP;
				#endif
				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:
				#ifdef CONFIG_ATV_SUPPORT
				if (!APP_IsScan_Running())
				{
                	TVFE_Audio_RFLineCTL(TRUE);
                    printf("SIF_SAS_OK\n");
				}
                message = APP_ATV_GLOBAL_EVENT_SIF_SAS_OK|PASS_TO_SYSAPP;
				#endif
				break;
			case FW_AUDIO_SIF_SCS_OK:
				#ifdef CONFIG_ATV_SUPPORT
				message = APP_ATV_GLOBAL_EVENT_SIF_SCS_OK|PASS_TO_SYSAPP;
				#endif
				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;
			case FW_HDMI_PORTSTATUS:
				dParam = *(UINT32 *)param;
				message = APP_ATV_GLOBAL_EVENT_HDMIPORT_STATUS|PASS_TO_SYSAPP;
				break;
			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_DVB_SYSTEM_DVBT_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");
				message = APP_GLOBAL_EVENT_AFT_PROCESS|PASS_TO_SYSAPP;
				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
			case FW_ADC_AUTOCHANGE_SOURCE:
				dParam = *(UINT32 *)param;
				message = APP_GLOBAL_EVENT_ADC_AUTO_CHANGE_SOURCE|PASS_TO_SYSAPP;
			break;
			case FW_ADC_AUTOADJUST:
				dParam = *(UINT32 *)param;
				message = APP_GLOBAL_EVENT_ADC_AUTOADJUST|PASS_TO_SYSAPP;
				break;
			case FW_MCCS_IMAGE_LUMINANCE:
			case FW_MCCS_IMAGE_CONTRAST:
			case FW_MCCS_IMAGE_SHARPNESS:
			case FW_MCCS_IMAGE_SATURATION:
			case FW_MCCS_IMAGE_RGAIN:
			case FW_MCCS_IMAGE_GGAIN:
			case FW_MCCS_IMAGE_BGAIN:
			case FW_MCCS_IMAGE_ROFFSET:
			case FW_MCCS_IMAGE_GOFFSET:
			case FW_MCCS_IMAGE_BOFFSET:
			case FW_MCCS_IMAGE_COLORLUT_SATGAIN_R:
			case FW_MCCS_IMAGE_COLORLUT_SATGAIN_Y:
			case FW_MCCS_IMAGE_COLORLUT_SATGAIN_G:
			case FW_MCCS_IMAGE_COLORLUT_SATGAIN_C:
			case FW_MCCS_IMAGE_COLORLUT_SATGAIN_B:
			case FW_MCCS_IMAGE_COLORLUT_SATGAIN_M:
			case FW_MCCS_IMAGE_GAMMA_TABLE_INDEX:
			case FW_MCCS_IMAGE_CONTRAST_AUTO:
			case FW_MCCS_OSD_HPOSITION:
			case FW_MCCS_OSD_VPOSITION:	
			case FW_MCCS_AUDIOVOLUME:
			case FW_MCCS_OSD_LANGUAGE:
			case FW_MCCS_AUDIOMUTE:	
			{
				dParam = *(UINT32 *)param;
				_ATVApp_MCCS_StoreSetting(event, dParam);
				_ATVApp_MCCS_CLOSE_USERMENU();	
				break;
			}
			#ifdef CONFIG_DDC_CI_SUPPORT
			case FW_MCCS_FBOSD_LANGUAGE:
				tv_FBOsdLanguage(APP_DCCCI_Language_FbOsdLanguage(g_stFeatureData.OSDLang));
				break;
			#endif
			case FW_MCCS_OSDLOCK:
			{
				dParam = *(UINT32 *)param;	
				if(dParam == 1)
				{
					SYSAPP_GOBJ_Set_OSDLOCK(TRUE);
					g_stSetupData.Osd_locked = TRUE;
					_ATVAPP_ShowPopup(ATV_APP_POP_MSG_OSDLOCK);
					
					AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_SETUP,		
						ITEM_OFFSET(APP_SETTING_Setup_t, Osd_locked),	 	
						sizeof(g_stSetupData.Osd_locked),		
						&(g_stSetupData.Osd_locked));
					AL_Setting_Store(APP_Data_UserSetting_Handle(), SYS_SET_ID_SETUP,		
						ITEM_OFFSET(APP_SETTING_Setup_t, Osd_locked),	 	
						sizeof(g_stSetupData.Osd_locked));
				}
				else
				{
					SYSAPP_GOBJ_Set_OSDLOCK(FALSE);
					g_stSetupData.Osd_locked = FALSE;

					AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_SETUP,		
						ITEM_OFFSET(APP_SETTING_Setup_t, Osd_locked),	 	
						sizeof(g_stSetupData.Osd_locked),		
						&(g_stSetupData.Osd_locked));
					AL_Setting_Store(APP_Data_UserSetting_Handle(), SYS_SET_ID_SETUP,		
						ITEM_OFFSET(APP_SETTING_Setup_t, Osd_locked),	 	
						sizeof(g_stSetupData.Osd_locked));
				}

				_ATVApp_MCCS_CLOSE_USERMENU();
				break;
			}
			case FW_MCCS_CLOSE_USERMENU:
			{
				_ATVApp_MCCS_CLOSE_USERMENU();	
			}
			break;
			case FW_MCCS_FLASH_CTRL:
				_ATVApp_MCCS_CLOSE_USERMENU();
				dParam = *(UINT32 *)param;
				if(dParam == 0)   //restore factory default
					_ATVApp_ResetAllSetting();
				else if(dParam == 1)   //restore factory brightness/contrast default
					_ATVApp_ResetLumContrastSetting();
				else if(dParam == 2)   //Restore factory geometry defaults
					ATVApp_ResetGeometrySetting();
				else if(dParam == 3)   //restore factory color default
					_ATVApp_ResetColorSetting();
				else if(dParam == 4)   //save current settings
					AL_Setting_Store(APP_Data_UserSetting_Handle(), 0xFF, 0, sizeof(APP_SETTING_Storage_t));	
				break;
			case FW_MCCS_SET_VGASETTING_AUTO:
				_ATVApp_MCCS_CLOSE_USERMENU();	
				ATVApp_ResetGeometrySetting();
				break;
			case FW_MCCS_SET_VGASETTING_HPOSITION:
			case FW_MCCS_SET_VGASETTING_VPOSITION:
			case FW_MCCS_SET_VGASETTING_CLOCK:
			case FW_MCCS_SET_VGASETTING_PHASE:
				dParam = *(UINT32 *)param;
				_ATVApp_MCCS_VGASetup(event, dParam);
				_ATVApp_MCCS_CLOSE_USERMENU();	
				break;
			case FW_MCCS_POWER_SETMODE:
				dParam = *(UINT32 *)param;
				if((dParam == 1) || (dParam == 4))
				{
					g_VCPPowerMode = dParam;
					if(dParam == 1)
						APP_Sysset_SetPanelState(ON);
					else
						APP_Sysset_SetPanelState(OFF);
				}
				_ATVApp_MCCS_CLOSE_USERMENU();	
				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
#ifndef CONFIG_SUPPORT_MONITOR
				SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_ATV, APP_GUIOBJ_MUTE, APP_INTRA_EVENT_HIDE_MUTE, 0);
#endif
			}
		}
	}

    if (ATVApp_IsPopupExist(PLAYBACK_POPUP_MSG_NO_SIGNAL))
    {
        ATVApp_ClosePopup(PLAYBACK_POPUP_MSG_NO_SIGNAL, UI_EVENT_NULL);
    }
#ifndef CONFIG_SUPPORT_MONITOR
    if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_BANNER))
    {
        SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, APP_GUIOBJ_BANNER);
    }
#endif
#ifdef CONFIG_ATV_SUPPORT
    if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, ATV_GUIOBJ_SIF))
    {
        SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_ATV, ATV_GUIOBJ_SIF);
    }
#endif
	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);
			#ifdef SUPPORT_LINEOUT_AS_HP
			APP_Audio_SetLineoutVol((UINT32)g_stVariationalData.Volume);
			#endif
			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);
		}
	}
}

#ifdef CONFIG_SUPPORT_NOSIGNAL_AUTO_CHANGE_SOURCE
void ATVApp_Reset_SwitchSourceToCheckSignal_Flag(void)
{
	g_CheckSignal_Times = 0xFF;
	g_CheckSignal = FALSE;
}

void ATVApp_SwitchSourceToCheckSignal(void)
{
	UINT16 u8Count = 0;
	APP_Source_Type_t eSourType = APP_SOURCE_MAX;
	APP_GUIOBJ_Source_GetCurrSource(&eSourType);
	g_CheckSignal_Times ++;
	g_CheckSignal = TRUE;
	if (APP_GOBJ_Source_CheckSource(eSourType, (UINT8 *)&u8Count) == SP_SUCCESS)
	{
		u8Count ++;
		if(u8Count >= g_u16SourceConfigTable_Size_New)
			u8Count = 0;

		eSourType = g_stSourceConfigTable_New[u8Count].eSourceType;
		if(eSourType == APP_SOURCE_MEDIA)
		{
			u8Count ++;
			if(u8Count >= g_u16SourceConfigTable_Size_New)
				u8Count = 0;
			eSourType = g_stSourceConfigTable_New[u8Count].eSourceType;
		}
		if (SP_SUCCESS != APP_GUIOBJ_Source_SetAppSource(eSourType))
		{
			atv_printf("APP_GUIOBJ_Source_SetAppSource Fail!!!!!!!!!\n");
			ATVApp_Reset_SwitchSourceToCheckSignal_Flag();
		}
	}
}
#endif