1 /*
2 * Copyright (c) 2023 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 "device_settings_proxy.h"
17
18 #include "edm_log.h"
19 #include "func_code.h"
20
21 namespace OHOS {
22 namespace EDM {
23 std::shared_ptr<DeviceSettingsProxy> DeviceSettingsProxy::instance_ = nullptr;
24 std::once_flag DeviceSettingsProxy::flag_;
25 const std::u16string DESCRIPTOR = u"ohos.edm.IEnterpriseDeviceMgr";
26
GetDeviceSettingsProxy()27 std::shared_ptr<DeviceSettingsProxy> DeviceSettingsProxy::GetDeviceSettingsProxy()
28 {
29 std::call_once(flag_, []() {
30 if (instance_ == nullptr) {
31 instance_ = std::make_shared<DeviceSettingsProxy>();
32 }
33 });
34 return instance_;
35 }
36
SetScreenOffTime(const AppExecFwk::ElementName & admin,int32_t value,const std::string & permissionTag)37 int32_t DeviceSettingsProxy::SetScreenOffTime(const AppExecFwk::ElementName &admin, int32_t value,
38 const std::string &permissionTag)
39 {
40 EDMLOGD("DeviceSettingsProxy::SetScreenOffTime");
41 MessageParcel data;
42 data.WriteInterfaceToken(DESCRIPTOR);
43 data.WriteInt32(WITHOUT_USERID);
44 data.WriteParcelable(&admin);
45 data.WriteString(permissionTag);
46 data.WriteInt32(value);
47 std::uint32_t funcCode = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, EdmInterfaceCode::SCREEN_OFF_TIME);
48 return EnterpriseDeviceMgrProxy::GetInstance()->HandleDevicePolicy(funcCode, data);
49 }
50
SetScreenOffTime(MessageParcel & data)51 int32_t DeviceSettingsProxy::SetScreenOffTime(MessageParcel &data)
52 {
53 EDMLOGD("DeviceSettingsProxy::SetScreenOffTime");
54 std::uint32_t funcCode = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, EdmInterfaceCode::SCREEN_OFF_TIME);
55 return EnterpriseDeviceMgrProxy::GetInstance()->HandleDevicePolicy(funcCode, data);
56 }
57
GetScreenOffTime(const AppExecFwk::ElementName & admin,int32_t & value,const std::string & permissionTag)58 int32_t DeviceSettingsProxy::GetScreenOffTime(const AppExecFwk::ElementName &admin, int32_t &value,
59 const std::string &permissionTag)
60 {
61 EDMLOGD("DeviceSettingsProxy::GetScreenOffTime");
62 auto proxy = EnterpriseDeviceMgrProxy::GetInstance();
63 MessageParcel data;
64 MessageParcel reply;
65 data.WriteInterfaceToken(DESCRIPTOR);
66 data.WriteInt32(WITHOUT_USERID);
67 data.WriteString(permissionTag);
68 data.WriteInt32(HAS_ADMIN);
69 data.WriteParcelable(&admin);
70 proxy->GetPolicy(EdmInterfaceCode::SCREEN_OFF_TIME, data, reply);
71 int32_t ret = ERR_INVALID_VALUE;
72 bool blRes = reply.ReadInt32(ret) && (ret == ERR_OK);
73 if (!blRes) {
74 EDMLOGE("EnterpriseDeviceMgrProxy:GetPolicy fail. %{public}d", ret);
75 return ret;
76 }
77 reply.ReadInt32(value);
78 return ERR_OK;
79 }
80
GetScreenOffTime(MessageParcel & data,int32_t & value)81 int32_t DeviceSettingsProxy::GetScreenOffTime(MessageParcel &data, int32_t &value)
82 {
83 EDMLOGD("DeviceSettingsProxy::GetScreenOffTime");
84 auto proxy = EnterpriseDeviceMgrProxy::GetInstance();
85 MessageParcel reply;
86 proxy->GetPolicy(EdmInterfaceCode::SCREEN_OFF_TIME, data, reply);
87 int32_t ret = ERR_INVALID_VALUE;
88 bool blRes = reply.ReadInt32(ret) && (ret == ERR_OK);
89 if (!blRes) {
90 EDMLOGE("EnterpriseDeviceMgrProxy:GetPolicy fail. %{public}d", ret);
91 return ret;
92 }
93 reply.ReadInt32(value);
94 return ERR_OK;
95 }
96
InstallUserCertificate(MessageParcel & data,std::string & result,std::string & innerCodeMsg)97 int32_t DeviceSettingsProxy::InstallUserCertificate(MessageParcel &data, std::string &result, std::string &innerCodeMsg)
98 {
99 EDMLOGD("DeviceSettingsProxy::InstallUserCertificate");
100 MessageParcel reply;
101 std::uint32_t funcCode =
102 POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, EdmInterfaceCode::INSTALL_CERTIFICATE);
103 ErrCode ret = EnterpriseDeviceMgrProxy::GetInstance()->HandleDevicePolicy(funcCode, data, reply);
104 EDMLOGI("DeviceSettingsProxy::InstallUserCertificate : %{public}d.", ret);
105 if (ret == ERR_OK) {
106 result = reply.ReadString();
107 } else if (ret == EdmReturnErrCode::MANAGED_CERTIFICATE_FAILED) {
108 innerCodeMsg = reply.ReadString();
109 }
110 return ret;
111 }
112
UninstallUserCertificate(MessageParcel & data,std::string & innerCodeMsg)113 int32_t DeviceSettingsProxy::UninstallUserCertificate(MessageParcel &data, std::string &innerCodeMsg)
114 {
115 EDMLOGD("DeviceSettingsProxy::UninstallUserCertificate");
116 MessageParcel reply;
117 std::uint32_t funcCode =
118 POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::REMOVE, EdmInterfaceCode::INSTALL_CERTIFICATE);
119 ErrCode ret = EnterpriseDeviceMgrProxy::GetInstance()->HandleDevicePolicy(funcCode, data, reply);
120 if (ret == EdmReturnErrCode::MANAGED_CERTIFICATE_FAILED) {
121 int32_t certRetCode = ERR_INVALID_VALUE;
122 reply.ReadInt32(certRetCode);
123 innerCodeMsg = std::to_string(certRetCode);
124 }
125 return ret;
126 }
127
SetPowerPolicy(const AppExecFwk::ElementName & admin,const PowerScene & powerScene,const PowerPolicy & powerPolicy)128 int32_t DeviceSettingsProxy::SetPowerPolicy(const AppExecFwk::ElementName &admin, const PowerScene &powerScene,
129 const PowerPolicy &powerPolicy)
130 {
131 EDMLOGD("DeviceSettingsProxy::SetPowerPolicy");
132 MessageParcel data;
133 MessageParcel reply;
134 std::uint32_t funcCode = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, EdmInterfaceCode::POWER_POLICY);
135 data.WriteInterfaceToken(DESCRIPTOR);
136 data.WriteInt32(WITHOUT_USERID);
137 data.WriteParcelable(&admin);
138 data.WriteString(WITHOUT_PERMISSION_TAG);
139 data.WriteUint32(static_cast<uint32_t>(powerScene));
140 if (!powerPolicy.Marshalling(data)) {
141 EDMLOGE("DeviceSettingsProxy::SetPowerPolicy Marshalling proxy fail.");
142 return EdmReturnErrCode::SYSTEM_ABNORMALLY;
143 }
144 return EnterpriseDeviceMgrProxy::GetInstance()->HandleDevicePolicy(funcCode, data);
145 }
146
SetPowerPolicy(MessageParcel & data)147 int32_t DeviceSettingsProxy::SetPowerPolicy(MessageParcel &data)
148 {
149 EDMLOGD("DeviceSettingsProxy::SetPowerPolicy");
150 MessageParcel reply;
151 std::uint32_t funcCode = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, EdmInterfaceCode::POWER_POLICY);
152 return EnterpriseDeviceMgrProxy::GetInstance()->HandleDevicePolicy(funcCode, data);
153 }
154
GetPowerPolicy(const AppExecFwk::ElementName & admin,const PowerScene & powerScene,PowerPolicy & powerPolicy)155 int32_t DeviceSettingsProxy::GetPowerPolicy(const AppExecFwk::ElementName &admin, const PowerScene &powerScene,
156 PowerPolicy &powerPolicy)
157 {
158 EDMLOGD("DeviceSettingsProxy::GetPowerPolicy");
159 MessageParcel data;
160 MessageParcel reply;
161 data.WriteInterfaceToken(DESCRIPTOR);
162 data.WriteInt32(WITHOUT_USERID);
163 data.WriteString(WITHOUT_PERMISSION_TAG);
164 data.WriteInt32(HAS_ADMIN);
165 data.WriteParcelable(&admin);
166 data.WriteUint32(static_cast<uint32_t>(powerScene));
167 EnterpriseDeviceMgrProxy::GetInstance()->GetPolicy(EdmInterfaceCode::POWER_POLICY, data, reply);
168 int32_t ret = ERR_INVALID_VALUE;
169 bool blRes = reply.ReadInt32(ret) && (ret == ERR_OK);
170 if (!blRes) {
171 EDMLOGE("DeviceSettingsProxy:getPowerPolicy fail. %{public}d", ret);
172 return ret;
173 }
174 if (!PowerPolicy::Unmarshalling(reply, powerPolicy)) {
175 EDMLOGE("DeviceSettingsProxy::getPowerPolicy Unmarshalling power policy fail.");
176 return EdmReturnErrCode::SYSTEM_ABNORMALLY;
177 }
178 return ERR_OK;
179 }
180
GetPowerPolicy(MessageParcel & data,PowerPolicy & powerPolicy)181 int32_t DeviceSettingsProxy::GetPowerPolicy(MessageParcel &data, PowerPolicy &powerPolicy)
182 {
183 EDMLOGD("DeviceSettingsProxy::GetPowerPolicy");
184 MessageParcel reply;
185 EnterpriseDeviceMgrProxy::GetInstance()->GetPolicy(EdmInterfaceCode::POWER_POLICY, data, reply);
186 int32_t ret = ERR_INVALID_VALUE;
187 bool blRes = reply.ReadInt32(ret) && (ret == ERR_OK);
188 if (!blRes) {
189 EDMLOGE("DeviceSettingsProxy:getPowerPolicy fail. %{public}d", ret);
190 return ret;
191 }
192 if (!PowerPolicy::Unmarshalling(reply, powerPolicy)) {
193 EDMLOGE("DeviceSettingsProxy::getPowerPolicy Unmarshalling power policy fail.");
194 return EdmReturnErrCode::SYSTEM_ABNORMALLY;
195 }
196 return ERR_OK;
197 }
198
SetWallPaper(MessageParcel & data,std::string & errMsg)199 int32_t DeviceSettingsProxy::SetWallPaper(MessageParcel &data, std::string &errMsg)
200 {
201 EDMLOGD("DeviceSettingsProxy::SetWallPaper");
202 MessageParcel reply;
203 std::uint32_t funcCode = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, EdmInterfaceCode::SET_WALL_PAPER);
204 int32_t ret = EnterpriseDeviceMgrProxy::GetInstance()->HandleDevicePolicy(funcCode, data, reply);
205 if (ret == EdmReturnErrCode::PARAMETER_VERIFICATION_FAILED) {
206 reply.ReadString(errMsg);
207 }
208 return ret;
209 }
210 } // namespace EDM
211 } // namespace OHOS