1 /*
2 * Copyright (c) 2023-2024 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 "system_manager_proxy.h"
17
18 #include "edm_log.h"
19 #include "func_code.h"
20 #include "update_policy_utils.h"
21
22 namespace OHOS {
23 namespace EDM {
24 std::shared_ptr<SystemManagerProxy> SystemManagerProxy::instance_ = nullptr;
25 std::once_flag SystemManagerProxy::flag_;
26 const std::u16string DESCRIPTOR = u"ohos.edm.IEnterpriseDeviceMgr";
27
GetSystemManagerProxy()28 std::shared_ptr<SystemManagerProxy> SystemManagerProxy::GetSystemManagerProxy()
29 {
30 std::call_once(flag_, []() {
31 if (instance_ == nullptr) {
32 instance_ = std::make_shared<SystemManagerProxy>();
33 }
34 });
35 return instance_;
36 }
37
SetNTPServer(MessageParcel & data)38 int32_t SystemManagerProxy::SetNTPServer(MessageParcel &data)
39 {
40 EDMLOGD("SystemManagerProxy::SetNTPServer");
41 std::uint32_t funcCode = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, EdmInterfaceCode::NTP_SERVER);
42 return EnterpriseDeviceMgrProxy::GetInstance()->HandleDevicePolicy(funcCode, data);
43 }
44
GetNTPServer(MessageParcel & data,std::string & value)45 int32_t SystemManagerProxy::GetNTPServer(MessageParcel &data, std::string &value)
46 {
47 EDMLOGD("SystemManagerProxy::GetNTPServer");
48 auto proxy = EnterpriseDeviceMgrProxy::GetInstance();
49 MessageParcel reply;
50 proxy->GetPolicy(EdmInterfaceCode::NTP_SERVER, data, reply);
51 int32_t ret = ERR_INVALID_VALUE;
52 bool blRes = reply.ReadInt32(ret) && (ret == ERR_OK);
53 if (!blRes) {
54 EDMLOGE("EnterpriseDeviceMgrProxy:GetPolicy fail. %{public}d", ret);
55 return ret;
56 }
57 reply.ReadString(value);
58 return ERR_OK;
59 }
60
SetOTAUpdatePolicy(MessageParcel & data,std::string & errorMsg)61 int32_t SystemManagerProxy::SetOTAUpdatePolicy(MessageParcel &data, std::string &errorMsg)
62 {
63 EDMLOGD("SystemManagerProxy::SetOTAUpdatePolicy");
64 MessageParcel reply;
65 std::uint32_t funcCode =
66 POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, EdmInterfaceCode::SET_OTA_UPDATE_POLICY);
67 ErrCode ret = EnterpriseDeviceMgrProxy::GetInstance()->HandleDevicePolicy(funcCode, data, reply);
68 if (ret == EdmReturnErrCode::PARAM_ERROR) {
69 errorMsg = reply.ReadString();
70 }
71 return ret;
72 }
73
GetOTAUpdatePolicy(MessageParcel & data,UpdatePolicy & updatePolicy)74 int32_t SystemManagerProxy::GetOTAUpdatePolicy(MessageParcel &data, UpdatePolicy &updatePolicy)
75 {
76 EDMLOGD("SystemManagerProxy::GetOTAUpdatePolicy");
77 MessageParcel reply;
78 EnterpriseDeviceMgrProxy::GetInstance()->GetPolicy(EdmInterfaceCode::SET_OTA_UPDATE_POLICY, data, reply);
79 int32_t ret = ERR_INVALID_VALUE;
80 bool blRes = reply.ReadInt32(ret) && (ret == ERR_OK);
81 if (!blRes) {
82 EDMLOGE("EnterpriseDeviceMgrProxy:GetPolicy fail. %{public}d", ret);
83 return ret;
84 }
85 UpdatePolicyUtils::ReadUpdatePolicy(reply, updatePolicy);
86 return ERR_OK;
87 }
88
NotifyUpdatePackages(const AppExecFwk::ElementName & admin,UpgradePackageInfo & packageInfo,std::string & errMsg)89 int32_t SystemManagerProxy::NotifyUpdatePackages(const AppExecFwk::ElementName &admin,
90 UpgradePackageInfo &packageInfo, std::string &errMsg)
91 {
92 EDMLOGD("SystemManagerProxy::NotifyUpdatePackages");
93 MessageParcel data;
94 MessageParcel reply;
95 data.WriteInterfaceToken(DESCRIPTOR);
96 data.WriteInt32(WITHOUT_USERID);
97 data.WriteParcelable(&admin);
98 data.WriteString(WITHOUT_PERMISSION_TAG);
99 UpdatePolicyUtils::WriteUpgradePackageInfo(data, packageInfo);
100 std::uint32_t funcCode =
101 POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, EdmInterfaceCode::NOTIFY_UPGRADE_PACKAGES);
102 ErrCode ret = EnterpriseDeviceMgrProxy::GetInstance()->HandleDevicePolicy(funcCode, data, reply);
103 if (ret == EdmReturnErrCode::UPGRADE_PACKAGES_ANALYZE_FAILED) {
104 errMsg = reply.ReadString();
105 }
106 return ret;
107 }
108
GetUpgradeResult(const AppExecFwk::ElementName & admin,const std::string & version,UpgradeResult & upgradeResult)109 int32_t SystemManagerProxy::GetUpgradeResult(const AppExecFwk::ElementName &admin, const std::string &version,
110 UpgradeResult &upgradeResult)
111 {
112 EDMLOGD("SystemManagerProxy::GetUpgradeResult");
113 MessageParcel data;
114 MessageParcel reply;
115 data.WriteInterfaceToken(DESCRIPTOR);
116 data.WriteInt32(WITHOUT_USERID);
117 data.WriteString(WITHOUT_PERMISSION_TAG);
118 data.WriteInt32(HAS_ADMIN);
119 data.WriteParcelable(&admin);
120 data.WriteInt32(static_cast<int32_t>(GetUpdateInfo::UPDATE_RESULT));
121 data.WriteString(version);
122 EnterpriseDeviceMgrProxy::GetInstance()->GetPolicy(EdmInterfaceCode::NOTIFY_UPGRADE_PACKAGES, data, reply);
123 int32_t ret = ERR_INVALID_VALUE;
124 bool blRes = reply.ReadInt32(ret) && (ret == ERR_OK);
125 if (!blRes) {
126 EDMLOGE("EnterpriseDeviceMgrProxy:GetPolicy fail. %{public}d", ret);
127 return ret;
128 }
129 UpdatePolicyUtils::ReadUpgradeResult(reply, upgradeResult);
130 return ERR_OK;
131 }
132
GetUpdateAuthData(MessageParcel & data,std::string & authData)133 int32_t SystemManagerProxy::GetUpdateAuthData(MessageParcel &data, std::string &authData)
134 {
135 EDMLOGD("SystemManagerProxy::GetUpdateAuthData.");
136 MessageParcel reply;
137 data.WriteInt32(static_cast<int32_t>(GetUpdateInfo::UPDATE_AUTH_DATA));
138 EnterpriseDeviceMgrProxy::GetInstance()->GetPolicy(EdmInterfaceCode::NOTIFY_UPGRADE_PACKAGES, data, reply);
139 int32_t ret = ERR_INVALID_VALUE;
140 bool blRes = reply.ReadInt32(ret) && (ret == ERR_OK);
141 if (!blRes) {
142 EDMLOGW("EnterpriseDeviceMgrProxy:GetPolicy fail. %{public}d", ret);
143 return ret;
144 }
145 reply.ReadString(authData);
146 return ERR_OK;
147 }
148
SetAutoUnlockAfterReboot(MessageParcel & data)149 int32_t SystemManagerProxy::SetAutoUnlockAfterReboot(MessageParcel &data)
150 {
151 EDMLOGD("SystemManagerProxy::SetAutoUnlockAfterReboot");
152 std::uint32_t funcCode =
153 POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, EdmInterfaceCode::SET_AUTO_UNLOCK_AFTER_REBOOT);
154 return EnterpriseDeviceMgrProxy::GetInstance()->HandleDevicePolicy(funcCode, data);
155 }
156
GetAutoUnlockAfterReboot(MessageParcel & data,bool & authData)157 int32_t SystemManagerProxy::GetAutoUnlockAfterReboot(MessageParcel &data, bool &authData)
158 {
159 EDMLOGD("SystemManagerProxy::GetAutoUnlockAfterReboot");
160 auto proxy = EnterpriseDeviceMgrProxy::GetInstance();
161 MessageParcel reply;
162 proxy->GetPolicy(EdmInterfaceCode::SET_AUTO_UNLOCK_AFTER_REBOOT, data, reply);
163 int32_t ret = ERR_INVALID_VALUE;
164 bool blRes = reply.ReadInt32(ret) && (ret == ERR_OK);
165 if (!blRes) {
166 EDMLOGE("EnterpriseDeviceMgrProxy:GetPolicy fail. %{public}d", ret);
167 return ret;
168 }
169 reply.ReadBool(authData);
170 return ERR_OK;
171 }
172
SetInstallLocalEnterpriseAppEnabled(MessageParcel & data)173 int32_t SystemManagerProxy::SetInstallLocalEnterpriseAppEnabled(MessageParcel &data)
174 {
175 EDMLOGD("SystemManagerProxy::SetInstallLocalEnterpriseAppEnabled");
176 std::uint32_t funcCode =
177 POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET,
178 EdmInterfaceCode::SET_INSTALL_LOCAL_ENTERPRISE_APP_ENABLED);
179 return EnterpriseDeviceMgrProxy::GetInstance()->HandleDevicePolicy(funcCode, data);
180 }
181
GetInstallLocalEnterpriseAppEnabled(MessageParcel & data,bool & isAllowedInstall)182 int32_t SystemManagerProxy::GetInstallLocalEnterpriseAppEnabled(MessageParcel &data, bool &isAllowedInstall)
183 {
184 EDMLOGD("SystemManagerProxy::GetInstallLocalEnterpriseAppEnabled");
185 auto proxy = EnterpriseDeviceMgrProxy::GetInstance();
186 MessageParcel reply;
187 proxy->GetPolicy(EdmInterfaceCode::SET_INSTALL_LOCAL_ENTERPRISE_APP_ENABLED, data, reply);
188 int32_t ret = ERR_INVALID_VALUE;
189 bool blRes = reply.ReadInt32(ret) && (ret == ERR_OK);
190 if (!blRes) {
191 EDMLOGE("EnterpriseDeviceMgrProxy:GetPolicy fail. %{public}d", ret);
192 return ret;
193 }
194 reply.ReadBool(isAllowedInstall);
195 return ERR_OK;
196 }
197
198
AddOrRemoveDisallowedNearlinkProtocols(MessageParcel & data,FuncOperateType operateType)199 int32_t SystemManagerProxy::AddOrRemoveDisallowedNearlinkProtocols(MessageParcel &data, FuncOperateType operateType)
200 {
201 EDMLOGD("SystemManagerProxy::AddOrRemoveDisallowedNearlinkProtocols");
202 std::uint32_t funcCode =
203 POLICY_FUNC_CODE((std::uint32_t)operateType, EdmInterfaceCode::DISALLOWED_NEARLINK_PROTOCOLS);
204 return EnterpriseDeviceMgrProxy::GetInstance()->HandleDevicePolicy(funcCode, data);
205 }
206
GetDisallowedNearlinkProtocols(MessageParcel & data,std::vector<int32_t> & protocols)207 int32_t SystemManagerProxy::GetDisallowedNearlinkProtocols(MessageParcel &data, std::vector<int32_t> &protocols)
208 {
209 EDMLOGD("SystemManagerProxy::GetDisallowedNearlinkProtocols");
210 MessageParcel reply;
211 EnterpriseDeviceMgrProxy::GetInstance()->GetPolicy(EdmInterfaceCode::DISALLOWED_NEARLINK_PROTOCOLS, data, reply);
212 int32_t ret = ERR_INVALID_VALUE;
213 bool blRes = reply.ReadInt32(ret) && (ret == ERR_OK);
214 if (!blRes) {
215 EDMLOGE("SystemManagerProxy:GetDisallowedNearlinkProtocols fail. %{public}d", ret);
216 return ret;
217 }
218 if (!reply.ReadInt32Vector(&protocols)) {
219 return EdmReturnErrCode::SYSTEM_ABNORMALLY;
220 }
221 return ERR_OK;
222 }
223
224 } // namespace EDM
225 } // namespace OHOS
226