dali/integration-api/adaptor-framework/scene-holder-impl.cpp

   1 /*
   2  * Copyright (c) 2020 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/integration-api/adaptor-framework/scene-holder-impl.h>
  20
  21 // EXTERNAL INCLUDES
  22 #include <sys/time.h>
  23 #include <dali/public-api/common/dali-common.h>
  24 #include <dali/public-api/actors/actor.h>
  25 #include <dali/public-api/actors/layer.h>
  26 #include <dali/integration-api/debug.h>
  27 #include <dali/integration-api/events/key-event-integ.h>
  28 #include <dali/integration-api/events/touch-event-integ.h>
  29 #include <dali/integration-api/events/hover-event-integ.h>
  30 #include <dali/integration-api/events/wheel-event-integ.h>
  31
  32 // INTERNAL INCLUDES
  33 #include <dali/internal/adaptor/common/adaptor-impl.h>
  34 #include <dali/internal/adaptor/common/lifecycle-observer.h>
  35 #include <dali/internal/graphics/gles/egl-graphics.h>
  36 #include <dali/internal/input/common/key-impl.h>
  37 #include <dali/internal/input/common/physical-keyboard-impl.h>
  38
  39 namespace Dali
  40 {
  41
  42 namespace Internal
  43 {
  44
  45 namespace Adaptor
  46 {
  47
  48 namespace
  49 {
  50
  51 #if defined(DEBUG_ENABLED)
  52 Debug::Filter* gSceneHolderLogFilter = Debug::Filter::New( Debug::NoLogging, false, "LOG_SCENE_HOLDER" );
  53 #endif
  54
  55 // Copied from x server
  56 static uint32_t GetCurrentMilliSeconds(void)
  57 {
  58   struct timeval tv;
  59
  60   struct timespec tp;
  61   static clockid_t clockid;
  62
  63   if (!clockid)
  64   {
  65 #ifdef CLOCK_MONOTONIC_COARSE
  66     if (clock_getres(CLOCK_MONOTONIC_COARSE, &tp) == 0 &&
  67       (tp.tv_nsec / 1000) <= 1000 && clock_gettime(CLOCK_MONOTONIC_COARSE, &tp) == 0)
  68     {
  69       clockid = CLOCK_MONOTONIC_COARSE;
  70     }
  71     else
  72 #endif
  73     if (clock_gettime(CLOCK_MONOTONIC, &tp) == 0)
  74     {
  75       clockid = CLOCK_MONOTONIC;
  76     }
  77     else
  78     {
  79       clockid = ~0L;
  80     }
  81   }
  82   if (clockid != ~0L && clock_gettime(clockid, &tp) == 0)
  83   {
  84     return static_cast<uint32_t>( (tp.tv_sec * 1000 ) + (tp.tv_nsec / 1000000L) );
  85   }
  86
  87   gettimeofday(&tv, NULL);
  88   return static_cast<uint32_t>( (tv.tv_sec * 1000 ) + (tv.tv_usec / 1000) );
  89 }
  90
  91 } // unnamed namespace
  92
  93 uint32_t SceneHolder::mSceneHolderCounter = 0;
  94
  95 class SceneHolder::SceneHolderLifeCycleObserver : public LifeCycleObserver
  96 {
  97 public:
  98
  99   SceneHolderLifeCycleObserver(Adaptor*& adaptor)
 100   : mAdaptor( adaptor )
 101   {
 102   };
 103
 104 private: // Adaptor::LifeCycleObserver interface
 105
 106   void OnStart() override {};
 107   void OnPause() override {};
 108   void OnResume() override {};
 109   void OnStop() override {};
 110   void OnDestroy() override
 111   {
 112     mAdaptor = nullptr;
 113   };
 114
 115 private:
 116   Adaptor*& mAdaptor;
 117 };
 118
 119
 120 SceneHolder::SceneHolder()
 121 : mLifeCycleObserver( new SceneHolderLifeCycleObserver( mAdaptor ) ),
 122   mId( mSceneHolderCounter++ ),
 123   mSurface( nullptr ),
 124   mAdaptor( nullptr ),
 125   mDpi(),
 126   mIsBeingDeleted( false ),
 127   mAdaptorStarted( false ),
 128   mVisible( true )
 129 {
 130 }
 131
 132 SceneHolder::~SceneHolder()
 133 {
 134   if ( mAdaptor )
 135   {
 136     mAdaptor->RemoveObserver( *mLifeCycleObserver.get() );
 137     mAdaptor->RemoveWindow( this );
 138
 139     mAdaptor->DeleteSurface( *mSurface.get() );
 140
 141     mAdaptor = nullptr;
 142   }
 143
 144   if ( mScene )
 145   {
 146     mScene.Discard();
 147   }
 148 }
 149
 150 void SceneHolder::Add( Dali::Actor actor )
 151 {
 152   if ( mScene )
 153   {
 154     mScene.Add( actor );
 155   }
 156 }
 157
 158 void SceneHolder::Remove( Dali::Actor actor )
 159 {
 160   if ( mScene )
 161   {
 162     mScene.Remove( actor );
 163   }
 164 }
 165
 166 Dali::Layer SceneHolder::GetRootLayer() const
 167 {
 168   return mScene ? mScene.GetRootLayer() : Dali::Layer();
 169 }
 170
 171 uint32_t SceneHolder::GetId() const
 172 {
 173   return mId;
 174 }
 175
 176 std::string SceneHolder::GetName() const
 177 {
 178   return mName;
 179 }
 180
 181 bool SceneHolder::IsVisible() const
 182 {
 183   return mVisible;
 184 }
 185
 186 Dali::Integration::Scene SceneHolder::GetScene()
 187 {
 188   return mScene;
 189 }
 190
 191 Uint16Pair SceneHolder::GetDpi() const
 192 {
 193   return mDpi;
 194 }
 195
 196 void SceneHolder::SetSurface(Dali::RenderSurfaceInterface* surface)
 197 {
 198   mSurface.reset( surface );
 199
 200   mScene.SurfaceReplaced();
 201
 202   SurfaceResized();
 203
 204   InitializeDpi();
 205
 206   mSurface->SetAdaptor( *mAdaptor );
 207   mSurface->SetScene( mScene );
 208
 209   OnSurfaceSet( surface );
 210 }
 211
 212 void SceneHolder::SurfaceResized()
 213 {
 214   PositionSize surfacePositionSize = mSurface->GetPositionSize();
 215   mScene.SurfaceResized( static_cast<float>( surfacePositionSize.width ), static_cast<float>( surfacePositionSize.height ) );
 216
 217   GraphicsInterface& graphics = mAdaptor->GetGraphicsInterface();
 218   EglGraphics* eglGraphics = static_cast<EglGraphics*>(&graphics);
 219   if (eglGraphics)
 220   {
 221     eglGraphics->SetFullSwapNextFrame();
 222   }
 223 }
 224
 225 Dali::RenderSurfaceInterface* SceneHolder::GetSurface() const
 226 {
 227   return mSurface.get();
 228 }
 229
 230 void SceneHolder::SetBackgroundColor( const Vector4& color )
 231 {
 232   if( mScene )
 233   {
 234     mScene.SetBackgroundColor( color );
 235
 236     GraphicsInterface& graphics = mAdaptor->GetGraphicsInterface();
 237     EglGraphics* eglGraphics = static_cast<EglGraphics*>(&graphics);
 238     if (eglGraphics)
 239     {
 240       eglGraphics->SetFullSwapNextFrame();
 241     }
 242   }
 243 }
 244
 245 Vector4 SceneHolder::GetBackgroundColor() const
 246 {
 247   return mScene ? mScene.GetBackgroundColor() : Color::BLACK;
 248 }
 249
 250 void SceneHolder::SetAdaptor(Dali::Adaptor& adaptor)
 251 {
 252   // Avoid doing this more than once
 253   if( mAdaptorStarted )
 254   {
 255     return;
 256   }
 257
 258   DALI_ASSERT_DEBUG(mSurface && "Surface needs to be set before calling this method\n");
 259
 260   mAdaptorStarted = true;
 261
 262   // Create the scene
 263   PositionSize surfacePositionSize = mSurface->GetPositionSize();
 264   mScene = Dali::Integration::Scene::New( Size(static_cast<float>( surfacePositionSize.width ), static_cast<float>( surfacePositionSize.height )) );
 265
 266   Internal::Adaptor::Adaptor& adaptorImpl = Internal::Adaptor::Adaptor::GetImplementation( adaptor );
 267   mAdaptor = &adaptorImpl;
 268
 269   // Create an observer for the adaptor lifecycle
 270   mAdaptor->AddObserver( *mLifeCycleObserver );
 271
 272   InitializeDpi();
 273
 274   mSurface->SetAdaptor( *mAdaptor );
 275   mSurface->SetScene( mScene );
 276
 277   OnAdaptorSet( adaptor );
 278 }
 279
 280 void SceneHolder::Pause()
 281 {
 282   Reset();
 283
 284   OnPause();
 285 }
 286
 287 void SceneHolder::Resume()
 288 {
 289   Reset();
 290
 291   OnResume();
 292 }
 293
 294 void SceneHolder::FeedTouchPoint( Dali::Integration::Point& point, int timeStamp )
 295 {
 296   if( timeStamp < 1 )
 297   {
 298     timeStamp = GetCurrentMilliSeconds();
 299   }
 300
 301   RecalculateTouchPosition( point );
 302
 303   Integration::TouchEvent touchEvent;
 304   Integration::HoverEvent hoverEvent;
 305   Integration::TouchEventCombiner::EventDispatchType type = mCombiner.GetNextTouchEvent(point, timeStamp, touchEvent, hoverEvent);
 306   if( type != Integration::TouchEventCombiner::DISPATCH_NONE )
 307   {
 308     DALI_LOG_INFO( gSceneHolderLogFilter, Debug::Verbose, "%d: Device %d: Button state %d (%.2f, %.2f)\n", timeStamp, point.GetDeviceId(), point.GetState(), point.GetScreenPosition().x, point.GetScreenPosition().y );
 309
 310     // Signals can be emitted while processing core events, and the scene holder could be deleted in the signal callback.
 311     // Keep the handle alive until the core events are processed.
 312     Dali::BaseHandle sceneHolder( this );
 313
 314     // First the touch and/or hover event & related gesture events are queued
 315     if( type == Integration::TouchEventCombiner::DISPATCH_TOUCH || type == Integration::TouchEventCombiner::DISPATCH_BOTH )
 316     {
 317       mScene.QueueEvent( touchEvent );
 318     }
 319
 320     if( type == Integration::TouchEventCombiner::DISPATCH_HOVER || type == Integration::TouchEventCombiner::DISPATCH_BOTH )
 321     {
 322       mScene.QueueEvent( hoverEvent );
 323     }
 324
 325     // Next the events are processed with a single call into Core
 326     mAdaptor->ProcessCoreEvents();
 327   }
 328 }
 329
 330 void SceneHolder::FeedWheelEvent( Dali::Integration::WheelEvent& wheelEvent )
 331 {
 332   // Signals can be emitted while processing core events, and the scene holder could be deleted in the signal callback.
 333   // Keep the handle alive until the core events are processed.
 334   Dali::BaseHandle sceneHolder( this );
 335
 336   mScene.QueueEvent( wheelEvent );
 337   mAdaptor->ProcessCoreEvents();
 338 }
 339
 340 void SceneHolder::FeedKeyEvent( Dali::Integration::KeyEvent& keyEvent )
 341 {
 342   Dali::PhysicalKeyboard physicalKeyboard = PhysicalKeyboard::Get();
 343   if( physicalKeyboard )
 344   {
 345     if( ! KeyLookup::IsDeviceButton( keyEvent.keyName.c_str() ) )
 346     {
 347       GetImplementation( physicalKeyboard ).KeyReceived( keyEvent.time > 1 );
 348     }
 349   }
 350
 351   // Signals can be emitted while processing core events, and the scene holder could be deleted in the signal callback.
 352   // Keep the handle alive until the core events are processed.
 353   Dali::BaseHandle sceneHolder( this );
 354
 355   // Create send KeyEvent to Core.
 356   mScene.QueueEvent( keyEvent );
 357   mAdaptor->ProcessCoreEvents();
 358 }
 359
 360 void SceneHolder::AddFrameRenderedCallback( std::unique_ptr< CallbackBase > callback, int32_t frameId )
 361 {
 362   mScene.AddFrameRenderedCallback( std::move( callback ), frameId );
 363
 364   DALI_LOG_INFO( gSceneHolderLogFilter, Debug::General, "SceneHolder::AddFrameRenderedCallback:: Added [%d]\n", frameId );
 365 }
 366
 367 void SceneHolder::AddFramePresentedCallback( std::unique_ptr< CallbackBase > callback, int32_t frameId )
 368 {
 369   mScene.AddFramePresentedCallback( std::move( callback ), frameId );
 370
 371   DALI_LOG_INFO( gSceneHolderLogFilter, Debug::General, "SceneHolder::AddFramePresentedCallback:: Added [%d]\n", frameId );
 372 }
 373
 374 Dali::Integration::SceneHolder SceneHolder::Get( Dali::Actor actor )
 375 {
 376   SceneHolder* sceneHolderImpl = nullptr;
 377
 378   if ( Internal::Adaptor::Adaptor::IsAvailable() )
 379   {
 380     Dali::Internal::Adaptor::Adaptor& adaptor = Internal::Adaptor::Adaptor::GetImplementation( Internal::Adaptor::Adaptor::Get() );
 381     sceneHolderImpl = adaptor.GetWindow( actor );
 382   }
 383
 384   return Dali::Integration::SceneHolder( sceneHolderImpl );
 385 }
 386
 387 void SceneHolder::Reset()
 388 {
 389   mCombiner.Reset();
 390
 391   // Any touch listeners should be told of the interruption.
 392   Integration::TouchEvent event;
 393   Integration::Point point;
 394   point.SetState( PointState::INTERRUPTED );
 395   event.AddPoint( point );
 396
 397   // First the touch event & related gesture events are queued
 398   mScene.QueueEvent( event );
 399
 400   // Next the events are processed with a single call into Core
 401   mAdaptor->ProcessCoreEvents();
 402 }
 403
 404 void SceneHolder::InitializeDpi()
 405 {
 406   unsigned int dpiHorizontal, dpiVertical;
 407   dpiHorizontal = dpiVertical = 0;
 408
 409   mSurface->GetDpi( dpiHorizontal, dpiVertical );
 410   mScene.SetDpi( Vector2( static_cast<float>( dpiHorizontal ), static_cast<float>( dpiVertical ) ) );
 411
 412   mDpi.SetX( dpiHorizontal );
 413   mDpi.SetY( dpiVertical );
 414 }
 415
 416 }// Adaptor
 417
 418 }// Internal
 419
 420 } // Dali