1 /*
2 * Copyright (c) 2022-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 <sstream>
17 #include "iremote_object.h"
18 #include "b_error/b_error.h"
19 #include "b_error/b_excep_utils.h"
20 #include "b_radar/b_radar.h"
21 #include "b_resources/b_constants.h"
22 #include "filemgmt_libhilog.h"
23 #include "iservice_registry.h"
24 #include "service_client.h"
25 #include "system_ability_definition.h"
26 #include "svc_death_recipient.h"
27 #include "hitrace_meter.h"
28
29 namespace OHOS::FileManagement::Backup {
30 using namespace std;
31
CheckServiceProxy()32 bool ServiceClient::CheckServiceProxy()
33 {
34 serviceProxy_ = ServiceClient::GetInstance();
35 bool isNull = false;
36 if (serviceProxy_ != nullptr) {
37 isNull = true;
38 }
39 return isNull;
40 }
41
GetServiceProxyPointer()42 sptr<IService> ServiceClient::GetServiceProxyPointer()
43 {
44 HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__);
45 unique_lock<mutex> lock(proxyMutex_);
46 return serviceProxy_;
47 }
48
GetInstance()49 sptr<IService> ServiceClient::GetInstance()
50 {
51 HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__);
52 unique_lock<mutex> getInstanceLock(getInstanceMutex_);
53 unique_lock<mutex> lock(proxyMutex_);
54 if (serviceProxy_ != nullptr) {
55 return serviceProxy_;
56 }
57 auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
58 if (!samgr) {
59 HILOGE("Get an empty samgr");
60 return nullptr;
61 }
62 sptr<ServiceProxyLoadCallback> loadCallback = sptr(new ServiceProxyLoadCallback());
63 if (loadCallback == nullptr) {
64 HILOGE("loadCallback is nullptr.");
65 return nullptr;
66 }
67 int32_t ret = samgr->LoadSystemAbility(FILEMANAGEMENT_BACKUP_SERVICE_SA_ID, loadCallback);
68 if (ret != ERR_OK) {
69 HILOGE("Failed to Load systemAbility, systemAbilityId:%{private}d, ret code:%{public}d",
70 FILEMANAGEMENT_BACKUP_SERVICE_SA_ID, ret);
71 return nullptr;
72 }
73 auto waitStatus =
74 loadCallback->proxyConVar_.wait_for(lock, std::chrono::milliseconds(BConstants::BACKUP_LOADSA_TIMEOUT_MS),
75 [loadCallback]() { return loadCallback->isLoadSuccess_.load(); });
76 if (!waitStatus) {
77 HILOGE("Load backup sa timeout");
78 AppRadar::Info info("", "", "\"reason\":\"Load backup sa timeout\"");
79 AppRadar::GetInstance().RecordBackupFuncRes(info, "ServiceClient::GetInstance",
80 AppRadar::GetInstance().GetUserId(), BizStageBackup::BIZ_STAGE_BOOT_BACKUP_SA_FAIL,
81 BError(BError::Codes::SA_INVAL_ARG).GetCode());
82 return nullptr;
83 }
84 return serviceProxy_;
85 }
86
InvaildInstance()87 void ServiceClient::InvaildInstance()
88 {
89 HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__);
90 HILOGI("Invalid Instance");
91 unique_lock<mutex> lock(proxyMutex_);
92 serviceProxy_ = nullptr;
93 }
94
OnLoadSystemAbilitySuccess(int32_t systemAbilityId,const OHOS::sptr<IRemoteObject> & remoteObject)95 void ServiceClient::ServiceProxyLoadCallback::OnLoadSystemAbilitySuccess(int32_t systemAbilityId,
96 const OHOS::sptr<IRemoteObject> &remoteObject)
97 {
98 HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__);
99 HILOGI("Load backup sa success, systemAbilityId: %{public}d, remoteObject result:%{public}s", systemAbilityId,
100 (remoteObject != nullptr) ? "true" : "false");
101 if (systemAbilityId != FILEMANAGEMENT_BACKUP_SERVICE_SA_ID || remoteObject == nullptr) {
102 isLoadSuccess_.store(false);
103 proxyConVar_.notify_one();
104 return;
105 }
106 unique_lock<mutex> lock(proxyMutex_);
107 serviceProxy_ = iface_cast<IService>(remoteObject);
108 if (serviceProxy_ == nullptr) {
109 HILOGE("serviceProxy_ is nullptr");
110 return;
111 }
112 auto remoteObj = serviceProxy_->AsObject();
113 if (!remoteObj) {
114 HILOGE("Failed to get remote object");
115 serviceProxy_ = nullptr;
116 isLoadSuccess_.store(false);
117 proxyConVar_.notify_one();
118 return;
119 }
120 auto callback = [](const wptr<IRemoteObject> &obj) {
121 ServiceClient::InvaildInstance();
122 };
123 sptr<SvcDeathRecipient> deathRecipient = sptr(new SvcDeathRecipient(callback));
124 remoteObj->AddDeathRecipient(deathRecipient);
125 isLoadSuccess_.store(true);
126 proxyConVar_.notify_one();
127 }
128
OnLoadSystemAbilityFail(int32_t systemAbilityId)129 void ServiceClient::ServiceProxyLoadCallback::OnLoadSystemAbilityFail(int32_t systemAbilityId)
130 {
131 HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__);
132 HILOGE("Load backup sa failed, systemAbilityId:%{private}d", systemAbilityId);
133 unique_lock<mutex> lock(proxyMutex_);
134 serviceProxy_ = nullptr;
135 isLoadSuccess_.store(false);
136 AppRadar::Info info("", "", "\"reason\":\"Load backup sa fail\"");
137 AppRadar::GetInstance().RecordBackupFuncRes(info, "ServiceProxyLoadCallback::OnLoadSystemAbilityFail",
138 AppRadar::GetInstance().GetUserId(), BizStageBackup::BIZ_STAGE_BOOT_BACKUP_SA_FAIL,
139 static_cast<int32_t>(BError::Codes::SA_INVAL_ARG));
140 proxyConVar_.notify_one();
141 }
142 } // namespace OHOS::FileManagement::Backup
143