WebSocket::~WebSocket()
{
// close();
// CC_SAFE_RELEASE_NULL(_wsHelper);
for (int i = 0; _wsProtocols[i].callback != nullptr; ++i)
{
SAFE_DELETEARRAY(_wsProtocols[i].name);
}
SAFE_DELETEARRAY(_wsProtocols);
}
void WebSocket::onUIThreadReceiveMessage(WsMessage* msg)
{
switch (msg->what) {
case WS_MSG_TO_UITHREAD_OPEN:
{
_delegate->onOpen(this);
}
break;
case WS_MSG_TO_UITHREAD_MESSAGE:
{
Data* data = (Data*)msg->obj;
_delegate->onMessage(this, *data);
SAFE_DELETEARRAY(data->bytes);
SAFE_DELETE(data);
}
break;
case WS_MSG_TO_UITHREAD_CLOSE:
{
//Waiting for the subThread safety exit
// _wsHelper->joinSubThread();
_delegate->onClose(this);
}
break;
case WS_MSG_TO_UITHREAD_ERROR:
{
// FIXME: The exact error needs to be checked.
WebSocket::ErrorCode err = ErrorCode::CONNECTION_FAILURE;
_delegate->onError(this, err);
}
break;
default:
break;
}
}
/// 지형객체를 메모리에서 소거한다.
HRESULT ZTerrain::_Destroy()
{
DettachChildNode(m_pQuadTree);
SAFE_DELETE( m_pQuadTree );
SAFE_DELETEARRAY( m_pvHeightMap );
SAFE_RELEASE( m_pRscVertexBuffer );
SAFE_RELEASE( m_pRscIndexBuffer );
SAFE_RELEASE( m_pTex );
return S_OK;
}
bool CTemplateManager::_Resize()
{
int nNewMaxCount = m_MaxTemplateCount + DB_TEMPLATE_INC_COUNT;
CDBTemplate* pNewTemplateArray = new CDBTemplate[nNewMaxCount];
if (!pNewTemplateArray)
{
return false;
}
if (m_TemplateCount > 0)
{
memcpy(pNewTemplateArray, m_pTemplateArray, sizeof(CDBTemplate)*m_TemplateCount);
}
SAFE_DELETEARRAY(m_pTemplateArray);
m_pTemplateArray = pNewTemplateArray;
m_MaxTemplateCount = nNewMaxCount;
return true;
}
bool CDBTemplateStruct::_Resize()
{
int nNewMaxCount = m_MaxColumnInfoCount + DB_COLUMN_INC_COUNT;
ColumnInfo* pColumnInfoArray = new ColumnInfo[nNewMaxCount];
if (!pColumnInfoArray)
{
return false;
}
if (m_ColumnInfoCount > 0)
{
memcpy(pColumnInfoArray, m_pColumnInfo, m_ColumnInfoCount);
}
SAFE_DELETEARRAY(m_pColumnInfo);
m_pColumnInfo = pColumnInfoArray;
m_MaxColumnInfoCount = nNewMaxCount;
return true;
}
//set image resolution
void CPURayTracer::SetImageResolution( int w , int h )
{
//check if there is need to allocate the data for new resolution
if( w == m_iImageWidth && h == m_iImageHeight )
return;
//copy the data
m_iImageWidth = w;
m_iImageHeight = h;
float aspect = (float) w / (float) h;
D3DXMatrixPerspectiveFovLH( &m_ProjectionMatrix , D3DX_PI/4 , aspect , 1.0f , 5000.0f );
//allocate the memory
SAFE_DELETEARRAY(m_pImageBackBuffer);
m_pImageBackBuffer = new _float4[ w * h ];
}
CFileObject::~CFileObject()
{
//
// The object is bound to the file handle and so this happens after close and the
// framework guarentees all requests on the file handle are cancelled prior to close
//
EnterCriticalSection(&m_RoleLock);
NT_ASSERT(m_Request == nullptr);
LeaveCriticalSection(&m_RoleLock);
PurgeQueue();
SAFE_DELETEARRAY(m_pszType);
SAFE_DELETE(m_pConnection);
DeleteCriticalSection(&m_RoleLock);
m_FileObject = nullptr;
}
CTemplateManager::~CTemplateManager()
{
SAFE_DELETEARRAY(m_pTemplateArray);
}
CPURayTracer::~CPURayTracer()
{
SAFE_DELETEARRAY(m_pImageBackBuffer);
}
int WebSocket::onSocketCallback(struct rtchatsdk_libwebsocket_context *ctx,
struct rtchatsdk_libwebsocket *wsi,
int reason,
void *user, void *in, ssize_t len)
{
// Public::sdklog("socket callback for %d reason", reason);
// CCASSERT(_wsContext == nullptr || ctx == _wsContext, "Invalid context.");
// CCASSERT(_wsInstance == nullptr || wsi == nullptr || wsi == _wsInstance, "Invaild websocket instance.");
switch (reason)
{
case LWS_CALLBACK_DEL_POLL_FD:
case LWS_CALLBACK_PROTOCOL_DESTROY:
case LWS_CALLBACK_CLIENT_CONNECTION_ERROR:
{
WsMessage* msg = nullptr;
if (reason == LWS_CALLBACK_CLIENT_CONNECTION_ERROR
|| (reason == LWS_CALLBACK_PROTOCOL_DESTROY && _readyState == State::CONNECTING)
|| (reason == LWS_CALLBACK_DEL_POLL_FD && _readyState == State::CONNECTING)
)
{
msg = new WsMessage();
msg->what = WS_MSG_TO_UITHREAD_ERROR;
_readyState = State::CLOSING;
}
else if (reason == LWS_CALLBACK_PROTOCOL_DESTROY && _readyState == State::CLOSING)
{
msg = new WsMessage();
msg->what = WS_MSG_TO_UITHREAD_CLOSE;
}
if (msg)
{
// _wsHelper->sendMessageToUIThread(msg);
onUIThreadReceiveMessage(msg);
}
}
break;
case LWS_CALLBACK_CLIENT_ESTABLISHED:
{
WsMessage* msg = new WsMessage();
msg->what = WS_MSG_TO_UITHREAD_OPEN;
_readyState = State::OPEN;
/*
* start the ball rolling,
* LWS_CALLBACK_CLIENT_WRITEABLE will come next service
*/
rtchatsdk_libwebsocket_callback_on_writable(ctx, wsi);
// _wsHelper->sendMessageToUIThread(msg);
onUIThreadReceiveMessage(msg);
}
break;
case LWS_CALLBACK_CLIENT_WRITEABLE:
{
pthread_mutex_lock(&_MessageMutex);
// std::lock_guard<std::mutex> lk(_wsHelper->_subThreadWsMessageQueueMutex);
// std::list<WsMessage*>::iterator iter = _wsHelper->_subThreadWsMessageQueue->begin();
int bytesWrite = 0;
for (auto it = _MessageQueue.begin(); it != _MessageQueue.end();) {
WsMessage* subThreadMsg = *it;
if ( WS_MSG_TO_SUBTRHEAD_SENDING_STRING == subThreadMsg->what
|| WS_MSG_TO_SUBTRHEAD_SENDING_BINARY == subThreadMsg->what)
{
Data* data = (Data*)subThreadMsg->obj;
const size_t c_bufferSize = WS_WRITE_BUFFER_SIZE;
size_t remaining = data->len - data->issued;
size_t n = std::min(remaining, c_bufferSize );
// Public::sdklog("[websocket:send] total: %d, sent: %d, remaining: %d, buffer size: %d", static_cast<int>(data->len), static_cast<int>(data->issued), static_cast<int>(remaining), static_cast<int>(n));
unsigned char* buf = new unsigned char[LWS_SEND_BUFFER_PRE_PADDING + n + LWS_SEND_BUFFER_POST_PADDING];
memcpy((char*)&buf[LWS_SEND_BUFFER_PRE_PADDING], data->bytes + data->issued, n);
int writeProtocol;
if (data->issued == 0) {
if (WS_MSG_TO_SUBTRHEAD_SENDING_STRING == subThreadMsg->what)
{
writeProtocol = LWS_WRITE_TEXT;
}
else
{
writeProtocol = LWS_WRITE_BINARY;
}
// If we have more than 1 fragment
if (data->len > c_bufferSize)
writeProtocol |= LWS_WRITE_NO_FIN;
} else {
// we are in the middle of fragments
writeProtocol = LWS_WRITE_CONTINUATION;
// and if not in the last fragment
if (remaining != n)
writeProtocol |= LWS_WRITE_NO_FIN;
}
bytesWrite = rtchatsdk_libwebsocket_write(wsi, &buf[LWS_SEND_BUFFER_PRE_PADDING], n, (rtchatsdk_libwebsocket_write_protocol)writeProtocol);
// Public::sdklog("[websocket:send] bytesWrite => %d", bytesWrite);
// Buffer overrun?
if (bytesWrite < 0)
{
break;
}
// Do we have another fragments to send?
else if (remaining != n)
{
data->issued += n;
break;
}
// Safely done!
else
{
SAFE_DELETEARRAY(data->bytes);
SAFE_DELETE(data);
SAFE_DELETEARRAY(buf);
// _wsHelper->_subThreadWsMessageQueue->erase(iter++);
_MessageQueue.erase(it++);
SAFE_DELETE(subThreadMsg);
}
}
}
pthread_mutex_unlock(&_MessageMutex);
// for (; iter != _wsHelper->_subThreadWsMessageQueue->end();)
// {
// WsMessage* subThreadMsg = *iter;
//
// if ( WS_MSG_TO_SUBTRHEAD_SENDING_STRING == subThreadMsg->what
// || WS_MSG_TO_SUBTRHEAD_SENDING_BINARY == subThreadMsg->what)
// {
// Data* data = (Data*)subThreadMsg->obj;
//
// const size_t c_bufferSize = WS_WRITE_BUFFER_SIZE;
//
// size_t remaining = data->len - data->issued;
// size_t n = std::min(remaining, c_bufferSize );
// Public::sdklog("[websocket:send] total: %d, sent: %d, remaining: %d, buffer size: %d", static_cast<int>(data->len), static_cast<int>(data->issued), static_cast<int>(remaining), static_cast<int>(n));
//
// unsigned char* buf = new unsigned char[LWS_SEND_BUFFER_PRE_PADDING + n + LWS_SEND_BUFFER_POST_PADDING];
//
// memcpy((char*)&buf[LWS_SEND_BUFFER_PRE_PADDING], data->bytes + data->issued, n);
//
// int writeProtocol;
//
// if (data->issued == 0) {
// if (WS_MSG_TO_SUBTRHEAD_SENDING_STRING == subThreadMsg->what)
// {
// writeProtocol = LWS_WRITE_TEXT;
// }
// else
// {
// writeProtocol = LWS_WRITE_BINARY;
// }
//
// // If we have more than 1 fragment
// if (data->len > c_bufferSize)
// writeProtocol |= LWS_WRITE_NO_FIN;
// } else {
// // we are in the middle of fragments
// writeProtocol = LWS_WRITE_CONTINUATION;
// // and if not in the last fragment
// if (remaining != n)
// writeProtocol |= LWS_WRITE_NO_FIN;
// }
//
// bytesWrite = libwebsocket_write(wsi, &buf[LWS_SEND_BUFFER_PRE_PADDING], n, (libwebsocket_write_protocol)writeProtocol);
// Public::sdklog("[websocket:send] bytesWrite => %d", bytesWrite);
//
// // Buffer overrun?
// if (bytesWrite < 0)
// {
// break;
// }
// // Do we have another fragments to send?
// else if (remaining != n)
// {
// data->issued += n;
// break;
// }
// // Safely done!
// else
// {
// SAFE_DELETEARRAY(data->bytes);
// SAFE_DELETE(data);
// SAFE_DELETEARRAY(buf);
//// _wsHelper->_subThreadWsMessageQueue->erase(iter++);
// SAFE_DELETE(subThreadMsg);
// }
// }
// }
/* get notified as soon as we can write again */
rtchatsdk_libwebsocket_callback_on_writable(ctx, wsi);
}
break;
case LWS_CALLBACK_CLOSED:
{
Public::sdklog(" %s", "connection closing..");
// _wsHelper->quitSubThread();
if (_readyState != State::CLOSED)
{
WsMessage* msg = new WsMessage();
_readyState = State::CLOSED;
msg->what = WS_MSG_TO_UITHREAD_CLOSE;
// _wsHelper->sendMessageToUIThread(msg);
onUIThreadReceiveMessage(msg);
}
}
break;
case LWS_CALLBACK_CLIENT_RECEIVE:
{
if (in && len > 0)
{
// Accumulate the data (increasing the buffer as we go)
if (_currentDataLen == 0)
{
_currentData = new char[len];
memcpy (_currentData, in, len);
_currentDataLen = len;
}
else
{
char *new_data = new char [_currentDataLen + len];
memcpy (new_data, _currentData, _currentDataLen);
memcpy (new_data + _currentDataLen, in, len);
SAFE_DELETEARRAY(_currentData);
_currentData = new_data;
_currentDataLen = _currentDataLen + len;
}
_pendingFrameDataLen = rtchatsdk_libwebsockets_remaining_packet_payload (wsi);
if (_pendingFrameDataLen > 0)
{
//CCLOG("%ld bytes of pending data to receive, consider increasing the libwebsocket rx_buffer_size value.", _pendingFrameDataLen);
}
// If no more data pending, send it to the client thread
if (_pendingFrameDataLen == 0)
{
WsMessage* msg = new WsMessage();
msg->what = WS_MSG_TO_UITHREAD_MESSAGE;
char* bytes = nullptr;
Data* data = new Data();
if (rtchatsdk_lws_frame_is_binary(wsi))
{
bytes = new char[_currentDataLen];
data->isBinary = true;
}
else
{
bytes = new char[_currentDataLen+1];
bytes[_currentDataLen] = '\0';
data->isBinary = false;
}
memcpy(bytes, _currentData, _currentDataLen);
data->bytes = bytes;
data->len = _currentDataLen;
msg->obj = (void*)data;
SAFE_DELETEARRAY(_currentData);
_currentData = nullptr;
_currentDataLen = 0;
// _wsHelper->sendMessageToUIThread(msg);
onUIThreadReceiveMessage(msg);
}
}
}
break;
default:
break;
}
return 0;
}
CDBTemplateStruct::~CDBTemplateStruct()
{
SAFE_DELETEARRAY(m_pColumnInfo);
}
