1 /*
2 * Copyright (c) 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 "quick_fix_manager_client.h"
17
18 #include "hilog_wrapper.h"
19 #include "hitrace_meter.h"
20 #include "if_system_ability_manager.h"
21 #include "iservice_registry.h"
22 #include "quick_fix_error_utils.h"
23 #include "quick_fix_load_callback.h"
24 #include "quick_fix_manager_proxy.h"
25 #include "system_ability_definition.h"
26
27 namespace OHOS {
28 namespace AAFwk {
29 namespace {
30 const int LOAD_SA_TIMEOUT_MS = 4 * 1000;
31 } // namespace
32
ApplyQuickFix(const std::vector<std::string> & quickFixFiles)33 int32_t QuickFixManagerClient::ApplyQuickFix(const std::vector<std::string> &quickFixFiles)
34 {
35 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
36 HILOG_DEBUG("function called.");
37
38 auto quickFixMgr = GetQuickFixMgrProxy();
39 if (quickFixMgr == nullptr) {
40 HILOG_ERROR("Get quick fix manager service failed.");
41 return QUICK_FIX_CONNECT_FAILED;
42 }
43
44 return quickFixMgr->ApplyQuickFix(quickFixFiles);
45 }
46
GetApplyedQuickFixInfo(const std::string & bundleName,ApplicationQuickFixInfo & quickFixInfo)47 int32_t QuickFixManagerClient::GetApplyedQuickFixInfo(const std::string &bundleName,
48 ApplicationQuickFixInfo &quickFixInfo)
49 {
50 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
51 HILOG_DEBUG("function called.");
52
53 auto quickFixMgr = GetQuickFixMgrProxy();
54 if (quickFixMgr == nullptr) {
55 HILOG_ERROR("Get quick fix manager service failed.");
56 return QUICK_FIX_CONNECT_FAILED;
57 }
58
59 return quickFixMgr->GetApplyedQuickFixInfo(bundleName, quickFixInfo);
60 }
61
GetQuickFixMgrProxy()62 sptr<IQuickFixManager> QuickFixManagerClient::GetQuickFixMgrProxy()
63 {
64 HILOG_DEBUG("function called.");
65 auto quickFixMgr = GetQuickFixMgr();
66 if (quickFixMgr != nullptr) {
67 HILOG_DEBUG("Quick fix manager has been started.");
68 return quickFixMgr;
69 }
70
71 if (!LoadQuickFixMgrService()) {
72 HILOG_ERROR("Load quick fix manager service failed.");
73 return nullptr;
74 }
75
76 quickFixMgr = GetQuickFixMgr();
77 if (quickFixMgr == nullptr || quickFixMgr->AsObject() == nullptr) {
78 HILOG_ERROR("Failed to get quick fix manager.");
79 return nullptr;
80 }
81
82 auto self = weak_from_this();
83 const auto &onClearProxyCallback = [self](const wptr<IRemoteObject> &remote) {
84 auto impl = self.lock();
85 if (impl && impl->quickFixMgr_ == remote) {
86 impl->ClearProxy();
87 }
88 };
89
90 sptr<QfmsDeathRecipient> recipient(new (std::nothrow) QfmsDeathRecipient(onClearProxyCallback));
91 quickFixMgr->AsObject()->AddDeathRecipient(recipient);
92
93 HILOG_DEBUG("function finished.");
94 return quickFixMgr;
95 }
96
ClearProxy()97 void QuickFixManagerClient::ClearProxy()
98 {
99 HILOG_DEBUG("function called.");
100 std::lock_guard<std::mutex> lock(mutex_);
101 quickFixMgr_ = nullptr;
102 }
103
OnRemoteDied(const wptr<IRemoteObject> & remote)104 void QuickFixManagerClient::QfmsDeathRecipient::OnRemoteDied([[maybe_unused]] const wptr<IRemoteObject> &remote)
105 {
106 if (proxy_ != nullptr) {
107 HILOG_ERROR("quick fix manager service died.");
108 proxy_(remote);
109 }
110 }
111
LoadQuickFixMgrService()112 bool QuickFixManagerClient::LoadQuickFixMgrService()
113 {
114 {
115 std::unique_lock<std::mutex> lock(loadSaMutex_);
116 loadSaFinished_ = false;
117 }
118
119 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
120 if (systemAbilityMgr == nullptr) {
121 HILOG_ERROR("Failed to get SystemAbilityManager.");
122 return false;
123 }
124
125 sptr<QuickFixLoadCallback> loadCallback = new (std::nothrow) QuickFixLoadCallback();
126 if (loadCallback == nullptr) {
127 HILOG_ERROR("Create load callback failed.");
128 return false;
129 }
130
131 auto ret = systemAbilityMgr->LoadSystemAbility(QUICK_FIX_MGR_SERVICE_ID, loadCallback);
132 if (ret != 0) {
133 HILOG_ERROR("Load system ability %{public}d failed with %{public}d.", QUICK_FIX_MGR_SERVICE_ID, ret);
134 return false;
135 }
136
137 {
138 std::unique_lock<std::mutex> lock(loadSaMutex_);
139 auto waitStatus = loadSaCondation_.wait_for(lock, std::chrono::milliseconds(LOAD_SA_TIMEOUT_MS),
140 [this]() {
141 return loadSaFinished_;
142 });
143 if (!waitStatus) {
144 HILOG_ERROR("Wait for load sa timeout.");
145 return false;
146 }
147 }
148
149 return true;
150 }
151
SetQuickFixMgr(const sptr<IRemoteObject> & remoteObject)152 void QuickFixManagerClient::SetQuickFixMgr(const sptr<IRemoteObject> &remoteObject)
153 {
154 std::lock_guard<std::mutex> lock(mutex_);
155 quickFixMgr_ = iface_cast<IQuickFixManager>(remoteObject);
156 }
157
GetQuickFixMgr()158 sptr<IQuickFixManager> QuickFixManagerClient::GetQuickFixMgr()
159 {
160 std::lock_guard<std::mutex> lock(mutex_);
161 return quickFixMgr_;
162 }
163
OnLoadSystemAbilitySuccess(const sptr<IRemoteObject> & remoteObject)164 void QuickFixManagerClient::OnLoadSystemAbilitySuccess(const sptr<IRemoteObject> &remoteObject)
165 {
166 SetQuickFixMgr(remoteObject);
167 std::unique_lock<std::mutex> lock(loadSaMutex_);
168 loadSaFinished_ = true;
169 loadSaCondation_.notify_one();
170 }
171
OnLoadSystemAbilityFail()172 void QuickFixManagerClient::OnLoadSystemAbilityFail()
173 {
174 SetQuickFixMgr(nullptr);
175 std::unique_lock<std::mutex> lock(loadSaMutex_);
176 loadSaFinished_ = true;
177 loadSaCondation_.notify_one();
178 }
179 } // namespace AAFwk
180 } // namespace OHOS
181