Revert "vector-animation: Imeplements rive animation"

[platform/core/uifw/dali-adaptor.git] / dali / internal / vector-animation / common / vector-animation-renderer-plugin-proxy.cpp

diff --git a/dali/internal/vector-animation/common/vector-animation-renderer-plugin-proxy.cpp b/dali/internal/vector-animation/common/vector-animation-renderer-plugin-proxy.cpp
index b213478..78b747a 100644 (file)
--- a/dali/internal/vector-animation/common/vector-animation-renderer-plugin-proxy.cpp
+++ b/dali/internal/vector-animation/common/vector-animation-renderer-plugin-proxy.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2021 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.
@@ -19,33 +19,30 @@
 #include <dali/internal/vector-animation/common/vector-animation-renderer-plugin-proxy.h>
 
 // EXTERNAL INCLUDES
-#include <dlfcn.h>
 #include <dali/integration-api/debug.h>
+#include <dlfcn.h>
 
 namespace Dali
 {
-
 namespace Internal
 {
-
 namespace Adaptor
 {
-
 namespace
 {
-
 // The default plugin name
-const char* DEFAULT_OBJECT_NAME( "libdali-vector-animation-renderer-plugin.so" );
+const char* DEFAULT_OBJECT_NAME("libdali2-vector-animation-renderer-plugin.so");
 
-}
+} // namespace
 
-VectorAnimationRendererPluginProxy::VectorAnimationRendererPluginProxy( const std::string& sharedObjectName )
+VectorAnimationRendererPluginProxy::VectorAnimationRendererPluginProxy(const std::string& sharedObjectName)
 : mSharedObjectName(),
-  mLibHandle( NULL ),
-  mPlugin( NULL ),
-  mCreateVectorAnimationRendererPtr( NULL )
+  mLibHandle(NULL),
+  mPlugin(NULL),
+  mCreateVectorAnimationRendererPtr(NULL),
+  mDefaultSignal()
 {
-  if( !sharedObjectName.empty() )
+  if(!sharedObjectName.empty())
   {
     mSharedObjectName = sharedObjectName;
   }
@@ -59,98 +56,149 @@ VectorAnimationRendererPluginProxy::VectorAnimationRendererPluginProxy( const st
 
 VectorAnimationRendererPluginProxy::~VectorAnimationRendererPluginProxy()
 {
-  if( mPlugin )
+  if(mPlugin)
   {
     delete mPlugin;
     mPlugin = NULL;
 
-    if( mLibHandle && dlclose( mLibHandle ) )
+    if(mLibHandle && dlclose(mLibHandle))
     {
-      DALI_LOG_ERROR( "Error closing vector animation renderer plugin library: %s\n", dlerror() );
+      DALI_LOG_ERROR("Error closing vector animation renderer plugin library: %s\n", dlerror());
     }
   }
 }
 
 void VectorAnimationRendererPluginProxy::Initialize()
 {
-  mLibHandle = dlopen( mSharedObjectName.c_str(), RTLD_LAZY );
+  mLibHandle = dlopen(mSharedObjectName.c_str(), RTLD_LAZY);
 
   char* error = dlerror();
-  if( mLibHandle == NULL || error != NULL )
+  if(mLibHandle == NULL || error != NULL)
   {
-    DALI_LOG_ERROR( "VectorAnimationRendererPluginProxy::Initialize: dlopen error [%s]\n", error );
+    DALI_LOG_ERROR("VectorAnimationRendererPluginProxy::Initialize: dlopen error [%s]\n", error);
     return;
   }
 
   // load plugin
-  mCreateVectorAnimationRendererPtr = reinterpret_cast< CreateVectorAnimationRendererFunction >( dlsym( mLibHandle, "CreateVectorAnimationRendererPlugin" ) );
+  mCreateVectorAnimationRendererPtr = reinterpret_cast<CreateVectorAnimationRendererFunction>(dlsym(mLibHandle, "CreateVectorAnimationRendererPlugin"));
 
   error = dlerror();
-  if( mCreateVectorAnimationRendererPtr == NULL || error != NULL )
+  if(mCreateVectorAnimationRendererPtr == NULL || error != NULL)
   {
-    DALI_LOG_ERROR( "VectorAnimationRendererPluginProxy::Initialize: Cannot load symbol: %s\n", error );
+    DALI_LOG_ERROR("VectorAnimationRendererPluginProxy::Initialize: Cannot load symbol: %s\n", error);
     return;
   }
 
   mPlugin = mCreateVectorAnimationRendererPtr();
-  if( !mPlugin )
+  if(!mPlugin)
   {
     DALI_LOG_ERROR("VectorAnimationRendererPluginProxy::Initialize: Plugin creation failed\n");
     return;
   }
 }
 
-bool VectorAnimationRendererPluginProxy::CreateRenderer( const std::string& url, Dali::Renderer renderer, uint32_t width, uint32_t height )
+void VectorAnimationRendererPluginProxy::Finalize()
 {
-  if( mPlugin )
+  if(mPlugin)
   {
-    return mPlugin->CreateRenderer( url, renderer, width, height );
+    mPlugin->Finalize();
   }
-  return false;
 }
 
-void VectorAnimationRendererPluginProxy::SetSize( uint32_t width, uint32_t height )
+bool VectorAnimationRendererPluginProxy::Load(const std::string& url)
 {
-  if( mPlugin )
+  if(mPlugin)
   {
-    mPlugin->SetSize( width, height );
+    return mPlugin->Load(url);
   }
+  return false;
 }
 
-bool VectorAnimationRendererPluginProxy::StartRender()
+void VectorAnimationRendererPluginProxy::SetRenderer(Dali::Renderer renderer)
 {
-  if( mPlugin )
+  if(mPlugin)
   {
-    return mPlugin->StartRender();
+    mPlugin->SetRenderer(renderer);
   }
-  return false;
 }
 
-void VectorAnimationRendererPluginProxy::StopRender()
+void VectorAnimationRendererPluginProxy::SetSize(uint32_t width, uint32_t height)
 {
-  if( mPlugin )
+  if(mPlugin)
   {
-    mPlugin->StopRender();
+    mPlugin->SetSize(width, height);
   }
 }
 
-void VectorAnimationRendererPluginProxy::Render( uint32_t frameNumber )
+bool VectorAnimationRendererPluginProxy::Render(uint32_t frameNumber)
 {
-  if( mPlugin )
+  if(mPlugin)
   {
-    mPlugin->Render( frameNumber );
+    return mPlugin->Render(frameNumber);
   }
+  return false;
 }
 
-uint32_t VectorAnimationRendererPluginProxy::GetTotalFrameNumber()
+uint32_t VectorAnimationRendererPluginProxy::GetTotalFrameNumber() const
 {
-  if( mPlugin )
+  if(mPlugin)
   {
     return mPlugin->GetTotalFrameNumber();
   }
   return 0;
 }
 
+float VectorAnimationRendererPluginProxy::GetFrameRate() const
+{
+  if(mPlugin)
+  {
+    return mPlugin->GetFrameRate();
+  }
+  return 0.0f;
+}
+
+void VectorAnimationRendererPluginProxy::GetDefaultSize(uint32_t& width, uint32_t& height) const
+{
+  if(mPlugin)
+  {
+    mPlugin->GetDefaultSize(width, height);
+  }
+}
+
+void VectorAnimationRendererPluginProxy::GetLayerInfo(Property::Map& map) const
+{
+  if(mPlugin)
+  {
+    mPlugin->GetLayerInfo(map);
+  }
+}
+
+bool VectorAnimationRendererPluginProxy::GetMarkerInfo(const std::string& marker, uint32_t& startFrame, uint32_t& endFrame) const
+{
+  if(mPlugin)
+  {
+    return mPlugin->GetMarkerInfo(marker, startFrame, endFrame);
+  }
+  return false;
+}
+
+void VectorAnimationRendererPluginProxy::IgnoreRenderedFrame()
+{
+  if(mPlugin)
+  {
+    mPlugin->IgnoreRenderedFrame();
+  }
+}
+
+VectorAnimationRendererPlugin::UploadCompletedSignalType& VectorAnimationRendererPluginProxy::UploadCompletedSignal()
+{
+  if(mPlugin)
+  {
+    return mPlugin->UploadCompletedSignal();
+  }
+  return mDefaultSignal;
+}
+
 } // namespace Adaptor
 
 } // namespace Internal