dali-toolkit/internal/visuals/animated-vector-image/vector-animation-task.cpp

   1 /*
   2  * Copyright (c) 2023 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-toolkit/internal/visuals/animated-vector-image/vector-animation-task.h>
  20
  21 // EXTERNAL INCLUDES
  22 #include <dali/integration-api/debug.h>
  23 #include <dali/public-api/math/math-utils.h>
  24 #include <dali/public-api/object/property-array.h>
  25
  26 // INTERNAL INCLUDES
  27 #include <dali-toolkit/internal/visuals/animated-vector-image/vector-animation-manager.h>
  28 #include <dali-toolkit/internal/visuals/animated-vector-image/vector-animation-thread.h>
  29 #include <dali-toolkit/internal/visuals/image-visual-shader-factory.h>
  30
  31 namespace Dali
  32 {
  33 namespace Toolkit
  34 {
  35 namespace Internal
  36 {
  37 namespace
  38 {
  39 constexpr auto LOOP_FOREVER = -1;
  40 constexpr auto MICROSECONDS_PER_SECOND(1e+6);
  41
  42 #if defined(DEBUG_ENABLED)
  43 Debug::Filter* gVectorAnimationLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_VECTOR_ANIMATION");
  44 #endif
  45
  46 } // unnamed namespace
  47
  48 VectorAnimationTask::VectorAnimationTask(VisualFactoryCache& factoryCache)
  49 : AsyncTask(MakeCallback(this, &VectorAnimationTask::TaskCompleted), AsyncTask::PriorityType::HIGH, AsyncTask::ThreadType::WORKER_THREAD),
  50   mUrl(),
  51   mVectorRenderer(VectorAnimationRenderer::New()),
  52   mAnimationData(),
  53   mVectorAnimationThread(factoryCache.GetVectorAnimationManager().GetVectorAnimationThread()),
  54   mConditionalWait(),
  55   mResourceReadySignal(),
  56   mLoadCompletedCallback(MakeCallback(this, &VectorAnimationTask::OnLoadCompleted)),
  57   mPlayState(PlayState::STOPPED),
  58   mStopBehavior(DevelImageVisual::StopBehavior::CURRENT_FRAME),
  59   mLoopingMode(DevelImageVisual::LoopingMode::RESTART),
  60   mNextFrameStartTime(),
  61   mFrameDurationMicroSeconds(MICROSECONDS_PER_SECOND / 60.0f),
  62   mFrameRate(60.0f),
  63   mCurrentFrame(0),
  64   mTotalFrame(0),
  65   mStartFrame(0),
  66   mEndFrame(0),
  67   mDroppedFrames(0),
  68   mWidth(0),
  69   mHeight(0),
  70   mAnimationDataIndex(0),
  71   mLoopCount(LOOP_FOREVER),
  72   mCurrentLoop(0),
  73   mForward(true),
  74   mUpdateFrameNumber(false),
  75   mNeedAnimationFinishedTrigger(true),
  76   mAnimationDataUpdated(false),
  77   mDestroyTask(false),
  78   mLoadRequest(false),
  79   mLoadFailed(false),
  80   mRasterized(false),
  81   mKeepAnimation(false)
  82 {
  83   mVectorRenderer.UploadCompletedSignal().Connect(this, &VectorAnimationTask::OnUploadCompleted);
  84 }
  85
  86 VectorAnimationTask::~VectorAnimationTask()
  87 {
  88   DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::~VectorAnimationTask: destructor [%p]\n", this);
  89 }
  90
  91 void VectorAnimationTask::Process()
  92 {
  93   mRasterized = Rasterize();
  94 }
  95
  96 bool VectorAnimationTask::IsReady()
  97 {
  98   return true;
  99 }
 100
 101 void VectorAnimationTask::Finalize()
 102 {
 103   ConditionalWait::ScopedLock lock(mConditionalWait);
 104
 105   // Release some objects in the main thread
 106   if(mAnimationFinishedCallback)
 107   {
 108     mVectorAnimationThread.RemoveEventTriggerCallback(mAnimationFinishedCallback.get());
 109   }
 110   if(mLoadCompletedCallback)
 111   {
 112     mVectorAnimationThread.RemoveEventTriggerCallback(mLoadCompletedCallback.get());
 113   }
 114
 115   mVectorRenderer.Finalize();
 116
 117   mDestroyTask = true;
 118 }
 119
 120 void VectorAnimationTask::TaskCompleted(VectorAnimationTaskPtr task)
 121 {
 122   mVectorAnimationThread.OnTaskCompleted(task, task->IsRasterized(), task->IsAnimating());
 123 }
 124
 125 bool VectorAnimationTask::IsRasterized()
 126 {
 127   return mRasterized;
 128 }
 129
 130 bool VectorAnimationTask::IsAnimating()
 131 {
 132   return mKeepAnimation;
 133 }
 134
 135 bool VectorAnimationTask::Load(bool synchronousLoading)
 136 {
 137   if(!mVectorRenderer.Load(mUrl))
 138   {
 139     DALI_LOG_ERROR("VectorAnimationTask::Load: Load failed [%s]\n", mUrl.c_str());
 140     mLoadRequest = false;
 141     mLoadFailed  = true;
 142     if(!synchronousLoading)
 143     {
 144       mVectorAnimationThread.AddEventTriggerCallback(mLoadCompletedCallback.get());
 145     }
 146     return false;
 147   }
 148
 149   mTotalFrame = mVectorRenderer.GetTotalFrameNumber();
 150
 151   mEndFrame = mTotalFrame - 1;
 152
 153   mFrameRate                 = mVectorRenderer.GetFrameRate();
 154   mFrameDurationMicroSeconds = MICROSECONDS_PER_SECOND / mFrameRate;
 155
 156   mLoadRequest = false;
 157   if(!synchronousLoading)
 158   {
 159     mVectorAnimationThread.AddEventTriggerCallback(mLoadCompletedCallback.get());
 160   }
 161
 162   DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::Load: file = %s [%d frames, %f fps] [%p]\n", mUrl.c_str(), mTotalFrame, mFrameRate, this);
 163
 164   return true;
 165 }
 166
 167 void VectorAnimationTask::SetRenderer(Renderer renderer)
 168 {
 169   ConditionalWait::ScopedLock lock(mConditionalWait);
 170
 171   mVectorRenderer.SetRenderer(renderer);
 172
 173   DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::SetRenderer [%p]\n", this);
 174 }
 175
 176 void VectorAnimationTask::RequestLoad(const std::string& url, bool synchronousLoading)
 177 {
 178   mUrl = url;
 179
 180   if(!synchronousLoading)
 181   {
 182     mLoadRequest = true;
 183
 184     mVectorAnimationThread.AddTask(this);
 185   }
 186   else
 187   {
 188     Load(true);
 189
 190     OnLoadCompleted();
 191   }
 192 }
 193
 194 bool VectorAnimationTask::IsLoadRequested() const
 195 {
 196   return mLoadRequest;
 197 }
 198
 199 void VectorAnimationTask::SetAnimationData(const AnimationData& data)
 200 {
 201   ConditionalWait::ScopedLock lock(mConditionalWait);
 202
 203   DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::SetAnimationData [%p]\n", this);
 204
 205   uint32_t index = mAnimationDataIndex == 0 ? 1 : 0; // Use the other buffer
 206
 207   mAnimationData[index] = data;
 208   mAnimationDataUpdated = true;
 209
 210   if(data.resendFlag & VectorAnimationTask::RESEND_SIZE)
 211   {
 212     // The size should be changed in the main thread.
 213     SetSize(data.width, data.height);
 214   }
 215
 216   mVectorAnimationThread.AddTask(this);
 217 }
 218
 219 void VectorAnimationTask::SetSize(uint32_t width, uint32_t height)
 220 {
 221   if(mWidth != width || mHeight != height)
 222   {
 223     mVectorRenderer.SetSize(width, height);
 224
 225     mWidth  = width;
 226     mHeight = height;
 227
 228     DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::SetSize: width = %d, height = %d [%p]\n", width, height, this);
 229   }
 230 }
 231
 232 void VectorAnimationTask::PlayAnimation()
 233 {
 234   if(mPlayState != PlayState::PLAYING)
 235   {
 236     mNeedAnimationFinishedTrigger = true;
 237     mUpdateFrameNumber            = false;
 238     mPlayState                    = PlayState::PLAYING;
 239
 240     DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::PlayAnimation: Play [%p]\n", this);
 241   }
 242 }
 243
 244 void VectorAnimationTask::StopAnimation()
 245 {
 246   if(mPlayState != PlayState::STOPPING)
 247   {
 248     mNeedAnimationFinishedTrigger = false;
 249     mPlayState                    = PlayState::STOPPING;
 250
 251     DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::StopAnimation: Stop [%p]\n", this);
 252   }
 253 }
 254
 255 void VectorAnimationTask::PauseAnimation()
 256 {
 257   if(mPlayState == PlayState::PLAYING)
 258   {
 259     mPlayState = PlayState::PAUSED;
 260
 261     DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::PauseAnimation: Pause [%p]\n", this);
 262   }
 263 }
 264
 265 void VectorAnimationTask::SetAnimationFinishedCallback(CallbackBase* callback)
 266 {
 267   ConditionalWait::ScopedLock lock(mConditionalWait);
 268   mAnimationFinishedCallback = std::unique_ptr<CallbackBase>(callback);
 269 }
 270
 271 void VectorAnimationTask::SetLoopCount(int32_t count)
 272 {
 273   if(mLoopCount != count)
 274   {
 275     mLoopCount   = count;
 276     mCurrentLoop = 0;
 277
 278     DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::SetLoopCount: [%d] [%p]\n", count, this);
 279   }
 280 }
 281
 282 void VectorAnimationTask::SetPlayRange(const Property::Array& playRange)
 283 {
 284   bool     valid      = false;
 285   uint32_t startFrame = 0, endFrame = 0;
 286   size_t   count = playRange.Count();
 287
 288   if(count >= 2)
 289   {
 290     int32_t start = 0, end = 0;
 291     if(playRange.GetElementAt(0).Get(start) && playRange.GetElementAt(1).Get(end))
 292     {
 293       startFrame = static_cast<uint32_t>(start);
 294       endFrame   = static_cast<uint32_t>(end);
 295       valid      = true;
 296     }
 297     else
 298     {
 299       std::string startMarker, endMarker;
 300       if(playRange.GetElementAt(0).Get(startMarker) && playRange.GetElementAt(1).Get(endMarker))
 301       {
 302         if(mVectorRenderer)
 303         {
 304           uint32_t frame; // We don't use this later
 305           if(mVectorRenderer.GetMarkerInfo(startMarker, startFrame, frame) && mVectorRenderer.GetMarkerInfo(endMarker, frame, endFrame))
 306           {
 307             valid = true;
 308           }
 309         }
 310       }
 311     }
 312   }
 313   else if(count == 1)
 314   {
 315     std::string marker;
 316     if(playRange.GetElementAt(0).Get(marker))
 317     {
 318       if(mVectorRenderer && mVectorRenderer.GetMarkerInfo(marker, startFrame, endFrame))
 319       {
 320         valid = true;
 321       }
 322     }
 323   }
 324
 325   if(!valid)
 326   {
 327     DALI_LOG_ERROR("VectorAnimationTask::SetPlayRange: Invalid range [%p]\n", this);
 328     return;
 329   }
 330
 331   // Make sure the range specified is between 0 and the total frame number
 332   startFrame = std::min(startFrame, mTotalFrame - 1);
 333   endFrame   = std::min(endFrame, mTotalFrame - 1);
 334
 335   // If the range is not in order swap values
 336   if(startFrame > endFrame)
 337   {
 338     uint32_t temp = startFrame;
 339     startFrame    = endFrame;
 340     endFrame      = temp;
 341   }
 342
 343   if(startFrame != mStartFrame || endFrame != mEndFrame)
 344   {
 345     mStartFrame = startFrame;
 346     mEndFrame   = endFrame;
 347
 348     // If the current frame is out of the range, change the current frame also.
 349     if(mStartFrame > mCurrentFrame)
 350     {
 351       mCurrentFrame = mStartFrame;
 352     }
 353     else if(mEndFrame < mCurrentFrame)
 354     {
 355       mCurrentFrame = mEndFrame;
 356     }
 357
 358     DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::SetPlayRange: [%d, %d] [%s] [%p]\n", mStartFrame, mEndFrame, mUrl.c_str(), this);
 359   }
 360 }
 361
 362 void VectorAnimationTask::GetPlayRange(uint32_t& startFrame, uint32_t& endFrame)
 363 {
 364   startFrame = mStartFrame;
 365   endFrame   = mEndFrame;
 366 }
 367
 368 void VectorAnimationTask::SetCurrentFrameNumber(uint32_t frameNumber)
 369 {
 370   if(mCurrentFrame == frameNumber)
 371   {
 372     DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::SetCurrentFrameNumber: Set same frame [%d] [%p]\n", frameNumber, this);
 373     return;
 374   }
 375
 376   if(frameNumber >= mStartFrame && frameNumber <= mEndFrame)
 377   {
 378     mCurrentFrame      = frameNumber;
 379     mUpdateFrameNumber = false;
 380
 381     DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::SetCurrentFrameNumber: frame number = %d [%p]\n", mCurrentFrame, this);
 382   }
 383   else
 384   {
 385     DALI_LOG_ERROR("Invalid frame number [%d (%d, %d)] [%p]\n", frameNumber, mStartFrame, mEndFrame, this);
 386   }
 387 }
 388
 389 uint32_t VectorAnimationTask::GetCurrentFrameNumber() const
 390 {
 391   return mCurrentFrame;
 392 }
 393
 394 uint32_t VectorAnimationTask::GetTotalFrameNumber() const
 395 {
 396   return mTotalFrame;
 397 }
 398
 399 void VectorAnimationTask::GetDefaultSize(uint32_t& width, uint32_t& height) const
 400 {
 401   mVectorRenderer.GetDefaultSize(width, height);
 402 }
 403
 404 void VectorAnimationTask::SetStopBehavior(DevelImageVisual::StopBehavior::Type stopBehavior)
 405 {
 406   mStopBehavior = stopBehavior;
 407
 408   DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::SetStopBehavior: stop behavor = %d [%p]\n", mStopBehavior, this);
 409 }
 410
 411 void VectorAnimationTask::SetLoopingMode(DevelImageVisual::LoopingMode::Type loopingMode)
 412 {
 413   mLoopingMode = loopingMode;
 414
 415   DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::SetLoopingMode: looping mode = %d [%p]\n", mLoopingMode, this);
 416 }
 417
 418 void VectorAnimationTask::GetLayerInfo(Property::Map& map) const
 419 {
 420   mVectorRenderer.GetLayerInfo(map);
 421 }
 422
 423 VectorAnimationTask::ResourceReadySignalType& VectorAnimationTask::ResourceReadySignal()
 424 {
 425   return mResourceReadySignal;
 426 }
 427
 428 bool VectorAnimationTask::Rasterize()
 429 {
 430   bool     stopped = false;
 431   uint32_t currentFrame;
 432   mKeepAnimation = false;
 433
 434   {
 435     ConditionalWait::ScopedLock lock(mConditionalWait);
 436     if(mDestroyTask)
 437     {
 438       // The task will be destroyed. We don't need rasterization.
 439       return false;
 440     }
 441   }
 442
 443   if(mLoadRequest)
 444   {
 445     return Load(false);
 446   }
 447
 448   if(mLoadFailed)
 449   {
 450     return false;
 451   }
 452
 453   ApplyAnimationData();
 454
 455   if(mPlayState == PlayState::PLAYING && mUpdateFrameNumber)
 456   {
 457     mCurrentFrame = mForward ? mCurrentFrame + mDroppedFrames + 1 : (mCurrentFrame > mDroppedFrames ? mCurrentFrame - mDroppedFrames - 1 : 0);
 458     Dali::ClampInPlace(mCurrentFrame, mStartFrame, mEndFrame);
 459   }
 460
 461   currentFrame = mCurrentFrame;
 462
 463   mUpdateFrameNumber = true;
 464
 465   if(mPlayState == PlayState::STOPPING)
 466   {
 467     mCurrentFrame = GetStoppedFrame(mStartFrame, mEndFrame, mCurrentFrame);
 468     currentFrame  = mCurrentFrame;
 469     stopped       = true;
 470   }
 471   else if(mPlayState == PlayState::PLAYING)
 472   {
 473     bool animationFinished = false;
 474
 475     if(currentFrame >= mEndFrame) // last frame
 476     {
 477       if(mLoopingMode == DevelImageVisual::LoopingMode::AUTO_REVERSE)
 478       {
 479         mForward = false;
 480       }
 481       else
 482       {
 483         if(mLoopCount < 0 || ++mCurrentLoop < mLoopCount) // repeat forever or before the last loop
 484         {
 485           mCurrentFrame      = mStartFrame;
 486           mUpdateFrameNumber = false;
 487         }
 488         else
 489         {
 490           animationFinished = true; // end of animation
 491         }
 492       }
 493     }
 494     else if(currentFrame == mStartFrame && !mForward) // first frame
 495     {
 496       if(mLoopCount < 0 || ++mCurrentLoop < mLoopCount) // repeat forever or before the last loop
 497       {
 498         mForward = true;
 499       }
 500       else
 501       {
 502         animationFinished = true; // end of animation
 503       }
 504     }
 505
 506     if(animationFinished)
 507     {
 508       if(mStopBehavior == DevelImageVisual::StopBehavior::CURRENT_FRAME)
 509       {
 510         stopped = true;
 511       }
 512       else
 513       {
 514         mPlayState = PlayState::STOPPING;
 515       }
 516     }
 517   }
 518
 519   // Rasterize
 520   bool renderSuccess = false;
 521   if(mVectorRenderer)
 522   {
 523     renderSuccess = mVectorRenderer.Render(currentFrame);
 524     if(!renderSuccess)
 525     {
 526       DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::Rasterize: Rendering failed. Try again later.[%d] [%p]\n", currentFrame, this);
 527       mUpdateFrameNumber = false;
 528     }
 529   }
 530
 531   if(stopped && renderSuccess)
 532   {
 533     mPlayState   = PlayState::STOPPED;
 534     mForward     = true;
 535     mCurrentLoop = 0;
 536
 537     if(mVectorRenderer)
 538     {
 539       // Notify the Renderer that rendering is stopped.
 540       mVectorRenderer.RenderStopped();
 541     }
 542
 543     // Animation is finished
 544     {
 545       ConditionalWait::ScopedLock lock(mConditionalWait);
 546       if(mNeedAnimationFinishedTrigger && mAnimationFinishedCallback)
 547       {
 548         mVectorAnimationThread.AddEventTriggerCallback(mAnimationFinishedCallback.get());
 549       }
 550     }
 551
 552     DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::Rasterize: Animation is finished [current = %d] [%p]\n", currentFrame, this);
 553   }
 554
 555   if(mPlayState != PlayState::PAUSED && mPlayState != PlayState::STOPPED)
 556   {
 557     mKeepAnimation = true;
 558   }
 559
 560   return true;
 561 }
 562
 563 uint32_t VectorAnimationTask::GetStoppedFrame(uint32_t startFrame, uint32_t endFrame, uint32_t currentFrame)
 564 {
 565   uint32_t frame = currentFrame;
 566
 567   switch(mStopBehavior)
 568   {
 569     case DevelImageVisual::StopBehavior::FIRST_FRAME:
 570     {
 571       frame = startFrame;
 572       break;
 573     }
 574     case DevelImageVisual::StopBehavior::LAST_FRAME:
 575     {
 576       if(mLoopingMode == DevelImageVisual::LoopingMode::AUTO_REVERSE)
 577       {
 578         frame = startFrame;
 579       }
 580       else
 581       {
 582         frame = endFrame;
 583       }
 584       break;
 585     }
 586     case DevelImageVisual::StopBehavior::CURRENT_FRAME:
 587     {
 588       frame = currentFrame;
 589       break;
 590     }
 591   }
 592
 593   return frame;
 594 }
 595
 596 VectorAnimationTask::TimePoint VectorAnimationTask::CalculateNextFrameTime(bool renderNow)
 597 {
 598   // std::chrono::time_point template has second parameter duration which defaults to the std::chrono::steady_clock supported
 599   // duration. In some C++11 implementations it is a milliseconds duration, so it fails to compile unless mNextFrameStartTime
 600   // is casted to use the default duration.
 601   mNextFrameStartTime = std::chrono::time_point_cast<TimePoint::duration>(mNextFrameStartTime + std::chrono::microseconds(mFrameDurationMicroSeconds));
 602   auto current        = std::chrono::steady_clock::now();
 603   mDroppedFrames      = 0;
 604
 605   if(renderNow)
 606   {
 607     mNextFrameStartTime = current;
 608   }
 609   else if(mNextFrameStartTime < current)
 610   {
 611     uint32_t droppedFrames = 0;
 612
 613     while(current > std::chrono::time_point_cast<TimePoint::duration>(mNextFrameStartTime + std::chrono::microseconds(mFrameDurationMicroSeconds)) && droppedFrames < mTotalFrame)
 614     {
 615       droppedFrames++;
 616       mNextFrameStartTime = std::chrono::time_point_cast<TimePoint::duration>(mNextFrameStartTime + std::chrono::microseconds(mFrameDurationMicroSeconds));
 617     }
 618
 619     mNextFrameStartTime = current;
 620     mDroppedFrames      = droppedFrames;
 621   }
 622
 623   return mNextFrameStartTime;
 624 }
 625
 626 VectorAnimationTask::TimePoint VectorAnimationTask::GetNextFrameTime()
 627 {
 628   return mNextFrameStartTime;
 629 }
 630
 631 void VectorAnimationTask::ApplyAnimationData()
 632 {
 633   uint32_t index;
 634
 635   {
 636     ConditionalWait::ScopedLock lock(mConditionalWait);
 637
 638     if(!mAnimationDataUpdated || mAnimationData[mAnimationDataIndex].resendFlag != 0)
 639     {
 640       // Data is not updated or the previous data is not applied yet.
 641       return;
 642     }
 643
 644     mAnimationDataIndex   = mAnimationDataIndex == 0 ? 1 : 0; // Swap index
 645     mAnimationDataUpdated = false;
 646
 647     index = mAnimationDataIndex;
 648   }
 649
 650   if(mAnimationData[index].resendFlag & VectorAnimationTask::RESEND_LOOP_COUNT)
 651   {
 652     SetLoopCount(mAnimationData[index].loopCount);
 653   }
 654
 655   if(mAnimationData[index].resendFlag & VectorAnimationTask::RESEND_PLAY_RANGE)
 656   {
 657     SetPlayRange(mAnimationData[index].playRange);
 658   }
 659
 660   if(mAnimationData[index].resendFlag & VectorAnimationTask::RESEND_STOP_BEHAVIOR)
 661   {
 662     SetStopBehavior(mAnimationData[index].stopBehavior);
 663   }
 664
 665   if(mAnimationData[index].resendFlag & VectorAnimationTask::RESEND_LOOPING_MODE)
 666   {
 667     SetLoopingMode(mAnimationData[index].loopingMode);
 668   }
 669
 670   if(mAnimationData[index].resendFlag & VectorAnimationTask::RESEND_CURRENT_FRAME)
 671   {
 672     SetCurrentFrameNumber(mAnimationData[index].currentFrame);
 673   }
 674
 675   if(mAnimationData[index].resendFlag & VectorAnimationTask::RESEND_NEED_RESOURCE_READY)
 676   {
 677     mVectorRenderer.InvalidateBuffer();
 678   }
 679
 680   if(mAnimationData[index].resendFlag & VectorAnimationTask::RESEND_DYNAMIC_PROPERTY)
 681   {
 682     for(auto&& iter : mAnimationData[index].dynamicProperties)
 683     {
 684       mVectorRenderer.AddPropertyValueCallback(iter.keyPath, static_cast<VectorAnimationRenderer::VectorProperty>(iter.property), iter.callback, iter.id);
 685     }
 686   }
 687
 688   if(mAnimationData[index].resendFlag & VectorAnimationTask::RESEND_PLAY_STATE)
 689   {
 690     if(mAnimationData[index].playState == DevelImageVisual::PlayState::PLAYING)
 691     {
 692       PlayAnimation();
 693     }
 694     else if(mAnimationData[index].playState == DevelImageVisual::PlayState::PAUSED)
 695     {
 696       PauseAnimation();
 697     }
 698     else if(mAnimationData[index].playState == DevelImageVisual::PlayState::STOPPED)
 699     {
 700       StopAnimation();
 701     }
 702   }
 703
 704   // reset data
 705   mAnimationData[index].dynamicProperties.clear();
 706   mAnimationData[index].resendFlag = 0;
 707 }
 708
 709 void VectorAnimationTask::OnUploadCompleted()
 710 {
 711   mResourceReadySignal.Emit(ResourceStatus::READY);
 712 }
 713
 714 void VectorAnimationTask::OnLoadCompleted()
 715 {
 716   if(!mLoadFailed)
 717   {
 718     mResourceReadySignal.Emit(ResourceStatus::LOADED);
 719   }
 720   else
 721   {
 722     mResourceReadySignal.Emit(ResourceStatus::FAILED);
 723   }
 724 }
 725 } // namespace Internal
 726
 727 } // namespace Toolkit
 728
 729 } // namespace Dali