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::mutex SystemManagerProxy::mutexLock_;
26 const std::u16string DESCRIPTOR = u"ohos.edm.IEnterpriseDeviceMgr";
27
GetSystemManagerProxy()28 std::shared_ptr<SystemManagerProxy> SystemManagerProxy::GetSystemManagerProxy()
29 {
30 if (instance_ == nullptr) {
31 std::lock_guard<std::mutex> lock(mutexLock_);
32 if (instance_ == nullptr) {
33 std::shared_ptr<SystemManagerProxy> temp = std::make_shared<SystemManagerProxy>();
34 instance_ = temp;
35 }
36 }
37 return instance_;
38 }
39
SetNTPServer(const AppExecFwk::ElementName & admin,const std::string & value)40 int32_t SystemManagerProxy::SetNTPServer(const AppExecFwk::ElementName &admin, const std::string &value)
41 {
42 EDMLOGD("SystemManagerProxy::SetNTPServer");
43 MessageParcel data;
44 data.WriteInterfaceToken(DESCRIPTOR);
45 data.WriteInt32(WITHOUT_USERID);
46 data.WriteParcelable(&admin);
47 data.WriteString(WITHOUT_PERMISSION_TAG);
48 data.WriteString(value);
49 std::uint32_t funcCode = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, EdmInterfaceCode::NTP_SERVER);
50 return EnterpriseDeviceMgrProxy::GetInstance()->HandleDevicePolicy(funcCode, data);
51 }
52
GetNTPServer(const AppExecFwk::ElementName & admin,std::string & value)53 int32_t SystemManagerProxy::GetNTPServer(const AppExecFwk::ElementName &admin, std::string &value)
54 {
55 EDMLOGD("SystemManagerProxy::GetNTPServer");
56 auto proxy = EnterpriseDeviceMgrProxy::GetInstance();
57 MessageParcel data;
58 MessageParcel reply;
59 data.WriteInterfaceToken(DESCRIPTOR);
60 data.WriteInt32(WITHOUT_USERID);
61 data.WriteString(WITHOUT_PERMISSION_TAG);
62 data.WriteInt32(HAS_ADMIN);
63 data.WriteParcelable(&admin);
64 proxy->GetPolicy(EdmInterfaceCode::NTP_SERVER, data, reply);
65 int32_t ret = ERR_INVALID_VALUE;
66 bool blRes = reply.ReadInt32(ret) && (ret == ERR_OK);
67 if (!blRes) {
68 EDMLOGE("EnterpriseDeviceMgrProxy:GetPolicy fail. %{public}d", ret);
69 return ret;
70 }
71 reply.ReadString(value);
72 return ERR_OK;
73 }
74
SetOTAUpdatePolicy(const AppExecFwk::ElementName & admin,const UpdatePolicy & updatePolicy,std::string & errorMsg)75 int32_t SystemManagerProxy::SetOTAUpdatePolicy(const AppExecFwk::ElementName &admin, const UpdatePolicy &updatePolicy,
76 std::string &errorMsg)
77 {
78 EDMLOGD("SystemManagerProxy::SetOTAUpdatePolicy");
79 MessageParcel data;
80 MessageParcel reply;
81 data.WriteInterfaceToken(DESCRIPTOR);
82 data.WriteInt32(WITHOUT_USERID);
83 data.WriteParcelable(&admin);
84 data.WriteString(WITHOUT_PERMISSION_TAG);
85 UpdatePolicyUtils::WriteUpdatePolicy(data, updatePolicy);
86 std::uint32_t funcCode =
87 POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, EdmInterfaceCode::SET_OTA_UPDATE_POLICY);
88 ErrCode ret = EnterpriseDeviceMgrProxy::GetInstance()->HandleDevicePolicy(funcCode, data, reply);
89 if (ret == EdmReturnErrCode::PARAM_ERROR) {
90 errorMsg = reply.ReadString();
91 }
92 return ret;
93 }
94
GetOTAUpdatePolicy(const AppExecFwk::ElementName & admin,UpdatePolicy & updatePolicy)95 int32_t SystemManagerProxy::GetOTAUpdatePolicy(const AppExecFwk::ElementName &admin, UpdatePolicy &updatePolicy)
96 {
97 EDMLOGD("SystemManagerProxy::GetOTAUpdatePolicy");
98 MessageParcel data;
99 MessageParcel reply;
100 data.WriteInterfaceToken(DESCRIPTOR);
101 data.WriteInt32(WITHOUT_USERID);
102 data.WriteString(WITHOUT_PERMISSION_TAG);
103 data.WriteInt32(HAS_ADMIN);
104 data.WriteParcelable(&admin);
105 EnterpriseDeviceMgrProxy::GetInstance()->GetPolicy(EdmInterfaceCode::SET_OTA_UPDATE_POLICY, data, reply);
106 int32_t ret = ERR_INVALID_VALUE;
107 bool blRes = reply.ReadInt32(ret) && (ret == ERR_OK);
108 if (!blRes) {
109 EDMLOGE("EnterpriseDeviceMgrProxy:GetPolicy fail. %{public}d", ret);
110 return ret;
111 }
112 UpdatePolicyUtils::ReadUpdatePolicy(reply, updatePolicy);
113 return ERR_OK;
114 }
115
NotifyUpdatePackages(const AppExecFwk::ElementName & admin,UpgradePackageInfo & packageInfo,std::string & errMsg)116 int32_t SystemManagerProxy::NotifyUpdatePackages(const AppExecFwk::ElementName &admin,
117 UpgradePackageInfo &packageInfo, std::string &errMsg)
118 {
119 EDMLOGD("SystemManagerProxy::NotifyUpdatePackages");
120 MessageParcel data;
121 MessageParcel reply;
122 data.WriteInterfaceToken(DESCRIPTOR);
123 data.WriteInt32(WITHOUT_USERID);
124 data.WriteParcelable(&admin);
125 data.WriteString(WITHOUT_PERMISSION_TAG);
126 UpdatePolicyUtils::WriteUpgradePackageInfo(data, packageInfo);
127 std::uint32_t funcCode =
128 POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, EdmInterfaceCode::NOTIFY_UPGRADE_PACKAGES);
129 ErrCode ret = EnterpriseDeviceMgrProxy::GetInstance()->HandleDevicePolicy(funcCode, data, reply);
130 if (ret == EdmReturnErrCode::UPGRADE_PACKAGES_ANALYZE_FAILED) {
131 errMsg = reply.ReadString();
132 }
133 UpdatePolicyUtils::ClosePackagesFileHandle(packageInfo.packages);
134 return ret;
135 }
136
GetUpgradeResult(const AppExecFwk::ElementName & admin,const std::string & version,UpgradeResult & upgradeResult)137 int32_t SystemManagerProxy::GetUpgradeResult(const AppExecFwk::ElementName &admin, const std::string &version,
138 UpgradeResult &upgradeResult)
139 {
140 EDMLOGD("SystemManagerProxy::GetUpgradeResult");
141 MessageParcel data;
142 MessageParcel reply;
143 data.WriteInterfaceToken(DESCRIPTOR);
144 data.WriteInt32(WITHOUT_USERID);
145 data.WriteString(WITHOUT_PERMISSION_TAG);
146 data.WriteInt32(HAS_ADMIN);
147 data.WriteParcelable(&admin);
148 data.WriteString(version);
149 EnterpriseDeviceMgrProxy::GetInstance()->GetPolicy(EdmInterfaceCode::NOTIFY_UPGRADE_PACKAGES, data, reply);
150 int32_t ret = ERR_INVALID_VALUE;
151 bool blRes = reply.ReadInt32(ret) && (ret == ERR_OK);
152 if (!blRes) {
153 EDMLOGE("EnterpriseDeviceMgrProxy:GetPolicy fail. %{public}d", ret);
154 return ret;
155 }
156 UpdatePolicyUtils::ReadUpgradeResult(reply, upgradeResult);
157 return ERR_OK;
158 }
159 } // namespace EDM
160 } // namespace OHOS
161