myvtm/Module/mod_localmediaplay/mod_localmediaplay.cpp

#include "stdafx.h"
#include "mod_localmediaplay.h"
#include "LocalMediaPlay_msg_g.h"
#include "fileutil.h"
#include "y2k_time.h"
#include "../../Other/rvcmediacommon/rvc_media_common.h"
#include "../mod_interactivecontrol/Event.h"

#define DEFAULT_SLEEP_TIME		(60 * 1000)
#define DEFAULT_ADVERT_TYPE		'A'
bool IS_DEBUG = false;
int scanTime = 600;
int removeOldTime = 1800;

#ifndef MAX_LOCAL_MEDIAS
#define MAX_LOCAL_MEDIAS 128
#endif // !MAX_LOCAL_MEDIAS


#ifndef RVC_MIN_LOCALPLAYER_TIME
#define RVC_MIN_LOCALPLAYER_TIME 6
#endif

//DWORD WINAPI clearOutdata(LPVOID lpv)
//{
//	CLocalMediaPlayEntity* curEntity = (CLocalMediaPlayEntity*)lpv;
//	Sleep(removeOldTime * 1000);
//	curEntity->m_mediaManage.clearOutdataResource();
//	return 0;
//}

#ifdef RVC_OS_WIN
DWORD WINAPI qryMedia(LPVOID lpv)
{
	CLocalMediaPlayEntity* curEntity = (CLocalMediaPlayEntity*)lpv;
	Sleep(3000);

	while (true)
	{
		curEntity->m_mediaManage.InitResourceListByLocal();
		//curEntity->StartVideo(0, 0, 0, 0, 0);
		Sleep(3600 * 1000);
	}

	return 0;
}

#else
void* queryMedia(void* param)
{
	CLocalMediaPlayEntity* curEntity = (CLocalMediaPlayEntity*)param;
	sleep(3);

	while (false == curEntity->GetScanExitFlag())
	{
		curEntity->m_mediaManage.InitResourceListByLocal();
		sleep(3600);
	}

	return 0;
}

void sig_handler(int signum)
{
	if (SIGTERM == signum){
		int ipid = getpid();
		kill(ipid, SIGKILL);
	}
}

#endif // RVC_OS_WIN


CLocalMediaPlayEntity::CLocalMediaPlayEntity() 
	: m_id_seq(0),  m_connection(NULL)
{
	//stopForDebug();
	m_defaultVolum = 50;

#ifdef RVC_OS_WIN
	m_scanThread=NULL;
	m_pAudioPlayer = NULL;
	memset(m_pVideoPlayer, 0, sizeof(m_pVideoPlayer));
	memset(m_pImagePlayer, 0, sizeof(m_pImagePlayer));
#else
	m_scanThreadId = 0;
	m_pMediaAudioPlayer = NULL;
	memset(m_pMediaPlayer, 0, sizeof(m_pMediaPlayer));
	memset(m_pPicturePlayer, 0, sizeof(m_pPicturePlayer));
	m_uMediaPlayThreadId = 0;
	m_uNoticePlayThreadId = 0;
	m_badplayflag = true;
	m_bgetflag = false;
	m_bgetico = false;
	m_remote_audio_queue = NULL;
	m_pFile = NULL;
	m_bRecordPCM = false;
#endif // RVC_OS_WIN

	ZeroMemory(&m_mediaParam, sizeof(MediaPlayParam));
}

CLocalMediaPlayEntity::~CLocalMediaPlayEntity()
{
	SecureClientRelease();

	DWORD exitCode = 0;
#ifdef RVC_OS_WIN
	if (m_scanThread)
	{
		TerminateThread(m_scanThread, exitCode);
		m_scanThread = NULL;
	}
#else
	m_scanexitflag = true;
	if (0 == pthread_join(m_scanThreadId, NULL)) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("pthread join scanThreadId success.");
	}
	m_bgetflag = false;
	m_bgetico = false;
	
#endif // RVC_OS_WIN
}

void CLocalMediaPlayEntity::SecureClientRelease()
{
	if (NULL != m_connection)
	{
		if (m_connection->IsConnectionOK())
			m_connection->Close();
		m_connection->DecRefCount();
		m_connection = NULL;
	}
}

bool CLocalMediaPlayEntity::SecureClientConnect()
{
	if (NULL != m_connection && m_connection->IsConnectionOK())
		return true;
	SecureClientRelease();
	m_connection = new CAdvertSyncConnection(this);

	return m_connection->ConnectFromCentralSetting();
}

void CLocalMediaPlayEntity::setMediaPath()
{
	CSimpleStringA downloadPath, mediaPath;
	GetFunction()->GetPath("Download", downloadPath);
	GetFunction()->GetPath("Ad", mediaPath);

	m_mediaManage.setDefaultDownloadPath(downloadPath.GetData());
	m_mediaManage.setDefaultAddvertPath(mediaPath.GetData());
}

CServerSessionBase* CLocalMediaPlayEntity::OnNewSession(const char* pszRemoteEntityName, const char * pszClass)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("%s connected class = %s!", pszRemoteEntityName, pszClass);
	return new CLocalMediaPlaySession(this, m_id_seq++);
}


void CLocalMediaPlayEntity::loadDefaultMedia()
{
#ifdef RVC_OS_WIN
	m_defaultImg.clear();
	m_defaultAudio.clear();
	m_defaultVideo.clear();
#else
	m_defaultPic.clear();
	m_Audios.clear();
	m_Videos.clear();
#endif // RVC_OS_WIN

	// 读取LocalMediaPlay.ini中的配置
	CSimpleStringA strRootPath;
	ErrorCodeEnum Error = Error_Succeed;
	Error = GetFunction()->GetPath("ADData", strRootPath);
	if (Error != Error_Succeed) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Fail to get local media root path!");
		return;
	}

	//General
	IS_DEBUG = false;
	scanTime = 600;
	removeOldTime = 1800;
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("runDebug:%s, scanTime:%d", IS_DEBUG ? "true" : "false", scanTime);

	CSimpleStringA imgPath = strRootPath + SPLIT_SLASH_STR + "Image" + SPLIT_SLASH_STR;
	//Image0
	do 
	{
#ifdef RVC_OS_WIN
        CImgPlayConfig curImg;
        ZeroMemory(&curImg, sizeof(CImgPlayConfig));
#else
        CPicPlayConfig curImg;
        ZeroMemory(&curImg, sizeof(CPicPlayConfig));
#endif // RVC_OS_WIN
        strncpy(curImg.strRootPath, (LPCSTR)imgPath, sizeof(curImg.strRootPath));
        DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("curSection: %s, config.strRootPath: %s", "Image0", curImg.strRootPath);
		curImg.bFullScreen = true;
        curImg.bPrimMonitor = false;
		curImg.nPlayCnt = 0;
		curImg.nPlayInterval = 5000;

		curImg.nFileCnt = 4;
		strcpy(curImg.strFileNames[0], "Ad0/0.jpg");
        strcpy(curImg.strFileNames[1], "Ad0/1.jpg");
        strcpy(curImg.strFileNames[2], "Ad0/2.jpg");
        strcpy(curImg.strFileNames[3], "Ad0/3.jpg");
#ifdef RVC_OS_WIN
        m_defaultImg.push_back(curImg);
#else
        m_defaultPic.push_back(curImg);
#endif // RVC_OS_WIN
	} while (false);

    //Image1
    do {
#ifdef RVC_OS_WIN
        CImgPlayConfig curImg;
        ZeroMemory(&curImg, sizeof(CImgPlayConfig));
#else
        CPicPlayConfig curImg;
        ZeroMemory(&curImg, sizeof(CPicPlayConfig));
#endif // RVC_OS_WIN
        strncpy(curImg.strRootPath, (LPCSTR)imgPath, sizeof(curImg.strRootPath));
        DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("curSection: %s, config.strRootPath: %s", "Image1", curImg.strRootPath);
        curImg.bFullScreen = false;
        curImg.bPrimMonitor = true;
        curImg.nPlayCnt = 6;
        curImg.nPlayInterval = 1000;

        curImg.nFileCnt = 4;
        strcpy(curImg.strFileNames[0], "Ad1/0.jpg");
        strcpy(curImg.strFileNames[1], "Ad1/1.jpg");
        strcpy(curImg.strFileNames[2], "Ad1/2.jpg");
        strcpy(curImg.strFileNames[3], "Ad1/3.jpg");
#ifdef RVC_OS_WIN
        m_defaultImg.push_back(curImg);
#else
        m_defaultPic.push_back(curImg);
#endif // RVC_OS_WIN
    } while (false);

	CSimpleStringA videoPath = strRootPath + SPLIT_SLASH_STR + "Video" + SPLIT_SLASH_STR;
    CSimpleStringA strRunTime_S("09:00:00"), strRunTime_E("17:30:00");
	//Video0
	do 
	{
	#ifdef RVC_OS_WIN
		CWmpPlayConfig curVideo;
		ZeroMemory(&curVideo, sizeof(CWmpPlayConfig));
	#else
		CMediaPlayConfig curVideo = { 0 };
	#endif // RVC_OS_WIN
        strcpy(curVideo.strRootPath, (LPCSTR)videoPath);
        DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("config.strRootPath: %s", curVideo.strRootPath);

		curVideo.bFullScreen = true;
		curVideo.bPrimMonitor = false;
		curVideo.bSimpleMode = true;
		curVideo.nPlayCnt = 1;
		curVideo.nPlayInterval = 2000;
        curVideo.nVolume = 50;
		CSmartPointer<IConfigInfo> tempConfig;
        Error = GetFunction()->OpenConfig(Config_Run, tempConfig);
        if (Error == Error_Succeed) {
            Error = tempConfig->ReadConfigValueInt("LocalVideo", "Volume", curVideo.nVolume);
            if (Error != Error_Succeed || curVideo.nVolume < 0 || curVideo.nVolume > 100)
                curVideo.nVolume = 50;
            m_defaultVolum = curVideo.nVolume;
        }
        strcpy(curVideo.strVideoRunTime_S, (LPCSTR)strRunTime_S);
        DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("config.strVideoRunTime_S: %s", (LPCSTR)strRunTime_S);
        strcpy(curVideo.strVideoRunTime_E, (LPCSTR)strRunTime_E);
        DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("config.strVideoRunTime_E: %s", (LPCSTR)strRunTime_E);

		curVideo.nFileCnt = 1;
		strcpy(curVideo.strFileNames[0], "可视柜台欢迎界面.wmv");
#ifdef RVC_OS_WIN
        m_defaultVideo.push_back(curVideo);
#else
        m_Videos.push_back(curVideo);
#endif // RVC_OS_WIN
	} while (false);

    //Video1
    do {
#ifdef RVC_OS_WIN
        CWmpPlayConfig curVideo;
        ZeroMemory(&curVideo, sizeof(CWmpPlayConfig));
#else
        CMediaPlayConfig curVideo = { 0 };
#endif // RVC_OS_WIN
        strcpy(curVideo.strRootPath, (LPCSTR)videoPath);
        DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("config.strRootPath: %s", curVideo.strRootPath);
        curVideo.bFullScreen = true;
        curVideo.bPrimMonitor = false;
        curVideo.bSimpleMode = true;
        curVideo.nPlayCnt = 0;
        curVideo.nPlayInterval = 10000;
        curVideo.nVolume = 50;
        CSmartPointer<IConfigInfo> tempConfig;
        Error = GetFunction()->OpenConfig(Config_Run, tempConfig);
        if (Error == Error_Succeed) {
            Error = tempConfig->ReadConfigValueInt("LocalVideo", "Volume", curVideo.nVolume);
            if (Error != Error_Succeed || curVideo.nVolume < 0 || curVideo.nVolume > 100)
                curVideo.nVolume = 50;
            m_defaultVolum = curVideo.nVolume;
        }
        strcpy(curVideo.strVideoRunTime_S, (LPCSTR)strRunTime_S);
        DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("config.strVideoRunTime_S: %s", (LPCSTR)strRunTime_S);
        strcpy(curVideo.strVideoRunTime_E, (LPCSTR)strRunTime_E);
        DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("config.strVideoRunTime_E: %s", (LPCSTR)strRunTime_E);

        curVideo.nFileCnt = 1;
        strcpy(curVideo.strFileNames[0], "可视柜台广告界面2.mp4");
#ifdef RVC_OS_WIN
        m_defaultVideo.push_back(curVideo);
#else
        m_Videos.push_back(curVideo);
#endif // RVC_OS_WIN
    } while (false);

	CSimpleStringA audioPath = strRootPath + SPLIT_SLASH_STR + "Audio" + SPLIT_SLASH_STR;
	//Audio
	do 
	{
#ifdef RVC_OS_WIN
        CWmpPlayConfig curAudio;
        ZeroMemory(&curAudio, sizeof(CWmpPlayConfig));
#else
        CMediaPlayConfig curAudio = { 0 };
#endif // RVC_OS_WIN
        strcpy(curAudio.strRootPath, (LPCSTR)audioPath);
        DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("config.strRootPath: %s", curAudio.strRootPath);
		curAudio.nPlayCnt = 1;
		curAudio.nPlayInterval = 5000;
        auto audioRet = GetLocalAudioVolume();
        if (audioRet.first)
            curAudio.nVolume = audioRet.second;
        else
            curAudio.nVolume = m_defaultVolum;

#ifdef RVC_OS_WIN
        m_defaultAudio.push_back(curAudio);
#else
        m_Audios.push_back(curAudio);
#endif // RVC_OS_WIN

	} while (false);
}

#ifdef RVC_OS_WIN

BOOL CLocalMediaPlayEntity::LoadPlayConfig(CWmpPlayConfig& config, int CfgInx)
{
	if (CfgInx >= MAX_PLAY_CHANNELS || CfgInx < 0)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Invalid CfgInx while LoadConfig!");
		return FALSE;
	}

	if (config.eMode == LOCALAUDIO && CfgInx < m_defaultAudio.size())
	{
		memcpy(&config, &(m_defaultAudio[CfgInx]), sizeof(CWmpPlayConfig));
	}
	else if (config.eMode == LOCALVIDEO && CfgInx < m_defaultVideo.size())
	{
		memcpy(&config, &(m_defaultVideo[CfgInx]), sizeof(CWmpPlayConfig));
	}
	else {
		return FALSE;
	}

	return TRUE;
}

BOOL CLocalMediaPlayEntity::LoadPlayConfig(CImgPlayConfig& config, int CfgInx)
{
	if (CfgInx >= m_defaultImg.size() || CfgInx < 0)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Invalid CfgInx while LoadConfig!");
		return FALSE;
	}

	memcpy(&config, &(m_defaultImg[CfgInx]), sizeof(CImgPlayConfig));

	return TRUE;
}

void CLocalMediaPlayEntity::WmpDebug(const char* fmt, ...)
{
	va_list arg;
	va_start(arg, fmt);
	vDbg(fmt, arg);
	va_end(arg);
}

void CLocalMediaPlayEntity::ImgDebug(const char* fmt, ...)
{
	va_list arg;
	va_start(arg, fmt);
	vDbg(fmt, arg);
	va_end(arg);
}

#else

int CLocalMediaPlayEntity::LoadPlayConfig(CMediaPlayConfig& config, int CfgInx)
{
	if (CfgInx >= MAX_PLAY_CHANNELS || CfgInx < 0)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Invalid CfgInx while LoadConfig!");
		return -1;
	}

	if (config.eMode == LOCALAUDIO && CfgInx < m_Audios.size())
	{
		memcpy(&config, &(m_Audios[CfgInx]), sizeof(CMediaPlayConfig));
	}
	else if (config.eMode == LOCALVIDEO && CfgInx < m_Videos.size())
	{
		memcpy(&config, &(m_Videos[CfgInx]), sizeof(CMediaPlayConfig));
	}
	else {
		return -1;
	}

	return 0;
}

int CLocalMediaPlayEntity::LoadPlayConfig(CPicPlayConfig& config, int CfgInx)
{
	if (CfgInx >= m_defaultPic.size() || CfgInx < 0)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Invalid CfgInx while LoadConfig!");
		return -1;
	}

	memcpy(&config, &(m_defaultPic[CfgInx]), sizeof(CPicPlayConfig));

	return 0;
}


void CLocalMediaPlayEntity::Debug(media_loglevel log_level, const char* fmt, ...)
{
	if (log_level >= MEDIA_LOG_ERROR){
		va_list arg;
		va_start(arg, fmt);
		int n = vsnprintf(NULL, 0, fmt, arg);
		if (n >= MAX_PATH) {
			char* buf = (char*)malloc((size_t)(n + 1));
			vsnprintf(buf, n + 1, fmt, arg);
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("%s", buf);
			free(buf);
		}
		else {
			char strlog[MAX_PATH] = { 0 };
			vsnprintf(strlog, MAX_PATH, fmt, arg);
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("%s", strlog);
		}
		va_end(arg);
	}
}

void CLocalMediaPlayEntity::PicDebug(pic_loglevel log_level, const char* fmt, ...)
{
	if (log_level >= PIC_LOG_ERROR){
		va_list arg;
		va_start(arg, fmt);
		int n = vsnprintf(NULL, 0, fmt, arg);
		if (n >= MAX_PATH) {
			char* buf = (char*)malloc((size_t)(n + 1));
			vsnprintf(buf, n + 1, fmt, arg);
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("%s", buf);
			free(buf);
		}
		else {
			char strlog[MAX_PATH] = { 0 };
			vsnprintf(strlog, MAX_PATH, fmt, arg);
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("%s", strlog);
		}
		va_end(arg);
	}
}

void CLocalMediaPlayEntity::MediaPlayFinished(int iMediaType)
{
	if (0 == iMediaType) {
		AudioPlayRet ret;
		ret.AudioNames = m_lastPlayAudio.c_str();
		ret.ret = true;
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("stop play audio %s success.", ret.AudioNames.GetData());
		if (false == m_buserstopaudio) {
			SpSendBroadcast(GetFunction(), eMsg_AudioPlayRet, eMsgSig_AudioPlayRet, ret);
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("user stop, not broadcast!");
		}
	}
	else {
		VideoPlayRet ret;
		ret.VideoNames = m_lastPlayVideo.c_str();
		ret.ret = true;
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("stop play video notice %s success.", ret.VideoNames.GetData());
		SpSendBroadcast(GetFunction(), eMsg_VideoPlayRet, eMsgSig_VideoPlayRet, ret);
	}
}

int CLocalMediaPlayEntity::GetMediaPlayerIcoPath(char* strPath, size_t uLen)
{
	return GetPlayerIcoPath(strPath, uLen);
}

int CLocalMediaPlayEntity::GetAudioOutDevName(char* strDev, size_t uLen)
{
	int iRet = -1;
	
	int idatalen = m_strAudioOutDev.GetLength();
	if (uLen > idatalen && idatalen > 0) {
		memcpy(strDev, m_strAudioOutDev.GetData(), idatalen);
		iRet = 0;
		if (false == m_bgetflag) {
			m_bgetflag = true;
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("%s:%d audio Out Device Name is %s.", __FUNCTION__, __LINE__, strDev);
		}
	}

	return iRet;
}

int CLocalMediaPlayEntity::PlayingAudioDataCallback(audio_param_t* param, const void* input, unsigned long uaudiolen)
{
	int iRet = -1;
	if (m_bStartRecord) {
		if (false == m_bloged) {
			char strmsg[MAX_PATH * 2] = { 0 };
			snprintf(strmsg, MAX_PATH * 2, "audio param target (%d channels, %d Hz, channel_layout(%d), frame_size(%d), bytes_per_sec(%d)).", param->channels, param->freq, param->channel_layout, param->frame_size, param->bytes_per_sec);
			m_bloged = true;
			LogWarn(Severity_Low, Error_Debug, LOG_EVT_PLAYING_AUDIO_INFOS, strmsg);
		}

		if (8000 == param->freq && 1 == param->channels && 1 == param->fmt) {
			//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("%s:%d uaudiolen:%d", __FUNCTION__, __LINE__, uaudiolen);
			if (uaudiolen + m_leftlen <= RVC_AUDIO_BUFFER_LEN) {
				int icount = (uaudiolen + m_leftlen) / RVC_AUDIO_LEN;
				if (icount > 0) {
					memcpy(m_audiobuffer + m_leftlen, (char*)input, icount * RVC_AUDIO_LEN - m_leftlen);
					for (int i = 0; i < icount; i++) {
						audio_frame frm;
						char straudio[RVC_AUDIO_LEN] = { 0 };
						memcpy(straudio, m_audiobuffer + i * RVC_AUDIO_LEN, RVC_AUDIO_LEN);
						frm.bitspersample = 16;
						frm.format = param->fmt;
						frm.data = straudio;
						frm.framesize = RVC_AUDIO_LEN;
						frm.nchannels = param->channels;
						frm.samplespersec = param->freq;
						frm.iseriesnumber = m_iseriesnumber++;
						if (!m_remote_audio_queue->InsertAudio(&frm)) {
							DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("InsertAudio failed! frameCount:%d", frm.framesize);
						}
						else {
							//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("%s:%d InsertAudio(seriesnumber = %d) success", __FUNCTION__, __LINE__, frm.iseriesnumber);
							if (m_bRecordPCM && m_pFile){
								fwrite(frm.data, RVC_AUDIO_LEN, 1, m_pFile);
							}
						}
					}
					memset(m_audiobuffer, 0, RVC_AUDIO_BUFFER_LEN);
					int ileftaudio = uaudiolen - (icount * RVC_AUDIO_LEN - m_leftlen);
					memcpy(m_audiobuffer, (char*)input + icount * RVC_AUDIO_LEN - m_leftlen, ileftaudio);
					m_leftlen = ileftaudio;
				}
				else {
					memcpy(m_audiobuffer + m_leftlen, (char*)input , uaudiolen);
					m_leftlen += uaudiolen;
				}
			}
			iRet = 0;
		}
	}

	return iRet;
}

int CLocalMediaPlayEntity::GetPicPlayerIcoPath(char* strPath, size_t uLen)
{
	return GetPlayerIcoPath(strPath, uLen);
}


bool CLocalMediaPlayEntity::GetPlayFlag()
{
	return m_badplayflag;
}


bool CLocalMediaPlayEntity::GetScanExitFlag()
{
	return m_scanexitflag;
}

DeviceTypeEnum CLocalMediaPlayEntity::GetDeviceType()
{
	return m_eDeviceType;
}

int CLocalMediaPlayEntity::GetPlayerIcoPath(char* strPath, size_t uLen)
{
	int iRet = -1;
	if (NULL == strPath) {
		return iRet;
	}
	
	CSimpleStringA csBinPath;
	ErrorCodeEnum eErrPath = GetFunction()->GetPath("Bin", csBinPath);
	if (eErrPath != Error_Succeed) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("GetBasePath failed (%d).", eErrPath);
		return iRet;
	}

	CSimpleStringA szIcoName("rvc_media_player_64px.bmp");
	szIcoName = csBinPath + SPLIT_SLASH_STR + szIcoName;
	if (m_bgetico == false) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("media player ico full path is %s.", szIcoName.GetData());
		m_bgetico = true;
	}

	if (uLen > szIcoName.GetLength()) {
		memcpy(strPath, szIcoName.GetData(), szIcoName.GetLength());
		iRet = 0;
		m_bgetico = true;
	}
	
	return iRet;
}


int CLocalMediaPlayEntity::GetAudioOutDev()
{
	int iRet = -1;
	CSmartPointer<IEntityFunction> spFunction = GetFunction();
	CSmartPointer<IConfigInfo> spRootConfig;
	ErrorCodeEnum Error = spFunction->OpenConfig(Config_Root, spRootConfig);
	if (Error == Error_Succeed) {
		SpIniMappingTable table;
		table.AddEntryString("audio", "handfree_out_dev", m_strAudioOutDev, "$");
		Error = table.Load(spRootConfig);
		if (Error == Error_Succeed) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Audio Out Device name is %s.", m_strAudioOutDev.GetData());
			iRet = 0;
		}
	}
	return iRet;
}
#endif // RVC_OS_WIN


void CLocalMediaPlayEntity::OnLog(const CAutoArray<CUUID> &SubIDs, const CUUID nLogID, const LogTypeEnum eLogType, const SeverityLevelEnum eLevel,
	const DWORD dwSysError, const DWORD dwUserCode, const DWORD dwEntityInstanceID, const WORD wEntityDevelID,
	const CAutoArray<DWORD> &Param, const char *pszEntityName, const char *pszModuleName, const char *pszMessage, const linkContext& pLinkInfo)
{
	if (dwUserCode == LOG_EVT_SELFCHECK_IEBROWSER_IDLE){
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("IEBrowser to idle, stop all media!");
		StopAll();
	}
	else if(LOG_EVT_UI_STARTREMOTERECORD == dwUserCode){
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Start remote record.");
		HandleRemoteRecord(pszMessage);
	}
	else if (LOG_EVT_UI_STOPREMOTERECORD == dwUserCode) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Stop remote record.");
		m_bStartRecord = false;
		m_iseriesnumber = 0;
		if (NULL != m_remote_audio_queue) {
			delete m_remote_audio_queue;
			m_remote_audio_queue = NULL;
		}

		if (m_pFile) {
			fclose(m_pFile);
			m_pFile = NULL;
		}
	}
}


void CLocalMediaPlayEntity::OnPreStart(CAutoArray<CSimpleStringA> strArgs, CSmartPointer<ITransactionContext> pTransactionContext)
{
	LOG_FUNCTION();
	ErrorCodeEnum Error = __OnStart(Error_Succeed);
	pTransactionContext->SendAnswer(Error);
}

ErrorCodeEnum CLocalMediaPlayEntity::__OnStart(ErrorCodeEnum preOperationError)
{
#ifdef RVC_OS_WIN
	//toolkit_setenv("SDL_AUDIODRIVER", "winmm");
#else
	GetAudioOutDev();
#endif // RVC_OS_WIN
	m_eDeviceType = eStand2sType;
	m_eDeviceType = RvcGetDeviceType();

	return Error_Succeed;
}


void CLocalMediaPlayEntity::OnStarted()
{
	LogEvent(Severity_Middle, LOG_EVT_MOD_LOCALPLAYER_STARTED_SUCCESS, "local meida play entity started successfully.");

	for (int i = 0; i != MAX_PLAY_CHANNELS; ++i)
	{
#ifdef RVC_OS_WIN
		m_pVideoPlayer[i] = new Clibwmpplayer(this);
		m_pImagePlayer[i] = new Clibimgplayer(this);
#else
		mediaplayer_init();
		m_pMediaPlayer[i] = new Clibmediaplayer(this);
		m_pPicturePlayer[i] = new Clibpictureplayer(this);
#endif 
	}

#ifdef RVC_OS_WIN
	m_pAudioPlayer = new Clibwmpplayer(this);
#else
	m_pMediaAudioPlayer = new Clibmediaplayer(this);
	signal(SIGTERM, sig_handler);

#endif // RVC_OS_WIN

	if (!IsRunConfigExist()){
		SetLocalVideoVolume(0, 50);
		SetLocalAudioVolume(50);
	}

	//setMediaPath();
	loadDefaultMedia();

	GetFunction()->SubscribeLog(m_SubIDIEIdle, this, Log_Event, Severity_None, Error_IgnoreAll, LOG_EVT_SELFCHECK_IEBROWSER_IDLE, NULL, false);
	GetFunction()->SubscribeLog(m_SubIDStartRecord, this, Log_Event, Severity_None, Error_IgnoreAll, LOG_EVT_UI_STARTREMOTERECORD, NULL, false);
	GetFunction()->SubscribeLog(m_SubIDStopRecord, this, Log_Event, Severity_None, Error_IgnoreAll, LOG_EVT_UI_STOPREMOTERECORD, NULL, false);

#ifdef RVC_OS_WIN
	m_scanThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)& qryMedia, this, 0, NULL);
	if (NULL != m_scanThread)
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("create qryMeia thread success, %d.", m_scanThread);
#else
	int err = pthread_create(&m_scanThreadId, NULL, queryMedia, this);
	if (0 == err) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("create queryMedia thread success, %u.", m_scanThreadId);
	}
	else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("create queryMedia thread failed.");
	}

	GetPcmRecordFlag();

#endif // RVC_OS_WIN
}

void CLocalMediaPlayEntity::OnPreClose(EntityCloseCauseEnum eCloseCause, CSmartPointer<ITransactionContext> pTransactionContext)
{
	LOG_FUNCTION();
	ErrorCodeEnum Error = __OnClose(Error_Succeed);
	pTransactionContext->SendAnswer(Error);
}

ErrorCodeEnum CLocalMediaPlayEntity::__OnClose(ErrorCodeEnum preOperationError)
{
	for (int i = 0; i != MAX_PLAY_CHANNELS; ++i)
	{
#ifdef RVC_OS_WIN
		delete m_pVideoPlayer[i]; m_pVideoPlayer[i] = NULL;
		delete m_pImagePlayer[i]; m_pImagePlayer[i] = NULL;
#else
		delete m_pMediaPlayer[i];  m_pMediaPlayer[i] = NULL;
		delete m_pPicturePlayer[i]; m_pPicturePlayer[i] = NULL;
#endif // RVC_OS_WIN
	}

#ifdef RVC_OS_WIN
	delete m_pAudioPlayer; m_pAudioPlayer = NULL;
#else
	delete m_pMediaAudioPlayer; m_pMediaAudioPlayer = NULL;
	mediaplayer_term();
#endif // RVC_OS_WIN
	
	GetFunction()->UnsubscribeLog(m_SubIDIEIdle);
	GetFunction()->UnsubscribeLog(m_SubIDStartRecord);
	GetFunction()->UnsubscribeLog(m_SubIDStopRecord);

	return Error_Succeed;
}

#ifdef RVC_OS_WIN
DWORD WINAPI CheckAudioThread(LPVOID param)
{
	CLocalMediaPlayEntity *entity = (CLocalMediaPlayEntity*)param;
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Begin CheckAudioThread");


	HANDLE playThread = NULL;
	if (!entity->m_pAudioPlayer->checkIsPlay(playThread))
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Create play audio Media Thread Failed!");
		return 0;
	}
	WaitForSingleObject(playThread, INFINITE);
	entity->m_pAudioPlayer->Close();

	AudioPlayRet ret;
	ret.AudioNames = entity->m_lastPlayAudio.c_str();
	ret.ret = true;
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("stop play audio %s success", ret.AudioNames);
	SpSendBroadcast(entity->GetFunction(), eMsg_AudioPlayRet, eMsgSig_AudioPlayRet, ret);

	return 0;
}

#else

void* StartAudioPlayingThreadFunc(void* param)
{
	CLocalMediaPlayEntity* entity = (CLocalMediaPlayEntity*)param;
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Enter StartAudioPlayingThreadFunc");
	const char* pAudioNames = entity->m_lastPlayAudio.c_str();
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Begin StartAudio, and Audio Info is %s.", pAudioNames);
	if (0 == entity->m_pMediaAudioPlayer->PlayLocalAudio(pAudioNames)) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Succeed to StartAudio, and Audio Info is %s.", pAudioNames);
	}
	else{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("StartAudio failed, for %s is not exsit.", pAudioNames);
	}
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Leave StartAudioPlayingThreadFunc");
	entity->m_uMediaPlayThreadId = 0;

	return 0;
}

#endif // RVC_OS_WIN


#ifdef RVC_OS_WIN
DWORD WINAPI MediaPlayThread(LPVOID param)
{
	CLocalMediaPlayEntity *entity = (CLocalMediaPlayEntity*)param;

	while (TRUE)
	{
		vector<ResourceParse> curParse;
		entity->m_mediaManage.GetPlayListByLocal(curParse);
		if (0 == curParse.size())
		{
			HANDLE playThread = NULL;
			CWmpPlayConfig config;
			ZeroMemory(&config, sizeof(CWmpPlayConfig));
			memcpy(&config, &(entity->m_defaultVideo[entity->m_mediaParam.nCfgInx]), sizeof(CWmpPlayConfig));
			config.nPlayCnt = 1;	//can be change 
			config.eMode = LOCALVIDEO;
			config.nWndX = entity->m_mediaParam.nWndX;
			config.nWndY = entity->m_mediaParam.nWndY;
			config.nWndWidth = entity->m_mediaParam.nWndWidth;
			config.nWndHeight = entity->m_mediaParam.nWndHeight;
			if (IS_DEBUG)
			{
				config.bFullScreen = false;
				config.bPrimMonitor = true;
			}
			// add by ly@2018/07/30
			if (!entity->GetLocalVideoVolume(0, config.nVolume))
			{
				config.nVolume = entity->m_defaultVolum;
			}
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("config.nVolume=%d while play local video.", config.nVolume);
			// 判断当前时间是否允许播放
			SYSTEMTIME st;
			GetLocalTime(&st);
			TCHAR strNow[TIME_LEN];
			sprintf(strNow, "%02d:%02d:%02d", st.wHour, st.wMinute, st.wSecond);
			if (strcmp(strNow, config.strVideoRunTime_S) < 0 || strcmp(strNow, config.strVideoRunTime_E) >= 0)
			{
				Sleep(10000);
				continue;
			}
			entity->m_pVideoPlayer[entity->m_mediaParam.nCfgInx]->PlayMedia(config);
			if (!entity->m_pVideoPlayer[entity->m_mediaParam.nCfgInx]->checkIsPlay(playThread))
			{
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Create play Video Media Thread Failed!");
				return 0;
			}
			WaitForSingleObject(playThread, INFINITE);
			if (entity->m_pVideoPlayer[entity->m_mediaParam.nCfgInx]->checkIsStop())
			{
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("stop play video");
				return 0;
			}
			else
				entity->m_pVideoPlayer[entity->m_mediaParam.nCfgInx]->Close();
		}

		for (vector<ResourceParse>::iterator i = curParse.begin(); i != curParse.end(); i++)
		{
			HANDLE playThread = NULL;
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("begin play extend %c:%s, %s", i->type, i->resourcePath.c_str(), i->videoNames.c_str());
			if ('V' == i->type)
			{//video
				CWmpPlayConfig config;
				ZeroMemory(&config, sizeof(CWmpPlayConfig));
				config.bFullScreen = IS_DEBUG ? false : i->fullScreen;
				config.bPrimMonitor = IS_DEBUG ? true : i->primMonitor;
				config.bSimpleMode = i->simpleMode;
				config.eMode = LOCALVIDEO;
				config.nFileCnt = 1;
				config.nPlayCnt = 1;
				config.nPlayInterval = i->playInterval;
				// add by ly@2018/07/30
				//config.nVolume = IS_DEBUG ? 0 : entity->m_defaultVolum;
				if (!entity->GetLocalVideoVolume(0, config.nVolume))
				{
					config.nVolume = entity->m_defaultVolum;
				}
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("config.nVolume=%d while play local video.", config.nVolume);
				config.nWndX = entity->m_mediaParam.nWndX;
				config.nWndY = entity->m_mediaParam.nWndY;
				config.nWndWidth = entity->m_mediaParam.nWndWidth;
				config.nWndHeight = entity->m_mediaParam.nWndHeight;
				strncpy_s(config.strRootPath, i->resourcePath.c_str(), sizeof(config.strRootPath));
				strncpy_s(config.strFileNames[0], i->videoNames.c_str(), 256);
				strncpy_s(config.strVideoRunTime_S, "09:00:00", sizeof(config.strVideoRunTime_S));
				strncpy_s(config.strVideoRunTime_E, "17:30:00", sizeof(config.strVideoRunTime_E));

				CSimpleStringA strVideoPath = config.strRootPath;
				CSimpleStringA strVideoFileName = config.strFileNames[0];
				CSimpleStringA strVideoFullPath = strVideoPath + strVideoFileName;
				BOOL bRet = IsFileExisted(strVideoFullPath.GetData());
				if (FALSE == bRet && false == entity->GetLocalLogFlag()){
					char strmsg[MAX_PATH] = {0};
					snprintf(strmsg, MAX_PATH, "adv video file %s not exist!", strVideoFullPath.GetData());
					LogWarn(Severity_Low, Error_Debug, LOG_EVT_ADV_VIDEO_NOT_EXIST, strmsg);
					entity->SetLocalLogFlag(true);
				}
				entity->m_pVideoPlayer[entity->m_mediaParam.nCfgInx]->PlayMedia(config);
				if (!entity->m_pVideoPlayer[entity->m_mediaParam.nCfgInx]->checkIsPlay(playThread))
				{
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Create play Video Media Thread Failed!");
					return 0;
				}
				WaitForSingleObject(playThread, INFINITE);
				if (entity->m_pVideoPlayer[entity->m_mediaParam.nCfgInx]->checkIsStop())
				{//ֹͣ����
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("stop play video");
					return 0;
				}
				else
					entity->m_pVideoPlayer[entity->m_mediaParam.nCfgInx]->Close();
			}
			else if ('P' == i->type)
			{//play Image
				CImgPlayConfig config;
				ZeroMemory(&config, sizeof(CImgPlayConfig));
				config.bFullScreen = IS_DEBUG ? false : i->fullScreen;
				config.bPrimMonitor = IS_DEBUG ? true : i->primMonitor;
				config.nFileCnt = 1;
				config.nPlayCnt = 1;
				config.nPlayInterval = i->playInterval;
				config.nWndX = entity->m_mediaParam.nWndX;
				config.nWndY = entity->m_mediaParam.nWndY;
				config.nWndWidth = entity->m_mediaParam.nWndWidth;
				config.nWndHeight = entity->m_mediaParam.nWndHeight;
				strncpy_s(config.strRootPath, i->resourcePath.c_str(), sizeof(config.strRootPath));
				strncpy_s(config.strFileNames[0], i->videoNames.c_str(), 256);
				CSimpleStringA strPicPath = config.strRootPath;
				CSimpleStringA strPicFileName = config.strFileNames[0];
				CSimpleStringA strPicFullPath = strPicPath + strPicFileName;
				BOOL bRet = IsFileExisted(strPicFullPath.GetData());
				if (FALSE == bRet && false == entity->GetLocalPicLogFlag()){
					char strmsg[MAX_PATH] = {0};
					snprintf(strmsg, MAX_PATH, "adv picture file %s not exist!", strPicFullPath.GetData());
					LogWarn(Severity_Low, Error_Debug, LOG_EVT_ADV_PIC_NOT_EXIST, strmsg);
					entity->SetLocalPicLogFlag(true);
				}
				entity->m_pImagePlayer[entity->m_mediaParam.nCfgInx]->PlayMedia(config);
				if (!entity->m_pImagePlayer[entity->m_mediaParam.nCfgInx]->checkIsPlay(playThread))
				{
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Create play Image Media Thread Failed!");
					return 0;
				}

				WaitForSingleObject(playThread, i->playInterval);
				if (entity->m_pImagePlayer[entity->m_mediaParam.nCfgInx]->checkIsStop())
				{//ֹͣ����
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("stop play Image");
					return 0;
				}
				else
					entity->m_pImagePlayer[entity->m_mediaParam.nCfgInx]->Close();
			}
		}
	}
	return 0;
}
#else
void* StartMediaPlayFunc(void* param)
{
	int iRet = -1;
	if (NULL == param){
		return (void*)&iRet;
	}
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Enter Media Play Function.");

	CLocalMediaPlayEntity* entity = (CLocalMediaPlayEntity*)param;
	while (entity->GetPlayFlag())
	{
		rvcResourceParse_t ResourceList[MAX_LOCAL_MEDIAS] = { 0 };
		size_t uCount = entity->m_mediaManage.GetPlayListByLocal(ResourceList, MAX_LOCAL_MEDIAS);
		unsigned int ustart_time = y2k_time_now();

		if (0 == uCount){
			int64_t playThreadId  = 0;
			CMediaPlayConfig config = {0};
			memcpy(&config, &(entity->m_Videos[entity->m_mediaParam.nCfgInx]), sizeof(CMediaPlayConfig));
			config.nPlayCnt = 1;	//can be change 
			config.eMode = LOCALVIDEO;
			config.nWndX = entity->m_mediaParam.nWndX;
			config.nWndY = entity->m_mediaParam.nWndY;
			config.nWndWidth = entity->m_mediaParam.nWndWidth;
			config.nWndHeight = entity->m_mediaParam.nWndHeight;
			if (IS_DEBUG){
				config.bFullScreen = false;
				config.bPrimMonitor = true;
			}

			if (!entity->GetLocalVideoVolume(0, config.nVolume)){
				config.nVolume = entity->m_defaultVolum;
			}
			
			struct tm* ptm = NULL;
			time_t t = time(NULL);
			ptm = localtime(&t);
			TCHAR strNow[TIME_LEN] = {0};
			sprintf(strNow, "%02d:%02d:%02d", ptm->tm_hour, ptm->tm_min, ptm->tm_sec);
			if (strcmp(strNow, config.strVideoRunTime_S) < 0 || strcmp(strNow, config.strVideoRunTime_E) >= 0){
				Sleep(10000);
				continue;
			}
			if (-1 == entity->m_pMediaPlayer[entity->m_mediaParam.nCfgInx]->PlayMedia(config)){
				Sleep(30*DEFAULT_SLEEP_TIME);
			}
			Sleep(800);
		}

		for (int i = 0; i < uCount && i < MAX_LOCAL_MEDIAS && entity->GetPlayFlag(); i++)
		{
			//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("ResourceList[%d] address is 0x%0x", i, ResourceList[i]);
			int64_t playThreadId = 0;
			rvcResourceParse_t item = ResourceList[i];
			//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("begin play extend %c:%s, %s", item.type, item.strResourcePath, item.strvideoNames);
			if ('V' == item.type)
			{//video
				CMediaPlayConfig config = {0};
				config.bFullScreen = IS_DEBUG ? false : item.fullScreen;
				config.bPrimMonitor = IS_DEBUG ? true : item.primMonitor;
				config.bSimpleMode = item.simpleMode;
				config.eMode = LOCALVIDEO;
				config.nFileCnt = 1;
				config.nPlayCnt = 1;
				config.nPlayInterval = item.playInterval;
				// add by ly@2018/07/30
				//config.nVolume = IS_DEBUG ? 0 : entity->m_defaultVolum;
				if (!entity->GetLocalVideoVolume(0, config.nVolume)){
					config.nVolume = entity->m_defaultVolum;
				}
				
				//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("config.nVolume=%d while play local video.", config.nVolume);
				config.nWndX = entity->m_mediaParam.nWndX;
				config.nWndY = entity->m_mediaParam.nWndY;
				config.nWndWidth = entity->m_mediaParam.nWndWidth;
				config.nWndHeight = entity->m_mediaParam.nWndHeight;
				strncpy(config.strRootPath, item.strResourcePath, strlen(item.strResourcePath));
				strncpy(config.strFileNames[0], item.strvideoNames, strlen(item.strvideoNames));
				strncpy(config.strVideoRunTime_S, "09:00:00", sizeof(config.strVideoRunTime_S));
				strncpy(config.strVideoRunTime_E, "17:30:00", sizeof(config.strVideoRunTime_E));
				int iPlayRet = entity->m_pMediaPlayer[entity->m_mediaParam.nCfgInx]->PlayMedia(config);
				if (-2 == iPlayRet){
					Sleep(DEFAULT_SLEEP_TIME);
					continue;
				}
				if (-3 == iPlayRet) {
					Sleep(DEFAULT_SLEEP_TIME/6);
				}
				Sleep(800);
			}
			else if ('P' == item.type)
			{//play Image
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Begin new Image play, entity->m_mediaParam.nCfgInx = %d.", entity->m_mediaParam.nCfgInx);
				CPicPlayConfig config = {0};
				config.bFullScreen = IS_DEBUG ? false : item.fullScreen;
				config.bPrimMonitor = IS_DEBUG ? true : item.primMonitor;
				config.nFileCnt = 1;
				config.nPlayCnt = 1;
				config.nPlayInterval = item.playInterval;
				config.nWndX = entity->m_mediaParam.nWndX;
				config.nWndY = entity->m_mediaParam.nWndY;
				config.nWndWidth = entity->m_mediaParam.nWndWidth;
				config.nWndHeight = entity->m_mediaParam.nWndHeight;
				strncpy(config.strRootPath, item.strResourcePath, strlen(item.strResourcePath));
				strncpy(config.strFileNames[0], item.strvideoNames, strlen(item.strvideoNames));
				if (entity->m_pPicturePlayer[entity->m_mediaParam.nCfgInx]->checkIsStop()){
					entity->m_pPicturePlayer[entity->m_mediaParam.nCfgInx]->PlayMedia(config);
					if (!entity->m_pPicturePlayer[entity->m_mediaParam.nCfgInx]->checkIsPlay(&playThreadId)) {
						DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Create play Image Media Thread Failed!");
						iRet = -1;
						return (void*)& iRet;
					}
					else {
						DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Image Media Player Thread id is %u.", playThreadId);
					}
					if (0 == pthread_join(playThreadId, NULL)) {
						DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("pthread join thread id %u success.", playThreadId);
						iRet = 0;
					}
					else {
						DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("pthread join thread id %u failed for %s.", playThreadId, strerror(errno));
						iRet = -1;
					}
				}
				Sleep(100);
			}
		}
		unsigned int uend_time = y2k_time_now();
		//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("uend_time - ustart_time = %u.", uend_time - ustart_time);
		if (uend_time - ustart_time < RVC_MIN_LOCALPLAYER_TIME) {
			Sleep(30*DEFAULT_SLEEP_TIME);
		}
	}
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Leave Media Play Function.");
	entity->m_uMediaPlayThreadId = 0;
	return (void*)&iRet;
}

#endif // RVC_OS_WIN

void* StartNoticePlayThreadFunc(void* param)
{
	int iRet = -1;
	CLocalMediaPlayEntity* entity = (CLocalMediaPlayEntity*)param;
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Enter NoticePlayThreadFunc");
	const char* pVideoName = entity->m_lastPlayVideo.c_str();
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Begin Start Notice Play, and Video Notice Info is %s.", pVideoName);
	
	Clibmediaplayer* player = entity->m_pMediaPlayer[entity->m_mediaParam.nCfgInx];
	player->PlayVideoNotice(entity->m_mediaParam.nWndX, entity->m_mediaParam.nWndY, entity->m_mediaParam.nWndWidth, entity->m_mediaParam.nWndHeight, pVideoName);
	
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Succeed to Start Notice Play, and Video Notice Info is %s.", pVideoName);
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Leave NoticePlayThreadFunc");
	entity->m_uNoticePlayThreadId = 0;

	iRet = 0;

	return (void*)& iRet;
}


void CLocalMediaPlayEntity::StartVideo(int nCfgInx, int nWndX, int nWndY, int nWndWidth, int nWndHeight)
{
	if (nCfgInx >= MAX_PLAY_CHANNELS || nCfgInx < 0)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Invalid CfgInx while StartVideo!");
		return;
	}
	
	m_mediaParam.nCfgInx = nCfgInx;
	m_mediaParam.nWndX = nWndX;
	m_mediaParam.nWndY = nWndY;
	m_mediaParam.nWndWidth = nWndWidth;
	m_mediaParam.nWndHeight = nWndHeight;

#ifdef RVC_OS_WIN	// RVC_OS_WIN
	if (NULL != m_playThread)
	{
		WaitForSingleObject(m_playThread, 5000);
		m_playThread = NULL;
	}
	if (NULL == m_playThread)
		m_playThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)& MediaPlayThread, this, 0, NULL);
#else
	m_badplayflag = true;
	int err = pthread_create(&m_uMediaPlayThreadId, NULL, StartMediaPlayFunc, this);
	if (0 == err) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("create media play thread[%u] success.", m_uMediaPlayThreadId);
	}
	else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("create media play thread failed.");
	}

#endif 
}

void CLocalMediaPlayEntity::StartAudio(const char *pAudioNames)
{
#ifdef RVC_OS_WIN
	static HANDLE audioPlayThread = NULL;
	if (audioPlayThread)//�ر����ڲ��ŵ���Ƶ
	{
		DWORD exitCode = 0;
		if (WAIT_TIMEOUT == WaitForSingleObject(audioPlayThread, 50))
		{
			TerminateThread(audioPlayThread, exitCode);
			m_pAudioPlayer->Close();
		}
		audioPlayThread = NULL;
	}

	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Begin StartAudio, and Audio Info is %s.", pAudioNames);
	m_pAudioPlayer->PlayLocalAudio(pAudioNames);
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Succeed to StartAudio, and Audio Info is %s.", pAudioNames);

	auto audioRet = GetLocalAudioVolume();
	m_pAudioPlayer->SetVolume(audioRet.second);
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Succeed to set audio volume %d!", audioRet.second);

	m_lastPlayAudio = pAudioNames;
	audioPlayThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)& CheckAudioThread, this, 0, NULL);
#else

	if (m_pMediaAudioPlayer->checkIsPlay()) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("current is playing, close it.");
		if (0 != m_uMediaPlayThreadId){
			m_pMediaAudioPlayer->Close();
			m_uMediaPlayThreadId = 0;
			Sleep(500);
		}
	}

	m_lastPlayAudio = pAudioNames;

	int err = pthread_create(&m_uMediaPlayThreadId, NULL, StartAudioPlayingThreadFunc, this);
	if (0 == err) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("create audio play thread[%u] success.", m_uMediaPlayThreadId);
	}
	else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("create audio play thread failed.");
	}

	m_buserstopaudio = false;

	auto audioRet = GetLocalAudioVolume();
	m_pMediaAudioPlayer->SetVolume(audioRet.second);
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Succeed to set audio volume %d!", audioRet.second);
	
#endif // RVC_OS_WIN
}

void CLocalMediaPlayEntity::StartImage(int nCfgInx, int nWndX, int nWndY, int nWndWidth, int nWndHeight)
{
	if (nCfgInx >= MAX_PLAY_CHANNELS || nCfgInx < 0)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Invalid CfgInx while StartImage!");
		return;
	}

#ifdef RVC_OS_WIN
	m_pImagePlayer[nCfgInx]->Play(nCfgInx, nWndX, nWndY, nWndWidth, nWndHeight);
#else
	m_pPicturePlayer[nCfgInx]->Play(nCfgInx, nWndX, nWndY, nWndWidth, nWndHeight);
#endif // RVC_OS_WIN

	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Succeed to StartImage!");
}


void CLocalMediaPlayEntity::StopVideo(int nCfgInx)
{
	if (nCfgInx >= MAX_PLAY_CHANNELS || nCfgInx < 0)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Invalid CfgInx while StopVideo!");
		return;
	}

#ifdef RVC_OS_WIN
	m_pVideoPlayer[nCfgInx]->Close();
	m_pImagePlayer[nCfgInx]->Close();
	if (m_playThread)
	{
		TerminateThread(m_playThread, -1);
		m_playThread = NULL;
	}
#else
	m_pMediaPlayer[nCfgInx]->Close();
	m_pPicturePlayer[nCfgInx]->Close();
	m_badplayflag = false;

#endif // RVC_OS_WIN

	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Succeed to StopVideo!");
}

void CLocalMediaPlayEntity::StopAudio()
{
#ifdef RVC_OS_WIN
	m_pAudioPlayer->Close();
#else
	m_pMediaAudioPlayer->Close();
	m_buserstopaudio = true;
#endif
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Succeed to StopAudio!");
}

void CLocalMediaPlayEntity::StopImage(int nCfgInx)
{
	if (nCfgInx >= MAX_PLAY_CHANNELS || nCfgInx < 0)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Invalid CfgInx while StopImage!");
		return;
	}

#ifdef RVC_OS_WIN
	m_pImagePlayer[nCfgInx]->Close();
#else
	m_pPicturePlayer[nCfgInx]->Close();
#endif // RVC_OS_WIN

	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Succeed to StopImage!");
}

void CLocalMediaPlayEntity::StopAll()
{
	StopAudio(); // �ر���Ƶ
	for (int i = 0; i < MAX_PLAY_CHANNELS; ++i)
	{
		StopVideo(i); // �ر���Ƶ
		StopImage(i); // �ر�ͼ��
	}
}

bool CLocalMediaPlayEntity::GetLocalVideoVolume(int nCfgInx, int &nVolume)
{
	//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("get local video volume req.");
	CSmartPointer<IConfigInfo> spConfig;
	ErrorCodeEnum Error = GetFunction()->OpenConfig(Config_Run, spConfig);
	if (Error == Error_Succeed)
	{
		Error = spConfig->ReadConfigValueInt("LocalVideo", "Volume", nVolume);
		if (Error == Error_Succeed && nVolume >= 0 && nVolume <= 100)
		{
			//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("succeed to get local video volume with nCfgInx:%d, nVolume:%d", nCfgInx, nVolume);
			return true;
		}
	}

	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("fail to get local video volume!");
	return false;
}

std::pair<bool, int> CLocalMediaPlayEntity::GetLocalAudioVolume()
{
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("get local audio volume req.");
	CSmartPointer<IConfigInfo> spConfig;
	int nVolume = 0;
	ErrorCodeEnum Error = GetFunction()->OpenConfig(Config_Run, spConfig);
	if (Error == Error_Succeed)
	{
		Error = spConfig->ReadConfigValueInt("LocalAudio", "Volume", nVolume);
		//if (nVolume == 0)
		//{
		//	nVolume = 50;
		//	spConfig->WriteConfigValueInt("LocalAudio", "Volume", nVolume);
		//	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("read nVolume 0, set default 50");
		//}
		if (Error == Error_Succeed && nVolume >= 0 && nVolume <= 100)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("succeed to get local audio volume with nVolume:%d", nVolume);
			return std::make_pair(true, nVolume);
		}
	}

	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("fail to get local audio volume!");
	return std::make_pair(false, nVolume);
}


bool CLocalMediaPlayEntity::SetLocalAudioVolume(int nVolume)
{
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("set local video audio req.");
	if (nVolume < 0 || nVolume > 100)
	{
		return false;
	}
	CSmartPointer<IConfigInfo> spConfig;
	ErrorCodeEnum Error = GetFunction()->OpenConfig(Config_Run, spConfig);
	if (Error == Error_Succeed)
	{
		Error = spConfig->WriteConfigValueInt("LocalAudio", "Volume", nVolume);
		if (Error == Error_Succeed)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("succeed to set local audio volume with nVolume:%d!", nVolume);
#ifdef RVC_OS_WIN
			m_pAudioPlayer->SetVolume(nVolume);
#else
			m_pMediaAudioPlayer->SetVolume(nVolume);
#endif // RVC_OS_WIN
			return true;
		}
	}

	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("fail to set local video volume!");
	return false;
}

bool CLocalMediaPlayEntity::SetLocalVideoVolume(int nCfgInx, int nVolume)
{
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("set local video volume req.");
	if (nVolume < 0 || nVolume > 100)
	{
		return false;
	}
	CSmartPointer<IConfigInfo> spConfig;
	ErrorCodeEnum Error = GetFunction()->OpenConfig(Config_Run, spConfig);
	if (Error == Error_Succeed)
	{
		Error = spConfig->WriteConfigValueInt("LocalVideo", "Volume", nVolume);
		if (Error == Error_Succeed)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("succeed to set local video volume with nCfgInx:%d, nVolume:%d!", nCfgInx, nVolume);
			for (int i = 0; i < MAX_PLAY_CHANNELS; ++i)
			{
#ifdef RVC_OS_WIN
				m_pVideoPlayer[i]->SetVolume(nVolume);
#else
				m_pMediaPlayer[i]->SetVolume(nVolume);
#endif
			}
			return true;
		}
	}

	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("fail to set local video volume!");
	return false;
}

bool CLocalMediaPlayEntity::IsRunConfigExist()
{
	CSimpleStringA strPath;
	ErrorCodeEnum eErr;

	if ((eErr = GetFunction()->GetPath("RunInfo", strPath)) != Error_Succeed)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("get runinfo path failed(%d)", eErr);
		return false;
	}

#ifdef RVC_OS_WIN
	CSimpleStringA strRuninfoFile;
	strRuninfoFile = CSimpleStringA::Format("%s\\runcfg\\%s.ini", (LPCTSTR)strPath, GetEntityName());
	WIN32_FIND_DATA  findData;
	if (FindFirstFileA((LPCTSTR)strRuninfoFile, &findData) != INVALID_HANDLE_VALUE) return true;
	return false;
#else
	CSimpleStringA strRuninfoFile;
	strRuninfoFile = CSimpleStringA::Format("%s" SPLIT_SLASH_STR "runcfg" SPLIT_SLASH_STR "%s.ini", (LPCTSTR)strPath, GetEntityName());
	if (ExistsFileA(strRuninfoFile)) {
		return true;
	}
	else{
		return false;
	}
#endif // RVC_OS_WIN
}

void CLocalMediaPlayEntity::OnSelfTest(EntityTestEnum eTestType, CSmartPointer<ITransactionContext> pTransactionContext)
{
	if (Test_ShakeHand == eTestType)
	{
		pTransactionContext->SendAnswer(Error_Succeed);
	}
}

void CLocalMediaPlayEntity::CStringSplit(char *str, char **result, const char *del)
{
	char* ptr = NULL;
	char* p = strtok_r(str, del, &ptr);
	while (p != NULL)
	{
		*result++ = p;
		p = strtok_r(NULL, del, &ptr);
	}
}

ErrorCodeEnum CLocalMediaPlayEntity::StartNotice(int nCfgInx, int nWndX, int nWndY, int nWndWidth, int nWndHeight, const char* pVideoName)
{
	ErrorCodeEnum Error = Error_Succeed;
	if (eStand2sType == m_eDeviceType || eDesk2SType == m_eDeviceType || eMobilePadType == m_eDeviceType || ePadtype == m_eDeviceType) {
		if (nCfgInx >= MAX_PLAY_CHANNELS || nCfgInx < 0 || NULL == pVideoName){
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Invalid param CfgInx or video name while StartNotice!");
			return Error_Param;
		}

		if (m_pMediaAudioPlayer->checkIsPlay()) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("audio current is playing, close it.");
			if (0 != m_uMediaPlayThreadId) {
				m_pMediaAudioPlayer->Close();
				m_uMediaPlayThreadId = 0;
				Sleep(500);
			}
		}

		if (m_pMediaPlayer[nCfgInx]->checkIsPlay()) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("video current is playing, close it.");
			if (0 != m_uNoticePlayThreadId) {
				m_pMediaPlayer[nCfgInx]->Close();
				m_uNoticePlayThreadId = 0;
				Sleep(500);
			}
		}

		m_mediaParam.nCfgInx = nCfgInx;
		m_mediaParam.nWndX = 1280;
		m_mediaParam.nWndY = 0;
		m_mediaParam.nWndWidth = nWndWidth;
		m_mediaParam.nWndHeight = nWndHeight;

		CSimpleStringA strPath = DEFAULT_RESOURSE_PATH;
		if (!ExistsDir(strPath.GetData())) {
			strPath = DEFAULT_RESOURSE_PATH_C;
		}
		CSimpleStringA VideoPath = strPath + SPLIT_SLASH_STR;
		CSimpleStringA strNoticeFileName = VideoPath + CSimpleStringA(pVideoName);
		BOOL bRet = ExistsFile(strNoticeFileName.GetData());
		if (bRet) {
			int iVolume = 60;
			GetLocalVideoVolume(nCfgInx, iVolume);
			m_pMediaPlayer[nCfgInx]->SetVolume(iVolume);
			m_lastPlayVideo = strNoticeFileName.GetData();

			int err = pthread_create(&m_uNoticePlayThreadId, NULL, StartNoticePlayThreadFunc, this);
			if (0 == err) {
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("create notice play thread[%u] success.", m_uNoticePlayThreadId);
				char strinfo[MAX_PATH] = { 0 };
				snprintf(strinfo, MAX_PATH, "start play video notice %s", strNoticeFileName.GetData());
				LogWarn(Severity_Low, Error_Debug, LOG_EVT_START_NOTICE_PLAY, strinfo);
			}
			else {
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("create notice play thread failed.");
			}
		}
		else {
			Error = Error_InvalidState;
			char strmsg[MAX_PATH] = { 0 };
			snprintf(strmsg, MAX_PATH, "play notice failed for %s not exist!", strNoticeFileName.GetData());
			LogWarn(Severity_Low, Error_Debug, LOG_EVT_NOTICE_FILE_NOT_EXIST, strmsg);
		}
	}
	
	return Error;
}


ErrorCodeEnum CLocalMediaPlayEntity::StopNotice(int nCfgInx)
{
	ErrorCodeEnum ErrorCode = Error_Succeed;

	if (eStand2sType == m_eDeviceType || eDesk2SType == m_eDeviceType || eMobilePadType == m_eDeviceType || ePadtype == m_eDeviceType) {
		if (nCfgInx >= MAX_PLAY_CHANNELS || nCfgInx < 0) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Invalid CfgInx while StopNotice!");
			return Error_Param;
		}

		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("m_pPlayer = 0x%08x while play!", m_pMediaPlayer[nCfgInx]);
		m_pMediaPlayer[nCfgInx]->Close();

		if (m_uNoticePlayThreadId > 0){
			if (0 == pthread_join(m_uNoticePlayThreadId, NULL)) {
				if (m_lastPlayVideo.length() > 0) {
					char strmsg[MAX_PATH] = { 0 };
					snprintf(strmsg, MAX_PATH, "%s%s", "success to stop play notice ", m_lastPlayVideo.c_str());
					LogWarn(Severity_Low, Error_Debug, LOG_EVT_STOP_NOTICE_PLAY, strmsg);
				}
			}
			m_uNoticePlayThreadId = 0;
		}
	}

	return ErrorCode;
}


ErrorCodeEnum CLocalMediaPlayEntity::StopPlayAllMedias()
{
	ErrorCodeEnum ErrorCode = Error_Succeed;

	StopAll();

	return ErrorCode;
}

DeviceTypeEnum CLocalMediaPlayEntity::RvcGetDeviceType()
{
	DeviceTypeEnum eType = eStand2sType;
	CSmartPointer<IEntityFunction> spFunction = GetFunction();
	CSystemStaticInfo stStaticinfo;
	spFunction->GetSystemStaticInfo(stStaticinfo);
	if (_stricmp(stStaticinfo.strMachineType, "RVC.Stand1SPlus") == 0) {
		eType = eStand1SPlusType;
	}
	else if (stricmp(stStaticinfo.strMachineType, "RVC.PAD") == 0) {
		if (stricmp(stStaticinfo.strSite, "CMB.FLB") == 0) {
			eType = eMobilePadType;
		}
		else {
			eType = ePadtype;
		}
	}
	else if (stricmp(stStaticinfo.strMachineType, "RVC.Desk2S") == 0) {
		eType = eDesk2SType;
	}
	else if (stricmp(stStaticinfo.strMachineType, "RPM.Stand1S") == 0) {
		eType = eRpm1sType;
	}
	else if (stricmp(stStaticinfo.strMachineType, "RVC.Desk1S") == 0) {
		eType = eDesk1SType;
	}
	else {
		eType = eStand2sType;
	}

	if (eType >= 0 && eType < sizeof(Device_Type_Table) / sizeof(char*)) {
		LOG_TRACE("device type is %s.", Device_Type_Table[eType]);
	}

	return eType;
}

ErrorCodeEnum CLocalMediaPlayEntity::GetPcmRecordFlag()
{
	CSmartPointer<IConfigInfo> spConfig;
	SpIniMappingTable table;
	ErrorCodeEnum Error = GetFunction()->OpenConfig(Config_CenterSetting, spConfig);
	if (Error == Error_Succeed){
		table.AddEntryBoolean("SalesRecorder", "IsRecordPCM", m_bRecordPCM, false);
		Error = table.Load(spConfig);
	}
	
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("record pcm flag is %s.", m_bRecordPCM ? "true" : "false");

	return Error;
}


ErrorCodeEnum CLocalMediaPlayEntity::HandleRemoteRecord(const char* pszMessage)
{
	ErrorCodeEnum Error = Error_Succeed;
	m_bStartRecord = true;
	memset(m_audiobuffer, 0, RVC_AUDIO_LEN);
	m_leftlen = 0;
	m_remote_audio_queue = new Clibaudioqueue(REC_COMMON_REMOTEAUDIO_SHM_QUEUE);
	m_iseriesnumber = 0;
	m_bloged = false;

	if (true == m_bRecordPCM){
		char strSwiftName[MAX_PATH] = { 0 };
		if (NULL != pszMessage) {
			size_t ulen = strlen(pszMessage);
			char* tmp = new char[ulen + 1];
			memset(tmp, 0, ulen + 1);
			memcpy(tmp, pszMessage, ulen);

			char* result[16] = { 0 };
			auto arr1 = CSimpleStringA2W(tmp).Split('@');
			auto arr2 = CAutoArray<CSimpleStringA>(arr1.GetCount());
			for (int i = 0; i < arr1.GetCount(); ++i) {
				arr2[i] = CSimpleStringW2A(arr1[i]);
				result[i] = const_cast<LPSTR>(arr2[i].GetData());
			}
			if (arr1.GetCount() > 4) {
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("record swift number is %s.", result[4]);
				snprintf(strSwiftName, MAX_PATH, "%s", result[4]);
			}
			delete tmp;
			tmp = NULL;
		}

		char strName[MAX_PATH] = { 0 };
		CSimpleStringA strTempDir;
		if (Error_Succeed == GetFunction()->GetPath("Temp", strTempDir)) {
			snprintf(strName, MAX_PATH, "%s/remote_audio_notice_%s.pcm", strTempDir.GetData(), strSwiftName);
		}
		else {
			snprintf(strName, MAX_PATH, "remote_audio_notice_%s.pcm", strSwiftName);
		}

		m_pFile = fopen(strName, "wb+");
		if (NULL != m_pFile) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("fopen %s success.", strName);
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("fopen %s failed.", strName);
		}
	}

	return Error;
}


void CLocalMediaPlaySession::Handle_StartPlayVideo(SpReqAnsContext<PlayService_StartPlayVideo_Req, PlayService_StartPlayVideo_Ans>::Pointer ctx)
{
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("start play Video, Index:%d, WndX:%d, WndY:%d, WndWidth:%d, WndWidth:%d", ctx->Req.CfgInx, ctx->Req.WndX, ctx->Req.WndY, ctx->Req.WndWidth, ctx->Req.WndHeight);
	
	CSimpleStringA UpdateState = "";
	ErrorCodeEnum Error = m_pEntity->GetFunction()->GetSysVar("UpdateState", UpdateState);
	if (Error == Error_Succeed && "1" == UpdateState)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("detect current is upgrade, do not play the media");
		ctx->Answer(Error_Stoped);
		m_pEntity->StopAll();
		return;
	}
	
	m_pEntity->StartVideo(ctx->Req.CfgInx, ctx->Req.WndX, ctx->Req.WndY, ctx->Req.WndWidth, ctx->Req.WndHeight);
	ctx->Answer(Error_Succeed);
}

void CLocalMediaPlaySession::Handle_StartPlayAudio(SpReqAnsContext<PlayService_StartPlayAudio_Req, PlayService_StartPlayAudio_Ans>::Pointer ctx)
{
	CSimpleStringA AudioNames = CSimpleStringW2A(ctx->Req.AudioNames);
	CSimpleStringA UpdateState = "";
	ErrorCodeEnum Error = m_pEntity->GetFunction()->GetSysVar("UpdateState", UpdateState);
	if (Error == Error_Succeed && "1" == UpdateState)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("detect current is upgrade, do not play the media");
		ctx->Answer(Error_Stoped);
		m_pEntity->StopAll();
		return;
	}

	m_pEntity->StartAudio(AudioNames.GetData());
	ctx->Answer(Error_Succeed);
}

void CLocalMediaPlaySession::Handle_StartPlayImage(SpReqAnsContext<PlayService_StartPlayImage_Req, PlayService_StartPlayImage_Ans>::Pointer ctx)
{
	m_pEntity->StartImage(ctx->Req.CfgInx, ctx->Req.WndX, ctx->Req.WndY, ctx->Req.WndWidth, ctx->Req.WndHeight);
	ctx->Answer(Error_Succeed);
}

void CLocalMediaPlaySession::Handle_StopPlayVideo(SpReqAnsContext<PlayService_StopPlayVideo_Req, PlayService_StopPlayVideo_Ans>::Pointer ctx)
{
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("stop play Video, Index:%d", ctx->Req.CfgInx);
	m_pEntity->StopVideo(ctx->Req.CfgInx);
	ctx->Answer(Error_Succeed);
}

void CLocalMediaPlaySession::Handle_StopPlayAudio(SpReqAnsContext<PlayService_StopPlayAudio_Req, PlayService_StopPlayAudio_Ans>::Pointer ctx)
{
	m_pEntity->StopAudio();
	ctx->Answer(Error_Succeed);
}

void CLocalMediaPlaySession::Handle_StopPlayImage(SpReqAnsContext<PlayService_StopPlayImage_Req, PlayService_StopPlayImage_Ans>::Pointer ctx)
{
	m_pEntity->StopImage(ctx->Req.CfgInx);
	ctx->Answer(Error_Succeed);
}

void CLocalMediaPlaySession::OnClose(ErrorCodeEnum)
{
	LOG_FUNCTION();
}

void CLocalMediaPlaySession::Handle_GetLocalVideoVolume( SpReqAnsContext<PlayService_GetLocalVideoVolume_Req, PlayService_GetLocalVideoVolume_Ans>::Pointer ctx )
{
	int volume = 0;
	if (m_pEntity->GetLocalVideoVolume(ctx->Req.CfgInx, volume))
	{
		ctx->Ans.Volume = volume;
		ctx->Answer(Error_Succeed);
	}
	else
	{
		ctx->Answer(Error_Unexpect);
	}
}

void CLocalMediaPlaySession::Handle_SetLocalVideoVolume( SpReqAnsContext<PlayService_SetLocalVideoVolume_Req, PlayService_SetLocalVideoVolume_Ans>::Pointer ctx )
{
	if (m_pEntity->SetLocalVideoVolume(ctx->Req.CfgInx, ctx->Req.Volume))
	{
		ctx->Answer(Error_Succeed);
	}
	else
	{
		ctx->Answer(Error_Unexpect);
	}
}


void CLocalMediaPlaySession::Handle_GetLocalAudioVolume(SpReqAnsContext<PlayService_GetLocalAudioVolume_Req, PlayService_GetLocalAudioVolume_Ans>::Pointer ctx)
{
	auto audioRet = m_pEntity->GetLocalAudioVolume();
	if (audioRet.first)
	{
		ctx->Ans.Volume = audioRet.second;
		ctx->Answer(Error_Succeed);
	}
	else
	{
		ctx->Answer(Error_Unexpect);
	}
}

void CLocalMediaPlaySession::Handle_SetLocalAudioVolume(SpReqAnsContext<PlayService_SetLocalAudioVolume_Req, PlayService_SetLocalAudioVolume_Ans>::Pointer ctx)
{
	if (m_pEntity->SetLocalAudioVolume(ctx->Req.Volume))
	{
		ctx->Answer(Error_Succeed);
	}
	else
	{
		ctx->Answer(Error_Unexpect);
	}
}

void CLocalMediaPlaySession::Handle_StartPlayNotice(SpReqAnsContext<PlayService_StartPlayNotice_Req, PlayService_StartPlayNotice_Ans>::Pointer ctx)
{
	CSimpleStringA UpdateState = "";
	ErrorCodeEnum Error = m_pEntity->GetFunction()->GetSysVar("UpdateState", UpdateState);
	if (Error == Error_Succeed && "1" == UpdateState) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("detect current is upgrade, do not play the media");
		ctx->Answer(Error_Stoped);
		m_pEntity->StopAll();
		return;
	}

	CSimpleStringA VideoName = CSimpleStringW2A(ctx->Req.VideoName);
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("start play notice, CfgInx = %d, WndX = %d, WndY = %d, WndWidth = %d, WndHeight = %d, and video name is %s.", ctx->Req.CfgInx, ctx->Req.WndX, ctx->Req.WndY, ctx->Req.WndWidth, ctx->Req.WndHeight, VideoName.GetData());
	Error = m_pEntity->StartNotice(ctx->Req.CfgInx, ctx->Req.WndX, ctx->Req.WndY, ctx->Req.WndWidth, ctx->Req.WndHeight, VideoName.GetData());
	ctx->Answer(Error);
}

void CLocalMediaPlaySession::Handle_StopPlayNotice(SpReqAnsContext<PlayService_StopPlayNotice_Req, PlayService_StopPlayNotice_Ans>::Pointer ctx)
{
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("stop play notice, Index:%d", ctx->Req.CfgInx);
	ErrorCodeEnum Error = m_pEntity->StopNotice(ctx->Req.CfgInx);
	ctx->Answer(Error);
}


void CLocalMediaPlaySession::Handle_StopPlayAllMedias(SpReqAnsContext<PlayService_StopPlayAllMedias_Req, PlayService_StopPlayAllMedias_Ans>::Pointer ctx)
{
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("stop play all medias");
	ErrorCodeEnum Error = m_pEntity->StopPlayAllMedias();
	ctx->Answer(Error);
}

SP_BEGIN_ENTITY_MAP()
	SP_ENTITY(CLocalMediaPlayEntity)
SP_END_ENTITY_MAP()