Add trace log to FrameCallbackProcessor::Update

[platform/core/uifw/dali-core.git] / dali / internal / update / manager / frame-callback-processor.cpp

diff --git a/dali/internal/update/manager/frame-callback-processor.cpp b/dali/internal/update/manager/frame-callback-processor.cpp
index 87f3b89..10e7d8d 100644 (file)
--- a/dali/internal/update/manager/frame-callback-processor.cpp
+++ b/dali/internal/update/manager/frame-callback-processor.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 Samsung Electronics Co., Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,102 +18,68 @@
 // CLASS HEADER
 #include <dali/internal/update/manager/frame-callback-processor.h>
 
+// EXTERNAL INCLUDES
+#include <algorithm>
+
 // INTERNAL INCLUDES
 #include <dali/devel-api/update/frame-callback-interface.h>
 #include <dali/devel-api/update/update-proxy.h>
-#include <dali/internal/update/manager/update-proxy-impl.h>
+#include <dali/integration-api/trace.h>
 
-namespace Dali
+namespace
 {
+DALI_INIT_TRACE_FILTER(gTraceFilter, DALI_TRACE_PERFORMANCE_MARKER, false);
+} // namespace
 
+namespace Dali
+{
 namespace Internal
 {
-
 namespace SceneGraph
 {
-
-namespace
-{
-
-template< typename FrameCallbackInfoT >
-class MatchRootNode
-{
-public:
-
-  MatchRootNode( PropertyOwner& rootNode )
-  : mRootNode( rootNode )
-  {
-  }
-
-  bool operator() ( const FrameCallbackInfoT& info )
-  {
-    return &info.updateProxyImpl->GetRootNode() == &mRootNode;
-  }
-
-private:
-
-  PropertyOwner& mRootNode;
-};
-
-} // unnamed namespace
-
-FrameCallbackProcessor::FrameCallbackProcessor( TransformManager& transformManager, Node& rootNode )
+FrameCallbackProcessor::FrameCallbackProcessor(UpdateManager& updateManager, TransformManager& transformManager)
 : mFrameCallbacks(),
-  mTransformManager( transformManager ),
-  mRootNode( rootNode )
+  mUpdateManager(updateManager),
+  mTransformManager(transformManager),
+  mNodeHierarchyChanged(true)
 {
 }
 
-FrameCallbackProcessor::~FrameCallbackProcessor()
-{
-}
+FrameCallbackProcessor::~FrameCallbackProcessor() = default;
 
-void FrameCallbackProcessor::AddFrameCallback( FrameCallbackInterface* frameCallback, const Node* rootNode )
+void FrameCallbackProcessor::AddFrameCallback(OwnerPointer<FrameCallback>& frameCallback, const Node* rootNode)
 {
-  Node& node = const_cast< Node& >( *rootNode ); // Was sent as const from event thread, we need to be able to use non-const version here.
+  Node& node = const_cast<Node&>(*rootNode); // Was sent as const from event thread, we need to be able to use non-const version here.
 
-  FrameCallbackInfo info;
-  info.frameCallback = frameCallback;
-  info.updateProxyImpl = new UpdateProxy( mTransformManager, node );
+  frameCallback->ConnectToSceneGraph(mUpdateManager, mTransformManager, node);
 
-  // We want to be notified when the node is destroyed (if we're not observing it already)
-  auto iter = std::find_if( mFrameCallbacks.begin(), mFrameCallbacks.end(), MatchRootNode< FrameCallbackInfo >( node ) );
-  if( iter == mFrameCallbacks.end() )
-  {
-    node.AddObserver( *this );
-  }
-
-  mFrameCallbacks.push_back( info );
+  mFrameCallbacks.emplace_back(frameCallback);
 }
 
-void FrameCallbackProcessor::RemoveFrameCallback( FrameCallbackInterface* frameCallback )
+void FrameCallbackProcessor::RemoveFrameCallback(FrameCallbackInterface* frameCallback)
 {
-  auto iter = std::remove_if( mFrameCallbacks.begin(), mFrameCallbacks.end(),
-                              [ this, frameCallback ]
-                                ( const FrameCallbackInfo& info )
-                                {
-                                  info.updateProxyImpl->GetRootNode().RemoveObserver( *this );
-                                  delete info.updateProxyImpl;
-                                  return info.frameCallback == frameCallback;
-                                } );
-  mFrameCallbacks.erase( iter, mFrameCallbacks.end() );
+  // Find and remove all frame-callbacks that use the given frame-callback-interface
+  auto iter = std::remove(mFrameCallbacks.begin(), mFrameCallbacks.end(), frameCallback);
+  mFrameCallbacks.erase(iter, mFrameCallbacks.end());
 }
 
-void FrameCallbackProcessor::Update( BufferIndex bufferIndex, float elapsedSeconds )
+void FrameCallbackProcessor::Update(BufferIndex bufferIndex, float elapsedSeconds)
 {
-  for( auto&& iter : mFrameCallbacks )
+  if(!mFrameCallbacks.empty())
   {
-    UpdateProxy& updateProxyImpl = *iter.updateProxyImpl;
-    updateProxyImpl.SetCurrentBufferIndex( bufferIndex );
-    Dali::UpdateProxy updateProxy( updateProxyImpl );
-    iter.frameCallback->Update( updateProxy, elapsedSeconds );
+    DALI_TRACE_BEGIN(gTraceFilter, "DALI_FRAME_CALLBACK_UPDATE");
+
+    // If any of the FrameCallback::Update calls returns false, then they are no longer required & can be removed.
+    auto iter = std::remove_if(
+      mFrameCallbacks.begin(), mFrameCallbacks.end(), [&](OwnerPointer<FrameCallback>& frameCallback) {
+        return !frameCallback->Update(bufferIndex, elapsedSeconds, mNodeHierarchyChanged);
+      });
+    mFrameCallbacks.erase(iter, mFrameCallbacks.end());
+
+    DALI_TRACE_END(gTraceFilter, "DALI_FRAME_CALLBACK_UPDATE");
   }
-}
 
-void FrameCallbackProcessor::PropertyOwnerDestroyed( PropertyOwner& owner )
-{
-  auto iter = std::remove_if( mFrameCallbacks.begin(), mFrameCallbacks.end(), MatchRootNode< FrameCallbackInfo >( owner )  );
-  mFrameCallbacks.erase( iter, mFrameCallbacks.end() );
+  mNodeHierarchyChanged = false;
 }
 
 } // namespace SceneGraph