automated-tests/src/dali-toolkit/utc-Dali-AnimatedVectorImageVisual.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 #include <stdlib.h>
  18 #include <chrono>
  19 #include <iostream>
  20 #include <thread>
  21
  22 #include <dali-toolkit-test-suite-utils.h>
  23 #include <toolkit-event-thread-callback.h>
  24 #include <toolkit-timer.h>
  25 #include <toolkit-vector-animation-renderer.h>
  26 #include "dummy-control.h"
  27
  28 #include <dali-toolkit/dali-toolkit.h>
  29
  30 #include <dali-toolkit/devel-api/controls/control-devel.h>
  31 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
  32 #include <dali-toolkit/devel-api/visuals/animated-vector-image-visual-actions-devel.h>
  33 #include <dali-toolkit/devel-api/visuals/animated-vector-image-visual-signals-devel.h>
  34 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
  35 #include <dali-toolkit/devel-api/visuals/visual-actions-devel.h>
  36 #include <dali-toolkit/devel-api/visuals/visual-properties-devel.h>
  37 #include <dali/devel-api/adaptor-framework/window-devel.h>
  38 #include <dali/devel-api/rendering/renderer-devel.h>
  39
  40 using namespace Dali;
  41 using namespace Dali::Toolkit;
  42
  43 void dali_animated_vector_image_visual_startup(void)
  44 {
  45   test_return_value = TET_UNDEF;
  46 }
  47
  48 void dali_animated_vector_image_visual_cleanup(void)
  49 {
  50   test_return_value = TET_PASS;
  51 }
  52
  53 namespace
  54 {
  55 const char* TEST_VECTOR_IMAGE_FILE_NAME            = TEST_RESOURCE_DIR "/insta_camera.json";
  56 const char* TEST_VECTOR_IMAGE_FILE_NAME_FRAME_DROP = "framedrop.json";
  57 const char* TEST_VECTOR_IMAGE_INVALID_FILE_NAME    = "invalid.json";
  58
  59 bool gAnimationFinishedSignalFired = false;
  60
  61 void VisualEventSignal(Control control, Dali::Property::Index visualIndex, Dali::Property::Index signalId)
  62 {
  63   if(visualIndex == DummyControl::Property::TEST_VISUAL && signalId == DevelAnimatedVectorImageVisual::Signal::ANIMATION_FINISHED)
  64   {
  65     gAnimationFinishedSignalFired = true;
  66   }
  67 }
  68
  69 } // namespace
  70
  71 int UtcDaliVisualFactoryGetAnimatedVectorImageVisual01(void)
  72 {
  73   ToolkitTestApplication application;
  74   tet_infoline("UtcDaliVisualFactoryGetAnimatedVectorImageVisual01: Request animated vector image visual with a json url");
  75
  76   VisualFactory factory = VisualFactory::Get();
  77   Visual::Base  visual  = factory.CreateVisual(TEST_VECTOR_IMAGE_FILE_NAME, ImageDimensions());
  78   DALI_TEST_CHECK(visual);
  79
  80   DummyControl      actor     = DummyControl::New(true);
  81   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
  82   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
  83   actor.SetProperty(Actor::Property::SIZE, Vector2(200.0f, 200.0f));
  84   application.GetScene().Add(actor);
  85
  86   application.SendNotification();
  87   application.Render();
  88
  89   // Trigger count is 2 - load & render a frame
  90   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
  91
  92   // renderer is added to actor
  93   DALI_TEST_CHECK(actor.GetRendererCount() == 1u);
  94   Renderer renderer = actor.GetRendererAt(0u);
  95   DALI_TEST_CHECK(renderer);
  96
  97   // Test SetOffScene().
  98   actor.Unparent();
  99   DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
 100
 101   END_TEST;
 102 }
 103
 104 int UtcDaliVisualFactoryGetAnimatedVectorImageVisual02(void)
 105 {
 106   ToolkitTestApplication application;
 107   tet_infoline("UtcDaliVisualFactoryGetAnimatedVectorImageVisual02: Request animated vector image visual with a Property::Map");
 108
 109   Property::Map propertyMap;
 110   propertyMap.Add(Toolkit::Visual::Property::TYPE, DevelVisual::ANIMATED_VECTOR_IMAGE)
 111     .Add(ImageVisual::Property::URL, TEST_VECTOR_IMAGE_FILE_NAME);
 112
 113   Visual::Base visual = VisualFactory::Get().CreateVisual(propertyMap);
 114   DALI_TEST_CHECK(visual);
 115
 116   DummyControl      actor     = DummyControl::New(true);
 117   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
 118   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
 119   actor.SetProperty(Actor::Property::SIZE, Vector2(200.0f, 200.0f));
 120   application.GetScene().Add(actor);
 121
 122   application.SendNotification();
 123   application.Render();
 124
 125   // Trigger count is 2 - load & render a frame
 126   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
 127
 128   // renderer is added to actor
 129   DALI_TEST_CHECK(actor.GetRendererCount() == 1u);
 130   Renderer renderer = actor.GetRendererAt(0u);
 131   DALI_TEST_CHECK(renderer);
 132
 133   actor.Unparent();
 134   DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
 135
 136   END_TEST;
 137 }
 138
 139 int UtcDaliVisualFactoryGetAnimatedVectorImageVisual03(void)
 140 {
 141   ToolkitTestApplication application;
 142   tet_infoline("UtcDaliVisualFactoryGetAnimatedVectorImageVisual03: Request animated vector image visual with a Property::Map");
 143
 144   int             startFrame = 1, endFrame = 3;
 145   Property::Array playRange;
 146   playRange.PushBack(startFrame);
 147   playRange.PushBack(endFrame);
 148
 149   Property::Map propertyMap;
 150   propertyMap.Add(Toolkit::Visual::Property::TYPE, DevelVisual::ANIMATED_VECTOR_IMAGE)
 151     .Add(ImageVisual::Property::URL, TEST_VECTOR_IMAGE_FILE_NAME)
 152     .Add(DevelImageVisual::Property::LOOP_COUNT, 3)
 153     .Add(DevelImageVisual::Property::PLAY_RANGE, playRange)
 154     .Add(DevelVisual::Property::CORNER_RADIUS, 50.0f)
 155     .Add(DevelVisual::Property::BORDERLINE_WIDTH, 20.0f);
 156
 157   Visual::Base visual = VisualFactory::Get().CreateVisual(propertyMap);
 158   DALI_TEST_CHECK(visual);
 159
 160   DummyControl      actor     = DummyControl::New(true);
 161   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
 162   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
 163   actor.SetProperty(Actor::Property::SIZE, Vector2(200.0f, 200.0f));
 164   application.GetScene().Add(actor);
 165
 166   application.SendNotification();
 167   application.Render();
 168
 169   // Trigger count is 2 - load & render a frame
 170   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
 171
 172   // renderer is added to actor
 173   DALI_TEST_CHECK(actor.GetRendererCount() == 1u);
 174   Renderer renderer = actor.GetRendererAt(0u);
 175   DALI_TEST_CHECK(renderer);
 176
 177   actor.Unparent();
 178   DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
 179
 180   END_TEST;
 181 }
 182
 183 int UtcDaliVisualFactoryGetAnimatedVectorImageVisual04(void)
 184 {
 185   ToolkitTestApplication application;
 186   tet_infoline("UtcDaliVisualFactoryGetAnimatedVectorImageVisual04: Request animated vector image visual with a Property::Map");
 187
 188   int             startFrame = 1, endFrame = 3;
 189   float           cornerRadius     = 22.0f;
 190   float           borderlineWidth  = 2.0f;
 191   Vector4         borderlineColor  = Vector4(1.0f, 1.0f, 1.0f, 1.0f);
 192   float           borderlineOffset = 0.1f;
 193   Property::Array playRange;
 194   playRange.PushBack(startFrame);
 195   playRange.PushBack(endFrame);
 196
 197   Property::Map propertyMap;
 198   propertyMap.Add("visualType", DevelVisual::ANIMATED_VECTOR_IMAGE)
 199     .Add("url", TEST_VECTOR_IMAGE_FILE_NAME)
 200     .Add("loopCount", 3)
 201     .Add("playRange", playRange)
 202     .Add("stopBehavior", DevelImageVisual::StopBehavior::FIRST_FRAME)
 203     .Add("loopingMode", DevelImageVisual::LoopingMode::AUTO_REVERSE)
 204     .Add("redrawInScalingDown", false)
 205     .Add("cornerRadius", cornerRadius)
 206     .Add("borderlineWidth", borderlineWidth)
 207     .Add("borderlineColor", borderlineColor)
 208     .Add("borderlineOffset", borderlineOffset);
 209
 210   Visual::Base visual = VisualFactory::Get().CreateVisual(propertyMap);
 211   DALI_TEST_CHECK(visual);
 212
 213   DummyControl      actor     = DummyControl::New(true);
 214   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
 215   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
 216   actor.SetProperty(Actor::Property::SIZE, Vector2(200.0f, 200.0f));
 217   application.GetScene().Add(actor);
 218
 219   application.SendNotification();
 220   application.Render();
 221
 222   // Trigger count is 2 - load & render a frame
 223   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
 224
 225   // renderer is added to actor
 226   DALI_TEST_CHECK(actor.GetRendererCount() == 1u);
 227
 228   Renderer renderer = actor.GetRendererAt(0u);
 229   DALI_TEST_CHECK(renderer);
 230
 231   Property::Map resultMap;
 232   visual.CreatePropertyMap(resultMap);
 233
 234   // check the property values from the returned map from a visual
 235   Property::Value* value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
 236   DALI_TEST_CHECK(value);
 237   DALI_TEST_CHECK(value->Get<std::string>() == TEST_VECTOR_IMAGE_FILE_NAME);
 238
 239   value = resultMap.Find(DevelImageVisual::Property::LOOP_COUNT, Property::INTEGER);
 240   DALI_TEST_CHECK(value);
 241   DALI_TEST_CHECK(value->Get<int>() == 3);
 242
 243   value = resultMap.Find(DevelImageVisual::Property::PLAY_RANGE, Property::ARRAY);
 244   DALI_TEST_CHECK(value);
 245
 246   Property::Array* result = value->GetArray();
 247   DALI_TEST_CHECK(result);
 248
 249   DALI_TEST_CHECK(result->GetElementAt(0).Get<int>() == startFrame);
 250   DALI_TEST_CHECK(result->GetElementAt(1).Get<int>() == endFrame);
 251
 252   value = resultMap.Find(DevelImageVisual::Property::STOP_BEHAVIOR, Property::INTEGER);
 253   DALI_TEST_CHECK(value);
 254   DALI_TEST_CHECK(value->Get<int>() == DevelImageVisual::StopBehavior::FIRST_FRAME);
 255
 256   value = resultMap.Find(DevelImageVisual::Property::LOOPING_MODE, Property::INTEGER);
 257   DALI_TEST_CHECK(value);
 258   DALI_TEST_CHECK(value->Get<int>() == DevelImageVisual::LoopingMode::AUTO_REVERSE);
 259
 260   value = resultMap.Find(DevelImageVisual::Property::REDRAW_IN_SCALING_DOWN, Property::BOOLEAN);
 261   DALI_TEST_CHECK(value);
 262   DALI_TEST_CHECK(value->Get<bool>() == false);
 263
 264   value = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
 265   DALI_TEST_CHECK(value);
 266   DALI_TEST_EQUALS(value->Get<Vector4>(), Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius), TEST_LOCATION);
 267
 268   value = resultMap.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, "cornerRadiusPolicy");
 269   DALI_TEST_CHECK(value);
 270   DALI_TEST_CHECK(value->Get<int>() == Visual::Transform::Policy::ABSOLUTE);
 271
 272   value = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
 273   DALI_TEST_CHECK(value);
 274   DALI_TEST_EQUALS(value->Get<float>(), borderlineWidth, TEST_LOCATION);
 275
 276   value = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
 277   DALI_TEST_CHECK(value);
 278   DALI_TEST_EQUALS(value->Get<Vector4>(), borderlineColor, TEST_LOCATION);
 279
 280   value = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
 281   DALI_TEST_CHECK(value);
 282   DALI_TEST_EQUALS(value->Get<float>(), borderlineOffset, TEST_LOCATION);
 283
 284   actor.Unparent();
 285   DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
 286
 287   END_TEST;
 288 }
 289
 290 int UtcDaliAnimatedVectorImageVisualGetPropertyMap01(void)
 291 {
 292   ToolkitTestApplication application;
 293   tet_infoline("UtcDaliAnimatedVectorImageVisualGetPropertyMap01");
 294
 295   int             startFrame = 1, endFrame = 3;
 296   Vector4         cornerRadius(50.0f, 22.0f, 0.0f, 3.0f);
 297   float           borderlineWidth  = 2.3f;
 298   Vector4         borderlineColor  = Vector4(0.3f, 0.3f, 1.0f, 1.0f);
 299   float           borderlineOffset = 0.3f;
 300   Property::Array playRange;
 301   playRange.PushBack(startFrame);
 302   playRange.PushBack(endFrame);
 303
 304   Property::Map propertyMap;
 305   propertyMap.Add(Toolkit::Visual::Property::TYPE, DevelVisual::ANIMATED_VECTOR_IMAGE)
 306     .Add(ImageVisual::Property::URL, TEST_VECTOR_IMAGE_FILE_NAME)
 307     .Add(DevelImageVisual::Property::LOOP_COUNT, 3)
 308     .Add(DevelImageVisual::Property::PLAY_RANGE, playRange)
 309     .Add(DevelVisual::Property::CORNER_RADIUS, cornerRadius)
 310     .Add(DevelVisual::Property::CORNER_RADIUS_POLICY, Visual::Transform::Policy::RELATIVE)
 311     .Add(DevelVisual::Property::BORDERLINE_WIDTH, borderlineWidth)
 312     .Add(DevelVisual::Property::BORDERLINE_COLOR, borderlineColor)
 313     .Add(DevelVisual::Property::BORDERLINE_OFFSET, borderlineOffset);
 314
 315   // request AnimatedVectorImageVisual with a property map
 316   VisualFactory factory = VisualFactory::Get();
 317   Visual::Base  visual  = factory.CreateVisual(propertyMap);
 318
 319   DummyControl      actor     = DummyControl::New(true);
 320   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
 321   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
 322
 323   Vector2 controlSize(20.f, 30.f);
 324   actor.SetProperty(Actor::Property::SIZE, controlSize);
 325
 326   application.GetScene().Add(actor);
 327
 328   application.SendNotification();
 329   application.Render();
 330
 331   // Trigger count is 2 - load & render a frame
 332   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
 333
 334   Property::Map resultMap;
 335   resultMap = actor.GetProperty<Property::Map>(DummyControl::Property::TEST_VISUAL);
 336
 337   // check the property values from the returned map from a visual
 338   Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
 339   DALI_TEST_CHECK(value);
 340   DALI_TEST_CHECK(value->Get<int>() == DevelVisual::ANIMATED_VECTOR_IMAGE);
 341
 342   value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
 343   DALI_TEST_CHECK(value);
 344   DALI_TEST_CHECK(value->Get<std::string>() == TEST_VECTOR_IMAGE_FILE_NAME);
 345
 346   value = resultMap.Find(DevelImageVisual::Property::LOOP_COUNT, Property::INTEGER);
 347   DALI_TEST_CHECK(value);
 348   DALI_TEST_CHECK(value->Get<int>() == 3);
 349
 350   value = resultMap.Find(DevelImageVisual::Property::PLAY_RANGE, Property::ARRAY);
 351   DALI_TEST_CHECK(value);
 352
 353   Property::Array* result = value->GetArray();
 354   DALI_TEST_CHECK(result);
 355
 356   DALI_TEST_CHECK(result->GetElementAt(0).Get<int>() == startFrame);
 357   DALI_TEST_CHECK(result->GetElementAt(1).Get<int>() == endFrame);
 358
 359   value = resultMap.Find(DevelImageVisual::Property::STOP_BEHAVIOR, Property::INTEGER);
 360   DALI_TEST_CHECK(value);
 361   DALI_TEST_CHECK(value->Get<int>() == DevelImageVisual::StopBehavior::CURRENT_FRAME);
 362
 363   value = resultMap.Find(DevelImageVisual::Property::LOOPING_MODE, Property::INTEGER);
 364   DALI_TEST_CHECK(value);
 365   DALI_TEST_CHECK(value->Get<int>() == DevelImageVisual::LoopingMode::RESTART);
 366
 367   value = resultMap.Find(DevelImageVisual::Property::CONTENT_INFO, Property::MAP);
 368   DALI_TEST_CHECK(value);
 369
 370   value = resultMap.Find(DevelImageVisual::Property::REDRAW_IN_SCALING_DOWN, Property::BOOLEAN);
 371   DALI_TEST_CHECK(value);
 372   DALI_TEST_CHECK(value->Get<bool>() == true); // Check default value
 373
 374   value = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
 375   DALI_TEST_CHECK(value);
 376   DALI_TEST_EQUALS(value->Get<Vector4>(), cornerRadius, TEST_LOCATION);
 377
 378   value = resultMap.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, "cornerRadiusPolicy");
 379   DALI_TEST_CHECK(value);
 380   DALI_TEST_CHECK(value->Get<int>() == Visual::Transform::Policy::RELATIVE);
 381
 382   value = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, "borderlineWidth");
 383   DALI_TEST_CHECK(value);
 384   DALI_TEST_EQUALS(value->Get<float>(), borderlineWidth, TEST_LOCATION);
 385
 386   value = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
 387   DALI_TEST_CHECK(value);
 388   DALI_TEST_EQUALS(value->Get<Vector4>(), borderlineColor, TEST_LOCATION);
 389
 390   value = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
 391   DALI_TEST_CHECK(value);
 392   DALI_TEST_EQUALS(value->Get<float>(), borderlineOffset, TEST_LOCATION);
 393
 394   // request AnimatedVectorImageVisual with an URL
 395   Visual::Base visual2 = factory.CreateVisual(TEST_VECTOR_IMAGE_FILE_NAME, ImageDimensions());
 396
 397   resultMap.Clear();
 398   visual2.CreatePropertyMap(resultMap);
 399
 400   // check the property values from the returned map from a visual
 401   value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
 402   DALI_TEST_CHECK(value);
 403   DALI_TEST_CHECK(value->Get<int>() == DevelVisual::ANIMATED_VECTOR_IMAGE);
 404
 405   value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
 406   DALI_TEST_CHECK(value);
 407   DALI_TEST_CHECK(value->Get<std::string>() == TEST_VECTOR_IMAGE_FILE_NAME);
 408
 409   END_TEST;
 410 }
 411
 412 int UtcDaliAnimatedVectorImageVisualPlayback(void)
 413 {
 414   ToolkitTestApplication application;
 415
 416   tet_infoline("UtcDaliAnimatedVectorImageVisualPlayback");
 417
 418   {
 419     // request AnimatedVectorImageVisual with a property map
 420     VisualFactory factory = VisualFactory::Get();
 421     Visual::Base  visual  = factory.CreateVisual(
 422       Property::Map()
 423         .Add(Toolkit::Visual::Property::TYPE, DevelVisual::ANIMATED_VECTOR_IMAGE)
 424         .Add(ImageVisual::Property::URL, TEST_VECTOR_IMAGE_FILE_NAME));
 425
 426     DummyControl        dummyControl = DummyControl::New(true);
 427     Impl::DummyControl& dummyImpl    = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
 428     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
 429     dummyControl.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
 430
 431     Property::Map attributes;
 432     tet_infoline("Test Play action");
 433     DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelAnimatedVectorImageVisual::Action::PLAY, attributes);
 434
 435     application.GetScene().Add(dummyControl);
 436     application.SendNotification();
 437     application.Render(16);
 438
 439     Property::Map    map   = dummyControl.GetProperty<Property::Map>(DummyControl::Property::TEST_VISUAL);
 440     Property::Value* value = map.Find(DevelImageVisual::Property::PLAY_STATE);
 441     DALI_TEST_CHECK(value->Get<int>() == DevelImageVisual::PlayState::PLAYING);
 442
 443     tet_infoline("Test Pause action");
 444     DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelAnimatedVectorImageVisual::Action::PAUSE, attributes);
 445
 446     application.SendNotification();
 447     application.Render(16);
 448
 449     map   = dummyControl.GetProperty<Property::Map>(DummyControl::Property::TEST_VISUAL);
 450     value = map.Find(DevelImageVisual::Property::PLAY_STATE);
 451     DALI_TEST_CHECK(value->Get<int>() == DevelImageVisual::PlayState::PAUSED);
 452
 453     tet_infoline("Test Play action");
 454     DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelAnimatedVectorImageVisual::Action::PLAY, attributes);
 455
 456     application.SendNotification();
 457     application.Render(16);
 458
 459     map   = dummyControl.GetProperty<Property::Map>(DummyControl::Property::TEST_VISUAL);
 460     value = map.Find(DevelImageVisual::Property::PLAY_STATE);
 461     DALI_TEST_CHECK(value->Get<int>() == DevelImageVisual::PlayState::PLAYING);
 462
 463     tet_infoline("Test Stop action");
 464     DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelAnimatedVectorImageVisual::Action::STOP, attributes);
 465
 466     application.SendNotification();
 467     application.Render(16);
 468
 469     map   = dummyControl.GetProperty<Property::Map>(DummyControl::Property::TEST_VISUAL);
 470     value = map.Find(DevelImageVisual::Property::PLAY_STATE);
 471     DALI_TEST_CHECK(value->Get<int>() == DevelImageVisual::PlayState::STOPPED);
 472
 473     tet_infoline("Test Stop action again");
 474     DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelAnimatedVectorImageVisual::Action::STOP, attributes);
 475
 476     application.SendNotification();
 477     application.Render(16);
 478
 479     map   = dummyControl.GetProperty<Property::Map>(DummyControl::Property::TEST_VISUAL);
 480     value = map.Find(DevelImageVisual::Property::PLAY_STATE);
 481     DALI_TEST_CHECK(value->Get<int>() == DevelImageVisual::PlayState::STOPPED);
 482
 483     tet_infoline("Test Play action");
 484     DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelAnimatedVectorImageVisual::Action::PLAY, attributes);
 485
 486     application.SendNotification();
 487     application.Render(16);
 488
 489     map   = dummyControl.GetProperty<Property::Map>(DummyControl::Property::TEST_VISUAL);
 490     value = map.Find(DevelImageVisual::Property::PLAY_STATE);
 491     DALI_TEST_CHECK(value->Get<int>() == DevelImageVisual::PlayState::PLAYING);
 492
 493     tet_infoline("Off stage");
 494     dummyControl.Unparent();
 495
 496     application.SendNotification();
 497     application.Render(16);
 498
 499     map   = dummyControl.GetProperty<Property::Map>(DummyControl::Property::TEST_VISUAL);
 500     value = map.Find(DevelImageVisual::Property::PLAY_STATE);
 501     DALI_TEST_CHECK(value->Get<int>() == DevelImageVisual::PlayState::STOPPED);
 502
 503     tet_infoline("On stage again");
 504     application.GetScene().Add(dummyControl);
 505
 506     application.SendNotification();
 507     application.Render(16);
 508
 509     map   = dummyControl.GetProperty<Property::Map>(DummyControl::Property::TEST_VISUAL);
 510     value = map.Find(DevelImageVisual::Property::PLAY_STATE);
 511     DALI_TEST_CHECK(value->Get<int>() == DevelImageVisual::PlayState::STOPPED);
 512
 513     tet_infoline("Test Play action");
 514     DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelAnimatedVectorImageVisual::Action::PLAY, attributes);
 515
 516     application.SendNotification();
 517     application.Render(16);
 518
 519     map   = dummyControl.GetProperty<Property::Map>(DummyControl::Property::TEST_VISUAL);
 520     value = map.Find(DevelImageVisual::Property::PLAY_STATE);
 521     DALI_TEST_CHECK(value->Get<int>() == DevelImageVisual::PlayState::PLAYING);
 522
 523     // Change Size
 524     Vector3 newSize(100.0f, 100.0f, 0.0f);
 525     dummyControl.SetProperty(Actor::Property::SIZE, newSize);
 526
 527     application.SendNotification();
 528     application.Render(16);
 529
 530     // Size should be changed
 531     Vector3 naturalSize = dummyControl.GetNaturalSize();
 532     DALI_TEST_CHECK(naturalSize == newSize);
 533
 534     dummyControl.Unparent();
 535   }
 536
 537   END_TEST;
 538 }
 539
 540 int UtcDaliAnimatedVectorImageVisualCustomShader(void)
 541 {
 542   ToolkitTestApplication application;
 543   tet_infoline("UtcDaliAnimatedVectorImageVisualCustomShader Test custom shader");
 544
 545   VisualFactory     factory = VisualFactory::Get();
 546   Property::Map     properties;
 547   Property::Map     shader;
 548   const std::string vertexShader                    = "Foobar";
 549   const std::string fragmentShader                  = "Foobar sampler2D Foobar";
 550   shader[Visual::Shader::Property::FRAGMENT_SHADER] = fragmentShader;
 551   shader[Visual::Shader::Property::VERTEX_SHADER]   = vertexShader;
 552
 553   properties[Visual::Property::TYPE]     = Visual::IMAGE;
 554   properties[Visual::Property::SHADER]   = shader;
 555   properties[ImageVisual::Property::URL] = TEST_VECTOR_IMAGE_FILE_NAME;
 556
 557   Visual::Base visual = factory.CreateVisual(properties);
 558
 559   // trigger creation through setting on stage
 560   DummyControl        dummy     = DummyControl::New(true);
 561   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
 562   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
 563
 564   dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
 565   dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
 566   application.GetScene().Add(dummy);
 567
 568   application.SendNotification();
 569   application.Render();
 570
 571   // Trigger count is 2 - load & render a frame
 572   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
 573
 574   Renderer        renderer = dummy.GetRendererAt(0);
 575   Shader          shader2  = renderer.GetShader();
 576   Property::Value value    = shader2.GetProperty(Shader::Property::PROGRAM);
 577   Property::Map*  map      = value.GetMap();
 578   DALI_TEST_CHECK(map);
 579
 580   std::string      resultFragmentShader, resultVertexShader;
 581   Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
 582   fragment->Get(resultFragmentShader);
 583   DALI_TEST_CHECK(resultFragmentShader.find(fragmentShader) != std::string::npos);
 584
 585   Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
 586   vertex->Get(resultVertexShader);
 587   DALI_TEST_CHECK(resultVertexShader.find(vertexShader) != std::string::npos);
 588
 589   END_TEST;
 590 }
 591
 592 int UtcDaliAnimatedVectorImageVisualNaturalSize(void)
 593 {
 594   ToolkitTestApplication application;
 595   tet_infoline("UtcDaliAnimatedVectorImageVisualNaturalSize");
 596
 597   VisualFactory factory = VisualFactory::Get();
 598   Visual::Base  visual  = factory.CreateVisual(TEST_VECTOR_IMAGE_FILE_NAME, ImageDimensions());
 599   DALI_TEST_CHECK(visual);
 600
 601   DummyControl      actor     = DummyControl::New(true);
 602   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
 603   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
 604
 605   Vector2 controlSize(20.f, 30.f);
 606   Vector2 naturalSize;
 607
 608   application.GetScene().Add(actor);
 609
 610   application.SendNotification();
 611   application.Render();
 612
 613   visual.GetNaturalSize(naturalSize);
 614
 615   DALI_TEST_EQUALS(naturalSize, Vector2(100.0f, 100.0f), TEST_LOCATION); // 100x100 is the content default size.
 616
 617   actor.SetProperty(Actor::Property::SIZE, controlSize);
 618
 619   application.SendNotification();
 620   application.Render();
 621
 622   visual.GetNaturalSize(naturalSize);
 623
 624   DALI_TEST_EQUALS(naturalSize, controlSize, TEST_LOCATION);
 625
 626   END_TEST;
 627 }
 628
 629 int UtcDaliAnimatedVectorImageVisualLoopCount(void)
 630 {
 631   ToolkitTestApplication application;
 632   tet_infoline("UtcDaliAnimatedVectorImageVisualLoopCount");
 633
 634   Property::Map propertyMap;
 635   propertyMap.Add(Toolkit::Visual::Property::TYPE, DevelVisual::ANIMATED_VECTOR_IMAGE)
 636     .Add(ImageVisual::Property::URL, TEST_VECTOR_IMAGE_FILE_NAME)
 637     .Add(DevelImageVisual::Property::LOOP_COUNT, 3);
 638
 639   Visual::Base visual = VisualFactory::Get().CreateVisual(propertyMap);
 640   DALI_TEST_CHECK(visual);
 641
 642   DummyControl      actor     = DummyControl::New(true);
 643   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
 644   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
 645
 646   Vector2 controlSize(20.f, 30.f);
 647   actor.SetProperty(Actor::Property::SIZE, controlSize);
 648
 649   application.GetScene().Add(actor);
 650
 651   Property::Map attributes;
 652   DevelControl::DoAction(actor, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelAnimatedVectorImageVisual::Action::PLAY, attributes);
 653
 654   application.SendNotification();
 655   application.Render();
 656
 657   // Trigger count is 2 - load & render a frame
 658   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
 659
 660   // renderer is added to actor
 661   DALI_TEST_CHECK(actor.GetRendererCount() == 1u);
 662   Renderer renderer = actor.GetRendererAt(0u);
 663   DALI_TEST_CHECK(renderer);
 664
 665   END_TEST;
 666 }
 667
 668 int UtcDaliAnimatedVectorImageVisualPlayRange(void)
 669 {
 670   ToolkitTestApplication application;
 671   tet_infoline("UtcDaliAnimatedVectorImageVisualPlayRange");
 672
 673   int             startFrame = 1, endFrame = 3;
 674   Property::Array array;
 675   array.PushBack(endFrame);
 676   array.PushBack(startFrame);
 677
 678   Property::Map propertyMap;
 679   propertyMap.Add(Toolkit::Visual::Property::TYPE, DevelVisual::ANIMATED_VECTOR_IMAGE)
 680     .Add(ImageVisual::Property::URL, TEST_VECTOR_IMAGE_FILE_NAME)
 681     .Add(DevelImageVisual::Property::PLAY_RANGE, array);
 682
 683   Visual::Base visual = VisualFactory::Get().CreateVisual(propertyMap);
 684   DALI_TEST_CHECK(visual);
 685
 686   DummyControl      actor     = DummyControl::New(true);
 687   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
 688   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
 689
 690   Vector2 controlSize(20.f, 30.f);
 691   actor.SetProperty(Actor::Property::SIZE, controlSize);
 692
 693   application.GetScene().Add(actor);
 694
 695   Property::Map attributes;
 696   DevelControl::DoAction(actor, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelAnimatedVectorImageVisual::Action::PLAY, attributes);
 697
 698   application.SendNotification();
 699   application.Render();
 700
 701   // Trigger count is 2 - load & render a frame
 702   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
 703
 704   // renderer is added to actor
 705   DALI_TEST_CHECK(actor.GetRendererCount() == 1u);
 706   Renderer renderer = actor.GetRendererAt(0u);
 707   DALI_TEST_CHECK(renderer);
 708
 709   Property::Map    map   = actor.GetProperty<Property::Map>(DummyControl::Property::TEST_VISUAL);
 710   Property::Value* value = map.Find(DevelImageVisual::Property::PLAY_RANGE);
 711
 712   int              resultStartFrame, resultEndFrame;
 713   Property::Array* result = value->GetArray();
 714   result->GetElementAt(0).Get(resultStartFrame);
 715   result->GetElementAt(1).Get(resultEndFrame);
 716
 717   DALI_TEST_EQUALS(startFrame, resultStartFrame, TEST_LOCATION);
 718   DALI_TEST_EQUALS(endFrame, resultEndFrame, TEST_LOCATION);
 719
 720   // Set invalid play range
 721   array.Clear();
 722   array.PushBack(1);
 723   array.PushBack(100);
 724
 725   attributes.Clear();
 726   attributes.Add(DevelImageVisual::Property::PLAY_RANGE, array);
 727   DevelControl::DoAction(actor, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelVisual::Action::UPDATE_PROPERTY, attributes);
 728
 729   // To make event trigger
 730   actor.SetProperty(Actor::Property::SIZE, Vector2(10.0f, 10.0f));
 731
 732   application.SendNotification();
 733   application.Render();
 734
 735   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
 736
 737   map   = actor.GetProperty<Property::Map>(DummyControl::Property::TEST_VISUAL);
 738   value = map.Find(DevelImageVisual::Property::PLAY_RANGE);
 739
 740   result = value->GetArray();
 741   result->GetElementAt(0).Get(resultStartFrame);
 742   result->GetElementAt(1).Get(resultEndFrame);
 743
 744   DALI_TEST_EQUALS(startFrame, resultStartFrame, TEST_LOCATION); // Should not be changed
 745   DALI_TEST_EQUALS(endFrame, resultEndFrame, TEST_LOCATION);
 746
 747   DevelControl::DoAction(actor, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelAnimatedVectorImageVisual::Action::PAUSE, Property::Map());
 748
 749   application.SendNotification();
 750   application.Render();
 751
 752   DevelControl::DoAction(actor, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelAnimatedVectorImageVisual::Action::JUMP_TO, 3);
 753
 754   // To make event trigger
 755   actor.SetProperty(Actor::Property::SIZE, Vector2(20.0f, 20.0f));
 756
 757   application.SendNotification();
 758   application.Render();
 759
 760   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
 761
 762   map   = actor.GetProperty<Property::Map>(DummyControl::Property::TEST_VISUAL);
 763   value = map.Find(DevelImageVisual::Property::CURRENT_FRAME_NUMBER);
 764   DALI_TEST_EQUALS(value->Get<int>(), 3, TEST_LOCATION);
 765
 766   array.Clear();
 767   array.PushBack(0);
 768   array.PushBack(2);
 769
 770   attributes.Clear();
 771   attributes.Add(DevelImageVisual::Property::PLAY_RANGE, array);
 772   DevelControl::DoAction(actor, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelVisual::Action::UPDATE_PROPERTY, attributes);
 773
 774   // To make event trigger
 775   actor.SetProperty(Actor::Property::SIZE, Vector2(10.0f, 10.0f));
 776
 777   application.SendNotification();
 778   application.Render();
 779
 780   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
 781
 782   map   = actor.GetProperty<Property::Map>(DummyControl::Property::TEST_VISUAL);
 783   value = map.Find(DevelImageVisual::Property::PLAY_RANGE);
 784
 785   result = value->GetArray();
 786   result->GetElementAt(0).Get(resultStartFrame);
 787   result->GetElementAt(1).Get(resultEndFrame);
 788
 789   DALI_TEST_EQUALS(0, resultStartFrame, TEST_LOCATION);
 790   DALI_TEST_EQUALS(2, resultEndFrame, TEST_LOCATION);
 791
 792   value = map.Find(DevelImageVisual::Property::CURRENT_FRAME_NUMBER);
 793   DALI_TEST_EQUALS(value->Get<int>(), 2, TEST_LOCATION); // CURRENT_FRAME_NUMBER should be changed also.
 794
 795   END_TEST;
 796 }
 797
 798 int UtcDaliAnimatedVectorImageVisualPlayRangeMarker(void)
 799 {
 800   ToolkitTestApplication application;
 801   tet_infoline("UtcDaliAnimatedVectorImageVisualPlayRangeMarker");
 802
 803   Property::Array array;
 804   array.PushBack(VECTOR_ANIMATION_MARKER_NAME_1);
 805
 806   Property::Map propertyMap;
 807   propertyMap.Add(Toolkit::Visual::Property::TYPE, DevelVisual::ANIMATED_VECTOR_IMAGE)
 808     .Add(ImageVisual::Property::URL, TEST_VECTOR_IMAGE_FILE_NAME)
 809     .Add(DevelImageVisual::Property::PLAY_RANGE, array);
 810
 811   Visual::Base visual = VisualFactory::Get().CreateVisual(propertyMap);
 812   DALI_TEST_CHECK(visual);
 813
 814   DummyControl      actor     = DummyControl::New(true);
 815   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
 816   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
 817
 818   Vector2 controlSize(20.f, 30.f);
 819   actor.SetProperty(Actor::Property::SIZE, controlSize);
 820
 821   application.GetScene().Add(actor);
 822
 823   Property::Map attributes;
 824   DevelControl::DoAction(actor, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelAnimatedVectorImageVisual::Action::PLAY, attributes);
 825
 826   application.SendNotification();
 827   application.Render();
 828
 829   // Trigger count is 2 - load & render a frame
 830   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
 831
 832   // renderer is added to actor
 833   DALI_TEST_CHECK(actor.GetRendererCount() == 1u);
 834   Renderer renderer = actor.GetRendererAt(0u);
 835   DALI_TEST_CHECK(renderer);
 836
 837   Property::Map    map   = actor.GetProperty<Property::Map>(DummyControl::Property::TEST_VISUAL);
 838   Property::Value* value = map.Find(DevelImageVisual::Property::PLAY_RANGE);
 839
 840   int              resultStartFrame, resultEndFrame;
 841   Property::Array* result = value->GetArray();
 842   result->GetElementAt(0).Get(resultStartFrame);
 843   result->GetElementAt(1).Get(resultEndFrame);
 844
 845   DALI_TEST_EQUALS(VECTOR_ANIMATION_MARKER_START_FRAME_1, resultStartFrame, TEST_LOCATION);
 846   DALI_TEST_EQUALS(VECTOR_ANIMATION_MARKER_END_FRAME_1, resultEndFrame, TEST_LOCATION);
 847
 848   // Set 2 markers
 849   array.Clear();
 850   array.PushBack(VECTOR_ANIMATION_MARKER_NAME_1);
 851   array.PushBack(VECTOR_ANIMATION_MARKER_NAME_2);
 852
 853   attributes.Clear();
 854   attributes.Add(DevelImageVisual::Property::PLAY_RANGE, array);
 855   DevelControl::DoAction(actor, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelVisual::Action::UPDATE_PROPERTY, attributes);
 856
 857   // To make event trigger
 858   actor.SetProperty(Actor::Property::SIZE, Vector2(10.0f, 10.0f));
 859
 860   application.SendNotification();
 861   application.Render();
 862
 863   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
 864
 865   map   = actor.GetProperty<Property::Map>(DummyControl::Property::TEST_VISUAL);
 866   value = map.Find(DevelImageVisual::Property::PLAY_RANGE);
 867
 868   result = value->GetArray();
 869   result->GetElementAt(0).Get(resultStartFrame);
 870   result->GetElementAt(1).Get(resultEndFrame);
 871
 872   DALI_TEST_EQUALS(VECTOR_ANIMATION_MARKER_START_FRAME_1, resultStartFrame, TEST_LOCATION);
 873   DALI_TEST_EQUALS(VECTOR_ANIMATION_MARKER_END_FRAME_2, resultEndFrame, TEST_LOCATION);
 874
 875   // Set invalid play range
 876   array.Clear();
 877   array.PushBack(1);
 878   array.PushBack(VECTOR_ANIMATION_MARKER_NAME_1);
 879
 880   attributes.Clear();
 881   attributes.Add(DevelImageVisual::Property::PLAY_RANGE, array);
 882   DevelControl::DoAction(actor, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelVisual::Action::UPDATE_PROPERTY, attributes);
 883
 884   // To make event trigger
 885   actor.SetProperty(Actor::Property::SIZE, Vector2(20.0f, 20.0f));
 886
 887   application.SendNotification();
 888   application.Render();
 889
 890   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
 891
 892   map   = actor.GetProperty<Property::Map>(DummyControl::Property::TEST_VISUAL);
 893   value = map.Find(DevelImageVisual::Property::PLAY_RANGE);
 894
 895   result = value->GetArray();
 896   result->GetElementAt(0).Get(resultStartFrame);
 897   result->GetElementAt(1).Get(resultEndFrame);
 898
 899   DALI_TEST_EQUALS(VECTOR_ANIMATION_MARKER_START_FRAME_1, resultStartFrame, TEST_LOCATION); // Should not be changed
 900   DALI_TEST_EQUALS(VECTOR_ANIMATION_MARKER_END_FRAME_2, resultEndFrame, TEST_LOCATION);
 901
 902   END_TEST;
 903 }
 904
 905 int UtcDaliAnimatedVectorImageVisualAnimationFinishedSignal(void)
 906 {
 907   ToolkitTestApplication application;
 908   tet_infoline("UtcDaliAnimatedVectorImageVisualAnimationFinishedSignal");
 909
 910   Property::Map propertyMap;
 911   propertyMap.Add(Toolkit::Visual::Property::TYPE, DevelVisual::ANIMATED_VECTOR_IMAGE)
 912     .Add(ImageVisual::Property::URL, TEST_VECTOR_IMAGE_FILE_NAME)
 913     .Add(DevelImageVisual::Property::LOOP_COUNT, 3);
 914
 915   Visual::Base visual = VisualFactory::Get().CreateVisual(propertyMap);
 916   DALI_TEST_CHECK(visual);
 917
 918   DummyControl      actor     = DummyControl::New(true);
 919   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
 920   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
 921
 922   DevelControl::VisualEventSignal(actor).Connect(&VisualEventSignal);
 923
 924   Vector2 controlSize(20.f, 30.f);
 925   actor.SetProperty(Actor::Property::SIZE, controlSize);
 926
 927   application.GetScene().Add(actor);
 928
 929   Property::Map attributes;
 930   DevelControl::DoAction(actor, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelAnimatedVectorImageVisual::Action::PLAY, attributes);
 931
 932   application.SendNotification();
 933   application.Render();
 934
 935   // Wait for animation finish - load, render, finish
 936   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(3), true, TEST_LOCATION);
 937
 938   Property::Map    map   = actor.GetProperty<Property::Map>(DummyControl::Property::TEST_VISUAL);
 939   Property::Value* value = map.Find(DevelImageVisual::Property::PLAY_STATE);
 940   DALI_TEST_CHECK(value->Get<int>() == DevelImageVisual::PlayState::STOPPED);
 941
 942   DALI_TEST_EQUALS(gAnimationFinishedSignalFired, true, TEST_LOCATION);
 943
 944   END_TEST;
 945 }
 946
 947 int UtcDaliAnimatedVectorImageVisualJumpTo(void)
 948 {
 949   ToolkitTestApplication application;
 950   tet_infoline("UtcDaliAnimatedVectorImageVisualJumpTo");
 951
 952   Property::Map propertyMap;
 953   propertyMap.Add(Toolkit::Visual::Property::TYPE, DevelVisual::ANIMATED_VECTOR_IMAGE)
 954     .Add(ImageVisual::Property::URL, TEST_VECTOR_IMAGE_FILE_NAME)
 955     .Add(DevelImageVisual::Property::LOOP_COUNT, 3);
 956
 957   Visual::Base visual = VisualFactory::Get().CreateVisual(propertyMap);
 958   DALI_TEST_CHECK(visual);
 959
 960   tet_printf("1. Visual is created.\n");
 961
 962   DummyControl      actor     = DummyControl::New(true);
 963   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
 964   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
 965
 966   Vector2 controlSize(20.f, 30.f);
 967   actor.SetProperty(Actor::Property::SIZE, controlSize);
 968
 969   application.GetScene().Add(actor);
 970
 971   application.SendNotification();
 972   application.Render();
 973
 974   // Trigger count is 2 - load & render a frame
 975   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
 976
 977   DevelControl::DoAction(actor, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelAnimatedVectorImageVisual::Action::JUMP_TO, 2);
 978
 979   // To make event trigger
 980   actor.SetProperty(Actor::Property::SIZE, Vector2(10.0f, 10.0f));
 981
 982   application.SendNotification();
 983   application.Render();
 984
 985   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
 986
 987   Property::Map    map   = actor.GetProperty<Property::Map>(DummyControl::Property::TEST_VISUAL);
 988   Property::Value* value = map.Find(DevelImageVisual::Property::CURRENT_FRAME_NUMBER);
 989   DALI_TEST_EQUALS(value->Get<int>(), 2, TEST_LOCATION);
 990
 991   tet_printf("2. The current frame number is [%d].\n", value->Get<int>());
 992
 993   Property::Array array;
 994   array.PushBack(0);
 995   array.PushBack(2);
 996
 997   Property::Map attributes;
 998   attributes.Add(DevelImageVisual::Property::PLAY_RANGE, array);
 999   DevelControl::DoAction(actor, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelVisual::Action::UPDATE_PROPERTY, attributes);
1000
1001   DevelControl::DoAction(actor, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelAnimatedVectorImageVisual::Action::JUMP_TO, 3);
1002
1003   // To make event trigger
1004   actor.SetProperty(Actor::Property::SIZE, Vector2(20.0f, 20.0f));
1005
1006   application.SendNotification();
1007   application.Render();
1008
1009   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
1010
1011   map   = actor.GetProperty<Property::Map>(DummyControl::Property::TEST_VISUAL);
1012   value = map.Find(DevelImageVisual::Property::CURRENT_FRAME_NUMBER);
1013   DALI_TEST_EQUALS(value->Get<int>(), 2, TEST_LOCATION);
1014
1015   tet_printf("3. The current frame number is [%d].\n", value->Get<int>());
1016
1017   // Change play range
1018   attributes.Clear();
1019   array.Clear();
1020
1021   array.PushBack(0);
1022   array.PushBack(4);
1023
1024   attributes.Add(DevelImageVisual::Property::PLAY_RANGE, array);
1025   DevelControl::DoAction(actor, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelVisual::Action::UPDATE_PROPERTY, attributes);
1026
1027   attributes.Clear();
1028   DevelControl::DoAction(actor, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelAnimatedVectorImageVisual::Action::PLAY, attributes);
1029
1030   application.SendNotification();
1031   application.Render();
1032
1033   // Wait for animation finish
1034   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
1035
1036   // Jump to 3
1037   DevelControl::DoAction(actor, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelAnimatedVectorImageVisual::Action::JUMP_TO, 3);
1038
1039   // To make event trigger
1040   actor.SetProperty(Actor::Property::SIZE, Vector2(10.0f, 10.0f));
1041
1042   application.SendNotification();
1043   application.Render();
1044
1045   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
1046
1047   map   = actor.GetProperty<Property::Map>(DummyControl::Property::TEST_VISUAL);
1048   value = map.Find(DevelImageVisual::Property::CURRENT_FRAME_NUMBER);
1049   DALI_TEST_EQUALS(value->Get<int>(), 3, TEST_LOCATION);
1050
1051   tet_printf("4. The current frame number is [%d].\n", value->Get<int>());
1052
1053   // Jump to the same position
1054   DevelControl::DoAction(actor, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelAnimatedVectorImageVisual::Action::JUMP_TO, 3);
1055
1056   // To make event trigger
1057   actor.SetProperty(Actor::Property::SIZE, Vector2(20.0f, 20.0f));
1058
1059   application.SendNotification();
1060   application.Render();
1061
1062   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
1063
1064   map   = actor.GetProperty<Property::Map>(DummyControl::Property::TEST_VISUAL);
1065   value = map.Find(DevelImageVisual::Property::CURRENT_FRAME_NUMBER);
1066   DALI_TEST_EQUALS(value->Get<int>(), 3, TEST_LOCATION);
1067
1068   tet_printf("5. The current frame number is [%d].\n", value->Get<int>());
1069
1070   END_TEST;
1071 }
1072
1073 int UtcDaliAnimatedVectorImageVisualUpdateProperty(void)
1074 {
1075   ToolkitTestApplication application;
1076   tet_infoline("UtcDaliAnimatedVectorImageVisualUpdateProperty");
1077
1078   int             startFrame = 1, endFrame = 3;
1079   Property::Array playRange;
1080   playRange.PushBack(startFrame);
1081   playRange.PushBack(endFrame);
1082
1083   Property::Map propertyMap;
1084   propertyMap.Add(Toolkit::Visual::Property::TYPE, DevelVisual::ANIMATED_VECTOR_IMAGE)
1085     .Add(ImageVisual::Property::URL, TEST_VECTOR_IMAGE_FILE_NAME)
1086     .Add(DevelImageVisual::Property::LOOP_COUNT, 3)
1087     .Add(DevelImageVisual::Property::PLAY_RANGE, playRange);
1088
1089   Visual::Base visual = VisualFactory::Get().CreateVisual(propertyMap);
1090   DALI_TEST_CHECK(visual);
1091
1092   DummyControl      actor     = DummyControl::New(true);
1093   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
1094   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
1095
1096   Vector2 controlSize(20.f, 30.f);
1097   actor.SetProperty(Actor::Property::SIZE, controlSize);
1098
1099   application.GetScene().Add(actor);
1100
1101   application.SendNotification();
1102   application.Render();
1103
1104   // Trigger count is 2 - load & render a frame
1105   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
1106
1107   Property::Map    map   = actor.GetProperty<Property::Map>(DummyControl::Property::TEST_VISUAL);
1108   Property::Value* value = map.Find(DevelImageVisual::Property::LOOP_COUNT);
1109   DALI_TEST_EQUALS(value->Get<int>(), 3, TEST_LOCATION);
1110
1111   value = map.Find(DevelImageVisual::Property::PLAY_RANGE, Property::ARRAY);
1112   DALI_TEST_CHECK(value);
1113
1114   Property::Array* result = value->GetArray();
1115   DALI_TEST_CHECK(result);
1116
1117   DALI_TEST_CHECK(result->GetElementAt(0).Get<int>() == startFrame);
1118   DALI_TEST_CHECK(result->GetElementAt(1).Get<int>() == endFrame);
1119
1120   playRange.Clear();
1121   playRange.PushBack(0);
1122   playRange.PushBack(2);
1123
1124   Property::Map attributes;
1125   attributes.Add(DevelImageVisual::Property::PLAY_RANGE, playRange);
1126   attributes.Add(DevelImageVisual::Property::LOOP_COUNT, 5);
1127
1128   DevelControl::DoAction(actor, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelVisual::Action::UPDATE_PROPERTY, attributes);
1129
1130   // To make event trigger
1131   actor.SetProperty(Actor::Property::SIZE, Vector2(10.0f, 10.0f));
1132
1133   application.SendNotification();
1134   application.Render();
1135
1136   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
1137
1138   map   = actor.GetProperty<Property::Map>(DummyControl::Property::TEST_VISUAL);
1139   value = map.Find(DevelImageVisual::Property::LOOP_COUNT);
1140   DALI_TEST_EQUALS(value->Get<int>(), 5, TEST_LOCATION);
1141
1142   value  = map.Find(DevelImageVisual::Property::PLAY_RANGE);
1143   result = value->GetArray();
1144   DALI_TEST_CHECK(result);
1145
1146   DALI_TEST_CHECK(result->GetElementAt(0).Get<int>() == 0);
1147   DALI_TEST_CHECK(result->GetElementAt(1).Get<int>() == 2);
1148
1149   attributes.Clear();
1150
1151   playRange.Clear();
1152   playRange.PushBack(startFrame);
1153   playRange.PushBack(endFrame);
1154
1155   attributes.Add(DevelImageVisual::Property::PLAY_RANGE, playRange);
1156
1157   DevelControl::DoAction(actor, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelVisual::Action::UPDATE_PROPERTY, attributes);
1158
1159   // To make event trigger
1160   actor.SetProperty(Actor::Property::SIZE, Vector2(20.0f, 20.0f));
1161
1162   application.SendNotification();
1163   application.Render();
1164
1165   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
1166
1167   map   = actor.GetProperty<Property::Map>(DummyControl::Property::TEST_VISUAL);
1168   value = map.Find(DevelImageVisual::Property::PLAY_RANGE);
1169
1170   result = value->GetArray();
1171   DALI_TEST_CHECK(result);
1172
1173   DALI_TEST_CHECK(result->GetElementAt(0).Get<int>() == startFrame);
1174   DALI_TEST_CHECK(result->GetElementAt(1).Get<int>() == endFrame);
1175
1176   // Play and update property
1177   attributes.Clear();
1178   DevelControl::DoAction(actor, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelAnimatedVectorImageVisual::Action::PLAY, attributes);
1179
1180   application.SendNotification();
1181   application.Render();
1182
1183   attributes.Add(DevelImageVisual::Property::LOOP_COUNT, 10);
1184
1185   DevelControl::DoAction(actor, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelVisual::Action::UPDATE_PROPERTY, attributes);
1186
1187   application.SendNotification();
1188   application.Render();
1189
1190   map   = actor.GetProperty<Property::Map>(DummyControl::Property::TEST_VISUAL);
1191   value = map.Find(DevelImageVisual::Property::LOOP_COUNT);
1192   DALI_TEST_EQUALS(value->Get<int>(), 10, TEST_LOCATION);
1193
1194   END_TEST;
1195 }
1196
1197 int UtcDaliAnimatedVectorImageVisualStopBehavior(void)
1198 {
1199   ToolkitTestApplication application;
1200   tet_infoline("UtcDaliAnimatedVectorImageVisualStopBehavior");
1201
1202   Property::Map propertyMap;
1203   propertyMap.Add(Toolkit::Visual::Property::TYPE, DevelVisual::ANIMATED_VECTOR_IMAGE)
1204     .Add(ImageVisual::Property::URL, TEST_VECTOR_IMAGE_FILE_NAME)
1205     .Add(DevelImageVisual::Property::LOOP_COUNT, 3)
1206     .Add(DevelImageVisual::Property::STOP_BEHAVIOR, DevelImageVisual::StopBehavior::FIRST_FRAME);
1207
1208   Visual::Base visual = VisualFactory::Get().CreateVisual(propertyMap);
1209   DALI_TEST_CHECK(visual);
1210
1211   DummyControl      actor     = DummyControl::New(true);
1212   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
1213   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
1214
1215   Vector2 controlSize(20.f, 30.f);
1216   actor.SetProperty(Actor::Property::SIZE, controlSize);
1217
1218   application.GetScene().Add(actor);
1219
1220   Property::Map attributes;
1221   DevelControl::DoAction(actor, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelAnimatedVectorImageVisual::Action::PLAY, attributes);
1222
1223   application.SendNotification();
1224   application.Render();
1225
1226   // Trigger count is 3 - load, render, animation finished
1227   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(3), true, TEST_LOCATION);
1228
1229   Property::Map    map   = actor.GetProperty<Property::Map>(DummyControl::Property::TEST_VISUAL);
1230   Property::Value* value = map.Find(DevelImageVisual::Property::CURRENT_FRAME_NUMBER);
1231   DALI_TEST_EQUALS(value->Get<int>(), 0, TEST_LOCATION); // Should be the first frame
1232
1233   // Change stop behavior
1234   attributes.Add(DevelImageVisual::Property::STOP_BEHAVIOR, DevelImageVisual::StopBehavior::LAST_FRAME);
1235
1236   DevelControl::DoAction(actor, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelVisual::Action::UPDATE_PROPERTY, attributes);
1237
1238   attributes.Clear();
1239
1240   // Play again
1241   DevelControl::DoAction(actor, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelAnimatedVectorImageVisual::Action::PLAY, attributes);
1242
1243   application.SendNotification();
1244   application.Render();
1245
1246   // Trigger count is 1 - animation finished
1247   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
1248
1249   map = actor.GetProperty<Property::Map>(DummyControl::Property::TEST_VISUAL);
1250
1251   Property::Value* value1           = map.Find(DevelImageVisual::Property::TOTAL_FRAME_NUMBER);
1252   int              totalFrameNumber = value1->Get<int>();
1253
1254   value = map.Find(DevelImageVisual::Property::CURRENT_FRAME_NUMBER);
1255   DALI_TEST_EQUALS(value->Get<int>(), totalFrameNumber - 1, TEST_LOCATION); // Should be the last frame
1256
1257   // Change stop behavior
1258   attributes.Add(DevelImageVisual::Property::STOP_BEHAVIOR, DevelImageVisual::StopBehavior::CURRENT_FRAME);
1259   attributes.Add(DevelImageVisual::Property::LOOP_COUNT, -1);
1260
1261   DevelControl::DoAction(actor, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelVisual::Action::UPDATE_PROPERTY, attributes);
1262
1263   attributes.Clear();
1264
1265   // Play again
1266   DevelControl::DoAction(actor, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelAnimatedVectorImageVisual::Action::PLAY, attributes);
1267
1268   application.SendNotification();
1269   application.Render();
1270
1271   // Pause
1272   DevelControl::DoAction(actor, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelAnimatedVectorImageVisual::Action::PAUSE, attributes);
1273
1274   // To make event trigger
1275   actor.SetProperty(Actor::Property::SIZE, Vector2(10.0f, 10.0f));
1276
1277   application.SendNotification();
1278   application.Render();
1279
1280   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
1281
1282   map                    = actor.GetProperty<Property::Map>(DummyControl::Property::TEST_VISUAL);
1283   value                  = map.Find(DevelImageVisual::Property::CURRENT_FRAME_NUMBER);
1284   int currentFrameNumber = value->Get<int>();
1285
1286   // Stop
1287   DevelControl::DoAction(actor, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelAnimatedVectorImageVisual::Action::STOP, attributes);
1288
1289   // To make event trigger
1290   actor.SetProperty(Actor::Property::SIZE, Vector2(20.0f, 20.0f));
1291
1292   application.SendNotification();
1293   application.Render();
1294
1295   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
1296
1297   map   = actor.GetProperty<Property::Map>(DummyControl::Property::TEST_VISUAL);
1298   value = map.Find(DevelImageVisual::Property::CURRENT_FRAME_NUMBER);
1299   DALI_TEST_EQUALS(value->Get<int>(), currentFrameNumber, TEST_LOCATION); // Should be same with currentFrameNumber
1300
1301   END_TEST;
1302 }
1303
1304 int UtcDaliAnimatedVectorImageVisualLoopingMode(void)
1305 {
1306   ToolkitTestApplication application;
1307   tet_infoline("UtcDaliAnimatedVectorImageVisualLoopingMode");
1308
1309   Property::Map propertyMap;
1310   propertyMap.Add(Toolkit::Visual::Property::TYPE, DevelVisual::ANIMATED_VECTOR_IMAGE)
1311     .Add(ImageVisual::Property::URL, TEST_VECTOR_IMAGE_FILE_NAME)
1312     .Add(DevelImageVisual::Property::LOOP_COUNT, 3)
1313     .Add(DevelImageVisual::Property::STOP_BEHAVIOR, DevelImageVisual::StopBehavior::LAST_FRAME)
1314     .Add(DevelImageVisual::Property::LOOPING_MODE, DevelImageVisual::LoopingMode::AUTO_REVERSE);
1315
1316   Visual::Base visual = VisualFactory::Get().CreateVisual(propertyMap);
1317   DALI_TEST_CHECK(visual);
1318
1319   DummyControl      actor     = DummyControl::New(true);
1320   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
1321   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
1322
1323   Vector2 controlSize(20.f, 30.f);
1324   actor.SetProperty(Actor::Property::SIZE, controlSize);
1325
1326   application.GetScene().Add(actor);
1327
1328   Property::Map attributes;
1329   DevelControl::DoAction(actor, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelAnimatedVectorImageVisual::Action::PLAY, attributes);
1330
1331   application.SendNotification();
1332   application.Render();
1333
1334   // Trigger count is 3 - load, render, animation finished
1335   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(3), true, TEST_LOCATION);
1336
1337   Property::Map    map   = actor.GetProperty<Property::Map>(DummyControl::Property::TEST_VISUAL);
1338   Property::Value* value = map.Find(DevelImageVisual::Property::CURRENT_FRAME_NUMBER);
1339   DALI_TEST_EQUALS(value->Get<int>(), 0, TEST_LOCATION); // Should be the first frame because of auto reverse
1340
1341   // Change stop behavior
1342   attributes.Add(DevelImageVisual::Property::STOP_BEHAVIOR, DevelImageVisual::StopBehavior::CURRENT_FRAME);
1343
1344   DevelControl::DoAction(actor, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelVisual::Action::UPDATE_PROPERTY, attributes);
1345
1346   // Play again
1347   DevelControl::DoAction(actor, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelAnimatedVectorImageVisual::Action::PLAY, attributes);
1348
1349   application.SendNotification();
1350   application.Render();
1351
1352   // Trigger count is 1 - animation finished
1353   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
1354
1355   map   = actor.GetProperty<Property::Map>(DummyControl::Property::TEST_VISUAL);
1356   value = map.Find(DevelImageVisual::Property::CURRENT_FRAME_NUMBER);
1357   DALI_TEST_EQUALS(value->Get<int>(), 0, TEST_LOCATION); // Should be the first frame
1358
1359   // Change looping mode
1360   attributes.Add(DevelImageVisual::Property::LOOPING_MODE, DevelImageVisual::LoopingMode::RESTART);
1361
1362   DevelControl::DoAction(actor, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelVisual::Action::UPDATE_PROPERTY, attributes);
1363
1364   // Play again
1365   DevelControl::DoAction(actor, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelAnimatedVectorImageVisual::Action::PLAY, attributes);
1366
1367   application.SendNotification();
1368   application.Render();
1369
1370   // Trigger count is 1 - animation finished
1371   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
1372
1373   Property::Value* value1           = map.Find(DevelImageVisual::Property::TOTAL_FRAME_NUMBER);
1374   int              totalFrameNumber = value1->Get<int>();
1375
1376   map   = actor.GetProperty<Property::Map>(DummyControl::Property::TEST_VISUAL);
1377   value = map.Find(DevelImageVisual::Property::CURRENT_FRAME_NUMBER);
1378   DALI_TEST_EQUALS(value->Get<int>(), totalFrameNumber - 1, TEST_LOCATION); // Should be the last frame
1379
1380   END_TEST;
1381 }
1382
1383 int UtcDaliAnimatedVectorImageVisualPropertyNotification(void)
1384 {
1385   ToolkitTestApplication application;
1386   tet_infoline("UtcDaliAnimatedVectorImageVisualPropertyNotification");
1387
1388   Property::Map propertyMap;
1389   propertyMap.Add(Toolkit::Visual::Property::TYPE, DevelVisual::ANIMATED_VECTOR_IMAGE)
1390     .Add(ImageVisual::Property::URL, TEST_VECTOR_IMAGE_FILE_NAME);
1391
1392   Visual::Base visual = VisualFactory::Get().CreateVisual(propertyMap);
1393   DALI_TEST_CHECK(visual);
1394
1395   DummyControl      actor     = DummyControl::New(true);
1396   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
1397   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
1398   actor.SetProperty(Actor::Property::SIZE, Vector2(10.0f, 10.0f));
1399
1400   application.GetScene().Add(actor);
1401
1402   application.SendNotification();
1403   application.Render();
1404
1405   // Trigger count is 2 - load & render a frame
1406   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
1407
1408   Renderer renderer = actor.GetRendererAt(0u);
1409   DALI_TEST_CHECK(renderer);
1410
1411   Vector2 controlSize(20.f, 30.f);
1412   actor.SetProperty(Actor::Property::SIZE, controlSize);
1413
1414   application.SendNotification();
1415   application.Render();
1416
1417   application.SendNotification();
1418   application.Render();
1419
1420   // Trigger count is 1 - render a frame
1421   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
1422
1423   auto textureSet = renderer.GetTextures();
1424   auto texture    = textureSet.GetTexture(0);
1425
1426   DALI_TEST_EQUALS(controlSize.width, texture.GetWidth(), TEST_LOCATION);
1427   DALI_TEST_EQUALS(controlSize.height, texture.GetHeight(), TEST_LOCATION);
1428
1429   // Change scale
1430   Vector3 controlScale(2.0f, 2.0f, 1.0f);
1431   actor.SetProperty(Actor::Property::SCALE, controlScale);
1432
1433   application.SendNotification();
1434   application.Render();
1435
1436   application.SendNotification();
1437   application.Render();
1438
1439   // Trigger count is 1 - render a frame
1440   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
1441
1442   renderer = actor.GetRendererAt(0u);
1443   DALI_TEST_CHECK(renderer);
1444
1445   textureSet = renderer.GetTextures();
1446   texture    = textureSet.GetTexture(0);
1447
1448   DALI_TEST_EQUALS(controlSize.width * controlScale.width, texture.GetWidth(), TEST_LOCATION);
1449   DALI_TEST_EQUALS(controlSize.height * controlScale.height, texture.GetHeight(), TEST_LOCATION);
1450
1451   // Size animation
1452   controlSize         = Vector2(50.0f, 100.0f);
1453   Animation animation = Animation::New(1.0);
1454   animation.AnimateTo(Property(actor, Actor::Property::SIZE), Vector3(controlSize.x, controlSize.y, 0.0f));
1455   animation.Play();
1456
1457   application.SendNotification();
1458   application.Render(1100); // After the animation
1459
1460   application.SendNotification();
1461   application.Render();
1462
1463   // Trigger count is 1 - render a frame
1464   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
1465
1466   renderer = actor.GetRendererAt(0u);
1467   DALI_TEST_CHECK(renderer);
1468
1469   textureSet = renderer.GetTextures();
1470   texture    = textureSet.GetTexture(0);
1471
1472   DALI_TEST_EQUALS(controlSize.width * controlScale.width, texture.GetWidth(), TEST_LOCATION);
1473   DALI_TEST_EQUALS(controlSize.height * controlScale.height, texture.GetHeight(), TEST_LOCATION);
1474
1475   END_TEST;
1476 }
1477
1478 int UtcDaliAnimatedVectorImageVisualMultipleInstances(void)
1479 {
1480   ToolkitTestApplication application;
1481   tet_infoline("UtcDaliAnimatedVectorImageVisualMultipleInstances");
1482
1483   Property::Map propertyMap;
1484   propertyMap.Add(Toolkit::Visual::Property::TYPE, DevelVisual::ANIMATED_VECTOR_IMAGE)
1485     .Add(ImageVisual::Property::URL, TEST_VECTOR_IMAGE_FILE_NAME);
1486
1487   Visual::Base visual1 = VisualFactory::Get().CreateVisual(propertyMap);
1488   DALI_TEST_CHECK(visual1);
1489
1490   DummyControl      actor1     = DummyControl::New(true);
1491   DummyControlImpl& dummyImpl1 = static_cast<DummyControlImpl&>(actor1.GetImplementation());
1492   dummyImpl1.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual1);
1493
1494   Vector2 controlSize(20.f, 30.f);
1495   actor1.SetProperty(Actor::Property::SIZE, controlSize);
1496
1497   application.GetScene().Add(actor1);
1498
1499   propertyMap.Clear();
1500   propertyMap.Add(Toolkit::Visual::Property::TYPE, DevelVisual::ANIMATED_VECTOR_IMAGE)
1501     .Add(ImageVisual::Property::URL, TEST_VECTOR_IMAGE_FILE_NAME);
1502
1503   Visual::Base visual2 = VisualFactory::Get().CreateVisual(propertyMap);
1504   DALI_TEST_CHECK(visual2);
1505
1506   DummyControl      actor2     = DummyControl::New(true);
1507   DummyControlImpl& dummyImpl2 = static_cast<DummyControlImpl&>(actor2.GetImplementation());
1508   dummyImpl2.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual2);
1509
1510   actor2.SetProperty(Actor::Property::SIZE, controlSize);
1511
1512   application.GetScene().Add(actor2);
1513
1514   // Trigger count is 4 - load & render a frame for each instance
1515   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(4), true, TEST_LOCATION);
1516
1517   DevelControl::DoAction(actor2, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelAnimatedVectorImageVisual::Action::PLAY, Property::Map());
1518
1519   // To make event trigger
1520   actor2.SetProperty(Actor::Property::SIZE, Vector2(10.0f, 10.0f));
1521
1522   application.SendNotification();
1523   application.Render();
1524
1525   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
1526
1527   Property::Map attributes;
1528   attributes.Add(DevelImageVisual::Property::STOP_BEHAVIOR, DevelImageVisual::StopBehavior::LAST_FRAME);
1529
1530   DevelControl::DoAction(actor1, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelVisual::Action::UPDATE_PROPERTY, attributes);
1531   DevelControl::DoAction(actor2, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelVisual::Action::UPDATE_PROPERTY, attributes);
1532
1533   DevelControl::DoAction(actor1, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelAnimatedVectorImageVisual::Action::PLAY, Property::Map());
1534
1535   // renderer is added to actor
1536   DALI_TEST_CHECK(actor1.GetRendererCount() == 1u);
1537   Renderer renderer1 = actor1.GetRendererAt(0u);
1538   DALI_TEST_CHECK(renderer1);
1539
1540   // renderer is added to actor
1541   DALI_TEST_CHECK(actor2.GetRendererCount() == 1u);
1542   Renderer renderer2 = actor2.GetRendererAt(0u);
1543   DALI_TEST_CHECK(renderer2);
1544
1545   END_TEST;
1546 }
1547
1548 int UtcDaliAnimatedVectorImageVisualControlVisibilityChanged(void)
1549 {
1550   ToolkitTestApplication application;
1551   tet_infoline("UtcDaliAnimatedVectorImageVisualControlVisibilityChanged");
1552
1553   Property::Map propertyMap;
1554   propertyMap.Add(Toolkit::Visual::Property::TYPE, DevelVisual::ANIMATED_VECTOR_IMAGE)
1555     .Add(ImageVisual::Property::URL, TEST_VECTOR_IMAGE_FILE_NAME);
1556
1557   Visual::Base visual = VisualFactory::Get().CreateVisual(propertyMap);
1558   DALI_TEST_CHECK(visual);
1559
1560   DummyControl      actor     = DummyControl::New(true);
1561   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
1562   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
1563
1564   Vector2 controlSize(20.f, 30.f);
1565   actor.SetProperty(Actor::Property::SIZE, controlSize);
1566
1567   application.GetScene().Add(actor);
1568
1569   application.SendNotification();
1570   application.Render();
1571
1572   // Trigger count is 2 - load & render a frame
1573   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
1574
1575   Property::Map attributes;
1576   DevelControl::DoAction(actor, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelAnimatedVectorImageVisual::Action::PLAY, attributes);
1577
1578   application.SendNotification();
1579   application.Render();
1580
1581   // Check rendering behavior
1582   DALI_TEST_CHECK(actor.GetRendererCount() == 1u);
1583   Renderer renderer = actor.GetRendererAt(0u);
1584   DALI_TEST_CHECK(renderer);
1585   DALI_TEST_CHECK(renderer.GetProperty<int>(DevelRenderer::Property::RENDERING_BEHAVIOR) == DevelRenderer::Rendering::CONTINUOUSLY);
1586
1587   actor.SetProperty(Actor::Property::VISIBLE, false);
1588
1589   application.SendNotification();
1590   application.Render();
1591
1592   // Check rendering behavior again
1593   DALI_TEST_CHECK(renderer.GetProperty<int>(DevelRenderer::Property::RENDERING_BEHAVIOR) == DevelRenderer::Rendering::IF_REQUIRED);
1594
1595   END_TEST;
1596 }
1597
1598 int UtcDaliAnimatedVectorImageVisualWindowVisibilityChanged(void)
1599 {
1600   ToolkitTestApplication application;
1601   tet_infoline("UtcDaliAnimatedVectorImageVisualWindowVisibilityChanged");
1602
1603   Property::Map propertyMap;
1604   propertyMap.Add(Toolkit::Visual::Property::TYPE, DevelVisual::ANIMATED_VECTOR_IMAGE)
1605     .Add(ImageVisual::Property::URL, TEST_VECTOR_IMAGE_FILE_NAME);
1606
1607   Visual::Base visual = VisualFactory::Get().CreateVisual(propertyMap);
1608   DALI_TEST_CHECK(visual);
1609
1610   DummyControl      actor     = DummyControl::New(true);
1611   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
1612   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
1613
1614   Vector2 controlSize(20.f, 30.f);
1615   actor.SetProperty(Actor::Property::SIZE, controlSize);
1616
1617   application.GetScene().Add(actor);
1618
1619   application.SendNotification();
1620   application.Render();
1621
1622   // Trigger count is 2 - load & render a frame
1623   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
1624
1625   Property::Map attributes;
1626   DevelControl::DoAction(actor, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelAnimatedVectorImageVisual::Action::PLAY, attributes);
1627
1628   application.SendNotification();
1629   application.Render();
1630
1631   // Check rendering behavior
1632   DALI_TEST_CHECK(actor.GetRendererCount() == 1u);
1633   Renderer renderer = actor.GetRendererAt(0u);
1634   DALI_TEST_CHECK(renderer);
1635   DALI_TEST_CHECK(renderer.GetProperty<int>(DevelRenderer::Property::RENDERING_BEHAVIOR) == DevelRenderer::Rendering::CONTINUOUSLY);
1636
1637   Window window = DevelWindow::Get(actor);
1638   window.Hide();
1639
1640   application.SendNotification();
1641   application.Render();
1642
1643   // Check rendering behavior again
1644   DALI_TEST_CHECK(renderer.GetProperty<int>(DevelRenderer::Property::RENDERING_BEHAVIOR) == DevelRenderer::Rendering::IF_REQUIRED);
1645
1646   END_TEST;
1647 }
1648
1649 int UtcDaliAnimatedVectorImageVisualInvalidFile01(void)
1650 {
1651   ToolkitTestApplication application;
1652   tet_infoline("Request loading with invalid file - should draw broken image");
1653
1654   TestGlAbstraction& gl           = application.GetGlAbstraction();
1655   TraceCallStack&    textureTrace = gl.GetTextureTrace();
1656   textureTrace.Enable(true);
1657
1658   Property::Map propertyMap;
1659   propertyMap.Add(Toolkit::Visual::Property::TYPE, DevelVisual::ANIMATED_VECTOR_IMAGE)
1660     .Add(ImageVisual::Property::URL, TEST_VECTOR_IMAGE_INVALID_FILE_NAME);
1661
1662   Visual::Base visual = VisualFactory::Get().CreateVisual(propertyMap);
1663   DALI_TEST_CHECK(visual);
1664
1665   DummyControl      actor     = DummyControl::New(true);
1666   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
1667   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
1668
1669   actor.SetProperty(Actor::Property::SIZE, Vector2(20.0f, 20.0f));
1670
1671   application.GetScene().Add(actor);
1672
1673   application.SendNotification();
1674   application.Render();
1675
1676   // Trigger count is 1 - load
1677   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
1678
1679   application.SendNotification();
1680   application.Render();
1681
1682   // Check resource status
1683   Visual::ResourceStatus status = actor.GetVisualResourceStatus(DummyControl::Property::TEST_VISUAL);
1684   DALI_TEST_EQUALS(status, Visual::ResourceStatus::FAILED, TEST_LOCATION);
1685
1686   // The broken image should be shown.
1687   DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
1688   DALI_TEST_EQUALS(textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION);
1689
1690   END_TEST;
1691 }
1692
1693 int UtcDaliAnimatedVectorImageVisualInvalidFile02(void)
1694 {
1695   ToolkitTestApplication application;
1696   tet_infoline("Request loading with invalid file - should draw broken image");
1697
1698   TestGlAbstraction& gl           = application.GetGlAbstraction();
1699   TraceCallStack&    textureTrace = gl.GetTextureTrace();
1700   textureTrace.Enable(true);
1701
1702   Property::Map propertyMap;
1703   propertyMap.Add(Toolkit::Visual::Property::TYPE, DevelVisual::ANIMATED_VECTOR_IMAGE)
1704     .Add(ImageVisual::Property::URL, TEST_VECTOR_IMAGE_INVALID_FILE_NAME);
1705
1706   Visual::Base visual = VisualFactory::Get().CreateVisual(propertyMap);
1707   DALI_TEST_CHECK(visual);
1708
1709   DummyControl      actor     = DummyControl::New(true);
1710   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
1711   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
1712
1713   actor.SetProperty(Actor::Property::SIZE, Vector2(20.0f, 20.0f));
1714
1715   application.SendNotification();
1716   application.Render();
1717
1718   // Trigger count is 1 - load
1719   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
1720
1721   // Add to the Scene after loading
1722   application.GetScene().Add(actor);
1723
1724   application.SendNotification();
1725   application.Render();
1726
1727   // Check resource status
1728   Visual::ResourceStatus status = actor.GetVisualResourceStatus(DummyControl::Property::TEST_VISUAL);
1729   DALI_TEST_EQUALS(status, Visual::ResourceStatus::FAILED, TEST_LOCATION);
1730
1731   // The broken image should be shown.
1732   DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
1733   DALI_TEST_EQUALS(textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION);
1734
1735   END_TEST;
1736 }
1737
1738 int UtcDaliAnimatedVectorImageVisualInvalidFile03(void)
1739 {
1740   ToolkitTestApplication application;
1741   tet_infoline("Request loading with invalid file without size set - should draw broken image");
1742
1743   TestGlAbstraction& gl           = application.GetGlAbstraction();
1744   TraceCallStack&    textureTrace = gl.GetTextureTrace();
1745   textureTrace.Enable(true);
1746
1747   Property::Map propertyMap;
1748   propertyMap.Add(Toolkit::Visual::Property::TYPE, DevelVisual::ANIMATED_VECTOR_IMAGE)
1749     .Add(ImageVisual::Property::URL, TEST_VECTOR_IMAGE_INVALID_FILE_NAME);
1750
1751   Visual::Base visual = VisualFactory::Get().CreateVisual(propertyMap);
1752   DALI_TEST_CHECK(visual);
1753
1754   DummyControl      actor     = DummyControl::New(true);
1755   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
1756   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
1757
1758   application.GetScene().Add(actor);
1759
1760   application.SendNotification();
1761   application.Render();
1762
1763   // Trigger count is 1 - load
1764   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
1765
1766   application.SendNotification();
1767   application.Render();
1768
1769   // Check resource status
1770   Visual::ResourceStatus status = actor.GetVisualResourceStatus(DummyControl::Property::TEST_VISUAL);
1771   DALI_TEST_EQUALS(status, Visual::ResourceStatus::FAILED, TEST_LOCATION);
1772
1773   // The broken image should be shown.
1774   DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
1775   DALI_TEST_EQUALS(textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION);
1776
1777   END_TEST;
1778 }
1779
1780 int UtcDaliAnimatedVectorImageVisualFrameDrops(void)
1781 {
1782   ToolkitTestApplication application;
1783   tet_infoline("UtcDaliAnimatedVectorImageVisualFrameDrops");
1784
1785   Property::Map propertyMap;
1786   propertyMap.Add(Toolkit::Visual::Property::TYPE, DevelVisual::ANIMATED_VECTOR_IMAGE)
1787     .Add(ImageVisual::Property::URL, TEST_VECTOR_IMAGE_FILE_NAME_FRAME_DROP);
1788
1789   Visual::Base visual = VisualFactory::Get().CreateVisual(propertyMap);
1790   DALI_TEST_CHECK(visual);
1791
1792   DummyControl      actor     = DummyControl::New(true);
1793   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
1794   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
1795
1796   Vector2 controlSize(20.f, 30.f);
1797   actor.SetProperty(Actor::Property::SIZE, controlSize);
1798
1799   application.GetScene().Add(actor);
1800
1801   Property::Map    map              = actor.GetProperty<Property::Map>(DummyControl::Property::TEST_VISUAL);
1802   Property::Value* value            = map.Find(DevelImageVisual::Property::TOTAL_FRAME_NUMBER);
1803   int              totalFrameNumber = value->Get<int>();
1804
1805   Property::Map attributes;
1806   DevelControl::DoAction(actor, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelAnimatedVectorImageVisual::Action::PLAY, attributes);
1807
1808   // Make delay to drop frames
1809   Test::VectorAnimationRenderer::DelayRendering(170); // longer than 16.6 * 10frames
1810
1811   application.SendNotification();
1812   application.Render();
1813
1814   // Trigger count is 3 - load, render the first frame & calculating frame drops
1815   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(3), true, TEST_LOCATION);
1816
1817   // Check dropped frame
1818   uint32_t frames = Test::VectorAnimationRenderer::GetDroppedFrames();
1819   DALI_TEST_CHECK(frames > 0);
1820   DALI_TEST_CHECK(frames <= static_cast<uint32_t>(totalFrameNumber));
1821
1822   END_TEST;
1823 }
1824
1825 int UtcDaliAnimatedVectorImageVisualSize(void)
1826 {
1827   ToolkitTestApplication application;
1828   tet_infoline("UtcDaliAnimatedVectorImageVisualSize");
1829
1830   TestGlAbstraction& gl           = application.GetGlAbstraction();
1831   TraceCallStack&    textureTrace = gl.GetTextureTrace();
1832
1833   VisualFactory factory = VisualFactory::Get();
1834   Visual::Base  visual  = factory.CreateVisual(TEST_VECTOR_IMAGE_FILE_NAME, ImageDimensions());
1835   DALI_TEST_CHECK(visual);
1836
1837   DummyControl      actor     = DummyControl::New(true);
1838   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
1839   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
1840
1841   application.GetScene().Add(actor);
1842
1843   application.SendNotification();
1844
1845   // Trigger count is 2 - load, resource ready
1846   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
1847
1848   textureTrace.Enable(true);
1849
1850   application.SendNotification();
1851   application.Render();
1852
1853   {
1854     int               width = 100, height = 100; // 100x100 is the content default size.
1855     std::stringstream out;
1856     out << GL_TEXTURE_2D << ", " << 0u << ", " << width << ", " << height;
1857     DALI_TEST_CHECK(textureTrace.FindMethodAndParams("TexImage2D", out.str().c_str()));
1858   }
1859
1860   actor.SetProperty(Actor::Property::SIZE, Vector2(200.0f, 200.0f));
1861
1862   application.SendNotification();
1863   application.Render();
1864
1865   // Trigger count is 1 - resource ready
1866   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
1867
1868   textureTrace.Reset();
1869
1870   application.SendNotification();
1871   application.Render();
1872
1873   {
1874     int               width = 200, height = 200;
1875     std::stringstream out;
1876     out << GL_TEXTURE_2D << ", " << 0u << ", " << width << ", " << height;
1877     DALI_TEST_CHECK(textureTrace.FindMethodAndParams("TexImage2D", out.str().c_str()));
1878   }
1879
1880   END_TEST;
1881 }