myvtm/DevAdapter/grg/hspscanner.1.1/hspscanner_impl.cpp

#include "hspscanner_impl.h"
#include <cstring>
#include <cstdio>
#include <unistd.h>
#include "log4vendor.h"
#include "dlfcn.h"
#include "BHCamBase.h"

class Inner_Log{
	public:
		Inner_Log(const char* funcname){
			memset(m_funcname,0,sizeof(m_funcname));
			strcpy(m_funcname,funcname);
			LOG4VTM(INFO,"========"<<m_funcname<<" entry");
		}
		~Inner_Log(){
			LOG4VTM(INFO,"========"<<m_funcname<<" leave");
		}
	private:
		char m_funcname[256];
};

#define DEFAULT_HPIXEL	3264
#define DEFAULT_VPIXEL	2448
#define IMAGEBUFF_SIZE	(DEFAULT_HPIXEL*DEFAULT_VPIXEL*3)

#ifdef LOG4VTM_FUNCTION
#undef LOG4VTM_FUNCTION
#define LOG4VTM_FUNCTION()	\
		Inner_Log log(__FUNCTION__);
#endif 

#define CHECK_FUNC_VALID(funcname)	\
		if(funcname == NULL){\
			FormatDevErrorInfo(__FUNCTION__, __LINE__,Error_Unexpect, #funcname" == NULL");\
			return Error_Unexpect;\
		}

#define CHECK_RETURN_VALUE(funcname,ret,retvalue)	\
		if(ret != FR_RET_SUCC)\
		{\
			FormatDevErrorInfo(__FUNCTION__, __LINE__,ret, #funcname" Failed");\
			return retvalue;\
		}

HSPSClassImpl::HSPSClassImpl()
	:m_mode(0)
{
	ResetParm();
	//m_pBuffPic = (unsigned char*)malloc(IMAGEBUFF_SIZE);
	m_hSo = NULL;
	m_hSo = dlopen("libBHCamBase.grg.so", RTLD_LAZY);
	if(m_hSo)
	{
		HIGH_StartCamera 			= (PHIGH_StartCamera)dlsym(m_hSo,"HIGH_StartCamera");
		HIGH_GetFirmwareVersion 	= (PHIGH_GetFirmwareVersion)dlsym(m_hSo,"HIGH_GetFirmwareVersion");
		HIGH_GetStatus 				= (PHIGH_GetStatus)dlsym(m_hSo,"HIGH_GetStatus");
		HIGH_StopCamera 			= (PHIGH_StopCamera)dlsym(m_hSo,"HIGH_StopCamera");
		HIGH_SetAutoCrop 			= (PHIGH_SetAutoCrop)dlsym(m_hSo,"HIGH_SetAutoCrop");
		HIGH_SetCameraPixel 		= (PHIGH_SetCameraPixel)dlsym(m_hSo,"HIGH_SetCameraPixel");
		HIGH_SetRotateSize 			= (PHIGH_SetRotateSize)dlsym(m_hSo,"HIGH_SetRotateSize");
		HIGH_SetColorType 			= (PHIGH_SetColorType)dlsym(m_hSo,"HIGH_SetColorType");
		HIGH_SetJPGQuality 			= (PHIGH_SetJPGQuality)dlsym(m_hSo,"HIGH_SetJPGQuality");
		HIGH_GetPixelNum 			= (PHIGH_GetPixelNum)dlsym(m_hSo,"HIGH_GetPixelNum");
		HIGH_GetHPixelByIndex 		= (PHIGH_GetHPixelByIndex)dlsym(m_hSo,"HIGH_GetHPixelByIndex");
		HIGH_GetVPixelByIndex 		= (PHIGH_GetVPixelByIndex)dlsym(m_hSo,"HIGH_GetVPixelByIndex");
		HIGH_CreateWindow 			= (PHIGH_CreateWindow)dlsym(m_hSo,"HIGH_CreateWindow");
		HIGH_CloseWindow 			= (PHIGH_CloseWindow)dlsym(m_hSo,"HIGH_CloseWindow");
		HIGH_PauseAndPlay 			= (PHIGH_PauseAndPlay)dlsym(m_hSo,"HIGH_PauseAndPlay");
		HIGH_TakePicture 			= (PHIGH_TakePicture)dlsym(m_hSo,"HIGH_TakePicture");
		HIGH_CameraData 			= (PHIGH_CameraData)dlsym(m_hSo,"HIGH_CameraData");
		HIGH_HideWindow 			= (PHIGH_HideWindow)dlsym(m_hSo,"HIGH_HideWindow");
	}else{
		FormatDevErrorInfo(__FUNCTION__, __LINE__,Error_Unexpect, "dlopen Failed");
	}
}

HSPSClassImpl::~HSPSClassImpl()
{
	if(m_hSo)
	{
		dlclose(m_hSo);
		m_hSo = NULL;
	}
/*	
	if(m_pBuffPic)
	{
		free(m_pBuffPic);
	}
*/	
	DevClose();
}

void HSPSClassImpl::ResetParm()
{
	memset(&m_status,0,sizeof(m_status));
	m_nX = 0;
	m_nY = 0;
	m_nWidth = DEFAULT_DIALOG_WIDTH;
	m_bAutoCorp = true;
	m_nColorType = 0;
	m_nRotateSize = 0;
}

void HSPSClassImpl::ZeroDevErrorInfo()
{
	memset(&m_DevErrorInfo, 0, sizeof(m_DevErrorInfo));
}

void HSPSClassImpl::FormatDevErrorInfo(const char* funcname, int line, int errCode,const char* errStr)
{
	ZeroDevErrorInfo();
	//snprintf(m_DevErrorInfo.szErrMsg, sizeof(m_DevErrorInfo.szErrMsg), "ErrCode:0x%x,Description:Func:%s,Line:%d,Msg:%s", errCode, funcname, line, errStr);
	snprintf(m_DevErrorInfo.szErrMsg, sizeof(m_DevErrorInfo.szErrMsg), "{\"ErrCode\":0x%x,\"Description\":\"Func:%s,Line:%d,Msg:%s\"}", errCode, funcname, line, errStr);
	m_DevErrorInfo.dwErrMsgLen = strlen(m_DevErrorInfo.szErrMsg);
	LOG4VTM(ERROR,m_DevErrorInfo.szErrMsg);
}

ErrorCodeEnum HSPSClassImpl::GetDevCategory(DevCategoryInfo &devCategory)
{
	LOG4VTM_FUNCTION();
	ErrorCodeEnum err = Error_Succeed;
	const char *pType = "PVER=ShenGuoTu#MID=Q800L";
	const char *pMode = "FWID=0";
	const char *pVendor = "grg";
	strcpy(devCategory.szType, pType);
	strcpy(devCategory.szModel, pMode);
	strcpy(devCategory.szVendor, pVendor);
	devCategory.version.wMajor = 1;
	devCategory.version.wMinor = 1;
	devCategory.version.wRevision = 65535;
	devCategory.version.wBuild = 1;
/*	
	CHECK_FUNC_VALID(HIGH_GetFirmwareVersion);
	char szVersion[64] = {0};
	int ret = HIGH_GetFirmwareVersion(szVersion);
	CHECK_RETURN_VALUE(HIGH_GetFirmwareVersion,ret,Error_Unexpect);
	printf("szVersion = %s\n",szVersion);
*/
	return err;
}

ErrorCodeEnum HSPSClassImpl::DevOpen()
{
	LOG4VTM_FUNCTION();
	ErrorCodeEnum err = Error_Succeed;
	DevClose();
	CHECK_FUNC_VALID(HIGH_StartCamera);
	int ret = HIGH_StartCamera();
	CHECK_RETURN_VALUE(HIGH_StartCamera,ret,Error_DevConnFailed);
	m_status.isConnected = 1;
	int hPixel = DEFAULT_HPIXEL;
	int vPixel = DEFAULT_VPIXEL;
	LOG4VTM(INFO,"========HIGH_SetCameraPixel entry");
	CHECK_FUNC_VALID(HIGH_SetCameraPixel);
	ret = HIGH_SetCameraPixel(hPixel,vPixel);
	CHECK_RETURN_VALUE(HIGH_SetCameraPixel,ret,Error_Unexpect);
	LOG4VTM(INFO,"========HIGH_SetCameraPixel leave");
	return err;
}

ErrorCodeEnum HSPSClassImpl::Reset()
{
	LOG4VTM_FUNCTION();
	ErrorCodeEnum err = Error_Succeed;
	DevClose();
	ResetParm();
	DevOpen();
	return err;
}

ErrorCodeEnum HSPSClassImpl::DevClose()
{
	LOG4VTM_FUNCTION();
	ErrorCodeEnum err = Error_Succeed;
	if(m_status.inPreview)
	{
		CHECK_FUNC_VALID(HIGH_CloseWindow);
		HIGH_CloseWindow();
	}
	CHECK_FUNC_VALID(HIGH_StopCamera);
	//if(m_status.isConnected)
	{
		HIGH_StopCamera();
	}
	m_status.isConnected = 0;
	m_status.inPreview = 0;
	m_status.inShow = 0;
	return err;
}

ErrorCodeEnum HSPSClassImpl::SetParam(ParamType type, ParamTypeValue value)
{
	try{
		LOG4VTM_FUNCTION();
		LOG4VTM(INFO,"ParamType = "<<type<<" ParamTypeValue = "<<value);
		switch(type){
			case HSPS_MODEL_COLOR:
				if(value == HSPS_COLOR_GREY)
				{
					m_nColorType = 1;
				}else
				{
					m_nColorType = 0;
				}
			break;
			case HSPS_MODEL_ROTATE:
				if(value == HSPS_ROTATE_LEFT)
				{
					m_nRotateSize = 1;
				}else if(value == HSPS_ROTATE_MIRROR)
				{
					m_nRotateSize = 2;
				}else if(value == HSPS_ROTATE_RIGHT)
				{
					m_nRotateSize = 3;
				}else{
					m_nRotateSize = 0;
				}
			break;
			case HSPS_MODEL_SCANSIZE:
				if(value == HSPS_SCAN_FULL || value == HSPS_SCAN_A4)
				{
					m_bAutoCorp = false;
				}else{
					m_bAutoCorp = true;
				}
			break;
			case HSPS_MODEL_VIEW:
				CHECK_FUNC_VALID(HIGH_HideWindow);
				if(value == HSPS_VIEW_HIDE)
				{
					if(	m_status.inPreview)
					{
						if(m_status.inShow)
						{
							int ret = HIGH_HideWindow(true);
							CHECK_RETURN_VALUE(HIGH_HideWindow,ret,Error_Unexpect);
							m_status.inShow = 0;
						}
					}
				}else{
					if(	m_status.inPreview)
					{
						if(!m_status.inShow){
							int ret = HIGH_HideWindow(false);
							CHECK_RETURN_VALUE(HIGH_HideWindow,ret,Error_Unexpect);
							m_status.inShow = 1;
						}
					}
				}
			break;
		default:
			break;
		}

		CHECK_FUNC_VALID(HIGH_SetAutoCrop);
		int ret = HIGH_SetAutoCrop(m_bAutoCorp);
		CHECK_RETURN_VALUE(HIGH_SetAutoCrop,ret,Error_Unexpect);

		CHECK_FUNC_VALID(HIGH_SetColorType);
		ret = HIGH_SetColorType(m_nColorType);
		CHECK_RETURN_VALUE(HIGH_SetColorType,ret,Error_Unexpect);

		CHECK_FUNC_VALID(HIGH_SetRotateSize);
		ret = HIGH_SetRotateSize(m_nRotateSize);
		CHECK_RETURN_VALUE(HIGH_SetRotateSize,ret,Error_Unexpect);
	}
	catch(const std::exception& e)
	{
		LOG4VTM(ERROR,"========SetParam coredump:"<<e.what());
		return Error_Unexpect;
	}
	return Error_Succeed;
}

ErrorCodeEnum HSPSClassImpl::SetPreview(short nValue)
{
	try{	
		LOG4VTM_FUNCTION();
		LOG4VTM(INFO,"nValue = "<<nValue);	
/*		
		//check dev status
		int iStatus;
		CHECK_FUNC_VALID(HIGH_GetStatus);
		HIGH_GetStatus(&iStatus);
		LOG4VTM(INFO,"GetDevStatus dev return = "<<iStatus);
		if(FR_DS_ONLINE != iStatus)
		{
			//if not connected then reopen dev
			ErrorCodeEnum retcode = DevOpen();
			if(Error_Succeed != retcode)
				return retcode;
		}
		//
*/		
		int ret = 0;
		if(nValue)
		{
			//Check device is available
			HspsDevStatus status;
			GetDevStatus(status);
			if(!m_status.isConnected)
			{
				FormatDevErrorInfo(__FUNCTION__, __LINE__,Error_NotInit, "device NotInit or NotExist");
				return Error_NotInit;
			}
			//if already previewed,return
			if(m_status.inPreview)
			{
				LOG4VTM(INFO,"========already previewed m_status.inPreview = " << m_status.inPreview);
				return Error_Succeed;
			}
				
			LOG4VTM(INFO,"========HIGH_SetAutoCrop entry");
			CHECK_FUNC_VALID(HIGH_SetAutoCrop);
			ret = HIGH_SetAutoCrop(m_bAutoCorp);
			CHECK_RETURN_VALUE(HIGH_SetAutoCrop,ret,Error_Unexpect);
			LOG4VTM(INFO,"========HIGH_SetAutoCrop leave");
			
			LOG4VTM(INFO,"========HIGH_SetColorType entry");
			CHECK_FUNC_VALID(HIGH_SetColorType);
			ret = HIGH_SetColorType(m_nColorType);
			CHECK_RETURN_VALUE(HIGH_SetColorType,ret,Error_Unexpect);
			LOG4VTM(INFO,"========HIGH_SetColorType leave");
			
			LOG4VTM(INFO,"========HIGH_SetRotateSize entry");
			CHECK_FUNC_VALID(HIGH_SetRotateSize);
			ret = HIGH_SetRotateSize(m_nRotateSize);
			CHECK_RETURN_VALUE(HIGH_SetRotateSize,ret,Error_Unexpect);
			LOG4VTM(INFO,"========HIGH_SetRotateSize leave");
			
	/*		
			if(HIGH_GetPixelNum == NULL){
				FormatDevErrorInfo(__FUNCTION__, __LINE__,Error_Unexpect, "HIGH_GetPixelNum == NULL");
				return Error_Unexpect;
			}
			int num = HIGH_GetPixelNum();
	*/		
	/*		
			if(HIGH_GetHPixelByIndex == NULL || HIGH_GetVPixelByIndex == NULL){
				FormatDevErrorInfo(__FUNCTION__, __LINE__,Error_Unexpect, "HIGH_GetHPixelByIndex == NULL || HIGH_GetVPixelByIndex == NULL");
				return Error_Unexpect;
			}
			
			int hPixel = HIGH_GetHPixelByIndex(0);
			int vPixel = HIGH_GetVPixelByIndex(0);
			printf("hPixel = %d,vPixel = %d\n",hPixel,vPixel);
	*/
/*	
			int hPixel = DEFAULT_HPIXEL;
			int vPixel = DEFAULT_VPIXEL;

			LOG4VTM(INFO,"========HIGH_SetCameraPixel entry");
			CHECK_FUNC_VALID(HIGH_SetCameraPixel);
			ret = HIGH_SetCameraPixel(hPixel,vPixel);
			CHECK_RETURN_VALUE(HIGH_SetCameraPixel,ret,Error_Unexpect);
			LOG4VTM(INFO,"========HIGH_SetCameraPixel leave");
*/
			LOG4VTM(INFO,"========HIGH_CreateWindow entry");
			CHECK_FUNC_VALID(HIGH_CreateWindow);
			ret = HIGH_CreateWindow(m_nX,m_nY,m_nWidth,m_nWidth*9/16);
			CHECK_RETURN_VALUE(HIGH_CreateWindow,ret,Error_Unexpect);
			LOG4VTM(INFO,"========HIGH_CreateWindow leave");
		}else
		{
			LOG4VTM(INFO,"========HIGH_CloseWindow entry");
			CHECK_FUNC_VALID(HIGH_CloseWindow);
			ret = HIGH_CloseWindow();
			CHECK_RETURN_VALUE(HIGH_CloseWindow,ret,Error_Unexpect);
			LOG4VTM(INFO,"========HIGH_CloseWindow leave");
		}
	}catch(const std::exception& e)
	{
		LOG4VTM(ERROR,"========SetPreview coredump:"<<e.what());
		return Error_Unexpect;
	}
	
	m_status.inPreview = nValue;
	m_status.inShow = nValue;
	return Error_Succeed;
}

ErrorCodeEnum HSPSClassImpl::ScanImage(const char* pszFileName)
{
	LOG4VTM_FUNCTION();
	LOG4VTM(INFO,"pszFileName = "<<pszFileName);
	CHECK_FUNC_VALID(HIGH_TakePicture);
	DeleteOldPic(pszFileName);
	int ret = HIGH_TakePicture(pszFileName);
	CHECK_RETURN_VALUE(HIGH_TakePicture,ret,Error_Unexpect);
	CheckSavePic(pszFileName);
	return Error_Succeed;
}

ErrorCodeEnum HSPSClassImpl::ScanImageEx(BYTE* pBtImg, int& nBtLen, const char* pszFileName)
{
	LOG4VTM_FUNCTION();
	LOG4VTM(INFO,"input nBtLen = "<<nBtLen<<" pszFileName = "<<pszFileName);
	const char* filename = "/tmp/HSPTempImage.jpg";
	CHECK_FUNC_VALID(HIGH_TakePicture);
	FILE* fp = NULL;
	int ret = 0;
	if(nBtLen == 0)
	{
		//get pic size
		if(strlen(pszFileName) != 0)
		{
			ret = HIGH_TakePicture(pszFileName);
			CHECK_RETURN_VALUE(HIGH_TakePicture,ret,Error_Unexpect);
			fp = fopen(pszFileName,"rb");
		}else{
			ret = HIGH_TakePicture(filename);
			CHECK_RETURN_VALUE(HIGH_TakePicture,ret,Error_Unexpect);
			fp = fopen(filename,"rb");
		}
		
		if(fp)
		{
			fseek(fp,0,SEEK_END);
			nBtLen=ftell(fp);
			LOG4VTM(INFO,"ScanImageEx get nBtLen = "<<nBtLen);
			fclose(fp);
			fp = NULL;
		}
		FormatDevErrorInfo(__FUNCTION__, __LINE__,Error_TooSmallBuffer, "ScanImageEx Error_TooSmallBuffer");
		return Error_TooSmallBuffer;
	}
	
	if(pBtImg == NULL)
	{
		FormatDevErrorInfo(__FUNCTION__, __LINE__,Error_Param, "pBtImg == NULL");
		return Error_Param;
	}
	
	if(strlen(pszFileName) != 0)
	{
		fp = fopen(pszFileName,"rb");
		if(fp)
		{
			fread(pBtImg,1,nBtLen,fp);
			fclose(fp);
			fp = NULL;
		}else{
			LOG4VTM(ERROR,"get image data file fp == NULL,pszFileName = "<<pszFileName);
		}
	}else{
		fp = fopen(filename,"rb");
		if(fp)
		{
			fread(pBtImg,1,nBtLen,fp);
			fclose(fp);
			fp = NULL;
		}else{
			LOG4VTM(ERROR,"get image data file fp == NULL,filename = "<<filename);
		}
		remove(filename);
	}
	
/*		
	const int nSize = 1024*700;//DEFAULT_HPIXEL*DEFAULT_VPIXEL*3;
	char* pTemp = (char*)malloc(DEFAULT_HPIXEL*DEFAULT_VPIXEL*3);
	if(nBtLen < nSize)
	{
		nBtLen = nSize;
		FormatDevErrorInfo(__FUNCTION__, __LINE__,Error_TooSmallBuffer, "ScanImageEx Error_TooSmallBuffer");
		return Error_TooSmallBuffer;
	}
	
	if(pBtImg == NULL)
	{
		//pBtImg = m_pBuffPic;
		FormatDevErrorInfo(__FUNCTION__, __LINE__,Error_Param, "pBtImg == NULL");
		return Error_Param;
	}
		
	CHECK_FUNC_VALID(HIGH_CameraData);
	//int ret = HIGH_CameraData((char*)pBtImg);
	int ret = HIGH_CameraData((char*)pTemp);
	CHECK_RETURN_VALUE(HIGH_CameraData,ret,Error_Unexpect);
	memcpy(pBtImg,pTemp,nSize);
	free(pTemp);
	
	if(strlen(pszFileName) != 0)
	{
		CHECK_FUNC_VALID(HIGH_TakePicture);
		DeleteOldPic(pszFileName);
		ret = HIGH_TakePicture(pszFileName);
		CHECK_RETURN_VALUE(HIGH_TakePicture,ret,Error_Unexpect);
		CheckSavePic(pszFileName);
	}
*/	
	return Error_Succeed;
}

ErrorCodeEnum HSPSClassImpl::SetViewPos(int nX, int nY, int nWidth)
{
	LOG4VTM_FUNCTION();
	LOG4VTM(INFO,"nX = "<<nX<<" nY = "<<nY<<" nWidth = "<<nWidth);
	if(nWidth == 0)   //bhj  宽度参数为0时，设置隐藏，不再返回参数错误。
	{
		//special process
		LOG4VTM(INFO,"nWidth == 0 special process");
		if(m_status.inPreview)
		{
			if(m_status.inShow)
			{
				CHECK_FUNC_VALID(HIGH_HideWindow);
				int ret = HIGH_HideWindow(true);
				CHECK_RETURN_VALUE(HIGH_HideWindow,ret,Error_Unexpect);
				m_status.inShow = 0;
			}
		}

		return Error_Succeed;
	}
	
	//exception process  //bhj
	if(nX<0 || nY<0 || nWidth<0)
	{
		LOG4VTM(ERROR,"nX<0 || nY<0 || nWidth<0 Error_Param");
		return Error_Param;
	}
	
	m_nX = nX;
	m_nY = nY;
	m_nWidth = nWidth;
	if(m_status.inPreview)
	{
		SetPreview(0);
		SetPreview(1);
	}
	return Error_Succeed;
}

ErrorCodeEnum HSPSClassImpl::SetProperty()
{
	LOG4VTM_FUNCTION();
	return Error_NotImpl;
}

ErrorCodeEnum HSPSClassImpl::GetDevStatus(HspsDevStatus& status)
{
	LOG4VTM_FUNCTION();
	int iStatus;
	CHECK_FUNC_VALID(HIGH_GetStatus);
	HIGH_GetStatus(&iStatus);
	LOG4VTM(INFO,"GetDevStatus dev return = "<<iStatus);
	if(FR_DS_ONLINE != iStatus)
	{
		m_status.isConnected = 0;
	}
	status = m_status;
/*	
	int iStatus;
	if(HIGH_GetStatus == NULL){
		FormatDevErrorInfo(__FUNCTION__, __LINE__,Error_Unexpect, "HIGH_GetStatus == NULL");
		return Error_Unexpect;
	}
	HIGH_GetStatus(&iStatus);
	printf("GetDevStatus = %d\n",iStatus);
*/	
	return Error_Succeed;
}

ErrorCodeEnum HSPSClassImpl::GetLastErr(DevErrorInfo &devErrInfo)
{
	memset(&devErrInfo, 0, sizeof(devErrInfo));
	memcpy(&devErrInfo, &m_DevErrorInfo, sizeof(devErrInfo));
	return Error_Succeed;
}

void HSPSClassImpl::DeleteOldPic(const char* pszFileName)
{
/*	
	FILE* fp = NULL;
	fp = fopen(pszFileName,"rb");
	if(fp)
	{
		remove(pszFileName);
		fclose(fp);
	}
*/	
}

void HSPSClassImpl::CheckSavePic(const char* pszFileName){
/*	
	FILE* fp = NULL;
	int time = 0;
	while(!fp && time++ < 5)//检测次数5次
	{
		sleep(1);
		fp = fopen(pszFileName,"rb");
	}
	if(fp)
		fclose(fp);
*/		
}

DEVICEBASE_API ErrorCodeEnum CreateDevComponent(DeviceBaseClass *&baseObj)
{
	baseObj = new HSPSClassImpl();
	if(baseObj == NULL) {
		return Error_Resource;
	} else {
		cmb::log_init_config config;
		config.dev_name = "HSPScanner";
		config.log_level = CMB_LOG_LEVEL_TRACE;
#if defined(_MSC_VER)
		config.log_dir = ("C:\\rvc\\dbg\\");
#else
		config.log_dir = ("/opt/rvc/dbg/");
#endif //_MSC_VER
		std::string str;
		cmb::log4vendor::init(config, str);
		printf("init after: %s\n", str.c_str());
		return Error_Succeed;
	}
}

DEVICEBASE_API ErrorCodeEnum  ReleaseDevComponent(DeviceBaseClass *&pBaseObj)
{
	if(pBaseObj == NULL) {
		return Error_Param;
	}

	if(HSPSClassImpl* pTmp = dynamic_cast<HSPSClassImpl*>(pBaseObj))
	{
		delete pTmp;
		pTmp = NULL;
		return Error_Succeed;
	}

	return Error_Param;
}