From a8b80503b566fba6f2e26d873ff62bef0c5ec47a Mon Sep 17 00:00:00 2001 From: fangyun Date: Sun, 9 Oct 2022 19:52:50 +0800 Subject: [PATCH] add event subscribe interface Signed-off-by: fangyun --- common/native/include/edm_errors.h | 15 ++ common/native/include/managed_event.h | 28 ++ .../include/enterprise_admin_extension.h | 10 - .../extension/include/enterprise_admin_stub.h | 4 + .../include/enterprise_admin_stub_impl.h | 10 +- .../extension/include/ienterprise_admin.h | 16 +- .../include/js_enterprise_admin_extension.h | 8 +- .../src/enterprise_admin_extension.cpp | 4 - .../extension/src/enterprise_admin_stub.cpp | 16 ++ .../src/enterprise_admin_stub_impl.cpp | 20 ++ .../src/js_enterprise_admin_extension.cpp | 16 ++ .../include/device_settings_manager.h | 2 +- .../include/enterprise_device_mgr_proxy.h | 3 + .../include/ienterprise_device_mgr.h | 4 + .../inner_api/src/device_settings_manager.cpp | 5 +- .../src/enterprise_device_mgr_proxy.cpp | 67 ++++- .../enterprise_admin_extension_ability.js | 6 + .../include/enterprise_device_manager_addon.h | 31 ++- .../src/enterprise_device_manager_addon.cpp | 238 ++++++++++++++--- services/edm/include/admin.h | 2 + services/edm/include/admin_manager.h | 3 + .../include/enterprise_admin_conn_manager.h | 3 +- .../edm/include/enterprise_admin_connection.h | 19 +- services/edm/include/enterprise_admin_proxy.h | 12 +- .../include/enterprise_device_mgr_ability.h | 13 +- .../edm/include/enterprise_device_mgr_stub.h | 3 + services/edm/src/admin_manager.cpp | 64 ++++- .../edm/src/enterprise_admin_conn_manager.cpp | 10 +- .../edm/src/enterprise_admin_connection.cpp | 24 ++ services/edm/src/enterprise_admin_proxy.cpp | 39 ++- .../edm/src/enterprise_device_mgr_ability.cpp | 244 +++++++++++++----- .../edm/src/enterprise_device_mgr_stub.cpp | 86 +++--- test/unittest/src/admin_manager_test.cpp | 44 ++++ 33 files changed, 858 insertions(+), 211 deletions(-) create mode 100644 common/native/include/managed_event.h diff --git a/common/native/include/edm_errors.h b/common/native/include/edm_errors.h index 77720e852..088e6e748 100644 --- a/common/native/include/edm_errors.h +++ b/common/native/include/edm_errors.h @@ -28,6 +28,21 @@ enum { // Reserved 0x04 ~ 0x0f for new modules, Event related modules start from 0x10 }; +namespace EdmReturnErrCode { + constexpr uint32_t PARAM_ERROR = 401; + constexpr uint32_t PERMISSION_DENIED = 201; + constexpr uint32_t INTERFACE_UNSUPPORTED = 801; + + constexpr uint32_t ADMIN_INACTIVE = 9200001; + constexpr uint32_t ADMIN_EDM_PERMISSION_DENIED = 9200002; + constexpr uint32_t COMPONENT_INVALID = 9200003; + constexpr uint32_t ENABLE_ADMIN_FAILED = 9200004; + constexpr uint32_t DISABLE_ADMIN_FAILED = 9200005; + constexpr uint32_t UID_INVALID = 9200006; + constexpr uint32_t SYSTEM_ABNORMALLY = 9200007; + constexpr uint32_t MANAGED_EVENTS_INVALID = 9200008; +}; + // Error code for SERVICE: 0x2000000,value:33554432 constexpr ErrCode EDM_SERVICE_ERR_OFFSET = ErrCodeOffset(SUBSYS_CUSTOMIZATION, EDM_MODULE_EDMSERVICE); enum { diff --git a/common/native/include/managed_event.h b/common/native/include/managed_event.h new file mode 100644 index 000000000..f33336041 --- /dev/null +++ b/common/native/include/managed_event.h @@ -0,0 +1,28 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef COMMON_NATIVE_INCLUDE_MANAGED_EVENT_H +#define COMMON_NATIVE_INCLUDE_MANAGED_EVENT_H + +namespace OHOS { +namespace EDM { +enum ManagedEvent { + BUNDLE_ADDED = 0, + BUNDLE_REMOVED, +}; +} // namespace EDM +} // namespace OHOS + +#endif // COMMON_NATIVE_INCLUDE_MANAGED_EVENT_H diff --git a/framework/extension/include/enterprise_admin_extension.h b/framework/extension/include/enterprise_admin_extension.h index 452d63052..87f461441 100644 --- a/framework/extension/include/enterprise_admin_extension.h +++ b/framework/extension/include/enterprise_admin_extension.h @@ -56,16 +56,6 @@ public: const sptr& token) override; static EnterpriseAdminExtension* Create(const std::unique_ptr& runtime); - - /** - * @brief The OnAdminEnabled callback. - */ - virtual void OnAdminEnabled(); - - /** - * @brief The OnAdminDisabled callback. - */ - virtual void OnAdminDisabled(); }; } // namespace EDM } // namespace OHOS diff --git a/framework/extension/include/enterprise_admin_stub.h b/framework/extension/include/enterprise_admin_stub.h index d4613a17c..0e10aad82 100644 --- a/framework/extension/include/enterprise_admin_stub.h +++ b/framework/extension/include/enterprise_admin_stub.h @@ -46,6 +46,10 @@ private: void OnAdminDisabledInner(MessageParcel& data, MessageParcel& reply); + void OnBundleAddedInner(MessageParcel& data, MessageParcel& reply); + + void OnBundleRemovedInner(MessageParcel& data, MessageParcel& reply); + using EnterpriseAdminFunc = void (EnterpriseAdminStub::*)(MessageParcel& data, MessageParcel& reply); std::map memberFuncMap_; diff --git a/framework/extension/include/enterprise_admin_stub_impl.h b/framework/extension/include/enterprise_admin_stub_impl.h index 93f0067d2..791fc573f 100644 --- a/framework/extension/include/enterprise_admin_stub_impl.h +++ b/framework/extension/include/enterprise_admin_stub_impl.h @@ -30,15 +30,13 @@ public: virtual ~EnterpriseAdminStubImpl() {} - /** - * @brief The OnAdminEnabled callback. - */ void OnAdminEnabled() override; - /** - * @brief The OnAdminDisabled callback. - */ void OnAdminDisabled() override; + + void OnBundleAdded(const std::string &bundleName) override; + + void OnBundleRemoved(const std::string &bundleName) override; private: std::weak_ptr extension_; }; diff --git a/framework/extension/include/ienterprise_admin.h b/framework/extension/include/ienterprise_admin.h index 641edae4a..27e5d4ef2 100644 --- a/framework/extension/include/ienterprise_admin.h +++ b/framework/extension/include/ienterprise_admin.h @@ -34,9 +34,23 @@ public: */ virtual void OnAdminDisabled() = 0; + /** + * @brief Called when a new application package has been installed on the device. + * @param bundleName Indicates the name of the bundle whose state has been installed. + */ + virtual void OnBundleAdded(const std::string &bundleName) = 0; + + /** + * @brief Called when a new application package has been Removed on the device. + * @param bundleName Indicates the name of the bundle whose state has been Removed. + */ + virtual void OnBundleRemoved(const std::string &bundleName) = 0; + enum { COMMAND_ON_ADMIN_ENABLED = 1, - COMMAND_ON_ADMIN_DISABLED = 2 + COMMAND_ON_ADMIN_DISABLED = 2, + COMMAND_ON_BUNDLE_ADDED = 3, + COMMAND_ON_BUNDLE_REMOVED = 4 }; }; } // namespace EDM diff --git a/framework/extension/include/js_enterprise_admin_extension.h b/framework/extension/include/js_enterprise_admin_extension.h index 26dd59504..965fb5aa9 100644 --- a/framework/extension/include/js_enterprise_admin_extension.h +++ b/framework/extension/include/js_enterprise_admin_extension.h @@ -53,9 +53,13 @@ public: void OnStop() override; - void OnAdminEnabled() override; + void OnAdminEnabled(); - void OnAdminDisabled() override; + void OnAdminDisabled(); + + void OnBundleAdded(const std::string &bundleName); + + void OnBundleRemoved(const std::string &bundleName); private: NativeValue* CallObjectMethod(const char* name, NativeValue** argv, size_t argc); diff --git a/framework/extension/src/enterprise_admin_extension.cpp b/framework/extension/src/enterprise_admin_extension.cpp index e394dcb04..3fb160887 100644 --- a/framework/extension/src/enterprise_admin_extension.cpp +++ b/framework/extension/src/enterprise_admin_extension.cpp @@ -61,9 +61,5 @@ std::shared_ptr EnterpriseAdminExtension::Creat } return context; } - -void EnterpriseAdminExtension::OnAdminEnabled() {} - -void EnterpriseAdminExtension::OnAdminDisabled() {} } // namespace EDM } // namespace OHOS \ No newline at end of file diff --git a/framework/extension/src/enterprise_admin_stub.cpp b/framework/extension/src/enterprise_admin_stub.cpp index 12068d0ee..57dc650a5 100644 --- a/framework/extension/src/enterprise_admin_stub.cpp +++ b/framework/extension/src/enterprise_admin_stub.cpp @@ -33,6 +33,8 @@ void EnterpriseAdminStub::AddCallFuncMap() { memberFuncMap_[COMMAND_ON_ADMIN_ENABLED] = &EnterpriseAdminStub::OnAdminEnabledInner; memberFuncMap_[COMMAND_ON_ADMIN_DISABLED] = &EnterpriseAdminStub::OnAdminDisabledInner; + memberFuncMap_[COMMAND_ON_BUNDLE_ADDED] = &EnterpriseAdminStub::OnBundleAddedInner; + memberFuncMap_[COMMAND_ON_BUNDLE_REMOVED] = &EnterpriseAdminStub::OnBundleRemovedInner; } void EnterpriseAdminStub::OnAdminEnabledInner(MessageParcel& data, MessageParcel& reply) @@ -47,6 +49,20 @@ void EnterpriseAdminStub::OnAdminDisabledInner(MessageParcel& data, MessageParce OnAdminDisabled(); } +void EnterpriseAdminStub::OnBundleAddedInner(MessageParcel& data, MessageParcel& reply) +{ + EDMLOGI("EnterpriseAdminStub::OnBundleAdded"); + std::string bundleName = data.ReadString(); + OnBundleAdded(bundleName); +} + +void EnterpriseAdminStub::OnBundleRemovedInner(MessageParcel& data, MessageParcel& reply) +{ + EDMLOGI("EnterpriseAdminStub::OnBundleRemoved"); + std::string bundleName = data.ReadString(); + OnBundleRemoved(bundleName); +} + int32_t EnterpriseAdminStub::OnRemoteRequest(uint32_t code, MessageParcel& data, MessageParcel& reply, MessageOption &option) { diff --git a/framework/extension/src/enterprise_admin_stub_impl.cpp b/framework/extension/src/enterprise_admin_stub_impl.cpp index 5f1bf37c1..57219dbe5 100644 --- a/framework/extension/src/enterprise_admin_stub_impl.cpp +++ b/framework/extension/src/enterprise_admin_stub_impl.cpp @@ -37,5 +37,25 @@ void EnterpriseAdminStubImpl::OnAdminDisabled() EDMLOGD("EnterpriseAdminStubImpl %{public}s end successfully.", __func__); } } + +void EnterpriseAdminStubImpl::OnBundleAdded(const std::string &bundleName) +{ + EDMLOGI("EnterpriseAdminStubImpl %{public}s begin.", __func__); + auto extension = extension_.lock(); + if (extension != nullptr) { + extension->OnBundleAdded(bundleName); + EDMLOGD("EnterpriseAdminStubImpl %{public}s end successfully.", __func__); + } +} + +void EnterpriseAdminStubImpl::OnBundleRemoved(const std::string &bundleName) +{ + EDMLOGI("EnterpriseAdminStubImpl %{public}s begin.", __func__); + auto extension = extension_.lock(); + if (extension != nullptr) { + extension->OnBundleRemoved(bundleName); + EDMLOGD("EnterpriseAdminStubImpl %{public}s end successfully.", __func__); + } +} } // namespace EDM } // namespace OHOS \ No newline at end of file diff --git a/framework/extension/src/js_enterprise_admin_extension.cpp b/framework/extension/src/js_enterprise_admin_extension.cpp index 1566a713f..a0feadb34 100644 --- a/framework/extension/src/js_enterprise_admin_extension.cpp +++ b/framework/extension/src/js_enterprise_admin_extension.cpp @@ -146,6 +146,22 @@ void JsEnterpriseAdminExtension::OnAdminDisabled() CallObjectMethod("onAdminDisabled", nullptr, JS_NAPI_ARGC_ZERO); } +void JsEnterpriseAdminExtension::OnBundleAdded(const std::string &bundleName) +{ + HILOG_INFO("JsEnterpriseAdminExtension::OnBundleAdded"); + auto& engine = jsRuntime_.GetNativeEngine(); + NativeValue* argv[] = { AbilityRuntime::CreateJsValue(engine, bundleName) }; + CallObjectMethod("onBundleAdded", argv, JS_NAPI_ARGC_ONE); +} + +void JsEnterpriseAdminExtension::OnBundleRemoved(const std::string &bundleName) +{ + HILOG_INFO("JsEnterpriseAdminExtension::OnBundleRemoved"); + auto& engine = jsRuntime_.GetNativeEngine(); + NativeValue* argv[] = { AbilityRuntime::CreateJsValue(engine, bundleName) }; + CallObjectMethod("onBundleRemoved", argv, JS_NAPI_ARGC_ONE); +} + NativeValue* JsEnterpriseAdminExtension::CallObjectMethod(const char* name, NativeValue** argv, size_t argc) { HILOG_INFO("JsEnterpriseAdminExtension::CallObjectMethod(%{public}s), begin", name); diff --git a/interfaces/inner_api/include/device_settings_manager.h b/interfaces/inner_api/include/device_settings_manager.h index c2dbdd583..3dc7efeb5 100644 --- a/interfaces/inner_api/include/device_settings_manager.h +++ b/interfaces/inner_api/include/device_settings_manager.h @@ -24,7 +24,7 @@ public: DeviceSettingsManager(); ~DeviceSettingsManager(); static std::shared_ptr GetDeviceSettingsManager(); - bool SetDateTime(AppExecFwk::ElementName &admin, int64_t time); + void SetDateTime(AppExecFwk::ElementName &admin, int64_t time); private: static std::shared_ptr proxy_; diff --git a/interfaces/inner_api/include/enterprise_device_mgr_proxy.h b/interfaces/inner_api/include/enterprise_device_mgr_proxy.h index 888c25764..5f65b737c 100644 --- a/interfaces/inner_api/include/enterprise_device_mgr_proxy.h +++ b/interfaces/inner_api/include/enterprise_device_mgr_proxy.h @@ -38,6 +38,8 @@ public: ErrCode GetEnabledAdmin(AdminType type, std::vector &enabledAdminList); ErrCode GetEnterpriseInfo(AppExecFwk::ElementName &admin, EntInfo &entInfo); ErrCode SetEnterpriseInfo(AppExecFwk::ElementName &admin, EntInfo &entInfo); + ErrCode SubscribeManagedEvent(AppExecFwk::ElementName &admin, std::vector &events); + ErrCode UnsubscribeManagedEvent(AppExecFwk::ElementName &admin, std::vector &events); bool IsSuperAdmin(std::string bundleName); bool IsAdminEnabled(AppExecFwk::ElementName &admin, int32_t userId); bool HandleDevicePolicy(int32_t policyCode, MessageParcel &data); @@ -55,6 +57,7 @@ private: static std::mutex mutexLock_; void GetEnabledAdmins(std::uint32_t type, std::vector &enabledAdminList); + ErrCode SubscribeManagedEvent(AppExecFwk::ElementName &admin, std::vector &events, bool subscribe); sptr GetRemoteObject(); bool GetPolicy(int policyCode, MessageParcel &reply); }; diff --git a/interfaces/inner_api/include/ienterprise_device_mgr.h b/interfaces/inner_api/include/ienterprise_device_mgr.h index 024df81ee..cde2ac373 100644 --- a/interfaces/inner_api/include/ienterprise_device_mgr.h +++ b/interfaces/inner_api/include/ienterprise_device_mgr.h @@ -39,6 +39,8 @@ public: virtual ErrCode GetEnabledAdmin(AdminType type, std::vector &enabledAdminList) = 0; virtual ErrCode GetEnterpriseInfo(AppExecFwk::ElementName &admin, MessageParcel &reply) = 0; virtual ErrCode SetEnterpriseInfo(AppExecFwk::ElementName &admin, EntInfo &entInfo) = 0; + virtual ErrCode SubscribeManagedEvent(AppExecFwk::ElementName &admin, std::vector &events) = 0; + virtual ErrCode UnsubscribeManagedEvent(AppExecFwk::ElementName &admin, std::vector &events) = 0; virtual bool IsSuperAdmin(std::string &bundleName) = 0; virtual bool IsAdminEnabled(AppExecFwk::ElementName &admin, int32_t userId) = 0; enum { @@ -51,6 +53,8 @@ public: SET_ENT_INFO = 7, IS_SUPER_ADMIN = 8, IS_ADMIN_ENABLED = 9, + SUBSCRIBE_MANAGED_EVENT = 10, + UNSUBSCRIBE_MANAGED_EVENT = 11, }; }; } // namespace EDM diff --git a/interfaces/inner_api/src/device_settings_manager.cpp b/interfaces/inner_api/src/device_settings_manager.cpp index ab0d19495..8d44c97d7 100644 --- a/interfaces/inner_api/src/device_settings_manager.cpp +++ b/interfaces/inner_api/src/device_settings_manager.cpp @@ -40,13 +40,13 @@ std::shared_ptr DeviceSettingsManager::GetDeviceSettingsM return instance_; } -bool DeviceSettingsManager::SetDateTime(AppExecFwk::ElementName &admin, int64_t time) +void DeviceSettingsManager::SetDateTime(AppExecFwk::ElementName &admin, int64_t time) { EDMLOGD("DeviceSettingsManager::SetDateTime"); auto proxy = EnterpriseDeviceMgrProxy::GetInstance(); if (proxy == nullptr) { EDMLOGE("can not get EnterpriseDeviceMgrProxy"); - return false; + return; } MessageParcel data; std::uint32_t funcCode = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, SET_DATETIME); @@ -54,7 +54,6 @@ bool DeviceSettingsManager::SetDateTime(AppExecFwk::ElementName &admin, int64_t data.WriteParcelable(&admin); data.WriteInt64(time); proxy->HandleDevicePolicy(funcCode, data); - return true; } } // namespace EDM } // namespace OHOS diff --git a/interfaces/inner_api/src/enterprise_device_mgr_proxy.cpp b/interfaces/inner_api/src/enterprise_device_mgr_proxy.cpp index 8b8b83612..928d75fcb 100644 --- a/interfaces/inner_api/src/enterprise_device_mgr_proxy.cpp +++ b/interfaces/inner_api/src/enterprise_device_mgr_proxy.cpp @@ -61,7 +61,7 @@ ErrCode EnterpriseDeviceMgrProxy::EnableAdmin(AppExecFwk::ElementName &admin, En EDMLOGD("EnterpriseDeviceMgrProxy::EnableAdmin"); sptr remote = GetRemoteObject(); if (!remote) { - return ERR_EDM_SERVICE_NOT_READY; + return EdmReturnErrCode::SYSTEM_ABNORMALLY; } MessageParcel data; MessageParcel reply; @@ -74,7 +74,7 @@ ErrCode EnterpriseDeviceMgrProxy::EnableAdmin(AppExecFwk::ElementName &admin, En ErrCode res = remote->SendRequest(IEnterpriseDeviceMgr::ADD_DEVICE_ADMIN, data, reply, option); if (FAILED(res)) { EDMLOGE("EnterpriseDeviceMgrProxy:EnableAdmin send request fail. %{public}d", res); - return ERR_EDM_SERVICE_NOT_READY; + return EdmReturnErrCode::SYSTEM_ABNORMALLY; } int32_t resCode; if (!reply.ReadInt32(resCode) || FAILED(resCode)) { @@ -89,7 +89,7 @@ ErrCode EnterpriseDeviceMgrProxy::DisableAdmin(AppExecFwk::ElementName &admin, i EDMLOGD("EnterpriseDeviceMgrProxy::DisableAdmin"); sptr remote = GetRemoteObject(); if (!remote) { - return ERR_EDM_SERVICE_NOT_READY; + return EdmReturnErrCode::SYSTEM_ABNORMALLY; } MessageParcel data; MessageParcel reply; @@ -100,7 +100,7 @@ ErrCode EnterpriseDeviceMgrProxy::DisableAdmin(AppExecFwk::ElementName &admin, i ErrCode res = remote->SendRequest(IEnterpriseDeviceMgr::REMOVE_DEVICE_ADMIN, data, reply, option); if (FAILED(res)) { EDMLOGE("EnterpriseDeviceMgrProxy:DisableAdmin send request fail. %{public}d", res); - return ERR_EDM_SERVICE_NOT_READY; + return EdmReturnErrCode::SYSTEM_ABNORMALLY; } int32_t resCode; if (!reply.ReadInt32(resCode) || FAILED(resCode)) { @@ -115,7 +115,7 @@ ErrCode EnterpriseDeviceMgrProxy::DisableSuperAdmin(std::string bundleName) EDMLOGD("EnterpriseDeviceMgrProxy::DisableSuperAdmin"); sptr remote = GetRemoteObject(); if (!remote) { - return ERR_EDM_SERVICE_NOT_READY; + return EdmReturnErrCode::SYSTEM_ABNORMALLY; } MessageParcel data; MessageParcel reply; @@ -125,7 +125,7 @@ ErrCode EnterpriseDeviceMgrProxy::DisableSuperAdmin(std::string bundleName) ErrCode res = remote->SendRequest(IEnterpriseDeviceMgr::REMOVE_SUPER_ADMIN, data, reply, option); if (FAILED(res)) { EDMLOGE("EnterpriseDeviceMgrProxy:DisableSuperAdmin send request fail. %{public}d", res); - return ERR_EDM_SERVICE_NOT_READY; + return EdmReturnErrCode::SYSTEM_ABNORMALLY; } int32_t resCode; if (!reply.ReadInt32(resCode) || FAILED(resCode)) { @@ -140,7 +140,7 @@ ErrCode EnterpriseDeviceMgrProxy::GetEnabledAdmin(AdminType type, std::vector remote = GetRemoteObject(); if (!remote) { - return ERR_EDM_SERVICE_NOT_READY; + return EdmReturnErrCode::SYSTEM_ABNORMALLY; } MessageParcel data; MessageParcel reply; @@ -150,7 +150,7 @@ ErrCode EnterpriseDeviceMgrProxy::GetEnabledAdmin(AdminType type, std::vectorSendRequest(IEnterpriseDeviceMgr::GET_ENABLED_ADMIN, data, reply, option); if (FAILED(res)) { EDMLOGE("EnterpriseDeviceMgrProxy:GetEnabledAdmin send request fail. %{public}d", res); - return ERR_EDM_SERVICE_NOT_READY; + return EdmReturnErrCode::SYSTEM_ABNORMALLY; } int32_t resCode; if (!reply.ReadInt32(resCode) || FAILED(resCode)) { @@ -166,7 +166,7 @@ ErrCode EnterpriseDeviceMgrProxy::GetEnterpriseInfo(AppExecFwk::ElementName &adm EDMLOGD("EnterpriseDeviceMgrProxy::GetEnterpriseInfo"); sptr remote = GetRemoteObject(); if (!remote) { - return ERR_EDM_SERVICE_NOT_READY; + return EdmReturnErrCode::SYSTEM_ABNORMALLY; } MessageParcel data; MessageParcel reply; @@ -176,7 +176,7 @@ ErrCode EnterpriseDeviceMgrProxy::GetEnterpriseInfo(AppExecFwk::ElementName &adm ErrCode res = remote->SendRequest(IEnterpriseDeviceMgr::GET_ENT_INFO, data, reply, option); if (FAILED(res)) { EDMLOGE("EnterpriseDeviceMgrProxy:GetEnterpriseInfo send request fail. %{public}d", res); - return ERR_EDM_SERVICE_NOT_READY; + return EdmReturnErrCode::SYSTEM_ABNORMALLY; } int32_t resCode; if (!reply.ReadInt32(resCode) || FAILED(resCode)) { @@ -193,7 +193,7 @@ ErrCode EnterpriseDeviceMgrProxy::SetEnterpriseInfo(AppExecFwk::ElementName &adm EDMLOGD("EnterpriseDeviceMgrProxy::SetEnterpriseInfo"); sptr remote = GetRemoteObject(); if (!remote) { - return ERR_EDM_SERVICE_NOT_READY; + return EdmReturnErrCode::SYSTEM_ABNORMALLY; } MessageParcel data; MessageParcel reply; @@ -204,7 +204,7 @@ ErrCode EnterpriseDeviceMgrProxy::SetEnterpriseInfo(AppExecFwk::ElementName &adm ErrCode res = remote->SendRequest(IEnterpriseDeviceMgr::SET_ENT_INFO, data, reply, option); if (FAILED(res)) { EDMLOGE("EnterpriseDeviceMgrProxy:SetEnterpriseInfo send request fail. %{public}d", res); - return ERR_EDM_SERVICE_NOT_READY; + return EdmReturnErrCode::SYSTEM_ABNORMALLY; } int32_t resCode; if (!reply.ReadInt32(resCode) || FAILED(resCode)) { @@ -214,12 +214,51 @@ ErrCode EnterpriseDeviceMgrProxy::SetEnterpriseInfo(AppExecFwk::ElementName &adm return ERR_OK; } +ErrCode EnterpriseDeviceMgrProxy::SubscribeManagedEvent(AppExecFwk::ElementName &admin, std::vector &events) +{ + EDMLOGD("EnterpriseDeviceMgrProxy::SubscribeManagedEvent"); + return SubscribeManagedEvent(admin, events, true); +} + +ErrCode EnterpriseDeviceMgrProxy::UnsubscribeManagedEvent(AppExecFwk::ElementName &admin, std::vector &events) +{ + EDMLOGD("EnterpriseDeviceMgrProxy::UnsubscribeManagedEvent"); + return SubscribeManagedEvent(admin, events, false); +} + +ErrCode EnterpriseDeviceMgrProxy::SubscribeManagedEvent(AppExecFwk::ElementName &admin, + std::vector &events, bool subscribe) +{ + sptr remote = GetRemoteObject(); + if (!remote) { + return EdmReturnErrCode::SYSTEM_ABNORMALLY; + } + MessageParcel data; + MessageParcel reply; + MessageOption option; + data.WriteInterfaceToken(DESCRIPTOR); + data.WriteParcelable(&admin); + data.WriteUInt32Vector(events); + uint32_t policyCode = IEnterpriseDeviceMgr::SUBSCRIBE_MANAGED_EVENT; + if (!subscribe) { + policyCode = IEnterpriseDeviceMgr::UNSUBSCRIBE_MANAGED_EVENT; + } + ErrCode res = remote->SendRequest(policyCode, data, reply, option); + if (FAILED(res)) { + EDMLOGE("EnterpriseDeviceMgrProxy:SubscribeManagedEvent send request fail. %{public}d", res); + return EdmReturnErrCode::SYSTEM_ABNORMALLY; + } + int32_t retCode; + reply.ReadInt32(retCode) + return retCode; +} + bool EnterpriseDeviceMgrProxy::IsSuperAdmin(std::string bundleName) { EDMLOGD("EnterpriseDeviceMgrProxy::IsSuperAdmin"); sptr remote = GetRemoteObject(); if (!remote) { - return ERR_EDM_SERVICE_NOT_READY; + return EdmReturnErrCode::SYSTEM_ABNORMALLY; } MessageParcel data; MessageParcel reply; @@ -242,7 +281,7 @@ bool EnterpriseDeviceMgrProxy::IsAdminEnabled(AppExecFwk::ElementName &admin, in EDMLOGD("EnterpriseDeviceMgrProxy::IsAdminEnabled"); sptr remote = GetRemoteObject(); if (!remote) { - return ERR_EDM_SERVICE_NOT_READY; + return EdmReturnErrCode::SYSTEM_ABNORMALLY; } MessageParcel data; MessageParcel reply; diff --git a/interfaces/kits/enterprise_admin_extension/enterprise_admin_extension_ability.js b/interfaces/kits/enterprise_admin_extension/enterprise_admin_extension_ability.js index 655dddc68..0d59bd6df 100644 --- a/interfaces/kits/enterprise_admin_extension/enterprise_admin_extension_ability.js +++ b/interfaces/kits/enterprise_admin_extension/enterprise_admin_extension_ability.js @@ -20,6 +20,12 @@ class EnterpriseAdminExtensionAbility { onAdminDisabled() { console.log('onAdminDisabled'); } + onBundleAdded(bundleName) { + console.log('EnterpriseAdminExtensionAbility->OnBundleAdded:' + bundleName); + } + onBundleRemoved(bundleName) { + console.log('EnterpriseAdminExtensionAbility->OnBundleRemoved:' + bundleName); + } } export default EnterpriseAdminExtensionAbility \ No newline at end of file diff --git a/interfaces/kits/include/enterprise_device_manager_addon.h b/interfaces/kits/include/enterprise_device_manager_addon.h index 701dfabdb..e4fbfffbb 100644 --- a/interfaces/kits/include/enterprise_device_manager_addon.h +++ b/interfaces/kits/include/enterprise_device_manager_addon.h @@ -17,6 +17,7 @@ #define INTERFACES_KITS_INCLUDE_ENTERPRISE_DEVICE_MANAGER_ADDON_H #include "admin_type.h" +#include "managed_event.h" #include "device_settings_manager.h" #include "edm_errors.h" #include "element_name.h" @@ -89,10 +90,10 @@ struct AsyncGetDeviceSettingsManagerCallbackInfo : AsyncCallbackInfo { napi_ref callback = 0; }; -class EdmReturnErrCode { -public: - static const int32_t PARAM_ERROR = 15200401; - static const int32_t PERMISSION_DENIED = 15200201; +struct AsyncSubscribeManagedEventCallbackInfo : AsyncCallbackInfo { + OHOS::AppExecFwk::ElementName elementName; + std::vector managedEvent; + bool subscribe = true; }; class EnterpriseDeviceManagerAddon { @@ -115,6 +116,8 @@ public: static std::string GetStringFromNAPI(napi_env env, napi_value value); static napi_value GetDeviceSettingsManager(napi_env env, napi_callback_info info); static napi_value SetDateTime(napi_env env, napi_callback_info info); + static napi_value SubscribeManagedEvent(napi_env env, napi_callback_info info); + static napi_value UnsubscribeManagedEvent(napi_env env, napi_callback_info info); static void NativeEnableAdmin(napi_env env, void *data); static void NativeDisableSuperAdmin(napi_env env, void *data); @@ -124,32 +127,42 @@ public: static void NativeIsSuperAdmin(napi_env env, void *data); static void NativeIsAdminEnabled(napi_env env, void *data); static void NativeSetDateTime(napi_env env, void *data); + static void NativeSubscribeManagedEvent(napi_env env, void *data); + static void NativeVoidCallbackComplete(napi_env env, napi_status status, void *data); static void NativeBoolCallbackComplete(napi_env env, napi_status status, void *data); static void NativeGetEnterpriseInfoComplete(napi_env env, napi_status status, void *data); static void ConvertEnterpriseInfo(napi_env env, napi_value objEntInfo, EntInfo &entInfo); static bool ParseEnterpriseInfo(napi_env env, EntInfo &enterpriseInfo, napi_value args); + static bool ParseManagedEvent(napi_env env, std::vector &managedEvent, napi_value args); static napi_value ParseString(napi_env env, std::string ¶m, napi_value args); - static napi_value CreateErrorMessage(napi_env env, ErrCode errorCode, std::string errMessage); static bool ParseElementName(napi_env env, OHOS::AppExecFwk::ElementName &elementName, napi_value args); static napi_value ParseStringArray(napi_env env, std::vector &hapFiles, napi_value args); static bool MatchValueType(napi_env env, napi_value value, napi_valuetype targetType); static void CreateAdminTypeObject(napi_env env, napi_value value); - static napi_value CreateUndefined(napi_env env); + static void CreateManagedEventObject(napi_env env, napi_value value); static napi_value ParseInt(napi_env env, int32_t ¶m, napi_value args); static napi_value ParseLong(napi_env env, int64_t ¶m, napi_value args); static napi_value DeviceSettingsManagerConstructor(napi_env env, napi_callback_info info); - private: - static napi_value ThrowNapiError(napi_env env, ErrCode errCode, const char* errMessage); + static napi_value CreateError(napi_env env, const ErrCode errorCode); + static napi_value CreateError(napi_env env, const int32_t errorCode, std::string errMessage); static std::pair GetMessageFromReturncode(ErrCode returnCode); static bool checkEnableAdminParamType(napi_env env, size_t argc, napi_value* argv, bool &hasCallback, bool &hasUserId); static bool checkAdminWithUserIdParamType(napi_env env, size_t argc, napi_value* argv, bool &hasCallback, bool &hasUserId); - static std::map> errMessageMap; + static napi_value SubscribeManagedEvent(napi_env env, napi_callback_info info, bool subscribe); + inline napi_value AssertAndThrowError(napi_env env, const bool assertion, const napi_value error) + { + if (!assertion) { + napi_throw(env, CreateError(env, EdmReturnErrCode::PARAM_ERROR, errMessage)); + } + return nullptr; + } + static std::map errMessageMap; static std::shared_ptr proxy_; static std::shared_ptr deviceSettingsManager_; }; diff --git a/interfaces/kits/src/enterprise_device_manager_addon.cpp b/interfaces/kits/src/enterprise_device_manager_addon.cpp index cba5fc94d..831395e31 100644 --- a/interfaces/kits/src/enterprise_device_manager_addon.cpp +++ b/interfaces/kits/src/enterprise_device_manager_addon.cpp @@ -24,9 +24,6 @@ using namespace OHOS::EDM; namespace { -constexpr int32_t NAPI_TYPE_NOMAL = 0; -constexpr int32_t NAPI_TYPE_SUPER = 1; - constexpr int32_t ARR_INDEX_ZERO = 0; constexpr int32_t ARR_INDEX_ONE = 1; constexpr int32_t ARR_INDEX_TWO = 2; @@ -45,16 +42,40 @@ constexpr int32_t NAPI_RETURN_ZERO = 0; constexpr int32_t NAPI_RETURN_ONE = 1; } -std::map> EnterpriseDeviceManagerAddon::errMessageMap = { +std::map EnterpriseDeviceManagerAddon::errMessageMap = { + { + EdmReturnErrCode::PERMISSION_DENIED, "the application does not have permission to call this function." + }, + { + EdmReturnErrCode::SYSTEM_ABNORMALLY, "the system ability work abnormally." + }, + { + EdmReturnErrCode::ENABLE_ADMIN_FAILED, "failed to activate the administrator application of the device." + }, { - ERR_EDM_PERMISSION_ERROR, std::make_pair(EdmReturnErrCode::PERMISSION_DENIED, "permission denied") + EdmReturnErrCode::COMPONENT_INVALID, "the administrator ability component is invalid." }, { - ERR_EDM_BMS_ERROR, std::make_pair(EdmReturnErrCode::PARAM_ERROR, "application basic info query invalid") + EdmReturnErrCode::ADMIN_INACTIVE, "the application is not a administrator of the device." }, { - ERR_EDM_ADD_ADMIN_FAILED, std::make_pair(EdmReturnErrCode::PARAM_ERROR, - "some conditions of enable admin are violated") + EdmReturnErrCode::DISABLE_ADMIN_FAILED, "the application is not a administrator of the device." + }, + { + EdmReturnErrCode::UID_INVALID, "the specified user ID is invalid." + }, + { + EdmReturnErrCode::INTERFACE_UNSUPPORTED, "the specified interface is not supported." + }, + { + EdmReturnErrCode::PARAM_ERROR, "invalid input parameter." + }, + { + EdmReturnErrCode::ADMIN_EDM_PERMISSION_DENIED, + "the administrator application does not have permission to manage the device." + }, + { + EdmReturnErrCode::MANAGED_EVENTS_INVALID, "the specified managed event is invalid." } }; @@ -113,7 +134,7 @@ napi_value EnterpriseDeviceManagerAddon::EnableAdmin(napi_env env, napi_callback napi_create_reference(env, argv[argc - 1], NAPI_RETURN_ONE, &asyncCallbackInfo->callback); } napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, "EnableAdmin", - NativeEnableAdmin, NativeBoolCallbackComplete); + NativeEnableAdmin, NativeVoidCallbackComplete); callbackPtr.release(); return asyncWorkReturn; } @@ -139,7 +160,7 @@ std::pair EnterpriseDeviceManagerAddon::GetMessageFromRetu { auto iter = errMessageMap.find(returnCode); if (iter != errMessageMap.end()) { - return iter->second; + return std::make_pair(returnCode, iter->second); } else { return std::make_pair(EdmReturnErrCode::PARAM_ERROR, "some thing wrong happend"); } @@ -186,9 +207,10 @@ bool EnterpriseDeviceManagerAddon::checkEnableAdminParamType(napi_env env, size_ MatchValueType(env, argv[ARR_INDEX_FOUR], napi_function); } -napi_value EnterpriseDeviceManagerAddon::ThrowNapiError(napi_env env, ErrCode errCode, const char* errMessage) +napi_value EnterpriseDeviceManagerAddon::ThrowNapiError(napi_env env, const ErrCode errCode, + const std::string errMessage) { - napi_throw_error(env, std::to_string(errCode).c_str(), errMessage); + napi_throw(env, CreateError(env, errCode, errMessage)); return nullptr; } @@ -201,30 +223,26 @@ void EnterpriseDeviceManagerAddon::NativeBoolCallbackComplete(napi_env env, napi AsyncCallbackInfo *asyncCallbackInfo = static_cast(data); if (asyncCallbackInfo->deferred != nullptr) { EDMLOGD("asyncCallbackInfo->deferred != nullptr"); - napi_value result = nullptr; if (asyncCallbackInfo->ret == ERR_OK) { EDMLOGD("asyncCallbackInfo->boolRet = %{public}d", asyncCallbackInfo->boolRet); + napi_value result = nullptr; napi_get_boolean(env, asyncCallbackInfo->boolRet, &result); napi_resolve_deferred(env, asyncCallbackInfo->deferred, result); } else { - std::string errTip = GetMessageFromReturncode(asyncCallbackInfo->ret).second; - napi_reject_deferred(env, asyncCallbackInfo->deferred, - CreateErrorMessage(env, GetMessageFromReturncode(asyncCallbackInfo->ret).first, errTip)); + napi_reject_deferred(env, asyncCallbackInfo->deferred, CreateError(env, asyncCallbackInfo->ret)); } } else { napi_value callbackValue[ARGS_SIZE_TWO] = { 0 }; if (asyncCallbackInfo->ret == ERR_OK) { - callbackValue[ARR_INDEX_ZERO] = CreateUndefined(env); + napi_get_null(env, &callbackValue[ARR_INDEX_ZERO]); EDMLOGD("asyncCallbackInfo->boolRet = %{public}d", asyncCallbackInfo->boolRet); napi_get_boolean(env, asyncCallbackInfo->boolRet, &callbackValue[ARR_INDEX_ONE]); } else { EDMLOGD("asyncCallbackInfo->first = %{public}u, second = %{public}s ", GetMessageFromReturncode(asyncCallbackInfo->ret).first, GetMessageFromReturncode(asyncCallbackInfo->ret).second.c_str()); - callbackValue[ARR_INDEX_ZERO] = CreateErrorMessage(env, - GetMessageFromReturncode(asyncCallbackInfo->ret).first, - GetMessageFromReturncode(asyncCallbackInfo->ret).second); - callbackValue[ARR_INDEX_ONE] = CreateUndefined(env); + callbackValue[ARR_INDEX_ZERO] = CreateError(env, asyncCallbackInfo->ret); + napi_get_null(env, &callbackValue[ARR_INDEX_ONE]); } napi_value callback = nullptr; napi_value result = nullptr; @@ -236,6 +254,38 @@ void EnterpriseDeviceManagerAddon::NativeBoolCallbackComplete(napi_env env, napi delete asyncCallbackInfo; } +void EnterpriseDeviceManagerAddon::NativeVoidCallbackComplete(napi_env env, napi_status status, void *data) +{ + if (data == nullptr) { + EDMLOGE("data is nullptr"); + return; + } + AsyncCallbackInfo *asyncCallbackInfo = static_cast(data); + napi_value error = nullptr; + if (asyncCallbackInfo->callback == nullptr) { + EDMLOGD("asyncCallbackInfo->deferred != nullptr"); + if (asyncCallbackInfo->ret == ERR_OK) { + napi_get_null(env, &error); + napi_resolve_deferred(env, asyncCallbackInfo->deferred, error); + } else { + napi_reject_deferred(env, asyncCallbackInfo->deferred, CreateError(env, asyncCallbackInfo->ret)); + } + } else { + if (asyncCallbackInfo->ret == ERR_OK) { + napi_get_null(env, &error); + } else { + error = CreateError(env, asyncCallbackInfo->ret); + } + napi_value callback = nullptr; + napi_value result = nullptr; + napi_get_reference_value(env, asyncCallbackInfo->callback, &callback); + napi_call_function(env, nullptr, callback, ARGS_SIZE_ONE, &error, &result); + napi_delete_reference(env, asyncCallbackInfo->callback); + } + napi_delete_async_work(env, asyncCallbackInfo->asyncWork); + delete asyncCallbackInfo; +} + bool EnterpriseDeviceManagerAddon::checkAdminWithUserIdParamType(napi_env env, size_t argc, napi_value* argv, bool &hasCallback, bool &hasUserId) { @@ -312,7 +362,7 @@ napi_value EnterpriseDeviceManagerAddon::DisableAdmin(napi_env env, napi_callbac napi_create_reference(env, argv[argc - 1], NAPI_RETURN_ONE, &asyncCallbackInfo->callback); } napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, "DisableAdmin", NativeDisableAdmin, - NativeBoolCallbackComplete); + NativeVoidCallbackComplete); callbackPtr.release(); return asyncWorkReturn; } @@ -359,7 +409,7 @@ napi_value EnterpriseDeviceManagerAddon::DisableSuperAdmin(napi_env env, napi_ca EDMLOGD("DisableSuperAdmin: asyncCallbackInfo->elementName.bundlename %{public}s", asyncCallbackInfo->bundleName.c_str()); napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, "DisableSuperAdmin", NativeDisableSuperAdmin, - NativeBoolCallbackComplete); + NativeVoidCallbackComplete); callbackPtr.release(); return asyncWorkReturn; } @@ -504,7 +554,7 @@ napi_value EnterpriseDeviceManagerAddon::SetEnterpriseInfo(napi_env env, napi_ca } napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, "SetEnterpriseInfo", NativeSetEnterpriseInfo, - NativeBoolCallbackComplete); + NativeVoidCallbackComplete); callbackPtr.release(); return asyncWorkReturn; } @@ -543,7 +593,7 @@ napi_value EnterpriseDeviceManagerAddon::SetDateTime(napi_env env, napi_callback } napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, "SetDateTime", - NativeSetDateTime, NativeBoolCallbackComplete); + NativeSetDateTime, NativeVoidCallbackComplete); callbackPtr.release(); return asyncWorkReturn; } @@ -561,10 +611,8 @@ void EnterpriseDeviceManagerAddon::NativeSetDateTime(napi_env env, void *data) EDMLOGE("can not get DeviceSettingsManager"); return; } - bool success = deviceSettingsManager_->SetDateTime(asyncCallbackInfo->elementName, asyncCallbackInfo->time); + deviceSettingsManager_->SetDateTime(asyncCallbackInfo->elementName, asyncCallbackInfo->time); asyncCallbackInfo->ret = ERR_OK; - asyncCallbackInfo->boolRet = success; - EDMLOGD("NativeSetDateTime asyncCallbackInfo->boolRet %{public}d", asyncCallbackInfo->boolRet); } void EnterpriseDeviceManagerAddon::NativeSetEnterpriseInfo(napi_env env, void *data) @@ -694,11 +742,72 @@ void EnterpriseDeviceManagerAddon::NativeIsAdminEnabled(napi_env env, void *data asyncCallbackInfo->boolRet = proxy_->IsAdminEnabled(asyncCallbackInfo->elementName, asyncCallbackInfo->userId); } -napi_value EnterpriseDeviceManagerAddon::CreateUndefined(napi_env env) +napi_value EnterpriseDeviceManagerAddon::SubscribeManagedEvent(napi_env env, napi_callback_info info) { - napi_value result = nullptr; - napi_get_undefined(env, &result); - return result; + EDMLOGI("SubscribeManagedEvent called"); + return SubscribeManagedEvent(env, info, true); +} + +napi_value EnterpriseDeviceManagerAddon::UnsubscribeManagedEvent(napi_env env, napi_callback_info info) +{ + EDMLOGI("UnsubscribeManagedEvent called"); + return SubscribeManagedEvent(env, info, false); +} + +napi_value EnterpriseDeviceManagerAddon::SubscribeManagedEvent(napi_env env, napi_callback_info info, bool subscribe) +{ + size_t argc = ARGS_SIZE_THREE; + napi_value argv[ARGS_SIZE_THREE] = {nullptr}; + napi_value thisArg = nullptr; + void *data = nullptr; + NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data)); + NAPI_ASSERT(env, argc >= ARGS_SIZE_TWO, "parameter count error"); + bool matchFlag = + MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object) && + MatchValueType(env, argv[ARR_INDEX_ONE], napi_object); + if (argc == ARGS_SIZE_THREE) { + matchFlag = matchFlag && MatchValueType(env, argv[ARR_INDEX_TWO], napi_function); + } + NAPI_ASSERT(env, matchFlag, "parameter type error"); + auto asyncCallbackInfo = new (std::nothrow) AsyncSubscribeManagedEventCallbackInfo(); + if (asyncCallbackInfo == nullptr) { + return nullptr; + } + std::unique_ptr callbackPtr {asyncCallbackInfo}; + bool ret = ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]); + NAPI_ASSERT(env, ret, "element name param error"); + ret = ParseManagedEvent(env, asyncCallbackInfo->managedEvent, argv[ARR_INDEX_ONE]); + NAPI_ASSERT(env, ret, "managed event param error"); + if (argc == ARGS_SIZE_THREE) { + napi_create_reference(env, argv[ARR_INDEX_TWO], NAPI_RETURN_ONE, &asyncCallbackInfo->callback); + } + asyncCallbackInfo->subscribe = subscribe; + napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, "SubscribeManagedEvent", NativeSubscribeManagedEvent, + NativeVoidCallbackComplete); + callbackPtr.release(); + return asyncWorkReturn; +} + +void EnterpriseDeviceManagerAddon::NativeSubscribeManagedEvent(napi_env env, void *data) +{ + EDMLOGI("NAPI_NativeSubscribeManagedEvent called"); + if (data == nullptr) { + EDMLOGE("data is nullptr"); + return; + } + AsyncSubscribeManagedEventCallbackInfo *asyncCallbakInfo = static_cast(data); + auto proxy_ = EnterpriseDeviceMgrProxy::GetInstance(); + if (proxy_ == nullptr) { + EDMLOGE("can not get EnterpriseDeviceMgrProxy"); + return; + } + if (asyncCallbakInfo->subscribe) { + asyncCallbakInfo->ret = proxy_->SubscribeManagedEvent(asyncCallbakInfo->elementName, + asyncCallbakInfo->managedEvent); + } else { + asyncCallbakInfo->ret = proxy_->UnsubscribeManagedEvent(asyncCallbakInfo->elementName, + asyncCallbakInfo->managedEvent); + } } bool EnterpriseDeviceManagerAddon::MatchValueType(napi_env env, napi_value value, napi_valuetype targetType) @@ -717,7 +826,8 @@ napi_value EnterpriseDeviceManagerAddon::HandleAsyncWork(napi_env env, AsyncCall } else { napi_get_undefined(env, &result); } - napi_value resource = CreateUndefined(env); + napi_value resource = nullptr; + napi_get_undefined(env, &resource); napi_value resourceName = nullptr; napi_create_string_utf8(env, workName.data(), NAPI_AUTO_LENGTH, &resourceName); napi_create_async_work(env, resource, resourceName, execute, complete, @@ -726,14 +836,20 @@ napi_value EnterpriseDeviceManagerAddon::HandleAsyncWork(napi_env env, AsyncCall return result; } -napi_value EnterpriseDeviceManagerAddon::CreateErrorMessage(napi_env env, ErrCode errorCode, std::string errMessage) +napi_value EnterpriseDeviceManagerAddon::CreateError(napi_env env, ErrCode errorCode) +{ + return CreateError(env, GetMessageFromReturncode(errorCode).first, + GetMessageFromReturncode(errorCode).second); +} + +napi_value EnterpriseDeviceManagerAddon::CreateError(napi_env env, const int32_t errorCode, std::string errMessage) { napi_value result = nullptr; napi_value message = nullptr; napi_value errorCodeStr = nullptr; - napi_create_string_utf8(env, static_cast(errMessage.data()), errMessage.size(), &message); napi_create_string_utf8(env, static_cast(std::to_string(errorCode).data()), std::to_string(errorCode).size(), &errorCodeStr); + napi_create_string_utf8(env, static_cast(errMessage.data()), errMessage.size(), &message); napi_create_error(env, errorCodeStr, message, &result); return result; } @@ -838,6 +954,27 @@ bool EnterpriseDeviceManagerAddon::ParseElementName(napi_env env, AppExecFwk::El return true; } +bool EnterpriseDeviceManagerAddon::ParseManagedEvent(napi_env env, std::vector &managedEvent, napi_value args) +{ + napi_status status; + uint32_t len; + status = napi_get_array_length(env, args, &len); + if (status != napi_ok) { + return false; + } + for (uint32_t i = 0; i < len; i++) { + napi_value event; + status = napi_get_element(env, args, i, &event); + if (status != napi_ok) { + return false; + } + uint32_t value = 0; + napi_get_value_uint32(env, event, &value); + managedEvent.push_back(value); + } + return true; +} + std::string EnterpriseDeviceManagerAddon::GetStringFromNAPI(napi_env env, napi_value value) { std::string result; @@ -859,13 +996,23 @@ std::string EnterpriseDeviceManagerAddon::GetStringFromNAPI(napi_env env, napi_v void EnterpriseDeviceManagerAddon::CreateAdminTypeObject(napi_env env, napi_value value) { napi_value nNomal; - NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, NAPI_TYPE_NOMAL, &nNomal)); + NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, AdminType::NORMAL, &nNomal)); NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "ADMIN_TYPE_NORMAL", nNomal)); napi_value nSuper; - NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, NAPI_TYPE_SUPER, &nSuper)); + NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, AdminType::ENT, &nSuper)); NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "ADMIN_TYPE_SUPER", nSuper)); } +void EnterpriseDeviceManagerAddon::CreateManagedEventObject(napi_env env, napi_value value) +{ + napi_value nBundleAdded; + NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, ManagedEvent::BUNDLE_ADDED, &nBundleAdded)); + NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "MANAGED_EVENT_BUNDLE_ADDED", nBundleAdded)); + napi_value nBundleRemoved; + NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, ManagedEvent::BUNDLE_REMOVED, &nBundleRemoved)); + NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "MANAGED_EVENT_BUNDLE_REMOVED", nBundleRemoved)); +} + napi_value EnterpriseDeviceManagerAddon::ParseString(napi_env env, std::string ¶m, napi_value args) { napi_status status; @@ -888,9 +1035,6 @@ napi_value EnterpriseDeviceManagerAddon::DeviceSettingsManagerConstructor(napi_e return jsthis; } -/** - * Promise and async callback - */ napi_value EnterpriseDeviceManagerAddon::GetDeviceSettingsManager(napi_env env, napi_callback_info info) { EDMLOGI("GetDeviceSettingsManager called"); @@ -898,7 +1042,10 @@ napi_value EnterpriseDeviceManagerAddon::GetDeviceSettingsManager(napi_env env, napi_value argv[ARGS_SIZE_ONE] = {nullptr}; NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL)); EDMLOGD("GetDeviceSettingsManager argc = [%{public}zu]", argc); - + NAPI_ASSERT(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "parameter type error"); + if (argc == ARGS_SIZE_ONE) { + NAPI_ASSERT(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "parameter type error"); + } AsyncGetDeviceSettingsManagerCallbackInfo *asyncCallbackInfo = new (std::nothrow) AsyncGetDeviceSettingsManagerCallbackInfo { .env = env, @@ -931,7 +1078,7 @@ napi_value EnterpriseDeviceManagerAddon::GetDeviceSettingsManager(napi_env env, napi_get_reference_value(env, g_classDeviceSettingsManager, &m_classDeviceSettingsManager); napi_get_undefined(env, &undefined); napi_new_instance(env, m_classDeviceSettingsManager, 0, nullptr, &result[ARR_INDEX_ONE]); - result[ARR_INDEX_ZERO] = CreateUndefined(env); + napi_get_null(env, &result[ARR_INDEX_ZERO]); napi_get_reference_value(env, asyncCallbackInfo->callback, &callback); napi_call_function(env, undefined, callback, ARGS_SIZE_TWO, &result[ARR_INDEX_ZERO], &callResult); if (asyncCallbackInfo->callback != nullptr) { @@ -983,6 +1130,10 @@ napi_value EnterpriseDeviceManagerAddon::Init(napi_env env, napi_value exports) NAPI_CALL(env, napi_create_object(env, &nAdminType)); CreateAdminTypeObject(env, nAdminType); + napi_value nManagedEvent = nullptr; + NAPI_CALL(env, napi_create_object(env, &nManagedEvent)); + CreateManagedEventObject(env, nManagedEvent); + napi_property_descriptor property[] = { DECLARE_NAPI_FUNCTION("enableAdmin", EnableAdmin), DECLARE_NAPI_FUNCTION("disableAdmin", DisableAdmin), @@ -992,8 +1143,11 @@ napi_value EnterpriseDeviceManagerAddon::Init(napi_env env, napi_value exports) DECLARE_NAPI_FUNCTION("setEnterpriseInfo", SetEnterpriseInfo), DECLARE_NAPI_FUNCTION("isSuperAdmin", IsSuperAdmin), DECLARE_NAPI_FUNCTION("getDeviceSettingsManager", GetDeviceSettingsManager), + DECLARE_NAPI_FUNCTION("subscribeManagedEvent", SubscribeManagedEvent), + DECLARE_NAPI_FUNCTION("unsubscribeManagedEvent", UnsubscribeManagedEvent), DECLARE_NAPI_PROPERTY("AdminType", nAdminType), + DECLARE_NAPI_PROPERTY("ManagedEvent", nManagedEvent), }; NAPI_CALL(env, napi_define_properties(env, exports, sizeof(property) / sizeof(property[0]), property)); diff --git a/services/edm/include/admin.h b/services/edm/include/admin.h index 74f7efcd3..a09402f2f 100644 --- a/services/edm/include/admin.h +++ b/services/edm/include/admin.h @@ -23,6 +23,7 @@ #include "edm_errors.h" #include "ent_info.h" #include "parcel_macro.h" +#include "managed_event.h" namespace OHOS { namespace EDM { @@ -32,6 +33,7 @@ struct AdminInfo { std::string className_; EntInfo entInfo_; std::vector permission_; + std::vector managedEvents_; }; class Admin { diff --git a/services/edm/include/admin_manager.h b/services/edm/include/admin_manager.h index ffc094e05..efbbb308c 100644 --- a/services/edm/include/admin_manager.h +++ b/services/edm/include/admin_manager.h @@ -32,6 +32,7 @@ public: static std::shared_ptr GetInstance(); ErrCode GetReqPermission(const std::vector &permissions, std::vector &edmPermissions); bool GetAdminByUserId(int32_t userId, std::vector> &userAdmin); + void GetAdminBySubscribeEvent(ManagedEvent event, std::unordered_map>> &subscribeAdmins); std::shared_ptr GetAdminByPkgName(const std::string &packageName, int32_t userId); ErrCode DeleteAdmin(const std::string &packageName, int32_t userId); ErrCode UpdateAdmin(AppExecFwk::ExtensionAbilityInfo &abilityInfo, const std::vector &permissions, @@ -47,6 +48,8 @@ public: std::vector &permissions, int32_t userId); ErrCode GetEntInfo(const std::string &packageName, EntInfo &entInfo, int32_t userId); ErrCode SetEntInfo(const std::string &packageName, EntInfo &entInfo, int32_t userId); + ErrCode SaveSubscribeEvents(std::vector &events, std::shared_ptr &admin, int32_t userId); + ErrCode RemoveSubscribeEvents(std::vector &events, std::shared_ptr &admin, int32_t userId); virtual ~AdminManager(); private: diff --git a/services/edm/include/enterprise_admin_conn_manager.h b/services/edm/include/enterprise_admin_conn_manager.h index 851a32676..58c980a9b 100644 --- a/services/edm/include/enterprise_admin_conn_manager.h +++ b/services/edm/include/enterprise_admin_conn_manager.h @@ -30,8 +30,7 @@ namespace OHOS { namespace EDM { class EnterpriseAdminConnManager : public DelayedSingleton { public: - bool ConnectAbility(const std::string& bundleName, const std::string& abilityName, uint32_t code, - int32_t userId); + bool ConnectAbility(sptr& connection); void Clear(); private: diff --git a/services/edm/include/enterprise_admin_connection.h b/services/edm/include/enterprise_admin_connection.h index 8940aaa4b..7791f8600 100644 --- a/services/edm/include/enterprise_admin_connection.h +++ b/services/edm/include/enterprise_admin_connection.h @@ -24,6 +24,11 @@ namespace EDM { class EnterpriseAdminConnection : public AAFwk::AbilityConnectionStub { public: explicit EnterpriseAdminConnection(uint32_t code); + + EnterpriseAdminConnection(AAFwk::Want want, uint32_t code, uint32_t userId) + :want_(want) + ,code_(code) + ,userId_(userId) {} virtual ~EnterpriseAdminConnection() override; @@ -44,9 +49,19 @@ public: * @param resultCode, Returns ERR_OK on success, others on failure. */ void OnAbilityDisconnectDone(const AppExecFwk::ElementName& element, int32_t resultCode) override; -private: - uint32_t code_{0}; + void SetBundleName(std::string bundleName); + + std::string GetBundleName(); + + AAFwk::Want GetWant(); + + uint32_t GetUserId(); +private: + AAFwk::Want want_; + uint32_t code_; + uint32_t userId_; + std::string bundleName_{""}; sptr proxy_{nullptr}; }; } // namespace EDM diff --git a/services/edm/include/enterprise_admin_proxy.h b/services/edm/include/enterprise_admin_proxy.h index a5346e3fd..f7895090b 100644 --- a/services/edm/include/enterprise_admin_proxy.h +++ b/services/edm/include/enterprise_admin_proxy.h @@ -38,8 +38,18 @@ public: * @brief The OnAdminDisabled callback. */ void OnAdminDisabled() override; + + /** + * @brief The OnBundleAdded callback. + */ + void OnBundleAdded(const std::string &bundleName) override; + + /** + * @brief The OnBundleRemoved callback. + */ + void OnBundleRemoved(const std::string &bundleName) override; private: - void SendRequest(uint32_t code); + void SendRequest(uint32_t code, MessageParcel &data); }; } // namespace EDM } // namespace OHOS diff --git a/services/edm/include/enterprise_device_mgr_ability.h b/services/edm/include/enterprise_device_mgr_ability.h index 504db8537..e1c3ec7fa 100644 --- a/services/edm/include/enterprise_device_mgr_ability.h +++ b/services/edm/include/enterprise_device_mgr_ability.h @@ -25,6 +25,7 @@ #include "plugin_manager.h" #include "policy_manager.h" #include "system_ability.h" +#include "enterprise_admin_proxy.h" namespace OHOS { namespace EDM { @@ -32,6 +33,7 @@ class EnterpriseDeviceMgrAbility : public SystemAbility, public EnterpriseDevice DECLARE_SYSTEM_ABILITY(EnterpriseDeviceMgrAbility); public: + using CommonEventCallbackFunc = void (EnterpriseDeviceMgrAbility::*)(const EventFwk::CommonEventData &data); EnterpriseDeviceMgrAbility(); DISALLOW_COPY_AND_MOVE(EnterpriseDeviceMgrAbility); ~EnterpriseDeviceMgrAbility(); @@ -46,9 +48,16 @@ public: ErrCode GetEnabledAdmin(AdminType type, std::vector &enabledAdminList) override; ErrCode GetEnterpriseInfo(AppExecFwk::ElementName &admin, MessageParcel &reply) override; ErrCode SetEnterpriseInfo(AppExecFwk::ElementName &admin, EntInfo &entInfo) override; - void OnUserRemoved(int userIdToRemove); + ErrCode SubscribeManagedEvent(AppExecFwk::ElementName &admin, std::vector &events) override; + ErrCode UnsubscribeManagedEvent(AppExecFwk::ElementName &admin, std::vector &events) override; + void OnCommonEventUserRemoved(const EventFwk::CommonEventData &data); + void OnCommonEventPackageAdded(const EventFwk::CommonEventData &data); + void OnCommonEventPackageRemoved(const EventFwk::CommonEventData &data); + void OnCommonEventPackageAddedOrRemoved(const EventFwk::CommonEventData &data, ManagedEvent event); bool IsSuperAdmin(std::string &bundleName) override; bool IsAdminEnabled(AppExecFwk::ElementName &admin, int32_t userId) override; + std::map commonEventFuncMap_; + static std::map managedEventMap; protected: void OnStart() override; @@ -59,6 +68,7 @@ protected: private: bool IsHdc(); + void AddCommonEventFuncMap(); ErrCode CheckCallingUid(std::string &bundleName); ErrCode RemoveAdminItem(std::string adminName, std::string policyName, std::string policyValue); ErrCode RemoveAdmin(const std::string &adminName, int32_t userId); @@ -67,6 +77,7 @@ private: int32_t GetCurrentUserId(); ErrCode UpdateDeviceAdmin(AppExecFwk::ElementName &admin); ErrCode VerifyEnableAdminCondition(AppExecFwk::ElementName &admin, AdminType type, int32_t userId); + ErrCode SubscribeManagedEvent(AppExecFwk::ElementName &admin, std::vector &events, bool subscribe); bool VerifyCallingPermission(const std::string &permissionName); sptr GetBundleMgr(); std::shared_ptr CreateEnterpriseDeviceEventSubscriber( diff --git a/services/edm/include/enterprise_device_mgr_stub.h b/services/edm/include/enterprise_device_mgr_stub.h index 3e8a9663a..69d594c29 100644 --- a/services/edm/include/enterprise_device_mgr_stub.h +++ b/services/edm/include/enterprise_device_mgr_stub.h @@ -44,6 +44,9 @@ private: ErrCode SetEnterpriseInfoInner(MessageParcel &data, MessageParcel &reply); ErrCode IsSuperAdminInner(MessageParcel &data, MessageParcel &reply); ErrCode IsAdminEnabledInner(MessageParcel &data, MessageParcel &reply); + ErrCode SubscribeManagedEventInner(MessageParcel &data, MessageParcel &reply); + ErrCode UnsubscribeManagedEventInner(MessageParcel &data, MessageParcel &reply); + ErrCode SubscribeManagedEventInner(MessageParcel &data, MessageParcel &reply, bool subscribe); }; } // namespace EDM } // namespace OHOS diff --git a/services/edm/src/admin_manager.cpp b/services/edm/src/admin_manager.cpp index ab1830eac..1158fa15c 100644 --- a/services/edm/src/admin_manager.cpp +++ b/services/edm/src/admin_manager.cpp @@ -75,6 +75,22 @@ bool AdminManager::GetAdminByUserId(int32_t userId, std::vector>> &subscribeAdmins) +{ + for (auto adminItem : admins_) { + std::vector> subAdmin; + for (auto &it : adminItem.second) { + std::vector events = it->adminInfo_.managedEvents_; + if (std::find(events.begin(),events.end(), event) != events.end()) { + subAdmin.push_back(it); + } + } + if (subAdmin.size() > 0) { + subscribeAdmins[adminItem.first] = subAdmin; + } + } +} + ErrCode AdminManager::SetAdminValue(AppExecFwk::ExtensionAbilityInfo &abilityInfo, EntInfo &entInfo, AdminType role, std::vector &permissions, int32_t userId) { @@ -297,6 +313,40 @@ ErrCode AdminManager::SetEntInfo(const std::string &packageName, EntInfo &entInf return ERR_EDM_UNKNOWN_ADMIN; } +ErrCode AdminManager::SaveSubscribeEvents(std::vector &events, std::shared_ptr &admin, int32_t userId) +{ + size_t eventsNumber = admin->adminInfo_.managedEvents_.size(); + for (auto &event : events) { + std::vector managedEvents = admin->adminInfo_.managedEvents_; + ManagedEvent subEvent = static_cast(event); + if (std::find(managedEvents.begin(), managedEvents.end(), subEvent) == managedEvents.end()) { + admin->adminInfo_.managedEvents_.push_back(subEvent); + } + } + if (admin->adminInfo_.managedEvents_.size() > eventsNumber) { + SaveAdmin(userId); + } + return ERR_OK; +} + +ErrCode AdminManager::RemoveSubscribeEvents(std::vector &events, std::shared_ptr &admin, int32_t userId) +{ + size_t eventsNumber = admin->adminInfo_.managedEvents_.size(); + for (auto &event : events) { + auto iter = admin->adminInfo_.managedEvents_.begin(); + while (iter != admin->adminInfo_.managedEvents_.end()) { + if (*iter == event) { + admin->adminInfo_.managedEvents_.erase(iter); + } else { + ++iter; + } + } + } + if (admin->adminInfo_.managedEvents_.size() < eventsNumber) { + SaveAdmin(userId); + } + return ERR_OK; +} // init void AdminManager::Init() { @@ -329,10 +379,14 @@ void AdminManager::ReadJsonAdminType(Json::Value &admin, enabledAdmin->adminInfo_.adminType_ = static_cast(admin["adminType"].asUInt()); enabledAdmin->adminInfo_.entInfo_.enterpriseName = admin["enterpriseInfo"]["enterpriseName"].asString(); // object enabledAdmin->adminInfo_.entInfo_.description = admin["enterpriseInfo"]["declaration"].asString(); - unsigned int adminSize = admin["permission"].size(); - for (unsigned int i = 0; i < adminSize; i++) { + uint32_t adminSize = admin["permission"].size(); + for (uint32_t i = 0; i < adminSize; i++) { enabledAdmin->adminInfo_.permission_.push_back(admin["permission"][i].asString()); // array } + uint32_t enevtsSize = admin["subscribeEvents"].size(); + for (uint32_t i = 0; i < enevtsSize; i++) { + enabledAdmin->adminInfo_.managedEvents_.push_back(static_cast(admin["subscribeEvents"][i].asUInt())); + } // read admin and store it in vector container adminVector.push_back(enabledAdmin); @@ -404,6 +458,7 @@ void AdminManager::WriteJsonAdminType(std::shared_ptr &enabledAdmin, Json { Json::Value entTree; Json::Value permissionTree; + Json::Value eventsTree; tree["name"] = enabledAdmin->adminInfo_.packageName_ + "/" + enabledAdmin->adminInfo_.className_; tree["adminType"] = enabledAdmin->adminInfo_.adminType_; @@ -416,6 +471,11 @@ void AdminManager::WriteJsonAdminType(std::shared_ptr &enabledAdmin, Json permissionTree.append(it); } tree["permission"] = permissionTree; + + for (auto &it : enabledAdmin->adminInfo_.managedEvents_) { + enevtsTree.append(it); + } + tree["subscribeEvents"] = enevtsTree; } void AdminManager::WriteJsonAdmin(const std::string &filePath, int32_t userId) diff --git a/services/edm/src/enterprise_admin_conn_manager.cpp b/services/edm/src/enterprise_admin_conn_manager.cpp index 5aaa4ae4c..5d6bf66ad 100644 --- a/services/edm/src/enterprise_admin_conn_manager.cpp +++ b/services/edm/src/enterprise_admin_conn_manager.cpp @@ -27,10 +27,9 @@ using namespace OHOS::AAFwk; namespace OHOS { namespace EDM { -bool EnterpriseAdminConnManager::ConnectAbility(const std::string& bundleName, const std::string& abilityName, - uint32_t code, int32_t userId) +bool EnterpriseAdminConnManager::ConnectAbility(sptr& connection) { - EDMLOGI("enter, target bundle = %{public}s", bundleName.c_str()); + EDMLOGI("enter, bundle status changed of = %{public}s", connection->GetBundleName().c_str()); std::lock_guard lock(mutex_); if (!GetAbilityMgrProxy()) { @@ -38,10 +37,7 @@ bool EnterpriseAdminConnManager::ConnectAbility(const std::string& bundleName, c return -1; } - sptr connection(new (std::nothrow) EnterpriseAdminConnection(code)); - Want want; - want.SetElementName(bundleName, abilityName); - int32_t ret = abilityMgr_->ConnectAbility(want, connection, nullptr, userId); + int32_t ret = abilityMgr_->ConnectAbility(connection->GetWant(), connection, nullptr, connection->GetUserId()); EDMLOGI("ConnectAbility over."); if (ret != ERR_OK) { EDMLOGE("connect failed"); diff --git a/services/edm/src/enterprise_admin_connection.cpp b/services/edm/src/enterprise_admin_connection.cpp index 8455f90da..6502a4ee2 100644 --- a/services/edm/src/enterprise_admin_connection.cpp +++ b/services/edm/src/enterprise_admin_connection.cpp @@ -34,6 +34,12 @@ void EnterpriseAdminConnection::OnAbilityConnectDone( case IEnterpriseAdmin::COMMAND_ON_ADMIN_DISABLED: proxy_->OnAdminDisabled(); break; + case IEnterpriseAdmin::COMMAND_ON_BUNDLE_ADDED: + proxy_->OnBundleAdded(GetBundleName()); + break; + case IEnterpriseAdmin::COMMAND_ON_BUNDLE_REMOVED: + proxy_->OnBundleRemoved(GetBundleName()); + break; default: return; } @@ -44,5 +50,23 @@ void EnterpriseAdminConnection::OnAbilityDisconnectDone(const AppExecFwk::Elemen { HILOG_INFO("EnterpriseAdminConnection OnAbilityDisconnectDone"); } + +void EnterpriseAdminConnection::SetBundleName(std::string bundleName) +{ + bundleName_ = bundleName; +} +std::string EnterpriseAdminConnection::GetBundleName() +{ + return bundleName_; +} +AAFwk::Want EnterpriseAdminConnection::GetWant() +{ + return want_; +} + +uint32_t EnterpriseAdminConnection::GetUserId() +{ + return userId_; +} } // namespace EDM } // namespace OHOS diff --git a/services/edm/src/enterprise_admin_proxy.cpp b/services/edm/src/enterprise_admin_proxy.cpp index d43a54907..22f21e019 100644 --- a/services/edm/src/enterprise_admin_proxy.cpp +++ b/services/edm/src/enterprise_admin_proxy.cpp @@ -20,25 +20,54 @@ namespace OHOS { namespace EDM { void EnterpriseAdminProxy::OnAdminEnabled() { + MessageParcel data; + if (!data.WriteInterfaceToken(GetDescriptor())) { + EDMLOGE("EnterpriseAdminProxy::%{public}s write descriptor failed!", __func__); + return; + } EDMLOGI("EnterpriseAdminProxy proxy OnAdminEnabled"); - SendRequest(COMMAND_ON_ADMIN_ENABLED); + SendRequest(COMMAND_ON_ADMIN_ENABLED, data); } void EnterpriseAdminProxy::OnAdminDisabled() { + MessageParcel data; + if (!data.WriteInterfaceToken(GetDescriptor())) { + EDMLOGE("EnterpriseAdminProxy::%{public}s write descriptor failed!", __func__); + return; + } EDMLOGI("EnterpriseAdminProxy proxy OnAdminDisabled"); - SendRequest(COMMAND_ON_ADMIN_DISABLED); + SendRequest(COMMAND_ON_ADMIN_DISABLED, data); } -void EnterpriseAdminProxy::SendRequest(uint32_t code) +void EnterpriseAdminProxy::OnBundleAdded(const std::string &bundleName) { MessageParcel data; - MessageParcel reply; - MessageOption option(MessageOption::TF_SYNC); if (!data.WriteInterfaceToken(GetDescriptor())) { EDMLOGE("EnterpriseAdminProxy::%{public}s write descriptor failed!", __func__); return; } + data.WriteString(bundleName); + EDMLOGI("EnterpriseAdminProxy proxy OnBundleAdded"); + SendRequest(COMMAND_ON_BUNDLE_ADDED, data); +} + +void EnterpriseAdminProxy::OnBundleRemoved(const std::string &bundleName) +{ + MessageParcel data; + if (!data.WriteInterfaceToken(GetDescriptor())) { + EDMLOGE("EnterpriseAdminProxy::%{public}s write descriptor failed!", __func__); + return; + } + data.WriteString(bundleName); + EDMLOGI("EnterpriseAdminProxy proxy OnBundleRemoved"); + SendRequest(COMMAND_ON_BUNDLE_REMOVED, data); +} + +void EnterpriseAdminProxy::SendRequest( uint32_t code, MessageParcel &data) +{ + MessageParcel reply; + MessageOption option(MessageOption::TF_SYNC); Remote()->SendRequest(code, data, reply, option); } } // namespace EDM diff --git a/services/edm/src/enterprise_device_mgr_ability.cpp b/services/edm/src/enterprise_device_mgr_ability.cpp index 0cdfd6222..dc2edc0a7 100644 --- a/services/edm/src/enterprise_device_mgr_ability.cpp +++ b/services/edm/src/enterprise_device_mgr_ability.cpp @@ -44,6 +44,27 @@ std::mutex EnterpriseDeviceMgrAbility::mutexLock_; sptr EnterpriseDeviceMgrAbility::instance_; constexpr int32_t DEFAULT_USER_ID = 100; + +std::map EnterpriseDeviceMgrAbility::managedEventMap = { + { + ManagedEvent::BUNDLE_ADDED, IEnterpriseAdmin::COMMAND_ON_BUNDLE_ADDED + }, + { + ManagedEvent::BUNDLE_REMOVED, IEnterpriseAdmin::COMMAND_ON_BUNDLE_REMOVED + } +}; + + +void EnterpriseDeviceMgrAbility::AddCommonEventFuncMap() +{ + commonEventFuncMap_[EventFwk::CommonEventSupport::COMMON_EVENT_USER_REMOVED] = + &EnterpriseDeviceMgrAbility::OnCommonEventUserRemoved; + commonEventFuncMap_[EventFwk::CommonEventSupport::COMMON_EVENT_PACKAGE_ADDED] = + &EnterpriseDeviceMgrAbility::OnCommonEventPackageAdded; + commonEventFuncMap_[EventFwk::CommonEventSupport::COMMON_EVENT_PACKAGE_REMOVED] = + &EnterpriseDeviceMgrAbility::OnCommonEventPackageRemoved; +} + const std::string PERMISSION_MANAGE_ENTERPRISE_DEVICE_ADMIN = "ohos.permission.MANAGE_ENTERPRISE_DEVICE_ADMIN"; EnterpriseDeviceEventSubscriber::EnterpriseDeviceEventSubscriber( const EventFwk::CommonEventSubscribeInfo &subscribeInfo, @@ -52,12 +73,12 @@ EnterpriseDeviceEventSubscriber::EnterpriseDeviceEventSubscriber( void EnterpriseDeviceEventSubscriber::OnReceiveEvent(const EventFwk::CommonEventData &data) { const std::string action = data.GetWant().GetAction(); - EDMLOGI("OnReceiveEvent get action: %{public}s", action.c_str()); - if (action == EventFwk::CommonEventSupport::COMMON_EVENT_USER_REMOVED) { - int userIdToRemove = data.GetCode() ; - if (userIdToRemove != 0) { - EDMLOGI("OnReceiveEvent user removed userid : %{public}d", userIdToRemove); - listener_.OnUserRemoved(userIdToRemove); + EDMLOGI("EDM OnReceiveEvent get action: %{public}s", action.c_str()); + auto func = listener_.commonEventFuncMap_.find(action); + if (func != listener_.commonEventFuncMap_.end()) { + auto commonEventFunc = func->second; + if (commonEventFunc != nullptr) { + return (listener_.*commonEventFunc)(data); } } else { EDMLOGW("OnReceiveEvent action is invalid"); @@ -68,26 +89,67 @@ std::shared_ptr EnterpriseDeviceMgrAbility::Cre EnterpriseDeviceMgrAbility &listener) { EventFwk::MatchingSkills skill = EventFwk::MatchingSkills(); - skill.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_USER_REMOVED); + AddCommonEventFuncMap(); + for (auto &item : commonEventFuncMap_) { + skill.AddEvent(item.first); + EDMLOGI("CreateEnterpriseDeviceEventSubscriber AddEvent: %{public}s", item.first.c_str()); + } EventFwk::CommonEventSubscribeInfo info(skill); return std::make_shared(info, listener); } -void EnterpriseDeviceMgrAbility::OnUserRemoved(int userIdToRemove) +void EnterpriseDeviceMgrAbility::OnCommonEventUserRemoved(const EventFwk::CommonEventData &data) { - EDMLOGI("OnUserRemoved"); + int userIdToRemove = data.GetCode(); + if (userIdToRemove == 0) { + return; + } + EDMLOGI("OnCommonEventUserRemoved"); // include super admin, need to be removed std::vector> userAdmin; adminMgr_->GetAdminByUserId(userIdToRemove, userAdmin); for (auto &item : userAdmin) { ErrCode ret = RemoveAdmin(item->adminInfo_.packageName_, userIdToRemove); if (ret != ERR_OK) { - EDMLOGW("EnterpriseDeviceMgrAbility::OnUserRemoved ret = %{public}d; packagename = %{public}s", ret, + EDMLOGW("EnterpriseDeviceMgrAbility::OnCommonEventUserRemoved ret = %{public}d; packagename = %{public}s", ret, item->adminInfo_.packageName_.c_str()); } } } +void EnterpriseDeviceMgrAbility::OnCommonEventPackageAdded(const EventFwk::CommonEventData &data) +{ + EDMLOGI("OnCommonEventPackageAdded"); + OnCommonEventPackageAddedOrRemoved(data, ManagedEvent::BUNDLE_ADDED); +} + +void EnterpriseDeviceMgrAbility::OnCommonEventPackageRemoved(const EventFwk::CommonEventData &data) +{ + EDMLOGI("OnCommonEventPackageRemoved"); + OnCommonEventPackageAddedOrRemoved(data, ManagedEvent::BUNDLE_REMOVED); +} + +void EnterpriseDeviceMgrAbility::OnCommonEventPackageAddedOrRemoved(const EventFwk::CommonEventData &data, ManagedEvent event) +{ + std::unordered_map>> subAdmins; + adminMgr_->GetAdminBySubscribeEvent(event, subAdmins); + if (subAdmins.empty()) { + EDMLOGW("Get subscriber by common event failed."); + return; + } + std::string bundleName = data.GetWant().GetElement().GetBundleName(); + AAFwk::Want want; + for (auto subAdmin : subAdmins) { + for (auto &it : subAdmin.second) { + want.SetElementName(it->adminInfo_.packageName_, it->adminInfo_.className_); + sptr connection(new (std::nothrow) EnterpriseAdminConnection(want, + managedEventMap[event], subAdmin.first)); + connection->SetBundleName(bundleName); + DelayedSingleton::GetInstance()->ConnectAbility(connection); + } + } +} + sptr EnterpriseDeviceMgrAbility::GetInstance() { if (instance_ == nullptr) { @@ -302,50 +364,50 @@ ErrCode EnterpriseDeviceMgrAbility::EnableAdmin(AppExecFwk::ElementName &admin, std::lock_guard autoLock(mutexLock_); if (!IsHdc() && !VerifyCallingPermission(PERMISSION_MANAGE_ENTERPRISE_DEVICE_ADMIN)) { EDMLOGW("EnterpriseDeviceMgrAbility::EnableAdmin check permission failed"); - return ERR_EDM_PERMISSION_ERROR; + return EdmReturnErrCode::PERMISSION_DENIED; } std::vector abilityInfo; auto bundleManager = GetBundleMgr(); if (!bundleManager) { EDMLOGW("can not get iBundleMgr"); - return ERR_EDM_BMS_ERROR; + return EdmReturnErrCode::SYSTEM_ABNORMALLY; } AAFwk::Want want; want.SetElement(admin); if (!bundleManager->QueryExtensionAbilityInfos(want, AppExecFwk::ExtensionAbilityType::ENTERPRISE_ADMIN, AppExecFwk::ExtensionAbilityInfoFlag::GET_EXTENSION_INFO_WITH_PERMISSION, userId, abilityInfo)) { EDMLOGW("EnableAdmin: QueryExtensionAbilityInfos failed"); - return ERR_EDM_BMS_ERROR; + return EdmReturnErrCode::COMPONENT_INVALID; } - ErrCode ret = VerifyEnableAdminCondition(admin, type, userId); - if (FAILED(ret)) { + if (FAILED(VerifyEnableAdminCondition(admin, type, userId))) { EDMLOGW("EnableAdmin: VerifyEnableAdminCondition failed."); - return ERR_EDM_ADD_ADMIN_FAILED; + return EdmReturnErrCode::ENABLE_ADMIN_FAILED; } /* Get all request and registered permissions */ std::vector permissionList; - ret = GetAllPermissionsByAdmin(admin.GetBundleName(), permissionList, userId); - if (FAILED(ret)) { - EDMLOGW("EnableAdmin: GetAllPermissionsByAdmin failed %{public}d", ret); - return ERR_EDM_ADD_ADMIN_FAILED; + if (FAILED(GetAllPermissionsByAdmin(admin.GetBundleName(), permissionList, userId))) { + EDMLOGW("EnableAdmin: GetAllPermissionsByAdmin failed"); + return EdmReturnErrCode::COMPONENT_INVALID; } /* Filter permissions with AdminType, such as NORMAL can't request super permission */ - ret = adminMgr_->GetGrantedPermission(abilityInfo.at(0), permissionList, type); - if (ret != ERR_OK) { - EDMLOGW("EnableAdmin: GetGrantedPermission failed %{public}d", ret); + if (FAILED(adminMgr_->GetGrantedPermission(abilityInfo.at(0), permissionList, type))) { + EDMLOGW("EnableAdmin: GetGrantedPermission failed"); // permission verify, should throw exception if failed - return ERR_EDM_ADD_ADMIN_FAILED; + return EdmReturnErrCode::ENABLE_ADMIN_FAILED; + } + if (FAILED(adminMgr_->SetAdminValue(abilityInfo.at(0), entInfo, type, permissionList, userId))) { + EDMLOGE("EnableAdmin: SetAdminValue failed."); + return EdmReturnErrCode::ENABLE_ADMIN_FAILED; } - EDMLOGI("EnableAdmin: SetAdminValue success %{public}s, type:%{public}d", admin.GetBundleName().c_str(), static_cast(type)); - ret = adminMgr_->SetAdminValue(abilityInfo.at(0), entInfo, type, permissionList, userId); - if (ret == ERR_OK) { - DelayedSingleton::GetInstance()->ConnectAbility(admin.GetBundleName(), - admin.GetAbilityName(), IEnterpriseAdmin::COMMAND_ON_ADMIN_ENABLED, userId); - } - return ret; + AAFwk::Want connectWant; + connectWant.SetElementName(admin.GetBundleName(), admin.GetAbilityName()); + sptr connection(new (std::nothrow) EnterpriseAdminConnection(connectWant, + IEnterpriseAdmin::COMMAND_ON_ADMIN_ENABLED, userId)); + DelayedSingleton::GetInstance()->ConnectAbility(connection); + return ERR_OK; } ErrCode EnterpriseDeviceMgrAbility::RemoveAdminItem(std::string adminName, std::string policyName, @@ -413,24 +475,28 @@ ErrCode EnterpriseDeviceMgrAbility::DisableAdmin(AppExecFwk::ElementName &admin, std::lock_guard autoLock(mutexLock_); if (!IsHdc() && !VerifyCallingPermission(PERMISSION_MANAGE_ENTERPRISE_DEVICE_ADMIN)) { EDMLOGW("EnterpriseDeviceMgrAbility::DisableAdmin check permission failed"); - return ERR_EDM_PERMISSION_ERROR; + return EdmReturnErrCode::PERMISSION_DENIED; } std::shared_ptr adminPtr = adminMgr_->GetAdminByPkgName(admin.GetBundleName(), userId); if (adminPtr == nullptr) { - return ERR_EDM_DEL_ADMIN_FAILED; + return EdmReturnErrCode::ADMIN_INACTIVE; } if (adminPtr->adminInfo_.adminType_ != AdminType::NORMAL) { EDMLOGW("DisableAdmin: only remove normal admin."); - return ERR_EDM_PERMISSION_ERROR; + return EdmReturnErrCode::PERMISSION_DENIED; } - ErrCode ret = RemoveAdmin(admin.GetBundleName(), userId); - if (ret == ERR_OK) { - DelayedSingleton::GetInstance()->ConnectAbility(admin.GetBundleName(), - admin.GetAbilityName(), IEnterpriseAdmin::COMMAND_ON_ADMIN_DISABLED, userId); + if (FAILED(RemoveAdmin(admin.GetBundleName(), userId))) { + EDMLOGW("DisableAdmin: disable admin failed."); + return EdmReturnErrCode::DISABLE_ADMIN_FAILED; } - return ret; + AAFwk::Want want; + want.SetElementName(admin.GetBundleName(), admin.GetAbilityName()); + sptr connection(new (std::nothrow) EnterpriseAdminConnection(want, + IEnterpriseAdmin::COMMAND_ON_ADMIN_DISABLED, userId)); + DelayedSingleton::GetInstance()->ConnectAbility(connection); + return ERR_OK; } bool EnterpriseDeviceMgrAbility::IsHdc() @@ -467,25 +533,26 @@ ErrCode EnterpriseDeviceMgrAbility::DisableSuperAdmin(std::string &bundleName) std::lock_guard autoLock(mutexLock_); std::shared_ptr admin = adminMgr_->GetAdminByPkgName(bundleName, DEFAULT_USER_ID); if (admin == nullptr) { - return ERR_EDM_DEL_ADMIN_FAILED; + return EdmReturnErrCode::ADMIN_INACTIVE; } if (admin->adminInfo_.adminType_ != AdminType::ENT) { EDMLOGW("DisableSuperAdmin: only remove super admin."); - return ERR_EDM_PERMISSION_ERROR; + return EdmReturnErrCode::ADMIN_INACTIVE; } - int32_t checkRet = CheckCallingUid(admin->adminInfo_.packageName_); - if (checkRet != ERR_OK) { - EDMLOGW("DisableSuperAdmin: CheckCallingUid failed: %{public}d", checkRet); - return ERR_EDM_PERMISSION_ERROR; + if (FAILED(CheckCallingUid(admin->adminInfo_.packageName_))) { + EDMLOGW("DisableSuperAdmin: CheckCallingUid failed"); + return EdmReturnErrCode::PERMISSION_DENIED; } - - ErrCode ret = RemoveAdmin(bundleName, DEFAULT_USER_ID); - EDMLOGW("OnAdminDisabled: RemoveAdmin(bundleName, DEFAULT_USER_ID) %{public}d", ret); - if (ret == ERR_OK) { - DelayedSingleton::GetInstance()->ConnectAbility(admin->adminInfo_.packageName_, - admin->adminInfo_.className_, IEnterpriseAdmin::COMMAND_ON_ADMIN_DISABLED, DEFAULT_USER_ID); + if (FAILED(RemoveAdmin(bundleName, DEFAULT_USER_ID))) { + EDMLOGW("DisableSuperAdmin: RemoveAdmin(bundleName, DEFAULT_USER_ID) failed"); + return EdmReturnErrCode::DISABLE_ADMIN_FAILED; } - return ret; + AAFwk::Want want; + want.SetElementName(admin->adminInfo_.packageName_, admin->adminInfo_.className_); + sptr connection(new (std::nothrow) EnterpriseAdminConnection(want, + IEnterpriseAdmin::COMMAND_ON_ADMIN_DISABLED, DEFAULT_USER_ID)); + DelayedSingleton::GetInstance()->ConnectAbility(connection); + return ERR_OK; } bool EnterpriseDeviceMgrAbility::IsSuperAdmin(std::string &bundleName) @@ -528,27 +595,28 @@ ErrCode EnterpriseDeviceMgrAbility::HandleDevicePolicy(uint32_t code, AppExecFwk std::shared_ptr deviceAdmin = adminMgr_->GetAdminByPkgName(admin.GetBundleName(), GetCurrentUserId()); if (deviceAdmin == nullptr) { EDMLOGW("HandleDevicePolicy: get admin failed"); - return ERR_EDM_GET_ADMIN_MGR_FAILED; + return EdmReturnErrCode::ADMIN_INACTIVE; } std::shared_ptr plugin = pluginMgr_->GetPluginByFuncCode(code); if (plugin == nullptr) { EDMLOGW("HandleDevicePolicy: get plugin failed, code:%{public}d", code); - return ERR_EDM_GET_PLUGIN_MGR_FAILED; + return EdmReturnErrCode::INTERFACE_UNSUPPORTED; } EDMLOGD("HandleDevicePolicy: plugin info:%{public}d , %{public}s , %{public}s", plugin->GetCode(), plugin->GetPolicyName().c_str(), plugin->GetPermission().c_str()); if (!deviceAdmin->CheckPermission(plugin->GetPermission()) || !VerifyCallingPermission(plugin->GetPermission())) { EDMLOGW("HandleDevicePolicy: check permission failed"); - return ERR_EDM_PERMISSION_ERROR; + return EdmReturnErrCode::ADMIN_EDM_PERMISSION_DENIED; } std::lock_guard autoLock(mutexLock_); std::string policyName = plugin->GetPolicyName(); std::string policyValue = ""; policyMgr_->GetPolicy(admin.GetBundleName(), policyName, policyValue); bool isChanged = false; - if (plugin->OnHandlePolicy(code, data, policyValue, isChanged) != ERR_OK) { + ErrCode ret = plugin->OnHandlePolicy(code, data, policyValue, isChanged); + if (FAILED(ret)) { EDMLOGW("HandleDevicePolicy: OnHandlePolicy failed"); - return ERR_EDM_HANDLE_POLICY_FAILED; + return ret; } EDMLOGD("HandleDevicePolicy: isChanged:%{public}d, needSave:%{public}d, policyValue:%{public}s\n", isChanged, @@ -558,10 +626,10 @@ ErrCode EnterpriseDeviceMgrAbility::HandleDevicePolicy(uint32_t code, AppExecFwk std::string mergedPolicy = policyValue; bool isGlobalChanged = false; if (plugin->NeedSavePolicy() && isChanged) { - ErrCode res = plugin->MergePolicyData(admin.GetBundleName(), mergedPolicy); - if (res != ERR_OK) { - EDMLOGW("HandleDevicePolicy: MergePolicyData failed error:%{public}d", res); - return ERR_EDM_HANDLE_POLICY_FAILED; + ret = plugin->MergePolicyData(admin.GetBundleName(), mergedPolicy); + if (FAILED(ret)) { + EDMLOGW("HandleDevicePolicy: MergePolicyData failed error:%{public}d", ret); + return ret; } policyMgr_->SetPolicy(admin.GetBundleName(), policyName, policyValue, mergedPolicy); isGlobalChanged = (oldCombinePolicy != mergedPolicy); @@ -627,8 +695,8 @@ ErrCode EnterpriseDeviceMgrAbility::GetEnterpriseInfo(AppExecFwk::ElementName &a EntInfo entInfo; ErrCode code = adminMgr_->GetEntInfo(admin.GetBundleName(), entInfo, GetCurrentUserId()); if (code != ERR_OK) { - reply.WriteInt32(ERR_EDM_GET_ENTINFO_FAILED); - return ERR_EDM_GET_ENTINFO_FAILED; + reply.WriteInt32(EdmReturnErrCode::ADMIN_INACTIVE); + return EdmReturnErrCode::ADMIN_INACTIVE; } reply.WriteInt32(ERR_OK); reply.WriteParcelable(&entInfo); @@ -644,15 +712,59 @@ ErrCode EnterpriseDeviceMgrAbility::SetEnterpriseInfo(AppExecFwk::ElementName &a int32_t userId = GetCurrentUserId(); std::shared_ptr adminItem = adminMgr_->GetAdminByPkgName(admin.GetBundleName(), userId); if (adminItem == nullptr) { - return ERR_EDM_SET_ENTINFO_FAILED; + return EdmReturnErrCode::ADMIN_INACTIVE; } int32_t ret = CheckCallingUid(adminItem->adminInfo_.packageName_); if (ret != ERR_OK) { EDMLOGW("SetEnterpriseInfo: CheckCallingUid failed: %{public}d", ret); - return ERR_EDM_PERMISSION_ERROR; + return EdmReturnErrCode::PERMISSION_DENIED; } ErrCode code = adminMgr_->SetEntInfo(admin.GetBundleName(), entInfo, userId); - return (code != ERR_OK) ? ERR_EDM_SET_ENTINFO_FAILED : ERR_OK; + return (code != ERR_OK) ? EdmReturnErrCode::ADMIN_INACTIVE : ERR_OK; +} + +ErrCode EnterpriseDeviceMgrAbility::SubscribeManagedEvent(AppExecFwk::ElementName &admin, std::vector &events) +{ + return SubscribeManagedEvent(admin, events, true); +} + +ErrCode EnterpriseDeviceMgrAbility::UnsubscribeManagedEvent(AppExecFwk::ElementName &admin, std::vector &events) +{ + return SubscribeManagedEvent(admin, events, false); +} + +ErrCode EnterpriseDeviceMgrAbility::SubscribeManagedEvent(AppExecFwk::ElementName &admin, std::vector &events, bool subscribe) +{ + std::lock_guard autoLock(mutexLock_); + if (!VerifyCallingPermission(PERMISSION_MANAGE_ENTERPRISE_DEVICE_ADMIN)) { + EDMLOGW("SubscribeManagedEvent: check permission failed"); + return EdmReturnErrCode::PERMISSION_DENIED; + } + int32_t userId = GetCurrentUserId(); + std::shared_ptr adminItem = adminMgr_->GetAdminByPkgName(admin.GetBundleName(), userId); + if (adminItem == nullptr) { + return EdmReturnErrCode::ADMIN_INACTIVE; + } + int32_t ret = CheckCallingUid(adminItem->adminInfo_.packageName_); + if (ret != ERR_OK) { + EDMLOGW("SubscribeManagedEvent: CheckCallingUid failed: %{public}d", ret); + return EdmReturnErrCode::PERMISSION_DENIED; + } + auto iter = events.begin(); + while (iter != events.end()) { + if (managedEventMap.find(*iter) == managedEventMap.end()) { + EDMLOGW("SubscribeManagedEvent: managed event invalid"); + return EdmReturnErrCode::MANAGED_EVENTS_INVALID; + } + ++iter; + } + ErrCode code; + if (subscribe) { + code = adminMgr_->SaveSubscribeEvents(events, adminItem, userId); + } else { + code = adminMgr_->RemoveSubscribeEvents(events, adminItem, userId); + } + return (code != ERR_OK) ? EdmReturnErrCode::ADMIN_INACTIVE : ERR_OK; } } // namespace EDM } // namespace OHOS \ No newline at end of file diff --git a/services/edm/src/enterprise_device_mgr_stub.cpp b/services/edm/src/enterprise_device_mgr_stub.cpp index 88ed27274..742dc6179 100644 --- a/services/edm/src/enterprise_device_mgr_stub.cpp +++ b/services/edm/src/enterprise_device_mgr_stub.cpp @@ -43,6 +43,8 @@ void EnterpriseDeviceMgrStub::AddCallFuncMap() memberFuncMap_[SET_ENT_INFO] = &EnterpriseDeviceMgrStub::SetEnterpriseInfoInner; memberFuncMap_[IS_SUPER_ADMIN] = &EnterpriseDeviceMgrStub::IsSuperAdminInner; memberFuncMap_[IS_ADMIN_ENABLED] = &EnterpriseDeviceMgrStub::IsAdminEnabledInner; + memberFuncMap_[SUBSCRIBE_MANAGED_EVENT] = &EnterpriseDeviceMgrStub::SubscribeManagedEventInner; + memberFuncMap_[UNSUBSCRIBE_MANAGED_EVENT] = &EnterpriseDeviceMgrStub::UnsubscribeManagedEventInner; } int32_t EnterpriseDeviceMgrStub::OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, @@ -53,8 +55,8 @@ int32_t EnterpriseDeviceMgrStub::OnRemoteRequest(uint32_t code, MessageParcel &d EDMLOGI("EnterpriseDeviceMgrStub code %{public}u", code); if (descriptor != remoteDescriptor) { EDMLOGE("EnterpriseDeviceMgrStub code %{public}d client and service descriptors are inconsistent", code); - reply.WriteInt32(ERR_EDM_PARAM_ERROR); - return ERR_EDM_PARAM_ERROR; + reply.WriteInt32(EdmReturnErrCode::PARAM_ERROR); + return EdmReturnErrCode::PARAM_ERROR; } if (SERVICE_FLAG(code)) { auto func = memberFuncMap_.find(code); @@ -85,8 +87,8 @@ ErrCode EnterpriseDeviceMgrStub::EnableAdminInner(MessageParcel &data, MessagePa { std::unique_ptr admin(data.ReadParcelable()); if (!admin) { - reply.WriteInt32(ERR_EDM_PARAM_ERROR); - return ERR_EDM_PARAM_ERROR; + reply.WriteInt32(EdmReturnErrCode::PARAM_ERROR); + return EdmReturnErrCode::PARAM_ERROR; } EDMLOGD("EnableAdminInner bundleName:: %{public}s : abilityName : %{public}s ", admin->GetBundleName().c_str(), admin->GetAbilityName().c_str()); @@ -95,24 +97,19 @@ ErrCode EnterpriseDeviceMgrStub::EnableAdminInner(MessageParcel &data, MessagePa int32_t userId = data.ReadInt32(); ErrCode retCode = EnableAdmin(*admin, *entInfo, AdminType(type), userId); reply.WriteInt32(retCode); - return (retCode != ERR_OK) ? ERR_EDM_ADD_ADMIN_FAILED : ERR_OK; + return ERR_OK; } ErrCode EnterpriseDeviceMgrStub::DisableAdminInner(MessageParcel &data, MessageParcel &reply) { std::unique_ptr admin(data.ReadParcelable()); if (!admin) { - reply.WriteInt32(ERR_EDM_PARAM_ERROR); - return ERR_EDM_PARAM_ERROR; + reply.WriteInt32(EdmReturnErrCode::PARAM_ERROR); + return EdmReturnErrCode::PARAM_ERROR; } int32_t userId = data.ReadInt32(); ErrCode retCode = DisableAdmin(*admin, userId); - if (retCode != ERR_OK) { - EDMLOGW("DisableAdminInner failed: %{public}d", retCode); - reply.WriteInt32(ERR_EDM_DEL_ADMIN_FAILED); - return ERR_EDM_DEL_ADMIN_FAILED; - } - reply.WriteInt32(ERR_OK); + reply.WriteInt32(retCode); return ERR_OK; } @@ -121,11 +118,7 @@ ErrCode EnterpriseDeviceMgrStub::DisableSuperAdminInner(MessageParcel &data, Mes std::string bundleName = data.ReadString(); EDMLOGD("DisableSuperAdminInner bundleName:: %{public}s :", bundleName.c_str()); ErrCode retCode = DisableSuperAdmin(bundleName); - if (retCode != ERR_OK) { - reply.WriteInt32(ERR_EDM_DEL_SUPER_ADMIN_FAILED); - return ERR_EDM_DEL_SUPER_ADMIN_FAILED; - } - reply.WriteInt32(ERR_OK); + reply.WriteInt32(retCode); return retCode; } @@ -134,6 +127,7 @@ ErrCode EnterpriseDeviceMgrStub::HandleDevicePolicyInner(uint32_t code, MessageP std::unique_ptr admin(data.ReadParcelable()); if (!admin) { EDMLOGW("HandleDevicePolicyInner: ReadParcelable failed"); + reply.WriteInt32(EdmReturnErrCode::PARAM_ERROR); return ERR_EDM_PARAM_ERROR; } ErrCode errCode = HandleDevicePolicy(code, *admin, data); @@ -163,9 +157,9 @@ ErrCode EnterpriseDeviceMgrStub::GetEnabledAdminInner(MessageParcel &data, Messa EDMLOGD("EnterpriseDeviceMgrStub:GetEnabledAdmin"); uint32_t type = AdminType::UNKNOWN; if (!data.ReadUint32(type)) { - reply.WriteInt32(ERR_EDM_PARAM_ERROR); + reply.WriteInt32(EdmReturnErrCode::PARAM_ERROR); EDMLOGE("EnterpriseDeviceMgrStub:GetEnabledAdminInner read type fail %{public}u", type); - return ERR_EDM_PARAM_ERROR; + return EdmReturnErrCode::PARAM_ERROR; } std::vector enabledAdminList; ErrCode res = GetEnabledAdmin((AdminType)type, enabledAdminList); @@ -186,8 +180,8 @@ ErrCode EnterpriseDeviceMgrStub::GetEnterpriseInfoInner(MessageParcel &data, Mes EDMLOGD("EnterpriseDeviceMgrStub:GetEnterpriseInfoInner"); std::unique_ptr admin(data.ReadParcelable()); if (!admin) { - reply.WriteInt32(ERR_EDM_PARAM_ERROR); - return ERR_EDM_PARAM_ERROR; + reply.WriteInt32(EdmReturnErrCode::PARAM_ERROR); + return EdmReturnErrCode::PARAM_ERROR; } EDMLOGD("GetEnterpriseInfoInner bundleName:: %{public}s : abilityName : %{public}s ", admin->GetBundleName().c_str(), admin->GetAbilityName().c_str()); @@ -210,8 +204,8 @@ ErrCode EnterpriseDeviceMgrStub::IsAdminEnabledInner(MessageParcel &data, Messag EDMLOGD("EnterpriseDeviceMgrStub:IsAdminEnabled"); std::unique_ptr admin(data.ReadParcelable()); if (!admin) { - reply.WriteInt32(ERR_EDM_PARAM_ERROR); - return ERR_EDM_PARAM_ERROR; + reply.WriteInt32(EdmReturnErrCode::PARAM_ERROR); + return EdmReturnErrCode::PARAM_ERROR; } int32_t userId = data.ReadInt32(); bool ret = IsAdminEnabled(*admin, userId); @@ -224,18 +218,44 @@ ErrCode EnterpriseDeviceMgrStub::SetEnterpriseInfoInner(MessageParcel &data, Mes EDMLOGD("EnterpriseDeviceMgrStub:SetEnterpriseInfoInner"); std::unique_ptr admin(data.ReadParcelable()); if (!admin) { - reply.WriteInt32(ERR_EDM_PARAM_ERROR); - return ERR_EDM_PARAM_ERROR; + reply.WriteInt32(EdmReturnErrCode::PARAM_ERROR); + return EdmReturnErrCode::PARAM_ERROR; } std::unique_ptr entInfo(data.ReadParcelable()); - ErrCode code = SetEnterpriseInfo(*admin, *entInfo); - if (code != ERR_OK) { - EDMLOGW("EnterpriseDeviceMgrStub:SetEnterpriseInfoInner failed:%{public}d", code); - reply.WriteInt32(ERR_EDM_SET_ENTINFO_FAILED); - return code; - } - reply.WriteInt32(ERR_OK); + ErrCode ret = SetEnterpriseInfo(*admin, *entInfo); + reply.WriteInt32(ret); return ERR_OK; } + +ErrCode EnterpriseDeviceMgrStub::SubscribeManagedEventInner(MessageParcel &data, MessageParcel &reply) +{ + EDMLOGD("EnterpriseDeviceMgrStub:SubscribeManagedEventInner"); + return SubscribeManagedEventInner(data, reply, true); +} + +ErrCode EnterpriseDeviceMgrStub::UnsubscribeManagedEventInner(MessageParcel &data, MessageParcel &reply) +{ + EDMLOGD("EnterpriseDeviceMgrStub:UnsubscribeManagedEventInner"); + return SubscribeManagedEventInner(data, reply, false); +} + +ErrCode EnterpriseDeviceMgrStub::SubscribeManagedEventInner(MessageParcel &data, MessageParcel &reply, bool subscribe) +{ + std::unique_ptr admin(data.ReadParcelable()); + if (!admin) { + reply.WriteInt32(EdmReturnErrCode::PARAM_ERROR); + return EdmReturnErrCode::PARAM_ERROR; + } + std::vector events; + data.ReadUInt32Vector(&events); + ErrCode code; + if (subscribe) { + code = SubscribeManagedEvent(*admin, events); + } else { + code = UnsubscribeManagedEvent(*admin, events); + } + reply.WriteInt32(code); + return code; +} } // namespace EDM } // namespace OHOS \ No newline at end of file diff --git a/test/unittest/src/admin_manager_test.cpp b/test/unittest/src/admin_manager_test.cpp index e5861a919..2b7998b70 100644 --- a/test/unittest/src/admin_manager_test.cpp +++ b/test/unittest/src/admin_manager_test.cpp @@ -406,6 +406,50 @@ HWTEST_F(AdminManagerTest, TestIsSuperAdminExist, TestSize.Level1) adminMgr_->SetAdminValue(abilityInfo, entInfo, AdminType::NORMAL, permissions, DEFAULT_USER_ID); ASSERT_TRUE(!adminMgr_->IsSuperAdminExist()); } + +/** + * @tc.name: TestSaveSubscribeEvents + * @tc.desc: Test AdminManager::SaveSubscribeEvents function. + * @tc.type: FUNC + */ +HWTEST_F(AdminManagerTest, TestSaveSubscribeEvents, TestSize.Level1) +{ + std::vector events = {0, 1}; + std::string bundleName = "com.edm.test.demo"; + AppExecFwk::ExtensionAbilityInfo abilityInfo; + abilityInfo.bundleName = bundleName; + abilityInfo.name = "testDemo"; + EntInfo entInfo; + entInfo.enterpriseName = "company"; + entInfo.description = "technology company in wuhan"; + std::vector permissions = { "ohos.permission.EDM_TEST_PERMISSION" }; + + adminMgr_->SetAdminValue(abilityInfo, entInfo, AdminType::NORMAL, permissions, DEFAULT_USER_ID); + ErrCode ret = adminMgr_->SaveSubscribeEvents(events, bundleName, DEFAULT_USER_ID); + ASSERT_TRUE(ret == ERR_OK); +} + +/** + * @tc.name: TestRemoveSubscribeEvents + * @tc.desc: Test AdminManager::RemoveSubscribeEvents function. + * @tc.type: FUNC + */ +HWTEST_F(AdminManagerTest, TestRemoveSubscribeEvents, TestSize.Level1) +{ + std::vector events = {0, 1}; + std::string bundleName = "com.edm.test.demo"; + AppExecFwk::ExtensionAbilityInfo abilityInfo; + abilityInfo.bundleName = bundleName; + abilityInfo.name = "testDemo"; + EntInfo entInfo; + entInfo.enterpriseName = "company"; + entInfo.description = "technology company in wuhan"; + std::vector permissions = { "ohos.permission.EDM_TEST_PERMISSION" }; + + adminMgr_->SetAdminValue(abilityInfo, entInfo, AdminType::NORMAL, permissions, DEFAULT_USER_ID); + ErrCode ret = adminMgr_->RemoveSubscribeEvents(events, bundleName, DEFAULT_USER_ID); + ASSERT_TRUE(ret == ERR_OK); +} } // namespace TEST } // namespace EDM } // namespace OHOS \ No newline at end of file -- Gitee