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
72namespace OHOS {
73namespace WallpaperMgrService {
74REGISTER_SYSTEM_ABILITY_BY_ID(WallpaperService, WALLPAPER_MANAGER_SERVICE_ID, true);
75
76using namespace OHOS::Media;
77using namespace OHOS::MiscServices;
78using namespace OHOS::Security::AccessToken;
79using namespace OHOS::AccountSA;
80
81constexpr const char *WALLPAPER_SYSTEM_ORIG = "wallpaper_system_orig";
82constexpr const char *WALLPAPER_HOME = "wallpaper_home";
83constexpr const char *WALLPAPER_LOCK_ORIG = "wallpaper_lock_orig";
84constexpr const char *WALLPAPER_LOCK = "wallpaper_lock";
85constexpr const char *LIVE_WALLPAPER_SYSTEM_ORIG = "live_wallpaper_system_orig";
86constexpr const char *LIVE_WALLPAPER_LOCK_ORIG = "live_wallpaper_lock_orig";
87constexpr const char *CUSTOM_WALLPAPER_LOCK = "custom_lock.zip";
88constexpr const char *CUSTOM_WALLPAPER_SYSTEM = "custom_system.zip";
89constexpr const char *OHOS_WALLPAPER_BUNDLE_NAME = "com.ohos.launcher";
90constexpr const char *SHOW_SYSTEM_SCREEN = "SHOW_SYSTEMSCREEN";
91constexpr const char *SHOW_LOCK_SCREEN = "SHOW_LOCKSCREEN";
92constexpr const char *SYSTEM_RES_TYPE = "SystemResType";
93constexpr const char *LOCKSCREEN_RES_TYPE = "LockScreenResType";
94constexpr const char *WALLPAPER_CHANGE = "wallpaperChange";
95constexpr const char *COLOR_CHANGE = "colorChange";
96constexpr const char *SCENEBOARD_BUNDLE_NAME = "com.ohos.sceneboard";
97
98constexpr const char *WALLPAPER_USERID_PATH = "/data/service/el1/public/wallpaper/";
99constexpr const char *WALLPAPER_SYSTEM_DIRNAME = "system";
100constexpr const char *WALLPAPER_TMP_DIRNAME = "fwsettmp";
101constexpr const char *WALLPAPER_LOCKSCREEN_DIRNAME = "lockscreen";
102constexpr const char *WALLPAPER_DEFAULT_FILEFULLPATH = "/system/etc/wallpaperdefault.jpeg";
103constexpr const char *WALLPAPER_DEFAULT_LOCK_FILEFULLPATH = "/system/etc/wallpaperlockdefault.jpeg";
104constexpr const char *WALLPAPER_CROP_PICTURE = "crop_file";
105constexpr const char *RESOURCE_PATH = "resource/themes/theme/";
106constexpr const char *DEFAULT_PATH = "default/";
107constexpr const char *HOME_MANIFEST = "home/manifest.json";
108constexpr const char *LOCK_MANIFEST = "lock/manifest.json";
109constexpr const char *HOME_RES = "home/base/resources/";
110constexpr const char *LOCK_RES = "lock/base/resources/";
111constexpr const char *IMAGE = "image";
112constexpr const char *SRC = "src";
113
114constexpr int64_t INIT_INTERVAL = 10000L;
115constexpr int64_t DELAY_TIME = 1000L;
116constexpr int64_t QUERY_USER_ID_INTERVAL = 300L;
117constexpr int32_t FOO_MAX_LEN = 52428800;
118constexpr int32_t MAX_RETRY_TIMES = 20;
119constexpr int32_t QUERY_USER_MAX_RETRY_TIMES = 100;
120constexpr int32_t DEFAULT_WALLPAPER_ID = -1;
121constexpr int32_t DEFAULT_USER_ID = 0;
122constexpr int32_t MAX_VIDEO_SIZE = 104857600;
123constexpr int32_t OPTION_QUALITY = 100;
124
125#ifndef THEME_SERVICE
126constexpr int32_t CONNECT_EXTENSION_INTERVAL = 100;
127constexpr int32_t DEFAULT_VALUE = -1;
128constexpr int32_t CONNECT_EXTENSION_MAX_RETRY_TIMES = 50;
129#endif
130
131std::mutex WallpaperService::instanceLock_;
132
133sptr<WallpaperService> WallpaperService::instance_;
134
135std::shared_ptr<AppExecFwk::EventHandler> WallpaperService::serviceHandler_;
136
137WallpaperService::WallpaperService(int32_t systemAbilityId, bool runOnCreate)
138    : SystemAbility(systemAbilityId, runOnCreate), WallpaperServiceStub(true),
139      state_(ServiceRunningState::STATE_NOT_START)
140{
141}
142
143WallpaperService::WallpaperService() : WallpaperServiceStub(true), state_(ServiceRunningState::STATE_NOT_START)
144{
145}
146
147WallpaperService::~WallpaperService()
148{
149}
150
151int32_t WallpaperService::Init()
152{
153    InitQueryUserId(QUERY_USER_MAX_RETRY_TIMES);
154    bool ret = Publish(this);
155    if (!ret) {
156        HILOG_ERROR("Publish failed!");
157        ReporterFault(FaultType::SERVICE_FAULT, FaultCode::SF_SERVICE_UNAVAILABLE);
158        return -1;
159    }
160    HILOG_INFO("Publish success.");
161    state_ = ServiceRunningState::STATE_RUNNING;
162#ifndef THEME_SERVICE
163    StartExtensionAbility(CONNECT_EXTENSION_MAX_RETRY_TIMES);
164#endif
165    return E_OK;
166}
167
168void WallpaperService::OnStart()
169{
170    HILOG_INFO("Enter OnStart.");
171    MemoryGuard cacheGuard;
172    if (state_ == ServiceRunningState::STATE_RUNNING) {
173        HILOG_ERROR("WallpaperService is already running.");
174        return;
175    }
176    InitData();
177    InitServiceHandler();
178    AddSystemAbilityListener(COMMON_EVENT_SERVICE_ID);
179    AddSystemAbilityListener(MEMORY_MANAGER_SA_ID);
180    auto cmd = std::make_shared<Command>(std::vector<std::string>({ "-all" }), "Show all",
181        [this](const std::vector<std::string> &input, std::string &output) -> bool {
182            output.append(
183                "WallpaperExtensionAbility\t: ExtensionInfo{" + std::string(OHOS_WALLPAPER_BUNDLE_NAME) + "}\n");
184            return true;
185        });
186    DumpHelper::GetInstance().RegisterCommand(cmd);
187    if (Init() != E_OK) {
188        auto callback = [=]() { Init(); };
189        serviceHandler_->PostTask(callback, INIT_INTERVAL);
190        HILOG_ERROR("Init failed. Try again 10s later.");
191    }
192    return;
193}
194
195void WallpaperService::OnAddSystemAbility(int32_t systemAbilityId, const std::string &deviceId)
196{
197    HILOG_INFO("OnAddSystemAbility systemAbilityId:%{public}d added!", systemAbilityId);
198    if (systemAbilityId == COMMON_EVENT_SERVICE_ID) {
199        int32_t times = 0;
200        RegisterSubscriber(times);
201    } else if (systemAbilityId == MEMORY_MANAGER_SA_ID) {
202        int32_t pid = getpid();
203        Memory::MemMgrClient::GetInstance().NotifyProcessStatus(pid, 1, 1, WALLPAPER_MANAGER_SERVICE_ID);
204    }
205}
206
207void WallpaperService::RegisterSubscriber(int32_t times)
208{
209    MemoryGuard cacheGuard;
210    times++;
211    subscriber_ = std::make_shared<WallpaperCommonEventSubscriber>(*this);
212    bool subRes = OHOS::EventFwk::CommonEventManager::SubscribeCommonEvent(subscriber_);
213    if (!subRes && times <= MAX_RETRY_TIMES) {
214        HILOG_INFO("RegisterSubscriber failed!");
215        auto callback = [this, times]() { RegisterSubscriber(times); };
216        serviceHandler_->PostTask(callback, DELAY_TIME);
217    }
218}
219
220void WallpaperService::InitServiceHandler()
221{
222    HILOG_INFO("InitServiceHandler started.");
223    if (serviceHandler_ != nullptr) {
224        HILOG_ERROR("InitServiceHandler already init.");
225        return;
226    }
227    std::shared_ptr<AppExecFwk::EventRunner> runner =
228        AppExecFwk::EventRunner::Create("WallpaperService", AppExecFwk::ThreadMode::FFRT);
229    serviceHandler_ = std::make_shared<AppExecFwk::EventHandler>(runner);
230}
231
232void WallpaperService::OnStop()
233{
234    HILOG_INFO("OnStop started.");
235    if (state_ != ServiceRunningState::STATE_RUNNING) {
236        return;
237    }
238    serviceHandler_ = nullptr;
239#ifndef THEME_SERVICE
240    connection_ = nullptr;
241#endif
242    recipient_ = nullptr;
243    extensionRemoteObject_ = nullptr;
244    if (subscriber_ != nullptr) {
245        bool unSubscribeResult = OHOS::EventFwk::CommonEventManager::UnSubscribeCommonEvent(subscriber_);
246        subscriber_ = nullptr;
247        HILOG_INFO("UnregisterSubscriber end, unSubscribeResult = %{public}d", unSubscribeResult);
248    }
249    state_ = ServiceRunningState::STATE_NOT_START;
250    int32_t pid = getpid();
251    Memory::MemMgrClient::GetInstance().NotifyProcessStatus(pid, 1, 0, WALLPAPER_MANAGER_SERVICE_ID);
252}
253
254void WallpaperService::InitData()
255{
256    HILOG_INFO("WallpaperService::initData --> start.");
257    wallpaperId_ = DEFAULT_WALLPAPER_ID;
258    int32_t userId = DEFAULT_USER_ID;
259    systemWallpaperMap_.Clear();
260    lockWallpaperMap_.Clear();
261    wallpaperTmpFullPath_ = std::string(WALLPAPER_USERID_PATH) + std::string(WALLPAPER_TMP_DIRNAME);
262    wallpaperCropPath_ = std::string(WALLPAPER_USERID_PATH) + std::string(WALLPAPER_CROP_PICTURE);
263    {
264        std::lock_guard<std::mutex> lock(wallpaperColorMtx_);
265        systemWallpaperColor_ = 0;
266        lockWallpaperColor_ = 0;
267    }
268    currentUserId_ = userId;
269    wallpaperEventMap_.clear();
270    appBundleName_ = SCENEBOARD_BUNDLE_NAME;
271    InitUserDir(userId);
272    UpdataWallpaperMap(userId, WALLPAPER_SYSTEM);
273    UpdataWallpaperMap(userId, WALLPAPER_LOCKSCREEN);
274    LoadWallpaperState();
275    ClearRedundantFile(userId, WALLPAPER_SYSTEM, WALLPAPER_SYSTEM_ORIG);
276    ClearRedundantFile(userId, WALLPAPER_LOCKSCREEN, WALLPAPER_LOCK_ORIG);
277}
278
279#ifndef THEME_SERVICE
280void WallpaperService::AddWallpaperExtensionDeathRecipient(const sptr<IRemoteObject> &remoteObject)
281{
282    if (remoteObject != nullptr) {
283        std::lock_guard<std::mutex> lock(remoteObjectMutex_);
284        IPCObjectProxy *proxy = reinterpret_cast<IPCObjectProxy *>(remoteObject.GetRefPtr());
285        if (recipient_ == nullptr) {
286            recipient_ = sptr<IRemoteObject::DeathRecipient>(new WallpaperExtensionAbilityDeathRecipient(*this));
287        }
288        if (proxy != nullptr && !proxy->IsObjectDead()) {
289            HILOG_INFO("get remoteObject succeed.");
290            proxy->AddDeathRecipient(recipient_);
291            extensionRemoteObject_ = remoteObject;
292        }
293    }
294}
295#endif
296
297void WallpaperService::RemoveExtensionDeathRecipient()
298{
299    if (extensionRemoteObject_ != nullptr && recipient_ != nullptr) {
300        HILOG_INFO("Remove Extension DeathRecipient.");
301        std::lock_guard<std::mutex> lock(remoteObjectMutex_);
302        if (extensionRemoteObject_ != nullptr) {
303            extensionRemoteObject_->RemoveDeathRecipient(recipient_);
304            recipient_ = nullptr;
305            extensionRemoteObject_ = nullptr;
306        }
307    }
308}
309
310void WallpaperService::InitQueryUserId(int32_t times)
311{
312    times--;
313    bool ret = InitUsersOnBoot();
314    if (!ret && times > 0) {
315        HILOG_DEBUG("InitQueryUserId failed!");
316        auto callback = [this, times]() { InitQueryUserId(times); };
317        serviceHandler_->PostTask(callback, QUERY_USER_ID_INTERVAL);
318    }
319}
320
321#ifndef THEME_SERVICE
322void WallpaperService::StartExtensionAbility(int32_t times)
323{
324    times--;
325    bool ret = ConnectExtensionAbility();
326    if (!ret && times > 0 && serviceHandler_ != nullptr) {
327        HILOG_ERROR("StartExtensionAbilty failed, remainder of the times: %{public}d", times);
328        auto callback = [this, times]() { StartExtensionAbility(times); };
329        serviceHandler_->PostTask(callback, CONNECT_EXTENSION_INTERVAL);
330    }
331}
332#endif
333
334bool WallpaperService::InitUsersOnBoot()
335{
336    std::vector<AccountSA::OsAccountInfo> osAccountInfos;
337    ErrCode errCode = AccountSA::OsAccountManager::QueryAllCreatedOsAccounts(osAccountInfos);
338    if (errCode != ERR_OK || osAccountInfos.empty()) {
339        HILOG_ERROR("Query all created userIds failed, errCode:%{public}d", errCode);
340        return false;
341    }
342    for (const auto &osAccountInfo : osAccountInfos) {
343        int32_t userId = osAccountInfo.GetLocalId();
344        HILOG_INFO("InitUsersOnBoot Current userId: %{public}d", userId);
345        InitUserDir(userId);
346        UpdataWallpaperMap(userId, WALLPAPER_SYSTEM);
347        UpdataWallpaperMap(userId, WALLPAPER_LOCKSCREEN);
348        ClearRedundantFile(userId, WALLPAPER_SYSTEM, WALLPAPER_SYSTEM_ORIG);
349        ClearRedundantFile(userId, WALLPAPER_LOCKSCREEN, WALLPAPER_LOCK_ORIG);
350    }
351    return true;
352}
353
354void WallpaperService::ClearRedundantFile(int32_t userId, WallpaperType wallpaperType, std::string fileName)
355{
356    HILOG_DEBUG("ClearRedundantFile Current userId: %{public}d", userId);
357    std::string wallpaperFilePath = GetWallpaperDir(userId, wallpaperType) + "/" + fileName;
358    FileDeal::DeleteFile(wallpaperFilePath);
359}
360
361void WallpaperService::OnInitUser(int32_t userId)
362{
363    if (userId < 0) {
364        HILOG_ERROR("userId error, userId = %{public}d", userId);
365        return;
366    }
367    std::string userDir = WALLPAPER_USERID_PATH + std::to_string(userId);
368    if (FileDeal::IsFileExist(userDir)) {
369        std::lock_guard<std::mutex> lock(mtx_);
370        if (!OHOS::ForceRemoveDirectory(userDir)) {
371            HILOG_ERROR("Force remove user directory path failed, errno %{public}d, userId:%{public}d", errno, userId);
372            return;
373        }
374    }
375    if (!InitUserDir(userId)) {
376        return;
377    }
378    UpdataWallpaperMap(userId, WALLPAPER_SYSTEM);
379    UpdataWallpaperMap(userId, WALLPAPER_LOCKSCREEN);
380    HILOG_INFO("OnInitUser success, userId = %{public}d", userId);
381}
382
383bool WallpaperService::InitUserDir(int32_t userId)
384{
385    std::string userDir = WALLPAPER_USERID_PATH + std::to_string(userId);
386    if (!FileDeal::Mkdir(userDir)) {
387        HILOG_ERROR("Failed to create destination path, userId:%{public}d", userId);
388        return false;
389    }
390    std::string wallpaperSystemFilePath = userDir + "/" + WALLPAPER_SYSTEM_DIRNAME;
391    if (!FileDeal::Mkdir(wallpaperSystemFilePath)) {
392        HILOG_ERROR("Failed to create destination wallpaper system path, userId:%{public}d, type:%{public}s.", userId,
393            WALLPAPER_SYSTEM_DIRNAME);
394        return false;
395    }
396    std::string wallpaperLockScreenFilePath = userDir + "/" + WALLPAPER_LOCKSCREEN_DIRNAME;
397    if (!FileDeal::Mkdir(wallpaperLockScreenFilePath)) {
398        HILOG_ERROR("Failed to create destination wallpaper lockscreen path, userId:%{public}d, type:%{public}s.",
399            userId, WALLPAPER_LOCKSCREEN_DIRNAME);
400        return false;
401    }
402    return true;
403}
404
405bool WallpaperService::RestoreUserResources(int32_t userId, WallpaperData &wallpaperData, WallpaperType wallpaperType)
406{
407    if (wallpaperType == WALLPAPER_SYSTEM) {
408        ClearRedundantFile(userId, wallpaperType, WALLPAPER_HOME);
409    } else {
410        ClearRedundantFile(userId, wallpaperType, WALLPAPER_LOCK);
411    }
412    std::string wallpaperDefaultPath = GetWallpaperDefaultPath(wallpaperType);
413    if (wallpaperDefaultPath.empty()) {
414        return false;
415    }
416    wallpaperData.wallpaperFile = wallpaperDefaultPath;
417    HILOG_INFO("Restore user resources end.");
418    return true;
419}
420
421std::string WallpaperService::GetWallpaperDefaultPath(WallpaperType wallpaperType)
422{
423    std::string wallpaperDefaultPath = (wallpaperType == WallpaperType::WALLPAPER_SYSTEM)
424                                           ? GetWallpaperPathInJson(HOME_MANIFEST)
425                                           : GetWallpaperPathInJson(LOCK_MANIFEST);
426    if (wallpaperDefaultPath.empty()) {
427        wallpaperDefaultPath = (wallpaperType == WallpaperType::WALLPAPER_SYSTEM) ? WALLPAPER_DEFAULT_FILEFULLPATH
428                                                                                  : WALLPAPER_DEFAULT_LOCK_FILEFULLPATH;
429    }
430    HILOG_DEBUG("wallpaperDefaultPath is:%{public}s.", wallpaperDefaultPath.c_str());
431    return wallpaperDefaultPath;
432}
433void WallpaperService::OnRemovedUser(int32_t userId)
434{
435    if (userId < 0) {
436        HILOG_ERROR("userId error, userId = %{public}d", userId);
437        return;
438    }
439    ClearWallpaperLocked(userId, WALLPAPER_SYSTEM);
440    ClearWallpaperLocked(userId, WALLPAPER_LOCKSCREEN);
441    std::string userDir = WALLPAPER_USERID_PATH + std::to_string(userId);
442    std::lock_guard<std::mutex> lock(mtx_);
443    if (!OHOS::ForceRemoveDirectory(userDir)) {
444        HILOG_ERROR("Force remove user directory path failed, errno %{public}d", errno);
445    }
446    HILOG_INFO("OnRemovedUser end, userId = %{public}d", userId);
447}
448
449void WallpaperService::OnSwitchedUser(int32_t userId)
450{
451    if (userId < 0) {
452        HILOG_ERROR("userId error, userId = %{public}d", userId);
453        return;
454    }
455    if (userId == currentUserId_) {
456        HILOG_ERROR("userId not switch, userId = %{public}d", userId);
457        return;
458    }
459    currentUserId_ = userId;
460    RemoveExtensionDeathRecipient();
461#ifndef THEME_SERVICE
462    ConnectExtensionAbility();
463#endif
464    std::string userDir = WALLPAPER_USERID_PATH + std::to_string(userId);
465    if (!FileDeal::IsFileExist(userDir)) {
466        HILOG_INFO("User file is not exist, userId = %{public}d", userId);
467        InitUserDir(userId);
468        UpdataWallpaperMap(userId, WALLPAPER_SYSTEM);
469        UpdataWallpaperMap(userId, WALLPAPER_LOCKSCREEN);
470    }
471    LoadWallpaperState();
472    SendWallpaperChangeEvent(userId, WALLPAPER_SYSTEM);
473    SendWallpaperChangeEvent(userId, WALLPAPER_LOCKSCREEN);
474    SaveColor(userId, WALLPAPER_SYSTEM);
475    SaveColor(userId, WALLPAPER_LOCKSCREEN);
476    HILOG_INFO("OnSwitchedUser end, newUserId = %{public}d", userId);
477}
478
479std::string WallpaperService::GetWallpaperDir(int32_t userId, WallpaperType wallpaperType)
480{
481    std::string userIdPath = WALLPAPER_USERID_PATH + std::to_string(userId);
482    std::string wallpaperFilePath;
483    if (wallpaperType == WALLPAPER_SYSTEM) {
484        wallpaperFilePath = userIdPath + "/" + WALLPAPER_SYSTEM_DIRNAME;
485    } else if (wallpaperType == WALLPAPER_LOCKSCREEN) {
486        wallpaperFilePath = userIdPath + "/" + WALLPAPER_LOCKSCREEN_DIRNAME;
487    }
488    return wallpaperFilePath;
489}
490
491bool WallpaperService::GetFileNameFromMap(int32_t userId, WallpaperType wallpaperType, std::string &filePathName)
492{
493    auto iterator = wallpaperType == WALLPAPER_SYSTEM ? systemWallpaperMap_.Find(userId)
494                                                      : lockWallpaperMap_.Find(userId);
495    if (!iterator.first) {
496        HILOG_ERROR("system wallpaper already cleared.");
497        return false;
498    }
499    HILOG_DEBUG("GetFileNameFromMap resourceType : %{public}d", static_cast<int32_t>(iterator.second.resourceType));
500    switch (iterator.second.resourceType) {
501        case PICTURE:
502            filePathName = iterator.second.wallpaperFile;
503            break;
504        case VIDEO:
505            filePathName = iterator.second.liveWallpaperFile;
506            break;
507        case DEFAULT:
508            filePathName = iterator.second.wallpaperFile;
509            break;
510        case PACKAGE:
511            filePathName = iterator.second.customPackageUri;
512            break;
513        default:
514            filePathName = "";
515            break;
516    }
517    return filePathName != "";
518}
519
520bool WallpaperService::GetPictureFileName(int32_t userId, WallpaperType wallpaperType, std::string &filePathName)
521{
522    auto iterator = wallpaperType == WALLPAPER_SYSTEM ? systemWallpaperMap_.Find(userId)
523                                                      : lockWallpaperMap_.Find(userId);
524    if (!iterator.first) {
525        HILOG_INFO("WallpaperType:%{public}d, WallpaperMap not found userId: %{public}d", wallpaperType, userId);
526        OnInitUser(userId);
527        iterator = wallpaperType == WALLPAPER_SYSTEM ? systemWallpaperMap_.Find(userId)
528                                                     : lockWallpaperMap_.Find(userId);
529    }
530    filePathName = iterator.second.wallpaperFile;
531    HILOG_INFO("GetPictureFileName filePathName : %{public}s", filePathName.c_str());
532    return filePathName != "";
533}
534
535int32_t WallpaperService::MakeWallpaperIdLocked()
536{
537    HILOG_INFO("MakeWallpaperIdLocked start.");
538    if (wallpaperId_ == INT32_MAX) {
539        wallpaperId_ = DEFAULT_WALLPAPER_ID;
540    }
541    return ++wallpaperId_;
542}
543
544void WallpaperService::UpdataWallpaperMap(int32_t userId, WallpaperType wallpaperType)
545{
546    HILOG_INFO("updata wallpaperMap.");
547    WallpaperData wallpaperData;
548    std::string wallpaperPath = GetWallpaperDir(userId, wallpaperType);
549    wallpaperData.liveWallpaperFile =
550        wallpaperPath + "/"
551        + (wallpaperType == WALLPAPER_SYSTEM ? LIVE_WALLPAPER_SYSTEM_ORIG : LIVE_WALLPAPER_LOCK_ORIG);
552    wallpaperData.customPackageUri =
553        wallpaperPath + "/" + (wallpaperType == WALLPAPER_SYSTEM ? CUSTOM_WALLPAPER_SYSTEM : CUSTOM_WALLPAPER_LOCK);
554    std::string wallpaperFilePath =
555        wallpaperPath + "/" + (wallpaperType == WALLPAPER_SYSTEM ? WALLPAPER_HOME : WALLPAPER_LOCK);
556    std::string wallpaperDefaultFilePath = GetWallpaperDefaultPath(wallpaperType);
557    ConcurrentMap<int32_t, WallpaperData> &wallpaperMap = [&]() -> ConcurrentMap<int32_t, WallpaperData>& {
558        if (wallpaperType == WALLPAPER_SYSTEM) {
559            return systemWallpaperMap_;
560        } else {
561            return lockWallpaperMap_;
562        }
563    }();
564    wallpaperData.wallpaperFile = wallpaperDefaultFilePath;
565    wallpaperData.userId = userId;
566    wallpaperData.allowBackup = true;
567    wallpaperData.resourceType = PICTURE;
568    wallpaperData.wallpaperId = DEFAULT_WALLPAPER_ID;
569    if (FileDeal::IsFileExist(wallpaperFilePath)) {
570        wallpaperData.wallpaperFile = wallpaperFilePath;
571    }
572    wallpaperMap.InsertOrAssign(userId, wallpaperData);
573}
574
575ErrorCode WallpaperService::GetColors(int32_t wallpaperType, std::vector<uint64_t> &colors)
576{
577    if (wallpaperType == WALLPAPER_SYSTEM) {
578        std::lock_guard<std::mutex> lock(wallpaperColorMtx_);
579        colors.emplace_back(systemWallpaperColor_);
580    } else if (wallpaperType == WALLPAPER_LOCKSCREEN) {
581        std::lock_guard<std::mutex> lock(wallpaperColorMtx_);
582        colors.emplace_back(lockWallpaperColor_);
583    }
584    HILOG_INFO("GetColors Service End.");
585    return E_OK;
586}
587
588ErrorCode WallpaperService::GetColorsV9(int32_t wallpaperType, std::vector<uint64_t> &colors)
589{
590    if (!IsSystemApp()) {
591        HILOG_ERROR("CallingApp is not SystemApp.");
592        return E_NOT_SYSTEM_APP;
593    }
594    return GetColors(wallpaperType, colors);
595}
596
597ErrorCode WallpaperService::GetFile(int32_t wallpaperType, int32_t &wallpaperFd)
598{
599    if (!CheckCallingPermission(WALLPAPER_PERMISSION_NAME_GET_WALLPAPER)) {
600        HILOG_ERROR("GetPixelMap no get permission!");
601        return E_NO_PERMISSION;
602    }
603    if (wallpaperType != static_cast<int32_t>(WALLPAPER_LOCKSCREEN)
604        && wallpaperType != static_cast<int32_t>(WALLPAPER_SYSTEM)) {
605        return E_PARAMETERS_INVALID;
606    }
607    auto type = static_cast<WallpaperType>(wallpaperType);
608    int32_t userId = QueryActiveUserId();
609    HILOG_INFO("QueryCurrentOsAccount userId: %{public}d", userId);
610    ErrorCode ret = GetImageFd(userId, type, wallpaperFd);
611    HILOG_INFO("GetImageFd fd:%{public}d, ret:%{public}d", wallpaperFd, ret);
612    return ret;
613}
614
615bool WallpaperService::CompareColor(const uint64_t &localColor, const ColorManager::Color &color)
616{
617    return localColor == color.PackValue();
618}
619
620bool WallpaperService::SaveColor(int32_t userId, WallpaperType wallpaperType)
621{
622    uint32_t errorCode = 0;
623    OHOS::Media::SourceOptions opts;
624    opts.formatHint = "image/jpeg";
625    std::string pathName;
626    if (!GetPictureFileName(userId, wallpaperType, pathName)) {
627        return false;
628    }
629    std::unique_ptr<OHOS::Media::ImageSource> imageSource =
630        OHOS::Media::ImageSource::CreateImageSource(pathName, opts, errorCode);
631    if (errorCode != 0 || imageSource == nullptr) {
632        HILOG_ERROR("CreateImageSource failed!");
633        return false;
634    }
635    OHOS::Media::DecodeOptions decodeOpts;
636    std::unique_ptr<PixelMap> wallpaperPixelMap = imageSource->CreatePixelMap(decodeOpts, errorCode);
637    if (errorCode != 0) {
638        HILOG_ERROR("CreatePixelMap failed!");
639        return false;
640    }
641    auto colorPicker = Rosen::ColorPicker::CreateColorPicker(std::move(wallpaperPixelMap), errorCode);
642    if (errorCode != 0) {
643        HILOG_ERROR("CreateColorPicker failed!");
644        return false;
645    }
646    auto color = ColorManager::Color();
647    uint32_t ret = colorPicker->GetMainColor(color);
648    if (ret != Rosen::SUCCESS) {
649        HILOG_ERROR("GetMainColor failed ret is : %{public}d", ret);
650        return false;
651    }
652    OnColorsChange(wallpaperType, color);
653    return true;
654}
655
656ErrorCode WallpaperService::SetWallpaper(int32_t fd, int32_t wallpaperType, int32_t length)
657{
658    StartAsyncTrace(HITRACE_TAG_MISC, "SetWallpaper", static_cast<int32_t>(TraceTaskId::SET_WALLPAPER));
659    ErrorCode wallpaperErrorCode = SetWallpaper(fd, wallpaperType, length, PICTURE);
660    FinishAsyncTrace(HITRACE_TAG_MISC, "SetWallpaper", static_cast<int32_t>(TraceTaskId::SET_WALLPAPER));
661    return wallpaperErrorCode;
662}
663
664ErrorCode WallpaperService::SetWallpaperByPixelMap(
665    std::shared_ptr<OHOS::Media::PixelMap> pixelMap, int32_t wallpaperType)
666{
667    if (pixelMap == nullptr) {
668        HILOG_ERROR("pixelMap is nullptr");
669        return E_FILE_ERROR;
670    }
671    StartAsyncTrace(HITRACE_TAG_MISC, "SetWallpaper", static_cast<int32_t>(TraceTaskId::SET_WALLPAPER));
672    ErrorCode wallpaperErrorCode = SetWallpaperByPixelMap(pixelMap, wallpaperType, PICTURE);
673    FinishAsyncTrace(HITRACE_TAG_MISC, "SetWallpaper", static_cast<int32_t>(TraceTaskId::SET_WALLPAPER));
674    return wallpaperErrorCode;
675}
676
677ErrorCode WallpaperService::SetWallpaperV9(int32_t fd, int32_t wallpaperType, int32_t length)
678{
679    if (!IsSystemApp()) {
680        HILOG_ERROR("CallingApp is not SystemApp.");
681        return E_NOT_SYSTEM_APP;
682    }
683    return SetWallpaper(fd, wallpaperType, length);
684}
685
686ErrorCode WallpaperService::SetWallpaperV9ByPixelMap(
687    std::shared_ptr<OHOS::Media::PixelMap> pixelMap, int32_t wallpaperType)
688{
689    if (!IsSystemApp()) {
690        HILOG_INFO("CallingApp is not SystemApp.");
691        return E_NOT_SYSTEM_APP;
692    }
693    if (pixelMap == nullptr) {
694        HILOG_ERROR("pixelMap is nullptr");
695        return E_FILE_ERROR;
696    }
697    return SetWallpaperByPixelMap(pixelMap, wallpaperType);
698}
699
700ErrorCode WallpaperService::SetWallpaperBackupData(
701    int32_t userId, WallpaperResourceType resourceType, const std::string &uriOrPixelMap, WallpaperType wallpaperType)
702{
703    HILOG_INFO("set wallpaper and backup data Start.");
704    if (!OHOS::FileExists(uriOrPixelMap)) {
705        return E_DEAL_FAILED;
706    }
707    WallpaperData wallpaperData;
708    bool ret = GetWallpaperSafeLocked(userId, wallpaperType, wallpaperData);
709    if (!ret) {
710        HILOG_ERROR("GetWallpaperSafeLocked failed!");
711        return E_DEAL_FAILED;
712    }
713    if (resourceType == PICTURE || resourceType == DEFAULT) {
714        wallpaperData.wallpaperFile = GetWallpaperDir(userId, wallpaperType) + "/"
715                                      + (wallpaperType == WALLPAPER_SYSTEM ? WALLPAPER_HOME : WALLPAPER_LOCK);
716    }
717    wallpaperData.resourceType = resourceType;
718    wallpaperData.wallpaperId = MakeWallpaperIdLocked();
719    std::string wallpaperFile;
720    WallpaperService::GetWallpaperFile(resourceType, wallpaperData, wallpaperFile);
721    {
722        std::lock_guard<std::mutex> lock(mtx_);
723        if (!FileDeal::CopyFile(uriOrPixelMap, wallpaperFile)) {
724            HILOG_ERROR("CopyFile failed!");
725            FileDeal::DeleteFile(uriOrPixelMap);
726            return E_DEAL_FAILED;
727        }
728        if (!FileDeal::DeleteFile(uriOrPixelMap)) {
729            return E_DEAL_FAILED;
730        }
731    }
732    if (!SaveWallpaperState(userId, wallpaperType, resourceType)) {
733        HILOG_ERROR("Save wallpaper state failed!");
734        return E_DEAL_FAILED;
735    }
736    if (wallpaperType == WALLPAPER_SYSTEM) {
737        systemWallpaperMap_.InsertOrAssign(userId, wallpaperData);
738    } else if (wallpaperType == WALLPAPER_LOCKSCREEN) {
739        lockWallpaperMap_.InsertOrAssign(userId, wallpaperData);
740    }
741    if (!SendWallpaperChangeEvent(userId, wallpaperType)) {
742        HILOG_ERROR("Send wallpaper state failed!");
743        return E_DEAL_FAILED;
744    }
745    return E_OK;
746}
747
748void WallpaperService::GetWallpaperFile(
749    WallpaperResourceType resourceType, const WallpaperData &wallpaperData, std::string &wallpaperFile)
750{
751    switch (resourceType) {
752        case PICTURE:
753            wallpaperFile = wallpaperData.wallpaperFile;
754            break;
755        case DEFAULT:
756            wallpaperFile = wallpaperData.wallpaperFile;
757            break;
758        case VIDEO:
759            wallpaperFile = wallpaperData.liveWallpaperFile;
760            break;
761        case PACKAGE:
762            wallpaperFile = wallpaperData.customPackageUri;
763            break;
764        default:
765            HILOG_ERROR("Non-existent error type!");
766            break;
767    }
768}
769
770WallpaperResourceType WallpaperService::GetResType(int32_t userId, WallpaperType wallpaperType)
771{
772    if (wallpaperType == WALLPAPER_LOCKSCREEN) {
773        auto iterator = lockWallpaperMap_.Find(userId);
774        if (iterator.first) {
775            return iterator.second.resourceType;
776        }
777    } else if (wallpaperType == WALLPAPER_SYSTEM) {
778        auto iterator = systemWallpaperMap_.Find(userId);
779        if (iterator.first) {
780            return iterator.second.resourceType;
781        }
782    }
783    return WallpaperResourceType::DEFAULT;
784}
785
786ErrorCode WallpaperService::SendEvent(const std::string &eventType)
787{
788    HILOG_INFO("Send event start.");
789    if (!CheckCallingPermission(WALLPAPER_PERMISSION_NAME_SET_WALLPAPER)) {
790        HILOG_ERROR("Send event not set permission!");
791        return E_NO_PERMISSION;
792    }
793
794    int32_t userId = QueryActiveUserId();
795    WallpaperType wallpaperType;
796    WallpaperData data;
797    if (eventType == SHOW_SYSTEM_SCREEN) {
798        wallpaperType = WALLPAPER_SYSTEM;
799    } else if (eventType == SHOW_LOCK_SCREEN) {
800        wallpaperType = WALLPAPER_LOCKSCREEN;
801    } else {
802        HILOG_ERROR("Event type error!");
803        return E_PARAMETERS_INVALID;
804    }
805
806    if (!GetWallpaperSafeLocked(userId, wallpaperType, data)) {
807        HILOG_ERROR("Get wallpaper safe locked failed!");
808        return E_PARAMETERS_INVALID;
809    }
810    std::string uri;
811    GetFileNameFromMap(userId, WALLPAPER_SYSTEM, uri);
812    WallpaperChanged(wallpaperType, data.resourceType, uri);
813    return E_OK;
814}
815
816bool WallpaperService::SendWallpaperChangeEvent(int32_t userId, WallpaperType wallpaperType)
817{
818    WallpaperData wallpaperData;
819    if (!GetWallpaperSafeLocked(userId, wallpaperType, wallpaperData)) {
820        HILOG_ERROR("GetWallpaperSafeLocked failed!");
821        return false;
822    }
823    shared_ptr<WallpaperCommonEventManager> wallpaperCommonEventManager = make_shared<WallpaperCommonEventManager>();
824    if (wallpaperType == WALLPAPER_SYSTEM) {
825        HILOG_INFO("Send wallpaper system setting message.");
826        wallpaperCommonEventManager->SendWallpaperSystemSettingMessage(wallpaperData.resourceType);
827    } else if (wallpaperType == WALLPAPER_LOCKSCREEN) {
828        HILOG_INFO("Send wallpaper lock setting message.");
829        wallpaperCommonEventManager->SendWallpaperLockSettingMessage(wallpaperData.resourceType);
830    }
831    HILOG_INFO("SetWallpaperBackupData callbackProxy_->OnCall start.");
832    if (callbackProxy_ != nullptr && (wallpaperData.resourceType == PICTURE || wallpaperData.resourceType == DEFAULT)) {
833        callbackProxy_->OnCall(wallpaperType);
834    }
835    std::string uri;
836    WallpaperChanged(wallpaperType, wallpaperData.resourceType, uri);
837    return true;
838}
839
840ErrorCode WallpaperService::SetVideo(int32_t fd, int32_t wallpaperType, int32_t length)
841{
842    if (!IsSystemApp()) {
843        HILOG_ERROR("current app is not SystemApp.");
844        return E_NOT_SYSTEM_APP;
845    }
846    StartAsyncTrace(HITRACE_TAG_MISC, "SetVideo", static_cast<int32_t>(TraceTaskId::SET_VIDEO));
847    ErrorCode wallpaperErrorCode = SetWallpaper(fd, wallpaperType, length, VIDEO);
848    FinishAsyncTrace(HITRACE_TAG_MISC, "SetVideo", static_cast<int32_t>(TraceTaskId::SET_VIDEO));
849    return wallpaperErrorCode;
850}
851
852ErrorCode WallpaperService::SetCustomWallpaper(int32_t fd, int32_t type, int32_t length)
853{
854    if (!IsSystemApp()) {
855        HILOG_ERROR("current app is not SystemApp.");
856        return E_NOT_SYSTEM_APP;
857    }
858    if (!CheckCallingPermission(WALLPAPER_PERMISSION_NAME_SET_WALLPAPER)) {
859        HILOG_ERROR("SetWallpaper no set permission!");
860        return E_NO_PERMISSION;
861    }
862    if (type != static_cast<int32_t>(WALLPAPER_LOCKSCREEN) && type != static_cast<int32_t>(WALLPAPER_SYSTEM)) {
863        return E_PARAMETERS_INVALID;
864    }
865    StartAsyncTrace(HITRACE_TAG_MISC, "SetCustomWallpaper", static_cast<int32_t>(TraceTaskId::SET_CUSTOM_WALLPAPER));
866    int32_t userId = QueryActiveUserId();
867    WallpaperType wallpaperType = static_cast<WallpaperType>(type);
868    WallpaperData wallpaperData;
869    if (!GetWallpaperSafeLocked(userId, wallpaperType, wallpaperData)) {
870        HILOG_ERROR("GetWallpaper data failed!");
871        return E_DEAL_FAILED;
872    }
873    if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
874        HILOG_ERROR("SceneBoard is not Enabled.");
875        return E_NO_PERMISSION;
876    }
877    if (!SaveWallpaperState(userId, wallpaperType, PACKAGE)) {
878        HILOG_ERROR("Save wallpaper state failed!");
879        return E_DEAL_FAILED;
880    }
881    ErrorCode wallpaperErrorCode = SetWallpaper(fd, wallpaperType, length, PACKAGE);
882    wallpaperData.resourceType = PACKAGE;
883    wallpaperData.wallpaperId = MakeWallpaperIdLocked();
884    if (wallpaperType == WALLPAPER_SYSTEM) {
885        systemWallpaperMap_.InsertOrAssign(userId, wallpaperData);
886    } else if (wallpaperType == WALLPAPER_LOCKSCREEN) {
887        lockWallpaperMap_.InsertOrAssign(userId, wallpaperData);
888    }
889    if (!SendWallpaperChangeEvent(userId, wallpaperType)) {
890        HILOG_ERROR("Send wallpaper state failed!");
891        return E_DEAL_FAILED;
892    }
893    FinishAsyncTrace(HITRACE_TAG_MISC, "SetCustomWallpaper", static_cast<int32_t>(TraceTaskId::SET_CUSTOM_WALLPAPER));
894    return wallpaperErrorCode;
895}
896
897ErrorCode WallpaperService::GetPixelMap(int32_t wallpaperType, IWallpaperService::FdInfo &fdInfo)
898{
899    HILOG_INFO("WallpaperService::getPixelMap start.");
900    if (!IsSystemApp()) {
901        HILOG_ERROR("CallingApp is not SystemApp.");
902        return E_NOT_SYSTEM_APP;
903    }
904    if (!CheckCallingPermission(WALLPAPER_PERMISSION_NAME_GET_WALLPAPER)) {
905        HILOG_ERROR("GetPixelMap no get permission!");
906        return E_NO_PERMISSION;
907    }
908    if (wallpaperType != static_cast<int32_t>(WALLPAPER_LOCKSCREEN)
909        && wallpaperType != static_cast<int32_t>(WALLPAPER_SYSTEM)) {
910        return E_PARAMETERS_INVALID;
911    }
912    auto type = static_cast<WallpaperType>(wallpaperType);
913    int32_t userId = QueryActiveUserId();
914    HILOG_INFO("QueryCurrentOsAccount userId: %{public}d", userId);
915    // current user's wallpaper is live video, not image
916    WallpaperResourceType resType = GetResType(userId, type);
917    if (resType != PICTURE && resType != DEFAULT) {
918        HILOG_ERROR("Current user's wallpaper is live video, not image.");
919        fdInfo.size = 0; // 0: empty file size
920        fdInfo.fd = -1;  // -1: invalid file description
921        return E_OK;
922    }
923    ErrorCode ret = GetImageSize(userId, type, fdInfo.size);
924    if (ret != E_OK) {
925        HILOG_ERROR("GetImageSize failed!");
926        return ret;
927    }
928    ret = GetImageFd(userId, type, fdInfo.fd);
929    if (ret != E_OK) {
930        HILOG_ERROR("GetImageFd failed!");
931        return ret;
932    }
933    return E_OK;
934}
935
936ErrorCode WallpaperService::GetPixelMapV9(int32_t wallpaperType, IWallpaperService::FdInfo &fdInfo)
937{
938    return GetPixelMap(wallpaperType, fdInfo);
939}
940
941int32_t WallpaperService::GetWallpaperId(int32_t wallpaperType)
942{
943    HILOG_INFO("WallpaperService::GetWallpaperId --> start.");
944    int32_t iWallpaperId = -1;
945    int32_t userId = QueryActiveUserId();
946    HILOG_INFO("QueryCurrentOsAccount userId: %{public}d", userId);
947    if (wallpaperType == WALLPAPER_LOCKSCREEN) {
948        auto iterator = lockWallpaperMap_.Find(userId);
949        if (iterator.first) {
950            iWallpaperId = iterator.second.wallpaperId;
951        }
952    } else if (wallpaperType == WALLPAPER_SYSTEM) {
953        auto iterator = systemWallpaperMap_.Find(userId);
954        if (iterator.first) {
955            iWallpaperId = iterator.second.wallpaperId;
956        }
957    }
958    HILOG_INFO("WallpaperService::GetWallpaperId --> end ID[%{public}d]", iWallpaperId);
959    return iWallpaperId;
960}
961
962bool WallpaperService::IsChangePermitted()
963{
964    HILOG_INFO("IsChangePermitted wallpaper Start.");
965    bool bFlag = CheckCallingPermission(WALLPAPER_PERMISSION_NAME_SET_WALLPAPER);
966    return bFlag;
967}
968
969bool WallpaperService::IsOperationAllowed()
970{
971    HILOG_INFO("IsOperationAllowed wallpaper Start.");
972    bool bFlag = CheckCallingPermission(WALLPAPER_PERMISSION_NAME_SET_WALLPAPER);
973    return bFlag;
974}
975
976ErrorCode WallpaperService::ResetWallpaper(int32_t wallpaperType)
977{
978    HILOG_INFO("reset wallpaper Start.");
979    bool permissionSet = CheckCallingPermission(WALLPAPER_PERMISSION_NAME_SET_WALLPAPER);
980    if (!permissionSet) {
981        HILOG_ERROR("reset wallpaper no set permission!");
982        return E_NO_PERMISSION;
983    }
984    if (wallpaperType != static_cast<int32_t>(WALLPAPER_LOCKSCREEN)
985        && wallpaperType != static_cast<int32_t>(WALLPAPER_SYSTEM)) {
986        HILOG_ERROR("wallpaperType = %{public}d type not support ", wallpaperType);
987        return E_PARAMETERS_INVALID;
988    }
989    WallpaperType type = static_cast<WallpaperType>(wallpaperType);
990    int32_t userId = QueryActiveUserId();
991    HILOG_INFO("QueryCurrentOsAccount userId: %{public}d", userId);
992    if (!CheckUserPermissionById(userId)) {
993        return E_USER_IDENTITY_ERROR;
994    }
995    ErrorCode wallpaperErrorCode = SetDefaultDataForWallpaper(userId, type);
996    HILOG_INFO(" Set default data result[%{public}d]", wallpaperErrorCode);
997    return wallpaperErrorCode;
998}
999
1000ErrorCode WallpaperService::ResetWallpaperV9(int32_t wallpaperType)
1001{
1002    if (!IsSystemApp()) {
1003        HILOG_ERROR("CallingApp is not SystemApp.");
1004        return E_NOT_SYSTEM_APP;
1005    }
1006    return ResetWallpaper(wallpaperType);
1007}
1008
1009ErrorCode WallpaperService::SetDefaultDataForWallpaper(int32_t userId, WallpaperType wallpaperType)
1010{
1011    WallpaperData wallpaperData;
1012    if (!GetWallpaperSafeLocked(userId, wallpaperType, wallpaperData)) {
1013        return E_DEAL_FAILED;
1014    }
1015    if (!RestoreUserResources(userId, wallpaperData, wallpaperType)) {
1016        HILOG_ERROR("RestoreUserResources error!");
1017        return E_DEAL_FAILED;
1018    }
1019    if (!SaveWallpaperState(userId, wallpaperType, DEFAULT)) {
1020        HILOG_ERROR("Save wallpaper state failed!");
1021        return E_DEAL_FAILED;
1022    }
1023    wallpaperData.wallpaperId = DEFAULT_WALLPAPER_ID;
1024    wallpaperData.resourceType = DEFAULT;
1025    wallpaperData.allowBackup = true;
1026    if (wallpaperType == WALLPAPER_LOCKSCREEN) {
1027        lockWallpaperMap_.InsertOrAssign(userId, wallpaperData);
1028    } else if (wallpaperType == WALLPAPER_SYSTEM) {
1029        systemWallpaperMap_.InsertOrAssign(userId, wallpaperData);
1030    }
1031    if (!SendWallpaperChangeEvent(userId, wallpaperType)) {
1032        HILOG_ERROR("Send wallpaper state failed!");
1033        return E_DEAL_FAILED;
1034    }
1035    SaveColor(userId, wallpaperType);
1036    return E_OK;
1037}
1038
1039ErrorCode WallpaperService::On(const std::string &type, sptr<IWallpaperEventListener> listener)
1040{
1041    HILOG_DEBUG("WallpaperService::On in.");
1042    if (listener == nullptr) {
1043        HILOG_ERROR("WallpaperService::On listener is null.");
1044        return E_DEAL_FAILED;
1045    }
1046    if (type == WALLPAPER_CHANGE && !IsSystemApp()) {
1047        HILOG_ERROR("current app is not SystemApp.");
1048        return E_NOT_SYSTEM_APP;
1049    }
1050    std::lock_guard<std::mutex> autoLock(listenerMapMutex_);
1051    wallpaperEventMap_[type].insert_or_assign(IPCSkeleton::GetCallingTokenID(), listener);
1052    return E_OK;
1053}
1054
1055ErrorCode WallpaperService::Off(const std::string &type, sptr<IWallpaperEventListener> listener)
1056{
1057    HILOG_DEBUG("WallpaperService::Off in.");
1058    (void)listener;
1059    if (type == WALLPAPER_CHANGE && !IsSystemApp()) {
1060        HILOG_ERROR("current app is not SystemApp.");
1061        return E_NOT_SYSTEM_APP;
1062    }
1063    std::lock_guard<std::mutex> autoLock(listenerMapMutex_);
1064    auto iter = wallpaperEventMap_.find(type);
1065    if (iter != wallpaperEventMap_.end()) {
1066        auto it = iter->second.find(IPCSkeleton::GetCallingTokenID());
1067        if (it != iter->second.end()) {
1068            it->second = nullptr;
1069            iter->second.erase(it);
1070        }
1071    }
1072    return E_OK;
1073}
1074
1075bool WallpaperService::RegisterWallpaperCallback(const sptr<IWallpaperCallback> callback)
1076{
1077    HILOG_INFO("  WallpaperService::RegisterWallpaperCallback.");
1078    callbackProxy_ = callback;
1079    return true;
1080}
1081
1082bool WallpaperService::GetWallpaperSafeLocked(int32_t userId, WallpaperType wallpaperType, WallpaperData &wallpaperData)
1083{
1084    HILOG_DEBUG("GetWallpaperSafeLocked start.");
1085    auto iterator = wallpaperType == WALLPAPER_SYSTEM ? systemWallpaperMap_.Find(userId)
1086                                                      : lockWallpaperMap_.Find(userId);
1087    if (!iterator.first) {
1088        HILOG_INFO("No Lock wallpaper?  Not tracking for lock-only");
1089        UpdataWallpaperMap(userId, wallpaperType);
1090        iterator = wallpaperType == WALLPAPER_SYSTEM ? systemWallpaperMap_.Find(userId)
1091                                                     : lockWallpaperMap_.Find(userId);
1092        if (!iterator.first) {
1093            HILOG_ERROR("Fail to get wallpaper data");
1094            return false;
1095        }
1096    }
1097    wallpaperData = iterator.second;
1098    return true;
1099}
1100
1101void WallpaperService::ClearWallpaperLocked(int32_t userId, WallpaperType wallpaperType)
1102{
1103    HILOG_INFO("Clear wallpaper Start.");
1104    auto iterator = wallpaperType == WALLPAPER_SYSTEM ? systemWallpaperMap_.Find(userId)
1105                                                      : lockWallpaperMap_.Find(userId);
1106    if (!iterator.first) {
1107        HILOG_ERROR("Lock wallpaper already cleared.");
1108        return;
1109    }
1110    if (!iterator.second.wallpaperFile.empty() || !iterator.second.liveWallpaperFile.empty()) {
1111        if (wallpaperType == WALLPAPER_LOCKSCREEN) {
1112            lockWallpaperMap_.Erase(userId);
1113        } else if (wallpaperType == WALLPAPER_SYSTEM) {
1114            systemWallpaperMap_.Erase(userId);
1115        }
1116    }
1117}
1118
1119bool WallpaperService::CheckCallingPermission(const std::string &permissionName)
1120{
1121    AccessTokenID callerToken = IPCSkeleton::GetCallingTokenID();
1122    int32_t result = AccessTokenKit::VerifyAccessToken(callerToken, permissionName);
1123    if (result != TypePermissionState::PERMISSION_GRANTED) {
1124        HILOG_ERROR("Check permission failed!");
1125        return false;
1126    }
1127    return true;
1128}
1129
1130void WallpaperService::ReporterFault(FaultType faultType, FaultCode faultCode)
1131{
1132    FaultMsg msg;
1133    msg.faultType = faultType;
1134    msg.errorCode = faultCode;
1135    ReportStatus nRet;
1136    if (faultType == FaultType::SERVICE_FAULT) {
1137        msg.moduleName = "WallpaperService";
1138        nRet = FaultReporter::ReportServiceFault(msg);
1139    } else {
1140        nRet = FaultReporter::ReportRuntimeFault(msg);
1141    }
1142
1143    if (nRet == ReportStatus::SUCCESS) {
1144        HILOG_INFO("ReporterFault success.");
1145    } else {
1146        HILOG_ERROR("ReporterFault failed!");
1147    }
1148}
1149
1150int32_t WallpaperService::Dump(int32_t fd, const std::vector<std::u16string> &args)
1151{
1152    std::vector<std::string> argsStr;
1153    for (auto item : args) {
1154        argsStr.emplace_back(Str16ToStr8(item));
1155    }
1156
1157    if (DumpHelper::GetInstance().Dispatch(fd, argsStr)) {
1158        HILOG_ERROR("DumpHelper Dispatch failed!");
1159        return 0;
1160    }
1161    return 1;
1162}
1163
1164#ifndef THEME_SERVICE
1165bool WallpaperService::ConnectExtensionAbility()
1166{
1167    HILOG_DEBUG("ConnectAdapter.");
1168    MemoryGuard cacheGuard;
1169    AAFwk::Want want;
1170    want.SetElementName(OHOS_WALLPAPER_BUNDLE_NAME, "WallpaperExtAbility");
1171    ErrCode errCode = AAFwk::AbilityManagerClient::GetInstance()->Connect();
1172    if (errCode != ERR_OK) {
1173        HILOG_ERROR("connect ability server failed errCode=%{public}d", errCode);
1174        return false;
1175    }
1176    if (connection_ == nullptr) {
1177        connection_ = new WallpaperExtensionAbilityConnection(*this);
1178    }
1179    auto ret = AAFwk::AbilityManagerClient::GetInstance()->ConnectExtensionAbility(want, connection_, DEFAULT_VALUE);
1180    HILOG_INFO("ConnectExtensionAbility errCode=%{public}d", ret);
1181    return ret;
1182}
1183#endif
1184
1185bool WallpaperService::IsSystemApp()
1186{
1187    HILOG_INFO("IsSystemApp start.");
1188    uint64_t tokenId = IPCSkeleton::GetCallingFullTokenID();
1189    return TokenIdKit::IsSystemAppByFullTokenID(tokenId);
1190}
1191
1192ErrorCode WallpaperService::GetImageFd(int32_t userId, WallpaperType wallpaperType, int32_t &fd)
1193{
1194    HILOG_INFO("WallpaperService::GetImageFd start.");
1195    std::string filePathName;
1196    if (!GetFileNameFromMap(userId, wallpaperType, filePathName)) {
1197        return E_DEAL_FAILED;
1198    }
1199    if (GetResType(userId, wallpaperType) == WallpaperResourceType::PACKAGE) {
1200        HILOG_INFO("The current wallpaper is a custom wallpaper");
1201        return E_OK;
1202    }
1203    {
1204        std::lock_guard<std::mutex> lock(mtx_);
1205        fd = open(filePathName.c_str(), O_RDONLY, S_IREAD);
1206    }
1207    if (fd < 0) {
1208        HILOG_ERROR("Open file failed, errno %{public}d", errno);
1209        ReporterFault(FaultType::LOAD_WALLPAPER_FAULT, FaultCode::RF_FD_INPUT_FAILED);
1210        return E_DEAL_FAILED;
1211    }
1212    HILOG_INFO("fd = %{public}d", fd);
1213    return E_OK;
1214}
1215
1216ErrorCode WallpaperService::GetImageSize(int32_t userId, WallpaperType wallpaperType, int32_t &size)
1217{
1218    HILOG_INFO("WallpaperService::GetImageSize start.");
1219    std::string filePathName;
1220    HILOG_INFO("userId = %{public}d", userId);
1221    if (!GetPictureFileName(userId, wallpaperType, filePathName)) {
1222        return E_DEAL_FAILED;
1223    }
1224
1225    if (!OHOS::FileExists(filePathName)) {
1226        HILOG_ERROR("file is not exist.");
1227        return E_NOT_FOUND;
1228    }
1229    std::lock_guard<std::mutex> lock(mtx_);
1230    FILE *fd = fopen(filePathName.c_str(), "rb");
1231    if (fd == nullptr) {
1232        HILOG_ERROR("fopen file failed, errno %{public}d", errno);
1233        return E_FILE_ERROR;
1234    }
1235    int32_t fend = fseek(fd, 0, SEEK_END);
1236    size = ftell(fd);
1237    int32_t fset = fseek(fd, 0, SEEK_SET);
1238    if (size <= 0 || fend != 0 || fset != 0) {
1239        HILOG_ERROR("ftell file failed or fseek file failed, errno %{public}d", errno);
1240        fclose(fd);
1241        return E_FILE_ERROR;
1242    }
1243    fclose(fd);
1244    return E_OK;
1245}
1246
1247int32_t WallpaperService::QueryActiveUserId()
1248{
1249    std::vector<int32_t> ids;
1250    ErrCode errCode = AccountSA::OsAccountManager::QueryActiveOsAccountIds(ids);
1251    if (errCode != ERR_OK || ids.empty()) {
1252        HILOG_ERROR("Query active userid failed, errCode: %{public}d,", errCode);
1253        return DEFAULT_USER_ID;
1254    }
1255    return ids[0];
1256}
1257
1258bool WallpaperService::CheckUserPermissionById(int32_t userId)
1259{
1260    OsAccountInfo osAccountInfo;
1261    ErrCode errCode = OsAccountManager::QueryOsAccountById(userId, osAccountInfo);
1262    if (errCode != ERR_OK) {
1263        HILOG_ERROR("Query os account info failed, errCode: %{public}d", errCode);
1264        return false;
1265    }
1266    HILOG_INFO("osAccountInfo GetType: %{public}d", static_cast<int32_t>(osAccountInfo.GetType()));
1267    if (osAccountInfo.GetType() == OsAccountType::GUEST) {
1268        HILOG_ERROR("The guest does not have permissions.");
1269        return false;
1270    }
1271    return true;
1272}
1273
1274ErrorCode WallpaperService::SetWallpaper(
1275    int32_t fd, int32_t wallpaperType, int32_t length, WallpaperResourceType resourceType)
1276{
1277    int32_t userId = QueryActiveUserId();
1278    HILOG_INFO("QueryCurrentOsAccount userId: %{public}d", userId);
1279    if (!CheckUserPermissionById(userId)) {
1280        return E_USER_IDENTITY_ERROR;
1281    }
1282    ErrorCode errCode = CheckValid(wallpaperType, length, resourceType);
1283    if (errCode != E_OK) {
1284        return errCode;
1285    }
1286    std::string uri = wallpaperTmpFullPath_;
1287    char *paperBuf = new (std::nothrow) char[length]();
1288    if (paperBuf == nullptr) {
1289        return E_NO_MEMORY;
1290    }
1291    {
1292        std::lock_guard<std::mutex> lock(mtx_);
1293        if (read(fd, paperBuf, length) <= 0) {
1294            HILOG_ERROR("read fd failed!");
1295            delete[] paperBuf;
1296            return E_DEAL_FAILED;
1297        }
1298        mode_t mode = S_IRUSR | S_IWUSR;
1299        int32_t fdw = open(uri.c_str(), O_WRONLY | O_CREAT, mode);
1300        if (fdw < 0) {
1301            HILOG_ERROR("Open wallpaper tmpFullPath failed, errno %{public}d", errno);
1302            delete[] paperBuf;
1303            return E_DEAL_FAILED;
1304        }
1305        if (write(fdw, paperBuf, length) <= 0) {
1306            HILOG_ERROR("Write to fdw failed, errno %{public}d", errno);
1307            ReporterFault(FaultType::SET_WALLPAPER_FAULT, FaultCode::RF_DROP_FAILED);
1308            delete[] paperBuf;
1309            close(fdw);
1310            return E_DEAL_FAILED;
1311        }
1312        delete[] paperBuf;
1313        close(fdw);
1314    }
1315    WallpaperType type = static_cast<WallpaperType>(wallpaperType);
1316    ErrorCode wallpaperErrorCode = SetWallpaperBackupData(userId, resourceType, uri, type);
1317    if (resourceType == PICTURE) {
1318        SaveColor(userId, type);
1319    }
1320    return wallpaperErrorCode;
1321}
1322
1323ErrorCode WallpaperService::SetWallpaperByPixelMap(
1324    std::shared_ptr<OHOS::Media::PixelMap> pixelMap, int32_t wallpaperType, WallpaperResourceType resourceType)
1325{
1326    if (pixelMap == nullptr) {
1327        HILOG_ERROR("pixelMap is nullptr");
1328        return E_FILE_ERROR;
1329    }
1330    int32_t userId = QueryActiveUserId();
1331    HILOG_INFO("QueryCurrentOsAccount userId: %{public}d", userId);
1332    if (!CheckUserPermissionById(userId)) {
1333        return E_USER_IDENTITY_ERROR;
1334    }
1335    std::string uri = wallpaperTmpFullPath_;
1336    ErrorCode errCode = WritePixelMapToFile(pixelMap, uri, wallpaperType, resourceType);
1337    if (errCode != E_OK) {
1338        HILOG_ERROR("WritePixelMapToFile failed!");
1339        return errCode;
1340    }
1341    WallpaperType type = static_cast<WallpaperType>(wallpaperType);
1342    ErrorCode wallpaperErrorCode = SetWallpaperBackupData(userId, resourceType, uri, type);
1343    if (resourceType == PICTURE) {
1344        SaveColor(userId, type);
1345    }
1346    return wallpaperErrorCode;
1347}
1348
1349ErrorCode WallpaperService::WritePixelMapToFile(std::shared_ptr<OHOS::Media::PixelMap> pixelMap,
1350    std::string wallpaperTmpFullPath, int32_t wallpaperType, WallpaperResourceType resourceType)
1351{
1352    if (pixelMap == nullptr) {
1353        HILOG_ERROR("pixelMap is nullptr");
1354        return E_FILE_ERROR;
1355    }
1356    std::stringbuf stringBuf;
1357    std::ostream ostream(&stringBuf);
1358    int32_t mapSize = WritePixelMapToStream(pixelMap, ostream);
1359    if (mapSize <= 0) {
1360        HILOG_ERROR("WritePixelMapToStream failed!");
1361        return E_WRITE_PARCEL_ERROR;
1362    }
1363    ErrorCode errCode = CheckValid(wallpaperType, mapSize, resourceType);
1364    if (errCode != E_OK) {
1365        HILOG_ERROR("CheckValid failed!");
1366        return errCode;
1367    }
1368    char *buffer = new (std::nothrow) char[mapSize]();
1369    if (buffer == nullptr) {
1370        HILOG_ERROR("buffer failed!");
1371        return E_NO_MEMORY;
1372    }
1373    stringBuf.sgetn(buffer, mapSize);
1374    {
1375        std::lock_guard<std::mutex> lock(mtx_);
1376        mode_t mode = S_IRUSR | S_IWUSR;
1377        int32_t fdw = open(wallpaperTmpFullPath.c_str(), O_WRONLY | O_CREAT, mode);
1378        if (fdw < 0) {
1379            HILOG_ERROR("Open wallpaper tmpFullPath failed, errno %{public}d", errno);
1380            delete[] buffer;
1381            return E_DEAL_FAILED;
1382        }
1383        if (write(fdw, buffer, mapSize) <= 0) {
1384            HILOG_ERROR("Write to fdw failed, errno %{public}d", errno);
1385            ReporterFault(FaultType::SET_WALLPAPER_FAULT, FaultCode::RF_DROP_FAILED);
1386            delete[] buffer;
1387            close(fdw);
1388            return E_DEAL_FAILED;
1389        }
1390        delete[] buffer;
1391        close(fdw);
1392    }
1393    return E_OK;
1394}
1395
1396int64_t WallpaperService::WritePixelMapToStream(
1397    std::shared_ptr<OHOS::Media::PixelMap> pixelMap, std::ostream &outputStream)
1398{
1399    if (pixelMap == nullptr) {
1400        HILOG_ERROR("pixelMap is nullptr");
1401        return 0;
1402    }
1403    OHOS::Media::ImagePacker imagePacker;
1404    OHOS::Media::PackOption option;
1405    option.format = "image/jpeg";
1406    option.quality = OPTION_QUALITY;
1407    option.numberHint = 1;
1408    std::set<std::string> formats;
1409    uint32_t ret = imagePacker.GetSupportedFormats(formats);
1410    if (ret != 0) {
1411        HILOG_ERROR("image packer get supported format failed, ret=%{public}u.", ret);
1412    }
1413
1414    imagePacker.StartPacking(outputStream, option);
1415    imagePacker.AddImage(*pixelMap);
1416    int64_t packedSize = 0;
1417    imagePacker.FinalizePacking(packedSize);
1418    HILOG_INFO("FrameWork WritePixelMapToStream End! packedSize=%{public}lld.", static_cast<long long>(packedSize));
1419    return packedSize;
1420}
1421
1422void WallpaperService::OnColorsChange(WallpaperType wallpaperType, const ColorManager::Color &color)
1423{
1424    std::vector<uint64_t> colors;
1425    if (wallpaperType == WALLPAPER_SYSTEM && !CompareColor(systemWallpaperColor_, color)) {
1426        {
1427            std::lock_guard<std::mutex> lock(wallpaperColorMtx_);
1428            systemWallpaperColor_ = color.PackValue();
1429            colors.emplace_back(systemWallpaperColor_);
1430        }
1431        NotifyColorChange(colors, WALLPAPER_SYSTEM);
1432    } else if (wallpaperType == WALLPAPER_LOCKSCREEN && !CompareColor(lockWallpaperColor_, color)) {
1433        {
1434            std::lock_guard<std::mutex> lock(wallpaperColorMtx_);
1435            lockWallpaperColor_ = color.PackValue();
1436            colors.emplace_back(lockWallpaperColor_);
1437        }
1438        NotifyColorChange(colors, WALLPAPER_LOCKSCREEN);
1439    }
1440}
1441
1442ErrorCode WallpaperService::CheckValid(int32_t wallpaperType, int32_t length, WallpaperResourceType resourceType)
1443{
1444    if (!CheckCallingPermission(WALLPAPER_PERMISSION_NAME_SET_WALLPAPER)) {
1445        HILOG_ERROR("SetWallpaper no set permission.");
1446        return E_NO_PERMISSION;
1447    }
1448    if (wallpaperType != static_cast<int32_t>(WALLPAPER_LOCKSCREEN)
1449        && wallpaperType != static_cast<int32_t>(WALLPAPER_SYSTEM)) {
1450        return E_PARAMETERS_INVALID;
1451    }
1452
1453    int32_t maxLength = resourceType == VIDEO ? MAX_VIDEO_SIZE : FOO_MAX_LEN;
1454    if (length <= 0 || length > maxLength) {
1455        return E_PARAMETERS_INVALID;
1456    }
1457    return E_OK;
1458}
1459
1460bool WallpaperService::WallpaperChanged(
1461    WallpaperType wallpaperType, WallpaperResourceType resType, const std::string &uri)
1462{
1463    std::lock_guard<std::mutex> autoLock(listenerMapMutex_);
1464    auto it = wallpaperEventMap_.find(WALLPAPER_CHANGE);
1465    if (it != wallpaperEventMap_.end()) {
1466        for (auto iter = it->second.begin(); iter != it->second.end(); iter++) {
1467            if (iter->second == nullptr) {
1468                continue;
1469            }
1470            iter->second->OnWallpaperChange(wallpaperType, resType, uri);
1471        }
1472        return true;
1473    }
1474    return false;
1475}
1476
1477void WallpaperService::NotifyColorChange(const std::vector<uint64_t> &colors, const WallpaperType &wallpaperType)
1478{
1479    std::lock_guard<std::mutex> autoLock(listenerMapMutex_);
1480    auto it = wallpaperEventMap_.find(COLOR_CHANGE);
1481    if (it != wallpaperEventMap_.end()) {
1482        for (auto iter = it->second.begin(); iter != it->second.end(); iter++) {
1483            if (iter->second == nullptr) {
1484                continue;
1485            }
1486            iter->second->OnColorsChange(colors, wallpaperType);
1487        }
1488    }
1489}
1490
1491bool WallpaperService::SaveWallpaperState(
1492    int32_t userId, WallpaperType wallpaperType, WallpaperResourceType resourceType)
1493{
1494    WallpaperData systemData;
1495    WallpaperData lockScreenData;
1496    if (!GetWallpaperSafeLocked(userId, WALLPAPER_SYSTEM, systemData)
1497        || !GetWallpaperSafeLocked(userId, WALLPAPER_LOCKSCREEN, lockScreenData)) {
1498        return false;
1499    }
1500    nlohmann::json root;
1501    if (wallpaperType == WALLPAPER_SYSTEM) {
1502        root[SYSTEM_RES_TYPE] = static_cast<int32_t>(resourceType);
1503        root[LOCKSCREEN_RES_TYPE] = static_cast<int32_t>(lockScreenData.resourceType);
1504    } else {
1505        root[LOCKSCREEN_RES_TYPE] = static_cast<int32_t>(resourceType);
1506        root[SYSTEM_RES_TYPE] = static_cast<int32_t>(systemData.resourceType);
1507    }
1508    std::string json = root.dump();
1509    if (json.empty()) {
1510        HILOG_ERROR("write user config file failed. because json content is empty.");
1511        return false;
1512    }
1513
1514    std::string userPath = WALLPAPER_USERID_PATH + std::to_string(userId) + "/wallpapercfg";
1515    mode_t mode = S_IRUSR | S_IWUSR;
1516    int fd = open(userPath.c_str(), O_CREAT | O_WRONLY | O_SYNC, mode);
1517    if (fd <= 0) {
1518        HILOG_ERROR("open user config file failed!");
1519        return false;
1520    }
1521    ssize_t size = write(fd, json.c_str(), json.size());
1522    if (size <= 0) {
1523        HILOG_ERROR("write user config file failed!");
1524        close(fd);
1525        return false;
1526    }
1527    close(fd);
1528    return true;
1529}
1530
1531void WallpaperService::LoadWallpaperState()
1532{
1533    int32_t userId = QueryActiveUserId();
1534    std::string userPath = WALLPAPER_USERID_PATH + std::to_string(userId) + "/wallpapercfg";
1535    int fd = open(userPath.c_str(), O_RDONLY, S_IREAD);
1536    if (fd <= 0) {
1537        HILOG_ERROR("open user config file failed!");
1538        return;
1539    }
1540    const size_t len = 255;
1541    char buf[len] = { 0 };
1542    ssize_t size = read(fd, buf, len);
1543    if (size <= 0) {
1544        HILOG_ERROR("read user config file failed!");
1545        close(fd);
1546        return;
1547    }
1548    close(fd);
1549
1550    if (buf[0] == '\0') {
1551        return;
1552    }
1553    WallpaperData systemData;
1554    WallpaperData lockScreenData;
1555    if (!GetWallpaperSafeLocked(userId, WALLPAPER_SYSTEM, systemData)
1556        || !GetWallpaperSafeLocked(userId, WALLPAPER_LOCKSCREEN, lockScreenData)) {
1557        return;
1558    }
1559    if (Json::accept(buf)) {
1560        auto root = nlohmann::json::parse(buf);
1561        if (root.contains(SYSTEM_RES_TYPE) && root[SYSTEM_RES_TYPE].is_number()) {
1562            systemData.resourceType = static_cast<WallpaperResourceType>(root[SYSTEM_RES_TYPE].get<int>());
1563        }
1564        if (root.contains(LOCKSCREEN_RES_TYPE) && root[SYSTEM_RES_TYPE].is_number()) {
1565            lockScreenData.resourceType = static_cast<WallpaperResourceType>(root[LOCKSCREEN_RES_TYPE].get<int>());
1566        }
1567    }
1568}
1569
1570std::string WallpaperService::GetDefaultResDir()
1571{
1572    std::string resPath;
1573    CfgFiles *cfgFiles = GetCfgFiles(RESOURCE_PATH);
1574    if (cfgFiles != nullptr) {
1575        for (auto &cfgPath : cfgFiles->paths) {
1576            if (cfgPath != nullptr) {
1577                HILOG_DEBUG("GetCfgFiles path is :%{public}s", cfgPath);
1578                resPath = cfgPath + std::string(DEFAULT_PATH);
1579                break;
1580            }
1581        }
1582        FreeCfgFiles(cfgFiles);
1583    }
1584    return resPath;
1585}
1586
1587std::string WallpaperService::GetWallpaperPathInJson(const std::string filePath)
1588{
1589    std::string resPath = GetDefaultResDir();
1590    if (resPath.empty() && !FileDeal::IsDirExist(resPath)) {
1591        HILOG_ERROR("wallpaperDefaultDir get failed!");
1592        return "";
1593    }
1594    std::string manifestFile = resPath + filePath;
1595    std::ifstream file(manifestFile);
1596    if (!file.is_open()) {
1597        HILOG_ERROR("open fail:%{public}s", manifestFile.c_str());
1598        file.close();
1599        return "";
1600    }
1601    std::string content((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
1602    file.close();
1603    if (!nlohmann::json::accept(content)) {
1604        HILOG_ERROR("accept failed!");
1605        return "";
1606    }
1607    auto root = nlohmann::json::parse(content.c_str());
1608    if (root.contains(IMAGE) && root[IMAGE].contains(SRC)) {
1609        std::string srcValue = root[IMAGE][SRC];
1610        std::string imageSrc;
1611        if (filePath == HOME_MANIFEST) {
1612            imageSrc = resPath + HOME_RES + srcValue;
1613        } else if (filePath == LOCK_MANIFEST) {
1614            imageSrc = resPath + LOCK_RES + srcValue;
1615        }
1616        return imageSrc;
1617    }
1618    HILOG_ERROR("src not exist.");
1619    return "";
1620}
1621} // namespace WallpaperMgrService
1622} // namespace OHOS
1623