Ensure to delete FrameworkFactory after WindowSystem::Shutdown in the Application destructor
Change-Id: Ica037f38c15cdca60b57c3467b89f6129f4889ab
#define DALI_ADAPTOR_TEST_APPLICATION_H
/*
- * Copyright (c) 2019 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.
*/
// 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* GetFrameworkFactory()
+FrameworkFactory* CreateFrameworkFactory()
{
- static std::unique_ptr<FrameworkFactory> frameworkFactory = nullptr;
+ return (new FrameworkFactoryAndroid());
+}
- if(!frameworkFactory)
- {
- frameworkFactory = Utils::MakeUnique<FrameworkFactoryAndroid>();
- }
- return frameworkFactory.get();
+FrameworkFactory* GetFrameworkFactory()
+{
+ return gFrameworkFactory;
}
} // 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* GetFrameworkFactory()
+FrameworkFactory* CreateFrameworkFactory()
{
- static std::unique_ptr<FrameworkFactory> frameworkFactory = nullptr;
+ return (new FrameworkFactoryAndroidJni());
+}
- if(!frameworkFactory)
- {
- frameworkFactory = Utils::MakeUnique<FrameworkFactoryAndroidJni>();
- }
- return frameworkFactory.get();
+FrameworkFactory* GetFrameworkFactory()
+{
+ return gFrameworkFactory;
}
} // 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);
- mFramework = Dali::Internal::Adaptor::GetFrameworkFactory()->CreateFramework(FrameworkBackend::DEFAULT, *this, *this, argc, argv, applicationType, mUseUiThread);
+
+ mFrameworkFactory = std::unique_ptr<FrameworkFactory>(Dali::Internal::Adaptor::CreateFrameworkFactory());
+ mFramework = mFrameworkFactory->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<Framework> mFramework;
+ std::unique_ptr<FrameworkFactory> mFrameworkFactory;
CommandLineOptions* mCommandLineOptions;
SlotDelegate<Application> mSlotDelegate;
- UIThreadLoader* mUIThreadLoader;
+ UIThreadLoader* mUIThreadLoader;
static ApplicationPtr gPreInitializedApplication;
};
}
};
-extern FrameworkFactory* GetFrameworkFactory();
+/**
+ * @brief Creates a framework factory
+ */
+FrameworkFactory* CreateFrameworkFactory();
+
+/**
+ * @brief Gets a framework factory
+ */
+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* GetFrameworkFactory()
+FrameworkFactory* CreateFrameworkFactory()
{
- static std::unique_ptr<FrameworkFactory> frameworkFactory = nullptr;
+ return (new FrameworkFactoryGlib());
+}
- if(!frameworkFactory)
- {
- frameworkFactory = Utils::MakeUnique<FrameworkFactoryGlib>();
- }
- return frameworkFactory.get();
+FrameworkFactory* GetFrameworkFactory()
+{
+ return gFrameworkFactory;
}
} // 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* GetFrameworkFactory()
+FrameworkFactory* CreateFrameworkFactory()
{
- static std::unique_ptr<FrameworkFactory> frameworkFactory = nullptr;
+ return (new FrameworkFactoryLibuv());
+}
- if(!frameworkFactory)
- {
- frameworkFactory = Utils::MakeUnique<FrameworkFactoryLibuv>();
- }
- return frameworkFactory.get();
+FrameworkFactory* GetFrameworkFactory()
+{
+ return gFrameworkFactory;
}
} // 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* GetFrameworkFactory()
+FrameworkFactory* CreateFrameworkFactory()
{
- static std::unique_ptr<FrameworkFactory> frameworkFactory = nullptr;
+ return (new FrameworkFactoryMac());
+}
- if(!frameworkFactory)
- {
- frameworkFactory = Utils::MakeUnique<FrameworkFactoryMac>();
- }
- return frameworkFactory.get();
+FrameworkFactory* GetFrameworkFactory()
+{
+ return gFrameworkFactory;
}
} // 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* GetFrameworkFactory()
+FrameworkFactory* CreateFrameworkFactory()
{
- static std::unique_ptr<FrameworkFactory> frameworkFactory = nullptr;
+ return (new FrameworkFactoryTizen());
+}
- if(!frameworkFactory)
- {
- frameworkFactory = Utils::MakeUnique<FrameworkFactoryTizen>();
- }
- return frameworkFactory.get();
+FrameworkFactory* GetFrameworkFactory()
+{
+ return gFrameworkFactory;
}
} // 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 mBackend{FrameworkBackend::DEFAULT};
};
} // 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* GetFrameworkFactory()
+FrameworkFactory* CreateFrameworkFactory()
{
- static std::unique_ptr<FrameworkFactory> frameworkFactory = nullptr;
+ return (new FrameworkFactoryUbuntu());
+}
- if(!frameworkFactory)
- {
- frameworkFactory = Utils::MakeUnique<FrameworkFactoryUbuntu>();
- }
- return frameworkFactory.get();
+FrameworkFactory* GetFrameworkFactory()
+{
+ return gFrameworkFactory;
}
} // 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* GetFrameworkFactory()
+FrameworkFactory* CreateFrameworkFactory()
{
- static std::unique_ptr<FrameworkFactory> frameworkFactory = nullptr;
+ return (new FrameworkFactoryWin());
+}
- if(!frameworkFactory)
- {
- frameworkFactory = Utils::MakeUnique<FrameworkFactoryWin>();
- }
- return frameworkFactory.get();
+FrameworkFactory* GetFrameworkFactory()
+{
+ return gFrameworkFactory;
}
} // 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;
};