UTS6710/aps/application/s2tek/formal/network/network_app.c

#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <types.h>

#include "app_infra/sysapp_if.h"
//#include "app_infra/cbk_event.h"
#include "sysapp_table.h"
#include "app_event.h"
#include "app_guiobj_source.h"
#include "app_guiobj_popmsg.h"
#include "app_guiobj_sleeptimer.h"
#include "app_guiobj_mainmenu.h"
#include "app_gui.h"
#include "app_guiobj_mute.h"
#include "app_data_setting.h"
#include "util_ioctl.h"
#include "app_audio.h"
#include "main_app.h"
#include "app_factory.h"
#include "network_app.h"
#include "network_gui_object_table.h"

#ifdef SUPPORT_CEC_TV
#include "umf_cec.h"
#endif
#include "app_guiobj_hdmilink.h"

//#include "airplay_app_gui_data.h"
#include "app_dvb_event.h"

#ifdef CONFIG_SUPPORT_MIRACAST
#include "wfd_if.h"
#include "wfd_core.h"
#include "app_guiobj_mute.h"
#include "umf_miracast.h"
#endif

#if defined (CONFIG_SUPPORT_DLNA)
#include "net_video_flow_ctrl.h"
#endif
#if defined (CONFIG_SUPPORT_NET_PLAY_RTSP) || defined(CONFIG_SUPPORT_NET_PLAY_HTTP)
#include "netctrl_video_flow_ctrl.h"
#endif
#include "app_video.h"
#ifdef CONFIG_SUPPORT_DLNA
#include "dlna_mw_if.h"
#endif
#ifdef CONFIG_SUPPORT_WIFI
#include "netsetting_if.h"
#endif
#include "app_guiobj_adjust.h"
#include "app_guiobj_Network_Information.h"

#include "app_menumgr.h"
#include "app_guiobj_fm_factory.h"
#include "NET_homepage_gui.h"
#include "app_sysset.h"
#include "app_guiobj_cul_fm_factorySetting_new.h"
#ifdef CONFIG_SUPPORT_NET_OTA
#include "net_ota.h"
#include "app_usb_upgrade.h"
#endif
#ifdef CONFIG_SUPPORT_NEW_AIRPLAY
#include "airplay.h"
#endif


//#define NETWORK_GUI_OBJECT_TABLE_DEFINE_HERE
#define NET_DEBUG

#ifdef NET_DEBUG
#define net_printf(fmt, arg...) printf("[NETWORK]"fmt,##arg)
#else
#define net_printf(a,...) do{}while(0)
#endif

//pthread_t nMiracastThread;

static int  Network_App_OnCreate(void** ppPrivateData);
static int  Network_App_OnDestroy(void** ppPrivateData);
static int  Network_App_OnRun(void* pPrivateData, UINT32 dParam);
static int  Network_App_OnTerminate(void* pPrivateData, UINT32 dParam);
static int  Network_App_OnTimerUpdate(void* pPrivateData);
static int  Network_App_OnEvent(void* pPrivateData, UINT32 dMessage, UINT32 dParam);

extern void _APP_GUIOBJ_Sound_SetMuteStatus();
static UINT8 g_u8SourceTrastTimer = 0;
#ifdef CONFIG_SUPPORT_NET_SETTING
static pthread_t gNetworkConnect_task;
#endif
#if (defined CONFIG_SUPPORT_WIFI) && (defined CONFIG_SUPPORT_NET_SETTING)
static UINT8 g_WifiConnecting = 0;
#endif
#ifdef CONFIG_SUPPORT_DLNA
static GL_Semaphore_t gDlnaSema = NULL;
static pthread_t gDlnaInitThread;
static bool gDlnaInitThreadValid = false;
static bool gDlnaInitThreadRunning = false;
static bool gDlnaInited = false;
#endif
#ifdef CONFIG_SUPPORT_MIRACAST
extern Boolean bWifiDongle;
#endif
#define URL_LEN	128

#ifdef SUPPORT_CEC_TV
static INT32 g_u32Mutekeydelaytime = 10;
static INT32 g_u32MuteIconHandle = 10;
static INT32 MUTE_KEY_INTERVAL = 10;
#endif
#ifdef CONFIG_SUPPORT_NET_PLAY_RTSP
static void _Play_RTSP_Stream()
{
	char szRtpUrl[URL_LEN] = "\0";
	UINT8 u8Mute = 0;

	memset(szRtpUrl, '\0', URL_LEN * sizeof(char));
	snprintf(szRtpUrl, URL_LEN * sizeof(char), "%s", "rtsp://192.168.0.100:8092/28MX.flv");

	NetCtrl_SetMediaInfo(szRtpUrl);
		
	/* mute/unmute audio */
	AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_USERINFO, 0,
	         sizeof(APP_SETTING_UserInfo_t), &(g_stUserInfoData));
	u8Mute = g_stUserInfoData.Mute;	
	APP_Audio_SetMute(u8Mute, TRUE, APP_MUTE_MODE_SIGNAL_DETECT, APP_SOURCE_NET);
	APP_Video_SetMute(FALSE, TRUE, APP_MUTE_MODE_SIGNAL_DETECT, APP_SOURCE_NET);
	
}
#elif defined(CONFIG_SUPPORT_NET_PLAY_HTTP)
static void _Play_HTTP_Stream()
{
	char szRtpUrl[URL_LEN] = "\0";
	UINT8 u8Mute = 0;

	memset(szRtpUrl, '\0', URL_LEN * sizeof(char));
	snprintf(szRtpUrl, URL_LEN * sizeof(char), "%s", "http://192.168.0.100:8088/28.ts");

	NetCtrl_SetMediaInfo(szRtpUrl);
		
	/* mute/unmute audio */
	AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_USERINFO, 0,
	         sizeof(APP_SETTING_UserInfo_t), &(g_stUserInfoData));
	u8Mute = g_stUserInfoData.Mute;	
	APP_Audio_SetMute(u8Mute, TRUE, APP_MUTE_MODE_SIGNAL_DETECT, APP_SOURCE_NET);
	APP_Video_SetMute(FALSE, TRUE, APP_MUTE_MODE_SIGNAL_DETECT, APP_SOURCE_NET);
	
}
#endif

#ifdef CONFIG_SUPPORT_NET_SETTING
static void _APP_GUIOBJ_NetworkInformation_Connect(void *param)
{
#ifdef CONFIG_SUPPORT_WIFI
	Al_APPW_t *pAPPW = NULL;
	int retry_count = 0;
	MID_NWSI_MAC_Addr_t mac;
#endif
	pthread_detach(pthread_self());
#if (defined CONFIG_SUPPORT_WIFI) && (defined CONFIG_SUPPORT_NET_SETTING)
	g_WifiConnecting = TRUE;
#endif
	AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_SETUP, 0,
		sizeof(APP_SETTING_Setup_t), &(g_stSetupData));

	switch (g_stSetupData.NetworkConnectMode)
	{
#ifdef CONFIG_SUPPORT_ETHERNET
		case e_AL_Network_Mode_Ethernet:
			Al_Network_Ctrl_Set_ConnectMode(e_AL_Network_Mode_Ethernet);
			Al_Network_Ctrl_SetDhcpStatic(e_AL_Network_Mode_Ethernet, g_stSetupData.EthernetConnectMode, &g_stSetupData.IPSetting);
			break;
#endif
#ifdef CONFIG_SUPPORT_WIFI
		case e_AL_Network_Mode_Wireless:
		{
			printf("e_AL_Network_Mode_Wireless =%d\n",g_stSetupData.WiFiSetting.bConnectedWifi);
			while(((MID_NWSI_GetMAC(E_MID_NWSI_CONNECT_TYPE_WIRELESS, &mac) != 0)
				|| ((MID_NWSI_GetIFFlag(E_MID_NWSI_CONNECT_TYPE_WIRELESS) & E_MID_NWSI_IF_UP) != E_MID_NWSI_IF_UP))
				&& retry_count < 40)
			{
				usleep(200000);
				retry_count ++;
				printf("wait dongle firmware ready\n");
			}
			Al_Network_Ctrl_Set_ConnectMode(e_AL_Network_Mode_Wireless);
			if(g_stSetupData.WiFiSetting.bConnectedWifi)
			{
				pAPPW = &g_stSetupData.WiFiSetting.WiFiPassword.APPW[0];
				Al_Network_Ctrl_SetIPMode(e_AL_IPMode_Auto);
				printf("@@@@@@@@@@@@@@@@ %s %d %d%d%d%d%d%d%d%d%d %d\n",g_stSetupData.WiFiSetting.ConnectAPData.name, pAPPW->PWlen, pAPPW->PassWord[0],pAPPW->PassWord[1],pAPPW->PassWord[2],pAPPW->PassWord[3],
						pAPPW->PassWord[4],pAPPW->PassWord[5],pAPPW->PassWord[6],pAPPW->PassWord[7],pAPPW->PassWord[8],pAPPW->PassWord[9]);
				if(Al_Network_Ctrl_ConnectAP(g_stSetupData.WiFiSetting.ConnectAPData, pAPPW->PWlen, pAPPW->PassWord) == AL_SUCCESS)
				{
					Al_Network_Ctrl_SetDhcpStatic(e_AL_Network_Mode_Wireless, g_stSetupData.EthernetConnectMode, &g_stSetupData.IPSetting);
				}
			}
		}
		break;
#endif
		default:
			break;
	}
	gNetworkConnect_task = 0;
#if (defined CONFIG_SUPPORT_WIFI) && (defined CONFIG_SUPPORT_NET_SETTING)
	g_WifiConnecting = FALSE;
#endif
	pthread_exit(NULL);
}
#endif
/******************************************************************************/
/**
* @brief
* @param
* @return
*
******************************************************************************/
#if ((defined CONFIG_SUPPORT_WIFI) || (defined CONFIG_SUPPORT_ETHERNET)) && (defined CONFIG_SUPPORT_NET_SETTING)	
void Network_App_Reconnect(void)
{
	pthread_attr_t AVAttr;
	int pthread_kill_err=ESRCH;
	pthread_attr_init(&AVAttr);
	pthread_attr_setstacksize(&AVAttr, 1*1024*1024);
	if(gNetworkConnect_task!=0)
		pthread_kill_err=pthread_kill(gNetworkConnect_task, 0);
	if(pthread_kill_err == ESRCH)
	{
		if(pthread_create(&gNetworkConnect_task, &AVAttr, (void *)_APP_GUIOBJ_NetworkInformation_Connect, NULL) !=0)
		{
			printf("Network_Connect pthread_create fail\n");
		}
	}
	pthread_attr_destroy(&AVAttr);
}
#endif
#if (defined CONFIG_SUPPORT_WIFI) && (defined CONFIG_SUPPORT_NET_SETTING)	
void Network_App_DisconnectWifi(void)
{
	int retry_count = 0;
	while(g_WifiConnecting && retry_count < 60)
	{
		usleep(200000);
		retry_count ++;
		printf("wait wifi connect finish \n");
	}
	Al_Network_Ctrl_Set_ConnectMode(e_AL_Network_Mode_None);
	Al_Network_Ctrl_DisconnectAP();
}
UINT8 Network_App_GetWifiConnectStatus()
{
	return g_WifiConnecting;
}
#endif


/******************************************************************************/
/**
* @brief
* @param
* @return
*
******************************************************************************/
static int NET_DestroyPartialObjects(bool bIsCleanAll)
{
    int i = 0;
    UINT32 u32TotalObj;
    UINT8 u8FilteredObj = 0;
    UINT32 u32GuiObjID[NET_GUIOBJ_MAX];
	UINT32 u32CloseGuiObjID[NET_GUIOBJ_MAX] = {0};

    /*
    when we call this api to destroty all gui object, the the current gui object will not
    implement lose foucus function,this means that some ui resource will not free,so
    create a null gui object to let the current gui object lost focus--gadenia
    */
    if(bIsCleanAll)
    {
       SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_NETWORK, NET_GUIOBJ_NULL, 0);
    }

    if (SYSAPP_GOBJ_GetTotalCreatedObjects(SYS_APP_NETWORK, &u32TotalObj) \
        == SYSTEM_APP_INDEX_ERROR)
    {
        net_printf("%s() %d\n", __FUNCTION__, __LINE__);
        return SP_ERR_FAILURE;
    }

    for (i = u32TotalObj - 1; i >= 0; i--)
    {
        if (SYSAPP_GOBJ_GetObjectIDByIndex(SYS_APP_NETWORK, i , &u32GuiObjID[u8FilteredObj]) \
            == SYSTEM_APP_INDEX_ERROR)
        {
            net_printf("%s() %d\n", __FUNCTION__, __LINE__);
            return SP_ERR_FAILURE;
        }
        if (
            (u32GuiObjID[u8FilteredObj] == NET_GUIOBJ_HOMEPAGE
            || u32GuiObjID[u8FilteredObj] == APP_GUIOBJ_MUTE
            || u32GuiObjID[u8FilteredObj] == NET_GUIOBJ_POPMSG
            )
            && (!bIsCleanAll)
            )
        {
            continue;
        }
        u8FilteredObj++;
    }
     for (i = u8FilteredObj - 1; i >= 0; i--)
    {
    	u32CloseGuiObjID[u8FilteredObj - i - 1] = u32GuiObjID[i];
		if(u32GuiObjID[i] == APP_GUIOBJ_MUTE)
		{
			SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_NETWORK,
				APP_GUIOBJ_MUTE, APP_INTRA_EVENT_HIDE_MUTE, 0);
		}
    }
    SYSAPP_GOBJ_DestroyPartialGUIObjects(SYS_APP_NETWORK, u32CloseGuiObjID, u8FilteredObj);
    return SP_SUCCESS;
}

SysAppInstDef stNetwork_Inst =
{
    SYS_APP_NETWORK,
    Network_App_OnCreate,
    Network_App_OnDestroy,
    Network_App_OnRun,
    Network_App_OnTerminate,
    Network_App_OnTimerUpdate,
    Network_App_OnEvent,

	SYSTEM_IDLE, //system state.
	NETWORK_GUI_Obj_List,    //GUI object table
	NET_GUIOBJ_MAX,  //GUI object table size

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

static bool g_bOpenHomeMenuAfterCloseNetMenu = FALSE;

static PopmsgParam_t stPopupWaitingList[Network_APP_POP_MSG_MAX-Network_APP_POP_MSG_NONE];
static UINT32 g_u32OldPopup = Network_APP_POP_MSG_NONE;
static UINT32 g_dCurPopup = Network_APP_POP_MSG_NONE;
static UINT32 g_u32PopupWaitingList = 0;

INT32 Network_App_SchedulePopup(PopmsgParam_t Popup)
{
    UINT32 u32CurPopup = Network_APP_POP_MSG_NONE;
    UINT8 bTimeoutFlag = 0;

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

    if (u32CurPopup > Network_APP_POP_MSG_NONE)
    {
        if (bTimeoutFlag == 0)
        {
            g_u32PopupWaitingList |= 1 << (u32CurPopup - Network_APP_POP_MSG_NONE);
            stPopupWaitingList[u32CurPopup-Network_APP_POP_MSG_NONE] = Popup;
        }
        if (u32CurPopup > g_u32OldPopup)
        {
            g_u32OldPopup = u32CurPopup;
            if (APP_MenuMgr_Exist_Main_Menu()
                || SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, APP_GUIOBJ_SOURCE)
				|| SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, APP_GUIOBJ_SOURCE_CEC)
               )
            {
                g_u32OldPopup = Network_APP_POP_MSG_NONE;
                g_dCurPopup = u32CurPopup;
                return 0;
            }
            if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, NET_GUIOBJ_POPMSG))
            {
                SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_NETWORK, NET_GUIOBJ_POPMSG);
            }
            APP_MenuMgr_SetMsgPopup(TRUE);
            SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_NETWORK, NET_GUIOBJ_POPMSG, (UINT32)&Popup);
        }
    }
    else
    {
        if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, NET_GUIOBJ_POPMSG))
        {
            SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_NETWORK, NET_GUIOBJ_POPMSG);
        }
        APP_MenuMgr_SetMsgPopup(TRUE);
        SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_NETWORK, NET_GUIOBJ_POPMSG, (UINT32)&Popup);
    }
    g_dCurPopup = u32CurPopup;

    return 1;
}

INT32 Network_App_ClosePopup(UINT32 u32ClosePopup, UINT32 dMessage)
{
    UINT32 dCheckFlag;

    APP_MenuMgr_SetMsgPopup(FALSE);
    if (u32ClosePopup > Network_APP_POP_MSG_NONE)
    {
        if (u32ClosePopup == g_u32OldPopup)
        {
            if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, NET_GUIOBJ_POPMSG))
            {
                SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_NETWORK, NET_GUIOBJ_POPMSG);
            }
        }

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

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

        if (u32ClosePopup == g_u32OldPopup)
        {
            g_u32OldPopup = Network_APP_POP_MSG_NONE;
            g_dCurPopup = Network_APP_POP_MSG_NONE;
            for (dCheckFlag = Network_APP_POP_MSG_MAX - 1;
                 dCheckFlag > Network_APP_POP_MSG_NONE; dCheckFlag--)
            {
                if (g_u32PopupWaitingList & (1 << (dCheckFlag - Network_APP_POP_MSG_NONE)))
                {
                    Network_App_SchedulePopup(stPopupWaitingList[
                             	dCheckFlag-Network_APP_POP_MSG_NONE]);
                    break;
                }
            }
        }
    }
    else
    {
        if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, NET_GUIOBJ_POPMSG))
        {
            SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_NETWORK, NET_GUIOBJ_POPMSG);
        }

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

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

        g_dCurPopup = Network_APP_POP_MSG_NONE;

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

        for (dCheckFlag = Network_APP_POP_MSG_MAX - 1; dCheckFlag > Network_APP_POP_MSG_NONE; dCheckFlag--)
        {
            if (g_u32PopupWaitingList & (1 << (dCheckFlag - Network_APP_POP_MSG_NONE)))
            {
                Network_App_SchedulePopup(stPopupWaitingList[
                                         dCheckFlag-Network_APP_POP_MSG_NONE]);
                break;
            }
        }
    }
    return 1;
}

/*****************************************************************************
** FUNCTION : Network_App_IsPopupExist
**
** DESCRIPTION :
**				Judge popmsg is exist
**
** PARAMETERS :
**				u32TargetPopup  -  popmsg type
**
** RETURN VALUES:
**				TRUE  -  exist
**				FALSE  -  not exist
*****************************************************************************/
UINT8 Network_App_IsPopupExist(UINT32 u32TargetPopup)
{
	if (u32TargetPopup == g_u32OldPopup)
	{
		return TRUE;
	}
	else
	{
		if((u32TargetPopup > Network_APP_POP_MSG_NONE)
			&& (g_u32PopupWaitingList & (1 << (u32TargetPopup - Network_APP_POP_MSG_NONE))))
		{
			return TRUE;
		}
		else
		{
			return FALSE;
		}
	}
}
static void Network_App_ShowPopup(Network_AppPopMsgType_t ePopType)
{
    PopmsgParam_t stPopup;

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

    switch (ePopType)
    {
   case Network_APP_POP_MSG_FLIP:
		stPopup.eType = POPMSG_TYPE_CONFIRM;
		stPopup.u16Exitkeys = POPMSG_EXIT_EXIT | POPMSG_EXIT_RECALL;
		stPopup.u16ReturnType = GUI_OBJECT_POST_EVENT | GUI_OBJECT_EVENT_BYPASS;
		stPopup.extend.stConfirm.eConfirmType = POPMSG_CONFIRM_FLIP;
		stPopup.extend.stConfirm.u8Default = POPMSG_YES;
		break;
#ifdef CONFIG_SUPPORT_MIRACAST
	case Network_APP_POP_MSG_CONNECTING:
		stPopup.eType = POPMSG_TYPE_PROMPT;
		stPopup.u16Exitkeys =  POPMSG_EXIT_KEY_NONE;
		stPopup.u16ReturnType = GUI_OBJECT_POST_EVENT | GUI_OBJECT_EVENT_BYPASS;
		stPopup.extend.stPrompt.ePromptType = POPMSG_PROMPT_WFD_CONNECTING;
		stPopup.extend.stPrompt.iTimeout = 3;
		break;

	case Network_APP_POP_MSG_EXIT:
		stPopup.eType = POPMSG_TYPE_CONFIRM;
		stPopup.u16Exitkeys =  POPMSG_EXIT_KEY_NONE;
		stPopup.u16ReturnType = GUI_OBJECT_POST_EVENT | GUI_OBJECT_EVENT_BYPASS;
		stPopup.extend.stConfirm.eConfirmType = POPMSG_PROMPT_WFD_EXIT;
		stPopup.extend.stConfirm.u8Default = POPMSG_NO;
		break;

	case Network_APP_POP_MSG_NETWORK_ERROR:
		stPopup.eType = POPMSG_TYPE_PROMPT;
		stPopup.u16Exitkeys =  POPMSG_EXIT_KEY_NONE;
		stPopup.u16ReturnType = GUI_OBJECT_POST_EVENT | GUI_OBJECT_EVENT_BYPASS;
		stPopup.extend.stPrompt.ePromptType = POPMSG_PROMPT_WFD_NETWORK_ERROR;
		stPopup.extend.stPrompt.iTimeout = 3;
		break;
#endif	
#ifdef CONFIG_SUPPORT_DLNA
	case Network_APP_POP_MSG_DLNA_MSG:
		stPopup.eType = POPMSG_TYPE_PROMPT;
		stPopup.u16Exitkeys =  POPMSG_EXIT_KEY_NONE;
		stPopup.u16ReturnType = GUI_OBJECT_POST_EVENT | GUI_OBJECT_EVENT_BYPASS;
		stPopup.extend.stPrompt.ePromptType = POPMSG_PROMPT_DLNA_MESSAGE;
		break;
#endif
#ifdef CONFIG_SUPPORT_NET_OTA
	case Network_APP_POP_ERASE_WHOLE_FLASH_OTA:
		stPopup.eType = POPMSG_TYPE_CONFIRM;
		stPopup.u16Exitkeys = POPMSG_EXIT_EXIT | POPMSG_EXIT_RECALL;
		stPopup.u16ReturnType = GUI_OBJECT_POST_EVENT | GUI_OBJECT_EVENT_BYPASS;
		stPopup.extend.stConfirm.eConfirmType = POPMSG_CONFIRM_OTA;
		stPopup.extend.stConfirm.u8Default = POPMSG_NO;
		break;
	case Network_APP_POP_FTP_FILE_DOWNLOAD_WAITING:
		stPopup.eType = POPMSG_TYPE_PROMPT;
		stPopup.u16ReturnType = GUI_OBJECT_NO_POST_ACTION ;
		stPopup.extend.stPrompt.iTimeout = 0;
		stPopup.extend.stPrompt.ePromptType = POPMSG_FTP_FILE_DOWNLOAD_WAITING;
		break;
#endif
	case Network_APP_POP_MSG_NOT_SUPPORT:
		stPopup.eType = POPMSG_TYPE_PROMPT;
		stPopup.u16Exitkeys =  POPMSG_EXIT_KEY_NONE;
		stPopup.u16ReturnType = GUI_OBJECT_POST_EVENT | GUI_OBJECT_EVENT_BYPASS;
		stPopup.extend.stPrompt.ePromptType = POPMSG_PROMPT_UNSUPPORT_FILE;
		stPopup.extend.stPrompt.iTimeout = 2;
		break;
        default:
            return;
    }

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

    Network_App_SchedulePopup(stPopup);
}

#ifdef CONFIG_SUPPORT_MIRACAST
//extern INT32 _MainApp_IsWFDSysAppRunning(void);
INT32 WFD_App_CallbackFunc(WFD_CallbackType_e eCallbackType, UINT32 dParam)
{
        UINT32 dMsgType = CBK_EVENT_MAX;

        net_printf("~~~~~~~~eCallbackType is [%d] ~~~~~dParam is [%d]\n", eCallbackType, dParam);

        switch (eCallbackType)
        {

                case WFD_CBK_SOURCE_KNOCK:
			{
				#if 0
				int sdRet = SYSTEM_APP_SUCCESFUL;
				sdRet = _MainApp_IsWFDSysAppRunning();
				printf("_MainApp_IsWFDSysAppRunning sdRet[%d]",sdRet);
				if(sdRet == 0)
				{
					return SYSTEM_APP_ONRUN_FAILED;
				}
				else if(sdRet == 1)
				{
					MAINAPP_SendGlobalEvent(CBK_EVENT_WFD_SOURCE_KNOCK,dParam);
					return SYSTEM_APP_SUCCESFUL;
				}
				else if(sdRet == 2)
				{
	                        	dMsgType = CBK_EVENT_WFD_SOURCE_KNOCK;
				}
				#endif
				dMsgType = CBK_EVENT_WFD_SOURCE_KNOCK;
			}
                        break;
		case WFD_CBK_LINK_SUCCESS:
			dMsgType = CBK_EVENT_WFD_LINK_SUCCESS;
			break;
		case WFD_CBK_LINK_SUCCESS_NO_VIDEO:
			dMsgType = CBK_EVENT_WFD_LINK_SUCCESS_NO_VIDEO;
			break;			
		case WFD_CBK_LINK_DISCONNECTED:
			dMsgType = CBK_EVENT_WFD_LINK_DISCONNECTED;
			break;
		case WFD_CBK_SOURCE_SOURCE_TEARDOWN:
			dMsgType = CBK_EVENT_WFD_SOURCE_TEARDOWN;
			break;
                default:
                        break;
        }
	SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_NETWORK, dMsgType, dParam);
        //SYSAPP_IF_SendGlobalEvent(&stWFDAppInst, dMsgType, dParam);
        return SYSTEM_APP_SUCCESFUL;
}
#endif

#if defined (CONFIG_SUPPORT_DLNA) ||defined (CONFIG_SUPPORT_NET_PLAY_RTSP) || defined(CONFIG_SUPPORT_NET_PLAY_HTTP)
BOOL SysApp_Network_AL_CallBackFuc(AL_NET_PLAYER_Event_t Event)
{
    net_printf("\n\n\n\n------only test ----callback message from al middleware\n");
    net_printf("[%s] 0x%x\n\n\n", __FUNCTION__, Event);
    switch (Event)
    {
    	case NET_PLAYER_AV_EVENT_INITOK:
		SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_NETWORK, (NET_GLOBAL_EVENT_MEDIA_INITOK|PASS_TO_SYSAPP), 0);
		break;
	case NET_PLAYER_AV_EVENT_INIT_FAILED:
		SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_NETWORK, (NET_GLOBAL_EVENT_MEDIA_INIT_FAIL|PASS_TO_SYSAPP), 0);
		break;
	case NET_PLAYER_AV_EVENT_DECODE_START:
		SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_NETWORK, (NET_GLOBAL_EVENT_MEDIA_DECODE_START|PASS_TO_SYSAPP), 0);
		break;
	case NET_PLAYER_AV_EVENT_PLAY_DONE:
		SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_NETWORK, (NET_GLOBAL_EVENT_MEDIA_PLAY_DONE|PASS_TO_SYSAPP), 0);
		break;
	case NET_PLAYER_PIC_EVENT_DECODE_START:
		SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_NETWORK, (NET_GLOBAL_EVENT_MEDIA_PIC_DECODE_START|PASS_TO_SYSAPP), 0);
		break;
	case NET_PLAYER_PIC_EVENT_DECODE_FINISH:
		SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_NETWORK, (NET_GLOBAL_EVENT_MEDIA_PIC_DECODE_FINISH|PASS_TO_SYSAPP), 0);
		break;
	case NET_PLAYER_PIC_EVENT_DECODE_ERROR:
		SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_NETWORK, (NET_GLOBAL_EVENT_MEDIA_PIC_DECODE_ERROR|PASS_TO_SYSAPP), 0);
		break;
        default:
            net_printf("[%s] Unknown message type received.\n", __FUNCTION__);
            break;
    }
    return TRUE;
}
#endif
#ifdef CONFIG_SUPPORT_DLNA
INT32 Dlna_App_CallbackFunc(DLNA_MW_CallbackType_e eCallbackType, UINT32 dParam)
{
    UINT32 dMsgType = CBK_EVENT_DLNA_MW_EVENT_MAX;
    printf("~~~~~~~~eCallbackType is [%d] ~~~~~dParam is [%d]\n", eCallbackType, dParam);

    switch (eCallbackType)
    {
            case DLNA_MW_CBK_DMS_CONTENT_LIST_ERROR:
                    dMsgType = CBK_EVENT_DLNA_CONTENT_LIST_ERROR;
                    break;

            case DLNA_MW_CBK_DMS_CONTENT_LIST_DONE:
                    dMsgType = CBK_EVENT_DLNA_CONTENT_LIST_DONE;
                    break;

            case DLNA_MW_CBK_DMS_ADD:
                    dMsgType = CBK_EVENT_DLNA_ADD_DMS_DONE;
                    break;

            case DLNA_MW_CBK_DMS_DELETE:
                    dMsgType = CBK_EVENT_DLNA_DELETE_DMS_DONE;
                    break;

            case DLNA_MW_CBK_DRAW_LARGE_PIC_DONE:
                    dMsgType = CBK_EVENT_DLNA_LARGE_PIC_DONE;
                    break;

            case DLNA_MW_CBK_DRAW_LARGE_PIC_ERROR:
                    dMsgType = CBK_EVENT_DLNA_LARGE_PIC_ERROR;
                    break;

            case DLNA_MW_CBK_DRAW_THUMBNAIL_DONE:
                    dMsgType = CBK_EVENT_DLNA_THUMBNAIL_DONE;
                    break;

            case DLNA_MW_CBK_DRAW_THUMBNAIL_ERROR:
                    dMsgType = CBK_EVENT_DLNA_THUMBNAIL_ERROR;
                    break;

            case DLNA_WM_CBK_DATA_DONE:
                    dMsgType = CBK_EVENT_DLNA_SMALL_PIC_DONE;
                    break;

            case DLNA_WM_CBK_DATA_FAIL:
                    dMsgType = CBK_EVENT_DLNA_SMALL_PIC_FAIL;
                    break;

            case DLNA_MW_CBK_PLAY_FINISH:
                    dMsgType = CBK_EVENT_VOD_CALLBACK_PLAYBACK_FINISH;
                    break;

            case DLNA_MW_CBK_CACHE_START:
                    dMsgType = CBK_EVENT_DLNA_CACHE_START;
                    break;

            case DLNA_MW_CBK_STARTUP_FAIL:
                    dMsgType = CBK_EVENT_VOD_CALLBACK_ADD_TASK_FAIL;
                    break;

            case DLNA_MW_CBK_CACHE_STOP:
                    dMsgType = CBK_EVENT_DLNA_CACHE_STOP;
                    break;

            case DLNA_MW_CBK_SHOW_PLAY:
	
			{
                     dMsgType = CBK_EVENT_SHOW_PLAY_DMR;
					 printf("CBK_EVENT_SHOW_PLAY_DMR=%x\n",CBK_EVENT_SHOW_PLAY_DMR);
			}
                 break;
            case DLNA_MW_CBK_SHOW_STOP:
                    dMsgType = CBK_EVENT_SHOW_STOP_DMR;
                    break;

            case DLNA_MW_CBK_SHOW_STOP_FAIL:
                    dMsgType = CBK_EVENT_VOD_CALLBACK_PLAYBACK_STOP_FAIL;
                    break;

            case DLNA_MW_CBK_FAIL:
                    dMsgType = CBK_EVENT_VOD_CALLBACK_PLAYBACK_NEXT_FAIL;
                    break;

            case DLNA_MW_CBK_SHOW_PAUSE:
                    dMsgType = CBK_EVENT_SHOW_PAUSE_DMR;
                    break;

            case DLNA_MW_CBK_SHOW_FF:
                    dMsgType = CBK_EVENT_VOD_CALLBACK_PLAYBACK_FF_DONE;
                    break;

            case  DLNA_MW_CBK_SHOW_FR:
                    dMsgType = CBK_EVENT_VOD_CALLBACK_PLAYBACK_FB_DONE;
                    break;
			case  DLNA_MW_CBK_SHOW_FR_FILE_BEGIN:
					dMsgType = CBK_EVENT_FASTBACK_TO_END;
					break;

            case DLNA_MW_CBK_SHOW_NEXT:
                    dMsgType = CBK_EVENT_SHOW_NEXT_DMR;
                    break;

            case DLNA_MW_CBK_SHOW_PREV:
                    dMsgType = CBK_EVENT_SHOW_PREV_DMR;
                    break;

            case DLNA_MW_CBK_SET_MUTE:
                    dMsgType = CBK_EVENT_SET_MUTE;
                    break;

            case DLNA_MW_CBK_GET_MUTE:
            {
                    UINT32 *pdMute = (UINT32*)dParam;
                    //dMsgType = CBK_EVENT_GET_MUTE;
                    AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_USERINFO, 0,
                              sizeof(APP_SETTING_UserInfo_t), &(g_stUserInfoData));
                    *pdMute = g_stUserInfoData.Mute;	
    				return SYSTEM_APP_SUCCESFUL;
            }
            case DLNA_MW_CBK_SET_VOLUME:
                    dMsgType = CBK_EVENT_SET_VOLUME;
                    break;

            case DLNA_MW_CBK_GET_VOLUME:
                    //dMsgType = CBK_EVENT_GET_VOLUME;
                    break;

            case DLNA_MW_CBK_PLAY_DONE:
                    dMsgType = CBK_EVENT_VIDEO_PLAY_DONE;
                    break;

            case DLNA_MW_CBK_STARTUP_DONE:
                    dMsgType = CBK_EVENT_STARTUP_DONE;
                    break;

            case DLNA_MW_CBK_PLAY_START:
                    dMsgType = CBK_EVENT_BPIC_STATR_PLAY;//add for mantis 0160705
                    break;

            case DLNA_MW_CBK_SHOW_FF_FAIL:
                    dMsgType = CBK_EVENT_VOD_CALLBACK_PLAYBACK_FF_FAIL;
                    break;

            case DLNA_MW_CBK_SHOW_FR_FAIL:
                    dMsgType = CBK_EVENT_VOD_CALLBACK_PLAYBACK_FB_FAIL;
                    break;
			case DLNA_MW_CBK_CHANGE2_NORMAL_PLAY_DONE:
				 dMsgType = CBK_EVENT_VOD_CALLBACK_PLAYBACK_CHANGE2_NORMAL_PLAY_DONE;
				 break;
			case DLNA_MW_CBK_PE_NO_VIDEO_TRACK:
					dMsgType = CBK_EVENT_PE_NO_VIDEO_TRACK;
				break;
			case DLNA_MW_CBK_PE_NOT_SUPPORT_AUDIO:
				dMsgType = CBK_EVENT_PE_NOT_SUPPORT_AUDIO;
				break;
				
            default:
                    break;
    }

    SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_NETWORK, dMsgType|PASS_TO_SYSAPP, dParam);
    return SYSTEM_APP_SUCCESFUL;
}


void* DLNAInitTask(void *arg)
{
	Al_IP_t ip = {0};
	net_printf("Enter DLNAInitTask\n");
	while(gDlnaInitThreadRunning)
	{
		if( Al_Network_Ctrl_GetIP(&ip) == AL_SUCCESS)
			break;
		sleep(1);
	}
	if(!gDlnaInitThreadRunning) // thread is canceled
	{
		net_printf("Exit DLNAInitTask - canceled\n");
		pthread_exit(NULL);
	}


	if (gDlnaSema == NULL)
	{
		GL_Status_t dRetVal;
		dRetVal = GL_SemaphoreCreate("DLNA Quit Semaphore", 1, 1, &gDlnaSema);
		
		if (dRetVal != GL_SUCCESS)
		{
			net_printf("DLNA Quit Semaphore create fail!!");
		}
	}
		
	DLNA_MWInitPara stInitData;
	memset(&stInitData, 0, sizeof(DLNA_MWInitPara));
	stInitData.semaQuit = gDlnaSema;
	stInitData.eMode = DLNA_DMR;
	if (DLNA_MW_IF_Initialize(&stInitData, Dlna_App_CallbackFunc) != DLNA_MW_IF_SUCCESSFUL)
	{
		net_printf("Init middleware fail\n");
		pthread_exit(NULL);
	}
	if (DLNA_MW_IF_NetPlayerInitialize() != DLNA_MW_IF_SUCCESSFUL)
	{
		net_printf("Init play fail\n");
		DLNA_MW_IF_Finalize();
		if(gDlnaSema != NULL)
		{
			GL_SemaphoreDelete(gDlnaSema);
			gDlnaSema = NULL;
		}
		pthread_exit(NULL);
	}
	gDlnaInited = true;
	net_printf("Exit DLNAInitTask\n");
	pthread_exit(NULL);
}

INT32 DLNAInit(void)
{
	net_printf("Enter DLNAInit\n");
	if(!gDlnaInitThreadValid)
	{
		gDlnaInitThreadRunning = true;
		gDlnaInitThreadValid = (pthread_create(&gDlnaInitThread, NULL, DLNAInitTask, NULL) == 0);
		gDlnaInitThreadRunning = gDlnaInitThreadValid;
	}
	else
	{
		net_printf("DLNA is being initialized.");
	}
	net_printf("Exit DLNAInit\n");
	return 0;
}

void DLNA_EXIT(void)
{
	net_printf("Enter DLNA_EXIT - 1\n");
	if(gDlnaInitThreadValid)
	{
		gDlnaInitThreadRunning = false;
		pthread_join(gDlnaInitThread, NULL);
		gDlnaInitThreadValid = false;
	}

	net_printf("Enter DLNA_EXIT - 2\n");
	if(gDlnaInited)
	{
		DLNA_MW_IF_NetPlayerFinalize();
		DLNA_MW_IF_Finalize();
		if(gDlnaSema != NULL)
		{
			GL_SemaphoreDelete(gDlnaSema);
			gDlnaSema = NULL;
		}
	}
	gDlnaInited = false;
	net_printf("Exit DLNA_EXIT\n");
}

void MonitorIPChange(void)
{
	static Al_IP_t old_ip = {0};
	Al_IP_t ip = {0};
	if( Al_Network_Ctrl_GetIP(&ip) == AL_SUCCESS 
		&&  memcmp(&ip, &old_ip, sizeof(Al_IP_t)) != 0)
	{
		net_printf("Detect IP changed from [%u.%u.%u.%u] to [%u.%u.%u.%u]\n", old_ip.IPA, old_ip.IPB, old_ip.IPC, old_ip.IPD, ip.IPA, ip.IPB, ip.IPC, ip.IPD);
		memcpy(&old_ip, &ip, sizeof(Al_IP_t));
		if(gDlnaInited)
		{
			net_printf("restart DMR now\n");
			DLNA_MW_IF_ReStartDMR();
		}
	}
	else if(Al_Network_Ctrl_GetIP(&ip) != AL_SUCCESS)
	{
	#ifdef CONFIG_SUPPORT_WIFI
		if(MID_NWSI_WLAN_GetAPState() == E_MID_NWSI_WLAN_CONNECT_STATE_ON)
		{
			Al_APPW_t *pAPPW = NULL;
			pAPPW = &g_stSetupData.WiFiSetting.WiFiPassword.APPW[0];
			if(Al_Network_Ctrl_ConnectAP(g_stSetupData.WiFiSetting.ConnectAPData, pAPPW->PWlen, pAPPW->PassWord) == AL_SUCCESS)
			{
				Al_Network_Ctrl_SetDhcpStatic(e_AL_Network_Mode_Wireless, g_stSetupData.EthernetConnectMode, &g_stSetupData.IPSetting);
			}
			MID_NWSI_WLAN_WiFiEnable(TRUE);
		}
	#endif
	}
}

#endif

#ifdef CONFIG_SUPPORT_NEW_AIRPLAY
bool SysApp_Airplay_CallBackFuc(Airplay_Event_t Event, int param)
{
	net_printf("\n\n\n\n------only test ----callback message from airplay middleware\n");
	net_printf("[%s] 0x%x\n\n\n", __FUNCTION__, Event);
	switch (Event)
	{
	case AIRPLAY_AV_EVENT_INITOK:
		SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_NETWORK, (NET_GLOBAL_EVENT_MEDIA_INITOK|PASS_TO_SYSAPP), 0);
		break;
	case AIRPLAY_AV_EVENT_PLAY_DONE:
		SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_NETWORK, (NET_GLOBAL_EVENT_MEDIA_PLAY_DONE|PASS_TO_SYSAPP), 0);
		break;
	case AIRPLAY_AV_EVENT_NOT_HTTP:
		if(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, NET_GUIOBJ_AIRPLAY_NEW))
		{
			SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_NETWORK, NET_GUIOBJ_AIRPLAY_NEW, CBK_EVENT_AIRPLAY_MW_NOT_HTTP, 0);
		}
		break;
	case AIRPLAY_AV_EVENT_SET_METADATA:
	{
		Airplay_Audio_MetaData_t metadata;
		if(Airplay_GetAudioMetadata(&metadata) == AIRPLAY_SUCCESS)
		{
			net_printf("\n\n------- Audio metadata -------\n");
			net_printf("Album  = [%.*s]\n", metadata.songAlbum.size, metadata.songAlbum.data);
			net_printf("Year = [%u]\n", metadata.songYear);
			net_printf("AlbumArtist = [%.*s]\n", metadata.songArtist.size, metadata.songArtist.data);
			net_printf("Artist = [%.*s]\n", metadata.songArtist.size, metadata.songArtist.data);
			net_printf("Name = [%.*s]\n", metadata.songName.size, metadata.songName.data);
			net_printf("Composer = [%.*s]\n", metadata.songComposer.size, metadata.songComposer.data);
			net_printf("Genre = [%.*s]\n", metadata.songGenre.size, metadata.songGenre.data);
			net_printf("TrackCount = [%u]\n", metadata.songTrackCount);
			net_printf("TotalTime = [%u]\n", metadata.totalTime);
			net_printf("\n-------------------------------\n");
		}
		break;
	}
	case AIRPLAY_AV_EVENT_SET_COVERART:
	{
		Airplay_Audio_CoverArt_t cover;
		if(Airplay_GetAudioCoverArt(&cover) == AIRPLAY_SUCCESS)
		{
			net_printf("Get cover art, size = %u, data = %p\n", cover.size, cover.data);
			// TODO: decode cover art here
			Airplay_FreeAudioCoverArt(&cover);
		}
		break;
	}
	case AIRPLAY_AV_EVENT_SET_VOLUME:
		g_stVariationalData.Volume = param >= ADJUST_MAX_VALUE ? ADJUST_MAX_VALUE : param;
		APP_Audio_SetVolume((UINT32)g_stVariationalData.Volume);
		AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_VARIATIONAL,
						 ITEM_OFFSET(APP_SETTING_Variational_t, Volume),
						 sizeof(g_stVariationalData.Volume), &(g_stVariationalData.Volume));
		if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, APP_GUIOBJ_ADJUST))
		{
			SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_NETWORK, APP_GUIOBJ_ADJUST);
		}
		SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_NETWORK, APP_GUIOBJ_ADJUST, ADJUST_VOLUME);
		break;
	default:
		net_printf("[%s] Unknown message type received.\n", __FUNCTION__);
		break;
	}
	return TRUE;
}
#endif


void SysApp_NET_DestroyAppointedGUI(void)
{
    if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, NET_GUIOBJ_POPMSG))
    {
        SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_NETWORK, NET_GUIOBJ_POPMSG);
    }
#ifdef SUPPORT_FACTORY_AUTO_TEST_MODE2
    if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, APP_GUIOBJ_FAC_AUTOTEST))
    {
        SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_NETWORK, APP_GUIOBJ_FAC_AUTOTEST);
    }
#endif
    if (APP_MenuMgr_Exist_Main_Menu())
    {
        APP_MenuMgr_Exit_Main_Menu();
    }

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

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

    if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, APP_GUIOBJ_SOURCE_CEC))
    {
        SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_NETWORK, APP_GUIOBJ_SOURCE_CEC);
    }

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

    if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, APP_GUIOBJ_ADJUST))
    {
        SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_NETWORK, APP_GUIOBJ_ADJUST);
    }

    if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, APP_GUIOBJ_AMPLIFIERVOLUME))
    {
        SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_NETWORK, APP_GUIOBJ_AMPLIFIERVOLUME);
    }

    if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, APP_GUIOBJ_SLEEP_INFO))
    {
        SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_NETWORK, APP_GUIOBJ_SLEEP_INFO);
    }
	if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, NET_GUIOBJ_NULL))
	{
	    SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_NETWORK, NET_GUIOBJ_NULL);
	}
}

static int Network_App_OnCreate(void** ppPrivateData)
{
	net_printf("OnInitialize function is called.\n");

    stNetwork_Inst.bAppState = SYSTEM_IDLE;

#ifdef CONFIG_SUPPORT_MIRACAST
	WFD_Init_AP_CBKFunc((WFD_CBK_Func) WFD_App_CallbackFunc);
#endif
#if defined (CONFIG_SUPPORT_DLNA) ||defined (CONFIG_SUPPORT_NET_PLAY_RTSP) || defined(CONFIG_SUPPORT_NET_PLAY_HTTP)
	DLNA_MediaCtrl_NET_Player_RegisterMsgRouteway(SysApp_Network_AL_CallBackFuc);
#endif
#ifdef CONFIG_SUPPORT_NEW_AIRPLAY
	Airplay_RegisterCBKFunc(SysApp_Airplay_CallBackFuc);
#endif

	return NET_APP_SUCCESS;
}

static int Network_App_OnDestroy(void** ppPrivateData)
{
	net_printf("OnDestroy() is called.\n");

	return NET_APP_SUCCESS;
}
static int Network_App_OnRun(void* pPrivateData, UINT32 dParam)
{
	net_printf("Network_App_OnRun() is called.\n");
	int dRet=NET_APP_SUCCESS;

	APP_GUIOBJ_PopMs_SetCloseFun(Network_App_ClosePopup);
    APP_GuiMgr_Set_Menu() ;
	APP_GuiMgr_SwitchShareMenu(SYS_APP_NETWORK);
	
    if (SP_SUCCESS != APP_GUIOBJ_Source_SetMidSource(NULL))
	{
	   printf("[%s] %d, Mid display setting source fail\n", __FUNCTION__, __LINE__);
	   APP_GUIOBJ_Source_SetSourceTransState(FALSE);
	   g_u8SourceTrastTimer = 0;
	   return SP_ERR_FAILURE;
	}
	NET_Homepage_SetSource(ITEM_HOMEPAGE_MAX);
    APP_GUIOBJ_Source_SetSourceTransState(FALSE);
	g_bOpenHomeMenuAfterCloseNetMenu = TRUE;

	SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_NETWORK,
                   	NET_GLOBAL_EVENT_ON_RUN | PASS_TO_SYSAPP, TRUE);

	net_printf("Network_App_OnRun() is called.\n");
	return dRet;
}

static int Network_App_OnTerminate(void* pPrivateData, UINT32 dParam)
{
	net_printf("App_OnTerminate() is called.\n");
	int dRet = NET_APP_SUCCESS;
#if defined (CONFIG_SUPPORT_NET_PLAY_RTSP) || defined(CONFIG_SUPPORT_NET_PLAY_HTTP)
	NetCtrl_Finalize();
#endif
#ifdef CONFIG_SUPPORT_MIRACAST
	if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, NET_GUIOBJ_WFD_AUDIO_PLAYBACK))
	{
		SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_NETWORK, NET_GUIOBJ_WFD_AUDIO_PLAYBACK);
	}
#endif
	NET_DestroyPartialObjects(TRUE);
	SYSAPP_GOBJ_FinalizeGUIObject(SYS_APP_NETWORK);
	
    stNetwork_Inst.bAppState = SYSTEM_IDLE;

	return dRet;
}

static int Network_App_OnTimerUpdate(void* pPrivateData)
{
	int dRet = NET_APP_SUCCESS;
	
	#ifdef SUPPORT_CEC_TV
		/*Delay the mute key sending to AMP*/
	if((0 <= g_u32Mutekeydelaytime) && (g_u32Mutekeydelaytime < MUTE_KEY_INTERVAL))
	{
		g_u32Mutekeydelaytime++;
		g_u32MuteIconHandle++;
	}
	#endif

#ifdef CONFIG_SUPPORT_MIRACAST_DLNA_INONE
	if(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, NET_GUIOBJ_MIRACAST_DLNA_PAGE))
		MonitorIPChange();
#else
#ifdef CONFIG_SUPPORT_DLNA
	if(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, NET_GUIOBJ_DLNA_PAGE))
		MonitorIPChange();
#endif
#endif

	return dRet;
}

int Network_App_OnGlobalEvent(void* pPrivateData, UINT32 dMessage, UINT32 dParam)
{
	net_printf("Network_App_OnGlobalEvent() is called.\n");

	int sdRet = NET_APP_SUCCESS;
	dMessage = (dMessage & ~PASS_TO_SYSAPP);

	#ifdef SUPPORT_CEC_TV
	if (CECTV_GetCECEnable() == CECTV_ENABLE)
	{
		//active source
		if(dMessage == UI_EVENT_TVRADIO)
		{
			CECTV_SendCmd(CECTV_SINGLE_ACT_CMD_CHGSRC_OUT_HDMI, SRC_OTHERS);
		}
		if(dMessage == UI_EVENT_MUTE)
		{
			if (CECTV_GetHDMISystemAudioMode()&& APP_Check_CEC_DEVICE_Status())
            {
				if(g_u32Mutekeydelaytime >= MUTE_KEY_INTERVAL)
				{
					cec_RemoteControlPassThrough(CECTV_KEY_MUTE);
					cec_RemoteControlPassThrough(CECTV_KEY_MUTE_RELEASE);
					g_u32Mutekeydelaytime = 0;
				}
            }
		}

		if(dMessage == UI_EVENT_VOL_UP)
		{
			if (CECTV_GetHDMISystemAudioMode() && APP_Check_CEC_DEVICE_Status())
            {
	            if (dParam & IR_EVENT_REPEAT_TYPE)
				{
					cec_RemoteControlPassThrough(CECTV_KEY_VOLUME_UP);
				}
				else if (dParam & IR_EVENT_REPEAT_END)
				{
					cec_RemoteControlPassThrough(CECTV_KEY_VOLUME_UP_RELEASE);
				}
				else
				{
					cec_RemoteControlPassThrough(CECTV_KEY_VOLUME_UP);
					cec_RemoteControlPassThrough(CECTV_KEY_VOLUME_UP_RELEASE);
				}
            }
		}
		if(dMessage == UI_EVENT_VOL_DN)
		{
			if (CECTV_GetHDMISystemAudioMode() && APP_Check_CEC_DEVICE_Status())
			{
				if (dParam & IR_EVENT_REPEAT_TYPE)
				{
					cec_RemoteControlPassThrough(CECTV_KEY_VOLUME_DOWN);
				}
				else if (dParam & IR_EVENT_REPEAT_END)
				{
					cec_RemoteControlPassThrough(CECTV_KEY_VOLUME_DOWN_RELEASE);
				}
				else
				{
					cec_RemoteControlPassThrough(CECTV_KEY_VOLUME_DOWN);
					cec_RemoteControlPassThrough(CECTV_KEY_VOLUME_DOWN_RELEASE);
				}
			}
		}
	}
#endif

	switch (dMessage)
	{
		case NET_GLOBAL_EVENT_ON_RUN:
			if(!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, NET_GUIOBJ_HOMEPAGE))
			{
				SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_NETWORK, NET_GUIOBJ_HOMEPAGE, 0);
			}

			if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, APP_GUIOBJ_MUTE))
			{
				SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_NETWORK, APP_GUIOBJ_MUTE, 0);
			}
#ifdef CONFIG_SUPPORT_NET_PLAY_RTSP
			{
				NetCtrl_Initialize();
				_Play_RTSP_Stream();
			}
#elif defined(CONFIG_SUPPORT_NET_PLAY_HTTP)
			{
				NetCtrl_Initialize();
				_Play_HTTP_Stream();
			}
#endif
			break;
		case NET_GLOBAL_EVENT_OBJECT_CLOSE:
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, NET_GUIOBJ_NULL))
            {
                SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_NETWORK, NET_GUIOBJ_NULL);
            }
			break;
		case UI_EVENT_EXIT:
        case UI_EVENT_RETURN:
			printf("%s %d\n",__FUNCTION__,__LINE__);
			SysApp_NET_DestroyAppointedGUI();
			break;
		case UI_EVENT_RECALL:
			break;
		case UI_EVENT_FAC_BURNINGMODE:
			{
				SysApp_NET_DestroyAppointedGUI();
				SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_NETWORK, NET_GUIOBJ_NULL, 0);
				MID_TVFE_SetAutoPowerOn(AC_AUTO_POWERON_ON);
				APP_Factory_SetBurnIn_LEDTwinkle(TRUE);
			}
			break;
		case UI_EVENT_MENU:
#if defined (CONFIG_SUPPORT_MIRACAST_DLNA_INONE)
			if(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, NET_GUIOBJ_MIRACAST_DLNA_PAGE))
			{
				break;
			}
#else
#if defined (CONFIG_SUPPORT_MIRACAST)
			if(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, NET_GUIOBJ_MIRACAST_PAGE))
			{
				break;
			}
#endif
#if defined (CONFIG_SUPPORT_DLNA)
			if(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, NET_GUIOBJ_DLNA_PAGE))
			{
				break;
			}
#endif
#endif
			if (APP_MenuMgr_Exist_Main_Menu())
			{
				APP_MenuMgr_Exit_Main_Menu();
				SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_NETWORK, NET_GUIOBJ_NULL);
			}
			else if(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, APP_GUIOBJ_SOURCE))
			{
				SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_NETWORK, APP_GUIOBJ_SOURCE);
				SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_NETWORK, NET_GUIOBJ_NULL, 0);
				SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_NETWORK, APP_GUIOBJ_MAINMENU, 0);
			}
			else
			{
				SysApp_NET_DestroyAppointedGUI();
				SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_NETWORK, NET_GUIOBJ_NULL, 0);
				SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_NETWORK, APP_GUIOBJ_MAINMENU, 0);
			}			
			break;
		case UI_EVENT_FACTORY:
			if(APP_MenuMgr_Exist_Factory_Menu())
			{
				APP_MenuMgr_Exit_Factory_Menu();
			}
			else
			{
				if(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, APP_GUIOBJ_MAINMENU))
				{
					APP_MenuMgr_Exit_Main_Menu();
					SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_NETWORK, NET_GUIOBJ_NULL, 0);
					SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_NETWORK, APP_GUIOBJ_FM_FACTORYSETTING, FIRST_ENTER_FACTORY);
				}
			}
			break;
		case UI_EVENT_SOURCE:
#if defined (CONFIG_SUPPORT_MIRACAST_DLNA_INONE)
			if(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, NET_GUIOBJ_MIRACAST_DLNA_PAGE))
			{
				break;
			}
#else
#if defined (CONFIG_SUPPORT_MIRACAST)
			if(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, NET_GUIOBJ_MIRACAST_PAGE))
			{
				break;
			}
#endif
#if defined (CONFIG_SUPPORT_DLNA)
			if(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, NET_GUIOBJ_DLNA_PAGE))
			{
				break;
			}
#endif
#endif
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, APP_GUIOBJ_SOURCE))
			{
				SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_NETWORK, APP_GUIOBJ_SOURCE);
				SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_NETWORK, NET_GUIOBJ_NULL);
			}
			else
			{
				SysApp_NET_DestroyAppointedGUI();
				SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_NETWORK, NET_GUIOBJ_NULL, 0);
				SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_NETWORK, APP_GUIOBJ_SOURCE, 0);
			}
			break;
#ifdef CONFIG_MEDIA_ENABLE
			case UI_EVENT_SRC_USB:
#ifdef SUPPORT_CEC_TV
	if (CECTV_GetCECEnable()==CECTV_ENABLE)
	{
		CECTV_SendCmd(CECTV_SINGLE_ACT_CMD_CHGSRC_OUT_HDMI, SRC_OTHERS);
	}
#endif
			{
				if (SP_SUCCESS != APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_MEDIA))
				{
					net_printf("APP_GUIOBJ_Source_SetAppSource Fail!!!!!!!!!\n");
				}
			}
			break;
#endif
		case UI_EVENT_SND_MOD:
			#ifdef SUPPORT_CEC_TV
#ifdef SUPPORT_SMODE_UNMUTE
			AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_USERINFO, 0,
			sizeof(APP_SETTING_UserInfo_t), &(g_stUserInfoData));
			if(g_stUserInfoData.Mute)
			{
			   if (CECTV_GetHDMISystemAudioMode()&& APP_Check_CEC_DEVICE_Status())
		            {
					cec_RemoteControlPassThrough(CECTV_KEY_MUTE);
				    	cec_RemoteControlPassThrough(CECTV_KEY_MUTE_RELEASE);
		            }
			}
			_APP_GUIOBJ_Sound_SetMuteStatus();
#endif
#endif
		case UI_EVENT_SLEEP:
		case UI_EVENT_PIC_MOD:
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, APP_GUIOBJ_BANNER))
			{
			    SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_NETWORK, APP_GUIOBJ_BANNER);
			}

			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, APP_GUIOBJ_ADJUST))
			{
			    SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_NETWORK, APP_GUIOBJ_ADJUST);
			}

			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, APP_GUIOBJ_AMPLIFIERVOLUME))
			{
			    SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_NETWORK, APP_GUIOBJ_AMPLIFIERVOLUME);
			}
			SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_NETWORK,APP_GUIOBJ_BANNER, dMessage);
			break;
		case APP_GLOBAL_EVENT_FLIP:
			if (APP_MenuMgr_Exist_Factory_Menu())
			{
				APP_MenuMgr_Exit_Factory_Menu();
			}
			Network_App_ShowPopup(Network_APP_POP_MSG_FLIP);
			break;	
		case APP_GLOBAL_EVENT_POPMSG_YES:
			if (POPMSG_CONFIRM_FLIP == dParam)
            {
				g_stFactoryUserData.Function.PanelSetting.n_FlipIndex = Factory_GetFlipIndex();
				AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_FACTUSER,
				   ITEM_OFFSET(APP_SETTING_FactoryUser_t, Function.PanelSetting.n_FlipIndex), sizeof(g_stFactoryUserData.Function.PanelSetting.n_FlipIndex),
					&(g_stFactoryUserData.Function.PanelSetting.n_FlipIndex));
				AL_Setting_Store(APP_Data_UserSetting_Handle(), SYS_SET_ID_FACTUSER,
				   ITEM_OFFSET(APP_SETTING_FactoryUser_t, Function.PanelSetting.n_FlipIndex), sizeof(g_stFactoryUserData.Function.PanelSetting.n_FlipIndex));

				MID_TVFE_SetPanelInverse((BOOL)(g_stFactoryUserData.Function.PanelSetting.n_FlipIndex));
				GL_TaskSleep(2000);
				APP_Sysset_Reset_System();
            }
#ifdef CONFIG_SUPPORT_NET_OTA
			if (POPMSG_CONFIRM_OTA == dParam)
			{
				if (!SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, APP_GUIOBJ_SOFTWARE_UPGRADE))
				{
					Network_App_ShowPopup(Network_APP_POP_FTP_FILE_DOWNLOAD_WAITING);
					if(NET_OTA_DownloadUpdate() == NET_OTA_OK)
					{
						Network_App_ClosePopup(POPMSG_FTP_FILE_DOWNLOAD_WAITING,UI_EVENT_NULL);
					#if defined(CONFIG_SUPPORT_NET_OTA_FROM_USB)
						APP_SetUpdateSource(UPGRADE_NETWORK_FROM_USB);
					#elif defined(CONFIG_SUPPORT_NET_OTA_FROM_MEM)
						APP_SetUpdateSource(UPGRADE_NETWORK_FROM_MEM);
					#else
						#error No storage for NET OTA is selected.
					#endif
						SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_NETWORK, APP_GUIOBJ_SOFTWARE_UPGRADE, SOFTWARE_UPGRADE_FROM_NET_OTA);
						return GUI_OBJECT_POST_EVENT;
					}
					Network_App_ClosePopup(POPMSG_FTP_FILE_DOWNLOAD_WAITING,UI_EVENT_NULL);
				}
			}
#endif
			break;
		case APP_GLOBAL_EVENT_POPMSG_NO:
			if (dParam == POPMSG_CONFIRM_FLIP)
            {
                Network_App_ClosePopup(POPMSG_CONFIRM_FLIP, UI_EVENT_NULL);
                SysApp_NET_DestroyAppointedGUI();
            }
			#ifdef CONFIG_SUPPORT_MIRACAST
			else if (Network_App_IsPopupExist(Network_APP_POP_MSG_EXIT))
			{
				Network_App_ClosePopup(Network_APP_POP_MSG_EXIT, UI_EVENT_NULL);
			}
			#endif
			#ifdef CONFIG_SUPPORT_NET_OTA
			if (POPMSG_CONFIRM_OTA == dParam)
			{
				if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, NET_GUIOBJ_NULL))
				{
					SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_NETWORK, NET_GUIOBJ_NULL);
				}				
			}
			#endif
			break;	
#ifdef CONFIG_SUPPORT_MIRACAST
		/*case APP_GLOBAL_EVENT_POPMSG_YES:
			//MAINAPP_SendGlobalEvent(UI_EVENT_SETUP,0);
			break;
		case APP_GLOBAL_EVENT_POPMSG_NO:
			if (Network_App_IsPopupExist(Network_APP_POP_MSG_EXIT))
			{
				Network_App_ClosePopup(Network_APP_POP_MSG_EXIT, UI_EVENT_NULL);
			}
			break;*/
		case CBK_EVENT_WFD_LINK_SUCCESS:
			if (Network_App_IsPopupExist(Network_APP_POP_MSG_CONNECTING))
			{
				Network_App_ClosePopup(Network_APP_POP_MSG_CONNECTING, UI_EVENT_NULL);
			}
			if (Network_App_IsPopupExist(Network_APP_POP_MSG_EXIT))
			{
				Network_App_ClosePopup(Network_APP_POP_MSG_EXIT, UI_EVENT_NULL);
			}
			if (Network_App_IsPopupExist(Network_APP_POP_MSG_NETWORK_ERROR))
			{
				Network_App_ClosePopup(Network_APP_POP_MSG_NETWORK_ERROR, UI_EVENT_NULL);
			}
			break;
		case CBK_EVENT_WFD_LINK_SUCCESS_NO_VIDEO:
			if (Network_App_IsPopupExist(Network_APP_POP_MSG_CONNECTING))
			{
				Network_App_ClosePopup(Network_APP_POP_MSG_CONNECTING, UI_EVENT_NULL);
			}
			if (Network_App_IsPopupExist(Network_APP_POP_MSG_EXIT))
			{
				Network_App_ClosePopup(Network_APP_POP_MSG_EXIT, UI_EVENT_NULL);
			}
			if (Network_App_IsPopupExist(Network_APP_POP_MSG_NETWORK_ERROR))
			{
				Network_App_ClosePopup(Network_APP_POP_MSG_NETWORK_ERROR, UI_EVENT_NULL);
			}
			if (SYSTEM_APP_SUCCESS != SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_NETWORK, NET_GUIOBJ_WFD_AUDIO_PLAYBACK/*here may be audio/video/photo*/, 0))
			{
				net_printf("%s Create audio playback guiobj error!\n", __FUNCTION__);
			}
			break;		
		case CBK_EVENT_WFD_LINK_DISCONNECTED:
			if (!Network_App_IsPopupExist(Network_APP_POP_MSG_NETWORK_ERROR))
			{
				Network_App_ShowPopup(Network_APP_POP_MSG_NETWORK_ERROR);
			}
			break;
		case CBK_EVENT_WFD_SOURCE_TEARDOWN:
			//MAINAPP_SendGlobalEvent(UI_EVENT_SETUP,0);
			break;
#endif
#if defined(CONFIG_SUPPORT_MIRACAST) || defined(CONFIG_SUPPORT_DLNA) || defined(CONFIG_SUPPORT_NET_PLAY_RTSP) || defined(CONFIG_SUPPORT_NET_PLAY_HTTP)
		case UI_EVENT_MUTE:
#ifdef SUPPORT_CEC_TV
            AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FEATURE, 0,
                            sizeof(APP_SETTING_Feature_t), &(g_stFeatureData));
            if ((APP_SWITCH_ON == g_stFeatureData.Enable_HDMILink)
#ifdef SUPPORT_AMPLIFIER_CONTROL
                && (APP_SWITCH_ON == g_stFeatureData.AmplifierControl)
#endif
                && (APP_HDMILINK_AMPLIFIER == g_stFeatureData.SpeakerPreference) && APP_GUIOBJ_Source_GetAmplifierPort()&& APP_Check_CEC_DEVICE_Status())
            {
                if (CECTV_GetCECEnable() == CECTV_ENABLE && CECTV_GetHDMISystemAudioMode() && g_u32MuteIconHandle >= MUTE_KEY_INTERVAL)
				{
					APP_Set_CECTV_Mute_Status(EVENT_CECTV_SET_MUTE_STATUS_MUTE);
					g_u32MuteIconHandle = 0;
					break;
				}
				else if(g_u32MuteIconHandle < MUTE_KEY_INTERVAL)//Don't handle mute icon
				{
					break;
				}

            }
			APP_Set_HDMICEC_TV_Mute_Status(!APP_Get_HDMICEC_TV_Mute_Status());
#endif
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, APP_GUIOBJ_SLEEP_INFO))
			{
				APP_GUIOBJ_SleepTimer_Reset();
				SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_NETWORK, APP_GUIOBJ_SLEEP_INFO);
			}
			APP_GUIOBJ_Mute_MuteKeyHandler();
			break;
#endif
		case APP_GLOBAL_EVENT_SLEEP_TIMER_INFO:
			SysApp_NET_DestroyAppointedGUI();
			SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_NETWORK, NET_GUIOBJ_NULL, 0);
			SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_NETWORK, APP_GUIOBJ_SLEEP_INFO, dParam);
			break;
#if defined(CONFIG_HEADPHONE_DETECT_BY_ISR) || defined(CONFIG_HPDET_BY_SWTIMER)
		case APP_GLOBAL_EVENT_HEADPHONE_PLUG_IN:
			APP_Audio_Set_HPStatus(APP_Audio_Headphone_PlugIn);
			APP_Audio_SetMuteSpeakerWithoutAMP(TRUE);
			APP_Audio_SetMuteAMP(TRUE);
			APP_Audio_SetMuteDACSpeak(TRUE);
			APP_Audio_SetMuteDACHeadohone(FALSE);
			AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_USERINFO, 0,
							sizeof(APP_SETTING_UserInfo_t), &(g_stUserInfoData));
			AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FEATURE, 0,
			sizeof(APP_SETTING_Feature_t), &(g_stFeatureData));
			if ((g_stUserInfoData.Mute == FALSE) && g_stFeatureData.SpeakerPreference == APP_HDMILINK_TVSPEAKER)
			{
				APP_Audio_SetMuteSpeakerWithoutAMP(FALSE);
			}
			AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_VARIATIONAL, 0,
				sizeof(APP_SETTING_Variational_t), &(g_stVariationalData));
			APP_Audio_SetVolume(g_stVariationalData.Volume);
			break;


		case APP_GLOBAL_EVENT_HEADPHONE_PLUG_OUT:
			APP_Audio_Set_HPStatus(APP_Audio_Headphone_PlugOut);
			APP_Audio_SetMuteDACHeadohone(TRUE);
			APP_Audio_SetMuteSpeakerWithoutAMP(TRUE);
			APP_Audio_SetMuteDACSpeak(FALSE);
			APP_Audio_SetMuteAMP(FALSE);
			AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_USERINFO, 0,
							sizeof(APP_SETTING_UserInfo_t), &(g_stUserInfoData));
			AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FEATURE, 0,
			sizeof(APP_SETTING_Feature_t), &(g_stFeatureData));
			if ((g_stUserInfoData.Mute == FALSE) && g_stFeatureData.SpeakerPreference == APP_HDMILINK_TVSPEAKER)

			{
				APP_Audio_SetMuteSpeakerWithoutAMP(FALSE);
			}
			AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_VARIATIONAL, 0,
				sizeof(APP_SETTING_Variational_t), &(g_stVariationalData));
			APP_Audio_SetVolume(g_stVariationalData.Volume);
			break;
#endif
		case NET_GLOBAL_EVENT_MEDIA_INITOK:
			{
#ifdef CONFIG_SUPPORT_DLNA
				DLNA_DMSItemInfo * DMSItemInfo = NULL;
				DLNA_MW_IF_Get_DMSContList(&DMSItemInfo, 0, DLNA_MEDIA_UNKNOWN);
#endif
#ifdef CONFIG_SUPPORT_MIRACAST_DLNA_INONE
				if(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, NET_GUIOBJ_MIRACAST_DLNA_PAGE))
				{
					SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_NETWORK,
							NET_GUIOBJ_MIRACAST_DLNA_PAGE, NET_GLOBAL_EVENT_MEDIA_HIDE_MSG, 0);
				}
#else
	#ifdef CONFIG_SUPPORT_MIRACAST
				if(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, NET_GUIOBJ_MIRACAST_PAGE))
				{
					SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_NETWORK,
							NET_GUIOBJ_MIRACAST_PAGE, NET_GLOBAL_EVENT_MEDIA_HIDE_MSG, 0);
				}
	#endif
	#ifdef CONFIG_SUPPORT_DLNA
				if(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, NET_GUIOBJ_DLNA_PAGE))
				{
					
					if(DMSItemInfo && DMSItemInfo->MediaType != DLNA_MEDIA_VIDEO)
					{
						SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_NETWORK,
							NET_GUIOBJ_DLNA_PAGE, NET_GLOBAL_EVENT_MEDIA_HIDE_LOADING, 0);
					}
				}
	#endif
#endif
#ifdef CONFIG_SUPPORT_NEW_AIRPLAY
				if(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, NET_GUIOBJ_AIRPLAY_NEW))
				{
					SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_NETWORK,
							NET_GUIOBJ_AIRPLAY_NEW, NET_GLOBAL_EVENT_MEDIA_HIDE_MSG, 0);
				}
#endif
				
				UINT8 u8AspectRatioIndex = 0;
				UINT8 u8Mute = 0;
				APP_Video_AspectRatioType_e u8AspectRatioType = APP_VIDEO_ASPECT_RATIO_MAX;
				APP_Video_AspectSystemSetRead(&u8AspectRatioIndex);
				u8AspectRatioType = APP_Video_AspectRatioIndexMappingToType(u8AspectRatioIndex);
				#ifdef CONFIG_SUPPORT_NEW_AIRPLAY
				if(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, NET_GUIOBJ_AIRPLAY_NEW))
				{
					APP_Video_Set_AspectRatio(APP_VIDEO_ASPECT_RATIO_JUSTSCAN);	
				}
				else
				#endif
				{
					APP_Video_Set_AspectRatio(u8AspectRatioType);		
				}
				/* mute/unmute audio */
				AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_USERINFO, 0,
                              sizeof(APP_SETTING_UserInfo_t), &(g_stUserInfoData));
				u8Mute = g_stUserInfoData.Mute;	
			
				APP_Audio_SetMute(u8Mute, TRUE, APP_MUTE_MODE_SIGNAL_DETECT, APP_SOURCE_NET);
#ifdef CONFIG_SUPPORT_DLNA
				if((SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, NET_GUIOBJ_DLNA_PAGE)) 
					&& DMSItemInfo && (DMSItemInfo->MediaType == DLNA_MEDIA_AUDIO))
				{
					APP_Video_SetMute(TRUE, FALSE, APP_MUTE_MODE_SIGNAL_DETECT, APP_SOURCE_NET);
				}
				else
				{
					APP_Video_SetMute(FALSE, TRUE, APP_MUTE_MODE_SIGNAL_DETECT, APP_SOURCE_NET);
				}
				
#else
				APP_Video_SetMute(FALSE, TRUE, APP_MUTE_MODE_SIGNAL_DETECT, APP_SOURCE_NET);
#endif

#if defined (CONFIG_SUPPORT_NET_PLAY_RTSP) || defined(CONFIG_SUPPORT_NET_PLAY_HTTP)
				if(NetCtrl_NET_Get_Play_State() == AL_NET_PLAYER_ERR_FAILURE)
				{
					NetCtrl_Finalize();
					usleep(100);
#ifdef CONFIG_SUPPORT_NET_PLAY_RTSP
					{
						NetCtrl_Initialize();
						_Play_RTSP_Stream();
					}
#elif defined(CONFIG_SUPPORT_NET_PLAY_HTTP)
					{
						NetCtrl_Initialize();
						_Play_HTTP_Stream();
					}
#endif
				}
#endif
			}
			break;
		case NET_GLOBAL_EVENT_MEDIA_INIT_FAIL:
#ifdef CONFIG_SUPPORT_MIRACAST_DLNA_INONE
			if(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, NET_GUIOBJ_MIRACAST_DLNA_PAGE))
			{
				SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_NETWORK,
						NET_GUIOBJ_MIRACAST_DLNA_PAGE, NET_GLOBAL_EVENT_MEDIA_SHOW_MSG, 0);
			}
#else
#ifdef CONFIG_SUPPORT_DLNA
			if(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, NET_GUIOBJ_DLNA_PAGE))
			{
				SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_NETWORK,
						NET_GUIOBJ_DLNA_PAGE, NET_GLOBAL_EVENT_MEDIA_SHOW_MSG, 0);
			}
#endif
#endif
			break;
		case NET_GLOBAL_EVENT_MEDIA_DECODE_START:
		case NET_GLOBAL_EVENT_MEDIA_PIC_DECODE_START:
#ifdef CONFIG_SUPPORT_DLNA
			if(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, NET_GUIOBJ_DLNA_PAGE))
			{
				SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_NETWORK,
						NET_GUIOBJ_DLNA_PAGE, NET_GLOBAL_EVENT_MEDIA_HIDE_MSG, 0);
			}
#endif
			break;
		case NET_GLOBAL_EVENT_MEDIA_PLAY_DONE:
#ifdef CONFIG_SUPPORT_MIRACAST_DLNA_INONE
			if(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, NET_GUIOBJ_MIRACAST_DLNA_PAGE))
			{
				SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_NETWORK,
						NET_GUIOBJ_MIRACAST_DLNA_PAGE, NET_GLOBAL_EVENT_MEDIA_SHOW_MSG, 0);
			}
#else
#ifdef CONFIG_SUPPORT_DLNA
			if(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, NET_GUIOBJ_DLNA_PAGE))
			{
				SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_NETWORK,
						NET_GUIOBJ_DLNA_PAGE, NET_GLOBAL_EVENT_MEDIA_SHOW_MSG, 0);
			}
#endif
#endif
#ifdef CONFIG_SUPPORT_NEW_AIRPLAY
			if(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, NET_GUIOBJ_AIRPLAY_NEW))
			{
				SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_NETWORK,
						NET_GUIOBJ_AIRPLAY_NEW, NET_GLOBAL_EVENT_MEDIA_SHOW_MSG, 0);
			}
#endif
#if defined (CONFIG_SUPPORT_NET_PLAY_RTSP) || defined(CONFIG_SUPPORT_NET_PLAY_HTTP)
			{
				NetCtrl_Finalize();
				usleep(100);
#ifdef CONFIG_SUPPORT_NET_PLAY_RTSP
				{
					NetCtrl_Initialize();
					_Play_RTSP_Stream();
				}
#elif defined(CONFIG_SUPPORT_NET_PLAY_HTTP)
				{
					NetCtrl_Initialize();
					_Play_HTTP_Stream();
				}
#endif
			}
#endif
			break;
		case NET_GLOBAL_EVENT_MEDIA_PIC_DECODE_FINISH:
#ifdef CONFIG_SUPPORT_DLNA
			if(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, NET_GUIOBJ_DLNA_PAGE))
			{
				SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_NETWORK,
					NET_GUIOBJ_DLNA_PAGE, NET_GLOBAL_EVENT_MEDIA_HIDE_LOADING, 0);
				APP_Video_SetMute(FALSE, TRUE, APP_MUTE_MODE_SIGNAL_DETECT, APP_SOURCE_NET);
			}
#endif
			break;
		case NET_GLOBAL_EVENT_MEDIA_PIC_DECODE_ERROR:
#ifdef CONFIG_SUPPORT_DLNA
			if(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, NET_GUIOBJ_DLNA_PAGE))
			{
				SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_NETWORK,
					NET_GUIOBJ_DLNA_PAGE, NET_GLOBAL_EVENT_MEDIA_SHOW_MSG, 0);
			}
			Network_App_ShowPopup(Network_APP_POP_MSG_NOT_SUPPORT);
#endif
			break;
#ifdef CONFIG_SUPPORT_MIRACAST_DLNA_INONE
		case CBK_EVENT_DLNA_CONTENT_LIST_DONE ... CBK_EVENT_DLNA_MW_EVENT_MAX:
			if(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, NET_GUIOBJ_MIRACAST_DLNA_PAGE))
			{
				SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_NETWORK,
							NET_GUIOBJ_MIRACAST_DLNA_PAGE, dMessage, dParam);
			}
			break;
#else
#ifdef CONFIG_SUPPORT_DLNA
		case CBK_EVENT_DLNA_CONTENT_LIST_DONE ... CBK_EVENT_DLNA_MW_EVENT_MAX:
			if(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, NET_GUIOBJ_DLNA_PAGE))
			{
				SYSAPP_GOBJ_SendMsgToSingleGUIObject(SYS_APP_NETWORK,
							NET_GUIOBJ_DLNA_PAGE, dMessage, dParam);
			}
			break;
#endif
#endif
#ifdef SUPPORT_CEC_TV
		case DMN_EVENT_CECTV_CHANGE_SOURCE:
		net_printf("MM_HomePage_OnEvent DMN_EVENT_CECTV_CHANGE_SOURCE.\n");
		// Check invalid state +++
		AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FACTUSER, 0,
		sizeof(APP_SETTING_FactoryUser_t), &(g_stFactoryUserData));
		if (g_stFactoryUserData.n_FactSet_BurningMode == al_true)
		{
		break;
		}
		APP_Source_Type_t eSrc;
		APP_Video_GetCECPortMapping(dParam, &eSrc);
		// Check invalid state ---
		if (SP_SUCCESS != APP_GUIOBJ_Source_SetAppSource(eSrc))
		{
		net_printf("[FileApp OnGlobalEvent] APP_GUIOBJ_Source_SetAppSource faild.\n");
		}
		break;
		case DMN_EVENT_CECTV_STANDBY:
		MAINAPP_SendGlobalEvent(UI_EVENT_POWER, 0);
		net_printf("CEC UI_EVENT_POWER.\n");
		break;

		case DMN_EVENT_CECTV_SET_MUTE_STATUS:
			AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FEATURE, 0,
				sizeof(APP_SETTING_Feature_t), &(g_stFeatureData));
			if ((APP_SWITCH_ON == g_stFeatureData.Enable_HDMILink)
#ifdef SUPPORT_AMPLIFIER_CONTROL
				&& (APP_SWITCH_ON == g_stFeatureData.AmplifierControl)
#endif
				&& (APP_HDMILINK_AMPLIFIER == g_stFeatureData.SpeakerPreference) && APP_GUIOBJ_Source_GetAmplifierPort()&& APP_Check_CEC_DEVICE_Status())
			{
				if (CECTV_GetCECEnable() == CECTV_ENABLE)
                {
                    if( (dParam & 0x80) != 0) //reopen TV, the amp vol status must sinc.So if amp is mute state, tv need to set mute state.
                    {
                    	 APP_Set_CECTV_Mute_Status(EVENT_CECTV_SET_MUTE_STATUS_MUTE);
                    }

                    APP_Process_CECTV_Mute_Status(dParam);
                }
			}
			break;

		case DMN_EVENT_CECTV_SET_SYSTEMAUDIO_STATUS:
			APP_Process_CECTV_Control_Status_From_Amp(dParam);
			break;

		case DMN_EVENT_CECTV_SET_DEVICE_OSDNAME:
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, APP_GUIOBJ_SOURCE)
				||SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, APP_GUIOBJ_SOURCE_CEC)
				||SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, APP_GUIOBJ_HDMI_LINK)
				#ifdef CONFIG_BT_RDA5856
				|| (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, APP_GUIOBJ_BT_SETTING))
				|| (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, APP_GUIOBJ_BT_DEVICELIST))
				#endif
				||SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, APP_GUIOBJ_MAINMENU))
			{
				break;
			}
			SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_NETWORK, APP_GUIOBJ_CEC_DEVICE_INSERT, dParam);
			break;
#endif
#ifdef CONFIG_SUPPORT_NET_OTA
		case APP_GLOBAL_EVENT_OTA_UPGRADE:
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, APP_GUIOBJ_SOFTWARE_UPGRADE))
			{
				net_printf("upgrade is running!");
				break;
			}
			else
			{
				SysApp_NET_DestroyAppointedGUI();
				SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_NETWORK, NET_GUIOBJ_NULL, 0);
				SYSAPP_IF_SendGlobalEventWithIndex(SYS_APP_NETWORK, APP_GLOBAL_EVENT_ERASE_WHOLE_FLASH_OTA|PASS_TO_SYSAPP, 0);
			}
			break;
#endif
#ifdef CONFIG_SUPPORT_NET_OTA
		case APP_GLOBAL_EVENT_ERASE_WHOLE_FLASH_OTA:
			if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, APP_GUIOBJ_FM_FACTORYSETTING))
			{
				SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_NETWORK, APP_GUIOBJ_FM_FACTORYSETTING);
			}
			Network_App_ShowPopup(Network_APP_POP_ERASE_WHOLE_FLASH_OTA);
			break;
		case NET_GLOBAL_EVENT_EXIT_UPGRADE:
			SysApp_NET_DestroyAppointedGUI();
			if(SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, NET_GUIOBJ_NULL))
			{
				SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_NETWORK, NET_GUIOBJ_NULL);
			}
			break;
#endif


		default:
			net_printf("Unknown global message received.\n");
			break;
	}
	return sdRet;
}

int Network_App_OnGUIFeedbackEvent(void* pPrivateData, UINT32 dMessage, UINT32 dParam)
{
	net_printf("Network_App_OnGUIFeedbackEvent() is called \n");
	int sdRet = NET_APP_SUCCESS;
	switch(dMessage)
    {
        case GUI_RESPOND_EXIT_ALL_MENU:
            SysApp_NET_DestroyAppointedGUI();
            break;

        default:
            net_printf("[Network] Unknown GUI feedback message received.\n");
            break;
    }
	return sdRet;
}

static int Network_App_OnEvent(void* pPrivateData, UINT32 dMessage, UINT32 dParam)
{
	int dRet = NET_APP_SUCCESS;

	net_printf("Network_App_OnEvent() is called,dParam:0x%x \n",dParam);

	switch (dMessage & GUIOBJ_MESSAGE_TYPE_MASK)
	{
		case SYSAPP_GLOBAL_EVENT_TYPE:
            dRet = Network_App_OnGlobalEvent(pPrivateData, (dMessage & GUIOBJ_MESSAGE_MASK), dParam);
			break;
		case GUIOBJ_FEEDBACK_EVENT_TYPE:
            dRet = Network_App_OnGUIFeedbackEvent(pPrivateData, (dMessage & GUIOBJ_MESSAGE_MASK), dParam);
			break;
		default:
			net_printf("Unknown message type received.\n");
			break;
	}

	return dRet;
}
#ifdef CONFIG_SUPPORT_NET_SETTING
int APP_Network_Init(void)
{
	AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_SETUP, 0,
		sizeof(APP_SETTING_Setup_t), &(g_stSetupData));
	
	if(g_stSetupData.NetworkSwitch == APP_SWITCH_ON)
	{
		Al_Network_Ctrl_Init();
		if(!gNetworkConnect_task)
		{
			pthread_attr_t AVAttr;
			pthread_attr_init(&AVAttr);
			pthread_attr_setstacksize(&AVAttr, 1*1024*1024);
			if(pthread_create(&gNetworkConnect_task, &AVAttr, (void *)_APP_GUIOBJ_NetworkInformation_Connect, NULL) != 0)
			{
				printf("Network_Connect pthread_create fail\n");
			}
			pthread_attr_destroy(&AVAttr);
		}
		printf("APP_Network_Init\n");	
	}
	return 0;
}
#endif
/*****************************************************************************
** FUNCTION : Network_App_fw_callback
**
** DESCRIPTION :
**
**
** PARAMETERS :
**				None
**
** RETURN VALUES:
**				None
*****************************************************************************/
INT32 NetworkApp_fw_callback(AFW_event_t event, void *param)
{
	UINT32 message = 0xffffffff;
	UINT32 dParam = 0;
	UINT32 Index = SYS_APP_NETWORK;

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

	if (Index == SYS_APP_NETWORK)
	{
		switch (event)
		{
			case FW_AUDIO_HEADPHONE_PLUG_IN:
				message = APP_GLOBAL_EVENT_HEADPHONE_PLUG_IN|PASS_TO_SYSAPP;
				break;

			case FW_AUDIO_HEADPHONE_PLUG_OUT:
				message = APP_GLOBAL_EVENT_HEADPHONE_PLUG_OUT|PASS_TO_SYSAPP;
				break;
			
#ifdef CONFIG_SUPPORT_MIRACAST
			case FW_USB_PLUGIN:		
				dParam = *(UINT32 *)param;
				if(dParam== 0)
				{
					if(miracast_check_dongle() == WIFI_DONGLE)
					{
						message = DMN_EVENT_WIFI_DONGLE_ATTACHED;
					}
				}
			    break;
			case FW_USB_PLUGOUT:
				if(bWifiDongle)
				{
					message = DMN_EVENT_WIFI_DONGLE_DETACHED;
				}
			    break;
#endif
			case FW_VIP_STATUS:
				message = NET_GLOBAL_EVENT_VIP_STATUS;
				break;
			case FW_VIP_FINISH:
				message = NET_GLOBAL_EVENT_VIP_FINISH;
				break;
			default:
				message = 0xffffffff;
				break;
		}
	}
	else
	{
		switch (event)
		{
			default:
				message = 0xffffffff;
				break;
		}
	}

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

		return SP_SUCCESS;
	}
	else
	{
		return SP_ERR_FAILURE;
	}
}
void SysApp_NET_VolumeKeyHandler(UINT32 dMessage, UINT8 IsCECKey)
{

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

				APP_Audio_SetMute(FALSE, TRUE, APP_MUTE_MODE_SIGNAL_DETECT, APP_SOURCE_NET);

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

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

	if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, APP_GUIOBJ_AMPLIFIERVOLUME))
	{
		SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_NETWORK, APP_GUIOBJ_AMPLIFIERVOLUME);
	}
	if(IsCECKey == TRUE
#ifdef SUPPORT_CEC_TV
		&& CECTV_GetHDMISystemAudioMode() && APP_Check_CEC_DEVICE_Status()
#endif
	)
	{
		if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, APP_GUIOBJ_ADJUST))
		{
			SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_NETWORK, APP_GUIOBJ_ADJUST);
		}
		if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, APP_GUIOBJ_AMPLIFIERVOLUME))
		{
			SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_NETWORK, APP_GUIOBJ_AMPLIFIERVOLUME);
		}
		else
		{
			SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_NETWORK,APP_GUIOBJ_AMPLIFIERVOLUME, 0);
		}
	}
	else
	{
		if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, APP_GUIOBJ_AMPLIFIERVOLUME))
		{
			SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_NETWORK, APP_GUIOBJ_AMPLIFIERVOLUME);
		}

		if (SYSAPP_GOBJ_GUIObjectExist(SYS_APP_NETWORK, APP_GUIOBJ_ADJUST))
		{
			SYSAPP_GOBJ_DestroyGUIObject(SYS_APP_NETWORK, APP_GUIOBJ_ADJUST);
		}
		else
		{
			UINT8 u8VolumeIdx = g_stVariationalData.Volume;
            if (dMessage == UI_EVENT_VOL_UP)
			{
				g_stVariationalData.Volume = u8VolumeIdx >= ADJUST_MAX_VALUE ? ADJUST_MAX_VALUE : ++u8VolumeIdx;
			}
			else if (dMessage == UI_EVENT_VOL_DN)
			{
				g_stVariationalData.Volume = u8VolumeIdx <= ADJUST_MIN_VALUE ? ADJUST_MIN_VALUE : --u8VolumeIdx;
			}
			AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FACTHOTEL, 0,
					sizeof(APP_SETTING_FactoryHotel_t), &(g_stFactoryHotelData));
			if ((g_stFactoryHotelData.MaxVolume < g_stVariationalData.Volume)
				&&(g_stFactoryHotelData.HotelModeOnOff == 1))
			{
				g_stVariationalData.Volume = g_stFactoryHotelData.MaxVolume;
			}
			APP_Audio_SetVolume((UINT32)g_stVariationalData.Volume);
			AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_VARIATIONAL,
							 ITEM_OFFSET(APP_SETTING_Variational_t, Volume),
							 sizeof(g_stVariationalData.Volume), &(g_stVariationalData.Volume));
			SYSAPP_GOBJ_CreateGUIObject_WithPara(SYS_APP_NETWORK, APP_GUIOBJ_ADJUST, ADJUST_VOLUME);
		}
	}
}