dali/internal/vector-animation/common/vector-animation-renderer-plugin-proxy.cpp

   1 /*
   2  * Copyright (c) 2022 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 // CLASS HEADER
  19 #include <dali/internal/vector-animation/common/vector-animation-renderer-plugin-proxy.h>
  20
  21 // EXTERNAL INCLUDES
  22 #include <dali/integration-api/debug.h>
  23 #include <dlfcn.h>
  24
  25 namespace Dali
  26 {
  27 namespace Internal
  28 {
  29 namespace Adaptor
  30 {
  31 namespace
  32 {
  33 // The default plugin name
  34 const char* DEFAULT_OBJECT_NAME("libdali2-vector-animation-renderer-plugin.so");
  35
  36 } // namespace
  37
  38 VectorAnimationRendererPluginProxy::VectorAnimationRendererPluginProxy(const std::string& sharedObjectName)
  39 : mSharedObjectName(),
  40   mLibHandle(NULL),
  41   mPlugin(NULL),
  42   mCreateVectorAnimationRendererPtr(NULL),
  43   mDefaultSignal()
  44 {
  45   if(!sharedObjectName.empty())
  46   {
  47     mSharedObjectName = sharedObjectName;
  48   }
  49   else
  50   {
  51     mSharedObjectName = DEFAULT_OBJECT_NAME;
  52   }
  53
  54   Initialize();
  55 }
  56
  57 VectorAnimationRendererPluginProxy::~VectorAnimationRendererPluginProxy()
  58 {
  59   if(mPlugin)
  60   {
  61     delete mPlugin;
  62     mPlugin = NULL;
  63
  64     if(mLibHandle && dlclose(mLibHandle))
  65     {
  66       DALI_LOG_ERROR("Error closing vector animation renderer plugin library: %s\n", dlerror());
  67     }
  68   }
  69 }
  70
  71 void VectorAnimationRendererPluginProxy::Initialize()
  72 {
  73   mLibHandle = dlopen(mSharedObjectName.c_str(), RTLD_LAZY);
  74
  75   char* error = dlerror();
  76   if(mLibHandle == NULL || error != NULL)
  77   {
  78     DALI_LOG_ERROR("VectorAnimationRendererPluginProxy::Initialize: dlopen error [%s]\n", error);
  79     return;
  80   }
  81
  82   // load plugin
  83   mCreateVectorAnimationRendererPtr = reinterpret_cast<CreateVectorAnimationRendererFunction>(dlsym(mLibHandle, "CreateVectorAnimationRendererPlugin"));
  84
  85   error = dlerror();
  86   if(mCreateVectorAnimationRendererPtr == NULL || error != NULL)
  87   {
  88     DALI_LOG_ERROR("VectorAnimationRendererPluginProxy::Initialize: Cannot load symbol: %s\n", error);
  89     return;
  90   }
  91
  92   mPlugin = mCreateVectorAnimationRendererPtr();
  93   if(!mPlugin)
  94   {
  95     DALI_LOG_ERROR("VectorAnimationRendererPluginProxy::Initialize: Plugin creation failed\n");
  96     return;
  97   }
  98 }
  99
 100 void VectorAnimationRendererPluginProxy::Finalize()
 101 {
 102   if(mPlugin)
 103   {
 104     mPlugin->Finalize();
 105   }
 106 }
 107
 108 bool VectorAnimationRendererPluginProxy::Load(const std::string& url)
 109 {
 110   if(mPlugin)
 111   {
 112     return mPlugin->Load(url);
 113   }
 114   return false;
 115 }
 116
 117 void VectorAnimationRendererPluginProxy::SetRenderer(Dali::Renderer renderer)
 118 {
 119   if(mPlugin)
 120   {
 121     mPlugin->SetRenderer(renderer);
 122   }
 123 }
 124
 125 void VectorAnimationRendererPluginProxy::SetSize(uint32_t width, uint32_t height)
 126 {
 127   if(mPlugin)
 128   {
 129     mPlugin->SetSize(width, height);
 130   }
 131 }
 132
 133 bool VectorAnimationRendererPluginProxy::Render(uint32_t frameNumber)
 134 {
 135   if(mPlugin)
 136   {
 137     return mPlugin->Render(frameNumber);
 138   }
 139   return false;
 140 }
 141
 142 void VectorAnimationRendererPluginProxy::RenderStopped()
 143 {
 144   if(mPlugin)
 145   {
 146     mPlugin->RenderStopped();
 147   }
 148 }
 149
 150 uint32_t VectorAnimationRendererPluginProxy::GetTotalFrameNumber() const
 151 {
 152   if(mPlugin)
 153   {
 154     return mPlugin->GetTotalFrameNumber();
 155   }
 156   return 0;
 157 }
 158
 159 float VectorAnimationRendererPluginProxy::GetFrameRate() const
 160 {
 161   if(mPlugin)
 162   {
 163     return mPlugin->GetFrameRate();
 164   }
 165   return 0.0f;
 166 }
 167
 168 void VectorAnimationRendererPluginProxy::GetDefaultSize(uint32_t& width, uint32_t& height) const
 169 {
 170   if(mPlugin)
 171   {
 172     mPlugin->GetDefaultSize(width, height);
 173   }
 174   else
 175   {
 176     width  = 0;
 177     height = 0;
 178   }
 179 }
 180
 181 void VectorAnimationRendererPluginProxy::GetLayerInfo(Property::Map& map) const
 182 {
 183   if(mPlugin)
 184   {
 185     mPlugin->GetLayerInfo(map);
 186   }
 187 }
 188
 189 bool VectorAnimationRendererPluginProxy::GetMarkerInfo(const std::string& marker, uint32_t& startFrame, uint32_t& endFrame) const
 190 {
 191   if(mPlugin)
 192   {
 193     return mPlugin->GetMarkerInfo(marker, startFrame, endFrame);
 194   }
 195   return false;
 196 }
 197
 198 void VectorAnimationRendererPluginProxy::InvalidateBuffer()
 199 {
 200   if(mPlugin)
 201   {
 202     mPlugin->InvalidateBuffer();
 203   }
 204 }
 205
 206 void VectorAnimationRendererPluginProxy::AddPropertyValueCallback(const std::string& keyPath, Dali::VectorAnimationRenderer::VectorProperty property, CallbackBase* callback, int32_t id)
 207 {
 208   if(mPlugin)
 209   {
 210     mPlugin->AddPropertyValueCallback(keyPath, property, callback, id);
 211   }
 212 }
 213
 214 VectorAnimationRendererPlugin::UploadCompletedSignalType& VectorAnimationRendererPluginProxy::UploadCompletedSignal()
 215 {
 216   if(mPlugin)
 217   {
 218     return mPlugin->UploadCompletedSignal();
 219   }
 220   return mDefaultSignal;
 221 }
 222
 223 } // namespace Adaptor
 224
 225 } // namespace Internal
 226
 227 } // namespace Dali