Git-Mirrors/RetroShare
1
0
Fork 0
mirror of https://github.com/RetroShare/RetroShare.git synced 2025-02-17 21:34:10 -05:00
Code Issues Actions Packages Projects Releases Wiki Activity

allowed some clients to Event handler to register with type NONE, which means that all event types will be sent to the client

Browse Source
This commit is contained in:
csoler 2020-01-11 19:01:43 +01:00
parent f76b81ba49
commit 6a4c98b2ed
No known key found for this signature in database
GPG Key ID: 7BCA522266C0804C
2 changed files with 20 additions and 25 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
libretroshare/src/jsonapi/jsonapi.cpp
View File

@ -331,13 +331,13 @@ JsonApiServer::JsonApiServer(): configMutex("JsonApiServer config"),
rsEvents, "rsEvents", cAns, session ) )
return;
uint32_t event_type;
RsEventType eventType = RsEventType::NONE;
// deserialize input parameters from JSON
{
RsGenericSerializer::SerializeContext& ctx(cReq);
RsGenericSerializer::SerializeJob j(RsGenericSerializer::FROM_JSON);
RS_SERIAL_PROCESS(event_type);
RS_SERIAL_PROCESS(eventType);
}
const std::weak_ptr<rb::Session> weakSession(session);
@ -374,7 +374,7 @@ JsonApiServer::JsonApiServer(): configMutex("JsonApiServer config"),
} );
};
bool retval = rsEvents->registerEventsHandler(static_cast<RsEventType>(event_type),multiCallback, hId);
bool retval = rsEvents->registerEventsHandler(eventType,multiCallback, hId);
{
RsGenericSerializer::SerializeContext& ctx(cAns);

39
libretroshare/src/services/rseventsservice.cc
View File

@ -176,30 +176,25 @@ void RsEventsService::handleEvent(std::shared_ptr<const RsEvent> event)
{
std::function<void(std::shared_ptr<const RsEvent>)> mCallback;
uint32_t event_type_index = (uint32_t)event->mType;
uint32_t event_type_index = static_cast<uint32_t>(event->mType);
mHandlerMapMtx.lock();
if(event_type_index >= mHandlerMaps.size() || event_type_index < 1)
{
RsErr() << "Cannot handle an event of type " << event_type_index << ": out of scope!" << std::endl;
return;
}
auto cbpt = mHandlerMaps[event_type_index].begin();
mHandlerMapMtx.unlock();
getHandlerFromMapLock:
mHandlerMapMtx.lock();
if(cbpt != mHandlerMaps[event_type_index].end())
{
mCallback = cbpt->second;
++cbpt;
}
mHandlerMapMtx.unlock();
RS_STACK_MUTEX(mHandlerMapMtx); /* LOCKED AREA */
if(mCallback)
{
mCallback(event); // It is relevant that this happens outside mutex
mCallback = std::function<void(std::shared_ptr<const RsEvent>)>(nullptr);
goto getHandlerFromMapLock;
if(event_type_index >= mHandlerMaps.size() || event_type_index < 1)
{
RsErr() << "Cannot handle an event of type " << event_type_index << ": out of scope!" << std::endl;
return;
}
// Call all clients that registered a callback for this event type
for(auto cbit: mHandlerMaps[event_type_index])
cbit.second(event);
// Also call all clients that registered with NONE, meaning that they expect all events
for(auto cbit: mHandlerMaps[static_cast<uint32_t>(RsEventType::NONE)])
cbit.second(event);
}
}