/******************************************************************************
** main_app_initflow.c:
**
** Copyright(c) 2008 Sunplus Technologies - All Rights Reserved
**
** History Information Description
** Date						Author					Modification
** 2009/04/21										Create
** 2009/08/05										Modify
******************************************************************************/

#define APPLICATION_MESSAGE_FILTER_TABLE_HERE
#define SYSTEM_APPLICATION_TABLE_DEFINE_HERE

/********************************************************************
	header file
********************************************************************/
#include <sys/ioctl.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <sys/time.h>
#include <sys/vfs.h>
#include "app_event.h"
#include "sysapp_if.h"
#include "sysapp_table.h"
#include "app_msg_filter_tbl.h"
#include "main_app.h"
#include "main_app_external.h"
#include "sysapp_table.h"
#include "sysapp_timer.h"
#include "al_fw.h"
#include "al_util.h"
#include "atv_app.h"
#if defined(CONFIG_DVB_SYSTEM) || defined(CONFIG_AUS_DVB_SYSTEM) || defined(CONFIG_DTMB_SYSTEM)
#include "dvb_app.h"
#endif
#ifdef CONFIG_ISDB_SYSTEM
#include "sbtvd_app.h"
#endif
#ifdef CONFIG_SUPPORT_NETAPP
#include "network_app.h"
#endif
#include "ir_map.h"
#include "umf_ir.h"
#include "drv_dtv_external.h"
#if defined(CONFIG_DTV_SUPPORT) || defined(CONFIG_ATV_SUPPORT)
#include "drv_tuner_external.h"
#endif
#include "kmf_ioctl.h"
#include "ap_extern.h"
#include "mid_dtv_display.h"
#ifdef CONFIG_DTV_SUPPORT
#include "mid_playback.h"
#endif
#include "mid_tvfe.h"
#include "middleware/debug/mid_mon.h"
#ifdef CONFIG_SUPPORT_SW_AFC
#include "mid_afc.h"
#endif
#include "cust_nvm_cfg.h"
#include "app_data_setting.h"
#if defined(CONFIG_DVB_SYSTEM) || defined(CONFIG_AUS_DVB_SYSTEM) || defined(CONFIG_DTMB_SYSTEM)
#include "app_dvb_playback.h"
#endif
#ifdef CONFIG_ISDB_SYSTEM
#include "app_sbtvd_playback.h"
#endif

#include "TV_region_config.h"
#ifdef CONFIG_TV_NEW_UI
#include "app_regionmgr_new.h"
#else
#include "app_regionmgr.h"
#endif
#include "gl_queue.h"
#include "gl_timer.h"
#include "app_gui.h"
#ifdef CONFIG_SCART_SUPPORT
#include "app_scart.h"
#endif
#include "app_audio.h"
#include "app_video.h"
#include "app_factory.h"
#if defined(CONFIG_DTV_SUPPORT) || defined(CONFIG_ATV_SUPPORT)
#include "app_database.h"
#include "app_scan_save.h"
#include "app_scan_api.h"
#include "al_aps_table_api.h"
#include "tuner_demod_ioctl.h"
#include "app_prog_list.h"
#endif
#include "app_sysset.h"
#include "mid_partition_list.h"
#ifdef SUPPORT_LED_FLASH
#include "app_led_control.h"
#endif
#ifdef CONFIG_SUPPORT_PVR
#include "mid_recorder.h"
#endif
#include <sismmio.h>
#ifdef SUPPORT_CEC_TV
#include "umf_cec.h"
#include "app_guiobj_hdmilink.h"
#endif
#ifdef CONFIG_SUPPORT_MIRACAST
#include "umf_miracast.h"
#include "netsetting_if.h"
#include "net_ip_setting.h"
//#include "wfd_if.h"
#endif
#ifdef CONFIG_SUPPORT_NET_OTA
#include "net_ota.h"
#endif
#include "app_systime.h"
#ifdef CONFIG_SUPPORT_IR_TX
#include "umf_autodvd.h"
#include "app_dvd.h"
#endif
#include "umf_event.h"
#include "app_console.h"
#include "app_area_info.h"
#include "app_iso639.h"
#include "pin_config.h"
#include "ap_extern.h"
#include "nvm_ioctl.h"
#include "app_guiobj_date_time.h"
#ifdef CONFIG_DTV_SUPPORT
#include "mid_siutil.h"
#endif
#include "util_ioctl.h"
#include "hdmi_ioctl.h"
#include "app_factory_flash_access.h"
#ifdef CONFIG_AUTO_USB_STORE_IRSEQ
#include "umf_automation.h"
#endif
#ifdef CONFIG_ATV_SUPPORT
#include "app_guiobj_atv_playback.h"
#endif
#ifdef CONFIG_DTV_SUPPORT
#if defined(CONFIG_DVB_SYSTEM) || defined(CONFIG_AUS_DVB_SYSTEM) || defined(CONFIG_DTMB_SYSTEM)
#include "app_guiobj_dtv_playback.h"
#if defined(CONFIG_CIPLUS_SUPPORT)
#include "app_ciplus_op.h"
#endif
#endif
#ifdef CONFIG_ISDB_SYSTEM
#include "app_guiobj_sbtvd_playback.h"
#endif
#endif

#if defined (CONFIG_SUPPORT_USB_UPGRADE) || defined (CONFIG_SUPPORT_OTA_UPGRADE)
#include "mid_upgrade.h"
#if defined(CONFIG_DVB_SYSTEM) || defined(CONFIG_AUS_DVB_SYSTEM) || defined(CONFIG_DTMB_SYSTEM)
#include "app_guiobj_dtv_ota_upgrade_prompt.h"
#elif defined CONFIG_ISDB_SYSTEM
#include "app_guiobj_sbtvd_ota_upgrade_prompt.h"
#endif
#endif

#if defined(CONFIG_SUPPORT_SYSTEM_STANDBYTIME) || defined(CONFIG_SUPPORT_SYSTEM_LIFETIME)
#include "app_usb_upgrade.h"
#endif

#include "app_guiobj_sleeptimer.h"
#include "app_guiobj_cul_fm_factorySetting_new.h"
#include "app_power_control.h"
#include "app_guiobj_fm_factory.h"

#include "util_ioctl.h"
#ifdef CONFIG_INN_UART_FAC_MODE
#include "al_console_inn_rs232.h"
#endif
#ifdef CONFIG_HK_UART_FAC_MODE
#include "al_console_HkRs232.h"
#endif
#ifdef CONFIG_TPV_UART_FAC_MODE
#include "al_console_TpvRs232.h"
#endif

#ifdef CONFIG_SUPPORT_NET_SETTING
#include "app_guiobj_Network_Information.h"
#endif
#ifdef CONFIG_MEDIA_ENABLE
#include "AL_Multimedia_FileSystem_IF.h"
#include "AL_Multimedia_Player_Types.h"
#include "media_app.h"
#endif
#ifdef CONFIG_BLUETOOTH_SUPPORT
#include "al_bluetooth.h"
#include "al_bluetooth_ctrl.h"
#ifdef CONFIG_BLUETOOTH_UPGRADE_SUPPORT
#include "al_bluetooth_upgrader.h"
#endif
#ifdef CONFIG_BT_RDA5856
#include "app_bt.h"
#endif
#endif

#ifdef CONFIG_SUPPORT_NES_GAME
#include "umf_js.h"
#include "nes_game.h"
#include "atv_guiobj_table.h"
#endif
#ifdef CONFIG_ENABLE_UMF_MODULES
#include "umf_mod.h"
#ifdef CONFIG_ENABLE_UMF_LANGUAGE_MODULES
#include "app_guiobj_language.h"
#endif
#endif
#ifdef CONFIG_EXTIC_DIGITALAMP_TAS5711
#include "TAS5711.h"
#endif
#ifdef CONFIG_EXTIC_KEYSTONE_CORRECTION_POL8902
#include "POL8902.h"
#endif
#ifdef CONFIG_SMART_MODULE_SUPPORT
#include "al_uart_smart.h"
#include "al_uart_smart_ctrl.h"
#include "app_smart.h"
#endif
#ifdef CONFIG_STB_MODULE_SUPPORT
#include "al_uart_stb.h"
#include "al_uart_stb_ctrl.h"
#include "app_stb.h"
#endif

#include "drv_pq_internal.h"
#include "app_systime.h"

#ifdef AC_ON_AUTO_GET_TIME
extern Boolean g_fBackgroundGetTime;
#endif
#include "drv_hdmi_external.h"
#ifdef CONFIG_HDMI_NOSIGNAL_POWEROFF_HDMI_WAKE_UP
#include "umf_ioctl.h"
#endif

/********************************************************************
	macro define
********************************************************************/
#define MAIN_APP_DEBUG
#ifdef MAIN_APP_DEBUG
#undef mainapp_printf
#define mainapp_printf(fmt, arg...) UMFDBG(0,"[Main App]:"fmt, ##arg)
#else
#define mainapp_printf(fmt, arg...) ((void) 0)
#endif

#define DBGCONFIADDR  0xa0000010
#define AC_FACTORY   0x80

#define WAKE_FLAG_REG526 0xbe0f0526
#ifdef CONFIG_SUPPORT_ALL_HDMI_PORTS_WAKE_UP
#define WAKE_SOURCE_HDMI 0x7
#define WAKE_SOURCE_VGA  0x40
#endif
#ifdef CONFIG_SUPPORT_SYSTEM_STANDBYTIME
#define SYSTEM_STANDBYMODE_TIME 0xbe0f0527
#endif
/********************************************************************
	Function declare
********************************************************************/

/********************************************************************
	global  variables
********************************************************************/

#ifdef SUPPORT_USB_UPGRADE_LONG_PRESS_KEYPAD_POWER
UINT8 IsKeypadPowerOnPressRepeat = FALSE;
#endif

#ifdef CONFIG_BT_RDA5856
Boolean g_SystemPowerOnReadyNeedReconnectBT = FALSE;
#endif

#ifdef CONFIG_SUPPORT_MIRACAST
Boolean bWifiDongle = FALSE;
#endif

#if defined(CONFIG_DTV_SUPPORT) || defined(CONFIG_ATV_SUPPORT)
#ifdef CONFIG_ISDB_SYSTEM
static void _MAINAPP_ResetDefVal(AL_DB_EDBType_t eDBType, AL_DB_ERecordType_t eRecType, al_void const * pService, al_uint32 u32ChannelIdx)
{
    /*
     * i assume the atv database layout is below:
     *     +------------------+--------------------+
     * Low | air atv database | cable atv database | High
     *     +------------------+--------------------+
     * and, SBTVD atv spec is tabelscan, so, when reset atv database,
     * i make all channel is active, but is no signal(available = 0)
     */

	SADBServInfo_t *pServInfo = al_null;
    app_scan_table_info_st air_table_info;
    app_scan_table_info_st cable_table_info;

	if (al_null == pService)
	{
		return;
	}

	pServInfo = (SADBServInfo_t *)pService;

    APP_Scan_API_GetTableInfo(RF_INPUT_PORT_AIR, &air_table_info);
    APP_Scan_API_GetTableInfo(RF_INPUT_PORT_CABLE, &cable_table_info);

	switch (eRecType)
	{
		case AL_RECTYPE_ATVSERVICE:
            if (u32ChannelIdx < air_table_info.u32ScanTableLen)
            {
                pServInfo->inuse = 0;
				pServInfo->skip = 0;
#ifdef CONFIG_DVB_SYSTEM
				pServInfo->u32Freq = air_table_info.pu32ScanTable[u32ChannelIdx]*1000;
                pServInfo->soundSystem = APP_OSD_SOUND_SYSTEM_M;
#elif defined(CONFIG_ISDB_SYSTEM) && defined CONFIG_ATV_SUPOORT
				pServInfo->u32Freq = air_table_info.pu32ScanTable[u32ChannelIdx];
                pServInfo->soundSystem = ANA_SCAN_AUDIO_STD_BTSC;
#endif

                pServInfo->colorSystem = APP_OSD_COLOR_SYSTEM_AUTO;
                pServInfo->multiAudio = TVFE_AUDIO_SIF_MODE_ERR;
                pServInfo->tvtype = 0;
            }
            else
            {
                pServInfo->inuse = 0;
				pServInfo->skip = 0;
#ifdef CONFIG_DVB_SYSTEM
				 pServInfo->u32Freq = cable_table_info.pu32ScanTable[u32ChannelIdx-air_table_info.u32ScanTableLen]*1000;
                pServInfo->soundSystem = APP_OSD_SOUND_SYSTEM_M;
#elif defined(CONFIG_ISDB_SYSTEM) && defined CONFIG_ATV_SUPOORT
				pServInfo->u32Freq = cable_table_info.pu32ScanTable[u32ChannelIdx-air_table_info.u32ScanTableLen];
                pServInfo->soundSystem = ANA_SCAN_AUDIO_STD_BTSC;
#endif
                pServInfo->colorSystem = APP_OSD_COLOR_SYSTEM_AUTO;
                pServInfo->multiAudio = TVFE_AUDIO_SIF_MODE_ERR;
                pServInfo->tvtype = 1;
            }
			break;

		default:
			break;
	}
}
#else
#ifndef CONFIG_SUPPORT_ATV_SCAN_NTSCM_PALM_N
static void _MAINAPP_ResetDefVal(AL_DB_EDBType_t eDBType, AL_DB_ERecordType_t eRecType, al_void const * pService, al_uint32 u32ChannelIdx)
{
	SADBServInfo_t *pServInfo = al_null;

	if (al_null == pService)
	{
		return;
	}

	pServInfo = (SADBServInfo_t *)pService;

	switch (eRecType)
	{
		case AL_RECTYPE_ATVSERVICE:
			pServInfo->u32Freq = ATV_SCAN_RANGE_MIN;
			u32ChannelIdx = u32ChannelIdx;
			pServInfo->skip = 0;
			pServInfo->colorSystem = APP_OSD_COLOR_SYSTEM_AUTO;
#ifdef CONFIG_ATV_SUPPORT
			pServInfo->soundSystem = ANA_SCAN_AUDIO_STD_ERR;
#endif
			pServInfo->multiAudio = TVFE_AUDIO_SIF_MODE_ERR;
			break;

		default:
			break;
	}
}
#else
static void _MAINAPP_ResetDefVal(AL_DB_EDBType_t eDBType, AL_DB_ERecordType_t eRecType, al_void const * pService, al_uint32 u32ChannelIdx)
{
    /*
     * i assume the atv database layout is below:
     *     +------------------+--------------------+
     * Low | air atv database |  catv atv database | High
     *     +------------------+--------------------+
     * and, atv spec is tabelscan, so, when reset atv database,
     * i make all channel is active, but is no signal(available = 0)
     */

	SADBServInfo_t *pServInfo = al_null;
    app_scan_table_info_st air_table_info;
    app_scan_table_info_st cable_table_info;

	if (al_null == pService)
	{
		return;
	}

	pServInfo = (SADBServInfo_t *)pService;

    APP_Scan_API_GetTableInfo(ATV_TYPE_AIR, &air_table_info);
    APP_Scan_API_GetTableInfo(ATV_TYPE_CATV, &cable_table_info);

	switch (eRecType)
	{
		case AL_RECTYPE_ATVSERVICE:
            if (u32ChannelIdx < air_table_info.u32ScanTableLen)
            {
                pServInfo->u32Freq = air_table_info.pu32ScanTable[u32ChannelIdx];
                pServInfo->inuse = 0;
                pServInfo->soundSystem = ANA_SCAN_AUDIO_STD_BTSC;
                pServInfo->colorSystem = APP_OSD_COLOR_SYSTEM_NTSC358;
                pServInfo->multiAudio = TVFE_AUDIO_SIF_MODE_ERR;
                pServInfo->tvtype = 0;
				pServInfo->skip = 0;
            }
            else
            {
                pServInfo->u32Freq = cable_table_info.pu32ScanTable[u32ChannelIdx-air_table_info.u32ScanTableLen];
                pServInfo->inuse = 0;
                pServInfo->soundSystem = ANA_SCAN_AUDIO_STD_BTSC;
                pServInfo->colorSystem = APP_OSD_COLOR_SYSTEM_NTSC358;
                pServInfo->multiAudio = TVFE_AUDIO_SIF_MODE_ERR;
                pServInfo->tvtype = 1;
				pServInfo->skip = 0;
            }
			break;

		default:
			break;
	}
}
#endif
#endif
#endif

#ifdef CONFIG_BLUETOOTH_SUPPORT
#ifndef CONFIG_BT_RDA5856
static int _MAINAPP_Bluetooth_Callback(BT_Message_t eMessage, UINT32 u32Param)
{
    UINT32 u32Message = DMN_EVENT_MAX;

    switch (eMessage)
    {
      case BT_MESSAGE_MODE:
          /*HB_STATUS_MODE_STANDBY (0x100)
           * HB_STATUS_MODE_BT (0x200) */
          printf("==mode:0x%x==\n", u32Param);
          if (u32Param == HB_STATUS_MODE_STANDBY)
              u32Message = DMN_EVENT_BLUETOOTH_STANDBY;
          else if (u32Param == HB_STATUS_MODE_BT)
              u32Message = DMN_EVENT_BLUETOOTH_ENABLE;

          break;
      case BT_MESSAGE_CON_STATUS:
          /* HB_STATUS_BT_WAIT_CONN (0x01)
           * HB_STATUS_BT_RECONNECT (0x02)
           * HB_STATUS_BT_CONNECTED ( 0x03) */
          if (u32Param == HB_STATUS_BT_WAIT_CONN)
              u32Message = DMN_EVENT_BLUETOOTH_WAITCONNECT;
          else if (u32Param == HB_STATUS_BT_CONNECTED)
              u32Message = DMN_EVENT_BLUETOOTH_CONNECTED;
          else if (u32Param == HB_STATUS_BT_RECONNECT)
              u32Message = DMN_EVENT_BLUETOOTH_RECONNECTED;
          break;
      case BT_MESSAGE_PLAYER:
          /* HB_STATUS_BT_PLAYING (0x04)
           * HB_STATUS_BT_PAUSE    =  HB_STATUS_BT_CONNECTED */
          if (u32Param == HB_STATUS_BT_PLAYING)
              u32Message = DMN_EVENT_BLUETOOTH_PLAY;
          else if (u32Param == HB_STATUS_BT_PAUSE)
              u32Message = DMN_EVENT_BLUETOOTH_PAUSE;

          break;
      case BT_MESSAGE_PHONE:
          /*  HB_STATUS_BT_PHONE_CALL (0x05)
           * HB_STATUS_BT_ONGOING_CALL   =   HB_STATUS_BT_PHONE_CALL
           * HB_STATUS_BT_INCOMING_CALL (0x06 )
           * HB_STATUS_BT_OUTGOING_CALL (0x07) */
          if (u32Param == HB_STATUS_BT_PHONE_CALL)
              u32Message = DMN_EVENT_BLUETOOTH_ONCALL;
          else if (u32Param == HB_STATUS_BT_INCOMING_CALL || u32Param == HB_STATUS_BT_OUTGOING_CALL)
              u32Message = DMN_EVENT_BLUETOOTH_INCOMING_CALL;
          else if (u32Param == HB_STATUS_BT_PHONE_OFF_CALL)
              u32Message = DMN_EVENT_BLUETOOTH_OFFCALL;
          break;
      case BT_MESSAGE_BT_NAME:
          u32Message = DMN_EVENT_MAX;
          //Al_Bluetooth_Get_Action(BT_CMD_GET_NAME, data[BT_NAME_LEN_MAX])
          break;
      case BT_MESSAGE_PAIRED_NAME:
          u32Message = DMN_EVENT_BLUETOOTH_GET_PAIREDNAME;
          break;
      case BT_MESSAGE_MAC:
          u32Message = DMN_EVENT_MAX;
          //Al_Bluetooth_Get_Action(BT_CMD_GET_MAC, data[BT_MAC_LEN_MAX])
          break;
      case BT_MESSAGE_VER:
          u32Message = DMN_EVENT_MAX;
          //Al_Bluetooth_Get_Action(BT_CMD_GET_VER, data[BT_VER_LEN_MAX])
          break;
      case BT_MESSAGE_PHONE_NUM:
          u32Message = DMN_EVENT_BLUETOOTH_GET_PHONENUM;
          break;
      default:
          u32Message = DMN_EVENT_MAX;
          break;
    }

    if ((u32Message >= DMN_EVENT_BLUETOOTH_STANDBY) && (u32Message <= DMN_EVENT_BLUETOOTH_MAX))
    {
        MSG_FILTER_DispatchMessage((UINT32) u32Message, (UINT32) u32Param);
    }

    return 1;
}
#endif
#endif

#ifdef SUPPORT_CEC_TV
static int _MAINAPP_CEC_Callback(CECTV_Message_t eMessage, UINT32 u32Param )
{
	UINT32 u32Message;
#if defined (CONFIG_SUPPORT_USB_UPGRADE) || defined (CONFIG_SUPPORT_OTA_UPGRADE)
	if (Mid_CmnUpgradeIsUpgradeing()== TRUE)
	{
		mainapp_printf("[debug]%s		%d\n",__FUNCTION__,__LINE__);
		mainapp_printf("System is upgradeing........\n\n\n");
		return 1;
	}
#endif

	switch (eMessage)
	{
		case CECTV_MESSAGE_CHANGE_SOURCE:
			u32Message = DMN_EVENT_CECTV_CHANGE_SOURCE;
			break;

		case CECTV_MESSAGE_STANDBY:
			u32Message = DMN_EVENT_CECTV_STANDBY;
			break;

		case CECTV_MESSAGE_SET_MUTE_STATUS:
			u32Message = DMN_EVENT_CECTV_SET_MUTE_STATUS;
			break;

		case CECTV_MESSAGE_SET_SYSTEMAUDIO_STATUS:
			u32Message = DMN_EVENT_CECTV_SET_SYSTEMAUDIO_STATUS;
			break;

		case CECTV_MESSAGE_SET_DEVICE_OSDNAME:
			u32Message = DMN_EVENT_CECTV_SET_DEVICE_OSDNAME;
			break;

		default:
			u32Message = DMN_EVENT_MAX;
			break;
	}

	if ((u32Message > DMN_EVENT_MIN) && (u32Message < DMN_EVENT_MAX))
	{
		u32Message = u32Message | PASS_TO_SYSAPP;
		MSG_FILTER_DispatchMessage((UINT32)u32Message, (UINT32)u32Param);
	}

	return 1;
}
#endif


#ifdef CONFIG_SUPPORT_PVR
int _RecorderList_Callback(MID_PVRRecListParseMsg_t dPVRRecListCallbackType)
{
	switch (dPVRRecListCallbackType)
	{
		case PVR_RECLIST_PRESE_DONE:
			MSG_FILTER_DispatchMessage(DMN_EVENT_DVB_PVRLIST_PARSE_OK, 0);
			break;

		default:
			break;
	}

	return SP_SUCCESS;
}
#endif

#ifdef CONFIG_SUPPORT_MIRACAST
//#define MiracastEventFlag 0xCCDEF000
//INT32 _MAINAPP_MIRACAST_Callback(int event_id, void *arg)
static int _MAINAPP_MIRACAST_Callback(MIRACAST_Message_t eMessage, void *Param)
{
	int ret = 1;
	//UEvent nNewEvent;
	UINT32 u32Message = DMN_EVENT_MAX;
	char *pAddress;
	switch(eMessage)
	{
		case MIRACAST_FINDING:
			pAddress = malloc(strlen(Param)+1);
			memset(pAddress, '\0', strlen(Param)+1);
			memcpy(pAddress, Param, strlen(Param));
			printf("[Miracast Callback] MIRACAST_FINDING Address:%s \n", pAddress);
			u32Message = DMN_EVENT_MIRACAST_FINDING;
			free(pAddress);			
			
			//nNewEvent.id = MiracastEventFlag|MIRACAST_FINDING;
			//UEvent_Send(&nNewEvent);
			break;

		case MIRACAST_FIND_DEVICES:
			printf("[Miracast Callback] MIRACAST_FIND_DEVICES\n");
			//nNewEvent.id = MiracastEventFlag|MIRACAST_FIND_DEVICES;
			u32Message = DMN_EVENT_MIRACAST_FIND_DEVICES;
			//UEvent_Send(&nNewEvent);
			break;

		case MIRACAST_FIND_RETRY:
			printf("[Miracast Callback] MIRACAST_FIND_RETRY\n");
			//nNewEvent.id = MiracastEventFlag|MIRACAST_FIND_RETRY;
			u32Message = DMN_EVENT_MIRACAST_FIND_RETRY;
			//UEvent_Send(&nNewEvent);
			break;

		case MIRACAST_CONNECTING:
			printf("[Miracast Callback] MIRACAST_CONNECTING\n");
			//nNewEvent.id = MiracastEventFlag|MIRACAST_CONNECTING;
			u32Message = DMN_EVENT_MIRACAST_CONNECTING;
			//UEvent_Send(&nNewEvent);
			break;

		case MIRACAST_CONNECT_SUCCESS:
			printf("[Miracast Callback] MIRACAST_CONNECT_SUCCESS\n");
			//nNewEvent.id = MiracastEventFlag|MIRACAST_CONNECT_SUCCESS;
			u32Message = DMN_EVENT_MIRACAST_CONNECT_SUCCESS;
			//UEvent_Send(&nNewEvent);
			break;

		case MIRACAST_CONNECT_INACTIVE:
			printf("[Miracast Callback] MIRACAST_CONNECT_INACTIVE\n");
			//nNewEvent.id = MiracastEventFlag|MIRACAST_CONNECT_INACTIVE;
			u32Message = DMN_EVENT_MIRACAST_CONNECT_INACTIVE;
			//UEvent_Send(&nNewEvent);
			break;

		case MIRACAST_CONNECT_RETRY:
			printf("[Miracast Callback] MIRACAST_CONNECT_RETRY\n");
			//nNewEvent.id = MiracastEventFlag|MIRACAST_CONNECT_RETRY;
			u32Message = DMN_EVENT_MIRACAST_CONNECT_RETRY;
			//UEvent_Send(&nNewEvent);
			break;

		case MIRACAST_CONNECT_FAIL:
			printf("[Miracast Callback] MIRACAST_CONNECT_FAIL\n");
			//nNewEvent.id = MiracastEventFlag|MIRACAST_CONNECT_FAIL;
			u32Message = DMN_EVENT_MIRACAST_CONNECT_FAIL;
			//UEvent_Send(&nNewEvent);
			break;

		case MIRACAST_DISCONNECT_RECEIVED:
			printf("[Miracast Callback] MIRACAST_DISCONNECT_RECEIVED\n");
			//nNewEvent.id = MiracastEventFlag|MIRACAST_DISCONNECT_RECEIVED;
			u32Message = DMN_EVENT_MIRACAST_DISCONNECT_RECEIVED;
			//UEvent_Send(&nNewEvent);
			break;

		case MIRACAST_EXIT_SUCCESS:
			printf("[Miracast Callback] MIRACAST_EXIT_SUCCESS\n");
			//nNewEvent.id = MiracastEventFlag|MIRACAST_EXIT_SUCCESS;
			u32Message = DMN_EVENT_MIRACAST_EXIT_SUCCESS;
			//UEvent_Send(&nNewEvent);
			break;

		case MIRACAST_HDCP_FAIL:
			printf("[Miracast Callback] MIRACAST_HDCP_FAIL\n");
			//nNewEvent.id = MiracastEventFlag|MIRACAST_HDCP_FAIL;
			u32Message = DMN_EVENT_MIRACAST_HDCP_FAIL;
			//UEvent_Send(&nNewEvent);
			break;

		case MIRACAST_NO_DONGLE:
			printf("[Miracast Callback] MIRACAST_NO_DONGLE\n");
			//nNewEvent.id = MiracastEventFlag|MIRACAST_EXIT_SUCCESS;
			u32Message = DMN_EVENT_MIRACAST_NO_DONGLE;
			//UEvent_Send(&nNewEvent);
			break;

		default:
			printf("[Miracast Callback] warning: Unknown id = 0x%08X !!!\n", u32Message);
			u32Message = DMN_EVENT_MAX;
			break;
	}
	if ((u32Message >= DMN_EVENT_MIRACAST_FINDING) && (u32Message <= DMN_EVENT_MIRACAST_MAX))
	{
		MSG_FILTER_DispatchMessage((UINT32) u32Message, (UINT32) Param);
	}
	return ret;
}
#endif
#if defined(CONFIG_DTV_SUPPORT) || defined(CONFIG_ATV_SUPPORT)
static EDBError_t _MAINAPP_DBNVMReadCallBack(ECDBIDBType_t enDBType, UINT32 uiStart, UINT32 uiBytes, void *pBuff)
{
	INT8 bRetVal = FALSE;

#ifdef CONFIG_DVB_SYSTEM_SBTVD_SUPPORT
	if (enDBType == CDBI_DBTYPE_DVB_SBTVD)
	{
		bRetVal = Cmd_NVMRead(ENVMPurposeIDDatabaseSBTVD, TRUE, uiBytes, (UINT8 *)pBuff);
	}
	else
#endif
#ifdef CONFIG_DVB_SYSTEM_DVBT_SUPPORT
	if (enDBType == CDBI_DBTYPE_DVB_T)
	{
	#if defined(CONFIG_CIPLUS_SUPPORT)
		if( APP_CIPLUS_IsProfileSource() )
			bRetVal = Cmd_NVMRead(ENVMPurposeIDDatabaseProfileDVBT, TRUE, uiBytes, (UINT8 *)pBuff);
		else
	#endif
		bRetVal = Cmd_NVMRead(ENVMPurposeIDDatabaseDVBT, TRUE, uiBytes, (UINT8 *)pBuff);
	}
	else
#endif
#ifdef CONFIG_DVB_SYSTEM_DVBC_SUPPORT
	if (enDBType == CDBI_DBTYPE_DVB_C)
	{
	#if defined(CONFIG_CIPLUS_SUPPORT)
		if( APP_CIPLUS_IsProfileSource() )
			bRetVal = Cmd_NVMRead(ENVMPurposeIDDatabaseProfileDVBC, TRUE, uiBytes, (UINT8 *)pBuff);
		else
	#endif
		bRetVal = Cmd_NVMRead(ENVMPurposeIDDatabaseDVBC, TRUE, uiBytes, (UINT8 *)pBuff);
	}
	else
#endif
#ifdef CONFIG_DVB_SYSTEM_DVBS_SUPPORT
	if (enDBType == CDBI_DBTYPE_DVB_S)
	{
	#if defined(CONFIG_CIPLUS_SUPPORT)
		if( APP_CIPLUS_IsProfileSource() )
			bRetVal = Cmd_NVMRead(ENVMPurposeIDDatabaseProfileDVBS, TRUE, uiBytes, (UINT8 *)pBuff);
		else
	#endif
		bRetVal = Cmd_NVMRead(ENVMPurposeIDDatabaseDVBS, TRUE, uiBytes, (UINT8 *)pBuff);
	}
	else
#endif
#ifdef CONFIG_ATV_SUPPORT
	if (enDBType == CDBI_DBTYPE_DVB_ATV)
	{
		bRetVal = Cmd_NVMRead(ENVMPurposeIDDatabaseATV, TRUE, uiBytes, (UINT8 *)pBuff);
	}
	else
#endif
	{
		mainapp_printf("Database Read, Some Error Occurs!!!!!!!!\n");
	}

	return bRetVal ? DB_FAILURE : DB_SUCCESS;
}

static EDBError_t _MAINAPP_DBNVMWriteCallBack(ECDBIDBType_t enDBType, UINT32 uiStart, UINT32 uiBytes, void const *pBuff)
{
	INT8 bRetVal = FALSE;

#ifdef CONFIG_DVB_SYSTEM_SBTVD_SUPPORT
	if (enDBType == CDBI_DBTYPE_DVB_SBTVD)
	{
		bRetVal = Cmd_NVMWrite(ENVMPurposeIDDatabaseSBTVD, TRUE, uiBytes, (UINT8 *)pBuff);
	}
	else
#endif
#ifdef CONFIG_DVB_SYSTEM_DVBT_SUPPORT
	if (enDBType == CDBI_DBTYPE_DVB_T)
	{
	#if defined(CONFIG_CIPLUS_SUPPORT)
		if( APP_CIPLUS_IsProfileSource() )
			bRetVal = Cmd_NVMWrite(ENVMPurposeIDDatabaseProfileDVBT, TRUE, uiBytes, (UINT8 *)pBuff);
		else
	#endif
		{
	#ifdef CONFIG_SUPPORT_MALAYSIA_CERTIFICATION
		extern UINT8 g_isStandyByRescan;
		extern UINT8 g_isScanAllFreq;
		AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_CHANNEL, 0,
			sizeof(APP_SETTING_Channel_t), &(g_stChannelData));
		if ((g_stChannelData.Country == AREA_MALAYSIA) && g_isStandyByRescan && !g_isScanAllFreq)
		{
			return DB_SUCCESS;
		}
	#endif
		bRetVal = Cmd_NVMWrite(ENVMPurposeIDDatabaseDVBT, TRUE, uiBytes, (UINT8 *)pBuff);
		}
	}
	else
#endif
#ifdef CONFIG_DVB_SYSTEM_DVBC_SUPPORT
	if (enDBType == CDBI_DBTYPE_DVB_C)
	{
	#if defined(CONFIG_CIPLUS_SUPPORT)
		if( APP_CIPLUS_IsProfileSource() )
			bRetVal = Cmd_NVMWrite(ENVMPurposeIDDatabaseProfileDVBC, TRUE, uiBytes, (UINT8 *)pBuff);
		else
	#endif
		bRetVal = Cmd_NVMWrite(ENVMPurposeIDDatabaseDVBC, TRUE, uiBytes, (UINT8 *)pBuff);
	}
	else
#endif
#ifdef CONFIG_DVB_SYSTEM_DVBS_SUPPORT
	if (enDBType == CDBI_DBTYPE_DVB_S)
	{
	#if defined(CONFIG_CIPLUS_SUPPORT)
		if( APP_CIPLUS_IsProfileSource() )
			bRetVal = Cmd_NVMWrite(ENVMPurposeIDDatabaseProfileDVBS, TRUE, uiBytes, (UINT8 *)pBuff);
		else
	#endif
		bRetVal = Cmd_NVMWrite(ENVMPurposeIDDatabaseDVBS, TRUE, uiBytes, (UINT8 *)pBuff);
	}
	else
#endif
#ifdef CONFIG_ATV_SUPPORT
	if (enDBType == CDBI_DBTYPE_DVB_ATV)
	{
		bRetVal = Cmd_NVMWrite(ENVMPurposeIDDatabaseATV, TRUE, uiBytes, (UINT8 *)pBuff);
	}
	else
#endif
	{
		mainapp_printf("Database Write, Some Error Occurs!!!!!!!!\n");
	}

	return bRetVal ? DB_FAILURE : DB_SUCCESS;
}
#endif
Boolean MID_DTVCI_IsCAMFirmwareUpgrading(void);

void _MAINAPP_Ir_Callback(UINT32 IrKey, UINT32 dParam, UINT8 dKeyValue)
{
	UINT32  sysAppIdx = 0;
#ifdef CONFIG_CI_SUPPORT
	if (MID_DTVCI_IsCAMFirmwareUpgrading()&& IrKey != UI_EVENT_POWER)
	{
    	return;
	}
#endif

	if (IrKey < UI_EVENT_NULL)
	{
		#ifdef CONFIG_SMART_MODULE_SUPPORT
		{
			APP_Source_Type_t eSourceType = APP_SOURCE_MAX;
			APP_GUIOBJ_Source_GetCurrSource(&eSourceType);
			if((APP_SOURCE_HDMI + CONFIG_HDMI_SMART_PORT) == eSourceType)
			{
				APP_Smart_Set_Smart_IRKey(IrKey);
			}
		}
		#endif
		if ((APP_WAKEUP_GetBootFlag() == TRUE) &&
			((IrKey < UI_EVENT_NULL) && (IrKey != UI_EVENT_POWER) && (IrKey != UI_EVENT_KEYPAD_POWER)))
		{
			return;
		}

		if ((APP_GUIOBJ_Source_GetSourceTransState() == TRUE)
			&& ((IrKey != UI_EVENT_POWER) && (IrKey != UI_EVENT_KEYPAD_POWER)))
		{
			mainapp_printf("source translation no handle key\n");
			return ;
		}
		else if (MAIN_APP_SUCCESS == MAINAPP_GetActiveSystemAppIndex(&sysAppIdx))
		{
			if((IrKey == UI_EVENT_POWER) || (IrKey == UI_EVENT_KEYPAD_POWER))
			{
				APP_Video_OSD_PQSet(APP_VIDEO_OSD_ITEM_BACKLIGHT,AL_FLASH_GetBackLight());
#ifdef CONFIG_SUPPORT_MALAYSIA_CERTIFICATION
				extern UINT8 g_isStandyByRescan;
				AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_CHANNEL, 0,
					sizeof(APP_SETTING_Channel_t), &(g_stChannelData));
				if (AREA_MALAYSIA ==g_stChannelData.Country && g_isStandyByRescan && (AL_CS_IsStopFinish() == al_false))
				{
					extern UINT8 g_PowerOnDurRescan;

					g_PowerOnDurRescan = 1;
					AL_CS_Stop();
					do
					{
						GL_TaskSleep(500);
					}while (AL_CS_IsStopFinish() == al_false);
					GL_TaskSleep(1000);
					Cmd_SetPanelBacklightPower(1);
					Cmd_SetPanelPower(TRUE);
					APP_Video_SetMute(FALSE, FALSE, APP_MUTE_MODE_NO_SIGNALE, APP_SOURCE_MAX);
					APP_Audio_SetMute(FALSE, FALSE, APP_MUTE_MODE_STATEMAX, APP_SOURCE_MAX);
					return;
				}
#endif
			}
			if (
#ifdef CONFIG_ATV_SUPPORT
				((sysAppIdx == SYS_APP_ATV) && (APP_GUIOBJ_ATV_Playback_GetZappingState() == TRUE)) ||
#endif
#ifdef CONFIG_DTV_SUPPORT
				((sysAppIdx == SYS_APP_DVB) && (APP_GUIOBJ_DVB_Playback_GetZappingState() == TRUE)) ||
#endif
			0)
			{
				mainapp_printf("zapping no handle key\n");
				return ;
			}
		}

		if (dParam&IR_EVENT_SINGLE_END
#ifdef SUPPORT_PIPMENU_TO_NEXT_AND_FF			
			&& IrKey != UI_EVENT_PIP_MENU
#endif
			)
		{
			return;
		}
#ifdef CONFIG_KEYPAD_SINGLE_REUSE
		if (dParam & (KEYPAD_EVENT_REPEAT_END))
		{
			dParam = dParam & (~KEYPAD_EVENT_REPEAT_END);
			dParam = dParam & (~KEYPAD_EVENT_REPEAT_TYPE);
			//Remove KEYPAD_EVENT_REPEAT_END & KEYPAD_EVENT_REPEAT_TYPE, dParam isn't repeat event now.
		}
		if (dParam & (IR_EVENT_REPEAT_END))
		{
			return;
		}
#else

		if (dParam & (KEYPAD_EVENT_REPEAT_END|IR_EVENT_REPEAT_END))
		{
			return;
		}
#endif
		extern const char *Ir_GetKeyString(UINT32 IrKey);
		if (strcmp(Ir_GetKeyString(IrKey), "Unknown"))
		{
			mainapp_printf("%s is pressed. time:%d\n",Ir_GetKeyString(IrKey),GL_GetRtc32());
		}
		else
		{
			mainapp_printf("IrKey ========== %d, time:%d\n",IrKey,GL_GetRtc32());
		}

		IrKey = IrKey|APPLICATION_EXTERNAL_UI_MESSAGE_TYPE;
		MSG_FILTER_DispatchMessage((UINT32)IrKey, (UINT32)dParam);
	}
}
#ifdef CONFIG_SUPPORT_NES_GAME
void _MAINAPP_Joystick_Callback(UINT32 Key, UINT32 joypadNum)
{
	if (Key == APP_GLOBAL_EVENT_JS_ADJUST_OK || Key == APP_GLOBAL_EVENT_JS_ADJUST_NG || Key == APP_GLOBAL_EVENT_JS_REMOVE)
	{
		MSG_FILTER_DispatchMessage((UINT32) Key, (UINT32) joypadNum);
	}
    else if (joystick_Convert_UIEvent_Get() && SYSAPP_GOBJ_GUIObjectExist(SYS_APP_ATV, APP_GUIOBJ_NESGAME_RUNNING))
    {

        if (Key == ADD_EVENT_JOYPAD_L1)
        {
            //mainapp_printf("[%s:%d] ADD_EVENT_JOYPAD_L1 !!!!!!!!!!!!!!!!!!!, JS NUMBER: %d\n",__FUNCTION__,__LINE__,joypadNum);
            Key = UI_EVENT_EXIT|APPLICATION_EXTERNAL_UI_MESSAGE_TYPE;
            MSG_FILTER_DispatchMessage((UINT32) Key, (UINT32) joypadNum);
        }
        else
        {
            Nes_Excute_Key(Key, (JoyPadNum)joypadNum);
        }
    }
    else if (joystick_Convert_UIEvent_Get())
    {
        switch (Key)
        {
            case ADD_EVENT_JOYPAD_UP:
                Key = UI_EVENT_UP|APPLICATION_EXTERNAL_UI_MESSAGE_TYPE;
				MSG_FILTER_DispatchMessage((UINT32) Key, (UINT32) joypadNum);
				break;
            case ADD_EVENT_JOYPAD_DOWN:
                Key = UI_EVENT_DOWN|APPLICATION_EXTERNAL_UI_MESSAGE_TYPE;
                MSG_FILTER_DispatchMessage((UINT32) Key, (UINT32) joypadNum);
                break;
            case ADD_EVENT_JOYPAD_LEFT:
                Key = UI_EVENT_LEFT|APPLICATION_EXTERNAL_UI_MESSAGE_TYPE;
                MSG_FILTER_DispatchMessage((UINT32) Key, (UINT32) joypadNum);
                break;
            case ADD_EVENT_JOYPAD_RIGHT:
                Key = UI_EVENT_RIGHT|APPLICATION_EXTERNAL_UI_MESSAGE_TYPE;
                MSG_FILTER_DispatchMessage((UINT32) Key, (UINT32) joypadNum);
                break;
            case ADD_EVENT_JOYPAD_START:
                //mainapp_printf("[%s:%d] ADD_EVENT_JOYPAD_SELECT !!!!!!!!!!!!!!!!!!!, JS NUMBER: %d\n",__FUNCTION__,__LINE__,joypadNum);
                Key = UI_EVENT_ENTER|APPLICATION_EXTERNAL_UI_MESSAGE_TYPE;
                MSG_FILTER_DispatchMessage((UINT32) Key, (UINT32) joypadNum);
                break;
            case ADD_EVENT_JOYPAD_L1:
                Key = UI_EVENT_EXIT|APPLICATION_EXTERNAL_UI_MESSAGE_TYPE;
                MSG_FILTER_DispatchMessage((UINT32) Key, (UINT32) joypadNum);
                break;
        }
    }

}
#endif

#ifdef CONFIG_SUPPORT_NET_OTA
void NET_OTA_Event_Callback(NET_OTA_Event_e event, int param)
{
	UINT32 Message = 0;
	UINT32 Param = 0;

	switch(event)
	{
		case NET_OTA_EVENT_NEW_UPDATE_FOUND:
			mainapp_printf("\nNET_OTA_EVENT_NEW_UPDATE_FOUND\n");
			Message = APP_GLOBAL_EVENT_OTA_UPGRADE | PASS_TO_SYSAPP;
			Param = param; // 1:EraseAll,0:not EraseAll
			break;
		default:
			return;
	}

    MSG_FILTER_DispatchMessage(Message, Param);
}
#endif

void DeviceMountStatus_Callback(MID_DeviceMount_Event_e Event, MID_DeviceMount_Event_Detail_t* Detail)
{
    UINT32 Message;

    switch(Event)
    {
        case MID_DEVICEMOUNT_EVENT_MOUNT_SUCCESS:
            Message = DMN_EVENT_USB_HDD_ATTACHED;
#ifdef CONFIG_MEDIA_ENABLE
            if (Detail != NULL)
            {
                USBLib_UpdateUsbVersion(TRUE, Detail->USBPath, Detail->USBPathlen, Detail->USBVersion);
            }
            {// the detach message for media source should action immediately
                UINT32  sysAppIdx = 0;
                GL_Queue_t QueueHandle = NULL;
                if (MAIN_APP_SUCCESS == MAINAPP_GetActiveSystemAppIndex(&sysAppIdx))
                {
                    if (sysAppIdx == SYS_APP_FILE_PLAYER)
                    {
				#ifdef CONFIG_USB_DEMO_SUPPORT
						extern void SysApp_MM_DestroyAppointedGUI(void);
						SysApp_MM_DestroyAppointedGUI();
				#endif
                        SYSAPP_IF_GetSystemAppQueueHandle(sysAppIdx , &QueueHandle);
                        GL_QueueFlush(QueueHandle ) ;
                    }
               	#ifdef CONFIG_USB_DEMO_SUPPORT
                    else
                    {
                    	APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_MEDIA);
                    }
				#endif
                }
            }
#endif
            break;

        case MID_DEVICEMOUNT_EVENT_DETACHED:
            Message = DMN_EVENT_USB_HDD_DETACHED;
            #ifdef CONFIG_MEDIA_ENABLE
            if (Detail != NULL)
            {
                USBLib_UpdateUsbVersion(FALSE, Detail->USBPath, Detail->USBPathlen, Detail->USBVersion);
            }
            #endif
            break;

        case MID_DEVICEMOUNT_EVENT_ATTACHED:
        case MID_DEVICEMOUNT_EVENT_MOUNT_FAIL:
        default:
            return;
    }
    MSG_FILTER_DispatchMessage(Message, 0);
#ifdef STATFS_IN_SPEED_THREAD
    if (Event == MID_DEVICEMOUNT_EVENT_MOUNT_SUCCESS && Detail != NULL)
    {
        struct statfs sbuf;
        printf("\n[%s, %d]statfs start!!!\n",__FUNCTION__,__LINE__);
        statfs(Detail->USBPath, &sbuf);
        printf("\n[%s, %d]statfs end!!!\n",__FUNCTION__,__LINE__);
    }
#endif
}

static void _MAINAPP_CheckEnterFactoryMode()
{
    UINT8 tmpVal = 0;

	
	Cmd_mmio_ReadUINT8(WAKE_FLAG_REG526, &tmpVal);
    if(tmpVal&AC_FACTORY)
    {
       Cmd_mmio_WriteUINT8(WAKE_FLAG_REG526, (tmpVal^AC_FACTORY));
	   SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_ATV, APP_GUIOBJ_FM_FACTORYSETTING, FIRST_ENTER_FACTORY);
    }
}

static void _MAINAPP_Mute_Init(void)
{
    UINT32 dCurIdx = 0;

#ifndef VIDEO_LOGO
	APP_Audio_SetMute(TRUE, FALSE, APP_MUTE_MODE_STATEMAX, APP_SOURCE_MAX);
#endif

	APP_Video_SetMute(TRUE, FALSE, APP_MUTE_MODE_STATEMAX, APP_SOURCE_MAX);

    AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_USERINFO, 0,
                    sizeof(APP_SETTING_UserInfo_t), &(g_stUserInfoData));
    dCurIdx = g_stUserInfoData.Mute;

	if (dCurIdx == APP_SWITCH_ON)
    {
#ifndef SUPPORT_STORE_MUTE_FLAG
        g_stUserInfoData.Mute = APP_SWITCH_OFF;

        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));
        AL_Setting_Store(APP_Data_UserSetting_Handle(), SYS_SET_ID_USERINFO,
                         ITEM_OFFSET(APP_SETTING_UserInfo_t, Mute),
                         sizeof(g_stUserInfoData.Mute));
#endif
    }

#ifdef SUPPORT_WAKEUP_TIMER_IN_STANDBY
	APP_WAKEUP_MuteAudio();
#endif
}

static void _MAINAPP_SW_Init(void)
{
#ifdef CONFIG_SUPPORT_NET_SETTING
	APP_Network_Init();
#endif
	/* init time offset to al_time */
	AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_CHANNEL, 0,
		sizeof(APP_SETTING_Channel_t), &(g_stChannelData));
	AL_Time_SetTimeOffset(g_stChannelData.Timediff);
#ifdef CONFIG_SUPPORT_ALL_HDMI_PORTS_WAKE_UP
	UINT8 wakeSrc = 0, portNum = 0;

	AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_USERINFO, 0,
			sizeof(APP_SETTING_UserInfo_t), &(g_stUserInfoData));
	Cmd_mmio_ReadUINT8(WAKE_FLAG_REG526, &wakeSrc);
	Cmd_mmio_WriteUINT8(WAKE_FLAG_REG526, (wakeSrc&AC_FACTORY));
	if(wakeSrc!=0)
	{
	    if(wakeSrc & WAKE_SOURCE_HDMI)
	    {
			for(portNum=0; (portNum<3 && wakeSrc!=0); portNum++)
			{
				if(((wakeSrc>>portNum)&0x1) !=0)
				{
#ifdef CONFIG_HDMI_PORT_MAP
					g_stUserInfoData.SourceIndex = (APP_SOURCE_HDMI+(((CONFIG_HDMI_PORT_MAP>>(portNum*4))&0xf)-1));
#else
                    g_stUserInfoData.SourceIndex = APP_SOURCE_HDMI;
#endif
					break;
				}
			}
		}
		else
		{
	    	if(wakeSrc & WAKE_SOURCE_VGA)
		    {
		        g_stUserInfoData.SourceIndex = APP_SOURCE_PC;
		    }
		}
		AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_USERINFO, 0,
			sizeof(APP_SETTING_UserInfo_t), &(g_stUserInfoData));
		AL_Setting_Store(APP_Data_UserSetting_Handle(),SYS_SET_ID_USERINFO, 0,
			sizeof(APP_SETTING_UserInfo_t));
			
	}
#endif
#ifdef CONFIG_DTV_SUPPORT
#ifdef CONFIG_MOD_PACK_DTV
	AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_USERINFO, 0,
			sizeof(APP_SETTING_UserInfo_t), &(g_stUserInfoData));
	if (g_stUserInfoData.SourceIndex != APP_SOURCE_MEDIA && g_stUserInfoData.SourceIndex != APP_SOURCE_MEDIA1)
	{
		umf_loadModule(UMFMOD_DTV);
		MID_SIUTIL_Init();
	}
#else
	MID_SIUTIL_Init();
#endif
#endif
#ifndef CONFIG_SUPPORT_MONITOR
	/* init time zone */
	AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FEATURE, 0,
		sizeof(APP_SETTING_Feature_t), &(g_stFeatureData));
	APP_GUIOBJ_DateTime_SetTimeZone(APP_GUIOBJ_DateTime_GetTimeZoneStringID(g_stFeatureData.TimeZone));
#endif
	MSG_FILTER_Initialize(MainAppQueueHandle, NULL);
	MSG_FILTER_SetMessageTable(MainAppMessageDefaultTable, (sizeof(MainAppMessageDefaultTable) / sizeof(UINT32)));

#ifdef CONFIG_SUPPORT_IR_TX
	Autodvd_ModualCfg_t AutodvdCfg =
	{
		.pfCallBack = APP_AUTODVD_Callback
	};
	Autodvd_Initialize(&AutodvdCfg);
#endif

#ifdef CONFIG_HDMI_SUPPORT
	HDMI_Customize_st stHDI_Customize;

    AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_USERINFO, 0,
			sizeof(APP_SETTING_UserInfo_t), &(g_stUserInfoData));
	stHDI_Customize.dSupportMaxHz	= SUPPORT_HDMI_VFREQ_MAX_HZ;	//the supported max V frequency of input timing
#if (CONFIG_CHIPID!=0x330)	//for ARC CTS using GPIO 5V to detect cable in/out
	stHDI_Customize.eARC_5V_GPIO = GPIO_ARC_DET;	//which GPIO is for ARC 5V
	stHDI_Customize.eARC_Port = HDMI_ARC_PORT_INDEX;	//which HDMI port is ARC port
#endif
    if(g_stUserInfoData.SourceIndex>= APP_SOURCE_HDMI && g_stUserInfoData.SourceIndex<=APP_SOURCE_HDMI2)
    	stHDI_Customize.eBootSrc = (g_stUserInfoData.SourceIndex - APP_SOURCE_HDMI); //HDMI_NUM_T
	else
		stHDI_Customize.eBootSrc = HDMI_NULL;
    
	Cmd_Hdmi_SetCustomization(stHDI_Customize);
#endif

#ifdef SUPPORT_WAKEUP_TIMER_IN_STANDBY
	/*< test code. */
	//APP_WAKEUP_MuteBlackLight();
#endif
	_MAINAPP_Mute_Init();

#ifdef CONFIG_BLUETOOTH_SUPPORT
#ifndef CONFIG_BT_RDA5856
    BT_ModualCfg_t BT_ModualCfg = {
        .pfCallBack = _MAINAPP_Bluetooth_Callback
    };
#else
    BT_ModualCfg_t BT_ModualCfg = {
        .pfCallBack = APP_BT_ModuleCallback
    };
	APP_BT_data_init(10);
#endif
    BlueTooth_Init(&BT_ModualCfg);

#ifdef CONFIG_BLUETOOTH_UPGRADE_SUPPORT
    BT_UpgradeCfg_t BT_UpgradeCfg = {
        .pfCallBack = APP_BT_UpgradeCallback
    };
	RegisterBTUpgradeCallback(&BT_UpgradeCfg);
#endif
#endif

#ifdef CONFIG_SMART_MODULE_SUPPORT
	Smart_ModualCfg_t Smart_ModualCfg = {
		.pfCallBack = APP_Smart_SmartModuleCallback
	};
	Smart_Init(&Smart_ModualCfg);
#endif

#ifdef CONFIG_STB_MODULE_SUPPORT
		STB_ModualCfg_t STB_ModualCfg = {
			.pfCallBack = APP_STB_STBModuleCallback
		};
		STB_Init(&STB_ModualCfg);
#endif
#if defined(CONFIG_DTV_SUPPORT) || defined(CONFIG_ATV_SUPPORT)
	/* initialize frontend */
	FrontendCmd_t  front;
	front.cmd = FRONTEND_CMD_INIT;
	front.param = NULL;
	ioctl(kmfdev, KMF_IOC_FRONTENDCTRL , &front);
	front.cmd = FRONTEND_CMD_SET_TUNER;
	front.param = NULL;
	ioctl(kmfdev, KMF_IOC_FRONTENDCTRL , &front);
	AL_CNIInit();
#endif
#ifdef CONFIG_DTV_SUPPORT
	extern void APP_GUIOBJ_Channel_SetFrontendRFType(void);
	APP_GUIOBJ_Channel_SetFrontendRFType();
#endif

#ifdef GPIO_DVD_ON_OFF
	//After power on TV platform, Need open DVD Power
	Cmd_gpio_WriteOnLevel(GPIO_DVD_ON_OFF);
#endif

#ifdef CONFIG_SUPPORT_SW_AFC
	/* init afc task */
	MID_AFC_Task_Init();
#endif

#ifdef CONFIG_SUPPORT_ALL_HDMI_PORTS_WAKE_UP     
	tv_SetBootRomHdmiSrc(CLEAR_HDMI_WAKE_SOURCE);
#endif
	tv_SetBootRomMenuSrcType(BootClear);
#ifdef CONFIG_DDC_CI_SUPPORT
	tv_SetDDCCIEnable(g_stSetupData.DDCCI_Enable);
#endif		

#if 0
#ifdef SUPPORT_PVR_CONTENT_PROTECT
	DRV_SpdrmInit();
#endif
#ifdef SUPPORT_NIM_RXDMA
	MID_RxdmaInit();
#endif
#endif

	AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_SETUP, 0,
					sizeof(APP_SETTING_Setup_t), &(g_stSetupData));
	SYSAPP_GOBJ_Set_OSDLOCK(g_stSetupData.Osd_locked);	

	UINT8 UARTMode=0;
	AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FACTUSER,
			ITEM_OFFSET(APP_SETTING_FactoryUser_t, n_FactSet_UARTDebug),
			sizeof(UINT8), &(UARTMode));
	if (UARTMode == 0)
	{
	   //mantis 21437 for disable all msg
		MID_TVFE_SetDebugModeOn(UARTMode);
	}
	else
	{
		//Cmd_mmio_WriteUINT32(DBGCONFIADDR,0x81000400);
	}

	AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FACTUSER,0,
				sizeof(APP_SETTING_FactoryUser_t), &g_stFactoryUserData);
	AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FACTHOTEL, 0,
			sizeof(APP_SETTING_FactoryHotel_t), &(g_stFactoryHotelData));
	if(
       #ifndef SUPPORT_HOTEL_MODE_OPENHOTEL_WITH_PINCODE
		(g_stFactoryUserData.Function.n_Funct_HotelMode == 1)&&
	   #endif
		(g_stFactoryHotelData.HotelModeOnOff == 1))
	{
		g_stVariationalData.Volume = g_stFactoryHotelData.DefaultVolume;
		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));
	}

#if (defined(SUPPORT_FACTORY_AUTO_TEST_MODE2))
	if(APP_Factory_GetAutoTestOnOff() == TRUE)
	{
		APP_AutoTest_SystemPowerOnReset();
		g_stUserInfoData.AutoInstalled = FALSE;
		AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_USERINFO,
						 ITEM_OFFSET(APP_SETTING_UserInfo_t, AutoInstalled),
						 sizeof(g_stUserInfoData.AutoInstalled), &(g_stUserInfoData.AutoInstalled));
		AL_Setting_Store(APP_Data_UserSetting_Handle(), SYS_SET_ID_USERINFO,
						 ITEM_OFFSET(APP_SETTING_UserInfo_t, AutoInstalled), sizeof(g_stUserInfoData.AutoInstalled));
	}
#elif defined(SUPPORT_FACTORY_AUTO_TEST)
	if(APP_Factory_GetAutoTestOnOff() == TRUE)
	{
		//enable debug message
		if (UARTMode == 0)
		{
			extern void Enable_Debug_Message(UINT32 DBGStatus);
			Enable_Debug_Message(0);
			MID_TVFE_SetDebugModeOn(TRUE);
		}

		g_stVariationalData.Volume = 50;
		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));

		g_stUserInfoData.AutoInstalled = FALSE;
		AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_USERINFO,
						 ITEM_OFFSET(APP_SETTING_UserInfo_t, AutoInstalled),
						 sizeof(g_stUserInfoData.AutoInstalled), &(g_stUserInfoData.AutoInstalled));
		AL_Setting_Store(APP_Data_UserSetting_Handle(), SYS_SET_ID_USERINFO,
						 ITEM_OFFSET(APP_SETTING_UserInfo_t, AutoInstalled), sizeof(g_stUserInfoData.AutoInstalled));

		extern void Enable_Debug_Message(UINT32 DBGStatus);
		Enable_Debug_Message(1<<MODULEID_UMF);
		printf("\n\nstart test\n\n");
		extern UINT8 APP_GetPoweronEnterVersion(void);
		if(APP_GetPoweronEnterVersion() == 0)
		{
			Factory_Ver_Debug();
		}
		Enable_Debug_Message(0);
	}
#endif
/*
#if (defined CONFIG_SUPPORT_PVR)
	MID_RecorderInitFsData();
	// init recorder demux unit
#ifdef SUPPORT_DUAL_NIM
	MID_RecorderSetDemuxUnit(SECOND_LIVE_INPUT);
	MID_PlaybackSyncSecondaryToPrimary(TRUE);
#else
	MID_RecorderSetDemuxUnit(PRIMARY_LIVE_INPUT);
#endif
	APP_GUIOBJ_DVB_PvrRec_RegUninitCallback();
	MID_TSPLParser_RegisterPvrRecListCallback((PVRRecListCallbackFunc)_RecorderList_Callback);
	extern void APP_GUIOBJ_DVB_PvrPlayInfo_Callback(MID_PVRPlayMsg_t dPVRPlayCallbackType);
	MID_TSPLParser_RegisterCallback(APP_GUIOBJ_DVB_PvrPlayInfo_Callback);
#endif
*///garfield
	MID_DISP_DTVDisplayInit();
	int error = 0;
    UINT32 u32PanelWidth = 0;
    UINT32 u32PanelHeight = 0;
#ifdef CONFIG_OSD_RESIZE_FOR_PANEL
    u32PanelWidth = OSD_ORIGINAL_REFERENCE_WIDTH;
    u32PanelHeight = OSD_ORIGINAL_REFERENCE_HEIGHT;
#else
    MID_DISP_DTVGetPanelResolution(&u32PanelWidth,&u32PanelHeight);
#endif
#if (defined TV_BITMAP_COMPRESSED && defined FilePlayer_BITMAP_COMPRESSED)
#if ((TV_BITMAP_COMPRESSED == 1 && FilePlayer_BITMAP_COMPRESSED == 0)	\
    || (TV_BITMAP_COMPRESSED == 0 && FilePlayer_BITMAP_COMPRESSED == 1))
    #error "Please both TV and media icon compressed or uncompressed"
#endif
    error = GEL_Open(u32PanelWidth, u32PanelHeight, TV_BITMAP_COMPRESSED);
#else
	#if defined TV_BITMAP_COMPRESSED
	error = GEL_Open(u32PanelWidth, u32PanelHeight, TV_BITMAP_COMPRESSED);
	#else
    error = GEL_Open(u32PanelWidth, u32PanelHeight, FALSE);
	#endif
#endif

	if (error != GUI_SUCCESS)
	{
		mainapp_printf("Gui_Engine_Init() - GEL_Open failed = 0x%x\n", error);
		return;
	}
	GUI_FUNC_CALL(GEL_SetMarqueeFpsAndStep(MARQUEE_TIMER_INTERVAL, MARQUEE_MOVE_STEP));
	GUI_FUNC_CALL(GEL_SetFontInfo(TV_ui_font_info,TV_FONT_STYLE_NUMBER,
			TV_string_info,TV_STR_ID_NUM, BASEFONT_SIZE,TV_UI_LANG_NUM,BASEFONT_CHARSPACING));

#ifdef CONFIG_ENABLE_UMF_LANGUAGE_MODULES
	GEL_RegLoadGlobalLangCB((LoadLangfun)umf_loadLangModuleByUILang);
	UINT32 StringId;
	AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FEATURE, 0,
		sizeof(APP_SETTING_Feature_t), &(g_stFeatureData));
	StringId = APP_GUIOBJ_OSD_Language_MappingTo_StringID(g_stFeatureData.OSDLang);
	GUI_FUNC_CALL(GEL_SetGlobalLang(
		APP_GuiMgr_GetCurFontLangIndex(
		(UINT32*)&StringId, OSD_TVPROJECT)));
#endif

	UINT16 width, height;
	error = GEL_GetOsdPlaneSize(&width, &height);

    MID_PartitionList_Init(DeviceMountStatus_Callback);

	MID_Mon_Init();

#ifdef SUPPORT_LED_FLASH
	//creat led flash timer
	APP_LED_Create_Flash_Task();
#endif

	AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FACTUSER,
		ITEM_OFFSET(APP_SETTING_FactoryUser_t, Function.SSCAdjust.n_Fun_SSC_Clk_Shift),
			sizeof(g_stFactoryUserData.Function.SSCAdjust.n_Fun_SSC_Clk_Shift),
			&(g_stFactoryUserData.Function.SSCAdjust.n_Fun_SSC_Clk_Shift));
	MID_TVFE_SetLVDS_CLOCK_Shift(g_stFactoryUserData.Function.SSCAdjust.n_Fun_SSC_Clk_Shift);

#if defined CONFIG_SUPPORT_ALL_ACTION_SHOW_BLUE_SCREEN || defined CONFIG_SUPPORT_ACTION_SHOW_BLUE_SCREEN_EXCEPT_MEDIA
	MID_DISP_DTVSetTVFEMuteColorByAPP(TRUE);
#else
	MID_DISP_DTVSetTVFEMuteColorByAPP(FALSE);
#endif

#ifdef CONFIG_SUPPORT_SYSTEM_LIFETIME
	//init system life funciton
	APP_SETTING_SystemPartLifeTimeTable_t dataSystemLifeTime;
	APP_SystemLifeTimeDataWriteRead(FALSE,(UINT8 *)&dataSystemLifeTime);
#endif

#ifdef CONFIG_SUPPORT_SYSTEM_STANDBYTIME
	APP_SETTING_SystemStandbyTimeTable_t standbtTime;
    UINT8 sbTimeVal;
	
	APP_SystemStandbyTimeDataWriteRead(FALSE,(UINT8 *)&standbtTime);
	Cmd_mmio_ReadUINT8((UINT32)(SYSTEM_STANDBYMODE_TIME), &sbTimeVal);
	standbtTime.SystemStandbyTime += sbTimeVal;
	Cmd_mmio_WriteUINT8((UINT32)(SYSTEM_STANDBYMODE_TIME), 0);
	APP_SystemStandbyTimeDataWriteRead(TRUE,(UINT8 *)&standbtTime);
#endif

#ifdef CONFIG_SUPPORT_NET_OTA
	NET_OTA_SetFTPHost("192.168.0.1", 21, "TESTER", "TEST", "/OTA_Upgrade");
	NET_OTA_RegisterCallback(NET_OTA_Event_Callback);
	NET_OTA_StartUpdateMonitor();
#endif

}

#ifdef SUPPORT_WAKEUP_TIMER_IN_STANDBY
static void _MAINAPP_InitTimerBootup(void)
{
	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_CHANNEL, 0,
		sizeof(APP_SETTING_Channel_t), &(g_stChannelData));
    AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_VARIATIONAL, 0,
        sizeof(APP_SETTING_Variational_t), &(g_stVariationalData));
#if defined(CONFIG_SUPPORT_SET_CLOCK_ONOFFTIME)|| defined (TEAC_ONOFF_TIMER_SUPPORT)
	AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FEATURE, 0,
		sizeof(APP_SETTING_Feature_t), &(g_stFeatureData));
	if ((g_stTVInfoData.WakeUpType == WAKE_TIMER_ONOFF_TIMER)
#ifdef AC_ON_AUTO_GET_TIME
		 &&(g_fBackgroundGetTime == FALSE)
#endif
		)
	{	//set power on source if wake by Ontimer
		AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_USERINFO, 0,
			sizeof(APP_SETTING_UserInfo_t), &(g_stUserInfoData));
		g_stTVInfoData.WakeUpType = WAKE_TIMER_MAX;
		if (g_stFeatureData.OnTime.RepeatMOde == APP_TIMER_ONOFF_TYPE_ONCE)
		{
			g_stFeatureData.OnTime.RepeatMOde = APP_TIMER_ONOFF_TYPE_OFF;
		}
		g_stVariationalData.Volume = g_stFeatureData.OnTime.OnVolume;
#ifdef CONFIG_DTV_SUPPORT
		if (g_stFeatureData.OnTime.OnSource == APP_SOURCE_DTV)
		{
			if (g_stChannelData.TV_Connection == APP_RF_TYPE_DVB_T)
			{
	#ifdef CONFIG_DVB_SYSTEM_DVBT_SUPPORT
				g_stTVInfoData.DVBT_ServType = g_stFeatureData.OnTime.OnServType;
				if (AL_RECTYPE_DVBRADIO == g_stFeatureData.OnTime.OnServType)
				{
					g_stVariationalData.DVBT_RadioHdl = g_stFeatureData.OnTime.OnChannel;
				}
				else if (AL_RECTYPE_DVBDATA == g_stFeatureData.OnTime.OnServType)
				{
					g_stTVInfoData.DVBT_DataHdl = g_stFeatureData.OnTime.OnChannel;
				}
				else
				{
					g_stVariationalData.DVBT_TVHdl = g_stFeatureData.OnTime.OnChannel;
				}
	#endif
			}
			else if (g_stChannelData.TV_Connection == APP_RF_TYPE_DVB_C)
			{
	#ifdef CONFIG_DVB_SYSTEM_DVBC_SUPPORT
				g_stTVInfoData.DVBC_ServType = g_stFeatureData.OnTime.OnServType;
				if (AL_RECTYPE_DVBRADIO == g_stFeatureData.OnTime.OnServType)
				{
					g_stVariationalData.DVBC_RadioHdl = g_stFeatureData.OnTime.OnChannel;
				}
				else if (AL_RECTYPE_DVBDATA == g_stFeatureData.OnTime.OnServType)
				{
					g_stTVInfoData.DVBC_DataHdl = g_stFeatureData.OnTime.OnChannel;
				}
				else
				{
					g_stVariationalData.DVBC_TVHdl = g_stFeatureData.OnTime.OnChannel;
				}
	#endif
			}
			else if (g_stChannelData.TV_Connection == APP_RF_TYPE_DVB_S)
			{
	#ifdef CONFIG_DVB_SYSTEM_DVBS_SUPPORT
				g_stTVInfoData.DVBS_ServType = g_stFeatureData.OnTime.OnServType;
				if (AL_RECTYPE_DVBRADIO == g_stFeatureData.OnTime.OnServType)
				{
					g_stVariationalData.DVBS_RadioHdl = g_stFeatureData.OnTime.OnChannel;
				}
				else if (AL_RECTYPE_DVBDATA == g_stFeatureData.OnTime.OnServType)
				{
					g_stTVInfoData.DVBS_DataHdl = g_stFeatureData.OnTime.OnChannel;
				}
				else
				{
					g_stVariationalData.DVBS_TVHdl = g_stFeatureData.OnTime.OnChannel;
				}
	#endif
			}
		}
		else
#endif
#ifdef CONFIG_ATV_SUPPORT
		if (g_stFeatureData.OnTime.OnSource == APP_SOURCE_ATV)
		{
			g_stVariationalData.ATV_TVHdl = g_stFeatureData.OnTime.OnChannel;
		}
#endif
		AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_VARIATIONAL,
			ITEM_OFFSET(APP_SETTING_Variational_t, Volume), sizeof(g_stVariationalData.Volume),
			&( g_stVariationalData.Volume));
		AL_Setting_Store(APP_Data_UserSetting_Handle(), SYS_SET_ID_VARIATIONAL,
			ITEM_OFFSET(APP_SETTING_Variational_t, Volume), sizeof(g_stVariationalData.Volume));


		AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_TVINFO, 0,
			sizeof(APP_SETTING_TVInfo_t), &(g_stTVInfoData));
		AL_Setting_Store(APP_Data_UserSetting_Handle(), SYS_SET_ID_TVINFO, 0,
			sizeof(g_stTVInfoData));

		AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_FEATURE, 0,
			sizeof(g_stFeatureData), &(g_stFeatureData));
		AL_Setting_Store(APP_Data_UserSetting_Handle(), SYS_SET_ID_FEATURE, 0,
			sizeof(g_stFeatureData));

		APP_WAKEUP_SetBootFlag(FALSE);
		APP_GUIOBJ_Source_SetAppSource(g_stFeatureData.OnTime.OnSource);
	}
	else
#endif
	{
#ifdef AC_ON_AUTO_GET_TIME
		if (g_fBackgroundGetTime == TRUE)
		{
			APP_BackgroundGetTime_SetTimeout();
		}
		else
#endif
		#ifdef CONFIG_DTV_SUPPORT
		{
			AL_DB_EDBType_t DBType_ret = AL_DBTYPE_DVB_T;
			AL_DB_ERecordType_t RecType = AL_RECTYPE_DVBTV;
			if (AL_DB_GetRecordType(g_stTVInfoData.BootChannelHdl, &DBType_ret, &RecType)
				 != AL_SUCCESS)
			{
				DBType_ret = g_stTVInfoData.BootChannelDBType;
				RecType = g_stTVInfoData.BootChannelRecType;
			}
			switch(DBType_ret)
			{
				case AL_DBTYPE_DVB_T:
					g_stChannelData.TV_Connection = APP_RF_TYPE_DVB_T;
#ifdef CONFIG_DVB_SYSTEM_DVBT_SUPPORT
					g_stTVInfoData.DVBT_ServType = RecType;
					if (AL_RECTYPE_DVBRADIO == RecType)
					{
						g_stVariationalData.DVBT_RadioHdl = g_stTVInfoData.BootChannelHdl;
					}
					else if (AL_RECTYPE_DVBDATA == RecType)
					{
						g_stTVInfoData.DVBT_DataHdl = g_stTVInfoData.BootChannelHdl;
					}
					else
					{
						g_stVariationalData.DVBT_TVHdl = g_stTVInfoData.BootChannelHdl;
					}
#endif
					break;
				case AL_DBTYPE_DVB_C:
					g_stChannelData.TV_Connection = APP_RF_TYPE_DVB_C;
#ifdef CONFIG_DVB_SYSTEM_DVBC_SUPPORT
					g_stTVInfoData.DVBC_ServType = RecType;
					if (AL_RECTYPE_DVBRADIO == RecType)
					{
						g_stVariationalData.DVBC_RadioHdl = g_stTVInfoData.BootChannelHdl;
					}
					else if (AL_RECTYPE_DVBDATA == RecType)
					{
						g_stTVInfoData.DVBC_DataHdl = g_stTVInfoData.BootChannelHdl;
					}
					else
					{
						g_stVariationalData.DVBC_TVHdl = g_stTVInfoData.BootChannelHdl;
					}
#endif
					break;

				case AL_DBTYPE_DVB_S:
					g_stChannelData.TV_Connection = APP_RF_TYPE_DVB_S;
#ifdef CONFIG_DVB_SYSTEM_DVBS_SUPPORT
					g_stTVInfoData.DVBS_ServType = RecType;
					if (AL_RECTYPE_DVBRADIO == RecType)
					{
						g_stVariationalData.DVBS_RadioHdl = g_stTVInfoData.BootChannelHdl;
					}
					else if (AL_RECTYPE_DVBDATA == RecType)
					{
						g_stTVInfoData.DVBS_DataHdl = g_stTVInfoData.BootChannelHdl;
					}
					else
					{
						g_stVariationalData.DVBS_TVHdl = g_stTVInfoData.BootChannelHdl;
					}
#endif
					break;
#ifdef CONFIG_ISDB_SYSTEM
				case AL_DBTYPE_DVB_SBTVD:
					g_stChannelData.TV_Connection = APP_RF_TYPE_DVB_T;
					g_stTVInfoData.SBTVD_ServType = RecType;
					if (AL_RECTYPE_DVBRADIO == RecType)
					{
						g_stVariationalData.SBTVD_RadioHdl = g_stTVInfoData.BootChannelHdl;
					}
					else
					{
						g_stVariationalData.SBTVD_TVHdl = g_stTVInfoData.BootChannelHdl;
					}
					break;
#endif
				default:
					break;
			}

			if (g_stTVInfoData.WakeUpType == WAKE_TIMER_REMINDER)
			{
				g_stTVInfoData.WakeUpType = WAKE_TIMER_MAX;
				APP_WAKEUP_SetBootFlag(FALSE);
				APP_WAKEUP_RealPowerUp();
			}

			AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_VARIATIONAL, 0,
				sizeof(g_stVariationalData),
				&( g_stVariationalData));
			AL_Setting_Store(APP_Data_UserSetting_Handle(), SYS_SET_ID_VARIATIONAL, 0,
				sizeof(g_stVariationalData));

			AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_TVINFO, 0,
				sizeof(APP_SETTING_TVInfo_t), &(g_stTVInfoData));
			AL_Setting_Store(APP_Data_UserSetting_Handle(), SYS_SET_ID_TVINFO, 0,
				sizeof(g_stTVInfoData));

			AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_CHANNEL, 0,
				sizeof(APP_SETTING_Channel_t), &(g_stChannelData));
			AL_Setting_Store(APP_Data_UserSetting_Handle(), SYS_SET_ID_CHANNEL, 0,
				sizeof(g_stChannelData));
		}
		APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_DTV);
		#endif
	}
}
#endif

static int _MAINAPP_InitSysApp(UINT32* dTotalApp)
{
	UINT8 i = 0;

	SYSAPP_IF_Initialize(TOTAL_SYS_APP_SIZE, apstSysAppInst);
	*dTotalApp = TOTAL_SYS_APP_SIZE;

	APP_RegionMgr_Init();
	APP_GuiMgr_Set_Menu() ;
	APP_GuiMgr_SwitchShareMenu(TOTAL_SYS_APP_SIZE);

	AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_USERINFO, 0,
		sizeof(APP_SETTING_UserInfo_t), &(g_stUserInfoData));
	APP_Source_Type_t SourceIndex = g_stUserInfoData.SourceIndex;

	APP_GUIOBJ_Source_RecordStandbySource(SourceIndex);
#ifdef CONFIG_DVB_SYSTEM
	AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_SETUP, 0,
					sizeof(APP_SETTING_Setup_t), &(g_stSetupData));
	APP_SCARTIN_SetAutoSCART(g_stSetupData.AutoSCART);
	if (g_stSetupData.AutoSCART == FALSE) // clear SCART PlugInStatus
	{
		APP_SCARTIN_SetAutoPlugInStatus(AUTO_PLUGIN_SCART0);
		APP_SCARTIN_SetPlugStatus(AUTO_PLUGIN_SCART0);
	}
#ifdef SUPPORT_FACTORY_AUTO_TEST
	if(APP_Factory_GetAutoTestOnOff() == TRUE)
	{
		if (g_stSetupData.AutoSCART == TRUE)
		{
			if (APP_SCARTIN_IsScartIn())
			{

				SourceIndex = APP_SOURCE_SCART;
				APP_SCARTIN_SetAutoPlugInStatus(AUTO_PLUGIN_SCART0);
			}
		}
	}
	else
#endif
	{
		if ((!g_stUserInfoData.AutoInstalled) && (g_stSetupData.AutoSCART == TRUE))
		{
			if (APP_SCARTIN_IsScartIn())
			{

				SourceIndex = APP_SOURCE_SCART;
				APP_SCARTIN_SetAutoPlugInStatus(AUTO_PLUGIN_SCART0);
			}

		}
	}
#endif
	SourceIndex = APP_Factory_GetHotelModePowerSource(SourceIndex);
#ifdef CONFIG_SUPPORT_MONITOR_POWERSAVE
	if(MID_DISP_DTV_Get_Wakeup_Status() == 1)
		SourceIndex = APP_SOURCE_HDMI;
	else if(MID_DISP_DTV_Get_Wakeup_Status() == 2)
		SourceIndex = APP_SOURCE_PC;
#endif

#ifdef CONFIG_ATV_SUPPORT
#ifdef NUMBER_KEY_WAKEUP_CHANNEL
	extern UINT8 bNumberKeyPowerOn;
	if (bNumberKeyPowerOn == TRUE)
	{
		SourceIndex = APP_SOURCE_ATV;
	}
#endif
#endif

	/*Initialize system app 1 by 1.*/
	{
		for (i = 0; i < TOTAL_SYS_APP_SIZE+1; i++)
		{
#ifdef CONFIG_ENABLE_UMF_MODULES
#ifdef CONFIG_SUPPORT_NETAPP
			if (i == SYS_APP_NETWORK)
			{
				SYSAPP_IF_InitializeSysApp(i, MainAppQueueHandle);
			}			
#endif

#ifdef CONFIG_MEDIA_ENABLE
			if (i == SYS_APP_FILE_PLAYER)
			{
#ifdef CONFIG_MOD_PACK_MEDIA
				if (SourceIndex == APP_SOURCE_MEDIA || SourceIndex == APP_SOURCE_MEDIA1)
				{
					umf_loadModule(UMFMOD_MEDIA);
					SYSAPP_IF_InitializeSysApp(i, MainAppQueueHandle);
				}
#else
				SYSAPP_IF_InitializeSysApp(i, MainAppQueueHandle);
#endif
			}			
#endif

			if (i== SYS_APP_ATV)
			{
#ifdef CONFIG_MOD_PACK_ATV
				if (SourceIndex == APP_SOURCE_ATV || SourceIndex == APP_SOURCE_AV || SourceIndex == APP_SOURCE_AV1
					|| SourceIndex == APP_SOURCE_AV2 || SourceIndex == APP_SOURCE_SVIDEO || SourceIndex == APP_SOURCE_SVIDEO1
					|| SourceIndex == APP_SOURCE_SVIDEO2 || SourceIndex == APP_SOURCE_DVD || SourceIndex == APP_SOURCE_YPBPR 
					|| SourceIndex == APP_SOURCE_YPBPR1 || SourceIndex == APP_SOURCE_YPBPR2 || SourceIndex == APP_SOURCE_SCART 
					|| SourceIndex == APP_SOURCE_SCART1 || SourceIndex == APP_SOURCE_HDMI || SourceIndex == APP_SOURCE_HDMI1 
					|| SourceIndex == APP_SOURCE_HDMI2 || SourceIndex == APP_SOURCE_PC)
				{
					umf_loadModule(UMFMOD_ATV);
					SYSAPP_IF_InitializeSysApp(i, MainAppQueueHandle);
				}
#else
				SYSAPP_IF_InitializeSysApp(i, MainAppQueueHandle);		
#endif
			}

#ifdef CONFIG_DTV_SUPPORT
			if (i == SYS_APP_DVB)
			{
#ifdef CONFIG_MOD_PACK_DTV
				if (SourceIndex != APP_SOURCE_MEDIA && SourceIndex != APP_SOURCE_MEDIA1)
				{
					if (g_stUserInfoData.SourceIndex == APP_SOURCE_MEDIA || g_stUserInfoData.SourceIndex == APP_SOURCE_MEDIA1)
					{
						umf_loadModule(UMFMOD_DTV);
					}
					SYSAPP_IF_InitializeSysApp(i, MainAppQueueHandle);
				}
#else
				SYSAPP_IF_InitializeSysApp(i, MainAppQueueHandle);
#endif
			}
#endif
			continue;
#endif
			SYSAPP_IF_InitializeSysApp(i, MainAppQueueHandle);
		}
	}
#ifdef CONFIG_MOD_PACK_DTV
	if (SourceIndex == APP_SOURCE_DTV)
#endif
	{
#ifdef CONFIG_DTV_SUPPORT    /* When power on Radio,should discuss especailly in fact */
#ifdef CONFIG_ISDB_SYSTEM
		AL_DB_EDBType_t eDBType = AL_DBTYPE_DVB_SBTVD;
#else
		AL_DB_EDBType_t eDBType = APP_DVB_Playback_GetCurrentNetType();
#endif
		AL_DB_ERecordType_t eServiceType = APP_DVB_Playback_GetCurrServiceType(eDBType);
		APP_DVB_Playback_SetNextServiceType(eServiceType);
#endif

#ifdef CONFIG_SUPPORT_OTA_UPGRADE
	 	APP_GUIOBJ_DVB_OTAPrompt_SetShowFlag(OtaShowPromt_FromStandby);
#endif
	}
#ifdef SUPPORT_WAKEUP_TIMER_IN_STANDBY
    if (APP_WAKEUP_GetBootFlag() == TRUE)
    {
		mainapp_printf("[debug]%s	%d\n",__FUNCTION__,__LINE__);
    	mainapp_printf("change source to DTV\n");
        _MAINAPP_InitTimerBootup();
#ifdef CONFIG_DVB_SYSTEM_DVBT_SUPPORT
		mainapp_printf("g_stVariationalData.DVBT_TVHdl is 0x%x\n\n\n\n\n\n",g_stVariationalData.DVBT_TVHdl);
#endif
#ifdef CONFIG_SUPPORT_SSU_UPGRADE
        if (
#ifdef CONFIG_MOD_PACK_DTV
		SourceIndex == APP_SOURCE_DTV && 
#endif
			g_stTVInfoData.WakeUpType == WAKE_TIMER_SSU)
		{	
			DVBApp_SetBootAutoUpGrade(TRUE);
			DVBApp_SetAU_Sate(AU_GoToUpgrade);
			DVBApp_SetAutoUpgrade(TRUE);

	#ifdef SUPPORT_SSU_ENHANCE_UPGRADE
			APP_GUIOBJ_DVB_OTAPrompt_RevTimer();
	#endif

			g_stTVInfoData.WakeUpType = WAKE_TIMER_MAX;
			AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_TVINFO, 0,
				sizeof(APP_SETTING_TVInfo_t), &(g_stTVInfoData));
			AL_Setting_Store(APP_Data_UserSetting_Handle(), SYS_SET_ID_TVINFO, 0,
				sizeof(g_stTVInfoData));
        }
#endif
    }
    else
#endif
    {
#ifdef CONFIG_MOD_PACK_DTV
        if (SourceIndex == APP_SOURCE_DTV)
#endif
        {
#ifdef CONFIG_SUPPORT_SSU_UPGRADE
			DVBApp_SetAU_Sate(AU_GoToUpgrade);
			DVBApp_SetAutoUpgrade(FALSE);

#ifdef SUPPORT_SSU_ENHANCE_UPGRADE
			APP_GUIOBJ_DVB_OTAPrompt_RevTimer();
#endif
#endif	
        }
#ifdef SUPPORT_CEC_TV
		tv_source_t eSrcPort = SRC_UNKNOWN;
		AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FEATURE, 0,
			sizeof(APP_SETTING_Feature_t), &(g_stFeatureData));
		eSrcPort = (tv_source_t)CECTV_GetAutoPwrOnSrc();

		if(g_stFeatureData.Enable_HDMILink == APP_SWITCH_ON
			&&g_stFeatureData.HDMI_AutoPowerOn == APP_SWITCH_ON)
		{
			mainapp_printf("[%s:%d]HDMI CEC Power On Source = %d \n",__FUNCTION__,__LINE__,eSrcPort);
			switch(eSrcPort)//check hdmi port
			{
				case SRC_HDMI_1:
					SourceIndex = APP_SOURCE_HDMI;
					break;
				case SRC_HDMI_2:
					SourceIndex = APP_SOURCE_HDMI1;
					break;
				case SRC_HDMI_3:
					SourceIndex = APP_SOURCE_HDMI2;
					break;
				case SRC_OTHERS:
				default:
					break;
			}
		}
		#endif

#ifdef CONFIG_HDMI_SUPPORT_MHL
		MHLAppInstanceData_t eMHLAppData;
		Cmd_Hdmi_GetMHLAppInstanceData(&eMHLAppData);
		if(eMHLAppData.cbusConnected == TRUE)
		{
			APP_Source_Type_t eMhlSrc;
			UINT8 IsMHLSoure;
			APP_GOBJ_Source_CheckAndGetMHLSource(&IsMHLSoure,&eMhlSrc);
			if(eMhlSrc>=APP_SOURCE_HDMI && APP_SOURCE_HDMI2>=eMhlSrc)
			{
				SourceIndex = eMhlSrc;
			}
		}
#endif

#if 0//CONFIG_CHIPID==0x531 //richie temp add to force YPbPr source when power on
		SourceIndex = APP_SOURCE_YPBPR;
#endif
		#if 0//def CONFIG_SMART_MODULE_SUPPORT
		SourceIndex = (APP_SOURCE_HDMI + CONFIG_HDMI_SMART_PORT);
		#endif
		APP_GUIOBJ_Source_SetAppSource(SourceIndex);
    }

#ifdef CONFIG_DVB_SYSTEM
	if ((SourceIndex == APP_SOURCE_SCART) || (SourceIndex == APP_SOURCE_SCART1))
	{
		APP_SCARTIN_SetPlugStatus(TRUE);
	}
#endif

#ifdef CONFIG_BLUETOOTH_SUPPORT
    Al_Bluetooth_Enable();
#endif
#ifdef CONFIG_SMART_MODULE_SUPPORT
	Al_Smart_Enable();
#endif
#ifdef CONFIG_STB_MODULE_SUPPORT
	Al_STB_Enable();
#endif

#ifdef SUPPORT_CEC_TV
	CECTV_ModualCfg_t CEC_ModualCfg =
	{
		.pfCallBack = _MAINAPP_CEC_Callback
	};
	CECTV_Init(&CEC_ModualCfg);

	APP_HDMILink_Init();

	AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FEATURE, 0,
		 sizeof(APP_SETTING_Feature_t), &(g_stFeatureData));
	if(g_stFeatureData.Enable_HDMILink == APP_SWITCH_ON)
	{
#ifdef CONFIG_WAKE_UP_DEVICE_BY_POWER_ON_TV
		tv_source_t eSrcPort = SRC_OTHERS;
		switch(SourceIndex)//check hdmi port
		{
				case APP_SOURCE_HDMI:
					eSrcPort = SRC_HDMI_1;
					break;
				case APP_SOURCE_HDMI1:
					eSrcPort = SRC_HDMI_2;
					break;
				case APP_SOURCE_HDMI2:
					eSrcPort = SRC_HDMI_3;
					break;
				//case SRC_OTHERS:
				default:
					break;
		}
		CECTV_SendCmd(CECTV_SINGLE_ACT_CMD_CHGSRC_TO_HDMI, eSrcPort);
#endif
		CECTV_SendCmd(CECTV_SINGLE_ACT_CMD_SET_OSD_LANGUAGE, g_stFeatureData.OSDLang);
	}
#endif


	/* initialize IR */
	ir_SetMappingTable(stIR_map, dIR_map_size);
    ir_LoadEventCode(0);
	KP_LoadCustomerConfig();
	ir_init(_MAINAPP_Ir_Callback);
#ifdef CONFIG_AUTO_USB_STORE_IRSEQ
	AUTO_IF_Initialize(_MAINAPP_Ir_Callback);
#endif
#ifdef CONFIG_KEYPAD_SINGLE_REUSE
	ir_RegisterKpCallback(APP_GetSingleKeyPadEvent);
#endif
#ifdef CONFIG_SUPPORT_NES_GAME
	joystick_init(_MAINAPP_Joystick_Callback);
#endif
#ifdef CONFIG_SUPPORT_MIRACAST
		MIRACAST_ModualCfg_t MIRACAST_ModualCfg =
		{
			.pfCallBack = _MAINAPP_MIRACAST_Callback
		};
		miracast_Init(&MIRACAST_ModualCfg);
#endif

	MAINAPP_RegisterFunc(APP_CustomerFuncStart, APP_CustomerFuncEnd);

	return 0;
}

static int _MAINAPP_FinalizeSysApp(UINT32 dParam)
{
#ifndef CONFIG_SUPPORT_MONITOR
	UINT32  dIndex = TOTAL_SYS_APP_SIZE;
#endif
	UINT8 i = 0;

	APP_GUIOBJ_SleepTimer_SetTimeoutPowerOffStatus(FALSE);
	MAINAPP_SetPowerOffState(TRUE);

#ifndef CONFIG_SUPPORT_MONITOR
	/* Clear mute and power on UI */
	if (MAIN_APP_SUCCESS == MAINAPP_GetActiveSystemAppIndex(&dIndex))
	{
		if (dIndex != TOTAL_SYS_APP_SIZE)
		{
			SYSAPP_GOBJ_SendMsgToSingleGUIObject(
				dIndex, APP_GUIOBJ_MUTE,
				APP_INTRA_EVENT_HIDE_MUTE, 0);
		}
	}
#endif
	/* Finalize all system app */
	/* add by qinhe for 64M D(T+C)+M */
	APP_Source_Type_t eSourceType = APP_SOURCE_MAX;
	APP_GUIOBJ_Source_GetCurrSource(&eSourceType);
#if 0 //#ifdef CONFIG_MEDIA_ENABLE
#ifdef CONFIG_ENABLE_UMF_MODULES
	APP_Source_Type_t eSourceType = APP_SOURCE_MAX;
	APP_GUIOBJ_Source_GetCurrSource(&eSourceType);
	if (eSourceType != APP_SOURCE_MEDIA)
	{
		for (i = 0; i < TOTAL_SYS_APP_SIZE; i++)
		{
			if (i != SYS_APP_FILE_PLAYER)
			{
				MAINAPP_FinalizeSystemApp(i);
			}
		}
	}
	else
#endif
#endif
	{
		for (i = 0; i < TOTAL_SYS_APP_SIZE+1; i++)
		{
#ifdef CONFIG_ENABLE_UMF_MODULES
			//UINT32 sysAPP = TOTAL_SYS_APP_SIZE;
			//UMFMOD_ID UMFModID = UMFMOD_MAX;
			//UINT32 unload = 0;			
#ifdef CONFIG_SUPPORT_NETAPP
			if (i == SYS_APP_NETWORK)
			{
				MAINAPP_FinalizeSystemApp(i);
			}			
#endif
#ifdef CONFIG_MEDIA_ENABLE
			if (i == SYS_APP_FILE_PLAYER)
			{
#ifdef CONFIG_MOD_PACK_MEDIA
				if (eSourceType == APP_SOURCE_MEDIA || eSourceType == APP_SOURCE_MEDIA1)
				{
					MAINAPP_FinalizeSystemApp(i);
					//UMFModID = UMFMOD_MEDIA;
					//sysAPP = SYS_APP_FILE_PLAYER;
					//unload = 1;
				}
#else
				MAINAPP_FinalizeSystemApp(i);
#endif
			}			
#endif

			if (i == SYS_APP_ATV)
			{
#ifdef CONFIG_MOD_PACK_ATV
				if (APP_GUIOBJ_SOURCE_IsATVSource())
				{
					MAINAPP_FinalizeSystemApp(i);
					//UMFModID = UMFMOD_ATV;
					//sysAPP = SYS_APP_ATV;
					//unload = 1;
				}
#else
				MAINAPP_FinalizeSystemApp(i);
#endif
			}			

#ifdef CONFIG_DTV_SUPPORT
			if (i == SYS_APP_DVB)
			{
#ifdef CONFIG_MOD_PACK_DTV
				if (eSourceType != APP_SOURCE_MEDIA && eSourceType != APP_SOURCE_MEDIA1)
				{
					MAINAPP_FinalizeSystemApp(i);
					//UMFModID = UMFMOD_DTV;
					//sysAPP = SYS_APP_DVB;
					//unload = 1;
				}
#else
				MAINAPP_FinalizeSystemApp(i);
#endif
			}			
#endif

#if 0
			if (unload)
			{
				UINT8 TryTimes = 100;
				int RetValue = SYSTEM_APP_ERROR_CODE_MAX;

				RetValue = SYSAPP_IF_GetSystemAppQueueHandle(sysAPP, NULL);
				while (RetValue != SYSTEM_APP_DATA_ERROR && TryTimes > 0)
				{
					GL_TaskSleep(1);
					RetValue = SYSAPP_IF_GetSystemAppQueueHandle(sysAPP, NULL);
					TryTimes--;
				}
				if (RetValue == SYSTEM_APP_DATA_ERROR)
				{
					umf_unloadModule(UMFModID);
				}
			}
#endif
			continue;
#endif
			MAINAPP_FinalizeSystemApp(i);
		}
	}
#if (defined CONFIG_MOD_PACK_TT) || (defined CONFIG_MOD_PACK_SUB)
#ifdef CONFIG_MOD_PACK_TT
    AL_TTX_Stop();
#endif
    TTOrSubModUnload();
#endif
#if defined(CONFIG_DTV_SUPPORT) || defined(CONFIG_ATV_SUPPORT)
	/* Store data to flash */
	if(((dParam&0xffff0000) & MAINAPP_DATABASE_NOSYNC) == MAINAPP_DATABASE_NOSYNC)
	{
		AL_FW_TermStoreDevice(al_false);
	}
	else
	{
		AL_FW_TermStoreDevice(al_true);
	}
#endif
	return 0;
}

static void _MAINAPP_HW_Finalize(UINT32 dParam)
{

#if defined(CONFIG_DTV_SUPPORT) || defined(CONFIG_ATV_SUPPORT)
	Cmd_Tuner_PowerSaving();
#endif
#ifdef GPIO_LNB_POWER_CONTROL_SLEEP
	Cmd_gpio_WriteOffLevel(GPIO_LNB_POWER_CONTROL_SLEEP);
#endif

	//power off DVD
	Cmd_gpio_WriteOffLevel(GPIO_DVD_STB);
	Cmd_gpio_WriteOffLevel(GPIO_DVD_ON_OFF);
#if 0 //mantis 0022204
	GL_MutexLock(APP_Get_LedControl_Mutex());
	Cmd_gpio_WriteOnLevel(GPIO_LED_R_ON_PIN);
	Cmd_gpio_WriteOffLevel(GPIO_LED_G_ON_PIN);
	GL_MutexUnlock(APP_Get_LedControl_Mutex());
#endif

}

static int _MAINAPP_SW_Finalize(UINT32 dParam)
{
	//mute audio
	//GL_TaskSleep(500);
    AUDIO_DEVICE_POWERCTRL AudioPowerCtrl;
    AudioPowerCtrl.flag = AUDIOPOWER_POWER_DOWN;
    AudioPowerCtrl.POWERStatus = TRUE;
    TVFE_Audio_SetDevicePower(&AudioPowerCtrl);

	/* Terminate system setting */
	AL_Setting_Close(APP_Data_UserSetting_Handle());
#ifdef CONFIG_AUTO_USB_STORE_IRSEQ
	AUTO_IF_Finalize();
#endif
	ir_finalize();
    Cmd_NVMUninital();
#ifdef CONFIG_SUPPORT_NET_OTA
	NET_OTA_StopUpdateMonitor();
#endif
#ifdef CONFIG_SUPPORT_NETWORK
    Al_Network_Ctrl_Destroy();
#endif

	//AL_SETTING_Terminate();

	return 0;
}

/*****************************************************************************
** FUNCTION : _MAINAPP_FW_Callback
**
** DESCRIPTION :
**				 Process messages received from AFW Framework
**
** PARAMETERS :
**				event	- Event sent by FW component
**				param	- User parameter
**
** RETURN VALUES:
**				None
*****************************************************************************/
void MAINAPP_FW_Callback(AFW_event_t event, void *param)
{
	UINT32 message = 0xffffffff;
	UINT32 dParam = 0;
	UINT32 u32CurrentSysappIndex = 0;
#ifdef CONFIG_SUPPORT_MIRACAST
	Dongle_e Dongle_Org = Dongle_None;
	Dongle_e Dongle_Check = Dongle_None;
	APP_Source_Type_t eSourType = APP_SOURCE_MAX;	
	APP_GUIOBJ_Source_GetCurrSource(&eSourType);
#endif
    if (MAIN_APP_SUCCESS != MAINAPP_GetActiveSystemAppIndex(&u32CurrentSysappIndex))
    {
    	if(event == FW_DB_LOAD_DEFAULT || event == FW_SCART_INPUTSRC_CHANGE || FW_SCART_INPUTSTATUS_CHANGE == event)
    	{
			mainapp_printf("[%s: %d]get active system app fail,Save Event to table!\n", __FUNCTION__, __LINE__);
			dParam = *(UINT32 *)param;
			MAINAPP_AddEevnetToTable(event,dParam);
		}
        return ;
    }
	/* Main app dispose */
	switch (event)
	{
		case FW_DB_LOAD_DEFAULT:
			message = FW_DB_LOAD_DEFAULT;
			dParam = *(UINT32 *)param;
			break;
#if defined (CONFIG_SUPPORT_NES_GAME) || defined(CONFIG_SUPPORT_MIRACAST)
	  case FW_USB_PLUGIN:
		{
			#ifdef CONFIG_SUPPORT_NES_GAME
			joystick_add_dev();
			#endif
			#ifdef CONFIG_SUPPORT_MIRACAST
			dParam = *(UINT32 *)param;
			if(dParam== 0 && WIFI_DONGLE!=Dongle_RDA_5995)
			{
				if(MID_NWSI_GetIFFlag(E_MID_NWSI_CONNECT_TYPE_WIRELESS) & E_MID_NWSI_IF_UP)
					*(UINT32 *)param=2;//not wifi dongle
				else
					Miracast_Insert_WIFI_Module(WIFI_DONGLE);
			}
			#endif
		}
		break;
      case FW_USB_PLUGOUT:
		{
			#ifdef CONFIG_SUPPORT_NES_GAME
			joystick_remove_dev();
			#endif
			#ifdef CONFIG_SUPPORT_MIRACAST
			Dongle_Org = miracast_get_dongle();
			Dongle_Check = miracast_check_dongle();
			bWifiDongle = FALSE;
			if(Dongle_Check != Dongle_Org && Dongle_Check == Dongle_None && WIFI_DONGLE!=Dongle_RDA_5995)
			{        
				bWifiDongle = TRUE;
				Miracast_Remove_WIFI_Module(Dongle_Org);
			}
			#endif
		}
		break;
#endif
		default:
			break;
	}

	if (message != 0xffffffff)
	{
		MAINAPP_SendGlobalEvent(message, dParam);
		return;
	}
#ifdef CONFIG_DTV_SUPPORT
	/* DVB sys app message dispose */
	else if (SYS_APP_DVB == u32CurrentSysappIndex
			&& SP_SUCCESS == DVBApp_fw_callback(event, param))
	{
		return;
	}
#endif
	/* ATV sys app message dispose */
	else if (SYS_APP_ATV == u32CurrentSysappIndex
			&& SP_SUCCESS == ATVApp_fw_callback(event, param))
	{
		return;
	}
#ifdef CONFIG_MEDIA_ENABLE
	/* FILE sys app message dispose */
	else if (SYS_APP_FILE_PLAYER == u32CurrentSysappIndex
			&& SP_SUCCESS == FILEApp_fw_callback(event, param))
	{
		return;
	}
#endif
#ifdef CONFIG_SUPPORT_NETAPP
	/* NETWORK sys app message dispose */
	else if (SYS_APP_NETWORK == u32CurrentSysappIndex
			&& SP_SUCCESS == NetworkApp_fw_callback(event, param))
	{
		return;
	}
#endif

	/* Other sys app message dispose */
	return;
}

al_uint32 MAINAPP_FW_GetContext(AL_FW_Context_Type_t ContextType, al_uint32 opera, al_void * pContext, al_uint32 Param)
{
#ifdef CONFIG_DTV_SUPPORT
	al_uint8 u8Area = 0;
	char *TempCountryCode = al_null;
#endif
	al_uint8 *Tempiso639language = al_null;
	al_uint8 u8LacalRegionId = 0xff;
#if 0
	al_uint8 u8TimeZone = AL_TIME_GMT_OFFSET_AUTO;
#endif
#ifdef CONFIG_SUPPORT_PVR
	AL_Return_t ret_val = AL_SUCCESS;
	al_uint32 offset = 0;
#endif
#ifdef CONFIG_EPG_LANG_DEFAULT_BY_OSDLANG
	UINT8 i = 0;
	al_int8 Iso639lang[4];
	al_int8 Iso639_2lang[4];
#endif

	if (pContext == NULL)
	{
		return AL_FAILURE;
	}
	al_uint32 ContextTypeOP = ContextType|opera;
	switch (ContextTypeOP)
	{
#ifdef CONFIG_DTV_SUPPORT
		case FW_CONTEXT_TYPE_LOCK_STATE | FW_CONTEXT_OP_TYPE_READ:
			{
				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))
				{
					mainapp_printf("Get DBType error!!!\n");
					return AL_FAILURE;
				}

				hCurrPrgHdl = APP_DVB_Playback_GetCurrentProgHandle(eDBType, (AL_RECTYPE_DVBTV |AL_RECTYPE_DVBRADIO | AL_RECTYPE_DVBDATA));
				if (hCurrPrgHdl == AL_DB_INVALIDHDL)
				{
					mainapp_printf("Get current program handle error!!!\n");
					return AL_FAILURE;
				}

				eProgState = APP_DVB_Playback_GetProgStateByHandle(eDBType, hCurrPrgHdl);

				if (eProgState == MID_PLAYBK_PROG_STATE_LOCKED)
				{
					*((al_bool *)pContext) = TRUE;
				}
				else
				{
					*((al_bool *)pContext) = FALSE;
				}
			}
			break;

		case FW_CONTEXT_TYPE_PARENTAL_LOCK_STATE | FW_CONTEXT_OP_TYPE_READ:
			{
				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))
				{
					mainapp_printf("Get DBType error!!!\n");
					return AL_FAILURE;
				}

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

				if (hCurrPrgHdl == AL_DB_INVALIDHDL)
				{
					mainapp_printf("Get current program handle error!!!\n");
					return AL_FAILURE;
				}

				eProgState = APP_DVB_Playback_GetProgStateByHandle(eDBType, hCurrPrgHdl);
				if (eProgState == MID_PLAYBK_PROG_STATE_LOCKED)
				{
					*((al_bool *)pContext) = al_true;
				}
				else
				{
					*((al_bool *)pContext) = al_false;
				}
			}
			break;

		case FW_CONTEXT_TYPE_COUNTRY_CODE | FW_CONTEXT_OP_TYPE_READ:
			AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_CHANNEL, 0,
				sizeof(APP_SETTING_Channel_t), &(g_stChannelData));
			u8Area = g_stChannelData.Country;
			TempCountryCode = APP_Area_GetCountryCode(u8Area);
			memcpy((al_uint8 *)pContext,(al_uint8 *)TempCountryCode,3);
			break;

	   case FW_CONTEXT_TYPE_CHECK_EVENTSTATE| FW_CONTEXT_OP_TYPE_READ:
			*((Boolean *)pContext) = DVBApp_GetForceProcessEventState();
			break;
#endif
#if defined(CONFIG_DTV_SUPPORT) || defined(CONFIG_ATV_SUPPORT)
		case FW_CONTEXT_TYPE_DB_UPDATED | FW_CONTEXT_OP_TYPE_WRITE:
			APP_ProgList_SetUpdateFlag(TRUE);
			break;
#endif
		case FW_CONTEXT_TYPE_ISO639LANGUAGE1 | FW_CONTEXT_OP_TYPE_READ:
			AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FEATURE, 0,
				sizeof(APP_SETTING_Feature_t), &(g_stFeatureData));
			Tempiso639language = APP_Language_GetISO639ByIndx(g_stFeatureData.DigitalTTLang, APP_DATA_LANG_TYPE_TELETEXT);
			if (Tempiso639language != al_null)
			{
				memcpy((al_uint8 *)pContext,(al_uint8 *)Tempiso639language,3);
			}
			break;

		case FW_CONTEXT_TYPE_ISO639LANGUAGE2 | FW_CONTEXT_OP_TYPE_READ:
			AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FEATURE, 0,
				sizeof(APP_SETTING_Feature_t), &(g_stFeatureData));
			Tempiso639language = APP_Language_GetISO639_2ByIndx(g_stFeatureData.DigitalTTLang, APP_DATA_LANG_TYPE_TELETEXT);
			if (Tempiso639language != al_null)
			{
				memcpy((al_uint8 *)pContext,(al_uint8 *)Tempiso639language,3);
			}
			break;
#ifdef CONFIG_EPG_LANG_DEFAULT_BY_OSDLANG
		case FW_CONTEXT_TYPE_OSDISO639LANGUAGE1 | FW_CONTEXT_OP_TYPE_READ:
			AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FEATURE, 0,
				sizeof(APP_SETTING_Feature_t), &(g_stFeatureData));
			Tempiso639language = APP_Language_GetISO639ByIndx(g_stFeatureData.OSDLang, APP_DATA_LANG_TYPE_EPGEXTEND);
			if (NULL != Tempiso639language)
			{
				for(i = 0; i < 3 ; i++)
				{
					Iso639lang[i] = Tempiso639language[i] + 32;
				}
				memcpy((al_uint8 *) pContext, (al_uint8 *) Iso639lang, 3);
			}
			break;

		case FW_CONTEXT_TYPE_OSDISO639LANGUAGE2 | FW_CONTEXT_OP_TYPE_READ:
			AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FEATURE, 0,
				sizeof(APP_SETTING_Feature_t), &(g_stFeatureData));
			Tempiso639language = APP_Language_GetISO639_2ByIndx(g_stFeatureData.OSDLang, APP_DATA_LANG_TYPE_EPGEXTEND);
			if (NULL != Tempiso639language)
			{
				for(i = 0; i < 3 ; i++)
				{
					Iso639_2lang[i] = Tempiso639language[i] + 32;
				}
				memcpy((al_uint8 *) pContext, (al_uint8 *) Iso639_2lang, 3);
			}
			break;
#endif

#ifdef SUPPORT_FREEVIEW_NZ
		case FW_CONTEXT_TYPE_CELLID | FW_CONTEXT_OP_TYPE_READ:
			{
				al_uint32 u32Cellid = 0;
				FrontendCmd_t  front;
				front.cmd = FRONTEND_CMD_GET_CELL_ID;
				front.param = &u32Cellid;
				ioctl(kmfdev, KMF_IOC_FRONTENDCTRL , &front);
				*(al_uint32 *)pContext = u32Cellid;
			}
			break;
#endif

		case FW_CONTEXT_TYPE_TIME_ZONE | FW_CONTEXT_OP_TYPE_READ:
			AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FEATURE, 0,
				sizeof(APP_SETTING_Feature_t), &(g_stFeatureData));
			*((al_uint8 *)pContext) = g_stFeatureData.TimeZone;
			break;

		case FW_CONTEXT_TYPE_TIME_OFFSET | FW_CONTEXT_OP_TYPE_READ:
#ifndef CONFIG_SUPPORT_MONITOR
			{
				al_int32 i32TimeVal = 0;
				float u8TimeZone = 0; 
				APP_GUIOBJ_DateTime_GetTimeZoneValue(&u8TimeZone); 
#ifdef TIMEZONE_BY_COUNTRY
				i32TimeVal = (u8TimeZone * 60 * 60);
#else
#ifdef CONFIG_AUS_DVB_SYSTEM
				if (APP_Area_Check_Area_Aus() == TRUE)
				{
					i32TimeVal = (u8TimeZone * 60 * 60);
				}
				else
#endif
				{
					i32TimeVal = (((int)u8TimeZone - 24) * 60 * 30);
				}
#endif
				*((al_int32 *)pContext) = i32TimeVal;
			}
#endif
			break;

		case FW_CONTEXT_TYPE_CHECK_FORCE_DST | FW_CONTEXT_OP_TYPE_READ:
#ifndef CONFIG_SUPPORT_MONITOR
			AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FEATURE, 0,
				sizeof(APP_SETTING_Feature_t), &(g_stFeatureData));
#ifdef CONFIG_AUS_DVB_SYSTEM
			if (APP_Area_Check_Area_Aus() == TRUE)
			{
				if((g_stFeatureData.DST)&&(APP_GUIOBJ_DateTime_CheckDSTOnOff()))
				{
					*((al_uint8 *)pContext) = TRUE;
				}
				else
				{
					*((al_uint8 *)pContext) = FALSE;
				}
			}
			else
#endif
#ifdef TIMEZONE_BY_COUNTRY
			{
				if((g_stFeatureData.DST)&&(APP_GUIOBJ_DateTime_CheckDSTOnOff()))
				{
					*((al_uint8 *)pContext) = TRUE;
				}
				else
				{
					*((al_uint8 *)pContext) = FALSE;
				}
			}
#else
			{
				*((al_uint8 *)pContext) = g_stFeatureData.DST;
			}
#endif
#endif
			break;
#ifndef CONFIG_ISDB_SYSTEM
#ifdef CONFIG_AUS_DVB_SYSTEM
		case FW_CONTEXT_TYPE_CHECK_AUS_AREA | FW_CONTEXT_OP_TYPE_READ:
			if (APP_Area_Check_Area_Aus() == TRUE)
			{
				*((al_uint8 *)pContext) = TRUE;
			}
			else
			{
				*((al_uint8 *)pContext) = FALSE;
			}
			break;
#endif
#endif
		case FW_CONTEXT_TYPE_COUNTRY_ID | FW_CONTEXT_OP_TYPE_READ:
			AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_CHANNEL, 0,
				sizeof(APP_SETTING_Channel_t), &(g_stChannelData));
			u8LacalRegionId = g_stChannelData.Country;
			*((al_uint8 *)pContext) = u8LacalRegionId;
			break;
#ifdef CONFIG_DVB_SYSTEM_DVBC_SUPPORT
		case FW_CONTEXT_TYPE_OPERATOR | FW_CONTEXT_OP_TYPE_READ:
			AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_CHANNEL, 0,
				sizeof(APP_SETTING_Channel_t), &(g_stChannelData));
			*((al_DVBC_Operator_en *)pContext) = g_stChannelData.Operator;
			break;
#endif
#ifdef CONFIG_DTV_SUPPORT
		case FW_CONTEXT_TYPE_ONID_MATCH | FW_CONTEXT_OP_TYPE_READ:
			AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_CHANNEL, 0,
				sizeof(APP_SETTING_Channel_t), &(g_stChannelData));
			u8LacalRegionId = g_stChannelData.Country;
			*((al_bool *)pContext) = _APP_DVB_CheckIsONIDMatchedByCurArea((al_uint16)Param, u8LacalRegionId);
			break;
#endif
		case FW_CONTEXT_TYPE_COUNTRY_REGION | FW_CONTEXT_OP_TYPE_READ:
			AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_SYSINFO, 0,
				sizeof(APP_SETTING_SystemInfo_t), &(g_stSysInfoData));
			u8LacalRegionId = g_stSysInfoData.CountryRegion;
			*((al_uint8 *)pContext) = u8LacalRegionId;
			break;
        case FW_CONTEXT_TYPE_TT_LANGUAGE | FW_CONTEXT_OP_TYPE_READ:
			AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FEATURE, 0,
				sizeof(APP_SETTING_Feature_t), &(g_stFeatureData));
            u8LacalRegionId = g_stFeatureData.AnalogueTTLang;
            *((al_uint8 *)pContext) = u8LacalRegionId;
            break;

		case FW_CONTEXT_TYPE_CHECK_OSDLANGUAGEFRENCH | FW_CONTEXT_OP_TYPE_READ:
			AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FEATURE, 0,
				sizeof(APP_SETTING_Feature_t), &(g_stFeatureData));
			if (g_stFeatureData.OSDLang == APP_OSDLANG_FRENCH)
			{
				*((al_bool *)pContext) = al_true;
			}
			else
			{
				*((al_bool *)pContext) = al_false;
			}
			break;

#ifdef CONFIG_SUPPORT_PVR
		case FW_CONTEXT_TYPE_PR | FW_CONTEXT_OP_TYPE_READ:
			{
				APP_SETTING_PVRInfo_t stpvr;
				al_int8  Num = AL_PR_GetMaxNoOfReminders();
				PR_details_t	PVRData[Num];

				memset(&stpvr, 0x00, sizeof stpvr);
				ret_val = AL_Setting_Reload(APP_Data_UserSetting_Handle(), SYS_SET_ID_PVR);
				if (ret_val != AL_SUCCESS)
				{
					mainapp_printf("[error]%s	%d\n",__FUNCTION__,__LINE__);
					return ret_val;
				}

				ret_val = AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_PVR, 0,
							sizeof(APP_SETTING_PVRInfo_t), &stpvr);
				if (ret_val != AL_SUCCESS)
				{
					mainapp_printf("[error]%s	%d\n",__FUNCTION__,__LINE__);
					return ret_val;
				}

				memset(&PVRData, 0, sizeof(PVRData));
				for (offset=0; offset < (al_uint32)Num; offset++)
				{
					PVRData[offset].details.db_type =(AL_DB_EDBType_t)stpvr.pvrinfo[offset].DBtype;
					PVRData[offset].details.rem_type = stpvr.pvrinfo[offset].Remtype;
					PVRData[offset].details.enable = (al_bool)stpvr.pvrinfo[offset].enable;
					PVRData[offset].details.occupied = (al_bool)stpvr.pvrinfo[offset].occupied;
					PVRData[offset].details.rem_details.handle = stpvr.pvrinfo[offset].serhdl;
					PVRData[offset].details.rem_details.event_end_time_insec = stpvr.pvrinfo[offset].end_time_in_sec;
					PVRData[offset].details.start_local_time_secs = stpvr.pvrinfo[offset].start_time_in_secs;
					PVRData[offset].details.snooze_time_secs = stpvr.pvrinfo[offset].snooze_time_in_sec;
					PVRData[offset].details.gmt_offset= stpvr.pvrinfo[offset].gmt_offset;
				#ifdef SUPPORT_EVENT_PROGRAM_TITLE
					memcpy(PVRData[offset].details.prog_name,stpvr.pvrinfo[offset].prog_name,sizeof(stpvr.pvrinfo[offset].prog_name));
				#endif
				}
				memcpy((PR_details_t*)pContext, PVRData, sizeof(PR_details_t)*Num);
				return ret_val;
			}
			break;

		case FW_CONTEXT_TYPE_PR | FW_CONTEXT_OP_TYPE_WRITE:
			{
				APP_SETTING_PVRInfo_t stpvr;
				PR_details_t * PVRData;
				AL_Return_t ret_val = AL_SUCCESS;

				PVRData = (PR_details_t *)pContext;
				memset(&stpvr, 0x00, sizeof stpvr);
				if (PVRData != al_null && Param < AL_PR_GetMaxNoOfReminders())
				{
					stpvr.pvrinfo[Param].DBtype = PVRData->details.db_type;
					stpvr.pvrinfo[Param].Remtype = PVRData->details.rem_type;
					stpvr.pvrinfo[Param].enable = PVRData->details.enable;
					stpvr.pvrinfo[Param].occupied = PVRData->details.occupied;
					stpvr.pvrinfo[Param].serhdl = PVRData->details.rem_details.handle;
					stpvr.pvrinfo[Param].end_time_in_sec = PVRData->details.rem_details.event_end_time_insec;
					stpvr.pvrinfo[Param].start_time_in_secs = PVRData->details.start_local_time_secs;
					stpvr.pvrinfo[Param].snooze_time_in_sec = PVRData->details.snooze_time_secs;
					stpvr.pvrinfo[Param].gmt_offset= PVRData->details.gmt_offset;
				#ifdef SUPPORT_EVENT_PROGRAM_TITLE
					memcpy(stpvr.pvrinfo[Param].prog_name,PVRData->details.prog_name,sizeof(stpvr.pvrinfo[Param].prog_name));
				#endif
				}
				ret_val = AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_PVR,
							ITEM_OFFSET(APP_SETTING_PVRInfo_t, pvrinfo[Param]),
							sizeof(stpvr.pvrinfo[Param]),
							&stpvr.pvrinfo[Param]);
				if (ret_val != AL_SUCCESS)
				{
					mainapp_printf("[error]%s	%d\n",__FUNCTION__,__LINE__);
					return ret_val;
				}
				ret_val = AL_Setting_Store(APP_Data_UserSetting_Handle(),SYS_SET_ID_PVR,
							ITEM_OFFSET(APP_SETTING_PVRInfo_t, pvrinfo[Param]),
							sizeof(stpvr.pvrinfo[Param]));
				if (ret_val != AL_SUCCESS)
				{
					mainapp_printf("[error]%s	%d\n",__FUNCTION__,__LINE__);
					return ret_val;
				}
				return	ret_val;
			}
			break;
#endif

		case FW_CONTEXT_TYPE_TIME_DIFFER | FW_CONTEXT_OP_TYPE_WRITE:
			g_stChannelData.Timediff = *((al_int32 *)pContext) ;
			AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_CHANNEL, 0,
				sizeof(APP_SETTING_Channel_t), &(g_stChannelData));
			AL_Setting_Store(APP_Data_UserSetting_Handle(), SYS_SET_ID_CHANNEL, 0, sizeof(APP_SETTING_Channel_t));
			break;

		case FW_CONTEXT_TYPE_TIME_DIFFER | FW_CONTEXT_OP_TYPE_READ:
			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));
			*((al_int32 *)pContext) = g_stChannelData.Timediff;
			break;

		case FW_CONTEXT_TYPE_GET_IOP_TIME | FW_CONTEXT_OP_TYPE_READ:
			{
				//extern void APP_MAIN_GetIopSleepTime(UINT8 a[]);
				//APP_MAIN_GetIopSleepTime(pContext);
			}
			break;

		case FW_CONTEXT_TYPE_GET_CHANNEL_LOCK | FW_CONTEXT_OP_TYPE_READ:
			{
				AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FACTUSER,0,
					sizeof(APP_SETTING_FactoryUser_t), &g_stFactoryUserData);

				if(g_stFactoryUserData.Function.n_Funct_HotelMode)
				{
					AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FACTHOTEL,0,
						sizeof(APP_SETTING_FactoryHotel_t), &g_stFactoryHotelData);
					*((al_int32 *)pContext) = g_stFactoryHotelData.ChannelLock;
				}
				else
				{
					*((al_int32 *)pContext) = FALSE;
				}
			}
			break;
#if defined(CONFIG_DTV_SUPPORT) || defined(CONFIG_ATV_SUPPORT)
		case FW_CONTEXT_TYPE_GET_DBNVM_HANDER | FW_CONTEXT_OP_TYPE_READ:
			{
				mainapp_printf("_____________________________________[%s] line %d\n",__FUNCTION__,__LINE__);
				AL_DB_Init_t  InitParam =	{_MAINAPP_DBNVMReadCallBack, _MAINAPP_DBNVMWriteCallBack};
				memcpy(pContext, &InitParam, sizeof InitParam);
			}
			break;

		case FW_CONTEXT_TYPE_GET_DBRESTORE_SETTER | FW_CONTEXT_OP_TYPE_READ:
			mainapp_printf("_____________________________________[%s] line %d\n",__FUNCTION__,__LINE__);
			*((al_int32 *)pContext) = (al_uint32)_MAINAPP_ResetDefVal;
			break;
#endif
		case FW_CONTEXT_TYPE_GET_SAVE_TIME| FW_CONTEXT_OP_TYPE_READ:
		{
			struct timeval temp;
			gettimeofday(&temp, NULL);
			*((al_int32 *)pContext) = (al_uint32)temp.tv_sec;
			break;
		}

#ifdef CONFIG_QSD
		case FW_CONTEXT_TYPE_GET_Current_Source | FW_CONTEXT_OP_TYPE_READ:
			{
				APP_Source_Type_t eSourceType = APP_SOURCE_MAX;
				InputSrc_t eSourcePort = INPUTSRC_END;
				APP_GUIOBJ_Source_GetMidSource(&eSourceType, &eSourcePort);
				*((al_uint32 *)pContext) = (al_uint32)eSourceType;
			}
			break;
#endif
#ifdef CONFIG_VCHIP_SUPPORT
      case FW_CONTEXT_TYPE_RRT_USERSET | FW_CONTEXT_OP_TYPE_READ:
          AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_SETUP, 0,
                          sizeof(APP_SETTING_Setup_t), &(g_stSetupData));
          *((al_int32 *)pContext) = g_stSetupData.VchipValue;
          break;
      case FW_CONTEXT_TYPE_RRT_USERSET | FW_CONTEXT_OP_TYPE_WRITE:
          g_stSetupData.VchipValue = *((al_int32 *)pContext) ;
          AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_SETUP, 0,
              sizeof(APP_SETTING_Setup_t), &(g_stSetupData));
          AL_Setting_Store(APP_Data_UserSetting_Handle(), SYS_SET_ID_SETUP, 0, sizeof(APP_SETTING_Setup_t));
          break;
#endif
#ifdef CONFIG_SUPPORT_DETECT_USBPLL
		case FW_CONTEXT_TYPE_TYPE_USBPLLFail | FW_CONTEXT_OP_TYPE_WRITE:
		   {
			   int ret = -1;
			   UINT8 * pData = NULL;
			   pData = malloc(sizeof(UINT8));
			   if (pData == NULL)
			   {
				   return AL_FAILURE;
			   }
			   memset(pData,0,sizeof(UINT8));
			   memcpy(pData,((al_int32 *)pContext),sizeof(UINT8));
			   ret = Cmd_NVMWrite(ENVMPurposeIDUSBPLLFailFlag, FALSE, sizeof(UINT8), pData);
			   if(ret != 0)
			   {
				 printf("\nFunction: %s   Write error!\n",__FUNCTION__);
			   }
			   free(pData);
			   pData = NULL;
		   }
			  break;
#endif
		default:
			return AL_FAILURE;
	}

	return AL_SUCCESS;
}

void PQ_Init(void)
{
	AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_PICTURE, 0, sizeof(APP_SETTING_Picture_t), &(g_stPictureData));
	AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FACTUSER,0, sizeof(APP_SETTING_FactoryUser_t), &g_stFactoryUserData);

	int value;

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

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

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

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

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

    if(value != PQ_DITHER_DISABLE)
    {
        MID_TVFE_SetPictureDitheringAlgorithm(AL_FLASH_GetPictureDitheringAlgorithm());
    }
	// Dynamic contrast
	DynamicContrast_t stDynamic;
	AL_FLASH_GetDynamicContrastALL(&stDynamic);
	int nLevel = stDynamic.n_PicMode_DynCon_DynamicContrastlevel;
	MID_TVFE_SetPictureDynamicContrastEnable( nLevel ? 1 : 0);
	MID_TVFE_SetPictureContrastLevel( stDynamic.n_PicMode_DynCon_ContrastLevel[nLevel] );
	MID_TVFE_SetPictureChromaLevel( stDynamic.n_PicMode_DynCon_ChromaLevel[nLevel] );
	MID_TVFE_SetPictureAlphaMode1( stDynamic.n_PicMode_DynCon_Alphamode1[nLevel] );
	MID_TVFE_SetPictureAlphaMode2( stDynamic.n_PicMode_DynCon_Alphamode2[nLevel] );
	MID_TVFE_SetPictureAlphaMode3( stDynamic.n_PicMode_DynCon_Alphamode3[nLevel] );
	MID_TVFE_SetPictureAlphaMode4( stDynamic.n_PicMode_DynCon_Alphamode4[nLevel] );
	MID_TVFE_SetPictureFleshToneLevel( stDynamic.n_PicMode_DynCon_FleshToneLevel );

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

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


/*****************************************************************************
** FUNCTION : MAINAPP_InitFlow
**
** DESCRIPTION :
**				whole system initialize flow
**
** PARAMETERS :
**				param : total sys app number
**
** RETURN VALUES:
**				None
*****************************************************************************/
int MAINAPP_InitFlow(void *param)
{
	/* if last power status is on or last memory */
    tv_SetBootRomAutoPowerOn(AL_FLASH_GetACAutoPowerOn());


#ifdef SUPPORT_WAKEUP_TIMER_IN_STANDBY
	/*< when system is wake up by timer(don't press power key). set g_fBootFromIOPTimer is TRUE */
	if (tv_GetBootType() != 0)
	{
		mainapp_printf("[debug]%s	%d\n",__FUNCTION__,__LINE__);
		mainapp_printf("The system is auto wake up\n\n");
		APP_WAKEUP_SetBootFlag(TRUE);
		AL_Power_SetWakeUpTimer(0,0);
	}
#endif
#ifdef CONFIG_TESTAUTOREBOOT
	APP_WAKEUP_SetBootFlag(FALSE);
#endif
	AL_Time_BootOnUpdateTime();
#ifdef CONFIG_SUPPORT_MONITOR_POWERSAVE
	Cmd_SetPanelPower(TRUE);
#endif
	_MAINAPP_SW_Init();

	/* initialize message filter. */
	_MAINAPP_InitSysApp((UINT32 *)param);

	/* initialize PQ relative function */
	PQ_Init();

	/*create App Infra update timer.*/
	SYSAPP_TIMER_CreateTimer();
#ifdef CONFIG_SUPPORT_NES_GAME
	joystick_add_dev();
#endif
#if 0 // newfontmask
#ifdef CONFIG_MEDIA_ENABLE
	/*set subtitle font info to sub lib.*/
	AL_Multimedia_Player_SetSubtitleFontInfo(TV_ui_font_info, TV_FONT_BLOCK_NUM, TV_FONT_STYLE_NUMBER, TV_UI_LANG_NUM);
#endif
#endif
#ifdef SUPPORT_SFU_AUTO_TEST
	Console_sfu_Cbk_t Console_SUF_Cfg =
	{
		.pfCallBack = APP_Console_SUF_Parser
	};
	al_console_sfu_init(&Console_SUF_Cfg);
	extern void event_Console(UINT32 sig, void *info, void *unused);
	event_Console(0, NULL, NULL);
#endif

#ifdef SUPPORT_ATS
	Console_ats_Cbk_t Console_ATS_Cfg =
	{
		.pfCallBack = APP_Console_ATS_Parser
	};
	al_console_ats_init(&Console_ATS_Cfg);
#endif

#ifdef SUPPORT_CONSOLE_AUTO_TEST
	Console_autotest_Cbk_t Console_AUTOTEST_Cfg =
	{
		.pfCallBack = APP_Console_AUTOTEST_Parser
	};
	al_console_autotest_init(&Console_AUTOTEST_Cfg);
	if(g_stFactoryUserData.uFacPMode)
		APP_Console_AutoTest_Action(TRUE);
#endif

#ifdef CONFIG_INN_UART_FAC_MODE
	InnRs232_autotest_Cbk_t InnRs232_AUTOTEST_Cfg =
	{
		.pfCallBack = APP_InnRs232_AUTOTEST_Parser
	};
	al_innrs232_autotest_init(&InnRs232_AUTOTEST_Cfg);
	//if(g_stFactoryUserData.xxx == TRUE)
	{
		APP_InnRs232_AutoTest_Action(TRUE);
	}
#endif

#ifdef CONFIG_HK_UART_FAC_MODE
	HkRs232_autotest_Cbk_t HkRs232_AUTOTEST_Cfg =
	{
		.pfCallBack = APP_HkRs232_AUTOTEST_Parser
	};
	al_hkrs232_autotest_init(&HkRs232_AUTOTEST_Cfg);
	//if(g_stFactoryUserData.xxx == TRUE)
	{
		APP_HkRs232_AutoTest_Action(TRUE);
	}
#endif

#ifdef CONFIG_TPV_UART_FAC_MODE
    TpvRs232_autotest_Cbk_t TpvRs232_AUTOTEST_Cfg =
    {
        .pfCallBack = APP_TpvRs232_AUTOTEST_Parser
    };
    al_tpvrs232_autotest_init(&TpvRs232_AUTOTEST_Cfg);
    //if(g_stFactoryUserData.xxx == TRUE)
    {
        APP_TpvRs232_AutoTest_Action(TRUE);
    }
#endif

#ifdef CONFIG_QSD // for S2 chip test using
	extern void event_Console(UINT32 sig, void *info, void *unused);
	event_Console(0, NULL, NULL);
	tv_SetBootRomAutoPowerOn(AC_AUTO_POWERON_ON);
#endif
#ifdef CONFIG_EXTIC_DIGITALAMP_TAS5711
	DIG_TAS5711_SW_Init();
#endif
#ifdef CONFIG_EXTIC_KEYSTONE_CORRECTION_POL8902
    POL8902_init();
#endif
#ifdef CONFIG_BT_RDA5856
	g_SystemPowerOnReadyNeedReconnectBT = TRUE;
#endif
	if (g_stFactoryUserData.n_FactSet_BurningMode == 1)
    {
    
#ifdef CONFIG_SUPPORT_DETECT_USBPLL
		   UINT8 u8USBPLL_Fail = 0;
		   Cmd_NVMRead(ENVMPurposeIDUSBPLLFailFlag, FALSE, sizeof(UINT8), &u8USBPLL_Fail);

    	   MID_TVFE_ChangeAgingModePattern(u8USBPLL_Fail);
#endif
		   APP_Cul_Fm_CheckAndStartBurningMode();
		   APP_SleepTimer_SetDetectFlag(FALSE);
    }

	_MAINAPP_CheckEnterFactoryMode();
	
	return SP_SUCCESS;
}
#ifdef CONFIG_SUPPORT_MONITOR_POWERSAVE
	extern int gcov_power_off_flag;
#endif

int MAINAPP_EnterStandby(EnterStandbyType_e type)
{
    int fd_mmio, shutdown;

	if (type == ENTERSTANDBY_UPGRADE)
	{
    	shutdown = 1;
    	ioctl(kmfdev, KMF_IOC_SHUTDOWN, &shutdown);
            	//LED control
#ifdef SUPPORT_LED_FLASH
    	APP_LED_Flash_Timer_Set(LED_FLASH_TYPE_MAX,0);
    	APP_LED_SetLEDBasicLight(0);
#endif

		/* SW Mute audio and video output */
		APP_Audio_SetMute(TRUE, FALSE, APP_MUTE_MODE_STATEMAX, APP_SOURCE_MAX);
		APP_Video_SetMute(TRUE, FALSE, APP_MUTE_MODE_STATEMAX, APP_SOURCE_MAX);
		APP_Audio_SetMuteDACHeadohone(TRUE);
		APP_Audio_SetMuteDACSpeak(TRUE);
        Cmd_gpio_WriteOnLevel(GPIO_AMP_MUTE_PIN);
        Cmd_gpio_WriteOffLevel(GPIO_AMP_EN_PIN);
        Cmd_gpio_WriteOffLevel(GPIO_AMP_STB_PIN);

		/* HW set when upgrade power off */
        _MAINAPP_SW_Finalize(type);
		_MAINAPP_HW_Finalize(type);
	}
	else
	{
		shutdown = 2;
		ioctl(kmfdev, KMF_IOC_SHUTDOWN, &shutdown);
	}
	tv_SetSysTimetoRTC();
	if((fd_mmio = open("/dev/sismmio", O_RDWR))== -1)
	{
		mainapp_printf("open /dev/sismmio fails!!\n");
		return SP_ERR_FAILURE;
	}

	mainapp_printf("*** Power Off ***\n");

#ifdef CONFIG_SUPPORT_MONITOR_POWERSAVE
	if(AL_Power_GetPowerState()==AL_POWER_STATE_SUSPEND)
	{
		mainapp_printf("*** Power Off SUSPEND***\n");
		shutdown = 3;
    	ioctl(kmfdev, KMF_IOC_SHUTDOWN, &shutdown);
		gcov_power_off_flag = true;
		close(fd_mmio);
		while(1)
		{
			sleep(100);
		}
	}
	else
		ioctl(fd_mmio, SISMMIO_REBOOT, NULL);
#else
	ioctl(fd_mmio, SISMMIO_REBOOT, NULL);
#endif
	close(fd_mmio);
	return SP_SUCCESS;

}

/*****************************************************************************
** FUNCTION : MAINAPP_FinalizeFlow
**
** DESCRIPTION :
**				whole system finalize flow
**
** PARAMETERS :
**				dParam - Finalize flow
**
** RETURN VALUES:
**				None
*****************************************************************************/
int MAINAPP_FinalizeFlow(UINT32 dParam)
{
    /* Mute audio and video output */

	APP_Audio_SetMute(TRUE, FALSE, APP_MUTE_MODE_STATEMAX, APP_SOURCE_MAX);
	APP_Video_SetMute(TRUE, FALSE, APP_MUTE_MODE_STATEMAX, APP_SOURCE_MAX);
	APP_Audio_SetMuteDACHeadohone(TRUE);
	APP_Audio_SetMuteDACSpeak(TRUE);
    Cmd_gpio_WriteOnLevel(GPIO_AMP_MUTE_PIN);
	Cmd_gpio_WriteOffLevel(GPIO_AMP_EN_PIN);
	Cmd_gpio_WriteOffLevel(GPIO_AMP_STB_PIN);

    int shutdown;
	shutdown = 1;
	ioctl(kmfdev, KMF_IOC_SHUTDOWN, &shutdown);
	//LED control
#ifdef SUPPORT_LED_FLASH	
	APP_LED_Flash_Timer_Set(LED_FLASH_TYPE_MAX,0);
	APP_LED_SetLEDBasicLight(0);
#endif	
#ifdef CONFIG_STANDBY_LED_USE_PWM_CONTROL
	tv_SetStandbyLEDPWMParam(DEFAULT_StandbyLEDPWMPeriod,DEFAULT_StandbyLEDPWMDuty);
#endif

	_MAINAPP_FinalizeSysApp(dParam);
	MAINAPP_Finalize();
	_MAINAPP_SW_Finalize(dParam);
	_MAINAPP_HW_Finalize(dParam);

	/* if last power status is off or last memory */
	if (AL_FLASH_GetACAutoPowerOn() != AC_AUTO_POWERON_ON)
	{
		 tv_SetBootRomAutoPowerOn(AC_AUTO_POWERON_OFF);
	}
	
#ifdef CONFIG_TESTAUTOREBOOT
	#if (CONFIG_AUTOREBOOT_STANDBYTIME >0)
		UINT32 currTime=0;
		AL_Time_GetRawTimeInSecs(&currTime);
		AL_Power_SetWakeUpTimer(currTime+CONFIG_AUTOREBOOT_STANDBYTIME,BootType_OnTime);
	#endif
#endif
	MAINAPP_EnterStandby(ENTERSTANDBY_NOMAL);

	return SP_SUCCESS;
}