• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2021-2025 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "distributed_device_profile_service_new.h"
17 
18 #include "file_ex.h"
19 #include "string_ex.h"
20 
21 #include "if_system_ability_manager.h"
22 #include "ipc_object_proxy.h"
23 #include "ipc_skeleton.h"
24 #include "iservice_registry.h"
25 #include "sa_profiles.h"
26 
27 #include "common_event_support.h"
28 #include "content_sensor_manager.h"
29 #include "device_profile_dumper.h"
30 #include "distributed_device_profile_constants.h"
31 #include "distributed_device_profile_errors.h"
32 #include "dm_adapter.h"
33 #include "device_profile_manager.h"
34 #include "dp_radar_helper.h"
35 #include "event_handler_factory.h"
36 #include "i_pincode_invalid_callback.h"
37 #include "local_service_info_manager.h"
38 #include "multi_user_manager.h"
39 #include "permission_manager.h"
40 #include "profile_cache.h"
41 #include "profile_data_manager.h"
42 #include "service_info_profile_manager.h"
43 #include "settings_data_manager.h"
44 #include "static_profile_manager.h"
45 #include "static_capability_collector.h"
46 #include "subscribe_profile_manager.h"
47 #include "switch_profile_manager.h"
48 #include "trust_profile_manager.h"
49 #include "session_key_manager.h"
50 
51 namespace OHOS {
52 namespace DistributedDeviceProfile {
53 namespace {
54 const std::string TAG = "DistributedDeviceProfileServiceNew";
55 const std::string UNLOAD_TASK_ID = "unload_dp_svr";
56 constexpr int32_t DELAY_TIME = 180000;
57 constexpr int32_t UNLOAD_IMMEDIATELY = 0;
58 constexpr int32_t WAIT_BUSINESS_PUT_TIME_S = 5;
59 constexpr int32_t WRTE_CACHE_PROFILE_DELAY_TIME_US = 200 * 1000;
60 constexpr int32_t WRTE_CACHE_PROFILE_RETRY_TIMES = 20;
61 constexpr int32_t DP_IPC_THREAD_NUM = 32;
62 }
63 
64 IMPLEMENT_SINGLE_INSTANCE(DistributedDeviceProfileServiceNew);
65 
DistributedDeviceProfileServiceNew()66 DistributedDeviceProfileServiceNew::DistributedDeviceProfileServiceNew()
67     : SystemAbility(DISTRIBUTED_DEVICE_PROFILE_SA_ID, true)
68 {
69     HILOGI("DPService construct!");
70 }
71 
Init()72 int32_t DistributedDeviceProfileServiceNew::Init()
73 {
74     HILOGI("init begin");
75     if (EventHandlerFactory::GetInstance().Init() != DP_SUCCESS) {
76         HILOGE("EventHandlerFactory init failed");
77         return DP_CACHE_INIT_FAIL;
78     }
79     if (PermissionManager::GetInstance().Init() != DP_SUCCESS) {
80         HILOGE("DpDeviceManager init failed");
81         return DP_DEVICE_MANAGER_INIT_FAIL;
82     }
83     if (TrustProfileManager::GetInstance().Init() != DP_SUCCESS) {
84         HILOGE("TrustProfileManager init failed");
85         return DP_TRUST_PROFILE_MANAGER_INIT_FAIL;
86     }
87     if (ProfileDataManager::GetInstance().Init() != DP_SUCCESS) {
88         HILOGE("ProfileDataManager init failed");
89         return DP_PROFILE_DATA_MANAGER_INIT_FAIL;
90     }
91     if (SubscribeProfileManager::GetInstance().Init() != DP_SUCCESS) {
92         HILOGE("SubscribeProfileManager init failed");
93         return DP_SUBSCRIBE_PROFILE_MANAGER_INIT_FAIL;
94     }
95     HILOGI("init finish");
96     return DP_SUCCESS;
97 }
98 
PostInit()99 int32_t DistributedDeviceProfileServiceNew::PostInit()
100 {
101     HILOGI("PostInit begin");
102     if (DMAdapter::GetInstance().Init() != DP_SUCCESS) {
103         HILOGE("DMAdapter init failed");
104         return DP_DM_ADAPTER_INIT_FAIL;
105     }
106     if (SwitchProfileManager::GetInstance().Init() != DP_SUCCESS) {
107         HILOGE("SwitchProfileManager init failed");
108         return DP_DEVICE_PROFILE_MANAGER_INIT_FAIL;
109     }
110     if (DeviceProfileManager::GetInstance().Init() != DP_SUCCESS) {
111         HILOGE("DeviceProfileManager init failed");
112         return DP_DEVICE_PROFILE_MANAGER_INIT_FAIL;
113     }
114     if (StaticProfileManager::GetInstance().Init() != DP_SUCCESS) {
115         HILOGE("StaticProfileManager init failed");
116         return DP_CONTENT_SENSOR_MANAGER_INIT_FAIL;
117     }
118     if (ProfileCache::GetInstance().Init() != DP_SUCCESS) {
119         HILOGE("ProfileCache init failed");
120         return DP_CACHE_INIT_FAIL;
121     }
122     if (StaticCapabilityCollector::GetInstance().Init() != DP_SUCCESS) {
123         HILOGE("StaticCapabilityCollector init failed");
124         return DP_CONTENT_SENSOR_MANAGER_INIT_FAIL;
125     }
126     if (ServiceInfoProfileManager::GetInstance().Init() != DP_SUCCESS) {
127         HILOGE("ServiceInfoProfileManager init failed");
128         return DP_SERVICE_INFO_PROFILE_MANAGER_INIT_FAIL;
129     }
130     if (LocalServiceInfoManager::GetInstance().Init() != DP_SUCCESS) {
131         HILOGE("LocalServiceInfoManager init failed");
132         return DP_LOCAL_SERVICE_INFO_MANAGER_INIT_FAIL;
133     }
134     if (MultiUserManager::GetInstance().Init() != DP_SUCCESS) {
135         HILOGE("MultiUserManager init failed");
136         return DP_MULTI_USER_MANAGER_INIT_FAIL;
137     }
138     return PostInitNext();
139 }
140 
PostInitNext()141 int32_t DistributedDeviceProfileServiceNew::PostInitNext()
142 {
143     if (SettingsDataManager::GetInstance().Init() != DP_SUCCESS) {
144         HILOGE("SettingsDataManager init failed");
145         return DP_SETTINGSDATA_MANAGER_INIT_FAIL;
146     }
147     if (ContentSensorManager::GetInstance().Init() != DP_SUCCESS) {
148         HILOGE("ContentSensorManager init failed");
149         return DP_CONTENT_SENSOR_MANAGER_INIT_FAIL;
150     }
151     SaveSwitchProfilesFromTempCache();
152     SaveDynamicProfilesFromTempCache();
153     isInited_ = true;
154     HILOGI("PostInit finish");
155     NotifyDeviceProfileInited();
156     return DP_SUCCESS;
157 }
158 
IsInited()159 bool DistributedDeviceProfileServiceNew::IsInited()
160 {
161     return isInited_;
162 }
163 
UnInit()164 int32_t DistributedDeviceProfileServiceNew::UnInit()
165 {
166     isInited_ = false;
167     if (TrustProfileManager::GetInstance().UnInit() != DP_SUCCESS) {
168         HILOGE("TrustProfileManager UnInit failed");
169         return DP_TRUST_PROFILE_MANAGER_UNINIT_FAIL;
170     }
171     if (ProfileDataManager::GetInstance().UnInit() != DP_SUCCESS) {
172         HILOGE("ProfileDataManager UnInit failed");
173         return DP_PROFILE_DATA_MANAGER_UNINIT_FAIL;
174     }
175     if (SwitchProfileManager::GetInstance().UnInit() != DP_SUCCESS) {
176         HILOGE("SwitchProfileManager UnInit failed");
177         return DP_DEVICE_PROFILE_MANAGER_UNINIT_FAIL;
178     }
179     if (DeviceProfileManager::GetInstance().UnInit() != DP_SUCCESS) {
180         HILOGE("DeviceProfileManager UnInit failed");
181         return DP_DEVICE_PROFILE_MANAGER_UNINIT_FAIL;
182     }
183     if (StaticProfileManager::GetInstance().UnInit() != DP_SUCCESS) {
184         HILOGE("StaticProfileManager UnInit failed");
185         return DP_CONTENT_SENSOR_MANAGER_UNINIT_FAIL;
186     }
187     int32_t ret = UnInitNext();
188     if (ret != DP_SUCCESS) {
189         return ret;
190     }
191     DestroyUnloadHandler();
192     ClearProfileCache();
193     return DP_SUCCESS;
194 }
195 
UnInitNext()196 int32_t DistributedDeviceProfileServiceNew::UnInitNext()
197 {
198     if (ProfileCache::GetInstance().UnInit() != DP_SUCCESS) {
199         HILOGE("ProfileCache UnInit failed");
200         return DP_CACHE_INIT_FAIL;
201     }
202     if (PermissionManager::GetInstance().UnInit() != DP_SUCCESS) {
203         HILOGE("DpDeviceManager UnInit failed");
204         return DP_DEVICE_MANAGER_UNINIT_FAIL;
205     }
206     if (SubscribeProfileManager::GetInstance().UnInit() != DP_SUCCESS) {
207         HILOGE("SubscribeProfileManager UnInit failed");
208         return DP_SUBSCRIBE_DEVICE_PROFILE_MANAGER_UNINIT_FAIL;
209     }
210     if (StaticCapabilityCollector::GetInstance().UnInit() != DP_SUCCESS) {
211         HILOGE("StaticCapabilityCollector UnInit failed");
212         return DP_CONTENT_SENSOR_MANAGER_UNINIT_FAIL;
213     }
214     if (SettingsDataManager::GetInstance().UnInit() != DP_SUCCESS) {
215         HILOGE("SettingsDataManager unInit failed");
216         return DP_SETTINGSDATA_MANAGER_UNINIT_FAIL;
217     }
218     if (ContentSensorManager::GetInstance().UnInit() != DP_SUCCESS) {
219         HILOGE("ContentSensorManager UnInit failed");
220         return DP_CONTENT_SENSOR_MANAGER_UNINIT_FAIL;
221     }
222     if (DMAdapter::GetInstance().UnInit() != DP_SUCCESS) {
223         HILOGE("DMAdapter UnInit failed");
224         return DP_DM_ADAPTER_UNINIT_FAIL;
225     }
226     if (EventHandlerFactory::GetInstance().UnInit() != DP_SUCCESS) {
227         HILOGE("EventHandlerFactory UnInit failed");
228         return DP_CACHE_UNINIT_FAIL;
229     }
230     return DP_SUCCESS;
231 }
232 
CreateUnloadHandler()233 int32_t DistributedDeviceProfileServiceNew::CreateUnloadHandler()
234 {
235     HILOGD("call!");
236     std::lock_guard<std::mutex> lock(unloadMutex_);
237     if (unloadHandler_ == nullptr) {
238         unloadHandler_ = EventHandlerFactory::GetInstance().GetEventHandler();
239     }
240     if (unloadHandler_ == nullptr) {
241         HILOGE("UnloadHandler is nullptr!");
242         return DP_UNLOAD_HANDLER_NULLPTR;
243     }
244     return DP_SUCCESS;
245 }
246 
DestroyUnloadHandler()247 int32_t DistributedDeviceProfileServiceNew::DestroyUnloadHandler()
248 {
249     HILOGD("call!");
250     std::lock_guard<std::mutex> lock(unloadMutex_);
251     if (unloadHandler_ == nullptr) {
252         HILOGE("UnloadHandler is nullptr!");
253         return DP_UNLOAD_HANDLER_NULLPTR;
254     }
255     unloadHandler_->RemoveTask(UNLOAD_TASK_ID);
256     unloadHandler_ = nullptr;
257     return DP_SUCCESS;
258 }
259 
PutAccessControlProfile(const AccessControlProfile & accessControlProfile)260 int32_t DistributedDeviceProfileServiceNew::PutAccessControlProfile(const AccessControlProfile& accessControlProfile)
261 {
262     if (!PermissionManager::GetInstance().IsCallerTrust(PUT_ACCESS_CONTROL_PROFILE)) {
263         HILOGE("the caller is permission denied!");
264         return DP_PERMISSION_DENIED;
265     }
266     int32_t ret = TrustProfileManager::GetInstance().PutAccessControlProfile(accessControlProfile);
267     DpRadarHelper::GetInstance().ReportPutAclProfile(ret, accessControlProfile);
268     return ret;
269 }
270 
UpdateAccessControlProfile(const AccessControlProfile & accessControlProfile)271 int32_t DistributedDeviceProfileServiceNew::UpdateAccessControlProfile(const AccessControlProfile& accessControlProfile)
272 {
273     if (!PermissionManager::GetInstance().IsCallerTrust(UPDATE_ACCESS_CONTROL_PROFILE)) {
274         HILOGE("the caller is permission denied!");
275         return DP_PERMISSION_DENIED;
276     }
277     int32_t ret = TrustProfileManager::GetInstance().UpdateAccessControlProfile(accessControlProfile);
278     DpRadarHelper::GetInstance().ReportUpdateAclProfile(ret, accessControlProfile);
279     return ret;
280 }
281 
PutProductInfoBatch(const std::vector<ProductInfo> & productInfos)282 int32_t DistributedDeviceProfileServiceNew::PutProductInfoBatch(const std::vector<ProductInfo>& productInfos)
283 {
284     if (!PermissionManager::GetInstance().CheckCallerPermission()) {
285         HILOGE("the caller is permission denied!");
286         return DP_PERMISSION_DENIED;
287     }
288     HILOGD("CheckCallerPermission success interface PutProductInfoBatch");
289     int32_t ret = ProfileDataManager::GetInstance().PutProductInfoBatch(productInfos);
290     return ret;
291 }
292 
PutDeviceIconInfoBatch(const std::vector<DeviceIconInfo> & deviceIconInfos)293 int32_t DistributedDeviceProfileServiceNew::PutDeviceIconInfoBatch(const std::vector<DeviceIconInfo>& deviceIconInfos)
294 {
295     if (!PermissionManager::GetInstance().CheckCallerPermission()) {
296         HILOGE("the caller is permission denied!");
297         return DP_PERMISSION_DENIED;
298     }
299     HILOGD("CheckCallerPermission success interface PutDeviceIconInfoBatch");
300     int32_t ret = ProfileDataManager::GetInstance().PutDeviceIconInfoBatch(deviceIconInfos);
301     return ret;
302 }
303 
GetDeviceIconInfos(const DeviceIconInfoFilterOptions & filterOptions,std::vector<DeviceIconInfo> & deviceIconInfos)304 int32_t DistributedDeviceProfileServiceNew::GetDeviceIconInfos(const DeviceIconInfoFilterOptions& filterOptions,
305     std::vector<DeviceIconInfo>& deviceIconInfos)
306 {
307     if (!PermissionManager::GetInstance().CheckCallerPermission()) {
308         HILOGE("the caller is permission denied!");
309         return DP_PERMISSION_DENIED;
310     }
311     HILOGD("CheckCallerPermission success interface GetDeviceIconInfos");
312     int32_t ret = ProfileDataManager::GetInstance().GetDeviceIconInfos(filterOptions, deviceIconInfos);
313     return ret;
314 }
315 
DeleteDeviceProfileBatch(std::vector<DeviceProfile> & deviceProfiles)316 int32_t DistributedDeviceProfileServiceNew::DeleteDeviceProfileBatch(std::vector<DeviceProfile>& deviceProfiles)
317 {
318     if (!PermissionManager::GetInstance().CheckCallerPermission()) {
319         HILOGE("the caller is permission denied!");
320         return DP_PERMISSION_DENIED;
321     }
322     HILOGD("CheckCallerPermission success interface DeleteDeviceProfileBatch");
323     int32_t ret = ProfileDataManager::GetInstance().DeleteDeviceProfileBatch(deviceProfiles);
324     return ret;
325 }
326 
GetTrustDeviceProfile(const std::string & deviceId,TrustDeviceProfile & trustDeviceProfile)327 int32_t DistributedDeviceProfileServiceNew::GetTrustDeviceProfile(const std::string& deviceId,
328     TrustDeviceProfile& trustDeviceProfile)
329 {
330     if (!PermissionManager::GetInstance().IsCallerTrust(GET_TRUST_DEVICE_PROFILE)) {
331         HILOGE("the caller is permission denied!");
332         return DP_PERMISSION_DENIED;
333     }
334     int32_t ret = TrustProfileManager::GetInstance().GetTrustDeviceProfile(deviceId, trustDeviceProfile);
335     DpRadarHelper::GetInstance().ReportGetTrustProfile(ret, deviceId, trustDeviceProfile);
336     return ret;
337 }
338 
GetAllTrustDeviceProfile(std::vector<TrustDeviceProfile> & trustDeviceProfiles)339 int32_t DistributedDeviceProfileServiceNew::GetAllTrustDeviceProfile(
340     std::vector<TrustDeviceProfile>& trustDeviceProfiles)
341 {
342     if (!PermissionManager::GetInstance().IsCallerTrust(GET_ALL_TRUST_DEVICE_PROFILE)) {
343         HILOGE("the caller is permission denied!");
344         return DP_PERMISSION_DENIED;
345     }
346     int32_t ret = TrustProfileManager::GetInstance().GetAllTrustDeviceProfile(trustDeviceProfiles);
347     DpRadarHelper::GetInstance().ReportGetAllTrustProfile(ret, trustDeviceProfiles);
348     return ret;
349 }
350 
GetAccessControlProfile(std::map<std::string,std::string> queryParams,std::vector<AccessControlProfile> & accessControlProfiles)351 int32_t DistributedDeviceProfileServiceNew::GetAccessControlProfile(std::map<std::string, std::string> queryParams,
352     std::vector<AccessControlProfile>& accessControlProfiles)
353 {
354     if (!PermissionManager::GetInstance().IsCallerTrust(GET_ACCESS_CONTROL_PROFILE)) {
355         HILOGE("the caller is permission denied!");
356         return DP_PERMISSION_DENIED;
357     }
358     int32_t ret = TrustProfileManager::GetInstance().GetAccessControlProfile(queryParams, accessControlProfiles);
359     DpRadarHelper::GetInstance().ReportGetAclProfile(ret, accessControlProfiles);
360     return ret;
361 }
362 
GetAllAccessControlProfile(std::vector<AccessControlProfile> & accessControlProfiles)363 int32_t DistributedDeviceProfileServiceNew::GetAllAccessControlProfile(
364     std::vector<AccessControlProfile>& accessControlProfiles)
365 {
366     if (!PermissionManager::GetInstance().IsCallerTrust(GET_ALL_ACCESS_CONTROL_PROFILE)) {
367         HILOGE("the caller is permission denied!");
368         return DP_PERMISSION_DENIED;
369     }
370     int32_t ret = TrustProfileManager::GetInstance().GetAllAccessControlProfile(accessControlProfiles);
371     DpRadarHelper::GetInstance().ReportGetAllAclProfile(ret, accessControlProfiles);
372     return ret;
373 }
374 
DeleteAccessControlProfile(int32_t accessControlId)375 int32_t DistributedDeviceProfileServiceNew::DeleteAccessControlProfile(int32_t accessControlId)
376 {
377     if (!PermissionManager::GetInstance().IsCallerTrust(DELETE_ACCESS_CONTROL_PROFILE)) {
378         HILOGE("the caller is permission denied!");
379         return DP_PERMISSION_DENIED;
380     }
381     int32_t ret = TrustProfileManager::GetInstance().DeleteAccessControlProfile(accessControlId);
382     DpRadarHelper::GetInstance().ReportDeleteAclProfile(ret);
383     return ret;
384 }
385 
PutSessionKey(uint32_t userId,const std::vector<uint8_t> & sessionKey,int32_t & sessionKeyId)386 int32_t DistributedDeviceProfileServiceNew::PutSessionKey(uint32_t userId,
387     const std::vector<uint8_t>& sessionKey, int32_t& sessionKeyId)
388 {
389     if (!PermissionManager::GetInstance().IsCallerTrust(PUT_SESSION_KEY)) {
390         HILOGE("the caller is permission denied!");
391         return DP_PERMISSION_DENIED;
392     }
393     int32_t ret = SessionKeyManager::GetInstance().PutSessionKey(userId, sessionKey, sessionKeyId);
394     return ret;
395 }
396 
GetSessionKey(uint32_t userId,int32_t sessionKeyId,std::vector<uint8_t> & sessionKey)397 int32_t DistributedDeviceProfileServiceNew::GetSessionKey(uint32_t userId,
398     int32_t sessionKeyId, std::vector<uint8_t>& sessionKey)
399 {
400     if (!PermissionManager::GetInstance().IsCallerTrust(GET_SESSION_KEY)) {
401         HILOGE("the caller is permission denied!");
402         return DP_PERMISSION_DENIED;
403     }
404     int32_t ret = SessionKeyManager::GetInstance().GetSessionKey(userId, sessionKeyId, sessionKey);
405     return ret;
406 }
407 
UpdateSessionKey(uint32_t userId,int32_t sessionKeyId,const std::vector<uint8_t> & sessionKey)408 int32_t DistributedDeviceProfileServiceNew::UpdateSessionKey(
409     uint32_t userId, int32_t sessionKeyId, const std::vector<uint8_t>& sessionKey)
410 {
411     if (!PermissionManager::GetInstance().IsCallerTrust(UPDATE_SESSION_KEY)) {
412         HILOGE("the caller is permission denied!");
413         return DP_PERMISSION_DENIED;
414     }
415     int32_t ret = SessionKeyManager::GetInstance().UpdateSessionKey(userId, sessionKeyId, sessionKey);
416     return ret;
417 }
418 
DeleteSessionKey(uint32_t userId,int32_t sessionKeyId)419 int32_t DistributedDeviceProfileServiceNew::DeleteSessionKey(uint32_t userId, int32_t sessionKeyId)
420 {
421     if (!PermissionManager::GetInstance().IsCallerTrust(DELETE_SESSION_KEY)) {
422         HILOGE("the caller is permission denied!");
423         return DP_PERMISSION_DENIED;
424     }
425     int32_t ret = SessionKeyManager::GetInstance().DeleteSessionKey(userId, sessionKeyId);
426     return ret;
427 }
428 
PutDeviceProfileBatch(std::vector<DeviceProfile> & deviceProfiles)429 int32_t DistributedDeviceProfileServiceNew::PutDeviceProfileBatch(std::vector<DeviceProfile>& deviceProfiles)
430 {
431     if (!PermissionManager::GetInstance().CheckCallerPermission()) {
432         HILOGE("the caller is permission denied!");
433         return DP_PERMISSION_DENIED;
434     }
435     HILOGD("CheckCallerPermission success interface PutDeviceProfileBatch");
436     int32_t ret = ProfileDataManager::GetInstance().PutDeviceProfileBatch(deviceProfiles);
437     return ret;
438 }
439 
PutServiceProfile(const ServiceProfile & serviceProfile)440 int32_t DistributedDeviceProfileServiceNew::PutServiceProfile(const ServiceProfile& serviceProfile)
441 {
442     if (!PermissionManager::GetInstance().CheckCallerPermission()) {
443         HILOGE("the caller is permission denied!");
444         return DP_PERMISSION_DENIED;
445     }
446     HILOGD("CheckCallerPermission success interface PutServiceProfile");
447     if (!IsInited()) {
448         return AddSvrProfilesToCache({ serviceProfile });
449     }
450     int32_t ret = DeviceProfileManager::GetInstance().PutServiceProfile(serviceProfile);
451     DpRadarHelper::GetInstance().ReportPutServiceProfile(ret, serviceProfile);
452     return ret;
453 }
454 
PutServiceProfileBatch(const std::vector<ServiceProfile> & serviceProfiles)455 int32_t DistributedDeviceProfileServiceNew::PutServiceProfileBatch(const std::vector<ServiceProfile>& serviceProfiles)
456 {
457     if (!PermissionManager::GetInstance().CheckCallerPermission()) {
458         HILOGE("the caller is permission denied!");
459         return DP_PERMISSION_DENIED;
460     }
461     HILOGD("CheckCallerPermission success interface PutServiceProfileBatch");
462     if (!IsInited()) {
463         return AddSvrProfilesToCache(serviceProfiles);
464     }
465     int32_t ret = DeviceProfileManager::GetInstance().PutServiceProfileBatch(serviceProfiles);
466     DpRadarHelper::GetInstance().ReportPutServiceProfileBatch(ret, serviceProfiles);
467     return ret;
468 }
469 
PutServiceInfoProfile(const ServiceInfoProfile & serviceInfoProfile)470 int32_t DistributedDeviceProfileServiceNew::PutServiceInfoProfile(const ServiceInfoProfile& serviceInfoProfile)
471 {
472     if (!PermissionManager::GetInstance().CheckCallerPermission()) {
473         HILOGE("the caller is permission denied!");
474         return DP_PERMISSION_DENIED;
475     }
476     HILOGD("CheckCallerPermission success interface PutServiceInfoProfile");
477     int32_t ret = ServiceInfoProfileManager::GetInstance().PutServiceInfoProfile(serviceInfoProfile);
478     if (ret == DP_SERVICE_INFO_PROFILE_EXISTS) {
479         ret = DP_SUCCESS;
480     }
481     return ret;
482 }
483 
DeleteServiceInfoProfile(const ServiceInfoUniqueKey & key)484 int32_t DistributedDeviceProfileServiceNew::DeleteServiceInfoProfile(const ServiceInfoUniqueKey& key)
485 {
486     if (!PermissionManager::GetInstance().CheckCallerPermission()) {
487         HILOGE("the caller is permission denied!");
488         return DP_PERMISSION_DENIED;
489     }
490     HILOGD("CheckCallerPermission success interface DeleteServiceInfoProfile");
491     int32_t ret = ServiceInfoProfileManager::GetInstance().DeleteServiceInfoProfile(key);
492     return ret;
493 }
494 
UpdateServiceInfoProfile(const ServiceInfoProfile & serviceInfoProfile)495 int32_t DistributedDeviceProfileServiceNew::UpdateServiceInfoProfile(const ServiceInfoProfile& serviceInfoProfile)
496 {
497     if (!PermissionManager::GetInstance().CheckCallerPermission()) {
498         HILOGE("the caller is permission denied!");
499         return DP_PERMISSION_DENIED;
500     }
501     HILOGD("CheckCallerPermission success interface UpdateServiceInfoProfile");
502     int32_t ret = ServiceInfoProfileManager::GetInstance().UpdateServiceInfoProfile(serviceInfoProfile);
503     return ret;
504 }
505 
GetServiceInfoProfileByUniqueKey(const ServiceInfoUniqueKey & key,ServiceInfoProfile & serviceInfoProfile)506 int32_t DistributedDeviceProfileServiceNew::GetServiceInfoProfileByUniqueKey(const ServiceInfoUniqueKey& key,
507     ServiceInfoProfile& serviceInfoProfile)
508 {
509     if (!PermissionManager::GetInstance().CheckCallerPermission()) {
510         HILOGE("the caller is permission denied!");
511         return DP_PERMISSION_DENIED;
512     }
513     HILOGD("CheckCallerPermission success interface GetServiceInfoProfileByUniqueKey");
514     int32_t ret = ServiceInfoProfileManager::GetInstance().GetServiceInfoProfileByUniqueKey(key, serviceInfoProfile);
515     return ret;
516 }
517 
GetServiceInfoProfileListByTokenId(const ServiceInfoUniqueKey & key,std::vector<ServiceInfoProfile> & serviceInfoProfiles)518 int32_t DistributedDeviceProfileServiceNew::GetServiceInfoProfileListByTokenId(const ServiceInfoUniqueKey& key,
519     std::vector<ServiceInfoProfile>& serviceInfoProfiles)
520 {
521     if (!PermissionManager::GetInstance().CheckCallerPermission()) {
522         HILOGE("the caller is permission denied!");
523         return DP_PERMISSION_DENIED;
524     }
525     HILOGD("CheckCallerPermission success interface GetServiceInfoProfileListByTokenId");
526     int32_t ret = ServiceInfoProfileManager::GetInstance().GetServiceInfoProfileListByTokenId(key,
527         serviceInfoProfiles);
528     return ret;
529 }
530 
GetAllServiceInfoProfileList(std::vector<ServiceInfoProfile> & serviceInfoProfiles)531 int32_t DistributedDeviceProfileServiceNew::GetAllServiceInfoProfileList(
532     std::vector<ServiceInfoProfile>& serviceInfoProfiles)
533 {
534     if (!PermissionManager::GetInstance().CheckCallerPermission()) {
535         HILOGE("the caller is permission denied!");
536         return DP_PERMISSION_DENIED;
537     }
538     HILOGD("CheckCallerPermission success interface GetAllServiceInfoProfileList");
539     int32_t ret = ServiceInfoProfileManager::GetInstance().GetAllServiceInfoProfileList(serviceInfoProfiles);
540     return ret;
541 }
542 
GetServiceInfoProfileListByBundleName(const ServiceInfoUniqueKey & key,std::vector<ServiceInfoProfile> & serviceInfoProfiles)543 int32_t DistributedDeviceProfileServiceNew::GetServiceInfoProfileListByBundleName(const ServiceInfoUniqueKey& key,
544     std::vector<ServiceInfoProfile>& serviceInfoProfiles)
545 {
546     if (!PermissionManager::GetInstance().CheckCallerPermission()) {
547         HILOGE("the caller is permission denied!");
548         return DP_PERMISSION_DENIED;
549     }
550     HILOGD("CheckCallerPermission success interface GetServiceInfoProfileListByBundleName");
551     int32_t ret = ServiceInfoProfileManager::GetInstance().GetServiceInfoProfileListByBundleName(key,
552         serviceInfoProfiles);
553     return ret;
554 }
555 
PutCharacteristicProfile(const CharacteristicProfile & charProfile)556 int32_t DistributedDeviceProfileServiceNew::PutCharacteristicProfile(const CharacteristicProfile& charProfile)
557 {
558     if (!PermissionManager::GetInstance().CheckCallerPermission()) {
559         HILOGE("the caller is permission denied!");
560         return DP_PERMISSION_DENIED;
561     }
562     if (!IsInited()) {
563         return AddCharProfilesToCache({ charProfile });
564     }
565     if (charProfile.GetCharacteristicKey() == SWITCH_STATUS) {
566         int32_t switchRet = SwitchProfileManager::GetInstance().PutCharacteristicProfile(charProfile);
567         DpRadarHelper::GetInstance().ReportPutCharProfile(switchRet, charProfile);
568         return switchRet;
569     }
570     HILOGD("CheckCallerPermission success interface DeviceProfileManager::PutCharacteristicProfile");
571     int32_t ret = DeviceProfileManager::GetInstance().PutCharacteristicProfile(charProfile);
572     DpRadarHelper::GetInstance().ReportPutCharProfile(ret, charProfile);
573     return ret;
574 }
575 
PutCharacteristicProfileBatch(const std::vector<CharacteristicProfile> & charProfiles)576 int32_t DistributedDeviceProfileServiceNew::PutCharacteristicProfileBatch(
577     const std::vector<CharacteristicProfile>& charProfiles)
578 {
579     if (!PermissionManager::GetInstance().CheckCallerPermission()) {
580         HILOGE("this caller is permission denied!");
581         return DP_PERMISSION_DENIED;
582     }
583     if (charProfiles.empty()) {
584         HILOGE("charProfiles is empty");
585         return DP_PUT_CHAR_BATCH_FAIL;
586     }
587     if (charProfiles.size() > MAX_CHAR_SIZE) {
588         HILOGE("charProfiles size is too large");
589         return DP_INVALID_PARAMS;
590     }
591     if (!IsInited()) {
592         return AddCharProfilesToCache(charProfiles);
593     }
594     std::vector<CharacteristicProfile> switchCharProfiles;
595     std::vector<CharacteristicProfile> dynamicCharProfiles;
596     for (auto& profile : charProfiles) {
597         if (profile.GetCharacteristicKey() == SWITCH_STATUS) {
598             switchCharProfiles.push_back(profile);
599             continue;
600         }
601         dynamicCharProfiles.push_back(profile);
602     }
603     int32_t switchRes = DP_SUCCESS;
604     if (switchCharProfiles.size() > 0) {
605         switchRes = SwitchProfileManager::GetInstance().PutCharacteristicProfileBatch(switchCharProfiles);
606         DpRadarHelper::GetInstance().ReportPutCharProfileBatch(switchRes, switchCharProfiles);
607     }
608     if (switchRes != DP_SUCCESS) {
609         HILOGE("PutCharacteristicProfileBatch fail, res:%{public}d", switchRes);
610     }
611     int32_t dynamicRes = DP_SUCCESS;
612     if (dynamicCharProfiles.size() > 0) {
613         dynamicRes = DeviceProfileManager::GetInstance().PutCharacteristicProfileBatch(dynamicCharProfiles);
614         DpRadarHelper::GetInstance().ReportPutCharProfileBatch(dynamicRes, dynamicCharProfiles);
615     }
616     if (dynamicRes != DP_SUCCESS) {
617         HILOGE("PutCharacteristicProfileBatch fail, res:%{public}d", dynamicRes);
618     }
619     if (switchRes != DP_SUCCESS || dynamicRes != DP_SUCCESS) {
620         return DP_PUT_CHAR_BATCH_FAIL;
621     }
622     HILOGD("PutCharacteristicProfileBatch success ");
623     return DP_SUCCESS;
624 }
625 
GetDeviceProfile(const std::string & deviceId,DeviceProfile & deviceProfile)626 int32_t DistributedDeviceProfileServiceNew::GetDeviceProfile(const std::string& deviceId, DeviceProfile& deviceProfile)
627 {
628     if (!PermissionManager::GetInstance().CheckCallerPermission()) {
629         HILOGE("this caller is permission denied!");
630         return DP_PERMISSION_DENIED;
631     }
632     HILOGD("CheckCallerPermission success interface GetDeviceProfile");
633     int32_t ret = DeviceProfileManager::GetInstance().GetDeviceProfile(deviceId, deviceProfile);
634     DpRadarHelper::GetInstance().ReportGetDeviceProfile(ret, deviceId, deviceProfile);
635     return ret;
636 }
637 
GetDeviceProfiles(DeviceProfileFilterOptions & options,std::vector<DeviceProfile> & deviceProfiles)638 int32_t DistributedDeviceProfileServiceNew::GetDeviceProfiles(DeviceProfileFilterOptions& options,
639     std::vector<DeviceProfile>& deviceProfiles)
640 {
641     if (!PermissionManager::GetInstance().CheckCallerPermission()) {
642         HILOGE("this caller is permission denied!");
643         return DP_PERMISSION_DENIED;
644     }
645     HILOGD("CheckCallerPermission success interface GetDeviceProfiles");
646     int32_t ret = ProfileDataManager::GetInstance().GetDeviceProfiles(options, deviceProfiles);
647     return ret;
648 }
649 
GetServiceProfile(const std::string & deviceId,const std::string & serviceName,ServiceProfile & serviceProfile)650 int32_t DistributedDeviceProfileServiceNew::GetServiceProfile(const std::string& deviceId,
651     const std::string& serviceName, ServiceProfile& serviceProfile)
652 {
653     if (!PermissionManager::GetInstance().CheckCallerPermission()) {
654         HILOGE("this caller is permission denied!");
655         return DP_PERMISSION_DENIED;
656     }
657     HILOGD("CheckCallerPermission success interface GetServiceProfile");
658     int32_t ret = DeviceProfileManager::GetInstance().GetServiceProfile(deviceId, serviceName, serviceProfile);
659     DpRadarHelper::GetInstance().ReportGetServiceProfile(ret, deviceId, serviceProfile);
660     return ret;
661 }
662 
GetCharacteristicProfile(const std::string & deviceId,const std::string & serviceName,const std::string & characteristicKey,CharacteristicProfile & charProfile)663 int32_t DistributedDeviceProfileServiceNew::GetCharacteristicProfile(const std::string& deviceId,
664     const std::string& serviceName, const std::string& characteristicKey, CharacteristicProfile& charProfile)
665 {
666     if (!PermissionManager::GetInstance().CheckCallerPermission()) {
667         HILOGE("this caller is permission denied!");
668         return DP_PERMISSION_DENIED;
669     }
670     if (characteristicKey == SWITCH_STATUS) {
671         HILOGD("CheckCallerPermission success interface SwitchProfileManager::GetCharacteristicProfile");
672         int32_t switchRet = SwitchProfileManager::GetInstance().GetCharacteristicProfile(deviceId, serviceName,
673             characteristicKey, charProfile);
674         DpRadarHelper::GetInstance().ReportGetCharProfile(switchRet, deviceId, charProfile);
675         return switchRet;
676     }
677     if (characteristicKey == STATIC_CHARACTERISTIC_KEY) {
678         HILOGD("CheckCallerPermission success interface StaticProfileManager::GetCharacteristicProfile");
679         int32_t staticRet = StaticProfileManager::GetInstance().GetCharacteristicProfile(deviceId, serviceName,
680             characteristicKey, charProfile);
681         DpRadarHelper::GetInstance().ReportGetCharProfile(staticRet, deviceId, charProfile);
682         return staticRet;
683     }
684     HILOGD("CheckCallerPermission success interface DeviceProfileManager::GetCharacteristicProfile");
685     int32_t ret = DeviceProfileManager::GetInstance().GetCharacteristicProfile(deviceId, serviceName,
686         characteristicKey, charProfile);
687     DpRadarHelper::GetInstance().ReportGetCharProfile(ret, deviceId, charProfile);
688     return ret;
689 }
690 
DeleteServiceProfile(const std::string & deviceId,const std::string & serviceName,bool isMultiUser,int32_t userId)691 int32_t DistributedDeviceProfileServiceNew::DeleteServiceProfile(const std::string& deviceId,
692     const std::string& serviceName, bool isMultiUser, int32_t userId)
693 {
694     if (!PermissionManager::GetInstance().CheckCallerPermission()) {
695         HILOGE("this caller is permission denied!");
696         return DP_PERMISSION_DENIED;
697     }
698     HILOGD("CheckCallerPermission success interface DeleteServiceProfile");
699     int32_t ret = DeviceProfileManager::GetInstance().DeleteServiceProfile(deviceId, serviceName, isMultiUser, userId);
700     DpRadarHelper::GetInstance().ReportDeleteServiceProfile(ret, deviceId);
701     return ret;
702 }
703 
DeleteCharacteristicProfile(const std::string & deviceId,const std::string & serviceName,const std::string & characteristicKey,bool isMultiUser,int32_t userId)704 int32_t DistributedDeviceProfileServiceNew::DeleteCharacteristicProfile(const std::string& deviceId,
705     const std::string& serviceName, const std::string& characteristicKey, bool isMultiUser, int32_t userId)
706 {
707     if (!PermissionManager::GetInstance().CheckCallerPermission()) {
708         HILOGE("this caller is permission denied!");
709         return DP_PERMISSION_DENIED;
710     }
711     HILOGD("CheckCallerPermission success interface DeleteCharacteristicProfile");
712     int32_t ret = DeviceProfileManager::GetInstance().DeleteCharacteristicProfile(deviceId, serviceName,
713         characteristicKey, isMultiUser, userId);
714     DpRadarHelper::GetInstance().ReportDeleteCharProfile(ret, deviceId);
715     return ret;
716 }
717 
PutLocalServiceInfo(const LocalServiceInfo & localServiceInfo)718 int32_t DistributedDeviceProfileServiceNew::PutLocalServiceInfo(const LocalServiceInfo& localServiceInfo)
719 {
720     if (!PermissionManager::GetInstance().CheckCallerPermission()) {
721         HILOGE("the caller is permission denied!");
722         return DP_PERMISSION_DENIED;
723     }
724     HILOGD("CheckCallerPermission success interface PutLocalServiceInfo");
725     int32_t ret = LocalServiceInfoManager::GetInstance().PutLocalServiceInfo(localServiceInfo);
726     if (ret == DP_SUCCESS && localServiceInfo.GetPinCode() == INVALID_PINCODE) {
727         HILOGI("NotifyPinCodeInvalid, serviceInfoProfile:%{public}s", localServiceInfo.dump().c_str());
728         NotifyPinCodeInvalid(localServiceInfo);
729     }
730     return ret;
731 }
732 
UpdateLocalServiceInfo(const LocalServiceInfo & localServiceInfo)733 int32_t DistributedDeviceProfileServiceNew::UpdateLocalServiceInfo(const LocalServiceInfo& localServiceInfo)
734 {
735     if (!PermissionManager::GetInstance().CheckCallerPermission()) {
736         HILOGE("the caller is permission denied!");
737         return DP_PERMISSION_DENIED;
738     }
739     HILOGD("CheckCallerPermission success interface UpdateLocalServiceInfo");
740     int32_t ret = LocalServiceInfoManager::GetInstance().UpdateLocalServiceInfo(localServiceInfo);
741     if (ret == DP_SUCCESS && localServiceInfo.GetPinCode() == INVALID_PINCODE) {
742         HILOGI("NotifyPinCodeInvalid, serviceInfoProfile:%{public}s", localServiceInfo.dump().c_str());
743         NotifyPinCodeInvalid(localServiceInfo);
744     }
745     return ret;
746 }
747 
GetLocalServiceInfoByBundleAndPinType(const std::string & bundleName,int32_t pinExchangeType,LocalServiceInfo & localServiceInfo)748 int32_t DistributedDeviceProfileServiceNew::GetLocalServiceInfoByBundleAndPinType(const std::string& bundleName,
749     int32_t pinExchangeType, LocalServiceInfo& localServiceInfo)
750 {
751     if (!PermissionManager::GetInstance().CheckCallerPermission()) {
752         HILOGE("the caller is permission denied!");
753         return DP_PERMISSION_DENIED;
754     }
755     HILOGD("CheckCallerPermission success interface GetLocalServiceInfoByBundleAndPinType");
756     int32_t ret = LocalServiceInfoManager::GetInstance().GetLocalServiceInfoByBundleAndPinType(bundleName,
757         pinExchangeType, localServiceInfo);
758     return ret;
759 }
760 
DeleteLocalServiceInfo(const std::string & bundleName,int32_t pinExchangeType)761 int32_t DistributedDeviceProfileServiceNew::DeleteLocalServiceInfo(const std::string& bundleName,
762     int32_t pinExchangeType)
763 {
764     if (!PermissionManager::GetInstance().CheckCallerPermission()) {
765         HILOGE("the caller is permission denied!");
766         return DP_PERMISSION_DENIED;
767     }
768     HILOGD("CheckCallerPermission success interface DeleteLocalServiceInfo");
769     int32_t ret = LocalServiceInfoManager::GetInstance().DeleteLocalServiceInfo(bundleName, pinExchangeType);
770     return ret;
771 }
772 
SubscribeDeviceProfile(const SubscribeInfo & subscriberInfo)773 int32_t DistributedDeviceProfileServiceNew::SubscribeDeviceProfile(const SubscribeInfo& subscriberInfo)
774 {
775     if (!PermissionManager::GetInstance().CheckCallerPermission()) {
776         HILOGE("this caller is permission denied!");
777         return DP_PERMISSION_DENIED;
778     }
779     HILOGD("CheckCallerPermission success interface SubscribeDeviceProfile");
780     int32_t ret = SubscribeProfileManager::GetInstance().SubscribeDeviceProfile(subscriberInfo);
781     DpRadarHelper::GetInstance().ReportSubscribeDeviceProfile(ret, subscriberInfo);
782     return ret;
783 }
784 
UnSubscribeDeviceProfile(const SubscribeInfo & subscriberInfo)785 int32_t DistributedDeviceProfileServiceNew::UnSubscribeDeviceProfile(const SubscribeInfo& subscriberInfo)
786 {
787     if (!PermissionManager::GetInstance().CheckCallerPermission()) {
788         HILOGE("this caller is permission denied!");
789         return DP_PERMISSION_DENIED;
790     }
791     HILOGD("CheckCallerPermission success interface UnSubscribeDeviceProfile");
792     int32_t ret = SubscribeProfileManager::GetInstance().UnSubscribeDeviceProfile(subscriberInfo);
793     DpRadarHelper::GetInstance().ReportUnSubscribeDeviceProfile(ret, subscriberInfo);
794     return ret;
795 }
796 
SyncDeviceProfile(const DistributedDeviceProfile::DpSyncOptions & syncOptions,sptr<IRemoteObject> syncCompletedCallback)797 int32_t DistributedDeviceProfileServiceNew::SyncDeviceProfile(
798     const DistributedDeviceProfile::DpSyncOptions& syncOptions, sptr<IRemoteObject> syncCompletedCallback)
799 {
800     if (!PermissionManager::GetInstance().CheckCallerSyncPermission()) {
801         HILOGE("this caller is permission denied!");
802         return DP_PERMISSION_DENIED;
803     }
804     HILOGD("CheckCallerSyncPermission success interface SyncDeviceProfile");
805     int32_t ret = DeviceProfileManager::GetInstance().SyncDeviceProfile(syncOptions, syncCompletedCallback);
806     DpRadarHelper::GetInstance().ReportSyncDeviceProfile(ret);
807     return ret;
808 }
809 
SendSubscribeInfos(std::map<std::string,SubscribeInfo> listenerMap)810 int32_t DistributedDeviceProfileServiceNew::SendSubscribeInfos(std::map<std::string, SubscribeInfo> listenerMap)
811 {
812     return SubscribeProfileManager::GetInstance().SubscribeDeviceProfile(listenerMap);
813 }
814 
Dump(int32_t fd,const std::vector<std::u16string> & args)815 int32_t DistributedDeviceProfileServiceNew::Dump(int32_t fd, const std::vector<std::u16string>& args)
816 {
817     if (args.size() > MAX_DUMP_ARGS_SIZE) {
818         HILOGE("args size is too large");
819         return DP_INVALID_PARAMS;
820     }
821     std::vector<std::string> argsInStr8;
822     for (const auto& arg : args) {
823         argsInStr8.emplace_back(Str16ToStr8(arg));
824     }
825 
826     std::string result;
827     DeviceProfileDumper::Dump(argsInStr8, result);
828 
829     if (!SaveStringToFd(fd, result)) {
830         HILOGE("save to fd failed");
831         return DP_INVALID_PARAMS;
832     }
833     return DP_SUCCESS;
834 }
835 
DelayUnloadTask()836 void DistributedDeviceProfileServiceNew::DelayUnloadTask()
837 {
838     HILOGD("delay unload task begin");
839     auto task = []() {
840         HILOGD("do unload task");
841         if (ProfileCache::GetInstance().IsDeviceOnline()) {
842             HILOGI("already device online in 3 min, not kill!");
843             return;
844         }
845         auto samgrProxy = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
846         if (samgrProxy == nullptr) {
847             HILOGE("get samgr failed");
848             return;
849         }
850         int32_t unloadResult = samgrProxy->UnloadSystemAbility(DISTRIBUTED_DEVICE_PROFILE_SA_ID);
851         if (unloadResult != DP_SUCCESS) {
852             HILOGE("remove system ability failed");
853             return;
854         }
855         HILOGI("kill dp svr success!");
856     };
857     {
858         std::lock_guard<std::mutex> lock(unloadMutex_);
859         if (unloadHandler_ == nullptr) {
860             HILOGE("unloadHandler is nullptr ");
861             return;
862         }
863         unloadHandler_->RemoveTask(UNLOAD_TASK_ID);
864         if (ProfileCache::GetInstance().IsDeviceOnline()) {
865             HILOGI("already device online, not kill!");
866             return;
867         }
868         HILOGI("delay unload task post task");
869         unloadHandler_->PostTask(task, UNLOAD_TASK_ID, DELAY_TIME);
870     }
871 }
872 
OnStart(const SystemAbilityOnDemandReason & startReason)873 void DistributedDeviceProfileServiceNew::OnStart(const SystemAbilityOnDemandReason& startReason)
874 {
875     HILOGI("start reason %{public}s", startReason.GetName().c_str());
876     if (Init() != DP_SUCCESS) {
877         HILOGE("init failed");
878         return;
879     }
880     AddSystemAbilityListener(SOFTBUS_SERVER_SA_ID);
881     AddSystemAbilityListener(DISTRIBUTED_KV_DATA_SERVICE_ABILITY_ID);
882     AddSystemAbilityListener(DISTRIBUTED_HARDWARE_DEVICEMANAGER_SA_ID);
883     AddSystemAbilityListener(SUBSYS_ACCOUNT_SYS_ABILITY_ID_BEGIN);
884     IPCSkeleton::SetMaxWorkThreadNum(DP_IPC_THREAD_NUM);
885     if (!Publish(this)) {
886         HILOGE("publish SA failed");
887         return;
888     }
889     if (CreateUnloadHandler() == DP_SUCCESS) {
890         HILOGI("CreateUnloadHandler success!");
891         DelayUnloadTask();
892     }
893 }
894 
OnStop()895 void DistributedDeviceProfileServiceNew::OnStop()
896 {
897     int32_t ret = UnInit();
898     HILOGI("UnInit ret=%{public}d", ret);
899 }
900 
OnIdle(const SystemAbilityOnDemandReason & idleReason)901 int32_t DistributedDeviceProfileServiceNew::OnIdle(const SystemAbilityOnDemandReason& idleReason)
902 {
903     HILOGI("idle reason %{public}d", idleReason.GetId());
904     return UNLOAD_IMMEDIATELY;
905 }
906 
OnAddSystemAbility(int32_t systemAbilityId,const std::string & deviceId)907 void DistributedDeviceProfileServiceNew::OnAddSystemAbility(int32_t systemAbilityId, const std::string& deviceId)
908 {
909     HILOGI("called systemAbilityId:%{public}d", systemAbilityId);
910     if (systemAbilityId == SUBSYS_ACCOUNT_SYS_ABILITY_ID_BEGIN) {
911         SubscribeAccountCommonEvent();
912     }
913     if (IsInited()) {
914         return;
915     }
916     {
917         std::lock_guard<std::mutex> lock(depSaIdsMtx_);
918         if (depSaIds_.empty()) {
919             return;
920         }
921         depSaIds_.erase(systemAbilityId);
922         if (!depSaIds_.empty()) {
923             return;
924         }
925     }
926     PostInit();
927 }
928 
SubscribeAccountCommonEvent()929 void DistributedDeviceProfileServiceNew::SubscribeAccountCommonEvent()
930 {
931     HILOGI("Start");
932     {
933         std::lock_guard<std::mutex> lock(accountCommonEventManagerMtx_);
934         if (accountCommonEventManager_ == nullptr) {
935             accountCommonEventManager_ = std::make_shared<DpAccountCommonEventManager>();
936         }
937     }
938     AccountEventCallback callback = [=](const auto &arg1, const auto &arg2) {
939         this->AccountCommonEventCallback(arg1, arg2);
940     };
941     std::vector<std::string> AccountCommonEventVec;
942     AccountCommonEventVec.emplace_back(EventFwk::CommonEventSupport::COMMON_EVENT_USER_SWITCHED);
943     AccountCommonEventVec.emplace_back(EventFwk::CommonEventSupport::COMMON_EVENT_USER_REMOVED);
944     std::lock_guard<std::mutex> lock(accountCommonEventManagerMtx_);
945     if (accountCommonEventManager_->SubscribeAccountCommonEvent(AccountCommonEventVec, callback)) {
946         HILOGI("Success");
947     }
948     return;
949 }
950 
AccountCommonEventCallback(int32_t userId,const std::string commonEventType)951 void DistributedDeviceProfileServiceNew::AccountCommonEventCallback(int32_t userId, const std::string commonEventType)
952 {
953     HILOGI("CommonEventType: %{public}s, userId: %{public}d", commonEventType.c_str(), userId);
954     if (commonEventType == EventFwk::CommonEventSupport::COMMON_EVENT_USER_SWITCHED) {
955         // swithed
956         MultiUserManager::GetInstance().SetCurrentForegroundUserID(userId);
957         return;
958     }
959     if (commonEventType == EventFwk::CommonEventSupport::COMMON_EVENT_USER_REMOVED) {
960         // removed
961         if (DeviceProfileManager::GetInstance().DeleteRemovedUserData(userId) != DP_SUCCESS) {
962             HILOGE("DeleteRemovedUserData failed,userId=%{public}d", userId);
963         } else {
964             HILOGI("DeleteRemovedUserData succeed,userId=%{public}d", userId);
965         }
966         return;
967     }
968     HILOGE("Invalied account common event.");
969     return;
970 }
971 
AddSvrProfilesToCache(const std::vector<ServiceProfile> & serviceProfiles)972 int32_t DistributedDeviceProfileServiceNew::AddSvrProfilesToCache(const std::vector<ServiceProfile>& serviceProfiles)
973 {
974     if (serviceProfiles.empty()) {
975         HILOGE("serviceProfiles empty");
976         return DP_INVALID_PARAM;
977     }
978     HILOGI("serviceProfiles.size:%{public}zu", serviceProfiles.size());
979     std::map<std::string, std::string> entries;
980     for (const auto& item : serviceProfiles) {
981         if (!ProfileUtils::IsSvrProfileValid(item)) {
982             HILOGE("the is invalid, serviceProfile:%{public}s", item.dump().c_str());
983             return DP_INVALID_PARAM;
984         }
985         if (ProfileCache::GetInstance().IsServiceProfileExist(item)) {
986             HILOGW("the profile is exist!, serviceProfile:%{public}s", item.dump().c_str());
987             return DP_CACHE_EXIST;
988         }
989         ProfileUtils::ServiceProfileToEntries(item, entries);
990     }
991     std::lock_guard<std::mutex> lock(dynamicProfileMapMtx_);
992     for (const auto& [key, value] : entries) {
993         dynamicProfileMap_[key] = value;
994     }
995     return DP_SUCCESS;
996 }
997 
AddCharProfilesToCache(const std::vector<CharacteristicProfile> & charProfiles)998 int32_t DistributedDeviceProfileServiceNew::AddCharProfilesToCache(
999     const std::vector<CharacteristicProfile>& charProfiles)
1000 {
1001     if (charProfiles.empty()) {
1002         HILOGE("charProfiles empty");
1003         return DP_INVALID_PARAM;
1004     }
1005     HILOGI("charProfiles.size:%{public}zu", charProfiles.size());
1006     std::vector<CharacteristicProfile> switchCharProfiles;
1007     std::map<std::string, std::string> entries;
1008     for (const auto& item : charProfiles) {
1009         if (!ProfileUtils::IsCharProfileValid(item)) {
1010             HILOGE("the is invalid, charProfile:%{public}s", item.dump().c_str());
1011             return DP_INVALID_PARAM;
1012         }
1013         if (ProfileCache::GetInstance().IsCharProfileExist(item)) {
1014             HILOGW("the profile is exist!, charProfile:%{public}s", item.dump().c_str());
1015             return DP_CACHE_EXIST;
1016         }
1017         if (item.GetCharacteristicKey() == SWITCH_STATUS) {
1018             switchCharProfiles.push_back(item);
1019             continue;
1020         }
1021         ProfileUtils::CharacteristicProfileToEntries(item, entries);
1022     }
1023     if (!entries.empty()) {
1024         HILOGI("entries.size:%{public}zu", entries.size());
1025         std::lock_guard<std::mutex> lock(dynamicProfileMapMtx_);
1026         for (const auto& [key, value] : entries) {
1027             dynamicProfileMap_[key] = value;
1028         }
1029     }
1030     if (!switchCharProfiles.empty()) {
1031         HILOGI("switchCharProfiles.size:%{public}zu", switchCharProfiles.size());
1032         std::lock_guard<std::mutex> lock(switchProfileMapMtx_);
1033         for (const auto& item : charProfiles) {
1034             std::string profileKey = ProfileUtils::GenerateCharProfileKey(item.GetDeviceId(),
1035                 item.GetServiceName(), item.GetCharacteristicKey());
1036             switchProfileMap_[profileKey] = item;
1037         }
1038     }
1039     return DP_SUCCESS;
1040 }
1041 
SaveSwitchProfilesFromTempCache()1042 int32_t DistributedDeviceProfileServiceNew::SaveSwitchProfilesFromTempCache()
1043 {
1044     std::vector<CharacteristicProfile> switchCharProfiles;
1045     {
1046         std::lock_guard<std::mutex> lock(switchProfileMapMtx_);
1047         if (switchProfileMap_.empty()) {
1048             HILOGW("switchProfileMap empty");
1049             return DP_SUCCESS;
1050         }
1051         HILOGI("switchProfileMap.size:%{public}zu", switchProfileMap_.size());
1052         for (const auto& [profileKey, item] : switchProfileMap_) {
1053             switchCharProfiles.emplace_back(item);
1054         }
1055         switchProfileMap_.clear();
1056     }
1057     int32_t ret = SwitchProfileManager::GetInstance().PutCharacteristicProfileBatch(switchCharProfiles);
1058     DpRadarHelper::GetInstance().ReportPutCharProfileBatch(ret, switchCharProfiles);
1059     if (ret != DP_SUCCESS) {
1060         HILOGE("PutCharacteristicProfileBatch fail, ret: %{public}d!", ret);
1061     }
1062     return ret;
1063 }
1064 
GetDynamicProfilesFromTempCache(std::map<std::string,std::string> & entries)1065 void DistributedDeviceProfileServiceNew::GetDynamicProfilesFromTempCache(
1066     std::map<std::string, std::string>& entries)
1067 {
1068     {
1069         std::lock_guard<std::mutex> lock(dynamicProfileMapMtx_);
1070         if (dynamicProfileMap_.empty()) {
1071             HILOGW("dynamicProfileMap empty!");
1072             return;
1073         }
1074         for (const auto& [key, value] : dynamicProfileMap_) {
1075             entries[key] = value;
1076         }
1077     }
1078 }
1079 
SaveDynamicProfilesFromTempCache()1080 int32_t DistributedDeviceProfileServiceNew::SaveDynamicProfilesFromTempCache()
1081 {
1082     std::map<std::string, std::string> entries;
1083     GetDynamicProfilesFromTempCache(entries);
1084     if (entries.empty() && DeviceProfileManager::GetInstance().IsFirstInitDB()) {
1085         HILOGW("entries empty!");
1086         sleep(WAIT_BUSINESS_PUT_TIME_S);
1087         GetDynamicProfilesFromTempCache(entries);
1088     }
1089     HILOGI("entries.size:%{public}zu", entries.size());
1090     int32_t tryTimes = WRTE_CACHE_PROFILE_RETRY_TIMES;
1091     while (tryTimes > 0) {
1092         if (DeviceProfileManager::GetInstance().SavePutTempCache(entries) == DP_SUCCESS) {
1093             break;
1094         }
1095         HILOGW("SavePutTempCache fail! leftTimes:%{public}d", tryTimes);
1096         usleep(WRTE_CACHE_PROFILE_DELAY_TIME_US);
1097         tryTimes--;
1098     }
1099     if (tryTimes <= 0) {
1100         DeviceProfileManager::GetInstance().ResetFirst();
1101     }
1102     {
1103         std::lock_guard<std::mutex> lock(dynamicProfileMapMtx_);
1104         dynamicProfileMap_.clear();
1105     }
1106     return DP_SUCCESS;
1107 }
1108 
ClearProfileCache()1109 void DistributedDeviceProfileServiceNew::ClearProfileCache()
1110 {
1111     {
1112         std::lock_guard<std::mutex> lock(dynamicProfileMapMtx_);
1113         dynamicProfileMap_.clear();
1114     }
1115     {
1116         std::lock_guard<std::mutex> lock(switchProfileMapMtx_);
1117         switchProfileMap_.clear();
1118     }
1119 }
1120 
SubscribeDeviceProfileInited(int32_t saId,sptr<IRemoteObject> dpInitedCallback)1121 int32_t DistributedDeviceProfileServiceNew::SubscribeDeviceProfileInited(int32_t saId,
1122     sptr <IRemoteObject> dpInitedCallback)
1123 {
1124     if (!PermissionManager::GetInstance().CheckCallerPermission()) {
1125         HILOGE("this caller is permission denied!");
1126         return DP_PERMISSION_DENIED;
1127     }
1128     if (dpInitedCallback == nullptr) {
1129         HILOGE("dpInitedCallback is nullptr");
1130         return DP_INVALID_PARAM;
1131     }
1132     if (saId <= 0 || saId > MAX_SAID) {
1133         HILOGE("saId is invalid, saId:%{public}d", saId);
1134         return DP_INVALID_PARAM;
1135     }
1136     if (isInited_.load()) {
1137         HILOGI("deviceProfile service is already inited.");
1138         sptr<IDpInitedCallback> callbackProxy = iface_cast<IDpInitedCallback>(dpInitedCallback);
1139         if (callbackProxy == nullptr) {
1140             HILOGE("Cast to IDpInitedCallback failed!");
1141             return DP_NULLPTR;
1142         }
1143         callbackProxy->OnDpInited();
1144     }
1145     std::lock_guard<std::mutex> lock(dpInitedCallbackMapMtx_);
1146     dpInitedCallbackMap_[saId] = dpInitedCallback;
1147     return DP_SUCCESS;
1148 }
1149 
UnSubscribeDeviceProfileInited(int32_t saId)1150 int32_t DistributedDeviceProfileServiceNew::UnSubscribeDeviceProfileInited(int32_t saId)
1151 {
1152     if (!PermissionManager::GetInstance().CheckCallerPermission()) {
1153         HILOGE("this caller is permission denied!");
1154         return DP_PERMISSION_DENIED;
1155     }
1156     std::lock_guard<std::mutex> lock(dpInitedCallbackMapMtx_);
1157     dpInitedCallbackMap_.erase(saId);
1158     return DP_SUCCESS;
1159 }
1160 
SubscribePinCodeInvalid(const std::string & bundleName,int32_t pinExchangeType,sptr<IRemoteObject> pinCodeCallback)1161 int32_t DistributedDeviceProfileServiceNew::SubscribePinCodeInvalid(const std::string& bundleName,
1162     int32_t pinExchangeType, sptr<IRemoteObject> pinCodeCallback)
1163 {
1164     if (!PermissionManager::GetInstance().CheckCallerPermission()) {
1165         HILOGE("this caller is permission denied!");
1166         return DP_PERMISSION_DENIED;
1167     }
1168     if (bundleName.empty()) {
1169         HILOGE("bundleName is invalid");
1170         return DP_INVALID_PARAM;
1171     }
1172     if (pinExchangeType == DEFAULT_PIN_EXCHANGE_TYPE) {
1173         HILOGE("pinExchangeType is invalid");
1174         return DP_INVALID_PARAM;
1175     }
1176     if (pinCodeCallback == nullptr) {
1177         HILOGE("pinCodeCallback is nullptr");
1178         return DP_INVALID_PARAM;
1179     }
1180     std::lock_guard<std::mutex> lock(pinCodeCallbackMapMtx_);
1181     pinCodeCallbackMap_[std::make_pair(bundleName, pinExchangeType)] = pinCodeCallback;
1182     return DP_SUCCESS;
1183 }
1184 
UnSubscribePinCodeInvalid(const std::string & bundleName,int32_t pinExchangeType)1185 int32_t DistributedDeviceProfileServiceNew::UnSubscribePinCodeInvalid(const std::string& bundleName,
1186     int32_t pinExchangeType)
1187 {
1188     if (!PermissionManager::GetInstance().CheckCallerPermission()) {
1189         HILOGE("this caller is permission denied!");
1190         return DP_PERMISSION_DENIED;
1191     }
1192     if (bundleName.empty()) {
1193         HILOGE("bundleName is invalid");
1194         return DP_INVALID_PARAM;
1195     }
1196     if (pinExchangeType == DEFAULT_PIN_EXCHANGE_TYPE) {
1197         HILOGE("pinExchangeType is invalid");
1198         return DP_INVALID_PARAM;
1199     }
1200     std::lock_guard<std::mutex> lock(pinCodeCallbackMapMtx_);
1201     pinCodeCallbackMap_.erase(std::make_pair(bundleName, pinExchangeType));
1202     return DP_SUCCESS;
1203 }
1204 
NotifyDeviceProfileInited()1205 int32_t DistributedDeviceProfileServiceNew::NotifyDeviceProfileInited()
1206 {
1207     std::lock_guard<std::mutex> lock(dpInitedCallbackMapMtx_);
1208     for (const auto& [saId, callback] : dpInitedCallbackMap_) {
1209         sptr<IDpInitedCallback> callbackProxy = iface_cast<IDpInitedCallback>(callback);
1210         if (callbackProxy == nullptr) {
1211             HILOGE("Cast to IDpInitedCallback failed!");
1212             continue;
1213         }
1214         callbackProxy->OnDpInited();
1215     }
1216     return DP_SUCCESS;
1217 }
1218 
NotifyPinCodeInvalid(const LocalServiceInfo & localServiceInfo)1219 int32_t DistributedDeviceProfileServiceNew::NotifyPinCodeInvalid(const LocalServiceInfo& localServiceInfo)
1220 {
1221     HILOGI("call");
1222     sptr<IPincodeInvalidCallback> callbackProxy = nullptr;
1223     {
1224         std::lock_guard<std::mutex> lock(pinCodeCallbackMapMtx_);
1225         auto item = pinCodeCallbackMap_.find({localServiceInfo.GetBundleName(),
1226             localServiceInfo.GetPinExchangeType()});
1227         if (item == pinCodeCallbackMap_.end()) {
1228             HILOGI("not subscribe PinCodeInvalid");
1229             return DP_SUCCESS;
1230         }
1231         callbackProxy = iface_cast<IPincodeInvalidCallback>(item->second);
1232         if (callbackProxy == nullptr) {
1233             HILOGE("Cast to IPincodeInvalidCallback failed!");
1234             return DP_NULLPTR;
1235         }
1236     }
1237     auto task = [callbackProxy, localServiceInfo]() {
1238         if (callbackProxy == nullptr) {
1239             HILOGI("OnPincodeInvalid task callbackProxy is nullptr");
1240             return;
1241         }
1242         callbackProxy->OnPincodeInvalid(localServiceInfo);
1243     };
1244     auto handler = EventHandlerFactory::GetInstance().GetEventHandler();
1245     HILOGI("notify");
1246     if (handler == nullptr || !handler->PostTask(task)) {
1247         HILOGE("Post OnPincodeInvalid task failed");
1248         return DP_POST_TASK_FAILED;
1249     }
1250     return DP_SUCCESS;
1251 }
1252 
PutAllTrustedDevices(const std::vector<TrustedDeviceInfo> deviceInfos)1253 int32_t DistributedDeviceProfileServiceNew::PutAllTrustedDevices(const std::vector<TrustedDeviceInfo> deviceInfos)
1254 {
1255     if (!PermissionManager::GetInstance().IsCallerTrust(PUT_ALL_TRUSTED_DEVICES)) {
1256         HILOGE("this caller is permission denied!");
1257         return DP_PERMISSION_DENIED;
1258     }
1259     return ProfileCache::GetInstance().AddAllTrustedDevices(deviceInfos);
1260 }
1261 } // namespace DeviceProfile
1262 } // namespace OHOS
1263