/*
- * Copyright (c) 2020 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2023 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
OffscreenApplication::~OffscreenApplication() = default;
-void OffscreenApplication::Start()
+void OffscreenApplication::MainLoop()
{
- Internal::GetImplementation(*this).Start();
+ Internal::GetImplementation(*this).MainLoop();
}
-void OffscreenApplication::Stop()
+void OffscreenApplication::Quit()
{
- Internal::GetImplementation(*this).Stop();
+ Internal::GetImplementation(*this).Quit();
}
Dali::OffscreenWindow OffscreenApplication::GetWindow()
#define DALI_OFFSCREEN_APPLICATION_H
/*
- * Copyright (c) 2020 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2023 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
public:
/**
- * @brief Starts the OffscreenApplication (rendering, event handling, etc)
+ * @brief This starts the application.
*/
- void Start();
+ void MainLoop();
/**
- * @brief Stops the OffscreenApplication
+ * @brief This quits the application.
*/
- void Stop();
+ void Quit();
/**
* @brief Get the default OffscreenWindow handle
{
namespace Adaptor
{
-std::unique_ptr<Framework> FrameworkFactoryAndroid::CreateFramework(Framework::Observer& observer, Framework::TaskObserver& taskObserver, int* argc, char*** argv, Framework::Type type, bool useUiThread)
+std::unique_ptr<Framework> FrameworkFactoryAndroid::CreateFramework(FrameworkBackend backend, Framework::Observer& observer, Framework::TaskObserver& taskObserver, int* argc, char*** argv, Framework::Type type, bool useUiThread)
{
return Utils::MakeUnique<FrameworkAndroid>(observer, taskObserver, argc, argv, type, useUiThread);
}
-std::unique_ptr<FrameworkFactory> GetFrameworkFactory()
+FrameworkFactory* GetFrameworkFactory()
{
- return Utils::MakeUnique<FrameworkFactoryAndroid>();
+ static std::unique_ptr<FrameworkFactory> frameworkFactory = nullptr;
+
+ if(!frameworkFactory)
+ {
+ frameworkFactory = Utils::MakeUnique<FrameworkFactoryAndroid>();
+ }
+ return frameworkFactory.get();
}
} // namespace Adaptor
class FrameworkFactoryAndroid : public FrameworkFactory
{
public:
- std::unique_ptr<Framework> CreateFramework(Framework::Observer& observer, Framework::TaskObserver& taskObserver, int* argc, char*** argv, Framework::Type type, bool useUiThread) override;
+ std::unique_ptr<Framework> CreateFramework(FrameworkBackend frameworkType, Framework::Observer& observer, Framework::TaskObserver& taskObserver, int* argc, char*** argv, Framework::Type type, bool useUiThread) override;
};
} // namespace Adaptor
{
namespace Adaptor
{
-std::unique_ptr<Framework> FrameworkFactoryAndroidJni::CreateFramework(Framework::Observer& observer, Framework::TaskObserver& taskObserver, int* argc, char*** argv, Framework::Type type, bool useUiThread)
+std::unique_ptr<Framework> FrameworkFactoryAndroidJni::CreateFramework(FrameworkBackend backend, Framework::Observer& observer, Framework::TaskObserver& taskObserver, int* argc, char*** argv, Framework::Type type, bool useUiThread)
{
return Utils::MakeUnique<FrameworkAndroidJni>(observer, taskObserver, argc, argv, type, useUiThread);
}
-std::unique_ptr<FrameworkFactory> GetFrameworkFactory()
+FrameworkFactory* GetFrameworkFactory()
{
- return Utils::MakeUnique<FrameworkFactoryAndroidJni>();
+ static std::unique_ptr<FrameworkFactory> frameworkFactory = nullptr;
+
+ if(!frameworkFactory)
+ {
+ frameworkFactory = Utils::MakeUnique<FrameworkFactoryAndroidJni>();
+ }
+ return frameworkFactory.get();
}
} // namespace Adaptor
class FrameworkFactoryAndroidJni : public FrameworkFactory
{
public:
- std::unique_ptr<Framework> CreateFramework(Framework::Observer& observer, Framework::TaskObserver& taskObserver, int* argc, char*** argv, Framework::Type type, bool useUiThread) override;
+ std::unique_ptr<Framework> CreateFramework(FrameworkBackend frameworkType, Framework::Observer& observer, Framework::TaskObserver& taskObserver, int* argc, char*** argv, Framework::Type type, bool useUiThread) override;
};
} // namespace Adaptor
}
mCommandLineOptions = new CommandLineOptions(argc, argv);
- mFramework = Dali::Internal::Adaptor::GetFrameworkFactory()->CreateFramework(*this, *this, argc, argv, applicationType, mUseUiThread);
+ mFramework = Dali::Internal::Adaptor::GetFrameworkFactory()->CreateFramework(FrameworkBackend::DEFAULT, *this, *this, argc, argv, applicationType, mUseUiThread);
mUseRemoteSurface = (applicationType == Framework::WATCH);
}
{
namespace Adaptor
{
+enum class FrameworkBackend
+{
+ DEFAULT,
+ GLIB
+};
+
class FrameworkFactory
{
public:
FrameworkFactory() = default;
virtual ~FrameworkFactory() = default;
- virtual std::unique_ptr<Framework> CreateFramework(Framework::Observer& observer, Framework::TaskObserver& taskObserver, int* argc, char*** argv, Framework::Type type, bool useUiThread) = 0;
+ virtual std::unique_ptr<Framework> CreateFramework(FrameworkBackend backend, Framework::Observer& observer, Framework::TaskObserver& taskObserver, int* argc, char*** argv, Framework::Type type, bool useUiThread) = 0;
+ virtual FrameworkBackend GetFrameworkBackend() const
+ {
+ return FrameworkBackend::DEFAULT;
+ }
};
-extern std::unique_ptr<FrameworkFactory> GetFrameworkFactory();
+extern FrameworkFactory* GetFrameworkFactory();
} // namespace Adaptor
} // namespace Internal
# module: adaptor, backend: tizen-wayland
SET( adaptor_adaptor_tizen_wayland_src_files
+ ${adaptor_adaptor_dir}/glib/framework-glib.cpp
${adaptor_adaptor_dir}/tizen-wayland/adaptor-impl-tizen.cpp
${adaptor_adaptor_dir}/tizen-wayland/framework-factory-tizen.cpp
${adaptor_adaptor_dir}/tizen-wayland/framework-tizen.cpp
# module: adaptor, backend: ubuntu
SET( adaptor_adaptor_ubuntu_src_files
${adaptor_adaptor_dir}/generic/adaptor-impl-generic.cpp
+ ${adaptor_adaptor_dir}/glib/framework-glib.cpp
${adaptor_adaptor_dir}/ubuntu/framework-factory-ubuntu.cpp
${adaptor_adaptor_dir}/ubuntu/framework-ubuntu.cpp
)
{
namespace Adaptor
{
-std::unique_ptr<Framework> FrameworkFactoryGlib::CreateFramework(Framework::Observer& observer, Framework::TaskObserver& taskObserver, int* argc, char*** argv, Framework::Type type, bool useUiThread)
+std::unique_ptr<Framework> FrameworkFactoryGlib::CreateFramework(FrameworkBackend backend, Framework::Observer& observer, Framework::TaskObserver& taskObserver, int* argc, char*** argv, Framework::Type type, bool useUiThread)
{
return Utils::MakeUnique<FrameworkGlib>(observer, taskObserver, argc, argv, type, useUiThread);
}
-std::unique_ptr<FrameworkFactory> GetFrameworkFactory()
+FrameworkFactory* GetFrameworkFactory()
{
- return Utils::MakeUnique<FrameworkFactoryGlib>();
+ static std::unique_ptr<FrameworkFactory> frameworkFactory = nullptr;
+
+ if(!frameworkFactory)
+ {
+ frameworkFactory = Utils::MakeUnique<FrameworkFactoryGlib>();
+ }
+ return frameworkFactory.get();
}
} // namespace Adaptor
class FrameworkFactoryGlib : public FrameworkFactory
{
public:
- std::unique_ptr<Framework> CreateFramework(Framework::Observer& observer, Framework::TaskObserver& taskObserver, int* argc, char*** argv, Framework::Type type, bool useUiThread) override;
+ std::unique_ptr<Framework> CreateFramework(FrameworkBackend frameworkType, Framework::Observer& observer, Framework::TaskObserver& taskObserver, int* argc, char*** argv, Framework::Type type, bool useUiThread) override;
};
} // namespace Adaptor
// Constructor
Impl(void* data)
{
- // In future, may need to change this to have own context or use Tizen context
- gMainLoop = mMainLoop = g_main_loop_new(nullptr, false);
+ GMainContext* context = g_main_context_new();
+ gMainLoop = mMainLoop = g_main_loop_new(context, false);
}
~Impl()
{
namespace Adaptor
{
-std::unique_ptr<Framework> FrameworkFactoryLibuv::CreateFramework(Framework::Observer& observer, Framework::TaskObserver& taskObserver, int* argc, char*** argv, Framework::Type type, bool useUiThread)
+std::unique_ptr<Framework> FrameworkFactoryLibuv::CreateFramework(FrameworkBackend backend, Framework::Observer& observer, Framework::TaskObserver& taskObserver, int* argc, char*** argv, Framework::Type type, bool useUiThread)
{
return Utils::MakeUnique<FrameworkLibuv>(observer, taskObserver, argc, argv, type, useUiThread);
}
-std::unique_ptr<FrameworkFactory> GetFrameworkFactory()
+FrameworkFactory* GetFrameworkFactory()
{
- return Utils::MakeUnique<FrameworkFactoryLibuv>();
+ static std::unique_ptr<FrameworkFactory> frameworkFactory = nullptr;
+
+ if(!frameworkFactory)
+ {
+ frameworkFactory = Utils::MakeUnique<FrameworkFactoryLibuv>();
+ }
+ return frameworkFactory.get();
}
} // namespace Adaptor
class FrameworkFactoryLibuv : public FrameworkFactory
{
public:
- std::unique_ptr<Framework> CreateFramework(Framework::Observer& observer, Framework::TaskObserver& taskObserver, int* argc, char*** argv, Framework::Type type, bool useUiThread) override;
+ std::unique_ptr<Framework> CreateFramework(FrameworkBackend frameworkType, Framework::Observer& observer, Framework::TaskObserver& taskObserver, int* argc, char*** argv, Framework::Type type, bool useUiThread) override;
};
} // namespace Adaptor
class FrameworkFactoryMac : public FrameworkFactory
{
public:
- std::unique_ptr<Framework> CreateFramework(Framework::Observer& observer, Framework::TaskObserver& taskObserver, int* argc, char*** argv, Framework::Type type, bool useUiThread) override;
+ std::unique_ptr<Framework> CreateFramework(FrameworkBackend frameworkType, Framework::Observer& observer, Framework::TaskObserver& taskObserver, int* argc, char*** argv, Framework::Type type, bool useUiThread) override;
};
} // namespace Adaptor
{
namespace Adaptor
{
-std::unique_ptr<Framework> FrameworkFactoryMac::CreateFramework(Framework::Observer& observer, Framework::TaskObserver& taskObserver, int* argc, char*** argv, Framework::Type type, bool useUiThread)
+std::unique_ptr<Framework> FrameworkFactoryMac::CreateFramework(FrameworkBackend backend, Framework::Observer& observer, Framework::TaskObserver& taskObserver, int* argc, char*** argv, Framework::Type type, bool useUiThread)
{
return Utils::MakeUnique<FrameworkMac>(observer, taskObserver, argc, argv, type, useUiThread);
}
-std::unique_ptr<FrameworkFactory> GetFrameworkFactory()
+FrameworkFactory* GetFrameworkFactory()
{
- return Utils::MakeUnique<FrameworkFactoryMac>();
+ static std::unique_ptr<FrameworkFactory> frameworkFactory = nullptr;
+
+ if(!frameworkFactory)
+ {
+ frameworkFactory = Utils::MakeUnique<FrameworkFactoryMac>();
+ }
+ return frameworkFactory.get();
}
} // namespace Adaptor
#include <dali/internal/adaptor/tizen-wayland/framework-factory-tizen.h>
// INTERNAL HEADERS
+#include <dali/internal/adaptor/glib/framework-glib.h>
#include <dali/internal/adaptor/tizen-wayland/framework-tizen.h>
#include <dali/internal/window-system/common/display-utils.h>
{
namespace Adaptor
{
-std::unique_ptr<Framework> FrameworkFactoryTizen::CreateFramework(Framework::Observer& observer, Framework::TaskObserver& taskObserver, int* argc, char*** argv, Framework::Type type, bool useUiThread)
+std::unique_ptr<Framework> FrameworkFactoryTizen::CreateFramework(FrameworkBackend backend, Framework::Observer& observer, Framework::TaskObserver& taskObserver, int* argc, char*** argv, Framework::Type type, bool useUiThread)
{
- return Utils::MakeUnique<FrameworkTizen>(observer, taskObserver, argc, argv, type, useUiThread);
+ mBackend = backend;
+ if(mBackend == FrameworkBackend::GLIB)
+ {
+ return Utils::MakeUnique<FrameworkGlib>(observer, taskObserver, argc, argv, type, useUiThread);
+ }
+ else
+ {
+ return Utils::MakeUnique<FrameworkTizen>(observer, taskObserver, argc, argv, type, useUiThread);
+ }
}
-std::unique_ptr<FrameworkFactory> GetFrameworkFactory()
+FrameworkFactory* GetFrameworkFactory()
{
- return Utils::MakeUnique<FrameworkFactoryTizen>();
+ static std::unique_ptr<FrameworkFactory> frameworkFactory = nullptr;
+
+ if(!frameworkFactory)
+ {
+ frameworkFactory = Utils::MakeUnique<FrameworkFactoryTizen>();
+ }
+ return frameworkFactory.get();
}
} // namespace Adaptor
class FrameworkFactoryTizen : public FrameworkFactory
{
public:
- std::unique_ptr<Framework> CreateFramework(Framework::Observer& observer, Framework::TaskObserver& taskObserver, int* argc, char*** argv, Framework::Type type, bool useUiThread) override;
+ std::unique_ptr<Framework> CreateFramework(FrameworkBackend frameworkType, Framework::Observer& observer, Framework::TaskObserver& taskObserver, int* argc, char*** argv, Framework::Type type, bool useUiThread) override;
+
+ FrameworkBackend GetFrameworkBackend() const override
+ {
+ return mBackend;
+ }
+
+private:
+ FrameworkBackend mBackend;
};
} // namespace Adaptor
{
namespace Adaptor
{
-std::unique_ptr<Framework> FrameworkFactoryUbuntu::CreateFramework(Framework::Observer& observer, Framework::TaskObserver& taskObserver, int* argc, char*** argv, Framework::Type type, bool useUiThread)
+std::unique_ptr<Framework> FrameworkFactoryUbuntu::CreateFramework(FrameworkBackend backend, Framework::Observer& observer, Framework::TaskObserver& taskObserver, int* argc, char*** argv, Framework::Type type, bool useUiThread)
{
return Utils::MakeUnique<FrameworkUbuntu>(observer, taskObserver, argc, argv, type, useUiThread);
}
-std::unique_ptr<FrameworkFactory> GetFrameworkFactory()
+FrameworkFactory* GetFrameworkFactory()
{
- return Utils::MakeUnique<FrameworkFactoryUbuntu>();
+ static std::unique_ptr<FrameworkFactory> frameworkFactory = nullptr;
+
+ if(!frameworkFactory)
+ {
+ frameworkFactory = Utils::MakeUnique<FrameworkFactoryUbuntu>();
+ }
+ return frameworkFactory.get();
}
} // namespace Adaptor
class FrameworkFactoryUbuntu : public FrameworkFactory
{
public:
- std::unique_ptr<Framework> CreateFramework(Framework::Observer& observer, Framework::TaskObserver& taskObserver, int* argc, char*** argv, Framework::Type type, bool useUiThread) override;
+ std::unique_ptr<Framework> CreateFramework(FrameworkBackend frameworkType, Framework::Observer& observer, Framework::TaskObserver& taskObserver, int* argc, char*** argv, Framework::Type type, bool useUiThread) override;
};
} // namespace Adaptor
{
namespace Adaptor
{
-std::unique_ptr<Framework> FrameworkFactoryWin::CreateFramework(Framework::Observer& observer, Framework::TaskObserver& taskObserver, int* argc, char*** argv, Framework::Type type, bool useUiThread)
+std::unique_ptr<Framework> FrameworkFactoryWin::CreateFramework(FrameworkBackend backend, Framework::Observer& observer, Framework::TaskObserver& taskObserver, int* argc, char*** argv, Framework::Type type, bool useUiThread)
{
return Utils::MakeUnique<FrameworkWin>(observer, taskObserver, argc, argv, type, useUiThread);
}
-std::unique_ptr<FrameworkFactory> GetFrameworkFactory()
+FrameworkFactory* GetFrameworkFactory()
{
- return Utils::MakeUnique<FrameworkFactoryWin>();
+ static std::unique_ptr<FrameworkFactory> frameworkFactory = nullptr;
+
+ if(!frameworkFactory)
+ {
+ frameworkFactory = Utils::MakeUnique<FrameworkFactoryWin>();
+ }
+ return frameworkFactory.get();
}
} // namespace Adaptor
class FrameworkFactoryWin : public FrameworkFactory
{
public:
- std::unique_ptr<Framework> CreateFramework(Framework::Observer& observer, Framework::TaskObserver& taskObserver, int* argc, char*** argv, Framework::Type type, bool useUiThread) override;
+ std::unique_ptr<Framework> CreateFramework(FrameworkBackend frameworkType, Framework::Observer& observer, Framework::TaskObserver& taskObserver, int* argc, char*** argv, Framework::Type type, bool useUiThread) override;
};
} // namespace Adaptor
#include <dali/internal/offscreen/common/offscreen-application-impl.h>
// INTERNAL INCLUDES
+#include <dali/devel-api/adaptor-framework/accessibility-bridge.h>
#include <dali/devel-api/adaptor-framework/environment-variable.h>
#include <dali/integration-api/adaptor-framework/adaptor.h>
#include <dali/integration-api/adaptor-framework/native-render-surface.h>
#include <dali/internal/adaptor/common/adaptor-impl.h>
+#include <dali/internal/adaptor/common/framework-factory.h>
#include <dali/internal/adaptor/common/thread-controller-interface.h>
#include <dali/internal/offscreen/common/offscreen-window-impl.h>
#include <dali/internal/system/common/environment-variables.h>
// Disable partial update
EnvironmentVariable::SetEnvironmentVariable(DALI_ENV_DISABLE_PARTIAL_UPDATE, "1");
- Dali::Internal::Adaptor::WindowSystem::Initialize();
+ // Disable ATSPI
+ Dali::Accessibility::Bridge::DisableAutoInit();
+
+ // Now we assume separated main loop for the offscreen application
+ mFramework = Internal::Adaptor::GetFrameworkFactory()->CreateFramework(Internal::Adaptor::FrameworkBackend::GLIB, *this, *this, nullptr, nullptr, Adaptor::Framework::NORMAL, false);
// Generate a default window
IntrusivePtr<Internal::OffscreenWindow> impl = Internal::OffscreenWindow::New(width, height, surface, isTranslucent);
OffscreenApplication::~OffscreenApplication()
{
- Dali::Internal::Adaptor::WindowSystem::Shutdown();
}
-void OffscreenApplication::Start()
+void OffscreenApplication::MainLoop()
+{
+ mFramework->Run();
+}
+
+void OffscreenApplication::Quit()
+{
+ // Actually quit the application.
+ // Force a call to Quit even if adaptor is not running.
+ Internal::Adaptor::Adaptor::GetImplementation(*mAdaptor).AddIdle(MakeCallback(this, &OffscreenApplication::QuitFromMainLoop), false, true);
+}
+
+Dali::OffscreenWindow OffscreenApplication::GetWindow()
+{
+ return mDefaultWindow;
+}
+
+void OffscreenApplication::RenderOnce()
+{
+ mAdaptor->RenderOnce();
+}
+
+void OffscreenApplication::OnInit()
{
// Start the adaptor
mAdaptor->Start();
- Dali::OffscreenApplication handle(this);
mInitSignal.Emit();
+
mAdaptor->NotifySceneCreated();
}
-void OffscreenApplication::Stop()
+void OffscreenApplication::OnTerminate()
{
+ mTerminateSignal.Emit();
+
// Stop the adaptor
mAdaptor->Stop();
- Dali::OffscreenApplication handle(this);
- mTerminateSignal.Emit();
+ mDefaultWindow.Reset();
}
-Dali::OffscreenWindow OffscreenApplication::GetWindow()
+void OffscreenApplication::QuitFromMainLoop()
{
- return mDefaultWindow;
-}
+ mAdaptor->Stop();
-void OffscreenApplication::RenderOnce()
-{
- mAdaptor->RenderOnce();
+ mFramework->Quit();
+ // This will trigger OnTerminate(), below, after the main loop has completed.
}
} // namespace Internal
#include <dali/devel-api/adaptor-framework/offscreen-application.h>
#include <dali/devel-api/adaptor-framework/offscreen-window.h>
#include <dali/integration-api/adaptor-framework/scene-holder-impl.h>
+#include <dali/internal/adaptor/common/framework.h>
namespace Dali
{
/**
* Implementation of the OffscreenApplication class.
*/
-class OffscreenApplication : public BaseObject
+class OffscreenApplication : public BaseObject, public Adaptor::Framework::Observer, public Adaptor::Framework::TaskObserver
{
public:
using OffscreenApplicationSignalType = Dali::OffscreenApplication::OffscreenApplicationSignalType;
virtual ~OffscreenApplication();
/**
- * @copydoc Dali::OffscreenApplication::Start()
+ * @copydoc Dali::OffscreenApplication::MainLoop()
*/
- void Start();
+ void MainLoop();
/**
- * @copydoc Dali::OffscreenApplication::Stop()
+ * @copydoc Dali::OffscreenApplication::Quit()
*/
- void Stop();
+ void Quit();
/**
* @copydoc Dali::OffscreenApplication::GetDefaultWindow()
return mTerminateSignal;
}
+public: // From Framework::Observer
+ /**
+ * Called when the framework is initialised.
+ */
+ void OnInit() override;
+
+ /**
+ * Called when the framework is terminated.
+ */
+ void OnTerminate() override;
+
private:
/**
* Private constructor
*/
OffscreenApplication(uint16_t width, uint16_t height, Dali::Any surface, bool isTranslucent, Dali::OffscreenApplication::RenderMode renderMode);
+ /**
+ * Quits from the main loop
+ */
+ void QuitFromMainLoop();
+
// Undefined
OffscreenApplication(const OffscreenApplication&) = delete;
OffscreenApplication& operator=(OffscreenApplication&) = delete;
std::unique_ptr<Dali::Adaptor> mAdaptor;
Dali::OffscreenWindow mDefaultWindow;
+ std::unique_ptr<Internal::Adaptor::Framework> mFramework;
+
OffscreenApplicationSignalType mInitSignal;
OffscreenApplicationSignalType mTerminateSignal;
};
${adaptor_system_dir}/common/shared-file.cpp
${adaptor_system_dir}/common/trigger-event.cpp
${adaptor_system_dir}/common/trigger-event-factory.cpp
+ ${adaptor_system_dir}/common/time-service.cpp
+ ${adaptor_system_dir}/generic/shared-file-operations-generic.cpp
+ ${adaptor_system_dir}/glib/callback-manager-glib.cpp
+ ${adaptor_system_dir}/glib/file-descriptor-monitor-glib.cpp
+ ${adaptor_system_dir}/glib/timer-impl-glib.cpp
${adaptor_system_dir}/linux/callback-manager-ecore.cpp
${adaptor_system_dir}/linux/file-descriptor-monitor-ecore.cpp
- ${adaptor_system_dir}/generic/shared-file-operations-generic.cpp
- ${adaptor_system_dir}/common/time-service.cpp
${adaptor_system_dir}/linux/system-factory-ecore.cpp
${adaptor_system_dir}/linux/timer-impl-ecore.cpp
)
/**
* Structure contains the callback function and control options
*/
-struct CallbackData
+struct GlibCallbackData
{
typedef gboolean (*CallbackFunction)(gpointer userData);
/**
* Constructor
*/
- CallbackData(CallbackBase* callback, bool hasReturnValue)
+ GlibCallbackData(CallbackBase* callback, bool hasReturnValue)
: mCallback(callback),
mHasReturnValue(hasReturnValue)
{
{
mSource = g_idle_source_new();
g_source_set_priority(mSource, G_PRIORITY_HIGH_IDLE);
- g_source_set_callback(mSource, &CallbackData::IdleCallback, this, nullptr); // No destroyNotify
+ g_source_set_callback(mSource, &GlibCallbackData::IdleCallback, this, nullptr); // No destroyNotify
g_source_attach(mSource, context);
}
}
/**
* Destructor
*/
- ~CallbackData()
+ ~GlibCallbackData()
{
g_source_destroy(mSource);
g_source_unref(mSource);
static gboolean IdleCallback(gpointer userData)
{
- gboolean retValue = G_SOURCE_REMOVE;
- CallbackData* callbackData = static_cast<CallbackData*>(userData);
+ gboolean retValue = G_SOURCE_REMOVE;
+ GlibCallbackData* callbackData = static_cast<GlibCallbackData*>(userData);
if(callbackData->mHasReturnValue)
{
for(CallbackList::iterator iter = mCallbackContainer.begin(); iter != mCallbackContainer.end(); ++iter)
{
- CallbackData* data = (*iter);
+ GlibCallbackData* data = (*iter);
delete data;
}
return false;
}
- CallbackData* callbackData = new CallbackData(callback, hasReturnValue);
+ GlibCallbackData* callbackData = new GlibCallbackData(callback, hasReturnValue);
// To inform the manager a callback has finished, we get it to call RemoveCallbackFromContainer
callbackData->mRemoveFromContainerFunction = MakeCallback(this, &GlibCallbackManager::RemoveCallbackFromContainer);
it != endIt;
++it)
{
- CallbackData* data = *it;
+ GlibCallbackData* data = *it;
if(data->mCallback == callback)
{
return false;
}
- CallbackData* callbackData = new CallbackData(callback, true);
+ GlibCallbackData* callbackData = new GlibCallbackData(callback, true);
// To inform the manager a callback has finished, we get it to call RemoveCallbackFromContainer
callbackData->mRemoveFromContainerFunction = MakeCallback(this, &GlibCallbackManager::RemoveCallbackFromContainer);
RemoveIdleCallback(callback);
}
-void GlibCallbackManager::RemoveCallbackFromContainer(CallbackData* callbackData)
+void GlibCallbackManager::RemoveCallbackFromContainer(GlibCallbackData* callbackData)
{
mCallbackContainer.remove(callbackData);
}
{
namespace Adaptor
{
-struct CallbackData;
+struct GlibCallbackData;
/**
* @brief Glib callback manager used to install call backs in the applications main loop.
* Always called from main thread
* @param callbackData callback data
*/
- void RemoveCallbackFromContainer(CallbackData* callbackData);
+ void RemoveCallbackFromContainer(GlibCallbackData* callbackData);
// Undefined
GlibCallbackManager(const GlibCallbackManager&) = delete;
GlibCallbackManager& operator=(GlibCallbackManager&) = delete;
private:
- typedef std::list<CallbackData*> CallbackList; ///< list of callbacks installed
+ typedef std::list<GlibCallbackData*> CallbackList; ///< list of callbacks installed
bool mRunning; ///< flag is set to true if when running
CallbackList mCallbackContainer; ///< container of live callbacks
/**
* Structure contains the callback function and control options
*/
-struct CallbackData
+struct EcoreCallbackData
{
/**
* Constructor
*/
- CallbackData(CallbackBase* callback, bool hasReturnValue)
+ EcoreCallbackData(CallbackBase* callback, bool hasReturnValue)
: mCallback(callback),
mRemoveFromContainerFunction(NULL),
mIdler(NULL),
/**
* Destructor
*/
- ~CallbackData()
+ ~EcoreCallbackData()
{
delete mCallback;
delete mRemoveFromContainerFunction;
*/
Eina_Bool IdleCallback(void* data)
{
- Eina_Bool ret = ECORE_CALLBACK_CANCEL; // CALLBACK Cancel will delete the idler so we don't need to call ecore_idler_del
- CallbackData* callbackData = static_cast<CallbackData*>(data);
+ Eina_Bool ret = ECORE_CALLBACK_CANCEL; // CALLBACK Cancel will delete the idler so we don't need to call ecore_idler_del
+ EcoreCallbackData* callbackData = static_cast<EcoreCallbackData*>(data);
if(callbackData->mHasReturnValue)
{
return false;
}
- CallbackData* callbackData = new CallbackData(callback, hasReturnValue);
+ EcoreCallbackData* callbackData = new EcoreCallbackData(callback, hasReturnValue);
callbackData->mRemoveFromContainerFunction = MakeCallback(this, &EcoreCallbackManager::RemoveCallbackFromContainer);
it != endIt;
++it)
{
- CallbackData* data = *it;
+ EcoreCallbackData* data = *it;
if(data->mCallback == callback)
{
return false;
}
- CallbackData* callbackData = new CallbackData(callback, true);
+ EcoreCallbackData* callbackData = new EcoreCallbackData(callback, true);
callbackData->mRemoveFromContainerFunction = MakeCallback(this, &EcoreCallbackManager::RemoveCallbackFromContainer);
it != endIt;
++it)
{
- CallbackData* data = *it;
+ EcoreCallbackData* data = *it;
if(data->mCallback == callback)
{
}
}
-void EcoreCallbackManager::RemoveCallbackFromContainer(CallbackData* callbackData)
+void EcoreCallbackManager::RemoveCallbackFromContainer(EcoreCallbackData* callbackData)
{
mCallbackContainer.remove(callbackData);
}
// always called from main thread
for(CallbackList::iterator iter = mCallbackContainer.begin(); iter != mCallbackContainer.end(); ++iter)
{
- CallbackData* data = (*iter);
+ EcoreCallbackData* data = (*iter);
if(data->mIdler)
{
{
namespace Adaptor
{
-struct CallbackData;
+struct EcoreCallbackData;
/**
* Ecore interface to install call backs in the applications main loop.
* Always called from main thread
* @param callbackData callback data
*/
- void RemoveCallbackFromContainer(CallbackData* callbackData);
+ void RemoveCallbackFromContainer(EcoreCallbackData* callbackData);
/**
* @brief Remove a standard call back from ecore
* Always called from main thread
* @param callbackData callback data
*/
- void RemoveStandardCallback(CallbackData* callbackData);
+ void RemoveStandardCallback(EcoreCallbackData* callbackData);
// Undefined
EcoreCallbackManager(const EcoreCallbackManager&) = delete;
EcoreCallbackManager& operator=(EcoreCallbackManager&) = delete;
private:
- typedef std::list<CallbackData*> CallbackList;
+ typedef std::list<EcoreCallbackData*> CallbackList;
bool mRunning; ///< flag is set to true if when running
CallbackList mCallbackContainer; ///< container of live idle callbacks
#include <dali/internal/system/linux/system-factory-ecore.h>
// INTERNAL HEADERS
+#include <dali/internal/adaptor/common/framework-factory.h>
+#include <dali/internal/system/glib/callback-manager-glib.h>
+#include <dali/internal/system/glib/file-descriptor-monitor-glib.h>
+#include <dali/internal/system/glib/timer-impl-glib.h>
#include <dali/internal/system/linux/callback-manager-ecore.h>
#include <dali/internal/system/linux/file-descriptor-monitor-ecore.h>
#include <dali/internal/system/linux/timer-impl-ecore.h>
{
std::unique_ptr<CallbackManager> SystemFactoryEcore::CreateCallbackManager()
{
- return Utils::MakeUnique<EcoreCallbackManager>();
+ auto backend = Dali::Internal::Adaptor::GetFrameworkFactory()->GetFrameworkBackend();
+ if(backend == FrameworkBackend::GLIB)
+ {
+ return Utils::MakeUnique<GlibCallbackManager>();
+ }
+ else
+ {
+ return Utils::MakeUnique<EcoreCallbackManager>();
+ }
}
std::unique_ptr<FileDescriptorMonitor> SystemFactoryEcore::CreateFileDescriptorMonitor(int fileDescriptor, CallbackBase* callback, int eventBitmask)
{
- return Utils::MakeUnique<FileDescriptorMonitorEcore>(fileDescriptor, callback, eventBitmask);
+ auto backend = Dali::Internal::Adaptor::GetFrameworkFactory()->GetFrameworkBackend();
+ if(backend == FrameworkBackend::GLIB)
+ {
+ return Utils::MakeUnique<FileDescriptorMonitorGlib>(fileDescriptor, callback, eventBitmask);
+ }
+ else
+ {
+ return Utils::MakeUnique<FileDescriptorMonitorEcore>(fileDescriptor, callback, eventBitmask);
+ }
}
TimerPtr SystemFactoryEcore::CreateTimer(uint32_t milliSec)
{
- return TimerEcore::New(milliSec);
+ auto backend = Dali::Internal::Adaptor::GetFrameworkFactory()->GetFrameworkBackend();
+ if(backend == FrameworkBackend::GLIB)
+ {
+ return TimerGlib::New(milliSec);
+ }
+ else
+ {
+ return TimerEcore::New(milliSec);
+ }
}
std::unique_ptr<SystemFactory> GetSystemFactory()
*
*/
+// EXTERNAL_HEADERS
+#include <Ecore_Wl2.h>
+#include <dali/integration-api/debug.h>
+
// INTERNAL HEADERS
#include <dali/devel-api/adaptor-framework/keyboard.h>
+#include <dali/internal/adaptor/common/framework-factory.h>
#include <dali/internal/system/common/time-service.h>
#include <dali/internal/window-system/common/window-system.h>
-// EXTERNAL_HEADERS
-#include <Ecore_Wl2.h>
-#include <dali/integration-api/debug.h>
-
#define START_DURATION_CHECK() \
uint32_t durationMilliSeconds = static_cast<uint32_t>(-1); \
uint32_t startTime, endTime; \
void Initialize()
{
- ecore_wl2_init();
+ auto backend = Dali::Internal::Adaptor::GetFrameworkFactory()->GetFrameworkBackend();
+ if(backend == FrameworkBackend::DEFAULT)
+ {
+ ecore_wl2_init();
+ }
}
void Shutdown()
{
- ecore_wl2_shutdown();
+ auto backend = Dali::Internal::Adaptor::GetFrameworkFactory()->GetFrameworkBackend();
+ if(backend == FrameworkBackend::DEFAULT)
+ {
+ ecore_wl2_shutdown();
+ }
}
void GetScreenSize(int32_t& width, int32_t& height)
{
- if(gScreenWidth == 0 || gScreenHeight == 0)
+ auto backend = Dali::Internal::Adaptor::GetFrameworkFactory()->GetFrameworkBackend();
+ if(backend == FrameworkBackend::DEFAULT)
{
- Ecore_Wl2_Display* display = ecore_wl2_display_connect(NULL);
- if(display)
+ if(gScreenWidth == 0 || gScreenHeight == 0)
{
- START_DURATION_CHECK();
- ecore_wl2_display_screen_size_get(display, &gScreenWidth, &gScreenHeight);
- FINISH_DURATION_CHECK("ecore_wl2_display_screen_size_get");
-
- DALI_ASSERT_ALWAYS((gScreenWidth > 0) && "screen width is 0");
- DALI_ASSERT_ALWAYS((gScreenHeight > 0) && "screen height is 0");
+ Ecore_Wl2_Display* display = ecore_wl2_display_connect(NULL);
+ if(display)
+ {
+ START_DURATION_CHECK();
+ ecore_wl2_display_screen_size_get(display, &gScreenWidth, &gScreenHeight);
+ FINISH_DURATION_CHECK("ecore_wl2_display_screen_size_get");
+
+ DALI_ASSERT_ALWAYS((gScreenWidth > 0) && "screen width is 0");
+ DALI_ASSERT_ALWAYS((gScreenHeight > 0) && "screen height is 0");
+ }
}
}
width = gScreenWidth;
void UpdateScreenSize()
{
- Ecore_Wl2_Display* display = ecore_wl2_display_connect(NULL);
- if(display)
+ auto backend = Dali::Internal::Adaptor::GetFrameworkFactory()->GetFrameworkBackend();
+ if(backend == FrameworkBackend::DEFAULT)
{
- START_DURATION_CHECK();
- ecore_wl2_display_screen_size_get(display, &gScreenWidth, &gScreenHeight);
- FINISH_DURATION_CHECK("ecore_wl2_display_screen_size_get");
+ Ecore_Wl2_Display* display = ecore_wl2_display_connect(NULL);
+ if(display)
+ {
+ START_DURATION_CHECK();
+ ecore_wl2_display_screen_size_get(display, &gScreenWidth, &gScreenHeight);
+ FINISH_DURATION_CHECK("ecore_wl2_display_screen_size_get");
+ }
}
}
bool SetKeyboardRepeatInfo(float rate, float delay)
{
- Ecore_Wl2_Input* input = ecore_wl2_input_default_input_get(ecore_wl2_connected_display_get(NULL));
- return ecore_wl2_input_keyboard_repeat_set(input, static_cast<double>(rate), static_cast<double>(delay));
+ auto backend = Dali::Internal::Adaptor::GetFrameworkFactory()->GetFrameworkBackend();
+ if(backend == FrameworkBackend::DEFAULT)
+ {
+ Ecore_Wl2_Input* input = ecore_wl2_input_default_input_get(ecore_wl2_connected_display_get(NULL));
+ return ecore_wl2_input_keyboard_repeat_set(input, static_cast<double>(rate), static_cast<double>(delay));
+ }
}
bool GetKeyboardRepeatInfo(float& rate, float& delay)
{
- Ecore_Wl2_Input* input = ecore_wl2_input_default_input_get(ecore_wl2_connected_display_get(NULL));
- double rateVal, delayVal;
- bool ret = ecore_wl2_input_keyboard_repeat_get(input, &rateVal, &delayVal);
- rate = static_cast<float>(rateVal);
- delay = static_cast<float>(delayVal);
+ auto backend = Dali::Internal::Adaptor::GetFrameworkFactory()->GetFrameworkBackend();
+ if(backend == FrameworkBackend::DEFAULT)
+ {
+ Ecore_Wl2_Input* input = ecore_wl2_input_default_input_get(ecore_wl2_connected_display_get(NULL));
+ double rateVal, delayVal;
+ bool ret = ecore_wl2_input_keyboard_repeat_get(input, &rateVal, &delayVal);
+ rate = static_cast<float>(rateVal);
+ delay = static_cast<float>(delayVal);
- return ret;
+ return ret;
+ }
+ return false;
}
} // namespace WindowSystem
#include <dali/integration-api/debug.h>
#include <dali/integration-api/gl-abstraction.h>
-#ifdef ECORE_WAYLAND2
-#include <Ecore_Wl2.h>
-#else
-#include <Ecore_Wayland.h>
-#endif
-
#include <tbm_bufmgr.h>
#include <tbm_surface_internal.h>
float xres, yres;
// 1 inch = 25.4 millimeters
-#ifdef ECORE_WAYLAND2
- // TODO: Application should set dpi value in wayland2
xres = 96;
yres = 96;
-#else
- xres = ecore_wl_dpi_get();
- yres = ecore_wl_dpi_get();
-#endif
dpiHorizontal = int(xres + 0.5f); // rounding
dpiVertical = int(yres + 0.5f);
projects / platform / core / uifw / dali-adaptor.git / commitdiff