Let we don't do any additional progress after application terminated.
Also, let we keep the VectorAnimationThread lifetime until all
working VectorAnimationTask are completed.
Since that task use VectorAnimationThread as reference, we cannot release
the memory of VectorAnimationManager memory. So just call finalize API.
Change-Id: I6f33c3f5863d8ad3ad9a08d45b134501582d87be
Signed-off-by: Eunki, Hong <eunkiki.hong@samsung.com>
Test::VectorAnimationRenderer::UseNativeImageTexture(false);
END_TEST;
-}
\ No newline at end of file
+}
+
+int UtcDaliAnimatedVectorImageVisualDestroyApplicationWhenFrameDropped(void)
+{
+ try
+ {
+ {
+ ToolkitTestApplication application;
+ tet_infoline("UtcDaliAnimatedVectorImageVisualDestroyApplicationWhenFrameDropped");
+
+ Property::Map propertyMap;
+ propertyMap.Add(Toolkit::Visual::Property::TYPE, DevelVisual::ANIMATED_VECTOR_IMAGE)
+ .Add(ImageVisual::Property::URL, TEST_VECTOR_IMAGE_FILE_NAME_FRAME_DROP)
+ .Add(ImageVisual::Property::SYNCHRONOUS_LOADING, false);
+
+ Visual::Base visual = VisualFactory::Get().CreateVisual(propertyMap);
+ DALI_TEST_CHECK(visual);
+
+ DummyControl actor = DummyControl::New(true);
+ DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
+ dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
+
+ Vector2 controlSize(20.f, 30.f);
+ actor.SetProperty(Actor::Property::SIZE, controlSize);
+
+ application.GetScene().Add(actor);
+
+ application.SendNotification();
+ application.Render();
+
+ // Trigger count is 2 - load, render the first frame
+ DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
+
+ Property::Map attributes;
+ DevelControl::DoAction(actor, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelAnimatedVectorImageVisual::Action::PLAY, attributes);
+
+ // Make delay to drop frames
+ Test::VectorAnimationRenderer::DelayRendering(500); // block Rasterize thread near 500 ms
+
+ // Request 1 frame rendering.
+ application.SendNotification();
+ application.Render();
+
+ // Destroy applicatoin immediately.
+ }
+
+ tet_result(TET_PASS);
+ }
+ catch(...)
+ {
+ tet_result(TET_FAIL);
+ }
+
+ END_TEST;
+}
: mEventCallbacks(),
mLifecycleObservers(),
mVectorAnimationThread(nullptr),
- mProcessorRegistered(false)
+ mProcessorRegistered(false),
+ mDestroyed(false)
{
}
VectorAnimationManager::~VectorAnimationManager()
{
- mEventCallbacks.clear();
-
- if(mProcessorRegistered && Adaptor::IsAvailable())
- {
- Adaptor::Get().UnregisterProcessor(*this, true);
- }
+ Finalize();
for(auto observer : mLifecycleObservers)
{
void VectorAnimationManager::RegisterEventCallback(CallbackBase* callback)
{
- mEventCallbacks.emplace_back(std::unique_ptr<Dali::CallbackBase>(callback));
+ if(DALI_LIKELY(!mDestroyed))
+ {
+ mEventCallbacks.emplace_back(std::unique_ptr<Dali::CallbackBase>(callback));
- if(!mProcessorRegistered)
+ if(!mProcessorRegistered && DALI_LIKELY(Adaptor::IsAvailable()))
+ {
+ Adaptor::Get().RegisterProcessor(*this, true); // Use post processor to trigger after layoutting
+ mProcessorRegistered = true;
+ }
+ }
+ else
{
- Adaptor::Get().RegisterProcessor(*this, true); // Use post processor to trigger after layoutting
- mProcessorRegistered = true;
+ delete callback; // No longer needed.
}
}
}
}
-void VectorAnimationManager::Process(bool postProcessor)
+void VectorAnimationManager::Finalize()
{
-#ifdef TRACE_ENABLED
- if(gTraceFilter && gTraceFilter->IsTraceEnabled())
+ if(DALI_LIKELY(!mDestroyed))
{
- if(mEventCallbacks.size() > 0u)
+ DALI_LOG_DEBUG_INFO("Finalizing Vector Animation Manager.\n");
+ mDestroyed = true;
+
+ mEventCallbacks.clear();
+
+ if(mProcessorRegistered && Adaptor::IsAvailable())
+ {
+ Adaptor::Get().UnregisterProcessor(*this, true);
+ mProcessorRegistered = false;
+ }
+
+ if(mVectorAnimationThread)
{
- std::ostringstream oss;
- oss << "[" << mEventCallbacks.size() << "]";
- DALI_TRACE_BEGIN_WITH_MESSAGE(gTraceFilter, "DALI_VECTOR_ANIMATION_MANAGER_PROCESS", oss.str().c_str());
+ mVectorAnimationThread->Finalize();
}
}
-#endif
+}
- for(auto&& iter : mEventCallbacks)
+void VectorAnimationManager::Process(bool postProcessor)
+{
+ if(DALI_LIKELY(!mDestroyed))
{
- CallbackBase::Execute(*iter);
- }
+#ifdef TRACE_ENABLED
+ if(gTraceFilter && gTraceFilter->IsTraceEnabled())
+ {
+ if(mEventCallbacks.size() > 0u)
+ {
+ std::ostringstream oss;
+ oss << "[" << mEventCallbacks.size() << "]";
+ DALI_TRACE_BEGIN_WITH_MESSAGE(gTraceFilter, "DALI_VECTOR_ANIMATION_MANAGER_PROCESS", oss.str().c_str());
+ }
+ }
+#endif
+
+ for(auto&& iter : mEventCallbacks)
+ {
+ CallbackBase::Execute(*iter);
+ }
#ifdef TRACE_ENABLED
- if(gTraceFilter && gTraceFilter->IsTraceEnabled())
- {
- if(mEventCallbacks.size() > 0u)
+ if(gTraceFilter && gTraceFilter->IsTraceEnabled())
{
- std::ostringstream oss;
- oss << "[" << mEventCallbacks.size() << "]";
- DALI_TRACE_END_WITH_MESSAGE(gTraceFilter, "DALI_VECTOR_ANIMATION_MANAGER_PROCESS", oss.str().c_str());
+ if(mEventCallbacks.size() > 0u)
+ {
+ std::ostringstream oss;
+ oss << "[" << mEventCallbacks.size() << "]";
+ DALI_TRACE_END_WITH_MESSAGE(gTraceFilter, "DALI_VECTOR_ANIMATION_MANAGER_PROCESS", oss.str().c_str());
+ }
}
- }
#endif
- mEventCallbacks.clear();
+ mEventCallbacks.clear();
+ }
Adaptor::Get().UnregisterProcessor(*this, true);
mProcessorRegistered = false;
*/
void UnregisterEventCallback(CallbackBase* callback);
+ /**
+ * @brief Finalize the manager. This will stop the animation thread and clear all resources.
+ */
+ void Finalize();
+
protected: // Implementation of Processor
/**
* @copydoc Dali::Integration::Processor::Process()
std::vector<std::unique_ptr<CallbackBase>> mEventCallbacks;
std::vector<LifecycleObserver*> mLifecycleObservers;
std::unique_ptr<VectorAnimationThread> mVectorAnimationThread;
- bool mProcessorRegistered;
+ bool mProcessorRegistered : 1;
+ bool mDestroyed : 1;
};
} // namespace Internal
// Forcely trigger render once if need.
if(mNotifyAfterRasterization || mNeedForceRenderOnceTrigger)
{
- Mutex::ScopedLock lock(mMutex);
mVectorAnimationThread.RequestForceRenderOnce();
mNeedForceRenderOnceTrigger = false;
}
#include <dali/devel-api/adaptor-framework/thread-settings.h>
#include <dali/integration-api/adaptor-framework/adaptor.h>
#include <dali/integration-api/debug.h>
+#include <dali/integration-api/trace.h>
#include <thread>
namespace Dali
// Stop the thread
{
ConditionalWait::ScopedLock lock(mConditionalWait);
- // Wait until some event thread trigger relative job finished.
- {
- Mutex::ScopedLock eventTriggerLock(mEventTriggerMutex);
- Mutex::ScopedLock taskCompletedLock(mTaskCompletedMutex);
- Mutex::ScopedLock animationTasksLock(mAnimationTasksMutex);
- DALI_LOG_DEBUG_INFO("Mark VectorAnimationThread destroyed\n");
- mDestroyThread = true;
- }
- mNeedToSleep = false;
+ Finalize();
mConditionalWait.Notify(lock);
}
DALI_LOG_DEBUG_INFO("VectorAnimationThread Join request\n");
Join();
+
+ // We need to wait all working tasks are completed before destructing this thread.
+ while(mWorkingTasks.size() > 0)
+ {
+ DALI_LOG_DEBUG_INFO("Still waiting WorkingTasks [%zu]\n", mWorkingTasks.size());
+ ConditionalWait::ScopedLock lock(mConditionalWait);
+
+ // ConditionalWait notifyed when task complete.
+ // If task complete, then remove working tasks list and then wait again, until all working tasks are completed.
+ decltype(mCompletedTasksQueue) completedTasksQueue;
+ {
+ Mutex::ScopedLock taskCompletedLock(mTaskCompletedMutex);
+ completedTasksQueue.swap(mCompletedTasksQueue);
+ }
+ if(completedTasksQueue.empty())
+ {
+ mConditionalWait.Wait(lock);
+ // Task completed may have been added to the queue while we were waiting.
+ {
+ Mutex::ScopedLock taskCompletedLock(mTaskCompletedMutex);
+ completedTasksQueue.swap(mCompletedTasksQueue);
+ }
+ }
+
+ DALI_LOG_DEBUG_INFO("Completed task queue [%zu]\n", completedTasksQueue.size());
+
+ for(auto& taskPair : completedTasksQueue)
+ {
+ auto workingIter = std::find(mWorkingTasks.begin(), mWorkingTasks.end(), taskPair.first);
+ if(workingIter != mWorkingTasks.end())
+ {
+ mWorkingTasks.erase(workingIter);
+ }
+ }
+ }
}
/// Event thread called
Mutex::ScopedLock taskCompletedLock(mTaskCompletedMutex);
- if(DALI_LIKELY(!mDestroyThread))
- {
- mCompletedTasksQueue.emplace_back(task, success && keepAnimation);
+ // DevNote : We need to add task queue, and notify even if mDestroyThread is true.
+ // Since we should make ensure that all working tasks are completed before destroying the thread.
+ mCompletedTasksQueue.emplace_back(task, success && keepAnimation);
- // wake up the animation thread.
- // Note that we should not make mNeedToSleep as false now.
- mConditionalWait.Notify(lock);
- }
+ // wake up the animation thread.
+ // Note that we should not make mNeedToSleep as false now.
+ mConditionalWait.Notify(lock);
}
/// VectorAnimationThread::SleepThread called, Mutex SleepThread::mAwakeCallbackMutex is locked
}
}
+/// Event thread called
+void VectorAnimationThread::Finalize()
+{
+ Mutex::ScopedLock eventTriggerLock(mEventTriggerMutex);
+ Mutex::ScopedLock taskCompletedLock(mTaskCompletedMutex);
+ Mutex::ScopedLock animationTasksLock(mAnimationTasksMutex);
+ // Wait until some event thread trigger, and tasks relative job finished.
+ if(DALI_LIKELY(!mDestroyThread))
+ {
+ DALI_LOG_DEBUG_INFO("Mark VectorAnimationThread destroyed\n");
+ mDestroyThread = true;
+ }
+ mNeedToSleep = false;
+}
+
/// VectorAnimationThread called
void VectorAnimationThread::Run()
{
mLogFactory.InstallLogFunction();
mTraceFactory.InstallTraceFunction();
- while(!mDestroyThread)
+ while(DALI_LIKELY(!mDestroyThread))
{
Rasterize();
}
/// VectorAnimationThread called
void VectorAnimationThread::MoveTasksToCompleted(VectorAnimationTaskPtr task, bool keepAnimation)
{
- if(DALI_LIKELY(!mDestroyThread))
- {
- bool needRasterize = false;
+ // DevNote : We need to consume task queue, and notify even if mDestroyThread is true.
+ // Since we should make ensure that all working tasks are completed before destroying the thread.
+ bool needRasterize = false;
- auto workingTask = std::find(mWorkingTasks.begin(), mWorkingTasks.end(), task);
- if(workingTask != mWorkingTasks.end())
- {
- mWorkingTasks.erase(workingTask);
- }
+ auto workingIter = std::find(mWorkingTasks.begin(), mWorkingTasks.end(), task);
+ if(workingIter != mWorkingTasks.end())
+ {
+ mWorkingTasks.erase(workingIter);
+ }
+ if(DALI_LIKELY(!mDestroyThread))
+ {
// Check pending task
{
Mutex::ScopedLock animationTasksLock(mAnimationTasksMutex);
*/
void RequestForceRenderOnce();
+ /**
+ * @brief Finalize the thread.
+ */
+ void Finalize();
+
protected:
/**
* @brief The entry function of the animation thread.
return *mVectorAnimationManager;
}
+void VisualFactoryCache::FinalizeVectorAnimationManager()
+{
+ if(mVectorAnimationManager)
+ {
+ mVectorAnimationManager->Finalize();
+ }
+}
+
Geometry VisualFactoryCache::CreateGridGeometry(Uint16Pair gridSize)
{
uint16_t gridWidth = gridSize.GetWidth();
*/
VectorAnimationManager& GetVectorAnimationManager();
+ /**
+ * @brief Finalize vector animation manager.
+ * It will be called when application is terminated.
+ */
+ void FinalizeVectorAnimationManager();
+
protected:
/**
* Undefined copy constructor.
#include <dali-toolkit/internal/visuals/visual-factory-impl.h>
// EXTERNAL INCLUDES
+#include <dali/devel-api/adaptor-framework/lifecycle-controller.h>
#include <dali/devel-api/scripting/scripting.h>
#include <dali/integration-api/adaptor-framework/adaptor.h>
#include <dali/integration-api/debug.h>
mPreMultiplyOnLoad(true),
mPrecompiledShaderRequested(false)
{
+ Dali::LifecycleController lifecycleController = Dali::LifecycleController::Get();
+ if(DALI_LIKELY(lifecycleController))
+ {
+ lifecycleController.TerminateSignal().Connect(this, &VisualFactory::OnApplicationTerminated);
+ }
}
VisualFactory::~VisualFactory()
{
- if(mIdleCallback && Adaptor::IsAvailable())
+ if(Adaptor::IsAvailable())
{
- // Removes the callback from the callback manager in case the control is destroyed before the callback is executed.
- Adaptor::Get().RemoveIdle(mIdleCallback);
- mIdleCallback = nullptr;
+ Dali::LifecycleController lifecycleController = Dali::LifecycleController::Get();
+ if(DALI_LIKELY(lifecycleController))
+ {
+ lifecycleController.TerminateSignal().Disconnect(this, &VisualFactory::OnApplicationTerminated);
+ }
+
+ if(mIdleCallback)
+ {
+ // Removes the callback from the callback manager in case the control is destroyed before the callback is executed.
+ Adaptor::Get().RemoveIdle(mIdleCallback);
+ mIdleCallback = nullptr;
+ }
}
}
mDiscardedVisuals.clear();
}
+void VisualFactory::OnApplicationTerminated()
+{
+ if(DALI_UNLIKELY(mIdleCallback))
+ {
+ OnDiscardCallback();
+ }
+
+ if(mFactoryCache)
+ {
+ mFactoryCache->FinalizeVectorAnimationManager();
+ }
+}
+
void VisualFactory::RegisterDiscardCallback()
{
if(!mIdleCallback && Adaptor::IsAvailable())
/**
* @copydoc Toolkit::VisualFactory
*/
-class VisualFactory : public BaseObject
+class VisualFactory : public BaseObject, public ConnectionTracker
{
public:
/**
*/
void RegisterDiscardCallback();
+ /**
+ * @brief Callbacks called when application is terminated.
+ */
+ void OnApplicationTerminated();
+
VisualFactory(const VisualFactory&) = delete;
VisualFactory& operator=(const VisualFactory& rhs) = delete;
projects / platform / core / uifw / dali-toolkit.git / commitdiff