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 #include <fcntl.h>
16 #include <sys/prctl.h>
17 #include <sys/sendfile.h>
18 #include <sys/stat.h>
19 #include <sys/types.h>
20 #include <unistd.h>
21
22 #include <cerrno>
23 #include <cstdio>
24 #include <cstdlib>
25 #include <cstring>
26 #include <fstream>
27 #include <iostream>
28 #include <sstream>
29 #include <thread>
30
31 #include "bundle_mgr_interface.h"
32 #include "bundle_mgr_proxy.h"
33 #include "color_picker.h"
34 #include "command.h"
35 #include "config_policy_utils.h"
36 #include "directory_ex.h"
37 #include "dump_helper.h"
38 #include "effect_errors.h"
39 #include "export/color.h"
40 #include "file_deal.h"
41 #include "file_ex.h"
42 #include "hilog_wrapper.h"
43 #include "hitrace_meter.h"
44 #include "image_packer.h"
45 #include "image_source.h"
46 #include "image_type.h"
47 #include "image_utils.h"
48 #include "iservice_registry.h"
49 #include "mem_mgr_client.h"
50 #include "mem_mgr_proxy.h"
51 #include "memory_guard.h"
52 #include "nlohmann/json.hpp"
53 #include "parameter.h"
54 #include "pixel_map.h"
55 #include "scene_board_judgement.h"
56 #include "system_ability_definition.h"
57 #include "tokenid_kit.h"
58 #include "uri.h"
59 #include "wallpaper_common.h"
60 #include "wallpaper_common_event_manager.h"
61 #include "wallpaper_manager_common_info.h"
62 #include "wallpaper_service.h"
63 #include "wallpaper_service_cb_proxy.h"
64 #include "want.h"
65 #include "window.h"
66
67 #ifndef THEME_SERVICE
68 #include "ability_manager_client.h"
69 #include "wallpaper_extension_ability_death_recipient.h"
70 #endif
71
72 namespace OHOS {
73 namespace WallpaperMgrService {
74 REGISTER_SYSTEM_ABILITY_BY_ID(WallpaperService, WALLPAPER_MANAGER_SERVICE_ID, true);
75
76 using namespace OHOS::Media;
77 using namespace OHOS::MiscServices;
78 using namespace OHOS::Security::AccessToken;
79 using namespace OHOS::AccountSA;
80
81 constexpr const char *WALLPAPER_SYSTEM_ORIG = "wallpaper_system_orig";
82 constexpr const char *WALLPAPER_HOME = "wallpaper_home";
83 constexpr const char *WALLPAPER_LOCK_ORIG = "wallpaper_lock_orig";
84 constexpr const char *WALLPAPER_LOCK = "wallpaper_lock";
85 constexpr const char *LIVE_WALLPAPER_SYSTEM_ORIG = "live_wallpaper_system_orig";
86 constexpr const char *LIVE_WALLPAPER_LOCK_ORIG = "live_wallpaper_lock_orig";
87 constexpr const char *CUSTOM_WALLPAPER_LOCK = "custom_lock.zip";
88 constexpr const char *CUSTOM_WALLPAPER_SYSTEM = "custom_system.zip";
89 constexpr const char *OHOS_WALLPAPER_BUNDLE_NAME = "com.ohos.launcher";
90 constexpr const char *SHOW_SYSTEM_SCREEN = "SHOW_SYSTEMSCREEN";
91 constexpr const char *SHOW_LOCK_SCREEN = "SHOW_LOCKSCREEN";
92 constexpr const char *SYSTEM_RES_TYPE = "SystemResType";
93 constexpr const char *LOCKSCREEN_RES_TYPE = "LockScreenResType";
94 constexpr const char *WALLPAPER_CHANGE = "wallpaperChange";
95 constexpr const char *COLOR_CHANGE = "colorChange";
96 constexpr const char *SCENEBOARD_BUNDLE_NAME = "com.ohos.sceneboard";
97
98 constexpr const char *WALLPAPER_USERID_PATH = "/data/service/el1/public/wallpaper/";
99 constexpr const char *WALLPAPER_SYSTEM_DIRNAME = "system";
100 constexpr const char *WALLPAPER_TMP_DIRNAME = "fwsettmp";
101 constexpr const char *WALLPAPER_LOCKSCREEN_DIRNAME = "lockscreen";
102 constexpr const char *WALLPAPER_DEFAULT_FILEFULLPATH = "/system/etc/wallpaperdefault.jpeg";
103 constexpr const char *WALLPAPER_DEFAULT_LOCK_FILEFULLPATH = "/system/etc/wallpaperlockdefault.jpeg";
104 constexpr const char *WALLPAPER_CROP_PICTURE = "crop_file";
105 constexpr const char *RESOURCE_PATH = "resource/themes/theme/";
106 constexpr const char *DEFAULT_PATH = "default/";
107 constexpr const char *MANIFEST = "manifest.json";
108 constexpr const char *RES = "resources/";
109 constexpr const char *HOME = "home/";
110 constexpr const char *LOCK = "lock/";
111 constexpr const char *BASE = "base/";
112 constexpr const char *LAND_PATH = "land/";
113 constexpr const char *HOME_UNFOLDED = "home/unfolded/";
114 constexpr const char *HOME_UNFOLDED2 = "home/unfolded2/";
115 constexpr const char *LOCK_UNFOLDED = "lock/unfolded/";
116 constexpr const char *LOCK_UNFOLDED2 = "lock/unfolded2/";
117 constexpr const char *IMAGE = "image";
118 constexpr const char *SRC = "src";
119 constexpr const char *NORMAL_LAND_WALLPAPER_HOME = "normal_land_wallpaper_home";
120 constexpr const char *UNFOLD1_PORT_WALLPAPER_HOME = "unfold1_port_wallpaper_home";
121 constexpr const char *UNFOLD1_LAND_WALLPAPER_HOME = "unfold1_land_wallpaper_home";
122 constexpr const char *UNFOLD2_PORT_WALLPAPER_HOME = "unfold2_port_wallpaper_home";
123 constexpr const char *UNFOLD2_LAND_WALLPAPER_HOME = "unfold2_land_wallpaper_home";
124 constexpr const char *NORMAL_LAND_WALLPAPER_LOCK = "normal_land_wallpaper_lock";
125 constexpr const char *UNFOLD1_PORT_WALLPAPER_LOCK = "unfold1_port_wallpaper_lock";
126 constexpr const char *UNFOLD1_LAND_WALLPAPER_LOCK = "unfold1_land_wallpaper_lock";
127 constexpr const char *UNFOLD2_PORT_WALLPAPER_LOCK = "unfold2_port_wallpaper_lock";
128 constexpr const char *UNFOLD2_LAND_WALLPAPER_LOCK = "unfold2_land_wallpaper_lock";
129 constexpr int64_t INIT_INTERVAL = 10000L;
130 constexpr int64_t DELAY_TIME = 1000L;
131 constexpr int64_t QUERY_USER_ID_INTERVAL = 300L;
132 constexpr int32_t FOO_MAX_LEN = 52428800;
133 constexpr int32_t MAX_RETRY_TIMES = 20;
134 constexpr int32_t QUERY_USER_MAX_RETRY_TIMES = 100;
135 constexpr int32_t DEFAULT_WALLPAPER_ID = -1;
136 constexpr int32_t DEFAULT_USER_ID = 0;
137 constexpr int32_t MAX_VIDEO_SIZE = 104857600;
138 constexpr int32_t OPTION_QUALITY = 100;
139
140 #ifndef THEME_SERVICE
141 constexpr int32_t CONNECT_EXTENSION_INTERVAL = 100;
142 constexpr int32_t DEFAULT_VALUE = -1;
143 constexpr int32_t CONNECT_EXTENSION_MAX_RETRY_TIMES = 50;
144 #endif
145
146 std::mutex WallpaperService::instanceLock_;
147
148 sptr<WallpaperService> WallpaperService::instance_;
149
150 std::shared_ptr<AppExecFwk::EventHandler> WallpaperService::serviceHandler_;
151
WallpaperService(int32_t systemAbilityId,bool runOnCreate)152 WallpaperService::WallpaperService(int32_t systemAbilityId, bool runOnCreate)
153 : SystemAbility(systemAbilityId, runOnCreate), WallpaperServiceStub(true),
154 state_(ServiceRunningState::STATE_NOT_START)
155 {
156 }
157
WallpaperService()158 WallpaperService::WallpaperService() : WallpaperServiceStub(true), state_(ServiceRunningState::STATE_NOT_START)
159 {
160 }
161
~WallpaperService()162 WallpaperService::~WallpaperService()
163 {
164 }
165
Init()166 int32_t WallpaperService::Init()
167 {
168 InitQueryUserId(QUERY_USER_MAX_RETRY_TIMES);
169 bool ret = Publish(this);
170 if (!ret) {
171 HILOG_ERROR("Publish failed!");
172 ReporterFault(FaultType::SERVICE_FAULT, FaultCode::SF_SERVICE_UNAVAILABLE);
173 return -1;
174 }
175 HILOG_INFO("Publish success.");
176 state_ = ServiceRunningState::STATE_RUNNING;
177 #ifndef THEME_SERVICE
178 StartExtensionAbility(CONNECT_EXTENSION_MAX_RETRY_TIMES);
179 #endif
180 return E_OK;
181 }
182
OnStart()183 void WallpaperService::OnStart()
184 {
185 HILOG_INFO("Enter OnStart.");
186 MemoryGuard cacheGuard;
187 if (state_ == ServiceRunningState::STATE_RUNNING) {
188 HILOG_ERROR("WallpaperService is already running.");
189 return;
190 }
191 InitData();
192 InitServiceHandler();
193 AddSystemAbilityListener(COMMON_EVENT_SERVICE_ID);
194 AddSystemAbilityListener(MEMORY_MANAGER_SA_ID);
195 auto cmd = std::make_shared<Command>(std::vector<std::string>({ "-all" }), "Show all",
196 [this](const std::vector<std::string> &input, std::string &output) -> bool {
197 output.append(
198 "WallpaperExtensionAbility\t: ExtensionInfo{" + std::string(OHOS_WALLPAPER_BUNDLE_NAME) + "}\n");
199 return true;
200 });
201 DumpHelper::GetInstance().RegisterCommand(cmd);
202 if (Init() != E_OK) {
203 auto callback = [=]() { Init(); };
204 serviceHandler_->PostTask(callback, INIT_INTERVAL);
205 HILOG_ERROR("Init failed. Try again 10s later.");
206 }
207 return;
208 }
209
OnAddSystemAbility(int32_t systemAbilityId,const std::string & deviceId)210 void WallpaperService::OnAddSystemAbility(int32_t systemAbilityId, const std::string &deviceId)
211 {
212 HILOG_INFO("OnAddSystemAbility systemAbilityId:%{public}d added!", systemAbilityId);
213 if (systemAbilityId == COMMON_EVENT_SERVICE_ID) {
214 int32_t times = 0;
215 RegisterSubscriber(times);
216 } else if (systemAbilityId == MEMORY_MANAGER_SA_ID) {
217 int32_t pid = getpid();
218 Memory::MemMgrClient::GetInstance().NotifyProcessStatus(pid, 1, 1, WALLPAPER_MANAGER_SERVICE_ID);
219 }
220 }
221
RegisterSubscriber(int32_t times)222 void WallpaperService::RegisterSubscriber(int32_t times)
223 {
224 MemoryGuard cacheGuard;
225 times++;
226 subscriber_ = std::make_shared<WallpaperCommonEventSubscriber>(*this);
227 bool subRes = OHOS::EventFwk::CommonEventManager::SubscribeCommonEvent(subscriber_);
228 if (!subRes && times <= MAX_RETRY_TIMES) {
229 HILOG_INFO("RegisterSubscriber failed!");
230 auto callback = [this, times]() { RegisterSubscriber(times); };
231 serviceHandler_->PostTask(callback, DELAY_TIME);
232 }
233 }
234
InitServiceHandler()235 void WallpaperService::InitServiceHandler()
236 {
237 HILOG_INFO("InitServiceHandler started.");
238 if (serviceHandler_ != nullptr) {
239 HILOG_ERROR("InitServiceHandler already init.");
240 return;
241 }
242 std::shared_ptr<AppExecFwk::EventRunner> runner =
243 AppExecFwk::EventRunner::Create("WallpaperService", AppExecFwk::ThreadMode::FFRT);
244 serviceHandler_ = std::make_shared<AppExecFwk::EventHandler>(runner);
245 }
246
OnStop()247 void WallpaperService::OnStop()
248 {
249 HILOG_INFO("OnStop started.");
250 if (state_ != ServiceRunningState::STATE_RUNNING) {
251 return;
252 }
253 serviceHandler_ = nullptr;
254 #ifndef THEME_SERVICE
255 connection_ = nullptr;
256 #endif
257 recipient_ = nullptr;
258 extensionRemoteObject_ = nullptr;
259 if (subscriber_ != nullptr) {
260 bool unSubscribeResult = OHOS::EventFwk::CommonEventManager::UnSubscribeCommonEvent(subscriber_);
261 subscriber_ = nullptr;
262 HILOG_INFO("UnregisterSubscriber end, unSubscribeResult = %{public}d", unSubscribeResult);
263 }
264 state_ = ServiceRunningState::STATE_NOT_START;
265 int32_t pid = getpid();
266 Memory::MemMgrClient::GetInstance().NotifyProcessStatus(pid, 1, 0, WALLPAPER_MANAGER_SERVICE_ID);
267 }
268
InitData()269 void WallpaperService::InitData()
270 {
271 HILOG_INFO("WallpaperService::initData --> start.");
272 wallpaperId_ = DEFAULT_WALLPAPER_ID;
273 int32_t userId = DEFAULT_USER_ID;
274 systemWallpaperMap_.Clear();
275 lockWallpaperMap_.Clear();
276 wallpaperTmpFullPath_ = std::string(WALLPAPER_USERID_PATH) + std::string(WALLPAPER_TMP_DIRNAME);
277 wallpaperCropPath_ = std::string(WALLPAPER_USERID_PATH) + std::string(WALLPAPER_CROP_PICTURE);
278 {
279 std::lock_guard<std::mutex> lock(wallpaperColorMtx_);
280 systemWallpaperColor_ = 0;
281 lockWallpaperColor_ = 0;
282 }
283 currentUserId_ = userId;
284 wallpaperEventMap_.clear();
285 appBundleName_ = SCENEBOARD_BUNDLE_NAME;
286 InitUserDir(userId);
287 UpdataWallpaperMap(userId, WALLPAPER_SYSTEM);
288 UpdataWallpaperMap(userId, WALLPAPER_LOCKSCREEN);
289 LoadWallpaperState();
290 ClearRedundantFile(userId, WALLPAPER_SYSTEM, WALLPAPER_SYSTEM_ORIG);
291 ClearRedundantFile(userId, WALLPAPER_LOCKSCREEN, WALLPAPER_LOCK_ORIG);
292 }
293
294 #ifndef THEME_SERVICE
AddWallpaperExtensionDeathRecipient(const sptr<IRemoteObject> & remoteObject)295 void WallpaperService::AddWallpaperExtensionDeathRecipient(const sptr<IRemoteObject> &remoteObject)
296 {
297 if (remoteObject != nullptr) {
298 std::lock_guard<std::mutex> lock(remoteObjectMutex_);
299 IPCObjectProxy *proxy = reinterpret_cast<IPCObjectProxy *>(remoteObject.GetRefPtr());
300 if (recipient_ == nullptr) {
301 recipient_ = sptr<IRemoteObject::DeathRecipient>(new WallpaperExtensionAbilityDeathRecipient(*this));
302 }
303 if (proxy != nullptr && !proxy->IsObjectDead()) {
304 HILOG_INFO("get remoteObject succeed.");
305 proxy->AddDeathRecipient(recipient_);
306 extensionRemoteObject_ = remoteObject;
307 }
308 }
309 }
310 #endif
311
RemoveExtensionDeathRecipient()312 void WallpaperService::RemoveExtensionDeathRecipient()
313 {
314 if (extensionRemoteObject_ != nullptr && recipient_ != nullptr) {
315 HILOG_INFO("Remove Extension DeathRecipient.");
316 std::lock_guard<std::mutex> lock(remoteObjectMutex_);
317 extensionRemoteObject_->RemoveDeathRecipient(recipient_);
318 recipient_ = nullptr;
319 extensionRemoteObject_ = nullptr;
320 }
321 }
322
InitQueryUserId(int32_t times)323 void WallpaperService::InitQueryUserId(int32_t times)
324 {
325 times--;
326 bool ret = InitUsersOnBoot();
327 if (!ret && times > 0) {
328 HILOG_DEBUG("InitQueryUserId failed!");
329 auto callback = [this, times]() { InitQueryUserId(times); };
330 serviceHandler_->PostTask(callback, QUERY_USER_ID_INTERVAL);
331 }
332 }
333
334 #ifndef THEME_SERVICE
StartExtensionAbility(int32_t times)335 void WallpaperService::StartExtensionAbility(int32_t times)
336 {
337 times--;
338 bool ret = ConnectExtensionAbility();
339 if (!ret && times > 0 && serviceHandler_ != nullptr) {
340 HILOG_ERROR("StartExtensionAbilty failed, remainder of the times: %{public}d", times);
341 auto callback = [this, times]() { StartExtensionAbility(times); };
342 serviceHandler_->PostTask(callback, CONNECT_EXTENSION_INTERVAL);
343 }
344 }
345 #endif
346
InitUsersOnBoot()347 bool WallpaperService::InitUsersOnBoot()
348 {
349 std::vector<AccountSA::OsAccountInfo> osAccountInfos;
350 ErrCode errCode = AccountSA::OsAccountManager::QueryAllCreatedOsAccounts(osAccountInfos);
351 if (errCode != ERR_OK || osAccountInfos.empty()) {
352 HILOG_ERROR("Query all created userIds failed, errCode:%{public}d", errCode);
353 return false;
354 }
355 for (const auto &osAccountInfo : osAccountInfos) {
356 int32_t userId = osAccountInfo.GetLocalId();
357 HILOG_INFO("InitUsersOnBoot Current userId: %{public}d", userId);
358 InitUserDir(userId);
359 UpdataWallpaperMap(userId, WALLPAPER_SYSTEM);
360 UpdataWallpaperMap(userId, WALLPAPER_LOCKSCREEN);
361 ClearRedundantFile(userId, WALLPAPER_SYSTEM, WALLPAPER_SYSTEM_ORIG);
362 ClearRedundantFile(userId, WALLPAPER_LOCKSCREEN, WALLPAPER_LOCK_ORIG);
363 }
364 return true;
365 }
366
ClearRedundantFile(int32_t userId,WallpaperType wallpaperType,std::string fileName)367 void WallpaperService::ClearRedundantFile(int32_t userId, WallpaperType wallpaperType, std::string fileName)
368 {
369 HILOG_DEBUG("ClearRedundantFile Current userId: %{public}d", userId);
370 std::string wallpaperFilePath = GetWallpaperDir(userId, wallpaperType) + "/" + fileName;
371 FileDeal::DeleteFile(wallpaperFilePath);
372 }
373
OnInitUser(int32_t userId)374 void WallpaperService::OnInitUser(int32_t userId)
375 {
376 if (userId < 0) {
377 HILOG_ERROR("userId error, userId = %{public}d", userId);
378 return;
379 }
380 std::string userDir = WALLPAPER_USERID_PATH + std::to_string(userId);
381 if (FileDeal::IsFileExist(userDir)) {
382 std::lock_guard<std::mutex> lock(mtx_);
383 if (!OHOS::ForceRemoveDirectory(userDir)) {
384 HILOG_ERROR("Force remove user directory path failed, errno %{public}d, userId:%{public}d", errno, userId);
385 return;
386 }
387 }
388 if (!InitUserDir(userId)) {
389 return;
390 }
391 UpdataWallpaperMap(userId, WALLPAPER_SYSTEM);
392 UpdataWallpaperMap(userId, WALLPAPER_LOCKSCREEN);
393 HILOG_INFO("OnInitUser success, userId = %{public}d", userId);
394 }
395
InitUserDir(int32_t userId)396 bool WallpaperService::InitUserDir(int32_t userId)
397 {
398 std::string userDir = WALLPAPER_USERID_PATH + std::to_string(userId);
399 if (!FileDeal::Mkdir(userDir)) {
400 HILOG_ERROR("Failed to create destination path, userId:%{public}d", userId);
401 return false;
402 }
403 std::string wallpaperSystemFilePath = userDir + "/" + WALLPAPER_SYSTEM_DIRNAME;
404 if (!FileDeal::Mkdir(wallpaperSystemFilePath)) {
405 HILOG_ERROR("Failed to create destination wallpaper system path, userId:%{public}d, type:%{public}s.", userId,
406 WALLPAPER_SYSTEM_DIRNAME);
407 return false;
408 }
409 std::string wallpaperLockScreenFilePath = userDir + "/" + WALLPAPER_LOCKSCREEN_DIRNAME;
410 if (!FileDeal::Mkdir(wallpaperLockScreenFilePath)) {
411 HILOG_ERROR("Failed to create destination wallpaper lockscreen path, userId:%{public}d, type:%{public}s.",
412 userId, WALLPAPER_LOCKSCREEN_DIRNAME);
413 return false;
414 }
415 return true;
416 }
417
RestoreUserResources(int32_t userId,WallpaperData & wallpaperData,WallpaperType wallpaperType)418 bool WallpaperService::RestoreUserResources(int32_t userId, WallpaperData &wallpaperData, WallpaperType wallpaperType)
419 {
420 if (!FileDeal::DeleteDir(GetWallpaperDir(userId, wallpaperType), false)) {
421 HILOG_ERROR("delete resources failed, userId:%{public}d, wallpaperType:%{public}d.", userId, wallpaperType);
422 return false;
423 }
424 std::string wallpaperPath = GetWallpaperDir(userId, wallpaperType);
425 wallpaperData = GetWallpaperDefaultPath(wallpaperType);
426 wallpaperData.userId = userId;
427 wallpaperData.allowBackup = true;
428 wallpaperData.resourceType = PICTURE;
429 wallpaperData.wallpaperId = DEFAULT_WALLPAPER_ID;
430 wallpaperData.liveWallpaperFile =
431 wallpaperPath + "/"
432 + (wallpaperType == WALLPAPER_SYSTEM ? LIVE_WALLPAPER_SYSTEM_ORIG : LIVE_WALLPAPER_LOCK_ORIG);
433 wallpaperData.customPackageUri =
434 wallpaperPath + "/" + (wallpaperType == WALLPAPER_SYSTEM ? CUSTOM_WALLPAPER_SYSTEM : CUSTOM_WALLPAPER_LOCK);
435 if (wallpaperData.wallpaperFile.empty()) {
436 HILOG_ERROR("get default path failed, userId:%{public}d, wallpaperType:%{public}d.", userId, wallpaperType);
437 return false;
438 }
439 HILOG_INFO("Restore user resources end.");
440 return true;
441 }
442
GetWallpaperDefaultPath(WallpaperType wallpaperType)443 WallpaperData WallpaperService::GetWallpaperDefaultPath(WallpaperType wallpaperType)
444 {
445 WallpaperData wallpaperData;
446 std::string manifest = MANIFEST;
447 std::string res = RES;
448 std::string base = BASE;
449 std::string land = LAND_PATH;
450 if (wallpaperType == WallpaperType::WALLPAPER_SYSTEM) {
451 wallpaperData.wallpaperFile = GetWallpaperPathInJson(HOME + manifest, HOME + base + res);
452 wallpaperData.normalLandFile = GetWallpaperPathInJson(HOME + base + land + manifest, HOME + base + land + res);
453 wallpaperData.unfoldedOnePortFile = GetWallpaperPathInJson(HOME_UNFOLDED + manifest, HOME_UNFOLDED + res);
454 wallpaperData.unfoldedOneLandFile =
455 GetWallpaperPathInJson(HOME_UNFOLDED + land + manifest, HOME_UNFOLDED + land + res);
456 wallpaperData.unfoldedTwoPortFile = GetWallpaperPathInJson(HOME_UNFOLDED2 + manifest, HOME_UNFOLDED2 + res);
457 wallpaperData.unfoldedTwoLandFile =
458 GetWallpaperPathInJson(HOME_UNFOLDED2 + land + manifest, HOME_UNFOLDED2 + land + res);
459 } else {
460 wallpaperData.wallpaperFile = GetWallpaperPathInJson(LOCK + manifest, LOCK + base + res);
461 wallpaperData.normalLandFile = GetWallpaperPathInJson(LOCK + base + land + manifest, LOCK + base + land + res);
462 wallpaperData.unfoldedOnePortFile = GetWallpaperPathInJson(LOCK_UNFOLDED + manifest, LOCK_UNFOLDED + res);
463 wallpaperData.unfoldedOneLandFile =
464 GetWallpaperPathInJson(LOCK_UNFOLDED + land + manifest, LOCK_UNFOLDED + land + res);
465 wallpaperData.unfoldedTwoPortFile = GetWallpaperPathInJson(LOCK_UNFOLDED2 + manifest, LOCK_UNFOLDED2 + res);
466 wallpaperData.unfoldedTwoLandFile =
467 GetWallpaperPathInJson(LOCK_UNFOLDED2 + land + manifest, LOCK_UNFOLDED2 + land + res);
468 }
469 if (wallpaperData.wallpaperFile.empty()) {
470 wallpaperData.wallpaperFile = (wallpaperType == WallpaperType::WALLPAPER_SYSTEM)
471 ? WALLPAPER_DEFAULT_FILEFULLPATH
472 : WALLPAPER_DEFAULT_LOCK_FILEFULLPATH;
473 }
474 return wallpaperData;
475 }
OnRemovedUser(int32_t userId)476 void WallpaperService::OnRemovedUser(int32_t userId)
477 {
478 if (userId < 0) {
479 HILOG_ERROR("userId error, userId = %{public}d", userId);
480 return;
481 }
482 ClearWallpaperLocked(userId, WALLPAPER_SYSTEM);
483 ClearWallpaperLocked(userId, WALLPAPER_LOCKSCREEN);
484 std::string userDir = WALLPAPER_USERID_PATH + std::to_string(userId);
485 std::lock_guard<std::mutex> lock(mtx_);
486 if (!OHOS::ForceRemoveDirectory(userDir)) {
487 HILOG_ERROR("Force remove user directory path failed, errno %{public}d", errno);
488 }
489 HILOG_INFO("OnRemovedUser end, userId = %{public}d", userId);
490 }
491
OnSwitchedUser(int32_t userId)492 void WallpaperService::OnSwitchedUser(int32_t userId)
493 {
494 if (userId < 0) {
495 HILOG_ERROR("userId error, userId = %{public}d", userId);
496 return;
497 }
498 if (userId == currentUserId_) {
499 HILOG_ERROR("userId not switch, userId = %{public}d", userId);
500 return;
501 }
502 currentUserId_ = userId;
503 RemoveExtensionDeathRecipient();
504 #ifndef THEME_SERVICE
505 ConnectExtensionAbility();
506 #endif
507 std::string userDir = WALLPAPER_USERID_PATH + std::to_string(userId);
508 if (!FileDeal::IsFileExist(userDir)) {
509 HILOG_INFO("User file is not exist, userId = %{public}d", userId);
510 InitUserDir(userId);
511 UpdataWallpaperMap(userId, WALLPAPER_SYSTEM);
512 UpdataWallpaperMap(userId, WALLPAPER_LOCKSCREEN);
513 }
514 LoadWallpaperState();
515 SendWallpaperChangeEvent(userId, WALLPAPER_SYSTEM);
516 SendWallpaperChangeEvent(userId, WALLPAPER_LOCKSCREEN);
517 SaveColor(userId, WALLPAPER_SYSTEM);
518 SaveColor(userId, WALLPAPER_LOCKSCREEN);
519 HILOG_INFO("OnSwitchedUser end, newUserId = %{public}d", userId);
520 }
521
GetWallpaperDir(int32_t userId,WallpaperType wallpaperType)522 std::string WallpaperService::GetWallpaperDir(int32_t userId, WallpaperType wallpaperType)
523 {
524 std::string userIdPath = WALLPAPER_USERID_PATH + std::to_string(userId);
525 std::string wallpaperFilePath;
526 if (wallpaperType == WALLPAPER_SYSTEM) {
527 wallpaperFilePath = userIdPath + "/" + WALLPAPER_SYSTEM_DIRNAME;
528 } else if (wallpaperType == WALLPAPER_LOCKSCREEN) {
529 wallpaperFilePath = userIdPath + "/" + WALLPAPER_LOCKSCREEN_DIRNAME;
530 }
531 return wallpaperFilePath;
532 }
533
GetFileNameFromMap(int32_t userId,WallpaperType wallpaperType,std::string & filePathName)534 bool WallpaperService::GetFileNameFromMap(int32_t userId, WallpaperType wallpaperType, std::string &filePathName)
535 {
536 auto iterator = wallpaperType == WALLPAPER_SYSTEM ? systemWallpaperMap_.Find(userId)
537 : lockWallpaperMap_.Find(userId);
538 if (!iterator.first) {
539 HILOG_ERROR("system wallpaper already cleared.");
540 return false;
541 }
542 HILOG_DEBUG("GetFileNameFromMap resourceType : %{public}d", static_cast<int32_t>(iterator.second.resourceType));
543 switch (iterator.second.resourceType) {
544 case PICTURE:
545 filePathName = iterator.second.wallpaperFile;
546 break;
547 case VIDEO:
548 filePathName = iterator.second.liveWallpaperFile;
549 break;
550 case DEFAULT:
551 filePathName = iterator.second.wallpaperFile;
552 break;
553 case PACKAGE:
554 filePathName = iterator.second.customPackageUri;
555 break;
556 default:
557 filePathName = "";
558 break;
559 }
560 return filePathName != "";
561 }
562
GetPictureFileName(int32_t userId,WallpaperType wallpaperType,std::string & filePathName)563 bool WallpaperService::GetPictureFileName(int32_t userId, WallpaperType wallpaperType, std::string &filePathName)
564 {
565 auto iterator = wallpaperType == WALLPAPER_SYSTEM ? systemWallpaperMap_.Find(userId)
566 : lockWallpaperMap_.Find(userId);
567 if (!iterator.first) {
568 HILOG_INFO("WallpaperType:%{public}d, WallpaperMap not found userId: %{public}d", wallpaperType, userId);
569 OnInitUser(userId);
570 iterator = wallpaperType == WALLPAPER_SYSTEM ? systemWallpaperMap_.Find(userId)
571 : lockWallpaperMap_.Find(userId);
572 }
573 filePathName = iterator.second.wallpaperFile;
574 HILOG_INFO("GetPictureFileName filePathName : %{public}s", filePathName.c_str());
575 return filePathName != "";
576 }
577
MakeWallpaperIdLocked()578 int32_t WallpaperService::MakeWallpaperIdLocked()
579 {
580 HILOG_INFO("MakeWallpaperIdLocked start.");
581 if (wallpaperId_ == INT32_MAX) {
582 wallpaperId_ = DEFAULT_WALLPAPER_ID;
583 }
584 return ++wallpaperId_;
585 }
586
UpdataWallpaperMap(int32_t userId,WallpaperType wallpaperType)587 void WallpaperService::UpdataWallpaperMap(int32_t userId, WallpaperType wallpaperType)
588 {
589 HILOG_INFO("updata wallpaperMap.");
590 std::string wallpaperPath = GetWallpaperDir(userId, wallpaperType);
591 std::string wallpaperFilePath =
592 wallpaperPath + "/" + (wallpaperType == WALLPAPER_SYSTEM ? WALLPAPER_HOME : WALLPAPER_LOCK);
593 ConcurrentMap<int32_t, WallpaperData> &wallpaperMap = [&]() -> ConcurrentMap<int32_t, WallpaperData>& {
594 if (wallpaperType == WALLPAPER_SYSTEM) {
595 return systemWallpaperMap_;
596 } else {
597 return lockWallpaperMap_;
598 }
599 }();
600 auto wallpaperData = GetWallpaperDefaultPath(wallpaperType);
601 wallpaperData.userId = userId;
602 wallpaperData.allowBackup = true;
603 wallpaperData.resourceType = PICTURE;
604 wallpaperData.wallpaperId = DEFAULT_WALLPAPER_ID;
605 wallpaperData.liveWallpaperFile =
606 wallpaperPath + "/"
607 + (wallpaperType == WALLPAPER_SYSTEM ? LIVE_WALLPAPER_SYSTEM_ORIG : LIVE_WALLPAPER_LOCK_ORIG);
608 wallpaperData.customPackageUri =
609 wallpaperPath + "/" + (wallpaperType == WALLPAPER_SYSTEM ? CUSTOM_WALLPAPER_SYSTEM : CUSTOM_WALLPAPER_LOCK);
610 if (FileDeal::IsFileExist(wallpaperFilePath)) {
611 wallpaperData.wallpaperFile = GetExistFilePath(
612 wallpaperPath + "/" + (wallpaperType == WALLPAPER_SYSTEM ? WALLPAPER_HOME : WALLPAPER_LOCK));
613 wallpaperData.normalLandFile = GetExistFilePath(
614 wallpaperPath + "/"
615 + (wallpaperType == WALLPAPER_SYSTEM ? NORMAL_LAND_WALLPAPER_HOME : NORMAL_LAND_WALLPAPER_LOCK));
616 wallpaperData.unfoldedOnePortFile = GetExistFilePath(
617 wallpaperPath + "/"
618 + (wallpaperType == WALLPAPER_SYSTEM ? UNFOLD1_PORT_WALLPAPER_HOME : UNFOLD1_PORT_WALLPAPER_LOCK));
619 wallpaperData.unfoldedOneLandFile = GetExistFilePath(
620 wallpaperPath + "/"
621 + (wallpaperType == WALLPAPER_SYSTEM ? UNFOLD1_LAND_WALLPAPER_HOME : UNFOLD1_LAND_WALLPAPER_LOCK));
622 wallpaperData.unfoldedTwoPortFile = GetExistFilePath(
623 wallpaperPath + "/"
624 + (wallpaperType == WALLPAPER_SYSTEM ? UNFOLD2_PORT_WALLPAPER_HOME : UNFOLD2_PORT_WALLPAPER_LOCK));
625 wallpaperData.unfoldedTwoLandFile = GetExistFilePath(
626 wallpaperPath + "/"
627 + (wallpaperType == WALLPAPER_SYSTEM ? UNFOLD2_LAND_WALLPAPER_HOME : UNFOLD2_LAND_WALLPAPER_LOCK));
628 }
629 wallpaperMap.InsertOrAssign(userId, wallpaperData);
630 }
631
GetColors(int32_t wallpaperType,std::vector<uint64_t> & colors)632 ErrorCode WallpaperService::GetColors(int32_t wallpaperType, std::vector<uint64_t> &colors)
633 {
634 if (wallpaperType == WALLPAPER_SYSTEM) {
635 std::lock_guard<std::mutex> lock(wallpaperColorMtx_);
636 colors.emplace_back(systemWallpaperColor_);
637 } else if (wallpaperType == WALLPAPER_LOCKSCREEN) {
638 std::lock_guard<std::mutex> lock(wallpaperColorMtx_);
639 colors.emplace_back(lockWallpaperColor_);
640 }
641 HILOG_INFO("GetColors Service End.");
642 return E_OK;
643 }
644
GetColorsV9(int32_t wallpaperType,std::vector<uint64_t> & colors)645 ErrorCode WallpaperService::GetColorsV9(int32_t wallpaperType, std::vector<uint64_t> &colors)
646 {
647 if (!IsSystemApp()) {
648 HILOG_ERROR("CallingApp is not SystemApp.");
649 return E_NOT_SYSTEM_APP;
650 }
651 return GetColors(wallpaperType, colors);
652 }
653
GetFile(int32_t wallpaperType,int32_t & wallpaperFd)654 ErrorCode WallpaperService::GetFile(int32_t wallpaperType, int32_t &wallpaperFd)
655 {
656 if (!CheckCallingPermission(WALLPAPER_PERMISSION_NAME_GET_WALLPAPER)) {
657 HILOG_ERROR("GetPixelMap no get permission!");
658 return E_NO_PERMISSION;
659 }
660 if (wallpaperType != static_cast<int32_t>(WALLPAPER_LOCKSCREEN)
661 && wallpaperType != static_cast<int32_t>(WALLPAPER_SYSTEM)) {
662 return E_PARAMETERS_INVALID;
663 }
664 auto type = static_cast<WallpaperType>(wallpaperType);
665 int32_t userId = QueryActiveUserId();
666 HILOG_INFO("QueryCurrentOsAccount userId: %{public}d", userId);
667 ErrorCode ret = GetImageFd(userId, type, wallpaperFd);
668 HILOG_INFO("GetImageFd fd:%{public}d, ret:%{public}d", wallpaperFd, ret);
669 return ret;
670 }
671
CompareColor(const uint64_t & localColor,const ColorManager::Color & color)672 bool WallpaperService::CompareColor(const uint64_t &localColor, const ColorManager::Color &color)
673 {
674 return localColor == color.PackValue();
675 }
676
SaveColor(int32_t userId,WallpaperType wallpaperType)677 bool WallpaperService::SaveColor(int32_t userId, WallpaperType wallpaperType)
678 {
679 uint32_t errorCode = 0;
680 OHOS::Media::SourceOptions opts;
681 opts.formatHint = "image/jpeg";
682 std::string pathName;
683 if (!GetPictureFileName(userId, wallpaperType, pathName)) {
684 return false;
685 }
686 std::unique_ptr<OHOS::Media::ImageSource> imageSource =
687 OHOS::Media::ImageSource::CreateImageSource(pathName, opts, errorCode);
688 if (errorCode != 0 || imageSource == nullptr) {
689 HILOG_ERROR("CreateImageSource failed!");
690 return false;
691 }
692 OHOS::Media::DecodeOptions decodeOpts;
693 std::unique_ptr<PixelMap> wallpaperPixelMap = imageSource->CreatePixelMap(decodeOpts, errorCode);
694 if (errorCode != 0) {
695 HILOG_ERROR("CreatePixelMap failed!");
696 return false;
697 }
698 auto colorPicker = Rosen::ColorPicker::CreateColorPicker(std::move(wallpaperPixelMap), errorCode);
699 if (errorCode != 0) {
700 HILOG_ERROR("CreateColorPicker failed!");
701 return false;
702 }
703 auto color = ColorManager::Color();
704 uint32_t ret = colorPicker->GetMainColor(color);
705 if (ret != Rosen::SUCCESS) {
706 HILOG_ERROR("GetMainColor failed ret is : %{public}d", ret);
707 return false;
708 }
709 OnColorsChange(wallpaperType, color);
710 return true;
711 }
712
SetWallpaper(int32_t fd,int32_t wallpaperType,int32_t length)713 ErrorCode WallpaperService::SetWallpaper(int32_t fd, int32_t wallpaperType, int32_t length)
714 {
715 StartAsyncTrace(HITRACE_TAG_MISC, "SetWallpaper", static_cast<int32_t>(TraceTaskId::SET_WALLPAPER));
716 ErrorCode wallpaperErrorCode = SetWallpaper(fd, wallpaperType, length, PICTURE);
717 FinishAsyncTrace(HITRACE_TAG_MISC, "SetWallpaper", static_cast<int32_t>(TraceTaskId::SET_WALLPAPER));
718 return wallpaperErrorCode;
719 }
720
SetWallpaperByPixelMap(std::shared_ptr<OHOS::Media::PixelMap> pixelMap,int32_t wallpaperType)721 ErrorCode WallpaperService::SetWallpaperByPixelMap(
722 std::shared_ptr<OHOS::Media::PixelMap> pixelMap, int32_t wallpaperType)
723 {
724 if (pixelMap == nullptr) {
725 HILOG_ERROR("pixelMap is nullptr");
726 return E_FILE_ERROR;
727 }
728 StartAsyncTrace(HITRACE_TAG_MISC, "SetWallpaper", static_cast<int32_t>(TraceTaskId::SET_WALLPAPER));
729 ErrorCode wallpaperErrorCode = SetWallpaperByPixelMap(pixelMap, wallpaperType, PICTURE);
730 FinishAsyncTrace(HITRACE_TAG_MISC, "SetWallpaper", static_cast<int32_t>(TraceTaskId::SET_WALLPAPER));
731 return wallpaperErrorCode;
732 }
733
SetWallpaperV9(int32_t fd,int32_t wallpaperType,int32_t length)734 ErrorCode WallpaperService::SetWallpaperV9(int32_t fd, int32_t wallpaperType, int32_t length)
735 {
736 if (!IsSystemApp()) {
737 HILOG_ERROR("CallingApp is not SystemApp.");
738 return E_NOT_SYSTEM_APP;
739 }
740 return SetWallpaper(fd, wallpaperType, length);
741 }
742
SetWallpaperV9ByPixelMap(std::shared_ptr<OHOS::Media::PixelMap> pixelMap,int32_t wallpaperType)743 ErrorCode WallpaperService::SetWallpaperV9ByPixelMap(
744 std::shared_ptr<OHOS::Media::PixelMap> pixelMap, int32_t wallpaperType)
745 {
746 if (!IsSystemApp()) {
747 HILOG_INFO("CallingApp is not SystemApp.");
748 return E_NOT_SYSTEM_APP;
749 }
750 if (pixelMap == nullptr) {
751 HILOG_ERROR("pixelMap is nullptr");
752 return E_FILE_ERROR;
753 }
754 return SetWallpaperByPixelMap(pixelMap, wallpaperType);
755 }
756
SetWallpaperBackupData(int32_t userId,WallpaperResourceType resourceType,const std::string & uriOrPixelMap,WallpaperType wallpaperType)757 ErrorCode WallpaperService::SetWallpaperBackupData(
758 int32_t userId, WallpaperResourceType resourceType, const std::string &uriOrPixelMap, WallpaperType wallpaperType)
759 {
760 HILOG_INFO("set wallpaper and backup data Start.");
761 if (!OHOS::FileExists(uriOrPixelMap)) {
762 return E_DEAL_FAILED;
763 }
764 if (!FileDeal::DeleteDir(GetWallpaperDir(userId, wallpaperType), false)) {
765 return E_DEAL_FAILED;
766 }
767 WallpaperData wallpaperData;
768 bool ret = GetWallpaperSafeLocked(userId, wallpaperType, wallpaperData);
769 if (!ret) {
770 HILOG_ERROR("GetWallpaperSafeLocked failed!");
771 return E_DEAL_FAILED;
772 }
773 if (resourceType == PICTURE || resourceType == DEFAULT) {
774 wallpaperData.wallpaperFile = GetWallpaperDir(userId, wallpaperType) + "/"
775 + (wallpaperType == WALLPAPER_SYSTEM ? WALLPAPER_HOME : WALLPAPER_LOCK);
776 }
777 wallpaperData.resourceType = resourceType;
778 wallpaperData.wallpaperId = MakeWallpaperIdLocked();
779 std::string wallpaperFile;
780 WallpaperService::GetWallpaperFile(resourceType, wallpaperData, wallpaperFile);
781 {
782 std::lock_guard<std::mutex> lock(mtx_);
783 if (!FileDeal::CopyFile(uriOrPixelMap, wallpaperFile)) {
784 HILOG_ERROR("CopyFile failed!");
785 FileDeal::DeleteFile(uriOrPixelMap);
786 return E_DEAL_FAILED;
787 }
788 if (!FileDeal::DeleteFile(uriOrPixelMap)) {
789 return E_DEAL_FAILED;
790 }
791 }
792 if (!SaveWallpaperState(userId, wallpaperType, resourceType)) {
793 HILOG_ERROR("Save wallpaper state failed!");
794 return E_DEAL_FAILED;
795 }
796 if (wallpaperType == WALLPAPER_SYSTEM) {
797 systemWallpaperMap_.InsertOrAssign(userId, wallpaperData);
798 } else if (wallpaperType == WALLPAPER_LOCKSCREEN) {
799 lockWallpaperMap_.InsertOrAssign(userId, wallpaperData);
800 }
801 if (!SendWallpaperChangeEvent(userId, wallpaperType)) {
802 HILOG_ERROR("Send wallpaper state failed!");
803 return E_DEAL_FAILED;
804 }
805 return E_OK;
806 }
807
GetWallpaperFile(WallpaperResourceType resourceType,const WallpaperData & wallpaperData,std::string & wallpaperFile)808 void WallpaperService::GetWallpaperFile(
809 WallpaperResourceType resourceType, const WallpaperData &wallpaperData, std::string &wallpaperFile)
810 {
811 switch (resourceType) {
812 case PICTURE:
813 wallpaperFile = wallpaperData.wallpaperFile;
814 break;
815 case DEFAULT:
816 wallpaperFile = wallpaperData.wallpaperFile;
817 break;
818 case VIDEO:
819 wallpaperFile = wallpaperData.liveWallpaperFile;
820 break;
821 case PACKAGE:
822 wallpaperFile = wallpaperData.customPackageUri;
823 break;
824 default:
825 HILOG_ERROR("Non-existent error type!");
826 break;
827 }
828 }
829
GetResType(int32_t userId,WallpaperType wallpaperType)830 WallpaperResourceType WallpaperService::GetResType(int32_t userId, WallpaperType wallpaperType)
831 {
832 if (wallpaperType == WALLPAPER_LOCKSCREEN) {
833 auto iterator = lockWallpaperMap_.Find(userId);
834 if (iterator.first) {
835 return iterator.second.resourceType;
836 }
837 } else if (wallpaperType == WALLPAPER_SYSTEM) {
838 auto iterator = systemWallpaperMap_.Find(userId);
839 if (iterator.first) {
840 return iterator.second.resourceType;
841 }
842 }
843 return WallpaperResourceType::DEFAULT;
844 }
845
SendEvent(const std::string & eventType)846 ErrorCode WallpaperService::SendEvent(const std::string &eventType)
847 {
848 HILOG_INFO("Send event start.");
849 if (!CheckCallingPermission(WALLPAPER_PERMISSION_NAME_SET_WALLPAPER)) {
850 HILOG_ERROR("Send event not set permission!");
851 return E_NO_PERMISSION;
852 }
853
854 int32_t userId = QueryActiveUserId();
855 WallpaperType wallpaperType;
856 WallpaperData data;
857 if (eventType == SHOW_SYSTEM_SCREEN) {
858 wallpaperType = WALLPAPER_SYSTEM;
859 } else if (eventType == SHOW_LOCK_SCREEN) {
860 wallpaperType = WALLPAPER_LOCKSCREEN;
861 } else {
862 HILOG_ERROR("Event type error!");
863 return E_PARAMETERS_INVALID;
864 }
865
866 if (!GetWallpaperSafeLocked(userId, wallpaperType, data)) {
867 HILOG_ERROR("Get wallpaper safe locked failed!");
868 return E_PARAMETERS_INVALID;
869 }
870 std::string uri;
871 GetFileNameFromMap(userId, WALLPAPER_SYSTEM, uri);
872 WallpaperChanged(wallpaperType, data.resourceType, uri);
873 return E_OK;
874 }
875
SendWallpaperChangeEvent(int32_t userId,WallpaperType wallpaperType)876 bool WallpaperService::SendWallpaperChangeEvent(int32_t userId, WallpaperType wallpaperType)
877 {
878 WallpaperData wallpaperData;
879 if (!GetWallpaperSafeLocked(userId, wallpaperType, wallpaperData)) {
880 HILOG_ERROR("GetWallpaperSafeLocked failed!");
881 return false;
882 }
883 shared_ptr<WallpaperCommonEventManager> wallpaperCommonEventManager = make_shared<WallpaperCommonEventManager>();
884 if (wallpaperType == WALLPAPER_SYSTEM) {
885 HILOG_INFO("Send wallpaper system setting message.");
886 wallpaperCommonEventManager->SendWallpaperSystemSettingMessage(wallpaperData.resourceType);
887 } else if (wallpaperType == WALLPAPER_LOCKSCREEN) {
888 HILOG_INFO("Send wallpaper lock setting message.");
889 wallpaperCommonEventManager->SendWallpaperLockSettingMessage(wallpaperData.resourceType);
890 }
891 HILOG_INFO("SetWallpaperBackupData callbackProxy_->OnCall start.");
892 if (callbackProxy_ != nullptr && (wallpaperData.resourceType == PICTURE || wallpaperData.resourceType == DEFAULT)) {
893 callbackProxy_->OnCall(wallpaperType);
894 }
895 std::string uri;
896 WallpaperChanged(wallpaperType, wallpaperData.resourceType, uri);
897 return true;
898 }
899
SetVideo(int32_t fd,int32_t wallpaperType,int32_t length)900 ErrorCode WallpaperService::SetVideo(int32_t fd, int32_t wallpaperType, int32_t length)
901 {
902 if (!IsSystemApp()) {
903 HILOG_ERROR("current app is not SystemApp.");
904 return E_NOT_SYSTEM_APP;
905 }
906 StartAsyncTrace(HITRACE_TAG_MISC, "SetVideo", static_cast<int32_t>(TraceTaskId::SET_VIDEO));
907 ErrorCode wallpaperErrorCode = SetWallpaper(fd, wallpaperType, length, VIDEO);
908 FinishAsyncTrace(HITRACE_TAG_MISC, "SetVideo", static_cast<int32_t>(TraceTaskId::SET_VIDEO));
909 return wallpaperErrorCode;
910 }
911
SetCustomWallpaper(int32_t fd,int32_t type,int32_t length)912 ErrorCode WallpaperService::SetCustomWallpaper(int32_t fd, int32_t type, int32_t length)
913 {
914 if (!IsSystemApp()) {
915 HILOG_ERROR("current app is not SystemApp.");
916 return E_NOT_SYSTEM_APP;
917 }
918 if (!CheckCallingPermission(WALLPAPER_PERMISSION_NAME_SET_WALLPAPER)) {
919 HILOG_ERROR("SetWallpaper no set permission!");
920 return E_NO_PERMISSION;
921 }
922 if (type != static_cast<int32_t>(WALLPAPER_LOCKSCREEN) && type != static_cast<int32_t>(WALLPAPER_SYSTEM)) {
923 return E_PARAMETERS_INVALID;
924 }
925 StartAsyncTrace(HITRACE_TAG_MISC, "SetCustomWallpaper", static_cast<int32_t>(TraceTaskId::SET_CUSTOM_WALLPAPER));
926 int32_t userId = QueryActiveUserId();
927 WallpaperType wallpaperType = static_cast<WallpaperType>(type);
928 WallpaperData wallpaperData;
929 if (!GetWallpaperSafeLocked(userId, wallpaperType, wallpaperData)) {
930 HILOG_ERROR("GetWallpaper data failed!");
931 return E_DEAL_FAILED;
932 }
933 if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
934 HILOG_ERROR("SceneBoard is not Enabled.");
935 return E_NO_PERMISSION;
936 }
937 if (!SaveWallpaperState(userId, wallpaperType, PACKAGE)) {
938 HILOG_ERROR("Save wallpaper state failed!");
939 return E_DEAL_FAILED;
940 }
941 ErrorCode wallpaperErrorCode = SetWallpaper(fd, wallpaperType, length, PACKAGE);
942 wallpaperData.resourceType = PACKAGE;
943 wallpaperData.wallpaperId = MakeWallpaperIdLocked();
944 if (wallpaperType == WALLPAPER_SYSTEM) {
945 systemWallpaperMap_.InsertOrAssign(userId, wallpaperData);
946 } else if (wallpaperType == WALLPAPER_LOCKSCREEN) {
947 lockWallpaperMap_.InsertOrAssign(userId, wallpaperData);
948 }
949 if (!SendWallpaperChangeEvent(userId, wallpaperType)) {
950 HILOG_ERROR("Send wallpaper state failed!");
951 return E_DEAL_FAILED;
952 }
953 FinishAsyncTrace(HITRACE_TAG_MISC, "SetCustomWallpaper", static_cast<int32_t>(TraceTaskId::SET_CUSTOM_WALLPAPER));
954 return wallpaperErrorCode;
955 }
956
GetPixelMap(int32_t wallpaperType,IWallpaperService::FdInfo & fdInfo)957 ErrorCode WallpaperService::GetPixelMap(int32_t wallpaperType, IWallpaperService::FdInfo &fdInfo)
958 {
959 HILOG_INFO("WallpaperService::getPixelMap start.");
960 if (!IsSystemApp()) {
961 HILOG_ERROR("CallingApp is not SystemApp.");
962 return E_NOT_SYSTEM_APP;
963 }
964 if (!CheckCallingPermission(WALLPAPER_PERMISSION_NAME_GET_WALLPAPER)) {
965 HILOG_ERROR("GetPixelMap no get permission!");
966 return E_NO_PERMISSION;
967 }
968 if (wallpaperType != static_cast<int32_t>(WALLPAPER_LOCKSCREEN)
969 && wallpaperType != static_cast<int32_t>(WALLPAPER_SYSTEM)) {
970 return E_PARAMETERS_INVALID;
971 }
972 auto type = static_cast<WallpaperType>(wallpaperType);
973 int32_t userId = QueryActiveUserId();
974 HILOG_INFO("QueryCurrentOsAccount userId: %{public}d", userId);
975 // current user's wallpaper is live video, not image
976 WallpaperResourceType resType = GetResType(userId, type);
977 if (resType != PICTURE && resType != DEFAULT) {
978 HILOG_ERROR("Current user's wallpaper is live video, not image.");
979 fdInfo.size = 0; // 0: empty file size
980 fdInfo.fd = -1; // -1: invalid file description
981 return E_OK;
982 }
983 ErrorCode ret = GetImageSize(userId, type, fdInfo.size);
984 if (ret != E_OK) {
985 HILOG_ERROR("GetImageSize failed!");
986 return ret;
987 }
988 ret = GetImageFd(userId, type, fdInfo.fd);
989 if (ret != E_OK) {
990 HILOG_ERROR("GetImageFd failed!");
991 return ret;
992 }
993 return E_OK;
994 }
995
GetPixelMapV9(int32_t wallpaperType,IWallpaperService::FdInfo & fdInfo)996 ErrorCode WallpaperService::GetPixelMapV9(int32_t wallpaperType, IWallpaperService::FdInfo &fdInfo)
997 {
998 return GetPixelMap(wallpaperType, fdInfo);
999 }
1000
GetWallpaperId(int32_t wallpaperType)1001 int32_t WallpaperService::GetWallpaperId(int32_t wallpaperType)
1002 {
1003 HILOG_INFO("WallpaperService::GetWallpaperId --> start.");
1004 int32_t iWallpaperId = -1;
1005 int32_t userId = QueryActiveUserId();
1006 HILOG_INFO("QueryCurrentOsAccount userId: %{public}d", userId);
1007 if (wallpaperType == WALLPAPER_LOCKSCREEN) {
1008 auto iterator = lockWallpaperMap_.Find(userId);
1009 if (iterator.first) {
1010 iWallpaperId = iterator.second.wallpaperId;
1011 }
1012 } else if (wallpaperType == WALLPAPER_SYSTEM) {
1013 auto iterator = systemWallpaperMap_.Find(userId);
1014 if (iterator.first) {
1015 iWallpaperId = iterator.second.wallpaperId;
1016 }
1017 }
1018 HILOG_INFO("WallpaperService::GetWallpaperId --> end ID[%{public}d]", iWallpaperId);
1019 return iWallpaperId;
1020 }
1021
IsChangePermitted()1022 bool WallpaperService::IsChangePermitted()
1023 {
1024 HILOG_INFO("IsChangePermitted wallpaper Start.");
1025 bool bFlag = CheckCallingPermission(WALLPAPER_PERMISSION_NAME_SET_WALLPAPER);
1026 return bFlag;
1027 }
1028
IsOperationAllowed()1029 bool WallpaperService::IsOperationAllowed()
1030 {
1031 HILOG_INFO("IsOperationAllowed wallpaper Start.");
1032 bool bFlag = CheckCallingPermission(WALLPAPER_PERMISSION_NAME_SET_WALLPAPER);
1033 return bFlag;
1034 }
1035
ResetWallpaper(int32_t wallpaperType)1036 ErrorCode WallpaperService::ResetWallpaper(int32_t wallpaperType)
1037 {
1038 HILOG_INFO("reset wallpaper Start.");
1039 bool permissionSet = CheckCallingPermission(WALLPAPER_PERMISSION_NAME_SET_WALLPAPER);
1040 if (!permissionSet) {
1041 HILOG_ERROR("reset wallpaper no set permission!");
1042 return E_NO_PERMISSION;
1043 }
1044 if (wallpaperType != static_cast<int32_t>(WALLPAPER_LOCKSCREEN)
1045 && wallpaperType != static_cast<int32_t>(WALLPAPER_SYSTEM)) {
1046 HILOG_ERROR("wallpaperType = %{public}d type not support ", wallpaperType);
1047 return E_PARAMETERS_INVALID;
1048 }
1049 WallpaperType type = static_cast<WallpaperType>(wallpaperType);
1050 int32_t userId = QueryActiveUserId();
1051 HILOG_INFO("QueryCurrentOsAccount userId: %{public}d", userId);
1052 if (!CheckUserPermissionById(userId)) {
1053 return E_USER_IDENTITY_ERROR;
1054 }
1055 ErrorCode wallpaperErrorCode = SetDefaultDataForWallpaper(userId, type);
1056 HILOG_INFO(" Set default data result[%{public}d]", wallpaperErrorCode);
1057 return wallpaperErrorCode;
1058 }
1059
ResetWallpaperV9(int32_t wallpaperType)1060 ErrorCode WallpaperService::ResetWallpaperV9(int32_t wallpaperType)
1061 {
1062 if (!IsSystemApp()) {
1063 HILOG_ERROR("CallingApp is not SystemApp.");
1064 return E_NOT_SYSTEM_APP;
1065 }
1066 return ResetWallpaper(wallpaperType);
1067 }
1068
SetDefaultDataForWallpaper(int32_t userId,WallpaperType wallpaperType)1069 ErrorCode WallpaperService::SetDefaultDataForWallpaper(int32_t userId, WallpaperType wallpaperType)
1070 {
1071 WallpaperData wallpaperData;
1072 if (!GetWallpaperSafeLocked(userId, wallpaperType, wallpaperData)) {
1073 return E_DEAL_FAILED;
1074 }
1075 if (!RestoreUserResources(userId, wallpaperData, wallpaperType)) {
1076 HILOG_ERROR("RestoreUserResources error!");
1077 return E_DEAL_FAILED;
1078 }
1079 if (!SaveWallpaperState(userId, wallpaperType, DEFAULT)) {
1080 HILOG_ERROR("Save wallpaper state failed!");
1081 return E_DEAL_FAILED;
1082 }
1083 wallpaperData.wallpaperId = DEFAULT_WALLPAPER_ID;
1084 wallpaperData.resourceType = DEFAULT;
1085 wallpaperData.allowBackup = true;
1086 if (wallpaperType == WALLPAPER_LOCKSCREEN) {
1087 lockWallpaperMap_.InsertOrAssign(userId, wallpaperData);
1088 } else if (wallpaperType == WALLPAPER_SYSTEM) {
1089 systemWallpaperMap_.InsertOrAssign(userId, wallpaperData);
1090 }
1091 if (!SendWallpaperChangeEvent(userId, wallpaperType)) {
1092 HILOG_ERROR("Send wallpaper state failed!");
1093 return E_DEAL_FAILED;
1094 }
1095 SaveColor(userId, wallpaperType);
1096 return E_OK;
1097 }
1098
On(const std::string & type,sptr<IWallpaperEventListener> listener)1099 ErrorCode WallpaperService::On(const std::string &type, sptr<IWallpaperEventListener> listener)
1100 {
1101 HILOG_DEBUG("WallpaperService::On in.");
1102 if (listener == nullptr) {
1103 HILOG_ERROR("WallpaperService::On listener is null.");
1104 return E_DEAL_FAILED;
1105 }
1106 if (type == WALLPAPER_CHANGE && !IsSystemApp()) {
1107 HILOG_ERROR("current app is not SystemApp.");
1108 return E_NOT_SYSTEM_APP;
1109 }
1110 std::lock_guard<std::mutex> autoLock(listenerMapMutex_);
1111 wallpaperEventMap_[type].insert_or_assign(IPCSkeleton::GetCallingTokenID(), listener);
1112 return E_OK;
1113 }
1114
Off(const std::string & type,sptr<IWallpaperEventListener> listener)1115 ErrorCode WallpaperService::Off(const std::string &type, sptr<IWallpaperEventListener> listener)
1116 {
1117 HILOG_DEBUG("WallpaperService::Off in.");
1118 (void)listener;
1119 if (type == WALLPAPER_CHANGE && !IsSystemApp()) {
1120 HILOG_ERROR("current app is not SystemApp.");
1121 return E_NOT_SYSTEM_APP;
1122 }
1123 std::lock_guard<std::mutex> autoLock(listenerMapMutex_);
1124 auto iter = wallpaperEventMap_.find(type);
1125 if (iter != wallpaperEventMap_.end()) {
1126 auto it = iter->second.find(IPCSkeleton::GetCallingTokenID());
1127 if (it != iter->second.end()) {
1128 it->second = nullptr;
1129 iter->second.erase(it);
1130 }
1131 }
1132 return E_OK;
1133 }
1134
RegisterWallpaperCallback(const sptr<IWallpaperCallback> callback)1135 bool WallpaperService::RegisterWallpaperCallback(const sptr<IWallpaperCallback> callback)
1136 {
1137 HILOG_INFO(" WallpaperService::RegisterWallpaperCallback.");
1138 callbackProxy_ = callback;
1139 return true;
1140 }
1141
GetWallpaperSafeLocked(int32_t userId,WallpaperType wallpaperType,WallpaperData & wallpaperData)1142 bool WallpaperService::GetWallpaperSafeLocked(int32_t userId, WallpaperType wallpaperType, WallpaperData &wallpaperData)
1143 {
1144 HILOG_DEBUG("GetWallpaperSafeLocked start.");
1145 auto iterator = wallpaperType == WALLPAPER_SYSTEM ? systemWallpaperMap_.Find(userId)
1146 : lockWallpaperMap_.Find(userId);
1147 if (!iterator.first) {
1148 HILOG_INFO("No Lock wallpaper? Not tracking for lock-only");
1149 UpdataWallpaperMap(userId, wallpaperType);
1150 iterator = wallpaperType == WALLPAPER_SYSTEM ? systemWallpaperMap_.Find(userId)
1151 : lockWallpaperMap_.Find(userId);
1152 if (!iterator.first) {
1153 HILOG_ERROR("Fail to get wallpaper data");
1154 return false;
1155 }
1156 }
1157 wallpaperData = iterator.second;
1158 ClearnWallpaperDataFile(wallpaperData);
1159 return true;
1160 }
1161
ClearWallpaperLocked(int32_t userId,WallpaperType wallpaperType)1162 void WallpaperService::ClearWallpaperLocked(int32_t userId, WallpaperType wallpaperType)
1163 {
1164 HILOG_INFO("Clear wallpaper Start.");
1165 auto iterator = wallpaperType == WALLPAPER_SYSTEM ? systemWallpaperMap_.Find(userId)
1166 : lockWallpaperMap_.Find(userId);
1167 if (!iterator.first) {
1168 HILOG_ERROR("Lock wallpaper already cleared.");
1169 return;
1170 }
1171 if (!iterator.second.wallpaperFile.empty() || !iterator.second.liveWallpaperFile.empty()) {
1172 if (wallpaperType == WALLPAPER_LOCKSCREEN) {
1173 lockWallpaperMap_.Erase(userId);
1174 } else if (wallpaperType == WALLPAPER_SYSTEM) {
1175 systemWallpaperMap_.Erase(userId);
1176 }
1177 }
1178 }
1179
CheckCallingPermission(const std::string & permissionName)1180 bool WallpaperService::CheckCallingPermission(const std::string &permissionName)
1181 {
1182 AccessTokenID callerToken = IPCSkeleton::GetCallingTokenID();
1183 int32_t result = AccessTokenKit::VerifyAccessToken(callerToken, permissionName);
1184 if (result != TypePermissionState::PERMISSION_GRANTED) {
1185 HILOG_ERROR("Check permission failed!");
1186 return false;
1187 }
1188 return true;
1189 }
1190
ReporterFault(FaultType faultType,FaultCode faultCode)1191 void WallpaperService::ReporterFault(FaultType faultType, FaultCode faultCode)
1192 {
1193 FaultMsg msg;
1194 msg.faultType = faultType;
1195 msg.errorCode = faultCode;
1196 ReportStatus nRet;
1197 if (faultType == FaultType::SERVICE_FAULT) {
1198 msg.moduleName = "WallpaperService";
1199 nRet = FaultReporter::ReportServiceFault(msg);
1200 } else {
1201 nRet = FaultReporter::ReportRuntimeFault(msg);
1202 }
1203
1204 if (nRet == ReportStatus::SUCCESS) {
1205 HILOG_INFO("ReporterFault success.");
1206 } else {
1207 HILOG_ERROR("ReporterFault failed!");
1208 }
1209 }
1210
Dump(int32_t fd,const std::vector<std::u16string> & args)1211 int32_t WallpaperService::Dump(int32_t fd, const std::vector<std::u16string> &args)
1212 {
1213 std::vector<std::string> argsStr;
1214 for (auto item : args) {
1215 argsStr.emplace_back(Str16ToStr8(item));
1216 }
1217
1218 if (DumpHelper::GetInstance().Dispatch(fd, argsStr)) {
1219 HILOG_ERROR("DumpHelper Dispatch failed!");
1220 return 0;
1221 }
1222 return 1;
1223 }
1224
1225 #ifndef THEME_SERVICE
ConnectExtensionAbility()1226 bool WallpaperService::ConnectExtensionAbility()
1227 {
1228 HILOG_DEBUG("ConnectAdapter.");
1229 MemoryGuard cacheGuard;
1230 AAFwk::Want want;
1231 want.SetElementName(OHOS_WALLPAPER_BUNDLE_NAME, "WallpaperExtAbility");
1232 ErrCode errCode = AAFwk::AbilityManagerClient::GetInstance()->Connect();
1233 if (errCode != ERR_OK) {
1234 HILOG_ERROR("connect ability server failed errCode=%{public}d", errCode);
1235 return false;
1236 }
1237 if (connection_ == nullptr) {
1238 connection_ = new WallpaperExtensionAbilityConnection(*this);
1239 }
1240 auto ret = AAFwk::AbilityManagerClient::GetInstance()->ConnectExtensionAbility(want, connection_, DEFAULT_VALUE);
1241 HILOG_INFO("ConnectExtensionAbility errCode=%{public}d", ret);
1242 return ret;
1243 }
1244 #endif
1245
IsSystemApp()1246 bool WallpaperService::IsSystemApp()
1247 {
1248 HILOG_INFO("IsSystemApp start.");
1249 uint64_t tokenId = IPCSkeleton::GetCallingFullTokenID();
1250 return TokenIdKit::IsSystemAppByFullTokenID(tokenId);
1251 }
1252
GetImageFd(int32_t userId,WallpaperType wallpaperType,int32_t & fd)1253 ErrorCode WallpaperService::GetImageFd(int32_t userId, WallpaperType wallpaperType, int32_t &fd)
1254 {
1255 HILOG_INFO("WallpaperService::GetImageFd start.");
1256 std::string filePathName;
1257 if (!GetFileNameFromMap(userId, wallpaperType, filePathName)) {
1258 return E_DEAL_FAILED;
1259 }
1260 if (GetResType(userId, wallpaperType) == WallpaperResourceType::PACKAGE) {
1261 HILOG_INFO("The current wallpaper is a custom wallpaper");
1262 return E_OK;
1263 }
1264 {
1265 std::lock_guard<std::mutex> lock(mtx_);
1266 fd = open(filePathName.c_str(), O_RDONLY, S_IREAD);
1267 }
1268 if (fd < 0) {
1269 HILOG_ERROR("Open file failed, errno %{public}d", errno);
1270 ReporterFault(FaultType::LOAD_WALLPAPER_FAULT, FaultCode::RF_FD_INPUT_FAILED);
1271 return E_DEAL_FAILED;
1272 }
1273 HILOG_INFO("fd = %{public}d", fd);
1274 return E_OK;
1275 }
1276
GetImageSize(int32_t userId,WallpaperType wallpaperType,int32_t & size)1277 ErrorCode WallpaperService::GetImageSize(int32_t userId, WallpaperType wallpaperType, int32_t &size)
1278 {
1279 HILOG_INFO("WallpaperService::GetImageSize start.");
1280 std::string filePathName;
1281 HILOG_INFO("userId = %{public}d", userId);
1282 if (!GetPictureFileName(userId, wallpaperType, filePathName)) {
1283 return E_DEAL_FAILED;
1284 }
1285
1286 if (!OHOS::FileExists(filePathName)) {
1287 HILOG_ERROR("file is not exist.");
1288 return E_NOT_FOUND;
1289 }
1290 std::lock_guard<std::mutex> lock(mtx_);
1291 FILE *fd = fopen(filePathName.c_str(), "rb");
1292 if (fd == nullptr) {
1293 HILOG_ERROR("fopen file failed, errno %{public}d", errno);
1294 return E_FILE_ERROR;
1295 }
1296 int32_t fend = fseek(fd, 0, SEEK_END);
1297 size = ftell(fd);
1298 int32_t fset = fseek(fd, 0, SEEK_SET);
1299 if (size <= 0 || fend != 0 || fset != 0) {
1300 HILOG_ERROR("ftell file failed or fseek file failed, errno %{public}d", errno);
1301 fclose(fd);
1302 return E_FILE_ERROR;
1303 }
1304 fclose(fd);
1305 return E_OK;
1306 }
1307
QueryActiveUserId()1308 int32_t WallpaperService::QueryActiveUserId()
1309 {
1310 std::vector<int32_t> ids;
1311 ErrCode errCode = AccountSA::OsAccountManager::QueryActiveOsAccountIds(ids);
1312 if (errCode != ERR_OK || ids.empty()) {
1313 HILOG_ERROR("Query active userid failed, errCode: %{public}d,", errCode);
1314 return DEFAULT_USER_ID;
1315 }
1316 return ids[0];
1317 }
1318
CheckUserPermissionById(int32_t userId)1319 bool WallpaperService::CheckUserPermissionById(int32_t userId)
1320 {
1321 OsAccountInfo osAccountInfo;
1322 ErrCode errCode = OsAccountManager::QueryOsAccountById(userId, osAccountInfo);
1323 if (errCode != ERR_OK) {
1324 HILOG_ERROR("Query os account info failed, errCode: %{public}d", errCode);
1325 return false;
1326 }
1327 HILOG_INFO("osAccountInfo GetType: %{public}d", static_cast<int32_t>(osAccountInfo.GetType()));
1328 if (osAccountInfo.GetType() == OsAccountType::GUEST) {
1329 HILOG_ERROR("The guest does not have permissions.");
1330 return false;
1331 }
1332 return true;
1333 }
1334
SetWallpaper(int32_t fd,int32_t wallpaperType,int32_t length,WallpaperResourceType resourceType)1335 ErrorCode WallpaperService::SetWallpaper(
1336 int32_t fd, int32_t wallpaperType, int32_t length, WallpaperResourceType resourceType)
1337 {
1338 int32_t userId = QueryActiveUserId();
1339 HILOG_INFO("QueryCurrentOsAccount userId: %{public}d", userId);
1340 if (!CheckUserPermissionById(userId)) {
1341 return E_USER_IDENTITY_ERROR;
1342 }
1343 ErrorCode errCode = CheckValid(wallpaperType, length, resourceType);
1344 if (errCode != E_OK) {
1345 return errCode;
1346 }
1347 std::string uri = wallpaperTmpFullPath_;
1348 char *paperBuf = new (std::nothrow) char[length]();
1349 if (paperBuf == nullptr) {
1350 return E_NO_MEMORY;
1351 }
1352 {
1353 std::lock_guard<std::mutex> lock(mtx_);
1354 if (read(fd, paperBuf, length) <= 0) {
1355 HILOG_ERROR("read fd failed!");
1356 delete[] paperBuf;
1357 return E_DEAL_FAILED;
1358 }
1359 mode_t mode = S_IRUSR | S_IWUSR;
1360 int32_t fdw = open(uri.c_str(), O_WRONLY | O_CREAT, mode);
1361 if (fdw < 0) {
1362 HILOG_ERROR("Open wallpaper tmpFullPath failed, errno %{public}d", errno);
1363 delete[] paperBuf;
1364 return E_DEAL_FAILED;
1365 }
1366 if (write(fdw, paperBuf, length) <= 0) {
1367 HILOG_ERROR("Write to fdw failed, errno %{public}d", errno);
1368 ReporterFault(FaultType::SET_WALLPAPER_FAULT, FaultCode::RF_DROP_FAILED);
1369 delete[] paperBuf;
1370 close(fdw);
1371 return E_DEAL_FAILED;
1372 }
1373 delete[] paperBuf;
1374 close(fdw);
1375 }
1376 WallpaperType type = static_cast<WallpaperType>(wallpaperType);
1377 ErrorCode wallpaperErrorCode = SetWallpaperBackupData(userId, resourceType, uri, type);
1378 if (resourceType == PICTURE) {
1379 SaveColor(userId, type);
1380 }
1381 return wallpaperErrorCode;
1382 }
1383
SetWallpaperByPixelMap(std::shared_ptr<OHOS::Media::PixelMap> pixelMap,int32_t wallpaperType,WallpaperResourceType resourceType)1384 ErrorCode WallpaperService::SetWallpaperByPixelMap(
1385 std::shared_ptr<OHOS::Media::PixelMap> pixelMap, int32_t wallpaperType, WallpaperResourceType resourceType)
1386 {
1387 if (pixelMap == nullptr) {
1388 HILOG_ERROR("pixelMap is nullptr");
1389 return E_FILE_ERROR;
1390 }
1391 int32_t userId = QueryActiveUserId();
1392 HILOG_INFO("QueryCurrentOsAccount userId: %{public}d", userId);
1393 if (!CheckUserPermissionById(userId)) {
1394 return E_USER_IDENTITY_ERROR;
1395 }
1396 std::string uri = wallpaperTmpFullPath_;
1397 ErrorCode errCode = WritePixelMapToFile(pixelMap, uri, wallpaperType, resourceType);
1398 if (errCode != E_OK) {
1399 HILOG_ERROR("WritePixelMapToFile failed!");
1400 return errCode;
1401 }
1402 WallpaperType type = static_cast<WallpaperType>(wallpaperType);
1403 ErrorCode wallpaperErrorCode = SetWallpaperBackupData(userId, resourceType, uri, type);
1404 if (resourceType == PICTURE) {
1405 SaveColor(userId, type);
1406 }
1407 return wallpaperErrorCode;
1408 }
1409
WritePixelMapToFile(std::shared_ptr<OHOS::Media::PixelMap> pixelMap,std::string wallpaperTmpFullPath,int32_t wallpaperType,WallpaperResourceType resourceType)1410 ErrorCode WallpaperService::WritePixelMapToFile(std::shared_ptr<OHOS::Media::PixelMap> pixelMap,
1411 std::string wallpaperTmpFullPath, int32_t wallpaperType, WallpaperResourceType resourceType)
1412 {
1413 if (pixelMap == nullptr) {
1414 HILOG_ERROR("pixelMap is nullptr");
1415 return E_FILE_ERROR;
1416 }
1417 std::stringbuf stringBuf;
1418 std::ostream ostream(&stringBuf);
1419 int32_t mapSize = WritePixelMapToStream(pixelMap, ostream);
1420 if (mapSize <= 0) {
1421 HILOG_ERROR("WritePixelMapToStream failed!");
1422 return E_WRITE_PARCEL_ERROR;
1423 }
1424 ErrorCode errCode = CheckValid(wallpaperType, mapSize, resourceType);
1425 if (errCode != E_OK) {
1426 HILOG_ERROR("CheckValid failed!");
1427 return errCode;
1428 }
1429 char *buffer = new (std::nothrow) char[mapSize]();
1430 if (buffer == nullptr) {
1431 HILOG_ERROR("buffer failed!");
1432 return E_NO_MEMORY;
1433 }
1434 stringBuf.sgetn(buffer, mapSize);
1435 {
1436 std::lock_guard<std::mutex> lock(mtx_);
1437 mode_t mode = S_IRUSR | S_IWUSR;
1438 int32_t fdw = open(wallpaperTmpFullPath.c_str(), O_WRONLY | O_CREAT, mode);
1439 if (fdw < 0) {
1440 HILOG_ERROR("Open wallpaper tmpFullPath failed, errno %{public}d", errno);
1441 delete[] buffer;
1442 return E_DEAL_FAILED;
1443 }
1444 if (write(fdw, buffer, mapSize) <= 0) {
1445 HILOG_ERROR("Write to fdw failed, errno %{public}d", errno);
1446 ReporterFault(FaultType::SET_WALLPAPER_FAULT, FaultCode::RF_DROP_FAILED);
1447 delete[] buffer;
1448 close(fdw);
1449 return E_DEAL_FAILED;
1450 }
1451 delete[] buffer;
1452 close(fdw);
1453 }
1454 return E_OK;
1455 }
1456
WritePixelMapToStream(std::shared_ptr<OHOS::Media::PixelMap> pixelMap,std::ostream & outputStream)1457 int64_t WallpaperService::WritePixelMapToStream(
1458 std::shared_ptr<OHOS::Media::PixelMap> pixelMap, std::ostream &outputStream)
1459 {
1460 if (pixelMap == nullptr) {
1461 HILOG_ERROR("pixelMap is nullptr");
1462 return 0;
1463 }
1464 OHOS::Media::ImagePacker imagePacker;
1465 OHOS::Media::PackOption option;
1466 option.format = "image/jpeg";
1467 option.quality = OPTION_QUALITY;
1468 option.numberHint = 1;
1469 std::set<std::string> formats;
1470 uint32_t ret = imagePacker.GetSupportedFormats(formats);
1471 if (ret != 0) {
1472 HILOG_ERROR("image packer get supported format failed, ret=%{public}u.", ret);
1473 }
1474
1475 imagePacker.StartPacking(outputStream, option);
1476 imagePacker.AddImage(*pixelMap);
1477 int64_t packedSize = 0;
1478 imagePacker.FinalizePacking(packedSize);
1479 HILOG_INFO("FrameWork WritePixelMapToStream End! packedSize=%{public}lld.", static_cast<long long>(packedSize));
1480 return packedSize;
1481 }
1482
OnColorsChange(WallpaperType wallpaperType,const ColorManager::Color & color)1483 void WallpaperService::OnColorsChange(WallpaperType wallpaperType, const ColorManager::Color &color)
1484 {
1485 std::vector<uint64_t> colors;
1486 if (wallpaperType == WALLPAPER_SYSTEM && !CompareColor(systemWallpaperColor_, color)) {
1487 {
1488 std::lock_guard<std::mutex> lock(wallpaperColorMtx_);
1489 systemWallpaperColor_ = color.PackValue();
1490 colors.emplace_back(systemWallpaperColor_);
1491 }
1492 NotifyColorChange(colors, WALLPAPER_SYSTEM);
1493 } else if (wallpaperType == WALLPAPER_LOCKSCREEN && !CompareColor(lockWallpaperColor_, color)) {
1494 {
1495 std::lock_guard<std::mutex> lock(wallpaperColorMtx_);
1496 lockWallpaperColor_ = color.PackValue();
1497 colors.emplace_back(lockWallpaperColor_);
1498 }
1499 NotifyColorChange(colors, WALLPAPER_LOCKSCREEN);
1500 }
1501 }
1502
CheckValid(int32_t wallpaperType,int32_t length,WallpaperResourceType resourceType)1503 ErrorCode WallpaperService::CheckValid(int32_t wallpaperType, int32_t length, WallpaperResourceType resourceType)
1504 {
1505 if (!CheckCallingPermission(WALLPAPER_PERMISSION_NAME_SET_WALLPAPER)) {
1506 HILOG_ERROR("SetWallpaper no set permission.");
1507 return E_NO_PERMISSION;
1508 }
1509 if (wallpaperType != static_cast<int32_t>(WALLPAPER_LOCKSCREEN)
1510 && wallpaperType != static_cast<int32_t>(WALLPAPER_SYSTEM)) {
1511 return E_PARAMETERS_INVALID;
1512 }
1513
1514 int32_t maxLength = resourceType == VIDEO ? MAX_VIDEO_SIZE : FOO_MAX_LEN;
1515 if (length <= 0 || length > maxLength) {
1516 return E_PARAMETERS_INVALID;
1517 }
1518 return E_OK;
1519 }
1520
WallpaperChanged(WallpaperType wallpaperType,WallpaperResourceType resType,const std::string & uri)1521 bool WallpaperService::WallpaperChanged(
1522 WallpaperType wallpaperType, WallpaperResourceType resType, const std::string &uri)
1523 {
1524 std::lock_guard<std::mutex> autoLock(listenerMapMutex_);
1525 auto it = wallpaperEventMap_.find(WALLPAPER_CHANGE);
1526 if (it != wallpaperEventMap_.end()) {
1527 for (auto iter = it->second.begin(); iter != it->second.end(); iter++) {
1528 if (iter->second == nullptr) {
1529 continue;
1530 }
1531 iter->second->OnWallpaperChange(wallpaperType, resType, uri);
1532 }
1533 return true;
1534 }
1535 return false;
1536 }
1537
NotifyColorChange(const std::vector<uint64_t> & colors,const WallpaperType & wallpaperType)1538 void WallpaperService::NotifyColorChange(const std::vector<uint64_t> &colors, const WallpaperType &wallpaperType)
1539 {
1540 std::lock_guard<std::mutex> autoLock(listenerMapMutex_);
1541 auto it = wallpaperEventMap_.find(COLOR_CHANGE);
1542 if (it != wallpaperEventMap_.end()) {
1543 for (auto iter = it->second.begin(); iter != it->second.end(); iter++) {
1544 if (iter->second == nullptr) {
1545 continue;
1546 }
1547 iter->second->OnColorsChange(colors, wallpaperType);
1548 }
1549 }
1550 }
1551
SaveWallpaperState(int32_t userId,WallpaperType wallpaperType,WallpaperResourceType resourceType)1552 bool WallpaperService::SaveWallpaperState(
1553 int32_t userId, WallpaperType wallpaperType, WallpaperResourceType resourceType)
1554 {
1555 WallpaperData systemData;
1556 WallpaperData lockScreenData;
1557 if (!GetWallpaperSafeLocked(userId, WALLPAPER_SYSTEM, systemData)
1558 || !GetWallpaperSafeLocked(userId, WALLPAPER_LOCKSCREEN, lockScreenData)) {
1559 return false;
1560 }
1561 nlohmann::json root;
1562 if (wallpaperType == WALLPAPER_SYSTEM) {
1563 root[SYSTEM_RES_TYPE] = static_cast<int32_t>(resourceType);
1564 root[LOCKSCREEN_RES_TYPE] = static_cast<int32_t>(lockScreenData.resourceType);
1565 } else {
1566 root[LOCKSCREEN_RES_TYPE] = static_cast<int32_t>(resourceType);
1567 root[SYSTEM_RES_TYPE] = static_cast<int32_t>(systemData.resourceType);
1568 }
1569 std::string json = root.dump();
1570 if (json.empty()) {
1571 HILOG_ERROR("write user config file failed. because json content is empty.");
1572 return false;
1573 }
1574
1575 std::string userPath = WALLPAPER_USERID_PATH + std::to_string(userId) + "/wallpapercfg";
1576 mode_t mode = S_IRUSR | S_IWUSR;
1577 int fd = open(userPath.c_str(), O_CREAT | O_WRONLY | O_SYNC, mode);
1578 if (fd <= 0) {
1579 HILOG_ERROR("open user config file failed!");
1580 return false;
1581 }
1582 ssize_t size = write(fd, json.c_str(), json.size());
1583 if (size <= 0) {
1584 HILOG_ERROR("write user config file failed!");
1585 close(fd);
1586 return false;
1587 }
1588 close(fd);
1589 return true;
1590 }
1591
LoadWallpaperState()1592 void WallpaperService::LoadWallpaperState()
1593 {
1594 int32_t userId = QueryActiveUserId();
1595 std::string userPath = WALLPAPER_USERID_PATH + std::to_string(userId) + "/wallpapercfg";
1596 int fd = open(userPath.c_str(), O_RDONLY, S_IREAD);
1597 if (fd <= 0) {
1598 HILOG_ERROR("open user config file failed!");
1599 return;
1600 }
1601 const size_t len = 255;
1602 char buf[len] = { 0 };
1603 ssize_t size = read(fd, buf, len);
1604 if (size <= 0) {
1605 HILOG_ERROR("read user config file failed!");
1606 close(fd);
1607 return;
1608 }
1609 close(fd);
1610
1611 if (buf[0] == '\0') {
1612 return;
1613 }
1614 WallpaperData systemData;
1615 WallpaperData lockScreenData;
1616 if (!GetWallpaperSafeLocked(userId, WALLPAPER_SYSTEM, systemData)
1617 || !GetWallpaperSafeLocked(userId, WALLPAPER_LOCKSCREEN, lockScreenData)) {
1618 return;
1619 }
1620 if (Json::accept(buf)) {
1621 auto root = nlohmann::json::parse(buf);
1622 if (root.contains(SYSTEM_RES_TYPE) && root[SYSTEM_RES_TYPE].is_number()) {
1623 systemData.resourceType = static_cast<WallpaperResourceType>(root[SYSTEM_RES_TYPE].get<int>());
1624 }
1625 if (root.contains(LOCKSCREEN_RES_TYPE) && root[SYSTEM_RES_TYPE].is_number()) {
1626 lockScreenData.resourceType = static_cast<WallpaperResourceType>(root[LOCKSCREEN_RES_TYPE].get<int>());
1627 }
1628 }
1629 }
1630
GetDefaultResDir()1631 std::string WallpaperService::GetDefaultResDir()
1632 {
1633 std::string resPath;
1634 CfgFiles *cfgFiles = GetCfgFiles(RESOURCE_PATH);
1635 if (cfgFiles != nullptr) {
1636 for (auto &cfgPath : cfgFiles->paths) {
1637 if (cfgPath != nullptr) {
1638 HILOG_DEBUG("GetCfgFiles path is :%{public}s", cfgPath);
1639 resPath = cfgPath + std::string(DEFAULT_PATH);
1640 break;
1641 }
1642 }
1643 FreeCfgFiles(cfgFiles);
1644 }
1645 return resPath;
1646 }
1647
GetWallpaperPathInJson(const std::string manifestName,const std::string filePath)1648 std::string WallpaperService::GetWallpaperPathInJson(const std::string manifestName, const std::string filePath)
1649 {
1650 std::string wallpaperPath;
1651 std::string resPath = GetDefaultResDir();
1652 if (resPath.empty() && !FileDeal::IsDirExist(resPath)) {
1653 HILOG_ERROR("wallpaperDefaultDir get failed!");
1654 return "";
1655 }
1656 std::string manifestFile = resPath + manifestName;
1657 std::ifstream file(manifestFile);
1658 if (!file.is_open()) {
1659 HILOG_ERROR("open fail:%{public}s", manifestFile.c_str());
1660 file.close();
1661 return "";
1662 }
1663 std::string content((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
1664 file.close();
1665 if (!nlohmann::json::accept(content)) {
1666 HILOG_ERROR("accept failed!");
1667 return "";
1668 }
1669 auto root = nlohmann::json::parse(content.c_str());
1670 if (root.contains(IMAGE) && root[IMAGE].contains(SRC)) {
1671 std::string srcValue = root[IMAGE][SRC];
1672 return GetExistFilePath(resPath + filePath + srcValue);
1673 }
1674 HILOG_ERROR("src not exist.");
1675 return "";
1676 }
1677
GetExistFilePath(const std::string & filePath)1678 std::string WallpaperService::GetExistFilePath(const std::string &filePath)
1679 {
1680 if (!FileDeal::IsFileExist(filePath)) {
1681 HILOG_ERROR("path file is not exist! %{public}s", filePath.c_str());
1682 return "";
1683 }
1684 return filePath;
1685 }
SetAllWallpapers(std::vector<WallpaperPictureInfo> allWallpaperInfos,int32_t wallpaperType)1686 ErrorCode WallpaperService::SetAllWallpapers(std::vector<WallpaperPictureInfo> allWallpaperInfos, int32_t wallpaperType)
1687 {
1688 StartAsyncTrace(HITRACE_TAG_MISC, "SetAllWallpapers", static_cast<int32_t>(TraceTaskId::SET_ALL_WALLPAPERS));
1689 ErrorCode wallpaperErrorCode = SetAllWallpapers(allWallpaperInfos, wallpaperType, PICTURE);
1690 FinishAsyncTrace(HITRACE_TAG_MISC, "SetAllWallpapers", static_cast<int32_t>(TraceTaskId::SET_ALL_WALLPAPERS));
1691 return wallpaperErrorCode;
1692 }
1693
SetAllWallpapers(std::vector<WallpaperPictureInfo> allWallpaperInfos,int32_t wallpaperType,WallpaperResourceType resourceType)1694 ErrorCode WallpaperService::SetAllWallpapers(
1695 std::vector<WallpaperPictureInfo> allWallpaperInfos, int32_t wallpaperType, WallpaperResourceType resourceType)
1696 {
1697 StartAsyncTrace(HITRACE_TAG_MISC, "SetAllWallpapers", static_cast<int32_t>(TraceTaskId::SET_ALL_WALLPAPERS));
1698 if (!IsSystemApp()) {
1699 HILOG_ERROR("CallingApp is not SystemApp.");
1700 return E_NOT_SYSTEM_APP;
1701 }
1702 int32_t userId = QueryActiveUserId();
1703 HILOG_INFO("SetAllWallpapers userId: %{public}d", userId);
1704 if (!CheckUserPermissionById(userId)) {
1705 return E_USER_IDENTITY_ERROR;
1706 }
1707 ErrorCode errCode;
1708 for (auto &wallpaperInfo : allWallpaperInfos) {
1709 wallpaperInfo.tempPath = std::string(WALLPAPER_USERID_PATH) + GetFoldStateName(wallpaperInfo.foldState) + "_"
1710 + GetRotateStateName(wallpaperInfo.rotateState);
1711 errCode = CheckValid(wallpaperType, wallpaperInfo.length, resourceType);
1712 if (errCode != E_OK) {
1713 return errCode;
1714 }
1715 errCode = WriteFdToFile(wallpaperInfo, wallpaperInfo.tempPath);
1716 if (errCode != E_OK) {
1717 DeleteTempResource(allWallpaperInfos);
1718 HILOG_ERROR("WriteFdToFile failed!");
1719 return errCode;
1720 }
1721 }
1722 WallpaperType type = static_cast<WallpaperType>(wallpaperType);
1723 std::string wallpaperPath = GetWallpaperDir(userId, type);
1724 FileDeal::DeleteDir(wallpaperPath, false);
1725 errCode = UpdateWallpaperData(allWallpaperInfos, userId, type);
1726 if (errCode != E_OK) {
1727 HILOG_ERROR("UpdateWallpaperData failed!");
1728 return errCode;
1729 }
1730 SaveColor(userId, type);
1731 if (!SendWallpaperChangeEvent(userId, type)) {
1732 HILOG_ERROR("Send wallpaper state failed!");
1733 return E_DEAL_FAILED;
1734 }
1735 FinishAsyncTrace(HITRACE_TAG_MISC, "SetAllWallpapers", static_cast<int32_t>(TraceTaskId::SET_ALL_WALLPAPERS));
1736 return errCode;
1737 }
1738
UpdateWallpaperData(std::vector<WallpaperPictureInfo> allWallpaperInfos,int32_t userId,WallpaperType wallpaperType)1739 ErrorCode WallpaperService::UpdateWallpaperData(
1740 std::vector<WallpaperPictureInfo> allWallpaperInfos, int32_t userId, WallpaperType wallpaperType)
1741 {
1742 ErrorCode errCode;
1743 WallpaperData wallpaperData;
1744 bool ret = GetWallpaperSafeLocked(userId, wallpaperType, wallpaperData);
1745 if (!ret) {
1746 HILOG_ERROR("GetWallpaperSafeLocked failed!");
1747 return E_DEAL_FAILED;
1748 }
1749 ClearnWallpaperDataFile(wallpaperData);
1750 errCode = SetAllWallpaperBackupData(allWallpaperInfos, userId, wallpaperType, wallpaperData);
1751 if (errCode != E_OK) {
1752 DeleteTempResource(allWallpaperInfos);
1753 HILOG_ERROR("SetAllWallpaperBackupData failed!");
1754 return errCode;
1755 }
1756 wallpaperData.resourceType = PICTURE;
1757 wallpaperData.wallpaperId = MakeWallpaperIdLocked();
1758 if (wallpaperType == WALLPAPER_SYSTEM) {
1759 systemWallpaperMap_.InsertOrAssign(userId, wallpaperData);
1760 } else if (wallpaperType == WALLPAPER_LOCKSCREEN) {
1761 lockWallpaperMap_.InsertOrAssign(userId, wallpaperData);
1762 }
1763 return E_OK;
1764 }
1765
WriteFdToFile(WallpaperPictureInfo & wallpaperPictureInfo,std::string & path)1766 ErrorCode WallpaperService::WriteFdToFile(WallpaperPictureInfo &wallpaperPictureInfo, std::string &path)
1767 {
1768 std::lock_guard<std::mutex> lock(mtx_);
1769 char *wallpaperBuffer = new (std::nothrow) char[wallpaperPictureInfo.length]();
1770 if (wallpaperBuffer == nullptr) {
1771 HILOG_ERROR("create wallpaperBuffer failed!");
1772 return E_NO_MEMORY;
1773 }
1774 if (read(wallpaperPictureInfo.fd, wallpaperBuffer, wallpaperPictureInfo.length) <= 0) {
1775 HILOG_ERROR("read fd failed!");
1776 delete[] wallpaperBuffer;
1777 return E_DEAL_FAILED;
1778 }
1779 mode_t mode = S_IRUSR | S_IWUSR;
1780 int32_t fdw = open(path.c_str(), O_WRONLY | O_CREAT, mode);
1781 if (fdw < 0) {
1782 HILOG_ERROR("Open wallpaper tmpFullPath failed, errno %{public}d", errno);
1783 delete[] wallpaperBuffer;
1784 return E_DEAL_FAILED;
1785 }
1786 if (write(fdw, wallpaperBuffer, wallpaperPictureInfo.length) <= 0) {
1787 HILOG_ERROR("Write to fdw failed, errno %{public}d", errno);
1788 ReporterFault(FaultType::SET_WALLPAPER_FAULT, FaultCode::RF_DROP_FAILED);
1789 delete[] wallpaperBuffer;
1790 close(fdw);
1791 return E_DEAL_FAILED;
1792 }
1793 delete[] wallpaperBuffer;
1794 close(fdw);
1795 return E_OK;
1796 }
1797
SetAllWallpaperBackupData(std::vector<WallpaperPictureInfo> allWallpaperInfos,int32_t userId,WallpaperType wallpaperType,WallpaperData & wallpaperData)1798 ErrorCode WallpaperService::SetAllWallpaperBackupData(std::vector<WallpaperPictureInfo> allWallpaperInfos,
1799 int32_t userId, WallpaperType wallpaperType, WallpaperData &wallpaperData)
1800 {
1801 HILOG_INFO("set All wallpaper and backup data Start.");
1802 for (auto &wallpaperInfo : allWallpaperInfos) {
1803 if (!OHOS::FileExists(wallpaperInfo.tempPath)) {
1804 return E_DEAL_FAILED;
1805 }
1806 UpdateWallpaperDataFile(wallpaperInfo, userId, wallpaperType, wallpaperData);
1807 std::string wallpaperFile = GetWallpaperDataFile(wallpaperInfo, userId, wallpaperType);
1808 {
1809 std::lock_guard<std::mutex> lock(mtx_);
1810 if (!FileDeal::CopyFile(wallpaperInfo.tempPath, wallpaperFile)) {
1811 HILOG_ERROR("CopyFile failed!");
1812 FileDeal::DeleteFile(wallpaperInfo.tempPath);
1813 return E_DEAL_FAILED;
1814 }
1815 if (!FileDeal::DeleteFile(wallpaperInfo.tempPath)) {
1816 return E_DEAL_FAILED;
1817 }
1818 }
1819 }
1820 return E_OK;
1821 }
1822
UpdateWallpaperDataFile(WallpaperPictureInfo & wallpaperPictureInfo,int32_t userId,WallpaperType wallpaperType,WallpaperData & wallpaperData)1823 void WallpaperService::UpdateWallpaperDataFile(WallpaperPictureInfo &wallpaperPictureInfo, int32_t userId,
1824 WallpaperType wallpaperType, WallpaperData &wallpaperData)
1825 {
1826 switch (static_cast<FoldState>(wallpaperPictureInfo.foldState)) {
1827 case FoldState::NORMAL:
1828 if (static_cast<RotateState>(wallpaperPictureInfo.rotateState) == RotateState::PORT) {
1829 wallpaperData.wallpaperFile = GetWallpaperDir(userId, wallpaperType) + "/"
1830 + (wallpaperType == WALLPAPER_SYSTEM ? WALLPAPER_HOME : WALLPAPER_LOCK);
1831 } else if (static_cast<RotateState>(wallpaperPictureInfo.rotateState) == RotateState::LAND) {
1832 wallpaperData.normalLandFile = GetWallpaperDataFile(wallpaperPictureInfo, userId, wallpaperType);
1833 }
1834 break;
1835
1836 case FoldState::UNFOLD_1:
1837 if (static_cast<RotateState>(wallpaperPictureInfo.rotateState) == RotateState::PORT) {
1838 wallpaperData.unfoldedOnePortFile = GetWallpaperDataFile(wallpaperPictureInfo, userId, wallpaperType);
1839 } else if (static_cast<RotateState>(wallpaperPictureInfo.rotateState) == RotateState::LAND) {
1840 wallpaperData.unfoldedOneLandFile = GetWallpaperDataFile(wallpaperPictureInfo, userId, wallpaperType);
1841 }
1842 break;
1843
1844 case FoldState::UNFOLD_2:
1845 if (static_cast<RotateState>(wallpaperPictureInfo.rotateState) == RotateState::PORT) {
1846 wallpaperData.unfoldedTwoPortFile = GetWallpaperDataFile(wallpaperPictureInfo, userId, wallpaperType);
1847 } else if (static_cast<RotateState>(wallpaperPictureInfo.rotateState) == RotateState::LAND) {
1848 wallpaperData.unfoldedTwoLandFile = GetWallpaperDataFile(wallpaperPictureInfo, userId, wallpaperType);
1849 }
1850 break;
1851 default:
1852 break;
1853 }
1854 }
1855
GetWallpaperDataFile(WallpaperPictureInfo & wallpaperPictureInfo,int32_t userId,WallpaperType wallpaperType)1856 std::string WallpaperService::GetWallpaperDataFile(
1857 WallpaperPictureInfo &wallpaperPictureInfo, int32_t userId, WallpaperType wallpaperType)
1858 {
1859 std::string wallpaperTypeName = wallpaperType == WALLPAPER_SYSTEM ? WALLPAPER_HOME : WALLPAPER_LOCK;
1860 std::string foldStateName = GetFoldStateName(wallpaperPictureInfo.foldState);
1861 std::string rotateStateName = GetRotateStateName(wallpaperPictureInfo.rotateState);
1862 if (foldStateName == "normal" && rotateStateName == "port") {
1863 return GetWallpaperDir(userId, wallpaperType) + "/" + wallpaperTypeName;
1864 }
1865 std::string wallpaperFile =
1866 GetWallpaperDir(userId, wallpaperType) + "/" + foldStateName + "_" + rotateStateName + "_" + wallpaperTypeName;
1867 return wallpaperFile;
1868 }
1869
ClearnWallpaperDataFile(WallpaperData & wallpaperData)1870 void WallpaperService::ClearnWallpaperDataFile(WallpaperData &wallpaperData)
1871 {
1872 wallpaperData.normalLandFile = "";
1873 wallpaperData.unfoldedOnePortFile = "";
1874 wallpaperData.unfoldedOneLandFile = "";
1875 wallpaperData.unfoldedTwoPortFile = "";
1876 wallpaperData.unfoldedTwoLandFile = "";
1877 }
1878
GetCorrespondWallpaper(int32_t wallpaperType,int32_t foldState,int32_t rotateState,IWallpaperService::FdInfo & fdInfo)1879 ErrorCode WallpaperService::GetCorrespondWallpaper(
1880 int32_t wallpaperType, int32_t foldState, int32_t rotateState, IWallpaperService::FdInfo &fdInfo)
1881 {
1882 StartAsyncTrace(
1883 HITRACE_TAG_MISC, "GetCorrespondWallpaper", static_cast<int32_t>(TraceTaskId::GET_CORRESPOND_WALLPAPER));
1884 HILOG_DEBUG("WallpaperService::GetCorrespondWallpaper start.");
1885 if (!IsSystemApp()) {
1886 HILOG_ERROR("CallingApp is not SystemApp.");
1887 return E_NOT_SYSTEM_APP;
1888 }
1889 if (!CheckCallingPermission(WALLPAPER_PERMISSION_NAME_GET_WALLPAPER)) {
1890 HILOG_ERROR("GetPixelMap no get permission!");
1891 return E_NO_PERMISSION;
1892 }
1893 if (wallpaperType != static_cast<int32_t>(WALLPAPER_LOCKSCREEN)
1894 && wallpaperType != static_cast<int32_t>(WALLPAPER_SYSTEM)) {
1895 return E_PARAMETERS_INVALID;
1896 }
1897 auto type = static_cast<WallpaperType>(wallpaperType);
1898 int32_t userId = QueryActiveUserId();
1899 HILOG_INFO("QueryCurrentOsAccount userId: %{public}d", userId);
1900 // current user's wallpaper is live video, not image
1901 WallpaperResourceType resType = GetResType(userId, type);
1902 if (resType != PICTURE && resType != DEFAULT) {
1903 HILOG_ERROR("Current user's wallpaper is live video, not image.");
1904 fdInfo.size = 0; // 0: empty file size
1905 fdInfo.fd = -1; // -1: invalid file description
1906 return E_OK;
1907 }
1908 ErrorCode ret = GetImageSize(userId, type, fdInfo.size, foldState, rotateState);
1909 if (ret != E_OK) {
1910 HILOG_ERROR("GetImageSize failed!");
1911 return ret;
1912 }
1913 ret = GetImageFd(userId, type, fdInfo.fd, foldState, rotateState);
1914 if (ret != E_OK) {
1915 HILOG_ERROR("GetImageFd failed!");
1916 return ret;
1917 }
1918 return E_OK;
1919 }
1920
GetImageSize(int32_t userId,WallpaperType wallpaperType,int32_t & size,int32_t foldState,int32_t rotateState)1921 ErrorCode WallpaperService::GetImageSize(
1922 int32_t userId, WallpaperType wallpaperType, int32_t &size, int32_t foldState, int32_t rotateState)
1923 {
1924 HILOG_DEBUG("WallpaperService::GetImageSize start.");
1925 std::string filePathName;
1926 if (!GetWallpaperDataPath(userId, wallpaperType, filePathName, foldState, rotateState)) {
1927 return E_DEAL_FAILED;
1928 }
1929 HILOG_INFO("GetImageSize file: %{public}s", filePathName.c_str());
1930 if (!OHOS::FileExists(filePathName)) {
1931 HILOG_ERROR("file is not exist.");
1932 return E_NOT_FOUND;
1933 }
1934 std::lock_guard<std::mutex> lock(mtx_);
1935 FILE *fd = fopen(filePathName.c_str(), "rb");
1936 if (fd == nullptr) {
1937 HILOG_ERROR("fopen file failed, errno %{public}d", errno);
1938 return E_FILE_ERROR;
1939 }
1940 int32_t fend = fseek(fd, 0, SEEK_END);
1941 size = ftell(fd);
1942 int32_t fset = fseek(fd, 0, SEEK_SET);
1943 if (size <= 0 || fend != 0 || fset != 0) {
1944 HILOG_ERROR("ftell file failed or fseek file failed, errno %{public}d", errno);
1945 fclose(fd);
1946 return E_FILE_ERROR;
1947 }
1948 fclose(fd);
1949 return E_OK;
1950 }
1951
GetImageFd(int32_t userId,WallpaperType wallpaperType,int32_t & fd,int32_t foldState,int32_t rotateState)1952 ErrorCode WallpaperService::GetImageFd(
1953 int32_t userId, WallpaperType wallpaperType, int32_t &fd, int32_t foldState, int32_t rotateState)
1954 {
1955 HILOG_DEBUG("WallpaperService::GetImageFd start.");
1956 std::string filePathName;
1957 if (!GetWallpaperDataPath(userId, wallpaperType, filePathName, foldState, rotateState)) {
1958 return E_DEAL_FAILED;
1959 }
1960 if (GetResType(userId, wallpaperType) == WallpaperResourceType::PACKAGE) {
1961 HILOG_INFO("The current wallpaper is a custom wallpaper");
1962 return E_OK;
1963 }
1964 fd = open(filePathName.c_str(), O_RDONLY, S_IREAD);
1965 if (fd < 0) {
1966 HILOG_ERROR("Open file failed, errno %{public}d", errno);
1967 ReporterFault(FaultType::LOAD_WALLPAPER_FAULT, FaultCode::RF_FD_INPUT_FAILED);
1968 return E_DEAL_FAILED;
1969 }
1970 HILOG_INFO("fd = %{public}d", fd);
1971 return E_OK;
1972 }
1973
GetWallpaperDataPath(int32_t userId,WallpaperType wallpaperType,std::string & filePathName,int32_t foldState,int32_t rotateState)1974 bool WallpaperService::GetWallpaperDataPath(
1975 int32_t userId, WallpaperType wallpaperType, std::string &filePathName, int32_t foldState, int32_t rotateState)
1976 {
1977 auto iterator = wallpaperType == WALLPAPER_SYSTEM ? systemWallpaperMap_.Find(userId)
1978 : lockWallpaperMap_.Find(userId);
1979 if (!iterator.first) {
1980 HILOG_INFO("WallpaperType:%{public}d, WallpaperMap not found userId: %{public}d", wallpaperType, userId);
1981 OnInitUser(userId);
1982 iterator = wallpaperType == WALLPAPER_SYSTEM ? systemWallpaperMap_.Find(userId)
1983 : lockWallpaperMap_.Find(userId);
1984 }
1985 filePathName = GetWallpaperPath(foldState, rotateState, iterator.second);
1986 return filePathName != "";
1987 }
1988
GetWallpaperPath(int32_t foldState,int32_t rotateState,WallpaperData & wallpaperData)1989 std::string WallpaperService::GetWallpaperPath(int32_t foldState, int32_t rotateState, WallpaperData &wallpaperData)
1990 {
1991 std::string wallpaperFilePath;
1992 if (foldState == static_cast<int32_t>(FoldState::UNFOLD_2)) {
1993 if (rotateState == static_cast<int32_t>(RotateState::LAND)) {
1994 wallpaperFilePath = wallpaperData.unfoldedTwoLandFile;
1995 if (wallpaperFilePath != "") {
1996 return wallpaperFilePath;
1997 }
1998 }
1999 wallpaperFilePath = wallpaperData.unfoldedTwoPortFile;
2000 if (wallpaperFilePath != "") {
2001 return wallpaperFilePath;
2002 }
2003 wallpaperFilePath = wallpaperData.wallpaperFile;
2004 }
2005 if (foldState == static_cast<int32_t>(FoldState::UNFOLD_1)) {
2006 if (rotateState == static_cast<int32_t>(RotateState::LAND)) {
2007 wallpaperFilePath = wallpaperData.unfoldedOneLandFile;
2008 if (wallpaperFilePath != "") {
2009 return wallpaperFilePath;
2010 }
2011 }
2012 wallpaperFilePath = wallpaperData.unfoldedOnePortFile;
2013 if (wallpaperFilePath != "") {
2014 return wallpaperFilePath;
2015 }
2016 wallpaperFilePath = wallpaperData.wallpaperFile;
2017 }
2018 if (foldState == static_cast<int32_t>(FoldState::NORMAL)) {
2019 if (rotateState == static_cast<int32_t>(RotateState::LAND)) {
2020 wallpaperFilePath = wallpaperData.normalLandFile;
2021 if (wallpaperFilePath != "") {
2022 return wallpaperFilePath;
2023 }
2024 }
2025 wallpaperFilePath = wallpaperData.wallpaperFile;
2026 }
2027 return wallpaperFilePath;
2028 }
2029
DeleteTempResource(std::vector<WallpaperPictureInfo> & tempResourceFiles)2030 void WallpaperService::DeleteTempResource(std::vector<WallpaperPictureInfo> &tempResourceFiles)
2031 {
2032 for (auto &wallpaperFile : tempResourceFiles) {
2033 FileDeal::DeleteFile(wallpaperFile.tempPath);
2034 }
2035 }
2036
GetFoldStateName(FoldState foldState)2037 std::string WallpaperService::GetFoldStateName(FoldState foldState)
2038 {
2039 std::string foldStateName;
2040 switch (foldState) {
2041 case FoldState::NORMAL:
2042 foldStateName = "normal";
2043 break;
2044 case FoldState::UNFOLD_1:
2045 foldStateName = "unfold1";
2046 break;
2047 case FoldState::UNFOLD_2:
2048 foldStateName = "unfold2";
2049 break;
2050 default:
2051 break;
2052 }
2053 return foldStateName;
2054 }
2055
GetRotateStateName(RotateState rotateState)2056 std::string WallpaperService::GetRotateStateName(RotateState rotateState)
2057 {
2058 std::string rotateStateName;
2059 switch (rotateState) {
2060 case RotateState::PORT:
2061 rotateStateName = "port";
2062 break;
2063 case RotateState::LAND:
2064 rotateStateName = "land";
2065 break;
2066 default:
2067 break;
2068 }
2069 return rotateStateName;
2070 }
2071 } // namespace WallpaperMgrService
2072 } // namespace OHOS
2073
