1 /*
2 * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "core/common/plugin_manager.h"
17
18 #include "base/log/log.h"
19 #include "base/utils/utils.h"
20
21 namespace OHOS::Ace {
22 std::shared_ptr<PluginUtils> PluginManager::pluginUtils_ = nullptr;
23 std::map<int64_t, RefPtr<PluginSubContainer>> PluginManager::pluginSubContainerMap_;
PluginManager()24 PluginManager::PluginManager() {}
25
~PluginManager()26 PluginManager::~PluginManager()
27 {
28 pluginSubContainerMap_.clear();
29 nonmatchedContainerMap_.clear();
30 }
31
AddPluginSubContainer(int64_t pluginId,const RefPtr<PluginSubContainer> & pluginSubContainer)32 void PluginManager::AddPluginSubContainer(int64_t pluginId, const RefPtr<PluginSubContainer>& pluginSubContainer)
33 {
34 std::lock_guard<std::mutex> lock(mutex_);
35 auto result = pluginSubContainerMap_.try_emplace(pluginId, pluginSubContainer);
36 if (!result.second) {
37 LOGW("already have pluginSubContainer of this instance");
38 }
39 }
40
RemovePluginSubContainer(int64_t pluginId)41 void PluginManager::RemovePluginSubContainer(int64_t pluginId)
42 {
43 std::lock_guard<std::mutex> lock(mutex_);
44 pluginSubContainerMap_.erase(pluginId);
45 }
46
GetPluginSubContainer(int64_t pluginId)47 RefPtr<PluginSubContainer> PluginManager::GetPluginSubContainer(int64_t pluginId)
48 {
49 std::lock_guard<std::mutex> lock(mutex_);
50 auto pluginSubContainer = pluginSubContainerMap_.find(pluginId);
51 if (pluginSubContainer != pluginSubContainerMap_.end()) {
52 return pluginSubContainer->second;
53 } else {
54 return nullptr;
55 }
56 }
57
AddNonmatchedContainer(const std::string & pluginKey,const RefPtr<PluginSubContainer> & pluginSubContainer)58 void PluginManager::AddNonmatchedContainer(
59 const std::string& pluginKey, const RefPtr<PluginSubContainer>& pluginSubContainer)
60 {
61 std::lock_guard<std::mutex> lock(nonmatchedContainerMutex_);
62 auto result = nonmatchedContainerMap_.try_emplace(pluginKey, pluginSubContainer);
63 if (!result.second) {
64 LOGW("already have pluginSubContainer of this key: %{public}s", pluginKey.c_str());
65 }
66 }
67
MatchPluginSubContainerWithPluginId(int64_t pluginId,const std::string & pluginKey)68 RefPtr<PluginSubContainer> PluginManager::MatchPluginSubContainerWithPluginId(
69 int64_t pluginId, const std::string& pluginKey)
70 {
71 std::lock_guard<std::mutex> lock(nonmatchedContainerMutex_);
72 auto iter = nonmatchedContainerMap_.find(pluginKey);
73 if (iter == nonmatchedContainerMap_.end()) {
74 LOGW("no subcontainer of key: %{private}s", pluginKey.c_str());
75 return nullptr;
76 }
77 auto pluginSubContainer = iter->second;
78 AddPluginSubContainer(pluginId, pluginSubContainer);
79 nonmatchedContainerMap_.erase(iter);
80 return pluginSubContainer;
81 }
82
GetPluginSubContainerId()83 int64_t PluginManager::GetPluginSubContainerId()
84 {
85 std::lock_guard<std::mutex> lock(mutex_);
86 if (pluginSubContainerMap_.empty()) {
87 return MIN_PLUGIN_SUBCONTAINER_ID;
88 }
89 return pluginSubContainerMap_.rbegin()->first + 1;
90 }
91
StartAbility(const std::string & bundleName,const std::string & abilityName,const std::string & params)92 int32_t PluginManager::StartAbility(
93 const std::string& bundleName, const std::string& abilityName, const std::string& params)
94 {
95 CHECK_NULL_RETURN(pluginUtils_, -1);
96 return pluginUtils_->StartAbility(bundleName, abilityName, params);
97 }
98
AddPluginParentContainer(int64_t pluginId,int32_t pluginParentContainerId)99 void PluginManager::AddPluginParentContainer(int64_t pluginId, int32_t pluginParentContainerId)
100 {
101 std::lock_guard<std::mutex> lock(parentContainerMutex_);
102 auto result = parentContainerMap_.try_emplace(pluginId, pluginParentContainerId);
103 if (!result.second) {
104 LOGW("already have pluginSubContainer of this instance, pluginId: %{public}ld", static_cast<long>(pluginId));
105 }
106 }
107
RemovePluginParentContainer(int64_t pluginId)108 void PluginManager::RemovePluginParentContainer(int64_t pluginId)
109 {
110 std::lock_guard<std::mutex> lock(parentContainerMutex_);
111 parentContainerMap_.erase(pluginId);
112 }
113
GetPluginParentContainerId(int64_t pluginId)114 int64_t PluginManager::GetPluginParentContainerId(int64_t pluginId)
115 {
116 std::lock_guard<std::mutex> lock(parentContainerMutex_);
117 auto result = parentContainerMap_.find(pluginId);
118 if (result != parentContainerMap_.end()) {
119 return result->second;
120 } else {
121 LOGW("ParentContainerId is empty.");
122 return 0;
123 }
124 }
125 } // namespace OHOS::Ace
126