/******************************************************************************
** 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"
#ifdef CONFIG_SUPPORT_NET_OTA
#include "net_ota.h"
#endif
#include "atv_app.h"
#ifdef CONFIG_SUPPORT_NETAPP
#include "network_app.h"
#endif
#ifdef CONFIG_MEDIA_ENABLE
#include "media_app.h"
#endif
#include "ir_map.h"
#include "umf_ir.h"
#include "drv_dtv_external.h"
#include "drv_tuner_external.h"
#include "kmf_ioctl.h"
#include "ap_extern.h"
#include "mid_dtv_display.h"
#include "mid_playback.h"
#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"

#include "TV_region_config.h"
#include "app_regionmgr.h"
#include "gl_queue.h"
#include "gl_timer.h"
#include "app_gui.h"
#include "app_scart.h"
#include "app_audio.h"
#include "app_video.h"
#include "app_factory.h"
#include "app_database.h"
#include "app_scan_save.h"
#include "mid_partition_list.h"
#ifdef SUPPORT_LED_FLASH
#include "app_led_control.h"
#endif
#include <sismmio.h>
#ifdef SUPPORT_CEC_TV
#include "umf_cec.h"
#include "app_guiobj_hdmilink.h"
#endif
#ifdef CONFIG_SUPPORT_WIFI
#include "netsetting_if.h"
#include "net_ip_setting.h"
#endif
#ifdef CONFIG_SUPPORT_MIRACAST
#include "umf_miracast.h"
//#include "wfd_if.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 "mid_siutil.h"
#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_MEDIA_ENABLE
#include "AL_Multimedia_Player_Types.h"
#endif
#ifdef CONFIG_ATV_SUPPORT
#include "app_guiobj_atv_playback.h"
#endif

#if defined (CONFIG_SUPPORT_USB_UPGRADE) || defined (CONFIG_SUPPORT_OTA_UPGRADE)
#include "mid_upgrade.h"
#endif
#include "app_guiobj_sleeptimer.h"
#include "app_guiobj_cul_fm_factorySetting_new.h"
#include "app_power_control.h"
//#include "app_scan_api.h"
#include "util_ioctl.h"
#include "al_aps_table_api.h"
#include "tuner_demod_ioctl.h"

#ifdef CONFIG_SUPPORT_NET_SETTING
#include "app_guiobj_Network_Information.h"
#endif
#ifdef CONFIG_MEDIA_ENABLE
#include "AL_Multimedia_FileSystem_IF.h"
#endif
#ifdef CONFIG_EXTIC_DIGITALAMP_TAS5711
#include "TAS5711.h"
#endif
#ifdef CONFIG_EXTIC_DIGITALAMP_NTP8849
#include "NTP8849.h"
#endif
#ifdef CONFIG_EXTIC_DIGITALAMP_WA6819B
#include "WA6819B.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
#if defined(CONFIG_BT_RDA5856)||defined(CONFIG_BT_POL6556)
#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_SMART_MODULE_SUPPORT
#include "al_uart_smart.h"
#include "al_uart_smart_ctrl.h"
#include "app_smart.h"
#endif
#ifdef CONFIG_VEHICLE_MODULE_SUPPORT
#include "al_uart_vehicle.h"
#include "al_uart_vehicle_ctrl.h"
#include "app_vehicle.h"
#endif
#include "app_sysset.h"
#include "drv_pq_internal.h"
#ifdef AC_ON_AUTO_GET_TIME
extern Boolean g_fBackgroundGetTime;
#endif
#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 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


#define DBGCONFIADDR  0xa0000010

/********************************************************************
	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_USB_RECOVER_SPOT_SUPPORT
static bool g_bFirstInsetUSB = FALSE;
#endif
#ifdef CONFIG_SUPPORT_WIFI
Boolean bWifiDongle = FALSE;
static GL_Task_t Wifi_Daemon = NULL;
Boolean bWifiDaemonInitOk = FALSE;
void _MAINAPP_WifiRoutine(void *pParam);
#endif

#ifdef CONFIG_USB_RECOVER_SPOT_SUPPORT
bool GetPowerOnFirstInsetUSB(void)
{
	return g_bFirstInsetUSB;
}
void SetPowerOnFirstInsetUSB(bool flag)
{
	g_bFirstInsetUSB = flag;
}

#endif
#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;
#ifdef CONFIG_DVB_SYSTEM
				pServInfo->u32Freq = air_table_info.pu32ScanTable[u32ChannelIdx]*1000;
                pServInfo->soundSystem = APP_OSD_SOUND_SYSTEM_M;
#elif defined(CONFIG_ISDB_SYSTEM)
				pServInfo->u32Freq = air_table_info.pu32ScanTable[u32ChannelIdx];
                pServInfo->soundSystem = ANA_SCAN_AUDIO_STD_BTSC;
#endif

                pServInfo->colorSystem = APP_OSD_COLOR_SYSTEM_DEFAULT;
                pServInfo->multiAudio = TVFE_AUDIO_SIF_MODE_ERR;
                pServInfo->tvtype = 0;
            }
            else
            {
                pServInfo->inuse = 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)
				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_DEFAULT;
                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)
{
#if defined (CONFIG_ATV_SUPPORT)
	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 = 1;
			pServInfo->colorSystem = APP_OSD_COLOR_SYSTEM_DEFAULT;
			pServInfo->soundSystem = ANA_SCAN_AUDIO_STD_A2BG;
            pServInfo->multiAudio = TVFE_AUDIO_SIF_MODE_ERR;
			break;
		default:
			break;
	}
#endif
}
#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)
     */
#if (CONFIG_ATV_SERVICE_NUM < 203)
    #error "Please config ATV program num is 203"
#endif

	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;
				#ifdef SUPPORT_ATV_SCAN_NTSCM_PALM_N_AMANUALSEARCH
				pServInfo->soundSystem = ANA_SCAN_AUDIO_STD_BTSC;
				pServInfo->AFC = 1;
				#endif
            }
            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;
				#ifdef SUPPORT_ATV_SCAN_NTSCM_PALM_N_AMANUALSEARCH
				pServInfo->soundSystem = ANA_SCAN_AUDIO_STD_BTSC;
				pServInfo->AFC = 1;
				#endif
            }
			break;

		default:
			break;
	}
}
#endif
#endif
#ifdef CONFIG_BLUETOOTH_SUPPORT
#if !defined(CONFIG_BT_RDA5856) &&  !defined(CONFIG_BT_POL6556) 
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;
	switch(eMessage)
	{
		case MIRACAST_FINDING:
			printf("[Miracast Callback] MIRACAST_FINDING\n");
			u32Message = DMN_EVENT_MIRACAST_FINDING;
			//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

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)
	{
		bRetVal = Cmd_NVMRead(ENVMPurposeIDDatabaseDVBT, TRUE, uiBytes, (UINT8 *)pBuff);
	}
	else
#endif
#ifdef CONFIG_DVB_SYSTEM_DVBC_SUPPORT
	if (enDBType == CDBI_DBTYPE_DVB_C)
	{
		bRetVal = Cmd_NVMRead(ENVMPurposeIDDatabaseDVBC, TRUE, uiBytes, (UINT8 *)pBuff);
	}
	else
#endif
#ifdef CONFIG_DVB_SYSTEM_DVBS_SUPPORT
	if (enDBType == CDBI_DBTYPE_DVB_S)
	{
		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)
	{
		bRetVal = Cmd_NVMWrite(ENVMPurposeIDDatabaseDVBT, TRUE, uiBytes, (UINT8 *)pBuff);
	}
	else
#endif
#ifdef CONFIG_DVB_SYSTEM_DVBC_SUPPORT
	if (enDBType == CDBI_DBTYPE_DVB_C)
	{
		bRetVal = Cmd_NVMWrite(ENVMPurposeIDDatabaseDVBC, TRUE, uiBytes, (UINT8 *)pBuff);
	}
	else
#endif
#ifdef CONFIG_DVB_SYSTEM_DVBS_SUPPORT
	if (enDBType == CDBI_DBTYPE_DVB_S)
	{
		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;
}

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))&&
				(g_stFactoryUserData.n_FactSet_BurningMode != 1))
			{
				APP_Video_OSD_PQSet(APP_VIDEO_OSD_ITEM_BACKLIGHT,AL_FLASH_GetBackLight());
			}
			if (
#ifdef CONFIG_ATV_SUPPORT
				((sysAppIdx == SYS_APP_ATV) && (APP_GUIOBJ_ATV_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;
		}

#if defined(CONFIG_KEYPAD_SINGLE_REUSE)
		if (dParam & (KEYPAD_EVENT_REPEAT_END))
		{
			dParam = dParam & (~KEYPAD_EVENT_REPEAT_END);
			dParam = dParam & (~KEYPAD_EVENT_REPEAT_TYPE);
		}
#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.\n",Ir_GetKeyString(IrKey));
		}
		else
		{
			mainapp_printf("IrKey ========== %d\n",IrKey);
		}
		#ifdef SUPPORT_POWERAGAIN_CONFIRM_POWEROFF
		if((IrKey == UI_EVENT_POWER)||(IrKey == UI_EVENT_KEYPAD_POWER))
		{
			dParam = AL_POWER_STATE_CONFIRM;
		}
		#endif
		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

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))
                {
                #ifdef CONFIG_USB_RECOVER_SPOT_SUPPORT
				  extern void SysApp_MM_DestroyAppointedGUI(void);
				  extern bool GetPowerOnFirstInsetUSB(void);
				  bool gb_FirstInsetUSB = GetPowerOnFirstInsetUSB();
				  printf("[%s,%d]:gb_FirstInsetUSB = %d!!!!!!!!!!!!!!!!!!!\n",__FUNCTION__,__LINE__,gb_FirstInsetUSB);
				  if ( gb_FirstInsetUSB == TRUE)//mode is last memory
				  {
				  		if (sysAppIdx == SYS_APP_FILE_PLAYER)
				  		{
							SysApp_MM_DestroyAppointedGUI();
						}
				  }
				#endif
               	#ifdef CONFIG_USB_DEMO_SUPPORT
					extern void SysApp_MM_DestroyAppointedGUI(void);
                    SysApp_MM_DestroyAppointedGUI();
            	#endif
                    if (sysAppIdx == SYS_APP_FILE_PLAYER)
                    {
                        SYSAPP_IF_GetSystemAppQueueHandle(sysAppIdx , &QueueHandle);
                        GL_QueueFlush(QueueHandle ) ;
                    }
#ifdef CONFIG_USB_RECOVER_SPOT_SUPPORT
				  else
				  { 
					if (gb_FirstInsetUSB == TRUE)//mode is last memory
					{
						//APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_MEDIA);
					}
				  }
#endif
               	#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
}

#ifdef CONFIG_KEYPAD_FIVE_KEY_REUSE
void _MAINAPP_KeyPad_FiveKey_Callback(UINT32 *dMessage)
{
	UINT32	dIndex = 0;
    INT32 dObjectID = 0;
	static BOOL bMainMenuFlg = FALSE;
    sys_app_errorcode_t ret = SYSTEM_APP_SUCCESS;
    
    if (MAIN_APP_SUCCESS != MAINAPP_GetActiveSystemAppIndex(&dIndex))
    {
        return;
    }

    if (dIndex == SYS_APP_ATV)
    {
        ret = SYSAPP_GOBJ_GetFocusedGUIObject(dIndex, &dObjectID);    
        printf("!!!!!!!!!!!!!Function=%s,line=%d,ret=%d,*dMessage=%d\n",__FUNCTION__,__LINE__,ret,*dMessage);
        if (ret == SYSTEM_APP_NO_FOCUSED_GUIOBJ || (ATVApp_IsPopupExist(PLAYBACK_POPUP_MSG_NO_SIGNAL)))//未进入菜单里
        {
			//printf("[sea]:log\n");//sea log
			if((*dMessage == UI_EVENT_UP) || (*dMessage == UI_EVENT_DOWN) )
			{
				bMainMenuFlg = FALSE;
			}
			else
			{
				bMainMenuFlg = TRUE;
			}
			//sea add for 5key
			if(*dMessage == UI_EVENT_UP)
				*dMessage = UI_EVENT_VOL_UP;
			if(*dMessage == UI_EVENT_DOWN)
				*dMessage = UI_EVENT_VOL_DN;
			//sea end

            switch(*dMessage)
            {                   
               case UI_EVENT_KEYPAD_SOURCE: 
                   *dMessage = UI_EVENT_SOURCE;
                   break;                
               case UI_EVENT_KEYPAD_POWER: 
                   *dMessage = UI_EVENT_POWER;
                   break;
               case UI_EVENT_KEYPAD_MENU:
                   *dMessage = UI_EVENT_MENU;
                   break;
               case UI_EVENT_KEYPAD_UP: 
                   *dMessage = UI_EVENT_VOL_UP;
                   break;
               case UI_EVENT_KEYPAD_DOWN: 
                   *dMessage = UI_EVENT_VOL_DN;
                   break;
               case UI_EVENT_KEYPAD_LEFT: 
                   *dMessage = UI_EVENT_CH_UP;
                   break;
               case UI_EVENT_KEYPAD_RIGHT: 
                   *dMessage = UI_EVENT_CH_DN;
                   break;                   
            } 
        }
        else if (ret == SYSTEM_APP_SUCCESS)//已经进入菜单
        {
			//sea add for 5key
			if(!bMainMenuFlg)
			{
				if(*dMessage == UI_EVENT_UP)
					*dMessage = UI_EVENT_VOL_UP;
				if(*dMessage == UI_EVENT_DOWN)
					*dMessage = UI_EVENT_VOL_DN;
			}
			//sea end

            switch (*dMessage)
            {                  
               case UI_EVENT_KEYPAD_SOURCE: 
                   *dMessage = UI_EVENT_RETURN;
                   break;    
               case UI_EVENT_KEYPAD_MENU:
                   *dMessage = UI_EVENT_ENTER;
                   break;                   
               case UI_EVENT_KEYPAD_UP: 
                   *dMessage = UI_EVENT_VOL_UP;
                   break;
               case UI_EVENT_KEYPAD_DOWN: 
                   *dMessage = UI_EVENT_VOL_DN;
                   break;
               case UI_EVENT_KEYPAD_LEFT: 
                   *dMessage = UI_EVENT_CH_UP;
                   break;
               case UI_EVENT_KEYPAD_RIGHT: 
                   *dMessage = UI_EVENT_CH_DN;
                   break;                   
            } 
        }
    }
    else if (dIndex == SYS_APP_FILE_PLAYER)
    {
        ret = SYSAPP_GOBJ_GetFocusedGUIObject(dIndex, &dObjectID);          
        printf("!!!!!!!!!!!!!Function=%s,line=%d,ret=%d,*dMessage=%d\n",__FUNCTION__,__LINE__,ret,*dMessage);
        if (ret == SYSTEM_APP_NO_FOCUSED_GUIOBJ)
        {
            switch(*dMessage)
            {
                case UI_EVENT_KEYPAD_MENU:
                    *dMessage = UI_EVENT_MENU;
                    break;
                case UI_EVENT_KEYPAD_SOURCE: 
                    *dMessage = UI_EVENT_SOURCE;
                    break;                 
                case UI_EVENT_KEYPAD_POWER: 
                    *dMessage = UI_EVENT_POWER;
                    break;
                case UI_EVENT_KEYPAD_UP: 
                    *dMessage = UI_EVENT_CH_UP;
                    break;
                case UI_EVENT_KEYPAD_DOWN: 
                    *dMessage = UI_EVENT_CH_DN;
                    break;
                case UI_EVENT_KEYPAD_LEFT: 
                    *dMessage = UI_EVENT_VOL_UP;
                    break;
                case UI_EVENT_KEYPAD_RIGHT: 
                    *dMessage = UI_EVENT_VOL_DN;
                    break;          
            } 
        }
        else if (ret == SYSTEM_APP_SUCCESS)
        {
            switch(*dMessage)
            {
                case UI_EVENT_KEYPAD_MENU:
                    *dMessage = UI_EVENT_ENTER;
                    break;
                case UI_EVENT_KEYPAD_EXIT: 
                    *dMessage = UI_EVENT_EXIT;
                    break;                 
                case UI_EVENT_KEYPAD_POWER: 
                    *dMessage = UI_EVENT_POWER;
                    break;
                case UI_EVENT_KEYPAD_UP: 
                    *dMessage = UI_EVENT_CH_UP;
                    break;
                case UI_EVENT_KEYPAD_DOWN: 
                    *dMessage = UI_EVENT_CH_DN;
                    break;
                case UI_EVENT_KEYPAD_LEFT: 
                    *dMessage = UI_EVENT_VOL_UP;
                    break;
                case UI_EVENT_KEYPAD_RIGHT: 
                    *dMessage = UI_EVENT_VOL_DN;
                    break;   
            } 
        }
    }
    
/*
	if (*dMessage != UI_EVENT_KEYPAD_POWER_KEY_LONG_PRESS)
	{
	    if(!(SYSAPP_GOBJ_GUIObjectExist(dIndex,APP_GUIOBJ_THREE_KEY_KEYPADMENU)))
	    {
			if ((dIndex == SYS_APP_ATV) && (ATVApp_IsPopupExist(PLAYBACK_POPUP_MSG_NO_SIGNAL)))
	        {
	            ATVApp_ClosePopup(PLAYBACK_POPUP_MSG_NO_SIGNAL, UI_EVENT_NULL);
	        }	
	        SYSAPP_IF_SendGlobalEventWithIndex(dIndex,
	            APP_GLOBAL_EVENT_THREE_KEY_KEYPADMENU_OPEN | PASS_TO_SYSAPP, *dMessage);
	    }
	}
*/

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

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_WIFI
    if (GL_TaskCreate("Wifi Dongle detect", (void *) _MAINAPP_WifiRoutine, NULL, 3, 4096, TRUE, &(Wifi_Daemon)) != GL_SUCCESS)
        printf("pthread_create fail: MAINAPP_WifiRoutine thread\n");
#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);

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

	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;
	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
	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
#if defined(CONFIG_BT_RDA5856) || defined(CONFIG_BT_POL6556)
    BT_ModualCfg_t BT_ModualCfg = {
        .pfCallBack = APP_BT_ModuleCallback
    };
	APP_BT_data_init(10);
#else
    BT_ModualCfg_t BT_ModualCfg = {
        .pfCallBack = _MAINAPP_Bluetooth_Callback
    };
#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_VEHICLE_MODULE_SUPPORT
		Vehicle_ModualCfg_t Vmart_ModualCfg = {
			.pfCallBack = APP_Vehicle_VehicleModuleCallback
		};
		Vehicle_Init(&Vmart_ModualCfg);
#endif

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

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

#ifdef CONFIG_DVB_SYSTEM_DVBS_SUPPORT
	MID_Playback_DVBSTuneInit();
#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

	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
	    Cmd_mmio_WriteUINT32(DBGCONFIADDR,0);
		MID_TVFE_SetDebugModeOn(UARTMode);
	}else
    {
        //mantis 21437 for disable all msg
        Cmd_mmio_WriteUINT32(DBGCONFIADDR,0x41000400);
    }
	
	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(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;
	}
#ifdef CONFIG_SUPPORT_FLIP_HORIZ
    extern UINT8 APP_GUIOBJ_Language_IsFlipHoriz(void);
    GEL_RegisterFlipHorizCallback(APP_GUIOBJ_Language_IsFlipHoriz);
#endif
	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));

    GUI_FUNC_CALL(GEL_SetBmpInfo(TV_bitmap_res));

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

#ifdef CONFIG_PROJECTOR_ASPECT	
	AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_PICTURE,
		ITEM_OFFSET(APP_SETTING_Picture_t, Projectionzoom),
		sizeof(g_stPictureData.Projectionzoom),
		&(g_stPictureData.Projectionzoom));
	MID_SetZoomAspect(g_stPictureData.Projectionzoom,g_stPictureData.Projectionzoom);
#endif

    MID_PartitionList_Init(DeviceMountStatus_Callback);

	MID_Mon_Init();

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

#ifdef CONFIG_SUPPORT_ACTION_SHOW_BLUE_SCREEN_EXCEPT_MEDIA
	MID_DISP_DTVSetTVFEMuteColorByAPP(TRUE);
#else
	MID_DISP_DTVSetTVFEMuteColorByAPP(FALSE);
#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;

		AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_VARIATIONAL, 0,
			sizeof(APP_SETTING_Variational_t), &(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_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
		{
			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

#ifdef CONFIG_SUPPORT_WIFI
void _MAINAPP_WifiRoutine(void *pParam)
{
    mainapp_printf("[debug]%s   %d\n",__FUNCTION__,__LINE__);
#ifdef CONFIG_SUPPORT_MULTI_DONGLE
    char cmd[100] = {0};
#endif    
    //rcs can not check wifidongle
#ifdef CONFIG_BOOTUP_WITH_EXTRA_ROOTFS
    struct stat buf;
    while(-1 != stat("/rootfs_ext.tar.gz", &buf))
    {
        printf("system not init ok ");
        GL_TaskSleep(100);
    }    
#endif

#ifdef CONFIG_SUPPORT_MULTI_DONGLE
    Dongle_e Dongle_Select = MID_NWSI_WLAN_CheckWifiDongle();
    MID_NWSI_WLAN_RemoveWifiModule(Dongle_Select);
    memset(cmd, 0, 100);
    sprintf(cmd, "ln -fs /bin/%s/wpa_supplicant /bin/wpa_supplicant", g_DongleMap[Dongle_Select].pDongleOutputString);
    system(cmd);
	
    memset(cmd, 0, 100);
    sprintf(cmd, "ln -fs /etc/%s/* /etc", g_DongleMap[Dongle_Select].pDongleOutputString);
    system(cmd);
	
    memset(cmd, 0, 100);
    sprintf(cmd, "ln -fs /tmp/%s/* /tmp", g_DongleMap[Dongle_Select].pDongleOutputString);
    system(cmd);

    if(Dongle_Select != Dongle_None)
        system("./tmp/wifi_start.sh");
    else
        printf("Didn't insert dongle \n");
#endif	

#ifdef CONFIG_SUPPORT_NET_SETTING
    APP_Network_Init();
#endif

#ifdef CONFIG_SUPPORT_MIRACAST
    MIRACAST_ModualCfg_t MIRACAST_ModualCfg =
    {
        .pfCallBack = _MAINAPP_MIRACAST_Callback
    };
    miracast_Init(&MIRACAST_ModualCfg);
#endif

    bWifiDaemonInitOk = TRUE;
    
    GL_TaskSelfDelete();
}
#endif

static int _MAINAPP_InitSysApp(UINT32* dTotalApp)
{
	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);
	AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_SETUP, 0,
					sizeof(APP_SETTING_Setup_t), &(g_stSetupData));
	#if 0
	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);
	}
	#endif
#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 0
		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_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.*/
#ifdef SUPPORT_BOOT_SPEEDUP
	#ifdef CONFIG_MEDIA_ENABLE
	if (SourceIndex == APP_SOURCE_MEDIA || SourceIndex == APP_SOURCE_MEDIA1)
	{
        SYSAPP_IF_InitializeSysApp(SYS_APP_FILE_PLAYER, MainAppQueueHandle);
    }
	else
	#endif
	#ifdef CONFIG_SUPPORT_NETAPP
	if (i == SYS_APP_NETWORK)
	{
		SYSAPP_IF_InitializeSysApp(i, MainAppQueueHandle);
	}
	else
	#endif
	#ifdef CONFIG_ATV_SUPPORT
	{
		SYSAPP_IF_InitializeSysApp(SYS_APP_ATV, MainAppQueueHandle);
    }
	#endif
#else
	UINT8 i;
    for (i = 0; i < TOTAL_SYS_APP_SIZE; i++)
	{
		SYSAPP_IF_InitializeSysApp(i, MainAppQueueHandle);
	}
#endif

#ifdef CONFIG_SUPPORT_OTA_UPGRADE
	 APP_GUIOBJ_DVB_OTAPrompt_SetShowFlag(OtaShowPromt_FromStandby);
#endif

#ifdef CONFIG_BLUETOOTH_SUPPORT
    Al_Bluetooth_Enable();
#endif
#ifdef CONFIG_SMART_MODULE_SUPPORT
	Al_Smart_Enable();
#endif
#ifdef CONFIG_VEHICLE_MODULE_SUPPORT
	Al_Vehicle_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
#if defined(CONFIG_KEYPAD_SINGLE_REUSE)
#ifdef CONFIG_SUPPORT_SHOW_KEYPADMENU
    ir_RegisterKpCallback(APP_GetSingleKeyPadEvent);
#endif
#elif defined (CONFIG_KEYPAD_FIVE_KEY_REUSE)
    ir_RegisterKpCallback(_MAINAPP_KeyPad_FiveKey_Callback);
#endif


#ifdef CONFIG_SUPPORT_NES_GAME 
	joystick_init(_MAINAPP_Joystick_Callback);
#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 (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_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 = 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;
	#endif
		APP_GUIOBJ_Source_SetAppSource(SourceIndex);
		APP_GUIOBJ_Source_SetSourceTransState(FALSE);
    }
	MAINAPP_RegisterFunc(APP_CustomerFuncStart, APP_CustomerFuncEnd);
	return 0;
}

static int _MAINAPP_FinalizeSysApp(UINT32 dParam)
{
	UINT32  dIndex = TOTAL_SYS_APP_SIZE;

	APP_GUIOBJ_SleepTimer_SetTimeoutPowerOffStatus(FALSE);
	MAINAPP_SetPowerOffState(TRUE);

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

	/* Finalize all system app */
	{
		UINT8 i;
		for (i = 0; i < TOTAL_SYS_APP_SIZE; i++)
		{
			MAINAPP_FinalizeSystemApp(i);
		}
	}

#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)
{
	
	Cmd_Tuner_PowerSaving();
	
#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);
	//Cmd_gpio_WriteOffLevel(GPIO_LED_G_ON_PIN);
#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
    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 = TOTAL_SYS_APP_SIZE;
#ifdef CONFIG_SUPPORT_WIFI
	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

	MAINAPP_GetActiveSystemAppIndex(&u32CurrentSysappIndex);

	/* Main app dispose */
	switch (event)
	{
		case FW_DB_LOAD_DEFAULT:
			message = FW_DB_LOAD_DEFAULT;
			dParam = *(UINT32 *)param;
			break;
		case FW_USB_PLUGIN:
		{
			#ifdef CONFIG_SUPPORT_MULTI_DONGLE
			char cmd[100] = {0};
			#endif
			#ifdef CONFIG_USB_RECOVER_SPOT_SUPPORT
			//g_bFirstInsetUSB = FALSE;
			//printf("[%s,%d]:receive FW_USB_PLUGIN msg!,u32CurrentSysappIndex = %d\n",__FUNCTION__,__LINE__,u32CurrentSysappIndex);
			//if (u32CurrentSysappIndex == TOTAL_SYS_APP_SIZE)
			{
				g_bFirstInsetUSB = TRUE;
				printf("[%s,%d]:receive FW_USB_PLUGIN msg!!!!!!!!!\n",__FUNCTION__,__LINE__);
			}	
			#endif
			#ifdef CONFIG_SUPPORT_NES_GAME 
			joystick_add_dev();
			#endif
			#ifdef CONFIG_SUPPORT_WIFI
			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
				{
					Dongle_Check = MID_NWSI_WLAN_CheckWifiDongle();
					if(Dongle_Check != Dongle_None)
					{
						#ifdef CONFIG_SUPPORT_MULTI_DONGLE
						memset(cmd, 0, 100);
						sprintf(cmd, "ln -fs /bin/%s/wpa_supplicant /bin/wpa_supplicant", g_DongleMap[Dongle_Check].pDongleOutputString);
						system(cmd);

						memset(cmd, 0, 100);
						sprintf(cmd, "ln -fs /etc/%s/* /etc", g_DongleMap[Dongle_Check].pDongleOutputString);
						system(cmd);

						memset(cmd, 0, 100);
						sprintf(cmd, "ln -fs /tmp/%s/* /tmp", g_DongleMap[Dongle_Check].pDongleOutputString);
						system(cmd);
						#endif

						MID_NWSI_WLAN_InsertWifiModule(Dongle_Check);
					}
					else
						printf("insert unsupported dongle \n");
				}
			}
			#endif
		}
		break;
		case FW_USB_PLUGOUT:
		{
			#ifdef CONFIG_SUPPORT_MULTI_DONGLE
			char cmd[100] = {0};
			#endif
			#ifdef CONFIG_SUPPORT_NES_GAME 
			joystick_remove_dev();
			#endif
			#ifdef CONFIG_SUPPORT_WIFI
			Dongle_Org = MID_NWSI_WLAN_GetWifiDongle();
			Dongle_Check = MID_NWSI_WLAN_CheckWifiDongle();
			bWifiDongle = FALSE;
			if(Dongle_Check != Dongle_Org && Dongle_Check == Dongle_None && WIFI_DONGLE!=Dongle_RDA_5995)
			{        
				bWifiDongle = TRUE;
				MID_NWSI_WLAN_RemoveWifiModule(Dongle_Org);
				#ifdef CONFIG_SUPPORT_MULTI_DONGLE
				memset(cmd, 0, 100);
				sprintf(cmd, "rm -rf /bin/wpa_supplicant");
				system(cmd);

				if(Dongle_Org == Dongle_AIC_8800)
				{
					memset(cmd, 0, 100);
					sprintf(cmd, "rm -rf /tmp/aic_load_fw.ko");
					system(cmd);
				}

				memset(cmd, 0, 100);
				sprintf(cmd, "rm -rf /tmp/%s.ko", g_DongleMap[Dongle_Org].pKoName);
				system(cmd);
				#endif
			}
			#endif
		}
		break;
		default:
			break;
	}

	if (message != 0xffffffff)
	{
		MAINAPP_SendGlobalEvent(message, dParam);
		return;
	}
	/* 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)
{
	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

	if (pContext == NULL)
	{
		return AL_FAILURE;
	}
	al_uint32 ContextTypeOP = ContextType|opera;
	switch (ContextTypeOP)
	{
		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 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:
#if 0
			AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FEATURE, 0,
				sizeof(APP_SETTING_Feature_t), &(g_stFeatureData));
			u8TimeZone = g_stFeatureData.TimeZone;
			*((al_uint8 *)pContext) = u8TimeZone;
#else
			//APP_GUIOBJ_DateTime_GetTimeZoneValue((al_uint8 *)pContext);
#endif
			break;

		case FW_CONTEXT_TYPE_TIME_OFFSET | FW_CONTEXT_OP_TYPE_READ:
			{
				al_int32 i32TimeVal = 0;
				al_uint8 u8TimeZone = 0;

				//APP_GUIOBJ_DateTime_GetTimeZoneValue(&u8TimeZone);
				i32TimeVal = (((int)u8TimeZone - 24) * 60 * 30);
				*((al_int32 *)pContext) = i32TimeVal;
			}

			break;

		case FW_CONTEXT_TYPE_CHECK_FORCE_DST | FW_CONTEXT_OP_TYPE_READ:
			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
			*((al_uint8 *)pContext) = g_stFeatureData.DST;
		break;
#ifdef CONFIG_DTV_SUPPORT
		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
		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;
		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_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) = TRUE;
			}
			else
			{
				*((al_bool *)pContext) = 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;
				}

				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 = stpvr.pvrinfo[offset].enable;
					PVRData[offset].details.occupied = 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;

		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;
		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
		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);
    AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_PQSETTING,0,sizeof(APP_SETTING_PqSetting_t),&(g_stPqSettingData));
	AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_SETUP, 0, sizeof(APP_SETTING_Setup_t), &(g_stSetupData));

	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)
{
	  UINT8 DitheringBit = 0;
	UINT8 Algorithm = 0;
	UINT8 bStatus;

	/* if last power status is on or last memory */
	if (AL_FLASH_GetACAutoPowerOn() > 0)
	{
		 tv_SetBootRomAutoPowerOn(al_true);
	}

#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
	AL_Time_BootOnUpdateTime();

	_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_QSD // for S2 chip test using
	extern void event_Console(UINT32 sig, void *info, void *unused);
	event_Console(0, NULL, NULL);
	tv_SetBootRomAutoPowerOn(al_true);
#endif

#ifndef CONFIG_SYSTEM_WATCHDOG_DISABLE
	if(g_stFactoryUserData.Function.n_Funct_WatchDog == 0)//remove watchdog
	{
		extern void wdog_remove(void);
		wdog_remove();
	}
#endif

#ifdef CONFIG_EXTIC_DIGITALAMP_TAS5711
	DIG_TAS5711_SW_Init();
#endif
#ifdef CONFIG_EXTIC_DIGITALAMP_NTP8849
    DIG_NTP8849_SW_Init();
#endif
#ifdef CONFIG_EXTIC_DIGITALAMP_WA6819B
	DIG_WA6819B_SW_Init();
#endif

#ifdef CONFIG_BT_RDA5856
	g_SystemPowerOnReadyNeedReconnectBT = TRUE;
#endif
	if (g_stFactoryUserData.n_FactSet_BurningMode == 1)
    {
#if defined(CONFIG_SUPPORT_BURN_MUSIC)	
    	   g_stFactoryUserData.n_FactSet_BurningMode = 0;	   
    	   AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_FACTUSER,
    	   ITEM_OFFSET(APP_SETTING_FactoryUser_t, n_FactSet_BurningMode),
    	   sizeof(g_stFactoryUserData.n_FactSet_BurningMode),&(g_stFactoryUserData.n_FactSet_BurningMode));
    	   AL_Setting_Store(APP_Data_UserSetting_Handle(), SYS_SET_ID_FACTUSER,
    	   ITEM_OFFSET(APP_SETTING_FactoryUser_t, n_FactSet_BurningMode),
    	   sizeof(g_stFactoryUserData.n_FactSet_BurningMode));
#else
		APP_Cul_Fm_CheckAndStartBurningMode();
		APP_Video_OSD_PQSet(APP_VIDEO_OSD_ITEM_BACKLIGHT, 100);
		APP_SleepTimer_SetDetectFlag(FALSE);
#endif
    }
	
#ifdef CONFIG_AUTO_DETECT_VALID_SOURCE
	APP_GUIOBJ_Source_AutoDetectSourceInit();
#endif	
	bStatus = AL_FLASH_GetPictureDithering();
		
	//	printf("\n\n\n\n MAINAPP_InitFlow	bStatus = %d   \n\n\n",bStatus);
		MID_TVFE_SetPictureDithering(bStatus);
		if(bStatus!= 0)
		{			 
			if (bStatus == PQ_DITHER_METHOD_1)
			{
				DitheringBit = AL_FLASH_GetPictureDitheringBit();
			}
			else
			{
				DitheringBit = AL_FLASH_GetPictureDitheringBit_M2();
			}
			MID_TVFE_SetPictureDitheringLevel(DitheringBit);
			Algorithm = AL_FLASH_GetPictureDitheringAlgorithm();
			MID_TVFE_SetPictureDitheringAlgorithm(Algorithm);
		}
	return SP_SUCCESS;
}
#ifdef CONFIG_GCOV_APPLICATION
	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_GCOV_APPLICATION
	gcov_power_off_flag = true;
	while(1);
#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

	_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(al_false);
	}

	MAINAPP_EnterStandby(ENTERSTANDBY_NOMAL);
	return SP_SUCCESS;
}