void CSteamBase::RunCallbacks()
{
std::vector<SteamAPIResult_t>::iterator iter;
for (iter = _results.begin(); iter < _results.end(); iter++)
{
SteamAPIResult_t result = *iter;
if (_resultHandlers.find(result.call) != _resultHandlers.end())
{
_resultHandlers[result.call]->Run(result.data, false, result.call);
}
std::vector<CCallbackBase*>::iterator cbiter;
for (cbiter = _callbacks.begin(); cbiter < _callbacks.end(); cbiter++)
{
CCallbackBase* cb = *cbiter;
if (cb && cb->GetICallback() == result.type)
{
cb->Run(result.data, false, 0);
}
}
if (result.data)
{
free(result.data);
}
}
_results.clear();
}
void CallbackManager::RunCallbacks()
{
CallbackMsg_t callbackMsg;
HSteamCall steamCall;
//g_Logging.AddToLogFileA("steam_emu.log", "RunCallbacks_i. callbackMsg: %d, steamCall: %d", callbackMsg, steamCall);
while( provider.Steam_BGetCallback(NULL, &callbackMsg, &steamCall) )
{
currentUser = callbackMsg.m_hSteamUser;
int32 callBack = callbackMsg.m_iCallback;
ECallbackType type = (ECallbackType)((callBack / 100) * 100);
//std::cout << "[DEBUG] Callback: " << callBack << ", Type: " << EnumString<ECallbackType>::From(type) << ", Size: " << callbackMsg.m_cubParam << std::endl;
g_Logging.AddToLogFileA( "steam_emu.log", "Callback %d Type %s Size %d", callBack, EnumString<ECallbackType>::From(type).c_str(), callbackMsg.m_cubParam );
if(callbackMsg.m_iCallback == SteamAPICallCompleted_t::k_iCallback)
{
SteamAPICallCompleted_t *call = (SteamAPICallCompleted_t *)callbackMsg.m_pubParam;
RunAPICallbacks(NULL, call);
}
std::pair<CallbacksMap::iterator, CallbacksMap::iterator> range = callbacks.equal_range(callbackMsg.m_iCallback);
for(CallbacksMap::const_iterator iter = range.first; iter != range.second; ++iter)
{
CCallbackBase *callback = iter->second;
if(false && !(callback->m_nCallbackFlags & CCallbackBase::k_ECallbackFlagsGameServer))
continue;
if(callbackTryCatch)
{
try {
callback->Run(callbackMsg.m_pubParam);
} catch(...) {};
} else {
callback->Run(callbackMsg.m_pubParam);
}
}
provider.Steam_FreeLastCallback(NULL);
}
}
void CallbackManager::RunAPICallbacks(HSteamPipe pipe, SteamAPICallCompleted_t *call)
{
SteamAPICall_t apicall = call->m_hAsyncCall;
APICallsMap::const_iterator iter = apicalls.find(apicall);
if(iter == apicalls.end())
return;
CCallbackBase *callback = iter->second;
int size = callback->GetCallbackSizeBytes();
void *data = malloc(size);
bool failed = false;
bool iok = provider.Steam_GetAPICallResult(pipe, apicall, data, size, callback->GetICallback(), &failed);
callback->Run(data, (!iok || failed), apicall);
free(data);
}
