#define DALI_ADAPTOR_TEST_APPLICATION_H
/*
- * Copyright (c) 2023 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2019 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.
*/
// INTERNAL INCLUDES
-#include <dali/internal/adaptor/common/framework-factory.h>
#include "adaptor-test-adaptor-impl.h"
#include "test-application.h"
: TestApplication(surfaceWidth, surfaceHeight, horizontalDpi, verticalDpi)
{
Internal::Adaptor::Adaptor::SetAvailable();
- mFrameworkFactory = std::unique_ptr<Internal::Adaptor::FrameworkFactory>(Dali::Internal::Adaptor::CreateFrameworkFactory());
}
~AdaptorTestApplication()
{
}
-
- std::unique_ptr<Internal::Adaptor::FrameworkFactory> mFrameworkFactory;
};
} // namespace Dali
{
namespace Adaptor
{
-FrameworkFactory* gFrameworkFactory = nullptr;
-
-FrameworkFactoryAndroid::FrameworkFactoryAndroid()
-{
- gFrameworkFactory = this;
-}
-
-FrameworkFactoryAndroid::~FrameworkFactoryAndroid()
-{
- gFrameworkFactory = nullptr;
-}
-
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);
}
-FrameworkFactory* CreateFrameworkFactory()
-{
- return (new FrameworkFactoryAndroid());
-}
-
FrameworkFactory* GetFrameworkFactory()
{
- return gFrameworkFactory;
+ static std::unique_ptr<FrameworkFactory> frameworkFactory = nullptr;
+
+ if(!frameworkFactory)
+ {
+ frameworkFactory = Utils::MakeUnique<FrameworkFactoryAndroid>();
+ }
+ return frameworkFactory.get();
}
} // namespace Adaptor
class FrameworkFactoryAndroid : public FrameworkFactory
{
public:
- FrameworkFactoryAndroid();
- ~FrameworkFactoryAndroid();
-
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
{
-FrameworkFactory* gFrameworkFactory = nullptr;
-
-FrameworkFactoryAndroidJni::FrameworkFactoryAndroidJni()
-{
- gFrameworkFactory = this;
-}
-
-FrameworkFactoryAndroidJni::~FrameworkFactoryAndroidJni()
-{
- gFrameworkFactory = nullptr;
-}
-
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);
}
-FrameworkFactory* CreateFrameworkFactory()
-{
- return (new FrameworkFactoryAndroidJni());
-}
-
FrameworkFactory* GetFrameworkFactory()
{
- return gFrameworkFactory;
+ static std::unique_ptr<FrameworkFactory> frameworkFactory = nullptr;
+
+ if(!frameworkFactory)
+ {
+ frameworkFactory = Utils::MakeUnique<FrameworkFactoryAndroidJni>();
+ }
+ return frameworkFactory.get();
}
} // namespace Adaptor
class FrameworkFactoryAndroidJni : public FrameworkFactory
{
public:
- FrameworkFactoryAndroidJni();
- ~FrameworkFactoryAndroidJni();
-
std::unique_ptr<Framework> CreateFramework(FrameworkBackend frameworkType, Framework::Observer& observer, Framework::TaskObserver& taskObserver, int* argc, char*** argv, Framework::Type type, bool useUiThread) override;
};
{
if(!gPreInitializedApplication)
{
- char* retEnv = std::getenv("TIZEN_UI_THREAD");
- bool isUseUIThread = false;
+ char* retEnv = std::getenv("TIZEN_UI_THREAD");
+ bool isUseUIThread = false;
if(retEnv)
{
- std::string uiThreadEnv = retEnv;
+ std::string uiThreadEnv = retEnv;
std::string enabledString = "true";
if(uiThreadEnv == enabledString)
{
{
DALI_LOG_RELEASE_INFO("PRE_INITIALIZED with UI Threading");
gPreInitializedApplication->mUIThreadLoader = new UIThreadLoader(argc, argv);
- gPreInitializedApplication->mUIThreadLoader->Run([&]() { gPreInitializedApplication->CreateWindow(); });
+ gPreInitializedApplication->mUIThreadLoader->Run([&](){gPreInitializedApplication->CreateWindow();});
}
else
{
DALI_LOG_RELEASE_INFO("Only PRE_INITIALIZED");
gPreInitializedApplication->CreateWindow(); // Only create window
}
+
+
}
}
mLanguageChangedSignal(),
mRegionChangedSignal(),
mFramework(nullptr),
- mFrameworkFactory(nullptr),
mCommandLineOptions(nullptr),
mAdaptorBuilder(nullptr),
mAdaptor(nullptr),
}
mCommandLineOptions = new CommandLineOptions(argc, argv);
-
- mFrameworkFactory = std::unique_ptr<FrameworkFactory>(Dali::Internal::Adaptor::CreateFrameworkFactory());
- mFramework = mFrameworkFactory->CreateFramework(FrameworkBackend::DEFAULT, *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 Launchpad
class CommandLineOptions;
-class FrameworkFactory;
typedef Dali::Rect<int> PositionSize;
LowMemorySignalType mTaskLowMemorySignal;
DeviceOrientationChangedSignalType mTaskDeviceOrientationChangedSignal;
- std::unique_ptr<Framework> mFramework;
- std::unique_ptr<FrameworkFactory> mFrameworkFactory;
+ std::unique_ptr<Framework> mFramework;
CommandLineOptions* mCommandLineOptions;
SlotDelegate<Application> mSlotDelegate;
- UIThreadLoader* mUIThreadLoader;
+ UIThreadLoader* mUIThreadLoader;
static ApplicationPtr gPreInitializedApplication;
};
}
};
-/**
- * @brief Creates a framework factory
- */
-FrameworkFactory* CreateFrameworkFactory();
-
-/**
- * @brief Gets a framework factory
- */
-FrameworkFactory* GetFrameworkFactory();
+extern FrameworkFactory* GetFrameworkFactory();
} // namespace Adaptor
} // namespace Internal
{
namespace Adaptor
{
-FrameworkFactory* gFrameworkFactory = nullptr;
-
-FrameworkFactoryGlib::FrameworkFactoryGlib()
-{
- gFrameworkFactory = this;
-}
-
-FrameworkFactoryGlib::~FrameworkFactoryGlib()
-{
- gFrameworkFactory = nullptr;
-}
-
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);
}
-FrameworkFactory* CreateFrameworkFactory()
-{
- return (new FrameworkFactoryGlib());
-}
-
FrameworkFactory* GetFrameworkFactory()
{
- return gFrameworkFactory;
+ static std::unique_ptr<FrameworkFactory> frameworkFactory = nullptr;
+
+ if(!frameworkFactory)
+ {
+ frameworkFactory = Utils::MakeUnique<FrameworkFactoryGlib>();
+ }
+ return frameworkFactory.get();
}
} // namespace Adaptor
class FrameworkFactoryGlib : public FrameworkFactory
{
public:
- FrameworkFactoryGlib();
- ~FrameworkFactoryGlib();
-
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
{
-FrameworkFactory* gFrameworkFactory = nullptr;
-
-FrameworkFactoryLibuv::FrameworkFactoryLibuv()
-{
- gFrameworkFactory = this;
-}
-
-FrameworkFactoryLibuv::~FrameworkFactoryLibuv()
-{
- gFrameworkFactory = nullptr;
-}
-
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);
}
-FrameworkFactory* CreateFrameworkFactory()
-{
- return (new FrameworkFactoryLibuv());
-}
-
FrameworkFactory* GetFrameworkFactory()
{
- return gFrameworkFactory;
+ static std::unique_ptr<FrameworkFactory> frameworkFactory = nullptr;
+
+ if(!frameworkFactory)
+ {
+ frameworkFactory = Utils::MakeUnique<FrameworkFactoryLibuv>();
+ }
+ return frameworkFactory.get();
}
} // namespace Adaptor
class FrameworkFactoryLibuv : public FrameworkFactory
{
public:
- FrameworkFactoryLibuv();
- ~FrameworkFactoryLibuv();
-
std::unique_ptr<Framework> CreateFramework(FrameworkBackend frameworkType, Framework::Observer& observer, Framework::TaskObserver& taskObserver, int* argc, char*** argv, Framework::Type type, bool useUiThread) override;
};
class FrameworkFactoryMac : public FrameworkFactory
{
public:
- FrameworkFactoryMac();
- ~FrameworkFactoryMac();
-
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
{
-FrameworkFactory* gFrameworkFactory = nullptr;
-
-FrameworkFactoryMac::FrameworkFactoryMac()
-{
- gFrameworkFactory = this;
-}
-
-FrameworkFactoryMac::~FrameworkFactoryMac()
-{
- gFrameworkFactory = nullptr;
-}
-
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);
}
-FrameworkFactory* CreateFrameworkFactory()
-{
- return (new FrameworkFactoryMac());
-}
-
FrameworkFactory* GetFrameworkFactory()
{
- return gFrameworkFactory;
+ static std::unique_ptr<FrameworkFactory> frameworkFactory = nullptr;
+
+ if(!frameworkFactory)
+ {
+ frameworkFactory = Utils::MakeUnique<FrameworkFactoryMac>();
+ }
+ return frameworkFactory.get();
}
} // namespace Adaptor
{
namespace Adaptor
{
-FrameworkFactory* gFrameworkFactory = nullptr;
-
-FrameworkFactoryTizen::FrameworkFactoryTizen()
-{
- gFrameworkFactory = this;
-}
-
-FrameworkFactoryTizen::~FrameworkFactoryTizen()
-{
- gFrameworkFactory = nullptr;
-}
-
std::unique_ptr<Framework> FrameworkFactoryTizen::CreateFramework(FrameworkBackend backend, Framework::Observer& observer, Framework::TaskObserver& taskObserver, int* argc, char*** argv, Framework::Type type, bool useUiThread)
{
mBackend = backend;
}
}
-FrameworkFactory* CreateFrameworkFactory()
-{
- return (new FrameworkFactoryTizen());
-}
-
FrameworkFactory* GetFrameworkFactory()
{
- return gFrameworkFactory;
+ static std::unique_ptr<FrameworkFactory> frameworkFactory = nullptr;
+
+ if(!frameworkFactory)
+ {
+ frameworkFactory = Utils::MakeUnique<FrameworkFactoryTizen>();
+ }
+ return frameworkFactory.get();
}
} // namespace Adaptor
class FrameworkFactoryTizen : public FrameworkFactory
{
public:
- FrameworkFactoryTizen();
- ~FrameworkFactoryTizen();
-
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
}
private:
- FrameworkBackend mBackend{FrameworkBackend::DEFAULT};
+ FrameworkBackend mBackend;
};
} // namespace Adaptor
{
namespace Adaptor
{
-FrameworkFactory* gFrameworkFactory = nullptr;
-
-FrameworkFactoryUbuntu::FrameworkFactoryUbuntu()
-{
- gFrameworkFactory = this;
-}
-
-FrameworkFactoryUbuntu::~FrameworkFactoryUbuntu()
-{
- gFrameworkFactory = nullptr;
-}
-
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);
}
-FrameworkFactory* CreateFrameworkFactory()
-{
- return (new FrameworkFactoryUbuntu());
-}
-
FrameworkFactory* GetFrameworkFactory()
{
- return gFrameworkFactory;
+ static std::unique_ptr<FrameworkFactory> frameworkFactory = nullptr;
+
+ if(!frameworkFactory)
+ {
+ frameworkFactory = Utils::MakeUnique<FrameworkFactoryUbuntu>();
+ }
+ return frameworkFactory.get();
}
} // namespace Adaptor
class FrameworkFactoryUbuntu : public FrameworkFactory
{
public:
- FrameworkFactoryUbuntu();
- ~FrameworkFactoryUbuntu();
-
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
{
-FrameworkFactory* gFrameworkFactory = nullptr;
-
-FrameworkFactoryWin::FrameworkFactoryWin()
-{
- gFrameworkFactory = this;
-}
-
-FrameworkFactoryWin::~FrameworkFactoryWin()
-{
- gFrameworkFactory = nullptr;
-}
-
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);
}
-FrameworkFactory* CreateFrameworkFactory()
-{
- return (new FrameworkFactoryWin());
-}
-
FrameworkFactory* GetFrameworkFactory()
{
- return gFrameworkFactory;
+ static std::unique_ptr<FrameworkFactory> frameworkFactory = nullptr;
+
+ if(!frameworkFactory)
+ {
+ frameworkFactory = Utils::MakeUnique<FrameworkFactoryWin>();
+ }
+ return frameworkFactory.get();
}
} // namespace Adaptor
class FrameworkFactoryWin : public FrameworkFactory
{
public:
- FrameworkFactoryWin();
- ~FrameworkFactoryWin();
-
std::unique_ptr<Framework> CreateFramework(FrameworkBackend frameworkType, Framework::Observer& observer, Framework::TaskObserver& taskObserver, int* argc, char*** argv, Framework::Type type, bool useUiThread) override;
};