1 /*
2 * Copyright (c) 2020-2023 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 "bundlems_slite_client.h"
17
18 #include "adapter.h"
19 #include "appexecfwk_errors.h"
20 #include "bundle_mgr_service.h"
21 #include "bundlems_log.h"
22 #include "cmsis_os2.h"
23 #include "ohos_mem_pool.h"
24 #include "samgr_lite.h"
25 #include "unistd.h"
26 #include "utils.h"
27 #include "want_utils.h"
28
29 namespace OHOS {
30 const unsigned int BMS_INSTALL_MSG = 100;
31 const unsigned int ERROR_SLEEP_TIMES = 300;
32 const unsigned int RETRY_TIMES = 10;
33 Bmsbuff *g_bmsbuff = nullptr;
34
Initialize() const35 bool BundleMsClient::Initialize() const
36 {
37 if (bmsProxy_ != nullptr) {
38 return true;
39 }
40 int retry = RETRY_TIMES;
41 while (retry--) {
42 IUnknown *iUnknown = SAMGR_GetInstance()->GetFeatureApi(BMS_SERVICE, BMS_SLITE_FEATURE);
43 if (iUnknown == nullptr) {
44 osDelay(ERROR_SLEEP_TIMES); // sleep 300ms
45 continue;
46 }
47
48 (void)iUnknown->QueryInterface(iUnknown, DEFAULT_VERSION, (void **)&bmsProxy_);
49 if (bmsProxy_ == nullptr) {
50 osDelay(ERROR_SLEEP_TIMES); // sleep 300ms
51 continue;
52 }
53
54 return true;
55 }
56
57 return false;
58 }
59
Install(const char * hapPath,const InstallParam * installParam,InstallerCallback installerCallback) const60 bool BundleMsClient::Install(const char *hapPath, const InstallParam *installParam,
61 InstallerCallback installerCallback) const
62 {
63 BundleMgrService *service = BundleMgrService::GetInstance();
64 if (service == nullptr) {
65 return false;
66 }
67 if (hapPath == nullptr) {
68 return false;
69 }
70 int len = strlen(hapPath);
71 if (len >= MAX_PATH_LEN) {
72 return false;
73 }
74 Bmsbuff *data = static_cast<Bmsbuff *>(AdapterMalloc(sizeof(Bmsbuff)));
75 if (data == nullptr) {
76 return false;
77 }
78 if (memcpy_s(data->bundleParameter, MAX_PATH_LEN, hapPath, len + 1) != 0) {
79 AdapterFree(data);
80 return false;
81 }
82 data->bundleInstallerCallback = installerCallback;
83 Request request = {
84 .msgId = BMS_INSTALL_MSG,
85 .len = sizeof(Bmsbuff),
86 .data = data,
87 .msgValue = 0,
88 };
89
90 int32_t ret = SAMGR_SendRequest(service->GetIdentity(), &request, nullptr);
91 return ret == ERR_OK;
92 }
93
Uninstall(const char * bundleName,const InstallParam * installParam,InstallerCallback installerCallback) const94 bool BundleMsClient::Uninstall (const char *bundleName, const InstallParam *installParam,
95 InstallerCallback installerCallback) const
96 {
97 BundleMgrService *service = BundleMgrService::GetInstance();
98 if (service == nullptr) {
99 return false;
100 }
101 if (bundleName == nullptr) {
102 return false;
103 }
104 int len = strlen(bundleName);
105 if (len >= MAX_PATH_LEN) {
106 return false;
107 }
108 Bmsbuff *data = static_cast<Bmsbuff *>(AdapterMalloc(sizeof(Bmsbuff)));
109 if (data == nullptr) {
110 return false;
111 }
112 if (memcpy_s(data->bundleParameter, MAX_PATH_LEN, bundleName, len + 1) != 0) {
113 AdapterFree(data);
114 return false;
115 }
116 data->bundleInstallerCallback = installerCallback;
117 Request request = {
118 .msgId = BMS_UNINSTALL_MSG,
119 .len = sizeof(Bmsbuff),
120 .data = data,
121 .msgValue = 0,
122 };
123 int32_t ret = SAMGR_SendRequest(service->GetIdentity(), &request, nullptr);
124 return ret == ERR_OK;
125 }
126
RegisterInstallerCallback(InstallerCallback installerCallback) const127 bool BundleMsClient::RegisterInstallerCallback (InstallerCallback installerCallback) const
128 {
129 BundleMgrService *service = BundleMgrService::GetInstance();
130 if (service == nullptr) {
131 return false;
132 }
133 if (installerCallback == nullptr) {
134 return false;
135 }
136 if (g_bmsbuff == nullptr) {
137 g_bmsbuff = reinterpret_cast<Bmsbuff *>(OhosMalloc(MEM_TYPE_APPFMK_LSRAM, sizeof(Bmsbuff)));
138 }
139 g_bmsbuff->bundleInstallerCallback = installerCallback;
140 Request request = {
141 .msgId = BMS_REGISTER_CALLBACK_MSG,
142 .len = 0,
143 .data = nullptr,
144 .msgValue = 0,
145 };
146 int32_t ret = SAMGR_SendRequest(service->GetIdentity(), &request, nullptr);
147 return ret == ERR_OK;
148 }
149
QueryAbilityInfo(const Want * want,AbilityInfo * abilityInfo) const150 uint8_t BundleMsClient::QueryAbilityInfo (const Want *want, AbilityInfo *abilityInfo) const
151 {
152 if ((want == nullptr) || (abilityInfo == nullptr)) {
153 return ERR_APPEXECFWK_QUERY_PARAMETER_ERROR;
154 }
155 if (!Initialize()) {
156 return ERR_APPEXECFWK_INSTALL_FAILED_INTERNAL_ERROR;
157 }
158 return bmsProxy_->QueryAbilityInfo(want, abilityInfo);
159 }
160
GetBundleInfo(const char * bundleName,int32_t flags,BundleInfo * bundleInfo) const161 uint8_t BundleMsClient::GetBundleInfo (const char *bundleName, int32_t flags, BundleInfo *bundleInfo) const
162 {
163 if ((bundleName == nullptr) || (bundleInfo == nullptr)) {
164 return ERR_APPEXECFWK_QUERY_PARAMETER_ERROR;
165 }
166 if (!Initialize()) {
167 HILOG_ERROR(HILOG_MODULE_AAFWK, "[BMS] Initialize is failed");
168 return ERR_APPEXECFWK_INSTALL_FAILED_INTERNAL_ERROR;
169 }
170 return bmsProxy_->GetBundleInfo(bundleName, flags, bundleInfo);
171 }
172
GetBundleInfos(int32_t flags,BundleInfo ** bundleInfos,int32_t * len) const173 uint8_t BundleMsClient::GetBundleInfos (int32_t flags, BundleInfo **bundleInfos, int32_t *len) const
174 {
175 if (bundleInfos == nullptr) {
176 return ERR_APPEXECFWK_QUERY_PARAMETER_ERROR;
177 }
178 if (len == nullptr) {
179 return ERR_APPEXECFWK_QUERY_NO_INFOS;
180 }
181 if (!Initialize()) {
182 HILOG_ERROR(HILOG_MODULE_AAFWK, "[BMS] Initialize is failed");
183 return ERR_APPEXECFWK_INSTALL_FAILED_INTERNAL_ERROR;
184 }
185 return bmsProxy_->GetBundleInfos(flags, bundleInfos, len);
186 }
187
GetInstallState(const char * bundleName,InstallState * installState,uint8_t * installProcess) const188 bool BundleMsClient::GetInstallState (const char *bundleName, InstallState *installState, uint8_t *installProcess) const
189 {
190 if ((bundleName == nullptr) || (installState == nullptr) || (installProcess == nullptr)) {
191 return ERR_APPEXECFWK_QUERY_PARAMETER_ERROR;
192 }
193 if (!Initialize()) {
194 return false;
195 }
196 return bmsProxy_->GetInstallState(bundleName, installState, installProcess);
197 }
198
GetBundleSize(const char * bundleName) const199 uint32_t BundleMsClient::GetBundleSize (const char *bundleName) const
200 {
201 if (bundleName == nullptr) {
202 return ERR_APPEXECFWK_QUERY_PARAMETER_ERROR;
203 }
204 if (!Initialize()) {
205 return ERR_APPEXECFWK_INSTALL_FAILED_INTERNAL_ERROR;
206 }
207 return bmsProxy_->GetBundleSize(bundleName);
208 }
209
UpdateBundleInfoList() const210 void BundleMsClient::UpdateBundleInfoList () const
211 {
212 if (!Initialize()) {
213 return;
214 }
215 bmsProxy_->UpdateBundleInfoList();
216 }
217
GetBundleInfosNoReplication(const int flags,BundleInfo ** bundleInfos,int32_t * len) const218 uint8_t BundleMsClient::GetBundleInfosNoReplication (const int flags, BundleInfo **bundleInfos, int32_t *len) const
219 {
220 if ((bundleInfos == nullptr) || (len == nullptr)) {
221 return ERR_APPEXECFWK_QUERY_PARAMETER_ERROR;
222 }
223 if (!Initialize()) {
224 return ERR_APPEXECFWK_INSTALL_FAILED_INTERNAL_ERROR;
225 }
226 return bmsProxy_->GetBundleInfosNoReplication(flags, bundleInfos, len);
227 }
228
QueryAbilityInfos(const Want * want,AbilityInfo ** abilityInfo,int32_t * len) const229 uint8_t BundleMsClient::QueryAbilityInfos(const Want *want, AbilityInfo **abilityInfo, int32_t *len) const
230 {
231 if (want == nullptr || (abilityInfo == nullptr)) {
232 return ERR_APPEXECFWK_QUERY_PARAMETER_ERROR;
233 }
234 if (!Initialize()) {
235 return ERR_APPEXECFWK_INSTALL_FAILED_INTERNAL_ERROR;
236 }
237 return bmsProxy_->QueryAbilityInfos(want, abilityInfo, len);
238 }
239
RegisterEvent(InstallerCallback installerCallback) const240 bool BundleMsClient::RegisterEvent(InstallerCallback installerCallback) const
241 {
242 if (installerCallback == nullptr) {
243 return ERR_APPEXECFWK_QUERY_PARAMETER_ERROR;
244 }
245 if (!Initialize()) {
246 return ERR_APPEXECFWK_INSTALL_FAILED_INTERNAL_ERROR;
247 }
248 return bmsProxy_->RegisterEvent(installerCallback);
249 }
250
UnregisterEvent(InstallerCallback installerCallback) const251 bool BundleMsClient::UnregisterEvent(InstallerCallback installerCallback) const
252 {
253 if (installerCallback == nullptr) {
254 return ERR_APPEXECFWK_QUERY_PARAMETER_ERROR;
255 }
256 if (!Initialize()) {
257 return ERR_APPEXECFWK_INSTALL_FAILED_INTERNAL_ERROR;
258 }
259 return bmsProxy_->UnregisterEvent(installerCallback);
260 }
261
InitPreAppInfo() const262 PreAppList *BundleMsClient::InitPreAppInfo () const
263 {
264 if (!Initialize()) {
265 return nullptr;
266 }
267 return bmsProxy_->InitPreAppInfo();
268 }
269
InsertPreAppInfo(const char * filePath,PreAppList * list) const270 void BundleMsClient::InsertPreAppInfo (const char *filePath, PreAppList *list) const
271 {
272 if ((filePath == nullptr) || (list == nullptr)) {
273 return;
274 }
275 if (!Initialize()) {
276 return;
277 }
278 bmsProxy_->InsertPreAppInfo(filePath, list);
279 }
280
SetPreAppInfo(PreAppList * list) const281 void BundleMsClient::SetPreAppInfo(PreAppList *list) const
282 {
283 if (list == nullptr) {
284 return;
285 }
286 if (!Initialize()) {
287 return;
288 }
289 bmsProxy_->SetPreAppInfo(list);
290 }
291 } // namespace OHOS
292