"src/service/wrt_service_lifecycle_file.h",
"src/service/wrt_service_manager.cc",
"src/service/wrt_service_manager.h",
+ "src/service/wrt_service_app_data.cc",
+ "src/service/wrt_service_app_data.h",
]
wrt_lib_sources_mde = [
#include "wrt/src/common/constants.h"
#include "wrt/src/common/tv/wrt_lib_wrapper.h"
#include "wrt/src/service/wrt_service.h"
+#include "wrt/src/service/wrt_service_app_data.h"
#include "wrt/src/service/wrt_service_manager.h"
namespace wrt {
const std::string& internal_id, const std::string& file_path) const {
if (WRTServiceManager::Get()->IsStandaloneService()) {
auto service_id = ApplicationData::GetServiceID(internal_id);
- auto pkg_path = WRTService::GetAppPkgPath(internal_id);
+ auto pkg_path = WRTServiceAppData::GetInstance().GetAppPkgPath(internal_id);
auto decrypted_src = EncryptedFileHandler::DecryptFile(
service_id, pkg_path, base::FilePath(file_path));
std::vector<std::string> TVExtension::GetWasmFiles(
const std::string& app_id) const {
- auto pkg_path = WRTService::GetAppPkgPath(app_id);
+ auto pkg_path = WRTServiceAppData::GetInstance().GetAppPkgPath(app_id);
auto res_path = base::FilePath(pkg_path).Append("res");
LOG(INFO) << "App's res path : " << res_path;
base::FileEnumerator enumerator(res_path, true /* recursive */,
}
void TVExtension::ServiceMount(const std::string& internal_id) const {
- auto pkg_path = WRTService::GetAppPkgPath(internal_id);
+ auto pkg_path = WRTServiceAppData::GetInstance().GetAppPkgPath(internal_id);
auto tmg_path = GetTmgPath(pkg_path);
if (!base::PathExists(tmg_path) ||
tmg_mounter.find(internal_id) != tmg_mounter.end()) {
return 0;
}
LOG(INFO) << "token : " << token;
- WRTServiceManager::Get()->SendOspAccessToken(token);
+ WRTServiceAppData::GetInstance().SetOspAccessToken(token);
return 0;
};
if (SSO_TRUE !=
callback,
nullptr)) {
LOG(ERROR) << "sso_request_access_token() has failed";
- WRTServiceManager::Get()->SendOspAccessToken(kDefaultSsoError);
+ WRTServiceAppData::GetInstance().SetOspAccessToken(
+ kDefaultSsoError);
}
}, client_id, secret));
}
#include "wrt/src/common/privilege.h"
#include "wrt/src/common/wrt_service_message_channel.h"
#include "wrt/src/service/wrt_service.h"
+#include "wrt/src/service/wrt_service_app_data.h"
#include "wrt/src/service/wrt_service_lifecycle_file.h"
#include "wrt/src/service/wrt_service_manager.h"
std::string WebRuntime::GetStartServiceFile(
const std::string& internal_id) const {
base::AutoLock lock(service_lock);
- auto app_data = WRTServiceManager::Get()->GetApplicationData(internal_id);
+ auto app_data =
+ WRTServiceAppData::GetInstance().GetApplicationData(internal_id);
return app_data->GetStartServiceFile();
}
std::vector<std::string> WebRuntime::GetPrivileges(
const std::string& internal_id) const {
base::AutoLock lock(service_lock);
- auto app_data = WRTServiceManager::Get()->GetApplicationData(internal_id);
+ auto app_data =
+ WRTServiceAppData::GetInstance().GetApplicationData(internal_id);
auto& info = app_data->permissions_info().GetAPIPermissions();
return std::vector<std::string>(info.begin(), info.end());
}
std::string WebRuntime::ResolveVirtualRoot(const std::string& internal_id,
const std::string& alias) const {
base::AutoLock lock(service_lock);
- auto app_data = WRTServiceManager::Get()->GetApplicationData(internal_id);
+ auto app_data =
+ WRTServiceAppData::GetInstance().GetApplicationData(internal_id);
if (alias == kAliasWgtPackage) {
return app_data->application_path();
} else if (alias == kAliasWgtPrivate) {
std::string WebRuntime::GetPkgApiVersion(const std::string& internal_id) const {
base::AutoLock lock(service_lock);
- auto app_data = WRTServiceManager::Get()->GetApplicationData(internal_id);
+ auto app_data =
+ WRTServiceAppData::GetInstance().GetApplicationData(internal_id);
return app_data->tizen_application_info().required_version();
}
void WebRuntime::SetServiceAppId(const std::string& internal_id) const {
base::AutoLock lock(service_lock);
thread_local static WRTServiceLifeCycleFile life_cycle_file(internal_id);
- WRTServiceManager::Get()->SetAppIdByTid(
+ WRTServiceAppData::GetInstance().SetAppIdByTid(
ApplicationData::GetServiceID(internal_id));
}
std::string WebRuntime::GetPackageId(const std::string& internal_id) const {
base::AutoLock lock(service_lock);
- auto app_data = WRTServiceManager::Get()->GetApplicationData(internal_id);
+ auto app_data =
+ WRTServiceAppData::GetInstance().GetApplicationData(internal_id);
return app_data->GetPackageID();
}
std::string WebRuntime::GetMainAppId(const std::string& internal_id) const {
- auto app_data = WRTServiceManager::Get()->GetApplicationData(internal_id);
+ auto app_data =
+ WRTServiceAppData::GetInstance().GetApplicationData(internal_id);
return app_data ? app_data->tizen_application_info().id() : std::string();
}
}
// static
-std::string WRTService::GetAppPkgPath(const std::string& internal_id) {
- return WRTServiceManager::Get()->GetAppPkgPath(internal_id);
-}
-
-// static
bool WRTService::StartService(const std::string internal_id) {
InterProcessCommunication ipc;
std::string content;
static void FinishStartingService(const std::string& internal_id);
static ServiceType GetServiceModel();
- static std::string GetAppPkgPath(const std::string& internal_id);
private:
static std::string current_application_;
--- /dev/null
+// Copyright 2024 Samsung Electronics. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "wrt/src/service/wrt_service_app_data.h"
+
+#include "base/synchronization/lock.h"
+#include "base/threading/platform_thread.h"
+#include "wrt/src/base/dlog_util.h"
+
+namespace wrt {
+
+static WRTServiceAppData* instance = nullptr;
+base::Lock service_app_data_lock;
+base::Lock application_data_lock;
+
+// static
+WRTServiceAppData& WRTServiceAppData::GetInstance() {
+ if (!instance) {
+ base::AutoLock lock(service_app_data_lock);
+ if (!instance) // double check to avoid create instance again
+ instance = new WRTServiceAppData;
+ }
+ return *instance;
+}
+
+std::string WRTServiceAppData::GetAppIdByTid() {
+ auto tid = static_cast<int>(base::PlatformThread::CurrentId());
+ base::AutoLock lock(service_app_data_lock);
+ return app_tid_map_[tid];
+}
+
+void WRTServiceAppData::SetAppIdByTid(const std::string& app_id) {
+ auto tid = static_cast<int>(base::PlatformThread::CurrentId());
+ base::AutoLock lock(service_app_data_lock);
+ app_tid_map_[tid] = app_id;
+}
+
+std::string WRTServiceAppData::GetAppControlData(std::string& app_id) {
+ base::AutoLock lock(service_app_data_lock);
+ return app_control_data_[app_id];
+}
+
+void WRTServiceAppData::SetAppcontrolData(const std::string& app_id,
+ const std::string& encoded_data) {
+ base::AutoLock lock(service_app_data_lock);
+ app_control_data_[app_id] = encoded_data;
+}
+
+std::string WRTServiceAppData::GetBuiltinService(
+ const std::string& internal_id) {
+ base::AutoLock lock(service_app_data_lock);
+ return builtin_service_[internal_id];
+}
+
+void WRTServiceAppData::SetBuiltinService(const std::string& internal_id,
+ const std::string& service_name) {
+ base::AutoLock lock(service_app_data_lock);
+ builtin_service_[internal_id] = service_name;
+}
+
+std::string WRTServiceAppData::GetAppPkgPath(const std::string& internal_id) {
+ base::AutoLock lock(service_app_data_lock);
+ return pkg_path_[internal_id];
+}
+
+void WRTServiceAppData::SetAppPkgPath(const std::string& internal_id,
+ const std::string& pkg_path) {
+ base::AutoLock lock(service_app_data_lock);
+ pkg_path_[internal_id] = pkg_path;
+}
+
+std::string WRTServiceAppData::GetServiceStatus(
+ const std::string& internal_id) {
+ base::AutoLock lock(service_app_data_lock);
+ return status_services_[internal_id];
+}
+
+void WRTServiceAppData::SetServiceStatus(const std::string& internal_id,
+ const std::string& status) {
+ base::AutoLock lock(service_app_data_lock);
+ status_services_[internal_id] = status;
+}
+
+ApplicationData* WRTServiceAppData::GetApplicationData(
+ const std::string& internal_id) {
+ base::AutoLock lock(application_data_lock);
+ ApplicationData* app_data = nullptr;
+ if (!application_data_map_[internal_id]) {
+ auto service_id = ApplicationData::GetServiceID(internal_id);
+ auto pkg_path = GetAppPkgPath(internal_id);
+ app_data = ApplicationData::Create(service_id, pkg_path);
+ app_data->Initialize();
+ application_data_map_[internal_id] =
+ std::unique_ptr<ApplicationData>(app_data);
+ } else {
+ app_data = application_data_map_[internal_id].get();
+ }
+ return app_data;
+}
+
+void WRTServiceAppData::SetOspAccessToken(const std::string& token) {
+ base::AutoLock lock(service_app_data_lock);
+ message_queue_.push(std::make_pair("OspAccessToken", token));
+}
+
+std::pair<std::string, std::string> WRTServiceAppData::GetOspAccessToken() {
+ std::pair<std::string, std::string> message;
+ if (!message_queue_.empty()) {
+ base::AutoLock lock(service_app_data_lock);
+ message = message_queue_.front();
+ message_queue_.pop();
+ }
+ return message;
+}
+
+void WRTServiceAppData::EraseBuiltinServiceApp(const std::string& internal_id) {
+ base::AutoLock lock(service_app_data_lock);
+ builtin_service_.erase(internal_id);
+}
+
+void WRTServiceAppData::EraseApplicationData(const std::string& internal_id) {
+ base::AutoLock lock(application_data_lock);
+ application_data_map_.erase(internal_id);
+}
+
+void WRTServiceAppData::EraseServiceAppDataMaps(
+ const std::string& internal_id) {
+ base::AutoLock lock(service_app_data_lock);
+ status_services_.erase(internal_id);
+ app_control_data_.erase(internal_id);
+ pkg_path_.erase(internal_id);
+ EraseApplicationData(internal_id);
+
+ auto tid = static_cast<int>(base::PlatformThread::CurrentId());
+ app_tid_map_.erase(tid);
+}
+
+bool WRTServiceAppData::IsServiceAppEmpty() {
+ if (status_services_.empty() && builtin_service_.empty())
+ return true;
+ return false;
+}
+
+} // namespace wrt
--- /dev/null
+// Copyright 2024 Samsung Electronics. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BROWSER_WRT_SERVICE_APP_DATA_H_
+#define BROWSER_WRT_SERVICE_APP_DATA_H_
+
+#include <map>
+#include <memory>
+#include <queue>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include "uv.h"
+#include "wrt/src/common/application_data.h"
+
+namespace wrt {
+
+class WRTServiceAppData {
+ public:
+ WRTServiceAppData() {}
+ ~WRTServiceAppData() {}
+
+ static WRTServiceAppData& GetInstance();
+ void EraseApplicationData(const std::string& internal_id);
+ void EraseBuiltinServiceApp(const std::string& internal_id);
+ void EraseServiceAppDataMaps(const std::string& internal_id);
+ std::string GetAppIdByTid();
+ void SetAppIdByTid(const std::string& app_id);
+ std::string GetAppControlData(std::string& app_id);
+ void SetAppcontrolData(const std::string& app_id,
+ const std::string& encoded_bundle);
+ std::string GetBuiltinService(const std::string& internal_id);
+ void SetBuiltinService(const std::string& internal_id,
+ const std::string& service_name);
+ std::string GetAppPkgPath(const std::string& internal_id);
+ void SetAppPkgPath(const std::string& internal_id,
+ const std::string& pkg_path);
+ std::string GetServiceStatus(const std::string& internal_id);
+ void SetServiceStatus(const std::string& internal_id,
+ const std::string& status);
+
+ ApplicationData* GetApplicationData(const std::string& internal_id);
+
+ void SetOspAccessToken(const std::string& token);
+ std::pair<std::string, std::string> GetOspAccessToken();
+ bool IsServiceAppEmpty();
+
+ private:
+ std::map<int, std::string> app_tid_map_;
+ std::unordered_map<std::string, std::string> app_control_data_;
+ std::unordered_map<std::string, std::string> builtin_service_;
+ std::unordered_map<std::string, std::string> pkg_path_;
+ std::unordered_map<std::string, std::string> status_services_;
+ std::unordered_map<std::string, std::unique_ptr<ApplicationData>>
+ application_data_map_;
+
+ std::queue<std::pair<std::string, std::string>> message_queue_;
+};
+
+} // namespace wrt
+
+#endif // BROWSER_WRT_SERVICE_MANAGER_H_
#include "wrt/src/base/string_utils.h"
#include "wrt/src/browser/api/wrt_api_web_runtime.h"
#include "wrt/src/service/wrt_service.h"
+#include "wrt/src/service/wrt_service_app_data.h"
#if BUILDFLAG(IS_TIZEN_TV)
#if TIZEN_VERSION_AT_LEAST(7, 0, 0)
LOG(ERROR) << "Argument should be {app_id}:{app_control_data}";
return;
}
- service_manager->SetAppcontrolData(appcontrol_argv[0], appcontrol_argv[1]);
+ WRTServiceAppData::GetInstance().SetAppcontrolData(appcontrol_argv[0],
+ appcontrol_argv[1]);
}
void DbusBuiltinService(const char*,
auto& file_path = service_argv[1];
auto service_id = ApplicationData::GetServiceID(internal_id);
- auto pkg_path = WRTService::GetAppPkgPath(internal_id);
+ auto pkg_path = WRTServiceAppData::GetInstance().GetAppPkgPath(internal_id);
auto decrypted_src = EncryptedFileHandler::DecryptFile(
service_id, pkg_path, base::FilePath(file_path));
}
bool WRTServiceManager::DidStartService(const std::string& internal_id) {
- return (status_services_[internal_id] == "started");
+ return (WRTServiceAppData::GetInstance().GetServiceStatus(internal_id) ==
+ "started");
}
void WRTServiceManager::StartService(const std::string& internal_id,
internal_id_ = internal_id;
uv_mutex_lock(&mutex_);
if (!DidStartService(internal_id)) {
- status_services_[internal_id] = "started";
+ WRTServiceAppData::GetInstance().SetServiceStatus(internal_id, "started");
}
prepared_to_start_services_.push_back(internal_id_);
ui_source_names_[internal_id_] = source_name;
- pkg_path_[internal_id_] = pkg_path;
+ WRTServiceAppData::GetInstance().SetAppPkgPath(internal_id, pkg_path);
uv_mutex_unlock(&mutex_);
+
uv_async_send(&handle_adder_);
}
}
void WRTServiceManager::FinalizeService(const std::string& internal_id) {
- uv_mutex_lock(&mutex_);
- status_services_.erase(internal_id);
- app_control_data_.erase(internal_id);
- pkg_path_.erase(internal_id);
- application_data_map_.erase(internal_id);
-
- auto tid = static_cast<int>(base::PlatformThread::CurrentId());
- app_tid_map_.erase(tid);
- uv_mutex_unlock(&mutex_);
-
+ WRTServiceAppData::GetInstance().EraseServiceAppDataMaps(internal_id);
SendMessage("KillLauncherProcess", internal_id.c_str());
}
const std::string& internal_id,
const std::string& pkg_path) {
internal_id_ = internal_id;
- uv_mutex_lock(&mutex_);
- pkg_path_[internal_id_] = pkg_path;
- builtin_service_[internal_id_] = service_name;
- uv_mutex_unlock(&mutex_);
+ WRTServiceAppData::GetInstance().SetAppPkgPath(internal_id, pkg_path);
+ WRTServiceAppData::GetInstance().SetBuiltinService(internal_id, service_name);
uv_async_send(&handle_builtin_);
}
switch (type) {
case AUL_START: {
auto encoded_bundle = ConvertEncodedBundle(bundle_data);
- Get()->SetAppcontrolData(app_id, encoded_bundle);
+ WRTServiceAppData::GetInstance().SetAppcontrolData(app_id,
+ encoded_bundle);
auto pkg_path = ApplicationData::GetPackagePath(app_id);
Get()->StartService(app_id, app_id, pkg_path);
break;
}
std::string WRTServiceManager::GetAppControlData(std::string& app_id) {
- return app_control_data_[app_id];
+ return WRTServiceAppData::GetInstance().GetAppControlData(app_id);
}
-void WRTServiceManager::SetAppcontrolData(const std::string& app_id,
- const std::string& encoded_data) {
- app_control_data_[app_id] = encoded_data;
-}
-
-std::string WRTServiceManager::GetAppPkgPath(const std::string& internal_id) {
- return pkg_path_[internal_id];
-}
void WRTServiceManager::DelayShutdown(int exit_count) {
// counter for terminating node process if no service
if (!wrt)
return false;
- uv_mutex_lock(&mutex_);
std::pair<std::string, std::string> message;
- if (!message_queue_.empty()) {
- message = message_queue_.front();
- message_queue_.pop();
- }
- uv_mutex_unlock(&mutex_);
+ message = WRTServiceAppData::GetInstance().GetOspAccessToken();
+
if (message.first.empty())
return false;
if (HandleMessageQueue())
return;
- if (status_services_.empty() && builtin_service_.empty()) {
+ if (WRTServiceAppData::GetInstance().IsServiceAppEmpty()) {
if (exit_count_) {
exit_count_--;
} else {
return is_running;
}
-std::string WRTServiceManager::GetAppIdByTid() {
- auto tid = static_cast<int>(base::PlatformThread::CurrentId());
- uv_mutex_lock(&mutex_);
- auto app_id = app_tid_map_[tid];
- uv_mutex_unlock(&mutex_);
- return app_id;
-}
-
-void WRTServiceManager::SetAppIdByTid(const std::string& app_id) {
- auto tid = static_cast<int>(base::PlatformThread::CurrentId());
- uv_mutex_lock(&mutex_);
- app_tid_map_[tid] = app_id;
- uv_mutex_unlock(&mutex_);
-}
-
ApplicationData* WRTServiceManager::GetApplicationData(
const std::string& internal_id) {
- uv_mutex_lock(&mutex_);
- ApplicationData* app_data = nullptr;
- if (!application_data_map_[internal_id]) {
- auto service_id = ApplicationData::GetServiceID(internal_id);
- auto pkg_path = GetAppPkgPath(internal_id);
- app_data = ApplicationData::Create(service_id, pkg_path);
- app_data->Initialize();
- application_data_map_[internal_id] =
- std::unique_ptr<ApplicationData>(app_data);
- } else {
- app_data = application_data_map_[internal_id].get();
- }
- uv_mutex_unlock(&mutex_);
- return app_data;
+ return WRTServiceAppData::GetInstance().GetApplicationData(internal_id);
}
bool WRTServiceManager::IsStandaloneService() {
std::string WRTServiceManager::GetRuntimeVariable(
const std::string& runtime_key) {
- auto app_id = GetAppIdByTid();
+ auto app_id = WRTServiceAppData::GetInstance().GetAppIdByTid();
if (runtime_key == "encoded_bundle") {
- return GetAppControlData(app_id);
+ return WRTServiceAppData::GetInstance().GetAppControlData(app_id);
} else if (runtime_key == "package_id") {
return GetApplicationData(app_id)->GetPackageID();
} else if (runtime_key == "application_id") {
}
}
-void WRTServiceManager::SendOspAccessToken(const std::string& token) {
- uv_mutex_lock(&mutex_);
- message_queue_.push(std::make_pair("OspAccessToken", token));
- uv_mutex_unlock(&mutex_);
-}
-
// static
void WRTServiceManager::OnServiceStarted(uv_async_t* handle) {
auto service_manager = WRTServiceManager::Get();
uv_mutex_lock(&service_manager->mutex_);
auto internal_id = service_manager->internal_id_;
- auto service_name = service_manager->builtin_service_[internal_id];
+ auto service_name =
+ WRTServiceAppData::GetInstance().GetBuiltinService(internal_id);
wrt->Emit("builtin-service", internal_id, service_name);
- service_manager->builtin_service_.erase(internal_id);
+ WRTServiceAppData::GetInstance().EraseBuiltinServiceApp(internal_id);
service_manager->DelayShutdown();
uv_mutex_unlock(&service_manager->mutex_);
}
void RunBuiltinService(const std::string& service_name,
const std::string& internal_id,
const std::string& pkg_path);
- void SendOspAccessToken(const std::string& token);
- void SetAppcontrolData(const std::string& app_id,
- const std::string& encoded_bundle);
+
void SetServiceModel(WRTService::ServiceType service_model);
void Shutdown();
WRTService::ServiceType GetServiceModel();
std::string GetAppControlData(std::string& app_id);
- std::string GetAppPkgPath(const std::string& internal_id);
std::string GetRuntimeVariable(const std::string& runtime_key);
std::string SendMessageAndWaitReply(const char* type, const char* argument);
- std::string GetAppIdByTid();
- void SetAppIdByTid(const std::string& app_id);
-
ApplicationData* GetApplicationData(const std::string& internal_id);
private:
std::vector<std::string> prepared_to_start_services_;
std::vector<std::string> prepared_to_stop_services_;
- std::map<int, std::string> app_tid_map_;
- std::unordered_map<std::string, std::string> app_control_data_;
- std::unordered_map<std::string, std::string> pkg_path_;
- std::unordered_map<std::string, std::string> builtin_service_;
std::unordered_map<std::string, std::string> ui_source_names_;
- std::unordered_map<std::string, std::string> status_services_;
- std::unordered_map<std::string, std::unique_ptr<ApplicationData>>
- application_data_map_;
wrt::InterProcessCommunication ipc_;
std::string internal_id_;
unsigned int exit_count_ = 120;
bool quit_requested_ = false;
int ppid_ = 0;
- std::queue<std::pair<std::string, std::string>> message_queue_;
};
} // namespace wrt
projects / platform / framework / web / chromium-efl.git / commitdiff