cocos2d::LUA_STRING CCCrypto::cryptAES256Lua(bool isDecrypt,
const char* input,
int inputLength,
const char* key,
int keyLength)
{
CCLuaStack* stack = CCLuaEngine::defaultEngine()->getLuaStack();
stack->clean();
if (getAES256KeyLength() == 0)
{
stack->pushNil();
return 1;
}
int bufferSize = inputLength + getAES256KeyLength();
void* buffer = malloc(bufferSize);
int dataUsed = cryptAES256(isDecrypt, (unsigned char*)input, inputLength, (unsigned char*)buffer, bufferSize, (unsigned char*)key, keyLength);
if (dataUsed > 0)
{
stack->pushString(static_cast<const char*>(buffer), dataUsed);
}
else
{
stack->pushNil();
}
free(buffer);
return 1;
}
LUA_STRING CCCrypto::encodingBase64Lua(bool isDecoding,
const char* input,
int inputLength)
{
CCLuaStack* stack = CCLuaEngine::defaultEngine()->getLuaStack();
stack->clean();
int bufferSize = isDecoding ? Base64decode_len(input) : Base64encode_len(inputLength);
char *buffer = bufferSize ? (char*)malloc(bufferSize) : NULL;
int size = 0;
if (buffer)
{
size = isDecoding ? Base64decode(buffer, input) : (Base64encode(buffer, input, inputLength) - 1);
}
if (size)
{
stack->pushString(buffer, size);
}
else
{
stack->pushNil();
}
if (buffer)
{
free(buffer);
}
return 1;
}
LUA_STRING CCCrypto::encodingBase64Lua(bool isDecoding,
const char* input,
int inputLength)
{
CCLuaStack* stack = CCLuaEngine::defaultEngine()->getLuaStack();
stack->clean();
int outputLength = inputLength * 2;
char* output = static_cast<char*>(malloc(outputLength));
int dataUsed = -1;
if (isDecoding)
{
dataUsed = decodeBase64(input, output, outputLength);
}
else
{
dataUsed = encodeBase64((unsigned char*)input, inputLength, output, outputLength);
}
if (dataUsed > 0 && dataUsed < outputLength)
{
stack->pushString(output, dataUsed);
}
else
{
stack->pushNil();
}
free(output);
return 1;
}
static int SendBinaryMessageToLua(int nHandler,const unsigned char* pTable,int nLength)
{
if (NULL == pTable || nHandler <= 0) {
return 0;
}
if (NULL == CCScriptEngineManager::sharedManager()->getScriptEngine()) {
return 0;
}
CCLuaStack *pStack = CCLuaEngine::defaultEngine()->getLuaStack();
if (NULL == pStack) {
return 0;
}
lua_State *tolua_s = pStack->getLuaState();
if (NULL == tolua_s) {
return 0;
}
int nRet = 0;
CCLuaValueArray array;
for (int i = 0 ; i < nLength; i++) {
CCLuaValue value = CCLuaValue::intValue(pTable[i]);
array.push_back(value);
}
pStack->pushCCLuaValueArray(array);
nRet = pStack->executeFunctionByHandler(nHandler, 1);
pStack->clean();
return nRet;
}
LUA_STRING CCHTTPRequest::getResponseDataLua(void)
{
CCAssert(m_state == kCCHTTPRequestStateCompleted, "CCHTTPRequest::getResponseDataLua() - request not completed");
CCLuaStack *stack = CCLuaEngine::defaultEngine()->getLuaStack();
stack->clean();
stack->pushString(static_cast<char*>(m_responseBuffer), (int)m_responseDataLength);
return 1;
}
void LuaArmatureWrapper::addArmatureFileInfoAsyncCallback(float percent)
{
if (0 != m_lHandler)
{
CCLuaEngine* pEngine = CCLuaEngine::defaultEngine();
CCLuaStack* pStack = pEngine->getLuaStack();
pStack->pushFloat(percent);
pStack->executeFunctionByHandler(m_lHandler, 1);
pStack->clean();
}
}
void LuaCocoStudioEventListener::eventCallbackFunc(CCObject* sender,int eventType)
{
if (0 != m_lHandler)
{
CCLuaEngine* pEngine = CCLuaEngine::defaultEngine();
CCLuaStack* pStack = pEngine->getLuaStack();
pStack->pushCCObject(sender, "CCObject");
pStack->pushInt(eventType);
pStack->executeFunctionByHandler(m_lHandler, 2);
pStack->clean();
}
}
int CZHelperFunc::getFileData(const char *pPathFile)
{
unsigned long size;
unsigned char* buf = CZHelperFunc::getFileData(pPathFile, "rb", &size);
if (NULL==buf) return 0;
CCLuaStack* stack = CCLuaEngine::defaultEngine()->getLuaStack();
stack->clean();
stack->pushString((const char*)(buf), size);
delete buf;
return 1;
}
const string CCCrypto::MD5String(void* input, int inputLength)
{
unsigned char buffer[MD5_BUFFER_LENGTH];
MD5(static_cast<void*>(input), inputLength, buffer);
CCLuaStack* stack = CCLuaEngine::defaultEngine()->getLuaStack();
stack->clean();
char* hex = bin2hex(buffer, MD5_BUFFER_LENGTH);
string ret(hex);
delete[] hex;
return ret;
}
CWidgetTouchModel CWidget::executeTouchBeganHandler(CCTouch* pTouch)
{
m_bTouchInterrupt = false;
if( m_pTouchBeganListener && m_pTouchBeganHandler )
{
CWidgetTouchModel eUserTouchModel = (m_pTouchBeganListener->*m_pTouchBeganHandler)(m_pThisObject, pTouch);
if( eUserTouchModel == eWidgetTouchNone )
{
return eWidgetTouchNone;
}
else
{
this->onTouchBegan(pTouch);
return eUserTouchModel;
}
}
#if USING_LUA
else if( m_nTouchBeganScriptHandler != 0 )
{
CCLuaEngine* pEngine = CCLuaEngine::defaultEngine();
CCLuaStack* pStack = pEngine->getLuaStack();
pStack->pushCCObject(m_pThisObject, "CCObject");
pStack->pushCCObject(pTouch, "CCTouch");
CCArray* pRetArray = new CCArray();
pRetArray->initWithCapacity(1);
int nRet = pStack->executeFunctionReturnArray(m_nTouchBeganScriptHandler, 2, 1, pRetArray);
CCAssert(pRetArray->count() > 0, "return count = 0");
CCDouble* pIntModel = (CCDouble*) pRetArray->objectAtIndex(0);
CWidgetTouchModel eUserTouchModel = (CWidgetTouchModel) ( (int)pIntModel->getValue() );
delete pRetArray;
pStack->clean();
if( eUserTouchModel == eWidgetTouchNone )
{
return eWidgetTouchNone;
}
else
{
this->onTouchBegan(pTouch);
return eUserTouchModel;
}
}
#endif
return this->onTouchBegan(pTouch);
}
LUA_STRING CCCrypto::MD5FileLua(const char* path)
{
unsigned char buffer[MD5_BUFFER_LENGTH];
MD5File(path, buffer);
CCLuaStack* stack = CCLuaEngine::defaultEngine()->getLuaStack();
stack->clean();
char* hex = bin2hex(buffer, MD5_BUFFER_LENGTH);
stack->pushString(hex);
delete[] hex;
return 1;
}
void LuaArmatureWrapper::movementEventCallback(CCArmature* armature, MovementEventType type,const char* movementID)
{
if (0 != m_lHandler)
{
CCLuaEngine* pEngine = CCLuaEngine::defaultEngine();
CCLuaStack* pStack = pEngine->getLuaStack();
pStack->pushCCObject(armature, "CCArmature");
pStack->pushInt(type);
pStack->pushString(movementID);
pStack->executeFunctionByHandler(m_lHandler, 3);
pStack->clean();
}
}
void CCZipFile::getFileDataOrder(const char *filename)
{
unsigned long size;
unsigned char* buf = getFileData(filename, &size);
CCLuaStack* stack = CCLuaEngine::defaultEngine()->getLuaStack();
stack->clean();
if (NULL==buf)
{
stack->pushNil();
return;
}
stack->pushString((const char*)buf, size);
delete []buf;
return;
}
void LuaArmatureWrapper::frameEventCallback(CCBone* bone, const char* frameEventName, int orginFrameIndex, int currentFrameIndex)
{
if (0 != m_lHandler)
{
CCLuaEngine* pEngine = CCLuaEngine::defaultEngine();
CCLuaStack* pStack = pEngine->getLuaStack();
pStack->pushCCObject(bone, "CCBone");
pStack->pushString(frameEventName);
pStack->pushInt(orginFrameIndex);
pStack->pushInt(currentFrameIndex);
pStack->executeFunctionByHandler(m_lHandler, 4);
pStack->clean();
}
}
void CCZipFile::getFileList()
{
if(!m_hasGenFlist)
{
genFileList();
}
CCLuaValueArray array;
for(auto a:m_fileList)
{
CCLuaValue value = CCLuaValue::stringValue(a.first);
array.push_back(value);
}
CCLuaStack* stack = CCLuaEngine::defaultEngine()->getLuaStack();
stack->clean();
stack->pushCCLuaValueArray(array);
return;
}
void CWidgetLayout::executeTouchCancelledAfterLongClickHandler(CCObject* pSender, CCTouch *pTouch, float fDuration)
{
if( m_pTouchCancelledAfterLongClickListener && m_pTouchCancelledAfterLongClickHandler )
{
(m_pTouchCancelledAfterLongClickListener->*m_pTouchCancelledAfterLongClickHandler)(pSender, pTouch, fDuration);
}
#if USING_LUA
else if( m_pTouchCancelledAfterLongClickScriptHandler != 0 )
{
CCLuaEngine* pEngine = CCLuaEngine::defaultEngine();
CCLuaStack* pStack = pEngine->getLuaStack();
pStack->pushCCObject(pSender, "CCObject");
pStack->pushCCObject(pTouch, "CCTouch");
pStack->pushFloat(fDuration);
int nRet = pStack->executeFunctionByHandler(m_pTouchCancelledAfterLongClickScriptHandler, 3);
pStack->clean();
}
#endif
}
LUA_STRING CCCrypto::sha1Lua(char* input, char* key, bool isRawOutput)
{
unsigned char buffer[SHA1_BUFFER_LENGTH];
MD5(static_cast<void*>(input), strlen(input), buffer);
CCLuaStack* stack = CCLuaEngine::defaultEngine()->getLuaStack();
stack->clean();
if (isRawOutput)
{
stack->pushString((char*)buffer, SHA1_BUFFER_LENGTH);
}
else
{
char* hex = bin2hex(buffer, SHA1_BUFFER_LENGTH);
stack->pushString(hex);
delete[] hex;
}
return 1;
}
LUA_STRING CCCrypto::decryptXXTEALua(const char* plaintext,
int plaintextLength,
const char* key,
int keyLength)
{
CCLuaStack* stack = CCLuaEngine::defaultEngine()->getLuaStack();
stack->clean();
int resultLength;
unsigned char* result = decryptXXTEA((unsigned char*)plaintext, plaintextLength, (unsigned char*)key, keyLength, &resultLength);
if (resultLength <= 0)
{
lua_pushnil(stack->getLuaState());
}
else
{
lua_pushlstring(stack->getLuaState(), (const char*)result, resultLength);
free(result);
}
return 1;
}
void CWidget::executeTouchCancelledHandler(CCTouch* pTouch, float fDuration)
{
if( m_pTouchCancelledListener && m_pTouchCancelledHandler )
{
if( !(m_pTouchCancelledListener->*m_pTouchCancelledHandler)(m_pThisObject, pTouch, fDuration) )
{
return;
}
}
#if USING_LUA
else if( m_nTouchCancelledScriptHandler != 0 )
{
CCLuaEngine* pEngine = CCLuaEngine::defaultEngine();
CCLuaStack* pStack = pEngine->getLuaStack();
pStack->pushCCObject(m_pThisObject, "CCObject");
pStack->pushCCObject(pTouch, "CCTouch");
pStack->pushFloat(fDuration);
CCArray* pRetArray = new CCArray();
pRetArray->initWithCapacity(1);
int nRet = pStack->executeFunctionReturnArray(m_nTouchCancelledScriptHandler, 3, 1, pRetArray);
CCAssert(pRetArray->count() > 0, "return count = 0");
CCBool* pBool = (CCBool*) pRetArray->objectAtIndex(0);
bool bContinue = pBool->getValue();
delete pRetArray;
pStack->clean();
if(!bContinue)
{
return;
}
}
#endif
this->onTouchCancelled(pTouch, fDuration);
return;
}
void CCHTTPRequest::update(float dt)
{
if (m_state == kCCHTTPRequestStateInProgress)
{
#if CC_LUA_ENGINE_ENABLED > 0
if (m_listener)
{
CCLuaValueDict dict;
dict["name"] = CCLuaValue::stringValue("inprogress");
dict["dltotal"] = CCLuaValue::floatValue((float)m_dltotal);
dict["dlnow"] = CCLuaValue::floatValue((float)m_dlnow);
dict["ultotal"] = CCLuaValue::floatValue((float)m_ultotal);
dict["ulnow"] = CCLuaValue::floatValue((float)m_ulnow);
dict["request"] = CCLuaValue::ccobjectValue(this, "CCHTTPRequest");
CCLuaStack *stack = CCLuaEngine::defaultEngine()->getLuaStack();
stack->clean();
stack->pushCCLuaValueDict(dict);
stack->executeFunctionByHandler(m_listener, 1);
}
#endif
return;
}
CCDirector::sharedDirector()->getScheduler()->unscheduleAllForTarget(this);
if (m_curlState != kCCHTTPRequestCURLStateIdle)
{
CCDirector::sharedDirector()->getScheduler()->scheduleSelector(schedule_selector(CCHTTPRequest::checkCURLState), this, 0, false);
}
if (m_state == kCCHTTPRequestStateCompleted)
{
CCLOG("CCHTTPRequest[0x%04x] - request completed", m_id);
if (m_delegate) m_delegate->requestFinished(this);
}
else
{
CCLOG("CCHTTPRequest[0x%04x] - request failed", m_id);
if (m_delegate) m_delegate->requestFailed(this);
}
#if CC_LUA_ENGINE_ENABLED > 0
if (m_listener)
{
CCLuaValueDict dict;
switch (m_state)
{
case kCCHTTPRequestStateCompleted:
dict["name"] = CCLuaValue::stringValue("completed");
break;
case kCCHTTPRequestStateCancelled:
dict["name"] = CCLuaValue::stringValue("cancelled");
break;
case kCCHTTPRequestStateFailed:
dict["name"] = CCLuaValue::stringValue("failed");
break;
default:
dict["name"] = CCLuaValue::stringValue("unknown");
}
dict["request"] = CCLuaValue::ccobjectValue(this, "CCHTTPRequest");
CCLuaStack *stack = CCLuaEngine::defaultEngine()->getLuaStack();
stack->clean();
stack->pushCCLuaValueDict(dict);
stack->executeFunctionByHandler(m_listener, 1);
}
#endif
}
