X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali%2Finternal%2Fevent%2Fcommon%2Fnotification-manager.cpp;h=828586acbc5aa9abe943942f7635abb77a65300a;hb=ab5d2ee99a1b975867bf694b5cdeb15df01b9cb5;hp=0212cd9733c81938869210f78d885a8219f398d0;hpb=ea86ef9851ff0868616ea28825d9f257dd96cf88;p=platform%2Fcore%2Fuifw%2Fdali-core.git diff --git a/dali/internal/event/common/notification-manager.cpp b/dali/internal/event/common/notification-manager.cpp index 0212cd9..828586a 100644 --- a/dali/internal/event/common/notification-manager.cpp +++ b/dali/internal/event/common/notification-manager.cpp @@ -19,56 +19,58 @@ #include // INTERNAL INCLUDES -#include -#include -#include +#include +#include +#include +#include #include -#include #include +#include +#include namespace Dali { - namespace Internal { - namespace { -typedef Dali::Vector< CompleteNotificationInterface* > InterfaceContainer; +typedef Dali::Vector InterfaceContainer; + +DALI_INIT_TRACE_FILTER(gTraceFilter, DALI_TRACE_PERFORMANCE_MARKER, false); /** * helper to move elements from one container to another * @param from where to move * @param to move target */ -void MoveElements( InterfaceContainer& from, InterfaceContainer& to ) +void MoveElements(InterfaceContainer& from, InterfaceContainer& to) { // check if there's something in from const InterfaceContainer::SizeType fromCount = from.Count(); - if( fromCount > 0u ) + if(fromCount > 0u) { // check if to has some elements const InterfaceContainer::SizeType toCount = to.Count(); - if( toCount == 0u ) + if(toCount == 0u) { // to is empty so we can swap with from - to.Swap( from ); + to.Swap(from); } else { - to.Reserve( toCount + fromCount ); - for( InterfaceContainer::SizeType i = 0; i < fromCount; ++i ) + to.Reserve(toCount + fromCount); + for(InterfaceContainer::SizeType i = 0; i < fromCount; ++i) { - to.PushBack( from[ i ] ); + to.PushBack(from[i]); } from.Clear(); } } } -} +} // namespace -typedef Dali::Mutex MessageQueueMutex; -typedef OwnerContainer< MessageBase* > MessageContainer; +using MessageQueueMutex = Dali::Mutex; +using MessageContainer = OwnerContainer; struct NotificationManager::Impl { @@ -76,19 +78,17 @@ struct NotificationManager::Impl { // reserve space on the vectors to avoid reallocs // applications typically have up-to 20-30 notifications at startup - updateCompletedMessageQueue.Reserve( 32 ); - updateWorkingMessageQueue.Reserve( 32 ); - eventMessageQueue.Reserve( 32 ); + updateCompletedMessageQueue.Reserve(32); + updateWorkingMessageQueue.Reserve(32); + eventMessageQueue.Reserve(32); // only a few manager objects get complete notifications (animation, render list, property notifications, ...) - updateCompletedInterfaceQueue.Reserve( 4 ); - updateWorkingInterfaceQueue.Reserve( 4 ); - eventInterfaceQueue.Reserve( 4 ); + updateCompletedInterfaceQueue.Reserve(4); + updateWorkingInterfaceQueue.Reserve(4); + eventInterfaceQueue.Reserve(4); } - ~Impl() - { - } + ~Impl() = default; // queueMutex must be locked whilst accessing queue MessageQueueMutex queueMutex; @@ -112,78 +112,88 @@ NotificationManager::~NotificationManager() delete mImpl; } -void NotificationManager::QueueCompleteNotification( CompleteNotificationInterface* instance ) +void NotificationManager::QueueCompleteNotification(CompleteNotificationInterface* instance) { // queueMutex must be locked whilst accessing queues - MessageQueueMutex::ScopedLock lock( mImpl->queueMutex ); + MessageQueueMutex::ScopedLock lock(mImpl->queueMutex); - mImpl->updateWorkingInterfaceQueue.PushBack( instance ); + mImpl->updateWorkingInterfaceQueue.PushBack(instance); } -void NotificationManager::QueueMessage( MessageBase* message ) +void NotificationManager::QueueMessage(MessageBase* message) { - DALI_ASSERT_DEBUG( NULL != message ); + DALI_ASSERT_DEBUG(NULL != message); // queueMutex must be locked whilst accessing queues - MessageQueueMutex::ScopedLock lock( mImpl->queueMutex ); + MessageQueueMutex::ScopedLock lock(mImpl->queueMutex); - mImpl->updateWorkingMessageQueue.PushBack( message ); + mImpl->updateWorkingMessageQueue.PushBack(message); } void NotificationManager::UpdateCompleted() { // queueMutex must be locked whilst accessing queues - MessageQueueMutex::ScopedLock lock( mImpl->queueMutex ); + MessageQueueMutex::ScopedLock lock(mImpl->queueMutex); // Move messages from update working queue to completed queue // note that in theory its possible for update completed to have last frames // events as well still hanging around. we need to keep them as well - mImpl->updateCompletedMessageQueue.MoveFrom( mImpl->updateWorkingMessageQueue ); + mImpl->updateCompletedMessageQueue.MoveFrom(mImpl->updateWorkingMessageQueue); // move pointers from interface queue - MoveElements( mImpl->updateWorkingInterfaceQueue, mImpl->updateCompletedInterfaceQueue ); + MoveElements(mImpl->updateWorkingInterfaceQueue, mImpl->updateCompletedInterfaceQueue); // finally the lock is released } bool NotificationManager::MessagesToProcess() { // queueMutex must be locked whilst accessing queues - MessageQueueMutex::ScopedLock lock( mImpl->queueMutex ); + MessageQueueMutex::ScopedLock lock(mImpl->queueMutex); - return ( 0u < mImpl->updateCompletedMessageQueue.Count() || - ( 0u < mImpl->updateCompletedInterfaceQueue.Count() ) ); + return (0u < mImpl->updateCompletedMessageQueue.Count() || + (0u < mImpl->updateCompletedInterfaceQueue.Count())); } void NotificationManager::ProcessMessages() { // queueMutex must be locked whilst accessing queues { - MessageQueueMutex::ScopedLock lock( mImpl->queueMutex ); + MessageQueueMutex::ScopedLock lock(mImpl->queueMutex); // Move messages from update completed queue to event queue // note that in theory its possible for event queue to have // last frames events as well still hanging around so need to keep them - mImpl->eventMessageQueue.MoveFrom( mImpl->updateCompletedMessageQueue ); - MoveElements( mImpl->updateCompletedInterfaceQueue, mImpl->eventInterfaceQueue ); + mImpl->eventMessageQueue.MoveFrom(mImpl->updateCompletedMessageQueue); + MoveElements(mImpl->updateCompletedInterfaceQueue, mImpl->eventInterfaceQueue); } // end of scope, lock is released - MessageContainer::Iterator iter = mImpl->eventMessageQueue.Begin(); - const MessageContainer::Iterator end = mImpl->eventMessageQueue.End(); - for( ; iter != end; ++iter ) + MessageContainer::Iterator iter = mImpl->eventMessageQueue.Begin(); + const MessageContainer::Iterator end = mImpl->eventMessageQueue.End(); + if(iter != end) { - (*iter)->Process( 0u/*ignored*/ ); + DALI_TRACE_BEGIN(gTraceFilter, "DALI_NOTIFICATION_PROCESS_MESSAGE"); + for(; iter != end; ++iter) + { + (*iter)->Process(0u /*ignored*/); + } + DALI_TRACE_END(gTraceFilter, "DALI_NOTIFICATION_PROCESS_MESSAGE"); } // release the processed messages from event side queue mImpl->eventMessageQueue.Clear(); - InterfaceContainer::Iterator iter2 = mImpl->eventInterfaceQueue.Begin(); - const InterfaceContainer::Iterator end2 = mImpl->eventInterfaceQueue.End(); - for( ; iter2 != end2; ++iter2 ) + InterfaceContainer::Iterator iter2 = mImpl->eventInterfaceQueue.Begin(); + const InterfaceContainer::Iterator end2 = mImpl->eventInterfaceQueue.End(); + if(iter2 != end2) { - CompleteNotificationInterface* interface = *iter2; - if( interface ) + DALI_TRACE_BEGIN(gTraceFilter, "DALI_NOTIFICATION_NOTIFY_COMPLETED"); + for(; iter2 != end2; ++iter2) { - interface->NotifyCompleted(); + CompleteNotificationInterface* interface = *iter2; + if(interface) + { + interface->NotifyCompleted(); + } } + DALI_TRACE_END(gTraceFilter, "DALI_NOTIFICATION_NOTIFY_COMPLETED"); } // just clear the container, we dont own the objects mImpl->eventInterfaceQueue.Clear();