UTS6710/aps/application/s2tek/formal/sbtvd/sbtvd_app.c

/********************************************************************
** File Name: system_app_dvb.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
********************************************************************/
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <types.h>
#include "umf_debug.h"

#define DVB_GUI_OBJECT_TABLE_DEFINE_HERE
#include "app_guiobj_mute.h"
#include "sysapp_if.h"
#include "main_app.h"
#include "app_event.h"
#include "app_sbtvd_event.h"
#include "sysapp_table.h"
#include "app_global.h"
#include "app_gui.h"
#include "app_audio.h"
#include "app_factory.h"
#include "app_database.h"
#include "al_time.h"
#include "app_area_info.h"
#include "app_video.h"
#include "al_fw.h"
#include "gl_timer.h"
#include "app_data_setting.h"
#include "board_config.h"
#include "app_sbtvd_epg.h"
#include "app_prog_list.h"
#include "sbtvd_app.h"
#include "app_file_psi_listeners.h"
#include "app_guiobj_mainmenu.h"
#include "app_guiobj_feature.h"
#include "app_guiobj_scan_process.h"
#include "app_guiobj_cul_fm_HotelSetting.h"
#include "app_guiobj_source.h"
#include "app_guiobj_sleeptimer.h"
#include "app_guiobj_adjust.h"
#include "app_guiobj_date_time.h"
#include "app_guiobj_sbtvd_table.h"
#include "mid_playback.h"
#include "mid_display.h"
#include "mid_dtv_display.h"
#include "dvb_dr.h"
#include "mid_dvbmon.h"
#include "mid_ota.h"
#include "mid_siutil.h"
#include "mid_siutil_dvb.h"
#include "mid_siutil_13818.h"
#include "mid_common.h"
#include "mid_psimon.h"
#include "app_sbtvd_prefername.h"
#include "app_guiobj_sbtvd_proginfo.h"
#include "app_sbtvd_playback.h"
#include "app_sbtvd_parental_lock.h"
#include "app_scan_api.h"
#include "app_scan_save.h"
 #include "app_systime.h"
#include "app_guiobj_sbtvd_epg.h"
#include "app_guiobj_language.h"
#include "ap_extern.h"
#include "mid_sub_dtv_interface.h"
#ifdef SUPPORT_ETHERNET
#include "app_dvb_network.h"
#endif
#ifdef SCAN_FREQ_OFFSET_RANGE_ENLARGE
#include "mid_dtv_scan.h"
#endif
#ifdef SUPPORT_SCART_TV
#include "drv_scart.h"
#endif
#include "app_guiobj_sbtvd_proginfo.h"
#include "app_guiobj_sbtvd_multiaud.h"
#include "app_guiobj_channel.h"
//#include "app_guiobj_dtv_lcn_conflict_menu.h"
#include "app_guiobj_sbtvd_playback.h"
#include "app_menumgr.h"
#ifdef CONFIG_SUPPORT_OTA_UPGRADE
#include "mid_otamon.h"
#include "app_guiobj_sbtvd_ota_upgrade_prompt.h"
#include "app_sbtvd_ota_listeners.h"
#include "app_guiobj_sbtvd_ota_upgrade_progress.h"
#endif
#ifdef CONFIG_SUPPORT_USB_UPGRADE
#include "app_usb_upgrade.h"
#endif
#include "app_prog_list.h"
#include "app_sbtvd_prog_manager.h"
#include "app_scart.h"
#ifdef CONFIG_SUPPORT_PVR
#include "app_guiobj_sbtvd_partitionlist.h"
#include "app_guiobj_sbtvd_pvr_recdurationtime.h"
#include "app_guiobj_sbtvd_pvr_rec.h"
#include "app_guiobj_sbtvd_pvr_playinfo.h"
#include "app_guiobj_sbtvd_pvrrec_info.h"
#include "mid_recorder.h"
#include "mid_tspl.h"
#include "pvrparser.h"
#include "mid_tspl_parser.h"
#include "mid_partition_list.h"
#if defined (CONFIG_SUPPORT_USB_UPGRADE) || defined (CONFIG_SUPPORT_OTA_UPGRADE)
#include "mid_upgrade.h"
#endif
#endif
#include "main_app_external.h"
#include "al_prog_reminder.h"
#include "app_guiobj_auto_search.h"
#include "app_guiobj_sbtvd_pvr_playinfo.h"
#include "app_guiobj_sbtvd_partitionlist.h"
#include "app_power_control.h"
#include "app_clone_data.h"
//#include "system_utils.h"
#ifdef SUPPORT_CEC_TV
#include "umf_cec.h"
#endif
#include "app_guiobj_hdmilink.h"
#include "app_sysset.h"
#include "app_guiobj_cul_fm_factorySetting_new.h"
#ifdef SUPPORT_LED_FLASH
#include "app_led_control.h"
#endif
#include "app_sysset.h"

#ifdef CELLO_cello
#include "app_guiobj_auto_installation_cello.h"
#endif
#ifdef N32_GAME_SUPPORT
#include "app_clone_data.h"
#endif
#ifdef SUPPORT_HKC_FACTORY_REMOTE
#ifdef CONFIG_ATV_SUPPORT
#include "app_atv_playback.h"
#endif
#endif
#include "app_guiobj_favnet.h"
#include "audio_ioctl.h"
#include "drv_dtv_external.h"
#include "drv_dtv_common.h"
#include "mid_dtv_display.h"
#include "app_console.h"
#ifdef CONFIG_QSD
#include "app_guiobj_cul_fm_factorySetting_new.h"
#endif
#include "unicode.h"
#include "cust_nvm_cfg.h"
#include "app_guiobj_sbtvd_chnlist.h"
#ifdef CONFIG_SUPPORT_ISDB_SUBTITLE
#include "al_sbtvd_subtitle.h"
#endif
/********************************************************************
	Macros
********************************************************************/
#define DVB_DEBUG
#ifdef DVB_DEBUG
#define dvb_printf(fmt, arg...) UMFDBG(0,"[DVB App]"fmt, ##arg)
#else
#define dvb_printf(fmt, arg...) ((void) 0)
#endif

#define PVR_DEBUG
#ifdef PVR_DEBUG
#undef	PVR_DEBF
#define PVR_DEBF(fmt, arg...) UMFDBG(0,fmt, ##arg)
#else
#undef	PVR_DEBF
#define PVR_DEBF(fmt, arg...) ((void) 0)
#endif

//#define FW_DEBUG
#ifdef FW_DEBUG
#define	FW_DEBF(fmt, arg...)	UMFDBG(0,fmt, ##arg)
#else
#define FW_DEBF(fmt, arg...) ((void) 0)
#endif

#ifdef SUPPORT_SUBTITLE_ON_PG
#define ON_DATA_APPLICATION_DECISION(b)\
	((b&OSD2CTRLMDL_SUB)>0? (OSD2CTRLMDL_SUB|(b&OSD2CTRLMDL_MH5)):(b&OSD2CTRLMDL_TTX))
#else
#define ON_DATA_APPLICATION_DECISION(b)\
	((b&OSD2CTRLMDL_SUB)>0? OSD2CTRLMDL_SUB:((b&OSD2CTRLMDL_MH5)>0? OSD2CTRLMDL_MH5:(b&OSD2CTRLMDL_TTX)))
#endif

#define AP_FMW_DFP_NAME_BUFF_SIZE	(32<<10)
#ifdef SUPPORT_DYNAMIC_MULTIPLEXES
#define MAX_TMP_PROG_SIZE		100
#endif

#define  DVB_10_MINUTES		(5400)//5400*100 ms(9 min)

#define NOT_USED(p) ((void)(p))

/********************************************************************
	Type definitions
********************************************************************/
enum
{
    DATA_APP_UNSTABLE   = 0,        // si information doesn't find yet
    DATA_APP_LANUCHABLE = (1 << 1), // the module has data,
    DATA_APP_NOT_FOUND  = (1 << 2), // no data found for this application
    DATA_APP_EXECUTABLE = (1 << 7), // there is data, and it can be shown
} enDataAppModuleState;

typedef struct DvbPrivateData_t_
{
    //user define private data
    UINT32 dUserData;

} DvbPrivateData_t;

typedef void (*SysTimeFunc)(void);

/********************************************************************
	Function Declare
********************************************************************/
#ifdef AC_ON_AUTO_GET_TIME
extern Boolean g_fBackgroundGetTime;
#endif
extern UINT8 AL_FLASH_GetColorLUTALL(ColorLUT_t* bColorLUTValue);
extern int APP_GUIOBJ_3DMenu_SetModeNoOutPutStructure(UINT32 u32Mode);
extern void _APP_GUIOBJ_3DMenu_GetForce2DAnother(UINT32 *u32Force2D);
extern void _APP_GUIOBJ_3DMenu_SetForce2DAnother(UINT32 u32Force2D);
static INT32 _DVBApp_OnCreate(void **ppPrivateData);
static INT32 _DVBApp_OnDestroy(void **ppPrivateData);
static INT32 _DVBApp_OnRun(void *pPrivateData, UINT32 dParam);
static INT32 _DVBApp_OnTerminate(void *pPrivateData, UINT32 dParam);
static INT32 _DVBApp_OnTimerUpdate(void *pPrivateData);
static INT32 _DVBApp_OnEvent(void *pPrivateData, UINT32 dMessage, UINT32 dParam);
extern void _APP_GUIOBJ_Sound_SetMuteStatus();
extern UINT8 gIsFactoryResetting;

static INT32 _DVBApp_Zapping(
                UINT8 bServiceType, AL_RecHandle_t hProgHdl,
                UINT8 bForce, UINT32 u32Paramter, Boolean bShowInfo);
static INT32 _DVBApp_CloseAllMenu(void);
extern Boolean gUSBUpgradeBinIsSupperBin;

/********************************************************************
	Global Variables
********************************************************************/
SysAppInstDef stDvbInst =
{
    SYS_APP_DVB,
    _DVBApp_OnCreate,
    _DVBApp_OnDestroy,
    _DVBApp_OnRun,
    _DVBApp_OnTerminate,
    _DVBApp_OnTimerUpdate,
    _DVBApp_OnEvent,

    SYSTEM_IDLE, //system state.
    Dvb_GUI_Obj_List,    //GUI object table
    DVB_GUIOBJ_MAX,      //GUI object table size

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

#ifdef CONFIG_SUPPORT_3D_EN
extern UINT8 bSet3DMode;
#endif

/*Static Variables*/
static PopmsgParam_t stPopupWaitingList[PLAYBACK_POPUP_MAX-PLAYBACK_POPUP_NONE];
static UINT32 g_dCurPopup = PLAYBACK_POPUP_NONE;
static UINT32 g_u32OldPopup = PLAYBACK_POPUP_NONE;
static UINT32 g_u32NoSignalTimer = 0;
static UINT32 g_u32NoSignalSleepTimer = 0;
static UINT32 g_u32PopupWaitingList = 0;
static UINT8 g_PauseState = FALSE;
static UINT8 g_SetPQFlag = FALSE;
static bool bSetUnMuteFlag = FALSE;
static bool g_bMidHasUnmute = FALSE;
static Prog_ScrambleStatus_t g_bScrambleFlag = PROG_STATUS_SCRAMBLE_UNKNOW;
static bool g_bTempSerFlag = FALSE;
#ifdef CONFIG_SUPPORT_OTA_UPGRADE
static bool g_bOTAFlag = FALSE;
#endif

#ifdef SUPPORT_DTV_SHOW_BLUESCREEN
static bool g_bIsBlueScreen = FALSE;
#endif
static bool g_bForceProcessEventCbk = FALSE;

#ifdef CONFIG_SUPPORT_PVR
AL_SCH_sched_id_t stoprec_id = AL_SCH_INVALID_ID;
AL_SCH_sched_id_t chsrc_id = AL_SCH_INVALID_ID;
static Boolean g_bIsCHUp = FALSE;
static Boolean g_bIsNumKey = FALSE;
static AL_RecHandle_t g_ProgHandle;
static UINT8 g_u8BGTimeshiftStart = 0;
static MID_REC_MODE g_eCheckRecMode = MID_REC_MODE_MAX;	//for auto mode speed not enough popup
AL_RecHandle_t g_ProgHandleB4Rec;
static Boolean g_bTvRadioSwap = FALSE;		//for timer rec to swap TV RADIO
static Boolean g_bPVRSwitchSource = FALSE;
AL_SCH_sched_id_t g_dReminderId;
AL_PR_details_t g_stDetails;
AL_PR_details_t g_stOldDetails;
AL_DB_ERecordType_t g_eRecType;
AL_PR_type_t g_remtype = AL_PR_INVALID_REM;
static APP_Favorite_t FavType = APP_FAVORITE_NONE;
static Boolean g_bIsPlaykey = TRUE;/*<set this flag when user press play/pause key*/
#endif
static Boolean g_bIsFav = FALSE;
static UINT8 g_u8SourceTrastTimer = 0;
static UINT8 g_u8PopScrambleMsgTimer = 0;
static UINT8 g_u8ZappingTimer = 0;
extern Boolean g_bAudHasUpdate;
#ifdef TEAC_BLUE_KEY_FUNCTION
static APP_Panel_PowerSequenceType_e g_eAppPanelOnOff = APP_PANEL_POWER_UP;
#endif
static Boolean g_bUnstable = FALSE;
static al_uint8 g_bNoSteamData = AL_DVB_MONITOR_VALUE_INVAILED; /**<stream data state record, al_false: has stream data, al_true: no stream data*/
static al_uint8 g_AdioChnPolTime = 0;
#ifdef CONFIG_SUPPORT_EWS
static AL_RecHandle_t g_PrevProgHandle = AL_DB_INVALIDHDL;
static al_uint8 g_EWSMode = FALSE;
static al_uint8 g_NonClearEWS = FALSE;
static DBPIDInfo_t g_MonAudioPid;
static DBPIDInfo_t g_PrevAudioPid;
#endif
#ifdef CONFIG_SUPPORT_SSU_UPGRADE
static bool autoupgrade = FALSE;// false:don't auto upgrade(show prompt), True: auto(show progress)
static AU_Timer_state_e autoupgrade_sate = AU_MAX;// this param is used for control auto grade process.
static bool bBootAutoUpGrade = 0;
void DVBApp_SetBootAutoUpGrade(Boolean flag)
{
	bBootAutoUpGrade = flag;
}
Boolean DVBApp_IsBootUpGrade(void)
{
	return bBootAutoUpGrade;
}

void DVBApp_SetAutoUpgrade(Boolean state)
{
	autoupgrade = state;
}
Boolean DVBApp_IsAutoUpgrade(void)
{
	return autoupgrade;
}

AU_Timer_state_e DVBApp_GetAU_Sate(void)
{
	return autoupgrade_sate;
}

void DVBApp_SetAU_Sate(AU_Timer_state_e state)
{
	autoupgrade_sate = state;
}
#endif
#ifdef CONFIG_CONFIRM_AUTO_UPGRADE
static int dLastFocusedIndex = 0;
#endif
/********************************************************************
	Function Define
********************************************************************/
UINT8 APP_GetPlaybackPauseState(void)
{
    return g_PauseState;
}

void APP_SetPlaybackPauseState(UINT8 state)
{
    g_PauseState = state;
}
UINT8 APP_GetPlaybackVideoState(void)
{
    return 0;
}

#ifdef SUPPORT_DYNAMIC_MULTIPLEXES
static void _DVBApp_NewServicesToDatabase(void)
{
	dvb_printf("%s() \n",__FUNCTION__);
	int i,j;
	UINT16 sindex,num;
	UINT32 u32CurrentArea;
	AL_PSIMon_SimpleSrv_t *srvbuf=	(AL_PSIMon_SimpleSrv_t *) zero_malloc(sizeof(AL_PSIMon_SimpleSrv_t)*PSIMON_MAX_OTHERTP_SRV);
	UINT8	*srvnamebuf=	(UINT8 *) zero_malloc(DB_DVB_MAX_CHNAME_LEN*PSIMON_MAX_OTHERTP_SRV);
	AL_DB_EDBType_t eDBType = APP_DVB_Playback_GetCurrentNetType();


	AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_CHANNEL, 0,
		sizeof(APP_SETTING_Channel_t), &(g_stChannelData));
	u32CurrentArea = g_stChannelData.Country;
	const AL_DVBT_AreaTable_t * area = NULL;
	APP_Area_GetAreaTableItem(u32CurrentArea,&area);
	AL_TPSects_Info_st *pTemp =
		(AL_TPSects_Info_st *)area->pTPRegion_Area;

	// 1. get new service list from other tp.
	AL_PSI_Monitor_GetOtherTpServList(srvbuf, srvnamebuf, &num);

    for (sindex = 0; sindex < num; sindex++)
    {
        UINT8 IsFreqFoundInTable = 0;
        AL_MultiplexDetail_t stTSInfo;
        AL_ServiceDetail_t stServInfo;
        AL_RecHandle_t hTp = 0;
        AL_RecHandle_t hProg = 0;
        static AL_RecHandle_t hParentHdl = AL_DB_INVALIDHDL;
        INT32 	u32Freq = 0;
        if (srvbuf == NULL || srvnamebuf == NULL)
        {
            break;
        }

        // 2. looking for the Tp's parameters from area table
        for (i = (area->SectNum - 1); i >= 0; i--)
        {
            for (j = (pTemp[i].SectTPCount - 1); j >= 0; j--)
            {
                u32Freq = pTemp[i].StartFreq + pTemp[i].stBandWidth.eBandWidth.BaseBandWidth * j * 1000;
                if (srvbuf[sindex].uiFreq == u32Freq
                    || srvbuf[sindex].uiFreq - 166 == u32Freq
                    || srvbuf[sindex].uiFreq + 167 == u32Freq)
                {
                    IsFreqFoundInTable = 1;
                    break;
                }
            }
            if (IsFreqFoundInTable)
            {
                break;
            }
        }
        if (IsFreqFoundInTable == 0)
        {
            dvb_printf(" Inexpected error! freq. doesn't find \n");
            break;
        }

        // 3. check if the TP presents already
        memset(&stTSInfo, 0, sizeof(AL_MultiplexDetail_t));
		stTSInfo.stSBTVDMultiplex.uiFreqK = u32Freq;
        stTSInfo.stSBTVDMultiplex.ucBandwidth = pTemp[i].stBandWidth.eBandWidth.BaseBandWidth;
        stTSInfo.stSBTVDMultiplex.ucAreaIndex = u32CurrentArea;
        stTSInfo.stSBTVDMultiplex.usTsId = srvbuf[sindex].usTsId;
#ifdef SUPPORT_HIERARCHY_MODE
        stTSInfo.stSBTVDMultiplex.ucHierarchyMode = pTemp[i].U8HierarchyMode;
#endif

		if (AL_DB_INVALIDHDL == hParentHdl)
        {
            AL_NetworkDetail_t stRootNet;
            stRootNet.stSBTVDNetwork.usNetId = 1;
            memcpy(stRootNet.stSBTVDNetwork.szNetName, "Dummy", 6);
            AL_DB_AddRecord(AL_DBTYPE_DVB_SBTVD, AL_RECTYPE_DVBNETWORK, &stRootNet, AL_DB_INVALIDHDL, &hParentHdl);
        }
      
        dvb_printf("[%s]Get parent network handle: 0x%02x\n", __FUNCTION__, hParentHdl);
        AL_DB_AddRecord(eDBType, AL_RECTYPE_DVBMULTIPLEX, &stTSInfo, hParentHdl, &hTp);

        // 4. add service to database
        memset(&stServInfo, 0, sizeof(AL_ServiceDetail_t));

#ifdef NEW_FONT
		al_uint32 u32CodePage = 0xff;
		al_uint8 *pExtText = al_null;
		al_int32 i32Len = 0;

		i32Len = DB_DVB_MAX_CHNAME_LEN;
		AL_Event_GetCodePage(&u32CodePage, srvbuf[sindex].pucname, &i32Len);
		if (u32CodePage == 0xff)
		{
			AL_Event_GetDefaultCodePage(&u32CodePage);
		}
		pExtText = UNI_StringToUtf8(u32CodePage, srvbuf[sindex].pucname, &i32Len, FALSE);
		memset(srvbuf[sindex].pucname, 0, DB_DVB_MAX_CHNAME_LEN);
		i32Len = i32Len < DB_DVB_MAX_CHNAME_LEN? i32Len : DB_DVB_MAX_CHNAME_LEN -1;
		memcpy(srvbuf[sindex].pucname, pExtText, i32Len);//service name
		//printf("[%s:%d] u32CodePage : %d, u32Len: %d\n",__FUNCTION__,__LINE__, u32CodePage, i32Len);
		free(pExtText);
		pExtText = al_null;
#endif

		memcpy(stServInfo.stSBTVDServ.szProgName, srvbuf[sindex].pucname, DB_DVB_MAX_CHNAME_LEN - 1);
        stServInfo.stSBTVDServ.usOrigNetId = srvbuf[sindex].usOrgNetId;
        stServInfo.stSBTVDServ.usServiceId = srvbuf[sindex].usServiceId;
        stServInfo.stSBTVDServ.usTsId = srvbuf[sindex].usTsId;
        stServInfo.stSBTVDServ.usProgNo = srvbuf[sindex].usProgNum;

        AL_Serv_SearchKey_t stSearchKey;
        memset(&stSearchKey, 0, sizeof(AL_Serv_SearchKey_t));
        stSearchKey.eDBType = eDBType;
        stSearchKey.eRecType = AL_RECTYPE_DVBMULTIPLEX;
        stSearchKey.u32Frequency = srvbuf[sindex].uiFreq;
        stSearchKey.eSearchField = AL_SRV_SEARCHFIELD_FREQ;
        AL_DB_SearchRecords((AL_DB_RecordMatchFunc)AL_Serv_MatchRecBySearchKey,
                            (al_void *)&stSearchKey, eDBType, AL_RECTYPE_DVBMULTIPLEX, 1, 0, al_null, al_null, &hParentHdl);
        dvb_printf("[%s]Get parent multiplex handle: 0x%02x\n", __FUNCTION__, hParentHdl);
        AL_DB_AddRecord(eDBType, srvbuf[sindex].ucServiceType, &stServInfo, hParentHdl, &hProg);
    }

    SAFE_FREE(srvbuf);
    SAFE_FREE(srvnamebuf);

    if (num)
    {
        //SORT_PARA stSortPara;
        UINT8 bLcnOnOff;

        bLcnOnOff = 0;
        AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_SYSINFO, 0,
                        sizeof(APP_SETTING_SystemInfo_t), &(g_stSysInfoData));
        bLcnOnOff = g_stSysInfoData.LcnOnOff;
        if (bLcnOnOff == LCN_ON)
        {
            AL_DB_SortRecords(eDBType, AL_RECTYPE_DVBTV, AL_DB_SORTBY_SERVTYPE, al_true);
            AL_DB_SortRecords(eDBType, AL_RECTYPE_DVBRADIO, AL_DB_SORTBY_SERVTYPE, al_true);
        }
    }
}
#endif

static AL_RecHandle_t _DVBApp_GetNextAvailableServiceEx(AL_DB_EDBType_t eNetType,AL_DB_ERecordType_t eServiceType,AL_RecHandle_t Hprog)
{
    AL_RecHandle_t hNextProgHdl = AL_DB_INVALIDHDL;
    AL_DB_ERecordType_t eRecType;
    AL_DB_EDBType_t eDBType;
    AL_RecHandle_t hCurTPHdl = Hprog;
    DBServAttrib_t stAttribute;
    AL_DB_GetRecord(AL_DB_REQ_GETPARENT, eNetType, AL_RECTYPE_DVBMULTIPLEX, &hCurTPHdl);
    hNextProgHdl = AL_DB_INVALIDHDL;
    while (AL_SUCCESS == AL_DB_GetChildRecord(hCurTPHdl, &hNextProgHdl)
       && hNextProgHdl != AL_DB_INVALIDHDL)
	{
		AL_DB_GetRecordType(hNextProgHdl, &eDBType, &eRecType);
        memset(&stAttribute, 0, sizeof(DBServAttrib_t));
        AL_DB_QueryDetailFieldByName(hNextProgHdl, (al_uint8 *)"stProgAttrib", (al_void *)&stAttribute);
		if((eRecType==eServiceType)&&(stAttribute.unStable == al_false)&&(stAttribute.delete== al_false)
			&& (stAttribute.notvisible == al_false))
		{
			return hNextProgHdl;
		}
	}
    if(hNextProgHdl!=AL_DB_INVALIDHDL)
    {
        dvb_printf("Get Next Service Successfully!\n");
    }
    else
    {
        dvb_printf("Get Next Service Failed!\n");
    }
    return hNextProgHdl;
}

AL_RecHandle_t DVBApp_GetNextAvailableService(AL_DB_EDBType_t eNetType,AL_DB_ERecordType_t eServiceType,AL_RecHandle_t hCurrProgHdl)
{
    AL_RecHandle_t hNextProgHdl = AL_DB_INVALIDHDL;
    hNextProgHdl = _DVBApp_GetNextAvailableServiceEx(eNetType,eServiceType,hCurrProgHdl);
    if(hNextProgHdl == AL_DB_INVALIDHDL)
    {
        if(eServiceType == AL_RECTYPE_DVBTV)
        {
            eServiceType = AL_RECTYPE_DVBRADIO;
            hNextProgHdl = _DVBApp_GetNextAvailableServiceEx(eNetType,eServiceType,hCurrProgHdl);
            if(hNextProgHdl == AL_DB_INVALIDHDL)
            {
                eServiceType = AL_RECTYPE_DVBDATA;
                hNextProgHdl = _DVBApp_GetNextAvailableServiceEx(eNetType,eServiceType,hCurrProgHdl);
                if(hNextProgHdl == AL_DB_INVALIDHDL)
                {
                    dvb_printf("DATABASE Empty!!!\n\n");
                }
            }
        }
        else if(eServiceType == AL_RECTYPE_DVBRADIO)
        {
            eServiceType = AL_RECTYPE_DVBTV;
            hNextProgHdl = _DVBApp_GetNextAvailableServiceEx(eNetType,eServiceType,hCurrProgHdl);
            if(hNextProgHdl == AL_DB_INVALIDHDL)
            {
                eServiceType = AL_RECTYPE_DVBDATA;
                hNextProgHdl = _DVBApp_GetNextAvailableServiceEx(eNetType,eServiceType,hCurrProgHdl);
                if(hNextProgHdl == AL_DB_INVALIDHDL)
                {
                    dvb_printf("DATABASE Empty!!!\n\n");
                }
            }
        }
        else
        {
            eServiceType = AL_RECTYPE_DVBTV;
            hNextProgHdl = _DVBApp_GetNextAvailableServiceEx(eNetType,eServiceType,hCurrProgHdl);
            if(hNextProgHdl == AL_DB_INVALIDHDL)
            {
                eServiceType = AL_RECTYPE_DVBRADIO;
                hNextProgHdl = _DVBApp_GetNextAvailableServiceEx(eNetType,eServiceType,hCurrProgHdl);
                if(hNextProgHdl == AL_DB_INVALIDHDL)
                {
                    dvb_printf("DATABASE Empty!!!\n\n");
                }
            }
        }
    }
    if(hNextProgHdl == AL_DB_INVALIDHDL)
	{
        dvb_printf("\n!!!!!!!!!DVBApp_GetNextAvailableService Failed!!!\n\n");
    }
    else
    {
        dvb_printf("\n!!!!!!!!!DVBApp_GetNextAvailableService Successfully!!!\n\n");
    }
    return hNextProgHdl;
}

void DVBApp_RemoveUnstableService(void)
{
	AL_RecHandle_t hCurrProgHdl = AL_DB_INVALIDHDL;
	AL_RecHandle_t hNextProgHdl = AL_DB_INVALIDHDL;
	AL_RecHandle_t hPrevProgHdl = AL_DB_INVALIDHDL;
	AL_RecHandle_t hServHdl = AL_DB_INVALIDHDL;
	AL_RecHandle_t hCurrTpHdl = AL_DB_INVALIDHDL;
	AL_DB_EDBType_t eNetType = APP_DVB_Playback_GetCurrentNetType();
	AL_DB_ERecordType_t eServiceType = APP_DVB_Playback_GetCurrServiceType(eNetType);
	DBServAttrib_t stAttribute;
	al_uint16	usTsId = 0xffff;
	al_uint16	usOrigNetId = 0xffff;
	al_uint16	usServiceId = 0xffff;
	APP_DVB_Playback_GetCurrServiceType(eNetType);
	//add for Background scan fail will show DATABASE_EMPTY begin
	bool g_bScanSuccessFlag = FALSE;
	hCurrProgHdl = APP_DVB_Playback_GetCurrentProgHandle(eNetType,eServiceType);
	hCurrTpHdl = hCurrProgHdl;
	AL_DB_GetRecord(AL_DB_REQ_GETPARENT, eNetType, AL_RECTYPE_DVBMULTIPLEX, &hCurrTpHdl);
	hServHdl = AL_DB_INVALIDHDL;
	while (AL_SUCCESS == AL_DB_GetChildRecord(hCurrTpHdl, &hServHdl)
		&& hServHdl != AL_DB_INVALIDHDL)
	{
		memset(&stAttribute, 0, sizeof(DBServAttrib_t));
		if(AL_SUCCESS != AL_DB_QueryDetailFieldByName(hServHdl, (al_uint8 *)"stProgAttrib", (al_void *)&stAttribute))
		{
			continue;
		}
		if(stAttribute.delete == al_true)
		{
			continue;
		}
		if(stAttribute.unStable == al_false)// Background scan SUCCESS
		{
			g_bScanSuccessFlag = al_true;
			break;
		}
	}
	if(g_bScanSuccessFlag == al_false)
	{
		printf("[%s:%d] background scan failed\n",__FUNCTION__,__LINE__);
		hServHdl = AL_DB_INVALIDHDL;
		while (AL_SUCCESS == AL_DB_GetChildRecord(hCurrTpHdl, &hServHdl)
			&& hServHdl != AL_DB_INVALIDHDL)
		{
			memset(&stAttribute, 0, sizeof(DBServAttrib_t));
			if(AL_SUCCESS != AL_DB_QueryDetailFieldByName(hServHdl, (al_uint8 *)"stProgAttrib", (al_void *)&stAttribute))
			{
				continue;
			}
			if(stAttribute.unStable == al_true)
			{
				stAttribute.unStable = al_false;
			}
			AL_DB_UpdateDetailFieldByName(hServHdl, (al_uint8 *)"stProgAttrib", (al_void *)&stAttribute);
		}

		SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_DVB,
			DVB_GUIOBJ_PLAYBACK,APP_DVB_INTRA_EVENT_START_PLAYBACK,0);
		return; // if Background scan fail,don't remove Prog
	}
	//add for Background scan fail will show DATABASE_EMPTY end

	hCurrProgHdl = APP_DVB_Playback_GetCurrentProgHandle(eNetType,eServiceType);
	hCurrTpHdl = hCurrProgHdl;
	memset(&stAttribute, 0, sizeof(DBServAttrib_t));
	AL_DB_QueryDetailFieldByName(hCurrProgHdl, (al_uint8 *)"stProgAttrib", (al_void *)&stAttribute);
	if (stAttribute.unStable == al_true)
	{
		hNextProgHdl = DVBApp_GetNextAvailableService(eNetType,eServiceType,hCurrProgHdl);
	}
    AL_DB_GetRecord(AL_DB_REQ_GETPARENT, eNetType, AL_RECTYPE_DVBMULTIPLEX, &hCurrTpHdl);

    {
    	hServHdl = AL_DB_INVALIDHDL;
        hPrevProgHdl = APP_DVB_Playback_GetPrevProg(eNetType);
    	while (AL_SUCCESS == AL_DB_GetChildRecord(hCurrTpHdl, &hServHdl)
    	    && hServHdl != AL_DB_INVALIDHDL)
    	{
    	    memset(&stAttribute, 0, sizeof(DBServAttrib_t));
    		if(AL_SUCCESS != AL_DB_QueryDetailFieldByName(hServHdl, (al_uint8 *)"stProgAttrib", (al_void *)&stAttribute))
    	    {
    			continue;
    	    }

	      if ((AL_SUCCESS != AL_DB_QueryDetailFieldByName(hServHdl, (al_uint8 *)"usTsId", (al_void *)&usTsId))
			|| (AL_SUCCESS != AL_DB_QueryDetailFieldByName(hServHdl, (al_uint8 *)"usOrigNetId", (al_void *)&usOrigNetId))
			|| (AL_SUCCESS != AL_DB_QueryDetailFieldByName(hServHdl, (al_uint8 *)"usServiceId", (al_void *)&usServiceId)))
		{
			printf("Get service info failed!!!\n");
		}
    	    if(stAttribute.unStable == al_true)
    		{
			if (AL_DB_RemoveRecord(hServHdl) == AL_SUCCESS)
			{
				AL_Event_UnLockChannels(AL_DBTYPE_DVB_SBTVD, usOrigNetId, usTsId, usServiceId);
			}
			else
			{
				printf("remove service failed!!!\n");
			}
                if(hPrevProgHdl != AL_DB_INVALIDHDL)
                {
    				if(hServHdl == hPrevProgHdl)
                    {
                        APP_DVB_Playback_SetPrevProg(eNetType,AL_DB_INVALIDHDL);
                        hPrevProgHdl = AL_DB_INVALIDHDL;
                    }
                }
                hServHdl = AL_DB_INVALIDHDL;
    	    }
    	}
	}

	//LCN_FreeLCNConflict();
	//LCN_FreeTRNDDictionary();
	APP_DVB_ChannelOrderChecking();
	APP_DVB_DataSavingToDB(eNetType);
#ifdef CONFIG_SUPPORT_PVR
	if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_FILEPLAY))
	{
		if ((hNextProgHdl != AL_DB_INVALIDHDL) &&
			(hNextProgHdl != hCurrProgHdl))
		{
			AL_DB_GetRecordType(hNextProgHdl, &eNetType, &eServiceType);
			APP_DVB_Playback_SetCurrentProgHandle(eNetType, eServiceType, hNextProgHdl);
			APP_DVB_Playback_SetCurrServiceType(eNetType,eServiceType);
		}
		dvb_printf("===lxl test %s is called. now PVR is playing ===\n", __FUNCTION__);
		return;
	}
#endif

	if ((hNextProgHdl != AL_DB_INVALIDHDL) &&
		(hNextProgHdl != hCurrProgHdl))
	{
	    _DVBApp_Zapping(eServiceType, hNextProgHdl, TRUE, 0, TRUE);
	}
	else
	{
		SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_DVB,
			DVB_GUIOBJ_PLAYBACK,APP_DVB_INTRA_EVENT_START_PLAYBACK,0);
	}

}

static void _DVBApp_SimulcaseDispose(UINT32 u32Param)
{
	AL_RecHandle_t hProgHdl = AL_DB_INVALIDHDL;
	AL_RecHandle_t hCurrProgHdl = AL_DB_INVALIDHDL;
	AL_RecHandle_t hCurrTpHdl = AL_DB_INVALIDHDL;
	AL_RecHandle_t hServHdl = AL_DB_INVALIDHDL;
	AL_DB_EDBType_t eNetType = APP_DVB_Playback_GetCurrentNetType();
	AL_DB_ERecordType_t eServiceType = APP_DVB_Playback_GetCurrServiceType(eNetType);
	al_bool bPlay = al_false;
	al_uint16	usTsId = 0xffff;
	al_uint16	usOrigNetId = 0xffff;
	al_uint16	usServiceId = 0xffff;

	hProgHdl = (AL_RecHandle_t)u32Param;

	APP_DVB_Playback_GetCurrServiceType(eNetType);
	hCurrProgHdl = APP_DVB_Playback_GetCurrentProgHandle(eNetType,eServiceType);
	if (hCurrProgHdl == hProgHdl)
	{
		hCurrTpHdl = hCurrProgHdl;
		AL_DB_GetRecord(AL_DB_REQ_GETPARENT, eNetType, AL_RECTYPE_DVBMULTIPLEX, &hCurrTpHdl);
		while (AL_SUCCESS == AL_DB_GetChildRecord(hCurrTpHdl, &hServHdl))
		{
			if ((hServHdl == AL_DB_INVALIDHDL) || (hServHdl == hProgHdl))
			{
				continue;
			}
			bPlay = al_true;
			_DVBApp_Zapping(eServiceType, hServHdl, TRUE, 0, TRUE);
		}

		if (!bPlay)
		{
			if ((AL_SUCCESS == AL_DB_GetRecord(AL_DB_REQ_GETFIRST, eNetType, eServiceType, &hServHdl))
				&& (hServHdl != AL_DB_INVALIDHDL))
			{
				if (hServHdl == hProgHdl)
				{
					if (AL_SUCCESS == AL_DB_GetRecord(AL_DB_REQ_GETNEXT, eNetType, eServiceType, &hServHdl))
					{
						_DVBApp_Zapping(eServiceType, hServHdl, TRUE, 0, TRUE);
					}
					else
					{
						SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PLAYBACK,
							APP_DVB_INTRA_EVENT_STOP_PLAYBACK, PLAYBACK_STOP_ALL);
					}
				}
				else
				{
					_DVBApp_Zapping(eServiceType, hServHdl, TRUE, 0, TRUE);
				}
			}
			else
			{
				SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PLAYBACK,
					APP_DVB_INTRA_EVENT_STOP_PLAYBACK, PLAYBACK_STOP_ALL);
			}
		}
	}

	if ((AL_SUCCESS != AL_DB_QueryDetailFieldByName(hProgHdl, (al_uint8 *)"usTsId", (al_void *)&usTsId))
		|| (AL_SUCCESS != AL_DB_QueryDetailFieldByName(hProgHdl, (al_uint8 *)"usOrigNetId", (al_void *)&usOrigNetId))
		|| (AL_SUCCESS != AL_DB_QueryDetailFieldByName(hProgHdl, (al_uint8 *)"usServiceId", (al_void *)&usServiceId)))
	{
		printf("Get service info failed!!!\n");
	}

	if (AL_DB_RemoveRecord(hProgHdl) == AL_SUCCESS)
	{
		AL_Event_UnLockChannels(eNetType, usOrigNetId, usTsId, usServiceId);
	}
	else
	{
		printf("remove service failed!!!\n");
	}
	APP_DVB_DataSavingToDB(eNetType);
}

static void _DVBApp_ServiceMove(void)
{
	UINT16 u16CurServiceId = 0;
	AL_PsiMon_NewSrvPosition_t stNewLoction;
	UINT16 i = 0;
	UINT16 u16TpNumber = 0;
	UINT16 u16TsId = 0;
	AL_RecHandle_t itphdl = AL_DB_INVALIDHDL;
	AL_RecHandle_t hProg = AL_DB_INVALIDHDL;
	AL_MultiplexDetail_t stTSInfo;
	AL_DB_EDBType_t eNetType = AL_DBTYPE_MAX;
	AL_ServiceDetail_t stServInfo;
	APP_Source_Type_t eSourType = APP_SOURCE_MAX;
	AL_DB_ERecordType_t service_type = AL_RECTYPE_MAX;

	APP_GUIOBJ_Source_GetCurrSource(&eSourType);
	APP_Database_GetCurrentDBType(eSourType, &eNetType);

	memset(&stServInfo, 0, sizeof(AL_ServiceDetail_t));
	memset(&stTSInfo, 0, sizeof(AL_MultiplexDetail_t));

	hProg = APP_DVB_Playback_GetCurrentProgHandle(eNetType, (AL_RECTYPE_DVBTV |AL_RECTYPE_DVBRADIO|AL_RECTYPE_DVBDATA));

	AL_DB_QueryDetail(hProg, (al_void *)&stServInfo);

	u16CurServiceId = stServInfo.stSBTVDServ.usServiceId;

	AL_PSI_Monitor_GetNewSrvPosition(&stNewLoction);

	if (u16CurServiceId != stNewLoction.usOldServiceId)
	{
		//the program has changed, no need to do anything
		return;
	}

	AL_DB_GetRecordsTotalNum(eNetType, AL_RECTYPE_DVBMULTIPLEX, (al_uint32 *)&u16TpNumber);

	for (i = 0; i < u16TpNumber; i++)
	{
		APP_Database_GetHandleByIndex(eNetType, AL_RECTYPE_DVBMULTIPLEX, i, &itphdl);
		AL_DB_QueryDetail(itphdl, (al_void *)&stTSInfo);

		u16TsId = stTSInfo.stSBTVDMultiplex.usTsId;

		if(stNewLoction.usTsId == u16TsId)
		{
			break;
		}
	}

	if (i == u16TpNumber)
	{
		return;
	}

	if (APP_DVB_ProgMgr_Query(&service_type, &hProg,
		stNewLoction.usOrgNetId, stNewLoction.usTsId, stNewLoction.usServiceId) == AL_SUCCESS)
	{
		//the service will be remove after remove procedure
	}
	else
	{
		stServInfo.stSBTVDServ.usOrigNetId = stNewLoction.usOrgNetId;
		stServInfo.stSBTVDServ.usTsId = stNewLoction.usTsId;
		stServInfo.stSBTVDServ.usServiceId = stNewLoction.usServiceId;
		AL_DB_UpdateDetailField(hProg, FIELD_OFFSET(SSBTVDDBServInfo_t, usOrigNetId),
			FIELD_SIZEOF(SSBTVDDBServInfo_t, usOrigNetId), (al_void *)&(stNewLoction.usOrgNetId));
		AL_DB_UpdateDetailField(hProg, FIELD_OFFSET(SSBTVDDBServInfo_t, usTsId),
			FIELD_SIZEOF(SSBTVDDBServInfo_t, usTsId), (al_void *)&(stNewLoction.usTsId));
		AL_DB_UpdateDetailField(hProg, FIELD_OFFSET(SSBTVDDBServInfo_t, usServiceId),
			FIELD_SIZEOF(SSBTVDDBServInfo_t, usServiceId), (al_void *)&(stNewLoction.usServiceId));
		service_type = g_stTVInfoData.SBTVD_ServType;

		hProg = APP_DVB_Playback_GetCurrentProgHandle(eNetType, service_type);
	}

	APP_DVB_Playback_SetNextServiceType(service_type);
	SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_DVB, APP_DVB_GLOBAL_EVENT_ZAPPING|PASS_TO_SYSAPP, hProg);
}

#ifdef MP4_SUB_PREFER_LANG
static void  _DVBApp_SetMp4SubcodepagebyPreferLang(void)
{
    int dret = 0;
    LANGName_t eMp4SubCodePage = 0;
    eMp4SubCodePage = Dvb_GetCurMP4FontCodePage(Dvb_GetCurMP4CodePageType(NULL), NULL);
    dret = FMW_SetSUBTOSDCodePage((int)eMp4SubCodePage);
    return ;
}
#endif

static INT32 _DVBApp_BackgroundMonitor_Init(void)
{
	MID_Status_t ret = MID_ERR_FAILURE;
#if defined(CONFIG_SUPPORT_OTA_UPGRADE)
	OtaMonComCallback_t callback;
	callback._pfMonDSICallbk = APP_DVB_OTACallback;
	callback._pfMonONIDCallb = APP_DVB_CheckIsONIDMatched;
	callback._pfMonEXITCallb = APP_DVB_OTAMonExitCallback;
	callback._pfMonStateCallbk = APP_DVB_NotifyOTAState;
	ret = MID_OtaMonInit(callback);
	if (MID_OTA_OtaMonThreadDataMutexCreate() == GL_SUCCESS)
	{
		MID_OTA_GetOTAInitInfo_FromFlah();
		dvb_printf("Ota Mutex Create success \n");
#ifdef CONFIG_SUPPORT_SSU_ENHANCE_UPGRADE
		MID_OtaMonUntInit(APP_DVB_OTASECallback);
#endif
	}
	else
	{
		dvb_printf("Ota Mutex Create Failed \n");
	}

	if (MID_SUCCESS != ret)
	{
		return SP_ERR_FAILURE;
	}
#endif

    if (MID_SUCCESS != ret)
    {
        return SP_ERR_FAILURE;
    }

    return SP_SUCCESS;
}

static void _DVBApp_EpgInit(void)
{
    UINT8 u8SysSet;
    AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FEATURE, 0,
                    sizeof(APP_SETTING_Feature_t), &(g_stFeatureData));
    u8SysSet = g_stFeatureData.DigitalTTLang;
    APP_DVB_EPG_SetEpgLanguage(u8SysSet);
    AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_CHANNEL, 0,
                    sizeof(APP_SETTING_Channel_t), &(g_stChannelData));
    u8SysSet = g_stChannelData.Country;
    if (u8SysSet >= MAX_AREA)
    {
        u8SysSet = 0;
    }
    AL_Event_SetCountryCode(APP_Area_GetCountryCode(u8SysSet));
#ifdef CONFIG_DVB_SYSTEM
    if (APP_Area_SupportDtg())
    {
        AL_Event_SetDTGSupport(al_true);
    }
    else
#endif
    {
        AL_Event_SetDTGSupport(al_false);
    }

}

static al_bool _DVBApp_SerMatch(al_void const *pRec, al_void const *pRecToAdd)
{
    bool matchFlag = FALSE;
    al_uint8 area = 0;
    AL_ServiceDetail_t *ServInfor = (AL_ServiceDetail_t *)pRec;
    AL_ServiceDetail_t *AddServInfor = (AL_ServiceDetail_t *)pRecToAdd;
    AL_DB_EDBType_t eDBType = AL_DBTYPE_MAX;
    APP_Database_GetCurrentDBType(APP_SOURCE_DTV, &eDBType);

    AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_CHANNEL, 0,
                    sizeof(APP_SETTING_Channel_t), &(g_stChannelData));
    area = g_stChannelData.Country;

#ifdef SUPPORT_DELETE_SAME_SERVICES
    int u16DeleteSameServices = 0;//0: default(expect: Russia need save same services)  1: on(keep current method)  2: off(save same services)
    AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FACTUSER, 0,
		sizeof(APP_SETTING_FactoryUser_t), &(g_stFactoryUserData));
    u16DeleteSameServices = g_stFactoryUserData.Function.n_Funct_DeleteSameServices;
    if (2 == u16DeleteSameServices)// 2: save same services
    {
        matchFlag = 0;
    }
    else
#endif
    {

    	switch (area)
	    {
	        default:
	            matchFlag = ((ServInfor->stSBTVDServ.usOrigNetId == AddServInfor->stSBTVDServ.usOrigNetId)
	                         && (ServInfor->stSBTVDServ.usServiceId == AddServInfor->stSBTVDServ.usServiceId)
	                         && (ServInfor->stSBTVDServ.usTsId == AddServInfor->stSBTVDServ.usTsId)
	                         && (ServInfor->stSBTVDServ.eTvRadioType == AddServInfor->stSBTVDServ.eTvRadioType));
			    break;
	    }
    }

	if (matchFlag)
	{
		FW_DEBF("[%s:%d] matchFlag @@@@@@@@@@@@@@@@@@@@@@@@@\n",__FUNCTION__,__LINE__);
		FW_DEBF("[%s:%d] usOrigNetId: %d, %d; usServiceId: %d, %d; usTsId: %d, %d; eTvRadioType: %d, %d\n",
			__FUNCTION__,__LINE__,ServInfor->stSBTVDServ.usOrigNetId, AddServInfor->stSBTVDServ.usOrigNetId,
			ServInfor->stSBTVDServ.usServiceId, AddServInfor->stSBTVDServ.usServiceId,
			ServInfor->stSBTVDServ.usTsId, AddServInfor->stSBTVDServ.usTsId,
			ServInfor->stSBTVDServ.eTvRadioType, AddServInfor->stSBTVDServ.eTvRadioType);
		FW_DEBF("[%s:%d] usDataPID: %d, %d; usStrmID: %d, %d; usStrmID: %d, %d; usECMPID: %d, %d; usCompTag: %d, %d \n",
			__FUNCTION__,__LINE__,ServInfor->stSBTVDServ.stVideoPid.usDataPID, AddServInfor->stSBTVDServ.stVideoPid.usDataPID,
			ServInfor->stSBTVDServ.stVideoPid.usStrmID, AddServInfor->stSBTVDServ.stVideoPid.usStrmID,
			ServInfor->stSBTVDServ.stVideoPid.usCodec, AddServInfor->stSBTVDServ.stVideoPid.usCodec,
			ServInfor->stSBTVDServ.stVideoPid.usECMPID, AddServInfor->stSBTVDServ.stVideoPid.usECMPID,
			ServInfor->stSBTVDServ.stVideoPid.usCompTag, AddServInfor->stSBTVDServ.stVideoPid.usCompTag);
		FW_DEBF("[%s:%d] usPcrPid: %d, %d; stAudioPid[0].usDataPID: %d, %d; stAudioPid[1].usDataPID: %d, %d; stAudioPid[2].usDataPID: %d, %d\n",
			__FUNCTION__,__LINE__,ServInfor->stSBTVDServ.usPcrPid, AddServInfor->stSBTVDServ.usPcrPid,
			ServInfor->stSBTVDServ.stAudioPid[0].usDataPID, AddServInfor->stSBTVDServ.stAudioPid[0].usDataPID,
			ServInfor->stSBTVDServ.stAudioPid[1].usDataPID, AddServInfor->stSBTVDServ.stAudioPid[1].usDataPID,
			ServInfor->stSBTVDServ.stAudioPid[2].usDataPID, AddServInfor->stSBTVDServ.stAudioPid[2].usDataPID);
	}

    return matchFlag;
}

static al_bool _DVBApp_TPMatch_ISBD(al_void const *pRecToAdd, al_void *pRec)
{
	AL_MultiplexDetail_t *TPInfor = (AL_MultiplexDetail_t *)pRec;
	AL_MultiplexDetail_t *AddTPInfor = (AL_MultiplexDetail_t *)pRecToAdd;

    return ((TPInfor->stSBTVDMultiplex.usOrigNetId == AddTPInfor->stSBTVDMultiplex.usOrigNetId)
			&& (TPInfor->stSBTVDMultiplex.usTsId == AddTPInfor->stSBTVDMultiplex.usTsId)
			&& (TPInfor->stSBTVDMultiplex.uiFreqK == AddTPInfor->stSBTVDMultiplex.uiFreqK)
#ifdef SUPPORT_HIERARCHY_MODE
			&& (TPInfor->stSBTVDMultiplex.ucHierarchyMode == AddTPInfor->stSBTVDMultiplex.ucHierarchyMode)
#endif
	);
}

static al_bool _DVBApp_NetworkMatch_ISDB(al_void const *pRecToAdd, al_void *pRec)
{
	AL_NetworkDetail_t *NetInfor = (AL_NetworkDetail_t *)pRec;
	AL_NetworkDetail_t *AddNetInfor = (AL_NetworkDetail_t *)pRecToAdd;

	return (NetInfor->stSBTVDNetwork.usNetId == AddNetInfor->stSBTVDNetwork.usNetId);
}

#ifdef SUPPORT_FACTORY_AUTO_TEST
static void _DVBApp_PrestoreProgram(AL_DB_EDBType_t eDBType)
{
	AL_Return_t enRet = AL_SUCCESS;
	NOT_USED(enRet);
	static AL_RecHandle_t hNetHdl = AL_DB_INVALIDHDL;
	AL_NetworkDetail_t stRootNet;
	AL_RecHandle_t hProg1 = AL_DB_INVALIDHDL;
	AL_RecHandle_t hProg2 = AL_DB_INVALIDHDL;
	AL_RecHandle_t hTp = AL_DB_INVALIDHDL;
	AL_MultiplexDetail_t ts;
	AL_ServiceDetail_t Program;

	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);
	AL_PR_DeleteAllSch(AL_DBTYPE_DVB_SBTVD,AL_PR_EVT_REM | AL_PR_SRV_REM);

   //dvb -t
	hNetHdl = AL_DB_INVALIDHDL;
	hTp = AL_DB_INVALIDHDL;
	stRootNet.stSBTVDNetwork.usNetId = 1;
	memcpy(stRootNet.stSBTVDNetwork.szNetName, "Dummy", 6);
	enRet = AL_DB_AddRecord(AL_DBTYPE_DVB_SBTVD, AL_RECTYPE_DVBNETWORK, &stRootNet, AL_DB_INVALIDHDL, &hNetHdl);
	memset(&ts, 0, sizeof(AL_MultiplexDetail_t));
	ts.stSBTVDMultiplex.uiFreqK = 474000;
	ts.stSBTVDMultiplex.ucBandwidth = 8;
	ts.stSBTVDMultiplex.ucHierarchyMode = FRONTEND_HIERARCHY_AUTO;
	AL_DB_AddRecord(AL_DBTYPE_DVB_SBTVD, AL_RECTYPE_DVBMULTIPLEX, &ts, hNetHdl, &hTp);

	memset(&Program, 0, sizeof(AL_ServiceDetail_t));
	Program.stSBTVDServ.eSDTSrvType = AL_RECTYPE_DVBTV;
	Program.stSBTVDServ.eTvRadioType= AL_RECTYPE_DVBTV;
	Program.stSBTVDServ.szProgName[0] = 0;
	Program.stSBTVDServ.usOrigNetId = 0x2222;
	Program.stSBTVDServ.usServiceId = 0x2222;
	Program.stSBTVDServ.usTsId = 0x2222;
	Program.stSBTVDServ.usProgNo = 0x1;
	Program.stSBTVDServ.usPMTPid= 0x1F55;
	Program.stSBTVDServ.stVideoPid.usDataPID = 0x1F40;
	Program.stSBTVDServ.stAudioPid[0].usDataPID= 0x1F41;
	enRet = AL_DB_AddRecord(AL_DBTYPE_DVB_SBTVD, AL_RECTYPE_DVBTV,
		&Program, hTp, &hProg1);

	memset(&ts, 0, sizeof(AL_MultiplexDetail_t));
	ts.stSBTVDMultiplex.uiFreqK = 666000;
	ts.stSBTVDMultiplex.ucBandwidth = 8;
	ts.stSBTVDMultiplex.ucHierarchyMode = FRONTEND_HIERARCHY_AUTO;
	AL_DB_AddRecord(AL_DBTYPE_DVB_SBTVD, AL_RECTYPE_DVBMULTIPLEX, &ts, hNetHdl, &hTp);

	memset(&Program, 0, sizeof(AL_ServiceDetail_t));
	Program.stSBTVDServ.eSDTSrvType = AL_RECTYPE_DVBTV;
	Program.stSBTVDServ.eTvRadioType= AL_RECTYPE_DVBTV;
	Program.stSBTVDServ.szProgName[0] = 0;
	Program.stSBTVDServ.usOrigNetId = 0x0000;
	Program.stSBTVDServ.usServiceId = 0x0001;
	Program.stSBTVDServ.usTsId = 0x0001;
	Program.stSBTVDServ.usProgNo = 0x2;
	Program.stSBTVDServ.usPMTPid= 0x0080;
	Program.stSBTVDServ.stVideoPid.usDataPID = 0x0064;
	Program.stSBTVDServ.stAudioPid[0].usDataPID= 0x0065;
	enRet = AL_DB_AddRecord(AL_DBTYPE_DVB_SBTVD, AL_RECTYPE_DVBTV,
		&Program, hTp, &hProg2);

	APP_DVB_Playback_SetCurrentRFTypeByNetType(eDBType);
	APP_DVB_Playback_SetCurrServiceType(eDBType, AL_RECTYPE_DVBTV);
	APP_DVB_Playback_SetCurrentProgHandle(AL_DBTYPE_DVB_SBTVD,AL_RECTYPE_DVBTV,hProg1);
	dvb_printf("\nfunction:%s,enRet:%d\n",__FUNCTION__,enRet);
	enRet = enRet;//fix [-Werror=unused-but-set-variable]
}
#endif

static void _DVBApp_SWInit(void)
{
	AL_PR_Init_Param_t Init_param=
	{
		.MaxNumOfReminders = AL_PR_MAX_NO_REMINDERS,
		.app_schd_time[0] = PR_NOTIFY_TIME_IN_SEC,

		/*reserves*/
		.app_schd_time[1] = 0,
		.app_schd_time[2] = 0
	};
	AL_PR_SetInitParam(&Init_param);

	AL_DB_EDBType_t eDBType = AL_DBTYPE_MAX;
	AL_DB_RecDupliChkFunc_t stMatchFuc;
	stMatchFuc.pServMatch = (AL_DB_RecordMatchFunc)_DVBApp_SerMatch;

	stMatchFuc.pNetMatch = (AL_DB_RecordMatchFunc)_DVBApp_NetworkMatch_ISDB;
	stMatchFuc.pMulitplexMatch = (AL_DB_RecordMatchFunc)_DVBApp_TPMatch_ISBD;
	AL_DB_RegisterDupliChkFunc(AL_DBTYPE_DVB_SBTVD, &stMatchFuc);


	APP_Database_GetCurrentDBType(APP_SOURCE_DTV, &eDBType);
    switch (eDBType)
    {
        case AL_DBTYPE_DVB_SBTVD:
            AL_FW_Init(FW_DVB_SBTVD_INIT, NULL, NULL);
            break;
        default:
			AL_FW_Init(FW_DVB_SBTVD_INIT, NULL, NULL);
            break;
    }

#ifndef SUPPORT_LCN_ONOFF
	do {
		UINT8 bLcnSetting, u8AreaIdx;

		AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_SYSINFO, 0,
			sizeof(APP_SETTING_SystemInfo_t), &(g_stSysInfoData));
		bLcnSetting = g_stSysInfoData.LcnOnOff;

		AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_CHANNEL, 0,
			sizeof(APP_SETTING_Channel_t), &(g_stChannelData));
		u8AreaIdx = g_stChannelData.Country;
		u8AreaIdx = u8AreaIdx; // avoid warning error
		if (! (bLcnSetting & LCN_ONOFF_CHANGED))	//mean use the default
		{
			// For the first time boot up, the flash data has not initiated yet
#ifdef SUPPORT_LCN
			APP_Area_GetDefaultAreaInfoLCN(eDBType, u8AreaIdx, &bLcnSetting);
#endif
			g_stSysInfoData.LcnOnOff = bLcnSetting;

			AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_SYSINFO,
				ITEM_OFFSET(APP_SETTING_SystemInfo_t, LcnOnOff),
				sizeof(g_stSysInfoData.LcnOnOff),&(g_stSysInfoData.LcnOnOff));
			AL_Setting_Store(APP_Data_UserSetting_Handle(), SYS_SET_ID_SYSINFO,
				ITEM_OFFSET(APP_SETTING_SystemInfo_t, LcnOnOff), sizeof(g_stSysInfoData.LcnOnOff));
		}

	} while(0);
#endif
	// EPG setup
	_DVBApp_EpgInit();

	UINT32 area = 0;
	AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_CHANNEL, 0,
		sizeof(APP_SETTING_Channel_t), &(g_stChannelData));
	area = g_stChannelData.Country;
	DVBApp_ResetDvbSpecRule(area);

#ifdef SUPPORT_FACTORY_AUTO_TEST
	if(APP_Factory_GetAutoTestOnOff() == TRUE)
	{
		_DVBApp_PrestoreProgram(eDBType);
	}
	else
#endif
	{
		APP_Factory_HotelModePowerOnChan();
	}

#ifdef MP4_SUB_PREFER_LANG
    _DVBApp_SetMp4SubcodepagebyPreferLang();
#endif

    // Monitor init
    if (_DVBApp_BackgroundMonitor_Init() == SP_SUCCESS)
    {
        dvb_printf("_DVBApp_BackgroundMonitor_Init() success\n");
    }
    else
    {
        dvb_printf("_DVBApp_BackgroundMonitor_Init() fail\n");
    }

   // APP_Database_InitListTypeName();

    //AUDIF_Set_OutputMode(OUTPUT_DOWNMIX_MODE, dwmix_L0R0);
    //AUDIF_Set_OutputMode(OUT_RFModeK3, RF_outmode);
    //AUDIF_Set_OutputMode(OUT_CustomModeB_DigitalDialnormK1, 0x6464);
}

static void _DVBApp_DTV_main_program(void *data)
{
	_DVBApp_SWInit();
}

static INT32 _DVBApp_ToggleVideoState(void)
{
	AL_DB_EDBType_t eDBType = APP_DVB_Playback_GetCurrentNetType();
#ifndef PLAY_VIDEO_FOR_ALLSRV
	AL_DB_ERecordType_t eServiceType = APP_DVB_Playback_GetCurrServiceType(eDBType);
#endif
    UINT8 u8ProgState = APP_DVB_Playback_GetProgStateByHandle(eDBType, AL_DB_INVALIDHDL);

    if (MID_PlaybackIsPlaying() == TRUE)
    {
        /*AV is playing, need to stop*/
        if (u8ProgState == MID_PLAYBK_PROG_STATE_LOCKED)
        {
#ifndef PLAY_VIDEO_FOR_ALLSRV
            if (eServiceType == AL_RECTYPE_DVBRADIO)
            {
                SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_DVB,
					DVB_GUIOBJ_PLAYBACK, APP_DVB_INTRA_EVENT_STOP_PLAYBACK,
					(PLAYBACK_STOP_MHEG5 | PLAYBACK_KEEP_FRAMEBUF));
            }
            else
#endif
            {
                SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_DVB,
					DVB_GUIOBJ_PLAYBACK, APP_DVB_INTRA_EVENT_STOP_PLAYBACK,
					(PLAYBACK_STOP_SUBTITLE | PLAYBACK_STOP_MHEG5));
            }
        }
    }
    else
    {
        SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_DVB,
			DVB_GUIOBJ_PLAYBACK, APP_DVB_INTRA_EVENT_START_PLAYBACK, 0);
    }

    return SP_SUCCESS;
}

static void _DVBApp_ShowPopup(DVB_DVBAppPopMsgType_t ePopType)
{
    UINT32 u32GuiObj = 0;
    PopmsgParam_t stPopup;
    AL_DB_EDBType_t eDBType = AL_DBTYPE_MAX;
    APP_Source_Type_t eSourType = APP_SOURCE_MAX;
    AL_ServiceDetail_t stService;

#ifdef CONFIG_QSD //Chip test mode doesn't need to show no signal OSD
	if(ePopType == DVB_APP_POP_MSG_NO_SIGNAL)
	{
		return;
	}
#endif

#if (defined (CONFIG_SUPPORT_PVR) || defined(CONFIG_CONFIRM_AUTO_UPGRADE))
	UINT32 dMsgType = 0;
	APP_GUIOBJ_PopMsg_GetMsgDialogType(&dMsgType);
#endif

#ifdef CONFIG_CONFIRM_AUTO_UPGRADE

	if (dMsgType == POPMSG_CONFIRM_START_AUTO_UPGRADE)
	{
		switch (ePopType)
		{
			case DVB_APP_POP_MSG_RADIO_CHANNEL:
			case DVB_APP_POP_MSG_VIDEO_NOT_SUPPORT:
			case DVB_APP_POP_MSG_SERVICE_NOT_AVAILABLE:
			case DVB_APP_POP_MSG_SCRAMBLE:
			case DVB_APP_POP_MSG_PARENTAL_LOCK:
			case DVB_APP_POP_MSG_NO_SIGNAL:
			case DVB_APP_POP_MSG_TEMPSERVICE:
			case DVB_APP_POP_MSG_CHECKPWD:
			case DVB_APP_POP_MSG_DATABASE_EMPTY:
				dvb_printf("\n\n%d. auto upgrade pop message exist, not display pop message: %d.\n\n", __LINE__, ePopType);
				return;
			default:
				break;

		}
	}
#endif

#ifdef CONFIG_SUPPORT_PVR
	if (dMsgType == POPMSG_CONFIRM_REC_REMIDER_TIME || dMsgType == POPMSG_CONFIRM_REC_REMIDER_TIME_CONFIRM)
	{
		switch (ePopType)
		{
			case DVB_APP_POP_MSG_TEMPSERVICE:
			case DVB_APP_POP_MSG_SERVICE_NOT_AVAILABLE:
			case DVB_APP_POP_MSG_NOT_AVAILABLE:
				dvb_printf("\n\n%d.PVR reminder Pop message exist, not display pop message: %d.\n\n", __LINE__, ePopType);
				return;
			default:
				break;

		}
	}

#endif
    for (u32GuiObj = 0; u32GuiObj < DVB_GUIOBJ_MAX; u32GuiObj++)
    {
        if (u32GuiObj == DVB_GUIOBJ_PLAYBACK
            || u32GuiObj == DVB_GUIOBJ_PROGINFO
            || u32GuiObj == DVB_GUIOBJ_POPMSG
            || u32GuiObj == DVB_GUIOBJ_FREEZE
            || u32GuiObj == APP_GUIOBJ_MUTE
            || u32GuiObj == APP_GUIOBJ_BANNER
            //|| u32GuiObj == APP_GUIOBJ_ADJUST
            //|| u32GuiObj == APP_GUIOBJ_AMPLIFIERVOLUME
#ifdef CONFIG_SUPPORT_ISDB_SUBTITLE
			|| u32GuiObj ==	DVB_GUIOBJ_CC
#endif			
#ifdef CONFIG_SUPPORT_PVR
            || u32GuiObj == DVB_GUIOBJ_PVR_REC
            || u32GuiObj == DVB_GUIOBJ_PVR_PAUSE
            || u32GuiObj == DVB_GUIOBJ_PVR_PLAYINFO
            || u32GuiObj == DVB_GUIOBJ_PVRREC_INFO
            || u32GuiObj == DVB_GUIOBJ_PVR_FILEPLAY
            || u32GuiObj == DVB_GUIOBJ_PVR_FILEPLAYINFO
#endif
           )
        {
            continue;
        }

		if(ePopType == DVB_APP_POP_MSG_OVERMAXVOLUME && u32GuiObj == APP_GUIOBJ_ADJUST)
		{
			continue;
		}

		if (ePopType != DVB_APP_POP_MSG_KEYLOCK)
		{
	        if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, u32GuiObj))
	        {
	            return;
	        }
		}
    }
	if ((SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_POPMSG))
		&&(g_dCurPopup == POPMSG_CONFIRM_FLIP))
	{
		return;
	}

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

    switch (ePopType)
    {
        case DVB_APP_POP_MSG_DATABASE_EMPTY:
            stPopup.eType = POPMSG_TYPE_PROMPT;
            stPopup.u16Exitkeys =  POPMSG_EXIT_KEY_NONE;
            stPopup.u16ReturnType = GUI_OBJECT_EVENT_BYPASS;
            stPopup.extend.stPrompt.ePromptType = PLAYBACK_POPUP_MSG_DATABASE_EMPTY;
            break;

        case DVB_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 DVB_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 DVB_APP_POP_MSG_NOT_AVAILABLE:
            stPopup.eType = POPMSG_TYPE_PROMPT;
            stPopup.u16Exitkeys =  POPMSG_EXIT_KEY_NONE;
            stPopup.u16ReturnType = GUI_OBJECT_EVENT_BYPASS;
            stPopup.extend.stPrompt.ePromptType = POPMSG_PROMPT_NOT_AVAILABLE;
            stPopup.extend.stPrompt.iTimeout = 2;
            break;
        case DVB_APP_POP_MSG_CHECKPWD:
            stPopup.eType = POPMSG_TYPE_PWD;
            stPopup.u16ReturnType = GUI_OBJECT_EVENT_BYPASS;
            stPopup.extend.stPwd.ePwdType = PLAYBACK_POPUP_PWD_LOCKED;
            break;

        case DVB_APP_POP_MSG_TEMPSERVICE:
            stPopup.eType = POPMSG_TYPE_PROMPT;
            stPopup.u16ReturnType = GUI_OBJECT_EVENT_BYPASS;
            APP_Database_GetCurrentDBType(eSourType, &eDBType);
            AL_DB_QueryDetail(APP_DVB_Playback_GetCurrentProgHandle(eDBType,
                  (AL_RECTYPE_DVBTV | AL_RECTYPE_DVBRADIO | AL_RECTYPE_DVBDATA)), (al_void *)&stService);
            if ((AL_DBTYPE_DVB_SBTVD == eDBType) && (1 == stService.stSBTVDServ.stProgAttrib.svrnotrun))
            {
                stPopup.extend.stPrompt.ePromptType = PLAYBACK_POPUP_MSG_TEMPSERVICE_SERVICE_NOT_RUNNING;
            }
            else
            {
                stPopup.extend.stPrompt.ePromptType = PLAYBACK_POPUP_MSG_TEMPSERVICE;
            }
            break;

        case DVB_APP_POP_MSG_NO_SIGNAL:
            stPopup.eType = POPMSG_TYPE_PROMPT;
            stPopup.u16ReturnType = GUI_OBJECT_EVENT_BYPASS;
            stPopup.extend.stPrompt.ePromptType = PLAYBACK_POPUP_MSG_NO_SIGNAL;
            break;

        case DVB_APP_POP_MSG_PARENTAL_LOCK:
            stPopup.eType = POPMSG_TYPE_PWD;
            stPopup.u16ReturnType = GUI_OBJECT_EVENT_BYPASS ;
            stPopup.extend.stPwd.ePwdType = PLAYBACK_POPUP_PWD_LOCKED;
            break;

        case DVB_APP_POP_MSG_SCRAMBLE:
            stPopup.eType = POPMSG_TYPE_PROMPT;
            stPopup.u16ReturnType = GUI_OBJECT_EVENT_BYPASS;
            stPopup.extend.stPrompt.ePromptType = PLAYBACK_POPUP_MSG_SCRAMBLED;
            break;

        case DVB_APP_POP_MSG_SERVICE_NOT_AVAILABLE:
            stPopup.eType = POPMSG_TYPE_PROMPT;
            stPopup.u16ReturnType = GUI_OBJECT_EVENT_BYPASS;
            stPopup.extend.stPrompt.ePromptType = PLAYBACK_POPUP_MSG_SERVICE_NOT_AVAILABLE;
            break;

        case DVB_APP_POP_MSG_NEW_SERVICE:
            stPopup.eType = POPMSG_TYPE_PROMPT;
            stPopup.u16Exitkeys =  POPMSG_EXIT_EXIT;
            stPopup.u16ReturnType = GUI_OBJECT_EVENT_BYPASS;
            stPopup.extend.stPrompt.ePromptType = PLAYBACK_POPUP_PROMPT_ADD_SRV;
            stPopup.extend.stPrompt.iTimeout = 3;
            break;

		case DVB_APP_POP_MSG_SERVICE_REMOVE:
			stPopup.eType = POPMSG_TYPE_CONFIRM;
			stPopup.u16Exitkeys =  POPMSG_EXIT_EXIT;
			stPopup.u16ReturnType= GUI_OBJECT_POST_EVENT|GUI_OBJECT_EVENT_BYPASS ;
			stPopup.extend.stPrompt.ePromptType = PLAYBACK_POPUP_CONFIRM_REMOVE_SRV;
			break;

        case DVB_APP_POP_MSG_OTH_TP_NEW_SERVICE:
            stPopup.eType = POPMSG_TYPE_CONFIRM;
            stPopup.u16Exitkeys =  POPMSG_EXIT_EXIT;
            stPopup.u16ReturnType = GUI_OBJECT_POST_EVENT | GUI_OBJECT_EVENT_BYPASS ;
            stPopup.extend.stPrompt.ePromptType = PLAYBACK_POPUP_PROMPT_OTH_TP_ADD_SRV;
            break;

        case DVB_APP_POP_MSG_VIDEO_NOT_SUPPORT:
            stPopup.eType = POPMSG_TYPE_PROMPT;
            stPopup.u16ReturnType = GUI_OBJECT_EVENT_BYPASS;
            stPopup.extend.stPrompt.ePromptType = PLAYBACK_POPUP_MSG_VIDEO_NOT_SUPPORT;
            break;

        case DVB_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;

#ifdef CONFIG_SUPPORT_PVR
        case DVB_APP_POP_MSG_REC_INIT:
            stPopup.eType = POPMSG_TYPE_PROMPT;
            stPopup.u16Exitkeys =  POPMSG_EXIT_KEY_NONE;
            stPopup.u16ReturnType = GUI_OBJECT_EVENT_BYPASS ;
            stPopup.extend.stPrompt.ePromptType = POPMSG_PROMPT_INITIAL_REC;
            stPopup.extend.stPrompt.iTimeout = 1;
            break;

        case DVB_APP_POP_MSG_TIMESHIFT_INIT:
            stPopup.eType = POPMSG_TYPE_PROMPT;
            stPopup.u16Exitkeys =  POPMSG_EXIT_KEY_NONE;
            stPopup.u16ReturnType = GUI_OBJECT_EVENT_BYPASS ;
            stPopup.extend.stPrompt.ePromptType = POPMSG_PROMPT_INITIAL_TIMESHIFT;
            stPopup.extend.stPrompt.iTimeout = 1;
            break;

        case DVB_APP_POP_MSG_AUTOTIMESHIFT_INIT:
            stPopup.eType = POPMSG_TYPE_PROMPT;
            stPopup.u16Exitkeys =  POPMSG_EXIT_KEY_NONE;
            stPopup.u16ReturnType = GUI_OBJECT_EVENT_BYPASS ;
            stPopup.extend.stPrompt.ePromptType = POPMSG_PROMPT_INITIAL_AUTOTIMESHIFT;
            stPopup.extend.stPrompt.iTimeout = 2;
            break;

        case DVB_APP_POP_MSG_REC_ENTER_NOT_VALID:
            stPopup.eType = POPMSG_TYPE_PROMPT;
            stPopup.u16Exitkeys =  POPMSG_EXIT_KEY_NONE;
            stPopup.u16ReturnType = GUI_OBJECT_EVENT_BYPASS ;
            stPopup.extend.stPrompt.ePromptType = POPMSG_PROMPT_INVALID_REC;
            stPopup.extend.stPrompt.iTimeout = 2;
            break;

        case DVB_APP_POP_MSG_REC_WRITE_ERROR:
            stPopup.eType = POPMSG_TYPE_PROMPT;
            stPopup.u16Exitkeys =  POPMSG_EXIT_KEY_NONE;
            stPopup.u16ReturnType = GUI_OBJECT_EVENT_BYPASS ;
            stPopup.extend.stPrompt.ePromptType = POPMSG_PROMPT_REC_WRITE_ERR;
            stPopup.extend.stPrompt.iTimeout = 2;
            break;

        case DVB_APP_POP_MSG_TIMESHIFT_ENTER_NOT_VALID:
            stPopup.eType = POPMSG_TYPE_PROMPT;
            stPopup.u16Exitkeys =  POPMSG_EXIT_KEY_NONE;
            stPopup.u16ReturnType = GUI_OBJECT_EVENT_BYPASS ;
            stPopup.extend.stPrompt.ePromptType = POPMSG_PROMPT_INVALID_TIMESHIFT;
            stPopup.extend.stPrompt.iTimeout = 2;
            break;

		case DVB_APP_POP_MSG_REC_REQUIRE_FORMAT:
            stPopup.eType = POPMSG_TYPE_PROMPT;
            stPopup.u16Exitkeys =  POPMSG_EXIT_KEY_NONE;
            stPopup.u16ReturnType = GUI_OBJECT_EVENT_BYPASS ;
            stPopup.extend.stPrompt.ePromptType = POPMSG_PROMPT_PVR_REQUIRE_FORMAT_DISK;
            stPopup.extend.stPrompt.iTimeout = 2;
            break;

		case DVB_APP_POP_MSG_REC_PARTITION_NOT_SET:
            stPopup.eType = POPMSG_TYPE_PROMPT;
            stPopup.u16Exitkeys =  POPMSG_EXIT_KEY_NONE;
            stPopup.u16ReturnType = GUI_OBJECT_EVENT_BYPASS ;
            stPopup.extend.stPrompt.ePromptType = POPMSG_PROMPT_PARTITION_NOT_SET;
            stPopup.extend.stPrompt.iTimeout = 2;
            break;

        case DVB_APP_POP_MSG_PVR_DISK_CHECKING:
            stPopup.eType = POPMSG_TYPE_PROMPT;
            stPopup.u16Exitkeys =  POPMSG_EXIT_KEY_NONE;
            stPopup.u16ReturnType = GUI_OBJECT_EVENT_BYPASS ;
            stPopup.extend.stPrompt.ePromptType = POPMSG_PROMPT_DISK_CHECKING;
            stPopup.extend.stPrompt.iTimeout = 2;
            break;

        case DVB_APP_POP_MSG_PVR_DISK_FULL:
            stPopup.eType = POPMSG_TYPE_PROMPT;
            stPopup.u16Exitkeys =  POPMSG_EXIT_KEY_NONE;
            stPopup.u16ReturnType = GUI_OBJECT_EVENT_BYPASS ;
            stPopup.extend.stPrompt.ePromptType = POPMSG_PROMPT_DISK_FULL;
            stPopup.extend.stPrompt.iTimeout = 2;
            break;

        case DVB_APP_POP_MSG_PVR_NO_STORAGE:
            stPopup.eType = POPMSG_TYPE_PROMPT;
            stPopup.u16Exitkeys =  POPMSG_EXIT_KEY_NONE;
            stPopup.u16ReturnType = GUI_OBJECT_EVENT_BYPASS ;
            stPopup.extend.stPrompt.ePromptType = POPMSG_PROMPT_NO_USBCARD_DEVICE;
            stPopup.extend.stPrompt.iTimeout = 2;
            break;
        case DVB_APP_POP_MSG_FOUNDDEVICE:
            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_FOUNDDEVICE;
            stPopup.extend.stPrompt.iTimeout = 2;
            break;

		case DVB_APP_POP_MSG_REC_NTFS_DIRTY:
            stPopup.eType = POPMSG_TYPE_PROMPT;
            stPopup.u16Exitkeys =  POPMSG_EXIT_KEY_NONE;
            stPopup.u16ReturnType = GUI_OBJECT_EVENT_BYPASS ;
            stPopup.extend.stPrompt.ePromptType = POPMSG_PROMPT_PARTITION_SET_NTFS_DIRTY;
            stPopup.extend.stPrompt.iTimeout = 3;
            break;

		case DVB_APP_POP_MSG_REC_SCRAMBLE_CHANNEL:
            stPopup.eType = POPMSG_TYPE_PROMPT;
            stPopup.u16Exitkeys =  POPMSG_EXIT_KEY_NONE;
            stPopup.u16ReturnType = GUI_OBJECT_EVENT_BYPASS ;
            stPopup.extend.stPrompt.ePromptType = POPMSG_PROMPT_INVALID_REC_SCRAMBLE;
            stPopup.extend.stPrompt.iTimeout = 2;
            break;

        case DVB_APP_POP_MSG_REC_START:
            stPopup.eType = POPMSG_TYPE_CONFIRM;
            stPopup.u16Exitkeys = POPMSG_EXIT_EXIT;
            stPopup.u16ReturnType = GUI_OBJECT_POST_EVENT ;
            stPopup.u32GuiObjID = DVB_GUIOBJ_PVR_REC;
            stPopup.extend.stConfirm.eConfirmType = POPMSG_CONFIRM_START_RECORD;
            stPopup.extend.stConfirm.u8Default = POPMSG_NO;
            break;

        case DVB_APP_POP_MSG_STOP_MHEG_FOR_REC:
            stPopup.eType = POPMSG_TYPE_CONFIRM;
            stPopup.u16Exitkeys = POPMSG_EXIT_EXIT;
            stPopup.u16ReturnType = GUI_OBJECT_POST_EVENT ;
            stPopup.u32GuiObjID = DVB_GUIOBJ_PVR_REC;
            stPopup.extend.stConfirm.eConfirmType = POPMSG_CONFIRM_STOP_MHEG_FOR_RECORD;
            stPopup.extend.stConfirm.u8Default = POPMSG_NO;
            break;

        case DVB_APP_POP_MSG_STOP_TSHIFT_TO_REC:
            stPopup.eType = POPMSG_TYPE_CONFIRM;
            stPopup.u16Exitkeys = POPMSG_EXIT_EXIT;
            stPopup.u16ReturnType = GUI_OBJECT_POST_EVENT ;
            stPopup.extend.stConfirm.eConfirmType = POPMSG_CONFIRM_STOP_THIFT_TO_REC;
            stPopup.extend.stConfirm.u8Default = POPMSG_NO;
            break;
		case DVB_APP_POP_MSG_UPDATE_TSID:
			stPopup.eType = POPMSG_TYPE_CONFIRM;
			stPopup.u16Exitkeys =  POPMSG_EXIT_EXIT;
			stPopup.u16ReturnType = GUI_OBJECT_EVENT_BYPASS;
			stPopup.extend.stPrompt.ePromptType = POPMSG_CONFIRM_FIND_NEW_TSID;
			stPopup.extend.stConfirm.u8Default = POPMSG_NO;
			break;

        case DVB_APP_POP_MSG_TIMESHIFT_START:
            stPopup.eType = POPMSG_TYPE_CONFIRM;
            stPopup.u16Exitkeys = POPMSG_EXIT_EXIT;
            stPopup.u16ReturnType = GUI_OBJECT_POST_EVENT ;
            stPopup.u32GuiObjID = DVB_GUIOBJ_PVR_REC;
            stPopup.extend.stConfirm.eConfirmType = POPMSG_CONFIRM_START_TIMESHIFT;
            stPopup.extend.stConfirm.u8Default = POPMSG_NO;
            break;

        case DVB_APP_POP_MSG_STOP_MHEG_FOR_TIMESHIFT:
            stPopup.eType = POPMSG_TYPE_CONFIRM;
            stPopup.u16Exitkeys = POPMSG_EXIT_EXIT;
            stPopup.u16ReturnType = GUI_OBJECT_POST_EVENT ;
            stPopup.u32GuiObjID = DVB_GUIOBJ_PVR_REC;
            stPopup.extend.stConfirm.eConfirmType = POPMSG_CONFIRM_STOP_MHEG_FOR_TIMESHIFT;
            stPopup.extend.stConfirm.u8Default = POPMSG_NO;
            break;

        case DVB_APP_POP_MSG_REC_STOP:
            stPopup.eType = POPMSG_TYPE_CONFIRM;
            stPopup.u16Exitkeys = POPMSG_EXIT_EXIT;
            stPopup.u16ReturnType = GUI_OBJECT_POST_EVENT ;
            stPopup.u32GuiObjID = DVB_GUIOBJ_PVR_REC;
            stPopup.extend.stConfirm.eConfirmType = POPMSG_CONFIRM_STOP_RECORD;
            stPopup.extend.stConfirm.u8Default = POPMSG_NO;
            break;

        case DVB_APP_POP_MSG_STOP_REC_FOR_MHEG:
            stPopup.eType = POPMSG_TYPE_CONFIRM;
            stPopup.u16Exitkeys = POPMSG_EXIT_EXIT;
            stPopup.u16ReturnType = GUI_OBJECT_POST_EVENT ;
            stPopup.u32GuiObjID = DVB_GUIOBJ_PVR_REC;
            stPopup.extend.stConfirm.eConfirmType = POPMSG_CONFIRM_STOP_RECORD_FOR_MHEG;
            stPopup.extend.stConfirm.u8Default = POPMSG_NO;
            break;

        case DVB_APP_POP_MSG_TIMESHIFT_STOP:
            stPopup.eType = POPMSG_TYPE_CONFIRM;
            stPopup.u16Exitkeys = POPMSG_EXIT_EXIT;
            stPopup.u16ReturnType = GUI_OBJECT_POST_EVENT ;
            stPopup.u32GuiObjID = DVB_GUIOBJ_PVR_REC;
            stPopup.extend.stConfirm.eConfirmType = POPMSG_CONFIRM_STOP_TIMESHIFT;
            stPopup.extend.stConfirm.u8Default = POPMSG_NO;
            break;

        case DVB_APP_POP_MSG_STOP_TIMESHIFT_FOR_MHEG:
            stPopup.eType = POPMSG_TYPE_CONFIRM;
            stPopup.u16Exitkeys = POPMSG_EXIT_EXIT;
            stPopup.u16ReturnType = GUI_OBJECT_POST_EVENT ;
            stPopup.u32GuiObjID = DVB_GUIOBJ_PVR_REC;
            stPopup.extend.stConfirm.eConfirmType = POPMSG_CONFIRM_STOP_TIMESHIFT_FOR_MHEG;
            stPopup.extend.stConfirm.u8Default = POPMSG_NO;
            break;

        case DVB_APP_POP_MSG_REC_STOP_CHANNEL_CHANGE:
            stPopup.eType = POPMSG_TYPE_CONFIRM;
            stPopup.u16Exitkeys = POPMSG_EXIT_EXIT;
            stPopup.u16ReturnType = GUI_OBJECT_POST_EVENT ;
            stPopup.u32GuiObjID = DVB_GUIOBJ_PVR_REC;
            stPopup.extend.stConfirm.eConfirmType = POPMSG_CONFIRM_STOP_RECORD_FOR_CH_CHANGE;
            stPopup.extend.stConfirm.u8Default = POPMSG_NO;
            break;

        case DVB_APP_POP_MSG_REC_STOP_FOR_RECALL:
            stPopup.eType = POPMSG_TYPE_CONFIRM;
            stPopup.u16Exitkeys = POPMSG_EXIT_EXIT;
            stPopup.u16ReturnType = GUI_OBJECT_POST_EVENT ;
            stPopup.u32GuiObjID = DVB_GUIOBJ_PVR_REC;
            stPopup.extend.stConfirm.eConfirmType = POPMSG_CONFIRM_STOP_RECORD_FOR_RECALL;
            stPopup.extend.stConfirm.u8Default = POPMSG_NO;
            break;

        case DVB_APP_POP_MSG_TIMESHIFT_STOP_CHANNEL_CHANGE:
            stPopup.eType = POPMSG_TYPE_CONFIRM;
            stPopup.u16Exitkeys = POPMSG_EXIT_EXIT;
            stPopup.u16ReturnType = GUI_OBJECT_POST_EVENT ;
            stPopup.u32GuiObjID = DVB_GUIOBJ_PVR_REC;
            stPopup.extend.stConfirm.eConfirmType = POPMSG_CONFIRM_STOP_TIMESHIFT_FOR_CH_CHANGE;
            stPopup.extend.stConfirm.u8Default = POPMSG_NO;
            break;

        case DVB_APP_POP_MSG_TIMESHIFT_STOP_FOR_RECALL:
            stPopup.eType = POPMSG_TYPE_CONFIRM;
            stPopup.u16Exitkeys = POPMSG_EXIT_EXIT;
            stPopup.u16ReturnType = GUI_OBJECT_POST_EVENT ;
            stPopup.u32GuiObjID = DVB_GUIOBJ_PVR_REC;
            stPopup.extend.stConfirm.eConfirmType = POPMSG_CONFIRM_STOP_TIMESHIFT_FOR_RECALL;
            stPopup.extend.stConfirm.u8Default = POPMSG_NO;
            break;

        case DVB_APP_POP_MSG_REC_STOP_SOURCE_CHANGE:
            stPopup.eType = POPMSG_TYPE_CONFIRM;
            stPopup.u16Exitkeys = POPMSG_EXIT_EXIT;
            stPopup.u16ReturnType = GUI_OBJECT_POST_EVENT ;
            stPopup.u32GuiObjID = DVB_GUIOBJ_PVR_REC;
            stPopup.extend.stConfirm.eConfirmType = POPMSG_CONFIRM_STOP_RECORD_FOR_SRC_CHANGE;
            stPopup.extend.stConfirm.u8Default = POPMSG_NO;
            break;

        case DVB_APP_POP_MSG_TIMESHIFT_STOP_SOURCE_CHANGE:
            stPopup.eType = POPMSG_TYPE_CONFIRM;
            stPopup.u16Exitkeys = POPMSG_EXIT_EXIT;
            stPopup.u16ReturnType = GUI_OBJECT_POST_EVENT ;
            stPopup.u32GuiObjID = DVB_GUIOBJ_PVR_REC;
            stPopup.extend.stConfirm.eConfirmType = POPMSG_CONFIRM_STOP_TIMESHIFT_FOR_SRC_CHANGE;
            stPopup.extend.stConfirm.u8Default = POPMSG_NO;
            break;

        case DVB_APP_POP_MSG_REC_SPEED_NOT_ENOUGH:
            stPopup.eType = POPMSG_TYPE_CONFIRM;
            stPopup.u16Exitkeys = POPMSG_EXIT_EXIT;
            stPopup.u16ReturnType = GUI_OBJECT_POST_EVENT ;
            stPopup.u32GuiObjID = DVB_GUIOBJ_PVR_REC;
            stPopup.extend.stConfirm.eConfirmType = POPMSG_CONFIRM_RECORDER_SPEED_NOT_ENOUGH;
            stPopup.extend.stConfirm.u8Default = POPMSG_NO;
            break;

        case DVB_APP_POP_MSG_TIMESHIFT_SPEED_NOT_ENOUGH:
            stPopup.eType = POPMSG_TYPE_CONFIRM;
            stPopup.u16Exitkeys = POPMSG_EXIT_EXIT;
            stPopup.u16ReturnType = GUI_OBJECT_POST_EVENT ;
            stPopup.u32GuiObjID = DVB_GUIOBJ_PVR_REC;
            stPopup.extend.stConfirm.eConfirmType = POPMSG_CONFIRM_TIMESHIFT_SPEED_NOT_ENOUGH;
            stPopup.extend.stConfirm.u8Default = POPMSG_NO;
            break;

        case DVB_APP_POP_MSG_REC_STOP_FOR_USBKEY:
            stPopup.eType = POPMSG_TYPE_CONFIRM;
            stPopup.u16Exitkeys = POPMSG_EXIT_EXIT;
            stPopup.u16ReturnType = GUI_OBJECT_POST_EVENT ;
            stPopup.u32GuiObjID = DVB_GUIOBJ_PVR_REC;
            stPopup.extend.stConfirm.eConfirmType = POPMSG_CONFIRM_STOP_RECORD_FOR_USBKEY;
            stPopup.extend.stConfirm.u8Default = POPMSG_NO;
            break;

        case DVB_APP_POP_MSG_TIMESHIFT_STOP_FOR_USBKEY:
            stPopup.eType = POPMSG_TYPE_CONFIRM;
            stPopup.u16Exitkeys = POPMSG_EXIT_EXIT;
            stPopup.u16ReturnType = GUI_OBJECT_POST_EVENT ;
            stPopup.u32GuiObjID = DVB_GUIOBJ_PVR_REC;
            stPopup.extend.stConfirm.eConfirmType = POPMSG_CONFIRM_STOP_TIMESHIFT_FOR_USBKEY;
            stPopup.extend.stConfirm.u8Default = POPMSG_NO;
            break;

        case DVB_APP_POP_MSG_REC_STOP_FOR_TVRADIOKEY:
            stPopup.eType = POPMSG_TYPE_CONFIRM;
            stPopup.u16Exitkeys = POPMSG_EXIT_EXIT;
            stPopup.u16ReturnType = GUI_OBJECT_POST_EVENT ;
            stPopup.u32GuiObjID = DVB_GUIOBJ_PVR_REC;
            stPopup.extend.stConfirm.eConfirmType = POPMSG_CONFIRM_STOP_RECORD_FOR_TVRADIOKEY;
            stPopup.extend.stConfirm.u8Default = POPMSG_NO;
            break;

        case DVB_APP_POP_MSG_TIMESHIFT_STOP_FOR_TVRADIOKEY:
            stPopup.eType = POPMSG_TYPE_CONFIRM;
            stPopup.u16Exitkeys = POPMSG_EXIT_EXIT;
            stPopup.u16ReturnType = GUI_OBJECT_POST_EVENT ;
            stPopup.u32GuiObjID = DVB_GUIOBJ_PVR_REC;
            stPopup.extend.stConfirm.eConfirmType = POPMSG_CONFIRM_STOP_TIMESHIFT_FOR_TVRADIOKEY;
            stPopup.extend.stConfirm.u8Default = POPMSG_NO;
            break;
		case DVB_APP_POP_MSG_PVR_TIMESHIFT_STANDBY:
            stPopup.eType = POPMSG_TYPE_CONFIRM;
            stPopup.u16Exitkeys = POPMSG_EXIT_EXIT;
            stPopup.u16ReturnType = GUI_OBJECT_POST_EVENT;
            stPopup.extend.stConfirm.eConfirmType = POPMSG_CONFIRM_PVR_TIMESHIFT_STANDBY;
            stPopup.extend.stConfirm.u8Default = POPMSG_NO;
			break;
        case DVB_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 DVB_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 DVB_APP_POP_MSG_STOP_REC_FOR_REMINDER:
			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_STOP_REC_FOR_REMINDER;
			stPopup.extend.stConfirm.u8Default = POPMSG_NO;
			break;
		case DVB_APP_POP_MSG_STOP_TSHIFT_FOR_REMINDER:
			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_STOP_TSHIFT_FOR_REMINDER;
			stPopup.extend.stConfirm.u8Default = POPMSG_NO;
			break;
        case DVB_APP_POP_MSG_STOP_REC_FOR_TIMER_REC:
            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_STOP_REC_FOR_TIMER_REC;
            stPopup.extend.stConfirm.u8Default = POPMSG_NO;
            break;
        case DVB_APP_POP_MSG_STOP_TSHIFT_FOR_TIMER_REC:
            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_STOP_TSHIFT_FOR_TIMER_REC;
            stPopup.extend.stConfirm.u8Default = POPMSG_NO;
            break;
        case DVB_APP_POP_MSG_TIMER_OUT_OF_DATE:
            stPopup.eType = POPMSG_TYPE_PROMPT;
            stPopup.u16Exitkeys =  POPMSG_EXIT_KEY_NONE;
            stPopup.u16ReturnType = GUI_OBJECT_EVENT_BYPASS ;
            stPopup.extend.stPrompt.ePromptType = POPMSG_PROMPT_TIMER_OUT_OF_DATE;
            stPopup.extend.stPrompt.iTimeout = 2;
            break;
        case DVB_APP_POP_MSG_PVR_SYSTEM_TIME_CHANGED:
            stPopup.eType = POPMSG_TYPE_PROMPT;
            stPopup.u16Exitkeys =  POPMSG_EXIT_EXIT;
            stPopup.u16ReturnType = GUI_OBJECT_POST_EVENT;
            stPopup.extend.stPrompt.ePromptType = POPMSG_PROMPT_PVR_SYSTEM_TIME_CHANGED;
            stPopup.extend.stPrompt.iTimeout = 2;
            break;
        case DVB_APP_POP_MSG_PVR_PARTITION_SET_SUCCESSFUL:
            stPopup.eType = POPMSG_TYPE_PROMPT;
            stPopup.u16Exitkeys =  POPMSG_EXIT_EXIT;
            stPopup.u16ReturnType = GUI_OBJECT_POST_EVENT;
            stPopup.extend.stPrompt.ePromptType = POPMSG_PROMPT_PARTITION_SET_SUCCESSFUL;
            stPopup.extend.stPrompt.iTimeout = 2;
            break;
        case DVB_APP_POP_MSG_PVR_ENABLE:
            stPopup.eType = POPMSG_TYPE_PROMPT;
            stPopup.u16Exitkeys =  POPMSG_EXIT_KEY_NONE;
            stPopup.u16ReturnType = GUI_OBJECT_EVENT_BYPASS;
            stPopup.extend.stPrompt.ePromptType = POPMSG_PROMPT_PVR_ENABLE;
            stPopup.extend.stPrompt.iTimeout = 2;
            break;
        case DVB_APP_POP_MSG_PVR_DISABLE:
            stPopup.eType = POPMSG_TYPE_PROMPT;
            stPopup.u16Exitkeys =  POPMSG_EXIT_KEY_NONE;
            stPopup.u16ReturnType = GUI_OBJECT_EVENT_BYPASS;
            stPopup.extend.stPrompt.ePromptType = POPMSG_PROMPT_PVR_DISABLE;
            stPopup.extend.stPrompt.iTimeout = 2;
            break;
        case DVB_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 DVB_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 DVB_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 ;
            stPopup.u32GuiObjID = DVB_GUIOBJ_PVR_REC;
            stPopup.extend.stConfirm.eConfirmType = POPMSG_CONFIRM_INSERT_USB;
            stPopup.extend.stConfirm.u8Default = POPMSG_NO;
            break;
        case DVB_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 ;
            stPopup.u32GuiObjID = DVB_GUIOBJ_PVR_REC;
            stPopup.extend.stConfirm.eConfirmType = POPMSG_CONFIRM_INVALID_USB;
            stPopup.extend.stConfirm.u8Default = POPMSG_NO;
            break;
#endif

        case DVB_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 DVB_APP_POP_MSG_EPG_ENABLE:
        stPopup.eType = POPMSG_TYPE_PROMPT;
        stPopup.u16Exitkeys =  POPMSG_EXIT_KEY_NONE;
        stPopup.u16ReturnType = GUI_OBJECT_EVENT_BYPASS;
        stPopup.extend.stPrompt.ePromptType = POPMSG_PROMPT_EPG_ENABLE;
        stPopup.extend.stPrompt.iTimeout = 2;
        break;
    case DVB_APP_POP_MSG_EPG_DISABLE:
        stPopup.eType = POPMSG_TYPE_PROMPT;
        stPopup.u16Exitkeys =  POPMSG_EXIT_KEY_NONE;
        stPopup.u16ReturnType = GUI_OBJECT_EVENT_BYPASS;
        stPopup.extend.stPrompt.ePromptType = POPMSG_PROMPT_EPG_DISABLE;
        stPopup.extend.stPrompt.iTimeout = 2;
        break;

    case DVB_APP_POP_MSG_RADIO_CHANNEL:
        stPopup.eType = POPMSG_TYPE_PROMPT;
        stPopup.u16Exitkeys =  POPMSG_EXIT_KEY_NONE;
        stPopup.u16ReturnType = GUI_OBJECT_EVENT_BYPASS;
        stPopup.extend.stPrompt.ePromptType = PLAYBACK_POPUP_MSG_RADIO_CHANNEL;
        break;
    case DVB_APP_POP_MSG_NO_RADIO:
        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_RADIO;
        stPopup.extend.stPrompt.iTimeout = 2;
        break;
	case DVB_APP_POP_MSG_NO_DTVORDATA:
		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_DTVORDATA;
		stPopup.extend.stPrompt.iTimeout = 2;
		break;
    case DVB_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 DVB_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 DVB_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 DVB_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
        default:
            return;
    }

    if (stDvbInst.bAppState == SYSTEM_IDLE)
    {
        return;
    }

    DVBApp_SchedulePopup(stPopup);
}

static INT32 _DVBApp_CheckPopupDisplay(void)
{
    UINT32 dCheckFlag;

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

static INT32 _DVBApp_HidePopupDisplay(void)
{
    if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PROGINFO))
    {
        SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PROGINFO);
    }

    if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PROGNUM))
    {
        SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PROGNUM);
    }
    APP_MenuMgr_SetMsgPopup(FALSE);
    g_u32OldPopup = PLAYBACK_POPUP_NONE;
    if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_POPMSG))
    {
        SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_POPMSG);
    }

    g_dCurPopup = PLAYBACK_POPUP_NONE;

	return SP_SUCCESS;
}

static al_void _DVBApp_SendServRefleshMsg(al_void)
{
	if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_CHNMGR))
	{
		SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_DVB, DVB_GUIOBJ_CHNMGR,
			APP_GLOBAL_EVENT_REFRESH_SERV_INFO, 0);
	}
	if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_FAVMGR))
	{
		SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_DVB, DVB_GUIOBJ_FAVMGR,
			APP_GLOBAL_EVENT_REFRESH_SERV_INFO, 0);
	}
	if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_CHNLIST))
	{
		SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_DVB, DVB_GUIOBJ_CHNLIST,
			APP_GLOBAL_EVENT_REFRESH_SERV_INFO, 0);
	}
	if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_FAVLIST))
	{
		SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_DVB, DVB_GUIOBJ_FAVLIST,
			APP_GLOBAL_EVENT_REFRESH_SERV_INFO, 0);
	}	
}

static INT32 _DVBApp_Zapping(
                UINT8 bServiceType, AL_RecHandle_t hProgHdl,
                UINT8 bForce, UINT32 u32Paramter, Boolean bShowInfo)
{
	AL_DB_EDBType_t eOldDBType = APP_GUIOBJ_DVB_Playback_GetPrevNetType();
	AL_DB_ERecordType_t eOldServiceType = APP_DVB_Playback_GetCurrServiceType(eOldDBType);
    AL_RecHandle_t hOldProgHdl;
    AL_RecHandle_t hNextProgHdl = hProgHdl;
	APP_Source_Type_t eSourType = APP_SOURCE_MAX;

	APP_GUIOBJ_Source_GetCurrSource(&eSourType);

    if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PROGNUM))
    {
        SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PROGNUM);
    }

    hOldProgHdl = APP_DVB_Playback_GetCurrentProgHandle(eOldDBType, eOldServiceType);
    if (AL_DB_INVALIDHDL != hNextProgHdl)
    {
        AL_ServiceDetail_t ServInfor;
        DBServAttrib_t stProgAttrib;
		AL_DB_EDBType_t eDBType;
		AL_DB_ERecordType_t eServiceType;

        AL_DB_QueryDetail(hNextProgHdl, &ServInfor);
	    AL_DB_GetRecordType(hNextProgHdl, &eDBType, &eServiceType);
		if (AL_DBTYPE_DVB_SBTVD == eDBType)
        {
            stProgAttrib = ServInfor.stSBTVDServ.stProgAttrib;
        }
        if (!(stProgAttrib.delete == al_true))
        {
            if ((hNextProgHdl != hOldProgHdl)
                || (bServiceType != eOldServiceType) || (bForce == TRUE)
#ifdef CHECK_HIDDEN_SERVICE
                || ((stProgAttrib.notvisible == al_true) != 0)
#endif
               )
            {
#ifdef CONFIG_SUPPORT_PVR
				if (MID_RecorderIsCurRecording() == DRV_SUCCESS)
				{
					PVR_DEBF("\n==========stop recorder to zapping!====\n");
                    if (MID_REC_MODE_MANUAL == MID_Recorder_GetRecMode())
                    {
					    DVBApp_StopRecord();
                    }
                    else
                    {
                        DVBApp_StopTimeshift(FALSE);
                    }
				}
#endif
                if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_FREEZE))
                {
                    SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_FREEZE);
                }

                if (APP_GetPlaybackPauseState() == TRUE)
                {
					APP_Audio_SetMute(TRUE, TRUE, APP_MUTE_MODE_CH_CHANGE, eSourType);
					APP_Video_SetMute(TRUE, TRUE, APP_MUTE_MODE_CH_CHANGE, eSourType);
                    MID_PlaybackStreamResume(1);
                    APP_SetPlaybackPauseState(FALSE);
                }
                DVBApp_ClearStatus();
				if (u32Paramter == FW_MONITOR_REPLACE_SERVICE)
				{
					SYSAPP_GOBJ_SendMsgToSingleGUIObject(
                    	SYS_APP_DVB, DVB_GUIOBJ_PLAYBACK,
                    	APP_DVB_INTRA_EVENT_ZAPPING_WITH_REPLACE, (UINT32)hNextProgHdl);
				}
				else
				{
					SYSAPP_GOBJ_SendMsgToSingleGUIObject(
                    	SYS_APP_DVB, DVB_GUIOBJ_PLAYBACK,
                    	APP_DVB_INTRA_EVENT_ZAPPING, (UINT32)hNextProgHdl);
				}
            }
        }		
        /*Add for dispose TV/RADIO key in channel manager /channel list /epg*/
        if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_CHNMGR)
            || SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_FAVMGR)
            || SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_CHNLIST)
            || SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_FAVLIST)
            || SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_EPG)
#ifdef SUPPORT_FACTORY_AUTO_TEST
			|| SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_FM_FACTORYSETTING)
#endif
            )
        {
            return SP_SUCCESS;
        }
        /*End*/
		AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FACTHOTEL, 0,
			sizeof(APP_SETTING_FactoryHotel_t), &(g_stFactoryHotelData));
		if((!APP_Factory_CheckNeedReopenFm(SYS_APP_DVB))
#ifdef SUPPORT_HOTEL_MODE_INFOBANNER_SHOW_CONTROL
			&&((!g_stFactoryHotelData.HotelModeOnOff)||(g_stFactoryHotelData.ShowInfoBar))
#endif
			)
        {
	        if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PROGINFO))
	        {
                if (bShowInfo == TRUE)
                {
    	            SYSAPP_GOBJ_SendMsgToSingleGUIObject(
    	                SYS_APP_DVB, DVB_GUIOBJ_PROGINFO,
    	                APP_DVB_GLOBAL_EVENT_INFO_UPDATE, 1);
                }
                else
                {
	                SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PROGINFO);
                }
	        }
	        else
	        {
	            if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_BANNER))
	            {
	                SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, APP_GUIOBJ_BANNER);
	            }
				if (!(APP_MenuMgr_Exist_Main_Menu()))
				{
		            if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_ADJUST))
		            {
		                SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, APP_GUIOBJ_ADJUST);
		            }
#ifdef SUPPORT_CEC_TV
		            if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_AMPLIFIERVOLUME))
		            {
		                SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, APP_GUIOBJ_AMPLIFIERVOLUME);
		            }
#endif
                    _DVBApp_CloseAllMenu();
                    if (bShowInfo == TRUE)
                    {
	            		SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, DVB_GUIOBJ_PROGINFO, 0);
                    }
				}
	        }
			if (APP_DVB_Playback_GetProgStateByHandle(APP_DVB_Playback_GetCurrentNetType(), AL_DB_INVALIDHDL)
				== MID_PLAYBK_PROG_STATE_LOCKED)
			{
    			if (bShowInfo == TRUE)
                {
    				_DVBApp_ShowPopup(DVB_APP_POP_MSG_CHECKPWD);
                }
			}
		}
    }
    else
    {
#ifdef SPECIAL_CHNORDER_FOR_SPAIN
		SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_DVB, UI_EVENT_DISPLAY, 0);
#else
		_DVBApp_ShowPopup(DVB_APP_POP_MSG_INVALID_INPUT);
#endif
    }
    _DVBApp_CheckPopupDisplay();

    return SP_SUCCESS;

}

static INT32 _DVBApp_DestroyPartialObjects(UINT8 *pMenuFlag)
{
    UINT32 i;
    UINT32 u32TotalObj;
    UINT8 u8FilteredObj = 0;
    UINT32 u32GuiObjID[DVB_GUIOBJ_MAX];

    if (SYSAPP_GOBJ_GetTotalCreatedObjects(SYS_APP_DVB, &u32TotalObj) == -1)
    {
        return SP_ERR_FAILURE;
    }

	for (i = 0; i <= u32TotalObj - 1; i++)
    {
        if (SYSAPP_GOBJ_GetObjectIDByIndex(SYS_APP_DVB, i , &u32GuiObjID[u8FilteredObj]) == -1)
        {
            return SP_ERR_FAILURE;
        }
        if ((u32GuiObjID[u8FilteredObj] == DVB_GUIOBJ_PLAYBACK)
            || (u32GuiObjID[u8FilteredObj] == DVB_GUIOBJ_FREEZE)
            || (u32GuiObjID[u8FilteredObj] == APP_GUIOBJ_MUTE)
#ifdef CONFIG_SUPPORT_ISDB_SUBTITLE
            || (u32GuiObjID[u8FilteredObj] == DVB_GUIOBJ_CC)
#endif       
           )
        {
            continue;
        }
        else if ((u32GuiObjID[u8FilteredObj] == DVB_GUIOBJ_CHNMGR)
                 || (u32GuiObjID[u8FilteredObj] == DVB_GUIOBJ_FAVMGR)
                 || (u32GuiObjID[u8FilteredObj] == DVB_GUIOBJ_SCAN_PROCESS)
                 || (u32GuiObjID[u8FilteredObj] == DVB_GUIOBJ_CHNRENAME)
                 || (u32GuiObjID[u8FilteredObj] == DVB_GUIOBJ_EPG)
                 || (u32GuiObjID[u8FilteredObj] == DVB_GUIOBJ_CHNLIST)
                 || (u32GuiObjID[u8FilteredObj] == DVB_GUIOBJ_FAVLIST)
                 || (u32GuiObjID[u8FilteredObj] == DVB_GUIOBJ_EPGEXTEND)
                 )
        {
            *pMenuFlag = TRUE;
        }
        u8FilteredObj++;
    }

    SYSAPP_GOBJ_DestroyPartialGUIObjects(SYS_APP_DVB, u32GuiObjID, u8FilteredObj);

    return SP_SUCCESS;
}

static void _DVBApp_Exit_All_Menu(void)
{
    UINT8 bMenuFlag = 0;
	al_bool bHasValidServ = al_false;
    al_uint8 bSignalState = al_false;
	AL_DB_EDBType_t eNetType = APP_DVB_Playback_GetCurrentNetType();

    if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_POPMSG))
    {
        DVBApp_ResetPopup_Channel();
        SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_POPMSG);
    }

#ifdef OSD_GAME_SUPPORT
    if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_OSDGAME))
    {
        SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_DVB, DVB_GUIOBJ_OSDGAME, APP_DVB_INTRA_EVENT_OSD_GAME_EXIT, (UINT32)NULL);
    }
#endif

    if (APP_MenuMgr_Exist_Main_Menu())
    {
        bMenuFlag = 1;
        APP_MenuMgr_Exit_Main_Menu();

    }

    if (APP_MenuMgr_Exist_Factory_Menu())
    {
        bMenuFlag = 1;
        APP_MenuMgr_Exit_Factory_Menu();
    }

#ifdef  CONFIG_SUPPORT_OTA_UPGRADE
    if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_OTA_UPGRADE_PROGRESS)
        && (!APP_MenuMgr_Exist_Main_Menu()))
    {
        bMenuFlag = TRUE;
    }
#endif
    if (g_u32OldPopup == PLAYBACK_POPUP_NONE)
    {
        if (_DVBApp_DestroyPartialObjects(&bMenuFlag) == SP_ERR_FAILURE)
        {
            SYSAPP_GOBJ_DestroyAllGUIObject(SYS_APP_DVB);
        }
    }

	bHasValidServ = AL_DB_HasVisibleService(eNetType);

    if (bMenuFlag)
    {
    #if 0
        if (TotalNum > 0)
        {
			al_uint8 bSignalState = al_false;
			AL_DVB_Monitor_GetState(AL_DVB_MONITOR_STATE_SIGNAL, &bSignalState);
            if ((bSignalState != AL_DVB_MONITOR_VALUE_TRUE) && (MID_PlaybackIsPlaying() == TRUE))
            {
                //DVBApp_ResetPopup_Channel();
                _DVBApp_ShowPopup(DVB_APP_POP_MSG_NO_SIGNAL);
            }
            else
            {
                if (eServiceType == AL_RECTYPE_DVBRADIO)
                {
                    //DVBApp_ResetPopup_Channel();
                    if (!APP_GUIOBJ_DVB_Playback_GetShowLogoState())
                    {
                        SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PLAYBACK, APP_DVB_INTRA_EVENT_SHOWLOGO, 0);
                    }
                    if (!DVBApp_IsPopupExist(PLAYBACK_POPUP_MSG_RADIO_CHANNEL))
                    {
#ifdef CONFIG_SUPPORT_MHEG5
                        if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_MHEG5))
#endif
                        {
                            _DVBApp_ShowPopup(DVB_APP_POP_MSG_RADIO_CHANNEL);
                        }
                    }
                }
                else
                {
                    DVBApp_ClosePopup(PLAYBACK_POPUP_MSG_RADIO_CHANNEL, UI_EVENT_NULL);
                }
                if (APP_DVB_Playback_GetProgStateByHandle(APP_DVB_Playback_GetCurrentNetType(), AL_DB_INVALIDHDL)
                    == MID_PLAYBK_PROG_STATE_SCRAMBLED)
                {
                    _DVBApp_ShowPopup(DVB_APP_POP_MSG_SCRAMBLE);
                }
            }
        }
        else
        {
            SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PLAYBACK, APP_DVB_INTRA_EVENT_SHOWLOGO, 0);
            //DVBApp_ResetPopup_Channel();
            _DVBApp_ShowPopup(DVB_APP_POP_MSG_DATABASE_EMPTY);
        }
	#endif
    }
    else
    {
        if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PROGINFO))
        {
            SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PROGINFO);
        }
    }

    AL_DVB_Monitor_GetState(AL_DVB_MONITOR_STATE_SIGNAL, &bSignalState);
    if (bSignalState == AL_DVB_MONITOR_VALUE_TRUE)
    {
        DVBApp_ClosePopup(PLAYBACK_POPUP_MSG_NO_SIGNAL, UI_EVENT_NULL);
    }

    DVBApp_ClosePopup(PLAYBACK_POPUP_PWD_LOCKED, UI_EVENT_NULL);

    if (bHasValidServ)
    {
        _DVBApp_ToggleVideoState();
        if (g_bMidHasUnmute)
        {
            DVBApp_CheckProgramType(TRUE);
        }
    }

    _DVBApp_CheckPopupDisplay();
}

static void _DVBApp_ExitAll(void)
{
    _DVBApp_Exit_All_Menu();
}

static INT32 _DVBApp_CloseAllMenu(void)
{
    INT32 u32GuiObj = 0;
    UINT32 u32GuiObjID;
    UINT32 u32TotalObj;

    _DVBApp_HidePopupDisplay();


    if (SYSAPP_GOBJ_GetTotalCreatedObjects(SYS_APP_DVB, &u32TotalObj) != SYSTEM_APP_SUCCESS)
    {
        return SP_ERR_FAILURE;
    }

    for (u32GuiObj =(INT32)(u32TotalObj - 1); u32GuiObj >= 0; u32GuiObj--)
    {
        if (SYSAPP_GOBJ_GetObjectIDByIndex(SYS_APP_DVB, u32GuiObj , &u32GuiObjID) != SYSTEM_APP_SUCCESS)
        {
            return SP_ERR_FAILURE;
        }
        if ((u32GuiObjID == DVB_GUIOBJ_PLAYBACK)
            ||(u32GuiObjID == DVB_GUIOBJ_FREEZE)
            ||(u32GuiObjID == APP_GUIOBJ_MUTE)
#ifdef CONFIG_SUPPORT_ISDB_SUBTITLE
            ||(u32GuiObjID == DVB_GUIOBJ_CC)
#endif            
#ifdef CONFIG_SUPPORT_PVR
			|| (u32GuiObjID == DVB_GUIOBJ_PVR_FILEPLAY)
			|| (u32GuiObjID == DVB_GUIOBJ_PVR_FILEPLAYINFO)
#endif
            )
        {
            continue;
        }
        SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, u32GuiObjID);
    }

    return SP_SUCCESS;
}

#ifdef CONFIG_SUPPORT_PVR
/* g_bMidHasUnmute , we need modify this flag before play record file when dtv play locked radio */
void DVBAPP_Pvr_fileplay_Setflag(Boolean flag)
{
	g_bMidHasUnmute = flag;
}
AL_SCH_sched_id_t DVBAPP_Pvr_GetStopTimer_id(void)
{
    return stoprec_id;
}

void DVBApp_Pvr_SetStopTimer_id(void)
{
    stoprec_id = AL_SCH_INVALID_ID;
}

void DVBApp_SetBGTimeshift(UINT8 u8StartInterval)
{
    if (u8StartInterval > 0)
    {
        g_u8BGTimeshiftStart = u8StartInterval;
    }
    else
    {
        g_u8BGTimeshiftStart = 0;
    }
}
static int DVBApp_CheckDiskSpeedAgain(int defpartition)
{
	int Speed_State;

	dvb_printf(" %s \n\n",__FUNCTION__);
	MID_RecorderSetDefaultPartition(defpartition, MID_REC_PARTITION_SET_FORCE);

	Speed_State = MID_RecorderGetPartitionSpeed(defpartition);
	return Speed_State;
}

static INT32 DVBApp_CheckForRecord(MID_REC_MODE eRecMode)
{
    int Speed_State;
    INT32 iRet = 0;
    INT32 iPtListIdx = -1;
	//al_bool SOURCE_HD = FALSE;
    al_uint8 bSignalState = al_false;
	al_bool bHasValidServ = al_false;
	UINT8 u8ProgLockState = FALSE;
    g_eCheckRecMode = eRecMode;
//move this action to here for mantis:22619 start
	AL_DB_EDBType_t eNetType = APP_DVB_Playback_GetCurrentNetType();
//move this action to here for mantis:22619 end

    u8ProgLockState = APP_DVB_Playback_GetProgStateByHandle(eNetType, AL_DB_INVALIDHDL);
    AL_DVB_Monitor_GetState(AL_DVB_MONITOR_STATE_SIGNAL, &bSignalState);
    if (u8ProgLockState == MID_PLAYBK_PROG_STATE_LOCKED)
    {
	    if(MID_REC_MODE_MANUAL == eRecMode)
    	{
#ifndef SUPPORT_SPEC_PVR_RECORD
			_DVBApp_ShowPopup(DVB_APP_POP_MSG_REC_ENTER_NOT_VALID);
			return SP_ERR_FAILURE;
#endif
    	}
		else
		{
			_DVBApp_ShowPopup(DVB_APP_POP_MSG_TIMESHIFT_ENTER_NOT_VALID);
			return SP_ERR_FAILURE;
		}
    }

	bHasValidServ = AL_DB_HasVisibleService(eNetType);
    if ((bSignalState != AL_DVB_MONITOR_VALUE_TRUE)
        || (DVBApp_CheckServiceNotAvailable() == TRUE)
        || !bHasValidServ)
    {
        if (MID_REC_MODE_AUTO == eRecMode)
        {
            DVBApp_SetBGTimeshift(PVR_BGTIMESHIFT_START_INTERVAL);
        }
        else
        {
            if (eRecMode == MID_REC_MODE_MANUAL)
            {
                _DVBApp_ShowPopup(DVB_APP_POP_MSG_REC_ENTER_NOT_VALID);
            }
            else if (eRecMode == MID_REC_MODE_TIMESHIFT_AFTER_REC)
            {
                _DVBApp_ShowPopup(DVB_APP_POP_MSG_TIMESHIFT_ENTER_NOT_VALID);
            }
        }
        return SP_ERR_FAILURE;
    }
    iRet = APP_GUIOBJ_DVB_PvrRec_IsReadyToRecord();
    if (iRet != PVR_MSG_SUCCESS)
    {
        switch (iRet)
        {
            case PVR_MSG_FAIL_DISK_CHECKING:
                _DVBApp_ShowPopup(DVB_APP_POP_MSG_PVR_DISK_CHECKING);
                if (MID_REC_MODE_AUTO == eRecMode)
                {
                    DVBApp_SetBGTimeshift(PVR_BGTIMESHIFT_START_INTERVAL);
                }
                break;
            case PVR_MSG_FAIL_PARTITION_NOT_SET:
                if (MID_REC_MODE_AUTO == eRecMode)
                {
                    DVBApp_SetBGTimeshift(PVR_BGTIMESHIFT_START_INTERVAL);
                }
                else
                {
                    _DVBApp_ShowPopup(DVB_APP_POP_MSG_REC_PARTITION_NOT_SET);
                }
                break;
            case PVR_MSG_FAIL_NO_STORAGE:
                _DVBApp_ShowPopup(DVB_APP_POP_MSG_PVR_NO_STORAGE);
                break;
            case PVR_MSG_FAIL_NTFS_DIRTY:
                _DVBApp_ShowPopup(DVB_APP_POP_MSG_REC_NTFS_DIRTY);
                break;
            case PVR_MSG_FAIL_NO_FREE_SPACE:
                _DVBApp_ShowPopup(DVB_APP_POP_MSG_PVR_DISK_FULL);
                break;
            case PVR_MSG_FAIL_H264_IN_PS_FORMAT:
				_DVBApp_ShowPopup(DVB_APP_POP_MSG_REC_ENTER_NOT_VALID);
                break;
            case PVR_MSG_SCRAMBLE_CHANNEL:
                if (MID_REC_MODE_AUTO == eRecMode)
                {
                    DVBApp_SetBGTimeshift(PVR_BGTIMESHIFT_START_INTERVAL);
                }
                else if (MID_REC_MODE_MANUAL== eRecMode)
                {
                    _DVBApp_ShowPopup(DVB_APP_POP_MSG_REC_ENTER_NOT_VALID);
                }
				else if ((MID_REC_MODE_TIMESHIFT_AFTER_REC== eRecMode))
				{
                    _DVBApp_ShowPopup(DVB_APP_POP_MSG_TIMESHIFT_ENTER_NOT_VALID);
				}
                break;

            default:
                if (MID_REC_MODE_AUTO == eRecMode)
                {
                    DVBApp_SetBGTimeshift(PVR_BGTIMESHIFT_START_INTERVAL);
                }
                else
                {
                    _DVBApp_ShowPopup(DVB_APP_POP_MSG_REC_ENTER_NOT_VALID);
                }
                break;
        }
        return SP_ERR_FAILURE;
    }

    MID_RecorderGetDefaultPartition(&iPtListIdx);
    Speed_State = MID_RecorderGetPartitionSpeed(iPtListIdx);
#ifdef REMIND_SPEED_NOT_ENOUGH
	al_uint8 SOURCE_HD = FALSE;
	AL_DVB_Monitor_GetState(AL_DVB_MONITOR_STATE_HDCONTENT, &SOURCE_HD);
	if (SOURCE_HD)
	{
        if ((Speed_State < MID_REC_SPEED_HDRECORD) && (eRecMode == MID_REC_MODE_MANUAL))
		{

#ifdef SUPPORT_WAKEUP_TIMER_IN_STANDBY
            if (APP_WAKEUP_GetBootFlag() == FALSE)//panel off, record immediately
#endif
            {
    			_DVBApp_ShowPopup(DVB_APP_POP_MSG_REC_SPEED_NOT_ENOUGH); //POPUP REC SPEED NOT ENOUGH
    			return SP_ERR_FAILURE;
            }
		}
        else if ((Speed_State < MID_REC_SPEED_HDTSHIFT) && (eRecMode != MID_REC_MODE_MANUAL))
		{
			_DVBApp_ShowPopup(DVB_APP_POP_MSG_TIMESHIFT_SPEED_NOT_ENOUGH); //POPUP TIMESHIFT SPEED NOT ENOUGH
			return SP_ERR_FAILURE;
		}
	}
	else
	{
        if ((Speed_State < MID_REC_SPEED_SDRECORD) && (eRecMode == MID_REC_MODE_MANUAL))
		{
#ifdef SUPPORT_WAKEUP_TIMER_IN_STANDBY
            if (APP_WAKEUP_GetBootFlag() == FALSE)//panel off, record immediately
#endif
            {
    			_DVBApp_ShowPopup(DVB_APP_POP_MSG_REC_SPEED_NOT_ENOUGH); //POPUP REC SPEED NOT ENOUGH
    			return SP_ERR_FAILURE;
            }
		}
        else if ((Speed_State < MID_REC_SPEED_SDTSHIFT) && (eRecMode != MID_REC_MODE_MANUAL))
		{
			_DVBApp_ShowPopup(DVB_APP_POP_MSG_TIMESHIFT_SPEED_NOT_ENOUGH); //POPUP TIMESHIFT SPEED NOT ENOUGH
			return SP_ERR_FAILURE;
		}
	}
#else
	if (Speed_State == MID_REC_SPEED_TOOLOW)
	{
		if ((Speed_State = DVBApp_CheckDiskSpeedAgain(iPtListIdx)) == MID_REC_SPEED_TOOLOW)
		{
			_DVBApp_ShowPopup(DVB_APP_POP_MSG_REC_REQUIRE_FORMAT); //POPUP REC SPEED NOT ENOUGH
			return SP_ERR_FAILURE;
		}
	}
#endif
//move this action to here for mantis:22619 start
    if (MID_REC_MODE_AUTO == eRecMode)
    {
		_DVBApp_CloseAllMenu();
		_DVBApp_ShowPopup(DVB_APP_POP_MSG_TIMESHIFT_INIT);
    }
//move this action to here for mantis:22619 end
	return SP_SUCCESS;
}

INT32 DVBApp_StartRecord(MID_REC_MODE eRecMode)
{
    INT32 iRet;

    if (MID_RecorderIsCurRecording() == DRV_SUCCESS)
    {
		return SP_ERR_FAILURE;
    }
	if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_SCAN_PROCESS))
	{
        return SP_ERR_FAILURE;
	}
#ifdef  CONFIG_SUPPORT_OTA_UPGRADE
	if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_OTA_UPGRADE_PROGRESS))
	{
        return SP_ERR_FAILURE;
	}
#endif
    if (DVBApp_CheckForRecord(eRecMode) != SP_SUCCESS)
    {
        dvb_printf("[%s %d]invalid to enter rec/timeshift!!! [off]\n",__FUNCTION__,__LINE__);
        return SP_ERR_FAILURE;
    }
#ifdef CONFIG_SUPPORT_MHEG5
	DVBApp_DataApplicationSwitch(OSD2CTRLMDL_DISABLE|OSD2CTRLMDL_MH5);
#endif

	/* disable timer record */
    APP_GUIOBJ_DVB_PvrRec_SetDurationTime(0);//means not timer record //zhongbaoxing added for mantis 142788 @20110720

    if (MID_REC_MODE_MANUAL == eRecMode)
    {
        MID_Recorder_SetRecMode(MID_REC_MODE_MANUAL);
#ifdef SUPPORT_WAKEUP_TIMER_IN_STANDBY
		if(APP_WAKEUP_GetBootFlag() == TRUE)
		{
			printf("[debug ]%s		%d\n",__FUNCTION__,__LINE__);
			printf("REC  Mode Chang to MID_REC_MODE_UNATTENDED\n\n\n");
			MID_Recorder_SetRecMode(MID_REC_MODE_UNATTENDED);
		}
#endif
		iRet = APP_GUIOBJ_DVB_PvrRec_StartRecord();
        if (iRet != PVR_MSG_SUCCESS)
		{
            _DVBApp_ShowPopup(DVB_APP_POP_MSG_REC_ENTER_NOT_VALID);
            MID_Recorder_SetRecMode(MID_REC_MODE_MAX);
            APP_GUIOBJ_DVB_PvrRec_RegUninitCallback();
	        DVBApp_DataApplicationSwitch(OSD2CTRLMDL_ENABLE | OSD2CTRLMDL_SUB);

	        return SP_ERR_FAILURE;
		}
        if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_FREEZE))
        {
#ifdef Subtitle_Freeze
			if(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_SUBTITLE))
			{
				AL_Subtitle_SetFreeze(FALSE);
			}
#endif
            SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_FREEZE);
            MID_PlaybackStreamResume(1);
            g_PauseState = FALSE;
        }
        _DVBApp_ShowPopup(DVB_APP_POP_MSG_REC_INIT);
        SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, DVB_GUIOBJ_PVR_REC, 0);
#ifdef SUPPORT_FREE_RECORD_TIME
        if (APP_GUIOBJ_DVB_PvrRec_GetTimerRecord() == FALSE)
        {
            AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FEATURE, 0,
                sizeof(APP_SETTING_Feature_t), &(g_stFeatureData));
            AL_SCH_details_t sch_detail;
            al_uint32 CurTimeInSec = 0;
            AL_Time_GetCurTimeInSecs(&CurTimeInSec);

            memset(&sch_detail, 0, sizeof(AL_SCH_details_t));
            sch_detail.sch_event = AL_SCH_TYPE_SINGLE | AL_SCH_TYPE_PRG_EXPIRE_SCH;
            sch_detail.sch_snooze = 0;
            sch_detail.sch_time = CurTimeInSec + g_stFeatureData.FreeRecordTime*60;    //for mantis 0156382
            sch_detail.sch_user_para = 0;

            PVR_DEBF("event_end_time_insec = %d\n", sch_detail.sch_time);
            PVR_DEBF("current time   	   = %d\n", CurTimeInSec);

            AL_SCH_ScheduleEvent(&sch_detail, &stoprec_id, al_null);
            APP_GUIOBJ_DVB_PvrRec_SetDurationTime(g_stFeatureData.FreeRecordTime*60);
        }
#endif
    }
    else if (MID_REC_MODE_TIMESHIFT_AFTER_REC == eRecMode)
    {
        MID_Recorder_SetRecMode(MID_REC_MODE_TIMESHIFT_AFTER_REC);
        iRet = APP_GUIOBJ_DVB_PvrRec_StartRecord();
        if (iRet != PVR_MSG_SUCCESS)
        {
            _DVBApp_ShowPopup(DVB_APP_POP_MSG_REC_ENTER_NOT_VALID);
            MID_Recorder_SetRecMode(MID_REC_MODE_MAX);
            APP_GUIOBJ_DVB_PvrRec_RegUninitCallback();
            DVBApp_DataApplicationSwitch(OSD2CTRLMDL_ENABLE | OSD2CTRLMDL_SUB);
            return SP_ERR_FAILURE;
        }
        if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_FREEZE))
        {
#ifdef Subtitle_Freeze
			if(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_SUBTITLE))
			{
				AL_Subtitle_SetFreeze(FALSE);
			}
#endif
            SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_FREEZE);
            MID_PlaybackStreamResume(1);
            g_PauseState = FALSE;
        }
        _DVBApp_ShowPopup(DVB_APP_POP_MSG_TIMESHIFT_INIT);
        if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVRREC_INFO))
        {
            SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PVRREC_INFO);
        }
#ifdef SUPPORT_TEAC_TIMESHIFT_CTRL
        SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB,
            DVB_GUIOBJ_PVR_PLAYINFO, PVR_PLAYINFO_ENTERPAUSE);
#else
        SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB,
            DVB_GUIOBJ_PVR_PLAYINFO, 0);
#endif
    }
    else if (MID_REC_MODE_AUTO == eRecMode)
    {
		MID_Recorder_SetRecMode(MID_REC_MODE_AUTO);
        iRet = APP_GUIOBJ_DVB_PvrRec_StartRecord();
        if (iRet != PVR_MSG_SUCCESS)
        {
            _DVBApp_ShowPopup(DVB_APP_POP_MSG_REC_ENTER_NOT_VALID);
            MID_Recorder_SetRecMode(MID_REC_MODE_MAX);
            APP_GUIOBJ_DVB_PvrRec_RegUninitCallback();
            DVBApp_DataApplicationSwitch(OSD2CTRLMDL_ENABLE | OSD2CTRLMDL_SUB);
            return SP_ERR_FAILURE;
        }
		else
		{
			_DVBApp_ShowPopup(DVB_APP_POP_MSG_AUTOTIMESHIFT_INIT);
		}
    }
#ifdef SUPPORT_LED_FLASH
	APP_LED_Flash_Timer_Set(LED_FLASH_TYPE_RECODER, LED_FLASH_TIMER_RECODER);
#endif

    return SP_SUCCESS;
}


INT32 DVBApp_StopRecord(void)
{
	AL_SCH_sched_id_t StopId= AL_SCH_INVALID_ID;
	AL_SCH_sched_id_t DurId= AL_SCH_INVALID_ID;
	StopId = DVBAPP_Pvr_GetStopTimer_id();
	if (StopId != AL_SCH_INVALID_ID)
	{
		//UnSchedule stop timer
		AL_SCH_UnScheduleEvent(&StopId);
		DVBApp_Pvr_SetStopTimer_id();
	}
	DurId = APP_GUIOBJ_DVB_PvrRecDurationTime_GetDurationID();
	if (DurId != AL_SCH_INVALID_ID)
	{
		//UnSchedule duration timer
		AL_SCH_UnScheduleEvent(&DurId);
		APP_GUIOBJ_DVB_PvrRecDurationTime_ResetDurationID();
	}
/* //need modify kai.wang
    extern INT32 APP_GUIOBJ_DVB_TimerList_GetRecordingPR(AL_PR_details_t* details, int* PROffset);
    extern AL_Return_t APP_GUIOBJ_DVB_TimerList_DeleteRecordingPR(int Param);
    int iOffset = 0;
    if (APP_GUIOBJ_DVB_TimerList_GetRecordingPR(NULL, &iOffset) == AL_SUCCESS)
    {
        APP_GUIOBJ_DVB_TimerList_DeleteRecordingPR(iOffset);
#ifdef SUB_CUSTOMER_Tianle
		if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_TIMERLIST_FORTEAC))
		{
			SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_DVB, DVB_GUIOBJ_TIMERLIST_FORTEAC,
				APP_GLOBAL_EVENT_REFRESH_DATA, 0);
		}
#else
		if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_TIMERLIST))
		{
			SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_DVB, DVB_GUIOBJ_TIMERLIST,
				APP_GLOBAL_EVENT_REFRESH_DATA, 0);
		}
#endif
    }
*/
#ifdef SUPPORT_PVR_RECORD_PLAY_CURRENTRECORD
    if ((DVBAPP_Pvr_GetRECPlayFlag())
        && (MID_REC_MODE_MANUAL == MID_Recorder_GetRecMode()))
    {
        if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVRREC_INFO))
        {
            SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PVRREC_INFO);
        }
        if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO))
        {
            SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO);
        }
        APP_GUIOBJ_DVB_PvrPlayInfo_StopTimeshift();
    }
#endif
    if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVRREC_INFO))
    {
        SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PVRREC_INFO);
    }
    if (MID_RecorderIsCurRecording() == DRV_SUCCESS)
    {
    	APP_GUIOBJ_DVB_PvrRec_StopRecord();
    }
    if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_REC))
    {
        SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PVR_REC);
    }
    if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_PAUSE))
    {
        SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PVR_PAUSE);
    }
    if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_RECDURATIONTIME))
    {
        SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PVR_RECDURATIONTIME);
    }
#ifdef SUPPORT_WAKEUP_TIMER_IN_STANDBY
	//check for standby recorder for the case stop rec unnormally
	//sent to man app to call APP_WAKEUP_CompleteNotify();
	MAINAPP_SendGlobalEvent(APP_GLOGAL_EVENT_PVR_TIEMRREC_CHECKSTANDBY, AL_POWER_STATE_OFF);
#endif

#ifdef SUPPORT_LED_FLASH
	APP_LED_Flash_Timer_Set(LED_FLASH_TYPE_RECODER, 0);
#endif

	APP_GUIOBJ_DVB_PvrRecInfo_SetDiskFull(FALSE);
    DVBApp_DataApplicationSwitch(OSD2CTRLMDL_ENABLE | OSD2CTRLMDL_SUB);
	int u8MidRecState;
	al_uint8 u8AutoTimeShift;
    u8MidRecState = MID_RecorderState();
    AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FEATURE,
                    ITEM_OFFSET(APP_SETTING_Feature_t, AutoTimeShift),
                    sizeof(g_stFeatureData.AutoTimeShift), &(g_stFeatureData.AutoTimeShift));
    u8AutoTimeShift = g_stFeatureData.AutoTimeShift;
    if (APP_PVR_TIMESHIFT_AUTO == u8AutoTimeShift && u8MidRecState == MID_REC_STATUS_STOP)
    {
		DVBApp_SetBGTimeshift(PVR_BGTIMESHIFT_START_INTERVAL);
	}
    return SP_SUCCESS;
}

INT32 DVBApp_StopTimeshift(Boolean bIsStopRec)
{
    if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVRREC_INFO))
    {
        SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PVRREC_INFO);
    }
    if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO))
    {
        SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO);
    }

    APP_GUIOBJ_DVB_PvrPlayInfo_StopTimeshift();
    if (bIsStopRec)
    {
#ifdef SUPPORT_LED_FLASH
		APP_LED_Flash_Timer_Set(LED_FLASH_TYPE_RECODER, 0);
#endif
		char szPtName[20];
		int sdDefPtIdx = 0;
		MID_RecorderGetDefaultPartition(&sdDefPtIdx);
		MID_PartitionList_GetMountName(sdDefPtIdx, szPtName);

		MID_RecorderStop();
		MID_RecorderSetProgHandle(0);
		MID_Recorder_SetRecMode(MID_REC_MODE_MAX);
		MID_RecorderDeleteTSPLFiles();	//delete TSPL buffer when Timeshift without Timeshift to Record enabled
		MID_Recorder_DeleteTShistIfExist(szPtName);
    }
    return SP_SUCCESS;
}

static UINT8 DVBApp_CheakFocusPopOnlyForRECicon(void)
{
	//For the problem: REC icon can not show when there are only some pops focused under REC
	UINT8 Flag = 0;
	INT32 iFocusedIndex = 0;
	if (SYSTEM_APP_NO_FOCUSED_GUIOBJ == SYSAPP_GOBJ_GetFocusedGUIObject(SYS_APP_DVB, &iFocusedIndex))
	{
		return Flag;
	}
	if (DVB_GUIOBJ_POPMSG == iFocusedIndex)
	{
		if(DVBApp_IsPopupExist(PLAYBACK_POPUP_MSG_RADIO_CHANNEL)
			||DVBApp_IsPopupExist(PLAYBACK_POPUP_MSG_NO_SIGNAL)
			||DVBApp_IsPopupExist(PLAYBACK_POPUP_MSG_TEMPSERVICE)
			||DVBApp_IsPopupExist(PLAYBACK_POPUP_MSG_TEMPSERVICE_SERVICE_NOT_RUNNING)
			||DVBApp_IsPopupExist(PLAYBACK_POPUP_MSG_SCRAMBLED)
			||DVBApp_IsPopupExist(PLAYBACK_POPUP_MSG_SERVICE_NOT_AVAILABLE)
			||DVBApp_IsPopupExist(PLAYBACK_POPUP_PWD_LOCKED))
		{
			Flag = 1;
		}
	}
	return Flag;
}

static INT32 _DVBApp_Recorder_PauseResume(void)
{
    int iFocusedIndex;
    if (MID_RecorderState() == MID_REC_STATUS_PAUSE)
    {
        if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_REC))
        {
            SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PVR_REC);
            SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, DVB_GUIOBJ_PVR_PAUSE, 0);
        }
        else if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO))
        {
            SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, DVB_GUIOBJ_PVR_PAUSE, 0);
        }
        else if (SYSTEM_APP_NO_FOCUSED_GUIOBJ == SYSAPP_GOBJ_GetFocusedGUIObject(SYS_APP_DVB, &iFocusedIndex)
                || DVBApp_CheakFocusPopOnlyForRECicon())
        {
            SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, DVB_GUIOBJ_PVR_PAUSE, 0);
        }

    }
    if (MID_RecorderState() == MID_REC_STATUS_START)
    {
        if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_PAUSE))
        {
            SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PVR_PAUSE);
            if (MID_REC_MODE_MANUAL == MID_Recorder_GetRecMode())
            {
                SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, DVB_GUIOBJ_PVR_REC, 0);
#ifdef SUPPORT_PVR_RECORD_PLAY_CURRENTRECORD
				if(DVBAPP_Pvr_GetRECPlayFlag())
				{
					SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO, PVR_PLAYINFO_ENTERNORMAL);
				}
#endif
			}
        }
    }
    return SP_SUCCESS;
}

void DVBApp_SetPVRSwitchSRC(Boolean Switch)
{
	g_bPVRSwitchSource = Switch;
}

Boolean DVBApp_GetPVRSwitchSRC(void)
{
	return g_bPVRSwitchSource;
}

void DVBApp_SetTVRadioSwap(Boolean IsSwap)
{
    g_bTvRadioSwap = IsSwap;
}

Boolean DVBApp_GetTVRadioSwap(void)
{
    return g_bTvRadioSwap;
}

AL_RecHandle_t DVBApp_GetSCHProgHandle(void)
{
    return g_stDetails.rem_details.handle;
}


UINT32 DVBApp_GetTimerRECStartTime(void)
{
	return g_stDetails.start_local_time_secs;
}

UINT32 DVBApp_GetReminderTime2Show(void)
{
	al_uint32 CurTimeInSec = 0;
	AL_Time_GetCurTimeInSecs(&CurTimeInSec);
	if (g_stDetails.start_local_time_secs > CurTimeInSec)
	{
		return (g_stDetails.start_local_time_secs-CurTimeInSec);
	}
	else
	{
		return 1;//show 1 sec
	}
}

UINT32 DVBApp_PVRRec_SetTimerCancle(void)
{
	AL_PR_details_t stDetails;
	if (g_stDetails.snooze_time_secs == 0)
	{
		AL_PR_Delete(g_dReminderId);
	}
	else
	{
		memset(&stDetails, 0x0, sizeof(AL_PR_details_t));
		memcpy(&stDetails, &g_stDetails, sizeof(AL_PR_details_t));
		stDetails.start_local_time_secs = stDetails.start_local_time_secs +
			stDetails.snooze_time_secs;
		stDetails.rem_details.event_end_time_insec = stDetails.rem_details.event_end_time_insec +
			stDetails.snooze_time_secs;
		if (AL_PR_Modify(&stDetails, g_dReminderId) != AL_SUCCESS)
		{
			dvb_printf("\n[%s]reschedule the reminder fail\n",__FUNCTION__);
			return SP_ERR_FAILURE;
		}
	}
	return SP_SUCCESS;
}

void DVBApp_SetRemType(AL_PR_type_t remtype)
{
	g_remtype = remtype;
}

AL_PR_type_t DVBApp_GetRemType(void)
{
	return g_remtype;
}

void _DVBApp_PVR_UpdateState(void)
{
	UINT8 u8AutoTimeShift;
    UINT8 u8MidRecState;
	INT32 I32DefPartition;

	u8MidRecState = MID_RecorderState();
    AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FEATURE,
                    ITEM_OFFSET(APP_SETTING_Feature_t, AutoTimeShift),
                    sizeof(g_stFeatureData.AutoTimeShift), &(g_stFeatureData.AutoTimeShift));
    u8AutoTimeShift = g_stFeatureData.AutoTimeShift;

	AL_DB_EDBType_t eNetType = APP_DVB_Playback_GetCurrentNetType();
#if defined (CONFIG_SUPPORT_USB_UPGRADE) || defined (CONFIG_SUPPORT_OTA_UPGRADE)
	if (Mid_CmnUpgradeIsUpgradeing()== TRUE)
	{
		if ( MID_RecorderIsCurRecording() == DRV_SUCCESS)
		{
			dvb_printf("[debug]%s		%d\n",__FUNCTION__,__LINE__);
			dvb_printf("System is upgradeing........\n\n\n");
			DVBApp_StopTimeshift(TRUE);
		}
		if (u8AutoTimeShift == APP_PVR_TIMESHIFT_AUTO)
		{
			dvb_printf("[debug]%s		%d\n",__FUNCTION__,__LINE__);
			dvb_printf("System is upgradeing........\n\n\n");
			u8AutoTimeShift = APP_PVR_TIMESHIFT_OFF;
		}
	}
	if((g_dCurPopup== POPMSG_CONFIRM_ERASE_WHOLE_FLASH)
		#ifdef CONFIG_SUPPORT_USB_AUTO_UPGRADE
		|| (g_dCurPopup == POPMSG_CONFIRM_START_AUTO_UPGRADE)
		#endif
		)
	{
		if (u8AutoTimeShift == APP_PVR_TIMESHIFT_AUTO)
		{
			dvb_printf("[debug]%s		%d\n",__FUNCTION__,__LINE__);
			dvb_printf("confirm if upgrade........\n\n\n");
			u8AutoTimeShift = APP_PVR_TIMESHIFT_OFF;
		}
	}
#endif

    if ((g_u8BGTimeshiftStart > 0)
		&& (APP_PVR_TIMESHIFT_AUTO == u8AutoTimeShift)
		&& (u8MidRecState == MID_REC_STATUS_STOP)
		)
	{
		if (--g_u8BGTimeshiftStart == 0)
        {
            if ((MID_RecorderGetDefaultPartition(&I32DefPartition) != MID_REC_FS_OK)
                || SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_FILEPLAY))
            {
                g_u8BGTimeshiftStart = PVR_BGTIMESHIFT_START_INTERVAL;
            }
            else
            {

                UINT8 u8ProgLockState = FALSE;
                u8ProgLockState = APP_DVB_Playback_GetProgStateByHandle(eNetType, AL_DB_INVALIDHDL);
				if ((u8ProgLockState == MID_PLAYBK_PROG_STATE_LOCKED)
                    || (MID_TSPLParser_GetThreadState() == TRUE)
                    || (DVBApp_CheckServiceNotAvailable() == TRUE)
					)
                {
                    g_u8BGTimeshiftStart = PVR_BGTIMESHIFT_START_INTERVAL;
                }
                else
                {
					if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_POPMSG))
					{
						SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_POPMSG);
					}
                    if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PROGINFO))
                    {
                        SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PROGINFO);
                    }

                    PVR_DEBF("[%s: %d] ============start BG timeshift!!! \n", __FUNCTION__, __LINE__);
                    //DVBApp_ResetPopup_Channel();
                    if (DVBApp_StartRecord(MID_REC_MODE_AUTO) == SP_ERR_FAILURE)
					{
						g_u8BGTimeshiftStart = PVR_BGTIMESHIFT_START_INTERVAL;
					}
                }
            }
        }
    }

    if (u8MidRecState != MID_REC_STATUS_STOP)
    {
        int iFocusedIndex;
        AL_RecHandle_t hRecProg;
        AL_RecHandle_t hCurProg;
        AL_DB_EDBType_t DBType = AL_DBTYPE_MAX;
        UINT8 u8MIDRecMode;

        APP_Database_GetCurrentDBType(APP_SOURCE_DTV, &DBType);
        hCurProg = APP_DVB_Playback_GetCurrentProgHandle(DBType, AL_RECTYPE_DVBTV | AL_RECTYPE_DVBRADIO | AL_RECTYPE_DVBDATA);
        hRecProg = MID_RecorderGetProgHandle();
        u8MIDRecMode = MID_Recorder_GetRecMode();
        if ((hCurProg != hRecProg || (APP_IsScan_Running()== TRUE))&& ( MID_RecorderIsCurRecording() == DRV_SUCCESS))
        {
            PVR_DEBF("\n\n\n[%s: %d]============== program/TS change!!\n\n\n", __FUNCTION__, __LINE__);
            if (MID_REC_MODE_MANUAL == u8MIDRecMode)
            {
                DVBApp_StopRecord();
            }
            else if ((MID_REC_MODE_TIMESHIFT_AFTER_REC == u8MIDRecMode) ||
                     (MID_REC_MODE_AUTO == u8MIDRecMode))
            {
                DVBApp_StopTimeshift(FALSE);
                if (APP_PVR_TIMESHIFT_AUTO == u8AutoTimeShift)
                {
                    DVBApp_SetBGTimeshift(PVR_BGTIMESHIFT_START_INTERVAL);
                }
            }
            return;
        }

        // deal with PAUSE/REC/TIMESHIFT menu flow
        if (SYSTEM_APP_NO_FOCUSED_GUIOBJ == SYSAPP_GOBJ_GetFocusedGUIObject(SYS_APP_DVB, &iFocusedIndex)
            || DVBApp_CheakFocusPopOnlyForRECicon())    //reshow PVR menu
        {
            if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PROGINFO))
            {
                return;
            }
            if (MID_REC_MODE_TIMESHIFT_AFTER_REC == u8MIDRecMode)
            {
				if ((u8MidRecState == MID_REC_STATUS_PAUSE) &&
                    (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_PAUSE)))
                {
                    SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, DVB_GUIOBJ_PVR_PAUSE, 0);
                }
				if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO))
                {
                    if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVRREC_INFO))
                    {
                        SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PVRREC_INFO);
                    }
                    SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO, 0);
                }
                else if ((APP_GUIOBJ_DVB_PvrPlayInfo_ExitTimeMenu() == FALSE)
                        && (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVRREC_INFO)))
                {
                    APP_GUIOBJ_DVB_PvrPlayInfo_CreatTimemenu();
                }
            }
            else if ((MID_REC_MODE_AUTO == u8MIDRecMode) &&
                     (PVR_STATE_STOP != APP_GUIOBJ_DVB_PvrPlayInfo_GetRecState()))
            {
                if ((u8MidRecState == MID_REC_STATUS_PAUSE) &&
                    (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_PAUSE)))
                {
                    SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, DVB_GUIOBJ_PVR_PAUSE, 0);
                }
                if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO))
                {
                    if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVRREC_INFO))
                    {
                        SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PVRREC_INFO);
                    }
                    SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO, 0);
                }
                else if ((APP_GUIOBJ_DVB_PvrPlayInfo_ExitTimeMenu() == FALSE)
                        && (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVRREC_INFO)))
                {
                    APP_GUIOBJ_DVB_PvrPlayInfo_CreatTimemenu();
                }
            }
            else if ((MID_REC_MODE_MANUAL == u8MIDRecMode) &&
                     (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_REC)) &&
                     (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_PAUSE)))
            {
                if (u8MidRecState == MID_REC_STATUS_START)
                {
                    SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, DVB_GUIOBJ_PVR_REC, 0);
#ifdef SUPPORT_PVR_RECORD_PLAY_CURRENTRECORD
					if((DVBAPP_Pvr_GetRECPlayFlag())
                        && (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO)))
					{
						SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO, PVR_PLAYINFO_ENTERNORMAL);
					}
#endif
				}
                else if (u8MidRecState == MID_REC_STATUS_PAUSE)
                {
                    SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, DVB_GUIOBJ_PVR_PAUSE, 0);
#ifdef SUPPORT_PVR_RECORD_PLAY_CURRENTRECORD
					if((DVBAPP_Pvr_GetRECPlayFlag())
                        && (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO)))
					{
						SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO, PVR_PLAYINFO_ENTERNORMAL);
					}
#endif
				}
            }
        }
        if ((MID_REC_STATUS_PAUSE == u8MidRecState)
            && (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_PAUSE)))//show pause menu
        {
            if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_REC))
            {
                SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PVR_REC);
                SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, DVB_GUIOBJ_PVR_PAUSE, 0);
            }
            else if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO))
            {
                SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, DVB_GUIOBJ_PVR_PAUSE, 0);
            }
            else if (SYSTEM_APP_NO_FOCUSED_GUIOBJ == SYSAPP_GOBJ_GetFocusedGUIObject(SYS_APP_DVB, &iFocusedIndex)
                    || DVBApp_CheakFocusPopOnlyForRECicon())
            {
                SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, DVB_GUIOBJ_PVR_PAUSE, 0);
            }
        }
        else if (MID_REC_STATUS_START == u8MidRecState) //hide pause menu
        {
            if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_PAUSE))
            {
                SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PVR_PAUSE);
                if (MID_REC_MODE_MANUAL == u8MIDRecMode)
                {
                    SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, DVB_GUIOBJ_PVR_REC, 0);
#ifdef SUPPORT_PVR_RECORD_PLAY_CURRENTRECORD
					if((DVBAPP_Pvr_GetRECPlayFlag())
                        && (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO)))
					{
						SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO, PVR_PLAYINFO_ENTERNORMAL);
					}
#endif
				}
            }
        }
    }
    else    //rec stop, destroy all pvr menu
    {
        if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_REC))
        {
            SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PVR_REC);
        }
        if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_PAUSE))
        {
            SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PVR_PAUSE);
        }
        if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO))
        {
             SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO);
        }
    }
}
Boolean g_PVR_TimerRecStart = FALSE;
Boolean DVBApp_PVRDEMUX_GetTimerRECFLag(void)
{
    return g_PVR_TimerRecStart;
}

void DVBApp_PVRDEMUX_SetTimerRECFLag(Boolean bFlag)
{
    g_PVR_TimerRecStart = bFlag;
}

#ifdef SUPPORT_PVR_REMINDER_CONFIRM_SPEC
static void _DVBApp_StopRECForTimerConfirmDone(UINT32 dParam)
{
    AL_DB_EDBType_t          DBType_ret = AL_DBTYPE_DVB_SBTVD;
    AL_DB_EDBType_t          DBType_Current = AL_DBTYPE_DVB_SBTVD;
    AL_DB_ERecordType_t    RecType = AL_RECTYPE_DVBTV;
    AL_RecHandle_t CurrentProgHandle;
    al_uint32 u32CurrentTime = 0;
    UINT8 u8MIDRecMode = MID_Recorder_GetRecMode();
    /*  get timer program  */
    AL_DB_GetRecordType(g_stDetails.rem_details.handle, &DBType_ret, &RecType);

    /* get current program handele */
    AL_Setting_Reload(APP_Data_UserSetting_Handle(), SYS_SET_ID_CHANNEL);
    AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_CHANNEL, 0,
                    sizeof(APP_SETTING_Channel_t), &(g_stChannelData));

	DBType_Current = AL_DBTYPE_DVB_SBTVD;

    CurrentProgHandle   = APP_DVB_Playback_GetCurrentProgHandle(DBType_Current, AL_RECTYPE_DVBTV | AL_RECTYPE_DVBRADIO | AL_RECTYPE_DVBDATA);
    if ((dParam == POPMSG_CONFIRM_STOP_REC_FOR_TIMER_REC)
        ||(dParam == POPMSG_CONFIRM_STOP_TSHIFT_FOR_TIMER_REC))
    {
        AL_Time_GetCurTimeInSecs(&u32CurrentTime);
        dvb_printf("================ current time %d\n",u32CurrentTime);

        dvb_printf("================ rec end time %d\n", g_stDetails.rem_details.event_end_time_insec);
        if (u32CurrentTime >
             (g_stDetails.rem_details.event_end_time_insec-10))
        {
            /* if the left time is less than 10Sec. not to respond the confirm */
            _DVBApp_ShowPopup(DVB_APP_POP_MSG_TIMER_OUT_OF_DATE);
            return;
        }
    }

    /*  zap prog */
    if (g_stDetails.rem_details.handle  != CurrentProgHandle)
    {
        PVR_DEBF("handle             ==== %d\n", g_stDetails.rem_details.handle);
        PVR_DEBF(" CurrentProgHandle ==== %d\n", CurrentProgHandle);
        g_ProgHandleB4Rec = g_stDetails.rem_details.handle;
        if (MID_RecorderIsCurRecording() == DRV_SUCCESS)
        {
            if (u8MIDRecMode == MID_REC_MODE_MANUAL)
                DVBApp_StopRecord();
            else
                DVBApp_StopTimeshift(TRUE);
        }
        _DVBApp_CloseAllMenu();
        _DVBApp_Zapping(RecType, g_stDetails.rem_details.handle, FALSE, 0, TRUE);
    }
    if (g_stDetails.rem_type == AL_PR_EVT_REM)
    {
        if (MID_RecorderIsCurRecording() == DRV_SUCCESS)
        {
            if (u8MIDRecMode == MID_REC_MODE_MANUAL)
                DVBApp_StopRecord();
            else
                DVBApp_StopTimeshift(TRUE);
        }
        DVBApp_ResetPopup_Channel();
        _DVBApp_CloseAllMenu();
		_APP_GUIOBJ_DVB_PvrRecDurationTime_ResetDurTime();
        if (DVBApp_StartRecord(MID_REC_MODE_MANUAL) != SP_SUCCESS)
        {
            APP_GUIOBJ_DVB_PvrRec_SetTimerRecord(FALSE);
            DVBApp_SetTVRadioSwap(FALSE);
            g_ProgHandleB4Rec = 0;
            return;
        }
        //APP_GUIOBJ_DVB_PvrRecDurationTime_SetDurTime(g_stDetails.rem_details.event_end_time_insec);
    }
    if ((dParam == POPMSG_CONFIRM_STOP_REC_FOR_REMINDER)
        ||(dParam == POPMSG_CONFIRM_STOP_TSHIFT_FOR_REMINDER))
    {
        DVBApp_SetTVRadioSwap(FALSE);
        g_ProgHandleB4Rec = 0;
#ifdef SUPPORT_WAKEUP_TIMER_IN_STANDBY
        if(APP_WAKEUP_GetBootFlag() == TRUE)
        {
            APP_WAKEUP_RealPowerUp();
        }
#endif
    }
}
#endif
#endif

#ifdef TEAC_BLUE_KEY_FUNCTION
APP_Panel_PowerSequenceType_e _DVB_GetPanelControlType(void)
{
    return g_eAppPanelOnOff;
}
void _DVB_SetPanelControlType(APP_Panel_PowerSequenceType_e eType)
{
    g_eAppPanelOnOff = eType;
}
#endif
static INT32 _DVBApp_OnCreate(void **ppPrivateData)
{
    dvb_printf(" %s is called.\n", __FUNCTION__);
    _DVBApp_DTV_main_program(NULL);
    DvbPrivateData_t *pDvbPrivateData = (DvbPrivateData_t *) GL_MemAlloc(sizeof(DvbPrivateData_t));
    memset(pDvbPrivateData, 0x00, sizeof(DvbPrivateData_t));
    pDvbPrivateData->dUserData = 0;
    (*ppPrivateData) = (void *)pDvbPrivateData;

    stDvbInst.bAppState = SYSTEM_IDLE;

    return 0;
}

static INT32 _DVBApp_OnDestroy(void **ppPrivateData)
{
    dvb_printf(" %s is called.\n", __FUNCTION__);
    SYSAPP_GOBJ_FinalizeGUIObject(SYS_APP_DVB);
    GL_MemFree((*ppPrivateData));
    (*ppPrivateData) = NULL;

    return 0;
}

static INT32 _DVBApp_OnRun(void *pPrivateData, UINT32 dParam)
{
    dvb_printf(" %s is called.\n", __FUNCTION__);

#if 0	//set ttx codepage when open create ttx.
	UINT32 u32DTVTTXZone = 0;
#endif

    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));
    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));
    AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_MULTIMEDIA, 0,
                    sizeof(APP_SETTING_Multimedia_t), &(g_stMultiMediaData));
    AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_SETUP, 0,
                    sizeof(APP_SETTING_Setup_t), &(g_stSetupData));
    AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FEATURE, 0,
                    sizeof(APP_SETTING_Feature_t), &(g_stFeatureData));
    stDvbInst.bAppState = SYSTEM_RUNNING;
    dvb_printf(" Dvbt state is %d.\n", stDvbInst.bAppState);

    if (dParam == 0)
    {
#ifdef SHOW_LOGO_NOSIGNAL
        // init show logo
    #ifdef JPEG_LOGO
        LOGO_Init();
        extern char *pu32LMA;
        extern unsigned int pu32LMASize;
        LOGO_SetParam((const UINT8 *)pu32LMA, pu32LMASize);

        //LOGO_SetShowPicLogoPlane(Logo_VPP_PLANE);
        //LOGO_StartUp_Pic_Show_AlignOrigin(gpAL_PanelDisplayDesc->Size.wHorSize, gpAL_PanelDisplayDesc->Size.wVerSize);
    #else
        extern const unsigned char DVDTitle[];
        extern const int DVDTitleSize;
        LOGO_Init();
        LOGO_SetParam(DVDTitle, DVDTitleSize);
    #endif
#else
        //mute screen to black or user define color
#endif
    }

    APP_GUIOBJ_PopMs_SetCloseFun(DVBApp_ClosePopup);
    APP_GuiMgr_Set_Menu() ;
	APP_GuiMgr_SwitchShareMenu(SYS_APP_DVB);

//    AUDIF_Set_OutputMode(OUT_RFModeK3, 0);
//    AUDIF_Set_OutputMode(OUT_CustomModeB_DigitalDialnormK1, 0x6464);

    SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_DVB,
		APP_DVB_GLOBAL_EVENT_DVB_ONRUN | PASS_TO_SYSAPP,TRUE);
	dvb_printf(" %s is exit., time: %d\n", __FUNCTION__,GL_GetRtc32());
	return 0;
}

static INT32 _DVBApp_OnTerminate(void *pPrivateData, UINT32 dParam)
{
	dvb_printf(" %s is called., time: %d\n", __FUNCTION__,GL_GetRtc32());

    DVBApp_DataApplicationSwitch(OSD2CTRLMDL_DISABLE | OSD2CTRLMDL_ALL);

    if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_FREEZE))
    {
#ifdef Subtitle_Freeze
		if(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_SUBTITLE))
		{
			AL_Subtitle_SetFreeze(FALSE);
		}
#endif
        SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_FREEZE);
    }
    if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_MUTE))
    {
        SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, APP_GUIOBJ_MUTE);
    }

    SYSAPP_GOBJ_FinalizeGUIObject(SYS_APP_DVB);
    g_u32OldPopup = PLAYBACK_POPUP_NONE;

	APP_GuiMgr_UnInitDvbOSD2();
    stDvbInst.bAppState = SYSTEM_IDLE;
#ifdef CONFIG_SUPPORT_PVR
	MID_TSPLParser_UnInit();
#endif
	dvb_printf(" %s is exit., time: %d\n", __FUNCTION__,GL_GetRtc32());
    return 0;
}

static void _DVBApp_Process_Unmute(void)
{
	UINT8 RegionIdx = 0;
	ColorLUT_t stColorLUTValue;
    APP_Source_Type_t eSourType = APP_SOURCE_MAX;
    APP_StorageSource_Type_t eStorageSourType = APP_STORAGE_SOURCE_MAX;
    if ((g_bMidHasUnmute == TRUE) && (bSetUnMuteFlag == TRUE))
    {
        if (g_SetPQFlag == FALSE)
        {
            g_SetPQFlag = TRUE;
            /*set PQ param*/
			AL_FLASH_GetColorLUTALL(&stColorLUTValue);

			for(RegionIdx = 0; RegionIdx<APP_ColorLUT_NUM; RegionIdx++)
			{
				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==6? TRUE : FALSE);
			}

            APP_GUIOBJ_Source_GetCurrSource(&eSourType);
            eStorageSourType = APP_Data_UserSetting_SourceTypeMappingToStorage(eSourType);
            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.stPictureModeSourceTab[eStorageSourType].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);
		}
        DVBApp_CheckProgramType(TRUE);
        bSetUnMuteFlag = FALSE;
    }
}

static INT32 _DVBApp_OnTimerUpdate(void *pPrivateData)
{
    UINT32 NoSignalTimer;
    INT32 dFocusedIndex;
	al_uint8 bMonitorState = al_false;
	al_uint8 bSignalState = al_false;
    APP_Source_Type_t eSourType = APP_SOURCE_MAX;
	AL_DB_EDBType_t eNetType = APP_DVB_Playback_GetCurrentNetType();
	AL_DB_ERecordType_t eServiceType = APP_DVB_Playback_GetCurrServiceType(eNetType);
	al_bool bHasValidServ = AL_DB_HasVisibleService(eNetType);

	/*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;
		}
	}
	/*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_DVB_Playback_GetZappingState())
	{
		g_u8ZappingTimer++;
		if (g_u8ZappingTimer >= 2)//3*100ms
		{
			APP_GUIOBJ_DVB_Playback_SetZappingState(FALSE);
			g_u8ZappingTimer = 0;
		}
	}
	//Polling DSP to detect audio channel num change.
	g_AdioChnPolTime++;
	if (g_AdioChnPolTime >= 10)//10*100ms = 1s
	{
		APP_Audio_PollingAudioChnannelNum();
		g_AdioChnPolTime = 0;
	}
	
    APP_GUIOBJ_Source_GetCurrSource(&eSourType);
    if (SYSTEM_APP_NO_FOCUSED_GUIOBJ == SYSAPP_GOBJ_GetFocusedGUIObject(SYS_APP_DVB, &dFocusedIndex))
    {
        _DVBApp_CheckPopupDisplay();
    }

	AL_DVB_Monitor_GetState(AL_DVB_MONITOR_STATE_MONITOR, &bMonitorState);
	AL_DVB_Monitor_GetState(AL_DVB_MONITOR_STATE_SIGNAL, &bSignalState);
	
#ifdef PLAY_VIDEO_FOR_ALLSRV
	AL_RecHandle_t hTempHdl = AL_DB_INVALIDHDL;

	MID_PlaybackGetCurProgHandle(al_null, &hTempHdl);
	DBPIDInfo_t 	stVideoPid;
	memset(&stVideoPid,0xff,sizeof(DBPIDInfo_t));

	AL_DB_QueryDetailFieldByName(hTempHdl, (al_uint8 *)"stVideoPid", (al_void *)&stVideoPid);
#endif	

    if (!bHasValidServ)
    {
    	g_bTempSerFlag = FALSE;
        if (SYSTEM_APP_NO_FOCUSED_GUIOBJ == SYSAPP_GOBJ_GetFocusedGUIObject(SYS_APP_DVB, &dFocusedIndex))
        {
			AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FACTUSER, 0,
				sizeof(APP_SETTING_FactoryUser_t), &(g_stFactoryUserData));

			if (!DVBApp_IsPopupExist(PLAYBACK_POPUP_MSG_DATABASE_EMPTY) && !g_stFactoryUserData.n_FactSet_BurningMode)
            {
                SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_DVB,
					DVB_GUIOBJ_PLAYBACK, APP_DVB_INTRA_EVENT_SHOWLOGO, 0);
                DVBApp_ResetPopup_Channel();
                _DVBApp_ShowPopup(DVB_APP_POP_MSG_DATABASE_EMPTY);
                DVBApp_CheckProgramType(FALSE);
            }
        }
#ifdef CONFIG_SUPPORT_PVR
		if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_FILEPLAY))
#endif
		{
        	return 0;
		}
    }
    else if (bMonitorState == al_true)
	{
		if (bSignalState == AL_DVB_MONITOR_VALUE_FALSE)
	    {
	    	g_bTempSerFlag = FALSE;
	    	if(!(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_SLEEP_INFO))||
			   !(APP_MenuMgr_Exist_Factory_Menu()))
			{
	    		g_u32NoSignalTimer ++;
	    		g_u32NoSignalSleepTimer ++;
			}
#ifdef CONFIG_SUPPORT_PVR
			if(MID_TSPLParser_GetThreadState() == TRUE)
			{
				g_u32NoSignalSleepTimer = 0;
			}
#endif
/*2.1.10 Input factory auto test mode close no signal standby function*/
#ifdef SUPPORT_FACTORY_AUTO_TEST
			if(APP_Factory_GetAutoTestOnOff() == TRUE)
			{
				g_u32NoSignalTimer = 0;
				g_u32NoSignalSleepTimer = 0;
			}
#endif
	        if (g_u32NoSignalSleepTimer == DVB_10_MINUTES)
	        {
	            g_u32NoSignalSleepTimer = 0;
				if(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_SLEEP_INFO) && (APP_GUIOBJ_SleepTimer_GetStandbyPopConflict() == FALSE))
				{
					APP_GUIOBJ_SleepTimer_SetStandbyPopConflict(TRUE);
		 		}
	            SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_DVB,
	                     	(APP_GLOBAL_EVENT_SLEEP_TIMER_INFO | PASS_TO_SYSAPP), APP_POWERDOWN_NO_SINGAL);
	        }

	        if (APP_RF_TYPE_DVB_S == g_stChannelData.TV_Connection)
	        {
	        	NoSignalTimer = 45;
	        }
	        else
	        {
	        	NoSignalTimer = 15;
	        }
	        if (g_u32NoSignalTimer >= NoSignalTimer)//15*100ms
	        {
	            if ((eSourType == APP_SOURCE_DTV)
					|| (eSourType == APP_SOURCE_RADIO))
	            {
#ifdef CONFIG_SUPPORT_PVR		//if playing timeshift file not to mute video
	                UINT32 u32PEState = MID_TSPL_MODE_STOP;
	                if (MID_TSPLParser_GetPlayState(&u32PEState, NULL) == DRV_SUCCESS)
	                {
	                    if (MID_TSPL_MODE_STOP == u32PEState)
	                    {
	                        if (!DVBApp_IsPopupExist(PLAYBACK_POPUP_MSG_NO_SIGNAL) && !SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_PAUSE))
		               	 	{
								SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_DVB,
		                                            	APP_DVB_GLOBAL_EVENT_NO_SIGNAL, 0);
		                    }
	                    }
	                }
					else
#endif
	                if (!DVBApp_IsPopupExist(PLAYBACK_POPUP_MSG_NO_SIGNAL))
	                {
#ifdef CONFIG_SUPPORT_PVR
	                    if (MID_RecorderState() != MID_REC_STATUS_STOP)
	                    {
	                        PopmsgType_t eType = POPMSG_TYPE_NONE;
	                        APP_GUIOBJ_PopMsg_GetMsgType(&eType);
	                        if (eType != POPMSG_TYPE_CONFIRM)
	                        {//not to send no signal event to clear comfirm type popmsg
	                            SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_DVB,
	                                   	APP_DVB_GLOBAL_EVENT_NO_SIGNAL, 0);
	                        }
	                    }
	                    else
#endif
	                    {
							if(!(DVBApp_IsPopupExist(PLAYBACK_POPUP_PWD_LOCKED)))
		                    {
                                if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_POPMSG))
                                {

                                    SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_DVB,
                                        APP_DVB_GLOBAL_EVENT_NO_SIGNAL, 0);
                                }
							}
	                    }
	                }
	            }
	        }
	    }
	    else
	    {
	        g_u32NoSignalTimer = 0;
            MID_PlaybackProgState_t progstate = MID_PLAYBK_PROG_STATE_NORMAL;
            progstate = APP_DVB_Playback_GetProgStateByHandle(APP_DVB_Playback_GetCurrentNetType(), AL_DB_INVALIDHDL);
#ifdef CONFIG_SUPPORT_PVR
			if (g_bNoSteamData == TRUE
				|| progstate == MID_PLAYBK_PROG_STATE_TEMP_SERVICE
				|| progstate == MID_PLAYBK_PROG_STATE_NOT_RUNNING)
			{
				if ( MID_RecorderState()== MID_REC_STATUS_START )
				{
					if ((MID_TSPLParser_GetThreadState() != TRUE)
						&& (APP_GUIOBJ_DVB_PvrPlayInfo_GetTunerState() == FALSE))
					{
						//printf("pause\n\n\n");
						MID_RecorderPauseResume();
						_DVBApp_Recorder_PauseResume();
					}
				}
			}
			if (!(g_bNoSteamData == TRUE
				|| progstate == MID_PLAYBK_PROG_STATE_TEMP_SERVICE
				|| progstate == MID_PLAYBK_PROG_STATE_NOT_RUNNING) && g_bIsPlaykey == TRUE)
			{
				if ( MID_RecorderState()== MID_REC_STATUS_PAUSE)
				{
					//printf("start \n\n\n");
					MID_RecorderPauseResume();
					_DVBApp_Recorder_PauseResume();
				}
			}
#endif
	        if (DVBApp_CheckServiceNotAvailable() == TRUE)
			{
				//set video and audio mute for temp service
				if (g_bTempSerFlag == FALSE)
				{
					DVBApp_CheckProgramType(FALSE);
					g_bTempSerFlag = TRUE;
					DVBApp_DataApplicationSwitch(OSD2CTRLMDL_DISABLE | OSD2CTRLMDL_SUB);
				}
		        if (DVBApp_IsPopupExist(PLAYBACK_POPUP_MSG_RADIO_CHANNEL))
	            {
	                DVBApp_ClosePopup(PLAYBACK_POPUP_MSG_RADIO_CHANNEL, UI_EVENT_NULL);
	            }
	            if (SYSTEM_APP_NO_FOCUSED_GUIOBJ == SYSAPP_GOBJ_GetFocusedGUIObject(SYS_APP_DVB, &dFocusedIndex))
	            {
#ifdef SUPPORT_DISABLE_H264
					if (progstate == MID_PLAYBK_PROG_STATE_VIDEO_MPEG4)
					{
						if (!DVBApp_IsPopupExist(DVB_APP_POP_MSG_VIDEO_NOT_SUPPORT))
						{
							_DVBApp_ShowPopup(DVB_APP_POP_MSG_VIDEO_NOT_SUPPORT);
						}
					}
					else if (!DVBApp_IsPopupExist(PLAYBACK_POPUP_MSG_SERVICE_NOT_AVAILABLE))
					{
                        if(APP_Get_DTVHiddenScanState() != TRUE)
                        {
							_DVBApp_ShowPopup(DVB_APP_POP_MSG_SERVICE_NOT_AVAILABLE);
                        }
					}
#else
					if (!DVBApp_IsPopupExist(PLAYBACK_POPUP_MSG_SERVICE_NOT_AVAILABLE))
	                {
	                    if(APP_Get_DTVHiddenScanState() != TRUE)
                        {
						    _DVBApp_ShowPopup(DVB_APP_POP_MSG_SERVICE_NOT_AVAILABLE);
                        }
	                }
#endif
	            }
	        }
	        else
	        {
				if (g_bNoSteamData == TRUE
                        || progstate == MID_PLAYBK_PROG_STATE_TEMP_SERVICE
                        || progstate == MID_PLAYBK_PROG_STATE_NOT_RUNNING)
                {
                        AL_DB_EDBType_t eDBType = APP_DVB_Playback_GetCurrentNetType();
                        AL_RecHandle_t hCurrPrgHdl = AL_DB_INVALIDHDL;
                        MID_PlaybackProgState_t eProgState = MID_PLAYBK_PROG_STATE_NORMAL;
                        hCurrPrgHdl = APP_DVB_Playback_GetCurrentProgHandle(eDBType, (AL_RECTYPE_DVBTV |AL_RECTYPE_DVBRADIO));
                        if ((hCurrPrgHdl == AL_DB_INVALIDHDL) && (bSignalState != AL_DVB_MONITOR_VALUE_INVAILED))
                        {
                                DVBApp_DataApplicationSwitch(OSD2CTRLMDL_DISABLE | OSD2CTRLMDL_SUB);
                        }
                        eProgState = APP_DVB_Playback_GetProgStateByHandle(eDBType, hCurrPrgHdl);
                        if ((eProgState != MID_PLAYBK_PROG_STATE_LOCKED) && (bSignalState != AL_DVB_MONITOR_VALUE_INVAILED))
                        {
                                DVBApp_DataApplicationSwitch(OSD2CTRLMDL_DISABLE | OSD2CTRLMDL_SUB);
                        }
                }
				g_bTempSerFlag = FALSE;
				if (DVBApp_IsPopupExist(PLAYBACK_POPUP_MSG_SERVICE_NOT_AVAILABLE))
	            {
	                DVBApp_ClosePopup(PLAYBACK_POPUP_MSG_SERVICE_NOT_AVAILABLE, UI_EVENT_NULL);
	            }
#ifdef PLAY_VIDEO_FOR_ALLSRV
				if (DVBApp_CheckHasVideo() == FALSE)
#else
				if (eServiceType == AL_RECTYPE_DVBRADIO)
#endif
	            {
	        	    if ((!APP_GUIOBJ_DVB_Playback_GetShowLogoState())
						&& (progstate == MID_PLAYBK_PROG_STATE_NORMAL)
#ifdef CONFIG_SUPPORT_PVR
	                    && !(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_FILEPLAY))
#endif
	                    )
					{
						SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_DVB,
							DVB_GUIOBJ_PLAYBACK, APP_DVB_INTRA_EVENT_SHOWLOGO, 0);
					}
	            }

				if (SYSTEM_APP_NO_FOCUSED_GUIOBJ != SYSAPP_GOBJ_GetFocusedGUIObject(SYS_APP_DVB, &dFocusedIndex))
				{
					if (g_u8PopScrambleMsgTimer!=0)
					{
						g_u8PopScrambleMsgTimer = 0;
					}
				}

				if (SYSTEM_APP_NO_FOCUSED_GUIOBJ == SYSAPP_GOBJ_GetFocusedGUIObject(SYS_APP_DVB, &dFocusedIndex))
	            {
	                if (progstate == MID_PLAYBK_PROG_STATE_LOCKED)
	                {
	                    if (!DVBApp_IsPopupExist(DVB_APP_POP_MSG_CHECKPWD)
#ifdef CONFIG_SUPPORT_PVR
							&& (APP_GUIOBJ_DVB_PvrRec_IsShowPopTime(g_stDetails.start_local_time_secs) == FALSE)
#endif
							)
	                	{
							_DVBApp_ShowPopup(DVB_APP_POP_MSG_CHECKPWD);
	                	}
	                }
	                else if (progstate == MID_PLAYBK_PROG_STATE_AUDIO_VIDEO_SCRAMBLED \
	                ||progstate == MID_PLAYBK_PROG_STATE_ONLY_VIDEO_SCRAMBLED \
	                || (progstate == MID_PLAYBK_PROG_STATE_ONLY_AUDIO_SCRAMBLED && 
#ifdef PLAY_VIDEO_FOR_ALLSRV
					((stVideoPid.usDataPID&0x1fff) == 0x1fff)
#else
					eServiceType == AL_RECTYPE_DVBRADIO
#endif
					))
	                {
						g_u8PopScrambleMsgTimer ++;

						 if (!DVBApp_IsPopupExist(DVB_APP_POP_MSG_SCRAMBLE)&&g_u8PopScrambleMsgTimer>8)
	                    {
							if (DVBApp_IsPopupExist(PLAYBACK_POPUP_MSG_NO_SIGNAL))
							{
								DVBApp_ClosePopup(PLAYBACK_POPUP_MSG_NO_SIGNAL, UI_EVENT_NULL);
							}

							if (DVBApp_IsPopupExist(PLAYBACK_POPUP_MSG_RADIO_CHANNEL))
							{
								DVBApp_ClosePopup(PLAYBACK_POPUP_MSG_RADIO_CHANNEL, UI_EVENT_NULL);
							}
	                    	printf("\n#####Pop Scramble MSG Menu,F=%s,L=%d g_u8PopScrambleMsgTimer=%d######\n",__FUNCTION__,__LINE__,g_u8PopScrambleMsgTimer);
		                    _DVBApp_ShowPopup(DVB_APP_POP_MSG_SCRAMBLE);
		                    g_u8PopScrambleMsgTimer = 0;
	                	}
	                }
					else if ((eServiceType == AL_RECTYPE_DVBRADIO)
							&&(!DVBApp_IsPopupExist(PLAYBACK_POPUP_MSG_RADIO_CHANNEL))
#ifdef PLAY_VIDEO_FOR_ALLSRV
							&& ((stVideoPid.usDataPID&0x1fff) == 0x1fff)
#endif
					)
					{
						{
							if(g_bScrambleFlag != PROG_STATUS_SCRAMBLE_UNKNOW)
							{
								_DVBApp_ShowPopup(DVB_APP_POP_MSG_RADIO_CHANNEL);
							}
						}
					}
	            }
#ifdef CONFIG_SUPPORT_PVR
				else if(((dFocusedIndex == DVB_GUIOBJ_PVR_PLAYINFO) || (dFocusedIndex == DVB_GUIOBJ_PVRREC_INFO))
						&& (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_POPMSG))
						&& (eServiceType == AL_RECTYPE_DVBRADIO)
#ifdef PLAY_VIDEO_FOR_ALLSRV
						&& ((stVideoPid.usDataPID&0x1fff) == 0x1fff)
#endif
				)
				{
					{
						if(g_bScrambleFlag != PROG_STATUS_SCRAMBLE_UNKNOW)
						{
							_DVBApp_ShowPopup(DVB_APP_POP_MSG_RADIO_CHANNEL);
						}
					}
				}
                else if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO)
                         && !SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_POPMSG)
                         && (progstate == MID_PLAYBK_PROG_STATE_LOCKED)
                        && APP_GUIOBJ_DVB_PvrRec_IsShowPopTime(g_stDetails.start_local_time_secs)==FALSE
				)
                {
                    if (!DVBApp_IsPopupExist(DVB_APP_POP_MSG_CHECKPWD))
                    {
                        _DVBApp_ShowPopup(DVB_APP_POP_MSG_CHECKPWD);
                    }
                }
#endif
	        }
	    }
    }
    /*Unmute dispose*/
    if (bSetUnMuteFlag)
    {
#if 1
        if (g_bMidHasUnmute)
        {
            _DVBApp_Process_Unmute();
        }
        else
        {
            AL_DB_EDBType_t eNetType = APP_DVB_Playback_GetCurrentNetType();
            AL_DB_ERecordType_t RecordType = AL_RECTYPE_DVBTV;
            UINT32 total_prog = 0;

			RecordType = APP_DVB_Playback_GetCurrServiceType(eNetType);
            AL_DB_GetRecordsTotalNum(eNetType, RecordType, &total_prog);
            if (total_prog > 0)
            {
                INT16 i16ProgState = MID_PLAYBK_PROG_STATE_NORMAL;
                i16ProgState = APP_DVB_Playback_GetProgStateByHandle(eNetType, AL_DB_INVALIDHDL);
                if ((i16ProgState != MID_PLAYBK_PROG_STATE_NORMAL) &&
                    (i16ProgState != MID_PLAYBK_PROG_STATE_VIDEO_AVC))
                {
                    DVBApp_CheckProgramType(FALSE);
                    bSetUnMuteFlag = FALSE;
                }
            }
        }
#else //zhongbaoxing moved to _DVBApp_Process_Unmute for mantis 143820 @20110801
        g_u8SetUnMuteTimer ++;
        if (g_u8SetUnMuteTimer == unMute_Check_timer)
        {
            if (g_SetPQFlag == FALSE)
            {
                g_SetPQFlag = TRUE;
                /*set PQ param*/
                eStorageSourType = APP_Data_UserSetting_SourceTypeMappingToStorage(eSourType);
                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);
            }
            DVBApp_CheckProgramType(TRUE);

            g_u8SetUnMuteTimer = 0;
            bSetUnMuteFlag = FALSE;
            if (APP_Area_SupportDtg())
            {
                DVBApp_DataApplicationSwitch(OSD2CTRLMDL_ENABLE | OSD2CTRLMDL_SUB | OSD2CTRLMDL_MH5);
            }
            else
            {
                DVBApp_DataApplicationSwitch(OSD2CTRLMDL_ENABLE | OSD2CTRLMDL_SUB);
            }

        }
#endif
    }
#ifdef CONFIG_SUPPORT_PVR
	AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FACTHOTEL, 0,
		sizeof(APP_SETTING_FactoryHotel_t), &(g_stFactoryHotelData));
#if defined(SUPPORT_HOTEL_MODE_PVR_FUNCTION_CONTROL)
	if((!g_stFactoryHotelData.HotelModeOnOff)||(g_stFactoryHotelData.PVRFunction))
#elif defined(SUPPORT_PVR_ONOFF)
    AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_SETUP, 0,
        sizeof(APP_SETTING_Setup_t), &(g_stSetupData));
    if(g_stSetupData.PVROnOff)
#endif
	{
		_DVBApp_PVR_UpdateState();
	}
#endif
#ifdef CONFIG_SUPPORT_SSU_UPGRADE
		unsigned int SsuEchWakeTimer;
		static al_uint32 timer;
		//dvb_printf("autoupgrade_sate          %d\n",autoupgrade_sate);
		if (autoupgrade_sate== AU_GetTime)
		{
			al_uint32  CurTimeInSec;
			AL_Time_GetCurTimeInSecs(&CurTimeInSec);
			AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_USERINFO,
				ITEM_OFFSET(APP_SETTING_UserInfo_t, OTAWakeupTime),
				sizeof(g_stUserInfoData.OTAWakeupTime),&SsuEchWakeTimer);
			SsuEchWakeTimer -= CurTimeInSec;
			timer = SsuEchWakeTimer*10;
			if (timer > 0)
			{
				autoupgrade_sate = AU_TimeCom;
			}
			else
			{
				autoupgrade_sate = AU_MAX;
			}
		}
		if (autoupgrade_sate == AU_TimeCom)
		{
			timer--;
			//dvb_printf("&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&%d\n",timer);
			if (timer <= 0)
			{
				autoupgrade_sate = AU_GoToUpgrade;
			}
		}
		if (autoupgrade_sate == AU_GoToUpgrade)
		{
			//dvb_printf(" go to auto grade\n");
			autoupgrade_sate = AU_MAX;

			UINT16 u16ONID_SSU = 0xffff;
			UINT16 u16TSID_SSU = 0xffff;
			MID_OTA_GetOtaMonThreadData(OTA_DATA_TS_ONID,(UINT8 *)&u16ONID_SSU);
			MID_OTA_GetOtaMonThreadData(OTA_DATA_TS_TSID,(UINT8 *)&u16TSID_SSU);
			if ((u16ONID_SSU == 0xffff && u16TSID_SSU == 0xffff)
			   ||(u16ONID_SSU == 0x0 && u16TSID_SSU == 0x0))
			{
				//dvb_printf("[don't find linkage descriptor, so try again]%s		%d\n",__FUNCTION__,__LINE__);
				autoupgrade_sate = AU_GoToUpgrade;
			}
			else
			{
				APP_GUIOBJ_DVB_OTAPrompt_StartOTAMon();
			}
		}
#endif
    return 0;
}


#ifdef SUPPORT_ATS
static UINT8 uGetDemodinfoOn = 0;
GL_Task_t ATSTask;
static UINT8 ATSTaskExistFlag = 0;

void _APP_ATS_Get_Demodinfo_ThreadControl(void *pData)
{
	ATSTaskExistFlag = 1;
	bool bNeedPrint = TRUE;
	while(uGetDemodinfoOn==1)
	{
		GL_TaskSleep(500);
		UINT32 u16SNR=0;
		FrontendCmd_t front;
		front.cmd = FRONTEND_CMD_GET_SIGNAL_SNR;
		front.param = &u16SNR;
		ioctl(kmfdev, KMF_IOC_FRONTENDCTRL , &front);
		u16SNR = u16SNR/10;

		UINT32 u16BER=0;
		front.cmd = FRONTEND_CMD_GET_SIGNAL_BER;
		front.param = &u16BER;
		ioctl(kmfdev, KMF_IOC_FRONTENDCTRL , &front);
		if(u16BER != 0xFFFF)
			u16BER = u16BER/10;
	
		UINT32 u16PER=0;
		front.cmd = FRONTEND_CMD_GET_SIGNAL_PER;
		front.param = &u16PER;
		ioctl(kmfdev, KMF_IOC_FRONTENDCTRL , &front);
		
		UINT32 u16UBC=0;
		front.cmd = FRONTEND_CMD_GET_SIGNAL_UBC;
		front.param = &u16UBC;
		ioctl(kmfdev, KMF_IOC_FRONTENDCTRL , &front);

		UINT32 u16SSI=0;
		front.cmd = FRONTEND_CMD_GET_SIGNAL_STRENGTH;
		front.param = &u16SSI;
		ioctl(kmfdev, KMF_IOC_FRONTENDCTRL , &front);

		UINT32 u16SQI=0;
		front.cmd = FRONTEND_CMD_GET_SIGNAL_QUALITY;
		front.param = &u16SQI;
		ioctl(kmfdev, KMF_IOC_FRONTENDCTRL , &front);
	
	    UINT32 IsDemodLock=0;
	    front.cmd = FRONTEND_CMD_GET_DEMOD_LOCK_STATUS;
	    front.param = (void *)&IsDemodLock;
	    ioctl(kmfdev, KMF_IOC_FRONTENDCTRL , &front);
	
		//ATS:lock xx SNR xxx BER xxxxx PER xxxxx UBC xxxxx SSI xxx SQI xxx

		if(bNeedPrint == TRUE)
		{
			char cLen[80];
			sprintf(cLen, "ATS:lock %2d SNR %3d BER %5d PER %5d UBC %5d SSI %3d SQI %3d\n", IsDemodLock,u16SNR,u16BER,u16PER,u16UBC,u16SSI,u16SQI);
			con_echo_sfu(80, (UINT8 *)cLen);
		}
		if(IsDemodLock == 0)
			bNeedPrint = FALSE;
		else
			bNeedPrint = TRUE;
	}

	if(uGetDemodinfoOn == 0)
	{
		ATSTaskExistFlag = 0;
		GL_TaskSelfDelete();
	}

}

UINT32 APP_ATS_Get_Demodinfo_On()
{
	if(ATSTaskExistFlag == 0)
    {
	    GL_Status_t ret = GL_FAILURE;
		ret = GL_TaskCreate("ATSGetDemodinfo", _APP_ATS_Get_Demodinfo_ThreadControl, NULL, 4, 32, FALSE, &ATSTask);
	    if (ret != GL_SUCCESS)
	    {
	        return AL_FAILURE;
	    }
		ret = GL_TaskActivate(ATSTask);
		if (ret != GL_SUCCESS)
	    {
	        return AL_FAILURE;
	    }
	}
	return AL_SUCCESS;
}
#endif

static INT32 _DVBApp_OnGlobalEvent(void *pPrivateData, UINT32 dMessage, UINT32 dParam)
{
	al_bool bHasValidServ = al_false;
	al_uint8 bSignalState = al_false;
	PopmsgParam_t stPopup;
	UINT32 dGuiObj = DVB_GUIOBJ_EPG;
	UINT8 u8HotelMode;
	UINT8 u8MainUIEn;
	AL_DB_ERecordType_t NextServiceType = 0;
	UINT32 u32TotalNum = 0;
	AL_RecHandle_t hProg;
	AL_RecHandle_t hCurProg;
	UINT32 dAppIndex = 0;
	MID_DISP_MUTE_ST eMuteSt = 0;
#ifdef CONFIG_SUPPORT_3D_EN
	APP_Video_Image3DAction_t ePicture3DState = APP_VIDEO_IMAGE_3D_DISABLED;
#endif

	APP_Source_Type_t eSourType = APP_SOURCE_MAX;
	APP_Source_Type_t eMidSourType = APP_SOURCE_MAX;
	AL_DB_EDBType_t eNetType = APP_DVB_Playback_GetCurrentNetType();
	AL_DB_ERecordType_t eServiceType = APP_DVB_Playback_GetCurrServiceType(eNetType);
	AL_RecHandle_t hCurrProgHandle = AL_DB_INVALIDHDL;

	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)
	{
		return SP_SUCCESS;
	}

	dMessage = (dMessage&~PASS_TO_SYSAPP);
	dvb_printf("%d. dMessage = 0x%x(%d)event received.\n", __LINE__, dMessage,(dMessage&0xfff));

	eServiceType = APP_DVB_Playback_GetCurrServiceType(eNetType);

	hCurProg = hProg = APP_DVB_Playback_GetCurrentProgHandle(eNetType, eServiceType);
	APP_GUIOBJ_Source_GetCurrSource(&eSourType);
	APP_GUIOBJ_Source_GetMidSource(&eMidSourType, NULL);
	UINT8 bAutoInstall = FALSE;

#ifdef IR_PLAYPAUE_COMBINE
	if (dMessage == UI_EVENT_PLAY)
	{
		dMessage = UI_EVENT_PLAY_PAUSE;
	}
	if (dMessage == UI_EVENT_PLAY_PAUSE)
	{
		dMessage = UI_EVENT_PAUSE;
	}
#endif
	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)
			{
				return 0;
			}
		}
	}

	if ((g_stFactoryHotelData.HotelModeOnOff == 1) && (g_stFactoryHotelData.AspectRatioLock == 1))
	{
		if (dMessage == UI_EVENT_ASPECT)
		{
			dMessage = UI_EVENT_NULL;
		}
	}
#ifdef CONFIG_SUPPORT_PVR
	UINT8 u8AutoTimeShift;
	UINT8 u8MidRecState;
	UINT8 u8MIDRecMode;
	AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FEATURE,
					ITEM_OFFSET(APP_SETTING_Feature_t, AutoTimeShift),
					sizeof(g_stFeatureData.AutoTimeShift), &(g_stFeatureData.AutoTimeShift));
	u8AutoTimeShift = g_stFeatureData.AutoTimeShift;
	u8MidRecState = MID_RecorderState();
	u8MIDRecMode = MID_Recorder_GetRecMode();
#ifdef SUPPORT_PLAY_PAUSE_KEY_START_REC
	if ((MID_REC_STATUS_STOP == u8MidRecState)
		&& (dMessage == UI_EVENT_PLAY_PAUSE)
		&& !SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_RECORDLIST)
		&& !SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_FILEPLAY))
	{
		dMessage = UI_EVENT_REC;
	}
#endif
#endif
#if defined(SUPPORT_PVR_ONOFF) || defined(SUPPORT_EPG_ONOFF)
		AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_SETUP, 0,
			sizeof(APP_SETTING_Setup_t), &(g_stSetupData));
#endif

#ifdef SUPPORT_CEC_TV
	if (CECTV_GetCECEnable()==CECTV_ENABLE)
	{
		//active source
		if(dMessage==UI_EVENT_TVRADIO)
		{
			dvb_printf("========================UI_EVENT_TVRADIO========================");

                             // no need to notice cec change src
			//CECTV_SendCmd(CECTV_SINGLE_ACT_CMD_CHGSRC_OUT_HDMI, SRC_OTHERS);
		}
		if(dMessage==UI_EVENT_MUTE)
		{
			dvb_printf("\n\n=============CEC Send Audio Mute===============\n\n");
			CECTV_SendCmd(CECTV_SINGLE_ACT_CMD_KEYPRESS, CECTV_KEY_MUTE<<8|0x05);//Mute Function
		}

		if(dMessage==UI_EVENT_VOL_UP)
		{
			dvb_printf("========================UI_EVENT_VOL_UP========================");
			CECTV_SendCmd(CECTV_SINGLE_ACT_CMD_KEYPRESS, CECTV_KEY_VOLUME_UP<<8|0x05);//UCP VOL_DN Function
		}
		if(dMessage==UI_EVENT_VOL_DN)
		{
			dvb_printf("========================UI_EVENT_VOL_DN========================");
			CECTV_SendCmd(CECTV_SINGLE_ACT_CMD_KEYPRESS, CECTV_KEY_VOLUME_DOWN<<8|0x05);//UCP VOL_DN Function
		}
	}
#endif

#ifdef TEAC_BLUE_KEY_FUNCTION
	if (_DVB_GetPanelControlType() == APP_PANEL_POWER_DOWN && (dMessage >= UI_EVENT_0 && dMessage < UI_EVENT_NULL) && (dMessage != UI_EVENT_POWER))
	{
		//APP_Panel_SetPowerSequence(APP_PANEL_POWER_UP);
		//APP_Video_OSD_PQSet(APP_VIDEO_OSD_ITEM_BACKLIGHT,
		//	g_stSetupData.HomeMode.Backlight[g_stSetupData.HomeMode.Type]);
		_DVB_SetPanelControlType(APP_PANEL_POWER_UP);
		return GUI_OBJECT_NO_POST_ACTION;
	}
#endif

	switch (dMessage)
	{
		case APP_DVB_GLOBAL_EVENT_SCAN_DONE:
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_SCAN_PROCESS))
			{
				SYSAPP_GOBJ_SendMsgToSingleGUIObject(
					SYS_APP_DVB, DVB_GUIOBJ_SCAN_PROCESS,
					APP_DVB_GLOBAL_EVENT_SCAN_DONE, 0);
			}
			else if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_INITINSTALL))
			{
				SYSAPP_IF_SendCriticalGlobalEventWithIndex(SYS_APP_DVB, APP_DVB_GLOBAL_EVENT_SCAN_DONE, 0);
			}
			else
			{
				APP_GUIOBJ_ScanProcess_ScanDone(NULL, 1);
			}
			break;
	  	case APP_DVB_GLOBAL_EVENT_DVB_ONRUN:
			dvb_printf(" APP_DVB_GLOBAL_EVENT_DVB_ONRUN event received\n");
			g_u32NoSignalTimer = 0;
			g_u32NoSignalSleepTimer = 0;
/*#ifdef CONFIG_SUPPORT_PVR
			if (MID_REC_STATUS_STOP != u8MidRecState)
			{
				if (MID_REC_MODE_MANUAL == u8MIDRecMode)
				{
					DVBApp_StopRecord();
				}
				else
				{
					DVBApp_StopTimeshift(TRUE);
				}
			}
#endif*/
			AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_CHANNEL,
							 ITEM_OFFSET(APP_SETTING_Channel_t, Country),
							 sizeof(g_stChannelData.Country), &(g_stChannelData.Country));
			DVBApp_ResetDvbSpecRule(g_stChannelData.Country);

#ifdef CONFIG_MEDIA_ENABLE
/*#ifdef CONFIG_SUPPORT_PVR
#ifdef SUPPORT_WAKEUP_TIMER_IN_STANDBY
			if(APP_WAKEUP_GetBootFlag()==FALSE)
#endif
			{
				if (MM_Music_GetPanelControlType() == APP_PANEL_POWER_DOWN)
					//APP_Panel_SetPowerSequence(APP_PANEL_POWER_UP);
			}
#endif*/
#endif
			/*Change Source*/
			UINT32 Indexmm = TOTAL_SYS_APP_SIZE;
			while(MAINAPP_GetActiveSystemAppIndex(&Indexmm) !=MAIN_APP_SUCCESS)
			{
				GL_TaskSleep(1);
			}
			if ((SP_SUCCESS != APP_GUIOBJ_Source_SetMidSource(NULL)) || (APP_IsScan_Running()))
			{
		#ifdef CONFIG_SUPPORT_PVR
				DVBApp_SetPVRSwitchSRC(FALSE);
		#endif
				return SP_ERR_FAILURE;
			}
#ifdef CONFIG_SUPPORT_PVR
			int iPtListIdx = -1;
			extern int _RecorderList_Callback(MID_PVRRecListParseMsg_t dPVRRecListCallbackType);
			MID_TSPLParser_RegisterPvrRecListCallback((PVRRecListCallbackFunc)_RecorderList_Callback);
			if (MID_RecorderGetDefaultPartition(&iPtListIdx) != MID_REC_FS_OK)
			{
				/* aps new don't support NTFS fs */
				if (APP_GUIOBJ_DVB_PartitionList_GetFirstFat(&iPtListIdx) == TRUE)
				{
					MID_RecorderSetDefaultPartition(iPtListIdx, MID_REC_PARTITION_SET_FORCE); //set partition 0 for default partition
				}
			}
			else	//for mantis 0180617, refresh mid PVR file list when change from other source
			{
				static char szPtName[15];
				MID_PartitionList_GetMountName(iPtListIdx, szPtName);
				extern Boolean MID_Recorder_DeleteTShistIfExist(char *szPtName);

				if(MID_Recorder_DeleteTShistIfExist(szPtName)==TRUE)
				{
					PVR_DEBF("Delete TSHIFT FILE [OK]\n");
				}

				extern Boolean MID_Recorder_DeleteIllegalPVR(char *szPtName);

				if(MID_Recorder_DeleteIllegalPVR(szPtName)==TRUE)
				{
					PVR_DEBF("Delete Illegal PVR [OK]\n");
				}

				MID_TSPLParser_Init(szPtName);
			}
			DVBApp_SetBGTimeshift(PVR_BGTIMESHIFT_START_INTERVAL);
#endif
			/* dtv or radio */
            APP_GUIOBJ_Source_SetAirSource(AIR_SOURCE_TYPE_DTV);
			eServiceType = APP_DVB_Playback_GetCurrServiceType(eNetType);
			if ((eServiceType != AL_RECTYPE_DVBTV) && (eServiceType  != AL_RECTYPE_DVBRADIO) && (eServiceType != AL_RECTYPE_DVBDATA))
			{
				eServiceType = AL_RECTYPE_DVBTV;
			}
			/* Check Service Type */
			{
				UINT32 u32TotalChnCount = 0;
				AL_DB_ERecordType_t eTempServiceType = eServiceType;
				if(eServiceType != AL_RECTYPE_DVBTV)
				{
					AL_DB_GetRecordsTotalNum(eNetType, eServiceType, &u32TotalChnCount);
					if(!u32TotalChnCount)
					{
						eTempServiceType = AL_RECTYPE_DVBTV;
						AL_DB_GetRecordsTotalNum(eNetType, eTempServiceType, &u32TotalChnCount);
						if(!u32TotalChnCount)
						{
							if(eServiceType == AL_RECTYPE_DVBRADIO)
							{
								AL_DB_GetRecordsTotalNum(eNetType, AL_RECTYPE_DVBDATA, &u32TotalChnCount);
								if(u32TotalChnCount)
								{
									eTempServiceType = AL_RECTYPE_DVBDATA;
								}
							}
							else if(eServiceType == AL_RECTYPE_DVBDATA)
							{
								AL_DB_GetRecordsTotalNum(eNetType, AL_RECTYPE_DVBRADIO, &u32TotalChnCount);
								if(u32TotalChnCount)
								{
									eTempServiceType = AL_RECTYPE_DVBRADIO;
								}
							}
						}
					}
				}
				else
				{
					AL_DB_GetRecordsTotalNum(eNetType, eServiceType, &u32TotalChnCount);
					if(!u32TotalChnCount)
					{
						AL_DB_GetRecordsTotalNum(eNetType, AL_RECTYPE_DVBDATA, &u32TotalChnCount);
						if(u32TotalChnCount)
						{
							eTempServiceType = AL_RECTYPE_DVBDATA;
						}
						else
						{
							AL_DB_GetRecordsTotalNum(eNetType, AL_RECTYPE_DVBRADIO, &u32TotalChnCount);
							if(u32TotalChnCount)
							{
								eTempServiceType = AL_RECTYPE_DVBRADIO;
							}
						}
					}
				}
				eServiceType = eTempServiceType;
				APP_DVB_Playback_SetCurrServiceType(eNetType, eServiceType);
			}

			/*create playback and mute guiobject*/
			if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PLAYBACK))
			{
				SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, DVB_GUIOBJ_PLAYBACK, 0);
			}

			if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_MUTE))
			{
				SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, APP_GUIOBJ_MUTE, 0);
			}
			
		   /* change source to net, it will destroy `mute' icon
			 * so, judge `mute' state, show icon
			 */
			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_DVB, APP_GUIOBJ_MUTE,
					APP_INTRA_EVENT_SHOW_MUTE, SHOW_MUTE_ON_TV);
			}
			bAutoInstall = g_stUserInfoData.AutoInstalled;
			if (bAutoInstall && (FALSE ==gIsFactoryResetting))
			{
				if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_INITINSTALL))
				{
					//Close all menu before show Auto Installation menu
					_DVBApp_CloseAllMenu();
#ifdef SUPPORT_FACTORY_AUTO_TEST
					if(APP_Factory_GetAutoTestOnOff() == FALSE)
#endif
					{
						SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, APP_GUIOBJ_INITINSTALL, 0);
					}
				}
			}
#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_DVB, APP_GUIOBJ_FM_FACTORYSETTING))
					{
						DVBApp_ResetPopup_Channel();
						_DVBApp_CloseAllMenu();
						SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, APP_GUIOBJ_FM_FACTORYSETTING, 1);
						Factory_Ver_Debug();
					}
				}
			}
#endif
			hProg = APP_DVB_Playback_GetCurrentProgHandle(eNetType, eServiceType);
#ifdef CONFIG_SUPPORT_PVR
			if (DVBApp_GetPVRSwitchSRC() == TRUE)
			{
				eServiceType = g_eRecType;
				APP_DVB_Playback_SetNextServiceType(eServiceType);
				hProg = DVBApp_GetSCHProgHandle();
			}
#endif

			if (APP_MenuMgr_Exist_Scan_Menu())
			{
				SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_DVB, APP_GLOBAL_EVENT_SET_SOURCE_COMPLETE, 0);
			}
			else
			{
#if 0			/*modify by qinhe for mantis 0011833*/
				AL_DB_GetRecordsTotalNum(eNetType, eServiceType, &TotalNum);
#else
				bHasValidServ = AL_DB_HasVisibleService(eNetType);
#endif
				if (bHasValidServ)
				{
					if (hProg == AL_DB_INVALIDHDL)
					{
						AL_RecHandle_t hTpHdl = AL_DB_INVALIDHDL;
						AL_DB_GetRecord(AL_DB_REQ_GETFIRST, eNetType, AL_RECTYPE_DVBMULTIPLEX, &hTpHdl);

						if (hTpHdl != AL_DB_INVALIDHDL)
						{
							hProg = APP_DVB_PLAYBACK_GetFirstProgHdlofLowestService();
							AL_DB_GetRecordType(hProg, &eNetType, &eServiceType);
							APP_DVB_Playback_SetCurrentProgHandle(eNetType, eServiceType, hProg);
							APP_DVB_Playback_SetNextServiceType(eServiceType);
						}
					}

					if (hProg == AL_DB_INVALIDHDL)
					{
						if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_SCAN_PROCESS))
						{
							SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_DVB,
							DVB_GUIOBJ_PLAYBACK, APP_DVB_INTRA_EVENT_SHOWLOGO, 0);
						}
						if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_INITINSTALL))
						{
							if (!DVBApp_IsPopupExist(PLAYBACK_POPUP_MSG_DATABASE_EMPTY))
							{
								DVBApp_ResetPopup_Channel();
								_DVBApp_ShowPopup(DVB_APP_POP_MSG_DATABASE_EMPTY);
							}
						}
					}
					else
					{
						DBServAttrib_t stAttribute;
						memset(&stAttribute, 0, sizeof(stAttribute));
						AL_DB_QueryDetailFieldByName(hProg, (al_uint8 *)"stProgAttrib", (al_void *)&stAttribute);
						if(stAttribute.unStable == al_true)
						{
							DVBApp_RemoveUnstableService();
						}
						else
						{
							_DVBApp_Zapping(eServiceType, hProg, TRUE, 0, TRUE);
						}
						/*Add for dispose TV/RADIO key in channel manager /channel list /epg*/
						if (!dParam)
						{
							if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_CHNMGR)
								|| SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_FAVMGR)
								|| SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_CHNLIST)
								|| SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_FAVLIST)
								|| SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_EPG))
							{
								break;
							}
						}
						/*End*/
						AL_DVB_Monitor_GetState(AL_DVB_MONITOR_STATE_SIGNAL, &bSignalState);
						if (bSignalState != AL_DVB_MONITOR_VALUE_TRUE)
						{
#ifdef PLAY_VIDEO_FOR_ALLSRV
							if (DVBApp_CheckHasVideo() == FALSE)
#else
							if (eServiceType == AL_RECTYPE_DVBRADIO)
#endif
							{
								SYSAPP_GOBJ_SendMsgToSingleGUIObject(
									SYS_APP_DVB, DVB_GUIOBJ_PLAYBACK,
									APP_DVB_INTRA_EVENT_SHOWLOGO, 0);
							}
							if(!APP_Factory_CheckNeedReopenFm(SYS_APP_DVB))
							{
								_DVBApp_ShowPopup(DVB_APP_POP_MSG_NO_SIGNAL);
							}
						}
						else
						{
							DVBApp_ClosePopup(PLAYBACK_POPUP_MSG_NO_SIGNAL, UI_EVENT_NULL);
	                    #if 0  //zhongbaoxing removed for mantis 171528 @20120307
							if (eServiceType == AL_RECTYPE_DVBRADIO)
							{
								if (!APP_GUIOBJ_DVB_Playback_GetShowLogoState())
								{
									SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_DVB,
										DVB_GUIOBJ_PLAYBACK, APP_DVB_INTRA_EVENT_SHOWLOGO, 0);
								}
#ifdef CONFIG_SUPPORT_MHEG5
								if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_MHEG5))
#endif
								{
									_DVBApp_ShowPopup(DVB_APP_POP_MSG_RADIO_CHANNEL);
								}
							}
							else
	                    #else
							if (eServiceType != AL_RECTYPE_DVBRADIO)
							{
								DVBApp_ClosePopup(PLAYBACK_POPUP_MSG_RADIO_CHANNEL, UI_EVENT_NULL);
							}
	                    #endif
						}
					}
				}
				else
				{
					SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_DVB,
						DVB_GUIOBJ_PLAYBACK, APP_DVB_INTRA_EVENT_SHOWLOGO, 0);
					if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_INITINSTALL))
					{
						if (!DVBApp_IsPopupExist(PLAYBACK_POPUP_MSG_DATABASE_EMPTY))
						{
							DVBApp_ResetPopup_Channel();
							if(!APP_Factory_CheckNeedReopenFm(SYS_APP_DVB))
							{
								_DVBApp_ShowPopup(DVB_APP_POP_MSG_DATABASE_EMPTY);
								DVBApp_CheckProgramType(FALSE);
							}
						}
					}
				}

	#ifdef SUPPORT_DTV_SHOW_BLUESCREEN
				al_uint8 bMonitorState = al_false;
				al_uint8 bSignalState = al_false;

				AL_DVB_Monitor_GetState(AL_DVB_MONITOR_STATE_MONITOR, &bMonitorState);
				AL_DVB_Monitor_GetState(AL_DVB_MONITOR_STATE_SIGNAL, &bSignalState);

				if ((g_stSetupData.BlueScreen == APP_SWITCH_ON)
					&&((!bHasValidServ)
					||!((bMonitorState) && (bSignalState == AL_DVB_MONITOR_VALUE_TRUE))))
				{
				#ifdef CONFIG_DVB_SYSTEM
					APP_SCARTOUT_SetVideoMute(APP_SOURCE_DTV, DTV_TRUE, TRUE);
				#endif
					MID_DISP_DTVSetVideoMute(0,0,255);
				}
	#endif
				_DVBApp_CheckPopupDisplay();
			}

#ifdef CONFIG_SUPPORT_PVR
			if(DVBApp_GetPVRSwitchSRC())
			{
				DVBApp_SetPVRSwitchSRC(FALSE);
				if(DVBApp_GetReminderTime2Show() > 1)//For confirm record ahead
				{
					AL_Return_t ret;
					memset(&g_stDetails,0,sizeof(AL_PR_details_t));
					ret = AL_PR_GetById(g_dReminderId, &g_stDetails);
					if (ret == AL_SUCCESS)
					{
						DVBApp_PVRRec_SetTimerCancle();
						SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_DVB,
								(APP_DVB_GLOBAL_EVENT_PVRSCH | PASS_TO_SYSAPP), (UINT32)&g_stDetails);
					}
				}
			}
#endif
			break;

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

		case APP_DVB_GLOBAL_EVENT_OBJECT_CLOSE:
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, dParam))
			{
				SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, dParam);
			}
			break;

		case APP_DVB_GLOBAL_EVENT_CLOSE_POPUP:
			DVBApp_ClosePopup(dParam, UI_EVENT_NULL);
			break;

		case APP_DVB_GLOBAL_EVENT_EXIT_ALL_MENU:
			_DVBApp_Exit_All_Menu();
			break;

		case APP_GLOBAL_EVENT_POPMSG_PWD:
			{dvb_printf("APP_GLOBAL_EVENT_POPMSG_PWD is received,Unlock success!!\n\n");
			g_SetPQFlag = TRUE;
			APP_DVB_Playback_SetUnlock(TRUE);

            AL_DVB_Monitor_GetState(AL_DVB_MONITOR_STATE_SIGNAL, &bSignalState);
            if (bSignalState == AL_DVB_MONITOR_VALUE_INVAILED)//tuner locked
            {
                al_uint8  uDVBMonState = AL_DVB_MONITOR_VALUE_TRUE;
                AL_DVB_Monitor_SetState(AL_DVB_MONITOR_STATE_SIGNAL, &uDVBMonState);
            }
			SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_DVB,
				DVB_GUIOBJ_PLAYBACK, APP_DVB_INTRA_EVENT_START_PLAYBACK, 0);
			if (APP_GetPlaybackPauseState() == TRUE)
			{
				if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_FREEZE))
				{
					MID_PlaybackStreamPause(1);
				}
			}

            DVBApp_CheckProgramType(TRUE);
			DVBApp_DataApplicationSwitch(OSD2CTRLMDL_ENABLE | OSD2CTRLMDL_SUB);
#ifdef CONFIG_SUPPORT_PVR
			AL_DB_EDBType_t DBType_Current = AL_DBTYPE_DVB_SBTVD;
			AL_RecHandle_t CurrentProgHandle;
			UINT32 CurrentTime;

			CurrentProgHandle	= APP_DVB_Playback_GetCurrentProgHandle(DBType_Current, AL_RECTYPE_DVBTV | AL_RECTYPE_DVBRADIO | AL_RECTYPE_DVBDATA);
			AL_Time_GetCurTimeInSecs(&CurrentTime);
			if (CurrentProgHandle == g_stDetails.rem_details.handle
				&& CurrentTime <g_stDetails.rem_details.event_end_time_insec
				&& CurrentTime > g_stDetails.start_local_time_secs)
			{
				SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_DVB, (APP_DVB_GLOBAL_EVENT_PVRSCH|PASS_TO_SYSAPP), (UINT32)&g_stDetails);
			}

#endif
			}
			break;

		case APP_DVB_GLOBAL_EVENT_START_PLAYBACK:
			SYSAPP_GOBJ_SendMsgToSingleGUIObject(
				SYS_APP_DVB, DVB_GUIOBJ_PLAYBACK,
				APP_DVB_INTRA_EVENT_START_PLAYBACK, 0);
			break;

		case APP_DVB_GLOBAL_EVENT_STOP_PLAYBACK:
			{
				MID_PlaybackProgState_t eProgState = MID_PLAYBK_PROG_STATE_NORMAL;
				AL_DB_EDBType_t eDBType = AL_DBTYPE_MAX;
				AL_RecHandle_t hCurrPrgHdl = AL_DB_INVALIDHDL;

				if (AL_SUCCESS != APP_Database_GetCurrentDBType(APP_SOURCE_DTV, &eDBType))
				{
					dvb_printf("Get DBType error!!!\n");
					break;
				}

				hCurrPrgHdl = APP_DVB_Playback_GetCurrentProgHandle(eDBType, (AL_RECTYPE_DVBTV |AL_RECTYPE_DVBRADIO|AL_RECTYPE_DVBDATA));

				if (hCurrPrgHdl == AL_DB_INVALIDHDL)
				{
					dvb_printf("Get current program handle error!!!\n");
					break;
				}
				eProgState = APP_DVB_Playback_GetProgStateByHandle(eDBType, hCurrPrgHdl);
				if((APP_DVB_ParentalLock_GetPrtRatinglock())
					&&(eProgState != MID_PLAYBK_PROG_STATE_LOCKED))
				{
					break;
				}
			}
			SYSAPP_GOBJ_SendMsgToSingleGUIObject(
				SYS_APP_DVB, DVB_GUIOBJ_PLAYBACK,
				APP_DVB_INTRA_EVENT_STOP_PLAYBACK, dParam);
			break;

#ifdef CONFIG_SUPPORT_PVR
		case APP_GLOBAL_EVENT_PVRREC_CHANGESOURCE:
			DVBApp_SetPVRSwitchSRC(FALSE);
			DVBApp_SetTVRadioSwap(FALSE);
			if (eServiceType != g_eRecType)
			{
				_DVBApp_Exit_All_Menu();
				if (stoprec_id != AL_SCH_INVALID_ID)
				{
					AL_SCH_UnScheduleEvent(&stoprec_id);
					APP_GUIOBJ_DVB_PvrRecDurationTime_ResetDurationID();
				}
#if 0   //for mantis 199484/209573, don't return to the last program after timer record
				DVBApp_SetTVRadioSwap(TRUE);
#endif
				if (APP_DVB_Playback_SwapServiceType(eNetType, (AL_DB_ERecordType_t *)&NextServiceType, &u32TotalNum) != AL_SUCCESS)
				{
					dvb_printf("PVRREC Change sevice type fail!!!!!!!!!!\n");
				}
			}
			break;
		case APP_GLOBAL_EVENT_PVR_REMINDER:
		{
			PVR_DEBF("Reminder   \n\n");
			AL_Return_t ret;
			AL_DB_EDBType_t DBType_ret = AL_DBTYPE_DVB_SBTVD;
			AL_DB_ERecordType_t RecType = AL_RECTYPE_DVBTV;
			al_uint32 CurTimeInSec = 0;
			AL_Time_GetCurTimeInSecs(&CurTimeInSec);


			g_dReminderId = dParam;
			memset(&g_stDetails,0,sizeof(AL_PR_details_t));
			ret = AL_PR_GetById(g_dReminderId, &g_stDetails);
			if (ret != AL_SUCCESS)
			{
				memset(&g_stDetails,0,sizeof(AL_PR_details_t));
				dvb_printf("AL_PR_GetById Error\n");
				break;
			}
			/*Only storage the current REC type for start prompted pop*/
			DVBApp_SetRemType(g_stDetails.rem_type);
			DBType_ret = APP_DVB_Playback_GetCurrentNetType();
			if (DBType_ret == g_stDetails.db_type)
			{
				/* if RF type diff, change RF type on APP_DVB_GLOBAL_EVENT_PVRSCH*/
				//APP_WAKEUP_Recorder_SetTimeout();
				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;
				}
			}
			_DVBApp_CloseAllMenu();
			_DVBApp_ShowPopup(DVB_APP_POP_MSG_PVR_REMIDER);
		}
		break;

		case APP_GLOBAL_EVENT_PVR_REMINDER_CONFIRM:
			_DVBApp_ShowPopup(DVB_APP_POP_MSG_PVR_REMIDER_CONFIRM);
			break;
		case APP_DVB_GLOBAL_EVENT_PVR_EXPIRE:
		{
			//stop recording;
			AL_SCH_sched_id_t Stop_id = AL_SCH_INVALID_ID;
			AL_SCH_sched_id_t Schedule_id = dParam;

			AL_SCH_details_t sch_details;
			AL_SCH_GetScheduleDetails(&dParam, &sch_details);

			PVR_DEBF("hProg ================= 0x%x\n", sch_details.sch_user_para);
			PVR_DEBF("%s  %d\n", __FUNCTION__, __LINE__);
			PVR_DEBF("stop record is call\n");

			Stop_id = stoprec_id;
			if (stoprec_id == AL_SCH_INVALID_ID)
			{
				Stop_id = APP_GUIOBJ_DVB_PvrRecDurationTime_GetDurationID();
			}
			if (Schedule_id != Stop_id)
			{
				//if expire timer ID no match, ignor it.
				break;
			}
			else
			{
				//if duration is less then 5s, we will consider this stop timer is wrong
				INT32 g_RecTime;
				MID_RecorderGetStreamTime(&g_RecTime);
				if (g_RecTime < 5)
				{
					break;
				}
			}
			if (u8MidRecState != MID_REC_STATUS_STOP)
			{
				PVR_DEBF("==========timer stop recorder!====\n");
				DVBApp_StopRecord();
			}
#if 0   //for mantis 199484, don't return to the last program after timer record
			AL_Return_t ret;
			AL_PR_details_t  details;
			AL_DB_EDBType_t DBType = APP_DVB_Playback_GetCurrentNetType();
			AL_SCH_sched_id_t  ref_id = AL_PR_MAX_NO_REMINDERS;
			AL_SCH_sched_id_t  ret_id_first = AL_PR_MAX_NO_REMINDERS;
			ret = AL_PR_Get(DBType, AL_PR_REC_FIRST, AL_PR_EVT_REM | AL_PR_SRV_REM, ref_id, &ret_id_first);
			if (ret == AL_SUCCESS)
			{
				AL_PR_GetById(ret_id_first, &details);
				/*if the comming minute will start recording, no need to change back to last channel*/
				/*CurTimeInSec sometimes has a delay, so minus 2 sec here*/
				if ((CurTimeInSec > details.start_local_time_secs - 60) &&
					(CurTimeInSec - 2 < details.start_local_time_secs))
				{
					break;
				}
			}
			if (DVBApp_GetTVRadioSwap() == TRUE)
			{
				_DVBApp_CloseAllMenu();
				DVBApp_SetTVRadioSwap(FALSE);
				if (APP_DVB_Playback_SwapServiceType(eNetType, (AL_DB_ERecordType_t *)&NextServiceType, &u32TotalNum) != AL_SUCCESS)
				{
					dvb_printf("PVR EXPIRE Change sevice type fail!!!!!!!!!!\n");
				}
				break;
			}

			if (g_ProgHandleB4Rec != 0)
			{
				_DVBApp_CloseAllMenu();
				AL_DB_EDBType_t 		DBType_ret = AL_DBTYPE_DVB_T;
				AL_DB_ERecordType_t   RecType = AL_RECTYPE_DVBTV;
				AL_DB_GetRecordType(g_ProgHandleB4Rec, &DBType_ret, &RecType);
#if defined(CONFIG_DVB_SYSTEM) || defined(CONFIG_AUS_DVB_SYSTEM)
				APP_RFType_en eRFType = APP_RF_TYPE_DVB_T;
				AL_DB_EDBType_t DBType_Current =
					APP_DVB_Playback_GetCurrentNetType();

				if (DBType_Current != DBType_ret)
				{
					if (details.db_type == AL_DBTYPE_DVB_T)
					{
						eRFType = APP_RF_TYPE_DVB_T;
					}
					else if (details.db_type == AL_DBTYPE_DVB_C)
					{
						eRFType = APP_RF_TYPE_DVB_C;
					}
					else if (details.db_type == AL_DBTYPE_DVB_S)
					{
						eRFType = APP_RF_TYPE_DVB_S;
					}
					APP_GUIOBJ_Channel_SetRFTypeWithHdl(eRFType, g_ProgHandleB4Rec);
				}
				else
#endif
				{
					_DVBApp_Zapping(RecType, g_ProgHandleB4Rec, FALSE, 0, TRUE);
				}
				g_ProgHandleB4Rec = 0;
			}
#endif
		}
		break;
		case APP_DVB_GLOBAL_EVENT_PVRSCH:
		{
			if (DVBApp_GetPVRSwitchSRC() == TRUE)
			{
				//resend the timer PVR start message if source change is not finish
				SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_DVB, (APP_DVB_GLOBAL_EVENT_PVRSCH|PASS_TO_SYSAPP), dParam);
				return 0;
			}
			AL_PR_details_t  details;
			memcpy((UINT8 *)&details, (UINT8 *)dParam, sizeof(AL_PR_details_t));

			AL_DB_EDBType_t 		 DBType_ret = AL_DBTYPE_DVB_SBTVD;
			AL_DB_EDBType_t 		 DBType_Current = AL_DBTYPE_DVB_SBTVD;
			AL_DB_ERecordType_t    RecType = AL_RECTYPE_DVBTV;
			AL_RecHandle_t CurrentProgHandle;
			/*	get remider program  */
			AL_DB_GetRecordType(details.rem_details.handle, &DBType_ret, &RecType);

			/* get current program handele */
			CurrentProgHandle	= APP_DVB_Playback_GetCurrentProgHandle(DBType_Current, AL_RECTYPE_DVBTV | AL_RECTYPE_DVBRADIO | AL_RECTYPE_DVBDATA);
			g_ProgHandleB4Rec = 0;
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_FILEPLAY))
			{
				SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PVR_FILEPLAY);
			}
			/*	zap prog */
			if (details.rem_details.handle	!= CurrentProgHandle)
			{
				PVR_DEBF("handle			   ==== 0x%x\n", details.rem_details.handle);
				PVR_DEBF(" CurrentProgHandle ==== 0x%x\n", CurrentProgHandle);
				g_ProgHandleB4Rec = CurrentProgHandle;
				if (MID_RecorderIsCurRecording() == DRV_SUCCESS)
				{
				#ifdef SUPPORT_PVR_REMINDER_CONFIRM_SPEC
					DVBApp_ResetPopup_Channel();	//close all menu before timer rec
					_DVBApp_CloseAllMenu();
					g_ProgHandleB4Rec = 0;
					if (details.rem_type == AL_PR_SRV_REM)
					{
						if (u8MIDRecMode == MID_REC_MODE_MANUAL)
						{
							_DVBApp_ShowPopup(DVB_APP_POP_MSG_STOP_REC_FOR_REMINDER);
						}
						else
						{
							_DVBApp_ShowPopup(DVB_APP_POP_MSG_STOP_TSHIFT_FOR_REMINDER);
						}
						break;
					}
					else
					{
						if (u8MIDRecMode == MID_REC_MODE_MANUAL)
						{
							_DVBApp_ShowPopup(DVB_APP_POP_MSG_STOP_REC_FOR_TIMER_REC);
						}
						else
						{
							_DVBApp_ShowPopup(DVB_APP_POP_MSG_STOP_TSHIFT_FOR_TIMER_REC);
						}
						break;
					}
				#endif
					if (u8MIDRecMode == MID_REC_MODE_MANUAL)
						DVBApp_StopRecord();
					else
						DVBApp_StopTimeshift(TRUE);
				}
				_DVBApp_CloseAllMenu();
				_DVBApp_Zapping(RecType, details.rem_details.handle, FALSE, 0, FALSE);
			}

			/* recorder */
			if (details.rem_type == AL_PR_EVT_REM)
			{
				DVBApp_ResetPopup_Channel();	//close all menu before timer rec
				_DVBApp_CloseAllMenu();
				if (MID_RecorderIsCurRecording() == DRV_SUCCESS)//for spec, stop current recording and start timer rec
				{
					if (u8MIDRecMode == MID_REC_MODE_MANUAL)
						DVBApp_StopRecord();
					else
						DVBApp_StopTimeshift(TRUE);
				}

				AL_DB_GetRecordsTotalNum(DBType_ret, RecType, &u32TotalNum);
				if (u32TotalNum == 0)
				{
					break;
				}
				if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PROGNUM))
				{
					SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PROGNUM);
				}
				if (MID_RecorderIsCurRecording() == DRV_SUCCESS)
				{
					PVR_DEBF("%s is call.LINE :  %d\n", __FUNCTION__, __LINE__);
				}
				else
				{
					AL_RecHandle_t hProg = AL_DB_INVALIDHDL;
					if (MID_PlaybackGetCurProgHandle(NULL, &hProg) != MID_SUCCESS)
					{
						PVR_DEBF("%s is call.LINE :  %d\n", __FUNCTION__, __LINE__);
						PVR_DEBF("Error, get current program handle failed...\n");
						hProg = AL_DB_INVALIDHDL;
					}

					if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PROGINFO))
					{
						SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PROGINFO);
					}
					APP_GUIOBJ_DVB_PvrRec_SetTimerRecord(TRUE);
					_APP_GUIOBJ_DVB_PvrRecDurationTime_ResetDurTime();

					if (DVBApp_StartRecord(MID_REC_MODE_MANUAL) != SP_SUCCESS)
					{
						APP_GUIOBJ_DVB_PvrRec_SetTimerRecord(FALSE);
						DVBApp_SetTVRadioSwap(FALSE);
						g_ProgHandleB4Rec = 0;
#ifdef SUPPORT_WAKEUP_TIMER_IN_STANDBY
						 //sent to man app to call APP_WAKEUP_CompleteNotify()
						 MAINAPP_SendGlobalEvent(APP_GLOGAL_EVENT_PVR_TIEMRREC_CHECKSTANDBY, AL_POWER_STATE_OFF);
#endif

				        //need modify kai.wang
						/*extern INT32 APP_GUIOBJ_DVB_TimerList_GetRecordingPR(AL_PR_details_t* details, int* PROffset);
						extern AL_Return_t APP_GUIOBJ_DVB_TimerList_DeleteRecordingPR(int Param);
						int iOffset = 0;
						if (APP_GUIOBJ_DVB_TimerList_GetRecordingPR(NULL, &iOffset) == AL_SUCCESS)
						{
							APP_GUIOBJ_DVB_TimerList_DeleteRecordingPR(iOffset);
						}*/
						break;
					}

					//when event change, we must save it as soon as possible .for 0165167. by kai.wang
					AL_PR_Update(0, 0);
					//end
					AL_SCH_details_t sch_detail;
					al_uint32 CurTimeInSec = 0;  //test
					AL_Time_GetCurTimeInSecs(&CurTimeInSec);

					memset(&sch_detail, 0, sizeof(AL_SCH_details_t));
					sch_detail.sch_event = AL_SCH_TYPE_SINGLE | AL_SCH_TYPE_PRG_EXPIRE_SCH;
					sch_detail.sch_snooze = 0;
					/*when A event end time is B event start time, need take 5s to stop and start flow.*/
					if (AL_PR_CheckEvtEndTime(details.rem_details.event_end_time_insec) == TRUE)
					{
						sch_detail.sch_time = details.rem_details.event_end_time_insec - 5; //for mantis 0156382
					}
					else
					{
						sch_detail.sch_time = details.rem_details.event_end_time_insec;
					}
					sch_detail.sch_user_para = (al_uint32)hProg;

					printf("event_end_time_insec = %d\n", sch_detail.sch_time);
					printf("current time				  = %d\n", CurTimeInSec);

					AL_SCH_ScheduleEvent(&sch_detail, &stoprec_id, al_null);
					APP_GUIOBJ_DVB_PvrRec_SetDurationTime(details.rem_details.event_end_time_insec - CurTimeInSec); //zhongbaoxing added for mantis 142788 @20110720
					PVR_DEBF("%s %d\n", __FUNCTION__, __LINE__);
				}
			}
			else
			{
				DVBApp_SetTVRadioSwap(FALSE);
				g_ProgHandleB4Rec = 0;
#ifdef SUPPORT_WAKEUP_TIMER_IN_STANDBY
				if(APP_WAKEUP_GetBootFlag() == TRUE)
				{
					APP_WAKEUP_RealPowerUp();
				}
#endif
			}
			AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FEATURE,
							ITEM_OFFSET(APP_SETTING_Feature_t, AutoTimeShift),
							sizeof(g_stFeatureData.AutoTimeShift), &(g_stFeatureData.AutoTimeShift));
			if (APP_PVR_TIMESHIFT_AUTO == g_stFeatureData.AutoTimeShift)
			{
				DVBApp_SetBGTimeshift(PVR_BGTIMESHIFT_START_INTERVAL);
			}
		}
		break;
		case APP_DVB_GLOBAL_EVENT_REMINDER_EXPIRE:
#ifdef SUB_CUSTOMER_Tianle
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_TIMERLIST_FORTEAC))
			{
				SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_DVB, DVB_GUIOBJ_TIMERLIST_FORTEAC, APP_DVB_GLOBAL_EVENT_REMINDER_EXPIRE, 0);
			}
#else
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_TIMERLIST))
			{
				SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_DVB, DVB_GUIOBJ_TIMERLIST, APP_DVB_GLOBAL_EVENT_REMINDER_EXPIRE, 0);
			}
#endif
			break;
		case APP_DVB_GLOBAL_EVENT_REMINDER_TIME_CHANGE:
			AL_SCH_Handle_Time_Change(dParam);
			UINT32 u32PopMsgDialogType = POPMSG_PROMPT_NO_PROG;
			APP_GUIOBJ_PopMsg_GetMsgDialogType(&u32PopMsgDialogType);
			if ((POPMSG_CONFIRM_REC_REMIDER_TIME == u32PopMsgDialogType)
				||(POPMSG_CONFIRM_REC_REMIDER_TIME_CONFIRM == u32PopMsgDialogType))
			{
				al_uint32 CurTimeInSec = 0;
				if (AL_Time_GetCurTimeInSecs(&CurTimeInSec) == AL_SUCCESS)
				{
					if ((DVBApp_GetTimerRECStartTime() > CurTimeInSec+PR_NOTIFY_TIME_IN_SEC)
						||(CurTimeInSec > DVBApp_GetTimerRECStartTime()+PR_NOTIFY_TIME_IN_SEC))
					{
						//system time changed, cancle the REMINDER cut down pop
						_DVBApp_ShowPopup(DVB_APP_POP_MSG_PVR_SYSTEM_TIME_CHANGED);
					}
				}
			}
			break;

		case APP_GLOGAL_EVENT_PVR_ASKFORSTANDBY:
			if(!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVRPOWER))
			{
				DVBApp_ResetPopup_Channel();
				_DVBApp_CloseAllMenu();
				SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, DVB_GUIOBJ_PVRPOWER, 0);
			}
			break;
		case APP_GLOGAL_EVENT_PVR_TIMESHIFT_STANDBY:
			_DVBApp_ShowPopup(DVB_APP_POP_MSG_PVR_TIMESHIFT_STANDBY);
			break;

		case APP_GLOBAL_EVENT_PVR_INSERT_USB_POP:
			_DVBApp_ShowPopup(DVB_APP_POP_MSG_INSERT_USB);
			break;
		case APP_GLOBAL_EVENT_PVR_INVALID_USB_POP:
			_DVBApp_ShowPopup(DVB_APP_POP_MSG_INVALID_USB);
			break;
		case APP_GLOBAL_EVENT_PVR_INSERT_USB_CONFIRM:
			_DVBApp_CloseAllMenu();
			_DVBApp_ShowPopup(DVB_APP_POP_MSG_INSERT_USB_CONFIRM);
			break;
		case APP_GLOBAL_EVENT_PVR_INVALID_USB_CONFIRM:
			_DVBApp_CloseAllMenu();
			_DVBApp_ShowPopup(DVB_APP_POP_MSG_INVALID_USB_CONFIRM);
			break;
#endif

		case FW_MONITOR_TUNER_LOCKED:
			if (APP_GUIOBJ_DVB_Playback_GetZappingState())
			{
				APP_GUIOBJ_DVB_Playback_SetZappingState(FALSE);
			}
			dvb_printf(" FW_MONITOR_TUNER_LOCKED event received\n");
			//g_bMidHasUnmute = TRUE;
			//bSetUnMuteFlag = TRUE;
			APP_Video_SetMute(FALSE, FALSE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
#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;
			AL_DB_ERecordType_t eRecordType;

		#if 1
			Boolean bShowLogo = DTV_FALSE;
			bShowLogo = APP_GUIOBJ_DVB_Playback_GetShowLogoState();
		#endif

			MID_PlaybackGetCurProgHandle(&eRecordType, al_null);
			if ((eRecordType == AL_RECTYPE_DVBRADIO) || (bShowLogo == TRUE))
			{
				APP_GUIOBJ_3DMenu_SetMode(TV_IDS_String_3DMODE_OFF);
			}
			else
			{
				MID_DISP_DTVGet3DModeChangeSt(&e3DModeChangeSt);
				if (DISP_3D_STATUS_RESET == 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)
					{
						//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 == DTV_TRUE)
							{
								bSet3DMode = DTV_FALSE;
							}
							else
							{
								APP_GUIOBJ_3DMenu_SetMode(TV_IDS_String_3DMODE_OFF);
							}
						}
						//_APP_GUIOBJ_3DMenu_SetForce2DAnother(TV_IDS_String_On);
					}
					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 == DTV_TRUE)
						{
							bSet3DMode = DTV_FALSE;
						}
						else
						{
							APP_GUIOBJ_3DMenu_SetMode(TV_IDS_String_3DMODE_OFF);
						}
					}
				}
			}
#endif
			/* modify by qinhe for mantis  0011315 */
			//APP_Video_SetMute(FALSE, FALSE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);

			//MID_DISP_DTVInformDisplayPipe();
#ifdef CONFIG_SUPPORT_PVR
			/*< modify by kai.wang*/
			//MID_RecorderSetSignalEx(PRIMARY_REC_UNIT, MID_REC_SIGNAL_GOOD);

			if (u8MidRecState == MID_REC_STATUS_PAUSE)
			{
				MID_RecorderPauseResume();
			}
			_DVBApp_Recorder_PauseResume();
#endif
			//DVBApp_CheckProgramType(TRUE);

			/*close Standby menu*/
			//AL_DVB_Monitor_GetState(AL_DVB_MONITOR_STATE_SIGNAL, &bSignalState);
			if(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_SLEEP_INFO))
			{
				if(APP_GUIOBJ_SleepTimer_GetOpenStandby() == al_true)
				{
					SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, 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);
					}
				}
			}
			break;
		case FW_MONITOR_TUNER_UNLOCKED:
			//MID_PlaybackStartAVChannel(eServiceType, hProg);
		#ifdef CONFIG_QSD
			// To echo message with DTV has no signal for chip test using.
			con_dbg_echo('G', 'O');
			con_dbg_echo('O', 'D');
		#endif
			dvb_printf(" FW_MONITOR_TUNER_UNLOCKED event received\n");
			if (APP_GUIOBJ_DVB_Playback_GetZappingState())
			{
				APP_GUIOBJ_DVB_Playback_SetZappingState(FALSE);
			}
			DVBApp_DataApplicationSwitch(OSD2CTRLMDL_DISABLE|OSD2CTRLMDL_ALL);
			/* reset set unmute flag */
			bSetUnMuteFlag = FALSE;
			g_bMidHasUnmute = FALSE;
			g_SetPQFlag = FALSE;
			//g_bNoSteamData = AL_DVB_MONITOR_VALUE_INVAILED;
		#ifdef SUPPORT_DTV_SHOW_BLUESCREEN
			g_bIsBlueScreen = FALSE;
		#endif
			{
				AL_DB_ERecordType_t eRecordType;
				if (MID_SUCCESS == MID_PlaybackGetCurProgHandle(&eRecordType, al_null))
				{
					if (eRecordType == AL_RECTYPE_DVBTV)
					{
						if ((MID_PlaybackIsPauseState() == 0)
#ifdef CONFIG_SUPPORT_PVR
							&& (DRV_SUCCESS != MID_RecorderIsCurRecording())
							&& (!MID_TSPLParser_GetThreadState())
#endif
						)
						{
							//zhongbaoxing added for mantis 0166730 @20120224
							APP_Video_SetMute(TRUE, TRUE, APP_MUTE_MODE_NO_SIGNALE, eSourType);
							//MID_PlaybackClearScreenNow(); //note: this function is no use anymore because of the bandwidth issue.
						}
#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 == DTV_TRUE)
							{
								bSet3DMode = DTV_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
							//	_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
							{
								//dvb_printf("\n\n\n\n@@@@@@DTV No signal	Always On\n\n\n");
								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(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
					}
				}
			}
#ifdef CONFIG_SUPPORT_PVR
			/*< modify by kai.wang*/
			//MID_RecorderSetSignalEx(PRIMARY_REC_UNIT, MID_REC_SIGNAL_BAD);
			if (u8MidRecState == MID_REC_STATUS_START)
			{
				MID_RecorderPauseResume();
			}
			_DVBApp_Recorder_PauseResume();
#endif
			//if (APP_Area_SupportDtg())
			if(APP_Get_DTVHiddenScanState()!=TRUE)
			{
				AL_DB_EDBType_t eDBType = APP_DVB_Playback_GetCurrentNetType();
				AL_RecHandle_t hCurrProgHdl = APP_DVB_Playback_GetCurrentProgHandle(eDBType, (AL_RECTYPE_DVBTV|AL_RECTYPE_DVBRADIO|AL_RECTYPE_DVBDATA));
				AL_PSI_Monitor_Stop(FALSE, FALSE);
				if (hCurrProgHdl != AL_DB_INVALIDHDL)
				{
					AL_PSI_Monitor_Start(hCurrProgHdl, FALSE);
				}
			}
			if (APP_GetPlaybackPauseState() == TRUE)
			{
				if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_FREEZE))
				{
					SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_FREEZE);
				}
				MID_PlaybackStreamResume(1);
				APP_SetPlaybackPauseState(FALSE);
			}
			
			if (stDvbInst.bAppState != SYSTEM_RUNNING)
			{
				break;
			}
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_MULTIAUD))
			{
				SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_MULTIAUD);
			}
#ifdef CONFIG_SUPPORT_PVR
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_RECDURATIONTIME))
			{
				SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PVR_RECDURATIONTIME);
			}
#endif
			DVBApp_CheckProgramType(TRUE);
#ifdef AC_ON_AUTO_GET_TIME
			if (g_fBackgroundGetTime == TRUE)
			{
				APP_WAKEUP_SetBootFlag(FALSE);
				dvb_printf("\n ----- tuner unlock, back ground get time fail!!!\n");
				MAINAPP_SendGlobalEvent(UI_EVENT_POWER, AL_POWER_STATE_OFF);
			}
#endif
			break;
		case FW_EPG_NOWNEXT_UPDATE_EVENT:
			g_bForceProcessEventCbk = FALSE;
			AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FEATURE, 0,
				sizeof(APP_SETTING_Feature_t), &(g_stFeatureData));
			if(g_stFeatureData.ChildLock)
			{
#if 0
			   //add for 0196870
				if(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_EPG))
				{
					if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_POPMSG))
					{
						SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_POPMSG);
					}
				}
#endif
				AL_Event_t event_hd = (AL_Event_t)dParam;
				al_uint8 bSignalState = al_false;
				AL_DVB_Monitor_GetState(AL_DVB_MONITOR_STATE_SIGNAL, &bSignalState);
				if (bSignalState == AL_DVB_MONITOR_VALUE_TRUE && event_hd)
				{
					UINT8 rating = 0;
					if (AL_Event_GetEventRatingByHdl(event_hd,&rating) == AL_SUCCESS)
					{
						if(APP_DVB_ParentalLock_CheckPrtRating(&rating))
						{
							APP_DVB_Playback_SetUnlock(FALSE);
							APP_Audio_SetMute(TRUE, FALSE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
							APP_Video_SetMute(TRUE, FALSE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
#ifndef PLAY_VIDEO_FOR_ALLSRV
							if (eServiceType == AL_RECTYPE_DVBRADIO)
							{
								SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_DVB,
									DVB_GUIOBJ_PLAYBACK, APP_DVB_INTRA_EVENT_STOP_PLAYBACK,
									( PLAYBACK_STOP_MHEG5 | PLAYBACK_KEEP_FRAMEBUF));
							}
							else
#endif
							{
								SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_DVB,
									DVB_GUIOBJ_PLAYBACK, APP_DVB_INTRA_EVENT_STOP_PLAYBACK,
									(PLAYBACK_STOP_SUBTITLE|PLAYBACK_STOP_MHEG5));
							}
	/*#ifdef SUPPORT_PVR
							if (MID_REC_STATUS_STOP != u8MidRecState)
							{
								if (MID_REC_MODE_MANUAL == u8MIDRecMode)
								{
#ifdef SUPPORT_SPEC_PVR_RECORD// TEAC allow record while the program locked, however the others did not
									if (DVBAPP_Pvr_GetRECPlayFlag() == TRUE)
									{
										DVBApp_StopTimeshift(FALSE);
									}
#else
									DVBApp_StopRecord();
#endif
								}
								else
								{
#ifdef SUPPORT_SPEC_PVR_RECORD// TEAC allow record while the program locked, however the others did not
									DVBApp_StopTimeshift(FALSE);
#else
									DVBApp_StopTimeshift(TRUE);
#endif
								}
							}
#endif*/
							if (!APP_MenuMgr_Exist_Main_Menu())
							{
								UINT32 u32PopMsgDialogType = POPMSG_PROMPT_NO_PROG;
								APP_GUIOBJ_PopMsg_GetMsgDialogType(&u32PopMsgDialogType);
								if((DVBApp_IsPopupExist(PLAYBACK_POPUP_PWD_LOCKED) == FALSE)
	/*#ifdef SUPPORT_PVR
									&& (u32PopMsgDialogType != POPMSG_PROMPT_INITIAL_AUTOTIMESHIFT)
									&& (u32PopMsgDialogType != POPMSG_PROMPT_INITIAL_REC)
									&& (u32PopMsgDialogType != POPMSG_PROMPT_INITIAL_TIMESHIFT)
#endif*/
								   )
								{
									_DVBApp_ShowPopup(DVB_APP_POP_MSG_CHECKPWD);
								}
							}
						}
					}
				}
			}
			if(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_EPGEXTEND))
			{
				SYSAPP_GOBJ_SendMsgToSingleGUIObject(
					SYS_APP_DVB, DVB_GUIOBJ_EPGEXTEND,
					FW_EPG_NOWNEXT_UPDATE_EVENT, 0);
			}
			else if(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_EPG))
			{
				SYSAPP_GOBJ_SendMsgToSingleGUIObject(
					SYS_APP_DVB, DVB_GUIOBJ_EPG,
					FW_EPG_NOWNEXT_UPDATE_EVENT, 0);
			}
			else if(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PROGINFO))
			{
				SYSAPP_GOBJ_SendMsgToSingleGUIObject(
					SYS_APP_DVB, DVB_GUIOBJ_PROGINFO,
					FW_EPG_NOWNEXT_UPDATE_EVENT, 0);
			}
			break;
		case FW_MONITOR_STREAM_NO_DATA:
			dvb_printf(" FW_MONITOR_STREAM_NO_DATA event received\n");
			/* reset set unmute flag */
			g_bNoSteamData = TRUE;
			bSetUnMuteFlag = FALSE;
			g_bMidHasUnmute = FALSE;
			g_SetPQFlag = FALSE;
#ifdef SUPPORT_DTV_SHOW_BLUESCREEN
			g_bIsBlueScreen = FALSE;
#endif
			/* add by qin.he on 2014/07/22 for mantis 23864 */
			if(APP_Get_DTVHiddenScanState()!=TRUE)
			{
				AL_DB_EDBType_t eDBType = APP_DVB_Playback_GetCurrentNetType();
				AL_RecHandle_t hCurrProgHdl = APP_DVB_Playback_GetCurrentProgHandle(eDBType, (AL_RECTYPE_DVBTV|AL_RECTYPE_DVBRADIO|AL_RECTYPE_DVBDATA));
				AL_PSI_Monitor_Stop(FALSE, FALSE);
				if (hCurrProgHdl != AL_DB_INVALIDHDL)
				{
					AL_PSI_Monitor_Start(hCurrProgHdl, FALSE);
				}
			}

			if(DVBApp_IsPopupExist(PLAYBACK_POPUP_PWD_LOCKED) == TRUE)
			{
				break;
			}
			
			{
#ifdef CONFIG_SUPPORT_PVR
				if (u8MidRecState == MID_REC_STATUS_START)
				{
					MID_RecorderPauseResume();
				}
				_DVBApp_Recorder_PauseResume();
#endif
				if (APP_GetPlaybackPauseState() == TRUE)
				{
					if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_FREEZE))
					{
						SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_FREEZE);
					}
					MID_PlaybackStreamResume(1);
					APP_SetPlaybackPauseState(FALSE);
				}
				DVBApp_CheckProgramType(TRUE);
				DVBApp_DataApplicationSwitch(OSD2CTRLMDL_DISABLE|OSD2CTRLMDL_ALL);
			}
			break;

		case FW_MONITOR_STREAM_HAS_DATA:
			dvb_printf(" FW_MONITOR_STREAM_HAS_DATA event received\n");
#ifdef CONFIG_SUPPORT_PVR
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_FILEPLAY))
			{
				dvb_printf("===lxl test %s ,%d is called. now PVR is playing ===\n", __FUNCTION__,__LINE__);
				break;
			}
			APP_GUIOBJ_DVB_PvrPlayInfo_SetTunerState(FALSE);
#endif
			g_bNoSteamData = FALSE;
#ifdef CONFIG_SUPPORT_PVR
			if (u8MidRecState == MID_REC_STATUS_PAUSE)
			{
				MID_RecorderPauseResume();
			}
			_DVBApp_Recorder_PauseResume();
#endif
			DVBApp_CheckProgramType(TRUE);
#ifndef PLAY_VIDEO_FOR_ALLSRV
			if (eServiceType == AL_RECTYPE_DVBRADIO)
			{
				//DVBApp_CheckProgramType(TRUE);
			}
			else
#endif
			{
				APP_Video_SetMute(FALSE, FALSE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
			}
			if (DVBApp_GetScrambleStatus() == PROG_STATUS_SCRAMBLE_CLEAR)
			{
				DVBApp_DataApplicationSwitch(OSD2CTRLMDL_ENABLE | OSD2CTRLMDL_SUB);
			}
			break;

		case FW_MONITOR_PARENTAL_LOCKED:
			dvb_printf("FW_MONITOR_PARENTAL_LOCKED received!!\n");
#ifdef SUPPORT_DTV_SHOW_BLUESCREEN
			g_bIsBlueScreen = FALSE;
#endif
			g_bMidHasUnmute = FALSE;
			if (APP_GUIOBJ_DVB_Playback_GetPlayState() == TRUE)
			{
				APP_DVB_ParentalLock_SetPrtRatinglock(TRUE);
#ifndef PLAY_VIDEO_FOR_ALLSRV
				if (eServiceType == AL_RECTYPE_DVBRADIO )
				{
					SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_DVB,
						(APP_DVB_GLOBAL_EVENT_STOP_PLAYBACK|PASS_TO_SYSAPP),
						( PLAYBACK_STOP_MHEG5 | PLAYBACK_KEEP_FRAMEBUF ));
				}
				else
#endif
				{
					SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_DVB,
						(APP_DVB_GLOBAL_EVENT_STOP_PLAYBACK|PASS_TO_SYSAPP),
						( PLAYBACK_STOP_SUBTITLE |PLAYBACK_STOP_MHEG5 ));
				}
#ifdef CONFIG_SUPPORT_PVR
				if (MID_REC_STATUS_STOP != u8MidRecState)
				{
					if (MID_REC_MODE_MANUAL == u8MIDRecMode)
					{
#ifdef SUPPORT_SPEC_PVR_RECORD// TEAC allow record while the program locked, however the others did not
						if (DVBAPP_Pvr_GetRECPlayFlag() == TRUE)
						{
							DVBApp_StopTimeshift(FALSE);
						}
#else
						DVBApp_StopRecord();
#endif
					}
					else
					{
#ifdef SUPPORT_SPEC_PVR_RECORD//TEAC allow record while the program locked, however the others did not
						DVBApp_StopTimeshift(FALSE);
#else
						DVBApp_StopTimeshift(TRUE);
#endif
					}
				}
#ifdef CONFIG_SUPPORT_PVR
				if (u8MidRecState == MID_REC_STATUS_START)
				{
					MID_RecorderPauseResume();
				}
				_DVBApp_Recorder_PauseResume();
#endif
#endif
				if (APP_GetPlaybackPauseState() == TRUE)
				{
					if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_FREEZE))
					{
						SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_FREEZE);
					}
					MID_PlaybackStreamResume(1);
					APP_SetPlaybackPauseState(FALSE);
				}
				DVBApp_CheckProgramType(TRUE);
			}
			break;

		case FW_MONITOR_PARENTAL_UNLOCKED:
			dvb_printf("FW_MONITOR_PARENTAL_UNLOCKED is received!!\n");
			g_SetPQFlag = TRUE;
			APP_DVB_ParentalLock_SetPrtRatinglock(FALSE);
			if (APP_GUIOBJ_DVB_Playback_GetPlayState() == FALSE)
			{
				SYSAPP_GOBJ_SendMsgToSingleGUIObject(
					SYS_APP_DVB, DVB_GUIOBJ_PLAYBACK,
					APP_DVB_INTRA_EVENT_START_PLAYBACK, 0);
			}

			DVBApp_CheckProgramType(TRUE);

			DVBApp_DataApplicationSwitch(OSD2CTRLMDL_ENABLE | OSD2CTRLMDL_SUB);

#ifdef CONFIG_SUPPORT_PVR
			if (u8MidRecState == MID_REC_STATUS_PAUSE)
			{
				MID_RecorderPauseResume();
			}
			_DVBApp_Recorder_PauseResume();
#endif
			break;

		case FW_MONITOR_SERVICE_ONLY_AUDIO_SCRAMBLE:
			dvb_printf("FW_MONITOR_SERVICE_ONLY_AUDIO_SCRAMBLE is received!!\n");
			g_bScrambleFlag = PROG_STATUS_ONLY_AUDIO_SCRAMBLED;
			g_bNoSteamData = FALSE;
			DVBApp_CheckProgramType(TRUE);
			break;
			
		case FW_MONITOR_SERVICE_ONLY_VIDEO_SCRAMBLE:
			printf("\n\n\nFW_MONITOR_SERVICE_ONLY_VIDEO_SCRAMBLE is received!!,No CAM Inserted!\n\n");
			g_bNoSteamData = FALSE;
			{
				DVBApp_DataApplicationSwitch(OSD2CTRLMDL_DISABLE|OSD2CTRLMDL_ALL);

			}
#ifdef CONFIG_SUPPORT_PVR
			if (u8MidRecState == MID_REC_STATUS_START)
			{
				MID_RecorderPauseResume();
			}
			_DVBApp_Recorder_PauseResume();
#endif
			g_bScrambleFlag = PROG_STATUS_ONLY_VIDEO_SCRAMBLED;
			DVBApp_CheckProgramType(TRUE);
			break;


		case FW_MONITOR_SERVICE_VIDEO_AUDIO_SCRAMBLE:
			printf("\n\n\nFW_MONITOR_SERVICE_VIDEO_AUDIO_SCRAMBLE is received!!\n\n");
			g_bNoSteamData = FALSE;
			{
				DVBApp_DataApplicationSwitch(OSD2CTRLMDL_DISABLE|OSD2CTRLMDL_ALL);
			}
#ifdef CONFIG_SUPPORT_PVR
			if (u8MidRecState == MID_REC_STATUS_START)
			{
				MID_RecorderPauseResume();
			}
			_DVBApp_Recorder_PauseResume();
#endif
			g_bScrambleFlag = PROG_STATUS_AUDIO_VIDEO_SCRAMBLED;
			DVBApp_CheckProgramType(TRUE);
			break;

		case FW_MONITOR_SERVICE_NO_SCRAMBLE:
			printf("\n\n\nFW_MONITOR_SERVICE_NO_SCRAMBLE is received!!\n\n");
			g_bNoSteamData = FALSE;
			g_bScrambleFlag = PROG_STATUS_SCRAMBLE_CLEAR;
			g_SetPQFlag = TRUE;
			DVBApp_CheckProgramType(TRUE);
#ifdef CONFIG_SUPPORT_PVR
			if (u8MidRecState == MID_REC_STATUS_PAUSE)
			{
				MID_RecorderPauseResume();
			}
			_DVBApp_Recorder_PauseResume();
#endif
			/*add by xm.zeng on 2013/9/23.
			sometimes the video is freezed, subtitle is updated.*/
			if(!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_FREEZE))
			{
				DVBApp_DataApplicationSwitch(OSD2CTRLMDL_ENABLE | OSD2CTRLMDL_SUB);
			}
			break;

		case FW_MONITOR_AUDIO_UPDATE:
			dvb_printf("FW_MONITOR_AUDIO_UPDATE is received!!\n");
			APP_GUIOBJ_DVB_MultiAud_Update(MULTIAUDIO_UPDATE);
#ifdef CONFIG_SUPPORT_PVR
			if (APP_GUIOBJ_DVB_PvrRec_PidRemap() != PVR_MSG_SUCCESS)
			{
				dvb_printf("\n MultiAud_Update to remap pid fail!!!\n");
			}
#endif
			DVBApp_CheckProgramType(TRUE);
			break;

		case APP_DVB_GLOBAL_EVENT_OSD2_UPDATE:
			dvb_printf("APP_DVB_GLOBAL_EVENT_OSD2_UPDATE is received!!\n\n");

            AL_DVB_Monitor_GetState(AL_DVB_MONITOR_STATE_SIGNAL, &bSignalState);
            if (bSignalState != AL_DVB_MONITOR_VALUE_TRUE)//force to tuner locked
            {
                al_uint8  u8DVBMonState = AL_DVB_MONITOR_VALUE_TRUE;
                AL_DVB_Monitor_SetState(AL_DVB_MONITOR_STATE_SIGNAL, &u8DVBMonState);
            }

#ifdef CONFIG_SUPPORT_PVR
			if ((SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_REC))
				 || (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO)))
			{
				break;
			}
#endif
			DVBApp_DataApplicationSwitch(OSD2CTRLMDL_FORCE | OSD2CTRLMDL_ENABLE | OSD2CTRLMDL_MH5 | OSD2CTRLMDL_SUB);
			break;

		case FW_MONITOR_SERTYPE_CHANGED:
			MID_PlaybackGetCurProgHandle(al_null, &hCurrProgHandle);
			if (hCurrProgHandle != AL_DB_INVALIDHDL)
			{
				AL_DB_ERecordType_t eSrvType =  (AL_DB_ERecordType_t)dParam;

				APP_DVB_Playback_SetCurrServiceType(eNetType, eSrvType);
				APP_DVB_Playback_SetCurrentProgHandle(eNetType,eSrvType,hCurrProgHandle);
			}
			_DVBApp_SendServRefleshMsg();
			SYSAPP_IF_SendCriticalGlobalEventWithIndex(SYS_APP_DVB, FW_MONITOR_UPDATE_SERVICE,0);
			break;

		case FW_MONITOR_REMOVE_SERVICE:
			//_DVBApp_ShowPopup(DVB_APP_POP_MSG_SERVICE_REMOVE);
			if(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_CHNMGR)
				|| SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_FAVMGR)
				|| SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_CHNLIST)
				|| SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_FAVLIST)
				|| SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_EPG)
				|| SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_CHNRENAME)
#ifdef CONFIG_SUPPORT_PVR
				|| SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_TIMEREDIT)
#endif
				)
			{
				if(DVBApp_GetUnstableState() == FALSE)
				{
					DVBApp_SetUnstableState(TRUE);
				}
				dvb_printf("Post Process The Unstable Services\n\n");
				break;
			}
			DVBApp_RemoveUnstableService();
			// here not break
		case FW_MONITOR_ADD_SERVICE:
		case FW_MONITOR_UPDATE_SERLCN:
			//_DVBApp_ShowPopup(DVB_APP_POP_MSG_NEW_SERVICE);
			APP_DVB_ChannelOrderChecking();
			APP_DVB_DataSavingToDB(eNetType);
			_DVBApp_SendServRefleshMsg();
			break;

#ifdef SUPPORT_DYNAMIC_MULTIPLEXES
		case FW_MONITOR_OTHERTP_SERVICE_FOUND:
			{
				UINT16 u16Num;

				AL_PSI_Monitor_GetOtherTpServList(NULL,NULL,&u16Num);
				_DVBApp_ShowPopup(DVB_APP_POP_MSG_OTH_TP_NEW_SERVICE);
			}
			break;
#endif

		case FW_MONITOR_SERVICE_MOVE:
			_DVBApp_ServiceMove();
			break;

		case FW_MONITOR_REPLACE_SERVICE:
			{
				dvb_printf("[%s:%d] FW_MONITOR_REPLACE_SERVICE !!!!!!!!!!!!!\n",__FUNCTION__,__LINE__);
				AL_RecHandle_t hReplaceProg = AL_DB_INVALIDHDL;
				hReplaceProg = (AL_RecHandle_t)dParam;
				_DVBApp_Zapping(eServiceType, hReplaceProg, TRUE, FW_MONITOR_REPLACE_SERVICE, TRUE);
			}
			break;
		case FW_MONITOR_CLOSECAPTION_UPDATE:
#ifdef CONFIG_SUPPORT_ISDB_SUBTITLE
			dvb_printf("[%s:%d] FW_MONITOR_CLOSECAPTION_UPDATE !!!!!!!!!!!!!\n",__FUNCTION__,__LINE__);
			eServiceType = APP_DVB_Playback_GetCurrServiceType(eNetType);
#ifndef PLAY_VIDEO_FOR_ALLSRV
			if(eSourType != APP_SOURCE_DTV || eServiceType == AL_RECTYPE_DVBRADIO)
			{
				break;
			}
#endif
			AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_SETUP, 0,
				sizeof(APP_SETTING_Setup_t), &(g_stSetupData));
			/**< get current subtitle on/off status from EEPROM */
			
			if(g_stSetupData.DTVCCMode != 0)
			{
				MID_PlaybackProgState_t progstate = MID_PLAYBK_PROG_STATE_REPLACE;
				progstate = APP_DVB_Playback_GetProgStateByHandle(APP_DVB_Playback_GetCurrentNetType(), AL_DB_INVALIDHDL);
				if((progstate != MID_PLAYBK_PROG_STATE_NORMAL)
					&& (progstate != MID_PLAYBK_PROG_STATE_VIDEO_AVC)
					&& (progstate != MID_PLAYBK_PROG_STATE_VIDEO_MPEG4))
				{
					break;
				}
				DVBApp_DataApplicationSwitch(OSD2CTRLMDL_ENABLE|OSD2CTRLMDL_SUB);
			}
#endif
			break;
		case FW_MONITOR_REPLACE_SIMULCASE_SERVICE:
			dvb_printf("[%s:%d] FW_MONITOR_REPLACE_SIMULCASE_SERVICE !!!!!!!!!!!!!\n",__FUNCTION__,__LINE__);
			_DVBApp_SimulcaseDispose(dParam);
			break;

#ifdef SUPPORT_CHANGE_TS_DYNAMICALLY
		case FW_MONITOR_TS_CHANGED:
			dvb_printf("[%s:%d] FW_MONITOR_TS_CHANGED !!!!!!!!!!!!!!!!\n\n",__FUNCTION__,__LINE__);
#ifdef CONFIG_SUPPORT_PVR
			if (MID_REC_MODE_MANUAL == u8MIDRecMode)
            {
                DVBApp_StopRecord();
            }
            else if ((MID_REC_MODE_TIMESHIFT_AFTER_REC == u8MIDRecMode) ||
                     (MID_REC_MODE_AUTO == u8MIDRecMode))
            {
                DVBApp_StopTimeshift(TRUE);
                if (APP_PVR_TIMESHIFT_AUTO == u8AutoTimeShift)
                {
                    DVBApp_SetBGTimeshift(PVR_BGTIMESHIFT_START_INTERVAL);
                }
            }
#endif
			if(APP_Get_DTVHiddenScanState()!=TRUE)
			{
				if (APP_MenuMgr_Exist_Factory_Menu())
				{
					APP_MenuMgr_Exit_Factory_Menu();
				}
				AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_CHANNEL, 0,
				sizeof(APP_SETTING_Channel_t), &(g_stChannelData));
				if(APP_Get_DTVTSChangeNeedScanState(dParam)!=TRUE)
				{
					dvb_printf("[%s:%d]no scan for ts change ,\n",__FUNCTION__,__LINE__);
					break;
				}
				APP_DTV_ScanProcess_TSChange();
			}
			break;
#endif
		case FW_MONITOR_NEW_TSID:
			//case UI_EVENT_RED:
			/* pop up msg for user to start channel search */
			AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_CHANNEL, 0,
							sizeof(APP_SETTING_Channel_t), &(g_stChannelData));
			//SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PLAYBACK, FW_MONITOR_NEW_TSID, 0);
			break;
		case FW_MONITOR_TIME_UPDATE:
			{
				al_uint32 TimeInSec = 0;
				AL_Time_t time;
				memset(&time, 0, sizeof(time));
				AL_Time_MjdToYmd(AL_Time_GetRawMjd(),&time.Year, &time.Month, &time.Day);
				AL_Time_GetRawTime(&time.Hour, &time.Min, &time.Sec);
				AL_Time_DateToSecs(&time, &TimeInSec);
				tv_SetBaseTimetoSystem(TimeInSec);
			}
#ifdef CONFIG_SUPPORT_PVR
#ifdef SUB_CUSTOMER_Tianle
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_TIMERLIST_FORTEAC))
			{
				SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_DVB, DVB_GUIOBJ_TIMERLIST_FORTEAC,
					APP_GLOBAL_EVENT_REFRESH_DATA, 0);
			}
#else
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_TIMERLIST))
			{
				SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_DVB, DVB_GUIOBJ_TIMERLIST,
					APP_GLOBAL_EVENT_REFRESH_DATA, 0);
			}
#endif
#endif
			break;
		case FW_MONITOR_FIND_NEW_TPLIST:
			{
				/* got the freq list which need tune */
				dvb_printf("Receive Freq change msg from afw! dvb_app received message which notice PSI Monitor has found some new freqs which need tune!!!!!!\n");
				_DVBApp_Exit_All_Menu();
				APP_DTV_ScanSetFreqList(dParam);
				APP_GUIOBJ_ScanProcess_SetCurrentSearchMode(SEARCH_D_FULL_FREQ_LIST_MODE);
				APP_DTV_ScanProcess_Start(SEARCH_D_FULL_FREQ_LIST_MODE);
			}

			break;
		case APP_DVB_GLOBAL_EVENT_NO_SIGNAL:
		#ifdef CONFIG_QSD
		  // TV doesn't need to show no signal osd for qsd chip test.
			return 0;
		#endif
			DVBApp_DataApplicationSwitch(OSD2CTRLMDL_DISABLE | OSD2CTRLMDL_ALL);
			if (MID_PlaybackIsPauseState() == 0)	// move to here for mantis 0158116
			{
        	#ifndef SUPPORT_DTV_SHOW_BLUESCREEN
				//MID_PlaybackClearScreenNow();
			#endif
			}
#ifdef CONFIG_SUPPORT_PVR
			if (u8MidRecState == MID_REC_STATUS_START)
			{
				MID_RecorderPauseResume();
			}
			_DVBApp_Recorder_PauseResume();
#endif
#if 0
			if(APP_Get_DTVHiddenScanState()!=TRUE)
			{
				MID_PsiMonStop(FALSE);
				MID_PsiMonStart();
			}
#else
			if(APP_Get_DTVHiddenScanState()!=TRUE)
			{
				AL_DB_EDBType_t eDBType = APP_DVB_Playback_GetCurrentNetType();
				AL_RecHandle_t hCurrProgHdl = APP_DVB_Playback_GetCurrentProgHandle(eDBType, (AL_RECTYPE_DVBTV|AL_RECTYPE_DVBRADIO|AL_RECTYPE_DVBDATA));
				AL_PSI_Monitor_Stop(FALSE, FALSE);
				if (hCurrProgHdl != AL_DB_INVALIDHDL)
				{
					AL_PSI_Monitor_Start(hCurrProgHdl, FALSE);
				}
			}
#endif
			/* if TT Menu exist, first close it */
			if (stDvbInst.bAppState != SYSTEM_RUNNING)
			{
				break;
			}
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_FREEZE))
			{
				SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_FREEZE);
			}
			if (APP_GetPlaybackPauseState() == TRUE)
			{
				MID_PlaybackStreamResume(1);
				APP_SetPlaybackPauseState(FALSE);
			}

		#ifdef SUPPORT_DTV_SHOW_BLUESCREEN
			if (g_stSetupData.BlueScreen == APP_SWITCH_ON)
			{
				g_bIsBlueScreen = TRUE;
			}
		#endif
			DVBApp_CheckProgramType(TRUE);
			break;
		case APP_GLOBAL_EVENT_SET_UNMUTE:
			{
				AL_DB_EDBType_t eNetType = APP_DVB_Playback_GetCurrentNetType();
				AL_DB_ERecordType_t eServiceType = APP_DVB_Playback_GetCurrServiceType(eNetType);
				if (eServiceType == AL_RECTYPE_DVBRADIO  || eServiceType == AL_RECTYPE_DVBDATA) 
				{
					APP_Audio_SetMute(FALSE, FALSE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
				}
				else
				{
					APP_Video_SetMute(FALSE, FALSE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
				}
				break;
			}
		case APP_DVB_GLOBAL_EVENT_SET_UNMUTE:
			dvb_printf(" APP_DVB_GLOBAL_EVENT_SET_UNMUTE event received\n");
			/* dtv, search all, when switch to scan analog, tvfe will send show snow525,
				 * but current source is dtv, so FormatChangeCallback() will send this message,
				 * judge here, when scan, do nothing, has side effect?
				 */
			if (!AL_CS_IsStop())
			{
				break;
			}
			#if 0//shiting.liao mark for 0020236:stop mheg5 ts,first show "no signal",then program stop at last picture
			/* add by qinhe for signal present message received too late */
			{
				MID_PlaybackProgState_t progstate = MID_PLAYBK_PROG_STATE_NORMAL;
				progstate = APP_DVB_Playback_GetProgStateByHandle(APP_DVB_Playback_GetCurrentNetType(), AL_DB_INVALIDHDL);

				if ((g_bNoSteamData == FALSE) && (progstate != MID_PLAYBK_PROG_STATE_TEMP_SERVICE)
					&& (progstate != MID_PLAYBK_PROG_STATE_NOT_RUNNING))
				{
					al_uint8  uDVBMonState = AL_DVB_MONITOR_VALUE_TRUE;
					AL_DVB_Monitor_SetState(AL_DVB_MONITOR_STATE_SIGNAL, &uDVBMonState);
				}
			}
			#endif
			if ((APP_SOURCE_DTV == eMidSourType) || (APP_SOURCE_RADIO == eMidSourType))
			{
				g_bMidHasUnmute = TRUE;
				bSetUnMuteFlag = TRUE;
				DVBApp_CheckProgramType(TRUE);
				if(APP_SOURCE_DTV == eMidSourType)
				{
				}
				
			}
			break;

		case APP_DVB_GLOBAL_EVENT_SERVICE_NOT_AVAILABLE_CLEAR:
#ifdef CONFIG_SUPPORT_PVR
			if (u8MidRecState == MID_REC_STATUS_PAUSE)
			{
				MID_RecorderPauseResume();
			}
			_DVBApp_Recorder_PauseResume();
#endif
			if (DVBApp_IsPopupExist(PLAYBACK_POPUP_MSG_SERVICE_NOT_AVAILABLE))
			{
				DVBApp_ClosePopup(PLAYBACK_POPUP_MSG_SERVICE_NOT_AVAILABLE, UI_EVENT_NULL);
			}

			DVBApp_DataApplicationSwitch(OSD2CTRLMDL_ENABLE | OSD2CTRLMDL_SUB);
			DVBApp_CheckProgramType(TRUE);
			break;

		case APP_DVB_GLOBAL_EVENT_SERVICE_VIDEO_NOT_SUPPORT:
		case APP_DVB_GLOBAL_EVENT_SERVICE_VIDEO_NOT_SUPPORT_CLEAR:
		case APP_DVB_GLOBAL_EVENT_PARENTAL_LOCK:
		case APP_DVB_GLOBAL_EVENT_PARENTAL_LOCK_CLEAR:
		case APP_DVB_GLOBAL_EVENT_TEMP_SERVICE:
		case APP_DVB_GLOBAL_EVENT_TEMP_SERVICE_CLEAR:

#ifdef CONFIG_SUPPORT_PVR
			if (u8MidRecState == MID_REC_STATUS_START)
			{
				MID_RecorderPauseResume();
			}
			_DVBApp_Recorder_PauseResume();
#endif
			if (g_bMidHasUnmute) //zhongbaoxing added for mantis 0150118 @20110905
			{
				DVBApp_CheckProgramType(TRUE);
			}
			break;

#if 0 //Have been the new approach to replace.
		case APP_DVB_GLOBAL_EVENT_SCRAMBLE:
			g_bScrambleFlag = PROG_STATUS_SCRAMBLED;
#ifdef CONFIG_SUPPORT_PVR
			if (u8MidRecState == MID_REC_STATUS_START)
			{
				MID_RecorderPauseResume();
			}
			_DVBApp_Recorder_PauseResume();
#endif
			DVBApp_CheckProgramType(TRUE);
			break;

		case APP_DVB_GLOBAL_EVENT_SCRAMBLE_CLEAR:
			g_bScrambleFlag = PROG_STATUS_SCRAMBLE_UNKNOW;
#ifdef CONFIG_SUPPORT_PVR
			if (u8MidRecState == MID_REC_STATUS_PAUSE)
			{
				MID_RecorderPauseResume();
			}
			_DVBApp_Recorder_PauseResume();
#endif
			if (g_bMidHasUnmute)
			{
				DVBApp_CheckProgramType(TRUE);
			}
			break;
#endif
		case FW_MONITOR_UPDATE_SERVICE:
#ifdef CONFIG_SUPPORT_PVR
			if (u8MidRecState != MID_REC_STATUS_STOP)
			{
				AL_RecHandle_t hProg = 0;
				AL_DB_EDBType_t DBType = AL_DBTYPE_MAX;
				AL_ServiceDetail_t stServInfo;

				APP_Database_GetCurrentDBType(APP_SOURCE_DTV, &DBType);

				hProg = APP_DVB_Playback_GetCurrentProgHandle(DBType,
					AL_RECTYPE_DVBTV |AL_RECTYPE_DVBRADIO | AL_RECTYPE_DVBDATA);

				if (AL_SUCCESS == AL_DB_QueryDetail(hProg, (al_void *)&stServInfo))
				{
					if (stServInfo.stSBTVDServ.stProgAttrib.scramble == al_true)
					{
						if (MID_RecorderState() == MID_REC_STATUS_START)
						{
							MID_RecorderPauseResume();
							_DVBApp_Recorder_PauseResume();
						}
					}
					else
					{
						if (MID_RecorderState() == MID_REC_STATUS_PAUSE)
						{
							MID_RecorderPauseResume();
							_DVBApp_Recorder_PauseResume();
						}
					}
				}
			}
#endif
			break;

#ifdef SUPPORT_CEC_TV
		case APP_DVB_GLOBAL_EVENT_HDMIPORT_STATUS:
			CECTV_HDMIPortStatus(dParam);
			break;
#endif
#if defined(CONFIG_HEADPHONE_DETECT_BY_ISR) || defined(CONFIG_HPDET_BY_SWTIMER)
		case APP_GLOBAL_EVENT_HEADPHONE_PLUG_IN:
			APP_Audio_Set_HPStatus(APP_Audio_Headphone_PlugIn);
			APP_Audio_SetMuteSpeakerWithoutAMP(TRUE);
			APP_Audio_SetMuteAMP(TRUE);
			APP_Audio_SetMuteDACSpeak(TRUE);
			APP_Audio_SetMuteDACHeadohone(FALSE);
			AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FEATURE, 0,
			sizeof(APP_SETTING_Feature_t), &(g_stFeatureData));
			if (g_stFeatureData.SpeakerPreference == APP_HDMILINK_TVSPEAKER)
				APP_Audio_SetMuteSpeakerWithoutAMP(FALSE);
			AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_VARIATIONAL, 0,
				sizeof(APP_SETTING_Variational_t), &(g_stVariationalData));
			APP_Audio_SetVolume(g_stVariationalData.Volume);
			break;

		case APP_GLOBAL_EVENT_HEADPHONE_PLUG_OUT:
			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));

			bHasValidServ = AL_DB_HasVisibleService(eNetType);
			AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FEATURE, 0,
			sizeof(APP_SETTING_Feature_t), &(g_stFeatureData));
			if ((g_stUserInfoData.Mute == FALSE) && bHasValidServ && g_stFeatureData.SpeakerPreference == APP_HDMILINK_TVSPEAKER)
			{
				#ifdef SUPPORT_WAKEUP_TIMER_IN_STANDBY
				if (APP_WAKEUP_GetBootFlag() == FALSE)
				#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

#ifdef CONFIG_QSD
		case APP_GLOBAL_EVENT_QSD_MEDIA_PLAY:
			{
				void MM_MediaQsd_SetTestFlag(BOOLEAN bFlag, UINT32 dParam);
				MM_MediaQsd_SetTestFlag(TRUE, dParam);
				APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_MEDIA);
			}
			break;

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

		case UI_EVENT_MENU:
			AutoUpgrade = FALSE;
			if (APP_MenuMgr_Exist_Main_Menu()
				|| APP_MenuMgr_Exist_Factory_Menu()
				|| SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_EPG)
				||	SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_EPGEXTEND)
				|| SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_MULTIAUD))
			{
				if (APP_GetPlaybackPauseState() == TRUE)
				{
					SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, DVB_GUIOBJ_FREEZE, 0);
				}
				_DVBApp_Exit_All_Menu();
			}
			else if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_CHNMGR)
					 || SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_FAVMGR)
					 || SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_CHNRENAME)
					 ||  SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_CHNLIST)
					 ||  SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_FAVLIST))
			{
				if (MID_PlaybackIsPauseState())
				{
					SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, DVB_GUIOBJ_FREEZE, 0);
				}
				_DVBApp_Exit_All_Menu();

				bHasValidServ = AL_DB_HasVisibleService(eNetType);
				
				if (bHasValidServ)
				{
					if ((!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PROGINFO))
#ifdef SUPPORT_HOTEL_MODE_INFOBANNER_SHOW_CONTROL
						&&((!g_stFactoryHotelData.HotelModeOnOff)||(g_stFactoryHotelData.ShowInfoBar))
#endif
						)
					{
						if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_ADJUST))
						{
							SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, APP_GUIOBJ_ADJUST);
						}
#ifdef SUPPORT_CEC_TV
						if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_AMPLIFIERVOLUME))
						{
							SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, APP_GUIOBJ_AMPLIFIERVOLUME);
						}
#endif						
						SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, DVB_GUIOBJ_PROGINFO, 0);
					}
				}
			}
			else
			{
				DVBApp_ResetPopup_Channel();
				_DVBApp_CloseAllMenu();
				if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_FREEZE))
				{
#ifdef Subtitle_Freeze
					AL_Subtitle_SetFreeze(FALSE);
#else
					DVBApp_DataApplicationSwitch(OSD2CTRLMDL_ENABLE | OSD2CTRLMDL_SUB);
#endif
					SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_FREEZE);
				}
				if (APP_GetPlaybackPauseState() == TRUE)
				{
					MID_PlaybackStreamResume(1);
					APP_SetPlaybackPauseState(FALSE);
				}
				SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB,
					APP_GUIOBJ_MAINMENU, FIRST_ENTER_MAINMENU);
			}
			break;

		case UI_EVENT_SOURCE:
#ifdef CONFIG_SUPPORT_PVR
			if (u8MidRecState != MID_REC_STATUS_STOP)
			{
				if (MID_REC_MODE_MANUAL == u8MIDRecMode)
				{
					_DVBApp_ShowPopup(DVB_APP_POP_MSG_REC_STOP_SOURCE_CHANGE);
					break;
				}
				else
				{
					_DVBApp_ShowPopup(DVB_APP_POP_MSG_TIMESHIFT_STOP_SOURCE_CHANGE);
					break;
				}
			}
			else
#endif
			{
				if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_SOURCE))
				{
#ifdef CONFIG_SUPPORT_PVR
					if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_FILEPLAY))
					{
						SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, APP_GUIOBJ_SOURCE);
					}
					else
#endif
					{
						_DVBApp_Exit_All_Menu();
					}
				}
				else
				{
					DVBApp_ResetPopup_Channel();
					_DVBApp_CloseAllMenu();
					SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, APP_GUIOBJ_SOURCE, 0);
				}
			}
			break;

#ifdef CONFIG_MEDIA_ENABLE
		case UI_EVENT_SRC_USB:
		{
#ifdef CONFIG_SUPPORT_PVR
			if (MID_REC_STATUS_STOP != u8MidRecState)// && (MID_REC_MODE_AUTO != u8MIDRecMode))
			{
				if (MID_REC_MODE_MANUAL == u8MIDRecMode)
				{
					_DVBApp_ShowPopup(DVB_APP_POP_MSG_REC_STOP_FOR_USBKEY);
				}
				else
				{
					_DVBApp_ShowPopup(DVB_APP_POP_MSG_TIMESHIFT_STOP_FOR_USBKEY);
				}
				break;
			}
#endif
			_DVBApp_CloseAllMenu();
			DVBApp_ResetPopup_Channel();
			if (SP_SUCCESS != APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_MEDIA))
			{
				dvb_printf("APP_GUIOBJ_Source_SetAppSource Fail!!!!!!!!!\n");
			}
		}
		break;
#endif

		case UI_EVENT_TV_DVD:
#ifdef CONFIG_ATV_SUPPORT
			DVBApp_ResetPopup_Channel();
			_DVBApp_CloseAllMenu();
			APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_DVD);

#else
			_DVBApp_ShowPopup(DVB_APP_POP_MSG_NOT_AVAILABLE);
#endif
			break;

#ifdef CONFIG_SUPPORT_PVR
#ifdef SUPPORT_PVR_ONOFF
		case UI_EVENT_PVR_ONOFF:
			if ((MID_REC_STATUS_STOP != u8MidRecState)
				|| SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_FILEPLAY))
			{
				break;
			}
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_MAINMENU))
			{
				DVBApp_ResetPopup_Channel();
				_DVBApp_CloseAllMenu();
				AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_SETUP, 0,
					sizeof(APP_SETTING_Setup_t), &(g_stSetupData));
				if (g_stSetupData.PVROnOff)
				{
					g_stSetupData.PVROnOff = 0;
					AL_PR_DeleteAllSch(eNetType, AL_PR_EVT_REM | AL_PR_SRV_REM);
					g_stFeatureData.AutoTimeShift = APP_PVR_TIMESHIFT_OFF;
					AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_FEATURE,
						ITEM_OFFSET(APP_SETTING_Feature_t, AutoTimeShift),
						sizeof(g_stFeatureData.AutoTimeShift),&(g_stFeatureData.AutoTimeShift));
					AL_Setting_Store(APP_Data_UserSetting_Handle(), SYS_SET_ID_FEATURE,
						ITEM_OFFSET(APP_SETTING_Feature_t, AutoTimeShift), sizeof(g_stFeatureData.AutoTimeShift));
					_DVBApp_ShowPopup(DVB_APP_POP_MSG_PVR_DISABLE);
				}
				else
				{
					g_stSetupData.PVROnOff = 1;
					_DVBApp_ShowPopup(DVB_APP_POP_MSG_PVR_ENABLE);
				}
				AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_SETUP,
					ITEM_OFFSET(APP_SETTING_Setup_t, PVROnOff),
					sizeof(g_stSetupData.PVROnOff), &(g_stSetupData.PVROnOff));
				AL_Setting_Store(APP_Data_UserSetting_Handle(), SYS_SET_ID_SETUP,
					ITEM_OFFSET(APP_SETTING_Setup_t, PVROnOff), sizeof(g_stSetupData.PVROnOff));
			}
			break;
#endif
#endif
#ifdef SUPPORT_EPG_ONOFF
		case UI_EVENT_EPG_ONOFF:
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_MAINMENU))
			{
				DVBApp_ResetPopup_Channel();
				_DVBApp_CloseAllMenu();
				AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_SETUP, 0,
					sizeof(APP_SETTING_Setup_t), &(g_stSetupData));
				if (g_stSetupData.EPGOnOff)
				{
					g_stSetupData.EPGOnOff = 0;
					_DVBApp_ShowPopup(DVB_APP_POP_MSG_EPG_DISABLE);
				}
				else
				{
					g_stSetupData.EPGOnOff = 1;
					_DVBApp_ShowPopup(DVB_APP_POP_MSG_EPG_ENABLE);
				}
				AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_SETUP,
					ITEM_OFFSET(APP_SETTING_Setup_t, EPGOnOff),
					sizeof(g_stSetupData.EPGOnOff), &(g_stSetupData.EPGOnOff));
				AL_Setting_Store(APP_Data_UserSetting_Handle(), SYS_SET_ID_SETUP,
					ITEM_OFFSET(APP_SETTING_Setup_t, EPGOnOff), sizeof(g_stSetupData.EPGOnOff));
			}
			break;
#endif
		#if 1//ll.jing mark for new fm
		case UI_EVENT_FAC_HOTEL:
			if (APP_MenuMgr_Exist_Factory_Menu())
			{
				_DVBApp_Exit_All_Menu();
			}
			else
			{
				if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_MAINMENU))
				{
					DVBApp_ResetPopup_Channel();
					_DVBApp_CloseAllMenu();
					SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, APP_GUIOBJ_FM_HOTELSETTING, ENTER_HOTELSET_NOTFROM_FACTORYMENU);
				}
			}
			break;
		#endif
		case UI_EVENT_FACTORY:
			if (APP_MenuMgr_Exist_Factory_Menu())
			{
				_DVBApp_Exit_All_Menu();
			}
			else
			{
#ifdef SUPPORT_HKC_FACTORY_REMOTE
				if ((SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_MAINMENU))||((dParam == UI_EVENT_HKC_FACTORYMENU)&&(g_stFactoryUserData.n_FactSet_FactoryRemote == 1)))
#else
				if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_MAINMENU))
#endif
				{
					DVBApp_ResetPopup_Channel();
					_DVBApp_CloseAllMenu();
					SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, APP_GUIOBJ_FM_FACTORYSETTING, 0);
				}
			}
			break;
#ifdef CONFIG_SUPPORT_USB_UPGRADE
		case UI_EVENT_CHECK_UPGRADE:
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_SOFTWARE_UPGRADE))
			{
				dvb_printf("upgrade is running!");
				break;
			}
			else
			{
				if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_SOURCE))
				{
					DVBApp_ResetPopup_Channel();
					_DVBApp_CloseAllMenu();
					SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, APP_GUIOBJ_SOFTWARE_UPGRADE, SOFTWARE_UPGRADE_FROM_PASSWORD);
				}
			}
			break;
#endif
		case UI_EVENT_POWER:
		#ifdef CONFIG_SUPPORT_PVR
			if (MID_RecorderIsCurRecording() == DRV_SUCCESS)
			{
				if (MID_REC_MODE_MANUAL == u8MIDRecMode)
				{
					if (!APP_GUIOBJ_DVB_PvrRec_GetDurationTime())
					{
						DVBApp_StopRecord();
					}
				}
				else
				{
					DVBApp_StopTimeshift(TRUE);
				}
			}
		#endif
			MAINAPP_SendGlobalEvent(UI_EVENT_POWER, AL_POWER_STATE_OFF);
			break;

		case UI_EVENT_EPG:
#ifdef SUPPORT_EPG_ONOFF
			if (!g_stSetupData.EPGOnOff)
			{
				break;
			}
#endif
			dGuiObj = DVB_GUIOBJ_EPG;
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_EPG)
				|| (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_EPGEXTEND)))
			{
				_DVBApp_Exit_All_Menu();
			}
			else
			{
				_DVBApp_Exit_All_Menu();
				bHasValidServ = AL_DB_HasVisibleService(eNetType);
				if (bHasValidServ)
				{
					SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, dGuiObj, 0);
				}
				else
				{
					_DVBApp_ShowPopup(DVB_APP_POP_MSG_NOT_AVAILABLE);
				}
			}
			break;
		case UI_EVENT_AUDIO:
#ifdef CONFIG_SUPPORT_PVR
			if (MID_TSPLParser_GetThreadState())
			{
				UINT32 u32PlayState = MID_TSPL_MODE_STOP;

				MID_TSPLParser_GetPlayState(&u32PlayState, NULL);
				if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_MULTIAUD))
				{
					SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PVR_MULTIAUD);
				}
				else if (u32PlayState == MID_TSPL_MODE_PLAY)
				{
					_DVBApp_HidePopupDisplay();
					if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO))
					{
						SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO);
					}
					if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_REC))
					{
						SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PVR_REC);
					}
					if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_BANNER))
					{
						SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, APP_GUIOBJ_BANNER);
					}
					dvb_printf("...Create PVR multi audio menu.\n");
					SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, DVB_GUIOBJ_PVR_MULTIAUD, 0);
				}
				break;
			}
			else
#endif
			{
				UINT8 u8ProgLockState = FALSE;

				u8ProgLockState = APP_DVB_Playback_GetProgStateByHandle(eNetType, AL_DB_INVALIDHDL);
				if (u8ProgLockState == MID_PLAYBK_PROG_STATE_LOCKED)
				{
					break;
				}
				bHasValidServ = AL_DB_HasVisibleService(eNetType);
				if (bHasValidServ)
				{
					if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_MULTIAUD))
					{
						SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_MULTIAUD);
						_DVBApp_CheckPopupDisplay();
					}
					else
					{
						_DVBApp_CloseAllMenu();
						SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, DVB_GUIOBJ_MULTIAUD, 0);
					}
				}
				else
				{
					_DVBApp_ShowPopup(DVB_APP_POP_MSG_NOT_AVAILABLE);
				}
			}
		break;

		case UI_EVENT_MUTE:
#ifdef SUPPORT_CEC_TV
			AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FEATURE, 0,
				sizeof(APP_SETTING_Feature_t), &(g_stFeatureData));
			if (( APP_SWITCH_ON == g_stFeatureData.Enable_HDMILink)
#ifdef SUPPORT_AMPLIFIER_CONTROL
				&&(APP_SWITCH_ON == g_stFeatureData.AmplifierControl)
#endif
				&&(APP_HDMILINK_AMPLIFIER == g_stFeatureData.SpeakerPreference) && APP_GUIOBJ_Source_GetAmplifierPort())
			{
				if (CECTV_GetCECEnable()==CECTV_ENABLE)
				{
					APP_Set_CECTV_Mute_Status(EVENT_CECTV_SET_MUTE_STATUS_MUTE);
					APP_GUIOBJ_Mute_MuteKeyHandler();
					break;
				}
			}
#endif
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_SLEEP_INFO))
			{
				APP_GUIOBJ_SleepTimer_Reset();
				SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, APP_GUIOBJ_SLEEP_INFO);
			}
			APP_GUIOBJ_Mute_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())
			{
				if (CECTV_GetCECEnable()==CECTV_ENABLE)
				{
					APP_Process_CECTV_Mute_Status(dParam);
					 if(g_stUserInfoData.Mute == TRUE && APP_Get_HDMICEC_AMP_Mute_Status() == FALSE)
					 {
					      APP_GUIOBJ_Mute_MuteKeyHandler();
					 }
					     else if(g_stUserInfoData.Mute == FALSE && APP_Get_HDMICEC_AMP_Mute_Status() == TRUE)
					 {
					      APP_GUIOBJ_Mute_MuteKeyHandler();
					 }
				}
			}
			break;
		case DMN_EVENT_CECTV_SET_SYSTEMAUDIO_STATUS:
			APP_Process_CECTV_Control_Status_From_Amp(dParam);
			break;

		case DMN_EVENT_CECTV_SET_DEVICE_OSDNAME:
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PROGINFO)
				||SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_SOURCE)
#ifdef SUPPORT_CEC_TV
				||SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_HDMI_LINK)
#endif
				||SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_MAINMENU)
				||SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_SOURCE_CEC))
			{
				break;
			}
			DVBApp_ResetPopup_Channel();
			_DVBApp_CloseAllMenu();
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_FREEZE))
			{
#ifdef Subtitle_Freeze
				AL_Subtitle_SetFreeze(FALSE);
#else
				DVBApp_DataApplicationSwitch(OSD2CTRLMDL_ENABLE | OSD2CTRLMDL_SUB);
#endif
				SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_FREEZE);
			}
			if (APP_GetPlaybackPauseState() == TRUE)
			{
				MID_PlaybackStreamResume(1);
				APP_SetPlaybackPauseState(FALSE);
			}
			SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB,
				APP_GUIOBJ_CEC_DEVICE_INSERT, 0);
			break;
#endif

		case UI_EVENT_EXIT:
#ifdef CONFIG_SUPPORT_PVR
#ifdef SUPPORT_PVR_ICON_HIDE
			if (u8MidRecState == MID_REC_STATUS_START && !(APP_MenuMgr_Exist_Main_Menu()))
			{
				if (MID_REC_MODE_MANUAL == u8MIDRecMode)
				{
					if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_REC))
					{
						SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PVR_REC, UI_EVENT_EXIT, 0);
					}
					break;
				}
				else
				{
					if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO))
					{
						SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO, UI_EVENT_EXIT, 0);
					}
					break;
				}
			}
#endif
#endif
		case UI_EVENT_RETURN:
#ifdef CONFIG_SUPPORT_PVR
#ifdef SUPPORT_TEAC_PVR_ICON_CTRL
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_REC)
				|| SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_PAUSE))
			{
				SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB,
					DVB_GUIOBJ_PVRREC_INFO, 0);
				break;
			}
#endif
			if ((SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_REC)) ||
				(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO)))
			{
			    if (APP_MenuMgr_Exist_Main_Menu())
			    {
			        APP_MenuMgr_Exit_Main_Menu();
			    }
				break;
			}
#endif

			AutoUpgrade = FALSE;
			_DVBApp_ExitAll();
			break;
		case UI_EVENT_CH_UP:
		case UI_EVENT_CH_DN:
			g_bIsFav = FALSE;
#ifdef CONFIG_SUPPORT_PVR
			if (u8MidRecState != MID_REC_STATUS_STOP)
			{
				g_bIsNumKey = FALSE;
				if (dMessage == UI_EVENT_CH_UP)
				{
					g_bIsCHUp = TRUE;
				}
				else
				{
					g_bIsCHUp = FALSE;
				}
				if (MID_REC_MODE_MANUAL == u8MIDRecMode)
				{
					_DVBApp_ShowPopup(DVB_APP_POP_MSG_REC_STOP_CHANNEL_CHANGE);
					break;
				}
				else
				{
					_DVBApp_ShowPopup(DVB_APP_POP_MSG_TIMESHIFT_STOP_CHANNEL_CHANGE);
					break;
				}
			}
			else
#endif
			{
				/* judge is database empty or not */
				al_uint32 TotalNum = 0;
				ServiceGroupType_t group_type;
				APP_EProgListType_t eCurProglist = ProgListType_Normal;
				AL_RecHandle_t hNetHdl = AL_DB_INVALIDHDL;
				al_int8 s8Navigate = 0;

				AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_TVINFO, 0,
					sizeof(APP_SETTING_TVInfo_t), &(g_stTVInfoData));
				AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_VARIATIONAL, 0,
								sizeof(APP_SETTING_Variational_t), &(g_stVariationalData));
				group_type = g_stTVInfoData.ChnListType;

				if (SERVICEGROUP_USER == group_type)
				{
					eCurProglist = ProgListType_User;
				}

				APP_Database_InitChnList(APP_Database_ConvertGroup2ChnListType(group_type), hNetHdl, eCurProglist);
				TotalNum = APP_Database_GetChnListSize();
				APP_Database_UninitChnList();

				if (TotalNum == 0)
				{
					/* show not available */
					_DVBApp_ShowPopup(DVB_APP_POP_MSG_NOT_AVAILABLE);
					break;
				}
				if (dMessage == UI_EVENT_CH_UP)
                {
					s8Navigate = 1;
                }
                else if (dMessage == UI_EVENT_CH_DN)
                {
					s8Navigate = -1;
				}
				{
					hProg = APP_DVB_PLAYBACK_GetNextProgHdl(eNetType, s8Navigate, APP_FAVORITE_NONE);
				}

				if (hProg != AL_DB_INVALIDHDL)
				{
					AL_DB_EDBType_t db_type;
					AL_DB_ERecordType_t record_type;
					AL_DB_GetRecordType(hProg, &db_type, &record_type);
					if (db_type == AL_DBTYPE_DVB_ATV)
					{

                        APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_ATV);
						break;
					}
					if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_ADJUST))
					{
						SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, APP_GUIOBJ_ADJUST);
					}
#ifdef SUPPORT_CEC_TV
					if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_AMPLIFIERVOLUME))
					{
						SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, APP_GUIOBJ_AMPLIFIERVOLUME);
					}
#endif
/*#ifdef CONFIG_SUPPORT_PVR
					if ((MID_REC_MODE_AUTO == u8MIDRecMode) && (u8MidRecState != MID_REC_STATUS_STOP))
					{
						DVBApp_StopTimeshift(FALSE);
					}
#endif*/
        #ifdef SUPPORT_CHANGE_TS_DYNAMICALLY
					AL_RecHandle_t hCurTPHdl = hCurProg;
					AL_RecHandle_t hNextTPHdl = hProg;
					AL_DB_GetRecord(AL_DB_REQ_GETPARENT, eNetType, AL_RECTYPE_DVBMULTIPLEX, &hCurTPHdl);
					AL_DB_GetRecord(AL_DB_REQ_GETPARENT, eNetType, AL_RECTYPE_DVBMULTIPLEX, &hNextTPHdl);
					if(APP_Get_DTVHiddenScanState()&&(hCurTPHdl!=hNextTPHdl))
					{
						APP_ScanProcess_Stop();
						APP_SetSrcChgFlag(TRUE);
						while(APP_Get_DTVHiddenScanState()||(!AL_CS_IsStop()))
						{
							GL_TaskSleep(50);
						}
						APP_SetSrcChgFlag(FALSE);
					}
#endif
					_DVBApp_Zapping(record_type, hProg, FALSE, 0, TRUE);
/*#ifdef CONFIG_SUPPORT_PVR
					if ((MID_REC_MODE_AUTO == u8MIDRecMode) && (u8MidRecState != MID_REC_STATUS_STOP))
					{
						DVBApp_StopTimeshift(TRUE);
					}

					DVBApp_SetBGTimeshift(PVR_BGTIMESHIFT_START_INTERVAL);
#endif*/
				}
				else
				{
					DVBApp_CheckProgramType(TRUE);
				}
				break;
			}

		case UI_EVENT_RECALL:
			{
				//_DVBApp_CloseAllMenu();
				UINT32 u32TotalChnCount = 0;
				DBServAttrib_t stAttribute;

				eServiceType = APP_DVB_Playback_GetCurrServiceType(eNetType);
				if ((eServiceType != AL_RECTYPE_DVBTV) && (eServiceType  != AL_RECTYPE_DVBRADIO) && (eServiceType != AL_RECTYPE_DVBDATA))
				{
					eServiceType = AL_RECTYPE_DVBTV;
				}
				AL_DB_GetRecordsTotalNum(eNetType, eServiceType, &u32TotalChnCount);
				if(!u32TotalChnCount)
				{
					AL_DB_GetRecordsTotalNum(eNetType, AL_RECTYPE_DVBDATA, &u32TotalChnCount);
					if(!u32TotalChnCount)
					{
						AL_DB_GetRecordsTotalNum(eNetType, AL_RECTYPE_DVBRADIO, &u32TotalChnCount);
					}
				}
				hProg = APP_DVB_Playback_GetPrevProg(eNetType);
				if (hProg != AL_DB_INVALIDHDL)
				{
					memset(&stAttribute, 0, sizeof(DBServAttrib_t));
					AL_DB_QueryDetailFieldByName(hProg, (al_uint8 *)"stProgAttrib", (al_void *)&stAttribute);
				}

				if ((hCurProg!=hProg)&&(hProg != AL_DB_INVALIDHDL)&& u32TotalChnCount && (stAttribute.delete == FALSE))
				{
#ifdef CONFIG_SUPPORT_PVR
					if (u8MidRecState != MID_REC_STATUS_STOP)
					{
						if (MID_REC_MODE_MANUAL == u8MIDRecMode)
						{
							_DVBApp_ShowPopup(DVB_APP_POP_MSG_REC_STOP_FOR_RECALL);
							break;
						}
						else
						{
							_DVBApp_ShowPopup(DVB_APP_POP_MSG_TIMESHIFT_STOP_FOR_RECALL);
							break;
						}
					}
#endif
					AL_DB_GetRecordType(hProg, NULL, &NextServiceType);
					if (eServiceType == NextServiceType)
					{
#ifdef SUPPORT_CHANGE_TS_DYNAMICALLY
						AL_RecHandle_t hCurTPHdl = hCurProg;
						AL_RecHandle_t hNextTPHdl = hProg;
						AL_DB_GetRecord(AL_DB_REQ_GETPARENT, eNetType, AL_RECTYPE_DVBMULTIPLEX, &hCurTPHdl);
						AL_DB_GetRecord(AL_DB_REQ_GETPARENT, eNetType, AL_RECTYPE_DVBMULTIPLEX, &hNextTPHdl);
						if(APP_Get_DTVHiddenScanState()&&(hCurTPHdl!=hNextTPHdl))
						{
							APP_ScanProcess_Stop();
							APP_SetSrcChgFlag(TRUE);
							while(APP_Get_DTVHiddenScanState()||(!AL_CS_IsStop()))
							{
								GL_TaskSleep(50);
							}
							APP_SetSrcChgFlag(FALSE);
						}
#endif
						_DVBApp_Zapping(NextServiceType, hProg, FALSE, 0, TRUE);
					}
#ifdef CHANGE_SOURCE_BY_RECALL_KEY
					else if (APP_DVB_Playback_SwapServiceType(eNetType, &NextServiceType, &u32TotalNum) == AL_SUCCESS)
					{
						;
					}
#endif
					else
					{
						_DVBApp_ShowPopup(DVB_APP_POP_MSG_NOT_AVAILABLE);
					}
				}
				else
				{
					_DVBApp_ShowPopup(DVB_APP_POP_MSG_NOT_AVAILABLE);
				}
			}
			break;

		case APP_DVB_GLOBAL_EVENT_ZAPPING:
#ifdef CONFIG_SUPPORT_PVR
			if (u8MidRecState != MID_REC_STATUS_STOP)
			{
				if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PROGNUM))
				{
					SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PROGNUM);
					if (hCurProg == dParam)
					{
						break;
					}
					else if(AL_DB_INVALIDHDL == dParam)
					{

#ifdef SPECIAL_CHNORDER_FOR_SPAIN
						SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_DVB, UI_EVENT_DISPLAY, 0);
#else
						_DVBApp_ShowPopup(DVB_APP_POP_MSG_INVALID_INPUT);
#endif
						break;
					}
					else
					{
						g_ProgHandle = dParam;
						g_bIsNumKey = TRUE;
						if (MID_REC_MODE_MANUAL == u8MIDRecMode)
						{
							_DVBApp_ShowPopup(DVB_APP_POP_MSG_REC_STOP_CHANNEL_CHANGE);
							break;
						}
						else
						{
							_DVBApp_ShowPopup(DVB_APP_POP_MSG_TIMESHIFT_STOP_CHANNEL_CHANGE);
							break;
						}
					}
				}
			}
#endif
#if 0
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_FREEZE))
			{
				SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_FREEZE);
			}
#endif
			_DVBApp_Zapping(eServiceType, dParam, FALSE, 0, TRUE);
			break;

#ifdef SUPPORT_CHANGE_TS_DYNAMICALLY
		case APP_DVB_GLOBAL_EVENT_TSCHANGE_REMOVE_SERVICE:
			dvb_printf("[%s:%d] APP_DVB_GLOBAL_EVENT_TSCHANGE_REMOVE_SERVICE !!!!!!!!!!\n\n",__FUNCTION__,__LINE__);
			if(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_CHNLIST)
				//||(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_CHNMGR)
				//|| SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_FAVMGR)
				|| SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_FAVLIST)
				|| SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_EPG)
				|| SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_CHNRENAME)
#ifdef CONFIG_SUPPORT_PVR
				//|| SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_TIMEREDIT)
#endif
				)
			{
			   if(DVBApp_GetUnstableState() == FALSE)
			   {
				   DVBApp_SetUnstableState(TRUE);
			   }
				dvb_printf(" Post Process The Unstable Services\n\n");
				break;
			}
			if(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_CHNMGR))
			{
				SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_CHNMGR);
			}
			else if(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_FAVMGR))
			{
				SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_FAVMGR);
			}
		#ifdef CONFIG_SUPPORT_PVR
			else if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_TIMEREDIT))
			{
				SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_TIMEREDIT);
			}
		#endif

			DVBApp_RemoveUnstableService();
			break;
#endif


		case UI_EVENT_ENTER:
#ifdef CONFIG_SUPPORT_PVR
#ifdef SUPPORT_PVR_ICON_HIDE
			if (u8MidRecState == MID_REC_STATUS_START)
			{
				if (MID_REC_MODE_MANUAL == u8MIDRecMode)
				{
					if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_REC))
					{
						SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PVR_REC, UI_EVENT_ENTER, 0);
					}
					break;
				}
				else
				{
					if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO))
					{
						SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO, UI_EVENT_ENTER, 0);
					}
					break;
				}
			}
#endif
#endif
#ifdef CELLO_REMOTE_KEY
		SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_DVB,
			UI_EVENT_CHLIST, 0);
		{
			bHasValidServ = AL_DB_HasVisibleService(eNetType);

			if (!bHasValidServ)
			{
				_DVBApp_ShowPopup(DVB_APP_POP_MSG_NOT_AVAILABLE);
				break;
			}
		}
#endif
		break;

#ifdef CELLO_REMOTE_KEY
		case UI_EVENT_INITIAL:
			DVBApp_ResetPopup_Channel();
			_DVBApp_CloseAllMenu();
			SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, APP_GUIOBJ_INITINSTALL, 0);
			break;
		case UI_EVENT_DTV:
			DVBApp_ResetPopup_Channel();
			_DVBApp_CloseAllMenu();
			APP_GUIOBJ_Channel_SetRFType(FRONTEND_CONNECT_TYPE_DVB_T, AL_DB_INVALIDHDL);
			APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_DTV);
			break;
		case UI_EVENT_SATELLITE:
			DVBApp_ResetPopup_Channel();
			_DVBApp_CloseAllMenu();
			APP_GUIOBJ_Channel_SetRFType(FRONTEND_CONNECT_TYPE_DVB_S, AL_DB_INVALIDHDL);
			APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_DTV);
			break;
		case UI_EVENT_CABLE:
			DVBApp_ResetPopup_Channel();
			_DVBApp_CloseAllMenu();
			APP_GUIOBJ_Channel_SetRFType(FRONTEND_CONNECT_TYPE_DVB_C, AL_DB_INVALIDHDL);
			APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_DTV);
			break;

		case UI_EVENT_DVD:
			if(eSourType != APP_SOURCE_DVD)
			{
#ifdef CONFIG_SUPPORT_PVR
				if (MID_REC_STATUS_STOP != u8MidRecState)// && (MID_REC_MODE_AUTO != u8MIDRecMode))
				{
					if (MID_REC_MODE_MANUAL == u8MIDRecMode)
					{
						_DVBApp_ShowPopup(DVB_APP_POP_MSG_REC_STOP_FOR_TVRADIOKEY);
					}
					else
					{
						_DVBApp_ShowPopup(DVB_APP_POP_MSG_TIMESHIFT_STOP_FOR_TVRADIOKEY);
					}
					break;
				}
#endif
				DVBApp_ResetPopup_Channel();
				_DVBApp_CloseAllMenu();
				APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_DVD);
			}
			break;

		case UI_EVENT_HDMI:
			if(eSourType != APP_SOURCE_HDMI && eSourType != APP_SOURCE_HDMI1 &&
				eSourType != APP_SOURCE_HDMI2)
			{
#ifdef CONFIG_SUPPORT_PVR
				if (MID_REC_STATUS_STOP != u8MidRecState)// && (MID_REC_MODE_AUTO != u8MIDRecMode))
				{
					if (MID_REC_MODE_MANUAL == u8MIDRecMode)
					{
						_DVBApp_ShowPopup(DVB_APP_POP_MSG_REC_STOP_FOR_TVRADIOKEY);
					}
					else
					{
						_DVBApp_ShowPopup(DVB_APP_POP_MSG_TIMESHIFT_STOP_FOR_TVRADIOKEY);
					}
					break;
				}
#endif
				DVBApp_ResetPopup_Channel();
				_DVBApp_CloseAllMenu();
				APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_HDMI);
			}
			break;
#endif

		case UI_EVENT_CHLIST:
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_MULTIAUD))
			{
				_DVBApp_CloseAllMenu();
			}
			else
			{
				if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_CHNLIST))
				{
					SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_CHNLIST);
					_DVBApp_CheckPopupDisplay();
				}
				else
				{
					_DVBApp_CloseAllMenu();
					SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, DVB_GUIOBJ_CHNLIST, 0);
				}
			}
			break;

		case UI_EVENT_FAV:
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_MULTIAUD))
			{
				_DVBApp_CloseAllMenu();
			}
			else
			{
				if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_CHNLIST))
				{
					SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_CHNLIST);
					_DVBApp_CheckPopupDisplay();
				}
				else
				{
					_DVBApp_CloseAllMenu();
                    SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, DVB_GUIOBJ_CHNLIST, SBTVD_CHNLIST_TYPE_FAVLIST);
				}
			}
			break;

		case UI_EVENT_FAV_UP:
		case UI_EVENT_FAV_DN:
		{
			UINT32 TotalNum = 0;
			AL_DB_EDBType_t DBType;
			AL_DB_ERecordType_t CurSerType = AL_RECTYPE_DVBTV;
			APP_Favorite_t FavType = APP_FAVORITE_1;

			g_bIsFav = TRUE;
			DBType = APP_DVB_Playback_GetCurrentNetType();
			CurSerType = APP_DVB_Playback_GetCurrServiceType(DBType);

			FavType = APP_GUIOBJ_DVB_Playback_GetFavType();
			if ((FavType <= APP_FAVORITE_NONE) || (FavType >= APP_FAVORITE_MAX))
			{
				FavType = APP_FAVORITE_1;
				APP_GUIOBJ_DVB_Playback_SetFavType(FavType);
				APP_GUIOBJ_DVB_Playback_StoreFavType();
			}

			do
			{
				/* search next fav list type */
				APP_Database_InitChnList(APP_DB_CHNLISTTYPE_DIGITAL, AL_DB_INVALIDHDL, APP_Database_ConvertFavType2List(FavType));
				TotalNum = APP_Database_GetChnListSize();
				APP_Database_UninitChnList();
				if (((FavType == APP_GUIOBJ_DVB_Playback_GetFavType()) && (TotalNum > 0)) ||
					(TotalNum > 1))
				{
					break;
				}

				FavType++;

				if (FavType == APP_FAVORITE_MAX)
				{
					FavType = APP_FAVORITE_1;
				}

			}while(FavType != APP_GUIOBJ_DVB_Playback_GetFavType());

			if (FavType == APP_FAVORITE_MAX)
			{
				APP_GUIOBJ_DVB_Playback_SetFavType(APP_FAVORITE_1);
				APP_GUIOBJ_DVB_Playback_StoreFavType();
				_DVBApp_ShowPopup(DVB_APP_POP_MSG_NOT_AVAILABLE);
				break;
			}

			APP_GUIOBJ_DVB_Playback_SetFavType(FavType);
			APP_GUIOBJ_DVB_Playback_StoreFavType();

			if (TotalNum < 2)
			{
				_DVBApp_ShowPopup(DVB_APP_POP_MSG_NOT_AVAILABLE);
				break;
			}

#ifdef CONFIG_SUPPORT_PVR
			if ((u8MidRecState != MID_REC_STATUS_STOP) && (APP_PVR_TIMESHIFT_AUTO != u8AutoTimeShift))
			{
				g_bIsNumKey = FALSE;
				if (MID_REC_MODE_TIMESHIFT_AFTER_REC == u8MIDRecMode)
				{
					if (dMessage == UI_EVENT_FAV_UP)
					{
						g_bIsCHUp = TRUE;
					}
					else
					{
						g_bIsCHUp = FALSE;
					}
					_DVBApp_ShowPopup(DVB_APP_POP_MSG_TIMESHIFT_STOP_CHANNEL_CHANGE);
					break;
				}
				else if (MID_REC_MODE_MANUAL == u8MIDRecMode)
				{
					if (dMessage == UI_EVENT_FAV_UP)
					{
						g_bIsCHUp = TRUE;
					}
					else
					{
						g_bIsCHUp = FALSE;
					}
					_DVBApp_ShowPopup(DVB_APP_POP_MSG_REC_STOP_CHANNEL_CHANGE);
					break;
				}
			}
			else
#endif
			{
				if (dMessage == UI_EVENT_FAV_UP)
				{
					hProg = APP_DVB_PLAYBACK_GetNextProgHdl(DBType, 1, FavType);
				}
				else
				{
					hProg = APP_DVB_PLAYBACK_GetNextProgHdl(DBType, -1, FavType);
				}
				if (hProg != AL_DB_INVALIDHDL)
				{
					AL_DB_EDBType_t db_type;
					AL_DB_ERecordType_t record_type;
					AL_DB_GetRecordType(hProg, &db_type, &record_type);
					if (db_type == AL_DBTYPE_DVB_ATV)
					{
						_DVBApp_CloseAllMenu();
						break;
					}
					if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_ADJUST))
					{
						SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, APP_GUIOBJ_ADJUST);
					}
#ifdef SUPPORT_CEC_TV
					if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_AMPLIFIERVOLUME))
					{
						SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, APP_GUIOBJ_AMPLIFIERVOLUME);
					}
#endif
/*#ifdef CONFIG_SUPPORT_PVR
					if ((APP_PVR_TIMESHIFT_AUTO == u8AutoTimeShift) && (u8MidRecState != MID_REC_STATUS_STOP))
					{
						DVBApp_StopTimeshift(TRUE);
					}
#endif*/
					_DVBApp_Zapping(CurSerType, hProg, FALSE, 0, TRUE);
/*#ifdef CONFIG_SUPPORT_PVR
					DVBApp_SetBGTimeshift(PVR_BGTIMESHIFT_START_INTERVAL);
#endif*/
				}
				else
				{
					DVBApp_CheckProgramType(TRUE);
				}
				break;
			}
		}
		break;

		case UI_EVENT_DISPLAY:
		{
				bHasValidServ = AL_DB_HasVisibleService(eNetType);
#ifdef CONFIG_SUPPORT_PVR
				if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVRREC_INFO))
				{
					dvb_printf(" rec info is exist \n");
					SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PVRREC_INFO);
				}
				else
#endif
				{
					if (bHasValidServ)
					{
#ifdef SUPPORT_HOTEL_MODE_INFOBANNER_SHOW_CONTROL
						if((g_stFactoryHotelData.HotelModeOnOff)&&(!g_stFactoryHotelData.ShowInfoBar))
							break;
#endif
#ifdef PLAY_VIDEO_FOR_ALLSRV
						AL_RecHandle_t hTempHdl;
						MID_PlaybackGetCurProgHandle(al_null, &hTempHdl);
						DBPIDInfo_t 	stVideoPid;
						memset(&stVideoPid,0xff,sizeof(DBPIDInfo_t));
					
						AL_DB_QueryDetailFieldByName(hTempHdl, (al_uint8 *)"stVideoPid", (al_void *)&stVideoPid);
#endif	
						if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PROGINFO))
						{
							SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PROGINFO);
#ifdef PLAY_VIDEO_FOR_ALLSRV
							if (DVBApp_CheckHasVideo() == FALSE)
#else
							if (eServiceType == AL_RECTYPE_DVBRADIO)
#endif
							{
								if (!APP_GUIOBJ_DVB_Playback_GetShowLogoState())
								{
									SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PLAYBACK, APP_DVB_INTRA_EVENT_SHOWLOGO, 0);
								}
							}
							if (APP_DVB_Playback_GetProgStateByHandle(APP_DVB_Playback_GetCurrentNetType(), AL_DB_INVALIDHDL)
								== MID_PLAYBK_PROG_STATE_LOCKED)
							{
								if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_ADJUST))
								{
									SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, APP_GUIOBJ_ADJUST);
								}
#ifdef SUPPORT_CEC_TV
								if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_AMPLIFIERVOLUME))
								{
									SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, APP_GUIOBJ_AMPLIFIERVOLUME);
								}
#endif
								SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, DVB_GUIOBJ_PROGINFO, 0);
								_DVBApp_ShowPopup(DVB_APP_POP_MSG_CHECKPWD);
							}
							else if (APP_DVB_Playback_GetProgStateByHandle(APP_DVB_Playback_GetCurrentNetType(), AL_DB_INVALIDHDL)
									 == MID_PLAYBK_PROG_STATE_AUDIO_VIDEO_SCRAMBLED \
									 ||APP_DVB_Playback_GetProgStateByHandle(APP_DVB_Playback_GetCurrentNetType(), AL_DB_INVALIDHDL)
									 == MID_PLAYBK_PROG_STATE_ONLY_VIDEO_SCRAMBLED \
									 ||(APP_DVB_Playback_GetProgStateByHandle(APP_DVB_Playback_GetCurrentNetType(), AL_DB_INVALIDHDL)
									 == MID_PLAYBK_PROG_STATE_ONLY_AUDIO_SCRAMBLED  
#ifdef PLAY_VIDEO_FOR_ALLSRV
									&&((stVideoPid.usDataPID&0x1fff) == 0x1fff)
#else
									&& (eServiceType == AL_RECTYPE_DVBRADIO)
#endif
									 ))
							{
								if (DVBApp_IsPopupExist(PLAYBACK_POPUP_MSG_NO_SIGNAL))
								{
									DVBApp_ClosePopup(PLAYBACK_POPUP_MSG_NO_SIGNAL, UI_EVENT_NULL);
								}

								if (DVBApp_IsPopupExist(PLAYBACK_POPUP_MSG_RADIO_CHANNEL))
								{
									DVBApp_ClosePopup(PLAYBACK_POPUP_MSG_RADIO_CHANNEL, UI_EVENT_NULL);
								}
								printf("\n#####Pop Scramble MSG Menu,F=%s,L=%d ######\n",__FUNCTION__,__LINE__);
								_DVBApp_ShowPopup(DVB_APP_POP_MSG_SCRAMBLE);
							}
							else if ((eServiceType == AL_RECTYPE_DVBRADIO)
								&&(!DVBApp_IsPopupExist(PLAYBACK_POPUP_MSG_RADIO_CHANNEL))
#ifdef PLAY_VIDEO_FOR_ALLSRV
								&&((stVideoPid.usDataPID&0x1fff) == 0x1fff)
#endif
							)
							{
								{
									if(g_bScrambleFlag != PROG_STATUS_SCRAMBLE_UNKNOW)
									{
										_DVBApp_ShowPopup(DVB_APP_POP_MSG_RADIO_CHANNEL);
									}
								}
							}
						}
						else
						{
							dvb_printf("[%s %d]\n", __FUNCTION__, __LINE__);
							_DVBApp_CloseAllMenu();
							if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_ADJUST))
							{
								SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, APP_GUIOBJ_ADJUST);
							}
#ifdef SUPPORT_CEC_TV
							if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_AMPLIFIERVOLUME))
							{
								SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, APP_GUIOBJ_AMPLIFIERVOLUME);
							}
#endif
							SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, DVB_GUIOBJ_PROGINFO, 0);
							if (APP_DVB_Playback_GetProgStateByHandle(APP_DVB_Playback_GetCurrentNetType(), AL_DB_INVALIDHDL)
								== MID_PLAYBK_PROG_STATE_LOCKED)
							{
								_DVBApp_ShowPopup(DVB_APP_POP_MSG_CHECKPWD);
							}
						}
					}
					else
					{
						_DVBApp_ShowPopup(DVB_APP_POP_MSG_NOT_AVAILABLE);
					}
				}
		}
		break;
		case UI_EVENT_TEXT:
		{
			if (DVBApp_IsPopupExist(PLAYBACK_POPUP_MSG_DATABASE_EMPTY) || DVBApp_IsPopupExist(PLAYBACK_POPUP_MSG_SERVICE_NOT_AVAILABLE))
			{
				 _DVBApp_ShowPopup(DVB_APP_POP_MSG_NOT_AVAILABLE);
				 break;
			}
            if(eSourType == APP_SOURCE_DTV)
			{
				_DVBApp_CloseAllMenu();
#ifdef CONFIG_SUPPORT_ISDB_SUBTITLE
				SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, DVB_GUIOBJ_CC_BANNER, 0);
#endif
			}
			else
			{
				_DVBApp_ShowPopup(DVB_APP_POP_MSG_NOT_AVAILABLE);
			}
		}
		break;

#ifdef SUPPORT_CLOCKINFO_SHOW
		case UI_EVENT_DEVLIST:	//UI_EVENT_DEVLIST	clock key
			{
				/*if digital programs are locked,  pressing clock key  is not  Available*/
				MID_PlaybackProgState_t GetProgState;
				GetProgState = APP_DVB_Playback_GetProgStateByHandle(APP_DVB_Playback_GetCurrentNetType(), AL_DB_INVALIDHDL);
				if ((GetProgState == MID_PLAYBK_PROG_STATE_LOCKED) \
				|| (GetProgState == MID_PLAYBK_PROG_STATE_ONLY_VIDEO_SCRAMBLED) \
				||(GetProgState == MID_PLAYBK_PROG_STATE_AUDIO_VIDEO_SCRAMBLED) \
				|| (GetProgState == MID_PLAYBK_PROG_STATE_ONLY_AUDIO_SCRAMBLED))
				{
					break;
				}
				if (DVBApp_IsPopupExist(PLAYBACK_POPUP_MSG_DATABASE_EMPTY))
				{
					 _DVBApp_ShowPopup(DVB_APP_POP_MSG_NOT_AVAILABLE);
					 break;
				}
			   if (eSourType == APP_SOURCE_DTV)
				{
					#if 0
					if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_TTXCLOCK))
					{
						//dvb_printf("close clock menu!\n");
						SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_TTXCLOCK);

					}
					else
					{
						al_bool bTtSignalStatus = 0;
						AL_TTX_GetSignalStatus(&bTtSignalStatus);
						if ((bTtSignalStatus == TRUE) && (_DTVAPP_Check_TTClock_HasValidData() == SP_SUCCESS))
						{
							//dvb_printf("open clock menu!\n");
							_DVBApp_CloseAllMenu();
							SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, DVB_GUIOBJ_TTXCLOCK, 0);

						}
						else
						{
							//dvb_printf("no  clock!\n");
							 _DVBApp_ShowPopup(DVB_APP_POP_MSG_NOT_AVAILABLE);
						}
					}
					#endif
				}
				else
				{
					 _DVBApp_ShowPopup(DVB_APP_POP_MSG_NOT_AVAILABLE);
				}
			}
			break;
#endif
		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))
			{
				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);
					}

					DVBApp_VolumeKeyHandler(dMessage,TRUE);
					break;
				}
			}
#endif
			DVBApp_VolumeKeyHandler(dMessage,FALSE);
			break;

		case UI_EVENT_ASPECT:
#ifdef CONFIG_SUPPORT_PVR
			/*if (MID_TSPLParser_GetThreadState() == TRUE)
			{
				UINT32 u32PEState = MID_TSPL_MODE_PLAY;
				MID_TSPLParser_GetPlayState(&u32PEState, NULL);
				if (u32PEState == MID_TSPL_MODE_PAUSE)
				{
					break;
				}
			}*/
			if (APP_GUIOBJ_DVB_PvrPlayInfo_GetRecState() == PVR_STATE_PAUSE)
	        {
				break;
	        }
#endif

			if ((APP_DVB_Playback_GetProgStateByHandle(eNetType, AL_DB_INVALIDHDL) == MID_PLAYBK_PROG_STATE_LOCKED)
#ifdef CONFIG_SUPPORT_PVR	//if playing pvr file, allow to set pic mode
				&& (!MID_TSPLParser_GetThreadState())
#endif
				)
			{
				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.PictureLock == 1)
			{

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

			MID_DISP_DTVGetVideoMute(&eMuteSt);
			if ((eMuteSt == MID_DISP_MUTE) || (eMuteSt == MID_DISP_MUTE_BY_APP) || (eMuteSt == MID_DISP_MUTE_BY_TVFE) ||(eMuteSt == MID_DISP_MUTE_BY_VIP))
			{
				break;
			}

			{
				bHasValidServ = AL_DB_HasVisibleService(eNetType);

				AL_DVB_Monitor_GetState(AL_DVB_MONITOR_STATE_SIGNAL, &bSignalState);
				if ((bHasValidServ && (bSignalState == AL_DVB_MONITOR_VALUE_TRUE)
#ifndef PLAY_VIDEO_FOR_ALLSRV
					&& (eServiceType != AL_RECTYPE_DVBRADIO)
#endif		
					)
#ifdef CONFIG_SUPPORT_PVR	//if playing pvr file, allow to set pic mode
					|| (MID_TSPLParser_GetThreadState())
#endif
				   )
				{
#ifdef CONFIG_SUPPORT_PVR
					if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_FILEPLAY))
#endif
					{
						_DVBApp_CloseAllMenu();
					}
					SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, APP_GUIOBJ_BANNER, dMessage);
				}
				else
				{
					_DVBApp_ShowPopup(DVB_APP_POP_MSG_NOT_AVAILABLE);
					break;
				}
			}
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_FREEZE))
			{
				SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_FREEZE);
			}

			if (APP_GetPlaybackPauseState() == TRUE)
			{
				MID_PlaybackStreamResume(1);
				g_PauseState = FALSE;
			}
			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_DVB,APP_GUIOBJ_BANNER))
					{
						SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, APP_GUIOBJ_BANNER, dMessage);
					}
				}
			}
			break;
#endif
#ifdef CELLO_REMOTE_KEY
		case UI_EVENT_PIC_ASPECT:
#endif
		case UI_EVENT_PIC_MOD:
			if ((APP_DVB_Playback_GetProgStateByHandle(eNetType, AL_DB_INVALIDHDL) == MID_PLAYBK_PROG_STATE_LOCKED)
				#ifdef CONFIG_SUPPORT_PVR
				&&(!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_FILEPLAY))
				#endif
				)
			{
				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.PictureLock == 1)
			{

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

		#if 0
			TVFE_GetAPPMuteFlag(&bAPPMuteEn);
			TVFE_GetTvfeMuteFlag(&bTvfeMuteEn);
			if ((bAPPMuteEn == DTV_TRUE) || (bTvfeMuteEn == DTV_TRUE))
			{
			#ifdef CONFIG_SUPPORT_MHEG5
				al_uint8 bSignalState = al_false;
				AL_DVB_Monitor_GetState(AL_DVB_MONITOR_STATE_SIGNAL, &bSignalState);
				if((bSignalState != AL_DVB_MONITOR_VALUE_TRUE)
					||(!((APP_DVB_Mheg5_GetBootCarouselStatus() == MHEG5_BOOT_CAROUSEL_EXISTED)
					&& APP_Area_SupportDtg())))
				{
					break;
				}
			#else
				break;
			#endif
			}

			if ((eServiceType == AL_RECTYPE_DVBRADIO)
#ifdef CONFIG_SUPPORT_PVR	//if playing pvr file, allow to set pic mode
				&& !SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_FILEPLAY)
#endif
			   )
			{
				break;			 //zhongbaoxing added for mantis bug 0136063 @20110525
			}

			TotalNum = DVBApp_Get_TotalNumber();

			AL_DVB_Monitor_GetState(AL_DVB_MONITOR_STATE_SIGNAL, &bSignalState);
			if (((TotalNum > 0) && (bSignalState == AL_DVB_MONITOR_VALUE_TRUE))
#ifdef CONFIG_SUPPORT_PVR	//if playing pvr file, allow to set pic mode
				|| SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_FILEPLAY)
#endif
			   )
#endif
			{
#ifdef CONFIG_SUPPORT_PVR
				if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_FILEPLAY))
#endif
				{
					_DVBApp_CloseAllMenu();
				}
				SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, APP_GUIOBJ_BANNER, dMessage);
			}
			break;
		case UI_EVENT_SLEEP:
			if ((APP_DVB_Playback_GetProgStateByHandle(eNetType, AL_DB_INVALIDHDL) == MID_PLAYBK_PROG_STATE_LOCKED)
				#ifdef CONFIG_SUPPORT_PVR
				&&(!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_FILEPLAY))
				#endif
				)
			{
				break;
			}
		#if 0
			TVFE_GetAPPMuteFlag(&bAPPMuteEn);
			TVFE_GetTvfeMuteFlag(&bTvfeMuteEn);
			if ((bAPPMuteEn == DTV_TRUE) || (bTvfeMuteEn == DTV_TRUE))
			{
			#ifdef CONFIG_SUPPORT_MHEG5
				al_uint8 bSignalState = al_false;
				AL_DVB_Monitor_GetState(AL_DVB_MONITOR_STATE_SIGNAL, &bSignalState);
				if((bSignalState != AL_DVB_MONITOR_VALUE_TRUE)
					||(!((APP_DVB_Mheg5_GetBootCarouselStatus() == MHEG5_BOOT_CAROUSEL_EXISTED)
					&& APP_Area_SupportDtg())))
				{
					break;
				}
			#else
				break;
			#endif
			}
		#endif
			{
#ifdef CONFIG_SUPPORT_PVR
				if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_FILEPLAY))
#endif
				{
					_DVBApp_CloseAllMenu();
				}
				SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, APP_GUIOBJ_BANNER, dMessage);
			}
			break;
		case UI_EVENT_SND_MOD:
#ifdef CELLO_REMOTE_KEY
		case UI_EVENT_SOUND_MTS:
#endif
			_APP_GUIOBJ_Sound_SetMuteStatus();
			if ((APP_DVB_Playback_GetProgStateByHandle(eNetType, AL_DB_INVALIDHDL) == MID_PLAYBK_PROG_STATE_LOCKED)
				#ifdef CONFIG_SUPPORT_PVR
				&&(!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_FILEPLAY))
				#endif
				)
			{
				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)
			{
				dvb_printf("[%s] Sound Option has been Lock On!!\n",__FUNCTION__);
				break;
			}

		#if 0
			TVFE_GetAPPMuteFlag(&bAPPMuteEn);
			TVFE_GetTvfeMuteFlag(&bTvfeMuteEn);
			if ((bAPPMuteEn == DTV_TRUE) || (bTvfeMuteEn == DTV_TRUE))
			{
			#ifdef CONFIG_SUPPORT_MHEG5
				al_uint8 bSignalState = al_false;
				AL_DVB_Monitor_GetState(AL_DVB_MONITOR_STATE_SIGNAL, &bSignalState);
				if((bSignalState != AL_DVB_MONITOR_VALUE_TRUE)
					||(!((APP_DVB_Mheg5_GetBootCarouselStatus() == MHEG5_BOOT_CAROUSEL_EXISTED)
					&& APP_Area_SupportDtg())))
				{
					break;
				}
			#else
				break;
			#endif
			}

			TotalNum = DVBApp_Get_TotalNumber();

			AL_DVB_Monitor_GetState(AL_DVB_MONITOR_STATE_SIGNAL, &bSignalState);
			if (((TotalNum > 0) && (bSignalState == AL_DVB_MONITOR_VALUE_TRUE))
#ifdef CONFIG_SUPPORT_PVR	//if playing pvr file, allow to set pic mode
				|| SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_FILEPLAY)
#endif
			   )
        #endif
			{
#ifdef CONFIG_SUPPORT_PVR
				if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_FILEPLAY))
#endif
				{
					_DVBApp_CloseAllMenu();
				}
				SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, APP_GUIOBJ_BANNER, dMessage);
			}
			break;
		case UI_EVENT_8:
		case UI_EVENT_0:
		case UI_EVENT_1:
		case UI_EVENT_2:
		case UI_EVENT_3:
		case UI_EVENT_4:
		case UI_EVENT_5:
		case UI_EVENT_6:
		case UI_EVENT_7:
		case UI_EVENT_9:
		case UI_EVENT_10:
#ifdef SUPPORT_FACTORY_AUTO_TEST
			if(dMessage == UI_EVENT_10)
			{
				if(APP_Factory_GetAutoTestOnOff() == TRUE)
				{
					APP_Factory_SetAutoTestSourceChange(dMessage);
					break;
				}
			}
#endif
#if 0 //def CONFIG_SUPPORT_PVR
			if ((u8MidRecState != MID_REC_STATUS_STOP) && (MID_REC_MODE_AUTO != u8MIDRecMode))
			{
				if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_BANNER))
				{
					SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, APP_GUIOBJ_BANNER);
				}
				if (MID_REC_MODE_TIMESHIFT_AFTER_REC == u8MIDRecMode)
				{
					g_u32NumEvent = dMessage;
					g_bIsNumKey = TRUE;
					_DVBApp_ShowPopup(DVB_APP_POP_MSG_TIMESHIFT_STOP_CHANNEL_CHANGE);
					break;
				}
				else if (MID_REC_MODE_MANUAL == u8MIDRecMode)
				{
					g_u32NumEvent = dMessage;
					g_bIsNumKey = TRUE;
					_DVBApp_ShowPopup(DVB_APP_POP_MSG_REC_STOP_CHANNEL_CHANGE);
					break;
				}
			}
#endif
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PROGNUM))
			{
				SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PROGNUM);
			}
			else
			{
				_DVBApp_HidePopupDisplay();
				_DVBApp_CloseAllMenu();
				SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, DVB_GUIOBJ_PROGNUM, (dMessage - UI_EVENT_0));
			}
			break;
#ifdef CONFIG_SUPPORT_PVR
		case UI_EVENT_REC:
#ifdef REMINDER_OLNY_NO_RECORD
			break;
#endif
			dvb_printf("UI_EVENT_REC");
#if defined(SUPPORT_HOTEL_MODE_PVR_FUNCTION_CONTROL)
			if((g_stFactoryHotelData.HotelModeOnOff)&&(!g_stFactoryHotelData.PVRFunction))
			{
				break;
			}
#elif defined(SUPPORT_PVR_ONOFF)
			if(!g_stSetupData.PVROnOff)
			{
				break;
			}
#endif
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_REC))
			{
				dvb_printf("double rec ,goto duration");
				if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVRREC_INFO))
				{
					SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PVRREC_INFO);
				}
				SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, DVB_GUIOBJ_PVR_RECDURATIONTIME, 0);
			}
			else
			{
				if (u8MidRecState == MID_REC_STATUS_STOP)
				{
					if (DVBApp_CheckForRecord(MID_REC_MODE_MANUAL) != SP_SUCCESS)
					{
						break;
					}
					{
#ifndef SUPPORT_PVR_SPEC_START_NO_POP
						_DVBApp_ShowPopup(DVB_APP_POP_MSG_REC_START);
#else
						dvb_printf("start record is call\n");
						_APP_GUIOBJ_DVB_PvrRecDurationTime_ResetDurTime();
						_DVBApp_CloseAllMenu();
						DVBApp_StartRecord(MID_REC_MODE_MANUAL);
#endif
					}
					break;
				}
#ifdef SUPPORT_SPEC_PVR_RECORD
				else if ((MID_REC_MODE_MANUAL != u8MIDRecMode)
						 && !SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PROGINFO))
				{	//if timeshifting, then pop to ask stop timeshift and start record
					_DVBApp_ShowPopup(DVB_APP_POP_MSG_STOP_TSHIFT_TO_REC);
				}
#endif
			}
			break;
		case UI_EVENT_STOP:
			if ((MID_REC_MODE_AUTO == u8MIDRecMode) && ((MID_REC_STATUS_START == u8MidRecState) || (!APP_GUIOBJ_DVB_PvrPlayInfo_GetStopPopFlag())))
			{
				if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_BANNER)
					|| SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_MULTIAUD)
					|| SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PROGINFO))
				{
					break;
				}
				if (PVR_STATE_STOP != APP_GUIOBJ_DVB_PvrPlayInfo_GetRecState())
				{
					APP_GUIOBJ_DVB_PvrPlayInfo_StopTimeshift();
				}
				if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO))
				{
					SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO);
				}
			}
			else
			{
				if (((SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_REC)) ||
					(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_PAUSE)))&&(!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO)))
				{
					_DVBApp_ShowPopup(DVB_APP_POP_MSG_REC_STOP);
				}
				else if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO))
				{
					if (MID_REC_MODE_AUTO == u8MIDRecMode)
					{
						SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO);
					}
					_DVBApp_ShowPopup(DVB_APP_POP_MSG_TIMESHIFT_STOP);
				}
				else
				{
					if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO))
					{
						SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO, dMessage, 0);
					}
				}
			}
			break;
		case APP_DVB_GLOBAL_EVENT_DTV_MEDIA_INIT_FAIL:
		case APP_DVB_GLOBAL_EVENT_DTV_MEDIA_INIT_SUCCESSFUL:
		case APP_DVB_GLOBAL_EVENT_PVR_RATING_UPDATE:
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_FILEPLAY))
			{
				SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PVR_FILEPLAY, dMessage, dParam);
				break;
			}
			break;
		case APP_DVB_GLOBAL_EVENT_DTV_MEDIA_INIT_PLAYSTATE:
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_FILEPLAY))
			{
				SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PVR_FILEPLAY, dMessage, 0);
				break;
			}
			
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO))
			{
				SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO, dMessage, 0);
				break;
			}
			{
				UINT8 u8Mute = 0;
				 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 == FALSE)
				 {
					 APP_Audio_SetMute(FALSE, TRUE, APP_MUTE_MODE_SIGNAL_DETECT, APP_SOURCE_DTV);
				 }
				 
				 MID_TSPLParser_Resume();
			}
			break;
		case APP_DVB_GLOBAL_EVENT_PVR_UPDATE_TIME:
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO))
			{
				SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO, dMessage, 0);
				break;
			}
			break;
		case APP_DVB_GLOBAL_EVENT_DTV_MEDIA_PLAYDONE:
		case APP_DVB_GLOBAL_EVENT_DTV_MEDIA_PLAYREADERROR:
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_FILEPLAY))
			{
				SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PVR_FILEPLAY, dMessage, 0);
				break;
			}
			if ((MID_REC_MODE_AUTO == u8MIDRecMode)
				|| (MID_REC_MODE_MANUAL == u8MIDRecMode))
			{
				if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO))
				{
					SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO);
				}
				APP_GUIOBJ_DVB_PvrPlayInfo_StopTimeshift();
			}
			else if (MID_REC_MODE_TIMESHIFT_AFTER_REC == u8MIDRecMode)
			{
				if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO))
				{
					SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO, dMessage, 0);
					break;
				}
				APP_GUIOBJ_DVB_PvrPlayInfo_StopTimeshift();
			}
			break;
		case APP_DVB_GLOBAL_EVENT_SWITCH_FILEPLAY:

			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_FILEPLAY))
			{
				SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PVR_FILEPLAY);
			}

			if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_SOURCE)
				&& !APP_MenuMgr_Exist_Main_Menu())
			{
				SYSAPP_GOBJ_CreateGUIObject_WithPara(
					SYS_APP_DVB, DVB_GUIOBJ_RECORDLIST, dParam);
			}
			break;

		case APP_DVB_GLOBAL_EVENT_CLOSE_FILEPLAY:
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_FILEPLAY))
			{
				SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PVR_FILEPLAY);
			}
			break;
		case APP_DVB_GLOBAL_EVENT_REC_NOTIFY_DISK_FULL:
			if (MID_REC_MODE_MANUAL == u8MIDRecMode)
			{
				DVBApp_StopRecord();
			}
			else if ((MID_REC_MODE_TIMESHIFT_AFTER_REC == u8MIDRecMode) ||
					 (MID_REC_MODE_AUTO == u8MIDRecMode))
			{
				DVBApp_StopTimeshift(TRUE);
			}
			_DVBApp_ShowPopup(DVB_APP_POP_MSG_PVR_DISK_FULL);
			break;

		case APP_DVB_GLOBAL_EVENT_REC_NOTIFY_WRITE_ERR:
		case APP_DVB_GLOBAL_EVENT_REC_NOTIFY_GFS_FAILURE:
			if (MID_PartitionList_GetMountedCount() == 0)
			{
				break;
			}

			if (MID_RecorderIsCurRecording() != DRV_SUCCESS)
			{
				break;
			}

			if (MID_REC_MODE_MANUAL == u8MIDRecMode|| MID_REC_MODE_UNATTENDED == u8MIDRecMode)
			{
				DVBApp_StopRecord();
				if(dMessage == APP_DVB_GLOBAL_EVENT_REC_NOTIFY_GFS_FAILURE)
				{
					_DVBApp_ShowPopup(DVB_APP_POP_MSG_REC_ENTER_NOT_VALID);
				}
				else
				{
					_DVBApp_ShowPopup(DVB_APP_POP_MSG_REC_WRITE_ERROR);
				}
			}
			else if ((MID_REC_MODE_TIMESHIFT_AFTER_REC == u8MIDRecMode) ||
					 (MID_REC_MODE_AUTO == u8MIDRecMode))
			{
				DVBApp_StopTimeshift(TRUE);
				if(dMessage == APP_DVB_GLOBAL_EVENT_REC_NOTIFY_GFS_FAILURE)
				{
					_DVBApp_ShowPopup(DVB_APP_POP_MSG_TIMESHIFT_ENTER_NOT_VALID);
				}
				else
				{
					_DVBApp_ShowPopup(DVB_APP_POP_MSG_REC_WRITE_ERROR);
				}
			}
			if (APP_PVR_TIMESHIFT_AUTO == u8AutoTimeShift)
			{
				DVBApp_SetBGTimeshift(PVR_BGTIMESHIFT_START_INTERVAL);
			}
			break;

		case UI_EVENT_GOTO:
			if ((SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_REC)) ||
				(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_PAUSE)))
			{
				if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_GOTO))
				{
					SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, DVB_GUIOBJ_PVR_GOTO, 0);
				}
			}
			break;

		case UI_EVENT_FF:
			break;


		case UI_EVENT_FR:
			if ((MID_REC_MODE_AUTO == u8MIDRecMode) && (u8MidRecState != MID_REC_STATUS_STOP))
			{
				if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_BANNER)
					|| SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_MULTIAUD)
					|| SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PROGINFO))
				{
					break;
				}
				if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVRREC_INFO))
				{
					SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PVRREC_INFO);
				}
				SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO, PVR_PLAYINFO_ENTERFR);
			}
			break;

		case UI_EVENT_PREV:
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO))
			{
				SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO, dMessage, 0);
			}
			break;
		case UI_EVENT_NEXT:
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO))
			{
				SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO, dMessage, 0);
			}
			break;
		case APP_DVB_GLOBAL_EVENT_REC_START_FROM_EPG:
			{
				AL_RecHandle_t hRecProg = AL_DB_INVALIDHDL;
				al_uint32 CurTimeInSec = 0;
				al_uint32 EndTimeInsec = 0;
				EndTimeInsec = APP_GUIOBJ_DVB_Epg_GetEndTime();
				AL_Time_GetCurTimeInSecs(&CurTimeInSec);
				if ((CurTimeInSec+10) >= EndTimeInsec)
				{
					_DVBApp_ShowPopup(DVB_APP_POP_MSG_REC_ENTER_NOT_VALID);
				}
				hRecProg = APP_GUIOBJ_DVB_Epg_GetRecHdl();
				_DVBApp_CloseAllMenu();
				if ((hRecProg != AL_DB_INVALIDHDL)
					&& (hCurProg != hRecProg))
				{
					AL_DB_EDBType_t db_type;
					AL_DB_ERecordType_t eServiceType;
					AL_DB_GetRecordType(hRecProg, &db_type, &eServiceType);
					_DVBApp_Zapping(eServiceType, hRecProg, FALSE, 0, FALSE);
				}
				_DVBApp_CloseAllMenu();
				_APP_GUIOBJ_DVB_PvrRecDurationTime_ResetDurTime();
				DVBApp_StartRecord(MID_REC_MODE_MANUAL);
				APP_GUIOBJ_DVB_PvrRecDurationTime_SetDurTime(EndTimeInsec);
			}
			break;
#endif
		case UI_EVENT_FREEZE:
		{
			MID_DISP_DTVGetVideoMute(&eMuteSt);
			if ((eMuteSt == MID_DISP_MUTE)
				|| (eMuteSt == MID_DISP_MUTE_BY_APP)
				||(eMuteSt == MID_DISP_MUTE_BY_TVFE)
				||(eMuteSt == MID_DISP_MUTE_BY_VIP))
			{
				break;
			}
		}
		/* here, judge database empty or not */
		{
			bHasValidServ = AL_DB_HasVisibleService(eNetType);

			if (!bHasValidServ)
			{
				/* database empty, do nothing */
				break;
			}
		}
#ifdef CONFIG_SUPPORT_PVR
		if ((MID_REC_STATUS_STOP != u8MidRecState) && (MID_REC_MODE_MANUAL != u8MIDRecMode))
		{
			break;	//when timeshift invalid freeze function
		}
#endif
#ifdef PLAY_VIDEO_FOR_ALLSRV
		AL_RecHandle_t hTempHdl;
		MID_PlaybackGetCurProgHandle(al_null, &hTempHdl);
		DBPIDInfo_t 	stVideoPid;
		memset(&stVideoPid,0xff,sizeof(DBPIDInfo_t));
					
		AL_DB_QueryDetailFieldByName(hTempHdl, (al_uint8 *)"stVideoPid", (al_void *)&stVideoPid);	
		if ((stVideoPid.usDataPID&0x1fff) == 0x1fff)	
#else
		if (eServiceType == AL_RECTYPE_DVBRADIO)
#endif
		{
			DVBApp_ClosePopup(PLAYBACK_POPUP_MSG_RADIO_CHANNEL, UI_EVENT_NULL);
			_DVBApp_ShowPopup(DVB_APP_POP_MSG_NOT_AVAILABLE);
			break;
		}

		if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_FREEZE))
		{
			//zhongbaoxing added for mantis 0164987 @20120117 +++
			//zhongbaoxing added for mantis 0164987 @20120117 ---
			SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_FREEZE);
			MID_PlaybackStreamResume(1);
			g_PauseState = FALSE;
		}
		else
		{
			AL_DVB_Monitor_GetState(AL_DVB_MONITOR_STATE_SIGNAL, &bSignalState);
			if (bSignalState == AL_DVB_MONITOR_VALUE_TRUE)
			{
				if (DVBApp_CheckServiceNotAvailable() == TRUE)
				{
					_DVBApp_ShowPopup(DVB_APP_POP_MSG_NOT_AVAILABLE);
					break;
				}

				g_PauseState = TRUE;
				//zhongbaoxing added for mantis 0164987 @20120117 +++
				//zhongbaoxing added for mantis 0164987 @20120117 ---
				SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, DVB_GUIOBJ_FREEZE, 0);
				MID_PlaybackStreamPause(1);
				g_PauseState = TRUE;
			}
		}
		break;
		case UI_EVENT_TVRADIO:
#ifdef CONFIG_SUPPORT_PVR
			if (MID_REC_STATUS_STOP != u8MidRecState)// && (MID_REC_MODE_AUTO != u8MIDRecMode))
			{
				if (MID_REC_MODE_MANUAL == u8MIDRecMode)
				{
					_DVBApp_ShowPopup(DVB_APP_POP_MSG_REC_STOP_FOR_TVRADIOKEY);
				}
				else
				{
					_DVBApp_ShowPopup(DVB_APP_POP_MSG_TIMESHIFT_STOP_FOR_TVRADIOKEY);
				}
				break;
			}
		#if 0
			else if ((MID_REC_STATUS_STOP != u8MidRecState) && (MID_REC_MODE_AUTO == u8MIDRecMode))
			{
				DVBApp_StopTimeshift(TRUE);
				DVBApp_SetBGTimeshift(PVR_BGTIMESHIFT_START_INTERVAL);
			}
		#endif
#endif
			if (APP_DVB_Playback_SwapServiceType(eNetType, (AL_DB_ERecordType_t *)&NextServiceType, &u32TotalNum) != AL_SUCCESS)
			{
				if(NextServiceType == AL_RECTYPE_DVBRADIO)
				{
					_DVBApp_ShowPopup(DVB_APP_POP_MSG_NO_RADIO);
				}
				else
				{
					_DVBApp_ShowPopup(DVB_APP_POP_MSG_NO_DTVORDATA);
				}
			}
			break;
#ifdef CELLO_REMOTE_KEY
		case UI_EVENT_ATV:
#endif
		case UI_EVENT_ATVDTV:
#ifdef CONFIG_SUPPORT_PVR
			if (MID_REC_STATUS_STOP != u8MidRecState)// && (MID_REC_MODE_AUTO != u8MIDRecMode))
			{
				if (MID_REC_MODE_MANUAL == u8MIDRecMode)
				{
					_DVBApp_ShowPopup(DVB_APP_POP_MSG_REC_STOP_FOR_TVRADIOKEY);
				}
				else
				{
					_DVBApp_ShowPopup(DVB_APP_POP_MSG_TIMESHIFT_STOP_FOR_TVRADIOKEY);
				}
				break;
			}
#endif
			if ((eSourType == APP_SOURCE_DTV) || (eSourType == APP_SOURCE_RADIO))
			{
				DVBApp_ResetPopup_Channel();
				_DVBApp_CloseAllMenu();
				APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_ATV);
			}
			break;
		break;
#ifdef TEAC_BLUE_KEY_FUNCTION
		case UI_EVENT_BLUE:
		{
			AL_DB_EDBType_t eNetType = APP_DVB_Playback_GetCurrentNetType();
			AL_DB_ERecordType_t eServiceType = APP_DVB_Playback_GetCurrServiceType(eNetType);
			if (eServiceType == AL_RECTYPE_DVBRADIO)
			{
				if (_DVB_GetPanelControlType()== APP_PANEL_POWER_UP)
				{
#ifdef CONFIG_SUPPORT_MHEG5
					if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_MHEG5))
#endif
					{
						//APP_Panel_SetPowerSequence(APP_PANEL_POWER_DOWN);
						_DVB_SetPanelControlType(APP_PANEL_POWER_DOWN);
					}
				}
				else if (_DVB_GetPanelControlType()== APP_PANEL_POWER_DOWN)
				{
					//APP_Panel_SetPowerSequence(APP_PANEL_POWER_UP);
					_DVB_SetPanelControlType(APP_PANEL_POWER_UP);
				}
			}
			break;
		}
#endif
#ifdef SUPPORT_AD_DESCRIPTION
		case UI_EVENT_AB:
		{
			UINT8 u8Mute = 0;
			u8Mute = g_stUserInfoData.Mute;
			if (u8Mute == TRUE)
			{
				AL_DVB_Monitor_GetState(AL_DVB_MONITOR_STATE_SIGNAL, &bSignalState);
				if (bSignalState == AL_DVB_MONITOR_VALUE_TRUE)
				{
					APP_Audio_SetMute(FALSE, TRUE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
				}
				else
				{
					APP_Audio_SetMute(FALSE, TRUE, APP_MUTE_MODE_NO_SIGNALE, 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
			}
			SYSAPP_GOBJ_SendMsgToSingleGUIObject(
				SYS_APP_DVB, APP_GUIOBJ_MUTE,
				APP_INTRA_EVENT_HIDE_MUTE, 0);
			break;
		}
		break;
#endif
#ifdef CONFIG_SUPPORT_HELP_MENU
		case UI_EVENT_HELP:
				DVBApp_ResetPopup_Channel();
				_DVBApp_CloseAllMenu();
				SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, APP_GUIOBJ_HELP_MENU, 0);
			break;
#endif
#ifdef SUPPORT_HKC_FACTORY_REMOTE
		case UI_EVENT_HKC_ENTER_BURNINGMODE:
			if(g_stFactoryUserData.n_FactSet_FactoryRemote == 1)
			{
				_DVBApp_Exit_All_Menu();
				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_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_DVB, 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_DVB, APP_GUIOBJ_FM_FACTORYSETTING))
				{
					DVBApp_ResetPopup_Channel();
        			_DVBApp_CloseAllMenu();
					SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, 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_DVB, 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_DVB, APP_GUIOBJ_ADJUST, ADJUST_VOLUME);
			}
			break;
		case UI_EVENT_HKC_RESET:
			if(g_stFactoryUserData.n_FactSet_FactoryRemote == 1)
			{
				SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PLAYBACK,
					APP_DVB_INTRA_EVENT_STOP_PLAYBACK, PLAYBACK_STOP_ALL);

				APP_Audio_SetMute(TRUE, FALSE, APP_MUTE_MODE_STATEMAX, eSourType);
				APP_Video_SetMute(TRUE, FALSE, APP_MUTE_MODE_STATEMAX, eSourType);
#ifdef CONFIG_ATV_SUPPORT
				AL_DB_Reset(AL_DBTYPE_DVB_ATV, al_true);
				APP_ATV_Playback_ResetFirstService();
#endif
				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);
				AL_PR_DeleteAllSch(AL_DBTYPE_DVB_SBTVD,AL_PR_EVT_REM | AL_PR_SRV_REM);
				App_Data_UserSetting_Restore();
				App_Data_UserSetting_FM_Hotel_Restore();
				App_Data_UserSetting_ResetLangContry_ByFMDefaultValue();
				APP_Video_ResetTVSetting();
				GL_TaskSleep(2000);
				MAINAPP_SendGlobalEvent(UI_EVENT_POWER, AL_POWER_STATE_OFF);
			}
			break;
		case UI_EVENT_HKC_RESET_DEFAULT_FAC:
			if(g_stFactoryUserData.n_FactSet_FactoryRemote == 1)
			{
				extern void _APP_GUIOBJ_FM_FactorySetting_Shipping(void);
				_APP_GUIOBJ_FM_FactorySetting_Shipping();
			}
			break;
		case UI_EVENT_HKC_TV:
			if(g_stFactoryUserData.n_FactSet_FactoryRemote == 1)
			{
				APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_ATV);
			}
			break;
		case UI_EVENT_HKC_AV:
			if(g_stFactoryUserData.n_FactSet_FactoryRemote == 1)
			{
				APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_AV);
			}
			break;
		case UI_EVENT_HKC_AV2:
			if(g_stFactoryUserData.n_FactSet_FactoryRemote == 1)
			{
				APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_AV1);
			}
			break;
		case UI_EVENT_HKC_PC:
			if(g_stFactoryUserData.n_FactSet_FactoryRemote == 1)
			{
				APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_PC);
			}
			break;
		case UI_EVENT_HKC_YPBPR:
			if(g_stFactoryUserData.n_FactSet_FactoryRemote == 1)
			{
				APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_YPBPR);
			}
			break;
		case UI_EVENT_HKC_YPBPR2:
			if(g_stFactoryUserData.n_FactSet_FactoryRemote == 1)
			{
				APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_YPBPR1);
			}
			break;
		case UI_EVENT_HKC_HDMI:
			if(g_stFactoryUserData.n_FactSet_FactoryRemote == 1)
			{
				APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_HDMI);
			}
			break;
		case UI_EVENT_HKC_HDMI2:
			if(g_stFactoryUserData.n_FactSet_FactoryRemote == 1)
			{
				APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_HDMI1);
			}
			break;
		case UI_EVENT_HKC_HDMI3:
			if(g_stFactoryUserData.n_FactSet_FactoryRemote == 1)
			{
				APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_HDMI2);
			}
			break;
		case UI_EVENT_HKC_SCART:
			if(g_stFactoryUserData.n_FactSet_FactoryRemote == 1)
			{
				APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_SCART);
			}
			break;
		case UI_EVENT_HKC_USB:
			if(g_stFactoryUserData.n_FactSet_FactoryRemote == 1)
			{
				APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_MEDIA);
			}
			break;
#endif
		case UI_EVENT_PAUSE:
		case UI_EVENT_PLAY_PAUSE:
#ifdef CONFIG_SUPPORT_PVR
			if ((MID_REC_MODE_AUTO == u8MIDRecMode) && (u8MidRecState != MID_REC_STATUS_STOP))
			{
				if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_BANNER)
					|| SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_MULTIAUD)
					|| SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PROGINFO))
				{
					break;
				}
				if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVRREC_INFO))
				{
					SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PVRREC_INFO);
				}
				SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO, PVR_PLAYINFO_ENTERPAUSE);
			}
		#if 0//def SUPPORT_PVR_RECORD_PLAY_CURRENTRECORD
			else if((MID_REC_MODE_MANUAL == u8MIDRecMode) && (u8MidRecState != MID_REC_STATUS_STOP))
			{
				if (APP_DVB_Playback_GetProgStateByHandle(eNetType, AL_DB_INVALIDHDL)
					== MID_PLAYBK_PROG_STATE_LOCKED)
				{
					break;
				}
				if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_BANNER)
					|| SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PROGINFO))
				{
					break;
				}
				if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_MULTIAUD))
				{
					break;
				}
				if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVRREC_INFO))
				{
					SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PVRREC_INFO);
				}
				if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO))
				{
					if (DVBAPP_Pvr_GetRECPlayFlag())
					{
						SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO, PVR_PLAYINFO_ENTERNORMAL);
					}
					else
					{
						SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO, PVR_PLAYINFO_ENTERPAUSE);
					}
				}
			}
		#else
			else
			{
				if ((SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_REC)) &&
					(!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO)))
				{
					MID_RecorderPauseResume();
					_DVBApp_Recorder_PauseResume();
					g_bIsPlaykey = FALSE;
				}
				else if ((SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_PAUSE)) &&
						 (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO)))
				{
					AL_DVB_Monitor_GetState(AL_DVB_MONITOR_STATE_SIGNAL, &bSignalState);
					if (bSignalState != AL_DVB_MONITOR_VALUE_TRUE)
					{
						break;
					}
					switch (APP_DVB_Playback_GetProgStateByHandle(eNetType, hProg))
					{
						case MID_PLAYBK_PROG_STATE_ONLY_VIDEO_SCRAMBLED:
							dvb_printf("Error: %s program state scrambled!\n", __FUNCTION__);
						case MID_PLAYBK_PROG_STATE_AUDIO_VIDEO_SCRAMBLED:
							dvb_printf("Error: %s program state scrambled!\n", __FUNCTION__);
						case MID_PLAYBK_PROG_STATE_ONLY_AUDIO_SCRAMBLED:
							dvb_printf("Error: %s program state scrambled!\n", __FUNCTION__);
						case MID_PLAYBK_PROG_STATE_TEMP_SERVICE:
							dvb_printf("Error: %s program state data service!\n", __FUNCTION__);
						case MID_PLAYBK_PROG_STATE_NOT_RUNNING:
							dvb_printf("Error: %s program state not running!\n", __FUNCTION__);
						case MID_PLAYBK_PROG_STATE_LOCKED:
							dvb_printf("Error: %s program state locked!\n", __FUNCTION__);
							return 0;
						default:
							break;
					}
					MID_RecorderPauseResume();
					_DVBApp_Recorder_PauseResume();
					g_bIsPlaykey = TRUE;
				}
			}
#endif
			break;
#else
			_DVBApp_ShowPopup(DVB_APP_POP_MSG_NOT_AVAILABLE);
			break;
#endif

		case UI_EVENT_TIMESHIFT:
#ifdef REMINDER_OLNY_NO_RECORD
			_DVBApp_ShowPopup(DVB_APP_POP_MSG_NOT_AVAILABLE);
			break;
#endif

#ifdef CONFIG_SUPPORT_PVR
#if defined(SUPPORT_HOTEL_MODE_PVR_FUNCTION_CONTROL)
		if((g_stFactoryHotelData.HotelModeOnOff)&&(!g_stFactoryHotelData.PVRFunction))
		{
			break;
		}
#elif defined(SUPPORT_PVR_ONOFF)
		if(!g_stSetupData.PVROnOff)
		{
			break;
		}
#endif
		if (u8MidRecState == MID_REC_STATUS_STOP)
		{
			if (DVBApp_CheckForRecord(MID_REC_MODE_TIMESHIFT_AFTER_REC) != SP_SUCCESS)
			{
				break;
			}
//	#ifdef SUPPORT_TEAC_TIMESHIFT_CTRL
	#if defined(SUPPORT_TEAC_TIMESHIFT_CTRL) || defined(SUPPORT_PVR_SPEC_START_NO_POP)
//for mantis 191631, TEAC spec. start timeshift immediately with no pop msg
			{
				PVR_DEBF(" ==timeshift start is called!!!== \n");
				_DVBApp_CloseAllMenu();
				DVBApp_StartRecord(MID_REC_MODE_TIMESHIFT_AFTER_REC);
			}
#else
			{
				_DVBApp_ShowPopup(DVB_APP_POP_MSG_TIMESHIFT_START);
			}
#endif
				break;
			}
			else if ((MID_REC_STATUS_STOP != u8MidRecState)
					 && (MID_REC_MODE_TIMESHIFT_AFTER_REC == u8MIDRecMode))
			{
					PVR_DEBF(" dvb app stop timeshift -UI_EVENT_TIMESHIFT- \n");
					_DVBApp_ShowPopup(DVB_APP_POP_MSG_TIMESHIFT_STOP);
			}
			break;
#else
			_DVBApp_ShowPopup(DVB_APP_POP_MSG_NOT_AVAILABLE);
			break;
#endif

#ifdef CONFIG_SUPPORT_PVR
		case UI_EVENT_REC_LIST:
#if (defined CONFIG_IR501)
		//case UI_EVENT_DEVLIST:
#endif
#if defined(SUPPORT_HOTEL_MODE_PVR_FUNCTION_CONTROL)
			if((g_stFactoryHotelData.HotelModeOnOff)&&(!g_stFactoryHotelData.PVRFunction))
			{
				break;
			}
#elif defined(SUPPORT_PVR_ONOFF)
			if(!g_stSetupData.PVROnOff)
			{
				break;
			}
#endif
			if (MID_RecorderIsCurRecording() != DRV_SUCCESS)	//not allow to open timerlist when recording
			{
				DVBApp_ResetPopup_Channel();
				_DVBApp_CloseAllMenu();
				if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_FREEZE))
				{
#ifdef Subtitle_Freeze
					AL_Subtitle_SetFreeze(FALSE);
#else
					DVBApp_DataApplicationSwitch(OSD2CTRLMDL_ENABLE | OSD2CTRLMDL_SUB);
#endif
					SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_FREEZE);
				}
				if (APP_GetPlaybackPauseState() == TRUE)
				{
					MID_PlaybackStreamResume(1);
					APP_SetPlaybackPauseState(FALSE);
				}
#ifdef SUB_CUSTOMER_Tianle
				SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, DVB_GUIOBJ_TIMERLIST_FORTEAC, 0);
#else
				SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, DVB_GUIOBJ_TIMERLIST, 0);
#endif
			}
			break;

		case UI_EVENT_REC_FILE:
#ifdef REMINDER_OLNY_NO_RECORD
			break;
#endif

#if defined(SUPPORT_HOTEL_MODE_PVR_FUNCTION_CONTROL)
			if((g_stFactoryHotelData.HotelModeOnOff)&&(!g_stFactoryHotelData.PVRFunction))
			{
				break;
			}
#elif defined(SUPPORT_PVR_ONOFF)
			if(!g_stSetupData.PVROnOff)
			{
				break;
			}
#endif
			if (!(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_RECORDLIST)))
			{
#ifndef SUPPORT_TEAC_TIMESHIFT_CTRL
				if (u8MidRecState == MID_REC_STATUS_STOP)
#endif
				{
					DVBApp_ResetPopup_Channel();
					_DVBApp_CloseAllMenu();
					if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_FREEZE))
					{
#ifdef Subtitle_Freeze
						AL_Subtitle_SetFreeze(FALSE);
#else
						DVBApp_DataApplicationSwitch(OSD2CTRLMDL_ENABLE | OSD2CTRLMDL_SUB);
#endif
						SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_FREEZE);
					}
					if (APP_GetPlaybackPauseState() == TRUE)
					{
						MID_PlaybackStreamResume(1);
						APP_SetPlaybackPauseState(FALSE);
					}
					SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, DVB_GUIOBJ_RECORDLIST, 0);
				}
#ifndef SUPPORT_TEAC_TIMESHIFT_CTRL
				else
				{
					_DVBApp_ShowPopup(DVB_APP_POP_MSG_NOT_AVAILABLE);
				}
#endif
			}
			else
			{
				SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_RECORDLIST);
				if (APP_DVB_Playback_GetProgStateByHandle(eNetType, AL_DB_INVALIDHDL) == MID_PLAYBK_PROG_STATE_LOCKED)
				{
					_DVBApp_ShowPopup(DVB_APP_POP_MSG_CHECKPWD);
				}
			}
			break;
#endif

/*#ifdef CONFIG_SUPPORT_PVR
		case APP_DVB_GLOBAL_EVENT_REC_DURATION_EXIT:
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_RECDURATIONTIME))
			{
				SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PVR_RECDURATIONTIME);
			}
			break;
		case APP_DVB_GLOBAL_EVENT_REC_GOTO_EXIT:
			SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PVR_GOTO);
			break;
#endif*/

		case APP_GLOBAL_EVENT_POPMSG_YES:
#ifdef SUPPORT_DYNAMIC_MULTIPLEXES
			if (dParam == PLAYBACK_POPUP_PROMPT_OTH_TP_ADD_SRV)
			{
				 _DVBApp_NewServicesToDatabase();
			}
			else

			if (dParam == PLAYBACK_POPUP_CONFIRM_REMOVE_SRV)
			{
				DVBApp_RemoveUnstableService();//zhongbaoxing added to remove not running services @20120210
			}
			else
#endif
#ifdef CONFIG_SUPPORT_PVR
			if (dParam == POPMSG_CONFIRM_REC_REMIDER_TIME)
			{
				if(DVBApp_GetReminderTime2Show() > 1)//For confirm record ahead
				{
					memset(&g_stDetails,0,sizeof(AL_PR_details_t));
					memset(&g_stOldDetails,0,sizeof(AL_PR_details_t));
					AL_PR_GetById(g_dReminderId, &g_stDetails);
					AL_PR_GetById(g_dReminderId, &g_stOldDetails);
					DVBApp_PVRRec_SetTimerCancle();
					SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_DVB,
							(APP_DVB_GLOBAL_EVENT_PVRSCH | PASS_TO_SYSAPP), (UINT32)&g_stOldDetails);
				}
			}
			else if (dParam == POPMSG_CONFIRM_FIND_NEW_TSID)
			{
				dvb_printf("======POPMSG_CONFIRM_FIND_NEW_TSID YES\n");
#ifdef CONFIG_DTV_SUPPORT
				if (APP_GetPlaybackPauseState() == TRUE)
				{
					MID_PlaybackStreamResume(1);
					APP_SetPlaybackPauseState(FALSE);
				}

				SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, DVB_GUIOBJ_SCAN_PROCESS, SEARCH_D_FULL_FREQ_MODE);
#endif
				//APP_GUIOBJ_DVB_PartitionList_PartitionFormat();
			}
			else if ((dParam == POPMSG_CONFIRM_START_RECORD)
					 || (dParam == POPMSG_CONFIRM_STOP_MHEG_FOR_RECORD))
			{
				dvb_printf("start record is call\n");
				_DVBApp_CloseAllMenu();
				_APP_GUIOBJ_DVB_PvrRecDurationTime_ResetDurTime();
				DVBApp_StartRecord(MID_REC_MODE_MANUAL);
			}
			else if (dParam == POPMSG_CONFIRM_STOP_THIFT_TO_REC)
			{
				DVBApp_StopTimeshift(TRUE);
				_DVBApp_CloseAllMenu();
				_APP_GUIOBJ_DVB_PvrRecDurationTime_ResetDurTime();
				DVBApp_StartRecord(MID_REC_MODE_MANUAL);
			}
#ifdef SUPPORT_PVR_REMINDER_CONFIRM_SPEC
			else if ((dParam == POPMSG_CONFIRM_STOP_REC_FOR_REMINDER)
				||(dParam == POPMSG_CONFIRM_STOP_TSHIFT_FOR_REMINDER)
				||(dParam == POPMSG_CONFIRM_STOP_REC_FOR_TIMER_REC)
				||(dParam == POPMSG_CONFIRM_STOP_TSHIFT_FOR_TIMER_REC))
			{
				_DVBApp_StopRECForTimerConfirmDone(dParam);
			}
#endif
			else if (dParam == POPMSG_CONFIRM_RECORDER_SPEED_NOT_ENOUGH)
			{
				INT32 iRet;
				dvb_printf("====== force to enter record !\n");
				_DVBApp_CloseAllMenu();
				_DVBApp_ShowPopup(DVB_APP_POP_MSG_REC_INIT);
				MID_Recorder_SetRecMode(MID_REC_MODE_MANUAL);
				iRet = APP_GUIOBJ_DVB_PvrRec_StartRecord();
				if (iRet != PVR_MSG_SUCCESS)
				{
					_DVBApp_ShowPopup(DVB_APP_POP_MSG_REC_ENTER_NOT_VALID);
					MID_Recorder_SetRecMode(MID_REC_MODE_MAX);
					APP_GUIOBJ_DVB_PvrRec_RegUninitCallback();
					return SP_ERR_FAILURE;
				}
				SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, DVB_GUIOBJ_PVR_REC, 0);
			}
			else if ((dParam == POPMSG_CONFIRM_START_TIMESHIFT)
					 || (dParam == POPMSG_CONFIRM_STOP_MHEG_FOR_TIMESHIFT))
			{
				_DVBApp_CloseAllMenu();
				DVBApp_StartRecord(MID_REC_MODE_TIMESHIFT_AFTER_REC);
			}
			else if (dParam == POPMSG_CONFIRM_TIMESHIFT_SPEED_NOT_ENOUGH)
			{
				INT32 iRet;
				PVR_DEBF("====== force to enter timeshift !\n");
				_DVBApp_CloseAllMenu();
				if (MID_REC_MODE_AUTO == g_eCheckRecMode)
				{
					MID_Recorder_SetRecMode(MID_REC_MODE_AUTO);
				}
				else
				{
					_DVBApp_ShowPopup(DVB_APP_POP_MSG_TIMESHIFT_INIT);
					MID_Recorder_SetRecMode(MID_REC_MODE_TIMESHIFT_AFTER_REC);
				}
				iRet = APP_GUIOBJ_DVB_PvrRec_StartRecord();
				if (iRet != PVR_MSG_SUCCESS)
				{
					_DVBApp_ShowPopup(DVB_APP_POP_MSG_REC_ENTER_NOT_VALID);
					MID_Recorder_SetRecMode(MID_REC_MODE_MAX);
					APP_GUIOBJ_DVB_PvrRec_RegUninitCallback();
					g_eCheckRecMode = MID_REC_MODE_MAX;
					return SP_ERR_FAILURE;
				}
				if (MID_REC_MODE_AUTO != MID_Recorder_GetRecMode())
				{
					if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVRREC_INFO))
					{
						SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PVRREC_INFO);
					}
					SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO, 0);
				}
			}
			else if (dParam == POPMSG_CONFIRM_STOP_RECORD)
			{
				dvb_printf("stop record is call\n");
				DVBApp_SetTVRadioSwap(FALSE);
				g_ProgHandleB4Rec = 0;
				DVBApp_StopRecord();
				memset(&g_stDetails,0,sizeof(AL_PR_details_t));

				if(g_stUserInfoData.Subtitle == 0)
					DVBApp_DataApplicationSwitch(OSD2CTRLMDL_ENABLE | OSD2CTRLMDL_MH5);
			}
			else if (dParam == POPMSG_CONFIRM_STOP_TIMESHIFT)
			{
				dvb_printf("stop timeshift is call\n");
				DVBApp_StopTimeshift(TRUE);
			
				if(g_stUserInfoData.Subtitle == 0)
					DVBApp_DataApplicationSwitch(OSD2CTRLMDL_ENABLE | OSD2CTRLMDL_MH5);
			}
			else if (dParam == POPMSG_CONFIRM_STOP_RECORD_FOR_RECALL)
			{
				DVBApp_SetTVRadioSwap(FALSE);
				g_ProgHandleB4Rec = 0;
				DVBApp_StopRecord();
				memset(&g_stDetails,0,sizeof(AL_PR_details_t));
				SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_DVB, UI_EVENT_RECALL, 0);
			}
			else if (dParam == POPMSG_CONFIRM_STOP_RECORD_FOR_CH_CHANGE)
			{
				dvb_printf("stop record for channel change!\n");
				DVBApp_StopRecord();
				memset(&g_stDetails,0,sizeof(AL_PR_details_t));
				{
					if (g_bIsNumKey)
					{
						_DVBApp_Zapping(eServiceType, g_ProgHandle, FALSE, 0, TRUE);
						return 0;
					}
					if (g_bIsFav == FALSE)
					{
						// normal
						if (TRUE == g_bIsCHUp)
						{
							hProg = APP_DVB_PLAYBACK_GetNextProgHdl(eNetType, 1, APP_FAVORITE_NONE);
						}
						else if (FALSE == g_bIsCHUp)
						{
							hProg = APP_DVB_PLAYBACK_GetNextProgHdl(eNetType, -1, APP_FAVORITE_NONE);
						}
					}
					else
					{
						// fav
						if (TRUE == g_bIsCHUp)
						{
							hProg = APP_DVB_PLAYBACK_GetNextProgHdl(eNetType, 1, FavType);
						}
						else if (FALSE == g_bIsCHUp)
						{
							hProg = APP_DVB_PLAYBACK_GetNextProgHdl(eNetType, -1, FavType);
						}
					}

					if (hProg != AL_DB_INVALIDHDL)
					{
						AL_DB_EDBType_t db_type;
						AL_DB_ERecordType_t record_type;
						AL_DB_GetRecordType(hProg, &db_type, &record_type);
						if (db_type == AL_DBTYPE_DVB_ATV)
						{
							_DVBApp_CloseAllMenu();
							break;
						}
						if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_ADJUST))
						{
							SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, APP_GUIOBJ_ADJUST);
						}
#ifdef SUPPORT_CEC_TV
						if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_AMPLIFIERVOLUME))
						{
							SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, APP_GUIOBJ_AMPLIFIERVOLUME);
						}
#endif
						_DVBApp_Zapping(eServiceType, hProg, FALSE, 0, TRUE);
					}
					else
					{
						DVBApp_CheckProgramType(TRUE);
					}
					break;
				}
			}
			else if (dParam == POPMSG_CONFIRM_STOP_RECORD_FOR_SRC_CHANGE)
			{
				dvb_printf("stop record for source change!\n");
				DVBApp_StopRecord();
				memset(&g_stDetails,0,sizeof(AL_PR_details_t));
				{
					if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_SOURCE))
					{
						_DVBApp_Exit_All_Menu();
					}
					else
					{
						DVBApp_ResetPopup_Channel();
						_DVBApp_CloseAllMenu();
						SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, APP_GUIOBJ_SOURCE, 0);
					}
					break;
				}
			}
			else if (dParam == POPMSG_CONFIRM_STOP_TIMESHIFT_FOR_RECALL)
			{
				DVBApp_StopTimeshift(TRUE);
				SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_DVB, UI_EVENT_RECALL, 0);
			}
			else if (dParam == POPMSG_CONFIRM_STOP_TIMESHIFT_FOR_CH_CHANGE)
			{
				dvb_printf("stop timeshift for channel change!\n");
				DVBApp_StopTimeshift(TRUE);
				{
					if (g_bIsNumKey)
					{
						_DVBApp_Zapping(eServiceType, g_ProgHandle, FALSE, 0, TRUE);
						return 0;
					}
					if (g_bIsFav == FALSE)
					{
						//normal
						if (TRUE == g_bIsCHUp)
						{
							hProg = APP_DVB_PLAYBACK_GetNextProgHdl(eNetType, 1, APP_FAVORITE_NONE);
						}
						else if (FALSE == g_bIsCHUp)
						{
							hProg = APP_DVB_PLAYBACK_GetNextProgHdl(eNetType, -1, APP_FAVORITE_NONE);
						}
					}
					else
					{
						// fav
						if (TRUE == g_bIsCHUp)
						{
							hProg = APP_DVB_PLAYBACK_GetNextProgHdl(eNetType, 1, FavType);
						}
						else if (FALSE == g_bIsCHUp)
						{
							hProg = APP_DVB_PLAYBACK_GetNextProgHdl(eNetType, -1, FavType);
						}
					}
					if (hProg != AL_DB_INVALIDHDL)
					{
						AL_DB_EDBType_t db_type;
						AL_DB_ERecordType_t record_type;
						AL_DB_GetRecordType(hProg, &db_type, &record_type);
						if (db_type == AL_DBTYPE_DVB_ATV)
						{
							_DVBApp_CloseAllMenu();
							break;
						}
						if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_ADJUST))
						{
							SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, APP_GUIOBJ_ADJUST);
						}
						if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_AMPLIFIERVOLUME))
						{
							SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, APP_GUIOBJ_AMPLIFIERVOLUME);
						}
						//APP_DVB_Playback_SetUnlock(FALSE);
						//DVBApp_ChannelChange(eServiceType, sdProgIndex);
						_DVBApp_Zapping(eServiceType, hProg, FALSE, 0, TRUE);
					}
					else
					{
						DVBApp_CheckProgramType(TRUE);
						DVBApp_SetBGTimeshift(PVR_BGTIMESHIFT_START_INTERVAL);
					}
					break;
				}
			}
			else if (dParam == POPMSG_CONFIRM_STOP_TIMESHIFT_FOR_SRC_CHANGE)
			{
				dvb_printf("stop timeshift for source change!\n");
				DVBApp_StopTimeshift(TRUE);
				AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FEATURE, 0,
					sizeof(APP_SETTING_Feature_t), &(g_stFeatureData));
				if (APP_PVR_TIMESHIFT_AUTO == g_stFeatureData.AutoTimeShift)
				{
					DVBApp_SetBGTimeshift(PVR_BGTIMESHIFT_START_INTERVAL);
				}
				if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_SOURCE))
				{
					_DVBApp_Exit_All_Menu();
				}
				else
				{
					DVBApp_ResetPopup_Channel();
					_DVBApp_CloseAllMenu();
					SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, APP_GUIOBJ_SOURCE, 0);
				}
				break;
			}
			else if ((dParam == POPMSG_CONFIRM_STOP_RECORD_FOR_EPG)
					 || (dParam == POPMSG_CONFIRM_STOP_TIMESHIFT_FOR_EPG))
			{
				if (dParam == POPMSG_CONFIRM_STOP_RECORD_FOR_EPG)
				{
					DVBApp_StopRecord();
				}
				else
				{
					DVBApp_StopTimeshift(TRUE);
				}

				_DVBApp_CloseAllMenu();
				bHasValidServ = AL_DB_HasVisibleService(eNetType);

				if (bHasValidServ)
				{
					SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, dGuiObj, 0);
				}
				else
				{
					_DVBApp_ShowPopup(DVB_APP_POP_MSG_NOT_AVAILABLE);
				}
				break;
			}
			else if ((dParam == POPMSG_CONFIRM_STOP_RECORD_FOR_CHNLIST)
					 || (dParam == POPMSG_CONFIRM_STOP_TIMESHIFT_FOR_CHNLIST))
			{
				if (dParam == POPMSG_CONFIRM_STOP_RECORD_FOR_CHNLIST)
				{
					DVBApp_StopRecord();
				}
				else
				{
					DVBApp_StopTimeshift(TRUE);
				}

				if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_MULTIAUD))
				{
					_DVBApp_CloseAllMenu();
				}
				else
				{
					if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_CHNLIST))
					{
						SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_CHNLIST);
						_DVBApp_CheckPopupDisplay();
					}
					else
					{
						_DVBApp_CloseAllMenu();
						SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, DVB_GUIOBJ_CHNLIST, 0);
					}
				}
				break;
			}
			else if ((dParam == POPMSG_CONFIRM_STOP_RECORD_FOR_FAVLIST)
					 || (dParam == POPMSG_CONFIRM_STOP_TIMESHIFT_FOR_FAVLIST))
			{
				if (dParam == POPMSG_CONFIRM_STOP_RECORD_FOR_FAVLIST)
				{
					DVBApp_StopRecord();
				}
				else
				{
					DVBApp_StopTimeshift(TRUE);
				}

				if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_MULTIAUD))
				{
					_DVBApp_CloseAllMenu();
				}
				else
				{
					if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_FAVLIST))
					{
						SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_FAVLIST);
						_DVBApp_CheckPopupDisplay();
					}
					else
					{
						_DVBApp_CloseAllMenu();
						SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, DVB_GUIOBJ_FAVLIST, 0);
					}
				}
				break;
			}
			else if ((dParam == POPMSG_CONFIRM_STOP_RECORD_FOR_USBKEY)
					 || (dParam == POPMSG_CONFIRM_STOP_TIMESHIFT_FOR_USBKEY))
			{
				if (dParam == POPMSG_CONFIRM_STOP_RECORD_FOR_USBKEY)
				{
					DVBApp_StopRecord();
				}
				else
				{
					DVBApp_StopTimeshift(TRUE);
				}

				_DVBApp_CloseAllMenu();
				DVBApp_ResetPopup_Channel();
				if (SP_SUCCESS != APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_MEDIA))
				{
					dvb_printf("APP_GUIOBJ_Source_SetAppSource Fail!!!!!!!!!\n");
				}
				break;
			}
			else if ((dParam == POPMSG_CONFIRM_STOP_RECORD_FOR_TVRADIOKEY)
					 || (dParam == POPMSG_CONFIRM_STOP_TIMESHIFT_FOR_TVRADIOKEY))
			{
				if (dParam == POPMSG_CONFIRM_STOP_RECORD_FOR_TVRADIOKEY)
				{
					DVBApp_StopRecord();
					memset(&g_stDetails,0,sizeof(AL_PR_details_t));
				}
				else
				{
					DVBApp_StopTimeshift(TRUE);
				}

				if (APP_DVB_Playback_SwapServiceType(eNetType, (AL_DB_ERecordType_t *)&NextServiceType, &u32TotalNum) != AL_SUCCESS)
				{
					_DVBApp_ShowPopup(DVB_APP_POP_MSG_NOT_AVAILABLE);
				}
				break;
			}
			else if (POPMSG_CONFIRM_REC_REMIDER_TIME_CONFIRM == dParam)
			{
				APP_WAKEUP_Recorder_ResetTimeout();
				DVBApp_PVRRec_SetTimerCancle();
			}
			else if (POPMSG_CONFIRM_PVR_TIMESHIFT_STANDBY == dParam)
			{
				if (u8MidRecState != MID_REC_STATUS_STOP)
				{
					if (MID_TSPLParser_GetThreadState() == FALSE)
						DVBApp_StopRecord();
					else
						DVBApp_StopTimeshift(TRUE);
				}
				MAINAPP_SendGlobalEvent(UI_EVENT_POWER, AL_POWER_STATE_OFF);
			}
			else if ((dParam == POPMSG_CONFIRM_STOP_RECORD_FOR_MHEG)
					 || (dParam == POPMSG_CONFIRM_STOP_TIMESHIFT_FOR_MHEG))
			{
				DVBApp_DataApplicationSwitch(OSD2CTRLMDL_DISABLE | OSD2CTRLMDL_SUB);
				g_stUserInfoData.Subtitle = 0; //OFF
				AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_USERINFO,
								 ITEM_OFFSET(APP_SETTING_UserInfo_t, Subtitle),
								 sizeof(g_stUserInfoData.Subtitle), &(g_stUserInfoData.Subtitle));
				AL_Setting_Store(APP_Data_UserSetting_Handle(), SYS_SET_ID_USERINFO,
								 ITEM_OFFSET(APP_SETTING_UserInfo_t, Subtitle), sizeof(g_stUserInfoData.Subtitle));
				if (MID_REC_MODE_MANUAL == u8MIDRecMode)
				{
					DVBApp_StopRecord();
				}
				else if (MID_REC_MODE_TIMESHIFT_AFTER_REC == u8MIDRecMode)
				{
					DVBApp_StopTimeshift(TRUE);
				}
				else if (MID_REC_MODE_AUTO == u8MIDRecMode)
				{
					g_stFeatureData.AutoTimeShift = APP_PVR_TIMESHIFT_OFF;
					AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_FEATURE,
									 ITEM_OFFSET(APP_SETTING_Feature_t, AutoTimeShift),
									 sizeof(g_stFeatureData.AutoTimeShift), &(g_stFeatureData.AutoTimeShift));
					AL_Setting_Store(APP_Data_UserSetting_Handle(), SYS_SET_ID_FEATURE,
									 ITEM_OFFSET(APP_SETTING_Feature_t, AutoTimeShift), sizeof(g_stFeatureData.AutoTimeShift));
					DVBApp_StopTimeshift(TRUE);
				}
				DVBApp_DataApplicationSwitch(OSD2CTRLMDL_ENABLE | OSD2CTRLMDL_MH5);
			}
			else if (POPMSG_CONFIRM_INVALID_USB == dParam)
			{
				MAINAPP_SendGlobalEvent(UI_EVENT_POWER, AL_POWER_STATE_OFF);
			}
			else
#endif
#ifdef CONFIG_CONFIRM_AUTO_UPGRADE
			if (dParam == POPMSG_CONFIRM_START_AUTO_UPGRADE)
			{
				DVBApp_ResetPopup_Channel();//add for 0159405 @20111114
				if (!APP_MenuMgr_Exist_Main_Menu()
					&& (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_FM_FACTORYSETTING)))
				{
					_DVBApp_Exit_All_Menu();
					SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, APP_GUIOBJ_SOFTWARE_UPGRADE, SOFTWARE_UPGRADE_FROM_AUTO_UPGRADE);
				}
				else if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_SOFTWARE_UPGRADE))
				{
					SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, APP_GUIOBJ_SOFTWARE_UPGRADE, 0);
				}
			}
			else
#endif
#ifdef N32_GAME_SUPPORT
			if (dParam == POPMSG_CONFIRM_START_GAME_UPGRADE)
			{
				dvb_printf("\n!!!start ugrade game\n");
				_DVBApp_ShowPopup(DVB_APP_POP_MSG_IMPORTING_GAME);
				APP_Clone_Revert_BinFile_to_System(UPGRADE_GAME_BIN_ID);
			}
			else
#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();

//				APP_Panel_SetBacklightEnOnOff(FALSE);//makr for S2tek
//				MID_GPIO_SetGPIOOffLevel(GPIO_PANEL_ON_PIN);//makr for S2tek
//				system_reset();//makr for S2tek
			}
#ifdef CONFIG_SUPPORT_USB_UPGRADE
			if (POPMSG_CONFIRM_ERASE_WHOLE_FLASH == dParam)
			{
				if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_SOFTWARE_UPGRADE))
				{
					SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, APP_GUIOBJ_SOFTWARE_UPGRADE, SOFTWARE_UPGRADE_FROM_FM);
				}
			}
#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_DVB,
						//(APP_GLOBAL_EVENT_PVR_REMINDER_CONFIRM | PASS_TO_SYSAPP), 0);
			}
			else 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)
				{
					_DVBApp_ShowPopup(DVB_APP_POP_MSG_PVR_REMIDER);
				}
			}
			else if (dParam == POPMSG_CONFIRM_STOP_RECORD)
			{
				/*added by xm.zeng on 2014/7/3 for mantis id:0023174*/
				if((g_bNoSteamData == TRUE)
					&& (bSetUnMuteFlag == FALSE)
					&& (g_bMidHasUnmute == FALSE))
				{
					DVBApp_CheckProgramType(TRUE);
				}
			}
			if (dParam == POPMSG_CONFIRM_STOP_TIMESHIFT_FOR_SRC_CHANGE)
			{
				DVBApp_CheckProgramType(FALSE);
			}
			if (POPMSG_CONFIRM_INSERT_USB == dParam)
			{
				MAINAPP_SendGlobalEvent(UI_EVENT_POWER, AL_POWER_STATE_OFF);
			}
#endif
			if (dParam == POPMSG_CONFIRM_FLIP)
			{
				DVBApp_ClosePopup(POPMSG_CONFIRM_FLIP, UI_EVENT_NULL);
				SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_DVB,
						(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_DVB, APP_GUIOBJ_SOFTWARE_UPGRADE))
				//{
					//SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, APP_GUIOBJ_SOFTWARE_UPGRADE, SOFTWARE_UPGRADE_FROM_FM);
				//}
			}
#endif
#ifdef CONFIG_CONFIRM_AUTO_UPGRADE
			if (dParam == POPMSG_CONFIRM_START_AUTO_UPGRADE)
			{
				AutoUpgrade = FALSE;
				if (dLastFocusedIndex != DVB_GUIOBJ_POPMSG)
				{
					SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, dLastFocusedIndex, 0);

					if (dLastFocusedIndex == DVB_GUIOBJ_PROGINFO)
					{
						DVBApp_CheckProgramType(TRUE);
					}
					else
					{
						bHasValidServ = AL_DB_HasVisibleService(eNetType);
						if (bHasValidServ)
						{
							DVBApp_CheckProgramType(FALSE);
						}
					}
				}
				else
				{
					DVBApp_CheckProgramType(TRUE);
				}
			}
#endif
			break;

		case APP_GLOBAL_EVENT_POPMSG_TIMEOUT:
			switch (dParam)
			{
				default:
					break;
			}

			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_DVB,
						//(APP_GLOBAL_EVENT_PVR_REMINDER_CONFIRM | PASS_TO_SYSAPP), 0);
			}
#endif
#ifdef CONFIG_CONFIRM_AUTO_UPGRADE
			if (dParam == POPMSG_CONFIRM_START_AUTO_UPGRADE)
			{
				bHasValidServ = AL_DB_HasVisibleService(eNetType);
				AutoUpgrade = FALSE;
				if (bHasValidServ)
				{
					DVBApp_CheckProgramType(TRUE);
				}
			}
#endif
			break;
#ifdef CONFIG_SUPPORT_OTA_UPGRADE
		case DMN_EVENT_OTA_EVENT_PROMPT:
			if (APP_GUIOBJ_DVB_OTAPrompt_GetShowFlag() == OtaShowPromt_MAX || APP_GUIOBJ_DVB_OTAPrompt_GetShowFlag() == OtaShowPromt_FromScan)
			{
				dvb_printf("only one choice\n");
			}
			else
			{
				APP_GUIOBJ_DVB_OTAPrompt_SetShowFlag(OtaShowPromt_MAX);

				if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_OTA_UPGRADE_PROMPT))
				{
					if (FALSE == DVBApp_GetOTAStatus())
					{
						DVBApp_SetOTAStatus(TRUE);
					}
					_DVBApp_ExitAll();
					SYSAPP_IF_SendCriticalGlobalEventWithIndex(SYS_APP_DVB, APP_DVB_GLOBAL_EVENT_OBJECT_OPEN | PASS_TO_SYSAPP, DVB_GUIOBJ_OTA_UPGRADE_PROMPT);
					MID_OtaMonStop(TRUE);
				}
			}
			break;
		case DMN_EVENT_OTA_EVENT_PROGRESS:
			if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_OTA_UPGRADE_PROGRESS))
			{
				if(FALSE == DVBApp_GetOTAStatus())
				{
					DVBApp_SetOTAStatus(TRUE);
				}

				_DVBApp_ExitAll();
				SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PLAYBACK,
					APP_DVB_INTRA_EVENT_STOP_PLAYBACK, PLAYBACK_STOP_ALL|PLAYBACK_KEEP_DMX_FIFO);

				APP_Audio_SetMute(TRUE, FALSE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
				APP_Video_SetMute(TRUE, FALSE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);

				APP_GUIOBJ_DVB_OTAUpgrade_RegisterUICallbk();
#ifdef CONFIG_SUPPORT_SSU_ENHANCE_UPGRADE
				APP_GUIOBJ_DVB_OTAPrompt_RevTimer();   /*revert  wake up time in this situation*/
				DVBApp_SetAU_Sate(AU_MAX);
				DVBApp_SetAutoUpgrade(FALSE);
#endif
				SYSAPP_IF_SendCriticalGlobalEventWithIndex(SYS_APP_DVB, APP_DVB_GLOBAL_EVENT_OBJECT_OPEN | PASS_TO_SYSAPP, DVB_GUIOBJ_OTA_UPGRADE_PROGRESS);
			}
			break;
#endif

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

			if ((MAIN_APP_SUCCESS != MAINAPP_GetActiveSystemAppIndex(&dAppIndex))||
				(APP_MenuMgr_Exist_Scan_Menu()) ||
		#ifdef CONFIG_SUPPORT_USB_UPGRADE
				(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_SOFTWARE_UPGRADE)) ||
		#endif
				(AL_CS_IsStop() != al_true))
			{
				break;
			}
		#endif
			DVBApp_ResetPopup_Channel();
			_DVBApp_CloseAllMenu();

			if (SP_SUCCESS != APP_GUIOBJ_Source_SetAppSource(dParam))
			{
				dvb_printf("[DvbApp 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;
			}

			/* recording */
	/*#ifdef CONFIG_SUPPORT_PVR
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_POPMSG))
			{
				UINT32 u32PopMsgDialogType = POPMSG_PROMPT_NO_PROG;
				APP_GUIOBJ_PopMsg_GetMsgDialogType(&u32PopMsgDialogType);
				if (u32PopMsgDialogType == POPMSG_CONFIRM_REC_REMIDER_TIME
					|| u32PopMsgDialogType == POPMSG_CONFIRM_REC_REMIDER_TIME_CONFIRM)
				{
			#ifdef CONFIG_DVB_SYSTEM
					//APP_SCARTIN_ResetAutoPlugInStatus(AUTO_PLUGIN_SCART0);

					//clear SCART PlugInStatus for mantis 0204109
					APP_SCARTIN_SetAutoPlugInStatus(AUTO_PLUGIN_SCART0);
					APP_SCARTIN_SetPlugStatus(AUTO_PLUGIN_SCART0);
			#endif
					break;
				}
			}

			if (u8MidRecState != MID_REC_STATUS_STOP)
			{
		#ifdef CONFIG_DVB_SYSTEM
				//APP_SCARTIN_ResetAutoPlugInStatus(AUTO_PLUGIN_SCART0);

				//clear SCART PlugInStatus for mantis 0204109
				APP_SCARTIN_SetAutoPlugInStatus(AUTO_PLUGIN_SCART0);
				APP_SCARTIN_SetPlugStatus(AUTO_PLUGIN_SCART0);
		#endif
				break;
			}
	#endif*/

			if ((MAIN_APP_SUCCESS != MAINAPP_GetActiveSystemAppIndex(&dAppIndex))||
				(APP_MenuMgr_Exist_Scan_Menu()) ||
		#ifdef CONFIG_SUPPORT_USB_UPGRADE
				(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_SOFTWARE_UPGRADE)) ||
		#endif
				(AL_CS_IsStop() != al_true))
			{
		#ifdef CONFIG_DVB_SYSTEM
				APP_SCARTIN_ResetAutoPlugInStatus(AUTO_PLUGIN_SCART0);
		#endif
				break;
			}

			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_POPMSG))
            {
				UINT32 u32PopMsgDialogType = POPMSG_PROMPT_NO_PROG;
				APP_GUIOBJ_PopMsg_GetMsgDialogType(&u32PopMsgDialogType);
				if (u32PopMsgDialogType == POPMSG_CONFIRM_REC_REMIDER_TIME)
                {
                    break;
                }
            }
#ifdef CONFIG_SUPPORT_PVR
			if (MID_RecorderIsCurRecording() == DRV_SUCCESS)
            {
                break;
            }
#endif
			/* Check Valid state ---*/

			DVBApp_ResetPopup_Channel();
			_DVBApp_CloseAllMenu();
#ifdef CONFIG_SUPPORT_PVR
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_FILEPLAY))
		    {
		        SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PVR_FILEPLAY);
		    }
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_FILEPLAYINFO))
		    {
		        SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PVR_FILEPLAYINFO);
		    }
#endif
			if (SP_SUCCESS != APP_GUIOBJ_Source_SetAppSource(dParam))
			{
				dvb_printf("[DvbApp OnGlobalEvent] APP_GUIOBJ_Source_SetAppSource faild.\n");
			}
			else
			{
			}
			break;

		case APP_GLOBAL_EVENT_SLEEP_TIMER_INFO:
			if ((APP_MenuMgr_Exist_Scan_Menu())
#ifdef CONFIG_SUPPORT_USB_UPGRADE //zhongbaoxing added for mantis bug 139209 @20110623
				|| (APP_Data_Get_USB_Upgrade_State() == TRUE)
#endif
			   )
			{
				APP_GUIOBJ_SleepTimer_Reset();
			}
			else
			{
				_DVBApp_CloseAllMenu();
				DVBApp_ResetPopup_Channel();
				if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_SLEEP_INFO))
				{
					SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, APP_GUIOBJ_SLEEP_INFO, dParam);
				}
			}
			break;
		case APP_GLOBAL_EVENT_CIHDCPKEY_RESULT:

			 if (dParam == 0xffffffff)
			 	break;

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

			 if (u32CIupgrade && u32HDCPupgrade)
			 {
			 	// upgrade CI & HDCP
			 	if (u32CIupgrade == APP_DATA_KEYUPGRADE_SUCCESS)
				{
					if (u32HDCPupgrade == APP_DATA_KEYUPGRADE_SUCCESS)
					{
						// CI OK, HDCP OK
						_DVBApp_ShowPopup(DVB_APP_POP_MSG_CI_PASS_HDCP_PASS);
					}
					else
					{
						// CI OK, HDCP fail
						_DVBApp_ShowPopup(DVB_APP_POP_MSG_CI_PASS_HDCP_FAIL);
					}
				}
				else
				{
					if (u32HDCPupgrade == APP_DATA_KEYUPGRADE_SUCCESS)
					{
						// CI fail, HDCP OK
						_DVBApp_ShowPopup(DVB_APP_POP_MSG_CI_FAIL_HDCP_PASS);
					}
					else
					{
						// CI fail, HDCP fail
						_DVBApp_ShowPopup(DVB_APP_POP_MSG_CI_FAIL_HDCP_FAIL);
					}
				}
			 }
			 else if (u32CIupgrade != APP_DATA_KEYUPGRADE_NOT_UPGRADE)
			 {
				 _DVBApp_CloseAllMenu();
			 	// upgrade CI
			 	if (u32CIupgrade == APP_DATA_KEYUPGRADE_SUCCESS)
				{
				 	_DVBApp_ShowPopup(DVB_APP_POP_MSG_CIPLUSE_UPGRADE_SUCC);
				}
				else
				{
					_DVBApp_ShowPopup(DVB_APP_POP_MSG_CIPLUSE_UPGRADE_FAILE);
				}
			 }
			 else if (u32HDCPupgrade != APP_DATA_KEYUPGRADE_NOT_UPGRADE)
			 {
			 	// upgrade HDCP
			 	if (u32HDCPupgrade == APP_DATA_KEYUPGRADE_SUCCESS)
				{
					_DVBApp_ShowPopup(DVB_APP_POP_MSG_HDCP_UPGRADE_SUCC);
				}
				else
				{
					_DVBApp_ShowPopup(DVB_APP_POP_MSG_HDCP_UPGRADE_FAILE);
				}
			 }
			break;
#ifdef CONFIG_SUPPORT_3D_EN
		case UI_EVENT_3D:
			dvb_printf("\n\n===UI_EVENT_3D [%s]====\n\n",__FUNCTION__);
			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)
			{
				dvb_printf("[%s] Picture Option has been Lock On!!\n",__FUNCTION__);
				break;
			}
			APP_Video_Check3DState(&ePicture3DState);
			if(ePicture3DState == APP_VIDEO_IMAGE_3D_DISABLED)
			{
				if(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_3D_INFO))
				{
					SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, APP_GUIOBJ_3D_INFO);
				}
		        _DVBApp_ShowPopup(DVB_APP_POP_MSG_NOT_AVAILABLE);
	            break;			
			}
			if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_3D_INFO))
			{
				Boolean bShowLogo = DTV_FALSE;
				bShowLogo = APP_GUIOBJ_DVB_Playback_GetShowLogoState();
				AL_DB_ERecordType_t eRecordType;
				MID_PlaybackGetCurProgHandle(&eRecordType, al_null);
				if((eRecordType == AL_RECTYPE_DVBRADIO) || (bShowLogo == DTV_TRUE))
				{
					break;
				}
				_DVBApp_CloseAllMenu();
				if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_FREEZE))
				{
					SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_FREEZE);
				}				
				if (APP_GetPlaybackPauseState() == TRUE)
				{
					MID_PlaybackStreamResume(1);
					g_PauseState = FALSE;
				}
				
				SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, APP_GUIOBJ_3D_INFO, dMessage);
				dvb_printf("\n\n%s %d\n\n", __FUNCTION__, dMessage);
			}
			else
			{
				SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, 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(SYS_APP_DVB, APP_GUIOBJ_3D_INFO)) && (g_stPictureData.stPictureModeSourceTab[eStorageSourType].st3DMenu.Mode3D != SPAL_PQ_3DMODE_OFF))
			{
				Boolean bShowLogo = DTV_FALSE;
				bShowLogo = APP_GUIOBJ_DVB_Playback_GetShowLogoState();
				AL_DB_ERecordType_t eRecordType;
				MID_PlaybackGetCurProgHandle(&eRecordType, al_null);
				if((eRecordType == AL_RECTYPE_DVBRADIO) || (bShowLogo == DTV_TRUE))
				{
					break;
				}
				_DVBApp_CloseAllMenu();
				SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB,APP_GUIOBJ_3D_INFO, dParam);
			}
			break;
#endif

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

#ifdef CONFIG_HDMI_SUPPORT_MHL
		case DMN_EVENT_MHL_CHANGE_SOURCE:
			/* Check Valid state +++*/
			/* Auto install not finish */
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_INITINSTALL))
			{
				break;
			}
			/* Scan State */
			if (AL_CS_IsStop() != 1)
			{
				break;
			}
			/*
			** Channel Tuning,
			** Channel - Digital Manual Search,
			*/
			if ((SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_AUTO_SEARCH))
				|| (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_SCAN_PROCESS))
				|| (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_DVB_T_MANUAL_SEARCH))
			   )
			{
				break;
			}
#ifdef CONFIG_SUPPORT_PVR
			if (MID_RecorderIsCurRecording() == DRV_SUCCESS)
			{
				break;
			}
#endif

			DVBApp_ResetPopup_Channel();
			_DVBApp_CloseAllMenu();
			/* Check Valid state ---*/
			APP_Source_Type_t eMhlSrc;
			UINT8 IsMHLSoure;
			APP_GOBJ_Source_CheckAndGetMHLSource(&IsMHLSoure,&eMhlSrc);
			if (SP_SUCCESS != APP_GUIOBJ_Source_SetAppSource(eMhlSrc))
			{
				dvb_printf("[DvbApp OnGlobalEvent] APP_GUIOBJ_Source_SetAppSource faild.\n");
			}

			break;
#endif

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

			/* Auto install not finish */
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_INITINSTALL))
			{
				break;
			}
			/* Scan State */
			if (AL_CS_IsStop() != 1)
			{
				break;
			}
			/*
			** Channel Tuning,
			** Channel - Digital Manual Search,
			*/
			if ((SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_AUTO_SEARCH))
				|| (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_SCAN_PROCESS))
				|| (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_DVB_T_MANUAL_SEARCH))
			   )
			{
				break;
			}
#ifdef CONFIG_SUPPORT_PVR
			if (MID_RecorderIsCurRecording() == DRV_SUCCESS)
            {
                break;
            }
#endif
			/* Check Valid state ---*/

			DVBApp_ResetPopup_Channel();
			_DVBApp_CloseAllMenu();
			APP_Source_Type_t eSrc;
			APP_Video_GetCECPortMapping(dParam, &eSrc);
			if (SP_SUCCESS != APP_GUIOBJ_Source_SetAppSource(eSrc))
			{
				dvb_printf("[DvbApp OnGlobalEvent] APP_GUIOBJ_Source_SetAppSource faild.\n");
			}
			break;
#endif
#ifdef CONFIG_SUPPORT_PVR
		case DMN_EVENT_USB_HDD_ATTACHED:
		{
			int iPtListIdx = -1;
			DVBApp_SetBGTimeshift(PVR_BGTIMESHIFT_START_INTERVAL);
			dvb_printf("dvb has received DMN_EVENT_USB_HDD_ATTACHED\n\n\n\n");
			//if (MID_RecorderGetDefaultPartition(&iPtListIdx) != MID_REC_FS_OK)
			{
				if (APP_GUIOBJ_DVB_PartitionList_GetFirstFat(&iPtListIdx) == TRUE)
				{
					printf("set default partition\n\n");
					MID_RecorderSetDefaultPartition(iPtListIdx, MID_REC_PARTITION_SET_FORCE); 
				}
			}
			#if 0
			if (!APP_MenuMgr_Exist_Main_Menu())
			{
				_DVBApp_ShowPopup(DVB_APP_POP_MSG_INSERT_USB);
			}
			#endif
			break;
		}
		case DMN_EVENT_USB_HDD_DETACHED:
		{
			int i;
			int MountCount;
			char DefPartitionName[5];
			char AttchPartitionName[5];
			Boolean HaveDefPartition = FALSE;
			int devicelen = 4;
			MountCount = MID_PartitionList_GetMountedCount();
			APP_GUIOBJ_DVB_PartitionList_ClearPartitionInfo();
			if (MountCount == 0 && !SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_POPMSG))
			{
				_DVBApp_ShowPopup(DVB_APP_POP_MSG_PVR_NO_STORAGE);
			}

			if (MID_RecorderIsCurRecording() == DRV_SUCCESS)
			{
				strncpy(DefPartitionName, (char *)(MID_RecorderGetRecordingCwd()+5), devicelen);
			}
			else
			{
				char DefPartition[15];
				int iPtListIdx;
				if (MID_RecorderGetDefaultPartition(&iPtListIdx) != MID_REC_FS_OK)
				{
					iPtListIdx = 0; //set partition 0 for default partition
				}

				MID_PartitionList_GetMountName(0, DefPartition);
				strncpy(DefPartitionName, (char *)(DefPartition+5),devicelen);
			}
			int j;
			for (j = 0; j < devicelen; j++ )
			{
				if (DefPartitionName[j] == '/')
				{
					DefPartitionName[j] = '\0';
				}
			}

			for (i=0; i < MountCount; i++)
			{
				strncpy(AttchPartitionName, (char *)(MID_PartitionList_GetDevName(i)+5), devicelen );
				for (j = 0; j < devicelen; j++ )
				{
					if (AttchPartitionName[j] == '/')
					{
						AttchPartitionName[j] = '\0';
					}
				}

				//printf("AttchPartitionName is %s, DefPartitionName is %s\n",AttchPartitionName,DefPartitionName);

				if (strncmp(DefPartitionName, AttchPartitionName, devicelen) == 0)
				{
					//printf("----------------------------------------------		%d\n",__LINE__);
					HaveDefPartition = TRUE;
					break;
				}
			}
			if (HaveDefPartition == FALSE)
			{
				//printf("----------------------------------------------		%d\n",__LINE__);
				if (MID_REC_MODE_MANUAL == u8MIDRecMode || MID_REC_MODE_UNATTENDED == u8MIDRecMode)
				{
					DVBApp_StopRecord();
				}
				else if ((MID_REC_MODE_TIMESHIFT_AFTER_REC == u8MIDRecMode) ||
						 (MID_REC_MODE_AUTO == u8MIDRecMode))
				{
					DVBApp_StopTimeshift(TRUE);
				}

				if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_FILEPLAY))
				{
					if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_MULTIAUD))
					{
						SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PVR_MULTIAUD);
					}
					SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PVR_FILEPLAY);
				}
				DVBApp_SetBGTimeshift(0);
				MID_TSPLParser_Init("NULL");	//for mantis 0150969, set the wrong szPtName to reset the g_sdPltCnt
				MID_RecorderRefreshDefaultPartition();
			}


			break;
		}
		case DMN_EVENT_DVB_RECORDER_GFS_OK:
			{
				INT32 dFocusedIndex;
				if (SYSTEM_APP_NO_FOCUSED_GUIOBJ == SYSAPP_GOBJ_GetFocusedGUIObject(SYS_APP_DVB, &dFocusedIndex))
				{
					_DVBApp_ShowPopup(DVB_APP_POP_MSG_PVR_PARTITION_SET_SUCCESSFUL);
				}
			}
			break;
#endif

#ifdef CONFIG_SUPPORT_USB_UPGRADE
		case APP_GLOBAL_EVENT_USB_UPGRADE:
			{
				UINT32 dActiveSysApp = TOTAL_SYS_APP_SIZE;
				unsigned int dIndex;
				MAINAPP_GetActiveSystemAppIndex(&dIndex);

				if (MAINAPP_GetActiveSystemAppIndex(&dActiveSysApp) != MAIN_APP_SUCCESS)
				{
					break;
				}

				if (dActiveSysApp != SYS_APP_DVB)
				{
					break;
				}

#ifdef SUPPORT_FACTORY_AUTO_TEST
				if(APP_Factory_GetUpgradeandAutoTestFlag() == TRUE)
				{
					AutoUpgrade = TRUE;
					_DVBApp_Exit_All_Menu();
					DVBApp_ResetPopup_Channel();//add for 0159405 @20111114
					if(dParam==1)
					{
						SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_DVB, APP_GLOBAL_EVENT_ERASE_WHOLE_FLASH|PASS_TO_SYSAPP, 0);
					}
					else
					{
						SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, APP_GUIOBJ_SOFTWARE_UPGRADE, SOFTWARE_UPGRADE_FROM_AUTO_UPGRADE);
					}
					break;
				}
#endif
				if(dParam==1)//from fm
				{
					SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_DVB, APP_GLOBAL_EVENT_ERASE_WHOLE_FLASH|PASS_TO_SYSAPP, 0);
					break;
				}

				if (AL_CS_IsStop() == FALSE)
				{
					break;
				}
			}

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

				_DVBApp_Exit_All_Menu();
				DVBApp_ResetPopup_Channel();//add for 0159405 @20111114
				AutoUpgrade = TRUE;
#if defined(CONFIG_CONFIRM_AUTO_UPGRADE)
				if(FALSE == gUSBUpgradeBinIsSupperBin)
				{
					SYSAPP_GOBJ_GetLastFocusedGUIObject(SYS_APP_DVB,&dLastFocusedIndex);
					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;
					DVBApp_SchedulePopup(stPopup);
				}
				else
#endif
				{
					SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, APP_GUIOBJ_SOFTWARE_UPGRADE, SOFTWARE_UPGRADE_FROM_AUTO_UPGRADE);
				}
			}
			break;
#endif

#ifdef N32_GAME_SUPPORT
			case APP_GLOBAL_EVENT_GAME_UPGRADE:
				if (!APP_MenuMgr_Exist_Main_Menu()
					&& !(APP_MenuMgr_Exist_Factory_Menu()))
				{
					_DVBApp_Exit_All_Menu();
					if(dParam == 0)
					{
						dvb_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;
						DVBApp_SchedulePopup(stPopup);
					}
					else
					{
						dvb_printf("\n!!!show popmsg not enough size to upgrade game\n");
						_DVBApp_ShowPopup(DVB_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;
			DVBApp_SchedulePopup(stPopup);
			break;
#ifdef CONFIG_SUPPORT_USB_UPGRADE
		case APP_GLOBAL_EVENT_ERASE_WHOLE_FLASH:
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_FM_FACTORYSETTING))
			{
				SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, 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;
			DVBApp_SchedulePopup(stPopup);
			break;
#endif
		case APP_GLOBAL_EVENT_KEYLOCK:
			_DVBApp_ShowPopup(DVB_APP_POP_MSG_KEYLOCK);
			break;
		case APP_GLOBAL_EVENT_OVER_MAXVOLUME:
			_DVBApp_ShowPopup(DVB_APP_POP_MSG_OVERMAXVOLUME);
			break;
#ifdef SUPPORT_SFU_AUTO_TEST
		case APP_DVB_GLOBAL_EVENT_SET_RF_TYPE:
			SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_DVB, UI_EVENT_RETURN, 0);
			APP_GUIOBJ_Channel_SetRFType(dParam, AL_DB_INVALIDHDL);
			APP_Console_TO_SUF_Respond(CON_TO_SUF_ACK);
#if 0
			extern void Enable_Debug_Message(UINT32 DBGStatus);
			Enable_Debug_Message(1<<MODULEID_UMF);
			dvb_printf("ACK\n");
			Enable_Debug_Message(0);
#endif
			break;
#endif
#ifdef SUPPORT_ATS
		case APP_DVB_GLOBAL_EVENT_ATS_SET_RF_TYPE:
			SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_DVB, UI_EVENT_RETURN, 0);
			APP_GUIOBJ_Channel_SetRFType(dParam, AL_DB_INVALIDHDL);
			break;
		case APP_DVB_GLOBAL_EVENT_ATS_GET_DEMODINFO_ON:
			uGetDemodinfoOn = 1;
			APP_ATS_Get_Demodinfo_On();
			break;
		case APP_DVB_GLOBAL_EVENT_ATS_GET_DEMODINFO_OFF:
			uGetDemodinfoOn = 0;
			break;
#endif
		case UI_EVENT_MultiPanelIndex:
#ifdef SUPPORT_FACTORY_AUTO_TEST
			if (APP_Factory_GetAutoTestOnOff() == TRUE)
			{
				if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_FM_FACTORYSETTING))
				{
					DVBApp_ResetPopup_Channel();
        			_DVBApp_CloseAllMenu();
					SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, APP_GUIOBJ_FM_FACTORYSETTING, 1);
					Factory_Ver_Debug();
				}
				else
				{
					SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, APP_GUIOBJ_FM_FACTORYSETTING);
				}
			}
			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;
			}
			break;

#if (defined(SUPPORT_FACTORY_AUTO_TEST)||defined(SUPPORT_FACTORY_AUTO_TEST_MODE2))
		case UI_EVENT_ERASE_HDCP:
		case UI_EVENT_ERASE_CIKEY:
		case UI_EVENT_FAC_HDCP_CHECK:
		case UI_EVENT_FAC_CIPLUSKEY_CHECK:
		case UI_EVENT_FAC_HDCP_UPDATE:
		case UI_EVENT_FAC_CIPLUSKEY_UPDATE:
			APP_CIPLUS_HDCP_Key_Action_Function(dMessage);
			break;
		case UI_EVENT_AUTO_TEST_ON:
		case UI_EVENT_AUTO_TEST_OFF:
			APP_Factory_Event_Action_Function(dMessage);
			break;

		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);
				DVBApp_ClearStatus();
				SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PLAYBACK,
					APP_DVB_INTRA_EVENT_STOP_PLAYBACK, PLAYBACK_STOP_ALL);
				//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
#if 0
        case FW_DB_LOAD_DEFAULT:
            dvb_printf("[%s]FW_DB_LOAD_DEFAULT received.\n", __FUNCTION__);
#ifdef CONFIG_DVB_SYSTEM_DVBS_SUPPORT
			if (AL_DBTYPE_DVB_S == APP_DVB_Playback_GetCurrentNetType())
			{
				/* wait for DVB-S becomes acticve */
				while(AL_FW_CheckActiveDBModule(AL_DBTYPE_DVB_S) != al_true);

				DVBApp_LoadCustomerDB(AL_DBTYPE_DVB_S);
			}
#endif
			break;
#endif
#ifdef CONFIG_SUPPORT_EWS
		case FW_EWS_FIND_AUD:
			if (dParam != 0)
			{
				memset(&g_PrevAudioPid, 0, sizeof(DBPIDInfo_t));
				g_PrevAudioPid.usDataPID = DB_DVB_INVALID_PID;
				memset(&g_MonAudioPid, 0, sizeof(DBPIDInfo_t));
				g_MonAudioPid.usDataPID = DB_DVB_INVALID_PID;
				memcpy(&g_MonAudioPid, (DBPIDInfo_t *)dParam, sizeof(DBPIDInfo_t));
				DMIOC_SET_EWS_PARAM stEwsParam;
				memset(&stEwsParam, 0, sizeof(DMIOC_SET_EWS_PARAM));
				stEwsParam.bActive = FALSE;
				ioctl(dtvdev, DTV_IOCTL_Set_EWS_Data  , &stEwsParam);
				memset(&stEwsParam, 0, sizeof(DMIOC_SET_EWS_PARAM));
				stEwsParam.bActive = TRUE;
				stEwsParam.clear_ews_flag = TRUE;
				stEwsParam.PID = g_MonAudioPid.usDataPID;
				dvb_printf("\n\n[%s]FW_EWS_FIND_AUD!!!!!!!, curr time: 0x%x\n\n", __FUNCTION__,GL_GetRtc32());
				ioctl(dtvdev, DTV_IOCTL_Set_EWS_Data  , &stEwsParam);
				g_EWSMode = TRUE;
				GL_MemFree((DBPIDInfo_t *)(dParam));
				dParam = 0;
			}
			break;
		case FW_EWS_ACTIVE:
			dvb_printf("\n\n[%s]FW_EWS_ACTIVE!!!!!!!, curr time: 0x%x\n\n", __FUNCTION__,GL_GetRtc32());
			{
				dvbpsi_anouncement_t stAnoumceData;
				AL_Serv_SearchKey_t stSearchKey;
				AL_RecHandle_t hProgHdl;
				AL_RecHandle_t hTpHdl;
				AL_RecHandle_t hCurrTpHdl;
				UINT32 u32Param = 0;
				DMIOC_SET_EWS_PARAM stEwsParam;

				memset(&stAnoumceData, 0, sizeof(dvbpsi_anouncement_t));
				memset(&stSearchKey, 0, sizeof(stSearchKey));
				AL_EWS_Monitor_GetData(&stAnoumceData);

				stSearchKey.u16OrigNetId = stAnoumceData.original_network_id;
				stSearchKey.u16TsId = stAnoumceData.transport_stream_id;
				stSearchKey.u16ServId = stAnoumceData.service_id;
				stSearchKey.eDBType = eNetType;
				stSearchKey.eRecType = AL_RECTYPE_DVBSERVICE;
				stSearchKey.eSearchField = AL_SRV_SEARCHFIELD_ORIGNETID
								| AL_SRV_SEARCHFIELD_TSID
								| AL_SRV_SEARCHFIELD_SRVID;
				if (AL_SUCCESS == AL_DB_GetMatchedRecord((AL_DB_RecordMatchFunc)AL_Serv_MatchRecBySearchKey,
					(al_void *)&stSearchKey, eNetType, AL_RECTYPE_DVBSERVICE, AL_DB_REQ_GETFIRST, &hProgHdl))
				{
					MID_PlaybackGetCurProgHandle(al_null, &hCurrProgHandle);
					if ((hCurrProgHandle != hProgHdl) && (hProgHdl != AL_DB_INVALIDHDL))
					{
						g_NonClearEWS = TRUE;
						if ((g_MonAudioPid.usDataPID != DB_DVB_INVALID_PID) && (g_PrevAudioPid.usDataPID == DB_DVB_INVALID_PID))
						{
							g_PrevAudioPid.usDataPID = MID_PlaybackGetActiveAudHandle(TRUE);
							g_PrevAudioPid.usCodec = MID_PlaybackGetActiveAudCodec();
						}

						memset(&stEwsParam, 0, sizeof(DMIOC_SET_EWS_PARAM));
						stEwsParam.bActive = FALSE;
						ioctl(dtvdev, DTV_IOCTL_Set_EWS_Data  , &stEwsParam);

						_DVBApp_Zapping(eServiceType, hProgHdl, TRUE, 0, TRUE);
						g_PrevProgHandle = hCurrProgHandle;

						hCurrTpHdl = hCurrProgHandle;
						hTpHdl = hProgHdl;
						if ((AL_SUCCESS == AL_DB_GetRecord(AL_DB_REQ_GETPARENT, eNetType, AL_RECTYPE_DVBMULTIPLEX, &hCurrTpHdl))
							&& (AL_SUCCESS == AL_DB_GetRecord(AL_DB_REQ_GETPARENT, eNetType, AL_RECTYPE_DVBMULTIPLEX, &hTpHdl))
							&& (hCurrTpHdl != AL_DB_INVALIDHDL) && (hTpHdl != AL_DB_INVALIDHDL) && (hCurrTpHdl != hTpHdl))
						{
							dvb_printf("[%s:%d] different tp, not need change audio pid !!!!!!!!!!!!!!!!!!!!!\n",__FUNCTION__,__LINE__);
							memset(&stEwsParam, 0, sizeof(DMIOC_SET_EWS_PARAM));
							stEwsParam.bActive = TRUE;
							stEwsParam.PID = g_MonAudioPid.usDataPID;
							ioctl(dtvdev, DTV_IOCTL_Set_EWS_Data  , &stEwsParam);
						}
						else if (g_MonAudioPid.usDataPID != DB_DVB_INVALID_PID)
						{
							u32Param = g_MonAudioPid.usCodec<<16|g_MonAudioPid.usDataPID;
							MID_PlaybackChangePid(MID_PLAYBK_CHANGE_AUDPID, u32Param);
							memset(&stEwsParam, 0, sizeof(DMIOC_SET_EWS_PARAM));
							stEwsParam.bActive = TRUE;
							stEwsParam.PID = g_MonAudioPid.usDataPID;
							ioctl(dtvdev, DTV_IOCTL_Set_EWS_Data  , &stEwsParam);
						}
						g_NonClearEWS = FALSE;
					}
					else if ((hCurrProgHandle == hProgHdl) && (hProgHdl != AL_DB_INVALIDHDL))
					{
						if ((g_MonAudioPid.usDataPID != DB_DVB_INVALID_PID) && (g_PrevAudioPid.usDataPID == DB_DVB_INVALID_PID))
						{
							g_PrevAudioPid.usDataPID = MID_PlaybackGetActiveAudHandle(TRUE);
							g_PrevAudioPid.usCodec = MID_PlaybackGetActiveAudCodec();
							u32Param = g_MonAudioPid.usCodec<<16|g_MonAudioPid.usDataPID;
							MID_PlaybackChangePid(MID_PLAYBK_CHANGE_AUDPID, u32Param);
						}
					}
				}

			}
			break;
		case FW_EWS_INACTIVE:
			dvb_printf("\n\n[%s]FW_EWS_INACTIVE!!!!!!!, g_PrevProgHandle: 0x%x, curr time: 0x%x\n\n", __FUNCTION__,g_PrevProgHandle, GL_GetRtc32());
			{
				DMIOC_SET_EWS_PARAM stEwsParam;
				UINT32 u32Param = 0;
				memset(&stEwsParam, 0, sizeof(DMIOC_SET_EWS_PARAM));
				stEwsParam.bActive = FALSE;
				ioctl(dtvdev, DTV_IOCTL_Set_EWS_Data  , &stEwsParam);
				g_EWSMode = FALSE;
				g_NonClearEWS = TRUE;
				if (g_PrevProgHandle != AL_DB_INVALIDHDL)
				{
					_DVBApp_Zapping(eServiceType, g_PrevProgHandle, TRUE, 0, TRUE);
					g_PrevProgHandle = AL_DB_INVALIDHDL;
				}

				if (g_PrevAudioPid.usDataPID != DB_DVB_INVALID_PID)
				{
					u32Param = g_PrevAudioPid.usCodec<<16|g_PrevAudioPid.usDataPID;
					MID_PlaybackChangePid(MID_PLAYBK_CHANGE_AUDPID, u32Param);
					memset(&g_PrevAudioPid, 0, sizeof(DBPIDInfo_t));
					g_PrevAudioPid.usDataPID = DB_DVB_INVALID_PID;
				}
				g_NonClearEWS = FALSE;
				memset(&stEwsParam, 0, sizeof(DMIOC_SET_EWS_PARAM));
				stEwsParam.clear_ews_flag = true;
				stEwsParam.bActive = TRUE;
				stEwsParam.PID = g_MonAudioPid.usDataPID;
				ioctl(dtvdev, DTV_IOCTL_Set_EWS_Data  , &stEwsParam);
			}
			break;
		case FW_EWS_NON_ANCM:
			dvb_printf("\n\n[%s]FW_EWS_NON_ANCM!!!!!!!, curr time: 0x%x\n\n", __FUNCTION__, GL_GetRtc32());
			{
				DMIOC_SET_EWS_PARAM stEwsParam;
				memset(&stEwsParam, 0, sizeof(DMIOC_SET_EWS_PARAM));
				stEwsParam.bActive = FALSE;
				ioctl(dtvdev, DTV_IOCTL_Set_EWS_Data  , &stEwsParam);
				DVBApp_ResetEWS();
			}
			break;
#endif

		default:
			dvb_printf("[%s] Unknown message 0x%x received.\n", __FUNCTION__, dMessage);
			break;
	}

	return 0;
}



static INT32 _DVBApp_OnGUIFeedbackEvent(void *pPrivateData, UINT32 dMessage, UINT32 dParam)
{
	al_uint8 bSignalState = al_false;
    AL_DB_EDBType_t eNetType = APP_DVB_Playback_GetCurrentNetType();
	AL_DB_ERecordType_t eServiceType = APP_DVB_Playback_GetCurrServiceType(eNetType);
#ifdef CONFIG_SUPPORT_PVR
    UINT8 u8MidRecState;
    UINT8 u8MIDRecMode;
    u8MidRecState = MID_RecorderState();
    u8MIDRecMode = MID_Recorder_GetRecMode();
#endif

    switch (dMessage)
    {
        case GUI_RESPOND_ZAPPING:
			{
	            AL_RecHandle_t NextHdl = dParam;
	            _DVBApp_CloseAllMenu();
	            if (NextHdl != AL_DB_INVALIDHDL)
	            {
	                _DVBApp_Zapping(eServiceType, NextHdl, FALSE, 0, TRUE);
	            }
	        }
            break;

        case GUI_RESPOND_EXIT_ALL_MENU:
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_SLEEP_INFO))
			{
				if(APP_GUIOBJ_SleepTimer_GetOpenStandby() == al_true)
				{
					_DVBApp_Exit_All_Menu();
					if(APP_GUIOBJ_SleepTimer_GetSleepPopConflict() == TRUE)
					{
						APP_GUIOBJ_SleepTimer_SetSleepPopConflict(FALSE);
						SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_DVB,
								(APP_GLOBAL_EVENT_SLEEP_TIMER_INFO|PASS_TO_SYSAPP), APP_POWERDOWN_SLEEP);
					}
				}
				else
				{
					_DVBApp_Exit_All_Menu();
					AL_DVB_Monitor_GetState(AL_DVB_MONITOR_STATE_SIGNAL, &bSignalState);
					if((bSignalState != AL_DVB_MONITOR_VALUE_TRUE)&&(APP_GUIOBJ_SleepTimer_GetStandbyPopConflict() == TRUE))
					{
						APP_GUIOBJ_SleepTimer_SetStandbyPopConflict(FALSE);
						SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_DVB,
		                    	(APP_GLOBAL_EVENT_SLEEP_TIMER_INFO | PASS_TO_SYSAPP), APP_POWERDOWN_NO_SINGAL);
					}
				}
			}
			else
			{
        		_DVBApp_Exit_All_Menu();
			}
            break;
#ifdef CONFIG_SUPPORT_PVR
        case GUI_RESPOND_REC_DURATIONTIME_EXIT:
            if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_RECDURATIONTIME))
            {
                SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PVR_RECDURATIONTIME);
            }
            break;
        case GUI_RESPOND_PVRPLAY_TO_GOTO:
            PVR_DEBF("goto is enter!!1\n");
            SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PVR_GOTO);
            SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO, dMessage, 0);
            break;
		case GUI_RESPOND_PVRFILEPLAY_ERROR:
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_FILEPLAY))
			{
				SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PVR_FILEPLAY);
			}
			break;
        case GUI_RESPOND_CLOSE_PVRINFO:
            if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVRREC_INFO))
			{
				SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PVRREC_INFO);
			}
            break;
        case GUI_RESPOND_CLOSE_PLAYINFO:
            if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO))
			{
				SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO);
			}
            break;
        case GUI_RESPOND_PVRINFO_FROMEXTENDINFO:
            if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PROGINFO))
            {
                SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PROGINFO);
            }
            if (u8MidRecState != MID_REC_STATUS_STOP)
            {
                if (u8MIDRecMode == MID_REC_MODE_TIMESHIFT_AFTER_REC)
                {
                    SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB,
                        DVB_GUIOBJ_PVR_PLAYINFO, PVR_PLAYINFO_ENTERNOTIMEMENU);
                }
                else if ((u8MIDRecMode == MID_REC_MODE_AUTO)
                            && (MID_TSPLParser_GetThreadState() == TRUE))
                {
                    SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB,
                        DVB_GUIOBJ_PVR_PLAYINFO, PVR_PLAYINFO_ENTERNOTIMEMENU);
                }
                else if ((u8MIDRecMode == MID_REC_MODE_MANUAL)
                            && (u8MidRecState == MID_REC_STATUS_START))
                {
                    SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, DVB_GUIOBJ_PVR_REC, 0);
#ifdef SUPPORT_PVR_RECORD_PLAY_CURRENTRECORD
                    if((DVBAPP_Pvr_GetRECPlayFlag())
                        && (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO)))
                    {
                        SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO,
                            PVR_PLAYINFO_ENTERNOTIMEMENU);
                    }
#endif
                }
                else if (u8MidRecState == MID_REC_STATUS_PAUSE)
                {
                    SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, DVB_GUIOBJ_PVR_PAUSE, 0);
#ifdef SUPPORT_PVR_RECORD_PLAY_CURRENTRECORD
                    if((DVBAPP_Pvr_GetRECPlayFlag())
                        && (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO)))
                    {
                        SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO,
                            PVR_PLAYINFO_ENTERNOTIMEMENU);
                    }
#endif
                }
                SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB,
                    DVB_GUIOBJ_PVRREC_INFO, 0);
            }

           break;
#endif

        default:
            dvb_printf("[%s] Unknown message received.\n", __FUNCTION__);
            break;
    }

    return 0;
}

static INT32 _DVBApp_OnEvent(void *pPrivateData, UINT32 dMessage, UINT32 dParam)
{
    switch (dMessage & GUIOBJ_MESSAGE_TYPE_MASK)
    {
        case SYSAPP_GLOBAL_EVENT_TYPE:
            _DVBApp_OnGlobalEvent(pPrivateData, (dMessage & GUIOBJ_MESSAGE_MASK), dParam);
            break;
        case GUIOBJ_FEEDBACK_EVENT_TYPE:
            _DVBApp_OnGUIFeedbackEvent(pPrivateData, (dMessage & GUIOBJ_MESSAGE_MASK), dParam);
            break;
        default:
            dvb_printf("[%s] Unknown message 0x%x received.\n", __FUNCTION__, dMessage);
            break;
    }
    return 0;
}

INT32 _DVBApp_DataApplicationStatus(UINT32 u32module)
{
    int iret = DATA_APP_UNSTABLE;
    UINT8 u8ProgState = MID_PLAYBK_PROG_STATE_NORMAL;
#ifdef CONFIG_SUPPORT_ISDB_SUBTITLE
	UINT8 onoff = 0;
	UINT32 GetSUBTotalNum = 0;
	AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_SETUP, 0,
		sizeof(APP_SETTING_Setup_t), &(g_stSetupData));
	onoff = g_stSetupData.DTVCCMode;
#endif
    switch (u32module & OSD2CTRLMDL_ALL)
    {
		case OSD2CTRLMDL_SUB:
#ifdef CONFIG_SUPPORT_ISDB_SUBTITLE
			if (AL_SBSUB_GetTotalNum(&GetSUBTotalNum) == AL_SUCCESS)
			{
				if(GetSUBTotalNum > 0)
				{
					iret |= DATA_APP_LANUCHABLE;
				}
			}
			else
			{
				iret |= DATA_APP_NOT_FOUND;
			}

			if (iret & DATA_APP_LANUCHABLE)
			{
				if (onoff == TRUE)
				{
					iret |= DATA_APP_EXECUTABLE;
				}
			}
#endif
			break;
    	
        default:
            dvb_printf("%s(): unknow module index\n", __FUNCTION__);
            break;
    }

#ifdef CONFIG_SUPPORT_PVR
	if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_FILEPLAY))
#endif
	{
		u8ProgState = APP_DVB_Playback_GetProgStateByHandle(APP_DVB_Playback_GetCurrentNetType(), AL_DB_INVALIDHDL);

		if (u8ProgState == MID_PLAYBK_PROG_STATE_LOCKED)
		{
		iret &= ~DATA_APP_EXECUTABLE;
		}
	}


    return iret;
}

static INT32 _DVBApp_DataApplicationGuiObjectRefresh(UINT32 gui_object_selection)
{
	int ret = 0;

	if (gui_object_selection & OSD2CTRLMDL_SUB)
	{
#ifdef CONFIG_SUPPORT_ISDB_SUBTITLE

        if (gui_object_selection & OSD2CTRLMDL_ENABLE)
        {
			if(!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_CC))
			{
	            {
					SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, DVB_GUIOBJ_CC, 0);
	            }
			}
			else if(AL_SBSUB_GetStartFlag() != AL_SUCCESS)
			{
				SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_DVB,
					DVB_GUIOBJ_CC, APP_GLOBAL_EVENT_CC_RESTART, 0);
			}
        }
		else if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_CC)
			&& (gui_object_selection & OSD2CTRLMDL_DISABLE))
		{
			SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_CC);
		}
#endif
	}
	return ret;
}

/*****************************************************************************
** FUNCTION : DVBApp_GetScrambleState
**
** DESCRIPTION :
**				get current program scramnle attrib
**
** PARAMETERS :
**				none
**
** RETURN VALUES:
**				TRUE  -  SCRAMBLE ATTRIB
**				FALSE  -  UN SCRAMBLE ATTRIB
*****************************************************************************/
Boolean DVBApp_GetScrambleAttrib(void)
{
    DBServAttrib_t stProgAttrib;
    AL_DB_EDBType_t DBType = AL_DBTYPE_DVB_SBTVD;
    AL_RecHandle_t hProg = AL_DB_INVALIDHDL;

    DBType = APP_DVB_Playback_GetCurrentNetType();
    hProg = APP_DVB_Playback_GetCurrentProgHandle(DBType, AL_RECTYPE_DVBTV | AL_RECTYPE_DVBRADIO);
	memset(&stProgAttrib, 0, sizeof(DBServAttrib_t));
	AL_DB_QueryDetailFieldByName(hProg, (al_uint8 *)"stProgAttrib", (al_void *)&stProgAttrib);

    if (stProgAttrib.scramble == al_true)
    {
        return TRUE;
    }
    else
    {
        return FALSE;
    }
}

/*****************************************************************************
** FUNCTION : DVBApp_CheckServiceNotAvailable
**
** DESCRIPTION :
**				Check current program state is not available or not
**
** PARAMETERS :
**				none
**
** RETURN VALUES:
**				TRUE  -  service not available
**				FALSE  -  not service not available
*****************************************************************************/
Boolean DVBApp_CheckServiceNotAvailable(void)
{
	MID_PlaybackProgState_t eProgState = MID_PLAYBK_PROG_STATE_NORMAL;
	AL_RecHandle_t hCurrPrgHdl = AL_DB_INVALIDHDL;
	AL_DB_EDBType_t eDBType = APP_DVB_Playback_GetCurrentNetType();
	al_uint8 bSignalState = AL_DVB_MONITOR_VALUE_INVAILED;

	AL_DVB_Monitor_GetState(AL_DVB_MONITOR_STATE_SIGNAL,&bSignalState);

	if (g_bNoSteamData == TRUE)
	{
#ifdef CONFIG_SUPPORT_MHEG5
		if ((APP_Area_SupportDtg())
			&& (APP_DVB_Mheg5_GetBootCarouselStatus() == MHEG5_BOOT_CAROUSEL_EXISTED))
		{
			return FALSE;
		}
		else
#endif
#ifdef CONFIG_CIPLUS_SUPPORT
		if (MID_DTVCI_GetAppMMIStatus())
		{
			return FALSE;
		}
		else
#endif
		{
			hCurrPrgHdl = APP_DVB_Playback_GetCurrentProgHandle(eDBType, (AL_RECTYPE_DVBTV |AL_RECTYPE_DVBRADIO));

			if ((hCurrPrgHdl == AL_DB_INVALIDHDL) && (bSignalState != AL_DVB_MONITOR_VALUE_INVAILED))
			{
				dvb_printf("Get current program handle error!!!\n");
				return TRUE;
			}

			eProgState = APP_DVB_Playback_GetProgStateByHandle(eDBType, hCurrPrgHdl);
			if ((eProgState == MID_PLAYBK_PROG_STATE_NOT_RUNNING) && (bSignalState != AL_DVB_MONITOR_VALUE_INVAILED))
			{
				return TRUE;
			}
			if ((eProgState != MID_PLAYBK_PROG_STATE_LOCKED) && (bSignalState != AL_DVB_MONITOR_VALUE_INVAILED))
			{
				return TRUE;
			}
			else
			{
				return FALSE;
			}
		}
	}

	return FALSE;
}

/*****************************************************************************
** FUNCTION : DVBApp_CheckProgramType
**
** DESCRIPTION :
**				Check program lock or temp sevice or vedio mpeg4 and so on
**
** PARAMETERS :
**				bInit  -  program state dispose
**
** RETURN VALUES:
**				SP_ERR_FAILURE  -  can not playback
**				SP_SUCCESS  -  playback
*****************************************************************************/
INT32 DVBApp_CheckProgramType(Boolean bFlag)
{
	AL_DB_EDBType_t eNetType = APP_DVB_Playback_GetCurrentNetType();
	AL_DB_ERecordType_t eServiceType = APP_DVB_Playback_GetCurrServiceType(eNetType);
	INT16 i16ProgState = MID_PLAYBK_PROG_STATE_NORMAL;
	al_uint8 bMonitorState = al_false;
	al_uint8 bSignalState = al_false;
	UINT8 u8Mute = 0;
	INT32 i32Ret = SP_ERR_FAILURE;
	APP_Source_Type_t eSourType = APP_SOURCE_MAX;
	al_bool bHasValidServ = al_false;

	bHasValidServ = AL_DB_HasVisibleService(eNetType);

	APP_GUIOBJ_Source_GetCurrSource(&eSourType);
	i16ProgState = APP_DVB_Playback_GetProgStateByHandle(APP_DVB_Playback_GetCurrentNetType(), AL_DB_INVALIDHDL);
	AL_DVB_Monitor_GetState(AL_DVB_MONITOR_STATE_MONITOR, &bMonitorState);
	AL_DVB_Monitor_GetState(AL_DVB_MONITOR_STATE_SIGNAL, &bSignalState);
	
	printf("\n @@@@@@@@@@@@@dvb_app.c i16ProgState=%d bMonitorState=%d,  bSignalState=%d, bHasValidServ=%d, line=%d \n",i16ProgState,bMonitorState,bSignalState,bHasValidServ,__LINE__);
	if ((bMonitorState) && (bSignalState == AL_DVB_MONITOR_VALUE_TRUE) && bHasValidServ)
	{
		if (DVBApp_IsPopupExist(PLAYBACK_POPUP_MSG_NO_SIGNAL))
		{
			DVBApp_ClosePopup(PLAYBACK_POPUP_MSG_NO_SIGNAL, UI_EVENT_NULL);
		}
#ifdef CONFIG_SUPPORT_PVR		//if playing timeshift file not to show pop
		UINT32 u32PEState = MID_TSPL_MODE_STOP;
		AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_USERINFO, 0,
		sizeof(APP_SETTING_UserInfo_t), &(g_stUserInfoData));
		u8Mute = g_stUserInfoData.Mute;//for manits 151777

		if (MID_TSPLParser_GetPlayState(&u32PEState, NULL) == DRV_SUCCESS)
		{
			if (MID_TSPL_MODE_STOP != u32PEState)
			{
				if ((u8Mute == FALSE) && (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_FILEPLAY)))
				{
					APP_Audio_SetMute(FALSE, TRUE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
				}

				return SP_ERR_FAILURE;
			}
		}
		if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_FILEPLAY))
		{
			if(u8Mute == FALSE)
			{
				APP_Audio_SetMute(FALSE, TRUE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
			}

			return SP_ERR_FAILURE;
		}
#endif
#ifdef PLAY_VIDEO_FOR_ALLSRV
	CDBIHandle_t hTempHdl = 0;

	MID_PlaybackGetCurProgHandle(al_null, &hTempHdl);
	DBPIDInfo_t 	stVideoPid;
	memset(&stVideoPid,0xff,sizeof(DBPIDInfo_t));
				
	AL_DB_QueryDetailFieldByName(hTempHdl, (al_uint8 *)"stVideoPid", (al_void *)&stVideoPid);	
#endif	

	switch (i16ProgState)
	{
		case MID_PLAYBK_PROG_STATE_AUDIO_VIDEO_SCRAMBLED:
#ifdef PLAY_VIDEO_FOR_ALLSRV
			if (DVBApp_CheckHasVideo() == TRUE)
#else			
			if (eServiceType != AL_RECTYPE_DVBRADIO) //zhongbaoxing added for mantis 0153467 @20110926
#endif
			{
				APP_GUIOBJ_DVB_Playback_ClearShowLogo();
			}
#if 0
#if 1 //richiechang 20120430, for samsung & SONY TVSet Behavior
			MID_PlaybackStreamInfo_t stAudStrmInfo;
			memset(&stAudStrmInfo, 0, sizeof(MID_PlaybackStreamInfo_t));

			MID_PlaybackGetAudioStreamInfo(&stAudStrmInfo, GL_NO_WAIT);
			if (stAudStrmInfo.bIsScrambled)
			{
				APP_Audio_SetMute(TRUE, FALSE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType); // mute audio if audio is scrambled
			}
			else
			{
				APP_Audio_SetMute(g_stUserInfoData.Mute, FALSE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType); // mute audio based on user setting if audio is not scrambled
			}
#else //richiechang 20120430, for SPV9200_Orion Behavior
			APP_Audio_SetMute(TRUE, FALSE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType); // mute audio if video is scrambled
#endif
#endif
			APP_Audio_SetMute(TRUE, FALSE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType); // mute audio if audio is scrambled
			APP_Video_SetMute(TRUE, FALSE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
#if 1
			if (bFlag == TRUE)
			{
				if (DVBApp_IsPopupExist(PLAYBACK_POPUP_MSG_SCRAMBLED) == FALSE)
				{
					_DVBApp_ShowPopup(DVB_APP_POP_MSG_SCRAMBLE);
				}
			}
#endif
			i32Ret = SP_ERR_FAILURE;
			break;

			case MID_PLAYBK_PROG_STATE_ONLY_VIDEO_SCRAMBLED:
#ifdef PLAY_VIDEO_FOR_ALLSRV
				if (DVBApp_CheckHasVideo() == TRUE)
#else			
				if (eServiceType != AL_RECTYPE_DVBRADIO) //zhongbaoxing added for mantis 0153467 @20110926
#endif
				{
					APP_GUIOBJ_DVB_Playback_ClearShowLogo();
				}

				APP_Audio_SetMute(g_stUserInfoData.Mute, FALSE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType); // mute audio based on user setting if audio is not scrambled
				APP_Video_SetMute(TRUE, FALSE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
#if 1 //for samsung & SONY TVSet Behavior
				if (bFlag == TRUE)
				{
					if (DVBApp_IsPopupExist(PLAYBACK_POPUP_MSG_SCRAMBLED) == FALSE)
					{
						printf("\n#####Pop Scramble MSG Menu,F=%s,L=%d######\n",__FUNCTION__,__LINE__);
						_DVBApp_ShowPopup(DVB_APP_POP_MSG_SCRAMBLE);
					}
				}
#endif
				i32Ret = SP_ERR_FAILURE;
				break;

		case MID_PLAYBK_PROG_STATE_LOCKED:
			APP_Audio_SetMute(TRUE, FALSE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
			APP_Video_SetMute(TRUE, FALSE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);

#ifdef PLAY_VIDEO_FOR_ALLSRV
			if (DVBApp_CheckHasVideo() == TRUE)
#else			
			if (eServiceType != AL_RECTYPE_DVBRADIO) //zhongbaoxing added for mantis 0153467 @20110926
#endif
			{
				APP_GUIOBJ_DVB_Playback_ClearShowLogo();
			}
			APP_GUIOBJ_DVB_Playback_SetPlayState(FALSE);
			if (bFlag == TRUE)
			{
				UINT32 u32PopMsgDialogType = POPMSG_PROMPT_NO_PROG;
				APP_GUIOBJ_PopMsg_GetMsgDialogType(&u32PopMsgDialogType);
				if ((DVBApp_IsPopupExist(PLAYBACK_POPUP_PWD_LOCKED) == FALSE)
#ifdef CONFIG_SUPPORT_PVR
					&& (u32PopMsgDialogType != POPMSG_PROMPT_INITIAL_AUTOTIMESHIFT)
					&& (u32PopMsgDialogType != POPMSG_PROMPT_INITIAL_REC)
					&& (u32PopMsgDialogType != POPMSG_PROMPT_INITIAL_TIMESHIFT)
					&& (u32PopMsgDialogType != POPMSG_PROMPT_INVALID_REC)
#endif
				)
				{
					_DVBApp_ShowPopup(DVB_APP_POP_MSG_CHECKPWD);
				}
			}
			i32Ret = SP_ERR_FAILURE;
			break;

		case MID_PLAYBK_PROG_STATE_TEMP_SERVICE:
			if ((bFlag == TRUE) && (DVBApp_CheckServiceNotAvailable() == TRUE))
			{
				_DVBApp_ShowPopup(DVB_APP_POP_MSG_TEMPSERVICE);
			}
			if (DVBApp_CheckServiceNotAvailable() == FALSE)
			{
				MID_DISP_DTVSetVideoUnmute();
				AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_USERINFO, 0,
					sizeof(APP_SETTING_UserInfo_t), &(g_stUserInfoData));
				if (g_stUserInfoData.Mute == FALSE)
				{
					APP_Audio_SetMute(g_stUserInfoData.Mute, TRUE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
				}
			}
			i32Ret = SP_ERR_FAILURE;
			break;

		case MID_PLAYBK_PROG_STATE_VIDEO_MPEG4:
			if (bFlag == TRUE)
			{
				if (DVBApp_IsPopupExist(PLAYBACK_POPUP_MSG_VIDEO_NOT_SUPPORT) == FALSE)
				{
					_DVBApp_ShowPopup(DVB_APP_POP_MSG_VIDEO_NOT_SUPPORT);
				}
			}
			i32Ret = SP_ERR_FAILURE;
			break;

		case MID_PLAYBK_PROG_STATE_REPLACE:
			if (DVBApp_CheckServiceNotAvailable() == FALSE)
			{
#ifdef PLAY_VIDEO_FOR_ALLSRV
				if (DVBApp_CheckHasVideo() == FALSE)
#else
				if (eServiceType == AL_RECTYPE_DVBRADIO)
#endif
				{
					if (APP_GUIOBJ_DVB_Playback_GetShowLogoState() == FALSE)
					{
						SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PLAYBACK, APP_DVB_INTRA_EVENT_SHOWLOGO, 0);
					}
				}
			}
			i32Ret = SP_ERR_FAILURE;
			break;

		case MID_PLAYBK_PROG_STATE_ONLY_AUDIO_SCRAMBLED:			
#ifdef PLAY_VIDEO_FOR_ALLSRV		
			if ((stVideoPid.usDataPID&0x1fff) == 0x1fff)
#else
			if(eServiceType == AL_RECTYPE_DVBRADIO)
#endif
			{
				APP_Audio_SetMute(TRUE, FALSE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
				APP_Video_SetMute(TRUE, FALSE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
	
				if (bFlag == TRUE)
				{
					if (DVBApp_IsPopupExist(PLAYBACK_POPUP_MSG_RADIO_CHANNEL))
					{
						DVBApp_ClosePopup(PLAYBACK_POPUP_MSG_RADIO_CHANNEL, UI_EVENT_NULL);
					}
					if (DVBApp_IsPopupExist(PLAYBACK_POPUP_MSG_NO_SIGNAL))
					{
						DVBApp_ClosePopup(PLAYBACK_POPUP_MSG_NO_SIGNAL, UI_EVENT_NULL);
					}
					if (DVBApp_IsPopupExist(PLAYBACK_POPUP_MSG_SCRAMBLED) == FALSE)
					{
						_DVBApp_ShowPopup(DVB_APP_POP_MSG_SCRAMBLE);
					}
				}
				
				i32Ret = SP_ERR_FAILURE;
				break;
			}
		case MID_PLAYBK_PROG_STATE_VIDEO_AVC:
		case MID_PLAYBK_PROG_STATE_NOT_RUNNING:
		default:
			if (bFlag == TRUE)
			{
				if (DVBApp_IsPopupExist(PLAYBACK_POPUP_PWD_LOCKED) == TRUE)
				{
					DVBApp_ClosePopup(PLAYBACK_POPUP_PWD_LOCKED, UI_EVENT_NULL);
				}

				if (DVBApp_IsPopupExist(PLAYBACK_POPUP_MSG_SCRAMBLED) == TRUE)
				{
					DVBApp_ClosePopup(PLAYBACK_POPUP_MSG_SCRAMBLED, UI_EVENT_NULL);
				}

				if (DVBApp_IsPopupExist(PLAYBACK_POPUP_MSG_TEMPSERVICE) == TRUE)
				{
					DVBApp_ClosePopup(PLAYBACK_POPUP_MSG_TEMPSERVICE, UI_EVENT_NULL);
				}

				if (DVBApp_IsPopupExist(PLAYBACK_POPUP_MSG_TEMPSERVICE_SERVICE_NOT_RUNNING) == TRUE)
				{
					DVBApp_ClosePopup(PLAYBACK_POPUP_MSG_TEMPSERVICE_SERVICE_NOT_RUNNING, UI_EVENT_NULL);
				}

				if (DVBApp_IsPopupExist(PLAYBACK_POPUP_MSG_TEMPSERVICE_LOAD_MHEG5) == TRUE)
				{
					DVBApp_ClosePopup(PLAYBACK_POPUP_MSG_TEMPSERVICE_LOAD_MHEG5, UI_EVENT_NULL);
				}

				if (DVBApp_IsPopupExist(PLAYBACK_POPUP_MSG_VIDEO_NOT_SUPPORT) == TRUE)
				{
					DVBApp_ClosePopup(PLAYBACK_POPUP_MSG_VIDEO_NOT_SUPPORT, UI_EVENT_NULL);
				}
			}

			if (DVBApp_CheckServiceNotAvailable() == TRUE)
			{
#ifdef PLAY_VIDEO_FOR_ALLSRV
				if (DVBApp_CheckHasVideo() == TRUE)
#else			
				if (eServiceType != AL_RECTYPE_DVBRADIO) //zhongbaoxing added for mantis 0153467 @20110926
#endif
				{
					APP_GUIOBJ_DVB_Playback_ClearShowLogo();
				}
				APP_Audio_SetMute(TRUE, FALSE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
				APP_Video_SetMute(TRUE, FALSE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
				if (bFlag == TRUE)
				{
					if (DVBApp_IsPopupExist(PLAYBACK_POPUP_MSG_SERVICE_NOT_AVAILABLE) == FALSE)
					{
                        if(APP_Get_DTVHiddenScanState() != TRUE)
                        {
						    _DVBApp_ShowPopup(DVB_APP_POP_MSG_SERVICE_NOT_AVAILABLE);
                        }
					}
				}
				i32Ret = SP_ERR_FAILURE;
			}
			else
			{
#ifdef SHOW_LOGO_RADIO
#ifdef PLAY_VIDEO_FOR_ALLSRV
				if (DVBApp_CheckHasVideo() == TRUE)
#else			
				if (eServiceType != AL_RECTYPE_DVBRADIO) //zhongbaoxing added for mantis 0153467 @20110926
#endif
#endif
				{
					APP_GUIOBJ_DVB_Playback_ClearShowLogo();
				}
				AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_USERINFO, 0,
					sizeof(APP_SETTING_UserInfo_t), &(g_stUserInfoData));
				u8Mute = g_stUserInfoData.Mute;

#ifndef PLAY_VIDEO_FOR_ALLSRV				
				if (eServiceType == AL_RECTYPE_DVBRADIO)
				{
					//if ((bSetUnMuteFlag == FALSE))
					{
						AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_USERINFO, 0,
							sizeof(APP_SETTING_UserInfo_t), &(g_stUserInfoData));
						u8Mute = g_stUserInfoData.Mute;

#ifndef SHOW_LOGO_RADIO
						APP_Video_SetMute(TRUE, FALSE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
#else
						APP_Video_SetMute(FALSE, TRUE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
#endif
#ifdef CONFIG_SUPPORT_PVR
#ifdef SUPPORT_WAKEUP_TIMER_IN_STANDBY
						if (APP_WAKEUP_GetBootFlag() == TRUE)
						{
							APP_Audio_SetMute(TRUE, FALSE, APP_MUTE_MODE_STATEMAX, APP_SOURCE_MAX);
						}
						else
#endif
#endif
						{
							APP_Audio_SetMute(u8Mute, TRUE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
						}
					}
				}
				else if ((eServiceType == AL_RECTYPE_DVBTV)||(eServiceType == AL_RECTYPE_DVBDATA))
#endif
				{
					if (DVBApp_IsPopupExist(PLAYBACK_POPUP_MSG_RADIO_CHANNEL) == TRUE)
					{
#ifdef PLAY_VIDEO_FOR_ALLSRV
						if ((eServiceType == AL_RECTYPE_DVBTV)||(eServiceType == AL_RECTYPE_DVBDATA)
							|| (eServiceType == AL_RECTYPE_DVBRADIO && ((stVideoPid.usDataPID&0x1fff) != 0x1fff)))
#endif
						{
							DVBApp_ClosePopup(PLAYBACK_POPUP_MSG_RADIO_CHANNEL, UI_EVENT_NULL);
						}
					}
					/*modify by qinhe for mantis 0011456*/
					
#ifdef PLAY_VIDEO_FOR_ALLSRV
					if (DVBApp_CheckHasVideo() == FALSE)
					{
						AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_USERINFO, 0,
							sizeof(APP_SETTING_UserInfo_t), &(g_stUserInfoData));
						u8Mute = g_stUserInfoData.Mute;

#ifndef SHOW_LOGO_RADIO
#ifdef CONFIG_SUPPORT_MHEG5
					/* do not mute video while MHEG5 is being displayed, because it could be playing I-frame */
						if ((eServiceType == AL_RECTYPE_DVBTV)
						&& ((APP_DVB_Mheg5_GetBootCarouselStatus() != MHEG5_BOOT_CAROUSEL_EXISTED)
						|| APP_Area_SupportDtg() == FALSE || APP_DVB_Mheg5_GetMheg5DisplayStatus() == FALSE))
#endif
							APP_Video_SetMute(TRUE, FALSE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
#else
							APP_Video_SetMute(FALSE, TRUE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
#endif
#ifdef CONFIG_SUPPORT_PVR
#ifdef SUPPORT_WAKEUP_TIMER_IN_STANDBY
							if (APP_WAKEUP_GetBootFlag() == TRUE)
							{
								APP_Audio_SetMute(TRUE, FALSE, APP_MUTE_MODE_STATEMAX, APP_SOURCE_MAX);
							}
							else
#endif
#endif
							{
								APP_Audio_SetMute(u8Mute, TRUE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
							}
					}
					else
#endif
					{
						if ((g_SetPQFlag == TRUE) && (g_bMidHasUnmute == TRUE))
						{
							AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_USERINFO, 0,
								sizeof(APP_SETTING_UserInfo_t), &(g_stUserInfoData));
							u8Mute = g_stUserInfoData.Mute;

#ifdef CONFIG_SUPPORT_PVR
#ifdef SUPPORT_WAKEUP_TIMER_IN_STANDBY
							if (APP_WAKEUP_GetBootFlag() == TRUE)
							{
								APP_Audio_SetMute(TRUE, FALSE, APP_MUTE_MODE_STATEMAX, APP_SOURCE_MAX);
							}
							else
#endif
#endif
							{
								APP_Audio_SetMute(u8Mute, TRUE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
							}
						}
						APP_Video_SetMute(FALSE, TRUE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
					}
				}
				i32Ret = SP_SUCCESS;
			}
		break;
		}
	}
	else
	{
#ifdef CONFIG_SUPPORT_PVR		//if playing timeshift file not to mute video
		AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_USERINFO, 0,
			sizeof(APP_SETTING_UserInfo_t), &(g_stUserInfoData));
		u8Mute = g_stUserInfoData.Mute;//for manits 151777
		if (MID_TSPLParser_GetThreadState() == TRUE)
		{
			if ((u8Mute == FALSE) && (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_FILEPLAY)))
			{
				APP_Audio_SetMute(FALSE, TRUE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
			}
			return SP_ERR_FAILURE;
		}
		if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_FILEPLAY))
		{
			if(u8Mute == FALSE)
			{
				APP_Audio_SetMute(FALSE, TRUE, APP_MUTE_MODE_SIGNAL_DETECT, eSourType);
			}
			return SP_ERR_FAILURE;
		}
#endif
		APP_Audio_SetMute(TRUE, TRUE, APP_MUTE_MODE_NO_SIGNALE, eSourType);
#ifdef SUPPORT_DTV_SHOW_BLUESCREEN
		if (g_stSetupData.BlueScreen == APP_SWITCH_ON)
		{
			if (!g_bIsBlueScreen)
			{
				MID_DISP_DTVSetVideoMute(0,0,255);
			}
		}
		else
#endif
		{
			APP_Video_SetMute(TRUE, TRUE, APP_MUTE_MODE_NO_SIGNALE, eSourType);
		}
		APP_GUIOBJ_DVB_Playback_ClearShowLogo();
		if (bFlag == TRUE)
		{
			APP_GUIOBJ_DVB_Playback_ClearShowLogo();
			if (DVBApp_IsPopupExist(PLAYBACK_POPUP_MSG_RADIO_CHANNEL))
			{
				DVBApp_ClosePopup(PLAYBACK_POPUP_MSG_RADIO_CHANNEL, UI_EVENT_NULL);
			}
			if ((DVBApp_IsPopupExist(PLAYBACK_POPUP_MSG_NO_SIGNAL) == FALSE)
#ifdef CONFIG_SUPPORT_PVR
				&& (APP_GUIOBJ_DVB_PvrPlayInfo_GetTunerState() == FALSE)
#endif
				&& (bSignalState == AL_DVB_MONITOR_VALUE_FALSE)
				)
			{
				if (DVBApp_IsPopupExist(PLAYBACK_POPUP_PWD_LOCKED))
				{
					DVBApp_ClosePopup(PLAYBACK_POPUP_PWD_LOCKED, UI_EVENT_NULL);
				}
				_DVBApp_ShowPopup(DVB_APP_POP_MSG_NO_SIGNAL);
			}
			else if (APP_DVB_Playback_GetProgStateByHandle(APP_DVB_Playback_GetCurrentNetType(), AL_DB_INVALIDHDL)
				== MID_PLAYBK_PROG_STATE_LOCKED)
			{
				_DVBApp_ShowPopup(DVB_APP_POP_MSG_CHECKPWD);
			}

		}
		i32Ret = SP_ERR_FAILURE;
	}

	return i32Ret;
}

/*****************************************************************************
** FUNCTION : DVBApp_SchedulePopup
**
** DESCRIPTION :
**				Schedule dvb popmsg
**
** PARAMETERS :
**				Popup  -  popmsg type
**
** RETURN VALUES:
**				None
*****************************************************************************/
INT32 DVBApp_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_DVB,
                                                       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_DVB, APP_GUIOBJ_SOURCE)
                || SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_SOURCE_CEC)
                || SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_EPG)
                || SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_CHNLIST)
                || SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_FAVLIST)
                || SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_MULTIAUD)
                || SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_INITINSTALL)
                || (APP_GUIOBJ_DVB_ProgInfo_IsExtendMode() == 1)
#ifdef OSD_GAME_SUPPORT
                || SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_OSDGAME)
#endif
                || SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_CHNMGR)
                || SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_FAVMGR)
#ifdef CONFIG_SUPPORT_3D_EN
					|| SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_3D_INFO)
#endif
               )
            {
                g_u32OldPopup = PLAYBACK_POPUP_NONE;
                g_dCurPopup = u32CurPopup;
                return 0;
            }

            if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_POPMSG))
            {
                SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_POPMSG);
            }
            APP_MenuMgr_SetMsgPopup(TRUE);
            SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, DVB_GUIOBJ_POPMSG, (UINT32)&Popup);
			g_dCurPopup = u32CurPopup;
        }
    }
    else
    {
        if ((SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PROGINFO))
            && (APP_GUIOBJ_DVB_ProgInfo_IsExtendMode() == 1))
        {
            SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PROGINFO);
        }

#ifdef OSD_GAME_SUPPORT
        if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_OSDGAME))
        {
            return 0;
        }
#endif

        if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_POPMSG))
        {
            SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_POPMSG);
        }
        APP_MenuMgr_SetMsgPopup(TRUE);

        SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, DVB_GUIOBJ_POPMSG, (UINT32)&Popup);
		g_dCurPopup = u32CurPopup;
    }

    return 1;
}

/*****************************************************************************
** FUNCTION : DVBApp_ClosePopup
**
** DESCRIPTION :
**				Close dvb popmsg
**
** PARAMETERS :
**				u32ClosePopup  -  popmsg type
**				dMessage  -  send message type when close popmsg
**
** RETURN VALUES:
**				None
*****************************************************************************/
INT32 DVBApp_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_DVB, DVB_GUIOBJ_POPMSG))
            {
                SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_POPMSG);
            }
        }

        if (dMessage != UI_EVENT_NULL)
        {
            SYSAPP_IF_SendCriticalGlobalEventWithIndex(SYS_APP_DVB, 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)))
                {
                    DVBApp_SchedulePopup(stPopupWaitingList[dCheckFlag-PLAYBACK_POPUP_NONE]);
                    break;
                }
            }
        }
    }
    else
    {
        if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_POPMSG))
        {
            SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_POPMSG);
        }

        if (dMessage != UI_EVENT_NULL)
        {
            SYSAPP_IF_SendCriticalGlobalEventWithIndex(SYS_APP_DVB, dMessage, g_dCurPopup);
        }
        if (g_u32OldPopup != PLAYBACK_POPUP_NONE)
        {
            g_u32OldPopup = PLAYBACK_POPUP_NONE;
        }
        g_dCurPopup = PLAYBACK_POPUP_NONE;
		if(u32ClosePopup == POPMSG_PROMPT_PWD_ERROR) //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)))
            {
                DVBApp_SchedulePopup(stPopupWaitingList[dCheckFlag-PLAYBACK_POPUP_NONE]);
                break;
            }
        }
    }

    return 1;
}

/*****************************************************************************
** FUNCTION : DVBApp_ResetPopup_Channel
**
** DESCRIPTION :
**				Reset all popup state
**
** PARAMETERS :
**				None
**
** RETURN VALUES:
**				None
*****************************************************************************/
INT32 DVBApp_ResetPopup_Channel(void)
{
    DVBApp_ClosePopup(PLAYBACK_POPUP_MSG_CHECK_ANTENNA_INPUT, UI_EVENT_NULL);
    DVBApp_ClosePopup(PLAYBACK_POPUP_MSG_RADIO_CHANNEL, UI_EVENT_NULL);
    DVBApp_ClosePopup(PLAYBACK_POPUP_MSG_TEMPSERVICE, UI_EVENT_NULL);
    DVBApp_ClosePopup(PLAYBACK_POPUP_MSG_TEMPSERVICE_LOAD_MHEG5, UI_EVENT_NULL);
    DVBApp_ClosePopup(PLAYBACK_POPUP_MSG_TEMPSERVICE_SERVICE_NOT_RUNNING, UI_EVENT_NULL);
    DVBApp_ClosePopup(PLAYBACK_POPUP_MSG_NO_SIGNAL, UI_EVENT_NULL);
    DVBApp_ClosePopup(PLAYBACK_POPUP_MSG_SCRAMBLED, UI_EVENT_NULL);
    DVBApp_ClosePopup(PLAYBACK_POPUP_MSG_SERVICE_NOT_AVAILABLE, UI_EVENT_NULL);
    DVBApp_ClosePopup(PLAYBACK_POPUP_CONFIRM_REMOVE_SRV, UI_EVENT_NULL);
    DVBApp_ClosePopup(PLAYBACK_POPUP_PROMPT_REMOVE_SRV, UI_EVENT_NULL);
    DVBApp_ClosePopup(PLAYBACK_POPUP_PWD_LOCKED, UI_EVENT_NULL);
    DVBApp_ClosePopup(PLAYBACK_POPUP_MSG_DATABASE_EMPTY, UI_EVENT_NULL);
    DVBApp_ClosePopup(PLAYBACK_POPUP_MSG_VIDEO_NOT_SUPPORT, UI_EVENT_NULL);
    return SP_SUCCESS;
}

/*****************************************************************************
** FUNCTION : DVBApp_HideMsgPopupDisplay
**
** DESCRIPTION :
**				Hide popup display
**
** PARAMETERS :
**				None
**
** RETURN VALUES:
**				None
*****************************************************************************/
INT32 DVBApp_HideMsgPopupDisplay(void)
{
    g_u32OldPopup = PLAYBACK_POPUP_NONE;
    if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_POPMSG))
    {
        SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_POPMSG);
    }

    return 0;
}

/*****************************************************************************
** FUNCTION : DVBApp_IsPopupExist
**
** DESCRIPTION :
**				Judge one pop up exist
**
** PARAMETERS :
**				u32TargetPopup  -   pop up type
**
** RETURN VALUES:
**				None
*****************************************************************************/
UINT8 DVBApp_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 : DVBApp_RestoreOnStandby
**
** DESCRIPTION :
**				dvb restore when standby
**
** PARAMETERS :
**				None
**
** RETURN VALUES:
**				None
*****************************************************************************/
void DVBApp_RestoreOnStandby(void)
{
    extern Boolean g_bScanRunning;
    if (g_bScanRunning)
    {
        MID_ScanStop();
        AL_DB_Sync(APP_DVB_Playback_GetCurrentNetType(), al_false);
    }
}

/*****************************************************************************
** FUNCTION : DVBApp_DataApplicationSwitch
**
** DESCRIPTION :
**				OSD layer 2 switch
**
** PARAMETERS :
**				u32flag  -  switch flag
**
** RETURN VALUES:
**				None
*****************************************************************************/
INT32 DVBApp_DataApplicationSwitch(UINT32 u32flag)
{
    UINT32 u32CurrentState = 0;

    if (_DVBApp_DataApplicationStatus(OSD2CTRLMDL_SUB)&DATA_APP_EXECUTABLE)
    {
        u32CurrentState |= OSD2CTRLMDL_SUB;
    }
    if (u32flag & OSD2CTRLMDL_DISABLE)
    {
		u32CurrentState = u32flag;
    }
    else
    {
        if (u32flag & OSD2CTRLMDL_FORCE)
        {
            u32CurrentState = (u32CurrentState & u32flag) > 0 ? (u32CurrentState & u32flag) : u32CurrentState;
        }
		else
		{
			u32CurrentState = (u32CurrentState & u32flag);
		}
    }

	if ((u32flag & OSD2CTRLMDL_SUB) && (u32CurrentState & OSD2CTRLMDL_MH5) && (u32flag & OSD2CTRLMDL_ENABLE))
	{
	    u32CurrentState = ON_DATA_APPLICATION_DECISION(u32CurrentState);
	}

    u32CurrentState |= (u32flag & (OSD2CTRLMDL_ENABLE | OSD2CTRLMDL_DISABLE));
    return _DVBApp_DataApplicationGuiObjectRefresh(u32CurrentState);
}

/*****************************************************************************
** FUNCTION : DVBApp_GetScrambleStatus
**
** DESCRIPTION :
**				clear flag status when change source
**
** PARAMETERS :
**				None
**
** RETURN VALUES:
**				None
*****************************************************************************/
Boolean DVBApp_GetScrambleStatus(void)
{
    return g_bScrambleFlag;
}
#ifdef CONFIG_SUPPORT_OTA_UPGRADE
/*****************************************************************************
** FUNCTION : DVBApp_GetOTAStatus
**
** DESCRIPTION :
**				clear flag status when cancel or finish OTA upgrade
**
** PARAMETERS :
**				None
**
** RETURN VALUES:
**				None
*****************************************************************************/
Boolean DVBApp_GetOTAStatus(void)
{
    return g_bOTAFlag;
}

/*****************************************************************************
** FUNCTION : DVBApp_SetOTAStatus
**
** DESCRIPTION :
**				set flag status
**
** PARAMETERS :
**				None
**
** RETURN VALUES:
**				None
*****************************************************************************/
void DVBApp_SetOTAStatus(Boolean b_flag)
{
    g_bOTAFlag = b_flag;
}
#endif
/*****************************************************************************
** FUNCTION : DVBApp_ClearStatus
**
** DESCRIPTION :
**				clear flag status when change source
**
** PARAMETERS :
**				None
**
** RETURN VALUES:
**				None
*****************************************************************************/
void DVBApp_ClearStatus(void)
{
    AL_DB_EDBType_t eNetType = APP_DVB_Playback_GetCurrentNetType();
	AL_DB_ERecordType_t eServiceType = APP_DVB_Playback_GetCurrServiceType(eNetType);

    bSetUnMuteFlag = FALSE;
    if (eServiceType == AL_RECTYPE_DVBTV)
    {
        g_bMidHasUnmute = FALSE;
    }
    else if (eServiceType == AL_RECTYPE_DVBRADIO)
    {
        g_bMidHasUnmute = TRUE;
    }
#ifdef SUPPORT_DTV_SHOW_BLUESCREEN
	g_bIsBlueScreen = FALSE;
#endif
    g_SetPQFlag = FALSE;
    g_bScrambleFlag = PROG_STATUS_SCRAMBLE_UNKNOW;
	g_bAudHasUpdate = FALSE;
	g_bForceProcessEventCbk = TRUE;
	g_bNoSteamData = FALSE;
	g_bTempSerFlag = FALSE;
#ifdef CONFIG_SUPPORT_OTA_UPGRADE
	DVBApp_SetOTAStatus(FALSE);
#endif
#ifdef CONFIG_SUPPORT_EWS
	if (g_NonClearEWS == FALSE)
	{
		DVBApp_ResetEWS();
	}
#endif
}

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

void  DVBApp_NoSignal_StandbyTimerReset(void)
{
	g_u32NoSignalSleepTimer = 0;
}

void DVBApp_CheckSrvType(al_uint8 SdtSrvType, al_uint8 SrvType, al_uint8 VideoCount, al_uint8 AudioCount, AL_DB_ERecordType_t *RetSrvType)
{
	if (RetSrvType == al_null)
	{
		return;
	}

	AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_CHANNEL, 0,
		sizeof(APP_SETTING_Channel_t), &(g_stChannelData));


	*RetSrvType = AL_RECTYPE_DVBTV;

	if (SrvType != 0xff)
	{
		if (SdtSrvType == SERVICE_DIGITAL_RADIO
			||SdtSrvType == SERVICE_ADVANCED_DIGITAL_RADIO)
		{
			*RetSrvType = AL_RECTYPE_DVBRADIO;
		}
		else if ((SdtSrvType != SERVICE_DIGITAL_TELEVISION
			&& SdtSrvType != SERVICE_MPEG2_HD_DIGITAL_TELEVISION
			&& SdtSrvType != SERVICE_ADVANCED_SD_DIGITAL_TV
			&& SdtSrvType != SERVICE_ADVANCED_HD_DIGITAL_TV)
			&& ((SrvType == SERVICE_DIGITAL_RADIO)
			|| (SrvType == SERVICE_ADVANCED_DIGITAL_RADIO)))
		{
			*RetSrvType = AL_RECTYPE_DVBRADIO;
		}
	}
	else
	{
		if (SdtSrvType == SERVICE_DIGITAL_RADIO
			||SdtSrvType == SERVICE_ADVANCED_DIGITAL_RADIO)
		{
			*RetSrvType = AL_RECTYPE_DVBRADIO;
		}
		else if ((SdtSrvType != SERVICE_DIGITAL_TELEVISION
			&& SdtSrvType != SERVICE_MPEG2_HD_DIGITAL_TELEVISION
			&& SdtSrvType != SERVICE_ADVANCED_SD_DIGITAL_TV
			&& SdtSrvType != SERVICE_ADVANCED_HD_DIGITAL_TV)
			&& ((SdtSrvType == SERVICE_DIGITAL_RADIO)
			|| (SdtSrvType == SERVICE_ADVANCED_DIGITAL_RADIO)))
		{
			*RetSrvType = AL_RECTYPE_DVBRADIO;
		}
	}

	if ((VideoCount != 0xff) && (AudioCount != 0xff))
	{
		AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_CHANNEL, 0,
			sizeof(APP_SETTING_Channel_t), &(g_stChannelData));

		if ((VideoCount == 0) && (AudioCount > 0)
			&& *RetSrvType == AL_RECTYPE_DVBTV)
		{
			*RetSrvType = AL_RECTYPE_DVBRADIO;
		}

	    	//mantis 186965 by changhong, for mh5 service
		if((VideoCount > 0) && (*RetSrvType == AL_RECTYPE_DVBDATA))
		{
			*RetSrvType = AL_RECTYPE_DVBTV;
		}
	}
}

void DVBApp_CheckNotVisibleBySrvType(al_uint8 SdtSrvType, al_uint8 bTempSrv, al_uint8 *bNotVisible, al_uint8 *bNotNeedSave)
{
	if (bNotVisible == al_null || bNotNeedSave ==al_null)
	{
		return;
	}
	AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_CHANNEL, 0,
		sizeof(APP_SETTING_Channel_t), &(g_stChannelData));

	if (SdtSrvType != SERVICE_NO_SDT)
	{
		if(SdtSrvType != SERVICE_DIGITAL_TELEVISION
			&& SdtSrvType != SERVICE_DIGITAL_RADIO
			&& SdtSrvType != SERVICE_ADVANCED_DIGITAL_RADIO
			&& SdtSrvType != SERVICE_ADVANCED_SD_DIGITAL_TV
			&& SdtSrvType != SERVICE_ADVANCED_HD_DIGITAL_TV
			&& SdtSrvType != SERVICE_MPEG2_HD_DIGITAL_TELEVISION)
		{
			if ((SdtSrvType != SERVICE_NOT_IN_SDT)
				&& bTempSrv)
			{
				*bNotVisible = TRUE;
			}
		}
		if(SdtSrvType == SERVICE_DIGITAL_TELEVISION && bTempSrv)
		{
			*bNotVisible = TRUE;
		}
	}

	/* mantis 0141374 */
	if ((SdtSrvType == SERVICE_NO_SDT)
		&& bTempSrv)
	{
		*bNotVisible = TRUE;
	}
}

void DVBApp_ResetDvbSpecRule(UINT8 u8Area)
{
    Dvb_SetFreqEnlargeEnable(0);
    AL_Event_SetDTGSupport(FALSE);
    AL_PSI_Monitor_SetupConf(AL_PSIMON_SPECIAL_SPEC_EBOOK, 0, DVBApp_CheckSrvType, DVBApp_CheckNotVisibleBySrvType);
	AL_CS_DtvSetSpecialSpec(AL_DB_DVB_PRISPEC_EBOOK);

    MID_ScanSetCountryCode(APP_Area_GetCountryCode(u8Area));

    switch (u8Area)
    {
        default:
			AL_PSI_Monitor_SetupConf(AL_PSIMON_SPECIAL_SPEC_DEMO_DEFAULT, 0, DVBApp_CheckSrvType, DVBApp_CheckNotVisibleBySrvType);
            break;
    }


    if (u8Area >= MAX_AREA)
    {
        u8Area = 0;
    }
    if (APP_Area_SupportDtg())
    {
        AL_Event_SetDTGSupport(al_true);
    }
    AL_Event_SetCountryCode(APP_Area_GetCountryCode(u8Area));
    APP_GuiMgr_Set_Default_Codepage(u8Area);
}

Boolean DVBApp_GetForceProcessEventState(void)
{
	return g_bForceProcessEventCbk;
}

/*****************************************************************************
** FUNCTION : DVBApp_fw_callback
**
** DESCRIPTION :
**
**
** PARAMETERS :
**				None
**
** RETURN VALUES:
**				None
*****************************************************************************/
INT32 DVBApp_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))
    {
        dvb_printf("[%s: %d][Error] get active system app fail\n", __FUNCTION__, __LINE__);
        return SP_ERR_FAILURE;
    }
    dvb_printf(" Received event: %d from AFW module callback.\n\n",event);

    if (Index == SYS_APP_DVB)
    {
        switch (event)
        {
            case FW_EPG_NOWNEXT_UPDATE_EVENT:
				if(g_bForceProcessEventCbk)
				{
					dParam = *(UINT32 *)param;
					message = event|PASS_TO_SYSAPP;
				}
				else
				{
					if(!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_EPG) &&
						!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_EPGEXTEND) &&
						!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PROGINFO) )
					{
						return SP_ERR_FAILURE;
					}
					message = event;
				}
                break;
            case FW_EPG_SCHEDULE_UPDATE_EVENT:
				if(!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_EPG) &&
					!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_EPGEXTEND) &&
					!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PROGINFO) )
				{
					return SP_ERR_FAILURE;
				}
                message = event;
                break;

            case FW_EPG_PREF_SERVICE_NAME_UPDATE_EVENT:
                message = FW_MONITOR_UPDATE_SERVICE;
                break;

			case FW_DATASAVING_DVBDB_STORE_START_EVENT:
			case FW_DATASAVING_ATVDB_STORE_START_EVENT:
			case FW_DATASAVING_DVBDB_STORE_END_EVENT:
			case FW_DATASAVING_ATVDB_STORE_END_EVENT:
				message = event;
				break;
#ifdef CONFIG_SUPPORT_PVR
			case FW_SCHEDULER_EVENT:
			{
				dvb_printf("event is coming,");
				message = APP_DVB_GLOBAL_EVENT_PVRSCH |PASS_TO_SYSAPP;
				dvb_printf("handle = 0x%x\n", ((AL_PR_details_t *)param)->rem_details.handle);
				memcpy(&g_stDetails, param, sizeof(AL_PR_details_t));
				dParam = (UINT32)&g_stDetails;
				free(param);
				param = NULL;
			}
			break;
			case FW_SCHEDULER_MSG:
				dvb_printf("first warning: event will come in 10 sec\n");
				dParam = *(UINT32 *)param;
				message = APP_GLOBAL_EVENT_PVR_REMINDER|PASS_TO_SYSAPP;
				break;
			case FW_SCHEDULER_EXPIRE:
				dvb_printf("warning: event duration is over #############\n");
				message = APP_DVB_GLOBAL_EVENT_PVR_EXPIRE|PASS_TO_SYSAPP;
				dParam =*(UINT32 *)param;

				break;
#endif
			case FW_MONITOR_TUNER_LOCKED:
			case FW_MONITOR_TUNER_UNLOCKED:
			case FW_MONITOR_STREAM_NO_DATA:
			case FW_MONITOR_STREAM_HAS_DATA:
			case FW_MONITOR_SERVICE_VIDEO_AUDIO_SCRAMBLE:
			case FW_MONITOR_SERVICE_ONLY_VIDEO_SCRAMBLE:
			case FW_MONITOR_SERVICE_ONLY_AUDIO_SCRAMBLE:
			case FW_MONITOR_SERVICE_NO_SCRAMBLE:
			case FW_MONITOR_PARENTAL_LOCKED:
			case FW_MONITOR_PARENTAL_UNLOCKED:
			case FW_MONITOR_SERVICE_MOVE:
			case FW_MONITOR_AUDIO_UPDATE:
			case FW_MONITOR_SUBTITLE_UPDATE:
			case FW_MONITOR_TELETEXT_UPDATE:
			case FW_MONITOR_ADD_SERVICE:
			case FW_MONITOR_UPDATE_SERLCN:
			case FW_MONITOR_REMOVE_SERVICE:
			case FW_MONITOR_OTHERTP_SERVICE_FOUND:
			case FW_MONITOR_REPLACE_SERVICE:
			case FW_MONITOR_REPLACE_SIMULCASE_SERVICE:
			case FW_MONITOR_TS_CHANGED:
			case FW_MONITOR_NEW_TSID:
            case FW_MONITOR_TIME_UPDATE:
			case FW_MONITOR_FIND_NEW_TPLIST:
			case FM_DTV_AUDIO_STARTED:
			case FM_DTV_AUDIO_SAMPLE_STOPPED:
			case FM_DTV_AUDIO_STOPPED:
			case FW_MONITOR_CLOSECAPTION_UPDATE:
#ifdef AC_ON_AUTO_GET_TIME
                if ((g_fBackgroundGetTime == TRUE)
                    && (event == FW_MONITOR_TIME_UPDATE))
                {
	                 APP_WAKEUP_SetBootFlag(FALSE);
					 MAINAPP_SendGlobalEvent(UI_EVENT_POWER, AL_POWER_STATE_OFF);
                }
#endif
#ifdef SUPPORT_WAKEUP_TIMER_IN_STANDBY
                if (event == FW_MONITOR_TIME_UPDATE)
                {
                    APP_TimeUpdateSetFlag(TRUE);
                }
#endif
				message = event|PASS_TO_SYSAPP;
				dParam = *(al_uint32 *)param;
				break;

			case FW_MONITOR_UPDATE_SERVICE:
				message = event;
				break;

			/* remove by qinhe on 2014/02/12 for mantis 18485, unmute need vip notify app */
			/*case FW_MONITOR_PMT_UPDATE:
				message= APP_DVB_GLOBAL_EVENT_SET_UNMUTE|PASS_TO_SYSAPP;
				dParam = *(al_uint32 *)param;
				break;*/

			case FW_MONITOR_SERTYPE_CHANGED:
				message = event|PASS_TO_SYSAPP;
				dParam = *(al_uint32 *)param;
				break;

#ifdef CONFIG_SUPPORT_PVR
			case FW_MONITOR_REMINDER_EXPIRE:
				{
					al_uint32 TimeInSec = 0;
					AL_Time_t time;
					memset(&time, 0, sizeof(time));
					AL_Time_MjdToYmd(AL_Time_GetRawMjd(),&time.Year, &time.Month, &time.Day);
					AL_Time_GetRawTime(&time.Hour, &time.Min, &time.Sec);
 					AL_Time_DateToSecs(&time, &TimeInSec);
					tv_SetBaseTimetoSystem(TimeInSec);
				}
#ifdef AC_ON_AUTO_GET_TIME
                if (g_fBackgroundGetTime == TRUE)
                {
					APP_WAKEUP_SetBootFlag(FALSE);
					MAINAPP_SendGlobalEvent(UI_EVENT_POWER, AL_POWER_STATE_OFF);
                }
#endif
#ifdef SUPPORT_WAKEUP_TIMER_IN_STANDBY
                APP_TimeUpdateSetFlag(TRUE);
#endif
				message = APP_DVB_GLOBAL_EVENT_REMINDER_EXPIRE;
				break;
			case FW_MONITOR_REMINDER_TIME_CHANGE:
				{
					al_uint32 TimeInSec = 0;
					AL_Time_t time;
					memset(&time, 0, sizeof(time));
					AL_Time_MjdToYmd(AL_Time_GetRawMjd(),&time.Year, &time.Month, &time.Day);
					AL_Time_GetRawTime(&time.Hour, &time.Min, &time.Sec);
 					AL_Time_DateToSecs(&time, &TimeInSec);
					tv_SetBaseTimetoSystem(TimeInSec);
				}
#ifdef AC_ON_AUTO_GET_TIME
                if (g_fBackgroundGetTime == TRUE)
                {
					APP_WAKEUP_SetBootFlag(FALSE);
					MAINAPP_SendGlobalEvent(UI_EVENT_POWER, AL_POWER_STATE_OFF);
                }
#endif
				if (param == NULL)
				{
					UMFDBG(0,"[error],%s  %d\n",__FUNCTION__,__LINE__);
				}
				dParam =*(al_uint32 *) param;
				message = APP_DVB_GLOBAL_EVENT_REMINDER_TIME_CHANGE | PASS_TO_SYSAPP;
				break;
#endif
			case FW_SIGNAL_PRESENT:
            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 (APP_GUIOBJ_DVB_Playback_GetZappingState() == FALSE)
				{
#ifdef CONFIG_SUPPORT_PVR
					al_uint8 bSignalState = al_false;
					AL_DVB_Monitor_GetState(AL_DVB_MONITOR_STATE_SIGNAL, &bSignalState);
					if((MID_TSPLParser_GetThreadState() == TRUE)&&(!bSignalState))
					{
						//timeshift, no signal
					}
					else
#endif
					{
						message = APP_DVB_GLOBAL_EVENT_SET_UNMUTE|PASS_TO_SYSAPP;
					}
				}
			#ifdef CONFIG_QSD
				// To echo message with DTV has signal for chip test using.
				con_dbg_echo('G', 'O');
				con_dbg_echo('O', 'D');
			#endif
				break;
#ifdef CONFIG_SCART_SUPPORT
			case FW_SCART_INPUTSTATUS_CHANGE:
	#ifdef CONFIG_SUPPORT_PVR
				if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_REC)
					|| SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_PLAYINFO))
				{
					break;
				}
	#endif
				dParam = *(UINT32 *)param;
				APP_SCARTIN_Pin8Function(dParam);
				break;
#endif

#ifdef SUPPORT_CEC_TV
			case FW_HDMI_PORTSTATUS:
				dParam = *(UINT32 *)param;
				message = APP_DVB_GLOBAL_EVENT_HDMIPORT_STATUS|PASS_TO_SYSAPP;
				break;
#endif
#if 0
            case FW_DB_LOAD_DEFAULT:
                message = event|PASS_TO_SYSAPP;
				dParam = *(al_uint32 *)param;
                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;

#ifdef CONFIG_QSD
			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;

			case FW_QSD_DTV_SetCH:
				dParam = (UINT32)APP_Database_GetHdlByIdx(*(UINT32 *)param);
				message = APP_DVB_GLOBAL_EVENT_ZAPPING|PASS_TO_SYSAPP;
				break;
#endif

#ifdef CONFIG_SUPPORT_EWS
			case FW_EWS_REC_ANCM:
			case FW_EWS_FIND_AUD:
				dParam =*(al_uint32 *) param;
				message = FW_EWS_FIND_AUD|PASS_TO_SYSAPP;
				break;
			case FW_EWS_ACTIVE:
			case FW_EWS_INACTIVE:
			case FW_EWS_NON_ANCM:
				message = event|PASS_TO_SYSAPP;
				break;
#endif
            case FW_USB_PLUGIN:
                break;
            case FW_USB_PLUGOUT:
                break;
#ifdef CONFIG_HDMI_SUPPORT_MHL
			case FW_HDMI_MHL_CONNECTED:
				dParam = *(UINT32 *)param;
				if(dParam == 1)
				{
					message = DMN_EVENT_MHL_CHANGE_SOURCE|PASS_TO_SYSAPP;		
				}
				break;
#endif
			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 DVBApp_VolumeKeyHandler(UINT32 dMessage, UINT8 IsCECKey)
{
	UINT8 u8Mute=0;
	al_uint8 bSignalState = al_false;

	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)
			{
				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_DVB, APP_GUIOBJ_MUTE,APP_INTRA_EVENT_HIDE_MUTE, 0);
				}
			}
		}
#endif
	}
	else
	{
		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)
			{
				AL_DVB_Monitor_GetState(AL_DVB_MONITOR_STATE_SIGNAL, &bSignalState);
				if ((bSignalState == AL_DVB_MONITOR_VALUE_TRUE)
#ifdef CONFIG_SUPPORT_PVR
					|| (MID_TSPLParser_GetThreadState())
#endif
					)
				{
					APP_Audio_SetMute(FALSE, TRUE, APP_MUTE_MODE_SIGNAL_DETECT, APP_SOURCE_DTV);
				}
				else
				{
					APP_Audio_SetMute(FALSE, TRUE, APP_MUTE_MODE_NO_SIGNALE, APP_SOURCE_DTV);
				}
				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

				SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_DVB, APP_GUIOBJ_MUTE,APP_INTRA_EVENT_HIDE_MUTE, 0);
			}
		}
	}

	if (DVBApp_IsPopupExist(PLAYBACK_POPUP_MSG_NO_SIGNAL))
	{
		DVBApp_ClosePopup(PLAYBACK_POPUP_MSG_NO_SIGNAL, UI_EVENT_NULL);
	}

	if (DVBApp_IsPopupExist(PLAYBACK_POPUP_MSG_RADIO_CHANNEL))
	{
		DVBApp_ClosePopup(PLAYBACK_POPUP_MSG_RADIO_CHANNEL, UI_EVENT_NULL);
	}
	if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_BANNER))
	{
		SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, APP_GUIOBJ_BANNER);
	}
#ifdef CONFIG_SUPPORT_PVR
	if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVRREC_INFO))
	{
		SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PVRREC_INFO);
	}
	if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PVR_REC))
	{
		SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PVR_REC);
	}
#endif
	if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, DVB_GUIOBJ_PROGINFO))
	{
		SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, DVB_GUIOBJ_PROGINFO);
	}
    if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_AMPLIFIERVOLUME))
    {
        SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, APP_GUIOBJ_AMPLIFIERVOLUME);
    }

	if(IsCECKey == TRUE)
	{
		if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_ADJUST))
		{
			SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, APP_GUIOBJ_ADJUST);
		}
		if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_AMPLIFIERVOLUME))
		{
			SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, APP_GUIOBJ_AMPLIFIERVOLUME);
		}
		else
		{
			SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, APP_GUIOBJ_AMPLIFIERVOLUME, 0);
		}
	}
	else
	{
		if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_AMPLIFIERVOLUME))
		{
			SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, APP_GUIOBJ_AMPLIFIERVOLUME);
		}
		if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_DVB, APP_GUIOBJ_ADJUST))
		{
			SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_DVB, APP_GUIOBJ_ADJUST);
		}
		else
		{
            //Below is CV's spec,pressing Volume key should realize function instead of showing adjust bar only.
            UINT8 u8VolumeIdx = g_stVariationalData.Volume;
            if (dMessage == UI_EVENT_VOL_UP)
			{
				g_stVariationalData.Volume = u8VolumeIdx >= ADJUST_MAX_VALUE ? ADJUST_MAX_VALUE : ++u8VolumeIdx;
			}
			else if (dMessage == UI_EVENT_VOL_DN)
			{
				g_stVariationalData.Volume = u8VolumeIdx <= ADJUST_MIN_VALUE ? ADJUST_MIN_VALUE : --u8VolumeIdx;
			}
			AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FACTHOTEL, 0,
				sizeof(APP_SETTING_FactoryHotel_t), &(g_stFactoryHotelData));
			if ((g_stFactoryHotelData.MaxVolume < g_stVariationalData.Volume)
				&&(g_stFactoryHotelData.HotelModeOnOff == 1))
			{
				g_stVariationalData.Volume = g_stFactoryHotelData.MaxVolume;
			}
			APP_Audio_SetVolume((UINT32)g_stVariationalData.Volume);
			AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_VARIATIONAL,
				ITEM_OFFSET(APP_SETTING_Variational_t, Volume),
				sizeof(g_stVariationalData.Volume), &(g_stVariationalData.Volume));
			//AL_Setting_Store(APP_Data_UserSetting_Handle(), SYS_SET_ID_USERINFO,
				//ITEM_OFFSET(APP_SETTING_UserInfo_t, Volume), sizeof(g_stUserInfoData.Volume));
			SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_DVB, APP_GUIOBJ_ADJUST, ADJUST_VOLUME);
		}
	}
}

Boolean DVBApp_GetUnstableState(void)
{
	return g_bUnstable;
}
void DVBApp_SetUnstableState(Boolean bstate)
{
	g_bUnstable = bstate;
}

#ifdef CONFIG_SUPPORT_EWS
al_uint8 DVBApp_GetEWSMode(void)
{
	return g_EWSMode;
}
void DVBApp_ResetEWS(void)
{
	dvb_printf("\n\n[%s] is called!!!!!!!\n\n", __FUNCTION__);
	DMIOC_SET_EWS_PARAM stEwsParam;
	memset(&stEwsParam, 0, sizeof(DMIOC_SET_EWS_PARAM));
	if (g_EWSMode == TRUE)
	{
		stEwsParam.bActive = FALSE;
		ioctl(dtvdev, DTV_IOCTL_Set_EWS_Data  , &stEwsParam);
	}
	g_PrevProgHandle = AL_DB_INVALIDHDL;
	g_EWSMode = FALSE;
	memset(&g_PrevAudioPid, 0, sizeof(DBPIDInfo_t));
	g_PrevAudioPid.usDataPID = DB_DVB_INVALID_PID;
	memset(&g_MonAudioPid, 0, sizeof(DBPIDInfo_t));
	g_MonAudioPid.usDataPID = DB_DVB_INVALID_PID;
	AL_EWS_Monitor_ResetData();
}
#endif

Boolean DVBApp_CheckHasVideo(void)
{
	AL_RecHandle_t hTempHdl = AL_DB_INVALIDHDL;
	MID_PlaybackGetCurProgHandle(al_null, &hTempHdl);
	DBPIDInfo_t 	stVideoPid;
	memset(&stVideoPid,0xff,sizeof(DBPIDInfo_t));
				
	AL_DB_QueryDetailFieldByName(hTempHdl, (al_uint8 *)"stVideoPid", (al_void *)&stVideoPid);	

	if ((stVideoPid.usDataPID&0x1fff) == 0x1fff)
	{
		return FALSE;
	}
	else
	{
		return TRUE;
	}
}