#include "thread-controller.h"
// INTERNAL INCLUDES
-#include <base/update-thread.h>
-#include <base/render-thread.h>
-#include <base/thread-synchronization.h>
-#include <base/vsync-notifier.h>
-#include <base/interfaces/adaptor-internal-services.h>
#include <base/environment-options.h>
+#include <base/thread-controller-interface.h>
+#include <base/combined-update-render/combined-update-render-controller.h>
+#include <base/separate-update-render/separate-update-render-controller.h>
+#include <base/single-threaded/single-thread-controller.h>
namespace Dali
{
namespace Adaptor
{
-ThreadController::ThreadController( AdaptorInternalServices& adaptorInterfaces,
- const EnvironmentOptions& environmentOptions )
-: mAdaptorInterfaces( adaptorInterfaces ),
- mUpdateThread( NULL ),
- mRenderThread( NULL ),
- mVSyncNotifier( NULL ),
- mThreadSync( NULL ),
- mNumberOfVSyncsPerRender( 1 )
+ThreadController::ThreadController( AdaptorInternalServices& adaptorInterfaces, const EnvironmentOptions& environmentOptions )
+: mThreadControllerInterface( NULL )
{
- mThreadSync = new ThreadSynchronization( adaptorInterfaces, mNumberOfVSyncsPerRender );
-
- mUpdateThread = new UpdateThread( *mThreadSync, adaptorInterfaces, environmentOptions );
-
- mRenderThread = new RenderThread( *mThreadSync, adaptorInterfaces, environmentOptions );
-
- mVSyncNotifier = new VSyncNotifier( *mThreadSync, adaptorInterfaces, environmentOptions );
+ switch( environmentOptions.GetThreadingMode() )
+ {
+ case ThreadingMode::SEPARATE_UPDATE_RENDER:
+ {
+ mThreadControllerInterface = new SeparateUpdateRenderController( adaptorInterfaces, environmentOptions );
+ break;
+ }
+
+ case ThreadingMode::COMBINED_UPDATE_RENDER:
+ {
+ mThreadControllerInterface = new CombinedUpdateRenderController( adaptorInterfaces, environmentOptions );
+ break;
+ }
+
+ case ThreadingMode::SINGLE_THREADED:
+ {
+ mThreadControllerInterface = new SingleThreadController( adaptorInterfaces, environmentOptions );
+ break;
+ }
+ }
}
ThreadController::~ThreadController()
{
- delete mVSyncNotifier;
- delete mRenderThread;
- delete mUpdateThread;
- delete mThreadSync;
+ delete mThreadControllerInterface;
}
-void ThreadController::Start()
+void ThreadController::Initialize()
{
- // Notify the synchronization object before starting the threads
- mThreadSync->Start();
-
- mUpdateThread->Start();
- mRenderThread->Start();
- mVSyncNotifier->Start();
+ mThreadControllerInterface->Initialize();
}
-void ThreadController::Pause()
+void ThreadController::Start()
{
- mThreadSync->Pause();
-
- // if update thread is napping, wake it up to get it to pause in correct place
- mThreadSync->UpdateRequested();
+ mThreadControllerInterface->Start();
}
-void ThreadController::ResumeFrameTime()
+void ThreadController::Pause()
{
- mThreadSync->ResumeFrameTime();
+ mThreadControllerInterface->Pause();
}
void ThreadController::Resume()
{
- mThreadSync->Resume();
+ mThreadControllerInterface->Resume();
}
void ThreadController::Stop()
{
- // Notify the synchronization object before stopping the threads
- mThreadSync->Stop();
-
- mVSyncNotifier->Stop();
- mUpdateThread->Stop();
- mRenderThread->Stop();
+ mThreadControllerInterface->Stop();
}
void ThreadController::RequestUpdate()
{
- mThreadSync->UpdateRequested();
+ mThreadControllerInterface->RequestUpdate();
}
void ThreadController::RequestUpdateOnce()
{
- // we may be sleeping
- mThreadSync->UpdateRequested();
- // if we are paused, need to allow one update
- mThreadSync->UpdateWhilePaused();
+ mThreadControllerInterface->RequestUpdateOnce();
}
void ThreadController::ReplaceSurface( RenderSurface* newSurface )
{
- // tell render thread to start the replace. This call will block until the replace
- // has completed.
- RenderSurface* currentSurface = mAdaptorInterfaces.GetRenderSurfaceInterface();
-
- // Ensure the current surface releases any locks to prevent deadlock.
- currentSurface->StopRender();
-
- mThreadSync->ReplaceSurface( newSurface );
-}
-
-void ThreadController::NewSurface( RenderSurface* newSurface )
-{
- // This API shouldn't be used when there is a current surface, but check anyway.
- RenderSurface* currentSurface = mAdaptorInterfaces.GetRenderSurfaceInterface();
- if( currentSurface )
- {
- currentSurface->StopRender();
- }
-
- mThreadSync->NewSurface( newSurface );
+ mThreadControllerInterface->ReplaceSurface( newSurface );
}
void ThreadController::SetRenderRefreshRate(unsigned int numberOfVSyncsPerRender )
{
- mNumberOfVSyncsPerRender = numberOfVSyncsPerRender;
- mThreadSync->SetRenderRefreshRate(numberOfVSyncsPerRender);
+ mThreadControllerInterface->SetRenderRefreshRate( numberOfVSyncsPerRender );
}
-
} // namespace Adaptor
} // namespace Internal