vector_animation_renderer_plugin_src_files = \
- $(extension_src_dir)/vector-animation-renderer/tizen-vector-animation-renderer.cpp
+ $(extension_src_dir)/vector-animation-renderer/tizen-vector-animation-renderer.cpp \
+ $(extension_src_dir)/vector-animation-renderer/tizen-vector-animation-manager.cpp
+
--- /dev/null
+#ifndef DALI_TIZEN_VECTOR_ANIMATION_EVENT_HANDLER_H
+#define DALI_TIZEN_VECTOR_ANIMATION_EVENT_HANDLER_H
+
+/*
+ * Copyright (c) 2019 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+
+namespace Dali
+{
+
+namespace Plugin
+{
+
+/**
+ * @brief Tizen vector animation event handler
+ */
+class TizenVectorAnimationEventHandler
+{
+public:
+
+ /**
+ * @brief Notify events
+ */
+ virtual void NotifyEvent() = 0;
+
+protected:
+
+ /**
+ * constructor
+ */
+ TizenVectorAnimationEventHandler()
+ {
+ }
+
+ /**
+ * virtual destructor
+ */
+ virtual ~TizenVectorAnimationEventHandler()
+ {
+ }
+
+ // Undefined copy constructor.
+ TizenVectorAnimationEventHandler( const TizenVectorAnimationEventHandler& ) = delete;
+
+ // Undefined assignment operator.
+ TizenVectorAnimationEventHandler& operator=( const TizenVectorAnimationEventHandler& ) = delete;
+};
+
+} // namespace Plugin
+
+} // namespace Dali;
+
+#endif // DALI_TIZEN_VECTOR_ANIMATION_EVENT_HANDLER_H
--- /dev/null
+/*
+ * Copyright (c) 2019 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include <dali-extension/vector-animation-renderer/tizen-vector-animation-manager.h>
+
+// EXTERNAL INCLUDES
+#include <dali/integration-api/debug.h>
+#include <dali/integration-api/adaptor-framework/adaptor.h>
+
+namespace Dali
+{
+
+namespace Plugin
+{
+
+TizenVectorAnimationManager& TizenVectorAnimationManager::Get()
+{
+ static TizenVectorAnimationManager animationManager;
+ return animationManager;
+}
+
+TizenVectorAnimationManager::TizenVectorAnimationManager()
+: mEventHandlers(),
+ mTriggeredHandlers(),
+ mMutex(),
+ mEventTrigger( new EventThreadCallback( MakeCallback( this, &TizenVectorAnimationManager::OnEventTriggered ) ) )
+{
+}
+
+TizenVectorAnimationManager::~TizenVectorAnimationManager()
+{
+}
+
+void TizenVectorAnimationManager::AddEventHandler( TizenVectorAnimationEventHandler& handler )
+{
+ if( mEventHandlers.end() == std::find( mEventHandlers.begin(), mEventHandlers.end(), &handler ) )
+ {
+ if( mEventHandlers.empty() )
+ {
+ Adaptor::Get().RegisterProcessor( *this );
+ }
+
+ mEventHandlers.push_back( &handler );
+ }
+}
+
+void TizenVectorAnimationManager::RemoveEventHandler( TizenVectorAnimationEventHandler& handler )
+{
+ auto iter = std::find( mEventHandlers.begin(), mEventHandlers.end(), &handler );
+ if( iter != mEventHandlers.end() )
+ {
+ mEventHandlers.erase( iter );
+
+ if( mEventHandlers.empty() )
+ {
+ if( Adaptor::IsAvailable() )
+ {
+ Adaptor::Get().UnregisterProcessor( *this );
+ }
+ }
+ }
+}
+
+void TizenVectorAnimationManager::TriggerEvent( TizenVectorAnimationEventHandler& handler )
+{
+ Dali::Mutex::ScopedLock lock( mMutex );
+
+ if( mTriggeredHandlers.end() == std::find( mTriggeredHandlers.begin(), mTriggeredHandlers.end(), &handler ) )
+ {
+ mTriggeredHandlers.push_back( &handler );
+
+ mEventTrigger->Trigger();
+ }
+}
+
+void TizenVectorAnimationManager::Process()
+{
+ OnEventTriggered();
+}
+
+void TizenVectorAnimationManager::OnEventTriggered()
+{
+ Dali::Mutex::ScopedLock lock( mMutex );
+
+ for( auto&& iter : mTriggeredHandlers )
+ {
+ iter->NotifyEvent();
+ }
+
+ mTriggeredHandlers.clear();
+}
+
+} // namespace Plugin
+
+} // namespace Dali;
--- /dev/null
+#ifndef DALI_TIZEN_VECTOR_ANIMATION_MANAGER_H
+#define DALI_TIZEN_VECTOR_ANIMATION_MANAGER_H
+
+/*
+ * Copyright (c) 2019 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include <dali/public-api/common/vector-wrapper.h>
+#include <dali/devel-api/threading/mutex.h>
+#include <dali/devel-api/adaptor-framework/event-thread-callback.h>
+#include <dali/integration-api/processor-interface.h>
+#include <memory>
+
+// INTERNAL INCLUDES
+#include <dali-extension/vector-animation-renderer/tizen-vector-animation-event-handler.h>
+
+namespace Dali
+{
+
+namespace Plugin
+{
+
+/**
+ * @brief Tizen vector animation manager
+ */
+class TizenVectorAnimationManager : public Integration::Processor
+{
+public:
+
+ /**
+ * @brief Create or retrieve TizenVectorAnimationManager singleton.
+ *
+ * @return A reference to the TizenVectorAnimationManager.
+ */
+ static TizenVectorAnimationManager& Get();
+
+ /**
+ * @brief Add the event handler.
+ *
+ * @param handler The event handler to add.
+ */
+ void AddEventHandler( TizenVectorAnimationEventHandler& handler );
+
+ /**
+ * @brief Remove the event handler.
+ *
+ * @param handler The event handler to remove.
+ */
+ void RemoveEventHandler( TizenVectorAnimationEventHandler& handler );
+
+ /**
+ * @brief Trigger the event.
+ */
+ void TriggerEvent( TizenVectorAnimationEventHandler& handler );
+
+protected: // Implementation of Processor
+
+ /**
+ * @copydoc Dali::Integration::Processor::Process()
+ */
+ void Process() override;
+
+private:
+
+ /**
+ * @brief Event callback to process events.
+ */
+ void OnEventTriggered();
+
+private:
+
+ /**
+ * @brief Constructor.
+ */
+ TizenVectorAnimationManager();
+
+ /**
+ * @brief Destructor.
+ */
+ virtual ~TizenVectorAnimationManager();
+
+ // Undefined
+ TizenVectorAnimationManager( const TizenVectorAnimationManager& ) = delete;
+
+ // Undefined
+ TizenVectorAnimationManager& operator=( const TizenVectorAnimationManager& ) = delete;
+
+private:
+
+ std::vector< TizenVectorAnimationEventHandler* > mEventHandlers;
+ std::vector< TizenVectorAnimationEventHandler* > mTriggeredHandlers;
+ Dali::Mutex mMutex;
+ std::unique_ptr< EventThreadCallback > mEventTrigger;
+};
+
+} // namespace Plugin
+
+} // namespace Dali;
+
+#endif // DALI_TIZEN_VECTOR_ANIMATION_MANAGER_H
#include <cstring> // for strlen()
#include <tbm_surface_internal.h>
+// INTERNAL INCLUDES
+#include <dali-extension/vector-animation-renderer/tizen-vector-animation-manager.h>
+
// The plugin factories
extern "C" DALI_EXPORT_API Dali::VectorAnimationRendererPlugin* CreateVectorAnimationRendererPlugin( void )
{
mRenderedTexture(),
mTargetSurface(),
mVectorRenderer(),
- mResourceReadyTrigger( new EventThreadCallback( MakeCallback( this, &TizenVectorAnimationRenderer::OnResourceReady ) ) ),
mUploadCompletedSignal(),
mTbmQueue( NULL ),
mTotalFrameNumber( 0 ),
mDefaultHeight( 0 ),
mFrameRate( 60.0f ),
mResourceReady( false ),
- mShaderChanged( false )
+ mShaderChanged( false ),
+ mResourceReadyTriggered( false )
{
}
Dali::Mutex::ScopedLock lock( mMutex );
ResetBuffers();
+
+ TizenVectorAnimationManager::Get().RemoveEventHandler( *this );
}
bool TizenVectorAnimationRenderer::Initialize( const std::string& url )
mDefaultWidth = static_cast< uint32_t >( w );
mDefaultHeight = static_cast< uint32_t >( h );
+ TizenVectorAnimationManager::Get().AddEventHandler( *this );
+
DALI_LOG_RELEASE_INFO( "TizenVectorAnimationRenderer::Initialize: file [%s] [%p]\n", url.c_str(), this );
return true;
bool TizenVectorAnimationRenderer::Render( uint32_t frameNumber )
{
+ Dali::Mutex::ScopedLock lock( mMutex );
+
if( tbm_surface_queue_can_dequeue( mTbmQueue, 0 ) )
{
- Dali::Mutex::ScopedLock lock( mMutex );
-
tbm_surface_h tbmSurface;
if( tbm_surface_queue_dequeue( mTbmQueue, &tbmSurface ) != TBM_SURFACE_QUEUE_ERROR_NONE )
{
mRenderedTexture = mTexture;
mResourceReady = true;
+ mResourceReadyTriggered = true;
- mResourceReadyTrigger->Trigger();
+ TizenVectorAnimationManager::Get().TriggerEvent( *this );
DALI_LOG_RELEASE_INFO( "TizenVectorAnimationRenderer::Render: Resource ready [current = %d] [%p]\n", frameNumber, this );
}
- }
- else
- {
- return false;
+
+ return true;
}
- return true;
+ return false;
}
uint32_t TizenVectorAnimationRenderer::GetTotalFrameNumber() const
void TizenVectorAnimationRenderer::GetLayerInfo( Property::Map& map ) const
{
+ Dali::Mutex::ScopedLock lock( mMutex );
+
auto layerInfo = mVectorRenderer->layers();
for( auto&& iter : layerInfo )
return mUploadCompletedSignal;
}
+void TizenVectorAnimationRenderer::NotifyEvent()
+{
+ Dali::Mutex::ScopedLock lock( mMutex );
+
+ if( mResourceReadyTriggered )
+ {
+ DALI_LOG_RELEASE_INFO( "TizenVectorAnimationRenderer::NotifyEvent: Set Texture [%p]\n", this );
+
+ // Set texture
+ if( mRenderer )
+ {
+ TextureSet textureSet = mRenderer.GetTextures();
+ textureSet.SetTexture( 0, mRenderedTexture );
+ }
+
+ mResourceReadyTriggered = false;
+
+ mUploadCompletedSignal.Emit();
+ }
+}
+
void TizenVectorAnimationRenderer::SetShader()
{
if( mShaderChanged )
mBuffers.clear();
}
-void TizenVectorAnimationRenderer::OnResourceReady()
-{
- DALI_LOG_RELEASE_INFO( "TizenVectorAnimationRenderer::OnResourceReady: Set Texture [%p]\n", this );
-
- // Set texture
- if( mRenderer )
- {
- TextureSet textureSet = mRenderer.GetTextures();
- textureSet.SetTexture( 0, mRenderedTexture );
- }
-
- mUploadCompletedSignal.Emit();
-}
-
} // namespace Plugin
} // namespace Dali;
*/
// EXTERNAL INCLUDES
-#include <dali/public-api/math/uint-16-pair.h>
#include <dali/public-api/common/vector-wrapper.h>
#include <dali/devel-api/threading/mutex.h>
-#include <dali/devel-api/adaptor-framework/event-thread-callback.h>
#include <dali/devel-api/adaptor-framework/native-image-source-queue.h>
#include <dali/devel-api/adaptor-framework/vector-animation-renderer-plugin.h>
#include <memory>
#include <tbm_surface.h>
#include <tbm_surface_queue.h>
+// INTERNAL INCLUDES
+#include <dali-extension/vector-animation-renderer/tizen-vector-animation-event-handler.h>
+
namespace Dali
{
/**
* @brief Implementation of the Tizen vector animation renderer class which has Tizen platform dependency.
*/
-class TizenVectorAnimationRenderer : public Dali::VectorAnimationRendererPlugin
+class TizenVectorAnimationRenderer : public Dali::VectorAnimationRendererPlugin, public TizenVectorAnimationEventHandler
{
public:
*/
UploadCompletedSignalType& UploadCompletedSignal() override;
+protected: // Implementation of TizenVectorAnimationEventHandler
+
+ /**
+ * @copydoc Dali::Plugin::TizenVectorAnimationEventHandler::NotifyEvent()
+ */
+ void NotifyEvent() override;
+
private:
/**
*/
void ResetBuffers();
- /**
- * @brief Event callback from rasterize thread. This is called after the first frame is ready.
- */
- void OnResourceReady();
-
private:
using SurfacePair = std::pair< tbm_surface_h, rlottie::Surface >;
std::string mUrl; ///< The content file path
std::vector< SurfacePair > mBuffers; ///< EGL Image vector
- Dali::Mutex mMutex; ///< Mutex
+ mutable Dali::Mutex mMutex; ///< Mutex
Dali::Renderer mRenderer; ///< Renderer
Dali::Texture mTexture; ///< Texture
Dali::Texture mRenderedTexture; ///< Rendered Texture
NativeImageSourceQueuePtr mTargetSurface; ///< The target surface
std::unique_ptr< rlottie::Animation > mVectorRenderer; ///< The vector animation renderer
- std::unique_ptr< EventThreadCallback > mResourceReadyTrigger; ///< Resource ready trigger
UploadCompletedSignalType mUploadCompletedSignal; ///< Upload completed signal
tbm_surface_queue_h mTbmQueue; ///< Tbm surface queue handle
uint32_t mTotalFrameNumber; ///< The total frame number
float mFrameRate; ///< The frame rate of the content
bool mResourceReady; ///< Whether the resource is ready
bool mShaderChanged; ///< Whether the shader is changed to support native image
+ bool mResourceReadyTriggered;///< Whether the resource ready is triggered
};
} // namespace Plugin
projects / platform / core / uifw / dali-extension.git / commitdiff