myvtm/Module/mod_SalesRecorder/mod_SalesRecorder.cpp

#include "stdafx.h"
#include "mod_SalesRecorder.h"
#include "Event.h"
#include "rvcmediacommon/rvc_media_common.h"
#include "fileutil.h"
#include "array.h"
#include <memutil.h>
#include <algorithm>
#ifdef RVC_OS_WIN
#include <Windows.h>
#endif 

#include "mod_customeraware/Event.h"
#include "mod_facetracking/sysvar.h"

#include <assert.h>

#include "EventCode.h"
#include <string.h>

#include "mod_interactivecontrol/InteractiveControl_client_g.h"
#include "mod_interactivecontrol/InteractiveControl_def_g.h"
#include "../mod_interactivecontrol/Event.h"


#ifndef RVC_MIN_FILESIZE
#define RVC_MIN_FILESIZE 10240
#endif


#define SYSVAR_CALLTYPE	"CallType"
#define CALLTYPE_NORMAL 'N'          // 呼叫类型，普通模式
#define CALLTYPE_MOBILE	'M'          // 呼叫类型，手机模式

#define MAX_DISK_PERCENT	95      // 磁盘最大占用百分比

static const char* record_failed_case_table[] = {
	"[RTA3L01] 启动录像失败，初始化失败",
	"[RTA3L02] 启动录像失败，字体为空，添加水印失败",
	"[RTA3L03] 开始录像失败，请稍后(约30秒)再试",
	"[RTA3L04] 录像失败，摄像头故障，获取不到视频，请联系厂商进行维修",
	"[RTA3L05] 录像失败，获取不到远端音频，请检查风险提示音是否正常播放且音量大小是否正常",
	"[RTA3L06] 录像失败，麦克风故障，获取不到本地音频，请联系厂商进行维修",
	"[RTA3L07] 录像失败，系统不支持当前音频采样率",
	"[RTA3L08] 录像失败，音频流写入失败，请稍后(约30秒)再试",
	"[RTA3L09] 录像失败，获取不到远端视频，请稍后(约30秒)再试"
};


static BOOL CheckDiskStatus(const char *szRoot, int nPercent, int *pFreeRatio)
{
#ifdef RVC_OS_WIN
	_ULARGE_INTEGER lpFreeBytesAvailableToCaller = {}, lpTotalNumberOfBytes = {}, lpTotalNumberOfFreeBytes = {};
	BOOL ret = GetDiskFreeSpaceEx(szRoot, &lpFreeBytesAvailableToCaller, &lpTotalNumberOfBytes, &lpTotalNumberOfFreeBytes);
	if (ret == 0)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("CheckDiskStatus.GetDiskFreeSpaceEx failed(%d).",GetLastError());
		return FALSE;
	}
	DWORD dwTotal = lpTotalNumberOfBytes.QuadPart/1048576;
	DWORD dwTotalFree = lpTotalNumberOfFreeBytes.QuadPart/1048576;
	int ratio = dwTotalFree*100/dwTotal;
	*pFreeRatio = ratio;
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("free disk %d MB, %d percent free.\n", dwTotalFree, ratio);
	//if (ratio < (100-MAX_DISK_PERCENT))
	if (ratio < (100-nPercent))
	{
		return FALSE;
	}
	return TRUE;
#else
	//todo 调用resourcewatcher
	return TRUE;
#endif

}


static int hch2int(char hch)
{
	if (hch >= '0' && hch <= '9')
		return hch-'0';
	else if (hch >= 'a' && hch <= 'f')
		return hch-'a'+10;
	else if (hch >= 'A' && hch <= 'F')
		return hch-'A'+10;

	return 0;
}

static long hexstr2int(const char *str, int len)
{
	long result = 0;
	if (str && len <= strlen(str)) {
		for (int i = 0; i < len; ++i) {
			result += (hch2int(str[i]) << ((len-i-1) << 2));
		}
	}
	return result;
}

static CSimpleStringA VideoSerialID2TimeString(const char *videoserialid)
{
	DWORD nTimeTicks = hexstr2int(videoserialid,8);
	return ((CSmallDateTime)nTimeTicks).ToTimeString();
}


static void 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);
	}
}

#ifdef RVC_OS_WIN
// 寻找某目录下与通配符匹配的文件
static BOOL FindMatchedFile(LPCSTR sFindPath, LPCSTR sFindFileName, ULONGLONG& uCountFile)
{
	char sPath[MAX_PATH];
	ZeroMemory(sPath, MAX_PATH);
	char sFormatFileName[MAX_PATH + 2] = "*";
	WIN32_FIND_DATA FindFileData;
	HANDLE hFind;
	BOOL fFinished = FALSE;

	strcpy(sFormatFileName, sFindPath);
	if (sFindPath[strlen(sFindPath) - 1] != SPLIT_SLASH)
	{
		strcat(sFormatFileName, SPLIT_SLASH_STR);
		strcat(sFormatFileName, "*");
	}
	else
	{
		strcat(sFormatFileName, "*");
	}
	strcat(sFormatFileName, sFindFileName);
	strcat(sFormatFileName, "*");

	hFind = FindFirstFile(sFormatFileName, &FindFileData);

	if (hFind == INVALID_HANDLE_VALUE)
	{
		return FALSE;
	}
	else
	{
		while (!fFinished)
		{
			strcpy(sPath, sFindPath);
			if (sPath[strlen(sPath) - 1] != SPLIT_SLASH)
			{
				strcat(sPath, SPLIT_SLASH_STR);
			}
			strcat(sPath, FindFileData.cFileName);

			if (!(FILE_ATTRIBUTE_DIRECTORY & FindFileData.dwFileAttributes))
			{
				++uCountFile;
			}

			if (!FindNextFile(hFind, &FindFileData))
			{
				if (GetLastError() == ERROR_NO_MORE_FILES)
				{
					fFinished = TRUE;
				}
				else
				{
					break;
				}
			}
		}

		FindClose(hFind);
	}

	return TRUE;
}

#else
static BOOL FindMatchedFile(LPCSTR sFindPath, LPCSTR sFindFileName, ULONGLONG& uCountFile)
{
	DIR* pDir = NULL;
	struct dirent* pFile = NULL;
	CSimpleStringA tmpFindFileName = sFindFileName;

	pDir = opendir(sFindPath);
	if (pDir == NULL) return FALSE;

	//linux不支持*查找，去掉后缀
	char strsuffix[MAX_PATH] = { 0 };
	snprintf(strsuffix, MAX_PATH, "*.%s", RECORD_MP4_SUFFIX);
	if (tmpFindFileName.IsEndWith(strsuffix)) {
		tmpFindFileName = tmpFindFileName.SubString(0, tmpFindFileName.GetLength() - 5);
	}

	while ((pFile = readdir(pDir)) != NULL) {
		if (pFile->d_type & DT_DIR) {
			//m_pHostApi->Debug("FindMatchedFile DIR name: %s.", pFile->d_name);
			if (strcmp(pFile->d_name, ".") == 0
				|| strcmp(pFile->d_name, "..") == 0) continue;

			char Path[256];
			int len = strlen(sFindPath);
			strncpy(Path, sFindPath, len + 1);
			if (sFindPath[len - 1] != '/') strncat(Path, "/", 2);
			strncat(Path, pFile->d_name, strlen(pFile->d_name) + 1);
			//m_pHostApi->Debug("FindMatchedFile Path: %s.", Path);
			FindMatchedFile(Path, (LPCTSTR)tmpFindFileName, uCountFile);
		}
		else {
			//m_pHostApi->Debug("FindMatchedFile FILE name: %s.", pFile->d_name);
			if (strstr(pFile->d_name, (LPCTSTR)tmpFindFileName) != NULL) {
				++uCountFile;
			}
		}
	}
	closedir(pDir);
	return TRUE;
}
#endif


static CSimpleStringA DecryptString(LPCTSTR lpszEncrpyted)
{
	if (NULL == lpszEncrpyted) {
		return CSimpleStringA("");
	}

	int	iEncrypt = 0;
	int len = strlen(lpszEncrpyted);
	CSimpleStringA csPlainTxt('\0', (len) / 2 + 1);
	int iCh = 0;
	for (int i = 0; i < len; i += 2) {
		sscanf(lpszEncrpyted + i, "%02X", &iCh);
		csPlainTxt[i / 2] = (char)(((char)iCh) ^ (128 | (iEncrypt++ & 127)));
	}
	return CSimpleStringA((LPCTSTR)csPlainTxt);
}

void SalesRecordServiceSession::Handle_GetOFLVideoRecords( SpReqAnsContext<SalesRecorderSerVice_GetOFLVideoRecords_Req, SalesRecorderSerVice_GetOFLVideoRecords_Ans>::Pointer ctx )
{
	ctx->Answer(Error_Succeed);
}

void SalesRecordServiceSession::Handle_CheckVideoDiskStatus( SpReqAnsContext<SalesRecorderSerVice_CheckVideoDiskStatus_Req, SalesRecorderSerVice_CheckVideoDiskStatus_Ans>::Pointer ctx )
{
	int nFreeRatio = 0;
	int bSufficient = CheckDiskStatus((LPCTSTR)ctx->Req.DriveLetter,m_pEntity->m_max_disk_percent,&nFreeRatio);
	ctx->Ans.IsSufficient = bSufficient;
	ctx->Ans.FreeRatio = nFreeRatio;
	ctx->Answer(Error_Succeed);
}

void SalesRecordServiceSession::Handle_PlayVideo(SpReqAnsContext<SalesRecorderSerVice_PlayVideo_Req, SalesRecorderSerVice_PlayVideo_Ans>::Pointer ctx)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("PlayVideo.");
	ErrorCodeEnum ErrorCode = m_pEntity->HandleDisplayVideo();
	ctx->Answer(ErrorCode);
}

void SalesRecordServiceSession::Handle_SaveVideo(SpReqAnsContext<SalesRecorderSerVice_SaveVideo_Req, SalesRecorderSerVice_SaveVideo_Ans>::Pointer ctx)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Save Video.");
	ErrorCodeEnum ErrorCode = m_pEntity->HandleSaveVideo();
	ctx->Answer(ErrorCode);
}

void SalesRecordServiceSession::Handle_StopRecord(SpReqAnsContext<SalesRecorderSerVice_StopRecord_Req, SalesRecorderSerVice_StopRecord_Ans>::Pointer ctx)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Stop Record.");
	ErrorCodeEnum ErrorCode = m_pEntity->HandleStopRecord((LPCTSTR)CSimpleStringW2A(ctx->Req.VideoName));
	ctx->Answer(ErrorCode);
}


void SalesRecordServiceSession::Handle_SetAudioTransFlag(SpReqAnsContext<SalesRecorderSerVice_SetAudioTransFlag_Req, SalesRecorderSerVice_SetAudioTransFlag_Ans>::Pointer ctx)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Audio transmission flag is %s.", ctx->Req.TransFlag ? "true" : "false");
	ctx->Answer(Error_Succeed);
}


void SalesRecordServiceSession::Handle_StopShowVideo(SpReqAnsContext<SalesRecorderSerVice_StopShowVideo_Req, SalesRecorderSerVice_StopShowVideo_Ans>::Pointer ctx)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Stop Show Video.");
	ErrorCodeEnum ErrorCode = m_pEntity->HandleStopShowVideo();
	ctx->Answer(ErrorCode);
}

void SalesRecordServiceSession::Handle_PlaySalesRecord(SpReqAnsContext<SalesRecorderSerVice_PlaySalesRecord_Req, SalesRecorderSerVice_PlaySalesRecord_Ans>::Pointer ctx)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Stop Show Video.");
	ErrorCodeEnum ErrorCode = m_pEntity->HandlePlaySalesRecordVideo(ctx->Req.WndX, ctx->Req.WndY, ctx->Req.WndWidth, ctx->Req.WndHeight);
	ctx->Answer(ErrorCode);
}

void SalesRecordServiceSession::Handle_StartRemoteRecord(SpReqAnsContext<SalesRecorderSerVice_StartRemoteRecord_Req, SalesRecorderSerVice_StartRemoteRecord_Ans>::Pointer ctx)
{
	ErrorCodeEnum ErrorCode = m_pEntity->HandleStartRecord(ctx->Req.VideoName.GetData(), true);
	ctx->Answer(ErrorCode);
}

CServerSessionBase * CSalesRecorderEntity::OnNewSession( const char* pszRemoteEntityName, const char * pszClass )
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("%s connected class = %s!", pszRemoteEntityName, pszClass);
	return new SalesRecordServiceSession(this);
}

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

ErrorCodeEnum CSalesRecorderEntity::__OnStart( ErrorCodeEnum preOperationError )
{
	//MessageBoxA(0,0,0,0);
	m_eDeviceType = eStand2sType;
	m_nSysCallType = 0;
	m_bNeedRestart = false;
	m_eAudioOutQuality = eUltraHD;
	m_bIsAudioNsOn = false;
	m_iAudioNsPolicy = 2;
	m_iAudioChannels = 1;

	m_eDeviceType = RvcGetDeviceType();

	int iAudioQuality = 3;
	int iAudioNsPolicy = 2;
	int iIsAudioNsOn = 0;
	int iAudioChannels = 1;
	int iLogLevel = 1;
	int iLowestLevel = 1;
	int iRecordType = 0;
	m_max_disk_percent = MAX_DISK_PERCENT; 
	m_audio_samplerate = 8;
	CSmartPointer<IConfigInfo> spConfig;
	CSmartPointer<IEntityFunction> spFunction = GetFunction();
	if (spFunction->OpenConfig(Config_CenterSetting, spConfig) == Error_Succeed) {
		spConfig->ReadConfigValueInt("SalesRecorder","MaxDiskPercent",m_max_disk_percent);
		spConfig->ReadConfigValueInt("SalesRecorder","AudioSampleRate",m_audio_samplerate);
		spConfig->ReadConfigValueInt("SalesRecorder","AudioBitRate",m_audio_out_bitrate);
		spConfig->ReadConfigValueInt("SalesRecorder","AudioNsPolicy",iAudioNsPolicy);
		spConfig->ReadConfigValueInt("SalesRecorder","IsAudioNsOn",iIsAudioNsOn);
		spConfig->ReadConfigValueInt("SalesRecorder","AudioQuality",iAudioQuality);
		spConfig->ReadConfigValueInt("SalesRecorder","AudioChannels",iAudioChannels);
		spConfig->ReadConfigValueInt("SalesRecorder","LogLevel",iLogLevel);
		spConfig->ReadConfigValueInt("SalesRecorder","LowestLevel",iLowestLevel);
	}

	if (m_max_disk_percent <= 0 || m_max_disk_percent >= 100) {
		m_max_disk_percent = MAX_DISK_PERCENT;
	}

	if (iLogLevel <= RECORD_LOG_ERROR && iLogLevel > 0){
		m_loglevel = (record_loglevel)iLogLevel;
	}
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("m_loglevel:%d", m_loglevel);

	if (iLowestLevel <= RECORD_LOG_ERROR && iLowestLevel > 0){
		m_lowestlevel = (record_loglevel)iLowestLevel;
	}
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("m_lowestlevel:%d", m_lowestlevel);

	SetRecordAudioQuality(iAudioQuality);
	SetRecordAudioNsPolicy(iAudioNsPolicy);
	SetRecordAudioChannles(iAudioChannels);

	if (0 != iIsAudioNsOn){
		m_bIsAudioNsOn = true;
	}
	
	if (m_bWholeSection != 0 && m_bWholeSection != 1){
		m_bWholeSection = FALSE;
	}

	if (m_bApplyHighQuality != 0 && m_bApplyHighQuality != 1){
		m_bApplyHighQuality = FALSE;
	}
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("m_bApplyHighQuality:%d",m_bApplyHighQuality);

	if (preOperationError != Error_Succeed) {
		return preOperationError;
	}

	ErrorCodeEnum Error = Error_Succeed;
	m_iActiveCamera = CAMERA_TYPE_ENV;
	m_iCameraState = 'N';
	
	int i = 0;

	m_arrListener.Init(4);
	GetFunction()->SubscribeLog(m_arrListener[i++], this, Log_Event, Severity_Middle, Error_IgnoreAll, LOG_EVT_UI_DELETEVIDEO, NULL, false);
	GetFunction()->SubscribeLog(m_arrListener[i++], this, Log_Event, Severity_None, Error_IgnoreAll, LOG_EVT_UI_RETURNMENU, NULL, false);
	GetFunction()->SubscribeLog(m_arrListener[i++], this, Log_Event, Severity_None, Error_IgnoreAll, LOG_EVT_UI_VIDEOAPPENDWATERMARK, NULL, false);
	GetFunction()->SubscribeLog(m_arrListener[i++], this, Log_Event, Severity_High, Error_IgnoreAll, LOG_EVT_SALESRECORD_ENTITY_EXCEPTION, NULL, false);

	GetFunction()->RegistSysVarEvent(SYSVAR_ACTIVETRACKINGCAMERA,this);
	GetFunction()->RegistSysVarEvent(SYSVAR_CAMERASTATE,this);
	CSimpleStringA strValue;
	GetFunction()->GetSysVar(SYSVAR_CAMERASTATE, strValue);
	m_iCameraState = strValue[0];
	if (strValue[0] == 'E'){
		m_iActiveCamera = CAMERA_TYPE_OPT;
	}
	else{
		m_iActiveCamera = CAMERA_TYPE_ENV;
	}

	GetFunction()->RegistSysVarEvent(SYSVAR_CALLTYPE, this);
	GetFunction()->GetSysVar(SYSVAR_CALLTYPE, strValue);
	if (strValue[0] == CALLTYPE_NORMAL) {
		m_nSysCallType = 0;
	} 
	else if (strValue[0] == CALLTYPE_MOBILE) {
		m_nSysCallType = 1;
	} 
	else {
		assert(0);
	}

	Error = GetFunction()->RegistSysVarEvent("SessionID", this);
	if (Error != Error_Succeed) 
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("register sysvar %s failed!", "SessionID");
	}

	Error = GetFunction()->GetPath("Temp", m_TempDir);
	if (Error != Error_Succeed) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("get global record temp path failed!");
	}

	if (m_TempDir.GetLength() > 0 && m_TempDir[m_TempDir.GetLength()-1] != SPLIT_SLASH) {
		m_TempDir += SPLIT_SLASH_STR;
	}
	Error = GetFunction()->GetPath("UploadVideo", m_RecordSaveDir);
	if (Error != Error_Succeed) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("get global record save path failed!");
	}

	if (m_RecordSaveDir.GetLength() > 0 && m_RecordSaveDir[m_RecordSaveDir.GetLength()-1] != SPLIT_SLASH) {
		m_RecordSaveDir += SPLIT_SLASH_STR;
	}

	return Error;
}

void CSalesRecorderEntity::OnStarted()
{
	InitSalesRecorder();
	LogEvent(Severity_Middle, LOG_EVT_MOD_SALESRECORDER_STARTED_SUCCESS, "sales recorder entity started successfully.");
}

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

ErrorCodeEnum CSalesRecorderEntity::__OnClose( ErrorCodeEnum preOperationError )
{
	if (preOperationError != Error_Succeed) {
		return preOperationError;
	}
		
	CSmartPointer<IEntityFunction> spFunction = GetFunction();
	for (int i = 0; i < m_arrListener.GetCount(); ++i) {
		spFunction->UnsubscribeLog(m_arrListener[i]);
	}

	GetFunction()->UnregistSysVarEvent(SYSVAR_ACTIVETRACKINGCAMERA);
	GetFunction()->UnregistSysVarEvent(SYSVAR_CAMERASTATE);

	StopRecord();

	ReleaseSalesRecorder();

	return Error_Succeed;
}

void CSalesRecorderEntity::OnSelfTest(EntityTestEnum eTestType,CSmartPointer<ITransactionContext> pTransactionContext)
{
	if (Test_ShakeHand == eTestType)
	{
		if (m_bNeedRestart){
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("[OnSelfTest] entity need restart now.");
			pTransactionContext->SendAnswer(Error_Unexpect);
		}
		else{
			pTransactionContext->SendAnswer(Error_Succeed);
		}
	}
}


int CSalesRecorderEntity::GetActiveCamera()
{
	return m_iActiveCamera;
}

int CSalesRecorderEntity::GetCameraState()
{
	//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("get active camera = %d", m_iCameraState);
	return m_iCameraState;
}

void CSalesRecorderEntity::OnRecordFailed(eRvcRecordFailedCase eCase, const char* pszMessage, bool bRecordDevFault )
{
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("OnSalesRecordFailed for [%d]:%s.", (int)eCase, record_failed_case_table[eCase]);

	if (eCase < eDefault && eCase >= 0) {
		LogEvent(Severity_Middle, LOG_EVT_UI_RECORDFAILED, record_failed_case_table[eCase]);
	}

	char strmsg[MAX_PATH] = { 0 };
	snprintf(strmsg, MAX_PATH, "{%s}.", pszMessage ? pszMessage : " ");
	LogWarn(Severity_Middle, Error_Debug, LOG_EVT_SALESRECORD_FAILED, strmsg);

	if (eBeginFailed == eCase) {
		m_bNeedRestart = true;
		RealSelfCheck();
	}
}

void CSalesRecorderEntity::OnRecordEntityExcption()
{
	LogEvent(Severity_High,LOG_EVT_SALESRECORD_ENTITY_EXCEPTION,"现场销售双录出现异常，请稍候重录，系统正在恢复中，预计60秒！");
	LogWarn(Severity_Low, Error_Debug, LOG_EVT_RECORD_ENTITY_EXCEPTION, "sales record entity exception!");
}


void CSalesRecorderEntity::OnRecordFinished()
{
	LogEvent(Severity_High, LOG_EVT_SALESRECORD_FINISHED, "现场销售双录已完成.");
	LogWarn(Severity_Low, Error_Debug, LOG_EVT_RECORD_FINISHED, "现场销售双录已完成.");
}

void CSalesRecorderEntity::Debug(record_loglevel elevel, const char* fmt, ...)
{
	record_loglevel entitylevel = (m_lowestlevel > m_loglevel) ? m_lowestlevel : m_loglevel;
	if (entitylevel <= elevel) {
		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 CSalesRecorderEntity::vDebug(record_loglevel elevel, const char* str, va_list list)
{
	record_loglevel entitylevel = (m_lowestlevel > m_loglevel) ? m_lowestlevel : m_loglevel;
	if (entitylevel <= elevel) {
		int n = vsnprintf(NULL, 0, str, list);
		if (n >= MAX_PATH) {
			char* buf = (char*)malloc((size_t)(n + 1));
			vsnprintf(buf, n + 1, str, list);
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("%s", buf);
			free(buf);
		}
		else {
			char strlog[MAX_PATH] = { 0 };
			vsnprintf(strlog, MAX_PATH, str, list);
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("%s", strlog);
		}
	}
}


#ifdef RVC_OS_WIN
void CSalesRecorderEntity::WmpDebug( const char *fmt, ... )
{
	va_list arg;
	va_start(arg, fmt);
	vDbg(fmt, arg);
	va_end(arg);
}
#else
void CSalesRecorderEntity::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);
	}
}
#endif // RVC_OS_WIN


void CSalesRecorderEntity::OnTimeout( DWORD dwTimerID )
{

}

void CSalesRecorderEntity::OnSysVarEvent( const char *pszKey, const char *pszValue,const char *pszOldValue,const char *pszEntityName )
{
	if (_stricmp(pszKey, SYSVAR_CAMERASTATE) == 0)
	{
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("camera state from : %c to %c", pszOldValue[0], pszValue[0]);
		m_iCameraState = pszValue[0]; 
		if (pszValue[0] == 'E')
		{
			m_iActiveCamera = CAMERA_TYPE_OPT;
		}
		else
		{
			m_iActiveCamera = CAMERA_TYPE_ENV;
		}
	}
	else if (_stricmp(pszKey, SYSVAR_ACTIVETRACKINGCAMERA) == 0)
	{
		if (m_iCameraState == 'N')
		{
			if (pszValue[0] == 'E')
			{
				m_iActiveCamera = CAMERA_TYPE_ENV;
			}
			else if (pszValue[0] == 'O')
			{
				m_iActiveCamera = CAMERA_TYPE_OPT;
			}
		}
	}
	else if (_stricmp(pszKey, SYSVAR_CALLTYPE) == 0)
	{
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("sys calltype from: %c to %c", pszOldValue[0], pszValue[0]);
		if(pszValue[0] == CALLTYPE_NORMAL)
		{
			m_nSysCallType = 0;
		} 
		else if(pszValue[0] == CALLTYPE_MOBILE)
		{
			m_nSysCallType = 1;
		}
		else 
		{
			m_nSysCallType = -1;
		}
	}
}

void CSalesRecorderEntity::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)
{
	// 响应客户经理销售录像相关的事件
	switch (dwUserCode)
	{
	case LOG_EVT_UI_SHOWVIDEO:
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("show video record.");
		HandleDisplayVideo();
		break;

	case LOG_EVT_UI_SAVEVIDEO:
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("save record!");
		HandleSaveVideo();
		break;

	case LOG_EVT_UI_DELETEVIDEO:
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("delete record!");
		HandleDeleteVideo();
		break;

	case LOG_EVT_UI_RETURNMENU:
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("return menu.");
		//HandleReturnMenu();
		break;
	case LOG_EVT_UI_VIDEOAPPENDWATERMARK:
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("handle video append water mark param is %s.", pszMessage);
		HandleVideoAppendWatermark(pszMessage);
		break;

	case LOG_EVT_SALESRECORD_ENTITY_EXCEPTION:
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("handle sales record entity exception, and message is %s.", pszMessage);
		HandleSalesRecordEntityException(pszMessage);
		break;

	default:
		break;
	}
}


bool CSalesRecorderEntity::GetStandardQualityOnSiteSalesRecorder()
{
	bool bRet = FALSE;

	m_pRecorder = new Clibvideorecord(&bRet, this, REC_COMMON_AUDIO_SHM_QUEUE, REC_COMMON_VIDEO_ENV_SHM_SNAPSHOT_QUEUE,
				REC_COMMON_VIDEO_OPT_SHM_SNAPSHOT_QUEUE, REC_COMMON_AUDIO_SALES_SHM_QUEUE, REC_COMMON_VIDEO_REMOTE_SHM_RTP_QUEUE, REC_COMMON_REMOTEAUDIO_SHM_QUEUE);
		
	return bRet;
}


bool CSalesRecorderEntity::GetHighQualityOnSiteSalesRecorder()
{
	bool bRet = false;

	m_pRecorder = new Clibvideorecord(&bRet, this, REC_COMMON_AUDIO_SHM_QUEUE, REC_COMMON_VIDEO_ENV_SHM_SNAPSHOT_QUEUE,
				REC_COMMON_VIDEO_OPT_SHM_SNAPSHOT_QUEUE, REC_COMMON_AUDIO_SALES_SHM_QUEUE, REC_COMMON_VIDEO_REMOTE_SHM_RTP_QUEUE, REC_COMMON_REMOTEAUDIO_SHM_QUEUE);

	return bRet;
}


void CSalesRecorderEntity::StartOnSiteSalesRecord(const int fps, const char* videofilename, int videoquality, int audioOutBitRate, SubtitleParam* subtitleParam, BOOL bWholeSection, BOOL bSessionManage, eRvcRecordType eRecordType)
{
	Rvc_RecordAudioParam_t tAudioParams;
	tAudioParams.eRecordType = eRecordType;
	tAudioParams.eOutPutType = m_eAudioOutQuality;
	tAudioParams.bIsNsOn = m_bIsAudioNsOn;
	tAudioParams.iNsPolicy = m_iAudioNsPolicy;
	tAudioParams.iAudioOutBitRate = audioOutBitRate;
	tAudioParams.iAudioChannels = m_iAudioChannels;

	if (eStand2Agent == eRecordType || ePad2Agent == eRecordType) {
		tAudioParams.eOutPutType = eLowDefinition;
		tAudioParams.bIsNsOn = false;
	}

	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("init lib video record success! and record type is %s and output audio quality is %s, audio noise suppression flag is %s. noise suppression policy is %d.", record_type_table[eRecordType], audio_quality_type_table[m_eAudioOutQuality], tAudioParams.bIsNsOn ? "true" : "false", tAudioParams.iNsPolicy);
	if (m_pRecorder->StartVideoRecord(fps, videoquality, eMP4, &tAudioParams, subtitleParam, bWholeSection, false, (LPCSTR)m_TempDir,
		m_TempDir.GetLength(), videofilename, strlen(videofilename)))
	{
		m_bStarted = true;
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Start VideoRecord success!");
	}
	else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Start VideoRecord failed!");
	}
}

void CSalesRecorderEntity::StartRecord(const char * videofilename, int videoquality, int audioOutBitRate, SubtitleParam *subtitleParam /* = NULL */, BOOL bWholeSection /* = FALSE */, BOOL bSessionManage /* = FALSE */, eRvcRecordType eRecordType /* = eSingleSide */)
{
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("videofilename = %s", videofilename);

	StartOnSiteSalesRecord(10, videofilename, videoquality, audioOutBitRate, subtitleParam, bWholeSection, bSessionManage, eRecordType);
}

ErrorCodeEnum CSalesRecorderEntity::StopRecord()
{
	ErrorCodeEnum eCode = Error_Succeed;
	if (m_bStarted) {
		m_pRecorder->StopVideoRecord();

		m_bStarted = FALSE;
	}
	else{
		eCode = Error_InvalidState;
	}

	return eCode;
}

ErrorCodeEnum CSalesRecorderEntity::ShowVideo( const char *videofilename)
{
	ErrorCodeEnum ErrorCode = Error_Succeed;

	return ErrorCode;
}


ErrorCodeEnum CSalesRecorderEntity::PlaySalesRecordVideo( const char *videofilename, int iWndX, int iWndY, int iWndWidth, int iWndHeight)
{
	ErrorCodeEnum ErrorCode = Error_Succeed;

	return ErrorCode;
}


void CSalesRecorderEntity::DeleteVideo( const char *videofilename)
{
	if(!m_bStarted)
	{
		CSimpleStringA strPath;
		ErrorCodeEnum Error = GetFunction()->GetPath("Temp", strPath);
		if (Error == Error_Succeed) {
			if (strPath.GetLength() > 0 && strPath[strPath.GetLength()-1] != SPLIT_SLASH) {
				strPath += SPLIT_SLASH_STR;
			}
			CSimpleStringA strFindFileName = CSimpleStringA::Format("%s*.%s", videofilename, RECORD_MP4_SUFFIX);
			ULONGLONG uVideoCount = 0;
			BOOL bRet = FindMatchedFile((LPCSTR)strPath, (LPCTSTR)strFindFileName, uVideoCount);
			if(bRet)
			{
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("succeed to get record count while delete video!");
				CSimpleStringA fileName;
				BOOL bDeleteSucc = TRUE;
				for(int i = 0; i != uVideoCount; ++i)
				{
					fileName = CSimpleStringA::Format("%s%s_%d.%s", (LPCSTR)strPath, videofilename, i, RECORD_MP4_SUFFIX);

					if(remove(fileName.GetData())) {
						bDeleteSucc = FALSE;
						DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Error Code %lu while delete %s ", errno, fileName.GetData());
					}
				}
				if (bDeleteSucc) {
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("succeed to delete videos!");
				}
			}
			else
			{
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("[DeleteVideo] videos not exist or have been deleted!");
			}
		}
	}
}


/*
SaveVideo包含两步，找到录像和移动录像
Error_Succeed		提交上传成功
Error_NotExist		not exist
Error_NotImpl		方法执行失败
*/


static unsigned long GetFileSize(const char* filename)
{
	struct stat statbuf;
	stat(filename, &statbuf);
	return statbuf.st_size;
}

ErrorCodeEnum CSalesRecorderEntity::SaveVideo( const char * videofilename)
{
	ErrorCodeEnum ErrorCode = Error_Succeed;

	if(!m_bStarted)
	{
		CSimpleStringA sourPath;
		ErrorCodeEnum Error = GetFunction()->GetPath("Temp", sourPath);
		if(Error == Error_Succeed)
		{
			if (sourPath.GetLength() > 0 && sourPath[sourPath.GetLength()-1] != SPLIT_SLASH) {
				sourPath += SPLIT_SLASH_STR;
			}
			ULONGLONG uVideoCount = 0;
			// 移动销售录像 edit by ly 2018/03/05
			CSimpleStringA strFindFileName = CSimpleStringA::Format("S_%s*.%s", videofilename, RECORD_MP4_SUFFIX);
			BOOL bRet = FindMatchedFile((LPCSTR)sourPath, (LPCSTR)strFindFileName, uVideoCount);
			if(bRet)
			{
				strFindFileName = strFindFileName.SubString(0,strFindFileName.GetLength()-5);
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("succeed to get sales record count while save video!");
				CSimpleStringA destPath;
				Error = GetFunction()->GetPath("UploadVideo", destPath);
				if(Error == Error_Succeed)
				{
					if (destPath.GetLength() > 0 && destPath[destPath.GetLength()-1] != SPLIT_SLASH) {
						destPath += SPLIT_SLASH_STR;
					}
					CSimpleStringA sourFileName, destFileName;
					BOOL bMoveSucc = TRUE;
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("strFindFileName=%s", (LPCSTR)strFindFileName);
					for(int i = 0; i != uVideoCount; ++i)
					{
						sourFileName = CSimpleStringA::Format("%s%s_%d.%s", (LPCSTR)sourPath, (LPCSTR)strFindFileName, i, RECORD_MP4_SUFFIX);
						destFileName = CSimpleStringA::Format("%s%s_%d.%s", (LPCSTR)destPath, (LPCSTR)strFindFileName, i, RECORD_MP4_SUFFIX);
						unsigned long ufilesize = GetFileSize(sourFileName.GetData());
						char strtext[MAX_PATH] = {0};
						snprintf(strtext, MAX_PATH, "%s file size is %u byte.", (LPCSTR)sourFileName, ufilesize);
						LogWarn(Severity_Low, Error_Debug, LOG_EVT_RECORD_FILESIZE, strtext);
						if(rename(sourFileName.GetData(), destFileName.GetData())) {
							bMoveSucc = FALSE;
							ErrorCode = Error_NotImpl;
							char strinfo[MAX_PATH] = { 0 };
							snprintf(strinfo, MAX_PATH, "Error Code %lu while move %s.", errno, (LPCSTR)sourFileName);
							LogWarn(Severity_Low, Error_Debug, LOG_EVT_RECORD_SAVED_FAILED, strinfo);
						}
						if (ufilesize > RVC_MIN_FILESIZE){

						}
						else{
							char strmsg[MAX_PATH] = {0};
							snprintf(strmsg, MAX_PATH, "%s file size is %u.", (LPCSTR)sourFileName, ufilesize);
							LogWarn(Severity_Low, Error_Debug, LOG_EVT_RECORD_INVALID_FILE, strmsg);
						}
					}
					if (bMoveSucc) {
						char strmsg[MAX_PATH] = { 0 };
						snprintf(strmsg, MAX_PATH, "succeed to save sales video, move it from %s to %s.", sourFileName.GetData(), destFileName.GetData());
						LogWarn(Severity_Low, Error_Debug, LOG_EVT_RECORD_SAVED_SUCCESS, strmsg);
					}
				}
			}
			else
			{
				LogWarn(Severity_Low, Error_Debug, LOG_EVT_RECORD_SAVED_FAILED, "sales videos not exist or have been deleted");
				ErrorCode = Error_NotExist;
			}
		}
	}
	else{
		ErrorCode = Error_InvalidState;
	}

	return ErrorCode;
}

CSimpleStringA CSalesRecorderEntity::GetTerminalStage()
{
	CSmartPointer<IEntityFunction> Func = GetFunction();
	CSimpleStringA strValue = "";
	Func->GetSysVar("TerminalStage", strValue);
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("TerminalStage:%s", (LPCTSTR)strValue);
	return strValue;
}


bool CSalesRecorderEntity::SecureClientConnect()
{
	SecureClientRelease();

	return true;
}

void CSalesRecorderEntity::SecureClientRelease()
{

}


// 请求InteractiveControl结束录像 add by ly 2018/03/12
ErrorCodeEnum CSalesRecorderEntity::StopRecordVideo()
{
	auto rc = Error_Succeed;

	auto pUIClient = new InteractiveControl::UIService_ClientBase(this);

	if(pUIClient->Connect() != Error_Succeed)
	{
		pUIClient->SafeDelete();
		pUIClient = NULL;
		rc = Error_DevConnFailed;
	}
	else
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("UIClient connected success!");
		InteractiveControl::UIService_StopRecordVideo_Req req;
		InteractiveControl::UIService_StopRecordVideo_Ans ans;
		rc = (*pUIClient)(EntityResource::getLink().upgradeLink())->StopRecordVideo(req, ans, 5000);
		if(rc != Error_Succeed)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Stop record video failed return 0x%08x", rc);
		}

		pUIClient->GetFunction()->CloseSession();
		pUIClient = NULL;
	}

	return rc;
}


ErrorCodeEnum CSalesRecorderEntity::HandleStartRecord(const char *pszMessage, const bool bRemoteRecord)
{
	ErrorCodeEnum Error = Error_Succeed;
	eRvcRecordType eRecordType = eSingleSide;
	if (NULL == pszMessage){
		return Error_Param;
	}

	size_t ulen = strlen(pszMessage);
	char *tmp = new char[ulen+1];

	strncpy(tmp, pszMessage, ulen);
	
	char *result[32] = {0};
	CStringSplit(tmp, result, "@");

	memset(m_SalesVideoName, 0, MAX_PATH);
	if (result[4]) {
		snprintf(m_SalesVideoName, MAX_PATH, "%s", result[4]);//录像名：录像类型标志_录像流水号（如S_C13213EF）
	}
	
	RecordSubTitle subTitle;
	ZeroMemory(&subTitle,sizeof(RecordSubTitle));

	if (result[5]) {
		CSimpleStringA strCardNo = DecryptString(result[5]);
		if (sizeof(subTitle.CustCardNo) > strCardNo.GetLength()) {
			strcpy_s(subTitle.CustCardNo, 24, strCardNo.GetData());
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Invalid CustCardNo.");
		}
	}

	char* pStr = result[6];
	if (pStr) {
		CSimpleStringW szCustName = CSimpleStringA2W(pStr);
		if (szCustName.GetLength() <= 4) {
			strcpy(subTitle.CustName, pStr);
		}
		else {
			CSimpleStringW aa = szCustName.SubString(0, 4);
			sprintf(subTitle.CustName, "%s...", (LPCTSTR)CSimpleStringW2A(aa));
		}
	}

	pStr = result[7];
	if (pStr) {
		int nProductCodeLen = strlen(pStr);
		if (nProductCodeLen <= 10) {
			strcpy(subTitle.ProductCode, pStr);
		}
		else {
			char aa[5] = { 0 }, bb[5] = { 0 };
			strncpy(aa, pStr, 4);
			strncpy(bb, pStr + nProductCodeLen - 4, 4);
			sprintf(subTitle.ProductCode, "%s...%s", aa, bb);
		}
	}

	pStr = result[8];
	if (pStr) {
		CSimpleStringW szProductName = CSimpleStringA2W(pStr);
		if (szProductName.GetLength() <= 5) {
			strcpy(subTitle.ProductName, pStr);
		}
		else {
			CSimpleStringW aa = szProductName.SubString(0, 3);
			CSimpleStringW bb = szProductName.SubString(szProductName.GetLength() - 2, 2);
			sprintf(subTitle.ProductName, "%s...%s", (LPCTSTR)CSimpleStringW2A(aa), (LPCTSTR)CSimpleStringW2A(bb));
		}
	}

	if (result[9]) {
		strcpy(subTitle.SapID, result[9]);
	} else {
		subTitle.SapID[0] = '\0';
	}

	if (result[10]) {
		pStr = result[10];
		CSimpleStringW szCustManagerName = CSimpleStringA2W(pStr);
		if (szCustManagerName.GetLength() <= 4) {
			strcpy(subTitle.CustManagerName, result[10]);
		}
		else {
			CSimpleStringW aa = szCustManagerName.SubString(0,4);
			sprintf(subTitle.CustManagerName,"%s...",(LPCTSTR)CSimpleStringW2A(aa));
		}
	} else {
		subTitle.CustManagerName[0] = '\0';
	}

	delete[] tmp;
	tmp = NULL;

	SubtitleParam subtitleParam;
	ZeroMemory(&subtitleParam,sizeof(SubtitleParam));
	subtitleParam.bSubtitle = TRUE;
	subtitleParam.bSubtitleSection = TRUE;
	subtitleParam.topSubtitleData[0] = '\0';
	if (strlen(subTitle.SapID)>0&&strlen(subTitle.CustManagerName)>0)
	{
		swprintf(subtitleParam.bottomSubtitleData1, MAX_PATH, L"%s  %s  %s", subTitle.CustCardNo, subTitle.CustName, subTitle.ProductCode);
		swprintf(subtitleParam.bottomSubtitleData2, MAX_PATH, L"%s  %s  %s", subTitle.ProductName, subTitle.SapID, subTitle.CustManagerName);
	}
	else
	{
		swprintf(subtitleParam.bottomSubtitleData1, MAX_PATH, L"%s  %s", subTitle.CustCardNo, subTitle.CustName);
		swprintf(subtitleParam.bottomSubtitleData2, MAX_PATH, L"%s  %s", subTitle.ProductCode, subTitle.ProductName);
	}

	int i_audio_out_bitrate = m_audio_out_bitrate;

	if (bRemoteRecord){
		if (eStand2sType == m_eDeviceType || eStand1SPlusType == m_eDeviceType)  {	//如果是大机
			eRecordType = eStand2Agent;   //可视柜台大机的双向录像
		} 
		else{
			eRecordType = ePad2Agent;   //可视柜台pad的双向录像
		}

		if(256 == m_audio_out_bitrate){
			i_audio_out_bitrate = 128;
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("change remote record audio out bitrate to %d.", i_audio_out_bitrate);
		}
	} 

	StartRecord(m_SalesVideoName, 90, i_audio_out_bitrate, &subtitleParam, m_bWholeSection, FALSE, eRecordType);

	char strmsg[MAX_PATH] = { 0 };
	snprintf(strmsg, MAX_PATH, "start remote record %s.", m_SalesVideoName);
	LogWarn(Severity_Low, Error_Debug, LOG_EVT_START_REMOTERECORD, strmsg);

	return Error;
}



ErrorCodeEnum CSalesRecorderEntity::HandleStopRecord(const char *pszMessage)
{
	ErrorCodeEnum ErrorCode = StopRecord();

	return ErrorCode;
}


ErrorCodeEnum CSalesRecorderEntity::HandleDisplayVideo()
{
	// 视频播放 libwmpplayer
	m_bIsShowVideo = TRUE;
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("play record file name is %s!", m_SalesVideoName);
	ErrorCodeEnum ErrorCode = ShowVideo(m_SalesVideoName);
	return ErrorCode;
}


ErrorCodeEnum CSalesRecorderEntity::HandlePlaySalesRecordVideo(int iWndX, int iWndY, int iWndWidth, int iWndHeight)
{
	// 视频播放 libwmpplayer
	m_bIsShowVideo = TRUE;
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("play sales record video file name is %s!", m_SalesVideoName);
	ErrorCodeEnum ErrorCode = PlaySalesRecordVideo(m_SalesVideoName, iWndX, iWndY, iWndWidth, iWndHeight);
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("play sales record video return code is 0x%08x.", ErrorCode);
	return ErrorCode;
}


ErrorCodeEnum CSalesRecorderEntity::HandleStopShowVideo()
{
	// 视频播放 libwmpplayer
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("stop show video record file name is %s!", m_SalesVideoName);
	ErrorCodeEnum ErrorCode = Error_Succeed;
	if(m_bIsShowVideo)
	{
		//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("m_pPlayer = %p while play!", m_pPlayer);
		//m_pPlayer->Close();
		m_bIsShowVideo = FALSE;
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("succeed to stop show video!");
	}
	else{
		ErrorCode = Error_NotImpl;
	}
	return ErrorCode;
}



ErrorCodeEnum CSalesRecorderEntity::HandleSaveVideo()
{
	ErrorCodeEnum ErrorCode = Error_Succeed;
	// 将视频从tmp移动到uploadvideo
	if (!strstr(m_SalesVideoName, "OFL")) // edit by ly 20180228
	{
		ErrorCode = SaveVideo(m_SalesVideoName+2);
	}
	else
	{
		ErrorCode = SaveVideo(m_SalesVideoName+4);
	}

	ZeroMemory(m_SalesVideoName,sizeof(m_SalesVideoName));

	return ErrorCode;
}


void CSalesRecorderEntity::HandleDeleteVideo()
{
	// 删除tmp中的视频
	DeleteVideo(m_SalesVideoName);  

	ZeroMemory(m_SalesVideoName,sizeof(m_SalesVideoName));
}

void CSalesRecorderEntity::HandleReturnMenu()
{
	CSimpleStringA strValue;
	GetFunction()->GetSysVar("DesktopType", strValue);
	if (strValue != CSimpleStringA("U"))
	{
		if (m_bStarted) // 如果正在进行客户经理录像
		{
			// 停止录像
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("stop record and return menu!");
			StopRecord();
		}

		ZeroMemory(m_SalesVideoName, sizeof(m_SalesVideoName));
	}
}

void CSalesRecorderEntity::HandleVideoAppendWatermark(const char* pszMessage)
{
	if (NULL == pszMessage){
		return;
	}

	wchar_t*result[10] = {0};
	auto arr1 = CSimpleStringA2W(pszMessage).Split('|');
	auto arr2 = CAutoArray<CSimpleStringW>(arr1.GetCount());
	int icount = sizeof(result)/sizeof(char*);
	for (int i = 0; i < arr1.GetCount() && i < sizeof(result)/sizeof(char*); i++)
	{
		arr2[i] = CSimpleStringW(arr1[i]);
		result[i] = (wchar_t*)arr2[i].GetData();
	}

	if (m_bStarted && (NULL != m_pRecorder)) 
	{
		m_pRecorder->SetRightVideoWaterMark(result[1]);
	}
}

ErrorCodeEnum CSalesRecorderEntity::HandleSalesRecordEntityException(const char* pszMessage)
{
	// 通知到业务中台
	SalesRecordException evt;
	evt.failedmsg = CSimpleStringA2W(pszMessage==NULL?"现场销售双录过程出现异常！":pszMessage);
	SpSendBroadcast(GetFunction(), SP_MSG_OF(SalesRecordException), SP_MSG_SIG_OF(SalesRecordException), evt);
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("[dbg] SalesRecord entity exception broadcast sent!");

	//停止录像
	StopRecord();

	m_bNeedRestart = true;

	//重启实体
	RealSelfCheck();

	return Error_Succeed;
}

bool CSalesRecorderEntity::InitSalesRecorder()
{
	bool bRet = FALSE;
	if (m_bApplyHighQuality)
	{
		bRet = GetHighQualityOnSiteSalesRecorder();
	}
	else
	{
		bRet = GetStandardQualityOnSiteSalesRecorder();
	}

	return bRet;
}


bool CSalesRecorderEntity::ReleaseSalesRecorder()
{
	if (m_pRecorder) {
		delete m_pRecorder;
		m_pRecorder = NULL;
	}
	return true;
}


ErrorCodeEnum CSalesRecorderEntity::RealSelfCheck()
{
	ErrorCodeEnum Error = Error_Succeed;
	SelfChekerClient* pSelfcheckClient = new SelfChekerClient(this);
	Error = pSelfcheckClient->Connect();
	if (Error != Error_Succeed)
	{
		pSelfcheckClient->SafeDelete();
		pSelfcheckClient = NULL;
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("SelfcheckClient connect fail!");
	}
	else
	{
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("SelfcheckClient connect success!");
	}

	if (pSelfcheckClient)
	{
		SelfChecker::SelfCheckerService_RealCheck_Req req;
		req.name = GetEntityName();
		SelfChecker::SelfCheckerService_RealCheck_Ans ans;
		DWORD Timeout = 500;
		Error = pSelfcheckClient->RealCheck(req,ans,Timeout);
		if (Error!=Error_Succeed)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("RealSelfcheck fail!");
		}
		else
		{
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("RealSelfcheck success!");
		}
	}

	LogWarn(Severity_Middle, Error_Debug, LOG_EVT_ENTITY_RESTART, "sales record entity self restart.");

	return Error;
}


#ifdef RVC_OS_WIN

bool IsMatchedVideo(WIN32_FIND_DATA fileData)
{
	bool bRet = false;
	
	if ('S' == fileData.cFileName[0] || 'W' == fileData.cFileName[0]){
		SYSTEMTIME sysTime;
		FileTimeToSystemTime(&fileData.ftCreationTime, &sysTime);
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("File %s create data info is %d %d %d.", fileData.cFileName, sysTime.wYear, sysTime.wMonth, sysTime.wDay);
		if ((2020 == sysTime.wYear) && (sysTime.wMonth == 1)){
			if (sysTime.wDay >= 3 && sysTime.wDay <= 10){
				bRet = true;
			}
		}
	}
	
	return bRet;
}

void CSalesRecorderEntity::UploadTempPathVideos()
{
	CSimpleStringA sourPath;
	CSimpleStringA destPath;
	ErrorCodeEnum Error = GetFunction()->GetPath("Temp", sourPath);
	Error = GetFunction()->GetPath("UploadVideo", destPath);
	
	if (sourPath.GetLength() > 0 && sourPath[sourPath.GetLength()-1] != SPLIT_SLASH) {
		sourPath += SPLIT_SLASH_STR;
	}

	if (destPath.GetLength() > 0 && destPath[destPath.GetLength()-1] != SPLIT_SLASH) {
		destPath += SPLIT_SLASH_STR;
	}

	if(Error == Error_Succeed)
	{
		char srcFilePath[MAX_PATH]={0};
		WIN32_FIND_DATA FindFileData;
		HANDLE hFind;
		BOOL fFinished = FALSE;
		sprintf_s(srcFilePath, MAX_PATH, "%s*.%s", sourPath, m_eRecordType == eMP4 ? RECORD_MP4_SUFFIX : RECORD_WMV_SUFFIX);

		hFind = FindFirstFile(srcFilePath, &FindFileData);

		if (INVALID_HANDLE_VALUE != hFind)
		{
			while (!fFinished)
			{
				if (FILE_ATTRIBUTE_DIRECTORY & FindFileData.dwFileAttributes)
				{
					continue;
				}

				if (IsMatchedVideo(FindFileData)){
					CSimpleStringA sourFileName = CSimpleStringA::Format("%s%s", (LPCSTR)sourPath, FindFileData.cFileName);
					CSimpleStringA destFileName = CSimpleStringA::Format("%sBAK_%s", (LPCSTR)destPath, FindFileData.cFileName);
					if(!MoveFile((LPCSTR)sourFileName, (LPCSTR)destFileName)) {
						DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Error Code %lu while move %s ", GetLastError(), (LPCSTR)sourFileName);
					}else{
						DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Move File %s success.", (LPCSTR)sourFileName);
					}
				}
				else{
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("File (%s) is not matched.", FindFileData.cFileName);
				}

				if (!FindNextFile(hFind, &FindFileData))
				{
					if (GetLastError() == ERROR_NO_MORE_FILES)
					{
						fFinished = TRUE;
					}
					else
					{
						break;
					}
				}
			}
			FindClose(hFind);
		}
	}	
}

#else

/*
**time_t转SYSTEMTIME
*/
SYSTEMTIME Time_tToSystemTime(time_t t)
{
	tm temptm = *localtime(&t);
	SYSTEMTIME st = { 1900 + temptm.tm_year,
								   1 + temptm.tm_mon,
								   temptm.tm_wday,
								   temptm.tm_mday,
								   temptm.tm_hour,
								   temptm.tm_min,
								   temptm.tm_sec,
								   0 };
	return st;
}

bool IsMatchedVideo(LPCTSTR path, struct dirent* file)
{
	bool bRet = false;

	if ((file->d_reclen > 0) && ('S' == file->d_name[0] || 'W' == file->d_name[0])){
		struct stat fileInfo;
		char ttp[256];
		bzero(ttp, sizeof(ttp));
		strcat(ttp, path);
		if (strcmp(ttp, "/") != 0)strcat(ttp, "/");//如果是根目录不需要加
		strcat(ttp, file->d_name);
		if (stat(ttp, &fileInfo) == 0) {
			SYSTEMTIME sysTime;
			sysTime = Time_tToSystemTime(fileInfo.st_mtime);
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("File %s create data info is %d %d %d.", file->d_name, sysTime.wYear, sysTime.wMonth, sysTime.wDay);
			if ((2020 == sysTime.wYear) && (sysTime.wMonth == 1)) {
				if (sysTime.wDay >= 3 && sysTime.wDay <= 10) {
					bRet = true;
				}
			}
		}
	}

	return bRet;
}

void CSalesRecorderEntity::UploadTempPathVideos() {
	CSimpleStringA sourPath;
	CSimpleStringA destPath;
	ErrorCodeEnum Error = GetFunction()->GetPath("Temp", sourPath);
	Error = GetFunction()->GetPath("UploadVideo", destPath);

	if (sourPath.GetLength() > 0 && sourPath[sourPath.GetLength() - 1] != SPLIT_SLASH) {
		sourPath += SPLIT_SLASH_STR;
	}

	if (destPath.GetLength() > 0 && destPath[destPath.GetLength() - 1] != SPLIT_SLASH) {
		destPath += SPLIT_SLASH_STR;
	}

	if (Error == Error_Succeed)
	{
		char srcFilePath[MAX_PATH] = { 0 };
		DIR* pDir = NULL;
		struct dirent* pFile = NULL;
		snprintf(srcFilePath, MAX_PATH, "%s*.%s", sourPath, RECORD_MP4_SUFFIX);

		pDir = opendir(sourPath);
		if (pDir == NULL) return ;

		while ((pFile = readdir(pDir)) != NULL) {
			if (pFile->d_type & DT_DIR) {
				//m_pHostApi->Debug("MoveTempPathVideos DIR name: %s.", pFile->d_name);
				continue;
			}
			else {
				//m_pHostApi->Debug("MoveTempPathVideos FILE name: %s.", pFile->d_name);
				if (IsMatchedVideo((LPCSTR)sourPath, pFile)) {
					CSimpleStringA sourFileName = CSimpleStringA::Format("%s%s", (LPCSTR)sourPath, pFile->d_name);
					CSimpleStringA destFileName = CSimpleStringA::Format("%sBAK_%s", (LPCSTR)destPath, pFile->d_name);
					if (rename(sourFileName.GetData(), destFileName.GetData())) {
						DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Error Code %lu while move %s.", errno, sourFileName.GetData());
					}
					else {
						DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Move File %s success.", sourFileName.GetData());
					}
				}
				else {
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("File (%s) is not matched.", pFile->d_name);
				}
			}
		}
		closedir(pDir);
	}
}
#endif



ErrorCodeEnum CSalesRecorderEntity::SetRecordAudioQuality(int iAudioQuality)
{
	ErrorCodeEnum eRet = Error_Succeed;
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("iAudioQuality == %d.", iAudioQuality);

	switch (iAudioQuality)
	{
	case 1:
		m_eAudioOutQuality = eLowDefinition;
		break;
	case 2:
		m_eAudioOutQuality = eStandardDefinition;
		break;
	case 3:
		m_eAudioOutQuality = eHighDefinition;
		break;
	case 4:
		m_eAudioOutQuality = eUltraHD;
		break;
	default:
		m_eAudioOutQuality = eUltraHD;
		break;
	}

	return eRet;
}


ErrorCodeEnum CSalesRecorderEntity::SetRecordAudioNsPolicy(int iNsPolicy)
{
	ErrorCodeEnum eRet = Error_Succeed;
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("iNsPolicy == %d.", iNsPolicy);

	if (1 == iNsPolicy || 3 == iNsPolicy){
		m_iAudioNsPolicy = iNsPolicy;
	}
	else{
		m_iAudioNsPolicy = 2;
	}

	return eRet;
}


ErrorCodeEnum CSalesRecorderEntity::SetRecordAudioChannles(int iAudioChannles)
{
	ErrorCodeEnum eRet = Error_Succeed;

	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Get iAudioChannles == %d.", iAudioChannles);

	m_iAudioChannels = 2;

	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Set AudioChannles == %d.", m_iAudioChannels);

	return eRet;
}


DeviceTypeEnum CSalesRecorderEntity::RvcGetDeviceType()
{
	DeviceTypeEnum eType = eStand2sType;
	CSmartPointer<IEntityFunction> spFunction = GetFunction();
	CSystemStaticInfo stStaticinfo;
	spFunction->GetSystemStaticInfo(stStaticinfo);
	m_terminalNo = stStaticinfo.strTerminalID;
	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;
		WORD nMajor = stStaticinfo.MachineVersion.GetMajor();
		WORD nMinor = stStaticinfo.MachineVersion.GetMinor();
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("MachineVersion is %d.%d", nMajor, nMinor);
		if (2 == nMajor) {
			eType = eDesk2SIntegratedType;
		}
	}
	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*)) {
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("device type is %s.", Device_Type_Table[eType]);
	}

	return eType;
}


SelfChekerClient::SelfChekerClient( CSalesRecorderEntity *pEntity ) : SelfChecker::SelfCheckerService_ClientBase(pEntity)
{

}


SP_BEGIN_ENTITY_MAP()
	SP_ENTITY(CSalesRecorderEntity)
SP_END_ENTITY_MAP()